pzks-labs/src/syntaxer.cpp

#include "expression.hpp"
#include "parser.hpp"
#include "print.h"
#include "syntaxer.hpp"
#include <queue>
#include <stack>
#include <vector>

namespace Syntax {

static int add_bracket_to(std::vector<Expression::Token>& tv, const int location, const int direction);

static void highlight_issue(const std::vector<Expression::Token>& tv, const int location)
{
	int start = location - 7 < 0 ? 0 : location - 7;
	int finish = location + 7 > tv.size() - 1 ? tv.size() - 1 : location + 7;

	std::cout << " >>> ";

	for (int i = start; i <= finish; i++)
	{
		if (i == location)
		{
			std::cout << "\033[31m" << *tv[i].to_math_str() << "\033[0m ";
		}
		else
		{
			std::cout << *tv[i].to_math_str() << " ";
		}
	}

	std::cout << "\n";
}

void pre_process(std::vector<Expression::Token>& tv)
{
	pr_debug("Pre-process: remove empty brackets");
	for (int i = 0; i < tv.size() - 1; i++)
	{
		if (tv[i].t == Expression::Token::OPERATOR
			&& tv[i].v.o == Expression::Token::OPA
			&& tv[i+1].t == Expression::Token::OPERATOR
			&& tv[i+1].v.o == Expression::Token::CPA)
		{
			std::vector<int> highlight;
			highlight.emplace_back(i);
			highlight.emplace_back(i+1);
			Parser::print_math_vector(tv, highlight);

			tv.erase(tv.begin() + i, tv.begin() + i + 2);
			i--;
		}
	}

	pr_debug("Pre-process: unary minus");
	int change = 1;
	while (change)
	{
		change = 0;

		for (int i = 0; i < tv.size() - 2; i++)
		{
			if (tv[i].t == Expression::Token::OPERATOR
				&& tv[i].v.o != Expression::Token::CPA
				&& tv[i+1].t == Expression::Token::OPERATOR
				&& tv[i+1].v.o == Expression::Token::SUB
				&& (tv[i+2].t == Expression::Token::CONST
					|| tv[i+2].t == Expression::Token::VAR
					|| (tv[i+2].t == Expression::Token::OPERATOR
						&& tv[i+2].v.o == Expression::Token::OPA)))
			{
				std::vector<int> highlight;

				tv.insert(tv.begin() + i + 1, Expression::Token(0.0));
				tv.insert(tv.begin() + i + 1, Expression::Token(Expression::Token::OPA));
				highlight.emplace_back(add_bracket_to(tv, i + 3, 1));

				highlight.emplace(highlight.begin(), i+2);
				highlight.emplace(highlight.begin(), i+1);
				Parser::print_math_vector(tv, highlight);

				i += 4;

				change++;
			}
		}
	}
}

int check_syntax(const std::vector<Expression::Token>& tv)
{
	int problem_cnt = 0;

	// check start and finish validity
	if (tv.size())
	{
		int pc = problem_cnt;

		switch (tv[0].t)
		{
		case Expression::Token::VAR:
		case Expression::Token::CONST:
			break;
		case Expression::Token::OPERATOR:
			switch (tv[0].v.o)
			{
			case Expression::Token::OPA:
				break;
			case Expression::Token::CPA:
				pr_warn("Expected value or opening bracket at token 0, got closing bracket");
				problem_cnt++;
				break;
			default:
				pr_warn("Expected value or opening bracket at token 0, got operator");
				problem_cnt++;
				break;
			}
			break;
		default:
			pr_warn("Impossible token type, this is a bug!");
			break;
		}

		if (pc != problem_cnt)
		{
			highlight_issue(tv, 0);
			pc = problem_cnt;
		}

		switch (tv.back().t)
		{
		case Expression::Token::VAR:
		case Expression::Token::CONST:
			break;
		case Expression::Token::OPERATOR:
			switch (tv.back().v.o)
			{
			case Expression::Token::CPA:
				break;
			case Expression::Token::OPA:
				pr_warn("Expected value or closing bracket at token " << tv.size() - 1 << ", got opening bracket");
				problem_cnt++;
				break;
			default:
				pr_warn("Expected value or closing bracket at token " << tv.size() - 1 << ", got operator");
				problem_cnt++;
				break;
			}
			break;
		default:
			pr_warn("Impossible token type, this is a bug!");
			break;
		}

		if (pc != problem_cnt)
		{
			highlight_issue(tv, tv.size()-1);
		}
	}

	// check token type sequence
	if (tv.size() > 1)
	{
		for (int i = 0, l = tv.size() - 1, pc; pc = problem_cnt, i < l; i++)
		{
			switch (tv[i].t)
			{
			case Expression::Token::VAR:
			case Expression::Token::CONST:
				switch (tv[i+1].t)
				{
				case Expression::Token::OPERATOR:
					switch (tv[i+1].v.o)
					{
					case Expression::Token::OPA:
						pr_warn("Expected operator at token " << i + 1 << ", got opening bracket");
						problem_cnt++;
						break;
					case Expression::Token::CPA:
						break;
					default:
						break;
					}
					break;
				case Expression::Token::VAR:
					pr_warn("Expected operator at token " << i + 1 << ", got variable");
					problem_cnt++;
					break;
				case Expression::Token::CONST:
					pr_warn("Expected operator at token " << i + 1 << ", got constant");
					problem_cnt++;
					break;
				default:
					pr_warn("Impossible token type, this is a bug!");
					break;
				}
				break;
			case Expression::Token::OPERATOR:
				switch (tv[i].v.o)
				{
				case Expression::Token::OPA:
					switch (tv[i+1].t)
					{
					case Expression::Token::OPERATOR:
						switch (tv[i+1].v.o)
						{
						case Expression::Token::OPA:
							break;
						case Expression::Token::CPA:
							pr_warn("Expected value at token " << i + 1 << ", got closing bracket");
							problem_cnt++;
							break;
						default:
							pr_warn("Expected value at token " << i + 1 << ", got operator");
							problem_cnt++;
							break;
						}
						break;
					case Expression::Token::CONST:
					case Expression::Token::VAR:
						break;
					default:
						pr_warn("Impossible token type, this is a bug!");
						break;
					}
					break;
				case Expression::Token::CPA:
					switch (tv[i+1].t)
					{
					case Expression::Token::OPERATOR:
						switch (tv[i+1].v.o)
						{
						case Expression::Token::CPA:
							break;
						case Expression::Token::OPA:
							pr_warn("Expected operator at token " << i + 1 << ", got opening bracket");
							problem_cnt++;
							break;
						default:
							break;
						}
						break;
					case Expression::Token::CONST:
						pr_warn("Expected operator at token " << i + 1 << ", got constant");
						problem_cnt++;
						break;
					case Expression::Token::VAR:
						pr_warn("Expected operator at token " << i + 1 << ", got variable");
						problem_cnt++;
						break;
					default:
						pr_warn("Impossible token type, this is a bug!");
						break;
					}
					break;
				default:
					switch (tv[i+1].t)
					{
					case Expression::Token::OPERATOR:
						switch (tv[i+1].v.o)
						{
						case Expression::Token::CPA:
							pr_warn("Expected value at token " << i + 1 << ", got closing bracket");
							problem_cnt++;
							break;
						case Expression::Token::OPA:
							break;
						default:
							pr_warn("Expected value at token " << i + 1 << ", got operator");
							problem_cnt++;
							break;
						}
						break;
					case Expression::Token::CONST:
						break;
					case Expression::Token::VAR:
						break;
					default:
						pr_warn("Impossible token type, this is a bug!");
						break;
					}
					break;
				}
				break;
			default:
				pr_warn("Impossible token type, this is a bug!");
				break;
			}

			if (pc != problem_cnt)
			{
				highlight_issue(tv, i + 1);
			}
		}
	}

	// check bracket matching
	{
		std::stack<int> s;

		for (int i = 0, l = tv.size(); i < l; i++)
		{
			if (tv[i].t == Expression::Token::OPERATOR)
			{
				switch (tv[i].v.o)
				{
				case Expression::Token::OPA:
					s.push(i);
					break;
				case Expression::Token::CPA:
					if (s.size())
					{
						s.pop();
					}
					else
					{
						pr_warn("Missing opening bracket at token " << i);
						problem_cnt++;
						highlight_issue(tv, i);
					}
					break;
				default:
					break;
				}
			}
		}

		for (int i = 0, l = s.size(); i < l; i++)
		{
			problem_cnt++;
			pr_warn("Opening bracket at token " << s.top() << " expected a closing bracket, but none found");
			highlight_issue(tv, s.top());
			s.pop();
		}
	}

	return problem_cnt;
}

// get mop = Math OPerator location (=absolute index in std::vector<Expression::Token>)
// mapper of 'priority vector index' -> 'token vector index'
static int get_mop_location(const std::vector<Expression::Token>& v, int position)
{
	int i = 0, l = v.size(), p = -1;
	for (; p += v[i].t == Expression::Token::OPERATOR
			&& v[i].v.o != Expression::Token::OPA
			&& v[i].v.o != Expression::Token::CPA, p != position; i++);
	return i;
}

static int get_left_location(const std::vector<Expression::Token>& v, int location)
{
	for (int i = location - 1; i >= 0; i--)
	{
		if (v[i].t != Expression::Token::OPERATOR && v[i].t != Expression::Token::NAT)
		{
			return i;
		}
	}

	return -1;
}

static int get_right_location(const std::vector<Expression::Token>& v, int location)
{
	for (int i = location + 1, l = v.size(); i < l; i++)
	{
		if (v[i].t != Expression::Token::OPERATOR && v[i].t != Expression::Token::NAT)
		{
			return i;
		}
	}

	return -1;
}

static int get_operator_weight(const std::vector<Expression::Token>& v, int location)
{
	int weight = 0;

	switch (const Expression::Token &p = v[get_left_location(v, location)]; p.t)
	{
	case Expression::Token::VAR:
	case Expression::Token::CONST:
		break;
	case Expression::Token::CV:
		weight += p.v.cv.w;
		break;
	default:
		pr_warn("Invalid token found to the left of operator");
		break;
	}

	switch (const Expression::Token &p = v[get_right_location(v, location)]; p.t)
	{
	case Expression::Token::VAR:
	case Expression::Token::CONST:
		break;
	case Expression::Token::CV:
		weight += p.v.cv.w;
		break;
	default:
		pr_warn("Invalid token found to the left of operator");
		break;
	}

	return weight;
}

static int get_min_index(const std::vector<int>& v)
{
	int idx = 0;

	for (int i = 1, l = v.size(); i < l; i++)
	{
		if (v[i] < v[idx])
		{
			idx = i;
		}
	}

	return idx;
}

static int get_max_index(const std::vector<int>& v)
{
	int idx = 0;

	for (int i = 1, l = v.size(); i < l; i++)
	{
		if (v[i] > v[idx])
		{
			idx = i;
		}
	}

	return idx;
}

static void write_operation(
		std::vector<Expression::Operation>& ov,
		const std::vector<Expression::Token>& tv,
		std::vector<Expression::Token>& mv,
		std::vector<int>& mp,
		int position)
{
	int location = get_mop_location(mv, position);
	int left_location = get_left_location(mv, location);
	int right_location = get_right_location(mv, location);

	Expression::Token &o = mv[location],
	      &l = mv[left_location],
	      &r = mv[right_location];

	int this_op_weight = get_operator_weight(mv, location) + 1;

	int il = l.t == Expression::Token::CV ? l.v.cv.i : left_location;
	int ir = r.t == Expression::Token::CV ? r.v.cv.i : right_location;

	// write new operation
	int this_ov_index = ov.size();
	ov.emplace_back(o.v.o,
			l.t == Expression::Token::CV ? Expression::Operation::DERIVED : Expression::Operation::NORMAL,
			il,
			r.t == Expression::Token::CV ? Expression::Operation::DERIVED : Expression::Operation::NORMAL,
			ir,
			this_op_weight);

	// update mv
	l.t = Expression::Token::NAT;
	r.t = Expression::Token::NAT;
	o.t = Expression::Token::CV;
	o.v.cv.w = this_op_weight;
	o.v.cv.i = this_ov_index;

	// update mp
	mp.erase(mp.begin() + position, mp.begin() + position + 1);
}

static int add_bracket_to(std::vector<Expression::Token>& tv, const int location, const int direction)
{
	int i = location + direction, l = tv.size(), lv = 0;

	if (direction == -1)
	{
		for (; i >= 0; i--)
		{
			if (tv[i].t == Expression::Token::OPERATOR)
			{
				if (tv[i].v.o == Expression::Token::CPA)
				{
					lv++;
				}

				if (!lv)
				{
					tv.insert(tv.begin() + i + 1, Expression::Token(Expression::Token::OPA));
					return i + 1;
				}

				if (tv[i].v.o == Expression::Token::OPA)
				{
					lv--;
				}
			}
		}

		tv.insert(tv.begin(), Expression::Token(Expression::Token::OPA));
		return 0;
	}
	else if (direction == 1)
	{
		for (; i < l; i++)
		{
			if (tv[i].t == Expression::Token::OPERATOR)
			{
				if (tv[i].v.o == Expression::Token::OPA)
				{
					lv++;
				}

				if (!lv)
				{
					tv.insert(tv.begin() + i, Expression::Token(Expression::Token::CPA));
					return i;
				}

				if (tv[i].v.o == Expression::Token::CPA)
				{
					lv--;
				}
			}
		}

		tv.emplace_back(Expression::Token::CPA);
		return i;
	}
	else
	{
		pr_warn("Invalid direction given, this is a big bug!");
		return -1;
	}
}

static void create_prios_vector(const std::vector<Expression::Token>& tv, std::vector<int>& pv)
{
	for (int i = 0, cp = 0, l = tv.size(); i < l; i++)
	{
		if (tv[i].t == Expression::Token::OPERATOR)
		{
			switch (tv[i].v.o)
			{
			case Expression::Token::OPA:
				cp++;
				break;
			case Expression::Token::CPA:
				cp--;
				break;
			case Expression::Token::ADD:
			case Expression::Token::SUB:
			case Expression::Token::MUL:
			case Expression::Token::DIV:
			case Expression::Token::POW:
				pv.emplace_back(cp);
				break;
			default:
				pr_warn("Token vector has broken operator at " << i);
				break;
			}
		}
	}
}

static void find_top_prio_op_range(const std::vector<int>& mp, int& start, int& finish)
{
	for (int i = 0, l = mp.size(), prio = -1; i < l; i++)
	{
		if (mp[i] > prio)
		{
			prio = mp[i];
			start = finish = i;
		}
		else if (mp[i] == prio && finish == i - 1)
		{
			finish = i;
		}
	}
}

struct Range
{
	int start, finish;

