Compare commits
6 Commits
2fd48537fb
...
e147e8648a
Author | SHA1 | Date |
---|---|---|
ame | e147e8648a | |
ame | 620c6efdd4 | |
ame | 65f0a57f28 | |
ame | 7c151136eb | |
ame | 2225e0a600 | |
ame | 2554a1ec80 |
117
src/builtins.cc
117
src/builtins.cc
|
@ -1,19 +1,32 @@
|
|||
#include "builtins.hh"
|
||||
#include "pretty.hh"
|
||||
|
||||
#include "cast.hh"
|
||||
namespace builtin {
|
||||
bool builtin::check_args(lexi l, state* s){
|
||||
if(l.args.size()!=args.size()&&args[0]!=ANY)
|
||||
return false;
|
||||
for(int i = 0; i!=l.args.size(); i++){
|
||||
if(args[i]==ANY) break;
|
||||
if(args[i]==NUMBER&&(l.args[i].type==INT||l.args[i].type==DOUBLE)) continue;
|
||||
if(l.args[i].type!=args[i]&&l.args[i].type!=STATEMENT){
|
||||
if(l.args[i].type==NONE){
|
||||
if(!s->names.count(l.args[i].ident))
|
||||
p_ferr("undefined refrence to "+l.args[i].ident,1);
|
||||
if(s->names[l.args[i].ident].type==args[i])
|
||||
if(s->names[l.args[i].ident].type==args[i])//||args[i]==NUMBER&&(s->names[l.args[i].ident].type==INT||s->names[l.args[i].ident].type==DOUBLE))
|
||||
continue;
|
||||
else {
|
||||
object tt = cast_o(s->names[l.args[i].ident],args[i],s);
|
||||
if(tt.type==args[i]){
|
||||
continue;
|
||||
}
|
||||
}
|
||||
std::cout<<s->names[l.args[i].ident].type;
|
||||
return false;
|
||||
} else {
|
||||
object tt = cast_o(l.args[i],args[i],s);
|
||||
if(tt.type==args[i]){
|
||||
continue;
|
||||
}
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
@ -23,51 +36,107 @@ namespace builtin {
|
|||
|
||||
|
||||
|
||||
std::any a_exit(lexi l, state* s){
|
||||
std::any a_exit(lexi *l, state* s){
|
||||
int ex;
|
||||
//if(l.args[0].type==NONE)
|
||||
// ex = std::get<int>(s->names[l.args[0].ident].value);
|
||||
//else
|
||||
ex = std::get<int>(l.args[0].value);
|
||||
ex = std::get<int>(l->args[0].value);
|
||||
exit(ex);
|
||||
}
|
||||
std::any write(lexi l, state* s){
|
||||
std::cout<<std::get<std::string>(l.args[0].value)<<std::endl;
|
||||
std::any write(lexi *l, state* s){
|
||||
std::cout<<std::get<std::string>(l->args[0].value)<<std::endl;
|
||||
return 0;
|
||||
}
|
||||
std::any _if(lexi l, state* s){
|
||||
if(std::get<int>(l.args[0].value)==1)
|
||||
interp(l.args[1].to_larray(),s);
|
||||
std::any _if(lexi *l, state* s){
|
||||
if(std::get<int>(l->args[0].value)==1)
|
||||
interp(l->args[1].to_larray(),s);
|
||||
else
|
||||
interp(l.args[2].to_larray(),s);
|
||||
interp(l->args[2].to_larray(),s);
|
||||
//std::cout<<batch_format(l.args[1].to_larray(),0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
std::any __anon(lexi l,state* s){
|
||||
for(object o : l.args)
|
||||
std::any __anon(lexi *l,state* s){
|
||||
for(object o : l->args)
|
||||
interp(o.n_value,s);
|
||||
return 0;
|
||||
}
|
||||
std::any _def(lexi l,state *s){
|
||||
s->names[l.args[0].ident] = l.args[1];
|
||||
std::any _def(lexi *l,state *s){
|
||||
s->names[l->args[0].ident] = l->args[1];
|
||||
return 0;
|
||||
}
|
||||
|
||||
std::any _add(lexi l, state* s){
|
||||
return std::get<int>(l.args[0].value) + std::get<int>(l.args[1].value);
|
||||
std::any _add(lexi *l, state* s){
|
||||
return std::get<int>(l->args[0].value) + std::get<int>(l->args[1].value);
|
||||
}
|
||||
std::any _sub(lexi l, state* s){
|
||||
return std::get<int>(l.args[0].value) - std::get<int>(l.args[1].value);
|
||||
std::any _sub(lexi *l, state* s){
|
||||
return std::get<int>(l->args[0].value) - std::get<int>(l->args[1].value);
|
||||
}
|
||||
std::any _mul(lexi l, state* s){
|
||||
return std::get<int>(l.args[0].value) * std::get<int>(l.args[1].value);
|
||||
std::any _mul(lexi *l, state* s){
|
||||
return std::get<int>(l->args[0].value) * std::get<int>(l->args[1].value);
|
||||
}
|
||||
std::any _div(lexi l, state* s){
|
||||
return std::get<int>(l.args[0].value) / std::get<int>(l.args[1].value);
|
||||
std::any _div(lexi *l, state* s){
|
||||
return std::get<int>(l->args[0].value) / std::get<int>(l->args[1].value);
|
||||
}
|
||||
std::any _mod(lexi l, state* s){
|
||||
return std::get<int>(l.args[0].value) % std::get<int>(l.args[1].value);
|
||||
std::any _mod(lexi *l, state* s){
|
||||
return std::get<int>(l->args[0].value) % std::get<int>(l->args[1].value);
|
||||
}
|
||||
std::any _get(lexi *l, state* s){
|
||||
auto ob = std::get<std::vector<object>>(l->args[0].value);
|
||||
if(std::get<int>(l->args[1].value)>ob.size()) p_ferr("out of range",1);
|
||||
return ob[std::get<int>(l->args[1].value)];
|
||||
}
|
||||
std::any _set(lexi *l, state* s){
|
||||
//std::cout<<l->args[0].ident<<std::endl;
|
||||
//exit(0);
|
||||
auto bb = std::get<std::vector<object>>(s->names[l->args[0].ident].value);
|
||||
bb[std::get<int>(l->args[1].value)] = l->args[2];
|
||||
s->names[l->args[0].ident].value = bb;//[std::get<int>(l->args[1].value)];
|
||||
return 0;
|
||||
//auto ob = std::get<std::vector<object>>(l->args[0].value);
|
||||
//if(std::get<int>(l->args[1].value)>ob.size()) p_ferr("out of range",1);
|
||||
//return ob[std::get<int>(l->args[1].value)];
|
||||
}
|
||||
|
||||
std::any _equ(lexi*l,state*s){
|
||||
return (int)(std::get<int>(l->args[0].value)==std::get<int>(l->args[1].value));
|
||||
}
|
||||
std::any _great(lexi*l,state*s){
|
||||
return (int)(std::get<int>(l->args[0].value)>std::get<int>(l->args[1].value));
|
||||
}
|
||||
std::any _less(lexi*l,state*s){
|
||||
return (int)(std::get<int>(l->args[0].value)<std::get<int>(l->args[1].value));
|
||||
}
|
||||
std::any _great_o_equ(lexi*l,state*s){
|
||||
return (int)(std::get<int>(l->args[0].value)>=std::get<int>(l->args[1].value));
|
||||
}
|
||||
std::any _less_o_equ(lexi*l,state*s){
|
||||
return (int)(std::get<int>(l->args[0].value)<=std::get<int>(l->args[1].value));
|
||||
}
|
||||
std::any _nequ(lexi*l,state*s){
|
||||
return (int)(std::get<int>(l->args[0].value)!=std::get<int>(l->args[1].value));
|
||||
}
|
||||
std::any _and(lexi*l,state*s){
|
||||
return (int)(std::get<int>(l->args[0].value)&&std::get<int>(l->args[1].value));
|
||||
}
|
||||
std::any _not(lexi*l,state*s){
|
||||
return (int)!std::get<int>(l->args[0].value);
|
||||
}
|
||||
std::any _or(lexi*l,state*s){
|
||||
return (int)(std::get<int>(l->args[0].value)||std::get<int>(l->args[1].value));
|
||||
}
|
||||
std::any _xor(lexi*l,state*s){
|
||||
return (int)(std::get<int>(l->args[0].value)^std::get<int>(l->args[1].value));
|
||||
}
|
||||
std::any _defn(lexi*l, state*s){
|
||||
func f;
|
||||
f.call = l->args[0].ident;
|
||||
f.args = {};
|
||||
f._return = NONE;
|
||||
f.calls = l->args[2].n_value;
|
||||
s->functions.insert({l->args[0].ident,f});
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
@ -29,11 +29,11 @@ namespace builtin {
|
|||
std::string call = "";
|
||||
std::vector<type> args = {};
|
||||
type _return = NONE;
|
||||
std::any(*exec)(lexi, state*);
|
||||
std::any(*exec)(lexi*, state*);
|
||||
|
||||
bool check_args(lexi, state*);
|
||||
|
||||
builtin(std::string _call, std::vector<type> _args, type __return, std::any(*e)(lexi, state*)){
|
||||
builtin(std::string _call, std::vector<type> _args, type __return, std::any(*e)(lexi*, state*)){
|
||||
call = _call;
|
||||
args = _args;
|
||||
_return = __return;
|
||||
|
@ -41,16 +41,31 @@ namespace builtin {
|
|||
}
|
||||
};
|
||||
|
||||
std::any a_exit(lexi l, state* s);
|
||||
std::any write(lexi l, state* s);
|
||||
std::any _if(lexi l, state* s);
|
||||
std::any __anon(lexi l, state* s);
|
||||
std::any _def(lexi l, state* s);
|
||||
std::any _add(lexi, state*);
|
||||
std::any _sub(lexi, state*);
|
||||
std::any _mul(lexi, state*);
|
||||
std::any _div(lexi, state*);
|
||||
std::any _mod(lexi, state*);
|
||||
std::any a_exit(lexi*, state*);
|
||||
std::any write(lexi*, state*);
|
||||
std::any _if(lexi*, state*);
|
||||
std::any __anon(lexi*, state*);
|
||||
std::any _def(lexi*, state*);
|
||||
std::any _add(lexi*, state*);
|
||||
std::any _sub(lexi*, state*);
|
||||
std::any _mul(lexi*, state*);
|
||||
std::any _div(lexi*, state*);
|
||||
std::any _mod(lexi*, state*);
|
||||
std::any _get(lexi*, state*);
|
||||
std::any _set(lexi*, state*);
|
||||
|
||||
std::any _equ(lexi*, state*);
|
||||
std::any _great(lexi*, state*);
|
||||
std::any _less(lexi*, state*);
|
||||
std::any _great_o_equ(lexi*, state*);
|
||||
std::any _less_o_equ(lexi*, state*);
|
||||
std::any _nequ(lexi*, state*);
|
||||
std::any _and(lexi*, state*);
|
||||
std::any _not(lexi*, state*);
|
||||
std::any _or(lexi*, state*);
|
||||
std::any _xor(lexi*, state*);
|
||||
|
||||
std::any _defn(lexi*, state*);
|
||||
|
||||
}
|
||||
|
||||
|
@ -65,10 +80,28 @@ static builtin::builtin _sub("-",{INT,INT},INT,builtin::_sub);
|
|||
static builtin::builtin _mul("*",{INT,INT},INT,builtin::_mul);
|
||||
static builtin::builtin _div("/",{INT,INT},INT,builtin::_div);
|
||||
static builtin::builtin _mod("%",{INT,INT},INT,builtin::_mod);
|
||||
static builtin::builtin _get("get",{ARRAY,INT},ANY,builtin::_get);
|
||||
static builtin::builtin _set("set",{NONE,INT,ANY},NONE,builtin::_set);
|
||||
|
||||
static builtin::builtin _equ("==",{INT,INT},INT,builtin::_equ);
|
||||
static builtin::builtin _great(">",{INT,INT},INT,builtin::_great);
|
||||
static builtin::builtin _less("<",{INT,INT},INT,builtin::_less);
|
||||
static builtin::builtin _great_o_equ(">=",{INT,INT},INT,builtin::_great_o_equ);
|
||||
static builtin::builtin _less_o_equ("<=",{INT,INT},INT,builtin::_less_o_equ);
|
||||
static builtin::builtin _nequ("!=",{INT,INT},INT,builtin::_nequ);
|
||||
static builtin::builtin _and("&&",{INT,INT},INT,builtin::_and);
|
||||
static builtin::builtin _not("!",{INT},INT,builtin::_not);
|
||||
static builtin::builtin _or("||",{INT,INT},INT,builtin::_or);
|
||||
static builtin::builtin _xor("^",{INT,INT},INT,builtin::_xor);
|
||||
|
||||
static builtin::builtin _defn("defn",{NONE,INT,ANON},ANY,builtin::_defn);
|
||||
|
||||
|
||||
static std::map<std::string, builtin::builtin*> builtins = {
|
||||
{"write",&_write},{"exit",&_exit},{"if",&_if},{"__anon",&__anon},{"def",&_def},{"+",&_add}
|
||||
,{"-",&_sub},{"*",&_mul},{"/",&_div},{"%",&_mod}
|
||||
,{"-",&_sub},{"*",&_mul},{"/",&_div},{"%",&_mod},{"get",&_get},{"set",&_set},{"==",&_equ},
|
||||
{">",&_great},{"<",&_less},{">=",&_great_o_equ},{"<=",&_less_o_equ},{"!=",&_nequ},{"&&",&_and},
|
||||
{"!",&_not},{"||",&_or},{"^",&_xor},{"defn",&_defn}
|
||||
};
|
||||
|
||||
void ttest(lexi);
|
||||
|
|
|
@ -0,0 +1,57 @@
|
|||
#include "cast.hh"
|
||||
#include "pretty.hh"
|
||||
|
||||
object cast_o(object i, type t, state* s){
|
||||
if(i.type==STATEMENT&&t!=STATEMENT&&t!=ANON&&i.ident!="__anon"){
|
||||
i = dtype(i,single_ex(i.n_value[0],s),builtins[i.n_value[0].oper]->_return,t);
|
||||
//i.type = STATEMENTC;
|
||||
if(i.type!=t)
|
||||
i = cast_o(i,t,s);
|
||||
return i;
|
||||
}
|
||||
switch(t){
|
||||
case INT:
|
||||
if(i.type==DOUBLE){
|
||||
i.type = INT;
|
||||
i.value = (int)std::get<double>(i.value);
|
||||
break;
|
||||
}
|
||||
if(i.type==STRING){
|
||||
i.type = INT;
|
||||
i.value = std::stoi(std::get<std::string>(i.value));
|
||||
break;
|
||||
}
|
||||
p_ferr("no avaliable converstion from "+std::to_string(i.type)+" to "+std::to_string(t),1);
|
||||
break;
|
||||
case NONE:
|
||||
case CHAR:
|
||||
break;
|
||||
case STRING:
|
||||
if(i.type==DOUBLE){
|
||||
i.type = STRING;
|
||||
i.value = std::to_string(std::get<double>(i.value));
|
||||
break;
|
||||
}
|
||||
if(i.type==INT){
|
||||
i.type = STRING;
|
||||
i.value = std::to_string(std::get<int>(i.value));
|
||||
break;
|
||||
}
|
||||
p_ferr("no avaliable converstion from "+std::to_string(i.type)+" to "+std::to_string(t),1);
|
||||
break;
|
||||
case STATEMENT:
|
||||
|
||||
break;
|
||||
case STATEMENT_UNEX:
|
||||
case STATEMENTC:
|
||||
case DOUBLE:
|
||||
case REF:
|
||||
case ARRAY:
|
||||
case ANON:
|
||||
case ANY:
|
||||
case NUMBER:
|
||||
|
||||
break;
|
||||
}
|
||||
return i;
|
||||
}
|
|
@ -0,0 +1,13 @@
|
|||
#include <iostream>
|
||||
|
||||
|
||||
#ifndef __state_hh
|
||||
#include "state.hh"
|
||||
#endif
|
||||
|
||||
#ifndef __parser_hh
|
||||
#include "parser.hh"
|
||||
#endif
|
||||
|
||||
|
||||
object cast_o(object, type, state*);
|
|
@ -1,11 +1,18 @@
|
|||
#include "interp.hh"
|
||||
|
||||
std::any single_ex(lexi l, state*s){
|
||||
if(!builtins.count(l.oper)&&l.oper!="__anon")
|
||||
//std::cout<<l.format(0);
|
||||
if(!builtins.count(l.oper)&&l.oper!="__anon"){
|
||||
if(!s->functions.count(l.oper))
|
||||
p_ferr("undefined refrence to "+l.oper+" on line:"+std::to_string(l.line)+":"+std::to_string(l._char),1);
|
||||
lexi gen = s->gen_args(s->functions[l.oper].args,l);
|
||||
return s->functions[l.oper].exec(gen,s);
|
||||
return 0;
|
||||
}
|
||||
if(!builtins[l.oper]->check_args(l,s))
|
||||
p_ferr("incorrect usage on "+l.oper,1);
|
||||
return builtins[l.oper]->exec(s->gen_args(builtins[l.oper]->args,l),s);
|
||||
lexi gen = s->gen_args(builtins[l.oper]->args,l);
|
||||
return builtins[l.oper]->exec(&gen,s);
|
||||
}
|
||||
|
||||
void interp(std::vector<lexi> inp, state* s){
|
||||
|
@ -14,6 +21,7 @@ void interp(std::vector<lexi> inp, state* s){
|
|||
//return;
|
||||
for(lexi l : inp){
|
||||
single_ex(l,s);
|
||||
//std::cout<<batch_format(inp, 0);
|
||||
//std::cout<<s->names[l.args[0].ident].ident;
|
||||
}
|
||||
|
||||
|
|
|
@ -1,6 +1,9 @@
|
|||
#include "parser.hh"
|
||||
|
||||
|
||||
std::map<char, char> matching = {{'"','"'},{'(',')'},{'{','}'}};
|
||||
std::vector<char> matching_keys = {'"','(','{'};
|
||||
std::map<char, type> matching_types = {{'"',STRING},{'(',STATEMENT_UNEX},{'{',ARRAY}};
|
||||
|
||||
void object::clear(){
|
||||
ident="";
|
||||
|
@ -19,8 +22,69 @@ std::vector<lexi> object::to_larray(){
|
|||
return r;
|
||||
}
|
||||
|
||||
char array_break = ',';
|
||||
void object::gen_value(){
|
||||
std::vector<object> array;
|
||||
object t;
|
||||
reading_symbol read = READING_O;
|
||||
int con_level;
|
||||
char last_con;
|
||||
switch(type){
|
||||
case ARRAY:
|
||||
t.type = NONE;
|
||||
for(int i = 0; i!=ident.size(); i++){
|
||||
if(read==READING_O&&ident[i]!=' '&&ident[i]!=array_break){
|
||||
read = READING_A;
|
||||
if(std::find(matching_keys.begin(),matching_keys.end(),ident[i]) != matching_keys.end()){
|
||||
con_level = 0;
|
||||
t.clear();
|
||||
last_con = ident[i];
|
||||
t.type = matching_types[last_con];
|
||||
read = READING_CON;
|
||||
continue;
|
||||
}
|
||||
}
|
||||
if(read!=READING_CON&&(ident[i]==array_break||ident[i]==' ')&&t.ident!=""){
|
||||
array.push_back(t);
|
||||
t.clear();
|
||||
read = READING_O;
|
||||
} else if(read==READING_A){
|
||||
|
||||
if(t.type==NONE){
|
||||
if(isdigit(ident[i])){
|
||||
t.type = INT;
|
||||
}
|
||||
}
|
||||
t.ident += ident[i];
|
||||
}else if(read==READING_CON){
|
||||
if(ident[i]==matching[last_con]&&con_level==0){
|
||||
array.push_back(t);
|
||||
t.clear();
|
||||
read = READING_O;
|
||||
} else {
|
||||
if(ident[i]==last_con)
|
||||
con_level++;
|
||||
else if(ident[i]==matching[last_con])
|
||||
con_level--;
|
||||
t.ident+=ident[i];
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
}
|
||||
if(t.ident!="")
|
||||
array.push_back(t);
|
||||
for(int i = 0; i!=array.size(); i++){
|
||||
if(array[i].type==STATEMENT_UNEX||array[i].type==ANON){
|
||||
array[i].ident = "("+array[i].ident+")";
|
||||
array[i].n_value = test(array[i].ident);
|
||||
array[i].type = STATEMENT;
|
||||
}
|
||||
array[i].gen_value();
|
||||
}
|
||||
|
||||
value = array;
|
||||
break;
|
||||
case INT:
|
||||
value = std::stoi(ident);
|
||||
break;
|
||||
|
@ -34,10 +98,13 @@ void object::gen_value(){
|
|||
case STRING:
|
||||
value = ident;
|
||||
case STATEMENT:
|
||||
case STATEMENTC:
|
||||
case STATEMENT_UNEX:
|
||||
case REF:
|
||||
case NUMBER:
|
||||
case ANON:
|
||||
case ARRAY:
|
||||
break;
|
||||
|
||||
case ANY:
|
||||
break;
|
||||
}
|
||||
|
@ -51,9 +118,15 @@ std::string lexi::format(int indent){
|
|||
}
|
||||
std::string argv = "[ ";
|
||||
for(object a : args){
|
||||
if(a.type!=STATEMENT)
|
||||
if(a.type!=STATEMENT&&a.type!=ARRAY)
|
||||
argv+="'"+a.ident+"'"+":"+std::to_string(a.type)+", ";
|
||||
else{
|
||||
else if(a.type==ARRAY){
|
||||
argv+="\n"+indent_s+"{";
|
||||
for(object b : std::get<std::vector<object>>(a.value)){
|
||||
argv+="'"+b.ident+"'"+":"+std::to_string(b.type)+", ";
|
||||
}
|
||||
argv+="}\n, ";
|
||||
} else {
|
||||
argv+="\n"+indent_s+batch_format(a.n_value, indent+INDENT_ITER)+indent_s+":"+std::to_string(a.type)+",";
|
||||
//std::cout<<a.n_value.size();
|
||||
}
|
||||
|
@ -70,10 +143,6 @@ void lexi::clear(){
|
|||
args = {};
|
||||
}
|
||||
|
||||
std::map<char, char> matching = {{'"','"'},{'(',')'},{'[',']'}};
|
||||
std::vector<char> matching_keys = {'"','(','['};
|
||||
std::map<char, type> matching_types = {{'"',STRING},{'(',STATEMENT_UNEX},{'[',ARRAY}};
|
||||
|
||||
std::string batch_format(std::vector<lexi> a,int indent){
|
||||
std::string r = "";
|
||||
for(lexi b : a){
|
||||
|
@ -169,6 +238,7 @@ std::vector<lexi> test(std::string input){
|
|||
|
||||
}
|
||||
}
|
||||
|
||||
for(int i = 0; i!=all.size(); i++){
|
||||
for(int y = 0; y!=all[i].args.size(); y++){
|
||||
if(all[i].args[y].type==STATEMENT_UNEX||all[i].args[y].type==ANON){
|
||||
|
|
|
@ -15,7 +15,7 @@ enum s_symbols {
|
|||
P_CLOSING = ')',
|
||||
};
|
||||
enum type {
|
||||
NONE, INT, DOUBLE, CHAR, STRING, STATEMENT_UNEX, STATEMENT, REF, ARRAY, ANON, ANY
|
||||
NONE, INT, DOUBLE, CHAR, STRING, STATEMENT_UNEX, STATEMENT, REF, ARRAY, ANON, ANY, NUMBER, STATEMENTC
|
||||
};
|
||||
enum reading_symbol {
|
||||
LOOKING, READING_O, READING_A, READING_CON
|
||||
|
@ -24,10 +24,11 @@ enum reading_symbol {
|
|||
class lexi;
|
||||
class object;
|
||||
|
||||
typedef std::variant<int, double, char, std::string, bool, long, std::vector<object>> val;
|
||||
class object {
|
||||
public:
|
||||
std::string ident = "";
|
||||
std::variant<int, double, char, std::string, bool, long> value = NULL;
|
||||
val value = NULL;
|
||||
std::vector<lexi> n_value;
|
||||
type type = NONE;
|
||||
|
||||
|
|
33
src/state.cc
33
src/state.cc
|
@ -1,12 +1,15 @@
|
|||
#include "state.hh"
|
||||
#include "cast.hh"
|
||||
|
||||
object dtype(object l, std::any a, type t){
|
||||
object dtype(object l, std::any a, type t, type wants){
|
||||
switch(t){
|
||||
case INT:
|
||||
l.value = std::any_cast<int>(a);
|
||||
l.type = INT;
|
||||
break;
|
||||
case DOUBLE:
|
||||
case STATEMENTC:
|
||||
case NUMBER:
|
||||
case STRING:
|
||||
case CHAR:
|
||||
case NONE:
|
||||
|
@ -15,13 +18,27 @@ object dtype(object l, std::any a, type t){
|
|||
case REF:
|
||||
case ANON:
|
||||
case ARRAY:
|
||||
break;
|
||||
case ANY:
|
||||
p_warn("AAAA");
|
||||
//std::vector<object> bb= std::any_cast<std::vector<object>>(a);
|
||||
|
||||
object bb = std::any_cast<object>(a);
|
||||
l = bb;
|
||||
//std::cout<<bb;
|
||||
//p_warn("AAAA");
|
||||
break;
|
||||
}
|
||||
return l;
|
||||
}
|
||||
|
||||
std::any func::exec(lexi l, state*s) {
|
||||
//return 0l
|
||||
for(lexi ss : calls){
|
||||
single_ex(ss,s);
|
||||
}
|
||||
return 0;//single_ex(l,s);
|
||||
};
|
||||
|
||||
lexi state::gen_args(std::vector<type> b, lexi i){
|
||||
//if(b[0]==ANY) return i;
|
||||
if(i.oper=="__anon")return i;
|
||||
|
@ -29,9 +46,17 @@ lexi state::gen_args(std::vector<type> b, lexi i){
|
|||
//std::cout<<"AA"<<std::endl;
|
||||
if(i.args[x].type==NONE&&b[x]!=NONE){
|
||||
if(!names.count(i.args[x].ident)) continue;//p_ferr("undefined refrence to "+i.args[x].ident,1);
|
||||
i.args[x] = names[i.args[x].ident];
|
||||
if(names[i.args[x].ident].type==b[x])
|
||||
i.args[x] = names[i.args[x].ident];
|
||||
else {
|
||||
i.args[x] = cast_o(names[i.args[x].ident],b[x],this);
|
||||
}
|
||||
} else if(b[x]!=ANON&&i.args[x].type==STATEMENT){
|
||||
i.args[x] = dtype(i.args[x],single_ex(i.args[x].n_value[0],this),builtins[i.args[x].n_value[0].oper]->_return);
|
||||
i.args[x] = dtype(i.args[x],single_ex(i.args[x].n_value[0],this),builtins[i.args[x].n_value[0].oper]->_return,b[x]);
|
||||
if(i.args[x].type!=b[x])
|
||||
i.args[x] = cast_o(i.args[x],b[x],this);
|
||||
} else if(b[x]!=ANY&&b[x]!=i.args[x].type){
|
||||
i.args[x] = cast_o(i.args[x],b[x],this);
|
||||
}
|
||||
}
|
||||
return i;
|
||||
|
|
18
src/state.hh
18
src/state.hh
|
@ -13,11 +13,27 @@ void tttest();
|
|||
#ifndef __parser_hh
|
||||
#include "parser.hh"
|
||||
#endif
|
||||
object dtype(object l, std::any a, type t, type wants);
|
||||
class func {
|
||||
public:
|
||||
std::string call = "";
|
||||
std::vector<type> args = {};
|
||||
type _return = NONE;
|
||||
std::vector<lexi> calls;
|
||||
std::any exec(lexi l, state*s);
|
||||
/*func(std::string _call, std::vector<type> _args, type __return, std::vector<lexi>e){
|
||||
call = _call;
|
||||
args = _args;
|
||||
_return = __return;
|
||||
calls = e;
|
||||
}*/
|
||||
|
||||
};
|
||||
|
||||
class state {
|
||||
public:
|
||||
std::map<std::string, object> names;
|
||||
|
||||
std::map<std::string, func> functions;
|
||||
lexi gen_args(std::vector<type>, lexi);
|
||||
};
|
||||
|
||||
|
|
|
@ -8,6 +8,7 @@ int main(int argc, char* argv[]){
|
|||
//std::cout<<batch_format(test(f_read("./test/if.ll")),0);
|
||||
state state;
|
||||
interp(test(f_read(argv[1])),&state);
|
||||
//std::cout<<batch_format(test(f_read(argv[1])),0);
|
||||
//interp(test(f_read("./test/exit.ll")));
|
||||
return 0;
|
||||
}
|
||||
|
|
|
@ -36,6 +36,14 @@ tests = {
|
|||
file = "./test/arth.ll",
|
||||
ex_return = "203",
|
||||
ex_out = "",
|
||||
},{
|
||||
file = "./test/outint.ll",
|
||||
ex_return = "0",
|
||||
ex_out = "36",
|
||||
},{
|
||||
file = "./test/array.ll",
|
||||
ex_return = "4",
|
||||
ex_out = "6\n5\n2222",
|
||||
},
|
||||
}
|
||||
|
||||
|
@ -62,7 +70,7 @@ function run_test(test)
|
|||
if(exit==test.ex_return) then
|
||||
return true
|
||||
end
|
||||
print("wrong exit code "..exit.."!="..test.ex_return)
|
||||
print("\nwrong exit code "..exit.."!="..test.ex_return)
|
||||
return false
|
||||
end
|
||||
print("wrong output '"..output.."'!='"..test.ex_out.."'")
|
||||
|
@ -76,11 +84,18 @@ local green = "\27[32m"
|
|||
local red = "\27[31m"
|
||||
local reset = "\27[0m"
|
||||
|
||||
local dir = io.popen("ls test")
|
||||
local test_count = 0
|
||||
local rtest_count = 0
|
||||
for t in dir:read("*all"):gmatch("[^\n]+") do
|
||||
test_count = test_count + 1
|
||||
end
|
||||
for _,t in pairs(tests) do
|
||||
print("--- *** "..t.file.."\n\n"..binary.." "..t.file.."\n")
|
||||
rtest_count = rtest_count + 1
|
||||
print("--- *** "..t.file)--.."\n\n"..binary.." "..t.file.."\n")
|
||||
local res = run_test(t)
|
||||
if(res) then
|
||||
print("--- "..green.." PASSED\n"..reset)
|
||||
--print("--- "..green.." PASSED\n"..reset)
|
||||
pass = pass + 1
|
||||
else
|
||||
print("--- "..red.."FAILED\n"..reset)
|
||||
|
@ -88,6 +103,9 @@ for _,t in pairs(tests) do
|
|||
end
|
||||
end
|
||||
|
||||
if(test_count>rtest_count) then
|
||||
print(red.."missing "..test_count - rtest_count.." tests (from ./test/)")
|
||||
end
|
||||
if(fail==0) then
|
||||
print(green.."all "..pass.." test(s) passed, all good:3"..reset)
|
||||
else
|
||||
|
|
|
@ -1,3 +1,3 @@
|
|||
(def a 20)
|
||||
(def a (+ (+ 20 20) a))
|
||||
(def a (+ (+ a 20) 20))
|
||||
(exit a)
|
||||
|
|
|
@ -0,0 +1,6 @@
|
|||
(def meow {1,(+ 2 2),{5},4,5,6})
|
||||
(write (get meow 5))
|
||||
(set meow 5 2222)
|
||||
(write (get (get meow 2) 0))
|
||||
(write (get meow 5))
|
||||
(exit (get meow 1))
|
|
@ -0,0 +1,3 @@
|
|||
(defn name 1
|
||||
((write "test")(write "whar")))
|
||||
(name)
|
|
@ -1 +0,0 @@
|
|||
()
|
|
@ -0,0 +1 @@
|
|||
(write (&& 1 1))
|
|
@ -0,0 +1,2 @@
|
|||
(def uu (+ 2 2))
|
||||
(write (* uu 9))
|
Loading…
Reference in New Issue