xxq250
/
Nasal-Interpreter
mirror of https://github.com/ValKmjolnir/Nasal-Interpreter.git
1
0
Fork 0
Code Issues Actions 1 Packages Projects Releases Wiki Activity

📝 change some identifiers' name.

This commit is contained in:
ValKmjolnir 2022-07-08 18:16:00 +08:00
parent 5d4cff0aa8
commit 11e9567b55
4 changed files with 390 additions and 395 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
nasal.h
View File

@ -127,18 +127,17 @@ double str2num(const char* str)
return is_negative?-ret_num:ret_num;
}
int utf8_hdchk(char head)
int utf8_hdchk(const char head)
{
// RFC-2279 but now we use RFC-3629 so nbytes is less than 4
uint8_t c=(uint8_t)head;
uint32_t nbytes=0;
const uint8_t c=(uint8_t)head;
if((c>>5)==0x06) // 110x xxxx (10xx xxxx)^1
nbytes=1;
return 1;
if((c>>4)==0x0e) // 1110 xxxx (10xx xxxx)^2
nbytes=2;
return 2;
if((c>>3)==0x1e) // 1111 0xxx (10xx xxxx)^3
nbytes=3;
return nbytes;
return 3;
return 0;
}
std::string chrhex(const char c)

366
nasal_codegen.h
View File

