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

gc changed to mark-sweep

This commit is contained in:
Valk Richard Li 2021-03-27 01:08:05 +08:00
parent 569d5c6c6a
commit 144e6f45da
15 changed files with 1678 additions and 2000 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -342,7 +342,7 @@ struct FUNC_TABLE
nasal_val* (*func_pointer)(nasal_val* x,nasal_gc& gc);
} builtin_func_table[]=
{
{"nasal_call_builtin_std_cout",builtin_print},
{"__builtin_std_cout",builtin_print},
{"",NULL}
};
```

84
lib.nas
View File

@ -1,157 +1,157 @@
var import=func(filename)
{
nasal_call_import(filename);
__builtin_import(filename);
return nil;
}
var print=func(elements...)
{
nasal_call_builtin_std_cout(elements);
__builtin_std_cout(elements);
return nil;
};
var println=func(elements...)
{
nasal_call_builtin_std_cout(elements);
__builtin_std_cout(elements);
print('\n');
return nil;
}
var append=func(vector,elements...)
{
nasal_call_builtin_push_back(vector,elements);
__builtin_push_back(vector,elements);
return nil;
}
var setsize=func(vector,size)
{
nasal_call_builtin_set_size(vector,size);
__builtin_set_size(vector,size);
return nil;
}
var system=func(str)
{
nasal_call_builtin_system(str);
__builtin_system(str);
return;
}
var input=func()
{
return nasal_call_builtin_input();
return __builtin_input();
}
var sleep=func(duration)
{
nasal_call_builtin_sleep(duration);
__builtin_sleep(duration);
return;
}
var split=func(delimeter,string)
{
return nasal_call_builtin_split(delimeter,string);
return __builtin_split(delimeter,string);
}
var rand=func(seed=nil)
{
return nasal_call_builtin_rand(seed);
return __builtin_rand(seed);
}
var id=func(thing)
{
return nasal_call_builtin_get_id(thing);
return __builtin_get_id(thing);
}
var int=func(value)
{
return nasal_call_builtin_trans_int(value);
return __builtin_int(value);
}
var num=func(value)
{
return nasal_call_builtin_trans_num(value);
return __builtin_num(value);
}
var pop=func(vector)
{
return nasal_call_builtin_pop_back(vector);
return __builtin_pop_back(vector);
}
var str=func(number)
{
return nasal_call_builtin_trans_str(number);
return __builtin_str(number);
}
var size=func(object)
{
return nasal_call_builtin_size(object);
return __builtin_size(object);
}
var contains=func(hash,key)
{
return nasal_call_builtin_contains(hash,key);
return __builtin_contains(hash,key);
}
var delete=func(hash,key)
{
nasal_call_builtin_delete(hash,key);
__builtin_delete(hash,key);
return;
}
var keys=func(hash)
{
return nasal_call_builtin_get_keys(hash);
return __builtin_get_keys(hash);
}
var time=func(begin_time)
{
return nasal_call_builtin_time(begin_time);
return __builtin_time(begin_time);
}
var die=func(str)
{
nasal_call_builtin_die(str);
__builtin_die(str);
return nil;
}
var typeof=func(object)
{
return nasal_call_builtin_type(object);
return __builtin_type(object);
}
var substr=func(str,begin,length)
{
return nasal_call_builtin_substr(str,begin,length);
return __builtin_substr(str,begin,length);
}
var streq=func(a,b)
{
return nasal_call_builtin_streq(a,b);
return __builtin_streq(a,b);
}
var left=func(string,length)
{
return nasal_call_builtin_left(string,length);
return __builtin_left(string,length);
}
var right=func(string,length)
{
return nasal_call_builtin_right(string,length);
return __builtin_right(string,length);
}
var cmp=func(a,b)
{
return nasal_call_builtin_cmp(a,b);
return __builtin_cmp(a,b);
}
var chr=func(code) #//Unlike in FG, this chr does not support Extended ASCII
{
return nasal_call_builtin_chr(code);
return __builtin_chr(code);
}
var io=
{
fin:func(filename)
{
return nasal_call_builtin_finput(filename);
return __builtin_fin(filename);
},
fout:func(filename,str)
{
nasal_call_builtin_foutput(filename,str);
__builtin_fout(filename,str);
return;
}
};
var bits=
{
bitxor: func(a,b){return nasal_call_builtin_xor(a,b); },
bitand: func(a,b){return nasal_call_builtin_and(a,b); },
bitor: func(a,b){return nasal_call_builtin_or(a,b); },
bitnand: func(a,b){return nasal_call_builtin_nand(a,b);},
bitnot: func(a) {return nasal_call_builtin_not(a); }
bitxor: func(a,b){return __builtin_xor(a,b); },
bitand: func(a,b){return __builtin_and(a,b); },
bitor: func(a,b){return __builtin_or(a,b); },
bitnand: func(a,b){return __builtin_nand(a,b);},
bitnot: func(a) {return __builtin_not(a); }
};
var math=
{
e: 2.7182818284590452354,
pi: 3.14159265358979323846264338327950288,
sin: func(x) {return nasal_call_builtin_sin(x); },
cos: func(x) {return nasal_call_builtin_cos(x); },
tan: func(x) {return nasal_call_builtin_tan(x); },
exp: func(x) {return nasal_call_builtin_exp(x); },
ln: func(x) {return nasal_call_builtin_cpp_math_ln(x); },
sqrt: func(x) {return nasal_call_builtin_cpp_math_sqrt(x);},
atan2: func(x,y){return nasal_call_builtin_cpp_atan2(x,y); }
sin: func(x) {return __builtin_sin(x); },
cos: func(x) {return __builtin_cos(x); },
tan: func(x) {return __builtin_tan(x); },
exp: func(x) {return __builtin_exp(x); },
ln: func(x) {return __builtin_ln(x); },
sqrt: func(x) {return __builtin_sqrt(x); },
atan2: func(x,y){return __builtin_atan2(x,y);}
};

24
main.cpp
View File

@ -10,15 +10,15 @@ nasal_vm vm;
void help()
{
std::cout
<<">> [\"file\"] input a file name.\n"
<<">> [help ] show help.\n"
<<">> [clear ] clear the screen.\n"
<<">> [lex ] use lexer to turn code into tokens.\n"
<<">> [\"file\"] input a file name. \n"
<<">> [help ] show help. \n"
<<">> [clear ] clear the screen. \n"
<<">> [lex ] use lexer to turn code into tokens. \n"
<<">> [ast ] do parsing and check the abstract syntax tree.\n"
<<">> [code ] show byte code.\n"
<<">> [exec ] execute program on bytecode vm.\n"
<<">> [logo ] print logo of nasal .\n"
<<">> [exit ] quit nasal interpreter.\n";
<<">> [code ] show byte code. \n"
<<">> [exec ] execute program on bytecode vm. \n"
<<">> [logo ] print logo of nasal . \n"
<<">> [exit ] quit nasal interpreter. \n";
return;
}
@ -90,11 +90,13 @@ void execute(std::string& command)
codegen.print_byte_code();
return;
}
vm.run(
codegen.get_string_table(),
codegen.get_number_table(),
vm.init(
codegen.get_str_table(),
codegen.get_num_table(),
codegen.get_exec_code()
);
vm.run();
vm.clear();
return;
}

13
nasal.h
View File

@ -25,7 +25,7 @@
check if a string can be converted to a number
if this string cannot be converted to a number,it will return nan
*/
inline double hex_to_double(std::string str)
inline double hex_to_double(std::string& str)
{
double ret=0;
for(int i=2;str[i];++i)
@ -42,7 +42,7 @@ inline double hex_to_double(std::string str)
}
return ret;
}
inline double oct_to_double(std::string str)
inline double oct_to_double(std::string& str)
{
double ret=0;
for(int i=2;str[i];++i)
@ -55,7 +55,7 @@ inline double oct_to_double(std::string str)
}
return ret;
}
inline double dec_to_double(std::string str,int len)
inline double dec_to_double(std::string& str,int len)
{
double ret=0;
int i=0;
@ -96,14 +96,13 @@ inline double dec_to_double(std::string str,int len)
}
double trans_string_to_number(std::string str)
{
double is_negative=1;
bool is_negative=false;
int len=str.length();
double ret_num=0;
if(!len) return std::nan("");
if(str[0]=='-' || str[0]=='+')
{
if(len==1) return std::nan("");
is_negative=(str[0]=='-'?-1:1);
is_negative=(str[0]=='-');
str=str.substr(1,len--);
}
if(len>1 && str[0]=='0' && str[1]=='x')
@ -112,7 +111,7 @@ double trans_string_to_number(std::string str)
ret_num=oct_to_double(str);
else
ret_num=dec_to_double(str,len);
return is_negative*ret_num;
return is_negative?-ret_num:ret_num;
}
/*

72
nasal_ast.h
View File

@ -3,7 +3,9 @@
enum ast_node
{
ast_null=0,ast_root,ast_block,
ast_null=0,
ast_root,
ast_block,
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_args,ast_default_arg,ast_dynamic_id,
@ -116,68 +118,68 @@ public:
nasal_ast::nasal_ast(int init_line=0,int init_type=ast_null)
{
this->line=init_line;
this->type=init_type;
line=init_line;
type=init_type;
return;
}
nasal_ast::nasal_ast(const nasal_ast& tmp)
{
this->line=tmp.line;
this->type=tmp.type;
this->str=tmp.str;
this->num=tmp.num;
this->children=tmp.children;
line=tmp.line;
type=tmp.type;
str=tmp.str;
num=tmp.num;
children=tmp.children;
return;
}
nasal_ast::~nasal_ast()
{
this->children.clear();
children.clear();
return;
}
nasal_ast& nasal_ast::operator=(const nasal_ast& tmp)
{
this->line=tmp.line;
this->type=tmp.type;
this->str=tmp.str;
this->num=tmp.num;
this->children=tmp.children;
line=tmp.line;
type=tmp.type;
str=tmp.str;
num=tmp.num;
children=tmp.children;
return *this;
}
void nasal_ast::clear()
{
this->line=0;
this->str="";
this->num=0;
this->type=ast_null;
this->children.clear();
line=0;
str="";
num=0;
type=ast_null;
children.clear();
return;
}
void nasal_ast::set_line(int l)
{
this->line=l;
line=l;
return;
}
void nasal_ast::set_type(int t)
{
this->type=t;
type=t;
return;
}
void nasal_ast::set_str(std::string& s)
{
this->str=s;
str=s;
return;
}
void nasal_ast::set_num(double n)
{
this->num=n;
num=n;
return;
}
@ -189,43 +191,43 @@ void nasal_ast::add_child(nasal_ast ast)
int nasal_ast::get_line()
{
return this->line;
return line;
}
int nasal_ast::get_type()
{
return this->type;
return type;
}
std::string nasal_ast::get_str()
{
return this->str;
return str;
}
double nasal_ast::get_num()
{
return this->num;
return num;
}
std::vector<nasal_ast>& nasal_ast::get_children()
{
return this->children;
return children;
}
void nasal_ast::print_ast(int depth)
{
std::string indentation="";
for(int i=0;i<depth;++i) indentation+="| ";
indentation+=ast_name(this->type);
indentation+=ast_name(type);
std::cout<<indentation;
if(this->type==ast_str || this->type==ast_id || this->type==ast_dynamic_id || this->type==ast_callh)
std::cout<<":"<<this->str;
else if(this->type==ast_num)
std::cout<<":"<<this->num;
if(type==ast_str || type==ast_id || type==ast_dynamic_id || type==ast_callh)
std::cout<<":"<<str;
else if(type==ast_num)
std::cout<<":"<<num;
std::cout<<'\n';
int child_size=this->children.size();
int child_size=children.size();
for(int i=0;i<child_size;++i)
this->children[i].print_ast(depth+1);
children[i].print_ast(depth+1);
return;
}

812
nasal_builtin.h
View File

File diff suppressed because it is too large Load Diff

476
nasal_codegen.h
View File

@ -5,40 +5,62 @@ enum op_code
{
op_nop,
op_load,// load value in value_stack to identifier
op_pushnum,
op_pushone,
op_pushzero,
op_pushnil,
op_pushstr,
op_newvec,op_newhash,op_newfunc,
op_vecapp,op_hashapp,
op_para,op_defpara,op_dynpara,
op_unot,op_usub,
op_add,op_sub,op_mul,op_div,op_lnk,
op_addeq,op_subeq,op_muleq,op_diveq,op_lnkeq,op_meq,
op_eq,op_neq,op_less,op_leq,op_grt,op_geq,
op_loadg,
op_loadl,
op_pnum,
op_pone,
op_pzero,
op_pnil,
op_pstr,
op_newv,
op_newh,
op_newf,
op_vapp,
op_happ,
op_para,
op_defpara,
op_dynpara,
op_unot,
op_usub,
op_add,
op_sub,
op_mul,
op_div,
op_lnk,
op_addeq,
op_subeq,
op_muleq,
op_diveq,
op_lnkeq,
op_meq,
op_eq,
op_neq,
op_less,
op_leq,
op_grt,
op_geq,
op_pop,
op_jmp, // jump with no condition
op_jmptrue, // used in operator and/or,jmp when condition is true and DO NOT POP
op_jmpfalse, // used in conditional/loop,jmp when condition is false and POP STACK
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_counter, // add counter for forindex/foreach
op_cntpop, // pop counter
op_forindex, // index counter on the top of forindex_stack plus 1
op_foreach, // index counter on the top of forindex_stack plus 1 and get the value in vector
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_call, // call identifier
op_callv, // call vec[index]
op_callvi, // call vec[immediate] (used in multi-assign/multi-define)
op_callh, // call hash.label
op_callf, // call function(parameters)
op_builtincall,// call builtin-function
op_slicebegin, // begin of slice like: vec[1,2,3:6,0,-1]
op_sliceend, // end of slice
op_slice, // slice like vec[1]
op_slice2, // slice like vec[nil:10]
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_mcall, // get memory of identifier
op_mcallv, // get memory of vec[index]
op_mcallh, // get memory of hash.label
op_return // return
op_ret // return
};
struct
@ -49,18 +71,20 @@ struct
{
{op_nop, "nop "},
{op_load, "load "},
{op_pushnum, "pnum "},
{op_pushone, "pone "},
{op_pushzero, "pzero "},
{op_pushnil, "pnil "},
{op_pushstr, "pstr "},
{op_newvec, "newv "},
{op_newhash, "newh "},
{op_newfunc, "newf "},
{op_vecapp, "vapp "},
{op_hashapp, "happ "},
{op_loadg, "loadg "},
{op_loadl, "loadl "},
{op_pnum, "pnum "},
{op_pone, "pone "},
{op_pzero, "pzero "},
{op_pnil, "pnil "},
{op_pstr, "pstr "},
{op_newv, "newv "},
{op_newh, "newh "},
{op_newf, "newf "},
{op_vapp, "vapp "},
{op_happ, "happ "},
{op_para, "para "},
{op_defpara, "deflt "},
{op_defpara, "def "},
{op_dynpara, "dyn "},
{op_unot, "not "},
{op_usub, "usub "},
@ -74,7 +98,7 @@ struct
{op_muleq, "muleq "},
{op_diveq, "diveq "},
{op_lnkeq, "linkeq"},
{op_meq, "memeq "},
{op_meq, "meq "},
{op_eq, "eq "},
{op_neq, "neq "},
{op_less, "less "},
@ -83,43 +107,43 @@ struct
{op_geq, "geq "},
{op_pop, "pop "},
{op_jmp, "jmp "},
{op_jmptrue, "jt "},
{op_jmpfalse, "jf "},
{op_jt, "jt "},
{op_jf, "jf "},
{op_counter, "cnt "},
{op_cntpop, "cntpop"},
{op_forindex, "findx "},
{op_foreach, "feach "},
{op_findex, "findx "},
{op_feach, "feach "},
{op_call, "call "},
{op_callv, "callv "},
{op_callvi, "callvi"},
{op_callh, "callh "},
{op_callf, "callf "},
{op_builtincall, "callb "},
{op_slicebegin, "slcbeg"},
{op_sliceend, "slcend"},
{op_slice, "slc "},
{op_slice2, "slc2 "},
{op_callb, "callb "},
{op_slcbegin, "slcbeg"},
{op_slcend, "slcend"},
{op_slc, "slc "},
{op_slc2, "slc2 "},
{op_mcall, "mcall "},
{op_mcallv, "mcallv"},
{op_mcallh, "mcallh"},
{op_return, "ret "},
{op_ret, "ret "},
{-1, NULL },
};
struct opcode
{
unsigned char op;
unsigned int index;
opcode(unsigned char _op=op_nop,unsigned int _index=0)
unsigned int num;
opcode(unsigned char _op=op_nop,unsigned int _num=0)
{
op=_op;
index=_index;
num=_num;
return;
}
opcode& operator=(const opcode& tmp)
{
op=tmp.op;
index=tmp.index;
num=tmp.num;
return *this;
}
};
@ -127,39 +151,40 @@ struct opcode
class nasal_codegen
{
private:
std::unordered_map<double,int> number_table;
std::unordered_map<std::string,int> string_table;
std::vector<double> number_result_table;
std::vector<std::string> string_result_table;
std::vector<opcode> exec_code;
std::list<std::vector<int> > continue_ptr;
std::list<std::vector<int> > break_ptr;
int error;
int in_forindex;
int in_foreach;
std::unordered_map<double,int> number_table;
std::unordered_map<std::string,int> string_table;
std::vector<double> num_res_table;
std::vector<std::string> str_res_table;
std::vector<opcode> exec_code;
std::list<std::vector<int> > continue_ptr;
std::list<std::vector<int> > break_ptr;
void regist_number(double);
void regist_string(std::string);
void gen(unsigned char,unsigned int);
void pop_gen();
void nil_gen();
void number_gen(nasal_ast&);
void string_gen(nasal_ast&);
void vector_gen(nasal_ast&);
void num_gen(nasal_ast&);
void str_gen(nasal_ast&);
void vec_gen(nasal_ast&);
void hash_gen(nasal_ast&);
void function_gen(nasal_ast&);
void func_gen(nasal_ast&);
void call_gen(nasal_ast&);
void call_id(nasal_ast&);
void call_hash(nasal_ast&);
void call_vec(nasal_ast&);
void call_func(nasal_ast&);
void mem_call(nasal_ast&);
void mem_call_id(nasal_ast&);
void mem_call_vec(nasal_ast&);
void mem_call_hash(nasal_ast&);
void mcall(nasal_ast&);
void mcall_id(nasal_ast&);
void mcall_vec(nasal_ast&);
void mcall_hash(nasal_ast&);
void multi_def(nasal_ast&);
void single_def(nasal_ast&);
void definition_gen(nasal_ast&);
void multi_assignment_gen(nasal_ast&);
void def_gen(nasal_ast&);
void multi_assign_gen(nasal_ast&);
void conditional_gen(nasal_ast&);
void loop_gen(nasal_ast&);
void load_continue_break(int,int);
@ -170,16 +195,16 @@ private:
void or_gen(nasal_ast&);
void and_gen(nasal_ast&);
void trino_gen(nasal_ast&);
void calculation_gen(nasal_ast&);
void calc_gen(nasal_ast&);
void block_gen(nasal_ast&);
void return_gen(nasal_ast&);
void ret_gen(nasal_ast&);
public:
nasal_codegen();
void main_progress(nasal_ast&);
void print_op(int);
void print_byte_code();
std::vector<std::string>& get_string_table();
std::vector<double>& get_number_table();
std::vector<std::string>& get_str_table();
std::vector<double>& get_num_table();
std::vector<opcode>& get_exec_code();
};
@ -223,40 +248,40 @@ void nasal_codegen::pop_gen()
void nasal_codegen::nil_gen()
{
opcode op(op_pushnil,0);
opcode op(op_pnil,0);
exec_code.push_back(op);
return;
}
void nasal_codegen::number_gen(nasal_ast& ast)
void nasal_codegen::num_gen(nasal_ast& ast)
{
double num=ast.get_num();
if(num==1) gen(op_pushone,0);
else if(num==0) gen(op_pushzero,0);
if(num==1) gen(op_pone,0);
else if(num==0) gen(op_pzero,0);
else
{
regist_number(num);
gen(op_pushnum,number_table[num]);
gen(op_pnum,number_table[num]);
}
return;
}
void nasal_codegen::string_gen(nasal_ast& ast)
void nasal_codegen::str_gen(nasal_ast& ast)
{
std::string str=ast.get_str();
regist_string(str);
gen(op_pushstr,string_table[str]);
gen(op_pstr,string_table[str]);
return;
}
void nasal_codegen::vector_gen(nasal_ast& ast)
void nasal_codegen::vec_gen(nasal_ast& ast)
{
int size=ast.get_children().size();
gen(op_newvec,0);
gen(op_newv,0);
for(int i=0;i<size;++i)
{
calculation_gen(ast.get_children()[i]);
gen(op_vecapp,0);
calc_gen(ast.get_children()[i]);
gen(op_vapp,0);
}
return;
}
@ -264,21 +289,21 @@ void nasal_codegen::vector_gen(nasal_ast& ast)
void nasal_codegen::hash_gen(nasal_ast& ast)
{
int size=ast.get_children().size();
gen(op_newhash,0);
gen(op_newh,0);
for(int i=0;i<size;++i)
{
calculation_gen(ast.get_children()[i].get_children()[1]);
calc_gen(ast.get_children()[i].get_children()[1]);
std::string str=ast.get_children()[i].get_children()[0].get_str();
regist_string(str);
gen(op_hashapp,string_table[str]);
gen(op_happ,string_table[str]);
}
return;
}
void nasal_codegen::function_gen(nasal_ast& ast)
void nasal_codegen::func_gen(nasal_ast& ast)
{
int newfunc_label=exec_code.size();
gen(op_newfunc,0);
gen(op_newf,0);
nasal_ast& ref_arg=ast.get_children()[0];
int arg_size=ref_arg.get_children().size();
@ -293,7 +318,7 @@ void nasal_codegen::function_gen(nasal_ast& ast)
}
else if(tmp.get_type()==ast_default_arg)
{
calculation_gen(tmp.get_children()[1]);
calc_gen(tmp.get_children()[1]);
std::string str=tmp.get_children()[0].get_str();
regist_string(str);
gen(op_defpara,string_table[str]);
@ -305,7 +330,7 @@ void nasal_codegen::function_gen(nasal_ast& ast)
gen(op_dynpara,string_table[str]);
}
}
exec_code[newfunc_label].index=exec_code.size()+1;
exec_code[newfunc_label].num=exec_code.size()+1;
int ptr=exec_code.size();
gen(op_jmp,0);
nasal_ast& block=ast.get_children()[1];
@ -313,16 +338,16 @@ void nasal_codegen::function_gen(nasal_ast& ast)
if(!block.get_children().size() || block.get_children().back().get_type()!=ast_return)
{
nil_gen();
gen(op_return,0);
gen(op_ret,0);
}
exec_code[ptr].index=exec_code.size();
exec_code[ptr].num=exec_code.size();
return;
}
void nasal_codegen::call_gen(nasal_ast& ast)
{
calculation_gen(ast.get_children()[0]);
if(exec_code.back().op==op_builtincall)
calc_gen(ast.get_children()[0]);
if(exec_code.back().op==op_callb)
return;
int child_size=ast.get_children().size();
for(int i=1;i<child_size;++i)
@ -342,10 +367,10 @@ void nasal_codegen::call_id(nasal_ast& ast)
{
std::string str=ast.get_str();
regist_string(str);
for(int i=0;builtin_func_table[i].func_pointer;++i)
if(builtin_func_table[i].func_name==str)
for(int i=0;builtin_func[i].func;++i)
if(builtin_func[i].name==str)
{
gen(op_builtincall,i);
gen(op_callb,i);
return;
}
gen(op_call,string_table[str]);
@ -364,62 +389,62 @@ void nasal_codegen::call_vec(nasal_ast& ast)
{
if(ast.get_children().size()==1 && ast.get_children()[0].get_type()!=ast_subvec)
{
calculation_gen(ast.get_children()[0]);
calc_gen(ast.get_children()[0]);
gen(op_callv,0);
return;
}
gen(op_slicebegin,0);
gen(op_slcbegin,0);
int size=ast.get_children().size();
for(int i=0;i<size;++i)
{
nasal_ast& tmp=ast.get_children()[i];
if(tmp.get_type()!=ast_subvec)
{
calculation_gen(tmp);
gen(op_slice,0);
calc_gen(tmp);
gen(op_slc,0);
}
else
{
calculation_gen(tmp.get_children()[0]);
calculation_gen(tmp.get_children()[1]);
gen(op_slice2,0);
calc_gen(tmp.get_children()[0]);
calc_gen(tmp.get_children()[1]);
gen(op_slc2,0);
}
}
gen(op_sliceend,0);
gen(op_slcend,0);
return;
}
void nasal_codegen::call_func(nasal_ast& ast)
{
if(!ast.get_children().size())
gen(op_newvec,0);
gen(op_newv,0);
else if(ast.get_children()[0].get_type()==ast_hashmember)
hash_gen(ast);
else
vector_gen(ast);
vec_gen(ast);
gen(op_callf,0);
return;
}
void nasal_codegen::mem_call(nasal_ast& ast)
void nasal_codegen::mcall(nasal_ast& ast)
{
if(ast.get_type()==ast_id)
mem_call_id(ast);
mcall_id(ast);
else
mem_call_id(ast.get_children()[0]);
mcall_id(ast.get_children()[0]);
int child_size=ast.get_children().size();
for(int i=1;i<child_size;++i)
{
nasal_ast& tmp=ast.get_children()[i];
if(tmp.get_type()==ast_callh)
mem_call_hash(tmp);
mcall_hash(tmp);
else if(tmp.get_type()==ast_callv)
mem_call_vec(tmp);
mcall_vec(tmp);
}
return;
}
void nasal_codegen::mem_call_id(nasal_ast& ast)
void nasal_codegen::mcall_id(nasal_ast& ast)
{
std::string str=ast.get_str();
regist_string(str);
@ -427,14 +452,14 @@ void nasal_codegen::mem_call_id(nasal_ast& ast)
return;
}
void nasal_codegen::mem_call_vec(nasal_ast& ast)
void nasal_codegen::mcall_vec(nasal_ast& ast)
{
calculation_gen(ast.get_children()[0]);
calc_gen(ast.get_children()[0]);
gen(op_mcallv,0);
return;
}
void nasal_codegen::mem_call_hash(nasal_ast& ast)
void nasal_codegen::mcall_hash(nasal_ast& ast)
{
std::string str=ast.get_str();
regist_string(str);
@ -444,7 +469,7 @@ void nasal_codegen::mem_call_hash(nasal_ast& ast)
void nasal_codegen::single_def(nasal_ast& ast)
{
calculation_gen(ast.get_children()[1]);
calc_gen(ast.get_children()[1]);
std::string str=ast.get_children()[0].get_str();
regist_string(str);
gen(op_load,string_table[str]);
@ -457,7 +482,7 @@ void nasal_codegen::multi_def(nasal_ast& ast)
{
for(int i=0;i<size;++i)
{
calculation_gen(ast.get_children()[1].get_children()[i]);
calc_gen(ast.get_children()[1].get_children()[i]);
std::string str=ast.get_children()[0].get_children()[i].get_str();
regist_string(str);
gen(op_load,string_table[str]);
@ -465,7 +490,7 @@ void nasal_codegen::multi_def(nasal_ast& ast)
}
else
{
calculation_gen(ast.get_children()[1]);
calc_gen(ast.get_children()[1]);
for(int i=0;i<size;++i)
{
gen(op_callvi,i);
@ -478,7 +503,7 @@ void nasal_codegen::multi_def(nasal_ast& ast)
return;
}
void nasal_codegen::definition_gen(nasal_ast& ast)
void nasal_codegen::def_gen(nasal_ast& ast)
{
if(ast.get_children()[0].get_type()==ast_id)
single_def(ast);
@ -487,27 +512,27 @@ void nasal_codegen::definition_gen(nasal_ast& ast)
return;
}
void nasal_codegen::multi_assignment_gen(nasal_ast& ast)
void nasal_codegen::multi_assign_gen(nasal_ast& ast)
{
int size=ast.get_children()[0].get_children().size();
if(ast.get_children()[1].get_type()==ast_multi_scalar)
{
for(int i=size-1;i>=0;--i)
calculation_gen(ast.get_children()[1].get_children()[i]);
calc_gen(ast.get_children()[1].get_children()[i]);
for(int i=0;i<size;++i)
{
mem_call(ast.get_children()[0].get_children()[i]);
mcall(ast.get_children()[0].get_children()[i]);
gen(op_meq,0);
pop_gen();
}
}
else
{
calculation_gen(ast.get_children()[1]);
calc_gen(ast.get_children()[1]);
for(int i=0;i<size;++i)
{
gen(op_callvi,i);
mem_call(ast.get_children()[0].get_children()[i]);
mcall(ast.get_children()[0].get_children()[i]);
gen(op_meq,0);
pop_gen();
}
@ -525,15 +550,15 @@ void nasal_codegen::conditional_gen(nasal_ast& ast)
nasal_ast& tmp=ast.get_children()[i];
if(tmp.get_type()==ast_if || tmp.get_type()==ast_elsif)
{
calculation_gen(tmp.get_children()[0]);
calc_gen(tmp.get_children()[0]);
int ptr=exec_code.size();
gen(op_jmpfalse,0);
gen(op_jf,0);
block_gen(tmp.get_children()[1]);
jmp_label.push_back(exec_code.size());
// without 'else' the last condition doesn't need to jmp
if(i!=size-1)
gen(op_jmp,0);
exec_code[ptr].index=exec_code.size();
exec_code[ptr].num=exec_code.size();
}
else
{
@ -542,7 +567,7 @@ void nasal_codegen::conditional_gen(nasal_ast& ast)
}
}
for(std::vector<int>::iterator i=jmp_label.begin();i!=jmp_label.end();++i)
exec_code[*i].index=exec_code.size();
exec_code[*i].num=exec_code.size();
return;
}
@ -564,9 +589,9 @@ void nasal_codegen::loop_gen(nasal_ast& ast)
void nasal_codegen::load_continue_break(int continue_place,int break_place)
{
for(int i=0;i<continue_ptr.front().size();++i)
exec_code[continue_ptr.front()[i]].index=continue_place;
exec_code[continue_ptr.front()[i]].num=continue_place;
for(int i=0;i<break_ptr.front().size();++i)
exec_code[break_ptr.front()[i]].index=break_place;
exec_code[break_ptr.front()[i]].num=break_place;
continue_ptr.pop_front();
break_ptr.pop_front();
return;
@ -575,13 +600,13 @@ void nasal_codegen::load_continue_break(int continue_place,int break_place)
void nasal_codegen::while_gen(nasal_ast& ast)
{
int loop_ptr=exec_code.size();
calculation_gen(ast.get_children()[0]);
calc_gen(ast.get_children()[0]);
int condition_ptr=exec_code.size();
gen(op_jmpfalse,0);
gen(op_jf,0);
block_gen(ast.get_children()[1]);
gen(op_jmp,loop_ptr);
exec_code[condition_ptr].index=exec_code.size();
exec_code[condition_ptr].num=exec_code.size();
load_continue_break(exec_code.size()-1,exec_code.size());
return;
}
@ -592,32 +617,51 @@ void nasal_codegen::for_gen(nasal_ast& ast)
switch(ast.get_children()[0].get_type())
{
case ast_null:break;
case ast_definition:definition_gen(ast.get_children()[0]);break;
case ast_multi_assign:multi_assignment_gen(ast.get_children()[0]);break;
case ast_nil:case ast_num:case ast_str:case ast_func:break;
case ast_vec:case ast_hash:
case ast_definition:def_gen(ast.get_children()[0]);break;
case ast_multi_assign:multi_assign_gen(ast.get_children()[0]);break;
case ast_nil:
case ast_num:
case ast_str:
case ast_func:break;
case ast_vec:
case ast_hash:
case ast_call:
case ast_equal:case ast_addeq:case ast_subeq:case ast_multeq:case ast_diveq:case ast_lnkeq:
case ast_neg:case ast_not:
case ast_add:case ast_sub:case ast_mult:case ast_div:case ast_link:
case ast_cmpeq:case ast_neq:case ast_leq:case ast_less:case ast_geq:case ast_grt:
case ast_trino:calculation_gen(ast.get_children()[0]);pop_gen();break;
case ast_equal:
case ast_addeq:
case ast_subeq:
case ast_multeq:
case ast_diveq:
case ast_lnkeq:
case ast_neg:
case ast_not:
case ast_add:
case ast_sub:
case ast_mult:
case ast_div:
case ast_link:
case ast_cmpeq:
case ast_neq:
case ast_leq:
case ast_less:
case ast_geq:
case ast_grt:
case ast_trino:calc_gen(ast.get_children()[0]);pop_gen();break;
}
int jmp_place=exec_code.size();
if(ast.get_children()[1].get_type()==ast_null)
gen(op_pushone,0);
gen(op_pone,0);
else
calculation_gen(ast.get_children()[1]);
calc_gen(ast.get_children()[1]);
int label_exit=exec_code.size();
gen(op_jmpfalse,0);
gen(op_jf,0);
block_gen(ast.get_children()[3]);
int continue_place=exec_code.size();
switch(ast.get_children()[2].get_type())
{
case ast_null:break;
case ast_definition:definition_gen(ast.get_children()[2]);break;
case ast_multi_assign:multi_assignment_gen(ast.get_children()[2]);break;
case ast_definition:def_gen(ast.get_children()[2]);break;
case ast_multi_assign:multi_assign_gen(ast.get_children()[2]);break;
case ast_nil:case ast_num:case ast_str:case ast_func:break;
case ast_vec:case ast_hash:
case ast_call:
@ -625,20 +669,20 @@ void nasal_codegen::for_gen(nasal_ast& ast)
case ast_neg:case ast_not:
case ast_add:case ast_sub:case ast_mult:case ast_div:case ast_link:
case ast_cmpeq:case ast_neq:case ast_leq:case ast_less:case ast_geq:case ast_grt:
case ast_trino:calculation_gen(ast.get_children()[2]);pop_gen();break;
case ast_trino:calc_gen(ast.get_children()[2]);pop_gen();break;
}
gen(op_jmp,jmp_place);
exec_code[label_exit].index=exec_code.size();
exec_code[label_exit].num=exec_code.size();
load_continue_break(continue_place,exec_code.size());
return;
}
void nasal_codegen::forindex_gen(nasal_ast& ast)
{
calculation_gen(ast.get_children()[1]);
calc_gen(ast.get_children()[1]);
gen(op_counter,0);
int ptr=exec_code.size();
gen(op_forindex,0);
gen(op_findex,0);
if(ast.get_children()[0].get_type()==ast_new_iter)
{
std::string str=ast.get_children()[0].get_children()[0].get_str();
@ -647,14 +691,14 @@ void nasal_codegen::forindex_gen(nasal_ast& ast)
}
else
{
mem_call(ast.get_children()[0]);
mcall(ast.get_children()[0]);
gen(op_meq,0);
pop_gen();
}
block_gen(ast.get_children()[2]);
gen(op_jmp,ptr);
exec_code[ptr].index=exec_code.size();
exec_code[ptr].num=exec_code.size();
load_continue_break(exec_code.size()-1,exec_code.size());
pop_gen();// pop vector
gen(op_cntpop,0);
@ -662,10 +706,10 @@ void nasal_codegen::forindex_gen(nasal_ast& ast)
}
void nasal_codegen::foreach_gen(nasal_ast& ast)
{
calculation_gen(ast.get_children()[1]);
calc_gen(ast.get_children()[1]);
gen(op_counter,0);
int ptr=exec_code.size();
gen(op_foreach,0);
gen(op_feach,0);
if(ast.get_children()[0].get_type()==ast_new_iter)
{
std::string str=ast.get_children()[0].get_children()[0].get_str();
@ -674,14 +718,14 @@ void nasal_codegen::foreach_gen(nasal_ast& ast)
}
else
{
mem_call(ast.get_children()[0]);
mcall(ast.get_children()[0]);
gen(op_meq,0);
pop_gen();
}
block_gen(ast.get_children()[2]);
gen(op_jmp,ptr);
exec_code[ptr].index=exec_code.size();
exec_code[ptr].num=exec_code.size();
load_continue_break(exec_code.size()-1,exec_code.size());
pop_gen();// pop vector
gen(op_cntpop,0);
@ -690,35 +734,35 @@ void nasal_codegen::foreach_gen(nasal_ast& ast)
void nasal_codegen::or_gen(nasal_ast& ast)
{
calculation_gen(ast.get_children()[0]);
calc_gen(ast.get_children()[0]);
int l1=exec_code.size();
gen(op_jmptrue,0);
gen(op_jt,0);
pop_gen();
calculation_gen(ast.get_children()[1]);
calc_gen(ast.get_children()[1]);
int l2=exec_code.size();
gen(op_jmptrue,0);
gen(op_jt,0);
pop_gen();
nil_gen();
exec_code[l1].index=exec_code[l2].index=exec_code.size();
exec_code[l1].num=exec_code[l2].num=exec_code.size();
return;
}
void nasal_codegen::and_gen(nasal_ast& ast)
{
calculation_gen(ast.get_children()[0]);
gen(op_jmptrue,exec_code.size()+2);
calc_gen(ast.get_children()[0]);
gen(op_jt,exec_code.size()+2);
int lfalse=exec_code.size();
gen(op_jmp,0);
pop_gen();// jt jumps here
calculation_gen(ast.get_children()[1]);
gen(op_jmptrue,exec_code.size()+3);
calc_gen(ast.get_children()[1]);
gen(op_jt,exec_code.size()+3);
exec_code[lfalse].index=exec_code.size();
exec_code[lfalse].num=exec_code.size();
pop_gen();
nil_gen();
//jt jumps here
@ -727,62 +771,62 @@ void nasal_codegen::and_gen(nasal_ast& ast)
void nasal_codegen::trino_gen(nasal_ast& ast)
{
calculation_gen(ast.get_children()[0]);
calc_gen(ast.get_children()[0]);
int lfalse=exec_code.size();
gen(op_jmpfalse,0);
calculation_gen(ast.get_children()[1]);
gen(op_jf,0);
calc_gen(ast.get_children()[1]);
int lexit=exec_code.size();
gen(op_jmp,0);
exec_code[lfalse].index=exec_code.size();
calculation_gen(ast.get_children()[2]);
exec_code[lexit].index=exec_code.size();
exec_code[lfalse].num=exec_code.size();
calc_gen(ast.get_children()[2]);
exec_code[lexit].num=exec_code.size();
return;
}
void nasal_codegen::calculation_gen(nasal_ast& ast)
void nasal_codegen::calc_gen(nasal_ast& ast)
{
switch(ast.get_type())
{
case ast_nil: nil_gen(); break;
case ast_num: number_gen(ast); break;
case ast_str: string_gen(ast); break;
case ast_num: num_gen(ast); break;
case ast_str: str_gen(ast); break;
case ast_id: call_id(ast); break;
case ast_vec: vector_gen(ast); break;
case ast_hash: hash_gen(ast); break;
case ast_func: function_gen(ast); break;
case ast_call: call_gen(ast); break;
case ast_vec: vec_gen(ast); break;
case ast_hash: hash_gen(ast);break;
case ast_func: func_gen(ast);break;
case ast_call: call_gen(ast);break;
case ast_equal:
calculation_gen(ast.get_children()[1]);
mem_call(ast.get_children()[0]);
calc_gen(ast.get_children()[1]);
mcall(ast.get_children()[0]);
gen(op_meq,0);
break;
// ast_addeq(22)~ast_lnkeq(26) op_addeq(23)~op_lnkeq(27)
case ast_addeq:case ast_subeq:case ast_multeq:case ast_diveq:case ast_lnkeq:
calculation_gen(ast.get_children()[1]);
mem_call(ast.get_children()[0]);
calc_gen(ast.get_children()[1]);
mcall(ast.get_children()[0]);
gen(ast.get_type()-ast_addeq+op_addeq,0);
break;
case ast_or:or_gen(ast);break;
case ast_and:and_gen(ast);break;
// ast_add(33)~ast_link(37) op_add(18)~op_lnk(22)
case ast_add:case ast_sub:case ast_mult:case ast_div:case ast_link:
calculation_gen(ast.get_children()[0]);
calculation_gen(ast.get_children()[1]);
calc_gen(ast.get_children()[0]);
calc_gen(ast.get_children()[1]);
gen(ast.get_type()-ast_add+op_add,0);
break;
// ast_cmpeq(27)~ast_geq(32) op_eq(29)~op_geq(34)
case ast_cmpeq:case ast_neq:case ast_less:case ast_leq:case ast_grt:case ast_geq:
calculation_gen(ast.get_children()[0]);
calculation_gen(ast.get_children()[1]);
calc_gen(ast.get_children()[0]);
calc_gen(ast.get_children()[1]);
gen(ast.get_type()-ast_cmpeq+op_eq,0);
break;
case ast_trino:trino_gen(ast);break;
case ast_neg:
calculation_gen(ast.get_children()[0]);
calc_gen(ast.get_children()[0]);
gen(op_usub,0);
break;
case ast_not:
calculation_gen(ast.get_children()[0]);
calc_gen(ast.get_children()[0]);
gen(op_unot,0);
break;
case ast_definition:
@ -802,8 +846,8 @@ void nasal_codegen::block_gen(nasal_ast& ast)
switch(tmp.get_type())
{
case ast_null:case ast_nil:case ast_num:case ast_str:case ast_func:break;
case ast_definition:definition_gen(tmp);break;
case ast_multi_assign:multi_assignment_gen(tmp);break;
case ast_definition:def_gen(tmp);break;
case ast_multi_assign:multi_assign_gen(tmp);break;
case ast_conditional:conditional_gen(tmp);break;
case ast_continue:
continue_ptr.front().push_back(exec_code.size());
@ -842,14 +886,14 @@ void nasal_codegen::block_gen(nasal_ast& ast)
case ast_grt:
case ast_or:
case ast_and:
case ast_trino:calculation_gen(tmp);pop_gen();break;
case ast_return:return_gen(tmp);break;
case ast_trino:calc_gen(tmp);pop_gen();break;
case ast_return:ret_gen(tmp);break;
}
}
return;
}
void nasal_codegen::return_gen(nasal_ast& ast)
void nasal_codegen::ret_gen(nasal_ast& ast)
{
for(int i=0;i<in_foreach;++i)
{
@ -862,10 +906,10 @@ void nasal_codegen::return_gen(nasal_ast& ast)
gen(op_cntpop,0);
}
if(ast.get_children().size())
calculation_gen(ast.get_children()[0]);
calc_gen(ast.get_children()[0]);
else
nil_gen();
gen(op_return,0);
gen(op_ret,0);
return;
}
@ -883,8 +927,8 @@ void nasal_codegen::main_progress(nasal_ast& ast)
switch(tmp.get_type())
{
case ast_null:case ast_nil:case ast_num:case ast_str:case ast_func:break;
case ast_definition:definition_gen(tmp);break;
case ast_multi_assign:multi_assignment_gen(tmp);break;
case ast_definition:def_gen(tmp);break;
case ast_multi_assign:multi_assign_gen(tmp);break;
case ast_conditional:conditional_gen(tmp);break;
case ast_while:
case ast_for:
@ -915,16 +959,16 @@ void nasal_codegen::main_progress(nasal_ast& ast)
case ast_grt:
case ast_or:
case ast_and:
case ast_trino:calculation_gen(tmp);pop_gen();break;
case ast_trino:calc_gen(tmp);pop_gen();break;
}
}
gen(op_nop,0);
number_result_table.resize(number_table.size());
string_result_table.resize(string_table.size());
num_res_table.resize(number_table.size());
str_res_table.resize(string_table.size());
for(auto i=number_table.begin();i!=number_table.end();++i)
number_result_table[i->second]=i->first;
num_res_table[i->second]=i->first;
for(auto i=string_table.begin();i!=string_table.end();++i)
string_result_table[i->second]=i->first;
str_res_table[i->second]=i->first;
return;
}
@ -940,22 +984,22 @@ void nasal_codegen::print_op(int index)
break;
}
// print opcode index
printf("0x%.8x ",exec_code[index].index);
printf("0x%.8x ",exec_code[index].num);
// print detail info
switch(exec_code[index].op)
{
case op_pushnum:std::cout<<'('<<number_result_table[exec_code[index].index]<<')';break;
case op_builtincall:std::cout<<'('<<builtin_func_table[exec_code[index].index].func_name<<')';break;
case op_hashapp:
case op_pnum:std::cout<<'('<<num_res_table[exec_code[index].num]<<')';break;
case op_callb:std::cout<<'('<<builtin_func[exec_code[index].num].name<<')';break;
case op_happ:
case op_call:
case op_mcall:
case op_pushstr:
case op_pstr:
case op_callh:
case op_mcallh:
case op_para:
case op_defpara:
case op_dynpara:
case op_load:std::cout<<'('<<string_result_table[exec_code[index].index]<<')';break;
case op_load:std::cout<<'('<<str_res_table[exec_code[index].num]<<')';break;
}
std::cout<<'\n';
return;
@ -963,24 +1007,24 @@ void nasal_codegen::print_op(int index)
void nasal_codegen::print_byte_code()
{
for(int i=0;i<number_result_table.size();++i)
std::cout<<".number "<<number_result_table[i]<<'\n';
for(int i=0;i<string_result_table.size();++i)
std::cout<<".symbol "<<string_result_table[i]<<'\n';
for(int i=0;i<num_res_table.size();++i)
std::cout<<".number "<<num_res_table[i]<<'\n';
for(int i=0;i<str_res_table.size();++i)
std::cout<<".symbol "<<str_res_table[i]<<'\n';
int size=exec_code.size();
for(int i=0;i<size;++i)
print_op(i);
return;
}
std::vector<std::string>& nasal_codegen::get_string_table()
std::vector<std::string>& nasal_codegen::get_str_table()
{
return string_result_table;
return str_res_table;
}
std::vector<double>& nasal_codegen::get_number_table()
std::vector<double>& nasal_codegen::get_num_table()
{
return number_result_table;
return num_res_table;
}
std::vector<opcode>& nasal_codegen::get_exec_code()

656
nasal_gc.h
View File

@ -1,7 +1,7 @@
#ifndef __NASAL_GC_H__
#define __NASAL_GC_H__
enum runtime_scalar_type
enum nasal_type
{
vm_nil=0,
vm_num,
@ -12,89 +12,74 @@ enum runtime_scalar_type
vm_hash
};
class nasal_gc;
class nasal_vec;
class nasal_hash;
class nasal_func;
class nasal_scop;
class nasal_val;
struct nasal_vec;
struct nasal_hash;
struct nasal_func;
struct nasal_scop;
struct nasal_val;
class nasal_vec
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* nil_addr; // reserved address of nasal_val,type vm_nil
nasal_val* global; // global scope address,type vm_scop
nasal_val** val_stack; // main stack
nasal_val** stack_top; // stack top
std::vector<nasal_val*> num_addrs; // reserved address for const vm_num
std::vector<nasal_val*> local; // local scope for function block
std::vector<nasal_val*> slice_stack; // slice stack for vec[val,val,val:val]
std::vector<nasal_val*> memory; // gc memory
std::queue<nasal_val*> free_list; // gc free list
/* gc functions */
void mark();
void sweep();
void gc_init();
void gc_clear();
nasal_val* gc_alloc(int);
struct nasal_vec
{
private:
nasal_gc& gc;
std::vector<nasal_val*> elems;
public:
nasal_vec(nasal_gc&);
~nasal_vec();
int size();
void add_elem(nasal_val*);
void print();
nasal_val* del_elem();
nasal_val* operator[](const int);
nasal_val* get_value_address(int);
nasal_val** get_mem_address(int);
nasal_val* get_val(int);
nasal_val** get_mem(int);
};
class nasal_hash
struct nasal_hash
{
private:
nasal_gc& gc;
std::unordered_map<std::string,nasal_val*> elems;
public:
nasal_hash(nasal_gc&);
~nasal_hash();
int size();
bool check_contain(std::string);
void add_elem(std::string,nasal_val*);
void del_elem(std::string);
bool check_contain(std::string&);
void print();
nasal_val* get_special_para(std::string);
nasal_val* get_value_address(std::string);
nasal_val** get_mem_address(std::string);
nasal_val* get_special_para(std::string&);
nasal_val* get_val(std::string&);
nasal_val** get_mem(std::string&);
nasal_val* get_keys();
};
class nasal_func
struct nasal_func
{
private:
nasal_gc& gc;
int entry;
nasal_val* closure_addr;
std::vector<int> para;
int dynpara;
std::vector<nasal_val*> default_para_addr;
public:
nasal_func(nasal_gc&);
~nasal_func();
int get_entry();
int get_dynamic_para();
void set_entry(int);
void add_para(int,nasal_val*,bool);
void set_closure_addr(nasal_val*);
void set_new_closure();
nasal_val* get_closure_addr();
std::vector<int>& get_para();
std::vector<nasal_val*>& get_default();
int entry;
std::vector<int> para;
std::vector<nasal_val*> default_para;
std::unordered_map<int,nasal_val*> closure;
nasal_func();
};
class nasal_scop
struct nasal_scop
{
private:
nasal_gc& gc;
std::unordered_map<int,nasal_val*> elems;
public:
nasal_scop(nasal_gc&);
~nasal_scop();
void set_closure(nasal_scop&);
void add_new_value(int,nasal_val*);
nasal_val* get_value_address(int);
nasal_val** get_mem_address(int);
nasal_val* get_val(int);
nasal_val** get_mem(int);
};
class nasal_val
struct nasal_val
{
protected:
bool mark;
int type;
union
{
@ -103,93 +88,37 @@ protected:
nasal_vec* vec;
nasal_hash* hash;
nasal_func* func;
nasal_scop* cls;
nasal_scop* scop;
}ptr;
public:
int ref_cnt;
nasal_val();
nasal_val(int,nasal_gc&);
nasal_val(int);
~nasal_val();
void clear();
void set_type(int,nasal_gc&);
void set_number(double);
void set_string(std::string);
int get_type();
void set_type(int);
double to_number();
double get_number();
std::string to_string();
std::string get_string();
nasal_vec& get_vector();
nasal_hash& get_hash();
nasal_func& get_func();
nasal_scop& get_closure();
};
class nasal_gc
{
private:
std::queue<nasal_val*> free_space;
std::vector<nasal_val*> memory;
public:
~nasal_gc();
void clear();
nasal_val* gc_alloc(int);
void add_reference(nasal_val*);
void del_reference(nasal_val*);
};
/*functions of nasal_vec*/
nasal_vec::nasal_vec(nasal_gc& ngc):gc(ngc)
{
return;
}
nasal_vec::~nasal_vec()
{
int size=elems.size();
for(int i=0;i<size;++i)
gc.del_reference(elems[i]);
return;
}
void nasal_vec::add_elem(nasal_val* value_address)
{
elems.push_back(value_address);
return;
}
nasal_val* nasal_vec::del_elem()
{
// pop back
if(!elems.size())
return NULL;
nasal_val* ret=elems.back();
elems.pop_back();
return ret;
}
int nasal_vec::size()
{
return elems.size();
}
nasal_val* nasal_vec::operator[](const int index)
{
return elems[index];
}
nasal_val* nasal_vec::get_value_address(int index)
nasal_val* nasal_vec::get_val(int index)
{
int vec_size=elems.size();
if(index<-vec_size || index>=vec_size)
{
std::cout<<">> [gc] nasal_vec::get_value_address: index out of range: "<<index<<"\n";
return NULL;
std::cout<<">> [gc] nasal_vec::get_val: index out of range: "<<index<<"\n";
return nullptr;
}
int idx[2]={index+vec_size,index};
return elems[idx[index>=0]];
}
nasal_val** nasal_vec::get_mem_address(int index)
nasal_val** nasal_vec::get_mem(int index)
{
int vec_size=elems.size();
if(index<-vec_size || index>=vec_size)
{
std::cout<<">> [gc] nasal_vec::get_mem_address: index out of range: "<<index<<"\n";
return NULL;
std::cout<<">> [gc] nasal_vec::get_mem: index out of range: "<<index<<"\n";
return nullptr;
}
int idx[2]={index+vec_size,index};
return &elems[idx[index>=0]];
@ -203,13 +132,13 @@ void nasal_vec::print()
for(int i=0;i<size;++i)
{
nasal_val* tmp=elems[i];
switch(tmp->get_type())
switch(tmp->type)
{
case vm_nil: std::cout<<"nil"; break;
case vm_num: std::cout<<tmp->get_number(); break;
case vm_str: std::cout<<tmp->get_string(); break;
case vm_vec: tmp->get_vector().print(); break;
case vm_hash: tmp->get_hash().print(); break;
case vm_num: std::cout<<tmp->ptr.num; break;
case vm_str: std::cout<<*tmp->ptr.str; break;
case vm_vec: tmp->ptr.vec->print(); break;
case vm_hash: tmp->ptr.hash->print(); break;
case vm_func: std::cout<<"func(...){...}"; break;
}
std::cout<<",]"[i==size-1];
@ -218,123 +147,93 @@ void nasal_vec::print()
}
/*functions of nasal_hash*/
nasal_hash::nasal_hash(nasal_gc& ngc):gc(ngc)
{
return;
}
nasal_hash::~nasal_hash()
{
for(auto iter=elems.begin();iter!=elems.end();++iter)
gc.del_reference(iter->second);
return;
}
void nasal_hash::add_elem(std::string key,nasal_val* value_address)
{
if(!elems.count(key))
elems[key]=value_address;
return;
}
void nasal_hash::del_elem(std::string key)
{
if(!elems.count(key))
{
gc.del_reference(elems[key]);
elems.erase(key);
}
return;
}
int nasal_hash::size()
{
return elems.size();
}
nasal_val* nasal_hash::get_special_para(std::string key)
nasal_val* nasal_hash::get_special_para(std::string& key)
{
if(elems.count(key))
return elems[key];
return NULL;
return nullptr;
}
nasal_val* nasal_hash::get_value_address(std::string key)
nasal_val* nasal_hash::get_val(std::string& key)
{
nasal_val* ret_value_addr=NULL;
nasal_val* ret_addr=nullptr;
if(elems.count(key))
return elems[key];
else if(elems.count("parents"))
{
nasal_val* val_addr=elems["parents"];
if(val_addr->get_type()==vm_vec)
if(val_addr->type==vm_vec)
{
nasal_vec& vec_ref=val_addr->get_vector();
std::vector<nasal_val*>& vec_ref=val_addr->ptr.vec->elems;
int size=vec_ref.size();
for(int i=0;i<size;++i)
{
nasal_val* tmp_val_addr=vec_ref.get_value_address(i);
if(tmp_val_addr->get_type()==vm_hash)
ret_value_addr=tmp_val_addr->get_hash().get_value_address(key);
if(ret_value_addr)
break;
nasal_val* tmp=vec_ref[i];
if(tmp->type==vm_hash)
ret_addr=tmp->ptr.hash->get_val(key);
if(ret_addr)
return ret_addr;
}
}
}
return ret_value_addr;
return ret_addr;
}
nasal_val** nasal_hash::get_mem_address(std::string key)
nasal_val** nasal_hash::get_mem(std::string& key)
{
nasal_val** mem_addr=NULL;
nasal_val** mem_addr=nullptr;
if(elems.count(key))
return &elems[key];
else if(elems.count("parents"))
{
nasal_val* val_addr=elems["parents"];
if(val_addr->get_type()==vm_vec)
if(val_addr->type==vm_vec)
{
nasal_vec& vec_ref=val_addr->get_vector();
std::vector<nasal_val*>& vec_ref=val_addr->ptr.vec->elems;
int size=vec_ref.size();
for(int i=0;i<size;++i)
{
nasal_val* tmp_val_addr=vec_ref.get_value_address(i);
if(tmp_val_addr->get_type()==vm_hash)
mem_addr=tmp_val_addr->get_hash().get_mem_address(key);
nasal_val* tmp_val_addr=vec_ref[i];
if(tmp_val_addr->type==vm_hash)
mem_addr=tmp_val_addr->ptr.hash->get_mem(key);
if(mem_addr)
break;
return mem_addr;
}
}
}
return mem_addr;
}
bool nasal_hash::check_contain(std::string key)
bool nasal_hash::check_contain(std::string& key)
{
if(elems.count(key))
return true;
if(elems.count("parents"))
{
bool result=false;
nasal_val* val_addr=elems["parents"];
if(val_addr->get_type()==vm_vec)
if(val_addr->type==vm_vec)
{
nasal_vec& vec_ref=val_addr->get_vector();
bool result=false;
std::vector<nasal_val*>& vec_ref=val_addr->ptr.vec->elems;
int size=vec_ref.size();
for(int i=0;i<size;++i)
{
nasal_val* tmp_val_addr=vec_ref.get_value_address(i);
if(tmp_val_addr->get_type()==vm_hash)
result=tmp_val_addr->get_hash().check_contain(key);
nasal_val* tmp=vec_ref[i];
if(tmp->type==vm_hash)
result=tmp->ptr.hash->check_contain(key);
if(result)
break;
return true;
}
}
return result;
}
return false;
}
nasal_val* nasal_hash::get_keys()
{
nasal_val* ret_addr=gc.gc_alloc(vm_vec);
nasal_vec& ref_vec=ret_addr->get_vector();
nasal_val* ret_addr=gc_alloc(vm_vec);
std::vector<nasal_val*>& ref_vec=ret_addr->ptr.vec->elems;
for(auto iter=elems.begin();iter!=elems.end();++iter)
{
nasal_val* str_addr=gc.gc_alloc(vm_str);
str_addr->set_string(iter->first);
ref_vec.add_elem(str_addr);
nasal_val* str_addr=gc_alloc(vm_str);
*str_addr->ptr.str=iter->first;
ref_vec.push_back(str_addr);
}
return ret_addr;
}
@ -350,13 +249,13 @@ void nasal_hash::print()
{
std::cout<<i->first<<':';
nasal_val* tmp=i->second;
switch(tmp->get_type())
switch(tmp->type)
{
case vm_nil: std::cout<<"nil"; break;
case vm_num: std::cout<<tmp->get_number(); break;
case vm_str: std::cout<<tmp->get_string(); break;
case vm_vec: tmp->get_vector().print(); break;
case vm_hash: tmp->get_hash().print(); break;
case vm_num: std::cout<<tmp->ptr.num; break;
case vm_str: std::cout<<*tmp->ptr.str; break;
case vm_vec: tmp->ptr.vec->print(); break;
case vm_hash: tmp->ptr.hash->print(); break;
case vm_func: std::cout<<"func(...){...}"; break;
}
std::cout<<',';
@ -366,161 +265,64 @@ void nasal_hash::print()
}
/*functions of nasal_func*/
nasal_func::nasal_func(nasal_gc& ngc):gc(ngc)
nasal_func::nasal_func()
{
closure_addr=NULL;
dynpara=-1;
return;
}
nasal_func::~nasal_func()
{
if(closure_addr)
gc.del_reference(closure_addr);
for(int i=0;i<default_para_addr.size();++i)
if(default_para_addr[i])
gc.del_reference(default_para_addr[i]);
return;
}
void nasal_func::set_entry(int etr)
{
entry=etr;
return;
}
int nasal_func::get_entry()
{
return entry;
}
void nasal_func::add_para(int name_index,nasal_val* val_addr=NULL,bool is_dynamic=false)
{
if(is_dynamic)
{
dynpara=name_index;
return;
}
para.push_back(name_index);
default_para_addr.push_back(val_addr);
return;
}
std::vector<int>& nasal_func::get_para()
{
return para;
}
int nasal_func::get_dynamic_para()
{
return dynpara;
}
std::vector<nasal_val*>& nasal_func::get_default()
{
return default_para_addr;
}
void nasal_func::set_closure_addr(nasal_val* value_address)
{
nasal_val* new_closure=gc.gc_alloc(vm_scop);
new_closure->get_closure().set_closure(value_address->get_closure());
closure_addr=new_closure;
return;
}
void nasal_func::set_new_closure()
{
closure_addr=gc.gc_alloc(vm_scop);
return;
}
nasal_val* nasal_func::get_closure_addr()
{
return closure_addr;
}
/*functions of nasal_scop*/
nasal_scop::nasal_scop(nasal_gc& ngc):gc(ngc)
{
return;
}
nasal_scop::~nasal_scop()
{
for(auto i=elems.begin();i!=elems.end();++i)
gc.del_reference(i->second);
return;
}
void nasal_scop::add_new_value(int key,nasal_val* value_address)
{
if(elems.count(key))
{
// if this value already exists,delete the old value and update a new value
gc.del_reference(elems[key]);
}
elems[key]=value_address;
return;
}
nasal_val* nasal_scop::get_value_address(int key)
nasal_val* nasal_scop::get_val(int key)
{
if(elems.count(key))
return elems[key];
return NULL;
return nullptr;
}
nasal_val** nasal_scop::get_mem_address(int key)
nasal_val** nasal_scop::get_mem(int key)
{
if(elems.count(key))
return &(elems[key]);
return NULL;
}
void nasal_scop::set_closure(nasal_scop& tmp)
{
elems=tmp.elems;
for(auto i=elems.begin();i!=elems.end();++i)
gc.add_reference(i->second);
return;
return nullptr;
}
/*functions of nasal_val*/
nasal_val::nasal_val()
{
ref_cnt=1;
mark=false;
type=vm_nil;
return;
}
nasal_val::nasal_val(int nasal_val_type,nasal_gc& nvm)
nasal_val::nasal_val(int val_type)
{
ref_cnt=1;
type=nasal_val_type;
switch(nasal_val_type)
mark=false;
type=val_type;
switch(type)
{
case vm_nil: break;
case vm_num: ptr.num=0; break;
case vm_str: ptr.str=new std::string; break;
case vm_vec: ptr.vec=new nasal_vec(nvm); break;
case vm_hash: ptr.hash=new nasal_hash(nvm); break;
case vm_func: ptr.func=new nasal_func(nvm); break;
case vm_scop: ptr.cls=new nasal_scop(nvm); break;
case vm_vec: ptr.vec=new nasal_vec; break;
case vm_hash: ptr.hash=new nasal_hash; break;
case vm_func: ptr.func=new nasal_func; break;
case vm_scop: ptr.scop=new nasal_scop; break;
}
return;
}
nasal_val::~nasal_val()
{
// must set type and scalar_ptr to default first
// this operation will avoid SIGTRAP caused by circular reference
// circular reference will cause using destructor repeatedly
int tmp_type=type;
type=vm_nil;
switch(tmp_type)
switch(type)
{
case vm_nil: break;
case vm_num: break;
case vm_str: delete ptr.str; break;
case vm_vec: delete ptr.vec; break;
case vm_hash: delete ptr.hash; break;
case vm_func: delete ptr.func; break;
case vm_scop: delete ptr.cls; break;
case vm_scop: delete ptr.scop; break;
}
type=vm_nil;
return;
}
void nasal_val::clear()
{
// must set type and scalar_ptr to default first
// this operation will avoid SIGTRAP caused by circular reference
// circular reference will cause using destructor repeatedly
int tmp_type=type;
type=vm_nil;
switch(tmp_type)
switch(type)
{
case vm_nil: break;
case vm_num: break;
@ -528,49 +330,30 @@ void nasal_val::clear()
case vm_vec: delete ptr.vec; break;
case vm_hash: delete ptr.hash; break;
case vm_func: delete ptr.func; break;
case vm_scop: delete ptr.cls; break;
case vm_scop: delete ptr.scop; break;
}
type=vm_nil;
return;
}
void nasal_val::set_type(int nasal_val_type,nasal_gc& nvm)
void nasal_val::set_type(int val_type)
{
type=nasal_val_type;
switch(nasal_val_type)
type=val_type;
switch(type)
{
case vm_nil: break;
case vm_num: ptr.num=0; break;
case vm_str: ptr.str=new std::string; break;
case vm_vec: ptr.vec=new nasal_vec(nvm); break;
case vm_hash: ptr.hash=new nasal_hash(nvm); break;
case vm_func: ptr.func=new nasal_func(nvm); break;
case vm_scop: ptr.cls=new nasal_scop(nvm); break;
case vm_vec: ptr.vec=new nasal_vec; break;
case vm_hash: ptr.hash=new nasal_hash; break;
case vm_func: ptr.func=new nasal_func; break;
case vm_scop: ptr.scop=new nasal_scop; break;
}
return;
}
void nasal_val::set_number(double num)
{
ptr.num=num;
return;
}
void nasal_val::set_string(std::string str)
{
*ptr.str=str;
return;
}
int nasal_val::get_type()
{
return type;
}
double nasal_val::to_number()
{
if(type==vm_num)
return ptr.num;
else if(type==vm_str)
if(type==vm_str)
return trans_string_to_number(*ptr.str);
return 0;
}
double nasal_val::get_number()
{
return ptr.num;
}
std::string nasal_val::to_string()
@ -581,79 +364,126 @@ std::string nasal_val::to_string()
return trans_number_to_string(ptr.num);
return "";
}
std::string nasal_val::get_string()
void mark()
{
return *ptr.str;
}
nasal_vec& nasal_val::get_vector()
{
return *ptr.vec;
}
nasal_hash& nasal_val::get_hash()
{
return *ptr.hash;
}
nasal_func& nasal_val::get_func()
{
return *ptr.func;
}
nasal_scop& nasal_val::get_closure()
{
return *ptr.cls;
int size;
std::queue<nasal_val*> bfs;
bfs.push(zero_addr);
bfs.push(one_addr);
bfs.push(nil_addr);
bfs.push(global);
size=num_addrs.size();
for(int i=0;i<size;++i)
bfs.push(num_addrs[i]);
size=local.size();
for(int i=0;i<size;++i)
bfs.push(local[i]);
size=slice_stack.size();
for(int i=0;i<size;++i)
bfs.push(slice_stack[i]);
for(nasal_val** i=val_stack;i<=stack_top;++i)
bfs.push(*i);
while(!bfs.empty())
{
nasal_val* tmp=bfs.front();
bfs.pop();
if(tmp->mark) continue;
tmp->mark=true;
if(tmp->type==vm_vec)
{
std::vector<nasal_val*>& vec=tmp->ptr.vec->elems;
for(auto i=vec.begin();i!=vec.end();++i)
if(!(*i)->mark)
bfs.push(*i);
}
else if(tmp->type==vm_hash)
{
std::unordered_map<std::string,nasal_val*>& hash=tmp->ptr.hash->elems;
for(auto i=hash.begin();i!=hash.end();++i)
if(!i->second->mark)
bfs.push(i->second);
}
else if(tmp->type==vm_func)
{
std::unordered_map<int,nasal_val*>& cls=tmp->ptr.func->closure;
std::vector<nasal_val*>& def=tmp->ptr.func->default_para;
for(auto i=cls.begin();i!=cls.end();++i)
if(!i->second->mark)
bfs.push(i->second);
for(auto i=def.begin();i!=def.end();++i)
if(*i && !(*i)->mark)
bfs.push(*i);
}
else if(tmp->type==vm_scop)
{
std::unordered_map<int,nasal_val*>& scop=tmp->ptr.scop->elems;
for(auto i=scop.begin();i!=scop.end();++i)
if(!i->second->mark)
bfs.push(i->second);
}
}
return;
}
/*functions of nasal_gc*/
nasal_gc::~nasal_gc()
void sweep()
{
int gc_mem_size=memory.size();
for(int i=0;i<gc_mem_size;++i)
memory[i]->clear();
for(int i=0;i<gc_mem_size;++i)
delete memory[i];
while(!free_space.empty())
free_space.pop();
return;
}
void nasal_gc::clear()
{
int gc_mem_size=memory.size();
for(int i=0;i<gc_mem_size;++i)
memory[i]->clear();
for(int i=0;i<gc_mem_size;++i)
delete memory[i];
while(!free_space.empty())
free_space.pop();
memory.clear();
return;
}
nasal_val* nasal_gc::gc_alloc(int val_type)
{
if(free_space.empty())
int size=memory.size();
for(int i=0;i<size;++i)
{
nasal_val* new_unit=new nasal_val(val_type,*this);
memory.push_back(new_unit);
return new_unit;
if(!memory[i]->mark)
{
memory[i]->clear();
free_list.push(memory[i]);
}
nasal_val* ret=free_space.front();
free_space.pop();
ret->ref_cnt=1;
ret->set_type(val_type,*this);
memory[i]->mark=false;
}
return;
}
void gc_init()
{
for(int i=0;i<65536;++i)
{
nasal_val* tmp=new nasal_val;
memory.push_back(tmp);
free_list.push(tmp);
}
return;
}
void gc_clear()
{
int size=memory.size();
for(int i=0;i<size;++i)
{
memory[i]->clear();
delete memory[i];
}
memory.clear();
while(!free_list.empty())
free_list.pop();
return;
}
nasal_val* gc_alloc(int type)
{
if(free_list.empty())
{
mark();
sweep();
}
if(free_list.empty())
for(int i=0;i<65536;++i)
{
nasal_val* tmp=new nasal_val;
memory.push_back(tmp);
free_list.push(tmp);
}
nasal_val* ret=free_list.front();
free_list.pop();
ret->set_type(type);
return ret;
}
void nasal_gc::add_reference(nasal_val* value_address)
{
++value_address->ref_cnt;
return;
}
void nasal_gc::del_reference(nasal_val* value_address)
{
--value_address->ref_cnt;
if(!value_address->ref_cnt)
{
value_address->clear();
free_space.push(value_address);
}
return;
}
#endif

24
nasal_parse.h
View File

@ -77,9 +77,9 @@ private:
nasal_ast unary();
nasal_ast scalar();
nasal_ast call_scalar();
nasal_ast call_hash();
nasal_ast call_vec();
nasal_ast call_func();
nasal_ast callh();
nasal_ast callv();
nasal_ast callf();
nasal_ast subvec();
nasal_ast definition();
nasal_ast var_incurve_def();
@ -95,7 +95,7 @@ private:
nasal_ast conditional();
nasal_ast continue_expr();
nasal_ast break_expr();
nasal_ast return_expr();
nasal_ast ret_expr();
public:
int get_error();
void set_toklist(std::vector<token>&);
@ -494,7 +494,7 @@ nasal_ast nasal_parse::expr()
case tok_if: node=conditional(); break;
case tok_continue: node=continue_expr(); break;
case tok_break: node=break_expr(); break;
case tok_ret: node=return_expr(); break;
case tok_ret: node=ret_expr(); break;
case tok_semi: break;
default: die(error_line,"error token \""+tok_list[ptr].str+"\"");break;
}
@ -714,13 +714,13 @@ nasal_ast nasal_parse::call_scalar()
nasal_ast node;
switch(tok_list[ptr].type)
{
case tok_lcurve: node=call_func(); break;
case tok_lbracket: node=call_vec(); break;
case tok_dot: node=call_hash(); break;
case tok_lcurve: node=callf(); break;
case tok_lbracket: node=callv(); break;
case tok_dot: node=callh(); break;
}
return node;
}
nasal_ast nasal_parse::call_hash()
nasal_ast nasal_parse::callh()
{
nasal_ast node(tok_list[ptr].line,ast_callh);
match(tok_dot);
@ -728,7 +728,7 @@ nasal_ast nasal_parse::call_hash()
match(tok_id);
return node;
}
nasal_ast nasal_parse::call_vec()
nasal_ast nasal_parse::callv()
{
nasal_ast node(tok_list[ptr].line,ast_callv);
match(tok_lbracket);
@ -743,7 +743,7 @@ nasal_ast nasal_parse::call_vec()
match(tok_rbracket);
return node;
}
nasal_ast nasal_parse::call_func()
nasal_ast nasal_parse::callf()
{
nasal_ast node(tok_list[ptr].line,ast_callf);
bool special_call=check_special_call();
@ -1033,7 +1033,7 @@ nasal_ast nasal_parse::break_expr()
match(tok_break);
return node;
}
nasal_ast nasal_parse::return_expr()
nasal_ast nasal_parse::ret_expr()
{
nasal_ast node(tok_list[ptr].line,ast_return);
match(tok_ret);

1083
nasal_vm.h
View File

File diff suppressed because it is too large Load Diff

15
test/bp.nas
View File

@ -4,14 +4,13 @@ rand(time(0));
var new_neuron=func()
{
var neuron={
return {
in:0,
out:0,
w:[],
bia:0,
diff:0
};
return neuron;
}
var sigmoid=func(x)
@ -126,7 +125,7 @@ var backward=func(x)
var cnt=0;
var show=0;
var error=1e8;
var error=100;
while(error>0.001)
{
error=0;
@ -138,20 +137,14 @@ while(error>0.001)
}
cnt+=1;
show+=1;
if(show==200)
if(show==150)
{
show=0;
print('epoch ',cnt,':',error,'\r');
}
}
print('finished after ',cnt,' epoch.\n');
var vec=[
[0,0],
[0,1],
[1,0],
[1,1]
];
foreach(var v;vec)
foreach(var v;training_set)
{
run(v);
print(v,': ',output[0].out,'\n');

24
test/class.nas
View File

@ -1,19 +1,23 @@
import("lib.nas");
var student=
var student=func(name,age)
{
new:func(name,age)
{
return {
parents:[student],
var val={
name:name,
age:age
};
},
print_info:func(){println(me.name,' ',me.age);},
get_age:func(){return me.age;},
get_name:func(){return me.name;}
return {
print_info:func(){println(val.name,' ',val.age);},
set_age: func(age){val.age=age;},
get_age: func(){return val.age;},
set_name: func(name){val.name=name;},
get_name: func(){return val.name;}
}
};
var s=student.new('tiansuohaoer',24);
var s=student('valk',24);
s.print_info();
println(s.get_age(),' ',s.get_name());
s.set_age(18);
s.set_name('aluo');
s.print_info();
println(s.get_age(),' ',s.get_name());

34
test/fib.nas
View File

@ -1,27 +1,19 @@
var print=func(elements...)
{
nasal_call_builtin_std_cout(elements);
return nil;
};
var setsize=func(vector,size)
{
nasal_call_builtin_set_size(vector,size);
return nil;
}
import("lib.nas");
var fib=func(x)
{
if(x<2) return x;
return fib(x-1)+fib(x-2);
}
print(fib(30),'\n');
for(var i=0;i<31;i+=1)
print(fib(i),'\n');
var m=[0,1,1,2,3,5,8];
setsize(m,101);
var fib=func(n)
{
if(m[n]!=nil) return m[n];
var t=fib(n-1)+fib(n-2);
m[n]=t;
return t;
}
print(fib(100),'\n');
# var m=[0,1,1,2,3,5,8];
# setsize(m,101);
# var fib=func(n)
# {
# if(m[n]!=nil) return m[n];
# var t=fib(n-1)+fib(n-2);
# m[n]=t;
# return t;
# }
# print(fib(100),'\n');

119
test/lexer.nas
View File

@ -1,60 +1,60 @@
import("lib.nas");
var s=split('',io.fin(input()));
var s=io.fin(input());
var len=size(s);
var ptr=0;
var cnt=0;
var token=[];
var jump_note=func()
{
while(ptr<len and s[ptr]!='\n')
while(ptr<len and chr(s[ptr])!='\n')
ptr+=1;
ptr+=1;
return;
}
var generate_id=func()
{
var tmp="";
while(ptr<len)
{
if('a'<=s[ptr] and s[ptr]<='z'
or 'A'<=s[ptr] and s[ptr]<='Z'
or s[ptr]=='_'
or '0'<=s[ptr] and s[ptr]<='9')
tmp~=s[ptr];
if('a'<=chr(s[ptr]) and chr(s[ptr])<='z'
or 'A'<=chr(s[ptr]) and chr(s[ptr])<='Z'
or chr(s[ptr])=='_'
or '0'<=chr(s[ptr]) and chr(s[ptr])<='9')
tmp~=chr(s[ptr]);
else
break;
ptr+=1;
}
return tmp;
}
var generate_str=func()
{
var tok_str="";
var mark=s[ptr];
var mark=chr(s[ptr]);
ptr+=1;
while(ptr<len and s[ptr]!=mark)
while(ptr<len and chr(s[ptr])!=mark)
{
if(s[ptr]=='\\')
if(chr(s[ptr])=='\\')
{
ptr+=1;
if(s[ptr]=='a') tok_str~='\a';
elsif(s[ptr]=='b') tok_str~='\b';
elsif(s[ptr]=='f') tok_str~='\f';
elsif(s[ptr]=='n') tok_str~='\n';
elsif(s[ptr]=='r') tok_str~='\r';
elsif(s[ptr]=='t') tok_str~='\t';
elsif(s[ptr]=='v') tok_str~='\v';
elsif(s[ptr]=='?') tok_str~='?';
elsif(s[ptr]=='0') tok_str~='\0';
elsif(s[ptr]=='\\') tok_str~='\\';
elsif(s[ptr]=='\'') tok_str~='\'';
elsif(s[ptr]=='\"') tok_str~='\"';
else tok_str~=s[ptr];
if(chr(s[ptr])=='a') tok_str~='\a';
elsif(chr(s[ptr])=='b') tok_str~='\b';
elsif(chr(s[ptr])=='f') tok_str~='\f';
elsif(chr(s[ptr])=='n') tok_str~='\n';
elsif(chr(s[ptr])=='r') tok_str~='\r';
elsif(chr(s[ptr])=='t') tok_str~='\t';
elsif(chr(s[ptr])=='v') tok_str~='\v';
elsif(chr(s[ptr])=='?') tok_str~='?';
elsif(chr(s[ptr])=='0') tok_str~='\0';
elsif(chr(s[ptr])=='\\') tok_str~='\\';
elsif(chr(s[ptr])=='\'') tok_str~='\'';
elsif(chr(s[ptr])=='\"') tok_str~='\"';
else tok_str~=chr(s[ptr]);
}
else
tok_str~=s[ptr];
tok_str~=chr(s[ptr]);
ptr+=1;
}
if(ptr>=len)
@ -62,80 +62,77 @@ var generate_str=func()
ptr+=1;
return tok_str;
}
var generate_number=func()
{
var number=s[ptr];
var number=chr(s[ptr]);
ptr+=1;
if(s[ptr]=='x')
if(chr(s[ptr])=='x')
{
ptr+=1;
while(ptr<len and ('a'<=s[ptr] and s[ptr]<='f' or '0'<=s[ptr] and s[ptr]<='9'))
while(ptr<len and ('a'<=chr(s[ptr]) and chr(s[ptr])<='f' or '0'<=chr(s[ptr]) and chr(s[ptr])<='9'))
{
number~=s[ptr];
number~=chr(s[ptr]);
ptr+=1;
}
return num(number);
}
elsif(s[ptr]=='o')
elsif(chr(s[ptr])=='o')
{
ptr+=1;
while(ptr<len and ('0'<=s[ptr] and s[ptr]<='7'))
while(ptr<len and ('0'<=chr(s[ptr]) and chr(s[ptr])<='7'))
{
number~=s[ptr];
number~=chr(s[ptr]);
ptr+=1;
}
return num(number);
}
while(ptr<len and ('0'<=s[ptr] and s[ptr]<='9'))
while(ptr<len and ('0'<=chr(s[ptr]) and chr(s[ptr])<='9'))
{
number~=s[ptr];
number~=chr(s[ptr]);
ptr+=1;
}
if(s[ptr]=='.')
number~=s[ptr];
if(chr(s[ptr])=='.')
number~=chr(s[ptr]);
else
return num(number);
ptr+=1;
while(ptr<len and ('0'<=s[ptr] and s[ptr]<='9'))
while(ptr<len and ('0'<=chr(s[ptr]) and chr(s[ptr])<='9'))
{
number~=s[ptr];
number~=chr(s[ptr]);
ptr+=1;
}
if(s[ptr]=='e' or s[ptr]=='E')
number~=s[ptr];
if(chr(s[ptr])=='e' or chr(s[ptr])=='E')
number~=chr(s[ptr]);
else
return num(number);
ptr+=1;
if(s[ptr]=='-' or s[ptr]=='+')
if(chr(s[ptr])=='-' or chr(s[ptr])=='+')
{
number~=s[ptr];
number~=chr(s[ptr]);
ptr+=1;
}
while(ptr<len and ('0'<=s[ptr] and s[ptr]<='9'))
while(ptr<len and ('0'<=chr(s[ptr]) and chr(s[ptr])<='9'))
{
number~=s[ptr];
number~=chr(s[ptr]);
ptr+=1;
}
return num(number);
}
var generate_operator=func()
{
var tmp="";
if(s[ptr]=='+' or s[ptr]=='-' or s[ptr]=='~' or s[ptr]=='/' or s[ptr]=='*' or s[ptr]=='>' or s[ptr]=='<' or s[ptr]=='!' or s[ptr]=='=')
if(chr(s[ptr])=='+' or chr(s[ptr])=='-' or chr(s[ptr])=='~' or chr(s[ptr])=='/' or chr(s[ptr])=='*' or chr(s[ptr])=='>' or chr(s[ptr])=='<' or chr(s[ptr])=='!' or chr(s[ptr])=='=')
{
tmp=s[ptr];
tmp=chr(s[ptr]);
ptr+=1;
if(ptr<len and s[ptr]=='=')
if(ptr<len and chr(s[ptr])=='=')
{
tmp~=s[ptr];
tmp~=chr(s[ptr]);
ptr+=1;
}
return tmp;
}
elsif(s[ptr]=='.')
elsif(chr(s[ptr])=='.')
{
if(ptr+2<len and s[ptr+1]=='.' and s[ptr+2]=='.')
{
@ -149,22 +146,21 @@ var generate_operator=func()
}
return tmp;
}
elsif(s[ptr]!=' ' and s[ptr]!='\t' and s[ptr]!='\n' and s[ptr]!='\r' and s[ptr][0]>0)
tmp=s[ptr];
elsif(chr(s[ptr])!=' ' and chr(s[ptr])!='\t' and chr(s[ptr])!='\n' and chr(s[ptr])!='\r' and chr(s[ptr])[0]>0)
tmp=chr(s[ptr]);
ptr+=1;
return tmp;
}
var cnt=0;
var token=[];
while(ptr<len)
{
if(s[ptr]=='#')
if(chr(s[ptr])=='#')
jump_note();
elsif('a'<=s[ptr] and s[ptr]<='z' or 'A'<=s[ptr] and s[ptr]<='Z' or s[ptr]=='_')
elsif('a'<=chr(s[ptr]) and chr(s[ptr])<='z' or 'A'<=chr(s[ptr]) and chr(s[ptr])<='Z' or chr(s[ptr])=='_')
append(token,generate_id());
elsif(s[ptr]=='\'' or s[ptr]=='\"')
elsif(chr(s[ptr])=='\'' or chr(s[ptr])=='\"')
append(token,generate_str());
elsif('0'<=s[ptr] and s[ptr]<='9')
elsif('0'<=chr(s[ptr]) and chr(s[ptr])<='9')
append(token,generate_number());
else
{
@ -175,6 +171,7 @@ while(ptr<len)
if(ptr>=len)
break;
}
foreach(var i;token)
{
print("(",cnt," | ",i,")\n");

84
test/lib.nas
View File

@ -1,157 +1,157 @@
var import=func(filename)
{
nasal_call_import(filename);
__builtin_import(filename);
return nil;
}
var print=func(elements...)
{
nasal_call_builtin_std_cout(elements);
__builtin_std_cout(elements);
return nil;
};
var println=func(elements...)
{
nasal_call_builtin_std_cout(elements);
__builtin_std_cout(elements);
print('\n');
return nil;
}
var append=func(vector,elements...)
{
nasal_call_builtin_push_back(vector,elements);
__builtin_push_back(vector,elements);
return nil;
}
var setsize=func(vector,size)
{
nasal_call_builtin_set_size(vector,size);
__builtin_set_size(vector,size);
return nil;
}
var system=func(str)
{
nasal_call_builtin_system(str);
__builtin_system(str);
return;
}
var input=func()
{
return nasal_call_builtin_input();
return __builtin_input();
}
var sleep=func(duration)
{
nasal_call_builtin_sleep(duration);
__builtin_sleep(duration);
return;
}
var split=func(delimeter,string)
{
return nasal_call_builtin_split(delimeter,string);
return __builtin_split(delimeter,string);
}
var rand=func(seed=nil)
{
return nasal_call_builtin_rand(seed);
return __builtin_rand(seed);
}
var id=func(thing)
{
return nasal_call_builtin_get_id(thing);
return __builtin_get_id(thing);
}
var int=func(value)
{
return nasal_call_builtin_trans_int(value);
return __builtin_int(value);
}
var num=func(value)
{
return nasal_call_builtin_trans_num(value);
return __builtin_num(value);
}
var pop=func(vector)
{
return nasal_call_builtin_pop_back(vector);
return __builtin_pop_back(vector);
}
var str=func(number)
{
return nasal_call_builtin_trans_str(number);
return __builtin_str(number);
}
var size=func(object)
{
return nasal_call_builtin_size(object);
return __builtin_size(object);
}
var contains=func(hash,key)
{
return nasal_call_builtin_contains(hash,key);
return __builtin_contains(hash,key);
}
var delete=func(hash,key)
{
nasal_call_builtin_delete(hash,key);
__builtin_delete(hash,key);
return;
}
var keys=func(hash)
{
return nasal_call_builtin_get_keys(hash);
return __builtin_get_keys(hash);
}
var time=func(begin_time)
{
return nasal_call_builtin_time(begin_time);
return __builtin_time(begin_time);
}
var die=func(str)
{
nasal_call_builtin_die(str);
__builtin_die(str);
return nil;
}
var typeof=func(object)
{
return nasal_call_builtin_type(object);
return __builtin_type(object);
}
var substr=func(str,begin,length)
{
return nasal_call_builtin_substr(str,begin,length);
return __builtin_substr(str,begin,length);
}
var streq=func(a,b)
{
return nasal_call_builtin_streq(a,b);
return __builtin_streq(a,b);
}
var left=func(string,length)
{
return nasal_call_builtin_left(string,length);
return __builtin_left(string,length);
}
var right=func(string,length)
{
return nasal_call_builtin_right(string,length);
return __builtin_right(string,length);
}
var cmp=func(a,b)
{
return nasal_call_builtin_cmp(a,b);
return __builtin_cmp(a,b);
}
var chr=func(code) #//Unlike in FG, this chr does not support Extended ASCII
{
return nasal_call_builtin_chr(code);
return __builtin_chr(code);
}
var io=
{
fin:func(filename)
{
return nasal_call_builtin_finput(filename);
return __builtin_fin(filename);
},
fout:func(filename,str)
{
nasal_call_builtin_foutput(filename,str);
__builtin_fout(filename,str);
return;
}
};
var bits=
{
bitxor: func(a,b){return nasal_call_builtin_xor(a,b); },
bitand: func(a,b){return nasal_call_builtin_and(a,b); },
bitor: func(a,b){return nasal_call_builtin_or(a,b); },
bitnand: func(a,b){return nasal_call_builtin_nand(a,b);},
bitnot: func(a) {return nasal_call_builtin_not(a); }
bitxor: func(a,b){return __builtin_xor(a,b); },
bitand: func(a,b){return __builtin_and(a,b); },
bitor: func(a,b){return __builtin_or(a,b); },
bitnand: func(a,b){return __builtin_nand(a,b);},
bitnot: func(a) {return __builtin_not(a); }
};
var math=
{
e: 2.7182818284590452354,
pi: 3.14159265358979323846264338327950288,
sin: func(x) {return nasal_call_builtin_sin(x); },
cos: func(x) {return nasal_call_builtin_cos(x); },
tan: func(x) {return nasal_call_builtin_tan(x); },
exp: func(x) {return nasal_call_builtin_exp(x); },
ln: func(x) {return nasal_call_builtin_cpp_math_ln(x); },
sqrt: func(x) {return nasal_call_builtin_cpp_math_sqrt(x);},
atan2: func(x,y){return nasal_call_builtin_cpp_atan2(x,y); }
sin: func(x) {return __builtin_sin(x); },
cos: func(x) {return __builtin_cos(x); },
tan: func(x) {return __builtin_tan(x); },
exp: func(x) {return __builtin_exp(x); },
ln: func(x) {return __builtin_ln(x); },
sqrt: func(x) {return __builtin_sqrt(x); },
atan2: func(x,y){return __builtin_atan2(x,y);}
};