🎚️ 🉑 🧓🏻 किले के लिए बाइट मशीन (और न केवल) मूल अमेरिकी में (भाग 4) 🧑🏼‍🤝‍🧑🏼 👩🏽‍🌾 💛

और फिर से मैंने लेख की मात्रा को कम करके आंका! मैंने योजना बनाई कि यह अंतिम लेख होगा, जहां हम एक संकलक बनाएंगे और परीक्षण करेंगे। लेकिन वॉल्यूम बड़ा हो गया, और मैंने लेख को दो में विभाजित करने का फैसला किया।

इस लेख में, हम कंपाइलर के लगभग सभी बुनियादी कार्यों को करेंगे। यह जीवन में आएगा, और काफी गंभीर कोड लिखना, संकलित करना और निष्पादित करना संभव होगा। और हम अगले भाग में परीक्षण करेंगे। (वैसे, पिछले भाग: एक , दो , तीन )।

मैं पहली बार हैबे में लिख रहा हूं, शायद यह सब ठीक नहीं है। मेरी राय में, लेख 2, 3 बल्कि सूखा, बहुत सारे कोड, थोड़ा विवरण के रूप में निकला। इस बार मैं कुछ अलग करने की कोशिश करूंगा, खुद विचारों के वर्णन पर ध्यान दूंगा। खैर, कोड ... कोड, निश्चित रूप से यह होगा! कौन अच्छी तरह से समझना चाहता है, ऐसा अवसर होगा। कई मामलों में, मैं कोड को स्पॉइलर के नीचे रखूंगा। और, ज़ाहिर है, आप हमेशा गीथूब पर पूर्ण स्रोत को देख सकते हैं।

संकलक कुछ समय के लिए कोडांतरक में लिखना जारी रखेगा, लेकिन फिर किले में जाएं और अपने आप पर संकलक लिखना जारी रखें। यह बैरन मुनचौसेन से मिलता-जुलता होगा, जिन्होंने दलदल से खुद को बालों से खींच लिया था। लेकिन, शुरुआत के लिए, मैं यह रेखांकित करूंगा कि किले पर कंपाइलर कैसे काम करता है। बिल्ली के लिए आपका स्वागत है!

कंपाइलर कैसे काम करता है?

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

: here h @ ;

यह अलॉट शब्द का उल्लेख करने योग्य है, जो पॉइंटर एच को स्थानांतरित करके निर्दिष्ट बाइट्स को आरक्षित करता है। अलॉट शब्द को इस प्रकार परिभाषित किया जा सकता है:

 : allot h +! ;

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

क्लासिक किले में, शब्द "," का उपयोग पूर्णांक मूल्य संकलित करने के लिए किया जाता है, शब्द "सी," का उपयोग बाइट संकलित करने के लिए किया जाता है। हमारी प्रणाली विभिन्न बिट डेप्थ (8, 16, 32, 64) के मूल्यों का उपयोग करती है, इसलिए, हम अतिरिक्त रूप से "w," और "i" शब्द बनाएंगे। हम "स्ट्र" शब्द भी बनाते हैं, जो स्ट्रिंग से दो मान लेते हुए स्ट्रिंग को संकलित करेगा - पता और स्ट्रिंग की लंबाई।

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

अब सिद्धांत से अभ्यास की ओर बढ़ते हैं!

ट्रेनिंग

शुरुआत में, हमें असेंबली भाषा में कुछ सरल बाइट कमांड करने की आवश्यकता है जो हमें चाहिए। यहां वे हैं: चाल (मेमोरी क्षेत्र की नकल), भरने (मेमोरी क्षेत्र को भरना), बिट संचालन (और, या, एक्सोर, इनवर्ट), बिट शिफ्ट कमांड (rshift, lshift)। चलो एक ही rpick करते हैं (यह पिक के समान है, यह केवल रिटर्न स्टैक के साथ काम करता है, डेटा स्टैक नहीं)।

ये कमांड बहुत सरल हैं, यहां उनका कोड है

 b_move = 0x66 bcmd_move: pop rcx pop rdi pop rsi repz movsb jmp _next b_fill = 0x67 bcmd_fill: pop rax pop rcx pop rdi repz stosb jmp _next b_rpick = 0x63 bcmd_rpick: pop rcx push [rbp + rcx * 8] jmp _next b_and = 0x58 bcmd_and: pop rax and [rsp], rax jmp _next b_or = 0x59 bcmd_or: pop rax or [rsp], rax jmp _next b_xor = 0x5A bcmd_xor: pop rax xor [rsp], rax jmp _next b_invert = 0x5B bcmd_invert: notq [rsp] jmp _next b_rshift = 0x5C bcmd_rshift: pop rcx or rcx, rcx jz _next 1: shrq [rsp] dec rcx jnz 1b jmp _next b_lshift = 0x5D bcmd_lshift: pop rcx or rcx, rcx jz _next 1: shlq [rsp] dec rcx jnz 1b jmp _next

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

निष्कर्ष में, हम शब्द syscall बनाते हैं। इसके साथ, लापता सिस्टम संचालन करना संभव होगा, उदाहरण के लिए, फाइलों के साथ काम करना। यदि प्लेटफ़ॉर्म स्वतंत्रता की आवश्यकता है तो ऐसा समाधान काम नहीं करेगा। लेकिन यह प्रणाली अब परीक्षणों के लिए उपयोग की जाती है, इसलिए इसे अभी के लिए रहने दें। यदि आवश्यक हो, सभी कार्यों को बाइट कमांड में परिवर्तित किया जा सकता है, यह बिल्कुल मुश्किल नहीं है। Syscall कमांड सिस्टम कॉल और स्टैक से कॉल नंबर के लिए 6 मापदंडों को स्वीकार करेगा। यह एक पैरामीटर लौटाएगा। पैरामीटर असाइनमेंट और रिटर्न वैल्यू सिस्टम कॉल नंबर द्वारा निर्धारित किए जाते हैं।

 b_syscall = 0xFF bcmd_syscall: sub rbp, 8 mov [rbp], r8 pop rax pop r9 pop r8 pop r10 pop rdx pop rsi pop rdi syscall push rax mov r8, [rbp] add rbp, 8 jmp _next