@ -3,81 +3,81 @@
enum op_code
{
op_exit, // stop the virtual machine
op_intg, // global scope size
op_intl, // local scope size
op_loadg, // load global value
op_loadl, // load local value
op_loadu, // load upvalue
op_pnum, // push constant number to the stack
op_pnil, // push constant nil to the stack
op_pstr, // push constant string to the stack
op_newv, // push new vector with initial values from stack
op_newh, // push new hash to the stack
op_newf, // push new function to the stack
op_happ, // hash append
op_para, // normal parameter
op_defpara, // default parameter
op_dynpara, // dynamic parameter
op_unot, // !
op_usub, // -
op_add, // +
op_sub, // -
op_mul, // *
op_div, // /
op_lnk, // ~
op_addc, // + const
op_subc, // - const
op_mulc, // * const
op_divc, // / const
op_lnkc, // ~ const
op_addeq, // +=
op_subeq, // -=
op_muleq, // *=
op_diveq, // /=
op_lnkeq, // ~=
op_addeqc, // += const
op_subeqc, // -= const
op_muleqc, // *= const
op_diveqc, // /= const
op_lnkeqc, // ~= const
op_meq, // =
op_eq, // ==
op_neq, // !=
op_less, // <
op_leq, // <=
op_grt, // >
op_geq, // >=
op_lessc, // < const
op_leqc, // <= const
op_grtc, // > const
op_geqc, // >= const
op_pop, // pop a value from stack
op_jmp, // jump with no condition
op_jt, // used in operator and/or,jmp when condition is true and DO NOT POP
op_jf, // used in conditional/loop,jmp when condition is false and POP STACK
op_cnt, // add counter for forindex/foreach
op_findex, // index counter on the top of forindex_stack plus 1
op_feach, // index counter on the top of forindex_stack plus 1 and get the value in vector
op_callg, // get value in global scope
op_calll, // get value in local scope
op_upval, // get upvalue in closure
op_callv, // call vec[index]
op_callvi, // call vec[immediate] (used in multi-assign/multi-define)
op_callh, // call hash.label
op_callfv, // call function(vector as parameters)
op_callfh, // call function(hash as parameters)
op_callb, // call builtin-function
op_slcbegin,// begin of slice like: vec[1,2,3:6,0,-1]
op_slcend, // end of slice
op_slc, // slice like vec[1]
op_slc2, // slice like vec[nil:10]
op_mcallg, // get memory space of value in global scope
op_mcalll, // get memory space of value in local scope
op_mupval, // get memory space of value in closure
op_mcallv, // get memory space of vec[index]
op_mcallh, // get memory space of hash.label
op_ret // return
op_exit, // stop the virtual machine
op_intg, // global scope size
op_intl, // local scope size
op_loadg, // load global value
op_loadl, // load local value
op_loadu, // load upvalue
op_pnum, // push constant number to the stack
op_pnil, // push constant nil to the stack
op_pstr, // push constant string to the stack
op_newv, // push new vector with initial values from stack
op_newh, // push new hash to the stack
op_newf, // push new function to the stack
op_happ, // hash append
op_para, // normal parameter
op_deft, // default parameter
op_dyn, // dynamic parameter
op_unot, // !
op_usub, // -
op_add, // +
op_sub, // -
op_mul, // *
op_div, // /
op_lnk, // ~
op_addc, // + const
op_subc, // - const
op_mulc, // * const
op_divc, // / const
op_lnkc, // ~ const
op_addeq, // +=
op_subeq, // -=
op_muleq, // *=
op_diveq, // /=
op_lnkeq, // ~=
op_addeqc, // += const
op_subeqc, // -= const
op_muleqc, // *= const
op_diveqc, // /= const
op_lnkeqc, // ~= const
op_meq, // =
op_eq, // ==
op_neq, // !=
op_less, // <
op_leq, // <=
op_grt, // >
op_geq, // >=
op_lessc, // < const
op_leqc, // <= const
op_grtc, // > const
op_geqc, // >= const
op_pop, // pop a value from stack
op_jmp, // jump with no condition
op_jt, // used in operator and/or,jmp when condition is true and DO NOT POP
op_jf, // used in conditional/loop,jmp when condition is false and POP STACK
op_cnt, // add counter for forindex/foreach
op_findex, // index counter on the top of forindex_stack plus 1
op_feach, // index counter on the top of forindex_stack plus 1 and get the value in vector
op_callg, // get value in global scope
op_calll, // get value in local scope
op_upval, // get upvalue in closure
op_callv, // call vec[index]
op_callvi, // call vec[immediate] (used in multi-assign/multi-define)
op_callh, // call hash.label
op_callfv, // call function(vector as parameters)
op_callfh, // call function(hash as parameters)
op_callb, // call builtin-function
op_slcbeg, // begin of slice like: vec[1,2,3:6,0,-1]
op_slcend, // end of slice
op_slc, // slice like vec[1]
op_slc2, // slice like vec[nil:10]
op_mcallg, // get memory space of value in global scope
op_mcalll, // get memory space of value in local scope
op_mupval, // get memory space of value in closure
op_mcallv, // get memory space of vec[index]
op_mcallh, // get memory space of hash.label
op_ret // return
};
struct
@ -86,82 +86,82 @@ struct
const char* name;
}code_table[]=
{
{op_exit, "exit "},
{op_intg, "intg "},
{op_intl, "intl "},
{op_loadg, "loadg "},
{op_loadl, "loadl "},
{op_loadu, "loadu "},
{op_pnum, "pnum "},
{op_pnil, "pnil "},
{op_pstr, "pstr "},
{op_newv, "newv "},
{op_newh, "newh "},
{op_newf, "newf "},
{op_happ, "happ "},
{op_para, "para "},
{op_defpara, "def "},
{op_dynpara, "dyn "},
{op_unot, "not "},
{op_usub, "usub "},
{op_add, "add "},
{op_sub, "sub "},
{op_mul, "mult "},
{op_div, "div "},
{op_lnk, "lnk "},
{op_addc, "addc "},
{op_subc, "subc "},
{op_mulc, "multc "},
{op_divc, "divc "},
{op_lnkc, "lnkc "},
{op_addeq, "addeq "},
{op_subeq, "subeq "},
{op_muleq, "muleq "},
{op_diveq, "diveq "},
{op_lnkeq, "lnkeq "},
{op_addeqc, "addeqc"},
{op_subeqc, "subeqc"},
{op_muleqc, "muleqc"},
{op_diveqc, "diveqc"},
{op_lnkeqc, "lnkeqc"},
{op_meq, "meq "},
{op_eq, "eq "},
{op_neq, "neq "},
{op_less, "less "},
{op_leq, "leq "},
{op_grt, "grt "},
{op_geq, "geq "},
{op_lessc, "lessc "},
{op_leqc, "leqc "},
{op_grtc, "grtc "},
{op_geqc, "geqc "},
{op_pop, "pop "},
{op_jmp, "jmp "},
{op_jt, "jt "},
{op_jf, "jf "},
{op_cnt, "cnt "},
{op_findex, "findx "},
{op_feach, "feach "},
{op_callg, "callg "},
{op_calll, "calll "},
{op_upval, "upval "},
{op_callv, "callv "},
{op_callvi, "callvi"},
{op_callh, "callh "},
{op_callfv, "callfv"},
{op_callfh, "callfh"},
{op_callb, "callb "},
{op_slcbegin,"slcbeg"},
{op_slcend, "slcend"},
{op_slc, "slc "},
{op_slc2, "slc2 "},
{op_mcallg, "mcallg"},
{op_mcalll, "mcalll"},
{op_mupval, "mupval"},
{op_mcallv, "mcallv"},
{op_mcallh, "mcallh"},
{op_ret, "ret "},
{-1, nullptr },
{op_exit, "exit "},
{op_intg, "intg "},
{op_intl, "intl "},
{op_loadg, "loadg "},
{op_loadl, "loadl "},
{op_loadu, "loadu "},
{op_pnum, "pnum "},
{op_pnil, "pnil "},
{op_pstr, "pstr "},
{op_newv, "newv "},
{op_newh, "newh "},
{op_newf, "newf "},
{op_happ, "happ "},
{op_para, "para "},
{op_deft, "def "},
{op_dyn, "dyn "},
{op_unot, "not "},
{op_usub, "usub "},
{op_add, "add "},
{op_sub, "sub "},
{op_mul, "mult "},
{op_div, "div "},
{op_lnk, "lnk "},
{op_addc, "addc "},
{op_subc, "subc "},
{op_mulc, "multc "},
{op_divc, "divc "},
{op_lnkc, "lnkc "},
{op_addeq, "addeq "},
{op_subeq, "subeq "},
{op_muleq, "muleq "},
{op_diveq, "diveq "},
{op_lnkeq, "lnkeq "},
{op_addeqc, "addeqc"},
{op_subeqc, "subeqc"},
{op_muleqc, "muleqc"},
{op_diveqc, "diveqc"},
{op_lnkeqc, "lnkeqc"},
{op_meq, "meq "},
{op_eq, "eq "},
{op_neq, "neq "},
{op_less, "less "},
{op_leq, "leq "},
{op_grt, "grt "},
{op_geq, "geq "},
{op_lessc, "lessc "},
{op_leqc, "leqc "},
{op_grtc, "grtc "},
{op_geqc, "geqc "},
{op_pop, "pop "},
{op_jmp, "jmp "},
{op_jt, "jt "},
{op_jf, "jf "},
{op_cnt, "cnt "},
{op_findex, "findx "},
{op_feach, "feach "},
{op_callg, "callg "},
{op_calll, "calll "},
{op_upval, "upval "},
{op_callv, "callv "},
{op_callvi, "callvi"},
{op_callh, "callh "},
{op_callfv, "callfv"},
{op_callfh, "callfh"},
{op_callb, "callb "},
{op_slcbeg, "slcbeg"},
{op_slcend, "slcend"},
{op_slc, "slc "},
{op_slc2, "slc2 "},
{op_mcallg, "mcallg"},
{op_mcalll, "mcalll"},
{op_mupval, "mupval"},
{op_mcallv, "mcallv"},
{op_mcallh, "mcallh"},
{op_ret, "ret "},
{-1, nullptr },
};
struct opcode
@ -189,13 +189,13 @@ private:
nasal_err& nerr;
const std::string* file;
std::stack<uint32_t> in_iterloop;
std::unordered_map<double,int> num_table;
std::unordered_map<std::string,int> str_table;
std::vector<double> num_res;
std::vector<std::string> str_res;
std::vector<opcode> code;
std::list<std::vector<int>> continue_ptr;
std::list<std::vector<int>> break_ptr;
std::unordered_map<double,uint32_t> num_table;
std::unordered_map<std::string,uint32_t> str_table;
std::vector<double> num_res;
std::vector<std::string> str_res;
std::vector<opcode> code;
std::list<std::vector<int>> continue_ptr;
std::list<std::vector<int>> break_ptr;
// global : max 4095 values
std::unordered_map<std::string,int> global;
// local : max 32768 upvalues 65536 values
@ -206,8 +206,8 @@ private:
std::stack<uint32_t> festk;
void die(std::string,const uint32_t);
void regist_number(const double);
void regist_string(const std::string&);
void regist_num(const double);
void regist_str(const std::string&);
void find_symbol(const nasal_ast&);
void add_sym(const std::string&);
int local_find(const std::string&);
@ -261,21 +261,21 @@ void nasal_codegen::die(std::string info,const uint32_t line)
nerr.err("code",line,info);
}
void nasal_codegen::regist_number(const double num)
void nasal_codegen::regist_num(const double num)
{
int size=num_table.size();
if(!num_table.count(num))
{
uint32_t size=num_table.size();
num_table[num]=size;
num_res.push_back(num);
}
}
void nasal_codegen::regist_string(const std::string& str)
void nasal_codegen::regist_str(const std::string& str)
{
int size=str_table.size();
if(!str_table.count(str))
{
uint32_t size=str_table.size();
str_table[str]=size;
str_res.push_back(str);
}
@ -356,13 +356,13 @@ void nasal_codegen::gen(uint8_t op,uint32_t num,uint32_t line)
void nasal_codegen::num_gen(const nasal_ast& ast)
{
double num=ast.num();
regist_number(num);
regist_num(num);
gen(op_pnum,num_table[num],ast.line());
}
void nasal_codegen::str_gen(const nasal_ast& ast)
{
regist_string(ast.str());
regist_str(ast.str());
gen(op_pstr,str_table[ast.str()],ast.line());
}
@ -380,7 +380,7 @@ void nasal_codegen::hash_gen(const nasal_ast& ast)
{
calc_gen(node[1]);
const std::string& str=node[0].str();
regist_string(str);
regist_str(str);
gen(op_happ,str_table[str],node.line());
}
}
@ -405,15 +405,15 @@ void nasal_codegen::func_gen(const nasal_ast& ast)
const std::string& str=tmp.str();
if(str=="me")
die("\"me\" should not be a parameter",tmp.line());
regist_string(str);
regist_str(str);
switch(tmp.type())
{
case ast_id:gen(op_para,str_table[str],tmp.line());break;
case ast_default:
calc_gen(tmp[0]);
gen(op_defpara,str_table[str],tmp.line());
gen(op_deft,str_table[str],tmp.line());
break;
case ast_dynamic:gen(op_dynpara,str_table[str],tmp.line());break;
case ast_dynamic:gen(op_dyn,str_table[str],tmp.line());break;
}
add_sym(str);
}
@ -492,7 +492,7 @@ void nasal_codegen::call_id(const nasal_ast& ast)
void nasal_codegen::call_hash(const nasal_ast& ast)
{
regist_string(ast.str());
regist_str(ast.str());
gen(op_callh,str_table[ast.str()],ast.line());
}
@ -505,7 +505,7 @@ void nasal_codegen::call_vec(const nasal_ast& ast)
gen(op_callv,0,ast[0].line());
return;
}
gen(op_slcbegin,0,ast.line());
gen(op_slcbeg,0,ast.line());
for(auto& tmp:ast.child())
{
if(tmp.type()!=ast_subvec)
@ -614,7 +614,7 @@ void nasal_codegen::mcall_vec(const nasal_ast& ast)
void nasal_codegen::mcall_hash(const nasal_ast& ast)
{
regist_string(ast.str());
regist_str(ast.str());
gen(op_mcallh,str_table[ast.str()],ast.line());
}
@ -1041,7 +1041,7 @@ void nasal_codegen::calc_gen(const nasal_ast& ast)
gen(ast.type()-ast_addeq+op_addeq,0,ast.line());
else
{
regist_number(ast[1].num());
regist_num(ast[1].num());
gen(ast.type()-ast_addeq+op_addeqc,num_table[ast[1].num()],ast.line());
}
break;
@ -1049,7 +1049,7 @@ void nasal_codegen::calc_gen(const nasal_ast& ast)
if(ast[1].type()!=ast_str)
calc_gen(ast[1]);
else
regist_string(ast[1].str());
regist_str(ast[1].str());
mcall(ast[0]);
if(ast[1].type()!=ast_str)
gen(op_lnkeq,0,ast.line());
@ -1068,7 +1068,7 @@ void nasal_codegen::calc_gen(const nasal_ast& ast)
}
else
{
regist_number(ast[1].num());
regist_num(ast[1].num());
gen(ast.type()-ast_add+op_addc,num_table[ast[1].num()],ast.line());
}
break;
@ -1081,7 +1081,7 @@ void nasal_codegen::calc_gen(const nasal_ast& ast)
}
else
{
regist_string(ast[1].str());
regist_str(ast[1].str());
gen(op_lnkc,str_table[ast[1].str()],ast.line());
}
break;
@ -1100,7 +1100,7 @@ void nasal_codegen::calc_gen(const nasal_ast& ast)
}
else
{
regist_number(ast[1].num());
regist_num(ast[1].num());
gen(ast.type()-ast_less+op_lessc,num_table[ast[1].num()],ast.line());
}
break;
@ -1225,8 +1225,8 @@ void nasal_codegen::compile(const nasal_parse& parse,const nasal_import& import)
file=import.get_file().data();
in_iterloop.push(0);
regist_number(0);
regist_number(1);
regist_num(0);
regist_num(1);
find_symbol(parse.ast()); // search symbols first
gen(op_intg,global.size(),0);
@ -1299,7 +1299,7 @@ void nasal_codegen::print_op(uint32_t index)
case op_happ: case op_pstr:
case op_lnkc:
case op_callh: case op_mcallh:
case op_para: case op_defpara:case op_dynpara:
case op_para: case op_deft: case op_dyn:
printf("0x%x (\"%s\")\n",c.num,rawstr(str_res[c.num],16).c_str());break;
default:printf("\n");break;
}
@ -1308,11 +1308,11 @@ void nasal_codegen::print_op(uint32_t index)
void nasal_codegen::print()
{
for(auto& num:num_res)
std::cout<<" .number "<<num<<'\n';
std::cout<<" .number "<<num<<"\n";
for(auto& str:str_res)
std::cout<<" .symbol \""<<rawstr(str)<<"\"\n";
std::cout<<"\n";
for(uint32_t i=0;i<code.size();++i)
for(size_t i=0;i<code.size();++i)
print_op(i);
}

