ब्रेनफॉक के लिए असेंबलर

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

मुख्य भागों का कार्यान्वयन

सुविधा के लिए, टेप को कई भागों में विभाजित किया गया था:

• रजिस्टरों
• अनेकता
• अस्थायी कोशिकाएँ और ध्वज कोशिकाएँ
• शेष स्मृति - सरणियों और तारों को संग्रहीत करने के लिए उपयोग किया जाता है

अनुवादक मानता है कि कार्यक्रम शून्य से भरे टेप के शून्य सेल पर शुरू होता है। टेप को लूप किया जाना चाहिए।

रजिस्टरों

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

mov ax 5 //   ax 5 mov bx 6 //   bx 6 sub ax bx //   ax 255 mov cx 12 mov dx 2 mul cx dx //  cx  24 mov dx 10 div cx dx //   :  cx - 2,  dx - 4 

अनेकता

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

 push ax push 5 pop bx pop cx 

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

अस्थायी कोशिकाएँ और ध्वज कोशिकाएँ

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

सरणियों

सरणी कोशिकाओं की श्रेणियां हैं जिन्हें सूचकांक द्वारा एक्सेस किया जा सकता है:

 array test 10 //    test    set test 0 42 //       42 get test 0 ax //   ax    

वैसे, एक सूचकांक एक रजिस्टर युक्त हो सकता है, उदाहरण के लिए, उपयोगकर्ता इनपुट, लेकिन 255 से अधिक सूचकांकों वाले तत्वों तक पहुंचना असंभव है।

पंक्तियां

स्ट्रिंग स्ट्रिंग के साथ घोषित किए जाते हैं:

 string hello "Hello, World!" //   hello puts hello //   

लाइनों को सरणियों के अनुभाग में रखा जाता है और जब प्रोग्राम शुरू होता है, तो इसे प्रारंभ किया जाता है।
स्ट्रिंग्स को ऐरे की तरह माना जा सकता है:

 get hello 0 ax put ax //  'H' 

बुनियादी निर्माण

इनपुट-आउटपुट

तीन I / O ऑपरेशन हैं:

 take ax //    ax    put ax //  ,    ax puts str //     str 

वैसे, पुट कमांड नियमित सरणियों को प्रिंट कर सकता है (इसमें पहले शून्य तक)।

साइकिल संगठन

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

 while ax //  while      // do smth. endwhile 

यह लूप तब तक कुछ करेगा जब तक कुल्हाड़ी शून्य नहीं हो जाती।

तुलना

तुलना असेंबलर शैली में की जाती है। किसी चीज़ की तुलना करने के लिए, आपको रजिस्टर में cmp कमांड लागू करने की आवश्यकता है:

 mov ax 2 mov bx 1 cmp ax bx 

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

 cmp ax bx //          ne //   //   ,     end nl //   // do end ng //   // do end eq //  // do end lt //  // do end gt //  // do end 

निष्कर्ष

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

उपयोगी लिंक

ब्रेनफॉक पर एल्गोरिदम - मैंने वहां से गुणा और विभाजन एल्गोरिदम का उपयोग किया।

BFDev एक सुविधाजनक ब्रेनफैक-आईडीई है, इसमें सभी कार्यक्रमों का परीक्षण किया गया था।

ब्रेनफिक्स एक उच्चस्तरीय भाषा है जिसका प्रसारण ब्रेनफॉक में किया जाता है। वहाँ से, संकलन समय में एक अज्ञात सूचकांक के साथ एक सरणी तत्व तक पहुंचने के लिए एक एल्गोरिथ्म लिया गया था।