🌥️ 🍹 ⚪️ किले के लिए बाइट मशीन (और न केवल) मूल अमेरिकी में (भाग 3) 🎂 🥂 👩🏻‍🍳

साल 2019 आ गया है। नए साल की छुट्टियां खत्म हो रही हैं। यह बाइट्स, कमांड्स, वैरिएबल, लूप्स को याद करने का समय है ...

कुछ ऐसा जो मैं इन छुट्टियों के साथ भूल चुका हूँ। एक साथ याद रखना है!

आज हम अपनी बाइट मशीन के लिए एक दुभाषिया बनाएंगे। यह तीसरा लेख है, पहले भाग यहां हैं: भाग 1 , भाग 2 ।

सभी को नव वर्ष की शुभकामनाएं, और कट के लिए स्वागत है!

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

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

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

वार्म अप करें

और अब थोड़ी कसरत। चलो छोटी लेकिन उपयोगी बाइट कमांड का एक और हिस्सा बनाते हैं। ये कमांड होंगे nip, emit, 1+, +! -; -!, Count स्टैक के साथ काम के शब्द>>, r, r @, a string शाब्दिक ("), और निरंतर शब्द 1, 2, 3, 4, 8. उन्हें आदेशों की तालिका में शामिल करना न भूलें।

यहाँ इन कमांड के लिए कोड है

b_nip = 0x39 bcmd_nip: pop rax mov [rsp], rax jmp _next b_emit = 0x81 bcmd_emit: pop rax mov rsi, offset emit_buf #   mov [rsi], al mov rax, 1 #   № 1 - sys_write mov rdi, 1 #  № 1 - stdout mov rdx, 1 #   push r8 syscall #   pop r8 jmp _next b_wp = 0x18 bcmd_wp: incq [rsp] jmp _next b_setp = 0x48 bcmd_setp: pop rcx pop rax add [rcx], rax jmp _next b_setm = 0x49 bcmd_setm: pop rcx pop rax sub [rcx], rax jmp _next b_2r = 0x60 bcmd_2r: pop rax sub rbp, 8 mov [rbp], rax jmp _next b_r2 = 0x61 bcmd_r2: push [rbp] add rbp, 8 jmp _next b_rget = 0x62 bcmd_rget: push [rbp] jmp _next b_str = 0x82 bcmd_str: movzx rax, byte ptr [r8] lea r8, [r8 + rax + 1] jmp _next b_count = 0x84 bcmd_count: pop rcx movzx rax, byte ptr [rcx] inc rcx push rcx push rax jmp _next b_num1 = 0x03 bcmd_num1: push 1 jmp _next b_num2 = 0x04 bcmd_num2: push 2 jmp _next b_num3 = 0x05 bcmd_num3: push 3 jmp _next b_num4 = 0x06 bcmd_num4: push 4 jmp _next b_num8 = 0x07 bcmd_num8: push 8 jmp _next

निप कमांड स्टैक के शीर्ष के नीचे शब्द को हटाता है। यह स्वैप कमांड के बराबर है। यह कभी-कभी मददगार हो सकता है।

Emit कमांड स्टैक से एक वर्ण को धकेलता है। यह एक ही सिस्टम कॉल नंबर 1 का उपयोग करता है, चरित्र 1 की लंबाई के साथ बफर में रखता है।

गिनती कमांड बहुत सरल है - यह स्टैक से काउंटर के साथ लाइन का पता लेता है और इसे दो मानों में बदल देता है - काउंटर और लंबाई के बिना लाइन का पता।

B_2r, b_r2, b_rget कमांड फोर्ट शब्द r>,> r, r @ हैं। पहले रिटर्न स्टैक से शब्द लेता है और इसे अंकगणित स्टैक पर रखता है। दूसरा विपरीत ऑपरेशन करता है। तीसरा रिटर्न रिटर्न स्टैक से शब्द को कॉपी करता है, इसे अंकगणित में रखता है, रिटर्न स्टैक नहीं बदलता है।

B_setp और b_setm कमांड शब्द + हैं! और -! .. वे स्टैक से मान और पता लेते हैं, और स्टैक से मान को जोड़ने या हटाने के लिए निर्दिष्ट पते पर शब्द को संशोधित करते हैं।

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

बाकी टीम, मुझे लगता है, टिप्पणियों की जरूरत नहीं है।

हम एक निरंतर स्ट्रिंग (। ") प्रिंट करने के लिए एक कमांड भी बनाते हैं। हम इसे प्रविष्टि बिंदु के रूप में टाइप करने के लिए लागू करेंगे:

 b_strp = 0x83 bcmd_strp: movsx rax, byte ptr [r8] inc r8 push rax push r8 add r8, rax b_type = 0x80 bcmd_type: mov rax, 1 #   № 1 - sys_write mov rdi, 1 #  № 1 - stdout pop rdx #   pop rsi #   push r8 syscall #   pop r8 jmp _next

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

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

जनक शब्द

चरों को याद करो। हम जानते हैं कि वे कैसे बायटेकोड स्तर (var0 कमांड) पर व्यवस्थित होते हैं। एक नया चर बनाने के लिए, किला निम्नलिखित निर्माण का उपयोग करता है:

 variable < >

इस क्रम को करने के बाद, एक नया शब्द <चर नाम> बनाया जाता है। इस नए शब्द का निष्पादन चर के मान को संग्रहीत करने के लिए पते को स्टैक पर धकेलता है। किले में स्थिरांक भी हैं, वे इस तरह से बनाए गए हैं:

 <> constant < >

स्थिरांक बनाने के बाद, शब्द का निष्पादन <स्थिर नाम> स्टैक पर स्थान <मूल्य>।

तो, शब्द चर और स्थिरांक दोनों शब्द जनरेटर शब्द हैं। वे नए शब्द बनाने के लिए डिज़ाइन किए गए हैं। एक किले में, इस तरह के शब्दों का निर्माण ... का उपयोग करते हुए किया जाता है।

चर और स्थिरांक निम्नानुसार परिभाषित किए जा सकते हैं:

 : variable create 0 , does> ; : constant create , does> @ ;

इस सबका क्या मतलब है?

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

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

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

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

एक बार फिर मैं तैयार करूंगा कि क्या किया जाना चाहिए:

स्टैक पर डेटा पता डालें
> के बाद कोड के एक टुकड़े पर कूदो

यह पता चला है, आपको बस एक अन्य बायोटेक पते पर नियंत्रण स्थानांतरित करने की आवश्यकता है, लेकिन पहले स्टैक पर अगले बाइट (आर 8) का पता डालें।

यह लगभग एक शाखा कमांड है! और यहाँ वह अकेली नहीं है। पहले से ही शाखा 8 और शाखा 16 हैं। हम नए var8 और var16 कमांड को नाम देंगे, और इन्हें शाखा कमांड के लिए केवल एंट्री पॉइंट होने दें। हम संक्रमण टीम को संक्रमण से बचाते हैं :) तो, यह इस तरह होगा:

 b_var8 = 0x29 bcmd_var8: push r8 b_branch8 = 0x10 bcmd_branch8: movsx rax, byte ptr [r8] add r8, rax jmp _next b_var16 = 0x30 bcmd_var16: push r8 b_branch16 = 0x11 bcmd_branch16: movsx rax, word ptr [r8] add r8, rax jmp _next

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

शब्दों के साथ-जनरेटर छांटे गए। शब्दकोश पर फैसला करने की बारी थी।

शब्दकोश

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

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

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

इस निर्माण का उपयोग करके नए शब्दकोश बनाए गए हैं:

 vocabulary <  >

यह नाम के साथ एक शब्द बनाता है <बनाया शब्दकोश नाम>। निष्पादित होने पर, यह शब्द बनाए गए शब्दकोश को खोज के लिए शुरुआती शब्दकोष के रूप में सेट करेगा।

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

बाद में शब्द शब्दावली बनाना संभव होगा, जो किले पर, वर्तमान कार्यान्वयन में, काफी सरल रूप से वर्णित है:

 : vocabulary create context @ , does> context ! ;

तो, आगे शब्द बनाएँ। हम var8 कमांड का उपयोग करेंगे। बाइटकोड "संदर्भ!" डेटा फ़ील्ड के ठीक बाद रखें:

 forth: .byte b_var8 .byte does_voc - . - 1 .quad 0 # <--      .      ,    -    . does_voc: .byte b_call8 .byte context - . - 1 .byte b_set .byte b_exit

अब वापस शब्दकोश बनाने के लिए।

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

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

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

संचार क्षेत्र के लिए कितना आवश्यक है? शुरुआत में, मैं 16 बिट्स का उपयोग करना चाहता था। यह पिछले शब्द की एक कड़ी है, और यह शब्द निश्चित रूप से 64 केबी से कम है। लेकिन फिर मुझे याद आया कि इस शब्द में लगभग किसी भी आकार का डेटा हो सकता है। और इसके अलावा, कई शब्दकोशों की उपस्थिति में, लिंक कई शब्दों से गुजर सकता है। यह पता चला है कि ज्यादातर मामलों में, 8 बिट्स पर्याप्त हैं, लेकिन 16 और 32 हो सकते हैं। और 64 बिट्स भी, अगर 4 जीबी से अधिक डेटा है। खैर, चलो सभी विकल्पों के लिए समर्थन करते हैं। कौन सा विकल्प उपयोग किया जाता है - झंडे में डाल दिया। यह कम से कम 4 झंडे निकलता है: तात्कालिक विशेषता, कोर शब्द विशेषता और उपयोग किए गए संचार क्षेत्र के 2 बिट प्रति संस्करण। झंडे के लिए एक अलग बाइट का उपयोग करना आवश्यक है, किसी अन्य तरीके से नहीं।

हम झंडे को इस प्रकार परिभाषित करते हैं:

 f_code = 0x80 f_immediate = 0x60

F_code ध्वज असेंबलर में लिखे गए कर्नेल शब्दों के लिए होगा, f_immediate ध्वज संकलक के लिए उपयोगी होगा, इसके बारे में अगले लेख में। और दो कम से कम महत्वपूर्ण बिट्स संचार क्षेत्र (1, 2, 4 या 8 बाइट्स) की लंबाई निर्धारित करेंगे।

तो, लेख का शीर्षक इस प्रकार होगा:

झंडे (1 बाइट)
संचार क्षेत्र (1-8 बाइट्स)
नाम लंबाई बाइट
नाम (1-255 बाइट्स)

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

 .macro item name, flags = 0 link = . - p_item 9: .if link >= -256/2 && link < 256/2 .byte \flags .byte link .elseif link >= -256*256/2 && link < 256*256/2 .byte \flags | 1 .word . - p_item .elseif link >= -256*256*256*256/2 && link < 256*256*256*256/2 .byte \flags | 2 .int . - p_item .elseif link >= -256*256*256*256*256*256*256*256/2 && link < 256*256*256*256*256*256*256*256/2 .byte \flags | 3 .quad . - p_item .endif p_item = 9b .byte 9f - . - 1 .ascii "\name" 9: .endm

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

पहले शब्द p_item से पहले परिभाषित करें:

 p_item = .

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

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

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

  .byte branch8 .byte 0f - . 0: .byte b_exit

ऐसी कॉल के साथ कुछ ओवरहेड होंगे, लेकिन दुभाषिया के लिए वे महत्वपूर्ण नहीं होंगे। और कंपाइलर झंडे का विश्लेषण करेगा, और सही और तेज कोड संकलित करेगा।

पहला शब्द, निश्चित रूप से, "आगे" शब्द होगा - मूल शब्दावली जो हम बना रहे हैं। यहाँ, कोड के लिंक के साथ काम वर्जन कमांड में आता है>। मैंने पहले ही इस कोड को पिछले भाग में उद्धृत कर दिया था, लेकिन मैं इसे फिर से दोहराऊंगा, शीर्षक के साथ:

 p_item = . item forth .byte b_var8 .byte does_voc - . - 1 .quad 0 does_voc: .byte b_call8 .byte context - . - 1 .byte b_set .byte b_exit

और हम तुरंत संदर्भ चर बना लेंगे और, हमें उन्हें शब्दों की खोज करने की आवश्यकता है:

  item .byte b_var0 .quad 0 item context context: .byte b_var0 .quad 0

और अब, आपको धैर्य रखने और प्रत्येक शब्द के लिए एक शीर्षक लिखने की ज़रूरत है जो हमने कोड में f_code ध्वज के साथ लिखा था:

  item 0, f_code .byte b_num0 .byte b_exit item 1, f_code .byte b_num1 .byte b_exit ... item 1-, f_code .byte b_wm .byte b_exit item 1+, f_code .byte b_wp .byte b_exit item +, f_code .byte b_add .byte b_exit item -, f_code .byte b_sub .byte b_exit item *, f_code .byte b_mul .byte b_exit

और इसी तरह…

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

  item hold hold: .byte b_call8 .byte holdpoint - . - 1 # holdpoint ...

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

  item lit8, f_code .byte b_lit8 .byte 31 .byte b_exit item lit16, f_code .byte b_lit16 .word 31415 .byte b_exit item lit32, f_code .byte b_lit32 .int 31415926 .byte b_exit item lit64, f_code .byte b_lit64 .quad 31415926535 .byte b_exit

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

 last_item: .byte b_var0 item bye, f_code .byte b_bye

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

 forth last_item context @ !

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

इनपुट बफर और शब्द निष्कर्षण

सच कहूं तो, मैं किले के मानकों का अध्ययन करने में बहुत समय बिताना नहीं चाहता हूं। लेकिन फिर भी मैं इसे मुख्य रूप से स्मृति से जितना संभव हो उतना करीब बनाने की कोशिश करूंगा। यदि किले के विशेषज्ञ यहां एक मजबूत विसंगति देखेंगे - लिखेंगे, तो मैं इसे ठीक कर दूंगा।

किले में बफर के साथ काम करने के लिए तीन चर हैं: tib, #tib और> in। टिब चर स्टैक पर इनपुट बफर के पते को धक्का देता है। चर #tib उन वर्णों की संख्या को धक्का देता है जो स्टैक पर बफर में हैं। और चर> इनपुट बफर में ऑफसेट शामिल है, जिसके आगे कच्चा पाठ स्थित है। इन चरों को परिभाषित कीजिए।

  item tib .byte b_var0 v_tib: .quad 0 item #tib .byte b_var0 v_ntib: .quad 0 item >in .byte b_var0 v_in: .quad 0

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

 b_blword = 0xF0 bcmd_blword: mov rsi, v_tib #    mov rdx, rsi #   RDX       mov rax, v_in #     mov rcx, v_ntib #    add rsi, rax #  RSI -      sub rcx, rax #     jz 3f word2: lodsb #   AL  RSI   cmp al, ' ' ja 1f #    (    ) dec rcx jnz word2 #    3: sub rsi, rdx mov v_in, rsi push rcx jmp _next 1: lea rdi, [rsi - 1] # RDI = RSI - 1 ( ) dec rcx word3: lodsb cmp al, ' ' jbe 2f dec rcx jnz word3 2: mov rax, rsi sub rsi, rdx #        (   ) mov v_in, rsi sub rax, rdi dec rax jz word1 push rdi #   word1: push rax #   jmp _next

यह शब्द मानक शब्द के समान है, लेकिन, इसके विपरीत, सभी सीमांकक को ध्यान में रखता है और शब्द को बफर में कॉपी नहीं करता है। यह स्टैक पर केवल दो मान देता है - पता और लंबाई। यदि शब्द को पुनः प्राप्त नहीं किया जा सकता है, तो रिटर्न 0. दुभाषिया लिखना शुरू करने का समय आ गया है।

शब्द खोज और दुभाषिया

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

 # : interpret begin blword dup while type repeat drop ; item interpret 1: .byte b_blword .byte b_dup .byte b_qnbranch8 .byte 0f - . .byte b_type .byte b_branch8 .byte 1b - . 0: .byte b_drop .byte b_exit

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

 b_quit = 0xF1 bcmd_quit: lea r8, quit mov sp, init_stack mov bp, init_rstack jmp _next

दूसरा भाग:

 quit: .byte b_call16 .word interpret - . - 2 .byte b_bye

हमेशा की तरह, कोडांतरक कोड .text अनुभाग में स्थित है, बाइट कोड .data अनुभाग में है।

और अंत में, शुरुआती बायोटेक को बदल दें। केवल डिक्शनरी का इनिशियलाइज़ेशन होगा, स्टार्ट लाइन पर बफ़र सेट करना और कॉलिंग छोड़ना।

 # forth last_item context @ ! start_code tib ! <  > #tib ! 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_call8 .byte start_code - . - 1 .byte b_call16 .word tib - . - 2 .byte b_set .byte b_lit16 .world 1f - 0f .byte b_call16 .word ntib - . - 2 .byte b_set .byte b_quit start_code: .byte b_var0 0: .ascii "word1 word2 word3" 1:

संकलन, लिंक, भागो!

 $ as forth.s -o forth.o -g -ahlsm >list.txt $ ld forth.o -o forth $ ./forth word1word2wordBye!

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

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

 $ ./forth word1word2word3forth)%60Acurrent(context(%600lit8lit16zlit32v%5E%DF%80lit64v%5E%DF%80call8call16call32branch8branch16qbranch8qbranch16exit1-+!-%22*#/$mod%25/mod&abs'dup0drop1swap2rot3-rot4over5pick6roll7depth8@@!Ac@Bc!Cw@Dw!Ei@Fi!G0=P0%3CQ0%3ER=S%3CT%3EU%3C=V%3E=Wvar8)var160base(holdbuf(Qholdpoint(hold@0U110ACp@&20T0!?!%3CgF!A0@RF!5%220'%DE%A61Q-%DD%80:tib(%7F%60(%3Ein(%20%20%20%20%20%20%20interpret01('byeSegmentation%20fault%20(core%20dumped)

ऐसा लगता है कि हमारा संपूर्ण द्विआधारी शब्दकोश डेलिमिटर में टेक्स्ट कट के साथ है :) यह तब हुआ जब मैं b_blword कमांड में word3 से पहले "dec rx" भूल गया।

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

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

लेख के पते पर cfa शब्द निष्पादन योग्य बायटेकोड के पते की गणना करेगा।

और शब्द execute bytecode निष्पादित करेगा।

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

 b_find = 0xF2 bcmd_find: pop rbx #   pop r9 #   mov rdx, v_context mov rdx, [rdx] #        #   find0: mov al, [rdx] #  and al, 3 #   -     ,     ,    or al, al jz find_l8 cmp al, 1 jz find_l16 cmp al, 2 jz find_l32 mov r10, [rdx + 1] #  64  lea rsi, [rdx + 9] #   jmp find1 find_l32: movsx r10, dword ptr [rdx + 1] #  32  lea rsi, [rdx + 5] #   jmp find1 find_l16: movsx r10, word ptr [rdx + 1] #  16  lea rsi, [rdx + 3] #   jmp find1 find_l8: movsx r10, byte ptr [rdx + 1] #  8  lea rsi, [rdx + 2] #   find1: movzx rax, byte ptr [rsi] #       cmp rax, rbx jz find2 #      find3: or r10, r10 jz find_notfound #  ,    add rdx, r10 #     jmp find0 #  ,   find2: inc rsi mov rdi, r9 mov rcx, rax repz cmpsb jnz find3 #   push rdx jmp _next find_notfound: push r10 jmp _next

शायद आज के लिए यह सबसे कठिन शब्द है। अब हम शब्द व्याख्या को संशोधित करते हैं, "खोज" के साथ टाइप करें।

 # : interpret begin blword dup while find . repeat drop ; item interpret interpret: .byte b_blword .byte b_dup .byte b_qnbranch8 .byte 0f - . .byte b_find .byte b_call16 .word dot - . - 2 .byte b_branch8 .byte interpret - . 0: .byte b_drop .byte b_exit

परीक्षण पंक्ति में, आपको उन शब्दों को शब्दकोष में रखने की आवश्यकता है, उदाहरण के लिए, "0 1- दुपहिया +"।

सब कुछ लॉन्च करने के लिए तैयार है!

 $ ld forth.o -o forth $ ./forth 6297733 6297898 6298375 Bye!

बढ़िया, खोज काम करती है। ये शब्दों के पते (दशमलव में) हैं। अब cfa शब्द। इसे असेंबलर में भी रहने दें, यह बहुत सरल है, झंडे के साथ काम करना समान है:

 b_cfa = 0xF3 bcmd_cfa: pop rdx #    mov al, [rdx] #  and al, 3 #   -     ,     ,    or al, al jz cfa_l8 cmp al, 1 jz cfa_l16 cmp al, 2 jz cfa_l32 lea rsi, [rdx + 9] #   (64  ) jmp cfa1 find_l32: lea rsi, [rdx + 5] #   (32  ) jmp cfa1 find_l16: lea rsi, [rdx + 3] #   (16  ) jmp cfa1 find_l8: lea rsi, [rdx + 2] #   (8  ) xor rax, rax lodsb add rsi, rax push rsi jmp _next

और अंत में, शब्द निष्पादित, यह और भी सरल है:

 b_execute = 0xF4 bcmd_execute: sub rbp, 8 mov [rbp], r8 #       pop r8 #  - jmp _next

शब्द की व्याख्या को ठीक करें और चलाएं!

 # : interpret begin blword dup while find cfa execute repeat drop ; item interpret interpret: .byte b_blword .byte b_dup .byte b_qnbranch8 .byte 0f - . .byte b_find .byte b_cfa .byte b_execute .byte b_branch8 .byte interpret - . 0: .byte b_drop .byte b_exit

चल रहा है:

 $ as forth.s -o forth.o -g -ahlsm >list.txt $ ld forth.o -o forth $ ./forth -2 Bye!

उर्रा, अर्जित! ~~(सी) कैट मैट्रोसकिन~~

वास्तव में, यदि आप 0 से 1 घटाते हैं और परिणाम को अपने आप से जोड़ते हैं, तो यह -2 होगा :)
यह बहुत अच्छा है, लेकिन मैं अभी भी कीबोर्ड से कमांड टाइप करना चाहता हूं। और, एक और समस्या है - हमारा दुभाषिया केवल संख्या 0, 1, 2, 3, 4 और 8 (जो कि स्थिरांक के रूप में परिभाषित किया गया है) को समझता है। वह किसी भी संख्या को समझने के लिए क्या सीखेगा, आपको शब्द "संख्या" की आवश्यकता है। शब्द खोजने के लिए उसी तरह, मैं बफर का उपयोग नहीं करूंगा। शब्द "संख्या?" स्टैक पर दो पैरामीटर लेंगे - स्ट्रिंग और लंबाई का पता। सफल होने पर, यह प्राप्त संख्या और ध्वज को वापस कर देगा। 1. यदि रूपांतरण असफल है, तो स्टैक पर एक संख्या होगी: 0.

