C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;


/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████

                        ██████  ██████   ██████   ██████  ██████   █████  ███    ███ 
                        ██   ██ ██   ██ ██    ██ ██       ██   ██ ██   ██ ████  ████ 
                        ██████  ██████  ██    ██ ██   ███ ██████  ███████ ██ ████ ██ 
                        ██      ██   ██ ██    ██ ██    ██ ██   ██ ██   ██ ██  ██  ██ 
                        ██      ██   ██  ██████   ██████  ██   ██ ██   ██ ██      ██ 
						
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */						                                                                                  
                                                                                     

public class Program
{
	public static int Main()
	{
DBG.Print_ON();	
//DBG.View_Call_Tree_ON();
//DBG.Colored_Console_ON();
		
//Console.Write("\n  OS");
DBG.ENTER("Main()");
		
		Parser Parser_Obj = new Parser();
		
		Parser_Obj.Parse("Example.cpp");
		
DBG.RETURN("");	
Console.Write("\n");
//Console.Write("  OS\n\n\n");
		
		return 58;
	}
}

/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████

                        ██████   █████  ██████  ███████ ███████ ██████  
                        ██   ██ ██   ██ ██   ██ ██      ██      ██   ██ 
                        ██████  ███████ ██████  ███████ █████   ██████  
                        ██      ██   ██ ██   ██      ██ ██      ██   ██ 
                        ██      ██   ██ ██   ██ ███████ ███████ ██   ██ 
                                                                                                                                                
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */


class Parser
{
	string FileName;
	
	Token[] Token_List;
	
 // IR_V0_View_Info                   IR = new IR_V0_View_Info();
 // IR_V1_Generete_DEPL               IR = new IR_V1_Generete_DEPL();
 //	IR_V2_Generete_CPP                IR = new IR_V2_Generete_CPP();
 // IR_V3_Generete_Destructured_DePL  IR = new IR_V3_Generete_Destructured_DePL();
 //	IR_V4_Generete_Destructured_CPP   IR = new IR_V4_Generete_Destructured_CPP();
	IR_V5_Generete_DOT                IR = new IR_V5_Generete_DOT();
	
	// ==========================================================
	public void Parse(string Src)
	{
DBG.ENTER("Parse(Srs = \"" + Src + "\")");
	
		FileName = Src;
		
		Generate_Tokens_List();
		
		Parse_Glb_Scope();

DBG.RETURN();
	}
	
	// ==========================================================
	void Generate_Tokens_List()
	{
DBG.ENTER("Generate_Tokens_List()");

//DBG.View_Call_Tree_OFF();
		
		// В строковую переменную, занести необходимый исходник
		string Src = Get_Src();
		
		Tokenizer T = new Tokenizer();		
		
		Token_List = T.Create_Token_List(Src);

//DBG.View_Call_Tree_ON();	
		
DBG.RETURN();
	}
	
	// =========================================================================
	static string Get_Src()
	{
DBG.ENTER("Get_Src()");
		
		string Src = Get_Src2();
		
			
DBG.Print("\n\n---------------------\n\n");
DBG.Print(Src);
		
DBG.RETURN();		
		return Src;
	}
	
	
	// =========================================================================
	static string Get_Src1()
	{
DBG.ENTER("Get_Src1()");
		
		string Src = "int main()\n" +
			         "{\n"          +
			         "    f1();\n"  +
			         "    f3(25);\n"+
					 "\n" +
					 "DBG.Print(\"No                      problem!!!\");\n"+
					 "};\n"+
			         "\n" +
			         "\n" +			
			 		 "void f1(void)\n" +
					 "{\n"             +
					 "    if(a == 2)\n"+
					 "        b = -3.18;\n"+
					 "};\n";
			
DBG.RETURN();		
		return Src;
	}
	
	
	// =========================================================================
	static string Get_Src2()
	{
DBG.ENTER("Get_Src2()");
		
		string Src = "int   Data_1;\n" +
			         "float Data_2;\n\n" +
			         "double Data_3 = 3;\n\n" + 
					 "int main(int a, int b, float X, double Y2)\n"+
					 "{\n" +
			         "    int a = 125;\n\n" +
			
                   //  "    for(int a = 10; a > 0; int a = a-1)\n" +
                   //  "    {\n" +
                   //  "        int a = 125;\n" +
                   //  "    };\n\n" +  
			//*
                     "    while(a > b)\n" +
                     "    {\n" +
                     "        int a = 125;\n" +
                     "        double b;\n" +
 
			         "   	  while(a > b)\n" +     // while in while
                     "        {\n" +
                     "            int x = 456;\n" +
                     "        };\n\n" + 
			
                     "    };\n\n" + 
			//*/
			
			//*
			         "    while(r > x)\n" +     
                     "    {\n" +
                     "        int x = 456;\n" +
                     "    };\n\n" + 			
			//*/
                     "    do\n" +
                     "    {\n" +
                     "        int a = 125;\n" +
                     "    } while(x > y);\n\n" + 

                     "\n    switch(a)\n"+
                     "    {\n" +

                     "     case 5: \n" +
                     "             int a;\n" + 
                     "             int b;\n" +
			         "\n" +
                     "             switch(z)\n"+
                     "             {\n" +

                     "             case 5: \n" +
                     "                      int a;\n" + 
                     "                      int b;\n" + 			
                     "                      break;\n" +
			         "             case 7: \n" +
                     "                      int c;\n" + 
                     "                      int d;\n" + 			
                     //"                   break;\n" +
	                 "             case 9: \n" +
                     "                     int e;\n" + 
                     //"                   break;\n" +
                     "             default:\n" +
                     "                   int f;\n" + 
                     //"                 int g;\n" + 				
	                // "                 break;\n" +

                     "            }\n\n" +			
			
                     "             break;\n" +
			         "     case 7: \n" +
                     "             int c;\n" + 
                     "             int d;\n" + 			
                     //"             break;\n" +
	                 "     case 9: \n" +
                     "             int e;\n" + 
                     //"             break;\n" +
                     "     default:\n" +
                     "             int f;\n" + 
                     //"             int g;\n" + 				
	                // "              break;\n" +

                     "    }\n\n" +


					 "    int    Data_A;\n" +
					 "    double Data_B = 25.45;\n\n" +	
					 "    if(x > y)\n" + 
			         "    {\n"+ 
					 "        if(x < y)\n" +
			         "        {\n" +  
			         "            int a = b;\n\n" +
			         "            if(a >= x)\n" + 
			         "                int x = 25;\n" + 
			         "            else\n" + 
			         "            {\n" +
			       //  "                int x = 41;\n" +
			         "            }\n"+
			         "        }\n" +
					 "        else\n" +
					 "            int a = c;\n\n" +
			         "    }\n"+
                     "    return 0;\n"+
					 "};\n\n" + 
					 "void f1(void)\n"+
			         "{\n"+
			         "    int a = 5;\n\n" +
				     "    goto Lb_1;\n" +
			         "    return;\n" +
			         " };"; 
		
DBG.RETURN();		
		return Src;
	}

	// ==========================================================
	void Parse_Glb_Scope()
	{
DBG.ENTER("Parse_Glb_Scope()");
	
		IR.START();
		
		while(true)
		{
            IR.Next_Sentence_in_global_scope();
			
			Token T = Get_Next_Token();
		
			if(T.Type == T_Type.EOF)
			{	
				DBG.RETURN("");
				
				return;
			}
					
			Parse_Sentence();
		}

//DBG.RETURN("");

	}
	
    int Index_Next_Token = 0; 

	// ==========================================================
	Token Get_Next_Token()
	{
DBG.ENTER("Get_Next_Token()");

		Token Ret = Token_List[Index_Next_Token];

        Index_Next_Token++;

//DBG.RETURN("");
DBG.RETURN("<- Type = " + Ret.Type + "; Value = \"" + Ret.Value + "\"");
		return Ret;
	}
	
    // ==========================================================
    void Back_Token()
    {
DBG.ENTER("Back_Token()");

        Index_Next_Token--;

DBG.RETURN("");
    }

	// ==========================================================
	void Parse_Sentence()
	{
DBG.ENTER("Parse_Sentence()");	
		
		// В Parse_Sentence(), вошли с одним "лишним" сдвигом индекса токенов
        // Откатываем назад совершенное ранее упреждающее чтение.
		Back_Token();
		
		Token T = Get_Next_Token();
		
		if     (T.Type  == T_Type.BuildInType)    Parse_Sentence_Type();    // Предложение, которое начинается с типа
		else if(T.Type  == T_Type.ControlKeyWord) Parse_Sentence_Control(); // Предложение, которое начинается с управляющей конструкции
		else if(T.Value == "class")               Parse_Sentence_Class();   // Предложение, которое начинается с ключевого слова "class"
		else if(T.Value == "struct")              Parse_Sentence_Struct();  // Предложение, которое начинается с ключевого слова "struct"
        else if(T.Value == "{")                   Parse_Block();            // Парсим блок
		else 
			DBG.Src_ERROR_TRAP("Undef type of Sentence - Token.Type = " + T.Type + "; Token.Value =" + T.Value);
		
DBG.RETURN("");
	}


    void Parse_Block()
    {
DBG.ENTER("Parse_Block()");

		// Предвыбрать один токен
		Token T = Get_Next_Token();
		
		// Проверка на пустой блок кода
        if(T.Value == "}") 
			return;

        do
        {
            Parse_Sentence();

            T = Get_Next_Token();
        }while(T.Value != "}");

DBG.RETURN(""); 
    }

	
	// ==========================================================
	void Parse_Sentence_Type()
	{
DBG.ENTER("Parse_Sentence_Type()");

		Token T = Get_Next_Token(); // reading Id
		
		T = Get_Next_Token();
		
		switch(T.Value)
		{
			case ";": Parse_Var();               break;
			case "=": Parse_Var_w_Init();        break;
			case "(": Parse_Definite_Function(); break;
			default: 
				DBG.Src_ERROR_TRAP("ERROR in Parse_Sentence_Type()"); break;
		}
		
DBG.RETURN("");
	}
	
    // ==========================================================
	void Parse_Sentence_Control()
	{
DBG.ENTER("Parse_Sentence_Control()");

        // В Parse_Sentence_Control(), вошли с одним "лишним" сдвигом индекса токенов
        // Откатываем назад совершенное ранее упреждающее чтение.
		Back_Token();

		Token T = Get_Next_Token();	
		
		switch(T.Value)
		{
			case "if":     Parse_Control_IF();     break;
			case "goto":   Parse_Control_GOTO();   break;
			case "return": Parse_Control_RETURN(); break;
			case "switch": Parse_Control_SWITCH(); break;
            case "do":     Parse_Control_DO();     break;
            case "while":  Parse_Control_WHILE();  break;
            case "for":    Parse_Control_FOR();    break;
			default: 
				DBG.Src_ERROR_TRAP("ERROR in Parse_Sentence_Control()"); break;
		}
		
DBG.RETURN("");
	}

    // ======================================================================================
    void Parse_Control_IF()
    {
DBG.ENTER("Parse_Control_IF()");

        Token T1 = Get_Next_Token();
        Token T2 = Get_Next_Token();
        Token T3 = Get_Next_Token();
        Token T4 = Get_Next_Token();
        Token T5 = Get_Next_Token();

		IR.CMD_IF(T2.Value, T3.Value, T4.Value);
      
		Get_Next_Token(); // предвыборка одного токена
		Parse_Sentence();
		
		// Проверка на else
		Token T6 = Get_Next_Token();
		
		if(T6.Value == "else")
		{
			IR.CMD_ELSE();
			
			Get_Next_Token(); // предвыборка одного токена
			Parse_Sentence();			
		}
		else
			Back_Token();
		
		
		IR.CMD_IF_END();

    DBG.RETURN("");
    }

	// ==========================================================
	void Parse_Control_GOTO()
	{
DBG.ENTER("Parse_Control_GOTO()");	

		Token T1 = Get_Next_Token(); // Label
        Token T2 = Get_Next_Token(); // ;
		
        IR.GOTO(T1.Value);		
		
DBG.RETURN("");		
	}
	
		// ==========================================================
	void Parse_Control_RETURN()
	{
DBG.ENTER("Parse_Control_RETURN()");	

        Token T1 = Get_Next_Token();
		
        if(T1.Value == ";") // варинт - "return;"
        {
			IR.RETURN_VOID();
        }
        else               // вариант - "return value;"
        {
            Token T2 = Get_Next_Token();

            IR.RETURN_w_Value(T1.Value);
        }		
		
DBG.RETURN("");		
	}
		
	// ======================================================================================
    void Parse_Control_SWITCH()
    {
DBG.ENTER("Parse_Control_SWITCH()");

                  Get_Next_Token(); // (
        Token T = Get_Next_Token(); // value
                  Get_Next_Token(); // )
                  Get_Next_Token(); // {
        
		IR.CMD_SWITCH_START(T.Value);
		

        // Проверка на пустой switch
        T = Get_Next_Token();
        if(T.Value == "}")
            DBG.Src_ERROR_TRAP("ERROR in Parse_Control_SWITCH() - free switch");

        Back_Token();

        // Перебор всех веток
        while(true)
        {
            T = Get_Next_Token();
            
            if(T.Value == "case")
            {
                T = Get_Next_Token(); // значение case-ветки
                
                IR.SWITCH_CASE(T.Value);
                
                Get_Next_Token(); // пропуск двоеточия

                // Цикл выборки предложений в текущей case-ветке 
                while(true)
                {
                    T = Get_Next_Token();

                    // Если текущая ветка окончена
                    if(T.Value == "case" || T.Value == "default" || T.Value == "}")
                    {
                       Back_Token();

                       break; // Вернуться в цикл выборки case-веток 
                    }

                    if(T.Value == "break")
					{
                        IR.BREAK_IN_SWITCH();
						
						Get_Next_Token(); // пропуск точки с запятой, который после break
					}
                    else
                        Parse_Sentence();
                }
            }
            else if(T.Value == "default")
            {
                IR.SWITCH_DEFAULT();

                Get_Next_Token(); // пропуск двоеточия
                
                // Цикл выборки предложений в текущей default-ветке 
                while(true)
                {
                    T = Get_Next_Token();

                    // Если текущая ветка окончена
                    if(T.Value == "}")
                    {
                       Back_Token();

                       break; // Вернуться в цикл выборки case-веток 
                    }

                    // Проверка синтаксических недопустимостей
                    if(T.Value == "case")
                        DBG.Src_ERROR_TRAP("ERROR in Parse_Control_SWITCH() - \"case\", after \"default\"");

                    if(T.Value == "default")
                        DBG.Src_ERROR_TRAP("ERROR in Parse_Control_SWITCH() - \"default\", after \"default\"");

                    // Корректный код
                    if(T.Value == "break")
					{
                        IR.BREAK_IN_SWITCH();
						
						Get_Next_Token(); // пропуск точки с запятой, который после break
					}
                    else
                        Parse_Sentence();
                }
                
            }
            else if(T.Value == "}")
            {
                IR.SWITCH_END();

                break; // Прервать цикр перебора веток 	
            }
            else
            {
                DBG.Src_ERROR_TRAP("ERROR in Parse_Control_SWITCH()");  
            }
		
        } // while(true) - Перебор всех веток
			

DBG.RETURN("");
    }
	
	// ==========================================================
	void Parse_Control_DO()
    {
        IR.DO_START();

       Get_Next_Token(); // Предвыборка одного токена
       Parse_Sentence();

                        Get_Next_Token(); // вычитать while
                        Get_Next_Token(); // вычитать (
        Token Op1     = Get_Next_Token(); // вычитать первый операнд
        Token CmpSign = Get_Next_Token(); // вычитать операцию сравнения
        Token Op2     = Get_Next_Token(); // вычитать второй операнд
                        Get_Next_Token(); // вычитать )
                        Get_Next_Token(); // вычитать ;

        IR.DO_END(Op1.Value, CmpSign.Value, Op2.Value);

    }

	// ==========================================================
	void Parse_Control_WHILE()
    {
                        Get_Next_Token(); // вычитать (
        Token Op1     = Get_Next_Token(); // вычитать первый операнд
        Token CmpSign = Get_Next_Token(); // вычитать операцию сравнения
        Token Op2     = Get_Next_Token(); // вычитать второй операнд
                        Get_Next_Token(); // вычитать )

        IR.WHILE_START(Op1.Value, CmpSign.Value, Op2.Value);

        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence();

        IR.WHILE_END();

        Get_Next_Token(); // вычитать ;
    }

    // ==========================================================
	// Костыль
	void Parse_Control_FOR()
    {
        if(IR.GetType().Name == "IR_V2_Generete_CPP")
            Parse_Control_FOR_V2();
        else
            Parse_Control_FOR_destructured();
    }

	// ==========================================================
    // Версия только для IR_V2_Generete_CPP
	void Parse_Control_FOR_V2()
    {
        Get_Next_Token(); // вычитать (

        DBG.Print("\n\n// FOR-loop START ---------------------");
        DBG.Print("\n{  // isolate variables\n");
        
        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence();

        Token Op1     = Get_Next_Token(); // вычитать первый операнд
        Token CmpSign = Get_Next_Token(); // вычитать операцию сравнения
        Token Op2     = Get_Next_Token(); // вычитать второй операнд 
                        Get_Next_Token(); // вычитать ;

       IR.WHILE_START(Op1.Value, CmpSign.Value, Op2.Value);

       // Запомнить текущий указатель токена
       int TMP1 = Index_Next_Token;

        // проскочить третий параметр for-цикла

       Token T;

       do
       {
           T = Get_Next_Token();
       }while(T.Value != ")");


        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence(); // Тело цикла

       // Запомнить текущий указатель токена
       int TMP2 = Index_Next_Token;

       Index_Next_Token = TMP1;

        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence(); // Тело цикла

        
        Index_Next_Token = TMP2;

        IR.WHILE_END();

        DBG.Print("\n}");
        DBG.Print("\n// FOR-loop END ---------------------");

        Get_Next_Token(); // вычитать ;             
    }


	// ==========================================================
	void Parse_Control_FOR_destructured()
    {
        Get_Next_Token(); // вычитать (

        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence();

        Token Op1     = Get_Next_Token(); // вычитать первый операнд
        Token CmpSign = Get_Next_Token(); // вычитать операцию сравнения
        Token Op2     = Get_Next_Token(); // вычитать второй операнд 
                        Get_Next_Token(); // вычитать ;

       IR.FOR_START(Op1.Value, CmpSign.Value, Op2.Value);

       // Запомнить текущий указатель токена
       int TMP1 = Index_Next_Token;

        // проскочить третий параметр for-цикла

       Token T;

       do
       {
           T = Get_Next_Token();
       }while(T.Value != ")");

        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence(); // Тело цикла

       // Запомнить текущий указатель токена
       int TMP2 = Index_Next_Token;

       Index_Next_Token = TMP1;

        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence(); // Тело цикла

        
        Index_Next_Token = TMP2;

        IR.FOR_END();

        Get_Next_Token(); // вычитать ;

    }

	// ==========================================================
	void Parse_Sentence_Class()
	{
DBG.ENTER("Parse_Sentence_Class()");


		
DBG.RETURN("");
	}
	
	// ==========================================================
	void Parse_Sentence_Struct()
	{
DBG.ENTER("Parse_Sentence_Struct()");

		
DBG.RETURN("");
	}
	
	// ==========================================================
	void Parse_Var()
	{
DBG.ENTER("Parse_Var()");

		// В Parse_Var(), вошли с тремя "лишним" предпросмотрами токенов
		Back_Token();
		Back_Token();
		Back_Token();

		Token Var_Type = Get_Next_Token();
		Token Var_Name = Get_Next_Token();
		
		// Send to Intermediate Representation
		IR.Def_Variable(Var_Type.Value, Var_Name.Value);
		
		Get_Next_Token();
		
DBG.RETURN("");
	}
	
	// ==========================================================
	void Parse_Var_w_Init()
	{
DBG.ENTER("Parse_Var_w_Init()");

		// В Parse_Var_w_Init(), вошли с тремя "лишним" предпросмотрами токенов
		Back_Token();
		Back_Token();
		Back_Token();
		
		Token Var_Type = Get_Next_Token();
		Token Var_Name = Get_Next_Token();
		
		Get_Next_Token();
		
		Token Var_Init_Value = Get_Next_Token();
		
		Get_Next_Token();
		
		// Send to Intermediate Representation
		IR.Def_Variable(Var_Type.Value, Var_Name.Value, Var_Init_Value.Value);
		
		
DBG.RETURN("");
	}
	
	// ==========================================================
	void Parse_Definite_Function()
	{
DBG.ENTER("Parse_Definite_Function()");

		// В Parse_Definite_Function(), вошли с тремя "лишним" сдвигами индекса токенов
		Back_Token();
		Back_Token();
		Back_Token();
		
		Token Ret_Type  = Get_Next_Token();
		Token Func_Name = Get_Next_Token();
		
		Get_Next_Token(); // опять вычитать "("
		
		IR.Define_Function_START(Func_Name.Value, Ret_Type.Value);
		
		Parse_Arg_List();
		Parse_in_Function_Body();
		
		IR.Def_Function_END();
		
DBG.RETURN("");
	}
	
	// ==========================================================
	void Parse_Arg_List()
	{
DBG.ENTER("Parse_Arg_List()");
		
		Token T =  Get_Next_Token();
		
		// Если у функции нет параметров
		if(T.Value == "void")
		{
			Get_Next_Token();
			
			//DBG.Print("\n\nArgList is void");
		}
		else
		{
			Back_Token();
			
			do
			{
				Token Param_Type = Get_Next_Token(); 
				Token Param_Name = Get_Next_Token(); 

				
				IR.Function_NextArg(Param_Name.Value,  Param_Type.Value);

				T = Get_Next_Token(); 
			}	
			while(T.Value == ",");
		}
		
		IR.Function_ArgList_END();
						
DBG.RETURN("");
	}
	
	//  ==========================================================
	void Parse_in_Function_Body()
	{
DBG.ENTER("Parse_in_Function_Body()");

		Get_Next_Token(); // вычитать "{"

		while(true)
		{
			Token T = Get_Next_Token(); // Вычитать следующий токен
		
			if(T.Value == "}")
				break;
			
			Parse_Sentence();
		}
		
		
		Get_Next_Token(); // вычитать ";"
		
		//DBG.Print("\n\nParse_Function_Body() ==> body is empty\n");
		
DBG.RETURN("");
	}
}

/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████

                ██ ██████         ██    ██  ██████          ██ ███    ██ ███████  ██████  
                ██ ██   ██        ██    ██ ██  ████         ██ ████   ██ ██      ██    ██ 
                ██ ██████         ██    ██ ██ ██ ██         ██ ██ ██  ██ █████   ██    ██ 
                ██ ██   ██         ██  ██  ████  ██         ██ ██  ██ ██ ██      ██    ██ 
                ██ ██   ██ ███████  ████    ██████  ███████ ██ ██   ████ ██       ██████  
                                                                                                                                                                                                                                                           
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */

class IR_V0_View_Info
{
	// string ResultStr;
	
	// ===================================================================================
    public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V0.Next_Sentence_in_global_scope()");
    
        DBG.Print("\n\nNext sentence in GLOBAL SCOPE\n", ConsoleColor.Yellow);

