🛷 🤘 👩‍💼 पायथन में खरोंच से एक साधारण दुभाषिया (भाग 3) 🔄 🥂 🆓

सामग्री

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

प्रकाशन के लिए स्पष्टीकरण

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

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

एएसटी निर्धारित करें

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

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

अल्फ़ान्यूमेरिक स्थिरांक जैसे 42
चर जैसे x
बाइनरी ऑपरेशन जैसे x + 42 । वे अन्य अंकगणितीय अभिव्यक्तियों से बनते हैं।

हम एक साथ कोष्ठक (जैसे (x+2)*3 ) में भावों को भी समूहबद्ध कर सकते हैं। यह एक अलग प्रकार की अभिव्यक्ति नहीं है, लेकिन एक अभिव्यक्ति को पार्स करने का एक अलग तरीका है।
हम इन रूपों के लिए तीन वर्गों को परिभाषित करते हैं, साथ ही आधार अंकगणितीय अभिव्यक्तियों के लिए एक आधार वर्ग। अब तक, कक्षाएं जानकारी के अलावा कुछ भी नहीं करती हैं। __repr__ विधि __repr__ को डीबगिंग के दौरान प्रिंट करने की अनुमति देगा। सभी AST वर्ग Equality का वारिस होगा, इसलिए हम दो AST वस्तुओं की पहचान की जांच कर सकते हैं, जो परीक्षण करते समय भी उपयोगी है।

 from equality import * class Aexp(Equality): pass class IntAexp(Aexp): def __init__(self, i): self.i = i def __repr__(self): return 'IntAexp(%d)' % self.i class VarAexp(Aexp): def __init__(self, name): self.name = name def __repr__(self): return 'VarAexp(%s)' % self.name class BinopAexp(Aexp): def __init__(self, op, left, right): self.op = op self.left = left self.right = right def __repr__(self): return 'BinopAexp(%s, %s, %s)' % (self.op, self.left, self.right)

तार्किक अभिव्यक्तियाँ थोड़ी अधिक जटिल हैं। तार्किक अभिव्यक्ति के 4 प्रकार हैं:

संबंध अभिव्यक्ति (जैसे x < 10 )
And भाव (जैसे x < 10 and y > 20 )
Or भाव
भाव Not

रिलेशनशिप एक्सप्रेशन के बाएँ और दाएँ पक्ष अंकगणितीय एक्सप्रेशन हैं। बाएँ और दाएँ पक्ष and , या not भाव तार्किक अभिव्यक्ति हैं। इस प्रकार का भेद हमें व्यर्थ भावों जैसे x < 10 and 30 से बचने में मदद करता है।

 class Bexp(Equality): pass class RelopBexp(Bexp): def __init__(self, op, left, right): ... class AndBexp(Bexp): def __init__(self, left, right): ... class OrBexp(Bexp): def __init__(self, left, right): ... class NotBexp(Bexp): def __init__(self, exp): ...

कथन (कथन) में एक ही समय में अंकगणित और तार्किक भाव हो सकते हैं। 4 प्रकार के भाव हैं: असाइनमेंट, जॉइन, कंडीशन और लूप।

 class Statement(Equality): pass class AssignStatement(Statement): def __init__(self, name, aexp): ... class CompoundStatement(Statement): def __init__(self, first, second): ... class IfStatement(Statement): def __init__(self, condition, true_stmt, false_stmt): ... class WhileStatement(Statement): def __init__(self, condition, body): ...

पुरातन

अब हमारे पास हमारी AST कक्षाएं और कॉम्बिनेटर का एक उपयुक्त सेट है - यह हमारे पार्सर को लिखने का समय है। जब एक पार्सर लिखते हैं, तो भाषा की बुनियादी संरचनाओं से शुरू करना आसान होता है, धीरे-धीरे अधिक जटिल चीजों पर आगे बढ़ रहा है।

keyword पार्सर को देखने वाला पहला पार्सर है। यह RESERVED टैग का उपयोग करके RESERVED का एक विशेष संस्करण है, जो सभी कीवर्ड को चिह्नित करता है। याद रखें, Reserved एकल टोकन से मेल खाता है, जिसका मूल्य और टैग हस्तांतरित किए गए समान हैं।

 def keyword(kw): return Reserved(kw, RESERVED)

keyword एक वास्तविक कॉम्बिनेटर है, क्योंकि यह एक फ़ंक्शन है जो एक पार्सर को लौटाता है। हम इसे अन्य पार्सर में सीधे उपयोग करेंगे।

