NouVeL/NouVeL/NVL.cpp

#include <map>
#include "NVL.h"

namespace {
	// general helpers, may move these into a different translation unit
	bool str_test_every_char_not(int (*test)(int), std::string str) 
	{
		for (auto& x : str)
		{
			if (!(*test)(x))
				return false;
		}
		return true;
	}
	void indent_loop(int indent)
	{
		for (int i = 0; i < indent; i++)
		{
			std::cout << "\t";
		}
	}
	int query_ifstream_line_number(std::ifstream& stream) 
	{
		std::streampos pos = stream.tellg();
		stream.seekg(0); // we should not be eof
		int i = 0;
		char c{};
		while (stream.tellg() < pos) 
		{
			if (c == '\n')
				i++;
			stream.get(c);
		}
		return i;
	}

	// facilities for scopers
	const std::map<char, char> SCOPER_MAP = {
			{'{', '}' },	// CURLY
			{'<', '>'},		// ANGLED 
			{'(', ')'},		// BRACKET
			{'[', ']'},		// SQUARE
			
			{'\'', '\''},	// SQUOTE
			{'\"', '\"'}	// DQUOTE
		};

	bool need_escape(char c) 
	{
		// todo: refactor, too cryptic
		return (c == '\'' || c == '\"');
	}

	struct ScopeContext {
		std::vector<char> Scope;
	};

	std::streampos scope_cope(char scope_char, std::ifstream& stream) 
	{
		// important
		// scope_cope() expects the scope opener to already have been fetched and stored in scope_char
		// i.o.w. it wont be able to cope properly because there will be one extra level of scope that it cannot match

		std::streampos initial = stream.tellg();
		
		std::streampos final;
		char c{};
		
		ScopeContext current_scope;
		current_scope.Scope.push_back(scope_char);

		while (!current_scope.Scope.empty()) {
			stream.get(c);

			// push scope if opening scoper is found
			bool set_scope_on_this_iter = false;
			// there cannot be any more scope inside of quoted strings
			if (current_scope.Scope.back() != '\'' && current_scope.Scope.back() != '\"') {
				for (auto const& x : SCOPER_MAP)
				{
					if (c == x.first) {
						current_scope.Scope.push_back(c); 
						set_scope_on_this_iter = true;
						break;
					}
				}
			}

			// pop last scope if ending scoper is found
			// set_scope_on_this_iter to prevent immediately popping scopers that have the same closers and openers
			if (!set_scope_on_this_iter && c == SCOPER_MAP.at(current_scope.Scope.back()))
				current_scope.Scope.pop_back();

			if (c == '\\') // encounters an escaped sequence
			{
				char cc = stream.peek(); 
				if (need_escape(cc)) // see if the escaped char happens to be a scoper
				{
					stream.get(c); // skip it, since whoever wrote the script escaped it
				}
			}

			// cannot match all the scopes and has read to the end of the file
			if (stream.eof())
				throw std::runtime_error("Can't cope with scope at line " + std::to_string(query_ifstream_line_number(stream)));
			
		}

		final = stream.tellg();
		stream.seekg(initial);

		return final;
	}

	// facilities for parsing
	void skip_ws(std::ifstream& stream)
	{
		stream >> std::ws;
	}

	bool only_ws_before_next_newline(std::ifstream& stream) {
		if (!isspace(stream.peek()))
			return false;

		std::streampos initial = stream.tellg();
		char c{};
		stream.get(c);
		while (c != '\n') 
		{
			stream.get(c);
			if (!isspace(c)) {
				stream.seekg(initial);
				return false;
			}
		}
		
		stream.seekg(initial);
		return true;
	}
	
	std::string read_sequence_name(std::ifstream& nvl) 
	{
		// this function will move the reading head of nvl, this is hard to keep track of but simplifies the program
		skip_ws(nvl);
		std::string token;
		char c{};

		nvl.get(c);
		while (c != ' ' && c != '{' && c != '\n')
		{
			token += c;
			nvl.get(c);
		}
		nvl.putback(c);

		return token;
	}


	void skip_comment(std::ifstream& nvl, char& c)
	{
		if (nvl.peek() == ';')
		{
			nvl.get(c);
			while (c != '\n')
			{
				nvl.get(c);
			}

			skip_ws(nvl);

			skip_comment(nvl, c);

			skip_ws(nvl);
		}
	}
}

