Sort

src/Autoindex/Autoindex.hpp

@@ -0,0 +1,20 @@
+#ifndef AUTOINDEX_HPP
+#define AUTOINDEX_HPP
+
+#include "webserv.hpp"
+
+class Autoindex
+{
+private:
+    
+public:
+    Autoindex();
+    static std::string getPage(std::string path, std::string host);
+    static std::string getReference(std::string file, std::string dir, std::string host);
+    ~Autoindex();
+};
+
+
+
+
+#endif

src/Header/Header.hpp

@@ -0,0 +1,56 @@
+#ifndef HEADER_HPP
+# define HEADER_HPP
+
+#include "webserv.hpp"
+#include "HeaderHandl.hpp"
+#include "Autoindex.hpp"
+
+class Header
+{
+private:
+	HeaderHandl	_request;
+	HeaderHandl	_respons;
+
+private:
+	int		_row;
+	int		_ret;
+	int		_autoIndex;
+	int		_fd;
+	char	*_buff;
+
+
+	std::string	_fileToSend;
+	std::map<std::string, std::string> _headerField;
+	std::map<std::string, std::string> _errorCode;
+	
+public:
+	std::map<std::string , std::string>	getHeaderField(void);
+	HeaderHandl					getRequest(void);
+	HeaderHandl					getRespons(void);
+	std::string					getReasonPhrase(std::string);
+	std::string					getReasonPhrase(int);
+	std::string					getErrorPage(int code);
+	void						setRawData(char *);
+	void						setFd(int);
+	int							getFd(void);
+
+	void						initErrorCode(void);
+	int							isFile(std::string);
+	int							isDir(std::string);
+	void						OpenResponsFile(const char *path);
+
+	int							parseStartLine(std::string);
+	void						parseURI(std::string);
+	int							parseHeaderfield(std::string);
+	void						printHeaderInfo(void);
+	int							parseRequest(void);
+	
+	int							sendRespons(int fd);
+	int							sendHeader(int fd);
+	void						clear(void);
+	Header();
+	Header(char *);
+	~Header();
+};
+
+#endif

src/Header/HeaderHandl.hpp

@@ -0,0 +1,37 @@
+#ifndef HEADERHANDL_HPP
+#define HEADERHANDL_HPP
+
+#include <iostream>
+#include <map>
+
+class HeaderHandl
+{
+public:
+    std::string _method;
+    std::string _URI;
+    std::string _fullURI;
+    std::string _version;
+    std::string _query;
+public:
+    // std::string _allow;
+    // std::string _contentLenght;
+    std::string _contentType;
+    std::string _host;
+    // std::string _contentLanguage;
+    std::string _contentLocation;
+    // std::string _date;
+    // std::string _lastModified;
+    // std::string _transferEncoding;
+    // std::string _server;
+    // std::string _location;
+public:
+    HeaderHandl();
+    
+    void    copyData(std::map<std::string, std::string>);
+
+    ~HeaderHandl();
+};
+
+
+
+#endif

src/Server/Server.cpp

