लो लेवल ब्रेनफक

भाग I
भाग II
भाग III

इस लेख में, हम TurboAssembler पर एक Brainfuck संकलक लिखेंगे
यहां आप चरण-दर-चरण मोड में bf- प्रोग्राम डिबग कर सकते हैं।

सबसे पहले, हम दुभाषिया को कुछ उच्च-स्तरीय भाषा में लिखेंगे, उदाहरण के लिए, पास्कल में।

Data_arr सरणी डेटा मेमोरी का प्रतिनिधित्व करेगी, str_arr स्ट्रिंग में कमांड होंगे।

हम एक ऐसा प्रोग्राम लिखेंगे जो एक ऐसे चरित्र को प्रदर्शित करता है जिसका एससी कोड संख्या + से मेल खाता है (इसलिए हमें केवल + और कमांड की आवश्यकता है)

var data_arr:array[1..10] of integer; //   str_arr: string; //  i, j: integer; //     begin j:=1; //       readln(str_arr); //  for i:=1 to length(str_arr) do begin //     if (str_arr[i]='+') then data_arr[j]:= data_arr[j]+1; if (str_arr[i]='.') then write(chr(data_arr[j])); end; end. 

bf कोड +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ बाहर दे देंगे ! (चरित्र के ascii कोड ! 33 है)।

कार्यक्रम को ऑनलाइन ide ideone.com पर चेक किया जा सकता है

अगला, गोटो के साथ लूप के लिए बदलें और कमांड जोड़ें $$$- <>$
अंत में, हम data_arr array को आउटपुट करेंगे

 LABEL prev,next; var data_arr:array[1..10] of integer; //   str_arr: string; //  i,j,k: integer; //     begin i:=1; j:=1; readln(str_arr); //  prev: if i>length(str_arr) then goto next; if (str_arr[i]='+') then data_arr[j]:= data_arr[j]+1; if (str_arr[i]='-') then data_arr[j]:= data_arr[j]-1; if (str_arr[i]='>') then j:=j+1; if (str_arr[i]='<') then j:=j-1; if (str_arr[i]='.') then write(chr(data_arr[j])); i:=i+1; goto prev; next: for k:=1 to 10 do begin write(data_arr[k]); write(' '); end; end. 

कोड $$$+> ++> +++$1 2 3 0 0 0 0 0 0 देगा
कोड $$$+> ++> +++ -$1 2 2 0 0 0 0 0 0 दे देंगे
ideone.com

इसके बाद, [ और ] जोड़ें
एक और i_stor वैरिएबल जोड़ें।
यदि वर्तमान तत्व ने परीक्षण को [ पर उत्तीर्ण किया है, तो हम data_arr सरणी के वर्तमान तत्व को शून्य पर चेक करते हैं, और यदि तत्व शून्य से अधिक है, तो चर को i_stor से मान लोड करें।

समापन ब्रैकेट को संसाधित करते समय ] , यदि data_arr शून्य नहीं है, तो हम वेरिएबल i_stor से वेरिएबल में ओपनिंग ब्रैकेट का पता लोड करते हैं।

