refactor: separate parsing classes

includes/TOMLNode.hpp

@@ -2,6 +2,8 @@
 #define TOMLNODE_HPP
 
 #include "webserv.hpp"
+#include "tomlstuff.hpp"
+
 #include <map>
 #include <vector>
 #include <fstream>
@@ -48,8 +50,9 @@ class toml_node
 		void setObject(TOMLMap *obj);
 		void setMapArray(TOMLMapArray *map_array);
 
-		std::string *TOMLMap_to_string(TOMLMap *map) const;
 		std::string *toString(void) const;
+		static std::string *TOMLMap_to_string(TOMLMap *map);
 };
 
+
 #endif

includes/TOMLParser.hpp

@@ -0,0 +1,43 @@
+#ifndef TOMLPARSER_HPP
+#define TOMLPARSER_HPP
+
+#include "webserv.hpp"
+#include "tomlstuff.hpp"
+#include "Tokenizer.hpp"
+#include "TOMLNode.hpp"
+#include <string>
+
+namespace config
+{
+	class TOMLParser
+	{
+		private:
+			std::fstream file;
+			TOMLMap *root; //root of TOML tree
+			/* toml_node *current; //node currently being parsed */
+			Tokenizer tokenizer;
+
+		public:
+			TOMLParser(const std::string filename);
+			TOMLMap *parse(void);
+
+			toml_node *parseMap(void);
+
+			void parseMapArray(void);
+
+			toml_node *parseString(void);
+
+			toml_node *parseNumber(void);
+
+			toml_node *parseArray(void);
+
+			toml_node *parseBool(void);
+
+			toml_node *parseNil(void);
+
+	};
+
+	/* parse tha root ! */
+	/* TOMLMap *TOMLParser::parse(void); */
+}
+#endif

includes/Tokenizer.hpp

@@ -0,0 +1,74 @@
+#ifndef TOKENIZER_HPP
+#define TOKENIZER_HPP
+
+#include "webserv.hpp"
+#include "tomlstuff.hpp"
+
+#include <map>
+#include <vector>
+#include <fstream>
+#include <cstdlib>
+#include <iostream>
+#include <exception>
+
+
+namespace config
+{
+	enum e_token
+	{
+		KEY,
+		NEWLINE,
+		ASSIGN,
+		STRING,
+		NUMBER,
+		COMMA,
+		BOOL,
+		NIL,
+		ARR_OPEN,
+		ARR_CLOSE,
+		MAP_OPEN,
+		MAP_CLOSE,
+		MAPARRAY_DECL
+	};
+
+	struct s_token
+	{
+		std::string value;
+		e_token type;
+		/* std::string to_string(void); */
+	};
+
+	bool isspace(char c);
+
+	bool istomlkey(char c);
+
+	class Tokenizer
+	{
+		private:
+			std::fstream file;
+			size_t prev_pos;
+			e_token last_token;
+
+		public:
+			Tokenizer(std::string filename);
+			char getWithoutWhiteSpace();
+			struct s_token getToken();
+			bool hasMoreTokens();
+			bool firstToken();
+			void rollBackToken();
+
+	};
+
+	/* struct s_token Tokenizer::getKey(void) */
+	/* { */
+	/* 	char c; */
+	/* 	struct s_token token; */
+	/* 	if (file.eof()) */
+	/* 	{ */
+	/* 		std::cout << "Tokens exhausted" << std::endl; */
+	/* 	} */
+	/* } */
+
+}
+
+#endif

includes/parse.hpp

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

includes/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
+

includes/webserv.hpp

@@ -19,16 +19,4 @@
 #include <map>
 #include <vector>
 
-void parse(void);
-
-class toml_node;
-
-/* typedef std::vector<TOMLMap *>	TOMLArray; */
-/* typedef std::vector<TOMLArray *> TOMLArrayOfMap; */
-typedef std::map<std::string, toml_node *> TOMLMap; // = JSONObject
-typedef std::vector<TOMLMap *> TOMLMapArray;
-typedef std::vector<toml_node *> TOMLArray;
-
-void display(TOMLMap *config);
-
 #endif

src/config/TOMLNode.cpp

@@ -1,4 +1,3 @@
-#include "webserv.hpp"
 #include "TOMLNode.hpp"
 
 /* toml_node::toml_node(void) */
@@ -143,7 +142,7 @@ std::string *toml_node::toString(void) const
 	}
 }
 