@@ -1,4 +1,5 @@
-#include "webserv.hpp"
+#include "Server.hpp"
+
 //----------------------------------------------Constructors-----------------------------------------------------------------------------------
 Server::Server()
 {
@@ -17,6 +18,36 @@ Server::Server(std::string path)
 //----------------------------------------------Configuration-----------------------------------------------------------------------------------
 void	Server::readConfig(void)
 {
+	TOMLMap *root = parse();
+
+
+	TOMLMap *map;
+	TOMLMap::iterator it1;
+	TOMLMapArray	*arr;
+	TOMLMapArray::iterator	it;
+
+
+	arr = root->find("server")->second->getMapArray();
+	it = arr->begin();
+
+	while (it != arr->end())
+	{
+		std::cout << BLUE << *it << std::endl;
+		map = *it;
+
+		it1 = map->begin();
+		while (it1 != map->end())
+		{
+			std::cout << TURGUOISE << it1->first << it1->second << ZERO_C << std::endl;
+			++it1;
+		}
+		
+
+		++it;
+	}
+	
+
+	
 
 }
 

src/Server/Server.hpp

@@ -0,0 +1,42 @@
+#ifndef SERVER_HPP
+#define SERVER_HPP
+
+#include "webserv.hpp"
+#include "Header.hpp"
+#include "ServerConfig.hpp"
+#include "Socket.hpp"
+#include "parse.hpp"
+
+class Header;
+
+class Server
+{
+private:
+	int	_port;
+	int	_epolfd;
+	int	_client;
+	struct epoll_event	_events[MAX_CLIENT];
+	struct sockaddr_in _addres;
+	std::string _ip;
+	std::vector<ServerConfig>	_configs;
+
+private:
+	void checkError(int fd, std::string str);
+	void sendFile(std::string str);
+	void sendHeader(Header head, int);
+	void sendRespons(Header head, int);
+	void setNonblocking(int fd);
+	void newConnection(int fd);
+public:
+	Server();
+	Server(std::string path);
+
+	void readConfig(void);
+	void setupConfig(void);
+	void start(void);
+	void end(void);
+	~Server();
+};
+
+
+#endif

src/Server/ServerConfig.hpp

@@ -0,0 +1,59 @@
+#ifndef SERVERCONFIG_HPP
+#define SERVERCONFIG_HPP
+
+#include "webserv.hpp"
+
+struct location
+{
+	std::string					location;
+	std::string					root;
+	std::string					directoryFile;
+	std::string					uploadDir;
+	bool						autoindex;
+	bool						uploadAccept;
+	std::vector<std::string>	methods;
+	std::map<int, std::string>	redirect;
+};
+
+class ServerConfig
+{
+private:
+	// TOMLMap		*_root;
+	std::string	_serverName;
+	std::string _host;
+	int			_port;
+	int			_clientBodySize;
+
+	std::map<int, std::string>	_errorPages;
+	std::vector<location>		_locations;
+
+public:
+	void	setServerName(std::string);
+	void	setHost(std::string);
+	void	setPort(int);
+	void	setClientBodySize(int);
+	void	setErrorPages(std::map<int, std::string>);
+	void	setLocations(std::vector<location>);
+	// void	setRoot(TOMLMap *);
+
+	std::string					getServerName(void);
+	std::string					getHost(void);
+	int							getPort(void);
+	int							getClientBodySize(void);
+	std::vector<location>		getLocations(void);
+	std::map<int, std::string>	getErrorPages(void);
+	// TOMLMap						*getRoot(void);
+
+public:
+	ServerConfig();
+	// ServerConfig(TOMLMap	*root);
+	
+	void	fillFields(void);
+	
+	~ServerConfig();
+};
+
+
+
+
+#endif

src/Server/Socket.hpp

@@ -0,0 +1,33 @@
+#ifndef SOCKET_HPP
+#define SOCKET_HPP
+
+#include "webserv.hpp"
+class Socket
+{
+private:
+    int                 _socketFd;
+    socklen_t           _addrlen;
+	struct sockaddr_in  _addres;
+
+    
+public:
+    Socket();
+    Socket(int domain, int type, int protocol, int port, std::string ip);
+    int getSocketFd(void);
+    struct sockaddr_in getAddres(void);
+    socklen_t getAddlen(void);
+    struct sockaddr *getSockaddr(void);
+    socklen_t *getSocklen(void);
+    void setSocketFd(int);
+    void setAddres(struct sockaddr_in);
+    int bindingSocket(void);
+    int listeningSocket(int nbr);
+    int init(int nbr);
+    void checkError(int fd, std::string str);
+
+    ~Socket();
+};
+
+
+
+#endif

src/config/TOMLNode.cpp

@@ -0,0 +1,165 @@
+#include "TOMLNode.hpp"
+
+/* toml_node::toml_node(void) */
+/* { */
+/* 	return; */
+/* } */
+
+/* toml_node::toml_node(const toml_node &src) */
+/* { */
+/* 	*this = src; */
+/* 	return; */
+/* } */
+
+/* toml_node::~toml_node(void) */
+/* { */
+/* 	return; */
+/* } */
+
+/* toml_node &toml_node::operator=(const toml_node &rhs) */
+/* { */
+/* 	//code */
+/* 	return (*this); */
+/* } */
+
+toml_node::e_type toml_node::get_type(void)
+{
+	return (type);
+}
+
+TOMLMap *toml_node::getMap(void)
+{
+	return (value.map);
+}
+
+TOMLMapArray *toml_node::getMapArray(void)
+{
+	return (value.map_array);
+}
+
+void toml_node::setString(std::string *str)
+{
+	value.str = str;
+	type = STRING;
+}
+
+void toml_node::setNumber(int num)
+{
+	value.integer = num;
+	type = NUM;
+}
+
+void toml_node::setArr(TOMLArray *toml_array)
+{
+	value.array = toml_array;
+	type = ARRAY;
+}
+void toml_node::setBool(bool b)
+{
+	value.boolean = b;
+	type = BOOL;
+}
+void toml_node::setNil(void)
+{
+	type = NIL;
+}
+
+void toml_node::setObject(TOMLMap *obj)
+{
+	value.map = obj;
+	type = MAP;
+}
+
+void toml_node::setMapArray(TOMLMapArray *map_array)
+{
+	value.map_array = map_array;
+	type = MAPARRAY;
+}
+
+std::string *toml_node::toString(void) const
+{
+	switch (type)
+	{
+		case STRING:
+			{
+				return (value.str);
+			}
+		case NUM:
+			{
+				std::stringstream ss;
+				ss << value.integer;
+				std::string *result = new std::string();
+				ss >> *result;
+				return (result);
+			}
+		case ARRAY:
+			{
+				TOMLArray::iterator it;
+				std::string *result = new std::string("[ ");
+				for (it = value.array->begin(); it != value.array->end(); ++it)
+				{
+					*result += *((*it)->toString());
+					*result += ", ";
+				}
+				*result += " ]";
+				return (result);
+			}
+		case MAP:
+			{
+				return (TOMLMap_to_string(value.map));
+			}
+		case MAPARRAY:
+			{
+				std::stringstream ss;
+				std::string *result = new std::string();
+				TOMLMapArray::iterator it;
+				TOMLMapArray *map_array = value.map_array;
+
+				ss << "[\n";
+				for (it = map_array->begin(); it != map_array->end(); ++it)
+				{
+					ss << (*TOMLMap_to_string(*it));
+					ss << ", " << std::endl;
+				}
+				ss << "]\n";
+
+
+				/* ss >> *result; */
+				*result = ss.str();
+				return (result);
+			}
+		case BOOL:
+			{
+				std::string *result;
+				if (value.boolean)
+					result = new std::string("true");
+				else
+					result = new std::string("false");
+				return (result);
+			}
+		default:
+			return ( new std::string("Not implemented :)"));
+	}
+}
+
+std::string *toml_node::TOMLMap_to_string(TOMLMap *map)
+{
+	std::stringstream ss;
+	std::string *result = new std::string();
+	TOMLMap::iterator it;
+
+	ss << "{\n";
+	for (it = map->begin(); it != map->end(); ++it)
+	{
+		ss << it->first
+			<< ": "
+			<< *(it->second->toString())
+			<< std::endl;
+	}
+
+	ss << "}" << std::endl;
+
+	/* ss >> *result; */
+	*result = ss.str();
+	return (result);
+}

src/config/TOMLNode.hpp

@@ -2,6 +2,8 @@
 #define TOMLNODE_HPP
 
 #include "webserv.hpp"
+#include "tomlstuff.hpp"
+
 #include <map>
 #include <vector>
 #include <fstream>
@@ -11,9 +13,6 @@
 #include <iostream>
 #include <sstream>
 
-
-
-
 class toml_node
 {
 
@@ -37,145 +36,23 @@ class toml_node
 			STRING, NUM, BOOL, ARRAY, MAP, MAPARRAY, NIL
 		}	type;
 		
-		enum e_type get_type(void)
-		{
-			return (type);
-		}
+		enum e_type get_type(void);
 
-		TOMLMap *getMap(void)
-		{
-			return (value.map);
-		}
+		TOMLMap *getMap(void);
+		TOMLMapArray *getMapArray(void);
 
-		TOMLMapArray *getMapArray(void)
-		{
-			return (value.map_array);
-		}
+		void setString(std::string *str);
+		void setNumber(int num);
 
-		void setString(std::string *str)
-		{
-			value.str = str;
-			type = STRING;
-		}
+		void setArr(TOMLArray *toml_array);
+		void setBool(bool b);
+		void setNil(void);
+		void setObject(TOMLMap *obj);
+		void setMapArray(TOMLMapArray *map_array);
 
-		void setNumber(int num)
-		{
-			value.integer = num;
-			type = NUM;
-		}
-
-		void setArr(TOMLArray *toml_array)
-		{
-			value.array = toml_array;
-			type = ARRAY;
-		}
-		void setBool(bool b)
-		{
-			value.boolean = b;
-			type = BOOL;
-		}
-		void setNil(void)
-		{
-			type = NIL;
-		}
-		void setObject(TOMLMap *obj)
-		{
-			value.map = obj;
-			type = MAP;
-		}
-		void setMapArray(TOMLMapArray *map_array)
-		{
-			value.map_array = map_array;
-			type = MAPARRAY;
-		}
-
-		static std::string *TOMLMap_to_string(TOMLMap *map)
-		{
-			std::stringstream ss;
-			std::string *result = new std::string();
-			TOMLMap::iterator it;
-
-			ss << "{\n";
-			for (it = map->begin(); it != map->end(); ++it)
-			{
-				ss << it->first
-					<< ": "
-					<< *(it->second->toString())
-					<< std::endl;
-			}
-
-			ss << "}" << std::endl;
-
-			/* ss >> *result; */
-			*result = ss.str();
-			return (result);
-		}
-
-		std::string *toString(void) const
-		{
-			switch (type)
-			{
-				case STRING:
-				{
-					return (value.str);
-				}
-				case NUM:
-				{
-					std::stringstream ss;
-					ss << value.integer;
-					std::string *result = new std::string();
-					ss >> *result;
-					return (result);
-				}
-				case ARRAY:
-				{
-					TOMLArray::iterator it;
-					std::string *result = new std::string("[ ");
-					for (it = value.array->begin(); it != value.array->end(); ++it)
-					{
-						*result += *((*it)->toString());
-						*result += ", ";
-					}
-					*result += " ]";
-					return (result);
-				}
-				case MAP:
-				{
-					return (TOMLMap_to_string(value.map));
-				}
-				case MAPARRAY:
-				{
-					std::stringstream ss;
-					std::string *result = new std::string();
-					TOMLMapArray::iterator it;
-					TOMLMapArray *map_array = value.map_array;
-
-					ss << "[\n";
-					for (it = map_array->begin(); it != map_array->end(); ++it)
-					{
-						ss << (*TOMLMap_to_string(*it));
-						ss << ", " << std::endl;
-					}
-					ss << "]\n";
-
-
-					/* ss >> *result; */
-					*result = ss.str();
-					return (result);
-				}
-				case BOOL:
-				{
-					std::string *result;
-					if (value.boolean)
-						result = new std::string("true");
-					else
-						result = new std::string("false");
-					return (result);
-				}
-				default:
-					return ( new std::string("Not implemented :)"));
-			}
-		}
+		std::string *toString(void) const;
+		static std::string *TOMLMap_to_string(TOMLMap *map);
 };
 
