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

add trace back info

This commit is contained in:
Li Haokun 2021-07-16 17:18:13 +08:00 committed by GitHub
parent 9da029b8fe
commit 9fe7a86a3b
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 147 additions and 121 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
README.md
View File

@ -36,11 +36,11 @@ MUST USE -O2/-O3 if want to optimize the interpreter!
Also remember to use g++ and clang++. Also remember to use g++ and clang++.
> g++|clang++ -std=c++11 -O2 main.cpp -o nasal.exe > g++ | clang++ -std=c++11 -O2 main.cpp -o nasal.exe
Or use this in linux/macOS/Unix Or use this in linux/macOS/Unix
> g++|clang++ -std=c++11 -O2 main.cpp -o nasal > g++ | clang++ -std=c++11 -O2 main.cpp -o nasal
## How to Use? ## How to Use?
@ -54,11 +54,11 @@ Input this command to run scripts directly:
Use these commands to get version of interpreter: Use these commands to get version of interpreter:
> ./nasal -v | -version > ./nasal -v | --version
Use these commands to get help: Use these commands to get help:
> ./nasal -h | -help > ./nasal -h | --help
If your system is Windows and you want to output unicode,please use this command before running nasal interpreter: If your system is Windows and you want to output unicode,please use this command before running nasal interpreter:

16
main.cpp
View File

@ -5,7 +5,6 @@ void help_interact()
std::cout std::cout
<<">> [ ] input a file name to execute. \n" <<">> [ ] input a file name to execute. \n"
<<">> [help ] show help. \n" <<">> [help ] show help. \n"
<<">> [lex ] view tokens. \n"
<<">> [ast ] view abstract syntax tree. \n" <<">> [ast ] view abstract syntax tree. \n"
<<">> [code ] view byte code. \n" <<">> [code ] view byte code. \n"
<<">> [exec ] execute program on bytecode vm.\n" <<">> [exec ] execute program on bytecode vm.\n"
@ -65,13 +64,7 @@ void execute(std::string& file,std::string& command)
die("lexer",file); die("lexer",file);
return; return;
} }
if(command=="lex")
{
lexer.print_token();
return;
}
parse.set_toklist(lexer.get_token_list()); parse.set_toklist(lexer.get_token_list());
lexer.get_token_list().clear();
parse.main_process(); parse.main_process();
if(parse.get_error()) if(parse.get_error())
{ {
@ -83,8 +76,8 @@ void execute(std::string& file,std::string& command)
parse.get_root().print_ast(0); parse.get_root().print_ast(0);
return; return;
} }
import.link(parse.get_root()); // first used file is itself
parse.get_root().clear(); import.link(parse.get_root(),file);
if(import.get_error()) if(import.get_error())
{ {
die("import",file); die("import",file);
@ -103,7 +96,8 @@ void execute(std::string& file,std::string& command)
} }
vm.init( vm.init(
codegen.get_str_table(), codegen.get_str_table(),
codegen.get_num_table() codegen.get_num_table(),
import.get_file()
); );
vm.run(codegen.get_exec_code()); vm.run(codegen.get_exec_code());
vm.clear(); vm.clear();
@ -128,7 +122,7 @@ void interact()
logo(); logo();
else if(command=="exit") else if(command=="exit")
return; return;
else if(command=="lex" || command=="ast" || command=="code" || command=="exec") else if(command=="ast" || command=="code" || command=="exec")
execute(file,command); execute(file,command);
else else
file=command; file=command;

4
nasal_ast.h
View File