और अब सीधे कंपाइलर पर चलते हैं।

संकलक

चलो चर एच बनाते हैं, यहां सब कुछ सरल है।

  item h h: .byte b_var0 .quad 0

हम इसकी आरंभिक पंक्ति में लिखेंगे:

 # forth last_item context @ ! h dup 8 + swap ! quit start: .byte b_call16 .word forth - . - 2 .byte b_call16 .word last_item - . - 2 .byte b_call16 .word context - . - 2 .byte b_get .byte b_set .byte b_call16 .word h - . - 2 .byte b_dup, b_num8, b_add, b_swap, b_set .byte b_quit

आइए यहाँ शब्द बनाते हैं:

  item here .byte b_call8, h - . - 1 .byte b_get .byte b_exit

और मूल्यों को संकलित करने के लिए भी शब्द: "अलॉट" और "सी,", "डब्ल्यू,", "आई,", ",", "स्ट्र,"

 # : allot h +! ; item allot allot: .byte b_call8, h - . - 1, b_setp, b_exit # : , here ! 8 allot ; item "," .byte b_call8, here - . - 1, b_set, b_num8, b_call8, allot - . - 1, b_exit # : i, here i! 4 allot ; item "i," .byte b_call8, here - . - 1, b_set32, b_num4, b_call8, allot - . - 1, b_exit # : w, here w! 2 allot ; item "w," .byte b_call8, here - . - 1, b_set16, b_num2, b_call8, allot - . - 1, b_exit # : c, here c! 1 allot ; item "c," .byte b_call8, here - . - 1, b_set8, b_num1, b_call8, allot - . - 1, b_exit # : str, dup -rot dup c, here swap move 1+ h +!; item "str," c_str: .byte b_dup, b_mrot, b_dup callb c_8 callb here .byte b_swap, b_move callb h .byte b_setp .byte b_exit

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

  item state .byte b_var0 .quad 0 item "]" .byte b_num1 callb state .byte b_set, b_exit item "[", f_immediate .byte b_num0 callb state .byte b_set, b_exit

$ संकलन शब्द के लिए बारी आई। यह स्टैक से शब्दकोश प्रविष्टि का पता लेगा और निर्दिष्ट शब्द संकलित करेगा। साधारण फोर्ट कार्यान्वयन में एक शब्द को संकलित करने के लिए, यह शब्द "," निष्पादन पते पर लागू करने के लिए पर्याप्त है। यहां सब कुछ बहुत अधिक जटिल है। सबसे पहले, दो प्रकार के शब्द हैं - बाइटकोड और मशीन कोड। पूर्व को बाइट द्वारा संकलित किया जाता है, और बाद में कॉल बाइट कमांड द्वारा। और दूसरी बात - हमारे पास कॉल कमांड के चार संस्करण हैं: call8, call16, call32 और call64। चार? नहीं! जब मैंने कंपाइलर लिखा, मैंने इन चार में 16 और जोड़े! :)

यह कैसे हुआ? हमें एक छोटा सा विषयांतर करना होगा।

कॉल कमांड में सुधार

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

लेकिन अगर आप कुछ बिट डालते हैं ... यह पता चला है कि वहाँ कहाँ है! हमारे पास दो बाइट्स हैं: एक बाइट कमांड है, दूसरा ऑफसेट है। लेकिन कुछ भी कमांड के निचले बिट्स को पैरामीटर (ऑफसेट) के उच्च बिट्स को रखने से रोकता है। एक बाइट मशीन के लिए, ऐसा लगता है जैसे कि एक कॉल कमांड के बजाय, कई हैं। हां, इस तरह हम एक कमांड के साथ बाइट-कमांड कोड टेबल की कई कोशिकाओं पर कब्जा कर लेते हैं, लेकिन कभी-कभी ऐसा करने के लायक है। कॉल कमांड सबसे अधिक उपयोग की जाने वाली कमांड में से एक है, इसलिए मैंने कमांड में 4 ऑफसेट बिट्स लगाने का फैसला किया। इस प्रकार, आप 4095 बाइट्स की दूरी पर कॉल कर सकते हैं! इसका मतलब है कि इस तरह के एक शॉर्ट कॉल कमांड का उपयोग लगभग हमेशा किया जाएगा। मैंने इन कमांडों को कोड 0xA0 के साथ रखा था और कमांड टेबल में निम्नलिखित लाइनें दिखाई दीं:

 .quad bcmd_call8b0, bcmd_call8b1, bcmd_call8b2, bcmd_call8b3, bcmd_call8b4, bcmd_call8b5, bcmd_call8b6, bcmd_call8b7 # 0xA0 .quad bcmd_call8b8, bcmd_call8b9, bcmd_call8b10, bcmd_call8b11, bcmd_call8b12, bcmd_call8b13, bcmd_call8b14, bcmd_call8b15

