हम अपनी प्रोग्रामिंग भाषा लिखते हैं, भाग 3: अनुवादक वास्तुकला। भाषा संरचनाओं और गणितीय अभिव्यक्तियों का विश्लेषण

परिचय

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

शुरुआत के लिए, स्थापित परंपराओं के अनुसार, मैं पिछले लेखों के लिंक प्रदान करूंगा:

भाग 1: एक भाषा VM लिखना
भाग 2: कार्यक्रमों की मध्यवर्ती प्रस्तुति

अपने सिर को बनाने के लिए हम इन लेखों में जो लिखते हैं उसकी पूरी समझ रखते हैं, आपको पहले से पिछले भागों के साथ खुद को परिचित करना चाहिए।

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

और परियोजना के बारे में थोड़ा:

→ लघु परियोजना स्थल
→ गिटहब भंडार

ठीक है, मैं यह भी कहूंगा कि सब कुछ ऑब्जेक्ट Pascal में लिखा गया है, अर्थात् FPC में।

तो चलिए शुरू करते हैं।

अधिकांश अनुवादकों के संचालन का सिद्धांत

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

अनुवादक का कार्य सबसे पहले विश्लेषण के लिए कोड तैयार करना है (उदाहरण के लिए, उस पर टिप्पणियों को हटाने के लिए) और कोड को टोकन में तोड़ना (भाषा के लिए टोकन न्यूनतम वर्ण सेट है)।

इसके बाद, विश्लेषण और रूपांतरण करके, आपको कोड को एक निश्चित मध्यवर्ती प्रतिनिधित्व में पार्स करने की आवश्यकता है और फिर निष्पादन के लिए तैयार आवेदन को इकट्ठा करें या ... इसे सामान्य रूप से इकट्ठा करने की आवश्यकता क्या है।

हां, मैंने वास्तव में पाठ के इस समूह के साथ कुछ भी नहीं कहा है, हालांकि - अब कार्य कई उप-प्रकारों में विभाजित है।

चलो छोड़ें कि कोड निष्पादन के लिए कैसे तैयार किया गया है, क्योंकि किसी प्रक्रिया का वर्णन करना बहुत उबाऊ है। मान लीजिए कि हमारे पास विश्लेषण के लिए तैयार टोकन का एक सेट है।

कोड विश्लेषण

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

एक नियम के रूप में, अनिवार्य भाषाओं में, कोड को पहले से ही संरचनाओं से एक प्रकार के पेड़ के रूप में प्रस्तुत किया जाता है।

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

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

यानी हम टोकन के माध्यम से भागते हैं, हमारे पास एक टोकन है (उदाहरण के लिए, इसे रहने दें ...) "अगर" - मुझे वास्तव में संदेह है कि इस तरह का टोकन कोड में ठीक उसी तरह हो सकता है -> यह शुरुआत की है अगर..तो [..] .. अंत निर्माण!

हम अपनी भाषा में स्थितियों के निर्माण के लिए क्रमशः बाद के सभी टोकन का विश्लेषण करते हैं।

कोड त्रुटियों के बारे में थोड़ा

संरचनाओं के विश्लेषण के चरण में और कोड के साथ चलना, त्रुटियों के प्रसंस्करण को स्कोर नहीं करना बेहतर है। यह उपयोगी अनुवादक कार्यक्षमता है। यदि संरचना के विश्लेषण के दौरान कोई त्रुटि होती है, तो यह तर्कसंगत है - संरचना ठीक से नहीं बनाई गई है और आपको डेवलपर को सूचित करना चाहिए।

अब मैश के बारे में। भाषा की भाषा को कैसे पार्स किया जाता है?

ऊपर, मैंने एक अनुवादक डिवाइस की सामान्यीकृत अवधारणा का वर्णन किया। अब मेरे काम के बारे में बात करने का समय है।

वास्तव में, अनुवादक ऊपर वर्णित के समान ही निकला। लेकिन मेरे लिए यह आगे के विश्लेषण के लिए टोकन के एक समूह में कोड को नहीं तोड़ता है।

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

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

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

पी.एस. पिछले लेख में, मैंने एक वीएम के लिए एक मध्यवर्ती भाषा से बाईटेकोड तक एक अनुवादक के निर्माण का वर्णन किया। दरअसल - यह मध्यवर्ती भाषा एक मध्यवर्ती प्रतिनिधित्व है।

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

कोड पर वार्म-अप चलाते हैं

शुरू करने के लिए, अनुवादक को कोड के साथ खुद को जल्दी से परिचित करना चाहिए, उस पर जाना चाहिए और कुछ डिजाइनों पर ध्यान देना चाहिए।

