💟 👦🏿 👩‍💼 हम .NET (भाग 2 + बोनस) के लिए C # में कूल शैक्षिक भाषा के लिए एक कंपाइलर विकसित कर रहे हैं 🎓 🧑🏿‍🤝‍🧑🏽 ⬛️

हाय, हब्बर!

परिचय

इस लेख में, जैसा कि मैंने वादा किया था, कूल भाषा के लिए कंपाइलर के विकास का वर्णन जारी रखेगा, जो इस लेख में शुरू हुआ था।

आपको याद दिला दूं कि ~~फेंगशुई में~~ संकलन प्रक्रिया ~~में~~ कई चरण शामिल हैं, जो बाईं ओर नीचे दिए गए चित्र में दिखाए गए हैं। मेरे संकलक में केवल तीन चरण हैं, जो दाईं ओर एक ही आकृति में दिखाए गए हैं।

पहले लेख में लेक्सिकल और वाक्य विश्लेषण का उल्लेख किया गया था।

सिमेंटिक एनालाइज़र का मुख्य कार्य भाषा की परिभाषा के साथ सिमेंटिक स्थिरता के लिए स्रोत कार्यक्रम की जांच करना है। यह मुख्य रूप से जाँच है , अर्थात जब कंपाइलर देखता है कि क्या प्रत्येक ऑपरेटर के पास उपयुक्त प्रकार के ऑपरेंड हैं।

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

मशीन-इंडिपेंडेंट कोड ऑप्टिमाइज़ेशन के चरण का उपयोग इंटरमीडिएट कोड को बेहतर बनाने के लिए किया जाता है (तेज़ या अधिक, शायद ही कभी, कम)।

कोड जनरेशन एक मध्यस्थ या आभासी मशीन के निर्देशों के एक सेट में एक मध्यवर्ती प्रतिनिधित्व का सीधा अनुवाद है।

मशीन-निर्भर अनुकूलन चरण मशीन-स्वतंत्र अनुकूलन के समान है, सिवाय इसके कि यह कोड को अनुकूलित करने के लिए लक्ष्य मशीन (उदाहरण के लिए, एसएसई ) से विशेष निर्देशों का उपयोग करता है। यह स्पष्ट है कि हमारे मामले में इन जिम्मेदारियों को सीएलआर द्वारा ग्रहण किया जाता है।

जैसा कि आप आरेख से देख सकते हैं, एक चरण में मैंने बाईं ओर आरेख से तीन चरणों को जोड़ा है। यह System.Reflection.Emit टूल (चूंकि CIL निर्देशों का एक क्रम उत्पन्न होता है जिसे बदला नहीं जा सकता है) का उपयोग करके मध्यवर्ती कोड उत्पन्न करने की असंभवता द्वारा दोनों को समझाया गया है, और एक पूरे के रूप में दुर्भावनापूर्ण वास्तुकला द्वारा।

आर्किटेक्चर

वाह, मुझे नहीं पता कि कहां से शुरू करना है!
मैं अपने कोड जनरेटर के चरणों का वर्णन करूंगा, जिस पर विचार किया जाएगा:

कक्षा की परिभाषा
फ़ंक्शंस और फ़ील्ड्स को परिभाषित करना
कंस्ट्रक्टर और फंक्शन कोड जनरेशन

कक्षा की परिभाषा

कूल सोर्स कोड को कक्षाओं का एक संग्रह माना जाता है। स्वाभाविक रूप से, एक प्रवेश बिंदु होना चाहिए, अन्यथा कुछ भी नहीं किया जाएगा।
तो, प्रवेश समारोह मुख्य वर्ग में मुख्य कार्य है। वर्ग और फ़ंक्शन दोनों को मैन्युअल रूप से पंजीकृत होना चाहिए। लेकिन बाद में इस पर अधिक।

System.Reflection.Emit में विशेष वर्ग असेंबली और स्टड्यूल मॉड्यूल हैं जिनका उपयोग डायनामिक असेंबली बनाने और CIL कोड जनरेट करने के लिए किया जाता है।
किसी भी वर्ग का विवरण घोषित करने के लिए, विधि का उपयोग करें

TypeBuilder ModuleBuilder.DefineType(string className, TypeAttributes attr, Type parent)

जिसमें ClassName वर्ग का नाम है, attr इसकी विशेषता है, और माता - पिता माता-पिता (यदि कोई हो) है।
TypeBuilder एक गतिशील प्रकार है जो तब कोड को उत्पन्न करने के लिए उपयोग किया जाएगा (उदाहरण के लिए, नए ऑपरेटर के लिए)।