	Range(int start, int finish)
		: start(start), finish(finish)
	{
	}
};

static void find_select_prio_op_ranges(const std::vector<int>& mp, std::vector<Range>& ranges, int target_prio)
{
	for (int i = 0, l = mp.size(), prio = 0, recording_range = 0; i < l; i++)
	{
		if (mp[i] == target_prio && !recording_range)
		{
			recording_range = 1;
			ranges.emplace_back(i, i);
		}
		else if (mp[i] == target_prio && recording_range)
		{
			ranges.back().finish = i;
		}
		else if (mp[i] != target_prio && recording_range)
		{
			recording_range = 0;
		}
	}
}

static void rank_inner_ops_raw(std::vector<int>& inner_op_ranks, const std::vector<Expression::Token>& mv, const int start, const int finish)
{
	for (int i = 0, lvl = 0; i < finish - start + 1; i++)
	{
		int idx = get_mop_location(mv, start + i);

		switch (mv[idx].v.o)
		{
		case Expression::Token::ADD:
		case Expression::Token::SUB:
			inner_op_ranks.push_back(0);
			break;
		case Expression::Token::MUL:
		case Expression::Token::DIV:
			inner_op_ranks.push_back(1);
			break;
		case Expression::Token::POW:
			inner_op_ranks.push_back(2);
			break;
		default:
			pr_warn("Operator is unrankable");
			break;
		}
	}
}

static void rank_inner_ops(std::vector<int>& inner_top_ops, const std::vector<Expression::Token>& mv, const int start, const int finish)
{
	for (int i = 0, lvl = 0; i < finish - start + 1; i++)
	{
		int idx = get_mop_location(mv, start + i);

		switch (mv[idx].v.o)
		{
		case Expression::Token::ADD:
		case Expression::Token::SUB:
			if (lvl == 0)
				inner_top_ops.push_back(i);

			break;
		case Expression::Token::MUL:
		case Expression::Token::DIV:
			if (lvl < 1)
			{
				lvl = 1;
				inner_top_ops.clear();
			}

			if (lvl == 1)
				inner_top_ops.push_back(i);

			break;
		case Expression::Token::POW:
			if (lvl < 2)
			{
				lvl = 2;
				inner_top_ops.clear();
			}

			if (lvl == 2)
				inner_top_ops.push_back(i);

			break;
		default:
			pr_warn("Operator is unrankable");
			break;
		}
	}
}

static void weight_operators(std::vector<int>& operator_weights, const std::vector<Expression::Token>& mv, const std::vector<int>& inner_top_ops, const int start)
{
	for (int i = 0, l = inner_top_ops.size(); i < l; i++)
	{
		int operator_location = get_mop_location(mv, start + inner_top_ops[i]);
		operator_weights.push_back(get_operator_weight(mv, operator_location));
	}
}

void post_process(std::vector<Expression::Token>& tv)
{
	pr_debug("Post processing:");
	Parser::print_math_vector(tv);

	// global prio evaluation
	std::vector<int> mp;
	create_prios_vector(tv, mp);

	if (mp.size() == 0)
	{
		return;
	}

	for (int current_prio_level = mp[get_max_index(mp)]; current_prio_level >= 0; current_prio_level--)
	{
		int corrections = 1;
		int relative_level = -current_prio_level;

		while (corrections)
		{
			corrections = 0;

			int same_op_cnt = -1;
			for (int i = 0; i < tv.size(); i++)
			{
				Expression::Token& tok = tv[i];

				if (tok.t == Expression::Token::OPERATOR)
				{
					if (tok.v.o == Expression::Token::OPA)
					{
						relative_level++;
					}
					else if (tok.v.o == Expression::Token::CPA)
					{
						relative_level--;
					}

					if (relative_level < 0)
					{
						same_op_cnt = -1;
					}
					else if ((tok.v.o == Expression::Token::SUB || tok.v.o == Expression::Token::DIV) && !relative_level)
					{
						same_op_cnt++;

						if (same_op_cnt == 2)
						{
							same_op_cnt = 0;

							corrections++;

							switch (tok.v.o)
							{
							case Expression::Token::SUB:
								tok.v.o = Expression::Token::ADD;
								break;
							case Expression::Token::DIV:
								tok.v.o = Expression::Token::MUL;
								break;
							default:
								pr_warn("Impossible operator in this branch, this is a bug!");
								break;
							}

							// inverse order to keep location valid between calls
							std::vector<int> highlight_locations;
							highlight_locations.emplace_back(i+1);
							highlight_locations.emplace_back(add_bracket_to(tv, i,  1) + 1);
							highlight_locations.emplace(highlight_locations.begin(), add_bracket_to(tv, i, -1));

							// advance one step to compensate for inserted left bracket
							i++;

							// elevate one level to compensate for new brackets
							relative_level++;

							Parser::print_math_vector(tv, highlight_locations);
						}
					}
				}
			}
		}
	}
}

std::vector<Expression::Operation> build_op_vector(const std::vector<Expression::Token>& tv)
{
	// define operator precedency
	std::vector<int> g_prios;
	create_prios_vector(tv, g_prios);

	for (int i = 0, l = g_prios.size(); i < l; i++)
	{
		pr_debug("prio=" << g_prios[i]);
	}

	// build operation vector
	std::vector<Expression::Operation> ov;
	{
		std::vector<Expression::Token> mv = tv;
		std::vector<int> mp = g_prios;

		while (mp.size())
		{
			int start, finish;
			find_top_prio_op_range(mp, start, finish);

			// --- process current range ---
			while (start != finish)
			{
				std::vector<int> inner_top_ops;
				rank_inner_ops(inner_top_ops, mv, start, finish);

				std::vector<int> operator_weights;
				weight_operators(operator_weights, mv, inner_top_ops, start);

				write_operation(ov, tv, mv, mp, start + inner_top_ops[get_min_index(operator_weights)]);
				finish--;
			}

			// process final operation w/out running selection algorithm
			write_operation(ov, tv, mv, mp, start);
		}
	}

	for (int i = 0, l = ov.size(); i < l; i++)
	{
		const Expression::Operation &o = ov[i];

		prs_debug("OP (w=" << o.w << "): ");

		if (o.tl == Expression::Operation::NORMAL)
		{
			const Expression::Token &real_value = tv[o.il];

			if (real_value.t == Expression::Token::VAR)
			{
				pri_debug(*real_value.v.s);
			}
			else
			{
				pri_debug(real_value.v.d);
			}
		}
		else
		{
			pri_debug("t" << o.il);
		}

		pri_debug(" " << o.o.op_math_str() << " ");

		if (o.tr == Expression::Operation::NORMAL)
		{
			const Expression::Token &real_value = tv[o.ir];

			if (real_value.t == Expression::Token::VAR)
			{
				pri_debug(*real_value.v.s);
			}
			else
			{
				pri_debug(real_value.v.d);
			}
		}
		else
		{
			pri_debug("t" << o.ir);
		}

		pri_debug(" = t" << i << "\n");
	}

	return ov;
}

Expression::TreeNode ov_to_tree(const std::vector<Expression::Token> tv, const std::vector<Expression::Operation>& ov)
{
	Expression::TreeNode root;
	std::queue<std::pair<Expression::TreeNode *, int>> queued_ops;

	if (ov.size())
	{
		queued_ops.emplace(&root, ov.size() - 1);
	}

	while (queued_ops.size())
	{
		const std::pair<Expression::TreeNode *, int> item = queued_ops.front();
		queued_ops.pop();

		const Expression::Operation &proc_op = ov[item.second];
		Expression::TreeNode &node = *item.first;

		node.o = proc_op.o;

		switch (proc_op.tl)
		{
		case Expression::Operation::DERIVED:
			queued_ops.emplace(node.l = new Expression::TreeNode(), proc_op.il);
			break;
		case Expression::Operation::NORMAL:
			node.l = new Expression::TreeNode(tv[proc_op.il]);
			break;
		}

		switch (proc_op.tr)
		{
		case Expression::Operation::DERIVED:
			queued_ops.emplace(node.r = new Expression::TreeNode(), proc_op.ir);
			break;
		case Expression::Operation::NORMAL:
			node.r = new Expression::TreeNode(tv[proc_op.ir]);
			break;
		}
	}

	return root;
}

#if 0
static int get_tree_depth(const Expression::TreeNode& root)
{
	retur
}
#endif

void print_op_tree(const Expression::TreeNode& root)
{
	std::vector<std::pair<Expression::TreeNode *, int>> items_to_display;
}

}