C# Online Compiler | .NET Fiddle

<no name> by Anonymous

using System;

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

// =======================================================================
// =======================================================================
public class Program
{
	public static int Main()
	{
//DBG.Print_OFF();	
		
Console.Write("  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;
	
	// ==========================================================
	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()");
		
		// В строковую переменную, занести необходимый исходник
		string Src = Get_Src();
		
DBG.Print(Src);
		
		Tokenizer T = new Tokenizer();
		
		Token[] Token_List = T.Create_Token_List(Src);

DBG.Print(Token_List);	
		
DBG.RETURN();
	}
	
	// =========================================================================
	static string Get_Src()
	{
DBG.ENTER("Get_Src()");
		
		string Src = "int main()" +
			         "{"          +
			         "    f1();"  +
			         "    f3(25);"+
			
					 "    Print(\"Hello world!\");"+
					 "};"+
			
			 		 "void f1(void)" +
					 "{"             +
					 "    if(a == 2)"+
					 "        b = 3;"+
					 "};";
		
DBG.RETURN();		
		return Src;
	}
	
	// ==========================================================
	void Parse_Glb_Scope()
	{
DBG.ENTER("Parse_Glb_Scope()");
	
		//while(true)
		{
			Token T = Get_Next_Token();
		
			if(T.Type == "EOF")
				return;
		
			//Back_Token();
			
			Parse_Sentence();
		}


DBG.RETURN("");
	}
	
	// ==========================================================
	Token Get_Next_Token()
	{
DBG.ENTER("Get_Next_Token()");
		Token Ret;
		
		Ret.Type  = "Type";
		Ret.Value = "(";

DBG.RETURN("");
//DBG.RETURN("Type = " + Ret.Type + Ret.Type + "; Value = " + Ret.Value);
		return Ret;
	}
	
	// ==========================================================
	void Parse_Sentence()
	{
DBG.ENTER("Parse_Sentence()");		
		
		Token T = Get_Next_Token();
		
		if     (T.Type  == "Type")   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_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_Class()");

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

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

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

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

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

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

		
DBG.RETURN("");
	}
}

// =======================================================================
// =======================================================================
class DBG
{
	static int Level = 0;
	
	static int Enter_Cnt = 0;
	
	// ==========================================================
	public static void ENTER(string Msg)
	{
//return;
		Level++;
		
		Enter_Cnt++;
		
		Console.Write("\n");
		
		for(int i=0; i<Level; i++)
		{
			if(i == 0)
				Console.Write("   ");
			else
				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;
		Console.WriteLine("");
		
		for(int i=0; i<Level; i++)
		{
			if(i == 0)
				Console.Write("   ");
			else
				Console.Write("·  ");
		}
		
		//Console.Write("┌-<- " + Msg);	
		Console.Write("╭──╯ " + Msg);	
		
		Level--;
	}
	static bool Visibled = true;
	
	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-2; i++) // TODO - зачем -2 ???
		{
			Token Current_Token = TknList[i];
			
			int TypeStr_Lenght = Current_Token.Type.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");
		}
	}
	
}

// =======================================================================
// =======================================================================
class Tokenizer
{
	// =========================================================================
	public Token[] Create_Token_List(string Src)
	{
DBG.ENTER("Create_Token_List()");
		
		Src = Clear_Space_Pack(Src);
		
DBG.Print("\n\n");
DBG.Print(Src);
		
DBG.Print("\n\n\n------------------\n\n\n");
		
		// Длина строки с исходником
		int Str_Len = Src.Length;
		
		string Out_Text = "";
		
		// Состояние "вне строки" или "в строке"
		bool InString = false;
		
		// Перебор всех символов исходника
		for(int i = 0; i < Str_Len; i++)
		{
			// Вычитать один символ исходника
			string c = Src[i].ToString();
			
			// Если вычитан символ двойной кавычки, то переключить состояние "вне строки" или "в строке"
			if(c == "\"")
			{
				if(InString == false)
					InString = true;
				else
					InString = false;
			}
			
			// Если не в строке, и если пробел, то заменить пробел на разделитель лексем
			if(InString == false)
				if(c == " ") c = "\n";			
			
			if(c == "\t") c = "\n";
			if(c == "\n") c = "\n";
			if(c == "\r") c = "\n";
			
			if(c == "(") c = "\n(\n";
			if(c == ")") c = "\n)\n";
			if(c == "{") c = "\n{\n";
			if(c == "}") c = "\n}\n";
			if(c == ";") c = "\n;\n";
			
			Out_Text += c;
		} // loop end		
		
		Out_Text = Clear_NewLine_Pack(Out_Text);
		
DBG.Print(Out_Text);
DBG.Print("\n\n\n");

		string[] Lexems = Out_Text.Split('\n', StringSplitOptions.RemoveEmptyEntries);
		
		int How_Lexems = Lexems.Length; 
		
		string Token_List = "";
		
		for(int i = 0; i < How_Lexems; i++)
		{
			string Lexem = Lexems[i];
			
			// Token_List += "|";
			
			if     (Is_Punctuator    (Lexem) == true) Token_List += "Punctuator     " + Lexem;
			else if(Is_BuildInType   (Lexem) == true) Token_List += "BuildInType    " + Lexem;
			else if(Is_Number        (Lexem) == true) Token_List += "Number         " + Lexem;
			else if(Is_ControlKeyWord(Lexem) == true) Token_List += "ControlKeyWord " + Lexem;	
			else if(Is_Operation     (Lexem) == true) Token_List += "Operation      " + Lexem;	
			else if(Is_String        (Lexem) == true) Token_List += "Literal_String " + Lexem;
			else if(Is_Identifier    (Lexem) == true) Token_List += "Identifier     " + Lexem;
			
			Token_List += "\n";
		}
		
		string[] Token_Array_Srtings = Token_List.Split('\n', StringSplitOptions.RemoveEmptyEntries);
		
		int How_Tokens = Token_Array_Srtings.Length; 
		
		Token[] Token_Array_Sructs = new Token[How_Tokens+2];
		
		for(int i = 0; i < How_Tokens; i++)
		{
			string[] TMP = Token_Array_Srtings[i].Split(' ', StringSplitOptions.RemoveEmptyEntries);
			
			Token_Array_Sructs[i] = new Token();
			
			Token_Array_Sructs[i].Type  = TMP[0];
			Token_Array_Sructs[i].Value = TMP[1];
		}
		
DBG.RETURN();		
		return Token_Array_Sructs;
	}
	