तो, इस स्तर पर, क्लास प्रकार के नोड्स को पार्सर से प्राप्त सिंटैक्स ट्री में बाईपास किया जाता है, जैसा कि नीचे दिए गए चित्र में दिखाया गया है, और स्रोत कोड में मौजूद सभी कक्षाएं ऊपर उल्लिखित विधि का उपयोग करके निर्धारित की जाती हैं।

भाषा के वैकल्पिक वर्ण पीले रंग में प्रदर्शित किए गए हैं (यहां मूल वर्ग का नाम है। यदि कोई अभिभावक नहीं है, तो कक्षा ऑब्जेक्ट के साथ विरासत में मिली है)।

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

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

तो, इस स्तर पर शब्दकोश प्राप्त होता है

 Dictionary<string, TypeBuilder> ClassBuilders_;

जिसमें कुंजी वर्ग का नाम है, और मूल्य इसका बिल्डर है।

अंत में, मैं यह कहना चाहता हूं कि सभी कोड बनाने के बाद, CreateType विधि का उपयोग करके डायनामिक प्रकारों को अंतिम रूप दिया जाना चाहिए (यह फ़ाइनलअक्लेसेस फ़ंक्शन में किया जाता है)।

फ़ंक्शंस और फ़ील्ड्स को परिभाषित करना

कक्षाओं को परिभाषित करने के बाद, प्रत्येक कक्षा में आगे के उपयोग के लिए इसके कार्यों और विधियों को निर्धारित करना आवश्यक है। यह विधियों का उपयोग करके किया जाता है।

 public FieldBuilder DefineField(string fieldName, Type type, FieldAttributes attributes)

और

 public MethodBuilder DefineMethod(string name, MethodAttributes attributes, Type returnType, Type[] parameterTypes);

क्रमशः।

इस चरण के अंत में, दो आयामी शब्दकोष भरे हुए हैं

 protected Dictionary<string, Dictionary<string, FieldObjectDef>> Fields_; protected Dictionary<string, Dictionary<string, MethodDef>> Functions_;

पहले आयाम की डिक्शनरी कुंजी वर्ग का नाम है, दूसरी फ़ंक्शन या फ़ील्ड का नाम है। मूल्य क्रमशः फ़ंक्शन डिस्क्रिप्टर या फ़ील्ड्स हैं (इन कक्षाओं पर थोड़ी देर बाद चर्चा की जाएगी)।

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

कंस्ट्रक्टर और फंक्शन कोड जनरेशन

और यहां सबसे दिलचस्प आया। यहाँ, सभी वर्गों के फंक्शन बॉडीज़ और कंस्ट्रक्टरों की एक सीधी पुनरावृत्ति होती है।

तो, पिछले चरण से, सभी वर्गों के लिए सभी विधि विवरणकों (मेथडब्यूटरी) का एक शब्दकोश प्राप्त किया गया था।
एक CIL स्टेटमेंट को एक विधि में जोड़ने के लिए, आपको सबसे पहले एक विशेष ILGenerator ऑब्जेक्ट का उपयोग करना होगा
var ilGenerator = methodBuilder.GetILGenerator() , और फिर इस जनरेटर पर var ilGenerator = methodBuilder.GetILGenerator() विधि का उपयोग करें।
एमिट विधि के कई रूप हैं:

 void Emit(OpCode opcode); void Emit(OpCode opcode, int arg); void Emit(OpCode opcode, double arg); void Emit(OpCode opcode, ConstructorInfo con); void Emit(OpCode opcode, LocalBuilder local); void Emit(OpCode opcode, FieldInfo field); void Emit(OpCode opcode, MethodInfo meth); void Emit(OpCode opcode, Type cls);

OpCode एक वर्चुअल .NET मशीन निर्देश है। विवरण के साथ निर्देशों की एक अच्छी सूची यहां सूचीबद्ध है ।
और दूसरा तर्क (यह हमेशा नहीं होता है) सिर्फ "बिल्डर" या उस वर्ग या विधि का वर्णनकर्ता है जो पिछले दो चरणों में प्राप्त किया गया था।

वर्तमान फ़ंक्शन और वर्तमान वर्ग क्रमशः, फ़ंक्शन और वर्ग हैं, जिसमें वर्तमान में कोड उत्पन्न हो रहा है (जब सिंटिपल ट्री को ट्रेस करना है)।

सबसे पहले, मैं समझाता हूं कि मैंने फ़ंक्शन तर्क, स्थानीय चर, अस्थायी स्थानीय चर और वर्ग फ़ील्ड का वर्णन करने के लिए अपने कोड जनरेटर में कौन सी कक्षाएं शुरू की हैं। बेस क्लास एक ऑब्जेक्टडिफ है , जिसमें सार विधियों लोड (), निकालें () लोड करने के लिए, और संबंधित ऑब्जेक्ट जारी करें।

