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  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();
	
	// ==========================================================
	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    Data_A;\n" +
					 "    double Data_B = 25.45;\n\n" +	
					 "    if(x > y)\n" + 
					 "        if(x < y)\n" +
			         "            int a = b;\n" +
					 "        else\n" +
					 "            int a = c;\n\n" +
                     "    return 0;\n"+
					 "};\n\n" + 
					 "void f1(void)\n"+
			         "{\n"+
			         "    int a = 5;\n\n" +
			         "    return;\n" +
			         " };"; 
		
DBG.RETURN();		
		return Src;
	}

	// ==========================================================
	void Parse_Glb_Scope()
	{
DBG.ENTER("Parse_Glb_Scope()");
	
		while(true)
		{
            IR.Next_Sentence_in_global_scope();
			
			Token T = Get_Next_Token();
		
			if(T.Type == T_Type.EOF)
				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 
			DBG.Src_ERROR_TRAP("Undef type of Sentence - Token.Type = " + T.Type + "; Token.Value =" + 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;
			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_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");		
	}
}

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

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

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");
		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()");
		
		char Type_in_DePL = ConvertType(RT);
        
        DBG.Print(") " + Type_in_DePL);
		
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() + "⤾ " + 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() + "ЯКЩО " + Op1 + " " + CmpSign + " " + Op2);
		
		TabLevel++;
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void CMD_ELSE()
	{
DBG.ENTER("IR_V1.CMD_ELSE()");		
		
		TabLevel--;
		
		DBG.Print("\n" + TabSpaser() + "ІНАКШЕ");
		
		TabLevel++;
		
DBG.RETURN("");
	}
	
	// ===================================================================================
	public void CMD_IF_END()
	{
DBG.ENTER("IR_V1.CMD_IF_END()");	
		
		TabLevel--;
		DBG.Print("\n" + TabSpaser() + "КІНЕЦЬ");
		
DBG.RETURN("");
	}
	
	
	// ===================================================================================
	char ConvertType(string type)
	{
	DBG.ENTER("IR_V1.ConvertType()");
	DBG.RETURN("");
	
		switch(type)
		{
			case "void"  : return 'v'; 
			case "int"   : return 'i';
			case "float" : return 'f';
			case "double": return 'd';
			default:       return '?';
		}	
	}	
}
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████

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

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 '.' :
                    {
    				    // Смысл точки зависит от контекста
	    			    // Если за точкой цифра, то точка не пунктуатор, а часть 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;

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;
		
		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  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();
    
    // ==========================================================
    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    Data_A;\n" +
                     "    double Data_B = 25.45;\n\n" + 
                     "    if(x > y)\n" + 
                     "        if(x < y)\n" +
                     "            int a = b;\n" +
                     "        else\n" +
                     "            int a = c;\n\n" +
                     "    return 0;\n"+
                     "};\n\n" + 
                     "void f1(void)\n"+
                     "{\n"+
                     "    int a = 5;\n\n" +
                     "    return;\n" +
                     " };"; 
        
DBG.RETURN();       
        return Src;
    }
​
    // ==========================================================
    void Parse_Glb_Scope()
    {
DBG.ENTER("Parse_Glb_Scope()");
    
        while(true)
        {
            IR.Next_Sentence_in_global_scope();
            
            Token T = Get_Next_Token();
        
            if(T.Type == T_Type.EOF)
                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 
            DBG.Src_ERROR_TRAP("Undef type of Sentence - Token.Type = " + T.Type + "; Token.Value =" + 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;
            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_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");      
    }
}
​
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████
​
                                ██ ██████         ██    ██  ██ 
                                ██ ██   ██        ██    ██ ███ 
                                ██ ██████         ██    ██  ██ 
                                ██ ██   ██         ██  ██   ██ 
                                ██ ██   ██ ███████  ████    ██   
                                                                                                                                                                                                                            
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */
​
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");
        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()");
        
        char Type_in_DePL = ConvertType(RT);
        
        DBG.Print(") " + Type_in_DePL);
        
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() + "⤾ " + 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() + "ЯКЩО " + Op1 + " " + CmpSign + " " + Op2);
        
        TabLevel++;
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void CMD_ELSE()
    {
DBG.ENTER("IR_V1.CMD_ELSE()");      
        
        TabLevel--;
        
        DBG.Print("\n" + TabSpaser() + "ІНАКШЕ");
        
        TabLevel++;
        
DBG.RETURN("");
    }
    
    // ===================================================================================
    public void CMD_IF_END()
    {
DBG.ENTER("IR_V1.CMD_IF_END()");    
        
        TabLevel--;
        DBG.Print("\n" + TabSpaser() + "КІНЕЦЬ");
        
DBG.RETURN("");
    }
    
    
    // ===================================================================================
    char ConvertType(string type)
    {
    DBG.ENTER("IR_V1.ConvertType()");
    DBG.RETURN("");
    
        switch(type)
        {
            case "void"  : return 'v'; 
            case "int"   : return 'i';
            case "float" : return 'f';
            case "double": return 'd';
            default:       return '?';
        }   
    }   
}
/* ████████████████████████████████████████████████████████████████████████████████████████████████████████████
​
                        ██████  ██████   ██████  
                        ██   ██ ██   ██ ██       
                        ██   ██ ██████  ██   ███ 
                        ██   ██ ██   ██ ██    ██ 
                        ██████  ██████   ██████  
                                                                                                  
   ████████████████████████████████████████████████████████████████████████████████████████████████████████████ */
​
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 '.' :
                    {
                        // Смысл точки зависит от контекста
                        // Если за точкой цифра, то точка не пунктуатор, а часть 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;
​
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;
        
        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;
}
​
​

Luke Skywalker
20
Moisture farm 1138,

Cached Result
Last Run:	4:57:20 am
Compile:	0.175s
Execute:	0s
Memory:	8kb
CPU:	0s

View IL Code