	DBG.RETURN("");
    }

	// ===================================================================================
	public void Def_Variable(string Type, string Name)
	{
	DBG.ENTER("IR_V0.Def_Variable(T, N)");
		
		DBG.Print("\n\nParse_Var()\n");
		DBG.Print("\n  Type = " + Type);
		DBG.Print("\n  Name = \"" + Name + "\"\n");
		
	DBG.RETURN("");
	}

	// ===================================================================================
	public void Def_Variable(string Type, string Name, string InitValue)
	{
	DBG.ENTER("IR_V0.Def_Variable(T, N, V)");
		
        DBG.Print("\n\nParse_Var_w_Init()\n");
		DBG.Print("\n  Type       = "   + Type);
		DBG.Print("\n  Name       = \"" + Name + "\"");
		DBG.Print("\n  Init_Value = "   + InitValue + "\n");
		
	DBG.RETURN("");
	} 
// -------
	// ===================================================================================
	public void CMD_IF(string Op1, string Sign, string Op2)
	{
 		DBG.Print("\n\n\nIF start\n");
		DBG.Print("\n  Cond = " + Op1 + Sign + Op2);		
	}
	
	// ===================================================================================
	public void CMD_ELSE()
	{
		DBG.Print("\n\n\nELSE-branch\n");
	}
	
	// ===================================================================================
	public void CMD_IF_END()
	{
		DBG.Print("\nIF end\n");
	}
	
	// ===================================================================================
	public void GOTO(string Lb_Name)
	{
		DBG.Print("\ngoto " + Lb_Name + ";");
	}
	
	// ===================================================================================
	public void RETURN_VOID()
	{
		DBG.Print("\nreturn;");
	}
	
	// ===================================================================================
	public void RETURN_w_Value(string Value)
	{
		DBG.Print("\nreturn " + Value + ";");
	}
	
	int Param_Cnt;
	
	// ===================================================================================
	public void Define_Function_START(string Func_Name, string Ret_Type)
	{
		DBG.Print("\n\nParse_Definite_Function()");
		DBG.Print("\n  Ret_Type  = " + Ret_Type);
		DBG.Print("\n  Func_Name = " + Func_Name + "\n");
		
		Param_Cnt = 1;
	}
	
	// ===================================================================================
	public void Def_Function_END()
	{
		DBG.Print("\nFunction definit is end");
	}	
	
	// ===================================================================================
	public void Function_NextArg(string Param_Name,  string Param_Type)
	{	
		DBG.Print("\n\nParam #"+ Param_Cnt + ":");
		DBG.Print("\n   Type = " + Param_Type); 
		DBG.Print("\n   Name = \"" + Param_Name + "\"\n");
		
		Param_Cnt++;
	}
	
	// ===================================================================================
	public void Function_ArgList_END()
	{
		DBG.Print("\nArgList is end");		
	}
	
	
	// ===================================================================================
	public void CMD_SWITCH_START(string SwitchValue)
	{
		DBG.Print("\nCMD_SWITCH_START, Param = " + SwitchValue);	
	}
	
	// ===================================================================================
	public void SWITCH_CASE(string CaseValue)
	{
		DBG.Print("\nSWITCH_CASE, Param = " + CaseValue);	
	}
	
	// ===================================================================================
	public void BREAK_IN_SWITCH()
	{
		DBG.Print("\nBREAK_IN_SWITCH");	
	}
	
	// ===================================================================================
	public void SWITCH_DEFAULT()
	{
		DBG.Print("\nSWITCH_DEFAULT");	
	}
	
	// ===================================================================================
	public void SWITCH_END()
	{
		DBG.Print("\nSWITCH_END");	
	}	
}

/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████

                ██ ██████         ██    ██  ██         ██████  ███████ ██████  ██      
                ██ ██   ██        ██    ██ ███         ██   ██ ██      ██   ██ ██      
                ██ ██████         ██    ██  ██         ██   ██ █████   ██████  ██      
                ██ ██   ██         ██  ██   ██         ██   ██ ██      ██      ██      
                ██ ██   ██ ███████  ████    ██ ███████ ██████  ███████ ██      ███████ 
                                                                                                                                                                                                                                                                                                                                                                           
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */

class IR_V1_Generete_DEPL
{
	//string ResultStr;
		
	// ===================================================================================
	public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V1.Next_Sentence_in_global_scope()");
    