इनमें से पहला बाइट कमांड केवल पैरामीटर में निर्दिष्ट ऑफसेट (255 तक) पर निचले पते की दिशा में कॉल करता है। बाकी संबंधित ऑफसेट को पैरामीटर में जोड़ते हैं। bcmd_call8b1 256 जोड़ता है, bcmd_call8b2 512 जोड़ता है, और इसी तरह। मैंने पहला कॉल कमांड अलग से बनाया, बाकी मैक्रो के साथ।

पहला आदेश:

 b_call8b0 = 0xA0 bcmd_call8b0: movzx rax, byte ptr [r8] sub rbp, 8 inc r8 mov [rbp], r8 sub r8, rax jmp _next

मैक्रो और बाकी कॉल कमांड बनाना:

 .macro call8b N b_call8b\N = 0xA\N bcmd_call8b\N: movzx rax, byte ptr [r8] sub rbp, 8 inc r8 add rax, \N * 256 mov [rbp], r8 sub r8, rax jmp _next .endm call8b 1 call8b 2 call8b 3 call8b 4 call8b 5 call8b 6 call8b 7 call8b 8 call8b 9 call8b 10 call8b 11 call8b 12 call8b 13 call8b 14 call8b 15

खैर, मैं पुराने कॉल 8 कमांड को आगे बढ़ाने के लिए कहता हूं, क्योंकि हमारे पास पहले से ही 16 टीमें कॉल बैक कर रही हैं। जो भी भ्रम है, मैंने उसका नाम बदलकर b_call8f कर दिया:

 b_call8f = 0x0C bcmd_call8f: movzx rax, byte ptr [r8] sub rbp, 8 inc r8 mov [rbp], r8 add r8, rax jmp _next

वैसे, सुविधा के लिए, मैंने एक मैक्रो बनाया, जो कोडांतरक में स्वचालित रूप से 4095 के भीतर कॉल बैक को संकलित करता है। और फिर मुझे कभी भी इसकी आवश्यकता नहीं है :)

 .macro callb adr .if \adr > . .error "callb do not for forward!" .endif .byte b_call8b0 + (. - \adr + 1) >> 8 .byte (. - \adr + 1) & 255 .endm

और अब ...

टीम संकलन

तो, हम एक जटिल जटिल संकलन एल्गोरिथ्म प्राप्त करते हैं। यदि यह एक बाइट कमांड है, तो बस एक बाइट (बाइट कमांड कोड) संकलित करें। और अगर यह शब्द पहले से ही bytecode में लिखा गया है, तो आपको कॉल कमांड के साथ इसके कॉल को संकलित करने की आवश्यकता है, बीस में से एक को चुनना। अधिक सटीक रूप से 19, इसलिए हमारे पास कोई कॉल फॉरवर्ड नहीं है, और कॉल 8 एफ किले के लिए उपयोग नहीं किया जाएगा।

तो चुनाव यह है। यदि ऑफ़सेट 0 ...- 4095 के भीतर है, तो कोड 0xA0 के साथ bcmd_call8b कमांड का चयन करें, कमांड के कम से कम महत्वपूर्ण बिट्स में चार सबसे महत्वपूर्ण ऑफ़सेट बिट्स को रखें। इसी समय, बाइट मशीन के लिए, bcmd_call8b0 कमांड में से एक के लिए कोड bcmd_call8b15 है।

यदि बैकवर्ड ऑफसेट 4095 से अधिक या उसके बराबर है, तो हम निर्धारित करते हैं कि ऑफसेट को किस आयाम में रखा गया है और कॉल 16 / 32/64 से उपयुक्त कमांड का उपयोग करें। यह ध्यान में रखा जाना चाहिए कि इन टीमों के लिए ऑफसेट पर हस्ताक्षर किए गए हैं। वे आगे और पीछे दोनों का कारण बन सकते हैं। उदाहरण के लिए, call16 दोनों दिशाओं में 32767 की दूरी कह सकता है।

परिणाम के रूप में यहां कार्यान्वयन है:

$ संकलन

एक शब्द संकलित करता है। एक पैरामीटर के रूप में, संकलित शब्द के शब्दकोश प्रविष्टि का पता लेता है। वास्तव में, यह f_code ध्वज की जाँच करता है, कोड पता (cfa) की गणना करता है, और compile_b या compile_c (यदि ध्वज सेट है) को कॉल करता है।

compile_c

एक बाइट कमांड संकलित करता है। यहाँ सबसे सरल शब्द किले पर इस तरह वर्णित है:

 : compile_c c@ c, ;

compile_b
यह स्टैक पर एक बाइटकोड पता लेता है और इसके कॉल को संकलित करता है।

test_bv

यह स्टैक से एक ऑफसेट लेता है (एक संकेत के साथ) और यह निर्धारित करता है कि किस गहराई का उपयोग करने के लिए (1, 2, 4, या 8 बाइट्स)। मान 0, 1, 2 या 3 लौटाता है। इस शब्द का उपयोग करके आप यह निर्धारित कर सकते हैं कि कॉल 16 / 32/64 कमांड में से किसका उपयोग करना है। संख्या संकलित करते समय (lit8 / 16/32/64 से एक विकल्प) यह शब्द काम में आएगा।

वैसे, आप सिस्टम में और इन शब्दों में से किसी के साथ किले कंसोल में "चारों ओर खेल" शुरू कर सकते हैं। उदाहरण के लिए:

 $ ./forth ( 0 ): > 222 test_bv ( 2 ): 222 1 > drop drop ( 0 ): > 1000000 test_bv ( 2 ): 1000000 2 > drop drop ( 0 ): > -33 test_bv ( 2 ): -33 0 >

test_bvc