id पार्सर का उपयोग चर नामों से मेल खाने के लिए किया जाता है। यह Tag कॉम्बिनेटर का उपयोग करता है, जो निर्दिष्ट टैग के साथ टोकन से मेल खाता है।

 id = Tag(ID)

num पार्सर का उपयोग पूर्णांकों से मेल खाने के लिए किया जाता है। यह लगभग id तरह काम करता है, सिवाय इसके कि हम एक विशेष पूर्णांक में टोकन को बदलने के लिए Process कॉम्बिनेटर (अधिक सटीक, ^ ऑपरेटर जिसे Process कहते हैं) का उपयोग करते हैं।

 num = Tag(INT) ^ (lambda i: int(i))

पार्सिंग अंकगणित अभिव्यक्तियाँ

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

पहले हम aexp_value पार्सर को परिभाषित करते हैं जो num और id द्वारा लौटाए गए मानों को वास्तविक अभिव्यक्तियों में बदल देगा।

 def aexp_value(): return (num ^ (lambda i: IntAexp(i))) | \ (id ^ (lambda v: VarAexp(v)))

हमने ऑपरेटर का इस्तेमाल किया | जो Alternate कॉम्बिनेटर के लिए छोटा है। इससे पूर्णांक अभिव्यक्तियों को पहले पार्स करना संभव होगा। यदि वे विफल होते हैं, तो चर के साथ अभिव्यक्ति को पार्स करने का प्रयास किया जाएगा।

ध्यान दें कि हमने aexp_value को एक फ़ंक्शन के रूप में परिभाषित किया है, जिसमें वैश्विक मान के बजाय कोई तर्क नहीं है, जैसा कि हमने id और num साथ किया था। हम शेष सभी पार्सरों के साथ भी ऐसा ही करेंगे। और हमने ऐसा इसलिए किया क्योंकि हम नहीं चाहते कि प्रत्येक पार्सर का कोड तुरंत गणना किया जाए। यदि हम प्रत्येक पार्सर को वैश्विक के रूप में परिभाषित करते हैं, तो प्रत्येक पार्सर अन्य पार्सरों को संदर्भित नहीं कर सकता है जो उसी स्रोत फ़ाइल में आगे का पालन करते हैं, क्योंकि वे अभी तक घोषित नहीं किए गए थे। इससे पुनरावर्ती पार्सर को परिभाषित करना असंभव हो जाएगा, और स्रोत कोड कम पठनीय हो जाएगा।

इसके अलावा, हम अपने अंकगणितीय अभिव्यक्तियों में कोष्ठक के साथ समूहन को लागू करना चाहेंगे। हालाँकि समूहीकरण के अभिव्यक्तियों के लिए अपने स्वयं के AST वर्ग की आवश्यकता नहीं होती है, फिर भी उन्हें एक और पार्सर की आवश्यकता होती है जो उन्हें संसाधित करता है।

 def process_group(parsed): ((_, p), _) = parsed return p def aexp_group(): return keyword('(') + Lazy(aexp) + keyword(')') ^ process_group

process_group फ़ंक्शन का उपयोग Process कॉम्बिनेटर ( ^ ऑपरेटर) के साथ किया जाता है। यह बस कोष्ठक के टोकन को त्यागता है और अभिव्यक्ति को अंदर लौटाता है। वास्तव में, aexp_group भी एक पार्सर है। याद रखें, Concat कॉम्बिनेटर के लिए + ऑपरेटर एक शॉर्टहैंड है। तो यह '(', अंकगणित की अभिव्यक्ति का अनुसरण करते हुए ( aexp द्वारा पार्स किया aexp , जिसे हम जल्द ही निर्धारित करेंगे), 'के आगे')। aexp aexp कॉल aexp बचें, क्योंकि aexp कॉल aexp_group , जिसके परिणामस्वरूप अनंत पुनरावृत्ति होगी। हम Lazy कॉम्बीनेटर का उपयोग करते हैं, जो कॉल को एफ़एक्स पर तब तक रोकता है जब तक कि पार्सर किसी इनपुट पर लागू न हो जाए।

अगला, हम aexp_value और aexp_group को aexp_term साथ aexp_term । अभिव्यक्ति aexp_term किसी भी सरल स्वतंत्र अभिव्यक्ति है जिसमें हमें अन्य अभिव्यक्तियों के संबंध में ऑपरेटरों की पूर्वता के बारे में परवाह नहीं करनी चाहिए।

 def aexp_term(): return aexp_value() | aexp_group()

