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

परिचय

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

पहला भाग ANTLR वातावरण में ऑपरेटरों की प्राथमिकताओं को ध्यान में रखते हुए एक व्याकरण लिखने की प्रक्रिया का वर्णन करेगा, साथ ही साथ सी # भाषा के लिए एक लेक्सर और पार्सर पैदा करेगा। इसके अलावा, यह मेरे रास्ते में मिले नुकसानों की जांच करेगा। इस प्रकार, मैं कम से कम किसी समय (शायद भविष्य में खुद के लिए) को बचाने की कोशिश करूंगा।

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

चेतावनी : इस संकलक को विकसित करने से पहले, मैंने व्यावहारिक रूप से किसी भी विषय के साहित्य का अध्ययन नहीं किया था। आधिकारिक वेबसाइट पर ANTLR वीडियो ट्यूटोरियल देखने, और "fumbling" सहपाठियों के साथ बात करने में मेरी रुचि के कई लेख पढ़ने से सब कुछ बदल गया। तो, विकसित सॉफ्टवेयर आदर्श से बहुत दूर है।

ताकि पाठक मुझे बेहतर समझे, मैं पहले कुछ परिभाषाएँ दूंगा (विकिपीडिया से):

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

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

इसलिए, कंपाइलर को विकसित करने के लिए निम्नलिखित कार्यक्रमों और पुस्तकालयों का उपयोग किया गया था:

1. ANTLRWorks - व्याकरण लिखने और विभिन्न भाषाओं (सी, सी #, जावा, जावास्क्रिप्ट, ऑब्जेक्टिव-सी, पर्ल, पायथन, रूबी, आदि) के लिए लेक्सर्स और पार्सर्स के लिए कोड जनरेट करने के लिए आईडीई। एलएल (*) पार्सिंग के आधार पर।
2. ANTLR C # रनटाइम डिस्ट्रीब्यूशन (Antlr3.Runtime.dll) का इस्तेमाल जेनरेट किए गए लेसर और पार्सर में किया जाता है।
3. दृश्य स्टूडियो 2010 अगला लेख WPF के तहत घटक पर चर्चा करेगा, वाक्य रचना हाइलाइटिंग और कोड पूरा करने वाले एवलॉनएडिट के लिए एक उन्नत पाठ संपादक)।
4. जावा रनटाइम एनवायरनमेंट (चूंकि ANTLRWorks जावा में लिखा गया है)।
5. IL Disassembler का उपयोग दूसरे भाग में यह समझने के लिए किया जाएगा कि C # जैसे कोई कंपाइलर CIL कोड कैसे बनाता है और इसे कैसे दिखना चाहिए।

भाषा कूल का विवरण