इस बिंदु पर, आप वैश्विक चर के साथ सौदा कर सकते हैं, निर्माण का उपयोग कर सकते हैं, साथ ही आयात, प्रक्रिया और कार्य, और OOP निर्माण कर सकते हैं।

भंडारण के लिए कई वस्तुओं में एक मध्यवर्ती दृश्य उत्पन्न करना बेहतर है, ताकि
प्रारंभ के बाद वैश्विक चर के लिए कोड पेस्ट करें, लेकिन मुख्य () की शुरुआत से पहले।

ओओपी निर्माण के लिए कोड अंत में डाला जा सकता है।

परिष्कृत डिजाइन

ठीक है, हमने सरल डिजाइनों का पता लगाया। अब यह मुश्किल का समय है। मुझे नहीं लगता कि आप दो चक्रों के साथ उदाहरण को भूल गए। जैसा कि हम जानते हैं, संरचनाएं आमतौर पर एक प्रकार के पेड़ के रूप में आती हैं। इसका मतलब है कि हम स्टैक का उपयोग करके जटिल संरचनाओं को पार्स कर सकते हैं।

स्टैक का इससे क्या लेना-देना है? हालांकि।

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

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

मैं अभी पूरा कोड नहीं दूंगा, क्योंकि इसमें बहुत कुछ नहीं है:

unit u_prep_codeblock; {$mode objfpc}{$H+} interface uses Classes, SysUtils; type TBlockEntryType = (btProc, btFunc, btIf, btFor, btWhile, btUntil, btTry, btClass, btSwitch, btCase); TCodeBlock = class(TObject) public bType: TBlockEntryType; mName, bMeta, bMCode, bEndCode: string; constructor Create(bt: TBlockEntryType; MT, MC, EC: string); end; implementation constructor TCodeBlock.Create(bt: TBlockEntryType; MT, MC, EC: string); begin inherited Create; bType := bt; bMeta := MT; bMCode := MC; bEndCode := EC; end; end. 

खैर, स्टैक एक साधारण TList है, यहां पहिया को फिर से मजबूत करना सिर्फ सादे बेवकूफ है।

इस प्रकार, निर्माण को पार्स करते हुए, मान लें कि लूप इस तरह दिखता है:

 function ParseWhile(s: string; varmgr: TVarManager): string; var WhileNum, ExprCode: string; begin Delete(s, 1, 5); //"while" Delete(s, Length(s), 1); //":" s := Trim(s); //   ,       ... //        :) WhileNum := '__gen_while_' + IntToStr(WhileBlCounter); Inc(WhileBlCounter); //   while   // ,        if IsExpr(s) then ExprCode := PreprocessExpression(s, varmgr) else ExprCode := PushIt(s, varmgr); //  ExprCode     //        //    //(      ) Result := WhileNum + ':' + sLineBreak + 'pushcp ' + WhileNum + '_end' + sLineBreak + ExprCode + sLineBreak + 'jz' + sLineBreak + 'pop'; //        //  -        //   break BlockStack.Add(TCodeBlock.Create(btWhile, '', 'pushcp ' + WhileNum + sLineBreak + 'jp' + sLineBreak + WhileNum + '_end:', WhileNum + '_end')); end; 

गणित के भावों के बारे में

आपने इस पर ध्यान नहीं दिया होगा, लेकिन गणितीय / तार्किक अभिव्यक्तियाँ भी संरचित कोड हैं।

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

कई बार - क्योंकि गुणा के रूप में प्राथमिकता वाले गणितीय कार्य हैं।
मैं यहां बिंदु नहीं देखता, क्योंकि कई और उबाऊ हैं।

पी.एस. /lang/u_prep_expressions.pas - यहां यह आपकी समीक्षा के लिए पूरी तरह से और पूरी तरह से उजागर है।

परिणाम

इसलिए, हमने एक अनुवादक लागू किया है जो रूपांतरित कर सकता है ... उदाहरण के लिए, यह कोड है:

 proc PrintArr(arr): for(i ?= 0; i < len(arr); i++): PrintLn("arr[", i, "] = ", arr[i]) end end proc main(): var arr = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] PrintArr(arr) InputLn() end 

हमारी भाषा में क्या कमी है? ठीक है, OOP का समर्थन करें। हम इस बारे में अपने अगले लेख में बात करेंगे।

यदि आपने किया तो अंत तक पढ़ने के लिए धन्यवाद।

यदि आपके लिए कुछ स्पष्ट नहीं है, तो मुझे आपकी टिप्पणियों की प्रतीक्षा है। या मंच पर प्रश्न, हां ... हां, मैं इसे कभी-कभी जांचता हूं।

और अब एक छोटा मतदान (ताकि मैं इसे देखूं और अपने लेखों के महत्व का आनंद लूं):