+
 #endif

src/config/TOMLParser.cpp

@@ -0,0 +1,482 @@
+#include "TOMLParser.hpp"
+
+/* -Template::-Template(void) */
+/* { */
+/* 	return; */
+/* } */
+
+/* -Template::-Template(const -Template &src) */
+/* { */
+/* 	*this = src; */
+/* 	return; */
+/* } */
+
+/* -Template::~-Template(void) */
+/* { */
+/* 	return; */
+/* } */
+
+/* -Template &-Template::operator=(const -Template &rhs) */
+/* { */
+/* 	//code */
+/* 	return (*this); */
+/* } */
+
+namespace config
+{
+
+	TOMLParser::TOMLParser(const std::string filename) : tokenizer(filename)
+	{};
+
+	void TOMLParser::processMap(void)
+	{
+		std::cerr << "Processing map" << std::endl;
+		toml_node *map_node;
+		s_token current;
+
+		try { current = tokenizer.getToken(); }
+		catch (std::logic_error e)
+		{
+			std::cerr << e.what() << std::endl;
+			return;
+		}
+		if (current.type == MAP_DECL)
+		{
+			if (tokenizer.getToken().type != NEWLINE)
+				throw std::logic_error("no newline after MAP_DECL");
+			map_node = parseMap();
+		}
+		else
+			throw std::logic_error("unexpected token in processMap");
+
+		std::cout << current.value << std::endl;
+
+		std::vector<std::string> full_name;
+
+		full_name = split_name(current.value);
+		
+		put_to_subtable(root, full_name, map_node, toml_node::MAP);
+
+	}
+
+	toml_node *TOMLParser::parseMap(void)
+	{
+		std::cerr << "Parsing map" << std::endl;
+		toml_node *node = new toml_node;
+		TOMLMap *mapObject = new TOMLMap;
+		bool completed = false;
+		while (!completed)
+		{
+			if (tokenizer.hasMoreTokens())
+			{
+				s_token nextToken;
+				try { nextToken = tokenizer.getToken(); }
+				catch (std::logic_error e)
+				{
+					std::cerr << e.what() << std::endl;
+					break;
+				}
+				if (nextToken.type == MAPARRAY_DECL)
+				{
+					tokenizer.rollBackToken();
+					tokenizer.set_last(NEWLINE);
+					break;
+				}
+				else if (nextToken.type == MAP_DECL)
+				{
+					tokenizer.rollBackToken();
+					tokenizer.set_last(NEWLINE);
+					break;
+				}
+				std::string key = nextToken.value;
+				std::cerr << key << std::endl;
+				if (tokenizer.getToken().type != ASSIGN)
+					throw std::logic_error("EXPECTED assign!");
+				nextToken = tokenizer.getToken();
+				switch (nextToken.type)
+				{
+					case STRING:
+						{
+							tokenizer.rollBackToken();
+							(*mapObject)[key] = parseString();
+							break;
+						}
+					case OPEN_BRACKET:
+						{
+							(*mapObject)[key] = parseArray();
+							break;
+						}
+					case NUMBER:
+						{
+							tokenizer.rollBackToken();
+							(*mapObject)[key] = parseNumber();
+							break;
+						}
+					case BOOL:
+						{
+							tokenizer.rollBackToken();
+							(*mapObject)[key] = parseBool();
+							break;
+						}
+					case MAPARRAY_DECL:
+						{
+							std::cerr << "reached MAPARRAY_DECL in parseMap" << std::endl;
+							completed = true;
+							break;
+						}
+					default:
+						{
+							/* throw std::logic_error("jopa in parseMap"); */
+							std::cerr << "Unknown token, marking as complete" << std::endl;
+							completed = true;
+							break;
+						}
+				}
+				if (tokenizer.hasMoreTokens())
+					nextToken = tokenizer.getToken();
+				else
+					break;
+				if (nextToken.type != NEWLINE)
+				{
+					throw std::logic_error("EXPECTED newline");
+				}
+			}
+			else
+			{
+				throw std::logic_error("parseMap: no more tokens");
+			}
+		}
+		node->setObject(mapObject);
+		return (node);
+	}
+
+	void TOMLParser::processMapArray(void)
+	{
+
+		std::cerr << "Parsing MapArray" << std::endl;
+		toml_node *map_node;
+		s_token current;
+
+		try { current = tokenizer.getToken(); }
+		catch (std::logic_error e)
+		{
+			std::cerr << e.what() << std::endl;
+			return;
+		}
+		if (current.type == MAPARRAY_DECL)
+		{
+			if (tokenizer.getToken().type != NEWLINE)
+				throw std::logic_error("no newline after map_array declaration");
+			map_node = parseMap();
+		}
+		else
+			throw std::logic_error("unexpected token in processMapArray");
+
+		std::cout << current.value << std::endl;
+
+		std::vector<std::string> full_name;
+
+		full_name = split_name(current.value);
+
+		put_to_subtable(root, full_name, map_node, toml_node::MAPARRAY);
+
+	}
+
+	toml_node *TOMLParser::parseString(void)
+	{
+		/* toml_node *node; */
+		toml_node *node = new toml_node;
+		std::string *sValue;
+
+		std::cerr << "Parsing string" << std::endl;
+		s_token token = tokenizer.getToken();
+		sValue = new std::string(token.value);
+		node->setString(sValue);
+
+		return (node);
+	}
+
+	toml_node *TOMLParser::parseNumber(void)
+	{
+		toml_node *node = new toml_node;
+		int value;
+
+		std::cerr << "Parsing number" << std::endl;
+		s_token token = tokenizer.getToken();
+		value = std::atoi(token.value.c_str());
+		node->setNumber(value);
+
+		return (node);
+	}
+
+	toml_node *TOMLParser::parseArray(void)
+	{
+		std::cerr << "Parsing array" << std::endl;
+		toml_node *node;
+		toml_node *result = new toml_node;
+		TOMLArray *array = new TOMLArray;
+		bool completed = false;
+		s_token current;
+
+		while (!completed)
+		{
+			if (!tokenizer.hasMoreTokens())
+				throw std::logic_error("No more tokens");
+			else
+			{
+				current = tokenizer.getToken();
+				switch (current.type)
+				{
+					case OPEN_BRACKET:
+						{
+							node = parseArray();
+							break;
+						}
+					case STRING:
+						{
+							tokenizer.rollBackToken();
+							node = parseString();
+							break;
+						}
+					case NUMBER:
+						{
+							tokenizer.rollBackToken();
+							node = parseNumber();
+							break;
+						}
+					case BOOL:
+						{
+							tokenizer.rollBackToken();
+							node = parseBool();
+							break;
+						}
+					case NIL:
+						{
+							node = parseNil();
+							break;
+						}
+					default:
+						{
+							throw std::logic_error("unkown token in parseArray");
+						}
+
+				}
+				array->push_back(node);
+				current = tokenizer.getToken();
+				if (current.type == COMMA)
+					continue;
+				else if (current.type == CLOSE_BRACKET)
+					completed = true;
+				else
+					throw std::invalid_argument("Unexpected token in array!");
+			}
+		}
+		result->setArr(array);
+		return (result);
+	}
+
+	toml_node *TOMLParser::parseBool(void)
+	{
+		toml_node *node = new toml_node;
+		bool value;
+
+		std::cerr << "Parsing bool" << std::endl;
+		s_token token = tokenizer.getToken();
+		if (token.value == "true")
+			value = true;
+		else if (token.value == "false")
+			value = false;
+		else
+			throw std::invalid_argument("Unexpected bool value");
+		node->setBool(value);
+
+		return (node);
+	}
+
+	toml_node *TOMLParser::parseNil(void)
+	{
+		toml_node *node = new toml_node;
+		std::cerr << "Parsing NIL" << std::endl;
+		node->setNil();
+		return (node);
+	}
+
+	/* parse tha root ! */
+	TOMLMap *TOMLParser::parse(void)
+	{
+		std::cerr << "Parsing ROOT" << std::endl;
+		root = new TOMLMap;
+		bool completed = false;
+		while (!completed)
+		{
+			if (tokenizer.hasMoreTokens())
+			{
+				s_token current;
+				try { current = tokenizer.getToken(); }
+				catch (std::logic_error e)
+				{
+					std::cerr << e.what() << std::endl;
+					break;
+				}
+				if (current.type == MAPARRAY_DECL)
+				{
+					/* processMapArray(); */
+					tokenizer.set_last(NEWLINE);
+					tokenizer.rollBackToken();
+					processMapArray();
+				}
+				else if (current.type == MAP_DECL)
+				{
+					std::cerr << "MAP_DECL value: " << current.value << std::endl;
+					tokenizer.set_last(NEWLINE);
+					tokenizer.rollBackToken();
+					/* if (tokenizer.getToken().type != NEWLINE) */
+					/* 	throw std::logic_error("no newline after MAP_DECL"); */
+					/* (*mapObject)[nextToken.value] = parseMap(); */
+					processMap();
+					continue;
+				}
+				else
+				{
+					std::string key = current.value;
+					std::cerr << key << std::endl;
+					if (tokenizer.getToken().type != ASSIGN)
+						throw std::logic_error("EXPECTED assign!");
+					current = tokenizer.getToken();
+					switch (current.type)
+					{
+						case STRING:
+							{
+								tokenizer.rollBackToken();
+								(*root)[key] = parseString();
+								break;
+							}
+						case OPEN_BRACKET:
+							{
+								(*root)[key] = parseArray();
+								break;
+							}
+						case NUMBER:
+							{
+								tokenizer.rollBackToken();
+								(*root)[key] = parseNumber();
+								break;
+							}
+						case BOOL:
+							{
+								tokenizer.rollBackToken();
+								(*root)[key] = parseBool();
+								break;
+							}
+						default:
+							{
+								/* throw std::logic_error("jopa in parseMap"); */
+								std::cerr << "Unknown token, marking as complete" << std::endl;
+								completed = true;
+								break;
+							}
+					}
+					if (tokenizer.hasMoreTokens())
+						current = tokenizer.getToken();
+					else
+						break;
+					if (current.type != NEWLINE)
+					{
+						throw std::logic_error("EXPECTED newline");
+					}
+				}
+			}
+			else
+			{
+				completed = true;
+				break;
+			}
+		}
+		return (root);
+	}
+
+	std::vector<std::string> TOMLParser::split_name(std::string name)
+	{
+		std::vector<std::string> full_name;
+		size_t dot;
+
+		while (1)
+		{
+			dot = name.find('.');
+			if (dot == std::string::npos)
+				break;
+			/* std::cout << dot << std::endl; */
+			full_name.push_back(name.substr(0, dot));
+			name.erase(0, dot + 1);
+		}
+		full_name.push_back(name);
+
+		for (size_t i = 0; i < full_name.size(); i++)
+			std::cout << full_name[i] << ", ";
+		std::cout << std::endl;
+
+		return (full_name);
+	}
+
+	void TOMLParser::put_to_subtable(TOMLMap *root,
+			std::vector<std::string> full_name,
+			toml_node *map_node, toml_node::e_type type)
+	{
+		std::vector<std::string>::iterator subname = full_name.begin();
+		toml_node *maparr_node;
+		TOMLMap::iterator it;
+
+		TOMLMap *local_root = root;
+
+		while (1)
+		{
+			if (subname + 1 == full_name.end())
+			{
+				it = local_root->find(*subname);
+				if (type == toml_node::MAPARRAY)
+				{
+					if (it == local_root->end())
+					{
+						maparr_node = new toml_node;
+						TOMLMapArray *map_array = new TOMLMapArray;
+						map_array->push_back(map_node->getMap());
+						maparr_node->setMapArray(map_array);
+						(*local_root)[*subname] = maparr_node;
+					}
+					else
+						(it->second)->getMapArray()->push_back(map_node->getMap());
+				}
+				else if (type == toml_node::MAP)
+				{
+					if (it == local_root->end())
+					{
+						(*local_root)[*subname] = map_node;
+					}
+					else
+						throw std::logic_error("map already in subtable!");
+				}
+				break;
+			}
+			else
+			{
+				it = local_root->find(*subname);
+
+				toml_node *map_node2;
+				map_node2 = new toml_node;
+				TOMLMap *map = new TOMLMap;
+				map_node2->setObject(map);
+				/* subname not found in local_root */
+				if (it == local_root->end())
+				{
+					(*local_root)[*subname] = map_node2;
+					local_root = map;
+				}
+				/* subname found in local_root */
+				else
+					local_root = *((it->second)->getMapArray()->end() - 1);
+
+			}
+			++subname;
+		}
+	}
+}