कूल - क्लासरूम ऑब्जेक्ट-ओरिएंटेड लैंग्वेज है, जैसा कि नाम से पता चलता है, एक शैक्षिक प्रोग्रामिंग भाषा जो किसी को भी ज़रूरत नहीं है , जिसमें कक्षाएं और ऑब्जेक्ट शामिल हैं। कूल एक कार्यात्मक रूप से टाइप की जाने वाली भाषा है, अर्थात प्रकार की जाँच संकलित अवस्था में सांख्यिकीय रूप से होती है। एक कार्यक्रम अनिवार्य रूप से कक्षाओं का एक संग्रह है। कक्षाओं में फ़ील्ड और फ़ंक्शंस का एक सेट शामिल होता है (यहाँ उन्हें फीचर कहा जाता है )।
सभी फ़ील्ड आधार और व्युत्पन्न वर्गों के भीतर दिखाई देते हैं। सभी कार्य हर जगह (सार्वजनिक) से दिखाई देते हैं।
यह भाषा भावों पर बनी है। सभी फ़ंक्शन तर्क के रूप में अभिव्यक्तियां ले सकते हैं, और सभी फ़ंक्शन के निकाय अभिव्यक्ति हैं जो किसी भी परिणाम को वापस करते हैं। यहां तक ​​कि लाइन आउटपुट जैसे फ़ंक्शन भी परिणाम देते हैं, अर्थात् उस वर्ग का एक उदाहरण जहां से उन्हें बुलाया जाता है।
कूल में स्थिर वर्ग स्ट्रिंग, इंट, बूल भी होते हैं, जिनसे उन्हें विरासत में नहीं मिला जा सकता है और जो शून्य मान नहीं ले सकते हैं (यहां इसे शून्य कहा जाता है )। इन वर्गों की वस्तुओं को मूल्य द्वारा पारित किया जाता है , संदर्भ द्वारा नहीं।
इस भाषा के कीवर्ड: वर्ग, और, असत्य, फाई, अगर, में, विरासत, isvoid, चलो, लूप, पूल, तब, जबकि, मामला, esac, नया, नहीं, सत्य
मैं ध्यान देना चाहता हूं कि कुछ ऑपरेटर एक घुंघराले ब्रैकेट के साथ समाप्त होते हैं (जैसे सी-जैसे वाले) या शब्द अंत; ( मृत पास्कल के रूप में), और रिवर्स ऑर्डर में एक ही ऑपरेटर का नाम (यदि -> फाई, लूप -> पूल, केस -> एसएसी)।
आपको क्या लगता है, यदि प्रत्येक ऑपरेटर किसी तरह का परिणाम देता है, तो यदि रिटर्न वापस करना चाहिए तो क्या होगा? आखिरकार, वह दो विकल्पों का विकल्प वापस कर सकता है। सही उत्तर: निकटतम सामान्य पूर्वज (पाठ्यपुस्तक में इसके बारे में किसी तरह जटिल लिखा गया है, अभी भी एक विशेष ऑपरेटर का उपयोग किया जाता है)। मैं स्पष्टता के लिए एक तस्वीर देता हूं:

चित्र 1

यहां, कक्षा ए और बी के लिए, निकटतम सामान्य पूर्वज कक्षा डी है।

केस स्टेटमेंट कई बार लागू किए गए स्टेटमेंट के समान है।

शून्य को हमेशा निर्माण के समय में लौटाया जाता है (जब तक कि लूप लूप न हो)।

ऐसा निर्माण {<expr1>; ... <exprn>; } एक्सप्रेशन की वस्तु वापस आती है, अर्थात अंतिम अभिव्यक्ति।

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

result <- (new A)@D.func() 

SELF_TYPE कीवर्ड का उपयोग उस वर्ग के पर्याय के रूप में किया जाता है जो किसी विशिष्ट कार्य का वर्णन करता है। पहचानकर्ता स्वयं वर्तमान वर्ग का सूचक है (अर्थात अन्य भाषाओं में)।

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

शून्य - शून्य का एक एनालॉग, एक संकेत है कि ऑब्जेक्ट नहीं बनाया गया है।

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

ANTLRWorks में कूल व्याकरण लिखना

तो, मूल व्याकरण निम्नलिखित रूप में दिया गया है:

 program ::= [[class; ]]+ class ::= class TYPE [inherits TYPE] { [[feature; ]]*} feature ::= ID( [ formal [[, formal]]*] ) : TYPE { expr } | ID : TYPE [ <- expr ] formal ::= ID : TYPE expr ::= ID <- expr | expr[@TYPE].ID( [ expr [[, expr]]*] ) | ID( [ expr [[, expr]]*] ) | if expr then expr else expr fi | while expr loop expr pool | { [[expr; ]] +} | let ID : TYPE [ <- expr ] [[, ID : TYPE [ <- expr ]]]* in expr | case expr of [[ID : TYPE => expr; ]]+ esac | new TYPE | isvoid expr | expr + expr | expr ? expr | expr ? expr | expr / expr | ~expr | expr < expr | expr <= expr | expr = expr | not expr | (expr) | ID | integer | string | true | false 

