हमारी गूढ़ भाषा के लिए दुभाषिया लिखना (भाग 2)

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

1. एक फ़ंक्शन (प्रक्रिया) की अवधारणा।
2. टिप्पणियाँ।

टिप्पणियाँ

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

unsigned int skipComment( std::ifstream &file )
{
unsigned int skipped = 0;
unsigned int unclosedComments = 1;
while( file.good() && ( unclosedComments != 0 ) )
{
char tmp = (char) file.get();
if ( bf_cBeg == tmp )
unclosedComments++;
else if ( tmp == bf_cEnd )
unclosedComments--;
skipped++;
}
return skipped;
}

जैसे ही '(' वर्ण का सामना होता है) फ़ंक्शन को कॉल किया जाएगा। यह टिप्पणी को "निगल" देगा और निगले गए वर्णों की संख्या वापस कर देगा।

कार्य / प्रक्रियाएं।

यहाँ, ज़ाहिर है, यह अधिक कठिन होगा!
हम मांग करेंगे:

• फ़ंक्शन का पहचानकर्ता (नाम) अद्वितीय होना चाहिए। अगला, हम देखेंगे कि यह आवश्यकता कहां से आई है।
• 2. फ़ंक्शन केवल एक मान लौटाता है, और यह (मान) शून्य रजिस्टर के मूल्य से मेल खाता है।
• 3. फ़ंक्शन को मापदंडों को स्थानांतरित करने के लिए, हम रजिस्टरों की वर्तमान स्थिति की एक प्रति का उपयोग करेंगे।

तो समारोह शरीर की तरह दिखना चाहिए:
{% <name>% <code>}

नाम एक प्रारंभिक कोष्ठक के बिना वर्णों का कोई भी अनुक्रम हो सकता है।

फ़ंक्शन का नाम खोजने के लिए, फ़ंक्शन का उपयोग करें:

std::string parseName( std::ifstream &file, const char parsingAfter )
{
if ( file.bad() || ( bf_fNme != parsingAfter ) )
return std::string();

std::string res = std::string();

while ( file.good() )
{
char tmp = (char) file.get();
if ( tmp == bf_fNme )
return res;
res += tmp;

}

return res;
}

यह फ़ंक्शन हमारे लिए उपयोगी होगा जब इसे कॉल करने के लिए फ़ंक्शन का नाम निर्धारित करना आवश्यक होगा। फ़ंक्शन को संग्रहीत करने के लिए, हम संरचना का उपयोग करेंगे:

struct proc
{
char code[ maxCodeSize ]; //
unsigned int realCodeSize; //
};

और हम फ़ंक्शन को std :: map <std :: string, proc> प्रक्रियाओं में संग्रहीत करेंगे, एक कुंजी के रूप में हम फ़ाइल का उपयोग करेंगे और फ़ंक्शन के पहचानकर्ता में भरेंगे। यह सीखना है कि फ़ाइल को पार्स कैसे करें और कंटेनर प्रक्रियाओं को कैसे भरें। यहां:

bool parseFunction( std::ifstream &file, const char parsingAfter )
{
if( ( bf_fBeg != parsingAfter ) || ( file.bad() ) )
return false;
if( bf_fNme != ( char ) file.get() )
return false;
std::string funcName = parseName( file, bf_fNme );

if( 0 == funcName.size() )
return false;

proc addProc;
addProc.realCodeSize = 0;

while( file.good() )
{
char tmp = (char) file.get();

if( bf_cBeg == tmp )
skipComment( file );
else if ( bf_cEnd == tmp )
; // Syntax error
else if ( bf_fEnd == tmp )
{
std::map<std::string, proc>::iterator it = procedures.find( funcName );
if( it == procedures.end() )
{
std::pair< std::string, proc > tmpP;
tmpP.first = funcName;
tmpP.second = addProc;
procedures.insert( tmpP );
std::cout << "Added proceudre: " << funcName << std::endl;
printCode( addProc.code, addProc.realCodeSize, funcName );
return true;
}
else
{
std::cerr << "Function with name " << funcName
<< " already exists. Ignoring all other definitions."
<< std::endl;
return false;
}
}
else
addProc.code[ addProc.realCodeSize++ ] = tmp;

}
return false;
}

तो, हमारे पास यह सब करने के लिए कई फ़ंक्शन, टिप्पणियां और एक लूप फ़ंक्शन है।
हमारी भाषा में 2 और वर्ण जोड़ें:

• # - वर्तमान के लिए जिम्मेदार रजिस्टर के मूल्य में वृद्धि, जबकि यदि कोई हो।
• ~ - जबकि वर्तमान के रजिस्टर की शुरुआत में कमी।

बस इतना ही। अब, जब कोड में '' @ 'का चिह्न मिलता है, तो हम फ़ंक्शन का नाम ढूंढते हैं, और नाम से हम फ़ंक्शन के शरीर को निष्पादित करते हैं। इसके लिए रजिस्टर की प्रतिलिपि बनाएँ, और लूप फ़ंक्शन को कॉल करें।

स्रोत कोड