अब हम मुश्किल भाग में आ रहे हैं: ऑपरेटरों और वरिष्ठता। एक और पार्सर को aexp लिए परिभाषित करना आसान होगा और इसे aexp_term साथ फेंक देना होगा। यह एक अभिव्यक्ति में परिणाम होगा:

 1 + 2 * 3

इस तरह के एक गलत विश्लेषण के लिए:

 (1 + 2) * 3

पार्सर को ऑपरेटरों की पूर्वता के बारे में पता होना चाहिए, और यह एक दूसरे के साथ मिलकर एक उच्चतर संचालन के साथ समूह बनाना होगा।

हम इस कार्य को करने के लिए कई सहायक कार्यों को परिभाषित करेंगे।

 def process_binop(op): return lambda l, r: BinopAexp(op, l, r)

process_binop फ़ंक्शन वह है जो BinopAexp ऑब्जेक्ट बनाता है। यह फ़ंक्शन किसी भी अंकगणितीय ऑपरेटर को लेता है और एक ऐसा फ़ंक्शन देता है जो इस ऑपरेटर के उपयोग से जोड़े के भावों को जोड़ता है ...

process_binop फ़ंक्शन का उपयोग Exp combinator ( * ऑपरेटर) के साथ किया जाना चाहिए। Exp कॉम्बिनेटर प्रत्येक जोड़ी की अभिव्यक्ति के बीच एक सीमांकक के साथ अभिव्यक्तियों की एक सूची तैयार करता है। बायाँ ऑपरेटर Exp एक पार्सर है जो सूची के व्यक्तिगत तत्वों (हमारे मामले में, अंकगणितीय अभिव्यक्तियों) से मेल खाता है। सही ऑपरेटर एक पार्सर है जो विभाजकों (ऑपरेटरों) से मेल खाता है। जो भी विभाजक से मेल नहीं खाता है, सही पार्सर एक फ़ंक्शन लौटाएगा, जो ऑपरेटरों के पत्राचार को देखते हुए, एक यूनियन फ़ंक्शन देता है। यूनियन फ़ंक्शन विभाजक के बाईं और दाईं ओर पार्स किए गए एक्सप्रेशन लेता है, और एकल, संयुक्त एक्सप्रेशन देता है। अभी तक उलझन में नहीं? हम शीघ्र ही Exp के उपयोग से Exp । process_binop फ़ंक्शन वह है जो सही पार्सर लौटाएगा।
इसके बाद, हम अपने वरिष्ठता स्तर और एक संयोजनकर्ता का निर्धारण करेंगे ताकि हम उनसे निपटने में मदद कर सकें।

 def any_operator_in_list(ops): op_parsers = [keyword(op) for op in ops] parser = reduce(lambda l, r: l | r, op_parsers) return parser aexp_precedence_levels = [ ['*', '/'], ['+', '-'], ]

any_operator_in_list फ़ंक्शन कीवर्ड स्ट्रिंग्स की एक सूची लेता है और संबंधित पार्सर को लौटाता है। aexp_precedence_levels के प्रत्येक स्तर (एक उच्चतर के साथ शुरू) के लिए ऑपरेटरों की एक सूची युक्त aexp_precedence_levels को परिभाषित करें।

 def precedence(value_parser, precedence_levels, combine): def op_parser(precedence_level): return any_operator_in_list(precedence_level) ^ combine parser = value_parser * op_parser(precedence_levels[0]) for precedence_level in precedence_levels[1:]: parser = parser * op_parser(precedence_level) return parser

precedence ऑपरेशन की वास्तविक सामग्री है। इसका पहला तर्क, value_parser , एक पार्सर है जो एक अभिव्यक्ति के सरल भागों को पढ़ सकता है: संख्याएं, चर और समूह। यह aexp_term होगा। precedence_levels सूची में ऑपरेटरों की एक सूची, प्रति स्तर एक सूची होती है। ऐसा करने के लिए, aexp_precedence_levels उपयोग aexp_precedence_levels । combine एक फ़ंक्शन लेगा, जो ऑपरेटर द्वारा पारित किया गया है, दो छोटे लोगों में से एक बड़ी अभिव्यक्ति बनाने के लिए एक फ़ंक्शन वापस करेगा। यह process_binop होगा