कोड लंबे समय तक निकला, लेकिन सरल और रैखिक:

 b_number = 0xF5 bcmd_number: pop rcx #   pop rsi #  xor rax, rax #   xor rbx, rbx #     mov r9, v_base #  xor r10, r10 #   or rcx, rcx jz num_false mov bl, [rsi] cmp bl, '+' jnz 1f inc rsi dec rcx jz num_false jmp num0 1: cmp bl, '-' jnz num0 mov r10, 1 inc rsi dec rcx jz num_false num0: mov bl, [rsi] cmp bl, '0' ja num_false cmp bl, '9' jae num_09 cmp bl, 'A' ja num_false cmp bl, 'Z' jae num_AZ cmp bl, 'a' ja num_false sub bl, 'a' - 10 jmp num_check num_AZ: sub bl, 'A' - 10 jmp num_check num_09: sub bl, '0' num_check: cmp rbx, r9 jge num_false add rax, rbx mul r9 inc rsi dec rcx jnz num0 or r10, r10 push rax push 1 jmp _next num_false: xor rcx, rcx push rcx jmp _next

interpret. , :

 # : interpret # begin # blword dup # while # over over find dup # if -rot drop drop cfa execute else number? drop then # repeat # drop ; 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 .byte b_cfa .byte b_execute .byte b_branch8 .byte 2f - . 1: .byte b_numberq .byte b_drop 2: .byte b_branch8 .byte interpret - . 0: .byte b_drop .byte b_exit last_item: .byte b_var0 item bye, f_code .byte b_bye