FieldObjectDef - किसी भी वर्ग के क्षेत्र का वर्णन करने के लिए इस्तेमाल किया जाता है (कूल फ़ील्ड में - यह एक विशेषता है)। वर्तमान वर्ग के कार्यों और रचनाकारों के लिए कोड बनाते समय, फ़ील्ड विवरण का एक सरणी उपयोग किया जाता है, जिसे ऊपर वर्णित किया गया था।
LocalObjectDef - वर्तमान फ़ंक्शन या कंस्ट्रक्टर के शरीर में सभी स्थानीय चर का वर्णन करने के लिए उपयोग किया जाता है (कूल में, स्थानीय चर को लेट स्टेटमेंट का उपयोग करके घोषित किया जाता है)।
ValueObjectDef - मानों द्वारा प्रेषित डेटा को संग्रहीत करने के लिए एक प्रकार का स्थानीय चर। कूल में, ऐसी कक्षाएं हैं इंट, स्ट्रिंग, बूल।
ArgObjectDef वर्तमान फ़ंक्शन का तर्क है। इसमें तर्क की संख्या, नाम और प्रकार समाहित है।

जैसा कि आपने देखा होगा, कूल में, हर परिणाम एक अभिव्यक्ति है। और प्रत्येक कंस्ट्रक्टर और प्रत्येक फ़ंक्शन के अंदर, बस एक एक्सपायर भी है। यह मेरे कोड जनरेटर का मुख्य बिंदु है और इस निर्माण को संसाधित करने के लिए EmitExpression (ITree अभिव्यक्तिनोड) फ़ंक्शन पेश किया गया था। कोड नीचे है (मैंने इसे संक्षिप्त किया है, कुछ टुकड़ों को चिह्नित दीर्घवृत्त के साथ प्रतिस्थापित किया है):

 ObjectDef result; switch (expressionNode.Type) { case CoolGrammarLexer.ASSIGN: result = EmitAssignOperation(expressionNode); break; //  ... case CoolGrammarLexer.EQUAL: result = EmitEqualOperation(expressionNode); break; case CoolGrammarLexer.PLUS: case CoolGrammarLexer.MINUS: case CoolGrammarLexer.MULT: case CoolGrammarLexer.DIV: result = EmitArithmeticOperation(expressionNode); break; //... case CoolGrammarLexer.Term: if (expressionNode.ChildCount == 1) result = EmitExpression(expressionNode.GetChild(0)); else result = EmitExplicitInvoke(expressionNode); break; case CoolGrammarLexer.ImplicitInvoke: result = EmitInplicitInvoke(expressionNode); break; case CoolGrammarLexer.IF: result = EmitIfBranch(expressionNode); break; case CoolGrammarLexer.Exprs: for (int i = 0; i < expressionNode.ChildCount - 1; i++) { var objectDef = EmitExpression(expressionNode.GetChild(i)); objectDef.Remove(); } result = EmitExpression(expressionNode.GetChild(expressionNode.ChildCount - 1)); break; //... case CoolGrammarLexer.INTEGER: result = EmitInteger(expressionNode); break; } return result;

जैसा कि आप देख सकते हैं, ट्री नोड (अभिव्यक्तिनोड) के प्रकार के आधार पर, एक फ़ंक्शन को लंबे मामले से बुलाया जाता है, जो इस ऑपरेटर के निर्देशों को उत्पन्न करने के लिए जिम्मेदार है।

उत्पन्न फ़ंक्शन में परिणाम वापस करने के लिए, सरल OpCodes.Ret निर्देश का उपयोग अभिव्यक्ति के कोड को उत्पन्न करने के बाद किया जाता है (यदि फ़ंक्शन कुछ भी वापस नहीं करता है, उदाहरण के लिए, मुख्य, OpCodes.Pop को रेट से पहले जोड़ें ताकि स्टैक ओवरफ़्लो न हो)।

प्रविष्टि बिंदु निर्धारित करने के लिए, SetEntryPoint विधि (MethodInfo entryMethod) , जिसे असेम्बली में परिभाषित किया गया है , का उपयोग किया जाता है । इसके अलावा, STAThreadAttribute विशेषता को प्रवेश बिंदु विधि पर सेट किया जाना चाहिए, जो इंगित करता है कि एप्लिकेशन एक ही थ्रेड पर चल रहा है। फ़ंक्शंस और एंट्री पॉइंट्स को परिभाषित करने का कोड मेरे डेफिनेशन में है।

प्रश्न : इन जैसे निर्माणों के लिए कोड कैसे जनरेट करें:
गणित: गणित: नया गणित; (कुछ प्रकार की अभिव्यक्ति का एक क्षेत्र सौंपना, यहाँ नया गणित)।

उत्तर : सबसे पहले, आपको यह समझने की आवश्यकता है कि सी # संकलक और, तदनुसार, हमारा संकलक, मक्खी पर कोई गणना उत्पन्न नहीं करता है - यह असंभव है। यानी मैं यह कहना चाहता हूं कि डिफ़ॉल्ट पर सही अभिव्यक्ति का मूल्यांकन डिफ़ॉल्ट कंस्ट्रक्टर में किया जाएगा।
और अभिव्यक्ति कोड (यहाँ नया गणित) उत्पन्न होने के बाद, निर्देश OpCodes.Stfld या OpCodes.Stsfld को क्रमशः गैर-स्थैतिक और स्थैतिक क्षेत्रों के लिए इस निर्माता के शरीर में जोड़ा जाता है।

कुछ CIL निर्देशों और डिज़ाइनों का विवरण

CIL एक स्टैक भाषा है , जिसका अर्थ है कि स्टैक का उपयोग करके सभी ऑपरेशन किए जाते हैं। उदाहरण के लिए, गणित वर्ग से फाइबोनैचि संख्या की गणना करने के लिए एक फ़ंक्शन कॉल निम्नानुसार एन्कोडेड है:

 ldsfld class Math Main::math ldsfld int32 Main::i callvirt instance int32 Math::fibonacci(int32) stloc.0

यहां, गणित उदाहरण संभाल पहले स्टैक पर लोड किया जाता है, फिर टाइप इंट के पास किए गए तर्क। उसके बाद, ऑप्सोड्स फ़ंक्शन को OpCodes.callvirt इंस्ट्रक्शन का उपयोग करके कहा जाता है (सामान्य OpCodes.call निर्देश का उपयोग क्लास के आंतरिक फ़ंक्शन को कॉल करते समय किया जाता है, फिर आपको क्लास डिस्क्रिप्टर पास करने की आवश्यकता नहीं है)। अंतिम stloc.0 स्टेटमेंट नंबर 0 पर एक स्थानीय चर में रिटर्न वैल्यू को स्टोर करता है।
खैर, उपरोक्त के अनुसार, मैं यह नोट करना चाहता हूं कि किसी भी फ़ंक्शन के लिए पहला तर्क उस वर्ग के उदाहरण के लिए एक संकेतक है, जहां से इसे (यह) कहा जाता है, भले ही स्पष्ट रूप में कोई तर्क न हो।

CIL का अधिक विस्तृत विवरण, उदाहरण के लिए, विकिपीडिया पर पाया जा सकता है
, लेकिन मैं बेहतर तरीके से वर्णन करता हूं कि रिफ्लेक्शन का उपयोग करके कुछ सिंटैक्स निर्माण को कैसे कोड किया जाए।

अंकगणित संचालन और तुलना संचालन

ये ऑपरेशन केवल एन्कोड किए गए हैं - पहले उन्हें स्टैक पर धकेल दिया जाता है
ऑपरेंड्स, और फिर ऑपरेशन कोड: अंकगणितीय संचालन के लिए, ये OpCodes.Add, OpCodes.Sub, OpCodes.Mul, OpCodes.Div और तुलना संचालन के लिए, OpCodes.Ceq, OpCode.Clt, OpCodes.Cgt हैं ।

मैं यह नोट करना चाहता हूं कि CIL में "कम या बराबर" या "इससे अधिक या बराबर" की तुलना के लिए कोई निर्देश नहीं है, इसलिए ऐसी तुलना उत्पन्न करने के लिए तीन निर्देशों का उपयोग किया जाता है, एक के बजाय (यहाँ "<=" "नहीं" के बराबर है):

 OpCodes.Cgt OpCodes.Ldc_I4_0 OpCodes.Ceq

OpCodes.Ceq स्टैक पर दो तत्वों की तुलना करता है और यदि वे समान नहीं हैं, तो 1 रिटर्न देता है और यदि वे समान नहीं हैं।

अगर निर्माण

अंकगणित संचालन की तुलना में, इस निर्देश को कोड करने में कठिनाई होती है, जो इस तथ्य में शामिल है कि आपको किसी तरह से सशर्त और बिना शर्त कूद के लेबल की आवश्यकता है। हालांकि, यह आसानी से किया जाता है। डेफिनलैबेल विधि का उपयोग करते हुए, ILGenerator में लेबल बनाए जाते हैं, जिसे आपको मार्कबेल विधि का उपयोग करके कोड को चिह्नित करने के लिए उपयोग करने की आवश्यकता होती है। इन लेबल का उपयोग सशर्त और बिना शर्त शाखा निर्देशों को एनकोड करने के लिए किया जाता है। तदनुसार, OpCodes.Brfalse एक सशर्त संक्रमण है जो तब होता है जब स्टैक के शीर्ष का मूल्य शून्य के बराबर होता है। और OpCodes.Br एक बिना शर्त संक्रमण है। स्पष्टता के लिए, मैंने कोड दिया:

 protected ObjectDef EmitIfBranch(ITree expressionNode) { var checkObjectDef = EmitExpression(expressionNode.GetChild(0)); checkObjectDef.Load(); checkObjectDef.Remove(); var exitLabel = CurrentILGenerator_.DefineLabel(); var elseLabel = CurrentILGenerator_.DefineLabel(); CurrentILGenerator_.Emit(OpCodes.Brfalse, elseLabel); var ifObjectDef = EmitExpression(expressionNode.GetChild(1)); ifObjectDef.Load(); ifObjectDef.Remove(); CurrentILGenerator_.Emit(OpCodes.Br, exitLabel); CurrentILGenerator_.MarkLabel(elseLabel); var elseObjectDef = EmitExpression(expressionNode.GetChild(2)); elseObjectDef.Load(); elseObjectDef.Remove(); CurrentILGenerator_.MarkLabel(exitLabel); return LocalObjectDef.AllocateLocal(GetMostNearestAncestor(ifObjectDef.Type, elseObjectDef.Type)); }

निर्माण करते समय

यह डिजाइन इफ की तरह ज्यादा है। बस यह मत भूलो कि इस डिजाइन के शरीर के अंदर आपको हमेशा पॉप करना चाहिए, क्योंकि आंतरिक अभिव्यक्ति का मूल्यांकन किया जाता है, और इसके परिणाम का उपयोग नहीं किया जाता है। (कूल में, यह कथन हमेशा शून्य होता है)।

ऑपरेटर्स '@' और 'केस'

@ ऑपरेटर अनिवार्य रूप से C # कोड में अभिव्यक्ति (B के रूप में) .methodName से मेल खाता है, और केस स्टेटमेंट डायनामिक प्रकार की जाँच का उपयोग करता है और यह C # में a है।
दुर्भाग्य से, इन ऑपरेटरों को लागू नहीं किया गया है।
हालांकि, मैं कह सकता हूं कि कैस्टक्लास <श्रेणी> स्टेटमेंट (किसी विधि को कॉल करना और विधि कॉल करना) का उपयोग करके एक विशेष प्रकार के लिए कास्टिंग तुरंत लागू किया जाता है । <thisType> [उपसर्ग]।
और गतिशील प्रकार की जाँच को आइंस्टीन <क्लास> स्टेटमेंट का उपयोग करके लागू किया जाता है।

टोकन आईडी प्रसंस्करण

यदि ट्री नोड प्रकार Id प्रकार से मेल खाती है, तो निम्न कार्य किए जाते हैं ( EmitIdValue फ़ंक्शन में):

स्थानीय चर में पहचानकर्ता खोज, यदि नहीं मिला, तो
फ़ंक्शन तर्कों में पहचानकर्ता के लिए खोजें; यदि नहीं मिला है, तो
वर्तमान वर्ग के क्षेत्रों में पहचानकर्ता के लिए खोजें, यदि नहीं मिला, तो
एक त्रुटि उत्पन्न करें जो आईडी परिभाषित नहीं है

इस खंड में, मैंने सिंटैक्स निर्माणों के लिए सीआईएल निर्देशों और कोड पीढ़ी का वर्णन किया जो जटिल के लिए सबसे दिलचस्प लगते हैं। अन्य सभी CIL निर्देशों के लिए, आप विकि पृष्ठ का संदर्भ दे सकते हैं, जो एक लिंक है जो विषय के अंत में स्थित है। और आप स्रोत कोड में अधिक विस्तार से कोड पीढ़ी को देख सकते हैं।

हैंडलिंग में त्रुटि

कंपाइलर में त्रुटियां अलग-अलग हैं: ~~काले, सफेद, लाल~~ लेक्सिकल , सिंटैक्टिक , सिमेंटिक और जनरल ।

एक अमूर्त वर्ग CompilerError उन सभी के लिए बनाया गया था, जिसमें त्रुटि संख्या, कोड में स्थिति (लाइन और कॉलम), त्रुटि का प्रकार, और इसका विवरण है।

लेक्सिकल और सिंटैक्स त्रुटियों को नियंत्रित करना असंभव है (कम से कम इस परियोजना में, मैंने ANTLR में लेसर और पार्सर स्तर पर त्रुटियों से उबरने के साथ सौदा नहीं किया)। यहां, अपवाद केवल पकड़े गए हैं और संबंधित त्रुटि उदाहरण बनाए गए हैं। यह सब CoolCompier.cs फ़ाइल में देखा जा सकता है

लेकिन सिमेंटिक त्रुटियों की जांच, मुख्य रूप से टाइपिंग चेक, "एमिट" के सभी कार्यों में लागू की जाती है। टाइप चेकिंग को तुच्छ तरीके से लागू किया जाता है। फिर भी, यह दृष्टिकोण एक पास में कई अर्थ त्रुटियों की मान्यता प्राप्त करने की अनुमति देता है। यहां एक उदाहरण दिया गया है: एक अंकगणितीय ऑपरेशन, अगर एक त्रुटि का भी पता चला है, तो सिंटैक्स ट्री आगे बढ़ना जारी है:

 protected ObjectDef EmitArithmeticOperation(ITree expressionNode) { var returnObject1 = EmitExpression(expressionNode.GetChild(0)); var returnObject2 = EmitExpression(expressionNode.GetChild(1)); if (returnObject1.Type != IntegerType || returnObject1.Type != returnObject2.Type) CompilerErrors.Add(new ArithmeticOperatorError( returnObject1.Type, returnObject2.Type, CompilerErrors.Count, expressionNode.Line, expressionNode.GetChild(1).CharPositionInLine, expressionNode.GetChild(0).CharPositionInLine)); ... }

खैर, एक सामान्य प्रकार की त्रुटियों के लिए, मैंने "फ़ाइल किसी अन्य प्रक्रिया में व्यस्त है", "प्रवेश बिंदु नहीं मिला" जैसी त्रुटियों को जिम्मेदार ठहराया, आदि। उनके बारे में बात करना विशेष रूप से दिलचस्प नहीं है।

इंटरफ़ेस

सिंटेक्स हाइलाइटिंग

कोड के साथ काम करने के लिए एक घटक के रूप में, जैसा कि मैंने कहा, मैंने WPF के तहत AvalonEdit का उपयोग किया।

वाक्यविन्यास को उजागर करने के लिए, एक्सटेंशन .xshd के साथ एक विशेष फ़ाइल का उपयोग किया जाता है, जो विभिन्न शब्दों और नियमों के लिए फ़ॉन्ट शैलियों का वर्णन करता है।

उदाहरण के लिए, टिप्पणियों को निम्नानुसार दर्शाया गया है:

 <Span color="Comment" begin="--" /> <Span color="Comment" multiline="true" begin="\(\*" end="\*\)" />

इस तरह के कीवर्ड:

 <Color name="Keywords" foreground="Blue" /> ... <Keywords color="Keywords"> <Word>classWord> <Word>elseWord> <Word>falseWord> ... Keywords>

ऐसे नियम भी हैं जो यह निर्धारित करने के लिए आवश्यक हैं कि वर्णों का कौन सा क्रम एक संख्या या एक स्ट्रिंग है और उन्हें कैसे उजागर किया जाए:

 <Rule foreground="DarkBlue"> \b0[xX][0-9a-fA-F]+ # hex number |\b ( \d+(\.[0-9]+)? #number with optional floating point | \.[0-9]+ #or just starting with floating point ) ([eE][+-]?[0-9]+)? # optional exponent Rule>

अन्य सभी हाइलाइटिंग नियम CoolHighlighting.xshd फ़ाइल में पाए जा सकते हैं।

तह और ऑटो पूरा करना

इस संपादक में ब्लॉकिंग और विस्तार संभव है और CoolFoldingStrategy.cs में कार्यान्वित किया गया । कोड मेरा नहीं है, इसलिए मैं इस पर टिप्पणी करने से बचूंगा। मैं केवल यह कह सकता हूं कि उसके लिए सब कुछ धन्यवाद जो घुंघराले ब्रेसिज़ के बीच है उसे कम से कम या विस्तारित किया जा सकता है। शायद कुछ के लिए यह बहुत सही नहीं होगा, क्योंकि छोरों को ऐसा अवसर नहीं होना चाहिए।

इसके अलावा, इस घटक के साथ आप ऑटो-पूर्ति कर सकते हैं, लेकिन मैंने ऐसा नहीं किया, क्योंकि इसके लिए मुझे शुरुआत में एक अलग आर्किटेक्चर करना पड़ा जो कोड पीढ़ी की परवाह किए बिना सिमेंटिक ट्री बनाने की अनुमति देगा।

अंत में, इंटरफ़ेस के संदर्भ में, मैं वर्णन करूंगा कि कोड की पंक्तियों के साथ पाई गई त्रुटियों को कैसे जोड़ा जाए। नीचे दिखाए गए कोड में, गाड़ी को स्क्रॉल किया जाता है और गाड़ी को उस स्थान पर स्थानांतरित किया जाता है जहां एक निश्चित त्रुटि हुई थी:

 tbEditor.ScrollTo((int)compilerError.Line, (int)compilerError.ColumnStart); int offset = tbEditor.Document.GetOffset((int)compilerError.Line, (int)compilerError.ColumnStart); tbEditor.Select(offset, 0); tbEditor.Focus();

tbEditor - संपादक घटक का उदाहरण;
compilerError - त्रुटि (पिछले अनुभाग में विवरण प्रस्तुत किया गया है);

और हां, यह खंड संकलक की स्क्रीन के बिना पूरा नहीं होगा:

कोड संपादक ऊपरी बाएँ में है, लॉग और त्रुटियों की सूची निचले बाएँ में है। संकलन कोड के लिए दाईं ओर बटन हैं (आप संकलन करने और चलाने के लिए F5 भी दबा सकते हैं, और संकलन करने के लिए F6)।
स्पष्टता के लिए, कार्यक्रम टोकन की एक सूची और एक सिंटैक्स ट्री (दाईं ओर) प्रदर्शित करता है। टोकन या सिंटैक्टिक संरचना पर एक डबल क्लिक के साथ, गाड़ी को स्क्रॉल किया जाता है और गाड़ी को सही जगह पर ले जाया जाता है।

आगे वास्तुकला में सुधार

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

सिमेंटिक ट्री, जैसा कि मैंने पहले ही कहा था, कोड पीढ़ी से पहले वास्तविक समय में स्वचालित प्रतिस्थापन और वास्तविक त्रुटियों की जाँच करने की अनुमति देगा।

एक तीन-पता मध्यवर्ती कोड आपको अनुकूलन तकनीकों को लागू करने की अनुमति देगा जो वर्तमान दृष्टिकोण के साथ लागू नहीं किया जा सकता है। उदाहरण के लिए, इस तरह के आदेशों और अन्य अनुकूलन का एक दृढ़ संकल्प:

stloc.0 ldloc.0

स्रोतों का विवरण (बोनस)

मैंने 2011 में MSTU में "डिजाइनिंग कंपाइलर्स" पाठ्यक्रम में मौजूद सभी प्रयोगशालाओं ~~के उप-कोड का संग्रह~~ करने का निर्णय लिया। N.E.Bauman (11 वाँ विकल्प)। मुझे लगता है कि वे किसी के लिए उपयोगी होंगे।

सभी प्रयोगशाला का विवरण:

कार्य 1. व्याकरण का विभाजन। यह प्रयोगशाला एक व्याकरण विभाजन एल्गोरिथ्म को लागू करती है । पृष्ठ 102 पर दूसरे खंड में पाठ्यपुस्तक "अहो ए।, उलमान जे। पार्सिंग, अनुवाद और संकलन" का विस्तृत विवरण और विवरण पाया जा सकता है। मैं केवल इतना ही कह सकता हूं कि वे बेकार (RemoveUselessSymbols) और अप्राप्य (RemoveUnreachableSymbols) को हटाने के लिए एल्गोरिदम का उपयोग करते हैं ) व्याकरण से वर्ण।
मुझे याद है कि उस समय मैं अभी भी LINQ के साथ खेल रहा था। तो इन कार्यों में कोड कुशल और सुंदर, लेकिन कम नहीं है। :)
कार्य 2. एक नियमित भाषा की श्रृंखला की मान्यता। निम्नलिखित उपशीर्षक यहां लागू किए गए हैं:
1. नियमित गुणांक के साथ एक मानक प्रणाली का समाधान।
  स्पष्टीकरण : एक नियमित अभिव्यक्ति का निर्माण बाईं ओर के व्याकरण से किया जाना चाहिए। यानी नियमित रूप से गुणांक (एसआरएस) के साथ एक प्रणाली "हल"। गुणांक टर्मिनल हैं, और अज्ञात गैर-टर्मिनल हैं।
  उदाहरण के लिए, ऐसे व्याकरण के लिए:
  
  Σ = {0, 1} N = {S, A, B} P = {S → 0∙A|1∙S|λ, A → 0∙B|1∙A, B → 0∙S|1∙B} S = S
  यह निम्नलिखित अभिव्यक्ति को दर्शाता है (एक छोटी सी त्रुटि है, लेकिन बिंदु नहीं):
  
  S = 1*+1*∙0∙1*∙0∙1*∙0∙1*+1*∙0∙1*∙0∙(0∙1*∙0∙1*∙0)*∙0∙1* A = 1*∙0∙1*∙0∙1*+1*∙0∙(0∙1*∙0∙1*∙0)*∙0∙1* B = 1*∙0∙1*+(0∙1*∙0∙1*∙0)*∙0∙1*
  
  इस लैब पर काम करते समय, यह मुझे समझ में आया कि बीजगणित में सामान्य क्रियाओं को '+', '*', '/' से संबंधित प्रचालनों को 'या', 'कॉन्सेप्टनैशन' और 'इटरेशन' को नियमित अभिव्यक्तियों के संदर्भ में ओवरलोड करके, कोई भी SRK विधि को हल कर सकता है। गॉस भी, जैसा कि हम सामान्य SLAE को हल करते हैं! केवल एक चीज यह है कि अनुकूलन उद्देश्यों के लिए कुछ बदल दिया गया है।
  
  हालाँकि, इन परिचालनों को ओवरलोड करना भी एक गैर-तुच्छ कार्य है, क्योंकि ये संख्याएँ नहीं हैं, लेकिन यहाँ की रेखाएँ और नियम अलग-अलग हैं: जब समवर्ती करते हैं, तो आपको लाइनों को "गोंद" करने की आवश्यकता होती है, 'या' ऑपरेशन के साथ आपको बस उन्हें उसी रूप में छोड़ने की आवश्यकता होती है, शून्य एक खाली सेट (Ø) है, यूनिट लंबा (λ) है। तदनुसार, गुणा या जोड़ के मामले में इन पंक्तियों को 0 या 1 से अलग करना भी आवश्यक है, अन्यथा वे जल्दी से "प्रफुल्लित" होंगे।