-std::string *TOMLMap_to_string(TOMLMap *map)
+std::string *toml_node::TOMLMap_to_string(TOMLMap *map)
 {
 	std::stringstream ss;
 	std::string *result = new std::string();

src/config/TOMLParser.cpp

@@ -0,0 +1,403 @@
+#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); */
+/* } */
+
+config::TOMLParser::TOMLParser(const std::string filename) : tokenizer(filename)
+{};
+
+toml_node *config::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();
+				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);
+}
+
+void config::TOMLParser::parseMapArray(void)
+{
+
+	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;
+		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 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;
+	}
+
+}
+
+toml_node *config::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 *config::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 *config::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 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 *config::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 *config::TOMLParser::parseNil(void)
+{
+	toml_node *node = new toml_node;
+	std::cerr << "Parsing NIL" << std::endl;
+	node->setNil();
+	return (node);
+}
+
+/* parse tha root ! */
+TOMLMap *config::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();
+				parseMapArray();
+			}
+			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);
+}

src/config/TOMLParser.hpp

@@ -1,400 +0,0 @@
-#ifndef TOMLPARSER_HPP
-#define TOMLPARSER_HPP
-
-#include "TOMLNode.hpp"
-#include "Tokenizer.hpp"
-#include <string>
-
-namespace config
-{
-	class TOMLParser
-	{
-		private:
-			std::fstream file;
-			TOMLMap *root; //root of TOML tree
-			/* toml_node *current; //node currently being parsed */
-			Tokenizer tokenizer;
-
-		public:
-			TOMLParser(const std::string filename) : tokenizer(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);
-			}
-
-			void parseMapArray(void)
-			{
-
-				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;
-					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 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;
-				}
-
-			}
-
-			toml_node *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 *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 *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();
-					parseMapArray();
-				}
-				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);
-	}
-}
-#endif

src/config/Tokenizer.cpp

@@ -1,40 +1,28 @@
-#ifndef TOKENIZER_HPP
-#define TOKENIZER_HPP
+#include "Tokenizer.hpp"
 
-#include "webserv.hpp"
-#include <map>
-#include <vector>
-#include <fstream>
-#include <cstdlib>
-#include <iostream>
-#include <exception>
+/* -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
 {
-	enum e_token
-	{
-		KEY,
-		NEWLINE,
-		ASSIGN,
-		STRING,
-		NUMBER,
-		COMMA,
-		BOOL,
-		NIL,
-		ARR_OPEN,
-		ARR_CLOSE,
-		MAP_OPEN,
-		MAP_CLOSE,
-		MAPARRAY_DECL
-	};
-
-	struct s_token
-	{
-		std::string value;
-		e_token type;
-		/* std::string to_string(void); */
-	};
-
 	bool isspace(char c)
 	{
 		if (c == ' ' || c == '\t')
@@ -50,74 +38,23 @@ namespace config
 		else
 			return (false);
 	}
-
-	class Tokenizer
+	Tokenizer::Tokenizer(std::string filename)
 	{
-		private:
-			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;
-				}
-			}
-			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);
-			}
-			void rollBackToken();
-	};
-
-	char Tokenizer::getWithoutWhiteSpace(void)
-	{
-		char c = ' ';
-		while (config::isspace(c))
+		file.open(filename.c_str(), std::ios::in);
+		if (!file.good())
 		{
-			file.get(c);
-			if ((c == ' ') && !file.good())
-			{
-				throw std::logic_error("No more tokens!");
-			}
-			else if (!file.good())
-				return (c);
+			std::cerr << "file didn't open" << std::endl;
 		}
-		return (c);
 	}
-
-	bool Tokenizer::hasMoreTokens(void)
+	bool Tokenizer::firstToken()
 	{
-		return (!file.eof());
+		// doesn't account for indent!
+		if (file.tellg() == 0 || file.tellg() == 1 || (last_token == NEWLINE))
+			return (true);
+		else
+			return (false);
 	}
 
-	void Tokenizer::rollBackToken(void)
-	{
-		if (file.eof())
-			file.clear();
-		file.seekg(prev_pos);
-	}
-
-	/* struct s_token Tokenizer::getKey(void) */
-	/* { */
-	/* 	char c; */
-	/* 	struct s_token token; */
-	/* 	if (file.eof()) */
-	/* 	{ */
-	/* 		std::cout << "Tokens exhausted" << std::endl; */
-	/* 	} */
-	/* } */
-
 	struct s_token Tokenizer::getToken(void)
 	{
 		char c;
@@ -240,6 +177,31 @@ namespace config
 		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);
+	}
 
-#endif
+	bool Tokenizer::hasMoreTokens(void)
+	{
+		return (!file.eof());
+	}
+
+	void Tokenizer::rollBackToken(void)
+	{
+		if (file.eof())
+			file.clear();
+		file.seekg(prev_pos);
+	}
+}

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; */

src/main.cpp

@@ -1,4 +1,5 @@
 #include "webserv.hpp"
+#include "parse.hpp"
 
 int	main(int argc, char **argv)
 {