	// ==================================================
	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;
	}
	
	// ========================================================
	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;

DBG.RETURN(); 		
		return false;
		
m:
		
DBG.RETURN(); 		
		return true;
	}
	
	// ==========================================================
		static bool Is_BuildInType(string Str)
	{
DBG.ENTER("Is_BuildInType()");
DBG.RETURN(); 
			
		if(Str == "int")    return true;
		if(Str == "float")  return true;
		if(Str == "double") return true;
		if(Str == "char")   return true;
		if(Str == "void")   return true;
		
		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;
	}	
}

​x
 
using System;
​
struct Token
{
    public string Type;
    public string Value;
}
​
// =======================================================================
// =======================================================================
public class Program
{
    public static int Main()
    {
//DBG.Print_OFF();  
        
Console.Write("  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;
    
    // ==========================================================
    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()");
        
        // В строковую переменную, занести необходимый исходник
        string Src = Get_Src();
        
DBG.Print(Src);
        
        Tokenizer T = new Tokenizer();
        
        Token[] Token_List = T.Create_Token_List(Src);
​
DBG.Print(Token_List);  
        
DBG.RETURN();
    }
    
    // =========================================================================
    static string Get_Src()
    {
DBG.ENTER("Get_Src()");
        
        string Src = "int main()" +
                     "{"          +
                     "    f1();"  +
                     "    f3(25);"+
            
                     "    Print(\"Hello world!\");"+
                     "};"+
            
                     "void f1(void)" +
                     "{"             +
                     "    if(a == 2)"+
                     "        b = 3;"+
                     "};";
        
DBG.RETURN();       
        return Src;
    }
    
    // ==========================================================
    void Parse_Glb_Scope()
    {
DBG.ENTER("Parse_Glb_Scope()");
    
        //while(true)
        {
            Token T = Get_Next_Token();
        
            if(T.Type == "EOF")
                return;
        
            //Back_Token();
            
            Parse_Sentence();
        }
​
​
DBG.RETURN("");
    }
    
    // ==========================================================
    Token Get_Next_Token()
    {
DBG.ENTER("Get_Next_Token()");
        Token Ret;
        
        Ret.Type  = "Type";
        Ret.Value = "(";
​
DBG.RETURN("");
//DBG.RETURN("Type = " + Ret.Type + Ret.Type + "; Value = " + Ret.Value);
        return Ret;
    }
    
    // ==========================================================
    void Parse_Sentence()
    {
DBG.ENTER("Parse_Sentence()");      
        
        Token T = Get_Next_Token();
        
        if     (T.Type  == "Type")   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_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_Class()");
​
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Sentence_Struct()
    {
DBG.ENTER("Parse_Struct()");
​
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Var()
    {
DBG.ENTER("Parse_Var()");
​
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Var_w_Init()
    {
DBG.ENTER("Parse_Var_w_Init()");
​
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Definite_Function()
    {
DBG.ENTER("Parse_Definite_Function()");
​
        Parse_Arg_List();
        Parse_Function_Body();
        
DBG.RETURN("");
    }
    
    // ==========================================================
    void Parse_Arg_List()
    {
DBG.ENTER("Parse_Arg_List()");
​
        
DBG.RETURN("");
    }
    
    //  ==========================================================
    void Parse_Function_Body()
    {
DBG.ENTER("Parse_Function_Body()");
​
        
DBG.RETURN("");
    }
}
​
// =======================================================================
// =======================================================================
class DBG
{
    static int Level = 0;
    
    static int Enter_Cnt = 0;
    
    // ==========================================================
    public static void ENTER(string Msg)
    {
//return;
        Level++;
        
        Enter_Cnt++;
        
        Console.Write("\n");
        
        for(int i=0; i<Level; i++)
        {
            if(i == 0)
                Console.Write("   ");
            else
                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;
        Console.WriteLine("");
        
        for(int i=0; i<Level; i++)
        {
            if(i == 0)
                Console.Write("   ");
            else
                Console.Write("·  ");
        }
        
        //Console.Write("┌-<- " + Msg); 
        Console.Write("╭──╯ " + Msg);   
        
        Level--;
    }
    static bool Visibled = true;
    
    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-2; i++) // TODO - зачем -2 ???
        {
            Token Current_Token = TknList[i];
            
            int TypeStr_Lenght = Current_Token.Type.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");
        }
    }
    
}
​
// =======================================================================
// =======================================================================
class Tokenizer
{
    // =========================================================================
    public Token[] Create_Token_List(string Src)
    {
DBG.ENTER("Create_Token_List()");
        
        Src = Clear_Space_Pack(Src);
        
DBG.Print("\n\n");
DBG.Print(Src);
        
DBG.Print("\n\n\n------------------\n\n\n");
        
        // Длина строки с исходником
        int Str_Len = Src.Length;
        
        string Out_Text = "";
        
        // Состояние "вне строки" или "в строке"
        bool InString = false;
        
        // Перебор всех символов исходника
        for(int i = 0; i < Str_Len; i++)
        {
            // Вычитать один символ исходника
            string c = Src[i].ToString();
            
            // Если вычитан символ двойной кавычки, то переключить состояние "вне строки" или "в строке"
            if(c == "\"")
            {
                if(InString == false)
                    InString = true;
                else
                    InString = false;
            }
            
            // Если не в строке, и если пробел, то заменить пробел на разделитель лексем
            if(InString == false)
                if(c == " ") c = "\n";          
            
            if(c == "\t") c = "\n";
            if(c == "\n") c = "\n";
            if(c == "\r") c = "\n";
            
            if(c == "(") c = "\n(\n";
            if(c == ")") c = "\n)\n";
            if(c == "{") c = "\n{\n";
            if(c == "}") c = "\n}\n";
            if(c == ";") c = "\n;\n";
            
            Out_Text += c;
        } // loop end       
        
        Out_Text = Clear_NewLine_Pack(Out_Text);
        
DBG.Print(Out_Text);
DBG.Print("\n\n\n");
​
        string[] Lexems = Out_Text.Split('\n', StringSplitOptions.RemoveEmptyEntries);
        
        int How_Lexems = Lexems.Length; 
        
        string Token_List = "";
        
        for(int i = 0; i < How_Lexems; i++)
        {
            string Lexem = Lexems[i];
            
            // Token_List += "|";
            
            if     (Is_Punctuator    (Lexem) == true) Token_List += "Punctuator     " + Lexem;
            else if(Is_BuildInType   (Lexem) == true) Token_List += "BuildInType    " + Lexem;
            else if(Is_Number        (Lexem) == true) Token_List += "Number         " + Lexem;
            else if(Is_ControlKeyWord(Lexem) == true) Token_List += "ControlKeyWord " + Lexem;  
            else if(Is_Operation     (Lexem) == true) Token_List += "Operation      " + Lexem;  
            else if(Is_String        (Lexem) == true) Token_List += "Literal_String " + Lexem;
            else if(Is_Identifier    (Lexem) == true) Token_List += "Identifier     " + Lexem;
            
            Token_List += "\n";
        }
        
        string[] Token_Array_Srtings = Token_List.Split('\n', StringSplitOptions.RemoveEmptyEntries);
        
        int How_Tokens = Token_Array_Srtings.Length; 
        
        Token[] Token_Array_Sructs = new Token[How_Tokens+2];
        
        for(int i = 0; i < How_Tokens; i++)
        {
            string[] TMP = Token_Array_Srtings[i].Split(' ', StringSplitOptions.RemoveEmptyEntries);
            
            Token_Array_Sructs[i] = new Token();
            
            Token_Array_Sructs[i].Type  = TMP[0];
            Token_Array_Sructs[i].Value = TMP[1];
        }
        
DBG.RETURN();       
        return Token_Array_Sructs;
    }
    
    // ==================================================
    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;
    }
    
    // ========================================================
    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;
​
DBG.RETURN();       
        return false;
        
m:
        
DBG.RETURN();       
        return true;
    }
    
    // ==========================================================
        static bool Is_BuildInType(string Str)
    {
DBG.ENTER("Is_BuildInType()");
DBG.RETURN(); 
            
        if(Str == "int")    return true;
        if(Str == "float")  return true;
        if(Str == "double") return true;
        if(Str == "char")   return true;
        if(Str == "void")   return true;
        
        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;
    }   
}
​
​
​

Nilai Ganjil

Cached Result
Last Run:	4:58:32 pm
Compile:	0.143s
Execute:	0s
Memory:	0b
CPU:	0.016s

View IL Code