यह स्टैक से एक ऑफसेट (एक संकेत के साथ) लेता है और निर्धारित करता है कि किस कमांड का उपयोग करना है। वास्तव में, यह देखने के लिए जाँच करता है कि ऑफ़सेट 0 ... -4095 की सीमा के भीतर है या नहीं। 0. इस मामले में, यदि इस अंतराल में कोई हिट नहीं है, तो यह test_bv कहलाता है।

यह सब कमांड को संकलित करने के लिए लेता है।

 # : test_bvc dup 0 >= over FFF <= and if 0 exit else ... item test_bvc test_bvc: .byte b_dup, b_neg .byte b_num0 .byte b_gteq .byte b_over, b_neg .byte b_lit16 .word 0xFFF .byte b_lteq .byte b_and .byte b_qnbranch8, 1f - . .byte b_num0 .byte b_exit item test_bv test_bv: .byte b_dup, b_lit8, 0x80, b_gteq, b_over, b_lit8, 0x7f, b_lteq, b_and, b_qnbranch8, 1f - ., b_num0 .byte b_exit 1: .byte b_dup .byte b_lit16 .word 0x8001 .byte b_gteq .byte b_over .byte b_lit16 .word 0x7ffe .byte b_lteq, b_and, b_qnbranch8, 2f - ., b_num1, b_exit 2: .byte b_dup .byte b_lit32 .int 0x80000002 .byte b_gteq .byte b_over .byte b_lit32 .int 0x7ffffffd .byte b_lteq, b_and, b_qnbranch8, 3f - ., b_num2, b_exit 3: .byte b_num3 .byte b_exit #  - item compile_c compile_c: .byte b_get8 callb c_8 .byte b_exit #   - item compile_b compile_b: callb here .byte b_num2, b_add .byte b_sub callb test_bvc .byte b_dup .byte b_zeq .byte b_qnbranch8, 1f - . .byte b_drop .byte b_neg .byte b_dup .byte b_lit8, 8 .byte b_rshift .byte b_lit8, b_call8b0 .byte b_or callb c_8 callb c_8 .byte b_exit 1: .byte b_dup, b_num1, b_eq, b_qnbranch8, 2f - ., b_drop, b_lit8, b_call16 callb c_8 .byte b_wm callb c_16 .byte b_exit 2: .byte b_num2, b_eq, b_qnbranch8, 3f - ., b_lit8, b_call32 callb c_8 .byte b_num3, b_sub callb c_32 .byte b_exit 3: .byte b_lit8, b_call64 callb c_8 .byte b_lit8, 7, b_sub callb c_64 .byte b_exit #: $compile dup c@ 0x80 and if cfa compile_c else cfa compile_b then ; item "$compile" _compile: .byte b_dup, b_get8, b_lit8, 0x80, b_and, b_qnbranch8, 1f - ., b_cfa callb compile_c .byte b_exit 1: .byte b_cfa callb compile_b .byte b_exit

अब हमें संख्या को संकलित करने की आवश्यकता है।

संख्या संकलित करना (शाब्दिक)

एक पूरा उपशीर्षक लिखा, विशेष रूप से शाब्दिक संकलन का वर्णन करने के लिए तैयार किया गया है, लेकिन यह पता चला है कि वर्णन करने के लिए कुछ खास नहीं है :)

हमने पहले से ही test_bv शब्द में आधा काम कर लिया है। यह केवल test_bv को कॉल करने के लिए बना रहता है, और, परिणाम के आधार पर, lit8 / 16/32/64 संकलित करता है, और फिर आकार में 1, 2, 4 या 8 बाइट्स के संबंधित मूल्य।

हम यह संकलन compn_n शब्द को परिभाषित करके करते हैं

 #   item compile_n compile_n: callb test_bv .byte b_dup .byte b_zeq .byte b_qnbranch8, 1f - . .byte b_drop, b_lit8, b_lit8 callb c_8 callb c_8 .byte b_exit 1: .byte b_dup, b_num1, b_eq, b_qnbranch8, 2f - ., b_drop, b_lit8, b_lit16 callb c_8 callb c_16 .byte b_exit 2: .byte b_num2, b_eq, b_qnbranch8, 3f - ., b_lit8, b_lit32 callb c_8 callb c_32 .byte b_exit 3: .byte b_lit8, b_lit64 callb c_8 callb c_64 .byte b_exit

दुभाषिया संशोधित करें

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

यहाँ दुभाषिया है

  item interpret interpret: .byte b_blword .byte b_dup .byte b_qnbranch8 .byte 0f - . .byte b_over .byte b_over .byte b_find .byte b_dup .byte b_qnbranch8 .byte 1f - . .byte b_mrot .byte b_drop .byte b_drop callb state .byte b_get .byte b_qnbranch8, irpt_execute - . #  0,    .byte b_dup, b_get8, b_lit8, f_immediate, b_and #  immediate    .byte b_qbranch8, irpt_execute - . #    -   #   ! callb _compile .byte b_branch8, 2f - . irpt_execute: .byte b_cfa #  ,    (state = 0  immediate  ) .byte b_execute .byte b_branch8, 2f - . 1: .byte b_drop .byte b_over, b_over .byte b_numberq # ,    .byte b_qbranch8, 3f - . #     0, ,      3 .byte b_type #    .byte b_strp #   .byte 19 #     .ascii " : word not found!\n" .byte b_quit #    3: .byte b_nip, b_nip #  ,     ( b_over, b_over) #   -   callb state # ,    .byte b_get .byte b_qnbranch8, 2f - . #   -     ;   -   #   callb compile_n 2: #       .byte b_depth #    .byte b_zlt # ,   0 ( 0<) .byte b_qnbranch8, interpret_ok - . #   ,    ,   .byte b_strp #    .byte 14 .ascii "\nstack fault!\n" .byte b_quit #    interpret_ok: .byte b_branch8 .byte interpret - . 0: .byte b_drop .byte b_exit

