#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <ctype.h>
#include<string>
#include<vector>
#include <iostream>
#include <string.h>
#include <stdlib.h>
using namespace std;
//#define BUFSIZE 80
typedef struct tabl
{
    vector<string> v;
} *ptabl;

tabl nTW, nTID, nTD, nTNUM;
ptabl TW = &nTW, TID = &nTID, TD = &nTD, TNUM = &nTNUM;
enum table
{
    tW, tID, tD, tNUM
};

struct lex
{
    int t;
    int ind;
    bool operator ==(lex a)
    {
        return t == a.t && ind == a.ind;
    }
};
//char buf[BUFSIZE];
string  buf;
char c;
int d;
void clear(void);
void add(void);
int look(ptabl t);
int putl(ptabl t);
int putnum();
int j;
void makelex(table t, int n);
void print_tables();
lex get_lex(void);
//lex scan(void);
void load_TD();
void load_TW();
FILE* fp;
lex eof = { 2,1 }, er = { -1,-1 };
lex cur_lex= { 0,0 };
void O();//операторы
void OP();//оператор
bool OPERAND();//операнд
void AR();//арифметическое выражение
bool AR_op();//арифметическая операция
void L();//логическoе выражение
void SR();//выражение сравнения
bool SR_op();//операция сравнения
bool Un();//унарная лог операция
bool Bin();//бинарная логическая операция
bool is_id();
bool is_num();
bool equal(string s);
string find_cur_lex();
string searchInTable(ptabl t, int i);
string current_lex="";
int main()
{

    load_TD();
    load_TW();
    fp = fopen("input.txt", "r");
    c = fgetc(fp);
    cur_lex = get_lex();
    find_cur_lex();
    if (!equal("do"))
    {
        printf("ERROR do expected");
        return 0;
    }
    cur_lex = get_lex();
    find_cur_lex();
    O();
    //cur_lex = scan();
    //find_cur_lex();
    if (!equal("loop"))
    {
        printf("ERROR loop expected");
        return 0;
    }
    cur_lex = get_lex();
    find_cur_lex();
    if (!equal("while"))
    {
        printf("ERROR while expected");
        return 0;
    }
    cur_lex = get_lex();
    find_cur_lex();
    L();
    if (!(cur_lex == eof))
    {
        printf("ERROR EOF expected");
    }
    printf("OKKKK\n");
    print_tables();
}
lex get_lex(void)
{
    enum state
    {
        H, ID, NUM, COM, ASS, DLM, ER, FIN
    };
    state TC;

    TC = H;


    do
    {
        switch (TC)
        {
        case H:
            if (isspace(c))
                c = fgetc(fp);
            else if (isalpha(c))
            {
                clear();
                add();
                c = fgetc(fp);
                TC = ID;
            }
            else if (isdigit(c))
            {
                d = c - '0'; c = fgetc(fp);
                TC = NUM;
            }
            else if (c == '{')
            {
                c = fgetc(fp);
                TC = COM;
            }
            else if (c == '}')
            {
                TC = ER;
            }
            else if (c == ':')
            {
                c = fgetc(fp);
                if (c == '=')
                {
                    buf = ":=";
                    //makelex(tD, look(TD));
                    c = fgetc(fp);
                    //find_cur_lex();
                    return { tD, look(TD) };
                }
                else
                {
                    TC = ER;
                }

            }
            else if (c == '!')
            {
                c = fgetc(fp);
                if (c == '=')
                {
                    buf = "!=";
                    //makelex(tD, look(TD));
                    c = fgetc(fp);
                //  find_cur_lex();
                    return { tD, look(TD) };

                }
                else
                    TC = ER;
            }
            else if (c == EOF)
            {
                clear();
                add();
                //makelex(tD, look(TD));
                TC = FIN;
                //find_cur_lex();
                return {tD, look(TD) };

            }
            else
                TC = DLM;
            break;
        case ID:
            if (isalpha(c) || isdigit(c))
            {
                add();
                c = fgetc(fp);
            }
            else
            {
                if (j = look(TW))
                {
                    //makelex(tW, j);
                    TC = H;
                    //find_cur_lex();
                    return { tW, j };
                }
                else {
                    j = putl(TID);
                    //makelex(tID, j);
                    TC = H;
                    //find_cur_lex();
                    return { tID, j };
                }; TC = H;
            };
            break;
        case COM:
            if (c == '}')
            {
                c = fgetc(fp);
                TC = H;
            }
            else if (c == EOF)
                TC = ER;
            else
                c = fgetc(fp);

            break;
        case NUM:
            if (isdigit(c)) {
                d = d * 10 + (c - '0');
                c = fgetc(fp);
            }
            else
            {
                if (isalpha(c))
                {
                    TC = ER;

                    continue;
                }
                //makelex(tNUM, );
                TC = H;
                buf = to_string(d);
                if (j = look(TNUM))
                {
                    //makelex(tW, j);
                    //TC = H;
                    //find_cur_lex();
                    return { tNUM, j };
                }

                return { tNUM, putnum() };

            }
            break;
        case DLM:
            clear();
            add();
            c = fgetc(fp);
            if (j = look(TD))
            {
                //makelex(tD, j);
                TC = H;
                //find_cur_lex();
                return { tD, j };

            }
            else
            {
                TC = ER;
            }

            break;
            default:
                c = fgetc(fp);
        }

    } while (TC != FIN && TC != ER);

    if (TC == ER)
    {
        printf("ERROR!!!\n\n");
        return{-1,-1};
    }
    else
    {
        printf("O.K.!!!\n\n");
        return { 2,1 };
    }
    //print_tables();
}
void clear(void)
{
    buf.clear();
}
void add(void)
{
    buf.push_back(c);
}
int look(ptabl t)
{
    for (int i = 0; i < t->v.size(); i++)
        if (buf == t->v[i])
            return j = (i+1);
    return 0;
}
int putl(ptabl t)
{
    int ex = look(t);
    if (ex)
        return ex;

    t->v.push_back(buf);
    return t->v.size();
}
int putnum()
{
    TNUM->v.push_back(to_string(d));
    return TNUM->v.size();
}
void makelex(table t, int n)
{
    n--;
    switch (t)
    {
    case tID:
        printf("(TID, %2d)  : %s\n", n, TID->v[n].c_str());
        break;
    case tNUM:
        printf("(TNUM, %2d) : %s\n", n, TNUM->v[n].c_str());
        break;
    case tD:
        printf("(TD, %2d)   : %s\n", n, TD->v[n][0] == EOF ? "End Of File" : TD->v[n].c_str());
        break;
    case tW:
        printf("(TW, %2d)   : %s\n", n, TW->v[n].c_str());
        break;
    }
}
void load_TD()
{
    string s;
    s.push_back(EOF);
    TD->v.push_back(s);
//  TD->v.push_back(":");
    TD->v.push_back(";");
    TD->v.push_back(":=");
    TD->v.push_back("!=");
    TD->v.push_back("+");
    TD->v.push_back("-");
    TD->v.push_back("=");
    TD->v.push_back("*");
    TD->v.push_back("/");
    TD->v.push_back("(");
    TD->v.push_back(")");
    TD->v.push_back(">");
    TD->v.push_back("<");

}
void load_TW()
{
    //TW->v.push_back("if");
    TW->v.push_back("do");
    TW->v.push_back("not");
    TW->v.push_back("or");
    TW->v.push_back("and");
    TW->v.push_back("loop");
    TW->v.push_back("while");
    //TW->v.push_back("begin");
    //TW->v.push_back("end");
    //TW->v.push_back("end.");
}

