[IPL/T] Overhauled how functions are handled, added list type

25 files changed, 251 insertions, 195 deletions

diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitor.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitor.cpp
index 1fce314..98af7f8 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitor.cpp
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitor.cpp
@@ -2,80 +2,145 @@
 #include <vector>
 #include "LLVMVisitor.h"
 
-LLVMVisitor::LLVMVisitor(const char* fileName) : outFile(std::ofstream(fileName)), greg("@v"), lreg("%v") {
-	if (!outFile.is_open())
-		throw std::runtime_error("Couldn't open file for writing!");
-	// outFile << "define i32 @main() {\n";
+LLVMRet LLVMVisitor::f_defun(const std::vector<Value*>& args) {
+	Name* fname = static_cast<Name*>(args[0]);
+	List* fargs = static_cast<List*>(args[1]);
+
+	/* Transform into IR of structure
+	 * define @name(T arg1, T arg2) {
+	 * ...
+	 *     ret T %reg
+	 * }
+	 */
+
+	lreg.reset();
+
+	LLVMRet funcRet;
+	unsigned outbodySize = outBuf.size();
+	for (unsigned i = 2; i < args.size(); i++) {
+		funcRet = args[i]->Visit(*this);
+	}
+	
+	std::map<std::string, LLVMRet> locals;
+	outFile << "define " << funcRet.type << " @" << fname->get_value() << "(";
+
+	for (Value* v : fargs->get_value()) {
+		std::string name = "%_" + static_cast<Name*>(v)->get_value();
+		// TODO: figure out argument type, based on usage
+		outFile << "i32 " << name;
+		locals.insert({ name, { "i32", name } });
+		if (v != fargs->get_value().back())
+			outFile << ", ";
+	}
+	outFile << ") {\n";
+
+	for (unsigned i = outbodySize; i < outBuf.size(); i++) {
+		outFile << outBuf[i];
+	}
+	while (outbodySize < outBuf.size()) {
+		outBuf.pop_back();
+	}
+
+	outFile << "\tret " << funcRet << "\n}\n\n";
+	return { funcRet.type, "@" + fname->get_value() };
 }
 
-void LLVMVisitor::finalizeFile() {
-	// outFile << "ret i32 0\n}\n";
+LLVMRet LLVMVisitor::nameAsVar(const Name* name, std::map<std::string, LLVMRet>& locals) {
+	auto asLoc = locals.find("%_" + name->get_value());
+	if (asLoc != locals.end())
+		return asLoc->second;
+
+	auto asVar = vars_user.find("@" + name->get_value());
+	if (asVar != vars_user.end())
+		return asVar->second;
+
+	auto asFunc = funcs_user.find("@" + name->get_value());
+	if (asFunc != funcs_user.end())
+		return asFunc->second;
+
+	// TODO: try to figure out type (f_defun)
+	LLVMRet newLocal = { "i32", "%_" + name->get_value() };
+	locals.insert({ newLocal.addr, newLocal });
+	return newLocal;
 }
 
-std::string LLVMVisitor::Visit(const Integer& vint) {
-	return std::to_string(vint.get_value());
+LLVMRet LLVMVisitor::aritop(const std::string name, const std::vector<Value*>& args, unsigned astart) {
+	LLVMRet leftRet = args[astart]->Visit(*this);
+	LLVMRet rightRet = (args.size() - astart > 2) ? aritop(name, args, astart+1)
+	                                              : args[astart+1]->Visit(*this);
+	
+	Register r = lreg++;
+	outBuf.push_back(*r + " = " + ((leftRet.type == "double") ? "f" : "") + name + " " + leftRet.toStr() + ", " + rightRet.addr + "\n");
+
+	return { leftRet.type, *r };
 }
 
-std::string LLVMVisitor::Visit(const Float& vfloat) {
-	return std::to_string(vfloat.get_value());
+LLVMRet LLVMVisitor::f_add(const std::vector<Value*>& args) {
+	return aritop("add", args);
 }
 
-std::string LLVMVisitor::Visit(const Name& vname) {
-	return vname.get_value();
+LLVMRet LLVMVisitor::f_sub(const std::vector<Value*>& args) {
+	return aritop("sub", args);
 }
 
-std::string LLVMVisitor::Visit(const Funcall& vfuncall) {
-	if (std::find(gfuncs.begin(), gfuncs.end(), vfuncall) == gfuncs.end())
-		throw std::runtime_error("Function doesn't exist!");
+LLVMRet LLVMVisitor::Visit(const Funcall& vfuncall) {
+	// Direct functions generate their own LLVM IR
+	auto directFuncIt = funcs_direct.find(vfuncall.get_funname());
+	if (directFuncIt != funcs_direct.end())
+		return directFuncIt->second(*this, vfuncall.get_args());
 
-	std::vector<std::string> pargs;
+	auto userFuncIt = funcs_user.find(vfuncall.get_funname());
+	if (userFuncIt == funcs_user.end())
+		throw std::runtime_error("Function isn't defined!");
+
+	/* Transform into IR of structure:
+	 * %0 = call T @func(T %a1, T %a2)
+	 */
+
+	std::vector<LLVMRet> pargs;
 	for (Value* arg : vfuncall.get_args())
 		pargs.push_back(arg->Visit(*this));
 
 	std::string valReg = *(lreg++);
-	outFile << valReg << " = call i32 " << vfuncall.get_funname() << "(";
-	for (std::string arg : pargs)
-		outFile << "i32 " << arg << ", ";
-	outFile << ")\n";
-	return valReg;
+	std::string out = valReg + " = call " + userFuncIt->second.toStr() + "(";
+	for (LLVMRet& arg : pargs) {
+		out += arg.toStr();
+		if (arg.addr != pargs.back().addr)
+			out += ", ";
+	}
+	outBuf.push_back(out += ")\n");
+	return { userFuncIt->second.type, valReg };
 }
 
-void f_add(std::string reg, Value::T_Primitive ty, std::string first, std::string second, std::ofstream& of) {
-	of << reg << " = ";
-	switch(ty) {
-		case Value::T_integer: of << "add i32"; break;
-		case Value::T_float: of << "fadd double"; break;
-		default: throw std::runtime_error("Invalid type for function!");
-	}
-	of << " " << first << ", " << second << "\n";
+LLVMVisitor::LLVMVisitor(const char* fileName) : outFile(std::ofstream(fileName)), greg("@v"), lreg("%v"), funcs_direct(), funcs_user(), vars_user(), outBuf() {
+	if (!outFile.is_open())
+		throw std::runtime_error("Couldn't open file for writing!");
+
+	funcs_direct.insert({"+", &LLVMVisitor::f_add});
+	funcs_direct.insert({"-", &LLVMVisitor::f_sub});
+	funcs_direct.insert({"defun", &LLVMVisitor::f_defun});
 }
 
-void f_sub(std::string reg, Value::T_Primitive ret, std::string first, std::string second, std::ofstream& of) {
-	of << reg << " = ";
-	switch(ret) {
-		case Value::T_integer: of << "sub i32"; break;
-		case Value::T_float: of << "fsub double"; break;
-		default: throw std::runtime_error("Invalid type for function!");
+void LLVMVisitor::insertMain() {
+	outFile << "define i32 @main() {\n";
+	for (std::string& codeline : outBuf) {
+		outFile << codeline;
 	}
-	of << " " << first << ", " << second << "\n";
+	outFile << "ret i32 0\n}\n";
 }
 
-std::string LLVMVisitor::rightAssoc(BiFout f, const BuiltInFunction& bfun, unsigned i) {
-	std::string leftArg = bfun.get_args()[i]->Visit(*this);
-	std::string rightArg;
-	if (bfun.get_args().size() - 2 == i)
-		rightArg = bfun.get_args()[i+1]->Visit(*this);
-	else
-		rightArg = rightAssoc(f, bfun, i+1);
+LLVMRet LLVMVisitor::Visit(const Integer& vint) {
+	return { "i32", std::to_string(vint.get_value()) };
+}
 
-	std::string valRegister = *(lreg++);
-	f(valRegister, bfun.RetType(), leftArg, rightArg, outFile);
-	return valRegister;
+LLVMRet LLVMVisitor::Visit(const Float& vfloat) {
+	return { "double", std::to_string(vfloat.get_value()) };
 }
 
-std::string LLVMVisitor::Visit(const BuiltInFunction& bfun) {
-	if (bfun.get_name() == "+") return rightAssoc(f_add, bfun);
-	if (bfun.get_name() == "-") return rightAssoc(f_sub, bfun);
+LLVMRet LLVMVisitor::Visit(const Name& vname) {
+	return { "name", vname.get_value() };
+}
 
-	return "";
+LLVMRet LLVMVisitor::Visit(const List& vlist) {
+	return { "", "" }; // TODO
 }
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitor.h b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitor.h
index 9354ca1..65c6498 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitor.h
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitor.h
@@ -3,33 +3,46 @@
 
 #include <fstream>
 #include <vector>
+#include <map>
 #include <algorithm>
+#include <functional>
 #include "Register.h"
+#include "LLVMVisitorReturn.h"
 #include "../Value/Integer.h"
 #include "../Value/Float.h"
 #include "../Value/Name.h"
+#include "../Value/List.h"
 #include "../Value/Function/Funcall.h"
-#include "../Value/Function/BuiltInFunction.h"
-#include "../Value/Function/UserFunction.h"
 
 class LLVMVisitor {
 	std::ofstream outFile;
 	Register greg;
 	Register lreg;
-	std::vector<std::string> gfuncs;
-	std::vector<std::string> gvars;
 
-	typedef void (&BiFout)(std::string reg, Value::T_Primitive ty, std::string first, std::string second, std::ofstream& of);
-	std::string rightAssoc(BiFout f, const BuiltInFunction& bfun, unsigned i = 0);
+	typedef std::function<LLVMRet(LLVMVisitor&, const std::vector<Value*>& args)> f_direct;
+	std::map<std::string, f_direct> funcs_direct;
+	
+	typedef const std::vector<Value*>& funcargs;
+	LLVMRet f_defun(funcargs args);
+	LLVMRet nameAsVar(const Name* name, std::map<std::string, LLVMRet>& locals);
+
+	LLVMRet aritop(const std::string name, funcargs args, unsigned astart = 0);
+	LLVMRet f_add(funcargs args);
+	LLVMRet f_sub(funcargs args);
+
+	std::map<std::string, LLVMRet> funcs_user;
+	std::map<std::string, LLVMRet> vars_user;
+
+	std::vector<std::string> outBuf;
 
 public:
-	std::string Visit(const Integer& vint);
-	std::string Visit(const Float& vfloat);
-	std::string Visit(const Name& vname);
-	std::string Visit(const Funcall& vfuncall);
-	std::string Visit(const BuiltInFunction& bfun);
+	LLVMRet Visit(const Integer& vint);
+	LLVMRet Visit(const Float& vfloat);
+	LLVMRet Visit(const Name& vname);
+	LLVMRet Visit(const List& vlist);
+	LLVMRet Visit(const Funcall& vfuncall);
 
-	void finalizeFile();
+	void insertMain();
 	LLVMVisitor(const char* fileName);
 };
 
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitorReturn.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitorReturn.cpp
new file mode 100644
index 0000000..27daa83
--- /dev/null
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitorReturn.cpp
@@ -0,0 +1,9 @@
+#include "LLVMVisitorReturn.h"
+
+std::string LLVMRet::toStr() const {
+	return type + ((type.empty() || addr.empty()) ? "" : " ") + addr;
+}
+
+std::ostream& operator<<(std::ostream& ostr, const LLVMRet& ret) {
+	return ostr << ret.toStr();
+}
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitorReturn.h b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitorReturn.h
new file mode 100644
index 0000000..fb73c94
--- /dev/null
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/LLVMVisitorReturn.h
@@ -0,0 +1,16 @@
+#ifndef LLVMVISITOR_RETURN
+#define LLVMVISITOR_RETURN
+
+#include <string>
+#include <ostream>
+
+struct LLVMRet {
+	std::string type;
+	std::string addr;
+
+	std::string toStr() const;
+};
+
+std::ostream& operator<<(std::ostream& ostr, const LLVMRet& ret);
+
+#endif
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/Register.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/Register.cpp
index 873d4e0..5d125a7 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/Register.cpp
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/Register.cpp
@@ -13,6 +13,14 @@ Register Register::operator++(int) {
 	return old;
 }
 
-std::string Register::operator*() {
+std::string Register::operator*() const {
 	return prepend + std::to_string(counter);
 }
+
+void Register::reset() {
+	counter = 0;
+}
+
+std::ostream& operator<<(std::ostream& ostr, const Register& reg) {
+	return ostr << *reg;
+}
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/Register.h b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/Register.h
index 768cfbc..ff51129 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/Register.h
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/LLVMVisitor/Register.h
@@ -2,6 +2,7 @@
 #define LLVMVISITOR_REGISTER
 
 #include <string>
+#include <ostream>
 
 class Register {
 	std::string prepend;
@@ -11,7 +12,10 @@ public:
 	Register(std::string prepend);
 	Register& operator++();
 	Register operator++(int);
-	std::string operator*();
+	std::string operator*() const;
+	void reset();
 };
 
+std::ostream& operator<<(std::ostream& ostr, const Register& reg);
+
 #endif
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Casting.h b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Casting.h
deleted file mode 100644
index e69de29..0000000
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Casting.h
+++ /dev/null
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Float.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Float.cpp
index 91268d7..d3a3c04 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Float.cpp
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Float.cpp
@@ -1,14 +1,10 @@
 #include "Float.h"
 #include "../LLVMVisitor/LLVMVisitor.h"
 
-std::string Float::Visit(LLVMVisitor& visitor) const {
+LLVMRet Float::Visit(LLVMVisitor& visitor) const {
 	return visitor.Visit(*this);
 }
 
-Value::T_Primitive Float::RetType() const {
-	return Value::T_float;
-}
-
 const double& Float::get_value() const {
 	return this->value;
 }
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Float.h b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Float.h
index 0f47be1..b87fd18 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Float.h
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Float.h
@@ -6,8 +6,7 @@
 class Float : public Value {
 	double value;
 public:
-	std::string Visit(LLVMVisitor& visitor) const override;
-	T_Primitive RetType() const override;
+	LLVMRet Visit(LLVMVisitor& visitor) const override;
 	const double& get_value() const;
 
 	Float(double value);
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/BuiltInFunction.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/BuiltInFunction.cpp
deleted file mode 100644
index 954c8da..0000000
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/BuiltInFunction.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "BuiltInFunction.h"
-#include "../../LLVMVisitor/LLVMVisitor.h"
-
-std::string BuiltInFunction::Visit(LLVMVisitor& visitor) const {
-	return visitor.Visit(*this);
-}
-
-Value::T_Primitive BuiltInFunction::RetType() const {
-	if (args.empty())
-		return T_void;
-	return args.front()->RetType();
-}
-
-BuiltInFunction::BuiltInFunction(std::string name, std::deque<Value*> args) : Function(name, args) {}
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/BuiltInFunction.h b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/BuiltInFunction.h
deleted file mode 100644
index c4ea301..0000000
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/BuiltInFunction.h
+++ /dev/null
@@ -1,13 +0,0 @@
-#ifndef VALUE_ADDFUNCTION
-#define VALUE_ADDFUNCTION
-
-#include "Function.h"
-
-class BuiltInFunction : public Function {
-public:
-	std::string Visit(LLVMVisitor& visitor) const override;
-	T_Primitive RetType() const override;
-	BuiltInFunction(std::string name, std::deque<Value*> args);
-};
-
-#endif
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Funcall.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Funcall.cpp
index e69de29..df88001 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Funcall.cpp
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Funcall.cpp
@@ -0,0 +1,16 @@
+#include "Funcall.h"
+#include "../../LLVMVisitor/LLVMVisitor.h"
+
+const std::string& Funcall::get_funname() const {
+	return funName;
+}
+
+const std::vector<Value*>& Funcall::get_args() const {
+	return args;
+}
+
+LLVMRet Funcall::Visit(LLVMVisitor& visitor) const {
+	return visitor.Visit(*this);
+}
+
+Funcall::Funcall(std::string funName, std::vector<Value*> args) : funName(funName), args(args) {}
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Funcall.h b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Funcall.h
index 5afc51d..30dda60 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Funcall.h
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Funcall.h
@@ -1,20 +1,19 @@
 #ifndef VALUE_FUNCALL
 #define VALUE_FUNCALL
 
-#include <deque>
+#include <vector>
 #include "../Value.h"
 
 class Funcall : public Value {
 	std::string funName;
-	std::deque<Value*> args;
+	std::vector<Value*> args;
 public:
 	const std::string& get_funname() const;
-	const std::deque<Value*>& get_args() const;
+	const std::vector<Value*>& get_args() const;
 
-	std::string Visit(LLVMVisitor& visitor) const override;
-	T_Primitive RetType() const override;
+	LLVMRet Visit(LLVMVisitor& visitor) const override;
 
-	Funcall(std::string funName, std::deque<Value*> args);
+	Funcall(std::string funName, std::vector<Value*> args);
 	~Funcall() override = default;
 };
 
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Function.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Function.cpp
deleted file mode 100644
index 9e35eab..0000000
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Function.cpp
+++ /dev/null
@@ -1,12 +0,0 @@
-#include "Function.h"
-#include "../../LLVMVisitor/LLVMVisitor.h"
-
-const std::string& Function::get_name() const {
-	return name;
-}
-
-const std::deque<Value*> Function::get_args() const {
-	return args;
-}
-
-Function::Function(std::string name, std::deque<Value*> args) : name(name), args(args) {}
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Function.h b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Function.h
deleted file mode 100644
index 34e3ea1..0000000
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/Function.h
+++ /dev/null
@@ -1,21 +0,0 @@
-#ifndef VALUE_FUNCTION
-#define VALUE_FUNCTION
-
-#include <string>
-#include <deque>
-#include "../Value.h"
-
-class Function : public Value {
-protected:
-	std::string name;
-	std::deque<Value*> args;
-
-public:
-	const std::string& get_name() const;
-	const std::deque<Value*> get_args() const;
-
-	Function(std::string name, std::deque<Value*> args);
-	~Function() override = default;
-};
-
-#endif
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/UserFunction.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/UserFunction.cpp
deleted file mode 100644
index a9841d3..0000000
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/UserFunction.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-#include "UserFunction.h"
-#include "../../LLVMVisitor/LLVMVisitor.h"
-
-std::string UserFunction::Visit(LLVMVisitor& visitor) const {
-	return visitor.Visit(*this);
-}
-
-Value::T_Primitive UserFunction::RetType() const {
-	if (body.empty())
-		return T_void;
-	return body.back()->RetType();
-}
-
-UserFunction::UserFunction(std::string name, std::deque<Value*> args, std::deque<Function*> body) : Function(name, args), body(body) {}
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/UserFunction.h b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/UserFunction.h
deleted file mode 100644
index 17cf931..0000000
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Function/UserFunction.h
+++ /dev/null
@@ -1,16 +0,0 @@
-#ifndef VALUE_USERFUNCTION
-#define VALUE_USERFUNCTION
-
-#include <deque>
-#include "Function.h"
-
-class UserFunction : public Function {
-	std::deque<Function*> body;
-
-public:
-	std::string Visit(LLVMVisitor& visitor) const override;
-	T_Primitive RetType() const override;
-	UserFunction(std::string name, std::deque<Value*> args, std::deque<Function*> body);
-};
-
-#endif
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Integer.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Integer.cpp
index 01bbe54..6fb7b73 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Integer.cpp
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Integer.cpp
@@ -1,14 +1,10 @@
 #include "Integer.h"
 #include "../LLVMVisitor/LLVMVisitor.h"
 
-std::string Integer::Visit(LLVMVisitor& visitor) const {
+LLVMRet Integer::Visit(LLVMVisitor& visitor) const {
 	return visitor.Visit(*this);
 }
 
-Value::T_Primitive Integer::RetType() const {
-	return Value::T_integer;
-}
-
 const int& Integer::get_value() const {
 	return this->value;
 }
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Integer.h b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Integer.h
index 4a84c31..86aafb9 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Integer.h
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Integer.h
@@ -6,8 +6,7 @@
 class Integer : public Value {
 	int value;
 public:
-	std::string Visit(LLVMVisitor& visitor) const override;
-	T_Primitive RetType() const override;
+	LLVMRet Visit(LLVMVisitor& visitor) const override;
 	const int& get_value() const;
 
 	Integer(int value);
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/List.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/List.cpp
new file mode 100644
index 0000000..63a7e01
--- /dev/null
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/List.cpp
@@ -0,0 +1,12 @@
+#include "List.h"
+#include "../LLVMVisitor/LLVMVisitor.h"
+
+LLVMRet List::Visit(LLVMVisitor& visitor) const {
+	return visitor.Visit(*this);
+}
+
+const std::vector<Value*>& List::get_value() const {
+	return vals;
+}
+
+List::List(std::vector<Value*> val) : vals(val) {}
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/List.h b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/List.h
new file mode 100644
index 0000000..770b87b
--- /dev/null
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/List.h
@@ -0,0 +1,17 @@
+#ifndef VALUE_LIST
+#define VALUE_LIST
+
+#include <vector>
+#include "Value.h"
+
+class List : public Value {
+	std::vector<Value*> vals;
+public:
+	LLVMRet Visit(LLVMVisitor& visitor) const override;
+	const std::vector<Value*>& get_value() const;
+
+	List(std::vector<Value*> val);
+	~List() override = default;
+};
+
+#endif
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Name.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Name.cpp
index 52094b9..cd92df3 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Name.cpp
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Name.cpp
@@ -1,17 +1,12 @@
 #include "Name.h"
-#include "Value.h"
 #include "../LLVMVisitor/LLVMVisitor.h"
 
 const std::string& Name::get_value() const {
 	return val;
 }
 
-std::string Name::Visit(LLVMVisitor& visitor) const {
+LLVMRet Name::Visit(LLVMVisitor& visitor) const {
 	return visitor.Visit(*this);
 }
 
-Value::T_Primitive Name::RetType() const {
-	return T_name;
-}
-
 Name::Name(std::string val) : val(val) {}
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Name.h b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Name.h
index b242c06..b0e0693 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Name.h
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Name.h
@@ -10,8 +10,7 @@ class Name : public Value {
 public:
 	const std::string& get_value() const;
 
-	std::string Visit(LLVMVisitor& visitor) const override;
-	T_Primitive RetType() const override;
+	LLVMRet Visit(LLVMVisitor& visitor) const override;
 
 	Name(std::string);
 	~Name() override = default;
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Value.h b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Value.h
index a675d13..dd5dc2a 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Value.h
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/Value/Value.h
@@ -4,17 +4,11 @@
 #include <string>
 
 class LLVMVisitor;
+struct LLVMRet;
 
 class Value {
 public:
-	enum T_Primitive {
-		T_void,
-		T_name,
-		T_integer,
-		T_float,
-	};
-	virtual std::string Visit(LLVMVisitor& visitor) const = 0;
-	virtual T_Primitive RetType() const = 0;
+	virtual LLVMRet Visit(LLVMVisitor& visitor) const = 0;
 	virtual ~Value() {};
 };
 
diff --git a/Year 2/Implementation of Programming Languages/Transpiler/src/main.cpp b/Year 2/Implementation of Programming Languages/Transpiler/src/main.cpp
index 7fc9bcf..319f408 100644
--- a/Year 2/Implementation of Programming Languages/Transpiler/src/main.cpp
+++ b/Year 2/Implementation of Programming Languages/Transpiler/src/main.cpp
@@ -1,18 +1,27 @@
 #include <iostream>
 #include <deque>
 #include "LLVMVisitor/LLVMVisitor.h"
-#include "Value/Function/BuiltInFunction.h"
+#include "Value/Function/Funcall.h"
 
 int main() {
 	LLVMVisitor visitor("testout.ll");
 	std::deque<Value*> nodes = {
-		new BuiltInFunction("+", {
+		new Funcall("+", {
 				new Float(1),
+				new Funcall("-", { new Float(5), new Float(10) }),
 				new Float(2),
-				new BuiltInFunction("-", { new Float(5), new Float(10) }),
-				new Float(123) }) };
+				new Float(123) }),
+		new Funcall("defun", {
+				new Name("notfun"),
+				new List({new Name("a"), new Name("b")}),
+				new Funcall("+", {
+						new Integer(7),
+						new Name("a"),
+						new Name("b")
+						}) })
+	};
 	for (Value* n : nodes) {
 		n->Visit(visitor);
 	}
-	visitor.finalizeFile();
+	visitor.insertMain();
 }