अब हम संकलक से एक कदम दूर हैं ...

नए शब्दों की परिभाषा (शब्द ":")

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

हेडर में झंडे, संचार का एक क्षेत्र और एक नाम होना चाहिए। यहां हमारे पास एक परिचित कहानी है - संचार क्षेत्र 1, 2, 4 या 8 बाइट्स हो सकता है। आइए शब्द compile_1248 बनाते हैं, जो इस तरह के संचार क्षेत्र को बनाने में हमारी मदद करेगा। यह स्टैक पर दो नंबर लेगा - ऑफसेट और test_bv कमांड द्वारा उत्पन्न मूल्य।

compile_1248

 #    , ,     #     ,  test_dv item compile_1248 compile_1248: .byte b_dup .byte b_zeq .byte b_qnbranch8, 1f - . .byte b_drop callb c_8 .byte b_exit 1: .byte b_dup, b_num1, b_eq, b_qnbranch8, 2f - . .byte b_drop callb c_16 .byte b_exit 2: .byte b_num2, b_eq, b_qnbranch8, 3f - . callb c_32 .byte b_exit 3: callb c_64 .byte b_exit

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

$ बना

 # : $create here current @ @ here - test_bv dup c, compile_1248 -rot str, current @ ! ' var0 here c!; item "$create" create: callb here callb current .byte b_get, b_get callb here .byte b_sub callb test_bv .byte b_dup callb c_8 callb compile_1248 .byte b_mrot callb c_str #       callb current .byte b_get, b_set #     - var0,      here #   ,    -    ,    #     ,     #    1 allot   ,   .byte b_lit8, b_var0 callb here .byte b_set8 .byte b_exit

अगला शब्द इनपुट स्ट्रीम से नए शब्द के नाम को उठाएगा, जिसमें वर्ड वर्ड का उपयोग किया जाएगा और $ create को कॉल किया जाएगा, जो निर्दिष्ट नाम के साथ एक नया शब्द बनाएगा।

create_in

  item "create_in" create_in: .byte b_blword .byte b_dup .byte b_qbranch8 .byte 1f - . .byte b_strp #   (     ) .byte 3f - 2f #     2: .ascii "\ncreate_in - name not found!\n" 3: .byte b_quit 1: callb create .byte b_exit

और अंत में, शब्द ":" बनाएं। यह create_in का उपयोग करके एक नया शब्द बनाएगा और संकलन मोड सेट करेगा, यह स्थापित नहीं है। और यदि स्थापित है, तो यह एक त्रुटि देता है। शब्द ":" पर तत्काल संकेत होगा।

शब्द:

 # : : create_in 1 state dup @ if ." : - no execute state!" then ! 110 ; immediate item ":", f_immediate colon: callb create_in .byte b_num1 callb state .byte b_dup .byte b_get .byte b_qnbranch8, 2f - . .byte b_strp #   (     ) .byte 4f - 3f #     3: .ascii "\n: - no execute state!\n" 4: .byte b_quit 2: .byte b_set .byte b_lit8, 110 .byte b_exit

अगर किसी ने कोड में देखा, तो उसने देखा कि यह शब्द कुछ और है :)

और यहाँ 110 है ???

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

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

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

जोड़े? राज्य

 #: ?pairs = ifnot exit then ." \nerror: no pairs operators" quit then ; item "?pairs" .byte b_eq, b_qbranch8, 1f - . .byte b_strp .byte 3f - 2f 2: .ascii "\nerror: no pairs operators" 3: .byte b_quit 1: .byte b_exit #: ?state state @ 0= if abort" error: no compile state" then ; item "?state" callb state .byte b_get, b_zeq, b_qnbranch8, 1f - . .byte b_strp .byte 3f - 2f 2: .ascii "\nerror: no compile state" 3: .byte b_quit 1: .byte b_exit

वह सब है! हमने असेंबलर में मैन्युअल रूप से कुछ और संकलन नहीं किया :)

लेकिन अंत तक, कंपाइलर अभी तक नहीं लिखा गया है, इसलिए शुरुआत में आपको कुछ असामान्य तरीकों का उपयोग करना होगा ...

तैयार कंपाइलर को संकलित करने के लिए तैयार हो जाओ

आरंभ करने के लिए, आप जांच सकते हैं कि कैसे शब्द ":" कुछ सरल संकलन करके काम करता है। चलो, उदाहरण के लिए, शब्द बनाते हैं:

 : ^2 dup * ;