186
nasal_dbg.h
View File

@ -184,25 +184,25 @@ void nasal_dbg::run(
init(gen.get_strs(),gen.get_nums(),gen.get_code(),linker.get_file(),argv);
const void* oprs[]=
{
&&vmexit, &&intg, &&intl, &&loadg,
&&loadl, &&loadu, &&pnum, &&pnil,
&&pstr, &&newv, &&newh, &&newf,
&&happ, &&para, &&defpara,&&dynpara,
&&unot, &&usub, &&add, &&sub,
&&mul, &&div, &&lnk, &&addc,
&&subc, &&mulc, &&divc, &&lnkc,
&&addeq, &&subeq, &&muleq, &&diveq,
&&lnkeq, &&addeqc, &&subeqc, &&muleqc,
&&diveqc, &&lnkeqc, &&meq, &&eq,
&&neq, &&less, &&leq, &&grt,
&&geq, &&lessc, &&leqc, &&grtc,
&&geqc, &&pop, &&jmp, &&jt,
&&jf, &&counter, &&findex, &&feach,
&&callg, &&calll, &&upval, &&callv,
&&callvi, &&callh, &&callfv, &&callfh,
&&callb, &&slcbegin, &&slcend, &&slc,
&&slc2, &&mcallg, &&mcalll, &&mupval,
&&mcallv, &&mcallh, &&ret
&&vmexit, &&intg, &&intl, &&loadg,
&&loadl, &&loadu, &&pnum, &&pnil,
&&pstr, &&newv, &&newh, &&newf,
&&happ, &&para, &&deft, &&dyn,
&&unot, &&usub, &&add, &&sub,
&&mul, &&div, &&lnk, &&addc,
&&subc, &&mulc, &&divc, &&lnkc,
&&addeq, &&subeq, &&muleq, &&diveq,
&&lnkeq, &&addeqc, &&subeqc, &&muleqc,
&&diveqc, &&lnkeqc, &&meq, &&eq,
&&neq, &&less, &&leq, &&grt,
&&geq, &&lessc, &&leqc, &&grtc,
&&geqc, &&pop, &&jmp, &&jt,
&&jf, &&cnt, &&findex, &&feach,
&&callg, &&calll, &&upval, &&callv,
&&callvi, &&callh, &&callfv, &&callfh,
&&callb, &&slcbeg, &&slcend, &&slc,
&&slc2, &&mcallg, &&mcalll, &&mupval,
&&mcallv, &&mcallh, &&ret
};
std::vector<const void*> code;
for(auto& i:gen.get_code())
@ -222,80 +222,80 @@ vmexit:
return;
#define dbg(op) {interact();op();if(top<canary)goto *code[++pc];goto vmexit;}
intg: dbg(opr_intg );
intl: dbg(opr_intl );
loadg: dbg(opr_loadg );
loadl: dbg(opr_loadl );
loadu: dbg(opr_loadu );
pnum: dbg(opr_pnum );
pnil: dbg(opr_pnil );
pstr: dbg(opr_pstr );
newv: dbg(opr_newv );
newh: dbg(opr_newh );
newf: dbg(opr_newf );
happ: dbg(opr_happ );
para: dbg(opr_para );
defpara: dbg(opr_defpara );
dynpara: dbg(opr_dynpara );
unot: dbg(opr_unot );
usub: dbg(opr_usub );
add: dbg(opr_add );
sub: dbg(opr_sub );
mul: dbg(opr_mul );
div: dbg(opr_div );
lnk: dbg(opr_lnk );
addc: dbg(opr_addc );
subc: dbg(opr_subc );
mulc: dbg(opr_mulc );
divc: dbg(opr_divc );
lnkc: dbg(opr_lnkc );
addeq: dbg(opr_addeq );
subeq: dbg(opr_subeq );
muleq: dbg(opr_muleq );
diveq: dbg(opr_diveq );
lnkeq: dbg(opr_lnkeq );
addeqc: dbg(opr_addeqc );
subeqc: dbg(opr_subeqc );
muleqc: dbg(opr_muleqc );
diveqc: dbg(opr_diveqc );
lnkeqc: dbg(opr_lnkeqc );
meq: dbg(opr_meq );
eq: dbg(opr_eq );
neq: dbg(opr_neq );
less: dbg(opr_less );
leq: dbg(opr_leq );
grt: dbg(opr_grt );
geq: dbg(opr_geq );
lessc: dbg(opr_lessc );
leqc: dbg(opr_leqc );
grtc: dbg(opr_grtc );
geqc: dbg(opr_geqc );
pop: dbg(opr_pop );
jmp: dbg(opr_jmp );
jt: dbg(opr_jt );
jf: dbg(opr_jf );
counter: dbg(opr_counter );
findex: dbg(opr_findex );
feach: dbg(opr_feach );
callg: dbg(opr_callg );
calll: dbg(opr_calll );
upval: dbg(opr_upval );
callv: dbg(opr_callv );
callvi: dbg(opr_callvi );
callh: dbg(opr_callh );
callfv: dbg(opr_callfv );
callfh: dbg(opr_callfh );
callb: dbg(opr_callb );
slcbegin:dbg(opr_slcbegin);
slcend: dbg(opr_slcend );
slc: dbg(opr_slc );
slc2: dbg(opr_slc2 );
mcallg: dbg(opr_mcallg );
mcalll: dbg(opr_mcalll );
mupval: dbg(opr_mupval );
mcallv: dbg(opr_mcallv );
mcallh: dbg(opr_mcallh );
ret: dbg(opr_ret );
intg: dbg(opr_intg );
intl: dbg(opr_intl );
loadg: dbg(opr_loadg );
loadl: dbg(opr_loadl );
loadu: dbg(opr_loadu );
pnum: dbg(opr_pnum );
pnil: dbg(opr_pnil );
pstr: dbg(opr_pstr );
newv: dbg(opr_newv );
newh: dbg(opr_newh );
newf: dbg(opr_newf );
happ: dbg(opr_happ );
para: dbg(opr_para );
deft: dbg(opr_deft );
dyn: dbg(opr_dyn );
unot: dbg(opr_unot );
usub: dbg(opr_usub );
add: dbg(opr_add );
sub: dbg(opr_sub );
mul: dbg(opr_mul );
div: dbg(opr_div );
lnk: dbg(opr_lnk );
addc: dbg(opr_addc );
subc: dbg(opr_subc );
mulc: dbg(opr_mulc );
divc: dbg(opr_divc );
lnkc: dbg(opr_lnkc );
addeq: dbg(opr_addeq );
subeq: dbg(opr_subeq );
muleq: dbg(opr_muleq );
diveq: dbg(opr_diveq );
lnkeq: dbg(opr_lnkeq );
addeqc: dbg(opr_addeqc);
subeqc: dbg(opr_subeqc);
muleqc: dbg(opr_muleqc);
diveqc: dbg(opr_diveqc);
lnkeqc: dbg(opr_lnkeqc);
meq: dbg(opr_meq );
eq: dbg(opr_eq );
neq: dbg(opr_neq );
less: dbg(opr_less );
leq: dbg(opr_leq );
grt: dbg(opr_grt );
geq: dbg(opr_geq );
lessc: dbg(opr_lessc );
leqc: dbg(opr_leqc );
grtc: dbg(opr_grtc );
geqc: dbg(opr_geqc );
pop: dbg(opr_pop );
jmp: dbg(opr_jmp );
jt: dbg(opr_jt );
jf: dbg(opr_jf );
cnt: dbg(opr_cnt );
findex: dbg(opr_findex);
feach: dbg(opr_feach );
callg: dbg(opr_callg );
calll: dbg(opr_calll );
upval: dbg(opr_upval );
callv: dbg(opr_callv );
callvi: dbg(opr_callvi);
callh: dbg(opr_callh );
callfv: dbg(opr_callfv);
callfh: dbg(opr_callfh);
callb: dbg(opr_callb );
slcbeg: dbg(opr_slcbeg);
slcend: dbg(opr_slcend);
slc: dbg(opr_slc );
slc2: dbg(opr_slc2 );
mcallg: dbg(opr_mcallg);
mcalll: dbg(opr_mcalll);
mupval: dbg(opr_mupval);
mcallv: dbg(opr_mcallv);
mcallh: dbg(opr_mcallh);
ret: dbg(opr_ret );
}
#endif

