.NET में ब्रेनफैक कंपाइलर

नमस्ते

मैं देखता हूं कि आपके पास एक ब्रेनफैक सप्ताह है और मैंने एक कंपाइलर लिखने का फैसला किया, खासकर जब से उन्होंने मुझे इस लेख में टिप्पणियों में गतिशील तरीकों के बारे में अधिक बताने के लिए कहा। इस लेख में, हम कोड संकलन के इस तरीके पर विचार करेंगे और सबसे सामान्य सरल भाषा का एक संकलक बनाने की कोशिश करेंगे

प्रविष्टि

.NET प्लेटफ़ॉर्म में किसी भी सोर्स कोड को संकलित करने के लिए, आपको 3 काम करने होंगे:

1. एक नया प्रोजेक्ट बनाएं और System.Reflection और System.Reflection.Emit नामस्थान को इससे कनेक्ट करें
2. स्रोत कोड का इनपुट और सत्यापन प्रदान करें
3. इस कोड को एक निष्पादन योग्य फ़ाइल में संकलित करें

और अगर पहले के साथ, मुझे उम्मीद है, कोई समस्या नहीं होगी, तो जाँच और संकलन के साथ कुछ समस्याएं पैदा हो सकती हैं यदि समस्याएं नहीं हैं।

इसलिए, सोर्स कोड की जाँच करें

शुद्धता के लिए स्रोत कोड की जांच करने के लिए, हमें यह जानना होगा कि इसमें कौन से ऑपरेंड हैं। उनमें से केवल 8 हैं:

1. > - अगली सेल पर जाएं
2. <- पिछली सेल पर जाएं
3. + - वर्तमान सेल में मान 1 से बढ़ाएँ
4. - - वर्तमान सेल में मूल्य 1 से घटाएं
5. । - वर्तमान सेल से मूल्य प्रिंट करें
6. , - बाहर से मूल्य दर्ज करें और वर्तमान सेल में सहेजें
7. [- यदि वर्तमान सेल का मान शून्य है, तो प्रोग्राम टेक्स्ट में सेल से संबंधित उसी के बाद आगे बढ़ें] (शून्य में ले जा रहा है)
8. ] - यदि वर्तमान सेल का मान शून्य नहीं है, तो प्रोग्राम टेक्स्ट में प्रतीक पर वापस जाएं [(खाते में घोंसले का शिकार हो रहा है)

कुल मिलाकर, स्रोत कोड सही होने के लिए, हमें यह सुनिश्चित करने की आवश्यकता है कि स्रोत कोड खाली नहीं है, और यह कि छोरों का घोंसला टूटा नहीं है।



चलो एक फ़ंक्शन लिखते हैं जो कोड की जांच करता है:



public bool CheckSource()

{

if (Src.Length == 0) throw new ArgumentException(" ");

int State = 0;

for (int i = 0; i < Src.Length; i++)

{

if (Src[i] == '[') State++;

if (Src[i] == ']') State--;

// , .

if (State < 0) throw new ArgumentException(String.Format(" . : {0}", i++));

}

if (State != 0) Console.WriteLine(" .");

return State == 0;

}









फ़ंक्शन केवल यह जांचता है कि कोड वहां है और उद्घाटन और समापन कोष्ठक सही क्रम में हैं, और उनकी संख्या समान है।

संकलन

तुरंत एक आरक्षण करें कि हम 30,000 बाइट्स की मेमोरी सीमा के साथ एक कंपाइलर लागू करेंगे। प्रत्येक कोशिका का आकार 1 बाइट होता है।



अपने मन में संकलक को संकलित करने के लिए, आपको असेम्बलीबर्ल क्लास को समझने की आवश्यकता है।

उस पर परिचालन का परिणाम एक निष्पादन योग्य फ़ाइल या लाइब्रेरी बन जाता है।

AssemblyBuilder ASM = AppDomain.CurrentDomain.DefineDynamicAssembly(new AssemblyName("BrainFuck Compiled Program"), AssemblyBuilderAccess.RunAndSave); //

ASM.Save(Filename);







यह कोड खाली असेंबली नहीं बनाएगा। इस असेंबली के खाली न होने के लिए, इसे मॉड्यूल्स से भरना होगा।

ModuleBuilder MDB = ASM.DefineDynamicModule(Filename); //







यह कोड असेंबली नाम के बराबर नाम वाला एक मॉड्यूल बनाएगा।

और इसमें क्लास प्रोग्राम बनाएं

TypeBuilder TPB = MDB.DefineType("Program", TypeAttributes.Class); //

TPB.CreateType(); //







अब हमारे पास एक वर्ग है। इसमें सभी ऑपरेशन किए जाएंगे।

हमें इसमें एक सरणी - मेमोरी और एक पॉइंटर चाहिए।

FieldBuilder FDB_1 = TPB.DefineField("Memory", typeof(byte[]), FieldAttributes.Private); // private byte[] Memory; // .

FieldBuilder FDB_2 = TPB.DefineField("Point", typeof(int), FieldAttributes.Private); //private int Point; // .







पूरा कार्यक्रम मेन में होगा।

खैर, मुख्य लिखें और इसे प्रवेश बिंदु बनाएं:

MethodBuilder MTB = TPB.DefineMethod("Main", MethodAttributes.Static, CallingConventions.Any); //static void Main() //Main Procedure

ASM.SetEntryPoint(MTB.GetBaseDefinition());







अब आपको उन वेरिएबल्स को इनिशियलाइज़ करना होगा जो आपको पहले मिले थे। MSDN का कहना है कि यह इस तरह किया जाता है:

ILGenerator MTB_IL=MTB.GetILGenerator();

MTB_IL.Emit(OpCodes.Ldc_I4,30000); // 30000 -

MTB_IL.Emit(OpCodes.Newarr,typeof(byte)); // 30000

MTB_IL.Emit(OpCodes.Stsfld, FDB_1); // Memory









फिर हम सभी कार्यों का वर्णन करते हैं: (कोड का एक गुच्छा, लेकिन टिप्पणी की गई)

foreach (var t in Src) // , .

{

switch (t)

{

case '>':

{

MTB_IL.Emit(OpCodes.Ldsfld,FDB_2); // POINT

MTB_IL.Emit(OpCodes.Ldc_I4_1); // 1

MTB_IL.Emit(OpCodes.Add); //

MTB_IL.Emit(OpCodes.Stsfld,FDB_2); // Point

break;

}

case '<':

{

MTB_IL.Emit(OpCodes.Ldsfld, FDB_2);// POINT

MTB_IL.Emit(OpCodes.Ldc_I4_1); // 1

MTB_IL.Emit(OpCodes.Sub); //

MTB_IL.Emit(OpCodes.Stsfld, FDB_2); // Point

break;

}

case '+':

{

MTB_IL.Emit(OpCodes.Ldsfld, FDB_1);// MEMORY

MTB_IL.Emit(OpCodes.Ldsfld, FDB_2);// POINT

MTB_IL.Emit(OpCodes.Ldelema, typeof(byte)); // MEMORY[POINT]

MTB_IL.Emit(OpCodes.Dup);

MTB_IL.Emit(OpCodes.Ldobj, typeof(byte));

MTB_IL.Emit(OpCodes.Ldc_I4_1);

MTB_IL.Emit(OpCodes.Add); //

MTB_IL.Emit(OpCodes.Conv_U1);

MTB_IL.Emit(OpCodes.Stobj, typeof(byte));//

break;

}

case '-':

{

MTB_IL.Emit(OpCodes.Ldsfld, FDB_1);// MEMORY

MTB_IL.Emit(OpCodes.Ldsfld, FDB_2);// POINT

MTB_IL.Emit(OpCodes.Ldelema, typeof(byte));// MEMORY[POINT]

MTB_IL.Emit(OpCodes.Dup);

MTB_IL.Emit(OpCodes.Ldobj, typeof(byte));

MTB_IL.Emit(OpCodes.Ldc_I4_1);

MTB_IL.Emit(OpCodes.Sub); //

MTB_IL.Emit(OpCodes.Conv_U1);

MTB_IL.Emit(OpCodes.Stobj, typeof(byte));//

break;

}

case '[':

{

var Lbl = MTB_IL.DefineLabel(); //

MTB_IL.MarkLabel(Lbl); // ,

Scopes.Push(Lbl); // . :)

break;

}

case ']':

{

MTB_IL.Emit(OpCodes.Ldsfld, FDB_1); // 3

MTB_IL.Emit(OpCodes.Ldsfld, FDB_2); //

MTB_IL.Emit(OpCodes.Ldelem_U1); //FDB_1 FDB_2

MTB_IL.Emit(OpCodes.Ldc_I4_0); // 0

MTB_IL.Emit(OpCodes.Ceq); // =0

MTB_IL.Emit(OpCodes.Brtrue,5); //

MTB_IL.Emit(OpCodes.Br,Scopes.Pop()); // . 5 .

break;

}

case '.':

{

MTB_IL.Emit(OpCodes.Ldsfld, FDB_1);// MEMORY

MTB_IL.Emit(OpCodes.Ldsfld, FDB_2);// POINT

MTB_IL.Emit(OpCodes.Ldelem_U1);// MEMORY[POINT]

MTB_IL.EmitCall(OpCodes.Call,typeof(Console).GetMethod("WriteLine",new[] {typeof(char)}),new[] {typeof(char)}); //Console.WriteLine(MEMORY[POINT]);

MTB_IL.Emit(OpCodes.Nop);

break;

}

case ',':

{

MTB_IL.Emit(OpCodes.Ldsfld, FDB_1);// MEMORY

MTB_IL.Emit(OpCodes.Ldsfld, FDB_2);// POINT

MTB_IL.EmitCall(OpCodes.Call, typeof(Console).GetMethod("ReadLine"), new[] { typeof(string) }); //Console.ReadLine();

MTB_IL.Emit(OpCodes.Call,typeof(Convert).GetMethod("ToByte",new[] {typeof(string)})); // .

MTB_IL.Emit(OpCodes.Stelem_I1); //

break;

}

}

}









और वह सब है!



MTB_IL.Emit(OpCodes.Ret); //

TPB.CreateType(); //

ASM.Save(Filename); //









इच्छा रखने वालों के लिए, यहाँ VS2010 के लिए स्रोत कोड + .sln है



UPD: असामान्य प्रोग्रामिंग की ओर अग्रसर