namespace NVL
{
	void parse_Dialogue(Context old_context, std::ifstream& nvl)
	{
		if (std::get<Call*>(old_context.Scope_Hierarchy.back())->Objects.size() != 1)
			throw std::runtime_error("Failed to parse dialogue at line " + std::to_string(query_ifstream_line_number(nvl)));

		const Object say_command = Object("Say");

		Object speaker = std::get<Call*>(old_context.Scope_Hierarchy.back())->Objects.front(); // Copy speaker object

		Sequence* parent_sequence = std::get<Sequence*>(old_context.Scope_Hierarchy.rbegin()[1]);
		// old call has never been pushed, we need to exit parse_Call right away when we finish parsing the dialogue, because this already deals with calls

		char c{};
		nvl.get(c); // get <
		std::streampos end = scope_cope('<', nvl);

		skip_ws(nvl);

		do
		{
			parent_sequence->Calls.push_back(Call());
			parent_sequence->Calls.back().Objects.push_back(say_command);
			parent_sequence->Calls.back().Objects.push_back(speaker);

			std::string text;

			if (nvl.peek() == '>')
				break;

			// im not sure if the execution order here will be problematic, seems to work ok
			while (!( (c == '\n' && only_ws_before_next_newline(nvl)) || nvl.peek() == '>'))
			{
				nvl.get(c);
				text += c;
			}

			while (isspace(text.back()))
				text.erase(text.size()-1, 1);

			for (size_t i = text.find('\n'); i != std::string::npos; i = text.find('\n')) 
			{
				int e = 0;
				std::cout << text.size();
				while (isspace(text.at(i + e))) 
					e++;

				text.erase(i, e);
				text.insert(i, " ");
			}

			parent_sequence->Calls.back().Objects.push_back(Object(text));
			skip_ws(nvl);
		} while (nvl.tellg() < end - static_cast<std::streampos>(1));

		nvl.get(c); // get >

		skip_ws(nvl);
		return;
	}

	template <bool is_parent_call, bool is_symbol>
	void parse_Object(Context parent_context, std::ifstream& nvl)
	{
		// chevron dialogue is now handled in a separate function
		Object this_object;
		Context this_context = parent_context;
		this_context.Scope_Hierarchy.push_back(&this_object);

		std::variant<std::string, std::vector<Object>> content = ""; // init to empty str
		char c{};		

		// early exit for comments
		if (nvl.peek() == ';' && is_parent_call)
		{
			while (nvl.peek() != '\n')
				nvl.get(c);
			return;
		}

		switch (nvl.peek())
		{
		case '[': // List
		{
			nvl.get(c);
			std::streampos end = scope_cope('[', nvl);
			while (nvl.tellg() < end - static_cast<std::streampos>(1))
			{
				parse_Object<false, false>(this_context, nvl);
				skip_ws(nvl);
			}
			nvl.get(c); // skip ending scoper (']')
			break;
		}
		case '\"': // String
		{
			nvl.get(c);
			std::streampos end = scope_cope('\"', nvl);
			while (nvl.tellg() < end - static_cast<std::streampos>(1))
			{
				nvl.get(c);

				// do not concat escaping '\' to content
				if (c == '\\' && (nvl.peek() == '\'' || nvl.peek() == '\"'))
					continue;

				content = std::get<std::string>(content) + c;
			}
			nvl.get(c); // skip ending scoper

			this_object.Value = std::get<std::string>(content);
			break;
		}
		default:
		{
			nvl.get(c);
			while (c != ' ' && c != '\n' && c != '}' && c != ']' && c != ',')
			{
				content = std::get<std::string>(content) + c;
				nvl.get(c);
			}

			// ']' handled in next object parse, '}' handled in sequence parse, '\n' will be skipped somewhere with skip_ws(), where? idk
			if (c == ']' || c == '}' || c == '\n')
			{
				nvl.putback(c);
			}


			try
			{
				// try number
				this_object.Value = std::stof(std::get<std::string>(content));
			}
			catch (std::exception)
			{
				if (std::get<std::string>(content) == "true")
				{
					this_object.Value = true;
				}
				else if (std::get<std::string>(content) == "false") {
					this_object.Value = false;
				}
				else
				{
					// early return if string is empty, this should only happen if calling from an object (not a call)
					if (str_test_every_char_not(&isspace, std::get<std::string>(content)))
						return;

					// default case if content does not match keywords
					this_object.Value = std::get<std::string>(content);
				}
			}
			break;
		}
		}


		this_object.Is_Symbol = is_symbol;

		if (is_parent_call)
			std::get<Call*>(parent_context.Scope_Hierarchy.back())->Objects.push_back(this_object);
		else if (std::get<Object*>(parent_context.Scope_Hierarchy.back())->Value.index() == 4) // 4 for list, indicates that parent is an object that is already a vector of objects
			std::get<std::vector<Object>>(
				std::get<Object*>(parent_context.Scope_Hierarchy.back())->Value
				).push_back(this_object);
		else // parent is not yet vector, initialize as (change from nil to) vector
			std::get<Object*>(parent_context.Scope_Hierarchy.back())->Value = std::vector<Object> { this_object };
		// the case for chevron dialogues are handled in the switch, there is an early return in the chevron case
	}

