main.cpp

#include <regex> 
#include <map>
#include <vector>
#include <stack>
#include <iostream>
#include <fstream>
#include <string>
#include <sstream>

using namespace std;

//Ñïèñîê ëåêñåì
enum Lexem {
    lex_error = -1,
    lex_begin = 1,
    lex_var,
    lex_type,
    lex_id,
    lex_const,
    lex_equal,
    lex_minus,
    lex_plus,
    lex_multiply,
    lex_div,
    lex_lbracket,
    lex_rbracket,
    lex_comma,
    lex_end,
    lex_dot,
    lex_colon,
    lex_semicol,
};

#define CODE_FILEPATH "code.txt"
#define LEX_FILEPATH "lex.txt"
#define PFIX_BUFF_FILEPATH "pfix_buff.txt"
#define PFIX_FILEPATH "pfix.txt"
#define MNEMOCODE_FILEPATH "mnemocode.txt"

ifstream lexFile{ LEX_FILEPATH };
ofstream buffPfixFile{ PFIX_BUFF_FILEPATH };
int currentId;
size_t currentString;
string currentLexeme;

int Z();
//Ïîäâûðàæåíèå
int W();
//Âûðàæåíèå
int E();
//Ïðèñâàèâàíèå (+ ïðèñâàèâàíèå)
int A();
//Êîä ïðîãðàììû
int F();
//Áëîê êîäà (begin F end.)
int D();
//Îáúÿâëåíèå òèïà è ïðîãðàììà
int T();
//Ñïèñîê ïåðåìåííûõ èëè îáúÿâëåíèå òèïà
int X();
//Îáúÿâëåíèå ïåðåìåííûõ
int S();


//Ëåñêè÷åñêèé àíàëèç
int LexicalAnalysis()
{
    bool isErrorExists{ false };


    regex regexw(R"([a-z_A-Z_]+)"); //Ñëîâî
    regex regexd("([0-9]+)"); //×èñëî
    regex regexi(R"(^[a-z_A-Z_]+[a-z_A-Z_0-9]*)"); //Èäåíòèôèêàòîð

    //Ïîòîê ÷òåíèÿ èñõîäíîãî ôàéëà ñ êîäîì
    ifstream srcFile{ CODE_FILEPATH };
    //Ïîòîê çàïèñè ôàéëà ñ ëåêñè÷åñêèì àíàëèçîì
    ofstream destFile{ LEX_FILEPATH };



    if (!srcFile)
    {
        cout << "[ERROR]\t\t" << "File error : Unable to open source file.Expected path : " << CODE_FILEPATH << endl;
        return 1;
    } 
    else
    {
        cout << "[DEBUG]\t\t" << "The original file was successfully opened" << endl;
    }


    //Íàêàïëèâàþùàÿ ñòðîêà áóôåð
    string strBuff;

    //Òåêóùèé ñèìâîë
    char sym;

    //Èäåíòèôèêàòîð ëåêñåìû
    int id;

    //Òåêóùàÿ ñòðîêà
    size_t currentString = 1;



    while (!srcFile.eof())
    {
        id = lex_error;
        strBuff = "";
        sym = srcFile.get();

        if (sym == ' ' || sym == '\n' || sym == '\t\t' || sym == EOF)
        {
            if (sym == '\n') currentString++;
            continue;
        }

        if (isalpha(sym) || isdigit(sym))
        {
            strBuff += sym;

            while (isalpha(srcFile.peek()) || isdigit(srcFile.peek()))
            {
                sym = srcFile.get();
                strBuff += sym;
            }
            if (regex_match(strBuff, regexd)) id = lex_const; // Åñëè ñëîâî ÿâëÿåòñÿ êîíñòàíòîé
            else if (regex_match(strBuff, regexi)) { // Ñðàâíåíèå ñëîâà ñ êëþ÷åâûìè ïî ðåãóëÿðíûì âûðàæåíèÿì
                if (strBuff == "Begin") id = lex_begin;
                else if (strBuff == "Var") id = lex_var;
                else if (strBuff == "Integer") id = lex_type;
                else if (strBuff == "End") id = lex_end;
                else id = lex_id; // Èíà÷å ñëîâî ÿâÿåòñÿ èäåíòèôèêàòîðîì
            }
            else id = lex_error; // Îøèáêà
        }
        else {
            strBuff += sym;

            switch (strBuff[0]) // Åñëè âñòðåòèëñÿ îïåðàòîð
            {
            case '=':
                id = lex_equal;
                break;
            case '-':
                id = lex_minus;
                break;
            case '+':
                id = lex_plus;
                break;
            case '*':
                id = lex_multiply;
                break;
            case '/':
                id = lex_div;
                break;
            case '(':
                id = lex_lbracket;
                break;
            case ')':
                id = lex_rbracket;
                break;
            case ',':
                id = lex_comma;
                break;
            case '.':
                id = lex_dot;
                break;
            case ';':
                id = lex_semicol;
                break;
            case ':':
                id = lex_colon;
                break;
            default:
                id = lex_error;
                break;
            }
        }
        if (id == lex_error)
        {
            cout << "Lexical error: " << '\'' << strBuff << "\' " << " is undefined " << '\n';
            isErrorExists = true;
        }
        destFile << strBuff << " " << id << " " << currentString << '\n';

    }

    cout << "[DEBUG]\t\t" << "The lexical file was successfully written" << endl;
    srcFile.close();
    cout << "[DEBUG]\t\t" << "The original file was closed" << endl;
    destFile.close();
    cout << "[DEBUG]\t\t" << "The lexical file was closed" << endl;
    if (isErrorExists)
        return 1;
    return 0;
}