यह शब्द चुकता है। लेकिन हमारे पास शब्द नहीं है "?" क्या करना है?हम शब्द बाहर निकलने के बजाय लिखते हैं, और यह संकलित करता है। और फिर "[" शब्द के साथ संकलन मोड को बंद करें और मूल्य 110 को छोड़ दें:

 $ ./forth ( 0 ): > : ^2 dup * exit [ drop ( 0 ): > 4 ^2 ( 1 ): 16 >

यह काम करता है! चलो

जारी रखें ...

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

 fcode: .ascii " 2 2 + . quit"

लेकिन, लाइन की शुरुआत में यह एक दर्जन रिक्त स्थान रखने के लायक है।

इस काम को करने के लिए, हम स्टार्ट बायटेकोड को बदलते हैं ताकि टिब, # टीब इस लाइन की ओर इशारा करें। अंत में सिस्टम के सामान्य कमांड लाइन में प्रवेश करने के लिए एक छोड़ दिया जाता है।

बायोटेक शुरू करना इस तरह से हो गया है

 start: .byte b_call16 .word forth - . - 2 .byte b_call16 .word last_item - . - 2 .byte b_call16 .word context - . - 2 .byte b_get .byte b_set .byte b_call16 .word vhere - . - 2 .byte b_dup .byte b_call16 .word h - . - 2 .byte b_set .byte b_call16 .word definitions - . - 2 .byte b_call16 .word tib - . - 2 .byte b_set .byte b_lit16 .word fcode_end - fcode .byte b_call16 .word ntib - . - 2 .byte b_set .byte b_call16 .word interpret - . - 2 .byte b_quit

भागो!

 $ ./forth 4 ( 0 ): >

बहुत बढ़िया!

और अब ...

कंपाइलर को कंपाइलर से कंपेयर करें

अगला, हम कोड को fcode लाइन में लिखते हैं। पहली बात, ज़ाहिर है, शब्द है ";"।

 : ; ?state 110 ?pairs lit8 [ blword exit find cfa c@ c, ] c, 0 state ! exit [ current @ @ dup c@ 96 or swap c! drop

मैं कुछ स्पष्टीकरण करूंगा।

 ?state 110 ?pairs

यहां हम जांचते हैं कि संकलन स्थिति वास्तव में सेट है, और 110 स्टैक पर है। अन्यथा, गलती से एक रुकावट होगी।

 lit8 [ blword exit find cfa c@ c, ]

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

 c, 0 state !

यह एक्जिट कमांड को संकलित करेगा जब शब्द ";" निष्पादित होता है, और फिर व्याख्या मोड सेट किया जाएगा। यहां "[" शब्द का उपयोग नहीं किया जा सकता है, क्योंकि इसका तात्कालिक संकेत है और इसे अब निष्पादित किया गया है , लेकिन हमें ऐसे आदेशों को शब्द में संकलित करने की आवश्यकता है "" ताकि वे संकलन मोड को बंद कर दें।

 exit [

इसका अनुभव हम पहले ही कर चुके हैं। बाहर निकलने का शब्द संकलित है और संकलन मोड बंद है। सब कुछ, शब्द "" संकलित। और आगे क्या लिखा है?

 current @ @ dup c@ 96 or swap c! drop

आपको नए शब्द के लिए तत्काल ध्वज सेट करना होगा। यह ठीक वैसा ही है जैसा कि संकेतित क्रम शब्द ड्रॉप को छोड़कर करता है। शब्द ड्रॉप, भूले हुए 110 को हटा देता है जिसने शब्द ":" को सृजन की शुरुआत में रखा था।

अब यह सब है!

हम लॉन्च करते हैं और कोशिश करते हैं।

 $ ./forth ( 0 ): > : ^3 dup dup * * ; ( 0 ): > 6 ^3 . 216 ( 0 ): >

वहाँ है!यह पहला शब्द है जिसे हमारे संकलक ने "वास्तविक के लिए" संकलित किया है।

लेकिन हमारे पास अभी भी कोई स्थिति नहीं है, कोई लूप नहीं है, और बहुत कुछ ... चलो एक संकलक बनाने के लिए एक छोटे लेकिन बहुत आवश्यक शब्द से शुरू करते हैं: तत्काल। यह बनाए गए अंतिम शब्द पर तत्काल विशेषता सेट करता है:

 : immediate current @ @ dup c@ 96 or swap c! ;

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

 : hex 16 base ! ; : decimal 10 base ! ; : bl 32 ; : tab 9 ; : lf 10 ;

हेक्स और दशमलव इसी संख्या प्रणाली सेट करें। बाकी लोग संबंधित वर्ण कोड प्राप्त करने के लिए निरंतर हैं।

हम एक काउंटर की प्रतिलिपि बनाने के लिए एक शब्द भी बनाते हैं
:: c @ 1+ मूव के ऊपर cmove;

और अब हम परिस्थितियों में लगे रहेंगे। सामान्य तौर पर, यदि कोई शब्द संकलित होता है, तो यह इस तरह दिखेगा:

 : if ?state compile ?nbranch8 here 0 c, 111 ; immediate : then ?state 111 ?pairs dup here swap - swap c! ; immediate

शुरुआत में ये सभी शब्द सत्यापित करते हैं कि संकलन मोड सेट है और ऐसा नहीं होने पर त्रुटि उत्पन्न होती है।

यदि शब्द एक सशर्त शाखा को संकलित करता है, तो सशर्त शाखा कमांड पैरामीटर के लिए एक बाइट आरक्षित करता है, और स्टैक पर उस बाइट के पते को धक्का देता है। फिर यह स्टैक पर नियंत्रण मूल्य 111 को धकेलता है।

शब्द तब नियंत्रण मूल्य 111 की उपस्थिति के लिए जांच करता है, और फिर स्टैक पर पते के लिए ऑफसेट लिखता है।

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

 : if compile ?nbranch8 here 0 c, ; immediate : then dup here swap - swap c! ; immediate

खैर, अब हम असली कोड प्रोग्राम करते हैं। चूँकि हमारे पास शब्द संकलन नहीं है, हम शब्द बनाते समय उसी चाल को लागू करते हैं ";";

 : if ?state lit8 [ blword ?nbranch8 find cfa c@ c, ] c, here 0 c, 111 ; immediate : then ?state 111 ?pairs dup here swap - swap c! ; immediate : else ?state 111 ?pairs lit8 [ blword branch8 find cfa c@ c, ] c, here 0 c, swap dup here swap - swap c! 111 ; immediate

अब आप स्थिति को संकलित करने का प्रयास कर सकते हैं। उदाहरण के लिए, एक शब्द जो 1000 को प्रिंट करता है, यदि स्टैक पर 5 हैं, और अन्य मामलों में 0:

 $ ./forth ( 0 ): > : test 5 = if 1000 . else 0 . then ; ( 0 ): > 22 test 0 ( 0 ): > 3 test 0 ( 0 ): > 5 test 1000 ( 0 ): >

यह स्पष्ट है कि इस तरह के परिणाम ने तुरंत काम नहीं किया, त्रुटियां थीं, डिबगिंग थी। लेकिन अंत में, शर्तों ने काम किया!

संक्रमण आदेशों की लंबाई के बारे में एक छोटा विषयांतर

, , 127 . . , , . , , . 8 , 40 127 . , ?

. — 16 .

. 16 — . , , call, . , 11 ( 1023 ). 300 1000 . , . 3 , 8 . : (?nbranch), (?branch) (branch). — 24 .

हमारे पास स्थितियां हैं, जीवन आसान हो जाता है :)

चलो एक शब्द बनाते हैं। "(डॉट-उद्धरण) यह निष्पादित किए जाने पर निर्दिष्ट पाठ प्रदर्शित करता है। इसका उपयोग इस तरह किया जाता है:

 ."    "

आप इस शब्द का उपयोग केवल संकलन मोड में कर सकते हैं। इस शब्द के उपकरण का विश्लेषण करने के बाद यह स्पष्ट हो जाएगा:

 : ." ?state 34 word dup if lit8 [ blword (.") find cfa c@ c, ] c, str, else drop then ; immediate

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

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