किंवदंती: [[]] * - पुनरावृत्ति; [[]] + एक सकारात्मक पुनरावृत्ति है? तो, इस तरह के एक व्याकरण को देखने के बाद क्या करने की आवश्यकता है? हमेशा के लिए उसके और संकलक के बारे में भूल जाओ। किसे एक और अनिर्णय की आवश्यकता है ?? इसलिए, यदि आप तुरंत ANTLR में इस व्याकरण को फिर से लिखते हैं और लेसर और पार्सर कोड उत्पन्न करते हैं, तो निम्न कारणों से कुछ भी अच्छा नहीं होगा:

• बाईं पुनरावृत्ति का अस्तित्व। बेशक, पुनरावर्ती वंश विधि के आधार पर, ANTLRWorks, इस तरह की त्रुटि का तुरंत पता लगाएगा और जारी करेगा: [घातक] नियम संकलन_unit में गैर-एलएल (*) निर्णय होता है, जो पुनरावर्ती नियम के कारण होता है, जो कि अलर्ट से बदला जाता है ... बाएं-फैक्टरिंग द्वारा हल होता है या सिनेटिक की भविष्यवाणी करता है। या backtrack = true विकल्प का उपयोग कर रहा है ... और, निश्चित रूप से, ANTLR में विकल्प backtrack = true है, जो आपको इस सीमा को पार करने की अनुमति देता है। लेकिन इसे लागू करने के लिए, आपको बाईं ओर की पुनरावृत्ति के साथ अभिव्यक्ति के लिए उत्पन्न अंतरिक्ष यान में एक और नोड के साथ आना होगा। तो सभी एक ही, इससे छुटकारा पाने के लिए अच्छा होगा। इसके अलावा, जैसा कि इस लेख से देखा जा सकता है, यह विकल्प पार्सर को धीमा कर देता है और लेखक जब भी संभव हो इसे छोड़ने की सलाह देता है।
• लेकिन मुख्य बात यह है कि व्याकरण के इस रूप में ऑपरेटरों की प्राथमिकता को ध्यान में नहीं रखा गया है। यदि बाईं पुनरावृत्ति केवल पार्सर दक्षता को प्रभावित करती है, तो इस समस्या को अनदेखा करने से बाद में गलत कोड पीढ़ी हो जाएगी (उदाहरण के लिए, 2 + 2 * 2 8 होगी, 6 नहीं)

हमने मैनुअल को आगे पढ़ा। और फिर यह सिर्फ संचालन की प्राथमिकताओं के बारे में लिखा गया है। वे निम्नलिखित रूप लेते हैं (शीर्ष पर - उच्चतम, नीचे - सबसे कम प्राथमिकताएं)।

• ।
• @
• ~
• isvoid
• * /
• + -
• <= <=
• नहीं
• <-

इसलिए, हमें इन कार्यों को ध्यान में रखते हुए अपना व्याकरण बनाने की आवश्यकता है। ऐसा करने के लिए, हम निम्नलिखित निर्माण नियम का पालन करते हैं: निचली प्राथमिकता के प्रत्येक ऑपरेटर के लिए, हम एक नया नियम बनाते हैं जिसमें इस प्राथमिकता का ऑपरेटर होगा और दाईं ओर उच्च प्राथमिकता के ऑपरेटर के लिए गैर-टर्मिनल होगा। मुझे पता है कि उलझन में लगता है, इसलिए हमारे मूल व्याकरण के लिए यह निर्माण दें:

 expr: (ID ASSIGN^)* not; not: (NOT^)* relation; relation: addition ((LE^ | LT^ | GE^ | GT^ | EQUAL^) addition)*; addition: multiplication ((PLUS^ | MINUS^) multiplication)*; multiplication: isvoid ((MULT^ | DIV^) isvoid)*; isvoid: (ISVOID^)* neg; neg: (NEG^)* dot; dot: term ((ATSIGN typeName)? DOT ID LPAREN invokeExprs? RPAREN)? -> ^(Term term ID? typeName? invokeExprs?); 