precedence अंदर, हम पहले op_parser को परिभाषित op_parser , जो किसी दिए गए वरिष्ठता स्तर के लिए, केवल ऑपरेटरों को समान स्तर के साथ पढ़ता है और एक फ़ंक्शन देता है जो दो अभिव्यक्तियों को जोड़ता है। op_parser लिए सही तर्क के रूप में op_parser का उपयोग किया जा सकता है। हम उच्च स्तर की पूर्वता के लिए op_parser के साथ op_parser को कॉल करके शुरू करते हैं, क्योंकि इन ऑपरेशनों को पहले समूहीकृत किया जाना चाहिए। अगला, हम परिणामी पार्सर को अगले स्तर पर पार्सर (बाएं तर्क Exp ) के एक तत्व के रूप में उपयोग करते हैं। लूप के अंत के बाद, परिणामस्वरूप पार्सर अंकगणितीय अभिव्यक्ति को सही ढंग से पार्स करने में सक्षम है।

यह व्यवहार में कैसे काम करता है? आइए एक नजर डालते हैं।

 E<sub>0</sub> = value_parser E<sub>1</sub> = E<sub>0</sub> * op_parser(precedence_levels[0]) E<sub>2</sub> = E<sub>1</sub> * op_parser(precedence_levels[1])

E ₀ , value_parser के समान है। यह संख्या, चर और समूहों को पार्स कर सकता है, लेकिन ऑपरेटरों को नहीं। E ₁ चीजों को सम्‍मिलित कर सकता है जिनमें E ₀ साथ संयोग हो सकता है, जो वरिष्ठता के पहले स्‍तर से ऑपरेटरों द्वारा अलग किए जाते हैं। इसलिए E ₁ a * b / c मेल खा सकता है, लेकिन जैसे ही यह + ऑपरेटर से सामना करता है, एक त्रुटि का कारण बन सकता है। E ₂ पूर्व स्तर के अगले स्तर के ऑपरेटरों द्वारा अलग किए गए अभिव्यक्तियों से मेल खा सकता है। चूँकि हमारे पास वरिष्ठता के केवल 2 स्तर हैं, E ₂ हमारे द्वारा समर्थित किसी भी अंकगणितीय अभिव्यक्तियों से मेल खा सकता है।

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

 4 * a + b / 2 - (6 + c) E<sub>0(4)</sub> * E<sub>0</sub>(a) + E<sub>0</sub>(b) / E<sub>0</sub>(2) - E<sub>0</sub>(6+c) E<sub>1</sub>(4*a) + E<sub>1</sub>(b/2) - E<sub>1</sub>(6+c) E<sub>2</sub>((4*a)+(b/2)-(6+c))

हम aexp उपयोग सीधे aexp निर्धारित करने के लिए aexp :

 def aexp(): return precedence(aexp_term(), aexp_precedence_levels, process_binop)

हम शायद पूर्ववर्तीता को कम अमूर्त रूप से परिभाषित कर सकते हैं, लेकिन हमारे दृष्टिकोण का लाभ यह है कि हम इसे किसी भी स्थिति में लागू करते हैं जिसमें ऑपरेटर की पूर्ववर्तीता की समस्या है। हम इसे तार्किक अभिव्यक्तियों को पार्स करने के लिए पुन: उपयोग करते हैं।

तार्किक भावों को पार्स करना

हम पहले से ही अंकगणित के भावों से तार्किक की ओर बढ़ सकते हैं। तार्किक अभिव्यक्तियाँ आमतौर पर अंकगणित की तुलना में सरल होती हैं, इसलिए हमें उन्हें पार्स करने के लिए नए टूल की आवश्यकता नहीं होती है। आइए सबसे सरल तार्किक अभिव्यक्तियों से शुरुआत करें:

 def process_relop(parsed): ((left, op), right) = parsed return RelopBexp(op, left, right) def bexp_relop(): relops = ['<', '<=', '>', '>=', '=', '!='] return aexp() + any_operator_in_list(relops) + aexp() ^ process_relop

