🚀 update

ast/nasal_new_vm.h

@@ -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
-    );
-};

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
+	$(CXX) $(NASAL_NEW_AST) -O3 -o nnew -ldl
-	@ echo "build done"
 
-nasal_new_main.o: ast/nasal_new_main.cpp
+nnew.exe: $(NASAL_NEW_AST)
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_main.cpp -fno-exceptions -fPIC -o nasal_new_main.o -I .
+	$(CXX) $(NASAL_NEW_AST) -O3 -o nnew.exe
 
-nasal_new_misc.o: ast/nasal_new_header.h ast/nasal_new_misc.cpp
+nasal_new_main.o: src/nasal_new_main.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_misc.cpp -fno-exceptions -fPIC -o nasal_new_misc.o -I .
+	$(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
+nasal_new_misc.o: src/nasal_new_header.h src/nasal_new_misc.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_err.cpp -fno-exceptions -fPIC -o nasal_new_err.o -I .
+	$(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
+nasal_new_err.o: src/nasal_new_err.h src/nasal_new_err.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_gc.cpp -fno-exceptions -fPIC -o nasal_new_gc.o -I . 
+	$(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
+nasal_new_gc.o: src/nasal_new_gc.h src/nasal_new_gc.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 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
+nasal_new_import.o: src/nasal_new_import.h src/nasal_new_import.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 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
+nasal_new_lexer.o: src/nasal_new_lexer.h src/nasal_new_lexer.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_ast.cpp -fno-exceptions -fPIC -o nasal_new_ast.o -I .
+	$(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
+nasal_new_ast.o: src/nasal_new_ast.h src/nasal_new_ast.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_builtin.cpp -fno-exceptions -fPIC -o nasal_new_builtin.o -I .
+	$(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
+nasal_new_builtin.o: src/nasal_new_builtin.h src/nasal_new_builtin.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 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
+nasal_new_codegen.o: src/nasal_new_codegen.h src/nasal_new_codegen.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_opcode.cpp -fno-exceptions -fPIC -o nasal_new_opcode.o -I .
+	$(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
+nasal_new_opcode.o: src/nasal_new_opcode.h src/nasal_new_opcode.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_parse.cpp -fno-exceptions -fPIC -o nasal_new_parse.o -I .
+	$(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
+nasal_new_parse.o: src/nasal_new_parse.h src/nasal_new_parse.cpp src/nasal_new_ast.h
-	$(CXX) -std=$(STD) -c -O3 ast/optimizer.cpp -fno-exceptions -fPIC -o optimizer.o -I .
+	$(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
+optimizer.o: src/optimizer.h src/optimizer.cpp src/nasal_new_ast.h
-	$(CXX) -std=$(STD) -c -O3 ast/symbol_finder.cpp -fno-exceptions -fPIC -o symbol_finder.o -I .
+	$(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
+symbol_finder.o: src/symbol_finder.h src/symbol_finder.cpp src/nasal_new_ast.h
-	$(CXX) -std=$(STD) -c -O3 ast/ast_visitor.cpp -fno-exceptions -fPIC -o ast_visitor.o -I .
+	$(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
+ast_visitor.o: src/nasal_new_ast.h src/ast_visitor.h src/ast_visitor.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/ast_dumper.cpp -fno-exceptions -fPIC -o ast_dumper.o -I .
+	$(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
+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 ast/nasal_new_vm.cpp -fno-exceptions -fPIC -o nasal_new_vm.o -I .
+	$(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
+nasal_new_vm.o: src/nasal_new_vm.h src/nasal_new_vm.cpp
-	$(CXX) -std=$(STD) -c -O3 ast/nasal_new_dbg.cpp -fno-exceptions -fPIC -o nasal_new_dbg.o -I .
+	$(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:

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),

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

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&);

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   "};
+    const char* name[] = {
-    std::clog<<"\ngc info (gc count|alloc count|memory size)\n";
+        "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 = 0;
-        usize len=std::max({
+        len = std::to_string(gcnt[i]).length();
-            std::to_string(gcnt[i]).length(),
+        indent = indent<len? len:indent;
-            std::to_string(acnt[i]).length(),
+        len = std::to_string(acnt[i]).length();
-            std::to_string(size[i]).length()
+        indent = indent<len? len:indent;
-        });
+        len = std::to_string(size[i]).length();
-#else // VS is a piece of shit
+        indent = indent<len? len:indent;
-        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) {
+    std::clog << "\ngc info (gc count|alloc count|memory size)\n";
-        if (gcnt[i] || acnt[i] || size[i]) {
+    for(u8 i = 0; i<gc_type_size; ++i) {
-            total+=gcnt[i];
+        if (!gcnt[i] && !acnt[i] && !size[i]) {
-            std::clog<<" "<<name[i];
+            continue;
-            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";
         }
+        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
+    auto den = std::chrono::high_resolution_clock::duration::period::den;
-    std::clog<<" time  | "<<(sec<0.1? sec*1000:sec)<<(sec<0.1? " ms\n":" s\n");
+    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;
+    using clk = std::chrono::high_resolution_clock;
-    const u8 index=type-vm_str;
+    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);

src/nasal_new_gc.h

@@ -327,8 +327,8 @@ struct gc {
     context mctx;
 
     /* runtime context */
-    context* rctx;
+    context* rctx = nullptr;
-    nas_co* cort=nullptr; // running coroutine
+    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) {}
 

src/nasal_new_main.cpp

@@ -15,12 +15,13 @@
 #include <unordered_map>
 #include <thread>
 
-const u32 VM_AST   =0x01;
+const u32 VM_RAW_AST = 1;
-const u32 VM_CODE  =0x02;
+const u32 VM_AST     = 1<<1;
-const u32 VM_TIME  =0x04;
+const u32 VM_CODE    = 1<<2;
-const u32 VM_EXEC  =0x08;
+const u32 VM_TIME    = 1<<3;
-const u32 VM_DETAIL=0x10;
+const u32 VM_EXEC    = 1<<4;
-const u32 VM_DEBUG =0x20;
+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"
+    <<"   -a,   --ast     | view ast (after link/optimize process).\n"
-    <<"   -c,   --code   | view bytecode.\n"
+    <<"         --raw-ast | view ast without after-processing.\n"
-    <<"   -e,   --exec   | execute.\n"
+    <<"   -c,   --code    | view bytecode.\n"
-    <<"   -t,   --time   | show execute time.\n"
+    <<"   -e,   --exec    | execute.\n"
-    <<"   -d,   --detail | get detail info.\n"
+    <<"   -t,   --time    | show execute time.\n"
-    <<"   -dbg, --debug  | debug mode.\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},

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
+}

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) {