OTYAP 2.5

#include "stdafx.h"
#include <fstream>
#include <iostream>
#include <string>
#include <vector>
#include <streambuf>
#include <malloc.h>
#include <algorithm>

template <typename T>
typename T::size_type levenshtein_distance(const T & src, const T & dst)
{
	const typename T::size_type m = src.size();
	const typename T::size_type n = dst.size();
	if (m == 0)
	{
		return n;
	}
	if (n == 0)
	{
		return m;
	}

	std::vector<std::vector<typename T::size_type>> matrix(m + 1);

	for (typename T::size_type i = 0; i <= m; ++i)
	{
		matrix[i].resize(n + 1);
		matrix[i][0] = i;
	}
	for (typename T::size_type i = 0; i <= n; ++i)
	{
		matrix[0][i] = i;
	}

	typename T::size_type above_cell, left_cell, diagonal_cell, cost;

	for (typename T::size_type i = 1; i <= m; ++i)
	{
		for (typename T::size_type j = 1; j <= n; ++j)
		{
			cost = src[i - 1] == dst[j - 1] ? 0 : 1;
			above_cell = matrix[i - 1][j];
			left_cell = matrix[i][j - 1];
			diagonal_cell = matrix[i - 1][j - 1];
			matrix[i][j] = std::min(std::min(above_cell + 1, left_cell + 1), diagonal_cell + cost);
		}
	}

	return matrix[m][n];
}

#include <Windows.h>


/*
Printing color messages in console
Usage: print_str(sring_you_want_to_print, color_of_text, time_between_letters);
Colors: https://i.stack.imgur.com/ZG625.png
*/
inline bool print_str(char* str, int k, int n)
{
	HANDLE hConsole = GetStdHandle(((DWORD)-11)); //Console address to change text color
	SetConsoleTextAttribute(hConsole, k);
	for (int l = 0; l < int(strlen(str)); l++)
	{
		std::cout << str[l];
		Sleep(n);
	}
	SetConsoleTextAttribute(hConsole, 14);
	return true;
}

enum States { Start, Identifier, Num, Negative_num, Operations, Less, More, Assign, Equal, Fail,
			Ident_out, Num_out, Operat_out, Comparison_out, Assign_out,  Fail_out, Ident_end, Num_end};

const int matrix[10][10] =
{
	Identifier,    Identifier, Fail,    Fail,	    Fail,	    Fail,		    Fail,	     	Fail,       Fail,		    Fail,
	Num,           Identifier, Num,     Num,	    Fail,	    Fail,		    Fail,	        Fail,       Fail,		    Fail,
	Negative_num,  Fail,       Fail,    Fail,	    Fail,	    Fail,		    Fail,	        Fail,       Fail,		    Fail,
	Operations,    Fail,       Fail,    Fail,	    Fail,	    Fail,		    Fail,		    Fail,       Fail,	  	    Fail,
	Less,          Fail,       Fail,    Fail,	    More,	    Fail,		    Fail,		    Fail,       Fail,		    Fail,
	More,          Fail,       Fail,    Fail,	    More,	    More,		    Fail,		    Fail,       Fail,	   	    Fail,
	Assign,        Fail,       Fail,    Fail,	    Fail,	    Fail,		    Fail,		    Equal,      Fail,		    Fail,
	Start,         Ident_out,  Num_out, Operat_out, Operat_out, Comparison_out, Comparison_out, Assign_out, Comparison_out, Fail_out,
	Fail,          Ident_end,  Num_end, Fail,       Fail,	    Fail,		    Fail,	     	Fail,       Fail,		    Fail,
	Fail,          Fail,       Fail,    Fail,       Fail,	    Fail,		    Fail,		    Fail,       Fail,		    Fail,
};