हम Process संयोजन के साथ process_relop फ़ंक्शन का उपयोग करते हैं। यह तीन जुड़े हुए मूल्यों को लेता है और उनसे RelopBexp बनाता है। bexp_relop हम दो अंकगणितीय अभिव्यक्तियों ( aexp ) को पार्स करते हैं, जो एक रिलेशन ऑपरेटर द्वारा अलग किया जाता है। और हम अपने पुराने आदमी का उपयोग करते हैं - any_operator_in_list फ़ंक्शन, इसलिए हमें प्रत्येक ऑपरेटर के लिए मामला लिखने की आवश्यकता नहीं है। इसके अलावा, Exp या precedence जैसे कॉम्बीनेटरों का उपयोग करने की कोई आवश्यकता नहीं precedence , क्योंकि रिलेशनशिप एक्सप्रेशंस को एक दूसरे से इसलिए नहीं जोड़ा जा सकता है क्योंकि वे अन्य भाषाओं में किए गए हैं।

अगला, अभिव्यक्ति को परिभाषित not । अभिव्यक्ति उच्च प्राथमिकता के साथ एक अपरिपक्व ऑपरेटर not है। इससे और or भावों को पार्स करना आसान हो जाता है।

 def bexp_not(): return keyword('not') + Lazy(bexp_term) ^ (lambda parsed: NotBexp(parsed[1]))

यहां हमने तार्किक अभिव्यक्ति के नाम के साथ कीवर्ड not जोड़ा (जिसे हम बाद में परिभाषित करेंगे)। चूंकि bexp_not को bexp_term परिभाषित करने के लिए उपयोग किया जाएगा, इसलिए हमें अनंत पुनरावृत्ति से बचने के लिए Lazy कॉम्बिनेटर का उपयोग करने की आवश्यकता है।

 def bexp_group(): return keyword('(') + Lazy(bexp) + keyword(')') ^ process_group def bexp_term(): return bexp_not() | \ bexp_relop() | \ bexp_group()

हम bexp_group और bexp_term को उसी तरह परिभाषित bexp_group जैसे अंकगणितीय समकक्षों के लिए। यह कोई नई बात नहीं है।
अगला, हमें उन अभिव्यक्तियों को परिभाषित करने की आवश्यकता है, जिनमें और or ऑपरेटर शामिल हैं। ये ऑपरेटर वास्तव में अंकगणितीय ऑपरेटरों की तरह काम करते हैं; दोनों को बाएं से दाएं किया जाता है, and इसमें वरिष्ठता का उच्चतम स्तर होता है।

 bexp_precedence_levels = [ ['and'], ['or'], ] def process_logic(op): if op == 'and': return lambda l, r: AndBexp(l, r) elif op == 'or': return lambda l, r: OrBexp(l, r) else: raise RuntimeError('unknown logic operator: ' + op) def bexp(): return precedence(bexp_term(), bexp_precedence_levels, process_logic)

process_binop तरह, process_logic Exp combinator के उपयोग के लिए अभिप्रेत है। यह एक ऑपरेटर लेता है और एक फ़ंक्शन देता है जो इस ऑपरेटर का उपयोग करके एक अभिव्यक्ति में दो सबएक्सप्रेस को जोड़ती है। हम इसे उसी तरह से पूर्वगामी के अनुसार प्रतिस्थापित करते हैं जैसे कि aexp । यहाँ जेनेरिक कोड लिखना बंद कर देता है, क्योंकि हमें जटिल कोड एक्सप्रेशन प्रोसेसिंग एक्सप्रेशन को दोहराना नहीं पड़ता है।

पार्सिंग आरोप

aexp और bexp , हम आईएमपी बयानों को पार्स करना शुरू कर सकते हैं। आइए असाइनमेंट के मामूली विवरण के साथ शुरू करें:

 def assign_stmt(): def process(parsed): ((name, _), exp) = parsed return AssignStatement(name, exp) return id + keyword(':=') + aexp() ^ process

वास्तव में कुछ भी दिलचस्प नहीं है। अगला, हम stmt_list को stmt_list । यह अर्धविराम द्वारा अलग किए गए कथनों की एक श्रृंखला को पार्स करेगा।

 def stmt_list(): separator = keyword(';') ^ (lambda x: lambda l, r: CompoundStatement(l, r)) return Exp(stmt(), separator)

याद रखें, हमें बाएँ हाथ की पुनरावृत्ति से बचने के लिए stmt() + keyword(';') + stmt() जैसे कुछ सरल के बजाय यहाँ EXP कॉम्बिनेटर का उपयोग करने की आवश्यकता है।
अगला, हमारे पास एक if :

 def if_stmt(): def process(parsed): (((((_, condition), _), true_stmt), false_parsed), _) = parsed if false_parsed: (_, false_stmt) = false_parsed else: false_stmt = None return IfStatement(condition, true_stmt, false_stmt) return keyword('if') + bexp() + \ keyword('then') + Lazy(stmt_list) + \ Opt(keyword('else') + Lazy(stmt_list)) + \ keyword('end') ^ process

