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;
	
	// ==========================================================
	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_Src5();
		
			
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 a;";
				
DBG.RETURN();		
		return Src;
	}
	
	// =========================================================================
	static string Get_Src3()
	{
DBG.ENTER("Get_Src3()");
		
		string Src = "int a;\n" +
			         "int b;";
		
DBG.RETURN();		
		return Src;
	}
		
	// =========================================================================
	static string Get_Src4()
	{
DBG.ENTER("Get_Src4()");
		
		string Src = "int a;\n" +
			         "int b;\n" +
			         "int c = 3;";
		
DBG.RETURN();		
		return Src;
	}

	// =========================================================================
	static string Get_Src5()
	{
DBG.ENTER("Get_Src5()");
		
		string Src = "int a;\n" +
			         "int b;\n" +
			         "int c = 3;\n" + 
					 "int Function()\n"+
					 "{\n" +
					 "};";
		
DBG.RETURN();		
		return Src;
	}

	// ==========================================================
	void Parse_Glb_Scope()
	{
DBG.ENTER("Parse_Glb_Scope()");
	
		while(true)
		{
DBG.Print("\n\nNext sentence\n");
			
			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.Value == "class")            Parse_Sentence_Class();  // Предложение, которое начинается с ключевого слова "class"
		else if(T.Value == "struct")           Parse_Sentence_Struct(); // Предложение, которое начинается с ключевого слова "struct"
		else ERROR_TRAP();
		
DBG.RETURN("");
	}
	
	void ERROR_TRAP()
	{
DBG.ENTER("ERROR_TRAP()");	
		
		while(true)
		{
		}
		
//DBG.RETURN("");		
	}
	
	// ==========================================================
	void Parse_Sentence_Type()
	{
DBG.ENTER("Parse_Sentence_Type()");

		Token T = Get_Next_Token();
		
		T = Get_Next_Token();
		
		switch(T.Value)
		{
			case ";": Parse_Var();               break;
			case "=": Parse_Var_w_Init();        break;
			case "(": Parse_Definite_Function(); break;
			default: ERROR_TRAP();               break;
		}
		
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();
		
		Get_Next_Token();
		
		DBG.Print("\n\nParse_Var() ==> Var_Type = " + Var_Type.Value + "; Var_Name = " + Var_Name.Value + "\n");
		
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();
		
		DBG.Print("\n\nParse_Var_w_Init() ==> Var_Type = " + Var_Type.Value + "; Var_Name = " + Var_Name.Value + "; Var_Init_Value = " + Var_Init_Value.Value + "\n");
		
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(); // опять вычитать "("
		
		DBG.Print("\n\nParse_Definite_Function() ==> Ret_Type = " + Ret_Type.Value + "; Func_Name = " + Func_Name.Value + "\n");
		
		Parse_Arg_List();
		Parse_Function_Body();
		
DBG.RETURN("");
	}
	
	// ==========================================================
	void Parse_Arg_List()
	{
DBG.ENTER("Parse_Arg_List()");

		Get_Next_Token(); // вычитать ")"
		
		DBG.Print("\n\nParse_Arg_List() ==> Arg_List is empty\n");

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

		Get_Next_Token(); // вычитать "{"
		Get_Next_Token(); // вычитать "}"
		Get_Next_Token(); // вычитать ";"
		
		DBG.Print("\n\nParse_Arg_List() ==> body is empty\n");
		
DBG.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)
	{
		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;		
		
		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");
		}
	}
	
	// ====================================================================
	public static void Src_ERROR_TRAP(string Msg)
	{
		Console.Write("  ----> Src_ERROR_TRAP(\"" + Msg + "\");\n\n\n");		
		
	 // while(true){};
		System.Environment.Exit(10);
	}
}

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

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

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


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


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

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 '.' :
                    {
    				    // Смысл точки зависит от контекста
	    			    // Если за точкой цифра, то точка не пунктуатор, а часть 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_Space_Pack(string Str)
	{
DBG.ENTER("Clear_Space_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 != ' ')
				Out_Text += c;
			else
			{
				if(Prev_Symbol != ' ')
					Out_Text += c;
			}
			
			Prev_Symbol = c;			
		}
		
DBG.RETURN();		
		return Out_Text;
	}
*/	
// ==================================================
	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 = "EOF";	
		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;
}
	