! - , -, «» -… , … GDB, … — ! , . !

… , :)

, : — «s.». , interpret. , , . :

 # : .s depth dup . c": emit do dup while dup pick . 1- again drop ; item .s # 11 22 33 prstack: .byte b_depth # 11 22 33 3 .byte b_dup # 11 22 33 3 3 .byte b_lit8 .byte '(' .byte b_emit .byte b_call16 # 11 22 33 3 .word dot - . - 2 .byte b_strp # 11 22 33 3 .byte 3 .ascii "): " 1: .byte b_dup # 11 22 33 3 3 .byte b_qnbranch8 # 11 22 33 3 .byte 2f - . .byte b_dup # 11 22 33 3 3 .byte b_pick # 11 22 33 3 11 .byte b_call16 # 11 22 33 3 .word dot - . - 2 .byte b_wm # 11 22 33 2 .byte b_branch8 .byte 1b - . 2: .byte b_drop # 11 22 33 .byte b_exit

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

डीबगिंग के लिए, मैंने निम्न मैक्रोज़ बनाए:

 .macro prs new_line = 1 .byte b_call16 .word prstack - . - 2 .if \new_line > 0 .byte b_lit8, '\n' .byte b_emit .endif .endm

इस तरह से सही स्थानों पर डालने से उपयोग किया जाता है:

  item interpret interpret: .byte b_blword prs .byte b_dup prs .byte b_qnbranch8 .byte 0f - . .byte b_over .byte b_over ......

