🖖 🎅🏼 👲🏾 पायथन # 4 में खरोंच से एक साधारण दुभाषिया ⚠️ 🔜 🚴🏻

पिछले तीन भागों में, हमने अपनी खिलौना भाषा छोटा सा भूत के लिए लेसर, पार्सर और एएसटी बनाया। हमने पार्सर कॉम्बिनेटरों की अपनी लाइब्रेरी भी लिखी। इस अंतिम लेख में, हम दुभाषिया के अंतिम घटक - कलाकार को लिखेंगे।

सामग्री

पायथन # 1 में खरोंच से एक साधारण दुभाषिया
पायथन # 2 में खरोंच से एक साधारण दुभाषिया
पायथन # 3 में खरोंच से एक साधारण दुभाषिया
पायथन # 4 में खरोंच से एक साधारण दुभाषिया

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

एक IMP प्रोग्राम निष्पादित करने के लिए, हमें तीन चीजों की आवश्यकता है:

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

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

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

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

निष्पादन कार्यों को परिभाषित करें

हम उन्हें अपने एएसटी वर्गों में विधियों के रूप में परिभाषित करेंगे। यह प्रत्येक फ़ंक्शन को सीधे उस संरचना तक पहुंच प्रदान करेगा जो वह प्रदर्शन करती है। यहाँ अंकगणितीय कार्य हैं:

class IntAexp(Aexp): ... def eval(self, env): return self.i class VarAexp(Aexp): ... def eval(self, env): if self.name in env: return env[self.name] else: return 0 class BinopAexp(Aexp): ... def eval(self, env): left_value = self.left.eval(env) right_value = self.right.eval(env) if self.op == '+': value = left_value + right_value elif self.op == '-': value = left_value - right_value elif self.op == '*': value = left_value * right_value elif self.op == '/': value = left_value / right_value else: raise RuntimeError('unknown operator: ' + self.op) return value

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

बिनोपएएक्सएपी में, हम "अज्ञात ऑपरेटर" के मामले को रनटाइमइमर को फेंककर संभालते हैं । Parser अज्ञात ऑपरेटरों से एक AST नहीं बना सकता है, इसलिए यह केवल हमारे लिए आसान हो जाता है। लेकिन अगर कोई अपना खुद का एएसटी बनाता है, तो उस पर विचार करने की आवश्यकता होगी।

यहाँ बूलियन संचालन के कार्य हैं:

 class RelopBexp(Bexp): ... def eval(self, env): left_value = self.left.eval(env) right_value = self.right.eval(env) if self.op == '<': value = left_value < right_value elif self.op == '<=': value = left_value <= right_value elif self.op == '>': value = left_value > right_value elif self.op == '>=': value = left_value >= right_value elif self.op == '=': value = left_value == right_value elif self.op == '!=': value = left_value != right_value else: raise RuntimeError('unknown operator: ' + self.op) return value class AndBexp(Bexp): ... def eval(self, env): left_value = self.left.eval(env) right_value = self.right.eval(env) return left_value and right_value class OrBexp(Bexp): ... def eval(self, env): left_value = self.left.eval(env) right_value = self.right.eval(env) return left_value or right_value class NotBexp(Bexp): ... def eval(self, env): value = self.exp.eval(env) return not value

यह बहुत सरल है। हम पिटोनी रिलेशनल और लॉजिकल ऑपरेटर्स का उपयोग करते हैं।

और यहां प्रत्येक प्रकार की अभिव्यक्ति के लिए निष्पादन कार्य हैं:

 class AssignStatement(Statement): ... def eval(self, env): value = self.aexp.eval(env) env[self.name] = value class CompoundStatement(Statement): ... def eval(self, env): self.first.eval(env) self.second.eval(env) class IfStatement(Statement): ... def eval(self, env): condition_value = self.condition.eval(env) if condition_value: self.true_stmt.eval(env) else: if self.false_stmt: self.false_stmt.eval(env) class WhileStatement(Statement): ... def eval(self, env): condition_value = self.condition.eval(env) while condition_value: self.body.eval(env) condition_value = self.condition.eval(env)

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

CompoundStatement: हम प्रत्येक अभिव्यक्ति को निष्पादित करते हैं, एक के बाद एक। याद रखें कि जहां भी अभिव्यक्ति की अनुमति है, CompoundStatement की अनुमति है, इसलिए अभिव्यक्तियों की लंबी श्रृंखला को नेस्टेड के रूप में डिकोड किया जाता है।

IfStatement: सबसे पहले, हम अभिव्यक्ति की बूलियन स्थिति को निष्पादित करते हैं। यदि सत्य है, तो हम एक सच्चे अभिव्यक्ति को क्रियान्वित करते हैं। यदि गलत और गलत अभिव्यक्ति को परिभाषित किया गया है, तो हम झूठी अभिव्यक्ति को निष्पादित करते हैं।

जबकिStatement: हम यह जांचने के लिए शर्त पूरी करते हैं कि लूप के शरीर को एक बार निष्पादित करना चाहिए या नहीं। हालत की जाँच करने के लिए हालत लूप के प्रत्येक पुनरावृत्ति को निष्पादित किया जाता है।

यह सब एक साथ रखना

खैर, हमने अपने दुभाषिया के मुख्य घटक बनाए हैं और अब यह केवल एक एकीकृत कार्यक्रम लिखने के लिए बना हुआ है:

 #!/usr/bin/env python import sys from imp_parser import * from imp_lexer import * def usage(): sys.stderr.write('Usage: imp filename\n') sys.exit(1) if __name__ == '__main__': if len(sys.argv) != 2: usage() filename = sys.argv[1] text = open(filename).read() tokens = imp_lex(text) parse_result = imp_parse(tokens) if not parse_result: sys.stderr.write('Parse error!\n') sys.exit(1) ast = parse_result.value env = {} ast.eval(env) sys.stdout.write('Final variable values:\n') for name in env: sys.stdout.write('%s: %s\n' % (name, env[name]))

कार्यक्रम में केवल एक तर्क की आपूर्ति की जाती है - व्याख्या करने के लिए नाम। वह फ़ाइल पढ़ती है और इसे लेसर और पार्सर को भेजती है, एक त्रुटि (यदि कोई है) की रिपोर्ट करती है। फिर हम पार्सर परिणाम से एएसटी निकालते हैं और खाली वातावरण का उपयोग करके इसे निष्पादित करते हैं। चूंकि IMP का कोई आउटपुट नहीं है, इसलिए हम टर्मिनल के लिए पूरे वातावरण का उत्पादन करते हैं।

भाज्य की गणना का एक विहित उदाहरण:

 n := 5; p := 1; while n > 0 do p := p * n; n := n - 1 end

निष्पादन ही:

 $ ./imp.py hello.imp Final variable values: p: 120 n: 0

निष्कर्ष

पिछले लेख में, हमने खरोंच से अपनी सरल भाषा के लिए एक दुभाषिया लिखा था। भाषा स्वयं कम उपयोग की है, लेकिन दुभाषिया काफी विस्तृत है और इसके मुख्य घटकों का उपयोग किसी और चीज में किया जा सकता है।

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

वैरिएबल को नाम स्थान पर स्थानीय बनाएं।
लूप के लिए जोड़ें।
I / O (इनपुट / आउटपुट) के लिए भाव जोड़ें।
सुविधाएँ जोड़ें।

पायथन # 4 में खरोंच से एक साधारण दुभाषिया

निष्पादन कार्यों को परिभाषित करें

यह सब एक साथ रखना

निष्कर्ष

More articles: