🗞️ 🌏 🐼 हम अपनी प्रोग्रामिंग भाषा लिखते हैं, भाग 1: हम एक भाषा VM लिखते हैं 🐏 🔌 😀

परिचय

सभी हब्बरचित्तेली को शुभ दिन!

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

मैं यहाँ पहले बताई गई भाषा के निर्माण का वर्णन करूँगा।

उन्होंने कई दिलचस्पी ली और टिप्पणियों में एक गर्म चर्चा को उकसाया। इसलिए - विषय कई के लिए दिलचस्प है।

मुझे लगता है कि यह परियोजना के बारे में तुरंत जानकारी पोस्ट करने के लायक है:

साइट (थोड़ी देर बाद प्रलेखन से भर जाएगी)।
कोष

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

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

इसलिए, शायद मैं अपनी कहानी शुरू करूंगा।

हमने लक्ष्य निर्धारित किए

सबसे पहले, किसी भी परियोजना को अपने लक्ष्यों और टीके की आवश्यकता होती है, जिसे भविष्य में लागू करना होगा। अग्रिम में यह तय करना आवश्यक है कि इसके लिए प्राथमिक वीएम लिखने के लिए किस प्रकार की भाषा बनाई जाएगी।

मेरे VM के आगे के विकास को निर्धारित करने वाले प्रमुख बिंदु इस प्रकार हैं:

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

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

मुझे तुरंत यह कहना चाहिए कि मैंने VM को यथासंभव स्पष्ट कहा - SVM (स्टैक-आधारित वर्चुअल मशीन)।

चलो चर वर्ग के कार्यान्वयन के साथ शुरू करते हैं

प्रारंभ में, मैंने बस एक भिन्न प्रकार का उपयोग किया, क्योंकि यह सरल और तेज है। यह एक बैसाखी थी, लेकिन इसने परियोजना को आगे बढ़ाया और मुझे वीएम और भाषा के पहले संस्करण को जल्दी से लागू करने की अनुमति दी। बाद में मैं कोड पर बैठ गया और मेरे "संस्करण" के कार्यान्वयन को लिखा। संक्षेप में, आपको एक वर्ग लिखने की ज़रूरत है जो एक पॉइंटर को मेमोरी में एक मूल्य में संग्रहीत करता है, मेरे कार्यान्वयन में यह null/cardinal/int64/double/string/array । कोई केस टाइपिंग का उपयोग कर सकता है, लेकिन मुझे लगा कि मेरे द्वारा लागू किए गए तरीके को लागू करना बेहतर होगा।

क्लास कोड लिखना शुरू करने से पहले, मैंने भविष्य की भाषा में स्ट्रिंग्स के लिए अधिक लचीली समर्थन के लिए मॉड्यूल हेडर में {$ H +} निर्देश को तुरंत डालने का फैसला किया।

पी.एस. उन लोगों के लिए जो H- और H + FPC मोड के बीच अंतर के बारे में नहीं जानते होंगे।

एच-मोड में कोड असेंबल करते समय, स्ट्रिंग को वर्णों के एक सरणी के रूप में प्रस्तुत किया जाएगा। जब H + - स्मृति के एक टुकड़े के लिए एक संकेतक के रूप में। पहले मामले में, लाइनों को शुरू में लंबाई में तय किया जाएगा और डिफ़ॉल्ट रूप से 256 वर्णों तक सीमित किया जाएगा। दूसरे मामले में, लाइनें गतिशील रूप से विस्तार योग्य होंगी और उनमें बहुत अधिक वर्णों को समेटा जा सकता है। वे थोड़ा धीमा काम करेंगे, लेकिन अधिक कार्यात्मक रूप से। एच + के साथ, आप स्ट्रिंग को वर्णों के एक सरणी के रूप में भी घोषित कर सकते हैं, उदाहरण के लिए इस तरह से:
 var s:string[256]; 

इसलिए, शुरुआत के लिए, हम Enum को एक प्रकार घोषित करेंगे, जिसे हम सूचक द्वारा डेटा प्रकार निर्धारित करने के लिए एक निश्चित ध्वज के रूप में उपयोग करेंगे:

 type TSVMType = (svmtNull, svmtWord, svmtInt, svmtReal, svmtStr, svmtArr);

