progress on variables

src/builtins.cc

@@ -1,43 +1,63 @@
 #include "builtins.hh"
+#include "pretty.hh"
 
 namespace builtin {
-			bool builtin::check_args(lexi l){
-			if(l.args.size()!=args.size())
+			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(l.args[i].type!=args[i]) return false;	
+				if(args[i]==ANY) break;
+				if(l.args[i].type!=args[i]){
+					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])
+							continue;
+						return false;
+					}
+					return false;
+				};	
 			}
 			return true;
 		}
 
 		
 
-	std::any a_exit(lexi l){
-		exit(std::get<int>(l.args[0].value));
+	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);
+		exit(ex);
 	}
-	std::any write(lexi l){
+	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){	
+	std::any _if(lexi l, state* s){	
 		if(std::get<int>(l.args[0].value)==1)
-			interp(l.args[1].to_larray());
+			interp(l.args[1].to_larray(),s);
 		else
-			interp(l.args[2].to_larray());	
+			interp(l.args[2].to_larray(),s);	
 		//std::cout<<batch_format(l.args[1].to_larray(),0);
 
 		return 0;	
 	}
-	std::any __anon(lexi l){
+	std::any __anon(lexi l,state* s){
 		for(object o : l.args)
-			interp(o.n_value);
+			interp(o.n_value,s);
+		return 0;
+	}
+	std::any _def(lexi l,state *s){
+		s->set(l.args[0].ident,l.args[1]);
 		return 0;
 	}
 }
 
 void ttest(lexi l){
 	//std::cout<<write.check_args(l)<<std::endl;
-	(void)builtins["write"]->exec(l);
+	//(void)builtins["write"]->exec(l);
 	//a.exec = tes;
 	//std::cout<<std::any_cast<typeid(typemap[INT])>(a.exec({5}));
 }

src/builtins.hh

@@ -7,6 +7,7 @@
 #include <functional>
 #include "stdarg.h"
 #include "interp.hh"
+#include "state.hh"
 
 namespace builtin {
 	class builtin {
@@ -14,11 +15,11 @@ namespace builtin {
 		std::string call = "";
 		std::vector<type> args = {};
 		type _return = NONE;	
-		std::any(*exec)(lexi);
+		std::any(*exec)(lexi, state*);
 
-		bool check_args(lexi l);
+		bool check_args(lexi, state*);
 
-		builtin(std::string _call, std::vector<type> _args, type __return, std::any(*e)(lexi)){
+		builtin(std::string _call, std::vector<type> _args, type __return, std::any(*e)(lexi, state*)){
 			call = _call;
 			args = _args;
 			_return = __return;
@@ -26,10 +27,11 @@ namespace builtin {
 		}
 	};
 
-	std::any a_exit(lexi l);
-	std::any write(lexi l);
-	std::any _if(lexi l);
-	std::any __anon(lexi l);
+	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);
 }
 
 
@@ -37,9 +39,10 @@ static builtin::builtin _write("write",{STRING},NONE,builtin::write);
 static builtin::builtin _exit("exit",{INT},NONE,builtin::a_exit);
 static builtin::builtin _if("if",{INT,STATEMENT,STATEMENT},NONE,builtin::_if);
 static builtin::builtin __anon("if",{ANY},NONE,builtin::__anon);
+static builtin::builtin _def("def",{ANY},NONE,builtin::_def);
 
 static std::map<std::string, builtin::builtin*> builtins = {
-	{"write",&_write},{"exit",&_exit},{"if",&_if},{"__anon",&__anon}
+	{"write",&_write},{"exit",&_exit},{"if",&_if},{"__anon",&__anon},{"def",&_def}
 
 };
 

src/interp.cc

@@ -1,14 +1,19 @@
 #include "interp.hh"
 #include "pretty.hh"
 #include "builtins.hh"
+#include "state.hh"
 
-void interp(std::vector<lexi> inp){
+void interp(std::vector<lexi> inp, state* s){
 	//std::cout<<batch_format(inp, 0);
-	//std::cout<<inp[0].args[0].value.index();
-	
+	//std::cout<<inp[0].args[0].value.index();	
+	//return;
 	for(lexi l : inp){
 		if(!builtins.count(l.oper)&&l.oper!="__anon")
 			p_ferr("undefined refrence to "+l.oper+" on line:"+std::to_string(l.line)+":"+std::to_string(l._char),1);
-		builtins[l.oper]->exec(l);
+		if(!builtins[l.oper]->check_args(l,s))
+			p_ferr("incorrect usage on "+l.oper,1);
+		builtins[l.oper]->exec(l,s);
+		//std::cout<<s->names[l.args[0].ident].ident;
 	}
+	
 }

src/interp.hh

@@ -1,5 +1,5 @@
 #include "parser.hh"
 #include <vector>
 #include <iostream>
-
-void interp(std::vector<lexi>);
+#include "state.hh"
+void interp(std::vector<lexi>, state*);

src/test.cc

@@ -5,10 +5,13 @@
 #include "interp.hh"
 #include "builtins.hh"
 #include <string>
+#include "state.hh"
+
 int main(int argc, char* argv[]){
 	//std::cout<<batch_format(test("(exit 5 22)(meow \"wharrrr\" (a 5 (aaa 5.5) ) 445)"),0);
 	//std::cout<<batch_format(test(f_read("./test/if.ll")),0);
-	interp(test(f_read(argv[1])));
+	state state;
+	interp(test(f_read(argv[1])),&state);
 	//interp(test(f_read("./test/exit.ll")));
 	return 0;
 }