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

आइए लिस्प में लिखने का प्रयास करें ... एक सरल अनिवार्य भाषा का अनुवादक। नहीं, नहीं, मुझसे गलती नहीं हुई - यह अनुवादक है। इसे लिस्प कोड में प्रसारित किया जाएगा। और फिर इस कोड को लिस्प सिस्टम द्वारा निष्पादित किया जा सकता है।

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

कार्यान्वयन के रूप में, मैं HomeLisp का उपयोग करूंगा । जो लोग रुचि रखते हैं, वे इस परियोजना को कॉमन लिस्प में ढाल सकते हैं। मैं तुरंत कहूंगा - विचाराधीन समस्या के संबंध में, कॉमन लिस्प और होम लिस्प के बीच महत्वपूर्ण अंतर केवल लाइनों और फाइलों के प्रसंस्करण में है।

यहां HomeLisp का पोर्टेबल संस्करण डाउनलोड करें । प्रलेखन भी उसी साइट पर स्थित है। जो लोग चाहते हैं लेख से कोड कॉपी कर सकते हैं और तुरंत प्रदर्शन की जांच कर सकते हैं।

आपके ध्यान में लाया गया विषय प्रसिद्ध नोवोसिबिर्स्क LSHUP-2018 में मेरी कार्यशाला का आधार बना। कार्यशाला के परिणाम यहां देखे जा सकते हैं । और फिर मैंने अपना दृष्टिकोण निर्धारित किया। मुझे लगता है कि पाठक लिस्प भाषा से परिचित है।

नीचे उतरना

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

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

proc main() local s,n,k input n for i=1 to n k=2*i-1 print k s=s+k end_for print s end_proc 

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

 (defun main nil (let ((s 0) (n 0) (k 0)) (setq n (read)) (iter (for i from 1 to n) (setq k (- (* 2 i) 1)) (printline k) (setq s (+ sk))) (printline s))) 

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