src/config/TOMLParser.hpp

@@ -1,8 +1,10 @@
 #ifndef TOMLPARSER_HPP
 #define TOMLPARSER_HPP
 
-#include "TOMLNode.hpp"
+#include "webserv.hpp"
+#include "tomlstuff.hpp"
 #include "Tokenizer.hpp"
+#include "TOMLNode.hpp"
 #include <string>
 
 namespace config
@@ -15,380 +17,33 @@ namespace config
 			/* toml_node *current; //node currently being parsed */
 			Tokenizer tokenizer;
 
+			static std::vector<std::string> split_name(std::string name);
+			static void put_to_subtable(TOMLMap *root,
+					std::vector<std::string> full_name,
+					toml_node *map_node, toml_node::e_type type);
+
 		public:
-			TOMLParser(const std::string filename) : tokenizer(filename) {}
+			TOMLParser(const std::string filename);
 			TOMLMap *parse(void);
 
-			toml_node *parseMap(void)
-			{
-				std::cerr << "Parsing object" << std::endl;
-				toml_node *node = new toml_node;
-				TOMLMap *mapObject = new TOMLMap;
-				bool completed = false;
-				while (!completed)
-				{
-					if (tokenizer.hasMoreTokens())
-					{
-						s_token nextToken;
-						try { nextToken = tokenizer.getToken(); }
-						catch (std::logic_error e)
-						{
-							std::cerr << e.what() << std::endl;
-							break;
-						}
-						if (nextToken.type == MAPARRAY_DECL)
-						{
-							tokenizer.rollBackToken();
-							break;
-						}
-						std::string key = nextToken.value;
-						std::cerr << key << std::endl;
-						if (tokenizer.getToken().type != ASSIGN)
-							throw std::logic_error("EXPECTED assign!");
-						nextToken = tokenizer.getToken();
-						switch (nextToken.type)
-						{
-							case STRING:
-							{
-								tokenizer.rollBackToken();
-								(*mapObject)[key] = parseString();
-								break;
-							}
-							case ARR_OPEN:
-							{
-								(*mapObject)[key] = parseArray();
-								break;
-							}
-							case NUMBER:
-							{
-								tokenizer.rollBackToken();
-								(*mapObject)[key] = parseNumber();
-								break;
-							}
-							case BOOL:
-							{
-								tokenizer.rollBackToken();
-								(*mapObject)[key] = parseBool();
-								break;
-							}
-							case MAPARRAY_DECL:
-							{
-								std::cerr << "reached MAPARRAY_DECL in parseMap" << std::endl;
-								completed = true;
-								break;
-							}
-							default:
-							{
-								/* throw std::logic_error("jopa in parseMap"); */
-								std::cerr << "Unknown token, marking as complete" << std::endl;
-								completed = true;
-								break;
-							}
-						}
-						if (tokenizer.hasMoreTokens())
-							nextToken = tokenizer.getToken();
-						else
-							break;
-						if (nextToken.type != NEWLINE)
-						{
-							throw std::logic_error("EXPECTED newline");
-						}
-					}
-					else
-					{
-						throw std::logic_error("parseMap: no more tokens");
-					}
-				}
-				node->setObject(mapObject);
-				return (node);
-			}
+			toml_node *parseMap(void);
+			void processMap(void);
 
