amelia
/
llisp
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

ARRAYS WOOHOO

This commit is contained in:
ame 2023-09-14 09:48:17 -05:00
parent 2554a1ec80
commit 2225e0a600
7 changed files with 144 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

61
src/builtins.cc
View File

@ -20,6 +20,7 @@ namespace builtin {
continue;
}
}
std::cout<<s->names[l.args[i].ident].type;
return false;
} else {
object tt = cast_o(l.args[i],args[i]);
@ -35,51 +36,67 @@ 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)];
}
}

30
src/builtins.hh
View File

@ -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,18 @@ namespace builtin {
}
};
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 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*);
}
@ -65,10 +67,12 @@ 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 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}
};
void ttest(lexi);

3
src/interp.cc
View File

@ -5,7 +5,8 @@ std::any single_ex(lexi l, state*s){
p_ferr("undefined refrence to "+l.oper+" on line:"+std::to_string(l.line)+":"+std::to_string(l._char),1);
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){

82
src/parser.cc
View File

@ -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;
@ -38,7 +102,8 @@ void object::gen_value(){
case REF:
case NUMBER:
case ANON:
case ARRAY:
break;
case ANY:
break;
}
@ -52,9 +117,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();
}
@ -71,10 +142,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){
@ -170,6 +237,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){

3
src/parser.hh
View File

@ -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;

10
src/state.cc
View File

@ -1,7 +1,7 @@
#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);
@ -17,7 +17,13 @@ object dtype(object l, std::any a, type t){
case REF:
case ANON:
case ARRAY:
break;
case ANY:
//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;
}
@ -37,7 +43,7 @@ lexi state::gen_args(std::vector<type> b, lexi i){
i.args[x] = cast_o(names[i.args[x].ident],b[x]);
}
} 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]);
} else if(b[x]!=ANY&&b[x]!=i.args[x].type){

1
src/test.cc
View File

@ -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;
}