अगला, कमांड पर जाएं i: = i + 1;
यदि इससे पहले i_stor से एक मान i (सत्यापन के दौरान) में लोड किया गया था, तो डंप के बाद हम [ (अन्यथा हम अंदर होंगे)

 LABEL prev,next; var data_arr:array[1..10] of integer; //   str_arr: string; //  i,j,k: integer; //     i_stor: integer; begin j:=1; i:=1; readln(str_arr); //  prev: if i>length(str_arr) then goto next; if (str_arr[i]='+') then data_arr[j]:= data_arr[j]+1; if (str_arr[i]='-') then data_arr[j]:= data_arr[j]-1; if (str_arr[i]='>') then j:=j+1; if (str_arr[i]='<') then j:=j-1; if (str_arr[i]='.') then write(chr(data_arr[j])); if (str_arr[i]='[') then begin if data_arr[j]>0 then i_stor:=i; end; if (str_arr[i]=']') then begin if data_arr[j]>0 then begin i:=i_stor; end; end; i:=i+1; goto prev; next: for k:=1 to 10 do begin write(data_arr[k]); write(' '); end; end. 

कोड $$$+++++ [> + <-]$नंबर 5 को अगली सेल में स्थानांतरित करता है 0 5 0 0 0 0 0 0 0 0 0
ideone.com
HelloWorld कोड ideone.com जैसा दिखता है

चलो कोडांतरक के लिए आगे बढ़ते हैं

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

 mov CX, 28h ; -   prev: ;   ;  ;  ;   loop prev ;    prev 

Str_arr कमांड की एक सरणी बनाएं, वहां डालें $$$+++$
एक डेटा ऐरे data_arr बनाएँ, (स्पष्टता के लिए) वहाँ 1,1,1,1,1,1,1,1,1,1,1 रखें

एक लूप में, चरित्र के साथ वर्तमान चरित्र की तुलना करें $$$+$और, यदि अक्षर समान हैं, तो वर्तमान सेल में 1 से मान बढ़ाएं।

 text segment ; bf1.asm assume cs:text, ds:data, ss:stk begin: ;   mov AX,data ;    mov DS,AX mov DL, str_arr ;   DL 1  mov CX, 0Ah ; 10  prev: cmp DL, 2Bh ;   + jne next ; ,    next mov BL, 00h ;   BL  inc data_arr[BX] ; ,      1 next: inc i ;       mov BL, i mov DL, str_arr [BX] loop prev mov AX, 4c00h ;   int 21h text ends data segment str_arr DB 2Bh,2Bh,2Bh,'$' ;  +++ data_arr DB 1,1,1,1,1,1,1,1,1,1,'$' ;  i DB 0 ;    data ends stk segment stack db 100h dup (0) ;  256  stk ends end begin 

कोडांतरण (अनुवाद) tasm.exe bf1.asm कमांड द्वारा किया जाता है
लिंकिंग tlink.exe bf1.obj द्वारा किया जाता है

TurboDebagger डिबगर में प्रोग्राम चलाने के बाद, आप देख सकते हैं कि पता 0130 से शुरू होता है, कमांड स्थित हैं $$$+++$
अगला डेटा सरणी है जिसमें हमने पहला तत्व बदला है, फिर i चर, जो लूप के निष्पादन के बाद 0Ah के बराबर हो जाता है।



आदेश जोड़ें $$$- <>।$
02h इंटरप्ट फंक्शन int 21h का उपयोग करके किसी एकल वर्ण को आउटपुट करने के लिए, DL कोड में वर्ण कोड रखने के लिए यह आवश्यक है (व्यवधान को कॉल करने से पहले)।

  mov AH,2 mov DL,   int 21h 

हम पूरा कार्यक्रम लिखेंगे

 text segment ; bf2.asm assume cs:text,ds:data, ss:stk begin: ;   mov AX,data ;    mov DS,AX mov DL, str_arr ;   DL 1  mov CX, 0Ah ; 10  prev: cmp DL, 2Bh ;   + jne next ; ,    next mov BL, j ;   BL   inc data_arr[BX] ; ,      1 next: cmp DL, 2Dh ;   - jne next1 ; ,    next1 mov BL, j dec data_arr[BX] next1: cmp DL, 3Eh ;   > jne next2 ; ,    next2 inc j ; ,      data_arr next2: cmp DL, 3Ch ;   < jne next3 ; ,    next3 dec j ; ,      data_arr next3: cmp DL, 2Eh ;   . jne next4 ; ,    next4 mov AH,2 ; ,    mov BL, j mov DL, data_arr[BX] int 21h next4: inc i ;       mov BL, i mov DL, str_arr [BX] loop prev mov AX, 4c00h ;   int 21h text ends data segment str_arr DB 2Bh,3Eh,2Bh,2Bh,'$' ;  +>++ data_arr DB 0,0,0,0,0,0,0,0,0,0,'$' ;  i DB 0, '$' ;    j DB 0, '$' ;    data ends stk segment stack db 100h dup (0) ;  256  stk ends end begin 

लूप इस तरह काम करता है:
अगर str_arr का वर्तमान तत्व नहीं है $$$+$फिर अगले लेबल पर जाएं : (अन्यथा, निष्पादित करें $$$+$)
अगर str_arr का वर्तमान तत्व नहीं है $$$-$फिर अगले 1 लेबल पर जाएं :
अगर str_arr का वर्तमान तत्व नहीं है $$$>$फिर अगले 2 लेबल पर जाएं :
अगर str_arr का वर्तमान तत्व नहीं है $$$<$फिर अगले 3 लेबल पर जाएं :
अगर str_arr का वर्तमान तत्व नहीं है $$$$$फिर अगले 4 लेबल पर जाएं :
अगले लेबल के बाद : स्ट्रिंग str_arr के सूचकांक को बढ़ाएं और लूप की शुरुआत में कूदें - लेबल के लिए प्रचलित :

इसके बाद, [ और ] जोड़ें
I_stor वैरिएबल जोड़ें।

यदि वर्तमान तत्व ने परीक्षण को [ पर उत्तीर्ण किया है, तो हम data_arr array के वर्तमान तत्व को शून्य पर चेक करते हैं, और यदि तत्व शून्य है, तो हम आगे (अगले लेबल पर) कूदते हैं, अन्यथा हम वैरिएबल से i_stor में मान को लोड करते हैं।

 next4: cmp DL, 5Bh ;   [ jne next5 ; ,    next5 mov BL, j mov DL, data_arr[BX] cmp DL, 00 ; ,    data_arr   jz next5 ;  ,   mov DL, i ;   mov i_stor, Dl ;  i_stor   i next5: 

समापन कोष्ठक को संसाधित करते समय ] , यदि data_arr शून्य नहीं है, तो चर i_stor से चर I में उद्घाटन ब्रैकेट का पता लोड करें

 next5: cmp DL, 5Dh ;   ] jne next6 ; ,    next6 mov BL, j mov DL, data_arr[BX] cmp DL, 00 ; ,    data_arr   jz next6 ;  ,   mov DL, i_stor ;   mov i, Dl ;  i_stor   i next6: 

कोड की जाँच करें $$$+++++ [> + <-]$

 text segment ; bf4.asm assume cs:text, ds:data, ss:stk begin: ;   mov AX,data ;    mov DS,AX mov DL, str_arr ;   DL 1  mov CX, 50h ; 80  prev: cmp DL, 2Bh ;   + jne next ; ,    next mov BL, j ;   BL   inc data_arr[BX] ; ,      1 next: cmp DL, 2Dh ;   - jne next1 ; ,    next1 mov BL, j dec data_arr[BX] ;BX,   Bl next1: cmp DL, 3Eh ;   > jne next2 ; ,    next2 inc j ; ,      data_arr next2: cmp DL, 3Ch ;   < jne next3 ; ,    next3 dec j ; ,      data_arr next3: cmp DL, 2Eh ;   . jne next4 ; ,    next4 mov AH,2 ; ,    mov BL, j mov DL, data_arr[BX] int 21h next4: cmp DL, 5Bh ;   [ jne next5 ; ,    next5 mov BL, j mov DL, data_arr[BX] cmp DL, 00 ; ,    data_arr   jz next5 ;  ,   mov DL, i ;   mov i_stor, Dl ;  i_stor   i next5: cmp DL, 5Dh ;   ] jne next6 ; ,    next6 mov BL, j mov DL, data_arr[BX] cmp DL, 00 ; ,    data_arr   jz next6 ;  ,   mov DL, i_stor ;   mov i, Dl ;  i_stor   i next6: inc i ;     mov BL, i mov DL, str_arr[BX] loop prev ;    prev: mov AX, 4c00h ;   int 21h text ends data segment str_arr DB 2Bh,2Bh,2Bh,2Bh,5Bh, 3Eh,2Bh,3Ch,2Dh ,5Dh, '$' ;  ++++[>+<-] data_arr DB 0,0,0,0,0,0,0,0,0,0,'$' ;  i DB 0,'$' ;    j DB 0,'$' ;    i_stor DB 0,'$' data ends stk segment stack db 100h dup (0) ;  256  stk ends end begin 

इनपुट लाइन 3fh इंटरप्ट 21h में फ़ंक्शन जोड़ें

  mov ah, 3fh ;   mov cx, 100h ; 256  mov dx,OFFSET str_arr int 21h 

हम स्ट्रिंग '$' के अंत तक पहुँचने के बाद लूप से बाहर निकलेंगे।
ऐसा करने के लिए, हम वर्तमान चरित्र की तुलना '$' अक्षर से करेंगे ।

 cmp DL, 24h ;  '$' je exit_loop 

लूप लूप को jmp कमांड से बदलें।

 text segment assume cs:text,ds:data, ss: stk begin: ;   mov AX,data ;    mov DS,AX ;   mov ah, 3fh mov cx, 100h ; 256  mov dx,OFFSET str_arr int 21h ; mov DL, str_arr ;   DL 1  ;mov CX, 100h ; 256  prev: cmp DL, 24h ;    '$' je exit_loop cmp DL, 2Bh ;   + jne next ; ,    next mov BL, j ;   BL   inc data_arr[BX] ; ,      1 next: cmp DL, 2Dh ;   - jne next1 ; ,    next1 mov BL, j dec data_arr[BX] ;BX,   Bl next1: cmp DL, 3Eh ;   > jne next2 ; ,    next2 inc j ; ,      data_arr next2: cmp DL, 3Ch ;   < jne next3 ; ,    next3 dec j ; ,      data_arr next3: cmp DL, 2Eh ;   . jne next4 ; ,    next4 mov AH,2 ; ,    mov BL, j mov DL, data_arr[BX] int 21h next4: cmp DL, 5Bh ;   [ jne next5 ; ,    next5 mov BL, j mov DL, data_arr[BX] cmp DL, 00 ; ,    data_arr   jz next5 ;  ,   mov DL, i ;   mov i_stor, Dl ;  i_stor   i next5: cmp DL, 5Dh ;   ] jne next6 ; ,    next6 mov BL, j mov DL, data_arr[BX] cmp DL, 00 ; ,    data_arr   jz next6 ;  ,   mov DL, i_stor ;   mov i, Dl ;  i_stor   i ;       prev: next6: inc i ;     mov BL, i mov DL, str_arr[BX] ; loop prev ;    prev: jmp prev exit_loop: MOV AH,2 ;     MOV DL,0Ah INT 21h mov AX, 4c00h ;   int 21h text ends data segment str_arr DB 256h DUP('$') ;   256  data_arr DB 0,0,0,0,0,0,0,0,0,0,'$' ;  i DB 0,'$' ;    j DB 0,'$' ;    i_stor DB 0,'$' data ends stk segment para stack db 100h dup (0) ;  256  stk ends end begin 

संकलन के दौरान हमें एक त्रुटि मिलती है

0001h बाइट्स की सीमा से बाहर सापेक्ष कूद

तथ्य यह है कि je / jne कमांड प्रोग्राम की कुछ पंक्तियों के बाद ही कूद सकते हैं (प्रत्येक पंक्ति मेमोरी में 1 से 5 बाइट्स तक ले जाती है)।


Je / jne प्रोग्राम के अंत में लंबी छलांग नहीं लगाई जा सकती।
इसलिए, हम अभिव्यक्ति की जगह लेते हैं

  cmp DL, 24h ;  '$' je exit_loop ... exit_loop: 

अभिव्यक्ति

 cmp DL, 24h ;  '$' jne exit_ jmp exit_loop exit_ ... exit_loop: 

इसलिए, यदि वर्तमान वर्ण $ से मेल खाता है, तो exit_loop पर जाएं: jmp कमांड के साथ लेबल करें, अन्यथा हम jmp कमांड पर कूदते हैं ।
जेएमपी कमांड इंट्रा-सेगमेंट रिलेटिव शॉर्ट ट्रांज़िशन (संक्रमण को 128 बाइट्स से कम कर सकता है, यानी IP: = IP + i8) या इंट्रा-सेगमेंट रिलेटिव लॉन्ग ट्रांज़िशन (327 बाइट्स से कम संक्रमण, यानी- IP = = IP + i16)।
डिफ़ॉल्ट रूप से, जेएमपी कमांड एक रिश्तेदार लंबी छलांग लगाता है , जो कि हमें चाहिए (सामान्य तौर पर, आप केवल कार्यक्रम की शुरुआत के बजाय जंप निर्देश को जोड़ सकते हैं)।

 ;jumps text segment assume cs:text,ds:data, ss: stk begin: ;   mov AX,data ;    mov DS,AX ;;; mov ah, 3fh ;   mov cx, 100h ; 256  mov dx,OFFSET str_arr int 21h ;;; mov DL, str_arr ;   DL 1  ;mov CX, 100h ; 256  prev: cmp DL, 24h ;  '$' ;je exit_loop jne l1 jmp SHORT exit_loop l1: cmp DL, 2Bh ;   + jne next ; ,    next mov BL, j ;   BL   inc data_arr[BX] ; ,      1 next: cmp DL, 2Dh ;   - jne next1 ; ,    next1 mov BL, j dec data_arr[BX] ;BX,   Bl next1: cmp DL, 3Eh ;   > jne next2 ; ,    next2 inc j ; ,      data_arr next2: cmp DL, 3Ch ;   < jne next3 ; ,    next3 dec j ; ,      data_arr next3: cmp DL, 2Eh ;   . jne next4 ; ,    next4 mov AH,2 ; ,    mov BL, j mov DL, data_arr[BX] int 21h next4: cmp DL, 5Bh ;   [ jne next5 ; ,    next5 mov BL, j mov DL, data_arr[BX] cmp DL, 00 ; ,    data_arr   jz next5 ;  ,   mov DL, i ;   mov i_stor, Dl ;  i_stor   i next5: cmp DL, 5Dh ;   ] jne next6 ; ,    next6 mov BL, j mov DL, data_arr[BX] cmp DL, 00 ; ,    data_arr   jz next6 ;  ,   mov DL, i_stor ;   mov i, Dl ;  i_stor   i ;       prev: next6: inc i ;     mov BL, i mov DL, str_arr[BX] ; loop prev ;    prev: jmp prev exit_loop: MOV AH,2 ;     MOV DL,0Ah INT 21h mov AX, 4c00h ;   int 21h text ends data segment str_arr DB 256h DUP('$') ;   256  data_arr DB 0,0,0,0,0,0,0,0,0,0,'$' ;  i DB 0,'$' ;    j DB 0,'$' ;    i_stor DB 0,'$' data ends stk segment para stack db 100h dup (0) ;  256  stk ends end begin 

कार्यक्रमों की लिस्टिंग के साथ जीथब से लिंक करें ।

PS यहाँ एक x86 रिवर्स पोलिश नोटेशन (RPN) कैलकुलेटर बनाने के बारे में एक लेख दिया गया है ।