void print_tables()
{
    for (int i = 1; i <= TW->v.size(); i++)
        makelex(tW, i);
    printf("\n\n");
    for (int i = 1; i <= TD->v.size(); i++)
        makelex(tD, i);
    printf("\n\n");
    for (int i = 1; i <= TID->v.size(); i++)
        makelex(tID, i);
    printf("\n\n");
    for (int i = 1; i <= TNUM->v.size(); i++)
        makelex(tNUM, i);
    printf("\n\n");
}
bool is_id()
{
    return (cur_lex.t == 1);

}
bool is_num()
{
    return cur_lex.t == 3;
}

bool equal(string s)
{
    if (cur_lex.t == tW)
        return s == searchInTable(TW, cur_lex.ind);
    if (cur_lex.t == tNUM)
        return s == searchInTable(TNUM, cur_lex.ind);
    if (cur_lex.t == tD)
        return s == searchInTable(TD, cur_lex.ind);
    if (cur_lex.t == tID)
        return s == searchInTable(TID, cur_lex.ind);
}

string searchInTable(ptabl t, int i)
{
    i--;
    return t->v[i];
}
void O()
{
    OP();
    if (equal(";"))
    {
        cur_lex = get_lex();
        find_cur_lex();
        O();
    }
    //cur_lex = scan();
    //find_cur_lex();
}
void OP()
{
    if (!is_id())
    {
        printf("ERRROR ID expected\n");
        exit(0);
    }
    cur_lex = get_lex();
    find_cur_lex();
    if(!equal(":="))
    {
        printf("ERRROR := expected\n");
        exit(0);
    }
    cur_lex = get_lex();
    find_cur_lex();
    AR();
}
void AR()
{
    if (equal("("))
    {
        cur_lex = get_lex();
        find_cur_lex();
        AR();
        if (!equal(")"))
        {
            printf("ERRROR ')' expected\n");
            exit(0);
        }
        cur_lex = get_lex();
        find_cur_lex();

        return;

    }

    if (!OPERAND())
        return;
    if (AR_op())
    {
        AR();
    }

    //cur_lex = scan();
}
bool AR_op()
{
    if(!equal("*") && !equal("/") && !equal("+") && !equal("-"))
    {
        return false;
        /*if (!equal(":="))
        {
            printf("ERRROR arithmetical operation expected expected\n");
            exit(0);
        }*/

    }
    cur_lex = get_lex();
    find_cur_lex();
    return true;
}
bool OPERAND()
{
    if (!is_id() && !is_num())
    {
        //printf("ERRROR Operand expected\n");
        //exit(0);
        return false;
    }

    cur_lex = get_lex();
    find_cur_lex();
    return true;
}
string find_cur_lex()
{
    if (cur_lex.t == tW)
        return current_lex = searchInTable(TW, cur_lex.ind);
    if (cur_lex.t == tNUM)
        return current_lex = searchInTable(TNUM, cur_lex.ind);
    if (cur_lex.t== tD)
        return current_lex = searchInTable(TD, cur_lex.ind);
    if (cur_lex.t == tID)
        return current_lex = searchInTable(TID, cur_lex.ind);

}

void L()
{
    Un();
    SR();
    if (Bin())
        L();
}

void SR()
{

    if (!OPERAND())
    {
        printf("ERRROR Operand  expected\n");
        exit(0);
    }

    if (!SR_op())
        return;

    if (!OPERAND())
    {
        printf("ERRROR Operand  expected\n");
        exit(0);
    }
}

bool Un()
{
    if (equal("not"))
    {
        cur_lex = get_lex();
        find_cur_lex();
        return true;
    }

    return false;
}

bool Bin()
{
    if (equal("and") || equal("or"))
    {
        cur_lex = get_lex();
        find_cur_lex();
        return true;
    }

    return false;
}

bool SR_op()
{
    if (equal(">") || equal("<") || equal("=") || equal("!="))
    {
        cur_lex = get_lex();
        find_cur_lex();
        return true;
    }
    return false;
}