हम अपनी गूढ़ भाषा के लिए एक दुभाषिया लिख ​​रहे हैं

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

तो ब्रेनफुक। संक्षेप में, विचार यह है कि एन रजिस्टर / सेल हैं। प्रोग्रामर की पहुंच उन सभी तक है, लेकिन उनके चारों ओर घूमना स्पष्ट रूप से होता है। यानी सेल 2 से सेल 7 पर तुरंत जाना असंभव है, यह क्रमिक रूप से आवश्यक है।

भाषा के "कीवर्ड":

• > - दाईं ओर सेल पर जाएं।
• <- सेल में बाईं ओर जाएं।
• + - सेल वैल्यू को एक से बढ़ाना।
• - - एक से सेल वैल्यू को घटाएं।
• , - मानक इनपुट डिवाइस से सेल में मान पढ़ें।
• । - एक मानक आउटपुट डिवाइस के साथ सेल वैल्यू प्रिंट करें।
• [- यदि वर्तमान सेल का मान 0 नहीं है और अगले सेल पर जाएं तो लूप को शुरू करें।
• ] जबकि ब्लॉक का अंत है। यदि "सशर्त कक्ष" का मान 0 नहीं है, तो चक्र को जारी रखें ("सशर्त कक्ष" वह कक्ष है जिस पर चक्र शुरू हुआ था)।

जोड़े गए "कीवर्ड":

• $ - सेल में मान को एक संख्या के रूप में पढ़ें (> ANCII वर्ण के रूप में रीडिफाइन के रूप में फिर से परिभाषित करें)
• ! - संख्या के रूप में प्रिंट करें
• {- फ़ंक्शन की शुरुआत, शुरुआत के बाद फ़ंक्शन का नाम होता है (अक्षर% <फ़ंक्शन का नाम>% के बीच अक्षरों का कोई भी अनुक्रम हो सकता है। किसी भी फ़ंक्शन के लिए कोशिकाओं की एक प्रतिलिपि बनाई जाती है, रिटर्न मान को कॉलिंग ब्लॉक के वर्तमान रजिस्टर में लिखा जाता है।
• } - समारोह का अंत
• - - टिप्पणी की शुरुआत
• ) - टिप्पणी का अंत
• @% <फ़ंक्शन नाम>% - फ़ंक्शन कॉल
• ^ - सेल को रीसेट करें

चूंकि कीवर्ड के पूरे सेट में ANCII वर्ण होते हैं, इसलिए हमारे पास:

//
const char bf_next = '>';
const char bf_prev = '<';
const char bf_incr = '+';
const char bf_decr = '-';
const char bf_prnt = '.';
const char bf_read = ',';
const char bf_wBeg = '[';
const char bf_wEnd = ']';

//
const char bf_pNum = '!' ;
const char bf_rNum = '$';
const char bf_fBeg = '{';
const char bf_fEnd = '}';
const char bf_fNme = '%';
const char bf_comm= '(';
const char bf_call = '@';
const char bf_null = '^';

सामान्यता के नुकसान के बिना, हम सीमित संख्या में सेल लेते हैं, 256 कहते हैं, और अगर हम एक अमान्य सेल में जाने की कोशिश करते हैं, तो हम बहुत पहले सेल में जाएंगे (यदि संक्रमण बाईं ओर है) या बहुत अंतिम तक (यदि दाईं ओर संक्रमण है)।

जोड़ें:

const unsigned long regSize = 256; //

long reg[ regSize ]; //
long stck[ regSize ]; // ,

void resetRegisters(); //

void printRegistres(); //

अब, मान लें कि हमारे पास test.bf है, इनपुट फ़ाइल के रूप में, जिसमें मेरी भाषा में कोड शामिल है या मेरे मूल ब्रेनफक में। दुभाषिया को "पिछड़ी अनुकूलता" प्रदान करनी चाहिए।

फिर, सामान्यता के नुकसान के बिना, हम सभी कोड को कुछ सीमित सरणी में संग्रहीत कर सकते हैं। यानी दुभाषिया सीमित आकार की फ़ाइलों के साथ काम करेगा, आइए इसे कहते हैं:

const unsigned long maxCodeSize = 1024000; /* */
unsigned long realCodeSize; // realCodeSize < maxCodeSize
char code[maxCodeSize]; //

दुभाषिया एक ही बार में सभी कोड पढ़ता है। एक वर्ण सरणी में, इसके लिए हम रीडकोड () फ़ंक्शन का उपयोग करेंगे। गैर-रिक्त पाठ पढ़ने के बाद, m_realCodeSize में कोड में सटीक वर्ण होंगे, टिप्पणियों को छोड़कर, टिप्पणियों को पढ़ते समय छोड़ दिया जाता है।

int main (int argc, char ** argv)
{
स्वागत ();
resetRegisters ();
readCode ("test.bf");
लूप (0, realCodeSize - 1, regSize, reg);
वापसी 0;
}

अगला, हम लूप के लिए कुछ कार्यों को परिभाषित करते हैं और स्टैक की नकल करते हैं और वास्तव में फ़ंक्शन को निष्पादित करते हैं।

bool loop( unsigned long from,
unsigned long to,
unsigned long condRegIndx,
unsigned long currReg,
long* registers );

bool runFunction( unsigned long from,
unsigned int to,
unsigned int& retValue);

void copyRegistersTo( long* source, long* destination );

पहला लूप निष्पादित करेगा और सही लौटेगा यदि लूप बिना समस्याओं के पूरा हो गया, अर्थात्। कोई सिंटैक्स त्रुटियाँ नहीं।

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

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

const unsigned long maxLoopCycles = 999999;

पहले हम पिछड़ी अनुकूलता को लागू करते हैं। हमारे दुभाषिया को अभी के लिए केवल ब्रेनफक कोड निष्पादित करने में सक्षम होने दें।
हमें कार्यों की आवश्यकता होगी:

bool makeCommand( char command, long* registers, unsigned long currReg )

unsigned long findLoopEnd( const unsigned long from )

पहले फ़ंक्शन के दूसरे और तीसरे पैरामीटर की आवश्यकता होती है। तीसरे पैरामीटर की आवश्यकता होती है कि किस सेल के साथ काम करने के लिए नेविगेट करने के लिए, दूसरे की आवश्यकता है क्योंकि प्रत्येक फ़ंक्शन के रजिस्टर अलग हैं, और उन पर संचालन समान हैं।

नाम के आधार पर दूसरा फ़ंक्शन, चक्र का अंत पाता है, अर्थात। संबंधित वर्ण '' '' है।

इस प्रकार, हमारे पास Brainfuck भाषा के लिए एक दुभाषिया है।
मैंने अपने दुभाषिया के स्रोत कोड को परीक्षण कोड के साथ रिकॉर्ड में संलग्न किया

$[+<->]<<$>!<>>++++[++++++++++<->]<+++.++++++++++++++++++<<<!>[<-<+>>]>>.<<<!

उपरोक्त कोड के लिए, मेरा दुभाषिया एक + b = c के रूप में दर्ज किए गए दो नंबरों के योग का उत्पादन करेगा।

सौभाग्य ... प्रोग्रामिंग!

पुनश्च
यदि दिलचस्पी है, तो मैं आपको बाद में बताऊंगा कि मैंने बाकी को कैसे लागू किया।