//ÍÅÒÅÐÌÈÍÀËÛ


//Âñïîìîãàòåëüíûé íåòåðìèíàë
int Z()
{
    if (currentId == lex_semicol || currentId == lex_rbracket)
    {
        return 0;
    }
    else if (currentId == lex_plus || currentId == lex_minus || currentId == lex_multiply || currentId == lex_div)
    {
        buffPfixFile << currentLexeme << ' ' << currentId << ' ' << currentString << '\n';
        lexFile >> currentLexeme >> currentId >> currentString;

        return W();
    }
    else
    {
        cout << "[ERROR]\t\t" << "Syntax error: expected \';\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    }
}


//Âûðàæåíèå
int E()
{
    if (currentId == lex_minus)
    {
        buffPfixFile << '~' << ' ' << currentId << ' ' << currentString << '\n';
        lexFile >> currentLexeme >> currentId >> currentString;
    }
    return W();
}


//Ïîäâûðàæåíèå
int W()
{
    if (currentId == lex_lbracket)
    {
        buffPfixFile << currentLexeme << ' ' << currentId << ' ' << currentString << '\n';
        lexFile >> currentLexeme >> currentId >> currentString;

        if (E() != 0)
        {
            return 1;
        }

        if (currentId == lex_rbracket)
        {
            buffPfixFile << currentLexeme << ' ' << currentId << ' ' << currentString << '\n';
            lexFile >> currentLexeme >> currentId >> currentString;

            return Z();
        }
        else {
            cout << "[ERROR]\t\t" << "Syntax error: expected \')\', but " << currentLexeme << " encountered at line " << currentString << endl;
            return 1;
        }
    }
    else if (currentId == lex_id || currentId == lex_const)
    {
        buffPfixFile << currentLexeme << ' ' << currentId << ' ' << currentString << '\n';
        lexFile >> currentLexeme >> currentId >> currentString;

        return Z();
    }
    else {
        cout << "[ERROR]\t\t" << "Syntax error: expected \'operator\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    }
}


//Ïðèñâàèâàíèå (+ ïðèñâàèâàíèå)
int A()
{
    if (currentId != lex_id) {
        cout << "[ERROR]\t\t" << "Syntax error: expected \'identificator\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    }
    buffPfixFile << currentLexeme << ' ' << currentId << ' ' << currentString << '\n';
    lexFile >> currentLexeme >> currentId >> currentString;

    if (currentId != lex_equal)
    {
        cout << "[ERROR]\t\t" << "Syntax error: expected \'=\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    }
    buffPfixFile << currentLexeme << ' ' << currentId << ' ' << currentString << '\n';
    lexFile >> currentLexeme >> currentId >> currentString;

    return E();
}


//Êîä ïðîãðàììû
int F()
{
    lexFile >> currentLexeme >> currentId >> currentString;

    while (currentId != lex_end && !lexFile.eof())
    {
        if (A() != 0)
        {
            return 1;
        }
        buffPfixFile << currentLexeme << ' ' << currentId << ' ' << currentString << '\n';
        lexFile >> currentLexeme >> currentId >> currentString;
    }
    return 0;
}


//Áëîê êîäà (begin F end.)
int D()
{
    lexFile >> currentLexeme >> currentId >> currentString;

    if (currentId != lex_begin) {
        cout << "[ERROR]\t\t" << "Syntax error: expected \'Begin\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    }

    if (F() != 0) {
        return 1;
    }

    if (currentId != lex_end) {
        cout << "[ERROR]\t\t" << "Syntax error: expected \'End\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    }

    lexFile >> currentLexeme >> currentId >> currentString;

    if (currentId != lex_dot) {
        cout << "[ERROR]\t\t" << "Syntax error: expected \'.\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    }

    return 0;
}


//Îáúÿâëåíèå òèïà è ïðîãðàììà
int T()
{
    lexFile >> currentLexeme >> currentId >> currentString;

    if (currentId != lex_type) {
        cout << "[ERROR]\t\t" << "Syntax error: expected \'Integer\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    }

    lexFile >> currentLexeme >> currentId >> currentString;
    buffPfixFile << currentLexeme << ' ' << currentId << ' ' << currentString << '\n';
    if (currentId != lex_semicol) {
        cout << "[ERROR]\t\t" << "Syntax error: expected \';\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    }

    return D();
}


//Ñïèñîê ïåðåìåííûõ èëè îáúÿâëåíèå òèïà
int X()
{
    lexFile >> currentLexeme >> currentId >> currentString;

    if (currentId == lex_comma)
        return S();
    else if (currentId == lex_colon)
        return T();
    else
    {
        cout << "[ERROR]\t\t" << "Syntax error: expected \':\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    }
}


//Îáúÿâëåíèå ïåðåìåííûõ
int S()
{
    lexFile >> currentLexeme >> currentId >> currentString;

    if (currentId == lex_id)
    {
        buffPfixFile << currentLexeme << ' ' << currentId << ' ' << currentString << '\n';
        return X();
    }
    else
    {
        cout << "[ERROR]\t\t" << "Syntax error: expected \'identificator\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    }
}


//Ñèíòàêñè÷åñêèé àíàëèç
int SyntaxAnalysis()
{
    //Îòêðûòèå ïîòîêà äëÿ ÷òåíèÿ ôàéëà ëåêñè÷åñêîãî àíàëèçà
    if (!lexFile)
    {
        cout << "[ERROR]\t\t" << "File error: Unable to open source file. Expected path: " << LEX_FILEPATH << endl;
        return 1;
    }
    else
    {
        cout << "[DEBUG]\t\t" << "The lexical file was successfully opened" << endl;
    }

    //Îòêðûòèå ïîòîêà äëÿ ÷òåíèÿ ôàéëà ëåêñè÷åñêîãî àíàëèçà
    if (!buffPfixFile)
    {
        cout << "[ERROR]\t\t" << "File error: Unable to open source file. Expected path: " << PFIX_BUFF_FILEPATH << endl;
        return 1;
    }
    else
    {
        cout << "[DEBUG]\t\t" << "The buffer postfix file was successfully opened" << endl;
    }

    lexFile >> currentLexeme >> currentId >> currentString;

    if (currentId == lex_var)
    {
        return S();
    }
    else
    {
        cout << "[ERROR]\t\t" << "Syntax error: expected \'Var\', but " << currentLexeme << " encountered at line " << currentString << endl;
        return 1;
    };
}

int MakeRPN()
{
    ifstream buffPfixFile{ PFIX_BUFF_FILEPATH };
    ofstream pfixFile{ PFIX_FILEPATH }; // Ôàéë äëÿ çàïèñè ðåçóëüòàòà

    if (!buffPfixFile)
    {
        cout << "[ERROR]\t\t" << "File error: Unable to open source file. Expected path: " << PFIX_BUFF_FILEPATH << endl;
        return 1;
    }
    else
    {
        cout << "[DEBUG]\t\t" << "The buffer postfix file was successfully opened" << endl;
    }

    if (!pfixFile)
    {
        cout << "[ERROR]\t\t" << "File error: Unable to open output file. Expected path: " << PFIX_FILEPATH << endl;
        return 1;
    }
    else
    {
        cout << "[DEBUG]\t\t" << "The postfix file was successfully opened" << endl;
    }


    map<string, int> varMap;
    stack<string> opStack;
    bool isAssignment = false; // Ôëàã, óêàçûâàþùèé, íàõîäèòñÿ ëè ëåâàÿ ÷àñòü âûðàæåíèÿ äî çíàêà "="

    do 
    {
        buffPfixFile >> currentLexeme >> currentId >> currentString;
        if (currentId == lex_id)
        {
            varMap.insert(std::make_pair(currentLexeme, 1));
        }

    } while (currentId != lex_semicol && !buffPfixFile.eof());    

    while (buffPfixFile >> currentLexeme >> currentId >> currentString)
    {
        if (currentId == lex_id) // Åñëè ëåêñåìà ÿâëÿåòñÿ èäåíòèôèêàòîðîì
        {
            if (isAssignment) {
                // Åñëè ïåðåìåííàÿ íàõîäèòñÿ â ëåâîé ÷àñòè âûðàæåíèÿ, èíèöèàëèçèðóåì å¸
                varMap[currentLexeme] = 2;
            }
            else {
                // Ïðîâåðÿåì, áûëà ëè îáúÿâëåíà ïåðåìåííàÿ
                if (varMap.find(currentLexeme) == varMap.end() || varMap[currentLexeme] == 0) {
                    cout << "[ERROR]\t\t" << "Error: Variable '" << currentLexeme << "' is not declared or initialized at line " << currentString <<"." << endl;
                    return 1;
                }
            }
            pfixFile << currentLexeme << " ";
        }
        else if (currentId == lex_const) // Åñëè ëåêñåìà ÿâëÿåòñÿ êîíñòàíòîé
        {
            pfixFile << currentLexeme << " ";
        }
        else if (currentId == lex_equal) // Åñëè ýòî çíàê ïðèñâàèâàíèÿ
        {
            isAssignment = true; // Ëåâàÿ ÷àñòü âûðàæåíèÿ äî çíàêà "="
            opStack.push(currentLexeme);
        }
        else if (currentId == lex_plus || currentId == lex_minus || currentId == lex_multiply || currentId == lex_div) // Åñëè ýòî îïåðàòîðû
        {
            while (!opStack.empty() && ((currentId == lex_plus || currentId == lex_minus) &&
                (opStack.top() == "*" || opStack.top() == "/" || opStack.top() == "-")) ||
                ((currentId == lex_multiply || currentId == lex_div) &&
                    (opStack.top() == "*" || opStack.top() == "/")))
            {
                pfixFile << opStack.top() << " ";
                opStack.pop();
            }
            opStack.push(currentLexeme);
        }
        else if (currentId == lex_lbracket) // Åñëè îòêðûâàþùàÿ ñêîáêà
        {
            opStack.push(currentLexeme);
        }
        else if (currentId == lex_rbracket) // Åñëè çàêðûâàþùàÿ ñêîáêà
        {
            while (!opStack.empty() && opStack.top() != "(") {
                pfixFile << opStack.top() << " ";
                opStack.pop();
            }
            opStack.pop(); // Óáèðàåì îòêðûâàþùóþ ñêîáêó
        }
        else if (currentId == lex_semicol) // Êîíåö âûðàæåíèÿ
        {
            while (!opStack.empty()) {
                pfixFile << opStack.top() << " ";
                opStack.pop();
            }
            pfixFile << endl;
            isAssignment = false; // Îáíóëÿåì ôëàã ïðèñâàèâàíèÿ äëÿ ñëåäóþùåãî âûðàæåíèÿ
        }
    }


    buffPfixFile.close();
    cout << "[DEBUG]\t\t" << "The buffer postfix file was successfully closed" << endl;
    pfixFile.close();
    cout << "[DEBUG]\t\t" << "The postfix file was successfully closed" << endl;

    return 0;

}


int GenerateMnemocode()
{
    regex regexd("([0-9]+)"); 
    regex regexi(R"(^[a-z_A-Z_]+[a-z_A-Z_0-9]*)"); 

    ifstream pfixFile{ PFIX_FILEPATH };
    if (!pfixFile)
    {
        cout << "[ERROR]\t\t" << "Unable to open postfix file. Expected path: " << PFIX_FILEPATH << endl;
        return 1;
    }
    else
    {
        cout << "[DEBUG]\t\t" << "The postfix file was successfully opened" << endl;
    }

    ofstream mnemocodeFile{ MNEMOCODE_FILEPATH };
    if (!mnemocodeFile)
    {
        cout << "[ERROR]\t\t" << "Unable to open mnemocode file. Expected path: " << MNEMOCODE_FILEPATH << endl;
        return 1;
    }
    else
    {
        cout << "[DEBUG]\t\t" << "The mnemocode file was successfully opened" << endl;
    }



    vector<string> pfixLine;
    string strBuff = "";
    string varBuff;

    while (!pfixFile.eof())
    {

        pfixFile >> varBuff;
        pfixFile >> strBuff;
        while (strBuff != "=" && !pfixFile.eof())
        {
            

            if (regex_match(strBuff, regexi))
            {
                mnemocodeFile << "LOAD " << strBuff << "\n";
            } 
            else if (regex_match(strBuff, regexd))
            {
                mnemocodeFile << "LIT " << strBuff << "\n";
            }
            else {
                switch (strBuff[0])
                {
                case '+':
                    mnemocodeFile << "ADD\n";
                    break;
                case '-':
                    mnemocodeFile << "SUB\n";
                    break;
                case '/':
                    mnemocodeFile << "DIV\n";
                    break;
                case '*':
                    mnemocodeFile << "MUL\n";
                    break;
                case '~':
                    mnemocodeFile << "NOT\n";
                    break;
                default:
                    cout << "[ERROR]\t\t" << "Lexical error: unexpected symbol: '" << strBuff << "'" << endl;
                    cout << "[DEBUG]\t\t" << "The postfix file was successfully closed" << endl;
                    cout << "[DEBUG]\t\t" << "The mnemocode file was successfully closed" << endl;
                    pfixFile.close();
                    mnemocodeFile.close();
                    return 1;
                }
            }

            pfixFile >> strBuff;
        }

        if (strBuff[0] == '=' && !pfixFile.eof())
        {
            mnemocodeFile << "STO " << varBuff << "\n";
        }
        else 
        {
            if (pfixFile.eof()) {
                pfixFile.close();
                mnemocodeFile.close();
                return 0;
            }

           
            cout << "[ERROR]\t\t" << "Lexical error: unexpected symbol: '" << strBuff << "'" << endl;
            cout << "[DEBUG]\t\t" << "The postfix file was successfully closed" << endl;
            cout << "[DEBUG]\t\t" << "The mnemocode file was successfully closed" << endl;
            pfixFile.close();
            mnemocodeFile.close();
            return 1;
        }
    }
}




int main()
{
    if (LexicalAnalysis()) return 1;
    else
        cout << "[RESULT]\t" << "Lexical analysis was successful" << endl;

    if (SyntaxAnalysis()) return 1;
    else
        cout << "[RESULT]\t" << "Syntax analysis was successful" << endl;
    
    buffPfixFile.close();
    cout << "[DEBUG]\t\t" << "The buffer postfix file was successfully closed" << endl;
    lexFile.close();
    cout << "[DEBUG]\t\t" << "The lexical file was successfully closed" << endl;

    if (MakeRPN()) return 1;
    else
        cout << "[RESULT]\t" << "The generation of reverse Polish notation was successful" << endl;
    if (GenerateMnemocode()) return 1;
    else
    {
        cout << "[RESULT]\t" << "The generation of mnemocode was successful" << endl;
    }
    cout << "\n\n\t\t\t" << "ALL OPERATIONS WAS SUCCESSFUL" << endl;
    return 0;
}