।

 $ ./forth ( 0 ): > : test ."    " ; ( 0 ): > test     ( 0 ): >

और अंत में, आइए शब्द को संकलित करें।

यह स्पष्ट है कि संकलन मोड में इस शब्द को स्ट्रीम से अगले शब्द का नाम लेना चाहिए, इसे शब्दकोश में ढूंढें। और फिर विकल्प होंगे: यह एक बाइट कमांड हो सकता है, या यह बाइट कोड में लिखा गया शब्द हो सकता है। इन शब्दों को अलग-अलग तरीकों से संकलित किया जाना चाहिए। इसलिए, हम दो सहायक शब्द बनाएंगे: "(compile_b)" और "(compile_c)"।

(compile_b) बाइटकोड को लागू करने के लिए कॉल कमांड को संकलित करेगा। पैरामीटर एक 64-बिट शब्द होगा - जिसे बायटेकोड का पता कहा जाता है।

(compile_c) बाइट कमांड को संकलित करेगा। तदनुसार, इस कमांड का पैरामीटर एक बाइट होगा - कमांड कोड।

ठीक है, शब्द खुद को या तो (compile_b) या (compile_c) संगत मापदंडों के साथ संकलित करेगा।

आइए शुरुआत करते हैं (संकलन_सी),सबसे सरल के साथ:

 : (compile_c) r> dup c@ swap 1+ >rc, ;

इसकी सादगी के बावजूद, हम सबसे पहले बाइटकोड में एक शब्द लिखते हैं, जो अपने आप में पैरामीटर है। इसलिए, मैं टिप्पणी करूंगा। (Compile_c) दर्ज करने के बाद, वापसी पता स्टैक पर स्थित है, क्योंकि यह ट्राइट नहीं है। यह कॉल कमांड के बाद अगले बाइट का पता है। कॉल के समय की स्थिति नीचे दिखाई गई है। A0 - कॉल कमांड कोड, XX - कॉल कमांड पैरामीटर - शब्द के बाइट कोड के कॉल एड्रेस (ऑफसेट) (compile_c)।

वापसी का पता बाइट एनएन दर्शाता है। आमतौर पर कमांड के अगले बाइट के लिए कोड होता है। लेकिन हमारे शब्द में पैरामीटर हैं, इसलिए NN शब्द "compile_c" का केवल पैरामीटर है, अर्थात् संकलित कमांड का बाइट कोड। आपको इस बाइट को पढ़ने और अगले बाइट कमांड को आगे बढ़ाकर रिटर्न एड्रेस बदलने की आवश्यकता है। यह अनुक्रम "r> डुप् सी @ स्वैप 1+> आर" द्वारा किया जाता है। यह क्रम रिटर्न स्टैक से रिटर्न एड्रेस को नियमित स्टैक तक खींचता है, इसमें से एक बाइट को पुनः प्राप्त करता है, इसमें से एक को जोड़ता है (रिटर्न एड्रेस), और इसे रिटर्न स्टैक में वापस लौटाता है। शेष कमांड "c", मापदंडों से प्राप्त बाइट कमांड कोड को संकलित करता है।

(compile_b) अधिक जटिल नहीं है:

 : (compile_b) r> dup @ swap 8 + >r compile_b ;

यहां सब कुछ समान है, केवल 64-बिट पैरामीटर पढ़ा जाता है, और शब्द संकलन संकलन का उपयोग शब्द को संकलित करने के लिए किया जाता है, जिसे हमने पहले ही संकलक के लिए बनाया है।

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

शब्द संकलन

 : compile blword over over find dup if dup c@ 128 and if cfa c@ (compile_b) [ blword (compile_c) find cfa , ] c, else cfa (compile_b) [ blword (compile_b) find cfa , ] , then drop drop else drop ." compile: " type ." - not found" then ; immediate

बनाए गए शब्द की जाँच करने के लिए, हम इसकी मदद से, ifnot शब्द बनाते हैं।

 : ifnot ?state compile ?branch8 here 0 c, 111 ; immediate