/*
* Most important function in automaton. Determines how automaton will work. Add states or new conditions in it for new functionality
*/
bool keyword(char* word)
{
	bool is_keyword = false;
	std::vector<std::string> keywords = { "if", "then", "elseif", "end", "or", "not", "and" };
	for (int i = 0; i < 7; i++)
		if (word == keywords[i])
			is_keyword = true;
	return  is_keyword;
}

int row(char& a)
{
	if ((a >= 'a' && a <= 'z') || (a >= 'A' && a <= 'Z'))
		return 0;
	if (a >= '0' && a <= '9')
		return 1;
	if (a == '-')
		return 2;
	if (a == '+' || a == '*' || a == '/')
		return 3;
	if (a == '<')
		return 4;
	if (a == '>')
		return 5;
	if (a == '=')
		return 6;
	if (a == ' ' || a == '\t' || a == '\n' || a == '\r' || a == '\0')
		return 7;
	if (a == ';')
		return 8;
	return 9;
}

/*
Automaton
Usage: automaton(string_you_want_to_check, results_1, ... , results_n);
*/
void auto_rifle(char* str, std::vector<char*>& vec_1, std::vector<int>& vec_2)
{
	int size = 16;
	char* word = static_cast<char*>(malloc(size * sizeof(char)));
	int state = 0, i = 0;
	for (unsigned long long k = 0; k < strlen(str); k++)
	{
		if (state == 0)
		{
			i = 0;
			word = static_cast<char*>(malloc(size * sizeof(char)));
		}
		state = matrix[(row(str[k]))][state];
		word[i] = str[k];
		i++;
		if (i == size)
		{
			size *= 2;
			word = static_cast<char*>(realloc(word, size * sizeof(char)));
		}
		if (state == Ident_out || state == Ident_end)
		{
			if (state == Ident_end)
				word[i - 1] = 0;
			word[i - 1] = 0;
			if (keyword(word))
			{
				if(word == "if")
					vec_2.push_back(1);
				if (word == "then")
					vec_2.push_back(2);
				if (word == "elseif")
					vec_2.push_back(3);
				if (word == "or" || word == "and")
					vec_2.push_back(4);
				if (word == "not")
					vec_2.push_back(5);
				if (word == "end")
					vec_2.push_back(6);
				print_str("\" ", 10, 10); std::cout << word; print_str(" \"  ", 10, 10); print_str("Keyword\n", 11, 10);
			}
			else
			{
				vec_2.push_back(7);
				print_str("\" ", 10, 10); std::cout << word; print_str(" \"  ", 10, 10); print_str("Variable / Identifier\n", 10, 10);
			}
		}
		if (state == Num_out || state == Num_end)
		{
			if (state == Num_end)
				word[i - 1] = 0;
			vec_2.push_back(8);
			word[i - 1] = 0;
			print_str("\" ", 10, 10); std::cout << word; print_str(" \"  ", 10, 10); print_str("Constant numbers\n", 9, 10);
		}if (state == Operat_out)
		{
			vec_2.push_back(9);
			word[i - 1] = 0;
			print_str("\" ", 10, 10); std::cout << word; print_str(" \"  ", 10, 10); print_str("Arithmetic operations\n", 15, 10);
		}if (state == Comparison_out)
		{
			vec_2.push_back(10);
			word[i - 1] = 0;
			print_str("\" ", 10, 10); std::cout << word; print_str(" \"  ", 10, 10); print_str("Comparison operations\n", 13, 10);
		}
		if (state == Assign_out)
		{
			vec_2.push_back(11);
			word[i - 1] = 0;
			print_str("\" ", 10, 10); std::cout << word; print_str(" \"  ", 10, 10); print_str("Assignment operation\n", 5, 10);
		}
		if (state == Fail_out)
		{
			vec_2.push_back(13);
			word[i - 1] = 0;
			print_str("\" ", 10, 10); std::cout << word; print_str(" \"  ", 10, 10); print_str("Can't analyze\n", 12, 10);
		}
		if (state >= Ident_out && state <= Num_end)
		{
			vec_1.push_back(word);

			if (state == Ident_end || state == Num_end)
			{
				vec_1.push_back(";");
				vec_2.push_back(12);
				print_str("\" ", 10, 10); std::cout << ";"; print_str(" \"  ", 10, 10); print_str("End or operator\n", 3, 10);
			}
			size = 16;
			state = 0;
			i = 0;
			word = 0;
		}
	}
	return;
}