	// ===================================================================================	
	DBG.RETURN("");
    }
	
	int TabLevel = 0;
	
	// ===================================================================================
	string TabSpaser()
	{
		string Str = "";
		
		for(int i = 0; i < TabLevel; i++)
			Str += "│   "; // · | │
		
		return Str;
	}
	
	// ===================================================================================
	public void Def_Variable(string Type, string Name)
	{
	DBG.ENTER("IR_V1.Def_Variable(T, N)");
		
		DBG.Print("\n" + TabSpaser() + Name + " " + ConvertType(Type));
		
	DBG.RETURN("");
	}

	// ===================================================================================
	public void Def_Variable(string Type, string Name, string InitValue)
	{
	DBG.ENTER("IR_V1.Def_Variable(T, N, V)");
				
		if(Type == "double" || Type == "float")
		{
			// Задано целое значение, то привести его к виду с точкой, 
			// иначе DePL сгенерирует неверный тип для переменной (int вместо double)
			if(InitValue.Contains('.') == false)
				InitValue = InitValue + ".0";				
		}	
		
		DBG.Print("\n" + TabSpaser() + Name + " = " + InitValue);
		
	DBG.RETURN("");
	} 
	
	bool First_Arg;
	
	string RT;
	
	// ===================================================================================
	public void Define_Function_START(string FuncName, string RetutnType)
	{
	DBG.ENTER("IR_V1.Define_Function_START()");
		
		DBG.Print("\n\n\n");
		DBG.Print(TabSpaser() + "ФУНКЦІЯ " + FuncName + "(");
		
        // Запомнить тип. Он будет использован позже
		RT = RetutnType;
		
		First_Arg = true;
		
		TabLevel++;
		
	DBG.RETURN("");		
	}
	
	// ===================================================================================
	public void Function_NextArg(string Param_Name,  string Param_Type)
	{
	DBG.ENTER("IR_V1.Function_NextArg()");
		
		if(First_Arg == true)
			DBG.Print(Param_Name + " " + ConvertType(Param_Type)); // без запятой перед параметром
		else
		{
	     // DBG.Print(", " + Param_Name + " " + ConvertType(Param_Type)); // версия в одну строку
			DBG.Print(", " + Param_Name + " " + ConvertType(Param_Type)); // версия в много строк
		}
		
		First_Arg = false;
		
	DBG.RETURN("");	
	}
	
	// ===================================================================================
	public void Function_ArgList_END()
	{
DBG.ENTER("IR_V1.Function_ArgList_END()");
		
		string Type_in_DePL = ConvertType(RT);
        
        DBG.Print(") " + Type_in_DePL);
		
		DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void Def_Function_END()
	{
DBG.ENTER("IR_V1.Def_Function_END()");
		
		DBG.Print("\n" + TabSpaser());
		
		TabLevel--;		

		DBG.Print("\n" + TabSpaser() + "ФІНІШ");	
		

		
DBG.RETURN("");
	}	
	
	// ===================================================================================
	public void RETURN_w_Value(string Value)
	{
DBG.ENTER("IR_V1.RETURN_w_Value()");		
		
		DBG.Print("\n" + TabSpaser() + "ВЕРНУТИСЬ " + Value);
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void RETURN_VOID()
	{
DBG.ENTER("IR_V1.RETURN_VOID()");	
		
		DBG.Print("\n" + TabSpaser() + "ВЕРНУТИСЬ");
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void GOTO(string Lb_Name)
	{
DBG.ENTER("IR_V1.GOTO()");	
		
		DBG.Print("\n --------------------- PROBLEM!!! ---------------------------");
		DBG.Print("\n -------------- DePL not supported \"goto\" -------------------");
		
DBG.RETURN("");
	}

	// ===================================================================================
	public void CMD_IF(string Op1, string CmpSign, string Op2)
	{
DBG.ENTER("IR_V1.CMD_IF()");
		
		DBG.Print("\n" + TabSpaser());
		DBG.Print("\n" + TabSpaser() + "ЯКЩО " + Op1 + " " + CmpSign + " " + Op2);
		
		TabLevel++;
		
		DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void CMD_ELSE()
	{
DBG.ENTER("IR_V1.CMD_ELSE()");		
		

		DBG.Print("\n" + TabSpaser());
		
		TabLevel--;

		DBG.Print("\n" + TabSpaser() + "ІНАКШЕ");
		
		TabLevel++;
		
		DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void CMD_IF_END()
	{
DBG.ENTER("IR_V1.CMD_IF_END()");	
		
		
		DBG.Print("\n" + TabSpaser());
		
		TabLevel--;
		DBG.Print("\n" + TabSpaser() + "КІНЕЦЬ");
		DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
	
	// ===================================================================================
	string ConvertType(string type)
	{
	DBG.ENTER("IR_V1.ConvertType()");
	DBG.RETURN("");
	
		switch(type)
		{
			case "void"  : return "void"; 
			case "int"   : return "int";
			case "float" : return "double";
			case "double": return "double";
			default:       return "?";
		}	
	}
	
	// ===================================================================================
	public void CMD_SWITCH_START(string SwitchValue)
	{
		DBG.Print("\n" + TabSpaser() + "ПЕРЕМИКАЧ " + SwitchValue);	
		
		TabLevel++;
		TabLevel++;
	}
	
	// ===================================================================================
	public void SWITCH_CASE(string CaseValue)
	{
		TabLevel--;		
		
		DBG.Print("\n" + TabSpaser() + "ВАРIАНТ " + CaseValue);	
		
		TabLevel++;
	}
	
	// ===================================================================================
	public void BREAK_IN_SWITCH()
	{
		DBG.Print("\n" + TabSpaser() + "BREAK");
	}
	
	// ===================================================================================
	public void SWITCH_DEFAULT()
	{
		TabLevel--;
		
		DBG.Print("\n" + TabSpaser() + "IНШЕ");	
		
		TabLevel++;
	}
	
	// ===================================================================================
	public void SWITCH_END()
	{
		TabLevel--;
		TabLevel--;
		
		DBG.Print("\n" + TabSpaser() + "КIНЕЦЬ\n");	
	}	
}


/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████

                ██ ██████         ██    ██ ██████           ██████ ██████  ██████  
                ██ ██   ██        ██    ██      ██         ██      ██   ██ ██   ██ 
                ██ ██████         ██    ██  █████          ██      ██████  ██████  
                ██ ██   ██         ██  ██  ██              ██      ██      ██      
                ██ ██   ██ ███████  ████   ███████ ███████  ██████ ██      ██                                                                                                                                                                                                                                                                                                                                                 
                                                                                                                                                                                                                            
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */

class IR_V2_Generete_CPP
{
	// string ResultStr;
		
	// ===================================================================================
	public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V2.Next_Sentence_in_global_scope()");
    

	// ===================================================================================	
	DBG.RETURN("");
    }
	
	int TabLevel = 0;
	
	// ===================================================================================
	string TabSpaser()
	{
		string Str = "";
		
		for(int i = 0; i < TabLevel; i++)
			Str += "    "; // · | │
		
		return Str;
	}
	
	// ===================================================================================
	public void Def_Variable(string Type, string Name)
	{
	DBG.ENTER("IR_V2.Def_Variable(T, N)");
		
		DBG.Print("\n" + TabSpaser() + Type + " " + Name + ";");
		
	DBG.RETURN("");
	}

	// ===================================================================================
	public void Def_Variable(string Type, string Name, string InitValue)
	{
	DBG.ENTER("IR_V2.Def_Variable(T, N, V)");
				
	
		DBG.Print("\n" + TabSpaser() + Type + " " + Name + " = " + InitValue + ";");
		
	DBG.RETURN("");
	} 
	
	bool First_Arg;
	
	
	// ===================================================================================
	public void Define_Function_START(string FuncName, string RetutnType)
	{
	DBG.ENTER("IR_V1.Define_Function_START()");
		
		DBG.Print("\n\n\n");
		DBG.Print(TabSpaser() + RetutnType + " " + FuncName + "(");
		
		
		First_Arg = true;
		
		TabLevel++;
		
	DBG.RETURN("");		
	}
	
	// ===================================================================================
	public void Function_NextArg(string Param_Name,  string Param_Type)
	{
	DBG.ENTER("IR_V1.Function_NextArg()");
		
		if(First_Arg == true)
			DBG.Print(Param_Type + " " + Param_Name); // без запятой перед параметром
		else
			DBG.Print(", " + Param_Type + " " + Param_Name); // версия в много строк
		
		First_Arg = false;
		
	DBG.RETURN("");	
	}
	
	// ===================================================================================
	public void Function_ArgList_END()
	{
DBG.ENTER("IR_V1.Function_ArgList_END()");
        
		// Если нет ни одного аргумента
		if(First_Arg == true)
		 	DBG.Print("void");
		
        DBG.Print(")\n{" + TabSpaser());
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void Def_Function_END()
	{
DBG.ENTER("IR_V1.Def_Function_END()");
		
		
		TabLevel--;		

		DBG.Print("\n" + TabSpaser() + "}");	
		

		
DBG.RETURN("");
	}	
	
	// ===================================================================================
	public void RETURN_w_Value(string Value)
	{
DBG.ENTER("IR_V1.RETURN_w_Value()");		
		
		DBG.Print("\n" + TabSpaser() + "return " + Value + ";");
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void RETURN_VOID()
	{
DBG.ENTER("IR_V1.RETURN_VOID()");	
		
		DBG.Print("\n" + TabSpaser() + "return;");
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void GOTO(string Lb_Name)
	{
DBG.ENTER("IR_V1.GOTO()");	
		
		DBG.Print("\n" + TabSpaser() + "goto " + Lb_Name + ";");
		
DBG.RETURN("");
	}

	// ===================================================================================
	public void CMD_IF(string Op1, string CmpSign, string Op2)
	{
DBG.ENTER("IR_V1.CMD_IF()");
		
		DBG.Print("\n" + TabSpaser());
		DBG.Print("\n" + TabSpaser() + "if(" + Op1 + " " + CmpSign + " " + Op2 + ")");
		
		DBG.Print("\n" + TabSpaser() + "{");
		
		TabLevel++;
		

		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void CMD_ELSE()
	{
DBG.ENTER("IR_V1.CMD_ELSE()");		
		

		//DBG.Print("\n" + TabSpaser());
		
		TabLevel--;

		DBG.Print("\n" + TabSpaser() + "}");
		
		DBG.Print("\n" + TabSpaser() + "else");
		
		DBG.Print("\n" + TabSpaser() + "{");
		
		TabLevel++;
		
		//DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void CMD_IF_END()
	{
DBG.ENTER("IR_V1.CMD_IF_END()");	
		
		
	
		TabLevel--;
		DBG.Print("\n" + TabSpaser() + "}");
		DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
		// ===================================================================================
	public void CMD_SWITCH_START(string SwitchValue)
	{
		DBG.Print("\n\n" + TabSpaser() + "switch(" + SwitchValue + ")\n"+ TabSpaser() + "{");	
		
		TabLevel++;
		TabLevel++;
	}
	
	// ===================================================================================
	public void SWITCH_CASE(string CaseValue)
	{
		TabLevel--;		
		
		DBG.Print("\n" + TabSpaser() + "case " + CaseValue + ":");	
		
		TabLevel++;
	}
	
	// ===================================================================================
	public void BREAK_IN_SWITCH()
	{
		DBG.Print("\n" + TabSpaser() + "break;");
	}
	
	// ===================================================================================
	public void SWITCH_DEFAULT()
	{
		TabLevel--;
		
		DBG.Print("\n" + TabSpaser() + "default:");	
		
		TabLevel++;
	}
	
	// ===================================================================================
	public void SWITCH_END()
	{
		TabLevel--;
		TabLevel--;
		
		DBG.Print("\n" + TabSpaser() + "}\n");	
	}	

    // ===================================================================================
	public void DO_START()
    {
        DBG.Print("\n\n" + TabSpaser() + "do\n" + TabSpaser() + "{");
		
		TabLevel++;

    }

    // ===================================================================================
	public void DO_END(string Op1, string CmpSign, string Op2)
    {
		TabLevel--;
		
		DBG.Print("\n" + TabSpaser() + "}while(" + Op1 + " " + CmpSign + " " + Op2 + ");");	
    }

    // ===================================================================================
	public void WHILE_START(string Op1, string CmpSign, string Op2)
    {
		DBG.Print("\n\n" + TabSpaser() + "while(" + Op1 + " " + CmpSign + " " + Op2 + ")\n" + TabSpaser() + "{");
		
		TabLevel++;
    }

    // ===================================================================================
	public void WHILE_END()
    {
		TabLevel--;
		
	 	DBG.Print("\n" + TabSpaser() + "};");
    }

    // ===================================================================================
	public void FOR_START(string Op1, string CmpSign, string Op2)
    {
    }

    // ===================================================================================
	public void FOR_END()
    {

    }
		
}

/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████

                ██ ██████         ██    ██ ██████          ██████          ██████  ███████ ██████  ██      
                ██ ██   ██        ██    ██      ██         ██   ██         ██   ██ ██      ██   ██ ██      
                ██ ██████         ██    ██  █████          ██   ██         ██   ██ █████   ██████  ██      
                ██ ██   ██         ██  ██       ██         ██   ██         ██   ██ ██      ██      ██      
                ██ ██   ██ ███████  ████   ██████  ███████ ██████  ███████ ██████  ███████ ██      ███████                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                            
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */

class IR_V3_Generete_Destructured_DePL
{
	// string ResultStr;
		
	// ===================================================================================
	public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V1.Next_Sentence_in_global_scope()");
    

	// ===================================================================================	
	DBG.RETURN("");
    }
	
	int TabLevel = 0;
	
	// ===================================================================================
	string TabSpaser()
	{
		string Str = "";
			
		//for(int i = 0; i < TabLevel; i++)
		//	Str += "    "; // · | │		
		
		return Str;
	}
	
	// ===================================================================================
	public void Def_Variable(string Type, string Name)
	{
	DBG.ENTER("IR_V1.Def_Variable(T, N)");
		
		DBG.Print("\n" + TabSpaser() + Name + " " + ConvertType(Type));
		
	DBG.RETURN("");
	}

	// ===================================================================================
	public void Def_Variable(string Type, string Name, string InitValue)
	{
	DBG.ENTER("IR_V1.Def_Variable(T, N, V)");
				
		if(Type == "double" || Type == "float")
		{
			// Задано целое значение, то привести его к виду с точкой, 
			// иначе DePL сгенерирует неверный тип для переменной (int вместо double)
			if(InitValue.Contains('.') == false)
				InitValue = InitValue + ".0";				
		}	
		
		DBG.Print("\n" + TabSpaser() + Name + " = " + InitValue);
		
	DBG.RETURN("");
	} 
	
	bool First_Arg;
	
	string RT;
	
	// ===================================================================================
	public void Define_Function_START(string FuncName, string RetutnType)
	{
	DBG.ENTER("IR_V1.Define_Function_START()");
		
		DBG.Print("\n\n\n");
		DBG.Print(TabSpaser() + "ФУНКЦІЯ " + FuncName + "(");
		
        // Запомнить тип. Он будет использован позже
		RT = RetutnType;
		
		First_Arg = true;
		
		TabLevel++;
		
	DBG.RETURN("");		
	}
	
	// ===================================================================================
	public void Function_NextArg(string Param_Name,  string Param_Type)
	{
	DBG.ENTER("IR_V1.Function_NextArg()");
		
		if(First_Arg == true)
			DBG.Print(Param_Name + " " + ConvertType(Param_Type)); // без запятой перед параметром
		else
		{
	     // DBG.Print(", " + Param_Name + " " + ConvertType(Param_Type)); // версия в одну строку
			DBG.Print(", " + Param_Name + " " + ConvertType(Param_Type)); // версия в много строк
		}
		
		First_Arg = false;
		
	DBG.RETURN("");	
	}
	
	// ===================================================================================
	public void Function_ArgList_END()
	{
DBG.ENTER("IR_V1.Function_ArgList_END()");
		
		string Type_in_DePL = ConvertType(RT);
        
        DBG.Print(") " + Type_in_DePL);
		
		//DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void Def_Function_END()
	{
DBG.ENTER("IR_V1.Def_Function_END()");
		
		//DBG.Print("\n" + TabSpaser());
		
		TabLevel--;		

		DBG.Print("\n" + TabSpaser() + "ФІНІШ");	
		

		
DBG.RETURN("");
	}	
	
	// ===================================================================================
	public void RETURN_w_Value(string Value)
	{
DBG.ENTER("IR_V1.RETURN_w_Value()");		
		
		DBG.Print("\n" + TabSpaser() + "ВЕРНУТИСЬ " + Value);
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void RETURN_VOID()
	{
DBG.ENTER("IR_V1.RETURN_VOID()");	
		
		DBG.Print("\n" + TabSpaser() + "ВЕРНУТИСЬ");
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void GOTO(string Lb_Name)
	{
DBG.ENTER("IR_V1.GOTO()");	
		
		DBG.Print("\n --------------------- PROBLEM!!! ---------------------------");
		DBG.Print("\n -------------- DePL not supported \"goto\" -------------------");
		
DBG.RETURN("");
	}

	string[] LB = new string[1000];
	
	int Curr_IF_Level = 0;
	
	// ===================================================================================
	public void CMD_IF(string Op1, string CmpSign, string Op2)
	{
DBG.ENTER("IR_V1.CMD_IF()");
		
		LB[Curr_IF_Level] = Gen_Label_Name();
		
		//DBG.Print("\n" + TabSpaser());
		DBG.Print("\n" + TabSpaser() + "ЯКЩО " + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + " СТРИБНУТИ_НА " + LB[Curr_IF_Level]);
		
		Curr_IF_Level++;
		
		TabLevel++;
		
		//DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}

    // ===================================================================================
    string Inverse_CMP(string CMP)
    {
        switch(CMP)
        {
            case ">":  return "⩽";
            case "<":  return "⩾";
            case "==": return "≠";
            case "!=": return "=";
            case ">=": return "<";
            case "<=": return ">"; 
			default: return "ERROR";
        }  		
    }

	int Lb_Cnt = 0;
	
	// ===================================================================================
	string Gen_Label_Name()
	{
		Lb_Cnt++;
		
		return "Lb_" + Lb_Cnt;
	}
	
	// ===================================================================================
	public void CMD_ELSE()
	{
DBG.ENTER("IR_V1.CMD_ELSE()");		
		

		//DBG.Print("\n" + TabSpaser());
		
		TabLevel--;

		DBG.Print("\n" + TabSpaser() + "СТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + "_2");
		DBG.Print("\n" + TabSpaser() + LB[Curr_IF_Level-1] + ":");
		
		// Установить признак того, что есть else-ветка
		LB[Curr_IF_Level-1] = LB[Curr_IF_Level-1] + "_";
		
		TabLevel++;
		
		//DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void CMD_IF_END()
	{
DBG.ENTER("IR_V1.CMD_IF_END()");	
		
		Curr_IF_Level--;
		
		string LB_Name = LB[Curr_IF_Level]; 
		
		// Если была else-ветка
		if(LB_Name[LB_Name.Length-1] == '_')
			LB_Name += '2';	
		
		//DBG.Print("\n" + TabSpaser());
		
		TabLevel--;
		DBG.Print("\n" + TabSpaser() + LB_Name + ':');
		//DBG.Print("\n" + TabSpaser());


		
DBG.RETURN("");
	}
	
	
	// ===================================================================================
	string ConvertType(string type)
	{
	DBG.ENTER("IR_V1.ConvertType()");
	DBG.RETURN("");
	
		switch(type)
		{
			case "void"  : return "void"; 
			case "int"   : return "int";
			case "float" : return "double";
			case "double": return "double";
			default:       return "?";
		}	
	}
	
	// ===================================================================================
	public void CMD_SWITCH_START(string SwitchValue)
	{		
		LB[Curr_IF_Level] = Gen_Label_Name();  // Запомнить метку, для переходов по break
		Curr_IF_Level++;
		
		LB[Curr_IF_Level] = SwitchValue;	
		Curr_IF_Level++;
		
        

        // Эта метка, вставлена в стек, только для того, чтобы при ПЕРВОМ входе в case, 
		// было такое-же состояние стека, как и при всех остальных входах в case-ветку
	 // LB[Curr_IF_Level] = "Free_LB";	
		LB[Curr_IF_Level] = Gen_Label_Name(); // + "_Free";	
		Curr_IF_Level++;
		
		// ВАЖНО - этот странный переход, вставляется в начале switch-а, т.к. в текущей версии, 
		// возникает один лишний скачек, из-за того, что все switch-ветки обрабатываются одинаково, 
		// как самый первый case так и все остальные case-ветки, имеют 
		// перескок проверки, необходимый для реализации проваливания веток.
		// и в этом месте, происходит перескок лишнего перескока.
		DBG.Print("\n\nСТРИБНУТИ_НА " + LB[Curr_IF_Level-1]);
		DBG.Print("             ----- switch START (see remark)");
		
		//DBG.Print("\n\n");

	}
	
	// ===================================================================================
	public void SWITCH_CASE(string CaseValue)
	{
		string Case_Label = LB[Curr_IF_Level-1];		
		Curr_IF_Level--;
		
		// Реализация проваливания веток.
		// Если в предыдущей ветке есть break или return, то до этого скачка, программа не дойдет
		// Т.е., этот скачек, произойдет только в том случае, когда должно быть проваливание ветки.
		// ПРИМ - в default-ветку, мы провалимся и без этого скачка, поэтому в default-ветке нет этого перехода
        DBG.Print("\nСТРИБНУТИ_НА " + Case_Label + "_2");		
		DBG.Print("           ----- Realization Fall_Through");

		DBG.Print("\n" + Case_Label + ":");
		
		LB[Curr_IF_Level] = Gen_Label_Name();  // Запомнить метку, перехода на проверку следующего case
		Curr_IF_Level++;		
		
		
		DBG.Print("\nЯКЩО " + LB[Curr_IF_Level-2] + " ≠ " + CaseValue + " СТРИБНУТИ_НА " + LB[Curr_IF_Level-1]);
		DBG.Print("  ----- case " + CaseValue + ":");

		DBG.Print("\n" + Case_Label + "_2:");
	}
	
	// ===================================================================================
	public void BREAK_IN_SWITCH()
	{
		DBG.Print("\nСТРИБНУТИ_НА " + LB[Curr_IF_Level-3]);	
		DBG.Print("             ----- break; ");
	}
	
	// ===================================================================================
	public void SWITCH_DEFAULT()
	{
		string Case_Label = LB[Curr_IF_Level-1];		
		Curr_IF_Level--;
		
		DBG.Print("\n" + Case_Label + ":");	
		DBG.Print("                         ----- default:");
		
		LB[Curr_IF_Level] = Gen_Label_Name(); // + "_Free";  // Эта метка, используется только для того, чтобы при входе 
		Curr_IF_Level++;                       // в SWITCH_END, было такое-же состояние, как и после case-ветки
		
	}
	
	// ===================================================================================
	public void SWITCH_END()
	{
		string Label = LB[Curr_IF_Level-1];		
		Curr_IF_Level--;	
		
		DBG.Print("\n" + Label + ":");	
		
		string Label_ForAll_Breaks = LB[Curr_IF_Level-2];		
		Curr_IF_Level -= 2; // Удалить два последних эл-та в стеке
		
		DBG.Print("\n" + Label_ForAll_Breaks + ":");
		DBG.Print("                         ----- switch END");
		DBG.Print("\n");
	}

    // ===================================================================================
	public void DO_START()
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
		Curr_IF_Level++;

        DBG.Print("\n\n" + LB[Curr_IF_Level-1] + ":                         ----- DO_START");

    }

    // ===================================================================================
	public void DO_END(string Op1, string CmpSign, string Op2)
    {
        DBG.Print("\nЯКЩО " + Op1 + " " + CmpSign + " " + Op2 + " " + "СТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + "  ----- DO_END");

        Curr_IF_Level--;	
    }

    // ===================================================================================
	public void WHILE_START(string Op1, string CmpSign, string Op2)
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
		Curr_IF_Level++;

        DBG.Print("\n\n" + LB[Curr_IF_Level-1] + ":                         ----- WHILE_START");
        DBG.Print("\nЯКЩО " + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + " " + "СТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + "_2");

    }

    // ===================================================================================
	public void WHILE_END()
    {
        DBG.Print("\nСТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + ":            ----- WHILE_END");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + "_2:");

        Curr_IF_Level--;	
    }

    // ===================================================================================
	public void FOR_START(string Op1, string CmpSign, string Op2)
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
		Curr_IF_Level++;

        DBG.Print("                        ----- FOR_START");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + ":");
        DBG.Print("\nЯКЩО " + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + " " + "СТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + "_2");

    }

    // ===================================================================================
	public void FOR_END()
    {
        DBG.Print("\nСТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + ":            ----- FOR_END");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + "_2:");

        Curr_IF_Level--;	
    }
}


/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████

                ██ ██████         ██    ██ ██   ██         ██████           ██████ ██████  ██████  
                ██ ██   ██        ██    ██ ██   ██         ██   ██         ██      ██   ██ ██   ██ 
                ██ ██████         ██    ██ ███████         ██   ██         ██      ██████  ██████  
                ██ ██   ██         ██  ██       ██         ██   ██         ██      ██      ██      
                ██ ██   ██ ███████  ████        ██ ███████ ██████  ███████  ██████ ██      ██      
                                                                                                                                                                                                                                                                                                                                                                                                      
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */

class IR_V4_Generete_Destructured_CPP
{
	// string ResultStr;
		
	// ===================================================================================
	public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V4.Next_Sentence_in_global_scope()");
    
	
	DBG.RETURN("");
    }
	
	int TabLevel = 0;
	
	// ===================================================================================
	string TabSpaser()
	{
		string Str = "";
			
		//for(int i = 0; i < TabLevel; i++)
		//	Str += "    "; // · | │		
		
		return Str;
	}
	
	// ===================================================================================
	public void Def_Variable(string Type, string Name)
	{
	DBG.ENTER("IR_V4.Def_Variable(T, N)");
		
		DBG.Print("\n" + TabSpaser() + Type + " " + Name + ";");
		
	DBG.RETURN("");
	}

	// ===================================================================================
	public void Def_Variable(string Type, string Name, string InitValue)
	{
	DBG.ENTER("IR_V4.Def_Variable(T, N, V)");
		
		DBG.Print("\n" + TabSpaser() + Type + " " + Name + " = " + InitValue + ";");
		
	DBG.RETURN("");
	} 
	
	bool First_Arg;
	

	// ===================================================================================
	public void Define_Function_START(string FuncName, string RetutnType)
	{
	DBG.ENTER("IR_V4.Define_Function_START()");
		
		DBG.Print("\n\n\n");
		DBG.Print(TabSpaser() + RetutnType + " " + FuncName + "(");
				
		First_Arg = true;
		
		TabLevel++;
		
	DBG.RETURN("");		
	}
	
	// ===================================================================================
	public void Function_NextArg(string Param_Name,  string Param_Type)
	{
	DBG.ENTER("IR_V4.Function_NextArg()");
		
		if(First_Arg == true)
			DBG.Print(Param_Type + " " + Param_Name); // без запятой перед параметром
		else
		{
			DBG.Print(", " + Param_Type  + " " + Param_Name); // версия в много строк
		}
		
		First_Arg = false;
		
	DBG.RETURN("");	
	}
	
	// ===================================================================================
	public void Function_ArgList_END()
	{
DBG.ENTER("IR_V1.Function_ArgList_END()");
        
		// Если нет ни одного аргумента
		if(First_Arg == true)
		 	DBG.Print("void");
		
        DBG.Print(")\n");
		DBG.Print("{\n");
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void Def_Function_END()
	{
DBG.ENTER("IR_V4.Def_Function_END()");
				
		TabLevel--;		

		DBG.Print("\n" + TabSpaser() + "}");	
		

		
DBG.RETURN("");
	}	
	
	// ===================================================================================
	public void RETURN_w_Value(string Value)
	{
DBG.ENTER("IR_V4.RETURN_w_Value()");		
		
		DBG.Print("\n" + TabSpaser() + "return " + Value + ";");
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void RETURN_VOID()
	{
DBG.ENTER("IR_V1.RETURN_VOID()");	
		
		DBG.Print("\n" + TabSpaser() + "return;");
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void GOTO(string Lb_Name)
	{
DBG.ENTER("IR_V4.GOTO()");	
		
		DBG.Print("\n" + TabSpaser() + "goto " + Lb_Name + ";");
		
DBG.RETURN("");
	}

	string[] LB = new string[1000];
	
	int Curr_IF_Level = 0;
	
	// ===================================================================================
	public void CMD_IF(string Op1, string CmpSign, string Op2)
	{
DBG.ENTER("IR_V4.CMD_IF()");
		
		LB[Curr_IF_Level] = Gen_Label_Name();
		
		//DBG.Print("\n" + TabSpaser());
		DBG.Print("\n" + TabSpaser() + "if(" + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + ") goto " + LB[Curr_IF_Level] + ";");
		DBG.Print("    // IF_START ");

		
		Curr_IF_Level++;
		
		TabLevel++;
		
		//DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}

    // ===================================================================================
    string Inverse_CMP(string CMP)
    {
        switch(CMP)
        {
            case ">":  return "<=";
            case "<":  return ">=";
            case "==": return "!=";
            case "!=": return "==";
            case ">=": return "<";
            case "<=": return ">"; 
			default: return "ERROR";
        }  		
    }

	int Lb_Cnt = 0;
	
	// ===================================================================================
	string Gen_Label_Name()
	{
		Lb_Cnt++;
		
		return "Lb_" + Lb_Cnt;
	}
	
	// ===================================================================================
	public void CMD_ELSE()
	{
DBG.ENTER("IR_V4.CMD_ELSE()");		
		

		//DBG.Print("\n" + TabSpaser());
		
		TabLevel--;

		DBG.Print("\n" + TabSpaser() + "goto " + LB[Curr_IF_Level-1] + "_2;            // IF_ELSE");
		DBG.Print("\n" + TabSpaser() + LB[Curr_IF_Level-1] + ":");
		
		// Установить признак того, что есть else-ветка
		LB[Curr_IF_Level-1] = LB[Curr_IF_Level-1] + "_";
		
		TabLevel++;
		
		//DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void CMD_IF_END()
	{
DBG.ENTER("IR_V4.CMD_IF_END()");	
		
		Curr_IF_Level--;
		
		string LB_Name = LB[Curr_IF_Level]; 
		
		// Если была else-ветка
		if(LB_Name[LB_Name.Length-1] == '_')
			LB_Name += '2';	
		
		//DBG.Print("\n" + TabSpaser());
		
		TabLevel--;
		DBG.Print("\n" + TabSpaser() + LB_Name + ":                 // IF_END");
		//DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void CMD_SWITCH_START(string SwitchValue)
	{		
		LB[Curr_IF_Level] = Gen_Label_Name();  // Запомнить метку, для переходов по break
		Curr_IF_Level++;
		
		LB[Curr_IF_Level] = SwitchValue;	
		Curr_IF_Level++;
		
        

        // Эта метка, вставлена в стек, только для того, чтобы при ПЕРВОМ входе в case, 
		// было такое-же состояние стека, как и при всех остальных входах в case-ветку
	 // LB[Curr_IF_Level] = "Free_LB";	
		LB[Curr_IF_Level] = Gen_Label_Name(); // + "_Free";	
		Curr_IF_Level++;
		
		// ВАЖНО - этот странный переход, вставляется в начале switch-а, т.к. в текущей версии, 
		// возникает один лишний скачек, из-за того, что все switch-ветки обрабатываются одинаково, 
		// как самый первый case так и все остальные case-ветки, имеют 
		// перескок проверки, необходимый для реализации проваливания веток.
		// и в этом месте, происходит перескок лишнего перескока.
		DBG.Print("\n\ngoto " + LB[Curr_IF_Level-1] + ";");
		DBG.Print("             // switch START (see remark)");
		
		//DBG.Print("\n\n");

	}
	
	// ===================================================================================
	public void SWITCH_CASE(string CaseValue)
	{
		string Case_Label = LB[Curr_IF_Level-1];		
		Curr_IF_Level--;
		
		// Реализация проваливания веток.
		// Если в предыдущей ветке есть break или return, то до этого скачка, программа не дойдет
		// Т.е., этот скачек, произойдет только в том случае, когда должно быть проваливание ветки.
		// ПРИМ - в default-ветку, мы провалимся и без этого скачка, поэтому в default-ветке нет этого перехода
        DBG.Print("\ngoto " + Case_Label + "_2;");		
		DBG.Print("            // Realization Fall_Through");

		DBG.Print("\n" + Case_Label + ":");
		
		LB[Curr_IF_Level] = Gen_Label_Name();  // Запомнить метку, перехода на проверку следующего case
		Curr_IF_Level++;		
		
		
		DBG.Print("\nif(" + LB[Curr_IF_Level-2] + " != " + CaseValue + ") goto " + LB[Curr_IF_Level-1] + ";");
		DBG.Print("   // case " + CaseValue + ":");

		DBG.Print("\n" + Case_Label + "_2:");
	}
	
	// ===================================================================================
	public void BREAK_IN_SWITCH()
	{
		DBG.Print("\ngoto " + LB[Curr_IF_Level-3] + ";");	
		DBG.Print("              // break; ");
	}
	
	// ===================================================================================
	public void SWITCH_DEFAULT()
	{
		string Case_Label = LB[Curr_IF_Level-1];		
		Curr_IF_Level--;
		
		DBG.Print("\n" + Case_Label + ":");	
		DBG.Print("                  // default:");
		
		LB[Curr_IF_Level] = Gen_Label_Name(); // + "_Free";  // Эта метка, используется только для того, чтобы при входе 
		Curr_IF_Level++;                       // в SWITCH_END, было такое-же состояние, как и после case-ветки
		
	}
	
	// ===================================================================================
	public void SWITCH_END()
	{
		string Label = LB[Curr_IF_Level-1];		
		Curr_IF_Level--;	
		
		DBG.Print("\n" + Label + ":");	
		
		string Label_ForAll_Breaks = LB[Curr_IF_Level-2];		
		Curr_IF_Level -= 2; // Удалить два последних эл-та в стеке
		
		DBG.Print("\n" + Label_ForAll_Breaks + ":");
		DBG.Print("                   // switch END");
		DBG.Print("\n");
	}

    // ===================================================================================
	public void DO_START()
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
		Curr_IF_Level++;

        DBG.Print("\n\n" + LB[Curr_IF_Level-1] + ":                  // DO_START");

    }

    // ===================================================================================
	public void DO_END(string Op1, string CmpSign, string Op2)
    {
        DBG.Print("\nif( " + Op1 + " " + CmpSign + " " + Op2 + ") goto " + LB[Curr_IF_Level-1] + ";  // DO_END");

        Curr_IF_Level--;	
    }

    // ===================================================================================
	public void WHILE_START(string Op1, string CmpSign, string Op2)
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
		Curr_IF_Level++;

        DBG.Print("\n\n" + LB[Curr_IF_Level-1] + ":                  // WHILE_START");
        DBG.Print("\nif(" + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + ") goto " + LB[Curr_IF_Level-1] + "_2;");

    }

    // ===================================================================================
	public void WHILE_END()
    {
        DBG.Print("\ngoto " + LB[Curr_IF_Level-1] + ";             // WHILE_END");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + "_2:");

        Curr_IF_Level--;	
    }

    // ===================================================================================
	public void FOR_START(string Op1, string CmpSign, string Op2)
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
		Curr_IF_Level++;

        DBG.Print("            // FOR_START");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + ":");
        DBG.Print("\nif(" + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + ") goto " + LB[Curr_IF_Level-1] + "_2;");

    }

    // ===================================================================================
	public void FOR_END()
    {
        DBG.Print("\ngoto " + LB[Curr_IF_Level-1] + ":             // FOR_END");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + "_2:");

        Curr_IF_Level--;	
    }
}

/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████

                ██ ██████         ██    ██ ███████         ██████   ██████  ████████ 
                ██ ██   ██        ██    ██ ██              ██   ██ ██    ██    ██    
                ██ ██████         ██    ██ ███████         ██   ██ ██    ██    ██    
                ██ ██   ██         ██  ██       ██         ██   ██ ██    ██    ██    
                ██ ██   ██ ███████  ████   ███████ ███████ ██████   ██████     ██    
                                                                                                                                                                                                                                                                                                                 
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */

class IR_V5_Generete_DOT
{
	// string ResultStr;

	class Stack_int
	{
		// Ссылка на массив, в котором хранятся данные стека
		int[] StackArray;

		// Индекс в массиве, где лежит верхний элемент стека
		int TopPos = -1; 

		public Stack_int(int Stack_Size) // Stack_Size - размер стека
		{
			// Выделить память под объект массива
			StackArray = new int[Stack_Size];
		}

		// Новое значение, поместить на вершину стека
		public void PUSH(int Value)
		{
			TopPos++;

			StackArray[TopPos] = Value;
		}

		// Извлечь значение с вершины стека
		public int POP()
		{
			int TMP = StackArray[TopPos];

			TopPos--;

			return TMP;
		}

		// Посмотреть значение на вершине стека, не извлекая его из стека.
		public int SEE_TOP()
		{
			return StackArray[TopPos];
		}
	}

	// Стек, в котором хранится цепочка номеров всех родительских узлов
	Stack_int All_ParentNodes = new Stack_int(1000);	


	
	// ===================================================================================
	int Create_Node(string label)
	{
		LastAddedNode_Number++;
		DBG.Print("\n" + TabSpaser() + "n" + LastAddedNode_Number + "[label=\"" + label + "\", xlabel=\"n" + LastAddedNode_Number + "\"];");
		
		return LastAddedNode_Number;
	}

	// ===================================================================================
	int Create_Node(string label, string color)
	{
		LastAddedNode_Number++;
		DBG.Print("\n" + TabSpaser() + "n" + LastAddedNode_Number + "[label=\"" + label + "\", xlabel=\"n" + LastAddedNode_Number + "\", fillcolor = \"" + color + "\", color = \"" + "black" + "\"];"); // color это цвет абриса
		
		return LastAddedNode_Number;
	}
	
	// ===================================================================================
	void Create_Link(int Src, int Dest)
	{
		DBG.Print("\n" + TabSpaser() + "n" + Src + " -> n" + Dest);
	}
	
		// ===================================================================================
	void Create_Link(int Src, int Dest, string color)
	{
		DBG.Print("\n" + TabSpaser() + "n" + Src + " -> n" + Dest + " [color = \"" + color + "\"]");
	}
	
	// ===================================================================================
	public void START()
	{
		// n1 - GLOBAL
		Create_Node("GLOBAL", "green");		
		
		All_ParentNodes.PUSH(LastAddedNode_Number);
	}
	
	// ===================================================================================
	public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V5.Next_Sentence_in_global_scope()");
    

	// ===================================================================================	
	DBG.RETURN("");
    }
	
	int TabLevel = 0;
	
	// ===================================================================================
	string TabSpaser()
	{
		string Str = "";
		
		for(int i = 0; i < TabLevel; i++)
			Str += "    "; // · | │
		
		return Str;
	}
	
	int LastAddedNode_Number = 0;
	
	// ===================================================================================
	public void Def_Variable(string Type, string Name)
	{
	DBG.ENTER("IR_V2.Def_Variable(T, N)");
		
		DBG.Print("\n\n"+ TabSpaser() + "// " + Type + " " + Name + ";"); 
		
  		// ВАЖНО - приведенные тут номера узлов, соответствуют первому предложению после GLOBAL (который n1)

		// n2 - Def_Var
		// n3 - VarName 
		// n4 - VarType
		
		Create_Node("Define\\nVariable", "aquamarine2");
		Create_Node("Var\\nName", "aquamarine2");
		Create_Node("Var\\nType", "aquamarine2");
		
		//n1 -> n2 // GLOBAL  -> Def_Var
		//n2 -> n3 // Def_Var -> VarName
		//n2 -> n4 // Def_Var -> VarType
		
		Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number-2, "aquamarine2");
		Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number-1, "aquamarine2");
		Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number, "aquamarine2");
		
	DBG.RETURN("");
	}

	// ===================================================================================
	public void Def_Variable(string Type, string Name, string InitValue)
	{
	DBG.ENTER("IR_V2.Def_Variable(T, N, V)");
		
		DBG.Print("\n\n"+ TabSpaser() + "// " + Type + " " + Name + " = " + InitValue + ";");
		
		Create_Node("Define\\nVariable", "aquamarine2");
		Create_Node("Var\\nName", "aquamarine2");
		Create_Node("Var\\nType", "aquamarine2");
		Create_Node("Init\\nValue", "aquamarine2");
		
		Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number-3, "aquamarine2");
		Create_Link(LastAddedNode_Number-3,    LastAddedNode_Number-2, "aquamarine2");
		Create_Link(LastAddedNode_Number-3,    LastAddedNode_Number-1, "aquamarine2");
		Create_Link(LastAddedNode_Number-3,    LastAddedNode_Number, "aquamarine2");
		
	DBG.RETURN("");
	} 
	
	bool First_Arg;
	
	
	// ===================================================================================
	public void Define_Function_START(string FuncName, string RetutnType)
	{
	DBG.ENTER("IR_V1.Define_Function_START()");
		
		DBG.Print("\n\n// " + RetutnType + " " + FuncName + "(");
		
		Create_Node("Define\\nFunction", "gold");
		
		// Parent -> DefineFunction
		Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number, "gold");
		
		Create_Node("FuncName", "gold");
		Create_Node("RetType", "gold");
		Create_Node("ArgList", "gold");
		
		Create_Link(LastAddedNode_Number-3, LastAddedNode_Number-2, "gold");
		Create_Link(LastAddedNode_Number-3, LastAddedNode_Number-1, "gold");
		Create_Link(LastAddedNode_Number-3, LastAddedNode_Number, "gold");

		
		All_ParentNodes.PUSH(LastAddedNode_Number-3);
		All_ParentNodes.PUSH(LastAddedNode_Number);


		First_Arg = true;
		
		TabLevel++;
		
	DBG.RETURN("");		
	}
	
	int Arg_Cnt = 0;
	
	// ===================================================================================
	public void Function_NextArg(string Param_Name,  string Param_Type)
	{
	DBG.ENTER("IR_V1.Function_NextArg()");
		
		Arg_Cnt++;		
		
		DBG.Print("\n\n" + TabSpaser() + "// Arg #" + Arg_Cnt + " " + Param_Type + " " + Param_Name);
		
		Create_Node("Arg #" + Arg_Cnt, "aquamarine2");
		Create_Node("Name", "aquamarine2");
		Create_Node("Type", "aquamarine2");
		
		Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number-2, "aquamarine2");
		Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number-1, "aquamarine2");
		Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number, "aquamarine2");
		
		First_Arg = false;
		
	DBG.RETURN("");	
	}
	
	// ===================================================================================
	public void Function_ArgList_END()
	{
DBG.ENTER("IR_V1.Function_ArgList_END()");
        
		DBG.Print("\n\n" + TabSpaser() + "// ArgList END");
		
		All_ParentNodes.POP();
			
		Create_Node("Body", "gold");	
		
		Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number, "gold");
		
		All_ParentNodes.PUSH(LastAddedNode_Number);
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void Def_Function_END()
	{
DBG.ENTER("IR_V1.Def_Function_END()");
		
		
		TabLevel--;		

		DBG.Print("\n" + TabSpaser() + "}");	
		

		
DBG.RETURN("");
	}	
	
	// ===================================================================================
	public void RETURN_w_Value(string Value)
	{
DBG.ENTER("IR_V1.RETURN_w_Value()");		
		
		DBG.Print("\n" + TabSpaser() + "return " + Value + ";");
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void RETURN_VOID()
	{
DBG.ENTER("IR_V1.RETURN_VOID()");	
		
		DBG.Print("\n" + TabSpaser() + "return;");
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void GOTO(string Lb_Name)
	{
DBG.ENTER("IR_V1.GOTO()");	
		
		DBG.Print("\n" + TabSpaser() + "goto " + Lb_Name + ";");
		
DBG.RETURN("");
	}

	// ===================================================================================
	public void CMD_IF(string Op1, string CmpSign, string Op2)
	{
DBG.ENTER("IR_V1.CMD_IF()");
		
		DBG.Print("\n" + TabSpaser());
		DBG.Print("\n" + TabSpaser() + "if(" + Op1 + " " + CmpSign + " " + Op2 + ")");
		
		DBG.Print("\n" + TabSpaser() + "{");
		
		TabLevel++;
		

		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void CMD_ELSE()
	{
DBG.ENTER("IR_V1.CMD_ELSE()");		
		

		//DBG.Print("\n" + TabSpaser());
		
		TabLevel--;

		DBG.Print("\n" + TabSpaser() + "}");
		
		DBG.Print("\n" + TabSpaser() + "else");
		
		DBG.Print("\n" + TabSpaser() + "{");
		
		TabLevel++;
		
		//DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void CMD_IF_END()
	{
DBG.ENTER("IR_V1.CMD_IF_END()");	
		
		
	
		TabLevel--;
		DBG.Print("\n" + TabSpaser() + "}");
		DBG.Print("\n" + TabSpaser());
		
DBG.RETURN("");
	}
	
		// ===================================================================================
	public void CMD_SWITCH_START(string SwitchValue)
	{
		DBG.Print("\n\n" + TabSpaser() + "switch(" + SwitchValue + ")\n"+ TabSpaser() + "{");	
		
		TabLevel++;
		TabLevel++;
	}
	
	// ===================================================================================
	public void SWITCH_CASE(string CaseValue)
	{
		TabLevel--;		
		
		DBG.Print("\n" + TabSpaser() + "case " + CaseValue + ":");	
		
		TabLevel++;
	}
	
	// ===================================================================================
	public void BREAK_IN_SWITCH()
	{
		DBG.Print("\n" + TabSpaser() + "break;");
	}
	
	// ===================================================================================
	public void SWITCH_DEFAULT()
	{
		TabLevel--;
		
		DBG.Print("\n" + TabSpaser() + "default:");	
		
		TabLevel++;
	}
	
	// ===================================================================================
	public void SWITCH_END()
	{
		TabLevel--;
		TabLevel--;
		
		DBG.Print("\n" + TabSpaser() + "}\n");	
	}	

    // ===================================================================================
	public void DO_START()
    {
		DBG.Print("\n\n" + TabSpaser() + "// do{");
		
		Create_Node("DO-WHILE", "coral3");
		Create_Node("Body", "coral3");
		
		int TMP = LastAddedNode_Number;
		
		Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number-1, "coral3");
		Create_Link(LastAddedNode_Number-1,    LastAddedNode_Number, "coral3");
		
		All_ParentNodes.PUSH(TMP-1); // узел DO-WHILE
		All_ParentNodes.PUSH(TMP);   // узел Body
		
		TabLevel++;

    }

    // ===================================================================================
	public void DO_END(string Op1, string CmpSign, string Op2)
    {
		TabLevel--;

		DBG.Print("\n\n" + TabSpaser() + "// } while(" + Op1 + " " + CmpSign + " " + Op2 + ");");
		
		All_ParentNodes.POP(); // После этого, на вершине узел DO-WHILE
		
		Create_Node("Cond", "coral3");
		Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number, "coral3");
		
		Create_Node(CmpSign, "deeppink2");
		Create_Node(Op1, "deeppink2");
		Create_Node(Op2, "deeppink2");		
		
		Create_Link(LastAddedNode_Number-3,    LastAddedNode_Number-2, "deeppink2");
		Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number-1, "deeppink2");
		Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number, "deeppink2");
		
		All_ParentNodes.POP(); 	
    }

    // ===================================================================================
	public void WHILE_START(string Op1, string CmpSign, string Op2)
    {
		DBG.Print("\n\n" + TabSpaser() + "// while(" + Op1 + " " + CmpSign + " " + Op2 + ")");
		
		Create_Node("WHILE", "coral3");
		Create_Node("Cond", "coral3");
		Create_Node("Body", "coral3");
		
		int TMP = LastAddedNode_Number;
		

		
		Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number-2, "coral3");
		Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number-1, "coral3");
		Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number, "coral3");
		
		// -------
		
		Create_Node(CmpSign, "deeppink2");
		Create_Node(Op1, "deeppink2");
		Create_Node(Op2, "deeppink2");		
		
		Create_Link(LastAddedNode_Number-4,    LastAddedNode_Number-2, "deeppink2");
		Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number-1, "deeppink2");
		Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number, "deeppink2");
		
		All_ParentNodes.PUSH(TMP);
		
		TabLevel++;
    }

    // ===================================================================================
	public void WHILE_END()
    {
		TabLevel--;
		
	 	All_ParentNodes.POP();
    }

    // ===================================================================================
	public void FOR_START(string Op1, string CmpSign, string Op2)
    {
    }

    // ===================================================================================
	public void FOR_END()
    {

    }
		
}



/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████

                        ██████  ██████   ██████  
                        ██   ██ ██   ██ ██       
                        ██   ██ ██████  ██   ███ 
                        ██   ██ ██   ██ ██    ██ 
                        ██████  ██████   ██████  
                                                                                                  
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */

class DBG
{
	static int  Level          = 0;
	static int  Enter_Cnt      = 0;
	static bool View_Call_Tree = false;
    static bool Visibled       = false;
	static bool Colored_Console = false;

	// ==========================================================
	static public void Colored_Console_ON()
	{
		Colored_Console = true;	
	}
	
	// ==========================================================
	static public void View_Call_Tree_ON()
	{
		View_Call_Tree = true;	
		
		Console.Write("\n ---------- SHOW CALL TREE --------------------------");	
	}
	
	// ==========================================================
	static public void View_Call_Tree_OFF()
	{
		View_Call_Tree = false;	
		
		Console.Write("\n ---------- HIDE CALL TREE --------------------------");		
	}
	
	// ==========================================================
	public static void ENTER(string Msg)
	{
//return;
		Level++;
		
		Enter_Cnt++;
		
		if(View_Call_Tree == false)
			return;
		
		Console.Write("\n");
		
		for(int i=0; i<Level; i++)
		{
			if(i == 0)
				Console.Write("   ");
			else
				Console.Write("·  ");
		}
		 
	 // Console.Write("└─>┐ ");
		Console.Write("╰──╮ ");	
		
		Console.Write("\n");
		
		for(int i=0; i<Level; i++)
		{
			if(i == 0)
				Console.Write("   ");
			else
				Console.Write("·  ");
		}
		
		Console.Write("·  " + Msg + "   " + Enter_Cnt);		
	}
	
	// ==========================================================
	public static void RETURN()
	{
		RETURN("");
	}
	
	// ==========================================================
	public static void RETURN(string Msg)
	{
//return;
		if(View_Call_Tree == false)
		{
			Level--;
			
			return;
		}
		
		Console.WriteLine("");
		
		for(int i=0; i<Level; i++)
		{
			if(i == 0)
				Console.Write("   ");
			else
				Console.Write("·  ");
		}
		
     // Console.Write("┌-<┘ ");	
	 	Console.Write("╭──╯ ");	
		
    ConsoleColor TMP = Console.ForegroundColor;

    if(Colored_Console == true)
		Console.ForegroundColor = ConsoleColor.Blue;

    Console.Write(Msg);

	if(Colored_Console == true)
    	Console.ForegroundColor = TMP;

		Level--;
	}
	// ====================================================================	
	public static void Print_ON()
	{
		Visibled = true;
	}
	
	// ====================================================================	
	public static void Print_OFF()
	{
		Visibled = false;
	}

	// ====================================================================
	public static void Print(string Str, ConsoleColor Clr)
	{
	    ConsoleColor TMP = Console.ForegroundColor;

    	if(Colored_Console == true)
			Console.ForegroundColor = Clr;

    	Print(Str);

		if(Colored_Console == true)
    		Console.ForegroundColor = TMP;	

	}

	// ====================================================================
	public static void Print(string Str)
	{
		if(Visibled == false)
			return;
		
		Console.Write(Str);
	}
	
	// ====================================================================
	public static void Print(string[] Str)
	{
		if(Visibled == false)
			return;
		
		foreach(string s in Str)
			DBG.Print("[\"" + s + "\"]\n");
	}
	
	// ====================================================================
	public static void Print(Token[] TknList)
	{
		if(Visibled == false)
			return;	
		
		DBG.Print("      TOKEN LIST:\n\n");
		DBG.Print("   TYPE         VALUE\n\n");
		
		for(int i = 0; i < TknList.Length-1; i++) 
		{
			Token Current_Token = TknList[i];
			
			int TypeStr_Lenght = Current_Token.Type.ToString().Length;
			
			int Spacer_Len = 16 - TypeStr_Lenght;
			
			string Spacer = "";
			
			for(int j = 0; j < Spacer_Len; j++)
				Spacer += " ";			
			
//			DBG.Print("[ [\"" + Current_Token.Type + "\"]" + Spacer + "[\"" + Current_Token.Value + "\"] ]\n");
			DBG.Print(          Current_Token.Type         + Spacer +  "\"" + Current_Token.Value + "\"\n");

		}
	}
	
	// ==========================================================
	void ERROR_TRAP()
	{
DBG.ENTER("ERROR_TRAP()");	
		
		//while(true) {}
		System.Environment.Exit(10);
		
//DBG.RETURN("");		
	}

	// ====================================================================
	public static void Src_ERROR_TRAP(string Msg)
	{
DBG.ENTER("Src_ERROR_TRAP()");

		Console.Write("  ----> Src_ERROR_TRAP(\"" + Msg + "\");\n\n\n");		
		
	 // while(true){};
		System.Environment.Exit(10);

//DBG.RETURN("");
	}
}

 
/* ███████████████████████████████████████████████████████████████████████████████████████

                ██      ███████ ██   ██ ███████ ██████  
                ██      ██       ██ ██  ██      ██   ██ 
                ██      █████     ███   █████   ██████  
                ██      ██       ██ ██  ██      ██   ██ 
                ███████ ███████ ██   ██ ███████ ██   ██ 

   ███████████████████████████████████████████████████████████████████████████████████████ 


	Разбить текст исходника на отдельные ЛЕКСЕМЫ. 
  
	ПРИМ - ЛЕКСЕМА, это минимальная НЕДЕЛИМАЯ часть программы, несущая смысл.


	ЛОГИКА РАБОТЫ ЛЕКСЕРА:
 
    Производится ПОСИМВОЛЬНАЯ вычитка исходного кода, и каждый считанный символ исходника, записывается в выходную строку. 
	НО, в зависимости от вычитанного символа, вычитанный символ может быть подменен на цепочку других символов.
 
	Для этого, в потоке символов исходного кода, отлавливаются 
	признаки-разделители между лексемами (пробелы, пунктуаторы и др.).
   
	Когда обнаруживается очередной признак-разделитель лексем, 
	то в выходную строку записывается разделитель лексем, который отделит текущую лексему от следующей.
*/

class Lexer
{
	public string[] Split_to_Lexems(string Src)
	{
DBG.ENTER("Split_to_Lexems()");
		
		//Src = Clear_Space_Pack(Src);
		
//DBG.Print("\n\n");
//DBG.Print(Src);
		
		
		// Состояние лексера - "вне строки" или "в строке"
		bool InString = false;
		
		// Все лексемы, накапливаются в этой строке
		// ПРИМ - между собой, лексемы отделяютя переводом строки - '\n'
		string Lexems_List = "";
		
		// Перебор всех символов исходника
		for(int i = 0; i < Src.Length; i++)
		{
			// Вычитать один символ исходника
			char c = Src[i];
			
			// Если вычитан символ двойной кавычки, то переключить состояние "вне строки" или "в строке"
			if(c == '"')
			{
				if(InString == false)
					InString = true;
				else
					InString = false;

               Lexems_List += '"';
               
               continue; 
			}				
			
            if(InString == true) // Если мы В строке
            {
                Lexems_List += c;
            }
            else                // Если мы НЕ в строке
            {
                switch(c)
                {              
                case ' ' : Lexems_List += "\n";    break; // заменить пробел на разделитель лексем     WHY string???
			    case '\t': Lexems_List += '\n';    break; // заменить непечатаемый символ на разделитель лексем
			    case '\n': Lexems_List += '\n';    break;
			    case '\r': Lexems_List += '\n';    break;
			    case '(' : Lexems_List += "\n(\n"; break; // Пунктуаторы - это отдельные лексемы
			    case ')' : Lexems_List += "\n)\n"; break;
			    case '{' : Lexems_List += "\n{\n"; break;
			    case '}' : Lexems_List += "\n}\n"; break;
			    case ';' : Lexems_List += "\n;\n"; break; 
				case '+' : Lexems_List += "\n+\n"; break; 
				case '-' : Lexems_List += "\n-\n"; break; 
				case '*' : Lexems_List += "\n*\n"; break; 
				case '/' : Lexems_List += "\n/\n"; break; 
				case ',' : Lexems_List += "\n,\n"; break; 
				case ':' : Lexems_List += "\n:\n"; break;
                case '.' :
                    {
    				    // Смысл точки зависит от контекста
	    			    // Если за точкой цифра, то точка не пунктуатор, а часть float-числа, иначе, точка - пунктуатор

                        char Next_c = Src[i+1];  // TODO - а если точка будет в конце файла???
					
    					// Смотрим на символ, следующий за точкой
                        if(Char.IsDigit(Next_c) == false)
                            Lexems_List += "\n.\n"; // точка является пунктуатором
                        else
							Lexems_List += '.';     // точка является частью float-числа
                    }
                    break;

                default: Lexems_List += c; break;
                } 
            }           
			
			
		} // loop end		

		Lexems_List = Clear_NewLine_Pack(Lexems_List);

//DBG.Print("\n\n------------------\n\n\n");
//DBG.Print(Lexems_List);
		
		
		  char[] Spacer = new char[]{'\n'};
		string[] Lexems = Lexems_List.Split(Spacer, StringSplitOptions.RemoveEmptyEntries);

//DBG.Print("\n\n------------------\n\n\n");
//DBG.Print(Lexems);
		
		
DBG.RETURN();
		return Lexems;
	}
// ==================================================
	string Clear_NewLine_Pack(string Str)
	{
DBG.ENTER("Clear_NewLine_Pack()");
		
		// Длина строки с исходником
		int Str_Len = Str.Length;
		
		string Out_Text = "";
	
		char Prev_Symbol = (char)0;
		
		// Перебор всех символов исходника
		for(int i = 0; i < Str_Len; i++)
		{
			// Вычитать один символ исходника
			char c = Str[i];
			
			if(c != '\n')
				Out_Text += c;
			else
			{
				if(Prev_Symbol != '\n')
					Out_Text += c;
			}
			
			Prev_Symbol = c;			
		}
		
DBG.RETURN();		
		return Out_Text;
	}

}


/* ██████████████████████████████████████████████████████████████████████████████████████████

           ████████  ██████  ██   ██ ███████ ███    ██ ██ ███████ ███████ ██████  
              ██    ██    ██ ██  ██  ██      ████   ██ ██    ███  ██      ██   ██ 
              ██    ██    ██ █████   █████   ██ ██  ██ ██   ███   █████   ██████  
              ██    ██    ██ ██  ██  ██      ██  ██ ██ ██  ███    ██      ██   ██ 
              ██     ██████  ██   ██ ███████ ██   ████ ██ ███████ ███████ ██   ██ 
                                                                                                                                                                             
   ██████████████████████████████████████████████████████████████████████████████████████████ */

class Tokenizer
{
	public Token[] Create_Token_List(string Src)
	{
DBG.ENTER("Create_Token_List()");
	
        Lexer Lex = new Lexer();

		string[] Lexems              = Lex.Split_to_Lexems(Src);
		Token [] Token_Array_Sructs  = Create_Token_Array (Lexems);	
		
DBG.RETURN();		
		return Token_Array_Sructs;
	}
	
// ==================================================================================
Token[] Create_Token_Array(string[] Lexems)
{
DBG.ENTER("Create_Token_Array()");
		
		Token[] Token_Array_Sructs = new Token[Lexems.Length + 2];
		
		for(int i = 0; i < Lexems.Length; i++)
		{
			string Lexem = Lexems[i];
			
			Token T = new Token();
			
			if     (Is_Punctuator    (Lexem) == true) { T.Type = T_Type.Punctuator;     T.Value = Lexem; }
			else if(Is_BuildInType   (Lexem) == true) { T.Type = T_Type.BuildInType;    T.Value = Lexem; }
			else if(Is_Number        (Lexem) == true) { T.Type = T_Type.Number;         T.Value = Lexem; }
			else if(Is_ControlKeyWord(Lexem) == true) { T.Type = T_Type.ControlKeyWord; T.Value = Lexem; }	
			else if(Is_Operation     (Lexem) == true) { T.Type = T_Type.Operation;      T.Value = Lexem; }	
			else if(Is_Identifier    (Lexem) == true) { T.Type = T_Type.Identifier;     T.Value = Lexem; }
			else if(Is_String        (Lexem) == true)
			{
				Lexem = Lexem.Remove(0, 1);
				Lexem = Lexem.Remove(Lexem.Length-1);
				
				T.Type = T_Type.Literal_String; 
				T.Value = Lexem;
			}
			else
				DBG.Src_ERROR_TRAP("Undef lexem type - " + Lexem);
			
			Token_Array_Sructs[i] = T;
		}
		
		Token T_EOF = new Token();
		T_EOF.Type  = T_Type.EOF;
		T_EOF.Value = "";	
		Token_Array_Sructs[Lexems.Length] = T_EOF;
	
DBG.Print("\n\n------------------\n\n\n");
DBG.Print(Token_Array_Sructs);
//DBG.Print("\n\n\n");
	
DBG.RETURN();
		return Token_Array_Sructs;
}
	

	// ========================================================
	bool Is_Punctuator(string Str)
	{
DBG.ENTER("Is_Punctuator()");

		
		if(Str == "(") goto m;
		if(Str == ")") goto m;
		if(Str == "{") goto m;
		if(Str == "}") goto m;
		if(Str == ";") goto m;
		if(Str == ".") goto m;
		if(Str == ",") goto m;
		if(Str == ":") goto m;

DBG.RETURN(); 		
		return false;		
m:
		
DBG.RETURN(); 		
		return true;
	}
	
	// ==========================================================
		static bool Is_BuildInType(string Str)
	{
DBG.ENTER("Is_BuildInType()");

			
		if(Str == "int")    { DBG.RETURN(); return true; }
		if(Str == "float")  { DBG.RETURN(); return true; }
		if(Str == "double") { DBG.RETURN(); return true; }
		if(Str == "char")   { DBG.RETURN(); return true; }
		if(Str == "void")   { DBG.RETURN(); return true; }

DBG.RETURN(); 		
		return false;
	}	
		
	// ==========================================================
	bool Is_ControlKeyWord(string Str)
	{
DBG.ENTER("Is_ControlKeyWord()");
DBG.RETURN(); 		
		
		if(Str == "if")      return true;
		if(Str == "else")    return true;
		if(Str == "while")   return true;
		if(Str == "for")     return true;
		if(Str == "do")      return true;
		if(Str == "goto")    return true;
		if(Str == "return")  return true;
        if(Str == "switch")  return true;
		if(Str == "case")    return true;
        if(Str == "default") return true;
		
		return false;
	}
	
	// ==========================================================
	bool Is_Operation(string Str)
	{
DBG.ENTER("Is_Operation()");
DBG.RETURN(); 		
		
		if(Str == "+")   return true;
		if(Str == "-")   return true;
		if(Str == "*")   return true;
		if(Str == "/")   return true;
		if(Str == "=")   return true;
		
		if(Str == "==")  return true;
		if(Str == "!=")  return true;
		if(Str == ">" )  return true;
		if(Str == "<" )  return true;
		if(Str == ">=")  return true;
		if(Str == "<=")  return true;		
		
		return false;
	}
	
	// ==========================================================
	// ВАЖНО - метод Is_Identifier(), должен вызываться только после Is_BuildInType() и Is_ControlKeyWord()
	bool Is_Identifier(string Str)
	{
DBG.ENTER("Is_Identifier()");
DBG.RETURN(); 
		
		// Длина строки с исходником
		int Str_Len = Str.Length;
		
		if(Str_Len == 0)
		{
			while(true); // ERROR TRAP
		}
		
		if(Char.IsDigit(Str[0]))
		   return false;
		
		// Перебор всех символов исходника
		for(int i = 0; i < Str_Len; i++)
		{
			// Вычитать один символ исходника
			char c = Str[i];
			
			if(c != '_' && Char.IsLetter(c) == false && Char.IsDigit(c) == false)
				return false;		
		}
/*
		if(Is_BuildInType(Str) == true)
		   return false;
		
		if(Is_ControlKeyWord(Str) == true)
			return false;
*/		
		return true;
	}
	
	// ==========================================================
	bool Is_Number(string Str)
	{
DBG.ENTER("Is_Number()");
DBG.RETURN(); 		
		
		if(Char.IsDigit(Str[0]))
		   	return true;
		else   
			return false;
	}	
			
	// ==========================================================
	bool Is_String(string Str)
	{
DBG.ENTER("Is_String()");
DBG.RETURN(); 
		 
		if(Str[0] == '"')
		   	return true;
		else   
			return false;
	}	
}

enum T_Type
{
	Punctuator,   
	BuildInType,   
	Number,        
	ControlKeyWord,
	Operation, 
	Identifier,
	Literal_String,
	EOF
}

struct Token
{
	public T_Type Type;
	public string Value;
}

​x
 
using System;
​
​
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████
​
                        ██████  ██████   ██████   ██████  ██████   █████  ███    ███ 
                        ██   ██ ██   ██ ██    ██ ██       ██   ██ ██   ██ ████  ████ 
                        ██████  ██████  ██    ██ ██   ███ ██████  ███████ ██ ████ ██ 
                        ██      ██   ██ ██    ██ ██    ██ ██   ██ ██   ██ ██  ██  ██ 
                        ██      ██   ██  ██████   ██████  ██   ██ ██   ██ ██      ██ 
                        
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */                                                                                                        
                                                                                     
​
public class Program
{
    public static int Main()
    {
DBG.Print_ON(); 
//DBG.View_Call_Tree_ON();
//DBG.Colored_Console_ON();
        
//Console.Write("\n  OS");
DBG.ENTER("Main()");
        
        Parser Parser_Obj = new Parser();
        
        Parser_Obj.Parse("Example.cpp");
        
DBG.RETURN(""); 
Console.Write("\n");
//Console.Write("  OS\n\n\n");
        
        return 58;
    }
}
​
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████
​
                        ██████   █████  ██████  ███████ ███████ ██████  
                        ██   ██ ██   ██ ██   ██ ██      ██      ██   ██ 
                        ██████  ███████ ██████  ███████ █████   ██████  
                        ██      ██   ██ ██   ██      ██ ██      ██   ██ 
                        ██      ██   ██ ██   ██ ███████ ███████ ██   ██ 
                                                                                                                                                
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */
​
​
class Parser
{
    string FileName;
    
    Token[] Token_List;
    
 // IR_V0_View_Info                   IR = new IR_V0_View_Info();
 // IR_V1_Generete_DEPL               IR = new IR_V1_Generete_DEPL();
 // IR_V2_Generete_CPP                IR = new IR_V2_Generete_CPP();
 // IR_V3_Generete_Destructured_DePL  IR = new IR_V3_Generete_Destructured_DePL();
 // IR_V4_Generete_Destructured_CPP   IR = new IR_V4_Generete_Destructured_CPP();
    IR_V5_Generete_DOT                IR = new IR_V5_Generete_DOT();
    
    // ==========================================================
    public void Parse(string Src)
    {
DBG.ENTER("Parse(Srs = \"" + Src + "\")");
    
        FileName = Src;
        
        Generate_Tokens_List();
        
        Parse_Glb_Scope();
​
DBG.RETURN();
    }
    
    // ==========================================================
    void Generate_Tokens_List()
    {
DBG.ENTER("Generate_Tokens_List()");
​
//DBG.View_Call_Tree_OFF();
        
        // В строковую переменную, занести необходимый исходник
        string Src = Get_Src();
        
        Tokenizer T = new Tokenizer();      
        
        Token_List = T.Create_Token_List(Src);
​
//DBG.View_Call_Tree_ON();  
        
DBG.RETURN();
    }
    
    // =========================================================================
    static string Get_Src()
    {
DBG.ENTER("Get_Src()");
        
        string Src = Get_Src2();
        
            
DBG.Print("\n\n---------------------\n\n");
DBG.Print(Src);
        
DBG.RETURN();       
        return Src;
    }
    
    
    // =========================================================================
    static string Get_Src1()
    {
DBG.ENTER("Get_Src1()");
        
        string Src = "int main()\n" +
                     "{\n"          +
                     "    f1();\n"  +
                     "    f3(25);\n"+
                     "\n" +
                     "DBG.Print(\"No                      problem!!!\");\n"+
                     "};\n"+
                     "\n" +
                     "\n" +         
                     "void f1(void)\n" +
                     "{\n"             +
                     "    if(a == 2)\n"+
                     "        b = -3.18;\n"+
                     "};\n";
            
DBG.RETURN();       
        return Src;
    }
    
    
    // =========================================================================
    static string Get_Src2()
    {
DBG.ENTER("Get_Src2()");
        
        string Src = "int   Data_1;\n" +
                     "float Data_2;\n\n" +
                     "double Data_3 = 3;\n\n" + 
                     "int main(int a, int b, float X, double Y2)\n"+
                     "{\n" +
                     "    int a = 125;\n\n" +
            
                   //  "    for(int a = 10; a > 0; int a = a-1)\n" +
                   //  "    {\n" +
                   //  "        int a = 125;\n" +
                   //  "    };\n\n" +  
            //*
                     "    while(a > b)\n" +
                     "    {\n" +
                     "        int a = 125;\n" +
                     "        double b;\n" +
 
                     "        while(a > b)\n" +     // while in while
                     "        {\n" +
                     "            int x = 456;\n" +
                     "        };\n\n" + 
            
                     "    };\n\n" + 
            //*/
            
            //*
                     "    while(r > x)\n" +     
                     "    {\n" +
                     "        int x = 456;\n" +
                     "    };\n\n" +             
            //*/
                     "    do\n" +
                     "    {\n" +
                     "        int a = 125;\n" +
                     "    } while(x > y);\n\n" + 
​
                     "\n    switch(a)\n"+
                     "    {\n" +
​
                     "     case 5: \n" +
                     "             int a;\n" + 
                     "             int b;\n" +
                     "\n" +
                     "             switch(z)\n"+
                     "             {\n" +
​
                     "             case 5: \n" +
                     "                      int a;\n" + 
                     "                      int b;\n" +             
                     "                      break;\n" +
                     "             case 7: \n" +
                     "                      int c;\n" + 
                     "                      int d;\n" +             
                     //"                   break;\n" +
                     "             case 9: \n" +
                     "                     int e;\n" + 
                     //"                   break;\n" +
                     "             default:\n" +
                     "                   int f;\n" + 
                     //"                 int g;\n" +                
                    // "                 break;\n" +
​
                     "            }\n\n" +          
            
                     "             break;\n" +
                     "     case 7: \n" +
                     "             int c;\n" + 
                     "             int d;\n" +          
                     //"             break;\n" +
                     "     case 9: \n" +
                     "             int e;\n" + 
                     //"             break;\n" +
                     "     default:\n" +
                     "             int f;\n" + 
                     //"             int g;\n" +                
                    // "              break;\n" +
​
                     "    }\n\n" +
​
​
                     "    int    Data_A;\n" +
                     "    double Data_B = 25.45;\n\n" + 
                     "    if(x > y)\n" + 
                     "    {\n"+ 
                     "        if(x < y)\n" +
                     "        {\n" +  
                     "            int a = b;\n\n" +
                     "            if(a >= x)\n" + 
                     "                int x = 25;\n" + 
                     "            else\n" + 
                     "            {\n" +
                   //  "                int x = 41;\n" +
                     "            }\n"+
                     "        }\n" +
                     "        else\n" +
                     "            int a = c;\n\n" +
                     "    }\n"+
                     "    return 0;\n"+
                     "};\n\n" + 
                     "void f1(void)\n"+
                     "{\n"+
                     "    int a = 5;\n\n" +
                     "    goto Lb_1;\n" +
                     "    return;\n" +
                     " };"; 
        
DBG.RETURN();       
        return Src;
    }
​
    // ==========================================================
    void Parse_Glb_Scope()
    {
DBG.ENTER("Parse_Glb_Scope()");
    
        IR.START();
        
        while(true)
        {
            IR.Next_Sentence_in_global_scope();
            
            Token T = Get_Next_Token();
        
            if(T.Type == T_Type.EOF)
            {   
                DBG.RETURN("");
                
                return;
            }
                    
            Parse_Sentence();
        }
​
//DBG.RETURN("");
​
    }
    
    int Index_Next_Token = 0; 
​
    // ==========================================================
    Token Get_Next_Token()
    {
DBG.ENTER("Get_Next_Token()");
​
        Token Ret = Token_List[Index_Next_Token];
​
        Index_Next_Token++;
​
//DBG.RETURN("");
DBG.RETURN("<- Type = " + Ret.Type + "; Value = \"" + Ret.Value + "\"");
        return Ret;
    }
    
    // ==========================================================
    void Back_Token()
    {
DBG.ENTER("Back_Token()");
​
        Index_Next_Token--;
​
DBG.RETURN("");
    }
​
    // ==========================================================
    void Parse_Sentence()
    {
DBG.ENTER("Parse_Sentence()");  
        
        // В Parse_Sentence(), вошли с одним "лишним" сдвигом индекса токенов
        // Откатываем назад совершенное ранее упреждающее чтение.
        Back_Token();
        
        Token T = Get_Next_Token();
        
        if     (T.Type  == T_Type.BuildInType)    Parse_Sentence_Type();    // Предложение, которое начинается с типа
        else if(T.Type  == T_Type.ControlKeyWord) Parse_Sentence_Control(); // Предложение, которое начинается с управляющей конструкции
        else if(T.Value == "class")               Parse_Sentence_Class();   // Предложение, которое начинается с ключевого слова "class"
        else if(T.Value == "struct")              Parse_Sentence_Struct();  // Предложение, которое начинается с ключевого слова "struct"
        else if(T.Value == "{")                   Parse_Block();            // Парсим блок
        else 
            DBG.Src_ERROR_TRAP("Undef type of Sentence - Token.Type = " + T.Type + "; Token.Value =" + T.Value);
        
DBG.RETURN("");
    }
​
​
    void Parse_Block()
    {
DBG.ENTER("Parse_Block()");
​
        // Предвыбрать один токен
        Token T = Get_Next_Token();
        
        // Проверка на пустой блок кода
        if(T.Value == "}") 
            return;
​
        do
        {
            Parse_Sentence();
​
            T = Get_Next_Token();
        }while(T.Value != "}");
​
DBG.RETURN(""); 
    }
​
    
    // ==========================================================
    void Parse_Sentence_Type()
    {
DBG.ENTER("Parse_Sentence_Type()");
​
        Token T = Get_Next_Token(); // reading Id
        
        T = Get_Next_Token();
        
        switch(T.Value)
        {
            case ";": Parse_Var();               break;
            case "=": Parse_Var_w_Init();        break;
            case "(": Parse_Definite_Function(); break;
            default: 
                DBG.Src_ERROR_TRAP("ERROR in Parse_Sentence_Type()"); break;
        }
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Sentence_Control()
    {
DBG.ENTER("Parse_Sentence_Control()");
​
        // В Parse_Sentence_Control(), вошли с одним "лишним" сдвигом индекса токенов
        // Откатываем назад совершенное ранее упреждающее чтение.
        Back_Token();
​
        Token T = Get_Next_Token(); 
        
        switch(T.Value)
        {
            case "if":     Parse_Control_IF();     break;
            case "goto":   Parse_Control_GOTO();   break;
            case "return": Parse_Control_RETURN(); break;
            case "switch": Parse_Control_SWITCH(); break;
            case "do":     Parse_Control_DO();     break;
            case "while":  Parse_Control_WHILE();  break;
            case "for":    Parse_Control_FOR();    break;
            default: 
                DBG.Src_ERROR_TRAP("ERROR in Parse_Sentence_Control()"); break;
        }
        
DBG.RETURN("");
    }
​
    // ======================================================================================
    void Parse_Control_IF()
    {
DBG.ENTER("Parse_Control_IF()");
​
        Token T1 = Get_Next_Token();
        Token T2 = Get_Next_Token();
        Token T3 = Get_Next_Token();
        Token T4 = Get_Next_Token();
        Token T5 = Get_Next_Token();
​
        IR.CMD_IF(T2.Value, T3.Value, T4.Value);
      
        Get_Next_Token(); // предвыборка одного токена
        Parse_Sentence();
        
        // Проверка на else
        Token T6 = Get_Next_Token();
        
        if(T6.Value == "else")
        {
            IR.CMD_ELSE();
            
            Get_Next_Token(); // предвыборка одного токена
            Parse_Sentence();           
        }
        else
            Back_Token();
        
        
        IR.CMD_IF_END();
​
    DBG.RETURN("");
    }
​
    // ==========================================================
    void Parse_Control_GOTO()
    {
DBG.ENTER("Parse_Control_GOTO()");  
​
        Token T1 = Get_Next_Token(); // Label
        Token T2 = Get_Next_Token(); // ;
        
        IR.GOTO(T1.Value);      
        
DBG.RETURN("");     
    }
    
        // ==========================================================
    void Parse_Control_RETURN()
    {
DBG.ENTER("Parse_Control_RETURN()");    
​
        Token T1 = Get_Next_Token();
        
        if(T1.Value == ";") // варинт - "return;"
        {
            IR.RETURN_VOID();
        }
        else               // вариант - "return value;"
        {
            Token T2 = Get_Next_Token();
​
            IR.RETURN_w_Value(T1.Value);
        }       
        
DBG.RETURN("");     
    }
        
    // ======================================================================================
    void Parse_Control_SWITCH()
    {
DBG.ENTER("Parse_Control_SWITCH()");
​
                  Get_Next_Token(); // (
        Token T = Get_Next_Token(); // value
                  Get_Next_Token(); // )
                  Get_Next_Token(); // {
        
        IR.CMD_SWITCH_START(T.Value);
        
​
        // Проверка на пустой switch
        T = Get_Next_Token();
        if(T.Value == "}")
            DBG.Src_ERROR_TRAP("ERROR in Parse_Control_SWITCH() - free switch");
​
        Back_Token();
​
        // Перебор всех веток
        while(true)
        {
            T = Get_Next_Token();
            
            if(T.Value == "case")
            {
                T = Get_Next_Token(); // значение case-ветки
                
                IR.SWITCH_CASE(T.Value);
                
                Get_Next_Token(); // пропуск двоеточия
​
                // Цикл выборки предложений в текущей case-ветке 
                while(true)
                {
                    T = Get_Next_Token();
​
                    // Если текущая ветка окончена
                    if(T.Value == "case" || T.Value == "default" || T.Value == "}")
                    {
                       Back_Token();
​
                       break; // Вернуться в цикл выборки case-веток 
                    }
​
                    if(T.Value == "break")
                    {
                        IR.BREAK_IN_SWITCH();
                        
                        Get_Next_Token(); // пропуск точки с запятой, который после break
                    }
                    else
                        Parse_Sentence();
                }
            }
            else if(T.Value == "default")
            {
                IR.SWITCH_DEFAULT();
​
                Get_Next_Token(); // пропуск двоеточия
                
                // Цикл выборки предложений в текущей default-ветке 
                while(true)
                {
                    T = Get_Next_Token();
​
                    // Если текущая ветка окончена
                    if(T.Value == "}")
                    {
                       Back_Token();
​
                       break; // Вернуться в цикл выборки case-веток 
                    }
​
                    // Проверка синтаксических недопустимостей
                    if(T.Value == "case")
                        DBG.Src_ERROR_TRAP("ERROR in Parse_Control_SWITCH() - \"case\", after \"default\"");
​
                    if(T.Value == "default")
                        DBG.Src_ERROR_TRAP("ERROR in Parse_Control_SWITCH() - \"default\", after \"default\"");
​
                    // Корректный код
                    if(T.Value == "break")
                    {
                        IR.BREAK_IN_SWITCH();
                        
                        Get_Next_Token(); // пропуск точки с запятой, который после break
                    }
                    else
                        Parse_Sentence();
                }
                
            }
            else if(T.Value == "}")
            {
                IR.SWITCH_END();
​
                break; // Прервать цикр перебора веток  
            }
            else
            {
                DBG.Src_ERROR_TRAP("ERROR in Parse_Control_SWITCH()");  
            }
        
        } // while(true) - Перебор всех веток
            
​
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Control_DO()
    {
        IR.DO_START();
​
       Get_Next_Token(); // Предвыборка одного токена
       Parse_Sentence();
​
                        Get_Next_Token(); // вычитать while
                        Get_Next_Token(); // вычитать (
        Token Op1     = Get_Next_Token(); // вычитать первый операнд
        Token CmpSign = Get_Next_Token(); // вычитать операцию сравнения
        Token Op2     = Get_Next_Token(); // вычитать второй операнд
                        Get_Next_Token(); // вычитать )
                        Get_Next_Token(); // вычитать ;
​
        IR.DO_END(Op1.Value, CmpSign.Value, Op2.Value);
​
    }
​
    // ==========================================================
    void Parse_Control_WHILE()
    {
                        Get_Next_Token(); // вычитать (
        Token Op1     = Get_Next_Token(); // вычитать первый операнд
        Token CmpSign = Get_Next_Token(); // вычитать операцию сравнения
        Token Op2     = Get_Next_Token(); // вычитать второй операнд
                        Get_Next_Token(); // вычитать )
​
        IR.WHILE_START(Op1.Value, CmpSign.Value, Op2.Value);
​
        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence();
​
        IR.WHILE_END();
​
        Get_Next_Token(); // вычитать ;
    }
​
    // ==========================================================
    // Костыль
    void Parse_Control_FOR()
    {
        if(IR.GetType().Name == "IR_V2_Generete_CPP")
            Parse_Control_FOR_V2();
        else
            Parse_Control_FOR_destructured();
    }
​
    // ==========================================================
    // Версия только для IR_V2_Generete_CPP
    void Parse_Control_FOR_V2()
    {
        Get_Next_Token(); // вычитать (
​
        DBG.Print("\n\n// FOR-loop START ---------------------");
        DBG.Print("\n{  // isolate variables\n");
        
        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence();
​
        Token Op1     = Get_Next_Token(); // вычитать первый операнд
        Token CmpSign = Get_Next_Token(); // вычитать операцию сравнения
        Token Op2     = Get_Next_Token(); // вычитать второй операнд 
                        Get_Next_Token(); // вычитать ;
​
       IR.WHILE_START(Op1.Value, CmpSign.Value, Op2.Value);
​
       // Запомнить текущий указатель токена
       int TMP1 = Index_Next_Token;
​
        // проскочить третий параметр for-цикла
​
       Token T;
​
       do
       {
           T = Get_Next_Token();
       }while(T.Value != ")");
​
​
        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence(); // Тело цикла
​
       // Запомнить текущий указатель токена
       int TMP2 = Index_Next_Token;
​
       Index_Next_Token = TMP1;
​
        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence(); // Тело цикла
​
        
        Index_Next_Token = TMP2;
​
        IR.WHILE_END();
​
        DBG.Print("\n}");
        DBG.Print("\n// FOR-loop END ---------------------");
​
        Get_Next_Token(); // вычитать ;             
    }
​
​
    // ==========================================================
    void Parse_Control_FOR_destructured()
    {
        Get_Next_Token(); // вычитать (
​
        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence();
​
        Token Op1     = Get_Next_Token(); // вычитать первый операнд
        Token CmpSign = Get_Next_Token(); // вычитать операцию сравнения
        Token Op2     = Get_Next_Token(); // вычитать второй операнд 
                        Get_Next_Token(); // вычитать ;
​
       IR.FOR_START(Op1.Value, CmpSign.Value, Op2.Value);
​
       // Запомнить текущий указатель токена
       int TMP1 = Index_Next_Token;
​
        // проскочить третий параметр for-цикла
​
       Token T;
​
       do
       {
           T = Get_Next_Token();
       }while(T.Value != ")");
​
        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence(); // Тело цикла
​
       // Запомнить текущий указатель токена
       int TMP2 = Index_Next_Token;
​
       Index_Next_Token = TMP1;
​
        Get_Next_Token(); // Предвыборка одного токена
        Parse_Sentence(); // Тело цикла
​
        
        Index_Next_Token = TMP2;
​
        IR.FOR_END();
​
        Get_Next_Token(); // вычитать ;
​
    }
​
    // ==========================================================
    void Parse_Sentence_Class()
    {
DBG.ENTER("Parse_Sentence_Class()");
​
​
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Sentence_Struct()
    {
DBG.ENTER("Parse_Sentence_Struct()");
​
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Var()
    {
DBG.ENTER("Parse_Var()");
​
        // В Parse_Var(), вошли с тремя "лишним" предпросмотрами токенов
        Back_Token();
        Back_Token();
        Back_Token();
​
        Token Var_Type = Get_Next_Token();
        Token Var_Name = Get_Next_Token();
        
        // Send to Intermediate Representation
        IR.Def_Variable(Var_Type.Value, Var_Name.Value);
        
        Get_Next_Token();
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Var_w_Init()
    {
DBG.ENTER("Parse_Var_w_Init()");
​
        // В Parse_Var_w_Init(), вошли с тремя "лишним" предпросмотрами токенов
        Back_Token();
        Back_Token();
        Back_Token();
        
        Token Var_Type = Get_Next_Token();
        Token Var_Name = Get_Next_Token();
        
        Get_Next_Token();
        
        Token Var_Init_Value = Get_Next_Token();
        
        Get_Next_Token();
        
        // Send to Intermediate Representation
        IR.Def_Variable(Var_Type.Value, Var_Name.Value, Var_Init_Value.Value);
        
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Definite_Function()
    {
DBG.ENTER("Parse_Definite_Function()");
​
        // В Parse_Definite_Function(), вошли с тремя "лишним" сдвигами индекса токенов
        Back_Token();
        Back_Token();
        Back_Token();
        
        Token Ret_Type  = Get_Next_Token();
        Token Func_Name = Get_Next_Token();
        
        Get_Next_Token(); // опять вычитать "("
        
        IR.Define_Function_START(Func_Name.Value, Ret_Type.Value);
        
        Parse_Arg_List();
        Parse_in_Function_Body();
        
        IR.Def_Function_END();
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Arg_List()
    {
DBG.ENTER("Parse_Arg_List()");
        
        Token T =  Get_Next_Token();
        
        // Если у функции нет параметров
        if(T.Value == "void")
        {
            Get_Next_Token();
            
            //DBG.Print("\n\nArgList is void");
        }
        else
        {
            Back_Token();
            
            do
            {
                Token Param_Type = Get_Next_Token(); 
                Token Param_Name = Get_Next_Token(); 
​
                
                IR.Function_NextArg(Param_Name.Value,  Param_Type.Value);
​
                T = Get_Next_Token(); 
            }   
            while(T.Value == ",");
        }
        
        IR.Function_ArgList_END();
                        
DBG.RETURN("");
    }
    
    //  ==========================================================
    void Parse_in_Function_Body()
    {
DBG.ENTER("Parse_in_Function_Body()");
​
        Get_Next_Token(); // вычитать "{"
​
        while(true)
        {
            Token T = Get_Next_Token(); // Вычитать следующий токен
        
            if(T.Value == "}")
                break;
            
            Parse_Sentence();
        }
        
        
        Get_Next_Token(); // вычитать ";"
        
        //DBG.Print("\n\nParse_Function_Body() ==> body is empty\n");
        
DBG.RETURN("");
    }
}
​
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████
​
                ██ ██████         ██    ██  ██████          ██ ███    ██ ███████  ██████  
                ██ ██   ██        ██    ██ ██  ████         ██ ████   ██ ██      ██    ██ 
                ██ ██████         ██    ██ ██ ██ ██         ██ ██ ██  ██ █████   ██    ██ 
                ██ ██   ██         ██  ██  ████  ██         ██ ██  ██ ██ ██      ██    ██ 
                ██ ██   ██ ███████  ████    ██████  ███████ ██ ██   ████ ██       ██████  
                                                                                                                                                                                                                                                           
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */
​
class IR_V0_View_Info
{
    // string ResultStr;
    
    // ===================================================================================
    public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V0.Next_Sentence_in_global_scope()");
    
        DBG.Print("\n\nNext sentence in GLOBAL SCOPE\n", ConsoleColor.Yellow);
​
    DBG.RETURN("");
    }
​
    // ===================================================================================
    public void Def_Variable(string Type, string Name)
    {
    DBG.ENTER("IR_V0.Def_Variable(T, N)");
        
        DBG.Print("\n\nParse_Var()\n");
        DBG.Print("\n  Type = " + Type);
        DBG.Print("\n  Name = \"" + Name + "\"\n");
        
    DBG.RETURN("");
    }
​
    // ===================================================================================
    public void Def_Variable(string Type, string Name, string InitValue)
    {
    DBG.ENTER("IR_V0.Def_Variable(T, N, V)");
        
        DBG.Print("\n\nParse_Var_w_Init()\n");
        DBG.Print("\n  Type       = "   + Type);
        DBG.Print("\n  Name       = \"" + Name + "\"");
        DBG.Print("\n  Init_Value = "   + InitValue + "\n");
        
    DBG.RETURN("");
    } 
// -------
    // ===================================================================================
    public void CMD_IF(string Op1, string Sign, string Op2)
    {
        DBG.Print("\n\n\nIF start\n");
        DBG.Print("\n  Cond = " + Op1 + Sign + Op2);        
    }
    
    // ===================================================================================
    public void CMD_ELSE()
    {
        DBG.Print("\n\n\nELSE-branch\n");
    }
    
    // ===================================================================================
    public void CMD_IF_END()
    {
        DBG.Print("\nIF end\n");
    }
    
    // ===================================================================================
    public void GOTO(string Lb_Name)
    {
        DBG.Print("\ngoto " + Lb_Name + ";");
    }
    
    // ===================================================================================
    public void RETURN_VOID()
    {
        DBG.Print("\nreturn;");
    }
    
    // ===================================================================================
    public void RETURN_w_Value(string Value)
    {
        DBG.Print("\nreturn " + Value + ";");
    }
    
    int Param_Cnt;
    
    // ===================================================================================
    public void Define_Function_START(string Func_Name, string Ret_Type)
    {
        DBG.Print("\n\nParse_Definite_Function()");
        DBG.Print("\n  Ret_Type  = " + Ret_Type);
        DBG.Print("\n  Func_Name = " + Func_Name + "\n");
        
        Param_Cnt = 1;
    }
    
    // ===================================================================================
    public void Def_Function_END()
    {
        DBG.Print("\nFunction definit is end");
    }   
    
    // ===================================================================================
    public void Function_NextArg(string Param_Name,  string Param_Type)
    {   
        DBG.Print("\n\nParam #"+ Param_Cnt + ":");
        DBG.Print("\n   Type = " + Param_Type); 
        DBG.Print("\n   Name = \"" + Param_Name + "\"\n");
        
        Param_Cnt++;
    }
    
    // ===================================================================================
    public void Function_ArgList_END()
    {
        DBG.Print("\nArgList is end");      
    }
    
    
    // ===================================================================================
    public void CMD_SWITCH_START(string SwitchValue)
    {
        DBG.Print("\nCMD_SWITCH_START, Param = " + SwitchValue);    
    }
    
    // ===================================================================================
    public void SWITCH_CASE(string CaseValue)
    {
        DBG.Print("\nSWITCH_CASE, Param = " + CaseValue);   
    }
    
    // ===================================================================================
    public void BREAK_IN_SWITCH()
    {
        DBG.Print("\nBREAK_IN_SWITCH"); 
    }
    
    // ===================================================================================
    public void SWITCH_DEFAULT()
    {
        DBG.Print("\nSWITCH_DEFAULT");  
    }
    
    // ===================================================================================
    public void SWITCH_END()
    {
        DBG.Print("\nSWITCH_END");  
    }   
}
​
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████
​
                ██ ██████         ██    ██  ██         ██████  ███████ ██████  ██      
                ██ ██   ██        ██    ██ ███         ██   ██ ██      ██   ██ ██      
                ██ ██████         ██    ██  ██         ██   ██ █████   ██████  ██      
                ██ ██   ██         ██  ██   ██         ██   ██ ██      ██      ██      
                ██ ██   ██ ███████  ████    ██ ███████ ██████  ███████ ██      ███████ 
                                                                                                                                                                                                                                                                                                                                                                           
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */
​
class IR_V1_Generete_DEPL
{
    //string ResultStr;
        
    // ===================================================================================
    public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V1.Next_Sentence_in_global_scope()");
    
​
    // ===================================================================================  
    DBG.RETURN("");
    }
    
    int TabLevel = 0;
    
    // ===================================================================================
    string TabSpaser()
    {
        string Str = "";
        
        for(int i = 0; i < TabLevel; i++)
            Str += "│   "; // · | │
        
        return Str;
    }
    
    // ===================================================================================
    public void Def_Variable(string Type, string Name)
    {
    DBG.ENTER("IR_V1.Def_Variable(T, N)");
        
        DBG.Print("\n" + TabSpaser() + Name + " " + ConvertType(Type));
        
    DBG.RETURN("");
    }
​
    // ===================================================================================
    public void Def_Variable(string Type, string Name, string InitValue)
    {
    DBG.ENTER("IR_V1.Def_Variable(T, N, V)");
                
        if(Type == "double" || Type == "float")
        {
            // Задано целое значение, то привести его к виду с точкой, 
            // иначе DePL сгенерирует неверный тип для переменной (int вместо double)
            if(InitValue.Contains('.') == false)
                InitValue = InitValue + ".0";               
        }   
        
        DBG.Print("\n" + TabSpaser() + Name + " = " + InitValue);
        
    DBG.RETURN("");
    } 
    
    bool First_Arg;
    
    string RT;
    
    // ===================================================================================
    public void Define_Function_START(string FuncName, string RetutnType)
    {
    DBG.ENTER("IR_V1.Define_Function_START()");
        
        DBG.Print("\n\n\n");
        DBG.Print(TabSpaser() + "ФУНКЦІЯ " + FuncName + "(");
        
        // Запомнить тип. Он будет использован позже
        RT = RetutnType;
        
        First_Arg = true;
        
        TabLevel++;
        
    DBG.RETURN("");     
    }
    
    // ===================================================================================
    public void Function_NextArg(string Param_Name,  string Param_Type)
    {
    DBG.ENTER("IR_V1.Function_NextArg()");
        
        if(First_Arg == true)
            DBG.Print(Param_Name + " " + ConvertType(Param_Type)); // без запятой перед параметром
        else
        {
         // DBG.Print(", " + Param_Name + " " + ConvertType(Param_Type)); // версия в одну строку
            DBG.Print(", " + Param_Name + " " + ConvertType(Param_Type)); // версия в много строк
        }
        
        First_Arg = false;
        
    DBG.RETURN(""); 
    }
    
    // ===================================================================================
    public void Function_ArgList_END()
    {
DBG.ENTER("IR_V1.Function_ArgList_END()");
        
        string Type_in_DePL = ConvertType(RT);
        
        DBG.Print(") " + Type_in_DePL);
        
        DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void Def_Function_END()
    {
DBG.ENTER("IR_V1.Def_Function_END()");
        
        DBG.Print("\n" + TabSpaser());
        
        TabLevel--;     
​
        DBG.Print("\n" + TabSpaser() + "ФІНІШ");    
        
​
        
DBG.RETURN("");
    }   
    
    // ===================================================================================
    public void RETURN_w_Value(string Value)
    {
DBG.ENTER("IR_V1.RETURN_w_Value()");        
        
        DBG.Print("\n" + TabSpaser() + "ВЕРНУТИСЬ " + Value);
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void RETURN_VOID()
    {
DBG.ENTER("IR_V1.RETURN_VOID()");   
        
        DBG.Print("\n" + TabSpaser() + "ВЕРНУТИСЬ");
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void GOTO(string Lb_Name)
    {
DBG.ENTER("IR_V1.GOTO()");  
        
        DBG.Print("\n --------------------- PROBLEM!!! ---------------------------");
        DBG.Print("\n -------------- DePL not supported \"goto\" -------------------");
        
DBG.RETURN("");
    }
​
    // ===================================================================================
    public void CMD_IF(string Op1, string CmpSign, string Op2)
    {
DBG.ENTER("IR_V1.CMD_IF()");
        
        DBG.Print("\n" + TabSpaser());
        DBG.Print("\n" + TabSpaser() + "ЯКЩО " + Op1 + " " + CmpSign + " " + Op2);
        
        TabLevel++;
        
        DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void CMD_ELSE()
    {
DBG.ENTER("IR_V1.CMD_ELSE()");      
        
​
        DBG.Print("\n" + TabSpaser());
        
        TabLevel--;
​
        DBG.Print("\n" + TabSpaser() + "ІНАКШЕ");
        
        TabLevel++;
        
        DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void CMD_IF_END()
    {
DBG.ENTER("IR_V1.CMD_IF_END()");    
        
        
        DBG.Print("\n" + TabSpaser());
        
        TabLevel--;
        DBG.Print("\n" + TabSpaser() + "КІНЕЦЬ");
        DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
    
    // ===================================================================================
    string ConvertType(string type)
    {
    DBG.ENTER("IR_V1.ConvertType()");
    DBG.RETURN("");
    
        switch(type)
        {
            case "void"  : return "void"; 
            case "int"   : return "int";
            case "float" : return "double";
            case "double": return "double";
            default:       return "?";
        }   
    }
    
    // ===================================================================================
    public void CMD_SWITCH_START(string SwitchValue)
    {
        DBG.Print("\n" + TabSpaser() + "ПЕРЕМИКАЧ " + SwitchValue); 
        
        TabLevel++;
        TabLevel++;
    }
    
    // ===================================================================================
    public void SWITCH_CASE(string CaseValue)
    {
        TabLevel--;     
        
        DBG.Print("\n" + TabSpaser() + "ВАРIАНТ " + CaseValue); 
        
        TabLevel++;
    }
    
    // ===================================================================================
    public void BREAK_IN_SWITCH()
    {
        DBG.Print("\n" + TabSpaser() + "BREAK");
    }
    
    // ===================================================================================
    public void SWITCH_DEFAULT()
    {
        TabLevel--;
        
        DBG.Print("\n" + TabSpaser() + "IНШЕ"); 
        
        TabLevel++;
    }
    
    // ===================================================================================
    public void SWITCH_END()
    {
        TabLevel--;
        TabLevel--;
        
        DBG.Print("\n" + TabSpaser() + "КIНЕЦЬ\n"); 
    }   
}
​
​
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████
​
                ██ ██████         ██    ██ ██████           ██████ ██████  ██████  
                ██ ██   ██        ██    ██      ██         ██      ██   ██ ██   ██ 
                ██ ██████         ██    ██  █████          ██      ██████  ██████  
                ██ ██   ██         ██  ██  ██              ██      ██      ██      
                ██ ██   ██ ███████  ████   ███████ ███████  ██████ ██      ██                                                                                                                                                                                                                                                                                                                                                 
                                                                                                                                                                                                                            
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */
​
class IR_V2_Generete_CPP
{
    // string ResultStr;
        
    // ===================================================================================
    public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V2.Next_Sentence_in_global_scope()");
    
​
    // ===================================================================================  
    DBG.RETURN("");
    }
    
    int TabLevel = 0;
    
    // ===================================================================================
    string TabSpaser()
    {
        string Str = "";
        
        for(int i = 0; i < TabLevel; i++)
            Str += "    "; // · | │
        
        return Str;
    }
    
    // ===================================================================================
    public void Def_Variable(string Type, string Name)
    {
    DBG.ENTER("IR_V2.Def_Variable(T, N)");
        
        DBG.Print("\n" + TabSpaser() + Type + " " + Name + ";");
        
    DBG.RETURN("");
    }
​
    // ===================================================================================
    public void Def_Variable(string Type, string Name, string InitValue)
    {
    DBG.ENTER("IR_V2.Def_Variable(T, N, V)");
                
    
        DBG.Print("\n" + TabSpaser() + Type + " " + Name + " = " + InitValue + ";");
        
    DBG.RETURN("");
    } 
    
    bool First_Arg;
    
    
    // ===================================================================================
    public void Define_Function_START(string FuncName, string RetutnType)
    {
    DBG.ENTER("IR_V1.Define_Function_START()");
        
        DBG.Print("\n\n\n");
        DBG.Print(TabSpaser() + RetutnType + " " + FuncName + "(");
        
        
        First_Arg = true;
        
        TabLevel++;
        
    DBG.RETURN("");     
    }
    
    // ===================================================================================
    public void Function_NextArg(string Param_Name,  string Param_Type)
    {
    DBG.ENTER("IR_V1.Function_NextArg()");
        
        if(First_Arg == true)
            DBG.Print(Param_Type + " " + Param_Name); // без запятой перед параметром
        else
            DBG.Print(", " + Param_Type + " " + Param_Name); // версия в много строк
        
        First_Arg = false;
        
    DBG.RETURN(""); 
    }
    
    // ===================================================================================
    public void Function_ArgList_END()
    {
DBG.ENTER("IR_V1.Function_ArgList_END()");
        
        // Если нет ни одного аргумента
        if(First_Arg == true)
            DBG.Print("void");
        
        DBG.Print(")\n{" + TabSpaser());
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void Def_Function_END()
    {
DBG.ENTER("IR_V1.Def_Function_END()");
        
        
        TabLevel--;     
​
        DBG.Print("\n" + TabSpaser() + "}");    
        
​
        
DBG.RETURN("");
    }   
    
    // ===================================================================================
    public void RETURN_w_Value(string Value)
    {
DBG.ENTER("IR_V1.RETURN_w_Value()");        
        
        DBG.Print("\n" + TabSpaser() + "return " + Value + ";");
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void RETURN_VOID()
    {
DBG.ENTER("IR_V1.RETURN_VOID()");   
        
        DBG.Print("\n" + TabSpaser() + "return;");
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void GOTO(string Lb_Name)
    {
DBG.ENTER("IR_V1.GOTO()");  
        
        DBG.Print("\n" + TabSpaser() + "goto " + Lb_Name + ";");
        
DBG.RETURN("");
    }
​
    // ===================================================================================
    public void CMD_IF(string Op1, string CmpSign, string Op2)
    {
DBG.ENTER("IR_V1.CMD_IF()");
        
        DBG.Print("\n" + TabSpaser());
        DBG.Print("\n" + TabSpaser() + "if(" + Op1 + " " + CmpSign + " " + Op2 + ")");
        
        DBG.Print("\n" + TabSpaser() + "{");
        
        TabLevel++;
        
​
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void CMD_ELSE()
    {
DBG.ENTER("IR_V1.CMD_ELSE()");      
        
​
        //DBG.Print("\n" + TabSpaser());
        
        TabLevel--;
​
        DBG.Print("\n" + TabSpaser() + "}");
        
        DBG.Print("\n" + TabSpaser() + "else");
        
        DBG.Print("\n" + TabSpaser() + "{");
        
        TabLevel++;
        
        //DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void CMD_IF_END()
    {
DBG.ENTER("IR_V1.CMD_IF_END()");    
        
        
    
        TabLevel--;
        DBG.Print("\n" + TabSpaser() + "}");
        DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
        // ===================================================================================
    public void CMD_SWITCH_START(string SwitchValue)
    {
        DBG.Print("\n\n" + TabSpaser() + "switch(" + SwitchValue + ")\n"+ TabSpaser() + "{");   
        
        TabLevel++;
        TabLevel++;
    }
    
    // ===================================================================================
    public void SWITCH_CASE(string CaseValue)
    {
        TabLevel--;     
        
        DBG.Print("\n" + TabSpaser() + "case " + CaseValue + ":");  
        
        TabLevel++;
    }
    
    // ===================================================================================
    public void BREAK_IN_SWITCH()
    {
        DBG.Print("\n" + TabSpaser() + "break;");
    }
    
    // ===================================================================================
    public void SWITCH_DEFAULT()
    {
        TabLevel--;
        
        DBG.Print("\n" + TabSpaser() + "default:"); 
        
        TabLevel++;
    }
    
    // ===================================================================================
    public void SWITCH_END()
    {
        TabLevel--;
        TabLevel--;
        
        DBG.Print("\n" + TabSpaser() + "}\n");  
    }   
​
    // ===================================================================================
    public void DO_START()
    {
        DBG.Print("\n\n" + TabSpaser() + "do\n" + TabSpaser() + "{");
        
        TabLevel++;
​
    }
​
    // ===================================================================================
    public void DO_END(string Op1, string CmpSign, string Op2)
    {
        TabLevel--;
        
        DBG.Print("\n" + TabSpaser() + "}while(" + Op1 + " " + CmpSign + " " + Op2 + ");"); 
    }
​
    // ===================================================================================
    public void WHILE_START(string Op1, string CmpSign, string Op2)
    {
        DBG.Print("\n\n" + TabSpaser() + "while(" + Op1 + " " + CmpSign + " " + Op2 + ")\n" + TabSpaser() + "{");
        
        TabLevel++;
    }
​
    // ===================================================================================
    public void WHILE_END()
    {
        TabLevel--;
        
        DBG.Print("\n" + TabSpaser() + "};");
    }
​
    // ===================================================================================
    public void FOR_START(string Op1, string CmpSign, string Op2)
    {
    }
​
    // ===================================================================================
    public void FOR_END()
    {
​
    }
        
}
​
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████
​
                ██ ██████         ██    ██ ██████          ██████          ██████  ███████ ██████  ██      
                ██ ██   ██        ██    ██      ██         ██   ██         ██   ██ ██      ██   ██ ██      
                ██ ██████         ██    ██  █████          ██   ██         ██   ██ █████   ██████  ██      
                ██ ██   ██         ██  ██       ██         ██   ██         ██   ██ ██      ██      ██      
                ██ ██   ██ ███████  ████   ██████  ███████ ██████  ███████ ██████  ███████ ██      ███████                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                   
                                                                                                                                                                                                                            
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */
​
class IR_V3_Generete_Destructured_DePL
{
    // string ResultStr;
        
    // ===================================================================================
    public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V1.Next_Sentence_in_global_scope()");
    
​
    // ===================================================================================  
    DBG.RETURN("");
    }
    
    int TabLevel = 0;
    
    // ===================================================================================
    string TabSpaser()
    {
        string Str = "";
            
        //for(int i = 0; i < TabLevel; i++)
        //  Str += "    "; // · | │     
        
        return Str;
    }
    
    // ===================================================================================
    public void Def_Variable(string Type, string Name)
    {
    DBG.ENTER("IR_V1.Def_Variable(T, N)");
        
        DBG.Print("\n" + TabSpaser() + Name + " " + ConvertType(Type));
        
    DBG.RETURN("");
    }
​
    // ===================================================================================
    public void Def_Variable(string Type, string Name, string InitValue)
    {
    DBG.ENTER("IR_V1.Def_Variable(T, N, V)");
                
        if(Type == "double" || Type == "float")
        {
            // Задано целое значение, то привести его к виду с точкой, 
            // иначе DePL сгенерирует неверный тип для переменной (int вместо double)
            if(InitValue.Contains('.') == false)
                InitValue = InitValue + ".0";               
        }   
        
        DBG.Print("\n" + TabSpaser() + Name + " = " + InitValue);
        
    DBG.RETURN("");
    } 
    
    bool First_Arg;
    
    string RT;
    
    // ===================================================================================
    public void Define_Function_START(string FuncName, string RetutnType)
    {
    DBG.ENTER("IR_V1.Define_Function_START()");
        
        DBG.Print("\n\n\n");
        DBG.Print(TabSpaser() + "ФУНКЦІЯ " + FuncName + "(");
        
        // Запомнить тип. Он будет использован позже
        RT = RetutnType;
        
        First_Arg = true;
        
        TabLevel++;
        
    DBG.RETURN("");     
    }
    
    // ===================================================================================
    public void Function_NextArg(string Param_Name,  string Param_Type)
    {
    DBG.ENTER("IR_V1.Function_NextArg()");
        
        if(First_Arg == true)
            DBG.Print(Param_Name + " " + ConvertType(Param_Type)); // без запятой перед параметром
        else
        {
         // DBG.Print(", " + Param_Name + " " + ConvertType(Param_Type)); // версия в одну строку
            DBG.Print(", " + Param_Name + " " + ConvertType(Param_Type)); // версия в много строк
        }
        
        First_Arg = false;
        
    DBG.RETURN(""); 
    }
    
    // ===================================================================================
    public void Function_ArgList_END()
    {
DBG.ENTER("IR_V1.Function_ArgList_END()");
        
        string Type_in_DePL = ConvertType(RT);
        
        DBG.Print(") " + Type_in_DePL);
        
        //DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void Def_Function_END()
    {
DBG.ENTER("IR_V1.Def_Function_END()");
        
        //DBG.Print("\n" + TabSpaser());
        
        TabLevel--;     
​
        DBG.Print("\n" + TabSpaser() + "ФІНІШ");    
        
​
        
DBG.RETURN("");
    }   
    
    // ===================================================================================
    public void RETURN_w_Value(string Value)
    {
DBG.ENTER("IR_V1.RETURN_w_Value()");        
        
        DBG.Print("\n" + TabSpaser() + "ВЕРНУТИСЬ " + Value);
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void RETURN_VOID()
    {
DBG.ENTER("IR_V1.RETURN_VOID()");   
        
        DBG.Print("\n" + TabSpaser() + "ВЕРНУТИСЬ");
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void GOTO(string Lb_Name)
    {
DBG.ENTER("IR_V1.GOTO()");  
        
        DBG.Print("\n --------------------- PROBLEM!!! ---------------------------");
        DBG.Print("\n -------------- DePL not supported \"goto\" -------------------");
        
DBG.RETURN("");
    }
​
    string[] LB = new string[1000];
    
    int Curr_IF_Level = 0;
    
    // ===================================================================================
    public void CMD_IF(string Op1, string CmpSign, string Op2)
    {
DBG.ENTER("IR_V1.CMD_IF()");
        
        LB[Curr_IF_Level] = Gen_Label_Name();
        
        //DBG.Print("\n" + TabSpaser());
        DBG.Print("\n" + TabSpaser() + "ЯКЩО " + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + " СТРИБНУТИ_НА " + LB[Curr_IF_Level]);
        
        Curr_IF_Level++;
        
        TabLevel++;
        
        //DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
​
    // ===================================================================================
    string Inverse_CMP(string CMP)
    {
        switch(CMP)
        {
            case ">":  return "⩽";
            case "<":  return "⩾";
            case "==": return "≠";
            case "!=": return "=";
            case ">=": return "<";
            case "<=": return ">"; 
            default: return "ERROR";
        }       
    }
​
    int Lb_Cnt = 0;
    
    // ===================================================================================
    string Gen_Label_Name()
    {
        Lb_Cnt++;
        
        return "Lb_" + Lb_Cnt;
    }
    
    // ===================================================================================
    public void CMD_ELSE()
    {
DBG.ENTER("IR_V1.CMD_ELSE()");      
        
​
        //DBG.Print("\n" + TabSpaser());
        
        TabLevel--;
​
        DBG.Print("\n" + TabSpaser() + "СТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + "_2");
        DBG.Print("\n" + TabSpaser() + LB[Curr_IF_Level-1] + ":");
        
        // Установить признак того, что есть else-ветка
        LB[Curr_IF_Level-1] = LB[Curr_IF_Level-1] + "_";
        
        TabLevel++;
        
        //DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void CMD_IF_END()
    {
DBG.ENTER("IR_V1.CMD_IF_END()");    
        
        Curr_IF_Level--;
        
        string LB_Name = LB[Curr_IF_Level]; 
        
        // Если была else-ветка
        if(LB_Name[LB_Name.Length-1] == '_')
            LB_Name += '2'; 
        
        //DBG.Print("\n" + TabSpaser());
        
        TabLevel--;
        DBG.Print("\n" + TabSpaser() + LB_Name + ':');
        //DBG.Print("\n" + TabSpaser());
​
​
        
DBG.RETURN("");
    }
    
    
    // ===================================================================================
    string ConvertType(string type)
    {
    DBG.ENTER("IR_V1.ConvertType()");
    DBG.RETURN("");
    
        switch(type)
        {
            case "void"  : return "void"; 
            case "int"   : return "int";
            case "float" : return "double";
            case "double": return "double";
            default:       return "?";
        }   
    }
    
    // ===================================================================================
    public void CMD_SWITCH_START(string SwitchValue)
    {       
        LB[Curr_IF_Level] = Gen_Label_Name();  // Запомнить метку, для переходов по break
        Curr_IF_Level++;
        
        LB[Curr_IF_Level] = SwitchValue;    
        Curr_IF_Level++;
        
        
​
        // Эта метка, вставлена в стек, только для того, чтобы при ПЕРВОМ входе в case, 
        // было такое-же состояние стека, как и при всех остальных входах в case-ветку
     // LB[Curr_IF_Level] = "Free_LB";  
        LB[Curr_IF_Level] = Gen_Label_Name(); // + "_Free"; 
        Curr_IF_Level++;
        
        // ВАЖНО - этот странный переход, вставляется в начале switch-а, т.к. в текущей версии, 
        // возникает один лишний скачек, из-за того, что все switch-ветки обрабатываются одинаково, 
        // как самый первый case так и все остальные case-ветки, имеют 
        // перескок проверки, необходимый для реализации проваливания веток.
        // и в этом месте, происходит перескок лишнего перескока.
        DBG.Print("\n\nСТРИБНУТИ_НА " + LB[Curr_IF_Level-1]);
        DBG.Print("             ----- switch START (see remark)");
        
        //DBG.Print("\n\n");
​
    }
    
    // ===================================================================================
    public void SWITCH_CASE(string CaseValue)
    {
        string Case_Label = LB[Curr_IF_Level-1];        
        Curr_IF_Level--;
        
        // Реализация проваливания веток.
        // Если в предыдущей ветке есть break или return, то до этого скачка, программа не дойдет
        // Т.е., этот скачек, произойдет только в том случае, когда должно быть проваливание ветки.
        // ПРИМ - в default-ветку, мы провалимся и без этого скачка, поэтому в default-ветке нет этого перехода
        DBG.Print("\nСТРИБНУТИ_НА " + Case_Label + "_2");       
        DBG.Print("           ----- Realization Fall_Through");
​
        DBG.Print("\n" + Case_Label + ":");
        
        LB[Curr_IF_Level] = Gen_Label_Name();  // Запомнить метку, перехода на проверку следующего case
        Curr_IF_Level++;        
        
        
        DBG.Print("\nЯКЩО " + LB[Curr_IF_Level-2] + " ≠ " + CaseValue + " СТРИБНУТИ_НА " + LB[Curr_IF_Level-1]);
        DBG.Print("  ----- case " + CaseValue + ":");
​
        DBG.Print("\n" + Case_Label + "_2:");
    }
    
    // ===================================================================================
    public void BREAK_IN_SWITCH()
    {
        DBG.Print("\nСТРИБНУТИ_НА " + LB[Curr_IF_Level-3]); 
        DBG.Print("             ----- break; ");
    }
    
    // ===================================================================================
    public void SWITCH_DEFAULT()
    {
        string Case_Label = LB[Curr_IF_Level-1];        
        Curr_IF_Level--;
        
        DBG.Print("\n" + Case_Label + ":"); 
        DBG.Print("                         ----- default:");
        
        LB[Curr_IF_Level] = Gen_Label_Name(); // + "_Free";  // Эта метка, используется только для того, чтобы при входе 
        Curr_IF_Level++;                       // в SWITCH_END, было такое-же состояние, как и после case-ветки
        
    }
    
    // ===================================================================================
    public void SWITCH_END()
    {
        string Label = LB[Curr_IF_Level-1];     
        Curr_IF_Level--;    
        
        DBG.Print("\n" + Label + ":");  
        
        string Label_ForAll_Breaks = LB[Curr_IF_Level-2];       
        Curr_IF_Level -= 2; // Удалить два последних эл-та в стеке
        
        DBG.Print("\n" + Label_ForAll_Breaks + ":");
        DBG.Print("                         ----- switch END");
        DBG.Print("\n");
    }
​
    // ===================================================================================
    public void DO_START()
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
        Curr_IF_Level++;
​
        DBG.Print("\n\n" + LB[Curr_IF_Level-1] + ":                         ----- DO_START");
​
    }
​
    // ===================================================================================
    public void DO_END(string Op1, string CmpSign, string Op2)
    {
        DBG.Print("\nЯКЩО " + Op1 + " " + CmpSign + " " + Op2 + " " + "СТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + "  ----- DO_END");
​
        Curr_IF_Level--;    
    }
​
    // ===================================================================================
    public void WHILE_START(string Op1, string CmpSign, string Op2)
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
        Curr_IF_Level++;
​
        DBG.Print("\n\n" + LB[Curr_IF_Level-1] + ":                         ----- WHILE_START");
        DBG.Print("\nЯКЩО " + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + " " + "СТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + "_2");
​
    }
​
    // ===================================================================================
    public void WHILE_END()
    {
        DBG.Print("\nСТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + ":            ----- WHILE_END");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + "_2:");
​
        Curr_IF_Level--;    
    }
​
    // ===================================================================================
    public void FOR_START(string Op1, string CmpSign, string Op2)
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
        Curr_IF_Level++;
​
        DBG.Print("                        ----- FOR_START");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + ":");
        DBG.Print("\nЯКЩО " + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + " " + "СТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + "_2");
​
    }
​
    // ===================================================================================
    public void FOR_END()
    {
        DBG.Print("\nСТРИБНУТИ_НА " + LB[Curr_IF_Level-1] + ":            ----- FOR_END");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + "_2:");
​
        Curr_IF_Level--;    
    }
}
​
​
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████
​
                ██ ██████         ██    ██ ██   ██         ██████           ██████ ██████  ██████  
                ██ ██   ██        ██    ██ ██   ██         ██   ██         ██      ██   ██ ██   ██ 
                ██ ██████         ██    ██ ███████         ██   ██         ██      ██████  ██████  
                ██ ██   ██         ██  ██       ██         ██   ██         ██      ██      ██      
                ██ ██   ██ ███████  ████        ██ ███████ ██████  ███████  ██████ ██      ██      
                                                                                                                                                                                                                                                                                                                                                                                                      
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */
​
class IR_V4_Generete_Destructured_CPP
{
    // string ResultStr;
        
    // ===================================================================================
    public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V4.Next_Sentence_in_global_scope()");
    
    
    DBG.RETURN("");
    }
    
    int TabLevel = 0;
    
    // ===================================================================================
    string TabSpaser()
    {
        string Str = "";
            
        //for(int i = 0; i < TabLevel; i++)
        //  Str += "    "; // · | │     
        
        return Str;
    }
    
    // ===================================================================================
    public void Def_Variable(string Type, string Name)
    {
    DBG.ENTER("IR_V4.Def_Variable(T, N)");
        
        DBG.Print("\n" + TabSpaser() + Type + " " + Name + ";");
        
    DBG.RETURN("");
    }
​
    // ===================================================================================
    public void Def_Variable(string Type, string Name, string InitValue)
    {
    DBG.ENTER("IR_V4.Def_Variable(T, N, V)");
        
        DBG.Print("\n" + TabSpaser() + Type + " " + Name + " = " + InitValue + ";");
        
    DBG.RETURN("");
    } 
    
    bool First_Arg;
    
​
    // ===================================================================================
    public void Define_Function_START(string FuncName, string RetutnType)
    {
    DBG.ENTER("IR_V4.Define_Function_START()");
        
        DBG.Print("\n\n\n");
        DBG.Print(TabSpaser() + RetutnType + " " + FuncName + "(");
                
        First_Arg = true;
        
        TabLevel++;
        
    DBG.RETURN("");     
    }
    
    // ===================================================================================
    public void Function_NextArg(string Param_Name,  string Param_Type)
    {
    DBG.ENTER("IR_V4.Function_NextArg()");
        
        if(First_Arg == true)
            DBG.Print(Param_Type + " " + Param_Name); // без запятой перед параметром
        else
        {
            DBG.Print(", " + Param_Type  + " " + Param_Name); // версия в много строк
        }
        
        First_Arg = false;
        
    DBG.RETURN(""); 
    }
    
    // ===================================================================================
    public void Function_ArgList_END()
    {
DBG.ENTER("IR_V1.Function_ArgList_END()");
        
        // Если нет ни одного аргумента
        if(First_Arg == true)
            DBG.Print("void");
        
        DBG.Print(")\n");
        DBG.Print("{\n");
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void Def_Function_END()
    {
DBG.ENTER("IR_V4.Def_Function_END()");
                
        TabLevel--;     
​
        DBG.Print("\n" + TabSpaser() + "}");    
        
​
        
DBG.RETURN("");
    }   
    
    // ===================================================================================
    public void RETURN_w_Value(string Value)
    {
DBG.ENTER("IR_V4.RETURN_w_Value()");        
        
        DBG.Print("\n" + TabSpaser() + "return " + Value + ";");
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void RETURN_VOID()
    {
DBG.ENTER("IR_V1.RETURN_VOID()");   
        
        DBG.Print("\n" + TabSpaser() + "return;");
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void GOTO(string Lb_Name)
    {
DBG.ENTER("IR_V4.GOTO()");  
        
        DBG.Print("\n" + TabSpaser() + "goto " + Lb_Name + ";");
        
DBG.RETURN("");
    }
​
    string[] LB = new string[1000];
    
    int Curr_IF_Level = 0;
    
    // ===================================================================================
    public void CMD_IF(string Op1, string CmpSign, string Op2)
    {
DBG.ENTER("IR_V4.CMD_IF()");
        
        LB[Curr_IF_Level] = Gen_Label_Name();
        
        //DBG.Print("\n" + TabSpaser());
        DBG.Print("\n" + TabSpaser() + "if(" + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + ") goto " + LB[Curr_IF_Level] + ";");
        DBG.Print("    // IF_START ");
​
        
        Curr_IF_Level++;
        
        TabLevel++;
        
        //DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
​
    // ===================================================================================
    string Inverse_CMP(string CMP)
    {
        switch(CMP)
        {
            case ">":  return "<=";
            case "<":  return ">=";
            case "==": return "!=";
            case "!=": return "==";
            case ">=": return "<";
            case "<=": return ">"; 
            default: return "ERROR";
        }       
    }
​
    int Lb_Cnt = 0;
    
    // ===================================================================================
    string Gen_Label_Name()
    {
        Lb_Cnt++;
        
        return "Lb_" + Lb_Cnt;
    }
    
    // ===================================================================================
    public void CMD_ELSE()
    {
DBG.ENTER("IR_V4.CMD_ELSE()");      
        
​
        //DBG.Print("\n" + TabSpaser());
        
        TabLevel--;
​
        DBG.Print("\n" + TabSpaser() + "goto " + LB[Curr_IF_Level-1] + "_2;            // IF_ELSE");
        DBG.Print("\n" + TabSpaser() + LB[Curr_IF_Level-1] + ":");
        
        // Установить признак того, что есть else-ветка
        LB[Curr_IF_Level-1] = LB[Curr_IF_Level-1] + "_";
        
        TabLevel++;
        
        //DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void CMD_IF_END()
    {
DBG.ENTER("IR_V4.CMD_IF_END()");    
        
        Curr_IF_Level--;
        
        string LB_Name = LB[Curr_IF_Level]; 
        
        // Если была else-ветка
        if(LB_Name[LB_Name.Length-1] == '_')
            LB_Name += '2'; 
        
        //DBG.Print("\n" + TabSpaser());
        
        TabLevel--;
        DBG.Print("\n" + TabSpaser() + LB_Name + ":                 // IF_END");
        //DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void CMD_SWITCH_START(string SwitchValue)
    {       
        LB[Curr_IF_Level] = Gen_Label_Name();  // Запомнить метку, для переходов по break
        Curr_IF_Level++;
        
        LB[Curr_IF_Level] = SwitchValue;    
        Curr_IF_Level++;
        
        
​
        // Эта метка, вставлена в стек, только для того, чтобы при ПЕРВОМ входе в case, 
        // было такое-же состояние стека, как и при всех остальных входах в case-ветку
     // LB[Curr_IF_Level] = "Free_LB";  
        LB[Curr_IF_Level] = Gen_Label_Name(); // + "_Free"; 
        Curr_IF_Level++;
        
        // ВАЖНО - этот странный переход, вставляется в начале switch-а, т.к. в текущей версии, 
        // возникает один лишний скачек, из-за того, что все switch-ветки обрабатываются одинаково, 
        // как самый первый case так и все остальные case-ветки, имеют 
        // перескок проверки, необходимый для реализации проваливания веток.
        // и в этом месте, происходит перескок лишнего перескока.
        DBG.Print("\n\ngoto " + LB[Curr_IF_Level-1] + ";");
        DBG.Print("             // switch START (see remark)");
        
        //DBG.Print("\n\n");
​
    }
    
    // ===================================================================================
    public void SWITCH_CASE(string CaseValue)
    {
        string Case_Label = LB[Curr_IF_Level-1];        
        Curr_IF_Level--;
        
        // Реализация проваливания веток.
        // Если в предыдущей ветке есть break или return, то до этого скачка, программа не дойдет
        // Т.е., этот скачек, произойдет только в том случае, когда должно быть проваливание ветки.
        // ПРИМ - в default-ветку, мы провалимся и без этого скачка, поэтому в default-ветке нет этого перехода
        DBG.Print("\ngoto " + Case_Label + "_2;");      
        DBG.Print("            // Realization Fall_Through");
​
        DBG.Print("\n" + Case_Label + ":");
        
        LB[Curr_IF_Level] = Gen_Label_Name();  // Запомнить метку, перехода на проверку следующего case
        Curr_IF_Level++;        
        
        
        DBG.Print("\nif(" + LB[Curr_IF_Level-2] + " != " + CaseValue + ") goto " + LB[Curr_IF_Level-1] + ";");
        DBG.Print("   // case " + CaseValue + ":");
​
        DBG.Print("\n" + Case_Label + "_2:");
    }
    
    // ===================================================================================
    public void BREAK_IN_SWITCH()
    {
        DBG.Print("\ngoto " + LB[Curr_IF_Level-3] + ";");   
        DBG.Print("              // break; ");
    }
    
    // ===================================================================================
    public void SWITCH_DEFAULT()
    {
        string Case_Label = LB[Curr_IF_Level-1];        
        Curr_IF_Level--;
        
        DBG.Print("\n" + Case_Label + ":"); 
        DBG.Print("                  // default:");
        
        LB[Curr_IF_Level] = Gen_Label_Name(); // + "_Free";  // Эта метка, используется только для того, чтобы при входе 
        Curr_IF_Level++;                       // в SWITCH_END, было такое-же состояние, как и после case-ветки
        
    }
    
    // ===================================================================================
    public void SWITCH_END()
    {
        string Label = LB[Curr_IF_Level-1];     
        Curr_IF_Level--;    
        
        DBG.Print("\n" + Label + ":");  
        
        string Label_ForAll_Breaks = LB[Curr_IF_Level-2];       
        Curr_IF_Level -= 2; // Удалить два последних эл-та в стеке
        
        DBG.Print("\n" + Label_ForAll_Breaks + ":");
        DBG.Print("                   // switch END");
        DBG.Print("\n");
    }
​
    // ===================================================================================
    public void DO_START()
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
        Curr_IF_Level++;
​
        DBG.Print("\n\n" + LB[Curr_IF_Level-1] + ":                  // DO_START");
​
    }
​
    // ===================================================================================
    public void DO_END(string Op1, string CmpSign, string Op2)
    {
        DBG.Print("\nif( " + Op1 + " " + CmpSign + " " + Op2 + ") goto " + LB[Curr_IF_Level-1] + ";  // DO_END");
​
        Curr_IF_Level--;    
    }
​
    // ===================================================================================
    public void WHILE_START(string Op1, string CmpSign, string Op2)
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
        Curr_IF_Level++;
​
        DBG.Print("\n\n" + LB[Curr_IF_Level-1] + ":                  // WHILE_START");
        DBG.Print("\nif(" + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + ") goto " + LB[Curr_IF_Level-1] + "_2;");
​
    }
​
    // ===================================================================================
    public void WHILE_END()
    {
        DBG.Print("\ngoto " + LB[Curr_IF_Level-1] + ";             // WHILE_END");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + "_2:");
​
        Curr_IF_Level--;    
    }
​
    // ===================================================================================
    public void FOR_START(string Op1, string CmpSign, string Op2)
    {
        LB[Curr_IF_Level] = Gen_Label_Name(); 
        Curr_IF_Level++;
​
        DBG.Print("            // FOR_START");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + ":");
        DBG.Print("\nif(" + Op1 + " " + Inverse_CMP(CmpSign) + " " + Op2 + ") goto " + LB[Curr_IF_Level-1] + "_2;");
​
    }
​
    // ===================================================================================
    public void FOR_END()
    {
        DBG.Print("\ngoto " + LB[Curr_IF_Level-1] + ":             // FOR_END");
        DBG.Print("\n" + LB[Curr_IF_Level-1] + "_2:");
​
        Curr_IF_Level--;    
    }
}
​
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████
​
                ██ ██████         ██    ██ ███████         ██████   ██████  ████████ 
                ██ ██   ██        ██    ██ ██              ██   ██ ██    ██    ██    
                ██ ██████         ██    ██ ███████         ██   ██ ██    ██    ██    
                ██ ██   ██         ██  ██       ██         ██   ██ ██    ██    ██    
                ██ ██   ██ ███████  ████   ███████ ███████ ██████   ██████     ██    
                                                                                                                                                                                                                                                                                                                 
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */
​
class IR_V5_Generete_DOT
{
    // string ResultStr;
​
    class Stack_int
    {
        // Ссылка на массив, в котором хранятся данные стека
        int[] StackArray;
​
        // Индекс в массиве, где лежит верхний элемент стека
        int TopPos = -1; 
​
        public Stack_int(int Stack_Size) // Stack_Size - размер стека
        {
            // Выделить память под объект массива
            StackArray = new int[Stack_Size];
        }
​
        // Новое значение, поместить на вершину стека
        public void PUSH(int Value)
        {
            TopPos++;
​
            StackArray[TopPos] = Value;
        }
​
        // Извлечь значение с вершины стека
        public int POP()
        {
            int TMP = StackArray[TopPos];
​
            TopPos--;
​
            return TMP;
        }
​
        // Посмотреть значение на вершине стека, не извлекая его из стека.
        public int SEE_TOP()
        {
            return StackArray[TopPos];
        }
    }
​
    // Стек, в котором хранится цепочка номеров всех родительских узлов
    Stack_int All_ParentNodes = new Stack_int(1000);    
​
​
    
    // ===================================================================================
    int Create_Node(string label)
    {
        LastAddedNode_Number++;
        DBG.Print("\n" + TabSpaser() + "n" + LastAddedNode_Number + "[label=\"" + label + "\", xlabel=\"n" + LastAddedNode_Number + "\"];");
        
        return LastAddedNode_Number;
    }
​
    // ===================================================================================
    int Create_Node(string label, string color)
    {
        LastAddedNode_Number++;
        DBG.Print("\n" + TabSpaser() + "n" + LastAddedNode_Number + "[label=\"" + label + "\", xlabel=\"n" + LastAddedNode_Number + "\", fillcolor = \"" + color + "\", color = \"" + "black" + "\"];"); // color это цвет абриса
        
        return LastAddedNode_Number;
    }
    
    // ===================================================================================
    void Create_Link(int Src, int Dest)
    {
        DBG.Print("\n" + TabSpaser() + "n" + Src + " -> n" + Dest);
    }
    
        // ===================================================================================
    void Create_Link(int Src, int Dest, string color)
    {
        DBG.Print("\n" + TabSpaser() + "n" + Src + " -> n" + Dest + " [color = \"" + color + "\"]");
    }
    
    // ===================================================================================
    public void START()
    {
        // n1 - GLOBAL
        Create_Node("GLOBAL", "green");     
        
        All_ParentNodes.PUSH(LastAddedNode_Number);
    }
    
    // ===================================================================================
    public void Next_Sentence_in_global_scope()
    {
    DBG.ENTER("IR_V5.Next_Sentence_in_global_scope()");
    
​
    // ===================================================================================  
    DBG.RETURN("");
    }
    
    int TabLevel = 0;
    
    // ===================================================================================
    string TabSpaser()
    {
        string Str = "";
        
        for(int i = 0; i < TabLevel; i++)
            Str += "    "; // · | │
        
        return Str;
    }
    
    int LastAddedNode_Number = 0;
    
    // ===================================================================================
    public void Def_Variable(string Type, string Name)
    {
    DBG.ENTER("IR_V2.Def_Variable(T, N)");
        
        DBG.Print("\n\n"+ TabSpaser() + "// " + Type + " " + Name + ";"); 
        
        // ВАЖНО - приведенные тут номера узлов, соответствуют первому предложению после GLOBAL (который n1)
​
        // n2 - Def_Var
        // n3 - VarName 
        // n4 - VarType
        
        Create_Node("Define\\nVariable", "aquamarine2");
        Create_Node("Var\\nName", "aquamarine2");
        Create_Node("Var\\nType", "aquamarine2");
        
        //n1 -> n2 // GLOBAL  -> Def_Var
        //n2 -> n3 // Def_Var -> VarName
        //n2 -> n4 // Def_Var -> VarType
        
        Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number-2, "aquamarine2");
        Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number-1, "aquamarine2");
        Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number, "aquamarine2");
        
    DBG.RETURN("");
    }
​
    // ===================================================================================
    public void Def_Variable(string Type, string Name, string InitValue)
    {
    DBG.ENTER("IR_V2.Def_Variable(T, N, V)");
        
        DBG.Print("\n\n"+ TabSpaser() + "// " + Type + " " + Name + " = " + InitValue + ";");
        
        Create_Node("Define\\nVariable", "aquamarine2");
        Create_Node("Var\\nName", "aquamarine2");
        Create_Node("Var\\nType", "aquamarine2");
        Create_Node("Init\\nValue", "aquamarine2");
        
        Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number-3, "aquamarine2");
        Create_Link(LastAddedNode_Number-3,    LastAddedNode_Number-2, "aquamarine2");
        Create_Link(LastAddedNode_Number-3,    LastAddedNode_Number-1, "aquamarine2");
        Create_Link(LastAddedNode_Number-3,    LastAddedNode_Number, "aquamarine2");
        
    DBG.RETURN("");
    } 
    
    bool First_Arg;
    
    
    // ===================================================================================
    public void Define_Function_START(string FuncName, string RetutnType)
    {
    DBG.ENTER("IR_V1.Define_Function_START()");
        
        DBG.Print("\n\n// " + RetutnType + " " + FuncName + "(");
        
        Create_Node("Define\\nFunction", "gold");
        
        // Parent -> DefineFunction
        Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number, "gold");
        
        Create_Node("FuncName", "gold");
        Create_Node("RetType", "gold");
        Create_Node("ArgList", "gold");
        
        Create_Link(LastAddedNode_Number-3, LastAddedNode_Number-2, "gold");
        Create_Link(LastAddedNode_Number-3, LastAddedNode_Number-1, "gold");
        Create_Link(LastAddedNode_Number-3, LastAddedNode_Number, "gold");
​
        
        All_ParentNodes.PUSH(LastAddedNode_Number-3);
        All_ParentNodes.PUSH(LastAddedNode_Number);
​
​
        First_Arg = true;
        
        TabLevel++;
        
    DBG.RETURN("");     
    }
    
    int Arg_Cnt = 0;
    
    // ===================================================================================
    public void Function_NextArg(string Param_Name,  string Param_Type)
    {
    DBG.ENTER("IR_V1.Function_NextArg()");
        
        Arg_Cnt++;      
        
        DBG.Print("\n\n" + TabSpaser() + "// Arg #" + Arg_Cnt + " " + Param_Type + " " + Param_Name);
        
        Create_Node("Arg #" + Arg_Cnt, "aquamarine2");
        Create_Node("Name", "aquamarine2");
        Create_Node("Type", "aquamarine2");
        
        Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number-2, "aquamarine2");
        Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number-1, "aquamarine2");
        Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number, "aquamarine2");
        
        First_Arg = false;
        
    DBG.RETURN(""); 
    }
    
    // ===================================================================================
    public void Function_ArgList_END()
    {
DBG.ENTER("IR_V1.Function_ArgList_END()");
        
        DBG.Print("\n\n" + TabSpaser() + "// ArgList END");
        
        All_ParentNodes.POP();
            
        Create_Node("Body", "gold");    
        
        Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number, "gold");
        
        All_ParentNodes.PUSH(LastAddedNode_Number);
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void Def_Function_END()
    {
DBG.ENTER("IR_V1.Def_Function_END()");
        
        
        TabLevel--;     
​
        DBG.Print("\n" + TabSpaser() + "}");    
        
​
        
DBG.RETURN("");
    }   
    
    // ===================================================================================
    public void RETURN_w_Value(string Value)
    {
DBG.ENTER("IR_V1.RETURN_w_Value()");        
        
        DBG.Print("\n" + TabSpaser() + "return " + Value + ";");
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void RETURN_VOID()
    {
DBG.ENTER("IR_V1.RETURN_VOID()");   
        
        DBG.Print("\n" + TabSpaser() + "return;");
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void GOTO(string Lb_Name)
    {
DBG.ENTER("IR_V1.GOTO()");  
        
        DBG.Print("\n" + TabSpaser() + "goto " + Lb_Name + ";");
        
DBG.RETURN("");
    }
​
    // ===================================================================================
    public void CMD_IF(string Op1, string CmpSign, string Op2)
    {
DBG.ENTER("IR_V1.CMD_IF()");
        
        DBG.Print("\n" + TabSpaser());
        DBG.Print("\n" + TabSpaser() + "if(" + Op1 + " " + CmpSign + " " + Op2 + ")");
        
        DBG.Print("\n" + TabSpaser() + "{");
        
        TabLevel++;
        
​
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void CMD_ELSE()
    {
DBG.ENTER("IR_V1.CMD_ELSE()");      
        
​
        //DBG.Print("\n" + TabSpaser());
        
        TabLevel--;
​
        DBG.Print("\n" + TabSpaser() + "}");
        
        DBG.Print("\n" + TabSpaser() + "else");
        
        DBG.Print("\n" + TabSpaser() + "{");
        
        TabLevel++;
        
        //DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void CMD_IF_END()
    {
DBG.ENTER("IR_V1.CMD_IF_END()");    
        
        
    
        TabLevel--;
        DBG.Print("\n" + TabSpaser() + "}");
        DBG.Print("\n" + TabSpaser());
        
DBG.RETURN("");
    }
    
        // ===================================================================================
    public void CMD_SWITCH_START(string SwitchValue)
    {
        DBG.Print("\n\n" + TabSpaser() + "switch(" + SwitchValue + ")\n"+ TabSpaser() + "{");   
        
        TabLevel++;
        TabLevel++;
    }
    
    // ===================================================================================
    public void SWITCH_CASE(string CaseValue)
    {
        TabLevel--;     
        
        DBG.Print("\n" + TabSpaser() + "case " + CaseValue + ":");  
        
        TabLevel++;
    }
    
    // ===================================================================================
    public void BREAK_IN_SWITCH()
    {
        DBG.Print("\n" + TabSpaser() + "break;");
    }
    
    // ===================================================================================
    public void SWITCH_DEFAULT()
    {
        TabLevel--;
        
        DBG.Print("\n" + TabSpaser() + "default:"); 
        
        TabLevel++;
    }
    
    // ===================================================================================
    public void SWITCH_END()
    {
        TabLevel--;
        TabLevel--;
        
        DBG.Print("\n" + TabSpaser() + "}\n");  
    }   
​
    // ===================================================================================
    public void DO_START()
    {
        DBG.Print("\n\n" + TabSpaser() + "// do{");
        
        Create_Node("DO-WHILE", "coral3");
        Create_Node("Body", "coral3");
        
        int TMP = LastAddedNode_Number;
        
        Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number-1, "coral3");
        Create_Link(LastAddedNode_Number-1,    LastAddedNode_Number, "coral3");
        
        All_ParentNodes.PUSH(TMP-1); // узел DO-WHILE
        All_ParentNodes.PUSH(TMP);   // узел Body
        
        TabLevel++;
​
    }
​
    // ===================================================================================
    public void DO_END(string Op1, string CmpSign, string Op2)
    {
        TabLevel--;
​
        DBG.Print("\n\n" + TabSpaser() + "// } while(" + Op1 + " " + CmpSign + " " + Op2 + ");");
        
        All_ParentNodes.POP(); // После этого, на вершине узел DO-WHILE
        
        Create_Node("Cond", "coral3");
        Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number, "coral3");
        
        Create_Node(CmpSign, "deeppink2");
        Create_Node(Op1, "deeppink2");
        Create_Node(Op2, "deeppink2");      
        
        Create_Link(LastAddedNode_Number-3,    LastAddedNode_Number-2, "deeppink2");
        Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number-1, "deeppink2");
        Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number, "deeppink2");
        
        All_ParentNodes.POP();  
    }
​
    // ===================================================================================
    public void WHILE_START(string Op1, string CmpSign, string Op2)
    {
        DBG.Print("\n\n" + TabSpaser() + "// while(" + Op1 + " " + CmpSign + " " + Op2 + ")");
        
        Create_Node("WHILE", "coral3");
        Create_Node("Cond", "coral3");
        Create_Node("Body", "coral3");
        
        int TMP = LastAddedNode_Number;
        
​
        
        Create_Link(All_ParentNodes.SEE_TOP(), LastAddedNode_Number-2, "coral3");
        Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number-1, "coral3");
        Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number, "coral3");
        
        // -------
        
        Create_Node(CmpSign, "deeppink2");
        Create_Node(Op1, "deeppink2");
        Create_Node(Op2, "deeppink2");      
        
        Create_Link(LastAddedNode_Number-4,    LastAddedNode_Number-2, "deeppink2");
        Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number-1, "deeppink2");
        Create_Link(LastAddedNode_Number-2,    LastAddedNode_Number, "deeppink2");
        
        All_ParentNodes.PUSH(TMP);
        
        TabLevel++;
    }
​
    // ===================================================================================
    public void WHILE_END()
    {
        TabLevel--;
        
        All_ParentNodes.POP();
    }
​
    // ===================================================================================
    public void FOR_START(string Op1, string CmpSign, string Op2)
    {
    }
​
    // ===================================================================================
    public void FOR_END()
    {
​
    }
        
}
​
​
​
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████
​
                        ██████  ██████   ██████  
                        ██   ██ ██   ██ ██       
                        ██   ██ ██████  ██   ███ 
                        ██   ██ ██   ██ ██    ██ 
                        ██████  ██████   ██████  
                                                                                                  
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */
​
class DBG
{
    static int  Level          = 0;
    static int  Enter_Cnt      = 0;
    static bool View_Call_Tree = false;
    static bool Visibled       = false;
    static bool Colored_Console = false;
​
    // ==========================================================
    static public void Colored_Console_ON()
    {
        Colored_Console = true; 
    }
    
    // ==========================================================
    static public void View_Call_Tree_ON()
    {
        View_Call_Tree = true;  
        
        Console.Write("\n ---------- SHOW CALL TREE --------------------------");   
    }
    
    // ==========================================================
    static public void View_Call_Tree_OFF()
    {
        View_Call_Tree = false; 
        
        Console.Write("\n ---------- HIDE CALL TREE --------------------------");       
    }
    
    // ==========================================================
    public static void ENTER(string Msg)
    {
//return;
        Level++;
        
        Enter_Cnt++;
        
        if(View_Call_Tree == false)
            return;
        
        Console.Write("\n");
        
        for(int i=0; i<Level; i++)
        {
            if(i == 0)
                Console.Write("   ");
            else
                Console.Write("·  ");
        }
         
     // Console.Write("└─>┐ ");
        Console.Write("╰──╮ "); 
        
        Console.Write("\n");
        
        for(int i=0; i<Level; i++)
        {
            if(i == 0)
                Console.Write("   ");
            else
                Console.Write("·  ");
        }
        
        Console.Write("·  " + Msg + "   " + Enter_Cnt);     
    }
    
    // ==========================================================
    public static void RETURN()
    {
        RETURN("");
    }
    
    // ==========================================================
    public static void RETURN(string Msg)
    {
//return;
        if(View_Call_Tree == false)
        {
            Level--;
            
            return;
        }
        
        Console.WriteLine("");
        
        for(int i=0; i<Level; i++)
        {
            if(i == 0)
                Console.Write("   ");
            else
                Console.Write("·  ");
        }
        
     // Console.Write("┌-<┘ "); 
        Console.Write("╭──╯ "); 
        
    ConsoleColor TMP = Console.ForegroundColor;
​
    if(Colored_Console == true)
        Console.ForegroundColor = ConsoleColor.Blue;
​
    Console.Write(Msg);
​
    if(Colored_Console == true)
        Console.ForegroundColor = TMP;
​
        Level--;
    }
    // ==================================================================== 
    public static void Print_ON()
    {
        Visibled = true;
    }
    
    // ==================================================================== 
    public static void Print_OFF()
    {
        Visibled = false;
    }
​
    // ====================================================================
    public static void Print(string Str, ConsoleColor Clr)
    {
        ConsoleColor TMP = Console.ForegroundColor;
​
        if(Colored_Console == true)
            Console.ForegroundColor = Clr;
​
        Print(Str);
​
        if(Colored_Console == true)
            Console.ForegroundColor = TMP;  
​
    }
​
    // ====================================================================
    public static void Print(string Str)
    {
        if(Visibled == false)
            return;
        
        Console.Write(Str);
    }
    
    // ====================================================================
    public static void Print(string[] Str)
    {
        if(Visibled == false)
            return;
        
        foreach(string s in Str)
            DBG.Print("[\"" + s + "\"]\n");
    }
    
    // ====================================================================
    public static void Print(Token[] TknList)
    {
        if(Visibled == false)
            return; 
        
        DBG.Print("      TOKEN LIST:\n\n");
        DBG.Print("   TYPE         VALUE\n\n");
        
        for(int i = 0; i < TknList.Length-1; i++) 
        {
            Token Current_Token = TknList[i];
            
            int TypeStr_Lenght = Current_Token.Type.ToString().Length;
            
            int Spacer_Len = 16 - TypeStr_Lenght;
            
            string Spacer = "";
            
            for(int j = 0; j < Spacer_Len; j++)
                Spacer += " ";          
            
//          DBG.Print("[ [\"" + Current_Token.Type + "\"]" + Spacer + "[\"" + Current_Token.Value + "\"] ]\n");
            DBG.Print(          Current_Token.Type         + Spacer +  "\"" + Current_Token.Value + "\"\n");
​
        }
    }
    
    // ==========================================================
    void ERROR_TRAP()
    {
DBG.ENTER("ERROR_TRAP()");  
        
        //while(true) {}
        System.Environment.Exit(10);
        
//DBG.RETURN("");       
    }
​
    // ====================================================================
    public static void Src_ERROR_TRAP(string Msg)
    {
DBG.ENTER("Src_ERROR_TRAP()");
​
        Console.Write("  ----> Src_ERROR_TRAP(\"" + Msg + "\");\n\n\n");        
        
     // while(true){};
        System.Environment.Exit(10);
​
//DBG.RETURN("");
    }
}
​
 
/* ███████████████████████████████████████████████████████████████████████████████████████
​
                ██      ███████ ██   ██ ███████ ██████  
                ██      ██       ██ ██  ██      ██   ██ 
                ██      █████     ███   █████   ██████  
                ██      ██       ██ ██  ██      ██   ██ 
                ███████ ███████ ██   ██ ███████ ██   ██ 
​
   ███████████████████████████████████████████████████████████████████████████████████████ 
​
​
    Разбить текст исходника на отдельные ЛЕКСЕМЫ. 
  
    ПРИМ - ЛЕКСЕМА, это минимальная НЕДЕЛИМАЯ часть программы, несущая смысл.
​
​
    ЛОГИКА РАБОТЫ ЛЕКСЕРА:
 
    Производится ПОСИМВОЛЬНАЯ вычитка исходного кода, и каждый считанный символ исходника, записывается в выходную строку. 
    НО, в зависимости от вычитанного символа, вычитанный символ может быть подменен на цепочку других символов.
 
    Для этого, в потоке символов исходного кода, отлавливаются 
    признаки-разделители между лексемами (пробелы, пунктуаторы и др.).
   
    Когда обнаруживается очередной признак-разделитель лексем, 
    то в выходную строку записывается разделитель лексем, который отделит текущую лексему от следующей.
*/
​
class Lexer
{
    public string[] Split_to_Lexems(string Src)
    {
DBG.ENTER("Split_to_Lexems()");
        
        //Src = Clear_Space_Pack(Src);
        
//DBG.Print("\n\n");
//DBG.Print(Src);
        
        
        // Состояние лексера - "вне строки" или "в строке"
        bool InString = false;
        
        // Все лексемы, накапливаются в этой строке
        // ПРИМ - между собой, лексемы отделяютя переводом строки - '\n'
        string Lexems_List = "";
        
        // Перебор всех символов исходника
        for(int i = 0; i < Src.Length; i++)
        {
            // Вычитать один символ исходника
            char c = Src[i];
            
            // Если вычитан символ двойной кавычки, то переключить состояние "вне строки" или "в строке"
            if(c == '"')
            {
                if(InString == false)
                    InString = true;
                else
                    InString = false;
​
               Lexems_List += '"';
               
               continue; 
            }               
            
            if(InString == true) // Если мы В строке
            {
                Lexems_List += c;
            }
            else                // Если мы НЕ в строке
            {
                switch(c)
                {              
                case ' ' : Lexems_List += "\n";    break; // заменить пробел на разделитель лексем     WHY string???
                case '\t': Lexems_List += '\n';    break; // заменить непечатаемый символ на разделитель лексем
                case '\n': Lexems_List += '\n';    break;
                case '\r': Lexems_List += '\n';    break;
                case '(' : Lexems_List += "\n(\n"; break; // Пунктуаторы - это отдельные лексемы
                case ')' : Lexems_List += "\n)\n"; break;
                case '{' : Lexems_List += "\n{\n"; break;
                case '}' : Lexems_List += "\n}\n"; break;
                case ';' : Lexems_List += "\n;\n"; break; 
                case '+' : Lexems_List += "\n+\n"; break; 
                case '-' : Lexems_List += "\n-\n"; break; 
                case '*' : Lexems_List += "\n*\n"; break; 
                case '/' : Lexems_List += "\n/\n"; break; 
                case ',' : Lexems_List += "\n,\n"; break; 
                case ':' : Lexems_List += "\n:\n"; break;
                case '.' :
                    {
                        // Смысл точки зависит от контекста
                        // Если за точкой цифра, то точка не пунктуатор, а часть float-числа, иначе, точка - пунктуатор
​
                        char Next_c = Src[i+1];  // TODO - а если точка будет в конце файла???
                    
                        // Смотрим на символ, следующий за точкой
                        if(Char.IsDigit(Next_c) == false)
                            Lexems_List += "\n.\n"; // точка является пунктуатором
                        else
                            Lexems_List += '.';     // точка является частью float-числа
                    }
                    break;
​
                default: Lexems_List += c; break;
                } 
            }           
            
            
        } // loop end       
​
        Lexems_List = Clear_NewLine_Pack(Lexems_List);
​
//DBG.Print("\n\n------------------\n\n\n");
//DBG.Print(Lexems_List);
        
        
          char[] Spacer = new char[]{'\n'};
        string[] Lexems = Lexems_List.Split(Spacer, StringSplitOptions.RemoveEmptyEntries);
​
//DBG.Print("\n\n------------------\n\n\n");
//DBG.Print(Lexems);
        
        
DBG.RETURN();
        return Lexems;
    }
// ==================================================
    string Clear_NewLine_Pack(string Str)
    {
DBG.ENTER("Clear_NewLine_Pack()");
        
        // Длина строки с исходником
        int Str_Len = Str.Length;
        
        string Out_Text = "";
    
        char Prev_Symbol = (char)0;
        
        // Перебор всех символов исходника
        for(int i = 0; i < Str_Len; i++)
        {
            // Вычитать один символ исходника
            char c = Str[i];
            
            if(c != '\n')
                Out_Text += c;
            else
            {
                if(Prev_Symbol != '\n')
                    Out_Text += c;
            }
            
            Prev_Symbol = c;            
        }
        
DBG.RETURN();       
        return Out_Text;
    }
​
}
​
​
/* ██████████████████████████████████████████████████████████████████████████████████████████
​
           ████████  ██████  ██   ██ ███████ ███    ██ ██ ███████ ███████ ██████  
              ██    ██    ██ ██  ██  ██      ████   ██ ██    ███  ██      ██   ██ 
              ██    ██    ██ █████   █████   ██ ██  ██ ██   ███   █████   ██████  
              ██    ██    ██ ██  ██  ██      ██  ██ ██ ██  ███    ██      ██   ██ 
              ██     ██████  ██   ██ ███████ ██   ████ ██ ███████ ███████ ██   ██ 
                                                                                                                                                                             
   ██████████████████████████████████████████████████████████████████████████████████████████ */
​
class Tokenizer
{
    public Token[] Create_Token_List(string Src)
    {
DBG.ENTER("Create_Token_List()");
    
        Lexer Lex = new Lexer();
​
        string[] Lexems              = Lex.Split_to_Lexems(Src);
        Token [] Token_Array_Sructs  = Create_Token_Array (Lexems); 
        
DBG.RETURN();       
        return Token_Array_Sructs;
    }
    
// ==================================================================================
Token[] Create_Token_Array(string[] Lexems)
{
DBG.ENTER("Create_Token_Array()");
        
        Token[] Token_Array_Sructs = new Token[Lexems.Length + 2];
        
        for(int i = 0; i < Lexems.Length; i++)
        {
            string Lexem = Lexems[i];
            
            Token T = new Token();
            
            if     (Is_Punctuator    (Lexem) == true) { T.Type = T_Type.Punctuator;     T.Value = Lexem; }
            else if(Is_BuildInType   (Lexem) == true) { T.Type = T_Type.BuildInType;    T.Value = Lexem; }
            else if(Is_Number        (Lexem) == true) { T.Type = T_Type.Number;         T.Value = Lexem; }
            else if(Is_ControlKeyWord(Lexem) == true) { T.Type = T_Type.ControlKeyWord; T.Value = Lexem; }  
            else if(Is_Operation     (Lexem) == true) { T.Type = T_Type.Operation;      T.Value = Lexem; }  
            else if(Is_Identifier    (Lexem) == true) { T.Type = T_Type.Identifier;     T.Value = Lexem; }
            else if(Is_String        (Lexem) == true)
            {
                Lexem = Lexem.Remove(0, 1);
                Lexem = Lexem.Remove(Lexem.Length-1);
                
                T.Type = T_Type.Literal_String; 
                T.Value = Lexem;
            }
            else
                DBG.Src_ERROR_TRAP("Undef lexem type - " + Lexem);
            
            Token_Array_Sructs[i] = T;
        }
        
        Token T_EOF = new Token();
        T_EOF.Type  = T_Type.EOF;
        T_EOF.Value = "";   
        Token_Array_Sructs[Lexems.Length] = T_EOF;
    
DBG.Print("\n\n------------------\n\n\n");
DBG.Print(Token_Array_Sructs);
//DBG.Print("\n\n\n");
    
DBG.RETURN();
        return Token_Array_Sructs;
}
    
​
    // ========================================================
    bool Is_Punctuator(string Str)
    {
DBG.ENTER("Is_Punctuator()");
​
        
        if(Str == "(") goto m;
        if(Str == ")") goto m;
        if(Str == "{") goto m;
        if(Str == "}") goto m;
        if(Str == ";") goto m;
        if(Str == ".") goto m;
        if(Str == ",") goto m;
        if(Str == ":") goto m;
​
DBG.RETURN();       
        return false;       
m:
        
DBG.RETURN();       
        return true;
    }
    
    // ==========================================================
        static bool Is_BuildInType(string Str)
    {
DBG.ENTER("Is_BuildInType()");
​
            
        if(Str == "int")    { DBG.RETURN(); return true; }
        if(Str == "float")  { DBG.RETURN(); return true; }
        if(Str == "double") { DBG.RETURN(); return true; }
        if(Str == "char")   { DBG.RETURN(); return true; }
        if(Str == "void")   { DBG.RETURN(); return true; }
​
DBG.RETURN();       
        return false;
    }   
        
    // ==========================================================
    bool Is_ControlKeyWord(string Str)
    {
DBG.ENTER("Is_ControlKeyWord()");
DBG.RETURN();       
        
        if(Str == "if")      return true;
        if(Str == "else")    return true;
        if(Str == "while")   return true;
        if(Str == "for")     return true;
        if(Str == "do")      return true;
        if(Str == "goto")    return true;
        if(Str == "return")  return true;
        if(Str == "switch")  return true;
        if(Str == "case")    return true;
        if(Str == "default") return true;
        
        return false;
    }
    
    // ==========================================================
    bool Is_Operation(string Str)
    {
DBG.ENTER("Is_Operation()");
DBG.RETURN();       
        
        if(Str == "+")   return true;
        if(Str == "-")   return true;
        if(Str == "*")   return true;
        if(Str == "/")   return true;
        if(Str == "=")   return true;
        
        if(Str == "==")  return true;
        if(Str == "!=")  return true;
        if(Str == ">" )  return true;
        if(Str == "<" )  return true;
        if(Str == ">=")  return true;
        if(Str == "<=")  return true;       
        
        return false;
    }
    
    // ==========================================================
    // ВАЖНО - метод Is_Identifier(), должен вызываться только после Is_BuildInType() и Is_ControlKeyWord()
    bool Is_Identifier(string Str)
    {
DBG.ENTER("Is_Identifier()");
DBG.RETURN(); 
        
        // Длина строки с исходником
        int Str_Len = Str.Length;
        
        if(Str_Len == 0)
        {
            while(true); // ERROR TRAP
        }
        
        if(Char.IsDigit(Str[0]))
           return false;
        
        // Перебор всех символов исходника
        for(int i = 0; i < Str_Len; i++)
        {
            // Вычитать один символ исходника
            char c = Str[i];
            
            if(c != '_' && Char.IsLetter(c) == false && Char.IsDigit(c) == false)
                return false;       
        }
/*
        if(Is_BuildInType(Str) == true)
           return false;
        
        if(Is_ControlKeyWord(Str) == true)
            return false;
*/      
        return true;
    }
    
    // ==========================================================
    bool Is_Number(string Str)
    {
DBG.ENTER("Is_Number()");
DBG.RETURN();       
        
        if(Char.IsDigit(Str[0]))
            return true;
        else   
            return false;
    }   
            
    // ==========================================================
    bool Is_String(string Str)
    {
DBG.ENTER("Is_String()");
DBG.RETURN(); 
         
        if(Str[0] == '"')
            return true;
        else   
            return false;
    }   
}
​
enum T_Type
{
    Punctuator,   
    BuildInType,   
    Number,        
    ControlKeyWord,
    Operation, 
    Identifier,
    Literal_String,
    EOF
}
​
struct Token
{
    public T_Type Type;
    public string Value;
}
​
​

Arreglos desordenados:

17     17
19     15
11     18
11     11
12     19
17     18
11     16
17     19
12     16
17     11
arreglos ordenados:

11   11  *
11   11  *
11   15  *
12   16  *
12   16  *
17   17  *
17   18  *
17   18  *
17   19  *
19   19  *

Last Run:	7:38:03 pm
Compile:	0.11s
Execute:	0s
Memory:	8kb
CPU:	0s

View IL Code