इसे देखें!

 $ ./forth ( 0 ): > : test 5 = ifnot 1000 . else 0 . then ; ( 0 ): > 22 test 1000 ( 0 ): > 3 test 1000 ( 0 ): > 5 test 0 ( 0 ): >

सब ठीक है! और यह चक्र करने का समय है ...

इस लेख में हम एक शर्त के साथ चक्र बनाएंगे। किले में एक शर्त के साथ एक चक्र के लिए दो विकल्प हैं।

पहला विकल्प शुरू होता है ... जब तक। जब तक शब्द स्टैक से मान नहीं निकालता है, और यदि यह शून्य के बराबर नहीं है, तो चक्र समाप्त होता है।

दूसरा विकल्प शुरू होता है ... जबकि ... दोहराएं। इस स्थिति में, चेक तब होता है जब शब्द निष्पादित होता है। यदि स्टैक पर मान शून्य है, तो लूप बाहर निकलता है।

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

 : begin ?state here 112 ; immediate : until ?state 112 ?pairs compile ?nbranch8 here - c, ; immediate : while ?state 112 ?pairs compile ?nbranch8 here 0 c, 113 ; immediate : repeat ?state 113 ?pairs swap compile branch8 here - c, dup here swap - swap c! ; immediate

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

लेकिन हमें साइकिल कमांड का अनुभव नहीं था!

हम यह मानक शब्द शब्द लिखकर करते हैं। हमें अंततः अपना शब्दकोश देखना चाहिए।
ऐसा करने के लिए, शुरुआत में, हम शब्द लिंक @ बनाते हैं। यह डिक्शनरी एंट्री (पिछली प्रविष्टि के ऑफ़सेट) से संचार क्षेत्र को निकालेगा। जैसा कि हम याद करते हैं, संचार क्षेत्र का एक अलग आकार हो सकता है: 1, 2, 4 या 8 बाइट्स। यह शब्द शब्दकोश प्रविष्टि के पते को स्टैक पर ले जाएगा, और दो मान लौटाएगा: नाम फ़ील्ड का पता और संचार क्षेत्र का मान।

 : link@ dup c@ 3 and swap 1+ swap dup 0= if drop dup 1+ swap c@ else dup 1 = if drop dup 2 + swap w@ else 2 = if drop dup 4 + swap i@ else drop dup 8 + swap @ then then then ;

और अब आप शब्द शब्द बना सकते हैं:

 : words context @ @ 0 begin + dup link@ swap count type tab emit dup 0= until drop drop ;

लॉन्च हो रहा है ...

 $ ./forth ( 0 ): > words words link@ repeat while until begin ifnot compile (compile_b) (compile_c) ." else then if cmove tab bl decimal hex immediate ; bye ?state ?pairs : str, interpret $compile compile_b compile_n compile_1248 compile_c c, w, i, , allot here h test_bv test_bvc [ ] state .s >in #tib tib . #> #s 60 # hold span holdpoint holdbuf base quit execute cfa find word blword var16 var8 (.") (") count emit expect type lshift rshift invert xor or and >= <= > < = 0> 0< 0= bfind compare syscall fill move rpick r@ r> >r -! +! i! i@ w! w@ c! c@ ! @ depth roll pick over -rot rot swap drop dup abs /mod mod / * - + 1+ 1- exit ?nbranch16 ?nbranch8 ?branch16 ?branch8 branch16 branch8 call8b0 call64 call32 call16 call8f lit64 lit32 lit16 lit8 8 4 3 2 1 0 context definitions current forth ( 0 ): >

यहाँ यह है, हमारी संपत्ति :)

मैं सब कुछ कहना चाहता था ... नहीं, चलो फिर भी एक पैरामीटर के रूप में संकलन और निष्पादन के लिए एक किले कार्यक्रम के साथ एक फ़ाइल निर्दिष्ट करना संभव है।

हम फ़ाइल खोलने, बंद करने और पढ़ने के लिए syscall कमांड बनाते हैं। हम उनके लिए आवश्यक स्थिरांक को परिभाषित करते हैं।

 : file_open 0 0 0 2 syscall ; : file_close 0 0 0 0 0 3 syscall ; : file_read 0 0 0 0 syscall ; : file_O_RDONLY 0 ; : file_O_WRONLY 1 ; : file_O_RDWR 3 ;

अब आप शुरुआत शब्द _start बना सकते हैं:

 : _start 0 pick 1 > if 2 pick file_O_RDONLY 0 file_open dup 0< if .\" error: \" . quit then dup here 32 + 32768 file_read dup 0< if .\" error: \" . quit then swap file_close drop #tib ! here 32 + tib ! 0 >in ! interpret then ;

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

अब यह अंत में fcode लाइन में लिखना है:

 _start quit

एक फ़ाइल test.f बनाएं और किले पर वहां कुछ लिखें। उदाहरण के लिए, सबसे बड़ा सामान्य कारक खोजने के लिए यूक्लिडियन एल्गोरिथ्म:

 : NOD begin over over <> while over over > if swap over - swap else over - then repeat drop ; 23101 44425 NOD . bye

हम शुरू करते हैं।

 $ ./forth test.f 1777 Bye! $

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

वह सब है।कौन परवाह करता है, आप G86ub से x86-64 पर लिनक्स के लिए स्रोत या रेडीमेड बाइनरी डाउनलोड कर सकते हैं: https://github.com/hal9000cc/forth64

स्रोत लाइसेंस के साथ आते हैं ~~GNU GPL v2~~ DCH v1 - क्या आप चाहते हैं :-)

किले के लिए बाइट मशीन (और न केवल) मूल अमेरिकी में (भाग 4)