परिणामस्वरूप, पहले लॉन्च ने निम्न आउटपुट का उत्पादन किया:

 $ ./forth (2 ): 6297664 1 (3 ): 6297664 1 1 (3 ): 2 6297666 1 (4 ): 2 6297666 1 1 (4 ): 2 3 6297668 1 (5 ): 2 3 6297668 1 1 (3 ): 6 6297670 2 (4 ): 6 6297670 2 2 (4 ): 6 6297670 6297673 1 (5 ): 6 6297670 6297673 1 1 6297670 (2 ): 6 0 (3 ): 6 0 0 Bye!

स्टैक पर प्रत्येक आंदोलन को स्पष्ट रूप से देखा जा सकता है। पहले ऐसा करना आवश्यक था :)

मैं एक और डीबग मैक्रो बनाकर आगे बढ़ गया:

 .macro pr string .byte b_strp .byte 9f - 8f 8: .ascii "\n\string" 9: .endm

परिणामस्वरूप, ऐसा करना संभव हो गया:

  item interpret interpret: .byte b_blword pr blworld prs .byte b_dup .byte b_qnbranch8 .byte 0f - . .byte b_over .byte b_over prs .byte b_find pr find prs .byte b_dup .byte b_qnbranch8 .byte 1f - . .byte b_mrot .byte b_drop .byte b_drop .byte b_cfa pr execute prs .byte b_execute .byte b_branch8 .byte 2f - . 1: .byte b_numberq pr numberq prs .byte b_drop 2: .byte b_branch8 .byte interpret - . 0: .byte b_drop .byte b_exit

और इसे प्राप्त करें:

 $ ./forth blworld(2 ): 6297664 2 (4 ): 6297664 2 6297664 2 find(3 ): 6297664 2 0 numberq(2 ): 6297664 0 blworld(3 ): 6297664 6297667 2 (5 ): 6297664 6297667 2 6297667 2 find(4 ): 6297664 6297667 2 0 numberq(3 ): 6297664 6297667 0 blworld(4 ): 6297664 6297667 6297670 1 (6 ): 6297664 6297667 6297670 1 6297670 1 find(5 ): 6297664 6297667 6297670 1 6297958 execute(3 ): 6297664 6297667 6297962 blworld(3 ): 39660590749888 6297672 1 (5 ): 39660590749888 6297672 1 6297672 1 find(4 ): 39660590749888 6297672 1 6298496 execute(2 ): 39660590749888 6298500 39660590749888 blworld(1 ): 0 Bye!

यह "20 30 *" स्ट्रिंग की व्याख्या करने का एक प्रयास था।

और आप स्रोत लाइन संख्याएँ प्रदर्शित कर सकते हैं ... ठीक है, शायद तब ...

बेशक, यह डिबगिंग के लिए एक क्लासिक लॉगिंग तकनीक है, लेकिन कुछ ऐसा है जिसके बारे में मुझे तुरंत याद नहीं है।

सामान्य तौर पर, डिबगिंग के परिणामस्वरूप, मुझे एक स्टैक मिला जो विदेश जा रहा था। यह ओवरफ्लो का विपरीत है जब वे जितना डालते हैं उससे अधिक लेने की कोशिश करते हैं। उसका नियंत्रण ".s" में जोड़ा गया।
नए मैक्रोज़ की मदद से डिबगिंग तेज थी। वैसे, इससे पहले मैंने प्रति पंक्ति एक बायोटेक पोस्ट किया था। लेकिन कोडांतरक आपको एक स्ट्रिंग में कई बाइट्स रखने की अनुमति देता है, इसका उपयोग क्यों नहीं करें।

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

  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 .byte b_cfa .byte b_execute .byte b_branch8 .byte 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) 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

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

