From afc8c544872a6e9faa2c184ba32492fd5099f39a Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Thu, 18 May 2023 18:45:56 +0800
Subject: [PATCH 01/34] :sparkles: gc::extend uses std::nothrow

---
 CMakeLists.txt |  4 +---
 doc/vs.md      |  4 ++--
 nasal_gc.h     | 26 ++++++++++++++------------
 3 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 278dcd9..9fe5c8e 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -27,9 +27,7 @@ target_include_directories(nasock PRIVATE ${CMAKE_SOURCE_DIR})
 
 add_executable(nasal main.cpp)
 
-if(CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
-    message("Ignore linking dl lib")
-else()
+if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
     target_link_libraries(nasal dl)
 endif()
 
diff --git a/doc/vs.md b/doc/vs.md
index afcf8b3..b828435 100644
--- a/doc/vs.md
+++ b/doc/vs.md
@@ -2,9 +2,9 @@
 
 ## First | 首先
 
-We give a __CMakeLists.txt__ for you to create new VS project from it.
+We give a [__CMakeLists.txt__](../CMakeLists.txt) for you to create new VS project from it.
 
-我们为你提供了 __CMakeLists.txt__ 用于创建新的 VS 工程。
+我们为你提供了 [__CMakeLists.txt__](../CMakeLists.txt) 用于创建新的 VS 工程。
 
 If you are using this way, you will __not need__ to continue reading.
 
diff --git a/nasal_gc.h b/nasal_gc.h
index 271405a..baa673a 100644
--- a/nasal_gc.h
+++ b/nasal_gc.h
@@ -1,4 +1,6 @@
 #pragma once
+
+// avoid MSVC warnings
 #ifdef _MSC_VER
 #pragma warning (disable:4244)
 #pragma warning (disable:4267)
@@ -64,7 +66,7 @@ struct nas_vec;   // vector
 struct nas_hash;  // hashmap(dict)
 struct nas_func;  // function(lambda)
 struct nas_upval; // upvalue
-struct nas_obj;   // special objects
+struct nas_ghost; // objects
 struct nas_co;    // coroutine
 struct nas_val;   // nas_val includes gc-managed types
 
@@ -117,7 +119,7 @@ public:
     nas_hash&  hash();
     nas_func&  func();
     nas_upval& upval();
-    nas_obj&   obj ();
+    nas_ghost& obj ();
     nas_co&    co  ();
 };
 
@@ -261,7 +263,7 @@ public:
     }
 };
 
-struct nas_obj {
+struct nas_ghost {
 public:
     usize type;
     void* ptr;
@@ -270,13 +272,13 @@ private:
     ghost_register_table* ghost_type_table;
 
 public:
-    nas_obj(): type(0), ptr(nullptr), ghost_type_table(nullptr) {}
-    ~nas_obj() {clear();}
+    nas_ghost(): type(0), ptr(nullptr), ghost_type_table(nullptr) {}
+    ~nas_ghost() {clear();}
     void set(usize, void*, ghost_register_table*);
     void clear();
 
 public:
-    friend std::ostream& operator<<(std::ostream& out, nas_obj& ghost) {
+    friend std::ostream& operator<<(std::ostream& out, nas_ghost& ghost) {
         out<<"<object "<<ghost.ghost_type_table->get_ghost_name(ghost.type);
         out<<" at 0x"<<std::hex<<(u64)ghost.ptr<<std::dec<<">";
         return out;
@@ -313,7 +315,7 @@ struct nas_val {
         nas_hash*  hash;
         nas_func*  func;
         nas_upval* upval;
-        nas_obj*   obj;
+        nas_ghost* obj;
         nas_co*    co;
     } ptr;
 
@@ -419,13 +421,13 @@ void nas_func::clear() {
     keys.clear();
 }
 
-void nas_obj::set(usize t, void* p, ghost_register_table* table) {
+void nas_ghost::set(usize t, void* p, ghost_register_table* table) {
     type=t;
     ptr=p;
     ghost_type_table=table;
 }
 
-void nas_obj::clear() {
+void nas_ghost::clear() {
     if (!ptr) {
         return;
     }
@@ -459,7 +461,7 @@ nas_val::nas_val(u8 val_type) {
         case vm_hash: ptr.hash=new nas_hash;  break;
         case vm_func: ptr.func=new nas_func;  break;
         case vm_upval:ptr.upval=new nas_upval;break;
-        case vm_obj:  ptr.obj=new nas_obj;    break;
+        case vm_obj:  ptr.obj=new nas_ghost;  break;
         case vm_co:   ptr.co=new nas_co;      break;
     }
 }
@@ -561,7 +563,7 @@ nas_vec&   var::vec  () {return *val.gcobj->ptr.vec;  }
 nas_hash&  var::hash () {return *val.gcobj->ptr.hash; }
 nas_func&  var::func () {return *val.gcobj->ptr.func; }
 nas_upval& var::upval() {return *val.gcobj->ptr.upval;}
-nas_obj&   var::obj  () {return *val.gcobj->ptr.obj;  }
+nas_ghost& var::obj  () {return *val.gcobj->ptr.obj;  }
 nas_co&    var::co   () {return *val.gcobj->ptr.co;   }
 
 const var zero=var::num(0);
@@ -747,7 +749,7 @@ void gc::extend(u8 type) {
     size[index]+=incr[index];
 
     for(u32 i=0;i<incr[index];++i) {
-        nas_val* tmp=new nas_val(type);
+        nas_val* tmp=new(std::nothrow) nas_val(type);
 
         if (!tmp) {
             std::cerr<<"nasal_gc.h: gc::extend: ";

From 9bf4eacc62d077ed54d49beae6dbbcea46422c7d Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Mon, 5 Jun 2023 00:11:37 +0800
Subject: [PATCH 02/34] prepare to use new ast

---
 .github/workflows/c-cpp.yml |   2 +-
 ast/nasal_new_ast.cpp       |  19 ++++
 ast/nasal_new_ast.h         | 112 +++++++++++++++++++++++
 makefile                    |   5 +-
 nasal_dbg.h                 | 176 ++++++++++++++++++++++--------------
 nasal_gc.h                  |   6 +-
 test/life.nas               |   2 +-
 7 files changed, 250 insertions(+), 72 deletions(-)
 create mode 100644 ast/nasal_new_ast.cpp
 create mode 100644 ast/nasal_new_ast.h

diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml
index 419659b..db27e23 100644
--- a/.github/workflows/c-cpp.yml
+++ b/.github/workflows/c-cpp.yml
@@ -4,7 +4,7 @@ on:
   schedule:
    - cron: "0 16 * * *"
   push:
-    branches: [ master ]
+    branches: [ master,develop ]
   pull_request:
     branches: [ master ]
   workflow_dispatch:
diff --git a/ast/nasal_new_ast.cpp b/ast/nasal_new_ast.cpp
new file mode 100644
index 0000000..266ed2d
--- /dev/null
+++ b/ast/nasal_new_ast.cpp
@@ -0,0 +1,19 @@
+#include "nasal_new_ast.h"
+
+bool stmt::accept(ast_visitor* visitor) {
+    visitor->visit_stmt(this);
+    return true;
+}
+
+bool expr::accept(ast_visitor* visitor) {
+    visitor->visit_expr(this);
+    return true;
+}
+
+void ast_visitor::visit_stmt(stmt* node) {
+    node->accept(this);
+}
+
+void ast_visitor::visit_expr(expr* node) {
+    node->accept(this);
+}
\ No newline at end of file
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
new file mode 100644
index 0000000..154d901
--- /dev/null
+++ b/ast/nasal_new_ast.h
@@ -0,0 +1,112 @@
+#pragma once
+
+#include "nasal.h"
+#include "nasal_err.h"
+
+enum class ast_node_type:u32 {
+    ast_null=0,      // null node
+    ast_stmt,
+    ast_expr,
+    ast_root,        // mark the root node of ast
+    ast_block,       // expression block 
+    ast_file,        // used to store which file the sub-tree is on, only used in main block
+    ast_nil,         // nil keyword
+    ast_num,         // number, basic value type
+    ast_str,         // string, basic value type
+    ast_id,          // identifier
+    ast_bool,        // bools
+    ast_func,        // func keyword
+    ast_hash,        // hash, basic value type
+    ast_vec,         // vector, basic value type
+    ast_pair,        // pair of key and value in hashmap
+    ast_call,        // mark a sub-tree of calling an identifier
+    ast_callh,       // id.name
+    ast_callv,       // id[index]
+    ast_callf,       // id()
+    ast_subvec,      // id[index:index]
+    ast_params,      // mark a sub-tree of function parameters
+    ast_default,     // default parameter
+    ast_dynamic,     // dynamic parameter
+    ast_and,         // and keyword
+    ast_or,          // or keyword
+    ast_equal,       // =
+    ast_addeq,       // +=
+    ast_subeq,       // -=
+    ast_multeq,      // *=
+    ast_diveq,       // /=
+    ast_lnkeq,       // ~=
+    ast_btandeq,     // &=
+    ast_btoreq,      // |=
+    ast_btxoreq,     // ^=
+    ast_cmpeq,       // ==
+    ast_neq,         // !=
+    ast_less,        // <
+    ast_leq,         // <=
+    ast_grt,         // >
+    ast_geq,         // >=
+    ast_add,         // +
+    ast_sub,         // -
+    ast_mult,        // *
+    ast_div,         // /
+    ast_link,        // ~
+    ast_neg,         // unary -
+    ast_lnot,        // unary !
+    ast_bnot,        // unary ~ bitwise not
+    ast_bitor,       // bitwise or
+    ast_bitxor,      // bitwise xor
+    ast_bitand,      // bitwise and
+    ast_trino,       // ?:
+    ast_for,         // for keyword
+    ast_forindex,    // forindex keyword
+    ast_foreach,     // foreach keyword
+    ast_while,       // while
+    ast_iter,        // iterator, used in forindex/foreach
+    ast_cond,        // mark a sub-tree of conditional expression
+    ast_if,          // if keyword
+    ast_elsif,       // elsif keyword
+    ast_else,        // else keyword
+    ast_multi_id,    // multi identifiers sub-tree
+    ast_tuple,       // tuple, only used in multiple assignment
+    ast_def,         // definition
+    ast_multi_assign,// multi assignment sub-tree
+    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
+};
+
+class ast_visitor;
+
+class ast_node {
+private:
+    span nd_loc;
+    ast_node_type nd_type;
+public:
+    ast_node(const span& location,ast_node_type node_type):
+        nd_loc(location), nd_type(node_type) {}
+    ~ast_node() = default;
+    virtual bool accept(ast_visitor*) = 0;
+};
+
+class stmt:public ast_node {
+public:
+    stmt(const span& location,ast_node_type node_type):
+        ast_node(location, node_type) {}
+    ~stmt() = default;
+    virtual bool accept(ast_visitor*);
+};
+
+class expr:public ast_node {
+private:
+
+public:
+    expr(const span& location,ast_node_type node_type):
+        ast_node(location, node_type) {}
+    ~expr() = default;
+    virtual bool accept(ast_visitor*);
+};
+
+class ast_visitor {
+public:
+    virtual void visit_stmt(stmt*);
+    virtual void visit_expr(expr*);
+};
\ No newline at end of file
diff --git a/makefile b/makefile
index 6376f16..01e0999 100644
--- a/makefile
+++ b/makefile
@@ -18,11 +18,14 @@ SRC=\
 
 STD=c++14
 
-nasal:$(SRC)
+nasal:$(SRC) nasal_new_ast.o
 	$(CXX) -std=$(STD) -O3 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
 nasal.exe:$(SRC)
 	$(CXX) -std=$(STD) -O3 main.cpp -o nasal.exe -fno-exceptions -Wshadow -Wall -static
 
+nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp nasal.h
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
+
 stable-release:$(SRC)
 	$(CXX) -std=$(STD) -O2 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
 stable-release-mingw:$(SRC)
diff --git a/nasal_dbg.h b/nasal_dbg.h
index 495c505..a10fc42 100644
--- a/nasal_dbg.h
+++ b/nasal_dbg.h
@@ -4,9 +4,61 @@
 #include "nasal_err.h"
 #include "nasal_opcode.h"
 #include "nasal_vm.h"
+
+#include <cstring>
 #include <algorithm>
+#include <unordered_map>
 
 class dbg:public vm {
+private:
+    enum class dbg_cmd {
+        cmd_error,
+        cmd_help,
+        cmd_backtrace,
+        cmd_continue,
+        cmd_list_file,
+        cmd_global,
+        cmd_local,
+        cmd_upval,
+        cmd_register,
+        cmd_show_all,
+        cmd_next,
+        cmd_break_point,
+        cmd_exit
+    };
+
+private:
+    const std::unordered_map<string, dbg_cmd> command_table = {
+        {"h", dbg_cmd::cmd_help},
+        {"help", dbg_cmd::cmd_help},
+        {"bt", dbg_cmd::cmd_backtrace},
+        {"backtrace", dbg_cmd::cmd_backtrace},
+        {"c", dbg_cmd::cmd_continue},
+        {"continue", dbg_cmd::cmd_continue},
+        {"f", dbg_cmd::cmd_list_file},
+        {"file", dbg_cmd::cmd_list_file},
+        {"g", dbg_cmd::cmd_global},
+        {"global", dbg_cmd::cmd_global},
+        {"l", dbg_cmd::cmd_local},
+        {"local", dbg_cmd::cmd_local},
+        {"u", dbg_cmd::cmd_upval},
+        {"upval", dbg_cmd::cmd_upval},
+        {"r", dbg_cmd::cmd_register},
+        {"register", dbg_cmd::cmd_register},
+        {"a", dbg_cmd::cmd_show_all},
+        {"all", dbg_cmd::cmd_show_all},
+        {"n", dbg_cmd::cmd_next},
+        {"next", dbg_cmd::cmd_next},
+        {"bk", dbg_cmd::cmd_break_point},
+        {"break", dbg_cmd::cmd_break_point},
+        {"q", dbg_cmd::cmd_exit},
+        {"exit", dbg_cmd::cmd_exit}
+    };
+    dbg_cmd get_cmd_type(const string& cmd) const {
+        return command_table.count(cmd)?
+            command_table.at(cmd):dbg_cmd::cmd_error;
+    }
+
 private:
     bool  next;
     usize fsize;
@@ -15,11 +67,12 @@ private:
     error& src;
 
     std::vector<string> parse(const string&);
-    u16 fileindex(const string&);
+    u16 file_index(const string&) const;
     void err();
     void help();
-    void callsort(const u64*);
-    void stepinfo();
+    void list_file() const;
+    void call_sort(const u64*) const;
+    void step_info();
     void interact();
 public:
     dbg(error& err):
@@ -50,7 +103,7 @@ std::vector<string> dbg::parse(const string& cmd) {
     return res;
 }
 
-u16 dbg::fileindex(const string& filename) {
+u16 dbg::file_index(const string& filename) const {
     for(u16 i=0;i<fsize;++i) {
         if (filename==files[i]) {
             return i;
@@ -66,24 +119,30 @@ void dbg::err() {
 }
 
 void dbg::help() {
-    std::cout
+    std::clog
     <<"<option>\n"
-    <<"\th,   help      | get help\n"
-    <<"\tbt,  backtrace | get function call trace\n"
-    <<"\tc,   continue  | run program until break point or exit\n"
-    <<"\tf,   file      | see all the compiled files\n"
-    <<"\tg,   global    | see global values\n"
-    <<"\tl,   local     | see local values\n"
-    <<"\tu,   upval     | see upvalue\n"
-    <<"\tr,   register  | show vm register detail\n"
-    <<"\ta,   all       | show global,local and upvalue\n"
-    <<"\tn,   next      | execute next bytecode\n"
-    <<"\tq,   exit      | exit debugger\n"
+    <<"  h,   help      | get help\n"
+    <<"  bt,  backtrace | get function call trace\n"
+    <<"  c,   continue  | run program until break point or exit\n"
+    <<"  f,   file      | see all the compiled files\n"
+    <<"  g,   global    | see global values\n"
+    <<"  l,   local     | see local values\n"
+    <<"  u,   upval     | see upvalue\n"
+    <<"  r,   register  | show vm register detail\n"
+    <<"  a,   all       | show global,local and upvalue\n"
+    <<"  n,   next      | execute next bytecode\n"
+    <<"  q,   exit      | exit debugger\n"
     <<"<option> <filename> <line>\n"
-    <<"\tbk,  break     | set break point\n";
+    <<"  bk,  break     | set break point\n";
 }
 
-void dbg::callsort(const u64* arr) {
+void dbg::list_file() const {
+    for(usize i=0; i<fsize; ++i) {
+        std::clog<<"["<<i<<"] "<<files[i]<<"\n";
+    }
+}
+
+void dbg::call_sort(const u64* arr) const {
     typedef std::pair<u32,u64> op;
     std::vector<op> opcall;
     u64 total=0;
@@ -105,22 +164,22 @@ void dbg::callsort(const u64* arr) {
     std::clog<<" total  : "<<total<<'\n';
 }
 
-void dbg::stepinfo() {
+void dbg::step_info() {
     u32 line=bytecode[ctx.pc].line==0?0:bytecode[ctx.pc].line-1;
     u32 begin=(line>>3)==0?0:((line>>3)<<3);
     u32 end=(1+(line>>3))<<3;
     src.load(files[bytecode[ctx.pc].fidx]);
-    std::cout<<"\nsource code:\n";
+    std::clog<<"\nsource code:\n";
     for(u32 i=begin;i<end && i<src.size();++i) {
-        std::cout<<(i==line?back_white:reset)<<(i==line?"--> ":"    ")<<src[i]<<reset<<"\n";
+        std::clog<<(i==line?back_white:reset)<<(i==line?"--> ":"    ")<<src[i]<<reset<<"\n";
     }
 
     begin=(ctx.pc>>3)==0?0:((ctx.pc>>3)<<3);
     end=(1+(ctx.pc>>3))<<3;
     codestream::set(cnum, cstr, files);
-    std::cout<<"next bytecode:\n";
+    std::clog<<"next bytecode:\n";
     for(u32 i=begin;i<end && bytecode[i].op!=op_exit;++i) {
-        std::cout
+        std::clog
         <<(i==ctx.pc?back_white:reset)
         <<(i==ctx.pc?"--> ":"    ")
         <<codestream(bytecode[i], i)
@@ -130,65 +189,51 @@ void dbg::stepinfo() {
 }
 
 void dbg::interact() {
-    // special operand
+    // special operand, end execution
     if (bytecode[ctx.pc].op==op_exit) {
         return;
     }
     
-    if (
-        (bytecode[ctx.pc].fidx!=bk_fidx || bytecode[ctx.pc].line!=bk_line) && // break point
-        !next // next step
-    ) {
+    if ((bytecode[ctx.pc].fidx!=bk_fidx ||
+        bytecode[ctx.pc].line!=bk_line) && // break point
+        !next) {// next step
         return;
     }
 
     next=false;
     string cmd;
-    stepinfo();
+    step_info();
     while(true) {
-        std::cout<<">> ";
+        std::clog<<">> ";
         std::getline(std::cin, cmd);
         auto res=parse(cmd);
         if (res.size()==0) {
-            stepinfo();
+            step_info();
         } else if (res.size()==1) {
-            if (res[0]=="h" || res[0]=="help") {
-                help();
-            } else if (res[0]=="bt" || res[0]=="backtrace") {
-                traceback();
-            } else if (res[0]=="c" || res[0]=="continue") {
-                return;
-            } else if (res[0]=="f" || res[0]=="file") {
-                for(usize i=0;i<fsize;++i) {
-                    std::cout<<"["<<i<<"] "<<files[i]<<"\n";
-                }
-            } else if (res[0]=="g" || res[0]=="global") {
-                gstate();
-            } else if (res[0]=="l" || res[0]=="local") {
-                lstate();
-            } else if (res[0]=="u" || res[0]=="upval") {
-                ustate();
-            } else if (res[0]=="r" || res[0]=="register") {
-                reginfo();
-            } else if (res[0]=="a" || res[0]=="all") {
-                detail();
-            } else if (res[0]=="n" || res[0]=="next") {
-                next=true;
-                return;
-            } else if (res[0]=="q" || res[0]=="exit")
-                std::exit(0);
-            else {
-                err();
+            switch(get_cmd_type(res[0])) {
+                case dbg_cmd::cmd_help: help(); break;
+                case dbg_cmd::cmd_backtrace: traceback(); break;
+                case dbg_cmd::cmd_continue: return;
+                case dbg_cmd::cmd_list_file: list_file(); break;
+                case dbg_cmd::cmd_global: gstate(); break;
+                case dbg_cmd::cmd_local: lstate(); break;
+                case dbg_cmd::cmd_upval: ustate(); break;
+                case dbg_cmd::cmd_register: reginfo(); break;
+                case dbg_cmd::cmd_show_all: detail(); break;
+                case dbg_cmd::cmd_next: next=true; return;
+                case dbg_cmd::cmd_exit: std::exit(0);
+                default: err(); break;
             }
-        } else if (res.size()==3 && (res[0]=="bk" || res[0]=="break")) {
-            bk_fidx=fileindex(res[1]);
+        } else if (res.size()==3 &&
+            get_cmd_type(res[0])==dbg_cmd::cmd_break_point) {
+            bk_fidx=file_index(res[1]);
             if (bk_fidx==65535) {
-                std::cout<<"cannot find file named `"<<res[1]<<"`\n";
-                bk_fidx=0;
+                std::clog<<"cannot find file named `"<<res[1]<<"`\n";
+                continue;
             }
             i32 tmp=atoi(res[2].c_str());
             if (tmp<=0) {
-                std::cout<<"incorrect line number `"<<res[2]<<"`\n";
+                std::clog<<"incorrect line number `"<<res[2]<<"`\n";
             } else {
                 bk_line=tmp;
             }
@@ -201,8 +246,7 @@ void dbg::interact() {
 void dbg::run(
     const codegen& gen,
     const linker& linker,
-    const std::vector<string>& argv
-) {
+    const std::vector<string>& argv) {
     verbose=true;
     fsize=linker.filelist().size();
     init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
@@ -269,7 +313,7 @@ void dbg::run(
         ++ctx.pc;
     }
 
-    callsort(count);
+    call_sort(count);
     ngc.info();
     ngc.clear();
     imm.clear();
diff --git a/nasal_gc.h b/nasal_gc.h
index baa673a..a889d63 100644
--- a/nasal_gc.h
+++ b/nasal_gc.h
@@ -249,7 +249,7 @@ public:
         if (mapper.count(name)) {
             std::cerr<<"nasal_gc.h: ghost_register_table::register_ghost_type: ";
             std::cerr<<"ghost type \""<<name<<"\" already exists.\n";
-            std::exit(-1);
+            std::exit(1);
         }
         auto res=destructors.size();
         mapper[name]=res;
@@ -754,7 +754,7 @@ void gc::extend(u8 type) {
         if (!tmp) {
             std::cerr<<"nasal_gc.h: gc::extend: ";
             std::cerr<<"failed to allocate memory\n";
-            std::exit(-1);
+            std::exit(1);
         }
 
         // add to heap
@@ -762,7 +762,7 @@ void gc::extend(u8 type) {
         unused[index].push_back(tmp);
     }
 
-    incr[index]*=2;
+    incr[index]=incr[index]+incr[index]/2;
 }
 
 void gc::init(const std::vector<string>& s, const std::vector<string>& argv) {
diff --git a/test/life.nas b/test/life.nas
index 626d68c..bffbf7a 100644
--- a/test/life.nas
+++ b/test/life.nas
@@ -11,7 +11,7 @@ var new_map=func(width,height){
 }
 
 var prt=func(map){
-    var s='\ec\e[1;1H';
+    var s='\e[H';
     foreach(var line;map){
         foreach(var elem;line)
             s~=elem~' ';

From 19480f7f26ea01b6e9d799065e948fcb5849b72d Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Wed, 7 Jun 2023 00:10:00 +0800
Subject: [PATCH 03/34] :sparkles: add new ast nodes

---
 ast/nasal_new_ast.cpp |  9 -------
 ast/nasal_new_ast.h   | 58 ++++++++++++++++++++++++++-----------------
 2 files changed, 35 insertions(+), 32 deletions(-)

diff --git a/ast/nasal_new_ast.cpp b/ast/nasal_new_ast.cpp
index 266ed2d..13b5afc 100644
--- a/ast/nasal_new_ast.cpp
+++ b/ast/nasal_new_ast.cpp
@@ -1,19 +1,10 @@
 #include "nasal_new_ast.h"
 
-bool stmt::accept(ast_visitor* visitor) {
-    visitor->visit_stmt(this);
-    return true;
-}
-
 bool expr::accept(ast_visitor* visitor) {
     visitor->visit_expr(this);
     return true;
 }
 
-void ast_visitor::visit_stmt(stmt* node) {
-    node->accept(this);
-}
-
 void ast_visitor::visit_expr(expr* node) {
     node->accept(this);
 }
\ No newline at end of file
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index 154d901..f125444 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -3,7 +3,7 @@
 #include "nasal.h"
 #include "nasal_err.h"
 
-enum class ast_node_type:u32 {
+enum class expr_type:u32 {
     ast_null=0,      // null node
     ast_stmt,
     ast_expr,
@@ -76,37 +76,49 @@ enum class ast_node_type:u32 {
 
 class ast_visitor;
 
-class ast_node {
+class expr {
 private:
     span nd_loc;
-    ast_node_type nd_type;
+    expr_type nd_type;
 public:
-    ast_node(const span& location,ast_node_type node_type):
+    expr(const span& location,expr_type node_type):
         nd_loc(location), nd_type(node_type) {}
-    ~ast_node() = default;
+    ~expr() = default;
     virtual bool accept(ast_visitor*) = 0;
 };
 
-class stmt:public ast_node {
-public:
-    stmt(const span& location,ast_node_type node_type):
-        ast_node(location, node_type) {}
-    ~stmt() = default;
-    virtual bool accept(ast_visitor*);
-};
-
-class expr:public ast_node {
-private:
-
-public:
-    expr(const span& location,ast_node_type node_type):
-        ast_node(location, node_type) {}
-    ~expr() = default;
-    virtual bool accept(ast_visitor*);
-};
+class null_expr:public expr {};
+class nil_expr:public expr {};
+class number_literal:public expr {};
+class string_literal:public expr {};
+class identifier:public expr {};
+class bool_literal:public expr {};
+class vector_expr:public expr {};
+class hash_expr:public expr {};
+class hash_pair:public expr {};
+class function:public expr {};
+class parameter:public expr {};
+class ternary_operator:public expr {};
+class binary_operator:public expr {};
+class unary_operator:public expr {};
+class call_expr:public expr {};
+class call_hash:public expr {};
+class call_vector:public expr {};
+class call_function:public expr {};
+class slice_vector:public expr {};
+class definition:public expr {};
+class multi_define:public expr {};
+class while_expr:public expr {};
+class for_expr:public expr {};
+class foreach_expr:public expr {};
+class forindex_expr:public expr {};
+class condition_expr:public expr {};
+class if_expr:public expr {};
+class continue_expr:public expr {};
+class break_expr:public expr {};
+class return_expr:public expr {};
 
 class ast_visitor {
 public:
-    virtual void visit_stmt(stmt*);
     virtual void visit_expr(expr*);
 };
\ No newline at end of file

From da22dd03c02806d770fb20937e8faceaf2bca2c2 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Mon, 12 Jun 2023 00:03:18 +0800
Subject: [PATCH 04/34] :sparkles: add nasal_new_parse

---
 ast/nasal_new_parse.cpp | 939 ++++++++++++++++++++++++++++++++++++++++
 ast/nasal_new_parse.h   | 184 ++++++++
 makefile                |   5 +-
 3 files changed, 1127 insertions(+), 1 deletion(-)
 create mode 100644 ast/nasal_new_parse.cpp
 create mode 100644 ast/nasal_new_parse.h

diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
new file mode 100644
index 0000000..653c3f4
--- /dev/null
+++ b/ast/nasal_new_parse.cpp
@@ -0,0 +1,939 @@
+#include "nasal_new_parse.h"
+
+const error& parse::compile(const lexer& lexer) {
+    toks=lexer.result().data();
+    ptr=in_func=in_loop=0;
+
+    root={toks[0].loc, ast_root};
+    while(!lookahead(tok::eof)) {
+        root.add(expr());
+        if (lookahead(tok::semi)) {
+            match(tok::semi);
+        } else if (need_semi_check(root.child().back()) && !lookahead(tok::eof)) {
+            // the last expression can be recognized without semi
+            die(prevspan, "expected \";\"");
+        }
+    }
+    root.update_span();
+    return err;
+}
+
+void parse::die(const span& loc, string info) {
+    err.err("parse", loc, info);
+}
+
+void parse::match(tok type,const char* info) {
+    if (!lookahead(type)) {
+        if (info) {
+            die(thisspan, info);
+            return;
+        }
+        switch(type) {
+            case tok::num:die(thisspan, "expected number");    break;
+            case tok::str:die(thisspan, "expected string");    break;
+            case tok::id: die(thisspan, "expected identifier");break;
+            default:      die(thisspan, "expected '"+tokname.at(type)+"'"); break;
+        }
+        return;
+    }
+    if (lookahead(tok::eof)) {
+        return;
+    }
+    next();
+}
+
+bool parse::lookahead(tok type) {
+    return toks[ptr].type==type;
+}
+
+bool parse::is_call(tok type) {
+    return type==tok::lcurve || type==tok::lbracket || type==tok::dot;
+}
+
+bool parse::check_comma(const tok* panic_set) {
+    for(u32 i=0;panic_set[i]!=tok::null;++i) {
+        if (lookahead(panic_set[i])) {
+            die(prevspan, "expected ',' between scalars");
+            return true;
+        }
+    }
+    return false;
+}
+
+bool parse::check_tuple() {
+    u32 check_ptr=ptr, curve=1, bracket=0, brace=0;
+    while(toks[++check_ptr].type!=tok::eof && curve) {
+        switch(toks[check_ptr].type) {
+            case tok::lcurve:   ++curve;   break;
+            case tok::lbracket: ++bracket; break;
+            case tok::lbrace:   ++brace;   break;
+            case tok::rcurve:   --curve;   break;
+            case tok::rbracket: --bracket; break;
+            case tok::rbrace:   --brace;   break;
+            default: break;
+        }
+        if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::comma) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool parse::check_func_end(const ast& node) {
+    u32 type=node.type();
+    if (type==ast_func) {
+        return true;
+    } else if (type==ast_num || type==ast_id || type==ast_str || type==ast_nil || type==ast_vec || type==ast_hash) {
+        return false;
+    }
+    if (node.child().empty() || (
+            type!=ast_def &&
+            type!=ast_equal &&
+            type!=ast_addeq &&
+            type!=ast_subeq &&
+            type!=ast_multeq &&
+            type!=ast_diveq &&
+            type!=ast_lnkeq
+        )
+    ) {
+        return false;
+    } else {
+        return check_func_end(node.child().back());
+    }
+    return false;
+}
+
+bool parse::check_special_call() {
+    // special call means like this: function_name(a:1,b:2,c:3);
+    u32 check_ptr=ptr, curve=1, bracket=0, brace=0;
+    while(toks[++check_ptr].type!=tok::eof && curve) {
+        switch(toks[check_ptr].type) {
+            case tok::lcurve:   ++curve;  break;
+            case tok::lbracket: ++bracket;break;
+            case tok::lbrace:   ++brace;  break;
+            case tok::rcurve:   --curve;  break;
+            case tok::rbracket: --bracket;break;
+            case tok::rbrace:   --brace;  break;
+            default: break;
+        }
+        // m?1:0 will be recognized as normal parameter
+        if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::quesmark) {
+            return false;
+        }
+        if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::colon) {
+            return true;
+        }
+    }
+    return false;
+}
+
+bool parse::need_semi_check(const ast& node) {
+    u32 type=node.type();
+    if (type==ast_for || type==ast_foreach || type==ast_forindex || type==ast_while || type==ast_cond) {
+        return false;
+    }
+    return !check_func_end(node);
+}
+
+ast parse::null() {
+    return {toks[ptr].loc, ast_null};
+}
+
+ast parse::nil() {
+    return {toks[ptr].loc, ast_nil};
+}
+
+ast parse::num() {
+    ast node(toks[ptr].loc, ast_num);
+    node.set_num(str2num(toks[ptr].str.c_str()));
+    match(tok::num);
+    return node;
+}
+
+ast parse::str() {
+    ast node(toks[ptr].loc, ast_str);
+    node.set_str(toks[ptr].str);
+    match(tok::str);
+    return node;
+}
+
+ast parse::id() {
+    ast node(toks[ptr].loc, ast_id);
+    node.set_str(toks[ptr].str);
+    match(tok::id);
+    return node;
+}
+
+ast parse::bools() {
+    ast node(toks[ptr].loc, ast_bool);
+    node.set_str(toks[ptr].str);
+    if (lookahead(tok::tktrue)) {
+        match(tok::tktrue);
+    } else {
+        match(tok::tkfalse);
+    }
+    return node;
+}
+
+ast parse::vec() {
+    // panic set for this token is not ','
+    // this is the FIRST set of calculation
+    // array end with tok::null=0
+    const tok panic[]={
+        tok::id,tok::str,tok::num,tok::tktrue,
+        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
+        tok::func,tok::var,tok::lcurve,tok::floater,
+        tok::lbrace,tok::lbracket,tok::null
+    };
+    ast node(toks[ptr].loc, ast_vec);
+    match(tok::lbracket);
+    while(!lookahead(tok::rbracket)) {
+        node.add(calc());
+        if (lookahead(tok::comma)) {
+            match(tok::comma);
+        } else if (lookahead(tok::eof)) {
+            break;
+        } else if (!lookahead(tok::rbracket) && !check_comma(panic)) {
+            break;
+        }
+    }
+    node.update_span(thisspan);
+    match(tok::rbracket, "expected ']' when generating vector");
+    return node;
+}
+
+ast parse::hash() {
+    ast node(toks[ptr].loc, ast_hash);
+    match(tok::lbrace);
+    while(!lookahead(tok::rbrace)) {
+        node.add(pair());
+        if (lookahead(tok::comma)) {
+            match(tok::comma);
+        } else if (lookahead(tok::id) || lookahead(tok::str)) { // first set of hashmember
+            die(prevspan, "expected ',' between hash members");
+        } else {
+            break;
+        }
+    }
+    node.update_span(thisspan);
+    match(tok::rbrace, "expected '}' when generating hash");
+    return node;
+}
+
+ast parse::pair() {
+    ast node(toks[ptr].loc, ast_pair);
+    if (lookahead(tok::id)) {
+        node.add(id());
+    } else if (lookahead(tok::str)) {
+        node.add(str());
+    } else {
+        match(tok::id, "expected hashmap key");
+    }
+    match(tok::colon);
+    node.add(calc());
+    node.update_span();
+    return node;
+}
+
+ast parse::func() {
+    ++in_func;
+    ast node(toks[ptr].loc, ast_func);
+    match(tok::func);
+    if (lookahead(tok::lcurve)) {
+        node.add(params());
+    } else {
+        node.add(null());
+    }
+    node.add(exprs());
+    --in_func;
+    node.update_span();
+    return node;
+}
+
+ast parse::params() {
+    ast node(toks[ptr].loc, ast_params);
+    match(tok::lcurve);
+    while(!lookahead(tok::rcurve)) {
+        ast tmp=id();
+        if (lookahead(tok::eq) || lookahead(tok::ellipsis)) {
+            ast special_arg(toks[ptr].loc, ast_null);
+            if (lookahead(tok::eq)) {
+                match(tok::eq);
+                special_arg=std::move(tmp);
+                special_arg.set_type(ast_default);
+                special_arg.add(calc());
+            } else {
+                match(tok::ellipsis);
+                special_arg=std::move(tmp);
+                special_arg.set_type(ast_dynamic);
+            }
+            node.add(std::move(special_arg));
+        } else {
+            node.add(std::move(tmp));
+        }
+        if (lookahead(tok::comma)) {
+            match(tok::comma);
+        } else if (lookahead(tok::id)) { // first set of identifier
+            die(prevspan, "expected ',' between identifiers");
+        } else {
+            break;
+        }
+    }
+    node.update_span(thisspan);
+    match(tok::rcurve, "expected ')' after parameter list");
+    return node;
+}
+
+ast parse::lcurve_expr() {
+    if (toks[ptr+1].type==tok::var)
+        return definition();
+    return check_tuple()?multi_assgin():calc();
+}
+
+ast parse::expr() {
+    tok type=toks[ptr].type;
+    if ((type==tok::brk || type==tok::cont) && !in_loop) {
+        die(thisspan, "must use break/continue in loops");
+    }
+    if (type==tok::ret && !in_func) {
+        die(thisspan, "must use return in functions");
+    }
+    switch(type) {
+        case tok::tknil:
+        case tok::num:
+        case tok::str:
+        case tok::id:
+        case tok::tktrue:
+        case tok::tkfalse:
+        case tok::func:
+        case tok::lbracket:
+        case tok::lbrace:
+        case tok::sub:
+        case tok::floater:
+        case tok::opnot:   return calc();          break;
+        case tok::var:     return definition();    break;
+        case tok::lcurve:  return lcurve_expr();   break;
+        case tok::rfor:
+        case tok::forindex:
+        case tok::foreach:
+        case tok::rwhile:  return loop();          break;
+        case tok::rif:     return cond();          break;
+        case tok::cont:    return continue_expr(); break;
+        case tok::brk:     return break_expr();    break;
+        case tok::ret:     return ret_expr();      break;
+        case tok::semi:                            break;
+        default:
+            die(thisspan, "incorrect token <"+toks[ptr].str+">");
+            next();
+            break;
+    }
+
+    // unreachable
+    return {toks[ptr].loc, ast_null};
+}
+
+ast parse::exprs() {
+    if (lookahead(tok::eof)) {
+        die(thisspan, "expected expression block");
+        return null();
+    }
+    ast node(toks[ptr].loc, ast_block);
+    if (lookahead(tok::lbrace)) {
+        match(tok::lbrace);
+        while(!lookahead(tok::rbrace) && !lookahead(tok::eof)) {
+            node.add(expr());
+            if (lookahead(tok::semi)) {
+                match(tok::semi);
+            } else if (need_semi_check(node.child().back()) && !lookahead(tok::rbrace)) {
+                // the last expression can be recognized without semi
+                die(prevspan, "expected ';'");
+            }
+        }
+        match(tok::rbrace, "expected '}' when generating expressions");
+    } else {
+        node.add(expr());
+        if (lookahead(tok::semi))
+            match(tok::semi);
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::calc() {
+    ast node=bitwise_or();
+    if (lookahead(tok::quesmark)) {
+        // trinocular calculation
+        ast tmp(toks[ptr].loc, ast_trino);
+        match(tok::quesmark);
+        tmp.add(std::move(node));
+        tmp.add(calc());
+        match(tok::colon);
+        tmp.add(calc());
+        node=std::move(tmp);
+    } else if (tok::eq<=toks[ptr].type && toks[ptr].type<=tok::lnkeq) {
+        // tok::eq~tok::lnkeq is 37 to 42,ast_equal~ast_lnkeq is 21~26
+        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::eq+ast_equal);
+        tmp.add(std::move(node));
+        match(toks[ptr].type);
+        tmp.add(calc());
+        node=std::move(tmp);
+    } else if (toks[ptr].type==tok::btandeq || toks[ptr].type==tok::btoreq || toks[ptr].type==tok::btxoreq) {
+        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::btandeq+ast_btandeq);
+        tmp.add(std::move(node));
+        match(toks[ptr].type);
+        tmp.add(calc());
+        node=std::move(tmp);
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::bitwise_or() {
+    ast node=bitwise_xor();
+    while(lookahead(tok::btor)) {
+        ast tmp(toks[ptr].loc, ast_bitor);
+        tmp.add(std::move(node));
+        match(tok::btor);
+        tmp.add(bitwise_xor());
+        tmp.update_span();
+        node=std::move(tmp);
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::bitwise_xor() {
+    ast node=bitwise_and();
+    while(lookahead(tok::btxor)) {
+        ast tmp(toks[ptr].loc, ast_bitxor);
+        tmp.add(std::move(node));
+        match(tok::btxor);
+        tmp.add(bitwise_and());
+        tmp.update_span();
+        node=std::move(tmp);
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::bitwise_and() {
+    ast node=or_expr();
+    while(lookahead(tok::btand)) {
+        ast tmp(toks[ptr].loc, ast_bitand);
+        tmp.add(std::move(node));
+        match(tok::btand);
+        tmp.add(or_expr());
+        tmp.update_span();
+        node=std::move(tmp);
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::or_expr() {
+    ast node=and_expr();
+    while(lookahead(tok::opor)) {
+        ast tmp(toks[ptr].loc, ast_or);
+        tmp.add(std::move(node));
+        match(tok::opor);
+        tmp.add(and_expr());
+        tmp.update_span();
+        node=std::move(tmp);
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::and_expr() {
+    ast node=cmp_expr();
+    while(lookahead(tok::opand)) {
+        ast tmp(toks[ptr].loc, ast_and);
+        tmp.add(std::move(node));
+        match(tok::opand);
+        tmp.add(cmp_expr());
+        tmp.update_span();
+        node=std::move(tmp);
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::cmp_expr() {
+    ast node=additive_expr();
+    while(tok::cmpeq<=toks[ptr].type && toks[ptr].type<=tok::geq) {
+        // tok::cmpeq~tok::geq is 43~48,ast_cmpeq~ast_geq is 27~32
+        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::cmpeq+ast_cmpeq);
+        tmp.add(std::move(node));
+        match(toks[ptr].type);
+        tmp.add(additive_expr());
+        tmp.update_span();
+        node=std::move(tmp);
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::additive_expr() {
+    ast node=multive_expr();
+    while(lookahead(tok::add) || lookahead(tok::sub) || lookahead(tok::floater)) {
+        ast tmp(toks[ptr].loc, ast_null);
+        switch(toks[ptr].type) {
+            case tok::add: tmp.set_type(ast_add);  break;
+            case tok::sub: tmp.set_type(ast_sub);  break;
+            case tok::floater: tmp.set_type(ast_link); break;
+            default: break;
+        }
+        tmp.add(std::move(node));
+        match(toks[ptr].type);
+        tmp.add(multive_expr());
+        tmp.update_span();
+        node=std::move(tmp);
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::multive_expr() {
+    ast node=(lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar();
+    while(lookahead(tok::mult) || lookahead(tok::div)) {
+        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::mult+ast_mult);
+        tmp.add(std::move(node));
+        match(toks[ptr].type);
+        tmp.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
+        tmp.update_span();
+        node=std::move(tmp);
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::unary() {
+    ast node(toks[ptr].loc,ast_null);
+    switch(toks[ptr].type) {
+        case tok::sub:     node.set_type(ast_neg);match(tok::sub);break;
+        case tok::opnot:   node.set_type(ast_lnot);match(tok::opnot);break;
+        case tok::floater: node.set_type(ast_bnot);match(tok::floater);break;
+        default: break;
+    }
+    node.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
+    node.update_span();
+    return node;
+}
+
+ast parse::scalar() {
+    ast node(toks[ptr].loc, ast_null);
+    if (lookahead(tok::tknil)) {
+        node=nil();
+        match(tok::tknil);
+    } else if (lookahead(tok::num)) {
+        node=num();
+    } else if (lookahead(tok::str)) {
+        node=str();
+    } else if (lookahead(tok::id)) {
+        node=id();
+    } else if (lookahead(tok::tktrue) || lookahead(tok::tkfalse)) {
+        node=bools();
+    } else if (lookahead(tok::func)) {
+        node=func();
+    } else if (lookahead(tok::lbracket)) {
+        node=vec();
+    } else if (lookahead(tok::lbrace)) {
+        node=hash();
+    } else if (lookahead(tok::lcurve)) {
+        const auto& loc=toks[ptr].loc;
+        match(tok::lcurve);
+        node=calc();
+        node.set_begin(loc.begin_line, loc.begin_column);
+        node.update_span(thisspan);
+        match(tok::rcurve);
+    } else if (lookahead(tok::var)) {
+        match(tok::var);
+        node.set_type(ast_def);
+        node.add(id());
+        match(tok::eq);
+        node.add(calc());
+    } else {
+        die(thisspan, "expected scalar");
+        return node;
+    }
+    // check call and avoid ambiguous syntax
+    if (is_call(toks[ptr].type) && !(lookahead(tok::lcurve) && toks[ptr+1].type==tok::var)) {
+        ast tmp=std::move(node);
+        node={toks[ptr].loc, ast_call};
+        node.add(std::move(tmp));
+        while(is_call(toks[ptr].type)) {
+            node.add(call_scalar());
+        }
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::call_scalar() {
+    switch(toks[ptr].type) {
+        case tok::lcurve:   return callf(); break;
+        case tok::lbracket: return callv(); break;
+        case tok::dot:      return callh(); break;
+        default: break;
+    }
+    // unreachable
+    return {toks[ptr].loc, ast_nil};
+}
+
+ast parse::callh() {
+    ast node(toks[ptr].loc, ast_callh);
+    match(tok::dot);
+    node.set_str(toks[ptr].str);
+    node.set_end(toks[ptr].loc.end_line, toks[ptr].loc.end_column);
+    match(tok::id, "expected hashmap key"); // get key
+    return node;
+}
+
+ast parse::callv() {
+    // panic set for this token is not ','
+    // this is the FIRST set of subvec
+    // array end with tok::null=0
+    const tok panic[]={
+        tok::id,tok::str,tok::num,tok::tktrue,
+        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
+        tok::func,tok::var,tok::lcurve,tok::floater,
+        tok::lbrace,tok::lbracket,tok::colon,tok::null
+    };
+    ast node(toks[ptr].loc, ast_callv);
+    match(tok::lbracket);
+    while(!lookahead(tok::rbracket)) {
+        node.add(subvec());
+        if (lookahead(tok::comma)) {
+            match(tok::comma);
+        } else if (lookahead(tok::eof)) {
+            break;
+        } else if (!lookahead(tok::rbracket) && !check_comma(panic)) {
+            break;
+        }
+    }
+    if (node.size()==0) {
+        die(thisspan, "expected index value");
+    }
+    node.update_span(thisspan);
+    match(tok::rbracket, "expected ']' when calling vector");
+    return node;
+}
+
+ast parse::callf() {
+    // panic set for this token is not ','
+    // this is the FIRST set of calculation/hashmember
+    // array end with tok::null=0
+    const tok panic[]={
+        tok::id,tok::str,tok::num,tok::tktrue,
+        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
+        tok::func,tok::var,tok::lcurve,tok::floater,
+        tok::lbrace,tok::lbracket,tok::null
+    };
+    ast node(toks[ptr].loc, ast_callf);
+    bool special_call=check_special_call();
+    match(tok::lcurve);
+    while(!lookahead(tok::rcurve)) {
+        node.add(special_call?pair():calc());
+        if (lookahead(tok::comma))
+            match(tok::comma);
+        else if (lookahead(tok::eof))
+            break;
+        else if (!lookahead(tok::rcurve) && !check_comma(panic))
+            break;
+    }
+    node.update_span(thisspan);
+    match(tok::rcurve, "expected ')' when calling function");
+    return node;
+}
+
+ast parse::subvec() {
+    ast node=lookahead(tok::colon)?nil():calc();
+    if (lookahead(tok::colon)) {
+        ast tmp(toks[ptr].loc, ast_subvec);
+        match(tok::colon);
+        tmp.add(std::move(node));
+        tmp.add((lookahead(tok::comma) || lookahead(tok::rbracket))?nil():calc());
+        node=std::move(tmp);
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::definition() {
+    ast node(toks[ptr].loc, ast_def);
+    if (lookahead(tok::var)) {
+        match(tok::var);
+        switch(toks[ptr].type) {
+            case tok::id: node.add(id());break;
+            case tok::lcurve: node.add(outcurve_def());break;
+            default: die(thisspan, "expected identifier");break;
+        }
+    } else if (lookahead(tok::lcurve)) {
+        node.add(incurve_def());
+    }
+    match(tok::eq);
+    if (lookahead(tok::lcurve)) {
+        node.add(check_tuple()?multi_scalar():calc());
+    } else {
+        node.add(calc());
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::incurve_def() {
+    const auto& loc=toks[ptr].loc;
+    match(tok::lcurve);
+    match(tok::var);
+    ast node=multi_id();
+    node.update_span(thisspan);
+    match(tok::rcurve);
+    node.set_begin(loc.begin_line, loc.begin_column);
+    return node;
+}
+
+ast parse::outcurve_def() {
+    const auto& loc=toks[ptr].loc;
+    match(tok::lcurve);
+    ast node=multi_id();
+    node.update_span(thisspan);
+    match(tok::rcurve);
+    node.set_begin(loc.begin_line, loc.begin_column);
+    return node;
+}
+
+ast parse::multi_id() {
+    ast node(toks[ptr].loc, ast_multi_id);
+    while(!lookahead(tok::eof)) {
+        // only identifier is allowed here
+        // but we check it at codegen stage
+        node.add(calc());
+        if (lookahead(tok::comma)) {
+            match(tok::comma);
+        } else if (lookahead(tok::id)) { // first set of identifier
+            die(prevspan, "expected ',' between identifiers");
+        } else {
+            break;
+        }
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::multi_scalar() {
+    // if check_call_memory is true,we will check if value called here can reach a memory space
+    const tok panic[]={
+        tok::id,tok::str,tok::num,tok::tktrue,
+        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
+        tok::func,tok::var,tok::lcurve,tok::floater,
+        tok::lbrace,tok::lbracket,tok::null
+    };
+    ast node(toks[ptr].loc, ast_tuple);
+    match(tok::lcurve);
+    while(!lookahead(tok::rcurve)) {
+        node.add(calc());
+        if (lookahead(tok::comma)) {
+            match(tok::comma);
+        } else if (lookahead(tok::eof)) {
+            break;
+        } else if (!lookahead(tok::rcurve) && !check_comma(panic)) {
+            break;
+        }
+    }
+    node.update_span(thisspan);
+    match(tok::rcurve, "expected ')' after multi-scalar");
+    return node;
+}
+
+ast parse::multi_assgin() {
+    ast node(toks[ptr].loc, ast_multi_assign);
+    node.add(multi_scalar());
+    match(tok::eq);
+    if (lookahead(tok::eof)) {
+        die(thisspan, "expected value list");
+        return node;
+    }
+    if (lookahead(tok::lcurve)) {
+        node.add(check_tuple()?multi_scalar():calc());
+    } else {
+        node.add(calc());
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::loop() {
+    ++in_loop;
+    ast node(toks[ptr].loc, ast_null);
+    switch(toks[ptr].type) {
+        case tok::rwhile:  node=while_loop(); break;
+        case tok::rfor:    node=for_loop();   break;
+        case tok::forindex:
+        case tok::foreach: node=forei_loop(); break;
+        default: break;
+    }
+    --in_loop;
+    return node;
+}
+
+ast parse::while_loop() {
+    ast node(toks[ptr].loc, ast_while);
+    match(tok::rwhile);
+    match(tok::lcurve);
+    node.add(calc());
+    match(tok::rcurve);
+    node.add(exprs());
+    node.update_span();
+    return node;
+}
+
+ast parse::for_loop() {
+    ast node(toks[ptr].loc, ast_for);
+    match(tok::rfor);
+    match(tok::lcurve);
+    // first expression
+    if (lookahead(tok::eof)) {
+        die(thisspan, "expected definition");
+    }
+    if (lookahead(tok::semi)) {
+        node.add(null());
+    } else if (lookahead(tok::var)) {
+        node.add(definition());
+    } else if (lookahead(tok::lcurve)) {
+        node.add(lcurve_expr());
+    } else {
+        node.add(calc());
+    }
+    match(tok::semi, "expected ';' in for(;;)");
+    // conditional expression
+    if (lookahead(tok::eof)) {
+        die(thisspan, "expected conditional expr");
+    }
+    if (lookahead(tok::semi)) {
+        node.add(null());
+    } else {
+        node.add(calc());
+    }
+    match(tok::semi, "expected ';' in for(;;)");
+    //after loop expression
+    if (lookahead(tok::eof)) {
+        die(thisspan, "expected calculation");
+    }
+    if (lookahead(tok::rcurve)) {
+        node.add(null());
+    } else {
+        node.add(calc());
+    }
+    match(tok::rcurve);
+    node.add(exprs());
+    node.update_span();
+    return node;
+}
+
+ast parse::forei_loop() {
+    ast node(toks[ptr].loc, ast_null);
+    switch(toks[ptr].type) {
+        case tok::forindex:node.set_type(ast_forindex);match(tok::forindex);break;
+        case tok::foreach: node.set_type(ast_foreach); match(tok::foreach); break;
+        default: break;
+    }
+    match(tok::lcurve);
+    // first expression
+    // foreach/forindex must have an iterator to loop through
+    if (!lookahead(tok::var) && !lookahead(tok::id)) {
+        die(thisspan, "expected iterator");
+    }
+    node.add(iter_gen());
+    match(tok::semi, "expected ';' in foreach/forindex(iter;vector)");
+    if (lookahead(tok::eof)) {
+        die(thisspan, "expected vector");
+    }
+    node.add(calc());
+    match(tok::rcurve);
+    node.add(exprs());
+    node.update_span();
+    return node;
+}
+
+ast parse::iter_gen() {
+    ast node(toks[ptr].loc, ast_null);
+    if (lookahead(tok::var)) {
+        match(tok::var);
+        node.set_type(ast_iter);
+        node.add(id());
+    } else {
+        node.set_type(ast_call);
+        node.add(id());
+        while(is_call(toks[ptr].type)) {
+            node.add(call_scalar());
+        }
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::cond() {
+    ast node(toks[ptr].loc, ast_cond);
+
+    // generate if
+    ast ifnode(toks[ptr].loc, ast_if);
+    match(tok::rif);
+    match(tok::lcurve);
+    ifnode.add(calc());
+    match(tok::rcurve);
+    ifnode.add(exprs());
+    ifnode.update_span();
+    node.add(std::move(ifnode));
+
+    // generate elsif
+    while(lookahead(tok::elsif)) {
+        ast elsifnode(toks[ptr].loc, ast_elsif);
+        match(tok::elsif);
+        match(tok::lcurve);
+        elsifnode.add(calc());
+        match(tok::rcurve);
+        elsifnode.add(exprs());
+        elsifnode.update_span();
+        node.add(std::move(elsifnode));
+    }
+
+    // generate else
+    if (lookahead(tok::relse)) {
+        ast elsenode(toks[ptr].loc, ast_else);
+        match(tok::relse);
+        elsenode.add(exprs());
+        elsenode.update_span();
+        node.add(std::move(elsenode));
+    }
+    node.update_span();
+    return node;
+}
+
+ast parse::continue_expr() {
+    ast node(toks[ptr].loc, ast_continue);
+    match(tok::cont);
+    return node;
+}
+
+ast parse::break_expr() {
+    ast node(toks[ptr].loc, ast_break);
+    match(tok::brk);
+    return node;
+}
+
+ast parse::ret_expr() {
+    ast node(toks[ptr].loc, ast_ret);
+    match(tok::ret);
+    tok type=toks[ptr].type;
+    if (type==tok::tknil || type==tok::num ||
+        type==tok::str || type==tok::id ||
+        type==tok::func || type==tok::sub ||
+        type==tok::opnot || type==tok::lcurve ||
+        type==tok::lbracket || type==tok::lbrace ||
+        type==tok::tktrue || type==tok::tkfalse
+    ) {
+        node.add(calc());
+    }
+    node.update_span();
+    return node;
+}
diff --git a/ast/nasal_new_parse.h b/ast/nasal_new_parse.h
new file mode 100644
index 0000000..d2bc242
--- /dev/null
+++ b/ast/nasal_new_parse.h
@@ -0,0 +1,184 @@
+#pragma once
+
+#include <unordered_map>
+
+#include "nasal.h"
+#include "nasal_new_ast.h"
+#include "nasal_lexer.h"
+#include "nasal_ast.h"
+#include "nasal_err.h"
+
+/*
+              _,,,_                                       
+            .'     `'.                                    
+           /     ____ \      Fucking Nasal Parser
+           |  .-'_  _\/    /                              
+           \_/   a  a|    /                               
+           (,`     \ |         .----.                     
+            |     -' |        /|     '--.                 
+             \   '=  /        ||    ]|   `-.              
+             /`-.__.'         ||    ]|    ::|             
+          .-'`-.__ \__        ||    ]|    ::|             
+         /        ``  `.      ||    ]|    ::|             
+       _ |     \     \  \     \|    ]|   .-'              
+      / \|      \    |   \     L.__  .--'(                
+     |   |\      `.  |    \  ,---|_      \---------,      
+     |   | '.      './\    \/ .--._|=-    |_      /|      
+     |   \   '.     `'.'. /`\/ .-'          '.   / |      
+     |   |     `'.     `;-:-;`)|             |-./  |      
+     |   /_       `'--./_  ` )/'-------------')/)  |      
+     \   | `""""----"`\//`""`/,===..'`````````/ (  |      
+      |  |            / `---` `==='          /   ) |      
+      /  \           /                      /   (  |      
+     |    '------.  |'--------------------'|     ) |      
+      \           `-|                      |    /  |      
+       `--...,______|                      |   (   |      
+              | |   |                      |    ) ,|      
+              | |   |                      |   ( /||      
+              | |   |                      |   )/ `"      
+             /   \  |                      |  (/          
+           .' /I\ '.|                      |  /)          
+        .-'_.'/ \'. |                      | /            
+        ```  `"""` `| .-------------------.||             
+                    `"`                   `"`             
+*/
+
+class parse {
+
+#define thisspan (toks[ptr].loc)
+#define prevspan (ptr!=0? toks[ptr-1].loc:toks[ptr].loc)
+
+private:
+    u32 ptr;
+    u32 in_func; // count function block
+    u32 in_loop; // count loop block
+    const token* toks;
+    ast root;
+    error& err;
+
+private:
+    const std::unordered_map<tok,string> tokname {
+        {tok::rfor    ,"for"     },
+        {tok::forindex,"forindex"},
+        {tok::foreach ,"foreach" },
+        {tok::rwhile  ,"while"   },
+        {tok::var     ,"var"     },
+        {tok::func    ,"func"    },
+        {tok::brk     ,"break"   },
+        {tok::cont    ,"continue"},
+        {tok::ret     ,"return"  },
+        {tok::rif     ,"if"      },
+        {tok::elsif   ,"elsif"   },
+        {tok::relse   ,"else"    },
+        {tok::tknil   ,"nil"     },
+        {tok::lcurve  ,"("       },
+        {tok::rcurve  ,")"       },
+        {tok::lbracket,"["       },
+        {tok::rbracket,"]"       },
+        {tok::lbrace  ,"{"       },
+        {tok::rbrace  ,"}"       },
+        {tok::semi    ,";"       },
+        {tok::opand   ,"and"     },
+        {tok::opor    ,"or"      },
+        {tok::comma   ,","       },
+        {tok::dot     ,"."       },
+        {tok::ellipsis,"..."     },
+        {tok::quesmark,"?"       },
+        {tok::colon   ,":"       },
+        {tok::add     ,"+"       },
+        {tok::sub     ,"-"       },
+        {tok::mult    ,"*"       },
+        {tok::div     ,"/"       },
+        {tok::floater ,"~"       },
+        {tok::btand   ,"&"       },
+        {tok::btor    ,"|"       },
+        {tok::btxor   ,"^"       },
+        {tok::opnot   ,"!"       },
+        {tok::eq      ,"="       },
+        {tok::addeq   ,"+="      },
+        {tok::subeq   ,"-="      },
+        {tok::multeq  ,"*="      },
+        {tok::diveq   ,"/="      },
+        {tok::lnkeq   ,"~="      },
+        {tok::btandeq ,"&="      },
+        {tok::btoreq  ,"|="      },
+        {tok::btxoreq ,"^="      },
+        {tok::cmpeq   ,"=="      },
+        {tok::neq     ,"!="      },
+        {tok::less    ,"<"       },
+        {tok::leq     ,"<="      },
+        {tok::grt     ,">"       },
+        {tok::geq     ,">="      }
+    };
+
+private:
+    void die(const span&,string);
+    void next() {++ptr;}
+    void match(tok type, const char* info=nullptr);
+    bool lookahead(tok);
+    bool is_call(tok);
+    bool check_comma(const tok*);
+    bool check_tuple();
+    bool check_func_end(const ast&);
+    bool check_special_call();
+    bool need_semi_check(const ast&);
+
+private:
+    ast null();
+    ast nil();
+    ast num();
+    ast str();
+    ast id();
+    ast bools();
+    ast vec();
+    ast hash();
+    ast pair();
+    ast func();
+    ast params();
+    ast lcurve_expr();
+    ast expr();
+    ast exprs();
+    ast calc();
+    ast bitwise_or();
+    ast bitwise_xor();
+    ast bitwise_and();
+    ast or_expr();
+    ast and_expr();
+    ast cmp_expr();
+    ast additive_expr();
+    ast multive_expr();
+    ast unary();
+    ast scalar();
+    ast call_scalar();
+    ast callh();
+    ast callv();
+    ast callf();
+    ast subvec();
+    ast definition();
+    ast incurve_def();
+    ast outcurve_def();
+    ast multi_id();
+    ast multi_scalar();
+    ast multi_assgin();
+    ast loop();
+    ast while_loop();
+    ast for_loop();
+    ast forei_loop();
+    ast iter_gen();
+    ast cond();
+    ast continue_expr();
+    ast break_expr();
+    ast ret_expr();
+
+public:
+    inline ast& tree() {return root;}
+    inline const ast& tree() const {return root;}
+
+public:
+    parse(error& e):
+        ptr(0), in_func(0), in_loop(0),
+        toks(nullptr),
+        root({0, 0, 0, 0, ""}, ast_root),
+        err(e) {}
+    const error& compile(const lexer&);
+};
\ No newline at end of file
diff --git a/makefile b/makefile
index 01e0999..73a9ba3 100644
--- a/makefile
+++ b/makefile
@@ -18,7 +18,7 @@ SRC=\
 
 STD=c++14
 
-nasal:$(SRC) nasal_new_ast.o
+nasal:$(SRC) nasal_new_ast.o nasal_new_parse.o
 	$(CXX) -std=$(STD) -O3 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
 nasal.exe:$(SRC)
 	$(CXX) -std=$(STD) -O3 main.cpp -o nasal.exe -fno-exceptions -Wshadow -Wall -static
@@ -26,6 +26,9 @@ nasal.exe:$(SRC)
 nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp nasal.h
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
 
+nasal_new_parse.o: ast/nasal_new_parse.h ast/nasal_new_parse.cpp nasal.h ast/nasal_new_ast.h
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
+
 stable-release:$(SRC)
 	$(CXX) -std=$(STD) -O2 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
 stable-release-mingw:$(SRC)

From ec1985b3cc53fcd3a79b3f309e568477de2879f5 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Wed, 14 Jun 2023 00:01:15 +0800
Subject: [PATCH 05/34] :sparkles: update

---
 ast/ast_visitor.cpp     |  21 +++++++
 ast/ast_visitor.h       |  12 ++++
 ast/nasal_new_ast.cpp   |  21 ++++++-
 ast/nasal_new_ast.h     | 127 ++++++++++++++++++++++++++++------------
 ast/nasal_new_parse.cpp |  36 ++++++++++++
 ast/nasal_new_parse.h   |  36 +-----------
 makefile                |   7 ++-
 7 files changed, 185 insertions(+), 75 deletions(-)
 create mode 100644 ast/ast_visitor.cpp
 create mode 100644 ast/ast_visitor.h

diff --git a/ast/ast_visitor.cpp b/ast/ast_visitor.cpp
new file mode 100644
index 0000000..4e6df01
--- /dev/null
+++ b/ast/ast_visitor.cpp
@@ -0,0 +1,21 @@
+#include "ast_visitor.h"
+
+void ast_visitor::visit_expr(expr* node) {
+    node->accept(this);
+}
+
+void ast_visitor::visit_null_expr(null_expr* node) {
+    node->accept(this);
+}
+
+void ast_visitor::visit_nil_expr(nil_expr* node) {
+    node->accept(this);
+}
+
+void ast_visitor::visit_number_literal(number_literal* node) {
+    node->accept(this);
+}
+
+void ast_visitor::visit_string_literal(string_literal* node) {
+    node->accept(this);
+}
\ No newline at end of file
diff --git a/ast/ast_visitor.h b/ast/ast_visitor.h
new file mode 100644
index 0000000..d077d52
--- /dev/null
+++ b/ast/ast_visitor.h
@@ -0,0 +1,12 @@
+#pragma once
+
+#include "nasal_new_ast.h"
+
+class ast_visitor {
+public:
+    virtual void visit_expr(expr*);
+    virtual void visit_null_expr(null_expr*);
+    virtual void visit_nil_expr(nil_expr*);
+    virtual void visit_number_literal(number_literal*);
+    virtual void visit_string_literal(string_literal*);
+};
\ No newline at end of file
diff --git a/ast/nasal_new_ast.cpp b/ast/nasal_new_ast.cpp
index 13b5afc..5bf617f 100644
--- a/ast/nasal_new_ast.cpp
+++ b/ast/nasal_new_ast.cpp
@@ -1,10 +1,27 @@
 #include "nasal_new_ast.h"
+#include "ast_visitor.h"
 
 bool expr::accept(ast_visitor* visitor) {
     visitor->visit_expr(this);
     return true;
 }
 
-void ast_visitor::visit_expr(expr* node) {
-    node->accept(this);
+bool null_expr::accept(ast_visitor* visitor) {
+    visitor->visit_null_expr(this);
+    return true;
+}
+
+bool nil_expr::accept(ast_visitor* visitor) {
+    visitor->visit_nil_expr(this);
+    return true;
+}
+
+bool number_literal::accept(ast_visitor* visitor) {
+    visitor->visit_number_literal(this);
+    return true;
+}
+
+bool string_literal::accept(ast_visitor* visitor) {
+    visitor->visit_string_literal(this);
+    return true;
 }
\ No newline at end of file
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index f125444..8121270 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -5,8 +5,7 @@
 
 enum class expr_type:u32 {
     ast_null=0,      // null node
-    ast_stmt,
-    ast_expr,
+    ast_expr,        // expression node
     ast_root,        // mark the root node of ast
     ast_block,       // expression block 
     ast_file,        // used to store which file the sub-tree is on, only used in main block
@@ -81,44 +80,98 @@ private:
     span nd_loc;
     expr_type nd_type;
 public:
-    expr(const span& location,expr_type node_type):
+    expr(const span& location, expr_type node_type):
         nd_loc(location), nd_type(node_type) {}
     ~expr() = default;
     virtual bool accept(ast_visitor*) = 0;
 };
 
-class null_expr:public expr {};
-class nil_expr:public expr {};
-class number_literal:public expr {};
-class string_literal:public expr {};
-class identifier:public expr {};
-class bool_literal:public expr {};
-class vector_expr:public expr {};
-class hash_expr:public expr {};
-class hash_pair:public expr {};
-class function:public expr {};
-class parameter:public expr {};
-class ternary_operator:public expr {};
-class binary_operator:public expr {};
-class unary_operator:public expr {};
-class call_expr:public expr {};
-class call_hash:public expr {};
-class call_vector:public expr {};
-class call_function:public expr {};
-class slice_vector:public expr {};
-class definition:public expr {};
-class multi_define:public expr {};
-class while_expr:public expr {};
-class for_expr:public expr {};
-class foreach_expr:public expr {};
-class forindex_expr:public expr {};
-class condition_expr:public expr {};
-class if_expr:public expr {};
-class continue_expr:public expr {};
-class break_expr:public expr {};
-class return_expr:public expr {};
-
-class ast_visitor {
+class null_expr:public expr {
 public:
-    virtual void visit_expr(expr*);
-};
\ No newline at end of file
+    null_expr(const span& location):
+        expr(location, expr_type::ast_null) {}
+    ~null_expr() = default;
+    virtual bool accept(ast_visitor*);
+};
+
+class nil_expr:public expr {
+public:
+    nil_expr(const span& location):
+        expr(location, expr_type::ast_nil) {}
+    ~nil_expr() = default;
+    virtual bool accept(ast_visitor*);
+};
+
+class number_literal:public expr {
+private:
+    f64 number;
+
+public:
+    number_literal(const span& location, const f64 num):
+        expr(location, expr_type::ast_num), number(num) {}
+    ~number_literal() = default;
+    virtual bool accept(ast_visitor*);
+};
+
+class string_literal:public expr {
+private:
+    string content;
+
+public:
+    string_literal(const span& location, const string& str):
+        expr(location, expr_type::ast_str), content(str) {}
+    ~string_literal() = default;
+    virtual bool accept(ast_visitor*);
+};
+
+class identifier:public expr {};
+
+class bool_literal:public expr {};
+
+class vector_expr:public expr {};
+
+class hash_expr:public expr {};
+
+class hash_pair:public expr {};
+
+class function:public expr {};
+
+class parameter:public expr {};
+
+class ternary_operator:public expr {};
+
+class binary_operator:public expr {};
+
+class unary_operator:public expr {};
+
+class call_expr:public expr {};
+
+class call_hash:public expr {};
+
+class call_vector:public expr {};
+
+class call_function:public expr {};
+
+class slice_vector:public expr {};
+
+class definition:public expr {};
+
+class multi_define:public expr {};
+
+class while_expr:public expr {};
+
+class for_expr:public expr {};
+
+class foreach_expr:public expr {};
+
+class forindex_expr:public expr {};
+
+class condition_expr:public expr {};
+
+class if_expr:public expr {};
+
+class continue_expr:public expr {};
+
+class break_expr:public expr {};
+
+class return_expr:public expr {};
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index 653c3f4..5d7fc44 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -18,6 +18,42 @@ const error& parse::compile(const lexer& lexer) {
     return err;
 }
 
+void parse::easter_egg() const {
+    std::clog
+    << "              _,,,_                                          \n"
+    << "            .'     `'.                                       \n"
+    << "           /     ____ \\      Fucking Nasal Parser           \n"
+    << "           |  .-'_  _\\/    /                                \n"
+    << "           \\_/   a  a|    /                                 \n"
+    << "           (,`     \\ |         .----.                       \n"
+    << "            |     -' |        /|     '--.                    \n"
+    << "             \\   '=  /        ||    ]|   `-.                \n"
+    << "             /`-.__.'         ||    ]|    ::|                \n"
+    << "          .-'`-.__ \\__        ||    ]|    ::|               \n"
+    << "         /        ``  `.      ||    ]|    ::|                \n"
+    << "       _ |     \\     \\  \\     \\|    ]|   .-'             \n"
+    << "      / \\|      \\    |   \\     L.__  .--'(                \n"
+    << "     |   |\\      `.  |    \\  ,---|_      \\---------,      \n"
+    << "     |   | '.      './\\    \\/ .--._|=-    |_      /|       \n"
+    << "     |   \\   '.     `'.'. /`\\/ .-'          '.   / |       \n"
+    << "     |   |     `'.     `;-:-;`)|             |-./  |         \n"
+    << "     |   /_       `'--./_  ` )/'-------------')/)  |         \n"
+    << "     \\   | `\"\"\"\"----\"`\\//`\"\"`/,===..'`````````/ (  |\n"
+    << "      |  |            / `---` `==='          /   ) |         \n"
+    << "      /  \\           /                      /   (  |        \n"
+    << "     |    '------.  |'--------------------'|     ) |         \n"
+    << "      \\           `-|                      |    /  |        \n"
+    << "       `--...,______|                      |   (   |         \n"
+    << "              | |   |                      |    ) ,|         \n"
+    << "              | |   |                      |   ( /||         \n"
+    << "              | |   |                      |   )/ `\"        \n"
+    << "             /   \\  |                      |  (/            \n"
+    << "           .' /I\\ '.|                      |  /)            \n"
+    << "        .-'_.'/ \\'. |                      | /              \n"
+    << "        ```  `\"\"\"` `| .-------------------.||             \n"
+    << "                    `\"`                   `\"`              \n";
+}
+
 void parse::die(const span& loc, string info) {
     err.err("parse", loc, info);
 }
diff --git a/ast/nasal_new_parse.h b/ast/nasal_new_parse.h
index d2bc242..acf8212 100644
--- a/ast/nasal_new_parse.h
+++ b/ast/nasal_new_parse.h
@@ -8,41 +8,6 @@
 #include "nasal_ast.h"
 #include "nasal_err.h"
 
-/*
-              _,,,_                                       
-            .'     `'.                                    
-           /     ____ \      Fucking Nasal Parser
-           |  .-'_  _\/    /                              
-           \_/   a  a|    /                               
-           (,`     \ |         .----.                     
-            |     -' |        /|     '--.                 
-             \   '=  /        ||    ]|   `-.              
-             /`-.__.'         ||    ]|    ::|             
-          .-'`-.__ \__        ||    ]|    ::|             
-         /        ``  `.      ||    ]|    ::|             
-       _ |     \     \  \     \|    ]|   .-'              
-      / \|      \    |   \     L.__  .--'(                
-     |   |\      `.  |    \  ,---|_      \---------,      
-     |   | '.      './\    \/ .--._|=-    |_      /|      
-     |   \   '.     `'.'. /`\/ .-'          '.   / |      
-     |   |     `'.     `;-:-;`)|             |-./  |      
-     |   /_       `'--./_  ` )/'-------------')/)  |      
-     \   | `""""----"`\//`""`/,===..'`````````/ (  |      
-      |  |            / `---` `==='          /   ) |      
-      /  \           /                      /   (  |      
-     |    '------.  |'--------------------'|     ) |      
-      \           `-|                      |    /  |      
-       `--...,______|                      |   (   |      
-              | |   |                      |    ) ,|      
-              | |   |                      |   ( /||      
-              | |   |                      |   )/ `"      
-             /   \  |                      |  (/          
-           .' /I\ '.|                      |  /)          
-        .-'_.'/ \'. |                      | /            
-        ```  `"""` `| .-------------------.||             
-                    `"`                   `"`             
-*/
-
 class parse {
 
 #define thisspan (toks[ptr].loc)
@@ -181,4 +146,5 @@ public:
         root({0, 0, 0, 0, ""}, ast_root),
         err(e) {}
     const error& compile(const lexer&);
+    void easter_egg() const;
 };
\ No newline at end of file
diff --git a/makefile b/makefile
index 73a9ba3..b141816 100644
--- a/makefile
+++ b/makefile
@@ -18,8 +18,9 @@ SRC=\
 
 STD=c++14
 
-nasal:$(SRC) nasal_new_ast.o nasal_new_parse.o
+nasal:$(SRC) nasal_new_ast.o nasal_new_parse.o ast_visitor.o
 	$(CXX) -std=$(STD) -O3 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
+
 nasal.exe:$(SRC)
 	$(CXX) -std=$(STD) -O3 main.cpp -o nasal.exe -fno-exceptions -Wshadow -Wall -static
 
@@ -29,8 +30,12 @@ nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp nasal.h
 nasal_new_parse.o: ast/nasal_new_parse.h ast/nasal_new_parse.cpp nasal.h ast/nasal_new_ast.h
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
 
+ast_visitor.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_visitor.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .
+
 stable-release:$(SRC)
 	$(CXX) -std=$(STD) -O2 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
+
 stable-release-mingw:$(SRC)
 	$(CXX) -std=$(STD) -O2 main.cpp -o nasal.exe -fno-exceptions -Wshadow -Wall -static
 

From c95810b46ce388695c32b8c7be07c1fe6c51e81a Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Fri, 16 Jun 2023 22:23:46 +0800
Subject: [PATCH 06/34] :sparkles: add nasal_new_lexer

---
 ast/ast_visitor.cpp     |  26 ++--
 ast/ast_visitor.h       |  12 +-
 ast/nasal_new_ast.cpp   |  23 +--
 ast/nasal_new_ast.h     | 152 ++++++++++++++----
 ast/nasal_new_lexer.cpp | 333 ++++++++++++++++++++++++++++++++++++++++
 ast/nasal_new_lexer.h   | 181 ++++++++++++++++++++++
 ast/new_main.cpp        | 176 +++++++++++++++++++++
 makefile                |   5 +-
 8 files changed, 852 insertions(+), 56 deletions(-)
 create mode 100644 ast/nasal_new_lexer.cpp
 create mode 100644 ast/nasal_new_lexer.h
 create mode 100644 ast/new_main.cpp

diff --git a/ast/ast_visitor.cpp b/ast/ast_visitor.cpp
index 4e6df01..01b6f93 100644
--- a/ast/ast_visitor.cpp
+++ b/ast/ast_visitor.cpp
@@ -1,21 +1,29 @@
 #include "ast_visitor.h"
 
-void ast_visitor::visit_expr(expr* node) {
+bool ast_visitor::visit_expr(expr* node) {
     node->accept(this);
 }
 
-void ast_visitor::visit_null_expr(null_expr* node) {
-    node->accept(this);
+bool ast_visitor::visit_null_expr(null_expr* node) {
+    return true;
 }
 
-void ast_visitor::visit_nil_expr(nil_expr* node) {
-    node->accept(this);
+bool ast_visitor::visit_nil_expr(nil_expr* node) {
+    return true;
 }
 
-void ast_visitor::visit_number_literal(number_literal* node) {
-    node->accept(this);
+bool ast_visitor::visit_number_literal(number_literal* node) {
+    return true;
 }
 
-void ast_visitor::visit_string_literal(string_literal* node) {
-    node->accept(this);
+bool ast_visitor::visit_string_literal(string_literal* node) {
+    return true;
+}
+
+bool ast_visitor::visit_identifier(identifier* node) {
+    return true;
+}
+
+bool ast_visitor::visit_bool_literal(bool_literal* node) {
+    return true;
 }
\ No newline at end of file
diff --git a/ast/ast_visitor.h b/ast/ast_visitor.h
index d077d52..94dd66c 100644
--- a/ast/ast_visitor.h
+++ b/ast/ast_visitor.h
@@ -4,9 +4,11 @@
 
 class ast_visitor {
 public:
-    virtual void visit_expr(expr*);
-    virtual void visit_null_expr(null_expr*);
-    virtual void visit_nil_expr(nil_expr*);
-    virtual void visit_number_literal(number_literal*);
-    virtual void visit_string_literal(string_literal*);
+    virtual bool visit_expr(expr*);
+    virtual bool visit_null_expr(null_expr*);
+    virtual bool visit_nil_expr(nil_expr*);
+    virtual bool visit_number_literal(number_literal*);
+    virtual bool visit_string_literal(string_literal*);
+    virtual bool visit_identifier(identifier*);
+    virtual bool visit_bool_literal(bool_literal*);
 };
\ No newline at end of file
diff --git a/ast/nasal_new_ast.cpp b/ast/nasal_new_ast.cpp
index 5bf617f..c34a1fe 100644
--- a/ast/nasal_new_ast.cpp
+++ b/ast/nasal_new_ast.cpp
@@ -1,27 +1,30 @@
 #include "nasal_new_ast.h"
 #include "ast_visitor.h"
 
-bool expr::accept(ast_visitor* visitor) {
+void expr::accept(ast_visitor* visitor) {
     visitor->visit_expr(this);
-    return true;
 }
 
-bool null_expr::accept(ast_visitor* visitor) {
+void null_expr::accept(ast_visitor* visitor) {
     visitor->visit_null_expr(this);
-    return true;
 }
 
-bool nil_expr::accept(ast_visitor* visitor) {
+void nil_expr::accept(ast_visitor* visitor) {
     visitor->visit_nil_expr(this);
-    return true;
 }
 
-bool number_literal::accept(ast_visitor* visitor) {
+void number_literal::accept(ast_visitor* visitor) {
     visitor->visit_number_literal(this);
-    return true;
 }
 
-bool string_literal::accept(ast_visitor* visitor) {
+void string_literal::accept(ast_visitor* visitor) {
     visitor->visit_string_literal(this);
-    return true;
+}
+
+void identifier::accept(ast_visitor* visitor) {
+    visitor->visit_identifier(this);
+}
+
+void bool_literal::accept(ast_visitor* visitor) {
+    visitor->visit_bool_literal(this);
 }
\ No newline at end of file
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index 8121270..1a6712c 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -83,7 +83,7 @@ public:
     expr(const span& location, expr_type node_type):
         nd_loc(location), nd_type(node_type) {}
     ~expr() = default;
-    virtual bool accept(ast_visitor*) = 0;
+    virtual void accept(ast_visitor*) = 0;
 };
 
 class null_expr:public expr {
@@ -91,7 +91,7 @@ public:
     null_expr(const span& location):
         expr(location, expr_type::ast_null) {}
     ~null_expr() = default;
-    virtual bool accept(ast_visitor*);
+    virtual void accept(ast_visitor*) override;
 };
 
 class nil_expr:public expr {
@@ -99,7 +99,7 @@ public:
     nil_expr(const span& location):
         expr(location, expr_type::ast_nil) {}
     ~nil_expr() = default;
-    virtual bool accept(ast_visitor*);
+    virtual void accept(ast_visitor*) override;
 };
 
 class number_literal:public expr {
@@ -110,7 +110,7 @@ public:
     number_literal(const span& location, const f64 num):
         expr(location, expr_type::ast_num), number(num) {}
     ~number_literal() = default;
-    virtual bool accept(ast_visitor*);
+    virtual void accept(ast_visitor*) override;
 };
 
 class string_literal:public expr {
@@ -121,57 +121,147 @@ public:
     string_literal(const span& location, const string& str):
         expr(location, expr_type::ast_str), content(str) {}
     ~string_literal() = default;
-    virtual bool accept(ast_visitor*);
+    virtual void accept(ast_visitor*) override;
 };
 
-class identifier:public expr {};
+class identifier:public expr {
+private:
+    string name;
 
-class bool_literal:public expr {};
+public:
+    identifier(const span& location, const string& str):
+        expr(location, expr_type::ast_id), name(str) {}
+    ~identifier() = default;
+    virtual void accept(ast_visitor*) override;
+};
 
-class vector_expr:public expr {};
+class bool_literal:public expr {
+private:
+    bool flag;
 
-class hash_expr:public expr {};
+public:
+    bool_literal(const span& location, const bool bool_flag):
+        expr(location, expr_type::ast_bool), flag(bool_flag) {}
+    ~bool_literal() = default;
+    virtual void accept(ast_visitor*) override;
+};
 
-class hash_pair:public expr {};
+class vector_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class function:public expr {};
+class hash_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class parameter:public expr {};
+class hash_pair:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class ternary_operator:public expr {};
+class function:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class binary_operator:public expr {};
+class parameter:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class unary_operator:public expr {};
+class ternary_operator:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class call_expr:public expr {};
+class binary_operator:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class call_hash:public expr {};
+class unary_operator:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class call_vector:public expr {};
+class call_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class call_function:public expr {};
+class call_hash:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class slice_vector:public expr {};
+class call_vector:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class definition:public expr {};
+class call_function:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class multi_define:public expr {};
+class slice_vector:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class while_expr:public expr {};
+class definition:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class for_expr:public expr {};
+class multi_define:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class foreach_expr:public expr {};
+class while_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class forindex_expr:public expr {};
+class for_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class condition_expr:public expr {};
+class foreach_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class if_expr:public expr {};
+class forindex_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class continue_expr:public expr {};
+class condition_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class break_expr:public expr {};
+class if_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
 
-class return_expr:public expr {};
+class continue_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
+
+class break_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
+
+class return_expr:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
diff --git a/ast/nasal_new_lexer.cpp b/ast/nasal_new_lexer.cpp
new file mode 100644
index 0000000..a476a91
--- /dev/null
+++ b/ast/nasal_new_lexer.cpp
@@ -0,0 +1,333 @@
+#ifdef _MSC_VER
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#pragma warning (disable:4102)
+#endif
+
+#include "nasal_new_lexer.h"
+
+bool lexer::skip(char c) {
+    return c==' '||c=='\n'||c=='\t'||c=='\r'||c==0;
+}
+
+bool lexer::is_id(char c) {
+    return (c=='_')||('a'<=c && c<='z')||('A'<=c&&c<='Z')||(c<0);   
+}
+
+bool lexer::is_hex(char c) {
+    return ('0'<=c&&c<='9')||('a'<=c&&c<='f')||('A'<=c && c<='F');
+}
+
+bool lexer::is_oct(char c) {
+    return '0'<=c&&c<='7';
+}
+
+bool lexer::is_dec(char c) {
+    return '0'<=c&&c<='9';
+}
+
+bool lexer::is_str(char c) {
+    return c=='\''||c=='\"'||c=='`';
+}
+
+bool lexer::is_single_opr(char c) {
+    return (
+        c=='('||c==')'||c=='['||c==']'||
+        c=='{'||c=='}'||c==','||c==';'||
+        c==':'||c=='?'||c=='`'||c=='@'||
+        c=='%'||c=='$'||c=='\\'
+    );
+}
+
+bool lexer::is_calc_opr(char c) {
+    return (
+        c=='='||c=='+'||c=='-'||c=='*'||
+        c=='!'||c=='/'||c=='<'||c=='>'||
+        c=='~'||c=='|'||c=='&'||c=='^'
+    );
+}
+
+void lexer::skip_note() {
+    // avoid note, after this process ptr will point to a '\n', so next loop line counter+1
+    while(++ptr<res.size() && res[ptr]!='\n') {}
+}
+
+void lexer::err_char() {
+    ++column;
+    char c=res[ptr++];
+    err.err("lexer", {line, column-1, line, column, filename}, "invalid character 0x"+chrhex(c));
+    err.fatal("lexer", "fatal error occurred, stop");
+}
+
+void lexer::open(const string& file) {
+    // check file exsits and it is a regular file
+    struct stat buffer;
+    if (stat(file.c_str(), &buffer)==0 && !S_ISREG(buffer.st_mode)) {
+        err.err("lexer", "<"+file+"> is not a regular file");
+        err.chkerr();
+    }
+
+    // load
+    filename=file;
+    std::ifstream in(file, std::ios::binary);
+    if (in.fail()) {
+        err.err("lexer", "failed to open <"+file+">");
+    } else {
+        err.load(file);
+    }
+    std::stringstream ss;
+    ss<<in.rdbuf();
+    res=ss.str();
+}
+
+tok lexer::get_type(const string& str) {
+    return typetbl.count(str)?typetbl.at(str):tok::null;
+}
+
+string lexer::utf8_gen() {
+    string str="";
+    while(ptr<res.size() && res[ptr]<0) {
+        string tmp="";
+        u32 nbytes=utf8_hdchk(res[ptr]);
+        if (!nbytes) {
+            ++ptr;
+            ++column;
+            continue;
+        }
+
+        tmp+=res[ptr++];
+        for(u32 i=0;i<nbytes;++i,++ptr) {
+            if (ptr<res.size() && (res[ptr]&0xc0)==0x80) {
+                tmp+=res[ptr];
+            }
+        }
+
+        // utf8 character's total length is 1+nbytes
+        if (tmp.length()!=1+nbytes) {
+            ++column;
+            string utf_info="0x"+chrhex(tmp[0]);
+            for(u32 i=1;i<tmp.size();++i) {
+                utf_info+=" 0x"+chrhex(tmp[i]);
+            }
+            err.err("lexer", {line, column-1, line, column, filename}, "invalid utf-8 <"+utf_info+">");
+            err.fatal("lexer", "fatal error occurred, stop");
+        }
+        str+=tmp;
+        column+=2; // may have some problems because not all the unicode takes 2 space
+    }
+    return str;
+}
+
+token lexer::id_gen() {
+    u32 begin_line=line;
+    u32 begin_column=column;
+    string str="";
+    while(ptr<res.size() && (is_id(res[ptr])||is_dec(res[ptr]))) {
+        if (res[ptr]<0) { // utf-8
+            str+=utf8_gen();
+        } else { // ascii
+            str+=res[ptr++];
+            ++column;
+        }
+    }
+    tok type=get_type(str);
+    return {{begin_line, begin_column, line, column, filename}, (type!=tok::null)?type:tok::id, str};
+}
+
+token lexer::num_gen() {
+    u32 begin_line=line;
+    u32 begin_column=column;
+    // generate hex number
+    if (ptr+1<res.size() && res[ptr]=='0' && res[ptr+1]=='x') {
+        string str="0x";
+        ptr+=2;
+        while(ptr<res.size() && is_hex(res[ptr])) {
+            str+=res[ptr++];
+        }
+        column+=str.length();
+        if (str.length()<3) { // "0x"
+            err.err("lexer", {begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
+        }
+        return {{begin_line, begin_column, line, column, filename}, tok::num, str};
+    } else if (ptr+1<res.size() && res[ptr]=='0' && res[ptr+1]=='o') { // generate oct number
+        string str="0o";
+        ptr+=2;
+        while(ptr<res.size() && is_oct(res[ptr])) {
+            str+=res[ptr++];
+        }
+        bool erfmt=false;
+        while(ptr<res.size() && (is_dec(res[ptr]) || is_hex(res[ptr]))) {
+            erfmt=true;
+            str+=res[ptr++];
+        }
+        column+=str.length();
+        if (str.length()==2 || erfmt) {
+            err.err("lexer", {begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
+        }
+        return {{begin_line, begin_column, line, column, filename}, tok::num, str};
+    }
+    // generate dec number
+    // dec number -> [0~9][0~9]*(.[0~9]*)(e|E(+|-)0|[1~9][0~9]*)
+    string str="";
+    while(ptr<res.size() && is_dec(res[ptr])) {
+        str+=res[ptr++];
+    }
+    if (ptr<res.size() && res[ptr]=='.') {
+        str+=res[ptr++];
+        while(ptr<res.size() && is_dec(res[ptr])) {
+            str+=res[ptr++];
+        }
+        // "xxxx." is not a correct number
+        if (str.back()=='.') {
+            column+=str.length();
+            err.err("lexer",{begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
+            return {{begin_line, begin_column, line, column, filename}, tok::num, "0"};
+        }
+    }
+    if (ptr<res.size() && (res[ptr]=='e' || res[ptr]=='E')) {
+        str+=res[ptr++];
+        if (ptr<res.size() && (res[ptr]=='-' || res[ptr]=='+')) {
+            str+=res[ptr++];
+        }
+        while(ptr<res.size() && is_dec(res[ptr])) {
+            str+=res[ptr++];
+        }
+        // "xxxe(-|+)" is not a correct number
+        if (str.back()=='e' || str.back()=='E' || str.back()=='-' || str.back()=='+') {
+            column+=str.length();
+            err.err("lexer",{begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
+            return {{begin_line, begin_column, line, column, filename}, tok::num, "0"};
+        }
+    }
+    column+=str.length();
+    return {{begin_line, begin_column, line, column, filename}, tok::num, str};
+}
+
+token lexer::str_gen() {
+    u32 begin_line=line;
+    u32 begin_column=column;
+    string str="";
+    const char begin=res[ptr];
+    ++column;
+    while(++ptr<res.size() && res[ptr]!=begin) {
+        ++column;
+        if (res[ptr]=='\n') {
+            column=0;
+            ++line;
+        }
+        if (res[ptr]=='\\' && ptr+1<res.size()) {
+            ++column;
+            ++ptr;
+            switch(res[ptr]) {
+                case '0': str+='\0';    break;
+                case 'a': str+='\a';    break;
+                case 'b': str+='\b';    break;
+                case 'e': str+='\033';  break;
+                case 't': str+='\t';    break;
+                case 'n': str+='\n';    break;
+                case 'v': str+='\v';    break;
+                case 'f': str+='\f';    break;
+                case 'r': str+='\r';    break;
+                case '?': str+='\?';    break;
+                case '\\':str+='\\';    break;
+                case '\'':str+='\'';    break;
+                case '\"':str+='\"';    break;
+                default:  str+=res[ptr];break;
+            }
+            if (res[ptr]=='\n') {
+                column=0;
+                ++line;
+            }
+            continue;
+        }
+        str+=res[ptr];
+    }
+    // check if this string ends with a " or '
+    if (ptr++>=res.size()) {
+        err.err("lexer", {begin_line, begin_column, line, column, filename}, "get EOF when generating string");
+        return {{begin_line, begin_column, line, column, filename}, tok::str, str};
+    }
+    ++column;
+    if (begin=='`' && str.length()!=1) {
+        err.err("lexer", {begin_line, begin_column, line, column, filename}, "\'`\' is used for string including one character");
+    }
+    return {{begin_line, begin_column, line, column, filename}, tok::str, str};
+}
+
+token lexer::single_opr() {
+    u32 begin_line=line;
+    u32 begin_column=column;
+    string str(1,res[ptr]);
+    ++column;
+    tok type=get_type(str);
+    if (type==tok::null) {
+        err.err("lexer", {begin_line, begin_column, line, column, filename}, "invalid operator `"+str+"`");
+    }
+    ++ptr;
+    return {{begin_line, begin_column, line, column, filename}, type, str};
+}
+
+token lexer::dots() {
+    u32 begin_line=line;
+    u32 begin_column=column;
+    string str=".";
+    if (ptr+2<res.size() && res[ptr+1]=='.' && res[ptr+2]=='.') {
+        str+="..";
+    }
+    ptr+=str.length();
+    column+=str.length();
+    return {{begin_line, begin_column, line, column, filename}, get_type(str), str};
+}
+
+token lexer::calc_opr() {
+    u32 begin_line=line;
+    u32 begin_column=column;
+    // get calculation operator
+    string str(1,res[ptr++]);
+    if (ptr<res.size() && res[ptr]=='=') {
+        str+=res[ptr++];
+    }
+    column+=str.length();
+    return {{begin_line, begin_column, line, column, filename}, get_type(str), str};
+}
+
+const error& lexer::scan(const string& file) {
+    line=1;
+    column=0;
+    ptr=0;
+    open(file);
+
+    while(ptr<res.size()) {
+        while(ptr<res.size() && skip(res[ptr])) {
+            // these characters will be ignored, and '\n' will cause ++line
+            ++column;
+            if (res[ptr++]=='\n') {
+                ++line;
+                column=0;
+            }
+        }
+        if (ptr>=res.size()) {
+            break;
+        }
+        if (is_id(res[ptr])) {
+            toks.push_back(id_gen());
+        } else if (is_dec(res[ptr])) {
+            toks.push_back(num_gen());
+        } else if (is_str(res[ptr])) {
+            toks.push_back(str_gen());
+        } else if (is_single_opr(res[ptr])) {
+            toks.push_back(single_opr());
+        } else if (res[ptr]=='.') {
+            toks.push_back(dots());
+        } else if (is_calc_opr(res[ptr])) {
+            toks.push_back(calc_opr());
+        } else if (res[ptr]=='#') {
+            skip_note();
+        } else {
+            err_char();
+        }
+    }
+    toks.push_back({{line, column, line, column, filename}, tok::eof, "<eof>"});
+    res="";
+    return err;
+}
diff --git a/ast/nasal_new_lexer.h b/ast/nasal_new_lexer.h
new file mode 100644
index 0000000..0f4adfd
--- /dev/null
+++ b/ast/nasal_new_lexer.h
@@ -0,0 +1,181 @@
+#pragma once
+
+#ifdef _MSC_VER
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#pragma warning (disable:4102)
+#endif
+
+#include <cstring>
+#include <sstream>
+#include <vector>
+#include <unordered_map>
+#include <sys/stat.h>
+
+#include "nasal.h"
+#include "nasal_err.h"
+
+#ifdef _MSC_VER
+#define S_ISREG(m) (((m)&0xF000)==0x8000)
+#endif
+
+enum class tok:u32 {
+    null=0,   // null token (default token type)
+    num,      // number literal
+    str,      // string literal
+    id,       // identifier
+    tktrue,   // keyword true
+    tkfalse,  // keyword false
+    rfor,     // loop keyword for
+    forindex, // loop keyword forindex
+    foreach,  // loop keyword foreach
+    rwhile,   // loop keyword while
+    var,      // keyword for definition
+    func,     // keyword for definition of function
+    brk,      // loop keyword break
+    cont,     // loop keyword continue
+    ret,      // function keyword return
+    rif,      // condition expression keyword if
+    elsif,    // condition expression keyword elsif
+    relse,    // condition expression keyword else
+    tknil,    // nil literal
+    lcurve,   // (
+    rcurve,   // )
+    lbracket, // [
+    rbracket, // ]
+    lbrace,   // {
+    rbrace,   // }
+    semi,     // ;
+    opand,    // operator and
+    opor,     // operator or
+    comma,    // ,
+    dot,      // .
+    ellipsis, // ...
+    quesmark, // ?
+    colon,    // :
+    add,      // operator +
+    sub,      // operator -
+    mult,     // operator *
+    div,      // operator /
+    floater,  // operator ~ and binary operator ~
+    btand,    // bitwise operator &
+    btor,     // bitwise operator |
+    btxor,    // bitwise operator ^
+    opnot,    // operator !
+    eq,       // operator =
+    addeq,    // operator +=
+    subeq,    // operator -=
+    multeq,   // operator *=
+    diveq,    // operator /=
+    lnkeq,    // operator ~=
+    btandeq,  // operator &=
+    btoreq,   // operator |=
+    btxoreq,  // operator ^=
+    cmpeq,    // operator ==
+    neq,      // operator !=
+    less,     // operator <
+    leq,      // operator <=
+    grt,      // operator >
+    geq,      // operator >=
+    eof       // <eof> end of token list
+};
+
+struct token {
+    span loc;    // location
+    tok type;    // token type
+    string str;  // content
+    token() = default;
+    token(const token&) = default;
+};
+
+class lexer {
+private:
+    u32    line;
+    u32    column;
+    usize  ptr;
+    string filename;
+    string res;
+    error& err;
+    std::vector<token> toks;
+    const std::unordered_map<string,tok> typetbl {
+        {"true"    ,tok::tktrue  },
+        {"false"   ,tok::tkfalse },
+        {"for"     ,tok::rfor    },
+        {"forindex",tok::forindex},
+        {"foreach" ,tok::foreach },
+        {"while"   ,tok::rwhile  },
+        {"var"     ,tok::var     },
+        {"func"    ,tok::func    },
+        {"break"   ,tok::brk     },
+        {"continue",tok::cont    },
+        {"return"  ,tok::ret     },
+        {"if"      ,tok::rif     },
+        {"elsif"   ,tok::elsif   },
+        {"else"    ,tok::relse   },
+        {"nil"     ,tok::tknil   },
+        {"("       ,tok::lcurve  },
+        {")"       ,tok::rcurve  },
+        {"["       ,tok::lbracket},
+        {"]"       ,tok::rbracket},
+        {"{"       ,tok::lbrace  },
+        {"}"       ,tok::rbrace  },
+        {";"       ,tok::semi    },
+        {"and"     ,tok::opand   },
+        {"or"      ,tok::opor    },
+        {","       ,tok::comma   },
+        {"."       ,tok::dot     },
+        {"..."     ,tok::ellipsis},
+        {"?"       ,tok::quesmark},
+        {":"       ,tok::colon   },
+        {"+"       ,tok::add     },
+        {"-"       ,tok::sub     },
+        {"*"       ,tok::mult    },
+        {"/"       ,tok::div     },
+        {"~"       ,tok::floater },
+        {"&"       ,tok::btand   },
+        {"|"       ,tok::btor    },
+        {"^"       ,tok::btxor   },
+        {"!"       ,tok::opnot   },
+        {"="       ,tok::eq      },
+        {"+="      ,tok::addeq   },
+        {"-="      ,tok::subeq   },
+        {"*="      ,tok::multeq  },
+        {"/="      ,tok::diveq   },
+        {"~="      ,tok::lnkeq   },
+        {"&="      ,tok::btandeq },
+        {"|="      ,tok::btoreq  },
+        {"^="      ,tok::btxoreq },
+        {"=="      ,tok::cmpeq   },
+        {"!="      ,tok::neq     },
+        {"<"       ,tok::less    },
+        {"<="      ,tok::leq     },
+        {">"       ,tok::grt     },
+        {">="      ,tok::geq     }
+    };
+
+    tok get_type(const string&);
+    bool skip(char);
+    bool is_id(char);
+    bool is_hex(char);
+    bool is_oct(char);
+    bool is_dec(char);
+    bool is_str(char);
+    bool is_single_opr(char);
+    bool is_calc_opr(char);
+
+    void skip_note();
+    void err_char();
+
+    void open(const string&);
+    string utf8_gen();
+    token id_gen();
+    token num_gen();
+    token str_gen();
+    token single_opr();
+    token dots();
+    token calc_opr();
+public:
+    lexer(error& e): line(1), column(0), ptr(0), filename(""), res(""), err(e) {}
+    const error& scan(const string&);
+    const std::vector<token>& result() const {return toks;}
+};
diff --git a/ast/new_main.cpp b/ast/new_main.cpp
new file mode 100644
index 0000000..aef7268
--- /dev/null
+++ b/ast/new_main.cpp
@@ -0,0 +1,176 @@
+#include "nasal.h"
+#include "nasal_err.h"
+#include "nasal_lexer.h"
+#include "nasal_ast.h"
+#include "nasal_parse.h"
+#include "nasal_import.h"
+#include "nasal_opt.h"
+#include "nasal_gc.h"
+#include "nasal_builtin.h"
+#include "nasal_codegen.h"
+#include "nasal_vm.h"
+#include "nasal_dbg.h"
+
+#include <unordered_map>
+
+const u32 VM_AST   =0x01;
+const u32 VM_CODE  =0x02;
+const u32 VM_TIME  =0x04;
+const u32 VM_EXEC  =0x08;
+const u32 VM_DETAIL=0x10;
+const u32 VM_DEBUG =0x20;
+
+std::ostream& help(std::ostream& out) {
+    out
+    <<"     ,--#-,\n"
+    <<"<3  / \\____\\  <3\n"
+    <<"    |_|__A_|\n"
+#ifdef _WIN32
+    <<"use command <chcp 65001> to use unicode.\n"
+#endif
+    <<"\nnasal <option>\n"
+    <<"option:\n"
+    <<"   -h,   --help   | get help.\n"
+    <<"\nnasal [option] <file> [argv]\n"
+    <<"option:\n"
+    <<"   -a,   --ast    | view abstract syntax tree.\n"
+    <<"   -c,   --code   | view bytecode.\n"
+    <<"   -e,   --exec   | execute.\n"
+    <<"   -t,   --time   | show execute time.\n"
+    <<"   -d,   --detail | get detail info.\n"
+    <<"   -dbg, --debug  | debug mode.\n"
+    <<"file:\n"
+    <<"   <filename>     | execute file.\n"
+    <<"argv:\n"
+    <<"   <args>         | cmd arguments used in program.\n";
+    return out;
+}
+
+std::ostream& logo(std::ostream& out) {
+    out
+    <<"       __                _\n"
+    <<"    /\\ \\ \\__ _ ___  __ _| |\n"
+    <<"   /  \\/ / _` / __|/ _` | |\n"
+    <<"  / /\\  / (_| \\__ \\ (_| | |\n"
+    <<"  \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
+    <<"ver  : "<<__nasver<<" ("<<__DATE__<<" "<<__TIME__<<")\n"
+    <<"std  : c++ "<<__cplusplus<<"\n"
+    <<"repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
+    <<"repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
+    <<"wiki : https://wiki.flightgear.org/Nasal_scripting_language\n"
+    <<"input <nasal -h> to get help .\n";
+    return out;
+}
+
+[[noreturn]]
+void err() {
+    std::cerr
+    <<"invalid argument(s).\n"
+    <<"use <nasal -h> to get help.\n";
+    std::exit(1);
+}
+
+void execute(
+    const string& file,
+    const std::vector<string>& argv,
+    const u32 cmd
+) {
+    using clk=std::chrono::high_resolution_clock;
+    const auto den=clk::duration::period::den;
+
+    error   err;
+    lexer   lex(err);
+    parse   parse(err);
+    linker  ld(err);
+    codegen gen(err);
+    vm      ctx;
+
+    // lexer scans file to get tokens
+    lex.scan(file).chkerr();
+
+    // parser gets lexer's token list to compile
+    parse.compile(lex).chkerr();
+
+    // linker gets parser's ast and load import files to this ast
+    ld.link(parse, file, cmd&VM_DETAIL).chkerr();
+
+    // optimizer does simple optimization on ast
+    optimize(parse.tree());
+    if (cmd&VM_AST) {
+        parse.tree().dump();
+    }
+
+    // code generator gets parser's ast and import file list to generate code
+    gen.compile(parse, ld).chkerr();
+    if (cmd&VM_CODE) {
+        gen.print();
+    }
+
+    // run
+    auto start=clk::now();
+    if (cmd&VM_DEBUG) {
+        dbg(err).run(gen, ld, argv);
+    } else if (cmd&VM_TIME || cmd&VM_EXEC) {
+        ctx.run(gen, ld, argv, cmd&VM_DETAIL);
+    }
+
+    // get running time
+    if (cmd&VM_TIME) {
+        f64 tm=(clk::now()-start).count()*1.0/den;
+        std::clog<<"process exited after "<<tm<<"s.\n\n";
+    }
+}
+
+i32 main(i32 argc, const char* argv[]) {
+    // output version info
+    if (argc<=1) {
+        std::clog<<logo;
+        return 0;
+    }
+
+    // run directly or show help
+    if (argc==2) {
+        string s(argv[1]);
+        if (s=="-h" || s=="--help") {
+            std::clog<<help;
+        } else if (s[0]!='-') {
+            execute(s, {}, VM_EXEC);
+        } else {
+            err();
+        }
+        return 0;
+    }
+
+    // execute with arguments
+    const std::unordered_map<string,u32> cmdlst={
+        {"--ast", VM_AST},
+        {"-a", VM_AST},
+        {"--code", VM_CODE},
+        {"-c", VM_CODE},
+        {"--exec", VM_EXEC},
+        {"-e", VM_EXEC},
+        {"--time", VM_TIME|VM_EXEC},
+        {"-t", VM_TIME|VM_EXEC},
+        {"--detail", VM_DETAIL|VM_EXEC},
+        {"-d", VM_DETAIL|VM_EXEC},
+        {"--debug", VM_DEBUG},
+        {"-dbg", VM_DEBUG}
+    };
+    u32 cmd=0;
+    string filename="";
+    std::vector<string> vm_argv;
+    for(i32 i=1; i<argc; ++i) {
+        if (cmdlst.count(argv[i])) {
+            cmd|=cmdlst.at(argv[i]);
+        } else if (!filename.length()) {
+            filename=argv[i];
+        } else {
+            vm_argv.push_back(argv[i]);
+        }
+    }
+    if (!filename.length()) {
+        err();
+    }
+    execute(filename, vm_argv, cmd?cmd:VM_EXEC);
+    return 0;
+}
\ No newline at end of file
diff --git a/makefile b/makefile
index b141816..ba986e7 100644
--- a/makefile
+++ b/makefile
@@ -18,12 +18,15 @@ SRC=\
 
 STD=c++14
 
-nasal:$(SRC) nasal_new_ast.o nasal_new_parse.o ast_visitor.o
+nasal:$(SRC) nasal_new_lexer.o nasal_new_ast.o nasal_new_parse.o ast_visitor.o
 	$(CXX) -std=$(STD) -O3 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
 
 nasal.exe:$(SRC)
 	$(CXX) -std=$(STD) -O3 main.cpp -o nasal.exe -fno-exceptions -Wshadow -Wall -static
 
+nasal_new_lexer.o: ast/nasal_new_lexer.h ast/nasal_new_lexer.cpp nasal.h
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.o -I .
+
 nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp nasal.h
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
 

From 7d8f199c8e7b87f0e5ead1d30d86d8df4363bebe Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sat, 17 Jun 2023 00:15:07 +0800
Subject: [PATCH 07/34] :sparkles: update

---
 ast/ast_visitor.cpp   | 19 +++++++++++++++++++
 ast/ast_visitor.h     |  3 +++
 ast/nasal_new_ast.cpp | 30 +++++++++++++++++++++++++++++
 ast/nasal_new_ast.h   | 44 +++++++++++++++++++++++++++++++++++++++----
 nasal_codegen.h       |  3 +++
 5 files changed, 95 insertions(+), 4 deletions(-)

diff --git a/ast/ast_visitor.cpp b/ast/ast_visitor.cpp
index 01b6f93..3931c29 100644
--- a/ast/ast_visitor.cpp
+++ b/ast/ast_visitor.cpp
@@ -26,4 +26,23 @@ bool ast_visitor::visit_identifier(identifier* node) {
 
 bool ast_visitor::visit_bool_literal(bool_literal* node) {
     return true;
+}
+
+bool ast_visitor::visit_vector_expr(vector_expr* node) {
+    for(auto i : node->get_elements()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_hash_expr(hash_expr* node) {
+    for(auto i : node->get_members()) {
+        i->accept(this);
+    }
+}
+
+bool ast_visitor::visit_hash_pair(hash_pair* node) {
+    if (node->get_element()) {
+        node->get_element()->accept(this);
+    }
 }
\ No newline at end of file
diff --git a/ast/ast_visitor.h b/ast/ast_visitor.h
index 94dd66c..92d42b2 100644
--- a/ast/ast_visitor.h
+++ b/ast/ast_visitor.h
@@ -11,4 +11,7 @@ public:
     virtual bool visit_string_literal(string_literal*);
     virtual bool visit_identifier(identifier*);
     virtual bool visit_bool_literal(bool_literal*);
+    virtual bool visit_vector_expr(vector_expr*);
+    virtual bool visit_hash_expr(hash_expr*);
+    virtual bool visit_hash_pair(hash_pair*);
 };
\ No newline at end of file
diff --git a/ast/nasal_new_ast.cpp b/ast/nasal_new_ast.cpp
index c34a1fe..8a5ef5c 100644
--- a/ast/nasal_new_ast.cpp
+++ b/ast/nasal_new_ast.cpp
@@ -27,4 +27,34 @@ void identifier::accept(ast_visitor* visitor) {
 
 void bool_literal::accept(ast_visitor* visitor) {
     visitor->visit_bool_literal(this);
+}
+
+vector_expr::~vector_expr() {
+    for(auto i : elements) {
+        delete i;
+    }
+}
+
+void vector_expr::accept(ast_visitor* visitor) {
+    visitor->visit_vector_expr(this);
+}
+
+hash_expr::~hash_expr() {
+    for(auto i : members) {
+        delete i;
+    }
+}
+
+void hash_expr::accept(ast_visitor* visitor) {
+    visitor->visit_hash_expr(this);
+}
+
+hash_pair::~hash_pair() {
+    if (element) {
+        delete element;
+    }
+}
+
+void hash_pair::accept(ast_visitor* visitor) {
+    visitor->visit_hash_pair(this);
 }
\ No newline at end of file
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index 1a6712c..c64d92b 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -3,6 +3,9 @@
 #include "nasal.h"
 #include "nasal_err.h"
 
+#include <vector>
+#include <unordered_map>
+
 enum class expr_type:u32 {
     ast_null=0,      // null node
     ast_expr,        // expression node
@@ -74,6 +77,7 @@ enum class expr_type:u32 {
 };
 
 class ast_visitor;
+class hash_pair;
 
 class expr {
 private:
@@ -115,10 +119,10 @@ public:
 
 class string_literal:public expr {
 private:
-    string content;
+    std::string content;
 
 public:
-    string_literal(const span& location, const string& str):
+    string_literal(const span& location, const std::string& str):
         expr(location, expr_type::ast_str), content(str) {}
     ~string_literal() = default;
     virtual void accept(ast_visitor*) override;
@@ -126,10 +130,10 @@ public:
 
 class identifier:public expr {
 private:
-    string name;
+    std::string name;
 
 public:
-    identifier(const span& location, const string& str):
+    identifier(const span& location, const std::string& str):
         expr(location, expr_type::ast_id), name(str) {}
     ~identifier() = default;
     virtual void accept(ast_visitor*) override;
@@ -147,17 +151,44 @@ public:
 };
 
 class vector_expr:public expr {
+private:
+    std::vector<expr*> elements;
+
 public:
+    vector_expr(const span& location):
+        expr(location, expr_type::ast_vec) {}
+    ~vector_expr();
+    void add_element(expr* node) {elements.push_back(node);}
+    std::vector<expr*>& get_elements() {return elements;}
     virtual void accept(ast_visitor*) override;
 };
 
 class hash_expr:public expr {
+private:
+    std::vector<hash_pair*> members;
+
 public:
+    hash_expr(const span& location):
+        expr(location, expr_type::ast_hash) {}
+    ~hash_expr();
+    void add_member(hash_pair* node) {members.push_back(node);}
+    std::vector<hash_pair*>& get_members() {return members;}
     virtual void accept(ast_visitor*) override;
 };
 
 class hash_pair:public expr {
+private:
+    std::string name;
+    expr* element;
+
 public:
+    hash_pair(const span& location):
+        expr(location, expr_type::ast_pair) {}
+    ~hash_pair();
+    void set_name(const std::string& field_name) {name = field_name;}
+    void set_element(expr* node) {element = node;}
+    const std::string& get_name() const {return name;}
+    expr* get_element() {return element;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -166,6 +197,11 @@ public:
     virtual void accept(ast_visitor*) override;
 };
 
+class code_block:public expr {
+public:
+    virtual void accept(ast_visitor*) override;
+};
+
 class parameter:public expr {
 public:
     virtual void accept(ast_visitor*) override;
diff --git a/nasal_codegen.h b/nasal_codegen.h
index ddae5b5..553e7c0 100644
--- a/nasal_codegen.h
+++ b/nasal_codegen.h
@@ -3,6 +3,9 @@
 #include "nasal_err.h"
 #include "nasal_builtin.h"
 #include "nasal_opcode.h"
+#include "nasal_ast.h"
+#include "nasal_parse.h"
+#include "nasal_import.h"
 
 #include <iomanip>
 #include <list>

From 78b7bec78638a8401ce37f1fe9b17e5c1a44cfc3 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sun, 18 Jun 2023 00:14:21 +0800
Subject: [PATCH 08/34] :sparkles: update

---
 ast/ast_visitor.cpp |  3 +++
 ast/nasal_new_ast.h | 37 +++++++++++++++++++++++++++++++++++--
 2 files changed, 38 insertions(+), 2 deletions(-)

diff --git a/ast/ast_visitor.cpp b/ast/ast_visitor.cpp
index 3931c29..017a0e7 100644
--- a/ast/ast_visitor.cpp
+++ b/ast/ast_visitor.cpp
@@ -2,6 +2,7 @@
 
 bool ast_visitor::visit_expr(expr* node) {
     node->accept(this);
+    return true;
 }
 
 bool ast_visitor::visit_null_expr(null_expr* node) {
@@ -39,10 +40,12 @@ bool ast_visitor::visit_hash_expr(hash_expr* node) {
     for(auto i : node->get_members()) {
         i->accept(this);
     }
+    return true;
 }
 
 bool ast_visitor::visit_hash_pair(hash_pair* node) {
     if (node->get_element()) {
         node->get_element()->accept(this);
     }
+    return true;
 }
\ No newline at end of file
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index c64d92b..d873d52 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -78,8 +78,15 @@ enum class expr_type:u32 {
 
 class ast_visitor;
 class hash_pair;
+class parameter;
+class code_block;
 
-class expr {
+class ast_abstract_node {
+public:
+    virtual void accept(ast_visitor*) = 0;
+};
+
+class expr:public ast_abstract_node {
 private:
     span nd_loc;
     expr_type nd_type;
@@ -87,7 +94,7 @@ public:
     expr(const span& location, expr_type node_type):
         nd_loc(location), nd_type(node_type) {}
     ~expr() = default;
-    virtual void accept(ast_visitor*) = 0;
+    virtual void accept(ast_visitor*);
 };
 
 class null_expr:public expr {
@@ -193,12 +200,32 @@ public:
 };
 
 class function:public expr {
+private:
+    std::vector<parameter*> parameter_list;
+    code_block* block;
+
 public:
+    function(const span& location):
+        expr(location, expr_type::ast_func),
+        block(nullptr) {}
+    ~function();
+    void add_parameter(parameter* node) {parameter_list.push_back(node);}
+    void set_code_block(code_block* node) {block = node;}
+    std::vector<parameter*>& get_parameter_list() {return parameter_list;}
+    code_block* get_code_block() {return block;}
     virtual void accept(ast_visitor*) override;
 };
 
 class code_block:public expr {
+private:
+    std::vector<expr*> expressions;
+
 public:
+    code_block(const span& location):
+        expr(location, expr_type::ast_block) {}
+    ~code_block();
+    void add_expression(expr* node) {expressions.push_back(node);}
+    std::vector<expr*>& get_expressions() {return expressions;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -289,11 +316,17 @@ public:
 
 class continue_expr:public expr {
 public:
+    continue_expr(const span& location):
+        expr(location, expr_type::ast_continue) {}
+    ~continue_expr() = default;
     virtual void accept(ast_visitor*) override;
 };
 
 class break_expr:public expr {
 public:
+    break_expr(const span& location):
+        expr(location, expr_type::ast_break) {}
+    ~break_expr() = default;
     virtual void accept(ast_visitor*) override;
 };
 

From bcf274aed4677c3f099cfb3b944b510e0ccd50ad Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Mon, 19 Jun 2023 00:10:14 +0800
Subject: [PATCH 09/34] :sparkles: update

---
 ast/nasal_new_ast.h     | 245 ++++++++++++++++++++++++++++++-----
 ast/nasal_new_parse.cpp | 281 ++++++++++++++++++++--------------------
 ast/nasal_new_parse.h   | 102 +++++++--------
 makefile                |   2 +-
 4 files changed, 406 insertions(+), 224 deletions(-)

diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index d873d52..db6bc8c 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -9,9 +9,7 @@
 enum class expr_type:u32 {
     ast_null=0,      // null node
     ast_expr,        // expression node
-    ast_root,        // mark the root node of ast
     ast_block,       // expression block 
-    ast_file,        // used to store which file the sub-tree is on, only used in main block
     ast_nil,         // nil keyword
     ast_num,         // number, basic value type
     ast_str,         // string, basic value type
@@ -26,11 +24,11 @@ enum class expr_type:u32 {
     ast_callv,       // id[index]
     ast_callf,       // id()
     ast_subvec,      // id[index:index]
-    ast_params,      // mark a sub-tree of function parameters
-    ast_default,     // default parameter
-    ast_dynamic,     // dynamic parameter
+
+    ast_param,       // function parameter
     ast_and,         // and keyword
     ast_or,          // or keyword
+
     ast_equal,       // =
     ast_addeq,       // +=
     ast_subeq,       // -=
@@ -40,37 +38,18 @@ enum class expr_type:u32 {
     ast_btandeq,     // &=
     ast_btoreq,      // |=
     ast_btxoreq,     // ^=
-    ast_cmpeq,       // ==
-    ast_neq,         // !=
-    ast_less,        // <
-    ast_leq,         // <=
-    ast_grt,         // >
-    ast_geq,         // >=
-    ast_add,         // +
-    ast_sub,         // -
-    ast_mult,        // *
-    ast_div,         // /
-    ast_link,        // ~
-    ast_neg,         // unary -
-    ast_lnot,        // unary !
-    ast_bnot,        // unary ~ bitwise not
-    ast_bitor,       // bitwise or
-    ast_bitxor,      // bitwise xor
-    ast_bitand,      // bitwise and
-    ast_trino,       // ?:
+
+    ast_ternary,
+    ast_binary,
+    ast_unary,
     ast_for,         // for keyword
-    ast_forindex,    // forindex keyword
-    ast_foreach,     // foreach keyword
+    ast_forei,       // foreach or forindex loop
     ast_while,       // while
     ast_iter,        // iterator, used in forindex/foreach
     ast_cond,        // mark a sub-tree of conditional expression
     ast_if,          // if keyword
-    ast_elsif,       // elsif keyword
-    ast_else,        // else keyword
     ast_multi_id,    // multi identifiers sub-tree
-    ast_tuple,       // tuple, only used in multiple assignment
     ast_def,         // definition
-    ast_multi_assign,// multi assignment sub-tree
     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
@@ -79,7 +58,9 @@ enum class expr_type:u32 {
 class ast_visitor;
 class hash_pair;
 class parameter;
+class multi_define;
 class code_block;
+class if_expr;
 
 class ast_abstract_node {
 public:
@@ -94,6 +75,12 @@ public:
     expr(const span& location, expr_type node_type):
         nd_loc(location), nd_type(node_type) {}
     ~expr() = default;
+    const span& get_location() const {return nd_loc;}
+    expr_type get_type() const {return nd_type;}
+    void update_location(const span& location) {
+        nd_loc.end_line = location.end_line;
+        nd_loc.end_column = location.end_column;
+    }
     virtual void accept(ast_visitor*);
 };
 
@@ -231,86 +218,267 @@ public:
 
 class parameter:public expr {
 public:
+    enum class param_type {
+        normal_parameter,
+        default_parameter,
+        dynamic_parameter
+    };
+
+private:
+    param_type type;
+    identifier* name;
+    expr* default_value;
+
+public:
+    parameter(const span& location):
+        expr(location, expr_type::ast_param),
+        name(nullptr), default_value(nullptr) {}
     virtual void accept(ast_visitor*) override;
 };
 
 class ternary_operator:public expr {
+private:
+    expr* condition;
+    expr* left;
+    expr* right;
+
 public:
+    ternary_operator(const span& location):
+        expr(location, expr_type::ast_ternary),
+        condition(nullptr), left(nullptr), right(nullptr) {}
     virtual void accept(ast_visitor*) override;
 };
 
 class binary_operator:public expr {
 public:
+    enum class binary_type {
+        add,
+        sub,
+        mult,
+        div,
+        concat,
+        cmpeq,
+        cmpneq,
+        less,
+        leq,
+        grt,
+        geq,
+        bitwise_or,
+        bitwise_xor,
+        bitwise_and
+    };
+
+private:
+    binary_type type;
+    expr* left;
+    expr* right;
+
+public:
+    binary_operator(const span& location):
+        expr(location, expr_type::ast_binary),
+        left(nullptr), right(nullptr) {}
     virtual void accept(ast_visitor*) override;
 };
 
 class unary_operator:public expr {
 public:
-    virtual void accept(ast_visitor*) override;
-};
+    enum class unary_type {
+        negative,
+        logical_not,
+        bitwise_not
+    };
+
+private:
+    unary_type type;
+    expr* value;
 
-class call_expr:public expr {
 public:
+    unary_operator(const span& location):
+        expr(location, expr_type::ast_unary),
+        value(nullptr) {}
     virtual void accept(ast_visitor*) override;
 };
 
 class call_hash:public expr {
+private:
+    std::string field;
+
 public:
+    call_hash(const span& location):
+        expr(location, expr_type::ast_callh),
+        field("") {}
     virtual void accept(ast_visitor*) override;
 };
 
 class call_vector:public expr {
+private:
+    std::vector<expr*> calls;
+
 public:
+    call_vector(const span& location):
+        expr(location, expr_type::ast_callv) {}
     virtual void accept(ast_visitor*) override;
 };
 
 class call_function:public expr {
 public:
+    call_function(const span& location):
+        expr(location, expr_type::ast_callf) {}
     virtual void accept(ast_visitor*) override;
 };
 
 class slice_vector:public expr {
+private:
+    expr* begin;
+    expr* end;
+
 public:
+    slice_vector(const span& location):
+        expr(location, expr_type::ast_subvec),
+        begin(nullptr), end(nullptr) {}
     virtual void accept(ast_visitor*) override;
 };
 
 class definition:public expr {
+private:
+    identifier* variable;
+    multi_define* variables;
+    expr* value;
+
 public:
+    definition(const span& location):
+        expr(location, expr_type::ast_def),
+        variable(nullptr), variables(nullptr), value(nullptr) {}
     virtual void accept(ast_visitor*) override;
 };
 
 class multi_define:public expr {
+private:
+    std::vector<expr*> variables;
+
 public:
+    multi_define(const span& location):
+        expr(location, expr_type::ast_multi_id) {}
     virtual void accept(ast_visitor*) override;
 };
 
 class while_expr:public expr {
+private:
+    expr* condition;
+    code_block* block;
+
 public:
+    while_expr(const span& location):
+        expr(location, expr_type::ast_while),
+        condition(nullptr), block(nullptr) {}
+    void set_condition(expr* node) {condition = node;}
+    void set_code_block (code_block* node) {block = node;}
+    expr* get_condition() {return condition;}
+    code_block* get_code_block() {return block;}
     virtual void accept(ast_visitor*) override;
 };
 
 class for_expr:public expr {
+private:
+    expr* initializing;
+    expr* condition;
+    expr* step;
+    code_block* block;
+
 public:
+    for_expr(const span& location):
+        expr(location, expr_type::ast_for),
+        initializing(nullptr), condition(nullptr),
+        step(nullptr), block(nullptr) {}
+    void set_initial(expr* node) {initializing = node;}
+    void set_condition(expr* node) {condition = node;}
+    void set_step(expr* node) {step = node;}
+    void set_code_block(code_block* node) {block = node;}
+    expr* get_initial() {return initializing;}
+    expr* get_condition() {return condition;}
+    expr* get_step() {return step;}
+    code_block* get_code_block() {return block;}
     virtual void accept(ast_visitor*) override;
 };
 
-class foreach_expr:public expr {
+class iter_expr:public expr {
+private:
+    identifier* name;
+    expr* value;
+
 public:
+    iter_expr(const span& location):
+        expr(location, expr_type::ast_iter),
+        name(nullptr), value(nullptr) {}
+    ~iter_expr();
+    void set_name(identifier* node) {name = node;}
+    void set_value(expr* node) {value = node;}
+    identifier* get_name() {return name;}
+    expr* get_value() {return value;}
     virtual void accept(ast_visitor*) override;
 };
 
-class forindex_expr:public expr {
+class forei_expr:public expr {
 public:
+    enum class forei_loop_type {
+        foreach,
+        forindex
+    };
+
+private:
+    forei_loop_type type;
+    iter_expr* iterator;
+    expr* vector_node;
+    code_block* block;
+
+public:
+    forei_expr(const span& location, forei_loop_type loop_type):
+        expr(location, expr_type::ast_forei),
+        type(loop_type), iterator(nullptr),
+        vector_node(nullptr), block(nullptr) {}
+    ~forei_expr();
+    void set_iterator(iter_expr* node) {iterator = node;}
+    void set_value(expr* node) {vector_node = node;}
+    void set_code_block(code_block* node) {block = node;}
+    iter_expr* get_iterator() {return iterator;}
+    expr* get_value() {return vector_node;}
+    code_block* get_code_block() {return block;}
     virtual void accept(ast_visitor*) override;
 };
 
 class condition_expr:public expr {
+private:
+    if_expr* if_stmt;
+    std::vector<if_expr*> elsif_stmt;
+    if_expr* else_stmt;
+
 public:
+    condition_expr(const span& location):
+        expr(location, expr_type::ast_cond),
+        if_stmt(nullptr), else_stmt(nullptr) {}
+    ~condition_expr();
+    void set_if_statement(if_expr* node) {if_stmt = node;}
+    void add_elsif_statement(if_expr* node) {elsif_stmt.push_back(node);}
+    void set_else_statement(if_expr* node) {else_stmt = node;}
+    if_expr* get_if_statement() {return if_stmt;}
+    std::vector<if_expr*>& get_elsif_stataments() {return elsif_stmt;}
+    if_expr* get_else_statement() {return else_stmt;}
     virtual void accept(ast_visitor*) override;
 };
 
 class if_expr:public expr {
+private:
+    expr* condition;
+    code_block* block;
+
 public:
+    if_expr(const span& location):
+        expr(location, expr_type::ast_if),
+        condition(nullptr), block(nullptr) {}
+    void set_condition(expr* node) {condition = node;}
+    void set_code_block(code_block* node) {block = node;}
+    expr* get_condition() {return condition;}
+    code_block* get_code_block() {return block;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -331,6 +499,15 @@ public:
 };
 
 class return_expr:public expr {
+private:
+    expr* value;
+
 public:
+    return_expr(const span& location):
+        expr(location, expr_type::ast_ret),
+        value(nullptr) {}
+    ~return_expr();
+    void set_value(expr* node) {value = node;}
+    expr* get_value() {return value;}
     virtual void accept(ast_visitor*) override;
 };
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index 5d7fc44..bfeb874 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -1,12 +1,14 @@
+#include "nasal_new_ast.h"
 #include "nasal_new_parse.h"
 
 const error& parse::compile(const lexer& lexer) {
     toks=lexer.result().data();
     ptr=in_func=in_loop=0;
 
-    root={toks[0].loc, ast_root};
+    root = new code_block(toks[0].loc);
+
     while(!lookahead(tok::eof)) {
-        root.add(expr());
+        root->add_expression(expr());
         if (lookahead(tok::semi)) {
             match(tok::semi);
         } else if (need_semi_check(root.child().back()) && !lookahead(tok::eof)) {
@@ -54,7 +56,7 @@ void parse::easter_egg() const {
     << "                    `\"`                   `\"`              \n";
 }
 
-void parse::die(const span& loc, string info) {
+void parse::die(const span& loc, std::string info) {
     err.err("parse", loc, info);
 }
 
@@ -123,15 +125,13 @@ bool parse::check_func_end(const ast& node) {
         return false;
     }
     if (node.child().empty() || (
-            type!=ast_def &&
-            type!=ast_equal &&
-            type!=ast_addeq &&
-            type!=ast_subeq &&
-            type!=ast_multeq &&
-            type!=ast_diveq &&
-            type!=ast_lnkeq
-        )
-    ) {
+        type!=ast_def &&
+        type!=ast_equal &&
+        type!=ast_addeq &&
+        type!=ast_subeq &&
+        type!=ast_multeq &&
+        type!=ast_diveq &&
+        type!=ast_lnkeq)) {
         return false;
     } else {
         return check_func_end(node.child().back());
@@ -163,46 +163,50 @@ bool parse::check_special_call() {
     return false;
 }
 
-bool parse::need_semi_check(const ast& node) {
-    u32 type=node.type();
-    if (type==ast_for || type==ast_foreach || type==ast_forindex || type==ast_while || type==ast_cond) {
+bool parse::need_semi_check(expr* node) {
+    auto type=node->get_type();
+    if (type==expr_type::ast_for ||
+        type==expr_type::ast_forei ||
+        type==expr_type::ast_while ||
+        type==expr_type::ast_cond) {
         return false;
     }
     return !check_func_end(node);
 }
 
-ast parse::null() {
-    return {toks[ptr].loc, ast_null};
+void parse::update_location(expr* node) {
+    node->update_location(toks[ptr].loc);
 }
 
-ast parse::nil() {
-    return {toks[ptr].loc, ast_nil};
+null_expr* parse::null() {
+    return new null_expr(toks[ptr].loc);
 }
 
-ast parse::num() {
-    ast node(toks[ptr].loc, ast_num);
-    node.set_num(str2num(toks[ptr].str.c_str()));
+nil_expr* parse::nil() {
+    return new nil_expr(toks[ptr].loc);
+}
+
+number_literal* parse::num() {
+    auto node = new number_literal(toks[ptr].loc,
+        str2num(toks[ptr].str.c_str()));
     match(tok::num);
     return node;
 }
 
-ast parse::str() {
-    ast node(toks[ptr].loc, ast_str);
-    node.set_str(toks[ptr].str);
+string_literal* parse::str() {
+    auto node = new string_literal(toks[ptr].loc, toks[ptr].str);
     match(tok::str);
     return node;
 }
 
-ast parse::id() {
-    ast node(toks[ptr].loc, ast_id);
-    node.set_str(toks[ptr].str);
+identifier* parse::id() {
+    auto node = new identifier(toks[ptr].loc, toks[ptr].str);
     match(tok::id);
     return node;
 }
 
-ast parse::bools() {
-    ast node(toks[ptr].loc, ast_bool);
-    node.set_str(toks[ptr].str);
+bool_literal* parse::bools() {
+    auto node = new bool_literal(toks[ptr].loc, toks[ptr].str=="true");
     if (lookahead(tok::tktrue)) {
         match(tok::tktrue);
     } else {
@@ -211,7 +215,7 @@ ast parse::bools() {
     return node;
 }
 
-ast parse::vec() {
+vector_expr* parse::vec() {
     // panic set for this token is not ','
     // this is the FIRST set of calculation
     // array end with tok::null=0
@@ -221,7 +225,7 @@ ast parse::vec() {
         tok::func,tok::var,tok::lcurve,tok::floater,
         tok::lbrace,tok::lbracket,tok::null
     };
-    ast node(toks[ptr].loc, ast_vec);
+    auto node = new vector_expr(toks[ptr].loc);
     match(tok::lbracket);
     while(!lookahead(tok::rbracket)) {
         node.add(calc());
@@ -233,16 +237,16 @@ ast parse::vec() {
             break;
         }
     }
-    node.update_span(thisspan);
+    update_location(node);
     match(tok::rbracket, "expected ']' when generating vector");
     return node;
 }
 
-ast parse::hash() {
-    ast node(toks[ptr].loc, ast_hash);
+hash_expr* parse::hash() {
+    auto node = new hash_expr(toks[ptr].loc);
     match(tok::lbrace);
     while(!lookahead(tok::rbrace)) {
-        node.add(pair());
+        node->add_member(pair());
         if (lookahead(tok::comma)) {
             match(tok::comma);
         } else if (lookahead(tok::id) || lookahead(tok::str)) { // first set of hashmember
@@ -251,46 +255,45 @@ ast parse::hash() {
             break;
         }
     }
-    node.update_span(thisspan);
+    update_location(node);
     match(tok::rbrace, "expected '}' when generating hash");
     return node;
 }
 
-ast parse::pair() {
-    ast node(toks[ptr].loc, ast_pair);
+hash_pair* parse::pair() {
+    auto node = new hash_pair(toks[ptr].loc);
     if (lookahead(tok::id)) {
-        node.add(id());
+        node->set_name(toks[ptr].str);
+        match(tok::id);
     } else if (lookahead(tok::str)) {
-        node.add(str());
+        node->set_name(toks[ptr].str);
+        match(tok::str);
     } else {
         match(tok::id, "expected hashmap key");
     }
     match(tok::colon);
-    node.add(calc());
-    node.update_span();
+    node->set_element(calc());
+    update_location(node);
     return node;
 }
 
-ast parse::func() {
+function* parse::func() {
     ++in_func;
-    ast node(toks[ptr].loc, ast_func);
+    auto node = new function(toks[ptr].loc);
     match(tok::func);
     if (lookahead(tok::lcurve)) {
-        node.add(params());
-    } else {
-        node.add(null());
+        params(node);
     }
-    node.add(exprs());
+    node->set_code_block(exprs());
     --in_func;
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::params() {
-    ast node(toks[ptr].loc, ast_params);
+void parse::params(function* func_node) {
     match(tok::lcurve);
     while(!lookahead(tok::rcurve)) {
-        ast tmp=id();
+        auto tmp = id();
         if (lookahead(tok::eq) || lookahead(tok::ellipsis)) {
             ast special_arg(toks[ptr].loc, ast_null);
             if (lookahead(tok::eq)) {
@@ -315,18 +318,18 @@ ast parse::params() {
             break;
         }
     }
-    node.update_span(thisspan);
+    update_location(node);
     match(tok::rcurve, "expected ')' after parameter list");
     return node;
 }
 
-ast parse::lcurve_expr() {
+expr* parse::lcurve_expr() {
     if (toks[ptr+1].type==tok::var)
         return definition();
     return check_tuple()?multi_assgin():calc();
 }
 
-ast parse::expr() {
+expr* parse::expression() {
     tok type=toks[ptr].type;
     if ((type==tok::brk || type==tok::cont) && !in_loop) {
         die(thisspan, "must use break/continue in loops");
@@ -346,18 +349,18 @@ ast parse::expr() {
         case tok::lbrace:
         case tok::sub:
         case tok::floater:
-        case tok::opnot:   return calc();          break;
-        case tok::var:     return definition();    break;
-        case tok::lcurve:  return lcurve_expr();   break;
+        case tok::opnot:   return calc();
+        case tok::var:     return definition();
+        case tok::lcurve:  return lcurve_expr();
         case tok::rfor:
         case tok::forindex:
         case tok::foreach:
-        case tok::rwhile:  return loop();          break;
-        case tok::rif:     return cond();          break;
-        case tok::cont:    return continue_expr(); break;
-        case tok::brk:     return break_expr();    break;
-        case tok::ret:     return ret_expr();      break;
-        case tok::semi:                            break;
+        case tok::rwhile:  return loop();
+        case tok::rif:     return cond();
+        case tok::cont:    return continue_expression();
+        case tok::brk:     return break_expression();
+        case tok::ret:     return return_expression();
+        case tok::semi: break;
         default:
             die(thisspan, "incorrect token <"+toks[ptr].str+">");
             next();
@@ -365,19 +368,19 @@ ast parse::expr() {
     }
 
     // unreachable
-    return {toks[ptr].loc, ast_null};
+    return new null_expr(toks[ptr].loc);
 }
 
-ast parse::exprs() {
+code_block* parse::expression_block() {
     if (lookahead(tok::eof)) {
         die(thisspan, "expected expression block");
-        return null();
+        return new code_block(toks[ptr].loc);
     }
-    ast node(toks[ptr].loc, ast_block);
+    auto node = new code_block(toks[ptr].loc);
     if (lookahead(tok::lbrace)) {
         match(tok::lbrace);
         while(!lookahead(tok::rbrace) && !lookahead(tok::eof)) {
-            node.add(expr());
+            node->add_expression(expression());
             if (lookahead(tok::semi)) {
                 match(tok::semi);
             } else if (need_semi_check(node.child().back()) && !lookahead(tok::rbrace)) {
@@ -387,15 +390,16 @@ ast parse::exprs() {
         }
         match(tok::rbrace, "expected '}' when generating expressions");
     } else {
-        node.add(expr());
-        if (lookahead(tok::semi))
+        node->add_expression(expression());
+        if (lookahead(tok::semi)) {
             match(tok::semi);
+        }
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::calc() {
+expr* parse::calc() {
     ast node=bitwise_or();
     if (lookahead(tok::quesmark)) {
         // trinocular calculation
@@ -420,11 +424,11 @@ ast parse::calc() {
         tmp.add(calc());
         node=std::move(tmp);
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::bitwise_or() {
+expr* parse::bitwise_or() {
     ast node=bitwise_xor();
     while(lookahead(tok::btor)) {
         ast tmp(toks[ptr].loc, ast_bitor);
@@ -434,11 +438,11 @@ ast parse::bitwise_or() {
         tmp.update_span();
         node=std::move(tmp);
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::bitwise_xor() {
+expr* parse::bitwise_xor() {
     ast node=bitwise_and();
     while(lookahead(tok::btxor)) {
         ast tmp(toks[ptr].loc, ast_bitxor);
@@ -448,11 +452,11 @@ ast parse::bitwise_xor() {
         tmp.update_span();
         node=std::move(tmp);
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::bitwise_and() {
+expr* parse::bitwise_and() {
     ast node=or_expr();
     while(lookahead(tok::btand)) {
         ast tmp(toks[ptr].loc, ast_bitand);
@@ -462,11 +466,11 @@ ast parse::bitwise_and() {
         tmp.update_span();
         node=std::move(tmp);
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::or_expr() {
+expr* parse::or_expr() {
     ast node=and_expr();
     while(lookahead(tok::opor)) {
         ast tmp(toks[ptr].loc, ast_or);
@@ -476,11 +480,11 @@ ast parse::or_expr() {
         tmp.update_span();
         node=std::move(tmp);
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::and_expr() {
+expr* parse::and_expr() {
     ast node=cmp_expr();
     while(lookahead(tok::opand)) {
         ast tmp(toks[ptr].loc, ast_and);
@@ -490,11 +494,11 @@ ast parse::and_expr() {
         tmp.update_span();
         node=std::move(tmp);
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::cmp_expr() {
+expr* parse::cmp_expr() {
     ast node=additive_expr();
     while(tok::cmpeq<=toks[ptr].type && toks[ptr].type<=tok::geq) {
         // tok::cmpeq~tok::geq is 43~48,ast_cmpeq~ast_geq is 27~32
@@ -505,11 +509,11 @@ ast parse::cmp_expr() {
         tmp.update_span();
         node=std::move(tmp);
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::additive_expr() {
+expr* parse::additive_expr() {
     ast node=multive_expr();
     while(lookahead(tok::add) || lookahead(tok::sub) || lookahead(tok::floater)) {
         ast tmp(toks[ptr].loc, ast_null);
@@ -525,11 +529,11 @@ ast parse::additive_expr() {
         tmp.update_span();
         node=std::move(tmp);
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::multive_expr() {
+expr* parse::multive_expr() {
     ast node=(lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar();
     while(lookahead(tok::mult) || lookahead(tok::div)) {
         ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::mult+ast_mult);
@@ -539,11 +543,11 @@ ast parse::multive_expr() {
         tmp.update_span();
         node=std::move(tmp);
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::unary() {
+expr* parse::unary() {
     ast node(toks[ptr].loc,ast_null);
     switch(toks[ptr].type) {
         case tok::sub:     node.set_type(ast_neg);match(tok::sub);break;
@@ -552,11 +556,11 @@ ast parse::unary() {
         default: break;
     }
     node.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::scalar() {
+expr* parse::scalar() {
     ast node(toks[ptr].loc, ast_null);
     if (lookahead(tok::tknil)) {
         node=nil();
@@ -580,7 +584,7 @@ ast parse::scalar() {
         match(tok::lcurve);
         node=calc();
         node.set_begin(loc.begin_line, loc.begin_column);
-        node.update_span(thisspan);
+        update_location(node);
         match(tok::rcurve);
     } else if (lookahead(tok::var)) {
         match(tok::var);
@@ -601,11 +605,11 @@ ast parse::scalar() {
             node.add(call_scalar());
         }
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::call_scalar() {
+expr* parse::call_scalar() {
     switch(toks[ptr].type) {
         case tok::lcurve:   return callf(); break;
         case tok::lbracket: return callv(); break;
@@ -616,7 +620,7 @@ ast parse::call_scalar() {
     return {toks[ptr].loc, ast_nil};
 }
 
-ast parse::callh() {
+expr* parse::callh() {
     ast node(toks[ptr].loc, ast_callh);
     match(tok::dot);
     node.set_str(toks[ptr].str);
@@ -625,7 +629,7 @@ ast parse::callh() {
     return node;
 }
 
-ast parse::callv() {
+expr* parse::callv() {
     // panic set for this token is not ','
     // this is the FIRST set of subvec
     // array end with tok::null=0
@@ -650,12 +654,12 @@ ast parse::callv() {
     if (node.size()==0) {
         die(thisspan, "expected index value");
     }
-    node.update_span(thisspan);
+    update_location(node);
     match(tok::rbracket, "expected ']' when calling vector");
     return node;
 }
 
-ast parse::callf() {
+expr* parse::callf() {
     // panic set for this token is not ','
     // this is the FIRST set of calculation/hashmember
     // array end with tok::null=0
@@ -677,12 +681,12 @@ ast parse::callf() {
         else if (!lookahead(tok::rcurve) && !check_comma(panic))
             break;
     }
-    node.update_span(thisspan);
+    update_location(node);
     match(tok::rcurve, "expected ')' when calling function");
     return node;
 }
 
-ast parse::subvec() {
+expr* parse::subvec() {
     ast node=lookahead(tok::colon)?nil():calc();
     if (lookahead(tok::colon)) {
         ast tmp(toks[ptr].loc, ast_subvec);
@@ -691,11 +695,11 @@ ast parse::subvec() {
         tmp.add((lookahead(tok::comma) || lookahead(tok::rbracket))?nil():calc());
         node=std::move(tmp);
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::definition() {
+expr* parse::definition() {
     ast node(toks[ptr].loc, ast_def);
     if (lookahead(tok::var)) {
         match(tok::var);
@@ -713,32 +717,32 @@ ast parse::definition() {
     } else {
         node.add(calc());
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::incurve_def() {
+expr* parse::incurve_def() {
     const auto& loc=toks[ptr].loc;
     match(tok::lcurve);
     match(tok::var);
     ast node=multi_id();
-    node.update_span(thisspan);
+    update_location(node);
     match(tok::rcurve);
     node.set_begin(loc.begin_line, loc.begin_column);
     return node;
 }
 
-ast parse::outcurve_def() {
+expr* parse::outcurve_def() {
     const auto& loc=toks[ptr].loc;
     match(tok::lcurve);
     ast node=multi_id();
-    node.update_span(thisspan);
+    update_location(node);
     match(tok::rcurve);
     node.set_begin(loc.begin_line, loc.begin_column);
     return node;
 }
 
-ast parse::multi_id() {
+expr* parse::multi_id() {
     ast node(toks[ptr].loc, ast_multi_id);
     while(!lookahead(tok::eof)) {
         // only identifier is allowed here
@@ -752,11 +756,11 @@ ast parse::multi_id() {
             break;
         }
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::multi_scalar() {
+expr* parse::multi_scalar() {
     // if check_call_memory is true,we will check if value called here can reach a memory space
     const tok panic[]={
         tok::id,tok::str,tok::num,tok::tktrue,
@@ -776,12 +780,12 @@ ast parse::multi_scalar() {
             break;
         }
     }
-    node.update_span(thisspan);
+    update_location(node);
     match(tok::rcurve, "expected ')' after multi-scalar");
     return node;
 }
 
-ast parse::multi_assgin() {
+expr* parse::multi_assgin() {
     ast node(toks[ptr].loc, ast_multi_assign);
     node.add(multi_scalar());
     match(tok::eq);
@@ -794,11 +798,11 @@ ast parse::multi_assgin() {
     } else {
         node.add(calc());
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::loop() {
+expr* parse::loop() {
     ++in_loop;
     ast node(toks[ptr].loc, ast_null);
     switch(toks[ptr].type) {
@@ -812,18 +816,18 @@ ast parse::loop() {
     return node;
 }
 
-ast parse::while_loop() {
+expr* parse::while_loop() {
     ast node(toks[ptr].loc, ast_while);
     match(tok::rwhile);
     match(tok::lcurve);
     node.add(calc());
     match(tok::rcurve);
     node.add(exprs());
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::for_loop() {
+expr* parse::for_loop() {
     ast node(toks[ptr].loc, ast_for);
     match(tok::rfor);
     match(tok::lcurve);
@@ -862,11 +866,11 @@ ast parse::for_loop() {
     }
     match(tok::rcurve);
     node.add(exprs());
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::forei_loop() {
+expr* parse::forei_loop() {
     ast node(toks[ptr].loc, ast_null);
     switch(toks[ptr].type) {
         case tok::forindex:node.set_type(ast_forindex);match(tok::forindex);break;
@@ -887,11 +891,11 @@ ast parse::forei_loop() {
     node.add(calc());
     match(tok::rcurve);
     node.add(exprs());
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::iter_gen() {
+expr* parse::iter_gen() {
     ast node(toks[ptr].loc, ast_null);
     if (lookahead(tok::var)) {
         match(tok::var);
@@ -904,11 +908,11 @@ ast parse::iter_gen() {
             node.add(call_scalar());
         }
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::cond() {
+expr* parse::cond() {
     ast node(toks[ptr].loc, ast_cond);
 
     // generate if
@@ -941,24 +945,24 @@ ast parse::cond() {
         elsenode.update_span();
         node.add(std::move(elsenode));
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
 
-ast parse::continue_expr() {
-    ast node(toks[ptr].loc, ast_continue);
+continue_expr* parse::continue_expression() {
+    auto node = new continue_expr(toks[ptr].loc);
     match(tok::cont);
     return node;
 }
 
-ast parse::break_expr() {
-    ast node(toks[ptr].loc, ast_break);
+break_expr* parse::break_expression() {
+    auto node = new break_expr(toks[ptr].loc);
     match(tok::brk);
     return node;
 }
 
-ast parse::ret_expr() {
-    ast node(toks[ptr].loc, ast_ret);
+return_expr* parse::return_expression() {
+    auto node = new return_expr(toks[ptr].loc);
     match(tok::ret);
     tok type=toks[ptr].type;
     if (type==tok::tknil || type==tok::num ||
@@ -966,10 +970,11 @@ ast parse::ret_expr() {
         type==tok::func || type==tok::sub ||
         type==tok::opnot || type==tok::lcurve ||
         type==tok::lbracket || type==tok::lbrace ||
-        type==tok::tktrue || type==tok::tkfalse
-    ) {
-        node.add(calc());
+        type==tok::tktrue || type==tok::tkfalse) {
+        node->set_value(calc());
+    } else {
+        node->set_value(nil());
     }
-    node.update_span();
+    update_location(node);
     return node;
 }
diff --git a/ast/nasal_new_parse.h b/ast/nasal_new_parse.h
index acf8212..5bd3c03 100644
--- a/ast/nasal_new_parse.h
+++ b/ast/nasal_new_parse.h
@@ -18,7 +18,7 @@ private:
     u32 in_func; // count function block
     u32 in_loop; // count loop block
     const token* toks;
-    ast root;
+    code_block* root;
     error& err;
 
 private:
@@ -77,7 +77,7 @@ private:
     };
 
 private:
-    void die(const span&,string);
+    void die(const span&,std::string);
     void next() {++ptr;}
     void match(tok type, const char* info=nullptr);
     bool lookahead(tok);
@@ -86,64 +86,64 @@ private:
     bool check_tuple();
     bool check_func_end(const ast&);
     bool check_special_call();
-    bool need_semi_check(const ast&);
+    bool need_semi_check(expr*);
+    void update_location(expr*);
 
 private:
-    ast null();
-    ast nil();
-    ast num();
-    ast str();
-    ast id();
-    ast bools();
-    ast vec();
-    ast hash();
-    ast pair();
-    ast func();
-    ast params();
-    ast lcurve_expr();
-    ast expr();
-    ast exprs();
-    ast calc();
-    ast bitwise_or();
-    ast bitwise_xor();
-    ast bitwise_and();
-    ast or_expr();
-    ast and_expr();
-    ast cmp_expr();
-    ast additive_expr();
-    ast multive_expr();
-    ast unary();
-    ast scalar();
-    ast call_scalar();
-    ast callh();
-    ast callv();
-    ast callf();
-    ast subvec();
-    ast definition();
-    ast incurve_def();
-    ast outcurve_def();
-    ast multi_id();
-    ast multi_scalar();
-    ast multi_assgin();
-    ast loop();
-    ast while_loop();
-    ast for_loop();
-    ast forei_loop();
-    ast iter_gen();
-    ast cond();
-    ast continue_expr();
-    ast break_expr();
-    ast ret_expr();
+    null_expr* null();
+    nil_expr* nil();
+    number_literal* num();
+    string_literal* str();
+    identifier* id();
+    bool_literal* bools();
+    vector_expr* vec();
+    hash_expr* hash();
+    hash_pair* pair();
+    function* func();
+    void params(function*);
+    expr* lcurve_expr();
+    expr* expression();
+    code_block* expression_block();
+    expr* calc();
+    expr* bitwise_or();
+    expr* bitwise_xor();
+    expr* bitwise_and();
+    expr* or_expr();
+    expr* and_expr();
+    expr* cmp_expr();
+    expr* additive_expr();
+    expr* multive_expr();
+    expr* unary();
+    expr* scalar();
+    expr* call_scalar();
+    expr* callh();
+    expr* callv();
+    expr* callf();
+    expr* subvec();
+    expr* definition();
+    expr* incurve_def();
+    expr* outcurve_def();
+    expr* multi_id();
+    expr* multi_scalar();
+    expr* multi_assgin();
+    expr* loop();
+    expr* while_loop();
+    expr* for_loop();
+    expr* forei_loop();
+    expr* iter_gen();
+    expr* cond();
+    continue_expr* continue_expression();
+    break_expr* break_expression();
+    return_expr* return_expression();
 
 public:
-    inline ast& tree() {return root;}
-    inline const ast& tree() const {return root;}
+    inline code_block* tree() {return root;}
 
 public:
     parse(error& e):
         ptr(0), in_func(0), in_loop(0),
         toks(nullptr),
-        root({0, 0, 0, 0, ""}, ast_root),
+        root(nullptr),
         err(e) {}
     const error& compile(const lexer&);
     void easter_egg() const;
diff --git a/makefile b/makefile
index ba986e7..160192e 100644
--- a/makefile
+++ b/makefile
@@ -31,7 +31,7 @@ nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp nasal.h
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
 
 nasal_new_parse.o: ast/nasal_new_parse.h ast/nasal_new_parse.cpp nasal.h ast/nasal_new_ast.h
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
+#	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_parse.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
 
 ast_visitor.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_visitor.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .

From c5d6a6694bb52e25a69d82d5913e3f486871461c Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Tue, 20 Jun 2023 00:01:50 +0800
Subject: [PATCH 10/34] :sparkles: update new parser

---
 ast/nasal_new_ast.h     |  46 ++++++++-
 ast/nasal_new_parse.cpp | 214 ++++++++++++++++++++++------------------
 ast/nasal_new_parse.h   |  34 +++----
 3 files changed, 174 insertions(+), 120 deletions(-)

diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index db6bc8c..9e3b260 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -58,6 +58,7 @@ enum class expr_type:u32 {
 class ast_visitor;
 class hash_pair;
 class parameter;
+class slice_vector;
 class multi_define;
 class code_block;
 class if_expr;
@@ -75,6 +76,10 @@ public:
     expr(const span& location, expr_type node_type):
         nd_loc(location), nd_type(node_type) {}
     ~expr() = default;
+    void set_begin(u32 line, u32 column) {
+        nd_loc.begin_line = line;
+        nd_loc.begin_column = column;
+    }
     const span& get_location() const {return nd_loc;}
     expr_type get_type() const {return nd_type;}
     void update_location(const span& location) {
@@ -233,6 +238,10 @@ public:
     parameter(const span& location):
         expr(location, expr_type::ast_param),
         name(nullptr), default_value(nullptr) {}
+    ~parameter();
+    void set_parameter_type(param_type pt) {type = pt;}
+    void set_parameter_name(identifier* node) {name = node;}
+    void set_default_value(expr* node) {default_value = node;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -246,6 +255,7 @@ public:
     ternary_operator(const span& location):
         expr(location, expr_type::ast_ternary),
         condition(nullptr), left(nullptr), right(nullptr) {}
+    ~ternary_operator();
     virtual void accept(ast_visitor*) override;
 };
 
@@ -277,6 +287,10 @@ public:
     binary_operator(const span& location):
         expr(location, expr_type::ast_binary),
         left(nullptr), right(nullptr) {}
+    ~binary_operator();
+    void set_type(binary_type operator_type) {type = operator_type;}
+    void set_left(expr* node) {left = node;}
+    void set_right(expr* node) {right = node;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -296,6 +310,9 @@ public:
     unary_operator(const span& location):
         expr(location, expr_type::ast_unary),
         value(nullptr) {}
+    ~unary_operator();
+    void set_type(unary_type operator_type) {type = operator_type;}
+    void set_value(expr* node) {value = node;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -304,26 +321,36 @@ private:
     std::string field;
 
 public:
-    call_hash(const span& location):
+    call_hash(const span& location, const std::string& name):
         expr(location, expr_type::ast_callh),
-        field("") {}
+        field(name) {}
+    ~call_hash();
     virtual void accept(ast_visitor*) override;
 };
 
 class call_vector:public expr {
 private:
-    std::vector<expr*> calls;
+    std::vector<slice_vector*> calls;
 
 public:
     call_vector(const span& location):
         expr(location, expr_type::ast_callv) {}
+    ~call_vector();
+    void add_slice(slice_vector* node) {calls.push_back(node);}
+    std::vector<slice_vector*>& get_slices() {return calls;}
     virtual void accept(ast_visitor*) override;
 };
 
 class call_function:public expr {
+private:
+    std::vector<expr*> args;
+
 public:
     call_function(const span& location):
         expr(location, expr_type::ast_callf) {}
+    ~call_function();
+    void add_argument(expr* node) {args.push_back(node);}
+    std::vector<expr*>& get_argument() {return args;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -336,6 +363,9 @@ public:
     slice_vector(const span& location):
         expr(location, expr_type::ast_subvec),
         begin(nullptr), end(nullptr) {}
+    ~slice_vector();
+    void set_begin(expr* node) {begin = node;}
+    void set_end(expr* node) {end = node;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -349,6 +379,7 @@ public:
     definition(const span& location):
         expr(location, expr_type::ast_def),
         variable(nullptr), variables(nullptr), value(nullptr) {}
+    ~definition();
     virtual void accept(ast_visitor*) override;
 };
 
@@ -359,6 +390,7 @@ private:
 public:
     multi_define(const span& location):
         expr(location, expr_type::ast_multi_id) {}
+    ~multi_define();
     virtual void accept(ast_visitor*) override;
 };
 
@@ -371,6 +403,7 @@ public:
     while_expr(const span& location):
         expr(location, expr_type::ast_while),
         condition(nullptr), block(nullptr) {}
+    ~while_expr();
     void set_condition(expr* node) {condition = node;}
     void set_code_block (code_block* node) {block = node;}
     expr* get_condition() {return condition;}
@@ -390,6 +423,7 @@ public:
         expr(location, expr_type::ast_for),
         initializing(nullptr), condition(nullptr),
         step(nullptr), block(nullptr) {}
+    ~for_expr();
     void set_initial(expr* node) {initializing = node;}
     void set_condition(expr* node) {condition = node;}
     void set_step(expr* node) {step = node;}
@@ -432,11 +466,12 @@ private:
     code_block* block;
 
 public:
-    forei_expr(const span& location, forei_loop_type loop_type):
+    forei_expr(const span& location):
         expr(location, expr_type::ast_forei),
-        type(loop_type), iterator(nullptr),
+        type(forei_loop_type::foreach), iterator(nullptr),
         vector_node(nullptr), block(nullptr) {}
     ~forei_expr();
+    void set_type(forei_loop_type ft) {type = ft;}
     void set_iterator(iter_expr* node) {iterator = node;}
     void set_value(expr* node) {vector_node = node;}
     void set_code_block(code_block* node) {block = node;}
@@ -475,6 +510,7 @@ public:
     if_expr(const span& location):
         expr(location, expr_type::ast_if),
         condition(nullptr), block(nullptr) {}
+    ~if_expr();
     void set_condition(expr* node) {condition = node;}
     void set_code_block(code_block* node) {block = node;}
     expr* get_condition() {return condition;}
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index bfeb874..85e2eed 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -8,15 +8,15 @@ const error& parse::compile(const lexer& lexer) {
     root = new code_block(toks[0].loc);
 
     while(!lookahead(tok::eof)) {
-        root->add_expression(expr());
+        root->add_expression(expression());
         if (lookahead(tok::semi)) {
             match(tok::semi);
-        } else if (need_semi_check(root.child().back()) && !lookahead(tok::eof)) {
+        } else if (need_semi_check(root->get_expressions().back()) && !lookahead(tok::eof)) {
             // the last expression can be recognized without semi
             die(prevspan, "expected \";\"");
         }
     }
-    root.update_span();
+    update_location(root);
     return err;
 }
 
@@ -228,7 +228,7 @@ vector_expr* parse::vec() {
     auto node = new vector_expr(toks[ptr].loc);
     match(tok::lbracket);
     while(!lookahead(tok::rbracket)) {
-        node.add(calc());
+        node->add_element(calc());
         if (lookahead(tok::comma)) {
             match(tok::comma);
         } else if (lookahead(tok::eof)) {
@@ -284,7 +284,7 @@ function* parse::func() {
     if (lookahead(tok::lcurve)) {
         params(node);
     }
-    node->set_code_block(exprs());
+    node->set_code_block(expression_block());
     --in_func;
     update_location(node);
     return node;
@@ -293,23 +293,23 @@ function* parse::func() {
 void parse::params(function* func_node) {
     match(tok::lcurve);
     while(!lookahead(tok::rcurve)) {
-        auto tmp = id();
+        auto param = new parameter(toks[ptr].loc);
+        param->set_parameter_name(id());
         if (lookahead(tok::eq) || lookahead(tok::ellipsis)) {
             ast special_arg(toks[ptr].loc, ast_null);
             if (lookahead(tok::eq)) {
                 match(tok::eq);
-                special_arg=std::move(tmp);
-                special_arg.set_type(ast_default);
-                special_arg.add(calc());
+                param->set_parameter_type(parameter::param_type::default_parameter);
+                param->set_default_value(calc());
             } else {
                 match(tok::ellipsis);
-                special_arg=std::move(tmp);
-                special_arg.set_type(ast_dynamic);
+                param->set_parameter_type(parameter::param_type::dynamic_parameter);
             }
-            node.add(std::move(special_arg));
         } else {
-            node.add(std::move(tmp));
+            param->set_parameter_type(parameter::param_type::normal_parameter);
         }
+        update_location(param);
+        func_node->add_parameter(param);
         if (lookahead(tok::comma)) {
             match(tok::comma);
         } else if (lookahead(tok::id)) { // first set of identifier
@@ -318,9 +318,9 @@ void parse::params(function* func_node) {
             break;
         }
     }
-    update_location(node);
+    update_location(func_node);
     match(tok::rcurve, "expected ')' after parameter list");
-    return node;
+    return;
 }
 
 expr* parse::lcurve_expr() {
@@ -383,7 +383,7 @@ code_block* parse::expression_block() {
             node->add_expression(expression());
             if (lookahead(tok::semi)) {
                 match(tok::semi);
-            } else if (need_semi_check(node.child().back()) && !lookahead(tok::rbrace)) {
+            } else if (need_semi_check(node->get_expressions().back()) && !lookahead(tok::rbrace)) {
                 // the last expression can be recognized without semi
                 die(prevspan, "expected ';'");
             }
@@ -400,7 +400,7 @@ code_block* parse::expression_block() {
 }
 
 expr* parse::calc() {
-    ast node=bitwise_or();
+    auto node = bitwise_or();
     if (lookahead(tok::quesmark)) {
         // trinocular calculation
         ast tmp(toks[ptr].loc, ast_trino);
@@ -428,7 +428,7 @@ expr* parse::calc() {
     return node;
 }
 
-expr* parse::bitwise_or() {
+binary_operator* parse::bitwise_or() {
     ast node=bitwise_xor();
     while(lookahead(tok::btor)) {
         ast tmp(toks[ptr].loc, ast_bitor);
@@ -442,7 +442,7 @@ expr* parse::bitwise_or() {
     return node;
 }
 
-expr* parse::bitwise_xor() {
+binary_operator* parse::bitwise_xor() {
     ast node=bitwise_and();
     while(lookahead(tok::btxor)) {
         ast tmp(toks[ptr].loc, ast_bitxor);
@@ -456,7 +456,7 @@ expr* parse::bitwise_xor() {
     return node;
 }
 
-expr* parse::bitwise_and() {
+binary_operator* parse::bitwise_and() {
     ast node=or_expr();
     while(lookahead(tok::btand)) {
         ast tmp(toks[ptr].loc, ast_bitand);
@@ -470,7 +470,7 @@ expr* parse::bitwise_and() {
     return node;
 }
 
-expr* parse::or_expr() {
+binary_operator* parse::or_expr() {
     ast node=and_expr();
     while(lookahead(tok::opor)) {
         ast tmp(toks[ptr].loc, ast_or);
@@ -484,7 +484,7 @@ expr* parse::or_expr() {
     return node;
 }
 
-expr* parse::and_expr() {
+binary_operator* parse::and_expr() {
     ast node=cmp_expr();
     while(lookahead(tok::opand)) {
         ast tmp(toks[ptr].loc, ast_and);
@@ -498,7 +498,7 @@ expr* parse::and_expr() {
     return node;
 }
 
-expr* parse::cmp_expr() {
+binary_operator* parse::cmp_expr() {
     ast node=additive_expr();
     while(tok::cmpeq<=toks[ptr].type && toks[ptr].type<=tok::geq) {
         // tok::cmpeq~tok::geq is 43~48,ast_cmpeq~ast_geq is 27~32
@@ -513,7 +513,7 @@ expr* parse::cmp_expr() {
     return node;
 }
 
-expr* parse::additive_expr() {
+binary_operator* parse::additive_expr() {
     ast node=multive_expr();
     while(lookahead(tok::add) || lookahead(tok::sub) || lookahead(tok::floater)) {
         ast tmp(toks[ptr].loc, ast_null);
@@ -534,34 +534,48 @@ expr* parse::additive_expr() {
 }
 
 expr* parse::multive_expr() {
-    ast node=(lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar();
+    expr* node=(lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar();
     while(lookahead(tok::mult) || lookahead(tok::div)) {
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::mult+ast_mult);
-        tmp.add(std::move(node));
+        auto tmp = new binary_operator(toks[ptr].loc);
+        if (lookahead(tok::mult)) {
+            tmp->set_type(binary_operator::binary_type::mult);
+        } else {
+            tmp->set_type(binary_operator::binary_type::div);
+        }
+        tmp->set_left(node);
         match(toks[ptr].type);
-        tmp.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
-        tmp.update_span();
-        node=std::move(tmp);
+        tmp->set_right((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
+        update_location(tmp);
+        node = tmp;
     }
     update_location(node);
     return node;
 }
 
-expr* parse::unary() {
-    ast node(toks[ptr].loc,ast_null);
+unary_operator* parse::unary() {
+    auto node = new unary_operator(toks[ptr].loc);
     switch(toks[ptr].type) {
-        case tok::sub:     node.set_type(ast_neg);match(tok::sub);break;
-        case tok::opnot:   node.set_type(ast_lnot);match(tok::opnot);break;
-        case tok::floater: node.set_type(ast_bnot);match(tok::floater);break;
+        case tok::sub:
+            node->set_type(unary_operator::unary_type::negative);
+            match(tok::sub);
+            break;
+        case tok::opnot:
+            node->set_type(unary_operator::unary_type::logical_not);
+            match(tok::opnot);
+            break;
+        case tok::floater:
+            node->set_type(unary_operator::unary_type::bitwise_not);
+            match(tok::floater);
+            break;
         default: break;
     }
-    node.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
+    node->set_value((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
     update_location(node);
     return node;
 }
 
 expr* parse::scalar() {
-    ast node(toks[ptr].loc, ast_null);
+    expr* node = nullptr;
     if (lookahead(tok::tknil)) {
         node=nil();
         match(tok::tknil);
@@ -583,7 +597,7 @@ expr* parse::scalar() {
         const auto& loc=toks[ptr].loc;
         match(tok::lcurve);
         node=calc();
-        node.set_begin(loc.begin_line, loc.begin_column);
+        node->set_begin(loc.begin_line, loc.begin_column);
         update_location(node);
         match(tok::rcurve);
     } else if (lookahead(tok::var)) {
@@ -617,19 +631,19 @@ expr* parse::call_scalar() {
         default: break;
     }
     // unreachable
-    return {toks[ptr].loc, ast_nil};
+    return null();
 }
 
-expr* parse::callh() {
-    ast node(toks[ptr].loc, ast_callh);
+call_hash* parse::callh() {
+    const auto& begin_loc = toks[ptr].loc;
     match(tok::dot);
-    node.set_str(toks[ptr].str);
-    node.set_end(toks[ptr].loc.end_line, toks[ptr].loc.end_column);
+    auto node = new call_hash(begin_loc, toks[ptr].str);
+    update_location(node);
     match(tok::id, "expected hashmap key"); // get key
     return node;
 }
 
-expr* parse::callv() {
+call_vector* parse::callv() {
     // panic set for this token is not ','
     // this is the FIRST set of subvec
     // array end with tok::null=0
@@ -639,10 +653,10 @@ expr* parse::callv() {
         tok::func,tok::var,tok::lcurve,tok::floater,
         tok::lbrace,tok::lbracket,tok::colon,tok::null
     };
-    ast node(toks[ptr].loc, ast_callv);
+    auto node = new call_vector(toks[ptr].loc);
     match(tok::lbracket);
     while(!lookahead(tok::rbracket)) {
-        node.add(subvec());
+        node->add_slice(subvec());
         if (lookahead(tok::comma)) {
             match(tok::comma);
         } else if (lookahead(tok::eof)) {
@@ -651,7 +665,7 @@ expr* parse::callv() {
             break;
         }
     }
-    if (node.size()==0) {
+    if (node->get_slices().size()==0) {
         die(thisspan, "expected index value");
     }
     update_location(node);
@@ -659,7 +673,7 @@ expr* parse::callv() {
     return node;
 }
 
-expr* parse::callf() {
+call_function* parse::callf() {
     // panic set for this token is not ','
     // this is the FIRST set of calculation/hashmember
     // array end with tok::null=0
@@ -669,11 +683,11 @@ expr* parse::callf() {
         tok::func,tok::var,tok::lcurve,tok::floater,
         tok::lbrace,tok::lbracket,tok::null
     };
-    ast node(toks[ptr].loc, ast_callf);
+    auto node = new call_function(toks[ptr].loc);
     bool special_call=check_special_call();
     match(tok::lcurve);
     while(!lookahead(tok::rcurve)) {
-        node.add(special_call?pair():calc());
+        node->add_argument(special_call?pair():calc());
         if (lookahead(tok::comma))
             match(tok::comma);
         else if (lookahead(tok::eof))
@@ -686,14 +700,12 @@ expr* parse::callf() {
     return node;
 }
 
-expr* parse::subvec() {
-    ast node=lookahead(tok::colon)?nil():calc();
+slice_vector* parse::subvec() {
+    auto node = new slice_vector(toks[ptr].loc);
+    node->set_begin(lookahead(tok::colon)?nil():calc());
     if (lookahead(tok::colon)) {
-        ast tmp(toks[ptr].loc, ast_subvec);
         match(tok::colon);
-        tmp.add(std::move(node));
-        tmp.add((lookahead(tok::comma) || lookahead(tok::rbracket))?nil():calc());
-        node=std::move(tmp);
+        node->set_end((lookahead(tok::comma) || lookahead(tok::rbracket))?nil():calc());
     }
     update_location(node);
     return node;
@@ -804,7 +816,7 @@ expr* parse::multi_assgin() {
 
 expr* parse::loop() {
     ++in_loop;
-    ast node(toks[ptr].loc, ast_null);
+    expr* node = nullptr;
     switch(toks[ptr].type) {
         case tok::rwhile:  node=while_loop(); break;
         case tok::rfor:    node=for_loop();   break;
@@ -816,19 +828,19 @@ expr* parse::loop() {
     return node;
 }
 
-expr* parse::while_loop() {
-    ast node(toks[ptr].loc, ast_while);
+while_expr* parse::while_loop() {
+    auto node = new while_expr(toks[ptr].loc);
     match(tok::rwhile);
     match(tok::lcurve);
-    node.add(calc());
+    node->set_condition(calc());
     match(tok::rcurve);
-    node.add(exprs());
+    node->set_code_block(expression_block());
     update_location(node);
     return node;
 }
 
-expr* parse::for_loop() {
-    ast node(toks[ptr].loc, ast_for);
+for_expr* parse::for_loop() {
+    auto node = new for_expr(toks[ptr].loc);
     match(tok::rfor);
     match(tok::lcurve);
     // first expression
@@ -836,13 +848,13 @@ expr* parse::for_loop() {
         die(thisspan, "expected definition");
     }
     if (lookahead(tok::semi)) {
-        node.add(null());
+        node->set_initial(null());
     } else if (lookahead(tok::var)) {
-        node.add(definition());
+        node->set_initial(definition());
     } else if (lookahead(tok::lcurve)) {
-        node.add(lcurve_expr());
+        node->set_initial(lcurve_expr());
     } else {
-        node.add(calc());
+        node->set_initial(calc());
     }
     match(tok::semi, "expected ';' in for(;;)");
     // conditional expression
@@ -850,9 +862,9 @@ expr* parse::for_loop() {
         die(thisspan, "expected conditional expr");
     }
     if (lookahead(tok::semi)) {
-        node.add(null());
+        node->set_condition(null());
     } else {
-        node.add(calc());
+        node->set_condition(calc());
     }
     match(tok::semi, "expected ';' in for(;;)");
     //after loop expression
@@ -860,21 +872,27 @@ expr* parse::for_loop() {
         die(thisspan, "expected calculation");
     }
     if (lookahead(tok::rcurve)) {
-        node.add(null());
+        node->set_step(null());
     } else {
-        node.add(calc());
+        node->set_step(calc());
     }
     match(tok::rcurve);
-    node.add(exprs());
+    node->set_code_block(expression_block());
     update_location(node);
     return node;
 }
 
-expr* parse::forei_loop() {
-    ast node(toks[ptr].loc, ast_null);
+forei_expr* parse::forei_loop() {
+    auto node = new forei_expr(toks[ptr].loc);
     switch(toks[ptr].type) {
-        case tok::forindex:node.set_type(ast_forindex);match(tok::forindex);break;
-        case tok::foreach: node.set_type(ast_foreach); match(tok::foreach); break;
+        case tok::forindex:
+            node->set_type(forei_expr::forei_loop_type::forindex);
+            match(tok::forindex);
+            break;
+        case tok::foreach: 
+            node->set_type(forei_expr::forei_loop_type::foreach);
+            match(tok::foreach);
+            break;
         default: break;
     }
     match(tok::lcurve);
@@ -883,24 +901,24 @@ expr* parse::forei_loop() {
     if (!lookahead(tok::var) && !lookahead(tok::id)) {
         die(thisspan, "expected iterator");
     }
-    node.add(iter_gen());
+    node->set_iterator(iter_gen());
     match(tok::semi, "expected ';' in foreach/forindex(iter;vector)");
     if (lookahead(tok::eof)) {
         die(thisspan, "expected vector");
     }
-    node.add(calc());
+    node->set_value(calc());
     match(tok::rcurve);
-    node.add(exprs());
+    node->set_code_block(expression_block());
     update_location(node);
     return node;
 }
 
-expr* parse::iter_gen() {
-    ast node(toks[ptr].loc, ast_null);
+iter_expr* parse::iter_gen() {
+    auto node = new iter_expr(toks[ptr].loc);
     if (lookahead(tok::var)) {
         match(tok::var);
         node.set_type(ast_iter);
-        node.add(id());
+        node->set_name(id());
     } else {
         node.set_type(ast_call);
         node.add(id());
@@ -912,38 +930,38 @@ expr* parse::iter_gen() {
     return node;
 }
 
-expr* parse::cond() {
-    ast node(toks[ptr].loc, ast_cond);
+condition_expr* parse::cond() {
+    auto node = new condition_expr(toks[ptr].loc);
 
     // generate if
-    ast ifnode(toks[ptr].loc, ast_if);
+    auto ifnode = new if_expr(toks[ptr].loc);
     match(tok::rif);
     match(tok::lcurve);
-    ifnode.add(calc());
+    ifnode->set_condition(calc());
     match(tok::rcurve);
-    ifnode.add(exprs());
-    ifnode.update_span();
-    node.add(std::move(ifnode));
+    ifnode->set_code_block(expression_block());
+    update_location(ifnode);
+    node->set_if_statement(ifnode);
 
     // generate elsif
     while(lookahead(tok::elsif)) {
-        ast elsifnode(toks[ptr].loc, ast_elsif);
+        auto elsifnode = new if_expr(toks[ptr].loc);
         match(tok::elsif);
         match(tok::lcurve);
-        elsifnode.add(calc());
+        elsifnode->set_condition(calc());
         match(tok::rcurve);
-        elsifnode.add(exprs());
-        elsifnode.update_span();
-        node.add(std::move(elsifnode));
+        elsifnode->set_code_block(expression_block());
+        update_location(elsifnode);
+        node->add_elsif_statement(elsifnode);
     }
 
     // generate else
     if (lookahead(tok::relse)) {
-        ast elsenode(toks[ptr].loc, ast_else);
+        auto elsenode = new if_expr(toks[ptr].loc);
         match(tok::relse);
-        elsenode.add(exprs());
-        elsenode.update_span();
-        node.add(std::move(elsenode));
+        elsenode->set_code_block(expression_block());
+        update_location(elsenode);
+        node->set_else_statement(elsenode);
     }
     update_location(node);
     return node;
diff --git a/ast/nasal_new_parse.h b/ast/nasal_new_parse.h
index 5bd3c03..5f3f9a2 100644
--- a/ast/nasal_new_parse.h
+++ b/ast/nasal_new_parse.h
@@ -105,21 +105,21 @@ private:
     expr* expression();
     code_block* expression_block();
     expr* calc();
-    expr* bitwise_or();
-    expr* bitwise_xor();
-    expr* bitwise_and();
-    expr* or_expr();
-    expr* and_expr();
-    expr* cmp_expr();
-    expr* additive_expr();
+    binary_operator* bitwise_or();
+    binary_operator* bitwise_xor();
+    binary_operator* bitwise_and();
+    binary_operator* or_expr();
+    binary_operator* and_expr();
+    binary_operator* cmp_expr();
+    binary_operator* additive_expr();
     expr* multive_expr();
-    expr* unary();
+    unary_operator* unary();
     expr* scalar();
     expr* call_scalar();
-    expr* callh();
-    expr* callv();
-    expr* callf();
-    expr* subvec();
+    call_hash* callh();
+    call_vector* callv();
+    call_function* callf();
+    slice_vector* subvec();
     expr* definition();
     expr* incurve_def();
     expr* outcurve_def();
@@ -127,11 +127,11 @@ private:
     expr* multi_scalar();
     expr* multi_assgin();
     expr* loop();
-    expr* while_loop();
-    expr* for_loop();
-    expr* forei_loop();
-    expr* iter_gen();
-    expr* cond();
+    while_expr* while_loop();
+    for_expr* for_loop();
+    forei_expr* forei_loop();
+    iter_expr* iter_gen();
+    condition_expr* cond();
     continue_expr* continue_expression();
     break_expr* break_expression();
     return_expr* return_expression();

From ac49c0d6769707983f01dfdd4cabc1ced26c3a39 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Wed, 21 Jun 2023 00:03:46 +0800
Subject: [PATCH 11/34] :sparkles: update

---
 ast/nasal_new_ast.h     | 58 +++++++++++++++++++++++++++++----
 ast/nasal_new_parse.cpp | 71 ++++++++++++++++++++++-------------------
 ast/nasal_new_parse.h   | 12 +++----
 ast/new_main.cpp        |  2 ++
 nasal_parse.h           |  6 ++--
 5 files changed, 100 insertions(+), 49 deletions(-)

diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index 9e3b260..e39b78f 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -49,7 +49,9 @@ 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_def,         // definition
+    ast_multi_assign,
     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
@@ -316,6 +318,21 @@ public:
     virtual void accept(ast_visitor*) override;
 };
 
+class call_expr:public expr {
+private:
+    expr* first;
+    std::vector<expr*> calls;
+
+public:
+    call_expr(const span& location):
+        expr(location, expr_type::ast_call),
+        first(nullptr) {}
+    ~call_expr();
+    void set_first(expr* node) {first = node;}
+    void add_call(expr* node) {calls.push_back(node);}
+    virtual void accept(ast_visitor*) override;
+};
+
 class call_hash:public expr {
 private:
     std::string field;
@@ -369,17 +386,17 @@ public:
     virtual void accept(ast_visitor*) override;
 };
 
-class definition:public expr {
+class definition_expr:public expr {
 private:
     identifier* variable;
     multi_define* variables;
     expr* value;
 
 public:
-    definition(const span& location):
+    definition_expr(const span& location):
         expr(location, expr_type::ast_def),
         variable(nullptr), variables(nullptr), value(nullptr) {}
-    ~definition();
+    ~definition_expr();
     virtual void accept(ast_visitor*) override;
 };
 
@@ -391,6 +408,33 @@ public:
     multi_define(const span& location):
         expr(location, expr_type::ast_multi_id) {}
     ~multi_define();
+    void add_var(expr* node) {variables.push_back(node);}
+    virtual void accept(ast_visitor*) override;
+};
+
+class tuple_expr:public expr {
+private:
+    std::vector<expr*> elements;
+
+public:
+    tuple_expr(const span& location):
+        expr(location, expr_type::ast_tuple) {}
+    ~tuple_expr();
+    void add_element(expr* node) {elements.push_back(node);}
+    virtual void accept(ast_visitor*) override;
+};
+
+class multi_assign:public expr {
+private:
+    tuple_expr* left;
+    expr* right;
+
+public:
+    multi_assign(const span& location):
+        expr(location, expr_type::ast_multi_assign) {}
+    ~multi_assign();
+    void set_left(tuple_expr* node) {left = node;}
+    void set_right(expr* node) {right = node;}
     virtual void accept(ast_visitor*) override;
 };
 
@@ -438,17 +482,17 @@ public:
 class iter_expr:public expr {
 private:
     identifier* name;
-    expr* value;
+    expr* call;
 
 public:
     iter_expr(const span& location):
         expr(location, expr_type::ast_iter),
-        name(nullptr), value(nullptr) {}
+        name(nullptr), call(nullptr) {}
     ~iter_expr();
     void set_name(identifier* node) {name = node;}
-    void set_value(expr* node) {value = node;}
+    void set_call(expr* node) {call = node;}
     identifier* get_name() {return name;}
-    expr* get_value() {return value;}
+    expr* get_call() {return call;}
     virtual void accept(ast_visitor*) override;
 };
 
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index 85e2eed..1cd9dbe 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -117,21 +117,26 @@ bool parse::check_tuple() {
     return false;
 }
 
-bool parse::check_func_end(const ast& node) {
-    u32 type=node.type();
-    if (type==ast_func) {
+bool parse::check_func_end(expr* node) {
+    auto type=node->get_type();
+    if (type==expr_type::ast_func) {
         return true;
-    } else if (type==ast_num || type==ast_id || type==ast_str || type==ast_nil || type==ast_vec || type==ast_hash) {
+    } else if (type==expr_type::ast_num ||
+        type==expr_type::ast_id ||
+        type==expr_type::ast_str ||
+        type==expr_type::ast_nil ||
+        type==expr_type::ast_vec ||
+        type==expr_type::ast_hash) {
         return false;
     }
     if (node.child().empty() || (
-        type!=ast_def &&
-        type!=ast_equal &&
-        type!=ast_addeq &&
-        type!=ast_subeq &&
-        type!=ast_multeq &&
-        type!=ast_diveq &&
-        type!=ast_lnkeq)) {
+        type!=expr_type::ast_def &&
+        type!=expr_type::ast_equal &&
+        type!=expr_type::ast_addeq &&
+        type!=expr_type::ast_subeq &&
+        type!=expr_type::ast_multeq &&
+        type!=expr_type::ast_diveq &&
+        type!=expr_type::ast_lnkeq)) {
         return false;
     } else {
         return check_func_end(node.child().back());
@@ -326,7 +331,7 @@ void parse::params(function* func_node) {
 expr* parse::lcurve_expr() {
     if (toks[ptr+1].type==tok::var)
         return definition();
-    return check_tuple()?multi_assgin():calc();
+    return check_tuple()?multi_assignment():calc();
 }
 
 expr* parse::expression() {
@@ -712,7 +717,7 @@ slice_vector* parse::subvec() {
 }
 
 expr* parse::definition() {
-    ast node(toks[ptr].loc, ast_def);
+    auto node = new definition_expr(toks[ptr].loc);
     if (lookahead(tok::var)) {
         match(tok::var);
         switch(toks[ptr].type) {
@@ -733,33 +738,33 @@ expr* parse::definition() {
     return node;
 }
 
-expr* parse::incurve_def() {
+multi_define* parse::incurve_def() {
     const auto& loc=toks[ptr].loc;
     match(tok::lcurve);
     match(tok::var);
-    ast node=multi_id();
+    auto node = multi_id();
     update_location(node);
     match(tok::rcurve);
-    node.set_begin(loc.begin_line, loc.begin_column);
+    node->set_begin(loc.begin_line, loc.begin_column);
     return node;
 }
 
-expr* parse::outcurve_def() {
+multi_define* parse::outcurve_def() {
     const auto& loc=toks[ptr].loc;
     match(tok::lcurve);
-    ast node=multi_id();
+    auto node = multi_id();
     update_location(node);
     match(tok::rcurve);
-    node.set_begin(loc.begin_line, loc.begin_column);
+    node->set_begin(loc.begin_line, loc.begin_column);
     return node;
 }
 
 expr* parse::multi_id() {
-    ast node(toks[ptr].loc, ast_multi_id);
+    auto node = new multi_define(toks[ptr].loc);
     while(!lookahead(tok::eof)) {
         // only identifier is allowed here
         // but we check it at codegen stage
-        node.add(calc());
+        node->add_var(calc());
         if (lookahead(tok::comma)) {
             match(tok::comma);
         } else if (lookahead(tok::id)) { // first set of identifier
@@ -772,7 +777,7 @@ expr* parse::multi_id() {
     return node;
 }
 
-expr* parse::multi_scalar() {
+tuple_expr* parse::multi_scalar() {
     // if check_call_memory is true,we will check if value called here can reach a memory space
     const tok panic[]={
         tok::id,tok::str,tok::num,tok::tktrue,
@@ -780,10 +785,10 @@ expr* parse::multi_scalar() {
         tok::func,tok::var,tok::lcurve,tok::floater,
         tok::lbrace,tok::lbracket,tok::null
     };
-    ast node(toks[ptr].loc, ast_tuple);
+    auto node = new tuple_expr(toks[ptr].loc);
     match(tok::lcurve);
     while(!lookahead(tok::rcurve)) {
-        node.add(calc());
+        node->add_element(calc());
         if (lookahead(tok::comma)) {
             match(tok::comma);
         } else if (lookahead(tok::eof)) {
@@ -797,18 +802,18 @@ expr* parse::multi_scalar() {
     return node;
 }
 
-expr* parse::multi_assgin() {
-    ast node(toks[ptr].loc, ast_multi_assign);
-    node.add(multi_scalar());
+multi_assign* parse::multi_assignment() {
+    auto node = new multi_assign(toks[ptr].loc);
+    node->set_left(multi_scalar());
     match(tok::eq);
     if (lookahead(tok::eof)) {
         die(thisspan, "expected value list");
         return node;
     }
     if (lookahead(tok::lcurve)) {
-        node.add(check_tuple()?multi_scalar():calc());
+        node->set_right(check_tuple()?multi_scalar():calc());
     } else {
-        node.add(calc());
+        node->set_right(calc());
     }
     update_location(node);
     return node;
@@ -917,14 +922,14 @@ iter_expr* parse::iter_gen() {
     auto node = new iter_expr(toks[ptr].loc);
     if (lookahead(tok::var)) {
         match(tok::var);
-        node.set_type(ast_iter);
         node->set_name(id());
     } else {
-        node.set_type(ast_call);
-        node.add(id());
+        auto tmp = new call_expr(toks[ptr].loc);
+        tmp->set_first(id());
         while(is_call(toks[ptr].type)) {
-            node.add(call_scalar());
+            tmp->add_call(call_scalar());
         }
+        node->set_call(tmp);
     }
     update_location(node);
     return node;
diff --git a/ast/nasal_new_parse.h b/ast/nasal_new_parse.h
index 5f3f9a2..8addbe3 100644
--- a/ast/nasal_new_parse.h
+++ b/ast/nasal_new_parse.h
@@ -84,7 +84,7 @@ private:
     bool is_call(tok);
     bool check_comma(const tok*);
     bool check_tuple();
-    bool check_func_end(const ast&);
+    bool check_func_end(expr*);
     bool check_special_call();
     bool need_semi_check(expr*);
     void update_location(expr*);
@@ -121,11 +121,11 @@ private:
     call_function* callf();
     slice_vector* subvec();
     expr* definition();
-    expr* incurve_def();
-    expr* outcurve_def();
-    expr* multi_id();
-    expr* multi_scalar();
-    expr* multi_assgin();
+    multi_define* incurve_def();
+    multi_define* outcurve_def();
+    multi_define* multi_id();
+    tuple_expr* multi_scalar();
+    multi_assign* multi_assignment();
     expr* loop();
     while_expr* while_loop();
     for_expr* for_loop();
diff --git a/ast/new_main.cpp b/ast/new_main.cpp
index aef7268..f1eb2b3 100644
--- a/ast/new_main.cpp
+++ b/ast/new_main.cpp
@@ -12,6 +12,7 @@
 #include "nasal_dbg.h"
 
 #include <unordered_map>
+#include <thread>
 
 const u32 VM_AST   =0x01;
 const u32 VM_CODE  =0x02;
@@ -55,6 +56,7 @@ std::ostream& logo(std::ostream& out) {
     <<"  \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
     <<"ver  : "<<__nasver<<" ("<<__DATE__<<" "<<__TIME__<<")\n"
     <<"std  : c++ "<<__cplusplus<<"\n"
+    <<"core : "<<std::thread::hardware_concurrency()<<" cores\n"
     <<"repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
     <<"repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
     <<"wiki : https://wiki.flightgear.org/Nasal_scripting_language\n"
diff --git a/nasal_parse.h b/nasal_parse.h
index 8d7e6e9..d79e165 100644
--- a/nasal_parse.h
+++ b/nasal_parse.h
@@ -151,7 +151,7 @@ private:
     ast outcurve_def();
     ast multi_id();
     ast multi_scalar();
-    ast multi_assgin();
+    ast multi_assign();
     ast loop();
     ast while_loop();
     ast for_loop();
@@ -459,7 +459,7 @@ ast parse::params() {
 ast parse::lcurve_expr() {
     if (toks[ptr+1].type==tok::var)
         return definition();
-    return check_tuple()?multi_assgin():calc();
+    return check_tuple()?multi_assign():calc();
 }
 
 ast parse::expr() {
@@ -917,7 +917,7 @@ ast parse::multi_scalar() {
     return node;
 }
 
-ast parse::multi_assgin() {
+ast parse::multi_assign() {
     ast node(toks[ptr].loc, ast_multi_assign);
     node.add(multi_scalar());
     match(tok::eq);

From 0132ca0870d427e1a750edd6dfdc25dbf5cb606d Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sat, 24 Jun 2023 00:30:50 +0800
Subject: [PATCH 12/34] :sparkles: update

---
 ast/nasal_new_ast.h     |  85 ++++++++++---------
 ast/nasal_new_parse.cpp | 177 ++++++++++++++++++++++------------------
 ast/nasal_new_parse.h   |  14 ++--
 3 files changed, 151 insertions(+), 125 deletions(-)

diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index e39b78f..ab38ba4 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -96,7 +96,7 @@ public:
     null_expr(const span& location):
         expr(location, expr_type::ast_null) {}
     ~null_expr() = default;
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class nil_expr:public expr {
@@ -104,7 +104,7 @@ public:
     nil_expr(const span& location):
         expr(location, expr_type::ast_nil) {}
     ~nil_expr() = default;
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class number_literal:public expr {
@@ -115,7 +115,7 @@ public:
     number_literal(const span& location, const f64 num):
         expr(location, expr_type::ast_num), number(num) {}
     ~number_literal() = default;
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class string_literal:public expr {
@@ -126,7 +126,7 @@ public:
     string_literal(const span& location, const std::string& str):
         expr(location, expr_type::ast_str), content(str) {}
     ~string_literal() = default;
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class identifier:public expr {
@@ -137,7 +137,7 @@ public:
     identifier(const span& location, const std::string& str):
         expr(location, expr_type::ast_id), name(str) {}
     ~identifier() = default;
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class bool_literal:public expr {
@@ -148,7 +148,7 @@ public:
     bool_literal(const span& location, const bool bool_flag):
         expr(location, expr_type::ast_bool), flag(bool_flag) {}
     ~bool_literal() = default;
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class vector_expr:public expr {
@@ -161,7 +161,7 @@ public:
     ~vector_expr();
     void add_element(expr* node) {elements.push_back(node);}
     std::vector<expr*>& get_elements() {return elements;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class hash_expr:public expr {
@@ -174,7 +174,7 @@ public:
     ~hash_expr();
     void add_member(hash_pair* node) {members.push_back(node);}
     std::vector<hash_pair*>& get_members() {return members;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class hash_pair:public expr {
@@ -190,7 +190,7 @@ public:
     void set_element(expr* node) {element = node;}
     const std::string& get_name() const {return name;}
     expr* get_element() {return element;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class function:public expr {
@@ -207,7 +207,7 @@ public:
     void set_code_block(code_block* node) {block = node;}
     std::vector<parameter*>& get_parameter_list() {return parameter_list;}
     code_block* get_code_block() {return block;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class code_block:public expr {
@@ -220,7 +220,7 @@ public:
     ~code_block();
     void add_expression(expr* node) {expressions.push_back(node);}
     std::vector<expr*>& get_expressions() {return expressions;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class parameter:public expr {
@@ -244,7 +244,7 @@ public:
     void set_parameter_type(param_type pt) {type = pt;}
     void set_parameter_name(identifier* node) {name = node;}
     void set_default_value(expr* node) {default_value = node;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class ternary_operator:public expr {
@@ -258,7 +258,10 @@ public:
         expr(location, expr_type::ast_ternary),
         condition(nullptr), left(nullptr), right(nullptr) {}
     ~ternary_operator();
-    virtual void accept(ast_visitor*) override;
+    void set_condition(expr* node) {condition = node;}
+    void set_left(expr* node) {left = node;}
+    void set_right(expr* node) {right = node;}
+    void accept(ast_visitor*) override;
 };
 
 class binary_operator:public expr {
@@ -277,7 +280,9 @@ public:
         geq,
         bitwise_or,
         bitwise_xor,
-        bitwise_and
+        bitwise_and,
+        condition_and,
+        condition_or
     };
 
 private:
@@ -293,7 +298,7 @@ public:
     void set_type(binary_type operator_type) {type = operator_type;}
     void set_left(expr* node) {left = node;}
     void set_right(expr* node) {right = node;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class unary_operator:public expr {
@@ -315,7 +320,7 @@ public:
     ~unary_operator();
     void set_type(unary_type operator_type) {type = operator_type;}
     void set_value(expr* node) {value = node;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class call_expr:public expr {
@@ -330,7 +335,7 @@ public:
     ~call_expr();
     void set_first(expr* node) {first = node;}
     void add_call(expr* node) {calls.push_back(node);}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class call_hash:public expr {
@@ -342,7 +347,7 @@ public:
         expr(location, expr_type::ast_callh),
         field(name) {}
     ~call_hash();
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class call_vector:public expr {
@@ -355,7 +360,7 @@ public:
     ~call_vector();
     void add_slice(slice_vector* node) {calls.push_back(node);}
     std::vector<slice_vector*>& get_slices() {return calls;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class call_function:public expr {
@@ -368,7 +373,7 @@ public:
     ~call_function();
     void add_argument(expr* node) {args.push_back(node);}
     std::vector<expr*>& get_argument() {return args;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class slice_vector:public expr {
@@ -383,33 +388,39 @@ public:
     ~slice_vector();
     void set_begin(expr* node) {begin = node;}
     void set_end(expr* node) {end = node;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class definition_expr:public expr {
 private:
-    identifier* variable;
+    identifier* variable_name;
     multi_define* variables;
     expr* value;
 
 public:
     definition_expr(const span& location):
         expr(location, expr_type::ast_def),
-        variable(nullptr), variables(nullptr), value(nullptr) {}
+        variable_name(nullptr), variables(nullptr), value(nullptr) {}
     ~definition_expr();
-    virtual void accept(ast_visitor*) override;
+    void set_identifier(identifier* node) {variable_name = node;}
+    void set_multi_define(multi_define* node) {variables = node;}
+    void set_value(expr* node) {value = node;}
+    void accept(ast_visitor*) override;
 };
 
 class multi_define:public expr {
 private:
     std::vector<expr*> variables;
+    expr* value;
 
 public:
     multi_define(const span& location):
-        expr(location, expr_type::ast_multi_id) {}
+        expr(location, expr_type::ast_multi_id),
+        value(nullptr) {}
     ~multi_define();
     void add_var(expr* node) {variables.push_back(node);}
-    virtual void accept(ast_visitor*) override;
+    void set_value(expr* node) {value = node;}
+    void accept(ast_visitor*) override;
 };
 
 class tuple_expr:public expr {
@@ -421,7 +432,7 @@ public:
         expr(location, expr_type::ast_tuple) {}
     ~tuple_expr();
     void add_element(expr* node) {elements.push_back(node);}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class multi_assign:public expr {
@@ -435,7 +446,7 @@ public:
     ~multi_assign();
     void set_left(tuple_expr* node) {left = node;}
     void set_right(expr* node) {right = node;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class while_expr:public expr {
@@ -452,7 +463,7 @@ public:
     void set_code_block (code_block* node) {block = node;}
     expr* get_condition() {return condition;}
     code_block* get_code_block() {return block;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class for_expr:public expr {
@@ -476,7 +487,7 @@ public:
     expr* get_condition() {return condition;}
     expr* get_step() {return step;}
     code_block* get_code_block() {return block;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class iter_expr:public expr {
@@ -493,7 +504,7 @@ public:
     void set_call(expr* node) {call = node;}
     identifier* get_name() {return name;}
     expr* get_call() {return call;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class forei_expr:public expr {
@@ -522,7 +533,7 @@ public:
     iter_expr* get_iterator() {return iterator;}
     expr* get_value() {return vector_node;}
     code_block* get_code_block() {return block;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class condition_expr:public expr {
@@ -542,7 +553,7 @@ public:
     if_expr* get_if_statement() {return if_stmt;}
     std::vector<if_expr*>& get_elsif_stataments() {return elsif_stmt;}
     if_expr* get_else_statement() {return else_stmt;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class if_expr:public expr {
@@ -559,7 +570,7 @@ public:
     void set_code_block(code_block* node) {block = node;}
     expr* get_condition() {return condition;}
     code_block* get_code_block() {return block;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class continue_expr:public expr {
@@ -567,7 +578,7 @@ public:
     continue_expr(const span& location):
         expr(location, expr_type::ast_continue) {}
     ~continue_expr() = default;
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class break_expr:public expr {
@@ -575,7 +586,7 @@ public:
     break_expr(const span& location):
         expr(location, expr_type::ast_break) {}
     ~break_expr() = default;
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
 
 class return_expr:public expr {
@@ -589,5 +600,5 @@ public:
     ~return_expr();
     void set_value(expr* node) {value = node;}
     expr* get_value() {return value;}
-    virtual void accept(ast_visitor*) override;
+    void accept(ast_visitor*) override;
 };
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index 1cd9dbe..ffa7c13 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -408,131 +408,145 @@ expr* parse::calc() {
     auto node = bitwise_or();
     if (lookahead(tok::quesmark)) {
         // trinocular calculation
-        ast tmp(toks[ptr].loc, ast_trino);
+        auto tmp = new ternary_operator(toks[ptr].loc);
         match(tok::quesmark);
-        tmp.add(std::move(node));
-        tmp.add(calc());
+        tmp->set_condition(node);
+        tmp->set_left(calc());
         match(tok::colon);
-        tmp.add(calc());
-        node=std::move(tmp);
+        tmp->set_right(calc());
+        node = tmp;
     } else if (tok::eq<=toks[ptr].type && toks[ptr].type<=tok::lnkeq) {
         // tok::eq~tok::lnkeq is 37 to 42,ast_equal~ast_lnkeq is 21~26
         ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::eq+ast_equal);
         tmp.add(std::move(node));
         match(toks[ptr].type);
         tmp.add(calc());
-        node=std::move(tmp);
+        node = tmp;
     } else if (toks[ptr].type==tok::btandeq || toks[ptr].type==tok::btoreq || toks[ptr].type==tok::btxoreq) {
         ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::btandeq+ast_btandeq);
         tmp.add(std::move(node));
         match(toks[ptr].type);
         tmp.add(calc());
-        node=std::move(tmp);
+        node = tmp;
     }
     update_location(node);
     return node;
 }
 
-binary_operator* parse::bitwise_or() {
-    ast node=bitwise_xor();
+expr* parse::bitwise_or() {
+    auto node = bitwise_xor();
     while(lookahead(tok::btor)) {
-        ast tmp(toks[ptr].loc, ast_bitor);
-        tmp.add(std::move(node));
+        auto tmp = new binary_operator(toks[ptr].loc);
+        tmp->set_type(binary_operator::binary_type::bitwise_or);
+        tmp->set_left(node);
         match(tok::btor);
-        tmp.add(bitwise_xor());
-        tmp.update_span();
-        node=std::move(tmp);
+        tmp->set_right(bitwise_xor());
+        update_location(tmp);
+        node = tmp;
     }
     update_location(node);
     return node;
 }
 
-binary_operator* parse::bitwise_xor() {
-    ast node=bitwise_and();
+expr* parse::bitwise_xor() {
+    auto node = bitwise_and();
     while(lookahead(tok::btxor)) {
-        ast tmp(toks[ptr].loc, ast_bitxor);
-        tmp.add(std::move(node));
+        auto tmp = new binary_operator(toks[ptr].loc);
+        tmp->set_type(binary_operator::binary_type::bitwise_xor);
+        tmp->set_left(node);
         match(tok::btxor);
-        tmp.add(bitwise_and());
-        tmp.update_span();
-        node=std::move(tmp);
+        tmp->set_right(bitwise_and());
+        update_location(tmp);
+        node = tmp;
     }
     update_location(node);
     return node;
 }
 
-binary_operator* parse::bitwise_and() {
-    ast node=or_expr();
+expr* parse::bitwise_and() {
+    auto node = or_expr();
     while(lookahead(tok::btand)) {
-        ast tmp(toks[ptr].loc, ast_bitand);
-        tmp.add(std::move(node));
+        auto tmp = new binary_operator(toks[ptr].loc);
+        tmp->set_type(binary_operator::binary_type::bitwise_and);
+        tmp->set_left(node);
         match(tok::btand);
-        tmp.add(or_expr());
-        tmp.update_span();
-        node=std::move(tmp);
+        tmp->set_right(or_expr());
+        update_location(tmp);
+        node = tmp;
     }
     update_location(node);
     return node;
 }
 
-binary_operator* parse::or_expr() {
-    ast node=and_expr();
+expr* parse::or_expr() {
+    auto node = and_expr();
     while(lookahead(tok::opor)) {
-        ast tmp(toks[ptr].loc, ast_or);
-        tmp.add(std::move(node));
+        auto tmp = new binary_operator(toks[ptr].loc);
+        tmp->set_type(binary_operator::binary_type::condition_or);
+        tmp->set_left(node);
         match(tok::opor);
-        tmp.add(and_expr());
-        tmp.update_span();
-        node=std::move(tmp);
+        tmp->set_right(and_expr());
+        update_location(tmp);
+        node = tmp;
     }
     update_location(node);
     return node;
 }
 
-binary_operator* parse::and_expr() {
-    ast node=cmp_expr();
+expr* parse::and_expr() {
+    auto node = cmp_expr();
     while(lookahead(tok::opand)) {
-        ast tmp(toks[ptr].loc, ast_and);
-        tmp.add(std::move(node));
+        auto tmp = new binary_operator(toks[ptr].loc);
+        tmp->set_type(binary_operator::binary_type::condition_and);
+        tmp->set_left(node);
         match(tok::opand);
-        tmp.add(cmp_expr());
-        tmp.update_span();
-        node=std::move(tmp);
+        tmp->set_right(cmp_expr());
+        update_location(tmp);
+        node = tmp;
     }
     update_location(node);
     return node;
 }
 
-binary_operator* parse::cmp_expr() {
-    ast node=additive_expr();
+expr* parse::cmp_expr() {
+    auto node = additive_expr();
     while(tok::cmpeq<=toks[ptr].type && toks[ptr].type<=tok::geq) {
         // tok::cmpeq~tok::geq is 43~48,ast_cmpeq~ast_geq is 27~32
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::cmpeq+ast_cmpeq);
-        tmp.add(std::move(node));
+        auto tmp = new binary_operator(toks[ptr].loc);
+        switch(toks[ptr].type) {
+            case tok::cmpeq: tmp->set_type(binary_operator::binary_type::cmpeq); break;
+            case tok::neq: tmp->set_type(binary_operator::binary_type::cmpneq); break;
+            case tok::less: tmp->set_type(binary_operator::binary_type::less); break;
+            case tok::leq: tmp->set_type(binary_operator::binary_type::leq); break;
+            case tok::grt: tmp->set_type(binary_operator::binary_type::grt); break;
+            case tok::geq: tmp->set_type(binary_operator::binary_type::geq); break;
+            default: break;
+        }
+        tmp->set_left(node);
         match(toks[ptr].type);
-        tmp.add(additive_expr());
-        tmp.update_span();
-        node=std::move(tmp);
+        tmp->set_right(additive_expr());
+        update_location(tmp);
+        node = tmp;
     }
     update_location(node);
     return node;
 }
 
-binary_operator* parse::additive_expr() {
-    ast node=multive_expr();
+expr* parse::additive_expr() {
+    auto node = multive_expr();
     while(lookahead(tok::add) || lookahead(tok::sub) || lookahead(tok::floater)) {
-        ast tmp(toks[ptr].loc, ast_null);
+        auto tmp = new binary_operator(toks[ptr].loc);
         switch(toks[ptr].type) {
-            case tok::add: tmp.set_type(ast_add);  break;
-            case tok::sub: tmp.set_type(ast_sub);  break;
-            case tok::floater: tmp.set_type(ast_link); break;
+            case tok::add: tmp->set_type(binary_operator::binary_type::add); break;
+            case tok::sub: tmp->set_type(binary_operator::binary_type::sub); break;
+            case tok::floater: tmp->set_type(binary_operator::binary_type::concat); break;
             default: break;
         }
-        tmp.add(std::move(node));
+        tmp->set_left(node);
         match(toks[ptr].type);
-        tmp.add(multive_expr());
-        tmp.update_span();
-        node=std::move(tmp);
+        tmp->set_right(multive_expr());
+        update_location(tmp);
+        node = tmp;
     }
     update_location(node);
     return node;
@@ -582,47 +596,48 @@ unary_operator* parse::unary() {
 expr* parse::scalar() {
     expr* node = nullptr;
     if (lookahead(tok::tknil)) {
-        node=nil();
+        node = nil();
         match(tok::tknil);
     } else if (lookahead(tok::num)) {
-        node=num();
+        node = num();
     } else if (lookahead(tok::str)) {
-        node=str();
+        node = str();
     } else if (lookahead(tok::id)) {
-        node=id();
+        node = id();
     } else if (lookahead(tok::tktrue) || lookahead(tok::tkfalse)) {
-        node=bools();
+        node = bools();
     } else if (lookahead(tok::func)) {
-        node=func();
+        node = func();
     } else if (lookahead(tok::lbracket)) {
-        node=vec();
+        node = vec();
     } else if (lookahead(tok::lbrace)) {
-        node=hash();
+        node = hash();
     } else if (lookahead(tok::lcurve)) {
         const auto& loc=toks[ptr].loc;
         match(tok::lcurve);
-        node=calc();
+        node = calc();
         node->set_begin(loc.begin_line, loc.begin_column);
         update_location(node);
         match(tok::rcurve);
     } else if (lookahead(tok::var)) {
         match(tok::var);
-        node.set_type(ast_def);
-        node.add(id());
+        auto def_node = new definition_expr(toks[ptr].loc);
+        def_node->set_identifier(id());
         match(tok::eq);
-        node.add(calc());
+        def_node->set_value(calc());
+        node = def_node;
     } else {
         die(thisspan, "expected scalar");
         return node;
     }
     // check call and avoid ambiguous syntax
     if (is_call(toks[ptr].type) && !(lookahead(tok::lcurve) && toks[ptr+1].type==tok::var)) {
-        ast tmp=std::move(node);
-        node={toks[ptr].loc, ast_call};
-        node.add(std::move(tmp));
+        auto call_node = new call_expr(toks[ptr].loc);
+        call_node->set_first(node);
         while(is_call(toks[ptr].type)) {
-            node.add(call_scalar());
+            call_node->add_call(call_scalar());
         }
+        node = call_node;
     }
     update_location(node);
     return node;
@@ -721,18 +736,18 @@ expr* parse::definition() {
     if (lookahead(tok::var)) {
         match(tok::var);
         switch(toks[ptr].type) {
-            case tok::id: node.add(id());break;
-            case tok::lcurve: node.add(outcurve_def());break;
+            case tok::id: node->set_identifier(id());break;
+            case tok::lcurve: node->set_multi_define(outcurve_def());break;
             default: die(thisspan, "expected identifier");break;
         }
     } else if (lookahead(tok::lcurve)) {
-        node.add(incurve_def());
+        node->set_multi_define(incurve_def());
     }
     match(tok::eq);
     if (lookahead(tok::lcurve)) {
-        node.add(check_tuple()?multi_scalar():calc());
+        node->set_value(check_tuple()?multi_scalar():calc());
     } else {
-        node.add(calc());
+        node->set_value(calc());
     }
     update_location(node);
     return node;
@@ -759,7 +774,7 @@ multi_define* parse::outcurve_def() {
     return node;
 }
 
-expr* parse::multi_id() {
+multi_define* parse::multi_id() {
     auto node = new multi_define(toks[ptr].loc);
     while(!lookahead(tok::eof)) {
         // only identifier is allowed here
diff --git a/ast/nasal_new_parse.h b/ast/nasal_new_parse.h
index 8addbe3..9753bc5 100644
--- a/ast/nasal_new_parse.h
+++ b/ast/nasal_new_parse.h
@@ -105,13 +105,13 @@ private:
     expr* expression();
     code_block* expression_block();
     expr* calc();
-    binary_operator* bitwise_or();
-    binary_operator* bitwise_xor();
-    binary_operator* bitwise_and();
-    binary_operator* or_expr();
-    binary_operator* and_expr();
-    binary_operator* cmp_expr();
-    binary_operator* additive_expr();
+    expr* bitwise_or();
+    expr* bitwise_xor();
+    expr* bitwise_and();
+    expr* or_expr();
+    expr* and_expr();
+    expr* cmp_expr();
+    expr* additive_expr();
     expr* multive_expr();
     unary_operator* unary();
     expr* scalar();

From 2ce13e21349faff30fa311eebcd6969aaff38fe5 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sat, 24 Jun 2023 16:50:43 +0800
Subject: [PATCH 13/34] :sparkles: change ast used in parser

---
 ast/nasal_new_ast.cpp                    | 298 +++++++++++++++++++++++
 ast/nasal_new_ast.h                      |  48 +++-
 ast/nasal_new_err.cpp                    | 163 +++++++++++++
 ast/nasal_new_err.h                      |  73 ++++++
 ast/nasal_new_header.h                   |  51 ++++
 ast/nasal_new_lexer.cpp                  |  30 +--
 ast/nasal_new_lexer.h                    |  28 ++-
 ast/{new_main.cpp => nasal_new_main.cpp} |  64 +++--
 ast/nasal_new_misc.cpp                   | 230 +++++++++++++++++
 ast/nasal_new_parse.cpp                  |  43 ++--
 ast/nasal_new_parse.h                    |   9 +-
 makefile                                 |  55 +++--
 12 files changed, 988 insertions(+), 104 deletions(-)
 create mode 100644 ast/nasal_new_err.cpp
 create mode 100644 ast/nasal_new_err.h
 create mode 100644 ast/nasal_new_header.h
 rename ast/{new_main.cpp => nasal_new_main.cpp} (80%)
 create mode 100644 ast/nasal_new_misc.cpp

diff --git a/ast/nasal_new_ast.cpp b/ast/nasal_new_ast.cpp
index 8a5ef5c..b487fe4 100644
--- a/ast/nasal_new_ast.cpp
+++ b/ast/nasal_new_ast.cpp
@@ -57,4 +57,302 @@ hash_pair::~hash_pair() {
 
 void hash_pair::accept(ast_visitor* visitor) {
     visitor->visit_hash_pair(this);
+}
+
+function::~function() {
+    for(auto i : parameter_list) {
+        delete i;
+    }
+    if (block) {
+        delete block;
+    }
+}
+
+void function::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+code_block::~code_block() {
+    for(auto i : expressions) {
+        delete i;
+    }
+}
+
+void code_block::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+parameter::~parameter() {
+    if (name) {
+        delete name;
+    }
+    if (default_value) {
+        delete default_value;
+    }
+}
+
+void parameter::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+ternary_operator::~ternary_operator() {
+    if (condition) {
+        delete condition;
+    }
+    if (left) {
+        delete left;
+    }
+    if (right) {
+        delete right;
+    }
+}
+
+void ternary_operator::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+binary_operator::~binary_operator() {
+    if (left) {
+        delete left;
+    }
+    if (right) {
+        delete right;
+    }
+}
+
+void binary_operator::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+unary_operator::~unary_operator() {
+    if (value) {
+        delete value;
+    }
+}
+
+void unary_operator::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+call_expr::~call_expr() {
+    if(first) {
+        delete first;
+    }
+    for(auto i : calls) {
+        delete i;
+    }
+}
+
+void call_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+void call_hash::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+call_vector::~call_vector() {
+    for(auto i : calls) {
+        delete i;
+    }
+}
+
+void call_vector::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+call_function::~call_function() {
+    for(auto i : args) {
+        delete i;
+    }
+}
+
+void call_function::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+slice_vector::~slice_vector() {
+    if (begin) {
+        delete begin;
+    }
+    if (end) {
+        delete end;
+    }
+}
+
+void slice_vector::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+definition_expr::~definition_expr() {
+    if (variable_name) {
+        delete variable_name;
+    }
+    if (variables) {
+        delete variables;
+    }
+    if (value) {
+        delete value;
+    }
+}
+
+void definition_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+assignment_expr::~assignment_expr() {
+    if (left) {
+        delete left;
+    }
+    if (right) {
+        delete right;
+    }
+}
+
+void assignment_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+multi_define::~multi_define() {
+    for(auto i : variables) {
+        delete i;
+    }
+    if (value) {
+        delete value;
+    }
+}
+
+void multi_define::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+tuple_expr::~tuple_expr() {
+    for(auto i : elements) {
+        delete i;
+    }
+}
+
+void tuple_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+multi_assign::~multi_assign() {
+    if (left) {
+        delete left;
+    }
+    if (right) {
+        delete right;
+    }
+}
+
+void multi_assign::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+while_expr::~while_expr() {
+    if (condition) {
+        delete condition;
+    }
+    if (block) {
+        delete block;
+    }
+}
+
+void while_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+for_expr::~for_expr() {
+    if (initializing) {
+        delete initializing;
+    }
+    if (condition) {
+        delete condition;
+    }
+    if (step) {
+        delete step;
+    }
+    if (block) {
+        delete block;
+    }
+}
+
+void for_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+iter_expr::~iter_expr() {
+    if (name) {
+        delete name;
+    }
+    if (call) {
+        delete call;
+    }
+}
+
+void iter_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+forei_expr::~forei_expr() {
+    if (iterator) {
+        delete iterator;
+    }
+    if (vector_node) {
+        delete vector_node;
+    }
+    if (block) {
+        delete block;
+    }
+}
+
+void forei_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+condition_expr::~condition_expr() {
+    if (if_stmt) {
+        delete if_stmt;
+    }
+    for(auto i : elsif_stmt) {
+        delete i;
+    }
+    if (else_stmt) {
+        delete else_stmt;
+    }
+}
+
+void condition_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+if_expr::~if_expr() {
+    if (condition) {
+        delete condition;
+    }
+    if (block) {
+        delete block;
+    }
+}
+
+void if_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+void continue_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+void break_expr::accept(ast_visitor* visitor) {
+    // TODO
+}
+
+return_expr::~return_expr() {
+    if (value) {
+        delete value;
+    }
+}
+
+void return_expr::accept(ast_visitor* visitor) {
+    // TODO
 }
\ No newline at end of file
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index ab38ba4..2de3937 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -1,7 +1,7 @@
 #pragma once
 
-#include "nasal.h"
-#include "nasal_err.h"
+#include "nasal_new_header.h"
+#include "nasal_new_err.h"
 
 #include <vector>
 #include <unordered_map>
@@ -51,6 +51,7 @@ enum class expr_type:u32 {
     ast_multi_id,    // multi identifiers sub-tree
     ast_tuple,
     ast_def,         // definition
+    ast_assign,
     ast_multi_assign,
     ast_continue,    // continue keyword, only used in loop
     ast_break,       // break keyword, only used in loop
@@ -88,7 +89,7 @@ public:
         nd_loc.end_line = location.end_line;
         nd_loc.end_column = location.end_column;
     }
-    virtual void accept(ast_visitor*);
+    void accept(ast_visitor*);
 };
 
 class null_expr:public expr {
@@ -115,6 +116,7 @@ public:
     number_literal(const span& location, const f64 num):
         expr(location, expr_type::ast_num), number(num) {}
     ~number_literal() = default;
+    f64 get_number() const {return number;}
     void accept(ast_visitor*) override;
 };
 
@@ -126,6 +128,7 @@ public:
     string_literal(const span& location, const std::string& str):
         expr(location, expr_type::ast_str), content(str) {}
     ~string_literal() = default;
+    const std::string get_content() const {return content;}
     void accept(ast_visitor*) override;
 };
 
@@ -137,6 +140,7 @@ public:
     identifier(const span& location, const std::string& str):
         expr(location, expr_type::ast_id), name(str) {}
     ~identifier() = default;
+    const std::string get_name() const {return name;}
     void accept(ast_visitor*) override;
 };
 
@@ -346,7 +350,7 @@ public:
     call_hash(const span& location, const std::string& name):
         expr(location, expr_type::ast_callh),
         field(name) {}
-    ~call_hash();
+    ~call_hash() = default;
     void accept(ast_visitor*) override;
 };
 
@@ -405,6 +409,42 @@ public:
     void set_identifier(identifier* node) {variable_name = node;}
     void set_multi_define(multi_define* node) {variables = node;}
     void set_value(expr* node) {value = node;}
+
+    expr* get_value() {return value;}
+    void accept(ast_visitor*) override;
+};
+
+class assignment_expr:public expr {
+public:
+    enum class assign_type {
+        equal,
+        add_equal,
+        sub_equal,
+        mult_equal,
+        div_equal,
+        concat_equal,
+        bitwise_and_equal,
+        bitwise_or_equal,
+        bitwise_xor_equal
+    };
+
+private:
+    assign_type type;
+    expr* left;
+    expr* right;
+
+public:
+    assignment_expr(const span& location):
+        expr(location, expr_type::ast_assign),
+        left(nullptr), right(nullptr) {}
+    ~assignment_expr();
+    void set_type(assign_type operator_type) {type = operator_type;}
+    void set_left(expr* node) {left = node;}
+    void set_right(expr* node) {right = node;}
+
+    assign_type get_type() const {return type;}
+    expr* get_left() {return left;}
+    expr* get_right() {return right;}
     void accept(ast_visitor*) override;
 };
 
diff --git a/ast/nasal_new_err.cpp b/ast/nasal_new_err.cpp
new file mode 100644
index 0000000..7cf657d
--- /dev/null
+++ b/ast/nasal_new_err.cpp
@@ -0,0 +1,163 @@
+#include "nasal_new_err.h"
+
+std::ostream& back_white(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0xf0);
+#else
+    s<<"\033[7m";
+#endif
+    return s;
+}
+
+std::ostream& red(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0c);
+#else
+    s<<"\033[91;1m";
+#endif
+    return s;
+}
+
+std::ostream& cyan(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x03);
+#else
+    s<<"\033[36;1m";
+#endif
+    return s;
+}
+
+std::ostream& orange(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0e);
+#else
+    s<<"\033[93;1m";
+#endif
+    return s;
+}
+
+std::ostream& white(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0f);
+#else
+    s<<"\033[0m\033[1m";
+#endif
+    return s;
+}
+
+std::ostream& reset(std::ostream& s) {
+#ifdef _WIN32
+    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), reset_ter_color.scr.wAttributes);
+#else
+    s<<"\033[0m";
+#endif
+    return s;
+}
+
+void flstream::load(const std::string& f) {
+    if (file==f) { // don't need to load a loaded file
+        return;
+    } else {
+        file=f;
+    }
+
+    res.clear();
+    std::ifstream in(f, std::ios::binary);
+    if (in.fail()) {
+        std::cerr<<red<<"src: "<<reset<<"cannot open <"<<f<<">\n";
+        std::exit(1);
+    }
+    
+    while(!in.eof()) {
+        std::string line;
+        std::getline(in, line);
+        res.push_back(line);
+    }
+}
+
+void error::fatal(const std::string& stage, const std::string& info) {
+    std::cerr<<red<<stage<<": "<<white<<info<<reset<<"\n";
+    if (file.length()) {
+        std::cerr<<cyan<<" --> "<<red<<file<<reset<<"\n\n";
+    } else {
+        std::cerr<<reset<<"\n";
+    }
+    std::exit(1);
+}
+
+void error::err(const std::string& stage, const std::string& info) {
+    ++cnt;
+    std::cerr<<red<<stage<<": "<<white<<info<<reset<<"\n";
+    if (file.length()) {
+        std::cerr<<cyan<<" --> "<<red<<file<<reset<<"\n\n";
+    } else {
+        std::cerr<<reset<<"\n";
+    }
+}
+
+void error::err(
+    const std::string& stage, const span& loc, const std::string& info) {
+    // load error occurred file into string lines
+    load(loc.file);
+
+    ++cnt;
+
+    std::cerr
+    <<red<<stage<<": "<<white<<info<<reset<<"\n"<<cyan<<"  --> "
+    <<red<<loc.file<<":"<<loc.begin_line<<":"<<loc.begin_column+1<<reset<<"\n";
+
+    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) {
+        if (!line) {
+            continue;
+        }
+
+        if (loc.begin_line<line && line<loc.end_line) {
+            if (line==loc.begin_line+1) {
+                std::cerr<<cyan<<iden<<" | "<<reset<<"...\n"<<cyan<<iden<<" | "<<reset<<"\n";
+            }
+            continue;
+        }
+
+        // if this line has nothing, skip
+        if (!res[line-1].length() && line!=loc.end_line) {
+            continue;
+        }
+
+        const std::string& code=res[line-1];
+        std::cerr<<cyan<<leftpad(line, maxlen)<<" | "<<reset<<code<<"\n";
+        // output underline
+        std::cerr<<cyan<<iden<<" | "<<reset;
+        if (loc.begin_line==loc.end_line) {
+            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) {
+                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^")<<reset;
+            }
+        } else if (line==loc.begin_line) {
+            for(u32 i=0; i<loc.begin_column; ++i) {
+                std::cerr<<char(" \t"[code[i]=='\t']);
+            }
+            for(u32 i=loc.begin_column; i<code.size(); ++i) {
+                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^")<<reset;
+            }
+        } else if (loc.begin_line<line && line<loc.end_line) {
+            for(u32 i=0; i<code.size(); ++i) {
+                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^");
+            }
+        } else {
+            for(u32 i=0; i<loc.end_column; ++i) {
+                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^");
+            }
+        }
+        if (line==loc.end_line) {
+            std::cerr<<reset;
+        } else {
+            std::cerr<<reset<<"\n";
+        }
+    }
+    std::cerr<<"\n\n";
+}
\ No newline at end of file
diff --git a/ast/nasal_new_err.h b/ast/nasal_new_err.h
new file mode 100644
index 0000000..192300b
--- /dev/null
+++ b/ast/nasal_new_err.h
@@ -0,0 +1,73 @@
+#pragma once
+
+#include <iostream>
+#include <fstream>
+#include <sstream> // MSVC need this to use std::getline
+#include <cstring>
+#include <vector>
+
+#include "nasal_new_header.h"
+
+struct span {
+    u32 begin_line;
+    u32 begin_column;
+    u32 end_line;
+    u32 end_column;
+    std::string file;
+};
+
+#ifdef _WIN32
+#include <windows.h> // use SetConsoleTextAttribute
+struct for_reset {
+    CONSOLE_SCREEN_BUFFER_INFO scr;
+    for_reset() {
+        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &scr);
+    }
+} reset_ter_color;
+#endif
+
+std::ostream& back_white(std::ostream&);
+std::ostream& red(std::ostream&);
+std::ostream& cyan(std::ostream&);
+std::ostream& orange(std::ostream&);
+std::ostream& white(std::ostream&);
+std::ostream& reset(std::ostream&);
+
+class flstream {
+protected:
+    std::string file;
+    std::vector<std::string> res;
+public:
+    flstream():file("") {}
+    void load(const std::string&);
+    const std::string& operator[](usize n) const {return res[n];}
+    const std::string& name() const {return file;}
+    usize size() const {return res.size();}
+};
+
+class error:public flstream {
+private:
+    u32 cnt; // counter for errors
+
+    std::string identation(usize len) {
+        return std::string(len,' ');
+    }
+    std::string leftpad(u32 num, usize len) {
+        auto tmp = std::to_string(num);
+        while(tmp.length()<len) {
+            tmp=" "+tmp;
+        }
+        return tmp;
+    }
+public:
+    error():cnt(0) {}
+    void fatal(const std::string&, const std::string&);
+    void err(const std::string&, const std::string&);
+    void err(const std::string&, const span&, const std::string&);
+
+    void chkerr() const {
+        if (cnt) {
+            std::exit(1);
+        }
+    }
+};
diff --git a/ast/nasal_new_header.h b/ast/nasal_new_header.h
new file mode 100644
index 0000000..4b67fe4
--- /dev/null
+++ b/ast/nasal_new_header.h
@@ -0,0 +1,51 @@
+#pragma once
+
+#ifndef __nasver
+#define __nasver "10.1"
+#endif
+
+#include <cstdint>
+#include <iostream>
+#include <fstream>
+#include <cstring>
+#include <cmath>
+#include <vector>
+
+bool is_windows();
+bool is_linux();
+bool is_macos();
+bool is_x86();
+bool is_amd64();
+bool is_x86_64();
+bool is_arm();
+bool is_aarch64();
+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=1024;
+
+f64 hex2f(const char*);
+f64 oct2f(const char*);
+
+// we have the same reason not using atof here
+// just as andy's interpreter does.
+// it is not platform independent, and may have strange output.
+// so we write a new function here to convert str to number manually.
+// but this also makes 0.1+0.2==0.3,
+// not another result that you may get in other languages.
+f64 dec2f(const char*);
+
+f64 str2num(const char*);
+i32 utf8_hdchk(const char);
+std::string chrhex(const char);
+std::string rawstr(const std::string&, const usize maxlen=0);
\ No newline at end of file
diff --git a/ast/nasal_new_lexer.cpp b/ast/nasal_new_lexer.cpp
index a476a91..3981794 100644
--- a/ast/nasal_new_lexer.cpp
+++ b/ast/nasal_new_lexer.cpp
@@ -59,7 +59,7 @@ void lexer::err_char() {
     err.fatal("lexer", "fatal error occurred, stop");
 }
 
-void lexer::open(const string& file) {
+void lexer::open(const std::string& file) {
     // check file exsits and it is a regular file
     struct stat buffer;
     if (stat(file.c_str(), &buffer)==0 && !S_ISREG(buffer.st_mode)) {
@@ -80,14 +80,14 @@ void lexer::open(const string& file) {
     res=ss.str();
 }
 
-tok lexer::get_type(const string& str) {
+tok lexer::get_type(const std::string& str) {
     return typetbl.count(str)?typetbl.at(str):tok::null;
 }
 
-string lexer::utf8_gen() {
-    string str="";
+std::string lexer::utf8_gen() {
+    std::string str="";
     while(ptr<res.size() && res[ptr]<0) {
-        string tmp="";
+        std::string tmp="";
         u32 nbytes=utf8_hdchk(res[ptr]);
         if (!nbytes) {
             ++ptr;
@@ -105,7 +105,7 @@ string lexer::utf8_gen() {
         // utf8 character's total length is 1+nbytes
         if (tmp.length()!=1+nbytes) {
             ++column;
-            string utf_info="0x"+chrhex(tmp[0]);
+            std::string utf_info="0x"+chrhex(tmp[0]);
             for(u32 i=1;i<tmp.size();++i) {
                 utf_info+=" 0x"+chrhex(tmp[i]);
             }
@@ -121,7 +121,7 @@ string lexer::utf8_gen() {
 token lexer::id_gen() {
     u32 begin_line=line;
     u32 begin_column=column;
-    string str="";
+    std::string str="";
     while(ptr<res.size() && (is_id(res[ptr])||is_dec(res[ptr]))) {
         if (res[ptr]<0) { // utf-8
             str+=utf8_gen();
@@ -139,7 +139,7 @@ token lexer::num_gen() {
     u32 begin_column=column;
     // generate hex number
     if (ptr+1<res.size() && res[ptr]=='0' && res[ptr+1]=='x') {
-        string str="0x";
+        std::string str="0x";
         ptr+=2;
         while(ptr<res.size() && is_hex(res[ptr])) {
             str+=res[ptr++];
@@ -150,7 +150,7 @@ token lexer::num_gen() {
         }
         return {{begin_line, begin_column, line, column, filename}, tok::num, str};
     } else if (ptr+1<res.size() && res[ptr]=='0' && res[ptr+1]=='o') { // generate oct number
-        string str="0o";
+        std::string str="0o";
         ptr+=2;
         while(ptr<res.size() && is_oct(res[ptr])) {
             str+=res[ptr++];
@@ -168,7 +168,7 @@ token lexer::num_gen() {
     }
     // generate dec number
     // dec number -> [0~9][0~9]*(.[0~9]*)(e|E(+|-)0|[1~9][0~9]*)
-    string str="";
+    std::string str="";
     while(ptr<res.size() && is_dec(res[ptr])) {
         str+=res[ptr++];
     }
@@ -206,7 +206,7 @@ token lexer::num_gen() {
 token lexer::str_gen() {
     u32 begin_line=line;
     u32 begin_column=column;
-    string str="";
+    std::string str="";
     const char begin=res[ptr];
     ++column;
     while(++ptr<res.size() && res[ptr]!=begin) {
@@ -257,7 +257,7 @@ token lexer::str_gen() {
 token lexer::single_opr() {
     u32 begin_line=line;
     u32 begin_column=column;
-    string str(1,res[ptr]);
+    std::string str(1,res[ptr]);
     ++column;
     tok type=get_type(str);
     if (type==tok::null) {
@@ -270,7 +270,7 @@ token lexer::single_opr() {
 token lexer::dots() {
     u32 begin_line=line;
     u32 begin_column=column;
-    string str=".";
+    std::string str=".";
     if (ptr+2<res.size() && res[ptr+1]=='.' && res[ptr+2]=='.') {
         str+="..";
     }
@@ -283,7 +283,7 @@ token lexer::calc_opr() {
     u32 begin_line=line;
     u32 begin_column=column;
     // get calculation operator
-    string str(1,res[ptr++]);
+    std::string str(1,res[ptr++]);
     if (ptr<res.size() && res[ptr]=='=') {
         str+=res[ptr++];
     }
@@ -291,7 +291,7 @@ token lexer::calc_opr() {
     return {{begin_line, begin_column, line, column, filename}, get_type(str), str};
 }
 
-const error& lexer::scan(const string& file) {
+const error& lexer::scan(const std::string& file) {
     line=1;
     column=0;
     ptr=0;
diff --git a/ast/nasal_new_lexer.h b/ast/nasal_new_lexer.h
index 0f4adfd..c4669c2 100644
--- a/ast/nasal_new_lexer.h
+++ b/ast/nasal_new_lexer.h
@@ -12,8 +12,8 @@
 #include <unordered_map>
 #include <sys/stat.h>
 
-#include "nasal.h"
-#include "nasal_err.h"
+#include "nasal_new_header.h"
+#include "nasal_new_err.h"
 
 #ifdef _MSC_VER
 #define S_ISREG(m) (((m)&0xF000)==0x8000)
@@ -81,9 +81,9 @@ enum class tok:u32 {
 };
 
 struct token {
-    span loc;    // location
-    tok type;    // token type
-    string str;  // content
+    span loc; // location
+    tok type; // token type
+    std::string str; // content
     token() = default;
     token(const token&) = default;
 };
@@ -93,11 +93,11 @@ private:
     u32    line;
     u32    column;
     usize  ptr;
-    string filename;
-    string res;
+    std::string filename;
+    std::string res;
     error& err;
     std::vector<token> toks;
-    const std::unordered_map<string,tok> typetbl {
+    const std::unordered_map<std::string, tok> typetbl {
         {"true"    ,tok::tktrue  },
         {"false"   ,tok::tkfalse },
         {"for"     ,tok::rfor    },
@@ -153,7 +153,7 @@ private:
         {">="      ,tok::geq     }
     };
 
-    tok get_type(const string&);
+    tok get_type(const std::string&);
     bool skip(char);
     bool is_id(char);
     bool is_hex(char);
@@ -166,8 +166,8 @@ private:
     void skip_note();
     void err_char();
 
-    void open(const string&);
-    string utf8_gen();
+    void open(const std::string&);
+    std::string utf8_gen();
     token id_gen();
     token num_gen();
     token str_gen();
@@ -175,7 +175,9 @@ private:
     token dots();
     token calc_opr();
 public:
-    lexer(error& e): line(1), column(0), ptr(0), filename(""), res(""), err(e) {}
-    const error& scan(const string&);
+    lexer(error& e):
+        line(1), column(0),
+        ptr(0), filename(""), res(""), err(e) {}
+    const error& scan(const std::string&);
     const std::vector<token>& result() const {return toks;}
 };
diff --git a/ast/new_main.cpp b/ast/nasal_new_main.cpp
similarity index 80%
rename from ast/new_main.cpp
rename to ast/nasal_new_main.cpp
index f1eb2b3..586243f 100644
--- a/ast/new_main.cpp
+++ b/ast/nasal_new_main.cpp
@@ -1,15 +1,9 @@
-#include "nasal.h"
-#include "nasal_err.h"
-#include "nasal_lexer.h"
-#include "nasal_ast.h"
-#include "nasal_parse.h"
-#include "nasal_import.h"
-#include "nasal_opt.h"
-#include "nasal_gc.h"
-#include "nasal_builtin.h"
-#include "nasal_codegen.h"
-#include "nasal_vm.h"
-#include "nasal_dbg.h"
+#include "nasal_new_header.h"
+#include "nasal_new_err.h"
+#include "nasal_new_lexer.h"
+#include "nasal_new_ast.h"
+#include "nasal_new_parse.h"
+#include "ast_visitor.h"
 
 #include <unordered_map>
 #include <thread>
@@ -73,8 +67,8 @@ void err() {
 }
 
 void execute(
-    const string& file,
-    const std::vector<string>& argv,
+    const std::string& file,
+    const std::vector<std::string>& argv,
     const u32 cmd
 ) {
     using clk=std::chrono::high_resolution_clock;
@@ -83,9 +77,9 @@ void execute(
     error   err;
     lexer   lex(err);
     parse   parse(err);
-    linker  ld(err);
-    codegen gen(err);
-    vm      ctx;
+    // linker  ld(err);
+    // codegen gen(err);
+    // vm      ctx;
 
     // lexer scans file to get tokens
     lex.scan(file).chkerr();
@@ -94,27 +88,27 @@ void execute(
     parse.compile(lex).chkerr();
 
     // linker gets parser's ast and load import files to this ast
-    ld.link(parse, file, cmd&VM_DETAIL).chkerr();
+    // ld.link(parse, file, cmd&VM_DETAIL).chkerr();
 
     // optimizer does simple optimization on ast
-    optimize(parse.tree());
-    if (cmd&VM_AST) {
-        parse.tree().dump();
-    }
+    // optimize(parse.tree());
+    // if (cmd&VM_AST) {
+    //     parse.tree().dump();
+    // }
 
     // code generator gets parser's ast and import file list to generate code
-    gen.compile(parse, ld).chkerr();
-    if (cmd&VM_CODE) {
-        gen.print();
-    }
+    // gen.compile(parse, ld).chkerr();
+    // if (cmd&VM_CODE) {
+    //     gen.print();
+    // }
 
     // run
     auto start=clk::now();
-    if (cmd&VM_DEBUG) {
-        dbg(err).run(gen, ld, argv);
-    } else if (cmd&VM_TIME || cmd&VM_EXEC) {
-        ctx.run(gen, ld, argv, cmd&VM_DETAIL);
-    }
+    // if (cmd&VM_DEBUG) {
+    //     dbg(err).run(gen, ld, argv);
+    // } else if (cmd&VM_TIME || cmd&VM_EXEC) {
+    //     ctx.run(gen, ld, argv, cmd&VM_DETAIL);
+    // }
 
     // get running time
     if (cmd&VM_TIME) {
@@ -132,7 +126,7 @@ i32 main(i32 argc, const char* argv[]) {
 
     // run directly or show help
     if (argc==2) {
-        string s(argv[1]);
+        std::string s(argv[1]);
         if (s=="-h" || s=="--help") {
             std::clog<<help;
         } else if (s[0]!='-') {
@@ -144,7 +138,7 @@ i32 main(i32 argc, const char* argv[]) {
     }
 
     // execute with arguments
-    const std::unordered_map<string,u32> cmdlst={
+    const std::unordered_map<std::string,u32> cmdlst = {
         {"--ast", VM_AST},
         {"-a", VM_AST},
         {"--code", VM_CODE},
@@ -159,8 +153,8 @@ i32 main(i32 argc, const char* argv[]) {
         {"-dbg", VM_DEBUG}
     };
     u32 cmd=0;
-    string filename="";
-    std::vector<string> vm_argv;
+    std::string filename="";
+    std::vector<std::string> vm_argv;
     for(i32 i=1; i<argc; ++i) {
         if (cmdlst.count(argv[i])) {
             cmd|=cmdlst.at(argv[i]);
diff --git a/ast/nasal_new_misc.cpp b/ast/nasal_new_misc.cpp
new file mode 100644
index 0000000..97ae1c7
--- /dev/null
+++ b/ast/nasal_new_misc.cpp
@@ -0,0 +1,230 @@
+#include "nasal_new_header.h"
+
+bool is_windows() {
+#if defined(_WIN32) || defined(_WIN64)
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool is_linux() {
+#if defined __linux__
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool is_macos() {
+#if defined __APPLE__
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool is_x86() {
+#if defined(__i386__) || defined(_M_IX86)
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool is_amd64() {
+#if defined(__amd64__) || defined(_M_X64)
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool is_x86_64() {
+    return is_amd64();
+}
+
+bool is_arm() {
+#if defined(__arm__) || defined(_M_ARM)
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool is_aarch64() {
+#if defined(__aarch64__) || defined(_M_ARM64)
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool is_ia64() {
+#if defined(__ia64__)
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool is_powerpc() {
+#if defined(__powerpc__)
+    return true;
+#else
+    return false;
+#endif
+}
+
+bool is_superh() {
+#if defined(__sh__)
+    return true;
+#else
+    return false;
+#endif
+}
+
+f64 hex2f(const char* str) {
+    f64 ret=0;
+    for(; *str; ++str) {
+        if ('0'<=*str && *str<='9') {
+            ret=ret*16+(*str-'0');
+        } else if ('a'<=*str && *str<='f') {
+            ret=ret*16+(*str-'a'+10);
+        } else if ('A'<=*str && *str<='F') {
+            ret=ret*16+(*str-'A'+10);
+        } else {
+            return nan("");
+        }
+    }
+    return ret;
+}
+
+f64 oct2f(const char* str) {
+    f64 ret=0;
+    while('0'<=*str && *str<'8') {
+        ret=ret*8+(*str++-'0');
+    }
+    if (*str) {
+        return nan("");
+    }
+    return ret;
+}
+
+// we have the same reason not using atof here
+// just as andy's interpreter does.
+// it is not platform independent, and may have strange output.
+// so we write a new function here to convert str to number manually.
+// but this also makes 0.1+0.2==0.3,
+// not another result that you may get in other languages.
+f64 dec2f(const char* str) {
+    f64 ret=0,negative=1,num_pow=0;
+    while('0'<=*str && *str<='9') {
+        ret=ret*10+(*str++-'0');
+    }
+    if (!*str) {
+        return ret;
+    }
+    if (*str=='.') {
+        if (!*++str) {
+            return nan("");
+        }
+        num_pow=0.1;
+        while('0'<=*str && *str<='9') {
+            ret+=num_pow*(*str++-'0');
+            num_pow*=0.1;
+        }
+        if (!*str) {
+            return ret;
+        }
+    }
+    if (*str!='e' && *str!='E') {
+        return nan("");
+    }
+    if (!*++str) {
+        return nan("");
+    }
+    if (*str=='-' || *str=='+') {
+        negative=(*str++=='-'? -1:1);
+    }
+    if (!*str) {
+        return nan("");
+    }
+    num_pow=0;
+    while('0'<=*str && *str<='9') {
+        num_pow=num_pow*10+(*str++-'0');
+    }
+    if (*str) {
+        return nan("");
+    }
+    return ret*std::pow(10,negative*num_pow);
+}
+
+f64 str2num(const char* str) {
+    bool negative=false;
+    f64 res=0;
+    if (*str=='-' || *str=='+') {
+        negative=(*str++=='-');
+    }
+    if (!*str) {
+        return nan("");
+    }
+    if (str[0]=='0' && str[1]=='x') {
+        res=hex2f(str+2);
+    } else if (str[0]=='0' && str[1]=='o') {
+        res=oct2f(str+2);
+    } else {
+        res=dec2f(str);
+    }
+    return negative?-res:res;
+}
+
+i32 utf8_hdchk(const char head) {
+    // RFC-2279 but now we use RFC-3629 so nbytes is less than 4
+    const u8 c=(u8)head;
+    if ((c>>5)==0x06) { // 110x xxxx (10xx xxxx)^1
+        return 1;
+    }
+    if ((c>>4)==0x0e) { // 1110 xxxx (10xx xxxx)^2
+        return 2;
+    }
+    if ((c>>3)==0x1e) { // 1111 0xxx (10xx xxxx)^3
+        return 3;
+    }
+    return 0;
+}
+
+std::string chrhex(const char c) {
+    const char hextbl[]="0123456789abcdef";
+    return {hextbl[(c&0xf0)>>4],hextbl[c&0x0f]};
+}
+
+std::string rawstr(const std::string& str, const usize maxlen) {
+    std::string ret("");
+    for(auto i:str) {
+        // windows doesn't output unicode normally, so we output the hex
+        if (is_windows() && i<=0) {
+            ret+="\\x"+chrhex(i);
+            continue;
+        }
+        switch(i) {
+            case '\0':  ret+="\\0"; break;
+            case '\a':  ret+="\\a"; break;
+            case '\b':  ret+="\\b"; break;
+            case '\t':  ret+="\\t"; break;
+            case '\n':  ret+="\\n"; break;
+            case '\v':  ret+="\\v"; break;
+            case '\f':  ret+="\\f"; break;
+            case '\r':  ret+="\\r"; break;
+            case '\033':ret+="\\e"; break;
+            case '\"':  ret+="\\\"";break;
+            case '\'':  ret+="\\\'";break;
+            case '\\':  ret+="\\\\";break;
+            default:    ret+=i;     break;
+        }
+    }
+    if (maxlen && ret.length()>maxlen) {
+        ret=ret.substr(0,maxlen)+"...";
+    }
+    return ret;
+}
\ No newline at end of file
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index ffa7c13..71bf125 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -129,17 +129,10 @@ bool parse::check_func_end(expr* node) {
         type==expr_type::ast_hash) {
         return false;
     }
-    if (node.child().empty() || (
-        type!=expr_type::ast_def &&
-        type!=expr_type::ast_equal &&
-        type!=expr_type::ast_addeq &&
-        type!=expr_type::ast_subeq &&
-        type!=expr_type::ast_multeq &&
-        type!=expr_type::ast_diveq &&
-        type!=expr_type::ast_lnkeq)) {
-        return false;
-    } else {
-        return check_func_end(node.child().back());
+    if (type==expr_type::ast_def) {
+        return check_func_end(((definition_expr*)type)->get_value());
+    } else if (type==expr_type::ast_assign) {
+        return check_func_end(((assignment_expr*)type)->get_right());
     }
     return false;
 }
@@ -301,7 +294,6 @@ void parse::params(function* func_node) {
         auto param = new parameter(toks[ptr].loc);
         param->set_parameter_name(id());
         if (lookahead(tok::eq) || lookahead(tok::ellipsis)) {
-            ast special_arg(toks[ptr].loc, ast_null);
             if (lookahead(tok::eq)) {
                 match(tok::eq);
                 param->set_parameter_type(parameter::param_type::default_parameter);
@@ -417,16 +409,31 @@ expr* parse::calc() {
         node = tmp;
     } else if (tok::eq<=toks[ptr].type && toks[ptr].type<=tok::lnkeq) {
         // tok::eq~tok::lnkeq is 37 to 42,ast_equal~ast_lnkeq is 21~26
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::eq+ast_equal);
-        tmp.add(std::move(node));
+        auto tmp = new assignment_expr(toks[ptr].loc);
+        switch(toks[ptr].type) {
+            case tok::eq: tmp->set_type(assignment_expr::assign_type::equal); break;
+            case tok::addeq: tmp->set_type(assignment_expr::assign_type::add_equal); break;
+            case tok::subeq: tmp->set_type(assignment_expr::assign_type::sub_equal); break;
+            case tok::multeq: tmp->set_type(assignment_expr::assign_type::mult_equal); break;
+            case tok::diveq: tmp->set_type(assignment_expr::assign_type::div_equal); break;
+            case tok::lnkeq: tmp->set_type(assignment_expr::assign_type::concat_equal); break;
+            default: break;
+        }
+        tmp->set_left(node);
         match(toks[ptr].type);
-        tmp.add(calc());
+        tmp->set_right(calc());
         node = tmp;
     } else if (toks[ptr].type==tok::btandeq || toks[ptr].type==tok::btoreq || toks[ptr].type==tok::btxoreq) {
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::btandeq+ast_btandeq);
-        tmp.add(std::move(node));
+        auto tmp = new assignment_expr(toks[ptr].loc);
+        switch(toks[ptr].type) {
+            case tok::btandeq: tmp->set_type(assignment_expr::assign_type::bitwise_and_equal); break;
+            case tok::btoreq: tmp->set_type(assignment_expr::assign_type::bitwise_or_equal); break;
+            case tok::btxoreq: tmp->set_type(assignment_expr::assign_type::bitwise_xor_equal); break;
+            default: break;
+        }
+        tmp->set_left(node);
         match(toks[ptr].type);
-        tmp.add(calc());
+        tmp->set_right(calc());
         node = tmp;
     }
     update_location(node);
diff --git a/ast/nasal_new_parse.h b/ast/nasal_new_parse.h
index 9753bc5..72abdd1 100644
--- a/ast/nasal_new_parse.h
+++ b/ast/nasal_new_parse.h
@@ -2,11 +2,10 @@
 
 #include <unordered_map>
 
-#include "nasal.h"
+#include "nasal_new_header.h"
 #include "nasal_new_ast.h"
-#include "nasal_lexer.h"
-#include "nasal_ast.h"
-#include "nasal_err.h"
+#include "nasal_new_lexer.h"
+#include "nasal_new_err.h"
 
 class parse {
 
@@ -22,7 +21,7 @@ private:
     error& err;
 
 private:
-    const std::unordered_map<tok,string> tokname {
+    const std::unordered_map<tok, std::string> tokname {
         {tok::rfor    ,"for"     },
         {tok::forindex,"forindex"},
         {tok::foreach ,"foreach" },
diff --git a/makefile b/makefile
index 160192e..5dfa980 100644
--- a/makefile
+++ b/makefile
@@ -18,24 +18,12 @@ SRC=\
 
 STD=c++14
 
-nasal:$(SRC) nasal_new_lexer.o nasal_new_ast.o nasal_new_parse.o ast_visitor.o
+nasal:$(SRC)
 	$(CXX) -std=$(STD) -O3 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
 
 nasal.exe:$(SRC)
 	$(CXX) -std=$(STD) -O3 main.cpp -o nasal.exe -fno-exceptions -Wshadow -Wall -static
 
-nasal_new_lexer.o: ast/nasal_new_lexer.h ast/nasal_new_lexer.cpp nasal.h
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.o -I .
-
-nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp nasal.h
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
-
-nasal_new_parse.o: ast/nasal_new_parse.h ast/nasal_new_parse.cpp nasal.h ast/nasal_new_ast.h
-#	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_parse.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
-
-ast_visitor.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_visitor.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .
-
 stable-release:$(SRC)
 	$(CXX) -std=$(STD) -O2 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
 
@@ -83,4 +71,43 @@ test:nasal
 	@ ./nasal -t -d test/turingmachine.nas
 	@ ./nasal -d test/wavecollapse.nas
 	@ ./nasal test/word_collector.nas test/md5compare.nas
-	@ ./nasal -t -d test/ycombinator.nas
\ No newline at end of file
+	@ ./nasal -t -d test/ycombinator.nas
+
+NASAL_NEW_AST=\
+	nasal_new_misc.o\
+	nasal_new_err.o\
+	nasal_new_lexer.o\
+	nasal_new_ast.o\
+	nasal_new_parse.o\
+	ast_visitor.o\
+	nasal_new_main.o
+
+# for test
+nasal_new: $(NASAL_NEW_AST)
+	$(CXX) $(NASAL_NEW_AST) -o nasal_new
+	@ echo "build done"
+
+nasal_new_main.o: ast/nasal_new_main.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_main.cpp -fno-exceptions -fPIC -o nasal_new_main.o -I .
+
+nasal_new_misc.o: ast/nasal_new_header.h ast/nasal_new_misc.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_misc.cpp -fno-exceptions -fPIC -o nasal_new_misc.o -I .
+
+nasal_new_err.o: ast/nasal_new_err.h ast/nasal_new_err.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_err.cpp -fno-exceptions -fPIC -o nasal_new_err.o -I .
+
+nasal_new_lexer.o: ast/nasal_new_lexer.h ast/nasal_new_lexer.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.o -I .
+
+nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
+
+nasal_new_parse.o: ast/nasal_new_parse.h ast/nasal_new_parse.cpp ast/nasal_new_ast.h
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_parse.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
+
+ast_visitor.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_visitor.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .
+
+.PHONY: nasal_new_clean
+nasal_new_clean:
+	rm $(NASAL_NEW_AST)
\ No newline at end of file

From 9f66960244856cf96f8166e5635399c82fbb9b65 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sun, 25 Jun 2023 00:31:11 +0800
Subject: [PATCH 14/34] :sparkles: add ast dumper

---
 ast/ast_dumper.cpp      | 368 ++++++++++++++++++++++++++++++++++++++++
 ast/ast_dumper.h        |  42 +++++
 ast/ast_visitor.cpp     | 179 ++++++++++++++++++-
 ast/ast_visitor.h       |  25 +++
 ast/nasal_new_ast.cpp   |  69 ++++----
 ast/nasal_new_ast.h     |  99 ++++++-----
 ast/nasal_new_main.cpp  |   8 +-
 ast/nasal_new_parse.cpp |  45 +++--
 ast/nasal_new_parse.h   |   6 +-
 makefile                |   8 +-
 10 files changed, 732 insertions(+), 117 deletions(-)
 create mode 100644 ast/ast_dumper.cpp
 create mode 100644 ast/ast_dumper.h

diff --git a/ast/ast_dumper.cpp b/ast/ast_dumper.cpp
new file mode 100644
index 0000000..0aaba4a
--- /dev/null
+++ b/ast/ast_dumper.cpp
@@ -0,0 +1,368 @@
+#include "ast_dumper.h"
+
+#include <iostream>
+
+bool ast_dumper::visit_expr(expr* node) {
+    std::cout << "expr\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_null_expr(null_expr* node) {
+    std::cout << "null\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    return true;
+}
+
+bool ast_dumper::visit_nil_expr(nil_expr* node) {
+    std::cout << "nil\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    return true;
+}
+
+bool ast_dumper::visit_number_literal(number_literal* node) {
+    std::cout << "number " << node->get_number() << "\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    return true;
+}
+
+bool ast_dumper::visit_string_literal(string_literal* node) {
+    std::cout << "string " << node->get_content() << "\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    return true;
+}
+
+bool ast_dumper::visit_identifier(identifier* node) {
+    std::cout << "identifier " << node->get_name() << "\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    return true;
+}
+
+bool ast_dumper::visit_bool_literal(bool_literal* node) {
+    std::cout << "bool " << node->get_flag() << "\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    return true;
+}
+
+bool ast_dumper::visit_vector_expr(vector_expr* node) {
+    std::cout << "vector\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    for(auto i : node->get_elements()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_hash_expr(hash_expr* node) {
+    std::cout << "hash\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    for(auto i : node->get_members()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_hash_pair(hash_pair* node) {
+    std::cout << "pair\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    if (node->get_value()) {
+        node->get_value()->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_function(function* node) {
+    std::cout << "function\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    for(auto i : node->get_parameter_list()) {
+        i->accept(this);
+    }
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_code_block(code_block* node) {
+    std::cout << "block\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    for(auto i : node->get_expressions()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_parameter(parameter* node) {
+    std::cout << "parameter\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_parameter_name()->accept(this);
+    if (node->get_default_value()) {
+        node->get_default_value()->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_ternary_operator(ternary_operator* node) {
+    std::cout << "ternary\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_condition()->accept(this);
+    node->get_left()->accept(this);
+    node->get_right()->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_binary_operator(binary_operator* node) {
+    std::cout << "binary\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_left()->accept(this);
+    node->get_right()->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_unary_operator(unary_operator* node) {
+    std::cout << "unary\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_value()->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_call_expr(call_expr* node) {
+    std::cout << "call_expr\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_first()->accept(this);
+    for(auto i : node->get_calls()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_call_hash(call_hash* node) {
+    std::cout << "call_hash\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    return true;
+}
+
+bool ast_dumper::visit_call_vector(call_vector* node) {
+    std::cout << "call_vector\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    for(auto i : node->get_slices()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_call_function(call_function* node) {
+    std::cout << "call_function\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    for(auto i : node->get_argument()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_slice_vector(slice_vector* node) {
+    std::cout << "slice\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_begin()->accept(this);
+    if (node->get_end()) {
+        node->get_end()->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_definition_expr(definition_expr* node) {
+    std::cout << "definition\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    if (node->get_variable_name()) {
+        node->get_variable_name()->accept(this);
+    } else {
+        node->get_variables()->accept(this);
+    }
+    node->get_value()->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_assignment_expr(assignment_expr* node) {
+    std::cout << "assignment\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_left()->accept(this);
+    node->get_right()->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_multi_identifier(multi_identifier* node) {
+    std::cout << "multi_define\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    for(auto i : node->get_variables()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_tuple_expr(tuple_expr* node) {
+    std::cout << "tuple\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    for(auto i : node->get_elements()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_multi_assign(multi_assign* node) {
+    std::cout << "multi_assign\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_tuple()->accept(this);
+    node->get_value()->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_while_expr(while_expr* node) {
+    std::cout << "while\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_condition()->accept(this);
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_for_expr(for_expr* node) {
+    std::cout << "for\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_initial()->accept(this);
+    node->get_condition()->accept(this);
+    node->get_step()->accept(this);
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_iter_expr(iter_expr* node) {
+    std::cout << "iter\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    if (node->get_name()) {
+        node->get_name()->accept(this);
+    } else {
+        node->get_call()->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_forei_expr(forei_expr* node) {
+    std::cout << "forei\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_iterator()->accept(this);
+    node->get_value()->accept(this);
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_condition_expr(condition_expr* node) {
+    std::cout << "condition\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    node->get_if_statement()->accept(this);
+    for(auto i : node->get_elsif_stataments()) {
+        i->accept(this);
+    }
+    if (node->get_else_statement()) {
+        node->get_else_statement()->accept(this);
+    }
+    return true;
+}
+
+bool ast_dumper::visit_if_expr(if_expr* node) {
+    std::cout << "if\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    if (node->get_condition()) {
+        node->get_condition()->accept(this);
+    }
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_dumper::visit_continue_expr(continue_expr* node) {
+    std::cout << "continue\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    return true;
+}
+
+bool ast_dumper::visit_break_expr(break_expr* node) {
+    std::cout << "break\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    return true;
+}
+
+bool ast_dumper::visit_return_expr(return_expr* node) {
+    std::cout << "return\n";
+    std::cout << " -> " << node->get_location().file << ":"
+    << node->get_location().begin_line << ":"
+    << node->get_location().begin_column << "\n";
+    if (node->get_value()) {
+        node->get_value()->accept(this);
+    }
+    return true;
+}
\ No newline at end of file
diff --git a/ast/ast_dumper.h b/ast/ast_dumper.h
new file mode 100644
index 0000000..4599537
--- /dev/null
+++ b/ast/ast_dumper.h
@@ -0,0 +1,42 @@
+#pragma once
+
+#include "ast_visitor.h"
+
+class ast_dumper:public ast_visitor {
+public:
+    bool visit_expr(expr*) override;
+    bool visit_null_expr(null_expr*) override;
+    bool visit_nil_expr(nil_expr*) override;
+    bool visit_number_literal(number_literal*) override;
+    bool visit_string_literal(string_literal*) override;
+    bool visit_identifier(identifier*) override;
+    bool visit_bool_literal(bool_literal*) override;
+    bool visit_vector_expr(vector_expr*) override;
+    bool visit_hash_expr(hash_expr*) override;
+    bool visit_hash_pair(hash_pair*) override;
+    bool visit_function(function*) override;
+    bool visit_code_block(code_block*) override;
+    bool visit_parameter(parameter*) override;
+    bool visit_ternary_operator(ternary_operator*) override;
+    bool visit_binary_operator(binary_operator*) override;
+    bool visit_unary_operator(unary_operator*) override;
+    bool visit_call_expr(call_expr*) override;
+    bool visit_call_hash(call_hash*) override;
+    bool visit_call_vector(call_vector*) override;
+    bool visit_call_function(call_function*) override;
+    bool visit_slice_vector(slice_vector*) override;
+    bool visit_definition_expr(definition_expr*) override;
+    bool visit_assignment_expr(assignment_expr*) override;
+    bool visit_multi_identifier(multi_identifier*) override;
+    bool visit_tuple_expr(tuple_expr*) override;
+    bool visit_multi_assign(multi_assign*) override;
+    bool visit_while_expr(while_expr*) override;
+    bool visit_for_expr(for_expr*) override;
+    bool visit_iter_expr(iter_expr*) override;
+    bool visit_forei_expr(forei_expr*) override;
+    bool visit_condition_expr(condition_expr*) override;
+    bool visit_if_expr(if_expr*) override;
+    bool visit_continue_expr(continue_expr*) override;
+    bool visit_break_expr(break_expr*) override;
+    bool visit_return_expr(return_expr*) override;
+};
\ No newline at end of file
diff --git a/ast/ast_visitor.cpp b/ast/ast_visitor.cpp
index 017a0e7..e641856 100644
--- a/ast/ast_visitor.cpp
+++ b/ast/ast_visitor.cpp
@@ -44,8 +44,183 @@ bool ast_visitor::visit_hash_expr(hash_expr* node) {
 }
 
 bool ast_visitor::visit_hash_pair(hash_pair* node) {
-    if (node->get_element()) {
-        node->get_element()->accept(this);
+    if (node->get_value()) {
+        node->get_value()->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_function(function* node) {
+    for(auto i : node->get_parameter_list()) {
+        i->accept(this);
+    }
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_code_block(code_block* node) {
+    for(auto i : node->get_expressions()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_parameter(parameter* node) {
+    node->get_parameter_name()->accept(this);
+    if (node->get_default_value()) {
+        node->get_default_value()->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_ternary_operator(ternary_operator* node) {
+    node->get_condition()->accept(this);
+    node->get_left()->accept(this);
+    node->get_right()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_binary_operator(binary_operator* node) {
+    node->get_left()->accept(this);
+    node->get_right()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_unary_operator(unary_operator* node) {
+    node->get_value()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_call_expr(call_expr* node) {
+    node->get_first()->accept(this);
+    for(auto i : node->get_calls()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_call_hash(call_hash* node) {
+    return true;
+}
+
+bool ast_visitor::visit_call_vector(call_vector* node) {
+    for(auto i : node->get_slices()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_call_function(call_function* node) {
+    for(auto i : node->get_argument()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_slice_vector(slice_vector* node) {
+    node->get_begin()->accept(this);
+    if (node->get_end()) {
+        node->get_end()->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_definition_expr(definition_expr* node) {
+    if (node->get_variable_name()) {
+        node->get_variable_name()->accept(this);
+    } else {
+        node->get_variables()->accept(this);
+    }
+    node->get_value()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_assignment_expr(assignment_expr* node) {
+    node->get_left()->accept(this);
+    node->get_right()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_multi_identifier(multi_identifier* node) {
+    for(auto i : node->get_variables()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_tuple_expr(tuple_expr* node) {
+    for(auto i : node->get_elements()) {
+        i->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_multi_assign(multi_assign* node) {
+    node->get_tuple()->accept(this);
+    node->get_value()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_while_expr(while_expr* node) {
+    node->get_condition()->accept(this);
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_for_expr(for_expr* node) {
+    node->get_initial()->accept(this);
+    node->get_condition()->accept(this);
+    node->get_step()->accept(this);
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_iter_expr(iter_expr* node) {
+    if (node->get_name()) {
+        node->get_name()->accept(this);
+    } else {
+        node->get_call()->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_forei_expr(forei_expr* node) {
+    node->get_iterator()->accept(this);
+    node->get_value()->accept(this);
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_condition_expr(condition_expr* node) {
+    node->get_if_statement()->accept(this);
+    for(auto i : node->get_elsif_stataments()) {
+        i->accept(this);
+    }
+    if (node->get_else_statement()) {
+        node->get_else_statement()->accept(this);
+    }
+    return true;
+}
+
+bool ast_visitor::visit_if_expr(if_expr* node) {
+    if (node->get_condition()) {
+        node->get_condition()->accept(this);
+    }
+    node->get_code_block()->accept(this);
+    return true;
+}
+
+bool ast_visitor::visit_continue_expr(continue_expr* node) {
+    return true;
+}
+
+bool ast_visitor::visit_break_expr(break_expr* node) {
+    return true;
+}
+
+bool ast_visitor::visit_return_expr(return_expr* node) {
+    if (node->get_value()) {
+        node->get_value()->accept(this);
     }
     return true;
 }
\ No newline at end of file
diff --git a/ast/ast_visitor.h b/ast/ast_visitor.h
index 92d42b2..ff30483 100644
--- a/ast/ast_visitor.h
+++ b/ast/ast_visitor.h
@@ -14,4 +14,29 @@ public:
     virtual bool visit_vector_expr(vector_expr*);
     virtual bool visit_hash_expr(hash_expr*);
     virtual bool visit_hash_pair(hash_pair*);
+    virtual bool visit_function(function*);
+    virtual bool visit_code_block(code_block*);
+    virtual bool visit_parameter(parameter*);
+    virtual bool visit_ternary_operator(ternary_operator*);
+    virtual bool visit_binary_operator(binary_operator*);
+    virtual bool visit_unary_operator(unary_operator*);
+    virtual bool visit_call_expr(call_expr*);
+    virtual bool visit_call_hash(call_hash*);
+    virtual bool visit_call_vector(call_vector*);
+    virtual bool visit_call_function(call_function*);
+    virtual bool visit_slice_vector(slice_vector*);
+    virtual bool visit_definition_expr(definition_expr*);
+    virtual bool visit_assignment_expr(assignment_expr*);
+    virtual bool visit_multi_identifier(multi_identifier*);
+    virtual bool visit_tuple_expr(tuple_expr*);
+    virtual bool visit_multi_assign(multi_assign*);
+    virtual bool visit_while_expr(while_expr*);
+    virtual bool visit_for_expr(for_expr*);
+    virtual bool visit_iter_expr(iter_expr*);
+    virtual bool visit_forei_expr(forei_expr*);
+    virtual bool visit_condition_expr(condition_expr*);
+    virtual bool visit_if_expr(if_expr*);
+    virtual bool visit_continue_expr(continue_expr*);
+    virtual bool visit_break_expr(break_expr*);
+    virtual bool visit_return_expr(return_expr*);
 };
\ No newline at end of file
diff --git a/ast/nasal_new_ast.cpp b/ast/nasal_new_ast.cpp
index b487fe4..c6d7c16 100644
--- a/ast/nasal_new_ast.cpp
+++ b/ast/nasal_new_ast.cpp
@@ -50,8 +50,8 @@ void hash_expr::accept(ast_visitor* visitor) {
 }
 
 hash_pair::~hash_pair() {
-    if (element) {
-        delete element;
+    if (value) {
+        delete value;
     }
 }
 
@@ -69,7 +69,7 @@ function::~function() {
 }
 
 void function::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_function(this);
 }
 
 code_block::~code_block() {
@@ -79,7 +79,7 @@ code_block::~code_block() {
 }
 
 void code_block::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_code_block(this);
 }
 
 parameter::~parameter() {
@@ -92,7 +92,7 @@ parameter::~parameter() {
 }
 
 void parameter::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_parameter(this);
 }
 
 ternary_operator::~ternary_operator() {
@@ -108,7 +108,7 @@ ternary_operator::~ternary_operator() {
 }
 
 void ternary_operator::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_ternary_operator(this);
 }
 
 binary_operator::~binary_operator() {
@@ -121,7 +121,7 @@ binary_operator::~binary_operator() {
 }
 
 void binary_operator::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_binary_operator(this);
 }
 
 unary_operator::~unary_operator() {
@@ -131,7 +131,7 @@ unary_operator::~unary_operator() {
 }
 
 void unary_operator::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_unary_operator(this);
 }
 
 call_expr::~call_expr() {
@@ -144,11 +144,11 @@ call_expr::~call_expr() {
 }
 
 void call_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_call_expr(this);
 }
 
 void call_hash::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_call_hash(this);
 }
 
 call_vector::~call_vector() {
@@ -158,7 +158,7 @@ call_vector::~call_vector() {
 }
 
 void call_vector::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_call_vector(this);
 }
 
 call_function::~call_function() {
@@ -168,7 +168,7 @@ call_function::~call_function() {
 }
 
 void call_function::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_call_function(this);
 }
 
 slice_vector::~slice_vector() {
@@ -181,7 +181,7 @@ slice_vector::~slice_vector() {
 }
 
 void slice_vector::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_slice_vector(this);
 }
 
 definition_expr::~definition_expr() {
@@ -197,7 +197,7 @@ definition_expr::~definition_expr() {
 }
 
 void definition_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_definition_expr(this);
 }
 
 assignment_expr::~assignment_expr() {
@@ -210,20 +210,17 @@ assignment_expr::~assignment_expr() {
 }
 
 void assignment_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_assignment_expr(this);
 }
 
-multi_define::~multi_define() {
+multi_identifier::~multi_identifier() {
     for(auto i : variables) {
         delete i;
     }
-    if (value) {
-        delete value;
-    }
 }
 
-void multi_define::accept(ast_visitor* visitor) {
-    // TODO
+void multi_identifier::accept(ast_visitor* visitor) {
+    visitor->visit_multi_identifier(this);
 }
 
 tuple_expr::~tuple_expr() {
@@ -233,20 +230,20 @@ tuple_expr::~tuple_expr() {
 }
 
 void tuple_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_tuple_expr(this);
 }
 
 multi_assign::~multi_assign() {
-    if (left) {
-        delete left;
+    if (tuple) {
+        delete tuple;
     }
-    if (right) {
-        delete right;
+    if (value) {
+        delete value;
     }
 }
 
 void multi_assign::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_multi_assign(this);
 }
 
 while_expr::~while_expr() {
@@ -259,7 +256,7 @@ while_expr::~while_expr() {
 }
 
 void while_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_while_expr(this);
 }
 
 for_expr::~for_expr() {
@@ -278,7 +275,7 @@ for_expr::~for_expr() {
 }
 
 void for_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_for_expr(this);
 }
 
 iter_expr::~iter_expr() {
@@ -291,7 +288,7 @@ iter_expr::~iter_expr() {
 }
 
 void iter_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_iter_expr(this);
 }
 
 forei_expr::~forei_expr() {
@@ -307,7 +304,7 @@ forei_expr::~forei_expr() {
 }
 
 void forei_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_forei_expr(this);
 }
 
 condition_expr::~condition_expr() {
@@ -323,7 +320,7 @@ condition_expr::~condition_expr() {
 }
 
 void condition_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_condition_expr(this);
 }
 
 if_expr::~if_expr() {
@@ -336,15 +333,15 @@ if_expr::~if_expr() {
 }
 
 void if_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_if_expr(this);
 }
 
 void continue_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_continue_expr(this);
 }
 
 void break_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_break_expr(this);
 }
 
 return_expr::~return_expr() {
@@ -354,5 +351,5 @@ return_expr::~return_expr() {
 }
 
 void return_expr::accept(ast_visitor* visitor) {
-    // TODO
+    visitor->visit_return_expr(this);
 }
\ No newline at end of file
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index 2de3937..58ec85d 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -8,8 +8,7 @@
 
 enum class expr_type:u32 {
     ast_null=0,      // null node
-    ast_expr,        // expression node
-    ast_block,       // expression block 
+    ast_block,       // code block 
     ast_nil,         // nil keyword
     ast_num,         // number, basic value type
     ast_str,         // string, basic value type
@@ -24,21 +23,7 @@ enum class expr_type:u32 {
     ast_callv,       // id[index]
     ast_callf,       // id()
     ast_subvec,      // id[index:index]
-
     ast_param,       // function parameter
-    ast_and,         // and keyword
-    ast_or,          // or keyword
-
-    ast_equal,       // =
-    ast_addeq,       // +=
-    ast_subeq,       // -=
-    ast_multeq,      // *=
-    ast_diveq,       // /=
-    ast_lnkeq,       // ~=
-    ast_btandeq,     // &=
-    ast_btoreq,      // |=
-    ast_btxoreq,     // ^=
-
     ast_ternary,
     ast_binary,
     ast_unary,
@@ -62,23 +47,18 @@ class ast_visitor;
 class hash_pair;
 class parameter;
 class slice_vector;
-class multi_define;
+class multi_identifier;
 class code_block;
 class if_expr;
 
 class ast_abstract_node {
-public:
-    virtual void accept(ast_visitor*) = 0;
-};
-
-class expr:public ast_abstract_node {
-private:
+protected:
     span nd_loc;
     expr_type nd_type;
+
 public:
-    expr(const span& location, expr_type node_type):
+    ast_abstract_node(const span& location, expr_type node_type):
         nd_loc(location), nd_type(node_type) {}
-    ~expr() = default;
     void set_begin(u32 line, u32 column) {
         nd_loc.begin_line = line;
         nd_loc.begin_column = column;
@@ -89,6 +69,14 @@ public:
         nd_loc.end_line = location.end_line;
         nd_loc.end_column = location.end_column;
     }
+    virtual void accept(ast_visitor*) = 0;
+};
+
+class expr:public ast_abstract_node {
+public:
+    expr(const span& location, expr_type node_type):
+        ast_abstract_node(location, node_type) {}
+    ~expr() = default;
     void accept(ast_visitor*);
 };
 
@@ -152,6 +140,7 @@ public:
     bool_literal(const span& location, const bool bool_flag):
         expr(location, expr_type::ast_bool), flag(bool_flag) {}
     ~bool_literal() = default;
+    bool get_flag() const {return flag;}
     void accept(ast_visitor*) override;
 };
 
@@ -184,16 +173,17 @@ public:
 class hash_pair:public expr {
 private:
     std::string name;
-    expr* element;
+    expr* value;
 
 public:
     hash_pair(const span& location):
-        expr(location, expr_type::ast_pair) {}
+        expr(location, expr_type::ast_pair),
+        value(nullptr) {}
     ~hash_pair();
     void set_name(const std::string& field_name) {name = field_name;}
-    void set_element(expr* node) {element = node;}
+    void set_value(expr* node) {value = node;}
     const std::string& get_name() const {return name;}
-    expr* get_element() {return element;}
+    expr* get_value() {return value;}
     void accept(ast_visitor*) override;
 };
 
@@ -248,6 +238,9 @@ public:
     void set_parameter_type(param_type pt) {type = pt;}
     void set_parameter_name(identifier* node) {name = node;}
     void set_default_value(expr* node) {default_value = node;}
+    param_type get_type() {return type;}
+    identifier* get_parameter_name() {return name;}
+    expr* get_default_value() {return default_value;}
     void accept(ast_visitor*) override;
 };
 
@@ -265,6 +258,9 @@ public:
     void set_condition(expr* node) {condition = node;}
     void set_left(expr* node) {left = node;}
     void set_right(expr* node) {right = node;}
+    expr* get_condition() {return condition;}
+    expr* get_left() {return left;}
+    expr* get_right() {return right;}
     void accept(ast_visitor*) override;
 };
 
@@ -302,6 +298,9 @@ public:
     void set_type(binary_type operator_type) {type = operator_type;}
     void set_left(expr* node) {left = node;}
     void set_right(expr* node) {right = node;}
+    binary_type get_type() const {return type;}
+    expr* get_left() {return left;}
+    expr* get_right() {return right;}
     void accept(ast_visitor*) override;
 };
 
@@ -324,6 +323,8 @@ public:
     ~unary_operator();
     void set_type(unary_type operator_type) {type = operator_type;}
     void set_value(expr* node) {value = node;}
+    unary_type get_type() const {return type;}
+    expr* get_value() {return value;}
     void accept(ast_visitor*) override;
 };
 
@@ -339,6 +340,8 @@ public:
     ~call_expr();
     void set_first(expr* node) {first = node;}
     void add_call(expr* node) {calls.push_back(node);}
+    expr* get_first() {return first;}
+    std::vector<expr*>& get_calls() {return calls;}
     void accept(ast_visitor*) override;
 };
 
@@ -351,6 +354,7 @@ public:
         expr(location, expr_type::ast_callh),
         field(name) {}
     ~call_hash() = default;
+    const std::string& get_field() const {return field;}
     void accept(ast_visitor*) override;
 };
 
@@ -392,13 +396,15 @@ public:
     ~slice_vector();
     void set_begin(expr* node) {begin = node;}
     void set_end(expr* node) {end = node;}
+    expr* get_begin() {return begin;}
+    expr* get_end() {return end;}
     void accept(ast_visitor*) override;
 };
 
 class definition_expr:public expr {
 private:
     identifier* variable_name;
-    multi_define* variables;
+    multi_identifier* variables;
     expr* value;
 
 public:
@@ -407,9 +413,10 @@ public:
         variable_name(nullptr), variables(nullptr), value(nullptr) {}
     ~definition_expr();
     void set_identifier(identifier* node) {variable_name = node;}
-    void set_multi_define(multi_define* node) {variables = node;}
+    void set_multi_define(multi_identifier* node) {variables = node;}
     void set_value(expr* node) {value = node;}
-
+    identifier* get_variable_name() {return variable_name;}
+    multi_identifier* get_variables() {return variables;}
     expr* get_value() {return value;}
     void accept(ast_visitor*) override;
 };
@@ -441,25 +448,22 @@ public:
     void set_type(assign_type operator_type) {type = operator_type;}
     void set_left(expr* node) {left = node;}
     void set_right(expr* node) {right = node;}
-
     assign_type get_type() const {return type;}
     expr* get_left() {return left;}
     expr* get_right() {return right;}
     void accept(ast_visitor*) override;
 };
 
-class multi_define:public expr {
+class multi_identifier:public expr {
 private:
     std::vector<expr*> variables;
-    expr* value;
 
 public:
-    multi_define(const span& location):
-        expr(location, expr_type::ast_multi_id),
-        value(nullptr) {}
-    ~multi_define();
+    multi_identifier(const span& location):
+        expr(location, expr_type::ast_multi_id) {}
+    ~multi_identifier();
     void add_var(expr* node) {variables.push_back(node);}
-    void set_value(expr* node) {value = node;}
+    std::vector<expr*>& get_variables() {return variables;}
     void accept(ast_visitor*) override;
 };
 
@@ -472,20 +476,24 @@ public:
         expr(location, expr_type::ast_tuple) {}
     ~tuple_expr();
     void add_element(expr* node) {elements.push_back(node);}
+    std::vector<expr*>& get_elements() {return elements;}
     void accept(ast_visitor*) override;
 };
 
 class multi_assign:public expr {
 private:
-    tuple_expr* left;
-    expr* right;
+    tuple_expr* tuple;
+    expr* value;
 
 public:
     multi_assign(const span& location):
-        expr(location, expr_type::ast_multi_assign) {}
+        expr(location, expr_type::ast_multi_assign),
+        tuple(nullptr), value(nullptr) {}
     ~multi_assign();
-    void set_left(tuple_expr* node) {left = node;}
-    void set_right(expr* node) {right = node;}
+    void set_tuple(tuple_expr* node) {tuple = node;}
+    void set_value(expr* node) {value = node;}
+    tuple_expr* get_tuple() {return tuple;}
+    expr* get_value() {return value;}
     void accept(ast_visitor*) override;
 };
 
@@ -570,6 +578,7 @@ public:
     void set_iterator(iter_expr* node) {iterator = node;}
     void set_value(expr* node) {vector_node = node;}
     void set_code_block(code_block* node) {block = node;}
+    forei_loop_type get_type() const {return type;}
     iter_expr* get_iterator() {return iterator;}
     expr* get_value() {return vector_node;}
     code_block* get_code_block() {return block;}
diff --git a/ast/nasal_new_main.cpp b/ast/nasal_new_main.cpp
index 586243f..3f473b8 100644
--- a/ast/nasal_new_main.cpp
+++ b/ast/nasal_new_main.cpp
@@ -4,6 +4,7 @@
 #include "nasal_new_ast.h"
 #include "nasal_new_parse.h"
 #include "ast_visitor.h"
+#include "ast_dumper.h"
 
 #include <unordered_map>
 #include <thread>
@@ -86,15 +87,16 @@ void execute(
 
     // parser gets lexer's token list to compile
     parse.compile(lex).chkerr();
+    if (cmd&VM_AST) {
+        auto dumper = new ast_dumper();
+        dumper->visit_expr(parse.tree());
+    }
 
     // linker gets parser's ast and load import files to this ast
     // ld.link(parse, file, cmd&VM_DETAIL).chkerr();
 
     // optimizer does simple optimization on ast
     // optimize(parse.tree());
-    // if (cmd&VM_AST) {
-    //     parse.tree().dump();
-    // }
 
     // code generator gets parser's ast and import file list to generate code
     // gen.compile(parse, ld).chkerr();
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index 71bf125..00e3727 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -60,7 +60,7 @@ void parse::die(const span& loc, std::string info) {
     err.err("parse", loc, info);
 }
 
-void parse::match(tok type,const char* info) {
+void parse::match(tok type, const char* info) {
     if (!lookahead(type)) {
         if (info) {
             die(thisspan, info);
@@ -121,18 +121,10 @@ bool parse::check_func_end(expr* node) {
     auto type=node->get_type();
     if (type==expr_type::ast_func) {
         return true;
-    } else if (type==expr_type::ast_num ||
-        type==expr_type::ast_id ||
-        type==expr_type::ast_str ||
-        type==expr_type::ast_nil ||
-        type==expr_type::ast_vec ||
-        type==expr_type::ast_hash) {
-        return false;
-    }
-    if (type==expr_type::ast_def) {
-        return check_func_end(((definition_expr*)type)->get_value());
+    } else if (type==expr_type::ast_def) {
+        return check_func_end(((definition_expr*)node)->get_value());
     } else if (type==expr_type::ast_assign) {
-        return check_func_end(((assignment_expr*)type)->get_right());
+        return check_func_end(((assignment_expr*)node)->get_right());
     }
     return false;
 }
@@ -270,7 +262,7 @@ hash_pair* parse::pair() {
         match(tok::id, "expected hashmap key");
     }
     match(tok::colon);
-    node->set_element(calc());
+    node->set_value(calc());
     update_location(node);
     return node;
 }
@@ -408,7 +400,6 @@ expr* parse::calc() {
         tmp->set_right(calc());
         node = tmp;
     } else if (tok::eq<=toks[ptr].type && toks[ptr].type<=tok::lnkeq) {
-        // tok::eq~tok::lnkeq is 37 to 42,ast_equal~ast_lnkeq is 21~26
         auto tmp = new assignment_expr(toks[ptr].loc);
         switch(toks[ptr].type) {
             case tok::eq: tmp->set_type(assignment_expr::assign_type::equal); break;
@@ -518,7 +509,6 @@ expr* parse::and_expr() {
 expr* parse::cmp_expr() {
     auto node = additive_expr();
     while(tok::cmpeq<=toks[ptr].type && toks[ptr].type<=tok::geq) {
-        // tok::cmpeq~tok::geq is 43~48,ast_cmpeq~ast_geq is 27~32
         auto tmp = new binary_operator(toks[ptr].loc);
         switch(toks[ptr].type) {
             case tok::cmpeq: tmp->set_type(binary_operator::binary_type::cmpeq); break;
@@ -760,7 +750,7 @@ expr* parse::definition() {
     return node;
 }
 
-multi_define* parse::incurve_def() {
+multi_identifier* parse::incurve_def() {
     const auto& loc=toks[ptr].loc;
     match(tok::lcurve);
     match(tok::var);
@@ -771,7 +761,7 @@ multi_define* parse::incurve_def() {
     return node;
 }
 
-multi_define* parse::outcurve_def() {
+multi_identifier* parse::outcurve_def() {
     const auto& loc=toks[ptr].loc;
     match(tok::lcurve);
     auto node = multi_id();
@@ -781,8 +771,8 @@ multi_define* parse::outcurve_def() {
     return node;
 }
 
-multi_define* parse::multi_id() {
-    auto node = new multi_define(toks[ptr].loc);
+multi_identifier* parse::multi_id() {
+    auto node = new multi_identifier(toks[ptr].loc);
     while(!lookahead(tok::eof)) {
         // only identifier is allowed here
         // but we check it at codegen stage
@@ -826,16 +816,16 @@ tuple_expr* parse::multi_scalar() {
 
 multi_assign* parse::multi_assignment() {
     auto node = new multi_assign(toks[ptr].loc);
-    node->set_left(multi_scalar());
+    node->set_tuple(multi_scalar());
     match(tok::eq);
     if (lookahead(tok::eof)) {
         die(thisspan, "expected value list");
         return node;
     }
     if (lookahead(tok::lcurve)) {
-        node->set_right(check_tuple()?multi_scalar():calc());
+        node->set_value(check_tuple()?multi_scalar():calc());
     } else {
-        node->set_right(calc());
+        node->set_value(calc());
     }
     update_location(node);
     return node;
@@ -845,10 +835,10 @@ expr* parse::loop() {
     ++in_loop;
     expr* node = nullptr;
     switch(toks[ptr].type) {
-        case tok::rwhile:  node=while_loop(); break;
-        case tok::rfor:    node=for_loop();   break;
+        case tok::rwhile:  node = while_loop(); break;
+        case tok::rfor:    node = for_loop();   break;
         case tok::forindex:
-        case tok::foreach: node=forei_loop(); break;
+        case tok::foreach: node = forei_loop(); break;
         default: break;
     }
     --in_loop;
@@ -870,6 +860,7 @@ for_expr* parse::for_loop() {
     auto node = new for_expr(toks[ptr].loc);
     match(tok::rfor);
     match(tok::lcurve);
+
     // first expression
     if (lookahead(tok::eof)) {
         die(thisspan, "expected definition");
@@ -884,6 +875,7 @@ for_expr* parse::for_loop() {
         node->set_initial(calc());
     }
     match(tok::semi, "expected ';' in for(;;)");
+
     // conditional expression
     if (lookahead(tok::eof)) {
         die(thisspan, "expected conditional expr");
@@ -894,6 +886,7 @@ for_expr* parse::for_loop() {
         node->set_condition(calc());
     }
     match(tok::semi, "expected ';' in for(;;)");
+
     //after loop expression
     if (lookahead(tok::eof)) {
         die(thisspan, "expected calculation");
@@ -1009,7 +1002,7 @@ break_expr* parse::break_expression() {
 return_expr* parse::return_expression() {
     auto node = new return_expr(toks[ptr].loc);
     match(tok::ret);
-    tok type=toks[ptr].type;
+    tok type = toks[ptr].type;
     if (type==tok::tknil || type==tok::num ||
         type==tok::str || type==tok::id ||
         type==tok::func || type==tok::sub ||
diff --git a/ast/nasal_new_parse.h b/ast/nasal_new_parse.h
index 72abdd1..98b736c 100644
--- a/ast/nasal_new_parse.h
+++ b/ast/nasal_new_parse.h
@@ -120,9 +120,9 @@ private:
     call_function* callf();
     slice_vector* subvec();
     expr* definition();
-    multi_define* incurve_def();
-    multi_define* outcurve_def();
-    multi_define* multi_id();
+    multi_identifier* incurve_def();
+    multi_identifier* outcurve_def();
+    multi_identifier* multi_id();
     tuple_expr* multi_scalar();
     multi_assign* multi_assignment();
     expr* loop();
diff --git a/makefile b/makefile
index 5dfa980..3cc1563 100644
--- a/makefile
+++ b/makefile
@@ -80,11 +80,12 @@ NASAL_NEW_AST=\
 	nasal_new_ast.o\
 	nasal_new_parse.o\
 	ast_visitor.o\
+	ast_dumper.o\
 	nasal_new_main.o
 
 # for test
-nasal_new: $(NASAL_NEW_AST)
-	$(CXX) $(NASAL_NEW_AST) -o nasal_new
+nnew: $(NASAL_NEW_AST)
+	$(CXX) $(NASAL_NEW_AST) -o nnew
 	@ echo "build done"
 
 nasal_new_main.o: ast/nasal_new_main.cpp
@@ -108,6 +109,9 @@ nasal_new_parse.o: ast/nasal_new_parse.h ast/nasal_new_parse.cpp ast/nasal_new_a
 ast_visitor.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_visitor.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .
 
+ast_dumper.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_dumper.h ast/ast_dumper.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/ast_dumper.cpp -fno-exceptions -fPIC -o ast_dumper.o -I .
+
 .PHONY: nasal_new_clean
 nasal_new_clean:
 	rm $(NASAL_NEW_AST)
\ No newline at end of file

From fe40bd7e3f95297d5c7ed2e227d7046ee3fb42b2 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sun, 25 Jun 2023 22:25:13 +0800
Subject: [PATCH 15/34] :sparkles: finish ast dumper

---
 ast/ast_dumper.cpp      | 357 ++++++++++++++++++++++++----------------
 ast/ast_dumper.h        |  37 ++++-
 ast/nasal_new_main.cpp  |   4 +-
 ast/nasal_new_parse.cpp |   9 +-
 main.cpp                |   8 +-
 nasal.h                 |   2 +-
 6 files changed, 262 insertions(+), 155 deletions(-)

diff --git a/ast/ast_dumper.cpp b/ast/ast_dumper.cpp
index 0aaba4a..89293c6 100644
--- a/ast/ast_dumper.cpp
+++ b/ast/ast_dumper.cpp
@@ -2,367 +2,434 @@
 
 #include <iostream>
 
-bool ast_dumper::visit_expr(expr* node) {
-    std::cout << "expr\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
-    node->accept(this);
-    return true;
-}
-
 bool ast_dumper::visit_null_expr(null_expr* node) {
-    std::cout << "null\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "null" << format_location(node->get_location());
     return true;
 }
 
 bool ast_dumper::visit_nil_expr(nil_expr* node) {
-    std::cout << "nil\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "nil" << format_location(node->get_location());
     return true;
 }
 
 bool ast_dumper::visit_number_literal(number_literal* node) {
-    std::cout << "number " << node->get_number() << "\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "number " << node->get_number();
+    std::cout << format_location(node->get_location());
     return true;
 }
 
 bool ast_dumper::visit_string_literal(string_literal* node) {
-    std::cout << "string " << node->get_content() << "\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "string \"" << rawstr(node->get_content()) << "\"";
+    std::cout << format_location(node->get_location());
     return true;
 }
 
 bool ast_dumper::visit_identifier(identifier* node) {
-    std::cout << "identifier " << node->get_name() << "\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "identifier " << node->get_name();
+    std::cout << format_location(node->get_location());
     return true;
 }
 
 bool ast_dumper::visit_bool_literal(bool_literal* node) {
-    std::cout << "bool " << node->get_flag() << "\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "bool " << node->get_flag();
+    std::cout << format_location(node->get_location());
     return true;
 }
 
 bool ast_dumper::visit_vector_expr(vector_expr* node) {
-    std::cout << "vector\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "vector";
+    std::cout << format_location(node->get_location());
+    push_indent();
     for(auto i : node->get_elements()) {
+        if (i==node->get_elements().back()) {
+            set_last();
+        }
         i->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_hash_expr(hash_expr* node) {
-    std::cout << "hash\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "hash";
+    std::cout << format_location(node->get_location());
+    push_indent();
     for(auto i : node->get_members()) {
+        if (i==node->get_members().back()) {
+            set_last();
+        }
         i->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_hash_pair(hash_pair* node) {
-    std::cout << "pair\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "pair " << node->get_name();
+    std::cout << format_location(node->get_location());
     if (node->get_value()) {
+        push_indent();
+        set_last();
         node->get_value()->accept(this);
+        pop_indent();
     }
     return true;
 }
 
 bool ast_dumper::visit_function(function* node) {
-    std::cout << "function\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "function";
+    std::cout << format_location(node->get_location());
+    push_indent();
     for(auto i : node->get_parameter_list()) {
         i->accept(this);
     }
+    set_last();
     node->get_code_block()->accept(this);
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_code_block(code_block* node) {
-    std::cout << "block\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "block";
+    std::cout << format_location(node->get_location());
+    push_indent();
     for(auto i : node->get_expressions()) {
+        if (i==node->get_expressions().back()) {
+            set_last();
+        }
         i->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_parameter(parameter* node) {
-    std::cout << "parameter\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "parameter";
+    std::cout << format_location(node->get_location());
+    push_indent();
+    if (!node->get_default_value()) {
+        set_last();
+    }
     node->get_parameter_name()->accept(this);
     if (node->get_default_value()) {
+        set_last();
         node->get_default_value()->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_ternary_operator(ternary_operator* node) {
-    std::cout << "ternary\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "ternary";
+    std::cout << format_location(node->get_location());
+    push_indent();
     node->get_condition()->accept(this);
     node->get_left()->accept(this);
+    set_last();
     node->get_right()->accept(this);
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_binary_operator(binary_operator* node) {
-    std::cout << "binary\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "binary";
+    std::cout << format_location(node->get_location());
+    push_indent();
     node->get_left()->accept(this);
+    set_last();
     node->get_right()->accept(this);
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_unary_operator(unary_operator* node) {
-    std::cout << "unary\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "unary";
+    std::cout << format_location(node->get_location());
+    push_indent();
+    set_last();
     node->get_value()->accept(this);
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_call_expr(call_expr* node) {
-    std::cout << "call_expr\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "call_expr";
+    std::cout << format_location(node->get_location());
+    push_indent();
+    if (!node->get_calls().size()) {
+        set_last();
+    }
     node->get_first()->accept(this);
     for(auto i : node->get_calls()) {
+        if (i==node->get_calls().back()) {
+            set_last();
+        }
         i->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_call_hash(call_hash* node) {
-    std::cout << "call_hash\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "call_hash" << node->get_field();
+    std::cout << format_location(node->get_location());
     return true;
 }
 
 bool ast_dumper::visit_call_vector(call_vector* node) {
-    std::cout << "call_vector\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "call_vector";
+    std::cout << format_location(node->get_location());
+    push_indent();
     for(auto i : node->get_slices()) {
+        if (i==node->get_slices().back()) {
+            set_last();
+        }
         i->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_call_function(call_function* node) {
-    std::cout << "call_function\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "call_function";
+    std::cout << format_location(node->get_location());
+    push_indent();
     for(auto i : node->get_argument()) {
+        if (i==node->get_argument().back()) {
+            set_last();
+        }
         i->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_slice_vector(slice_vector* node) {
-    std::cout << "slice\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "slice";
+    std::cout << format_location(node->get_location());
+    push_indent();
+    if (!node->get_end()) {
+        set_last();
+    }
     node->get_begin()->accept(this);
     if (node->get_end()) {
+        set_last();
         node->get_end()->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_definition_expr(definition_expr* node) {
-    std::cout << "definition\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "definition";
+    std::cout << format_location(node->get_location());
+    push_indent();
     if (node->get_variable_name()) {
         node->get_variable_name()->accept(this);
     } else {
         node->get_variables()->accept(this);
     }
+    set_last();
     node->get_value()->accept(this);
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_assignment_expr(assignment_expr* node) {
-    std::cout << "assignment\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "assignment";
+    std::cout << format_location(node->get_location());
+    push_indent();
     node->get_left()->accept(this);
+    set_last();
     node->get_right()->accept(this);
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_multi_identifier(multi_identifier* node) {
-    std::cout << "multi_define\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "multi_define";
+    std::cout << format_location(node->get_location());
+    push_indent();
     for(auto i : node->get_variables()) {
+        if (i==node->get_variables().back()) {
+            set_last();
+        }
         i->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_tuple_expr(tuple_expr* node) {
-    std::cout << "tuple\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "tuple";
+    std::cout << format_location(node->get_location());
+    push_indent();
     for(auto i : node->get_elements()) {
+        if (i==node->get_elements().back()) {
+            set_last();
+        }
         i->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_multi_assign(multi_assign* node) {
-    std::cout << "multi_assign\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "multi_assign";
+    std::cout << format_location(node->get_location());
+    push_indent();
     node->get_tuple()->accept(this);
+    set_last();
     node->get_value()->accept(this);
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_while_expr(while_expr* node) {
-    std::cout << "while\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "while";
+    std::cout << format_location(node->get_location());
+    push_indent();
     node->get_condition()->accept(this);
+    set_last();
     node->get_code_block()->accept(this);
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_for_expr(for_expr* node) {
-    std::cout << "for\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "for";
+    std::cout << format_location(node->get_location());
+    push_indent();
     node->get_initial()->accept(this);
     node->get_condition()->accept(this);
     node->get_step()->accept(this);
+    set_last();
     node->get_code_block()->accept(this);
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_iter_expr(iter_expr* node) {
-    std::cout << "iter\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "iter";
+    std::cout << format_location(node->get_location());
+    push_indent();
+    set_last();
     if (node->get_name()) {
         node->get_name()->accept(this);
     } else {
         node->get_call()->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_forei_expr(forei_expr* node) {
-    std::cout << "forei\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    if (node->get_type()==forei_expr::forei_loop_type::foreach) {
+        std::cout << "foreach";
+    } else {
+        std::cout << "forindex";
+    }
+    std::cout << format_location(node->get_location());
+    push_indent();
     node->get_iterator()->accept(this);
     node->get_value()->accept(this);
+    set_last();
     node->get_code_block()->accept(this);
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_condition_expr(condition_expr* node) {
-    std::cout << "condition\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "condition";
+    std::cout << format_location(node->get_location());
+    push_indent();
+    if (!node->get_elsif_stataments().size() &&
+        !node->get_else_statement()) {
+        set_last();
+    }
     node->get_if_statement()->accept(this);
     for(auto i : node->get_elsif_stataments()) {
+        if (i==node->get_elsif_stataments().back() &&
+            !node->get_else_statement()) {
+            set_last();
+        }
         i->accept(this);
     }
     if (node->get_else_statement()) {
+        set_last();
         node->get_else_statement()->accept(this);
     }
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_if_expr(if_expr* node) {
-    std::cout << "if\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "if";
+    std::cout << format_location(node->get_location());
+    push_indent();
     if (node->get_condition()) {
         node->get_condition()->accept(this);
     }
+    set_last();
     node->get_code_block()->accept(this);
+    pop_indent();
     return true;
 }
 
 bool ast_dumper::visit_continue_expr(continue_expr* node) {
-    std::cout << "continue\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "continue";
+    std::cout << format_location(node->get_location());
     return true;
 }
 
 bool ast_dumper::visit_break_expr(break_expr* node) {
-    std::cout << "break\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "break";
+    std::cout << format_location(node->get_location());
     return true;
 }
 
 bool ast_dumper::visit_return_expr(return_expr* node) {
-    std::cout << "return\n";
-    std::cout << " -> " << node->get_location().file << ":"
-    << node->get_location().begin_line << ":"
-    << node->get_location().begin_column << "\n";
+    dump_indent();
+    std::cout << "return";
+    std::cout << format_location(node->get_location());
     if (node->get_value()) {
+        push_indent();
+        set_last();
         node->get_value()->accept(this);
+        pop_indent();
     }
     return true;
 }
\ No newline at end of file
diff --git a/ast/ast_dumper.h b/ast/ast_dumper.h
index 4599537..e6fbb51 100644
--- a/ast/ast_dumper.h
+++ b/ast/ast_dumper.h
@@ -2,9 +2,44 @@
 
 #include "ast_visitor.h"
 
+#include <iostream>
+#include <cstring>
+#include <sstream>
+
 class ast_dumper:public ast_visitor {
+private:
+    std::vector<std::string> indent;
+    void push_indent() {
+        if (indent.size()) {
+            if (indent.back()=="|--") {
+                indent.back() = "|  ";
+            } else if (indent.back()=="+--") {
+                indent.back() = "   ";
+            }
+            // indent.back() = (indent.back()=="|--")? "|  ":"   ";
+        }
+        indent.push_back("|--");
+    }
+    void pop_indent() {indent.pop_back();}
+    void set_last() {indent.back() = "+--";}
+    void dump_indent() {
+        if (indent.size() && indent.back()=="|  ") {
+            indent.back() = "|--";
+        }
+        for(const auto& i : indent) {
+            std::cout << i;
+        }
+    }
+    std::string format_location(const span& location) {
+        std::stringstream ss;
+        ss << " -> ";
+        ss << location.file << ":";
+        ss << location.begin_line << ":" << location.begin_column;
+        ss << "\n";
+        return ss.str();
+    }
+
 public:
-    bool visit_expr(expr*) override;
     bool visit_null_expr(null_expr*) override;
     bool visit_nil_expr(nil_expr*) override;
     bool visit_number_literal(number_literal*) override;
diff --git a/ast/nasal_new_main.cpp b/ast/nasal_new_main.cpp
index 3f473b8..6ba6175 100644
--- a/ast/nasal_new_main.cpp
+++ b/ast/nasal_new_main.cpp
@@ -51,7 +51,7 @@ std::ostream& logo(std::ostream& out) {
     <<"  \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
     <<"ver  : "<<__nasver<<" ("<<__DATE__<<" "<<__TIME__<<")\n"
     <<"std  : c++ "<<__cplusplus<<"\n"
-    <<"core : "<<std::thread::hardware_concurrency()<<" cores\n"
+    <<"core : "<<std::thread::hardware_concurrency()<<" core(s)\n"
     <<"repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
     <<"repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
     <<"wiki : https://wiki.flightgear.org/Nasal_scripting_language\n"
@@ -89,7 +89,7 @@ void execute(
     parse.compile(lex).chkerr();
     if (cmd&VM_AST) {
         auto dumper = new ast_dumper();
-        dumper->visit_expr(parse.tree());
+        dumper->visit_code_block(parse.tree());
     }
 
     // linker gets parser's ast and load import files to this ast
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index 00e3727..e175910 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -610,7 +610,7 @@ expr* parse::scalar() {
     } else if (lookahead(tok::lbrace)) {
         node = hash();
     } else if (lookahead(tok::lcurve)) {
-        const auto& loc=toks[ptr].loc;
+        const auto& loc = toks[ptr].loc;
         match(tok::lcurve);
         node = calc();
         node->set_begin(loc.begin_line, loc.begin_column);
@@ -625,7 +625,7 @@ expr* parse::scalar() {
         node = def_node;
     } else {
         die(thisspan, "expected scalar");
-        return node;
+        return null();
     }
     // check call and avoid ambiguous syntax
     if (is_call(toks[ptr].type) && !(lookahead(tok::lcurve) && toks[ptr+1].type==tok::var)) {
@@ -839,7 +839,10 @@ expr* parse::loop() {
         case tok::rfor:    node = for_loop();   break;
         case tok::forindex:
         case tok::foreach: node = forei_loop(); break;
-        default: break;
+        default:
+            die(thisspan, "unreachable");
+            node = null();
+            break;
     }
     --in_loop;
     return node;
diff --git a/main.cpp b/main.cpp
index aef7268..084e28d 100644
--- a/main.cpp
+++ b/main.cpp
@@ -11,6 +11,7 @@
 #include "nasal_vm.h"
 #include "nasal_dbg.h"
 
+#include <thread>
 #include <unordered_map>
 
 const u32 VM_AST   =0x01;
@@ -55,6 +56,7 @@ std::ostream& logo(std::ostream& out) {
     <<"  \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
     <<"ver  : "<<__nasver<<" ("<<__DATE__<<" "<<__TIME__<<")\n"
     <<"std  : c++ "<<__cplusplus<<"\n"
+    <<"core : "<<std::thread::hardware_concurrency()<<" core(s)\n"
     <<"repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
     <<"repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
     <<"wiki : https://wiki.flightgear.org/Nasal_scripting_language\n"
@@ -90,15 +92,15 @@ void execute(
 
     // parser gets lexer's token list to compile
     parse.compile(lex).chkerr();
+    if (cmd&VM_AST) {
+        parse.tree().dump();
+    }
 
     // linker gets parser's ast and load import files to this ast
     ld.link(parse, file, cmd&VM_DETAIL).chkerr();
 
     // optimizer does simple optimization on ast
     optimize(parse.tree());
-    if (cmd&VM_AST) {
-        parse.tree().dump();
-    }
 
     // code generator gets parser's ast and import file list to generate code
     gen.compile(parse, ld).chkerr();
diff --git a/nasal.h b/nasal.h
index 9624c35..7290f62 100644
--- a/nasal.h
+++ b/nasal.h
@@ -105,7 +105,7 @@ using usize=std::size_t;
 using f64=double;
 using std::string;
 
-const u32 STACK_DEPTH=1024;
+const u32 STACK_DEPTH=4096;
 
 f64 hex2f(const char* str) {
     f64 ret=0;

From fb3d9ed2f30358bdab492909d272aad8d8a54035 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sun, 25 Jun 2023 22:47:36 +0800
Subject: [PATCH 16/34] :sparkles: update

---
 ast/ast_dumper.cpp | 37 ++++++++++++++++++++++++++++++-------
 ast/ast_dumper.h   |  1 -
 2 files changed, 30 insertions(+), 8 deletions(-)

diff --git a/ast/ast_dumper.cpp b/ast/ast_dumper.cpp
index 89293c6..6c26c09 100644
--- a/ast/ast_dumper.cpp
+++ b/ast/ast_dumper.cpp
@@ -133,7 +133,7 @@ bool ast_dumper::visit_parameter(parameter* node) {
 
 bool ast_dumper::visit_ternary_operator(ternary_operator* node) {
     dump_indent();
-    std::cout << "ternary";
+    std::cout << "ternary_operator";
     std::cout << format_location(node->get_location());
     push_indent();
     node->get_condition()->accept(this);
@@ -146,7 +146,25 @@ bool ast_dumper::visit_ternary_operator(ternary_operator* node) {
 
 bool ast_dumper::visit_binary_operator(binary_operator* node) {
     dump_indent();
-    std::cout << "binary";
+    std::cout << "binary_operator ";
+    switch(node->get_type()) {
+        case binary_operator::binary_type::add: std::cout << "+"; break;
+        case binary_operator::binary_type::sub: std::cout << "-"; break;
+        case binary_operator::binary_type::mult: std::cout << "*"; break;
+        case binary_operator::binary_type::div: std::cout << "/"; break;
+        case binary_operator::binary_type::concat: std::cout << "~"; break;
+        case binary_operator::binary_type::bitwise_and: std::cout << "&"; break;
+        case binary_operator::binary_type::bitwise_or: std::cout << "|"; break;
+        case binary_operator::binary_type::bitwise_xor: std::cout << "^"; break;
+        case binary_operator::binary_type::cmpeq: std::cout << "=="; break;
+        case binary_operator::binary_type::cmpneq: std::cout << "!="; break;
+        case binary_operator::binary_type::grt: std::cout << ">"; break;
+        case binary_operator::binary_type::geq: std::cout << ">="; break;
+        case binary_operator::binary_type::less: std::cout << "<"; break;
+        case binary_operator::binary_type::leq: std::cout << "<="; break;
+        case binary_operator::binary_type::condition_and: std::cout << "and"; break;
+        case binary_operator::binary_type::condition_or: std::cout << "or"; break;
+    }
     std::cout << format_location(node->get_location());
     push_indent();
     node->get_left()->accept(this);
@@ -158,7 +176,12 @@ bool ast_dumper::visit_binary_operator(binary_operator* node) {
 
 bool ast_dumper::visit_unary_operator(unary_operator* node) {
     dump_indent();
-    std::cout << "unary";
+    std::cout << "unary_operator ";
+    switch(node->get_type()) {
+        case unary_operator::unary_type::negative: std::cout << "-"; break;
+        case unary_operator::unary_type::logical_not: std::cout << "!"; break;
+        case unary_operator::unary_type::bitwise_not: std::cout << "~"; break;
+    }
     std::cout << format_location(node->get_location());
     push_indent();
     set_last();
@@ -188,7 +211,7 @@ bool ast_dumper::visit_call_expr(call_expr* node) {
 
 bool ast_dumper::visit_call_hash(call_hash* node) {
     dump_indent();
-    std::cout << "call_hash" << node->get_field();
+    std::cout << "call_hash " << node->get_field();
     std::cout << format_location(node->get_location());
     return true;
 }
@@ -270,7 +293,7 @@ bool ast_dumper::visit_assignment_expr(assignment_expr* node) {
 
 bool ast_dumper::visit_multi_identifier(multi_identifier* node) {
     dump_indent();
-    std::cout << "multi_define";
+    std::cout << "multiple_definition";
     std::cout << format_location(node->get_location());
     push_indent();
     for(auto i : node->get_variables()) {
@@ -300,7 +323,7 @@ bool ast_dumper::visit_tuple_expr(tuple_expr* node) {
 
 bool ast_dumper::visit_multi_assign(multi_assign* node) {
     dump_indent();
-    std::cout << "multi_assign";
+    std::cout << "multiple_assignment";
     std::cout << format_location(node->get_location());
     push_indent();
     node->get_tuple()->accept(this);
@@ -338,7 +361,7 @@ bool ast_dumper::visit_for_expr(for_expr* node) {
 
 bool ast_dumper::visit_iter_expr(iter_expr* node) {
     dump_indent();
-    std::cout << "iter";
+    std::cout << "iterator";
     std::cout << format_location(node->get_location());
     push_indent();
     set_last();
diff --git a/ast/ast_dumper.h b/ast/ast_dumper.h
index e6fbb51..ce868a0 100644
--- a/ast/ast_dumper.h
+++ b/ast/ast_dumper.h
@@ -16,7 +16,6 @@ private:
             } else if (indent.back()=="+--") {
                 indent.back() = "   ";
             }
-            // indent.back() = (indent.back()=="|--")? "|  ":"   ";
         }
         indent.push_back("|--");
     }

From 8a10f07ce7fc65529e4dd4a32d8a4b213245a57a Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Mon, 26 Jun 2023 19:35:21 +0800
Subject: [PATCH 17/34] :sparkles: change parameter::name to std::string

---
 ast/ast_dumper.cpp      | 10 +++-------
 ast/ast_visitor.cpp     |  1 -
 ast/nasal_new_ast.cpp   |  3 ---
 ast/nasal_new_ast.h     | 23 ++++++++---------------
 ast/nasal_new_parse.cpp | 20 ++++++++++----------
 stl/lib.nas             |  3 +--
 6 files changed, 22 insertions(+), 38 deletions(-)

diff --git a/ast/ast_dumper.cpp b/ast/ast_dumper.cpp
index 6c26c09..47adbd2 100644
--- a/ast/ast_dumper.cpp
+++ b/ast/ast_dumper.cpp
@@ -116,18 +116,14 @@ bool ast_dumper::visit_code_block(code_block* node) {
 
 bool ast_dumper::visit_parameter(parameter* node) {
     dump_indent();
-    std::cout << "parameter";
+    std::cout << "parameter " << node->get_parameter_name();
     std::cout << format_location(node->get_location());
-    push_indent();
-    if (!node->get_default_value()) {
-        set_last();
-    }
-    node->get_parameter_name()->accept(this);
     if (node->get_default_value()) {
+        push_indent();
         set_last();
         node->get_default_value()->accept(this);
+        pop_indent();
     }
-    pop_indent();
     return true;
 }
 
diff --git a/ast/ast_visitor.cpp b/ast/ast_visitor.cpp
index e641856..7284724 100644
--- a/ast/ast_visitor.cpp
+++ b/ast/ast_visitor.cpp
@@ -66,7 +66,6 @@ bool ast_visitor::visit_code_block(code_block* node) {
 }
 
 bool ast_visitor::visit_parameter(parameter* node) {
-    node->get_parameter_name()->accept(this);
     if (node->get_default_value()) {
         node->get_default_value()->accept(this);
     }
diff --git a/ast/nasal_new_ast.cpp b/ast/nasal_new_ast.cpp
index c6d7c16..4ad8131 100644
--- a/ast/nasal_new_ast.cpp
+++ b/ast/nasal_new_ast.cpp
@@ -83,9 +83,6 @@ void code_block::accept(ast_visitor* visitor) {
 }
 
 parameter::~parameter() {
-    if (name) {
-        delete name;
-    }
     if (default_value) {
         delete default_value;
     }
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index 58ec85d..a16d6a9 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -51,14 +51,15 @@ class multi_identifier;
 class code_block;
 class if_expr;
 
-class ast_abstract_node {
+class expr {
 protected:
     span nd_loc;
     expr_type nd_type;
 
 public:
-    ast_abstract_node(const span& location, expr_type node_type):
+    expr(const span& location, expr_type node_type):
         nd_loc(location), nd_type(node_type) {}
+    ~expr() = default;
     void set_begin(u32 line, u32 column) {
         nd_loc.begin_line = line;
         nd_loc.begin_column = column;
@@ -69,15 +70,7 @@ public:
         nd_loc.end_line = location.end_line;
         nd_loc.end_column = location.end_column;
     }
-    virtual void accept(ast_visitor*) = 0;
-};
-
-class expr:public ast_abstract_node {
-public:
-    expr(const span& location, expr_type node_type):
-        ast_abstract_node(location, node_type) {}
-    ~expr() = default;
-    void accept(ast_visitor*);
+    virtual void accept(ast_visitor*);
 };
 
 class null_expr:public expr {
@@ -227,19 +220,19 @@ public:
 
 private:
     param_type type;
-    identifier* name;
+    std::string name;
     expr* default_value;
 
 public:
     parameter(const span& location):
         expr(location, expr_type::ast_param),
-        name(nullptr), default_value(nullptr) {}
+        name(""), default_value(nullptr) {}
     ~parameter();
     void set_parameter_type(param_type pt) {type = pt;}
-    void set_parameter_name(identifier* node) {name = node;}
+    void set_parameter_name(const std::string& pname) {name = pname;}
     void set_default_value(expr* node) {default_value = node;}
     param_type get_type() {return type;}
-    identifier* get_parameter_name() {return name;}
+    const std::string& get_parameter_name() const {return name;}
     expr* get_default_value() {return default_value;}
     void accept(ast_visitor*) override;
 };
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index e175910..a306be5 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -284,16 +284,16 @@ void parse::params(function* func_node) {
     match(tok::lcurve);
     while(!lookahead(tok::rcurve)) {
         auto param = new parameter(toks[ptr].loc);
-        param->set_parameter_name(id());
-        if (lookahead(tok::eq) || lookahead(tok::ellipsis)) {
-            if (lookahead(tok::eq)) {
-                match(tok::eq);
-                param->set_parameter_type(parameter::param_type::default_parameter);
-                param->set_default_value(calc());
-            } else {
-                match(tok::ellipsis);
-                param->set_parameter_type(parameter::param_type::dynamic_parameter);
-            }
+        auto id_node = id();
+        param->set_parameter_name(id_node->get_name());
+        delete id_node;
+        if (lookahead(tok::eq)) {
+            match(tok::eq);
+            param->set_parameter_type(parameter::param_type::default_parameter);
+            param->set_default_value(calc());
+        } else if (lookahead(tok::ellipsis)) {
+            match(tok::ellipsis);
+            param->set_parameter_type(parameter::param_type::dynamic_parameter);
         } else {
             param->set_parameter_type(parameter::param_type::normal_parameter);
         }
diff --git a/stl/lib.nas b/stl/lib.nas
index b7f734e..07e037f 100644
--- a/stl/lib.nas
+++ b/stl/lib.nas
@@ -222,8 +222,7 @@ var isfunc=func(f){
 }
 
 var isghost=func(g){
-    die("this runtime has no ghost object");
-    return 0;
+    return typeof(f)=="obj";
 }
 
 var ishash=func(h){

From 89f96d407b99a924dd28b1ac23eacd8e88b93fb9 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Mon, 26 Jun 2023 19:35:56 +0800
Subject: [PATCH 18/34] :bug: fix bug

---
 stl/lib.nas | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/lib.nas b/stl/lib.nas
index 07e037f..d8e3ba3 100644
--- a/stl/lib.nas
+++ b/stl/lib.nas
@@ -222,7 +222,7 @@ var isfunc=func(f){
 }
 
 var isghost=func(g){
-    return typeof(f)=="obj";
+    return typeof(g)=="obj";
 }
 
 var ishash=func(h){

From c516c0c3bf67d3156badc76c30c215f191329145 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Mon, 26 Jun 2023 23:59:09 +0800
Subject: [PATCH 19/34] :sparkles: add new import & use c++17

---
 CMakeLists.txt           |   2 +-
 README.md                |   2 +-
 ast/ast_dumper.cpp       |   7 ++
 ast/ast_dumper.h         |   3 +-
 ast/ast_visitor.cpp      |   4 +
 ast/ast_visitor.h        |   1 +
 ast/nasal_new_ast.cpp    |   4 +
 ast/nasal_new_ast.h      |  16 +++
 ast/nasal_new_import.cpp | 217 +++++++++++++++++++++++++++++++++++++++
 ast/nasal_new_import.h   |  40 ++++++++
 ast/nasal_new_lexer.cpp  |   8 +-
 ast/nasal_new_main.cpp   |   9 +-
 ast/nasal_new_parse.h    |  14 ++-
 makefile                 |   8 +-
 module/makefile          |   2 +-
 15 files changed, 322 insertions(+), 15 deletions(-)
 create mode 100644 ast/nasal_new_import.cpp
 create mode 100644 ast/nasal_new_import.h

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 9fe5c8e..4850541 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -5,7 +5,7 @@ project(nasal VERSION 10.1)
 message("CMAKE_HOST_SYSTEM_NAME: ${CMAKE_HOST_SYSTEM_NAME}")
 
 # -std=c++14 -Wshadow -Wall
-set(CMAKE_CXX_STANDARD 14)
+set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_CXX_FLAGS_RELEASE_INIT "-Wshadow -Wall")
 
diff --git a/README.md b/README.md
index df4a46f..5f72b5d 100644
--- a/README.md
+++ b/README.md
@@ -32,7 +32,7 @@ __Contact us if having great ideas to share!__
 is an ECMAscript-like language used in [FlightGear](https://www.flightgear.org/).
 The designer is [Andy Ross](https://github.com/andyross).
 
-This interpreter is totally rewritten by [ValKmjolnir](https://github.com/ValKmjolnir) using `C++`(`-std=c++14`)
+This interpreter is totally rewritten by [ValKmjolnir](https://github.com/ValKmjolnir) using `C++`(`-std=c++17`)
 without reusing the code in [Andy Ross's nasal interpreter](https://github.com/andyross/nasal).
 But we really appreciate that Andy created this amazing programming language.
 
diff --git a/ast/ast_dumper.cpp b/ast/ast_dumper.cpp
index 47adbd2..21c7ff6 100644
--- a/ast/ast_dumper.cpp
+++ b/ast/ast_dumper.cpp
@@ -2,6 +2,13 @@
 
 #include <iostream>
 
+bool ast_dumper::visit_file_info(file_info* node) {
+    dump_indent();
+    std::cout << "file \"" << node->get_file_name() << "\"";
+    std::cout << format_location(node->get_location());
+    return true;
+}
+
 bool ast_dumper::visit_null_expr(null_expr* node) {
     dump_indent();
     std::cout << "null" << format_location(node->get_location());
diff --git a/ast/ast_dumper.h b/ast/ast_dumper.h
index ce868a0..25a26e4 100644
--- a/ast/ast_dumper.h
+++ b/ast/ast_dumper.h
@@ -33,12 +33,13 @@ private:
         std::stringstream ss;
         ss << " -> ";
         ss << location.file << ":";
-        ss << location.begin_line << ":" << location.begin_column;
+        ss << location.begin_line << ":" << location.begin_column + 1;
         ss << "\n";
         return ss.str();
     }
 
 public:
+    bool visit_file_info(file_info*) override;
     bool visit_null_expr(null_expr*) override;
     bool visit_nil_expr(nil_expr*) override;
     bool visit_number_literal(number_literal*) override;
diff --git a/ast/ast_visitor.cpp b/ast/ast_visitor.cpp
index 7284724..6d8c3e1 100644
--- a/ast/ast_visitor.cpp
+++ b/ast/ast_visitor.cpp
@@ -5,6 +5,10 @@ bool ast_visitor::visit_expr(expr* node) {
     return true;
 }
 
+bool ast_visitor::visit_file_info(file_info* node) {
+    return true;
+}
+
 bool ast_visitor::visit_null_expr(null_expr* node) {
     return true;
 }
diff --git a/ast/ast_visitor.h b/ast/ast_visitor.h
index ff30483..e9b407f 100644
--- a/ast/ast_visitor.h
+++ b/ast/ast_visitor.h
@@ -5,6 +5,7 @@
 class ast_visitor {
 public:
     virtual bool visit_expr(expr*);
+    virtual bool visit_file_info(file_info*);
     virtual bool visit_null_expr(null_expr*);
     virtual bool visit_nil_expr(nil_expr*);
     virtual bool visit_number_literal(number_literal*);
diff --git a/ast/nasal_new_ast.cpp b/ast/nasal_new_ast.cpp
index 4ad8131..cbc6bd1 100644
--- a/ast/nasal_new_ast.cpp
+++ b/ast/nasal_new_ast.cpp
@@ -5,6 +5,10 @@ void expr::accept(ast_visitor* visitor) {
     visitor->visit_expr(this);
 }
 
+void file_info::accept(ast_visitor* visitor) {
+    visitor->visit_file_info(this);
+}
+
 void null_expr::accept(ast_visitor* visitor) {
     visitor->visit_null_expr(this);
 }
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index a16d6a9..0def471 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -8,6 +8,7 @@
 
 enum class expr_type:u32 {
     ast_null=0,      // null node
+    ast_file_info,   // stores file info
     ast_block,       // code block 
     ast_nil,         // nil keyword
     ast_num,         // number, basic value type
@@ -73,6 +74,21 @@ public:
     virtual void accept(ast_visitor*);
 };
 
+class file_info:public expr {
+private:
+    uint16_t index;
+    std::string filename;
+
+public:
+    file_info(const span& location, uint16_t file_index, const std::string& name):
+        expr(location, expr_type::ast_file_info),
+        index(file_index), filename(name) {}
+    ~file_info() = default;
+    uint16_t get_index() const {return index;}
+    const std::string& get_file_name() const {return filename;}
+    void accept(ast_visitor*) override;
+};
+
 class null_expr:public expr {
 public:
     null_expr(const span& location):
diff --git a/ast/nasal_new_import.cpp b/ast/nasal_new_import.cpp
new file mode 100644
index 0000000..535ee37
--- /dev/null
+++ b/ast/nasal_new_import.cpp
@@ -0,0 +1,217 @@
+#include "nasal_new_import.h"
+
+linker::linker(error& e): show_path(false), lib_loaded(false), err(e) {
+    char sep=is_windows()? ';':':';
+    std::string PATH=getenv("PATH");
+    usize last=0;
+    usize pos=PATH.find(sep, 0);
+    while(pos!=std::string::npos) {
+        std::string dirpath=PATH.substr(last, pos-last);
+        if (dirpath.length()) {
+            envpath.push_back(dirpath);
+        }
+        last=pos+1;
+        pos=PATH.find(sep, last);
+    }
+    if (last!=PATH.length()) {
+        envpath.push_back(PATH.substr(last));
+    }
+}
+
+std::string linker::get_path(call_expr* node) {
+    if (node->get_calls()[0]->get_type()==expr_type::ast_callf) {
+        auto tmp = (call_function*)node->get_calls()[0];
+        return ((string_literal*)tmp->get_argument()[0])->get_content();
+    }
+    auto fpath = std::string(".");
+    for(auto i : node->get_calls()) {
+        fpath += (is_windows()? "\\":"/") + ((call_hash*)i)->get_field();
+    }
+    return fpath + ".nas";
+}
+
+std::string linker::find_file(const std::string& filename) {
+    // first add file name itself into the file path
+    std::vector<std::string> fpath = {filename};
+
+    // generate search path from environ path
+    for(const auto& p : envpath) {
+        fpath.push_back(p + (is_windows()? "\\":"/") + filename);
+    }
+
+    // search file
+    for(const auto& i : fpath) {
+        if (access(i.c_str(), F_OK)!=-1) {
+            return i;
+        }
+    }
+
+    // we will find lib.nas in nasal std directory
+    if (filename=="lib.nas") {
+        return is_windows()? find_file("stl\\lib.nas"):find_file("stl/lib.nas");
+    }
+    if (!show_path) {
+        err.err("link", "cannot find file <" + filename + ">");
+        return "";
+    }
+    std::string paths = "";
+    for(const auto& i : fpath) {
+        paths += "  " + i + "\n";
+    }
+    err.err("link", "cannot find file <" + filename + "> in these paths:\n" + paths);
+    return "";
+}
+
+bool linker::import_check(expr* node) {
+/*
+    call
+    |_id:import
+    |_callh:stl
+    |_callh:file
+*/
+    if (node->get_type()!=expr_type::ast_call) {
+        return false;
+    }
+    auto tmp = (call_expr*)node;
+    if (tmp->get_first()->get_type()!=expr_type::ast_id) {
+        return false;
+    }
+    if (((identifier*)tmp->get_first())->get_name()!="import") {
+        return false;
+    }
+    if (!tmp->get_calls().size()) {
+        return false;
+    }
+    // import.xxx.xxx;
+    if (tmp->get_calls()[0]->get_type()==expr_type::ast_callh) {
+        for(auto i : tmp->get_calls()) {
+            if (i->get_type()!=expr_type::ast_callh) {
+                return false;
+            }
+        }
+        return true;
+    }
+    // import("xxx");
+    if (tmp->get_calls().size()!=1) {
+        return false;
+    }
+/*
+    call
+    |_id:import
+    |_call_func
+      |_string:'filename'
+*/
+    if (tmp->get_calls()[0]->get_type()!=expr_type::ast_callf) {
+        return false;
+    }
+    auto func_call = (call_function*)tmp->get_calls()[0];
+    if (func_call->get_argument().size()!=1) {
+        return false;
+    }
+    if (func_call->get_argument()[0]->get_type()!=expr_type::ast_str) {
+        return false;
+    }
+    return true;
+}
+
+bool linker::exist(const std::string& file) {
+    // avoid importing the same file
+    for(const auto& fname : files) {
+        if (file==fname) {
+            return true;
+        }
+    }
+    files.push_back(file);
+    return false;
+}
+
+void linker::link(code_block* new_tree_root, code_block* old_tree_root) {
+    // add children of add_root to the back of root
+    for(auto& i:old_tree_root->get_expressions()) {
+        new_tree_root->add_expression(i);
+    }
+    // clean old root
+    old_tree_root->get_expressions().clear();
+}
+
+code_block* linker::import_regular_file(call_expr* node) {
+    lexer lex(err);
+    parse par(err);
+    // get filename and set node to ast_null
+    auto filename = get_path(node);
+    // node.clear();
+
+    // avoid infinite loading loop
+    filename = find_file(filename);
+    if (!filename.length() || exist(filename)) {
+        return new code_block({0, 0, 0, 0, filename});
+    }
+    
+    // start importing...
+    lex.scan(filename);
+    par.compile(lex);
+    auto tmp = par.swap(nullptr);
+
+    // check if tmp has 'import'
+    return load(tmp, files.size()-1);
+}
+
+code_block* linker::import_nasal_lib() {
+    lexer lex(err);
+    parse par(err);
+    auto filename = find_file("lib.nas");
+    if (!filename.length()) {
+        return new code_block({0, 0, 0, 0, filename});
+    }
+
+    // avoid infinite loading loop
+    if (exist(filename)) {
+        return new code_block({0, 0, 0, 0, filename});
+    }
+    
+    // start importing...
+    lex.scan(filename);
+    par.compile(lex);
+    auto tmp = par.swap(nullptr);
+
+    // check if tmp has 'import'
+    return load(tmp, files.size()-1);
+}
+
+code_block* linker::load(code_block* root, u16 fileindex) {
+    auto tree = new code_block({0, 0, 0, 0, files[fileindex]});
+    if (!lib_loaded) {
+        auto tmp = import_nasal_lib();
+        link(tree, tmp);
+        delete tmp;
+        lib_loaded = true;
+    }
+    for(auto i : root->get_expressions()) {
+        if (!import_check(i)) {
+            break;
+        }
+        auto tmp = import_regular_file((call_expr*)i);
+        link(tree, tmp);
+        delete tmp;
+    }
+    // add root to the back of tree
+    auto file_head = new file_info(
+        {0, 0, 0, 0, files[fileindex]}, fileindex, files[fileindex]);
+    tree->add_expression(file_head);
+    link(tree, root);
+    return tree;
+}
+
+const error& linker::link(
+    parse& parse, const std::string& self, bool spath = false) {
+    show_path = spath;
+    // initializing
+    files = {self};
+    // scan root and import files
+    // then generate a new ast and return to import_ast
+    // the main file's index is 0
+    auto new_tree_root = load(parse.tree(), 0);
+    auto old_tree_root = parse.swap(new_tree_root);
+    delete old_tree_root;
+    return err;
+}
diff --git a/ast/nasal_new_import.h b/ast/nasal_new_import.h
new file mode 100644
index 0000000..09d12b6
--- /dev/null
+++ b/ast/nasal_new_import.h
@@ -0,0 +1,40 @@
+#pragma once
+
+#ifndef _MSC_VER
+#include <unistd.h>
+#else
+#define _CRT_SECURE_NO_DEPRECATE 1
+#define _CRT_NONSTDC_NO_DEPRECATE 1
+#include <io.h>
+#endif
+
+#ifdef _MSC_VER
+#define F_OK 0
+#endif
+
+#include "nasal_new_header.h"
+#include "nasal_new_ast.h"
+#include "nasal_new_lexer.h"
+#include "nasal_new_parse.h"
+
+class linker{
+private:
+    bool show_path;
+    bool lib_loaded;
+    error& err;
+    std::vector<std::string> files;
+    std::vector<std::string> envpath;
+
+    bool import_check(expr*);
+    bool exist(const std::string&);
+    void link(code_block*, code_block*);
+    std::string get_path(call_expr*);
+    std::string find_file(const std::string&);
+    code_block* import_regular_file(call_expr*);
+    code_block* import_nasal_lib();
+    code_block* load(code_block*, u16);
+public:
+    linker(error&);
+    const error& link(parse&, const std::string&, bool);
+    const std::vector<std::string>& filelist() const {return files;}
+};
diff --git a/ast/nasal_new_lexer.cpp b/ast/nasal_new_lexer.cpp
index 3981794..b5fbcd2 100644
--- a/ast/nasal_new_lexer.cpp
+++ b/ast/nasal_new_lexer.cpp
@@ -68,16 +68,16 @@ void lexer::open(const std::string& file) {
     }
 
     // load
-    filename=file;
+    filename = file;
     std::ifstream in(file, std::ios::binary);
     if (in.fail()) {
-        err.err("lexer", "failed to open <"+file+">");
+        err.err("lexer", "failed to open <" + file + ">");
     } else {
         err.load(file);
     }
     std::stringstream ss;
-    ss<<in.rdbuf();
-    res=ss.str();
+    ss << in.rdbuf();
+    res = ss.str();
 }
 
 tok lexer::get_type(const std::string& str) {
diff --git a/ast/nasal_new_main.cpp b/ast/nasal_new_main.cpp
index 6ba6175..395d2d9 100644
--- a/ast/nasal_new_main.cpp
+++ b/ast/nasal_new_main.cpp
@@ -3,6 +3,7 @@
 #include "nasal_new_lexer.h"
 #include "nasal_new_ast.h"
 #include "nasal_new_parse.h"
+#include "nasal_new_import.h"
 #include "ast_visitor.h"
 #include "ast_dumper.h"
 
@@ -78,7 +79,7 @@ void execute(
     error   err;
     lexer   lex(err);
     parse   parse(err);
-    // linker  ld(err);
+    linker  ld(err);
     // codegen gen(err);
     // vm      ctx;
 
@@ -87,14 +88,14 @@ void execute(
 
     // parser gets lexer's token list to compile
     parse.compile(lex).chkerr();
+
+    // linker gets parser's ast and load import files to this ast
+    ld.link(parse, file, cmd&VM_DETAIL).chkerr();
     if (cmd&VM_AST) {
         auto dumper = new ast_dumper();
         dumper->visit_code_block(parse.tree());
     }
 
-    // linker gets parser's ast and load import files to this ast
-    // ld.link(parse, file, cmd&VM_DETAIL).chkerr();
-
     // optimizer does simple optimization on ast
     // optimize(parse.tree());
 
diff --git a/ast/nasal_new_parse.h b/ast/nasal_new_parse.h
index 98b736c..bcef3fb 100644
--- a/ast/nasal_new_parse.h
+++ b/ast/nasal_new_parse.h
@@ -136,7 +136,14 @@ private:
     return_expr* return_expression();
 
 public:
-    inline code_block* tree() {return root;}
+    code_block* tree() {return root;}
+
+    // swap root pointer with another pointer(maybe nullptr)
+    code_block* swap(code_block* another) {
+        auto res = root;
+        root = another;
+        return res;
+    }
 
 public:
     parse(error& e):
@@ -144,6 +151,11 @@ public:
         toks(nullptr),
         root(nullptr),
         err(e) {}
+    ~parse() {
+        if (root) {
+            delete root;
+        }
+    }
     const error& compile(const lexer&);
     void easter_egg() const;
 };
\ No newline at end of file
diff --git a/makefile b/makefile
index 3cc1563..915b1d8 100644
--- a/makefile
+++ b/makefile
@@ -16,7 +16,7 @@ SRC=\
 	nasal_dbg.h\
 	nasal.h
 
-STD=c++14
+STD=c++17
 
 nasal:$(SRC)
 	$(CXX) -std=$(STD) -O3 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
@@ -76,6 +76,7 @@ test:nasal
 NASAL_NEW_AST=\
 	nasal_new_misc.o\
 	nasal_new_err.o\
+	nasal_new_import.o\
 	nasal_new_lexer.o\
 	nasal_new_ast.o\
 	nasal_new_parse.o\
@@ -97,8 +98,11 @@ nasal_new_misc.o: ast/nasal_new_header.h ast/nasal_new_misc.cpp
 nasal_new_err.o: ast/nasal_new_err.h ast/nasal_new_err.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_err.cpp -fno-exceptions -fPIC -o nasal_new_err.o -I .
 
+nasal_new_import.o: ast/nasal_new_import.h ast/nasal_new_import.cpp
+	$(CXX) --std=$(STD) -c -O3 ast/nasal_new_import.cpp -fno-exceptions -fPIC -o nasal_new_import.o -I .
+
 nasal_new_lexer.o: ast/nasal_new_lexer.h ast/nasal_new_lexer.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.o -I .
+	$(CXX) --std=$(STD) -c -O3 ast/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.o -I .
 
 nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
diff --git a/module/makefile b/module/makefile
index d506850..f3d4148 100644
--- a/module/makefile
+++ b/module/makefile
@@ -5,7 +5,7 @@ dynamic_libs_dll=libfib.dll libkey.dll libnasock.dll libmat.dll
 
 used_header= ../nasal.h ../nasal_gc.h
 
-STD=c++14
+STD=c++17
 
 all: $(dynamic_libs_so)
 	@ echo "[Compiling] done"

From e2ec8cb9a0819096e8e2b887bf313eae3c0f2370 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Tue, 27 Jun 2023 22:54:13 +0800
Subject: [PATCH 20/34] :rocket: add function ghosttype

---
 ast/nasal_new_builtin.cpp | 1266 +++++++++++++++++++++++++++++++++++++
 ast/nasal_new_builtin.h   |  230 +++++++
 ast/nasal_new_gc.cpp      |  563 +++++++++++++++++
 ast/nasal_new_gc.h        |  414 ++++++++++++
 ast/nasal_new_import.cpp  |   11 +-
 ast/nasal_new_parse.cpp   |    5 +-
 makefile                  |   14 +-
 nasal_builtin.h           |   13 +
 nasal_gc.h                |    4 +
 stl/lib.nas               |    3 +
 10 files changed, 2515 insertions(+), 8 deletions(-)
 create mode 100644 ast/nasal_new_builtin.cpp
 create mode 100644 ast/nasal_new_builtin.h
 create mode 100644 ast/nasal_new_gc.cpp
 create mode 100644 ast/nasal_new_gc.h

diff --git a/ast/nasal_new_builtin.cpp b/ast/nasal_new_builtin.cpp
new file mode 100644
index 0000000..a1bea78
--- /dev/null
+++ b/ast/nasal_new_builtin.cpp
@@ -0,0 +1,1266 @@
+#include "nasal_new_builtin.h"
+
+var builtin_print(var* local, gc& ngc) {
+    for(auto& i:local[1].vec().elems) {
+        std::cout<<i;
+    }
+    std::cout<<std::flush;
+    return nil;
+}
+
+var builtin_println(var* local, gc& ngc) {
+    for(auto& i:local[1].vec().elems) {
+        std::cout<<i;
+    }
+    std::cout<<std::endl;
+    return nil;
+}
+
+var builtin_exit(var* local, gc& ngc) {
+    std::exit(local[1].num());
+    return nil;
+}
+
+var builtin_abort(var* local, gc& ngc) {
+    std::abort();
+    return nil;
+}
+
+var builtin_append(var* local, gc& ngc) {
+    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) {
+        v.push_back(i);
+    }
+    return nil;
+}
+
+var builtin_setsize(var* local, gc& ngc) {
+    var vec=local[1];
+    var size=local[2];
+    if (vec.type!=vm_vec) {
+        return nas_err("setsize", "\"vec\" must be vector");
+    }
+    if (size.type!=vm_num || size.num()<0) {
+        return nil;
+    }
+    vec.vec().elems.resize((i64)size.num(), nil);
+    return nil;
+}
+
+var builtin_system(var* local, gc& ngc) {
+    var str=local[1];
+    if (str.type!=vm_str) {
+        return var::num(-1);
+    }
+    return var::num((f64)system(str.str().c_str()));
+}
+
+var builtin_input(var* local, gc& ngc) {
+    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();
+    } else {
+        std::getline(std::cin, ret.str(), end.str()[0]);
+    }
+    return ret;
+}
+
+var builtin_readfile(var* local, gc& ngc) {
+    var val=local[1];
+    if (val.type!=vm_str) {
+        return nas_err("io::readfile", "\"filename\" must be string");
+    }
+    std::ifstream in(val.str(), std::ios::binary);
+    std::stringstream rd;
+    if (!in.fail()) {
+        rd<<in.rdbuf();
+    }
+    return ngc.newstr(rd.str());
+}
+
+var builtin_fout(var* local, gc& ngc) {
+    var val=local[1];
+    var str=local[2];
+    if (val.type!=vm_str) {
+        return nas_err("io::fout", "\"filename\" must be string");
+    }
+    std::ofstream out(val.str());
+    if (out.fail()) {
+        return nas_err("io::fout", "cannot open <"+val.str()+">");
+    }
+    out<<str;
+    return nil;
+}
+
+var builtin_split(var* local, gc& ngc) {
+    var delimeter=local[1];
+    var str=local[2];
+    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();
+
+    // avoid being sweeped
+    var res=ngc.temp=ngc.alloc(vm_vec);
+    auto& vec=res.vec().elems;
+
+    if (!deli.length()) {
+        for(auto i:s) {
+            vec.push_back(ngc.newstr(i));
+        }
+        ngc.temp=nil;
+        return res;
+    }
+    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);
+    }
+    if (last!=s.length()) {
+        vec.push_back(ngc.newstr(s.substr(last)));
+    }
+    ngc.temp=nil;
+    return res;
+}
+
+var builtin_rand(var* local, gc& ngc) {
+    var val=local[1];
+    if (val.type!=vm_num && val.type!=vm_nil) {
+        return nas_err("rand", "\"seed\" must be nil or number");
+    }
+    if (val.type==vm_num) {
+        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));
+    }
+    return var::num(num);
+}
+
+var builtin_id(var* local, gc& ngc) {
+    var val=local[1];
+    std::stringstream ss;
+    ss<<"0";
+    if (val.type>vm_num) {
+        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];
+    if (val.type!=vm_num && val.type!=vm_str) {
+        return nil;
+    }
+    return var::num(f64((i32)val.tonum()));
+}
+
+var builtin_floor(var* local, gc& ngc) {
+    var val=local[1];
+    return var::num(std::floor(val.num()));
+}
+
+var builtin_num(var* local, gc& ngc) {
+    var val=local[1];
+    if (val.type==vm_num) {
+        return val;
+    }
+    if (val.type!=vm_str) {
+        return nil;
+    }
+    f64 res=val.tonum();
+    if (std::isnan(res)) {
+        return nil;
+    }
+    return var::num(res);
+}
+
+var builtin_pop(var* local, gc& ngc) {
+    var val=local[1];
+    if (val.type!=vm_vec) {
+        return nas_err("pop", "\"vec\" must be vector");
+    }
+    auto& vec=val.vec().elems;
+    if (vec.size()) {
+        var tmp=vec.back();
+        vec.pop_back();
+        return tmp;
+    }
+    return nil;
+}
+
+var builtin_str(var* local, gc& ngc) {
+    return ngc.newstr(local[1].tostr());
+}
+
+var builtin_size(var* local, gc& ngc) {
+    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;
+    }
+    return var::num(num);
+}
+
+var builtin_u32xor(var* local, gc& ngc) {
+    return var::num((f64)(u32(local[1].num())^u32(local[2].num())));
+}
+
+var builtin_u32and(var* local, gc& ngc) {
+    return var::num((f64)(u32(local[1].num())&u32(local[2].num())));
+}
+
+var builtin_u32or(var* local, gc& ngc) {
+    return var::num((f64)(u32(local[1].num())|u32(local[2].num())));
+}
+
+var builtin_u32nand(var* local, gc& ngc) {
+    return var::num((f64)(u32)(~(u32(local[1].num())&u32(local[2].num()))));
+}
+
+var builtin_u32not(var* local, gc& ngc) {
+    return var::num((f64)(u32)(~u32(local[1].num())));
+}
+
+var builtin_pow(var* local, gc& ngc) {
+    var x=local[1];
+    var y=local[2];
+    if (x.type!=vm_num || y.type!=vm_num) {
+        return var::num(std::nan(""));
+    }
+    return var::num(std::pow(x.num(), y.num()));
+}
+
+var builtin_sin(var* local, gc& ngc) {
+    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];
+    return var::num(val.type==vm_num?cos(val.num()):std::nan(""));
+}
+
+var builtin_tan(var* local, gc& ngc) {
+    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];
+    return var::num(val.type==vm_num?exp(val.num()):std::nan(""));
+}
+
+var builtin_lg(var* local, gc& ngc) {
+    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];
+    return var::num(val.type==vm_num?log(val.num()):std::nan(""));
+}
+
+var builtin_sqrt(var* local, gc& ngc) {
+    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];
+    if (x.type!=vm_num || y.type!=vm_num) {
+        return var::num(std::nan(""));
+    }
+    return var::num(atan2(y.num(), x.num()));
+}
+
+var builtin_isnan(var* local, gc& ngc) {
+    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];
+    if (val.type!=vm_num) {
+        return nas_err("time", "\"begin\" must be number");
+    }
+    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];
+    if (hash.type!=vm_hash || key.type!=vm_str) {
+        return 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];
+    if (hash.type!=vm_hash) {
+        return nas_err("delete", "\"hash\" must be hash");
+    }
+    if (key.type!=vm_str) {
+        return nil;
+    }
+    if (hash.hash().elems.count(key.str())) {
+        hash.hash().elems.erase(key.str());
+    }
+    return nil;
+}
+
+var builtin_keys(var* local, gc& ngc) {
+    var hash=local[1];
+    if (hash.type!=vm_hash) {
+        return nas_err("keys", "\"hash\" must be hash");
+    }
+    // avoid being sweeped
+    var res=ngc.temp=ngc.alloc(vm_vec);
+    auto& vec=res.vec().elems;
+    for(auto& iter:hash.hash().elems) {
+        vec.push_back(ngc.newstr(iter.first));
+    }
+    ngc.temp=nil;
+    return res;
+}
+
+var builtin_die(var* local, gc& ngc) {
+    return nas_err("error", local[1].tostr());
+}
+
+var builtin_find(var* local, gc& ngc) {
+    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);
+    }
+    return var::num((f64)pos);
+}
+
+var builtin_type(var* local, gc& ngc) {
+    switch(local[1].type) {
+        case vm_none: return ngc.newstr("undefined");break;
+        case vm_nil:  return ngc.newstr("nil");      break;
+        case vm_num:  return ngc.newstr("num");      break;
+        case vm_str:  return ngc.newstr("str");      break;
+        case vm_vec:  return ngc.newstr("vec");      break;
+        case vm_hash: return ngc.newstr("hash");     break;
+        case vm_func: return ngc.newstr("func");     break;
+        case vm_obj:  return ngc.newstr("obj");      break;
+        case vm_co:   return ngc.newstr("coroutine");break;
+    }
+    return nil;
+}
+
+var builtin_substr(var* local, gc& ngc) {
+    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");
+    }
+    if (beg.type!=vm_num || beg.num()<0) {
+        return nas_err("substr", "\"begin\" should be number >= 0");
+    }
+    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();
+    if (begin>=str.str().length()) {
+        return nas_err("susbtr", "begin index out of range: "+std::to_string(begin));
+    }
+    return ngc.newstr(str.str().substr(begin,length));
+}
+
+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 builtin_left(var* local, gc& ngc) {
+    var str=local[1];
+    var len=local[2];
+    if (str.type!=vm_str) {
+        return nas_err("left", "\"string\" must be string");
+    }
+    if (len.type!=vm_num) {
+        return nas_err("left", "\"length\" must be number");
+    }
+    if (len.num()<0) {
+        return ngc.newstr("");
+    }
+    return ngc.newstr(str.str().substr(0,len.num()));
+}
+
+var builtin_right(var* local, gc& ngc) {
+    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();
+    if (length>srclen) {
+        length=srclen;
+    }
+    if (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];
+    if (a.type!=vm_str || b.type!=vm_str) {
+        return nas_err("cmp", "\"a\" and \"b\" must be string");
+    }
+    return var::num((f64)strcmp(a.str().c_str(), b.str().c_str()));
+}
+
+var builtin_chr(var* local, gc& ngc) {
+    const char* extend[]={
+        "€"," ","‚","ƒ","„","…","†","‡",
+        "ˆ","‰","Š","‹","Œ"," ","Ž"," ",
+        " ","‘","’","“","”","•","–","—",
+        "˜","™","š","›","œ"," ","ž","Ÿ",
+        " ","¡","¢","£","¤","¥","¦","§",
+        "¨","©","ª","«","¬"," ","®","¯",
+        "°","±","²","³","´","µ","¶","·",
+        "¸","¹","º","»","¼","½","¾","¿",
+        "À","Á","Â","Ã","Ä","Å","Æ","Ç",
+        "È","É","Ê","Ë","Ì","Í","Î","Ï",
+        "Ð","Ñ","Ò","Ó","Ô","Õ","Ö","×",
+        "Ø","Ù","Ú","Û","Ü","Ý","Þ","ß",
+        "à","á","â","ã","ä","å","æ","ç",
+        "è","é","ê","ë","ì","í","î","ï",
+        "ð","ñ","ò","ó","ô","õ","ö","÷",
+        "ø","ù","ú","û","ü","ý","þ","ÿ"
+    };
+    i32 num=local[1].num();
+    if (0<=num && num<128) {
+        return ngc.newstr((char)num);
+    } else if (128<=num && num<256) {
+        return ngc.newstr(extend[num-128]);
+    }
+    return ngc.newstr(" ");
+}
+
+var builtin_char(var* local, gc& ngc) {
+    return ngc.newstr((unsigned char)local[1].num());
+}
+
+var builtin_values(var* local, gc& ngc) {
+    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) {
+        v.push_back(i.second);
+    }
+    return vec;
+}
+
+var builtin_exists(var* local, gc& ngc) {
+    if (local[1].type!=vm_str) {
+        return zero;
+    }
+    return access(local[1].str().c_str(), F_OK)!=-1?one:zero;
+}
+
+var builtin_open(var* local, gc& ngc) {
+    var name=local[1];
+    var mode=local[2];
+    if (name.type!=vm_str) {
+        return nas_err("open", "\"filename\" must be string");
+    }
+    if (mode.type!=vm_str) {
+        return nas_err("open", "\"mode\" must be string");
+    }
+    FILE* res=fopen(name.str().c_str(), mode.str().c_str());
+    if (!res) {
+        return nas_err("open", "failed to open file <"+name.str()+">");
+    }
+    var ret=ngc.alloc(vm_obj);
+    ret.obj().set(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];
+    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
+        return nas_err("close", "not a valid filehandle");
+    }
+    fd.obj().clear();
+    return nil;
+}
+
+var builtin_read(var* local, gc& ngc) {
+    var fd=local[1];
+    var buf=local[2];
+    var len=local[3];
+    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
+        return nas_err("read", "not a valid filehandle");
+    }
+    if (buf.type!=vm_str || buf.val.gcobj->unmut) {
+        return nas_err("read", "\"buf\" must be mutable string");
+    }
+    if (len.type!=vm_num) {
+        return nas_err("read", "\"len\" must be number");
+    }
+    if (len.num()<=0 || len.num()>=(1<<30)) {
+        return nas_err("read", "\"len\" less than 1 or too large");
+    }
+    char* buff=new char[(usize)len.num()+1];
+    if (!buff) {
+        return nas_err("read", "malloc failed");
+    }
+    f64 res=fread(buff,1,len.num(), (FILE*)fd.obj().ptr);
+    buf.str()=buff;
+    buf.val.gcobj->unmut=true;
+    delete []buff;
+    return var::num(res);
+}
+
+var builtin_write(var* local, gc& ngc) {
+    var fd=local[1];
+    var str=local[2];
+    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
+        return nas_err("write", "not a valid filehandle");
+    }
+    if (str.type!=vm_str) {
+        return nas_err("write", "\"str\" must be string");
+    }
+    return var::num((f64)fwrite(str.str().c_str(), 1, str.str().length(), (FILE*)fd.obj().ptr));
+}
+
+var builtin_seek(var* local, gc& ngc) {
+    var fd=local[1];
+    var pos=local[2];
+    var whence=local[3];
+    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
+        return nas_err("seek", "not a valid filehandle");
+    }
+    return var::num((f64)fseek((FILE*)fd.obj().ptr, pos.num(), whence.num()));
+}
+
+var builtin_tell(var* local, gc& ngc) {
+    var fd=local[1];
+    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
+        return nas_err("tell", "not a valid filehandle");
+    }
+    return var::num((f64)ftell((FILE*)fd.obj().ptr));
+}
+
+var builtin_readln(var* local, gc& ngc) {
+    var fd=local[1];
+    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
+        return nas_err("readln", "not a valid filehandle");
+    }
+    var str=ngc.alloc(vm_str);
+    char c;
+    while((c=fgetc((FILE*)fd.obj().ptr))!=EOF) {
+        if (c=='\r') {
+            continue;
+        }
+        if (c=='\n') {
+            return str;
+        }
+        str.str()+=c;
+    }
+    if (str.str().length()) {
+        return str;
+    }
+    return nil;
+}
+
+var builtin_stat(var* local, gc& ngc) {
+    var name=local[1];
+    if (name.type!=vm_str) {
+        return nas_err("stat", "\"filename\" must be string");
+    }
+    struct stat buf;
+    if (stat(name.str().c_str(),&buf)<0) {
+        return nas_err("stat", "failed to open file <"+name.str()+">");
+    }
+    var ret=ngc.alloc(vm_vec);
+    ret.vec().elems={
+        var::num((f64)buf.st_dev),
+        var::num((f64)buf.st_ino),
+        var::num((f64)buf.st_mode),
+        var::num((f64)buf.st_nlink),
+        var::num((f64)buf.st_uid),
+        var::num((f64)buf.st_gid),
+        var::num((f64)buf.st_rdev),
+        var::num((f64)buf.st_size),
+        var::num((f64)buf.st_atime),
+        var::num((f64)buf.st_mtime),
+        var::num((f64)buf.st_ctime)
+    };
+    return ret;
+}
+
+var builtin_eof(var* local, gc& ngc) {
+    var fd=local[1];
+    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
+        return nas_err("readln", "not a valid filehandle");
+    }
+    return var::num((f64)feof((FILE*)fd.obj().ptr));
+}
+
+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];
+    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();
+    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) {
+        if (s[i>>3]&(1<<(7-(i&7)))) {
+            res|=1<<(bit+len-i-1);
+        }
+    }
+    return var::num((f64)res);
+}
+
+var builtin_sfld(var* local, gc& ngc) {
+    // bits.sfld(s,0,3);
+    // 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];
+    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();
+    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) {
+        if (s[i>>3]&(1<<(7-(i&7)))) {
+            res|=1<<(bit+len-i-1);
+        }
+    }
+    if (res&(1<<(len-1))) {
+        res|=~((1<<len)-1);
+    }
+    return var::num((f64)((i32)res));
+}
+
+var builtin_setfld(var* local, gc& ngc) {
+    // bits.setfld(s,0,8,69);
+    // 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];
+    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();
+    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) {
+        if (val&(1<<(i-bit))) {
+            s[i>>3]|=(1<<(7-(i&7)));
+        } else {
+            s[i>>3]&=~(1<<(7-(i&7)));
+        }
+    }
+    return nil;
+}
+
+var builtin_buf(var* local, gc& ngc) {
+    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();
+    s.resize(length.num(), '\0');
+    return str;
+}
+
+var builtin_sleep(var* local, gc& ngc) {
+    var val=local[1];
+    if (val.type!=vm_num) {
+        return nil;
+    }
+#if defined(_WIN32) && !defined(_GLIBCXX_HAS_GTHREADS)
+    // mingw-w64 win32 thread model has no std::this_thread
+    // also msvc will use this
+    Sleep(i64(val.num()*1e3));
+#else
+    std::this_thread::sleep_for(std::chrono::microseconds(i64(val.num()*1e6)));
+#endif
+    return nil;
+}
+
+var builtin_pipe(var* local, gc& ngc) {
+#ifndef _WIN32
+    i32 fd[2];
+    var res=ngc.alloc(vm_vec);
+    if (pipe(fd)==-1) {
+        return nas_err("pipe", "failed to create pipe");
+    }
+    res.vec().elems.push_back(var::num((f64)fd[0]));
+    res.vec().elems.push_back(var::num((f64)fd[1]));
+    return res;
+#endif
+    return nas_err("pipe", "not supported");
+}
+
+var builtin_fork(var* local, gc& ngc) {
+#ifndef _WIN32
+    f64 res=fork();
+    if (res<0) {
+        return nas_err("fork", "failed to fork a process");
+    }
+    return var::num((f64)res);
+#endif
+    return nas_err("fork", "not supported");
+}
+
+var builtin_waitpid(var* local, gc& ngc) {
+    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);
+    vec.vec().elems.push_back(var::num((f64)ret_pid));
+    vec.vec().elems.push_back(var::num((f64)status));
+    return vec;
+#endif
+    return nas_err("waitpid", "not supported");
+}
+
+var builtin_opendir(var* local, gc& ngc) {
+    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);
+    if (p==INVALID_HANDLE_VALUE) {
+        return nas_err("opendir", "cannot open dir <"+path.str()+">");
+    }
+#else
+    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);
+    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];
+    if (!handle.objchk(ngc.global_ghost_type_table.ghost_dir)) {
+        return nas_err("readdir", "not a valid dir handle");
+    }
+#ifdef _MSC_VER
+    WIN32_FIND_DATAA data;
+    if (!FindNextFileA(handle.obj().ptr,&data)) {
+        return nil;
+    }
+    return ngc.newstr(data.cFileName);
+#else
+    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];
+    if (!handle.objchk(ngc.global_ghost_type_table.ghost_dir)) {
+        return nas_err("closedir", "not a valid dir handle");
+    }
+    handle.obj().clear();
+    return nil;
+}
+
+var builtin_chdir(var* local, gc& ngc) {
+    var path=local[1];
+    if (path.type!=vm_str) {
+        return var::num((f64)-1);
+    }
+    return var::num((f64)chdir(path.str().c_str()));
+}
+
+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) {
+        vec.push_back(ngc.newstr(*env));
+    }
+    ngc.temp=nil;
+    return res;
+}
+
+var builtin_getcwd(var* local, gc& ngc) {
+    char buf[1024];
+    if (!getcwd(buf,sizeof(buf))) {
+        return nil;
+    }
+    return ngc.newstr(buf);
+}
+
+var builtin_getenv(var* local, gc& ngc) {
+    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;
+}
+
+var builtin_dlopen(var* local, gc& ngc) {
+    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];
+    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());
+    delete []str;
+#else
+    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);
+    lib.obj().set(ngc.global_ghost_type_table.ghost_dylib, ptr, &ngc.global_ghost_type_table);
+    ret.hash().elems["lib"]=lib;
+
+#ifdef _WIN32
+    void* func=(void*)GetProcAddress((HMODULE)lib.obj().ptr, "get");
+#else
+    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);
+    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);
+        tmp.obj().set(ngc.global_ghost_type_table.ghost_faddr, p, &ngc.global_ghost_type_table);
+        ret.hash().elems[tbl[i].name]=tmp;
+    }
+
+    ngc.temp=nil;
+    return ret;
+}
+
+var builtin_dlclose(var* local, gc& ngc) {
+    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");
+    }
+    libptr.obj().clear();
+    return nil;
+}
+
+var builtin_dlcallv(var* local, gc& ngc) {
+    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
+    );
+}
+
+var builtin_dlcall(var* local, gc& ngc) {
+    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;
+    // arguments' stored place begins at local +2
+    return ((module_func)fp.obj().ptr)(
+        local_frame_start,
+        local_frame_size,
+        &ngc
+    );
+}
+
+var builtin_platform(var* local, gc& ngc) {
+    if (is_windows()) {
+        return ngc.newstr("windows");
+    } else if (is_linux()) {
+        return ngc.newstr("linux");
+    } else if (is_macos()) {
+        return ngc.newstr("macOS");
+    }
+    return ngc.newstr("unknown");
+}
+
+var builtin_arch(var* local, gc& ngc) {
+    if (is_x86()) {
+        return ngc.newstr("x86");
+    } else if (is_x86_64()) {
+        return ngc.newstr("x86-64");
+    } else if (is_amd64()) {
+        return ngc.newstr("amd64");
+    } else if (is_arm()) {
+        return ngc.newstr("arm");
+    } else if (is_aarch64()) {
+        return ngc.newstr("aarch64");
+    } else if (is_ia64()) {
+        return ngc.newstr("ia64");
+    } else if (is_powerpc()) {
+        return ngc.newstr("powerpc");
+    } else if (is_superh()) {
+        return ngc.newstr("superh");
+    }
+    return ngc.newstr("unknown");
+}
+
+// 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]);
+        }
+        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;
+    buff.resize(buffsize,0);
+    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;
+
+    // u32(abs(sin(i+1))*(2pow32))
+    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,
+        0x21e1cde6,0xc33707d6,0xf4d50d87,0x455a14ed,0xa9e3e905,0xfcefa3f8,0x676f02d9,0x8d2a4c8a,
+        0xfffa3942,0x8771f681,0x6d9d6122,0xfde5380c,0xa4beea44,0x4bdecfa9,0xf6bb4b60,0xbebfbc70,
+        0x289b7ec6,0xeaa127fa,0xd4ef3085,0x04881d05,0xd9d4d039,0xe6db99e5,0x1fa27cf8,0xc4ac5665,
+        0xf4292244,0x432aff97,0xab9423a7,0xfc93a039,0x655b59c3,0x8f0ccc92,0xffeff47d,0x85845dd1,
+        0x6fa87e4f,0xfe2ce6e0,0xa3014314,0x4e0811a1,0xf7537e82,0xbd3af235,0x2ad7d2bb,0xeb86d391
+    };
+
+    // left shift bits
+    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,
+        6,10,15,21,6,10,15,21,6,10,15,21,6,10,15,21
+    };
+
+    // index
+    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;
+        0,7,14,5,12,3,10,1,8,15,6,13,4,11,2,9  // g=(7*i)%16;
+    };
+    
+#define shift(x,n)  (((x)<<(n))|((x)>>(32-(n)))) // cycle left shift
+#define md5f(x,y,z) (((x)&(y))|((~x)&(z)))    
+#define md5g(x,y,z) (((x)&(z))|((y)&(~z)))
+#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;
+        }
+        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];
+    if (str.type!=vm_str) {
+        return nas_err("md5", "\"str\" must be string");
+    }
+    return ngc.newstr(md5(str.str()));
+}
+
+var builtin_cocreate(var* local, gc& ngc) {
+    // +-------------+
+    // | old pc      | <- top[0]
+    // +-------------+
+    // | old localr  | <- top[-1]
+    // +-------------+
+    // | old upvalr  | <- top[-2]
+    // +-------------+
+    // | local scope |
+    // | ...         |
+    // +-------------+ <- local pointer stored in localr
+    // | old funcr   | <- old function stored in funcr
+    // +-------------+
+    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;
+
+    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++;
+    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;
+    
+    return co;
+}
+
+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];
+    // return nil if is not a coroutine object
+    if (co.type!=vm_co) {
+        return nil;
+    }
+    // cannot resume a dead coroutine
+    if (co.co().status==coroutine_status::dead) {
+        return nil;
+    }
+
+    // change to coroutine context
+    ngc.ctxchg(co.co());
+
+    // fetch coroutine's stack top and return
+    // so the coroutine's stack top in fact is not changed
+    if (ngc.rctx->top[0].type==vm_ret) {
+        // when first calling this coroutine, the stack top must be vm_ret
+        return ngc.rctx->top[0];
+    }
+
+    // after first calling the coroutine, each time coroutine.yield triggered
+    // a new space will be reserved on stack with value nil
+    // so we could fill this place with args
+
+    // the coroutine seems like coroutine.yield returns the value
+    // but in fact coroutine.yield stop the coroutine
+    // until main context calls the coroutine.resume
+    return local[2];
+}
+
+var builtin_coyield(var* local, gc& ngc) {
+    if (!ngc.cort) {
+        return nas_err("coroutine::yield", "no coroutine is running");
+    }
+
+    // this will set to main stack top
+    ngc.ctxreserve();
+    
+    // then this will return value to main's stack top[0]
+    // the procedure seems like coroutine.resume returns the value
+    // but in fact coroutine.resume stop the main context
+    // until coroutine calls the coroutine.yield
+    return local[1];
+}
+
+var builtin_costatus(var* local, gc& ngc) {
+    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;
+    }
+    return nil;
+}
+
+var builtin_corun(var* local, gc& ngc) {
+    return ngc.cort?one:zero;
+}
+
+var builtin_millisec(var* local, gc& ngc) {
+    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;
+    return res;
+}
+
+var builtin_gcextend(var* local, gc& ngc) {
+    var type=local[1];
+    if (type.type!=vm_str) {
+        return nil;
+    }
+    auto& s=type.str();
+    if (s=="str") {
+        ngc.extend(vm_str);
+    } else if (s=="vec") {
+        ngc.extend(vm_vec);
+    } else if (s=="hash") {
+        ngc.extend(vm_hash);
+    } else if (s=="func") {
+        ngc.extend(vm_func);
+    } else if (s=="upval") {
+        ngc.extend(vm_upval);
+    } else if (s=="obj") {
+        ngc.extend(vm_obj);
+    } else if (s=="co") {
+        ngc.extend(vm_co);
+    }
+    return nil;
+}
+
+var builtin_logtime(var* local, gc& ngc) {
+    time_t t=time(nullptr);
+    tm* tm_t=localtime(&t);
+    char s[64];
+    snprintf(
+        s,64,"%d-%.2d-%.2d %.2d:%.2d:%.2d",
+        tm_t->tm_year+1900,
+        tm_t->tm_mon+1,
+        tm_t->tm_mday,
+        tm_t->tm_hour,
+        tm_t->tm_min,
+        tm_t->tm_sec
+    );
+    return ngc.newstr(s);
+}
+
+var builtin_ghosttype(var* local, gc& ngc) {
+    var arg = local[1];
+    if (arg.type!=vm_obj) {
+        return nas_err("ghosttype", "this is not a ghost object.");
+    }
+    const auto& name = arg.obj().get_ghost_name();
+    if (!name.length()) {
+        return var::num((u64)arg.obj().ptr);
+    }
+    return ngc.newstr(name);
+}
\ No newline at end of file
diff --git a/ast/nasal_new_builtin.h b/ast/nasal_new_builtin.h
new file mode 100644
index 0000000..ec983f8
--- /dev/null
+++ b/ast/nasal_new_builtin.h
@@ -0,0 +1,230 @@
+#pragma once
+
+#include "nasal_new_header.h"
+#include "nasal_new_gc.h"
+
+#ifndef _MSC_VER
+#include <unistd.h>
+#include <dirent.h>
+#else
+#pragma warning (disable:4566) // i know i'm using utf-8, fuck you
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#pragma warning (disable:4996)
+#define _CRT_SECURE_NO_DEPRECATE 1
+#define _CRT_NONSTDC_NO_DEPRECATE 1
+#include <io.h>
+#include <direct.h>
+#endif
+
+#include <sstream>
+#include <cmath>
+#include <thread>
+#include <sys/stat.h>
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#include <sys/wait.h>
+#endif
+
+#if defined __APPLE__
+#include <crt_externs.h>
+#define environ (*_NSGetEnviron())
+#endif
+
+var builtin_print(var*, gc&);
+var builtin_println(var*, gc&);
+var builtin_exit(var*, gc&);
+var builtin_abort(var*, gc&);
+var builtin_append(var*, gc&);
+var builtin_setsize(var*, gc&);
+var builtin_system(var*, gc&);
+var builtin_input(var*, gc&);
+var builtin_readfile(var*, gc&);
+var builtin_fout(var*, gc&);
+var builtin_split(var*, gc&);
+var builtin_rand(var*, gc&);
+var builtin_id(var*, gc&);
+var builtin_int(var*, gc&);
+var builtin_floor(var*, gc&);
+var builtin_num(var*, gc&);
+var builtin_pop(var*, gc&);
+var builtin_str(var*, gc&);
+var builtin_size(var*, gc&);
+var builtin_u32xor(var*, gc&);
+var builtin_u32and(var*, gc&);
+var builtin_u32or(var*, gc&);
+var builtin_u32nand(var*, gc&);
+var builtin_u32not(var*, gc&);
+var builtin_pow(var*, gc&);
+var builtin_sin(var*, gc&);
+var builtin_cos(var*, gc&);
+var builtin_tan(var*, gc&);
+var builtin_exp(var*, gc&);
+var builtin_lg(var*, gc&);
+var builtin_ln(var*, gc&);
+var builtin_sqrt(var*, gc&);
+var builtin_atan2(var*, gc&);
+var builtin_isnan(var*, gc&);
+var builtin_time(var*, gc&);
+var builtin_contains(var*, gc&);
+var builtin_delete(var*, gc&);
+var builtin_keys(var*, gc&);
+var builtin_die(var*, gc&);
+var builtin_find(var*, gc&);
+var builtin_type(var*, gc&);
+var builtin_substr(var*, gc&);
+var builtin_streq(var*, gc&);
+var builtin_left(var*, gc&);
+var builtin_right(var*, gc&);
+var builtin_cmp(var*, gc&);
+var builtin_chr(var*, gc&);
+var builtin_char(var*, gc&);
+var builtin_values(var*, gc&);
+var builtin_exists(var*, gc&);
+var builtin_open(var*, gc&);
+var builtin_close(var*, gc&);
+var builtin_read(var*, gc&);
+var builtin_write(var*, gc&);
+var builtin_seek(var*, gc&);
+var builtin_tell(var*, gc&);
+var builtin_readln(var*, gc&);
+var builtin_stat(var*, gc&);
+var builtin_eof(var*, gc&);
+var builtin_fld(var*, gc&);
+var builtin_sfld(var*, gc&);
+var builtin_setfld(var*, gc&);
+var builtin_buf(var*, gc&);
+var builtin_sleep(var*, gc&);
+var builtin_pipe(var*, gc&);
+var builtin_fork(var*, gc&);
+var builtin_waitpid(var*, gc&);
+var builtin_opendir(var*, gc&);
+var builtin_readdir(var*, gc&);
+var builtin_closedir(var*, gc&);
+var builtin_chdir(var*, gc&);
+var builtin_environ(var*, gc&);
+var builtin_getcwd(var*, gc&);
+var builtin_getenv(var*, gc&);
+var builtin_dlopen(var*, gc&);
+var builtin_dlclose(var*, gc&);
+var builtin_dlcallv(var*, gc&);
+var builtin_dlcall(var*, gc&);
+var builtin_platform(var*, gc&);
+var builtin_arch(var*, gc&);
+// md5 related functions
+std::string tohex(u32);
+std::string md5(const std::string&);
+var builtin_md5(var*, gc&);
+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&);
+var builtin_millisec(var*, gc&);
+var builtin_sysargv(var*, gc&);
+var builtin_gcextend(var*, gc&);
+var builtin_logtime(var*, gc&);
+var builtin_ghosttype(var*, gc&);
+
+// register builtin function's name and it's address here in this table below
+// this table must end with {nullptr,nullptr}
+struct {
+    const char* name;
+    var (*func)(var*,gc&);
+} 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},
+    {"__coyield", builtin_coyield },
+    {"__costatus",builtin_costatus},
+    {"__corun"   ,builtin_corun   },
+    {"__millisec",builtin_millisec},
+    {"__sysargv", builtin_sysargv },
+    {"__gcextd",  builtin_gcextend},
+    {"__logtime", builtin_logtime },
+    {"__ghosttype", builtin_ghosttype},
+    {nullptr,     nullptr         }
+};
diff --git a/ast/nasal_new_gc.cpp b/ast/nasal_new_gc.cpp
new file mode 100644
index 0000000..ecd7ab2
--- /dev/null
+++ b/ast/nasal_new_gc.cpp
@@ -0,0 +1,563 @@
+#include "nasal_new_gc.h"
+
+void filehandle_destructor(void* ptr) {
+    if ((FILE*)ptr==stdin) {
+        return;
+    }
+    fclose((FILE*)ptr);
+}
+
+void dir_entry_destructor(void* ptr) {
+#ifndef _MSC_VER
+    closedir((DIR*)ptr);
+#else
+    FindClose(ptr);
+#endif
+}
+
+void dylib_destructor(void* ptr) {
+#ifdef _WIN32
+    FreeLibrary((HMODULE)ptr);
+#else
+    dlclose(ptr);
+#endif
+}
+
+void func_addr_destructor(void* ptr) {}
+
+var nas_vec::get_val(const i32 n) {
+    i32 size=elems.size();
+    if (n<-size || n>=size) {
+        return var::none();
+    }
+    return elems[n>=0?n:n+size];
+}
+
+var* nas_vec::get_mem(const i32 n) {
+    i32 size=elems.size();
+    if (n<-size || n>=size) {
+        return nullptr;
+    }
+    return &elems[n>=0?n:n+size];
+}
+
+std::ostream& operator<<(std::ostream& out, nas_vec& vec) {
+    if (!vec.elems.size() || vec.printed) {
+        out<<(vec.elems.size()?"[..]":"[]");
+        return out;
+    }
+    vec.printed=true;
+    usize iter=0,size=vec.elems.size();
+    out<<'[';
+    for(auto& i:vec.elems) {
+        out<<i<<",]"[(++iter)==size];
+    }
+    vec.printed=false;
+    return out;
+}
+
+var nas_hash::get_val(const std::string& key) {
+    if (elems.count(key)) {
+        return elems.at(key);
+    } else if (!elems.count("parents")) {
+        return var::none();
+    }
+    var ret=var::none();
+    var val=elems.at("parents");
+    if (val.type!=vm_vec) {
+        return ret;
+    }
+    for(auto& i:val.vec().elems) {
+        if (i.type==vm_hash) {
+            ret=i.hash().get_val(key);
+        }
+        if (ret.type!=vm_none) {
+            return ret;
+        }
+    }
+    return ret;
+}
+
+var* nas_hash::get_mem(const std::string& key) {
+    if (elems.count(key)) {
+        return &elems.at(key);
+    } else if (!elems.count("parents")) {
+        return nullptr;
+    }
+    var* addr=nullptr;
+    var val=elems.at("parents");
+    if (val.type!=vm_vec) {
+        return addr;
+    }
+    for(auto& i:val.vec().elems) {
+        if (i.type==vm_hash) {
+            addr=i.hash().get_mem(key);
+        }
+        if (addr) {
+            return addr;
+        }
+    }
+    return addr;
+}
+
+std::ostream& operator<<(std::ostream& out, nas_hash& hash) {
+    if (!hash.elems.size() || hash.printed) {
+        out<<(hash.elems.size()?"{..}":"{}");
+        return out;
+    }
+    hash.printed=true;
+    usize iter=0,size=hash.elems.size();
+    out<<'{';
+    for(auto& i:hash.elems) {
+        out<<i.first<<':'<<i.second<<",}"[(++iter)==size];
+    }
+    hash.printed=false;
+    return out;
+}
+
+void nas_func::clear() {
+    dpara=-1;
+    local.clear();
+    upval.clear();
+    keys.clear();
+}
+
+void nas_ghost::set(usize t, void* p, ghost_register_table* table) {
+    type=t;
+    ptr=p;
+    ghost_type_table=table;
+}
+
+void nas_ghost::clear() {
+    if (!ptr) {
+        return;
+    }
+    ghost_type_table->destructor(type)(ptr);
+    ptr=nullptr;
+}
+
+void nas_co::clear() {
+    for(u32 i=0;i<STACK_DEPTH;++i) {
+        stack[i]=var::nil();
+    }
+    ctx.pc=0;
+    ctx.localr=nullptr;
+    ctx.memr=nullptr;
+    ctx.canary=stack+STACK_DEPTH-1;
+    ctx.top=stack;
+    ctx.funcr=var::nil();
+    ctx.upvalr=var::nil();
+    ctx.stack=stack;
+
+    status=coroutine_status::suspended;
+}
+
+nas_val::nas_val(u8 val_type) {
+    mark=gc_status::collected;
+    type=val_type;
+    unmut=0;
+    switch(val_type) {
+        case vm_str: ptr.str=new std::string; break;
+        case vm_vec: ptr.vec=new nas_vec; break;
+        case vm_hash: ptr.hash=new nas_hash; break;
+        case vm_func: ptr.func=new nas_func; break;
+        case vm_upval: ptr.upval=new nas_upval; break;
+        case vm_obj: ptr.obj=new nas_ghost; break;
+        case vm_co: ptr.co=new nas_co; break;
+    }
+}
+
+nas_val::~nas_val() {
+    switch(type) {
+        case vm_str:  delete ptr.str;  break;
+        case vm_vec:  delete ptr.vec;  break;
+        case vm_hash: delete ptr.hash; break;
+        case vm_func: delete ptr.func; break;
+        case vm_upval:delete ptr.upval;break;
+        case vm_obj:  delete ptr.obj;  break;
+        case vm_co:   delete ptr.co;   break;
+    }
+    type=vm_nil;
+}
+
+void nas_val::clear() {
+    switch(type) {
+        case vm_str:  ptr.str->clear();       break;
+        case vm_vec:  ptr.vec->elems.clear(); break;
+        case vm_hash: ptr.hash->elems.clear();break;
+        case vm_func: ptr.func->clear();      break;
+        case vm_upval:ptr.upval->clear();     break;
+        case vm_obj:  ptr.obj->clear();       break;
+        case vm_co:   ptr.co->clear();        break;
+    }
+}
+
+f64 var::tonum() {
+    return type!=vm_str? val.num:str2num(str().c_str());
+}
+
+std::string var::tostr() {
+    if (type==vm_str) {
+        return str();
+    } else if (type==vm_num) {
+        std::string tmp=std::to_string(num());
+        tmp.erase(tmp.find_last_not_of('0')+1, std::string::npos);
+        tmp.erase(tmp.find_last_not_of('.')+1, std::string::npos);
+        return tmp;
+    }
+    return "";
+}
+
+std::ostream& operator<<(std::ostream& out, var& ref) {
+    switch(ref.type) {
+        case vm_none: out<<"undefined";   break;
+        case vm_nil:  out<<"nil";         break;
+        case vm_num:  out<<ref.val.num;   break;
+        case vm_str:  out<<ref.str();     break;
+        case vm_vec:  out<<ref.vec();     break;
+        case vm_hash: out<<ref.hash();    break;
+        case vm_func: out<<"func(..) {..}";break;
+        case vm_obj:  out<<ref.obj();     break;
+        case vm_co:   out<<"<coroutine>"; break;
+    }
+    return out;
+}
+
+bool var::objchk(usize obj_type) {
+    return type==vm_obj && obj().type==obj_type && obj().ptr;
+}
+
+var var::none() {
+    return {vm_none, (u32)0};
+}
+
+var var::nil() {
+    return {vm_nil, (u32)0};
+}
+
+var var::ret(u32 pc) {
+    return {vm_ret, pc};
+}
+
+var var::cnt(i64 n) {
+    return {vm_cnt, n};
+}
+
+var var::num(f64 n) {
+    return {vm_num, n};
+}
+
+var var::gcobj(nas_val* p) {
+    return {p->type, p};
+}
+
+var var::addr(var* p) {
+    return {vm_addr, p};
+}
+
+var* var::addr() {
+    return val.addr;
+}
+
+u32 var::ret() {
+    return val.ret;
+}
+
+i64& var::cnt() {
+    return val.cnt;
+}
+
+f64 var::num() {
+    return val.num;
+}
+
+std::string& var::str() {
+    return *val.gcobj->ptr.str;
+}
+
+nas_vec& var::vec() {
+    return *val.gcobj->ptr.vec;
+}
+
+nas_hash& var::hash() {
+    return *val.gcobj->ptr.hash;
+}
+
+nas_func& var::func() {
+    return *val.gcobj->ptr.func;
+}
+
+nas_upval& var::upval() {
+    return *val.gcobj->ptr.upval;
+}
+
+nas_ghost& var::obj() {
+    return *val.gcobj->ptr.obj;
+}
+
+nas_co& var::co() {
+    return *val.gcobj->ptr.co;
+}
+
+void gc::mark() {
+    std::vector<var> bfs;
+    mark_context(bfs);
+    
+    while(!bfs.empty()) {
+        var value=bfs.back();
+        bfs.pop_back();
+        if (value.type<=vm_num ||
+            value.val.gcobj->mark!=gc_status::uncollected) {
+            continue;
+        }
+        mark_var(bfs, value);
+    }
+}
+
+void gc::mark_context(std::vector<var>& bfs_queue) {
+
+    // scan now running context, this context maybe related to coroutine or main
+    for(var* i=rctx->stack;i<=rctx->top;++i) {
+        bfs_queue.push_back(*i);
+    }
+    bfs_queue.push_back(rctx->funcr);
+    bfs_queue.push_back(rctx->upvalr);
+    bfs_queue.push_back(temp);
+
+    if (!cort) {
+        return;
+    }
+
+    // coroutine is running, so scan main process stack from mctx
+    for(var* i=mctx.stack;i<=mctx.top;++i) {
+        bfs_queue.push_back(*i);
+    }
+    bfs_queue.push_back(mctx.funcr);
+    bfs_queue.push_back(mctx.upvalr);
+}
+
+void gc::mark_var(std::vector<var>& bfs_queue, var& value) {
+    value.val.gcobj->mark=gc_status::found;
+    switch(value.type) {
+        case vm_vec: mark_vec(bfs_queue, value.vec()); break;
+        case vm_hash: mark_hash(bfs_queue, value.hash()); break;
+        case vm_func: mark_func(bfs_queue, value.func()); break;
+        case vm_upval: mark_upval(bfs_queue, value.upval()); break;
+        case vm_co: mark_co(bfs_queue, value.co()); break;
+        default: break;
+    }
+}
+
+void gc::mark_vec(std::vector<var>& bfs_queue, nas_vec& vec) {
+    for(auto& i:vec.elems) {
+        bfs_queue.push_back(i);
+    }
+}
+
+void gc::mark_hash(std::vector<var>& bfs_queue, nas_hash& hash) {
+    for(auto& i:hash.elems) {
+        bfs_queue.push_back(i.second);
+    }
+}
+
+void gc::mark_func(std::vector<var>& bfs_queue, nas_func& function) {
+    for(auto& i:function.local) {
+        bfs_queue.push_back(i);
+    }
+    for(auto& i:function.upval) {
+        bfs_queue.push_back(i);
+    }
+}
+
+void gc::mark_upval(std::vector<var>& bfs_queue, nas_upval& upval) {
+    for(auto& i:upval.elems) {
+        bfs_queue.push_back(i);
+    }
+}
+
+void gc::mark_co(std::vector<var>& bfs_queue, nas_co& co) {
+    bfs_queue.push_back(co.ctx.funcr);
+    bfs_queue.push_back(co.ctx.upvalr);
+    for(var* i=co.stack;i<=co.ctx.top;++i) {
+        bfs_queue.push_back(*i);
+    }
+}
+
+void gc::sweep() {
+    for(auto i:memory) {
+        if (i->mark==gc_status::uncollected) {
+            i->clear();
+            unused[i->type-vm_str].push_back(i);
+            i->mark=gc_status::collected;
+        } else if (i->mark==gc_status::found) {
+            i->mark=gc_status::uncollected;
+        }
+    }
+}
+
+void gc::extend(u8 type) {
+    const u8 index=type-vm_str;
+    size[index]+=incr[index];
+
+    for(u32 i=0;i<incr[index];++i) {
+        nas_val* tmp=new(std::nothrow) nas_val(type);
+
+        if (!tmp) {
+            std::cerr<<"nasal_gc.h: gc::extend: ";
+            std::cerr<<"failed to allocate memory\n";
+            std::exit(1);
+        }
+
+        // add to heap
+        memory.push_back(tmp);
+        unused[index].push_back(tmp);
+    }
+
+    incr[index]=incr[index]+incr[index]/2;
+}
+
+void gc::init(
+    const std::vector<std::string>& s, const std::vector<std::string>& argv) {
+    // initialize function register
+    rctx->funcr=nil;
+    worktime=0;
+
+    // initialize counters
+    for(u8 i=0;i<gc_type_size;++i) {
+        size[i]=gcnt[i]=acnt[i]=0;
+    }
+
+    // coroutine pointer set to nullptr
+    cort=nullptr;
+
+    // init constant strings
+    strs.resize(s.size());
+    for(u32 i=0;i<strs.size();++i) {
+        strs[i]=var::gcobj(new nas_val(vm_str));
+        strs[i].val.gcobj->unmut=1;
+        strs[i].str()=s[i];
+    }
+
+    // record arguments
+    env_argv.resize(argv.size());
+    for(usize i=0;i<argv.size();++i) {
+        env_argv[i]=var::gcobj(new nas_val(vm_str));
+        env_argv[i].val.gcobj->unmut=1;
+        env_argv[i].str()=argv[i];
+    }
+}
+
+void gc::clear() {
+    for(auto i:memory) {
+        delete i;
+    }
+    memory.clear();
+    for(u8 i=0;i<gc_type_size;++i) {
+        unused[i].clear();
+    }
+    for(auto& i:strs) {
+        delete i.val.gcobj;
+    }
+    strs.clear();
+    env_argv.clear();
+}
+
+void gc::info() {
+    using std::left;
+    using std::setw;
+    using std::setfill;
+    const char* name[]={"str  ","vec  ","hash ","func ","upval","obj  ","co   "};
+    std::clog<<"\ngc info (gc count|alloc count|memory size)\n";
+
+    usize ident=0;
+    for(u8 i=0;i<gc_type_size;++i) {
+#ifndef _MSC_VER
+        usize len=std::max({
+            std::to_string(gcnt[i]).length(),
+            std::to_string(acnt[i]).length(),
+            std::to_string(size[i]).length()
+        });
+#else // VS is a piece of shit
+        usize len=std::to_string(gcnt[i]).length();
+        ident=ident<len?len:ident;
+        len=std::to_string(acnt[i]).length();
+        ident=ident<len?len:ident;
+        len=std::to_string(size[i]).length();
+#endif
+        ident=ident<len?len:ident;
+    }
+
+    double total=0;
+    for(u8 i=0;i<gc_type_size;++i) {
+        if (gcnt[i] || acnt[i] || size[i]) {
+            total+=gcnt[i];
+            std::clog<<" "<<name[i];
+            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<gcnt[i];
+            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<acnt[i];
+            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<size[i];
+            std::clog<<"\n";
+        }
+    }
+
+    double sec=worktime*1.0/1000000000; // seconds
+    std::clog<<" time  | "<<(sec<0.1? sec*1000:sec)<<(sec<0.1? " ms\n":" s\n");
+    if (total) {
+        std::clog<<" avg   | "<<sec/total*1000<<" ms\n";
+    }
+    std::clog<<"\n";
+}
+
+var gc::alloc(u8 type) {
+    using clk=std::chrono::high_resolution_clock;
+    const u8 index=type-vm_str;
+    ++acnt[index];
+    if (unused[index].empty()) {
+        ++gcnt[index];
+        auto begin=clk::now();
+        mark();
+        sweep();
+        worktime+=(clk::now()-begin).count();
+    }
+    if (unused[index].empty()) {
+        extend(type);
+    }
+    var ret=var::gcobj(unused[index].back());
+    ret.val.gcobj->mark=gc_status::uncollected;
+    unused[index].pop_back();
+    return ret;
+}
+
+void gc::ctxchg(nas_co& co) {
+    // store running state to main context
+    mctx=*rctx;
+
+    // restore coroutine context state
+    *rctx=co.ctx;
+
+    // set coroutine pointer
+    cort=&co;
+
+    // set coroutine state to running
+    cort->status=coroutine_status::running;
+}
+
+void gc::ctxreserve() {
+    // pc=0 means this coroutine is finished
+    cort->status=rctx->pc?
+        coroutine_status::suspended:
+        coroutine_status::dead;
+
+    // store running state to coroutine
+    cort->ctx=*rctx;
+
+    // restore main context state
+    *rctx=mctx;
+
+    // set coroutine pointer to nullptr
+    cort=nullptr;
+}
+
+var nas_err(const std::string& error_function_name, const std::string& info) {
+    std::cerr<<"[vm] "<<error_function_name<<": "<<info<<"\n";
+    return var::none();
+}
\ No newline at end of file
diff --git a/ast/nasal_new_gc.h b/ast/nasal_new_gc.h
new file mode 100644
index 0000000..f53b18f
--- /dev/null
+++ b/ast/nasal_new_gc.h
@@ -0,0 +1,414 @@
+#pragma once
+
+// avoid MSVC warnings
+#ifdef _MSC_VER
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#pragma warning (disable:4102)
+#endif
+
+#ifndef _MSC_VER
+#include <unistd.h>
+#include <dirent.h>
+#else
+#include <io.h>
+#include <direct.h>
+#endif
+
+#ifdef _WIN32
+#include <windows.h>
+#else
+#include <dlfcn.h>
+#endif
+
+#include <iomanip>
+#include <vector>
+#include <unordered_map>
+#include <chrono>
+#include <algorithm>
+
+#include "nasal_new_header.h"
+#include "nasal_new_err.h"
+
+enum vm_type:u8 {
+    /* none-gc object */
+    vm_none=0,
+    vm_cnt,
+    vm_addr,
+    vm_ret,
+    vm_nil,
+    vm_num,
+    /* gc object */
+    vm_str,
+    vm_vec,
+    vm_hash,
+    vm_func,
+    vm_upval,
+    vm_obj,
+    vm_co
+};
+
+const u32 gc_type_size=vm_co-vm_str+1;
+
+enum class coroutine_status:u32 {
+    suspended,
+    running,
+    dead
+};
+
+enum class gc_status:u8 {
+    uncollected=0,   
+    collected,
+    found
+};
+
+struct nas_vec;   // vector
+struct nas_hash;  // hashmap(dict)
+struct nas_func;  // function(lambda)
+struct nas_upval; // upvalue
+struct nas_ghost; // objects
+struct nas_co;    // coroutine
+struct nas_val;   // nas_val includes gc-managed types
+
+struct var {
+public:
+    u8 type;
+    union {
+        u32 ret;
+        i64 cnt;
+        f64 num;
+        var* addr;
+        nas_val* gcobj;
+    } val;
+
+private:
+    var(u8 t, u32 pc) {type=t;val.ret=pc;}
+    var(u8 t, i64 ct) {type=t;val.cnt=ct;}
+    var(u8 t, f64 n) {type=t;val.num=n;}
+    var(u8 t, var* p) {type=t;val.addr=p;}
+    var(u8 t, nas_val* p) {type=t;val.gcobj=p;}
+
+public:
+    var() = default;
+    var(const var&) = default;
+    bool operator==(const var& nr) const {
+        return type==nr.type && val.gcobj==nr.val.gcobj;
+    }
+    bool operator!=(const var& nr) const {
+        return type!=nr.type || val.gcobj!=nr.val.gcobj;
+    }
+    friend std::ostream& operator<<(std::ostream&, var&);
+
+    // number and string can be translated to each other
+    f64 tonum();
+    std::string tostr();
+    bool objchk(usize);
+
+    // create new var object
+    static var none();
+    static var nil();
+    static var ret(u32);
+    static var cnt(i64);
+    static var num(f64);
+    static var gcobj(nas_val*);
+    static var addr(var*);
+
+    // get content
+    var* addr();
+    u32 ret();
+    i64& cnt();
+    f64 num();
+    std::string& str();
+    nas_vec& vec();
+    nas_hash& hash();
+    nas_func& func();
+    nas_upval& upval();
+    nas_ghost& obj();
+    nas_co& co();
+};
+
+struct nas_vec {
+    std::vector<var> elems;
+
+    // mark if this is printed, avoid stackoverflow
+    bool printed;
+
+    nas_vec():printed(false) {}
+    usize size() const {return elems.size();}
+    var get_val(const i32);
+    var* get_mem(const i32);
+};
+
+struct nas_hash {
+    std::unordered_map<std::string, var> elems;
+
+    // mark if this is printed, avoid stackoverflow
+    bool printed;
+
+    nas_hash():printed(false) {}
+    usize size() const {return elems.size();}
+    var get_val(const std::string&);
+    var* get_mem(const std::string&);
+};
+
+struct nas_func {
+    i32 dpara; // dynamic parameter name index in hash.
+    u32 entry; // pc will set to entry-1 to call this function
+    u32 psize; // used to load default parameters to a new function
+    u32 lsize; // used to expand memory space for local values on stack
+    std::vector<var> local; // local scope with default value(var)
+    std::vector<var> upval; // closure
+    std::unordered_map<u32,u32> keys; // parameter table, u32 begins from 1
+
+    nas_func(): dpara(-1), entry(0), psize(0), lsize(0) {}
+    void clear();
+};
+
+struct nas_upval {
+public:
+    /* on stack, use these variables */
+    bool onstk;
+    u32 size;
+    var* stk;
+
+    /* not on stack, use this */
+    std::vector<var> elems;
+
+public:
+    nas_upval(): onstk(true), size(0), stk(nullptr) {}
+
+    var& operator[](usize n) {
+        return onstk? stk[n]:elems[n];
+    }
+
+    void clear() {
+        onstk=true;
+        elems.clear();
+        size=0;
+    }
+};
+
+void filehandle_destructor(void*);
+void dir_entry_destructor(void*);
+void dylib_destructor(void*);
+void func_addr_destructor(void*);
+
+struct ghost_register_table {
+private:
+    using dtor=void (*)(void*);
+
+private:
+    std::unordered_map<std::string, usize> mapper;
+    std::vector<std::string> ghost_name;
+    std::vector<dtor> destructors;
+
+public:
+    // reserved ghost type only for native functions
+    usize ghost_file;
+    usize ghost_dir;
+    usize ghost_dylib;
+    usize ghost_faddr;
+
+public:
+    ghost_register_table() {
+        ghost_file = register_ghost_type("file", filehandle_destructor);
+        ghost_dir = register_ghost_type("dir", dir_entry_destructor);
+        ghost_dylib = register_ghost_type("dylib", dylib_destructor);
+        ghost_faddr = register_ghost_type("faddr", func_addr_destructor);
+    }
+
+    bool exists(const std::string& name) const {
+        return mapper.count(name);
+    }
+
+    usize get_ghost_type_index(const std::string& name) const {
+        return mapper.at(name);
+    }
+
+    const std::string& get_ghost_name(usize index) const {
+        return ghost_name.at(index);
+    }
+
+    usize register_ghost_type(const std::string& name, dtor ptr) {
+        if (mapper.count(name)) {
+            std::cerr<<"nasal_gc.h: ghost_register_table::register_ghost_type: ";
+            std::cerr<<"ghost type \""<<name<<"\" already exists.\n";
+            std::exit(1);
+        }
+        auto res=destructors.size();
+        mapper[name]=res;
+        ghost_name.push_back(name);
+        destructors.push_back(ptr);
+        return res;
+    }
+
+    dtor destructor(usize index) {
+        return destructors.at(index);
+    }
+};
+
+struct nas_ghost {
+public:
+    usize type;
+    void* ptr;
+
+private:
+    ghost_register_table* ghost_type_table;
+
+public:
+    nas_ghost(): type(0), ptr(nullptr), ghost_type_table(nullptr) {}
+    ~nas_ghost() {clear();}
+    void set(usize, void*, ghost_register_table*);
+    void clear();
+
+public:
+    friend std::ostream& operator<<(std::ostream& out, nas_ghost& ghost) {
+        out<<"<object "<<ghost.ghost_type_table->get_ghost_name(ghost.type);
+        out<<" at 0x"<<std::hex<<(u64)ghost.ptr<<std::dec<<">";
+        return out;
+    }
+
+    const std::string& get_ghost_name() const {
+        return ghost_type_table->get_ghost_name(type);
+    }
+};
+
+struct context {
+    u32  pc;
+    var* localr;
+    var* memr;
+    var  funcr;
+    var  upvalr;
+    var* canary;
+    var* stack;
+    var* top;
+};
+
+struct nas_co {
+    var stack[STACK_DEPTH];
+    context ctx;
+    coroutine_status status;
+
+    nas_co() {clear();}
+    void clear();
+};
+
+struct nas_val {
+    gc_status mark;
+    u8 type; // value type
+    u8 unmut; // used to mark if a string is unmutable
+    union {
+        std::string* str;
+        nas_vec*   vec;
+        nas_hash*  hash;
+        nas_func*  func;
+        nas_upval* upval;
+        nas_ghost* obj;
+        nas_co*    co;
+    } ptr;
+
+    nas_val(u8);
+    ~nas_val();
+    void clear();
+};
+
+std::ostream& operator<<(std::ostream&, nas_vec&);
+std::ostream& operator<<(std::ostream&, nas_hash&);
+std::ostream& operator<<(std::ostream&, var&);
+
+const var zero = var::num(0);
+const var one = var::num(1);
+const var nil = var::nil();
+
+struct gc {
+    ghost_register_table global_ghost_type_table;
+    /* main context temporary storage */
+    context mctx;
+
+    /* runtime context */
+    context* rctx;
+    nas_co* cort=nullptr; // running coroutine
+
+    /*  temporary space used in builtin/module functions */
+    var temp=nil;
+
+    /* constants and memory pool */
+    std::vector<var> strs;        // reserved address for const vm_str
+    std::vector<var> env_argv;    // command line arguments
+    std::vector<nas_val*> memory; // gc memory
+    std::vector<nas_val*> unused[gc_type_size]; // gc free list
+
+    /* heap increase size */
+    u32 incr[gc_type_size]={
+        128, // vm_str
+        128, // vm_vec
+        64,  // vm_hash
+        128, // vm_func
+        256, // vm_upval
+        16,  // vm_obj
+        16   // vm_co
+    };
+
+    /* values for analysis */
+    u64 size[gc_type_size];
+    u64 gcnt[gc_type_size];
+    u64 acnt[gc_type_size];
+    i64 worktime=0;
+
+    gc(context* _ctx): rctx(_ctx) {}
+
+private:
+    /* gc functions */
+    void mark();
+    void mark_context(std::vector<var>&);
+    void mark_var(std::vector<var>&, var&);
+    inline void mark_vec(std::vector<var>&, nas_vec&);
+    inline void mark_hash(std::vector<var>&, nas_hash&);
+    inline void mark_func(std::vector<var>&, nas_func&);
+    inline void mark_upval(std::vector<var>&, nas_upval&);
+    inline void mark_co(std::vector<var>&, nas_co&);
+    void sweep();
+
+public:
+    void extend(u8);
+    void init(const std::vector<std::string>&, const std::vector<std::string>&);
+    void clear();
+    void info();
+    var alloc(const u8);
+    void ctxchg(nas_co&);
+    void ctxreserve();
+
+public:
+    var newstr(char c) {
+        var s=alloc(vm_str);
+        s.str()=c;
+        return s;
+    }
+
+    var newstr(const char* buff) {
+        var s=alloc(vm_str);
+        s.str()=buff;
+        return s;
+    }
+
+    var newstr(const std::string& buff) {
+        var s=alloc(vm_str);
+        s.str()=buff;
+        return s;
+    }
+};
+
+// use to print error log and return error value
+var nas_err(const std::string&, const std::string&);
+
+// module function type
+typedef var (*module_func)(var*, usize, gc*);
+
+// module function stores in tables with this type, end with {nullptr,nullptr}
+struct module_func_info {
+    const char* name;
+    module_func fd;
+};
+
+// module function "get" type
+typedef module_func_info* (*get_func_ptr)(ghost_register_table*);
diff --git a/ast/nasal_new_import.cpp b/ast/nasal_new_import.cpp
index 535ee37..da52eb2 100644
--- a/ast/nasal_new_import.cpp
+++ b/ast/nasal_new_import.cpp
@@ -137,9 +137,16 @@ void linker::link(code_block* new_tree_root, code_block* old_tree_root) {
 code_block* linker::import_regular_file(call_expr* node) {
     lexer lex(err);
     parse par(err);
-    // get filename and set node to ast_null
+    // get filename
     auto filename = get_path(node);
-    // node.clear();
+    // clear this node
+    for(auto i : node->get_calls()) {
+        delete i;
+    }
+    node->get_calls().clear();
+    auto location = node->get_first()->get_location();
+    delete node->get_first();
+    node->set_first(new nil_expr(location));
 
     // avoid infinite loading loop
     filename = find_file(filename);
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index a306be5..5660f36 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -284,9 +284,8 @@ void parse::params(function* func_node) {
     match(tok::lcurve);
     while(!lookahead(tok::rcurve)) {
         auto param = new parameter(toks[ptr].loc);
-        auto id_node = id();
-        param->set_parameter_name(id_node->get_name());
-        delete id_node;
+        param->set_parameter_name(toks[ptr].str);
+        match(tok::id);
         if (lookahead(tok::eq)) {
             match(tok::eq);
             param->set_parameter_type(parameter::param_type::default_parameter);
diff --git a/makefile b/makefile
index 915b1d8..52fbc9c 100644
--- a/makefile
+++ b/makefile
@@ -76,9 +76,11 @@ test:nasal
 NASAL_NEW_AST=\
 	nasal_new_misc.o\
 	nasal_new_err.o\
+	nasal_new_gc.o\
 	nasal_new_import.o\
 	nasal_new_lexer.o\
 	nasal_new_ast.o\
+	nasal_new_builtin.o\
 	nasal_new_parse.o\
 	ast_visitor.o\
 	ast_dumper.o\
@@ -86,7 +88,7 @@ NASAL_NEW_AST=\
 
 # for test
 nnew: $(NASAL_NEW_AST)
-	$(CXX) $(NASAL_NEW_AST) -o nnew
+	$(CXX) $(NASAL_NEW_AST) -o nnew -ldl
 	@ echo "build done"
 
 nasal_new_main.o: ast/nasal_new_main.cpp
@@ -98,15 +100,21 @@ nasal_new_misc.o: ast/nasal_new_header.h ast/nasal_new_misc.cpp
 nasal_new_err.o: ast/nasal_new_err.h ast/nasal_new_err.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_err.cpp -fno-exceptions -fPIC -o nasal_new_err.o -I .
 
+nasal_new_gc.o: ast/nasal_new_gc.h ast/nasal_new_gc.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_gc.cpp -fno-exceptions -fPIC -o nasal_new_gc.o -I . 
+
 nasal_new_import.o: ast/nasal_new_import.h ast/nasal_new_import.cpp
-	$(CXX) --std=$(STD) -c -O3 ast/nasal_new_import.cpp -fno-exceptions -fPIC -o nasal_new_import.o -I .
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_import.cpp -fno-exceptions -fPIC -o nasal_new_import.o -I .
 
 nasal_new_lexer.o: ast/nasal_new_lexer.h ast/nasal_new_lexer.cpp
-	$(CXX) --std=$(STD) -c -O3 ast/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.o -I .
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.o -I .
 
 nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
 
+nasal_new_builtin.o: ast/nasal_new_builtin.h ast/nasal_new_builtin.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_builtin.cpp -fno-exceptions -fPIC -o nasal_new_builtin.o -I .
+
 nasal_new_parse.o: ast/nasal_new_parse.h ast/nasal_new_parse.cpp ast/nasal_new_ast.h
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_parse.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
 
diff --git a/nasal_builtin.h b/nasal_builtin.h
index cb492fd..d800bd3 100644
--- a/nasal_builtin.h
+++ b/nasal_builtin.h
@@ -1287,6 +1287,18 @@ var builtin_logtime(var* local, gc& ngc) {
     return ngc.newstr(s);
 }
 
+var builtin_ghosttype(var* local, gc& ngc) {
+    var arg = local[1];
+    if (arg.type!=vm_obj) {
+        return nas_err("ghosttype", "this is not a ghost object.");
+    }
+    const auto& name = arg.obj().get_ghost_name();
+    if (!name.length()) {
+        return var::num((u64)arg.obj().ptr);
+    }
+    return ngc.newstr(name);
+}
+
 // register builtin function's name and it's address here in this table below
 // this table must end with {nullptr,nullptr}
 struct {
@@ -1383,5 +1395,6 @@ struct {
     {"__sysargv", builtin_sysargv },
     {"__gcextd",  builtin_gcextend},
     {"__logtime", builtin_logtime },
+    {"__ghosttype", builtin_ghosttype},
     {nullptr,     nullptr         }
 };
diff --git a/nasal_gc.h b/nasal_gc.h
index a889d63..d66bf25 100644
--- a/nasal_gc.h
+++ b/nasal_gc.h
@@ -283,6 +283,10 @@ public:
         out<<" at 0x"<<std::hex<<(u64)ghost.ptr<<std::dec<<">";
         return out;
     }
+
+    const std::string& get_ghost_name() const {
+        return ghost_type_table->get_ghost_name(type);
+    }
 };
 
 struct context {
diff --git a/stl/lib.nas b/stl/lib.nas
index d8e3ba3..ff8e774 100644
--- a/stl/lib.nas
+++ b/stl/lib.nas
@@ -250,6 +250,9 @@ var isvec=func(v){
     return typeof(v)=="vec";
 }
 
+var ghosttype=func(ghost_object) {
+    return __ghosttype(ghost_object);
+}
 
 # get the index of val in the vec
 var vecindex=func(vec,val){

From 15f63210b42969e6bbee75c529ec0223212f1ec0 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Wed, 28 Jun 2023 00:34:54 +0800
Subject: [PATCH 21/34] :sparkles: add codegen/opcode/optimizer

---
 ast/ast_dumper.h          |   5 ++
 ast/nasal_new_codegen.cpp |   1 +
 ast/nasal_new_codegen.h   |   1 +
 ast/nasal_new_main.cpp    |   7 +-
 ast/nasal_new_opcode.cpp  |  86 ++++++++++++++++++++++
 ast/nasal_new_opcode.h    | 146 ++++++++++++++++++++++++++++++++++++++
 ast/optimizer.cpp         |  21 ++++++
 ast/optimizer.h           |  83 ++++++++++++++++++++++
 makefile                  |  12 ++++
 9 files changed, 360 insertions(+), 2 deletions(-)
 create mode 100644 ast/nasal_new_codegen.cpp
 create mode 100644 ast/nasal_new_codegen.h
 create mode 100644 ast/nasal_new_opcode.cpp
 create mode 100644 ast/nasal_new_opcode.h
 create mode 100644 ast/optimizer.cpp
 create mode 100644 ast/optimizer.h

diff --git a/ast/ast_dumper.h b/ast/ast_dumper.h
index 25a26e4..cb9bcb9 100644
--- a/ast/ast_dumper.h
+++ b/ast/ast_dumper.h
@@ -74,4 +74,9 @@ public:
     bool visit_continue_expr(continue_expr*) override;
     bool visit_break_expr(break_expr*) override;
     bool visit_return_expr(return_expr*) override;
+
+public:
+    void dump(code_block* root) {
+        root->accept(this);
+    }
 };
\ No newline at end of file
diff --git a/ast/nasal_new_codegen.cpp b/ast/nasal_new_codegen.cpp
new file mode 100644
index 0000000..84b8848
--- /dev/null
+++ b/ast/nasal_new_codegen.cpp
@@ -0,0 +1 @@
+#include "nasal_new_codegen.h"
\ No newline at end of file
diff --git a/ast/nasal_new_codegen.h b/ast/nasal_new_codegen.h
new file mode 100644
index 0000000..7b9637e
--- /dev/null
+++ b/ast/nasal_new_codegen.h
@@ -0,0 +1 @@
+#pragma once
\ No newline at end of file
diff --git a/ast/nasal_new_main.cpp b/ast/nasal_new_main.cpp
index 395d2d9..75fbf95 100644
--- a/ast/nasal_new_main.cpp
+++ b/ast/nasal_new_main.cpp
@@ -6,6 +6,7 @@
 #include "nasal_new_import.h"
 #include "ast_visitor.h"
 #include "ast_dumper.h"
+#include "optimizer.h"
 
 #include <unordered_map>
 #include <thread>
@@ -93,11 +94,13 @@ void execute(
     ld.link(parse, file, cmd&VM_DETAIL).chkerr();
     if (cmd&VM_AST) {
         auto dumper = new ast_dumper();
-        dumper->visit_code_block(parse.tree());
+        dumper->dump(parse.tree());
     }
 
     // optimizer does simple optimization on ast
-    // optimize(parse.tree());
+    auto opt = new optimizer;
+    opt->do_optimization(parse.tree());
+    delete opt;
 
     // code generator gets parser's ast and import file list to generate code
     // gen.compile(parse, ld).chkerr();
diff --git a/ast/nasal_new_opcode.cpp b/ast/nasal_new_opcode.cpp
new file mode 100644
index 0000000..bbe9ef5
--- /dev/null
+++ b/ast/nasal_new_opcode.cpp
@@ -0,0 +1,86 @@
+#include "nasal_new_opcode.h"
+
+void codestream::set(
+    const f64* numbuff,
+    const std::string* strbuff,
+    const std::string* filelist=nullptr
+) {
+    nums=numbuff;
+    strs=strbuff;
+    files=filelist;
+}
+
+void codestream::dump(std::ostream& out) const {
+    using std::setw;
+    using std::setfill;
+    using std::hex;
+    using std::dec;
+    auto op=code.op;
+    auto num=code.num;
+    out<<hex<<"0x"
+        <<setw(6)<<setfill('0')<<index<<"     "
+        <<setw(2)<<setfill('0')<<(u32)op<<" "
+        <<setw(2)<<setfill('0')<<((num>>16)&0xff)<<" "
+        <<setw(2)<<setfill('0')<<((num>>8)&0xff)<<" "
+        <<setw(2)<<setfill('0')<<(num&0xff)<<"     "
+        <<opname[op]<<"  "<<dec;
+    switch(op) {
+        case op_addeq: case op_subeq:
+        case op_muleq: case op_diveq:
+        case op_lnkeq: case op_meq:
+        case op_btandeq: case op_btoreq:
+        case op_btxoreq:
+            out<<hex<<"0x"<<num<<dec<<" sp-"<<num;break;
+        case op_addeqc: case op_subeqc:
+        case op_muleqc:case op_diveqc:
+            out<<hex<<"0x"<<num<<dec<<" ("<<nums[num]<<")";break;
+        case op_lnkeqc:
+            out<<hex<<"0x"<<num<<dec<<" ("<<rawstr(strs[num], 16)<<")";break;
+        case op_addecp: case op_subecp:
+        case op_mulecp: case op_divecp:
+            out<<hex<<"0x"<<num<<dec<<" ("<<nums[num]<<") sp-1";break;
+        case op_lnkecp:
+            out<<hex<<"0x"<<num<<dec<<" ("<<rawstr(strs[num], 16)<<") sp-1";break;
+        case op_addc: case op_subc:
+        case op_mulc: case op_divc:
+        case op_lessc: case op_leqc:
+        case op_grtc: case op_geqc:
+        case op_pnum:
+            out<<hex<<"0x"<<num<<dec<<" ("<<nums[num]<<")";break;
+        case op_callvi: case op_newv:
+        case op_callfv: case op_intg:
+        case op_intl: case op_findex:
+        case op_feach: case op_newf:
+        case op_jmp: case op_jt:
+        case op_jf: case op_callg:
+        case op_mcallg: case op_loadg:
+        case op_calll: case op_mcalll:
+        case op_loadl:
+            out<<hex<<"0x"<<num<<dec;break;
+        case op_callb:
+            out<<hex<<"0x"<<num<<" <"<<builtin[num].name
+                <<"@0x"<<(u64)builtin[num].func<<dec<<">";break;
+        case op_upval: case op_mupval:
+        case op_loadu:
+            out<<hex<<"0x"<<((num>>16)&0xffff)
+                <<"[0x"<<(num&0xffff)<<"]"<<dec;break;
+        case op_happ: case op_pstr:
+        case op_lnkc: case op_callh:
+        case op_mcallh: case op_para:
+        case op_deft: case op_dyn:
+            out<<hex<<"0x"<<num<<dec<<" ("<<rawstr(strs[num], 16)<<")";break;
+        default:
+            if (files) {
+                out<<hex<<"0x"<<num<<dec;
+            }
+            break;
+    }
+    if (files) {
+        out<<"("<<files[code.fidx]<<":"<<code.line<<")";
+    }
+}
+
+std::ostream& operator<<(std::ostream& out, const codestream& ins) {
+    ins.dump(out);
+    return out;
+}
\ No newline at end of file
diff --git a/ast/nasal_new_opcode.h b/ast/nasal_new_opcode.h
new file mode 100644
index 0000000..e2428f6
--- /dev/null
+++ b/ast/nasal_new_opcode.h
@@ -0,0 +1,146 @@
+#pragma once
+
+#include "nasal_new_header.h"
+#include "nasal_new_builtin.h"
+
+#include <iostream>
+
+enum op_code_type:u8 {
+    op_exit,   // stop the virtual machine
+    op_intg,   // global scope size, set stack top
+    op_intl,   // local scope size
+    op_loadg,  // load global value
+    op_loadl,  // load local value
+    op_loadu,  // load upvalue
+    op_pnum,   // push constant number to the stack
+    op_pnil,   // push constant nil to the stack
+    op_pstr,   // push constant std::string to the stack
+    op_newv,   // push new vector with initial values from stack
+    op_newh,   // push new hash to the stack
+    op_newf,   // push new function to the stack
+    op_happ,   // hash append
+    op_para,   // normal  parameter
+    op_deft,   // default parameter
+    op_dyn,    // dynamic parameter
+    op_lnot,   // ! logical negation
+    op_usub,   // - negation
+    op_bnot,   // ~ bitwise not static_cast<i32>
+    op_btor,   // | bitwise or
+    op_btxor,  // ^ bitwise xor
+    op_btand,  // & bitwise and
+    op_add,    // +
+    op_sub,    // -
+    op_mul,    // *
+    op_div,    // /
+    op_lnk,    // ~
+    op_addc,   // + const
+    op_subc,   // - const
+    op_mulc,   // * const
+    op_divc,   // / const
+    op_lnkc,   // ~ const
+    op_addeq,  // += maybe pop stack top
+    op_subeq,  // -= maybe pop stack top
+    op_muleq,  // *= maybe pop stack top
+    op_diveq,  // /= maybe pop stack top
+    op_lnkeq,  // ~= maybe pop stack top
+    op_btandeq,// &= maybe pop stack top
+    op_btoreq, // |= maybe pop stack top
+    op_btxoreq,// ^= maybe pop stack top
+    op_addeqc, // += const don't pop stack top
+    op_subeqc, // -= const don't pop stack top
+    op_muleqc, // *= const don't pop stack top
+    op_diveqc, // /= const don't pop stack top
+    op_lnkeqc, // ~= const don't pop stack top
+    op_addecp, // += const and pop stack top
+    op_subecp, // -= const and pop stack top
+    op_mulecp, // *= const and pop stack top
+    op_divecp, // /= const and pop stack top
+    op_lnkecp, // ~= concat const std::string and pop stack top
+    op_meq,    // = maybe pop stack top
+    op_eq,     // ==
+    op_neq,    // !=
+    op_less,   // <
+    op_leq,    // <=
+    op_grt,    // >
+    op_geq,    // >=
+    op_lessc,  // < const
+    op_leqc,   // <= const
+    op_grtc,   // > const
+    op_geqc,   // >= const
+    op_pop,    // pop a value out of stack top
+    op_jmp,    // jump absolute address with no condition
+    op_jt,     // used in operator and/or,jmp when condition is true and DO NOT POP
+    op_jf,     // used in conditional/loop,jmp when condition is false and POP STACK
+    op_cnt,    // add counter for forindex/foreach
+    op_findex, // index counter on the top of forindex_stack plus 1
+    op_feach,  // index counter on the top of forindex_stack plus 1 and get the value in vector
+    op_callg,  // get value in global scope
+    op_calll,  // get value in local scope
+    op_upval,  // get value in closure, high 16 as the index of upval, low 16 as the index of local
+    op_callv,  // call vec[index]
+    op_callvi, // call vec[immediate] (used in multi-assign/multi-define)
+    op_callh,  // call hash.label
+    op_callfv, // call function(vector as parameters)
+    op_callfh, // call function(hash as parameters)
+    op_callb,  // call builtin-function
+    op_slcbeg, // begin of slice like: vec[1,2,3:6,0,-1]
+    op_slcend, // end of slice
+    op_slc,    // slice like vec[1]
+    op_slc2,   // slice like vec[nil:10]
+    op_mcallg, // get memory space of value in global scope
+    op_mcalll, // get memory space of value in local scope
+    op_mupval, // get memory space of value in closure
+    op_mcallv, // get memory space of vec[index]
+    op_mcallh, // get memory space of hash.label
+    op_ret     // return
+};
+
+const char* opname[]={
+    "exit  ","intg  ","intl  ","loadg ",
+    "loadl ","loadu ","pnum  ","pnil  ",
+    "pstr  ","newv  ","newh  ","newf  ",
+    "happ  ","para  ","def   ","dyn   ",
+    "lnot  ","usub  ","bnot  ","btor  ",
+    "btxor ","btand ","add   ","sub   ",
+    "mult  ","div   ","lnk   ","addc  ",
+    "subc  ","multc ","divc  ","lnkc  ",
+    "addeq ","subeq ","muleq ","diveq ",
+    "lnkeq ","bandeq","boreq ","bxoreq",
+    "addeqc","subeqc","muleqc","diveqc",
+    "lnkeqc","addecp","subecp","mulecp",
+    "divecp","lnkecp","meq   ","eq    ",
+    "neq   ","less  ","leq   ","grt   ",
+    "geq   ","lessc ","leqc  ","grtc  ",
+    "geqc  ","pop   ","jmp   ","jt    ",
+    "jf    ","cnt   ","findx ","feach ",
+    "callg ","calll ","upval ","callv ",
+    "callvi","callh ","callfv","callfh",
+    "callb ","slcbeg","slcend","slc   ",
+    "slc2  ","mcallg","mcalll","mupval",
+    "mcallv","mcallh","ret   "
+};
+
+struct opcode {
+    u8  op;   // opcode
+    u16 fidx; // source code file index
+    u32 num;  // immediate num
+    u32 line; // location line of source code
+    opcode() = default;
+    opcode(const opcode&) = default;
+    opcode& operator=(const opcode&) = default;
+};
+
+class codestream {
+private:
+    opcode code;
+    const u32 index;
+    inline static const f64* nums = nullptr;
+    inline static const std::string* strs = nullptr;
+    inline static const std::string* files = nullptr;
+public:
+    codestream(const opcode& c, const u32 i): code(c), index(i) {}
+    static void set(const f64*, const std::string*, const std::string*);
+    void dump(std::ostream&) const;
+};
+
+std::ostream& operator<<(std::ostream&, const codestream&);
\ No newline at end of file
diff --git a/ast/optimizer.cpp b/ast/optimizer.cpp
new file mode 100644
index 0000000..1d4ca56
--- /dev/null
+++ b/ast/optimizer.cpp
@@ -0,0 +1,21 @@
+#include "optimizer.h"
+
+void const_string(binary_operator* node) {
+
+}
+
+void const_number(binary_operator* node) {
+    
+}
+
+bool optimizer::visit_binary_operator(binary_operator* node) {
+    return true;
+}
+
+bool optimizer::visit_unary_operator(unary_operator* node) {
+    return true;
+}
+
+void optimizer::do_optimization(code_block* root) {
+    root->accept(this);
+}
\ No newline at end of file
diff --git a/ast/optimizer.h b/ast/optimizer.h
new file mode 100644
index 0000000..b26dabd
--- /dev/null
+++ b/ast/optimizer.h
@@ -0,0 +1,83 @@
+#pragma once
+
+#include <cmath>
+
+#include "nasal_new_ast.h"
+#include "ast_visitor.h"
+
+class optimizer:public ast_visitor {
+private:
+    void const_string(binary_operator*);
+    void const_number(binary_operator*);
+
+public:
+    bool visit_binary_operator(binary_operator*) override;
+    bool visit_unary_operator(unary_operator*) override;
+
+public:
+    void do_optimization(code_block*);
+};
+
+// void const_str(ast& root) {
+//     auto& vec=root.child();
+//     root.set_str(vec[0].str()+vec[1].str());
+//     root.child().clear();
+//     root.set_type(ast_str);
+// }
+
+// void const_num(ast& root) {
+//     auto& vec=root.child();
+//     f64 res=0;
+//     switch(root.type()) {
+//         case ast_add:    res=vec[0].num()+vec[1].num(); break;
+//         case ast_sub:    res=vec[0].num()-vec[1].num(); break;
+//         case ast_mult:   res=vec[0].num()*vec[1].num(); break;
+//         case ast_div:    res=vec[0].num()/vec[1].num(); break;
+//         case ast_less:   res=vec[0].num()<vec[1].num(); break;
+//         case ast_leq:    res=vec[0].num()<=vec[1].num();break;
+//         case ast_grt:    res=vec[0].num()>vec[1].num(); break;
+//         case ast_geq:    res=vec[0].num()>=vec[1].num();break;
+//         case ast_bitor:  res=i32(vec[0].num())|i32(vec[1].num()); break;
+//         case ast_bitxor: res=i32(vec[0].num())^i32(vec[1].num()); break;
+//         case ast_bitand: res=i32(vec[0].num())&i32(vec[1].num()); break;
+//     }
+//     // inf and nan will cause number hashmap error in codegen
+//     if (std::isinf(res) || std::isnan(res)) {
+//         return;
+//     }
+//     root.set_num(res);
+//     root.child().clear();
+//     root.set_type(ast_num);
+// }
+
+// void calc_const(ast& root) {
+//     auto& vec=root.child();
+//     for(auto& i:vec) {
+//         calc_const(i);
+//     }
+//     if (vec.size()==1 && root.type()==ast_neg && vec[0].type()==ast_num) {
+//         f64 res=-vec[0].num();
+//         root.set_num(res);
+//         root.child().clear();
+//         root.set_type(ast_num);
+//         return;
+//     }
+//     if (vec.size()!=2) {
+//         return;
+//     }
+//     if (root.type()!=ast_add && root.type()!=ast_sub &&
+//        root.type()!=ast_mult && root.type()!=ast_div &&
+//        root.type()!=ast_link && root.type()!=ast_less &&
+//        root.type()!=ast_leq && root.type()!=ast_grt &&
+//        root.type()!=ast_geq && root.type()!=ast_bitor &&
+//        root.type()!=ast_bitxor && root.type()!=ast_bitand) {
+//         return;
+//     }
+//     if (root.type()==ast_link &&
+//        vec[0].type()==ast_str && vec[1].type()==ast_str) {
+//         const_str(root);
+//     } else if (root.type()!=ast_link &&
+//             vec[0].type()==ast_num && vec[1].type()==ast_num) {
+//         const_num(root);
+//     }
+// }
\ No newline at end of file
diff --git a/makefile b/makefile
index 52fbc9c..89209bb 100644
--- a/makefile
+++ b/makefile
@@ -81,7 +81,10 @@ NASAL_NEW_AST=\
 	nasal_new_lexer.o\
 	nasal_new_ast.o\
 	nasal_new_builtin.o\
+	nasal_new_codegen.o\
+	nasal_new_opcode.o\
 	nasal_new_parse.o\
+	optimizer.o\
 	ast_visitor.o\
 	ast_dumper.o\
 	nasal_new_main.o
@@ -115,9 +118,18 @@ nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp
 nasal_new_builtin.o: ast/nasal_new_builtin.h ast/nasal_new_builtin.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_builtin.cpp -fno-exceptions -fPIC -o nasal_new_builtin.o -I .
 
+nasal_new_codegen.o: ast/nasal_new_codegen.h ast/nasal_new_codegen.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.o -I .
+
+nasal_new_opcode.o: ast/nasal_new_opcode.h ast/nasal_new_opcode.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_opcode.cpp -fno-exceptions -fPIC -o nasal_new_opcode.o -I .
+
 nasal_new_parse.o: ast/nasal_new_parse.h ast/nasal_new_parse.cpp ast/nasal_new_ast.h
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_parse.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
 
+optimizer.o: ast/optimizer.h ast/optimizer.cpp ast/nasal_new_ast.h
+	$(CXX) -std=$(STD) -c -O3 ast/optimizer.cpp -fno-exceptions -fPIC -o optimizer.o -I .
+
 ast_visitor.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_visitor.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .
 

From 5d9267d3b9a677014685d264a8f05f2632e822f1 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Thu, 29 Jun 2023 00:30:50 +0800
Subject: [PATCH 22/34] :sparkles: add symbol_finder & codegen

---
 ast/nasal_new_ast.h       |   8 +-
 ast/nasal_new_codegen.cpp | 977 +++++++++++++++++++++++++++++++++++++-
 ast/nasal_new_codegen.h   | 102 +++-
 ast/nasal_new_main.cpp    |   6 +
 ast/nasal_new_opcode.cpp  |   8 +-
 ast/nasal_new_opcode.h    |   2 +-
 ast/nasal_new_parse.cpp   |   3 +-
 ast/symbol_finder.cpp     |  29 ++
 ast/symbol_finder.h       |  19 +
 makefile                  |   6 +-
 10 files changed, 1146 insertions(+), 14 deletions(-)
 create mode 100644 ast/symbol_finder.cpp
 create mode 100644 ast/symbol_finder.h

diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index 0def471..50e816b 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -247,7 +247,7 @@ public:
     void set_parameter_type(param_type pt) {type = pt;}
     void set_parameter_name(const std::string& pname) {name = pname;}
     void set_default_value(expr* node) {default_value = node;}
-    param_type get_type() {return type;}
+    param_type get_parameter_type() {return type;}
     const std::string& get_parameter_name() const {return name;}
     expr* get_default_value() {return default_value;}
     void accept(ast_visitor*) override;
@@ -465,14 +465,14 @@ public:
 
 class multi_identifier:public expr {
 private:
-    std::vector<expr*> variables;
+    std::vector<identifier*> variables;
 
 public:
     multi_identifier(const span& location):
         expr(location, expr_type::ast_multi_id) {}
     ~multi_identifier();
-    void add_var(expr* node) {variables.push_back(node);}
-    std::vector<expr*>& get_variables() {return variables;}
+    void add_var(identifier* node) {variables.push_back(node);}
+    std::vector<identifier*>& get_variables() {return variables;}
     void accept(ast_visitor*) override;
 };
 
diff --git a/ast/nasal_new_codegen.cpp b/ast/nasal_new_codegen.cpp
index 84b8848..35ffeed 100644
--- a/ast/nasal_new_codegen.cpp
+++ b/ast/nasal_new_codegen.cpp
@@ -1 +1,976 @@
-#include "nasal_new_codegen.h"
\ No newline at end of file
+#include "nasal_new_codegen.h"
+
+bool codegen::check_memory_reachable(call_expr* node) {
+    if (node->get_type()==expr_type::ast_call) {
+        const ast& tmp=node.child().back();
+        if (tmp->get_type()==expr_type::ast_callf) {
+            die("bad left-value with function call", node->get_location());
+            return false;
+        }
+        if (tmp->get_type()==expr_type::ast_callv && (tmp.size()==0 || tmp.size()>1 || tmp[0]->get_type()==expr_type::ast_subvec)) {
+            die("bad left-value with subvec", node->get_location());
+            return false;
+        }
+    } else if (node->get_type()!=ast_id) {
+        die("bad left-value", node->get_location());
+        return false;
+    }
+    return true;
+}
+
+void codegen::check_id_exist(identifier* node) {
+    const auto& name = node->get_name();
+    for(u32 i=0;builtin[i].name;++i) {
+        if (builtin[i].name==name) {
+            if (local.empty()) {
+                die("useless native function used in global scope", node->get_location());
+            }
+            return;
+        }
+    }
+
+    if (local_find(name)>=0) {
+        return;
+    }
+    if (upvalue_find(name)>=0) {
+        return;
+    }
+    if (global_find(name)>=0) {
+        return;
+    }
+    die("undefined symbol \"" + name + "\", and this symbol is useless here", node->get_location());
+}
+
+void codegen::regist_num(const f64 num) {
+    if (!num_table.count(num)) {
+        u32 size=num_table.size();
+        num_table[num]=size;
+        num_res.push_back(num);
+    }
+}
+
+void codegen::regist_str(const std::string& str) {
+    if (!str_table.count(str)) {
+        u32 size=str_table.size();
+        str_table[str]=size;
+        str_res.push_back(str);
+    }
+}
+
+void codegen::find_symbol(code_block* node) {
+    auto finder = new symbol_finder;
+    for(const auto& i : finder->do_find(node)) {
+        add_sym(i);
+    }
+}
+
+void codegen::add_sym(const std::string& name) {
+    if (local.empty()) {
+        if (global.count(name)) {
+            return;
+        }
+        i32 index=global.size();
+        global[name]=index;
+        return;
+    }
+    if (local.back().count(name)) {
+        return;
+    }
+    i32 index=local.back().size();
+    local.back()[name]=index;
+}
+
+i32 codegen::local_find(const std::string& name) {
+    if (local.empty()) {
+        return -1;
+    }
+    return local.back().count(name)?local.back()[name]:-1;
+}
+
+i32 codegen::global_find(const std::string& name) {
+    return global.count(name)?global[name]:-1;
+}
+
+i32 codegen::upvalue_find(const std::string& name) {
+    // 32768 level 65536 upvalues
+    i32 index=-1;
+    usize size=local.size();
+    if (size<=1) {
+        return -1;
+    }
+    auto iter=local.begin();
+    for(u32 i=0;i<size-1;++i,++iter) {
+        if (iter->count(name)) {
+            index=((i<<16)|(*iter)[name]);
+        }
+    }
+    return index;
+}
+
+void codegen::gen(u8 op, u32 num, u32 line) {
+    code.push_back({op, fileindex, num, line});
+}
+
+void codegen::num_gen(number_literal* node) {
+    f64 num = node->get_number();
+    regist_num(num);
+    gen(op_pnum,num_table[num], node->get_location().begin_line);
+}
+
+void codegen::str_gen(string_literal* node) {
+    regist_str(node->get_content());
+    gen(op_pstr, str_table[node->get_content()], node->get_location().begin_line);
+}
+
+void codegen::bool_gen(bool_literal* node) {
+    f64 num = node->get_flag()?1:0;
+    regist_num(num);
+    gen(op_pnum, num_table[num], node->get_location().begin_line);
+}
+
+void codegen::vec_gen(vector_expr* node) {
+    for(auto child : node->get_elements()) {
+        calc_gen(child);
+    }
+    gen(op_newv, node->get_elements().size(), node->get_location().begin_line);
+}
+
+void codegen::hash_gen(hash_expr* node) {
+    gen(op_newh, 0, node->get_location().begin_line);
+    for(auto child : node->get_members()) {
+        calc_gen(child->get_value());
+        const std::string& str=child->get_name();
+        regist_str(str);
+        gen(op_happ, str_table[str], child->get_location().begin_line);
+    }
+}
+
+void codegen::func_gen(function* node) {
+    // parameter list format check
+    bool checked_default = false;
+    bool checked_dynamic = false;
+    std::unordered_map<std::string,bool> argname;
+    for(auto tmp : node->get_parameter_list()) {
+        if (tmp->get_parameter_type()==parameter::param_type::default_parameter) {
+            checked_default=true;
+        } else if (tmp->get_parameter_type()==parameter::param_type::dynamic_parameter) {
+            checked_dynamic=true;
+        }
+        // check default parameter and dynamic parameter
+        if (checked_default && tmp->get_parameter_type()!=parameter::param_type::default_parameter) {
+            die("must use default parameters here", tmp->get_location());
+        }
+        if (checked_dynamic && tmp!=node->get_parameter_list().back()) {
+            die("dynamic parameter must be the last one", tmp->get_location());
+        }
+        // check redefinition
+        const auto& name = tmp->get_parameter_name();
+        if (argname.count(name)) {
+            die("redefinition of parameter: "+name, tmp->get_location());
+        } else {
+            argname[name]=true;
+        }
+    }
+
+    usize newf=code.size();
+    gen(op_newf, 0, node->get_location().begin_line);
+    usize lsize=code.size();
+    gen(op_intl, 0, node->get_location().begin_line);
+    
+    // add special keyword 'me' into symbol table
+    // this symbol is only used in local scope(function's scope)
+    // this keyword is set to nil as default value
+    // after calling a hash, this keyword is set to this hash
+    // this symbol's index will be 0
+    local.push_back({{"me", 0}});
+
+    // generate parameter list
+    for(auto& tmp : node->get_parameter_list()) {
+        const std::string& str=tmp.str();
+        if (str=="me") {
+            die("\"me\" should not be a parameter", tmp->get_location());
+        }
+        regist_str(str);
+        switch(tmp->get_type()) {
+            case expr_type::ast_id:
+                gen(op_para, str_table[str], tmp->get_location().begin_line);
+                break;
+            case expr_type::ast_default:
+                calc_gen(tmp[0]);
+                gen(op_deft, str_table[str], tmp->get_location().begin_line);
+                break;
+            case expr_type::ast_dynamic:
+                gen(op_dyn, str_table[str], tmp->get_location().begin_line);
+                break;
+        }
+        add_sym(str);
+    }
+
+    code[newf].num=code.size()+1; // entry
+    usize jmp_ptr=code.size();
+    gen(op_jmp, 0, node->get_location().begin_line);
+
+    auto block = node->get_code_block();
+    // search symbols first, must use after loading parameters
+    // or the location of symbols will change and cause fatal error
+    find_symbol(block);
+    in_iterloop.push(0);
+    block_gen(block);
+    in_iterloop.pop();
+    code[lsize].num=local.back().size();
+    if (local.back().size()>=STACK_DEPTH) {
+        die("too many local variants: "+std::to_string(local.back().size()), block->get_location());
+    }
+    local.pop_back();
+
+    if (!block.size() || block.child().back()->get_type()!=ast_ret) {
+        gen(op_pnil, 0, block->get_location().begin_line);
+        gen(op_ret, 0, block->get_location().begin_line);
+    }
+    code[jmp_ptr].num=code.size();
+}
+
+void codegen::call_gen(call_expr* node) {
+    calc_gen(node->get_first());
+    if (code.back().op==op_callb) {
+        return;
+    }
+    for(auto i : node->get_calls()) {
+        switch(i->get_type()) {
+            case expr_type::ast_callh: call_hash_gen((call_hash*)i); break;
+            case expr_type::ast_callv: call_vec((call_vector*)i); break;
+            case expr_type::ast_callf: call_func((call_function*)i); break;
+        }
+    }
+}
+
+void codegen::call_id(identifier* node) {
+    const auto& name = node->get_location();
+    for(u32 i=0;builtin[i].name;++i) {
+        if (builtin[i].name==str) {
+            gen(op_callb, i, node->get_location().begin_line);
+            if (local.empty()) {
+                die("should warp native function in local scope", node->get_location());
+            }
+            return;
+        }
+    }
+    i32 index;
+    if ((index=local_find(str))>=0) {
+        gen(op_calll, index, node->get_location().begin_line);
+        return;
+    }
+    if ((index=upvalue_find(str))>=0) {
+        gen(op_upval, index, node->get_location().begin_line);
+        return;
+    }
+    if ((index=global_find(str))>=0) {
+        gen(op_callg, index, node->get_location().begin_line);
+        return;
+    }
+    die("undefined symbol \""+str+"\"", node->get_location());
+}
+
+void codegen::call_hash_gen(call_hash* node) {
+    regist_str(node.str());
+    gen(op_callh, str_table[node.str()], node->get_location().begin_line);
+}
+
+void codegen::call_vec(call_vector* node) {
+    // maybe this place can use callv-const if ast's first child is ast_num
+    if (node.size()==1 && node[0]->get_type()!=ast_subvec) {
+        calc_gen(node[0]);
+        gen(op_callv, 0, node[0]->get_location().begin_line);
+        return;
+    }
+    gen(op_slcbeg,0,node->get_location().begin_line);
+    for(auto& tmp:node.child()) {
+        if (tmp->get_type()!=ast_subvec) {
+            calc_gen(tmp);
+            gen(op_slc, 0, tmp->get_location().begin_line);
+        } else {
+            calc_gen(tmp[0]);
+            calc_gen(tmp[1]);
+            gen(op_slc2, 0, tmp->get_location().begin_line);
+        }
+    }
+    gen(op_slcend, 0, node->get_location().begin_line);
+}
+
+void codegen::call_func(call_function* node) {
+    if (!node.size()) {
+        gen(op_callfv, 0, node->get_location().begin_line);
+    } else if (node[0]->get_type()==expr_type::ast_pair) {
+        hash_gen(node);
+        gen(op_callfh, 0, node->get_location().begin_line);
+    } else {
+        for(auto& child:node.child()) {
+            calc_gen(child);
+        }
+        gen(op_callfv, node.size(), node->get_location().begin_line);
+    }
+}
+
+/* mcall should run after calc_gen because this operation may trigger gc.
+*  to avoid gc incorrectly collecting values that include the memory space(which will cause SIGSEGV),
+*  we must run ast[1] then we run ast[0] to get the memory space.
+*  at this time the value including the memory space can must be found alive.
+*  BUT in fact this method does not make much safety.
+*  so we use another way to avoid gc-caused SIGSEGV: reserve m-called value on stack.
+*  you could see the notes in `vm::opr_mcallv()`.
+*/
+void codegen::mcall(call_expr* node) {
+    if (!check_memory_reachable(node)) {
+        return;
+    }
+    if (node->get_type()==expr_type::ast_id) {
+        mcall_id(node);
+        return;
+    }
+    if (node.size()==1) { // foreach and forindex use call-id ast to get mcall
+        mcall_id(node[0]);
+        return;
+    }
+    calc_gen(node[0]);
+    for(usize i=1;i<node.size()-1;++i) {
+        const ast& tmp=node[i];
+        switch(tmp->get_type()) {
+            case expr_type::ast_callh:call_hash(tmp);break;
+            case expr_type::ast_callv:call_vec(tmp); break;
+            case expr_type::ast_callf:call_func(tmp);break;
+        }
+    }
+    const ast& tmp=node.child().back();
+    if (tmp->get_type()==expr_type::ast_callh) {
+        mcall_hash(tmp);
+    } else if (tmp->get_type()==expr_type::ast_callv) {
+        mcall_vec(tmp);
+    }
+}
+
+void codegen::mcall_id(identifier* node) {
+    const auto& name = node->get_name();
+    for(u32 i=0;builtin[i].name;++i) {
+        if (builtin[i].name==name) {
+            die("cannot modify native function", node->get_location());
+            return;
+        }
+    }
+    i32 index;
+    if ((index=local_find(name))>=0) {
+        gen(op_mcalll, index, node->get_location().begin_line);
+        return;
+    }
+    if ((index=upvalue_find(name))>=0) {
+        gen(op_mupval, index, node->get_location().begin_line);
+        return;
+    }
+    if ((index=global_find(name))>=0) {
+        gen(op_mcallg, index, node->get_location().begin_line);
+        return;
+    }
+    die("undefined symbol \"" + name + "\"", node->get_location());
+}
+
+void codegen::mcall_vec(call_vector* node) {
+    calc_gen(node[0]);
+    gen(op_mcallv, 0, node->get_location().begin_line);
+}
+
+void codegen::mcall_hash(call_hash* node) {
+    regist_str(node.str());
+    gen(op_mcallh, str_table[node.str()], node->get_location().begin_line);
+}
+
+void codegen::single_def(definition_expr* node) {
+    const auto& str = node->get_variable_name()->get_name();
+    calc_gen(node->get_value());
+    local.empty()?
+        gen(op_loadg, global_find(str), node->get_location().begin_line):
+        gen(op_loadl, local_find(str), node->get_location().begin_line);
+}
+
+void codegen::multi_def(definition_expr* node) {
+    auto& ids=node[0].child();
+    usize size=ids.size();
+    if (node[1]->get_type()==expr_type::ast_tuple) { // (var a,b,c)=(c,b,a);
+        auto& vals=node[1].child();
+        for(usize i=0;i<size;++i) {
+            // check node type, only identifier is allowed
+            if (ids[i]->get_type()!=ast_id) {
+                die("cannot call identifier in multi-definition", ids[i]->get_location());
+                continue;
+            }
+            calc_gen(vals[i]);
+            const std::string& str=ids[i].str();
+            local.empty()?
+                gen(op_loadg, global_find(str), ids[i]->get_location().begin_line):
+                gen(op_loadl, local_find(str), ids[i]->get_location().begin_line);
+        }
+    } else { // (var a,b,c)=[0,1,2];
+        calc_gen(node[1]);
+        for(usize i=0;i<size;++i) {
+            // check node type, only identifier is allowed
+            if (ids[i]->get_type()!=ast_id) {
+                die("cannot call identifier in multi-definition", ids[i]->get_location());
+                continue;
+            }
+            gen(op_callvi, i, node[1]->get_location().begin_line);
+            const std::string& str=ids[i].str();
+            local.empty()?
+                gen(op_loadg, global_find(str), ids[i]->get_location().begin_line):
+                gen(op_loadl, local_find(str), ids[i]->get_location().begin_line);
+        }
+        gen(op_pop, 0, node->get_location().begin_line);
+    }
+}
+
+void codegen::def_gen(definition_expr* node) {
+    if (node[0]->get_type()==expr_type::ast_id && node[1]->get_type()==expr_type::ast_tuple) {
+        die("cannot accept too many values", node[1]->get_location());
+    } else if (node[0]->get_type()==expr_type::ast_multi_id && node[1]->get_type()==expr_type::ast_tuple && node[0].size()<node[1].size()) {
+        die("lack values in multi-definition", node[1]->get_location());
+    } else if (node[0]->get_type()==expr_type::ast_multi_id && node[1]->get_type()==expr_type::ast_tuple && node[0].size()>node[1].size()) {
+        die("too many values in multi-definition", node[1]->get_location());
+    }
+    node[0]->get_type()==expr_type::ast_id?single_def(node):multi_def(node);
+}
+
+void codegen::multi_assign_gen(multi_assign* node) {
+    if (node[1]->get_type()==expr_type::ast_tuple && node[0].size()<node[1].size()) {
+        die("lack values in multi-assignment", node[1]->get_location());
+    } else if (node[1]->get_type()==expr_type::ast_tuple && node[0].size()>node[1].size()) {
+        die("too many values in multi-assignment", node[1]->get_location());
+    }
+    i32 size=node[0].size();
+    if (node[1]->get_type()==expr_type::ast_tuple) {
+        for(i32 i=size-1;i>=0;--i) {
+            calc_gen(node[1][i]);
+        }
+        for(i32 i=0;i<size;++i) {
+            mcall(node[0][i]);
+            // multi assign user loadl and loadg to avoid meq's stack--
+            // and this operation changes local and global value directly
+            if (code.back().op==op_mcalll) {
+                code.back().op=op_loadl;
+            } else if (code.back().op==op_mupval) {
+                code.back().op=op_loadu;
+            } else if (code.back().op==op_mcallg) {
+                code.back().op=op_loadg;
+            } else {
+                gen(op_meq, 1, node[0][i]->get_location().begin_line);
+            }
+        }
+    } else {
+        calc_gen(node[1]);
+        for(i32 i=0;i<size;++i) {
+            gen(op_callvi, i, node[1]->get_location().begin_line);
+            // multi assign user loadl and loadg to avoid meq's stack--
+            // and this operation changes local and global value directly
+            mcall(node[0][i]);
+            if (code.back().op==op_mcalll) {
+                code.back().op=op_loadl;
+            } else if (code.back().op==op_mupval) {
+                code.back().op=op_loadu;
+            } else if (code.back().op==op_mcallg) {
+                code.back().op=op_loadg;
+            } else {
+                gen(op_meq, 1, node[0][i]->get_location().begin_line);
+            }
+        }
+        gen(op_pop, 0, node->get_location().begin_line);
+    }
+}
+
+void codegen::cond_gen(condition_expr* node) {
+    std::vector<usize> jmp_label;
+    for(auto& tmp:node.child()) {
+        if (tmp->get_type()==expr_type::ast_if || tmp->get_type()==expr_type::ast_elsif) {
+            calc_gen(tmp[0]);
+            usize ptr=code.size();
+            gen(op_jf, 0, tmp->get_location().begin_line);
+            block_gen(tmp[1]);
+            // without 'else' the last condition doesn't need to jmp
+            if (&tmp!=&node.child().back()) {
+                jmp_label.push_back(code.size());
+                gen(op_jmp, 0, tmp->get_location().begin_line);
+            }
+            code[ptr].num=code.size();
+        } else {
+            block_gen(tmp[0]);
+            break;
+        }
+    }
+    for(auto i:jmp_label) {
+        code[i].num=code.size();
+    }
+}
+
+void codegen::loop_gen(expr* node) {
+    continue_ptr.push_front({});
+    break_ptr.push_front({});
+    switch(node->get_type()) {
+        case expr_type::ast_while:   while_gen(node);   break;
+        case expr_type::ast_for:     for_gen(node);     break;
+        case expr_type::ast_forindex:forindex_gen(node);break;
+        case expr_type::ast_foreach: foreach_gen(node); break;
+    }
+}
+
+void codegen::load_continue_break(i32 continue_place,i32 break_place) {
+    for(auto i:continue_ptr.front()) {
+        code[i].num=continue_place;
+    }
+    for(auto i:break_ptr.front()) {
+        code[i].num=break_place;
+    }
+    continue_ptr.pop_front();
+    break_ptr.pop_front();
+}
+
+void codegen::while_gen(while_expr* node) {
+    usize loop_ptr=code.size();
+    calc_gen(node[0]);
+    usize condition_ptr=code.size();
+    gen(op_jf, 0, node[0]->get_location().begin_line);
+
+    block_gen(node[1]);
+    gen(op_jmp, loop_ptr, node[1]->get_location().begin_line);
+    code[condition_ptr].num=code.size();
+    load_continue_break(code.size()-1, code.size());
+}
+
+void codegen::for_gen(for_expr* node) {
+    expr_gen(node[0]);
+    usize jmp_place=code.size();
+    if (node[1]->get_type()==expr_type::ast_null) {
+        gen(op_pnum, num_table[1], node[1]->get_location().begin_line);
+    } else {
+        calc_gen(node[1]);
+    }
+    usize label_exit=code.size();
+    gen(op_jf, 0, node[1]->get_location().begin_line);
+
+    block_gen(node[3]);
+    usize continue_place=code.size();
+    expr_gen(node[2]);
+    gen(op_jmp, jmp_place, node[2]->get_location().begin_line);
+    code[label_exit].num=code.size();
+
+    load_continue_break(continue_place, code.size());
+}
+
+void codegen::expr_gen(expr* node) {
+    switch(node->get_type()) {
+        case expr_type::ast_null:break;
+        case expr_type::ast_def:def_gen(node);break;
+        case expr_type::ast_multi_assign:multi_assign_gen(node);break;
+        case expr_type::ast_addeq:case expr_type::ast_subeq:
+        case expr_type::ast_multeq:case expr_type::ast_diveq:case expr_type::ast_lnkeq:
+        case expr_type::ast_btandeq:case expr_type::ast_btoreq:case expr_type::ast_btxoreq:
+            calc_gen(node);
+            if (op_addeq<=code.back().op && code.back().op<=op_btxoreq) {
+                code.back().num=1;
+            } else if (op_addeqc<=code.back().op && code.back().op<=op_lnkeqc) {
+                code.back().op=code.back().op-op_addeqc+op_addecp;
+            } else {
+                gen(op_pop, 0, node->get_location().begin_line);
+            }
+            break;
+        case expr_type::ast_nil:case expr_type::ast_num:case expr_type::ast_str:case expr_type::ast_bool:break;
+        case expr_type::ast_vec:case expr_type::ast_hash:case expr_type::ast_func:case expr_type::ast_call:
+        case expr_type::ast_neg:case expr_type::ast_lnot:case expr_type::ast_bnot:
+        case expr_type::ast_bitor:case expr_type::ast_bitxor:case expr_type::ast_bitand:
+        case expr_type::ast_add:case expr_type::ast_sub:case expr_type::ast_mult:case expr_type::ast_div:case expr_type::ast_link:
+        case expr_type::ast_cmpeq:case expr_type::ast_neq:
+        case expr_type::ast_leq:case expr_type::ast_less:
+        case expr_type::ast_geq:case expr_type::ast_grt:
+        case expr_type::ast_or:case expr_type::ast_and:
+        case expr_type::ast_trino:
+            calc_gen(node);
+            gen(op_pop, 0, node->get_location().begin_line);
+            break;
+        case expr_type::ast_equal:
+            if (node[0]->get_type()==expr_type::ast_id) {
+                calc_gen(node[1]);
+                mcall_id(node[0]);
+                // only the first mcall_id can use load
+                if (code.back().op==op_mcalll) {
+                    code.back().op=op_loadl;
+                } else if (code.back().op==op_mupval) {
+                    code.back().op=op_loadu;
+                } else {
+                    code.back().op=op_loadg;
+                }
+            } else {
+                calc_gen(node);
+                if (code.back().op==op_meq) {
+                    code.back().num=1;
+                } else {
+                    gen(op_pop, 0, node->get_location().begin_line);
+                }
+            }
+            break;
+    }
+}
+
+void codegen::forindex_gen(forei_expr* node) {
+    calc_gen(node[1]);
+    gen(op_cnt, 0, node[1]->get_location().begin_line);
+    usize ptr=code.size();
+    gen(op_findex, 0, node->get_location().begin_line);
+    if (node[0]->get_type()==expr_type::ast_iter) { // define a new iterator
+        const std::string& str=node[0][0].str();
+        local.empty()?
+            gen(op_loadg, global_find(str), node[0][0]->get_location().begin_line):
+            gen(op_loadl, local_find(str), node[0][0]->get_location().begin_line);
+    } else { // use exist variable as the iterator
+        mcall(node[0]);
+        if (code.back().op==op_mcallg) {
+            code.back().op=op_loadg;
+        } else if (code.back().op==op_mcalll) {
+            code.back().op=op_loadl;
+        } else if (code.back().op==op_mupval) {
+            code.back().op=op_loadu;
+        } else {
+            gen(op_meq, 1, node[0]->get_location().begin_line);
+        }
+    }
+    ++in_iterloop.top();
+    block_gen(node[2]);
+    --in_iterloop.top();
+    gen(op_jmp, ptr, node->get_location().begin_line);
+    code[ptr].num=code.size();
+    load_continue_break(code.size()-1, code.size());
+    gen(op_pop, 0, node[1]->get_location().begin_line);// pop vector
+    gen(op_pop, 0, node->get_location().begin_line);// pop iterator
+}
+
+void codegen::foreach_gen(forei_expr* node) {
+    calc_gen(node[1]);
+    gen(op_cnt, 0, node->get_location().begin_line);
+    usize ptr=code.size();
+    gen(op_feach, 0, node->get_location().begin_line);
+    if (node[0]->get_type()==expr_type::ast_iter) { // define a new iterator
+        const std::string& str=node[0][0].str();
+        local.empty()?
+            gen(op_loadg, global_find(str), node[0][0]->get_location().begin_line):
+            gen(op_loadl, local_find(str), node[0][0]->get_location().begin_line);
+    } else { // use exist variable as the iterator
+        mcall(node[0]);
+        if (code.back().op==op_mcallg) {
+            code.back().op=op_loadg;
+        } else if (code.back().op==op_mcalll) {
+            code.back().op=op_loadl;
+        } else if (code.back().op==op_mupval) {
+            code.back().op=op_loadu;
+        } else {
+            gen(op_meq, 1, node[0]->get_location().begin_line);
+        }
+    }
+    ++in_iterloop.top();
+    block_gen(node[2]);
+    --in_iterloop.top();
+    gen(op_jmp, ptr, node->get_location().begin_line);
+    code[ptr].num=code.size();
+    load_continue_break(code.size()-1, code.size());
+    gen(op_pop, 0, node[1]->get_location().begin_line);// pop vector
+    gen(op_pop, 0, node->get_location().begin_line);// pop iterator
+}
+
+void codegen::or_gen(binary_operator* node) {
+    calc_gen(node->get_left());
+    usize l1 = code.size();
+    gen(op_jt, 0, node->get_left()->get_location().begin_line);
+
+    gen(op_pop, 0, node->get_left()->get_location().begin_line);
+    calc_gen(node->get_right());
+    usize l2=code.size();
+    gen(op_jt, 0, node->get_right()->get_location().begin_line);
+
+    gen(op_pop, 0, node->get_right()->get_location().begin_line);
+    gen(op_pnil, 0, node->get_right()->get_location().begin_line);
+
+    code[l1].num = code[l2].num = code.size();
+}
+
+void codegen::and_gen(binary_operator* node) {
+    calc_gen(node->get_left());
+    gen(op_jt, code.size()+2, node->get_left()->get_location().begin_line);
+
+    usize lfalse=code.size();
+    gen(op_jmp, 0, node->get_left()->get_location().begin_line);
+    gen(op_pop, 0, node->get_right()->get_location().begin_line);// jt jumps here
+
+    calc_gen(node->get_right());
+    gen(op_jt, code.size()+3, node->get_right()->get_location().begin_line);
+
+    code[lfalse].num=code.size();
+    gen(op_pop, 0, node->get_right()->get_location().begin_line);
+    gen(op_pnil, 0, node->get_right()->get_location().begin_line);
+    // jt jumps here
+}
+
+void codegen::trino_gen(ternary_operator* node) {
+    calc_gen(node->get_condition());
+    usize lfalse=code.size();
+    gen(op_jf, 0, node->get_condition()->get_location().begin_line);
+    calc_gen(node->get_left());
+    usize lexit=code.size();
+    gen(op_jmp, 0, node->get_left()->get_location().begin_line);
+    code[lfalse].num=code.size();
+    calc_gen(node->get_right());
+    code[lexit].num=code.size();
+}
+
+void codegen::calc_gen(expr* node) {
+    switch(node->get_type()) {
+        case expr_type::ast_nil:  gen(op_pnil,0,node->get_location().begin_line);break;
+        case expr_type::ast_num:  num_gen(node);  break;
+        case expr_type::ast_str:  str_gen(node);  break;
+        case expr_type::ast_id:   call_id(node);  break;
+        case expr_type::ast_bool: bool_gen(node); break;
+        case expr_type::ast_vec:  vec_gen(node);  break;
+        case expr_type::ast_hash: hash_gen(node); break;
+        case expr_type::ast_func: func_gen(node); break;
+        case expr_type::ast_call: call_gen(node); break;
+        case expr_type::ast_equal:
+            calc_gen(node[1]);
+            mcall(node[0]);
+            gen(op_meq, 0, node->get_location().begin_line);
+            break;
+        // ast_addeq(22)~ast_lnkeq(26) op_addeq(23)~op_lnkeq(27)
+        case expr_type::ast_addeq:case expr_type::ast_subeq:case expr_type::ast_multeq:case expr_type::ast_diveq:
+            if (node[1]->get_type()!=ast_num) {
+                calc_gen(node[1]);
+            }
+            mcall(node[0]);
+            if (node[1]->get_type()!=ast_num) {
+                gen(node->get_type()-ast_addeq+op_addeq, 0, node->get_location().begin_line);
+            } else {
+                regist_num(node[1].num());
+                gen(node->get_type()-ast_addeq+op_addeqc, num_table[node[1].num()], node->get_location().begin_line);
+            }
+            break;
+        case expr_type::ast_lnkeq:
+            if (node[1]->get_type()!=ast_str) {
+                calc_gen(node[1]);
+            } else {
+                regist_str(node[1].str());
+            }
+            mcall(node[0]);
+            if (node[1]->get_type()!=ast_str) {
+                gen(op_lnkeq, 0, node->get_location().begin_line);
+            } else {
+                gen(op_lnkeqc, str_table[node[1].str()], node->get_location().begin_line);
+            }
+            break;
+        case expr_type::ast_btandeq:case expr_type::ast_btoreq:case expr_type::ast_btxoreq:
+            calc_gen(node[1]);
+            mcall(node[0]);
+            gen(node->get_type()-ast_btandeq+op_btandeq, 0, node->get_location().begin_line);
+            break;
+        case expr_type::ast_or:or_gen(node);break;
+        case expr_type::ast_and:and_gen(node);break;
+        // ast_add(33)~ast_link(37) op_add(18)~op_lnk(22)
+        case expr_type::ast_add:case expr_type::ast_sub:case expr_type::ast_mult:case expr_type::ast_div:
+            calc_gen(node[0]);
+            if (node[1]->get_type()!=ast_num) {
+                calc_gen(node[1]);
+                gen(node->get_type()-ast_add+op_add, 0, node->get_location().begin_line);
+            } else {
+                regist_num(node[1].num());
+                gen(node->get_type()-ast_add+op_addc, num_table[node[1].num()], node->get_location().begin_line);
+            }
+            break;
+        case expr_type::ast_link:
+            calc_gen(node[0]);
+            if (node[1]->get_type()!=ast_str) {
+                calc_gen(node[1]);
+                gen(op_lnk, 0, node->get_location().begin_line);
+            } else {
+                regist_str(node[1].str());
+                gen(op_lnkc, str_table[node[1].str()], node->get_location().begin_line);
+            }
+            break;
+        // ast_cmpeq(27)~ast_geq(32) op_eq(29)~op_geq(34)
+        case expr_type::ast_cmpeq:case expr_type::ast_neq:
+            calc_gen(node[0]);
+            calc_gen(node[1]);
+            gen(node->get_type()-ast_cmpeq+op_eq, 0, node->get_location().begin_line);
+            break;
+        case expr_type::ast_less:case expr_type::ast_leq:case expr_type::ast_grt:case expr_type::ast_geq:
+            calc_gen(node[0]);
+            if (node[1]->get_type()!=ast_num) {
+                calc_gen(node[1]);
+                gen(node->get_type()-ast_less+op_less, 0, node->get_location().begin_line);
+            } else {
+                regist_num(node[1].num());
+                gen(node->get_type()-ast_less+op_lessc, num_table[node[1].num()], node->get_location().begin_line);
+            }
+            break;
+        case expr_type::ast_trino:trino_gen(node);break;
+        case expr_type::ast_neg:
+            calc_gen(node[0]);
+            gen(op_usub, 0, node->get_location().begin_line);
+            break;
+        case expr_type::ast_lnot:
+            calc_gen(node[0]);
+            gen(op_lnot, 0, node->get_location().begin_line);
+            break;
+        case expr_type::ast_bnot:
+            calc_gen(node[0]);
+            gen(op_bnot, 0, node->get_location().begin_line);
+            break;
+        case expr_type::ast_bitor:
+            calc_gen(node[0]);
+            calc_gen(node[1]);
+            gen(op_btor, 0, node->get_location().begin_line);
+            break;
+        case expr_type::ast_bitxor:
+            calc_gen(node[0]);
+            calc_gen(node[1]);
+            gen(op_btxor, 0, node->get_location().begin_line);
+            break;
+        case expr_type::ast_bitand:
+            calc_gen(node[0]);
+            calc_gen(node[1]);
+            gen(op_btand, 0, node->get_location().begin_line);
+            break;
+        case expr_type::ast_def:
+            single_def(node);
+            call_id(node[0]);
+            break;
+    }
+}
+
+void codegen::block_gen(code_block* node) {
+    for(auto& tmp:node.child()) {
+        switch(tmp->get_type()) {
+            case expr_type::ast_null:break;
+            case expr_type::ast_id:check_id_exist(tmp);break;
+            case expr_type::ast_nil:case expr_type::ast_num:case expr_type::ast_str:case expr_type::ast_bool:break;
+            case expr_type::ast_file:fileindex=tmp.num();break; // special node type in main block
+            case expr_type::ast_cond:cond_gen(tmp);break;
+            case expr_type::ast_continue:
+                continue_ptr.front().push_back(code.size());
+                gen(op_jmp, 0, tmp->get_location().begin_line);
+                break;
+            case expr_type::ast_break:
+                break_ptr.front().push_back(code.size());
+                gen(op_jmp, 0, tmp->get_location().begin_line);
+                break;
+            case expr_type::ast_while:
+            case expr_type::ast_for:
+            case expr_type::ast_forindex:
+            case expr_type::ast_foreach:loop_gen(tmp);break;
+            case expr_type::ast_equal:
+            case expr_type::ast_addeq:case expr_type::ast_subeq:
+            case expr_type::ast_multeq:case expr_type::ast_diveq:case expr_type::ast_lnkeq:
+            case expr_type::ast_btandeq:case expr_type::ast_btoreq:case expr_type::ast_btxoreq:
+            case expr_type::ast_vec:case expr_type::ast_hash:case expr_type::ast_func:case expr_type::ast_call:
+            case expr_type::ast_neg:case expr_type::ast_lnot:case expr_type::ast_bnot:
+            case expr_type::ast_bitor:case expr_type::ast_bitxor:case expr_type::ast_bitand:
+            case expr_type::ast_add:case expr_type::ast_sub:case expr_type::ast_mult:case expr_type::ast_div:case expr_type::ast_link:
+            case expr_type::ast_cmpeq:case expr_type::ast_neq:
+            case expr_type::ast_leq:case expr_type::ast_less:
+            case expr_type::ast_geq:case expr_type::ast_grt:
+            case expr_type::ast_or:
+            case expr_type::ast_and:
+            case expr_type::ast_trino:
+            case expr_type::ast_def:
+            case expr_type::ast_multi_assign:expr_gen(tmp);break;
+            case expr_type::ast_ret:ret_gen(tmp);break;
+        }
+    }
+}
+
+void codegen::ret_gen(const ast& node) {
+    for(u32 i=0;i<in_iterloop.top();++i) {
+        gen(op_pop, 0, node->get_location().begin_line);
+        gen(op_pop, 0, node->get_location().begin_line);
+    }
+    if (node.size()) {
+        calc_gen(node[0]);
+    } else {
+        gen(op_pnil, 0, node->get_location().begin_line);
+    }
+    gen(op_ret, 0, node->get_location().begin_line);
+}
+
+const error& codegen::compile(const parse& parse, const linker& import) {
+    fileindex=0;
+    file=import.filelist().data();
+    in_iterloop.push(0);
+    find_symbol(parse.tree()); // search symbols first
+    gen(op_intg, global.size(), 0);
+    block_gen(parse.tree()); // generate main block
+    gen(op_exit, 0, 0);
+
+    // size out of bound check
+    if (num_res.size()>0xffffff) {
+        err.load(file[0]); // load main execute file
+        err.err("code", "too many constant numbers: "+std::to_string(num_res.size()));
+    }
+    if (str_res.size()>0xffffff) {
+        err.load(file[0]); // load main execute file
+        err.err("code", "too many constant strings: "+std::to_string(str_res.size()));
+    }
+    if (global.size()>=STACK_DEPTH) {
+        err.load(file[0]); // load main execute file
+        err.err("code", "too many global variants: "+std::to_string(global.size()));
+    }
+    if (code.size()>0xffffff) {
+        err.load(file[0]); // load main execute file
+        err.err("code", "bytecode size overflow: "+std::to_string(code.size()));
+    }
+    return err;
+}
+
+void codegen::print() {
+    // func end stack, reserved for code print
+    std::stack<u32> fbstk;
+    std::stack<u32> festk;
+
+    // print const numbers
+    for(auto& num:num_res) {
+        std::cout<<"  .number "<<num<<"\n";
+    }
+
+    // print const strings
+    for(auto& str:str_res) {
+        std::cout<<"  .symbol \""<<rawstr(str)<<"\"\n";
+    }
+
+    // print code
+    std::cout<<"\n";
+    codestream::set(num_res.data(), str_res.data());
+    for(u32 i=0;i<code.size();++i) {
+        // print opcode index, opcode name, opcode immediate number
+        const opcode& c=code[i];
+        if (!festk.empty() && i==festk.top()) {
+            std::cout<<std::hex<<"<0x"<<fbstk.top()<<std::dec<<">;\n";
+            // avoid two empty lines
+            if (c.op!=op_newf) {
+                std::cout<<"\n";
+            }
+            fbstk.pop();
+            festk.pop();
+        }
+
+        // get function begin index and end index
+        if (c.op==op_newf) {
+            std::cout<<std::hex<<"\nfunc <0x"<<i<<std::dec<<">:\n";
+            for(u32 j=i;j<code.size();++j) {
+                if (code[j].op==op_jmp) {
+                    fbstk.push(i);
+                    festk.push(code[j].num);
+                    break;
+                }
+            }
+        }
+
+        // output bytecode
+        std::cout<<"  "<<codestream(c,i)<<"\n";
+    }
+}
diff --git a/ast/nasal_new_codegen.h b/ast/nasal_new_codegen.h
index 7b9637e..28c2817 100644
--- a/ast/nasal_new_codegen.h
+++ b/ast/nasal_new_codegen.h
@@ -1 +1,101 @@
-#pragma once
\ No newline at end of file
+#pragma once
+
+#include "nasal_new_err.h"
+#include "nasal_new_builtin.h"
+#include "nasal_new_opcode.h"
+#include "nasal_new_ast.h"
+#include "ast_visitor.h"
+#include "symbol_finder.h"
+#include "nasal_new_parse.h"
+#include "nasal_new_import.h"
+
+#include <iomanip>
+#include <list>
+#include <stack>
+#include <unordered_map>
+
+#ifdef _MSC_VER
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#endif
+
+class codegen {
+private:
+    u16 fileindex;
+    error& err;
+    const std::string* file;
+    std::stack<u32> in_iterloop;
+    std::unordered_map<f64,u32> num_table;
+    std::unordered_map<std::string,u32> str_table;
+    std::vector<f64> num_res;
+    std::vector<std::string> str_res;
+    std::vector<opcode> code;
+    std::list<std::vector<i32>> continue_ptr;
+    std::list<std::vector<i32>> break_ptr;
+
+    // symbol table
+    // global : max STACK_DEPTH-1 values
+    std::unordered_map<std::string,i32> global;
+    // local  : max 32768 upvalues 65536 values
+    // but in fact local scope also has less than STACK_DEPTH value
+    std::list<std::unordered_map<std::string,i32>> local;
+
+    bool check_memory_reachable(call_expr*);
+    void check_id_exist(identifier*);
+    
+    void die(const std::string& info, const span& loc) {
+        err.err("code", loc, info);
+    }
+
+    void regist_num(const f64);
+    void regist_str(const std::string&);
+    void find_symbol(code_block*);
+    void add_sym(const std::string&);
+    i32 local_find(const std::string&);
+    i32 global_find(const std::string&);
+    i32 upvalue_find(const std::string&);
+
+    void gen(u8, u32, u32);
+
+    void num_gen(number_literal*);
+    void str_gen(string_literal*);
+    void bool_gen(bool_literal*);
+    void vec_gen(vector_expr*);
+    void hash_gen(hash_expr*);
+    void func_gen(function*);
+    void call_gen(call_expr*);
+    void call_id(identifier*);
+    void call_hash_gen(call_hash*);
+    void call_vec(call_vector*);
+    void call_func(call_function*);
+    void mcall(call_expr*);
+    void mcall_id(identifier*);
+    void mcall_vec(call_vector*);
+    void mcall_hash(call_hash*);
+    void multi_def(definition_expr*);
+    void single_def(definition_expr*);
+    void def_gen(definition_expr*);
+    void multi_assign_gen(multi_assign*);
+    void cond_gen(condition_expr*);
+    void loop_gen(expr*);
+    void load_continue_break(i32, i32);
+    void while_gen(while_expr*);
+    void for_gen(for_expr*);
+    void expr_gen(expr*);
+    void forindex_gen(forei_expr*);
+    void foreach_gen(forei_expr*);
+    void or_gen(binary_operator*);
+    void and_gen(binary_operator*);
+    void trino_gen(ternary_operator*);
+    void calc_gen(expr*);
+    void block_gen(code_block*);
+    void ret_gen(return_expr*);
+
+public:
+    codegen(error& e): fileindex(0), err(e), file(nullptr) {}
+    const error& compile(const parse&, const linker&);
+    void print();
+    const std::vector<std::string>& strs() const {return str_res;}
+    const std::vector<f64>& nums() const {return num_res;}
+    const std::vector<opcode>& codes() const {return code;}
+};
diff --git a/ast/nasal_new_main.cpp b/ast/nasal_new_main.cpp
index 75fbf95..1a2aeaf 100644
--- a/ast/nasal_new_main.cpp
+++ b/ast/nasal_new_main.cpp
@@ -6,6 +6,7 @@
 #include "nasal_new_import.h"
 #include "ast_visitor.h"
 #include "ast_dumper.h"
+#include "symbol_finder.h"
 #include "optimizer.h"
 
 #include <unordered_map>
@@ -102,6 +103,11 @@ void execute(
     opt->do_optimization(parse.tree());
     delete opt;
 
+    auto finder = new symbol_finder;
+    for(const auto& symbol : finder->do_find(parse.tree())) {
+        std::cout << symbol << std::endl;
+    }
+
     // code generator gets parser's ast and import file list to generate code
     // gen.compile(parse, ld).chkerr();
     // if (cmd&VM_CODE) {
diff --git a/ast/nasal_new_opcode.cpp b/ast/nasal_new_opcode.cpp
index bbe9ef5..6004308 100644
--- a/ast/nasal_new_opcode.cpp
+++ b/ast/nasal_new_opcode.cpp
@@ -3,11 +3,11 @@
 void codestream::set(
     const f64* numbuff,
     const std::string* strbuff,
-    const std::string* filelist=nullptr
+    const std::string* filelist
 ) {
-    nums=numbuff;
-    strs=strbuff;
-    files=filelist;
+    nums = numbuff;
+    strs = strbuff;
+    files = filelist;
 }
 
 void codestream::dump(std::ostream& out) const {
diff --git a/ast/nasal_new_opcode.h b/ast/nasal_new_opcode.h
index e2428f6..c34d831 100644
--- a/ast/nasal_new_opcode.h
+++ b/ast/nasal_new_opcode.h
@@ -139,7 +139,7 @@ private:
     inline static const std::string* files = nullptr;
 public:
     codestream(const opcode& c, const u32 i): code(c), index(i) {}
-    static void set(const f64*, const std::string*, const std::string*);
+    static void set(const f64*, const std::string*, const std::string* filelist = nullptr);
     void dump(std::ostream&) const;
 };
 
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index 5660f36..c4398e0 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -774,8 +774,7 @@ multi_identifier* parse::multi_id() {
     auto node = new multi_identifier(toks[ptr].loc);
     while(!lookahead(tok::eof)) {
         // only identifier is allowed here
-        // but we check it at codegen stage
-        node->add_var(calc());
+        node->add_var(id());
         if (lookahead(tok::comma)) {
             match(tok::comma);
         } else if (lookahead(tok::id)) { // first set of identifier
diff --git a/ast/symbol_finder.cpp b/ast/symbol_finder.cpp
new file mode 100644
index 0000000..7b2cdf2
--- /dev/null
+++ b/ast/symbol_finder.cpp
@@ -0,0 +1,29 @@
+#include "symbol_finder.h"
+
+bool symbol_finder::visit_definition_expr(definition_expr* node) {
+    if (node->get_variable_name()) {
+        symbols.push_back(node->get_variable_name()->get_name());
+    } else {
+        for(auto i : node->get_variables()->get_variables()) {
+            symbols.push_back(i->get_name());
+        }
+    }
+    node->get_value()->accept(this);
+    return true;
+}
+
+bool symbol_finder::visit_function(function* node) {
+    return true;
+}
+
+bool symbol_finder::visit_iter_expr(iter_expr* node) {
+    if (node->get_name()) {
+        symbols.push_back(node->get_name()->get_name());
+    }
+}
+
+const std::vector<std::string>& symbol_finder::do_find(code_block* root) {
+    symbols.clear();
+    root->accept(this);
+    return symbols;
+}
\ No newline at end of file
diff --git a/ast/symbol_finder.h b/ast/symbol_finder.h
new file mode 100644
index 0000000..7444644
--- /dev/null
+++ b/ast/symbol_finder.h
@@ -0,0 +1,19 @@
+#pragma once
+
+#include "nasal_new_ast.h"
+#include "ast_visitor.h"
+
+#include <cstring>
+#include <sstream>
+#include <vector>
+
+class symbol_finder:public ast_visitor {
+private:
+    std::vector<std::string> symbols;
+
+public:
+    bool visit_definition_expr(definition_expr*) override;
+    bool visit_function(function*) override;
+    bool visit_iter_expr(iter_expr*) override;
+    const std::vector<std::string>& do_find(code_block*);
+};
\ No newline at end of file
diff --git a/makefile b/makefile
index 89209bb..e8e9bbe 100644
--- a/makefile
+++ b/makefile
@@ -85,6 +85,7 @@ NASAL_NEW_AST=\
 	nasal_new_opcode.o\
 	nasal_new_parse.o\
 	optimizer.o\
+	symbol_finder.o\
 	ast_visitor.o\
 	ast_dumper.o\
 	nasal_new_main.o
@@ -119,7 +120,7 @@ nasal_new_builtin.o: ast/nasal_new_builtin.h ast/nasal_new_builtin.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_builtin.cpp -fno-exceptions -fPIC -o nasal_new_builtin.o -I .
 
 nasal_new_codegen.o: ast/nasal_new_codegen.h ast/nasal_new_codegen.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.o -I .
+#	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.o -I .
 
 nasal_new_opcode.o: ast/nasal_new_opcode.h ast/nasal_new_opcode.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_opcode.cpp -fno-exceptions -fPIC -o nasal_new_opcode.o -I .
@@ -130,6 +131,9 @@ nasal_new_parse.o: ast/nasal_new_parse.h ast/nasal_new_parse.cpp ast/nasal_new_a
 optimizer.o: ast/optimizer.h ast/optimizer.cpp ast/nasal_new_ast.h
 	$(CXX) -std=$(STD) -c -O3 ast/optimizer.cpp -fno-exceptions -fPIC -o optimizer.o -I .
 
+symbol_finder.o: ast/symbol_finder.h ast/symbol_finder.cpp ast/nasal_new_ast.h
+	$(CXX) -std=$(STD) -c -O3 ast/symbol_finder.cpp -fno-exceptions -fPIC -o symbol_finder.o -I .
+
 ast_visitor.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_visitor.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .
 

From 8e4e4bfe8932d29da8b17b6a9441f9fc1405c034 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Fri, 30 Jun 2023 00:25:58 +0800
Subject: [PATCH 23/34] :sparkles: update

---
 ast/ast_dumper.cpp        |   2 +-
 ast/nasal_new_ast.h       |   4 +-
 ast/nasal_new_codegen.cpp | 368 +++++++++++++++++++-------------------
 ast/nasal_new_codegen.h   |   2 +-
 ast/nasal_new_gc.h        |  11 +-
 ast/nasal_new_header.h    |   2 +-
 ast/nasal_new_parse.cpp   |   4 +-
 ast/optimizer.cpp         |   4 +-
 nasal_codegen.h           |  12 +-
 9 files changed, 206 insertions(+), 203 deletions(-)

diff --git a/ast/ast_dumper.cpp b/ast/ast_dumper.cpp
index 21c7ff6..c6497d4 100644
--- a/ast/ast_dumper.cpp
+++ b/ast/ast_dumper.cpp
@@ -379,7 +379,7 @@ bool ast_dumper::visit_iter_expr(iter_expr* node) {
 
 bool ast_dumper::visit_forei_expr(forei_expr* node) {
     dump_indent();
-    if (node->get_type()==forei_expr::forei_loop_type::foreach) {
+    if (node->get_loop_type()==forei_expr::forei_loop_type::foreach) {
         std::cout << "foreach";
     } else {
         std::cout << "forindex";
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index 50e816b..ce96d92 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -583,11 +583,11 @@ public:
         type(forei_loop_type::foreach), iterator(nullptr),
         vector_node(nullptr), block(nullptr) {}
     ~forei_expr();
-    void set_type(forei_loop_type ft) {type = ft;}
+    void set_loop_type(forei_loop_type ft) {type = ft;}
     void set_iterator(iter_expr* node) {iterator = node;}
     void set_value(expr* node) {vector_node = node;}
     void set_code_block(code_block* node) {block = node;}
-    forei_loop_type get_type() const {return type;}
+    forei_loop_type get_loop_type() const {return type;}
     iter_expr* get_iterator() {return iterator;}
     expr* get_value() {return vector_node;}
     code_block* get_code_block() {return block;}
diff --git a/ast/nasal_new_codegen.cpp b/ast/nasal_new_codegen.cpp
index 35ffeed..9f4acce 100644
--- a/ast/nasal_new_codegen.cpp
+++ b/ast/nasal_new_codegen.cpp
@@ -1,17 +1,19 @@
 #include "nasal_new_codegen.h"
 
 bool codegen::check_memory_reachable(call_expr* node) {
-    if (node->get_type()==expr_type::ast_call) {
-        const ast& tmp=node.child().back();
+    if (node->get_first()->get_type()==expr_type::ast_call) {
+        const auto tmp=node->get_calls().back();
         if (tmp->get_type()==expr_type::ast_callf) {
             die("bad left-value with function call", node->get_location());
             return false;
         }
-        if (tmp->get_type()==expr_type::ast_callv && (tmp.size()==0 || tmp.size()>1 || tmp[0]->get_type()==expr_type::ast_subvec)) {
+        if (tmp->get_type()==expr_type::ast_callv &&
+            (((call_vector*)tmp)->get_slices().size()!=1 ||
+            ((call_vector*)tmp)->get_slices()[0]->get_end())) {
             die("bad left-value with subvec", node->get_location());
             return false;
         }
-    } else if (node->get_type()!=ast_id) {
+    } else if (node->get_first()->get_type()!=expr_type::ast_id) {
         die("bad left-value", node->get_location());
         return false;
     }
@@ -186,20 +188,20 @@ void codegen::func_gen(function* node) {
 
     // generate parameter list
     for(auto& tmp : node->get_parameter_list()) {
-        const std::string& str=tmp.str();
+        const auto& str = tmp->get_parameter_name();
         if (str=="me") {
             die("\"me\" should not be a parameter", tmp->get_location());
         }
         regist_str(str);
-        switch(tmp->get_type()) {
-            case expr_type::ast_id:
+        switch(tmp->get_parameter_type()) {
+            case parameter::param_type::normal_parameter:
                 gen(op_para, str_table[str], tmp->get_location().begin_line);
                 break;
-            case expr_type::ast_default:
-                calc_gen(tmp[0]);
+            case parameter::param_type::default_parameter:
+                calc_gen(tmp->get_default_value());
                 gen(op_deft, str_table[str], tmp->get_location().begin_line);
                 break;
-            case expr_type::ast_dynamic:
+            case parameter::param_type::dynamic_parameter:
                 gen(op_dyn, str_table[str], tmp->get_location().begin_line);
                 break;
         }
@@ -223,7 +225,8 @@ void codegen::func_gen(function* node) {
     }
     local.pop_back();
 
-    if (!block.size() || block.child().back()->get_type()!=ast_ret) {
+    if (!block->get_expressions().size() ||
+        block->get_expressions().back()->get_type()!=expr_type::ast_ret) {
         gen(op_pnil, 0, block->get_location().begin_line);
         gen(op_ret, 0, block->get_location().begin_line);
     }
@@ -245,9 +248,9 @@ void codegen::call_gen(call_expr* node) {
 }
 
 void codegen::call_id(identifier* node) {
-    const auto& name = node->get_location();
-    for(u32 i=0;builtin[i].name;++i) {
-        if (builtin[i].name==str) {
+    const auto& name = node->get_name();
+    for(u32 i=0; builtin[i].name; ++i) {
+        if (builtin[i].name==name) {
             gen(op_callb, i, node->get_location().begin_line);
             if (local.empty()) {
                 die("should warp native function in local scope", node->get_location());
@@ -256,41 +259,42 @@ void codegen::call_id(identifier* node) {
         }
     }
     i32 index;
-    if ((index=local_find(str))>=0) {
+    if ((index=local_find(name))>=0) {
         gen(op_calll, index, node->get_location().begin_line);
         return;
     }
-    if ((index=upvalue_find(str))>=0) {
+    if ((index=upvalue_find(name))>=0) {
         gen(op_upval, index, node->get_location().begin_line);
         return;
     }
-    if ((index=global_find(str))>=0) {
+    if ((index=global_find(name))>=0) {
         gen(op_callg, index, node->get_location().begin_line);
         return;
     }
-    die("undefined symbol \""+str+"\"", node->get_location());
+    die("undefined symbol \"" + name + "\"", node->get_location());
 }
 
 void codegen::call_hash_gen(call_hash* node) {
-    regist_str(node.str());
-    gen(op_callh, str_table[node.str()], node->get_location().begin_line);
+    regist_str(node->get_field());
+    gen(op_callh, str_table[node->get_field()], node->get_location().begin_line);
 }
 
 void codegen::call_vec(call_vector* node) {
     // maybe this place can use callv-const if ast's first child is ast_num
-    if (node.size()==1 && node[0]->get_type()!=ast_subvec) {
-        calc_gen(node[0]);
-        gen(op_callv, 0, node[0]->get_location().begin_line);
+    if (node->get_slices().size()==1 &&
+        !node->get_slices()[0]->get_end()) {
+        calc_gen(node->get_slices()[0]->get_begin());
+        gen(op_callv, 0, node->get_slices()[0]->get_location().begin_line);
         return;
     }
     gen(op_slcbeg,0,node->get_location().begin_line);
-    for(auto& tmp:node.child()) {
-        if (tmp->get_type()!=ast_subvec) {
-            calc_gen(tmp);
+    for(auto tmp : node->get_slices()) {
+        if (!tmp->get_end()) {
+            calc_gen(tmp->get_begin());
             gen(op_slc, 0, tmp->get_location().begin_line);
         } else {
-            calc_gen(tmp[0]);
-            calc_gen(tmp[1]);
+            calc_gen(tmp->get_begin());
+            calc_gen(tmp->get_end());
             gen(op_slc2, 0, tmp->get_location().begin_line);
         }
     }
@@ -298,16 +302,21 @@ void codegen::call_vec(call_vector* node) {
 }
 
 void codegen::call_func(call_function* node) {
-    if (!node.size()) {
-        gen(op_callfv, 0, node->get_location().begin_line);
-    } else if (node[0]->get_type()==expr_type::ast_pair) {
-        hash_gen(node);
+    if (node->get_argument().size() &&
+        node->get_argument()[0]->get_type()==expr_type::ast_pair) {
+        gen(op_newh, 0, node->get_location().begin_line);
+        for(auto child : node->get_argument()) {
+            calc_gen(((hash_pair*)child)->get_value());
+            const auto& str = ((hash_pair*)child)->get_name();
+            regist_str(str);
+            gen(op_happ, str_table[str], child->get_location().begin_line);
+        }
         gen(op_callfh, 0, node->get_location().begin_line);
     } else {
-        for(auto& child:node.child()) {
+        for(auto child : node->get_argument()) {
             calc_gen(child);
         }
-        gen(op_callfv, node.size(), node->get_location().begin_line);
+        gen(op_callfv, node->get_argument().size(), node->get_location().begin_line);
     }
 }
 
@@ -323,28 +332,24 @@ void codegen::mcall(call_expr* node) {
     if (!check_memory_reachable(node)) {
         return;
     }
-    if (node->get_type()==expr_type::ast_id) {
-        mcall_id(node);
-        return;
+    if (node->get_first()->get_type()==expr_type::ast_id &&
+        !node->get_calls().size()) {
+        mcall_id((identifier*)node->get_first());
     }
-    if (node.size()==1) { // foreach and forindex use call-id ast to get mcall
-        mcall_id(node[0]);
-        return;
-    }
-    calc_gen(node[0]);
-    for(usize i=1;i<node.size()-1;++i) {
-        const ast& tmp=node[i];
+    calc_gen(node->get_first());
+    for(usize i = 0; i<node->get_calls().size()-1; ++i) {
+        auto tmp = node->get_calls()[i];
         switch(tmp->get_type()) {
-            case expr_type::ast_callh:call_hash(tmp);break;
-            case expr_type::ast_callv:call_vec(tmp); break;
-            case expr_type::ast_callf:call_func(tmp);break;
+            case expr_type::ast_callh: call_hash_gen((call_hash*)tmp); break;
+            case expr_type::ast_callv: call_vec((call_vector*)tmp); break;
+            case expr_type::ast_callf: call_func((call_function*)tmp); break;
         }
     }
-    const ast& tmp=node.child().back();
+    auto tmp = node->get_calls().back();
     if (tmp->get_type()==expr_type::ast_callh) {
-        mcall_hash(tmp);
+        mcall_hash((call_hash*)tmp);
     } else if (tmp->get_type()==expr_type::ast_callv) {
-        mcall_vec(tmp);
+        mcall_vec((call_vector*)tmp);
     }
 }
 
@@ -373,13 +378,13 @@ void codegen::mcall_id(identifier* node) {
 }
 
 void codegen::mcall_vec(call_vector* node) {
-    calc_gen(node[0]);
+    calc_gen(node->get_slices()[0]);
     gen(op_mcallv, 0, node->get_location().begin_line);
 }
 
 void codegen::mcall_hash(call_hash* node) {
-    regist_str(node.str());
-    gen(op_mcallh, str_table[node.str()], node->get_location().begin_line);
+    regist_str(node->get_field());
+    gen(op_mcallh, str_table[node->get_field()], node->get_location().begin_line);
 }
 
 void codegen::single_def(definition_expr* node) {
@@ -391,32 +396,27 @@ void codegen::single_def(definition_expr* node) {
 }
 
 void codegen::multi_def(definition_expr* node) {
-    auto& ids=node[0].child();
-    usize size=ids.size();
-    if (node[1]->get_type()==expr_type::ast_tuple) { // (var a,b,c)=(c,b,a);
-        auto& vals=node[1].child();
-        for(usize i=0;i<size;++i) {
-            // check node type, only identifier is allowed
-            if (ids[i]->get_type()!=ast_id) {
-                die("cannot call identifier in multi-definition", ids[i]->get_location());
-                continue;
-            }
+    auto& ids = node->get_variables()->get_variables();
+    usize size = ids.size();
+    if (node->get_value()->get_type()==expr_type::ast_tuple) { // (var a,b,c)=(c,b,a);
+        auto& vals = ((tuple_expr*)node->get_value())->get_elements();
+        if (ids.size()<vals.size()) {
+            die("lack values in multi-definition", node->get_value()->get_location());
+        } else if (ids.size()>vals.size()) {
+            die("too many values in multi-definition", node->get_value()->get_location());
+        }
+        for(usize i = 0; i<size; ++i) {
             calc_gen(vals[i]);
-            const std::string& str=ids[i].str();
+            const auto& str = ids[i]->get_name();
             local.empty()?
                 gen(op_loadg, global_find(str), ids[i]->get_location().begin_line):
                 gen(op_loadl, local_find(str), ids[i]->get_location().begin_line);
         }
     } else { // (var a,b,c)=[0,1,2];
-        calc_gen(node[1]);
-        for(usize i=0;i<size;++i) {
-            // check node type, only identifier is allowed
-            if (ids[i]->get_type()!=ast_id) {
-                die("cannot call identifier in multi-definition", ids[i]->get_location());
-                continue;
-            }
-            gen(op_callvi, i, node[1]->get_location().begin_line);
-            const std::string& str=ids[i].str();
+        calc_gen(node->get_value());
+        for(usize i = 0; i<size; ++i) {
+            gen(op_callvi, i, node->get_value()->get_location().begin_line);
+            const auto& str = ids[i]->get_name();
             local.empty()?
                 gen(op_loadg, global_find(str), ids[i]->get_location().begin_line):
                 gen(op_loadl, local_find(str), ids[i]->get_location().begin_line);
@@ -426,14 +426,11 @@ void codegen::multi_def(definition_expr* node) {
 }
 
 void codegen::def_gen(definition_expr* node) {
-    if (node[0]->get_type()==expr_type::ast_id && node[1]->get_type()==expr_type::ast_tuple) {
-        die("cannot accept too many values", node[1]->get_location());
-    } else if (node[0]->get_type()==expr_type::ast_multi_id && node[1]->get_type()==expr_type::ast_tuple && node[0].size()<node[1].size()) {
-        die("lack values in multi-definition", node[1]->get_location());
-    } else if (node[0]->get_type()==expr_type::ast_multi_id && node[1]->get_type()==expr_type::ast_tuple && node[0].size()>node[1].size()) {
-        die("too many values in multi-definition", node[1]->get_location());
+    if (node->get_variable_name() &&
+        node->get_value()->get_type()==expr_type::ast_tuple) {
+        die("cannot accept too many values", node->get_value()->get_location());
     }
-    node[0]->get_type()==expr_type::ast_id?single_def(node):multi_def(node);
+    node->get_variable_name()? single_def(node):multi_def(node);
 }
 
 void codegen::multi_assign_gen(multi_assign* node) {
@@ -510,10 +507,17 @@ void codegen::loop_gen(expr* node) {
     continue_ptr.push_front({});
     break_ptr.push_front({});
     switch(node->get_type()) {
-        case expr_type::ast_while:   while_gen(node);   break;
-        case expr_type::ast_for:     for_gen(node);     break;
-        case expr_type::ast_forindex:forindex_gen(node);break;
-        case expr_type::ast_foreach: foreach_gen(node); break;
+        case expr_type::ast_while:
+            while_gen((while_expr*)node); break;
+        case expr_type::ast_for:
+            for_gen((for_expr*)node); break;
+        case expr_type::ast_forei:
+            if (((forei_expr*)node)->get_loop_type()==forei_expr::forei_loop_type::forindex) {
+                forindex_gen((forei_expr*)node);
+            } else {
+                foreach_gen((forei_expr*)node);
+            }
+            break;
     }
 }
 
@@ -530,31 +534,31 @@ void codegen::load_continue_break(i32 continue_place,i32 break_place) {
 
 void codegen::while_gen(while_expr* node) {
     usize loop_ptr=code.size();
-    calc_gen(node[0]);
+    calc_gen(node->get_condition());
     usize condition_ptr=code.size();
-    gen(op_jf, 0, node[0]->get_location().begin_line);
+    gen(op_jf, 0, node->get_condition()->get_location().begin_line);
 
-    block_gen(node[1]);
-    gen(op_jmp, loop_ptr, node[1]->get_location().begin_line);
+    block_gen(node->get_code_block());
+    gen(op_jmp, loop_ptr, node->get_code_block()->get_location().begin_line);
     code[condition_ptr].num=code.size();
     load_continue_break(code.size()-1, code.size());
 }
 
 void codegen::for_gen(for_expr* node) {
-    expr_gen(node[0]);
+    expr_gen(node->get_initial());
     usize jmp_place=code.size();
-    if (node[1]->get_type()==expr_type::ast_null) {
-        gen(op_pnum, num_table[1], node[1]->get_location().begin_line);
+    if (node->get_condition()->get_type()==expr_type::ast_null) {
+        gen(op_pnum, num_table[1], node->get_condition()->get_location().begin_line);
     } else {
-        calc_gen(node[1]);
+        calc_gen(node->get_condition());
     }
     usize label_exit=code.size();
-    gen(op_jf, 0, node[1]->get_location().begin_line);
+    gen(op_jf, 0, node->get_condition()->get_location().begin_line);
 
-    block_gen(node[3]);
+    block_gen(node->get_code_block());
     usize continue_place=code.size();
-    expr_gen(node[2]);
-    gen(op_jmp, jmp_place, node[2]->get_location().begin_line);
+    expr_gen(node->get_step());
+    gen(op_jmp, jmp_place, node->get_step()->get_location().begin_line);
     code[label_exit].num=code.size();
 
     load_continue_break(continue_place, code.size());
@@ -563,30 +567,15 @@ void codegen::for_gen(for_expr* node) {
 void codegen::expr_gen(expr* node) {
     switch(node->get_type()) {
         case expr_type::ast_null:break;
-        case expr_type::ast_def:def_gen(node);break;
-        case expr_type::ast_multi_assign:multi_assign_gen(node);break;
-        case expr_type::ast_addeq:case expr_type::ast_subeq:
-        case expr_type::ast_multeq:case expr_type::ast_diveq:case expr_type::ast_lnkeq:
-        case expr_type::ast_btandeq:case expr_type::ast_btoreq:case expr_type::ast_btxoreq:
-            calc_gen(node);
-            if (op_addeq<=code.back().op && code.back().op<=op_btxoreq) {
-                code.back().num=1;
-            } else if (op_addeqc<=code.back().op && code.back().op<=op_lnkeqc) {
-                code.back().op=code.back().op-op_addeqc+op_addecp;
-            } else {
-                gen(op_pop, 0, node->get_location().begin_line);
-            }
-            break;
+        case expr_type::ast_def:
+            def_gen((definition_expr*)node);break;
+        case expr_type::ast_multi_assign:
+            multi_assign_gen((multi_assign*)node);break;
         case expr_type::ast_nil:case expr_type::ast_num:case expr_type::ast_str:case expr_type::ast_bool:break;
         case expr_type::ast_vec:case expr_type::ast_hash:case expr_type::ast_func:case expr_type::ast_call:
-        case expr_type::ast_neg:case expr_type::ast_lnot:case expr_type::ast_bnot:
-        case expr_type::ast_bitor:case expr_type::ast_bitxor:case expr_type::ast_bitand:
-        case expr_type::ast_add:case expr_type::ast_sub:case expr_type::ast_mult:case expr_type::ast_div:case expr_type::ast_link:
-        case expr_type::ast_cmpeq:case expr_type::ast_neq:
-        case expr_type::ast_leq:case expr_type::ast_less:
-        case expr_type::ast_geq:case expr_type::ast_grt:
-        case expr_type::ast_or:case expr_type::ast_and:
-        case expr_type::ast_trino:
+        case expr_type::ast_unary:
+        case expr_type::ast_binary:
+        case expr_type::ast_ternary:
             calc_gen(node);
             gen(op_pop, 0, node->get_location().begin_line);
             break;
@@ -611,21 +600,33 @@ void codegen::expr_gen(expr* node) {
                 }
             }
             break;
+        case expr_type::ast_addeq:case expr_type::ast_subeq:
+        case expr_type::ast_multeq:case expr_type::ast_diveq:case expr_type::ast_lnkeq:
+        case expr_type::ast_btandeq:case expr_type::ast_btoreq:case expr_type::ast_btxoreq:
+            calc_gen(node);
+            if (op_addeq<=code.back().op && code.back().op<=op_btxoreq) {
+                code.back().num=1;
+            } else if (op_addeqc<=code.back().op && code.back().op<=op_lnkeqc) {
+                code.back().op=code.back().op-op_addeqc+op_addecp;
+            } else {
+                gen(op_pop, 0, node->get_location().begin_line);
+            }
+            break;
     }
 }
 
 void codegen::forindex_gen(forei_expr* node) {
-    calc_gen(node[1]);
-    gen(op_cnt, 0, node[1]->get_location().begin_line);
-    usize ptr=code.size();
+    calc_gen(node->get_value());
+    gen(op_cnt, 0, node->get_value()->get_location().begin_line);
+    usize ptr = code.size();
     gen(op_findex, 0, node->get_location().begin_line);
-    if (node[0]->get_type()==expr_type::ast_iter) { // define a new iterator
-        const std::string& str=node[0][0].str();
+    if (node->get_iterator()->get_name()) { // define a new iterator
+        const auto& str = node->get_iterator()->get_name()->get_name();
         local.empty()?
-            gen(op_loadg, global_find(str), node[0][0]->get_location().begin_line):
-            gen(op_loadl, local_find(str), node[0][0]->get_location().begin_line);
+            gen(op_loadg, global_find(str), node->get_iterator()->get_name()->get_location().begin_line):
+            gen(op_loadl, local_find(str), node->get_iterator()->get_name()->get_location().begin_line);
     } else { // use exist variable as the iterator
-        mcall(node[0]);
+        mcall((call_expr*)node->get_iterator()->get_call());
         if (code.back().op==op_mcallg) {
             code.back().op=op_loadg;
         } else if (code.back().op==op_mcalll) {
@@ -633,31 +634,31 @@ void codegen::forindex_gen(forei_expr* node) {
         } else if (code.back().op==op_mupval) {
             code.back().op=op_loadu;
         } else {
-            gen(op_meq, 1, node[0]->get_location().begin_line);
+            gen(op_meq, 1, node->get_iterator()->get_location().begin_line);
         }
     }
     ++in_iterloop.top();
-    block_gen(node[2]);
+    block_gen(node->get_code_block());
     --in_iterloop.top();
     gen(op_jmp, ptr, node->get_location().begin_line);
     code[ptr].num=code.size();
     load_continue_break(code.size()-1, code.size());
-    gen(op_pop, 0, node[1]->get_location().begin_line);// pop vector
+    gen(op_pop, 0, node->get_value()->get_location().begin_line);// pop vector
     gen(op_pop, 0, node->get_location().begin_line);// pop iterator
 }
 
 void codegen::foreach_gen(forei_expr* node) {
-    calc_gen(node[1]);
+    calc_gen(node->get_value());
     gen(op_cnt, 0, node->get_location().begin_line);
-    usize ptr=code.size();
+    usize ptr = code.size();
     gen(op_feach, 0, node->get_location().begin_line);
-    if (node[0]->get_type()==expr_type::ast_iter) { // define a new iterator
-        const std::string& str=node[0][0].str();
+    if (node->get_iterator()->get_name()) { // define a new iterator
+        const auto& str = node->get_iterator()->get_name()->get_name();
         local.empty()?
-            gen(op_loadg, global_find(str), node[0][0]->get_location().begin_line):
-            gen(op_loadl, local_find(str), node[0][0]->get_location().begin_line);
+            gen(op_loadg, global_find(str), node->get_iterator()->get_name()->get_location().begin_line):
+            gen(op_loadl, local_find(str), node->get_iterator()->get_name()->get_location().begin_line);
     } else { // use exist variable as the iterator
-        mcall(node[0]);
+        mcall((call_expr*)node->get_iterator()->get_call());
         if (code.back().op==op_mcallg) {
             code.back().op=op_loadg;
         } else if (code.back().op==op_mcalll) {
@@ -665,17 +666,17 @@ void codegen::foreach_gen(forei_expr* node) {
         } else if (code.back().op==op_mupval) {
             code.back().op=op_loadu;
         } else {
-            gen(op_meq, 1, node[0]->get_location().begin_line);
+            gen(op_meq, 1, node->get_iterator()->get_location().begin_line);
         }
     }
     ++in_iterloop.top();
-    block_gen(node[2]);
+    block_gen(node->get_code_block());
     --in_iterloop.top();
     gen(op_jmp, ptr, node->get_location().begin_line);
     code[ptr].num=code.size();
     load_continue_break(code.size()-1, code.size());
-    gen(op_pop, 0, node[1]->get_location().begin_line);// pop vector
-    gen(op_pop, 0, node->get_location().begin_line);// pop iterator
+    gen(op_pop, 0, node->get_value()->get_location().begin_line); // pop vector
+    gen(op_pop, 0, node->get_location().begin_line); // pop iterator
 }
 
 void codegen::or_gen(binary_operator* node) {
@@ -725,15 +726,24 @@ void codegen::trino_gen(ternary_operator* node) {
 
 void codegen::calc_gen(expr* node) {
     switch(node->get_type()) {
-        case expr_type::ast_nil:  gen(op_pnil,0,node->get_location().begin_line);break;
-        case expr_type::ast_num:  num_gen(node);  break;
-        case expr_type::ast_str:  str_gen(node);  break;
-        case expr_type::ast_id:   call_id(node);  break;
-        case expr_type::ast_bool: bool_gen(node); break;
-        case expr_type::ast_vec:  vec_gen(node);  break;
-        case expr_type::ast_hash: hash_gen(node); break;
-        case expr_type::ast_func: func_gen(node); break;
-        case expr_type::ast_call: call_gen(node); break;
+        case expr_type::ast_nil:
+            gen(op_pnil,0,node->get_location().begin_line); break;
+        case expr_type::ast_num:
+            num_gen((number_literal*)node); break;
+        case expr_type::ast_str:
+            str_gen((string_literal*)node); break;
+        case expr_type::ast_id:
+            call_id((identifier*)node); break;
+        case expr_type::ast_bool:
+            bool_gen((bool_literal*)node); break;
+        case expr_type::ast_vec:
+            vec_gen((vector_expr*)node); break;
+        case expr_type::ast_hash:
+            hash_gen((hash_expr*)node); break;
+        case expr_type::ast_func:
+            func_gen((function*)node); break;
+        case expr_type::ast_call:
+            call_gen((call_expr*)node); break;
         case expr_type::ast_equal:
             calc_gen(node[1]);
             mcall(node[0]);
@@ -809,7 +819,8 @@ void codegen::calc_gen(expr* node) {
                 gen(node->get_type()-ast_less+op_lessc, num_table[node[1].num()], node->get_location().begin_line);
             }
             break;
-        case expr_type::ast_trino:trino_gen(node);break;
+        case expr_type::ast_ternary:
+            trino_gen((ternary_operator*)node);break;
         case expr_type::ast_neg:
             calc_gen(node[0]);
             gen(op_usub, 0, node->get_location().begin_line);
@@ -838,20 +849,24 @@ void codegen::calc_gen(expr* node) {
             gen(op_btand, 0, node->get_location().begin_line);
             break;
         case expr_type::ast_def:
-            single_def(node);
-            call_id(node[0]);
+            single_def((definition_expr*)node);
+            call_id(((definition_expr*)node)->get_variable_name());
             break;
     }
 }
 
 void codegen::block_gen(code_block* node) {
-    for(auto& tmp:node.child()) {
+    for(auto tmp : node->get_expressions()) {
         switch(tmp->get_type()) {
             case expr_type::ast_null:break;
-            case expr_type::ast_id:check_id_exist(tmp);break;
-            case expr_type::ast_nil:case expr_type::ast_num:case expr_type::ast_str:case expr_type::ast_bool:break;
-            case expr_type::ast_file:fileindex=tmp.num();break; // special node type in main block
-            case expr_type::ast_cond:cond_gen(tmp);break;
+            case expr_type::ast_id:
+                check_id_exist((identifier*)tmp); break;
+            case expr_type::ast_nil:case expr_type::ast_num:
+            case expr_type::ast_str:case expr_type::ast_bool:break;
+            case expr_type::ast_file_info:
+                fileindex = ((file_info*)tmp)->get_index();break; // special node type in main block
+            case expr_type::ast_cond:
+                cond_gen((condition_expr*)tmp); break;
             case expr_type::ast_continue:
                 continue_ptr.front().push_back(code.size());
                 gen(op_jmp, 0, tmp->get_location().begin_line);
@@ -862,43 +877,32 @@ void codegen::block_gen(code_block* node) {
                 break;
             case expr_type::ast_while:
             case expr_type::ast_for:
-            case expr_type::ast_forindex:
-            case expr_type::ast_foreach:loop_gen(tmp);break;
-            case expr_type::ast_equal:
-            case expr_type::ast_addeq:case expr_type::ast_subeq:
-            case expr_type::ast_multeq:case expr_type::ast_diveq:case expr_type::ast_lnkeq:
-            case expr_type::ast_btandeq:case expr_type::ast_btoreq:case expr_type::ast_btxoreq:
-            case expr_type::ast_vec:case expr_type::ast_hash:case expr_type::ast_func:case expr_type::ast_call:
-            case expr_type::ast_neg:case expr_type::ast_lnot:case expr_type::ast_bnot:
-            case expr_type::ast_bitor:case expr_type::ast_bitxor:case expr_type::ast_bitand:
-            case expr_type::ast_add:case expr_type::ast_sub:case expr_type::ast_mult:case expr_type::ast_div:case expr_type::ast_link:
-            case expr_type::ast_cmpeq:case expr_type::ast_neq:
-            case expr_type::ast_leq:case expr_type::ast_less:
-            case expr_type::ast_geq:case expr_type::ast_grt:
-            case expr_type::ast_or:
-            case expr_type::ast_and:
-            case expr_type::ast_trino:
+            case expr_type::ast_forei:
+                loop_gen(tmp); break;
+            case expr_type::ast_binary:
+            case expr_type::ast_vec:case expr_type::ast_hash:
+            case expr_type::ast_func:case expr_type::ast_call:
+            case expr_type::ast_unary:
+            case expr_type::ast_ternary:
             case expr_type::ast_def:
-            case expr_type::ast_multi_assign:expr_gen(tmp);break;
-            case expr_type::ast_ret:ret_gen(tmp);break;
+            case expr_type::ast_multi_assign:
+                expr_gen(tmp); break;
+            case expr_type::ast_ret:
+                ret_gen((return_expr*)tmp); break;
         }
     }
 }
 
-void codegen::ret_gen(const ast& node) {
+void codegen::ret_gen(return_expr* node) {
     for(u32 i=0;i<in_iterloop.top();++i) {
         gen(op_pop, 0, node->get_location().begin_line);
         gen(op_pop, 0, node->get_location().begin_line);
     }
-    if (node.size()) {
-        calc_gen(node[0]);
-    } else {
-        gen(op_pnil, 0, node->get_location().begin_line);
-    }
+    calc_gen(node->get_value());
     gen(op_ret, 0, node->get_location().begin_line);
 }
 
-const error& codegen::compile(const parse& parse, const linker& import) {
+const error& codegen::compile(parse& parse, linker& import) {
     fileindex=0;
     file=import.filelist().data();
     in_iterloop.push(0);
diff --git a/ast/nasal_new_codegen.h b/ast/nasal_new_codegen.h
index 28c2817..e705da7 100644
--- a/ast/nasal_new_codegen.h
+++ b/ast/nasal_new_codegen.h
@@ -93,7 +93,7 @@ private:
 
 public:
     codegen(error& e): fileindex(0), err(e), file(nullptr) {}
-    const error& compile(const parse&, const linker&);
+    const error& compile(parse&, linker&);
     void print();
     const std::vector<std::string>& strs() const {return str_res;}
     const std::vector<f64>& nums() const {return num_res;}
diff --git a/ast/nasal_new_gc.h b/ast/nasal_new_gc.h
index f53b18f..ba6b356 100644
--- a/ast/nasal_new_gc.h
+++ b/ast/nasal_new_gc.h
@@ -26,6 +26,7 @@
 #include <unordered_map>
 #include <chrono>
 #include <algorithm>
+#include <thread>
 
 #include "nasal_new_header.h"
 #include "nasal_new_err.h"
@@ -362,11 +363,11 @@ private:
     void mark();
     void mark_context(std::vector<var>&);
     void mark_var(std::vector<var>&, var&);
-    inline void mark_vec(std::vector<var>&, nas_vec&);
-    inline void mark_hash(std::vector<var>&, nas_hash&);
-    inline void mark_func(std::vector<var>&, nas_func&);
-    inline void mark_upval(std::vector<var>&, nas_upval&);
-    inline void mark_co(std::vector<var>&, nas_co&);
+    void mark_vec(std::vector<var>&, nas_vec&);
+    void mark_hash(std::vector<var>&, nas_hash&);
+    void mark_func(std::vector<var>&, nas_func&);
+    void mark_upval(std::vector<var>&, nas_upval&);
+    void mark_co(std::vector<var>&, nas_co&);
     void sweep();
 
 public:
diff --git a/ast/nasal_new_header.h b/ast/nasal_new_header.h
index 4b67fe4..7adc074 100644
--- a/ast/nasal_new_header.h
+++ b/ast/nasal_new_header.h
@@ -32,7 +32,7 @@ using u64 = std::uint64_t;
 using usize = std::size_t;
 using f64 = double;
 
-const u32 STACK_DEPTH=1024;
+const u32 STACK_DEPTH=4096;
 
 f64 hex2f(const char*);
 f64 oct2f(const char*);
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index c4398e0..bb62a69 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -907,11 +907,11 @@ forei_expr* parse::forei_loop() {
     auto node = new forei_expr(toks[ptr].loc);
     switch(toks[ptr].type) {
         case tok::forindex:
-            node->set_type(forei_expr::forei_loop_type::forindex);
+            node->set_loop_type(forei_expr::forei_loop_type::forindex);
             match(tok::forindex);
             break;
         case tok::foreach: 
-            node->set_type(forei_expr::forei_loop_type::foreach);
+            node->set_loop_type(forei_expr::forei_loop_type::foreach);
             match(tok::foreach);
             break;
         default: break;
diff --git a/ast/optimizer.cpp b/ast/optimizer.cpp
index 1d4ca56..b24018c 100644
--- a/ast/optimizer.cpp
+++ b/ast/optimizer.cpp
@@ -1,10 +1,10 @@
 #include "optimizer.h"
 
-void const_string(binary_operator* node) {
+void optimizer::const_string(binary_operator* node) {
 
 }
 
-void const_number(binary_operator* node) {
+void optimizer::const_number(binary_operator* node) {
     
 }
 
diff --git a/nasal_codegen.h b/nasal_codegen.h
index 553e7c0..0fbd9ab 100644
--- a/nasal_codegen.h
+++ b/nasal_codegen.h
@@ -105,7 +105,7 @@ bool codegen::check_memory_reachable(const ast& node) {
             die("bad left-value with function call", node.location());
             return false;
         }
-        if (tmp.type()==ast_callv && (tmp.size()==0 || tmp.size()>1 || tmp[0].type()==ast_subvec)) {
+        if (tmp.type()==ast_callv && (tmp.size()!=1 || tmp[0].type()==ast_subvec)) {
             die("bad left-value with subvec", node.location());
             return false;
         }
@@ -413,16 +413,14 @@ void codegen::call_vec(const ast& node) {
 }
 
 void codegen::call_func(const ast& node) {
-    if (!node.size()) {
-        gen(op_callfv, 0, node.line());
-    } else if (node[0].type()==ast_pair) {
-        hash_gen(node);
-        gen(op_callfh, 0, node.line());
-    } else {
+    if (!node.size() || node[0].type()!=ast_pair) {
         for(auto& child:node.child()) {
             calc_gen(child);
         }
         gen(op_callfv, node.size(), node.line());
+    } else if (node[0].type()==ast_pair) {
+        hash_gen(node);
+        gen(op_callfh, 0, node.line());
     }
 }
 

From 90ad1a53d7ed5e7328a4877ab53db3d6e7b4ce0e Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sat, 1 Jul 2023 00:55:00 +0800
Subject: [PATCH 24/34] :sparkles: update

---
 ast/ast_dumper.cpp        |   4 +-
 ast/nasal_new_ast.h       |  12 +-
 ast/nasal_new_codegen.cpp | 378 ++++++++++++++++++++++++--------------
 ast/nasal_new_codegen.h   |   4 +
 ast/nasal_new_parse.cpp   |  56 +++---
 test/httptest.nas         |   7 +-
 6 files changed, 288 insertions(+), 173 deletions(-)

diff --git a/ast/ast_dumper.cpp b/ast/ast_dumper.cpp
index c6497d4..80c344a 100644
--- a/ast/ast_dumper.cpp
+++ b/ast/ast_dumper.cpp
@@ -150,7 +150,7 @@ bool ast_dumper::visit_ternary_operator(ternary_operator* node) {
 bool ast_dumper::visit_binary_operator(binary_operator* node) {
     dump_indent();
     std::cout << "binary_operator ";
-    switch(node->get_type()) {
+    switch(node->get_operator_type()) {
         case binary_operator::binary_type::add: std::cout << "+"; break;
         case binary_operator::binary_type::sub: std::cout << "-"; break;
         case binary_operator::binary_type::mult: std::cout << "*"; break;
@@ -180,7 +180,7 @@ bool ast_dumper::visit_binary_operator(binary_operator* node) {
 bool ast_dumper::visit_unary_operator(unary_operator* node) {
     dump_indent();
     std::cout << "unary_operator ";
-    switch(node->get_type()) {
+    switch(node->get_operator_type()) {
         case unary_operator::unary_type::negative: std::cout << "-"; break;
         case unary_operator::unary_type::logical_not: std::cout << "!"; break;
         case unary_operator::unary_type::bitwise_not: std::cout << "~"; break;
diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index ce96d92..2051d77 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -304,10 +304,10 @@ public:
         expr(location, expr_type::ast_binary),
         left(nullptr), right(nullptr) {}
     ~binary_operator();
-    void set_type(binary_type operator_type) {type = operator_type;}
+    void set_operator_type(binary_type operator_type) {type = operator_type;}
     void set_left(expr* node) {left = node;}
     void set_right(expr* node) {right = node;}
-    binary_type get_type() const {return type;}
+    binary_type get_operator_type() const {return type;}
     expr* get_left() {return left;}
     expr* get_right() {return right;}
     void accept(ast_visitor*) override;
@@ -330,9 +330,9 @@ public:
         expr(location, expr_type::ast_unary),
         value(nullptr) {}
     ~unary_operator();
-    void set_type(unary_type operator_type) {type = operator_type;}
+    void set_operator_type(unary_type operator_type) {type = operator_type;}
     void set_value(expr* node) {value = node;}
-    unary_type get_type() const {return type;}
+    unary_type get_operator_type() const {return type;}
     expr* get_value() {return value;}
     void accept(ast_visitor*) override;
 };
@@ -454,10 +454,10 @@ public:
         expr(location, expr_type::ast_assign),
         left(nullptr), right(nullptr) {}
     ~assignment_expr();
-    void set_type(assign_type operator_type) {type = operator_type;}
+    void set_assignment_type(assign_type operator_type) {type = operator_type;}
     void set_left(expr* node) {left = node;}
     void set_right(expr* node) {right = node;}
-    assign_type get_type() const {return type;}
+    assign_type get_assignment_type() const {return type;}
     expr* get_left() {return left;}
     expr* get_right() {return right;}
     void accept(ast_visitor*) override;
diff --git a/ast/nasal_new_codegen.cpp b/ast/nasal_new_codegen.cpp
index 9f4acce..984b72a 100644
--- a/ast/nasal_new_codegen.cpp
+++ b/ast/nasal_new_codegen.cpp
@@ -433,19 +433,68 @@ void codegen::def_gen(definition_expr* node) {
     node->get_variable_name()? single_def(node):multi_def(node);
 }
 
-void codegen::multi_assign_gen(multi_assign* node) {
-    if (node[1]->get_type()==expr_type::ast_tuple && node[0].size()<node[1].size()) {
-        die("lack values in multi-assignment", node[1]->get_location());
-    } else if (node[1]->get_type()==expr_type::ast_tuple && node[0].size()>node[1].size()) {
-        die("too many values in multi-assignment", node[1]->get_location());
+void codegen::assignment_gen(assignment_expr* node) {
+    switch(node->get_assignment_type()) {
+        case assignment_expr::assign_type::equal:
+            calc_gen(node->get_right());
+            mcall((call_expr*)node->get_left());
+            gen(op_meq, 0, node->get_location().begin_line);
+            break;
+        case assignment_expr::assign_type::add_equal:
+        case assignment_expr::assign_type::sub_equal:
+        case assignment_expr::assign_type::mult_equal:
+        case assignment_expr::assign_type::div_equal:
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+            }
+            mcall((call_expr*)node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                gen(node->get_type()-ast_addeq+op_addeq, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(node->get_type()-ast_addeq+op_addeqc, num_table[num], node->get_location().begin_line);
+            }
+            break;
+        case assignment_expr::assign_type::concat_equal:
+            if (node[1]->get_type()!=ast_str) {
+                calc_gen(node[1]);
+            } else {
+                regist_str(node[1].str());
+            }
+            mcall(node[0]);
+            if (node[1]->get_type()!=ast_str) {
+                gen(op_lnkeq, 0, node->get_location().begin_line);
+            } else {
+                gen(op_lnkeqc, str_table[node[1].str()], node->get_location().begin_line);
+            }
+            break;
+        case assignment_expr::assign_type::bitwise_and_equal:
+        case assignment_expr::assign_type::bitwise_or_equal:
+        case assignment_expr::assign_type::bitwise_xor_equal:
+            calc_gen(node->get_right());
+            mcall((call_expr*)node->get_left());
+            gen(node->get_type()-ast_btandeq+op_btandeq, 0, node->get_location().begin_line);
+            break;
     }
-    i32 size=node[0].size();
-    if (node[1]->get_type()==expr_type::ast_tuple) {
+}
+
+void codegen::multi_assign_gen(multi_assign* node) {
+    if (node->get_value()->get_type()==expr_type::ast_tuple &&
+        node->get_tuple()->get_elements().size()<((tuple_expr*)node->get_value())->get_elements().size()) {
+        die("lack values in multi-assignment", node->get_value()->get_location());
+    } else if (node->get_value()->get_type()==expr_type::ast_tuple &&
+        node->get_tuple()->get_elements().size()>((tuple_expr*)node->get_value())->get_elements().size()) {
+        die("too many values in multi-assignment", node->get_value()->get_location());
+    }
+    i32 size = node->get_tuple()->get_elements().size();
+    if (node->get_value()->get_type()==expr_type::ast_tuple) {
         for(i32 i=size-1;i>=0;--i) {
-            calc_gen(node[1][i]);
+            calc_gen(((tuple_expr*)node->get_value())->get_elements()[i]);
         }
+        auto& tuple = node->get_tuple()->get_elements();
         for(i32 i=0;i<size;++i) {
-            mcall(node[0][i]);
+            mcall((call_expr*)tuple[i]);
             // multi assign user loadl and loadg to avoid meq's stack--
             // and this operation changes local and global value directly
             if (code.back().op==op_mcalll) {
@@ -455,16 +504,17 @@ void codegen::multi_assign_gen(multi_assign* node) {
             } else if (code.back().op==op_mcallg) {
                 code.back().op=op_loadg;
             } else {
-                gen(op_meq, 1, node[0][i]->get_location().begin_line);
+                gen(op_meq, 1, tuple[i]->get_location().begin_line);
             }
         }
     } else {
-        calc_gen(node[1]);
+        calc_gen(node->get_value());
+        auto& tuple = node->get_tuple()->get_elements();
         for(i32 i=0;i<size;++i) {
-            gen(op_callvi, i, node[1]->get_location().begin_line);
+            gen(op_callvi, i, node->get_value()->get_location().begin_line);
             // multi assign user loadl and loadg to avoid meq's stack--
             // and this operation changes local and global value directly
-            mcall(node[0][i]);
+            mcall((call_expr*)tuple[i]);
             if (code.back().op==op_mcalll) {
                 code.back().op=op_loadl;
             } else if (code.back().op==op_mupval) {
@@ -472,7 +522,7 @@ void codegen::multi_assign_gen(multi_assign* node) {
             } else if (code.back().op==op_mcallg) {
                 code.back().op=op_loadg;
             } else {
-                gen(op_meq, 1, node[0][i]->get_location().begin_line);
+                gen(op_meq, 1, tuple[i]->get_location().begin_line);
             }
         }
         gen(op_pop, 0, node->get_location().begin_line);
@@ -481,25 +531,31 @@ void codegen::multi_assign_gen(multi_assign* node) {
 
 void codegen::cond_gen(condition_expr* node) {
     std::vector<usize> jmp_label;
-    for(auto& tmp:node.child()) {
-        if (tmp->get_type()==expr_type::ast_if || tmp->get_type()==expr_type::ast_elsif) {
-            calc_gen(tmp[0]);
-            usize ptr=code.size();
-            gen(op_jf, 0, tmp->get_location().begin_line);
-            block_gen(tmp[1]);
-            // without 'else' the last condition doesn't need to jmp
-            if (&tmp!=&node.child().back()) {
-                jmp_label.push_back(code.size());
-                gen(op_jmp, 0, tmp->get_location().begin_line);
-            }
-            code[ptr].num=code.size();
-        } else {
-            block_gen(tmp[0]);
-            break;
+    calc_gen(node->get_if_statement()->get_condition());
+    auto ptr = code.size();
+    gen(op_jf, 0, node->get_if_statement()->get_location().begin_line);
+    block_gen(node->get_if_statement()->get_code_block());
+    code[ptr].num = code.size();
+
+    for(auto tmp : node->get_elsif_stataments()) {
+        calc_gen(tmp->get_condition());
+        ptr = code.size();
+        gen(op_jf, 0, tmp->get_location().begin_line);
+        block_gen(tmp->get_code_block());
+        // the last condition doesn't need to jmp
+        if (tmp!=node->get_elsif_stataments().back() ||
+            node->get_else_statement()) {
+            jmp_label.push_back(code.size());
+            gen(op_jmp, 0, tmp->get_location().begin_line);
         }
+        code[ptr].num=code.size();
+    }
+
+    if (node->get_else_statement()) {
+        block_gen(node->get_else_statement()->get_code_block());
     }
     for(auto i:jmp_label) {
-        code[i].num=code.size();
+        code[i].num = code.size();
     }
 }
 
@@ -712,6 +768,156 @@ void codegen::and_gen(binary_operator* node) {
     // jt jumps here
 }
 
+void codegen::unary_gen(unary_operator* node) {
+    calc_gen(node->get_value());
+    switch(node->get_operator_type()) {
+        case unary_operator::unary_type::negative:
+            gen(op_usub, 0, node->get_location().begin_line); break;
+        case unary_operator::unary_type::logical_not:
+            gen(op_lnot, 0, node->get_location().begin_line); break;
+        case unary_operator::unary_type::bitwise_not:
+            gen(op_bnot, 0, node->get_location().begin_line); break;
+    }
+}
+
+void codegen::binary_gen(binary_operator* node) {
+    switch(node->get_operator_type()) {
+        case binary_operator::binary_type::condition_or: or_gen(node); return;
+        case binary_operator::binary_type::condition_and: and_gen(node); return;
+        default: break;
+    }
+    switch(node->get_operator_type()) {
+        case binary_operator::binary_type::cmpeq:
+            calc_gen(node->get_left());
+            calc_gen(node->get_right());
+            gen(op_eq, 0, node->get_location().begin_line);
+            return;
+        case binary_operator::binary_type::cmpneq:
+            calc_gen(node->get_left());
+            calc_gen(node->get_right());
+            gen(op_neq, 0, node->get_location().begin_line);
+            return;
+        case binary_operator::binary_type::bitwise_or:
+            calc_gen(node->get_left());
+            calc_gen(node->get_right());
+            gen(op_btor, 0, node->get_location().begin_line);
+            return;
+        case binary_operator::binary_type::bitwise_xor:
+            calc_gen(node->get_left());
+            calc_gen(node->get_right());
+            gen(op_btxor, 0, node->get_location().begin_line);
+            return;
+        case binary_operator::binary_type::bitwise_and:
+            calc_gen(node->get_left());
+            calc_gen(node->get_right());
+            gen(op_btand, 0, node->get_location().begin_line);
+            return;
+        default: break;
+    }
+    switch(node->get_operator_type()) {
+        case binary_operator::binary_type::add:
+            calc_gen(node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+                gen(op_add, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_addc, num_table[num], node->get_location().begin_line);
+            }
+            return;
+        case binary_operator::binary_type::sub:
+            calc_gen(node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+                gen(op_sub, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_subc, num_table[num], node->get_location().begin_line);
+            }
+            return;
+        case binary_operator::binary_type::mult:
+            calc_gen(node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+                gen(op_mul, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_mulc, num_table[num], node->get_location().begin_line);
+            }
+            return;
+        case binary_operator::binary_type::div:
+            calc_gen(node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+                gen(op_div, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_divc, num_table[num], node->get_location().begin_line);
+            }
+            return;
+        case binary_operator::binary_type::concat:
+            calc_gen(node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_str) {
+                calc_gen(node->get_right());
+                gen(op_lnk, 0, node->get_location().begin_line);
+            } else {
+                const auto& str = ((string_literal*)node->get_right())->get_content();
+                regist_str(str);
+                gen(op_lnkc, str_table[str], node->get_location().begin_line);
+            }
+            break;
+        // ast_cmpeq(27)~ast_geq(32) op_eq(29)~op_geq(34)
+        case binary_operator::binary_type::less:
+            calc_gen(node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+                gen(op_less, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_lessc, num_table[num], node->get_location().begin_line);
+            }
+            return;
+        case binary_operator::binary_type::leq:
+            calc_gen(node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+                gen(op_leq, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_leqc, num_table[num], node->get_location().begin_line);
+            }
+            return;
+        case binary_operator::binary_type::grt:
+            calc_gen(node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+                gen(op_grt, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_grtc, num_table[num], node->get_location().begin_line);
+            }
+            return;
+        case binary_operator::binary_type::geq:
+            calc_gen(node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+                gen(op_geq, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_geqc, num_table[num], node->get_location().begin_line);
+            }
+            return;
+    }
+}
+
 void codegen::trino_gen(ternary_operator* node) {
     calc_gen(node->get_condition());
     usize lfalse=code.size();
@@ -727,7 +933,7 @@ void codegen::trino_gen(ternary_operator* node) {
 void codegen::calc_gen(expr* node) {
     switch(node->get_type()) {
         case expr_type::ast_nil:
-            gen(op_pnil,0,node->get_location().begin_line); break;
+            gen(op_pnil, 0, node->get_location().begin_line); break;
         case expr_type::ast_num:
             num_gen((number_literal*)node); break;
         case expr_type::ast_str:
@@ -744,110 +950,14 @@ void codegen::calc_gen(expr* node) {
             func_gen((function*)node); break;
         case expr_type::ast_call:
             call_gen((call_expr*)node); break;
-        case expr_type::ast_equal:
-            calc_gen(node[1]);
-            mcall(node[0]);
-            gen(op_meq, 0, node->get_location().begin_line);
-            break;
-        // ast_addeq(22)~ast_lnkeq(26) op_addeq(23)~op_lnkeq(27)
-        case expr_type::ast_addeq:case expr_type::ast_subeq:case expr_type::ast_multeq:case expr_type::ast_diveq:
-            if (node[1]->get_type()!=ast_num) {
-                calc_gen(node[1]);
-            }
-            mcall(node[0]);
-            if (node[1]->get_type()!=ast_num) {
-                gen(node->get_type()-ast_addeq+op_addeq, 0, node->get_location().begin_line);
-            } else {
-                regist_num(node[1].num());
-                gen(node->get_type()-ast_addeq+op_addeqc, num_table[node[1].num()], node->get_location().begin_line);
-            }
-            break;
-        case expr_type::ast_lnkeq:
-            if (node[1]->get_type()!=ast_str) {
-                calc_gen(node[1]);
-            } else {
-                regist_str(node[1].str());
-            }
-            mcall(node[0]);
-            if (node[1]->get_type()!=ast_str) {
-                gen(op_lnkeq, 0, node->get_location().begin_line);
-            } else {
-                gen(op_lnkeqc, str_table[node[1].str()], node->get_location().begin_line);
-            }
-            break;
-        case expr_type::ast_btandeq:case expr_type::ast_btoreq:case expr_type::ast_btxoreq:
-            calc_gen(node[1]);
-            mcall(node[0]);
-            gen(node->get_type()-ast_btandeq+op_btandeq, 0, node->get_location().begin_line);
-            break;
-        case expr_type::ast_or:or_gen(node);break;
-        case expr_type::ast_and:and_gen(node);break;
-        // ast_add(33)~ast_link(37) op_add(18)~op_lnk(22)
-        case expr_type::ast_add:case expr_type::ast_sub:case expr_type::ast_mult:case expr_type::ast_div:
-            calc_gen(node[0]);
-            if (node[1]->get_type()!=ast_num) {
-                calc_gen(node[1]);
-                gen(node->get_type()-ast_add+op_add, 0, node->get_location().begin_line);
-            } else {
-                regist_num(node[1].num());
-                gen(node->get_type()-ast_add+op_addc, num_table[node[1].num()], node->get_location().begin_line);
-            }
-            break;
-        case expr_type::ast_link:
-            calc_gen(node[0]);
-            if (node[1]->get_type()!=ast_str) {
-                calc_gen(node[1]);
-                gen(op_lnk, 0, node->get_location().begin_line);
-            } else {
-                regist_str(node[1].str());
-                gen(op_lnkc, str_table[node[1].str()], node->get_location().begin_line);
-            }
-            break;
-        // ast_cmpeq(27)~ast_geq(32) op_eq(29)~op_geq(34)
-        case expr_type::ast_cmpeq:case expr_type::ast_neq:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(node->get_type()-ast_cmpeq+op_eq, 0, node->get_location().begin_line);
-            break;
-        case expr_type::ast_less:case expr_type::ast_leq:case expr_type::ast_grt:case expr_type::ast_geq:
-            calc_gen(node[0]);
-            if (node[1]->get_type()!=ast_num) {
-                calc_gen(node[1]);
-                gen(node->get_type()-ast_less+op_less, 0, node->get_location().begin_line);
-            } else {
-                regist_num(node[1].num());
-                gen(node->get_type()-ast_less+op_lessc, num_table[node[1].num()], node->get_location().begin_line);
-            }
-            break;
+        case expr_type::ast_assign:
+            assignment_gen((assignment_expr*)node); break;
         case expr_type::ast_ternary:
-            trino_gen((ternary_operator*)node);break;
-        case expr_type::ast_neg:
-            calc_gen(node[0]);
-            gen(op_usub, 0, node->get_location().begin_line);
-            break;
-        case expr_type::ast_lnot:
-            calc_gen(node[0]);
-            gen(op_lnot, 0, node->get_location().begin_line);
-            break;
-        case expr_type::ast_bnot:
-            calc_gen(node[0]);
-            gen(op_bnot, 0, node->get_location().begin_line);
-            break;
-        case expr_type::ast_bitor:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(op_btor, 0, node->get_location().begin_line);
-            break;
-        case expr_type::ast_bitxor:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(op_btxor, 0, node->get_location().begin_line);
-            break;
-        case expr_type::ast_bitand:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(op_btand, 0, node->get_location().begin_line);
-            break;
+            trino_gen((ternary_operator*)node); break;
+        case expr_type::ast_unary:
+            unary_gen((unary_operator*)node); break;
+        case expr_type::ast_binary:
+            binary_gen((binary_operator*)node); break;
         case expr_type::ast_def:
             single_def((definition_expr*)node);
             call_id(((definition_expr*)node)->get_variable_name());
diff --git a/ast/nasal_new_codegen.h b/ast/nasal_new_codegen.h
index e705da7..40fd3c6 100644
--- a/ast/nasal_new_codegen.h
+++ b/ast/nasal_new_codegen.h
@@ -75,6 +75,8 @@ private:
     void multi_def(definition_expr*);
     void single_def(definition_expr*);
     void def_gen(definition_expr*);
+    void assignment_gen(assignment_expr*);
+    void assign_statement(assignment_expr*);
     void multi_assign_gen(multi_assign*);
     void cond_gen(condition_expr*);
     void loop_gen(expr*);
@@ -86,6 +88,8 @@ private:
     void foreach_gen(forei_expr*);
     void or_gen(binary_operator*);
     void and_gen(binary_operator*);
+    void unary_gen(unary_operator*);
+    void binary_gen(binary_operator*);
     void trino_gen(ternary_operator*);
     void calc_gen(expr*);
     void block_gen(code_block*);
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index bb62a69..fd680c7 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -401,12 +401,12 @@ expr* parse::calc() {
     } else if (tok::eq<=toks[ptr].type && toks[ptr].type<=tok::lnkeq) {
         auto tmp = new assignment_expr(toks[ptr].loc);
         switch(toks[ptr].type) {
-            case tok::eq: tmp->set_type(assignment_expr::assign_type::equal); break;
-            case tok::addeq: tmp->set_type(assignment_expr::assign_type::add_equal); break;
-            case tok::subeq: tmp->set_type(assignment_expr::assign_type::sub_equal); break;
-            case tok::multeq: tmp->set_type(assignment_expr::assign_type::mult_equal); break;
-            case tok::diveq: tmp->set_type(assignment_expr::assign_type::div_equal); break;
-            case tok::lnkeq: tmp->set_type(assignment_expr::assign_type::concat_equal); break;
+            case tok::eq: tmp->set_assignment_type(assignment_expr::assign_type::equal); break;
+            case tok::addeq: tmp->set_assignment_type(assignment_expr::assign_type::add_equal); break;
+            case tok::subeq: tmp->set_assignment_type(assignment_expr::assign_type::sub_equal); break;
+            case tok::multeq: tmp->set_assignment_type(assignment_expr::assign_type::mult_equal); break;
+            case tok::diveq: tmp->set_assignment_type(assignment_expr::assign_type::div_equal); break;
+            case tok::lnkeq: tmp->set_assignment_type(assignment_expr::assign_type::concat_equal); break;
             default: break;
         }
         tmp->set_left(node);
@@ -416,9 +416,9 @@ expr* parse::calc() {
     } else if (toks[ptr].type==tok::btandeq || toks[ptr].type==tok::btoreq || toks[ptr].type==tok::btxoreq) {
         auto tmp = new assignment_expr(toks[ptr].loc);
         switch(toks[ptr].type) {
-            case tok::btandeq: tmp->set_type(assignment_expr::assign_type::bitwise_and_equal); break;
-            case tok::btoreq: tmp->set_type(assignment_expr::assign_type::bitwise_or_equal); break;
-            case tok::btxoreq: tmp->set_type(assignment_expr::assign_type::bitwise_xor_equal); break;
+            case tok::btandeq: tmp->set_assignment_type(assignment_expr::assign_type::bitwise_and_equal); break;
+            case tok::btoreq: tmp->set_assignment_type(assignment_expr::assign_type::bitwise_or_equal); break;
+            case tok::btxoreq: tmp->set_assignment_type(assignment_expr::assign_type::bitwise_xor_equal); break;
             default: break;
         }
         tmp->set_left(node);
@@ -434,7 +434,7 @@ expr* parse::bitwise_or() {
     auto node = bitwise_xor();
     while(lookahead(tok::btor)) {
         auto tmp = new binary_operator(toks[ptr].loc);
-        tmp->set_type(binary_operator::binary_type::bitwise_or);
+        tmp->set_operator_type(binary_operator::binary_type::bitwise_or);
         tmp->set_left(node);
         match(tok::btor);
         tmp->set_right(bitwise_xor());
@@ -449,7 +449,7 @@ expr* parse::bitwise_xor() {
     auto node = bitwise_and();
     while(lookahead(tok::btxor)) {
         auto tmp = new binary_operator(toks[ptr].loc);
-        tmp->set_type(binary_operator::binary_type::bitwise_xor);
+        tmp->set_operator_type(binary_operator::binary_type::bitwise_xor);
         tmp->set_left(node);
         match(tok::btxor);
         tmp->set_right(bitwise_and());
@@ -464,7 +464,7 @@ expr* parse::bitwise_and() {
     auto node = or_expr();
     while(lookahead(tok::btand)) {
         auto tmp = new binary_operator(toks[ptr].loc);
-        tmp->set_type(binary_operator::binary_type::bitwise_and);
+        tmp->set_operator_type(binary_operator::binary_type::bitwise_and);
         tmp->set_left(node);
         match(tok::btand);
         tmp->set_right(or_expr());
@@ -479,7 +479,7 @@ expr* parse::or_expr() {
     auto node = and_expr();
     while(lookahead(tok::opor)) {
         auto tmp = new binary_operator(toks[ptr].loc);
-        tmp->set_type(binary_operator::binary_type::condition_or);
+        tmp->set_operator_type(binary_operator::binary_type::condition_or);
         tmp->set_left(node);
         match(tok::opor);
         tmp->set_right(and_expr());
@@ -494,7 +494,7 @@ expr* parse::and_expr() {
     auto node = cmp_expr();
     while(lookahead(tok::opand)) {
         auto tmp = new binary_operator(toks[ptr].loc);
-        tmp->set_type(binary_operator::binary_type::condition_and);
+        tmp->set_operator_type(binary_operator::binary_type::condition_and);
         tmp->set_left(node);
         match(tok::opand);
         tmp->set_right(cmp_expr());
@@ -510,12 +510,12 @@ expr* parse::cmp_expr() {
     while(tok::cmpeq<=toks[ptr].type && toks[ptr].type<=tok::geq) {
         auto tmp = new binary_operator(toks[ptr].loc);
         switch(toks[ptr].type) {
-            case tok::cmpeq: tmp->set_type(binary_operator::binary_type::cmpeq); break;
-            case tok::neq: tmp->set_type(binary_operator::binary_type::cmpneq); break;
-            case tok::less: tmp->set_type(binary_operator::binary_type::less); break;
-            case tok::leq: tmp->set_type(binary_operator::binary_type::leq); break;
-            case tok::grt: tmp->set_type(binary_operator::binary_type::grt); break;
-            case tok::geq: tmp->set_type(binary_operator::binary_type::geq); break;
+            case tok::cmpeq: tmp->set_operator_type(binary_operator::binary_type::cmpeq); break;
+            case tok::neq: tmp->set_operator_type(binary_operator::binary_type::cmpneq); break;
+            case tok::less: tmp->set_operator_type(binary_operator::binary_type::less); break;
+            case tok::leq: tmp->set_operator_type(binary_operator::binary_type::leq); break;
+            case tok::grt: tmp->set_operator_type(binary_operator::binary_type::grt); break;
+            case tok::geq: tmp->set_operator_type(binary_operator::binary_type::geq); break;
             default: break;
         }
         tmp->set_left(node);
@@ -533,9 +533,9 @@ expr* parse::additive_expr() {
     while(lookahead(tok::add) || lookahead(tok::sub) || lookahead(tok::floater)) {
         auto tmp = new binary_operator(toks[ptr].loc);
         switch(toks[ptr].type) {
-            case tok::add: tmp->set_type(binary_operator::binary_type::add); break;
-            case tok::sub: tmp->set_type(binary_operator::binary_type::sub); break;
-            case tok::floater: tmp->set_type(binary_operator::binary_type::concat); break;
+            case tok::add: tmp->set_operator_type(binary_operator::binary_type::add); break;
+            case tok::sub: tmp->set_operator_type(binary_operator::binary_type::sub); break;
+            case tok::floater: tmp->set_operator_type(binary_operator::binary_type::concat); break;
             default: break;
         }
         tmp->set_left(node);
@@ -553,9 +553,9 @@ expr* parse::multive_expr() {
     while(lookahead(tok::mult) || lookahead(tok::div)) {
         auto tmp = new binary_operator(toks[ptr].loc);
         if (lookahead(tok::mult)) {
-            tmp->set_type(binary_operator::binary_type::mult);
+            tmp->set_operator_type(binary_operator::binary_type::mult);
         } else {
-            tmp->set_type(binary_operator::binary_type::div);
+            tmp->set_operator_type(binary_operator::binary_type::div);
         }
         tmp->set_left(node);
         match(toks[ptr].type);
@@ -571,15 +571,15 @@ unary_operator* parse::unary() {
     auto node = new unary_operator(toks[ptr].loc);
     switch(toks[ptr].type) {
         case tok::sub:
-            node->set_type(unary_operator::unary_type::negative);
+            node->set_operator_type(unary_operator::unary_type::negative);
             match(tok::sub);
             break;
         case tok::opnot:
-            node->set_type(unary_operator::unary_type::logical_not);
+            node->set_operator_type(unary_operator::unary_type::logical_not);
             match(tok::opnot);
             break;
         case tok::floater:
-            node->set_type(unary_operator::unary_type::bitwise_not);
+            node->set_operator_type(unary_operator::unary_type::bitwise_not);
             match(tok::floater);
             break;
         default: break;
diff --git a/test/httptest.nas b/test/httptest.nas
index 68a0437..f3f66f7 100644
--- a/test/httptest.nas
+++ b/test/httptest.nas
@@ -5,9 +5,10 @@ var http=func(){
     return {
         establish:func(ip,port){
             sd=socket.socket(socket.AF_INET,socket.SOCK_STREAM,socket.IPPROTO_IP);
-            if(socket.bind(sd,ip,port)<0){
-                println("failed to bind socket "~sd~" at IP: "~ip~" port: "~port~".");
-                return;
+            while(socket.bind(sd,ip,port)<0){
+                println("[",os.time(),"] failed to bind socket "~sd~" at IP: "~ip~" port: "~port~".");
+                unix.sleep(5);
+                println("[",os.time(),"] retrying...");
             }
             socket.listen(sd,1);
             println("[",os.time(),"] start server at [",ip,":",port,"]");

From b6886cc95702fe5f865a6a1eb7ec456278e69fbe Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sat, 1 Jul 2023 16:38:37 +0800
Subject: [PATCH 25/34] :sparkles: finish new codegen

---
 ast/nasal_new_codegen.cpp |  160 ++++--
 ast/nasal_new_codegen.h   |    2 +-
 ast/nasal_new_dbg.cpp     |  235 ++++++++
 ast/nasal_new_dbg.h       |   87 +++
 ast/nasal_new_main.cpp    |   34 +-
 ast/nasal_new_opcode.cpp  |   25 +
 ast/nasal_new_opcode.h    |   29 +-
 ast/nasal_new_vm.cpp      | 1129 +++++++++++++++++++++++++++++++++++++
 ast/nasal_new_vm.h        |  159 ++++++
 makefile                  |   10 +-
 10 files changed, 1773 insertions(+), 97 deletions(-)
 create mode 100644 ast/nasal_new_dbg.cpp
 create mode 100644 ast/nasal_new_dbg.h
 create mode 100644 ast/nasal_new_vm.cpp
 create mode 100644 ast/nasal_new_vm.h

diff --git a/ast/nasal_new_codegen.cpp b/ast/nasal_new_codegen.cpp
index 984b72a..ea80e20 100644
--- a/ast/nasal_new_codegen.cpp
+++ b/ast/nasal_new_codegen.cpp
@@ -1,8 +1,8 @@
 #include "nasal_new_codegen.h"
 
-bool codegen::check_memory_reachable(call_expr* node) {
-    if (node->get_first()->get_type()==expr_type::ast_call) {
-        const auto tmp=node->get_calls().back();
+bool codegen::check_memory_reachable(expr* node) {
+    if (node->get_type()==expr_type::ast_call) {
+        const auto tmp=((call_expr*)node)->get_calls().back();
         if (tmp->get_type()==expr_type::ast_callf) {
             die("bad left-value with function call", node->get_location());
             return false;
@@ -13,7 +13,7 @@ bool codegen::check_memory_reachable(call_expr* node) {
             die("bad left-value with subvec", node->get_location());
             return false;
         }
-    } else if (node->get_first()->get_type()!=expr_type::ast_id) {
+    } else if (node->get_type()!=expr_type::ast_id) {
         die("bad left-value", node->get_location());
         return false;
     }
@@ -441,40 +441,127 @@ void codegen::assignment_gen(assignment_expr* node) {
             gen(op_meq, 0, node->get_location().begin_line);
             break;
         case assignment_expr::assign_type::add_equal:
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+            }
+            mcall((call_expr*)node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                gen(op_addeq, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_addeqc, num_table[num], node->get_location().begin_line);
+            }
+            break;
         case assignment_expr::assign_type::sub_equal:
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+            }
+            mcall((call_expr*)node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                gen(op_subeq, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_subeqc, num_table[num], node->get_location().begin_line);
+            }
+            break;
         case assignment_expr::assign_type::mult_equal:
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                calc_gen(node->get_right());
+            }
+            mcall((call_expr*)node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_num) {
+                gen(op_muleq, 0, node->get_location().begin_line);
+            } else {
+                auto num = ((number_literal*)node->get_right())->get_number();
+                regist_num(num);
+                gen(op_muleqc, num_table[num], node->get_location().begin_line);
+            }
+            break;
         case assignment_expr::assign_type::div_equal:
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
             }
             mcall((call_expr*)node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
-                gen(node->get_type()-ast_addeq+op_addeq, 0, node->get_location().begin_line);
+                gen(op_diveq, 0, node->get_location().begin_line);
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(node->get_type()-ast_addeq+op_addeqc, num_table[num], node->get_location().begin_line);
+                gen(op_diveqc, num_table[num], node->get_location().begin_line);
             }
             break;
         case assignment_expr::assign_type::concat_equal:
-            if (node[1]->get_type()!=ast_str) {
-                calc_gen(node[1]);
-            } else {
-                regist_str(node[1].str());
+            if (node->get_right()->get_type()!=expr_type::ast_str) {
+                calc_gen(node->get_right());
             }
-            mcall(node[0]);
-            if (node[1]->get_type()!=ast_str) {
+            mcall((call_expr*)node->get_left());
+            if (node->get_right()->get_type()!=expr_type::ast_str) {
                 gen(op_lnkeq, 0, node->get_location().begin_line);
             } else {
-                gen(op_lnkeqc, str_table[node[1].str()], node->get_location().begin_line);
+                const auto& str = ((string_literal*)node->get_right())->get_content();
+                regist_str(str);
+                gen(op_lnkeqc, str_table[str], node->get_location().begin_line);
             }
             break;
         case assignment_expr::assign_type::bitwise_and_equal:
+            calc_gen(node->get_right());
+            mcall((call_expr*)node->get_left());
+            gen(op_btandeq, 0, node->get_location().begin_line);
+            break;
         case assignment_expr::assign_type::bitwise_or_equal:
+            calc_gen(node->get_right());
+            mcall((call_expr*)node->get_left());
+            gen(op_btoreq, 0, node->get_location().begin_line);
+            break;
         case assignment_expr::assign_type::bitwise_xor_equal:
             calc_gen(node->get_right());
             mcall((call_expr*)node->get_left());
-            gen(node->get_type()-ast_btandeq+op_btandeq, 0, node->get_location().begin_line);
+            gen(op_btxoreq, 0, node->get_location().begin_line);
+            break;
+    }
+}
+
+void codegen::assign_statement(assignment_expr* node) {
+    switch(node->get_assignment_type()) {
+        case assignment_expr::assign_type::equal:
+            if (node->get_left()->get_type()==expr_type::ast_id) {
+                calc_gen(node->get_right());
+                mcall_id((identifier*)node->get_left());
+                // only the first mcall_id can use load
+                if (code.back().op==op_mcalll) {
+                    code.back().op=op_loadl;
+                } else if (code.back().op==op_mupval) {
+                    code.back().op=op_loadu;
+                } else {
+                    code.back().op=op_loadg;
+                }
+            } else {
+                calc_gen(node);
+                if (code.back().op==op_meq) {
+                    code.back().num=1;
+                } else {
+                    gen(op_pop, 0, node->get_location().begin_line);
+                }
+            }
+            break;
+        case assignment_expr::assign_type::add_equal:
+        case assignment_expr::assign_type::sub_equal:
+        case assignment_expr::assign_type::mult_equal:
+        case assignment_expr::assign_type::div_equal:
+        case assignment_expr::assign_type::concat_equal:
+        case assignment_expr::assign_type::bitwise_and_equal:
+        case assignment_expr::assign_type::bitwise_or_equal:
+        case assignment_expr::assign_type::bitwise_xor_equal:
+            calc_gen(node);
+            if (op_addeq<=code.back().op && code.back().op<=op_btxoreq) {
+                code.back().num=1;
+            } else if (op_addeqc<=code.back().op && code.back().op<=op_lnkeqc) {
+                code.back().op=code.back().op-op_addeqc+op_addecp;
+            } else {
+                gen(op_pop, 0, node->get_location().begin_line);
+            }
             break;
     }
 }
@@ -624,50 +711,21 @@ void codegen::expr_gen(expr* node) {
     switch(node->get_type()) {
         case expr_type::ast_null:break;
         case expr_type::ast_def:
-            def_gen((definition_expr*)node);break;
+            def_gen((definition_expr*)node); break;
         case expr_type::ast_multi_assign:
-            multi_assign_gen((multi_assign*)node);break;
-        case expr_type::ast_nil:case expr_type::ast_num:case expr_type::ast_str:case expr_type::ast_bool:break;
-        case expr_type::ast_vec:case expr_type::ast_hash:case expr_type::ast_func:case expr_type::ast_call:
+            multi_assign_gen((multi_assign*)node); break;
+        case expr_type::ast_nil:case expr_type::ast_num:
+        case expr_type::ast_str:case expr_type::ast_bool:break;
+        case expr_type::ast_vec:case expr_type::ast_hash:
+        case expr_type::ast_func:case expr_type::ast_call:
         case expr_type::ast_unary:
         case expr_type::ast_binary:
         case expr_type::ast_ternary:
             calc_gen(node);
             gen(op_pop, 0, node->get_location().begin_line);
             break;
-        case expr_type::ast_equal:
-            if (node[0]->get_type()==expr_type::ast_id) {
-                calc_gen(node[1]);
-                mcall_id(node[0]);
-                // only the first mcall_id can use load
-                if (code.back().op==op_mcalll) {
-                    code.back().op=op_loadl;
-                } else if (code.back().op==op_mupval) {
-                    code.back().op=op_loadu;
-                } else {
-                    code.back().op=op_loadg;
-                }
-            } else {
-                calc_gen(node);
-                if (code.back().op==op_meq) {
-                    code.back().num=1;
-                } else {
-                    gen(op_pop, 0, node->get_location().begin_line);
-                }
-            }
-            break;
-        case expr_type::ast_addeq:case expr_type::ast_subeq:
-        case expr_type::ast_multeq:case expr_type::ast_diveq:case expr_type::ast_lnkeq:
-        case expr_type::ast_btandeq:case expr_type::ast_btoreq:case expr_type::ast_btxoreq:
-            calc_gen(node);
-            if (op_addeq<=code.back().op && code.back().op<=op_btxoreq) {
-                code.back().num=1;
-            } else if (op_addeqc<=code.back().op && code.back().op<=op_lnkeqc) {
-                code.back().op=code.back().op-op_addeqc+op_addecp;
-            } else {
-                gen(op_pop, 0, node->get_location().begin_line);
-            }
-            break;
+        case expr_type::ast_assign:
+            assign_statement((assignment_expr*)node); break;
     }
 }
 
diff --git a/ast/nasal_new_codegen.h b/ast/nasal_new_codegen.h
index 40fd3c6..bc398fa 100644
--- a/ast/nasal_new_codegen.h
+++ b/ast/nasal_new_codegen.h
@@ -40,7 +40,7 @@ private:
     // but in fact local scope also has less than STACK_DEPTH value
     std::list<std::unordered_map<std::string,i32>> local;
 
-    bool check_memory_reachable(call_expr*);
+    bool check_memory_reachable(expr*);
     void check_id_exist(identifier*);
     
     void die(const std::string& info, const span& loc) {
diff --git a/ast/nasal_new_dbg.cpp b/ast/nasal_new_dbg.cpp
new file mode 100644
index 0000000..182df43
--- /dev/null
+++ b/ast/nasal_new_dbg.cpp
@@ -0,0 +1,235 @@
+#include "nasal_new_dbg.h"
+
+std::vector<std::string> dbg::parse(const std::string& cmd) {
+    std::vector<std::string> res;
+    usize last=0;
+    usize pos=cmd.find(" ", 0);
+    while(pos!=std::string::npos) {
+        if (pos>last) {
+            res.push_back(cmd.substr(last, pos-last));
+        }
+        last=pos+1;
+        pos=cmd.find(" ", last);
+    }
+    if (last<cmd.length()) {
+        res.push_back(cmd.substr(last));
+    }
+    return res;
+}
+
+u16 dbg::file_index(const std::string& filename) const {
+    for(u16 i=0;i<fsize;++i) {
+        if (filename==files[i]) {
+            return i;
+        }
+    }
+    return 65535;
+}
+
+void dbg::err() {
+    std::cerr
+    <<"incorrect command\n"
+    <<"input \'h\' to get help\n";
+}
+
+void dbg::help() {
+    std::clog
+    <<"<option>\n"
+    <<"  h,   help      | get help\n"
+    <<"  bt,  backtrace | get function call trace\n"
+    <<"  c,   continue  | run program until break point or exit\n"
+    <<"  f,   file      | see all the compiled files\n"
+    <<"  g,   global    | see global values\n"
+    <<"  l,   local     | see local values\n"
+    <<"  u,   upval     | see upvalue\n"
+    <<"  r,   register  | show vm register detail\n"
+    <<"  a,   all       | show global,local and upvalue\n"
+    <<"  n,   next      | execute next bytecode\n"
+    <<"  q,   exit      | exit debugger\n"
+    <<"<option> <filename> <line>\n"
+    <<"  bk,  break     | set break point\n";
+}
+
+void dbg::list_file() const {
+    for(usize i=0; i<fsize; ++i) {
+        std::clog<<"["<<i<<"] "<<files[i]<<"\n";
+    }
+}
+
+void dbg::call_sort(const u64* arr) const {
+    typedef std::pair<u32,u64> op;
+    std::vector<op> opcall;
+    u64 total=0;
+    for(u32 i=0;i<op_ret+1;++i) {
+        total+=arr[i];
+        opcall.push_back({i, arr[i]});
+    }
+    std::sort(opcall.begin(), opcall.end(),
+        [](const op& a, const op& b) {return a.second>b.second;}
+    );
+    std::clog<<"\noperands call info (<1% ignored)\n";
+    for(auto& i:opcall) {
+        u64 rate=i.second*100/total;
+        if (!rate) {
+            break;
+        }
+        std::clog<<" "<<opname[i.first]<<" : "<<i.second<<" ("<<rate<<"%)\n";
+    }
+    std::clog<<" total  : "<<total<<'\n';
+}
+
+void dbg::step_info() {
+    u32 line=bytecode[ctx.pc].line==0?0:bytecode[ctx.pc].line-1;
+    u32 begin=(line>>3)==0?0:((line>>3)<<3);
+    u32 end=(1+(line>>3))<<3;
+    src.load(files[bytecode[ctx.pc].fidx]);
+    std::clog<<"\nsource code:\n";
+    for(u32 i=begin;i<end && i<src.size();++i) {
+        std::clog<<(i==line?back_white:reset)<<(i==line?"--> ":"    ")<<src[i]<<reset<<"\n";
+    }
+
+    begin=(ctx.pc>>3)==0?0:((ctx.pc>>3)<<3);
+    end=(1+(ctx.pc>>3))<<3;
+    codestream::set(cnum, cstr, files);
+    std::clog<<"next bytecode:\n";
+    for(u32 i=begin;i<end && bytecode[i].op!=op_exit;++i) {
+        std::clog
+        <<(i==ctx.pc?back_white:reset)
+        <<(i==ctx.pc?"--> ":"    ")
+        <<codestream(bytecode[i], i)
+        <<reset<<"\n";
+    }
+    stackinfo(10);
+}
+
+void dbg::interact() {
+    // special operand, end execution
+    if (bytecode[ctx.pc].op==op_exit) {
+        return;
+    }
+    
+    if ((bytecode[ctx.pc].fidx!=bk_fidx ||
+        bytecode[ctx.pc].line!=bk_line) && // break point
+        !next) {// next step
+        return;
+    }
+
+    next=false;
+    std::string cmd;
+    step_info();
+    while(true) {
+        std::clog<<">> ";
+        std::getline(std::cin, cmd);
+        auto res=parse(cmd);
+        if (res.size()==0) {
+            step_info();
+        } else if (res.size()==1) {
+            switch(get_cmd_type(res[0])) {
+                case dbg_cmd::cmd_help: help(); break;
+                case dbg_cmd::cmd_backtrace: traceback(); break;
+                case dbg_cmd::cmd_continue: return;
+                case dbg_cmd::cmd_list_file: list_file(); break;
+                case dbg_cmd::cmd_global: gstate(); break;
+                case dbg_cmd::cmd_local: lstate(); break;
+                case dbg_cmd::cmd_upval: ustate(); break;
+                case dbg_cmd::cmd_register: reginfo(); break;
+                case dbg_cmd::cmd_show_all: detail(); break;
+                case dbg_cmd::cmd_next: next=true; return;
+                case dbg_cmd::cmd_exit: std::exit(0);
+                default: err(); break;
+            }
+        } else if (res.size()==3 &&
+            get_cmd_type(res[0])==dbg_cmd::cmd_break_point) {
+            bk_fidx=file_index(res[1]);
+            if (bk_fidx==65535) {
+                std::clog<<"cannot find file named `"<<res[1]<<"`\n";
+                continue;
+            }
+            i32 tmp=atoi(res[2].c_str());
+            if (tmp<=0) {
+                std::clog<<"incorrect line number `"<<res[2]<<"`\n";
+            } else {
+                bk_line=tmp;
+            }
+        } else {
+            err();
+        }
+    }
+}
+
+void dbg::run(
+    const codegen& gen,
+    const linker& linker,
+    const std::vector<std::string>& argv) {
+    verbose=true;
+    fsize=linker.filelist().size();
+    init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
+    u64 count[op_ret+1]={0};
+    typedef void (dbg::*nafunc)();
+    const nafunc oprs[]={
+        nullptr,        &dbg::o_intg,
+        &dbg::o_intl,   &dbg::o_loadg,
+        &dbg::o_loadl,  &dbg::o_loadu,
+        &dbg::o_pnum,   &dbg::o_pnil,
+        &dbg::o_pstr,   &dbg::o_newv,
+        &dbg::o_newh,   &dbg::o_newf,
+        &dbg::o_happ,   &dbg::o_para,
+        &dbg::o_deft,   &dbg::o_dyn,
+        &dbg::o_lnot,   &dbg::o_usub,
+        &dbg::o_bnot,   &dbg::o_btor,
+        &dbg::o_btxor,  &dbg::o_btand,
+        &dbg::o_add,    &dbg::o_sub,
+        &dbg::o_mul,    &dbg::o_div,
+        &dbg::o_lnk,    &dbg::o_addc,
+        &dbg::o_subc,   &dbg::o_mulc,
+        &dbg::o_divc,   &dbg::o_lnkc,
+        &dbg::o_addeq,  &dbg::o_subeq,
+        &dbg::o_muleq,  &dbg::o_diveq,
+        &dbg::o_lnkeq,  &dbg::o_bandeq,
+        &dbg::o_boreq,  &dbg::o_bxoreq,
+        &dbg::o_addeqc, &dbg::o_subeqc,
+        &dbg::o_muleqc, &dbg::o_diveqc,
+        &dbg::o_lnkeqc, &dbg::o_addecp,
+        &dbg::o_subecp, &dbg::o_mulecp,
+        &dbg::o_divecp, &dbg::o_lnkecp,
+        &dbg::o_meq,    &dbg::o_eq,
+        &dbg::o_neq,    &dbg::o_less,
+        &dbg::o_leq,    &dbg::o_grt,
+        &dbg::o_geq,    &dbg::o_lessc,
+        &dbg::o_leqc,   &dbg::o_grtc,
+        &dbg::o_geqc,   &dbg::o_pop,
+        &dbg::o_jmp,    &dbg::o_jt,
+        &dbg::o_jf,     &dbg::o_cnt,
+        &dbg::o_findex, &dbg::o_feach,
+        &dbg::o_callg,  &dbg::o_calll,
+        &dbg::o_upval,  &dbg::o_callv,
+        &dbg::o_callvi, &dbg::o_callh,
+        &dbg::o_callfv, &dbg::o_callfh,
+        &dbg::o_callb,  &dbg::o_slcbeg,
+        &dbg::o_slcend, &dbg::o_slc,
+        &dbg::o_slc2,   &dbg::o_mcallg,
+        &dbg::o_mcalll, &dbg::o_mupval,
+        &dbg::o_mcallv, &dbg::o_mcallh,
+        &dbg::o_ret
+    };
+    std::vector<u32> code;
+    for(auto& i:gen.codes()) {
+        code.push_back(i.op);
+        imm.push_back(i.num);
+    }
+    while(oprs[code[ctx.pc]]) {
+        interact();
+        ++count[code[ctx.pc]];
+        (this->*oprs[code[ctx.pc]])();
+        if (ctx.top>=ctx.canary) {
+            die("stack overflow");
+        }
+        ++ctx.pc;
+    }
+
+    call_sort(count);
+    ngc.info();
+    ngc.clear();
+    imm.clear();
+    return;
+}
diff --git a/ast/nasal_new_dbg.h b/ast/nasal_new_dbg.h
new file mode 100644
index 0000000..d05bc25
--- /dev/null
+++ b/ast/nasal_new_dbg.h
@@ -0,0 +1,87 @@
+#pragma once
+
+#include "nasal_new_import.h"
+#include "nasal_new_err.h"
+#include "nasal_new_opcode.h"
+#include "nasal_new_vm.h"
+
+#include <cstring>
+#include <algorithm>
+#include <unordered_map>
+
+class dbg:public vm {
+private:
+    enum class dbg_cmd {
+        cmd_error,
+        cmd_help,
+        cmd_backtrace,
+        cmd_continue,
+        cmd_list_file,
+        cmd_global,
+        cmd_local,
+        cmd_upval,
+        cmd_register,
+        cmd_show_all,
+        cmd_next,
+        cmd_break_point,
+        cmd_exit
+    };
+
+private:
+    const std::unordered_map<std::string, dbg_cmd> command_table = {
+        {"h", dbg_cmd::cmd_help},
+        {"help", dbg_cmd::cmd_help},
+        {"bt", dbg_cmd::cmd_backtrace},
+        {"backtrace", dbg_cmd::cmd_backtrace},
+        {"c", dbg_cmd::cmd_continue},
+        {"continue", dbg_cmd::cmd_continue},
+        {"f", dbg_cmd::cmd_list_file},
+        {"file", dbg_cmd::cmd_list_file},
+        {"g", dbg_cmd::cmd_global},
+        {"global", dbg_cmd::cmd_global},
+        {"l", dbg_cmd::cmd_local},
+        {"local", dbg_cmd::cmd_local},
+        {"u", dbg_cmd::cmd_upval},
+        {"upval", dbg_cmd::cmd_upval},
+        {"r", dbg_cmd::cmd_register},
+        {"register", dbg_cmd::cmd_register},
+        {"a", dbg_cmd::cmd_show_all},
+        {"all", dbg_cmd::cmd_show_all},
+        {"n", dbg_cmd::cmd_next},
+        {"next", dbg_cmd::cmd_next},
+        {"bk", dbg_cmd::cmd_break_point},
+        {"break", dbg_cmd::cmd_break_point},
+        {"q", dbg_cmd::cmd_exit},
+        {"exit", dbg_cmd::cmd_exit}
+    };
+    dbg_cmd get_cmd_type(const std::string& cmd) const {
+        return command_table.count(cmd)?
+            command_table.at(cmd):dbg_cmd::cmd_error;
+    }
+
+private:
+    bool  next;
+    usize fsize;
+    u16   bk_fidx;
+    u32   bk_line;
+    error& src;
+
+    std::vector<std::string> parse(const std::string&);
+    u16 file_index(const std::string&) const;
+    void err();
+    void help();
+    void list_file() const;
+    void call_sort(const u64*) const;
+    void step_info();
+    void interact();
+public:
+    dbg(error& err):
+        next(false), fsize(0),
+        bk_fidx(0), bk_line(0),
+        src(err) {}
+    void run(
+        const codegen&,
+        const linker&,
+        const std::vector<std::string>&
+    );
+};
diff --git a/ast/nasal_new_main.cpp b/ast/nasal_new_main.cpp
index 1a2aeaf..94196ad 100644
--- a/ast/nasal_new_main.cpp
+++ b/ast/nasal_new_main.cpp
@@ -8,6 +8,9 @@
 #include "ast_dumper.h"
 #include "symbol_finder.h"
 #include "optimizer.h"
+#include "nasal_new_codegen.h"
+#include "nasal_new_vm.h"
+#include "nasal_new_dbg.h"
 
 #include <unordered_map>
 #include <thread>
@@ -73,8 +76,8 @@ void err() {
 void execute(
     const std::string& file,
     const std::vector<std::string>& argv,
-    const u32 cmd
-) {
+    const u32 cmd) {
+
     using clk=std::chrono::high_resolution_clock;
     const auto den=clk::duration::period::den;
 
@@ -82,8 +85,8 @@ void execute(
     lexer   lex(err);
     parse   parse(err);
     linker  ld(err);
-    // codegen gen(err);
-    // vm      ctx;
+    codegen gen(err);
+    vm      ctx;
 
     // lexer scans file to get tokens
     lex.scan(file).chkerr();
@@ -103,24 +106,19 @@ void execute(
     opt->do_optimization(parse.tree());
     delete opt;
 
-    auto finder = new symbol_finder;
-    for(const auto& symbol : finder->do_find(parse.tree())) {
-        std::cout << symbol << std::endl;
-    }
-
     // code generator gets parser's ast and import file list to generate code
-    // gen.compile(parse, ld).chkerr();
-    // if (cmd&VM_CODE) {
-    //     gen.print();
-    // }
+    gen.compile(parse, ld).chkerr();
+    if (cmd&VM_CODE) {
+        gen.print();
+    }
 
     // run
     auto start=clk::now();
-    // if (cmd&VM_DEBUG) {
-    //     dbg(err).run(gen, ld, argv);
-    // } else if (cmd&VM_TIME || cmd&VM_EXEC) {
-    //     ctx.run(gen, ld, argv, cmd&VM_DETAIL);
-    // }
+    if (cmd&VM_DEBUG) {
+        dbg(err).run(gen, ld, argv);
+    } else if (cmd&VM_TIME || cmd&VM_EXEC) {
+        ctx.run(gen, ld, argv, cmd&VM_DETAIL);
+    }
 
     // get running time
     if (cmd&VM_TIME) {
diff --git a/ast/nasal_new_opcode.cpp b/ast/nasal_new_opcode.cpp
index 6004308..d5f66b1 100644
--- a/ast/nasal_new_opcode.cpp
+++ b/ast/nasal_new_opcode.cpp
@@ -1,5 +1,30 @@
 #include "nasal_new_opcode.h"
 
+const char* opname[]={
+    "exit  ","intg  ","intl  ","loadg ",
+    "loadl ","loadu ","pnum  ","pnil  ",
+    "pstr  ","newv  ","newh  ","newf  ",
+    "happ  ","para  ","def   ","dyn   ",
+    "lnot  ","usub  ","bnot  ","btor  ",
+    "btxor ","btand ","add   ","sub   ",
+    "mult  ","div   ","lnk   ","addc  ",
+    "subc  ","multc ","divc  ","lnkc  ",
+    "addeq ","subeq ","muleq ","diveq ",
+    "lnkeq ","bandeq","boreq ","bxoreq",
+    "addeqc","subeqc","muleqc","diveqc",
+    "lnkeqc","addecp","subecp","mulecp",
+    "divecp","lnkecp","meq   ","eq    ",
+    "neq   ","less  ","leq   ","grt   ",
+    "geq   ","lessc ","leqc  ","grtc  ",
+    "geqc  ","pop   ","jmp   ","jt    ",
+    "jf    ","cnt   ","findx ","feach ",
+    "callg ","calll ","upval ","callv ",
+    "callvi","callh ","callfv","callfh",
+    "callb ","slcbeg","slcend","slc   ",
+    "slc2  ","mcallg","mcalll","mupval",
+    "mcallv","mcallh","ret   "
+};
+
 void codestream::set(
     const f64* numbuff,
     const std::string* strbuff,
diff --git a/ast/nasal_new_opcode.h b/ast/nasal_new_opcode.h
index c34d831..7b0e966 100644
--- a/ast/nasal_new_opcode.h
+++ b/ast/nasal_new_opcode.h
@@ -95,31 +95,6 @@ enum op_code_type:u8 {
     op_ret     // return
 };
 
-const char* opname[]={
-    "exit  ","intg  ","intl  ","loadg ",
-    "loadl ","loadu ","pnum  ","pnil  ",
-    "pstr  ","newv  ","newh  ","newf  ",
-    "happ  ","para  ","def   ","dyn   ",
-    "lnot  ","usub  ","bnot  ","btor  ",
-    "btxor ","btand ","add   ","sub   ",
-    "mult  ","div   ","lnk   ","addc  ",
-    "subc  ","multc ","divc  ","lnkc  ",
-    "addeq ","subeq ","muleq ","diveq ",
-    "lnkeq ","bandeq","boreq ","bxoreq",
-    "addeqc","subeqc","muleqc","diveqc",
-    "lnkeqc","addecp","subecp","mulecp",
-    "divecp","lnkecp","meq   ","eq    ",
-    "neq   ","less  ","leq   ","grt   ",
-    "geq   ","lessc ","leqc  ","grtc  ",
-    "geqc  ","pop   ","jmp   ","jt    ",
-    "jf    ","cnt   ","findx ","feach ",
-    "callg ","calll ","upval ","callv ",
-    "callvi","callh ","callfv","callfh",
-    "callb ","slcbeg","slcend","slc   ",
-    "slc2  ","mcallg","mcalll","mupval",
-    "mcallv","mcallh","ret   "
-};
-
 struct opcode {
     u8  op;   // opcode
     u16 fidx; // source code file index
@@ -143,4 +118,6 @@ public:
     void dump(std::ostream&) const;
 };
 
-std::ostream& operator<<(std::ostream&, const codestream&);
\ No newline at end of file
+std::ostream& operator<<(std::ostream&, const codestream&);
+
+extern const char* opname[];
\ No newline at end of file
diff --git a/ast/nasal_new_vm.cpp b/ast/nasal_new_vm.cpp
new file mode 100644
index 0000000..639712a
--- /dev/null
+++ b/ast/nasal_new_vm.cpp
@@ -0,0 +1,1129 @@
+#include "nasal_new_vm.h"
+
+void vm::init(
+    const std::vector<std::string>& strs,
+    const std::vector<f64>&    nums,
+    const std::vector<opcode>& code,
+    const std::vector<std::string>& filenames,
+    const std::vector<std::string>& argv
+) {
+    cnum=nums.data();
+    cstr=strs.data();
+    bytecode=code.data();
+    files=filenames.data();
+
+    /* set canary and program counter */
+    ctx.pc=0;
+    ctx.localr=ctx.memr=nullptr;
+    ctx.funcr=ctx.upvalr=nil;
+    ctx.canary=stack+STACK_DEPTH-1; // stack[STACK_DEPTH-1]
+    ctx.top=stack;
+    ctx.stack=stack;
+
+    /* clear main stack */
+    for(u32 i=0;i<STACK_DEPTH;++i) {
+        stack[i]=nil;
+    }
+
+    /* init gc */
+    ngc.init(strs,argv);
+}
+
+void vm::valinfo(var& val) {
+    const nas_val* p=val.val.gcobj;
+    switch(val.type) {
+        case vm_none: std::clog<<"| null |";break;
+        case vm_ret:  std::clog<<"| pc   | 0x"<<std::hex
+                               <<val.ret()<<std::dec;break;
+        case vm_addr: std::clog<<"| addr | 0x"<<std::hex
+                               <<(u64)val.addr()<<std::dec;break;
+        case vm_cnt:  std::clog<<"| cnt  | "<<val.cnt();break;
+        case vm_nil:  std::clog<<"| nil  |";break;
+        case vm_num:  std::clog<<"| num  | "<<val.num();break;
+        case vm_str:  std::clog<<"| str  | <0x"<<std::hex<<(u64)p
+                               <<"> "<<rawstr(val.str(),16)<<std::dec;break;
+        case vm_func: std::clog<<"| func | <0x"<<std::hex<<(u64)p
+                               <<"> entry:0x"<<val.func().entry
+                               <<std::dec;break;
+        case vm_upval:std::clog<<"| upval| <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> ["<<val.upval().size
+                               <<" val]";break;
+        case vm_vec:  std::clog<<"| vec  | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> ["<<val.vec().size()
+                               <<" val]";break;
+        case vm_hash: std::clog<<"| hash | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> {"<<val.hash().size()
+                               <<" val}";break;
+        case vm_obj:  std::clog<<"| obj  | <0x"<<std::hex<<(u64)p
+                               <<"> obj:0x"<<(u64)val.obj().ptr
+                               <<std::dec;break;
+        case vm_co:   std::clog<<"| co   | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> coroutine";break;
+        default:      std::clog<<"| err  | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> unknown object";break;
+    }
+    std::clog<<"\n";
+}
+
+void vm::traceback() {
+    /* bytecode[0].num is the global size */
+    var* bottom=ngc.rctx->stack==stack?stack+bytecode[0].num:ngc.rctx->stack;
+    var* ctx_top=ngc.rctx->stack==stack?ctx.top:ngc.rctx->top;
+    std::stack<u32> ret;
+    for(var* i=bottom;i<=ctx_top;++i) {
+        if (i->type==vm_ret && i->ret()!=0) {
+            ret.push(i->ret());
+        }
+    }
+    ret.push(ctx.pc); // store the position program crashed
+    std::clog<<"trace back ("<<(ngc.rctx->stack==stack?"main":"coroutine")<<")\n";
+    codestream::set(cnum, cstr, files);
+    for(u32 p=0,same=0,prev=0xffffffff;!ret.empty();prev=p,ret.pop()) {
+        if ((p=ret.top())==prev) {
+            ++same;
+            continue;
+        }
+        if (same) {
+            std::clog
+            <<"  0x"<<std::hex<<std::setw(6)<<std::setfill('0')
+            <<prev<<std::dec<<"     "<<same<<" same call(s)\n";
+        }
+        same=0;
+        std::clog<<"  "<<codestream(bytecode[p],p)<<"\n";
+    }
+    // the first called place has no same calls
+}
+
+void vm::stackinfo(const u32 limit=10) {
+    /* bytecode[0].num is the global size */
+    const u32 gsize=ngc.rctx->stack==stack?bytecode[0].num:0;
+    var* t=ctx.top;
+    var* bottom=ngc.rctx->stack+gsize;
+    std::clog<<"stack (0x"<<std::hex<<(u64)bottom<<std::dec
+             <<" <+"<<gsize<<">, limit "<<limit<<", total "
+             <<(t<bottom? 0:(i64)(t-bottom+1))<<")\n";
+    for(u32 i=0;i<limit && t>=bottom;++i,--t) {
+        std::clog<<"  0x"<<std::hex
+                 <<std::setw(6)<<std::setfill('0')
+                 <<(u64)(t-ngc.rctx->stack)<<std::dec
+                 <<"    ";
+        valinfo(t[0]);
+    }
+}
+
+void vm::reginfo() {
+    std::clog<<"registers ("<<(ngc.cort?"coroutine":"main")<<")\n"<<std::hex
+             <<"  [pc    ]    | pc   | 0x"<<ctx.pc<<"\n"
+             <<"  [global]    | addr | 0x"<<(u64)stack<<"\n"
+             <<"  [local ]    | addr | 0x"<<(u64)ctx.localr<<"\n"
+             <<"  [memr  ]    | addr | 0x"<<(u64)ctx.memr<<"\n"
+             <<"  [canary]    | addr | 0x"<<(u64)ctx.canary<<"\n"
+             <<"  [top   ]    | addr | 0x"<<(u64)ctx.top<<"\n"
+             <<std::dec;
+    std::clog<<"  [funcr ]    ";valinfo(ctx.funcr);
+    std::clog<<"  [upval ]    ";valinfo(ctx.upvalr);
+}
+
+void vm::gstate() {
+    if (!bytecode[0].num || stack[0].type==vm_none) { // bytecode[0].op is op_intg
+        return;
+    }
+    std::clog<<"global (0x"<<std::hex<<(u64)stack<<" <+0>)\n"<<std::dec;
+    for(u32 i=0;i<bytecode[0].num;++i) {
+        std::clog<<"  0x"<<std::hex<<std::setw(6)
+                 <<std::setfill('0')<<i<<std::dec
+                 <<"    ";
+        valinfo(stack[i]);
+    }
+}
+
+void vm::lstate() {
+    if (!ctx.localr || !ctx.funcr.func().lsize) {
+        return;
+    }
+    const u32 lsize=ctx.funcr.func().lsize;
+    std::clog<<"local (0x"<<std::hex<<(u64)ctx.localr
+             <<" <+"<<(u64)(ctx.localr-ngc.rctx->stack)<<">)\n"<<std::dec;
+    for(u32 i=0;i<lsize;++i) {
+        std::clog<<"  0x"<<std::hex<<std::setw(6)
+                 <<std::setfill('0')<<i<<std::dec
+                 <<"    ";
+        valinfo(ctx.localr[i]);
+    }
+}
+
+void vm::ustate() {
+    if (ctx.funcr.type==vm_nil || ctx.funcr.func().upval.empty()) {
+        return;
+    }
+    std::clog<<"upvalue\n";
+    auto& upval=ctx.funcr.func().upval;
+    for(u32 i=0;i<upval.size();++i) {
+        std::clog<<"  -> upval["<<i<<"]:\n";
+        auto& uv=upval[i].upval();
+        for(u32 j=0;j<uv.size;++j) {
+            std::clog<<"     0x"<<std::hex<<std::setw(6)
+                     <<std::setfill('0')<<j<<std::dec
+                     <<" ";
+            valinfo(uv[j]);
+        }
+    }
+}
+
+void vm::detail() {
+    reginfo();
+    gstate();
+    lstate();
+    ustate();
+}
+
+void vm::die(const std::string& str) {
+    std::cerr<<"[vm] error: "<<str<<"\n";
+    traceback();
+    stackinfo();
+
+    // show verbose crash info
+    if (verbose) {
+        detail();
+    }
+
+    if (ngc.rctx->stack==stack) { // in main context, exit directly
+        std::exit(1);
+    } else { // in coroutine, shut down the coroutine and return to main context
+        ctx.pc=0; // mark coroutine 'dead'
+        ngc.ctxreserve();
+        ctx.top[0]=nil;
+    }
+}
+
+inline bool vm::cond(var& val) {
+    if (val.type==vm_num) {
+        return val.num();
+    } else if (val.type==vm_str) {
+        const f64 num=str2num(val.str().c_str());
+        return std::isnan(num)? !val.str().empty():num;
+    }
+    return false;
+}
+
+void vm::o_intg() {
+    // global values store on stack
+    ctx.top+=imm[ctx.pc];
+    --ctx.top;// point to the top
+}
+
+void vm::o_intl() {
+    ctx.top[0].func().local.resize(imm[ctx.pc], nil);
+    ctx.top[0].func().lsize=imm[ctx.pc];
+}
+
+void vm::o_loadg() {
+    stack[imm[ctx.pc]]=(ctx.top--)[0];
+}
+
+void vm::o_loadl() {
+    ctx.localr[imm[ctx.pc]]=(ctx.top--)[0];
+}
+
+void vm::o_loadu() {
+    ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff]
+         .upval()[imm[ctx.pc]&0xffff]=(ctx.top--)[0];
+}
+
+void vm::o_pnum() {
+    (++ctx.top)[0]=var::num(cnum[imm[ctx.pc]]);
+}
+
+void vm::o_pnil() {
+    (++ctx.top)[0]=nil;
+}
+
+void vm::o_pstr() {
+    (++ctx.top)[0]=ngc.strs[imm[ctx.pc]];
+}
+
+void vm::o_newv() {
+    var newv=ngc.alloc(vm_vec);
+    auto& vec=newv.vec().elems;
+    vec.resize(imm[ctx.pc]);
+    // use top-=imm[pc]-1 here will cause error if imm[pc] is 0
+    ctx.top=ctx.top-imm[ctx.pc]+1;
+    for(u32 i=0;i<imm[ctx.pc];++i) {
+        vec[i]=ctx.top[i];
+    }
+    ctx.top[0]=newv;
+}
+
+void vm::o_newh() {
+    (++ctx.top)[0]=ngc.alloc(vm_hash);
+}
+
+void vm::o_newf() {
+    (++ctx.top)[0]=ngc.alloc(vm_func);
+    nas_func& func=ctx.top[0].func();
+    func.entry=imm[ctx.pc];
+    func.psize=1;
+
+    /* this means you create a new function in local scope */
+    if (ctx.localr) {
+        func.upval=ctx.funcr.func().upval;
+        // function created in the same local scope shares one closure
+        // so this size & stk setting has no problem
+        var upval=(ctx.upvalr.type==vm_nil)?ngc.alloc(vm_upval):ctx.upvalr;
+        upval.upval().size=ctx.funcr.func().lsize;
+        upval.upval().stk=ctx.localr;
+        func.upval.push_back(upval);
+        ctx.upvalr=upval;
+    }
+}
+
+void vm::o_happ() {
+    ctx.top[-1].hash().elems[cstr[imm[ctx.pc]]]=ctx.top[0];
+    --ctx.top;
+}
+
+void vm::o_para() {
+    nas_func& func=ctx.top[0].func();
+    // func->size has 1 place reserved for "me"
+    func.keys[imm[ctx.pc]]=func.psize;
+    func.local[func.psize++]=var::none();
+}
+
+void vm::o_deft() {
+    var val=ctx.top[0];
+    nas_func& func=(--ctx.top)[0].func();
+    // func->size has 1 place reserved for "me"
+    func.keys[imm[ctx.pc]]=func.psize;
+    func.local[func.psize++]=val;
+}
+
+void vm::o_dyn() {
+    ctx.top[0].func().dpara=imm[ctx.pc];
+}
+
+void vm::o_lnot() {
+    var val=ctx.top[0];
+    switch(val.type) {
+        case vm_nil:ctx.top[0]=one;break;
+        case vm_num:ctx.top[0]=val.num()?zero:one;break;
+        case vm_str:{
+            const f64 num=str2num(val.str().c_str());
+            if (std::isnan(num)) {
+                ctx.top[0]=var::num((f64)val.str().empty());
+            } else {
+                ctx.top[0]=num?zero:one;
+            }
+        } break;
+        default:{
+            die("incorrect value type");
+            return;
+        } break;
+    }
+}
+
+void vm::o_usub() {
+    ctx.top[0]=var::num(-ctx.top[0].tonum());
+}
+
+void vm::o_bnot() {
+    ctx.top[0]=var::num(~static_cast<int32_t>(ctx.top[0].num()));
+}
+
+void vm::o_btor() {
+    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())|static_cast<int32_t>(ctx.top[0].tonum()));
+    --ctx.top;
+}
+
+void vm::o_btxor() {
+    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())^static_cast<int32_t>(ctx.top[0].tonum()));
+    --ctx.top;
+}
+
+void vm::o_btand() {
+    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())&static_cast<int32_t>(ctx.top[0].tonum()));
+    --ctx.top;
+}
+
+#define op_calc(type)\
+    ctx.top[-1]=var::num(ctx.top[-1].tonum() type ctx.top[0].tonum());\
+    --ctx.top;
+
+void vm::o_add() {op_calc(+);}
+void vm::o_sub() {op_calc(-);}
+void vm::o_mul() {op_calc(*);}
+void vm::o_div() {op_calc(/);}
+void vm::o_lnk() {
+    ctx.top[-1]=ngc.newstr(ctx.top[-1].tostr()+ctx.top[0].tostr());
+    --ctx.top;
+}
+
+#define op_calc_const(type)\
+    ctx.top[0]=var::num(ctx.top[0].tonum() type cnum[imm[ctx.pc]]);
+
+void vm::o_addc() {op_calc_const(+);}
+void vm::o_subc() {op_calc_const(-);}
+void vm::o_mulc() {op_calc_const(*);}
+void vm::o_divc() {op_calc_const(/);}
+void vm::o_lnkc() {
+    ctx.top[0]=ngc.newstr(ctx.top[0].tostr()+cstr[imm[ctx.pc]]);
+}
+
+// top[0] stores the value of memr[0], to avoid being garbage-collected
+// so when the calculation ends, top-=1, then top-=imm[pc]
+// because this return value is meaningless if on stack when imm[pc]=1
+// like this: func{a+=c;}(); the result of 'a+c' will no be used later, imm[pc]=1
+// but if b+=a+=c; the result of 'a+c' will be used later, imm[pc]=0
+#define op_calc_eq(type)\
+    ctx.top[-1]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type ctx.top[-1].tonum());\
+    ctx.memr=nullptr;\
+    ctx.top-=imm[ctx.pc]+1;
+
+void vm::o_addeq() {op_calc_eq(+);}
+void vm::o_subeq() {op_calc_eq(-);}
+void vm::o_muleq() {op_calc_eq(*);}
+void vm::o_diveq() {op_calc_eq(/);}
+void vm::o_lnkeq() {
+    ctx.top[-1]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+ctx.top[-1].tostr());
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+void vm::o_bandeq() {
+    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())&i32(ctx.top[-1].tonum()));
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+void vm::o_boreq() {
+    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())|i32(ctx.top[-1].tonum()));
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+void vm::o_bxoreq() {
+    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())^i32(ctx.top[-1].tonum()));
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+// top[0] stores the value of memr[0], to avoid being garbage-collected
+// so when the calculation ends, top-=imm[pc]>>31
+// because this return value is meaningless if on stack when imm[pc]>>31=1
+// like this: func{a+=1;}(); the result of 'a+1' will no be used later, imm[pc]>>31=1
+// but if b+=a+=1; the result of 'a+1' will be used later, imm[pc]>>31=0
+#define op_calc_eq_const(type)\
+    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
+    ctx.memr=nullptr;
+
+void vm::o_addeqc() {op_calc_eq_const(+);}
+void vm::o_subeqc() {op_calc_eq_const(-);}
+void vm::o_muleqc() {op_calc_eq_const(*);}
+void vm::o_diveqc() {op_calc_eq_const(/);}
+void vm::o_lnkeqc() {
+    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
+    ctx.memr=nullptr;
+}
+
+#define op_calc_eq_const_and_pop(type)\
+    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
+    ctx.memr=nullptr;\
+    --ctx.top;
+
+void vm::o_addecp() {op_calc_eq_const_and_pop(+);}
+void vm::o_subecp() {op_calc_eq_const_and_pop(-);}
+void vm::o_mulecp() {op_calc_eq_const_and_pop(*);}
+void vm::o_divecp() {op_calc_eq_const_and_pop(/);}
+void vm::o_lnkecp() {
+    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
+    ctx.memr=nullptr;
+    --ctx.top;
+}
+
+void vm::o_meq() {
+    // pop old memr[0] and replace it
+    // the reason why we should get memr and push the old value on stack
+    // is that when lnkeq/lnkeqc is called, there will be
+    // a new gc object vm_str which is returned by gc::alloc
+    // this may cause gc, so we should temporarily put it on stack
+    ctx.memr[0]=ctx.top[-1];
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+void vm::o_eq() {
+    var val2=ctx.top[0];
+    var val1=(--ctx.top)[0];
+    if (val1.type==vm_nil && val2.type==vm_nil) {
+        ctx.top[0]=one;
+    } else if (val1.type==vm_str && val2.type==vm_str) {
+        ctx.top[0]=(val1.str()==val2.str())?one:zero;
+    } else if ((val1.type==vm_num || val2.type==vm_num)
+        && val1.type!=vm_nil && val2.type!=vm_nil) {
+        ctx.top[0]=(val1.tonum()==val2.tonum())?one:zero;
+    } else {
+        ctx.top[0]=(val1==val2)?one:zero;
+    }
+}
+
+void vm::o_neq() {
+    var val2=ctx.top[0];
+    var val1=(--ctx.top)[0];
+    if (val1.type==vm_nil && val2.type==vm_nil) {
+        ctx.top[0]=zero;
+    } else if (val1.type==vm_str && val2.type==vm_str) {
+        ctx.top[0]=(val1.str()!=val2.str())?one:zero;
+    } else if ((val1.type==vm_num || val2.type==vm_num)
+        && val1.type!=vm_nil && val2.type!=vm_nil) {
+        ctx.top[0]=(val1.tonum()!=val2.tonum())?one:zero;
+    } else {
+        ctx.top[0]=(val1!=val2)?one:zero;
+    }
+}
+
+#define op_cmp(type)\
+    --ctx.top;\
+    ctx.top[0]=(ctx.top[0].tonum() type ctx.top[1].tonum())?one:zero;
+
+void vm::o_less() {op_cmp(<);}
+void vm::o_leq() {op_cmp(<=);}
+void vm::o_grt() {op_cmp(>);}
+void vm::o_geq() {op_cmp(>=);}
+
+#define op_cmp_const(type)\
+    ctx.top[0]=(ctx.top[0].tonum() type cnum[imm[ctx.pc]])?one:zero;
+
+void vm::o_lessc() {op_cmp_const(<);}
+void vm::o_leqc() {op_cmp_const(<=);}
+void vm::o_grtc() {op_cmp_const(>);}
+void vm::o_geqc() {op_cmp_const(>=);}
+
+void vm::o_pop() {
+    --ctx.top;
+}
+
+void vm::o_jmp() {
+    ctx.pc=imm[ctx.pc]-1;
+}
+
+void vm::o_jt() {
+    // jump true needs to reserve the result on stack
+    // because conditional expression in nasal has return value
+    if (cond(ctx.top[0])) {
+        ctx.pc=imm[ctx.pc]-1;
+    }
+}
+
+void vm::o_jf() {
+    // jump false doesn't need to reserve result
+    if (!cond(ctx.top[0])) {
+        ctx.pc=imm[ctx.pc]-1;
+    }
+    --ctx.top;
+}
+
+void vm::o_cnt() {
+    if (ctx.top[0].type!=vm_vec) {
+        die("must use vector in forindex/foreach");
+        return;
+    }
+    (++ctx.top)[0]=var::cnt(-1);
+}
+
+void vm::o_findex() {
+    if ((usize)(++ctx.top[0].cnt())>=ctx.top[-1].vec().size()) {
+        ctx.pc=imm[ctx.pc]-1;
+        return;
+    }
+    ctx.top[1]=var::num(ctx.top[0].cnt());
+    ++ctx.top;
+}
+
+void vm::o_feach() {
+    auto& ref=ctx.top[-1].vec().elems;
+    if ((usize)(++ctx.top[0].cnt())>=ref.size()) {
+        ctx.pc=imm[ctx.pc]-1;
+        return;
+    }
+    ctx.top[1]=ref[ctx.top[0].cnt()];
+    ++ctx.top;
+}
+
+void vm::o_callg() {
+    // get main stack directly
+    (++ctx.top)[0]=stack[imm[ctx.pc]];
+}
+
+void vm::o_calll() {
+    (++ctx.top)[0]=ctx.localr[imm[ctx.pc]];
+}
+
+void vm::o_upval() {
+    (++ctx.top)[0]=ctx.funcr.func()
+        .upval[(imm[ctx.pc]>>16)&0xffff]
+        .upval()[imm[ctx.pc]&0xffff];
+}
+
+void vm::o_callv() {
+    var val=ctx.top[0];
+    var vec=(--ctx.top)[0];
+    if (vec.type==vm_vec) {
+        ctx.top[0]=vec.vec().get_val(val.tonum());
+        if (ctx.top[0].type==vm_none) {
+            die("out of range:"+std::to_string(val.tonum()));
+            return;
+        }
+    } else if (vec.type==vm_hash) {
+        if (val.type!=vm_str) {
+            die("must use string as the key");
+            return;
+        }
+        ctx.top[0]=vec.hash().get_val(val.str());
+        if (ctx.top[0].type==vm_none) {
+            die("cannot find member \""+val.str()+"\"");
+            return;
+        } else if (ctx.top[0].type==vm_func) {
+            ctx.top[0].func().local[0]=val; // 'me'
+        }
+    } else if (vec.type==vm_str) {
+        auto& str = vec.str();
+        i32 num = val.tonum();
+        i32 len = str.length();
+        if (num<-len || num>=len) {
+            die("out of range:"+std::to_string(val.tonum()));
+            return;
+        }
+        ctx.top[0]=var::num(f64((u8)str[num>=0? num:num+len]));
+    } else {
+        die("must call a vector/hash/string");
+        return;
+    }
+}
+
+void vm::o_callvi() {
+    var val=ctx.top[0];
+    if (val.type!=vm_vec) {
+        die("must use a vector");
+        return;
+    }
+    // cannot use operator[],because this may cause overflow
+    (++ctx.top)[0]=val.vec().get_val(imm[ctx.pc]);
+    if (ctx.top[0].type==vm_none) {
+        die("out of range:"+std::to_string(imm[ctx.pc]));
+        return;
+    }
+}
+
+void vm::o_callh() {
+    var val=ctx.top[0];
+    if (val.type!=vm_hash) {
+        die("must call a hash");
+        return;
+    }
+    ctx.top[0]=val.hash().get_val(cstr[imm[ctx.pc]]);
+    if (ctx.top[0].type==vm_none) {
+        die("member \""+cstr[imm[ctx.pc]]+"\" does not exist");
+        return;
+    } else if (ctx.top[0].type==vm_func) {
+        ctx.top[0].func().local[0]=val; // 'me'
+    }
+}
+
+void vm::o_callfv() {
+    u32 argc=imm[ctx.pc]; // arguments counter
+    var* local=ctx.top-argc+1; // arguments begin address
+    if (local[-1].type!=vm_func) {
+        die("must call a function");
+        return;
+    }
+    auto& func=local[-1].func();
+    var tmp=local[-1];
+    local[-1]=ctx.funcr;
+    ctx.funcr=tmp;
+    // top-argc+lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
+    if (ctx.top-argc+func.lsize+3>=ctx.canary) {
+        die("stack overflow");
+        return;
+    }
+    // parameter size is func->psize-1, 1 is reserved for "me"
+    u32 psize=func.psize-1;
+    if (argc<psize && func.local[argc+1].type==vm_none) {
+        die("lack argument(s)");
+        return;
+    }
+
+    var dynamic=nil;
+    if (func.dpara>=0) { // load dynamic arguments
+        dynamic=ngc.alloc(vm_vec);
+        for(u32 i=psize;i<argc;++i) {
+            dynamic.vec().elems.push_back(local[i]);
+        }
+    }
+    // should reset stack top after allocating vector
+    // because this may cause gc
+    // then all the available values the vector needs
+    // are all outside the stack top and may be
+    // collected incorrectly
+    ctx.top=local+func.lsize;
+
+    u32 min_size=(std::min)(psize, argc); // avoid error in MSVC
+    for(u32 i=min_size;i>=1;--i) { // load arguments
+        local[i]=local[i-1];
+    }
+    local[0]=func.local[0];// load "me"
+    // load local scope & default arguments
+    for(u32 i=min_size+1;i<func.lsize;++i) {
+        local[i]=func.local[i];
+    }
+    if (func.dpara>=0) {
+        local[psize+1]=dynamic;
+    }
+
+    ctx.top[0]=ctx.upvalr;
+    (++ctx.top)[0]=var::addr(ctx.localr);
+    (++ctx.top)[0]=var::ret(ctx.pc);
+    ctx.pc=func.entry-1;
+    ctx.localr=local;
+    ctx.upvalr=nil;
+}
+
+void vm::o_callfh() {
+    auto& hash=ctx.top[0].hash().elems;
+    if (ctx.top[-1].type!=vm_func) {
+        die("must call a function");
+        return;
+    }
+    auto& func=ctx.top[-1].func();
+    var tmp=ctx.top[-1];
+    ctx.top[-1]=ctx.funcr;
+    ctx.funcr=tmp;
+
+    // top -1(hash) +lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
+    if (ctx.top+func.lsize+2>=ctx.canary) {
+        die("stack overflow");
+        return;
+    }
+    if (func.dpara>=0) {
+        die("special call cannot use dynamic argument");
+        return;
+    }
+
+    var* local=ctx.top;
+    ctx.top+=func.lsize;
+    for(u32 i=0;i<func.lsize;++i) {
+        local[i]=func.local[i];
+    }
+    
+    for(auto& i:func.keys) {
+        auto& key=cstr[i.first];
+        if (hash.count(key)) {
+            local[i.second]=hash[key];
+        } else if (local[i.second].type==vm_none) {
+            die("lack argument(s): \""+key+"\"");
+            return;
+        }
+    }
+
+    ctx.top[0]=ctx.upvalr;
+    (++ctx.top)[0]=var::addr(ctx.localr);
+    (++ctx.top)[0]=var::ret(ctx.pc); // rewrite top with vm_ret
+    ctx.pc=func.entry-1;
+    ctx.localr=local;
+    ctx.upvalr=nil;
+}
+
+void vm::o_callb() {
+    // reserve place for builtin function return,
+    // this code is written for coroutine
+    (++ctx.top)[0]=nil;
+
+    // if running a builtin function about coroutine
+    // (top) will be set to another context.top, instead of main_context.top
+    var tmp=(*builtin[imm[ctx.pc]].func)(ctx.localr, ngc);
+
+    // so we use tmp variable to store this return value
+    // and set it to top[0] later
+    ctx.top[0]=tmp;
+
+    // if get none, this means errors occurred when calling this native function
+    if (ctx.top[0].type==vm_none) {
+        die("native function error");
+        return;
+    }
+}
+
+void vm::o_slcbeg() {
+    // +--------------+
+    // | slice_vector | <-- top[0]
+    // +--------------+
+    // | resource_vec | <-- top[-1]
+    // +--------------+
+    (++ctx.top)[0]=ngc.alloc(vm_vec);
+    if (ctx.top[-1].type!=vm_vec) {
+        die("must slice a vector");
+        return;
+    }
+}
+
+void vm::o_slcend() {
+    ctx.top[-1]=ctx.top[0];
+    --ctx.top;
+}
+
+void vm::o_slc() {
+    var val=(ctx.top--)[0];
+    var res=ctx.top[-1].vec().get_val(val.tonum());
+    if (res.type==vm_none) {
+        die("index "+std::to_string(val.tonum())+" out of range");
+        return;
+    }
+    ctx.top[0].vec().elems.push_back(res);
+}
+
+void vm::o_slc2() {
+    var val2=(ctx.top--)[0];
+    var val1=(ctx.top--)[0];
+    auto& ref=ctx.top[-1].vec().elems;
+    auto& aim=ctx.top[0].vec().elems;
+
+    u8 type1=val1.type,type2=val2.type;
+    i32 num1=val1.tonum();
+    i32 num2=val2.tonum();
+    i32 size=ref.size();
+    if (type1==vm_nil && type2==vm_nil) {
+        num1=0;
+        num2=size-1;
+    } else if (type1==vm_nil && type2!=vm_nil) {
+        num1=num2<0? -size:0;
+    } else if (type1!=vm_nil && type2==vm_nil) {
+        num2=num1<0? -1:size-1;
+    }
+
+    if (num1<-size || num1>=size || num2<-size || num2>=size) {
+        die("index "+std::to_string(num1)+":"+std::to_string(num2)+" out of range");
+        return;
+    } else if (num1<=num2) {
+        for(i32 i=num1;i<=num2;++i) {
+            aim.push_back(i>=0?ref[i]:ref[i+size]);
+        }
+    }
+}
+
+void vm::o_mcallg() {
+    ctx.memr=stack+imm[ctx.pc];
+    (++ctx.top)[0]=ctx.memr[0];
+    // push value in this memory space on stack
+    // to avoid being garbage collected
+}
+
+void vm::o_mcalll() {
+    ctx.memr=ctx.localr+imm[ctx.pc];
+    (++ctx.top)[0]=ctx.memr[0];
+    // push value in this memory space on stack
+    // to avoid being garbage collected
+}
+
+void vm::o_mupval() {
+    ctx.memr=&(ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff].upval()[imm[ctx.pc]&0xffff]);
+    (++ctx.top)[0]=ctx.memr[0];
+    // push value in this memory space on stack
+    // to avoid being garbage collected
+}
+
+void vm::o_mcallv() {
+    var val=ctx.top[0];     // index
+    var vec=(--ctx.top)[0]; // mcall vector, reserved on stack to avoid gc
+    if (vec.type==vm_vec) {
+        ctx.memr=vec.vec().get_mem(val.tonum());
+        if (!ctx.memr) {
+            die("index "+std::to_string(val.tonum())+" out of range");
+            return;
+        }
+    } else if (vec.type==vm_hash) { // do mcallh but use the mcallv way
+        if (val.type!=vm_str) {
+            die("key must be string");
+            return;
+        }
+        auto& ref = vec.hash();
+        auto& str = val.str();
+        ctx.memr = ref.get_mem(str);
+        if (!ctx.memr) {
+            ref.elems[str]=nil;
+            ctx.memr=ref.get_mem(str);
+        }
+    } else {
+        die("cannot get memory space in this type");
+        return;
+    }
+}
+
+void vm::o_mcallh() {
+    var hash=ctx.top[0]; // mcall hash, reserved on stack to avoid gc
+    if (hash.type!=vm_hash) {
+        die("must call a hash");
+        return;
+    }
+    auto& ref=hash.hash();
+    auto& str=cstr[imm[ctx.pc]];
+    ctx.memr=ref.get_mem(str);
+    if (!ctx.memr) { // create a new key
+        ref.elems[str]=nil;
+        ctx.memr=ref.get_mem(str);
+    }
+}
+
+void vm::o_ret() {
+/*  +-------------+
+*   | return value| <- top[0]
+*   +-------------+
+*   | old pc      | <- top[-1]
+*   +-------------+
+*   | old localr  | <- top[-2]
+*   +-------------+
+*   | old upvalr  | <- top[-3]
+*   +-------------+
+*   | local scope |
+*   +-------------+ <- local pointer stored in localr
+*   | old funcr   | <- old function stored in funcr
+*   +-------------+
+*/
+    var  ret  =ctx.top[0];
+    var* local=ctx.localr;
+    var  func =ctx.funcr;
+    var  up   =ctx.upvalr;
+
+    ctx.pc    =ctx.top[-1].ret();
+    ctx.localr=ctx.top[-2].addr();
+    ctx.upvalr=ctx.top[-3];
+
+    ctx.top=local-1;
+    ctx.funcr=ctx.top[0];
+    ctx.top[0]=ret; // rewrite func with returned value
+
+    if (up.type==vm_upval) { // synchronize upvalue
+        auto& upval=up.upval();
+        auto size=func.func().lsize;
+        upval.onstk=false;
+        upval.elems.resize(size);
+        for(u32 i=0;i<size;++i) {
+            upval.elems[i]=local[i];
+        }
+    }
+
+    // cannot use gc.cort to judge,
+    // because there maybe another function call inside but return here
+    // coroutine function ends with setting pc to 0
+    if (!ctx.pc) {
+        ngc.ctxreserve();
+    }
+}
+
+void vm::run(
+    const codegen& gen,
+    const linker& linker,
+    const std::vector<std::string>& argv,
+    const bool detail
+) {
+    verbose=detail;
+    init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
+#ifndef _MSC_VER
+    const void* oprs[]={
+        &&vmexit, &&intg,   &&intl,   &&loadg,
+        &&loadl,  &&loadu,  &&pnum,   &&pnil,
+        &&pstr,   &&newv,   &&newh,   &&newf,
+        &&happ,   &&para,   &&deft,   &&dyn,
+        &&lnot,   &&usub,   &&bnot,   &&btor,
+        &&btxor,  &&btand,  &&add,    &&sub,
+        &&mul,    &&div,    &&lnk,    &&addc,
+        &&subc,   &&mulc,   &&divc,   &&lnkc,
+        &&addeq,  &&subeq,  &&muleq,  &&diveq,
+        &&lnkeq,  &&bandeq, &&boreq,  &&bxoreq,
+        &&addeqc, &&subeqc, &&muleqc, &&diveqc,
+        &&lnkeqc, &&addecp, &&subecp, &&mulecp,
+        &&divecp, &&lnkecp, &&meq,    &&eq,
+        &&neq,    &&less,   &&leq,    &&grt,
+        &&geq,    &&lessc,  &&leqc,   &&grtc,
+        &&geqc,   &&pop,    &&jmp,    &&jt,
+        &&jf,     &&cnt,    &&findex, &&feach,
+        &&callg,  &&calll,  &&upval,  &&callv,
+        &&callvi, &&callh,  &&callfv, &&callfh,
+        &&callb,  &&slcbeg, &&slcend, &&slc,
+        &&slc2,   &&mcallg, &&mcalll, &&mupval,
+        &&mcallv, &&mcallh, &&ret
+    };
+    std::vector<const void*> code;
+    for(auto& i:gen.codes()) {
+        code.push_back(oprs[i.op]);
+        imm.push_back(i.num);
+    }
+    // goto the first operand
+    goto *code[ctx.pc];
+#else
+    typedef void (vm::*nafunc)();
+    const nafunc oprs[]={
+        nullptr,       &vm::o_intg,
+        &vm::o_intl,   &vm::o_loadg,
+        &vm::o_loadl,  &vm::o_loadu,
+        &vm::o_pnum,   &vm::o_pnil,
+        &vm::o_pstr,   &vm::o_newv,
+        &vm::o_newh,   &vm::o_newf,
+        &vm::o_happ,   &vm::o_para,
+        &vm::o_deft,   &vm::o_dyn,
+        &vm::o_lnot,   &vm::o_usub,
+        &vm::o_bnot,   &vm::o_btor,
+        &vm::o_btxor,  &vm::o_btand,
+        &vm::o_add,    &vm::o_sub,
+        &vm::o_mul,    &vm::o_div,
+        &vm::o_lnk,    &vm::o_addc,
+        &vm::o_subc,   &vm::o_mulc,
+        &vm::o_divc,   &vm::o_lnkc,
+        &vm::o_addeq,  &vm::o_subeq,
+        &vm::o_muleq,  &vm::o_diveq,
+        &vm::o_lnkeq,  &vm::o_bandeq,
+        &vm::o_boreq,  &vm::o_bxoreq,
+        &vm::o_addeqc, &vm::o_subeqc,
+        &vm::o_muleqc, &vm::o_diveqc,
+        &vm::o_lnkeqc, &vm::o_addecp,
+        &vm::o_subecp, &vm::o_mulecp,
+        &vm::o_divecp, &vm::o_lnkecp,
+        &vm::o_meq,    &vm::o_eq,
+        &vm::o_neq,    &vm::o_less,
+        &vm::o_leq,    &vm::o_grt,
+        &vm::o_geq,    &vm::o_lessc,
+        &vm::o_leqc,   &vm::o_grtc,
+        &vm::o_geqc,   &vm::o_pop,
+        &vm::o_jmp,    &vm::o_jt,
+        &vm::o_jf,     &vm::o_cnt,
+        &vm::o_findex, &vm::o_feach,
+        &vm::o_callg,  &vm::o_calll,
+        &vm::o_upval,  &vm::o_callv,
+        &vm::o_callvi, &vm::o_callh,
+        &vm::o_callfv, &vm::o_callfh,
+        &vm::o_callb,  &vm::o_slcbeg,
+        &vm::o_slcend, &vm::o_slc,
+        &vm::o_slc2,   &vm::o_mcallg,
+        &vm::o_mcalll, &vm::o_mupval,
+        &vm::o_mcallv, &vm::o_mcallh,
+        &vm::o_ret
+    };
+    std::vector<nafunc> code;
+    for(auto& i:gen.codes()) {
+        code.push_back(oprs[i.op]);
+        imm.push_back(i.num);
+    }
+    while(code[ctx.pc]) {
+        (this->*code[ctx.pc])();
+        if (ctx.top>=ctx.canary) {
+            die("stack overflow");
+        }
+        ++ctx.pc;
+    }
+#endif
+
+vmexit:
+    if (detail) {
+        ngc.info();
+    }
+    ngc.clear();
+    imm.clear();
+    return;
+
+#ifndef _MSC_VER
+// may cause stackoverflow
+#define exec_check(op) {\
+        op();\
+        if (ctx.top<ctx.canary)\
+            goto *code[++ctx.pc];\
+        die("stack overflow");\
+        goto *code[++ctx.pc];\
+    }
+// do not cause stackoverflow
+#define exec_nodie(op) {op();goto *code[++ctx.pc];}
+
+intg:   exec_nodie(o_intg  ); // +imm[pc] (detected at codegen)
+intl:   exec_nodie(o_intl  ); // -0
+loadg:  exec_nodie(o_loadg ); // -1
+loadl:  exec_nodie(o_loadl ); // -1
+loadu:  exec_nodie(o_loadu ); // -1
+pnum:   exec_check(o_pnum  ); // +1
+pnil:   exec_check(o_pnil  ); // +1
+pstr:   exec_check(o_pstr  ); // +1
+newv:   exec_check(o_newv  ); // +1-imm[pc]
+newh:   exec_check(o_newh  ); // +1
+newf:   exec_check(o_newf  ); // +1
+happ:   exec_nodie(o_happ  ); // -1
+para:   exec_nodie(o_para  ); // -0
+deft:   exec_nodie(o_deft  ); // -1
+dyn:    exec_nodie(o_dyn   ); // -0
+lnot:   exec_nodie(o_lnot  ); // -0
+usub:   exec_nodie(o_usub  ); // -0
+bnot:   exec_nodie(o_bnot  ); // -0
+btor:   exec_nodie(o_btor  ); // -1
+btxor:  exec_nodie(o_btxor ); // -1
+btand:  exec_nodie(o_btand ); // -1
+add:    exec_nodie(o_add   ); // -1
+sub:    exec_nodie(o_sub   ); // -1
+mul:    exec_nodie(o_mul   ); // -1
+div:    exec_nodie(o_div   ); // -1
+lnk:    exec_nodie(o_lnk   ); // -1
+addc:   exec_nodie(o_addc  ); // -0
+subc:   exec_nodie(o_subc  ); // -0
+mulc:   exec_nodie(o_mulc  ); // -0
+divc:   exec_nodie(o_divc  ); // -0
+lnkc:   exec_nodie(o_lnkc  ); // -0
+addeq:  exec_nodie(o_addeq ); // -1
+subeq:  exec_nodie(o_subeq ); // -1
+muleq:  exec_nodie(o_muleq ); // -1
+diveq:  exec_nodie(o_diveq ); // -1
+lnkeq:  exec_nodie(o_lnkeq ); // -1
+bandeq: exec_nodie(o_bandeq); // -1
+boreq:  exec_nodie(o_boreq ); // -1
+bxoreq: exec_nodie(o_bxoreq); // -1
+addeqc: exec_nodie(o_addeqc); // -0
+subeqc: exec_nodie(o_subeqc); // -0
+muleqc: exec_nodie(o_muleqc); // -0
+diveqc: exec_nodie(o_diveqc); // -0
+lnkeqc: exec_nodie(o_lnkeqc); // -0
+addecp: exec_nodie(o_addecp); // -1
+subecp: exec_nodie(o_subecp); // -1
+mulecp: exec_nodie(o_mulecp); // -1
+divecp: exec_nodie(o_divecp); // -1
+lnkecp: exec_nodie(o_lnkecp); // -1
+meq:    exec_nodie(o_meq   ); // -1
+eq:     exec_nodie(o_eq    ); // -1
+neq:    exec_nodie(o_neq   ); // -1
+less:   exec_nodie(o_less  ); // -1
+leq:    exec_nodie(o_leq   ); // -1
+grt:    exec_nodie(o_grt   ); // -1
+geq:    exec_nodie(o_geq   ); // -1
+lessc:  exec_nodie(o_lessc ); // -0
+leqc:   exec_nodie(o_leqc  ); // -0
+grtc:   exec_nodie(o_grtc  ); // -0
+geqc:   exec_nodie(o_geqc  ); // -0
+pop:    exec_nodie(o_pop   ); // -1
+jmp:    exec_nodie(o_jmp   ); // -0
+jt:     exec_nodie(o_jt    ); // -0
+jf:     exec_nodie(o_jf    ); // -1
+cnt:    exec_nodie(o_cnt   ); // -0
+findex: exec_check(o_findex); // +1
+feach:  exec_check(o_feach ); // +1
+callg:  exec_check(o_callg ); // +1
+calll:  exec_check(o_calll ); // +1
+upval:  exec_check(o_upval ); // +1
+callv:  exec_nodie(o_callv ); // -0
+callvi: exec_nodie(o_callvi); // -0
+callh:  exec_nodie(o_callh ); // -0
+callfv: exec_nodie(o_callfv); // check in the function
+callfh: exec_nodie(o_callfh); // check in the function
+callb:  exec_nodie(o_callb ); // -0
+slcbeg: exec_check(o_slcbeg); // +1
+slcend: exec_nodie(o_slcend); // -1
+slc:    exec_nodie(o_slc   ); // -1
+slc2:   exec_nodie(o_slc2  ); // -2
+mcallg: exec_check(o_mcallg); // +1
+mcalll: exec_check(o_mcalll); // +1
+mupval: exec_check(o_mupval); // +1
+mcallv: exec_nodie(o_mcallv); // -0
+mcallh: exec_nodie(o_mcallh); // -0
+ret:    exec_nodie(o_ret   ); // -2
+#endif
+}
diff --git a/ast/nasal_new_vm.h b/ast/nasal_new_vm.h
new file mode 100644
index 0000000..5c686fd
--- /dev/null
+++ b/ast/nasal_new_vm.h
@@ -0,0 +1,159 @@
+#pragma once
+
+#include <iomanip>
+#include <stack>
+
+#include "nasal_new_import.h"
+#include "nasal_new_gc.h"
+#include "nasal_new_codegen.h"
+
+#ifdef _MSC_VER
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#pragma warning (disable:4102)
+#endif
+
+class vm {
+protected:
+
+    /* registers and constants of vm */
+    context ctx;
+
+    /* constants */
+    const f64* cnum=nullptr;    // constant numbers
+    const std::string* cstr=nullptr; // constant symbols and strings
+    std::vector<u32> imm;       // immediate number table
+    
+    /* garbage collector */
+    gc ngc;
+
+    /* main stack */
+    var stack[STACK_DEPTH];
+
+    /* values used for debugger */
+    const std::string* files=nullptr;    // file name list
+    const opcode* bytecode=nullptr; // bytecode buffer address
+
+    /* vm initializing function */
+    void init(
+        const std::vector<std::string>&,
+        const std::vector<f64>&,
+        const std::vector<opcode>&,
+        const std::vector<std::string>&,
+        const std::vector<std::string>&);
+
+    /* debug functions */
+    bool verbose;
+    void valinfo(var&);
+    void traceback();
+    void stackinfo(const u32);
+    void reginfo();
+    void gstate();
+    void lstate();
+    void ustate();
+    void detail();
+    void die(const std::string&);
+
+    /* vm calculation functions*/
+    bool cond(var&);
+
+    /* vm operands */
+    void o_intg();
+    void o_intl();
+    void o_loadg();
+    void o_loadl();
+    void o_loadu();
+    void o_pnum();
+    void o_pnil();
+    void o_pstr();
+    void o_newv();
+    void o_newh();
+    void o_newf();
+    void o_happ();
+    void o_para();
+    void o_deft();
+    void o_dyn();
+    void o_lnot();
+    void o_usub();
+    void o_bnot();
+    void o_btor();
+    void o_btxor();
+    void o_btand();
+    void o_add();
+    void o_sub();
+    void o_mul();
+    void o_div();
+    void o_lnk();
+    void o_addc();
+    void o_subc();
+    void o_mulc();
+    void o_divc();
+    void o_lnkc();
+    void o_addeq();
+    void o_subeq();
+    void o_muleq();
+    void o_diveq();
+    void o_lnkeq();
+    void o_bandeq();
+    void o_boreq();
+    void o_bxoreq();
+    void o_addeqc();
+    void o_subeqc();
+    void o_muleqc();
+    void o_diveqc();
+    void o_lnkeqc();
+    void o_addecp();
+    void o_subecp();
+    void o_mulecp();
+    void o_divecp();
+    void o_lnkecp();
+    void o_meq();
+    void o_eq();
+    void o_neq();
+    void o_less();
+    void o_leq();
+    void o_grt();
+    void o_geq();
+    void o_lessc();
+    void o_leqc();
+    void o_grtc();
+    void o_geqc();
+    void o_pop();
+    void o_jmp();
+    void o_jt();
+    void o_jf();
+    void o_cnt();
+    void o_findex();
+    void o_feach();
+    void o_callg();
+    void o_calll();
+    void o_upval();
+    void o_callv();
+    void o_callvi();
+    void o_callh();
+    void o_callfv();
+    void o_callfh();
+    void o_callb();
+    void o_slcbeg();
+    void o_slcend();
+    void o_slc();
+    void o_slc2();
+    void o_mcallg();
+    void o_mcalll();
+    void o_mupval();
+    void o_mcallv();
+    void o_mcallh();
+    void o_ret();
+public:
+
+    /* constructor of vm instance */
+    vm(): ngc(&ctx), verbose(false) {}
+
+    /* execution entry */
+    void run(
+        const codegen&,
+        const linker&,
+        const std::vector<std::string>&,
+        const bool
+    );
+};
diff --git a/makefile b/makefile
index e8e9bbe..c6c5715 100644
--- a/makefile
+++ b/makefile
@@ -84,6 +84,8 @@ NASAL_NEW_AST=\
 	nasal_new_codegen.o\
 	nasal_new_opcode.o\
 	nasal_new_parse.o\
+	nasal_new_vm.o\
+	nasal_new_dbg.o\
 	optimizer.o\
 	symbol_finder.o\
 	ast_visitor.o\
@@ -120,7 +122,7 @@ nasal_new_builtin.o: ast/nasal_new_builtin.h ast/nasal_new_builtin.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_builtin.cpp -fno-exceptions -fPIC -o nasal_new_builtin.o -I .
 
 nasal_new_codegen.o: ast/nasal_new_codegen.h ast/nasal_new_codegen.cpp
-#	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.o -I .
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.o -I .
 
 nasal_new_opcode.o: ast/nasal_new_opcode.h ast/nasal_new_opcode.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_opcode.cpp -fno-exceptions -fPIC -o nasal_new_opcode.o -I .
@@ -140,6 +142,12 @@ ast_visitor.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_visitor.cpp
 ast_dumper.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_dumper.h ast/ast_dumper.cpp
 	$(CXX) -std=$(STD) -c -O3 ast/ast_dumper.cpp -fno-exceptions -fPIC -o ast_dumper.o -I .
 
+nasal_new_vm.o: ast/nasal_new_vm.h ast/nasal_new_vm.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_vm.cpp -fno-exceptions -fPIC -o nasal_new_vm.o -I .
+
+nasal_new_dbg.o: ast/nasal_new_dbg.h ast/nasal_new_dbg.cpp
+	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_dbg.cpp -fno-exceptions -fPIC -o nasal_new_dbg.o -I .
+
 .PHONY: nasal_new_clean
 nasal_new_clean:
 	rm $(NASAL_NEW_AST)
\ No newline at end of file

From af3ade5a41bf9e77b200bc4630483b9b91847674 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sat, 1 Jul 2023 18:41:55 +0800
Subject: [PATCH 26/34] :bug: fix codegen bug in condition & mcall

---
 ast/nasal_new_ast.h       |   1 +
 ast/nasal_new_codegen.cpp | 331 ++++++++++++++++++++------------------
 ast/nasal_new_codegen.h   |   3 +-
 ast/nasal_new_parse.cpp   |  21 ++-
 ast/nasal_new_vm.h        |   1 +
 5 files changed, 192 insertions(+), 165 deletions(-)

diff --git a/ast/nasal_new_ast.h b/ast/nasal_new_ast.h
index 2051d77..f1dc306 100644
--- a/ast/nasal_new_ast.h
+++ b/ast/nasal_new_ast.h
@@ -66,6 +66,7 @@ public:
         nd_loc.begin_column = column;
     }
     const span& get_location() const {return nd_loc;}
+    const u32 get_line() const {return nd_loc.begin_line;}
     expr_type get_type() const {return nd_type;}
     void update_location(const span& location) {
         nd_loc.end_line = location.end_line;
diff --git a/ast/nasal_new_codegen.cpp b/ast/nasal_new_codegen.cpp
index ea80e20..abc4207 100644
--- a/ast/nasal_new_codegen.cpp
+++ b/ast/nasal_new_codegen.cpp
@@ -1,31 +1,12 @@
 #include "nasal_new_codegen.h"
 
-bool codegen::check_memory_reachable(expr* node) {
-    if (node->get_type()==expr_type::ast_call) {
-        const auto tmp=((call_expr*)node)->get_calls().back();
-        if (tmp->get_type()==expr_type::ast_callf) {
-            die("bad left-value with function call", node->get_location());
-            return false;
-        }
-        if (tmp->get_type()==expr_type::ast_callv &&
-            (((call_vector*)tmp)->get_slices().size()!=1 ||
-            ((call_vector*)tmp)->get_slices()[0]->get_end())) {
-            die("bad left-value with subvec", node->get_location());
-            return false;
-        }
-    } else if (node->get_type()!=expr_type::ast_id) {
-        die("bad left-value", node->get_location());
-        return false;
-    }
-    return true;
-}
-
 void codegen::check_id_exist(identifier* node) {
     const auto& name = node->get_name();
-    for(u32 i=0;builtin[i].name;++i) {
+    for(u32 i = 0; builtin[i].name; ++i) {
         if (builtin[i].name==name) {
             if (local.empty()) {
-                die("useless native function used in global scope", node->get_location());
+                die("native function used in global scope",
+                    node->get_location());
             }
             return;
         }
@@ -40,21 +21,23 @@ void codegen::check_id_exist(identifier* node) {
     if (global_find(name)>=0) {
         return;
     }
-    die("undefined symbol \"" + name + "\", and this symbol is useless here", node->get_location());
+    die("undefined symbol \"" + name +
+        "\", and this symbol is useless here",
+        node->get_location());
 }
 
 void codegen::regist_num(const f64 num) {
     if (!num_table.count(num)) {
-        u32 size=num_table.size();
-        num_table[num]=size;
+        u32 size = num_table.size();
+        num_table[num] = size;
         num_res.push_back(num);
     }
 }
 
 void codegen::regist_str(const std::string& str) {
     if (!str_table.count(str)) {
-        u32 size=str_table.size();
-        str_table[str]=size;
+        u32 size = str_table.size();
+        str_table[str] = size;
         str_res.push_back(str);
     }
 }
@@ -64,6 +47,7 @@ void codegen::find_symbol(code_block* node) {
     for(const auto& i : finder->do_find(node)) {
         add_sym(i);
     }
+    delete finder;
 }
 
 void codegen::add_sym(const std::string& name) {
@@ -71,63 +55,63 @@ void codegen::add_sym(const std::string& name) {
         if (global.count(name)) {
             return;
         }
-        i32 index=global.size();
-        global[name]=index;
+        i32 index = global.size();
+        global[name] = index;
         return;
     }
     if (local.back().count(name)) {
         return;
     }
-    i32 index=local.back().size();
-    local.back()[name]=index;
+    i32 index = local.back().size();
+    local.back()[name] = index;
 }
 
 i32 codegen::local_find(const std::string& name) {
     if (local.empty()) {
         return -1;
     }
-    return local.back().count(name)?local.back()[name]:-1;
+    return local.back().count(name)? local.back().at(name):-1;
 }
 
 i32 codegen::global_find(const std::string& name) {
-    return global.count(name)?global[name]:-1;
+    return global.count(name)? global.at(name):-1;
 }
 
 i32 codegen::upvalue_find(const std::string& name) {
     // 32768 level 65536 upvalues
-    i32 index=-1;
-    usize size=local.size();
+    i32 index = -1;
+    usize size = local.size();
     if (size<=1) {
         return -1;
     }
-    auto iter=local.begin();
-    for(u32 i=0;i<size-1;++i,++iter) {
+    auto iter = local.begin();
+    for(u32 i = 0; i<size-1; ++i, ++iter) {
         if (iter->count(name)) {
-            index=((i<<16)|(*iter)[name]);
+            index = ((i<<16)|(*iter).at(name));
         }
     }
     return index;
 }
 
-void codegen::gen(u8 op, u32 num, u32 line) {
-    code.push_back({op, fileindex, num, line});
+void codegen::gen(u8 operation_code, u32 num, u32 line) {
+    code.push_back({operation_code, fileindex, num, line});
 }
 
 void codegen::num_gen(number_literal* node) {
     f64 num = node->get_number();
     regist_num(num);
-    gen(op_pnum,num_table[num], node->get_location().begin_line);
+    gen(op_pnum,num_table.at(num), node->get_location().begin_line);
 }
 
 void codegen::str_gen(string_literal* node) {
     regist_str(node->get_content());
-    gen(op_pstr, str_table[node->get_content()], node->get_location().begin_line);
+    gen(op_pstr, str_table.at(node->get_content()), node->get_location().begin_line);
 }
 
 void codegen::bool_gen(bool_literal* node) {
-    f64 num = node->get_flag()?1:0;
+    f64 num = node->get_flag()? 1:0;
     regist_num(num);
-    gen(op_pnum, num_table[num], node->get_location().begin_line);
+    gen(op_pnum, num_table.at(num), node->get_location().begin_line);
 }
 
 void codegen::vec_gen(vector_expr* node) {
@@ -141,9 +125,9 @@ void codegen::hash_gen(hash_expr* node) {
     gen(op_newh, 0, node->get_location().begin_line);
     for(auto child : node->get_members()) {
         calc_gen(child->get_value());
-        const std::string& str=child->get_name();
-        regist_str(str);
-        gen(op_happ, str_table[str], child->get_location().begin_line);
+        const auto& field_name = child->get_name();
+        regist_str(field_name);
+        gen(op_happ, str_table.at(field_name), child->get_location().begin_line);
     }
 }
 
@@ -151,26 +135,34 @@ void codegen::func_gen(function* node) {
     // parameter list format check
     bool checked_default = false;
     bool checked_dynamic = false;
-    std::unordered_map<std::string,bool> argname;
+    std::unordered_map<std::string, bool> argname;
     for(auto tmp : node->get_parameter_list()) {
-        if (tmp->get_parameter_type()==parameter::param_type::default_parameter) {
+        if (tmp->get_parameter_type()==
+            parameter::param_type::default_parameter) {
             checked_default=true;
-        } else if (tmp->get_parameter_type()==parameter::param_type::dynamic_parameter) {
+        } else if (tmp->get_parameter_type()==
+            parameter::param_type::dynamic_parameter) {
             checked_dynamic=true;
         }
         // check default parameter and dynamic parameter
-        if (checked_default && tmp->get_parameter_type()!=parameter::param_type::default_parameter) {
-            die("must use default parameters here", tmp->get_location());
+        if (checked_default &&
+            tmp->get_parameter_type()!=
+            parameter::param_type::default_parameter) {
+            die("must use default parameter here",
+                tmp->get_location());
         }
-        if (checked_dynamic && tmp!=node->get_parameter_list().back()) {
-            die("dynamic parameter must be the last one", tmp->get_location());
+        if (checked_dynamic &&
+            tmp!=node->get_parameter_list().back()) {
+            die("dynamic parameter must be the last one",
+                tmp->get_location());
         }
         // check redefinition
         const auto& name = tmp->get_parameter_name();
         if (argname.count(name)) {
-            die("redefinition of parameter: "+name, tmp->get_location());
+            die("redefinition of parameter: " + name,
+                tmp->get_location());
         } else {
-            argname[name]=true;
+            argname[name] = true;
         }
     }
 
@@ -187,29 +179,30 @@ void codegen::func_gen(function* node) {
     local.push_back({{"me", 0}});
 
     // generate parameter list
-    for(auto& tmp : node->get_parameter_list()) {
-        const auto& str = tmp->get_parameter_name();
-        if (str=="me") {
-            die("\"me\" should not be a parameter", tmp->get_location());
+    for(auto tmp : node->get_parameter_list()) {
+        const auto& name = tmp->get_parameter_name();
+        if (name=="me") {
+            die("\"me\" should not be a parameter",
+                tmp->get_location());
         }
-        regist_str(str);
+        regist_str(name);
         switch(tmp->get_parameter_type()) {
             case parameter::param_type::normal_parameter:
-                gen(op_para, str_table[str], tmp->get_location().begin_line);
+                gen(op_para, str_table.at(name), tmp->get_location().begin_line);
                 break;
             case parameter::param_type::default_parameter:
                 calc_gen(tmp->get_default_value());
-                gen(op_deft, str_table[str], tmp->get_location().begin_line);
+                gen(op_deft, str_table.at(name), tmp->get_location().begin_line);
                 break;
             case parameter::param_type::dynamic_parameter:
-                gen(op_dyn, str_table[str], tmp->get_location().begin_line);
+                gen(op_dyn, str_table.at(name), tmp->get_location().begin_line);
                 break;
         }
-        add_sym(str);
+        add_sym(name);
     }
 
-    code[newf].num=code.size()+1; // entry
-    usize jmp_ptr=code.size();
+    code[newf].num = code.size()+1; // entry
+    usize jmp_ptr = code.size();
     gen(op_jmp, 0, node->get_location().begin_line);
 
     auto block = node->get_code_block();
@@ -219,9 +212,10 @@ void codegen::func_gen(function* node) {
     in_iterloop.push(0);
     block_gen(block);
     in_iterloop.pop();
-    code[lsize].num=local.back().size();
+    code[lsize].num = local.back().size();
     if (local.back().size()>=STACK_DEPTH) {
-        die("too many local variants: "+std::to_string(local.back().size()), block->get_location());
+        die("too many local variants: " +
+            std::to_string(local.back().size()), block->get_location());
     }
     local.pop_back();
 
@@ -230,7 +224,7 @@ void codegen::func_gen(function* node) {
         gen(op_pnil, 0, block->get_location().begin_line);
         gen(op_ret, 0, block->get_location().begin_line);
     }
-    code[jmp_ptr].num=code.size();
+    code[jmp_ptr].num = code.size();
 }
 
 void codegen::call_gen(call_expr* node) {
@@ -249,11 +243,12 @@ void codegen::call_gen(call_expr* node) {
 
 void codegen::call_id(identifier* node) {
     const auto& name = node->get_name();
-    for(u32 i=0; builtin[i].name; ++i) {
+    for(u32 i = 0; builtin[i].name; ++i) {
         if (builtin[i].name==name) {
             gen(op_callb, i, node->get_location().begin_line);
             if (local.empty()) {
-                die("should warp native function in local scope", node->get_location());
+                die("should warp native function in local scope",
+                    node->get_location());
             }
             return;
         }
@@ -276,7 +271,7 @@ void codegen::call_id(identifier* node) {
 
 void codegen::call_hash_gen(call_hash* node) {
     regist_str(node->get_field());
-    gen(op_callh, str_table[node->get_field()], node->get_location().begin_line);
+    gen(op_callh, str_table.at(node->get_field()), node->get_location().begin_line);
 }
 
 void codegen::call_vec(call_vector* node) {
@@ -287,7 +282,7 @@ void codegen::call_vec(call_vector* node) {
         gen(op_callv, 0, node->get_slices()[0]->get_location().begin_line);
         return;
     }
-    gen(op_slcbeg,0,node->get_location().begin_line);
+    gen(op_slcbeg, 0, node->get_location().begin_line);
     for(auto tmp : node->get_slices()) {
         if (!tmp->get_end()) {
             calc_gen(tmp->get_begin());
@@ -307,9 +302,9 @@ void codegen::call_func(call_function* node) {
         gen(op_newh, 0, node->get_location().begin_line);
         for(auto child : node->get_argument()) {
             calc_gen(((hash_pair*)child)->get_value());
-            const auto& str = ((hash_pair*)child)->get_name();
-            regist_str(str);
-            gen(op_happ, str_table[str], child->get_location().begin_line);
+            const auto& field_name = ((hash_pair*)child)->get_name();
+            regist_str(field_name);
+            gen(op_happ, str_table.at(field_name), child->get_location().begin_line);
         }
         gen(op_callfh, 0, node->get_location().begin_line);
     } else {
@@ -328,34 +323,41 @@ void codegen::call_func(call_function* node) {
 *  so we use another way to avoid gc-caused SIGSEGV: reserve m-called value on stack.
 *  you could see the notes in `vm::opr_mcallv()`.
 */
-void codegen::mcall(call_expr* node) {
-    if (!check_memory_reachable(node)) {
+void codegen::mcall(expr* node) {
+    if (node->get_type()!=expr_type::ast_id &&
+        node->get_type()!=expr_type::ast_call) {
+        die("bad left-value", node->get_location());
         return;
     }
-    if (node->get_first()->get_type()==expr_type::ast_id &&
-        !node->get_calls().size()) {
-        mcall_id((identifier*)node->get_first());
+    if (node->get_type()==expr_type::ast_id) {
+        mcall_id((identifier*)node);
+        return;
     }
-    calc_gen(node->get_first());
-    for(usize i = 0; i<node->get_calls().size()-1; ++i) {
-        auto tmp = node->get_calls()[i];
+    auto call_node = (call_expr*)node;
+    calc_gen(call_node->get_first());
+    for(usize i = 0; i<call_node->get_calls().size()-1; ++i) {
+        auto tmp = call_node->get_calls()[i];
         switch(tmp->get_type()) {
             case expr_type::ast_callh: call_hash_gen((call_hash*)tmp); break;
             case expr_type::ast_callv: call_vec((call_vector*)tmp); break;
             case expr_type::ast_callf: call_func((call_function*)tmp); break;
         }
     }
-    auto tmp = node->get_calls().back();
+    auto tmp = call_node->get_calls().back();
     if (tmp->get_type()==expr_type::ast_callh) {
         mcall_hash((call_hash*)tmp);
     } else if (tmp->get_type()==expr_type::ast_callv) {
         mcall_vec((call_vector*)tmp);
+    } else if (tmp->get_type()==expr_type::ast_callf) {
+        die("bad left-value: function call", tmp->get_location());
+    } else {
+        die("bad left-value: unknown call", tmp->get_location());
     }
 }
 
 void codegen::mcall_id(identifier* node) {
     const auto& name = node->get_name();
-    for(u32 i=0;builtin[i].name;++i) {
+    for(u32 i = 0; builtin[i].name; ++i) {
         if (builtin[i].name==name) {
             die("cannot modify native function", node->get_location());
             return;
@@ -378,13 +380,22 @@ void codegen::mcall_id(identifier* node) {
 }
 
 void codegen::mcall_vec(call_vector* node) {
-    calc_gen(node->get_slices()[0]);
+    if (node->get_slices().size()>1) {
+        die("bad left-value: subvec call", node->get_location());
+        return;
+    }
+    auto call = node->get_slices()[0];
+    if (call->get_end()) {
+        die("bad left-value: subvec call", node->get_location());
+        return;
+    }
+    calc_gen(call->get_begin());
     gen(op_mcallv, 0, node->get_location().begin_line);
 }
 
 void codegen::mcall_hash(call_hash* node) {
     regist_str(node->get_field());
-    gen(op_mcallh, str_table[node->get_field()], node->get_location().begin_line);
+    gen(op_mcallh, str_table.at(node->get_field()), node->get_location().begin_line);
 }
 
 void codegen::single_def(definition_expr* node) {
@@ -396,30 +407,30 @@ void codegen::single_def(definition_expr* node) {
 }
 
 void codegen::multi_def(definition_expr* node) {
-    auto& ids = node->get_variables()->get_variables();
-    usize size = ids.size();
+    auto& identifiers = node->get_variables()->get_variables();
+    usize size = identifiers.size();
     if (node->get_value()->get_type()==expr_type::ast_tuple) { // (var a,b,c)=(c,b,a);
         auto& vals = ((tuple_expr*)node->get_value())->get_elements();
-        if (ids.size()<vals.size()) {
+        if (identifiers.size()<vals.size()) {
             die("lack values in multi-definition", node->get_value()->get_location());
-        } else if (ids.size()>vals.size()) {
+        } else if (identifiers.size()>vals.size()) {
             die("too many values in multi-definition", node->get_value()->get_location());
         }
         for(usize i = 0; i<size; ++i) {
             calc_gen(vals[i]);
-            const auto& str = ids[i]->get_name();
+            const auto& name = identifiers[i]->get_name();
             local.empty()?
-                gen(op_loadg, global_find(str), ids[i]->get_location().begin_line):
-                gen(op_loadl, local_find(str), ids[i]->get_location().begin_line);
+                gen(op_loadg, global_find(name), identifiers[i]->get_location().begin_line):
+                gen(op_loadl, local_find(name), identifiers[i]->get_location().begin_line);
         }
     } else { // (var a,b,c)=[0,1,2];
         calc_gen(node->get_value());
         for(usize i = 0; i<size; ++i) {
             gen(op_callvi, i, node->get_value()->get_location().begin_line);
-            const auto& str = ids[i]->get_name();
+            const auto& name = identifiers[i]->get_name();
             local.empty()?
-                gen(op_loadg, global_find(str), ids[i]->get_location().begin_line):
-                gen(op_loadl, local_find(str), ids[i]->get_location().begin_line);
+                gen(op_loadg, global_find(name), identifiers[i]->get_location().begin_line):
+                gen(op_loadl, local_find(name), identifiers[i]->get_location().begin_line);
         }
         gen(op_pop, 0, node->get_location().begin_line);
     }
@@ -437,14 +448,14 @@ void codegen::assignment_gen(assignment_expr* node) {
     switch(node->get_assignment_type()) {
         case assignment_expr::assign_type::equal:
             calc_gen(node->get_right());
-            mcall((call_expr*)node->get_left());
+            mcall(node->get_left());
             gen(op_meq, 0, node->get_location().begin_line);
             break;
         case assignment_expr::assign_type::add_equal:
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
             }
-            mcall((call_expr*)node->get_left());
+            mcall(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 gen(op_addeq, 0, node->get_location().begin_line);
             } else {
@@ -457,7 +468,7 @@ void codegen::assignment_gen(assignment_expr* node) {
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
             }
-            mcall((call_expr*)node->get_left());
+            mcall(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 gen(op_subeq, 0, node->get_location().begin_line);
             } else {
@@ -470,7 +481,7 @@ void codegen::assignment_gen(assignment_expr* node) {
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
             }
-            mcall((call_expr*)node->get_left());
+            mcall(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 gen(op_muleq, 0, node->get_location().begin_line);
             } else {
@@ -483,7 +494,7 @@ void codegen::assignment_gen(assignment_expr* node) {
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
             }
-            mcall((call_expr*)node->get_left());
+            mcall(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 gen(op_diveq, 0, node->get_location().begin_line);
             } else {
@@ -496,7 +507,7 @@ void codegen::assignment_gen(assignment_expr* node) {
             if (node->get_right()->get_type()!=expr_type::ast_str) {
                 calc_gen(node->get_right());
             }
-            mcall((call_expr*)node->get_left());
+            mcall(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_str) {
                 gen(op_lnkeq, 0, node->get_location().begin_line);
             } else {
@@ -507,17 +518,17 @@ void codegen::assignment_gen(assignment_expr* node) {
             break;
         case assignment_expr::assign_type::bitwise_and_equal:
             calc_gen(node->get_right());
-            mcall((call_expr*)node->get_left());
+            mcall(node->get_left());
             gen(op_btandeq, 0, node->get_location().begin_line);
             break;
         case assignment_expr::assign_type::bitwise_or_equal:
             calc_gen(node->get_right());
-            mcall((call_expr*)node->get_left());
+            mcall(node->get_left());
             gen(op_btoreq, 0, node->get_location().begin_line);
             break;
         case assignment_expr::assign_type::bitwise_xor_equal:
             calc_gen(node->get_right());
-            mcall((call_expr*)node->get_left());
+            mcall(node->get_left());
             gen(op_btxoreq, 0, node->get_location().begin_line);
             break;
     }
@@ -576,12 +587,12 @@ void codegen::multi_assign_gen(multi_assign* node) {
     }
     i32 size = node->get_tuple()->get_elements().size();
     if (node->get_value()->get_type()==expr_type::ast_tuple) {
-        for(i32 i=size-1;i>=0;--i) {
+        for(i32 i = size-1; i>=0; --i) {
             calc_gen(((tuple_expr*)node->get_value())->get_elements()[i]);
         }
         auto& tuple = node->get_tuple()->get_elements();
-        for(i32 i=0;i<size;++i) {
-            mcall((call_expr*)tuple[i]);
+        for(i32 i = 0; i<size; ++i) {
+            mcall(tuple[i]);
             // multi assign user loadl and loadg to avoid meq's stack--
             // and this operation changes local and global value directly
             if (code.back().op==op_mcalll) {
@@ -597,11 +608,11 @@ void codegen::multi_assign_gen(multi_assign* node) {
     } else {
         calc_gen(node->get_value());
         auto& tuple = node->get_tuple()->get_elements();
-        for(i32 i=0;i<size;++i) {
+        for(i32 i = 0; i<size; ++i) {
             gen(op_callvi, i, node->get_value()->get_location().begin_line);
             // multi assign user loadl and loadg to avoid meq's stack--
             // and this operation changes local and global value directly
-            mcall((call_expr*)tuple[i]);
+            mcall(tuple[i]);
             if (code.back().op==op_mcalll) {
                 code.back().op=op_loadl;
             } else if (code.back().op==op_mupval) {
@@ -622,6 +633,11 @@ void codegen::cond_gen(condition_expr* node) {
     auto ptr = code.size();
     gen(op_jf, 0, node->get_if_statement()->get_location().begin_line);
     block_gen(node->get_if_statement()->get_code_block());
+    if (node->get_elsif_stataments().size() ||
+        node->get_else_statement()) {
+        jmp_label.push_back(code.size());
+        gen(op_jmp, 0, node->get_if_statement()->get_location().begin_line);
+    }
     code[ptr].num = code.size();
 
     for(auto tmp : node->get_elsif_stataments()) {
@@ -655,7 +671,8 @@ void codegen::loop_gen(expr* node) {
         case expr_type::ast_for:
             for_gen((for_expr*)node); break;
         case expr_type::ast_forei:
-            if (((forei_expr*)node)->get_loop_type()==forei_expr::forei_loop_type::forindex) {
+            if (((forei_expr*)node)->get_loop_type()==
+                forei_expr::forei_loop_type::forindex) {
                 forindex_gen((forei_expr*)node);
             } else {
                 foreach_gen((forei_expr*)node);
@@ -664,45 +681,46 @@ void codegen::loop_gen(expr* node) {
     }
 }
 
-void codegen::load_continue_break(i32 continue_place,i32 break_place) {
-    for(auto i:continue_ptr.front()) {
-        code[i].num=continue_place;
+void codegen::load_continue_break(i32 continue_place, i32 break_place) {
+    for(auto i : continue_ptr.front()) {
+        code[i].num = continue_place;
     }
-    for(auto i:break_ptr.front()) {
-        code[i].num=break_place;
+    for(auto i : break_ptr.front()) {
+        code[i].num = break_place;
     }
     continue_ptr.pop_front();
     break_ptr.pop_front();
 }
 
 void codegen::while_gen(while_expr* node) {
-    usize loop_ptr=code.size();
+    usize loop_ptr = code.size();
     calc_gen(node->get_condition());
-    usize condition_ptr=code.size();
+    usize condition_ptr = code.size();
     gen(op_jf, 0, node->get_condition()->get_location().begin_line);
 
     block_gen(node->get_code_block());
     gen(op_jmp, loop_ptr, node->get_code_block()->get_location().begin_line);
-    code[condition_ptr].num=code.size();
+    code[condition_ptr].num = code.size();
     load_continue_break(code.size()-1, code.size());
 }
 
 void codegen::for_gen(for_expr* node) {
     expr_gen(node->get_initial());
-    usize jmp_place=code.size();
+    usize jmp_place = code.size();
     if (node->get_condition()->get_type()==expr_type::ast_null) {
-        gen(op_pnum, num_table[1], node->get_condition()->get_location().begin_line);
+        regist_num(1);
+        gen(op_pnum, num_table.at(1), node->get_condition()->get_location().begin_line);
     } else {
         calc_gen(node->get_condition());
     }
-    usize label_exit=code.size();
+    usize label_exit = code.size();
     gen(op_jf, 0, node->get_condition()->get_location().begin_line);
 
     block_gen(node->get_code_block());
-    usize continue_place=code.size();
+    usize continue_place = code.size();
     expr_gen(node->get_step());
     gen(op_jmp, jmp_place, node->get_step()->get_location().begin_line);
-    code[label_exit].num=code.size();
+    code[label_exit].num = code.size();
 
     load_continue_break(continue_place, code.size());
 }
@@ -714,6 +732,8 @@ void codegen::expr_gen(expr* node) {
             def_gen((definition_expr*)node); break;
         case expr_type::ast_multi_assign:
             multi_assign_gen((multi_assign*)node); break;
+        case expr_type::ast_assign:
+            assign_statement((assignment_expr*)node); break;
         case expr_type::ast_nil:case expr_type::ast_num:
         case expr_type::ast_str:case expr_type::ast_bool:break;
         case expr_type::ast_vec:case expr_type::ast_hash:
@@ -724,8 +744,6 @@ void codegen::expr_gen(expr* node) {
             calc_gen(node);
             gen(op_pop, 0, node->get_location().begin_line);
             break;
-        case expr_type::ast_assign:
-            assign_statement((assignment_expr*)node); break;
     }
 }
 
@@ -740,7 +758,7 @@ void codegen::forindex_gen(forei_expr* node) {
             gen(op_loadg, global_find(str), node->get_iterator()->get_name()->get_location().begin_line):
             gen(op_loadl, local_find(str), node->get_iterator()->get_name()->get_location().begin_line);
     } else { // use exist variable as the iterator
-        mcall((call_expr*)node->get_iterator()->get_call());
+        mcall(node->get_iterator()->get_call());
         if (code.back().op==op_mcallg) {
             code.back().op=op_loadg;
         } else if (code.back().op==op_mcalll) {
@@ -772,7 +790,7 @@ void codegen::foreach_gen(forei_expr* node) {
             gen(op_loadg, global_find(str), node->get_iterator()->get_name()->get_location().begin_line):
             gen(op_loadl, local_find(str), node->get_iterator()->get_name()->get_location().begin_line);
     } else { // use exist variable as the iterator
-        mcall((call_expr*)node->get_iterator()->get_call());
+        mcall(node->get_iterator()->get_call());
         if (code.back().op==op_mcallg) {
             code.back().op=op_loadg;
         } else if (code.back().op==op_mcalll) {
@@ -813,14 +831,14 @@ void codegen::and_gen(binary_operator* node) {
     calc_gen(node->get_left());
     gen(op_jt, code.size()+2, node->get_left()->get_location().begin_line);
 
-    usize lfalse=code.size();
+    usize lfalse = code.size();
     gen(op_jmp, 0, node->get_left()->get_location().begin_line);
     gen(op_pop, 0, node->get_right()->get_location().begin_line);// jt jumps here
 
     calc_gen(node->get_right());
     gen(op_jt, code.size()+3, node->get_right()->get_location().begin_line);
 
-    code[lfalse].num=code.size();
+    code[lfalse].num = code.size();
     gen(op_pop, 0, node->get_right()->get_location().begin_line);
     gen(op_pnil, 0, node->get_right()->get_location().begin_line);
     // jt jumps here
@@ -881,7 +899,7 @@ void codegen::binary_gen(binary_operator* node) {
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_addc, num_table[num], node->get_location().begin_line);
+                gen(op_addc, num_table.at(num), node->get_location().begin_line);
             }
             return;
         case binary_operator::binary_type::sub:
@@ -892,7 +910,7 @@ void codegen::binary_gen(binary_operator* node) {
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_subc, num_table[num], node->get_location().begin_line);
+                gen(op_subc, num_table.at(num), node->get_location().begin_line);
             }
             return;
         case binary_operator::binary_type::mult:
@@ -903,7 +921,7 @@ void codegen::binary_gen(binary_operator* node) {
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_mulc, num_table[num], node->get_location().begin_line);
+                gen(op_mulc, num_table.at(num), node->get_location().begin_line);
             }
             return;
         case binary_operator::binary_type::div:
@@ -914,7 +932,7 @@ void codegen::binary_gen(binary_operator* node) {
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_divc, num_table[num], node->get_location().begin_line);
+                gen(op_divc, num_table.at(num), node->get_location().begin_line);
             }
             return;
         case binary_operator::binary_type::concat:
@@ -925,10 +943,9 @@ void codegen::binary_gen(binary_operator* node) {
             } else {
                 const auto& str = ((string_literal*)node->get_right())->get_content();
                 regist_str(str);
-                gen(op_lnkc, str_table[str], node->get_location().begin_line);
+                gen(op_lnkc, str_table.at(str), node->get_location().begin_line);
             }
             break;
-        // ast_cmpeq(27)~ast_geq(32) op_eq(29)~op_geq(34)
         case binary_operator::binary_type::less:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
@@ -937,7 +954,7 @@ void codegen::binary_gen(binary_operator* node) {
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_lessc, num_table[num], node->get_location().begin_line);
+                gen(op_lessc, num_table.at(num), node->get_location().begin_line);
             }
             return;
         case binary_operator::binary_type::leq:
@@ -948,7 +965,7 @@ void codegen::binary_gen(binary_operator* node) {
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_leqc, num_table[num], node->get_location().begin_line);
+                gen(op_leqc, num_table.at(num), node->get_location().begin_line);
             }
             return;
         case binary_operator::binary_type::grt:
@@ -959,7 +976,7 @@ void codegen::binary_gen(binary_operator* node) {
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_grtc, num_table[num], node->get_location().begin_line);
+                gen(op_grtc, num_table.at(num), node->get_location().begin_line);
             }
             return;
         case binary_operator::binary_type::geq:
@@ -970,7 +987,7 @@ void codegen::binary_gen(binary_operator* node) {
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_geqc, num_table[num], node->get_location().begin_line);
+                gen(op_geqc, num_table.at(num), node->get_location().begin_line);
             }
             return;
     }
@@ -978,14 +995,14 @@ void codegen::binary_gen(binary_operator* node) {
 
 void codegen::trino_gen(ternary_operator* node) {
     calc_gen(node->get_condition());
-    usize lfalse=code.size();
+    usize lfalse = code.size();
     gen(op_jf, 0, node->get_condition()->get_location().begin_line);
     calc_gen(node->get_left());
-    usize lexit=code.size();
+    usize lexit = code.size();
     gen(op_jmp, 0, node->get_left()->get_location().begin_line);
-    code[lfalse].num=code.size();
+    code[lfalse].num = code.size();
     calc_gen(node->get_right());
-    code[lexit].num=code.size();
+    code[lexit].num = code.size();
 }
 
 void codegen::calc_gen(expr* node) {
@@ -1017,6 +1034,7 @@ void codegen::calc_gen(expr* node) {
         case expr_type::ast_binary:
             binary_gen((binary_operator*)node); break;
         case expr_type::ast_def:
+            // definition in calculation only should be single def
             single_def((definition_expr*)node);
             call_id(((definition_expr*)node)->get_variable_name());
             break;
@@ -1032,7 +1050,7 @@ void codegen::block_gen(code_block* node) {
             case expr_type::ast_nil:case expr_type::ast_num:
             case expr_type::ast_str:case expr_type::ast_bool:break;
             case expr_type::ast_file_info:
-                fileindex = ((file_info*)tmp)->get_index();break; // special node type in main block
+                fileindex = ((file_info*)tmp)->get_index(); break; // special node type in main block
             case expr_type::ast_cond:
                 cond_gen((condition_expr*)tmp); break;
             case expr_type::ast_continue:
@@ -1053,6 +1071,7 @@ void codegen::block_gen(code_block* node) {
             case expr_type::ast_unary:
             case expr_type::ast_ternary:
             case expr_type::ast_def:
+            case expr_type::ast_assign:
             case expr_type::ast_multi_assign:
                 expr_gen(tmp); break;
             case expr_type::ast_ret:
@@ -1062,7 +1081,7 @@ void codegen::block_gen(code_block* node) {
 }
 
 void codegen::ret_gen(return_expr* node) {
-    for(u32 i=0;i<in_iterloop.top();++i) {
+    for(u32 i = 0; i<in_iterloop.top(); ++i) {
         gen(op_pop, 0, node->get_location().begin_line);
         gen(op_pop, 0, node->get_location().begin_line);
     }
@@ -1071,8 +1090,8 @@ void codegen::ret_gen(return_expr* node) {
 }
 
 const error& codegen::compile(parse& parse, linker& import) {
-    fileindex=0;
-    file=import.filelist().data();
+    fileindex = 0;
+    file = import.filelist().data();
     in_iterloop.push(0);
     find_symbol(parse.tree()); // search symbols first
     gen(op_intg, global.size(), 0);
@@ -1105,21 +1124,21 @@ void codegen::print() {
     std::stack<u32> festk;
 
     // print const numbers
-    for(auto& num:num_res) {
+    for(auto num : num_res) {
         std::cout<<"  .number "<<num<<"\n";
     }
 
     // print const strings
-    for(auto& str:str_res) {
+    for(const auto& str : str_res) {
         std::cout<<"  .symbol \""<<rawstr(str)<<"\"\n";
     }
 
     // print code
     std::cout<<"\n";
     codestream::set(num_res.data(), str_res.data());
-    for(u32 i=0;i<code.size();++i) {
+    for(u32 i = 0; i<code.size(); ++i) {
         // print opcode index, opcode name, opcode immediate number
-        const opcode& c=code[i];
+        const auto& c = code[i];
         if (!festk.empty() && i==festk.top()) {
             std::cout<<std::hex<<"<0x"<<fbstk.top()<<std::dec<<">;\n";
             // avoid two empty lines
@@ -1133,7 +1152,7 @@ void codegen::print() {
         // get function begin index and end index
         if (c.op==op_newf) {
             std::cout<<std::hex<<"\nfunc <0x"<<i<<std::dec<<">:\n";
-            for(u32 j=i;j<code.size();++j) {
+            for(u32 j = i; j<code.size(); ++j) {
                 if (code[j].op==op_jmp) {
                     fbstk.push(i);
                     festk.push(code[j].num);
diff --git a/ast/nasal_new_codegen.h b/ast/nasal_new_codegen.h
index bc398fa..f21bd16 100644
--- a/ast/nasal_new_codegen.h
+++ b/ast/nasal_new_codegen.h
@@ -40,7 +40,6 @@ private:
     // but in fact local scope also has less than STACK_DEPTH value
     std::list<std::unordered_map<std::string,i32>> local;
 
-    bool check_memory_reachable(expr*);
     void check_id_exist(identifier*);
     
     void die(const std::string& info, const span& loc) {
@@ -68,7 +67,7 @@ private:
     void call_hash_gen(call_hash*);
     void call_vec(call_vector*);
     void call_func(call_function*);
-    void mcall(call_expr*);
+    void mcall(expr*);
     void mcall_id(identifier*);
     void mcall_vec(call_vector*);
     void mcall_hash(call_hash*);
diff --git a/ast/nasal_new_parse.cpp b/ast/nasal_new_parse.cpp
index fd680c7..e83a6a8 100644
--- a/ast/nasal_new_parse.cpp
+++ b/ast/nasal_new_parse.cpp
@@ -939,14 +939,21 @@ iter_expr* parse::iter_gen() {
     if (lookahead(tok::var)) {
         match(tok::var);
         node->set_name(id());
-    } else {
-        auto tmp = new call_expr(toks[ptr].loc);
-        tmp->set_first(id());
-        while(is_call(toks[ptr].type)) {
-            tmp->add_call(call_scalar());
-        }
-        node->set_call(tmp);
+        update_location(node);
+        return node;
     }
+    auto id_node = id();
+    if (!is_call(toks[ptr].type)) {
+        node->set_name(id_node);
+        update_location(node);
+        return node;
+    }
+    auto tmp = new call_expr(id_node->get_location());
+    tmp->set_first(id());
+    while(is_call(toks[ptr].type)) {
+        tmp->add_call(call_scalar());
+    }
+    node->set_call(tmp);
     update_location(node);
     return node;
 }
diff --git a/ast/nasal_new_vm.h b/ast/nasal_new_vm.h
index 5c686fd..9bfe4c9 100644
--- a/ast/nasal_new_vm.h
+++ b/ast/nasal_new_vm.h
@@ -144,6 +144,7 @@ protected:
     void o_mcallv();
     void o_mcallh();
     void o_ret();
+
 public:
 
     /* constructor of vm instance */

From 597c0388cb2dab46b43282da896b8095f5bb799b Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sat, 1 Jul 2023 23:21:52 +0800
Subject: [PATCH 27/34] :rocket: update

---
 ast/nasal_new_vm.h                         |  160 --
 makefile                                   |   98 +-
 {ast => src}/ast_dumper.cpp                |    0
 {ast => src}/ast_dumper.h                  |    0
 {ast => src}/ast_visitor.cpp               |    0
 {ast => src}/ast_visitor.h                 |    0
 {ast => src}/nasal_new_ast.cpp             |    0
 {ast => src}/nasal_new_ast.h               |    0
 {ast => src}/nasal_new_builtin.cpp         |    0
 {ast => src}/nasal_new_builtin.h           |    0
 {ast => src}/nasal_new_codegen.cpp         |    0
 {ast => src}/nasal_new_codegen.h           |    0
 {ast => src}/nasal_new_dbg.cpp             |    0
 {ast => src}/nasal_new_dbg.h               |    1 +
 {ast => src}/nasal_new_err.cpp             |    9 +
 {ast => src}/nasal_new_err.h               |   10 -
 {ast => src}/nasal_new_gc.cpp              |   78 +-
 {ast => src}/nasal_new_gc.h                |   11 +-
 {ast => src}/nasal_new_header.h            |    0
 {ast => src}/nasal_new_import.cpp          |    0
 {ast => src}/nasal_new_import.h            |    0
 {ast => src}/nasal_new_lexer.cpp           |    0
 {ast => src}/nasal_new_lexer.h             |    0
 {ast => src}/nasal_new_main.cpp            |   49 +-
 {ast => src}/nasal_new_misc.cpp            |    0
 {ast => src}/nasal_new_opcode.cpp          |    0
 {ast => src}/nasal_new_opcode.h            |    0
 {ast => src}/nasal_new_parse.cpp           |    0
 {ast => src}/nasal_new_parse.h             |    0
 src/nasal_new_vm.cpp                       |  412 ++++
 ast/nasal_new_vm.cpp => src/nasal_new_vm.h | 2010 +++++++++-----------
 {ast => src}/optimizer.cpp                 |    0
 {ast => src}/optimizer.h                   |    0
 {ast => src}/symbol_finder.cpp             |    1 +
 {ast => src}/symbol_finder.h               |    0
 35 files changed, 1436 insertions(+), 1403 deletions(-)
 delete mode 100644 ast/nasal_new_vm.h
 rename {ast => src}/ast_dumper.cpp (100%)
 rename {ast => src}/ast_dumper.h (100%)
 rename {ast => src}/ast_visitor.cpp (100%)
 rename {ast => src}/ast_visitor.h (100%)
 rename {ast => src}/nasal_new_ast.cpp (100%)
 rename {ast => src}/nasal_new_ast.h (100%)
 rename {ast => src}/nasal_new_builtin.cpp (100%)
 rename {ast => src}/nasal_new_builtin.h (100%)
 rename {ast => src}/nasal_new_codegen.cpp (100%)
 rename {ast => src}/nasal_new_codegen.h (100%)
 rename {ast => src}/nasal_new_dbg.cpp (100%)
 rename {ast => src}/nasal_new_dbg.h (96%)
 rename {ast => src}/nasal_new_err.cpp (91%)
 rename {ast => src}/nasal_new_err.h (85%)
 rename {ast => src}/nasal_new_gc.cpp (81%)
 rename {ast => src}/nasal_new_gc.h (97%)
 rename {ast => src}/nasal_new_header.h (100%)
 rename {ast => src}/nasal_new_import.cpp (100%)
 rename {ast => src}/nasal_new_import.h (100%)
 rename {ast => src}/nasal_new_lexer.cpp (100%)
 rename {ast => src}/nasal_new_lexer.h (100%)
 rename {ast => src}/nasal_new_main.cpp (81%)
 rename {ast => src}/nasal_new_misc.cpp (100%)
 rename {ast => src}/nasal_new_opcode.cpp (100%)
 rename {ast => src}/nasal_new_opcode.h (100%)
 rename {ast => src}/nasal_new_parse.cpp (100%)
 rename {ast => src}/nasal_new_parse.h (100%)
 create mode 100644 src/nasal_new_vm.cpp
 rename ast/nasal_new_vm.cpp => src/nasal_new_vm.h (50%)
 rename {ast => src}/optimizer.cpp (100%)
 rename {ast => src}/optimizer.h (100%)
 rename {ast => src}/symbol_finder.cpp (94%)
 rename {ast => src}/symbol_finder.h (100%)

diff --git a/ast/nasal_new_vm.h b/ast/nasal_new_vm.h
deleted file mode 100644
index 9bfe4c9..0000000
--- a/ast/nasal_new_vm.h
+++ /dev/null
@@ -1,160 +0,0 @@
-#pragma once
-
-#include <iomanip>
-#include <stack>
-
-#include "nasal_new_import.h"
-#include "nasal_new_gc.h"
-#include "nasal_new_codegen.h"
-
-#ifdef _MSC_VER
-#pragma warning (disable:4244)
-#pragma warning (disable:4267)
-#pragma warning (disable:4102)
-#endif
-
-class vm {
-protected:
-
-    /* registers and constants of vm */
-    context ctx;
-
-    /* constants */
-    const f64* cnum=nullptr;    // constant numbers
-    const std::string* cstr=nullptr; // constant symbols and strings
-    std::vector<u32> imm;       // immediate number table
-    
-    /* garbage collector */
-    gc ngc;
-
-    /* main stack */
-    var stack[STACK_DEPTH];
-
-    /* values used for debugger */
-    const std::string* files=nullptr;    // file name list
-    const opcode* bytecode=nullptr; // bytecode buffer address
-
-    /* vm initializing function */
-    void init(
-        const std::vector<std::string>&,
-        const std::vector<f64>&,
-        const std::vector<opcode>&,
-        const std::vector<std::string>&,
-        const std::vector<std::string>&);
-
-    /* debug functions */
-    bool verbose;
-    void valinfo(var&);
-    void traceback();
-    void stackinfo(const u32);
-    void reginfo();
-    void gstate();
-    void lstate();
-    void ustate();
-    void detail();
-    void die(const std::string&);
-
-    /* vm calculation functions*/
-    bool cond(var&);
-
-    /* vm operands */
-    void o_intg();
-    void o_intl();
-    void o_loadg();
-    void o_loadl();
-    void o_loadu();
-    void o_pnum();
-    void o_pnil();
-    void o_pstr();
-    void o_newv();
-    void o_newh();
-    void o_newf();
-    void o_happ();
-    void o_para();
-    void o_deft();
-    void o_dyn();
-    void o_lnot();
-    void o_usub();
-    void o_bnot();
-    void o_btor();
-    void o_btxor();
-    void o_btand();
-    void o_add();
-    void o_sub();
-    void o_mul();
-    void o_div();
-    void o_lnk();
-    void o_addc();
-    void o_subc();
-    void o_mulc();
-    void o_divc();
-    void o_lnkc();
-    void o_addeq();
-    void o_subeq();
-    void o_muleq();
-    void o_diveq();
-    void o_lnkeq();
-    void o_bandeq();
-    void o_boreq();
-    void o_bxoreq();
-    void o_addeqc();
-    void o_subeqc();
-    void o_muleqc();
-    void o_diveqc();
-    void o_lnkeqc();
-    void o_addecp();
-    void o_subecp();
-    void o_mulecp();
-    void o_divecp();
-    void o_lnkecp();
-    void o_meq();
-    void o_eq();
-    void o_neq();
-    void o_less();
-    void o_leq();
-    void o_grt();
-    void o_geq();
-    void o_lessc();
-    void o_leqc();
-    void o_grtc();
-    void o_geqc();
-    void o_pop();
-    void o_jmp();
-    void o_jt();
-    void o_jf();
-    void o_cnt();
-    void o_findex();
-    void o_feach();
-    void o_callg();
-    void o_calll();
-    void o_upval();
-    void o_callv();
-    void o_callvi();
-    void o_callh();
-    void o_callfv();
-    void o_callfh();
-    void o_callb();
-    void o_slcbeg();
-    void o_slcend();
-    void o_slc();
-    void o_slc2();
-    void o_mcallg();
-    void o_mcalll();
-    void o_mupval();
-    void o_mcallv();
-    void o_mcallh();
-    void o_ret();
-
-public:
-
-    /* constructor of vm instance */
-    vm(): ngc(&ctx), verbose(false) {}
-
-    /* execution entry */
-    void run(
-        const codegen&,
-        const linker&,
-        const std::vector<std::string>&,
-        const bool
-    );
-};
diff --git a/makefile b/makefile
index c6c5715..08c5a68 100644
--- a/makefile
+++ b/makefile
@@ -74,79 +74,81 @@ test:nasal
 	@ ./nasal -t -d test/ycombinator.nas
 
 NASAL_NEW_AST=\
-	nasal_new_misc.o\
 	nasal_new_err.o\
-	nasal_new_gc.o\
-	nasal_new_import.o\
-	nasal_new_lexer.o\
 	nasal_new_ast.o\
-	nasal_new_builtin.o\
-	nasal_new_codegen.o\
-	nasal_new_opcode.o\
-	nasal_new_parse.o\
-	nasal_new_vm.o\
-	nasal_new_dbg.o\
-	optimizer.o\
-	symbol_finder.o\
 	ast_visitor.o\
 	ast_dumper.o\
+	nasal_new_lexer.o\
+	nasal_new_parse.o\
+	nasal_new_import.o\
+	optimizer.o\
+	nasal_new_opcode.o\
+	symbol_finder.o\
+	nasal_new_codegen.o\
+	nasal_new_misc.o\
+	nasal_new_gc.o\
+	nasal_new_builtin.o\
+	nasal_new_vm.o\
+	nasal_new_dbg.o\
 	nasal_new_main.o
 
 # for test
 nnew: $(NASAL_NEW_AST)
-	$(CXX) $(NASAL_NEW_AST) -o nnew -ldl
-	@ echo "build done"
+	$(CXX) $(NASAL_NEW_AST) -O3 -o nnew -ldl
 
-nasal_new_main.o: ast/nasal_new_main.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_main.cpp -fno-exceptions -fPIC -o nasal_new_main.o -I .
+nnew.exe: $(NASAL_NEW_AST)
+	$(CXX) $(NASAL_NEW_AST) -O3 -o nnew.exe
 
-nasal_new_misc.o: ast/nasal_new_header.h ast/nasal_new_misc.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_misc.cpp -fno-exceptions -fPIC -o nasal_new_misc.o -I .
+nasal_new_main.o: src/nasal_new_main.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_main.cpp -fno-exceptions -fPIC -o nasal_new_main.o -I .
 
-nasal_new_err.o: ast/nasal_new_err.h ast/nasal_new_err.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_err.cpp -fno-exceptions -fPIC -o nasal_new_err.o -I .
+nasal_new_misc.o: src/nasal_new_header.h src/nasal_new_misc.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_misc.cpp -fno-exceptions -fPIC -o nasal_new_misc.o -I .
 
-nasal_new_gc.o: ast/nasal_new_gc.h ast/nasal_new_gc.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_gc.cpp -fno-exceptions -fPIC -o nasal_new_gc.o -I . 
+nasal_new_err.o: src/nasal_new_err.h src/nasal_new_err.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_err.cpp -fno-exceptions -fPIC -o nasal_new_err.o -I .
 
-nasal_new_import.o: ast/nasal_new_import.h ast/nasal_new_import.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_import.cpp -fno-exceptions -fPIC -o nasal_new_import.o -I .
+nasal_new_gc.o: src/nasal_new_gc.h src/nasal_new_gc.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_gc.cpp -fno-exceptions -fPIC -o nasal_new_gc.o -I . 
 
-nasal_new_lexer.o: ast/nasal_new_lexer.h ast/nasal_new_lexer.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.o -I .
+nasal_new_import.o: src/nasal_new_import.h src/nasal_new_import.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_import.cpp -fno-exceptions -fPIC -o nasal_new_import.o -I .
 
-nasal_new_ast.o: ast/nasal_new_ast.h ast/nasal_new_ast.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
+nasal_new_lexer.o: src/nasal_new_lexer.h src/nasal_new_lexer.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.o -I .
 
-nasal_new_builtin.o: ast/nasal_new_builtin.h ast/nasal_new_builtin.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_builtin.cpp -fno-exceptions -fPIC -o nasal_new_builtin.o -I .
+nasal_new_ast.o: src/nasal_new_ast.h src/nasal_new_ast.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
 
-nasal_new_codegen.o: ast/nasal_new_codegen.h ast/nasal_new_codegen.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.o -I .
+nasal_new_builtin.o: src/nasal_new_builtin.h src/nasal_new_builtin.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_builtin.cpp -fno-exceptions -fPIC -o nasal_new_builtin.o -I .
 
-nasal_new_opcode.o: ast/nasal_new_opcode.h ast/nasal_new_opcode.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_opcode.cpp -fno-exceptions -fPIC -o nasal_new_opcode.o -I .
+nasal_new_codegen.o: src/nasal_new_codegen.h src/nasal_new_codegen.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.o -I .
 
-nasal_new_parse.o: ast/nasal_new_parse.h ast/nasal_new_parse.cpp ast/nasal_new_ast.h
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_parse.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
+nasal_new_opcode.o: src/nasal_new_opcode.h src/nasal_new_opcode.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_opcode.cpp -fno-exceptions -fPIC -o nasal_new_opcode.o -I .
 
-optimizer.o: ast/optimizer.h ast/optimizer.cpp ast/nasal_new_ast.h
-	$(CXX) -std=$(STD) -c -O3 ast/optimizer.cpp -fno-exceptions -fPIC -o optimizer.o -I .
+nasal_new_parse.o: src/nasal_new_parse.h src/nasal_new_parse.cpp src/nasal_new_ast.h
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_parse.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
 
-symbol_finder.o: ast/symbol_finder.h ast/symbol_finder.cpp ast/nasal_new_ast.h
-	$(CXX) -std=$(STD) -c -O3 ast/symbol_finder.cpp -fno-exceptions -fPIC -o symbol_finder.o -I .
+optimizer.o: src/optimizer.h src/optimizer.cpp src/nasal_new_ast.h
+	$(CXX) -std=$(STD) -c -O3 src/optimizer.cpp -fno-exceptions -fPIC -o optimizer.o -I .
 
-ast_visitor.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_visitor.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .
+symbol_finder.o: src/symbol_finder.h src/symbol_finder.cpp src/nasal_new_ast.h
+	$(CXX) -std=$(STD) -c -O3 src/symbol_finder.cpp -fno-exceptions -fPIC -o symbol_finder.o -I .
 
-ast_dumper.o: ast/nasal_new_ast.h ast/ast_visitor.h ast/ast_dumper.h ast/ast_dumper.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/ast_dumper.cpp -fno-exceptions -fPIC -o ast_dumper.o -I .
+ast_visitor.o: src/nasal_new_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 .
 
-nasal_new_vm.o: ast/nasal_new_vm.h ast/nasal_new_vm.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_vm.cpp -fno-exceptions -fPIC -o nasal_new_vm.o -I .
+ast_dumper.o: src/nasal_new_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 .
 
-nasal_new_dbg.o: ast/nasal_new_dbg.h ast/nasal_new_dbg.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_dbg.cpp -fno-exceptions -fPIC -o nasal_new_dbg.o -I .
+nasal_new_vm.o: src/nasal_new_vm.h src/nasal_new_vm.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_vm.cpp -fno-exceptions -fPIC -o nasal_new_vm.o -I .
+
+nasal_new_dbg.o: src/nasal_new_dbg.h src/nasal_new_dbg.cpp
+	$(CXX) -std=$(STD) -c -O3 src/nasal_new_dbg.cpp -fno-exceptions -fPIC -o nasal_new_dbg.o -I .
 
 .PHONY: nasal_new_clean
 nasal_new_clean:
diff --git a/ast/ast_dumper.cpp b/src/ast_dumper.cpp
similarity index 100%
rename from ast/ast_dumper.cpp
rename to src/ast_dumper.cpp
diff --git a/ast/ast_dumper.h b/src/ast_dumper.h
similarity index 100%
rename from ast/ast_dumper.h
rename to src/ast_dumper.h
diff --git a/ast/ast_visitor.cpp b/src/ast_visitor.cpp
similarity index 100%
rename from ast/ast_visitor.cpp
rename to src/ast_visitor.cpp
diff --git a/ast/ast_visitor.h b/src/ast_visitor.h
similarity index 100%
rename from ast/ast_visitor.h
rename to src/ast_visitor.h
diff --git a/ast/nasal_new_ast.cpp b/src/nasal_new_ast.cpp
similarity index 100%
rename from ast/nasal_new_ast.cpp
rename to src/nasal_new_ast.cpp
diff --git a/ast/nasal_new_ast.h b/src/nasal_new_ast.h
similarity index 100%
rename from ast/nasal_new_ast.h
rename to src/nasal_new_ast.h
diff --git a/ast/nasal_new_builtin.cpp b/src/nasal_new_builtin.cpp
similarity index 100%
rename from ast/nasal_new_builtin.cpp
rename to src/nasal_new_builtin.cpp
diff --git a/ast/nasal_new_builtin.h b/src/nasal_new_builtin.h
similarity index 100%
rename from ast/nasal_new_builtin.h
rename to src/nasal_new_builtin.h
diff --git a/ast/nasal_new_codegen.cpp b/src/nasal_new_codegen.cpp
similarity index 100%
rename from ast/nasal_new_codegen.cpp
rename to src/nasal_new_codegen.cpp
diff --git a/ast/nasal_new_codegen.h b/src/nasal_new_codegen.h
similarity index 100%
rename from ast/nasal_new_codegen.h
rename to src/nasal_new_codegen.h
diff --git a/ast/nasal_new_dbg.cpp b/src/nasal_new_dbg.cpp
similarity index 100%
rename from ast/nasal_new_dbg.cpp
rename to src/nasal_new_dbg.cpp
diff --git a/ast/nasal_new_dbg.h b/src/nasal_new_dbg.h
similarity index 96%
rename from ast/nasal_new_dbg.h
rename to src/nasal_new_dbg.h
index d05bc25..9d0fcdf 100644
--- a/ast/nasal_new_dbg.h
+++ b/src/nasal_new_dbg.h
@@ -74,6 +74,7 @@ private:
     void call_sort(const u64*) const;
     void step_info();
     void interact();
+
 public:
     dbg(error& err):
         next(false), fsize(0),
diff --git a/ast/nasal_new_err.cpp b/src/nasal_new_err.cpp
similarity index 91%
rename from ast/nasal_new_err.cpp
rename to src/nasal_new_err.cpp
index 7cf657d..8e7f7ec 100644
--- a/ast/nasal_new_err.cpp
+++ b/src/nasal_new_err.cpp
@@ -1,4 +1,13 @@
 #include "nasal_new_err.h"
+#ifdef _WIN32
+#include <windows.h> // use SetConsoleTextAttribute
+struct for_reset {
+    CONSOLE_SCREEN_BUFFER_INFO scr;
+    for_reset() {
+        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &scr);
+    }
+} reset_ter_color;
+#endif
 
 std::ostream& back_white(std::ostream& s) {
 #ifdef _WIN32
diff --git a/ast/nasal_new_err.h b/src/nasal_new_err.h
similarity index 85%
rename from ast/nasal_new_err.h
rename to src/nasal_new_err.h
index 192300b..5f73b05 100644
--- a/ast/nasal_new_err.h
+++ b/src/nasal_new_err.h
@@ -16,16 +16,6 @@ struct span {
     std::string file;
 };
 
-#ifdef _WIN32
-#include <windows.h> // use SetConsoleTextAttribute
-struct for_reset {
-    CONSOLE_SCREEN_BUFFER_INFO scr;
-    for_reset() {
-        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &scr);
-    }
-} reset_ter_color;
-#endif
-
 std::ostream& back_white(std::ostream&);
 std::ostream& red(std::ostream&);
 std::ostream& cyan(std::ostream&);
diff --git a/ast/nasal_new_gc.cpp b/src/nasal_new_gc.cpp
similarity index 81%
rename from ast/nasal_new_gc.cpp
rename to src/nasal_new_gc.cpp
index ecd7ab2..8747397 100644
--- a/ast/nasal_new_gc.cpp
+++ b/src/nasal_new_gc.cpp
@@ -466,57 +466,71 @@ void gc::info() {
     using std::left;
     using std::setw;
     using std::setfill;
-    const char* name[]={"str  ","vec  ","hash ","func ","upval","obj  ","co   "};
-    std::clog<<"\ngc info (gc count|alloc count|memory size)\n";
+    const char* name[] = {
+        "string   ",
+        "vector   ",
+        "hashmap  ",
+        "function ",
+        "upvalue  ",
+        "object   ",
+        "coroutine"
+    };
 
-    usize ident=0;
+    usize indent=0;
     for(u8 i=0;i<gc_type_size;++i) {
-#ifndef _MSC_VER
-        usize len=std::max({
-            std::to_string(gcnt[i]).length(),
-            std::to_string(acnt[i]).length(),
-            std::to_string(size[i]).length()
-        });
-#else // VS is a piece of shit
-        usize len=std::to_string(gcnt[i]).length();
-        ident=ident<len?len:ident;
-        len=std::to_string(acnt[i]).length();
-        ident=ident<len?len:ident;
-        len=std::to_string(size[i]).length();
-#endif
-        ident=ident<len?len:ident;
+        usize len = 0;
+        len = std::to_string(gcnt[i]).length();
+        indent = indent<len? len:indent;
+        len = std::to_string(acnt[i]).length();
+        indent = indent<len? len:indent;
+        len = std::to_string(size[i]).length();
+        indent = indent<len? len:indent;
     }
 
     double total=0;
-    for(u8 i=0;i<gc_type_size;++i) {
-        if (gcnt[i] || acnt[i] || size[i]) {
-            total+=gcnt[i];
-            std::clog<<" "<<name[i];
-            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<gcnt[i];
-            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<acnt[i];
-            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<size[i];
-            std::clog<<"\n";
+    std::clog << "\ngc info (gc count|alloc count|memory size)\n";
+    for(u8 i = 0; i<gc_type_size; ++i) {
+        if (!gcnt[i] && !acnt[i] && !size[i]) {
+            continue;
         }
+        total += gcnt[i];
+        std::clog << " " << name[i];
+        std::clog << " | " << left << setw(indent) << setfill(' ') << gcnt[i];
+        std::clog << " | " << left << setw(indent) << setfill(' ') << acnt[i];
+        std::clog << " | " << left << setw(indent) << setfill(' ') << size[i];
+        std::clog << "\n";
     }
 
-    double sec=worktime*1.0/1000000000; // seconds
-    std::clog<<" time  | "<<(sec<0.1? sec*1000:sec)<<(sec<0.1? " ms\n":" s\n");
+    auto den = std::chrono::high_resolution_clock::duration::period::den;
+    std::clog << " gc time   | " << worktime*1.0/den*1000 << " ms\n";
     if (total) {
-        std::clog<<" avg   | "<<sec/total*1000<<" ms\n";
+        std::clog << " avg time  | " << worktime*1.0/den*1000/total << " ms\n";
+        std::clog << " max gc    | " << max_time*1.0/den*1000 << " ms\n";
+        std::clog << " max mark  | " << max_mark_time*1.0/den*1000 << " ms\n";
+        std::clog << " max sweep | " << max_sweep_time*1.0/den*1000 << " ms\n";
     }
     std::clog<<"\n";
 }
 
 var gc::alloc(u8 type) {
-    using clk=std::chrono::high_resolution_clock;
-    const u8 index=type-vm_str;
+    using clk = std::chrono::high_resolution_clock;
+    const u8 index = type-vm_str;
     ++acnt[index];
     if (unused[index].empty()) {
         ++gcnt[index];
-        auto begin=clk::now();
+        auto begin = clk::now();
         mark();
+        auto mark_end = clk::now();
         sweep();
-        worktime+=(clk::now()-begin).count();
+        auto sweep_end = clk::now();
+        
+        auto total_time = (sweep_end-begin).count();
+        auto mark_time = (mark_end-begin).count();
+        auto sweep_time = (sweep_end-mark_end).count();
+        worktime += total_time;
+        max_time = max_time<total_time? total_time:max_time;
+        max_mark_time = max_mark_time<mark_time? mark_time:max_mark_time;
+        max_sweep_time = max_sweep_time<sweep_time? sweep_time:max_sweep_time;
     }
     if (unused[index].empty()) {
         extend(type);
diff --git a/ast/nasal_new_gc.h b/src/nasal_new_gc.h
similarity index 97%
rename from ast/nasal_new_gc.h
rename to src/nasal_new_gc.h
index ba6b356..75cacb4 100644
--- a/ast/nasal_new_gc.h
+++ b/src/nasal_new_gc.h
@@ -327,8 +327,8 @@ struct gc {
     context mctx;
 
     /* runtime context */
-    context* rctx;
-    nas_co* cort=nullptr; // running coroutine
+    context* rctx = nullptr;
+    nas_co* cort = nullptr; // running coroutine
 
     /*  temporary space used in builtin/module functions */
     var temp=nil;
@@ -340,7 +340,7 @@ struct gc {
     std::vector<nas_val*> unused[gc_type_size]; // gc free list
 
     /* heap increase size */
-    u32 incr[gc_type_size]={
+    u32 incr[gc_type_size] = {
         128, // vm_str
         128, // vm_vec
         64,  // vm_hash
@@ -354,7 +354,10 @@ struct gc {
     u64 size[gc_type_size];
     u64 gcnt[gc_type_size];
     u64 acnt[gc_type_size];
-    i64 worktime=0;
+    i64 worktime = 0;
+    i64 max_time = 0;
+    i64 max_mark_time = 0;
+    i64 max_sweep_time = 0;
 
     gc(context* _ctx): rctx(_ctx) {}
 
diff --git a/ast/nasal_new_header.h b/src/nasal_new_header.h
similarity index 100%
rename from ast/nasal_new_header.h
rename to src/nasal_new_header.h
diff --git a/ast/nasal_new_import.cpp b/src/nasal_new_import.cpp
similarity index 100%
rename from ast/nasal_new_import.cpp
rename to src/nasal_new_import.cpp
diff --git a/ast/nasal_new_import.h b/src/nasal_new_import.h
similarity index 100%
rename from ast/nasal_new_import.h
rename to src/nasal_new_import.h
diff --git a/ast/nasal_new_lexer.cpp b/src/nasal_new_lexer.cpp
similarity index 100%
rename from ast/nasal_new_lexer.cpp
rename to src/nasal_new_lexer.cpp
diff --git a/ast/nasal_new_lexer.h b/src/nasal_new_lexer.h
similarity index 100%
rename from ast/nasal_new_lexer.h
rename to src/nasal_new_lexer.h
diff --git a/ast/nasal_new_main.cpp b/src/nasal_new_main.cpp
similarity index 81%
rename from ast/nasal_new_main.cpp
rename to src/nasal_new_main.cpp
index 94196ad..d397166 100644
--- a/ast/nasal_new_main.cpp
+++ b/src/nasal_new_main.cpp
@@ -15,12 +15,13 @@
 #include <unordered_map>
 #include <thread>
 
-const u32 VM_AST   =0x01;
-const u32 VM_CODE  =0x02;
-const u32 VM_TIME  =0x04;
-const u32 VM_EXEC  =0x08;
-const u32 VM_DETAIL=0x10;
-const u32 VM_DEBUG =0x20;
+const u32 VM_RAW_AST = 1;
+const u32 VM_AST     = 1<<1;
+const u32 VM_CODE    = 1<<2;
+const u32 VM_TIME    = 1<<3;
+const u32 VM_EXEC    = 1<<4;
+const u32 VM_DETAIL  = 1<<5;
+const u32 VM_DEBUG   = 1<<6;
 
 std::ostream& help(std::ostream& out) {
     out
@@ -32,19 +33,20 @@ std::ostream& help(std::ostream& out) {
 #endif
     <<"\nnasal <option>\n"
     <<"option:\n"
-    <<"   -h,   --help   | get help.\n"
+    <<"   -h,   --help    | get help.\n"
     <<"\nnasal [option] <file> [argv]\n"
     <<"option:\n"
-    <<"   -a,   --ast    | view abstract syntax tree.\n"
-    <<"   -c,   --code   | view bytecode.\n"
-    <<"   -e,   --exec   | execute.\n"
-    <<"   -t,   --time   | show execute time.\n"
-    <<"   -d,   --detail | get detail info.\n"
-    <<"   -dbg, --debug  | debug mode.\n"
+    <<"   -a,   --ast     | view ast (after link/optimize process).\n"
+    <<"         --raw-ast | view ast without after-processing.\n"
+    <<"   -c,   --code    | view bytecode.\n"
+    <<"   -e,   --exec    | execute.\n"
+    <<"   -t,   --time    | show execute time.\n"
+    <<"   -d,   --detail  | get detail info.\n"
+    <<"   -dbg, --debug   | debug mode.\n"
     <<"file:\n"
-    <<"   <filename>     | execute file.\n"
+    <<"   <filename>      | execute file.\n"
     <<"argv:\n"
-    <<"   <args>         | cmd arguments used in program.\n";
+    <<"   <args>          | cmd arguments used in program.\n";
     return out;
 }
 
@@ -93,18 +95,24 @@ void execute(
 
     // parser gets lexer's token list to compile
     parse.compile(lex).chkerr();
+    if (cmd&VM_RAW_AST) {
+        auto dumper = new ast_dumper;
+        dumper->dump(parse.tree());
+        delete dumper;
+    }
 
     // linker gets parser's ast and load import files to this ast
     ld.link(parse, file, cmd&VM_DETAIL).chkerr();
-    if (cmd&VM_AST) {
-        auto dumper = new ast_dumper();
-        dumper->dump(parse.tree());
-    }
-
+    
     // optimizer does simple optimization on ast
     auto opt = new optimizer;
     opt->do_optimization(parse.tree());
     delete opt;
+    if (cmd&VM_AST) {
+        auto dumper = new ast_dumper;
+        dumper->dump(parse.tree());
+        delete dumper;
+    }
 
     // code generator gets parser's ast and import file list to generate code
     gen.compile(parse, ld).chkerr();
@@ -149,6 +157,7 @@ i32 main(i32 argc, const char* argv[]) {
 
     // execute with arguments
     const std::unordered_map<std::string,u32> cmdlst = {
+        {"--raw-ast", VM_RAW_AST},
         {"--ast", VM_AST},
         {"-a", VM_AST},
         {"--code", VM_CODE},
diff --git a/ast/nasal_new_misc.cpp b/src/nasal_new_misc.cpp
similarity index 100%
rename from ast/nasal_new_misc.cpp
rename to src/nasal_new_misc.cpp
diff --git a/ast/nasal_new_opcode.cpp b/src/nasal_new_opcode.cpp
similarity index 100%
rename from ast/nasal_new_opcode.cpp
rename to src/nasal_new_opcode.cpp
diff --git a/ast/nasal_new_opcode.h b/src/nasal_new_opcode.h
similarity index 100%
rename from ast/nasal_new_opcode.h
rename to src/nasal_new_opcode.h
diff --git a/ast/nasal_new_parse.cpp b/src/nasal_new_parse.cpp
similarity index 100%
rename from ast/nasal_new_parse.cpp
rename to src/nasal_new_parse.cpp
diff --git a/ast/nasal_new_parse.h b/src/nasal_new_parse.h
similarity index 100%
rename from ast/nasal_new_parse.h
rename to src/nasal_new_parse.h
diff --git a/src/nasal_new_vm.cpp b/src/nasal_new_vm.cpp
new file mode 100644
index 0000000..0ded3a2
--- /dev/null
+++ b/src/nasal_new_vm.cpp
@@ -0,0 +1,412 @@
+#include "nasal_new_vm.h"
+
+void vm::init(
+    const std::vector<std::string>& strs,
+    const std::vector<f64>&    nums,
+    const std::vector<opcode>& code,
+    const std::vector<std::string>& filenames,
+    const std::vector<std::string>& argv
+) {
+    cnum=nums.data();
+    cstr=strs.data();
+    bytecode=code.data();
+    files=filenames.data();
+
+    /* set canary and program counter */
+    ctx.pc=0;
+    ctx.localr=ctx.memr=nullptr;
+    ctx.funcr=ctx.upvalr=nil;
+    ctx.canary=stack+STACK_DEPTH-1; // stack[STACK_DEPTH-1]
+    ctx.top=stack;
+    ctx.stack=stack;
+
+    /* clear main stack */
+    for(u32 i=0;i<STACK_DEPTH;++i) {
+        stack[i]=nil;
+    }
+
+    /* init gc */
+    ngc.init(strs,argv);
+}
+
+void vm::valinfo(var& val) {
+    const nas_val* p=val.val.gcobj;
+    switch(val.type) {
+        case vm_none: std::clog<<"| null |";break;
+        case vm_ret:  std::clog<<"| pc   | 0x"<<std::hex
+                               <<val.ret()<<std::dec;break;
+        case vm_addr: std::clog<<"| addr | 0x"<<std::hex
+                               <<(u64)val.addr()<<std::dec;break;
+        case vm_cnt:  std::clog<<"| cnt  | "<<val.cnt();break;
+        case vm_nil:  std::clog<<"| nil  |";break;
+        case vm_num:  std::clog<<"| num  | "<<val.num();break;
+        case vm_str:  std::clog<<"| str  | <0x"<<std::hex<<(u64)p
+                               <<"> "<<rawstr(val.str(),16)<<std::dec;break;
+        case vm_func: std::clog<<"| func | <0x"<<std::hex<<(u64)p
+                               <<"> entry:0x"<<val.func().entry
+                               <<std::dec;break;
+        case vm_upval:std::clog<<"| upval| <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> ["<<val.upval().size
+                               <<" val]";break;
+        case vm_vec:  std::clog<<"| vec  | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> ["<<val.vec().size()
+                               <<" val]";break;
+        case vm_hash: std::clog<<"| hash | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> {"<<val.hash().size()
+                               <<" val}";break;
+        case vm_obj:  std::clog<<"| obj  | <0x"<<std::hex<<(u64)p
+                               <<"> obj:0x"<<(u64)val.obj().ptr
+                               <<std::dec;break;
+        case vm_co:   std::clog<<"| co   | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> coroutine";break;
+        default:      std::clog<<"| err  | <0x"<<std::hex<<(u64)p
+                               <<std::dec<<"> unknown object";break;
+    }
+    std::clog<<"\n";
+}
+
+void vm::traceback() {
+    /* bytecode[0].num is the global size */
+    var* bottom=ngc.rctx->stack==stack?stack+bytecode[0].num:ngc.rctx->stack;
+    var* ctx_top=ngc.rctx->stack==stack?ctx.top:ngc.rctx->top;
+    std::stack<u32> ret;
+    for(var* i=bottom;i<=ctx_top;++i) {
+        if (i->type==vm_ret && i->ret()!=0) {
+            ret.push(i->ret());
+        }
+    }
+    ret.push(ctx.pc); // store the position program crashed
+    std::clog<<"trace back ("<<(ngc.rctx->stack==stack?"main":"coroutine")<<")\n";
+    codestream::set(cnum, cstr, files);
+    for(u32 p=0,same=0,prev=0xffffffff;!ret.empty();prev=p,ret.pop()) {
+        if ((p=ret.top())==prev) {
+            ++same;
+            continue;
+        }
+        if (same) {
+            std::clog
+            <<"  0x"<<std::hex<<std::setw(6)<<std::setfill('0')
+            <<prev<<std::dec<<"     "<<same<<" same call(s)\n";
+        }
+        same=0;
+        std::clog<<"  "<<codestream(bytecode[p],p)<<"\n";
+    }
+    // the first called place has no same calls
+}
+
+void vm::stackinfo(const u32 limit=10) {
+    /* bytecode[0].num is the global size */
+    const u32 gsize=ngc.rctx->stack==stack?bytecode[0].num:0;
+    var* t=ctx.top;
+    var* bottom=ngc.rctx->stack+gsize;
+    std::clog<<"stack (0x"<<std::hex<<(u64)bottom<<std::dec
+             <<" <+"<<gsize<<">, limit "<<limit<<", total "
+             <<(t<bottom? 0:(i64)(t-bottom+1))<<")\n";
+    for(u32 i=0;i<limit && t>=bottom;++i,--t) {
+        std::clog<<"  0x"<<std::hex
+                 <<std::setw(6)<<std::setfill('0')
+                 <<(u64)(t-ngc.rctx->stack)<<std::dec
+                 <<"    ";
+        valinfo(t[0]);
+    }
+}
+
+void vm::reginfo() {
+    std::clog<<"registers ("<<(ngc.cort?"coroutine":"main")<<")\n"<<std::hex
+             <<"  [pc    ]    | pc   | 0x"<<ctx.pc<<"\n"
+             <<"  [global]    | addr | 0x"<<(u64)stack<<"\n"
+             <<"  [local ]    | addr | 0x"<<(u64)ctx.localr<<"\n"
+             <<"  [memr  ]    | addr | 0x"<<(u64)ctx.memr<<"\n"
+             <<"  [canary]    | addr | 0x"<<(u64)ctx.canary<<"\n"
+             <<"  [top   ]    | addr | 0x"<<(u64)ctx.top<<"\n"
+             <<std::dec;
+    std::clog<<"  [funcr ]    ";valinfo(ctx.funcr);
+    std::clog<<"  [upval ]    ";valinfo(ctx.upvalr);
+}
+
+void vm::gstate() {
+    if (!bytecode[0].num || stack[0].type==vm_none) { // bytecode[0].op is op_intg
+        return;
+    }
+    std::clog<<"global (0x"<<std::hex<<(u64)stack<<" <+0>)\n"<<std::dec;
+    for(u32 i=0;i<bytecode[0].num;++i) {
+        std::clog<<"  0x"<<std::hex<<std::setw(6)
+                 <<std::setfill('0')<<i<<std::dec
+                 <<"    ";
+        valinfo(stack[i]);
+    }
+}
+
+void vm::lstate() {
+    if (!ctx.localr || !ctx.funcr.func().lsize) {
+        return;
+    }
+    const u32 lsize=ctx.funcr.func().lsize;
+    std::clog<<"local (0x"<<std::hex<<(u64)ctx.localr
+             <<" <+"<<(u64)(ctx.localr-ngc.rctx->stack)<<">)\n"<<std::dec;
+    for(u32 i=0;i<lsize;++i) {
+        std::clog<<"  0x"<<std::hex<<std::setw(6)
+                 <<std::setfill('0')<<i<<std::dec
+                 <<"    ";
+        valinfo(ctx.localr[i]);
+    }
+}
+
+void vm::ustate() {
+    if (ctx.funcr.type==vm_nil || ctx.funcr.func().upval.empty()) {
+        return;
+    }
+    std::clog<<"upvalue\n";
+    auto& upval=ctx.funcr.func().upval;
+    for(u32 i=0;i<upval.size();++i) {
+        std::clog<<"  -> upval["<<i<<"]:\n";
+        auto& uv=upval[i].upval();
+        for(u32 j=0;j<uv.size;++j) {
+            std::clog<<"     0x"<<std::hex<<std::setw(6)
+                     <<std::setfill('0')<<j<<std::dec
+                     <<" ";
+            valinfo(uv[j]);
+        }
+    }
+}
+
+void vm::detail() {
+    reginfo();
+    gstate();
+    lstate();
+    ustate();
+}
+
+void vm::die(const std::string& str) {
+    std::cerr<<"[vm] error: "<<str<<"\n";
+    traceback();
+    stackinfo();
+
+    // show verbose crash info
+    if (verbose) {
+        detail();
+    }
+
+    if (ngc.rctx->stack==stack) { // in main context, exit directly
+        std::exit(1);
+    } else {
+        // in coroutine, shut down the coroutine and return to main context
+        ctx.pc=0; // mark coroutine 'dead'
+        ngc.ctxreserve();
+        ctx.top[0]=nil;
+    }
+}
+
+void vm::run(
+    const codegen& gen,
+    const linker& linker,
+    const std::vector<std::string>& argv,
+    const bool detail
+) {
+    verbose=detail;
+    init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
+#ifndef _MSC_VER
+    const void* oprs[]={
+        &&vmexit, &&intg,   &&intl,   &&loadg,
+        &&loadl,  &&loadu,  &&pnum,   &&pnil,
+        &&pstr,   &&newv,   &&newh,   &&newf,
+        &&happ,   &&para,   &&deft,   &&dyn,
+        &&lnot,   &&usub,   &&bnot,   &&btor,
+        &&btxor,  &&btand,  &&add,    &&sub,
+        &&mul,    &&div,    &&lnk,    &&addc,
+        &&subc,   &&mulc,   &&divc,   &&lnkc,
+        &&addeq,  &&subeq,  &&muleq,  &&diveq,
+        &&lnkeq,  &&bandeq, &&boreq,  &&bxoreq,
+        &&addeqc, &&subeqc, &&muleqc, &&diveqc,
+        &&lnkeqc, &&addecp, &&subecp, &&mulecp,
+        &&divecp, &&lnkecp, &&meq,    &&eq,
+        &&neq,    &&less,   &&leq,    &&grt,
+        &&geq,    &&lessc,  &&leqc,   &&grtc,
+        &&geqc,   &&pop,    &&jmp,    &&jt,
+        &&jf,     &&cnt,    &&findex, &&feach,
+        &&callg,  &&calll,  &&upval,  &&callv,
+        &&callvi, &&callh,  &&callfv, &&callfh,
+        &&callb,  &&slcbeg, &&slcend, &&slc,
+        &&slc2,   &&mcallg, &&mcalll, &&mupval,
+        &&mcallv, &&mcallh, &&ret
+    };
+    std::vector<const void*> code;
+    for(auto& i:gen.codes()) {
+        code.push_back(oprs[i.op]);
+        imm.push_back(i.num);
+    }
+    // goto the first operand
+    goto *code[ctx.pc];
+#else
+    typedef void (vm::*nafunc)();
+    const nafunc oprs[]={
+        nullptr,       &vm::o_intg,
+        &vm::o_intl,   &vm::o_loadg,
+        &vm::o_loadl,  &vm::o_loadu,
+        &vm::o_pnum,   &vm::o_pnil,
+        &vm::o_pstr,   &vm::o_newv,
+        &vm::o_newh,   &vm::o_newf,
+        &vm::o_happ,   &vm::o_para,
+        &vm::o_deft,   &vm::o_dyn,
+        &vm::o_lnot,   &vm::o_usub,
+        &vm::o_bnot,   &vm::o_btor,
+        &vm::o_btxor,  &vm::o_btand,
+        &vm::o_add,    &vm::o_sub,
+        &vm::o_mul,    &vm::o_div,
+        &vm::o_lnk,    &vm::o_addc,
+        &vm::o_subc,   &vm::o_mulc,
+        &vm::o_divc,   &vm::o_lnkc,
+        &vm::o_addeq,  &vm::o_subeq,
+        &vm::o_muleq,  &vm::o_diveq,
+        &vm::o_lnkeq,  &vm::o_bandeq,
+        &vm::o_boreq,  &vm::o_bxoreq,
+        &vm::o_addeqc, &vm::o_subeqc,
+        &vm::o_muleqc, &vm::o_diveqc,
+        &vm::o_lnkeqc, &vm::o_addecp,
+        &vm::o_subecp, &vm::o_mulecp,
+        &vm::o_divecp, &vm::o_lnkecp,
+        &vm::o_meq,    &vm::o_eq,
+        &vm::o_neq,    &vm::o_less,
+        &vm::o_leq,    &vm::o_grt,
+        &vm::o_geq,    &vm::o_lessc,
+        &vm::o_leqc,   &vm::o_grtc,
+        &vm::o_geqc,   &vm::o_pop,
+        &vm::o_jmp,    &vm::o_jt,
+        &vm::o_jf,     &vm::o_cnt,
+        &vm::o_findex, &vm::o_feach,
+        &vm::o_callg,  &vm::o_calll,
+        &vm::o_upval,  &vm::o_callv,
+        &vm::o_callvi, &vm::o_callh,
+        &vm::o_callfv, &vm::o_callfh,
+        &vm::o_callb,  &vm::o_slcbeg,
+        &vm::o_slcend, &vm::o_slc,
+        &vm::o_slc2,   &vm::o_mcallg,
+        &vm::o_mcalll, &vm::o_mupval,
+        &vm::o_mcallv, &vm::o_mcallh,
+        &vm::o_ret
+    };
+    std::vector<nafunc> code;
+    for(auto& i:gen.codes()) {
+        code.push_back(oprs[i.op]);
+        imm.push_back(i.num);
+    }
+    while(code[ctx.pc]) {
+        (this->*code[ctx.pc])();
+        if (ctx.top>=ctx.canary) {
+            die("stack overflow");
+        }
+        ++ctx.pc;
+    }
+#endif
+
+vmexit:
+    if (detail) {
+        ngc.info();
+    }
+    ngc.clear();
+    imm.clear();
+    return;
+
+#ifndef _MSC_VER
+// may cause stackoverflow
+#define exec_check(op) {\
+    op();\
+    if (ctx.top<ctx.canary)\
+        goto *code[++ctx.pc];\
+    die("stack overflow");\
+    goto *code[++ctx.pc];\
+}
+// do not cause stackoverflow
+#define exec_nodie(op) {\
+    op();\
+    goto *code[++ctx.pc];\
+}
+
+intg:   exec_nodie(o_intg  ); // +imm[pc] (detected at codegen)
+intl:   exec_nodie(o_intl  ); // -0
+loadg:  exec_nodie(o_loadg ); // -1
+loadl:  exec_nodie(o_loadl ); // -1
+loadu:  exec_nodie(o_loadu ); // -1
+pnum:   exec_check(o_pnum  ); // +1
+pnil:   exec_check(o_pnil  ); // +1
+pstr:   exec_check(o_pstr  ); // +1
+newv:   exec_check(o_newv  ); // +1-imm[pc]
+newh:   exec_check(o_newh  ); // +1
+newf:   exec_check(o_newf  ); // +1
+happ:   exec_nodie(o_happ  ); // -1
+para:   exec_nodie(o_para  ); // -0
+deft:   exec_nodie(o_deft  ); // -1
+dyn:    exec_nodie(o_dyn   ); // -0
+lnot:   exec_nodie(o_lnot  ); // -0
+usub:   exec_nodie(o_usub  ); // -0
+bnot:   exec_nodie(o_bnot  ); // -0
+btor:   exec_nodie(o_btor  ); // -1
+btxor:  exec_nodie(o_btxor ); // -1
+btand:  exec_nodie(o_btand ); // -1
+add:    exec_nodie(o_add   ); // -1
+sub:    exec_nodie(o_sub   ); // -1
+mul:    exec_nodie(o_mul   ); // -1
+div:    exec_nodie(o_div   ); // -1
+lnk:    exec_nodie(o_lnk   ); // -1
+addc:   exec_nodie(o_addc  ); // -0
+subc:   exec_nodie(o_subc  ); // -0
+mulc:   exec_nodie(o_mulc  ); // -0
+divc:   exec_nodie(o_divc  ); // -0
+lnkc:   exec_nodie(o_lnkc  ); // -0
+addeq:  exec_nodie(o_addeq ); // -1
+subeq:  exec_nodie(o_subeq ); // -1
+muleq:  exec_nodie(o_muleq ); // -1
+diveq:  exec_nodie(o_diveq ); // -1
+lnkeq:  exec_nodie(o_lnkeq ); // -1
+bandeq: exec_nodie(o_bandeq); // -1
+boreq:  exec_nodie(o_boreq ); // -1
+bxoreq: exec_nodie(o_bxoreq); // -1
+addeqc: exec_nodie(o_addeqc); // -0
+subeqc: exec_nodie(o_subeqc); // -0
+muleqc: exec_nodie(o_muleqc); // -0
+diveqc: exec_nodie(o_diveqc); // -0
+lnkeqc: exec_nodie(o_lnkeqc); // -0
+addecp: exec_nodie(o_addecp); // -1
+subecp: exec_nodie(o_subecp); // -1
+mulecp: exec_nodie(o_mulecp); // -1
+divecp: exec_nodie(o_divecp); // -1
+lnkecp: exec_nodie(o_lnkecp); // -1
+meq:    exec_nodie(o_meq   ); // -1
+eq:     exec_nodie(o_eq    ); // -1
+neq:    exec_nodie(o_neq   ); // -1
+less:   exec_nodie(o_less  ); // -1
+leq:    exec_nodie(o_leq   ); // -1
+grt:    exec_nodie(o_grt   ); // -1
+geq:    exec_nodie(o_geq   ); // -1
+lessc:  exec_nodie(o_lessc ); // -0
+leqc:   exec_nodie(o_leqc  ); // -0
+grtc:   exec_nodie(o_grtc  ); // -0
+geqc:   exec_nodie(o_geqc  ); // -0
+pop:    exec_nodie(o_pop   ); // -1
+jmp:    exec_nodie(o_jmp   ); // -0
+jt:     exec_nodie(o_jt    ); // -0
+jf:     exec_nodie(o_jf    ); // -1
+cnt:    exec_nodie(o_cnt   ); // -0
+findex: exec_check(o_findex); // +1
+feach:  exec_check(o_feach ); // +1
+callg:  exec_check(o_callg ); // +1
+calll:  exec_check(o_calll ); // +1
+upval:  exec_check(o_upval ); // +1
+callv:  exec_nodie(o_callv ); // -0
+callvi: exec_nodie(o_callvi); // -0
+callh:  exec_nodie(o_callh ); // -0
+callfv: exec_nodie(o_callfv); // check in the function
+callfh: exec_nodie(o_callfh); // check in the function
+callb:  exec_nodie(o_callb ); // -0
+slcbeg: exec_check(o_slcbeg); // +1
+slcend: exec_nodie(o_slcend); // -1
+slc:    exec_nodie(o_slc   ); // -1
+slc2:   exec_nodie(o_slc2  ); // -2
+mcallg: exec_check(o_mcallg); // +1
+mcalll: exec_check(o_mcalll); // +1
+mupval: exec_check(o_mupval); // +1
+mcallv: exec_nodie(o_mcallv); // -0
+mcallh: exec_nodie(o_mcallh); // -0
+ret:    exec_nodie(o_ret   ); // -2
+#endif
+}
diff --git a/ast/nasal_new_vm.cpp b/src/nasal_new_vm.h
similarity index 50%
rename from ast/nasal_new_vm.cpp
rename to src/nasal_new_vm.h
index 639712a..f3e3ffb 100644
--- a/ast/nasal_new_vm.cpp
+++ b/src/nasal_new_vm.h
@@ -1,1129 +1,881 @@
-#include "nasal_new_vm.h"
-
-void vm::init(
-    const std::vector<std::string>& strs,
-    const std::vector<f64>&    nums,
-    const std::vector<opcode>& code,
-    const std::vector<std::string>& filenames,
-    const std::vector<std::string>& argv
-) {
-    cnum=nums.data();
-    cstr=strs.data();
-    bytecode=code.data();
-    files=filenames.data();
-
-    /* set canary and program counter */
-    ctx.pc=0;
-    ctx.localr=ctx.memr=nullptr;
-    ctx.funcr=ctx.upvalr=nil;
-    ctx.canary=stack+STACK_DEPTH-1; // stack[STACK_DEPTH-1]
-    ctx.top=stack;
-    ctx.stack=stack;
-
-    /* clear main stack */
-    for(u32 i=0;i<STACK_DEPTH;++i) {
-        stack[i]=nil;
-    }
-
-    /* init gc */
-    ngc.init(strs,argv);
-}
-
-void vm::valinfo(var& val) {
-    const nas_val* p=val.val.gcobj;
-    switch(val.type) {
-        case vm_none: std::clog<<"| null |";break;
-        case vm_ret:  std::clog<<"| pc   | 0x"<<std::hex
-                               <<val.ret()<<std::dec;break;
-        case vm_addr: std::clog<<"| addr | 0x"<<std::hex
-                               <<(u64)val.addr()<<std::dec;break;
-        case vm_cnt:  std::clog<<"| cnt  | "<<val.cnt();break;
-        case vm_nil:  std::clog<<"| nil  |";break;
-        case vm_num:  std::clog<<"| num  | "<<val.num();break;
-        case vm_str:  std::clog<<"| str  | <0x"<<std::hex<<(u64)p
-                               <<"> "<<rawstr(val.str(),16)<<std::dec;break;
-        case vm_func: std::clog<<"| func | <0x"<<std::hex<<(u64)p
-                               <<"> entry:0x"<<val.func().entry
-                               <<std::dec;break;
-        case vm_upval:std::clog<<"| upval| <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> ["<<val.upval().size
-                               <<" val]";break;
-        case vm_vec:  std::clog<<"| vec  | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> ["<<val.vec().size()
-                               <<" val]";break;
-        case vm_hash: std::clog<<"| hash | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> {"<<val.hash().size()
-                               <<" val}";break;
-        case vm_obj:  std::clog<<"| obj  | <0x"<<std::hex<<(u64)p
-                               <<"> obj:0x"<<(u64)val.obj().ptr
-                               <<std::dec;break;
-        case vm_co:   std::clog<<"| co   | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> coroutine";break;
-        default:      std::clog<<"| err  | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> unknown object";break;
-    }
-    std::clog<<"\n";
-}
-
-void vm::traceback() {
-    /* bytecode[0].num is the global size */
-    var* bottom=ngc.rctx->stack==stack?stack+bytecode[0].num:ngc.rctx->stack;
-    var* ctx_top=ngc.rctx->stack==stack?ctx.top:ngc.rctx->top;
-    std::stack<u32> ret;
-    for(var* i=bottom;i<=ctx_top;++i) {
-        if (i->type==vm_ret && i->ret()!=0) {
-            ret.push(i->ret());
-        }
-    }
-    ret.push(ctx.pc); // store the position program crashed
-    std::clog<<"trace back ("<<(ngc.rctx->stack==stack?"main":"coroutine")<<")\n";
-    codestream::set(cnum, cstr, files);
-    for(u32 p=0,same=0,prev=0xffffffff;!ret.empty();prev=p,ret.pop()) {
-        if ((p=ret.top())==prev) {
-            ++same;
-            continue;
-        }
-        if (same) {
-            std::clog
-            <<"  0x"<<std::hex<<std::setw(6)<<std::setfill('0')
-            <<prev<<std::dec<<"     "<<same<<" same call(s)\n";
-        }
-        same=0;
-        std::clog<<"  "<<codestream(bytecode[p],p)<<"\n";
-    }
-    // the first called place has no same calls
-}
-
-void vm::stackinfo(const u32 limit=10) {
-    /* bytecode[0].num is the global size */
-    const u32 gsize=ngc.rctx->stack==stack?bytecode[0].num:0;
-    var* t=ctx.top;
-    var* bottom=ngc.rctx->stack+gsize;
-    std::clog<<"stack (0x"<<std::hex<<(u64)bottom<<std::dec
-             <<" <+"<<gsize<<">, limit "<<limit<<", total "
-             <<(t<bottom? 0:(i64)(t-bottom+1))<<")\n";
-    for(u32 i=0;i<limit && t>=bottom;++i,--t) {
-        std::clog<<"  0x"<<std::hex
-                 <<std::setw(6)<<std::setfill('0')
-                 <<(u64)(t-ngc.rctx->stack)<<std::dec
-                 <<"    ";
-        valinfo(t[0]);
-    }
-}
-
-void vm::reginfo() {
-    std::clog<<"registers ("<<(ngc.cort?"coroutine":"main")<<")\n"<<std::hex
-             <<"  [pc    ]    | pc   | 0x"<<ctx.pc<<"\n"
-             <<"  [global]    | addr | 0x"<<(u64)stack<<"\n"
-             <<"  [local ]    | addr | 0x"<<(u64)ctx.localr<<"\n"
-             <<"  [memr  ]    | addr | 0x"<<(u64)ctx.memr<<"\n"
-             <<"  [canary]    | addr | 0x"<<(u64)ctx.canary<<"\n"
-             <<"  [top   ]    | addr | 0x"<<(u64)ctx.top<<"\n"
-             <<std::dec;
-    std::clog<<"  [funcr ]    ";valinfo(ctx.funcr);
-    std::clog<<"  [upval ]    ";valinfo(ctx.upvalr);
-}
-
-void vm::gstate() {
-    if (!bytecode[0].num || stack[0].type==vm_none) { // bytecode[0].op is op_intg
-        return;
-    }
-    std::clog<<"global (0x"<<std::hex<<(u64)stack<<" <+0>)\n"<<std::dec;
-    for(u32 i=0;i<bytecode[0].num;++i) {
-        std::clog<<"  0x"<<std::hex<<std::setw(6)
-                 <<std::setfill('0')<<i<<std::dec
-                 <<"    ";
-        valinfo(stack[i]);
-    }
-}
-
-void vm::lstate() {
-    if (!ctx.localr || !ctx.funcr.func().lsize) {
-        return;
-    }
-    const u32 lsize=ctx.funcr.func().lsize;
-    std::clog<<"local (0x"<<std::hex<<(u64)ctx.localr
-             <<" <+"<<(u64)(ctx.localr-ngc.rctx->stack)<<">)\n"<<std::dec;
-    for(u32 i=0;i<lsize;++i) {
-        std::clog<<"  0x"<<std::hex<<std::setw(6)
-                 <<std::setfill('0')<<i<<std::dec
-                 <<"    ";
-        valinfo(ctx.localr[i]);
-    }
-}
-
-void vm::ustate() {
-    if (ctx.funcr.type==vm_nil || ctx.funcr.func().upval.empty()) {
-        return;
-    }
-    std::clog<<"upvalue\n";
-    auto& upval=ctx.funcr.func().upval;
-    for(u32 i=0;i<upval.size();++i) {
-        std::clog<<"  -> upval["<<i<<"]:\n";
-        auto& uv=upval[i].upval();
-        for(u32 j=0;j<uv.size;++j) {
-            std::clog<<"     0x"<<std::hex<<std::setw(6)
-                     <<std::setfill('0')<<j<<std::dec
-                     <<" ";
-            valinfo(uv[j]);
-        }
-    }
-}
-
-void vm::detail() {
-    reginfo();
-    gstate();
-    lstate();
-    ustate();
-}
-
-void vm::die(const std::string& str) {
-    std::cerr<<"[vm] error: "<<str<<"\n";
-    traceback();
-    stackinfo();
-
-    // show verbose crash info
-    if (verbose) {
-        detail();
-    }
-
-    if (ngc.rctx->stack==stack) { // in main context, exit directly
-        std::exit(1);
-    } else { // in coroutine, shut down the coroutine and return to main context
-        ctx.pc=0; // mark coroutine 'dead'
-        ngc.ctxreserve();
-        ctx.top[0]=nil;
-    }
-}
-
-inline bool vm::cond(var& val) {
-    if (val.type==vm_num) {
-        return val.num();
-    } else if (val.type==vm_str) {
-        const f64 num=str2num(val.str().c_str());
-        return std::isnan(num)? !val.str().empty():num;
-    }
-    return false;
-}
-
-void vm::o_intg() {
-    // global values store on stack
-    ctx.top+=imm[ctx.pc];
-    --ctx.top;// point to the top
-}
-
-void vm::o_intl() {
-    ctx.top[0].func().local.resize(imm[ctx.pc], nil);
-    ctx.top[0].func().lsize=imm[ctx.pc];
-}
-
-void vm::o_loadg() {
-    stack[imm[ctx.pc]]=(ctx.top--)[0];
-}
-
-void vm::o_loadl() {
-    ctx.localr[imm[ctx.pc]]=(ctx.top--)[0];
-}
-
-void vm::o_loadu() {
-    ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff]
-         .upval()[imm[ctx.pc]&0xffff]=(ctx.top--)[0];
-}
-
-void vm::o_pnum() {
-    (++ctx.top)[0]=var::num(cnum[imm[ctx.pc]]);
-}
-
-void vm::o_pnil() {
-    (++ctx.top)[0]=nil;
-}
-
-void vm::o_pstr() {
-    (++ctx.top)[0]=ngc.strs[imm[ctx.pc]];
-}
-
-void vm::o_newv() {
-    var newv=ngc.alloc(vm_vec);
-    auto& vec=newv.vec().elems;
-    vec.resize(imm[ctx.pc]);
-    // use top-=imm[pc]-1 here will cause error if imm[pc] is 0
-    ctx.top=ctx.top-imm[ctx.pc]+1;
-    for(u32 i=0;i<imm[ctx.pc];++i) {
-        vec[i]=ctx.top[i];
-    }
-    ctx.top[0]=newv;
-}
-
-void vm::o_newh() {
-    (++ctx.top)[0]=ngc.alloc(vm_hash);
-}
-
-void vm::o_newf() {
-    (++ctx.top)[0]=ngc.alloc(vm_func);
-    nas_func& func=ctx.top[0].func();
-    func.entry=imm[ctx.pc];
-    func.psize=1;
-
-    /* this means you create a new function in local scope */
-    if (ctx.localr) {
-        func.upval=ctx.funcr.func().upval;
-        // function created in the same local scope shares one closure
-        // so this size & stk setting has no problem
-        var upval=(ctx.upvalr.type==vm_nil)?ngc.alloc(vm_upval):ctx.upvalr;
-        upval.upval().size=ctx.funcr.func().lsize;
-        upval.upval().stk=ctx.localr;
-        func.upval.push_back(upval);
-        ctx.upvalr=upval;
-    }
-}
-
-void vm::o_happ() {
-    ctx.top[-1].hash().elems[cstr[imm[ctx.pc]]]=ctx.top[0];
-    --ctx.top;
-}
-
-void vm::o_para() {
-    nas_func& func=ctx.top[0].func();
-    // func->size has 1 place reserved for "me"
-    func.keys[imm[ctx.pc]]=func.psize;
-    func.local[func.psize++]=var::none();
-}
-
-void vm::o_deft() {
-    var val=ctx.top[0];
-    nas_func& func=(--ctx.top)[0].func();
-    // func->size has 1 place reserved for "me"
-    func.keys[imm[ctx.pc]]=func.psize;
-    func.local[func.psize++]=val;
-}
-
-void vm::o_dyn() {
-    ctx.top[0].func().dpara=imm[ctx.pc];
-}
-
-void vm::o_lnot() {
-    var val=ctx.top[0];
-    switch(val.type) {
-        case vm_nil:ctx.top[0]=one;break;
-        case vm_num:ctx.top[0]=val.num()?zero:one;break;
-        case vm_str:{
-            const f64 num=str2num(val.str().c_str());
-            if (std::isnan(num)) {
-                ctx.top[0]=var::num((f64)val.str().empty());
-            } else {
-                ctx.top[0]=num?zero:one;
-            }
-        } break;
-        default:{
-            die("incorrect value type");
-            return;
-        } break;
-    }
-}
-
-void vm::o_usub() {
-    ctx.top[0]=var::num(-ctx.top[0].tonum());
-}
-
-void vm::o_bnot() {
-    ctx.top[0]=var::num(~static_cast<int32_t>(ctx.top[0].num()));
-}
-
-void vm::o_btor() {
-    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())|static_cast<int32_t>(ctx.top[0].tonum()));
-    --ctx.top;
-}
-
-void vm::o_btxor() {
-    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())^static_cast<int32_t>(ctx.top[0].tonum()));
-    --ctx.top;
-}
-
-void vm::o_btand() {
-    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())&static_cast<int32_t>(ctx.top[0].tonum()));
-    --ctx.top;
-}
-
-#define op_calc(type)\
-    ctx.top[-1]=var::num(ctx.top[-1].tonum() type ctx.top[0].tonum());\
-    --ctx.top;
-
-void vm::o_add() {op_calc(+);}
-void vm::o_sub() {op_calc(-);}
-void vm::o_mul() {op_calc(*);}
-void vm::o_div() {op_calc(/);}
-void vm::o_lnk() {
-    ctx.top[-1]=ngc.newstr(ctx.top[-1].tostr()+ctx.top[0].tostr());
-    --ctx.top;
-}
-
-#define op_calc_const(type)\
-    ctx.top[0]=var::num(ctx.top[0].tonum() type cnum[imm[ctx.pc]]);
-
-void vm::o_addc() {op_calc_const(+);}
-void vm::o_subc() {op_calc_const(-);}
-void vm::o_mulc() {op_calc_const(*);}
-void vm::o_divc() {op_calc_const(/);}
-void vm::o_lnkc() {
-    ctx.top[0]=ngc.newstr(ctx.top[0].tostr()+cstr[imm[ctx.pc]]);
-}
-
-// top[0] stores the value of memr[0], to avoid being garbage-collected
-// so when the calculation ends, top-=1, then top-=imm[pc]
-// because this return value is meaningless if on stack when imm[pc]=1
-// like this: func{a+=c;}(); the result of 'a+c' will no be used later, imm[pc]=1
-// but if b+=a+=c; the result of 'a+c' will be used later, imm[pc]=0
-#define op_calc_eq(type)\
-    ctx.top[-1]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type ctx.top[-1].tonum());\
-    ctx.memr=nullptr;\
-    ctx.top-=imm[ctx.pc]+1;
-
-void vm::o_addeq() {op_calc_eq(+);}
-void vm::o_subeq() {op_calc_eq(-);}
-void vm::o_muleq() {op_calc_eq(*);}
-void vm::o_diveq() {op_calc_eq(/);}
-void vm::o_lnkeq() {
-    ctx.top[-1]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+ctx.top[-1].tostr());
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_bandeq() {
-    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())&i32(ctx.top[-1].tonum()));
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_boreq() {
-    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())|i32(ctx.top[-1].tonum()));
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_bxoreq() {
-    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())^i32(ctx.top[-1].tonum()));
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-// top[0] stores the value of memr[0], to avoid being garbage-collected
-// so when the calculation ends, top-=imm[pc]>>31
-// because this return value is meaningless if on stack when imm[pc]>>31=1
-// like this: func{a+=1;}(); the result of 'a+1' will no be used later, imm[pc]>>31=1
-// but if b+=a+=1; the result of 'a+1' will be used later, imm[pc]>>31=0
-#define op_calc_eq_const(type)\
-    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
-    ctx.memr=nullptr;
-
-void vm::o_addeqc() {op_calc_eq_const(+);}
-void vm::o_subeqc() {op_calc_eq_const(-);}
-void vm::o_muleqc() {op_calc_eq_const(*);}
-void vm::o_diveqc() {op_calc_eq_const(/);}
-void vm::o_lnkeqc() {
-    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
-    ctx.memr=nullptr;
-}
-
-#define op_calc_eq_const_and_pop(type)\
-    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
-    ctx.memr=nullptr;\
-    --ctx.top;
-
-void vm::o_addecp() {op_calc_eq_const_and_pop(+);}
-void vm::o_subecp() {op_calc_eq_const_and_pop(-);}
-void vm::o_mulecp() {op_calc_eq_const_and_pop(*);}
-void vm::o_divecp() {op_calc_eq_const_and_pop(/);}
-void vm::o_lnkecp() {
-    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
-    ctx.memr=nullptr;
-    --ctx.top;
-}
-
-void vm::o_meq() {
-    // pop old memr[0] and replace it
-    // the reason why we should get memr and push the old value on stack
-    // is that when lnkeq/lnkeqc is called, there will be
-    // a new gc object vm_str which is returned by gc::alloc
-    // this may cause gc, so we should temporarily put it on stack
-    ctx.memr[0]=ctx.top[-1];
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_eq() {
-    var val2=ctx.top[0];
-    var val1=(--ctx.top)[0];
-    if (val1.type==vm_nil && val2.type==vm_nil) {
-        ctx.top[0]=one;
-    } else if (val1.type==vm_str && val2.type==vm_str) {
-        ctx.top[0]=(val1.str()==val2.str())?one:zero;
-    } else if ((val1.type==vm_num || val2.type==vm_num)
-        && val1.type!=vm_nil && val2.type!=vm_nil) {
-        ctx.top[0]=(val1.tonum()==val2.tonum())?one:zero;
-    } else {
-        ctx.top[0]=(val1==val2)?one:zero;
-    }
-}
-
-void vm::o_neq() {
-    var val2=ctx.top[0];
-    var val1=(--ctx.top)[0];
-    if (val1.type==vm_nil && val2.type==vm_nil) {
-        ctx.top[0]=zero;
-    } else if (val1.type==vm_str && val2.type==vm_str) {
-        ctx.top[0]=(val1.str()!=val2.str())?one:zero;
-    } else if ((val1.type==vm_num || val2.type==vm_num)
-        && val1.type!=vm_nil && val2.type!=vm_nil) {
-        ctx.top[0]=(val1.tonum()!=val2.tonum())?one:zero;
-    } else {
-        ctx.top[0]=(val1!=val2)?one:zero;
-    }
-}
-
-#define op_cmp(type)\
-    --ctx.top;\
-    ctx.top[0]=(ctx.top[0].tonum() type ctx.top[1].tonum())?one:zero;
-
-void vm::o_less() {op_cmp(<);}
-void vm::o_leq() {op_cmp(<=);}
-void vm::o_grt() {op_cmp(>);}
-void vm::o_geq() {op_cmp(>=);}
-
-#define op_cmp_const(type)\
-    ctx.top[0]=(ctx.top[0].tonum() type cnum[imm[ctx.pc]])?one:zero;
-
-void vm::o_lessc() {op_cmp_const(<);}
-void vm::o_leqc() {op_cmp_const(<=);}
-void vm::o_grtc() {op_cmp_const(>);}
-void vm::o_geqc() {op_cmp_const(>=);}
-
-void vm::o_pop() {
-    --ctx.top;
-}
-
-void vm::o_jmp() {
-    ctx.pc=imm[ctx.pc]-1;
-}
-
-void vm::o_jt() {
-    // jump true needs to reserve the result on stack
-    // because conditional expression in nasal has return value
-    if (cond(ctx.top[0])) {
-        ctx.pc=imm[ctx.pc]-1;
-    }
-}
-
-void vm::o_jf() {
-    // jump false doesn't need to reserve result
-    if (!cond(ctx.top[0])) {
-        ctx.pc=imm[ctx.pc]-1;
-    }
-    --ctx.top;
-}
-
-void vm::o_cnt() {
-    if (ctx.top[0].type!=vm_vec) {
-        die("must use vector in forindex/foreach");
-        return;
-    }
-    (++ctx.top)[0]=var::cnt(-1);
-}
-
-void vm::o_findex() {
-    if ((usize)(++ctx.top[0].cnt())>=ctx.top[-1].vec().size()) {
-        ctx.pc=imm[ctx.pc]-1;
-        return;
-    }
-    ctx.top[1]=var::num(ctx.top[0].cnt());
-    ++ctx.top;
-}
-
-void vm::o_feach() {
-    auto& ref=ctx.top[-1].vec().elems;
-    if ((usize)(++ctx.top[0].cnt())>=ref.size()) {
-        ctx.pc=imm[ctx.pc]-1;
-        return;
-    }
-    ctx.top[1]=ref[ctx.top[0].cnt()];
-    ++ctx.top;
-}
-
-void vm::o_callg() {
-    // get main stack directly
-    (++ctx.top)[0]=stack[imm[ctx.pc]];
-}
-
-void vm::o_calll() {
-    (++ctx.top)[0]=ctx.localr[imm[ctx.pc]];
-}
-
-void vm::o_upval() {
-    (++ctx.top)[0]=ctx.funcr.func()
-        .upval[(imm[ctx.pc]>>16)&0xffff]
-        .upval()[imm[ctx.pc]&0xffff];
-}
-
-void vm::o_callv() {
-    var val=ctx.top[0];
-    var vec=(--ctx.top)[0];
-    if (vec.type==vm_vec) {
-        ctx.top[0]=vec.vec().get_val(val.tonum());
-        if (ctx.top[0].type==vm_none) {
-            die("out of range:"+std::to_string(val.tonum()));
-            return;
-        }
-    } else if (vec.type==vm_hash) {
-        if (val.type!=vm_str) {
-            die("must use string as the key");
-            return;
-        }
-        ctx.top[0]=vec.hash().get_val(val.str());
-        if (ctx.top[0].type==vm_none) {
-            die("cannot find member \""+val.str()+"\"");
-            return;
-        } else if (ctx.top[0].type==vm_func) {
-            ctx.top[0].func().local[0]=val; // 'me'
-        }
-    } else if (vec.type==vm_str) {
-        auto& str = vec.str();
-        i32 num = val.tonum();
-        i32 len = str.length();
-        if (num<-len || num>=len) {
-            die("out of range:"+std::to_string(val.tonum()));
-            return;
-        }
-        ctx.top[0]=var::num(f64((u8)str[num>=0? num:num+len]));
-    } else {
-        die("must call a vector/hash/string");
-        return;
-    }
-}
-
-void vm::o_callvi() {
-    var val=ctx.top[0];
-    if (val.type!=vm_vec) {
-        die("must use a vector");
-        return;
-    }
-    // cannot use operator[],because this may cause overflow
-    (++ctx.top)[0]=val.vec().get_val(imm[ctx.pc]);
-    if (ctx.top[0].type==vm_none) {
-        die("out of range:"+std::to_string(imm[ctx.pc]));
-        return;
-    }
-}
-
-void vm::o_callh() {
-    var val=ctx.top[0];
-    if (val.type!=vm_hash) {
-        die("must call a hash");
-        return;
-    }
-    ctx.top[0]=val.hash().get_val(cstr[imm[ctx.pc]]);
-    if (ctx.top[0].type==vm_none) {
-        die("member \""+cstr[imm[ctx.pc]]+"\" does not exist");
-        return;
-    } else if (ctx.top[0].type==vm_func) {
-        ctx.top[0].func().local[0]=val; // 'me'
-    }
-}
-
-void vm::o_callfv() {
-    u32 argc=imm[ctx.pc]; // arguments counter
-    var* local=ctx.top-argc+1; // arguments begin address
-    if (local[-1].type!=vm_func) {
-        die("must call a function");
-        return;
-    }
-    auto& func=local[-1].func();
-    var tmp=local[-1];
-    local[-1]=ctx.funcr;
-    ctx.funcr=tmp;
-    // top-argc+lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
-    if (ctx.top-argc+func.lsize+3>=ctx.canary) {
-        die("stack overflow");
-        return;
-    }
-    // parameter size is func->psize-1, 1 is reserved for "me"
-    u32 psize=func.psize-1;
-    if (argc<psize && func.local[argc+1].type==vm_none) {
-        die("lack argument(s)");
-        return;
-    }
-
-    var dynamic=nil;
-    if (func.dpara>=0) { // load dynamic arguments
-        dynamic=ngc.alloc(vm_vec);
-        for(u32 i=psize;i<argc;++i) {
-            dynamic.vec().elems.push_back(local[i]);
-        }
-    }
-    // should reset stack top after allocating vector
-    // because this may cause gc
-    // then all the available values the vector needs
-    // are all outside the stack top and may be
-    // collected incorrectly
-    ctx.top=local+func.lsize;
-
-    u32 min_size=(std::min)(psize, argc); // avoid error in MSVC
-    for(u32 i=min_size;i>=1;--i) { // load arguments
-        local[i]=local[i-1];
-    }
-    local[0]=func.local[0];// load "me"
-    // load local scope & default arguments
-    for(u32 i=min_size+1;i<func.lsize;++i) {
-        local[i]=func.local[i];
-    }
-    if (func.dpara>=0) {
-        local[psize+1]=dynamic;
-    }
-
-    ctx.top[0]=ctx.upvalr;
-    (++ctx.top)[0]=var::addr(ctx.localr);
-    (++ctx.top)[0]=var::ret(ctx.pc);
-    ctx.pc=func.entry-1;
-    ctx.localr=local;
-    ctx.upvalr=nil;
-}
-
-void vm::o_callfh() {
-    auto& hash=ctx.top[0].hash().elems;
-    if (ctx.top[-1].type!=vm_func) {
-        die("must call a function");
-        return;
-    }
-    auto& func=ctx.top[-1].func();
-    var tmp=ctx.top[-1];
-    ctx.top[-1]=ctx.funcr;
-    ctx.funcr=tmp;
-
-    // top -1(hash) +lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
-    if (ctx.top+func.lsize+2>=ctx.canary) {
-        die("stack overflow");
-        return;
-    }
-    if (func.dpara>=0) {
-        die("special call cannot use dynamic argument");
-        return;
-    }
-
-    var* local=ctx.top;
-    ctx.top+=func.lsize;
-    for(u32 i=0;i<func.lsize;++i) {
-        local[i]=func.local[i];
-    }
-    
-    for(auto& i:func.keys) {
-        auto& key=cstr[i.first];
-        if (hash.count(key)) {
-            local[i.second]=hash[key];
-        } else if (local[i.second].type==vm_none) {
-            die("lack argument(s): \""+key+"\"");
-            return;
-        }
-    }
-
-    ctx.top[0]=ctx.upvalr;
-    (++ctx.top)[0]=var::addr(ctx.localr);
-    (++ctx.top)[0]=var::ret(ctx.pc); // rewrite top with vm_ret
-    ctx.pc=func.entry-1;
-    ctx.localr=local;
-    ctx.upvalr=nil;
-}
-
-void vm::o_callb() {
-    // reserve place for builtin function return,
-    // this code is written for coroutine
-    (++ctx.top)[0]=nil;
-
-    // if running a builtin function about coroutine
-    // (top) will be set to another context.top, instead of main_context.top
-    var tmp=(*builtin[imm[ctx.pc]].func)(ctx.localr, ngc);
-
-    // so we use tmp variable to store this return value
-    // and set it to top[0] later
-    ctx.top[0]=tmp;
-
-    // if get none, this means errors occurred when calling this native function
-    if (ctx.top[0].type==vm_none) {
-        die("native function error");
-        return;
-    }
-}
-
-void vm::o_slcbeg() {
-    // +--------------+
-    // | slice_vector | <-- top[0]
-    // +--------------+
-    // | resource_vec | <-- top[-1]
-    // +--------------+
-    (++ctx.top)[0]=ngc.alloc(vm_vec);
-    if (ctx.top[-1].type!=vm_vec) {
-        die("must slice a vector");
-        return;
-    }
-}
-
-void vm::o_slcend() {
-    ctx.top[-1]=ctx.top[0];
-    --ctx.top;
-}
-
-void vm::o_slc() {
-    var val=(ctx.top--)[0];
-    var res=ctx.top[-1].vec().get_val(val.tonum());
-    if (res.type==vm_none) {
-        die("index "+std::to_string(val.tonum())+" out of range");
-        return;
-    }
-    ctx.top[0].vec().elems.push_back(res);
-}
-
-void vm::o_slc2() {
-    var val2=(ctx.top--)[0];
-    var val1=(ctx.top--)[0];
-    auto& ref=ctx.top[-1].vec().elems;
-    auto& aim=ctx.top[0].vec().elems;
-
-    u8 type1=val1.type,type2=val2.type;
-    i32 num1=val1.tonum();
-    i32 num2=val2.tonum();
-    i32 size=ref.size();
-    if (type1==vm_nil && type2==vm_nil) {
-        num1=0;
-        num2=size-1;
-    } else if (type1==vm_nil && type2!=vm_nil) {
-        num1=num2<0? -size:0;
-    } else if (type1!=vm_nil && type2==vm_nil) {
-        num2=num1<0? -1:size-1;
-    }
-
-    if (num1<-size || num1>=size || num2<-size || num2>=size) {
-        die("index "+std::to_string(num1)+":"+std::to_string(num2)+" out of range");
-        return;
-    } else if (num1<=num2) {
-        for(i32 i=num1;i<=num2;++i) {
-            aim.push_back(i>=0?ref[i]:ref[i+size]);
-        }
-    }
-}
-
-void vm::o_mcallg() {
-    ctx.memr=stack+imm[ctx.pc];
-    (++ctx.top)[0]=ctx.memr[0];
-    // push value in this memory space on stack
-    // to avoid being garbage collected
-}
-
-void vm::o_mcalll() {
-    ctx.memr=ctx.localr+imm[ctx.pc];
-    (++ctx.top)[0]=ctx.memr[0];
-    // push value in this memory space on stack
-    // to avoid being garbage collected
-}
-
-void vm::o_mupval() {
-    ctx.memr=&(ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff].upval()[imm[ctx.pc]&0xffff]);
-    (++ctx.top)[0]=ctx.memr[0];
-    // push value in this memory space on stack
-    // to avoid being garbage collected
-}
-
-void vm::o_mcallv() {
-    var val=ctx.top[0];     // index
-    var vec=(--ctx.top)[0]; // mcall vector, reserved on stack to avoid gc
-    if (vec.type==vm_vec) {
-        ctx.memr=vec.vec().get_mem(val.tonum());
-        if (!ctx.memr) {
-            die("index "+std::to_string(val.tonum())+" out of range");
-            return;
-        }
-    } else if (vec.type==vm_hash) { // do mcallh but use the mcallv way
-        if (val.type!=vm_str) {
-            die("key must be string");
-            return;
-        }
-        auto& ref = vec.hash();
-        auto& str = val.str();
-        ctx.memr = ref.get_mem(str);
-        if (!ctx.memr) {
-            ref.elems[str]=nil;
-            ctx.memr=ref.get_mem(str);
-        }
-    } else {
-        die("cannot get memory space in this type");
-        return;
-    }
-}
-
-void vm::o_mcallh() {
-    var hash=ctx.top[0]; // mcall hash, reserved on stack to avoid gc
-    if (hash.type!=vm_hash) {
-        die("must call a hash");
-        return;
-    }
-    auto& ref=hash.hash();
-    auto& str=cstr[imm[ctx.pc]];
-    ctx.memr=ref.get_mem(str);
-    if (!ctx.memr) { // create a new key
-        ref.elems[str]=nil;
-        ctx.memr=ref.get_mem(str);
-    }
-}
-
-void vm::o_ret() {
-/*  +-------------+
-*   | return value| <- top[0]
-*   +-------------+
-*   | old pc      | <- top[-1]
-*   +-------------+
-*   | old localr  | <- top[-2]
-*   +-------------+
-*   | old upvalr  | <- top[-3]
-*   +-------------+
-*   | local scope |
-*   +-------------+ <- local pointer stored in localr
-*   | old funcr   | <- old function stored in funcr
-*   +-------------+
-*/
-    var  ret  =ctx.top[0];
-    var* local=ctx.localr;
-    var  func =ctx.funcr;
-    var  up   =ctx.upvalr;
-
-    ctx.pc    =ctx.top[-1].ret();
-    ctx.localr=ctx.top[-2].addr();
-    ctx.upvalr=ctx.top[-3];
-
-    ctx.top=local-1;
-    ctx.funcr=ctx.top[0];
-    ctx.top[0]=ret; // rewrite func with returned value
-
-    if (up.type==vm_upval) { // synchronize upvalue
-        auto& upval=up.upval();
-        auto size=func.func().lsize;
-        upval.onstk=false;
-        upval.elems.resize(size);
-        for(u32 i=0;i<size;++i) {
-            upval.elems[i]=local[i];
-        }
-    }
-
-    // cannot use gc.cort to judge,
-    // because there maybe another function call inside but return here
-    // coroutine function ends with setting pc to 0
-    if (!ctx.pc) {
-        ngc.ctxreserve();
-    }
-}
-
-void vm::run(
-    const codegen& gen,
-    const linker& linker,
-    const std::vector<std::string>& argv,
-    const bool detail
-) {
-    verbose=detail;
-    init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
-#ifndef _MSC_VER
-    const void* oprs[]={
-        &&vmexit, &&intg,   &&intl,   &&loadg,
-        &&loadl,  &&loadu,  &&pnum,   &&pnil,
-        &&pstr,   &&newv,   &&newh,   &&newf,
-        &&happ,   &&para,   &&deft,   &&dyn,
-        &&lnot,   &&usub,   &&bnot,   &&btor,
-        &&btxor,  &&btand,  &&add,    &&sub,
-        &&mul,    &&div,    &&lnk,    &&addc,
-        &&subc,   &&mulc,   &&divc,   &&lnkc,
-        &&addeq,  &&subeq,  &&muleq,  &&diveq,
-        &&lnkeq,  &&bandeq, &&boreq,  &&bxoreq,
-        &&addeqc, &&subeqc, &&muleqc, &&diveqc,
-        &&lnkeqc, &&addecp, &&subecp, &&mulecp,
-        &&divecp, &&lnkecp, &&meq,    &&eq,
-        &&neq,    &&less,   &&leq,    &&grt,
-        &&geq,    &&lessc,  &&leqc,   &&grtc,
-        &&geqc,   &&pop,    &&jmp,    &&jt,
-        &&jf,     &&cnt,    &&findex, &&feach,
-        &&callg,  &&calll,  &&upval,  &&callv,
-        &&callvi, &&callh,  &&callfv, &&callfh,
-        &&callb,  &&slcbeg, &&slcend, &&slc,
-        &&slc2,   &&mcallg, &&mcalll, &&mupval,
-        &&mcallv, &&mcallh, &&ret
-    };
-    std::vector<const void*> code;
-    for(auto& i:gen.codes()) {
-        code.push_back(oprs[i.op]);
-        imm.push_back(i.num);
-    }
-    // goto the first operand
-    goto *code[ctx.pc];
-#else
-    typedef void (vm::*nafunc)();
-    const nafunc oprs[]={
-        nullptr,       &vm::o_intg,
-        &vm::o_intl,   &vm::o_loadg,
-        &vm::o_loadl,  &vm::o_loadu,
-        &vm::o_pnum,   &vm::o_pnil,
-        &vm::o_pstr,   &vm::o_newv,
-        &vm::o_newh,   &vm::o_newf,
-        &vm::o_happ,   &vm::o_para,
-        &vm::o_deft,   &vm::o_dyn,
-        &vm::o_lnot,   &vm::o_usub,
-        &vm::o_bnot,   &vm::o_btor,
-        &vm::o_btxor,  &vm::o_btand,
-        &vm::o_add,    &vm::o_sub,
-        &vm::o_mul,    &vm::o_div,
-        &vm::o_lnk,    &vm::o_addc,
-        &vm::o_subc,   &vm::o_mulc,
-        &vm::o_divc,   &vm::o_lnkc,
-        &vm::o_addeq,  &vm::o_subeq,
-        &vm::o_muleq,  &vm::o_diveq,
-        &vm::o_lnkeq,  &vm::o_bandeq,
-        &vm::o_boreq,  &vm::o_bxoreq,
-        &vm::o_addeqc, &vm::o_subeqc,
-        &vm::o_muleqc, &vm::o_diveqc,
-        &vm::o_lnkeqc, &vm::o_addecp,
-        &vm::o_subecp, &vm::o_mulecp,
-        &vm::o_divecp, &vm::o_lnkecp,
-        &vm::o_meq,    &vm::o_eq,
-        &vm::o_neq,    &vm::o_less,
-        &vm::o_leq,    &vm::o_grt,
-        &vm::o_geq,    &vm::o_lessc,
-        &vm::o_leqc,   &vm::o_grtc,
-        &vm::o_geqc,   &vm::o_pop,
-        &vm::o_jmp,    &vm::o_jt,
-        &vm::o_jf,     &vm::o_cnt,
-        &vm::o_findex, &vm::o_feach,
-        &vm::o_callg,  &vm::o_calll,
-        &vm::o_upval,  &vm::o_callv,
-        &vm::o_callvi, &vm::o_callh,
-        &vm::o_callfv, &vm::o_callfh,
-        &vm::o_callb,  &vm::o_slcbeg,
-        &vm::o_slcend, &vm::o_slc,
-        &vm::o_slc2,   &vm::o_mcallg,
-        &vm::o_mcalll, &vm::o_mupval,
-        &vm::o_mcallv, &vm::o_mcallh,
-        &vm::o_ret
-    };
-    std::vector<nafunc> code;
-    for(auto& i:gen.codes()) {
-        code.push_back(oprs[i.op]);
-        imm.push_back(i.num);
-    }
-    while(code[ctx.pc]) {
-        (this->*code[ctx.pc])();
-        if (ctx.top>=ctx.canary) {
-            die("stack overflow");
-        }
-        ++ctx.pc;
-    }
-#endif
-
-vmexit:
-    if (detail) {
-        ngc.info();
-    }
-    ngc.clear();
-    imm.clear();
-    return;
-
-#ifndef _MSC_VER
-// may cause stackoverflow
-#define exec_check(op) {\
-        op();\
-        if (ctx.top<ctx.canary)\
-            goto *code[++ctx.pc];\
-        die("stack overflow");\
-        goto *code[++ctx.pc];\
-    }
-// do not cause stackoverflow
-#define exec_nodie(op) {op();goto *code[++ctx.pc];}
-
-intg:   exec_nodie(o_intg  ); // +imm[pc] (detected at codegen)
-intl:   exec_nodie(o_intl  ); // -0
-loadg:  exec_nodie(o_loadg ); // -1
-loadl:  exec_nodie(o_loadl ); // -1
-loadu:  exec_nodie(o_loadu ); // -1
-pnum:   exec_check(o_pnum  ); // +1
-pnil:   exec_check(o_pnil  ); // +1
-pstr:   exec_check(o_pstr  ); // +1
-newv:   exec_check(o_newv  ); // +1-imm[pc]
-newh:   exec_check(o_newh  ); // +1
-newf:   exec_check(o_newf  ); // +1
-happ:   exec_nodie(o_happ  ); // -1
-para:   exec_nodie(o_para  ); // -0
-deft:   exec_nodie(o_deft  ); // -1
-dyn:    exec_nodie(o_dyn   ); // -0
-lnot:   exec_nodie(o_lnot  ); // -0
-usub:   exec_nodie(o_usub  ); // -0
-bnot:   exec_nodie(o_bnot  ); // -0
-btor:   exec_nodie(o_btor  ); // -1
-btxor:  exec_nodie(o_btxor ); // -1
-btand:  exec_nodie(o_btand ); // -1
-add:    exec_nodie(o_add   ); // -1
-sub:    exec_nodie(o_sub   ); // -1
-mul:    exec_nodie(o_mul   ); // -1
-div:    exec_nodie(o_div   ); // -1
-lnk:    exec_nodie(o_lnk   ); // -1
-addc:   exec_nodie(o_addc  ); // -0
-subc:   exec_nodie(o_subc  ); // -0
-mulc:   exec_nodie(o_mulc  ); // -0
-divc:   exec_nodie(o_divc  ); // -0
-lnkc:   exec_nodie(o_lnkc  ); // -0
-addeq:  exec_nodie(o_addeq ); // -1
-subeq:  exec_nodie(o_subeq ); // -1
-muleq:  exec_nodie(o_muleq ); // -1
-diveq:  exec_nodie(o_diveq ); // -1
-lnkeq:  exec_nodie(o_lnkeq ); // -1
-bandeq: exec_nodie(o_bandeq); // -1
-boreq:  exec_nodie(o_boreq ); // -1
-bxoreq: exec_nodie(o_bxoreq); // -1
-addeqc: exec_nodie(o_addeqc); // -0
-subeqc: exec_nodie(o_subeqc); // -0
-muleqc: exec_nodie(o_muleqc); // -0
-diveqc: exec_nodie(o_diveqc); // -0
-lnkeqc: exec_nodie(o_lnkeqc); // -0
-addecp: exec_nodie(o_addecp); // -1
-subecp: exec_nodie(o_subecp); // -1
-mulecp: exec_nodie(o_mulecp); // -1
-divecp: exec_nodie(o_divecp); // -1
-lnkecp: exec_nodie(o_lnkecp); // -1
-meq:    exec_nodie(o_meq   ); // -1
-eq:     exec_nodie(o_eq    ); // -1
-neq:    exec_nodie(o_neq   ); // -1
-less:   exec_nodie(o_less  ); // -1
-leq:    exec_nodie(o_leq   ); // -1
-grt:    exec_nodie(o_grt   ); // -1
-geq:    exec_nodie(o_geq   ); // -1
-lessc:  exec_nodie(o_lessc ); // -0
-leqc:   exec_nodie(o_leqc  ); // -0
-grtc:   exec_nodie(o_grtc  ); // -0
-geqc:   exec_nodie(o_geqc  ); // -0
-pop:    exec_nodie(o_pop   ); // -1
-jmp:    exec_nodie(o_jmp   ); // -0
-jt:     exec_nodie(o_jt    ); // -0
-jf:     exec_nodie(o_jf    ); // -1
-cnt:    exec_nodie(o_cnt   ); // -0
-findex: exec_check(o_findex); // +1
-feach:  exec_check(o_feach ); // +1
-callg:  exec_check(o_callg ); // +1
-calll:  exec_check(o_calll ); // +1
-upval:  exec_check(o_upval ); // +1
-callv:  exec_nodie(o_callv ); // -0
-callvi: exec_nodie(o_callvi); // -0
-callh:  exec_nodie(o_callh ); // -0
-callfv: exec_nodie(o_callfv); // check in the function
-callfh: exec_nodie(o_callfh); // check in the function
-callb:  exec_nodie(o_callb ); // -0
-slcbeg: exec_check(o_slcbeg); // +1
-slcend: exec_nodie(o_slcend); // -1
-slc:    exec_nodie(o_slc   ); // -1
-slc2:   exec_nodie(o_slc2  ); // -2
-mcallg: exec_check(o_mcallg); // +1
-mcalll: exec_check(o_mcalll); // +1
-mupval: exec_check(o_mupval); // +1
-mcallv: exec_nodie(o_mcallv); // -0
-mcallh: exec_nodie(o_mcallh); // -0
-ret:    exec_nodie(o_ret   ); // -2
-#endif
-}
+#pragma once
+
+#include <iomanip>
+#include <stack>
+
+#include "nasal_new_import.h"
+#include "nasal_new_gc.h"
+#include "nasal_new_codegen.h"
+
+#ifdef _MSC_VER
+#pragma warning (disable:4244)
+#pragma warning (disable:4267)
+#pragma warning (disable:4102)
+#endif
+
+class vm {
+protected:
+
+    /* registers and constants of vm */
+    context ctx;
+
+    /* constants */
+    const f64* cnum = nullptr; // constant numbers
+    const std::string* cstr = nullptr; // constant symbols and strings
+    std::vector<u32> imm; // immediate number table
+    
+    /* garbage collector */
+    gc ngc;
+
+    /* main stack */
+    var stack[STACK_DEPTH];
+
+    /* values used for debugger */
+    const std::string* files = nullptr; // file name list
+    const opcode* bytecode = nullptr; // bytecode buffer address
+
+    /* vm initializing function */
+    void init(
+        const std::vector<std::string>&,
+        const std::vector<f64>&,
+        const std::vector<opcode>&,
+        const std::vector<std::string>&,
+        const std::vector<std::string>&);
+
+    /* debug functions */
+    bool verbose;
+    void valinfo(var&);
+    void traceback();
+    void stackinfo(const u32);
+    void reginfo();
+    void gstate();
+    void lstate();
+    void ustate();
+    void detail();
+    void die(const std::string&);
+
+    /* vm calculation functions*/
+    inline bool cond(var&);
+
+    /* vm operands */
+    inline void o_intg();
+    inline void o_intl();
+    inline void o_loadg();
+    inline void o_loadl();
+    inline void o_loadu();
+    inline void o_pnum();
+    inline void o_pnil();
+    inline void o_pstr();
+    inline void o_newv();
+    inline void o_newh();
+    inline void o_newf();
+    inline void o_happ();
+    inline void o_para();
+    inline void o_deft();
+    inline void o_dyn();
+    inline void o_lnot();
+    inline void o_usub();
+    inline void o_bnot();
+    inline void o_btor();
+    inline void o_btxor();
+    inline void o_btand();
+    inline void o_add();
+    inline void o_sub();
+    inline void o_mul();
+    inline void o_div();
+    inline void o_lnk();
+    inline void o_addc();
+    inline void o_subc();
+    inline void o_mulc();
+    inline void o_divc();
+    inline void o_lnkc();
+    inline void o_addeq();
+    inline void o_subeq();
+    inline void o_muleq();
+    inline void o_diveq();
+    inline void o_lnkeq();
+    inline void o_bandeq();
+    inline void o_boreq();
+    inline void o_bxoreq();
+    inline void o_addeqc();
+    inline void o_subeqc();
+    inline void o_muleqc();
+    inline void o_diveqc();
+    inline void o_lnkeqc();
+    inline void o_addecp();
+    inline void o_subecp();
+    inline void o_mulecp();
+    inline void o_divecp();
+    inline void o_lnkecp();
+    inline void o_meq();
+    inline void o_eq();
+    inline void o_neq();
+    inline void o_less();
+    inline void o_leq();
+    inline void o_grt();
+    inline void o_geq();
+    inline void o_lessc();
+    inline void o_leqc();
+    inline void o_grtc();
+    inline void o_geqc();
+    inline void o_pop();
+    inline void o_jmp();
+    inline void o_jt();
+    inline void o_jf();
+    inline void o_cnt();
+    inline void o_findex();
+    inline void o_feach();
+    inline void o_callg();
+    inline void o_calll();
+    inline void o_upval();
+    inline void o_callv();
+    inline void o_callvi();
+    inline void o_callh();
+    inline void o_callfv();
+    inline void o_callfh();
+    inline void o_callb();
+    inline void o_slcbeg();
+    inline void o_slcend();
+    inline void o_slc();
+    inline void o_slc2();
+    inline void o_mcallg();
+    inline void o_mcalll();
+    inline void o_mupval();
+    inline void o_mcallv();
+    inline void o_mcallh();
+    inline void o_ret();
+
+public:
+
+    /* constructor of vm instance */
+    vm(): ngc(&ctx), verbose(false) {}
+
+    /* execution entry */
+    void run(
+        const codegen&,
+        const linker&,
+        const std::vector<std::string>&,
+        const bool
+    );
+};
+
+inline bool vm::cond(var& val) {
+    if (val.type==vm_num) {
+        return val.num();
+    } else if (val.type==vm_str) {
+        const f64 num=str2num(val.str().c_str());
+        return std::isnan(num)? !val.str().empty():num;
+    }
+    return false;
+}
+
+inline void vm::o_intg() {
+    // global values store on stack
+    ctx.top+=imm[ctx.pc];
+    --ctx.top;// point to the top
+}
+
+inline void vm::o_intl() {
+    ctx.top[0].func().local.resize(imm[ctx.pc], nil);
+    ctx.top[0].func().lsize=imm[ctx.pc];
+}
+
+inline void vm::o_loadg() {
+    stack[imm[ctx.pc]]=(ctx.top--)[0];
+}
+
+inline void vm::o_loadl() {
+    ctx.localr[imm[ctx.pc]]=(ctx.top--)[0];
+}
+
+inline void vm::o_loadu() {
+    ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff]
+         .upval()[imm[ctx.pc]&0xffff]=(ctx.top--)[0];
+}
+
+inline void vm::o_pnum() {
+    (++ctx.top)[0]=var::num(cnum[imm[ctx.pc]]);
+}
+
+inline void vm::o_pnil() {
+    (++ctx.top)[0]=nil;
+}
+
+inline void vm::o_pstr() {
+    (++ctx.top)[0]=ngc.strs[imm[ctx.pc]];
+}
+
+inline void vm::o_newv() {
+    var newv=ngc.alloc(vm_vec);
+    auto& vec=newv.vec().elems;
+    vec.resize(imm[ctx.pc]);
+    // use top-=imm[pc]-1 here will cause error if imm[pc] is 0
+    ctx.top=ctx.top-imm[ctx.pc]+1;
+    for(u32 i=0;i<imm[ctx.pc];++i) {
+        vec[i]=ctx.top[i];
+    }
+    ctx.top[0]=newv;
+}
+
+inline void vm::o_newh() {
+    (++ctx.top)[0]=ngc.alloc(vm_hash);
+}
+
+inline void vm::o_newf() {
+    (++ctx.top)[0]=ngc.alloc(vm_func);
+    nas_func& func=ctx.top[0].func();
+    func.entry=imm[ctx.pc];
+    func.psize=1;
+
+    /* this means you create a new function in local scope */
+    if (ctx.localr) {
+        func.upval=ctx.funcr.func().upval;
+        // function created in the same local scope shares one closure
+        // so this size & stk setting has no problem
+        var upval=(ctx.upvalr.type==vm_nil)?ngc.alloc(vm_upval):ctx.upvalr;
+        upval.upval().size=ctx.funcr.func().lsize;
+        upval.upval().stk=ctx.localr;
+        func.upval.push_back(upval);
+        ctx.upvalr=upval;
+    }
+}
+
+inline void vm::o_happ() {
+    ctx.top[-1].hash().elems[cstr[imm[ctx.pc]]]=ctx.top[0];
+    --ctx.top;
+}
+
+inline void vm::o_para() {
+    nas_func& func=ctx.top[0].func();
+    // func->size has 1 place reserved for "me"
+    func.keys[imm[ctx.pc]]=func.psize;
+    func.local[func.psize++]=var::none();
+}
+
+inline void vm::o_deft() {
+    var val=ctx.top[0];
+    nas_func& func=(--ctx.top)[0].func();
+    // func->size has 1 place reserved for "me"
+    func.keys[imm[ctx.pc]]=func.psize;
+    func.local[func.psize++]=val;
+}
+
+inline void vm::o_dyn() {
+    ctx.top[0].func().dpara=imm[ctx.pc];
+}
+
+inline void vm::o_lnot() {
+    var val=ctx.top[0];
+    switch(val.type) {
+        case vm_nil:ctx.top[0]=one;break;
+        case vm_num:ctx.top[0]=val.num()?zero:one;break;
+        case vm_str:{
+            const f64 num=str2num(val.str().c_str());
+            if (std::isnan(num)) {
+                ctx.top[0]=var::num((f64)val.str().empty());
+            } else {
+                ctx.top[0]=num?zero:one;
+            }
+        } break;
+        default:{
+            die("incorrect value type");
+            return;
+        } break;
+    }
+}
+
+inline void vm::o_usub() {
+    ctx.top[0]=var::num(-ctx.top[0].tonum());
+}
+
+inline void vm::o_bnot() {
+    ctx.top[0]=var::num(~static_cast<int32_t>(ctx.top[0].num()));
+}
+
+inline void vm::o_btor() {
+    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())|static_cast<int32_t>(ctx.top[0].tonum()));
+    --ctx.top;
+}
+
+inline void vm::o_btxor() {
+    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())^static_cast<int32_t>(ctx.top[0].tonum()));
+    --ctx.top;
+}
+
+inline void vm::o_btand() {
+    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())&static_cast<int32_t>(ctx.top[0].tonum()));
+    --ctx.top;
+}
+
+#define op_calc(type)\
+    ctx.top[-1]=var::num(ctx.top[-1].tonum() type ctx.top[0].tonum());\
+    --ctx.top;
+
+inline void vm::o_add() {op_calc(+);}
+inline void vm::o_sub() {op_calc(-);}
+inline void vm::o_mul() {op_calc(*);}
+inline void vm::o_div() {op_calc(/);}
+inline void vm::o_lnk() {
+    ctx.top[-1]=ngc.newstr(ctx.top[-1].tostr()+ctx.top[0].tostr());
+    --ctx.top;
+}
+
+#define op_calc_const(type)\
+    ctx.top[0]=var::num(ctx.top[0].tonum() type cnum[imm[ctx.pc]]);
+
+inline void vm::o_addc() {op_calc_const(+);}
+inline void vm::o_subc() {op_calc_const(-);}
+inline void vm::o_mulc() {op_calc_const(*);}
+inline void vm::o_divc() {op_calc_const(/);}
+inline void vm::o_lnkc() {
+    ctx.top[0]=ngc.newstr(ctx.top[0].tostr()+cstr[imm[ctx.pc]]);
+}
+
+// top[0] stores the value of memr[0], to avoid being garbage-collected
+// so when the calculation ends, top-=1, then top-=imm[pc]
+// because this return value is meaningless if on stack when imm[pc]=1
+// like this: func{a+=c;}(); the result of 'a+c' will no be used later, imm[pc]=1
+// but if b+=a+=c; the result of 'a+c' will be used later, imm[pc]=0
+#define op_calc_eq(type)\
+    ctx.top[-1]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type ctx.top[-1].tonum());\
+    ctx.memr=nullptr;\
+    ctx.top-=imm[ctx.pc]+1;
+
+inline void vm::o_addeq() {op_calc_eq(+);}
+inline void vm::o_subeq() {op_calc_eq(-);}
+inline void vm::o_muleq() {op_calc_eq(*);}
+inline void vm::o_diveq() {op_calc_eq(/);}
+inline void vm::o_lnkeq() {
+    ctx.top[-1]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+ctx.top[-1].tostr());
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+inline void vm::o_bandeq() {
+    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())&i32(ctx.top[-1].tonum()));
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+inline void vm::o_boreq() {
+    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())|i32(ctx.top[-1].tonum()));
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+inline void vm::o_bxoreq() {
+    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())^i32(ctx.top[-1].tonum()));
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+// top[0] stores the value of memr[0], to avoid being garbage-collected
+// so when the calculation ends, top-=imm[pc]>>31
+// because this return value is meaningless if on stack when imm[pc]>>31=1
+// like this: func{a+=1;}(); the result of 'a+1' will no be used later, imm[pc]>>31=1
+// but if b+=a+=1; the result of 'a+1' will be used later, imm[pc]>>31=0
+#define op_calc_eq_const(type)\
+    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
+    ctx.memr=nullptr;
+
+inline void vm::o_addeqc() {op_calc_eq_const(+);}
+inline void vm::o_subeqc() {op_calc_eq_const(-);}
+inline void vm::o_muleqc() {op_calc_eq_const(*);}
+inline void vm::o_diveqc() {op_calc_eq_const(/);}
+inline void vm::o_lnkeqc() {
+    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
+    ctx.memr=nullptr;
+}
+
+#define op_calc_eq_const_and_pop(type)\
+    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
+    ctx.memr=nullptr;\
+    --ctx.top;
+
+inline void vm::o_addecp() {op_calc_eq_const_and_pop(+);}
+inline void vm::o_subecp() {op_calc_eq_const_and_pop(-);}
+inline void vm::o_mulecp() {op_calc_eq_const_and_pop(*);}
+inline void vm::o_divecp() {op_calc_eq_const_and_pop(/);}
+inline void vm::o_lnkecp() {
+    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
+    ctx.memr=nullptr;
+    --ctx.top;
+}
+
+inline void vm::o_meq() {
+    // pop old memr[0] and replace it
+    // the reason why we should get memr and push the old value on stack
+    // is that when lnkeq/lnkeqc is called, there will be
+    // a new gc object vm_str which is returned by gc::alloc
+    // this may cause gc, so we should temporarily put it on stack
+    ctx.memr[0]=ctx.top[-1];
+    ctx.memr=nullptr;
+    ctx.top-=imm[ctx.pc]+1;
+}
+
+inline void vm::o_eq() {
+    var val2=ctx.top[0];
+    var val1=(--ctx.top)[0];
+    if (val1.type==vm_nil && val2.type==vm_nil) {
+        ctx.top[0]=one;
+    } else if (val1.type==vm_str && val2.type==vm_str) {
+        ctx.top[0]=(val1.str()==val2.str())?one:zero;
+    } else if ((val1.type==vm_num || val2.type==vm_num)
+        && val1.type!=vm_nil && val2.type!=vm_nil) {
+        ctx.top[0]=(val1.tonum()==val2.tonum())?one:zero;
+    } else {
+        ctx.top[0]=(val1==val2)?one:zero;
+    }
+}
+
+inline void vm::o_neq() {
+    var val2=ctx.top[0];
+    var val1=(--ctx.top)[0];
+    if (val1.type==vm_nil && val2.type==vm_nil) {
+        ctx.top[0]=zero;
+    } else if (val1.type==vm_str && val2.type==vm_str) {
+        ctx.top[0]=(val1.str()!=val2.str())?one:zero;
+    } else if ((val1.type==vm_num || val2.type==vm_num)
+        && val1.type!=vm_nil && val2.type!=vm_nil) {
+        ctx.top[0]=(val1.tonum()!=val2.tonum())?one:zero;
+    } else {
+        ctx.top[0]=(val1!=val2)?one:zero;
+    }
+}
+
+#define op_cmp(type)\
+    --ctx.top;\
+    ctx.top[0]=(ctx.top[0].tonum() type ctx.top[1].tonum())?one:zero;
+
+inline void vm::o_less() {op_cmp(<);}
+inline void vm::o_leq() {op_cmp(<=);}
+inline void vm::o_grt() {op_cmp(>);}
+inline void vm::o_geq() {op_cmp(>=);}
+
+#define op_cmp_const(type)\
+    ctx.top[0]=(ctx.top[0].tonum() type cnum[imm[ctx.pc]])?one:zero;
+
+inline void vm::o_lessc() {op_cmp_const(<);}
+inline void vm::o_leqc() {op_cmp_const(<=);}
+inline void vm::o_grtc() {op_cmp_const(>);}
+inline void vm::o_geqc() {op_cmp_const(>=);}
+
+inline void vm::o_pop() {
+    --ctx.top;
+}
+
+inline void vm::o_jmp() {
+    ctx.pc=imm[ctx.pc]-1;
+}
+
+inline void vm::o_jt() {
+    // jump true needs to reserve the result on stack
+    // because conditional expression in nasal has return value
+    if (cond(ctx.top[0])) {
+        ctx.pc=imm[ctx.pc]-1;
+    }
+}
+
+inline void vm::o_jf() {
+    // jump false doesn't need to reserve result
+    if (!cond(ctx.top[0])) {
+        ctx.pc=imm[ctx.pc]-1;
+    }
+    --ctx.top;
+}
+
+inline void vm::o_cnt() {
+    if (ctx.top[0].type!=vm_vec) {
+        die("must use vector in forindex/foreach");
+        return;
+    }
+    (++ctx.top)[0]=var::cnt(-1);
+}
+
+inline void vm::o_findex() {
+    if ((usize)(++ctx.top[0].cnt())>=ctx.top[-1].vec().size()) {
+        ctx.pc=imm[ctx.pc]-1;
+        return;
+    }
+    ctx.top[1]=var::num(ctx.top[0].cnt());
+    ++ctx.top;
+}
+
+inline void vm::o_feach() {
+    auto& ref=ctx.top[-1].vec().elems;
+    if ((usize)(++ctx.top[0].cnt())>=ref.size()) {
+        ctx.pc=imm[ctx.pc]-1;
+        return;
+    }
+    ctx.top[1]=ref[ctx.top[0].cnt()];
+    ++ctx.top;
+}
+
+inline void vm::o_callg() {
+    // get main stack directly
+    (++ctx.top)[0]=stack[imm[ctx.pc]];
+}
+
+inline void vm::o_calll() {
+    (++ctx.top)[0]=ctx.localr[imm[ctx.pc]];
+}
+
+inline void vm::o_upval() {
+    (++ctx.top)[0]=ctx.funcr.func()
+        .upval[(imm[ctx.pc]>>16)&0xffff]
+        .upval()[imm[ctx.pc]&0xffff];
+}
+
+inline void vm::o_callv() {
+    var val=ctx.top[0];
+    var vec=(--ctx.top)[0];
+    if (vec.type==vm_vec) {
+        ctx.top[0]=vec.vec().get_val(val.tonum());
+        if (ctx.top[0].type==vm_none) {
+            die("out of range:"+std::to_string(val.tonum()));
+            return;
+        }
+    } else if (vec.type==vm_hash) {
+        if (val.type!=vm_str) {
+            die("must use string as the key");
+            return;
+        }
+        ctx.top[0]=vec.hash().get_val(val.str());
+        if (ctx.top[0].type==vm_none) {
+            die("cannot find member \""+val.str()+"\"");
+            return;
+        } else if (ctx.top[0].type==vm_func) {
+            ctx.top[0].func().local[0]=val; // 'me'
+        }
+    } else if (vec.type==vm_str) {
+        auto& str = vec.str();
+        i32 num = val.tonum();
+        i32 len = str.length();
+        if (num<-len || num>=len) {
+            die("out of range:"+std::to_string(val.tonum()));
+            return;
+        }
+        ctx.top[0]=var::num(f64((u8)str[num>=0? num:num+len]));
+    } else {
+        die("must call a vector/hash/string");
+        return;
+    }
+}
+
+inline void vm::o_callvi() {
+    var val=ctx.top[0];
+    if (val.type!=vm_vec) {
+        die("must use a vector");
+        return;
+    }
+    // cannot use operator[],because this may cause overflow
+    (++ctx.top)[0]=val.vec().get_val(imm[ctx.pc]);
+    if (ctx.top[0].type==vm_none) {
+        die("out of range:"+std::to_string(imm[ctx.pc]));
+        return;
+    }
+}
+
+inline void vm::o_callh() {
+    var val=ctx.top[0];
+    if (val.type!=vm_hash) {
+        die("must call a hash");
+        return;
+    }
+    ctx.top[0]=val.hash().get_val(cstr[imm[ctx.pc]]);
+    if (ctx.top[0].type==vm_none) {
+        die("member \""+cstr[imm[ctx.pc]]+"\" does not exist");
+        return;
+    } else if (ctx.top[0].type==vm_func) {
+        ctx.top[0].func().local[0]=val; // 'me'
+    }
+}
+
+inline void vm::o_callfv() {
+    u32 argc=imm[ctx.pc]; // arguments counter
+    var* local=ctx.top-argc+1; // arguments begin address
+    if (local[-1].type!=vm_func) {
+        die("must call a function");
+        return;
+    }
+    auto& func=local[-1].func();
+    var tmp=local[-1];
+    local[-1]=ctx.funcr;
+    ctx.funcr=tmp;
+    // top-argc+lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
+    if (ctx.top-argc+func.lsize+3>=ctx.canary) {
+        die("stack overflow");
+        return;
+    }
+    // parameter size is func->psize-1, 1 is reserved for "me"
+    u32 psize=func.psize-1;
+    if (argc<psize && func.local[argc+1].type==vm_none) {
+        die("lack argument(s)");
+        return;
+    }
+
+    var dynamic=nil;
+    if (func.dpara>=0) { // load dynamic arguments
+        dynamic=ngc.alloc(vm_vec);
+        for(u32 i=psize;i<argc;++i) {
+            dynamic.vec().elems.push_back(local[i]);
+        }
+    }
+    // should reset stack top after allocating vector
+    // because this may cause gc
+    // then all the available values the vector needs
+    // are all outside the stack top and may be
+    // collected incorrectly
+    ctx.top=local+func.lsize;
+
+    u32 min_size=(std::min)(psize, argc); // avoid error in MSVC
+    for(u32 i=min_size;i>=1;--i) { // load arguments
+        local[i]=local[i-1];
+    }
+    local[0]=func.local[0];// load "me"
+    // load local scope & default arguments
+    for(u32 i=min_size+1;i<func.lsize;++i) {
+        local[i]=func.local[i];
+    }
+    if (func.dpara>=0) {
+        local[psize+1]=dynamic;
+    }
+
+    ctx.top[0]=ctx.upvalr;
+    (++ctx.top)[0]=var::addr(ctx.localr);
+    (++ctx.top)[0]=var::ret(ctx.pc);
+    ctx.pc=func.entry-1;
+    ctx.localr=local;
+    ctx.upvalr=nil;
+}
+
+inline void vm::o_callfh() {
+    auto& hash=ctx.top[0].hash().elems;
+    if (ctx.top[-1].type!=vm_func) {
+        die("must call a function");
+        return;
+    }
+    auto& func=ctx.top[-1].func();
+    var tmp=ctx.top[-1];
+    ctx.top[-1]=ctx.funcr;
+    ctx.funcr=tmp;
+
+    // top -1(hash) +lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
+    if (ctx.top+func.lsize+2>=ctx.canary) {
+        die("stack overflow");
+        return;
+    }
+    if (func.dpara>=0) {
+        die("special call cannot use dynamic argument");
+        return;
+    }
+
+    var* local=ctx.top;
+    ctx.top+=func.lsize;
+    for(u32 i=0;i<func.lsize;++i) {
+        local[i]=func.local[i];
+    }
+    
+    for(auto& i:func.keys) {
+        auto& key=cstr[i.first];
+        if (hash.count(key)) {
+            local[i.second]=hash[key];
+        } else if (local[i.second].type==vm_none) {
+            die("lack argument(s): \""+key+"\"");
+            return;
+        }
+    }
+
+    ctx.top[0]=ctx.upvalr;
+    (++ctx.top)[0]=var::addr(ctx.localr);
+    (++ctx.top)[0]=var::ret(ctx.pc); // rewrite top with vm_ret
+    ctx.pc=func.entry-1;
+    ctx.localr=local;
+    ctx.upvalr=nil;
+}
+
+inline void vm::o_callb() {
+    // reserve place for builtin function return,
+    // this code is written for coroutine
+    (++ctx.top)[0]=nil;
+
+    // if running a builtin function about coroutine
+    // (top) will be set to another context.top, instead of main_context.top
+    var tmp=(*builtin[imm[ctx.pc]].func)(ctx.localr, ngc);
+
+    // so we use tmp variable to store this return value
+    // and set it to top[0] later
+    ctx.top[0]=tmp;
+
+    // if get none, this means errors occurred when calling this native function
+    if (ctx.top[0].type==vm_none) {
+        die("native function error");
+        return;
+    }
+}
+
+inline void vm::o_slcbeg() {
+    // +--------------+
+    // | slice_vector | <-- top[0]
+    // +--------------+
+    // | resource_vec | <-- top[-1]
+    // +--------------+
+    (++ctx.top)[0]=ngc.alloc(vm_vec);
+    if (ctx.top[-1].type!=vm_vec) {
+        die("must slice a vector");
+        return;
+    }
+}
+
+inline void vm::o_slcend() {
+    ctx.top[-1]=ctx.top[0];
+    --ctx.top;
+}
+
+inline void vm::o_slc() {
+    var val=(ctx.top--)[0];
+    var res=ctx.top[-1].vec().get_val(val.tonum());
+    if (res.type==vm_none) {
+        die("index "+std::to_string(val.tonum())+" out of range");
+        return;
+    }
+    ctx.top[0].vec().elems.push_back(res);
+}
+
+inline void vm::o_slc2() {
+    var val2=(ctx.top--)[0];
+    var val1=(ctx.top--)[0];
+    auto& ref=ctx.top[-1].vec().elems;
+    auto& aim=ctx.top[0].vec().elems;
+
+    u8 type1=val1.type,type2=val2.type;
+    i32 num1=val1.tonum();
+    i32 num2=val2.tonum();
+    i32 size=ref.size();
+    if (type1==vm_nil && type2==vm_nil) {
+        num1=0;
+        num2=size-1;
+    } else if (type1==vm_nil && type2!=vm_nil) {
+        num1=num2<0? -size:0;
+    } else if (type1!=vm_nil && type2==vm_nil) {
+        num2=num1<0? -1:size-1;
+    }
+
+    if (num1<-size || num1>=size || num2<-size || num2>=size) {
+        die("index "+std::to_string(num1)+":"+std::to_string(num2)+" out of range");
+        return;
+    } else if (num1<=num2) {
+        for(i32 i=num1;i<=num2;++i) {
+            aim.push_back(i>=0?ref[i]:ref[i+size]);
+        }
+    }
+}
+
+inline void vm::o_mcallg() {
+    ctx.memr=stack+imm[ctx.pc];
+    (++ctx.top)[0]=ctx.memr[0];
+    // push value in this memory space on stack
+    // to avoid being garbage collected
+}
+
+inline void vm::o_mcalll() {
+    ctx.memr=ctx.localr+imm[ctx.pc];
+    (++ctx.top)[0]=ctx.memr[0];
+    // push value in this memory space on stack
+    // to avoid being garbage collected
+}
+
+inline void vm::o_mupval() {
+    ctx.memr=&(ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff].upval()[imm[ctx.pc]&0xffff]);
+    (++ctx.top)[0]=ctx.memr[0];
+    // push value in this memory space on stack
+    // to avoid being garbage collected
+}
+
+inline void vm::o_mcallv() {
+    var val=ctx.top[0];     // index
+    var vec=(--ctx.top)[0]; // mcall vector, reserved on stack to avoid gc
+    if (vec.type==vm_vec) {
+        ctx.memr=vec.vec().get_mem(val.tonum());
+        if (!ctx.memr) {
+            die("index "+std::to_string(val.tonum())+" out of range");
+            return;
+        }
+    } else if (vec.type==vm_hash) { // do mcallh but use the mcallv way
+        if (val.type!=vm_str) {
+            die("key must be string");
+            return;
+        }
+        auto& ref = vec.hash();
+        auto& str = val.str();
+        ctx.memr = ref.get_mem(str);
+        if (!ctx.memr) {
+            ref.elems[str]=nil;
+            ctx.memr=ref.get_mem(str);
+        }
+    } else {
+        die("cannot get memory space in this type");
+        return;
+    }
+}
+
+inline void vm::o_mcallh() {
+    var hash=ctx.top[0]; // mcall hash, reserved on stack to avoid gc
+    if (hash.type!=vm_hash) {
+        die("must call a hash");
+        return;
+    }
+    auto& ref=hash.hash();
+    auto& str=cstr[imm[ctx.pc]];
+    ctx.memr=ref.get_mem(str);
+    if (!ctx.memr) { // create a new key
+        ref.elems[str]=nil;
+        ctx.memr=ref.get_mem(str);
+    }
+}
+
+inline void vm::o_ret() {
+/*  +-------------+
+*   | return value| <- top[0]
+*   +-------------+
+*   | old pc      | <- top[-1]
+*   +-------------+
+*   | old localr  | <- top[-2]
+*   +-------------+
+*   | old upvalr  | <- top[-3]
+*   +-------------+
+*   | local scope |
+*   +-------------+ <- local pointer stored in localr
+*   | old funcr   | <- old function stored in funcr
+*   +-------------+
+*/
+    var  ret  =ctx.top[0];
+    var* local=ctx.localr;
+    var  func =ctx.funcr;
+    var  up   =ctx.upvalr;
+
+    ctx.pc    =ctx.top[-1].ret();
+    ctx.localr=ctx.top[-2].addr();
+    ctx.upvalr=ctx.top[-3];
+
+    ctx.top=local-1;
+    ctx.funcr=ctx.top[0];
+    ctx.top[0]=ret; // rewrite func with returned value
+
+    if (up.type==vm_upval) { // synchronize upvalue
+        auto& upval=up.upval();
+        auto size=func.func().lsize;
+        upval.onstk=false;
+        upval.elems.resize(size);
+        for(u32 i=0;i<size;++i) {
+            upval.elems[i]=local[i];
+        }
+    }
+
+    // cannot use gc.cort to judge,
+    // because there maybe another function call inside but return here
+    // coroutine function ends with setting pc to 0
+    if (!ctx.pc) {
+        ngc.ctxreserve();
+    }
+}
\ No newline at end of file
diff --git a/ast/optimizer.cpp b/src/optimizer.cpp
similarity index 100%
rename from ast/optimizer.cpp
rename to src/optimizer.cpp
diff --git a/ast/optimizer.h b/src/optimizer.h
similarity index 100%
rename from ast/optimizer.h
rename to src/optimizer.h
diff --git a/ast/symbol_finder.cpp b/src/symbol_finder.cpp
similarity index 94%
rename from ast/symbol_finder.cpp
rename to src/symbol_finder.cpp
index 7b2cdf2..883c80a 100644
--- a/ast/symbol_finder.cpp
+++ b/src/symbol_finder.cpp
@@ -20,6 +20,7 @@ bool symbol_finder::visit_iter_expr(iter_expr* node) {
     if (node->get_name()) {
         symbols.push_back(node->get_name()->get_name());
     }
+    return true;
 }
 
 const std::vector<std::string>& symbol_finder::do_find(code_block* root) {
diff --git a/ast/symbol_finder.h b/src/symbol_finder.h
similarity index 100%
rename from ast/symbol_finder.h
rename to src/symbol_finder.h

From a7a2f47d1e38757104b191f53a61ba6fc0f90130 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sun, 2 Jul 2023 00:32:13 +0800
Subject: [PATCH 28/34] :rocket: switch build script to new nasal

---
 .github/workflows/c-cpp.yml |   8 +-
 CMakeLists.txt              |  37 +++-
 README.md                   |   2 +-
 doc/README_zh.md            |   2 +-
 makefile                    | 154 +++++++--------
 module/makefile             |   2 +-
 src/nasal_new_codegen.cpp   | 367 +++++++++++++++++-------------------
 src/nasal_new_codegen.h     |   3 +-
 src/nasal_new_header.h      |   2 +-
 src/nasal_new_main.cpp      | 107 ++++++-----
 src/nasal_new_parse.cpp     |   2 +-
 src/nasal_new_parse.h       |   2 +-
 12 files changed, 348 insertions(+), 340 deletions(-)

diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml
index db27e23..f1291c3 100644
--- a/.github/workflows/c-cpp.yml
+++ b/.github/workflows/c-cpp.yml
@@ -16,9 +16,9 @@ jobs:
     - uses: actions/checkout@v2
     - name: make
       run: |
-          make
+          make -j
           cd module
-          make all
+          make all -j
           cd ..
           make test
           tar -czf nasal-mac-nightly.tgz .
@@ -42,9 +42,9 @@ jobs:
     - uses: actions/checkout@v2
     - name: make
       run: |
-          make
+          make -j
           cd module
-          make all
+          make all -j
           cd ..
           make test
           touch nasal-linux-x86_64-nightly.tgz
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 4850541..90dd40c 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -4,7 +4,7 @@ project(nasal VERSION 10.1)
 
 message("CMAKE_HOST_SYSTEM_NAME: ${CMAKE_HOST_SYSTEM_NAME}")
 
-# -std=c++14 -Wshadow -Wall
+# -std=c++17 -Wshadow -Wall
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_CXX_FLAGS_RELEASE_INIT "-Wshadow -Wall")
@@ -14,24 +14,45 @@ set(CMAKE_BUILD_TYPE "Release")
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/module)
 
 add_library(fib SHARED ${CMAKE_SOURCE_DIR}/module/fib.cpp)
-target_include_directories(fib PRIVATE ${CMAKE_SOURCE_DIR})
+target_include_directories(fib PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 add_library(key SHARED ${CMAKE_SOURCE_DIR}/module/keyboard.cpp)
-target_include_directories(key PRIVATE ${CMAKE_SOURCE_DIR})
+target_include_directories(key PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 add_library(mat SHARED ${CMAKE_SOURCE_DIR}/module/matrix.cpp)
-target_include_directories(mat PRIVATE ${CMAKE_SOURCE_DIR})
+target_include_directories(mat PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 add_library(nasock SHARED ${CMAKE_SOURCE_DIR}/module/nasocket.cpp)
-target_include_directories(nasock PRIVATE ${CMAKE_SOURCE_DIR})
+target_include_directories(nasock PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
-add_executable(nasal main.cpp)
+set(NASAL_OBJECT_SOURCE_FILE
+    ${CMAKE_SOURCE_DIR}/src/ast_dumper.cpp
+    ${CMAKE_SOURCE_DIR}/src/ast_visitor.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_ast.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_builtin.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_codegen.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_dbg.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_err.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_gc.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_import.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_lexer.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_misc.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_opcode.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_parse.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_vm.cpp
+    ${CMAKE_SOURCE_DIR}/src/optimizer.cpp
+    ${CMAKE_SOURCE_DIR}/src/symbol_finder.cpp)
 
+add_executable(nasal ${CMAKE_SOURCE_DIR}/src/nasal_new_main.cpp)
+
+add_library(nasal-object STATIC ${NASAL_OBJECT_SOURCE_FILE})
+target_include_directories(nasal-object PRIVATE ${CMAKE_SOURCE_DIR}/src)
+
+target_link_libraries(nasal nasal-object)
 if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
     target_link_libraries(nasal dl)
 endif()
-
-target_include_directories(nasal PRIVATE ${CMAKE_SOURCE_DIR})
+target_include_directories(nasal PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
     add_custom_command(
diff --git a/README.md b/README.md
index 5f72b5d..b2dd19b 100644
--- a/README.md
+++ b/README.md
@@ -4,7 +4,7 @@
 
 ![GitHub code size](https://img.shields.io/github/languages/code-size/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
 ![GitHub release(latest by date)](https://img.shields.io/github/v/release/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
-![in dev](https://img.shields.io/badge/dev-v10.1-blue?style=flat-square&logo=github)
+![in dev](https://img.shields.io/badge/dev-v11.0-blue?style=flat-square&logo=github)
 [![license](https://img.shields.io/badge/license-MIT-green?style=flat-square&logo=github)](./LICENSE)
 
 > This document is also available in: [__中文__](./doc/README_zh.md) | [__English__](./README.md)
diff --git a/doc/README_zh.md b/doc/README_zh.md
index 04a4277..c8b7515 100644
--- a/doc/README_zh.md
+++ b/doc/README_zh.md
@@ -4,7 +4,7 @@
 
 ![GitHub code size](https://img.shields.io/github/languages/code-size/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
 ![GitHub release(latest by date)](https://img.shields.io/github/v/release/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
-![in dev](https://img.shields.io/badge/dev-v10.1-blue?style=flat-square&logo=github)
+![in dev](https://img.shields.io/badge/dev-v11.0-blue?style=flat-square&logo=github)
 [![license](https://img.shields.io/badge/license-MIT-green?style=flat-square&logo=github)](../LICENSE)
 
 > 这篇文档包含多语言版本: [__中文__](../doc/README_zh.md) | [__English__](../README.md)
diff --git a/makefile b/makefile
index 08c5a68..e9fa4d5 100644
--- a/makefile
+++ b/makefile
@@ -1,79 +1,8 @@
 .PHONY:test clean
 
-SRC=\
-	main.cpp\
-	nasal_ast.h\
-	nasal_err.h\
-	nasal_builtin.h\
-	nasal_opcode.h\
-	nasal_opt.h\
-	nasal_codegen.h\
-	nasal_gc.h\
-	nasal_import.h\
-	nasal_lexer.h\
-	nasal_parse.h\
-	nasal_vm.h\
-	nasal_dbg.h\
-	nasal.h
-
 STD=c++17
 
-nasal:$(SRC)
-	$(CXX) -std=$(STD) -O3 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
-
-nasal.exe:$(SRC)
-	$(CXX) -std=$(STD) -O3 main.cpp -o nasal.exe -fno-exceptions -Wshadow -Wall -static
-
-stable-release:$(SRC)
-	$(CXX) -std=$(STD) -O2 main.cpp -o nasal -fno-exceptions -ldl -Wshadow -Wall
-
-stable-release-mingw:$(SRC)
-	$(CXX) -std=$(STD) -O2 main.cpp -o nasal.exe -fno-exceptions -Wshadow -Wall -static
-
-clean:
-	@ echo "[clean] nasal" && if [ -e nasal ]; then rm nasal; fi
-	@ echo "[clean] nasal.exe" && if [ -e nasal.exe ]; then rm nasal.exe; fi
-
-test:nasal
-	@ ./nasal -e test/ascii-art.nas
-	@ ./nasal -t -d test/bfs.nas
-	@ ./nasal -t test/bigloop.nas
-	@ ./nasal -t test/bp.nas
-	@ ./nasal -d test/calc.nas
-	@ ./nasal -e test/choice.nas
-	@ ./nasal -e test/class.nas
-	@ ./nasal -t -d test/console3D.nas 20
-	@ ./nasal -e test/coroutine.nas
-	@ ./nasal -t -d test/datalog.nas
-	@ ./nasal -e test/diff.nas
-	@ ./nasal -e test/donuts.nas 15
-	-@ ./nasal -d test/exception.nas
-	@ ./nasal -t -d test/fib.nas
-	@ ./nasal -e test/filesystem.nas
-	@ ./nasal -d test/hexdump.nas
-	@ ./nasal -e test/json.nas
-	@ ./nasal -e test/leetcode1319.nas
-	@ ./nasal -d test/lexer.nas
-	@ ./nasal -d test/life.nas
-	@ ./nasal -t test/loop.nas
-	@ ./nasal -t test/mandelbrot.nas
-	@ ./nasal -t test/md5.nas
-	@ ./nasal -t -d test/md5compare.nas
-	@ ./nasal -d test/module_test.nas
-	@ ./nasal -e test/nasal_test.nas
-	@ ./nasal -t -d test/occupation.nas 2
-	@ ./nasal -t -d test/pi.nas
-	@ ./nasal -t -d test/prime.nas
-	@ ./nasal -e test/qrcode.nas
-	@ ./nasal -t -d test/quick_sort.nas
-	@ ./nasal -e test/scalar.nas hello world
-	@ ./nasal -e test/trait.nas
-	@ ./nasal -t -d test/turingmachine.nas
-	@ ./nasal -d test/wavecollapse.nas
-	@ ./nasal test/word_collector.nas test/md5compare.nas
-	@ ./nasal -t -d test/ycombinator.nas
-
-NASAL_NEW_AST=\
+NASAL_OBJECT=\
 	nasal_new_err.o\
 	nasal_new_ast.o\
 	ast_visitor.o\
@@ -93,11 +22,11 @@ NASAL_NEW_AST=\
 	nasal_new_main.o
 
 # for test
-nnew: $(NASAL_NEW_AST)
-	$(CXX) $(NASAL_NEW_AST) -O3 -o nnew -ldl
+nasal: $(NASAL_OBJECT)
+	$(CXX) $(NASAL_OBJECT) -O3 -o nasal -ldl
 
-nnew.exe: $(NASAL_NEW_AST)
-	$(CXX) $(NASAL_NEW_AST) -O3 -o nnew.exe
+nasal.exe: $(NASAL_OBJECT)
+	$(CXX) $(NASAL_OBJECT) -O3 -o nasal.exe
 
 nasal_new_main.o: src/nasal_new_main.cpp
 	$(CXX) -std=$(STD) -c -O3 src/nasal_new_main.cpp -fno-exceptions -fPIC -o nasal_new_main.o -I .
@@ -152,4 +81,75 @@ nasal_new_dbg.o: src/nasal_new_dbg.h src/nasal_new_dbg.cpp
 
 .PHONY: nasal_new_clean
 nasal_new_clean:
-	rm $(NASAL_NEW_AST)
\ No newline at end of file
+	rm $(NASAL_OBJECT)
+
+SRC=\
+	main.cpp\
+	nasal_ast.h\
+	nasal_err.h\
+	nasal_builtin.h\
+	nasal_opcode.h\
+	nasal_opt.h\
+	nasal_codegen.h\
+	nasal_gc.h\
+	nasal_import.h\
+	nasal_lexer.h\
+	nasal_parse.h\
+	nasal_vm.h\
+	nasal_dbg.h\
+	nasal.h
+
+nasal_old:$(SRC)
+	$(CXX) -std=$(STD) -O3 main.cpp -o nasal_old -fno-exceptions -ldl -Wshadow -Wall
+
+nasal_old.exe:$(SRC)
+	$(CXX) -std=$(STD) -O3 main.cpp -o nasal_old.exe -fno-exceptions -Wshadow -Wall -static
+
+stable-release:$(SRC)
+	$(CXX) -std=$(STD) -O2 main.cpp -o nasal_old -fno-exceptions -ldl -Wshadow -Wall
+
+stable-release-mingw:$(SRC)
+	$(CXX) -std=$(STD) -O2 main.cpp -o nasal_old.exe -fno-exceptions -Wshadow -Wall -static
+
+clean:
+	@ echo "[clean] nasal" && if [ -e nasal ]; then rm nasal; fi
+	@ echo "[clean] nasal.exe" && if [ -e nasal.exe ]; then rm nasal.exe; fi
+
+test:nasal
+	@ ./nasal -e test/ascii-art.nas
+	@ ./nasal -t -d test/bfs.nas
+	@ ./nasal -t test/bigloop.nas
+	@ ./nasal -t test/bp.nas
+	@ ./nasal -d test/calc.nas
+	@ ./nasal -e test/choice.nas
+	@ ./nasal -e test/class.nas
+	@ ./nasal -t -d test/console3D.nas 20
+	@ ./nasal -e test/coroutine.nas
+	@ ./nasal -t -d test/datalog.nas
+	@ ./nasal -e test/diff.nas
+	@ ./nasal -e test/donuts.nas 15
+	-@ ./nasal -d test/exception.nas
+	@ ./nasal -t -d test/fib.nas
+	@ ./nasal -e test/filesystem.nas
+	@ ./nasal -d test/hexdump.nas
+	@ ./nasal -e test/json.nas
+	@ ./nasal -e test/leetcode1319.nas
+	@ ./nasal -d test/lexer.nas
+	@ ./nasal -d test/life.nas
+	@ ./nasal -t test/loop.nas
+	@ ./nasal -t test/mandelbrot.nas
+	@ ./nasal -t test/md5.nas
+	@ ./nasal -t -d test/md5compare.nas
+	@ ./nasal -d test/module_test.nas
+	@ ./nasal -e test/nasal_test.nas
+	@ ./nasal -t -d test/occupation.nas 2
+	@ ./nasal -t -d test/pi.nas
+	@ ./nasal -t -d test/prime.nas
+	@ ./nasal -e test/qrcode.nas
+	@ ./nasal -t -d test/quick_sort.nas
+	@ ./nasal -e test/scalar.nas hello world
+	@ ./nasal -e test/trait.nas
+	@ ./nasal -t -d test/turingmachine.nas
+	@ ./nasal -d test/wavecollapse.nas
+	@ ./nasal test/word_collector.nas test/md5compare.nas
+	@ ./nasal -t -d test/ycombinator.nas
\ No newline at end of file
diff --git a/module/makefile b/module/makefile
index f3d4148..d95626d 100644
--- a/module/makefile
+++ b/module/makefile
@@ -3,7 +3,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= ../nasal.h ../nasal_gc.h
+used_header= ../src/nasal_new_header.h ../src/nasal_new_gc.h
 
 STD=c++17
 
diff --git a/src/nasal_new_codegen.cpp b/src/nasal_new_codegen.cpp
index abc4207..1e1f370 100644
--- a/src/nasal_new_codegen.cpp
+++ b/src/nasal_new_codegen.cpp
@@ -100,34 +100,34 @@ void codegen::gen(u8 operation_code, u32 num, u32 line) {
 void codegen::num_gen(number_literal* node) {
     f64 num = node->get_number();
     regist_num(num);
-    gen(op_pnum,num_table.at(num), node->get_location().begin_line);
+    gen(op_pnum,num_table.at(num), node->get_line());
 }
 
 void codegen::str_gen(string_literal* node) {
     regist_str(node->get_content());
-    gen(op_pstr, str_table.at(node->get_content()), node->get_location().begin_line);
+    gen(op_pstr, str_table.at(node->get_content()), node->get_line());
 }
 
 void codegen::bool_gen(bool_literal* node) {
     f64 num = node->get_flag()? 1:0;
     regist_num(num);
-    gen(op_pnum, num_table.at(num), node->get_location().begin_line);
+    gen(op_pnum, num_table.at(num), node->get_line());
 }
 
 void codegen::vec_gen(vector_expr* node) {
     for(auto child : node->get_elements()) {
         calc_gen(child);
     }
-    gen(op_newv, node->get_elements().size(), node->get_location().begin_line);
+    gen(op_newv, node->get_elements().size(), node->get_line());
 }
 
 void codegen::hash_gen(hash_expr* node) {
-    gen(op_newh, 0, node->get_location().begin_line);
+    gen(op_newh, 0, node->get_line());
     for(auto child : node->get_members()) {
         calc_gen(child->get_value());
         const auto& field_name = child->get_name();
         regist_str(field_name);
-        gen(op_happ, str_table.at(field_name), child->get_location().begin_line);
+        gen(op_happ, str_table.at(field_name), child->get_line());
     }
 }
 
@@ -167,9 +167,9 @@ void codegen::func_gen(function* node) {
     }
 
     usize newf=code.size();
-    gen(op_newf, 0, node->get_location().begin_line);
+    gen(op_newf, 0, node->get_line());
     usize lsize=code.size();
-    gen(op_intl, 0, node->get_location().begin_line);
+    gen(op_intl, 0, node->get_line());
     
     // add special keyword 'me' into symbol table
     // this symbol is only used in local scope(function's scope)
@@ -188,14 +188,14 @@ void codegen::func_gen(function* node) {
         regist_str(name);
         switch(tmp->get_parameter_type()) {
             case parameter::param_type::normal_parameter:
-                gen(op_para, str_table.at(name), tmp->get_location().begin_line);
+                gen(op_para, str_table.at(name), tmp->get_line());
                 break;
             case parameter::param_type::default_parameter:
                 calc_gen(tmp->get_default_value());
-                gen(op_deft, str_table.at(name), tmp->get_location().begin_line);
+                gen(op_deft, str_table.at(name), tmp->get_line());
                 break;
             case parameter::param_type::dynamic_parameter:
-                gen(op_dyn, str_table.at(name), tmp->get_location().begin_line);
+                gen(op_dyn, str_table.at(name), tmp->get_line());
                 break;
         }
         add_sym(name);
@@ -203,7 +203,7 @@ void codegen::func_gen(function* node) {
 
     code[newf].num = code.size()+1; // entry
     usize jmp_ptr = code.size();
-    gen(op_jmp, 0, node->get_location().begin_line);
+    gen(op_jmp, 0, node->get_line());
 
     auto block = node->get_code_block();
     // search symbols first, must use after loading parameters
@@ -221,8 +221,8 @@ void codegen::func_gen(function* node) {
 
     if (!block->get_expressions().size() ||
         block->get_expressions().back()->get_type()!=expr_type::ast_ret) {
-        gen(op_pnil, 0, block->get_location().begin_line);
-        gen(op_ret, 0, block->get_location().begin_line);
+        gen(op_pnil, 0, block->get_line());
+        gen(op_ret, 0, block->get_line());
     }
     code[jmp_ptr].num = code.size();
 }
@@ -245,7 +245,7 @@ void codegen::call_id(identifier* node) {
     const auto& name = node->get_name();
     for(u32 i = 0; builtin[i].name; ++i) {
         if (builtin[i].name==name) {
-            gen(op_callb, i, node->get_location().begin_line);
+            gen(op_callb, i, node->get_line());
             if (local.empty()) {
                 die("should warp native function in local scope",
                     node->get_location());
@@ -255,15 +255,15 @@ void codegen::call_id(identifier* node) {
     }
     i32 index;
     if ((index=local_find(name))>=0) {
-        gen(op_calll, index, node->get_location().begin_line);
+        gen(op_calll, index, node->get_line());
         return;
     }
     if ((index=upvalue_find(name))>=0) {
-        gen(op_upval, index, node->get_location().begin_line);
+        gen(op_upval, index, node->get_line());
         return;
     }
     if ((index=global_find(name))>=0) {
-        gen(op_callg, index, node->get_location().begin_line);
+        gen(op_callg, index, node->get_line());
         return;
     }
     die("undefined symbol \"" + name + "\"", node->get_location());
@@ -271,7 +271,7 @@ void codegen::call_id(identifier* node) {
 
 void codegen::call_hash_gen(call_hash* node) {
     regist_str(node->get_field());
-    gen(op_callh, str_table.at(node->get_field()), node->get_location().begin_line);
+    gen(op_callh, str_table.at(node->get_field()), node->get_line());
 }
 
 void codegen::call_vec(call_vector* node) {
@@ -279,39 +279,39 @@ void codegen::call_vec(call_vector* node) {
     if (node->get_slices().size()==1 &&
         !node->get_slices()[0]->get_end()) {
         calc_gen(node->get_slices()[0]->get_begin());
-        gen(op_callv, 0, node->get_slices()[0]->get_location().begin_line);
+        gen(op_callv, 0, node->get_slices()[0]->get_line());
         return;
     }
-    gen(op_slcbeg, 0, node->get_location().begin_line);
+    gen(op_slcbeg, 0, node->get_line());
     for(auto tmp : node->get_slices()) {
         if (!tmp->get_end()) {
             calc_gen(tmp->get_begin());
-            gen(op_slc, 0, tmp->get_location().begin_line);
+            gen(op_slc, 0, tmp->get_line());
         } else {
             calc_gen(tmp->get_begin());
             calc_gen(tmp->get_end());
-            gen(op_slc2, 0, tmp->get_location().begin_line);
+            gen(op_slc2, 0, tmp->get_line());
         }
     }
-    gen(op_slcend, 0, node->get_location().begin_line);
+    gen(op_slcend, 0, node->get_line());
 }
 
 void codegen::call_func(call_function* node) {
     if (node->get_argument().size() &&
         node->get_argument()[0]->get_type()==expr_type::ast_pair) {
-        gen(op_newh, 0, node->get_location().begin_line);
+        gen(op_newh, 0, node->get_line());
         for(auto child : node->get_argument()) {
             calc_gen(((hash_pair*)child)->get_value());
             const auto& field_name = ((hash_pair*)child)->get_name();
             regist_str(field_name);
-            gen(op_happ, str_table.at(field_name), child->get_location().begin_line);
+            gen(op_happ, str_table.at(field_name), child->get_line());
         }
-        gen(op_callfh, 0, node->get_location().begin_line);
+        gen(op_callfh, 0, node->get_line());
     } else {
         for(auto child : node->get_argument()) {
             calc_gen(child);
         }
-        gen(op_callfv, node->get_argument().size(), node->get_location().begin_line);
+        gen(op_callfv, node->get_argument().size(), node->get_line());
     }
 }
 
@@ -365,15 +365,15 @@ void codegen::mcall_id(identifier* node) {
     }
     i32 index;
     if ((index=local_find(name))>=0) {
-        gen(op_mcalll, index, node->get_location().begin_line);
+        gen(op_mcalll, index, node->get_line());
         return;
     }
     if ((index=upvalue_find(name))>=0) {
-        gen(op_mupval, index, node->get_location().begin_line);
+        gen(op_mupval, index, node->get_line());
         return;
     }
     if ((index=global_find(name))>=0) {
-        gen(op_mcallg, index, node->get_location().begin_line);
+        gen(op_mcallg, index, node->get_line());
         return;
     }
     die("undefined symbol \"" + name + "\"", node->get_location());
@@ -390,20 +390,20 @@ void codegen::mcall_vec(call_vector* node) {
         return;
     }
     calc_gen(call->get_begin());
-    gen(op_mcallv, 0, node->get_location().begin_line);
+    gen(op_mcallv, 0, node->get_line());
 }
 
 void codegen::mcall_hash(call_hash* node) {
     regist_str(node->get_field());
-    gen(op_mcallh, str_table.at(node->get_field()), node->get_location().begin_line);
+    gen(op_mcallh, str_table.at(node->get_field()), node->get_line());
 }
 
 void codegen::single_def(definition_expr* node) {
     const auto& str = node->get_variable_name()->get_name();
     calc_gen(node->get_value());
     local.empty()?
-        gen(op_loadg, global_find(str), node->get_location().begin_line):
-        gen(op_loadl, local_find(str), node->get_location().begin_line);
+        gen(op_loadg, global_find(str), node->get_line()):
+        gen(op_loadl, local_find(str), node->get_line());
 }
 
 void codegen::multi_def(definition_expr* node) {
@@ -420,19 +420,19 @@ void codegen::multi_def(definition_expr* node) {
             calc_gen(vals[i]);
             const auto& name = identifiers[i]->get_name();
             local.empty()?
-                gen(op_loadg, global_find(name), identifiers[i]->get_location().begin_line):
-                gen(op_loadl, local_find(name), identifiers[i]->get_location().begin_line);
+                gen(op_loadg, global_find(name), identifiers[i]->get_line()):
+                gen(op_loadl, local_find(name), identifiers[i]->get_line());
         }
     } else { // (var a,b,c)=[0,1,2];
         calc_gen(node->get_value());
         for(usize i = 0; i<size; ++i) {
-            gen(op_callvi, i, node->get_value()->get_location().begin_line);
+            gen(op_callvi, i, node->get_value()->get_line());
             const auto& name = identifiers[i]->get_name();
             local.empty()?
-                gen(op_loadg, global_find(name), identifiers[i]->get_location().begin_line):
-                gen(op_loadl, local_find(name), identifiers[i]->get_location().begin_line);
+                gen(op_loadg, global_find(name), identifiers[i]->get_line()):
+                gen(op_loadl, local_find(name), identifiers[i]->get_line());
         }
-        gen(op_pop, 0, node->get_location().begin_line);
+        gen(op_pop, 0, node->get_line());
     }
 }
 
@@ -449,7 +449,7 @@ void codegen::assignment_gen(assignment_expr* node) {
         case assignment_expr::assign_type::equal:
             calc_gen(node->get_right());
             mcall(node->get_left());
-            gen(op_meq, 0, node->get_location().begin_line);
+            gen(op_meq, 0, node->get_line());
             break;
         case assignment_expr::assign_type::add_equal:
             if (node->get_right()->get_type()!=expr_type::ast_num) {
@@ -457,11 +457,11 @@ void codegen::assignment_gen(assignment_expr* node) {
             }
             mcall(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
-                gen(op_addeq, 0, node->get_location().begin_line);
+                gen(op_addeq, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_addeqc, num_table[num], node->get_location().begin_line);
+                gen(op_addeqc, num_table[num], node->get_line());
             }
             break;
         case assignment_expr::assign_type::sub_equal:
@@ -470,11 +470,11 @@ void codegen::assignment_gen(assignment_expr* node) {
             }
             mcall(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
-                gen(op_subeq, 0, node->get_location().begin_line);
+                gen(op_subeq, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_subeqc, num_table[num], node->get_location().begin_line);
+                gen(op_subeqc, num_table[num], node->get_line());
             }
             break;
         case assignment_expr::assign_type::mult_equal:
@@ -483,11 +483,11 @@ void codegen::assignment_gen(assignment_expr* node) {
             }
             mcall(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
-                gen(op_muleq, 0, node->get_location().begin_line);
+                gen(op_muleq, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_muleqc, num_table[num], node->get_location().begin_line);
+                gen(op_muleqc, num_table[num], node->get_line());
             }
             break;
         case assignment_expr::assign_type::div_equal:
@@ -496,11 +496,11 @@ void codegen::assignment_gen(assignment_expr* node) {
             }
             mcall(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
-                gen(op_diveq, 0, node->get_location().begin_line);
+                gen(op_diveq, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_diveqc, num_table[num], node->get_location().begin_line);
+                gen(op_diveqc, num_table[num], node->get_line());
             }
             break;
         case assignment_expr::assign_type::concat_equal:
@@ -509,27 +509,27 @@ void codegen::assignment_gen(assignment_expr* node) {
             }
             mcall(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_str) {
-                gen(op_lnkeq, 0, node->get_location().begin_line);
+                gen(op_lnkeq, 0, node->get_line());
             } else {
                 const auto& str = ((string_literal*)node->get_right())->get_content();
                 regist_str(str);
-                gen(op_lnkeqc, str_table[str], node->get_location().begin_line);
+                gen(op_lnkeqc, str_table[str], node->get_line());
             }
             break;
         case assignment_expr::assign_type::bitwise_and_equal:
             calc_gen(node->get_right());
             mcall(node->get_left());
-            gen(op_btandeq, 0, node->get_location().begin_line);
+            gen(op_btandeq, 0, node->get_line());
             break;
         case assignment_expr::assign_type::bitwise_or_equal:
             calc_gen(node->get_right());
             mcall(node->get_left());
-            gen(op_btoreq, 0, node->get_location().begin_line);
+            gen(op_btoreq, 0, node->get_line());
             break;
         case assignment_expr::assign_type::bitwise_xor_equal:
             calc_gen(node->get_right());
             mcall(node->get_left());
-            gen(op_btxoreq, 0, node->get_location().begin_line);
+            gen(op_btxoreq, 0, node->get_line());
             break;
     }
 }
@@ -553,7 +553,7 @@ void codegen::assign_statement(assignment_expr* node) {
                 if (code.back().op==op_meq) {
                     code.back().num=1;
                 } else {
-                    gen(op_pop, 0, node->get_location().begin_line);
+                    gen(op_pop, 0, node->get_line());
                 }
             }
             break;
@@ -571,7 +571,7 @@ void codegen::assign_statement(assignment_expr* node) {
             } else if (op_addeqc<=code.back().op && code.back().op<=op_lnkeqc) {
                 code.back().op=code.back().op-op_addeqc+op_addecp;
             } else {
-                gen(op_pop, 0, node->get_location().begin_line);
+                gen(op_pop, 0, node->get_line());
             }
             break;
     }
@@ -602,14 +602,14 @@ void codegen::multi_assign_gen(multi_assign* node) {
             } else if (code.back().op==op_mcallg) {
                 code.back().op=op_loadg;
             } else {
-                gen(op_meq, 1, tuple[i]->get_location().begin_line);
+                gen(op_meq, 1, tuple[i]->get_line());
             }
         }
     } else {
         calc_gen(node->get_value());
         auto& tuple = node->get_tuple()->get_elements();
         for(i32 i = 0; i<size; ++i) {
-            gen(op_callvi, i, node->get_value()->get_location().begin_line);
+            gen(op_callvi, i, node->get_value()->get_line());
             // multi assign user loadl and loadg to avoid meq's stack--
             // and this operation changes local and global value directly
             mcall(tuple[i]);
@@ -620,10 +620,10 @@ void codegen::multi_assign_gen(multi_assign* node) {
             } else if (code.back().op==op_mcallg) {
                 code.back().op=op_loadg;
             } else {
-                gen(op_meq, 1, tuple[i]->get_location().begin_line);
+                gen(op_meq, 1, tuple[i]->get_line());
             }
         }
-        gen(op_pop, 0, node->get_location().begin_line);
+        gen(op_pop, 0, node->get_line());
     }
 }
 
@@ -631,25 +631,25 @@ void codegen::cond_gen(condition_expr* node) {
     std::vector<usize> jmp_label;
     calc_gen(node->get_if_statement()->get_condition());
     auto ptr = code.size();
-    gen(op_jf, 0, node->get_if_statement()->get_location().begin_line);
+    gen(op_jf, 0, node->get_if_statement()->get_line());
     block_gen(node->get_if_statement()->get_code_block());
     if (node->get_elsif_stataments().size() ||
         node->get_else_statement()) {
         jmp_label.push_back(code.size());
-        gen(op_jmp, 0, node->get_if_statement()->get_location().begin_line);
+        gen(op_jmp, 0, node->get_if_statement()->get_line());
     }
     code[ptr].num = code.size();
 
     for(auto tmp : node->get_elsif_stataments()) {
         calc_gen(tmp->get_condition());
         ptr = code.size();
-        gen(op_jf, 0, tmp->get_location().begin_line);
+        gen(op_jf, 0, tmp->get_line());
         block_gen(tmp->get_code_block());
         // the last condition doesn't need to jmp
         if (tmp!=node->get_elsif_stataments().back() ||
             node->get_else_statement()) {
             jmp_label.push_back(code.size());
-            gen(op_jmp, 0, tmp->get_location().begin_line);
+            gen(op_jmp, 0, tmp->get_line());
         }
         code[ptr].num=code.size();
     }
@@ -671,13 +671,7 @@ void codegen::loop_gen(expr* node) {
         case expr_type::ast_for:
             for_gen((for_expr*)node); break;
         case expr_type::ast_forei:
-            if (((forei_expr*)node)->get_loop_type()==
-                forei_expr::forei_loop_type::forindex) {
-                forindex_gen((forei_expr*)node);
-            } else {
-                foreach_gen((forei_expr*)node);
-            }
-            break;
+            forei_gen((forei_expr*)node); break;
     }
 }
 
@@ -696,10 +690,10 @@ void codegen::while_gen(while_expr* node) {
     usize loop_ptr = code.size();
     calc_gen(node->get_condition());
     usize condition_ptr = code.size();
-    gen(op_jf, 0, node->get_condition()->get_location().begin_line);
+    gen(op_jf, 0, node->get_condition()->get_line());
 
     block_gen(node->get_code_block());
-    gen(op_jmp, loop_ptr, node->get_code_block()->get_location().begin_line);
+    gen(op_jmp, loop_ptr, node->get_code_block()->get_line());
     code[condition_ptr].num = code.size();
     load_continue_break(code.size()-1, code.size());
 }
@@ -709,22 +703,58 @@ void codegen::for_gen(for_expr* node) {
     usize jmp_place = code.size();
     if (node->get_condition()->get_type()==expr_type::ast_null) {
         regist_num(1);
-        gen(op_pnum, num_table.at(1), node->get_condition()->get_location().begin_line);
+        gen(op_pnum, num_table.at(1), node->get_condition()->get_line());
     } else {
         calc_gen(node->get_condition());
     }
     usize label_exit = code.size();
-    gen(op_jf, 0, node->get_condition()->get_location().begin_line);
+    gen(op_jf, 0, node->get_condition()->get_line());
 
     block_gen(node->get_code_block());
     usize continue_place = code.size();
     expr_gen(node->get_step());
-    gen(op_jmp, jmp_place, node->get_step()->get_location().begin_line);
+    gen(op_jmp, jmp_place, node->get_step()->get_line());
     code[label_exit].num = code.size();
 
     load_continue_break(continue_place, code.size());
 }
 
+void codegen::forei_gen(forei_expr* node) {
+    calc_gen(node->get_value());
+    gen(op_cnt, 0, node->get_value()->get_line());
+    usize ptr = code.size();
+    if (node->get_loop_type()==forei_expr::forei_loop_type::forindex) {
+        gen(op_findex, 0, node->get_line());
+    } else {
+        gen(op_feach, 0, node->get_line());
+    }
+    if (node->get_iterator()->get_name()) { // define a new iterator
+        const auto& str = node->get_iterator()->get_name()->get_name();
+        local.empty()?
+            gen(op_loadg, global_find(str), node->get_iterator()->get_name()->get_line()):
+            gen(op_loadl, local_find(str), node->get_iterator()->get_name()->get_line());
+    } else { // use exist variable as the iterator
+        mcall(node->get_iterator()->get_call());
+        if (code.back().op==op_mcallg) {
+            code.back().op=op_loadg;
+        } else if (code.back().op==op_mcalll) {
+            code.back().op=op_loadl;
+        } else if (code.back().op==op_mupval) {
+            code.back().op=op_loadu;
+        } else {
+            gen(op_meq, 1, node->get_iterator()->get_line());
+        }
+    }
+    ++in_iterloop.top();
+    block_gen(node->get_code_block());
+    --in_iterloop.top();
+    gen(op_jmp, ptr, node->get_line());
+    code[ptr].num=code.size();
+    load_continue_break(code.size()-1, code.size());
+    gen(op_pop, 0, node->get_value()->get_line());// pop vector
+    gen(op_pop, 0, node->get_line());// pop iterator
+}
+
 void codegen::expr_gen(expr* node) {
     switch(node->get_type()) {
         case expr_type::ast_null:break;
@@ -735,112 +765,48 @@ void codegen::expr_gen(expr* node) {
         case expr_type::ast_assign:
             assign_statement((assignment_expr*)node); break;
         case expr_type::ast_nil:case expr_type::ast_num:
-        case expr_type::ast_str:case expr_type::ast_bool:break;
+        case expr_type::ast_str:case expr_type::ast_bool: break;
         case expr_type::ast_vec:case expr_type::ast_hash:
         case expr_type::ast_func:case expr_type::ast_call:
         case expr_type::ast_unary:
         case expr_type::ast_binary:
         case expr_type::ast_ternary:
             calc_gen(node);
-            gen(op_pop, 0, node->get_location().begin_line);
+            gen(op_pop, 0, node->get_line());
             break;
     }
 }
 
-void codegen::forindex_gen(forei_expr* node) {
-    calc_gen(node->get_value());
-    gen(op_cnt, 0, node->get_value()->get_location().begin_line);
-    usize ptr = code.size();
-    gen(op_findex, 0, node->get_location().begin_line);
-    if (node->get_iterator()->get_name()) { // define a new iterator
-        const auto& str = node->get_iterator()->get_name()->get_name();
-        local.empty()?
-            gen(op_loadg, global_find(str), node->get_iterator()->get_name()->get_location().begin_line):
-            gen(op_loadl, local_find(str), node->get_iterator()->get_name()->get_location().begin_line);
-    } else { // use exist variable as the iterator
-        mcall(node->get_iterator()->get_call());
-        if (code.back().op==op_mcallg) {
-            code.back().op=op_loadg;
-        } else if (code.back().op==op_mcalll) {
-            code.back().op=op_loadl;
-        } else if (code.back().op==op_mupval) {
-            code.back().op=op_loadu;
-        } else {
-            gen(op_meq, 1, node->get_iterator()->get_location().begin_line);
-        }
-    }
-    ++in_iterloop.top();
-    block_gen(node->get_code_block());
-    --in_iterloop.top();
-    gen(op_jmp, ptr, node->get_location().begin_line);
-    code[ptr].num=code.size();
-    load_continue_break(code.size()-1, code.size());
-    gen(op_pop, 0, node->get_value()->get_location().begin_line);// pop vector
-    gen(op_pop, 0, node->get_location().begin_line);// pop iterator
-}
-
-void codegen::foreach_gen(forei_expr* node) {
-    calc_gen(node->get_value());
-    gen(op_cnt, 0, node->get_location().begin_line);
-    usize ptr = code.size();
-    gen(op_feach, 0, node->get_location().begin_line);
-    if (node->get_iterator()->get_name()) { // define a new iterator
-        const auto& str = node->get_iterator()->get_name()->get_name();
-        local.empty()?
-            gen(op_loadg, global_find(str), node->get_iterator()->get_name()->get_location().begin_line):
-            gen(op_loadl, local_find(str), node->get_iterator()->get_name()->get_location().begin_line);
-    } else { // use exist variable as the iterator
-        mcall(node->get_iterator()->get_call());
-        if (code.back().op==op_mcallg) {
-            code.back().op=op_loadg;
-        } else if (code.back().op==op_mcalll) {
-            code.back().op=op_loadl;
-        } else if (code.back().op==op_mupval) {
-            code.back().op=op_loadu;
-        } else {
-            gen(op_meq, 1, node->get_iterator()->get_location().begin_line);
-        }
-    }
-    ++in_iterloop.top();
-    block_gen(node->get_code_block());
-    --in_iterloop.top();
-    gen(op_jmp, ptr, node->get_location().begin_line);
-    code[ptr].num=code.size();
-    load_continue_break(code.size()-1, code.size());
-    gen(op_pop, 0, node->get_value()->get_location().begin_line); // pop vector
-    gen(op_pop, 0, node->get_location().begin_line); // pop iterator
-}
-
 void codegen::or_gen(binary_operator* node) {
     calc_gen(node->get_left());
     usize l1 = code.size();
-    gen(op_jt, 0, node->get_left()->get_location().begin_line);
+    gen(op_jt, 0, node->get_left()->get_line());
 
-    gen(op_pop, 0, node->get_left()->get_location().begin_line);
+    gen(op_pop, 0, node->get_left()->get_line());
     calc_gen(node->get_right());
     usize l2=code.size();
-    gen(op_jt, 0, node->get_right()->get_location().begin_line);
+    gen(op_jt, 0, node->get_right()->get_line());
 
-    gen(op_pop, 0, node->get_right()->get_location().begin_line);
-    gen(op_pnil, 0, node->get_right()->get_location().begin_line);
+    gen(op_pop, 0, node->get_right()->get_line());
+    gen(op_pnil, 0, node->get_right()->get_line());
 
     code[l1].num = code[l2].num = code.size();
 }
 
 void codegen::and_gen(binary_operator* node) {
     calc_gen(node->get_left());
-    gen(op_jt, code.size()+2, node->get_left()->get_location().begin_line);
+    gen(op_jt, code.size()+2, node->get_left()->get_line());
 
     usize lfalse = code.size();
-    gen(op_jmp, 0, node->get_left()->get_location().begin_line);
-    gen(op_pop, 0, node->get_right()->get_location().begin_line);// jt jumps here
+    gen(op_jmp, 0, node->get_left()->get_line());
+    gen(op_pop, 0, node->get_right()->get_line());// jt jumps here
 
     calc_gen(node->get_right());
-    gen(op_jt, code.size()+3, node->get_right()->get_location().begin_line);
+    gen(op_jt, code.size()+3, node->get_right()->get_line());
 
     code[lfalse].num = code.size();
-    gen(op_pop, 0, node->get_right()->get_location().begin_line);
-    gen(op_pnil, 0, node->get_right()->get_location().begin_line);
+    gen(op_pop, 0, node->get_right()->get_line());
+    gen(op_pnil, 0, node->get_right()->get_line());
     // jt jumps here
 }
 
@@ -848,11 +814,11 @@ void codegen::unary_gen(unary_operator* node) {
     calc_gen(node->get_value());
     switch(node->get_operator_type()) {
         case unary_operator::unary_type::negative:
-            gen(op_usub, 0, node->get_location().begin_line); break;
+            gen(op_usub, 0, node->get_line()); break;
         case unary_operator::unary_type::logical_not:
-            gen(op_lnot, 0, node->get_location().begin_line); break;
+            gen(op_lnot, 0, node->get_line()); break;
         case unary_operator::unary_type::bitwise_not:
-            gen(op_bnot, 0, node->get_location().begin_line); break;
+            gen(op_bnot, 0, node->get_line()); break;
     }
 }
 
@@ -866,27 +832,27 @@ void codegen::binary_gen(binary_operator* node) {
         case binary_operator::binary_type::cmpeq:
             calc_gen(node->get_left());
             calc_gen(node->get_right());
-            gen(op_eq, 0, node->get_location().begin_line);
+            gen(op_eq, 0, node->get_line());
             return;
         case binary_operator::binary_type::cmpneq:
             calc_gen(node->get_left());
             calc_gen(node->get_right());
-            gen(op_neq, 0, node->get_location().begin_line);
+            gen(op_neq, 0, node->get_line());
             return;
         case binary_operator::binary_type::bitwise_or:
             calc_gen(node->get_left());
             calc_gen(node->get_right());
-            gen(op_btor, 0, node->get_location().begin_line);
+            gen(op_btor, 0, node->get_line());
             return;
         case binary_operator::binary_type::bitwise_xor:
             calc_gen(node->get_left());
             calc_gen(node->get_right());
-            gen(op_btxor, 0, node->get_location().begin_line);
+            gen(op_btxor, 0, node->get_line());
             return;
         case binary_operator::binary_type::bitwise_and:
             calc_gen(node->get_left());
             calc_gen(node->get_right());
-            gen(op_btand, 0, node->get_location().begin_line);
+            gen(op_btand, 0, node->get_line());
             return;
         default: break;
     }
@@ -895,99 +861,99 @@ void codegen::binary_gen(binary_operator* node) {
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
-                gen(op_add, 0, node->get_location().begin_line);
+                gen(op_add, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_addc, num_table.at(num), node->get_location().begin_line);
+                gen(op_addc, num_table.at(num), node->get_line());
             }
             return;
         case binary_operator::binary_type::sub:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
-                gen(op_sub, 0, node->get_location().begin_line);
+                gen(op_sub, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_subc, num_table.at(num), node->get_location().begin_line);
+                gen(op_subc, num_table.at(num), node->get_line());
             }
             return;
         case binary_operator::binary_type::mult:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
-                gen(op_mul, 0, node->get_location().begin_line);
+                gen(op_mul, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_mulc, num_table.at(num), node->get_location().begin_line);
+                gen(op_mulc, num_table.at(num), node->get_line());
             }
             return;
         case binary_operator::binary_type::div:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
-                gen(op_div, 0, node->get_location().begin_line);
+                gen(op_div, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_divc, num_table.at(num), node->get_location().begin_line);
+                gen(op_divc, num_table.at(num), node->get_line());
             }
             return;
         case binary_operator::binary_type::concat:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_str) {
                 calc_gen(node->get_right());
-                gen(op_lnk, 0, node->get_location().begin_line);
+                gen(op_lnk, 0, node->get_line());
             } else {
                 const auto& str = ((string_literal*)node->get_right())->get_content();
                 regist_str(str);
-                gen(op_lnkc, str_table.at(str), node->get_location().begin_line);
+                gen(op_lnkc, str_table.at(str), node->get_line());
             }
             break;
         case binary_operator::binary_type::less:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
-                gen(op_less, 0, node->get_location().begin_line);
+                gen(op_less, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_lessc, num_table.at(num), node->get_location().begin_line);
+                gen(op_lessc, num_table.at(num), node->get_line());
             }
             return;
         case binary_operator::binary_type::leq:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
-                gen(op_leq, 0, node->get_location().begin_line);
+                gen(op_leq, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_leqc, num_table.at(num), node->get_location().begin_line);
+                gen(op_leqc, num_table.at(num), node->get_line());
             }
             return;
         case binary_operator::binary_type::grt:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
-                gen(op_grt, 0, node->get_location().begin_line);
+                gen(op_grt, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_grtc, num_table.at(num), node->get_location().begin_line);
+                gen(op_grtc, num_table.at(num), node->get_line());
             }
             return;
         case binary_operator::binary_type::geq:
             calc_gen(node->get_left());
             if (node->get_right()->get_type()!=expr_type::ast_num) {
                 calc_gen(node->get_right());
-                gen(op_geq, 0, node->get_location().begin_line);
+                gen(op_geq, 0, node->get_line());
             } else {
                 auto num = ((number_literal*)node->get_right())->get_number();
                 regist_num(num);
-                gen(op_geqc, num_table.at(num), node->get_location().begin_line);
+                gen(op_geqc, num_table.at(num), node->get_line());
             }
             return;
     }
@@ -996,10 +962,10 @@ void codegen::binary_gen(binary_operator* node) {
 void codegen::trino_gen(ternary_operator* node) {
     calc_gen(node->get_condition());
     usize lfalse = code.size();
-    gen(op_jf, 0, node->get_condition()->get_location().begin_line);
+    gen(op_jf, 0, node->get_condition()->get_line());
     calc_gen(node->get_left());
     usize lexit = code.size();
-    gen(op_jmp, 0, node->get_left()->get_location().begin_line);
+    gen(op_jmp, 0, node->get_left()->get_line());
     code[lfalse].num = code.size();
     calc_gen(node->get_right());
     code[lexit].num = code.size();
@@ -1008,7 +974,7 @@ void codegen::trino_gen(ternary_operator* node) {
 void codegen::calc_gen(expr* node) {
     switch(node->get_type()) {
         case expr_type::ast_nil:
-            gen(op_pnil, 0, node->get_location().begin_line); break;
+            gen(op_pnil, 0, node->get_line()); break;
         case expr_type::ast_num:
             num_gen((number_literal*)node); break;
         case expr_type::ast_str:
@@ -1050,16 +1016,17 @@ void codegen::block_gen(code_block* node) {
             case expr_type::ast_nil:case expr_type::ast_num:
             case expr_type::ast_str:case expr_type::ast_bool:break;
             case expr_type::ast_file_info:
-                fileindex = ((file_info*)tmp)->get_index(); break; // special node type in main block
+                // special node type in main block
+                fileindex = ((file_info*)tmp)->get_index(); break;
             case expr_type::ast_cond:
                 cond_gen((condition_expr*)tmp); break;
             case expr_type::ast_continue:
                 continue_ptr.front().push_back(code.size());
-                gen(op_jmp, 0, tmp->get_location().begin_line);
+                gen(op_jmp, 0, tmp->get_line());
                 break;
             case expr_type::ast_break:
                 break_ptr.front().push_back(code.size());
-                gen(op_jmp, 0, tmp->get_location().begin_line);
+                gen(op_jmp, 0, tmp->get_line());
                 break;
             case expr_type::ast_while:
             case expr_type::ast_for:
@@ -1082,11 +1049,11 @@ void codegen::block_gen(code_block* node) {
 
 void codegen::ret_gen(return_expr* node) {
     for(u32 i = 0; i<in_iterloop.top(); ++i) {
-        gen(op_pop, 0, node->get_location().begin_line);
-        gen(op_pop, 0, node->get_location().begin_line);
+        gen(op_pop, 0, node->get_line());
+        gen(op_pop, 0, node->get_line());
     }
     calc_gen(node->get_value());
-    gen(op_ret, 0, node->get_location().begin_line);
+    gen(op_ret, 0, node->get_line());
 }
 
 const error& codegen::compile(parse& parse, linker& import) {
@@ -1101,19 +1068,23 @@ const error& codegen::compile(parse& parse, linker& import) {
     // size out of bound check
     if (num_res.size()>0xffffff) {
         err.load(file[0]); // load main execute file
-        err.err("code", "too many constant numbers: "+std::to_string(num_res.size()));
+        err.err("code",
+            "too many constant numbers: " + std::to_string(num_res.size()));
     }
     if (str_res.size()>0xffffff) {
         err.load(file[0]); // load main execute file
-        err.err("code", "too many constant strings: "+std::to_string(str_res.size()));
+        err.err("code",
+            "too many constant strings: " + std::to_string(str_res.size()));
     }
     if (global.size()>=STACK_DEPTH) {
         err.load(file[0]); // load main execute file
-        err.err("code", "too many global variants: "+std::to_string(global.size()));
+        err.err("code",
+            "too many global variants: " + std::to_string(global.size()));
     }
     if (code.size()>0xffffff) {
         err.load(file[0]); // load main execute file
-        err.err("code", "bytecode size overflow: "+std::to_string(code.size()));
+        err.err("code",
+            "bytecode size overflow: " + std::to_string(code.size()));
     }
     return err;
 }
@@ -1125,12 +1096,12 @@ void codegen::print() {
 
     // print const numbers
     for(auto num : num_res) {
-        std::cout<<"  .number "<<num<<"\n";
+        std::cout << "  .number " << num << "\n";
     }
 
     // print const strings
     for(const auto& str : str_res) {
-        std::cout<<"  .symbol \""<<rawstr(str)<<"\"\n";
+        std::cout << "  .symbol \"" << rawstr(str) << "\"\n";
     }
 
     // print code
@@ -1140,7 +1111,7 @@ void codegen::print() {
         // print opcode index, opcode name, opcode immediate number
         const auto& c = code[i];
         if (!festk.empty() && i==festk.top()) {
-            std::cout<<std::hex<<"<0x"<<fbstk.top()<<std::dec<<">;\n";
+            std::cout << std::hex << "<0x" << fbstk.top() << std::dec << ">;\n";
             // avoid two empty lines
             if (c.op!=op_newf) {
                 std::cout<<"\n";
@@ -1151,7 +1122,7 @@ void codegen::print() {
 
         // get function begin index and end index
         if (c.op==op_newf) {
-            std::cout<<std::hex<<"\nfunc <0x"<<i<<std::dec<<">:\n";
+            std::cout << std::hex << "\nfunc <0x" << i << std::dec << ">:\n";
             for(u32 j = i; j<code.size(); ++j) {
                 if (code[j].op==op_jmp) {
                     fbstk.push(i);
@@ -1162,6 +1133,6 @@ void codegen::print() {
         }
 
         // output bytecode
-        std::cout<<"  "<<codestream(c,i)<<"\n";
+        std::cout << "  " << codestream(c,i) << "\n";
     }
 }
diff --git a/src/nasal_new_codegen.h b/src/nasal_new_codegen.h
index f21bd16..a051e6a 100644
--- a/src/nasal_new_codegen.h
+++ b/src/nasal_new_codegen.h
@@ -83,8 +83,7 @@ private:
     void while_gen(while_expr*);
     void for_gen(for_expr*);
     void expr_gen(expr*);
-    void forindex_gen(forei_expr*);
-    void foreach_gen(forei_expr*);
+    void forei_gen(forei_expr*);
     void or_gen(binary_operator*);
     void and_gen(binary_operator*);
     void unary_gen(unary_operator*);
diff --git a/src/nasal_new_header.h b/src/nasal_new_header.h
index 7adc074..f2247a7 100644
--- a/src/nasal_new_header.h
+++ b/src/nasal_new_header.h
@@ -1,7 +1,7 @@
 #pragma once
 
 #ifndef __nasver
-#define __nasver "10.1"
+#define __nasver "11.0"
 #endif
 
 #include <cstdint>
diff --git a/src/nasal_new_main.cpp b/src/nasal_new_main.cpp
index d397166..c0de3e7 100644
--- a/src/nasal_new_main.cpp
+++ b/src/nasal_new_main.cpp
@@ -14,6 +14,7 @@
 
 #include <unordered_map>
 #include <thread>
+#include <cstdlib>
 
 const u32 VM_RAW_AST = 1;
 const u32 VM_AST     = 1<<1;
@@ -25,53 +26,67 @@ const u32 VM_DEBUG   = 1<<6;
 
 std::ostream& help(std::ostream& out) {
     out
-    <<"     ,--#-,\n"
-    <<"<3  / \\____\\  <3\n"
-    <<"    |_|__A_|\n"
+    << "     ,--#-,\n"
+    << "<3  / \\____\\  <3\n"
+    << "    |_|__A_|\n"
 #ifdef _WIN32
-    <<"use command <chcp 65001> to use unicode.\n"
+    << "use command <chcp 65001> to use unicode.\n"
 #endif
-    <<"\nnasal <option>\n"
-    <<"option:\n"
-    <<"   -h,   --help    | get help.\n"
-    <<"\nnasal [option] <file> [argv]\n"
-    <<"option:\n"
-    <<"   -a,   --ast     | view ast (after link/optimize process).\n"
-    <<"         --raw-ast | view ast without after-processing.\n"
-    <<"   -c,   --code    | view bytecode.\n"
-    <<"   -e,   --exec    | execute.\n"
-    <<"   -t,   --time    | show execute time.\n"
-    <<"   -d,   --detail  | get detail info.\n"
-    <<"   -dbg, --debug   | debug mode.\n"
-    <<"file:\n"
-    <<"   <filename>      | execute file.\n"
-    <<"argv:\n"
-    <<"   <args>          | cmd arguments used in program.\n";
+    << "\nnasal <option>\n"
+    << "option:\n"
+    << "   -h,   --help    | get help.\n"
+    << "   -v,   --version | get version.\n"
+    << "\nnasal [option] <file> [argv]\n"
+    << "option:\n"
+    << "   -a,   --ast     | view ast after link/optimize process.\n"
+    << "         --raw-ast | view ast without after-processing.\n"
+    << "   -c,   --code    | view generated bytecode.\n"
+    << "   -e,   --exec    | execute directly.\n"
+    << "   -t,   --time    | show execute time.\n"
+    << "   -d,   --detail  | get detail info.\n"
+    << "   -dbg, --debug   | debug mode.\n"
+    << "file:\n"
+    << "   <filename>      | execute file.\n"
+    << "argv:\n"
+    << "   <args>          | cmd arguments used in program.\n";
     return out;
 }
 
 std::ostream& logo(std::ostream& out) {
     out
-    <<"       __                _\n"
-    <<"    /\\ \\ \\__ _ ___  __ _| |\n"
-    <<"   /  \\/ / _` / __|/ _` | |\n"
-    <<"  / /\\  / (_| \\__ \\ (_| | |\n"
-    <<"  \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
-    <<"ver  : "<<__nasver<<" ("<<__DATE__<<" "<<__TIME__<<")\n"
-    <<"std  : c++ "<<__cplusplus<<"\n"
-    <<"core : "<<std::thread::hardware_concurrency()<<" core(s)\n"
-    <<"repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
-    <<"repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
-    <<"wiki : https://wiki.flightgear.org/Nasal_scripting_language\n"
-    <<"input <nasal -h> to get help .\n";
+    << "       __                _\n"
+    << "    /\\ \\ \\__ _ ___  __ _| |\n"
+    << "   /  \\/ / _` / __|/ _` | |\n"
+    << "  / /\\  / (_| \\__ \\ (_| | |\n"
+    << "  \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
+    << "ver  : " << __nasver << " (" << __DATE__ << " " << __TIME__ << ")\n"
+    << "std  : c++ " << __cplusplus << "\n"
+    << "core : " << std::thread::hardware_concurrency() << " core(s)\n"
+    << "repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
+    << "repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
+    << "wiki : https://wiki.flightgear.org/Nasal_scripting_language\n"
+    << "input <nasal -h> to get help .\n";
     return out;
 }
 
+std::ostream& version(std::ostream& out) {
+    std::srand(std::time(nullptr));
+    f64 num = 0;
+    for(u32 i = 0; i<5; ++i) {
+        num = (num+rand())*(1.0/(RAND_MAX+1.0));
+    }
+    if (num<0.01) {
+        parse::easter_egg();
+    }
+    out << "version " << __nasver;
+    out << " (" << __DATE__ << " " << __TIME__ << ")\n";
+}
+
 [[noreturn]]
 void err() {
     std::cerr
-    <<"invalid argument(s).\n"
-    <<"use <nasal -h> to get help.\n";
+    << "invalid argument(s).\n"
+    << "use <nasal -h> to get help.\n";
     std::exit(1);
 }
 
@@ -80,8 +95,8 @@ void execute(
     const std::vector<std::string>& argv,
     const u32 cmd) {
 
-    using clk=std::chrono::high_resolution_clock;
-    const auto den=clk::duration::period::den;
+    using clk = std::chrono::high_resolution_clock;
+    const auto den = clk::duration::period::den;
 
     error   err;
     lexer   lex(err);
@@ -131,14 +146,14 @@ void execute(
     // get running time
     if (cmd&VM_TIME) {
         f64 tm=(clk::now()-start).count()*1.0/den;
-        std::clog<<"process exited after "<<tm<<"s.\n\n";
+        std::clog << "process exited after " << tm << "s.\n\n";
     }
 }
 
 i32 main(i32 argc, const char* argv[]) {
     // output version info
     if (argc<=1) {
-        std::clog<<logo;
+        std::clog << logo;
         return 0;
     }
 
@@ -146,7 +161,9 @@ i32 main(i32 argc, const char* argv[]) {
     if (argc==2) {
         std::string s(argv[1]);
         if (s=="-h" || s=="--help") {
-            std::clog<<help;
+            std::clog << help;
+        } else if (s=="-v" || s=="--version") {
+            std::clog << version;
         } else if (s[0]!='-') {
             execute(s, {}, VM_EXEC);
         } else {
@@ -171,14 +188,14 @@ i32 main(i32 argc, const char* argv[]) {
         {"--debug", VM_DEBUG},
         {"-dbg", VM_DEBUG}
     };
-    u32 cmd=0;
-    std::string filename="";
+    u32 cmd = 0;
+    std::string filename = "";
     std::vector<std::string> vm_argv;
-    for(i32 i=1; i<argc; ++i) {
+    for(i32 i = 1; i<argc; ++i) {
         if (cmdlst.count(argv[i])) {
-            cmd|=cmdlst.at(argv[i]);
+            cmd |= cmdlst.at(argv[i]);
         } else if (!filename.length()) {
-            filename=argv[i];
+            filename = argv[i];
         } else {
             vm_argv.push_back(argv[i]);
         }
@@ -186,6 +203,6 @@ i32 main(i32 argc, const char* argv[]) {
     if (!filename.length()) {
         err();
     }
-    execute(filename, vm_argv, cmd?cmd:VM_EXEC);
+    execute(filename, vm_argv, cmd? cmd:VM_EXEC);
     return 0;
 }
\ No newline at end of file
diff --git a/src/nasal_new_parse.cpp b/src/nasal_new_parse.cpp
index e83a6a8..11b37ae 100644
--- a/src/nasal_new_parse.cpp
+++ b/src/nasal_new_parse.cpp
@@ -20,7 +20,7 @@ const error& parse::compile(const lexer& lexer) {
     return err;
 }
 
-void parse::easter_egg() const {
+void parse::easter_egg() {
     std::clog
     << "              _,,,_                                          \n"
     << "            .'     `'.                                       \n"
diff --git a/src/nasal_new_parse.h b/src/nasal_new_parse.h
index bcef3fb..100bcc7 100644
--- a/src/nasal_new_parse.h
+++ b/src/nasal_new_parse.h
@@ -157,5 +157,5 @@ public:
         }
     }
     const error& compile(const lexer&);
-    void easter_egg() const;
+    static void easter_egg();
 };
\ No newline at end of file

From ba6b7cd05c875639d37558eca2ab56e6f707b39f Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sun, 2 Jul 2023 16:17:56 +0800
Subject: [PATCH 29/34] :sparkles: change dir stl -> std

---
 nasal_import.h               |  4 ++--
 src/nasal_new_codegen.cpp    | 37 +++++++++++++++++++++++-------------
 src/nasal_new_codegen.h      |  6 +++---
 src/nasal_new_import.cpp     | 15 ++++++++++-----
 src/nasal_new_import.h       |  2 +-
 src/nasal_new_main.cpp       |  1 +
 {stl => std}/csv.nas         |  0
 {stl => std}/fg_env.nas      |  0
 {stl => std}/file.nas        |  0
 {stl => std}/json.nas        |  0
 {stl => std}/lib.nas         |  0
 {stl => std}/list.nas        |  0
 {stl => std}/log.nas         |  0
 {stl => std}/mat.nas         |  0
 {stl => std}/module.nas      |  0
 {stl => std}/padding.nas     |  0
 {stl => std}/process_bar.nas |  0
 {stl => std}/queue.nas       |  0
 {stl => std}/result.nas      |  0
 {stl => std}/sort.nas        |  0
 {stl => std}/stack.nas       |  0
 {stl => std}/string.nas      |  0
 test/ascii-art.nas           |  4 ++--
 test/auto_crash.nas          |  2 +-
 test/bfs.nas                 |  2 +-
 test/bp.nas                  |  2 +-
 test/calc.nas                | 10 +++++-----
 test/coroutine.nas           |  4 ++--
 test/datalog.nas             |  6 +++---
 test/json.nas                |  4 ++--
 test/jsonrpc.nas             |  2 +-
 test/lexer.nas               |  2 +-
 test/life.nas                |  2 +-
 test/md5compare.nas          |  8 ++++----
 test/occupation.nas          |  2 +-
 test/ppmgen.nas              |  2 +-
 test/quick_sort.nas          |  2 +-
 test/word_collector.nas      |  2 +-
 38 files changed, 69 insertions(+), 52 deletions(-)
 rename {stl => std}/csv.nas (100%)
 rename {stl => std}/fg_env.nas (100%)
 rename {stl => std}/file.nas (100%)
 rename {stl => std}/json.nas (100%)
 rename {stl => std}/lib.nas (100%)
 rename {stl => std}/list.nas (100%)
 rename {stl => std}/log.nas (100%)
 rename {stl => std}/mat.nas (100%)
 rename {stl => std}/module.nas (100%)
 rename {stl => std}/padding.nas (100%)
 rename {stl => std}/process_bar.nas (100%)
 rename {stl => std}/queue.nas (100%)
 rename {stl => std}/result.nas (100%)
 rename {stl => std}/sort.nas (100%)
 rename {stl => std}/stack.nas (100%)
 rename {stl => std}/string.nas (100%)

diff --git a/nasal_import.h b/nasal_import.h
index 08d8730..984fcf8 100644
--- a/nasal_import.h
+++ b/nasal_import.h
@@ -86,7 +86,7 @@ string linker::findf(const string& fname) {
 
     // we will find lib.nas in nasal std directory
     if (fname=="lib.nas") {
-        return is_windows()? findf("stl\\lib.nas"):findf("stl/lib.nas");
+        return is_windows()? findf("std\\lib.nas"):findf("std/lib.nas");
     }
     if (!show_path) {
         err.err("link", "cannot find file <"+fname+">");
@@ -105,7 +105,7 @@ bool linker::imptchk(const ast& node) {
 /*
     call
     |_id:import
-    |_callh:stl
+    |_callh:std
     |_callh:file
 */
     if (node.type()==ast_call && node[0].str()=="import" && node.size()>=2 && node[1].type()==ast_callh) {
diff --git a/src/nasal_new_codegen.cpp b/src/nasal_new_codegen.cpp
index 1e1f370..a2f7065 100644
--- a/src/nasal_new_codegen.cpp
+++ b/src/nasal_new_codegen.cpp
@@ -237,6 +237,7 @@ void codegen::call_gen(call_expr* node) {
             case expr_type::ast_callh: call_hash_gen((call_hash*)i); break;
             case expr_type::ast_callv: call_vec((call_vector*)i); break;
             case expr_type::ast_callf: call_func((call_function*)i); break;
+            default: break;
         }
     }
 }
@@ -341,6 +342,7 @@ void codegen::mcall(expr* node) {
             case expr_type::ast_callh: call_hash_gen((call_hash*)tmp); break;
             case expr_type::ast_callv: call_vec((call_vector*)tmp); break;
             case expr_type::ast_callf: call_func((call_function*)tmp); break;
+            default: break;
         }
     }
     auto tmp = call_node->get_calls().back();
@@ -444,7 +446,7 @@ void codegen::def_gen(definition_expr* node) {
     node->get_variable_name()? single_def(node):multi_def(node);
 }
 
-void codegen::assignment_gen(assignment_expr* node) {
+void codegen::assignment_expression(assignment_expr* node) {
     switch(node->get_assignment_type()) {
         case assignment_expr::assign_type::equal:
             calc_gen(node->get_right());
@@ -534,7 +536,7 @@ void codegen::assignment_gen(assignment_expr* node) {
     }
 }
 
-void codegen::assign_statement(assignment_expr* node) {
+void codegen::assignment_statement(assignment_expr* node) {
     switch(node->get_assignment_type()) {
         case assignment_expr::assign_type::equal:
             if (node->get_left()->get_type()==expr_type::ast_id) {
@@ -672,6 +674,7 @@ void codegen::loop_gen(expr* node) {
             for_gen((for_expr*)node); break;
         case expr_type::ast_forei:
             forei_gen((forei_expr*)node); break;
+        default: break;
     }
 }
 
@@ -699,7 +702,7 @@ void codegen::while_gen(while_expr* node) {
 }
 
 void codegen::for_gen(for_expr* node) {
-    expr_gen(node->get_initial());
+    statement_generation(node->get_initial());
     usize jmp_place = code.size();
     if (node->get_condition()->get_type()==expr_type::ast_null) {
         regist_num(1);
@@ -712,7 +715,7 @@ void codegen::for_gen(for_expr* node) {
 
     block_gen(node->get_code_block());
     usize continue_place = code.size();
-    expr_gen(node->get_step());
+    statement_generation(node->get_step());
     gen(op_jmp, jmp_place, node->get_step()->get_line());
     code[label_exit].num = code.size();
 
@@ -755,7 +758,7 @@ void codegen::forei_gen(forei_expr* node) {
     gen(op_pop, 0, node->get_line());// pop iterator
 }
 
-void codegen::expr_gen(expr* node) {
+void codegen::statement_generation(expr* node) {
     switch(node->get_type()) {
         case expr_type::ast_null:break;
         case expr_type::ast_def:
@@ -763,17 +766,20 @@ void codegen::expr_gen(expr* node) {
         case expr_type::ast_multi_assign:
             multi_assign_gen((multi_assign*)node); break;
         case expr_type::ast_assign:
-            assign_statement((assignment_expr*)node); break;
+            assignment_statement((assignment_expr*)node); break;
         case expr_type::ast_nil:case expr_type::ast_num:
         case expr_type::ast_str:case expr_type::ast_bool: break;
-        case expr_type::ast_vec:case expr_type::ast_hash:
-        case expr_type::ast_func:case expr_type::ast_call:
+        case expr_type::ast_vec:
+        case expr_type::ast_hash:
+        case expr_type::ast_func:
+        case expr_type::ast_call:
         case expr_type::ast_unary:
         case expr_type::ast_binary:
         case expr_type::ast_ternary:
             calc_gen(node);
             gen(op_pop, 0, node->get_line());
             break;
+        default: break;
     }
 }
 
@@ -956,6 +962,7 @@ void codegen::binary_gen(binary_operator* node) {
                 gen(op_geqc, num_table.at(num), node->get_line());
             }
             return;
+        default: break;
     }
 }
 
@@ -992,7 +999,7 @@ void codegen::calc_gen(expr* node) {
         case expr_type::ast_call:
             call_gen((call_expr*)node); break;
         case expr_type::ast_assign:
-            assignment_gen((assignment_expr*)node); break;
+            assignment_expression((assignment_expr*)node); break;
         case expr_type::ast_ternary:
             trino_gen((ternary_operator*)node); break;
         case expr_type::ast_unary:
@@ -1004,6 +1011,7 @@ void codegen::calc_gen(expr* node) {
             single_def((definition_expr*)node);
             call_id(((definition_expr*)node)->get_variable_name());
             break;
+        default: break;
     }
 }
 
@@ -1032,17 +1040,20 @@ void codegen::block_gen(code_block* node) {
             case expr_type::ast_for:
             case expr_type::ast_forei:
                 loop_gen(tmp); break;
-            case expr_type::ast_binary:
-            case expr_type::ast_vec:case expr_type::ast_hash:
-            case expr_type::ast_func:case expr_type::ast_call:
+            case expr_type::ast_vec:
+            case expr_type::ast_hash:
+            case expr_type::ast_func:
+            case expr_type::ast_call:
             case expr_type::ast_unary:
+            case expr_type::ast_binary:
             case expr_type::ast_ternary:
             case expr_type::ast_def:
             case expr_type::ast_assign:
             case expr_type::ast_multi_assign:
-                expr_gen(tmp); break;
+                statement_generation(tmp); break;
             case expr_type::ast_ret:
                 ret_gen((return_expr*)tmp); break;
+            default: break;
         }
     }
 }
diff --git a/src/nasal_new_codegen.h b/src/nasal_new_codegen.h
index a051e6a..8ef1e7f 100644
--- a/src/nasal_new_codegen.h
+++ b/src/nasal_new_codegen.h
@@ -74,16 +74,16 @@ private:
     void multi_def(definition_expr*);
     void single_def(definition_expr*);
     void def_gen(definition_expr*);
-    void assignment_gen(assignment_expr*);
-    void assign_statement(assignment_expr*);
+    void assignment_expression(assignment_expr*);
+    void assignment_statement(assignment_expr*);
     void multi_assign_gen(multi_assign*);
     void cond_gen(condition_expr*);
     void loop_gen(expr*);
     void load_continue_break(i32, i32);
     void while_gen(while_expr*);
     void for_gen(for_expr*);
-    void expr_gen(expr*);
     void forei_gen(forei_expr*);
+    void statement_generation(expr*);
     void or_gen(binary_operator*);
     void and_gen(binary_operator*);
     void unary_gen(unary_operator*);
diff --git a/src/nasal_new_import.cpp b/src/nasal_new_import.cpp
index da52eb2..00abaff 100644
--- a/src/nasal_new_import.cpp
+++ b/src/nasal_new_import.cpp
@@ -30,7 +30,8 @@ std::string linker::get_path(call_expr* node) {
     return fpath + ".nas";
 }
 
-std::string linker::find_file(const std::string& filename) {
+std::string linker::find_file(
+    const std::string& filename, const span& location) {
     // first add file name itself into the file path
     std::vector<std::string> fpath = {filename};
 
@@ -48,9 +49,12 @@ std::string linker::find_file(const std::string& filename) {
 
     // we will find lib.nas in nasal std directory
     if (filename=="lib.nas") {
-        return is_windows()? find_file("stl\\lib.nas"):find_file("stl/lib.nas");
+        return is_windows()?
+            find_file("std\\lib.nas", location):
+            find_file("std/lib.nas", location);
     }
     if (!show_path) {
+        err.load(location.file);
         err.err("link", "cannot find file <" + filename + ">");
         return "";
     }
@@ -58,6 +62,7 @@ std::string linker::find_file(const std::string& filename) {
     for(const auto& i : fpath) {
         paths += "  " + i + "\n";
     }
+    err.load(location.file);
     err.err("link", "cannot find file <" + filename + "> in these paths:\n" + paths);
     return "";
 }
@@ -66,7 +71,7 @@ bool linker::import_check(expr* node) {
 /*
     call
     |_id:import
-    |_callh:stl
+    |_callh:std
     |_callh:file
 */
     if (node->get_type()!=expr_type::ast_call) {
@@ -149,7 +154,7 @@ code_block* linker::import_regular_file(call_expr* node) {
     node->set_first(new nil_expr(location));
 
     // avoid infinite loading loop
-    filename = find_file(filename);
+    filename = find_file(filename, node->get_location());
     if (!filename.length() || exist(filename)) {
         return new code_block({0, 0, 0, 0, filename});
     }
@@ -166,7 +171,7 @@ code_block* linker::import_regular_file(call_expr* node) {
 code_block* linker::import_nasal_lib() {
     lexer lex(err);
     parse par(err);
-    auto filename = find_file("lib.nas");
+    auto filename = find_file("lib.nas", {0, 0, 0, 0, files[0]});
     if (!filename.length()) {
         return new code_block({0, 0, 0, 0, filename});
     }
diff --git a/src/nasal_new_import.h b/src/nasal_new_import.h
index 09d12b6..73378e5 100644
--- a/src/nasal_new_import.h
+++ b/src/nasal_new_import.h
@@ -29,7 +29,7 @@ private:
     bool exist(const std::string&);
     void link(code_block*, code_block*);
     std::string get_path(call_expr*);
-    std::string find_file(const std::string&);
+    std::string find_file(const std::string&, const span&);
     code_block* import_regular_file(call_expr*);
     code_block* import_nasal_lib();
     code_block* load(code_block*, u16);
diff --git a/src/nasal_new_main.cpp b/src/nasal_new_main.cpp
index c0de3e7..ae6efff 100644
--- a/src/nasal_new_main.cpp
+++ b/src/nasal_new_main.cpp
@@ -80,6 +80,7 @@ std::ostream& version(std::ostream& out) {
     }
     out << "version " << __nasver;
     out << " (" << __DATE__ << " " << __TIME__ << ")\n";
+    return out;
 }
 
 [[noreturn]]
diff --git a/stl/csv.nas b/std/csv.nas
similarity index 100%
rename from stl/csv.nas
rename to std/csv.nas
diff --git a/stl/fg_env.nas b/std/fg_env.nas
similarity index 100%
rename from stl/fg_env.nas
rename to std/fg_env.nas
diff --git a/stl/file.nas b/std/file.nas
similarity index 100%
rename from stl/file.nas
rename to std/file.nas
diff --git a/stl/json.nas b/std/json.nas
similarity index 100%
rename from stl/json.nas
rename to std/json.nas
diff --git a/stl/lib.nas b/std/lib.nas
similarity index 100%
rename from stl/lib.nas
rename to std/lib.nas
diff --git a/stl/list.nas b/std/list.nas
similarity index 100%
rename from stl/list.nas
rename to std/list.nas
diff --git a/stl/log.nas b/std/log.nas
similarity index 100%
rename from stl/log.nas
rename to std/log.nas
diff --git a/stl/mat.nas b/std/mat.nas
similarity index 100%
rename from stl/mat.nas
rename to std/mat.nas
diff --git a/stl/module.nas b/std/module.nas
similarity index 100%
rename from stl/module.nas
rename to std/module.nas
diff --git a/stl/padding.nas b/std/padding.nas
similarity index 100%
rename from stl/padding.nas
rename to std/padding.nas
diff --git a/stl/process_bar.nas b/std/process_bar.nas
similarity index 100%
rename from stl/process_bar.nas
rename to std/process_bar.nas
diff --git a/stl/queue.nas b/std/queue.nas
similarity index 100%
rename from stl/queue.nas
rename to std/queue.nas
diff --git a/stl/result.nas b/std/result.nas
similarity index 100%
rename from stl/result.nas
rename to std/result.nas
diff --git a/stl/sort.nas b/std/sort.nas
similarity index 100%
rename from stl/sort.nas
rename to std/sort.nas
diff --git a/stl/stack.nas b/std/stack.nas
similarity index 100%
rename from stl/stack.nas
rename to std/stack.nas
diff --git a/stl/string.nas b/std/string.nas
similarity index 100%
rename from stl/string.nas
rename to std/string.nas
diff --git a/test/ascii-art.nas b/test/ascii-art.nas
index e1cf805..08c29fd 100644
--- a/test/ascii-art.nas
+++ b/test/ascii-art.nas
@@ -1,5 +1,5 @@
-import.stl.padding;
-import.stl.process_bar;
+import.std.padding;
+import.std.process_bar;
 
 var char_ttf=[
     ["    ","    ","    ","    ","    ","    "],
diff --git a/test/auto_crash.nas b/test/auto_crash.nas
index 2ab0e72..cd5dce7 100644
--- a/test/auto_crash.nas
+++ b/test/auto_crash.nas
@@ -1,5 +1,5 @@
 # Road check and auto pilot by ValKmjolnir
-import.stl.fg_env;
+import.std.fg_env;
 
 var dt=0.01;
 var intergral=0;
diff --git a/test/bfs.nas b/test/bfs.nas
index b210665..dffce5b 100644
--- a/test/bfs.nas
+++ b/test/bfs.nas
@@ -1,4 +1,4 @@
-import.stl.queue;
+import.std.queue;
 
 rand(time(0));
 var pixel=[' ','#','.','*'];
diff --git a/test/bp.nas b/test/bp.nas
index 47b1438..1218a2d 100644
--- a/test/bp.nas
+++ b/test/bp.nas
@@ -1,4 +1,4 @@
-import.stl.mat;
+import.std.mat;
 
 rand(time(0));
 
diff --git a/test/calc.nas b/test/calc.nas
index c322450..a14692e 100644
--- a/test/calc.nas
+++ b/test/calc.nas
@@ -1,11 +1,11 @@
-import.stl.padding;
-import.stl.file;
-import.stl.sort;
+import.std.padding;
+import.std.file;
+import.std.sort;
 
 var source=find_all_files_with_extension(".","cpp","h");
 sort(source,func(a,b){return cmp(a,b)<0});
 
-var lib=find_all_files_with_extension("./stl","nas");
+var lib=find_all_files_with_extension("./std","nas");
 sort(lib,func(a,b){return cmp(a,b)<0});
 
 var testfile=find_all_files_with_extension("./test","nas");
@@ -79,7 +79,7 @@ var calc=func(codetype,files,path=""){
 }
 
 var all=calc("source code:",source)
-    +calc("lib:",lib,"stl/")
+    +calc("lib:",lib,"std/")
     +calc("test file:",testfile,"test/")
     +calc("module:",module,"module/");
 println(rightpad("total:",padding_length),'|',leftpad(str(all),6),' kb   |');
\ No newline at end of file
diff --git a/test/coroutine.nas b/test/coroutine.nas
index 20e1732..0e2e8b9 100644
--- a/test/coroutine.nas
+++ b/test/coroutine.nas
@@ -1,7 +1,7 @@
 # coroutine.nas by ValKmjolnir
 # 2022/5/19
-import.stl.process_bar;
-import.stl.padding;
+import.std.process_bar;
+import.std.padding;
 
 if(os.platform()=="windows"){
     system("chcp 65001");
diff --git a/test/datalog.nas b/test/datalog.nas
index 2c5560c..31af9ea 100644
--- a/test/datalog.nas
+++ b/test/datalog.nas
@@ -1,6 +1,6 @@
-import.stl.sort;
-import.stl.padding;
-import.stl.process_bar;
+import.std.sort;
+import.std.padding;
+import.std.process_bar;
 
 var mess=func(vec) {
     srand();
diff --git a/test/json.nas b/test/json.nas
index 990a255..5355d92 100644
--- a/test/json.nas
+++ b/test/json.nas
@@ -1,5 +1,5 @@
-import.stl.json;
-import.stl.process_bar;
+import.std.json;
+import.std.process_bar;
 
 var ss=JSON.stringify({
     vec:[0,1,2],
diff --git a/test/jsonrpc.nas b/test/jsonrpc.nas
index d4f5e0d..37ef20e 100644
--- a/test/jsonrpc.nas
+++ b/test/jsonrpc.nas
@@ -1,5 +1,5 @@
 import.module.libsock;
-import.stl.json;
+import.std.json;
 
 var gettime=func(){
     return split(" ",os.time())[1];
diff --git a/test/lexer.nas b/test/lexer.nas
index c8410a6..561eb57 100644
--- a/test/lexer.nas
+++ b/test/lexer.nas
@@ -172,7 +172,7 @@ var lexer=func(file)
     };
 }
 
-var lex=lexer("stl/fg_env.nas");
+var lex=lexer("std/fg_env.nas");
 lex.compile();
 foreach(var tok;lex.get_token())
     print('(',tok.line,' | ',tok.token,')\n');
\ No newline at end of file
diff --git a/test/life.nas b/test/life.nas
index bffbf7a..3978352 100644
--- a/test/life.nas
+++ b/test/life.nas
@@ -1,4 +1,4 @@
-import.stl.process_bar;
+import.std.process_bar;
 
 var new_map=func(width,height){
     var tmp=[];
diff --git a/test/md5compare.nas b/test/md5compare.nas
index 8f980d5..a6e9566 100644
--- a/test/md5compare.nas
+++ b/test/md5compare.nas
@@ -1,6 +1,6 @@
 import.test.md5;
-import.stl.process_bar;
-import.stl.file;
+import.std.process_bar;
+import.std.file;
 srand();
 
 var compare=func() {
@@ -48,8 +48,8 @@ var filechecksum=func(){
     foreach(var p;find_all_files_with_extension("./test","nas")) {
         append(files,"./test/"~p);
     }
-    foreach(var p;find_all_files_with_extension("./stl","nas")) {
-        append(files,"./stl/"~p);
+    foreach(var p;find_all_files_with_extension("./std","nas")) {
+        append(files,"./std/"~p);
     }
     foreach(var p;find_all_files_with_extension("./module","nas","cpp")) {
         append(files,"./module/"~p);
diff --git a/test/occupation.nas b/test/occupation.nas
index b527e15..b46fe76 100644
--- a/test/occupation.nas
+++ b/test/occupation.nas
@@ -1,4 +1,4 @@
-import.stl.process_bar;
+import.std.process_bar;
 import.module.libkey;
 
 var is_windows_platform=os.platform()=="windows";
diff --git a/test/ppmgen.nas b/test/ppmgen.nas
index 8de5a3d..75e725d 100644
--- a/test/ppmgen.nas
+++ b/test/ppmgen.nas
@@ -1,4 +1,4 @@
-import.stl.process_bar;
+import.std.process_bar;
 
 var ppm=func(filename,width,height,RGB){
     # P3 use ASCII number
diff --git a/test/quick_sort.nas b/test/quick_sort.nas
index 1456fe0..21b6438 100644
--- a/test/quick_sort.nas
+++ b/test/quick_sort.nas
@@ -1,4 +1,4 @@
-import.stl.sort;
+import.std.sort;
 
 var vec=[];
 rand(time(0));
diff --git a/test/word_collector.nas b/test/word_collector.nas
index e033cdd..23efb73 100644
--- a/test/word_collector.nas
+++ b/test/word_collector.nas
@@ -1,4 +1,4 @@
-import.stl.sort;
+import.std.sort;
 
 var to_lower=func(s){
     var tmp="";

From ac2744e24f6dfa2627103acc167e386ad5096200 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sun, 2 Jul 2023 19:48:36 +0800
Subject: [PATCH 30/34] :sparkles: change build scripts

---
 .github/workflows/c-cpp.yml |    8 +-
 CMakeLists.txt              |   48 +-
 main.cpp                    |  178 -----
 makefile                    |   32 +-
 module/fib.cpp              |    2 +-
 module/keyboard.cpp         |    2 +-
 module/makefile             |   39 +-
 module/matrix.cpp           |    2 +-
 module/nasocket.cpp         |    2 +-
 nasal.h                     |  255 -------
 nasal_ast.h                 |  301 --------
 nasal_builtin.h             | 1400 -----------------------------------
 nasal_codegen.h             | 1088 ---------------------------
 nasal_dbg.h                 |  321 --------
 nasal_err.h                 |  228 ------
 nasal_gc.h                  |  928 -----------------------
 nasal_import.h              |  226 ------
 nasal_lexer.h               |  506 -------------
 nasal_opcode.h              |  233 ------
 nasal_opt.h                 |   75 --
 nasal_parse.h               | 1111 ---------------------------
 nasal_vm.h                  | 1287 --------------------------------
 src/ast_dumper.cpp          |   12 +
 src/nasal_new_ast.cpp       |    9 +
 src/nasal_new_ast.h         |   15 +-
 src/nasal_new_codegen.cpp   |   10 +
 src/nasal_new_gc.h          |    1 -
 src/nasal_new_header.h      |    4 +-
 src/optimizer.cpp           |  119 ++-
 src/optimizer.h             |   69 +-
 test/calc.nas               |    4 +-
 test/md5compare.nas         |    5 +-
 32 files changed, 231 insertions(+), 8289 deletions(-)
 delete mode 100644 main.cpp
 delete mode 100644 nasal.h
 delete mode 100644 nasal_ast.h
 delete mode 100644 nasal_builtin.h
 delete mode 100644 nasal_codegen.h
 delete mode 100644 nasal_dbg.h
 delete mode 100644 nasal_err.h
 delete mode 100644 nasal_gc.h
 delete mode 100644 nasal_import.h
 delete mode 100644 nasal_lexer.h
 delete mode 100644 nasal_opcode.h
 delete mode 100644 nasal_opt.h
 delete mode 100644 nasal_parse.h
 delete mode 100644 nasal_vm.h

diff --git a/.github/workflows/c-cpp.yml b/.github/workflows/c-cpp.yml
index f1291c3..58c2c5a 100644
--- a/.github/workflows/c-cpp.yml
+++ b/.github/workflows/c-cpp.yml
@@ -16,9 +16,9 @@ jobs:
     - uses: actions/checkout@v2
     - name: make
       run: |
-          make -j
+          make -j4
           cd module
-          make all -j
+          make all -j4
           cd ..
           make test
           tar -czf nasal-mac-nightly.tgz .
@@ -42,9 +42,9 @@ jobs:
     - uses: actions/checkout@v2
     - name: make
       run: |
-          make -j
+          make -j4
           cd module
-          make all -j
+          make all -j4
           cd ..
           make test
           touch nasal-linux-x86_64-nightly.tgz
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 90dd40c..fdd7981 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,22 +9,12 @@ set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED True)
 set(CMAKE_CXX_FLAGS_RELEASE_INIT "-Wshadow -Wall")
 
+add_compile_options(-fPIC)
+
 # generate release executables
 set(CMAKE_BUILD_TYPE "Release")
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/module)
-
-add_library(fib SHARED ${CMAKE_SOURCE_DIR}/module/fib.cpp)
-target_include_directories(fib PRIVATE ${CMAKE_SOURCE_DIR}/src)
-
-add_library(key SHARED ${CMAKE_SOURCE_DIR}/module/keyboard.cpp)
-target_include_directories(key PRIVATE ${CMAKE_SOURCE_DIR}/src)
-
-add_library(mat SHARED ${CMAKE_SOURCE_DIR}/module/matrix.cpp)
-target_include_directories(mat PRIVATE ${CMAKE_SOURCE_DIR}/src)
-
-add_library(nasock SHARED ${CMAKE_SOURCE_DIR}/module/nasocket.cpp)
-target_include_directories(nasock PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
+# build nasal used object
 set(NASAL_OBJECT_SOURCE_FILE
     ${CMAKE_SOURCE_DIR}/src/ast_dumper.cpp
     ${CMAKE_SOURCE_DIR}/src/ast_visitor.cpp
@@ -42,18 +32,16 @@ set(NASAL_OBJECT_SOURCE_FILE
     ${CMAKE_SOURCE_DIR}/src/nasal_new_vm.cpp
     ${CMAKE_SOURCE_DIR}/src/optimizer.cpp
     ${CMAKE_SOURCE_DIR}/src/symbol_finder.cpp)
-
-add_executable(nasal ${CMAKE_SOURCE_DIR}/src/nasal_new_main.cpp)
-
 add_library(nasal-object STATIC ${NASAL_OBJECT_SOURCE_FILE})
 target_include_directories(nasal-object PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
+# build nasal
+add_executable(nasal ${CMAKE_SOURCE_DIR}/src/nasal_new_main.cpp)
 target_link_libraries(nasal nasal-object)
 if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
     target_link_libraries(nasal dl)
 endif()
 target_include_directories(nasal PRIVATE ${CMAKE_SOURCE_DIR}/src)
-
 if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
     add_custom_command(
         TARGET nasal POST_BUILD
@@ -61,4 +49,28 @@ if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
                 ${CMAKE_SOURCE_DIR}/build/nasal
                 ${CMAKE_SOURCE_DIR}/nasal
     )
-endif()
\ No newline at end of file
+endif()
+
+# build module
+set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/module)
+
+set(MODULE_USED_OBJECT_SOURCE_FILE
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_misc.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_new_gc.cpp)
+add_library(module-used-object STATIC ${MODULE_USED_OBJECT_SOURCE_FILE})
+
+add_library(fib SHARED ${CMAKE_SOURCE_DIR}/module/fib.cpp)
+target_include_directories(fib PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(fib module-used-object)
+
+add_library(key SHARED ${CMAKE_SOURCE_DIR}/module/keyboard.cpp)
+target_include_directories(key PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(key module-used-object)
+
+add_library(mat SHARED ${CMAKE_SOURCE_DIR}/module/matrix.cpp)
+target_include_directories(mat PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(mat module-used-object)
+
+add_library(nasock SHARED ${CMAKE_SOURCE_DIR}/module/nasocket.cpp)
+target_include_directories(nasock PRIVATE ${CMAKE_SOURCE_DIR}/src)
+target_link_libraries(nasock module-used-object)
\ No newline at end of file
diff --git a/main.cpp b/main.cpp
deleted file mode 100644
index 084e28d..0000000
--- a/main.cpp
+++ /dev/null
@@ -1,178 +0,0 @@
-#include "nasal.h"
-#include "nasal_err.h"
-#include "nasal_lexer.h"
-#include "nasal_ast.h"
-#include "nasal_parse.h"
-#include "nasal_import.h"
-#include "nasal_opt.h"
-#include "nasal_gc.h"
-#include "nasal_builtin.h"
-#include "nasal_codegen.h"
-#include "nasal_vm.h"
-#include "nasal_dbg.h"
-
-#include <thread>
-#include <unordered_map>
-
-const u32 VM_AST   =0x01;
-const u32 VM_CODE  =0x02;
-const u32 VM_TIME  =0x04;
-const u32 VM_EXEC  =0x08;
-const u32 VM_DETAIL=0x10;
-const u32 VM_DEBUG =0x20;
-
-std::ostream& help(std::ostream& out) {
-    out
-    <<"     ,--#-,\n"
-    <<"<3  / \\____\\  <3\n"
-    <<"    |_|__A_|\n"
-#ifdef _WIN32
-    <<"use command <chcp 65001> to use unicode.\n"
-#endif
-    <<"\nnasal <option>\n"
-    <<"option:\n"
-    <<"   -h,   --help   | get help.\n"
-    <<"\nnasal [option] <file> [argv]\n"
-    <<"option:\n"
-    <<"   -a,   --ast    | view abstract syntax tree.\n"
-    <<"   -c,   --code   | view bytecode.\n"
-    <<"   -e,   --exec   | execute.\n"
-    <<"   -t,   --time   | show execute time.\n"
-    <<"   -d,   --detail | get detail info.\n"
-    <<"   -dbg, --debug  | debug mode.\n"
-    <<"file:\n"
-    <<"   <filename>     | execute file.\n"
-    <<"argv:\n"
-    <<"   <args>         | cmd arguments used in program.\n";
-    return out;
-}
-
-std::ostream& logo(std::ostream& out) {
-    out
-    <<"       __                _\n"
-    <<"    /\\ \\ \\__ _ ___  __ _| |\n"
-    <<"   /  \\/ / _` / __|/ _` | |\n"
-    <<"  / /\\  / (_| \\__ \\ (_| | |\n"
-    <<"  \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
-    <<"ver  : "<<__nasver<<" ("<<__DATE__<<" "<<__TIME__<<")\n"
-    <<"std  : c++ "<<__cplusplus<<"\n"
-    <<"core : "<<std::thread::hardware_concurrency()<<" core(s)\n"
-    <<"repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
-    <<"repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
-    <<"wiki : https://wiki.flightgear.org/Nasal_scripting_language\n"
-    <<"input <nasal -h> to get help .\n";
-    return out;
-}
-
-[[noreturn]]
-void err() {
-    std::cerr
-    <<"invalid argument(s).\n"
-    <<"use <nasal -h> to get help.\n";
-    std::exit(1);
-}
-
-void execute(
-    const string& file,
-    const std::vector<string>& argv,
-    const u32 cmd
-) {
-    using clk=std::chrono::high_resolution_clock;
-    const auto den=clk::duration::period::den;
-
-    error   err;
-    lexer   lex(err);
-    parse   parse(err);
-    linker  ld(err);
-    codegen gen(err);
-    vm      ctx;
-
-    // lexer scans file to get tokens
-    lex.scan(file).chkerr();
-
-    // parser gets lexer's token list to compile
-    parse.compile(lex).chkerr();
-    if (cmd&VM_AST) {
-        parse.tree().dump();
-    }
-
-    // linker gets parser's ast and load import files to this ast
-    ld.link(parse, file, cmd&VM_DETAIL).chkerr();
-
-    // optimizer does simple optimization on ast
-    optimize(parse.tree());
-
-    // code generator gets parser's ast and import file list to generate code
-    gen.compile(parse, ld).chkerr();
-    if (cmd&VM_CODE) {
-        gen.print();
-    }
-
-    // run
-    auto start=clk::now();
-    if (cmd&VM_DEBUG) {
-        dbg(err).run(gen, ld, argv);
-    } else if (cmd&VM_TIME || cmd&VM_EXEC) {
-        ctx.run(gen, ld, argv, cmd&VM_DETAIL);
-    }
-
-    // get running time
-    if (cmd&VM_TIME) {
-        f64 tm=(clk::now()-start).count()*1.0/den;
-        std::clog<<"process exited after "<<tm<<"s.\n\n";
-    }
-}
-
-i32 main(i32 argc, const char* argv[]) {
-    // output version info
-    if (argc<=1) {
-        std::clog<<logo;
-        return 0;
-    }
-
-    // run directly or show help
-    if (argc==2) {
-        string s(argv[1]);
-        if (s=="-h" || s=="--help") {
-            std::clog<<help;
-        } else if (s[0]!='-') {
-            execute(s, {}, VM_EXEC);
-        } else {
-            err();
-        }
-        return 0;
-    }
-
-    // execute with arguments
-    const std::unordered_map<string,u32> cmdlst={
-        {"--ast", VM_AST},
-        {"-a", VM_AST},
-        {"--code", VM_CODE},
-        {"-c", VM_CODE},
-        {"--exec", VM_EXEC},
-        {"-e", VM_EXEC},
-        {"--time", VM_TIME|VM_EXEC},
-        {"-t", VM_TIME|VM_EXEC},
-        {"--detail", VM_DETAIL|VM_EXEC},
-        {"-d", VM_DETAIL|VM_EXEC},
-        {"--debug", VM_DEBUG},
-        {"-dbg", VM_DEBUG}
-    };
-    u32 cmd=0;
-    string filename="";
-    std::vector<string> vm_argv;
-    for(i32 i=1; i<argc; ++i) {
-        if (cmdlst.count(argv[i])) {
-            cmd|=cmdlst.at(argv[i]);
-        } else if (!filename.length()) {
-            filename=argv[i];
-        } else {
-            vm_argv.push_back(argv[i]);
-        }
-    }
-    if (!filename.length()) {
-        err();
-    }
-    execute(filename, vm_argv, cmd?cmd:VM_EXEC);
-    return 0;
-}
\ No newline at end of file
diff --git a/makefile b/makefile
index e9fa4d5..6c04e62 100644
--- a/makefile
+++ b/makefile
@@ -1,5 +1,3 @@
-.PHONY:test clean
-
 STD=c++17
 
 NASAL_OBJECT=\
@@ -83,38 +81,12 @@ nasal_new_dbg.o: src/nasal_new_dbg.h src/nasal_new_dbg.cpp
 nasal_new_clean:
 	rm $(NASAL_OBJECT)
 
-SRC=\
-	main.cpp\
-	nasal_ast.h\
-	nasal_err.h\
-	nasal_builtin.h\
-	nasal_opcode.h\
-	nasal_opt.h\
-	nasal_codegen.h\
-	nasal_gc.h\
-	nasal_import.h\
-	nasal_lexer.h\
-	nasal_parse.h\
-	nasal_vm.h\
-	nasal_dbg.h\
-	nasal.h
-
-nasal_old:$(SRC)
-	$(CXX) -std=$(STD) -O3 main.cpp -o nasal_old -fno-exceptions -ldl -Wshadow -Wall
-
-nasal_old.exe:$(SRC)
-	$(CXX) -std=$(STD) -O3 main.cpp -o nasal_old.exe -fno-exceptions -Wshadow -Wall -static
-
-stable-release:$(SRC)
-	$(CXX) -std=$(STD) -O2 main.cpp -o nasal_old -fno-exceptions -ldl -Wshadow -Wall
-
-stable-release-mingw:$(SRC)
-	$(CXX) -std=$(STD) -O2 main.cpp -o nasal_old.exe -fno-exceptions -Wshadow -Wall -static
-
+.PHONY: clean
 clean:
 	@ echo "[clean] nasal" && if [ -e nasal ]; then rm nasal; fi
 	@ echo "[clean] nasal.exe" && if [ -e nasal.exe ]; then rm nasal.exe; fi
 
+.PHONY: test
 test:nasal
 	@ ./nasal -e test/ascii-art.nas
 	@ ./nasal -t -d test/bfs.nas
diff --git a/module/fib.cpp b/module/fib.cpp
index f0a546a..1ff1891 100644
--- a/module/fib.cpp
+++ b/module/fib.cpp
@@ -1,7 +1,7 @@
 // module for test
 
 #include <iostream>
-#include "../nasal.h"
+#include "../src/nasal_new_header.h"
 
 namespace nasal_fib_module {
 
diff --git a/module/keyboard.cpp b/module/keyboard.cpp
index c3c8e2f..da2f9c5 100644
--- a/module/keyboard.cpp
+++ b/module/keyboard.cpp
@@ -1,4 +1,4 @@
-#include "../nasal.h"
+#include "../src/nasal_new_header.h"
 #include <iostream>
 
 #ifndef _MSC_VER
diff --git a/module/makefile b/module/makefile
index d95626d..33c6b4e 100644
--- a/module/makefile
+++ b/module/makefile
@@ -1,9 +1,10 @@
 .PHONY=clean all winall
 
-dynamic_libs_so=libfib.so libkey.so libnasock.so libmat.so
-dynamic_libs_dll=libfib.dll libkey.dll libnasock.dll libmat.dll
+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_new_header.h ../src/nasal_new_gc.h
+used_header = ../src/nasal_new_header.h ../src/nasal_new_gc.h
+used_object = ../nasal_new_misc.o ../nasal_new_gc.o
 
 STD=c++17
 
@@ -12,48 +13,48 @@ all: $(dynamic_libs_so)
 winall: $(dynamic_libs_dll)
 	@ echo [Compiling] done
 
-libfib.so: fib.cpp $(used_header)
+libfib.so: fib.cpp $(used_header) $(used_object)
 	@ echo "[Compiling] libfib.so"
 	@ $(CXX) -std=$(STD) -c -O3 fib.cpp -fPIC -o fib.o
-	@ $(CXX) -shared -o libfib.so fib.o
+	@ $(CXX) -shared -o libfib.so fib.o $(used_object)
 	@ rm fib.o
-libfib.dll: fib.cpp $(used_header)
+libfib.dll: fib.cpp $(used_header) $(used_object)
 	@ echo [Compiling] libfib.dll
 	@ $(CXX) -std=$(STD) -c -O3 fib.cpp -fPIC -o fib.o
-	@ $(CXX) -shared -o libfib.dll fib.o
+	@ $(CXX) -shared -o libfib.dll fib.o $(used_object) -static
 	@ del fib.o
 
-libkey.so: keyboard.cpp $(used_header)
+libkey.so: keyboard.cpp $(used_header) $(used_object)
 	@ echo "[Compiling] libkey.so"
 	@ $(CXX) -std=$(STD) -c -O3 keyboard.cpp -fPIC -o keyboard.o
-	@ $(CXX) -shared -o libkey.so keyboard.o
+	@ $(CXX) -shared -o libkey.so keyboard.o $(used_object)
 	@ rm keyboard.o
-libkey.dll: keyboard.cpp $(used_header)
+libkey.dll: keyboard.cpp $(used_header) $(used_object)
 	@ echo [Compiling] libkey.dll
 	@ $(CXX) -std=$(STD) -c -O3 keyboard.cpp -fPIC -o keyboard.o -static
-	@ $(CXX) -shared -o libkey.dll keyboard.o -static
+	@ $(CXX) -shared -o libkey.dll keyboard.o $(used_object) -static
 	@ del keyboard.o
 
-libnasock.so: nasocket.cpp $(used_header)
+libnasock.so: nasocket.cpp $(used_header) $(used_object)
 	@ echo "[Compiling] libnasock.so"
 	@ $(CXX) -std=$(STD) -c -O3 nasocket.cpp -fPIC -o nasocket.o
-	@ $(CXX) -shared -o libnasock.so nasocket.o
+	@ $(CXX) -shared -o libnasock.so nasocket.o $(used_object)
 	@ rm nasocket.o
-libnasock.dll: nasocket.cpp $(used_header)
+libnasock.dll: nasocket.cpp $(used_header) $(used_object)
 	@ echo [Compiling] libnasock.dll
 	@ $(CXX) -std=$(STD) -c -O3 nasocket.cpp -fPIC -o nasocket.o -lwsock32 -static
-	@ $(CXX) -shared -o libnasock.dll nasocket.o -lwsock32 -static
+	@ $(CXX) -shared -o libnasock.dll nasocket.o $(used_object) -lwsock32 -static
 	@ del nasocket.o
 
-libmat.so: matrix.cpp $(used_header)
+libmat.so: matrix.cpp $(used_header) $(used_object)
 	@ echo "[Compiling] libmat.so"
 	@ $(CXX) -std=$(STD) -c -O3 matrix.cpp -fPIC -o matrix.o
-	@ $(CXX) -shared -o libmat.so matrix.o
+	@ $(CXX) -shared -o libmat.so matrix.o $(used_object)
 	@ rm matrix.o
-libmat.dll: matrix.cpp $(used_header)
+libmat.dll: matrix.cpp $(used_header) $(used_object)
 	@ echo [Compiling] libmat.dll
 	@ $(CXX) -std=$(STD) -c -O3 matrix.cpp -fPIC -o matrix.o -static
-	@ $(CXX) -shared -o libmat.dll matrix.o -static
+	@ $(CXX) -shared -o libmat.dll matrix.o $(used_object) -static
 	@ del matrix.o
 
 clean:
diff --git a/module/matrix.cpp b/module/matrix.cpp
index 5bf8939..da3cbdc 100644
--- a/module/matrix.cpp
+++ b/module/matrix.cpp
@@ -1,4 +1,4 @@
-#include "../nasal.h"
+#include "../src/nasal_new_header.h"
 #include <cmath>
 
 var nas_vec2(var* args, usize size, gc* ngc) {
diff --git a/module/nasocket.cpp b/module/nasocket.cpp
index 5320244..902fe9a 100644
--- a/module/nasocket.cpp
+++ b/module/nasocket.cpp
@@ -1,4 +1,4 @@
-#include "../nasal.h"
+#include "../src/nasal_new_header.h"
 
 #ifndef _MSC_VER
 #include <unistd.h>
diff --git a/nasal.h b/nasal.h
deleted file mode 100644
index 7290f62..0000000
--- a/nasal.h
+++ /dev/null
@@ -1,255 +0,0 @@
-#pragma once
-
-#ifndef __nasver
-#define __nasver "10.1"
-#endif
-
-#include <cstdint>
-#include <iostream>
-#include <fstream>
-#include <cstring>
-#include <cmath>
-#include <vector>
-
-bool is_windows() {
-#if defined(_WIN32) || defined(_WIN64)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_linux() {
-#if defined __linux__
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_macos() {
-#if defined __APPLE__
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_x86() {
-#if defined(__i386__) || defined(_M_IX86)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_amd64() {
-#if defined(__amd64__) || defined(_M_X64)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_x86_64() {
-    return is_amd64();
-}
-
-bool is_arm() {
-#if defined(__arm__) || defined(_M_ARM)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_aarch64() {
-#if defined(__aarch64__) || defined(_M_ARM64)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_ia64() {
-#if defined(__ia64__)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_powerpc() {
-#if defined(__powerpc__)
-    return true;
-#else
-    return false;
-#endif
-}
-
-bool is_superh() {
-#if defined(__sh__)
-    return true;
-#else
-    return false;
-#endif
-}
-
-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;
-using std::string;
-
-const u32 STACK_DEPTH=4096;
-
-f64 hex2f(const char* str) {
-    f64 ret=0;
-    for(; *str; ++str) {
-        if ('0'<=*str && *str<='9') {
-            ret=ret*16+(*str-'0');
-        } else if ('a'<=*str && *str<='f') {
-            ret=ret*16+(*str-'a'+10);
-        } else if ('A'<=*str && *str<='F') {
-            ret=ret*16+(*str-'A'+10);
-        } else {
-            return nan("");
-        }
-    }
-    return ret;
-}
-
-f64 oct2f(const char* str) {
-    f64 ret=0;
-    while('0'<=*str && *str<'8') {
-        ret=ret*8+(*str++-'0');
-    }
-    if (*str) {
-        return nan("");
-    }
-    return ret;
-}
-
-// we have the same reason not using atof here
-// just as andy's interpreter does.
-// it is not platform independent, and may have strange output.
-// so we write a new function here to convert str to number manually.
-// but this also makes 0.1+0.2==0.3,
-// not another result that you may get in other languages.
-f64 dec2f(const char* str) {
-    f64 ret=0,negative=1,num_pow=0;
-    while('0'<=*str && *str<='9') {
-        ret=ret*10+(*str++-'0');
-    }
-    if (!*str) {
-        return ret;
-    }
-    if (*str=='.') {
-        if (!*++str) {
-            return nan("");
-        }
-        num_pow=0.1;
-        while('0'<=*str && *str<='9') {
-            ret+=num_pow*(*str++-'0');
-            num_pow*=0.1;
-        }
-        if (!*str) {
-            return ret;
-        }
-    }
-    if (*str!='e' && *str!='E') {
-        return nan("");
-    }
-    if (!*++str) {
-        return nan("");
-    }
-    if (*str=='-' || *str=='+') {
-        negative=(*str++=='-'? -1:1);
-    }
-    if (!*str) {
-        return nan("");
-    }
-    num_pow=0;
-    while('0'<=*str && *str<='9') {
-        num_pow=num_pow*10+(*str++-'0');
-    }
-    if (*str) {
-        return nan("");
-    }
-    return ret*std::pow(10,negative*num_pow);
-}
-
-f64 str2num(const char* str) {
-    bool negative=false;
-    f64 res=0;
-    if (*str=='-' || *str=='+') {
-        negative=(*str++=='-');
-    }
-    if (!*str) {
-        return nan("");
-    }
-    if (str[0]=='0' && str[1]=='x') {
-        res=hex2f(str+2);
-    } else if (str[0]=='0' && str[1]=='o') {
-        res=oct2f(str+2);
-    } else {
-        res=dec2f(str);
-    }
-    return negative?-res:res;
-}
-
-i32 utf8_hdchk(const char head) {
-    // RFC-2279 but now we use RFC-3629 so nbytes is less than 4
-    const u8 c=(u8)head;
-    if ((c>>5)==0x06) { // 110x xxxx (10xx xxxx)^1
-        return 1;
-    }
-    if ((c>>4)==0x0e) { // 1110 xxxx (10xx xxxx)^2
-        return 2;
-    }
-    if ((c>>3)==0x1e) { // 1111 0xxx (10xx xxxx)^3
-        return 3;
-    }
-    return 0;
-}
-
-string chrhex(const char c) {
-    const char hextbl[]="0123456789abcdef";
-    return {hextbl[(c&0xf0)>>4],hextbl[c&0x0f]};
-}
-
-string rawstr(const string& str, const usize maxlen=0) {
-    string ret("");
-    for(auto i:str) {
-        // windows doesn't output unicode normally, so we output the hex
-        if (is_windows() && i<=0) {
-            ret+="\\x"+chrhex(i);
-            continue;
-        }
-        switch(i) {
-            case '\0':  ret+="\\0"; break;
-            case '\a':  ret+="\\a"; break;
-            case '\b':  ret+="\\b"; break;
-            case '\t':  ret+="\\t"; break;
-            case '\n':  ret+="\\n"; break;
-            case '\v':  ret+="\\v"; break;
-            case '\f':  ret+="\\f"; break;
-            case '\r':  ret+="\\r"; break;
-            case '\033':ret+="\\e"; break;
-            case '\"':  ret+="\\\"";break;
-            case '\'':  ret+="\\\'";break;
-            case '\\':  ret+="\\\\";break;
-            default:    ret+=i;     break;
-        }
-    }
-    if (maxlen && ret.length()>maxlen) {
-        ret=ret.substr(0,maxlen)+"...";
-    }
-    return ret;
-}
-
-#include "nasal_gc.h" // declarations of var and nasal_gc
diff --git a/nasal_ast.h b/nasal_ast.h
deleted file mode 100644
index c424854..0000000
--- a/nasal_ast.h
+++ /dev/null
@@ -1,301 +0,0 @@
-#pragma once
-
-#include <vector>
-#include <cstring>
-
-#include "nasal.h"
-#include "nasal_err.h"
-
-enum ast_node:u32 {
-    ast_null=0,      // null node
-    ast_root,        // mark the root node of ast
-    ast_block,       // expression block 
-    ast_file,        // used to store which file the sub-tree is on, only used in main block
-    ast_nil,         // nil keyword
-    ast_num,         // number, basic value type
-    ast_str,         // string, basic value type
-    ast_id,          // identifier
-    ast_bool,        // bools
-    ast_func,        // func keyword
-    ast_hash,        // hash, basic value type
-    ast_vec,         // vector, basic value type
-    ast_pair,        // pair of key and value in hashmap
-    ast_call,        // mark a sub-tree of calling an identifier
-    ast_callh,       // id.name
-    ast_callv,       // id[index]
-    ast_callf,       // id()
-    ast_subvec,      // id[index:index]
-    ast_params,      // mark a sub-tree of function parameters
-    ast_default,     // default parameter
-    ast_dynamic,     // dynamic parameter
-    ast_and,         // and keyword
-    ast_or,          // or keyword
-    ast_equal,       // =
-    ast_addeq,       // +=
-    ast_subeq,       // -=
-    ast_multeq,      // *=
-    ast_diveq,       // /=
-    ast_lnkeq,       // ~=
-    ast_btandeq,     // &=
-    ast_btoreq,      // |=
-    ast_btxoreq,     // ^=
-    ast_cmpeq,       // ==
-    ast_neq,         // !=
-    ast_less,        // <
-    ast_leq,         // <=
-    ast_grt,         // >
-    ast_geq,         // >=
-    ast_add,         // +
-    ast_sub,         // -
-    ast_mult,        // *
-    ast_div,         // /
-    ast_link,        // ~
-    ast_neg,         // unary -
-    ast_lnot,        // unary !
-    ast_bnot,        // unary ~ bitwise not
-    ast_bitor,       // bitwise or
-    ast_bitxor,      // bitwise xor
-    ast_bitand,      // bitwise and
-    ast_trino,       // ?:
-    ast_for,         // for keyword
-    ast_forindex,    // forindex keyword
-    ast_foreach,     // foreach keyword
-    ast_while,       // while
-    ast_iter,        // iterator, used in forindex/foreach
-    ast_cond,        // mark a sub-tree of conditional expression
-    ast_if,          // if keyword
-    ast_elsif,       // elsif keyword
-    ast_else,        // else keyword
-    ast_multi_id,    // multi identifiers sub-tree
-    ast_tuple,       // tuple, only used in multiple assignment
-    ast_def,         // definition
-    ast_multi_assign,// multi assignment sub-tree
-    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
-};
-
-const char* ast_name[]={
-    "Null",
-    "AbstractSyntaxTreeRoot",
-    "CodeBlock",
-    "FileIndex",
-    "NilLiteral",
-    "NumberLiteral",
-    "StringLiteral",
-    "Identifier",
-    "BoolLiteral",
-    "Function",
-    "HashMap",
-    "Vector",
-    "HashMapPair",
-    "IdentifierCall",
-    "HashMapCall",
-    "VectorCall",
-    "FunctionCall",
-    "SubVector",
-    "ParameterList",
-    "DefaultParameter",
-    "DynamicParameter",
-    "And",
-    "Or",
-    "Equal",
-    "AddEqual",
-    "SubEqual",
-    "MultEqual",
-    "DivEqual",
-    "LinkEqual",
-    "BitwiseAndEqual",
-    "BitwiseOrEqual",
-    "BitwiseXorEqual",
-    "CompareEqual",
-    "NotEqual",
-    "Less",
-    "LessOrEqual",
-    "Great",
-    "GreatOrEqual",
-    "Add",
-    "Sub",
-    "Mult",
-    "Div",     
-    "Link",
-    "Negative",
-    "LogicalNot",
-    "BitwiseNot",
-    "BitwiseOr",
-    "BitwiseXor",
-    "BitwiseAnd",
-    "Trinocular",
-    "ForLoop",
-    "ForindexLoop",
-    "ForeachLoop",
-    "WhileLoop",
-    "Iterator",
-    "Condition",
-    "If",
-    "Elsif",
-    "Else",
-    "LeftTuple",
-    "Tuple",
-    "Definition",
-    "MultipleAssignment",
-    "Continue",
-    "Break",
-    "Return"
-};
-
-class ast {
-public:
-    ast(const ast&) = delete;
-    ast& operator=(const ast&) = delete;
-
-    ast(ast&&) = default;
-    ast& operator=(ast&&) = default;
-
-private:
-    void print(u32, bool, std::vector<string>&) const;
-
-private:
-    span loc;
-    u32 nd_type;
-    f64 nd_num;
-    string nd_str;
-    std::vector<ast> nd_child;
-
-public:
-    ast(const span& s, const u32 t)
-        : loc(s), nd_type(t), nd_num(0), nd_str("") {}
-
-public:
-    void dump() const;
-    void clear();
-
-public:
-    ast& operator[](usize n) {return nd_child[n];}
-    const ast& operator[](usize n) const {return nd_child[n];}
-    usize size() const {return nd_child.size();}
-
-public:
-    void add(ast&& node) {nd_child.push_back(std::move(node));}
-    void set_begin(const u32, const u32);
-    void set_end(const u32, const u32);
-    void set_type(const u32 t) {nd_type=t;}
-    void set_str(const string& s) {nd_str=s;}
-    void set_num(const f64 n) {nd_num=n;}
-
-public:
-    u32 line() const {return loc.end_line;}
-    u32 type() const {return nd_type;}
-    f64 num()  const {return nd_num;}
-    const string& str() const {return nd_str;}
-    const string& file() const {return loc.file;}
-    const span& location() const {return loc;}
-
-    const std::vector<ast>& child() const {return nd_child;}
-    std::vector<ast>& child() {return nd_child;}
-
-    void update_span();
-    void update_span(const span&);
-};
-
-void ast::set_begin(const u32 l, const u32 c) {
-    loc.begin_line=l;
-    loc.begin_column=c;
-}
-
-void ast::set_end(const u32 l, const u32 c) {
-    loc.end_line=l;
-    loc.end_column=c;
-}
-
-void ast::clear() {
-    loc={0, 0, 0, 0, ""};
-    nd_num=0;
-    nd_str.clear();
-    nd_type=ast_null;
-    nd_child.clear();
-}
-
-void ast::dump() const{
-    std::vector<string> tmp;
-    print(0, false, tmp);
-}
-
-void ast::print(u32 depth, bool last, std::vector<string>& indent) const{
-    // output the indentation first
-    for(auto& i:indent) {
-        std::cout<<i;
-    }
-
-    // output ast node name
-    std::cout<<ast_name[nd_type];
-
-    // output string literal and number
-    if (nd_type==ast_str ||
-        nd_type==ast_id ||
-        nd_type==ast_bool ||
-        nd_type==ast_default ||
-        nd_type==ast_dynamic ||
-        nd_type==ast_callh) {
-        std::cout<<":"<<rawstr(nd_str);
-    } else if (nd_type==ast_num || nd_type==ast_file) {
-        std::cout<<":"<<nd_num;
-    }
-
-    // okay, we must know that begin_column starts from index 0
-    std::cout<<" --> "<<loc.file<<":"<<loc.begin_line<<":"<<loc.begin_column+1<<"\n";
-
-    // output tree structure
-    if (last && depth) {
-        indent.back()="  ";
-    } else if (!last && depth) {
-        indent.back()=is_windows()? "| ":"│ ";
-    }
-    for(u32 i=0; i<nd_child.size(); ++i) {
-        if (is_windows()) {
-            indent.push_back(i==nd_child.size()-1?"+-":"|-");
-        } else {
-            indent.push_back(i==nd_child.size()-1?"└─":"├─");
-        }
-        nd_child[i].print(depth+1,i==nd_child.size()-1,indent);
-        indent.pop_back();
-    }
-}
-
-void ast::update_span() {
-    if (!nd_child.size()) {
-        return;
-    }
-    for(const auto& i:nd_child) {
-        if (loc.begin_line>i.loc.begin_line) {
-            loc.begin_line=i.loc.begin_line;
-            loc.begin_column=i.loc.begin_column;
-        } else if (loc.begin_line==i.loc.begin_line && loc.begin_column>i.loc.begin_column) {
-            loc.begin_column=i.loc.begin_column;
-        }
-        if (loc.end_line<i.loc.end_line) {
-            loc.end_line=i.loc.end_line;
-            loc.end_column=i.loc.end_column;
-        } else if (loc.end_line==i.loc.end_line && loc.end_column<i.loc.end_column) {
-            loc.end_column=i.loc.end_column;
-        }
-        loc.file=i.loc.file;
-    }
-}
-
-void ast::update_span(const span& tloc) {
-    update_span();
-    if (loc.begin_line>tloc.begin_line) {
-        loc.begin_line=tloc.begin_line;
-        loc.begin_column=tloc.begin_column;
-    } else if (loc.begin_line==tloc.begin_line && loc.begin_column>tloc.begin_column) {
-        loc.begin_column=tloc.begin_column;
-    }
-    if (loc.end_line<tloc.end_line) {
-        loc.end_line=tloc.end_line;
-        loc.end_column=tloc.end_column;
-    } else if (loc.end_line==tloc.end_line && loc.end_column<tloc.end_column) {
-        loc.end_column=tloc.end_column;
-    }
-    loc.file=tloc.file;
-}
\ No newline at end of file
diff --git a/nasal_builtin.h b/nasal_builtin.h
deleted file mode 100644
index d800bd3..0000000
--- a/nasal_builtin.h
+++ /dev/null
@@ -1,1400 +0,0 @@
-#pragma once
-
-#include "nasal.h"
-#include "nasal_gc.h"
-
-#ifndef _MSC_VER
-#include <unistd.h>
-#include <dirent.h>
-#else
-#pragma warning (disable:4566) // i know i'm using utf-8, fuck you
-#pragma warning (disable:4244)
-#pragma warning (disable:4267)
-#pragma warning (disable:4996)
-#define _CRT_SECURE_NO_DEPRECATE 1
-#define _CRT_NONSTDC_NO_DEPRECATE 1
-#include <io.h>
-#include <direct.h>
-#endif
-
-#include <sstream>
-#include <cmath>
-#include <thread>
-#include <sys/stat.h>
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <dlfcn.h>
-#include <sys/wait.h>
-#endif
-
-#if defined __APPLE__
-#include <crt_externs.h>
-#define environ (*_NSGetEnviron())
-#endif
-
-var builtin_print(var* local, gc& ngc) {
-    for(auto& i:local[1].vec().elems) {
-        std::cout<<i;
-    }
-    std::cout<<std::flush;
-    return nil;
-}
-
-var builtin_println(var* local, gc& ngc) {
-    for(auto& i:local[1].vec().elems) {
-        std::cout<<i;
-    }
-    std::cout<<std::endl;
-    return nil;
-}
-
-var builtin_exit(var* local, gc& ngc) {
-    std::exit(local[1].num());
-    return nil;
-}
-
-var builtin_abort(var* local, gc& ngc) {
-    std::abort();
-    return nil;
-}
-
-var builtin_append(var* local, gc& ngc) {
-    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) {
-        v.push_back(i);
-    }
-    return nil;
-}
-
-var builtin_setsize(var* local, gc& ngc) {
-    var vec=local[1];
-    var size=local[2];
-    if (vec.type!=vm_vec) {
-        return nas_err("setsize", "\"vec\" must be vector");
-    }
-    if (size.type!=vm_num || size.num()<0) {
-        return nil;
-    }
-    vec.vec().elems.resize((i64)size.num(), nil);
-    return nil;
-}
-
-var builtin_system(var* local, gc& ngc) {
-    var str=local[1];
-    if (str.type!=vm_str) {
-        return var::num(-1);
-    }
-    return var::num((f64)system(str.str().c_str()));
-}
-
-var builtin_input(var* local, gc& ngc) {
-    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();
-    } else {
-        std::getline(std::cin, ret.str(), end.str()[0]);
-    }
-    return ret;
-}
-
-var builtin_readfile(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type!=vm_str) {
-        return nas_err("io::readfile", "\"filename\" must be string");
-    }
-    std::ifstream in(val.str(), std::ios::binary);
-    std::stringstream rd;
-    if (!in.fail()) {
-        rd<<in.rdbuf();
-    }
-    return ngc.newstr(rd.str());
-}
-
-var builtin_fout(var* local, gc& ngc) {
-    var val=local[1];
-    var str=local[2];
-    if (val.type!=vm_str) {
-        return nas_err("io::fout", "\"filename\" must be string");
-    }
-    std::ofstream out(val.str());
-    if (out.fail()) {
-        return nas_err("io::fout", "cannot open <"+val.str()+">");
-    }
-    out<<str;
-    return nil;
-}
-
-var builtin_split(var* local, gc& ngc) {
-    var delimeter=local[1];
-    var str=local[2];
-    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 string& deli=delimeter.str();
-    const string& s=str.str();
-
-    // avoid being sweeped
-    var res=ngc.temp=ngc.alloc(vm_vec);
-    auto& vec=res.vec().elems;
-
-    if (!deli.length()) {
-        for(auto i:s) {
-            vec.push_back(ngc.newstr(i));
-        }
-        ngc.temp=nil;
-        return res;
-    }
-    usize last=0;
-    usize pos=s.find(deli, 0);
-    while(pos!=string::npos) {
-        if (pos>last) {
-            vec.push_back(ngc.newstr(s.substr(last, pos-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;
-    return res;
-}
-
-var builtin_rand(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type!=vm_num && val.type!=vm_nil) {
-        return nas_err("rand", "\"seed\" must be nil or number");
-    }
-    if (val.type==vm_num) {
-        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));
-    }
-    return var::num(num);
-}
-
-var builtin_id(var* local, gc& ngc) {
-    var val=local[1];
-    std::stringstream ss;
-    ss<<"0";
-    if (val.type>vm_num) {
-        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];
-    if (val.type!=vm_num && val.type!=vm_str) {
-        return nil;
-    }
-    return var::num(f64((i32)val.tonum()));
-}
-
-var builtin_floor(var* local, gc& ngc) {
-    var val=local[1];
-    return var::num(std::floor(val.num()));
-}
-
-var builtin_num(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type==vm_num) {
-        return val;
-    }
-    if (val.type!=vm_str) {
-        return nil;
-    }
-    f64 res=val.tonum();
-    if (std::isnan(res)) {
-        return nil;
-    }
-    return var::num(res);
-}
-
-var builtin_pop(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type!=vm_vec) {
-        return nas_err("pop", "\"vec\" must be vector");
-    }
-    auto& vec=val.vec().elems;
-    if (vec.size()) {
-        var tmp=vec.back();
-        vec.pop_back();
-        return tmp;
-    }
-    return nil;
-}
-
-var builtin_str(var* local, gc& ngc) {
-    return ngc.newstr(local[1].tostr());
-}
-
-var builtin_size(var* local, gc& ngc) {
-    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;
-    }
-    return var::num(num);
-}
-
-var builtin_u32xor(var* local, gc& ngc) {
-    return var::num((f64)(u32(local[1].num())^u32(local[2].num())));
-}
-
-var builtin_u32and(var* local, gc& ngc) {
-    return var::num((f64)(u32(local[1].num())&u32(local[2].num())));
-}
-
-var builtin_u32or(var* local, gc& ngc) {
-    return var::num((f64)(u32(local[1].num())|u32(local[2].num())));
-}
-
-var builtin_u32nand(var* local, gc& ngc) {
-    return var::num((f64)(u32)(~(u32(local[1].num())&u32(local[2].num()))));
-}
-
-var builtin_u32not(var* local, gc& ngc) {
-    return var::num((f64)(u32)(~u32(local[1].num())));
-}
-
-var builtin_pow(var* local, gc& ngc) {
-    var x=local[1];
-    var y=local[2];
-    if (x.type!=vm_num || y.type!=vm_num) {
-        return var::num(std::nan(""));
-    }
-    return var::num(std::pow(x.num(), y.num()));
-}
-
-var builtin_sin(var* local, gc& ngc) {
-    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];
-    return var::num(val.type==vm_num?cos(val.num()):std::nan(""));
-}
-
-var builtin_tan(var* local, gc& ngc) {
-    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];
-    return var::num(val.type==vm_num?exp(val.num()):std::nan(""));
-}
-
-var builtin_lg(var* local, gc& ngc) {
-    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];
-    return var::num(val.type==vm_num?log(val.num()):std::nan(""));
-}
-
-var builtin_sqrt(var* local, gc& ngc) {
-    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];
-    if (x.type!=vm_num || y.type!=vm_num) {
-        return var::num(std::nan(""));
-    }
-    return var::num(atan2(y.num(), x.num()));
-}
-
-var builtin_isnan(var* local, gc& ngc) {
-    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];
-    if (val.type!=vm_num) {
-        return nas_err("time", "\"begin\" must be number");
-    }
-    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];
-    if (hash.type!=vm_hash || key.type!=vm_str) {
-        return 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];
-    if (hash.type!=vm_hash) {
-        return nas_err("delete", "\"hash\" must be hash");
-    }
-    if (key.type!=vm_str) {
-        return nil;
-    }
-    if (hash.hash().elems.count(key.str())) {
-        hash.hash().elems.erase(key.str());
-    }
-    return nil;
-}
-
-var builtin_keys(var* local, gc& ngc) {
-    var hash=local[1];
-    if (hash.type!=vm_hash) {
-        return nas_err("keys", "\"hash\" must be hash");
-    }
-    // avoid being sweeped
-    var res=ngc.temp=ngc.alloc(vm_vec);
-    auto& vec=res.vec().elems;
-    for(auto& iter:hash.hash().elems) {
-        vec.push_back(ngc.newstr(iter.first));
-    }
-    ngc.temp=nil;
-    return res;
-}
-
-var builtin_die(var* local, gc& ngc) {
-    return nas_err("error", local[1].tostr());
-}
-
-var builtin_find(var* local, gc& ngc) {
-    var needle=local[1];
-    var haystack=local[2];
-    usize pos=haystack.tostr().find(needle.tostr());
-    if (pos==string::npos) {
-        return var::num((f64)-1);
-    }
-    return var::num((f64)pos);
-}
-
-var builtin_type(var* local, gc& ngc) {
-    switch(local[1].type) {
-        case vm_none: return ngc.newstr("undefined");break;
-        case vm_nil:  return ngc.newstr("nil");      break;
-        case vm_num:  return ngc.newstr("num");      break;
-        case vm_str:  return ngc.newstr("str");      break;
-        case vm_vec:  return ngc.newstr("vec");      break;
-        case vm_hash: return ngc.newstr("hash");     break;
-        case vm_func: return ngc.newstr("func");     break;
-        case vm_obj:  return ngc.newstr("obj");      break;
-        case vm_co:   return ngc.newstr("coroutine");break;
-    }
-    return nil;
-}
-
-var builtin_substr(var* local, gc& ngc) {
-    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");
-    }
-    if (beg.type!=vm_num || beg.num()<0) {
-        return nas_err("substr", "\"begin\" should be number >= 0");
-    }
-    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();
-    if (begin>=str.str().length()) {
-        return nas_err("susbtr", "begin index out of range: "+std::to_string(begin));
-    }
-    return ngc.newstr(str.str().substr(begin,length));
-}
-
-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 builtin_left(var* local, gc& ngc) {
-    var str=local[1];
-    var len=local[2];
-    if (str.type!=vm_str) {
-        return nas_err("left", "\"string\" must be string");
-    }
-    if (len.type!=vm_num) {
-        return nas_err("left", "\"length\" must be number");
-    }
-    if (len.num()<0) {
-        return ngc.newstr("");
-    }
-    return ngc.newstr(str.str().substr(0,len.num()));
-}
-
-var builtin_right(var* local, gc& ngc) {
-    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();
-    if (length>srclen) {
-        length=srclen;
-    }
-    if (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];
-    if (a.type!=vm_str || b.type!=vm_str) {
-        return nas_err("cmp", "\"a\" and \"b\" must be string");
-    }
-    return var::num((f64)strcmp(a.str().c_str(), b.str().c_str()));
-}
-
-var builtin_chr(var* local, gc& ngc) {
-    const char* extend[]={
-        "€"," ","‚","ƒ","„","…","†","‡",
-        "ˆ","‰","Š","‹","Œ"," ","Ž"," ",
-        " ","‘","’","“","”","•","–","—",
-        "˜","™","š","›","œ"," ","ž","Ÿ",
-        " ","¡","¢","£","¤","¥","¦","§",
-        "¨","©","ª","«","¬"," ","®","¯",
-        "°","±","²","³","´","µ","¶","·",
-        "¸","¹","º","»","¼","½","¾","¿",
-        "À","Á","Â","Ã","Ä","Å","Æ","Ç",
-        "È","É","Ê","Ë","Ì","Í","Î","Ï",
-        "Ð","Ñ","Ò","Ó","Ô","Õ","Ö","×",
-        "Ø","Ù","Ú","Û","Ü","Ý","Þ","ß",
-        "à","á","â","ã","ä","å","æ","ç",
-        "è","é","ê","ë","ì","í","î","ï",
-        "ð","ñ","ò","ó","ô","õ","ö","÷",
-        "ø","ù","ú","û","ü","ý","þ","ÿ"
-    };
-    i32 num=local[1].num();
-    if (0<=num && num<128) {
-        return ngc.newstr((char)num);
-    } else if (128<=num && num<256) {
-        return ngc.newstr(extend[num-128]);
-    }
-    return ngc.newstr(" ");
-}
-
-var builtin_char(var* local, gc& ngc) {
-    return ngc.newstr((unsigned char)local[1].num());
-}
-
-var builtin_values(var* local, gc& ngc) {
-    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) {
-        v.push_back(i.second);
-    }
-    return vec;
-}
-
-var builtin_exists(var* local, gc& ngc) {
-    if (local[1].type!=vm_str) {
-        return zero;
-    }
-    return access(local[1].str().c_str(), F_OK)!=-1?one:zero;
-}
-
-var builtin_open(var* local, gc& ngc) {
-    var name=local[1];
-    var mode=local[2];
-    if (name.type!=vm_str) {
-        return nas_err("open", "\"filename\" must be string");
-    }
-    if (mode.type!=vm_str) {
-        return nas_err("open", "\"mode\" must be string");
-    }
-    FILE* res=fopen(name.str().c_str(), mode.str().c_str());
-    if (!res) {
-        return nas_err("open", "failed to open file <"+name.str()+">");
-    }
-    var ret=ngc.alloc(vm_obj);
-    ret.obj().set(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];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("close", "not a valid filehandle");
-    }
-    fd.obj().clear();
-    return nil;
-}
-
-var builtin_read(var* local, gc& ngc) {
-    var fd=local[1];
-    var buf=local[2];
-    var len=local[3];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("read", "not a valid filehandle");
-    }
-    if (buf.type!=vm_str || buf.val.gcobj->unmut) {
-        return nas_err("read", "\"buf\" must be mutable string");
-    }
-    if (len.type!=vm_num) {
-        return nas_err("read", "\"len\" must be number");
-    }
-    if (len.num()<=0 || len.num()>=(1<<30)) {
-        return nas_err("read", "\"len\" less than 1 or too large");
-    }
-    char* buff=new char[(usize)len.num()+1];
-    if (!buff) {
-        return nas_err("read", "malloc failed");
-    }
-    f64 res=fread(buff,1,len.num(), (FILE*)fd.obj().ptr);
-    buf.str()=buff;
-    buf.val.gcobj->unmut=true;
-    delete []buff;
-    return var::num(res);
-}
-
-var builtin_write(var* local, gc& ngc) {
-    var fd=local[1];
-    var str=local[2];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("write", "not a valid filehandle");
-    }
-    if (str.type!=vm_str) {
-        return nas_err("write", "\"str\" must be string");
-    }
-    return var::num((f64)fwrite(str.str().c_str(), 1, str.str().length(), (FILE*)fd.obj().ptr));
-}
-
-var builtin_seek(var* local, gc& ngc) {
-    var fd=local[1];
-    var pos=local[2];
-    var whence=local[3];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("seek", "not a valid filehandle");
-    }
-    return var::num((f64)fseek((FILE*)fd.obj().ptr, pos.num(), whence.num()));
-}
-
-var builtin_tell(var* local, gc& ngc) {
-    var fd=local[1];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("tell", "not a valid filehandle");
-    }
-    return var::num((f64)ftell((FILE*)fd.obj().ptr));
-}
-
-var builtin_readln(var* local, gc& ngc) {
-    var fd=local[1];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("readln", "not a valid filehandle");
-    }
-    var str=ngc.alloc(vm_str);
-    char c;
-    while((c=fgetc((FILE*)fd.obj().ptr))!=EOF) {
-        if (c=='\r') {
-            continue;
-        }
-        if (c=='\n') {
-            return str;
-        }
-        str.str()+=c;
-    }
-    if (str.str().length()) {
-        return str;
-    }
-    return nil;
-}
-
-var builtin_stat(var* local, gc& ngc) {
-    var name=local[1];
-    if (name.type!=vm_str) {
-        return nas_err("stat", "\"filename\" must be string");
-    }
-    struct stat buf;
-    if (stat(name.str().c_str(),&buf)<0) {
-        return nas_err("stat", "failed to open file <"+name.str()+">");
-    }
-    var ret=ngc.alloc(vm_vec);
-    ret.vec().elems={
-        var::num((f64)buf.st_dev),
-        var::num((f64)buf.st_ino),
-        var::num((f64)buf.st_mode),
-        var::num((f64)buf.st_nlink),
-        var::num((f64)buf.st_uid),
-        var::num((f64)buf.st_gid),
-        var::num((f64)buf.st_rdev),
-        var::num((f64)buf.st_size),
-        var::num((f64)buf.st_atime),
-        var::num((f64)buf.st_mtime),
-        var::num((f64)buf.st_ctime)
-    };
-    return ret;
-}
-
-var builtin_eof(var* local, gc& ngc) {
-    var fd=local[1];
-    if (!fd.objchk(ngc.global_ghost_type_table.ghost_file)) {
-        return nas_err("readln", "not a valid filehandle");
-    }
-    return var::num((f64)feof((FILE*)fd.obj().ptr));
-}
-
-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];
-    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();
-    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) {
-        if (s[i>>3]&(1<<(7-(i&7)))) {
-            res|=1<<(bit+len-i-1);
-        }
-    }
-    return var::num((f64)res);
-}
-
-var builtin_sfld(var* local, gc& ngc) {
-    // bits.sfld(s,0,3);
-    // 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];
-    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();
-    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) {
-        if (s[i>>3]&(1<<(7-(i&7)))) {
-            res|=1<<(bit+len-i-1);
-        }
-    }
-    if (res&(1<<(len-1))) {
-        res|=~((1<<len)-1);
-    }
-    return var::num((f64)((i32)res));
-}
-
-var builtin_setfld(var* local, gc& ngc) {
-    // bits.setfld(s,0,8,69);
-    // 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];
-    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();
-    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) {
-        if (val&(1<<(i-bit))) {
-            s[i>>3]|=(1<<(7-(i&7)));
-        } else {
-            s[i>>3]&=~(1<<(7-(i&7)));
-        }
-    }
-    return nil;
-}
-
-var builtin_buf(var* local, gc& ngc) {
-    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();
-    s.resize(length.num(), '\0');
-    return str;
-}
-
-var builtin_sleep(var* local, gc& ngc) {
-    var val=local[1];
-    if (val.type!=vm_num) {
-        return nil;
-    }
-#if defined(_WIN32) && !defined(_GLIBCXX_HAS_GTHREADS)
-    // mingw-w64 win32 thread model has no std::this_thread
-    // also msvc will use this
-    Sleep(i64(val.num()*1e3));
-#else
-    std::this_thread::sleep_for(std::chrono::microseconds(i64(val.num()*1e6)));
-#endif
-    return nil;
-}
-
-var builtin_pipe(var* local, gc& ngc) {
-#ifndef _WIN32
-    i32 fd[2];
-    var res=ngc.alloc(vm_vec);
-    if (pipe(fd)==-1) {
-        return nas_err("pipe", "failed to create pipe");
-    }
-    res.vec().elems.push_back(var::num((f64)fd[0]));
-    res.vec().elems.push_back(var::num((f64)fd[1]));
-    return res;
-#endif
-    return nas_err("pipe", "not supported");
-}
-
-var builtin_fork(var* local, gc& ngc) {
-#ifndef _WIN32
-    f64 res=fork();
-    if (res<0) {
-        return nas_err("fork", "failed to fork a process");
-    }
-    return var::num((f64)res);
-#endif
-    return nas_err("fork", "not supported");
-}
-
-var builtin_waitpid(var* local, gc& ngc) {
-    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);
-    vec.vec().elems.push_back(var::num((f64)ret_pid));
-    vec.vec().elems.push_back(var::num((f64)status));
-    return vec;
-#endif
-    return nas_err("waitpid", "not supported");
-}
-
-var builtin_opendir(var* local, gc& ngc) {
-    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);
-    if (p==INVALID_HANDLE_VALUE) {
-        return nas_err("opendir", "cannot open dir <"+path.str()+">");
-    }
-#else
-    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);
-    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];
-    if (!handle.objchk(ngc.global_ghost_type_table.ghost_dir)) {
-        return nas_err("readdir", "not a valid dir handle");
-    }
-#ifdef _MSC_VER
-    WIN32_FIND_DATAA data;
-    if (!FindNextFileA(handle.obj().ptr,&data)) {
-        return nil;
-    }
-    return ngc.newstr(data.cFileName);
-#else
-    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];
-    if (!handle.objchk(ngc.global_ghost_type_table.ghost_dir)) {
-        return nas_err("closedir", "not a valid dir handle");
-    }
-    handle.obj().clear();
-    return nil;
-}
-
-var builtin_chdir(var* local, gc& ngc) {
-    var path=local[1];
-    if (path.type!=vm_str) {
-        return var::num((f64)-1);
-    }
-    return var::num((f64)chdir(path.str().c_str()));
-}
-
-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) {
-        vec.push_back(ngc.newstr(*env));
-    }
-    ngc.temp=nil;
-    return res;
-}
-
-var builtin_getcwd(var* local, gc& ngc) {
-    char buf[1024];
-    if (!getcwd(buf,sizeof(buf))) {
-        return nil;
-    }
-    return ngc.newstr(buf);
-}
-
-var builtin_getenv(var* local, gc& ngc) {
-    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;
-}
-
-var builtin_dlopen(var* local, gc& ngc) {
-    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];
-    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());
-    delete []str;
-#else
-    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);
-    lib.obj().set(ngc.global_ghost_type_table.ghost_dylib, ptr, &ngc.global_ghost_type_table);
-    ret.hash().elems["lib"]=lib;
-
-#ifdef _WIN32
-    void* func=(void*)GetProcAddress((HMODULE)lib.obj().ptr, "get");
-#else
-    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);
-    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);
-        tmp.obj().set(ngc.global_ghost_type_table.ghost_faddr, p, &ngc.global_ghost_type_table);
-        ret.hash().elems[tbl[i].name]=tmp;
-    }
-
-    ngc.temp=nil;
-    return ret;
-}
-
-var builtin_dlclose(var* local, gc& ngc) {
-    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");
-    }
-    libptr.obj().clear();
-    return nil;
-}
-
-var builtin_dlcallv(var* local, gc& ngc) {
-    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
-    );
-}
-
-var builtin_dlcall(var* local, gc& ngc) {
-    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;
-    // arguments' stored place begins at local +2
-    return ((module_func)fp.obj().ptr)(
-        local_frame_start,
-        local_frame_size,
-        &ngc
-    );
-}
-
-var builtin_platform(var* local, gc& ngc) {
-    if (is_windows()) {
-        return ngc.newstr("windows");
-    } else if (is_linux()) {
-        return ngc.newstr("linux");
-    } else if (is_macos()) {
-        return ngc.newstr("macOS");
-    }
-    return ngc.newstr("unknown");
-}
-
-var builtin_arch(var* local, gc& ngc) {
-    if (is_x86()) {
-        return ngc.newstr("x86");
-    } else if (is_x86_64()) {
-        return ngc.newstr("x86-64");
-    } else if (is_amd64()) {
-        return ngc.newstr("amd64");
-    } else if (is_arm()) {
-        return ngc.newstr("arm");
-    } else if (is_aarch64()) {
-        return ngc.newstr("aarch64");
-    } else if (is_ia64()) {
-        return ngc.newstr("ia64");
-    } else if (is_powerpc()) {
-        return ngc.newstr("powerpc");
-    } else if (is_superh()) {
-        return ngc.newstr("superh");
-    }
-    return ngc.newstr("unknown");
-}
-
-// md5 related functions
-string tohex(u32 num) {
-    const char str16[]="0123456789abcdef";
-    string str="";
-    for(u32 i=0;i<4;i++, num>>=8) {
-        string tmp="";
-        for(u32 j=0,b=num&0xff;j<2;j++,b>>=4) {
-            tmp.insert(0,1,str16[b&0xf]);
-        }
-        str+=tmp;
-    }
-    return str;
-}
-
-string md5(const string& src) {
-    std::vector<u32> buff;
-    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);
-    }
-    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[]={
-        0xd76aa478,0xe8c7b756,0x242070db,0xc1bdceee,0xf57c0faf,0x4787c62a,0xa8304613,0xfd469501,
-        0x698098d8,0x8b44f7af,0xffff5bb1,0x895cd7be,0x6b901122,0xfd987193,0xa679438e,0x49b40821,
-        0xf61e2562,0xc040b340,0x265e5a51,0xe9b6c7aa,0xd62f105d,0x02441453,0xd8a1e681,0xe7d3fbc8,
-        0x21e1cde6,0xc33707d6,0xf4d50d87,0x455a14ed,0xa9e3e905,0xfcefa3f8,0x676f02d9,0x8d2a4c8a,
-        0xfffa3942,0x8771f681,0x6d9d6122,0xfde5380c,0xa4beea44,0x4bdecfa9,0xf6bb4b60,0xbebfbc70,
-        0x289b7ec6,0xeaa127fa,0xd4ef3085,0x04881d05,0xd9d4d039,0xe6db99e5,0x1fa27cf8,0xc4ac5665,
-        0xf4292244,0x432aff97,0xab9423a7,0xfc93a039,0x655b59c3,0x8f0ccc92,0xffeff47d,0x85845dd1,
-        0x6fa87e4f,0xfe2ce6e0,0xa3014314,0x4e0811a1,0xf7537e82,0xbd3af235,0x2ad7d2bb,0xeb86d391
-    };
-
-    // left shift bits
-    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,
-        6,10,15,21,6,10,15,21,6,10,15,21,6,10,15,21
-    };
-
-    // index
-    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;
-        0,7,14,5,12,3,10,1,8,15,6,13,4,11,2,9  // g=(7*i)%16;
-    };
-    
-#define shift(x,n)  (((x)<<(n))|((x)>>(32-(n)))) // cycle left shift
-#define md5f(x,y,z) (((x)&(y))|((~x)&(z)))    
-#define md5g(x,y,z) (((x)&(z))|((y)&(~z)))
-#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;
-        }
-        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];
-    if (str.type!=vm_str) {
-        return nas_err("md5", "\"str\" must be string");
-    }
-    return ngc.newstr(md5(str.str()));
-}
-
-var builtin_cocreate(var* local, gc& ngc) {
-    // +-------------+
-    // | old pc      | <- top[0]
-    // +-------------+
-    // | old localr  | <- top[-1]
-    // +-------------+
-    // | old upvalr  | <- top[-2]
-    // +-------------+
-    // | local scope |
-    // | ...         |
-    // +-------------+ <- local pointer stored in localr
-    // | old funcr   | <- old function stored in funcr
-    // +-------------+
-    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;
-
-    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++;
-    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;
-    
-    return co;
-}
-
-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];
-    // return nil if is not a coroutine object
-    if (co.type!=vm_co) {
-        return nil;
-    }
-    // cannot resume a dead coroutine
-    if (co.co().status==coroutine_status::dead) {
-        return nil;
-    }
-
-    // change to coroutine context
-    ngc.ctxchg(co.co());
-
-    // fetch coroutine's stack top and return
-    // so the coroutine's stack top in fact is not changed
-    if (ngc.rctx->top[0].type==vm_ret) {
-        // when first calling this coroutine, the stack top must be vm_ret
-        return ngc.rctx->top[0];
-    }
-
-    // after first calling the coroutine, each time coroutine.yield triggered
-    // a new space will be reserved on stack with value nil
-    // so we could fill this place with args
-
-    // the coroutine seems like coroutine.yield returns the value
-    // but in fact coroutine.yield stop the coroutine
-    // until main context calls the coroutine.resume
-    return local[2];
-}
-
-var builtin_coyield(var* local, gc& ngc) {
-    if (!ngc.cort) {
-        return nas_err("coroutine::yield", "no coroutine is running");
-    }
-
-    // this will set to main stack top
-    ngc.ctxreserve();
-    
-    // then this will return value to main's stack top[0]
-    // the procedure seems like coroutine.resume returns the value
-    // but in fact coroutine.resume stop the main context
-    // until coroutine calls the coroutine.yield
-    return local[1];
-}
-
-var builtin_costatus(var* local, gc& ngc) {
-    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;
-    }
-    return nil;
-}
-
-var builtin_corun(var* local, gc& ngc) {
-    return ngc.cort?one:zero;
-}
-
-var builtin_millisec(var* local, gc& ngc) {
-    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;
-    return res;
-}
-
-var builtin_gcextend(var* local, gc& ngc) {
-    var type=local[1];
-    if (type.type!=vm_str) {
-        return nil;
-    }
-    auto& s=type.str();
-    if (s=="str") {
-        ngc.extend(vm_str);
-    } else if (s=="vec") {
-        ngc.extend(vm_vec);
-    } else if (s=="hash") {
-        ngc.extend(vm_hash);
-    } else if (s=="func") {
-        ngc.extend(vm_func);
-    } else if (s=="upval") {
-        ngc.extend(vm_upval);
-    } else if (s=="obj") {
-        ngc.extend(vm_obj);
-    } else if (s=="co") {
-        ngc.extend(vm_co);
-    }
-    return nil;
-}
-
-var builtin_logtime(var* local, gc& ngc) {
-    time_t t=time(nullptr);
-    tm* tm_t=localtime(&t);
-    char s[64];
-    snprintf(
-        s,64,"%d-%.2d-%.2d %.2d:%.2d:%.2d",
-        tm_t->tm_year+1900,
-        tm_t->tm_mon+1,
-        tm_t->tm_mday,
-        tm_t->tm_hour,
-        tm_t->tm_min,
-        tm_t->tm_sec
-    );
-    return ngc.newstr(s);
-}
-
-var builtin_ghosttype(var* local, gc& ngc) {
-    var arg = local[1];
-    if (arg.type!=vm_obj) {
-        return nas_err("ghosttype", "this is not a ghost object.");
-    }
-    const auto& name = arg.obj().get_ghost_name();
-    if (!name.length()) {
-        return var::num((u64)arg.obj().ptr);
-    }
-    return ngc.newstr(name);
-}
-
-// register builtin function's name and it's address here in this table below
-// this table must end with {nullptr,nullptr}
-struct {
-    const char* name;
-    var (*func)(var*,gc&);
-} 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},
-    {"__coyield", builtin_coyield },
-    {"__costatus",builtin_costatus},
-    {"__corun"   ,builtin_corun   },
-    {"__millisec",builtin_millisec},
-    {"__sysargv", builtin_sysargv },
-    {"__gcextd",  builtin_gcextend},
-    {"__logtime", builtin_logtime },
-    {"__ghosttype", builtin_ghosttype},
-    {nullptr,     nullptr         }
-};
diff --git a/nasal_codegen.h b/nasal_codegen.h
deleted file mode 100644
index 0fbd9ab..0000000
--- a/nasal_codegen.h
+++ /dev/null
@@ -1,1088 +0,0 @@
-#pragma once
-
-#include "nasal_err.h"
-#include "nasal_builtin.h"
-#include "nasal_opcode.h"
-#include "nasal_ast.h"
-#include "nasal_parse.h"
-#include "nasal_import.h"
-
-#include <iomanip>
-#include <list>
-#include <stack>
-#include <unordered_map>
-
-#ifdef _MSC_VER
-#pragma warning (disable:4244)
-#pragma warning (disable:4267)
-#endif
-
-class codegen {
-private:
-    u16 fileindex;
-    error& err;
-    const string* file;
-    std::stack<u32> in_iterloop;
-    std::unordered_map<f64,u32> num_table;
-    std::unordered_map<string,u32> str_table;
-    std::vector<f64> num_res;
-    std::vector<string> str_res;
-    std::vector<opcode> code;
-    std::list<std::vector<i32>> continue_ptr;
-    std::list<std::vector<i32>> break_ptr;
-
-    // symbol table
-    // global : max STACK_DEPTH-1 values
-    std::unordered_map<string,i32> global;
-    // local  : max 32768 upvalues 65536 values
-    // but in fact local scope also has less than STACK_DEPTH value
-    std::list<std::unordered_map<string,i32>> local;
-
-    bool check_memory_reachable(const ast&);
-    void check_id_exist(const ast&);
-    
-    void die(const string& info, const span& loc) {
-        err.err("code", loc, info);
-    }
-
-    void regist_num(const f64);
-    void regist_str(const string&);
-    void find_symbol(const ast&);
-    void add_sym(const string&);
-    i32 local_find(const string&);
-    i32 global_find(const string&);
-    i32 upvalue_find(const string&);
-
-    void gen(u8, u32, u32);
-
-    void num_gen(const ast&);
-    void str_gen(const ast&);
-    void bool_gen(const ast&);
-    void vec_gen(const ast&);
-    void hash_gen(const ast&);
-    void func_gen(const ast&);
-    void call_gen(const ast&);
-    void call_id(const ast&);
-    void call_hash(const ast&);
-    void call_vec(const ast&);
-    void call_func(const ast&);
-    void mcall(const ast&);
-    void mcall_id(const ast&);
-    void mcall_vec(const ast&);
-    void mcall_hash(const ast&);
-    void multi_def(const ast&);
-    void single_def(const ast&);
-    void def_gen(const ast&);
-    void multi_assign_gen(const ast&);
-    void cond_gen(const ast&);
-    void loop_gen(const ast&);
-    void load_continue_break(i32, i32);
-    void while_gen(const ast&);
-    void for_gen(const ast&);
-    void expr_gen(const ast&);
-    void forindex_gen(const ast&);
-    void foreach_gen(const ast&);
-    void or_gen(const ast&);
-    void and_gen(const ast&);
-    void trino_gen(const ast&);
-    void calc_gen(const ast&);
-    void block_gen(const ast&);
-    void ret_gen(const ast&);
-
-public:
-    codegen(error& e): fileindex(0), err(e), file(nullptr) {}
-    const error& compile(const parse&, const linker&);
-    void print();
-    const std::vector<string>& strs()  const {return str_res;}
-    const std::vector<f64>&    nums()  const {return num_res;}
-    const std::vector<opcode>& codes() const {return code;}
-};
-
-bool codegen::check_memory_reachable(const ast& node) {
-    if (node.type()==ast_call) {
-        const ast& tmp=node.child().back();
-        if (tmp.type()==ast_callf) {
-            die("bad left-value with function call", node.location());
-            return false;
-        }
-        if (tmp.type()==ast_callv && (tmp.size()!=1 || tmp[0].type()==ast_subvec)) {
-            die("bad left-value with subvec", node.location());
-            return false;
-        }
-    } else if (node.type()!=ast_id) {
-        die("bad left-value", node.location());
-        return false;
-    }
-    return true;
-}
-
-void codegen::check_id_exist(const ast& node) {
-    const string& str=node.str();
-    for(u32 i=0;builtin[i].name;++i) {
-        if (builtin[i].name==str) {
-            if (local.empty()) {
-                die("useless native function used in global scope", node.location());
-            }
-            return;
-        }
-    }
-
-    if (local_find(str)>=0) {
-        return;
-    }
-    if (upvalue_find(str)>=0) {
-        return;
-    }
-    if (global_find(str)>=0) {
-        return;
-    }
-    die("undefined symbol \""+str+"\", and this symbol is useless here", node.location());
-}
-
-void codegen::regist_num(const f64 num) {
-    if (!num_table.count(num)) {
-        u32 size=num_table.size();
-        num_table[num]=size;
-        num_res.push_back(num);
-    }
-}
-
-void codegen::regist_str(const string& str) {
-    if (!str_table.count(str)) {
-        u32 size=str_table.size();
-        str_table[str]=size;
-        str_res.push_back(str);
-    }
-}
-
-void codegen::find_symbol(const ast& node) {
-    // symbol definition checked here
-    // if find a function, return
-    if (node.type()==ast_func) {
-        return;
-    } else if (node.type()==ast_def) { // find definition, check
-        if (node[0].type()==ast_multi_id) {
-            for(auto& i:node[0].child()) {
-                add_sym(i.str());
-            }
-        } else {
-            add_sym(node[0].str());
-        }
-        find_symbol(node[1]);
-    } else if (node.type()==ast_iter) { // find iterator(foreach, forindex), check
-        add_sym(node[0].str());
-    } else { // check children
-        for(auto& i:node.child()) {
-            find_symbol(i);
-        }
-    }
-}
-
-void codegen::add_sym(const string& name) {
-    if (local.empty()) {
-        if (global.count(name)) {
-            return;
-        }
-        i32 index=global.size();
-        global[name]=index;
-        return;
-    }
-    if (local.back().count(name)) {
-        return;
-    }
-    i32 index=local.back().size();
-    local.back()[name]=index;
-}
-
-i32 codegen::local_find(const string& name) {
-    if (local.empty()) {
-        return -1;
-    }
-    return local.back().count(name)?local.back()[name]:-1;
-}
-
-i32 codegen::global_find(const string& name) {
-    return global.count(name)?global[name]:-1;
-}
-
-i32 codegen::upvalue_find(const string& name) {
-    // 32768 level 65536 upvalues
-    i32 index=-1;
-    usize size=local.size();
-    if (size<=1) {
-        return -1;
-    }
-    auto iter=local.begin();
-    for(u32 i=0;i<size-1;++i,++iter) {
-        if (iter->count(name)) {
-            index=((i<<16)|(*iter)[name]);
-        }
-    }
-    return index;
-}
-
-void codegen::gen(u8 op, u32 num, u32 line) {
-    code.push_back({op, fileindex, num, line});
-}
-
-void codegen::num_gen(const ast& node) {
-    f64 num=node.num();
-    regist_num(num);
-    gen(op_pnum,num_table[num], node.line());
-}
-
-void codegen::str_gen(const ast& node) {
-    regist_str(node.str());
-    gen(op_pstr, str_table[node.str()], node.line());
-}
-
-void codegen::bool_gen(const ast& node) {
-    f64 num=node.str()=="true"?1:0;
-    regist_num(num);
-    gen(op_pnum, num_table[num], node.line());
-}
-
-void codegen::vec_gen(const ast& node) {
-    for(auto& child:node.child()) {
-        calc_gen(child);
-    }
-    gen(op_newv, node.size(), node.line());
-}
-
-void codegen::hash_gen(const ast& node) {
-    gen(op_newh, 0, node.line());
-    for(auto& child:node.child()) {
-        calc_gen(child[1]);
-        const string& str=child[0].str();
-        regist_str(str);
-        gen(op_happ, str_table[str], child.line());
-    }
-}
-
-void codegen::func_gen(const ast& node) {
-    // parameter list format check
-    bool checked_default=false;
-    bool checked_dynamic=false;
-    std::unordered_map<string,bool> argname;
-    for(auto& tmp:node[0].child()) {
-        if (tmp.type()==ast_default) {
-            checked_default=true;
-        } else if (tmp.type()==ast_dynamic) {
-            checked_dynamic=true;
-        }
-        // check default parameter and dynamic parameter
-        if (checked_default && tmp.type()!=ast_default) {
-            die("must use default parameters here", tmp.location());
-        }
-        if (checked_dynamic && &tmp!=&node[0].child().back()) {
-            die("dynamic parameter must be the last one", tmp.location());
-        }
-        // check redefinition
-        string name=tmp.str();
-        if (argname.count(name)) {
-            die("redefinition of parameter: "+name, tmp.location());
-        } else {
-            argname[name]=true;
-        }
-    }
-
-    usize newf=code.size();
-    gen(op_newf, 0, node.line());
-    usize lsize=code.size();
-    gen(op_intl, 0, node.line());
-    
-    // add special keyword 'me' into symbol table
-    // this symbol is only used in local scope(function's scope)
-    // this keyword is set to nil as default value
-    // after calling a hash, this keyword is set to this hash
-    // this symbol's index will be 0
-    local.push_back({{"me", 0}});
-
-    // generate parameter list
-    for(auto& tmp:node[0].child()) {
-        const string& str=tmp.str();
-        if (str=="me") {
-            die("\"me\" should not be a parameter", tmp.location());
-        }
-        regist_str(str);
-        switch(tmp.type()) {
-            case ast_id:
-                gen(op_para, str_table[str], tmp.line());
-                break;
-            case ast_default:
-                calc_gen(tmp[0]);
-                gen(op_deft, str_table[str], tmp.line());
-                break;
-            case ast_dynamic:
-                gen(op_dyn, str_table[str], tmp.line());
-                break;
-        }
-        add_sym(str);
-    }
-
-    code[newf].num=code.size()+1; // entry
-    usize jmp_ptr=code.size();
-    gen(op_jmp, 0, node.line());
-
-    const ast& block=node[1];
-    // search symbols first, must use after loading parameters
-    // or the location of symbols will change and cause fatal error
-    find_symbol(block);
-    in_iterloop.push(0);
-    block_gen(block);
-    in_iterloop.pop();
-    code[lsize].num=local.back().size();
-    if (local.back().size()>=STACK_DEPTH) {
-        die("too many local variants: "+std::to_string(local.back().size()), block.location());
-    }
-    local.pop_back();
-
-    if (!block.size() || block.child().back().type()!=ast_ret) {
-        gen(op_pnil, 0, block.line());
-        gen(op_ret, 0, block.line());
-    }
-    code[jmp_ptr].num=code.size();
-}
-
-void codegen::call_gen(const ast& node) {
-    calc_gen(node[0]);
-    if (code.back().op==op_callb) {
-        return;
-    }
-    for(usize i=1;i<node.size();++i) {
-        const ast& tmp=node[i];
-        switch(tmp.type()) {
-            case ast_callh:call_hash(tmp);break;
-            case ast_callv:call_vec(tmp); break;
-            case ast_callf:call_func(tmp);break;
-        }
-    }
-}
-
-void codegen::call_id(const ast& node) {
-    const string& str=node.str();
-    for(u32 i=0;builtin[i].name;++i) {
-        if (builtin[i].name==str) {
-            gen(op_callb, i, node.line());
-            if (local.empty()) {
-                die("should warp native function in local scope", node.location());
-            }
-            return;
-        }
-    }
-    i32 index;
-    if ((index=local_find(str))>=0) {
-        gen(op_calll, index, node.line());
-        return;
-    }
-    if ((index=upvalue_find(str))>=0) {
-        gen(op_upval, index, node.line());
-        return;
-    }
-    if ((index=global_find(str))>=0) {
-        gen(op_callg, index, node.line());
-        return;
-    }
-    die("undefined symbol \""+str+"\"", node.location());
-}
-
-void codegen::call_hash(const ast& node) {
-    regist_str(node.str());
-    gen(op_callh, str_table[node.str()], node.line());
-}
-
-void codegen::call_vec(const ast& node) {
-    // maybe this place can use callv-const if ast's first child is ast_num
-    if (node.size()==1 && node[0].type()!=ast_subvec) {
-        calc_gen(node[0]);
-        gen(op_callv, 0, node[0].line());
-        return;
-    }
-    gen(op_slcbeg,0,node.line());
-    for(auto& tmp:node.child()) {
-        if (tmp.type()!=ast_subvec) {
-            calc_gen(tmp);
-            gen(op_slc, 0, tmp.line());
-        } else {
-            calc_gen(tmp[0]);
-            calc_gen(tmp[1]);
-            gen(op_slc2, 0, tmp.line());
-        }
-    }
-    gen(op_slcend, 0, node.line());
-}
-
-void codegen::call_func(const ast& node) {
-    if (!node.size() || node[0].type()!=ast_pair) {
-        for(auto& child:node.child()) {
-            calc_gen(child);
-        }
-        gen(op_callfv, node.size(), node.line());
-    } else if (node[0].type()==ast_pair) {
-        hash_gen(node);
-        gen(op_callfh, 0, node.line());
-    }
-}
-
-/* mcall should run after calc_gen because this operation may trigger gc.
-*  to avoid gc incorrectly collecting values that include the memory space(which will cause SIGSEGV),
-*  we must run ast[1] then we run ast[0] to get the memory space.
-*  at this time the value including the memory space can must be found alive.
-*  BUT in fact this method does not make much safety.
-*  so we use another way to avoid gc-caused SIGSEGV: reserve m-called value on stack.
-*  you could see the notes in `vm::opr_mcallv()`.
-*/
-void codegen::mcall(const ast& node) {
-    if (!check_memory_reachable(node)) {
-        return;
-    }
-    if (node.type()==ast_id) {
-        mcall_id(node);
-        return;
-    }
-    if (node.size()==1) { // foreach and forindex use call-id ast to get mcall
-        mcall_id(node[0]);
-        return;
-    }
-    calc_gen(node[0]);
-    for(usize i=1;i<node.size()-1;++i) {
-        const ast& tmp=node[i];
-        switch(tmp.type()) {
-            case ast_callh:call_hash(tmp);break;
-            case ast_callv:call_vec(tmp); break;
-            case ast_callf:call_func(tmp);break;
-        }
-    }
-    const ast& tmp=node.child().back();
-    if (tmp.type()==ast_callh) {
-        mcall_hash(tmp);
-    } else if (tmp.type()==ast_callv) {
-        mcall_vec(tmp);
-    }
-}
-
-void codegen::mcall_id(const ast& node) {
-    const string& str=node.str();
-    for(u32 i=0;builtin[i].name;++i) {
-        if (builtin[i].name==str) {
-            die("cannot modify native function", node.location());
-            return;
-        }
-    }
-    i32 index;
-    if ((index=local_find(str))>=0) {
-        gen(op_mcalll, index, node.line());
-        return;
-    }
-    if ((index=upvalue_find(str))>=0) {
-        gen(op_mupval, index, node.line());
-        return;
-    }
-    if ((index=global_find(str))>=0) {
-        gen(op_mcallg, index, node.line());
-        return;
-    }
-    die("undefined symbol \""+str+"\"", node.location());
-}
-
-void codegen::mcall_vec(const ast& node) {
-    calc_gen(node[0]);
-    gen(op_mcallv, 0, node.line());
-}
-
-void codegen::mcall_hash(const ast& node) {
-    regist_str(node.str());
-    gen(op_mcallh, str_table[node.str()], node.line());
-}
-
-void codegen::single_def(const ast& node) {
-    const string& str=node[0].str();
-    calc_gen(node[1]);
-    local.empty()?
-        gen(op_loadg, global_find(str), node.line()):
-        gen(op_loadl, local_find(str), node.line());
-}
-void codegen::multi_def(const ast& node) {
-    auto& ids=node[0].child();
-    usize size=ids.size();
-    if (node[1].type()==ast_tuple) { // (var a,b,c)=(c,b,a);
-        auto& vals=node[1].child();
-        for(usize i=0;i<size;++i) {
-            // check node type, only identifier is allowed
-            if (ids[i].type()!=ast_id) {
-                die("cannot call identifier in multi-definition", ids[i].location());
-                continue;
-            }
-            calc_gen(vals[i]);
-            const string& str=ids[i].str();
-            local.empty()?
-                gen(op_loadg, global_find(str), ids[i].line()):
-                gen(op_loadl, local_find(str), ids[i].line());
-        }
-    } else { // (var a,b,c)=[0,1,2];
-        calc_gen(node[1]);
-        for(usize i=0;i<size;++i) {
-            // check node type, only identifier is allowed
-            if (ids[i].type()!=ast_id) {
-                die("cannot call identifier in multi-definition", ids[i].location());
-                continue;
-            }
-            gen(op_callvi, i, node[1].line());
-            const string& str=ids[i].str();
-            local.empty()?
-                gen(op_loadg, global_find(str), ids[i].line()):
-                gen(op_loadl, local_find(str), ids[i].line());
-        }
-        gen(op_pop, 0, node.line());
-    }
-}
-
-void codegen::def_gen(const ast& node) {
-    if (node[0].type()==ast_id && node[1].type()==ast_tuple) {
-        die("cannot accept too many values", node[1].location());
-    } else if (node[0].type()==ast_multi_id && node[1].type()==ast_tuple && node[0].size()<node[1].size()) {
-        die("lack values in multi-definition", node[1].location());
-    } else if (node[0].type()==ast_multi_id && node[1].type()==ast_tuple && node[0].size()>node[1].size()) {
-        die("too many values in multi-definition", node[1].location());
-    }
-    node[0].type()==ast_id?single_def(node):multi_def(node);
-}
-
-void codegen::multi_assign_gen(const ast& node) {
-    if (node[1].type()==ast_tuple && node[0].size()<node[1].size()) {
-        die("lack values in multi-assignment", node[1].location());
-    } else if (node[1].type()==ast_tuple && node[0].size()>node[1].size()) {
-        die("too many values in multi-assignment", node[1].location());
-    }
-    i32 size=node[0].size();
-    if (node[1].type()==ast_tuple) {
-        for(i32 i=size-1;i>=0;--i) {
-            calc_gen(node[1][i]);
-        }
-        for(i32 i=0;i<size;++i) {
-            mcall(node[0][i]);
-            // multi assign user loadl and loadg to avoid meq's stack--
-            // and this operation changes local and global value directly
-            if (code.back().op==op_mcalll) {
-                code.back().op=op_loadl;
-            } else if (code.back().op==op_mupval) {
-                code.back().op=op_loadu;
-            } else if (code.back().op==op_mcallg) {
-                code.back().op=op_loadg;
-            } else {
-                gen(op_meq, 1, node[0][i].line());
-            }
-        }
-    } else {
-        calc_gen(node[1]);
-        for(i32 i=0;i<size;++i) {
-            gen(op_callvi, i, node[1].line());
-            // multi assign user loadl and loadg to avoid meq's stack--
-            // and this operation changes local and global value directly
-            mcall(node[0][i]);
-            if (code.back().op==op_mcalll) {
-                code.back().op=op_loadl;
-            } else if (code.back().op==op_mupval) {
-                code.back().op=op_loadu;
-            } else if (code.back().op==op_mcallg) {
-                code.back().op=op_loadg;
-            } else {
-                gen(op_meq, 1, node[0][i].line());
-            }
-        }
-        gen(op_pop, 0, node.line());
-    }
-}
-
-void codegen::cond_gen(const ast& node) {
-    std::vector<usize> jmp_label;
-    for(auto& tmp:node.child()) {
-        if (tmp.type()==ast_if || tmp.type()==ast_elsif) {
-            calc_gen(tmp[0]);
-            usize ptr=code.size();
-            gen(op_jf, 0, tmp.line());
-            block_gen(tmp[1]);
-            // without 'else' the last condition doesn't need to jmp
-            if (&tmp!=&node.child().back()) {
-                jmp_label.push_back(code.size());
-                gen(op_jmp, 0, tmp.line());
-            }
-            code[ptr].num=code.size();
-        } else {
-            block_gen(tmp[0]);
-            break;
-        }
-    }
-    for(auto i:jmp_label) {
-        code[i].num=code.size();
-    }
-}
-
-void codegen::loop_gen(const ast& node) {
-    continue_ptr.push_front({});
-    break_ptr.push_front({});
-    switch(node.type()) {
-        case ast_while:   while_gen(node);   break;
-        case ast_for:     for_gen(node);     break;
-        case ast_forindex:forindex_gen(node);break;
-        case ast_foreach: foreach_gen(node); break;
-    }
-}
-
-void codegen::load_continue_break(i32 continue_place,i32 break_place) {
-    for(auto i:continue_ptr.front()) {
-        code[i].num=continue_place;
-    }
-    for(auto i:break_ptr.front()) {
-        code[i].num=break_place;
-    }
-    continue_ptr.pop_front();
-    break_ptr.pop_front();
-}
-
-void codegen::while_gen(const ast& node) {
-    usize loop_ptr=code.size();
-    calc_gen(node[0]);
-    usize condition_ptr=code.size();
-    gen(op_jf, 0, node[0].line());
-
-    block_gen(node[1]);
-    gen(op_jmp, loop_ptr, node[1].line());
-    code[condition_ptr].num=code.size();
-    load_continue_break(code.size()-1, code.size());
-}
-
-void codegen::for_gen(const ast& node) {
-    expr_gen(node[0]);
-    usize jmp_place=code.size();
-    if (node[1].type()==ast_null) {
-        gen(op_pnum, num_table[1], node[1].line());
-    } else {
-        calc_gen(node[1]);
-    }
-    usize label_exit=code.size();
-    gen(op_jf, 0, node[1].line());
-
-    block_gen(node[3]);
-    usize continue_place=code.size();
-    expr_gen(node[2]);
-    gen(op_jmp, jmp_place, node[2].line());
-    code[label_exit].num=code.size();
-
-    load_continue_break(continue_place, code.size());
-}
-
-void codegen::expr_gen(const ast& node) {
-    switch(node.type()) {
-        case ast_null:break;
-        case ast_def:def_gen(node);break;
-        case ast_multi_assign:multi_assign_gen(node);break;
-        case ast_addeq:case ast_subeq:
-        case ast_multeq:case ast_diveq:case ast_lnkeq:
-        case ast_btandeq:case ast_btoreq:case ast_btxoreq:
-            calc_gen(node);
-            if (op_addeq<=code.back().op && code.back().op<=op_btxoreq) {
-                code.back().num=1;
-            } else if (op_addeqc<=code.back().op && code.back().op<=op_lnkeqc) {
-                code.back().op=code.back().op-op_addeqc+op_addecp;
-            } else {
-                gen(op_pop, 0, node.line());
-            }
-            break;
-        case ast_nil:case ast_num:case ast_str:case ast_bool:break;
-        case ast_vec:case ast_hash:case ast_func:case ast_call:
-        case ast_neg:case ast_lnot:case ast_bnot:
-        case ast_bitor:case ast_bitxor:case ast_bitand:
-        case ast_add:case ast_sub:case ast_mult:case ast_div:case ast_link:
-        case ast_cmpeq:case ast_neq:
-        case ast_leq:case ast_less:
-        case ast_geq:case ast_grt:
-        case ast_or:case ast_and:
-        case ast_trino:
-            calc_gen(node);
-            gen(op_pop, 0, node.line());
-            break;
-        case ast_equal:
-            if (node[0].type()==ast_id) {
-                calc_gen(node[1]);
-                mcall_id(node[0]);
-                // only the first mcall_id can use load
-                if (code.back().op==op_mcalll) {
-                    code.back().op=op_loadl;
-                } else if (code.back().op==op_mupval) {
-                    code.back().op=op_loadu;
-                } else {
-                    code.back().op=op_loadg;
-                }
-            } else {
-                calc_gen(node);
-                if (code.back().op==op_meq) {
-                    code.back().num=1;
-                } else {
-                    gen(op_pop, 0, node.line());
-                }
-            }
-            break;
-    }
-}
-
-void codegen::forindex_gen(const ast& node) {
-    calc_gen(node[1]);
-    gen(op_cnt, 0, node[1].line());
-    usize ptr=code.size();
-    gen(op_findex, 0, node.line());
-    if (node[0].type()==ast_iter) { // define a new iterator
-        const string& str=node[0][0].str();
-        local.empty()?
-            gen(op_loadg, global_find(str), node[0][0].line()):
-            gen(op_loadl, local_find(str), node[0][0].line());
-    } else { // use exist variable as the iterator
-        mcall(node[0]);
-        if (code.back().op==op_mcallg) {
-            code.back().op=op_loadg;
-        } else if (code.back().op==op_mcalll) {
-            code.back().op=op_loadl;
-        } else if (code.back().op==op_mupval) {
-            code.back().op=op_loadu;
-        } else {
-            gen(op_meq, 1, node[0].line());
-        }
-    }
-    ++in_iterloop.top();
-    block_gen(node[2]);
-    --in_iterloop.top();
-    gen(op_jmp, ptr, node.line());
-    code[ptr].num=code.size();
-    load_continue_break(code.size()-1, code.size());
-    gen(op_pop, 0, node[1].line());// pop vector
-    gen(op_pop, 0, node.line());// pop iterator
-}
-
-void codegen::foreach_gen(const ast& node) {
-    calc_gen(node[1]);
-    gen(op_cnt, 0, node.line());
-    usize ptr=code.size();
-    gen(op_feach, 0, node.line());
-    if (node[0].type()==ast_iter) { // define a new iterator
-        const string& str=node[0][0].str();
-        local.empty()?
-            gen(op_loadg, global_find(str), node[0][0].line()):
-            gen(op_loadl, local_find(str), node[0][0].line());
-    } else { // use exist variable as the iterator
-        mcall(node[0]);
-        if (code.back().op==op_mcallg) {
-            code.back().op=op_loadg;
-        } else if (code.back().op==op_mcalll) {
-            code.back().op=op_loadl;
-        } else if (code.back().op==op_mupval) {
-            code.back().op=op_loadu;
-        } else {
-            gen(op_meq, 1, node[0].line());
-        }
-    }
-    ++in_iterloop.top();
-    block_gen(node[2]);
-    --in_iterloop.top();
-    gen(op_jmp, ptr, node.line());
-    code[ptr].num=code.size();
-    load_continue_break(code.size()-1, code.size());
-    gen(op_pop, 0, node[1].line());// pop vector
-    gen(op_pop, 0, node.line());// pop iterator
-}
-
-void codegen::or_gen(const ast& node) {
-    calc_gen(node[0]);
-    usize l1=code.size();
-    gen(op_jt, 0, node[0].line());
-
-    gen(op_pop, 0, node[0].line());
-    calc_gen(node[1]);
-    usize l2=code.size();
-    gen(op_jt, 0, node[1].line());
-
-    gen(op_pop, 0, node[1].line());
-    gen(op_pnil, 0, node[1].line());
-
-    code[l1].num=code[l2].num=code.size();
-}
-
-void codegen::and_gen(const ast& node) {
-    calc_gen(node[0]);
-    gen(op_jt, code.size()+2, node[0].line());
-
-    usize lfalse=code.size();
-    gen(op_jmp, 0, node[0].line());
-    gen(op_pop, 0, node[1].line());// jt jumps here
-
-    calc_gen(node[1]);
-    gen(op_jt, code.size()+3, node[1].line());
-
-    code[lfalse].num=code.size();
-    gen(op_pop, 0, node[1].line());
-    gen(op_pnil, 0, node[1].line());
-    // jt jumps here
-}
-
-void codegen::trino_gen(const ast& node) {
-    calc_gen(node[0]);
-    usize lfalse=code.size();
-    gen(op_jf, 0, node[0].line());
-    calc_gen(node[1]);
-    usize lexit=code.size();
-    gen(op_jmp, 0, node[1].line());
-    code[lfalse].num=code.size();
-    calc_gen(node[2]);
-    code[lexit].num=code.size();
-}
-
-void codegen::calc_gen(const ast& node) {
-    switch(node.type()) {
-        case ast_nil:  gen(op_pnil,0,node.line());break;
-        case ast_num:  num_gen(node);  break;
-        case ast_str:  str_gen(node);  break;
-        case ast_id:   call_id(node);  break;
-        case ast_bool: bool_gen(node); break;
-        case ast_vec:  vec_gen(node);  break;
-        case ast_hash: hash_gen(node); break;
-        case ast_func: func_gen(node); break;
-        case ast_call: call_gen(node); break;
-        case ast_equal:
-            calc_gen(node[1]);
-            mcall(node[0]);
-            gen(op_meq, 0, node.line());
-            break;
-        // ast_addeq(22)~ast_lnkeq(26) op_addeq(23)~op_lnkeq(27)
-        case ast_addeq:case ast_subeq:case ast_multeq:case ast_diveq:
-            if (node[1].type()!=ast_num) {
-                calc_gen(node[1]);
-            }
-            mcall(node[0]);
-            if (node[1].type()!=ast_num) {
-                gen(node.type()-ast_addeq+op_addeq, 0, node.line());
-            } else {
-                regist_num(node[1].num());
-                gen(node.type()-ast_addeq+op_addeqc, num_table[node[1].num()], node.line());
-            }
-            break;
-        case ast_lnkeq:
-            if (node[1].type()!=ast_str) {
-                calc_gen(node[1]);
-            } else {
-                regist_str(node[1].str());
-            }
-            mcall(node[0]);
-            if (node[1].type()!=ast_str) {
-                gen(op_lnkeq, 0, node.line());
-            } else {
-                gen(op_lnkeqc, str_table[node[1].str()], node.line());
-            }
-            break;
-        case ast_btandeq:case ast_btoreq:case ast_btxoreq:
-            calc_gen(node[1]);
-            mcall(node[0]);
-            gen(node.type()-ast_btandeq+op_btandeq, 0, node.line());
-            break;
-        case ast_or:or_gen(node);break;
-        case ast_and:and_gen(node);break;
-        // ast_add(33)~ast_link(37) op_add(18)~op_lnk(22)
-        case ast_add:case ast_sub:case ast_mult:case ast_div:
-            calc_gen(node[0]);
-            if (node[1].type()!=ast_num) {
-                calc_gen(node[1]);
-                gen(node.type()-ast_add+op_add, 0, node.line());
-            } else {
-                regist_num(node[1].num());
-                gen(node.type()-ast_add+op_addc, num_table[node[1].num()], node.line());
-            }
-            break;
-        case ast_link:
-            calc_gen(node[0]);
-            if (node[1].type()!=ast_str) {
-                calc_gen(node[1]);
-                gen(op_lnk, 0, node.line());
-            } else {
-                regist_str(node[1].str());
-                gen(op_lnkc, str_table[node[1].str()], node.line());
-            }
-            break;
-        // ast_cmpeq(27)~ast_geq(32) op_eq(29)~op_geq(34)
-        case ast_cmpeq:case ast_neq:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(node.type()-ast_cmpeq+op_eq, 0, node.line());
-            break;
-        case ast_less:case ast_leq:case ast_grt:case ast_geq:
-            calc_gen(node[0]);
-            if (node[1].type()!=ast_num) {
-                calc_gen(node[1]);
-                gen(node.type()-ast_less+op_less, 0, node.line());
-            } else {
-                regist_num(node[1].num());
-                gen(node.type()-ast_less+op_lessc, num_table[node[1].num()], node.line());
-            }
-            break;
-        case ast_trino:trino_gen(node);break;
-        case ast_neg:
-            calc_gen(node[0]);
-            gen(op_usub, 0, node.line());
-            break;
-        case ast_lnot:
-            calc_gen(node[0]);
-            gen(op_lnot, 0, node.line());
-            break;
-        case ast_bnot:
-            calc_gen(node[0]);
-            gen(op_bnot, 0, node.line());
-            break;
-        case ast_bitor:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(op_btor, 0, node.line());
-            break;
-        case ast_bitxor:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(op_btxor, 0, node.line());
-            break;
-        case ast_bitand:
-            calc_gen(node[0]);
-            calc_gen(node[1]);
-            gen(op_btand, 0, node.line());
-            break;
-        case ast_def:
-            single_def(node);
-            call_id(node[0]);
-            break;
-    }
-}
-
-void codegen::block_gen(const ast& node) {
-    for(auto& tmp:node.child()) {
-        switch(tmp.type()) {
-            case ast_null:break;
-            case ast_id:check_id_exist(tmp);break;
-            case ast_nil:case ast_num:case ast_str:case ast_bool:break;
-            case ast_file:fileindex=tmp.num();break; // special node type in main block
-            case ast_cond:cond_gen(tmp);break;
-            case ast_continue:
-                continue_ptr.front().push_back(code.size());
-                gen(op_jmp, 0, tmp.line());
-                break;
-            case ast_break:
-                break_ptr.front().push_back(code.size());
-                gen(op_jmp, 0, tmp.line());
-                break;
-            case ast_while:
-            case ast_for:
-            case ast_forindex:
-            case ast_foreach:loop_gen(tmp);break;
-            case ast_equal:
-            case ast_addeq:case ast_subeq:
-            case ast_multeq:case ast_diveq:case ast_lnkeq:
-            case ast_btandeq:case ast_btoreq:case ast_btxoreq:
-            case ast_vec:case ast_hash:case ast_func:case ast_call:
-            case ast_neg:case ast_lnot:case ast_bnot:
-            case ast_bitor:case ast_bitxor:case ast_bitand:
-            case ast_add:case ast_sub:case ast_mult:case ast_div:case ast_link:
-            case ast_cmpeq:case ast_neq:
-            case ast_leq:case ast_less:
-            case ast_geq:case ast_grt:
-            case ast_or:
-            case ast_and:
-            case ast_trino:
-            case ast_def:
-            case ast_multi_assign:expr_gen(tmp);break;
-            case ast_ret:ret_gen(tmp);break;
-        }
-    }
-}
-
-void codegen::ret_gen(const ast& node) {
-    for(u32 i=0;i<in_iterloop.top();++i) {
-        gen(op_pop, 0, node.line());
-        gen(op_pop, 0, node.line());
-    }
-    if (node.size()) {
-        calc_gen(node[0]);
-    } else {
-        gen(op_pnil, 0, node.line());
-    }
-    gen(op_ret, 0, node.line());
-}
-
-const error& codegen::compile(const parse& parse, const linker& import) {
-    fileindex=0;
-    file=import.filelist().data();
-    in_iterloop.push(0);
-    find_symbol(parse.tree()); // search symbols first
-    gen(op_intg, global.size(), 0);
-    block_gen(parse.tree()); // generate main block
-    gen(op_exit, 0, 0);
-
-    // size out of bound check
-    if (num_res.size()>0xffffff) {
-        err.load(file[0]); // load main execute file
-        err.err("code", "too many constant numbers: "+std::to_string(num_res.size()));
-    }
-    if (str_res.size()>0xffffff) {
-        err.load(file[0]); // load main execute file
-        err.err("code", "too many constant strings: "+std::to_string(str_res.size()));
-    }
-    if (global.size()>=STACK_DEPTH) {
-        err.load(file[0]); // load main execute file
-        err.err("code", "too many global variants: "+std::to_string(global.size()));
-    }
-    if (code.size()>0xffffff) {
-        err.load(file[0]); // load main execute file
-        err.err("code", "bytecode size overflow: "+std::to_string(code.size()));
-    }
-    return err;
-}
-
-void codegen::print() {
-    // func end stack, reserved for code print
-    std::stack<u32> fbstk;
-    std::stack<u32> festk;
-
-    // print const numbers
-    for(auto& num:num_res) {
-        std::cout<<"  .number "<<num<<"\n";
-    }
-
-    // print const strings
-    for(auto& str:str_res) {
-        std::cout<<"  .symbol \""<<rawstr(str)<<"\"\n";
-    }
-
-    // print code
-    std::cout<<"\n";
-    codestream::set(num_res.data(), str_res.data());
-    for(u32 i=0;i<code.size();++i) {
-        // print opcode index, opcode name, opcode immediate number
-        const opcode& c=code[i];
-        if (!festk.empty() && i==festk.top()) {
-            std::cout<<std::hex<<"<0x"<<fbstk.top()<<std::dec<<">;\n";
-            // avoid two empty lines
-            if (c.op!=op_newf) {
-                std::cout<<"\n";
-            }
-            fbstk.pop();
-            festk.pop();
-        }
-
-        // get function begin index and end index
-        if (c.op==op_newf) {
-            std::cout<<std::hex<<"\nfunc <0x"<<i<<std::dec<<">:\n";
-            for(u32 j=i;j<code.size();++j) {
-                if (code[j].op==op_jmp) {
-                    fbstk.push(i);
-                    festk.push(code[j].num);
-                    break;
-                }
-            }
-        }
-
-        // output bytecode
-        std::cout<<"  "<<codestream(c,i)<<"\n";
-    }
-}
diff --git a/nasal_dbg.h b/nasal_dbg.h
deleted file mode 100644
index a10fc42..0000000
--- a/nasal_dbg.h
+++ /dev/null
@@ -1,321 +0,0 @@
-#pragma once
-
-#include "nasal_import.h"
-#include "nasal_err.h"
-#include "nasal_opcode.h"
-#include "nasal_vm.h"
-
-#include <cstring>
-#include <algorithm>
-#include <unordered_map>
-
-class dbg:public vm {
-private:
-    enum class dbg_cmd {
-        cmd_error,
-        cmd_help,
-        cmd_backtrace,
-        cmd_continue,
-        cmd_list_file,
-        cmd_global,
-        cmd_local,
-        cmd_upval,
-        cmd_register,
-        cmd_show_all,
-        cmd_next,
-        cmd_break_point,
-        cmd_exit
-    };
-
-private:
-    const std::unordered_map<string, dbg_cmd> command_table = {
-        {"h", dbg_cmd::cmd_help},
-        {"help", dbg_cmd::cmd_help},
-        {"bt", dbg_cmd::cmd_backtrace},
-        {"backtrace", dbg_cmd::cmd_backtrace},
-        {"c", dbg_cmd::cmd_continue},
-        {"continue", dbg_cmd::cmd_continue},
-        {"f", dbg_cmd::cmd_list_file},
-        {"file", dbg_cmd::cmd_list_file},
-        {"g", dbg_cmd::cmd_global},
-        {"global", dbg_cmd::cmd_global},
-        {"l", dbg_cmd::cmd_local},
-        {"local", dbg_cmd::cmd_local},
-        {"u", dbg_cmd::cmd_upval},
-        {"upval", dbg_cmd::cmd_upval},
-        {"r", dbg_cmd::cmd_register},
-        {"register", dbg_cmd::cmd_register},
-        {"a", dbg_cmd::cmd_show_all},
-        {"all", dbg_cmd::cmd_show_all},
-        {"n", dbg_cmd::cmd_next},
-        {"next", dbg_cmd::cmd_next},
-        {"bk", dbg_cmd::cmd_break_point},
-        {"break", dbg_cmd::cmd_break_point},
-        {"q", dbg_cmd::cmd_exit},
-        {"exit", dbg_cmd::cmd_exit}
-    };
-    dbg_cmd get_cmd_type(const string& cmd) const {
-        return command_table.count(cmd)?
-            command_table.at(cmd):dbg_cmd::cmd_error;
-    }
-
-private:
-    bool  next;
-    usize fsize;
-    u16   bk_fidx;
-    u32   bk_line;
-    error& src;
-
-    std::vector<string> parse(const string&);
-    u16 file_index(const string&) const;
-    void err();
-    void help();
-    void list_file() const;
-    void call_sort(const u64*) const;
-    void step_info();
-    void interact();
-public:
-    dbg(error& err):
-        next(false), fsize(0),
-        bk_fidx(0), bk_line(0),
-        src(err) {}
-    void run(
-        const codegen&,
-        const linker&,
-        const std::vector<string>&
-    );
-};
-
-std::vector<string> dbg::parse(const string& cmd) {
-    std::vector<string> res;
-    usize last=0;
-    usize pos=cmd.find(" ", 0);
-    while(pos!=string::npos) {
-        if (pos>last) {
-            res.push_back(cmd.substr(last, pos-last));
-        }
-        last=pos+1;
-        pos=cmd.find(" ", last);
-    }
-    if (last<cmd.length()) {
-        res.push_back(cmd.substr(last));
-    }
-    return res;
-}
-
-u16 dbg::file_index(const string& filename) const {
-    for(u16 i=0;i<fsize;++i) {
-        if (filename==files[i]) {
-            return i;
-        }
-    }
-    return 65535;
-}
-
-void dbg::err() {
-    std::cerr
-    <<"incorrect command\n"
-    <<"input \'h\' to get help\n";
-}
-
-void dbg::help() {
-    std::clog
-    <<"<option>\n"
-    <<"  h,   help      | get help\n"
-    <<"  bt,  backtrace | get function call trace\n"
-    <<"  c,   continue  | run program until break point or exit\n"
-    <<"  f,   file      | see all the compiled files\n"
-    <<"  g,   global    | see global values\n"
-    <<"  l,   local     | see local values\n"
-    <<"  u,   upval     | see upvalue\n"
-    <<"  r,   register  | show vm register detail\n"
-    <<"  a,   all       | show global,local and upvalue\n"
-    <<"  n,   next      | execute next bytecode\n"
-    <<"  q,   exit      | exit debugger\n"
-    <<"<option> <filename> <line>\n"
-    <<"  bk,  break     | set break point\n";
-}
-
-void dbg::list_file() const {
-    for(usize i=0; i<fsize; ++i) {
-        std::clog<<"["<<i<<"] "<<files[i]<<"\n";
-    }
-}
-
-void dbg::call_sort(const u64* arr) const {
-    typedef std::pair<u32,u64> op;
-    std::vector<op> opcall;
-    u64 total=0;
-    for(u32 i=0;i<op_ret+1;++i) {
-        total+=arr[i];
-        opcall.push_back({i, arr[i]});
-    }
-    std::sort(opcall.begin(), opcall.end(),
-        [](const op& a, const op& b) {return a.second>b.second;}
-    );
-    std::clog<<"\noperands call info (<1% ignored)\n";
-    for(auto& i:opcall) {
-        u64 rate=i.second*100/total;
-        if (!rate) {
-            break;
-        }
-        std::clog<<" "<<opname[i.first]<<" : "<<i.second<<" ("<<rate<<"%)\n";
-    }
-    std::clog<<" total  : "<<total<<'\n';
-}
-
-void dbg::step_info() {
-    u32 line=bytecode[ctx.pc].line==0?0:bytecode[ctx.pc].line-1;
-    u32 begin=(line>>3)==0?0:((line>>3)<<3);
-    u32 end=(1+(line>>3))<<3;
-    src.load(files[bytecode[ctx.pc].fidx]);
-    std::clog<<"\nsource code:\n";
-    for(u32 i=begin;i<end && i<src.size();++i) {
-        std::clog<<(i==line?back_white:reset)<<(i==line?"--> ":"    ")<<src[i]<<reset<<"\n";
-    }
-
-    begin=(ctx.pc>>3)==0?0:((ctx.pc>>3)<<3);
-    end=(1+(ctx.pc>>3))<<3;
-    codestream::set(cnum, cstr, files);
-    std::clog<<"next bytecode:\n";
-    for(u32 i=begin;i<end && bytecode[i].op!=op_exit;++i) {
-        std::clog
-        <<(i==ctx.pc?back_white:reset)
-        <<(i==ctx.pc?"--> ":"    ")
-        <<codestream(bytecode[i], i)
-        <<reset<<"\n";
-    }
-    stackinfo(10);
-}
-
-void dbg::interact() {
-    // special operand, end execution
-    if (bytecode[ctx.pc].op==op_exit) {
-        return;
-    }
-    
-    if ((bytecode[ctx.pc].fidx!=bk_fidx ||
-        bytecode[ctx.pc].line!=bk_line) && // break point
-        !next) {// next step
-        return;
-    }
-
-    next=false;
-    string cmd;
-    step_info();
-    while(true) {
-        std::clog<<">> ";
-        std::getline(std::cin, cmd);
-        auto res=parse(cmd);
-        if (res.size()==0) {
-            step_info();
-        } else if (res.size()==1) {
-            switch(get_cmd_type(res[0])) {
-                case dbg_cmd::cmd_help: help(); break;
-                case dbg_cmd::cmd_backtrace: traceback(); break;
-                case dbg_cmd::cmd_continue: return;
-                case dbg_cmd::cmd_list_file: list_file(); break;
-                case dbg_cmd::cmd_global: gstate(); break;
-                case dbg_cmd::cmd_local: lstate(); break;
-                case dbg_cmd::cmd_upval: ustate(); break;
-                case dbg_cmd::cmd_register: reginfo(); break;
-                case dbg_cmd::cmd_show_all: detail(); break;
-                case dbg_cmd::cmd_next: next=true; return;
-                case dbg_cmd::cmd_exit: std::exit(0);
-                default: err(); break;
-            }
-        } else if (res.size()==3 &&
-            get_cmd_type(res[0])==dbg_cmd::cmd_break_point) {
-            bk_fidx=file_index(res[1]);
-            if (bk_fidx==65535) {
-                std::clog<<"cannot find file named `"<<res[1]<<"`\n";
-                continue;
-            }
-            i32 tmp=atoi(res[2].c_str());
-            if (tmp<=0) {
-                std::clog<<"incorrect line number `"<<res[2]<<"`\n";
-            } else {
-                bk_line=tmp;
-            }
-        } else {
-            err();
-        }
-    }
-}
-
-void dbg::run(
-    const codegen& gen,
-    const linker& linker,
-    const std::vector<string>& argv) {
-    verbose=true;
-    fsize=linker.filelist().size();
-    init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
-    u64 count[op_ret+1]={0};
-    typedef void (dbg::*nafunc)();
-    const nafunc oprs[]={
-        nullptr,        &dbg::o_intg,
-        &dbg::o_intl,   &dbg::o_loadg,
-        &dbg::o_loadl,  &dbg::o_loadu,
-        &dbg::o_pnum,   &dbg::o_pnil,
-        &dbg::o_pstr,   &dbg::o_newv,
-        &dbg::o_newh,   &dbg::o_newf,
-        &dbg::o_happ,   &dbg::o_para,
-        &dbg::o_deft,   &dbg::o_dyn,
-        &dbg::o_lnot,   &dbg::o_usub,
-        &dbg::o_bnot,   &dbg::o_btor,
-        &dbg::o_btxor,  &dbg::o_btand,
-        &dbg::o_add,    &dbg::o_sub,
-        &dbg::o_mul,    &dbg::o_div,
-        &dbg::o_lnk,    &dbg::o_addc,
-        &dbg::o_subc,   &dbg::o_mulc,
-        &dbg::o_divc,   &dbg::o_lnkc,
-        &dbg::o_addeq,  &dbg::o_subeq,
-        &dbg::o_muleq,  &dbg::o_diveq,
-        &dbg::o_lnkeq,  &dbg::o_bandeq,
-        &dbg::o_boreq,  &dbg::o_bxoreq,
-        &dbg::o_addeqc, &dbg::o_subeqc,
-        &dbg::o_muleqc, &dbg::o_diveqc,
-        &dbg::o_lnkeqc, &dbg::o_addecp,
-        &dbg::o_subecp, &dbg::o_mulecp,
-        &dbg::o_divecp, &dbg::o_lnkecp,
-        &dbg::o_meq,    &dbg::o_eq,
-        &dbg::o_neq,    &dbg::o_less,
-        &dbg::o_leq,    &dbg::o_grt,
-        &dbg::o_geq,    &dbg::o_lessc,
-        &dbg::o_leqc,   &dbg::o_grtc,
-        &dbg::o_geqc,   &dbg::o_pop,
-        &dbg::o_jmp,    &dbg::o_jt,
-        &dbg::o_jf,     &dbg::o_cnt,
-        &dbg::o_findex, &dbg::o_feach,
-        &dbg::o_callg,  &dbg::o_calll,
-        &dbg::o_upval,  &dbg::o_callv,
-        &dbg::o_callvi, &dbg::o_callh,
-        &dbg::o_callfv, &dbg::o_callfh,
-        &dbg::o_callb,  &dbg::o_slcbeg,
-        &dbg::o_slcend, &dbg::o_slc,
-        &dbg::o_slc2,   &dbg::o_mcallg,
-        &dbg::o_mcalll, &dbg::o_mupval,
-        &dbg::o_mcallv, &dbg::o_mcallh,
-        &dbg::o_ret
-    };
-    std::vector<u32> code;
-    for(auto& i:gen.codes()) {
-        code.push_back(i.op);
-        imm.push_back(i.num);
-    }
-    while(oprs[code[ctx.pc]]) {
-        interact();
-        ++count[code[ctx.pc]];
-        (this->*oprs[code[ctx.pc]])();
-        if (ctx.top>=ctx.canary) {
-            die("stack overflow");
-        }
-        ++ctx.pc;
-    }
-
-    call_sort(count);
-    ngc.info();
-    ngc.clear();
-    imm.clear();
-    return;
-}
diff --git a/nasal_err.h b/nasal_err.h
deleted file mode 100644
index c2f4545..0000000
--- a/nasal_err.h
+++ /dev/null
@@ -1,228 +0,0 @@
-#pragma once
-
-#include <iostream>
-#include <fstream>
-#include <sstream> // MSVC need this to use std::getline
-#include <cstring>
-#include <vector>
-
-#include "nasal.h"
-
-struct span {
-    u32 begin_line;
-    u32 begin_column;
-    u32 end_line;
-    u32 end_column;
-    string file;
-};
-
-#ifdef _WIN32
-#include <windows.h> // use SetConsoleTextAttribute
-struct for_reset {
-    CONSOLE_SCREEN_BUFFER_INFO scr;
-    for_reset() {
-        GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &scr);
-    }
-} reset_ter_color;
-#endif
-
-std::ostream& back_white(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0xf0);
-#else
-    s<<"\033[7m";
-#endif
-    return s;
-}
-
-std::ostream& red(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0c);
-#else
-    s<<"\033[91;1m";
-#endif
-    return s;
-}
-
-std::ostream& cyan(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x03);
-#else
-    s<<"\033[36;1m";
-#endif
-    return s;
-}
-
-std::ostream& orange(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0e);
-#else
-    s<<"\033[93;1m";
-#endif
-    return s;
-}
-
-std::ostream& white(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), 0x0f);
-#else
-    s<<"\033[0m\033[1m";
-#endif
-    return s;
-}
-
-std::ostream& reset(std::ostream& s) {
-#ifdef _WIN32
-    SetConsoleTextAttribute(GetStdHandle(STD_OUTPUT_HANDLE), reset_ter_color.scr.wAttributes);
-#else
-    s<<"\033[0m";
-#endif
-    return s;
-}
-
-class flstream {
-protected:
-    string file;
-    std::vector<string> res;
-public:
-    flstream():file("") {}
-    void load(const string&);
-    const string& operator[](usize n) const {return res[n];}
-    const string& name() const {return file;}
-    usize size() const {return res.size();}
-};
-
-class error:public flstream {
-private:
-    u32 cnt; // counter for errors
-
-    string identation(usize len) {
-        return string(len,' ');
-    }
-    string leftpad(u32 num, usize len) {
-        string tmp=std::to_string(num);
-        while(tmp.length()<len) {
-            tmp=" "+tmp;
-        }
-        return tmp;
-    }
-public:
-    error():cnt(0) {}
-    void fatal(const string&, const string&);
-    void err(const string&, const string&);
-    void err(const string&, const span&, const string&);
-
-    void chkerr() const {
-        if (cnt) {
-            std::exit(1);
-        }
-    }
-};
-
-
-void flstream::load(const string& f) {
-    if (file==f) { // don't need to load a loaded file
-        return;
-    } else {
-        file=f;
-    }
-
-    res.clear();
-    std::ifstream in(f, std::ios::binary);
-    if (in.fail()) {
-        std::cerr<<red<<"src: "<<reset<<"cannot open <"<<f<<">\n";
-        std::exit(1);
-    }
-    
-    while(!in.eof()) {
-        string line;
-        std::getline(in, line);
-        res.push_back(line);
-    }
-}
-
-void error::fatal(const string& stage, const string& info) {
-    std::cerr<<red<<stage<<": "<<white<<info<<reset<<"\n";
-    if (file.length()) {
-        std::cerr<<cyan<<" --> "<<red<<file<<reset<<"\n\n";
-    } else {
-        std::cerr<<reset<<"\n";
-    }
-    std::exit(1);
-}
-
-void error::err(const string& stage, const string& info) {
-    ++cnt;
-    std::cerr<<red<<stage<<": "<<white<<info<<reset<<"\n";
-    if (file.length()) {
-        std::cerr<<cyan<<" --> "<<red<<file<<reset<<"\n\n";
-    } else {
-        std::cerr<<reset<<"\n";
-    }
-}
-
-void error::err(const string& stage, const span& loc, const string& info) {
-    // load error occurred file into string lines
-    load(loc.file);
-
-    ++cnt;
-
-    std::cerr
-    <<red<<stage<<": "<<white<<info<<reset<<"\n"<<cyan<<"  --> "
-    <<red<<loc.file<<":"<<loc.begin_line<<":"<<loc.begin_column+1<<reset<<"\n";
-
-    const usize maxlen=std::to_string(loc.end_line).length();
-    const string iden=identation(maxlen);
-
-    for(u32 line=loc.begin_line; line<=loc.end_line; ++line) {
-        if (!line) {
-            continue;
-        }
-
-        if (loc.begin_line<line && line<loc.end_line) {
-            if (line==loc.begin_line+1) {
-                std::cerr<<cyan<<iden<<" | "<<reset<<"...\n"<<cyan<<iden<<" | "<<reset<<"\n";
-            }
-            continue;
-        }
-
-        // if this line has nothing, skip
-        if (!res[line-1].length() && line!=loc.end_line) {
-            continue;
-        }
-
-        const string& code=res[line-1];
-        std::cerr<<cyan<<leftpad(line, maxlen)<<" | "<<reset<<code<<"\n";
-        // output underline
-        std::cerr<<cyan<<iden<<" | "<<reset;
-        if (loc.begin_line==loc.end_line) {
-            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) {
-                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^")<<reset;
-            }
-        } else if (line==loc.begin_line) {
-            for(u32 i=0; i<loc.begin_column; ++i) {
-                std::cerr<<char(" \t"[code[i]=='\t']);
-            }
-            for(u32 i=loc.begin_column; i<code.size(); ++i) {
-                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^")<<reset;
-            }
-        } else if (loc.begin_line<line && line<loc.end_line) {
-            for(u32 i=0; i<code.size(); ++i) {
-                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^");
-            }
-        } else {
-            for(u32 i=0; i<loc.end_column; ++i) {
-                std::cerr<<red<<(code[i]=='\t'?"^^^^":"^");
-            }
-        }
-        if (line==loc.end_line) {
-            std::cerr<<reset;
-        } else {
-            std::cerr<<reset<<"\n";
-        }
-    }
-    std::cerr<<"\n\n";
-}
\ No newline at end of file
diff --git a/nasal_gc.h b/nasal_gc.h
deleted file mode 100644
index d66bf25..0000000
--- a/nasal_gc.h
+++ /dev/null
@@ -1,928 +0,0 @@
-#pragma once
-
-// avoid MSVC warnings
-#ifdef _MSC_VER
-#pragma warning (disable:4244)
-#pragma warning (disable:4267)
-#pragma warning (disable:4102)
-#endif
-
-#ifndef _MSC_VER
-#include <unistd.h>
-#include <dirent.h>
-#else
-#include <io.h>
-#include <direct.h>
-#endif
-
-#ifdef _WIN32
-#include <windows.h>
-#else
-#include <dlfcn.h>
-#endif
-
-#include <iomanip>
-#include <vector>
-#include <unordered_map>
-#include <chrono>
-#include <algorithm>
-
-#include "nasal.h"
-#include "nasal_err.h"
-
-enum vm_type:u8 {
-    /* none-gc object */
-    vm_none=0,
-    vm_cnt,
-    vm_addr,
-    vm_ret,
-    vm_nil,
-    vm_num,
-    /* gc object */
-    vm_str,
-    vm_vec,
-    vm_hash,
-    vm_func,
-    vm_upval,
-    vm_obj,
-    vm_co
-};
-
-const u32 gc_type_size=vm_co-vm_str+1;
-
-enum class coroutine_status:u32 {
-    suspended,
-    running,
-    dead
-};
-
-enum class gc_status:u8 {
-    uncollected=0,   
-    collected,
-    found
-};
-
-struct nas_vec;   // vector
-struct nas_hash;  // hashmap(dict)
-struct nas_func;  // function(lambda)
-struct nas_upval; // upvalue
-struct nas_ghost; // objects
-struct nas_co;    // coroutine
-struct nas_val;   // nas_val includes gc-managed types
-
-struct var {
-public:
-    u8 type;
-    union {
-        u32 ret;
-        i64 cnt;
-        f64 num;
-        var* addr;
-        nas_val* gcobj;
-    } val;
-
-private:
-    var(u8 t, u32 pc) {type=t;val.ret=pc;}
-    var(u8 t, i64 ct) {type=t;val.cnt=ct;}
-    var(u8 t, f64 n) {type=t;val.num=n;}
-    var(u8 t, var* p) {type=t;val.addr=p;}
-    var(u8 t, nas_val* p) {type=t;val.gcobj=p;}
-
-public:
-    var() = default;
-    var(const var&) = default;
-    bool operator==(const var& nr) const {return type==nr.type && val.gcobj==nr.val.gcobj;}
-    bool operator!=(const var& nr) const {return type!=nr.type || val.gcobj!=nr.val.gcobj;}
-    friend std::ostream& operator<<(std::ostream&, var&);
-
-    // number and string can be translated to each other
-    f64 tonum();
-    string tostr();
-    bool objchk(usize);
-
-    // create new var object
-    static var none();
-    static var nil();
-    static var ret(u32);
-    static var cnt(i64);
-    static var num(f64);
-    static var gcobj(nas_val*);
-    static var addr(var*);
-
-    // get content
-    var*       addr();
-    u32        ret ();
-    i64&       cnt ();
-    f64        num ();
-    string&    str ();
-    nas_vec&   vec ();
-    nas_hash&  hash();
-    nas_func&  func();
-    nas_upval& upval();
-    nas_ghost& obj ();
-    nas_co&    co  ();
-};
-
-struct nas_vec {
-    std::vector<var> elems;
-
-    // mark if this is printed, avoid stackoverflow
-    bool printed;
-
-    nas_vec():printed(false) {}
-    usize size() const {return elems.size();}
-    var get_val(const i32);
-    var* get_mem(const i32);
-};
-
-struct nas_hash {
-    std::unordered_map<string,var> elems;
-
-    // mark if this is printed, avoid stackoverflow
-    bool printed;
-
-    nas_hash():printed(false) {}
-    usize size() const {return elems.size();}
-    var get_val(const string&);
-    var* get_mem(const string&);
-};
-
-struct nas_func {
-    i32 dpara; // dynamic parameter name index in hash.
-    u32 entry; // pc will set to entry-1 to call this function
-    u32 psize; // used to load default parameters to a new function
-    u32 lsize; // used to expand memory space for local values on stack
-    std::vector<var> local; // local scope with default value(var)
-    std::vector<var> upval; // closure
-    std::unordered_map<u32,u32> keys; // parameter table, u32 begins from 1
-
-    nas_func(): dpara(-1), entry(0), psize(0), lsize(0) {}
-    void clear();
-};
-
-struct nas_upval {
-public:
-    /* on stack, use these variables */
-    bool onstk;
-    u32 size;
-    var* stk;
-
-    /* not on stack, use this */
-    std::vector<var> elems;
-
-public:
-    nas_upval(): onstk(true), size(0), stk(nullptr) {}
-
-    var& operator[](usize n) {
-        return onstk? stk[n]:elems[n];
-    }
-
-    void clear() {
-        onstk=true;
-        elems.clear();
-        size=0;
-    }
-};
-
-void filehandle_destructor(void* ptr) {
-    if ((FILE*)ptr==stdin) {
-        return;
-    }
-    fclose((FILE*)ptr);
-}
-
-void dir_entry_destructor(void* ptr) {
-#ifndef _MSC_VER
-    closedir((DIR*)ptr);
-#else
-    FindClose(ptr);
-#endif
-}
-
-void dylib_destructor(void* ptr) {
-#ifdef _WIN32
-    FreeLibrary((HMODULE)ptr);
-#else
-    dlclose(ptr);
-#endif
-}
-
-void func_addr_destructor(void* ptr) {}
-
-struct ghost_register_table {
-private:
-    using dtor=void (*)(void*);
-
-private:
-    std::unordered_map<string,usize> mapper;
-    std::vector<string> ghost_name;
-    std::vector<dtor> destructors;
-
-public:
-    // reserved ghost type only for native functions
-    usize ghost_file;
-    usize ghost_dir;
-    usize ghost_dylib;
-    usize ghost_faddr;
-
-public:
-    ghost_register_table() {
-        ghost_file=register_ghost_type("file", filehandle_destructor);
-        ghost_dir=register_ghost_type("dir", dir_entry_destructor);
-        ghost_dylib=register_ghost_type("dylib", dylib_destructor);
-        ghost_faddr=register_ghost_type("faddr", func_addr_destructor);
-    }
-
-    bool exists(const string& name) const {
-        return mapper.count(name);
-    }
-
-    usize get_ghost_type_index(const string& name) const {
-        return mapper.at(name);
-    }
-
-    const string& get_ghost_name(usize index) const {
-        return ghost_name.at(index);
-    }
-
-    usize register_ghost_type(const std::string& name, dtor ptr) {
-        if (mapper.count(name)) {
-            std::cerr<<"nasal_gc.h: ghost_register_table::register_ghost_type: ";
-            std::cerr<<"ghost type \""<<name<<"\" already exists.\n";
-            std::exit(1);
-        }
-        auto res=destructors.size();
-        mapper[name]=res;
-        ghost_name.push_back(name);
-        destructors.push_back(ptr);
-        return res;
-    }
-
-    dtor destructor(usize index) {
-        return destructors.at(index);
-    }
-};
-
-struct nas_ghost {
-public:
-    usize type;
-    void* ptr;
-
-private:
-    ghost_register_table* ghost_type_table;
-
-public:
-    nas_ghost(): type(0), ptr(nullptr), ghost_type_table(nullptr) {}
-    ~nas_ghost() {clear();}
-    void set(usize, void*, ghost_register_table*);
-    void clear();
-
-public:
-    friend std::ostream& operator<<(std::ostream& out, nas_ghost& ghost) {
-        out<<"<object "<<ghost.ghost_type_table->get_ghost_name(ghost.type);
-        out<<" at 0x"<<std::hex<<(u64)ghost.ptr<<std::dec<<">";
-        return out;
-    }
-
-    const std::string& get_ghost_name() const {
-        return ghost_type_table->get_ghost_name(type);
-    }
-};
-
-struct context {
-    u32  pc;
-    var* localr;
-    var* memr;
-    var  funcr;
-    var  upvalr;
-    var* canary;
-    var* stack;
-    var* top;
-};
-
-struct nas_co {
-    var stack[STACK_DEPTH];
-    context ctx;
-    coroutine_status status;
-
-    nas_co() {clear();}
-    void clear();
-};
-
-struct nas_val {
-    gc_status mark;
-    u8 type; // value type
-    u8 unmut; // used to mark if a string is unmutable
-    union {
-        string*    str;
-        nas_vec*   vec;
-        nas_hash*  hash;
-        nas_func*  func;
-        nas_upval* upval;
-        nas_ghost* obj;
-        nas_co*    co;
-    } ptr;
-
-    nas_val(u8);
-    ~nas_val();
-    void clear();
-};
-
-var nas_vec::get_val(const i32 n) {
-    i32 size=elems.size();
-    if (n<-size || n>=size) {
-        return var::none();
-    }
-    return elems[n>=0?n:n+size];
-}
-
-var* nas_vec::get_mem(const i32 n) {
-    i32 size=elems.size();
-    if (n<-size || n>=size) {
-        return nullptr;
-    }
-    return &elems[n>=0?n:n+size];
-}
-
-std::ostream& operator<<(std::ostream& out, nas_vec& vec) {
-    if (!vec.elems.size() || vec.printed) {
-        out<<(vec.elems.size()?"[..]":"[]");
-        return out;
-    }
-    vec.printed=true;
-    usize iter=0,size=vec.elems.size();
-    out<<'[';
-    for(auto& i:vec.elems) {
-        out<<i<<",]"[(++iter)==size];
-    }
-    vec.printed=false;
-    return out;
-}
-
-var nas_hash::get_val(const string& key) {
-    if (elems.count(key)) {
-        return elems.at(key);
-    } else if (!elems.count("parents")) {
-        return var::none();
-    }
-    var ret=var::none();
-    var val=elems.at("parents");
-    if (val.type!=vm_vec) {
-        return ret;
-    }
-    for(auto& i:val.vec().elems) {
-        if (i.type==vm_hash) {
-            ret=i.hash().get_val(key);
-        }
-        if (ret.type!=vm_none) {
-            return ret;
-        }
-    }
-    return ret;
-}
-
-var* nas_hash::get_mem(const string& key) {
-    if (elems.count(key)) {
-        return &elems.at(key);
-    } else if (!elems.count("parents")) {
-        return nullptr;
-    }
-    var* addr=nullptr;
-    var val=elems.at("parents");
-    if (val.type!=vm_vec) {
-        return addr;
-    }
-    for(auto& i:val.vec().elems) {
-        if (i.type==vm_hash) {
-            addr=i.hash().get_mem(key);
-        }
-        if (addr) {
-            return addr;
-        }
-    }
-    return addr;
-}
-
-std::ostream& operator<<(std::ostream& out, nas_hash& hash) {
-    if (!hash.elems.size() || hash.printed) {
-        out<<(hash.elems.size()?"{..}":"{}");
-        return out;
-    }
-    hash.printed=true;
-    usize iter=0,size=hash.elems.size();
-    out<<'{';
-    for(auto& i:hash.elems) {
-        out<<i.first<<':'<<i.second<<",}"[(++iter)==size];
-    }
-    hash.printed=false;
-    return out;
-}
-
-void nas_func::clear() {
-    dpara=-1;
-    local.clear();
-    upval.clear();
-    keys.clear();
-}
-
-void nas_ghost::set(usize t, void* p, ghost_register_table* table) {
-    type=t;
-    ptr=p;
-    ghost_type_table=table;
-}
-
-void nas_ghost::clear() {
-    if (!ptr) {
-        return;
-    }
-    ghost_type_table->destructor(type)(ptr);
-    ptr=nullptr;
-}
-
-void nas_co::clear() {
-    for(u32 i=0;i<STACK_DEPTH;++i) {
-        stack[i]=var::nil();
-    }
-    ctx.pc=0;
-    ctx.localr=nullptr;
-    ctx.memr=nullptr;
-    ctx.canary=stack+STACK_DEPTH-1;
-    ctx.top=stack;
-    ctx.funcr=var::nil();
-    ctx.upvalr=var::nil();
-    ctx.stack=stack;
-
-    status=coroutine_status::suspended;
-}
-
-nas_val::nas_val(u8 val_type) {
-    mark=gc_status::collected;
-    type=val_type;
-    unmut=0;
-    switch(val_type) {
-        case vm_str:  ptr.str=new string;     break;
-        case vm_vec:  ptr.vec=new nas_vec;    break;
-        case vm_hash: ptr.hash=new nas_hash;  break;
-        case vm_func: ptr.func=new nas_func;  break;
-        case vm_upval:ptr.upval=new nas_upval;break;
-        case vm_obj:  ptr.obj=new nas_ghost;  break;
-        case vm_co:   ptr.co=new nas_co;      break;
-    }
-}
-
-nas_val::~nas_val() {
-    switch(type) {
-        case vm_str:  delete ptr.str;  break;
-        case vm_vec:  delete ptr.vec;  break;
-        case vm_hash: delete ptr.hash; break;
-        case vm_func: delete ptr.func; break;
-        case vm_upval:delete ptr.upval;break;
-        case vm_obj:  delete ptr.obj;  break;
-        case vm_co:   delete ptr.co;   break;
-    }
-    type=vm_nil;
-}
-
-void nas_val::clear() {
-    switch(type) {
-        case vm_str:  ptr.str->clear();       break;
-        case vm_vec:  ptr.vec->elems.clear(); break;
-        case vm_hash: ptr.hash->elems.clear();break;
-        case vm_func: ptr.func->clear();      break;
-        case vm_upval:ptr.upval->clear();     break;
-        case vm_obj:  ptr.obj->clear();       break;
-        case vm_co:   ptr.co->clear();        break;
-    }
-}
-
-f64 var::tonum() {
-    return type!=vm_str? val.num:str2num(str().c_str());
-}
-
-string var::tostr() {
-    if (type==vm_str) {
-        return str();
-    } else if (type==vm_num) {
-        string tmp=std::to_string(num());
-        tmp.erase(tmp.find_last_not_of('0')+1, string::npos);
-        tmp.erase(tmp.find_last_not_of('.')+1, string::npos);
-        return tmp;
-    }
-    return "";
-}
-
-std::ostream& operator<<(std::ostream& out, var& ref) {
-    switch(ref.type) {
-        case vm_none: out<<"undefined";   break;
-        case vm_nil:  out<<"nil";         break;
-        case vm_num:  out<<ref.val.num;   break;
-        case vm_str:  out<<ref.str();     break;
-        case vm_vec:  out<<ref.vec();     break;
-        case vm_hash: out<<ref.hash();    break;
-        case vm_func: out<<"func(..) {..}";break;
-        case vm_obj:  out<<ref.obj();     break;
-        case vm_co:   out<<"<coroutine>"; break;
-    }
-    return out;
-}
-
-bool var::objchk(usize obj_type) {
-    return type==vm_obj && obj().type==obj_type && obj().ptr;
-}
-
-var var::none() {
-    return {vm_none, (u32)0};
-}
-
-var var::nil() {
-    return {vm_nil, (u32)0};
-}
-
-var var::ret(u32 pc) {
-    return {vm_ret, pc};
-}
-
-var var::cnt(i64 n) {
-    return {vm_cnt, n};
-}
-
-var var::num(f64 n) {
-    return {vm_num, n};
-}
-
-var var::gcobj(nas_val* p) {
-    return {p->type, p};
-}
-
-var var::addr(var* p) {
-    return {vm_addr, p};
-}
-
-var*       var::addr () {return val.addr;             }
-u32        var::ret  () {return val.ret;              }
-i64&       var::cnt  () {return val.cnt;              }
-f64        var::num  () {return val.num;              }
-string&    var::str  () {return *val.gcobj->ptr.str;  }
-nas_vec&   var::vec  () {return *val.gcobj->ptr.vec;  }
-nas_hash&  var::hash () {return *val.gcobj->ptr.hash; }
-nas_func&  var::func () {return *val.gcobj->ptr.func; }
-nas_upval& var::upval() {return *val.gcobj->ptr.upval;}
-nas_ghost& var::obj  () {return *val.gcobj->ptr.obj;  }
-nas_co&    var::co   () {return *val.gcobj->ptr.co;   }
-
-const var zero=var::num(0);
-const var one =var::num(1);
-const var nil =var::nil();
-
-struct gc {
-    ghost_register_table global_ghost_type_table;
-    /* main context temporary storage */
-    context mctx;
-
-    /* runtime context */
-    context* rctx;
-    nas_co* cort=nullptr; // running coroutine
-
-    /*  temporary space used in builtin/module functions */
-    var temp=nil;
-
-    /* constants and memory pool */
-    std::vector<var> strs;        // reserved address for const vm_str
-    std::vector<var> env_argv;    // command line arguments
-    std::vector<nas_val*> memory; // gc memory
-    std::vector<nas_val*> unused[gc_type_size]; // gc free list
-
-    /* heap increase size */
-    u32 incr[gc_type_size]={
-        128, // vm_str
-        128, // vm_vec
-        64,  // vm_hash
-        128, // vm_func
-        256, // vm_upval
-        16,  // vm_obj
-        16   // vm_co
-    };
-
-    /* values for analysis */
-    u64 size[gc_type_size];
-    u64 gcnt[gc_type_size];
-    u64 acnt[gc_type_size];
-    i64 worktime=0;
-
-    gc(context* _ctx): rctx(_ctx) {}
-
-private:
-    /* gc functions */
-    void mark();
-    void mark_context(std::vector<var>&);
-    void mark_var(std::vector<var>&, var&);
-    inline void mark_vec(std::vector<var>&, nas_vec&);
-    inline void mark_hash(std::vector<var>&, nas_hash&);
-    inline void mark_func(std::vector<var>&, nas_func&);
-    inline void mark_upval(std::vector<var>&, nas_upval&);
-    inline void mark_co(std::vector<var>&, nas_co&);
-    void sweep();
-
-public:
-    void extend(u8);
-    void init(const std::vector<string>&, const std::vector<string>&);
-    void clear();
-    void info();
-    var alloc(const u8);
-    void ctxchg(nas_co&);
-    void ctxreserve();
-
-public:
-    var newstr(char c) {
-        var s=alloc(vm_str);
-        s.str()=c;
-        return s;
-    }
-
-    var newstr(const char* buff) {
-        var s=alloc(vm_str);
-        s.str()=buff;
-        return s;
-    }
-
-    var newstr(const string& buff) {
-        var s=alloc(vm_str);
-        s.str()=buff;
-        return s;
-    }
-};
-
-void gc::mark() {
-    std::vector<var> bfs;
-    mark_context(bfs);
-    
-    while(!bfs.empty()) {
-        var value=bfs.back();
-        bfs.pop_back();
-        if (value.type<=vm_num ||
-            value.val.gcobj->mark!=gc_status::uncollected) {
-            continue;
-        }
-        mark_var(bfs, value);
-    }
-}
-
-void gc::mark_context(std::vector<var>& bfs_queue) {
-
-    // scan now running context, this context maybe related to coroutine or main
-    for(var* i=rctx->stack;i<=rctx->top;++i) {
-        bfs_queue.push_back(*i);
-    }
-    bfs_queue.push_back(rctx->funcr);
-    bfs_queue.push_back(rctx->upvalr);
-    bfs_queue.push_back(temp);
-
-    if (!cort) {
-        return;
-    }
-
-    // coroutine is running, so scan main process stack from mctx
-    for(var* i=mctx.stack;i<=mctx.top;++i) {
-        bfs_queue.push_back(*i);
-    }
-    bfs_queue.push_back(mctx.funcr);
-    bfs_queue.push_back(mctx.upvalr);
-}
-
-void gc::mark_var(std::vector<var>& bfs_queue, var& value) {
-    value.val.gcobj->mark=gc_status::found;
-    switch(value.type) {
-        case vm_vec: mark_vec(bfs_queue, value.vec()); break;
-        case vm_hash: mark_hash(bfs_queue, value.hash()); break;
-        case vm_func: mark_func(bfs_queue, value.func()); break;
-        case vm_upval: mark_upval(bfs_queue, value.upval()); break;
-        case vm_co: mark_co(bfs_queue, value.co()); break;
-        default: break;
-    }
-}
-
-void gc::mark_vec(std::vector<var>& bfs_queue, nas_vec& vec) {
-    for(auto& i:vec.elems) {
-        bfs_queue.push_back(i);
-    }
-}
-
-void gc::mark_hash(std::vector<var>& bfs_queue, nas_hash& hash) {
-    for(auto& i:hash.elems) {
-        bfs_queue.push_back(i.second);
-    }
-}
-
-void gc::mark_func(std::vector<var>& bfs_queue, nas_func& function) {
-    for(auto& i:function.local) {
-        bfs_queue.push_back(i);
-    }
-    for(auto& i:function.upval) {
-        bfs_queue.push_back(i);
-    }
-}
-
-void gc::mark_upval(std::vector<var>& bfs_queue, nas_upval& upval) {
-    for(auto& i:upval.elems) {
-        bfs_queue.push_back(i);
-    }
-}
-
-void gc::mark_co(std::vector<var>& bfs_queue, nas_co& co) {
-    bfs_queue.push_back(co.ctx.funcr);
-    bfs_queue.push_back(co.ctx.upvalr);
-    for(var* i=co.stack;i<=co.ctx.top;++i) {
-        bfs_queue.push_back(*i);
-    }
-}
-
-void gc::sweep() {
-    for(auto i:memory) {
-        if (i->mark==gc_status::uncollected) {
-            i->clear();
-            unused[i->type-vm_str].push_back(i);
-            i->mark=gc_status::collected;
-        } else if (i->mark==gc_status::found) {
-            i->mark=gc_status::uncollected;
-        }
-    }
-}
-
-void gc::extend(u8 type) {
-    const u8 index=type-vm_str;
-    size[index]+=incr[index];
-
-    for(u32 i=0;i<incr[index];++i) {
-        nas_val* tmp=new(std::nothrow) nas_val(type);
-
-        if (!tmp) {
-            std::cerr<<"nasal_gc.h: gc::extend: ";
-            std::cerr<<"failed to allocate memory\n";
-            std::exit(1);
-        }
-
-        // add to heap
-        memory.push_back(tmp);
-        unused[index].push_back(tmp);
-    }
-
-    incr[index]=incr[index]+incr[index]/2;
-}
-
-void gc::init(const std::vector<string>& s, const std::vector<string>& argv) {
-    // initialize function register
-    rctx->funcr=nil;
-    worktime=0;
-
-    // initialize counters
-    for(u8 i=0;i<gc_type_size;++i) {
-        size[i]=gcnt[i]=acnt[i]=0;
-    }
-
-    // coroutine pointer set to nullptr
-    cort=nullptr;
-
-    // init constant strings
-    strs.resize(s.size());
-    for(u32 i=0;i<strs.size();++i) {
-        strs[i]=var::gcobj(new nas_val(vm_str));
-        strs[i].val.gcobj->unmut=1;
-        strs[i].str()=s[i];
-    }
-
-    // record arguments
-    env_argv.resize(argv.size());
-    for(usize i=0;i<argv.size();++i) {
-        env_argv[i]=var::gcobj(new nas_val(vm_str));
-        env_argv[i].val.gcobj->unmut=1;
-        env_argv[i].str()=argv[i];
-    }
-}
-
-void gc::clear() {
-    for(auto i:memory) {
-        delete i;
-    }
-    memory.clear();
-    for(u8 i=0;i<gc_type_size;++i) {
-        unused[i].clear();
-    }
-    for(auto& i:strs) {
-        delete i.val.gcobj;
-    }
-    strs.clear();
-    env_argv.clear();
-}
-
-void gc::info() {
-    using std::left;
-    using std::setw;
-    using std::setfill;
-    const char* name[]={"str  ","vec  ","hash ","func ","upval","obj  ","co   "};
-    std::clog<<"\ngc info (gc count|alloc count|memory size)\n";
-
-    usize ident=0;
-    for(u8 i=0;i<gc_type_size;++i) {
-#ifndef _MSC_VER
-        usize len=std::max({
-            std::to_string(gcnt[i]).length(),
-            std::to_string(acnt[i]).length(),
-            std::to_string(size[i]).length()
-        });
-#else // VS is a piece of shit
-        usize len=std::to_string(gcnt[i]).length();
-        ident=ident<len?len:ident;
-        len=std::to_string(acnt[i]).length();
-        ident=ident<len?len:ident;
-        len=std::to_string(size[i]).length();
-#endif
-        ident=ident<len?len:ident;
-    }
-
-    double total=0;
-    for(u8 i=0;i<gc_type_size;++i) {
-        if (gcnt[i] || acnt[i] || size[i]) {
-            total+=gcnt[i];
-            std::clog<<" "<<name[i];
-            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<gcnt[i];
-            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<acnt[i];
-            std::clog<<" | "<<left<<setw(ident)<<setfill(' ')<<size[i];
-            std::clog<<"\n";
-        }
-    }
-
-    double sec=worktime*1.0/1000000000; // seconds
-    std::clog<<" time  | "<<(sec<0.1? sec*1000:sec)<<(sec<0.1? " ms\n":" s\n");
-    if (total) {
-        std::clog<<" avg   | "<<sec/total*1000<<" ms\n";
-    }
-    std::clog<<"\n";
-}
-
-var gc::alloc(u8 type) {
-    using clk=std::chrono::high_resolution_clock;
-    const u8 index=type-vm_str;
-    ++acnt[index];
-    if (unused[index].empty()) {
-        ++gcnt[index];
-        auto begin=clk::now();
-        mark();
-        sweep();
-        worktime+=(clk::now()-begin).count();
-    }
-    if (unused[index].empty()) {
-        extend(type);
-    }
-    var ret=var::gcobj(unused[index].back());
-    ret.val.gcobj->mark=gc_status::uncollected;
-    unused[index].pop_back();
-    return ret;
-}
-
-void gc::ctxchg(nas_co& co) {
-    // store running state to main context
-    mctx=*rctx;
-
-    // restore coroutine context state
-    *rctx=co.ctx;
-
-    // set coroutine pointer
-    cort=&co;
-
-    // set coroutine state to running
-    cort->status=coroutine_status::running;
-}
-
-void gc::ctxreserve() {
-    // pc=0 means this coroutine is finished
-    cort->status=rctx->pc?
-        coroutine_status::suspended:
-        coroutine_status::dead;
-
-    // store running state to coroutine
-    cort->ctx=*rctx;
-
-    // restore main context state
-    *rctx=mctx;
-
-    // set coroutine pointer to nullptr
-    cort=nullptr;
-}
-
-// use to print error log and return error value
-var nas_err(const string& error_function_name, const string& info) {
-    std::cerr<<"[vm] "<<error_function_name<<": "<<info<<"\n";
-    return var::none();
-}
-
-// module function type
-typedef var (*module_func)(var*, usize, gc*);
-
-// module function stores in tables with this type, end with {nullptr,nullptr}
-struct module_func_info {
-    const char* name;
-    module_func fd;
-};
-
-// module function "get" type
-typedef module_func_info* (*get_func_ptr)(ghost_register_table*);
diff --git a/nasal_import.h b/nasal_import.h
deleted file mode 100644
index 984fcf8..0000000
--- a/nasal_import.h
+++ /dev/null
@@ -1,226 +0,0 @@
-#pragma once
-
-#ifndef _MSC_VER
-#include <unistd.h>
-#else
-#define _CRT_SECURE_NO_DEPRECATE 1
-#define _CRT_NONSTDC_NO_DEPRECATE 1
-#include <io.h>
-#endif
-
-#ifdef _MSC_VER
-#define F_OK 0
-#endif
-
-#include "nasal.h"
-#include "nasal_ast.h"
-#include "nasal_lexer.h"
-#include "nasal_parse.h"
-
-class linker{
-private:
-    bool show_path;
-    bool lib_loaded;
-    error& err;
-    std::vector<string> files;
-    std::vector<string> envpath;
-
-    bool imptchk(const ast&);
-    bool exist(const string&);
-    void link(ast&, ast&&);
-    string path(const ast&);
-    string findf(const string&);
-    ast fimpt(ast&);
-    ast libimpt();
-    ast load(ast&, u16);
-public:
-    linker(error&);
-    const error& link(parse&, const string&, bool);
-    const std::vector<string>& filelist() const {return files;}
-};
-
-linker::linker(error& e): show_path(false), lib_loaded(false), err(e) {
-    char sep=is_windows()? ';':':';
-    string PATH=getenv("PATH");
-    usize last=0;
-    usize pos=PATH.find(sep, 0);
-    while(pos!=string::npos) {
-        string dirpath=PATH.substr(last, pos-last);
-        if (dirpath.length()) {
-            envpath.push_back(dirpath);
-        }
-        last=pos+1;
-        pos=PATH.find(sep, last);
-    }
-    if (last!=PATH.length()) {
-        envpath.push_back(PATH.substr(last));
-    }
-}
-
-string linker::path(const ast& node) {
-    if (node[1].type()==ast_callf) {
-        return node[1][0].str();
-    }
-    string fpath=".";
-    for(usize i=1;i<node.size();++i) {
-        fpath+=(is_windows()? "\\":"/")+node[i].str();
-    }
-    return fpath+".nas";
-}
-
-string linker::findf(const string& fname) {
-    // first add file name itself into the file path
-    std::vector<string> fpath={fname};
-
-    // generate search path from environ path
-    for(auto&p:envpath) {
-        fpath.push_back(p+(is_windows()? "\\":"/")+fname);
-    }
-
-    // search file
-    for(auto& i:fpath) {
-        if (access(i.c_str(), F_OK)!=-1) {
-            return i;
-        }
-    }
-
-    // we will find lib.nas in nasal std directory
-    if (fname=="lib.nas") {
-        return is_windows()? findf("std\\lib.nas"):findf("std/lib.nas");
-    }
-    if (!show_path) {
-        err.err("link", "cannot find file <"+fname+">");
-        return "";
-    }
-    string paths="";
-    for(auto& i:fpath) {
-        paths+="  "+i+"\n";
-    }
-    err.err("link", "cannot find file <"+fname+"> in these paths:\n"+paths);
-    return "";
-}
-
-bool linker::imptchk(const ast& node) {
-// only these two kinds of node can be recognized as 'import':
-/*
-    call
-    |_id:import
-    |_callh:std
-    |_callh:file
-*/
-    if (node.type()==ast_call && node[0].str()=="import" && node.size()>=2 && node[1].type()==ast_callh) {
-        for(usize i=1;i<node.size();++i) {
-            if (node[i].type()!=ast_callh) {
-                return false;
-            }
-        }
-        return true;
-    }
-/*
-    call
-    |_id:import
-    |_call_func
-      |_string:'filename'
-*/
-    return (
-        node.type()==ast_call &&
-        node[0].str()=="import" &&
-        node.size()==2 &&
-        node[1].type()==ast_callf &&
-        node[1].size()==1 &&
-        node[1][0].type()==ast_str
-    );
-}
-
-bool linker::exist(const string& file) {
-    // avoid importing the same file
-    for(auto& fname:files) {
-        if (file==fname) {
-            return true;
-        }
-    }
-    files.push_back(file);
-    return false;
-}
-
-void linker::link(ast& root, ast&& add_root) {
-    // add children of add_root to the back of root
-    for(auto& i:add_root.child()) {
-        root.add(std::move(i));
-    }
-}
-
-ast linker::fimpt(ast& node) {
-    lexer lex(err);
-    parse par(err);
-    // get filename and set node to ast_null
-    string filename=path(node);
-    node.clear();
-
-    // avoid infinite loading loop
-    filename=findf(filename);
-    if (!filename.length() || exist(filename)) {
-        return {{0, 0, 0, 0, filename}, ast_root};
-    }
-    
-    // start importing...
-    lex.scan(filename);
-    par.compile(lex);
-    ast tmp=std::move(par.tree());
-
-    // check if tmp has 'import'
-    return load(tmp, files.size()-1);
-}
-
-ast linker::libimpt() {
-    lexer lex(err);
-    parse par(err);
-    string filename=findf("lib.nas");
-    if (!filename.length()) {
-        return {{0, 0, 0, 0, filename}, ast_root};
-    }
-
-    // avoid infinite loading loop
-    if (exist(filename)) {
-        return {{0, 0, 0, 0, filename}, ast_root};
-    }
-    
-    // start importing...
-    lex.scan(filename);
-    par.compile(lex);
-    ast tmp=std::move(par.tree());
-
-    // check if tmp has 'import'
-    return load(tmp, files.size()-1);
-}
-
-ast linker::load(ast& root, u16 fileindex) {
-    ast tree({0, 0, 0, 0, files[fileindex]}, ast_root);
-    if (!lib_loaded) {
-        link(tree, libimpt());
-        lib_loaded=true;
-    }
-    for(auto& i:root.child()) {
-        if (imptchk(i)) {
-            link(tree, fimpt(i));
-        } else {
-            break;
-        }
-    }
-    // add root to the back of tree
-    ast file_head({0, 0, 0, 0, files[fileindex]}, ast_file);
-    file_head.set_num(fileindex);
-    tree.add(std::move(file_head));
-    link(tree, std::move(root));
-    return tree;
-}
-
-const error& linker::link(parse& parse, const string& self, bool spath=false) {
-    show_path=spath;
-    // initializing
-    files={self};
-    // scan root and import files,then generate a new ast and return to import_ast
-    // the main file's index is 0
-    parse.tree()=load(parse.tree(), 0);
-    return err;
-}
diff --git a/nasal_lexer.h b/nasal_lexer.h
deleted file mode 100644
index b6cae34..0000000
--- a/nasal_lexer.h
+++ /dev/null
@@ -1,506 +0,0 @@
-#pragma once
-#ifdef _MSC_VER
-#pragma warning (disable:4244)
-#pragma warning (disable:4267)
-#pragma warning (disable:4102)
-#endif
-
-#include <cstring>
-#include <sstream>
-#include <vector>
-#include <unordered_map>
-#include <sys/stat.h>
-
-#include "nasal.h"
-#include "nasal_err.h"
-
-#ifdef _MSC_VER
-#define S_ISREG(m) (((m)&0xF000)==0x8000)
-#endif
-
-enum class tok:u32 {
-    null=0,   // null token (default token type)
-    num,      // number literal
-    str,      // string literal
-    id,       // identifier
-    tktrue,   // keyword true
-    tkfalse,  // keyword false
-    rfor,     // loop keyword for
-    forindex, // loop keyword forindex
-    foreach,  // loop keyword foreach
-    rwhile,   // loop keyword while
-    var,      // keyword for definition
-    func,     // keyword for definition of function
-    brk,      // loop keyword break
-    cont,     // loop keyword continue
-    ret,      // function keyword return
-    rif,      // condition expression keyword if
-    elsif,    // condition expression keyword elsif
-    relse,    // condition expression keyword else
-    tknil,    // nil literal
-    lcurve,   // (
-    rcurve,   // )
-    lbracket, // [
-    rbracket, // ]
-    lbrace,   // {
-    rbrace,   // }
-    semi,     // ;
-    opand,    // operator and
-    opor,     // operator or
-    comma,    // ,
-    dot,      // .
-    ellipsis, // ...
-    quesmark, // ?
-    colon,    // :
-    add,      // operator +
-    sub,      // operator -
-    mult,     // operator *
-    div,      // operator /
-    floater,  // operator ~ and binary operator ~
-    btand,    // bitwise operator &
-    btor,     // bitwise operator |
-    btxor,    // bitwise operator ^
-    opnot,    // operator !
-    eq,       // operator =
-    addeq,    // operator +=
-    subeq,    // operator -=
-    multeq,   // operator *=
-    diveq,    // operator /=
-    lnkeq,    // operator ~=
-    btandeq,  // operator &=
-    btoreq,   // operator |=
-    btxoreq,  // operator ^=
-    cmpeq,    // operator ==
-    neq,      // operator !=
-    less,     // operator <
-    leq,      // operator <=
-    grt,      // operator >
-    geq,      // operator >=
-    eof       // <eof> end of token list
-};
-
-struct token {
-    span loc;    // location
-    tok type;    // token type
-    string str;  // content
-    token() = default;
-    token(const token&) = default;
-};
-
-class lexer {
-private:
-    u32    line;
-    u32    column;
-    usize  ptr;
-    string filename;
-    string res;
-    error& err;
-    std::vector<token> toks;
-    const std::unordered_map<string,tok> typetbl {
-        {"true"    ,tok::tktrue  },
-        {"false"   ,tok::tkfalse },
-        {"for"     ,tok::rfor    },
-        {"forindex",tok::forindex},
-        {"foreach" ,tok::foreach },
-        {"while"   ,tok::rwhile  },
-        {"var"     ,tok::var     },
-        {"func"    ,tok::func    },
-        {"break"   ,tok::brk     },
-        {"continue",tok::cont    },
-        {"return"  ,tok::ret     },
-        {"if"      ,tok::rif     },
-        {"elsif"   ,tok::elsif   },
-        {"else"    ,tok::relse   },
-        {"nil"     ,tok::tknil   },
-        {"("       ,tok::lcurve  },
-        {")"       ,tok::rcurve  },
-        {"["       ,tok::lbracket},
-        {"]"       ,tok::rbracket},
-        {"{"       ,tok::lbrace  },
-        {"}"       ,tok::rbrace  },
-        {";"       ,tok::semi    },
-        {"and"     ,tok::opand   },
-        {"or"      ,tok::opor    },
-        {","       ,tok::comma   },
-        {"."       ,tok::dot     },
-        {"..."     ,tok::ellipsis},
-        {"?"       ,tok::quesmark},
-        {":"       ,tok::colon   },
-        {"+"       ,tok::add     },
-        {"-"       ,tok::sub     },
-        {"*"       ,tok::mult    },
-        {"/"       ,tok::div     },
-        {"~"       ,tok::floater },
-        {"&"       ,tok::btand   },
-        {"|"       ,tok::btor    },
-        {"^"       ,tok::btxor   },
-        {"!"       ,tok::opnot   },
-        {"="       ,tok::eq      },
-        {"+="      ,tok::addeq   },
-        {"-="      ,tok::subeq   },
-        {"*="      ,tok::multeq  },
-        {"/="      ,tok::diveq   },
-        {"~="      ,tok::lnkeq   },
-        {"&="      ,tok::btandeq },
-        {"|="      ,tok::btoreq  },
-        {"^="      ,tok::btxoreq },
-        {"=="      ,tok::cmpeq   },
-        {"!="      ,tok::neq     },
-        {"<"       ,tok::less    },
-        {"<="      ,tok::leq     },
-        {">"       ,tok::grt     },
-        {">="      ,tok::geq     }
-    };
-
-    tok get_type(const string&);
-    bool skip(char);
-    bool is_id(char);
-    bool is_hex(char);
-    bool is_oct(char);
-    bool is_dec(char);
-    bool is_str(char);
-    bool is_single_opr(char);
-    bool is_calc_opr(char);
-
-    void skip_note();
-    void err_char();
-
-    void open(const string&);
-    string utf8_gen();
-    token id_gen();
-    token num_gen();
-    token str_gen();
-    token single_opr();
-    token dots();
-    token calc_opr();
-public:
-    lexer(error& e): line(1), column(0), ptr(0), filename(""), res(""), err(e) {}
-    const error& scan(const string&);
-    const std::vector<token>& result() const {return toks;}
-};
-
-bool lexer::skip(char c) {
-    return c==' '||c=='\n'||c=='\t'||c=='\r'||c==0;
-}
-
-bool lexer::is_id(char c) {
-    return (c=='_')||('a'<=c && c<='z')||('A'<=c&&c<='Z')||(c<0);   
-}
-
-bool lexer::is_hex(char c) {
-    return ('0'<=c&&c<='9')||('a'<=c&&c<='f')||('A'<=c && c<='F');
-}
-
-bool lexer::is_oct(char c) {
-    return '0'<=c&&c<='7';
-}
-
-bool lexer::is_dec(char c) {
-    return '0'<=c&&c<='9';
-}
-
-bool lexer::is_str(char c) {
-    return c=='\''||c=='\"'||c=='`';
-}
-
-bool lexer::is_single_opr(char c) {
-    return (
-        c=='('||c==')'||c=='['||c==']'||
-        c=='{'||c=='}'||c==','||c==';'||
-        c==':'||c=='?'||c=='`'||c=='@'||
-        c=='%'||c=='$'||c=='\\'
-    );
-}
-
-bool lexer::is_calc_opr(char c) {
-    return (
-        c=='='||c=='+'||c=='-'||c=='*'||
-        c=='!'||c=='/'||c=='<'||c=='>'||
-        c=='~'||c=='|'||c=='&'||c=='^'
-    );
-}
-
-void lexer::skip_note() {
-    // avoid note, after this process ptr will point to a '\n', so next loop line counter+1
-    while(++ptr<res.size() && res[ptr]!='\n') {}
-}
-
-void lexer::err_char() {
-    ++column;
-    char c=res[ptr++];
-    err.err("lexer", {line, column-1, line, column, filename}, "invalid character 0x"+chrhex(c));
-    err.fatal("lexer", "fatal error occurred, stop");
-}
-
-void lexer::open(const string& file) {
-    // check file exsits and it is a regular file
-    struct stat buffer;
-    if (stat(file.c_str(), &buffer)==0 && !S_ISREG(buffer.st_mode)) {
-        err.err("lexer", "<"+file+"> is not a regular file");
-        err.chkerr();
-    }
-
-    // load
-    filename=file;
-    std::ifstream in(file, std::ios::binary);
-    if (in.fail()) {
-        err.err("lexer", "failed to open <"+file+">");
-    } else {
-        err.load(file);
-    }
-    std::stringstream ss;
-    ss<<in.rdbuf();
-    res=ss.str();
-}
-
-tok lexer::get_type(const string& str) {
-    return typetbl.count(str)?typetbl.at(str):tok::null;
-}
-
-string lexer::utf8_gen() {
-    string str="";
-    while(ptr<res.size() && res[ptr]<0) {
-        string tmp="";
-        u32 nbytes=utf8_hdchk(res[ptr]);
-        if (!nbytes) {
-            ++ptr;
-            ++column;
-            continue;
-        }
-
-        tmp+=res[ptr++];
-        for(u32 i=0;i<nbytes;++i,++ptr) {
-            if (ptr<res.size() && (res[ptr]&0xc0)==0x80) {
-                tmp+=res[ptr];
-            }
-        }
-
-        // utf8 character's total length is 1+nbytes
-        if (tmp.length()!=1+nbytes) {
-            ++column;
-            string utf_info="0x"+chrhex(tmp[0]);
-            for(u32 i=1;i<tmp.size();++i) {
-                utf_info+=" 0x"+chrhex(tmp[i]);
-            }
-            err.err("lexer", {line, column-1, line, column, filename}, "invalid utf-8 <"+utf_info+">");
-            err.fatal("lexer", "fatal error occurred, stop");
-        }
-        str+=tmp;
-        column+=2; // may have some problems because not all the unicode takes 2 space
-    }
-    return str;
-}
-
-token lexer::id_gen() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    string str="";
-    while(ptr<res.size() && (is_id(res[ptr])||is_dec(res[ptr]))) {
-        if (res[ptr]<0) { // utf-8
-            str+=utf8_gen();
-        } else { // ascii
-            str+=res[ptr++];
-            ++column;
-        }
-    }
-    tok type=get_type(str);
-    return {{begin_line, begin_column, line, column, filename}, (type!=tok::null)?type:tok::id, str};
-}
-
-token lexer::num_gen() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    // generate hex number
-    if (ptr+1<res.size() && res[ptr]=='0' && res[ptr+1]=='x') {
-        string str="0x";
-        ptr+=2;
-        while(ptr<res.size() && is_hex(res[ptr])) {
-            str+=res[ptr++];
-        }
-        column+=str.length();
-        if (str.length()<3) { // "0x"
-            err.err("lexer", {begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
-        }
-        return {{begin_line, begin_column, line, column, filename}, tok::num, str};
-    } else if (ptr+1<res.size() && res[ptr]=='0' && res[ptr+1]=='o') { // generate oct number
-        string str="0o";
-        ptr+=2;
-        while(ptr<res.size() && is_oct(res[ptr])) {
-            str+=res[ptr++];
-        }
-        bool erfmt=false;
-        while(ptr<res.size() && (is_dec(res[ptr]) || is_hex(res[ptr]))) {
-            erfmt=true;
-            str+=res[ptr++];
-        }
-        column+=str.length();
-        if (str.length()==2 || erfmt) {
-            err.err("lexer", {begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
-        }
-        return {{begin_line, begin_column, line, column, filename}, tok::num, str};
-    }
-    // generate dec number
-    // dec number -> [0~9][0~9]*(.[0~9]*)(e|E(+|-)0|[1~9][0~9]*)
-    string str="";
-    while(ptr<res.size() && is_dec(res[ptr])) {
-        str+=res[ptr++];
-    }
-    if (ptr<res.size() && res[ptr]=='.') {
-        str+=res[ptr++];
-        while(ptr<res.size() && is_dec(res[ptr])) {
-            str+=res[ptr++];
-        }
-        // "xxxx." is not a correct number
-        if (str.back()=='.') {
-            column+=str.length();
-            err.err("lexer",{begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
-            return {{begin_line, begin_column, line, column, filename}, tok::num, "0"};
-        }
-    }
-    if (ptr<res.size() && (res[ptr]=='e' || res[ptr]=='E')) {
-        str+=res[ptr++];
-        if (ptr<res.size() && (res[ptr]=='-' || res[ptr]=='+')) {
-            str+=res[ptr++];
-        }
-        while(ptr<res.size() && is_dec(res[ptr])) {
-            str+=res[ptr++];
-        }
-        // "xxxe(-|+)" is not a correct number
-        if (str.back()=='e' || str.back()=='E' || str.back()=='-' || str.back()=='+') {
-            column+=str.length();
-            err.err("lexer",{begin_line, begin_column, line, column, filename}, "invalid number `"+str+"`");
-            return {{begin_line, begin_column, line, column, filename}, tok::num, "0"};
-        }
-    }
-    column+=str.length();
-    return {{begin_line, begin_column, line, column, filename}, tok::num, str};
-}
-
-token lexer::str_gen() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    string str="";
-    const char begin=res[ptr];
-    ++column;
-    while(++ptr<res.size() && res[ptr]!=begin) {
-        ++column;
-        if (res[ptr]=='\n') {
-            column=0;
-            ++line;
-        }
-        if (res[ptr]=='\\' && ptr+1<res.size()) {
-            ++column;
-            ++ptr;
-            switch(res[ptr]) {
-                case '0': str+='\0';    break;
-                case 'a': str+='\a';    break;
-                case 'b': str+='\b';    break;
-                case 'e': str+='\033';  break;
-                case 't': str+='\t';    break;
-                case 'n': str+='\n';    break;
-                case 'v': str+='\v';    break;
-                case 'f': str+='\f';    break;
-                case 'r': str+='\r';    break;
-                case '?': str+='\?';    break;
-                case '\\':str+='\\';    break;
-                case '\'':str+='\'';    break;
-                case '\"':str+='\"';    break;
-                default:  str+=res[ptr];break;
-            }
-            if (res[ptr]=='\n') {
-                column=0;
-                ++line;
-            }
-            continue;
-        }
-        str+=res[ptr];
-    }
-    // check if this string ends with a " or '
-    if (ptr++>=res.size()) {
-        err.err("lexer", {begin_line, begin_column, line, column, filename}, "get EOF when generating string");
-        return {{begin_line, begin_column, line, column, filename}, tok::str, str};
-    }
-    ++column;
-    if (begin=='`' && str.length()!=1) {
-        err.err("lexer", {begin_line, begin_column, line, column, filename}, "\'`\' is used for string including one character");
-    }
-    return {{begin_line, begin_column, line, column, filename}, tok::str, str};
-}
-
-token lexer::single_opr() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    string str(1,res[ptr]);
-    ++column;
-    tok type=get_type(str);
-    if (type==tok::null) {
-        err.err("lexer", {begin_line, begin_column, line, column, filename}, "invalid operator `"+str+"`");
-    }
-    ++ptr;
-    return {{begin_line, begin_column, line, column, filename}, type, str};
-}
-
-token lexer::dots() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    string str=".";
-    if (ptr+2<res.size() && res[ptr+1]=='.' && res[ptr+2]=='.') {
-        str+="..";
-    }
-    ptr+=str.length();
-    column+=str.length();
-    return {{begin_line, begin_column, line, column, filename}, get_type(str), str};
-}
-
-token lexer::calc_opr() {
-    u32 begin_line=line;
-    u32 begin_column=column;
-    // get calculation operator
-    string str(1,res[ptr++]);
-    if (ptr<res.size() && res[ptr]=='=') {
-        str+=res[ptr++];
-    }
-    column+=str.length();
-    return {{begin_line, begin_column, line, column, filename}, get_type(str), str};
-}
-
-const error& lexer::scan(const string& file) {
-    line=1;
-    column=0;
-    ptr=0;
-    open(file);
-
-    while(ptr<res.size()) {
-        while(ptr<res.size() && skip(res[ptr])) {
-            // these characters will be ignored, and '\n' will cause ++line
-            ++column;
-            if (res[ptr++]=='\n') {
-                ++line;
-                column=0;
-            }
-        }
-        if (ptr>=res.size()) {
-            break;
-        }
-        if (is_id(res[ptr])) {
-            toks.push_back(id_gen());
-        } else if (is_dec(res[ptr])) {
-            toks.push_back(num_gen());
-        } else if (is_str(res[ptr])) {
-            toks.push_back(str_gen());
-        } else if (is_single_opr(res[ptr])) {
-            toks.push_back(single_opr());
-        } else if (res[ptr]=='.') {
-            toks.push_back(dots());
-        } else if (is_calc_opr(res[ptr])) {
-            toks.push_back(calc_opr());
-        } else if (res[ptr]=='#') {
-            skip_note();
-        } else {
-            err_char();
-        }
-    }
-    toks.push_back({{line, column, line, column, filename}, tok::eof, "<eof>"});
-    res="";
-    return err;
-}
diff --git a/nasal_opcode.h b/nasal_opcode.h
deleted file mode 100644
index 8c5c270..0000000
--- a/nasal_opcode.h
+++ /dev/null
@@ -1,233 +0,0 @@
-#pragma once
-
-#include "nasal.h"
-#include "nasal_builtin.h"
-
-#include <iostream>
-
-enum op_code_type:u8 {
-    op_exit,   // stop the virtual machine
-    op_intg,   // global scope size, set stack top
-    op_intl,   // local scope size
-    op_loadg,  // load global value
-    op_loadl,  // load local value
-    op_loadu,  // load upvalue
-    op_pnum,   // push constant number to the stack
-    op_pnil,   // push constant nil to the stack
-    op_pstr,   // push constant string to the stack
-    op_newv,   // push new vector with initial values from stack
-    op_newh,   // push new hash to the stack
-    op_newf,   // push new function to the stack
-    op_happ,   // hash append
-    op_para,   // normal  parameter
-    op_deft,   // default parameter
-    op_dyn,    // dynamic parameter
-    op_lnot,   // ! logical negation
-    op_usub,   // - negation
-    op_bnot,   // ~ bitwise not static_cast<i32>
-    op_btor,   // | bitwise or
-    op_btxor,  // ^ bitwise xor
-    op_btand,  // & bitwise and
-    op_add,    // +
-    op_sub,    // -
-    op_mul,    // *
-    op_div,    // /
-    op_lnk,    // ~
-    op_addc,   // + const
-    op_subc,   // - const
-    op_mulc,   // * const
-    op_divc,   // / const
-    op_lnkc,   // ~ const
-    op_addeq,  // += maybe pop stack top
-    op_subeq,  // -= maybe pop stack top
-    op_muleq,  // *= maybe pop stack top
-    op_diveq,  // /= maybe pop stack top
-    op_lnkeq,  // ~= maybe pop stack top
-    op_btandeq,// &= maybe pop stack top
-    op_btoreq, // |= maybe pop stack top
-    op_btxoreq,// ^= maybe pop stack top
-    op_addeqc, // += const don't pop stack top
-    op_subeqc, // -= const don't pop stack top
-    op_muleqc, // *= const don't pop stack top
-    op_diveqc, // /= const don't pop stack top
-    op_lnkeqc, // ~= const don't pop stack top
-    op_addecp, // += const and pop stack top
-    op_subecp, // -= const and pop stack top
-    op_mulecp, // *= const and pop stack top
-    op_divecp, // /= const and pop stack top
-    op_lnkecp, // ~= concat const string and pop stack top
-    op_meq,    // = maybe pop stack top
-    op_eq,     // ==
-    op_neq,    // !=
-    op_less,   // <
-    op_leq,    // <=
-    op_grt,    // >
-    op_geq,    // >=
-    op_lessc,  // < const
-    op_leqc,   // <= const
-    op_grtc,   // > const
-    op_geqc,   // >= const
-    op_pop,    // pop a value out of stack top
-    op_jmp,    // jump absolute address with no condition
-    op_jt,     // used in operator and/or,jmp when condition is true and DO NOT POP
-    op_jf,     // used in conditional/loop,jmp when condition is false and POP STACK
-    op_cnt,    // add counter for forindex/foreach
-    op_findex, // index counter on the top of forindex_stack plus 1
-    op_feach,  // index counter on the top of forindex_stack plus 1 and get the value in vector
-    op_callg,  // get value in global scope
-    op_calll,  // get value in local scope
-    op_upval,  // get value in closure, high 16 as the index of upval, low 16 as the index of local
-    op_callv,  // call vec[index]
-    op_callvi, // call vec[immediate] (used in multi-assign/multi-define)
-    op_callh,  // call hash.label
-    op_callfv, // call function(vector as parameters)
-    op_callfh, // call function(hash as parameters)
-    op_callb,  // call builtin-function
-    op_slcbeg, // begin of slice like: vec[1,2,3:6,0,-1]
-    op_slcend, // end of slice
-    op_slc,    // slice like vec[1]
-    op_slc2,   // slice like vec[nil:10]
-    op_mcallg, // get memory space of value in global scope
-    op_mcalll, // get memory space of value in local scope
-    op_mupval, // get memory space of value in closure
-    op_mcallv, // get memory space of vec[index]
-    op_mcallh, // get memory space of hash.label
-    op_ret     // return
-};
-
-const char* opname[]={
-    "exit  ","intg  ","intl  ","loadg ",
-    "loadl ","loadu ","pnum  ","pnil  ",
-    "pstr  ","newv  ","newh  ","newf  ",
-    "happ  ","para  ","def   ","dyn   ",
-    "lnot  ","usub  ","bnot  ","btor  ",
-    "btxor ","btand ","add   ","sub   ",
-    "mult  ","div   ","lnk   ","addc  ",
-    "subc  ","multc ","divc  ","lnkc  ",
-    "addeq ","subeq ","muleq ","diveq ",
-    "lnkeq ","bandeq","boreq ","bxoreq",
-    "addeqc","subeqc","muleqc","diveqc",
-    "lnkeqc","addecp","subecp","mulecp",
-    "divecp","lnkecp","meq   ","eq    ",
-    "neq   ","less  ","leq   ","grt   ",
-    "geq   ","lessc ","leqc  ","grtc  ",
-    "geqc  ","pop   ","jmp   ","jt    ",
-    "jf    ","cnt   ","findx ","feach ",
-    "callg ","calll ","upval ","callv ",
-    "callvi","callh ","callfv","callfh",
-    "callb ","slcbeg","slcend","slc   ",
-    "slc2  ","mcallg","mcalll","mupval",
-    "mcallv","mcallh","ret   "
-};
-
-struct opcode {
-    u8  op;   // opcode
-    u16 fidx; // source code file index
-    u32 num;  // immediate num
-    u32 line; // location line of source code
-    opcode() = default;
-    opcode(const opcode&) = default;
-    opcode& operator=(const opcode&) = default;
-};
-
-class codestream {
-private:
-    opcode code;
-    const u32 index;
-    static const f64* nums;
-    static const string* strs;
-    static const string* files;
-public:
-    codestream(const opcode& c, const u32 i): code(c), index(i) {}
-    static void set(const f64*, const string*, const string*);
-    void dump(std::ostream&) const;
-};
-
-const f64* codestream::nums=nullptr;
-const string* codestream::strs=nullptr;
-const string* codestream::files=nullptr;
-
-void codestream::set(
-    const f64* numbuff,
-    const string* strbuff,
-    const string* filelist=nullptr
-) {
-    nums=numbuff;
-    strs=strbuff;
-    files=filelist;
-}
-
-void codestream::dump(std::ostream& out) const {
-    using std::setw;
-    using std::setfill;
-    using std::hex;
-    using std::dec;
-    auto op=code.op;
-    auto num=code.num;
-    out<<hex<<"0x"
-        <<setw(6)<<setfill('0')<<index<<"     "
-        <<setw(2)<<setfill('0')<<(u32)op<<" "
-        <<setw(2)<<setfill('0')<<((num>>16)&0xff)<<" "
-        <<setw(2)<<setfill('0')<<((num>>8)&0xff)<<" "
-        <<setw(2)<<setfill('0')<<(num&0xff)<<"     "
-        <<opname[op]<<"  "<<dec;
-    switch(op) {
-        case op_addeq: case op_subeq:
-        case op_muleq: case op_diveq:
-        case op_lnkeq: case op_meq:
-        case op_btandeq: case op_btoreq:
-        case op_btxoreq:
-            out<<hex<<"0x"<<num<<dec<<" sp-"<<num;break;
-        case op_addeqc: case op_subeqc:
-        case op_muleqc:case op_diveqc:
-            out<<hex<<"0x"<<num<<dec<<" ("<<nums[num]<<")";break;
-        case op_lnkeqc:
-            out<<hex<<"0x"<<num<<dec<<" ("<<rawstr(strs[num], 16)<<")";break;
-        case op_addecp: case op_subecp:
-        case op_mulecp: case op_divecp:
-            out<<hex<<"0x"<<num<<dec<<" ("<<nums[num]<<") sp-1";break;
-        case op_lnkecp:
-            out<<hex<<"0x"<<num<<dec<<" ("<<rawstr(strs[num], 16)<<") sp-1";break;
-        case op_addc: case op_subc:
-        case op_mulc: case op_divc:
-        case op_lessc: case op_leqc:
-        case op_grtc: case op_geqc:
-        case op_pnum:
-            out<<hex<<"0x"<<num<<dec<<" ("<<nums[num]<<")";break;
-        case op_callvi: case op_newv:
-        case op_callfv: case op_intg:
-        case op_intl: case op_findex:
-        case op_feach: case op_newf:
-        case op_jmp: case op_jt:
-        case op_jf: case op_callg:
-        case op_mcallg: case op_loadg:
-        case op_calll: case op_mcalll:
-        case op_loadl:
-            out<<hex<<"0x"<<num<<dec;break;
-        case op_callb:
-            out<<hex<<"0x"<<num<<" <"<<builtin[num].name
-                <<"@0x"<<(u64)builtin[num].func<<dec<<">";break;
-        case op_upval: case op_mupval:
-        case op_loadu:
-            out<<hex<<"0x"<<((num>>16)&0xffff)
-                <<"[0x"<<(num&0xffff)<<"]"<<dec;break;
-        case op_happ: case op_pstr:
-        case op_lnkc: case op_callh:
-        case op_mcallh: case op_para:
-        case op_deft: case op_dyn:
-            out<<hex<<"0x"<<num<<dec<<" ("<<rawstr(strs[num], 16)<<")";break;
-        default:
-            if (files) {
-                out<<hex<<"0x"<<num<<dec;
-            }
-            break;
-    }
-    if (files) {
-        out<<"("<<files[code.fidx]<<":"<<code.line<<")";
-    }
-}
-
-std::ostream& operator<<(std::ostream& out, const codestream& ins) {
-    ins.dump(out);
-    return out;
-}
\ No newline at end of file
diff --git a/nasal_opt.h b/nasal_opt.h
deleted file mode 100644
index 7ff9cd8..0000000
--- a/nasal_opt.h
+++ /dev/null
@@ -1,75 +0,0 @@
-#pragma once
-
-#include <cmath>
-
-#include "nasal_ast.h"
-
-void const_str(ast& root) {
-    auto& vec=root.child();
-    root.set_str(vec[0].str()+vec[1].str());
-    root.child().clear();
-    root.set_type(ast_str);
-}
-
-void const_num(ast& root) {
-    auto& vec=root.child();
-    f64 res=0;
-    switch(root.type()) {
-        case ast_add:    res=vec[0].num()+vec[1].num(); break;
-        case ast_sub:    res=vec[0].num()-vec[1].num(); break;
-        case ast_mult:   res=vec[0].num()*vec[1].num(); break;
-        case ast_div:    res=vec[0].num()/vec[1].num(); break;
-        case ast_less:   res=vec[0].num()<vec[1].num(); break;
-        case ast_leq:    res=vec[0].num()<=vec[1].num();break;
-        case ast_grt:    res=vec[0].num()>vec[1].num(); break;
-        case ast_geq:    res=vec[0].num()>=vec[1].num();break;
-        case ast_bitor:  res=i32(vec[0].num())|i32(vec[1].num()); break;
-        case ast_bitxor: res=i32(vec[0].num())^i32(vec[1].num()); break;
-        case ast_bitand: res=i32(vec[0].num())&i32(vec[1].num()); break;
-    }
-    // inf and nan will cause number hashmap error in codegen
-    if (std::isinf(res) || std::isnan(res)) {
-        return;
-    }
-    root.set_num(res);
-    root.child().clear();
-    root.set_type(ast_num);
-}
-
-void calc_const(ast& root) {
-    auto& vec=root.child();
-    for(auto& i:vec) {
-        calc_const(i);
-    }
-    if (vec.size()==1 && root.type()==ast_neg && vec[0].type()==ast_num) {
-        f64 res=-vec[0].num();
-        root.set_num(res);
-        root.child().clear();
-        root.set_type(ast_num);
-        return;
-    }
-    if (vec.size()!=2) {
-        return;
-    }
-    if (root.type()!=ast_add && root.type()!=ast_sub &&
-       root.type()!=ast_mult && root.type()!=ast_div &&
-       root.type()!=ast_link && root.type()!=ast_less &&
-       root.type()!=ast_leq && root.type()!=ast_grt &&
-       root.type()!=ast_geq && root.type()!=ast_bitor &&
-       root.type()!=ast_bitxor && root.type()!=ast_bitand) {
-        return;
-    }
-    if (root.type()==ast_link &&
-       vec[0].type()==ast_str && vec[1].type()==ast_str) {
-        const_str(root);
-    } else if (root.type()!=ast_link &&
-            vec[0].type()==ast_num && vec[1].type()==ast_num) {
-        const_num(root);
-    }
-}
-
-void optimize(ast& root) {
-    for(auto& i:root.child()) {
-        calc_const(i);
-    }
-}
diff --git a/nasal_parse.h b/nasal_parse.h
deleted file mode 100644
index d79e165..0000000
--- a/nasal_parse.h
+++ /dev/null
@@ -1,1111 +0,0 @@
-#pragma once
-
-#include <unordered_map>
-
-#include "nasal.h"
-#include "nasal_lexer.h"
-#include "nasal_ast.h"
-#include "nasal_err.h"
-
-/*
-              _,,,_                                       
-            .'     `'.                                    
-           /     ____ \      Fucking Nasal Parser
-           |  .-'_  _\/    /                              
-           \_/   a  a|    /                               
-           (,`     \ |         .----.                     
-            |     -' |        /|     '--.                 
-             \   '=  /        ||    ]|   `-.              
-             /`-.__.'         ||    ]|    ::|             
-          .-'`-.__ \__        ||    ]|    ::|             
-         /        ``  `.      ||    ]|    ::|             
-       _ |     \     \  \     \|    ]|   .-'              
-      / \|      \    |   \     L.__  .--'(                
-     |   |\      `.  |    \  ,---|_      \---------,      
-     |   | '.      './\    \/ .--._|=-    |_      /|      
-     |   \   '.     `'.'. /`\/ .-'          '.   / |      
-     |   |     `'.     `;-:-;`)|             |-./  |      
-     |   /_       `'--./_  ` )/'-------------')/)  |      
-     \   | `""""----"`\//`""`/,===..'`````````/ (  |      
-      |  |            / `---` `==='          /   ) |      
-      /  \           /                      /   (  |      
-     |    '------.  |'--------------------'|     ) |      
-      \           `-|                      |    /  |      
-       `--...,______|                      |   (   |      
-              | |   |                      |    ) ,|      
-              | |   |                      |   ( /||      
-              | |   |                      |   )/ `"      
-             /   \  |                      |  (/          
-           .' /I\ '.|                      |  /)          
-        .-'_.'/ \'. |                      | /            
-        ```  `"""` `| .-------------------.||             
-                    `"`                   `"`             
-*/
-
-class parse {
-#define thisspan (toks[ptr].loc)
-#define prevspan (ptr!=0? toks[ptr-1].loc:toks[ptr].loc)
-private:
-    u32 ptr;
-    u32 in_func; // count function block
-    u32 in_loop; // count loop block
-    const token* toks;
-    ast root;
-    error& err;
-    const std::unordered_map<tok,string> tokname {
-        {tok::rfor    ,"for"     },
-        {tok::forindex,"forindex"},
-        {tok::foreach ,"foreach" },
-        {tok::rwhile  ,"while"   },
-        {tok::var     ,"var"     },
-        {tok::func    ,"func"    },
-        {tok::brk     ,"break"   },
-        {tok::cont    ,"continue"},
-        {tok::ret     ,"return"  },
-        {tok::rif     ,"if"      },
-        {tok::elsif   ,"elsif"   },
-        {tok::relse   ,"else"    },
-        {tok::tknil   ,"nil"     },
-        {tok::lcurve  ,"("       },
-        {tok::rcurve  ,")"       },
-        {tok::lbracket,"["       },
-        {tok::rbracket,"]"       },
-        {tok::lbrace  ,"{"       },
-        {tok::rbrace  ,"}"       },
-        {tok::semi    ,";"       },
-        {tok::opand   ,"and"     },
-        {tok::opor    ,"or"      },
-        {tok::comma   ,","       },
-        {tok::dot     ,"."       },
-        {tok::ellipsis,"..."     },
-        {tok::quesmark,"?"       },
-        {tok::colon   ,":"       },
-        {tok::add     ,"+"       },
-        {tok::sub     ,"-"       },
-        {tok::mult    ,"*"       },
-        {tok::div     ,"/"       },
-        {tok::floater ,"~"       },
-        {tok::btand   ,"&"       },
-        {tok::btor    ,"|"       },
-        {tok::btxor   ,"^"       },
-        {tok::opnot   ,"!"       },
-        {tok::eq      ,"="       },
-        {tok::addeq   ,"+="      },
-        {tok::subeq   ,"-="      },
-        {tok::multeq  ,"*="      },
-        {tok::diveq   ,"/="      },
-        {tok::lnkeq   ,"~="      },
-        {tok::btandeq ,"&="      },
-        {tok::btoreq  ,"|="      },
-        {tok::btxoreq ,"^="      },
-        {tok::cmpeq   ,"=="      },
-        {tok::neq     ,"!="      },
-        {tok::less    ,"<"       },
-        {tok::leq     ,"<="      },
-        {tok::grt     ,">"       },
-        {tok::geq     ,">="      }
-    };
-
-    void die(const span&,string);
-    void next() {++ptr;}
-    void match(tok type, const char* info=nullptr);
-    bool lookahead(tok);
-    bool is_call(tok);
-    bool check_comma(const tok*);
-    bool check_tuple();
-    bool check_func_end(const ast&);
-    bool check_special_call();
-    bool need_semi_check(const ast&);
-    ast null();
-    ast nil();
-    ast num();
-    ast str();
-    ast id();
-    ast bools();
-    ast vec();
-    ast hash();
-    ast pair();
-    ast func();
-    ast params();
-    ast lcurve_expr();
-    ast expr();
-    ast exprs();
-    ast calc();
-    ast bitwise_or();
-    ast bitwise_xor();
-    ast bitwise_and();
-    ast or_expr();
-    ast and_expr();
-    ast cmp_expr();
-    ast additive_expr();
-    ast multive_expr();
-    ast unary();
-    ast scalar();
-    ast call_scalar();
-    ast callh();
-    ast callv();
-    ast callf();
-    ast subvec();
-    ast definition();
-    ast incurve_def();
-    ast outcurve_def();
-    ast multi_id();
-    ast multi_scalar();
-    ast multi_assign();
-    ast loop();
-    ast while_loop();
-    ast for_loop();
-    ast forei_loop();
-    ast iter_gen();
-    ast cond();
-    ast continue_expr();
-    ast break_expr();
-    ast ret_expr();
-public:
-    parse(error& e):
-        ptr(0), in_func(0), in_loop(0),
-        toks(nullptr),
-        root({0, 0, 0, 0, ""}, ast_root),
-        err(e) {}
-    const error& compile(const lexer&);
-    ast& tree() {return root;}
-    const ast& tree() const {return root;}
-};
-
-const error& parse::compile(const lexer& lexer) {
-    toks=lexer.result().data();
-    ptr=in_func=in_loop=0;
-
-    root={toks[0].loc, ast_root};
-    while(!lookahead(tok::eof)) {
-        root.add(expr());
-        if (lookahead(tok::semi)) {
-            match(tok::semi);
-        } else if (need_semi_check(root.child().back()) && !lookahead(tok::eof)) {
-            // the last expression can be recognized without semi
-            die(prevspan, "expected \";\"");
-        }
-    }
-    root.update_span();
-    return err;
-}
-
-void parse::die(const span& loc, string info) {
-    err.err("parse", loc, info);
-}
-
-void parse::match(tok type,const char* info) {
-    if (!lookahead(type)) {
-        if (info) {
-            die(thisspan, info);
-            return;
-        }
-        switch(type) {
-            case tok::num:die(thisspan, "expected number");    break;
-            case tok::str:die(thisspan, "expected string");    break;
-            case tok::id: die(thisspan, "expected identifier");break;
-            default:      die(thisspan, "expected '"+tokname.at(type)+"'"); break;
-        }
-        return;
-    }
-    if (lookahead(tok::eof)) {
-        return;
-    }
-    next();
-}
-
-bool parse::lookahead(tok type) {
-    return toks[ptr].type==type;
-}
-
-bool parse::is_call(tok type) {
-    return type==tok::lcurve || type==tok::lbracket || type==tok::dot;
-}
-
-bool parse::check_comma(const tok* panic_set) {
-    for(u32 i=0;panic_set[i]!=tok::null;++i) {
-        if (lookahead(panic_set[i])) {
-            die(prevspan, "expected ',' between scalars");
-            return true;
-        }
-    }
-    return false;
-}
-
-bool parse::check_tuple() {
-    u32 check_ptr=ptr, curve=1, bracket=0, brace=0;
-    while(toks[++check_ptr].type!=tok::eof && curve) {
-        switch(toks[check_ptr].type) {
-            case tok::lcurve:   ++curve;   break;
-            case tok::lbracket: ++bracket; break;
-            case tok::lbrace:   ++brace;   break;
-            case tok::rcurve:   --curve;   break;
-            case tok::rbracket: --bracket; break;
-            case tok::rbrace:   --brace;   break;
-            default: break;
-        }
-        if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::comma) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool parse::check_func_end(const ast& node) {
-    u32 type=node.type();
-    if (type==ast_func) {
-        return true;
-    } else if (type==ast_num || type==ast_id || type==ast_str || type==ast_nil || type==ast_vec || type==ast_hash) {
-        return false;
-    }
-    if (node.child().empty() || (
-            type!=ast_def &&
-            type!=ast_equal &&
-            type!=ast_addeq &&
-            type!=ast_subeq &&
-            type!=ast_multeq &&
-            type!=ast_diveq &&
-            type!=ast_lnkeq
-        )
-    ) {
-        return false;
-    } else {
-        return check_func_end(node.child().back());
-    }
-    return false;
-}
-
-bool parse::check_special_call() {
-    // special call means like this: function_name(a:1,b:2,c:3);
-    u32 check_ptr=ptr, curve=1, bracket=0, brace=0;
-    while(toks[++check_ptr].type!=tok::eof && curve) {
-        switch(toks[check_ptr].type) {
-            case tok::lcurve:   ++curve;  break;
-            case tok::lbracket: ++bracket;break;
-            case tok::lbrace:   ++brace;  break;
-            case tok::rcurve:   --curve;  break;
-            case tok::rbracket: --bracket;break;
-            case tok::rbrace:   --brace;  break;
-            default: break;
-        }
-        // m?1:0 will be recognized as normal parameter
-        if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::quesmark) {
-            return false;
-        }
-        if (curve==1 && !bracket && !brace && toks[check_ptr].type==tok::colon) {
-            return true;
-        }
-    }
-    return false;
-}
-
-bool parse::need_semi_check(const ast& node) {
-    u32 type=node.type();
-    if (type==ast_for || type==ast_foreach || type==ast_forindex || type==ast_while || type==ast_cond) {
-        return false;
-    }
-    return !check_func_end(node);
-}
-
-ast parse::null() {
-    return {toks[ptr].loc, ast_null};
-}
-
-ast parse::nil() {
-    return {toks[ptr].loc, ast_nil};
-}
-
-ast parse::num() {
-    ast node(toks[ptr].loc, ast_num);
-    node.set_num(str2num(toks[ptr].str.c_str()));
-    match(tok::num);
-    return node;
-}
-
-ast parse::str() {
-    ast node(toks[ptr].loc, ast_str);
-    node.set_str(toks[ptr].str);
-    match(tok::str);
-    return node;
-}
-
-ast parse::id() {
-    ast node(toks[ptr].loc, ast_id);
-    node.set_str(toks[ptr].str);
-    match(tok::id);
-    return node;
-}
-
-ast parse::bools() {
-    ast node(toks[ptr].loc, ast_bool);
-    node.set_str(toks[ptr].str);
-    if (lookahead(tok::tktrue)) {
-        match(tok::tktrue);
-    } else {
-        match(tok::tkfalse);
-    }
-    return node;
-}
-
-ast parse::vec() {
-    // panic set for this token is not ','
-    // this is the FIRST set of calculation
-    // array end with tok::null=0
-    const tok panic[]={
-        tok::id,tok::str,tok::num,tok::tktrue,
-        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
-        tok::func,tok::var,tok::lcurve,tok::floater,
-        tok::lbrace,tok::lbracket,tok::null
-    };
-    ast node(toks[ptr].loc, ast_vec);
-    match(tok::lbracket);
-    while(!lookahead(tok::rbracket)) {
-        node.add(calc());
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::eof)) {
-            break;
-        } else if (!lookahead(tok::rbracket) && !check_comma(panic)) {
-            break;
-        }
-    }
-    node.update_span(thisspan);
-    match(tok::rbracket, "expected ']' when generating vector");
-    return node;
-}
-
-ast parse::hash() {
-    ast node(toks[ptr].loc, ast_hash);
-    match(tok::lbrace);
-    while(!lookahead(tok::rbrace)) {
-        node.add(pair());
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::id) || lookahead(tok::str)) { // first set of hashmember
-            die(prevspan, "expected ',' between hash members");
-        } else {
-            break;
-        }
-    }
-    node.update_span(thisspan);
-    match(tok::rbrace, "expected '}' when generating hash");
-    return node;
-}
-
-ast parse::pair() {
-    ast node(toks[ptr].loc, ast_pair);
-    if (lookahead(tok::id)) {
-        node.add(id());
-    } else if (lookahead(tok::str)) {
-        node.add(str());
-    } else {
-        match(tok::id, "expected hashmap key");
-    }
-    match(tok::colon);
-    node.add(calc());
-    node.update_span();
-    return node;
-}
-
-ast parse::func() {
-    ++in_func;
-    ast node(toks[ptr].loc, ast_func);
-    match(tok::func);
-    if (lookahead(tok::lcurve)) {
-        node.add(params());
-    } else {
-        node.add(null());
-    }
-    node.add(exprs());
-    --in_func;
-    node.update_span();
-    return node;
-}
-
-ast parse::params() {
-    ast node(toks[ptr].loc, ast_params);
-    match(tok::lcurve);
-    while(!lookahead(tok::rcurve)) {
-        ast tmp=id();
-        if (lookahead(tok::eq) || lookahead(tok::ellipsis)) {
-            ast special_arg(toks[ptr].loc, ast_null);
-            if (lookahead(tok::eq)) {
-                match(tok::eq);
-                special_arg=std::move(tmp);
-                special_arg.set_type(ast_default);
-                special_arg.add(calc());
-            } else {
-                match(tok::ellipsis);
-                special_arg=std::move(tmp);
-                special_arg.set_type(ast_dynamic);
-            }
-            node.add(std::move(special_arg));
-        } else {
-            node.add(std::move(tmp));
-        }
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::id)) { // first set of identifier
-            die(prevspan, "expected ',' between identifiers");
-        } else {
-            break;
-        }
-    }
-    node.update_span(thisspan);
-    match(tok::rcurve, "expected ')' after parameter list");
-    return node;
-}
-
-ast parse::lcurve_expr() {
-    if (toks[ptr+1].type==tok::var)
-        return definition();
-    return check_tuple()?multi_assign():calc();
-}
-
-ast parse::expr() {
-    tok type=toks[ptr].type;
-    if ((type==tok::brk || type==tok::cont) && !in_loop) {
-        die(thisspan, "must use break/continue in loops");
-    }
-    if (type==tok::ret && !in_func) {
-        die(thisspan, "must use return in functions");
-    }
-    switch(type) {
-        case tok::tknil:
-        case tok::num:
-        case tok::str:
-        case tok::id:
-        case tok::tktrue:
-        case tok::tkfalse:
-        case tok::func:
-        case tok::lbracket:
-        case tok::lbrace:
-        case tok::sub:
-        case tok::floater:
-        case tok::opnot:   return calc();          break;
-        case tok::var:     return definition();    break;
-        case tok::lcurve:  return lcurve_expr();   break;
-        case tok::rfor:
-        case tok::forindex:
-        case tok::foreach:
-        case tok::rwhile:  return loop();          break;
-        case tok::rif:     return cond();          break;
-        case tok::cont:    return continue_expr(); break;
-        case tok::brk:     return break_expr();    break;
-        case tok::ret:     return ret_expr();      break;
-        case tok::semi:                            break;
-        default:
-            die(thisspan, "incorrect token <"+toks[ptr].str+">");
-            next();
-            break;
-    }
-
-    // unreachable
-    return {toks[ptr].loc, ast_null};
-}
-
-ast parse::exprs() {
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected expression block");
-        return null();
-    }
-    ast node(toks[ptr].loc, ast_block);
-    if (lookahead(tok::lbrace)) {
-        match(tok::lbrace);
-        while(!lookahead(tok::rbrace) && !lookahead(tok::eof)) {
-            node.add(expr());
-            if (lookahead(tok::semi)) {
-                match(tok::semi);
-            } else if (need_semi_check(node.child().back()) && !lookahead(tok::rbrace)) {
-                // the last expression can be recognized without semi
-                die(prevspan, "expected ';'");
-            }
-        }
-        match(tok::rbrace, "expected '}' when generating expressions");
-    } else {
-        node.add(expr());
-        if (lookahead(tok::semi))
-            match(tok::semi);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::calc() {
-    ast node=bitwise_or();
-    if (lookahead(tok::quesmark)) {
-        // trinocular calculation
-        ast tmp(toks[ptr].loc, ast_trino);
-        match(tok::quesmark);
-        tmp.add(std::move(node));
-        tmp.add(calc());
-        match(tok::colon);
-        tmp.add(calc());
-        node=std::move(tmp);
-    } else if (tok::eq<=toks[ptr].type && toks[ptr].type<=tok::lnkeq) {
-        // tok::eq~tok::lnkeq is 37 to 42,ast_equal~ast_lnkeq is 21~26
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::eq+ast_equal);
-        tmp.add(std::move(node));
-        match(toks[ptr].type);
-        tmp.add(calc());
-        node=std::move(tmp);
-    } else if (toks[ptr].type==tok::btandeq || toks[ptr].type==tok::btoreq || toks[ptr].type==tok::btxoreq) {
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::btandeq+ast_btandeq);
-        tmp.add(std::move(node));
-        match(toks[ptr].type);
-        tmp.add(calc());
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::bitwise_or() {
-    ast node=bitwise_xor();
-    while(lookahead(tok::btor)) {
-        ast tmp(toks[ptr].loc, ast_bitor);
-        tmp.add(std::move(node));
-        match(tok::btor);
-        tmp.add(bitwise_xor());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::bitwise_xor() {
-    ast node=bitwise_and();
-    while(lookahead(tok::btxor)) {
-        ast tmp(toks[ptr].loc, ast_bitxor);
-        tmp.add(std::move(node));
-        match(tok::btxor);
-        tmp.add(bitwise_and());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::bitwise_and() {
-    ast node=or_expr();
-    while(lookahead(tok::btand)) {
-        ast tmp(toks[ptr].loc, ast_bitand);
-        tmp.add(std::move(node));
-        match(tok::btand);
-        tmp.add(or_expr());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::or_expr() {
-    ast node=and_expr();
-    while(lookahead(tok::opor)) {
-        ast tmp(toks[ptr].loc, ast_or);
-        tmp.add(std::move(node));
-        match(tok::opor);
-        tmp.add(and_expr());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::and_expr() {
-    ast node=cmp_expr();
-    while(lookahead(tok::opand)) {
-        ast tmp(toks[ptr].loc, ast_and);
-        tmp.add(std::move(node));
-        match(tok::opand);
-        tmp.add(cmp_expr());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::cmp_expr() {
-    ast node=additive_expr();
-    while(tok::cmpeq<=toks[ptr].type && toks[ptr].type<=tok::geq) {
-        // tok::cmpeq~tok::geq is 43~48,ast_cmpeq~ast_geq is 27~32
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::cmpeq+ast_cmpeq);
-        tmp.add(std::move(node));
-        match(toks[ptr].type);
-        tmp.add(additive_expr());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::additive_expr() {
-    ast node=multive_expr();
-    while(lookahead(tok::add) || lookahead(tok::sub) || lookahead(tok::floater)) {
-        ast tmp(toks[ptr].loc, ast_null);
-        switch(toks[ptr].type) {
-            case tok::add: tmp.set_type(ast_add);  break;
-            case tok::sub: tmp.set_type(ast_sub);  break;
-            case tok::floater: tmp.set_type(ast_link); break;
-            default: break;
-        }
-        tmp.add(std::move(node));
-        match(toks[ptr].type);
-        tmp.add(multive_expr());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::multive_expr() {
-    ast node=(lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar();
-    while(lookahead(tok::mult) || lookahead(tok::div)) {
-        ast tmp(toks[ptr].loc, (u32)toks[ptr].type-(u32)tok::mult+ast_mult);
-        tmp.add(std::move(node));
-        match(toks[ptr].type);
-        tmp.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
-        tmp.update_span();
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::unary() {
-    ast node(toks[ptr].loc,ast_null);
-    switch(toks[ptr].type) {
-        case tok::sub:     node.set_type(ast_neg);match(tok::sub);break;
-        case tok::opnot:   node.set_type(ast_lnot);match(tok::opnot);break;
-        case tok::floater: node.set_type(ast_bnot);match(tok::floater);break;
-        default: break;
-    }
-    node.add((lookahead(tok::sub) || lookahead(tok::opnot) || lookahead(tok::floater))?unary():scalar());
-    node.update_span();
-    return node;
-}
-
-ast parse::scalar() {
-    ast node(toks[ptr].loc, ast_null);
-    if (lookahead(tok::tknil)) {
-        node=nil();
-        match(tok::tknil);
-    } else if (lookahead(tok::num)) {
-        node=num();
-    } else if (lookahead(tok::str)) {
-        node=str();
-    } else if (lookahead(tok::id)) {
-        node=id();
-    } else if (lookahead(tok::tktrue) || lookahead(tok::tkfalse)) {
-        node=bools();
-    } else if (lookahead(tok::func)) {
-        node=func();
-    } else if (lookahead(tok::lbracket)) {
-        node=vec();
-    } else if (lookahead(tok::lbrace)) {
-        node=hash();
-    } else if (lookahead(tok::lcurve)) {
-        const auto& loc=toks[ptr].loc;
-        match(tok::lcurve);
-        node=calc();
-        node.set_begin(loc.begin_line, loc.begin_column);
-        node.update_span(thisspan);
-        match(tok::rcurve);
-    } else if (lookahead(tok::var)) {
-        match(tok::var);
-        node.set_type(ast_def);
-        node.add(id());
-        match(tok::eq);
-        node.add(calc());
-    } else {
-        die(thisspan, "expected scalar");
-        return node;
-    }
-    // check call and avoid ambiguous syntax
-    if (is_call(toks[ptr].type) && !(lookahead(tok::lcurve) && toks[ptr+1].type==tok::var)) {
-        ast tmp=std::move(node);
-        node={toks[ptr].loc, ast_call};
-        node.add(std::move(tmp));
-        while(is_call(toks[ptr].type)) {
-            node.add(call_scalar());
-        }
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::call_scalar() {
-    switch(toks[ptr].type) {
-        case tok::lcurve:   return callf(); break;
-        case tok::lbracket: return callv(); break;
-        case tok::dot:      return callh(); break;
-        default: break;
-    }
-    // unreachable
-    return {toks[ptr].loc, ast_nil};
-}
-
-ast parse::callh() {
-    ast node(toks[ptr].loc, ast_callh);
-    match(tok::dot);
-    node.set_str(toks[ptr].str);
-    node.set_end(toks[ptr].loc.end_line, toks[ptr].loc.end_column);
-    match(tok::id, "expected hashmap key"); // get key
-    return node;
-}
-
-ast parse::callv() {
-    // panic set for this token is not ','
-    // this is the FIRST set of subvec
-    // array end with tok::null=0
-    const tok panic[]={
-        tok::id,tok::str,tok::num,tok::tktrue,
-        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
-        tok::func,tok::var,tok::lcurve,tok::floater,
-        tok::lbrace,tok::lbracket,tok::colon,tok::null
-    };
-    ast node(toks[ptr].loc, ast_callv);
-    match(tok::lbracket);
-    while(!lookahead(tok::rbracket)) {
-        node.add(subvec());
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::eof)) {
-            break;
-        } else if (!lookahead(tok::rbracket) && !check_comma(panic)) {
-            break;
-        }
-    }
-    if (node.size()==0) {
-        die(thisspan, "expected index value");
-    }
-    node.update_span(thisspan);
-    match(tok::rbracket, "expected ']' when calling vector");
-    return node;
-}
-
-ast parse::callf() {
-    // panic set for this token is not ','
-    // this is the FIRST set of calculation/hashmember
-    // array end with tok::null=0
-    const tok panic[]={
-        tok::id,tok::str,tok::num,tok::tktrue,
-        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
-        tok::func,tok::var,tok::lcurve,tok::floater,
-        tok::lbrace,tok::lbracket,tok::null
-    };
-    ast node(toks[ptr].loc, ast_callf);
-    bool special_call=check_special_call();
-    match(tok::lcurve);
-    while(!lookahead(tok::rcurve)) {
-        node.add(special_call?pair():calc());
-        if (lookahead(tok::comma))
-            match(tok::comma);
-        else if (lookahead(tok::eof))
-            break;
-        else if (!lookahead(tok::rcurve) && !check_comma(panic))
-            break;
-    }
-    node.update_span(thisspan);
-    match(tok::rcurve, "expected ')' when calling function");
-    return node;
-}
-
-ast parse::subvec() {
-    ast node=lookahead(tok::colon)?nil():calc();
-    if (lookahead(tok::colon)) {
-        ast tmp(toks[ptr].loc, ast_subvec);
-        match(tok::colon);
-        tmp.add(std::move(node));
-        tmp.add((lookahead(tok::comma) || lookahead(tok::rbracket))?nil():calc());
-        node=std::move(tmp);
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::definition() {
-    ast node(toks[ptr].loc, ast_def);
-    if (lookahead(tok::var)) {
-        match(tok::var);
-        switch(toks[ptr].type) {
-            case tok::id: node.add(id());break;
-            case tok::lcurve: node.add(outcurve_def());break;
-            default: die(thisspan, "expected identifier");break;
-        }
-    } else if (lookahead(tok::lcurve)) {
-        node.add(incurve_def());
-    }
-    match(tok::eq);
-    if (lookahead(tok::lcurve)) {
-        node.add(check_tuple()?multi_scalar():calc());
-    } else {
-        node.add(calc());
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::incurve_def() {
-    const auto& loc=toks[ptr].loc;
-    match(tok::lcurve);
-    match(tok::var);
-    ast node=multi_id();
-    node.update_span(thisspan);
-    match(tok::rcurve);
-    node.set_begin(loc.begin_line, loc.begin_column);
-    return node;
-}
-
-ast parse::outcurve_def() {
-    const auto& loc=toks[ptr].loc;
-    match(tok::lcurve);
-    ast node=multi_id();
-    node.update_span(thisspan);
-    match(tok::rcurve);
-    node.set_begin(loc.begin_line, loc.begin_column);
-    return node;
-}
-
-ast parse::multi_id() {
-    ast node(toks[ptr].loc, ast_multi_id);
-    while(!lookahead(tok::eof)) {
-        // only identifier is allowed here
-        // but we check it at codegen stage
-        node.add(calc());
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::id)) { // first set of identifier
-            die(prevspan, "expected ',' between identifiers");
-        } else {
-            break;
-        }
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::multi_scalar() {
-    // if check_call_memory is true,we will check if value called here can reach a memory space
-    const tok panic[]={
-        tok::id,tok::str,tok::num,tok::tktrue,
-        tok::tkfalse,tok::opnot,tok::sub,tok::tknil,
-        tok::func,tok::var,tok::lcurve,tok::floater,
-        tok::lbrace,tok::lbracket,tok::null
-    };
-    ast node(toks[ptr].loc, ast_tuple);
-    match(tok::lcurve);
-    while(!lookahead(tok::rcurve)) {
-        node.add(calc());
-        if (lookahead(tok::comma)) {
-            match(tok::comma);
-        } else if (lookahead(tok::eof)) {
-            break;
-        } else if (!lookahead(tok::rcurve) && !check_comma(panic)) {
-            break;
-        }
-    }
-    node.update_span(thisspan);
-    match(tok::rcurve, "expected ')' after multi-scalar");
-    return node;
-}
-
-ast parse::multi_assign() {
-    ast node(toks[ptr].loc, ast_multi_assign);
-    node.add(multi_scalar());
-    match(tok::eq);
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected value list");
-        return node;
-    }
-    if (lookahead(tok::lcurve)) {
-        node.add(check_tuple()?multi_scalar():calc());
-    } else {
-        node.add(calc());
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::loop() {
-    ++in_loop;
-    ast node(toks[ptr].loc, ast_null);
-    switch(toks[ptr].type) {
-        case tok::rwhile:  node=while_loop(); break;
-        case tok::rfor:    node=for_loop();   break;
-        case tok::forindex:
-        case tok::foreach: node=forei_loop(); break;
-        default: break;
-    }
-    --in_loop;
-    return node;
-}
-
-ast parse::while_loop() {
-    ast node(toks[ptr].loc, ast_while);
-    match(tok::rwhile);
-    match(tok::lcurve);
-    node.add(calc());
-    match(tok::rcurve);
-    node.add(exprs());
-    node.update_span();
-    return node;
-}
-
-ast parse::for_loop() {
-    ast node(toks[ptr].loc, ast_for);
-    match(tok::rfor);
-    match(tok::lcurve);
-    // first expression
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected definition");
-    }
-    if (lookahead(tok::semi)) {
-        node.add(null());
-    } else if (lookahead(tok::var)) {
-        node.add(definition());
-    } else if (lookahead(tok::lcurve)) {
-        node.add(lcurve_expr());
-    } else {
-        node.add(calc());
-    }
-    match(tok::semi, "expected ';' in for(;;)");
-    // conditional expression
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected conditional expr");
-    }
-    if (lookahead(tok::semi)) {
-        node.add(null());
-    } else {
-        node.add(calc());
-    }
-    match(tok::semi, "expected ';' in for(;;)");
-    //after loop expression
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected calculation");
-    }
-    if (lookahead(tok::rcurve)) {
-        node.add(null());
-    } else {
-        node.add(calc());
-    }
-    match(tok::rcurve);
-    node.add(exprs());
-    node.update_span();
-    return node;
-}
-
-ast parse::forei_loop() {
-    ast node(toks[ptr].loc, ast_null);
-    switch(toks[ptr].type) {
-        case tok::forindex:node.set_type(ast_forindex);match(tok::forindex);break;
-        case tok::foreach: node.set_type(ast_foreach); match(tok::foreach); break;
-        default: break;
-    }
-    match(tok::lcurve);
-    // first expression
-    // foreach/forindex must have an iterator to loop through
-    if (!lookahead(tok::var) && !lookahead(tok::id)) {
-        die(thisspan, "expected iterator");
-    }
-    node.add(iter_gen());
-    match(tok::semi, "expected ';' in foreach/forindex(iter;vector)");
-    if (lookahead(tok::eof)) {
-        die(thisspan, "expected vector");
-    }
-    node.add(calc());
-    match(tok::rcurve);
-    node.add(exprs());
-    node.update_span();
-    return node;
-}
-
-ast parse::iter_gen() {
-    ast node(toks[ptr].loc, ast_null);
-    if (lookahead(tok::var)) {
-        match(tok::var);
-        node.set_type(ast_iter);
-        node.add(id());
-    } else {
-        node.set_type(ast_call);
-        node.add(id());
-        while(is_call(toks[ptr].type)) {
-            node.add(call_scalar());
-        }
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::cond() {
-    ast node(toks[ptr].loc, ast_cond);
-
-    // generate if
-    ast ifnode(toks[ptr].loc, ast_if);
-    match(tok::rif);
-    match(tok::lcurve);
-    ifnode.add(calc());
-    match(tok::rcurve);
-    ifnode.add(exprs());
-    ifnode.update_span();
-    node.add(std::move(ifnode));
-
-    // generate elsif
-    while(lookahead(tok::elsif)) {
-        ast elsifnode(toks[ptr].loc, ast_elsif);
-        match(tok::elsif);
-        match(tok::lcurve);
-        elsifnode.add(calc());
-        match(tok::rcurve);
-        elsifnode.add(exprs());
-        elsifnode.update_span();
-        node.add(std::move(elsifnode));
-    }
-
-    // generate else
-    if (lookahead(tok::relse)) {
-        ast elsenode(toks[ptr].loc, ast_else);
-        match(tok::relse);
-        elsenode.add(exprs());
-        elsenode.update_span();
-        node.add(std::move(elsenode));
-    }
-    node.update_span();
-    return node;
-}
-
-ast parse::continue_expr() {
-    ast node(toks[ptr].loc, ast_continue);
-    match(tok::cont);
-    return node;
-}
-
-ast parse::break_expr() {
-    ast node(toks[ptr].loc, ast_break);
-    match(tok::brk);
-    return node;
-}
-
-ast parse::ret_expr() {
-    ast node(toks[ptr].loc, ast_ret);
-    match(tok::ret);
-    tok type=toks[ptr].type;
-    if (type==tok::tknil || type==tok::num ||
-        type==tok::str || type==tok::id ||
-        type==tok::func || type==tok::sub ||
-        type==tok::opnot || type==tok::lcurve ||
-        type==tok::lbracket || type==tok::lbrace ||
-        type==tok::tktrue || type==tok::tkfalse
-    ) {
-        node.add(calc());
-    }
-    node.update_span();
-    return node;
-}
diff --git a/nasal_vm.h b/nasal_vm.h
deleted file mode 100644
index 04de83c..0000000
--- a/nasal_vm.h
+++ /dev/null
@@ -1,1287 +0,0 @@
-#pragma once
-
-#include <iomanip>
-#include <stack>
-
-#include "nasal_import.h"
-#include "nasal_gc.h"
-#include "nasal_codegen.h"
-
-#ifdef _MSC_VER
-#pragma warning (disable:4244)
-#pragma warning (disable:4267)
-#pragma warning (disable:4102)
-#endif
-
-class vm {
-protected:
-
-    /* registers and constants of vm */
-    context ctx;
-
-    /* constants */
-    const f64* cnum=nullptr;    // constant numbers
-    const string* cstr=nullptr; // constant symbols and strings
-    std::vector<u32> imm;       // immediate number table
-    
-    /* garbage collector */
-    gc ngc;
-
-    /* main stack */
-    var stack[STACK_DEPTH];
-
-    /* values used for debugger */
-    const string* files=nullptr;    // file name list
-    const opcode* bytecode=nullptr; // bytecode buffer address
-
-    /* vm initializing function */
-    void init(
-        const std::vector<string>&,
-        const std::vector<f64>&,
-        const std::vector<opcode>&,
-        const std::vector<string>&,
-        const std::vector<string>&);
-
-    /* debug functions */
-    bool verbose;
-    void valinfo(var&);
-    void traceback();
-    void stackinfo(const u32);
-    void reginfo();
-    void gstate();
-    void lstate();
-    void ustate();
-    void detail();
-    void die(const string&);
-
-    /* vm calculation functions*/
-    bool cond(var&);
-
-    /* vm operands */
-    void o_intg();
-    void o_intl();
-    void o_loadg();
-    void o_loadl();
-    void o_loadu();
-    void o_pnum();
-    void o_pnil();
-    void o_pstr();
-    void o_newv();
-    void o_newh();
-    void o_newf();
-    void o_happ();
-    void o_para();
-    void o_deft();
-    void o_dyn();
-    void o_lnot();
-    void o_usub();
-    void o_bnot();
-    void o_btor();
-    void o_btxor();
-    void o_btand();
-    void o_add();
-    void o_sub();
-    void o_mul();
-    void o_div();
-    void o_lnk();
-    void o_addc();
-    void o_subc();
-    void o_mulc();
-    void o_divc();
-    void o_lnkc();
-    void o_addeq();
-    void o_subeq();
-    void o_muleq();
-    void o_diveq();
-    void o_lnkeq();
-    void o_bandeq();
-    void o_boreq();
-    void o_bxoreq();
-    void o_addeqc();
-    void o_subeqc();
-    void o_muleqc();
-    void o_diveqc();
-    void o_lnkeqc();
-    void o_addecp();
-    void o_subecp();
-    void o_mulecp();
-    void o_divecp();
-    void o_lnkecp();
-    void o_meq();
-    void o_eq();
-    void o_neq();
-    void o_less();
-    void o_leq();
-    void o_grt();
-    void o_geq();
-    void o_lessc();
-    void o_leqc();
-    void o_grtc();
-    void o_geqc();
-    void o_pop();
-    void o_jmp();
-    void o_jt();
-    void o_jf();
-    void o_cnt();
-    void o_findex();
-    void o_feach();
-    void o_callg();
-    void o_calll();
-    void o_upval();
-    void o_callv();
-    void o_callvi();
-    void o_callh();
-    void o_callfv();
-    void o_callfh();
-    void o_callb();
-    void o_slcbeg();
-    void o_slcend();
-    void o_slc();
-    void o_slc2();
-    void o_mcallg();
-    void o_mcalll();
-    void o_mupval();
-    void o_mcallv();
-    void o_mcallh();
-    void o_ret();
-public:
-
-    /* constructor of vm instance */
-    vm(): ngc(&ctx), verbose(false) {}
-
-    /* execution entry */
-    void run(
-        const codegen&,
-        const linker&,
-        const std::vector<string>&,
-        const bool
-    );
-};
-
-void vm::init(
-    const std::vector<string>& strs,
-    const std::vector<f64>&    nums,
-    const std::vector<opcode>& code,
-    const std::vector<string>& filenames,
-    const std::vector<string>& argv
-) {
-    cnum=nums.data();
-    cstr=strs.data();
-    bytecode=code.data();
-    files=filenames.data();
-
-    /* set canary and program counter */
-    ctx.pc=0;
-    ctx.localr=ctx.memr=nullptr;
-    ctx.funcr=ctx.upvalr=nil;
-    ctx.canary=stack+STACK_DEPTH-1; // stack[STACK_DEPTH-1]
-    ctx.top=stack;
-    ctx.stack=stack;
-
-    /* clear main stack */
-    for(u32 i=0;i<STACK_DEPTH;++i) {
-        stack[i]=nil;
-    }
-
-    /* init gc */
-    ngc.init(strs,argv);
-}
-
-void vm::valinfo(var& val) {
-    const nas_val* p=val.val.gcobj;
-    switch(val.type) {
-        case vm_none: std::clog<<"| null |";break;
-        case vm_ret:  std::clog<<"| pc   | 0x"<<std::hex
-                               <<val.ret()<<std::dec;break;
-        case vm_addr: std::clog<<"| addr | 0x"<<std::hex
-                               <<(u64)val.addr()<<std::dec;break;
-        case vm_cnt:  std::clog<<"| cnt  | "<<val.cnt();break;
-        case vm_nil:  std::clog<<"| nil  |";break;
-        case vm_num:  std::clog<<"| num  | "<<val.num();break;
-        case vm_str:  std::clog<<"| str  | <0x"<<std::hex<<(u64)p
-                               <<"> "<<rawstr(val.str(),16)<<std::dec;break;
-        case vm_func: std::clog<<"| func | <0x"<<std::hex<<(u64)p
-                               <<"> entry:0x"<<val.func().entry
-                               <<std::dec;break;
-        case vm_upval:std::clog<<"| upval| <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> ["<<val.upval().size
-                               <<" val]";break;
-        case vm_vec:  std::clog<<"| vec  | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> ["<<val.vec().size()
-                               <<" val]";break;
-        case vm_hash: std::clog<<"| hash | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> {"<<val.hash().size()
-                               <<" val}";break;
-        case vm_obj:  std::clog<<"| obj  | <0x"<<std::hex<<(u64)p
-                               <<"> obj:0x"<<(u64)val.obj().ptr
-                               <<std::dec;break;
-        case vm_co:   std::clog<<"| co   | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> coroutine";break;
-        default:      std::clog<<"| err  | <0x"<<std::hex<<(u64)p
-                               <<std::dec<<"> unknown object";break;
-    }
-    std::clog<<"\n";
-}
-
-void vm::traceback() {
-    /* bytecode[0].num is the global size */
-    var* bottom=ngc.rctx->stack==stack?stack+bytecode[0].num:ngc.rctx->stack;
-    var* ctx_top=ngc.rctx->stack==stack?ctx.top:ngc.rctx->top;
-    std::stack<u32> ret;
-    for(var* i=bottom;i<=ctx_top;++i) {
-        if (i->type==vm_ret && i->ret()!=0) {
-            ret.push(i->ret());
-        }
-    }
-    ret.push(ctx.pc); // store the position program crashed
-    std::clog<<"trace back ("<<(ngc.rctx->stack==stack?"main":"coroutine")<<")\n";
-    codestream::set(cnum, cstr, files);
-    for(u32 p=0,same=0,prev=0xffffffff;!ret.empty();prev=p,ret.pop()) {
-        if ((p=ret.top())==prev) {
-            ++same;
-            continue;
-        }
-        if (same) {
-            std::clog
-            <<"  0x"<<std::hex<<std::setw(6)<<std::setfill('0')
-            <<prev<<std::dec<<"     "<<same<<" same call(s)\n";
-        }
-        same=0;
-        std::clog<<"  "<<codestream(bytecode[p],p)<<"\n";
-    }
-    // the first called place has no same calls
-}
-
-void vm::stackinfo(const u32 limit=10) {
-    /* bytecode[0].num is the global size */
-    const u32 gsize=ngc.rctx->stack==stack?bytecode[0].num:0;
-    var* t=ctx.top;
-    var* bottom=ngc.rctx->stack+gsize;
-    std::clog<<"stack (0x"<<std::hex<<(u64)bottom<<std::dec
-             <<" <+"<<gsize<<">, limit "<<limit<<", total "
-             <<(t<bottom? 0:(i64)(t-bottom+1))<<")\n";
-    for(u32 i=0;i<limit && t>=bottom;++i,--t) {
-        std::clog<<"  0x"<<std::hex
-                 <<std::setw(6)<<std::setfill('0')
-                 <<(u64)(t-ngc.rctx->stack)<<std::dec
-                 <<"    ";
-        valinfo(t[0]);
-    }
-}
-
-void vm::reginfo() {
-    std::clog<<"registers ("<<(ngc.cort?"coroutine":"main")<<")\n"<<std::hex
-             <<"  [pc    ]    | pc   | 0x"<<ctx.pc<<"\n"
-             <<"  [global]    | addr | 0x"<<(u64)stack<<"\n"
-             <<"  [local ]    | addr | 0x"<<(u64)ctx.localr<<"\n"
-             <<"  [memr  ]    | addr | 0x"<<(u64)ctx.memr<<"\n"
-             <<"  [canary]    | addr | 0x"<<(u64)ctx.canary<<"\n"
-             <<"  [top   ]    | addr | 0x"<<(u64)ctx.top<<"\n"
-             <<std::dec;
-    std::clog<<"  [funcr ]    ";valinfo(ctx.funcr);
-    std::clog<<"  [upval ]    ";valinfo(ctx.upvalr);
-}
-
-void vm::gstate() {
-    if (!bytecode[0].num || stack[0].type==vm_none) { // bytecode[0].op is op_intg
-        return;
-    }
-    std::clog<<"global (0x"<<std::hex<<(u64)stack<<" <+0>)\n"<<std::dec;
-    for(u32 i=0;i<bytecode[0].num;++i) {
-        std::clog<<"  0x"<<std::hex<<std::setw(6)
-                 <<std::setfill('0')<<i<<std::dec
-                 <<"    ";
-        valinfo(stack[i]);
-    }
-}
-
-void vm::lstate() {
-    if (!ctx.localr || !ctx.funcr.func().lsize) {
-        return;
-    }
-    const u32 lsize=ctx.funcr.func().lsize;
-    std::clog<<"local (0x"<<std::hex<<(u64)ctx.localr
-             <<" <+"<<(u64)(ctx.localr-ngc.rctx->stack)<<">)\n"<<std::dec;
-    for(u32 i=0;i<lsize;++i) {
-        std::clog<<"  0x"<<std::hex<<std::setw(6)
-                 <<std::setfill('0')<<i<<std::dec
-                 <<"    ";
-        valinfo(ctx.localr[i]);
-    }
-}
-
-void vm::ustate() {
-    if (ctx.funcr.type==vm_nil || ctx.funcr.func().upval.empty()) {
-        return;
-    }
-    std::clog<<"upvalue\n";
-    auto& upval=ctx.funcr.func().upval;
-    for(u32 i=0;i<upval.size();++i) {
-        std::clog<<"  -> upval["<<i<<"]:\n";
-        auto& uv=upval[i].upval();
-        for(u32 j=0;j<uv.size;++j) {
-            std::clog<<"     0x"<<std::hex<<std::setw(6)
-                     <<std::setfill('0')<<j<<std::dec
-                     <<" ";
-            valinfo(uv[j]);
-        }
-    }
-}
-
-void vm::detail() {
-    reginfo();
-    gstate();
-    lstate();
-    ustate();
-}
-
-void vm::die(const string& str) {
-    std::cerr<<"[vm] error: "<<str<<"\n";
-    traceback();
-    stackinfo();
-
-    // show verbose crash info
-    if (verbose) {
-        detail();
-    }
-
-    if (ngc.rctx->stack==stack) { // in main context, exit directly
-        std::exit(1);
-    } else { // in coroutine, shut down the coroutine and return to main context
-        ctx.pc=0; // mark coroutine 'dead'
-        ngc.ctxreserve();
-        ctx.top[0]=nil;
-    }
-}
-
-inline bool vm::cond(var& val) {
-    if (val.type==vm_num) {
-        return val.num();
-    } else if (val.type==vm_str) {
-        const f64 num=str2num(val.str().c_str());
-        return std::isnan(num)? !val.str().empty():num;
-    }
-    return false;
-}
-
-void vm::o_intg() {
-    // global values store on stack
-    ctx.top+=imm[ctx.pc];
-    --ctx.top;// point to the top
-}
-
-void vm::o_intl() {
-    ctx.top[0].func().local.resize(imm[ctx.pc], nil);
-    ctx.top[0].func().lsize=imm[ctx.pc];
-}
-
-void vm::o_loadg() {
-    stack[imm[ctx.pc]]=(ctx.top--)[0];
-}
-
-void vm::o_loadl() {
-    ctx.localr[imm[ctx.pc]]=(ctx.top--)[0];
-}
-
-void vm::o_loadu() {
-    ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff]
-         .upval()[imm[ctx.pc]&0xffff]=(ctx.top--)[0];
-}
-
-void vm::o_pnum() {
-    (++ctx.top)[0]=var::num(cnum[imm[ctx.pc]]);
-}
-
-void vm::o_pnil() {
-    (++ctx.top)[0]=nil;
-}
-
-void vm::o_pstr() {
-    (++ctx.top)[0]=ngc.strs[imm[ctx.pc]];
-}
-
-void vm::o_newv() {
-    var newv=ngc.alloc(vm_vec);
-    auto& vec=newv.vec().elems;
-    vec.resize(imm[ctx.pc]);
-    // use top-=imm[pc]-1 here will cause error if imm[pc] is 0
-    ctx.top=ctx.top-imm[ctx.pc]+1;
-    for(u32 i=0;i<imm[ctx.pc];++i) {
-        vec[i]=ctx.top[i];
-    }
-    ctx.top[0]=newv;
-}
-
-void vm::o_newh() {
-    (++ctx.top)[0]=ngc.alloc(vm_hash);
-}
-
-void vm::o_newf() {
-    (++ctx.top)[0]=ngc.alloc(vm_func);
-    nas_func& func=ctx.top[0].func();
-    func.entry=imm[ctx.pc];
-    func.psize=1;
-
-    /* this means you create a new function in local scope */
-    if (ctx.localr) {
-        func.upval=ctx.funcr.func().upval;
-        // function created in the same local scope shares one closure
-        // so this size & stk setting has no problem
-        var upval=(ctx.upvalr.type==vm_nil)?ngc.alloc(vm_upval):ctx.upvalr;
-        upval.upval().size=ctx.funcr.func().lsize;
-        upval.upval().stk=ctx.localr;
-        func.upval.push_back(upval);
-        ctx.upvalr=upval;
-    }
-}
-
-void vm::o_happ() {
-    ctx.top[-1].hash().elems[cstr[imm[ctx.pc]]]=ctx.top[0];
-    --ctx.top;
-}
-
-void vm::o_para() {
-    nas_func& func=ctx.top[0].func();
-    // func->size has 1 place reserved for "me"
-    func.keys[imm[ctx.pc]]=func.psize;
-    func.local[func.psize++]=var::none();
-}
-
-void vm::o_deft() {
-    var val=ctx.top[0];
-    nas_func& func=(--ctx.top)[0].func();
-    // func->size has 1 place reserved for "me"
-    func.keys[imm[ctx.pc]]=func.psize;
-    func.local[func.psize++]=val;
-}
-
-void vm::o_dyn() {
-    ctx.top[0].func().dpara=imm[ctx.pc];
-}
-
-void vm::o_lnot() {
-    var val=ctx.top[0];
-    switch(val.type) {
-        case vm_nil:ctx.top[0]=one;break;
-        case vm_num:ctx.top[0]=val.num()?zero:one;break;
-        case vm_str:{
-            const f64 num=str2num(val.str().c_str());
-            if (std::isnan(num)) {
-                ctx.top[0]=var::num((f64)val.str().empty());
-            } else {
-                ctx.top[0]=num?zero:one;
-            }
-        } break;
-        default:{
-            die("incorrect value type");
-            return;
-        } break;
-    }
-}
-
-void vm::o_usub() {
-    ctx.top[0]=var::num(-ctx.top[0].tonum());
-}
-
-void vm::o_bnot() {
-    ctx.top[0]=var::num(~static_cast<int32_t>(ctx.top[0].num()));
-}
-
-void vm::o_btor() {
-    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())|static_cast<int32_t>(ctx.top[0].tonum()));
-    --ctx.top;
-}
-
-void vm::o_btxor() {
-    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())^static_cast<int32_t>(ctx.top[0].tonum()));
-    --ctx.top;
-}
-
-void vm::o_btand() {
-    ctx.top[-1]=var::num(static_cast<int32_t>(ctx.top[-1].tonum())&static_cast<int32_t>(ctx.top[0].tonum()));
-    --ctx.top;
-}
-
-#define op_calc(type)\
-    ctx.top[-1]=var::num(ctx.top[-1].tonum() type ctx.top[0].tonum());\
-    --ctx.top;
-
-void vm::o_add() {op_calc(+);}
-void vm::o_sub() {op_calc(-);}
-void vm::o_mul() {op_calc(*);}
-void vm::o_div() {op_calc(/);}
-void vm::o_lnk() {
-    ctx.top[-1]=ngc.newstr(ctx.top[-1].tostr()+ctx.top[0].tostr());
-    --ctx.top;
-}
-
-#define op_calc_const(type)\
-    ctx.top[0]=var::num(ctx.top[0].tonum() type cnum[imm[ctx.pc]]);
-
-void vm::o_addc() {op_calc_const(+);}
-void vm::o_subc() {op_calc_const(-);}
-void vm::o_mulc() {op_calc_const(*);}
-void vm::o_divc() {op_calc_const(/);}
-void vm::o_lnkc() {
-    ctx.top[0]=ngc.newstr(ctx.top[0].tostr()+cstr[imm[ctx.pc]]);
-}
-
-// top[0] stores the value of memr[0], to avoid being garbage-collected
-// so when the calculation ends, top-=1, then top-=imm[pc]
-// because this return value is meaningless if on stack when imm[pc]=1
-// like this: func{a+=c;}(); the result of 'a+c' will no be used later, imm[pc]=1
-// but if b+=a+=c; the result of 'a+c' will be used later, imm[pc]=0
-#define op_calc_eq(type)\
-    ctx.top[-1]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type ctx.top[-1].tonum());\
-    ctx.memr=nullptr;\
-    ctx.top-=imm[ctx.pc]+1;
-
-void vm::o_addeq() {op_calc_eq(+);}
-void vm::o_subeq() {op_calc_eq(-);}
-void vm::o_muleq() {op_calc_eq(*);}
-void vm::o_diveq() {op_calc_eq(/);}
-void vm::o_lnkeq() {
-    ctx.top[-1]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+ctx.top[-1].tostr());
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_bandeq() {
-    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())&i32(ctx.top[-1].tonum()));
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_boreq() {
-    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())|i32(ctx.top[-1].tonum()));
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_bxoreq() {
-    ctx.top[-1]=ctx.memr[0]=var::num(i32(ctx.memr[0].tonum())^i32(ctx.top[-1].tonum()));
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-// top[0] stores the value of memr[0], to avoid being garbage-collected
-// so when the calculation ends, top-=imm[pc]>>31
-// because this return value is meaningless if on stack when imm[pc]>>31=1
-// like this: func{a+=1;}(); the result of 'a+1' will no be used later, imm[pc]>>31=1
-// but if b+=a+=1; the result of 'a+1' will be used later, imm[pc]>>31=0
-#define op_calc_eq_const(type)\
-    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
-    ctx.memr=nullptr;
-
-void vm::o_addeqc() {op_calc_eq_const(+);}
-void vm::o_subeqc() {op_calc_eq_const(-);}
-void vm::o_muleqc() {op_calc_eq_const(*);}
-void vm::o_diveqc() {op_calc_eq_const(/);}
-void vm::o_lnkeqc() {
-    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
-    ctx.memr=nullptr;
-}
-
-#define op_calc_eq_const_and_pop(type)\
-    ctx.top[0]=ctx.memr[0]=var::num(ctx.memr[0].tonum() type cnum[imm[ctx.pc]]);\
-    ctx.memr=nullptr;\
-    --ctx.top;
-
-void vm::o_addecp() {op_calc_eq_const_and_pop(+);}
-void vm::o_subecp() {op_calc_eq_const_and_pop(-);}
-void vm::o_mulecp() {op_calc_eq_const_and_pop(*);}
-void vm::o_divecp() {op_calc_eq_const_and_pop(/);}
-void vm::o_lnkecp() {
-    ctx.top[0]=ctx.memr[0]=ngc.newstr(ctx.memr[0].tostr()+cstr[imm[ctx.pc]]);
-    ctx.memr=nullptr;
-    --ctx.top;
-}
-
-void vm::o_meq() {
-    // pop old memr[0] and replace it
-    // the reason why we should get memr and push the old value on stack
-    // is that when lnkeq/lnkeqc is called, there will be
-    // a new gc object vm_str which is returned by gc::alloc
-    // this may cause gc, so we should temporarily put it on stack
-    ctx.memr[0]=ctx.top[-1];
-    ctx.memr=nullptr;
-    ctx.top-=imm[ctx.pc]+1;
-}
-
-void vm::o_eq() {
-    var val2=ctx.top[0];
-    var val1=(--ctx.top)[0];
-    if (val1.type==vm_nil && val2.type==vm_nil) {
-        ctx.top[0]=one;
-    } else if (val1.type==vm_str && val2.type==vm_str) {
-        ctx.top[0]=(val1.str()==val2.str())?one:zero;
-    } else if ((val1.type==vm_num || val2.type==vm_num)
-        && val1.type!=vm_nil && val2.type!=vm_nil) {
-        ctx.top[0]=(val1.tonum()==val2.tonum())?one:zero;
-    } else {
-        ctx.top[0]=(val1==val2)?one:zero;
-    }
-}
-
-void vm::o_neq() {
-    var val2=ctx.top[0];
-    var val1=(--ctx.top)[0];
-    if (val1.type==vm_nil && val2.type==vm_nil) {
-        ctx.top[0]=zero;
-    } else if (val1.type==vm_str && val2.type==vm_str) {
-        ctx.top[0]=(val1.str()!=val2.str())?one:zero;
-    } else if ((val1.type==vm_num || val2.type==vm_num)
-        && val1.type!=vm_nil && val2.type!=vm_nil) {
-        ctx.top[0]=(val1.tonum()!=val2.tonum())?one:zero;
-    } else {
-        ctx.top[0]=(val1!=val2)?one:zero;
-    }
-}
-
-#define op_cmp(type)\
-    --ctx.top;\
-    ctx.top[0]=(ctx.top[0].tonum() type ctx.top[1].tonum())?one:zero;
-
-void vm::o_less() {op_cmp(<);}
-void vm::o_leq() {op_cmp(<=);}
-void vm::o_grt() {op_cmp(>);}
-void vm::o_geq() {op_cmp(>=);}
-
-#define op_cmp_const(type)\
-    ctx.top[0]=(ctx.top[0].tonum() type cnum[imm[ctx.pc]])?one:zero;
-
-void vm::o_lessc() {op_cmp_const(<);}
-void vm::o_leqc() {op_cmp_const(<=);}
-void vm::o_grtc() {op_cmp_const(>);}
-void vm::o_geqc() {op_cmp_const(>=);}
-
-void vm::o_pop() {
-    --ctx.top;
-}
-
-void vm::o_jmp() {
-    ctx.pc=imm[ctx.pc]-1;
-}
-
-void vm::o_jt() {
-    // jump true needs to reserve the result on stack
-    // because conditional expression in nasal has return value
-    if (cond(ctx.top[0])) {
-        ctx.pc=imm[ctx.pc]-1;
-    }
-}
-
-void vm::o_jf() {
-    // jump false doesn't need to reserve result
-    if (!cond(ctx.top[0])) {
-        ctx.pc=imm[ctx.pc]-1;
-    }
-    --ctx.top;
-}
-
-void vm::o_cnt() {
-    if (ctx.top[0].type!=vm_vec) {
-        die("must use vector in forindex/foreach");
-        return;
-    }
-    (++ctx.top)[0]=var::cnt(-1);
-}
-
-void vm::o_findex() {
-    if ((usize)(++ctx.top[0].cnt())>=ctx.top[-1].vec().size()) {
-        ctx.pc=imm[ctx.pc]-1;
-        return;
-    }
-    ctx.top[1]=var::num(ctx.top[0].cnt());
-    ++ctx.top;
-}
-
-void vm::o_feach() {
-    auto& ref=ctx.top[-1].vec().elems;
-    if ((usize)(++ctx.top[0].cnt())>=ref.size()) {
-        ctx.pc=imm[ctx.pc]-1;
-        return;
-    }
-    ctx.top[1]=ref[ctx.top[0].cnt()];
-    ++ctx.top;
-}
-
-void vm::o_callg() {
-    // get main stack directly
-    (++ctx.top)[0]=stack[imm[ctx.pc]];
-}
-
-void vm::o_calll() {
-    (++ctx.top)[0]=ctx.localr[imm[ctx.pc]];
-}
-
-void vm::o_upval() {
-    (++ctx.top)[0]=ctx.funcr.func()
-        .upval[(imm[ctx.pc]>>16)&0xffff]
-        .upval()[imm[ctx.pc]&0xffff];
-}
-
-void vm::o_callv() {
-    var val=ctx.top[0];
-    var vec=(--ctx.top)[0];
-    if (vec.type==vm_vec) {
-        ctx.top[0]=vec.vec().get_val(val.tonum());
-        if (ctx.top[0].type==vm_none) {
-            die("out of range:"+std::to_string(val.tonum()));
-            return;
-        }
-    } else if (vec.type==vm_hash) {
-        if (val.type!=vm_str) {
-            die("must use string as the key");
-            return;
-        }
-        ctx.top[0]=vec.hash().get_val(val.str());
-        if (ctx.top[0].type==vm_none) {
-            die("cannot find member \""+val.str()+"\"");
-            return;
-        } else if (ctx.top[0].type==vm_func) {
-            ctx.top[0].func().local[0]=val; // 'me'
-        }
-    } else if (vec.type==vm_str) {
-        string& str=vec.str();
-        i32 num=val.tonum();
-        i32 len=str.length();
-        if (num<-len || num>=len) {
-            die("out of range:"+std::to_string(val.tonum()));
-            return;
-        }
-        ctx.top[0]=var::num(f64((u8)str[num>=0? num:num+len]));
-    } else {
-        die("must call a vector/hash/string");
-        return;
-    }
-}
-
-void vm::o_callvi() {
-    var val=ctx.top[0];
-    if (val.type!=vm_vec) {
-        die("must use a vector");
-        return;
-    }
-    // cannot use operator[],because this may cause overflow
-    (++ctx.top)[0]=val.vec().get_val(imm[ctx.pc]);
-    if (ctx.top[0].type==vm_none) {
-        die("out of range:"+std::to_string(imm[ctx.pc]));
-        return;
-    }
-}
-
-void vm::o_callh() {
-    var val=ctx.top[0];
-    if (val.type!=vm_hash) {
-        die("must call a hash");
-        return;
-    }
-    ctx.top[0]=val.hash().get_val(cstr[imm[ctx.pc]]);
-    if (ctx.top[0].type==vm_none) {
-        die("member \""+cstr[imm[ctx.pc]]+"\" does not exist");
-        return;
-    } else if (ctx.top[0].type==vm_func) {
-        ctx.top[0].func().local[0]=val; // 'me'
-    }
-}
-
-void vm::o_callfv() {
-    u32 argc=imm[ctx.pc]; // arguments counter
-    var* local=ctx.top-argc+1; // arguments begin address
-    if (local[-1].type!=vm_func) {
-        die("must call a function");
-        return;
-    }
-    auto& func=local[-1].func();
-    var tmp=local[-1];
-    local[-1]=ctx.funcr;
-    ctx.funcr=tmp;
-    // top-argc+lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
-    if (ctx.top-argc+func.lsize+3>=ctx.canary) {
-        die("stack overflow");
-        return;
-    }
-    // parameter size is func->psize-1, 1 is reserved for "me"
-    u32 psize=func.psize-1;
-    if (argc<psize && func.local[argc+1].type==vm_none) {
-        die("lack argument(s)");
-        return;
-    }
-
-    var dynamic=nil;
-    if (func.dpara>=0) { // load dynamic arguments
-        dynamic=ngc.alloc(vm_vec);
-        for(u32 i=psize;i<argc;++i) {
-            dynamic.vec().elems.push_back(local[i]);
-        }
-    }
-    // should reset stack top after allocating vector
-    // because this may cause gc
-    // then all the available values the vector needs
-    // are all outside the stack top and may be
-    // collected incorrectly
-    ctx.top=local+func.lsize;
-
-    u32 min_size=(std::min)(psize, argc); // avoid error in MSVC
-    for(u32 i=min_size;i>=1;--i) { // load arguments
-        local[i]=local[i-1];
-    }
-    local[0]=func.local[0];// load "me"
-    // load local scope & default arguments
-    for(u32 i=min_size+1;i<func.lsize;++i) {
-        local[i]=func.local[i];
-    }
-    if (func.dpara>=0) {
-        local[psize+1]=dynamic;
-    }
-
-    ctx.top[0]=ctx.upvalr;
-    (++ctx.top)[0]=var::addr(ctx.localr);
-    (++ctx.top)[0]=var::ret(ctx.pc);
-    ctx.pc=func.entry-1;
-    ctx.localr=local;
-    ctx.upvalr=nil;
-}
-
-void vm::o_callfh() {
-    auto& hash=ctx.top[0].hash().elems;
-    if (ctx.top[-1].type!=vm_func) {
-        die("must call a function");
-        return;
-    }
-    auto& func=ctx.top[-1].func();
-    var tmp=ctx.top[-1];
-    ctx.top[-1]=ctx.funcr;
-    ctx.funcr=tmp;
-
-    // top -1(hash) +lsize(local) +1(old pc) +1(old localr) +1(old upvalr)
-    if (ctx.top+func.lsize+2>=ctx.canary) {
-        die("stack overflow");
-        return;
-    }
-    if (func.dpara>=0) {
-        die("special call cannot use dynamic argument");
-        return;
-    }
-
-    var* local=ctx.top;
-    ctx.top+=func.lsize;
-    for(u32 i=0;i<func.lsize;++i) {
-        local[i]=func.local[i];
-    }
-    
-    for(auto& i:func.keys) {
-        auto& key=cstr[i.first];
-        if (hash.count(key)) {
-            local[i.second]=hash[key];
-        } else if (local[i.second].type==vm_none) {
-            die("lack argument(s): \""+key+"\"");
-            return;
-        }
-    }
-
-    ctx.top[0]=ctx.upvalr;
-    (++ctx.top)[0]=var::addr(ctx.localr);
-    (++ctx.top)[0]=var::ret(ctx.pc); // rewrite top with vm_ret
-    ctx.pc=func.entry-1;
-    ctx.localr=local;
-    ctx.upvalr=nil;
-}
-
-void vm::o_callb() {
-    // reserve place for builtin function return,
-    // this code is written for coroutine
-    (++ctx.top)[0]=nil;
-
-    // if running a builtin function about coroutine
-    // (top) will be set to another context.top, instead of main_context.top
-    var tmp=(*builtin[imm[ctx.pc]].func)(ctx.localr, ngc);
-
-    // so we use tmp variable to store this return value
-    // and set it to top[0] later
-    ctx.top[0]=tmp;
-
-    // if get none, this means errors occurred when calling this native function
-    if (ctx.top[0].type==vm_none) {
-        die("native function error");
-        return;
-    }
-}
-
-void vm::o_slcbeg() {
-    // +--------------+
-    // | slice_vector | <-- top[0]
-    // +--------------+
-    // | resource_vec | <-- top[-1]
-    // +--------------+
-    (++ctx.top)[0]=ngc.alloc(vm_vec);
-    if (ctx.top[-1].type!=vm_vec) {
-        die("must slice a vector");
-        return;
-    }
-}
-
-void vm::o_slcend() {
-    ctx.top[-1]=ctx.top[0];
-    --ctx.top;
-}
-
-void vm::o_slc() {
-    var val=(ctx.top--)[0];
-    var res=ctx.top[-1].vec().get_val(val.tonum());
-    if (res.type==vm_none) {
-        die("index "+std::to_string(val.tonum())+" out of range");
-        return;
-    }
-    ctx.top[0].vec().elems.push_back(res);
-}
-
-void vm::o_slc2() {
-    var val2=(ctx.top--)[0];
-    var val1=(ctx.top--)[0];
-    auto& ref=ctx.top[-1].vec().elems;
-    auto& aim=ctx.top[0].vec().elems;
-
-    u8 type1=val1.type,type2=val2.type;
-    i32 num1=val1.tonum();
-    i32 num2=val2.tonum();
-    i32 size=ref.size();
-    if (type1==vm_nil && type2==vm_nil) {
-        num1=0;
-        num2=size-1;
-    } else if (type1==vm_nil && type2!=vm_nil) {
-        num1=num2<0? -size:0;
-    } else if (type1!=vm_nil && type2==vm_nil) {
-        num2=num1<0? -1:size-1;
-    }
-
-    if (num1<-size || num1>=size || num2<-size || num2>=size) {
-        die("index "+std::to_string(num1)+":"+std::to_string(num2)+" out of range");
-        return;
-    } else if (num1<=num2) {
-        for(i32 i=num1;i<=num2;++i) {
-            aim.push_back(i>=0?ref[i]:ref[i+size]);
-        }
-    }
-}
-
-void vm::o_mcallg() {
-    ctx.memr=stack+imm[ctx.pc];
-    (++ctx.top)[0]=ctx.memr[0];
-    // push value in this memory space on stack
-    // to avoid being garbage collected
-}
-
-void vm::o_mcalll() {
-    ctx.memr=ctx.localr+imm[ctx.pc];
-    (++ctx.top)[0]=ctx.memr[0];
-    // push value in this memory space on stack
-    // to avoid being garbage collected
-}
-
-void vm::o_mupval() {
-    ctx.memr=&(ctx.funcr.func().upval[(imm[ctx.pc]>>16)&0xffff].upval()[imm[ctx.pc]&0xffff]);
-    (++ctx.top)[0]=ctx.memr[0];
-    // push value in this memory space on stack
-    // to avoid being garbage collected
-}
-
-void vm::o_mcallv() {
-    var val=ctx.top[0];     // index
-    var vec=(--ctx.top)[0]; // mcall vector, reserved on stack to avoid gc
-    if (vec.type==vm_vec) {
-        ctx.memr=vec.vec().get_mem(val.tonum());
-        if (!ctx.memr) {
-            die("index "+std::to_string(val.tonum())+" out of range");
-            return;
-        }
-    } else if (vec.type==vm_hash) { // do mcallh but use the mcallv way
-        if (val.type!=vm_str) {
-            die("key must be string");
-            return;
-        }
-        nas_hash& ref=vec.hash();
-        string& str=val.str();
-        ctx.memr=ref.get_mem(str);
-        if (!ctx.memr) {
-            ref.elems[str]=nil;
-            ctx.memr=ref.get_mem(str);
-        }
-    } else {
-        die("cannot get memory space in this type");
-        return;
-    }
-}
-
-void vm::o_mcallh() {
-    var hash=ctx.top[0]; // mcall hash, reserved on stack to avoid gc
-    if (hash.type!=vm_hash) {
-        die("must call a hash");
-        return;
-    }
-    auto& ref=hash.hash();
-    auto& str=cstr[imm[ctx.pc]];
-    ctx.memr=ref.get_mem(str);
-    if (!ctx.memr) { // create a new key
-        ref.elems[str]=nil;
-        ctx.memr=ref.get_mem(str);
-    }
-}
-
-void vm::o_ret() {
-/*  +-------------+
-*   | return value| <- top[0]
-*   +-------------+
-*   | old pc      | <- top[-1]
-*   +-------------+
-*   | old localr  | <- top[-2]
-*   +-------------+
-*   | old upvalr  | <- top[-3]
-*   +-------------+
-*   | local scope |
-*   +-------------+ <- local pointer stored in localr
-*   | old funcr   | <- old function stored in funcr
-*   +-------------+
-*/
-    var  ret  =ctx.top[0];
-    var* local=ctx.localr;
-    var  func =ctx.funcr;
-    var  up   =ctx.upvalr;
-
-    ctx.pc    =ctx.top[-1].ret();
-    ctx.localr=ctx.top[-2].addr();
-    ctx.upvalr=ctx.top[-3];
-
-    ctx.top=local-1;
-    ctx.funcr=ctx.top[0];
-    ctx.top[0]=ret; // rewrite func with returned value
-
-    if (up.type==vm_upval) { // synchronize upvalue
-        auto& upval=up.upval();
-        auto size=func.func().lsize;
-        upval.onstk=false;
-        upval.elems.resize(size);
-        for(u32 i=0;i<size;++i) {
-            upval.elems[i]=local[i];
-        }
-    }
-
-    // cannot use gc.cort to judge,
-    // because there maybe another function call inside but return here
-    // coroutine function ends with setting pc to 0
-    if (!ctx.pc) {
-        ngc.ctxreserve();
-    }
-}
-
-void vm::run(
-    const codegen& gen,
-    const linker& linker,
-    const std::vector<string>& argv,
-    const bool detail
-) {
-    verbose=detail;
-    init(gen.strs(), gen.nums(), gen.codes(), linker.filelist(), argv);
-#ifndef _MSC_VER
-    const void* oprs[]={
-        &&vmexit, &&intg,   &&intl,   &&loadg,
-        &&loadl,  &&loadu,  &&pnum,   &&pnil,
-        &&pstr,   &&newv,   &&newh,   &&newf,
-        &&happ,   &&para,   &&deft,   &&dyn,
-        &&lnot,   &&usub,   &&bnot,   &&btor,
-        &&btxor,  &&btand,  &&add,    &&sub,
-        &&mul,    &&div,    &&lnk,    &&addc,
-        &&subc,   &&mulc,   &&divc,   &&lnkc,
-        &&addeq,  &&subeq,  &&muleq,  &&diveq,
-        &&lnkeq,  &&bandeq, &&boreq,  &&bxoreq,
-        &&addeqc, &&subeqc, &&muleqc, &&diveqc,
-        &&lnkeqc, &&addecp, &&subecp, &&mulecp,
-        &&divecp, &&lnkecp, &&meq,    &&eq,
-        &&neq,    &&less,   &&leq,    &&grt,
-        &&geq,    &&lessc,  &&leqc,   &&grtc,
-        &&geqc,   &&pop,    &&jmp,    &&jt,
-        &&jf,     &&cnt,    &&findex, &&feach,
-        &&callg,  &&calll,  &&upval,  &&callv,
-        &&callvi, &&callh,  &&callfv, &&callfh,
-        &&callb,  &&slcbeg, &&slcend, &&slc,
-        &&slc2,   &&mcallg, &&mcalll, &&mupval,
-        &&mcallv, &&mcallh, &&ret
-    };
-    std::vector<const void*> code;
-    for(auto& i:gen.codes()) {
-        code.push_back(oprs[i.op]);
-        imm.push_back(i.num);
-    }
-    // goto the first operand
-    goto *code[ctx.pc];
-#else
-    typedef void (vm::*nafunc)();
-    const nafunc oprs[]={
-        nullptr,       &vm::o_intg,
-        &vm::o_intl,   &vm::o_loadg,
-        &vm::o_loadl,  &vm::o_loadu,
-        &vm::o_pnum,   &vm::o_pnil,
-        &vm::o_pstr,   &vm::o_newv,
-        &vm::o_newh,   &vm::o_newf,
-        &vm::o_happ,   &vm::o_para,
-        &vm::o_deft,   &vm::o_dyn,
-        &vm::o_lnot,   &vm::o_usub,
-        &vm::o_bnot,   &vm::o_btor,
-        &vm::o_btxor,  &vm::o_btand,
-        &vm::o_add,    &vm::o_sub,
-        &vm::o_mul,    &vm::o_div,
-        &vm::o_lnk,    &vm::o_addc,
-        &vm::o_subc,   &vm::o_mulc,
-        &vm::o_divc,   &vm::o_lnkc,
-        &vm::o_addeq,  &vm::o_subeq,
-        &vm::o_muleq,  &vm::o_diveq,
-        &vm::o_lnkeq,  &vm::o_bandeq,
-        &vm::o_boreq,  &vm::o_bxoreq,
-        &vm::o_addeqc, &vm::o_subeqc,
-        &vm::o_muleqc, &vm::o_diveqc,
-        &vm::o_lnkeqc, &vm::o_addecp,
-        &vm::o_subecp, &vm::o_mulecp,
-        &vm::o_divecp, &vm::o_lnkecp,
-        &vm::o_meq,    &vm::o_eq,
-        &vm::o_neq,    &vm::o_less,
-        &vm::o_leq,    &vm::o_grt,
-        &vm::o_geq,    &vm::o_lessc,
-        &vm::o_leqc,   &vm::o_grtc,
-        &vm::o_geqc,   &vm::o_pop,
-        &vm::o_jmp,    &vm::o_jt,
-        &vm::o_jf,     &vm::o_cnt,
-        &vm::o_findex, &vm::o_feach,
-        &vm::o_callg,  &vm::o_calll,
-        &vm::o_upval,  &vm::o_callv,
-        &vm::o_callvi, &vm::o_callh,
-        &vm::o_callfv, &vm::o_callfh,
-        &vm::o_callb,  &vm::o_slcbeg,
-        &vm::o_slcend, &vm::o_slc,
-        &vm::o_slc2,   &vm::o_mcallg,
-        &vm::o_mcalll, &vm::o_mupval,
-        &vm::o_mcallv, &vm::o_mcallh,
-        &vm::o_ret
-    };
-    std::vector<nafunc> code;
-    for(auto& i:gen.codes()) {
-        code.push_back(oprs[i.op]);
-        imm.push_back(i.num);
-    }
-    while(code[ctx.pc]) {
-        (this->*code[ctx.pc])();
-        if (ctx.top>=ctx.canary) {
-            die("stack overflow");
-        }
-        ++ctx.pc;
-    }
-#endif
-
-vmexit:
-    if (detail) {
-        ngc.info();
-    }
-    ngc.clear();
-    imm.clear();
-    return;
-
-#ifndef _MSC_VER
-// may cause stackoverflow
-#define exec_check(op) {\
-        op();\
-        if (ctx.top<ctx.canary)\
-            goto *code[++ctx.pc];\
-        die("stack overflow");\
-        goto *code[++ctx.pc];\
-    }
-// do not cause stackoverflow
-#define exec_nodie(op) {op();goto *code[++ctx.pc];}
-
-intg:   exec_nodie(o_intg  ); // +imm[pc] (detected at codegen)
-intl:   exec_nodie(o_intl  ); // -0
-loadg:  exec_nodie(o_loadg ); // -1
-loadl:  exec_nodie(o_loadl ); // -1
-loadu:  exec_nodie(o_loadu ); // -1
-pnum:   exec_check(o_pnum  ); // +1
-pnil:   exec_check(o_pnil  ); // +1
-pstr:   exec_check(o_pstr  ); // +1
-newv:   exec_check(o_newv  ); // +1-imm[pc]
-newh:   exec_check(o_newh  ); // +1
-newf:   exec_check(o_newf  ); // +1
-happ:   exec_nodie(o_happ  ); // -1
-para:   exec_nodie(o_para  ); // -0
-deft:   exec_nodie(o_deft  ); // -1
-dyn:    exec_nodie(o_dyn   ); // -0
-lnot:   exec_nodie(o_lnot  ); // -0
-usub:   exec_nodie(o_usub  ); // -0
-bnot:   exec_nodie(o_bnot  ); // -0
-btor:   exec_nodie(o_btor  ); // -1
-btxor:  exec_nodie(o_btxor ); // -1
-btand:  exec_nodie(o_btand ); // -1
-add:    exec_nodie(o_add   ); // -1
-sub:    exec_nodie(o_sub   ); // -1
-mul:    exec_nodie(o_mul   ); // -1
-div:    exec_nodie(o_div   ); // -1
-lnk:    exec_nodie(o_lnk   ); // -1
-addc:   exec_nodie(o_addc  ); // -0
-subc:   exec_nodie(o_subc  ); // -0
-mulc:   exec_nodie(o_mulc  ); // -0
-divc:   exec_nodie(o_divc  ); // -0
-lnkc:   exec_nodie(o_lnkc  ); // -0
-addeq:  exec_nodie(o_addeq ); // -1
-subeq:  exec_nodie(o_subeq ); // -1
-muleq:  exec_nodie(o_muleq ); // -1
-diveq:  exec_nodie(o_diveq ); // -1
-lnkeq:  exec_nodie(o_lnkeq ); // -1
-bandeq: exec_nodie(o_bandeq); // -1
-boreq:  exec_nodie(o_boreq ); // -1
-bxoreq: exec_nodie(o_bxoreq); // -1
-addeqc: exec_nodie(o_addeqc); // -0
-subeqc: exec_nodie(o_subeqc); // -0
-muleqc: exec_nodie(o_muleqc); // -0
-diveqc: exec_nodie(o_diveqc); // -0
-lnkeqc: exec_nodie(o_lnkeqc); // -0
-addecp: exec_nodie(o_addecp); // -1
-subecp: exec_nodie(o_subecp); // -1
-mulecp: exec_nodie(o_mulecp); // -1
-divecp: exec_nodie(o_divecp); // -1
-lnkecp: exec_nodie(o_lnkecp); // -1
-meq:    exec_nodie(o_meq   ); // -1
-eq:     exec_nodie(o_eq    ); // -1
-neq:    exec_nodie(o_neq   ); // -1
-less:   exec_nodie(o_less  ); // -1
-leq:    exec_nodie(o_leq   ); // -1
-grt:    exec_nodie(o_grt   ); // -1
-geq:    exec_nodie(o_geq   ); // -1
-lessc:  exec_nodie(o_lessc ); // -0
-leqc:   exec_nodie(o_leqc  ); // -0
-grtc:   exec_nodie(o_grtc  ); // -0
-geqc:   exec_nodie(o_geqc  ); // -0
-pop:    exec_nodie(o_pop   ); // -1
-jmp:    exec_nodie(o_jmp   ); // -0
-jt:     exec_nodie(o_jt    ); // -0
-jf:     exec_nodie(o_jf    ); // -1
-cnt:    exec_nodie(o_cnt   ); // -0
-findex: exec_check(o_findex); // +1
-feach:  exec_check(o_feach ); // +1
-callg:  exec_check(o_callg ); // +1
-calll:  exec_check(o_calll ); // +1
-upval:  exec_check(o_upval ); // +1
-callv:  exec_nodie(o_callv ); // -0
-callvi: exec_nodie(o_callvi); // -0
-callh:  exec_nodie(o_callh ); // -0
-callfv: exec_nodie(o_callfv); // check in the function
-callfh: exec_nodie(o_callfh); // check in the function
-callb:  exec_nodie(o_callb ); // -0
-slcbeg: exec_check(o_slcbeg); // +1
-slcend: exec_nodie(o_slcend); // -1
-slc:    exec_nodie(o_slc   ); // -1
-slc2:   exec_nodie(o_slc2  ); // -2
-mcallg: exec_check(o_mcallg); // +1
-mcalll: exec_check(o_mcalll); // +1
-mupval: exec_check(o_mupval); // +1
-mcallv: exec_nodie(o_mcallv); // -0
-mcallh: exec_nodie(o_mcallh); // -0
-ret:    exec_nodie(o_ret   ); // -2
-#endif
-}
diff --git a/src/ast_dumper.cpp b/src/ast_dumper.cpp
index 80c344a..2596527 100644
--- a/src/ast_dumper.cpp
+++ b/src/ast_dumper.cpp
@@ -148,6 +148,14 @@ bool ast_dumper::visit_ternary_operator(ternary_operator* node) {
 }
 
 bool ast_dumper::visit_binary_operator(binary_operator* node) {
+    if (node->get_optimized_number()) {
+        node->get_optimized_number()->accept(this);
+        return true;
+    }
+    if (node->get_optimized_string()) {
+        node->get_optimized_string()->accept(this);
+        return true;
+    }
     dump_indent();
     std::cout << "binary_operator ";
     switch(node->get_operator_type()) {
@@ -178,6 +186,10 @@ bool ast_dumper::visit_binary_operator(binary_operator* node) {
 }
 
 bool ast_dumper::visit_unary_operator(unary_operator* node) {
+    if (node->get_optimized_number()) {
+        node->get_optimized_number()->accept(this);
+        return true;
+    }
     dump_indent();
     std::cout << "unary_operator ";
     switch(node->get_operator_type()) {
diff --git a/src/nasal_new_ast.cpp b/src/nasal_new_ast.cpp
index cbc6bd1..79d1140 100644
--- a/src/nasal_new_ast.cpp
+++ b/src/nasal_new_ast.cpp
@@ -119,6 +119,12 @@ binary_operator::~binary_operator() {
     if (right) {
         delete right;
     }
+    if (optimized_const_number) {
+        delete optimized_const_number;
+    }
+    if (optimized_const_string) {
+        delete optimized_const_string;
+    }
 }
 
 void binary_operator::accept(ast_visitor* visitor) {
@@ -129,6 +135,9 @@ unary_operator::~unary_operator() {
     if (value) {
         delete value;
     }
+    if (optimized_number) {
+        delete optimized_number;
+    }
 }
 
 void unary_operator::accept(ast_visitor* visitor) {
diff --git a/src/nasal_new_ast.h b/src/nasal_new_ast.h
index f1dc306..c2a030d 100644
--- a/src/nasal_new_ast.h
+++ b/src/nasal_new_ast.h
@@ -299,18 +299,26 @@ private:
     binary_type type;
     expr* left;
     expr* right;
+    number_literal* optimized_const_number;
+    string_literal* optimized_const_string;
 
 public:
     binary_operator(const span& location):
         expr(location, expr_type::ast_binary),
-        left(nullptr), right(nullptr) {}
+        left(nullptr), right(nullptr),
+        optimized_const_number(nullptr),
+        optimized_const_string(nullptr) {}
     ~binary_operator();
     void set_operator_type(binary_type operator_type) {type = operator_type;}
     void set_left(expr* node) {left = node;}
     void set_right(expr* node) {right = node;}
+    void set_optimized_number(number_literal* node) {optimized_const_number = node;}
+    void set_optimized_string(string_literal* node) {optimized_const_string = node;}
     binary_type get_operator_type() const {return type;}
     expr* get_left() {return left;}
     expr* get_right() {return right;}
+    number_literal* get_optimized_number() {return optimized_const_number;}
+    string_literal* get_optimized_string() {return optimized_const_string;}
     void accept(ast_visitor*) override;
 };
 
@@ -325,16 +333,19 @@ public:
 private:
     unary_type type;
     expr* value;
+    number_literal* optimized_number;
 
 public:
     unary_operator(const span& location):
         expr(location, expr_type::ast_unary),
-        value(nullptr) {}
+        value(nullptr), optimized_number(nullptr) {}
     ~unary_operator();
     void set_operator_type(unary_type operator_type) {type = operator_type;}
     void set_value(expr* node) {value = node;}
+    void set_optimized_number(number_literal* node) {optimized_number = node;}
     unary_type get_operator_type() const {return type;}
     expr* get_value() {return value;}
+    number_literal* get_optimized_number() {return optimized_number;}
     void accept(ast_visitor*) override;
 };
 
diff --git a/src/nasal_new_codegen.cpp b/src/nasal_new_codegen.cpp
index a2f7065..745ed2b 100644
--- a/src/nasal_new_codegen.cpp
+++ b/src/nasal_new_codegen.cpp
@@ -829,6 +829,16 @@ void codegen::unary_gen(unary_operator* node) {
 }
 
 void codegen::binary_gen(binary_operator* node) {
+    // generate optimized result
+    if (node->get_optimized_number()) {
+        num_gen(node->get_optimized_number());
+        return;
+    }
+    if (node->get_optimized_string()) {
+        str_gen(node->get_optimized_string());
+        return;
+    }
+
     switch(node->get_operator_type()) {
         case binary_operator::binary_type::condition_or: or_gen(node); return;
         case binary_operator::binary_type::condition_and: and_gen(node); return;
diff --git a/src/nasal_new_gc.h b/src/nasal_new_gc.h
index 75cacb4..7e94558 100644
--- a/src/nasal_new_gc.h
+++ b/src/nasal_new_gc.h
@@ -29,7 +29,6 @@
 #include <thread>
 
 #include "nasal_new_header.h"
-#include "nasal_new_err.h"
 
 enum vm_type:u8 {
     /* none-gc object */
diff --git a/src/nasal_new_header.h b/src/nasal_new_header.h
index f2247a7..418601c 100644
--- a/src/nasal_new_header.h
+++ b/src/nasal_new_header.h
@@ -48,4 +48,6 @@ f64 dec2f(const char*);
 f64 str2num(const char*);
 i32 utf8_hdchk(const char);
 std::string chrhex(const char);
-std::string rawstr(const std::string&, const usize maxlen=0);
\ No newline at end of file
+std::string rawstr(const std::string&, const usize maxlen=0);
+
+#include "nasal_new_gc.h"
\ No newline at end of file
diff --git a/src/optimizer.cpp b/src/optimizer.cpp
index b24018c..ed5a0fe 100644
--- a/src/optimizer.cpp
+++ b/src/optimizer.cpp
@@ -1,18 +1,129 @@
 #include "optimizer.h"
 
-void optimizer::const_string(binary_operator* node) {
-
+void optimizer::const_string(
+    binary_operator* node,
+    string_literal* left_node,
+    string_literal* right_node) {
+    if (node->get_operator_type()!=binary_operator::binary_type::concat) {
+        return;
+    }
+    const auto& left = left_node->get_content();
+    const auto& right = right_node->get_content();
+    node->set_optimized_string(
+        new string_literal(node->get_location(), left+right));
 }
 
-void optimizer::const_number(binary_operator* node) {
-    
+void optimizer::const_number(
+    binary_operator* node,
+    number_literal* left_node,
+    number_literal* right_node) {
+    const auto left = left_node->get_number();
+    const auto right = right_node->get_number();
+    f64 res;
+    switch(node->get_operator_type()) {
+        case binary_operator::binary_type::add: res = left+right; break;
+        case binary_operator::binary_type::sub: res = left-right; break;
+        case binary_operator::binary_type::mult: res = left*right; break;
+        case binary_operator::binary_type::div: res = left/right; break;
+        case binary_operator::binary_type::less: res = left<right; break;
+        case binary_operator::binary_type::leq: res = left<=right; break;
+        case binary_operator::binary_type::grt: res = left>right; break;
+        case binary_operator::binary_type::geq: res = left>=right; break;
+        case binary_operator::binary_type::bitwise_or:
+            res = i32(left)|i32(right); break;
+        case binary_operator::binary_type::bitwise_xor:
+            res = i32(left)^i32(right); break;
+        case binary_operator::binary_type::bitwise_and:
+            res = i32(left)&i32(right); break;
+        default: return;
+    }
+    if (std::isinf(res) || std::isnan(res)) {
+        return;
+    }
+    node->set_optimized_number(
+        new number_literal(node->get_location(), res));
+}
+
+void optimizer::const_number(
+    unary_operator* node,
+    number_literal* value_node) {
+    auto res = value_node->get_number();
+    switch(node->get_operator_type()) {
+        case unary_operator::unary_type::negative: res = -res; break;
+        case unary_operator::unary_type::bitwise_not: res = ~i32(res); break;
+        case unary_operator::unary_type::logical_not: res = !res; break;
+    }
+    if (std::isinf(res) || std::isnan(res)) {
+        return;
+    }
+    node->set_optimized_number(
+        new number_literal(node->get_location(), res));
 }
 
 bool optimizer::visit_binary_operator(binary_operator* node) {
+    node->get_left()->accept(this);
+    node->get_right()->accept(this);
+    number_literal* left_num_node = nullptr;
+    number_literal* right_num_node = nullptr;
+    string_literal* left_str_node = nullptr;
+    string_literal* right_str_node = nullptr;
+    if (node->get_left()->get_type()==expr_type::ast_num) {
+        left_num_node = (number_literal*)node->get_left();
+    } else if (node->get_left()->get_type()==expr_type::ast_binary &&
+        ((binary_operator*)node->get_left())->get_optimized_number()) {
+        left_num_node = ((binary_operator*)node->get_left())->get_optimized_number();
+    } else if (node->get_left()->get_type()==expr_type::ast_unary &&
+        ((unary_operator*)node->get_left())->get_optimized_number()) {
+        left_num_node = ((unary_operator*)node->get_left())->get_optimized_number();
+    }
+    if (node->get_right()->get_type()==expr_type::ast_num) {
+        right_num_node = (number_literal*)node->get_right();
+    } else if (node->get_right()->get_type()==expr_type::ast_binary &&
+        ((binary_operator*)node->get_right())->get_optimized_number()) {
+        right_num_node = ((binary_operator*)node->get_right())->get_optimized_number();
+    } else if (node->get_right()->get_type()==expr_type::ast_unary &&
+        ((unary_operator*)node->get_right())->get_optimized_number()) {
+        right_num_node = ((unary_operator*)node->get_right())->get_optimized_number();
+    }
+
+    if (node->get_left()->get_type()==expr_type::ast_str) {
+        left_str_node = (string_literal*)node->get_left();
+    } else if (node->get_left()->get_type()==expr_type::ast_binary &&
+        ((binary_operator*)node->get_left())->get_optimized_string()) {
+        left_str_node = ((binary_operator*)node->get_left())->get_optimized_string();
+    }
+    if (node->get_right()->get_type()==expr_type::ast_str) {
+        right_str_node = (string_literal*)node->get_right();
+    } else if (node->get_right()->get_type()==expr_type::ast_binary &&
+        ((binary_operator*)node->get_right())->get_optimized_string()) {
+        right_str_node = ((binary_operator*)node->get_right())->get_optimized_string();
+    }
+    if (left_num_node && right_num_node) {
+        const_number(node, left_num_node, right_num_node);
+        return true;
+    }
+    if (left_str_node && right_str_node) {
+        const_string(node, left_str_node, right_str_node);
+        return true;
+    }
     return true;
 }
 
 bool optimizer::visit_unary_operator(unary_operator* node) {
+    node->get_value()->accept(this);
+    number_literal* value_node = nullptr;
+    if (node->get_value()->get_type()==expr_type::ast_num) {
+        value_node = (number_literal*)node->get_value();
+    } else if (node->get_value()->get_type()==expr_type::ast_binary &&
+        ((binary_operator*)node->get_value())->get_optimized_number()) {
+        value_node = ((binary_operator*)node->get_value())->get_optimized_number();
+    } else if (node->get_value()->get_type()==expr_type::ast_unary &&
+        ((unary_operator*)node->get_value())->get_optimized_number()) {
+        value_node = ((unary_operator*)node->get_value())->get_optimized_number();
+    }
+    if (value_node) {
+        const_number(node, value_node);
+    }
     return true;
 }
 
diff --git a/src/optimizer.h b/src/optimizer.h
index b26dabd..0ecc53a 100644
--- a/src/optimizer.h
+++ b/src/optimizer.h
@@ -7,8 +7,9 @@
 
 class optimizer:public ast_visitor {
 private:
-    void const_string(binary_operator*);
-    void const_number(binary_operator*);
+    void const_string(binary_operator*, string_literal*, string_literal*);
+    void const_number(binary_operator*, number_literal*, number_literal*);
+    void const_number(unary_operator*, number_literal*);
 
 public:
     bool visit_binary_operator(binary_operator*) override;
@@ -17,67 +18,3 @@ public:
 public:
     void do_optimization(code_block*);
 };
-
-// void const_str(ast& root) {
-//     auto& vec=root.child();
-//     root.set_str(vec[0].str()+vec[1].str());
-//     root.child().clear();
-//     root.set_type(ast_str);
-// }
-
-// void const_num(ast& root) {
-//     auto& vec=root.child();
-//     f64 res=0;
-//     switch(root.type()) {
-//         case ast_add:    res=vec[0].num()+vec[1].num(); break;
-//         case ast_sub:    res=vec[0].num()-vec[1].num(); break;
-//         case ast_mult:   res=vec[0].num()*vec[1].num(); break;
-//         case ast_div:    res=vec[0].num()/vec[1].num(); break;
-//         case ast_less:   res=vec[0].num()<vec[1].num(); break;
-//         case ast_leq:    res=vec[0].num()<=vec[1].num();break;
-//         case ast_grt:    res=vec[0].num()>vec[1].num(); break;
-//         case ast_geq:    res=vec[0].num()>=vec[1].num();break;
-//         case ast_bitor:  res=i32(vec[0].num())|i32(vec[1].num()); break;
-//         case ast_bitxor: res=i32(vec[0].num())^i32(vec[1].num()); break;
-//         case ast_bitand: res=i32(vec[0].num())&i32(vec[1].num()); break;
-//     }
-//     // inf and nan will cause number hashmap error in codegen
-//     if (std::isinf(res) || std::isnan(res)) {
-//         return;
-//     }
-//     root.set_num(res);
-//     root.child().clear();
-//     root.set_type(ast_num);
-// }
-
-// void calc_const(ast& root) {
-//     auto& vec=root.child();
-//     for(auto& i:vec) {
-//         calc_const(i);
-//     }
-//     if (vec.size()==1 && root.type()==ast_neg && vec[0].type()==ast_num) {
-//         f64 res=-vec[0].num();
-//         root.set_num(res);
-//         root.child().clear();
-//         root.set_type(ast_num);
-//         return;
-//     }
-//     if (vec.size()!=2) {
-//         return;
-//     }
-//     if (root.type()!=ast_add && root.type()!=ast_sub &&
-//        root.type()!=ast_mult && root.type()!=ast_div &&
-//        root.type()!=ast_link && root.type()!=ast_less &&
-//        root.type()!=ast_leq && root.type()!=ast_grt &&
-//        root.type()!=ast_geq && root.type()!=ast_bitor &&
-//        root.type()!=ast_bitxor && root.type()!=ast_bitand) {
-//         return;
-//     }
-//     if (root.type()==ast_link &&
-//        vec[0].type()==ast_str && vec[1].type()==ast_str) {
-//         const_str(root);
-//     } else if (root.type()!=ast_link &&
-//             vec[0].type()==ast_num && vec[1].type()==ast_num) {
-//         const_num(root);
-//     }
-// }
\ No newline at end of file
diff --git a/test/calc.nas b/test/calc.nas
index a14692e..6103183 100644
--- a/test/calc.nas
+++ b/test/calc.nas
@@ -2,7 +2,7 @@ import.std.padding;
 import.std.file;
 import.std.sort;
 
-var source=find_all_files_with_extension(".","cpp","h");
+var source=find_all_files_with_extension("./src","cpp","h");
 sort(source,func(a,b){return cmp(a,b)<0});
 
 var lib=find_all_files_with_extension("./std","nas");
@@ -78,7 +78,7 @@ var calc=func(codetype,files,path=""){
     return int(bytes/1024);
 }
 
-var all=calc("source code:",source)
+var all=calc("source code:",source,"src/")
     +calc("lib:",lib,"std/")
     +calc("test file:",testfile,"test/")
     +calc("module:",module,"module/");
diff --git a/test/md5compare.nas b/test/md5compare.nas
index a6e9566..1cb6ebc 100644
--- a/test/md5compare.nas
+++ b/test/md5compare.nas
@@ -54,9 +54,12 @@ var filechecksum=func(){
     foreach(var p;find_all_files_with_extension("./module","nas","cpp")) {
         append(files,"./module/"~p);
     }
-    foreach(var p;find_all_files_with_extension(".","cpp","h","md")) {
+    foreach(var p;find_all_files_with_extension(".","md")) {
         append(files,"./"~p);
     }
+    foreach(var p;find_all_files_with_extension("./src","cpp","h")) {
+        append(files,"./src/"~p);
+    }
     foreach(var p;find_all_files_with_extension("./doc","md")) {
         append(files,"./doc/"~p);
     }

From 917b4f6568277be0be45f636750f44a93cbd38b3 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sun, 2 Jul 2023 20:29:41 +0800
Subject: [PATCH 31/34] :bug: fix compile error in visual studio

---
 src/nasal_new_builtin.cpp | 99 ++++++++++++++++++++++++++++++++++++++-
 src/nasal_new_builtin.h   | 97 ++------------------------------------
 src/nasal_new_gc.h        |  2 +
 3 files changed, 102 insertions(+), 96 deletions(-)

diff --git a/src/nasal_new_builtin.cpp b/src/nasal_new_builtin.cpp
index a1bea78..da79b39 100644
--- a/src/nasal_new_builtin.cpp
+++ b/src/nasal_new_builtin.cpp
@@ -1,4 +1,4 @@
-#include "nasal_new_builtin.h"
+#include "nasal_new_builtin.h"
 
 var builtin_print(var* local, gc& ngc) {
     for(auto& i:local[1].vec().elems) {
@@ -1263,4 +1263,99 @@ var builtin_ghosttype(var* local, gc& ngc) {
         return var::num((u64)arg.obj().ptr);
     }
     return ngc.newstr(name);
-}
\ No newline at end of file
+}
+
+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},
+    {"__coyield", builtin_coyield },
+    {"__costatus",builtin_costatus},
+    {"__corun"   ,builtin_corun   },
+    {"__millisec",builtin_millisec},
+    {"__sysargv", builtin_sysargv },
+    {"__gcextd",  builtin_gcextend},
+    {"__logtime", builtin_logtime },
+    {"__ghosttype", builtin_ghosttype},
+    {nullptr,     nullptr         }
+};
\ No newline at end of file
diff --git a/src/nasal_new_builtin.h b/src/nasal_new_builtin.h
index ec983f8..f372127 100644
--- a/src/nasal_new_builtin.h
+++ b/src/nasal_new_builtin.h
@@ -131,100 +131,9 @@ var builtin_ghosttype(var*, gc&);
 
 // register builtin function's name and it's address here in this table below
 // this table must end with {nullptr,nullptr}
-struct {
+struct nasal_builtin_table {
     const char* name;
     var (*func)(var*,gc&);
-} 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},
-    {"__coyield", builtin_coyield },
-    {"__costatus",builtin_costatus},
-    {"__corun"   ,builtin_corun   },
-    {"__millisec",builtin_millisec},
-    {"__sysargv", builtin_sysargv },
-    {"__gcextd",  builtin_gcextend},
-    {"__logtime", builtin_logtime },
-    {"__ghosttype", builtin_ghosttype},
-    {nullptr,     nullptr         }
 };
+
+extern nasal_builtin_table builtin[];
diff --git a/src/nasal_new_gc.h b/src/nasal_new_gc.h
index 7e94558..fe84ae9 100644
--- a/src/nasal_new_gc.h
+++ b/src/nasal_new_gc.h
@@ -27,6 +27,8 @@
 #include <chrono>
 #include <algorithm>
 #include <thread>
+#include <cstring>
+#include <sstream>
 
 #include "nasal_new_header.h"
 

From da43ec5193efb5c112d8962f7553347499ebc5af Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sun, 2 Jul 2023 20:39:28 +0800
Subject: [PATCH 32/34] :memo: update docks

---
 README.md        | 13 +++++--------
 doc/README_zh.md | 15 ++++++---------
 doc/vs.md        | 43 -------------------------------------------
 3 files changed, 11 insertions(+), 60 deletions(-)
 delete mode 100644 doc/vs.md

diff --git a/README.md b/README.md
index b2dd19b..ea02047 100644
--- a/README.md
+++ b/README.md
@@ -59,7 +59,6 @@ the interpreter a useful tool in your own projects.
 ![windows](https://img.shields.io/badge/Microsoft-Windows-green?style=flat-square&logo=windows)
 ![macOS](https://img.shields.io/badge/Apple%20Inc.-MacOS-green?style=flat-square&logo=apple)
 ![linux](https://img.shields.io/badge/GNU-Linux-green?style=flat-square&logo=GNU)
-
 ![g++](https://img.shields.io/badge/GNU-g++-A42E2B?style=flat-square&logo=GNU)
 ![clang++](https://img.shields.io/badge/LLVM-clang++-262D3A?style=flat-square&logo=LLVM)
 ![vs](https://img.shields.io/badge/Visual_Studio-MSVC-5C2D91?style=flat-square&logo=visualstudio)
@@ -68,19 +67,17 @@ Better download the latest update source of the interpreter and build it! It's q
 
 __CAUTION__: If want to use the release zip/tar.gz file to build the interpreter, please read the [__Release Notes__](./doc/dev.md#release-notes) to make sure this release file has no fatal bugs.
 
-Use g++(`MinGW-w64`) or MSVC(`Visual Studio`) on `Windows` .
-
-Use g++/clang++ on `Linux/macOS/Unix` platform (we suggest `clang`).
-
-On `Windows (MinGW-w64)`:
+### __`Windows (MinGW-w64)`__
 
 Make sure your MinGW thread model is `posix thread model`, otherwise it may not have the thread library.
 
 > mingw32-make nasal.exe
 
-You could create project in `Visual Studio` by this way: [__Click__](./doc/vs.md).
+### __`Windows (Visual Studio)`__
 
-On `Linux/macOS/Unix`:
+This project gives a [__CMakelists.txt__](./CMakeLists.txt) for you to create project in `Visual Studio`.
+
+### __`Linux/macOS/Unix`__
 
 > make nasal
 
diff --git a/doc/README_zh.md b/doc/README_zh.md
index c8b7515..b7526bb 100644
--- a/doc/README_zh.md
+++ b/doc/README_zh.md
@@ -49,29 +49,26 @@ __如果有好的意见或建议，欢迎联系我们!__
 ![windows](https://img.shields.io/badge/Microsoft-Windows-green?style=flat-square&logo=windows)
 ![macOS](https://img.shields.io/badge/Apple%20Inc.-MacOS-green?style=flat-square&logo=apple)
 ![linux](https://img.shields.io/badge/GNU-Linux-green?style=flat-square&logo=GNU)
-
 ![g++](https://img.shields.io/badge/GNU-g++-A42E2B?style=flat-square&logo=GNU)
 ![clang++](https://img.shields.io/badge/LLVM-clang++-262D3A?style=flat-square&logo=LLVM)
 ![vs](https://img.shields.io/badge/Visual_Studio-MSVC-5C2D91?style=flat-square&logo=visualstudio)
 
-我们推荐你下载最新更新的代码包来直接编译，这个项目非常小巧,没有使用任何第三方库，因此编译起来非常轻松，
+我们推荐你下载最新代码包编译，这个项目非常小巧,没有使用任何第三方库，因此编译起来非常轻松，
 你只需要这两样东西: C++ 编译器以及make程序。
 
 __注意__: 如果你想直接下载发行版提供的zip/tar.gz压缩包来构建这个解释器，在下载之前请阅读[__发行日志__](../doc/dev_zh.md#发行日志)以保证这个发行版的文件中不包含非常严重的bug。
 
-`Windows` 用户通过 g++(`MinGW-w64`) 或者使用 MSVC(`Visual Studio`) 来进行编译。
-
-`Linux/macOS/Unix` 用户可以使用 g++ 或者 clang++ 来进行编译 (建议您使用 `clang`)。
-
-`Windows` 平台(`MinGW-w64`):
+### __`Windows` 平台(`MinGW-w64`)__
 
 一定要确保您的 MinGW thread model 是 `posix thread model`, 否则可能存在没有 thread 库的问题。
 
 > mingw32-make nasal.exe
 
-你也可以在`Visual Studio`中用这种方式来创建项目：[__点击跳转__](../doc/vs.md)。
+### __`Windows` 平台(`Vistual Studio`)__
 
-`Linux/macOS/Unix` 平台:
+项目提供了 [__CMakeLists.txt__](../CMakeLists.txt) 用于在`Visual Studio`中用这种方式来创建项目。
+
+### __`Linux/macOS/Unix` 平台__
 
 > make nasal
 
diff --git a/doc/vs.md b/doc/vs.md
deleted file mode 100644
index b828435..0000000
--- a/doc/vs.md
+++ /dev/null
@@ -1,43 +0,0 @@
-# Create VS project | 创建 VS 工程
-
-## First | 首先
-
-We give a [__CMakeLists.txt__](../CMakeLists.txt) for you to create new VS project from it.
-
-我们为你提供了 [__CMakeLists.txt__](../CMakeLists.txt) 用于创建新的 VS 工程。
-
-If you are using this way, you will __not need__ to continue reading.
-
-如果你使用的是这种方式，下面的内容你就 __不需要__ 再读了。
-
-Creating VS project from a CMake file is the __simplest__ way.
-
-从 CMake 文件创建 VS 工程是 __最简单__ 的方式。
-
-## How to Create VS project
-
-Make sure you are using VS 2022. You may not get the dynamic libraries by using this way to compile.
-
-1. Get code from this repo using `git`.
-
-2. In Visual Studio, click `File`->`New`->`Project From Existing Code...`.
-
-3. Select `Visual C++`->`Next`->choose `project file location`->write the `project name` at ease->`Finish`.
-
-4. Remove cpp files in `module` to avoid compilation problems.(they should be compiled to dynamic libraries)
-
-5. Click `Source Files` in `Search Solution Explorer` at left, right click `main.cpp`, compile.
-
-## 如何创建VS工程
-
-确保你使用的是 VS 2022。这个方式可能无法生成一些动态库。
-
-1. 用 `git` 从这个仓库获取代码。
-
-2. 在VS的界面，点击文件(F)->新建(N)->从现有代码创建项目(E)。
-
-3. 选择创建 `Visual C++` 项目->下一步->项目文件位置选择你下载的代码存放的文件夹->填项目名称，随便写->完成。
-
-4. 从项目中去掉 `module` 里的cpp文件，以防止编译错误。(那些本应该编译到动态库)
-
-5. 点开左侧解决方案资源管理器中的 `Source Files`，右键点击 `main.cpp`，编译。

From 45f87925aeef5fadee0fd39d55dab16f7d72f340 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sun, 2 Jul 2023 21:37:14 +0800
Subject: [PATCH 33/34] :memo: change license to GPLv2

---
 LICENSE                      | 352 +++++++++++++++++++++++++++++++++--
 README.md                    |   4 +-
 doc/README_zh.md             |   4 +-
 doc/nasal-http-test-web.html |   7 +-
 4 files changed, 342 insertions(+), 25 deletions(-)

diff --git a/LICENSE b/LICENSE
index 36c4b17..ecbc059 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,21 +1,339 @@
-MIT License
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
 
-Copyright (c) 2019-2023 ValKmjolnir
+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
+ 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+                            Preamble
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+  The licenses for most software are designed to take away your
+freedom to share and change it.  By contrast, the GNU General Public
+License is intended to guarantee your freedom to share and change free
+software--to make sure the software is free for all its users.  This
+General Public License applies to most of the Free Software
+Foundation's software and to any other program whose authors commit to
+using it.  (Some other Free Software Foundation software is covered by
+the GNU Lesser General Public License instead.)  You can apply it to
+your programs, too.
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+this service if you wish), that you receive source code or can get it
+if you want it, that you can change the software or use pieces of it
+in new free programs; and that you know you can do these things.
+
+  To protect your rights, we need to make restrictions that forbid
+anyone to deny you these rights or to ask you to surrender the rights.
+These restrictions translate to certain responsibilities for you if you
+distribute copies of the software, or if you modify it.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must give the recipients all the rights that
+you have.  You must make sure that they, too, receive or can get the
+source code.  And you must show them these terms so they know their
+rights.
+
+  We protect your rights with two steps: (1) copyright the software, and
+(2) offer you this license which gives you legal permission to copy,
+distribute and/or modify the software.
+
+  Also, for each author's protection and ours, we want to make certain
+that everyone understands that there is no warranty for this free
+software.  If the software is modified by someone else and passed on, we
+want its recipients to know that what they have is not the original, so
+that any problems introduced by others will not reflect on the original
+authors' reputations.
+
+  Finally, any free program is threatened constantly by software
+patents.  We wish to avoid the danger that redistributors of a free
+program will individually obtain patent licenses, in effect making the
+program proprietary.  To prevent this, we have made it clear that any
+patent must be licensed for everyone's free use or not licensed at all.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                    GNU GENERAL PUBLIC LICENSE
+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
+
+  0. This License applies to any program or other work which contains
+a notice placed by the copyright holder saying it may be distributed
+under the terms of this General Public License.  The "Program", below,
+refers to any such program or work, and a "work based on the Program"
+means either the Program or any derivative work under copyright law:
+that is to say, a work containing the Program or a portion of it,
+either verbatim or with modifications and/or translated into another
+language.  (Hereinafter, translation is included without limitation in
+the term "modification".)  Each licensee is addressed as "you".
+
+Activities other than copying, distribution and modification are not
+covered by this License; they are outside its scope.  The act of
+running the Program is not restricted, and the output from the Program
+is covered only if its contents constitute a work based on the
+Program (independent of having been made by running the Program).
+Whether that is true depends on what the Program does.
+
+  1. You may copy and distribute verbatim copies of the Program's
+source code as you receive it, in any medium, provided that you
+conspicuously and appropriately publish on each copy an appropriate
+copyright notice and disclaimer of warranty; keep intact all the
+notices that refer to this License and to the absence of any warranty;
+and give any other recipients of the Program a copy of this License
+along with the Program.
+
+You may charge a fee for the physical act of transferring a copy, and
+you may at your option offer warranty protection in exchange for a fee.
+
+  2. You may modify your copy or copies of the Program or any portion
+of it, thus forming a work based on the Program, and copy and
+distribute such modifications or work under the terms of Section 1
+above, provided that you also meet all of these conditions:
+
+    a) You must cause the modified files to carry prominent notices
+    stating that you changed the files and the date of any change.
+
+    b) You must cause any work that you distribute or publish, that in
+    whole or in part contains or is derived from the Program or any
+    part thereof, to be licensed as a whole at no charge to all third
+    parties under the terms of this License.
+
+    c) If the modified program normally reads commands interactively
+    when run, you must cause it, when started running for such
+    interactive use in the most ordinary way, to print or display an
+    announcement including an appropriate copyright notice and a
+    notice that there is no warranty (or else, saying that you provide
+    a warranty) and that users may redistribute the program under
+    these conditions, and telling the user how to view a copy of this
+    License.  (Exception: if the Program itself is interactive but
+    does not normally print such an announcement, your work based on
+    the Program is not required to print an announcement.)
+
+These requirements apply to the modified work as a whole.  If
+identifiable sections of that work are not derived from the Program,
+and can be reasonably considered independent and separate works in
+themselves, then this License, and its terms, do not apply to those
+sections when you distribute them as separate works.  But when you
+distribute the same sections as part of a whole which is a work based
+on the Program, the distribution of the whole must be on the terms of
+this License, whose permissions for other licensees extend to the
+entire whole, and thus to each and every part regardless of who wrote it.
+
+Thus, it is not the intent of this section to claim rights or contest
+your rights to work written entirely by you; rather, the intent is to
+exercise the right to control the distribution of derivative or
+collective works based on the Program.
+
+In addition, mere aggregation of another work not based on the Program
+with the Program (or with a work based on the Program) on a volume of
+a storage or distribution medium does not bring the other work under
+the scope of this License.
+
+  3. You may copy and distribute the Program (or a work based on it,
+under Section 2) in object code or executable form under the terms of
+Sections 1 and 2 above provided that you also do one of the following:
+
+    a) Accompany it with the complete corresponding machine-readable
+    source code, which must be distributed under the terms of Sections
+    1 and 2 above on a medium customarily used for software interchange; or,
+
+    b) Accompany it with a written offer, valid for at least three
+    years, to give any third party, for a charge no more than your
+    cost of physically performing source distribution, a complete
+    machine-readable copy of the corresponding source code, to be
+    distributed under the terms of Sections 1 and 2 above on a medium
+    customarily used for software interchange; or,
+
+    c) Accompany it with the information you received as to the offer
+    to distribute corresponding source code.  (This alternative is
+    allowed only for noncommercial distribution and only if you
+    received the program in object code or executable form with such
+    an offer, in accord with Subsection b above.)
+
+The source code for a work means the preferred form of the work for
+making modifications to it.  For an executable work, complete source
+code means all the source code for all modules it contains, plus any
+associated interface definition files, plus the scripts used to
+control compilation and installation of the executable.  However, as a
+special exception, the source code distributed need not include
+anything that is normally distributed (in either source or binary
+form) with the major components (compiler, kernel, and so on) of the
+operating system on which the executable runs, unless that component
+itself accompanies the executable.
+
+If distribution of executable or object code is made by offering
+access to copy from a designated place, then offering equivalent
+access to copy the source code from the same place counts as
+distribution of the source code, even though third parties are not
+compelled to copy the source along with the object code.
+
+  4. You may not copy, modify, sublicense, or distribute the Program
+except as expressly provided under this License.  Any attempt
+otherwise to copy, modify, sublicense or distribute the Program is
+void, and will automatically terminate your rights under this License.
+However, parties who have received copies, or rights, from you under
+this License will not have their licenses terminated so long as such
+parties remain in full compliance.
+
+  5. You are not required to accept this License, since you have not
+signed it.  However, nothing else grants you permission to modify or
+distribute the Program or its derivative works.  These actions are
+prohibited by law if you do not accept this License.  Therefore, by
+modifying or distributing the Program (or any work based on the
+Program), you indicate your acceptance of this License to do so, and
+all its terms and conditions for copying, distributing or modifying
+the Program or works based on it.
+
+  6. Each time you redistribute the Program (or any work based on the
+Program), the recipient automatically receives a license from the
+original licensor to copy, distribute or modify the Program subject to
+these terms and conditions.  You may not impose any further
+restrictions on the recipients' exercise of the rights granted herein.
+You are not responsible for enforcing compliance by third parties to
+this License.
+
+  7. If, as a consequence of a court judgment or allegation of patent
+infringement or for any other reason (not limited to patent issues),
+conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot
+distribute so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you
+may not distribute the Program at all.  For example, if a patent
+license would not permit royalty-free redistribution of the Program by
+all those who receive copies directly or indirectly through you, then
+the only way you could satisfy both it and this License would be to
+refrain entirely from distribution of the Program.
+
+If any portion of this section is held invalid or unenforceable under
+any particular circumstance, the balance of the section is intended to
+apply and the section as a whole is intended to apply in other
+circumstances.
+
+It is not the purpose of this section to induce you to infringe any
+patents or other property right claims or to contest validity of any
+such claims; this section has the sole purpose of protecting the
+integrity of the free software distribution system, which is
+implemented by public license practices.  Many people have made
+generous contributions to the wide range of software distributed
+through that system in reliance on consistent application of that
+system; it is up to the author/donor to decide if he or she is willing
+to distribute software through any other system and a licensee cannot
+impose that choice.
+
+This section is intended to make thoroughly clear what is believed to
+be a consequence of the rest of this License.
+
+  8. If the distribution and/or use of the Program is restricted in
+certain countries either by patents or by copyrighted interfaces, the
+original copyright holder who places the Program under this License
+may add an explicit geographical distribution limitation excluding
+those countries, so that distribution is permitted only in or among
+countries not thus excluded.  In such case, this License incorporates
+the limitation as if written in the body of this License.
+
+  9. The Free Software Foundation may publish revised and/or new versions
+of the General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+Each version is given a distinguishing version number.  If the Program
+specifies a version number of this License which applies to it and "any
+later version", you have the option of following the terms and conditions
+either of that version or of any later version published by the Free
+Software Foundation.  If the Program does not specify a version number of
+this License, you may choose any version ever published by the Free Software
+Foundation.
+
+  10. If you wish to incorporate parts of the Program into other free
+programs whose distribution conditions are different, write to the author
+to ask for permission.  For software which is copyrighted by the Free
+Software Foundation, write to the Free Software Foundation; we sometimes
+make exceptions for this.  Our decision will be guided by the two goals
+of preserving the free status of all derivatives of our free software and
+of promoting the sharing and reuse of software generally.
+
+                            NO WARRANTY
+
+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY
+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN
+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES
+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED
+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS
+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE
+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,
+REPAIR OR CORRECTION.
+
+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,
+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING
+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED
+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY
+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGES.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+convey the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License along
+    with this program; if not, write to the Free Software Foundation, Inc.,
+    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+
+Also add information on how to contact you by electronic and paper mail.
+
+If the program is interactive, make it output a short notice like this
+when it starts in an interactive mode:
+
+    Gnomovision version 69, Copyright (C) year name of author
+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, the commands you use may
+be called something other than `show w' and `show c'; they could even be
+mouse-clicks or menu items--whatever suits your program.
+
+You should also get your employer (if you work as a programmer) or your
+school, if any, to sign a "copyright disclaimer" for the program, if
+necessary.  Here is a sample; alter the names:
+
+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
+  `Gnomovision' (which makes passes at compilers) written by James Hacker.
+
+  <signature of Ty Coon>, 1 April 1989
+  Ty Coon, President of Vice
+
+This General Public License does not permit incorporating your program into
+proprietary programs.  If your program is a subroutine library, you may
+consider it more useful to permit linking proprietary applications with the
+library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.
\ No newline at end of file
diff --git a/README.md b/README.md
index ea02047..153fc09 100644
--- a/README.md
+++ b/README.md
@@ -5,7 +5,7 @@
 ![GitHub code size](https://img.shields.io/github/languages/code-size/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
 ![GitHub release(latest by date)](https://img.shields.io/github/v/release/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
 ![in dev](https://img.shields.io/badge/dev-v11.0-blue?style=flat-square&logo=github)
-[![license](https://img.shields.io/badge/license-MIT-green?style=flat-square&logo=github)](./LICENSE)
+[![license](https://img.shields.io/badge/license-GPLv2-green?style=flat-square&logo=github)](./LICENSE)
 
 > This document is also available in: [__中文__](./doc/README_zh.md) | [__English__](./README.md)
 
@@ -36,7 +36,7 @@ This interpreter is totally rewritten by [ValKmjolnir](https://github.com/ValKmj
 without reusing the code in [Andy Ross's nasal interpreter](https://github.com/andyross/nasal).
 But we really appreciate that Andy created this amazing programming language.
 
-This project uses __MIT license__ (2021/5/4).
+This project uses __MIT license__ (2019/7~2021/5/4~2023/5), __GPL v2 license__ (since 2023/6).
 
 ### __Why writing this nasal interpreter?__
 
diff --git a/doc/README_zh.md b/doc/README_zh.md
index b7526bb..aef8878 100644
--- a/doc/README_zh.md
+++ b/doc/README_zh.md
@@ -5,7 +5,7 @@
 ![GitHub code size](https://img.shields.io/github/languages/code-size/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
 ![GitHub release(latest by date)](https://img.shields.io/github/v/release/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github)
 ![in dev](https://img.shields.io/badge/dev-v11.0-blue?style=flat-square&logo=github)
-[![license](https://img.shields.io/badge/license-MIT-green?style=flat-square&logo=github)](../LICENSE)
+[![license](https://img.shields.io/badge/license-GPLv2-green?style=flat-square&logo=github)](../LICENSE)
 
 > 这篇文档包含多语言版本: [__中文__](../doc/README_zh.md) | [__English__](../README.md)
 
@@ -34,7 +34,7 @@ __如果有好的意见或建议，欢迎联系我们!__
 
 该解释器项目由 [ValKmjolnir](https://github.com/ValKmjolnir) 完全使用 `C++`(`-std=c++14`)重新实现，没有复用 [Andy Ross的nasal解释器](https://github.com/andyross/nasal) 中的任何一行代码。尽管没有参考任何代码，我们依然非常感谢Andy为我们带来了这样一个神奇且简洁的编程语言。
 
-该项目已使用 __MIT__ 协议开源 (2021/5/4)。
+该项目使用 __MIT__ 协议开源 (2019/7~2021/5/4~2023/5)，从 2023/6 开始使用 __GPL v2__ 协议。
 
 ### __我们为什么想要重新写一个nasal解释器?__
 
diff --git a/doc/nasal-http-test-web.html b/doc/nasal-http-test-web.html
index 52d04bb..a4f8307 100644
--- a/doc/nasal-http-test-web.html
+++ b/doc/nasal-http-test-web.html
@@ -37,7 +37,7 @@
             <a href="https://github.com/ValKmjolnir/Nasal-Interpreter"><img src="https://img.shields.io/github/languages/code-size/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github"></img></a>
             <a href="https://github.com/ValKmjolnir/Nasal-Interpreter"><img src="https://img.shields.io/github/v/release/ValKmjolnir/Nasal-Interpreter?style=flat-square&logo=github"></img></a>
             <a href="https://github.com/ValKmjolnir/Nasal-Interpreter"><img src="https://img.shields.io/badge/dev-v10.0-blue?style=flat-square&logo=github"></img></a>
-            <a href="https://github.com/ValKmjolnir/Nasal-Interpreter"><img src="https://img.shields.io/badge/license-MIT-green?style=flat-square&logo=github"><br/></img></a>
+            <a href="https://github.com/ValKmjolnir/Nasal-Interpreter"><img src="https://img.shields.io/badge/license-GPLv2-green?style=flat-square&logo=github"><br/></img></a>
         </div>
         <h2>&nbsp;Introduction | 介绍</h2>
         <text>
@@ -51,12 +51,11 @@
             <p>
                 The interpreter is totally rewritten by <a href="https://github.com/ValKmjolnir">ValKmjolnir</a> using C++(-std=c++11) without reusing the code in Andy Ross's nasal interpreter.
                 But we really appreciate that Andy created this amazing programming language and his interpreter project.
-                Now this project uses <a href="/license">MIT license</a> (2021/5/4). Edit it if you want, use this project to learn or create more interesting things(But don't forget me XD).<br/>
+                Now this project uses <a href="/license">GPL-2.0 license</a> (2021/5/4).<br/>
             </p>
             <p>
                 这个解释器是由<a href="https://github.com/ValKmjolnir">ValKmjolnir</a>用C++11编写的，完全没有复用Andy Ross版解释器的代码。但是我们仍然非常感谢Andy为我们带来了这么一款有趣的编程语言。
-                现在这个项目使用<a href="/license">MIT协议</a>开源 (2021/5/4)。
-                如果你有需求，可以自行修改，用这个解释器项目来学习或者创造更有意思的东西吧！(不过别忘了在项目协议中留下原作者名字哦)
+                现在这个项目使用<a href="/license">GPL-2.0协议</a>开源。
             </p>
         </text>
         <h2>&nbsp;Benchmark | 执行效率</h2>

From 27bc544bbe38bb863065d9ab6ca9fda847f97bf6 Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Sun, 2 Jul 2023 22:02:31 +0800
Subject: [PATCH 34/34] :memo: rename files

---
 CMakeLists.txt                                | 30 +++---
 makefile                                      | 91 +++++++++----------
 module/fib.cpp                                |  2 +-
 module/keyboard.cpp                           |  2 +-
 module/makefile                               |  4 +-
 module/matrix.cpp                             |  2 +-
 module/nasocket.cpp                           |  2 +-
 src/ast_visitor.h                             |  2 +-
 src/{nasal_new_main.cpp => main.cpp}          | 18 ++--
 src/{nasal_new_header.h => nasal.h}           |  2 +-
 src/{nasal_new_ast.cpp => nasal_ast.cpp}      |  2 +-
 src/{nasal_new_ast.h => nasal_ast.h}          |  4 +-
 ...asal_new_builtin.cpp => nasal_builtin.cpp} |  2 +-
 src/{nasal_new_builtin.h => nasal_builtin.h}  |  4 +-
 ...asal_new_codegen.cpp => nasal_codegen.cpp} |  2 +-
 src/{nasal_new_codegen.h => nasal_codegen.h}  | 12 +--
 src/{nasal_new_dbg.cpp => nasal_dbg.cpp}      |  2 +-
 src/{nasal_new_dbg.h => nasal_dbg.h}          |  8 +-
 src/{nasal_new_err.cpp => nasal_err.cpp}      |  2 +-
 src/{nasal_new_err.h => nasal_err.h}          |  2 +-
 src/{nasal_new_gc.cpp => nasal_gc.cpp}        |  2 +-
 src/{nasal_new_gc.h => nasal_gc.h}            |  2 +-
 ...{nasal_new_import.cpp => nasal_import.cpp} |  2 +-
 src/{nasal_new_import.h => nasal_import.h}    |  8 +-
 src/{nasal_new_lexer.cpp => nasal_lexer.cpp}  |  2 +-
 src/{nasal_new_lexer.h => nasal_lexer.h}      |  4 +-
 src/{nasal_new_misc.cpp => nasal_misc.cpp}    |  2 +-
 ...{nasal_new_opcode.cpp => nasal_opcode.cpp} |  2 +-
 src/{nasal_new_opcode.h => nasal_opcode.h}    |  4 +-
 src/{nasal_new_parse.cpp => nasal_parse.cpp}  |  4 +-
 src/{nasal_new_parse.h => nasal_parse.h}      |  8 +-
 src/{nasal_new_vm.cpp => nasal_vm.cpp}        |  2 +-
 src/{nasal_new_vm.h => nasal_vm.h}            |  6 +-
 src/optimizer.h                               |  2 +-
 src/symbol_finder.h                           |  2 +-
 35 files changed, 122 insertions(+), 125 deletions(-)
 rename src/{nasal_new_main.cpp => main.cpp} (95%)
 rename src/{nasal_new_header.h => nasal.h} (93%)
 rename src/{nasal_new_ast.cpp => nasal_ast.cpp} (94%)
 rename src/{nasal_new_ast.h => nasal_ast.h} (96%)
 rename src/{nasal_new_builtin.cpp => nasal_builtin.cpp} (96%)
 rename src/{nasal_new_builtin.h => nasal_builtin.h} (98%)
 rename src/{nasal_new_codegen.cpp => nasal_codegen.cpp} (97%)
 rename src/{nasal_new_codegen.h => nasal_codegen.h} (94%)
 rename src/{nasal_new_dbg.cpp => nasal_dbg.cpp} (96%)
 rename src/{nasal_new_dbg.h => nasal_dbg.h} (91%)
 rename src/{nasal_new_err.cpp => nasal_err.cpp} (95%)
 rename src/{nasal_new_err.h => nasal_err.h} (97%)
 rename src/{nasal_new_gc.cpp => nasal_gc.cpp} (95%)
 rename src/{nasal_new_gc.h => nasal_gc.h} (99%)
 rename src/{nasal_new_import.cpp => nasal_import.cpp} (96%)
 rename src/{nasal_new_import.h => nasal_import.h} (84%)
 rename src/{nasal_new_lexer.cpp => nasal_lexer.cpp} (96%)
 rename src/{nasal_new_lexer.h => nasal_lexer.h} (98%)
 rename src/{nasal_new_misc.cpp => nasal_misc.cpp} (94%)
 rename src/{nasal_new_opcode.cpp => nasal_opcode.cpp} (96%)
 rename src/{nasal_new_opcode.h => nasal_opcode.h} (98%)
 rename src/{nasal_new_parse.cpp => nasal_parse.cpp} (96%)
 rename src/{nasal_new_parse.h => nasal_parse.h} (94%)
 rename src/{nasal_new_vm.cpp => nasal_vm.cpp} (96%)
 rename src/{nasal_new_vm.h => nasal_vm.h} (99%)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index fdd7981..38a182f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -18,25 +18,25 @@ set(CMAKE_BUILD_TYPE "Release")
 set(NASAL_OBJECT_SOURCE_FILE
     ${CMAKE_SOURCE_DIR}/src/ast_dumper.cpp
     ${CMAKE_SOURCE_DIR}/src/ast_visitor.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_ast.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_builtin.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_codegen.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_dbg.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_err.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_gc.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_import.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_lexer.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_misc.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_opcode.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_parse.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_vm.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_ast.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_builtin.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_codegen.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_dbg.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_err.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_gc.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_import.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_lexer.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_misc.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_opcode.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_parse.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_vm.cpp
     ${CMAKE_SOURCE_DIR}/src/optimizer.cpp
     ${CMAKE_SOURCE_DIR}/src/symbol_finder.cpp)
 add_library(nasal-object STATIC ${NASAL_OBJECT_SOURCE_FILE})
 target_include_directories(nasal-object PRIVATE ${CMAKE_SOURCE_DIR}/src)
 
 # build nasal
-add_executable(nasal ${CMAKE_SOURCE_DIR}/src/nasal_new_main.cpp)
+add_executable(nasal ${CMAKE_SOURCE_DIR}/src/main.cpp)
 target_link_libraries(nasal nasal-object)
 if(NOT CMAKE_HOST_SYSTEM_NAME MATCHES "Windows")
     target_link_libraries(nasal dl)
@@ -55,8 +55,8 @@ endif()
 set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/module)
 
 set(MODULE_USED_OBJECT_SOURCE_FILE
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_misc.cpp
-    ${CMAKE_SOURCE_DIR}/src/nasal_new_gc.cpp)
+    ${CMAKE_SOURCE_DIR}/src/nasal_misc.cpp
+    ${CMAKE_SOURCE_DIR}/src/nasal_gc.cpp)
 add_library(module-used-object STATIC ${MODULE_USED_OBJECT_SOURCE_FILE})
 
 add_library(fib SHARED ${CMAKE_SOURCE_DIR}/module/fib.cpp)
diff --git a/makefile b/makefile
index 6c04e62..55ec0db 100644
--- a/makefile
+++ b/makefile
@@ -1,23 +1,23 @@
 STD=c++17
 
 NASAL_OBJECT=\
-	nasal_new_err.o\
-	nasal_new_ast.o\
+	nasal_err.o\
+	nasal_ast.o\
 	ast_visitor.o\
 	ast_dumper.o\
-	nasal_new_lexer.o\
-	nasal_new_parse.o\
-	nasal_new_import.o\
+	nasal_lexer.o\
+	nasal_parse.o\
+	nasal_import.o\
 	optimizer.o\
-	nasal_new_opcode.o\
+	nasal_opcode.o\
 	symbol_finder.o\
-	nasal_new_codegen.o\
-	nasal_new_misc.o\
-	nasal_new_gc.o\
-	nasal_new_builtin.o\
-	nasal_new_vm.o\
-	nasal_new_dbg.o\
-	nasal_new_main.o
+	nasal_codegen.o\
+	nasal_misc.o\
+	nasal_gc.o\
+	nasal_builtin.o\
+	nasal_vm.o\
+	nasal_dbg.o\
+	main.o
 
 # for test
 nasal: $(NASAL_OBJECT)
@@ -26,65 +26,62 @@ nasal: $(NASAL_OBJECT)
 nasal.exe: $(NASAL_OBJECT)
 	$(CXX) $(NASAL_OBJECT) -O3 -o nasal.exe
 
-nasal_new_main.o: src/nasal_new_main.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_main.cpp -fno-exceptions -fPIC -o nasal_new_main.o -I .
+main.o: src/main.cpp
+	$(CXX) -std=$(STD) -c -O3 src/main.cpp -fno-exceptions -fPIC -o main.o -I .
 
-nasal_new_misc.o: src/nasal_new_header.h src/nasal_new_misc.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_misc.cpp -fno-exceptions -fPIC -o nasal_new_misc.o -I .
+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 .
 
-nasal_new_err.o: src/nasal_new_err.h src/nasal_new_err.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_err.cpp -fno-exceptions -fPIC -o nasal_new_err.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 .
 
-nasal_new_gc.o: src/nasal_new_gc.h src/nasal_new_gc.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_gc.cpp -fno-exceptions -fPIC -o nasal_new_gc.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 . 
 
-nasal_new_import.o: src/nasal_new_import.h src/nasal_new_import.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_import.cpp -fno-exceptions -fPIC -o nasal_new_import.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 .
 
-nasal_new_lexer.o: src/nasal_new_lexer.h src/nasal_new_lexer.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_lexer.cpp -fno-exceptions -fPIC -o nasal_new_lexer.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 .
 
-nasal_new_ast.o: src/nasal_new_ast.h src/nasal_new_ast.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.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 .
 
-nasal_new_builtin.o: src/nasal_new_builtin.h src/nasal_new_builtin.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_builtin.cpp -fno-exceptions -fPIC -o nasal_new_builtin.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 .
 
-nasal_new_codegen.o: src/nasal_new_codegen.h src/nasal_new_codegen.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_codegen.cpp -fno-exceptions -fPIC -o nasal_new_codegen.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 .
 
-nasal_new_opcode.o: src/nasal_new_opcode.h src/nasal_new_opcode.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_opcode.cpp -fno-exceptions -fPIC -o nasal_new_opcode.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 .
 
-nasal_new_parse.o: src/nasal_new_parse.h src/nasal_new_parse.cpp src/nasal_new_ast.h
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_parse.cpp -fno-exceptions -fPIC -o nasal_new_parse.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 .
 
-optimizer.o: src/optimizer.h src/optimizer.cpp src/nasal_new_ast.h
+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 .
 
-symbol_finder.o: src/symbol_finder.h src/symbol_finder.cpp src/nasal_new_ast.h
+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 .
 
-ast_visitor.o: src/nasal_new_ast.h src/ast_visitor.h src/ast_visitor.cpp
+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 .
 
-ast_dumper.o: src/nasal_new_ast.h src/ast_visitor.h src/ast_dumper.h src/ast_dumper.cpp
+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 .
 
-nasal_new_vm.o: src/nasal_new_vm.h src/nasal_new_vm.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_vm.cpp -fno-exceptions -fPIC -o nasal_new_vm.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 .
 
-nasal_new_dbg.o: src/nasal_new_dbg.h src/nasal_new_dbg.cpp
-	$(CXX) -std=$(STD) -c -O3 src/nasal_new_dbg.cpp -fno-exceptions -fPIC -o nasal_new_dbg.o -I .
-
-.PHONY: nasal_new_clean
-nasal_new_clean:
-	rm $(NASAL_OBJECT)
+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 .
 
 .PHONY: clean
 clean:
 	@ echo "[clean] nasal" && if [ -e nasal ]; then rm nasal; fi
 	@ echo "[clean] nasal.exe" && if [ -e nasal.exe ]; then rm nasal.exe; fi
+	@ rm $(NASAL_OBJECT)
 
 .PHONY: test
 test:nasal
diff --git a/module/fib.cpp b/module/fib.cpp
index 1ff1891..1e6ae92 100644
--- a/module/fib.cpp
+++ b/module/fib.cpp
@@ -1,7 +1,7 @@
 // module for test
 
 #include <iostream>
-#include "../src/nasal_new_header.h"
+#include "../src/nasal.h"
 
 namespace nasal_fib_module {
 
diff --git a/module/keyboard.cpp b/module/keyboard.cpp
index da2f9c5..18f0368 100644
--- a/module/keyboard.cpp
+++ b/module/keyboard.cpp
@@ -1,4 +1,4 @@
-#include "../src/nasal_new_header.h"
+#include "../src/nasal.h"
 #include <iostream>
 
 #ifndef _MSC_VER
diff --git a/module/makefile b/module/makefile
index 33c6b4e..4e635b0 100644
--- a/module/makefile
+++ b/module/makefile
@@ -3,8 +3,8 @@
 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_new_header.h ../src/nasal_new_gc.h
-used_object = ../nasal_new_misc.o ../nasal_new_gc.o
+used_header = ../src/nasal.h ../src/nasal_gc.h
+used_object = ../nasal_misc.o ../nasal_gc.o
 
 STD=c++17
 
diff --git a/module/matrix.cpp b/module/matrix.cpp
index da3cbdc..8d1f582 100644
--- a/module/matrix.cpp
+++ b/module/matrix.cpp
@@ -1,4 +1,4 @@
-#include "../src/nasal_new_header.h"
+#include "../src/nasal.h"
 #include <cmath>
 
 var nas_vec2(var* args, usize size, gc* ngc) {
diff --git a/module/nasocket.cpp b/module/nasocket.cpp
index 902fe9a..5fffe8b 100644
--- a/module/nasocket.cpp
+++ b/module/nasocket.cpp
@@ -1,4 +1,4 @@
-#include "../src/nasal_new_header.h"
+#include "../src/nasal.h"
 
 #ifndef _MSC_VER
 #include <unistd.h>
diff --git a/src/ast_visitor.h b/src/ast_visitor.h
index e9b407f..4c2a1ed 100644
--- a/src/ast_visitor.h
+++ b/src/ast_visitor.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "nasal_new_ast.h"
+#include "nasal_ast.h"
 
 class ast_visitor {
 public:
diff --git a/src/nasal_new_main.cpp b/src/main.cpp
similarity index 95%
rename from src/nasal_new_main.cpp
rename to src/main.cpp
index ae6efff..8202636 100644
--- a/src/nasal_new_main.cpp
+++ b/src/main.cpp
@@ -1,16 +1,16 @@
-#include "nasal_new_header.h"
-#include "nasal_new_err.h"
-#include "nasal_new_lexer.h"
-#include "nasal_new_ast.h"
-#include "nasal_new_parse.h"
-#include "nasal_new_import.h"
+#include "nasal.h"
+#include "nasal_err.h"
+#include "nasal_lexer.h"
+#include "nasal_ast.h"
+#include "nasal_parse.h"
+#include "nasal_import.h"
 #include "ast_visitor.h"
 #include "ast_dumper.h"
 #include "symbol_finder.h"
 #include "optimizer.h"
-#include "nasal_new_codegen.h"
-#include "nasal_new_vm.h"
-#include "nasal_new_dbg.h"
+#include "nasal_codegen.h"
+#include "nasal_vm.h"
+#include "nasal_dbg.h"
 
 #include <unordered_map>
 #include <thread>
diff --git a/src/nasal_new_header.h b/src/nasal.h
similarity index 93%
rename from src/nasal_new_header.h
rename to src/nasal.h
index 418601c..f12c9a4 100644
--- a/src/nasal_new_header.h
+++ b/src/nasal.h
@@ -50,4 +50,4 @@ i32 utf8_hdchk(const char);
 std::string chrhex(const char);
 std::string rawstr(const std::string&, const usize maxlen=0);
 
-#include "nasal_new_gc.h"
\ No newline at end of file
+#include "nasal_gc.h"
\ No newline at end of file
diff --git a/src/nasal_new_ast.cpp b/src/nasal_ast.cpp
similarity index 94%
rename from src/nasal_new_ast.cpp
rename to src/nasal_ast.cpp
index 79d1140..5eb9aee 100644
--- a/src/nasal_new_ast.cpp
+++ b/src/nasal_ast.cpp
@@ -1,4 +1,4 @@
-#include "nasal_new_ast.h"
+#include "nasal_ast.h"
 #include "ast_visitor.h"
 
 void expr::accept(ast_visitor* visitor) {
diff --git a/src/nasal_new_ast.h b/src/nasal_ast.h
similarity index 96%
rename from src/nasal_new_ast.h
rename to src/nasal_ast.h
index c2a030d..370891d 100644
--- a/src/nasal_new_ast.h
+++ b/src/nasal_ast.h
@@ -1,7 +1,7 @@
 #pragma once
 
-#include "nasal_new_header.h"
-#include "nasal_new_err.h"
+#include "nasal.h"
+#include "nasal_err.h"
 
 #include <vector>
 #include <unordered_map>
diff --git a/src/nasal_new_builtin.cpp b/src/nasal_builtin.cpp
similarity index 96%
rename from src/nasal_new_builtin.cpp
rename to src/nasal_builtin.cpp
index da79b39..83ed4fa 100644
--- a/src/nasal_new_builtin.cpp
+++ b/src/nasal_builtin.cpp
@@ -1,4 +1,4 @@
-#include "nasal_new_builtin.h"
+#include "nasal_builtin.h"
 
 var builtin_print(var* local, gc& ngc) {
     for(auto& i:local[1].vec().elems) {
diff --git a/src/nasal_new_builtin.h b/src/nasal_builtin.h
similarity index 98%
rename from src/nasal_new_builtin.h
rename to src/nasal_builtin.h
index f372127..2169a3a 100644
--- a/src/nasal_new_builtin.h
+++ b/src/nasal_builtin.h
@@ -1,7 +1,7 @@
 #pragma once
 
-#include "nasal_new_header.h"
-#include "nasal_new_gc.h"
+#include "nasal.h"
+#include "nasal_gc.h"
 
 #ifndef _MSC_VER
 #include <unistd.h>
diff --git a/src/nasal_new_codegen.cpp b/src/nasal_codegen.cpp
similarity index 97%
rename from src/nasal_new_codegen.cpp
rename to src/nasal_codegen.cpp
index 745ed2b..a6282f6 100644
--- a/src/nasal_new_codegen.cpp
+++ b/src/nasal_codegen.cpp
@@ -1,4 +1,4 @@
-#include "nasal_new_codegen.h"
+#include "nasal_codegen.h"
 
 void codegen::check_id_exist(identifier* node) {
     const auto& name = node->get_name();
diff --git a/src/nasal_new_codegen.h b/src/nasal_codegen.h
similarity index 94%
rename from src/nasal_new_codegen.h
rename to src/nasal_codegen.h
index 8ef1e7f..f1f8afa 100644
--- a/src/nasal_new_codegen.h
+++ b/src/nasal_codegen.h
@@ -1,13 +1,13 @@
 #pragma once
 
-#include "nasal_new_err.h"
-#include "nasal_new_builtin.h"
-#include "nasal_new_opcode.h"
-#include "nasal_new_ast.h"
+#include "nasal_err.h"
+#include "nasal_builtin.h"
+#include "nasal_opcode.h"
+#include "nasal_ast.h"
 #include "ast_visitor.h"
 #include "symbol_finder.h"
-#include "nasal_new_parse.h"
-#include "nasal_new_import.h"
+#include "nasal_parse.h"
+#include "nasal_import.h"
 
 #include <iomanip>
 #include <list>
diff --git a/src/nasal_new_dbg.cpp b/src/nasal_dbg.cpp
similarity index 96%
rename from src/nasal_new_dbg.cpp
rename to src/nasal_dbg.cpp
index 182df43..eab3571 100644
--- a/src/nasal_new_dbg.cpp
+++ b/src/nasal_dbg.cpp
@@ -1,4 +1,4 @@
-#include "nasal_new_dbg.h"
+#include "nasal_dbg.h"
 
 std::vector<std::string> dbg::parse(const std::string& cmd) {
     std::vector<std::string> res;
diff --git a/src/nasal_new_dbg.h b/src/nasal_dbg.h
similarity index 91%
rename from src/nasal_new_dbg.h
rename to src/nasal_dbg.h
index 9d0fcdf..96fdf5e 100644
--- a/src/nasal_new_dbg.h
+++ b/src/nasal_dbg.h
@@ -1,9 +1,9 @@
 #pragma once
 
-#include "nasal_new_import.h"
-#include "nasal_new_err.h"
-#include "nasal_new_opcode.h"
-#include "nasal_new_vm.h"
+#include "nasal_import.h"
+#include "nasal_err.h"
+#include "nasal_opcode.h"
+#include "nasal_vm.h"
 
 #include <cstring>
 #include <algorithm>
diff --git a/src/nasal_new_err.cpp b/src/nasal_err.cpp
similarity index 95%
rename from src/nasal_new_err.cpp
rename to src/nasal_err.cpp
index 8e7f7ec..621c59e 100644
--- a/src/nasal_new_err.cpp
+++ b/src/nasal_err.cpp
@@ -1,4 +1,4 @@
-#include "nasal_new_err.h"
+#include "nasal_err.h"
 #ifdef _WIN32
 #include <windows.h> // use SetConsoleTextAttribute
 struct for_reset {
diff --git a/src/nasal_new_err.h b/src/nasal_err.h
similarity index 97%
rename from src/nasal_new_err.h
rename to src/nasal_err.h
index 5f73b05..7709766 100644
--- a/src/nasal_new_err.h
+++ b/src/nasal_err.h
@@ -6,7 +6,7 @@
 #include <cstring>
 #include <vector>
 
-#include "nasal_new_header.h"
+#include "nasal.h"
 
 struct span {
     u32 begin_line;
diff --git a/src/nasal_new_gc.cpp b/src/nasal_gc.cpp
similarity index 95%
rename from src/nasal_new_gc.cpp
rename to src/nasal_gc.cpp
index 8747397..1a66794 100644
--- a/src/nasal_new_gc.cpp
+++ b/src/nasal_gc.cpp
@@ -1,4 +1,4 @@
-#include "nasal_new_gc.h"
+#include "nasal_gc.h"
 
 void filehandle_destructor(void* ptr) {
     if ((FILE*)ptr==stdin) {
diff --git a/src/nasal_new_gc.h b/src/nasal_gc.h
similarity index 99%
rename from src/nasal_new_gc.h
rename to src/nasal_gc.h
index fe84ae9..c4817f3 100644
--- a/src/nasal_new_gc.h
+++ b/src/nasal_gc.h
@@ -30,7 +30,7 @@
 #include <cstring>
 #include <sstream>
 
-#include "nasal_new_header.h"
+#include "nasal.h"
 
 enum vm_type:u8 {
     /* none-gc object */
diff --git a/src/nasal_new_import.cpp b/src/nasal_import.cpp
similarity index 96%
rename from src/nasal_new_import.cpp
rename to src/nasal_import.cpp
index 00abaff..2658305 100644
--- a/src/nasal_new_import.cpp
+++ b/src/nasal_import.cpp
@@ -1,4 +1,4 @@
-#include "nasal_new_import.h"
+#include "nasal_import.h"
 
 linker::linker(error& e): show_path(false), lib_loaded(false), err(e) {
     char sep=is_windows()? ';':':';
diff --git a/src/nasal_new_import.h b/src/nasal_import.h
similarity index 84%
rename from src/nasal_new_import.h
rename to src/nasal_import.h
index 73378e5..5964613 100644
--- a/src/nasal_new_import.h
+++ b/src/nasal_import.h
@@ -12,10 +12,10 @@
 #define F_OK 0
 #endif
 
-#include "nasal_new_header.h"
-#include "nasal_new_ast.h"
-#include "nasal_new_lexer.h"
-#include "nasal_new_parse.h"
+#include "nasal.h"
+#include "nasal_ast.h"
+#include "nasal_lexer.h"
+#include "nasal_parse.h"
 
 class linker{
 private:
diff --git a/src/nasal_new_lexer.cpp b/src/nasal_lexer.cpp
similarity index 96%
rename from src/nasal_new_lexer.cpp
rename to src/nasal_lexer.cpp
index b5fbcd2..a85c252 100644
--- a/src/nasal_new_lexer.cpp
+++ b/src/nasal_lexer.cpp
@@ -4,7 +4,7 @@
 #pragma warning (disable:4102)
 #endif
 
-#include "nasal_new_lexer.h"
+#include "nasal_lexer.h"
 
 bool lexer::skip(char c) {
     return c==' '||c=='\n'||c=='\t'||c=='\r'||c==0;
diff --git a/src/nasal_new_lexer.h b/src/nasal_lexer.h
similarity index 98%
rename from src/nasal_new_lexer.h
rename to src/nasal_lexer.h
index c4669c2..e96009e 100644
--- a/src/nasal_new_lexer.h
+++ b/src/nasal_lexer.h
@@ -12,8 +12,8 @@
 #include <unordered_map>
 #include <sys/stat.h>
 
-#include "nasal_new_header.h"
-#include "nasal_new_err.h"
+#include "nasal.h"
+#include "nasal_err.h"
 
 #ifdef _MSC_VER
 #define S_ISREG(m) (((m)&0xF000)==0x8000)
diff --git a/src/nasal_new_misc.cpp b/src/nasal_misc.cpp
similarity index 94%
rename from src/nasal_new_misc.cpp
rename to src/nasal_misc.cpp
index 97ae1c7..954ae53 100644
--- a/src/nasal_new_misc.cpp
+++ b/src/nasal_misc.cpp
@@ -1,4 +1,4 @@
-#include "nasal_new_header.h"
+#include "nasal.h"
 
 bool is_windows() {
 #if defined(_WIN32) || defined(_WIN64)
diff --git a/src/nasal_new_opcode.cpp b/src/nasal_opcode.cpp
similarity index 96%
rename from src/nasal_new_opcode.cpp
rename to src/nasal_opcode.cpp
index d5f66b1..3b027c1 100644
--- a/src/nasal_new_opcode.cpp
+++ b/src/nasal_opcode.cpp
@@ -1,4 +1,4 @@
-#include "nasal_new_opcode.h"
+#include "nasal_opcode.h"
 
 const char* opname[]={
     "exit  ","intg  ","intl  ","loadg ",
diff --git a/src/nasal_new_opcode.h b/src/nasal_opcode.h
similarity index 98%
rename from src/nasal_new_opcode.h
rename to src/nasal_opcode.h
index 7b0e966..0496e6b 100644
--- a/src/nasal_new_opcode.h
+++ b/src/nasal_opcode.h
@@ -1,7 +1,7 @@
 #pragma once
 
-#include "nasal_new_header.h"
-#include "nasal_new_builtin.h"
+#include "nasal.h"
+#include "nasal_builtin.h"
 
 #include <iostream>
 
diff --git a/src/nasal_new_parse.cpp b/src/nasal_parse.cpp
similarity index 96%
rename from src/nasal_new_parse.cpp
rename to src/nasal_parse.cpp
index 11b37ae..dc195e1 100644
--- a/src/nasal_new_parse.cpp
+++ b/src/nasal_parse.cpp
@@ -1,5 +1,5 @@
-#include "nasal_new_ast.h"
-#include "nasal_new_parse.h"
+#include "nasal_ast.h"
+#include "nasal_parse.h"
 
 const error& parse::compile(const lexer& lexer) {
     toks=lexer.result().data();
diff --git a/src/nasal_new_parse.h b/src/nasal_parse.h
similarity index 94%
rename from src/nasal_new_parse.h
rename to src/nasal_parse.h
index 100bcc7..0648ac0 100644
--- a/src/nasal_new_parse.h
+++ b/src/nasal_parse.h
@@ -2,10 +2,10 @@
 
 #include <unordered_map>
 
-#include "nasal_new_header.h"
-#include "nasal_new_ast.h"
-#include "nasal_new_lexer.h"
-#include "nasal_new_err.h"
+#include "nasal.h"
+#include "nasal_ast.h"
+#include "nasal_lexer.h"
+#include "nasal_err.h"
 
 class parse {
 
diff --git a/src/nasal_new_vm.cpp b/src/nasal_vm.cpp
similarity index 96%
rename from src/nasal_new_vm.cpp
rename to src/nasal_vm.cpp
index 0ded3a2..9f6f679 100644
--- a/src/nasal_new_vm.cpp
+++ b/src/nasal_vm.cpp
@@ -1,4 +1,4 @@
-#include "nasal_new_vm.h"
+#include "nasal_vm.h"
 
 void vm::init(
     const std::vector<std::string>& strs,
diff --git a/src/nasal_new_vm.h b/src/nasal_vm.h
similarity index 99%
rename from src/nasal_new_vm.h
rename to src/nasal_vm.h
index f3e3ffb..caa9bfa 100644
--- a/src/nasal_new_vm.h
+++ b/src/nasal_vm.h
@@ -3,9 +3,9 @@
 #include <iomanip>
 #include <stack>
 
-#include "nasal_new_import.h"
-#include "nasal_new_gc.h"
-#include "nasal_new_codegen.h"
+#include "nasal_import.h"
+#include "nasal_gc.h"
+#include "nasal_codegen.h"
 
 #ifdef _MSC_VER
 #pragma warning (disable:4244)
diff --git a/src/optimizer.h b/src/optimizer.h
index 0ecc53a..dc6ba7a 100644
--- a/src/optimizer.h
+++ b/src/optimizer.h
@@ -2,7 +2,7 @@
 
 #include <cmath>
 
-#include "nasal_new_ast.h"
+#include "nasal_ast.h"
 #include "ast_visitor.h"
 
 class optimizer:public ast_visitor {
diff --git a/src/symbol_finder.h b/src/symbol_finder.h
index 7444644..33410d3 100644
--- a/src/symbol_finder.h
+++ b/src/symbol_finder.h
@@ -1,6 +1,6 @@
 #pragma once
 
-#include "nasal_new_ast.h"
+#include "nasal_ast.h"
 #include "ast_visitor.h"
 
 #include <cstring>