/*
	// ======================================================================
	Token[] Convert_to_Token_Array_Struct(string[] Token_Array_Srtings)
	{
DBG.ENTER("Convert_to_Token_Array_Struct()");
		
		int How_Tokens = Token_Array_Srtings.Length; 
		
		Token[] Token_Array_Sructs = new Token[How_Tokens+2];
		
		for(int i = 0; i < How_Tokens; i++)
		{
			char[] Spacer = new char[]{' '};
			string[] TMP = Token_Array_Srtings[i].Split(Spacer, StringSplitOptions.RemoveEmptyEntries);
						
			string Type = TMP[0];		
			
			string Value = "";
			
			for(int j = 1; j < TMP.Length; j++)
			{
				Value += TMP[j];
				
				// После последнего слова, пробел не ставить
				if(j < TMP.Length - 1)
					Value += ' ';
			}
			
			
			Token_Array_Sructs[i] = new Token();
			
			Token_Array_Sructs[i].Type  = Type;
			Token_Array_Sructs[i].Value = Value;
		}

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;

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;
		
		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;
    
    // ==========================================================
    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_Src5();
        
            
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 a;";
                
DBG.RETURN();       
        return Src;
    }
    
    // =========================================================================
    static string Get_Src3()
    {
DBG.ENTER("Get_Src3()");
        
        string Src = "int a;\n" +
                     "int b;";
        
DBG.RETURN();       
        return Src;
    }
        
    // =========================================================================
    static string Get_Src4()
    {
DBG.ENTER("Get_Src4()");
        
        string Src = "int a;\n" +
                     "int b;\n" +
                     "int c = 3;";
        
DBG.RETURN();       
        return Src;
    }
​
    // =========================================================================
    static string Get_Src5()
    {
DBG.ENTER("Get_Src5()");
        
        string Src = "int a;\n" +
                     "int b;\n" +
                     "int c = 3;\n" + 
                     "int Function()\n"+
                     "{\n" +
                     "};";
        
DBG.RETURN();       
        return Src;
    }
​
    // ==========================================================
    void Parse_Glb_Scope()
    {
DBG.ENTER("Parse_Glb_Scope()");
    
        while(true)
        {
DBG.Print("\n\nNext sentence\n");
            
            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.Value == "class")            Parse_Sentence_Class();  // Предложение, которое начинается с ключевого слова "class"
        else if(T.Value == "struct")           Parse_Sentence_Struct(); // Предложение, которое начинается с ключевого слова "struct"
        else ERROR_TRAP();
        
DBG.RETURN("");
    }
    
    void ERROR_TRAP()
    {
DBG.ENTER("ERROR_TRAP()");  
        
        while(true)
        {
        }
        
//DBG.RETURN("");       
    }
    
    // ==========================================================
    void Parse_Sentence_Type()
    {
DBG.ENTER("Parse_Sentence_Type()");
​
        Token T = Get_Next_Token();
        
        T = Get_Next_Token();
        
        switch(T.Value)
        {
            case ";": Parse_Var();               break;
            case "=": Parse_Var_w_Init();        break;
            case "(": Parse_Definite_Function(); break;
            default: ERROR_TRAP();               break;
        }
        
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();
        
        Get_Next_Token();
        
        DBG.Print("\n\nParse_Var() ==> Var_Type = " + Var_Type.Value + "; Var_Name = " + Var_Name.Value + "\n");
        
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();
        
        DBG.Print("\n\nParse_Var_w_Init() ==> Var_Type = " + Var_Type.Value + "; Var_Name = " + Var_Name.Value + "; Var_Init_Value = " + Var_Init_Value.Value + "\n");
        
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(); // опять вычитать "("
        
        DBG.Print("\n\nParse_Definite_Function() ==> Ret_Type = " + Ret_Type.Value + "; Func_Name = " + Func_Name.Value + "\n");
        
        Parse_Arg_List();
        Parse_Function_Body();
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Arg_List()
    {
DBG.ENTER("Parse_Arg_List()");
​
        Get_Next_Token(); // вычитать ")"
        
        DBG.Print("\n\nParse_Arg_List() ==> Arg_List is empty\n");
​
                
DBG.RETURN("");
    }
    
    //  ==========================================================
    void Parse_Function_Body()
    {
DBG.ENTER("Parse_Function_Body()");
​
        Get_Next_Token(); // вычитать "{"
        Get_Next_Token(); // вычитать "}"
        Get_Next_Token(); // вычитать ";"
        
        DBG.Print("\n\nParse_Arg_List() ==> body is empty\n");
        
DBG.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)
    {
        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;     
        
        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");
        }
    }
    
    // ====================================================================
    public static void Src_ERROR_TRAP(string Msg)
    {
        Console.Write("  ----> Src_ERROR_TRAP(\"" + Msg + "\");\n\n\n");        
        
     // while(true){};
        System.Environment.Exit(10);
    }
}
​
 
/* ███████████████████████████████████████████████████████████████████████████████████████
​
                ██      ███████ ██   ██ ███████ ██████  
                ██      ██       ██ ██  ██      ██   ██ 
                ██      █████     ███   █████   ██████  
                ██      ██       ██ ██  ██      ██   ██ 
                ███████ ███████ ██   ██ ███████ ██   ██ 
​
   ███████████████████████████████████████████████████████████████████████████████████████ 
​
​
    Разбить текст исходника на отдельные ЛЕКСЕМЫ. 
  
    ПРИМ - ЛЕКСЕМА, это минимальная НЕДЕЛИМАЯ часть программы, несущая смысл.
​
​
    ЛОГИКА РАБОТЫ ЛЕКСЕРА:
 
    Производится ПОСИМВОЛЬНАЯ вычитка исходного кода, и каждый считанный символ исходника, записывается в выходную строку. 
    НО, в зависимости от вычитанного символа, вычитанный символ может быть подменен на цепочку других символов.
 
    Для этого, в потоке символов исходного кода, отлавливаются 
    признаки-разделители между лексемами (пробелы, пунктуаторы и др.).
   
    Когда обнаруживается очередной признак-разделитель лексем, 
    то в выходную строку записывается разделитель лексем, который отделит текущую лексему от следующей.
*/
​
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 '.' :
                    {
                        // Смысл точки зависит от контекста
                        // Если за точкой цифра, то точка не пунктуатор, а часть 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_Space_Pack(string Str)
    {
DBG.ENTER("Clear_Space_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 != ' ')
                Out_Text += c;
            else
            {
                if(Prev_Symbol != ' ')
                    Out_Text += c;
            }
            
            Prev_Symbol = c;            
        }
        
DBG.RETURN();       
        return Out_Text;
    }
*/  
// ==================================================
    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 = "EOF";    
        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;
}
    