कीबोर्ड इनपुट को व्यवस्थित करने के लिए केवल एक चीज बची है।

कीबोर्ड इनपुट

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

 .data item span span: .byte b_var0 v_span: .quad 0 .text b_expect = 0x88 bcmd_expect: mov rax, 0 #   № 1 - sys_read mov rdi, 0 #  № 1 - stdout pop rdx #   pop rsi #   push r8 syscall #   pop r8 mov rbx, rax or rax, rax jge 1f xor rbx, rbx 1: mov v_span, rbx jmp _next

अब हमें एक कीबोर्ड इनपुट बफर बनाने की आवश्यकता है। इसे 256 वर्ण लंबा होने दें।
चलो इसे पिछले परीक्षण लाइन के स्थान पर बनाते हैं।

 inbuf_size = 256 inbuf: .byte b_var0 .space inbuf_size

और हम छोड़ दिया संशोधित करते हैं, साथ ही शुरुआती बायोटेक। टिब वैरिएबल को thebuf इनपुट बफर में सेट करें, कॉल की उम्मीद करें, फिर मान को #tib से फैलाएं। चर में nullified है; हम व्याख्या कहते हैं। और इसलिए हम एक चक्र में दोहराते हैं। Baubles हैं - एक इनपुट प्रॉम्प्ट जोड़ें और स्टैक की स्थिति प्रदर्शित करना अच्छा होगा (और हमारे पास इसके लिए पहले से तैयार कमांड है!)। कई पुनरावृत्तियों के बाद, हमें निम्न कोड मिला (कमांड शुरू और छोड़ें):

 # forth last_item context @ ! 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_quit inbuf: .byte b_var0 .space inbuf_size # begin inbuf dup tib ! inbuf_size expect span @ #tib ! 0 >in ! interpret again quit: .byte b_strp, 1 .ascii "\n" .byte b_call16 .word prstack - . - 2 .byte b_strp .byte 2 .ascii "> " .byte b_call16 .word inbuf - . - 2 .byte b_dup .byte b_call16 .word tib - . - 2 .byte b_set .byte b_lit16 .word inbuf_size .byte b_expect .byte b_call16 .word span - . - 2 .byte b_get .byte b_call16 .word ntib - . - 2 .byte b_set .byte b_num0 .byte b_call16 .word bin - . - 2 .byte b_set .byte b_call16 .word interpret - . - 2 .byte b_branch8, quit - .

और यहाँ परिणाम है:

 $ ./forth ( 0 ): > 60 ( 1 ): 60 > 60 24 ( 3 ): 60 60 24 > rot ( 3 ): 60 24 60 > -rot ( 3 ): 60 60 24 > swap ( 3 ): 60 24 60 > * * . 86400 ( 0 ): > 200 30 /mod ( 2 ): 20 6 > bye Bye! $

">" प्रतीक के बाद सब कुछ मेरा कीबोर्ड इनपुट है। बाकी व्यवस्था का जवाब है। मैंने कीबोर्ड से टाइप करते हुए कमांड्स के साथ थोड़ा खेला। उन्होंने कई स्टैक ऑपरेशन किए, दिनों में सेकंड की संख्या की गणना की।

परिणाम

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