-			toml_node *parseString(void)
-			{
-				/* toml_node *node; */
-				toml_node *node = new toml_node;
-				std::string *sValue;
+			void processMapArray(void);
 
-				std::cerr << "Parsing string" << std::endl;
-				s_token token = tokenizer.getToken();
-				sValue = new std::string(token.value);
-				node->setString(sValue);
+			toml_node *parseString(void);
 
-				return (node);
-			}
+			toml_node *parseNumber(void);
 
-			toml_node *parseNumber(void)
-			{
-				toml_node *node = new toml_node;
-				int value;
+			toml_node *parseArray(void);
 
-				std::cerr << "Parsing number" << std::endl;
-				s_token token = tokenizer.getToken();
-				value = std::atoi(token.value.c_str());
-				node->setNumber(value);
+			toml_node *parseBool(void);
 
-				return (node);
-			}
+			toml_node *parseNil(void);
 
-			toml_node *parseArray(void)
-			{
-				std::cerr << "Parsing array" << std::endl;
-				toml_node *node;
-				toml_node *result = new toml_node;
-				TOMLArray *array = new TOMLArray;
-				bool completed = false;
-				s_token current;
-
-				while (!completed)
-				{
-					if (!tokenizer.hasMoreTokens())
-						throw std::logic_error("No more tokens");
-					else
-					{
-						current = tokenizer.getToken();
-						switch (current.type)
-						{
-							case ARR_OPEN:
-							{
-								node = parseArray();
-								break;
-							}
-							case STRING:
-							{
-								tokenizer.rollBackToken();
-								node = parseString();
-								break;
-							}
-							case NUMBER:
-							{
-								tokenizer.rollBackToken();
-								node = parseNumber();
-								break;
-							}
-							case BOOL:
-							{
-								tokenizer.rollBackToken();
-								node = parseBool();
-								break;
-							}
-							case NIL:
-							{
-								node = parseNil();
-								break;
-							}
-							default:
-							{
-								throw std::logic_error("unkown token in parseArray");
-							}
-
-						}
-						array->push_back(node);
-						current = tokenizer.getToken();
-						if (current.type == COMMA)
-							continue;
-						else if (current.type == ARR_CLOSE)
-							completed = true;
-						else
-							throw std::invalid_argument("Unexpected token in array!");
-					}
-				}
-				result->setArr(array);
-				return (result);
-			}
-
-			toml_node *parseBool(void)
-			{
-				toml_node *node = new toml_node;
-				bool value;
-
-				std::cerr << "Parsing bool" << std::endl;
-				s_token token = tokenizer.getToken();
-				if (token.value == "true")
-					value = true;
-				else if (token.value == "false")
-					value = false;
-				else
-					throw std::invalid_argument("Unexpected bool value");
-				node->setBool(value);
-
-				return (node);
-			}
-
-			toml_node *parseNil(void)
-			{
-				toml_node *node = new toml_node;
-				std::cerr << "Parsing NIL" << std::endl;
-				node->setNil();
-				return (node);
-			}
 	};
 
 	/* parse tha root ! */
