pzks-labs/src/parser.cpp

#include <iostream>
#include <cctype>
#include <cstring>
#include <memory>
#include <vector>
#include "expression.hpp"
#include "print.h"

namespace Parser {

class Parser
{
	enum State {
		I, // idle
		RC, // read constant
		RV, // read variable
		OP, // read operator
	} s;

	const char *state_str(enum State e)
	{
		switch (e)
		{
		case I:
			return "I";
		case RC:
			return "RC";
		case RV:
			return "RV";
		case OP:
			return "OP";
		default:
			return "Not a valid state!";
		}
	}

	void switch_state(enum State e)
	{
		pr_debug("Leaving " << state_str(s) << ", entering " << state_str(e));
		switch (s)
		{
		case I:
			leave_i();
			break;
		case RC:
			leave_rc();
			break;
		case RV:
			leave_rv();
			break;
		case OP:
			leave_op();
			break;
		default:
			pr_warn("Warning: broken state machine on leave");
			break;
		}

		switch (e)
		{
		case I:
			enter_i();
			break;
		case RC:
			enter_rc();
			break;
		case RV:
			enter_rv();
			break;
		case OP:
			enter_op();
			break;
		default:
			pr_warn("Warning: broken state machine on enter");
			break;
		}

		s = e;
	}

public:
	char buffer[256];
	std::shared_ptr<std::vector<Expression::Token>>& pv;

	Parser(std::shared_ptr<std::vector<Expression::Token>>& pv)
		: s(I), pv(pv)
	{
		buf_clear();
	}

	void buf_clear(void)
	{
		memset(buffer, 0, 256);
	}

	void buf_push(char c)
	{
		buffer[strlen(buffer)] = c;
	}

	int dispatch_to_current(char c)
	{
		switch (s)
		{
		case I:
			return parse_i(c);
		case RC:
			return parse_rc(c);
		case RV:
			return parse_rv(c);
		case OP:
			return parse_op(c);
		default:
			pr_warn("State machine is broken, unable to dispatch character " << c << ", returning 0");
			return 0;
		}
	}

	void enter_i(void) {}
	int  parse_i(char c)
	{
		if (isdigit(c) || c == '.')
		{
			switch_state(RC);
			return 1;
		}
		else if (isalpha(c))
		{
			switch_state(RV);
			return 1;
		}
		else if (c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')')
		{
			switch_state(OP);
			return 1;
		}
		else
		{
			pr_warn("Unknown character skipped (" << c << "), still in idle");
			return 0;
		}
	}
	void leave_i(void) {}

	void enter_rc(void)
	{
		buf_clear();
	}
	int  parse_rc(char c)
	{
		if (!(isdigit(c) || c == '.'))
		{
			switch_state(I);
			return 1;
		}
		else
		{
			buf_push(c);
			return 0;
		}
	}
	void leave_rc(void)
	{
		double value;

		if (!sscanf(buffer, "%lf", &value))
		{
			pr_warn("Invalid CONST: " << buffer);
		}
		else
		{
			pv->push_back(Expression::Token(value));
		}
	}

	void enter_rv(void)
	{
		buf_clear();
	}
	int  parse_rv(char c)
	{
		if (!isalpha(c))
		{
			switch_state(I);
			return 1;
		}
		else
		{
			buf_push(c);
			return 0;
		}
	}
	void leave_rv(void)
	{
		pv->push_back(Expression::Token(buffer));
	}

	void enter_op(void)
	{
		buf_clear();
	}
	int  parse_op(char c)
	{
		if (!(c == '+' || c == '-' || c == '*' || c == '/' || c == '(' || c == ')'))
		{
			switch_state(I);
			return 1;
		}
		else
		{
			buf_push(c);
			return 0;
		}
	}
	void leave_op(void)
	{
		if      (!strcmp(buffer, "("))
		{
			pv->push_back(Expression::Token(Expression::Token::OPA));
		}
		else if (!strcmp(buffer, ")"))
		{
			pv->push_back(Expression::Token(Expression::Token::CPA));
		}
		else if (!strcmp(buffer, "+"))
		{
			pv->push_back(Expression::Token(Expression::Token::ADD));
		}
		else if (!strcmp(buffer, "-"))
		{
			pv->push_back(Expression::Token(Expression::Token::SUB));
		}
		else if (!strcmp(buffer, "*"))
		{
			pv->push_back(Expression::Token(Expression::Token::MUL));
		}
		else if (!strcmp(buffer, "/"))
		{
			pv->push_back(Expression::Token(Expression::Token::DIV));
		}
		else if (!strcmp(buffer, "**"))
		{
			pv->push_back(Expression::Token(Expression::Token::POW));
		}
		else
		{
			pr_warn("Skip unknown operator: " << buffer);
		}
	}
};

std::shared_ptr<std::vector<Expression::Token>> tokenize_input(char *input_string)
{
	std::shared_ptr<std::vector<Expression::Token>> pv = std::make_shared<std::vector<Expression::Token>>();

	Parser p(pv);
	for (int i = 0, l = strlen(input_string); i < l; i++)
	{
		i -= p.dispatch_to_current(input_string[i]);
	}

	(void) p.dispatch_to_current('\0');

	return pv;
}

int assert_same(std::vector<Expression::Token>& a, std::vector<Expression::Token>& b)
{
	if (a.size() != b.size())
	{
		std::cout << "Vectors are of different lengths: " << a.size() << " != " << b.size() << "\n";
		return 1;
	}

	for (int i = 0, l = a.size(); i < l; i++)
	{
		if (a[i].t != b[i].t)
		{
			std::cout << "Token " << i << " types differ: " << a[i].type_str() << " != " << b[i].type_str() << "\n";
			return 1;
		}

		switch (a[i].t)
		{
		case Expression::Token::VAR:
			if (strcmp((*(a[i].v.s)).c_str(),
				   (*(b[i].v.s)).c_str()))
			{
				std::cout << "Variable names at " << i << " differ: " << (*(a[i].v.s)).c_str() << " != " << (*(b[i].v.s)).c_str() << "\n";
				return 1;
			}
			break;
		case Expression::Token::CONST:
			if (a[i].v.d != b[i].v.d)
			{
				std::cout << "Constants at " << i << " differ: " << a[i].v.d << " != " << b[i].v.d << "\n";
				return 1;
			}
			break;
		case Expression::Token::OPERATOR:
			if (a[i].v.o != b[i].v.o)
			{
				std::cout << "Operators at " << i << " differ: " << a[i].op_str() << " != " << b[i].op_str() << "\n";
				return 1;
			}
			break;
		}
	}
	return 0;
}

}