इस मामले में शब्द में सभी शेष अभिव्यक्तियाँ शामिल हैं जिन्हें विचार नहीं किया गया है, अर्थात्। समान प्राथमिकता वाले भाव।

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

 {$channel = Hidden;}; 

टिप्पणियों का वर्णन करने वाले प्रत्येक नियम के दाईं ओर लिखा गया है। उदाहरण के लिए:

 COMMENT : '--' .* ('\n'|'\r') {$channel = Hidden;}; 

ANTLR ऑपरेटर्स

आगे, मैं इस्तेमाल किए गए ANTLR विवरणों का वर्णन करूंगा:

1. ! - जरूरत है ताकि अतिरिक्त भाषा टोकन पार्सिंग में हस्तक्षेप न करें। उदाहरण के लिए, कोष्ठक और अन्य ऑपरेटर जो केवल पार्सर के लिए आवश्यक हैं (उदाहरण के लिए, फाई, एसएसी सिंटैक्स कंस्ट्रक्शन के समान एंडिंग)। यह सुनिश्चित करने के लिए ऑपरेटर की आवश्यकता होती है कि सिंटैक्स ट्री टोकन की धारा से बनाया गया है, न कि पार्स ट्री)।
2. -> - बाईं ओर खड़े टोकन के अनुक्रम को दाईं ओर खड़े टोकन के अनुक्रम में परिवर्तित करने के लिए आवश्यक है, जो कोड बनाते समय प्रक्रिया करने के लिए सुविधाजनक होगा। इस ऑपरेटर के साथ मिलकर ^ ऑपरेटर का भी उपयोग किया जाता है।
3. ^ इस ऑपरेटर और उसके वंश के साथ चिह्नित टोकन से उत्पन्न वाक्यविन्यास ट्री में एक नया नोड बनाने के लिए उपयोग किया जाता है। इस ऑपरेटर के दो रूप हैं:
   • पोस्टफ़िक्स। उदाहरण के लिए, ऐसे नियम के लिए:

      relation: addition ((LE^ | LT^ | GE^ | GT^ | EQUAL^) addition)*; 

     एक नोड को सिंटेक्स ट्री में डाला जाता है, जिसमें एक संचालक को कोष्ठक और बच्चों के अलावा संकेत दिया जाता है, जो कि ऑपरेटर के बाईं ओर होता है और इसके अलावा , जो ऑपरेटर के दाईं ओर होता है।
   • उपसर्ग। उदाहरण के लिए, ऐसे नियम के लिए:

      CLASS typeName (INHERITS typeName)? LCURLY featureList RCURLY -> ^(Class typeName featureList typeName?) 

     टाइपनेम के वंशज के साथ कक्षा के मूल नोड को टाइप करें। नाम सिंटैक्स ट्री में डाला जाता है ?

उपयोग किए जाने वाले अन्य सभी ANTLR संचालकों को टिप्पणियों की आवश्यकता नहीं है (एक ऐसे व्यक्ति के लिए, जिसने असतत गणित का अध्ययन किया है), और यदि उन्हें आवश्यकता है, तो छोटे व्यक्ति:

1. * - Iteration।
2. + - सकारात्मक पुनरावृत्ति।
3. ? - बाएं हाथ का टोकन या टोकन का एक समूह या तो मौजूद या अनुपस्थित हो सकता है।