कार्यान्वयन कहाँ से शुरू करें? प्रसारण और पढ़ने के लिए फ़ाइल का चयन करके शुरू करें और उस फ़ाइल लाइन को लाइन से पढ़ना। हमें कई बार अनुवादक को शुरू करना होगा, इसलिए इसे शुरू से ही सुविधाजनक होने दें। यहाँ इस समारोह की तरह लग सकता है:

 (defun start (&optional (fname nil)) (setq *numline* 0) (setq *flagerr* nil) (when (null fname) (setq fname (sysGetOpenName (sysHome) "-|*.mbs"))) (let ((fi (gensym 'fi))) (when fname (filOpen fi fname _INPUT) (loop (getLine fi) (when (or *flagerr* (filEOF fi)) (return t))) (filClose fi) (when *flagerr* (printsline "****   ")))) (unset '*numline*) (unset '*flagerr*)) 

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

यदि इनपुट फ़ाइल नाम को छोड़ दिया जाता है, तो फ़ाइल का चयन करने के लिए मानक विंडोज़-डायलॉग (sysGetOpenName) कहा जाता है। वर्तमान निर्देशिका (sysHome) का उपयोग आरंभ निर्देशिका के रूप में किया जाता है। अगला, फ़ाइल मैनिप्युलेटर के लिए एक अद्वितीय वर्ण बनाया जाता है और फ़ाइल पाठ पढ़ने के लिए खोला जाता है। फिर, एक अंतहीन लूप में, फ़ाइल को लाइन द्वारा लाइन ( गेटलाइन फ़ंक्शन) पढ़ा जाता है। प्रत्येक ऑपरेशन के बाद, यह जाँच की जाती है कि क्या कोई त्रुटि हुई है और यदि फ़ाइल का अंत पहुँच गया है। यदि कोई त्रुटि होती है या फ़ाइल का अंत तय हो जाता है, तो चक्र टूट जाता है, फ़ाइल बंद हो जाती है, और यदि त्रुटियां थीं, तो एक अंतिम संदेश प्रदर्शित होता है।
वास्तव में फ़ाइल से पढ़ना getLine फ़ंक्शन द्वारा किया जाता है:

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

यह फ़ंक्शन एक खुली फ़ाइल के पहचानकर्ता को स्वीकार करता है और एक अनंत लूप में निम्नलिखित क्रियाएं करता है:

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

इस प्रकार, फ़ाइल की सभी लाइनें अपने मूल रूप में आउटपुट लिस्टिंग में आती हैं।

हम प्रक्रियाओं में टूट जाते हैं

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

पार्सर एल्गोरिदम का वर्णन करने से पहले, हम इस तथ्य पर ध्यान देते हैं कि इनपुट स्ट्रिंग के सभी वर्णों को दो वर्गों में विभाजित किया जा सकता है:

• साधारण पात्र;
• विभाजक वर्ण।

तो, असाइनमेंट ऑपरेटर "x = 15 + y ^ 2" में, वर्ण x, 1,5, y और 2 साधारण वर्ण हैं, और वर्ण "स्पेस" , + , ^ सीमांकक हैं। एक सामान्य चरित्र एक विभाजक से कैसे अलग है? विभाजक - हमेशा एक टोकन को दूसरे से अलग करता है। हमारा असाइनमेंट ऑपरेटर, टोकन में विभाजित किया जा रहा है, इस तरह दिखता है: "x", "=", "15", "y", "^", "2" ।

जैसा कि आप देख सकते हैं, सभी सीमांकक पार्सिंग के परिणाम में नहीं आते हैं (रिक्त स्थान, विशेष रूप से, गिर नहीं)। हम विभाजकों को कॉल करेंगे जो पहले प्रकार के विभाजक के रूप में परिणाम में नहीं आते हैं। अन्य विभाजकों को दूसरे प्रकार के विभाजक कहा जाएगा।

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

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

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

यहाँ पार्सर कोड है:

 (defun parser (txt &optional (d1 " ,") (d2 "()+-*/\^=<>%")) (let ((res nil) (lex "") ) (iter (for s in-string (strCat txt (strLeft d1 1))) (cond ((plusp (strInd d1 s)) (when (> (strLen lex) 0) (collecting lex into res)) (setq lex "")) ((plusp (strInd d2 s)) (when (> (strLen lex) 0) (collecting lex into res)) (collecting s into res) (setq lex "")) (t (setq lex (strCat lex s))))) res)) 

आवश्यक पैरामीटर के अलावा, फ़ंक्शन में दो वैकल्पिक पैरामीटर होते हैं: d1 में एक स्ट्रिंग होती है, जिसमें से प्रत्येक वर्ण में पहले प्रकार का विभाजक होता है, और लाइन d2 में दूसरे प्रकार के विभाजक होते हैं।

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

चलो हमारे पार्सर "कार्रवाई में" की जाँच करें:

 (parser "x = 15 + y^2") ==> ("x" "=" "15" "+" "y" "^" "2") 

यह सही है, है ना? लेकिन स्ट्रिंग्स की सूचियों के साथ काम करना बहुत लिस्प नहीं है। चलो स्ट्रिंग्स की सूची से परमाणुओं की सूची में चलते हैं। ऐसा करने के लिए, हमें एक फ़ंक्शन की आवश्यकता होती है ... जो सभी टोकन को फिर से एक लंबी लाइन में जोड़ता है (लेकिन टोकन के बीच एक स्थान सम्मिलित करता है), फिर इस लाइन की शुरुआत के लिए शुरुआती ब्रैकेट को चिपका देता है, समापन ब्रैकेट को बंद कर देता है ... और फिर लिस्प को सूची पढ़ने के लिए मजबूर करता है:

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

अब, यदि हम mk-intf फ़ंक्शन के इनपुट में असाइनमेंट ऑपरेटर को जमा करते हैं, तो हमें यह मिलता है:

 (mk-intf "x = 15 + y^2") ==> (X = 15 + Y ^ 2) 

जो, आप देखते हैं, बहुत अच्छा है।

अब चलिए स्टार्ट फंक्शन को थोड़ा बदलते हैं: इस फंक्शन को पूरा प्रोसेस पढ़ना और प्रोसेस करना होगा:

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

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

कार्रवाई-खरीद क्या करनी चाहिए? यह फ़ंक्शन एक पैरामीटर के रूप में खुली फ़ाइल के पहचानकर्ता को प्राप्त करता है। फ़ंक्शन फ़ाइल से लाइन द्वारा फ़ाइल लाइन पढ़ता है, खाली लाइनों और टिप्पणियों को छोड़ देता है, बाकी लाइनों को पार्स करता है, इसे सूची रूप में अनुवाद करता है, और प्रक्रिया के शरीर को उत्पन्न करता है।

हम धीरे-धीरे "सीखेंगे" एक्शन-प्रोक जेनरेशन। और चलो एक प्रक्रिया की शुरुआत और अंत को पहचानने के लिए हमारे फ़ंक्शन को सिखाते हैं। एक मिनी-बेसिक में, प्रक्रिया की शुरुआत है:

 proc name(p1,p2,p3) 

इस तरह एक पंक्ति को पार्स करने की कोशिश करें:

 (mk-intf "proc name(p1,p2,p3)") ==> (PROC NAME (P1 P2 P3)) 

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

 (defun action-proc (fi) (let ((stmt nil) (proc-name nil) (proc-parm 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))) ((eq (car stmt) 'end_proc) (return t)) (t (printsline (strCat "****  " (output stmt) "  ")) (setq *flagerr* t)))) `(defun ,proc-name ,proc-parm (quote OK)))) 

डिफॉन क्लॉज के अंतिम गठन के लिए, एक रिवर्स लॉक का उपयोग किया जाता है। ध्यान दें कि उत्पन्न प्रक्रिया परिणाम के रूप में एक ठीक परमाणु वापस कर देगी।

अब हम अपने कोड को कार्रवाई में देख सकते हैं। निम्न कोड को फ़ाइल में 0000.mbs पर रखें:

 proc f1(x,y) end_proc proc f2(x) end_proc 

प्रारंभ प्रक्रिया चलाएँ, 0000.mbs चुनें और कंसोल पर देखें:

 0001 proc f1(x,y) 0002 end_proc 0003 proc f2(x) 0004 end_proc 

यदि आप चाहें, तो आप यह सुनिश्चित कर सकते हैं कि लिस्प मशीन में अब दो (अब तक बेकार) कार्य f1 और f2 हैं :

 (getd 'f1) ==> (EXPR (XY) (QUOTE OK)) (getd 'f2) ==> (EXPR (X) (QUOTE OK)) 

इतना ही नहीं! वे पहले से ही शुरू किए जा सकते हैं:

 (f1 1 2) ==> OK (f2 2) ==> OK 

हमारे अनुवादक ने पहली सांस ली ...

इनपुट, आउटपुट और स्थानीय चर

अब हमारे नवजात अनुवादक को सिखाने का समय है कि इनपुट , प्रिंट और स्थानीय ऑपरेटरों को कैसे संभालें।

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

 (defun action-proc (fi) (let ((stmt nil) (proc-name nil) (proc-parm nil) (loc-var nil) (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))) ((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) ))))) (t (printsline (strCat "****  " (output stmt) "  ")) (setq *flagerr* t)))) `(defun ,proc-name ,proc-parm ,@body))) 

अब इस सोर्स कोड को मिनी बेसिक पर तैयार करते हैं:

 proc f1(x,y) print x print y end_proc proc f2(x) input x print x end_proc 

और इसका अनुवाद करने का प्रयास करें ... हमारे पास दो लिस्प फ़ंक्शन एफ 1 और एफ 2 होंगे । आइए उनके परिभाषित भावों को देखें और सुनिश्चित करें कि वे सही तरीके से उत्पन्न हुए हैं:

 (getd 'f1) ==> (EXPR (XY) (PRINTLINE X) (PRINTLINE Y)) (getd 'f2) ==> (EXPR (X) (SETQ X (READ)) (PRINTLINE X)) 

आप इन फ़ंक्शंस को कॉल कर सकते हैं, और सुनिश्चित कर सकते हैं कि वे ठीक उसी तरह काम करते हैं जैसा आप चाहते हैं। यह आपको परेशान नहीं करता है कि हम पैरामीटर चर में मान दर्ज करते हैं - हमारे पास अभी तक स्थानीय चर नहीं हैं ... चलो उन्हें जोड़ते हैं।

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

 (defun action-proc (fi) (let ((stmt nil) (proc-name nil) (proc-parm nil) (loc-var nil) (lv nil) (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))) ((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)))) (t (printsline (strCat "****  " (output stmt) "  ")) (setq *flagerr* t)))) (iter (for a in (setof loc-var)) (collecting (list a 0) into lv)) `(defun ,proc-name ,proc-parm (let ,lv ,@body)))) 

स्थानीय चर की सूची लोक- चर चर में जमा होती है। प्रक्रिया पूरी होने के बाद, इस सूची से प्रपत्र (नाम 0) के जोड़े की एक सूची बनाई जाती है। इसी समय, समान नामों का दोहराव अवांछनीय है ... इसे कैसे रोका जाए? बेशक, स्थानीय ऑपरेटर के प्रत्येक प्रसंस्करण पर जांचना संभव है कि क्या कोई डुप्लिकेट नाम हैं (यदि कोई हो, तो एक त्रुटि संदेश दें)। लेकिन, यह मुझे लगता है, यह केवल पुनरावृत्ति को खत्म करने के लिए बेहतर है, जो कि सेटऑफ कॉल करता है । अब इस प्रोग्राम को ट्रांसलेट और रन करते हैं:

 proc f1(x,y) local a,b,c print x print y input a print a end_proc 

हम सुनिश्चित करते हैं कि यह ठीक उसी तरह काम करता है जैसा कि एल्गोरिथ्म बताता है। लेकिन सभी सबसे दिलचस्प आगे है!

यहां से आप जो हम हैं उसका अंतिम संस्करण डाउनलोड कर सकते हैं w कोडित ...

जारी रखा जाए!