#undef max

const int Lex_matrix[13][11] =
{
	1,  10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
	10, 10, 5,  10, 10, 10, 10, 10, 10, 10, 10,
	10, 10, 1,  10, 10, 10, 10, 10, 10, 1,  10,
	10, 3,  10, 10, 3,  10, 10, 10, 10, 10, 10,
	10, 10, 1,  10, 10, 10, 10, 10, 10, 10, 10,
	10, 10, 10, 10, 10, 10, 10, 10, 10, 11, 10,
	10, 2,  10, 2,  2,  6,  10, 8,  10, 6,  10,
	10, 2,  10, 10, 2,  10, 10, 8,  10, 10, 10,
	10, 10, 10, 10, 10, 10, 10, 10, 7,  10, 10,
	10, 10, 4,  10, 10, 10, 10, 10, 10, 10, 10,
	10, 10, 10, 10, 10, 10, 7,  10, 10, 10, 10,
	10, 10, 10, 10, 10, 10, 10, 10, 9,  10, 10,
	10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10
};

int text_row(int num)
{
	if (num == 1)
		return 0;
	if (num == 2)
		return 1;
	if (num == 3)
		return 2;
	if (num == 4)
		return 3;
	if (num == 5)
		return 4;
	if (num == 6)
		return 5;
	if (num == 7)
		return 6;
	if (num == 8)
		return 7;
	if (num == 9)
		return 8;
	if (num == 10)
		return 9;
	if (num == 11)
		return 10;
	if (num == 12)
		return 11;
	return 12;
}

void text_analyze(std::vector<int>& vec)
{
	int state = 0;
	for (signed int i = 0; i < vec.size(); i++)
	{
		state = Lex_matrix[(text_row(vec[i]))][state];
		if (state == 11)
			std::cout << "happy end";
	}
}

/*
* Read function, reads from given path/.../file
* Usage: read(vec_you_want_to_fill)
* Now automatically reads everything and fills linked string to further work
*/
void read(char* &file)
{
	int size = 256, i = -1, k = 0;
	std::ifstream in;
	char ch;
	print_str("Write file name or path to it: ", 10, 10);
	do {
		char* file_path = static_cast<char*>(malloc(256 * sizeof(char)));
		file_path[255] = '\n';
		std::cin.getline(file_path, 256);
		if (file_path[255] != '\n')
		{
			print_str("You wrote too long file path and i ", 4, 10);
			std::cin.clear();
			std::cin.ignore(std::numeric_limits<std::streamsize>::max(), '\n');
		}
		in.open(file_path);
		free(file_path);
	} while (!in.is_open() && print_str("Couldn't read the file, type again: ", 4, 10));
	do
	{
		if (i == size)
		{
			size *= 2;
			file = static_cast<char*>(realloc(file, size * sizeof(char)));
		}
		file[++i] = in.get();
	} while (!in.eof());
	if (i == size)
	{
		size *= 2;
		file = static_cast<char*>(realloc(file, size * sizeof(char)));
	}
	file[i++] = '\n';
	file[i] = 0;
	in.close();
}

int main()
{
	setlocale(LC_ALL, "Russian");
	std::vector<char*> variables;
	std::vector<int> type;
	char* file = static_cast<char*>(malloc(256 * sizeof(char)));
	read(file);
	std::cout << file;
	auto_rifle(file, variables, type);
	free(file);
	text_analyze(type);
	print_str("\n\nPress enter to continue. . .", 7, 5);
	getchar();
	return 0;
}