अगला, हम अपने चर प्रकार और कुछ विधियों की मूल संरचना का वर्णन करते हैं:

  TSVMMem = class m_val: pointer; m_type: TSVMType; constructor Create; destructor Destroy; procedure Clear; end; ... constructor TSVMMem.Create; begin m_val := nil; m_type := svmtNull; end; destructor TSVMMem.Destroy; begin Clear; end; procedure TSVMMem.Clear; inline; begin case m_type of svmtNull: { nop }; svmtWord: Dispose(PCardinal(m_val)); svmtInt: Dispose(PInt64(m_val)); svmtReal: Dispose(PDouble(m_val)); svmtStr: Dispose(PString(m_val)); svmtArr: begin SetLength(PMemArray(m_val)^, 0); Dispose(PMemArray(m_val)); end; else Error(reVarInvalidOp); end; end;

वर्ग को कुछ भी विरासत में नहीं मिलता है, इसलिए निर्माणकर्ता और विध्वंसक में विरासत में मिली कॉल को छोड़ा जा सकता है। मैं इनलाइन निर्देश पर ध्यान दूंगा। फ़ाइल हेडर में {$ इनलाइन को जोड़ना सुनिश्चित करना बेहतर है। VMs में इसके सक्रिय उपयोग ने उत्पादकता में काफी वृद्धि की (कहीं-कहीं 15-20% तक एमबी!)। वह संकलक को बताती है कि विधि का शरीर इसके आह्वान के स्थान पर सबसे अच्छा एम्बेडेड है। आउटपुट कोड अंत में थोड़ा बड़ा होगा, लेकिन तेजी से काम करेगा। इस मामले में, इनलाइन का उपयोग करना उचित है।

ठीक है, इस स्तर पर हमने अपनी कक्षा की नींव को धो दिया है। अब हमें अपनी कक्षा में कई सेटरों और गेटर्स (सेटर एंड गेट्टर) का वर्णन करने की आवश्यकता है।

कार्य कुछ तरीकों को लिखना है जो आपको रटना करने की अनुमति देगा और बाद में हमारी कक्षा से मान प्राप्त करेगा।

पहले, आइए हमारी कक्षा के लिए एक मान असाइन करें। पहले आप एक सामान्यीकृत सेटर लिख सकते हैं, और फिर व्यक्तिगत डेटा प्रकारों के लिए:

 procedure TSVMMem.SetV(const value; t:TSVMType); inline; begin if (m_val <> nil) and (m_type = t) then begin case t of svmtWord: PCardinal(m_val)^ := Cardinal(value); svmtInt: PInt64(m_val)^ := Int64(value); svmtReal: PDouble(m_val)^ := Double(value); svmtStr: PString(m_val)^ := String(value); end; end else begin if m_val <> nil then FreeMem(m_val); m_type := t; case t of svmtWord: begin New(PCardinal(m_val)); PCardinal(m_val)^ := Cardinal(value); end; svmtInt: begin New(PInt64(m_val)); PInt64(m_val)^ := Int64(value); end; svmtReal: begin New(PDouble(m_val)); PDouble(m_val)^ := Double(value); end; svmtStr: begin New(PString(m_val)); PString(m_val)^ := String(value); end; else Error(reVarTypeCast); end; end; end; ... procedure TSVMMem.SetW(value:cardinal); inline; begin if (m_val <> nil) and (m_type = svmtWord) then PCardinal(m_val)^ := value else begin if m_val <> nil then FreeMem(m_val); m_type := svmtWord; New(PCardinal(m_val)); PCardinal(m_val)^ := value; end; end;

अब आप एक जोड़े के लिए कोड लिख सकते हैं:

 function TSVMMem.GetW:cardinal; inline; begin Result := 0; case m_type of svmtWord: Result := PCardinal(m_val)^; svmtInt: Result := PInt64(m_val)^; svmtReal: Result := Trunc(PDouble(m_val)^); svmtStr: Result := StrToQWord(PString(m_val)^); else Error(reVarTypeCast); end; end;

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

 procedure TSVMMem.OpAdd(m:TSVMMem); inline; begin case m_type of svmtWord: case m.m_type of svmtWord: SetW(GetW + m.GetW); svmtInt: SetI(GetW + m.GetI); svmtReal: SetD(GetW + m.GetD); svmtStr: SetD(GetW + StrToFloat(m.GetS)); else Error(reVarInvalidOp); end; svmtInt: case m.m_type of svmtWord: SetI(GetI + m.GetW); svmtInt: SetI(GetI + m.GetI); svmtReal: SetD(GetI + m.GetD); svmtStr: SetD(GetI + StrToFloat(m.GetS)); else Error(reVarInvalidOp); end; svmtReal: case m.m_type of svmtWord: SetD(GetD + m.GetW); svmtInt: SetD(GetD + m.GetI); svmtReal: SetD(GetD + m.GetD); svmtStr: SetD(GetD + StrToFloat(m.GetS)); else Error(reVarInvalidOp); end; svmtStr: case m.m_type of svmtWord: SetS(GetS + IntToStr(m.GetW)); svmtInt: SetS(GetS + IntToStr(m.GetI)); svmtReal: SetS(GetS + FloatToStr(m.GetD)); svmtStr: SetS(GetS + m.GetS); else Error(reVarInvalidOp); end; else Error(reVarInvalidOp); end; end;

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

 function TSVMMem.ArrGet(index: cardinal; grabber:PGrabber): pointer; inline; begin Result := nil; case m_type of svmtArr: Result := PMemArray(m_val)^[index]; svmtStr: begin Result := TSVMMem.CreateFW(Ord(PString(m_val)^[index])); grabber^.AddTask(Result); end; else Error(reInvalidOp); end; end;

सुपर। अब हम आगे बढ़ सकते हैं।

हमें एक स्टैक का एहसास होता है

थोड़ी देर बाद मुझे ऐसे विचार आए। स्टैक एक ही समय में स्थिर (गति के लिए) और गतिशील (लचीलेपन के लिए) दोनों होना चाहिए।

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

मैं पूरे स्टैक कार्यान्वयन को लाता हूं:

 type TStack = object public items: array of pointer; size, i_pos: cardinal; parent_vm: pointer; procedure init(vm: pointer); procedure push(p: pointer); function peek: pointer; procedure pop; function popv: pointer; procedure swp; procedure drop; end; PStack = ^TStack; procedure TStack.init(vm: pointer); begin SetLength(items, StackBlockSize); i_pos := 0; size := StackBlockSize; parent_vm := vm; end; procedure TStack.push(p: pointer); inline; begin items[i_pos] := p; inc(i_pos); if i_pos >= size then begin size := size + StackBlockSize; SetLength(items, size) end; end; function TStack.peek: pointer; inline; begin Result := items[i_pos - 1]; end; procedure TStack.pop; inline; begin dec(i_pos); if size - i_pos > StackBlockSize then begin size := size - StackBlockSize; SetLength(items, size); end; end; function TStack.popv: pointer; inline; begin dec(i_pos); Result := items[i_pos]; if size - i_pos > StackBlockSize then begin size := size - StackBlockSize; SetLength(items, size); end; end; procedure TStack.swp; inline; var p: pointer; begin p := items[i_pos - 2]; items[i_pos - 2] := items[i_pos - 1]; items[i_pos - 1] := p; end; procedure TStack.drop; inline; begin SetLength(items, StackBlockSize); size := StackBlockSize; i_pos := 0; end;

बाहरी तरीकों में, वीएम स्टैक को एक पॉइंटर पास करेगा ताकि वे वहां से आवश्यक तर्क ले सकें। VM स्ट्रीम में एक पॉइंटर को बाद में जोड़ा गया, ताकि बाहरी तरीकों से कॉलबैक कॉल को कार्यान्वित किया जा सके और सामान्य तौर पर, VM तरीकों पर अधिक शक्ति स्थानांतरित की जा सके।

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

कचरा के बारे में बात करें

यह आमतौर पर बहुत, बहुत कुछ है। और आपको इसके साथ कुछ करने की जरूरत है।

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

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

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

यानी कॉल के समय कचरा संग्रहकर्ता के पास बिंदुओं की एक तैयार-निर्मित सूची होती है, जिसे आपको ऊपर जाने और मेमोरी को खाली करने की आवश्यकता होती है।

तो, अब हम एक सार निष्पादन योग्य फ़ाइल में संकलन से निपटेंगे

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

ऐसा करने के लिए, आपको निष्पादन योग्य फ़ाइलों के प्रारूप को निर्धारित करने की आवश्यकता है। मुझे निम्नलिखित मिला:

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

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

कोड निष्पादन

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

ओपकोड का एक सेट - एक छोटी सी टिप्पणी के साथ एक आभासी मशीन के लिए निर्देश जो मैं पहले से दिखाता हूं:

 type TComand = ( {** for stack **} bcPH, // [top] = [var] bcPK, // [var] = [top] bcPP, // pop bcSDP, // stkdrop bcSWP, // [top] <-> [top-1] {** jump's **} bcJP, // jump [top] bcJZ, // [top] == 0 ? jp [top-1] bcJN, // [top] <> 0 ? jp [top-1] bcJC, // jp [top] & push callback point as ip+1 bcJR, // jp to last callback point & rem last callback point {** for untyped's **} bcEQ, // [top] == [top-1] ? [top] = 1 : [top] = 0 bcBG, // [top] > [top-1] ? [top] = 1 : [top] = 0 bcBE, // [top] >= [top-1] ? [top] = 1 : [top] = 0 bcNOT, // [top] = ![top] bcAND, // [top] = [top] and [top-1] bcOR, // [top] = [top] or [top-1] bcXOR, // [top] = [top] xor [top-1] bcSHR, // [top] = [top] shr [top-1] bcSHL, // [top] = [top] shl [top-1] bcNEG, // [top] = -[top] bcINC, // [top]++ bcDEC, // [top]-- bcADD, // [top] = [top] + [top-1] bcSUB, // [top] = [top] - [top-1] bcMUL, // [top] = [top] * [top-1] bcDIV, // [top] = [top] / [top-1] bcMOD, // [top] = [top] % [top-1] bcIDIV, // [top] = [top] \ [top-1] bcMV, // [top]^ = [top-1]^ bcMVBP, // [top]^^ = [top-1]^ bcGVBP, // [top]^ = [top-1]^^ bcMVP, // [top]^ = [top-1] {** memory operation's **} bcMS, // memory map size = [top] bcNW, // [top] = @new bcMC, // copy [top] bcMD, // double [top] bcRM, // rem @[top] bcNA, // [top] = @new array[ [top] ] of pointer bcTF, // [top] = typeof( [top] ) bcSF, // [top] = sizeof( [top] ) {** array's **} bcAL, // length( [top] as array ) bcSL, // setlength( [top] as array, {stack} ) bcPA, // push ([top] as array)[top-1] bcSA, // peek [top-2] -> ([top] as array)[top-1] {** memory grabber **} bcGPM, // add pointer to TMem to grabber task-list bcGC, // run grabber {** constant's **} bcPHC, // push copy of const bcPHCP, // push pointer to original const {** external call's **} bcPHEXMP, // push pointer to external method bcINV, // call external method bcINVBP, // call external method by pointer [top] {** for thread's **} bcPHN, // push null bcCTHR, // [top] = thread(method = [top], arg = [top+1]):id bcSTHR, // suspendthread(id = [top]) bcRTHR, // resumethread(id = [top]) bcTTHR, // terminatethread(id = [top]) {** for try..catch..finally block's **} bcTR, // try @block_catch = [top], @block_end = [top+1] bcTRS, // success exit from try/catch block bcTRR, // raise exception, message = [top] {** for string's **} bcSTRD, // strdel bcCHORD, bcORDCH, {** [!] directly memory operations **} bcALLC, //alloc memory bcRALLC, //realloc memory bcDISP, //dispose memory bcGTB, //get byte bcSTB, //set byte bcCBP, //mem copy bcRWBP, //read word bcWWBP, //write word bcRIBP, //read int bcWIBP, //write int bcRFBP, //read float bcWFBP, //write float bcRSBP, //read string bcWSBP, //write string bcTHREXT,//stop code execution bcDBP //debug method call );

तो, आप धाराप्रवाह परिचित हैं कि मेरे द्वारा लिखित वीएम किन कार्यों को अंजाम दे सकता है। अब मैं इस बारे में बात करना चाहता हूं कि यह सब कैसे काम करता है।

एक वीएम को एक वस्तु के रूप में लागू किया जाता है, जिससे आप आसानी से मल्टीथ्रेडिंग समर्थन को लागू कर सकते हैं।

इसमें ऑपकोड के साथ एक सरणी के लिए एक संकेतक है, आईपी (इंस्ट्रक्शन पॉइंटर) - अन्य वीएम संरचनाओं को निष्पादित निर्देश और संकेत की ऑफसेट।

कोड निष्पादन एक बड़ा स्विच-केस है।

बस VM का विवरण दें:

 type TSVM = object public ip, end_ip: TInstructionPointer; mainclasspath: string; mem: PMemory; stack: TStack; cbstack: TCallBackStack; bytes: PByteArr; grabber: TGrabber; consts: PConstSection; extern_methods: PImportSection; try_blocks: TTRBlocks; procedure Run; procedure RunThread; procedure LoadByteCodeFromFile(fn: string); procedure LoadByteCodeFromArray(b: TByteArr); end;

अपवाद से निपटने के बारे में थोड़ा सा

ऐसा करने के लिए, वीएम में अपवाद हैंडलर्स का एक ढेर होता है और एक बड़ी कोशिश / कैच ब्लॉक होता है जिसमें कोड निष्पादन लिपटा होता है। स्टैक से, आप एक संरचना डाल सकते हैं जिसमें प्रवेश पर एक ऑफसेट बिंदु ऑफसेट है और अंत में / अंत अपवाद हैंडलिंग ब्लॉक है। मैंने ट्रॉ ओपोड भी प्रदान किया, जो कि पकड़ने से पहले रखा जाता है और कोड को अंत में / अंत में फेंक देता है यदि यह सफल होता है, साथ ही साथ संबंधित स्टैक के शीर्ष से अपवाद हैंडलर के बारे में जानकारी के साथ ब्लॉक को हटा देता है। क्या यह सरल है? बस। क्या यह सुविधाजनक है? सुविधाजनक।

चलो बाहरी तरीकों और पुस्तकालयों के बारे में बात करते हैं

मैंने पहले ही उनका उल्लेख किया। आयात, पुस्तकालय ... उनके बिना, भाषा में वांछित लचीलापन और कार्यक्षमता नहीं होगी।

सबसे पहले, वीएम के कार्यान्वयन में, हम इसे कॉल करने के लिए बाहरी विधि के प्रकार और प्रोटोकॉल की घोषणा करेंगे।

 type TExternalFunction = procedure(PStack: pointer); cdecl; PExternalFunction = ^TExternalFunction;

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

बाद में कोड निष्पादन के दौरान कॉल इस तरह से होता है:

 TExternalFunction(self.extern_methods^.GetFunc(TSVMMem(self.stack.popv).GetW))(@self.stack);

आइए हमारे वीएम के लिए एक सरल पुस्तकालय लिखें

और उसे पहली नींद विधि लागू करने दें:

 library bf; {$mode objfpc}{$H+} uses SysUtils, svm_api in '..\svm_api.pas'; procedure DSleep(Stack:PStack); cdecl; begin sleep(TSVMMem(Stack^.popv).GetW); end; exports DSleep name 'SLEEP'; end.

परिणाम

इस पर मैं शायद एक चक्रित चक्र से अपना पहला लेख समाप्त करूंगा।

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

पूरा VM कोड रिपॉजिटरी में / रनटाइम / svm ब्रांच में उपलब्ध है।

यदि आपको यह लेख पसंद आया है, तो कर्म में प्लस फेंकने और इसे शीर्ष में उठाने के लिए आलसी मत बनो, मैंने कोशिश की और आपके लिए प्रयास करूंगा।

यदि आपके लिए कुछ स्पष्ट नहीं है, तो टिप्पणी या मंच पर आपका स्वागत है।

शायद आपके सवाल और उनके जवाब न केवल आपके लिए दिलचस्प होंगे।

हम अपनी प्रोग्रामिंग भाषा लिखते हैं, भाग 1: हम एक भाषा VM लिखते हैं