-	TOMLMap *TOMLParser::parse(void)
-	{
-		std::cerr << "Parsing ROOT" << std::endl;
-		root = new TOMLMap;
-		bool completed = false;
-		while (!completed)
-		{
-			if (tokenizer.hasMoreTokens())
-			{
-				s_token current;
-				try { current = tokenizer.getToken(); }
-				catch (std::logic_error e)
-				{
-					std::cerr << e.what() << std::endl;
-					break;
-				}
-				if (current.type == MAPARRAY_DECL)
-				{
-					/* parseMapArray(); */
-					tokenizer.rollBackToken();
-					std::cerr << "Parsing MapArray" << std::endl;
-					toml_node *map_node;
-					toml_node *maparr_node;
-					s_token current;
-
-					try { current = tokenizer.getToken(); }
-					catch (std::logic_error e)
-					{
-						std::cerr << e.what() << std::endl;
-						break;
-					}
-					if (current.type == MAPARRAY_DECL)
-					{
-						if (tokenizer.getToken().type != NEWLINE)
-							throw std::logic_error("no newline after map_array declaration");
-						map_node = parseMap();
-					}
-					else
-						throw std::logic_error("unexpected token in parseMapArray");
-
-					TOMLMap::iterator it;
-					std::cout << current.value << std::endl;
-					std::string name = current.value;
-					std::vector<std::string> full_name;
-					size_t dot;
-
-					while (1)
-					{
-						dot = name.find('.');
-						if (dot == std::string::npos)
-							break;
-						/* std::cout << dot << std::endl; */
-						full_name.push_back(name.substr(0, dot));
-						name.erase(0, dot + 1);
-					}
-					full_name.push_back(name);
-
-					for (size_t i = 0; i < full_name.size(); i++)
-						std::cout << full_name[i] << ", ";
-					std::cout << std::endl;
-					
-					/* throw std::logic_error("tha end"); */
-					TOMLMap *local_root;
-
-					std::vector<std::string>::iterator subname = full_name.begin();
-					local_root = root;
-					while (1)
-					{
-						if (subname + 1 == full_name.end())
-						{
-							it = local_root->find(*subname);
-							if (it == local_root->end())
-							{
-								maparr_node = new toml_node;
-								TOMLMapArray *map_array = new TOMLMapArray;
-								map_array->push_back(map_node->getMap());
-								maparr_node->setMapArray(map_array);
-								(*local_root)[*subname] = maparr_node;
-							}
-							else
-								(it->second)->getMapArray()->push_back(map_node->getMap());
-							break;
-						}
-						else
-						{
-							it = local_root->find(*subname);
-
-							toml_node *map_node2;
-							map_node2 = new toml_node;
-							TOMLMap *map = new TOMLMap;
-							map_node2->setObject(map);
-							/* subname not found in local_root */
-							if (it == local_root->end())
-							{
-								(*local_root)[*subname] = map_node2;
-								local_root = map;
-							}
-							/* subname found in local_root */
-							else
-							{
-								local_root = *((it->second)->getMapArray()->end() - 1);
-							}
-
-						}
-						++subname;
-					}
-
-				}
-				else
-				{
-					std::string key = current.value;
-					std::cerr << key << std::endl;
-					if (tokenizer.getToken().type != ASSIGN)
-						throw std::logic_error("EXPECTED assign!");
-					current = tokenizer.getToken();
-					switch (current.type)
-					{
-						case STRING:
-							{
-								tokenizer.rollBackToken();
-								(*root)[key] = parseString();
-								break;
-							}
-						case ARR_OPEN:
-							{
-								(*root)[key] = parseArray();
-								break;
-							}
-						case NUMBER:
-							{
-								tokenizer.rollBackToken();
-								(*root)[key] = parseNumber();
-								break;
-							}
-						case BOOL:
-							{
-								tokenizer.rollBackToken();
-								(*root)[key] = parseBool();
-								break;
-							}
-						default:
-							{
-								/* throw std::logic_error("jopa in parseMap"); */
-								std::cerr << "Unknown token, marking as complete" << std::endl;
-								completed = true;
-								break;
-							}
-					}
-					if (tokenizer.hasMoreTokens())
-						current = tokenizer.getToken();
-					else
-						break;
-					if (current.type != NEWLINE)
-					{
-						throw std::logic_error("EXPECTED newline");
-					}
-				}
-			}
-			else
-			{
-				completed = true;
-				break;
-			}
-		}
-		return (root);
-	}
+	/* TOMLMap *TOMLParser::parse(void); */
 }
 #endif

src/config/Tokenizer.cpp