/*
    // ======================================================================
    Token[] Convert_to_Token_Array_Struct(string[] Token_Array_Srtings)
    {
DBG.ENTER("Convert_to_Token_Array_Struct()");
        
        int How_Tokens = Token_Array_Srtings.Length; 
        
        Token[] Token_Array_Sructs = new Token[How_Tokens+2];
        
        for(int i = 0; i < How_Tokens; i++)
        {
            char[] Spacer = new char[]{' '};
            string[] TMP = Token_Array_Srtings[i].Split(Spacer, StringSplitOptions.RemoveEmptyEntries);
                        
            string Type = TMP[0];       
            
            string Value = "";
            
            for(int j = 1; j < TMP.Length; j++)
            {
                Value += TMP[j];
                
                // После последнего слова, пробел не ставить
                if(j < TMP.Length - 1)
                    Value += ' ';
            }
            
            
            Token_Array_Sructs[i] = new Token();
            
            Token_Array_Sructs[i].Type  = Type;
            Token_Array_Sructs[i].Value = Value;
        }
​
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;
​
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;
        
        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;
}
​
​

Compilation error (line 17, col 46): An object reference is required for the non-static field, method, or property 'Program.base64UrlDecode(string)'

Last Run:	3:08:52 am
Compile:	0.045s
Execute:	0s
Memory:	0b
CPU:	0s

View IL Code