From e41f728589798516abc12d93205bd5cd034ed8ad Mon Sep 17 00:00:00 2001
From: ValKmjolnir <lhk101lhk101@qq.com>
Date: Fri, 15 Oct 2021 22:21:57 +0800
Subject: [PATCH] update

---
 main.cpp       |  282 ++++---
 nasal_import.h |  256 +++---
 nasal_lexer.h  |  725 ++++++++---------
 nasal_parse.h  | 2028 ++++++++++++++++++++++++------------------------
 4 files changed, 1645 insertions(+), 1646 deletions(-)

diff --git a/main.cpp b/main.cpp
index a58a054..d39dcfb 100644
--- a/main.cpp
+++ b/main.cpp
@@ -1,144 +1,140 @@
-#include "nasal.h"
-#define VM_LEXINFO   1
-#define VM_ASTINFO   2
-#define VM_CODEINFO  4
-#define VM_EXECTIME  8
-#define VM_OPCALLNUM 16
-#define VM_EXEC      32
-void help_cmd()
-{
-    std::cout
-#ifdef _WIN32
-    <<"use command \'chcp 65001\' if want to use unicode.\n"
-#endif
-    <<"nasal <option>\n"
-    <<"option:\n"
-    <<"    -h, --help    | get help.\n"
-    <<"    -v, --version | get version of nasal interpreter.\n\n"
-    <<"nasal <file>\n"
-    <<"file:\n"
-    <<"    input file name to execute script file.\n\n"
-    <<"nasal [options] <file>\n"
-    <<"option:\n"
-    <<"    -l, --lex     | view token info.\n"
-    <<"    -a, --ast     | view abstract syntax tree.\n"
-    <<"    -c, --code    | view bytecode.\n"
-    <<"    -t, --time    | execute and get the running time.\n"
-    <<"    -o, --opcnt   | count operands while running.\n"
-    <<"file:\n"
-    <<"    input file name to execute script file.\n";
-    return;
-}
-
-void logo()
-{
-    std::cout
-    <<"       __                _      \n"
-    <<"    /\\ \\ \\__ _ ___  __ _| |  \n"
-    <<"   /  \\/ / _` / __|/ _` | |    \n"
-    <<"  / /\\  / (_| \\__ \\ (_| | |  \n"
-    <<"  \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
-    <<"nasal interpreter ver 8.0\n"
-    <<"thanks to : https://github.com/andyross/nasal\n"
-    <<"code repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
-    <<"code repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
-    <<"lang info : http://wiki.flightgear.org/Nasal_scripting_language\n"
-    <<"input \"nasal -h\" to get help .\n";
-    return;
-}
-
-void die(const char* stage,const std::string& filename)
-{
-    std::cout<<"["<<stage<<"] in <"<<filename<<">: error(s) occurred,stop.\n";
-    std::exit(1);
-}
-
-void cmderr()
-{
-    std::cout
-    <<"invalid argument(s).\n"
-    <<"use nasal -h to get help.\n";
-    std::exit(1);
-}
-
-void execute(const std::string& file,const uint16_t cmd)
-{
-    nasal_lexer   lexer;
-    nasal_parse   parse;
-    nasal_import  import;
-    nasal_codegen codegen;
-    nasal_vm      vm;
-    lexer.open(file);
-    lexer.scan();
-    if(lexer.err())
-        die("lexer",file);
-    if(cmd&VM_LEXINFO)
-        lexer.print();
-    parse.compile(lexer.get_tokens());
-    if(parse.err())
-        die("parse",file);
-    if(cmd&VM_ASTINFO)
-        parse.get_root().print(0);
-    // first used file is itself
-    import.link(parse.get_root(),file);
-    if(import.err())
-        die("import",file);
-    codegen.compile(import.get_root(),import.get_file());
-    if(codegen.err())
-        die("code",file);
-    if(cmd&VM_CODEINFO)
-        codegen.print();
-    vm.init(
-        codegen.get_strs(),
-        codegen.get_nums(),
-        import.get_file()
-    );
-    if(cmd&VM_EXECTIME)
-    {
-        clock_t t=clock();
-        vm.run(codegen.get_code(),cmd&VM_OPCALLNUM);
-        std::cout<<"process exited after "<<((double)(clock()-t))/CLOCKS_PER_SEC<<"s.\n";
-    }
-    else if(cmd&VM_EXEC)
-        vm.run(codegen.get_code(),cmd&VM_OPCALLNUM);
-    vm.clear();
-    return;
-}
-
-int main(int argc,const char* argv[])
-{
-    std::string filename;
-    uint16_t cmd=0;
-    if(argc==2 && (!strcmp(argv[1],"-v") || !strcmp(argv[1],"--version")))
-        logo();
-    else if(argc==2 && (!strcmp(argv[1],"-h") || !strcmp(argv[1],"--help")))
-        help_cmd();
-    else if(argc==2 && argv[1][0]!='-')
-        cmd|=VM_EXEC;
-    else if(argc>=3)
-    {
-        for(int i=1;i<argc-1;++i)
-        {
-            std::string s(argv[i]);
-            if(s=="--lex" || s=="-l")
-                cmd|=VM_LEXINFO;
-            else if(s=="--ast" || s=="-a")
-                cmd|=VM_ASTINFO;
-            else if(s=="--code" || s=="-c")
-                cmd|=VM_CODEINFO;
-            else if(s=="--opcnt" || s=="-o")
-                cmd|=VM_OPCALLNUM|VM_EXEC;
-            else if(s=="--time" || s=="-t")
-                cmd|=VM_EXECTIME;
-            else
-                cmderr();
-        }
-    }
-    else
-        cmderr();
-    if(argv[argc-1][0]=='-')
-        cmderr();
-    if(cmd)
-        execute(argv[argc-1],cmd);
-    return 0;
+#include "nasal.h"
+#define VM_LEXINFO   1
+#define VM_ASTINFO   2
+#define VM_CODEINFO  4
+#define VM_EXECTIME  8
+#define VM_OPCALLNUM 16
+#define VM_EXEC      32
+void help_cmd()
+{
+    std::cout
+#ifdef _WIN32
+    <<"use command \'chcp 65001\' if want to use unicode.\n"
+#endif
+    <<"nasal <option>\n"
+    <<"option:\n"
+    <<"    -h, --help    | get help.\n"
+    <<"    -v, --version | get version of nasal interpreter.\n\n"
+    <<"nasal <file>\n"
+    <<"file:\n"
+    <<"    input file name to execute script file.\n\n"
+    <<"nasal [options] <file>\n"
+    <<"option:\n"
+    <<"    -l, --lex     | view token info.\n"
+    <<"    -a, --ast     | view abstract syntax tree.\n"
+    <<"    -c, --code    | view bytecode.\n"
+    <<"    -t, --time    | execute and get the running time.\n"
+    <<"    -o, --opcnt   | count operands while running.\n"
+    <<"file:\n"
+    <<"    input file name to execute script file.\n";
+    return;
+}
+
+void logo()
+{
+    std::cout
+    <<"       __                _      \n"
+    <<"    /\\ \\ \\__ _ ___  __ _| |  \n"
+    <<"   /  \\/ / _` / __|/ _` | |    \n"
+    <<"  / /\\  / (_| \\__ \\ (_| | |  \n"
+    <<"  \\_\\ \\/ \\__,_|___/\\__,_|_|\n"
+    <<"nasal interpreter ver 8.0\n"
+    <<"thanks to : https://github.com/andyross/nasal\n"
+    <<"code repo : https://github.com/ValKmjolnir/Nasal-Interpreter\n"
+    <<"code repo : https://gitee.com/valkmjolnir/Nasal-Interpreter\n"
+    <<"lang info : http://wiki.flightgear.org/Nasal_scripting_language\n"
+    <<"input \"nasal -h\" to get help .\n";
+    return;
+}
+
+void die(const char* stage,const std::string& filename)
+{
+    std::cout<<"["<<stage<<"] in <"<<filename<<">: error(s) occurred,stop.\n";
+    std::exit(1);
+}
+
+void cmderr()
+{
+    std::cout
+    <<"invalid argument(s).\n"
+    <<"use nasal -h to get help.\n";
+    std::exit(1);
+}
+
+void execute(const std::string& file,const uint16_t cmd)
+{
+    nasal_lexer   lexer;
+    nasal_parse   parse;
+    nasal_import  import;
+    nasal_codegen codegen;
+    nasal_vm      vm;
+    lexer.open(file);
+    lexer.scan();
+    if(lexer.err())
+        die("lexer",file);
+    if(cmd&VM_LEXINFO)
+        lexer.print();
+    parse.compile(lexer.get_tokens());
+    if(parse.err())
+        die("parse",file);
+    if(cmd&VM_ASTINFO)
+        parse.ast().print(0);
+    // first used file is itself
+    import.link(parse.ast(),file);
+    if(import.err())
+        die("import",file);
+    codegen.compile(import.ast(),import.get_file());
+    if(codegen.err())
+        die("code",file);
+    if(cmd&VM_CODEINFO)
+        codegen.print();
+    vm.init(
+        codegen.get_strs(),
+        codegen.get_nums(),
+        import.get_file()
+    );
+    if(cmd&VM_EXECTIME)
+    {
+        clock_t t=clock();
+        vm.run(codegen.get_code(),cmd&VM_OPCALLNUM);
+        std::cout<<"process exited after "<<((double)(clock()-t))/CLOCKS_PER_SEC<<"s.\n";
+    }
+    else if(cmd&VM_EXEC)
+        vm.run(codegen.get_code(),cmd&VM_OPCALLNUM);
+    vm.clear();
+    return;
+}
+
+int main(int argc,const char* argv[])
+{
+    if(argc==2 && (!strcmp(argv[1],"-v") || !strcmp(argv[1],"--version")))
+        logo();
+    else if(argc==2 && (!strcmp(argv[1],"-h") || !strcmp(argv[1],"--help")))
+        help_cmd();
+    else if(argc==2 && argv[1][0]!='-')
+        execute(argv[1],VM_EXEC);
+    else if(argc>=3)
+    {
+        uint16_t cmd=0;
+        for(int i=1;i<argc-1;++i)
+        {
+            std::string s(argv[i]);
+            if(s=="--lex" || s=="-l")
+                cmd|=VM_LEXINFO;
+            else if(s=="--ast" || s=="-a")
+                cmd|=VM_ASTINFO;
+            else if(s=="--code" || s=="-c")
+                cmd|=VM_CODEINFO;
+            else if(s=="--opcnt" || s=="-o")
+                cmd|=VM_OPCALLNUM|VM_EXEC;
+            else if(s=="--time" || s=="-t")
+                cmd|=VM_EXECTIME;
+            else
+                cmderr();
+        }
+        execute(argv[argc-1],cmd);
+    }
+    else
+        cmderr();
+    return 0;
 }
\ No newline at end of file
diff --git a/nasal_import.h b/nasal_import.h
index f3be9dc..008992b 100644
--- a/nasal_import.h
+++ b/nasal_import.h
@@ -1,129 +1,129 @@
-#ifndef __NASAL_IMPORT_H__
-#define __NASAL_IMPORT_H__
-
-class nasal_import
-{
-private:
-    uint32_t                 error;
-    nasal_lexer              import_lex;
-    nasal_parse              import_par;
-    nasal_ast                import_ast;
-    std::vector<std::string> filename_table;
-    void      die(const std::string&,const char*);
-    bool      check_import(const nasal_ast&);
-    bool      check_exist(const std::string&);
-    void      linker(nasal_ast&,nasal_ast&&);
-    nasal_ast file_import(nasal_ast&);
-    nasal_ast load(nasal_ast&,uint16_t);
-public:
-    uint32_t  err(){return error;}
-    void      link(nasal_ast&,const std::string&);
-    const nasal_ast& get_root(){return import_ast;}
-    const std::vector<std::string>& get_file(){return filename_table;}
-};
-
-void nasal_import::die(const std::string& filename,const char* error_stage)
-{
-    ++error;
-    std::cout<<"[import] in <\""<<filename<<"\">: error(s) occurred in "<<error_stage<<".\n";
-}
-
-bool nasal_import::check_import(const nasal_ast& node)
-{
-/*
-only this kind of node can be recognized as 'import':
-    call
-        id:import
-        call_func
-            string:'filename'
-*/
-    if(node.get_type()!=ast_call)
-        return false;
-    const std::vector<nasal_ast>& ref_vec=node.get_children();
-    if(ref_vec.size()!=2)
-        return false;
-    if(ref_vec[0].get_str()!="import")
-        return false;
-    if(ref_vec[1].get_type()!=ast_callf)
-        return false;
-    if(ref_vec[1].get_children().size()!=1 || ref_vec[1].get_children()[0].get_type()!=ast_str)
-        return false;
-    return true;
-}
-
-bool nasal_import::check_exist(const std::string& file)
-{
-    // avoid importing the same file
-    for(auto& fname:filename_table)
-        if(file==fname)
-            return true;
-    filename_table.push_back(file);
-    return false;
-}
-
-void nasal_import::linker(nasal_ast& root,nasal_ast&& add_root)
-{
-    // add children of add_root to the back of root
-    for(auto& i:add_root.get_children())
-        root.add_child(std::move(i));
-}
-
-nasal_ast nasal_import::file_import(nasal_ast& node)
-{
-    // initializing
-    nasal_ast tmp(0,ast_root);
-
-    // get filename and set node to ast_null
-    std::string filename=node.get_children()[1].get_children()[0].get_str();
-    node.clear();
-
-    // avoid infinite loading loop
-    if(check_exist(filename))
-        return tmp;
-    
-    // start importing...
-    import_lex.open(filename);
-    import_lex.scan();
-    if(import_lex.err())
-    {
-        die(filename,"lexer");
-        return tmp;
-    }
-    import_par.compile(import_lex.get_tokens());
-    if(import_par.err())
-    {
-        die(filename,"parser");
-        return tmp;
-    }
-    tmp=std::move(import_par.get_root());
-    // check if tmp has 'import'
-    return load(tmp,filename_table.size()-1);
-}
-
-nasal_ast nasal_import::load(nasal_ast& root,uint16_t fileindex)
-{
-    nasal_ast new_root(0,ast_root);
-    for(auto& i:root.get_children())
-        if(check_import(i))
-            linker(new_root,file_import(i));
-    // add root to the back of new_root
-    nasal_ast file_head(0,ast_file);
-    file_head.set_num(fileindex);
-    new_root.add_child(std::move(file_head));
-    linker(new_root,std::move(root));
-    return new_root;
-}
-
-void nasal_import::link(nasal_ast& root,const std::string& self)
-{
-    // initializing
-    error=0;
-    filename_table.clear();
-    filename_table.push_back(self);
-    import_ast.clear();
-    // scan root and import files,then generate a new ast and return to import_ast
-    // the main file's index is 0
-    import_ast=load(root,0);
-}
-
+#ifndef __NASAL_IMPORT_H__
+#define __NASAL_IMPORT_H__
+
+class nasal_import
+{
+private:
+    uint32_t                 error;
+    nasal_lexer              import_lex;
+    nasal_parse              import_par;
+    nasal_ast                import_ast;
+    std::vector<std::string> filename_table;
+    void      die(const std::string&,const char*);
+    bool      check_import(const nasal_ast&);
+    bool      check_exist(const std::string&);
+    void      linker(nasal_ast&,nasal_ast&&);
+    nasal_ast file_import(nasal_ast&);
+    nasal_ast load(nasal_ast&,uint16_t);
+public:
+    uint32_t  err(){return error;}
+    void      link(nasal_ast&,const std::string&);
+    const nasal_ast& ast(){return import_ast;}
+    const std::vector<std::string>& get_file(){return filename_table;}
+};
+
+void nasal_import::die(const std::string& file,const char* stage)
+{
+    ++error;
+    std::cout<<"[import] in <\""<<file<<"\">: error(s) occurred in "<<stage<<".\n";
+}
+
+bool nasal_import::check_import(const nasal_ast& node)
+{
+/*
+only this kind of node can be recognized as 'import':
+    call
+        id:import
+        call_func
+            string:'filename'
+*/
+    if(node.get_type()!=ast_call)
+        return false;
+    const std::vector<nasal_ast>& ref_vec=node.get_children();
+    if(ref_vec.size()!=2)
+        return false;
+    if(ref_vec[0].get_str()!="import")
+        return false;
+    if(ref_vec[1].get_type()!=ast_callf)
+        return false;
+    if(ref_vec[1].get_children().size()!=1 || ref_vec[1].get_children()[0].get_type()!=ast_str)
+        return false;
+    return true;
+}
+
+bool nasal_import::check_exist(const std::string& file)
+{
+    // avoid importing the same file
+    for(auto& fname:filename_table)
+        if(file==fname)
+            return true;
+    filename_table.push_back(file);
+    return false;
+}
+
+void nasal_import::linker(nasal_ast& root,nasal_ast&& add_root)
+{
+    // add children of add_root to the back of root
+    for(auto& i:add_root.get_children())
+        root.add_child(std::move(i));
+}
+
+nasal_ast nasal_import::file_import(nasal_ast& node)
+{
+    // initializing
+    nasal_ast tmp(0,ast_root);
+
+    // get filename and set node to ast_null
+    std::string filename=node.get_children()[1].get_children()[0].get_str();
+    node.clear();
+
+    // avoid infinite loading loop
+    if(check_exist(filename))
+        return tmp;
+    
+    // start importing...
+    import_lex.open(filename);
+    import_lex.scan();
+    if(import_lex.err())
+    {
+        die(filename,"lexer");
+        return tmp;
+    }
+    import_par.compile(import_lex.get_tokens());
+    if(import_par.err())
+    {
+        die(filename,"parser");
+        return tmp;
+    }
+    tmp=std::move(import_par.ast());
+    // check if tmp has 'import'
+    return load(tmp,filename_table.size()-1);
+}
+
+nasal_ast nasal_import::load(nasal_ast& root,uint16_t fileindex)
+{
+    nasal_ast new_root(0,ast_root);
+    for(auto& i:root.get_children())
+        if(check_import(i))
+            linker(new_root,file_import(i));
+    // add root to the back of new_root
+    nasal_ast file_head(0,ast_file);
+    file_head.set_num(fileindex);
+    new_root.add_child(std::move(file_head));
+    linker(new_root,std::move(root));
+    return new_root;
+}
+
+void nasal_import::link(nasal_ast& root,const std::string& self)
+{
+    // initializing
+    error=0;
+    filename_table.clear();
+    filename_table.push_back(self);
+    import_ast.clear();
+    // scan root and import files,then generate a new ast and return to import_ast
+    // the main file's index is 0
+    import_ast=load(root,0);
+}
+
 #endif
\ No newline at end of file
diff --git a/nasal_lexer.h b/nasal_lexer.h
index 5d03087..714048d 100644
--- a/nasal_lexer.h
+++ b/nasal_lexer.h
@@ -1,362 +1,365 @@
-#ifndef __NASAL_LEXER_H__
-#define __NASAL_LEXER_H__
-
-#define IS_IDENTIFIER(c)      ((c=='_')||('a'<=c && c<='z')||('A'<=c&&c<='Z'))
-#define IS_HEX_NUMBER(c)      (('0'<=c&&c<='9')||('a'<=c&&c<='f')||('A'<=c && c<='F'))
-#define IS_OCT_NUMEBR(c)      ('0'<=c&&c<='7')
-#define IS_DIGIT(c)           ('0'<=c&&c<='9')
-#define IS_STRING(c)          (c=='\''||c=='\"'||c=='`')
-// single operators have only one character
-#define IS_SINGLE_OPERATOR(c) (c=='('||c==')'||c=='['||c==']'||c=='{'||c=='}'||c==','||c==';'||c=='|'||c==':'||\
-                               c=='?'||c=='`'||c=='&'||c=='@'||c=='%'||c=='$'||c=='^'||c=='\\')
-// calculation operators may have two chars, for example: += -= *= /= ~= != == >= <=
-#define IS_CALC_OPERATOR(c)   (c=='='||c=='+'||c=='-'||c=='*'||c=='!'||c=='/'||c=='<'||c=='>'||c=='~')
-#define IS_NOTE(c)            (c=='#')
-
-enum token_type
-{
-    tok_null=0,
-    tok_num,tok_str,tok_id,
-    tok_for,tok_forindex,tok_foreach,tok_while,
-    tok_var,tok_func,tok_break,tok_continue,
-    tok_ret,tok_if,tok_elsif,tok_else,tok_nil,
-    tok_lcurve,tok_rcurve,
-    tok_lbracket,tok_rbracket,
-    tok_lbrace,tok_rbrace,
-    tok_semi,tok_and,tok_or,tok_comma,tok_dot,tok_ellipsis,tok_quesmark,
-    tok_colon,tok_add,tok_sub,tok_mult,tok_div,tok_link,tok_not,
-    tok_eq,
-    tok_addeq,tok_subeq,tok_multeq,tok_diveq,tok_lnkeq,
-    tok_cmpeq,tok_neq,tok_less,tok_leq,tok_grt,tok_geq,
-    tok_eof
-};
-
-struct
-{
-    const char* str;
-    const int tok_type;
-}token_table[]=
-{
-    {"for"     ,tok_for      },
-    {"forindex",tok_forindex },
-    {"foreach" ,tok_foreach  },
-    {"while"   ,tok_while    },
-    {"var"     ,tok_var      },
-    {"func"    ,tok_func     },
-    {"break"   ,tok_break    },
-    {"continue",tok_continue },
-    {"return"  ,tok_ret      },
-    {"if"      ,tok_if       },
-    {"elsif"   ,tok_elsif    },
-    {"else"    ,tok_else     },
-    {"nil"     ,tok_nil      },
-    {"("       ,tok_lcurve   },
-    {")"       ,tok_rcurve   },
-    {"["       ,tok_lbracket },
-    {"]"       ,tok_rbracket },
-    {"{"       ,tok_lbrace   },
-    {"}"       ,tok_rbrace   },
-    {";"       ,tok_semi     },
-    {"and"     ,tok_and      },
-    {"or"      ,tok_or       },
-    {","       ,tok_comma    },
-    {"."       ,tok_dot      },
-    {"..."     ,tok_ellipsis },
-    {"?"       ,tok_quesmark },
-    {":"       ,tok_colon    },
-    {"+"       ,tok_add      },
-    {"-"       ,tok_sub      },
-    {"*"       ,tok_mult     },
-    {"/"       ,tok_div      },
-    {"~"       ,tok_link     },
-    {"!"       ,tok_not      },
-    {"="       ,tok_eq       },
-    {"+="      ,tok_addeq    },
-    {"-="      ,tok_subeq    },
-    {"*="      ,tok_multeq   },
-    {"/="      ,tok_diveq    },
-    {"~="      ,tok_lnkeq    },
-    {"=="      ,tok_cmpeq    },
-    {"!="      ,tok_neq      },
-    {"<"       ,tok_less     },
-    {"<="      ,tok_leq      },
-    {">"       ,tok_grt      },
-    {">="      ,tok_geq      },
-    {nullptr   ,-1           }
-};
-
-struct token
-{
-    uint32_t line;
-    uint32_t type;
-    std::string str;
-    token(uint32_t l=0,uint32_t t=tok_null,std::string s=""){line=l;type=t;str=s;}
-};
-
-class nasal_lexer
-{
-private:
-    uint32_t    error;
-    uint32_t    line;
-    uint32_t    ptr;
-    size_t      res_size;
-    std::string line_code;
-    std::string res;
-    std::vector<token> token_list;
-    uint32_t get_type(const std::string&);
-    void die(const char*);
-    std::string id_gen();
-    std::string num_gen();
-    std::string str_gen();
-public:
-    void open(const std::string&);
-    void scan();
-    void print();
-    uint32_t err(){return error;}
-    const std::vector<token>& get_tokens(){return token_list;}
-};
-
-void nasal_lexer::open(const std::string& filename)
-{
-    error=0;
-    res.clear();
-    std::ifstream fin(filename,std::ios::binary);
-    if(fin.fail())
-    {
-        ++error;
-        std::cout<<"[lexer] cannot open file <"<<filename<<">.\n";
-        return;
-    }
-    while(!fin.eof())
-    {
-        char c=fin.get();
-        if(fin.eof())
-            break;
-        res+=c;
-    }
-    return;
-}
-
-uint32_t nasal_lexer::get_type(const std::string& tk_str)
-{
-    for(int i=0;token_table[i].str;++i)
-        if(tk_str==token_table[i].str)
-            return token_table[i].tok_type;
-    return tok_null;
-}
-
-void nasal_lexer::die(const char* error_info)
-{
-    ++error;
-    std::cout<<"[lexer] line "<<line<<" column "<<line_code.length()<<": \n"<<line_code<<"\n";
-    for(auto i:line_code)
-        std::cout<<(i=='\t'?'\t':' ');
-    std::cout<<"^"<<error_info<<'\n';
-    return;
-}
-
-std::string nasal_lexer::id_gen()
-{
-    std::string token_str="";
-    while(ptr<res_size && (IS_IDENTIFIER(res[ptr])||IS_DIGIT(res[ptr])))
-        token_str+=res[ptr++];
-    line_code+=token_str;
-    return token_str;
-    // after running this process, ptr will point to the next token's beginning character
-}
-
-std::string nasal_lexer::num_gen()
-{
-    // generate hex number
-    if(ptr+1<res_size && res[ptr]=='0' && res[ptr+1]=='x')
-    {
-        std::string token_str="0x";
-        ptr+=2;
-        while(ptr<res_size && IS_HEX_NUMBER(res[ptr]))
-            token_str+=res[ptr++];
-        line_code+=token_str;
-        if(token_str.length()<3)// "0x"
-            die("incorrect number.");
-        return token_str;
-    }
-    // generate oct number
-    else if(ptr+1<res_size && res[ptr]=='0' && res[ptr+1]=='o')
-    {
-        std::string token_str="0o";
-        ptr+=2;
-        while(ptr<res_size && IS_OCT_NUMEBR(res[ptr]))
-            token_str+=res[ptr++];
-        line_code+=token_str;
-        if(token_str.length()<3)// "0o"
-            die("incorrect number.");
-        return token_str;
-    }
-    // generate dec number
-    // dec number -> [0~9][0~9]*(.[0~9]*)(e|E(+|-)0|[1~9][0~9]*)
-    std::string token_str="";
-    while(ptr<res_size && IS_DIGIT(res[ptr]))
-        token_str+=res[ptr++];
-    if(ptr<res_size && res[ptr]=='.')
-    {
-        token_str+=res[ptr++];
-        while(ptr<res_size && IS_DIGIT(res[ptr]))
-            token_str+=res[ptr++];
-        // "xxxx." is not a correct number
-        if(token_str.back()=='.')
-        {
-            line_code+=token_str;
-            die("incorrect number.");
-            return "0";
-        }
-    }
-    if(ptr<res_size && (res[ptr]=='e' || res[ptr]=='E'))
-    {
-        token_str+=res[ptr++];
-        if(ptr<res_size && (res[ptr]=='-' || res[ptr]=='+'))
-            token_str+=res[ptr++];
-        while(ptr<res_size && IS_DIGIT(res[ptr]))
-            token_str+=res[ptr++];
-        // "xxxe(-|+)" is not a correct number
-        if(token_str.back()=='e' || token_str.back()=='E' || token_str.back()=='-' || token_str.back()=='+')
-        {
-            line_code+=token_str;
-            die("incorrect number.");
-            return "0";
-        }
-    }
-    line_code+=token_str;
-    return token_str;
-}
-
-std::string nasal_lexer::str_gen()
-{
-    std::string token_str="";
-    char str_begin=res[ptr];
-    line_code+=str_begin;
-    while(++ptr<res_size && res[ptr]!=str_begin)
-    {
-        line_code+=res[ptr];
-        if(res[ptr]=='\n')
-        {
-            line_code="";
-            ++line;
-        }
-        if(res[ptr]=='\\' && ptr+1<res_size)
-        {
-            line_code+=res[++ptr];
-            switch(res[ptr])
-            {
-                case 'a': token_str.push_back('\a');break;
-                case 'b': token_str.push_back('\b');break;
-                case 'f': token_str.push_back('\f');break;
-                case 'n': token_str.push_back('\n');break;
-                case 'r': token_str.push_back('\r');break;
-                case 't': token_str.push_back('\t');break;
-                case 'v': token_str.push_back('\v');break;
-                case '?': token_str.push_back('\?');break;
-                case '0': token_str.push_back('\0');break;
-                case '\\':token_str.push_back('\\');break;
-                case '\'':token_str.push_back('\'');break;
-                case '\"':token_str.push_back('\"');break;
-                default:  token_str.push_back(res[ptr]);break;
-            }
-            continue;
-        }
-        token_str+=res[ptr];
-    }
-    // check if this string ends with a " or '
-    if(ptr++>=res_size)
-        die("get EOF when generating string.");
-    if(str_begin=='`' && token_str.length()!=1)
-        die("\'`\' is used for string that includes one character.");
-    return token_str;
-}
-
-void nasal_lexer::scan()
-{
-    token_list.clear();
-    line=1;
-    ptr=0;
-    line_code="";
-    res_size=res.size();
-
-    std::string token_str;
-    while(ptr<res_size)
-    {
-        while(ptr<res_size && (res[ptr]==' ' || res[ptr]=='\n' || res[ptr]=='\t' || res[ptr]=='\r' || res[ptr]<0))
-        {
-            // these characters will be ignored, and '\n' will cause ++line
-            line_code+=res[ptr];
-            if(res[ptr++]=='\n')
-            {
-                ++line;
-                line_code="";
-            }
-        }
-        if(ptr>=res_size) break;
-        if(IS_IDENTIFIER(res[ptr]))
-        {
-            token_str=id_gen();
-            token_list.push_back({line,get_type(token_str),token_str});
-            if(!token_list.back().type)
-                token_list.back().type=tok_id;
-        }
-        else if(IS_DIGIT(res[ptr]))
-            token_list.push_back({line,tok_num,num_gen()});
-        else if(IS_STRING(res[ptr]))
-            token_list.push_back({line,tok_str,str_gen()});
-        else if(IS_SINGLE_OPERATOR(res[ptr]))
-        {
-            token_str=res[ptr];
-            line_code+=res[ptr];
-            uint32_t type=get_type(token_str);
-            if(!type)
-                die("incorrect operator.");
-            token_list.push_back({line,type,token_str});
-            ++ptr;
-        }
-        else if(res[ptr]=='.')
-        {
-            if(ptr+2<res_size && res[ptr+1]=='.' && res[ptr+2]=='.')
-            {
-                token_str="...";
-                ptr+=3;
-            }
-            else
-            {
-                token_str=".";
-                ++ptr;
-            }
-            line_code+=token_str;
-            token_list.push_back({line,get_type(token_str),token_str});
-        }
-        else if(IS_CALC_OPERATOR(res[ptr]))
-        {
-            // get calculation operator
-            token_str=res[ptr++];
-            if(ptr<res_size && res[ptr]=='=')
-                token_str+=res[ptr++];
-            line_code+=token_str;
-            token_list.push_back({line,get_type(token_str),token_str});
-        }
-        else if(IS_NOTE(res[ptr]))// avoid note, after this process ptr will point to a '\n', so next loop line counter+1
-            while(++ptr<res_size && res[ptr]!='\n');
-        else
-        {
-            line_code+=res[ptr++];
-            die("unknown character.");
-        }
-    }
-    token_list.push_back({line,tok_eof,""});
-    res.clear();
-    return;
-}
-
-void nasal_lexer::print()
-{
-    for(auto& tok:token_list)
-        std::cout<<"("<<tok.line<<" | "<<tok.str<<")\n";
-    return;
-}
-
+#ifndef __NASAL_LEXER_H__
+#define __NASAL_LEXER_H__
+
+#define IS_IDENTIFIER(c)      ((c=='_')||('a'<=c && c<='z')||('A'<=c&&c<='Z'))
+#define IS_HEX_NUMBER(c)      (('0'<=c&&c<='9')||('a'<=c&&c<='f')||('A'<=c && c<='F'))
+#define IS_OCT_NUMEBR(c)      ('0'<=c&&c<='7')
+#define IS_DIGIT(c)           ('0'<=c&&c<='9')
+#define IS_STRING(c)          (c=='\''||c=='\"'||c=='`')
+// single operators have only one character
+#define IS_SINGLE_OPERATOR(c) (c=='('||c==')'||c=='['||c==']'||c=='{'||c=='}'||c==','||c==';'||c=='|'||c==':'||\
+                               c=='?'||c=='`'||c=='&'||c=='@'||c=='%'||c=='$'||c=='^'||c=='\\')
+// calculation operators may have two chars, for example: += -= *= /= ~= != == >= <=
+#define IS_CALC_OPERATOR(c)   (c=='='||c=='+'||c=='-'||c=='*'||c=='!'||c=='/'||c=='<'||c=='>'||c=='~')
+#define IS_NOTE(c)            (c=='#')
+
+enum token_type
+{
+    tok_null=0,
+    tok_num,tok_str,tok_id,
+    tok_for,tok_forindex,tok_foreach,tok_while,
+    tok_var,tok_func,tok_break,tok_continue,
+    tok_ret,tok_if,tok_elsif,tok_else,tok_nil,
+    tok_lcurve,tok_rcurve,
+    tok_lbracket,tok_rbracket,
+    tok_lbrace,tok_rbrace,
+    tok_semi,tok_and,tok_or,tok_comma,tok_dot,tok_ellipsis,tok_quesmark,
+    tok_colon,tok_add,tok_sub,tok_mult,tok_div,tok_link,tok_not,
+    tok_eq,
+    tok_addeq,tok_subeq,tok_multeq,tok_diveq,tok_lnkeq,
+    tok_cmpeq,tok_neq,tok_less,tok_leq,tok_grt,tok_geq,
+    tok_eof
+};
+
+struct
+{
+    const char* str;
+    const int tok_type;
+}token_table[]=
+{
+    {"for"     ,tok_for      },
+    {"forindex",tok_forindex },
+    {"foreach" ,tok_foreach  },
+    {"while"   ,tok_while    },
+    {"var"     ,tok_var      },
+    {"func"    ,tok_func     },
+    {"break"   ,tok_break    },
+    {"continue",tok_continue },
+    {"return"  ,tok_ret      },
+    {"if"      ,tok_if       },
+    {"elsif"   ,tok_elsif    },
+    {"else"    ,tok_else     },
+    {"nil"     ,tok_nil      },
+    {"("       ,tok_lcurve   },
+    {")"       ,tok_rcurve   },
+    {"["       ,tok_lbracket },
+    {"]"       ,tok_rbracket },
+    {"{"       ,tok_lbrace   },
+    {"}"       ,tok_rbrace   },
+    {";"       ,tok_semi     },
+    {"and"     ,tok_and      },
+    {"or"      ,tok_or       },
+    {","       ,tok_comma    },
+    {"."       ,tok_dot      },
+    {"..."     ,tok_ellipsis },
+    {"?"       ,tok_quesmark },
+    {":"       ,tok_colon    },
+    {"+"       ,tok_add      },
+    {"-"       ,tok_sub      },
+    {"*"       ,tok_mult     },
+    {"/"       ,tok_div      },
+    {"~"       ,tok_link     },
+    {"!"       ,tok_not      },
+    {"="       ,tok_eq       },
+    {"+="      ,tok_addeq    },
+    {"-="      ,tok_subeq    },
+    {"*="      ,tok_multeq   },
+    {"/="      ,tok_diveq    },
+    {"~="      ,tok_lnkeq    },
+    {"=="      ,tok_cmpeq    },
+    {"!="      ,tok_neq      },
+    {"<"       ,tok_less     },
+    {"<="      ,tok_leq      },
+    {">"       ,tok_grt      },
+    {">="      ,tok_geq      },
+    {nullptr   ,-1           }
+};
+
+struct token
+{
+    uint32_t line;
+    uint32_t type;
+    std::string str;
+    token(uint32_t l=0,uint32_t t=tok_null,std::string s=""){line=l;type=t;str=s;}
+};
+
+class nasal_lexer
+{
+private:
+    uint32_t    error;
+    uint32_t    line;
+    uint32_t    ptr;
+    size_t      res_size;
+    std::string line_code;
+    std::string res;
+    std::vector<token> token_list;
+    uint32_t get_type(const std::string&);
+    void die(const char*);
+    std::string id_gen();
+    std::string num_gen();
+    std::string str_gen();
+public:
+    void open(const std::string&);
+    void scan();
+    void print();
+    uint32_t err(){return error;}
+    const std::vector<token>& get_tokens(){return token_list;}
+};
+
+void nasal_lexer::open(const std::string& filename)
+{
+    error=0;
+    res.clear();
+    std::ifstream fin(filename,std::ios::binary);
+    if(fin.fail())
+    {
+        ++error;
+        std::cout<<"[lexer] cannot open file <"<<filename<<">.\n";
+        return;
+    }
+    std::stringstream ss;
+    ss<<fin.rdbuf();
+    res=ss.str();
+    // while(!fin.eof())
+    // {
+    //     char c=fin.get();
+    //     if(fin.eof())
+    //         break;
+    //     res+=c;
+    // }
+    return;
+}
+
+uint32_t nasal_lexer::get_type(const std::string& tk_str)
+{
+    for(int i=0;token_table[i].str;++i)
+        if(tk_str==token_table[i].str)
+            return token_table[i].tok_type;
+    return tok_null;
+}
+
+void nasal_lexer::die(const char* error_info)
+{
+    ++error;
+    std::cout<<"[lexer] line "<<line<<" column "<<line_code.length()<<": \n"<<line_code<<"\n";
+    for(auto i:line_code)
+        std::cout<<(i=='\t'?'\t':' ');
+    std::cout<<"^"<<error_info<<'\n';
+    return;
+}
+
+std::string nasal_lexer::id_gen()
+{
+    std::string token_str="";
+    while(ptr<res_size && (IS_IDENTIFIER(res[ptr])||IS_DIGIT(res[ptr])))
+        token_str+=res[ptr++];
+    line_code+=token_str;
+    return token_str;
+    // after running this process, ptr will point to the next token's beginning character
+}
+
+std::string nasal_lexer::num_gen()
+{
+    // generate hex number
+    if(ptr+1<res_size && res[ptr]=='0' && res[ptr+1]=='x')
+    {
+        std::string token_str="0x";
+        ptr+=2;
+        while(ptr<res_size && IS_HEX_NUMBER(res[ptr]))
+            token_str+=res[ptr++];
+        line_code+=token_str;
+        if(token_str.length()<3)// "0x"
+            die("incorrect number.");
+        return token_str;
+    }
+    // generate oct number
+    else if(ptr+1<res_size && res[ptr]=='0' && res[ptr+1]=='o')
+    {
+        std::string token_str="0o";
+        ptr+=2;
+        while(ptr<res_size && IS_OCT_NUMEBR(res[ptr]))
+            token_str+=res[ptr++];
+        line_code+=token_str;
+        if(token_str.length()<3)// "0o"
+            die("incorrect number.");
+        return token_str;
+    }
+    // generate dec number
+    // dec number -> [0~9][0~9]*(.[0~9]*)(e|E(+|-)0|[1~9][0~9]*)
+    std::string token_str="";
+    while(ptr<res_size && IS_DIGIT(res[ptr]))
+        token_str+=res[ptr++];
+    if(ptr<res_size && res[ptr]=='.')
+    {
+        token_str+=res[ptr++];
+        while(ptr<res_size && IS_DIGIT(res[ptr]))
+            token_str+=res[ptr++];
+        // "xxxx." is not a correct number
+        if(token_str.back()=='.')
+        {
+            line_code+=token_str;
+            die("incorrect number.");
+            return "0";
+        }
+    }
+    if(ptr<res_size && (res[ptr]=='e' || res[ptr]=='E'))
+    {
+        token_str+=res[ptr++];
+        if(ptr<res_size && (res[ptr]=='-' || res[ptr]=='+'))
+            token_str+=res[ptr++];
+        while(ptr<res_size && IS_DIGIT(res[ptr]))
+            token_str+=res[ptr++];
+        // "xxxe(-|+)" is not a correct number
+        if(token_str.back()=='e' || token_str.back()=='E' || token_str.back()=='-' || token_str.back()=='+')
+        {
+            line_code+=token_str;
+            die("incorrect number.");
+            return "0";
+        }
+    }
+    line_code+=token_str;
+    return token_str;
+}
+
+std::string nasal_lexer::str_gen()
+{
+    std::string token_str="";
+    char str_begin=res[ptr];
+    line_code+=str_begin;
+    while(++ptr<res_size && res[ptr]!=str_begin)
+    {
+        line_code+=res[ptr];
+        if(res[ptr]=='\n')
+        {
+            line_code="";
+            ++line;
+        }
+        if(res[ptr]=='\\' && ptr+1<res_size)
+        {
+            line_code+=res[++ptr];
+            switch(res[ptr])
+            {
+                case 'a': token_str.push_back('\a');break;
+                case 'b': token_str.push_back('\b');break;
+                case 'f': token_str.push_back('\f');break;
+                case 'n': token_str.push_back('\n');break;
+                case 'r': token_str.push_back('\r');break;
+                case 't': token_str.push_back('\t');break;
+                case 'v': token_str.push_back('\v');break;
+                case '?': token_str.push_back('\?');break;
+                case '0': token_str.push_back('\0');break;
+                case '\\':token_str.push_back('\\');break;
+                case '\'':token_str.push_back('\'');break;
+                case '\"':token_str.push_back('\"');break;
+                default:  token_str.push_back(res[ptr]);break;
+            }
+            continue;
+        }
+        token_str+=res[ptr];
+    }
+    // check if this string ends with a " or '
+    if(ptr++>=res_size)
+        die("get EOF when generating string.");
+    if(str_begin=='`' && token_str.length()!=1)
+        die("\'`\' is used for string that includes one character.");
+    return token_str;
+}
+
+void nasal_lexer::scan()
+{
+    token_list.clear();
+    line=1;
+    ptr=0;
+    line_code="";
+    res_size=res.size();
+
+    std::string token_str;
+    while(ptr<res_size)
+    {
+        while(ptr<res_size && (res[ptr]==' ' || res[ptr]=='\n' || res[ptr]=='\t' || res[ptr]=='\r' || res[ptr]<0))
+        {
+            // these characters will be ignored, and '\n' will cause ++line
+            line_code+=res[ptr];
+            if(res[ptr++]=='\n')
+            {
+                ++line;
+                line_code="";
+            }
+        }
+        if(ptr>=res_size) break;
+        if(IS_IDENTIFIER(res[ptr]))
+        {
+            token_str=id_gen();
+            token_list.push_back({line,get_type(token_str),token_str});
+            if(!token_list.back().type)
+                token_list.back().type=tok_id;
+        }
+        else if(IS_DIGIT(res[ptr]))
+            token_list.push_back({line,tok_num,num_gen()});
+        else if(IS_STRING(res[ptr]))
+            token_list.push_back({line,tok_str,str_gen()});
+        else if(IS_SINGLE_OPERATOR(res[ptr]))
+        {
+            token_str=res[ptr];
+            line_code+=res[ptr];
+            uint32_t type=get_type(token_str);
+            if(!type)
+                die("incorrect operator.");
+            token_list.push_back({line,type,token_str});
+            ++ptr;
+        }
+        else if(res[ptr]=='.')
+        {
+            if(ptr+2<res_size && res[ptr+1]=='.' && res[ptr+2]=='.')
+            {
+                token_str="...";
+                ptr+=3;
+            }
+            else
+            {
+                token_str=".";
+                ++ptr;
+            }
+            line_code+=token_str;
+            token_list.push_back({line,get_type(token_str),token_str});
+        }
+        else if(IS_CALC_OPERATOR(res[ptr]))
+        {
+            // get calculation operator
+            token_str=res[ptr++];
+            if(ptr<res_size && res[ptr]=='=')
+                token_str+=res[ptr++];
+            line_code+=token_str;
+            token_list.push_back({line,get_type(token_str),token_str});
+        }
+        else if(IS_NOTE(res[ptr]))// avoid note, after this process ptr will point to a '\n', so next loop line counter+1
+            while(++ptr<res_size && res[ptr]!='\n');
+        else
+        {
+            line_code+=res[ptr++];
+            die("unknown character.");
+        }
+    }
+    token_list.push_back({line,tok_eof,""});
+    res.clear();
+    return;
+}
+
+void nasal_lexer::print()
+{
+    for(auto& tok:token_list)
+        std::cout<<"("<<tok.line<<" | "<<tok.str<<")\n";
+    return;
+}
+
 #endif