@@ -0,0 +1,223 @@
+#include "Tokenizer.hpp"
+
+/* -Template::-Template(void) */
+/* { */
+/* 	return; */
+/* } */
+
+/* -Template::-Template(const -Template &src) */
+/* { */
+/* 	*this = src; */
+/* 	return; */
+/* } */
+
+/* -Template::~-Template(void) */
+/* { */
+/* 	return; */
+/* } */
+
+/* -Template &-Template::operator=(const -Template &rhs) */
+/* { */
+/* 	//code */
+/* 	return (*this); */
+/* } */
+namespace config
+{
+	bool isspace(char c)
+	{
+		if (c == ' ' || c == '\t')
+			return (true);
+		else
+			return (false);
+	}
+
+	bool istomlkey(char c)
+	{
+		if (isalnum(c) || c == '-' || c == '_')
+			return (true);
+		else
+			return (false);
+	}
+	Tokenizer::Tokenizer(std::string filename)
+	{
+		file.open(filename.c_str(), std::ios::in);
+		if (!file.good())
+		{
+			std::cerr << "file didn't open" << std::endl;
+		}
+	}
+	bool Tokenizer::firstToken()
+	{
+		// doesn't account for indent!
+		if (file.tellg() == 0 || file.tellg() == 1 || (last_token == NEWLINE))
+			return (true);
+		else
+			return (false);
+	}
+
+	struct s_token Tokenizer::getToken(void)
+	{
+		char c;
+		struct s_token token;
+
+		if (file.eof())
+		{
+			std::cout << "Tokens exhausted" << std::endl;
+		}
+		prev_pos = file.tellg();
+		c = getWithoutWhiteSpace();
+
+		if (firstToken() && config::istomlkey(c))
+		{
+			token.type = KEY;
+			while (config::istomlkey(c))
+			{
+				token.value += c;
+				file.get(c);
+			}
+		}
+		else if (c == '"')
+		{
+			token.type = STRING;
+			token.value = "";
+			/* TODO: maybe do-while? */
+			file.get(c);
+			while (c != '"')
+			{
+				token.value += c;
+				file.get(c);
+			}
+		}
+		else if (c == '[' && firstToken())
+		{
+			/* std::streampos prev_pos = file.tellg(); */
+			file.get(c);
+			if (c == '[')
+			{
+				token.type = MAPARRAY_DECL;
+				file.get(c);
+				while (c != ']')
+				{
+					token.value += c;
+					file.get(c);
+				}
+				if (c == ']')
+					file.get(c);
+				if (c != ']')
+					throw std::logic_error("error in MAPARRAY_DECL");
+			}
+			else
+			{
+				token.type = MAP_DECL;
+				token.value += c;
+				file.get(c);
+				while (c != ']')
+				{
+					token.value += c;
+					file.get(c);
+				}
+				if (c != ']')
+					throw std::logic_error("malformed MAP_DECL");
+			}
+		}
+		else if (c == '[')
+		{
+			token.type = OPEN_BRACKET;
+		}
+		else if (c == ']')
+			token.type = CLOSE_BRACKET;
+		else if (c == '=')
+			token.type = ASSIGN;
+		else if (c == '\n')
+			token.type = NEWLINE;
+		else if (c == '-' || isdigit(c))
+		{
+			std::streampos prevCharPos;
+			token.type = NUMBER;
+			token.value = "";
+			token.value += c;
+			/* prevCharPos = file.tellg(); */
+			while (c == '-' || c == '.' || isdigit(c))
+			{
+				prevCharPos = file.tellg();
+				file.get(c);
+				if (file.eof())
+					break;
+				else
+				{
+					if (c == '-' || c == '.' || isdigit(c))
+						token.value += c;
+					else
+						file.seekg(prevCharPos);
+
+				}
+			}
+		}
+		else if (c == 'f')
+		{
+			token.type = BOOL;
+			token.value = "false";
+			file.seekg(4, std::ios_base::cur);
+
+			/* token.value = ""; */
+			/* while (std::isalpha(c)) */
+			/* { */
+			/* 	token.value += c; */
+			/* 	file.get(c); */
+			/* } */
+			std::cerr << "value is: " << token.value << std::endl;
+			std::cerr << "c is: " << c << std::endl;
+		}
+		else if (c == 't')
+		{
+			token.type = BOOL;
+			while (std::isalpha(c))
+			{
+				token.value += c;
+				file.get(c);
+			}
+			/* file.seekg(3, std::ios_base::cur); */
+		}
+		else if (c == 'n')
+		{
+			token.type = NIL;
+			file.seekg(3, std::ios_base::cur);
+		}
+		else if (c == ',')
+			token.type = COMMA;
+		last_token = token.type;
+		return (token);
+	}
+	char Tokenizer::getWithoutWhiteSpace(void)
+	{
+		char c = ' ';
+		while (config::isspace(c))
+		{
+			file.get(c);
+			if ((c == ' ') && !file.good())
+			{
+				throw std::logic_error("No more tokens!");
+			}
+			else if (!file.good())
+				return (c);
+		}
+		return (c);
+	}
+
+	bool Tokenizer::hasMoreTokens(void)
+	{
+		return (!file.eof());
+	}
+
+	void Tokenizer::rollBackToken(void)
+	{
+		if (file.eof())
+			file.clear();
+		file.seekg(prev_pos);
+	}
+
+	void Tokenizer::set_last(e_token type)
+	{
+		last_token = type;
+	}
+}

src/config/Tokenizer.hpp

@@ -2,6 +2,8 @@
 #define TOKENIZER_HPP
 
 #include "webserv.hpp"
+#include "tomlstuff.hpp"
+
 #include <map>
 #include <vector>
 #include <fstream>
@@ -9,6 +11,7 @@
 #include <iostream>
 #include <exception>
 
+
 namespace config
 {
 	enum e_token
@@ -21,10 +24,9 @@ namespace config
 		COMMA,
 		BOOL,
 		NIL,
-		ARR_OPEN,
-		ARR_CLOSE,
-		MAP_OPEN,
-		MAP_CLOSE,
+		OPEN_BRACKET,
+		CLOSE_BRACKET,
+		MAP_DECL,
 		MAPARRAY_DECL
 	};
 
@@ -35,21 +37,9 @@ namespace config
 		/* std::string to_string(void); */
 	};
 
-	bool isspace(char c)
-	{
-		if (c == ' ' || c == '\t')
-			return (true);
-		else
-			return (false);
-	}
+	bool isspace(char c);
 