@ -5,6 +5,7 @@ enum ast_node
{ {
ast_null=0, ast_null=0,
ast_root,ast_block, ast_root,ast_block,
ast_file, // ast_file is only used to store which file the subtree is on,codegen will generate nothing
ast_nil,ast_num,ast_str,ast_id,ast_func,ast_hash,ast_vec, ast_nil,ast_num,ast_str,ast_id,ast_func,ast_hash,ast_vec,
ast_hashmember,ast_call,ast_callh,ast_callv,ast_callf,ast_subvec, ast_hashmember,ast_call,ast_callh,ast_callv,ast_callf,ast_subvec,
ast_args,ast_default_arg,ast_dynamic_id, ast_args,ast_default_arg,ast_dynamic_id,
@ -27,6 +28,7 @@ const char* ast_name[]=
{ {
"null", "null",
"root","block", "root","block",
"file",
"nil","num","str","id","func","hash","vec", "nil","num","str","id","func","hash","vec",
"hashmember","call","callh","callv","callf","subvec", "hashmember","call","callh","callv","callf","subvec",
"args","deflt_arg","dyn_id", "args","deflt_arg","dyn_id",
@ -131,7 +133,7 @@ void nasal_ast::print_ast(int depth)
std::cout<<ast_name[type]; std::cout<<ast_name[type];
if(type==ast_str || type==ast_id || type==ast_default_arg || type==ast_dynamic_id || type==ast_callh) if(type==ast_str || type==ast_id || type==ast_default_arg || type==ast_dynamic_id || type==ast_callh)
std::cout<<":"<<str; std::cout<<":"<<str;
else if(type==ast_num) else if(type==ast_num || type==ast_file)
std::cout<<":"<<num; std::cout<<":"<<num;
std::cout<<'\n'; std::cout<<'\n';
for(auto& i:children) for(auto& i:children)

6
nasal_builtin.h
View File

@ -54,11 +54,7 @@ nasal_val* builtin_right(std::vector<nasal_val*>&,nasal_gc&);
nasal_val* builtin_cmp(std::vector<nasal_val*>&,nasal_gc&); nasal_val* builtin_cmp(std::vector<nasal_val*>&,nasal_gc&);
nasal_val* builtin_chr(std::vector<nasal_val*>&,nasal_gc&); nasal_val* builtin_chr(std::vector<nasal_val*>&,nasal_gc&);
void builtin_err(const char* func_name,std::string info) #define builtin_err(func_name,info) std::cout<<">> [vm] "<<func_name<<": "<<info<<".\n"
{
std::cout<<">> [vm] "<<func_name<<": "<<info<<".\n";
return;
}
// register builtin function's name and it's address here in this table below // register builtin function's name and it's address here in this table below
// this table must end with {"",nullptr} // this table must end with {"",nullptr}

12
nasal_codegen.h
View File

@ -168,12 +168,14 @@ struct
struct opcode struct opcode
{ {
uint8_t op; uint16_t op;
uint16_t fidx;
uint32_t num; uint32_t num;
uint32_t line; uint32_t line;
opcode(uint8_t _op=op_nop,uint32_t _num=0,uint32_t _line=0) opcode(uint8_t _op=op_nop,uint16_t _fidx=0,uint32_t _num=0,uint32_t _line=0)
{ {
op=_op; op=_op;
fidx=_fidx;
num=_num; num=_num;
line=_line; line=_line;
return; return;
@ -181,6 +183,7 @@ struct opcode
opcode& operator=(const opcode& tmp) opcode& operator=(const opcode& tmp)
{ {
op=tmp.op; op=tmp.op;
fidx=tmp.fidx;
num=tmp.num; num=tmp.num;
line=tmp.line; line=tmp.line;
return *this; return *this;
@ -191,6 +194,7 @@ class nasal_codegen
{ {
private: private:
int error; int error;
uint16_t fileindex;
int in_forindex; int in_forindex;
int in_foreach; int in_foreach;
std::unordered_map<double,int> number_table; std::unordered_map<double,int> number_table;
@ -316,7 +320,7 @@ int nasal_codegen::global_find(std::string& name)
void nasal_codegen::gen(uint8_t op,uint32_t num,uint32_t line) void nasal_codegen::gen(uint8_t op,uint32_t num,uint32_t line)
{ {
exec_code.push_back({op,num,line}); exec_code.push_back({op,fileindex,num,line});
return; return;
} }
@ -1136,6 +1140,7 @@ void nasal_codegen::main_progress(nasal_ast& ast)
error=0; error=0;
in_foreach=0; in_foreach=0;
in_forindex=0; in_forindex=0;
fileindex=0;
number_table.clear(); number_table.clear();
string_table.clear(); string_table.clear();
@ -1149,6 +1154,7 @@ void nasal_codegen::main_progress(nasal_ast& ast)
switch(tmp.get_type()) switch(tmp.get_type())
{ {
case ast_null:case ast_nil:case ast_num:case ast_str:case ast_func:break; case ast_null:case ast_nil:case ast_num:case ast_str:case ast_func:break;
case ast_file:fileindex=tmp.get_num();break;
case ast_def:def_gen(tmp);break; case ast_def:def_gen(tmp);break;
case ast_multi_assign:multi_assign_gen(tmp);break; case ast_multi_assign:multi_assign_gen(tmp);break;
case ast_conditional:conditional_gen(tmp);break; case ast_conditional:conditional_gen(tmp);break;

38
nasal_import.h
View File

@ -4,21 +4,22 @@
class nasal_import class nasal_import
{ {
private: private:
int error; int error;
nasal_lexer import_lex; nasal_lexer import_lex;
nasal_parse import_par; nasal_parse import_par;
nasal_ast import_ast; nasal_ast import_ast;
std::vector<std::string> filename_table; std::vector<std::string> filename_table;
void die(std::string&,const char*); void die(std::string&,const char*);
bool check_import(nasal_ast&); bool check_import(nasal_ast&);
bool check_exist(std::string&); bool check_exist(std::string&);
void linker(nasal_ast&,nasal_ast&&); void linker(nasal_ast&,nasal_ast&&);
nasal_ast file_import(nasal_ast&); nasal_ast file_import(nasal_ast&);
nasal_ast load(nasal_ast&); nasal_ast load(nasal_ast&,uint16_t);
public: public:
int get_error(){return error;} int get_error(){return error;}
void link(nasal_ast&); void link(nasal_ast&,std::string&);
nasal_ast& get_root(){return import_ast;} nasal_ast& get_root(){return import_ast;}
std::vector<std::string>& get_file(){return filename_table;}
}; };
void nasal_import::die(std::string& filename,const char* error_stage) void nasal_import::die(std::string& filename,const char* error_stage)
@ -91,7 +92,6 @@ nasal_ast nasal_import::file_import(nasal_ast& node)
return tmp; return tmp;
} }
import_par.set_toklist(import_lex.get_token_list()); import_par.set_toklist(import_lex.get_token_list());
import_lex.get_token_list().clear();
import_par.main_process(); import_par.main_process();
if(import_par.get_error()) if(import_par.get_error())
{ {
@ -99,30 +99,34 @@ nasal_ast nasal_import::file_import(nasal_ast& node)
return tmp; return tmp;
} }
tmp=std::move(import_par.get_root()); tmp=std::move(import_par.get_root());
import_par.get_root().clear();
// check if tmp has 'import' // check if tmp has 'import'
return load(tmp); return load(tmp,filename_table.size()-1);
} }
nasal_ast nasal_import::load(nasal_ast& root) nasal_ast nasal_import::load(nasal_ast& root,uint16_t fileindex)
{ {
nasal_ast new_root(0,ast_root); nasal_ast new_root(0,ast_root);
for(auto& i:root.get_children()) for(auto& i:root.get_children())
if(check_import(i)) if(check_import(i))
linker(new_root,file_import(i)); linker(new_root,file_import(i));
// add root to the back of new_root // 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)); linker(new_root,std::move(root));
return new_root; return new_root;
} }
void nasal_import::link(nasal_ast& root) void nasal_import::link(nasal_ast& root,std::string& self)
{ {
// initializing // initializing
error=0; error=0;
filename_table.clear(); filename_table.clear();
filename_table.push_back(self);
import_ast.clear(); import_ast.clear();
// scan root and import files,then generate a new ast and return to import_ast // scan root and import files,then generate a new ast and return to import_ast
import_ast=load(root); // the main file's index is 0
import_ast=load(root,0);
return; return;
} }

184
nasal_vm.h
View File

@ -15,7 +15,10 @@ private:
std::vector<uint32_t> imm; // immediate number std::vector<uint32_t> imm; // immediate number
nasal_val** mem_addr; // used for mem_call nasal_val** mem_addr; // used for mem_call
nasal_gc gc; // garbage collector nasal_gc gc; // garbage collector
/* values used for debug */
std::vector<opcode> bytecode; // bytecode
std::vector<std::string> files; // files
void die(std::string); void die(std::string);
bool condition(nasal_val*); bool condition(nasal_val*);
void opr_intg(); void opr_intg();
@ -97,19 +100,22 @@ public:
nasal_vm():stack_top(gc.stack_top){}; nasal_vm():stack_top(gc.stack_top){};
void init( void init(
std::vector<std::string>&, std::vector<std::string>&,
std::vector<double>&); std::vector<double>&,
std::vector<std::string>&);
void clear(); void clear();
void run(std::vector<opcode>&); void run(std::vector<opcode>&);
}; };
void nasal_vm::init( void nasal_vm::init(
std::vector<std::string>& strs, std::vector<std::string>& strs,
std::vector<double>& nums) std::vector<double>& nums,
std::vector<std::string>& filenames)
{ {
gc.gc_init(nums,strs); gc.gc_init(nums,strs);
gc.val_stack[STACK_MAX_DEPTH-1]=nullptr; gc.val_stack[STACK_MAX_DEPTH-1]=nullptr;
num_table=nums; // get constant numbers num_table=nums; // get constant numbers
str_table=strs; // get constant strings & symbols str_table=strs; // get constant strings & symbols
files=filenames;// get filenames for debugger
return; return;
} }
void nasal_vm::clear() void nasal_vm::clear()
@ -126,7 +132,22 @@ void nasal_vm::clear()
} }
void nasal_vm::die(std::string str) void nasal_vm::die(std::string str)
{ {
printf(">> [vm] 0x%.8x: %s\n",pc,str.c_str()); printf(">> [vm] error: %s\ntrace back:\n",str.c_str());
// add error pc into ret_stack
ret.push(pc);
// trace back will use ret_stack
while(!ret.empty())
{
uint32_t point=ret.top();
ret.pop();
printf(
"\tpc 0x%.8x: %s 0x%.8x (%s line %d)\n",
point,
code_table[bytecode[point].op].name,
bytecode[point].num,
files[bytecode[point].fidx].c_str(),
bytecode[point].line);
}
gc.val_stack[STACK_MAX_DEPTH-1]=(nasal_val*)0xffff; gc.val_stack[STACK_MAX_DEPTH-1]=(nasal_val*)0xffff;
return; return;
} }
@ -735,7 +756,8 @@ inline void nasal_vm::opr_callfh()
inline void nasal_vm::opr_callb() inline void nasal_vm::opr_callb()
{ {
(++stack_top)[0]=(*builtin_func[imm[pc]].func)(gc.local.back(),gc); (++stack_top)[0]=(*builtin_func[imm[pc]].func)(gc.local.back(),gc);
gc.val_stack[STACK_MAX_DEPTH-1]=(stack_top[0]?nullptr:(nasal_val*)0xffff); if(!stack_top[0])
die("native function error.");
return; return;
} }
inline void nasal_vm::opr_slcbegin() inline void nasal_vm::opr_slcbegin()
@ -898,6 +920,8 @@ void nasal_vm::run(std::vector<opcode>& exec)
&&slcend, &&slc, &&slc2, &&mcallg, &&slcend, &&slc, &&slc2, &&mcallg,
&&mcalll, &&mcallv, &&mcallh, &&ret &&mcalll, &&mcallv, &&mcallh, &&ret
}; };
bytecode=exec;
std::vector<void*> code; std::vector<void*> code;
for(auto& i:exec) for(auto& i:exec)
{ {
@ -912,7 +936,7 @@ void nasal_vm::run(std::vector<opcode>& exec)
nop: nop:
if(canary[0] && canary[0]!=(nasal_val*)0xffff) if(canary[0] && canary[0]!=(nasal_val*)0xffff)
std::cout<<">> [vm] stack overflow.\n"; die("stack overflow");
std::cout<<">> [vm] process exited after "<<((double)(clock()-begin))/CLOCKS_PER_SEC<<"s.\n"; std::cout<<">> [vm] process exited after "<<((double)(clock()-begin))/CLOCKS_PER_SEC<<"s.\n";
// debug // debug
// for(int i=0;i<15;++i) // for(int i=0;i<15;++i)
@ -933,80 +957,80 @@ nop:
//#define exec_opnodie(op,num) {op();++count[num];goto *code[++pc];} //#define exec_opnodie(op,num) {op();++count[num];goto *code[++pc];}
#define exec_opnodie(op,num) {op();goto *code[++pc];} #define exec_opnodie(op,num) {op();goto *code[++pc];}
intg: exec_opnodie(opr_intg ,op_intg); intg: exec_opnodie(opr_intg ,op_intg );
intl: exec_opnodie(opr_intl ,op_intl); intl: exec_opnodie(opr_intl ,op_intl );
offset: exec_opnodie(opr_offset ,op_offset); offset: exec_opnodie(opr_offset ,op_offset );
loadg: exec_opnodie(opr_loadg ,op_loadg); loadg: exec_opnodie(opr_loadg ,op_loadg );
loadl: exec_opnodie(opr_loadl ,op_loadl); loadl: exec_opnodie(opr_loadl ,op_loadl );
pnum: exec_operand(opr_pnum ,op_pnum); pnum: exec_operand(opr_pnum ,op_pnum );
pone: exec_operand(opr_pone ,op_pone); pone: exec_operand(opr_pone ,op_pone );
pzero: exec_operand(opr_pzero ,op_pzero); pzero: exec_operand(opr_pzero ,op_pzero );
pnil: exec_operand(opr_pnil ,op_pnil); pnil: exec_operand(opr_pnil ,op_pnil );
pstr: exec_operand(opr_pstr ,op_pstr); pstr: exec_operand(opr_pstr ,op_pstr );
newv: exec_operand(opr_newv ,op_newv); newv: exec_operand(opr_newv ,op_newv );
newh: exec_operand(opr_newh ,op_newh); newh: exec_operand(opr_newh ,op_newh );
newf: exec_operand(opr_newf ,op_newf); newf: exec_operand(opr_newf ,op_newf );
happ: exec_opnodie(opr_happ ,op_happ); happ: exec_opnodie(opr_happ ,op_happ );
para: exec_opnodie(opr_para ,op_para); para: exec_opnodie(opr_para ,op_para );
defpara: exec_opnodie(opr_defpara ,op_defpara); defpara: exec_opnodie(opr_defpara ,op_defpara );
dynpara: exec_opnodie(opr_dynpara ,op_dynpara); dynpara: exec_opnodie(opr_dynpara ,op_dynpara );
unot: exec_operand(opr_unot ,op_unot); unot: exec_operand(opr_unot ,op_unot );
usub: exec_opnodie(opr_usub ,op_usub); usub: exec_opnodie(opr_usub ,op_usub );
add: exec_opnodie(opr_add ,op_add); add: exec_opnodie(opr_add ,op_add );
sub: exec_opnodie(opr_sub ,op_sub); sub: exec_opnodie(opr_sub ,op_sub );
mul: exec_opnodie(opr_mul ,op_mul); mul: exec_opnodie(opr_mul ,op_mul );
div: exec_opnodie(opr_div ,op_div); div: exec_opnodie(opr_div ,op_div );
lnk: exec_opnodie(opr_lnk ,op_lnk); lnk: exec_opnodie(opr_lnk ,op_lnk );
addc: exec_opnodie(opr_addc ,op_addc); addc: exec_opnodie(opr_addc ,op_addc );
subc: exec_opnodie(opr_subc ,op_subc); subc: exec_opnodie(opr_subc ,op_subc );
mulc: exec_opnodie(opr_mulc ,op_mulc); mulc: exec_opnodie(opr_mulc ,op_mulc );
divc: exec_opnodie(opr_divc ,op_divc); divc: exec_opnodie(opr_divc ,op_divc );
lnkc: exec_opnodie(opr_lnkc ,op_lnkc); lnkc: exec_opnodie(opr_lnkc ,op_lnkc );
addeq: exec_opnodie(opr_addeq ,op_addeq); addeq: exec_opnodie(opr_addeq ,op_addeq );
subeq: exec_opnodie(opr_subeq ,op_subeq); subeq: exec_opnodie(opr_subeq ,op_subeq );
muleq: exec_opnodie(opr_muleq ,op_muleq); muleq: exec_opnodie(opr_muleq ,op_muleq );
diveq: exec_opnodie(opr_diveq ,op_diveq); diveq: exec_opnodie(opr_diveq ,op_diveq );
lnkeq: exec_opnodie(opr_lnkeq ,op_lnkeq); lnkeq: exec_opnodie(opr_lnkeq ,op_lnkeq );
addeqc: exec_opnodie(opr_addeqc ,op_addeqc); addeqc: exec_opnodie(opr_addeqc ,op_addeqc );
subeqc: exec_opnodie(opr_subeqc ,op_subeqc); subeqc: exec_opnodie(opr_subeqc ,op_subeqc );
muleqc: exec_opnodie(opr_muleqc ,op_muleqc); muleqc: exec_opnodie(opr_muleqc ,op_muleqc );
diveqc: exec_opnodie(opr_diveqc ,op_diveqc); diveqc: exec_opnodie(opr_diveqc ,op_diveqc );
lnkeqc: exec_opnodie(opr_lnkeqc ,op_lnkeqc); lnkeqc: exec_opnodie(opr_lnkeqc ,op_lnkeqc );
meq: exec_opnodie(opr_meq ,op_meq); meq: exec_opnodie(opr_meq ,op_meq );
eq: exec_opnodie(opr_eq ,op_eq); eq: exec_opnodie(opr_eq ,op_eq );
neq: exec_opnodie(opr_neq ,op_neq); neq: exec_opnodie(opr_neq ,op_neq );
less: exec_opnodie(opr_less ,op_less); less: exec_opnodie(opr_less ,op_less );
leq: exec_opnodie(opr_leq ,op_leq); leq: exec_opnodie(opr_leq ,op_leq );
grt: exec_opnodie(opr_grt ,op_grt); grt: exec_opnodie(opr_grt ,op_grt );
geq: exec_opnodie(opr_geq ,op_geq); geq: exec_opnodie(opr_geq ,op_geq );
lessc: exec_opnodie(opr_lessc ,op_lessc); lessc: exec_opnodie(opr_lessc ,op_lessc );
leqc: exec_opnodie(opr_leqc ,op_leqc); leqc: exec_opnodie(opr_leqc ,op_leqc );
grtc: exec_opnodie(opr_grtc ,op_grtc); grtc: exec_opnodie(opr_grtc ,op_grtc );
geqc: exec_opnodie(opr_geqc ,op_geqc); geqc: exec_opnodie(opr_geqc ,op_geqc );
pop: exec_opnodie(opr_pop ,op_pop); pop: exec_opnodie(opr_pop ,op_pop );
jmp: exec_opnodie(opr_jmp ,op_jmp); jmp: exec_opnodie(opr_jmp ,op_jmp );
jt: exec_opnodie(opr_jt ,op_jt); jt: exec_opnodie(opr_jt ,op_jt );
jf: exec_opnodie(opr_jf ,op_jf); jf: exec_opnodie(opr_jf ,op_jf );
counter: exec_operand(opr_counter ,op_cnt); counter: exec_operand(opr_counter ,op_cnt );
cntpop: exec_opnodie(opr_cntpop ,op_cntpop); cntpop: exec_opnodie(opr_cntpop ,op_cntpop );
findex: exec_opnodie(opr_findex ,op_findex); findex: exec_opnodie(opr_findex ,op_findex );
feach: exec_opnodie(opr_feach ,op_feach); feach: exec_opnodie(opr_feach ,op_feach );
callg: exec_opnodie(opr_callg ,op_callg); callg: exec_opnodie(opr_callg ,op_callg );
calll: exec_opnodie(opr_calll ,op_calll); calll: exec_opnodie(opr_calll ,op_calll );
callv: exec_operand(opr_callv ,op_callv); callv: exec_operand(opr_callv ,op_callv );
callvi: exec_operand(opr_callvi ,op_callvi); callvi: exec_operand(opr_callvi ,op_callvi );
callh: exec_operand(opr_callh ,op_callh); callh: exec_operand(opr_callh ,op_callh );
callfv: exec_operand(opr_callfv ,op_callfv); callfv: exec_operand(opr_callfv ,op_callfv );
callfh: exec_operand(opr_callfh ,op_callfh); callfh: exec_operand(opr_callfh ,op_callfh );
callb: exec_operand(opr_callb ,op_callb); callb: exec_operand(opr_callb ,op_callb );
slcbegin:exec_operand(opr_slcbegin,op_slcbegin); slcbegin:exec_operand(opr_slcbegin,op_slcbegin);
slcend: exec_opnodie(opr_slcend ,op_slcend); slcend: exec_opnodie(opr_slcend ,op_slcend );
slc: exec_operand(opr_slc ,op_slc); slc: exec_operand(opr_slc ,op_slc );
slc2: exec_operand(opr_slc2 ,op_slc2); slc2: exec_operand(opr_slc2 ,op_slc2 );
mcallg: exec_opnodie(opr_mcallg ,op_mcallg); mcallg: exec_opnodie(opr_mcallg ,op_mcallg );
mcalll: exec_opnodie(opr_mcalll ,op_mcalll); mcalll: exec_opnodie(opr_mcalll ,op_mcalll );
mcallv: exec_operand(opr_mcallv ,op_mcallv); mcallv: exec_operand(opr_mcallv ,op_mcallv );
mcallh: exec_operand(opr_mcallh ,op_mcallh); mcallh: exec_operand(opr_mcallh ,op_mcallh );
ret: exec_opnodie(opr_ret ,op_ret); ret: exec_opnodie(opr_ret ,op_ret );
} }
#endif #endif