मैं यह नोट करना चाहता हूं कि ऑपरेटरों को '->' और '^' का उपयोग करते समय, नए टोकन शुरू करने की आवश्यकता है। यह इसी खंड टोकन {} में किया जाता है। वैसे, मैं यह सुनिश्चित करने के पक्ष में हूं कि .g फ़ाइल में एक विशेष लेक्सर और पार्सर भाषा के लिए कम से कम कोड शामिल है (हमारे मामले में, C # के लिए)। फिर भी, इस तरह के कोड को अभी भी STRING टोकन के लिए उपयोग किया जाना है:

 STRING: '"' { StringBuilder b = new StringBuilder(); } ( '"' '"' { b.Append('"');} | c=~('"'|'\r'|'\n') { b.Append((char)c);} )* '"' { Text = b.ToString(); } ; 

यहां, स्ट्रिंग प्रोसेसिंग को कुशल बनाने के लिए StringBuilder का उपयोग किया जाता है। सिद्धांत रूप में, इस तरह के कोड के अन्य इंटरसेप्टर lexer को अनुकूलित करने के लिए स्वीकार्य हैं, लेकिन सभी नियमों के लिए नहीं। C # lexer और parser कोड में नेमस्पेस निर्दिष्ट करने के लिए (उदाहरण के लिए, System.Text)। StringBuilder), निम्न निर्माणों का उपयोग किया जाता है (कुछ "अनावश्यक" चेतावनियाँ भी यहाँ अक्षम हैं):

 @lexer::header {#pragma warning disable 3021 using System; using System.Text; } @parser::header {#pragma warning disable 3021 using System.Text;} 

हमने ANTLRWorks में व्याकरण संकलित करने के बाद, हमें C # lexer और parser कोड (धन्यवाद, कैप) उत्पन्न करने की आवश्यकता है।

ANTLRWorks दिए गए सेटिंग्स के साथ 3 फाइलें उत्पन्न करता है:

• CoolGrammar.tokens
• CoolGrammarLexer.cs
• CoolGrammarParser.cs

C # कोड में जेनरेट किए गए लेसर का उपयोग करना

उत्पन्न C # कोड में सभी टोकन की सूची प्राप्त करना बहुत तुच्छ नहीं लगता है (हालाँकि यह हमेशा आवश्यक नहीं है):

 var stream = new ANTLRStringStream(Source); // Source -  . lexer = new CoolGrammarLexer(stream, new RecognizerSharedState() { errorRecovery = true }); IToken token; token = lexer.NextToken(); while (token.Type != CoolGrammarLexer.EOF) { //    . //  : CoolTokens.Dictionary[token.Type] (  '('  LPAREN, //     ,      ) //  : token.Text (  '('   "(") //     : token.Line //       : token.Column token = lexer.NextToken(); //   ,   ,      . } //           0, //        (  ). lexer.Reset(); 

CoolTokens. retard निम्नानुसार उत्पन्न किया जाना चाहिए:

 var Lines = File.ReadAllLines(fileName); Dictionary = new Dictionary<int, string>(Lines.Length); foreach (var line in Lines) { var parts = line.Split('='); if (!Dictionary.ContainsKey(int.Parse(parts[1]))) Dictionary.Add(int.Parse(parts[1]), parts[0]); } 

fileName - CoolCompiler.tokens फ़ाइल का पथ

C # कोड में उत्पन्न पार्सर का उपयोग करना

 var tokenStream = new CommonTokenStream(lexer); //   lexer,   . parser = new CoolGrammarParser(tokenStream); Tree = parser.program(); //   ,     (.. program   ). 

वाक्यविन्यास के पेड़ को पार करने के लिए, IList इंटरफ़ेस के निम्न गुणों और विधियों का उपयोग किया जाता है:

• treeNode.ChildCount - ट्रीनोड नोड पर बच्चों की संख्या
• TreeNode.GetChild (i) - पेड़ से एक बच्चा हो रहा है नोड I
• treeNode.Type - इस नोड का टोकन। यह टाइप इंट का है और इसकी तुलना लेक्सर वर्ग में घोषित स्थिरांक से की जानी चाहिए। उदाहरण के लिए: TreeNode.Type == CoolGrammarLexer.EQUAL (चाहे दिया गया टोकन एक '=' चिन्ह है)। मैं ध्यान देना चाहता हूं कि जब किसी पेड़ को ट्रेस किया जाता है, तो टाइप संपत्ति का उपयोग करना आवश्यक होता है, न कि टेक्स्ट, क्योंकि संख्याओं को जोड़ना तुलनाओं की तुलना में तेजी से होता है। हालाँकि, त्रुटि की संभावना कम हो जाती है, क्योंकि सभी स्थिरांक स्वतः उत्पन्न हो जाते हैं।
• treeNode.Line - कोड में टोकन लाइन नंबर
• TreeNode.CharPositionInLine - लाइन की शुरुआत से कोड में टोकन स्थिति

मैं इस तथ्य पर भी विशेष ध्यान देना चाहता था कि C # में एक व्याकरण से कोड बनाते समय, आपको सार्वजनिक संशोधक को व्याकरण स्वयंसिद्ध (इस मामले में, कार्यक्रम से पहले) के सामने रखना होगा ताकि आप इसे कोड से बाद में कॉल कर सकें (अन्यथा यह निजी होगा)

निष्कर्ष

इस लेख में वर्णित है कि ANTLRWorks में व्याकरण का वर्णन कैसे किया जाता है, जो तब C # lexers और parsers उत्पन्न करने के लिए उपयोग किया जाता है, और एक lexer और parser का उपयोग कैसे करें। अगला लेख आपको एक भाषा के शब्दार्थ (यानी टाइपिंग चेकिंग, सिमेंटिक एरर को हैंडल करने) के बारे में बताएगा कि कैसे सिंटैक्स ट्री के प्रत्येक नोड को बायपास किया जाए और CIL निर्देशों के स्पष्टीकरण के साथ इसी सिंटैक्स के निर्माण के लिए CIL कोड जनरेट करें, कैसे वर्चुअल मशीन स्टैक काम करता है और अंतर्निहित के उपयोग की व्याख्या। .NET पुस्तकालय System.Reflection.E कोड पीढ़ी को सुविधाजनक बनाने के लिए। बेशक, मैं अपने रास्ते पर मिले नुकसानों का वर्णन करूँगा (विशेष रूप से, System.Reflection.Emit का उपयोग करके एक वर्ग पदानुक्रम बनाना)। यह भी वर्णन करेगा कि कैसे सुंदर वॉलपेपर को एक सुंदर और आधुनिक इंटरफ़ेस बनाने के लिए! हालांकि, निष्कर्ष में जो लिखा गया है वह पहले से ही आंशिक रूप से परिचय में लिखा गया है।

अंत में, मैं एक प्रश्न पूछना चाहता हूं कि हब्रोसोकिसिटी, जिसका उत्तर मुझे नहीं मिला:

C # lexer के लिए, मैं हमेशा NoViableAltException को फेंकने के लिए इस तरह का कोड जनरेट करता हूं, और इस थ्रो को किसी भी तरह से इंटरसेप्ट नहीं किया जा सकता है:

 catch (NoViableAltException nvae) { DebugRecognitionException(nvae); throw; } 

मैं एक व्याकरण फ़ाइल कैसे लिख सकता हूं ताकि इस पंक्ति में सिर्फ एक थ्रो न हो, लेकिन उदाहरण के लिए मेरा अपवाद उठाया गया है या क्या लेक्सर काम करना जारी रखता है? और आपको हर बार C # कोड जेनरेट होने पर इस लाइन को सही करना होगा। नोट: ANTLR में @rulecatch के साथ छेड़छाड़ करने से कुछ भी नहीं हुआ।

अच्छा होगा यदि कोई इस समस्या का पता लगाए और टिप्पणियों में उत्तर लिखे।

पढ़ने की सलाह दी

• निश्चित ANTLR संदर्भ, टेरेंस Parr, 2007।
• संकलनकर्ता। सिद्धांत, प्रौद्योगिकी और उपकरण, 2008, अल्फ्रेड डब्ल्यू। अहो, मोनिका एस। लाम, रवि सेटी, जेफरी डी। उल्मान

कूल भाषा मैनुअल, इसका व्याकरण फ़ाइल .g एक्सटेंशन, ANTLRWorks पर्यावरण के साथ