-	bool istomlkey(char c)
-	{
-		if (isalnum(c) || c == '-' || c == '_')
-			return (true);
-		else
-			return (false);
-	}
+	bool istomlkey(char c);
 
 	class Tokenizer
 	{
@@ -57,57 +47,18 @@ namespace config
 			std::fstream file;
 			size_t prev_pos;
 			e_token last_token;
+
 		public:
-			Tokenizer(std::string filename)
-			{
-				file.open(filename.c_str(), std::ios::in);
-				if (!file.good())
-				{
-					std::cerr << "file didn't open" << std::endl;
-				}
-			}
+			Tokenizer(std::string filename);
 			char getWithoutWhiteSpace();
 			struct s_token getToken();
 			bool hasMoreTokens();
-			bool firstToken()
-			{
-				// doesn't account for indent!
-				if (file.tellg() == 0 || file.tellg() == 1 || (last_token == NEWLINE))
-					return (true);
-				else
-					return (false);
-			}
+			bool firstToken();
 			void rollBackToken();
+			void set_last(e_token type);
+
 	};
 
-	char Tokenizer::getWithoutWhiteSpace(void)
-	{
-		char c = ' ';
-		while (config::isspace(c))
-		{
-			file.get(c);
-			if ((c == ' ') && !file.good())
-			{
-				throw std::logic_error("No more tokens!");
-			}
-			else if (!file.good())
-				return (c);
-		}
-		return (c);
-	}
-
-	bool Tokenizer::hasMoreTokens(void)
-	{
-		return (!file.eof());
-	}
-
-	void Tokenizer::rollBackToken(void)
-	{
-		if (file.eof())
-			file.clear();
-		file.seekg(prev_pos);
-	}
-
 	/* struct s_token Tokenizer::getKey(void) */
 	/* { */
 	/* 	char c; */
@@ -118,128 +69,6 @@ namespace config
 	/* 	} */
 	/* } */
 
-	struct s_token Tokenizer::getToken(void)
-	{
-		char c;
-		struct s_token token;
-
-		if (file.eof())
-		{
-			std::cout << "Tokens exhausted" << std::endl;
-		}
-		prev_pos = file.tellg();
-		c = getWithoutWhiteSpace();
-
-		if (firstToken() && config::istomlkey(c))
-		{
-			token.type = KEY;
-			while (config::istomlkey(c))
-			{
-				token.value += c;
-				file.get(c);
-			}
-		}
-		else if (c == '"')
-		{
-			token.type = STRING;
-			token.value = "";
-			/* TODO: maybe do-while? */
-			file.get(c);
-			while (c != '"')
-			{
-				token.value += c;
-				file.get(c);
-			}
-		}
-		else if (c == '[')
-		{
-			std::streampos prev_pos = file.tellg();
-			file.get(c);
-			if (c == '[')
-			{
-				token.type = MAPARRAY_DECL;
-				file.get(c);
-				while (c != ']')
-				{
-					token.value += c;
-					file.get(c);
-				}
-				if (c == ']')
-					file.get(c);
-				if (c != ']')
-					throw std::logic_error("error in MAPARRAY_DECL");
-			}
-			else
-			{
-				token.type = ARR_OPEN;
-				file.seekg(prev_pos);
-			}
-
-		}
-		else if (c == ']')
-			token.type = ARR_CLOSE;
-		else if (c == '=')
-			token.type = ASSIGN;
-		else if (c == '\n')
-			token.type = NEWLINE;
-		else if (c == '-' || isdigit(c))
-		{
-			std::streampos prevCharPos;
-			token.type = NUMBER;
-			token.value = "";
-			token.value += c;
-			/* prevCharPos = file.tellg(); */
-			while (c == '-' || c == '.' || isdigit(c))
-			{
-				prevCharPos = file.tellg();
-				file.get(c);
-				if (file.eof())
-					break;
-				else
-				{
-					if (c == '-' || c == '.' || isdigit(c))
-						token.value += c;
-					else
-						file.seekg(prevCharPos);
-
-				}
-			}
-		}
-		else if (c == 'f')
-		{
-			token.type = BOOL;
-			token.value = "false";
-			file.seekg(4, std::ios_base::cur);
-
-			/* token.value = ""; */
-			/* while (std::isalpha(c)) */
-			/* { */
-			/* 	token.value += c; */
-			/* 	file.get(c); */
-			/* } */
-			std::cerr << "value is: " << token.value << std::endl;
-			std::cerr << "c is: " << c << std::endl;
-		}
-		else if (c == 't')
-		{
-			token.type = BOOL;
-			while (std::isalpha(c))
-			{
-				token.value += c;
-				file.get(c);
-			}
-			/* file.seekg(3, std::ios_base::cur); */
-		}
-		else if (c == 'n')
-		{
-			token.type = NIL;
-			file.seekg(3, std::ios_base::cur);
-		}
-		else if (c == ',')
-			token.type = COMMA;
-		last_token = token.type;
-		return (token);
-	}
 }
 
 #endif

src/config/parse.cpp

@@ -6,10 +6,7 @@
 #include <iostream>
 #include <exception>
 
-#include "TOMLNode.hpp"
-#include "TOMLParser.hpp"
-#include "Tokenizer.hpp"
-
+#include "parse.hpp"
 /* struct location */
 /* { */
 /* 	std::string location; */
@@ -41,10 +38,11 @@ namespace config
 	}
 }
 
-void parse(void)
+TOMLMap *parse(void)
 {
 	std::string filename = "config/simple.toml";
 	config::TOMLParser parser(filename);
 	TOMLMap *root = parser.parse();
 	config::display(root);
+	return (root);
 }

src/config/parse.hpp

@@ -0,0 +1,13 @@
+#ifndef PARSE_HPP
+#define PARSE_HPP
+
+#include "tomlstuff.hpp"
+
+#include "Tokenizer.hpp"
+#include "TOMLNode.hpp"
+#include "TOMLParser.hpp"
+
+TOMLMap *parse(void);
+void display(TOMLMap *config);
+
+#endif

src/config/tomlstuff.hpp

@@ -0,0 +1,11 @@
+#ifndef TOMLSTUFF_HPP
+#define TOMLSTUFF_HPP
+
+class toml_node;
+
+typedef std::map<std::string, toml_node *> TOMLMap; // = JSONObject
+typedef std::vector<TOMLMap *> TOMLMapArray;
+typedef std::vector<toml_node *> TOMLArray;
+
+#endif
+

src/main.cpp

@@ -1,4 +1,6 @@
 #include "webserv.hpp"
+#include "parse.hpp"
+#include "Server.hpp"
 
 int	main(int argc, char **argv)
 {
@@ -8,10 +10,8 @@ int	main(int argc, char **argv)
 	Server	server;
 	
 	 server.readConfig(); 
-	 server.setupConfig();
-	 server.start();
-	// parse();
-	
+	//  server.setupConfig();
+	//  server.start();
 
 
 	return (0);