	void parse_Call(Context parent_context, std::ifstream& nvl)
	{
		Call this_call;

		Context this_context = parent_context;
		this_context.Scope_Hierarchy.push_back(&this_call);

		skip_ws(nvl);

		// do not push anything if line starts with a comment
		char c{};
		skip_comment(nvl, c);
		// early exit if sequence is empty
		if (nvl.peek() == '}')
			return;

		while (!(nvl.peek() == '\n' || nvl.peek() == '}'))
		{
			skip_ws(nvl);
			if (nvl.peek() == '<') // dialogue! abandon current call, parse_Dialogue deals with pushing calls
			{
				parse_Dialogue(this_context, nvl);
				return;
			}

			parse_Object<true, false>(this_context, nvl);
		}

		std::get<Sequence*>(parent_context.Scope_Hierarchy.back())->Calls.push_back(this_call);
	}

	void parse_Sequence(Context parent_context, std::ifstream& nvl)
	{
		Sequence this_sequence;
		Context this_context = parent_context;
		this_context.Scope_Hierarchy.push_back(&this_sequence);

		skip_ws(nvl);

		char c{};
		skip_comment(nvl, c);

		this_sequence = Sequence(read_sequence_name(nvl));

		skip_ws(nvl);

		nvl.get(c); // get {

		if (c != '{')
			throw std::runtime_error("Sequence parse failed at line " + std::to_string(query_ifstream_line_number(nvl)));

		std::streampos end_pos = scope_cope(c, nvl);

		while (nvl.tellg() < end_pos - static_cast<std::streampos>(1))
		{
			parse_Call(this_context, nvl);
			skip_ws(nvl);
		}

		nvl.get(c); // get }

		std::get<Tree*>(parent_context.Scope_Hierarchy.back())->Sequences.push_back(this_sequence);
	}

	void parse_NVL(Tree& root, std::string path)
	{
		std::ifstream nvl;
		std::cout << "Reading file " << path << "..." << std::endl;
		nvl.open(path);

		if (nvl.is_open()) {
			Context current_context;
			current_context.Scope_Hierarchy.push_back(&root);

			skip_ws(nvl); // just in case the file is completely empty

			while (!nvl.eof()) {
				// parse_Sequence() already takes care of comments before a sequence
				parse_Sequence(current_context, nvl);
				skip_ws(nvl);

				char c{};
				skip_comment(nvl, c);

				skip_ws(nvl);
			}

			nvl.close();
		} else
			throw std::runtime_error("Unable to read file " + path);

	}



	void Object::Print(int indent)
	{
		indent_loop(indent);
		std::cout << "Object: ";

		switch (Value.index())
		{
		case 0:
			std::cout << "Nil" << std::endl;
			break;
		case 1:
			std::cout << "Float: " << std::get<float>(Value) << std::endl;
			break;
		case 2:
			if (Is_Symbol)
				std::cout << "Symbol: " << std::get<std::string>(Value) << std::endl;
			else
				std::cout << "String: " << std::get<std::string>(Value) << std::endl;
			break;
		case 3:
			std::cout << "Bool: " << std::boolalpha << std::get<bool>(Value) << std::endl;
			break;
		case 4:
			std::cout << "List:" << std::endl;

			for (auto& x : std::get<std::vector<Object>>(Value))
			{
				x.Print(indent + 1);
			} 
			break;
		}
	}

	void Call::Print(int indent)
	{
		indent_loop(indent);
		std::cout << "Call:" << std::endl;

		for (auto& x : Objects)
		{
			x.Print(indent + 1);
		}
	}

	void Sequence::Print(int indent)
	{
		indent_loop(indent);
		std::cout << "Sequence " << Name << ":" << std::endl;

		for (auto& x : Calls)
		{
			x.Print(indent + 1);
		}

		indent_loop(indent);
		std::cout << "-----------------------------------------------" << std::endl;
	}

	void Tree::Print(int indent)
	{
		indent_loop(indent);
		std::cout << "Tree:" << std::endl;

		for (auto& x : Sequences) 
		{
			x.Print(indent + 1);
		}
	}
}