220
nasal_vm.h
View File

@ -61,8 +61,8 @@ protected:
void opr_newf();
void opr_happ();
void opr_para();
void opr_defpara();
void opr_dynpara();
void opr_deft();
void opr_dyn();
void opr_unot();
void opr_usub();
void opr_add();
@ -100,7 +100,7 @@ protected:
void opr_jmp();
void opr_jt();
void opr_jf();
void opr_counter();
void opr_cnt();
void opr_findex();
void opr_feach();
void opr_callg();
@ -112,7 +112,7 @@ protected:
void opr_callfv();
void opr_callfh();
void opr_callb();
void opr_slcbegin();
void opr_slcbeg();
void opr_slcend();
void opr_slc();
void opr_slc2();
@ -179,13 +179,9 @@ void nasal_vm::bytecodeinfo(const char* header,const uint32_t p)
{
const opcode& c=bytecode[p];
printf("%s0x%.8x: %.2x %.2x %.2x %.2x %.2x %s ",
header,
p,
c.op,
uint8_t((c.num>>24)&0xff),
uint8_t((c.num>>16)&0xff),
uint8_t((c.num>>8)&0xff),
uint8_t(c.num&0xff),
header,p,c.op,
uint8_t((c.num>>24)&0xff),uint8_t((c.num>>16)&0xff),
uint8_t((c.num>>8)&0xff),uint8_t(c.num&0xff),
code_table[c.op].name
);
switch(c.op)
@ -217,7 +213,7 @@ void nasal_vm::bytecodeinfo(const char* header,const uint32_t p)
case op_happ: case op_pstr:
case op_lnkc:
case op_callh: case op_mcallh:
case op_para: case op_defpara:case op_dynpara:
case op_para: case op_deft: case op_dyn:
printf("0x%x (\"%s\")",c.num,rawstr(str_table[c.num],16).c_str());
break;
default:printf("0x%x",c.num);break;
@ -471,14 +467,14 @@ inline void nasal_vm::opr_para()
func.keys[str_table[imm[pc]]]=func.psize;// func->size has 1 place reserved for "me"
func.local[func.psize++]={vm_none};
}
inline void nasal_vm::opr_defpara()
inline void nasal_vm::opr_deft()
{
nasal_ref val=top[0];
nasal_func& func=(--top)[0].func();
func.keys[str_table[imm[pc]]]=func.psize;// func->size has 1 place reserved for "me"
func.local[func.psize++]=val;
}
inline void nasal_vm::opr_dynpara()
inline void nasal_vm::opr_dyn()
{
top[0].func().dynpara=imm[pc];
}
@ -646,7 +642,7 @@ inline void nasal_vm::opr_jf()
pc=imm[pc]-1;
--top;
}
inline void nasal_vm::opr_counter()
inline void nasal_vm::opr_cnt()
{
(++top)[0]={vm_cnt,(int64_t)-1};
if(top[-1].type!=vm_vec)
@ -829,7 +825,7 @@ inline void nasal_vm::opr_callb()
if(top[0].type==vm_none)
die("native function error.");
}
inline void nasal_vm::opr_slcbegin()
inline void nasal_vm::opr_slcbeg()
{
// +--------------+
// | slice_vector | <-- top[0]
@ -998,29 +994,29 @@ void nasal_vm::run(
{
detail_info=detail;
init(gen.get_strs(),gen.get_nums(),gen.get_code(),linker.get_file(),argv);
uint64_t count[op_ret+1]={0};
const void* oprs[]=
{
&&vmexit, &&intg, &&intl, &&loadg,
&&loadl, &&loadu, &&pnum, &&pnil,
&&pstr, &&newv, &&newh, &&newf,
&&happ, &&para, &&defpara,&&dynpara,
&&unot, &&usub, &&add, &&sub,
&&mul, &&div, &&lnk, &&addc,
&&subc, &&mulc, &&divc, &&lnkc,
&&addeq, &&subeq, &&muleq, &&diveq,
&&lnkeq, &&addeqc, &&subeqc, &&muleqc,
&&diveqc, &&lnkeqc, &&meq, &&eq,
&&neq, &&less, &&leq, &&grt,
&&geq, &&lessc, &&leqc, &&grtc,
&&geqc, &&pop, &&jmp, &&jt,
&&jf, &&counter, &&findex, &&feach,
&&callg, &&calll, &&upval, &&callv,
&&callvi, &&callh, &&callfv, &&callfh,
&&callb, &&slcbegin, &&slcend, &&slc,
&&slc2, &&mcallg, &&mcalll, &&mupval,
&&mcallv, &&mcallh, &&ret
&&vmexit, &&intg, &&intl, &&loadg,
&&loadl, &&loadu, &&pnum, &&pnil,
&&pstr, &&newv, &&newh, &&newf,
&&happ, &&para, &&deft, &&dyn,
&&unot, &&usub, &&add, &&sub,
&&mul, &&div, &&lnk, &&addc,
&&subc, &&mulc, &&divc, &&lnkc,
&&addeq, &&subeq, &&muleq, &&diveq,
&&lnkeq, &&addeqc, &&subeqc, &&muleqc,
&&diveqc, &&lnkeqc, &&meq, &&eq,
&&neq, &&less, &&leq, &&grt,
&&geq, &&lessc, &&leqc, &&grtc,
&&geqc, &&pop, &&jmp, &&jt,
&&jf, &&cnt, &&findex, &&feach,
&&callg, &&calll, &&upval, &&callv,
&&callvi, &&callh, &&callfv, &&callfh,
&&callb, &&slcbeg, &&slcend, &&slc,
&&slc2, &&mcallg, &&mcalll, &&mupval,
&&mcallv, &&mcallh, &&ret
};
uint64_t count[op_ret+1]={0};
std::vector<const void*> code;
for(auto& i:gen.get_code())
{
@ -1041,83 +1037,83 @@ vmexit:
imm.clear();
return;
// may cause stackoverflow
#define exec_operand(op,num) {op();++count[num];if(top<canary)goto *code[++pc];goto vmexit;}
#define exec_operand(op,num) {++count[num];op();if(top<canary)goto *code[++pc];goto vmexit;}
// do not cause stackoverflow
#define exec_opnodie(op,num) {op();++count[num];goto *code[++pc];}
#define exec_opnodie(op,num) {++count[num];op();goto *code[++pc];}
intg: exec_opnodie(opr_intg ,op_intg ); // +imm[pc] (detected at codegen)
intl: exec_opnodie(opr_intl ,op_intl ); // -0
loadg: exec_opnodie(opr_loadg ,op_loadg ); // -1
loadl: exec_opnodie(opr_loadl ,op_loadl ); // -1
loadu: exec_opnodie(opr_loadu ,op_loadu ); // -1
pnum: exec_operand(opr_pnum ,op_pnum ); // +1
pnil: exec_operand(opr_pnil ,op_pnil ); // +1
pstr: exec_operand(opr_pstr ,op_pstr ); // +1
newv: exec_operand(opr_newv ,op_newv ); // +1-imm[pc]
newh: exec_operand(opr_newh ,op_newh ); // +1
newf: exec_operand(opr_newf ,op_newf ); // +1
happ: exec_opnodie(opr_happ ,op_happ ); // -1
para: exec_opnodie(opr_para ,op_para ); // -0
defpara: exec_opnodie(opr_defpara ,op_defpara ); // -1
dynpara: exec_opnodie(opr_dynpara ,op_dynpara ); // -0
unot: exec_opnodie(opr_unot ,op_unot ); // -0
usub: exec_opnodie(opr_usub ,op_usub ); // -0
add: exec_opnodie(opr_add ,op_add ); // -1
sub: exec_opnodie(opr_sub ,op_sub ); // -1
mul: exec_opnodie(opr_mul ,op_mul ); // -1
div: exec_opnodie(opr_div ,op_div ); // -1
lnk: exec_opnodie(opr_lnk ,op_lnk ); // -1
addc: exec_opnodie(opr_addc ,op_addc ); // -0
subc: exec_opnodie(opr_subc ,op_subc ); // -0
mulc: exec_opnodie(opr_mulc ,op_mulc ); // -0
divc: exec_opnodie(opr_divc ,op_divc ); // -0
lnkc: exec_opnodie(opr_lnkc ,op_lnkc ); // -0
addeq: exec_opnodie(opr_addeq ,op_addeq ); // -1
subeq: exec_opnodie(opr_subeq ,op_subeq ); // -1
muleq: exec_opnodie(opr_muleq ,op_muleq ); // -1
diveq: exec_opnodie(opr_diveq ,op_diveq ); // -1
lnkeq: exec_opnodie(opr_lnkeq ,op_lnkeq ); // -1
addeqc: exec_opnodie(opr_addeqc ,op_addeqc ); // -0
subeqc: exec_opnodie(opr_subeqc ,op_subeqc ); // -0
muleqc: exec_opnodie(opr_muleqc ,op_muleqc ); // -0
diveqc: exec_opnodie(opr_diveqc ,op_diveqc ); // -0
lnkeqc: exec_opnodie(opr_lnkeqc ,op_lnkeqc ); // -0
meq: exec_opnodie(opr_meq ,op_meq ); // -1
eq: exec_opnodie(opr_eq ,op_eq ); // -1
neq: exec_opnodie(opr_neq ,op_neq ); // -1
less: exec_opnodie(opr_less ,op_less ); // -1
leq: exec_opnodie(opr_leq ,op_leq ); // -1
grt: exec_opnodie(opr_grt ,op_grt ); // -1
geq: exec_opnodie(opr_geq ,op_geq ); // -1
lessc: exec_opnodie(opr_lessc ,op_lessc ); // -0
leqc: exec_opnodie(opr_leqc ,op_leqc ); // -0
grtc: exec_opnodie(opr_grtc ,op_grtc ); // -0
geqc: exec_opnodie(opr_geqc ,op_geqc ); // -0
pop: exec_opnodie(opr_pop ,op_pop ); // -1
jmp: exec_opnodie(opr_jmp ,op_jmp ); // -0
jt: exec_opnodie(opr_jt ,op_jt ); // -0
jf: exec_opnodie(opr_jf ,op_jf ); // -1
counter: exec_opnodie(opr_counter ,op_cnt ); // -0
findex: exec_operand(opr_findex ,op_findex ); // +1
feach: exec_operand(opr_feach ,op_feach ); // +1
callg: exec_operand(opr_callg ,op_callg ); // +1
calll: exec_operand(opr_calll ,op_calll ); // +1
upval: exec_operand(opr_upval ,op_upval ); // +1
callv: exec_opnodie(opr_callv ,op_callv ); // -0
callvi: exec_opnodie(opr_callvi ,op_callvi ); // -0
callh: exec_opnodie(opr_callh ,op_callh ); // -0
callfv: exec_opnodie(opr_callfv ,op_callfv ); // check in the function
callfh: exec_opnodie(opr_callfh ,op_callfh ); // check in the function
callb: exec_opnodie(opr_callb ,op_callb ); // -0
slcbegin:exec_operand(opr_slcbegin,op_slcbegin); // +1
slcend: exec_opnodie(opr_slcend ,op_slcend ); // -1
slc: exec_opnodie(opr_slc ,op_slc ); // -1
slc2: exec_opnodie(opr_slc2 ,op_slc2 ); // -2
mcallg: exec_operand(opr_mcallg ,op_mcallg ); // +1
mcalll: exec_operand(opr_mcalll ,op_mcalll ); // +1
mupval: exec_operand(opr_mupval ,op_mupval ); // +1
mcallv: exec_opnodie(opr_mcallv ,op_mcallv ); // -0
mcallh: exec_opnodie(opr_mcallh ,op_mcallh ); // -0
ret: exec_opnodie(opr_ret ,op_ret ); // -2
intg: exec_opnodie(opr_intg ,op_intg ); // +imm[pc] (detected at codegen)
intl: exec_opnodie(opr_intl ,op_intl ); // -0
loadg: exec_opnodie(opr_loadg ,op_loadg ); // -1
loadl: exec_opnodie(opr_loadl ,op_loadl ); // -1
loadu: exec_opnodie(opr_loadu ,op_loadu ); // -1
pnum: exec_operand(opr_pnum ,op_pnum ); // +1
pnil: exec_operand(opr_pnil ,op_pnil ); // +1
pstr: exec_operand(opr_pstr ,op_pstr ); // +1
newv: exec_operand(opr_newv ,op_newv ); // +1-imm[pc]
newh: exec_operand(opr_newh ,op_newh ); // +1
newf: exec_operand(opr_newf ,op_newf ); // +1
happ: exec_opnodie(opr_happ ,op_happ ); // -1
para: exec_opnodie(opr_para ,op_para ); // -0
deft: exec_opnodie(opr_deft ,op_deft ); // -1
dyn: exec_opnodie(opr_dyn ,op_dyn ); // -0
unot: exec_opnodie(opr_unot ,op_unot ); // -0
usub: exec_opnodie(opr_usub ,op_usub ); // -0
add: exec_opnodie(opr_add ,op_add ); // -1
sub: exec_opnodie(opr_sub ,op_sub ); // -1
mul: exec_opnodie(opr_mul ,op_mul ); // -1
div: exec_opnodie(opr_div ,op_div ); // -1
lnk: exec_opnodie(opr_lnk ,op_lnk ); // -1
addc: exec_opnodie(opr_addc ,op_addc ); // -0
subc: exec_opnodie(opr_subc ,op_subc ); // -0
mulc: exec_opnodie(opr_mulc ,op_mulc ); // -0
divc: exec_opnodie(opr_divc ,op_divc ); // -0
lnkc: exec_opnodie(opr_lnkc ,op_lnkc ); // -0
addeq: exec_opnodie(opr_addeq ,op_addeq ); // -1
subeq: exec_opnodie(opr_subeq ,op_subeq ); // -1
muleq: exec_opnodie(opr_muleq ,op_muleq ); // -1
diveq: exec_opnodie(opr_diveq ,op_diveq ); // -1
lnkeq: exec_opnodie(opr_lnkeq ,op_lnkeq ); // -1
addeqc: exec_opnodie(opr_addeqc,op_addeqc); // -0
subeqc: exec_opnodie(opr_subeqc,op_subeqc); // -0
muleqc: exec_opnodie(opr_muleqc,op_muleqc); // -0
diveqc: exec_opnodie(opr_diveqc,op_diveqc); // -0
lnkeqc: exec_opnodie(opr_lnkeqc,op_lnkeqc); // -0
meq: exec_opnodie(opr_meq ,op_meq ); // -1
eq: exec_opnodie(opr_eq ,op_eq ); // -1
neq: exec_opnodie(opr_neq ,op_neq ); // -1
less: exec_opnodie(opr_less ,op_less ); // -1
leq: exec_opnodie(opr_leq ,op_leq ); // -1
grt: exec_opnodie(opr_grt ,op_grt ); // -1
geq: exec_opnodie(opr_geq ,op_geq ); // -1
lessc: exec_opnodie(opr_lessc ,op_lessc ); // -0
leqc: exec_opnodie(opr_leqc ,op_leqc ); // -0
grtc: exec_opnodie(opr_grtc ,op_grtc ); // -0
geqc: exec_opnodie(opr_geqc ,op_geqc ); // -0
pop: exec_opnodie(opr_pop ,op_pop ); // -1
jmp: exec_opnodie(opr_jmp ,op_jmp ); // -0
jt: exec_opnodie(opr_jt ,op_jt ); // -0
jf: exec_opnodie(opr_jf ,op_jf ); // -1
cnt: exec_opnodie(opr_cnt ,op_cnt ); // -0
findex: exec_operand(opr_findex,op_findex); // +1
feach: exec_operand(opr_feach ,op_feach ); // +1
callg: exec_operand(opr_callg ,op_callg ); // +1
calll: exec_operand(opr_calll ,op_calll ); // +1
upval: exec_operand(opr_upval ,op_upval ); // +1
callv: exec_opnodie(opr_callv ,op_callv ); // -0
callvi: exec_opnodie(opr_callvi,op_callvi); // -0
callh: exec_opnodie(opr_callh ,op_callh ); // -0
callfv: exec_opnodie(opr_callfv,op_callfv); // check in the function
callfh: exec_opnodie(opr_callfh,op_callfh); // check in the function
callb: exec_opnodie(opr_callb ,op_callb ); // -0
slcbeg: exec_operand(opr_slcbeg,op_slcbeg); // +1
slcend: exec_opnodie(opr_slcend,op_slcend); // -1
slc: exec_opnodie(opr_slc ,op_slc ); // -1
slc2: exec_opnodie(opr_slc2 ,op_slc2 ); // -2
mcallg: exec_operand(opr_mcallg,op_mcallg); // +1
mcalll: exec_operand(opr_mcalll,op_mcalll); // +1
mupval: exec_operand(opr_mupval,op_mupval); // +1
mcallv: exec_opnodie(opr_mcallv,op_mcallv); // -0
mcallh: exec_opnodie(opr_mcallh,op_mcallh); // -0
ret: exec_opnodie(opr_ret ,op_ret ); // -2
}
#endif