\ No newline at end of file
diff --git a/nasal_parse.h b/nasal_parse.h
index da2533d..dd5815c 100644
--- a/nasal_parse.h
+++ b/nasal_parse.h
@@ -1,1014 +1,1014 @@
-#ifndef __NASAL_PARSE_H__
-#define __NASAL_PARSE_H__
-
-/*
-              _,,,_                                       
-            .'     `'.                                    
-           /     ____ \      Fucking Nasal Parser
-           |  .-'_  _\/    /                              
-           \_/   a  a|    /                               
-           (,`     \ |         .----.                     
-            |     -' |        /|     '--.                 
-             \   '=  /        ||    ]|   `-.              
-             /`-.__.'         ||    ]|    ::|             
-          .-'`-.__ \__        ||    ]|    ::|             
-         /        ``  `.      ||    ]|    ::|             
-       _ |     \     \  \     \|    ]|   .-'              
-      / \|      \    |   \     L.__  .--'(                
-     |   |\      `.  |    \  ,---|_      \---------,      
-     |   | '.      './\    \/ .--._|=-    |_      /|      
-     |   \   '.     `'.'. /`\/ .-'          '.   / |      
-     |   |     `'.     `;-:-;`)|             |-./  |      
-     |   /_       `'--./_  ` )/'-------------')/)  |      
-     \   | `""""----"`\//`""`/,===..'`````````/ (  |      
-      |  |            / `---` `==='          /   ) |      
-      /  \           /                      /   (  |      
-     |    '------.  |'--------------------'|     ) |      
-      \           `-|                      |    /  |      
-       `--...,______|                      |   (   |      
-              | |   |                      |    ) ,|      
-              | |   |                      |   ( /||      
-              | |   |                      |   )/ `"      
-             /   \  |                      |  (/          
-           .' /I\ '.|                      |  /)          
-        .-'_.'/ \'. |                      | /            
-        ```  `"""` `| .-------------------.||             
-                    `"`                   `"`             
-*/
-
-class nasal_parse
-{
-#define error_line (tok_list[ptr].line)
-#define is_call(type) ((type)==tok_lcurve || (type)==tok_lbracket || (type)==tok_dot)
-private:
-    int ptr;
-    uint32_t error;
-    nasal_ast root;
-    std::vector<token> tok_list;
-    std::vector<token> error_token;
-    int in_function; // count when generating function block,used to check return-expression
-    int in_loop;     // count when generating loop block,used to check break/continue-expression
-    void die(int,const std::string&&);
-    void die(int,const char*);
-    void match(int type,const char* err_info="");
-    bool check_comma(const int*);
-    bool check_multi_scalar();
-    bool check_function_end(const nasal_ast&);
-    bool check_special_call();
-    bool need_semi_check(const nasal_ast&);
-    void check_memory_reachable(const nasal_ast&);
-    nasal_ast null_node_gen();
-    nasal_ast nil_gen();
-    nasal_ast num_gen();
-    nasal_ast str_gen();
-    nasal_ast id_gen();
-    nasal_ast vec_gen();
-    nasal_ast hash_gen();
-    nasal_ast hmem_gen();
-    nasal_ast func_gen();
-    nasal_ast args_gen();
-    nasal_ast lcurve_expr();
-    nasal_ast expr();
-    nasal_ast exprs();
-    nasal_ast calc();
-    nasal_ast or_expr();
-    nasal_ast and_expr();
-    nasal_ast cmp_expr();
-    nasal_ast additive_expr();
-    nasal_ast multive_expr();
-    nasal_ast unary();
-    nasal_ast scalar();
-    nasal_ast call_scalar();
-    nasal_ast callh();
-    nasal_ast callv();
-    nasal_ast callf();
-    nasal_ast subvec();
-    nasal_ast definition();
-    nasal_ast var_incurve_def();
-    nasal_ast var_outcurve_def();
-    nasal_ast multi_id();
-    nasal_ast multi_scalar(bool);
-    nasal_ast multi_assgin();
-    nasal_ast loop();
-    nasal_ast while_loop();
-    nasal_ast for_loop();
-    nasal_ast forei_loop();
-    nasal_ast new_iter_gen();
-    nasal_ast conditional();
-    nasal_ast continue_expr();
-    nasal_ast break_expr();
-    nasal_ast ret_expr();
-public:
-    uint32_t   err(){return error;}
-    void       compile(const std::vector<token>&);
-    nasal_ast& get_root(){return root;}
-};
-void nasal_parse::compile(const std::vector<token>& toks)
-{
-    tok_list=toks;
-    ptr=in_function=in_loop=error=0;
-    root.clear();
-    error_token.clear();
-
-    root.set_line(1);
-    root.set_type(ast_root);
-    while(tok_list[ptr].type!=tok_eof)
-    {
-        int err_tok_size=error_token.size();
-        root.add_child(expr());
-        if(tok_list[ptr].type==tok_semi)
-            match(tok_semi);
-        // if detect error token, avoid checking semicolon
-        else if(error_token.size()>err_tok_size)
-            continue;
-        // the last expression can be recognized without semi
-        else if(need_semi_check(root.get_children().back()) && tok_list[ptr].type!=tok_eof)
-            die(error_line,"expected \";\"");
-    }
-    if(!error_token.size())
-        return;
-    ++error;
-    std::cout<<"[parse] line";
-    int err_line=0;
-    for(auto& tok:error_token)
-        if(err_line!=tok.line)
-        {
-            std::cout<<' '<<tok.line;
-            err_line=tok.line;
-        }
-    std::cout
-    <<" have fatal syntax errors."
-    <<"check \'(\',\'[\',\'{\',\')\',\']\',\'}\' match or not.\n";
-    return;
-}
-void nasal_parse::die(int line,const std::string&& info)
-{
-    ++error;
-    std::cout<<"[parse] line "<<line<<": "<<info<<".\n";
-}
-void nasal_parse::die(int line,const char* info)
-{
-    ++error;
-    std::cout<<"[parse] line "<<line<<": "<<info<<".\n";
-}
-void nasal_parse::match(int type,const char* err_info)
-{
-    if(tok_list[ptr].type!=type)
-    {
-        if(err_info[0])
-        {
-            die(error_line,err_info);
-            return;
-        }
-        switch(type)
-        {
-            case tok_num:die(error_line,"expected number");    break;
-            case tok_str:die(error_line,"expected string");    break;
-            case tok_id: die(error_line,"expected identifier");break;
-            default:     die(error_line,"expected \'"+std::string(token_table[type-tok_for].str)+"\'"); break;
-        }
-        return;
-    }
-    if(tok_list[ptr].type==tok_eof)
-        return;
-    ++ptr;
-    return;
-}
-bool nasal_parse::check_comma(const int* panic_set)
-{
-    for(int i=0;panic_set[i];++i)
-        if(tok_list[ptr].type==panic_set[i])
-        {
-            die(error_line,"expected \',\' between scalars");
-            return true;
-        }
-    return false;
-}
-bool nasal_parse::check_multi_scalar()
-{
-    int check_ptr=ptr,curve_cnt=1,bracket_cnt=0,brace_cnt=0;
-    while(tok_list[++check_ptr].type!=tok_eof && curve_cnt)
-    {
-        switch(tok_list[check_ptr].type)
-        {
-            case tok_lcurve:   ++curve_cnt;   break;
-            case tok_lbracket: ++bracket_cnt; break;
-            case tok_lbrace:   ++brace_cnt;   break;
-            case tok_rcurve:   --curve_cnt;   break;
-            case tok_rbracket: --bracket_cnt; break;
-            case tok_rbrace:   --brace_cnt;   break;
-        }
-        if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_comma)
-            return true;
-    }
-    return false;
-}
-bool nasal_parse::check_function_end(const nasal_ast& node)
-{
-    int type=node.get_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.get_children().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_function_end(node.get_children().back());
-    return false;
-}
-bool nasal_parse::check_special_call()
-{
-    // special call means like this:
-    // function_name(a:1,b:2,c:3);
-    int check_ptr=ptr,curve_cnt=1,bracket_cnt=0,brace_cnt=0,ques_cnt=0;
-    while(tok_list[++check_ptr].type!=tok_eof && curve_cnt)
-    {
-        switch(tok_list[check_ptr].type)
-        {
-            case tok_lcurve:   ++curve_cnt;  break;
-            case tok_lbracket: ++bracket_cnt;break;
-            case tok_lbrace:   ++brace_cnt;  break;
-            case tok_rcurve:   --curve_cnt;  break;
-            case tok_rbracket: --bracket_cnt;break;
-            case tok_rbrace:   --brace_cnt;  break;
-        }
-        // m?1:0 will be recognized as normal parameter
-        if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_quesmark)
-            return false;
-        if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_colon)
-            return true;
-    }
-    return false;
-}
-bool nasal_parse::need_semi_check(const nasal_ast& node)
-{
-    int type=node.get_type();
-    if(type==ast_for || type==ast_foreach || type==ast_forindex || type==ast_while || type==ast_conditional)
-        return false;
-    return !check_function_end(node);
-}
-void nasal_parse::check_memory_reachable(const nasal_ast& node)
-{
-    if(node.get_type()==ast_call)
-    {
-        const nasal_ast& tmp=node.get_children().back();
-        if(tmp.get_type()==ast_callf)
-            die(tmp.get_line(),"bad left-value");
-        if(tmp.get_type()==ast_callv && (tmp.get_children().size()>1 || tmp.get_children()[0].get_type()==ast_subvec))
-            die(tmp.get_line(),"bad left-value");
-    }
-    else if(node.get_type()!=ast_id)
-        die(node.get_line(),"bad left-value");
-    return;
-}
-nasal_ast nasal_parse::null_node_gen()
-{
-    return nasal_ast(tok_list[ptr].line,ast_null);
-}
-nasal_ast nasal_parse::nil_gen()
-{
-    return nasal_ast(tok_list[ptr].line,ast_nil);
-}
-nasal_ast nasal_parse::num_gen()
-{
-    nasal_ast node(tok_list[ptr].line,ast_num);
-    node.set_num(str2num(tok_list[ptr].str.c_str()));
-    return node;
-}
-nasal_ast nasal_parse::str_gen()
-{
-    nasal_ast node(tok_list[ptr].line,ast_str);
-    node.set_str(tok_list[ptr].str);
-    return node;
-}
-nasal_ast nasal_parse::id_gen()
-{
-    nasal_ast node(tok_list[ptr].line,ast_id);
-    node.set_str(tok_list[ptr].str);
-    return node;
-}
-nasal_ast nasal_parse::vec_gen()
-{
-    // panic set for this token is not ','
-    // this is the FIRST set of calculation
-    // array end with tok_null=0
-    const int panic_set[]={tok_id,tok_str,tok_num,tok_not,tok_sub,tok_nil,tok_func,tok_var,tok_lcurve,tok_lbrace,tok_lbracket,tok_null};
-    nasal_ast node(tok_list[ptr].line,ast_vec);
-    match(tok_lbracket);
-    while(tok_list[ptr].type!=tok_rbracket)
-    {
-        node.add_child(calc());
-        if(tok_list[ptr].type==tok_comma)
-            match(tok_comma);
-        else if(tok_list[ptr].type==tok_eof)
-            break;
-        else if(tok_list[ptr].type!=tok_rbracket && !check_comma(panic_set))
-            break;
-    }
-    match(tok_rbracket,"expected \']\' when generating vector");
-    return node;
-}
-nasal_ast nasal_parse::hash_gen()
-{
-    nasal_ast node(tok_list[ptr].line,ast_hash);
-    match(tok_lbrace);
-    while(tok_list[ptr].type!=tok_rbrace)
-    {
-        node.add_child(hmem_gen());
-        if(tok_list[ptr].type==tok_comma)
-            match(tok_comma);
-        else if(tok_list[ptr].type==tok_id || tok_list[ptr].type==tok_str)// first set of hashmember
-            die(error_line,"expected \',\' between hash members");
-        else
-            break;
-    }
-    match(tok_rbrace,"expected \'}\' when generating hash");
-    return node;
-}
-nasal_ast nasal_parse::hmem_gen()
-{
-    nasal_ast node(tok_list[ptr].line,ast_hashmember);
-    if(tok_list[ptr].type==tok_id)
-    {
-        node.add_child(id_gen());
-        match(tok_id);
-    }
-    else if(tok_list[ptr].type==tok_str)
-    {
-        node.add_child(str_gen());
-        match(tok_str);
-    }
-    else
-        match(tok_id);
-    match(tok_colon);
-    node.add_child(calc());
-    return node;
-}
-nasal_ast nasal_parse::func_gen()
-{
-    nasal_ast node(tok_list[ptr].line,ast_func);
-    match(tok_func);
-    if(tok_list[ptr].type==tok_lcurve)
-        node.add_child(args_gen());
-    else
-        node.add_child(null_node_gen());
-    node.add_child(exprs());
-    return node;
-}
-nasal_ast nasal_parse::args_gen()
-{
-    nasal_ast node(tok_list[ptr].line,ast_args);
-    match(tok_lcurve);
-    while(tok_list[ptr].type!=tok_rcurve)
-    {
-        nasal_ast tmp=id_gen();
-        match(tok_id);
-        if(tok_list[ptr].type==tok_eq || tok_list[ptr].type==tok_ellipsis)
-        {
-            nasal_ast special_arg(tok_list[ptr].line,ast_null);
-            if(tok_list[ptr].type==tok_eq)
-            {
-                match(tok_eq);
-                special_arg=std::move(tmp);
-                special_arg.set_type(ast_default_arg);
-                special_arg.add_child(calc());
-            }
-            else
-            {
-                match(tok_ellipsis);
-                special_arg=std::move(tmp);
-                special_arg.set_type(ast_dynamic_id);
-            }
-            node.add_child(std::move(special_arg));
-        }
-        else
-            node.add_child(std::move(tmp));
-        if(tok_list[ptr].type==tok_comma)
-            match(tok_comma);
-        else if(tok_list[ptr].type==tok_id)// first set of identifier
-            die(error_line,"expected \',\' between identifiers");
-        else
-            break;
-    }
-    match(tok_rcurve,"expected \')\' after parameter list");
-
-    std::string args_format="func(";
-    for(auto& tmp:node.get_children())
-    {
-        switch(tmp.get_type())
-        {
-            case ast_id:          args_format+=tmp.get_str();break;
-            case ast_default_arg: args_format+=tmp.get_str()+"=val";break;
-            case ast_dynamic_id:  args_format+=tmp.get_str()+"...";break;
-        }
-        args_format+=",)"[&tmp==&node.get_children().back()];
-    }
-    bool checked_default_val=false,checked_dynamic_ids=false;
-    for(auto& tmp:node.get_children())
-    {
-        if(tmp.get_type()==ast_default_arg)
-            checked_default_val=true;
-        else if(tmp.get_type()==ast_dynamic_id)
-            checked_dynamic_ids=true;
-        if(checked_default_val && tmp.get_type()!=ast_default_arg)
-            die(tmp.get_line(),"must use default paras after using it once: "+args_format);
-        if(checked_dynamic_ids && &tmp!=&node.get_children().back())
-            die(tmp.get_line(),"dynamic para must be the end: "+args_format);
-    }
-    std::unordered_map<std::string,bool> argname_table;
-    for(auto& tmp:node.get_children())
-    {
-        std::string new_name;
-        switch(tmp.get_type())
-        {
-            case ast_dynamic_id:
-            case ast_id:         new_name=tmp.get_str();break;
-            case ast_default_arg:new_name=tmp.get_str();break;
-        }
-        if(argname_table.count(new_name))
-            die(tmp.get_line(),"parameter's name repeats: "+new_name);
-        else
-            argname_table[new_name]=true;
-    }
-    return node;
-}
-nasal_ast nasal_parse::lcurve_expr()
-{
-    if(tok_list[ptr+1].type==tok_var)
-        return definition();
-    return check_multi_scalar()?multi_assgin():calc();
-}
-nasal_ast nasal_parse::expr()
-{
-    nasal_ast node(tok_list[ptr].line,ast_null);
-    int tok_type=tok_list[ptr].type;
-    if((tok_type==tok_break || tok_type==tok_continue) && !in_loop)
-        die(error_line,"use break/continue in the loop");
-    if(tok_type==tok_ret && !in_function)
-        die(error_line,"use return in the function");
-    switch(tok_type)
-    {
-        case tok_nil:
-        case tok_num:
-        case tok_str:
-        case tok_id:
-        case tok_func:
-        case tok_lbracket:
-        case tok_lbrace:
-        case tok_sub:
-        case tok_not:      node=calc();          break;
-        case tok_var:      node=definition();    break;
-        case tok_lcurve:   node=lcurve_expr();   break;
-        case tok_for:
-        case tok_forindex:
-        case tok_foreach:
-        case tok_while:    node=loop();          break;
-        case tok_if:       node=conditional();   break;
-        case tok_continue: node=continue_expr(); break;
-        case tok_break:    node=break_expr();    break;
-        case tok_ret:      node=ret_expr();      break;
-        case tok_semi:                           break;
-        default:error_token.push_back(tok_list[ptr]);++ptr;break;
-    }
-    return node;
-}
-nasal_ast nasal_parse::exprs()
-{
-    if(tok_list[ptr].type==tok_eof)
-    {
-        die(error_line,"expected expression block");
-        return null_node_gen();
-    }
-    nasal_ast node(tok_list[ptr].line,ast_block);
-    if(tok_list[ptr].type==tok_lbrace)
-    {
-        match(tok_lbrace);
-        while(tok_list[ptr].type!=tok_rbrace && tok_list[ptr].type!=tok_eof)
-        {
-            int err_tok_size=error_token.size();
-            node.add_child(expr());
-            if(tok_list[ptr].type==tok_semi)
-                match(tok_semi);
-            // if detect error token, avoid checking semicolon
-            else if(error_token.size()>err_tok_size)
-                continue;
-            // the last expression can be recognized without semi
-            else if(need_semi_check(node.get_children().back()) && tok_list[ptr].type!=tok_rbrace)
-                die(error_line,"expected \";\"");
-        }
-        match(tok_rbrace,"expected \'}\' when generating expressions");
-    }
-    else
-    {
-        node.add_child(expr());
-        if(tok_list[ptr].type==tok_semi)
-            match(tok_semi);
-    }
-    return node;
-}
-nasal_ast nasal_parse::calc()
-{
-    nasal_ast node=or_expr();
-    if(tok_list[ptr].type==tok_quesmark)
-    {
-        // trinocular calculation
-        nasal_ast tmp(tok_list[ptr].line,ast_trino);
-        match(tok_quesmark);
-        tmp.add_child(std::move(node));
-        tmp.add_child(calc());
-        match(tok_colon);
-        tmp.add_child(calc());
-        node=std::move(tmp);
-    }
-    else if(tok_eq<=tok_list[ptr].type && tok_list[ptr].type<=tok_lnkeq)
-    {
-        check_memory_reachable(node);
-        // tok_eq~tok_lnkeq is 37 to 42,ast_equal~ast_lnkeq is 21~26
-        nasal_ast tmp(tok_list[ptr].line,tok_list[ptr].type-tok_eq+ast_equal);
-        tmp.add_child(std::move(node));
-        match(tok_list[ptr].type);
-        tmp.add_child(calc());
-        node=std::move(tmp);
-    }
-    return node;
-}
-nasal_ast nasal_parse::or_expr()
-{
-    nasal_ast node=and_expr();
-    while(tok_list[ptr].type==tok_or)
-    {
-        nasal_ast tmp(tok_list[ptr].line,ast_or);
-        tmp.add_child(std::move(node));
-        match(tok_or);
-        tmp.add_child(and_expr());
-        node=std::move(tmp);
-    }
-    return node;
-}
-nasal_ast nasal_parse::and_expr()
-{
-    nasal_ast node=cmp_expr();
-    while(tok_list[ptr].type==tok_and)
-    {
-        nasal_ast tmp(tok_list[ptr].line,ast_and);
-        tmp.add_child(std::move(node));
-        match(tok_and);
-        tmp.add_child(cmp_expr());
-        node=std::move(tmp);
-    }
-    return node;
-}
-nasal_ast nasal_parse::cmp_expr()
-{
-    nasal_ast node=additive_expr();
-    while(tok_cmpeq<=tok_list[ptr].type && tok_list[ptr].type<=tok_geq)
-    {
-        // tok_cmpeq~tok_geq is 43~48,ast_cmpeq~ast_geq is 27~32
-        nasal_ast tmp(tok_list[ptr].line,tok_list[ptr].type-tok_cmpeq+ast_cmpeq);
-        tmp.add_child(std::move(node));
-        match(tok_list[ptr].type);
-        tmp.add_child(additive_expr());
-        node=std::move(tmp);
-    }
-    return node;
-}
-nasal_ast nasal_parse::additive_expr()
-{
-    nasal_ast node=multive_expr();
-    while(tok_list[ptr].type==tok_add || tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_link)
-    {
-        nasal_ast tmp(tok_list[ptr].line,ast_null);
-        switch(tok_list[ptr].type)
-        {
-            case tok_add:  tmp.set_type(ast_add);  break;
-            case tok_sub:  tmp.set_type(ast_sub);  break;
-            case tok_link: tmp.set_type(ast_link); break;
-        }
-        tmp.add_child(std::move(node));
-        match(tok_list[ptr].type);
-        tmp.add_child(multive_expr());
-        node=std::move(tmp);
-    }
-    return node;
-}
-nasal_ast nasal_parse::multive_expr()
-{
-    nasal_ast node=(tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_not)?unary():scalar();
-    while(tok_list[ptr].type==tok_mult || tok_list[ptr].type==tok_div)
-    {
-        nasal_ast tmp(tok_list[ptr].line,tok_list[ptr].type-tok_mult+ast_mult);
-        tmp.add_child(std::move(node));
-        match(tok_list[ptr].type);
-        tmp.add_child((tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_not)?unary():scalar());
-        node=std::move(tmp);
-    }
-    return node;
-}
-nasal_ast nasal_parse::unary()
-{
-    nasal_ast node(tok_list[ptr].line,ast_null);
-    switch(tok_list[ptr].type)
-    {
-        case tok_sub:node.set_type(ast_neg);match(tok_sub);break;
-        case tok_not:node.set_type(ast_not);match(tok_not);break;
-    }
-    node.add_child((tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_not)?unary():scalar());
-    return node;
-}
-nasal_ast nasal_parse::scalar()
-{
-    nasal_ast node(tok_list[ptr].line,ast_null);
-    if(tok_list[ptr].type==tok_nil)     {node=nil_gen(); match(tok_nil);}
-    else if(tok_list[ptr].type==tok_num){node=num_gen(); match(tok_num);}
-    else if(tok_list[ptr].type==tok_str){node=str_gen(); match(tok_str);}
-    else if(tok_list[ptr].type==tok_id) {node=id_gen();  match(tok_id); }
-    else if(tok_list[ptr].type==tok_func)
-    {
-        ++in_function;
-        node=func_gen();
-        --in_function;
-    }
-    else if(tok_list[ptr].type==tok_lbracket)
-        node=vec_gen();
-    else if(tok_list[ptr].type==tok_lbrace)
-        node=hash_gen();
-    else if(tok_list[ptr].type==tok_lcurve)
-    {
-        match(tok_lcurve);
-        node=calc();
-        match(tok_rcurve);
-    }
-    else if(tok_list[ptr].type==tok_var)
-    {
-        match(tok_var);
-        node.set_type(ast_def);
-        node.add_child(id_gen());
-        match(tok_id);
-        match(tok_eq);
-        node.add_child(calc());
-    }
-    else
-    {
-        die(error_line,"expected scalar");
-        return node;
-    }
-    // check call and avoid ambiguous syntax
-    if(is_call(tok_list[ptr].type) && !(tok_list[ptr].type==tok_lcurve && tok_list[ptr+1].type==tok_var))
-    {
-        nasal_ast tmp=std::move(node);
-        node.set_line(tok_list[ptr].line);
-        node.set_type(ast_call);
-        node.add_child(std::move(tmp));
-        while(is_call(tok_list[ptr].type))
-            node.add_child(call_scalar());
-    }
-    return node;
-}
-nasal_ast nasal_parse::call_scalar()
-{
-    switch(tok_list[ptr].type)
-    {
-        case tok_lcurve:   return callf(); break;
-        case tok_lbracket: return callv(); break;
-        case tok_dot:      return callh(); break;
-    }
-    // should never run this expression
-    return nasal_ast(tok_list[ptr].line,ast_nil);
-}
-nasal_ast nasal_parse::callh()
-{
-    nasal_ast node(tok_list[ptr].line,ast_callh);
-    match(tok_dot);
-    node.set_str(tok_list[ptr].str);
-    match(tok_id);
-    return node;
-}
-nasal_ast nasal_parse::callv()
-{
-    // panic set for this token is not ','
-    // this is the FIRST set of subvec
-    // array end with tok_null=0
-    const int panic_set[]={tok_id,tok_str,tok_num,tok_not,tok_sub,tok_nil,tok_func,tok_var,tok_lcurve,tok_lbrace,tok_lbracket,tok_colon,tok_null};
-    nasal_ast node(tok_list[ptr].line,ast_callv);
-    match(tok_lbracket);
-    while(tok_list[ptr].type!=tok_rbracket)
-    {
-        node.add_child(subvec());
-        if(tok_list[ptr].type==tok_comma)
-            match(tok_comma);
-        else if(tok_list[ptr].type==tok_eof)
-            break;
-        else if(tok_list[ptr].type!=tok_rbracket && !check_comma(panic_set))
-            break;
-    }
-    match(tok_rbracket,"expected \']\' when calling vector");
-    return node;
-}
-nasal_ast nasal_parse::callf()
-{
-    // panic set for this token is not ','
-    // this is the FIRST set of calculation/hashmember
-    // array end with tok_null=0
-    const int panic_set[]={tok_id,tok_str,tok_num,tok_not,tok_sub,tok_nil,tok_func,tok_var,tok_lcurve,tok_lbrace,tok_lbracket,tok_null};
-    nasal_ast node(tok_list[ptr].line,ast_callf);
-    bool special_call=check_special_call();
-    match(tok_lcurve);
-    while(tok_list[ptr].type!=tok_rcurve)
-    {
-        node.add_child(special_call?hmem_gen():calc());
-        if(tok_list[ptr].type==tok_comma)
-            match(tok_comma);
-        else if(tok_list[ptr].type==tok_eof)
-            break;
-        else if(tok_list[ptr].type!=tok_rcurve && !check_comma(panic_set))
-            break;
-    }
-    match(tok_rcurve,"expected \')\' when calling function");
-    return node;
-}
-nasal_ast nasal_parse::subvec()
-{
-    nasal_ast node=tok_list[ptr].type==tok_colon?nil_gen():calc();
-    if(tok_list[ptr].type==tok_colon)
-    {
-        nasal_ast tmp(node.get_line(),ast_subvec);
-        match(tok_colon);
-        tmp.add_child(std::move(node));
-        tmp.add_child((tok_list[ptr].type==tok_comma || tok_list[ptr].type==tok_rbracket)?nil_gen():calc());
-        node=std::move(tmp);
-    }
-    return node;
-}
-nasal_ast nasal_parse::definition()
-{
-    nasal_ast node(tok_list[ptr].line,ast_def);
-    if(tok_list[ptr].type==tok_var)
-    {
-        match(tok_var);
-        switch(tok_list[ptr].type)
-        {
-            case tok_id:     node.add_child(id_gen());match(tok_id); break;
-            case tok_lcurve: node.add_child(var_outcurve_def());     break;
-            default:         die(error_line,"expected identifier");  break;
-        }
-    }
-    else if(tok_list[ptr].type==tok_lcurve)
-        node.add_child(var_incurve_def());
-    match(tok_eq);
-    if(tok_list[ptr].type==tok_lcurve)
-        node.add_child(check_multi_scalar()?multi_scalar(false):calc());
-    else
-        node.add_child(calc());
-    if(node.get_children()[0].get_type()==ast_id && node.get_children()[1].get_type()==ast_multi_scalar)
-        die(node.get_children()[1].get_line(),"one identifier cannot accept too many values");
-    else if(node.get_children()[0].get_type()==ast_multi_id && node.get_children()[1].get_type()==ast_multi_scalar)
-        if(node.get_children()[0].get_children().size()!=node.get_children()[1].get_children().size())
-            die(node.get_children()[0].get_line(),"too much or lack values in multi-definition");
-    return node;
-}
-nasal_ast nasal_parse::var_incurve_def()
-{
-    match(tok_lcurve);
-    match(tok_var);
-    nasal_ast node=multi_id();
-    match(tok_rcurve);
-    return node;
-}
-nasal_ast nasal_parse::var_outcurve_def()
-{
-    match(tok_lcurve);
-    nasal_ast node=multi_id();
-    match(tok_rcurve);
-    return node;
-}
-nasal_ast nasal_parse::multi_id()
-{
-    nasal_ast node(tok_list[ptr].line,ast_multi_id);
-    while(tok_list[ptr].type!=tok_eof)
-    {
-        node.add_child(id_gen());
-        match(tok_id);
-        if(is_call(tok_list[ptr].type))
-        {
-            call_scalar();// recognize calls but this is still a syntax error
-            die(error_line,"cannot call identifier in multi-definition");
-        }
-        if(tok_list[ptr].type==tok_comma)
-            match(tok_comma);
-        else if(tok_list[ptr].type==tok_id)// first set of identifier
-            die(error_line,"expected \',\' between identifiers");
-        else
-            break;
-    }
-    return node;
-}
-nasal_ast nasal_parse::multi_scalar(bool check_call_memory)
-{
-    // if check_call_memory is true,we will check if value called here can reach a memory space
-    const int panic_set[]={tok_id,tok_str,tok_num,tok_not,tok_sub,tok_nil,tok_func,tok_var,tok_lcurve,tok_lbrace,tok_lbracket,tok_null};
-    nasal_ast node(tok_list[ptr].line,ast_multi_scalar);
-    match(tok_lcurve);
-    while(tok_list[ptr].type!=tok_rcurve)
-    {
-        node.add_child(calc());
-        if(check_call_memory)
-            check_memory_reachable(node.get_children().back());
-        if(tok_list[ptr].type==tok_comma)
-            match(tok_comma);
-        else if(tok_list[ptr].type==tok_eof)
-            break;
-        else if(tok_list[ptr].type!=tok_rcurve && !check_comma(panic_set))
-            break;
-    }
-    match(tok_rcurve,"expected \')\' after multi-scalar");
-    return node;
-}
-nasal_ast nasal_parse::multi_assgin()
-{
-    nasal_ast node(tok_list[ptr].line,ast_multi_assign);
-    node.add_child(multi_scalar(true));
-    match(tok_eq);
-    if(tok_list[ptr].type==tok_eof)
-    {
-        die(error_line,"expected value list");
-        return node;
-    }
-    if(tok_list[ptr].type==tok_lcurve)
-        node.add_child(check_multi_scalar()?multi_scalar(false):calc());
-    else
-        node.add_child(calc());
-    if(node.get_children()[1].get_type()==ast_multi_scalar
-        && node.get_children()[0].get_children().size()!=node.get_children()[1].get_children().size())
-        die(node.get_children()[0].get_line(),"too much or lack values in multi-assignment");
-    return node;
-}
-nasal_ast nasal_parse::loop()
-{
-    ++in_loop;
-    nasal_ast node;
-    switch(tok_list[ptr].type)
-    {
-        case tok_while:   node=while_loop(); break;
-        case tok_for:     node=for_loop();   break;
-        case tok_forindex:
-        case tok_foreach: node=forei_loop(); break;
-    }
-    --in_loop;
-    return node;
-}
-nasal_ast nasal_parse::while_loop()
-{
-    nasal_ast node(tok_list[ptr].line,ast_while);
-    match(tok_while);
-    match(tok_lcurve);
-    node.add_child(calc());
-    match(tok_rcurve);
-    node.add_child(exprs());
-    return node;
-}
-nasal_ast nasal_parse::for_loop()
-{
-    nasal_ast node(tok_list[ptr].line,ast_for);
-    match(tok_for);
-    match(tok_lcurve);
-    // first expression
-    if(tok_list[ptr].type==tok_eof)
-        die(error_line,"expected definition");
-    if(tok_list[ptr].type==tok_semi)
-        node.add_child(null_node_gen());
-    else if(tok_list[ptr].type==tok_var)
-        node.add_child(definition());
-    else if(tok_list[ptr].type==tok_lcurve)
-        node.add_child(lcurve_expr());
-    else
-        node.add_child(calc());
-    // check first semi
-    match(tok_semi,"expected \';\' in for(;;)");
-    // conditional expression
-    if(tok_list[ptr].type==tok_eof)
-        die(error_line,"expected conditional expr");
-    if(tok_list[ptr].type==tok_semi)
-        node.add_child(null_node_gen());
-    else
-        node.add_child(calc());
-    // check second semi
-    match(tok_semi,"expected \';\' in for(;;)");
-    //after loop expression
-    if(tok_list[ptr].type==tok_eof)
-        die(error_line,"expected calculation");
-    if(tok_list[ptr].type==tok_rcurve)
-        node.add_child(null_node_gen());
-    else
-        node.add_child(calc());
-    match(tok_rcurve);
-    node.add_child(exprs());
-    return node;
-}
-nasal_ast nasal_parse::forei_loop()
-{
-    nasal_ast node(tok_list[ptr].line,ast_null);
-    switch(tok_list[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;
-    }
-    match(tok_lcurve);
-    // first expression
-    // foreach/forindex must have an iterator to loop through
-    if(tok_list[ptr].type!=tok_var && tok_list[ptr].type!=tok_id)
-        die(error_line,"expected iterator");
-    node.add_child(new_iter_gen());
-    // check semi
-    match(tok_semi,"expected \';\' in foreach/forindex(iter;vector)");
-    // check vector
-    if(tok_list[ptr].type==tok_eof)
-        die(error_line,"expected vector");
-    node.add_child(calc());
-    match(tok_rcurve);
-    node.add_child(exprs());
-    return node;
-}
-nasal_ast nasal_parse::new_iter_gen()
-{
-    nasal_ast node(tok_list[ptr].line,ast_null);
-    if(tok_list[ptr].type==tok_var)
-    {
-        match(tok_var);
-        node.set_type(ast_new_iter);
-        node.add_child(id_gen());
-        match(tok_id);
-    }
-    else
-    {
-        node.set_type(ast_call);
-        node.add_child(id_gen());
-        match(tok_id);
-        while(is_call(tok_list[ptr].type))
-            node.add_child(call_scalar());
-    }
-    return node;
-}
-nasal_ast nasal_parse::conditional()
-{
-    nasal_ast node(tok_list[ptr].line,ast_conditional);
-    nasal_ast tmp(tok_list[ptr].line,ast_if);
-    match(tok_if);
-    match(tok_lcurve);
-    tmp.add_child(calc());
-    match(tok_rcurve);
-    tmp.add_child(exprs());
-    node.add_child(std::move(tmp));
-    // end of if-expression
-    while(tok_list[ptr].type==tok_elsif)
-    {
-        nasal_ast tmp(tok_list[ptr].line,ast_elsif);
-        match(tok_elsif);
-        match(tok_lcurve);
-        tmp.add_child(calc());
-        match(tok_rcurve);
-        tmp.add_child(exprs());
-        node.add_child(std::move(tmp));
-    }
-    if(tok_list[ptr].type==tok_else)
-    {
-        nasal_ast tmp(tok_list[ptr].line,ast_else);
-        match(tok_else);
-        tmp.add_child(exprs());
-        node.add_child(std::move(tmp));
-    }
-    return node;
-}
-nasal_ast nasal_parse::continue_expr()
-{
-    nasal_ast node(tok_list[ptr].line,ast_continue);
-    match(tok_continue);
-    return node;
-}
-nasal_ast nasal_parse::break_expr()
-{
-    nasal_ast node(tok_list[ptr].line,ast_break);
-    match(tok_break);
-    return node;
-}
-nasal_ast nasal_parse::ret_expr()
-{
-    nasal_ast node(tok_list[ptr].line,ast_ret);
-    match(tok_ret);
-    int type=tok_list[ptr].type;
-    if(type==tok_nil || type==tok_num || type==tok_str || type==tok_id || type==tok_func ||
-    type==tok_sub || type==tok_not || type==tok_lcurve || type==tok_lbracket || type==tok_lbrace)
-        node.add_child(calc());
-    return node;
-}
-#endif
+#ifndef __NASAL_PARSE_H__
+#define __NASAL_PARSE_H__
+
+/*
+              _,,,_                                       
+            .'     `'.                                    
+           /     ____ \      Fucking Nasal Parser
+           |  .-'_  _\/    /                              
+           \_/   a  a|    /                               
+           (,`     \ |         .----.                     
+            |     -' |        /|     '--.                 
+             \   '=  /        ||    ]|   `-.              
+             /`-.__.'         ||    ]|    ::|             
+          .-'`-.__ \__        ||    ]|    ::|             
+         /        ``  `.      ||    ]|    ::|             
+       _ |     \     \  \     \|    ]|   .-'              
+      / \|      \    |   \     L.__  .--'(                
+     |   |\      `.  |    \  ,---|_      \---------,      
+     |   | '.      './\    \/ .--._|=-    |_      /|      
+     |   \   '.     `'.'. /`\/ .-'          '.   / |      
+     |   |     `'.     `;-:-;`)|             |-./  |      
+     |   /_       `'--./_  ` )/'-------------')/)  |      
+     \   | `""""----"`\//`""`/,===..'`````````/ (  |      
+      |  |            / `---` `==='          /   ) |      
+      /  \           /                      /   (  |      
+     |    '------.  |'--------------------'|     ) |      
+      \           `-|                      |    /  |      
+       `--...,______|                      |   (   |      
+              | |   |                      |    ) ,|      
+              | |   |                      |   ( /||      
+              | |   |                      |   )/ `"      
+             /   \  |                      |  (/          
+           .' /I\ '.|                      |  /)          
+        .-'_.'/ \'. |                      | /            
+        ```  `"""` `| .-------------------.||             
+                    `"`                   `"`             
+*/
+
+class nasal_parse
+{
+#define error_line (tok_list[ptr].line)
+#define is_call(type) ((type)==tok_lcurve || (type)==tok_lbracket || (type)==tok_dot)
+private:
+    int ptr;
+    uint32_t error;
+    nasal_ast root;
+    std::vector<token> tok_list;
+    std::vector<token> error_token;
+    int in_function; // count when generating function block,used to check return-expression
+    int in_loop;     // count when generating loop block,used to check break/continue-expression
+    void die(int,const std::string&&);
+    void die(int,const char*);
+    void match(int type,const char* err_info="");
+    bool check_comma(const int*);
+    bool check_multi_scalar();
+    bool check_function_end(const nasal_ast&);
+    bool check_special_call();
+    bool need_semi_check(const nasal_ast&);
+    void check_memory_reachable(const nasal_ast&);
+    nasal_ast null_node_gen();
+    nasal_ast nil_gen();
+    nasal_ast num_gen();
+    nasal_ast str_gen();
+    nasal_ast id_gen();
+    nasal_ast vec_gen();
+    nasal_ast hash_gen();
+    nasal_ast hmem_gen();
+    nasal_ast func_gen();
+    nasal_ast args_gen();
+    nasal_ast lcurve_expr();
+    nasal_ast expr();
+    nasal_ast exprs();
+    nasal_ast calc();
+    nasal_ast or_expr();
+    nasal_ast and_expr();
+    nasal_ast cmp_expr();
+    nasal_ast additive_expr();
+    nasal_ast multive_expr();
+    nasal_ast unary();
+    nasal_ast scalar();
+    nasal_ast call_scalar();
+    nasal_ast callh();
+    nasal_ast callv();
+    nasal_ast callf();
+    nasal_ast subvec();
+    nasal_ast definition();
+    nasal_ast var_incurve_def();
+    nasal_ast var_outcurve_def();
+    nasal_ast multi_id();
+    nasal_ast multi_scalar(bool);
+    nasal_ast multi_assgin();
+    nasal_ast loop();
+    nasal_ast while_loop();
+    nasal_ast for_loop();
+    nasal_ast forei_loop();
+    nasal_ast new_iter_gen();
+    nasal_ast conditional();
+    nasal_ast continue_expr();
+    nasal_ast break_expr();
+    nasal_ast ret_expr();
+public:
+    uint32_t   err(){return error;}
+    void       compile(const std::vector<token>&);
+    nasal_ast& ast(){return root;}
+};
+void nasal_parse::compile(const std::vector<token>& toks)
+{
+    tok_list=toks;
+    ptr=in_function=in_loop=error=0;
+    root.clear();
+    error_token.clear();
+
+    root.set_line(1);
+    root.set_type(ast_root);
+    while(tok_list[ptr].type!=tok_eof)
+    {
+        int err_tok_size=error_token.size();
+        root.add_child(expr());
+        if(tok_list[ptr].type==tok_semi)
+            match(tok_semi);
+        // if detect error token, avoid checking semicolon
+        else if(error_token.size()>err_tok_size)
+            continue;
+        // the last expression can be recognized without semi
+        else if(need_semi_check(root.get_children().back()) && tok_list[ptr].type!=tok_eof)
+            die(error_line,"expected \";\"");
+    }
+    if(!error_token.size())
+        return;
+    ++error;
+    std::cout<<"[parse] line";
+    int err_line=0;
+    for(auto& tok:error_token)
+        if(err_line!=tok.line)
+        {
+            std::cout<<' '<<tok.line;
+            err_line=tok.line;
+        }
+    std::cout
+    <<" have fatal syntax errors."
+    <<"check \'(\',\'[\',\'{\',\')\',\']\',\'}\' match or not.\n";
+    return;
+}
+void nasal_parse::die(int line,const std::string&& info)
+{
+    ++error;
+    std::cout<<"[parse] line "<<line<<": "<<info<<".\n";
+}
+void nasal_parse::die(int line,const char* info)
+{
+    ++error;
+    std::cout<<"[parse] line "<<line<<": "<<info<<".\n";
+}
+void nasal_parse::match(int type,const char* err_info)
+{
+    if(tok_list[ptr].type!=type)
+    {
+        if(err_info[0])
+        {
+            die(error_line,err_info);
+            return;
+        }
+        switch(type)
+        {
+            case tok_num:die(error_line,"expected number");    break;
+            case tok_str:die(error_line,"expected string");    break;
+            case tok_id: die(error_line,"expected identifier");break;
+            default:     die(error_line,"expected \'"+std::string(token_table[type-tok_for].str)+"\'"); break;
+        }
+        return;
+    }
+    if(tok_list[ptr].type==tok_eof)
+        return;
+    ++ptr;
+    return;
+}
+bool nasal_parse::check_comma(const int* panic_set)
+{
+    for(int i=0;panic_set[i];++i)
+        if(tok_list[ptr].type==panic_set[i])
+        {
+            die(error_line,"expected \',\' between scalars");
+            return true;
+        }
+    return false;
+}
+bool nasal_parse::check_multi_scalar()
+{
+    int check_ptr=ptr,curve_cnt=1,bracket_cnt=0,brace_cnt=0;
+    while(tok_list[++check_ptr].type!=tok_eof && curve_cnt)
+    {
+        switch(tok_list[check_ptr].type)
+        {
+            case tok_lcurve:   ++curve_cnt;   break;
+            case tok_lbracket: ++bracket_cnt; break;
+            case tok_lbrace:   ++brace_cnt;   break;
+            case tok_rcurve:   --curve_cnt;   break;
+            case tok_rbracket: --bracket_cnt; break;
+            case tok_rbrace:   --brace_cnt;   break;
+        }
+        if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_comma)
+            return true;
+    }
+    return false;
+}
+bool nasal_parse::check_function_end(const nasal_ast& node)
+{
+    int type=node.get_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.get_children().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_function_end(node.get_children().back());
+    return false;
+}
+bool nasal_parse::check_special_call()
+{
+    // special call means like this:
+    // function_name(a:1,b:2,c:3);
+    int check_ptr=ptr,curve_cnt=1,bracket_cnt=0,brace_cnt=0,ques_cnt=0;
+    while(tok_list[++check_ptr].type!=tok_eof && curve_cnt)
+    {
+        switch(tok_list[check_ptr].type)
+        {
+            case tok_lcurve:   ++curve_cnt;  break;
+            case tok_lbracket: ++bracket_cnt;break;
+            case tok_lbrace:   ++brace_cnt;  break;
+            case tok_rcurve:   --curve_cnt;  break;
+            case tok_rbracket: --bracket_cnt;break;
+            case tok_rbrace:   --brace_cnt;  break;
+        }
+        // m?1:0 will be recognized as normal parameter
+        if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_quesmark)
+            return false;
+        if(curve_cnt==1 && !bracket_cnt && !brace_cnt && tok_list[check_ptr].type==tok_colon)
+            return true;
+    }
+    return false;
+}
+bool nasal_parse::need_semi_check(const nasal_ast& node)
+{
+    int type=node.get_type();
+    if(type==ast_for || type==ast_foreach || type==ast_forindex || type==ast_while || type==ast_conditional)
+        return false;
+    return !check_function_end(node);
+}
+void nasal_parse::check_memory_reachable(const nasal_ast& node)
+{
+    if(node.get_type()==ast_call)
+    {
+        const nasal_ast& tmp=node.get_children().back();
+        if(tmp.get_type()==ast_callf)
+            die(tmp.get_line(),"bad left-value");
+        if(tmp.get_type()==ast_callv && (tmp.get_children().size()>1 || tmp.get_children()[0].get_type()==ast_subvec))
+            die(tmp.get_line(),"bad left-value");
+    }
+    else if(node.get_type()!=ast_id)
+        die(node.get_line(),"bad left-value");
+    return;
+}
+nasal_ast nasal_parse::null_node_gen()
+{
+    return nasal_ast(tok_list[ptr].line,ast_null);
+}
+nasal_ast nasal_parse::nil_gen()
+{
+    return nasal_ast(tok_list[ptr].line,ast_nil);
+}
+nasal_ast nasal_parse::num_gen()
+{
+    nasal_ast node(tok_list[ptr].line,ast_num);
+    node.set_num(str2num(tok_list[ptr].str.c_str()));
+    return node;
+}
+nasal_ast nasal_parse::str_gen()
+{
+    nasal_ast node(tok_list[ptr].line,ast_str);
+    node.set_str(tok_list[ptr].str);
+    return node;
+}
+nasal_ast nasal_parse::id_gen()
+{
+    nasal_ast node(tok_list[ptr].line,ast_id);
+    node.set_str(tok_list[ptr].str);
+    return node;
+}
+nasal_ast nasal_parse::vec_gen()
+{
+    // panic set for this token is not ','
+    // this is the FIRST set of calculation
+    // array end with tok_null=0
+    const int panic_set[]={tok_id,tok_str,tok_num,tok_not,tok_sub,tok_nil,tok_func,tok_var,tok_lcurve,tok_lbrace,tok_lbracket,tok_null};
+    nasal_ast node(tok_list[ptr].line,ast_vec);
+    match(tok_lbracket);
+    while(tok_list[ptr].type!=tok_rbracket)
+    {
+        node.add_child(calc());
+        if(tok_list[ptr].type==tok_comma)
+            match(tok_comma);
+        else if(tok_list[ptr].type==tok_eof)
+            break;
+        else if(tok_list[ptr].type!=tok_rbracket && !check_comma(panic_set))
+            break;
+    }
+    match(tok_rbracket,"expected \']\' when generating vector");
+    return node;
+}
+nasal_ast nasal_parse::hash_gen()
+{
+    nasal_ast node(tok_list[ptr].line,ast_hash);
+    match(tok_lbrace);
+    while(tok_list[ptr].type!=tok_rbrace)
+    {
+        node.add_child(hmem_gen());
+        if(tok_list[ptr].type==tok_comma)
+            match(tok_comma);
+        else if(tok_list[ptr].type==tok_id || tok_list[ptr].type==tok_str)// first set of hashmember
+            die(error_line,"expected \',\' between hash members");
+        else
+            break;
+    }
+    match(tok_rbrace,"expected \'}\' when generating hash");
+    return node;
+}
+nasal_ast nasal_parse::hmem_gen()
+{
+    nasal_ast node(tok_list[ptr].line,ast_hashmember);
+    if(tok_list[ptr].type==tok_id)
+    {
+        node.add_child(id_gen());
+        match(tok_id);
+    }
+    else if(tok_list[ptr].type==tok_str)
+    {
+        node.add_child(str_gen());
+        match(tok_str);
+    }
+    else
+        match(tok_id);
+    match(tok_colon);
+    node.add_child(calc());
+    return node;
+}
+nasal_ast nasal_parse::func_gen()
+{
+    nasal_ast node(tok_list[ptr].line,ast_func);
+    match(tok_func);
+    if(tok_list[ptr].type==tok_lcurve)
+        node.add_child(args_gen());
+    else
+        node.add_child(null_node_gen());
+    node.add_child(exprs());
+    return node;
+}
+nasal_ast nasal_parse::args_gen()
+{
+    nasal_ast node(tok_list[ptr].line,ast_args);
+    match(tok_lcurve);
+    while(tok_list[ptr].type!=tok_rcurve)
+    {
+        nasal_ast tmp=id_gen();
+        match(tok_id);
+        if(tok_list[ptr].type==tok_eq || tok_list[ptr].type==tok_ellipsis)
+        {
+            nasal_ast special_arg(tok_list[ptr].line,ast_null);
+            if(tok_list[ptr].type==tok_eq)
+            {
+                match(tok_eq);
+                special_arg=std::move(tmp);
+                special_arg.set_type(ast_default_arg);
+                special_arg.add_child(calc());
+            }
+            else
+            {
+                match(tok_ellipsis);
+                special_arg=std::move(tmp);
+                special_arg.set_type(ast_dynamic_id);
+            }
+            node.add_child(std::move(special_arg));
+        }
+        else
+            node.add_child(std::move(tmp));
+        if(tok_list[ptr].type==tok_comma)
+            match(tok_comma);
+        else if(tok_list[ptr].type==tok_id)// first set of identifier
+            die(error_line,"expected \',\' between identifiers");
+        else
+            break;
+    }
+    match(tok_rcurve,"expected \')\' after parameter list");
+
+    std::string args_format="func(";
+    for(auto& tmp:node.get_children())
+    {
+        switch(tmp.get_type())
+        {
+            case ast_id:          args_format+=tmp.get_str();break;
+            case ast_default_arg: args_format+=tmp.get_str()+"=val";break;
+            case ast_dynamic_id:  args_format+=tmp.get_str()+"...";break;
+        }
+        args_format+=",)"[&tmp==&node.get_children().back()];
+    }
+    bool checked_default_val=false,checked_dynamic_ids=false;
+    for(auto& tmp:node.get_children())
+    {
+        if(tmp.get_type()==ast_default_arg)
+            checked_default_val=true;
+        else if(tmp.get_type()==ast_dynamic_id)
+            checked_dynamic_ids=true;
+        if(checked_default_val && tmp.get_type()!=ast_default_arg)
+            die(tmp.get_line(),"must use default paras after using it once: "+args_format);
+        if(checked_dynamic_ids && &tmp!=&node.get_children().back())
+            die(tmp.get_line(),"dynamic para must be the end: "+args_format);
+    }
+    std::unordered_map<std::string,bool> argname_table;
+    for(auto& tmp:node.get_children())
+    {
+        std::string new_name;
+        switch(tmp.get_type())
+        {
+            case ast_dynamic_id:
+            case ast_id:         new_name=tmp.get_str();break;
+            case ast_default_arg:new_name=tmp.get_str();break;
+        }
+        if(argname_table.count(new_name))
+            die(tmp.get_line(),"parameter's name repeats: "+new_name);
+        else
+            argname_table[new_name]=true;
+    }
+    return node;
+}
+nasal_ast nasal_parse::lcurve_expr()
+{
+    if(tok_list[ptr+1].type==tok_var)
+        return definition();
+    return check_multi_scalar()?multi_assgin():calc();
+}
+nasal_ast nasal_parse::expr()
+{
+    nasal_ast node(tok_list[ptr].line,ast_null);
+    int tok_type=tok_list[ptr].type;
+    if((tok_type==tok_break || tok_type==tok_continue) && !in_loop)
+        die(error_line,"use break/continue in the loop");
+    if(tok_type==tok_ret && !in_function)
+        die(error_line,"use return in the function");
+    switch(tok_type)
+    {
+        case tok_nil:
+        case tok_num:
+        case tok_str:
+        case tok_id:
+        case tok_func:
+        case tok_lbracket:
+        case tok_lbrace:
+        case tok_sub:
+        case tok_not:      node=calc();          break;
+        case tok_var:      node=definition();    break;
+        case tok_lcurve:   node=lcurve_expr();   break;
+        case tok_for:
+        case tok_forindex:
+        case tok_foreach:
+        case tok_while:    node=loop();          break;
+        case tok_if:       node=conditional();   break;
+        case tok_continue: node=continue_expr(); break;
+        case tok_break:    node=break_expr();    break;
+        case tok_ret:      node=ret_expr();      break;
+        case tok_semi:                           break;
+        default:error_token.push_back(tok_list[ptr]);++ptr;break;
+    }
+    return node;
+}
+nasal_ast nasal_parse::exprs()
+{
+    if(tok_list[ptr].type==tok_eof)
+    {
+        die(error_line,"expected expression block");
+        return null_node_gen();
+    }
+    nasal_ast node(tok_list[ptr].line,ast_block);
+    if(tok_list[ptr].type==tok_lbrace)
+    {
+        match(tok_lbrace);
+        while(tok_list[ptr].type!=tok_rbrace && tok_list[ptr].type!=tok_eof)
+        {
+            int err_tok_size=error_token.size();
+            node.add_child(expr());
+            if(tok_list[ptr].type==tok_semi)
+                match(tok_semi);
+            // if detect error token, avoid checking semicolon
+            else if(error_token.size()>err_tok_size)
+                continue;
+            // the last expression can be recognized without semi
+            else if(need_semi_check(node.get_children().back()) && tok_list[ptr].type!=tok_rbrace)
+                die(error_line,"expected \";\"");
+        }
+        match(tok_rbrace,"expected \'}\' when generating expressions");
+    }
+    else
+    {
+        node.add_child(expr());
+        if(tok_list[ptr].type==tok_semi)
+            match(tok_semi);
+    }
+    return node;
+}
+nasal_ast nasal_parse::calc()
+{
+    nasal_ast node=or_expr();
+    if(tok_list[ptr].type==tok_quesmark)
+    {
+        // trinocular calculation
+        nasal_ast tmp(tok_list[ptr].line,ast_trino);
+        match(tok_quesmark);
+        tmp.add_child(std::move(node));
+        tmp.add_child(calc());
+        match(tok_colon);
+        tmp.add_child(calc());
+        node=std::move(tmp);
+    }
+    else if(tok_eq<=tok_list[ptr].type && tok_list[ptr].type<=tok_lnkeq)
+    {
+        check_memory_reachable(node);
+        // tok_eq~tok_lnkeq is 37 to 42,ast_equal~ast_lnkeq is 21~26
+        nasal_ast tmp(tok_list[ptr].line,tok_list[ptr].type-tok_eq+ast_equal);
+        tmp.add_child(std::move(node));
+        match(tok_list[ptr].type);
+        tmp.add_child(calc());
+        node=std::move(tmp);
+    }
+    return node;
+}
+nasal_ast nasal_parse::or_expr()
+{
+    nasal_ast node=and_expr();
+    while(tok_list[ptr].type==tok_or)
+    {
+        nasal_ast tmp(tok_list[ptr].line,ast_or);
+        tmp.add_child(std::move(node));
+        match(tok_or);
+        tmp.add_child(and_expr());
+        node=std::move(tmp);
+    }
+    return node;
+}
+nasal_ast nasal_parse::and_expr()
+{
+    nasal_ast node=cmp_expr();
+    while(tok_list[ptr].type==tok_and)
+    {
+        nasal_ast tmp(tok_list[ptr].line,ast_and);
+        tmp.add_child(std::move(node));
+        match(tok_and);
+        tmp.add_child(cmp_expr());
+        node=std::move(tmp);
+    }
+    return node;
+}
+nasal_ast nasal_parse::cmp_expr()
+{
+    nasal_ast node=additive_expr();
+    while(tok_cmpeq<=tok_list[ptr].type && tok_list[ptr].type<=tok_geq)
+    {
+        // tok_cmpeq~tok_geq is 43~48,ast_cmpeq~ast_geq is 27~32
+        nasal_ast tmp(tok_list[ptr].line,tok_list[ptr].type-tok_cmpeq+ast_cmpeq);
+        tmp.add_child(std::move(node));
+        match(tok_list[ptr].type);
+        tmp.add_child(additive_expr());
+        node=std::move(tmp);
+    }
+    return node;
+}
+nasal_ast nasal_parse::additive_expr()
+{
+    nasal_ast node=multive_expr();
+    while(tok_list[ptr].type==tok_add || tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_link)
+    {
+        nasal_ast tmp(tok_list[ptr].line,ast_null);
+        switch(tok_list[ptr].type)
+        {
+            case tok_add:  tmp.set_type(ast_add);  break;
+            case tok_sub:  tmp.set_type(ast_sub);  break;
+            case tok_link: tmp.set_type(ast_link); break;
+        }
+        tmp.add_child(std::move(node));
+        match(tok_list[ptr].type);
+        tmp.add_child(multive_expr());
+        node=std::move(tmp);
+    }
+    return node;
+}
+nasal_ast nasal_parse::multive_expr()
+{
+    nasal_ast node=(tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_not)?unary():scalar();
+    while(tok_list[ptr].type==tok_mult || tok_list[ptr].type==tok_div)
+    {
+        nasal_ast tmp(tok_list[ptr].line,tok_list[ptr].type-tok_mult+ast_mult);
+        tmp.add_child(std::move(node));
+        match(tok_list[ptr].type);
+        tmp.add_child((tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_not)?unary():scalar());
+        node=std::move(tmp);
+    }
+    return node;
+}
+nasal_ast nasal_parse::unary()
+{
+    nasal_ast node(tok_list[ptr].line,ast_null);
+    switch(tok_list[ptr].type)
+    {
+        case tok_sub:node.set_type(ast_neg);match(tok_sub);break;
+        case tok_not:node.set_type(ast_not);match(tok_not);break;
+    }
+    node.add_child((tok_list[ptr].type==tok_sub || tok_list[ptr].type==tok_not)?unary():scalar());
+    return node;
+}
+nasal_ast nasal_parse::scalar()
+{
+    nasal_ast node(tok_list[ptr].line,ast_null);
+    if(tok_list[ptr].type==tok_nil)     {node=nil_gen(); match(tok_nil);}
+    else if(tok_list[ptr].type==tok_num){node=num_gen(); match(tok_num);}
+    else if(tok_list[ptr].type==tok_str){node=str_gen(); match(tok_str);}
+    else if(tok_list[ptr].type==tok_id) {node=id_gen();  match(tok_id); }
+    else if(tok_list[ptr].type==tok_func)
+    {
+        ++in_function;
+        node=func_gen();
+        --in_function;
+    }
+    else if(tok_list[ptr].type==tok_lbracket)
+        node=vec_gen();
+    else if(tok_list[ptr].type==tok_lbrace)
+        node=hash_gen();
+    else if(tok_list[ptr].type==tok_lcurve)
+    {
+        match(tok_lcurve);
+        node=calc();
+        match(tok_rcurve);
+    }
+    else if(tok_list[ptr].type==tok_var)
+    {
+        match(tok_var);
+        node.set_type(ast_def);
+        node.add_child(id_gen());
+        match(tok_id);
+        match(tok_eq);
+        node.add_child(calc());
+    }
+    else
+    {
+        die(error_line,"expected scalar");
+        return node;
+    }
+    // check call and avoid ambiguous syntax
+    if(is_call(tok_list[ptr].type) && !(tok_list[ptr].type==tok_lcurve && tok_list[ptr+1].type==tok_var))
+    {
+        nasal_ast tmp=std::move(node);
+        node.set_line(tok_list[ptr].line);
+        node.set_type(ast_call);
+        node.add_child(std::move(tmp));
+        while(is_call(tok_list[ptr].type))
+            node.add_child(call_scalar());
+    }
+    return node;
+}
+nasal_ast nasal_parse::call_scalar()
+{
+    switch(tok_list[ptr].type)
+    {
+        case tok_lcurve:   return callf(); break;
+        case tok_lbracket: return callv(); break;
+        case tok_dot:      return callh(); break;
+    }
+    // should never run this expression
+    return nasal_ast(tok_list[ptr].line,ast_nil);
+}
+nasal_ast nasal_parse::callh()
+{
+    nasal_ast node(tok_list[ptr].line,ast_callh);
+    match(tok_dot);
+    node.set_str(tok_list[ptr].str);
+    match(tok_id);
+    return node;
+}
+nasal_ast nasal_parse::callv()
+{
+    // panic set for this token is not ','
+    // this is the FIRST set of subvec
+    // array end with tok_null=0
+    const int panic_set[]={tok_id,tok_str,tok_num,tok_not,tok_sub,tok_nil,tok_func,tok_var,tok_lcurve,tok_lbrace,tok_lbracket,tok_colon,tok_null};
+    nasal_ast node(tok_list[ptr].line,ast_callv);
+    match(tok_lbracket);
+    while(tok_list[ptr].type!=tok_rbracket)
+    {
+        node.add_child(subvec());
+        if(tok_list[ptr].type==tok_comma)
+            match(tok_comma);
+        else if(tok_list[ptr].type==tok_eof)
+            break;
+        else if(tok_list[ptr].type!=tok_rbracket && !check_comma(panic_set))
+            break;
+    }
+    match(tok_rbracket,"expected \']\' when calling vector");
+    return node;
+}
+nasal_ast nasal_parse::callf()
+{
+    // panic set for this token is not ','
+    // this is the FIRST set of calculation/hashmember
+    // array end with tok_null=0
+    const int panic_set[]={tok_id,tok_str,tok_num,tok_not,tok_sub,tok_nil,tok_func,tok_var,tok_lcurve,tok_lbrace,tok_lbracket,tok_null};
+    nasal_ast node(tok_list[ptr].line,ast_callf);
+    bool special_call=check_special_call();
+    match(tok_lcurve);
+    while(tok_list[ptr].type!=tok_rcurve)
+    {
+        node.add_child(special_call?hmem_gen():calc());
+        if(tok_list[ptr].type==tok_comma)
+            match(tok_comma);
+        else if(tok_list[ptr].type==tok_eof)
+            break;
+        else if(tok_list[ptr].type!=tok_rcurve && !check_comma(panic_set))
+            break;
+    }
+    match(tok_rcurve,"expected \')\' when calling function");
+    return node;
+}
+nasal_ast nasal_parse::subvec()
+{
+    nasal_ast node=tok_list[ptr].type==tok_colon?nil_gen():calc();
+    if(tok_list[ptr].type==tok_colon)
+    {
+        nasal_ast tmp(node.get_line(),ast_subvec);
+        match(tok_colon);
+        tmp.add_child(std::move(node));
+        tmp.add_child((tok_list[ptr].type==tok_comma || tok_list[ptr].type==tok_rbracket)?nil_gen():calc());
+        node=std::move(tmp);
+    }
+    return node;
+}
+nasal_ast nasal_parse::definition()
+{
+    nasal_ast node(tok_list[ptr].line,ast_def);
+    if(tok_list[ptr].type==tok_var)
+    {
+        match(tok_var);
+        switch(tok_list[ptr].type)
+        {
+            case tok_id:     node.add_child(id_gen());match(tok_id); break;
+            case tok_lcurve: node.add_child(var_outcurve_def());     break;
+            default:         die(error_line,"expected identifier");  break;
+        }
+    }
+    else if(tok_list[ptr].type==tok_lcurve)
+        node.add_child(var_incurve_def());
+    match(tok_eq);
+    if(tok_list[ptr].type==tok_lcurve)
+        node.add_child(check_multi_scalar()?multi_scalar(false):calc());
+    else
+        node.add_child(calc());
+    if(node.get_children()[0].get_type()==ast_id && node.get_children()[1].get_type()==ast_multi_scalar)
+        die(node.get_children()[1].get_line(),"one identifier cannot accept too many values");
+    else if(node.get_children()[0].get_type()==ast_multi_id && node.get_children()[1].get_type()==ast_multi_scalar)
+        if(node.get_children()[0].get_children().size()!=node.get_children()[1].get_children().size())
+            die(node.get_children()[0].get_line(),"too much or lack values in multi-definition");
+    return node;
+}
+nasal_ast nasal_parse::var_incurve_def()
+{
+    match(tok_lcurve);
+    match(tok_var);
+    nasal_ast node=multi_id();
+    match(tok_rcurve);
+    return node;
+}
+nasal_ast nasal_parse::var_outcurve_def()
+{
+    match(tok_lcurve);
+    nasal_ast node=multi_id();
+    match(tok_rcurve);
+    return node;
+}
+nasal_ast nasal_parse::multi_id()
+{
+    nasal_ast node(tok_list[ptr].line,ast_multi_id);
+    while(tok_list[ptr].type!=tok_eof)
+    {
+        node.add_child(id_gen());
+        match(tok_id);
+        if(is_call(tok_list[ptr].type))
+        {
+            call_scalar();// recognize calls but this is still a syntax error
+            die(error_line,"cannot call identifier in multi-definition");
+        }
+        if(tok_list[ptr].type==tok_comma)
+            match(tok_comma);
+        else if(tok_list[ptr].type==tok_id)// first set of identifier
+            die(error_line,"expected \',\' between identifiers");
+        else
+            break;
+    }
+    return node;
+}
+nasal_ast nasal_parse::multi_scalar(bool check_call_memory)
+{
+    // if check_call_memory is true,we will check if value called here can reach a memory space
+    const int panic_set[]={tok_id,tok_str,tok_num,tok_not,tok_sub,tok_nil,tok_func,tok_var,tok_lcurve,tok_lbrace,tok_lbracket,tok_null};
+    nasal_ast node(tok_list[ptr].line,ast_multi_scalar);
+    match(tok_lcurve);
+    while(tok_list[ptr].type!=tok_rcurve)
+    {
+        node.add_child(calc());
+        if(check_call_memory)
+            check_memory_reachable(node.get_children().back());
+        if(tok_list[ptr].type==tok_comma)
+            match(tok_comma);
+        else if(tok_list[ptr].type==tok_eof)
+            break;
+        else if(tok_list[ptr].type!=tok_rcurve && !check_comma(panic_set))
+            break;
+    }
+    match(tok_rcurve,"expected \')\' after multi-scalar");
+    return node;
+}
+nasal_ast nasal_parse::multi_assgin()
+{
+    nasal_ast node(tok_list[ptr].line,ast_multi_assign);
+    node.add_child(multi_scalar(true));
+    match(tok_eq);
+    if(tok_list[ptr].type==tok_eof)
+    {
+        die(error_line,"expected value list");
+        return node;
+    }
+    if(tok_list[ptr].type==tok_lcurve)
+        node.add_child(check_multi_scalar()?multi_scalar(false):calc());
+    else
+        node.add_child(calc());
+    if(node.get_children()[1].get_type()==ast_multi_scalar
+        && node.get_children()[0].get_children().size()!=node.get_children()[1].get_children().size())
+        die(node.get_children()[0].get_line(),"too much or lack values in multi-assignment");
+    return node;
+}
+nasal_ast nasal_parse::loop()
+{
+    ++in_loop;
+    nasal_ast node;
+    switch(tok_list[ptr].type)
+    {
+        case tok_while:   node=while_loop(); break;
+        case tok_for:     node=for_loop();   break;
+        case tok_forindex:
+        case tok_foreach: node=forei_loop(); break;
+    }
+    --in_loop;
+    return node;
+}
+nasal_ast nasal_parse::while_loop()
+{
+    nasal_ast node(tok_list[ptr].line,ast_while);
+    match(tok_while);
+    match(tok_lcurve);
+    node.add_child(calc());
+    match(tok_rcurve);
+    node.add_child(exprs());
+    return node;
+}
+nasal_ast nasal_parse::for_loop()
+{
+    nasal_ast node(tok_list[ptr].line,ast_for);
+    match(tok_for);
+    match(tok_lcurve);
+    // first expression
+    if(tok_list[ptr].type==tok_eof)
+        die(error_line,"expected definition");
+    if(tok_list[ptr].type==tok_semi)
+        node.add_child(null_node_gen());
+    else if(tok_list[ptr].type==tok_var)
+        node.add_child(definition());
+    else if(tok_list[ptr].type==tok_lcurve)
+        node.add_child(lcurve_expr());
+    else
+        node.add_child(calc());
+    // check first semi
+    match(tok_semi,"expected \';\' in for(;;)");
+    // conditional expression
+    if(tok_list[ptr].type==tok_eof)
+        die(error_line,"expected conditional expr");
+    if(tok_list[ptr].type==tok_semi)
+        node.add_child(null_node_gen());
+    else
+        node.add_child(calc());
+    // check second semi
+    match(tok_semi,"expected \';\' in for(;;)");
+    //after loop expression
+    if(tok_list[ptr].type==tok_eof)
+        die(error_line,"expected calculation");
+    if(tok_list[ptr].type==tok_rcurve)
+        node.add_child(null_node_gen());
+    else
+        node.add_child(calc());
+    match(tok_rcurve);
+    node.add_child(exprs());
+    return node;
+}
+nasal_ast nasal_parse::forei_loop()
+{
+    nasal_ast node(tok_list[ptr].line,ast_null);
+    switch(tok_list[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;
+    }
+    match(tok_lcurve);
+    // first expression
+    // foreach/forindex must have an iterator to loop through
+    if(tok_list[ptr].type!=tok_var && tok_list[ptr].type!=tok_id)
+        die(error_line,"expected iterator");
+    node.add_child(new_iter_gen());
+    // check semi
+    match(tok_semi,"expected \';\' in foreach/forindex(iter;vector)");
+    // check vector
+    if(tok_list[ptr].type==tok_eof)
+        die(error_line,"expected vector");
+    node.add_child(calc());
+    match(tok_rcurve);
+    node.add_child(exprs());
+    return node;
+}
+nasal_ast nasal_parse::new_iter_gen()
+{
+    nasal_ast node(tok_list[ptr].line,ast_null);
+    if(tok_list[ptr].type==tok_var)
+    {
+        match(tok_var);
+        node.set_type(ast_new_iter);
+        node.add_child(id_gen());
+        match(tok_id);
+    }
+    else
+    {
+        node.set_type(ast_call);
+        node.add_child(id_gen());
+        match(tok_id);
+        while(is_call(tok_list[ptr].type))
+            node.add_child(call_scalar());
+    }
+    return node;
+}
+nasal_ast nasal_parse::conditional()
+{
+    nasal_ast node(tok_list[ptr].line,ast_conditional);
+    nasal_ast tmp(tok_list[ptr].line,ast_if);
+    match(tok_if);
+    match(tok_lcurve);
+    tmp.add_child(calc());
+    match(tok_rcurve);
+    tmp.add_child(exprs());
+    node.add_child(std::move(tmp));
+    // end of if-expression
+    while(tok_list[ptr].type==tok_elsif)
+    {
+        nasal_ast tmp(tok_list[ptr].line,ast_elsif);
+        match(tok_elsif);
+        match(tok_lcurve);
+        tmp.add_child(calc());
+        match(tok_rcurve);
+        tmp.add_child(exprs());
+        node.add_child(std::move(tmp));
+    }
+    if(tok_list[ptr].type==tok_else)
+    {
+        nasal_ast tmp(tok_list[ptr].line,ast_else);
+        match(tok_else);
+        tmp.add_child(exprs());
+        node.add_child(std::move(tmp));
+    }
+    return node;
+}
+nasal_ast nasal_parse::continue_expr()
+{
+    nasal_ast node(tok_list[ptr].line,ast_continue);
+    match(tok_continue);
+    return node;
+}
+nasal_ast nasal_parse::break_expr()
+{
+    nasal_ast node(tok_list[ptr].line,ast_break);
+    match(tok_break);
+    return node;
+}
+nasal_ast nasal_parse::ret_expr()
+{
+    nasal_ast node(tok_list[ptr].line,ast_ret);
+    match(tok_ret);
+    int type=tok_list[ptr].type;
+    if(type==tok_nil || type==tok_num || type==tok_str || type==tok_id || type==tok_func ||
+    type==tok_sub || type==tok_not || type==tok_lcurve || type==tok_lbracket || type==tok_lbrace)
+        node.add_child(calc());
+    return node;
+}
+#endif