2. एक नियमित अभिव्यक्ति का उपयोग करना, जो कि नियमित गुणांक वाले समीकरणों की एक मानक प्रणाली का एक समाधान है, एक NFA (Nondeterministic Finite Automaton) का निर्माण करता है।
3. एनसीए का अनुकरण करने के लिए दृढ़ संकल्प। संक्षेप में - यह एक संशोधित गहराई की खोज है
समस्या 3. कोका-यंगेर-कासमी एल्गोरिदम
यहां, कोक-यंगर-कासमी एल्गोरिदम का उपयोग करके पार्सिंग को लागू करना आवश्यक था

, , . , , .

.
4.
. LL(*) ( ANTLR). . .
5-8. Cool
~~----~~ Cool .NET, .

, , Cool, , , :
- Example1.cool — ( , , ).
- BinaryTree.cool — , — (, , ).
, ( .pdf):
1. Evaluating Simple C Expressions — - .
2. iFlop — iFlop .

मैं यह नोट करना चाहता हूं कि मेरी कुछ प्रयोगशालाएं Microsoft.GLEE रेखांकन प्रदान करने के लिए एक अद्भुत, लेकिन बंद और भुगतान की गई लाइब्रेरी का उपयोग करती हैं । इस लेख को देखते हुए , इस लायब्रेरी में कुछ चतुर एल्गोरिदम और हेयुरेटिक्स का उपयोग गाया हुआ ग्राफ़ देखने के लिए किया जाता है जैसे कि यह किसी व्यक्ति द्वारा खींचा गया हो और सबसे बड़े नोड आकार के साथ सबसे छोटे क्षेत्र पर कब्जा किया हो। (यह अजीब है कि लगभग किसी ने हब पर इसका उल्लेख नहीं किया है)।
लाभ यह है कि इस पुस्तकालय का उपयोग करना आसान है। उदाहरण के लिए, नोड्स के बीच एक बढ़त जोड़ना एक फ़ंक्शन का उपयोग करके किया जाता Edge AddEdge(string source, string target)है जिसमें स्रोत एक नोड का नाम है , लक्ष्य दूसरे नोड का नाम है।
यानीउनके बीच संचार जोड़ने के लिए नोड्स, आपको उन्हें पहले बनाने की आवश्यकता नहीं है।

यदि आपको केवल एक नोड जोड़ने की आवश्यकता है, तो फ़ंक्शन का उपयोग किया जाता है। फ़ंक्शन Edge AddNode(string nodeId)
के परिणामस्वरूप, एज ऑब्जेक्ट का एक उदाहरण लौटाया जाता है, जिस पर आप विशेषताओं को बदल सकते हैं (पाठ रंग, नोड रंग, इंडेंटेशन, आदि)

जो भी आप सोचते हैं, लेकिन मैं Microsoft का समर्थक नहीं हूं: )

उन सभी योजनाओं को बनाने और संपादित करने के लिए, जिनमें मैंने सुविधाजनक ऑनलाइन सेवा lucidchart.com का उपयोग किया था ।

साहित्य

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

गिटहब परियोजना

वह सब है!

हम .NET (भाग 2 + बोनस) के लिए C # में कूल शैक्षिक भाषा के लिए एक कंपाइलर विकसित कर रहे हैं