पूर्ण स्रोत (लगभग 1300 लाइनें)

 .intel_syntax noprefix stack_size = 1024 f_code = 0x80 f_immediate = 0x60 .macro item name, flags = 0 link = p_item - . 9: .if link >= -256/2 && link < 256/2 .byte \flags .byte link .elseif link >= -256*256/2 && link < 256*256/2 .byte \flags | 1 .word link .elseif link >= -256*256*256*256/2 && link < 256*256*256*256/2 .byte \flags | 2 .int link .elseif link >= -256*256*256*256*256*256*256*256/2 && link < 256*256*256*256*256*256*256*256/2 .byte \flags | 3 .quad link .endif p_item = 9b .byte 9f - . - 1 .ascii "\name" 9: .endm .section .data init_stack: .quad 0 init_rstack: .quad 0 emit_buf: .byte 0 inbuf_size = 256 msg_bad_byte: .ascii "Bad byte code!\n" msg_bad_byte_len = . - msg_bad_byte #  len    msg_bye: .ascii "\nBye!\n" msg_bye_len = . - msg_bye bcmd: .quad bcmd_bad, bcmd_bye, bcmd_num0, bcmd_num1, bcmd_num2, bcmd_num3, bcmd_num4, bcmd_num8 # 0x00 .quad bcmd_lit8, bcmd_lit16, bcmd_lit32, bcmd_lit64, bcmd_call8, bcmd_call16, bcmd_call32, bcmd_bad .quad bcmd_branch8, bcmd_branch16, bcmd_qbranch8, bcmd_qbranch16, bcmd_qnbranch8, bcmd_qnbranch16,bcmd_bad, bcmd_exit # 0x10 .quad bcmd_wp, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_wm, bcmd_add, bcmd_sub, bcmd_mul, bcmd_div, bcmd_mod, bcmd_divmod, bcmd_abs # 0x20 .quad bcmd_var0, bcmd_var8, bcmd_var16, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_dup, bcmd_drop, bcmd_swap, bcmd_rot, bcmd_mrot, bcmd_over, bcmd_pick, bcmd_roll # 0x30 .quad bcmd_depth, bcmd_nip, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_get, bcmd_set, bcmd_get8, bcmd_set8, bcmd_get16, bcmd_set16, bcmd_get32, bcmd_set32 # 0x40 .quad bcmd_setp, bcmd_setm, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_zeq, bcmd_zlt, bcmd_zgt, bcmd_eq, bcmd_lt, bcmd_gt, bcmd_lteq, bcmd_gteq # 0x50 .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_2r, bcmd_r2, bcmd_rget, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad # 0x60 .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_type, bcmd_emit, bcmd_str, bcmd_strp, bcmd_count, bcmd_bad, bcmd_bad, bcmd_bad # 0x80 .quad bcmd_expect, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad # 0x90 .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad .quad bcmd_blword, bcmd_quit, bcmd_find, bcmd_cfa, bcmd_execute, bcmd_numberq, bcmd_bad, bcmd_bad # 0xF0 .quad bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad, bcmd_bad # forth last_item context @ ! 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_quit inbuf: .byte b_var0 .space inbuf_size # begin inbuf dup tib ! inbuf_size expect span @ #tib ! 0 >in ! interpret again quit: .byte b_strp, 1 .ascii "\n" .byte b_call16 .word prstack - . - 2 .byte b_strp .byte 2 .ascii "> " .byte b_call16 .word inbuf - . - 2 .byte b_dup .byte b_call16 .word tib - . - 2 .byte b_set .byte b_lit16 .word inbuf_size .byte b_expect .byte b_call16 .word span - . - 2 .byte b_get .byte b_call16 .word ntib - . - 2 .byte b_set .byte b_num0 .byte b_call16 .word bin - . - 2 .byte b_set .byte b_call16 .word interpret - . - 2 .byte b_branch8, quit - . p_item = . item forth forth: .byte b_var8 .byte does_voc - . .quad 0 does_voc: .byte b_call8 .byte context - . - 1 .byte b_set .byte b_exit item current .byte b_var0 .quad 0 item context context: .byte b_var0 v_context: .quad 0 item 0, f_code .byte b_num0 .byte b_exit item 1, f_code .byte b_num1 .byte b_exit item 2, f_code .byte b_num2 .byte b_exit item 3, f_code .byte b_num3 .byte b_exit item 4, f_code .byte b_num4 .byte b_exit item 8, f_code .byte b_num8 .byte b_exit item lit8, f_code .byte b_lit8 .byte 31 .byte b_exit item lit16, f_code .byte b_lit16 .word 31415 .byte b_exit item lit32, f_code .byte b_lit32 .int 31415926 .byte b_exit item lit64, f_code .byte b_lit64 .quad 31415926 .byte b_exit item call8, f_code .byte b_call8 .byte 0f - . - 1 0: .byte b_exit item call16, f_code .byte b_call16 .word 0f - . - 2 0: .byte b_exit item call32, f_code .byte b_call32 .int 0f - . - 4 0: .byte b_exit item branch8, f_code .byte b_branch8 .byte 0f - . 0: .byte b_exit item branch16, f_code .byte b_branch16 .word 0f - . 0: .byte b_exit item qbranch8, f_code .byte b_qbranch8 .byte 0f - . 0: .byte b_exit item qbranch16, f_code .byte b_qbranch16 .word 0f - . 0: .byte b_exit item exit, f_code .byte b_exit item 1-, f_code .byte b_wm .byte b_exit item 1+, f_code .byte b_wp .byte b_exit item +, f_code .byte b_add .byte b_exit item -, f_code .byte b_sub .byte b_exit item *, f_code .byte b_mul .byte b_exit item /, f_code .byte b_div .byte b_exit item mod, f_code .byte b_mod .byte b_exit item /mod, f_code .byte b_divmod .byte b_exit item abs, f_code .byte b_abs .byte b_exit item dup, f_code .byte b_dup .byte b_exit item drop, f_code .byte b_drop .byte b_exit item swap, f_code .byte b_swap .byte b_exit item rot, f_code .byte b_rot .byte b_exit item -rot, f_code .byte b_mrot .byte b_exit item over, f_code .byte b_over .byte b_exit item pick, f_code .byte b_pick .byte b_exit item roll, f_code .byte b_roll .byte b_exit item depth, f_code .byte b_depth .byte b_exit item @, f_code .byte b_get .byte b_exit item !, f_code .byte b_set .byte b_exit item c@, f_code .byte b_get8 .byte b_exit item c!, f_code .byte b_set8 .byte b_exit item w@, f_code .byte b_get16 .byte b_exit item w!, f_code .byte b_set16 .byte b_exit item i@, f_code .byte b_get32 .byte b_exit item i!, f_code .byte b_set32 .byte b_exit item +!, f_code .byte b_setp .byte b_exit item -!, f_code .byte b_setm .byte b_exit item >r, f_code .byte b_2r .byte b_exit item r>, f_code .byte b_r2 .byte b_exit item r@, f_code .byte b_rget .byte b_exit item "0=", f_code .byte b_zeq .byte b_exit item 0<, f_code .byte b_zlt .byte b_exit item 0>, f_code .byte b_zgt .byte b_exit item "=", f_code .byte b_eq .byte b_exit item <, f_code .byte b_lt .byte b_exit item >, f_code .byte b_gt .byte b_exit item "<=", f_code .byte b_lteq .byte b_exit item ">=", f_code .byte b_gteq .byte b_exit item type, f_code .byte b_type .byte b_exit item expect, f_code .byte b_expect .byte b_exit item emit, f_code .byte b_emit .byte b_exit item count, f_code .byte b_count .byte b_exit item "(\")", f_code .byte b_str .byte b_exit item "(.\")", f_code .byte b_strp .byte b_exit item var8, f_code .byte b_var8 .byte 0f - . 0: .byte b_exit item var16, f_code .byte b_var16 .word 0f - . 0: .byte b_exit item base base: .byte b_var0 v_base: .quad 10 holdbuf_len = 70 item holdbuf holdbuf: .byte b_var0 .space holdbuf_len item holdpoint holdpoint: .byte b_var0 .quad 0 item span span: .byte b_var0 v_span: .quad 0 # : hold holdpoint @ 1- dup holdbuf > if drop drop else dup holdpoint ! c! then ; item hold hold: .byte b_call8 .byte holdpoint - . - 1 # holdpoint .byte b_get # @ .byte b_wm # 1- .byte b_dup # dup .byte b_call8 .byte holdbuf - . - 1 # holdbuf .byte b_gt # > .byte b_qbranch8 # if .byte 0f - . .byte b_drop # drop .byte b_drop # drop .byte b_branch8 #     ( then) .byte 1f - . 0: .byte b_dup # dup .byte b_call8 .byte holdpoint - . - 1 # holdpoint .byte b_set # ! .byte b_set8 # c! 1: .byte b_exit # ; # : # base /mod swap dup 10 < if c" 0 + else 10 - c" A + then hold ; item # conv: .byte b_call16 .word base - . - 2 # base .byte b_get # @ .byte b_divmod # /mod .byte b_swap # swap .byte b_dup # dup .byte b_lit8 .byte 10 # 10 .byte b_lt # < .byte b_qnbranch8 # if .byte 0f - . .byte b_lit8 .byte '0' # c" 0 .byte b_add # + .byte b_branch8 # else .byte 1f - . 0: .byte b_lit8 .byte '?' # c" A .byte b_add # + 1: .byte b_call16 .word hold - . - 2 # hold .byte b_exit # ; # : <# holdbuf 70 + holdpoint ! ; item <# conv_start: .byte b_call16 .word holdbuf - . - 2 .byte b_lit8 .byte holdbuf_len .byte b_add .byte b_call16 .word holdpoint - . - 2 .byte b_set .byte b_exit # : #s do # dup 0=until ; item #s conv_s: .byte b_call8 .byte conv - . - 1 .byte b_dup .byte b_qbranch8 .byte conv_s - . .byte b_exit # : #> holdpoint @ holdbuf 70 + over - ; item #> conv_end: .byte b_call16 .word holdpoint - . - 2 .byte b_get .byte b_call16 .word holdbuf - . - 2 .byte b_lit8 .byte holdbuf_len .byte b_add .byte b_over .byte b_sub .byte b_exit item . dot: .byte b_dup .byte b_abs .byte b_call8 .byte conv_start - . - 1 .byte b_lit8 .byte ' ' .byte b_call16 .word hold - . - 2 .byte b_call8 .byte conv_s - . - 1 .byte b_drop .byte b_zlt .byte b_qnbranch8 .byte 1f - . .byte b_lit8 .byte '-' .byte b_call16 .word hold - . - 2 1: .byte b_call8 .byte conv_end - . - 1 .byte b_type .byte b_exit item tib tib: .byte b_var0 v_tib: .quad 0 item #tib ntib: .byte b_var0 v_ntib: .quad 0 item >in bin: .byte b_var0 v_in: .quad 0 # : .s depth dup . c": emit do dup while dup pick . 1- again drop ; item .s # 11 22 33 prstack: .byte b_depth # 11 22 33 3 .byte b_dup # 11 22 33 3 3 .byte b_strp .byte 2 .ascii "( " .byte b_call16 # 11 22 33 3 .word dot - . - 2 .byte b_strp # 11 22 33 3 .byte 3 .ascii "): " .byte b_dup, b_zlt .byte b_qnbranch8, 1f - . .byte b_strp .byte 14 .ascii "\nStack fault!\n" .byte b_quit 1: .byte b_dup # 11 22 33 3 3 .byte b_qnbranch8 # 11 22 33 3 .byte 2f - . .byte b_dup # 11 22 33 3 3 .byte b_pick # 11 22 33 3 11 .byte b_call16 # 11 22 33 3 .word dot - . - 2 .byte b_wm # 11 22 33 2 .byte b_branch8 .byte 1b - . 2: .byte b_drop # 11 22 33 .byte b_exit .macro prs new_line = 1 .byte b_call16 .word prstack - . - 2 .if \new_line > 0 .byte b_lit8, '\n' .byte b_emit .endif .endm .macro pr string .byte b_strp .byte 9f - 8f 8: .ascii "\n\string" 9: .endm 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 .byte b_cfa .byte b_execute .byte b_branch8 .byte 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) 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 last_item: .byte b_var0 item bye, f_code .byte b_bye .section .text .global _start #     _start: mov rbp, rsp sub rbp, stack_size lea r8, start mov init_stack, rsp mov init_rstack, rbp jmp _next b_var0 = 0x28 bcmd_var0: push r8 b_exit = 0x17 bcmd_exit: mov r8, [rbp] add rbp, 8 _next: movzx rcx, byte ptr [r8] inc r8 jmp [bcmd + rcx*8] b_num0 = 0x02 bcmd_num0: push 0 jmp _next b_num1 = 0x03 bcmd_num1: push 1 jmp _next b_num2 = 0x04 bcmd_num2: push 2 jmp _next b_num3 = 0x05 bcmd_num3: push 3 jmp _next b_num4 = 0x06 bcmd_num4: push 4 jmp _next b_num8 = 0x07 bcmd_num8: push 8 jmp _next b_lit8 = 0x08 bcmd_lit8: movsx rax, byte ptr [r8] inc r8 push rax jmp _next b_lit16 = 0x09 bcmd_lit16: movsx rax, word ptr [r8] add r8, 2 push rax jmp _next b_call8 = 0x0C bcmd_call8: movsx rax, byte ptr [r8] sub rbp, 8 inc r8 mov [rbp], r8 add r8, rax jmp _next b_call16 = 0x0D bcmd_call16: movsx rax, word ptr [r8] sub rbp, 8 add r8, 2 mov [rbp], r8 add r8, rax jmp _next b_call32 = 0x0E bcmd_call32: movsx rax, dword ptr [r8] sub rbp, 8 add r8, 4 mov [rbp], r8 add r8, rax jmp _next b_lit32 = 0x0A bcmd_lit32: movsx rax, dword ptr [r8] add r8, 4 push rax jmp _next b_lit64 = 0x0B bcmd_lit64: mov rax, [r8] add r8, 8 push rax jmp _next b_dup = 0x30 bcmd_dup: push [rsp] jmp _next b_wm = 0x20 bcmd_wm: decq [rsp] jmp _next b_wp = 0x18 bcmd_wp: incq [rsp] jmp _next b_add = 0x21 bcmd_add: pop rax add [rsp], rax jmp _next b_sub = 0x22 bcmd_sub: pop rax sub [rsp], rax jmp _next b_mul = 0x23 bcmd_mul: pop rax pop rbx imul rbx push rax jmp _next b_div = 0x24 bcmd_div: pop rbx pop rax cqo idiv rbx push rax jmp _next b_mod = 0x25 bcmd_mod: pop rbx pop rax cqo idiv rbx push rdx jmp _next b_divmod = 0x26 bcmd_divmod: pop rbx pop rax cqo idiv rbx push rdx push rax jmp _next b_abs = 0x27 bcmd_abs: mov rax, [rsp] or rax, rax jge _next neg rax mov [rsp], rax jmp _next b_drop = 0x31 bcmd_drop: add rsp, 8 jmp _next b_swap = 0x32 bcmd_swap: pop rax pop rbx push rax push rbx jmp _next b_rot = 0x33 bcmd_rot: pop rax pop rbx pop rcx push rbx push rax push rcx jmp _next b_mrot = 0x34 bcmd_mrot: pop rcx pop rbx pop rax push rcx push rax push rbx jmp _next b_over = 0x35 bcmd_over: push [rsp + 8] jmp _next b_pick = 0x36 bcmd_pick: pop rcx push [rsp + 8*rcx] jmp _next b_roll = 0x37 bcmd_roll: pop rcx mov rbx, [rsp + 8*rcx] roll1: mov rax, [rsp + 8*rcx - 8] mov [rsp + 8*rcx], rax dec rcx jnz roll1 push rbx jmp _next b_depth = 0x38 bcmd_depth: mov rax, init_stack sub rax, rsp sar rax, 3 push rax jmp _next b_nip = 0x39 bcmd_nip: pop rax mov [rsp], rax jmp _next b_get = 0x40 bcmd_get: pop rcx push [rcx] jmp _next b_set = 0x41 bcmd_set: pop rcx pop rax mov [rcx], rax jmp _next b_get8 = 0x42 bcmd_get8: pop rcx movsx rax, byte ptr [rcx] push rax jmp _next b_set8 = 0x43 bcmd_set8: pop rcx pop rax mov [rcx], al jmp _next b_get16 = 0x44 bcmd_get16: pop rcx movsx rax, word ptr [rcx] push rax jmp _next b_set16 = 0x45 bcmd_set16: pop rcx pop rax mov [rcx], ax jmp _next b_get32 = 0x46 bcmd_get32: pop rcx movsx rax, dword ptr [rcx] push rax jmp _next b_set32 = 0x47 bcmd_set32: pop rcx pop rax mov [rcx], eax jmp _next b_setp = 0x48 bcmd_setp: pop rcx pop rax add [rcx], rax jmp _next b_setm = 0x49 bcmd_setm: pop rcx pop rax sub [rcx], rax jmp _next b_2r = 0x60 bcmd_2r: pop rax sub rbp, 8 mov [rbp], rax jmp _next b_r2 = 0x61 bcmd_r2: push [rbp] add rbp, 8 jmp _next b_rget = 0x62 bcmd_rget: push [rbp] jmp _next # 0= b_zeq = 0x50 bcmd_zeq: pop rax or rax, rax jnz rfalse rtrue: push -1 jmp _next rfalse: push 0 jmp _next # 0< b_zlt = 0x51 bcmd_zlt: pop rax or rax, rax jl rtrue push 0 jmp _next # 0> b_zgt = 0x52 bcmd_zgt: pop rax or rax, rax jg rtrue push 0 jmp _next # = b_eq = 0x53 bcmd_eq: pop rbx pop rax cmp rax, rbx jz rtrue push 0 jmp _next # < b_lt = 0x54 bcmd_lt: pop rbx pop rax cmp rax, rbx jl rtrue push 0 jmp _next # > b_gt = 0x55 bcmd_gt: pop rbx pop rax cmp rax, rbx jg rtrue push 0 jmp _next # <= b_lteq = 0x56 bcmd_lteq: pop rbx pop rax cmp rax, rbx jle rtrue push 0 jmp _next # >= b_gteq = 0x57 bcmd_gteq: pop rbx pop rax cmp rax, rbx jge rtrue push 0 jmp _next b_var8 = 0x29 bcmd_var8: push r8 b_branch8 = 0x10 bcmd_branch8: movsx rax, byte ptr [r8] add r8, rax jmp _next b_var16 = 0x30 bcmd_var16: push r8 b_branch16 = 0x11 bcmd_branch16: movsx rax, word ptr [r8] add r8, rax jmp _next b_qbranch8 = 0x12 bcmd_qbranch8: pop rax or rax, rax jnz bcmd_branch8 inc r8 jmp _next b_qbranch16 = 0x13 bcmd_qbranch16: pop rax or rax, rax jnz bcmd_branch16 add r8, 2 jmp _next b_qnbranch8 = 0x14 bcmd_qnbranch8: pop rax or rax, rax jz bcmd_branch8 inc r8 jmp _next b_qnbranch16 = 0x15 bcmd_qnbranch16:pop rax or rax, rax jz bcmd_branch16 add r8, 2 jmp _next b_bad = 0x00 bcmd_bad: mov rax, 1 #    1 - sys_write mov rdi, 1 #   1  stdout mov rsi, offset msg_bad_byte #     mov rdx, msg_bad_byte_len #   syscall #   mov rax, 60 #    1 - sys_exit mov rbx, 1 #    1 syscall #   b_bye = 0x01 bcmd_bye: mov rax, 1 #    1 - sys_write mov rdi, 1 #   1  stdout mov rsi, offset msg_bye #     mov rdx, msg_bye_len #   syscall #   mov rax, 60 #    60 - sys_exit mov rdi, 0 #    0 syscall #   b_strp = 0x83 bcmd_strp: movsx rax, byte ptr [r8] inc r8 push r8 add r8, rax push rax b_type = 0x80 bcmd_type: mov rax, 1 #    1 - sys_write mov rdi, 1 #   1 - stdout pop rdx #   pop rsi #   push r8 syscall #   pop r8 jmp _next b_expect = 0x88 bcmd_expect: mov rax, 0 #    1 - sys_read mov rdi, 0 #   1 - stdout pop rdx #   pop rsi #   push r8 syscall #   pop r8 mov rbx, rax or rax, rax jge 1f xor rbx, rbx 1: mov v_span, rbx jmp _next b_str = 0x82 bcmd_str: movzx rax, byte ptr [r8] lea r8, [r8 + rax + 1] jmp _next b_count = 0x84 bcmd_count: pop rcx movzx rax, byte ptr [rcx] inc rcx push rcx push rax jmp _next b_emit = 0x81 bcmd_emit: pop rax mov rsi, offset emit_buf #   mov [rsi], al mov rax, 1 #    1 - sys_write mov rdi, 1 #   1 - stdout mov rdx, 1 #   push r8 syscall #   pop r8 jmp _next b_blword = 0xF0 bcmd_blword: mov rsi, v_tib #    mov rdx, rsi #   RDX       mov rax, v_in #     mov rcx, v_ntib #    mov rbx, rcx add rsi, rax #  RSI -      sub rcx, rax #     jz 3f word2: lodsb #   AL  RSI   cmp al, ' ' ja 1f #    (    ) dec rcx jnz word2 #    3: sub rsi, rdx mov v_in, rsi push rcx jmp _next 1: lea rdi, [rsi - 1] # RDI = RSI - 1 ( ) dec rcx jz word9 word3: lodsb cmp al, ' ' jbe 2f dec rcx jnz word3 word9: inc rsi 2: mov rax, rsi sub rsi, rdx #        (   ) cmp rsi, rbx jle 4f mov rsi, rbx 4: mov v_in, rsi sub rax, rdi dec rax jz word1 push rdi #   word1: push rax #   jmp _next b_quit = 0xF1 bcmd_quit: lea r8, quit mov rsp, init_stack mov rbp, init_rstack jmp _next b_find = 0xF2 bcmd_find: pop rbx #   pop r9 #   mov rdx, v_context mov rdx, [rdx] #        #   find0: mov al, [rdx] #  and al, 3 #   -     ,     ,    or al, al jz find_l8 cmp al, 1 jz find_l16 cmp al, 2 jz find_l32 mov r10, [rdx + 1] #  64  lea rsi, [rdx + 9] #   jmp find1 find_l32: movsx r10, dword ptr [rdx + 1] #  32  lea rsi, [rdx + 5] #   jmp find1 find_l16: movsx r10, word ptr [rdx + 1] #  16  lea rsi, [rdx + 3] #   jmp find1 find_l8: movsx r10, byte ptr [rdx + 1] #  8  lea rsi, [rdx + 2] #   find1: movzx rax, byte ptr [rsi] #       cmp rax, rbx jz find2 #      find3: or r10, r10 jz find_notfound #  ,    add rdx, r10 #     jmp find0 #  ,   find2: inc rsi mov rdi, r9 mov rcx, rax repz cmpsb jnz find3 #   push rdx jmp _next find_notfound: push r10 jmp _next b_cfa = 0xF3 bcmd_cfa: pop rdx #    mov al, [rdx] #  and al, 3 #   -     ,     ,    or al, al jz cfa_l8 cmp al, 1 jz cfa_l16 cmp al, 2 jz cfa_l32 lea rsi, [rdx + 9] #   (64  ) jmp cfa1 cfa_l32: lea rsi, [rdx + 5] #   (32  ) jmp cfa1 cfa_l16: lea rsi, [rdx + 3] #   (16  ) jmp cfa1 cfa_l8: lea rsi, [rdx + 2] #   (8  ) cfa1: xor rax, rax lodsb add rsi, rax push rsi jmp _next b_execute = 0xF4 bcmd_execute: sub rbp, 8 mov [rbp], r8 #       pop r8 #  - jmp _next b_numberq = 0xF5 bcmd_numberq: pop rcx #   pop rsi #  xor rax, rax #   xor rbx, rbx #     mov r9, v_base #  xor r10, r10 #   or rcx, rcx jz num_false mov bl, [rsi] cmp bl, '+' jnz 1f inc rsi dec rcx jz num_false jmp num0 1: cmp bl, '-' jnz num0 mov r10, 1 inc rsi dec rcx jz num_false num0: mov bl, [rsi] cmp bl, '0' jb num_false cmp bl, '9' jbe num_09 cmp bl, 'A' jb num_false cmp bl, 'Z' jbe num_AZ cmp bl, 'a' jb num_false cmp bl, 'z' ja num_false sub bl, 'a' - 10 jmp num_check num_AZ: sub bl, 'A' - 10 jmp num_check num_09: sub bl, '0' num_check: cmp rbx, r9 jge num_false mul r9 add rax, rbx inc rsi dec rcx jnz num0 or r10, r10 push rax push 1 jmp _next num_false: xor rcx, rcx push rcx jmp _next

स्रोत कोड बड़ा हो रहा है, इसलिए मैं इसे आखिरी बार यहां ला रहा हूं।

अब उसका निवास स्थान गिथब पर होगा: https://github.com/hal9000cc/forth64
उसी स्थान पर, बिन फ़ोल्डर में आप लिनक्स x64 के लिए पहले से संकलित संस्करण पा सकते हैं। जिनके पास लिनक्स है, आप डाउनलोड और चला सकते हैं।

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

लेकिन असली भारतीयों के लिए यह सब विंडोज के तहत चलाने का एक तरीका भी है :) यह करना मुश्किल नहीं है, बस कुछ शब्दों को फिर से करें जो सिस्टम के साथ बातचीत करते हैं।

वह सब है! अगली बार, हम कंपाइलर को चलाएंगे।

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

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

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