हम लिस्प - III में एक सरल अनुवादक लिखते हैं

पिछला लेख

त्रुटियां, त्रुटियां, त्रुटियां ...

उपयोगकर्ता त्रुटियों से एक अच्छा कार्यक्रम संरक्षित किया जाना चाहिए। यह बिल्कुल निश्चित है। गलतियों को संभालने की जरूरत है, और यहां तक ​​कि बेहतर चेतावनी दी गई है (रोकथाम हमेशा इलाज से बेहतर है!)। एरोबेटिक्स - इसलिए उपयोगकर्ता के साथ एक संवाद बनाएं ताकि बाद वाले बस गलती न कर सकें।

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

दुर्भाग्य से, ऐसी तकनीक हमेशा लागू नहीं की जा सकती है। विशेष रूप से, अनुवादक के इनपुट में आने वाले डिज़ाइनों की विविधता इनपुट मास्क को सेट करके "गलत लोगों को काटने" के लिए बहुत बड़ी है।

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

चलिए पहले स्टार्ट फंक्शन से शुरू करते हैं। वह क्या कर रही है? वह इनपुट फ़ाइल का नाम लेती है, उसे खोलती है, और लाइन द्वारा लाइन बनाती है। ऐसे कार्यक्रमों के लिए, उपयोगकर्ता इंटरैक्शन परिदृश्य पहले से ही "बसे" है - इसे विहित माना जा सकता है:

• यदि फ़ाइल नाम निर्दिष्ट नहीं है, तो मानक "ओपन" डायलॉग को कॉल करें;
• यदि उपयोगकर्ता ने "ओपन" संवाद में "इंकार" बटन पर क्लिक किया - बंद करें;
• जांचें कि दिए गए / दर्ज नाम वाली फाइल मौजूद है या नहीं। यदि यह मौजूद नहीं है, तो एक संदेश जारी करें और बाहर निकलें;
• यदि निर्दिष्ट फ़ाइल मौजूद है, तो इसे संसाधित करें।

प्रारंभ प्रक्रिया का हमारा संस्करण इस परिदृश्य को संतुष्ट नहीं करता है। वास्तव में, नीचे दिए गए कोड को देखें:

(defun start (&optional (fname "")) (setq *numline* 0) (setq *flagerr* nil) (setq *oplist* …) ;;      (when (zerop (strLen fname)) (setq fname (sysGetOpenName (sysHome) "-|*.mbs"))) (let ((fi (gensym 'fi))) (filOpen fi fname _INPUT) (loop (let ((curr-proc (action-proc fi))) (when *flagerr* (return t)) (when (filEOF fi) (return t)) (eval curr-proc))) (filClose fi)) (when *flagerr* (printsline "****   "))) 

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

इन दोषों को ठीक करें:

 (defun start (&optional (fname "")) (setq *numline* 0) (setq *flagerr* nil) (setq *oplist* … ) (when (zerop (strLen fname)) (setq fname (sysGetOpenName (sysHome) "-|*.mbs"))) (if (and fname (filExistp fname)) (let ((fi (gensym 'fi))) (filOpen fi fname _INPUT) (loop (let ((curr-proc (action-proc fi))) (when *flagerr* (return t)) (when curr-proc (eval curr-proc)) (when (filEOF fi) (return t)))) (filClose fi) (when *flagerr* (printsline "****   "))) (printsline (if fname (strCat "****  " fname "  ") "****   "))) (unset '*numline*) (unset '*flagerr*) (unset '*oplist*)) 

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

• फंक्शन एक्शन-प्रोक्योर पूरा हुआ। इसके काम का परिणाम स्थानीय चर वक्र-खरीद में संग्रहीत है;
• यदि * ध्वजवाहक * झंडा उठाया जाता है, तो लूप टूट जाता है;
• यदि क्रिया-खरीद फ़ंक्शन ने एक गैर-रिक्त परिणाम लौटाया, तो उत्पन्न फ़ंक्शन को लिस्प वातावरण में लोड किया गया है;
• यदि फ़ाइल का अंत पहुँच जाता है, तो लूप भी टूट जाता है।

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

इस दोष को ठीक करने के लिए, आइए वैश्विक चर "एरर काउंटर" की शुरुआत करें, त्रुटियों के साथ प्रक्रिया को संसाधित करते समय, हम इस काउंटर को बढ़ाएंगे। और प्रत्येक प्रक्रिया को संसाधित करने के बाद त्रुटि ध्वज को रीसेट किया जाएगा:

 (defun start (&optional (fname "")) (setq *numline* 0) (setq *flagerr* nil) (setq *errcount* 0) (setq *oplist* …) (when (zerop (strLen fname)) (setq fname (sysGetOpenName (sysHome) "-|*.mbs"))) (if (and fname (filExistp fname)) (let ((fi (gensym 'fi))) (filCloseAll) (filOpen fi fname _INPUT) (loop (let ((curr-proc (action-proc fi))) (when *flagerr* (setq *errcount* (add1 *errcount*))) (when (and curr-proc (not *flagerr*)) (eval curr-proc)) (setq *flagerr* nil) (when (filEOF fi) (return t)))) (filClose fi) (when (> *errcount* 0) (printsline "****   "))) (printsline (if fname (strCat "****  " fname "  ") "****   "))) (unset '*numline*) (unset '*flagerr*) (unset '*oplist*) (unset '*errcount*)) 

अब, प्रारंभ फ़ंक्शन स्वीकार्य कार्य करेगा। चलो यह सुनिश्चित करते हैं। निम्न स्रोत फ़ाइल बनाएँ:

 * *    * proc test1(x) local y y=x^2 bla-bla end_proc * *    * proc test2() local x,y input x y=test1(x) print y end_proc * *    * proc test3(x) bla-bla-bla print x end_proc 

और हमारे अनुवादक के माध्यम से "इसे पास होने दें"। हमें मिलता है:

 0001 * 0002 *    0003 * 0004 proc test1(x) 0005 local y 0006 y=x^2 0007 bla-bla ****  (BLA - BLA)   0008 end_proc 0009 * 0010 *    0011 * 0012 proc test2() 0013 local x,y 0014 input x 0015 y=test1(x) 0016 print y 0017 end_proc 0018 * 0019 *    0020 * 0021 proc test3(x) 0022 bla-bla-bla ****  (BLA - BLA - BLA)   0023 print x 0024 end_proc 0025 ****    

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

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

आइए इस त्रुटि को संभालें।

HomeLisp में, त्रुटियों को संभालने के लिए एक निर्माण का उपयोग किया जाता है (अभिव्यक्ति -1 को छोड़कर अभिव्यक्ति -1 को आज़माएं)। यह निम्नानुसार काम करता है:

• अभिव्यक्ति -1 की गणना करने का प्रयास किया जाता है। यदि प्रयास सफल होता है, तो गणना परिणाम पूरे प्रयास फॉर्म के परिणाम के रूप में वापस आ जाता है;
• यदि कोई त्रुटि होती है, तो अभिव्यक्ति -2 की गणना की जाती है। उसी समय, पैरामीटर (इरोमेसेज) के बिना एक सिस्टम फ़ंक्शन उपलब्ध है, जो त्रुटि संदेश का पाठ लौटाता है।

पूर्वगामी के आधार पर, सूची प्रपत्र में स्थानांतरण निम्नानुसार जारी किया जा सकता है:

 (defun mk-intf (txt) (let ((lex (parser txt " ," "()+-*/\^=<>%")) (intf "")) (iter (for a in lex) (setq intf (strCat intf a " "))) (try (input (strCat "(" intf ")")) except (progn (printsline (strCat "**** " (errormessage))) `(,txt) )))) 

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

 * *    * proc test1(x) local y y=(x^2)) end_proc * *    * proc test2() local x,y input x y=test1(x) print y end_proc * *    * proc test3(x) x=3+)x^2 print x end_proc 

हमें अपेक्षित परिणाम मिलेगा:

 0001 * 0002 *    0003 * 0004 proc test1(x) 0005 local y 0006 y=(x^2)) ****        ****  ("y=(x^2))")   0007 end_proc 0008 * 0009 *    0010 * 0011 proc test2() 0012 local x,y 0013 input x 0014 y=test1(x) 0015 print y 0016 end_proc 0017 * 0018 *    0019 * 0020 proc test3(x) 0021 x=3+)x^2 ****        ****  ("x=3+)x^2")   0022 print x 0023 end_proc ****    

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

 proc test() local x,y x=6 y=-x print y end_proc 

प्रसारण अनुवादक के "पतन" के साथ समाप्त होगा! एक गिरावट y = -x ऑपरेटर का कारण बनेगी। मामला क्या है? एक शून्य में! एक infix फॉर्मूले से एक उपसर्ग के रूप में एक सूत्र में परिवर्तित करते हुए, हमने किसी तरह यह नहीं सोचा कि माइनस "दो-सामना" - एक द्विआधारी माइनस (एक ऑपरेशन संकेत) है, और एक अनार्य माइनस (एक संख्या का संकेत) है। हमारे पार्सर इस अंतर को नहीं जानते हैं - यह सभी विपक्ष को द्विआधारी मानता है ... अब क्या करना है? पहले से ही काम कर रहे कोड को नष्ट नहीं करने के लिए, आइए सभी अनैच्छिक सहमति को बाइनरी में बदल दें। कैसे? लेकिन बहुत सरल है। यह काफी स्पष्ट है कि केवल एक ही निर्माण में "माइनस" रहता है:

"(-Nechto"
"> -समर्थन"
"<-Nechto"
"= कुछ"
खैर, सूत्र की शुरुआत में, वह भी मिल सकते हैं। इसलिए, यदि, टोकन में टूटने से पहले, हम निम्नलिखित प्रतिस्थापन करते हैं:

"-Something" => "(0-कुछ"
"> -समर्थन" => "> 0-कुछ"
"<-Something" => "<0-something"
"= कुछ" => "= 0 कुछ"

और यदि सूत्र शून्य से शुरू होता है, तो हम सूत्र की शुरुआत में शून्य प्रदान करते हैं, तो सभी शून्य बाइनरी हो जाएंगे और त्रुटि मौलिक रूप से समाप्त हो जाएगी। चलिए उस फ़ंक्शन को कॉल करते हैं जो प्रीप्रो नाम से ऊपर रूपांतरण करेगा। यहाँ यह है कि यह कैसा दिख सकता है:

 (defun prepro (s) (let* ((s0 (if (eq "-" (strLeft s 1)) (strCat "0" s) s)) (s1 (strRep s0 "(-" "(0-")) (s2 (strRep s1 "=-" "=0-")) (s3 (strRep s2 ">-" ">0-")) (s4 (strRep s3 "<-" "<0-"))) s4)) 

यहां किसी विशेष टिप्पणी की आवश्यकता नहीं है। लेकिन हमारे साधारण पार्सर में एक और परेशानी है जो पहली नज़र में बिल्कुल स्पष्ट नहीं है - संचालन के दोहरे संकेत। सूत्रों के साथ काम करते समय, संकेत ">" और "=" कंधे से कंधा मिलाकर एक ऑपरेशन "> =" (और एक टोकन होना चाहिए!)। पार्सर यह जानना नहीं चाहता है - यह प्रत्येक संकेत को एक अलग टोकन बना देगा। आप प्राप्त टोकन की सूची को देखकर, और यदि संयोजन के अनुसार संबंधित वर्ण एक दूसरे के बगल में हैं, तो आप इस समस्या का सामना कर सकते हैं। हम उस फ़ंक्शन को नाम देते हैं जो "पोस्टप्रो" नाम से यूनियन का प्रदर्शन करेगा। यहाँ एक संभावित कार्यान्वयन के लिए कोड है:

 (defun postpro (lex-list) (cond ((null (cdr lex-list)) lex-list) (t (let ((c1 (car lex-list)) (c2 (cadr lex-list))) (cond ((and (eq c1 ">") (eq c2 "=")) (cons ">=" (postpro (cddr lex-list)))) ((and (eq c1 "<") (eq c2 "=")) (cons "<=" (postpro (cddr lex-list)))) ((and (eq c1 "=") (eq c2 "=")) (cons "==" (postpro (cddr lex-list)))) ((and (eq c1 "<") (eq c2 ">")) (cons "<>" (postpro (cddr lex-list)))) ((and (eq c1 ">") (eq c2 "<")) (cons "<>" (postpro (cddr lex-list)))) ((and (eq c1 "!") (eq c2 "=")) (cons "/=" (postpro (cddr lex-list)))) ((and (eq c1 "/") (eq c2 "=")) (cons "/=" (postpro (cddr lex-list)))) (t (cons c1 (postpro (cdr lex-list))))))))) 

इसके अलावा, जैसा कि हम देखते हैं, कुछ खास नहीं है। लेकिन अब ऑपरेटर को आंतरिक सूची प्रपत्र में अनुवाद करने का अंतिम कार्य इस प्रकार होगा:

 (defun mk-intf (txt) (let ((lex (postpro (parser (prepro txt) " ," "()+-*/\^=<>%"))) (intf "")) (iter (for a in lex) (setq intf (strCat intf a " "))) (try (input (strCat "(" intf ")")) except (progn (printsline (strCat "**** " (errormessage))) `(,txt) )))) 

अब चलो inf2ipn फ़ंक्शन पर एक महत्वपूर्ण नज़र डालें। क्या उपयोगकर्ता त्रुटियों यह "दोष" कर सकते हैं? हमने पहले ही ऊपर के कोष्ठकों के असंतुलन को काट दिया है। इससे ज्यादा और क्या हो सकता है? एक पंक्ति में दो ऑपरेशन या दो ऑपरेंड के संकेत। कोई व्यक्ति inf2ipn कोड में इसका विश्लेषण कर सकता है (और जो लोग अपनी इच्छा से ऐसा कर सकते हैं)। हम सूत्र को SCR से उपसर्ग में बदलने के चरण में इन त्रुटियों को "पकड़" लेते हैं। और चलो (बस मामले में) हम उन सभी त्रुटियों को पकड़ लेंगे जो कि फार्मूला को प्रीफिक्स से उपसर्ग में बदलने की प्रक्रिया में उत्पन्न हो सकती हैं। इसके लिए सबसे अच्छी जगह i2p रैपर फंक्शन है। अब यह इस तरह दिख सकता है:

 (defun i2p (f) (try (ipn2pref (inf2ipn f)) except (progn (printsline "****    ") (printsline (strCat "**** " (errormessage))) (setq *flagerr* t) nil))) 

और अब हम एक पंक्ति में दो ऑपरेशन संकेत या दो ऑपरेंड के सूत्र में उपस्थिति को रोकेंगे। पिछले लेख ने एक SCR से एक सूत्र को एक उपसर्ग रूप में अनुवाद करने के लिए एक एल्गोरिथ्म का वर्णन किया। इस एल्गोरिथ्म के सही समापन का एक संकेत यह है कि अंतिम चरण में स्टैक में एक एकल मान होना चाहिए। अगर ऐसा नहीं है, तो एक गलती की गई है। और एक और गलत स्थिति उस स्थिति में उत्पन्न होती है जब फ़ंक्शन को गलत (अधिक या कम) मापदंडों की संख्या के साथ कहा जाता है। इन स्थितियों को "पकड़ा जाना चाहिए":

 (defun ipn2pref (f &optional (s nil)) (cond ((null f) (if (null (cdr s)) (car s) (progn (printsline "****    ") (setq *flagerr* t) nil))) ((numberp (car f)) (ipn2pref (cdr f) (cons (car f) s))) ((is-op (car f)) (let ((ar (arity (car f)))) (if (< (length s) ar) (progn (setq *flagerr* t) (printsline "****    ") nil) (ipn2pref (cdr f) (cons (cons (car f) (reverse (subseq s 0 ar))) (subseq s ar)))))) ((atom (car f)) (ipn2pref (cdr f) (cons (car f) s))) (t (ipn2pref (cdr f) (cons (list (car f) (car s)) (cdr s)))))) 

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

 (defun action-proc (fi) (let ((stmt nil) (proc-name nil) (proc-parm nil) (loc-var nil) (lv '((result 0))) (body nil)) (loop (setq stmt (mk-intf (getLine fi))) (when (null stmt) (return t)) (cond ((eq (car stmt) 'proc) (setq proc-name (nth 1 stmt)) (setq proc-parm (nth 2 stmt)) (setq *oplist* (cons (list proc-name (length proc-parm)) *oplist*))) ((eq (car stmt) 'end_proc) (return t)) ((eq (car stmt) 'print) (setq body (append body (list (cons 'printline (cdr stmt)))))) ((eq (car stmt) 'input) (setq body (append body (list (list 'setq (cadr stmt) (list 'read) ))))) ((eq (car stmt) 'local) (setq loc-var (append loc-var (cdr stmt)))) ((eq (cadr stmt) '=) (setq body (append body (list (action-set stmt))))) (t (printsline (strCat "****  " (output stmt) "  ")) (setq *flagerr* t)))) (iter (for a in (setof loc-var)) (collecting (list a 0) into lv)) (if proc-name `(defun ,proc-name ,proc-parm (let ,lv ,@body result)) nil))) 

हम अभी के लिए यहाँ रुकेंगे (हालाँकि हम अभी भी समस्याओं का सामना करेंगे, और कोड को अंतिम रूप देना होगा; लेकिन ऐसा प्रोग्रामर का बहुत कुछ है ...) और अब हम अपनी भाषा में दो सुधारों पर विचार करेंगे जो अभी करने के लिए उपयुक्त हैं।

मामूली सुधार ...

पिछले लेख में, मैंने लिखा था कि एक प्रोग्रामर के लिए यह असुविधाजनक है यदि किसी भाषा में एक ऑपरेटर ठीक एक लाइन में रहता है। कई पंक्तियों पर भारी बयान लिखने की क्षमता प्रदान करना आवश्यक है। आइए इसे लागू करें। ऐसा करना बिल्कुल भी मुश्किल नहीं है। गेटलाइन प्रक्रिया में, हम एक स्थानीय वैरिएबल बनाएंगे जिसमें हम पढ़े गए पाठ को संचित करेंगे (बशर्ते कि यह एक टिप्पणी नहीं है और "_" वर्णों के एक जोड़े के साथ समाप्त होता है। जैसे ही एक अलग समाप्ति के साथ एक महत्वपूर्ण रेखा तय हो जाती है, हम एक मान के रूप में संचित मूल्य को वापस कर देते हैं। यह कोड है:

 (defun getLine (fil) (let ((stri "") (res "")) (loop (when (filEof fil) (return "")) (setq *numline* (add1 *numline*)) (setq stri (filGetline fil)) (printsline (strCat (format *numline* "0000") " " (strRTrim stri))) (unless (or (eq "" stri) (eq "*" (strLeft stri 1))) (setq stri (strATrim stri)) (if (eq " _"(strRight stri 2)) (setq res (strCat res (strLeft stri (- (strLen stri) 2)))) (setq res (strCat res stri))) (unless (eq " _"(strRight stri 2)) (return res)))))) 

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

 z=(x>y)*5+(x<=y)*10 

रनटाइम त्रुटि का कारण होगा। और यह समझ में आता है: लिस्प में, अभिव्यक्ति (> xy) की गणना नील या टी के साथ की जाती है। लेकिन निल / टी को 5 से गुणा नहीं किया जा सकता है ... हालांकि, यह परेशानी मदद करना आसान है। आइए कुछ सरल मैक्रोज़ लिखें जो तुलनात्मक अभिव्यक्तियों के परिणाम को 0/1 (नील / टी के बजाय) के साथ बदलते हैं:

 (defmacro $= (xy) `(if (= ,x ,y) 1 0)) (defmacro $== (xy) `(if (= ,x ,y) 1 0)) (defmacro $> (xy) `(if (> ,x ,y) 1 0)) (defmacro $< (xy) `(if (< ,x ,y) 1 0)) (defmacro $/= (xy) `(if (/= ,x ,y) 1 0)) (defmacro $<> (xy) `(if (/= ,x ,y) 1 0)) (defmacro $<= (xy) `(if (<= ,x ,y) 1 0)) (defmacro $>= (xy) `(if (>= ,x ,y) 1 0)) 

अब, ipn2pref फ़ंक्शन में लाइन पर एक नज़र डालें जो ऑपरेशन के प्रसंस्करण को पूरा करती है। यहाँ लाइन है:

 (ipn2pref (cdr f) (cons (cons (car f) (reverse (subseq s 0 ar))) (subseq s ar))) 

यहां (कार f) ऑपरेशन का नाम है। तुलना कोड बदलने के लिए एक छोटा सा कार्य लिखें:

 (defun chng-comp (op) (if (member op '(= == /= <> > < >= <=)) (implode (cons '$ (explode op))) op)) 

फ़ंक्शन यह जांचता है कि क्या इसका तर्क एक तुलनात्मक ऑपरेशन है, और यदि आवश्यक हो, तो शुरुआत में "$" चरित्र को जोड़ता है। अब इसे ipn2pref फ़ंक्शन के सही स्थान पर कॉल करें:

 (ipn2pref (cdr f) (cons (cons (chng-comp (car f)) (reverse (subseq s 0 ar))) (subseq s ar))) 

इसका परिणाम क्या होगा? तुलना कार्यों को संबंधित मैक्रो के लिए कॉल द्वारा बदल दिया जाएगा, और अन्य सभी ऑपरेशन नहीं बदलेंगे। यदि आप इस फ़ंक्शन का अनुवाद करते हैं:

 proc test() local x,y x=1 y=2 result=(x>y)*5+(x<=y)*10 end_proc 

और फिर इसे कॉल करें, हमें अपेक्षित परिणाम मिलता है।

आज के लिए बस इतना ही।

इस लेख का कोड यहां स्थित है।
जारी रखा जाए।