यहां एकमात्र कठिनाई यह है कि else खंड वैकल्पिक है। यह फ़ंक्शन निष्पादन को थोड़ा अधिक जटिल बनाता है।
अंत में, हमारे पास कुछ while :

 def while_stmt(): def process(parsed): ((((_, condition), _), body), _) = parsed return WhileStatement(condition, body) return keyword('while') + bexp() + \ keyword('do') + Lazy(stmt_list) + \ keyword('end') ^ process

हम इसे stmt साथ stmt :

 def stmt(): return assign_stmt() | \ if_stmt() | \ while_stmt()

आप यह देख सकते हैं कि if दोनों और if में, शरीर में stmt_list का उपयोग करना stmt_list से बेहतर है। stmt_list वास्तव में हमारी शीर्ष स्तर की परिभाषा है। हम सीधे stmt पर निर्भर नहीं रह सकते हैं, क्योंकि इससे लेफ्ट-साइड पार्सर stmt_list होगा, और चूंकि हम if और while निकायों में वैकल्पिक स्टेटमेंट चाहते हैं, तो हम सीधे stmt_list उपयोग stmt_list ।

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

अब हमारे पास भाषा के हर हिस्से के लिए एक पार्सर है। हमें बस कुछ उच्च-स्तरीय परिभाषाएँ बनाने की आवश्यकता है:

 def parser(): return Phrase(stmt_list())

parser पूरे कार्यक्रम को पार्स करेगा। एक कार्यक्रम सिर्फ बयानों की एक सूची है, लेकिन Phrase कॉम्बिनेटर यह सुनिश्चित करता है कि हम अंत में जंक (अमान्य) टोकन के कारण समाप्ति से पहले फ़ाइल में प्रत्येक टोकन का उपयोग करें।

 def imp_parse(tokens): ast = parser()(tokens, 0) return ast

ग्राहक कार्यक्रम को पार्स करने के लिए imp_parse फ़ंक्शन को कॉल करेगा। यह टोकन की पूरी सूची लेता है, पार्सर कहता है, पहले टोकन पर शुरू होता है और परिणामस्वरूप सार सिंटैक्स ट्री (एएसटी) देता है।

यहाँ हमारे पार्सरों (इकाइयों के अलावा) की जाँच के लिए एक सरल नियंत्रण कार्यक्रम है:

 import sys from imp_parser import * if __name__ == '__main__': if len(sys.argv) != 3: sys.stderr.write('usage: %s filename parsername' % sys.argv[0]) sys.exit(1) filename = sys.argv[1] file = open(filename) characters = file.read() file.close() tokens = imp_lex(characters) parser = globals()[sys.argv[2]]() result = parser(tokens, 0) print result

यह प्रोग्राम फ़ाइल (पहला तर्क) को पढ़ता है और इसे imp_parse.py (दूसरा तर्क) के कुछ पार्सर से पार्स करता है। एक उदाहरण:

 $ echo '1 + 2 * 3' >foo.imp $ python imp_parser_driver.py foo.imp aexp Result(BinopAexp(+, IntAexp(1), BinopAexp(*, IntAexp(2), IntAexp(3))), 5)

यह प्रयोग के लिए एक अच्छा सैंडबॉक्स प्रदान करना चाहिए।

निष्कर्ष

इस लेख में, हमने स्क्रैच से एक कॉम्बीनेटर लाइब्रेरी लिखी और इसका इस्तेमाल उन्होंने IMP के लिए एक पार्सर लिखने के लिए किया। इस श्रृंखला में अगले और आखिरी लेख में, हम एक प्रदर्शन करेंगे ( नोट अनुवाद: शब्द मूल्यांकनकर्ता का सबसे अच्छा अनुवाद नहीं पा सके) हमारे सार सार वाक्य वृक्ष ( एएसटी ) के लिए।

मूल लेख के लेखक - जे कॉनरोड

पीएस मैं सब टैग के साथ समस्याओं को देखता हूं। एक धारणा है कि शुरुआती के लिए इस तरह के टैग का उपयोग करना बहुत जल्दी है। इसे कैसे बदलें - मुझे नहीं पता। जब तक समाधान स्पष्ट नहीं किया जाता है, मैं छोड़ दूंगा

पायथन में खरोंच से एक साधारण दुभाषिया (भाग 3)