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

delete slice_stack

This commit is contained in:
ValKmjolnir 2021-07-07 14:46:46 +08:00
parent 57d6bcdc52
commit 590c595522
3 changed files with 45 additions and 43 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
nasal_builtin.h
View File

@ -2,12 +2,11 @@
#define __NASAL_BUILTIN_H__ #define __NASAL_BUILTIN_H__
/* /*
builtin functions must be called inside a outer function like this: builtin functions must be called inside a outer function like this:
var print=func(elements...) var print=func(elems...)
{ {
__builtin_std_cout(elements); return __builtin_print(elems);
return nil;
} }
builtin function __builtin_std_cout is wrapped up by print builtin function __builtin_print is wrapped up by print
*/ */
// declaration of builtin functions // declaration of builtin functions
@ -691,11 +690,11 @@ nasal_val* builtin_type(std::vector<nasal_val*>& local_scope,nasal_gc& gc)
switch(val_addr->type) switch(val_addr->type)
{ {
case vm_nil: *ret_addr->ptr.str="nil"; break; case vm_nil: *ret_addr->ptr.str="nil"; break;
case vm_num: *ret_addr->ptr.str="number"; break; case vm_num: *ret_addr->ptr.str="num"; break;
case vm_str: *ret_addr->ptr.str="string"; break; case vm_str: *ret_addr->ptr.str="str"; break;
case vm_vec: *ret_addr->ptr.str="vector"; break; case vm_vec: *ret_addr->ptr.str="vec"; break;
case vm_hash: *ret_addr->ptr.str="hash"; break; case vm_hash: *ret_addr->ptr.str="hash"; break;
case vm_func: *ret_addr->ptr.str="function"; break; case vm_func: *ret_addr->ptr.str="func"; break;
} }
return ret_addr; return ret_addr;
} }

15
nasal_gc.h
View File

@ -18,10 +18,10 @@ const int increment[vm_type_size]=
{ {
0, // vm_nil,in fact it is not in use 0, // vm_nil,in fact it is not in use
65536,// vm_num 65536,// vm_num
256, // vm_str 512, // vm_str
16, // vm_func 64, // vm_func
2048, // vm_vec 2048, // vm_vec
8 // vm_hash 512 // vm_hash
}; };
struct nasal_val;//declaration of nasal_val struct nasal_val;//declaration of nasal_val
@ -63,7 +63,7 @@ struct nasal_val// 16 bytes
#define GC_COLLECTED 1 #define GC_COLLECTED 1
#define GC_FOUND 2 #define GC_FOUND 2
uint8_t mark; uint8_t mark;
uint16_t type; uint8_t type;
union union
{ {
double num; double num;
@ -234,7 +234,7 @@ std::string nasal_val::to_string()
struct nasal_gc struct nasal_gc
{ {
#define STACK_MAX_DEPTH (4096) #define STACK_MAX_DEPTH (4080)
nasal_val* zero_addr; // reserved address of nasal_val,type vm_num, 0 nasal_val* zero_addr; // reserved address of nasal_val,type vm_num, 0
nasal_val* one_addr; // reserved address of nasal_val,type vm_num, 1 nasal_val* one_addr; // reserved address of nasal_val,type vm_num, 1
nasal_val* nil_addr; // reserved address of nasal_val,type vm_nil nasal_val* nil_addr; // reserved address of nasal_val,type vm_nil
@ -242,7 +242,6 @@ struct nasal_gc
nasal_val** stack_top; // stack top nasal_val** stack_top; // stack top
std::vector<nasal_val*> num_addrs; // reserved address for const vm_num std::vector<nasal_val*> num_addrs; // reserved address for const vm_num
std::vector<nasal_val*> str_addrs; // reserved address for const vm_str std::vector<nasal_val*> str_addrs; // reserved address for const vm_str
std::vector<nasal_val*> slice_stack; // slice stack for vec[val,val,val:val]
std::vector<nasal_val*> memory; // gc memory std::vector<nasal_val*> memory; // gc memory
std::queue <nasal_val*> free_list[vm_type_size]; // gc free list std::queue <nasal_val*> free_list[vm_type_size]; // gc free list
std::list<std::vector<nasal_val*>> local; std::list<std::vector<nasal_val*>> local;
@ -261,8 +260,6 @@ void nasal_gc::mark()
for(auto& i:local) for(auto& i:local)
for(auto j:i) for(auto j:i)
bfs.push(j); bfs.push(j);
for(auto i:slice_stack)
bfs.push(i);
for(nasal_val** i=val_stack;i<=stack_top;++i) for(nasal_val** i=val_stack;i<=stack_top;++i)
bfs.push(*i); bfs.push(*i);
while(!bfs.empty()) while(!bfs.empty())
@ -357,9 +354,7 @@ void nasal_gc::gc_clear()
for(int i=0;i<vm_type_size;++i) for(int i=0;i<vm_type_size;++i)
while(!free_list[i].empty()) while(!free_list[i].empty())
free_list[i].pop(); free_list[i].pop();
//global.clear();
local.clear(); local.clear();
slice_stack.clear();
delete nil_addr; delete nil_addr;
delete one_addr; delete one_addr;

54
nasal_vm.h
View File

@ -10,6 +10,7 @@ private:
uint32_t pc; // program counter uint32_t pc; // program counter
std::stack<int> ret; // ptr stack stores address for function to return std::stack<int> ret; // ptr stack stores address for function to return
std::stack<int> counter; // iterator stack for forindex/foreach std::stack<int> counter; // iterator stack for forindex/foreach
std::vector<double> num_table;// numbers used in process(const calculation)
std::vector<std::string> str_table;// symbols used in process std::vector<std::string> str_table;// symbols used in process
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
@ -107,6 +108,7 @@ void nasal_vm::init(
{ {
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
str_table=strs; // get constant strings & symbols str_table=strs; // get constant strings & symbols
return; return;
} }
@ -117,6 +119,7 @@ void nasal_vm::clear()
ret.pop(); ret.pop();
while(!counter.empty()) while(!counter.empty())
counter.pop(); counter.pop();
num_table.clear();
str_table.clear(); str_table.clear();
imm.clear(); imm.clear();
return; return;
@ -315,28 +318,28 @@ inline void nasal_vm::opr_lnk()
inline void nasal_vm::opr_addc() inline void nasal_vm::opr_addc()
{ {
nasal_val* new_val=gc.gc_alloc(vm_num); nasal_val* new_val=gc.gc_alloc(vm_num);
new_val->ptr.num=stack_top[0]->to_number()+gc.num_addrs[imm[pc]]->ptr.num; new_val->ptr.num=stack_top[0]->to_number()+num_table[imm[pc]];
stack_top[0]=new_val; stack_top[0]=new_val;
return; return;
} }
inline void nasal_vm::opr_subc() inline void nasal_vm::opr_subc()
{ {
nasal_val* new_val=gc.gc_alloc(vm_num); nasal_val* new_val=gc.gc_alloc(vm_num);
new_val->ptr.num=stack_top[0]->to_number()-gc.num_addrs[imm[pc]]->ptr.num; new_val->ptr.num=stack_top[0]->to_number()-num_table[imm[pc]];
stack_top[0]=new_val; stack_top[0]=new_val;
return; return;
} }
inline void nasal_vm::opr_mulc() inline void nasal_vm::opr_mulc()
{ {
nasal_val* new_val=gc.gc_alloc(vm_num); nasal_val* new_val=gc.gc_alloc(vm_num);
new_val->ptr.num=stack_top[0]->to_number()*gc.num_addrs[imm[pc]]->ptr.num; new_val->ptr.num=stack_top[0]->to_number()*num_table[imm[pc]];
stack_top[0]=new_val; stack_top[0]=new_val;
return; return;
} }
inline void nasal_vm::opr_divc() inline void nasal_vm::opr_divc()
{ {
nasal_val* new_val=gc.gc_alloc(vm_num); nasal_val* new_val=gc.gc_alloc(vm_num);
new_val->ptr.num=stack_top[0]->to_number()/gc.num_addrs[imm[pc]]->ptr.num; new_val->ptr.num=stack_top[0]->to_number()/num_table[imm[pc]];
stack_top[0]=new_val; stack_top[0]=new_val;
return; return;
} }
@ -385,28 +388,28 @@ inline void nasal_vm::opr_lnkeq()
inline void nasal_vm::opr_addeqc() inline void nasal_vm::opr_addeqc()
{ {
nasal_val* new_val=gc.gc_alloc(vm_num); nasal_val* new_val=gc.gc_alloc(vm_num);
new_val->ptr.num=mem_addr[0]->to_number()+gc.num_addrs[imm[pc]]->ptr.num; new_val->ptr.num=mem_addr[0]->to_number()+num_table[imm[pc]];
stack_top[0]=mem_addr[0]=new_val; stack_top[0]=mem_addr[0]=new_val;
return; return;
} }
inline void nasal_vm::opr_subeqc() inline void nasal_vm::opr_subeqc()
{ {
nasal_val* new_val=gc.gc_alloc(vm_num); nasal_val* new_val=gc.gc_alloc(vm_num);
new_val->ptr.num=mem_addr[0]->to_number()-gc.num_addrs[imm[pc]]->ptr.num; new_val->ptr.num=mem_addr[0]->to_number()-num_table[imm[pc]];
stack_top[0]=mem_addr[0]=new_val; stack_top[0]=mem_addr[0]=new_val;
return; return;
} }
inline void nasal_vm::opr_muleqc() inline void nasal_vm::opr_muleqc()
{ {
nasal_val* new_val=gc.gc_alloc(vm_num); nasal_val* new_val=gc.gc_alloc(vm_num);
new_val->ptr.num=mem_addr[0]->to_number()*gc.num_addrs[imm[pc]]->ptr.num; new_val->ptr.num=mem_addr[0]->to_number()*num_table[imm[pc]];
stack_top[0]=mem_addr[0]=new_val; stack_top[0]=mem_addr[0]=new_val;
return; return;
} }
inline void nasal_vm::opr_diveqc() inline void nasal_vm::opr_diveqc()
{ {
nasal_val* new_val=gc.gc_alloc(vm_num); nasal_val* new_val=gc.gc_alloc(vm_num);
new_val->ptr.num=mem_addr[0]->to_number()/gc.num_addrs[imm[pc]]->ptr.num; new_val->ptr.num=mem_addr[0]->to_number()/num_table[imm[pc]];
stack_top[0]=mem_addr[0]=new_val; stack_top[0]=mem_addr[0]=new_val;
return; return;
} }
@ -480,22 +483,22 @@ inline void nasal_vm::opr_geq()
} }
inline void nasal_vm::opr_lessc() inline void nasal_vm::opr_lessc()
{ {
stack_top[0]=(stack_top[0]->to_number()<gc.num_addrs[imm[pc]]->ptr.num)?gc.one_addr:gc.zero_addr; stack_top[0]=(stack_top[0]->to_number()<num_table[imm[pc]])?gc.one_addr:gc.zero_addr;
return; return;
} }
inline void nasal_vm::opr_leqc() inline void nasal_vm::opr_leqc()
{ {
stack_top[0]=(stack_top[0]->to_number()<=gc.num_addrs[imm[pc]]->ptr.num)?gc.one_addr:gc.zero_addr; stack_top[0]=(stack_top[0]->to_number()<=num_table[imm[pc]])?gc.one_addr:gc.zero_addr;
return; return;
} }
inline void nasal_vm::opr_grtc() inline void nasal_vm::opr_grtc()
{ {
stack_top[0]=(stack_top[0]->to_number()>gc.num_addrs[imm[pc]]->ptr.num)?gc.one_addr:gc.zero_addr; stack_top[0]=(stack_top[0]->to_number()>num_table[imm[pc]])?gc.one_addr:gc.zero_addr;
return; return;
} }
inline void nasal_vm::opr_geqc() inline void nasal_vm::opr_geqc()
{ {
stack_top[0]=(stack_top[0]->to_number()>=gc.num_addrs[imm[pc]]->ptr.num)?gc.one_addr:gc.zero_addr; stack_top[0]=(stack_top[0]->to_number()>=num_table[imm[pc]])?gc.one_addr:gc.zero_addr;
return; return;
} }
inline void nasal_vm::opr_pop() inline void nasal_vm::opr_pop()
@ -734,32 +737,36 @@ inline void nasal_vm::opr_callb()
} }
inline void nasal_vm::opr_slcbegin() inline void nasal_vm::opr_slcbegin()
{ {
gc.slice_stack.push_back(gc.gc_alloc(vm_vec)); // | slice_vector | <-- stack_top[0]
if(stack_top[0]->type!=vm_vec) // ----------------
// | resource_vec | <-- stack_top[-1]
// ----------------
(++stack_top)[0]=gc.gc_alloc(vm_vec);
if(stack_top[-1]->type!=vm_vec)
die("slcbegin: must slice a vector"); die("slcbegin: must slice a vector");
return; return;
} }
inline void nasal_vm::opr_slcend() inline void nasal_vm::opr_slcend()
{ {
stack_top[0]=gc.slice_stack.back(); stack_top[-1]=stack_top[0];
gc.slice_stack.pop_back(); --stack_top;
return; return;
} }
inline void nasal_vm::opr_slc() inline void nasal_vm::opr_slc()
{ {
nasal_val* val=(stack_top--)[0]; nasal_val* val=(stack_top--)[0];
nasal_val* res=stack_top[0]->ptr.vec->get_val(val->to_number()); nasal_val* res=stack_top[-1]->ptr.vec->get_val(val->to_number());
if(!res) if(!res)
die("slc: index out of range:"+num2str(val->to_number())); die("slc: index out of range:"+num2str(val->to_number()));
gc.slice_stack.back()->ptr.vec->elems.push_back(res); stack_top[0]->ptr.vec->elems.push_back(res);
return; return;
} }
inline void nasal_vm::opr_slc2() inline void nasal_vm::opr_slc2()
{ {
nasal_val* val2=(stack_top--)[0]; nasal_val* val2=(stack_top--)[0];
nasal_val* val1=(stack_top--)[0]; nasal_val* val1=(stack_top--)[0];
std::vector<nasal_val*>& ref=stack_top[0]->ptr.vec->elems; std::vector<nasal_val*>& ref=stack_top[-1]->ptr.vec->elems;
std::vector<nasal_val*>& aim=gc.slice_stack.back()->ptr.vec->elems; std::vector<nasal_val*>& aim=stack_top[0]->ptr.vec->elems;
int type1=val1->type,type2=val2->type; int type1=val1->type,type2=val2->type;
int num1=val1->to_number(); int num1=val1->to_number();
@ -865,7 +872,7 @@ inline void nasal_vm::opr_ret()
} }
void nasal_vm::run(std::vector<opcode>& exec) void nasal_vm::run(std::vector<opcode>& exec)
{ {
// int count[op_ret]={0}; // int count[op_ret+1]={0};
void* opr_table[]= void* opr_table[]=
{ {
&&nop, &&intg, &&intl, &&offset, &&nop, &&intg, &&intl, &&offset,
@ -895,12 +902,13 @@ void nasal_vm::run(std::vector<opcode>& exec)
imm.push_back(i.num); imm.push_back(i.num);
} }
nasal_val** canary=gc.val_stack+STACK_MAX_DEPTH-1;
clock_t begin=clock(); clock_t begin=clock();
pc=0; pc=0;
goto *code[pc]; goto *code[pc];
nop: nop:
if(gc.val_stack[STACK_MAX_DEPTH-1]&&gc.val_stack[STACK_MAX_DEPTH-1]!=(nasal_val*)0xffff) if(canary[0] && canary[0]!=(nasal_val*)0xffff)
std::cout<<">> [vm] stack overflow.\n"; std::cout<<">> [vm] stack overflow.\n";
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
@ -917,7 +925,7 @@ nop:
// count[index]=0; // count[index]=0;
// } // }
return; return;
#define exec_operand(op,num) {op();/*++count[num];*/if(!gc.val_stack[STACK_MAX_DEPTH-1])goto *code[++pc];goto nop;} #define exec_operand(op,num) {op();/*++count[num];*/if(!canary[0])goto *code[++pc];goto nop;}
intg: exec_operand(opr_intg ,1); intg: exec_operand(opr_intg ,1);
intl: exec_operand(opr_intl ,2); intl: exec_operand(opr_intl ,2);
offset: exec_operand(opr_offset ,3); offset: exec_operand(opr_offset ,3);