hui

#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")
                    vec_2.push_back(4);
                if (word == "not"|| word == "and")
                    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[][] =
{

}

/*
* 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);
    print_str("Variable / Identifier:\n", 10, 10);
    for (unsigned int i = 0; i < type.size(); i++)
    {
        if (type[i] == 7)
        {
            print_str("\" ", 10, 10);
            std::cout << variables[i];
            print_str(" \"  ", 10, 10);
        }
    }
    print_str("\nConstant numbers:\n", 9, 10);
    for (unsigned int i = 0; i < type.size(); i++)
    {
        if (type[i] == 8)
        {
            print_str("\" ", 10, 10);
            std::cout << variables[i];
            print_str(" \"  ", 10, 10);
        }
    }
    print_str("\n\nPress enter to continue. . .", 7, 5);
    getchar();
    return 0;
}