Parte IParte IIParte IIICriação de um tradutor de linguagem de cérebro no TurboAssembler'e.
Adicione a saída da matriz
data_arr (a "fita" da máquina de Turing) à tela.
Vamos escrever um programa que exibe os elementos de uma matriz arbitrária por meio da função de interrupção
09h 21h.model tiny ; ascii-decoder.asm jumps .data data_arr DB 1,0,2,0,3,0,4,0,5,0,6,0,7,'$' ; .code ORG 100h start: ; mov AX, @data ; mov DS,AX ;;;;;;;;;;;;;;;; MOV AH,2 ; MOV DL,0Ah INT 21h mov dx,offset data_arr ; mov ah,09h ; int 21h ;;;;;;;;;; MOV AH,2 ; MOV DL,0Ah INT 21h mov AX, 4c00h ; int 21h end start
Na tela, veremos códigos ascii de elementos do
array data_arr DB 1,0,2,0,3,0,4,0,5,0,6,0,7, '$'
Para representar os elementos da matriz como números, usaremos o operador
div .
O comando
div NUMBER divide o registro
AX por
NUMBER e coloca a parte inteira da divisão em
AL e o restante da divisão em
AH (o
NUMBER pode ser uma área de memória ou um registro geral)
Imprimir o primeiro e o segundo elementos da matriz
.model tiny ; ascii-decoder.asm jumps .data data_arr DB 10,12,0,0,0,0,0,0,0,0,'$' ; .code ORG 100h start: ; mov AX, @data ; mov DS,AX ;;;;;;;;;;;;;;;; MOV AH,2 ; MOV DL,0Ah INT 21h ;mov dx,offset data_arr ; ;mov ah,09h ; ;int 21h ;; sub AH, AH ; AH mov AL, data_arr ; mov BL, 10 ; div BL ; AL=, AH= mov BX,AX add BX,3030h mov AH,2 ; 21h mov DL,BL ; int 21h mov DL, BH ; int 21h ; sub AH, AH ; AH mov AL, data_arr+1 ; mov BL, 10 ; div BL ; AL=, AH= mov BX,AX add BX,3030h mov AH,2 ; 21h mov DL,BL ; int 21h mov DL, BH ; int 21h ;;;;;;;;;; MOV AH,2 ; MOV DL,0Ah INT 21h mov AX, 4c00h ; int 21h end start
Para exibir todos os elementos da matriz, usaremos o comando
loop .
Colocamos no registro
CX o número de medidas igual ao número de elementos na matriz e, em cada medida, adicionaremos uma ao índice da matriz
i .
.model tiny ; ascii-decoder1.asm jumps .data data_arr DB 3,5,6,7,0,11,12,13,0,20,'$' ; i DB 0,'$' .code ORG 100h start: ; mov AX, @data ; mov DS,AX ;;;;;;;;;;;;;;;; MOV AH,2 ; MOV DL,0Ah INT 21h ;mov dx,offset data_arr ; ;mov ah,09h ; ;int 21h mov CX, 0Ah _prev: ;; ; mov BL,i sub AH, AH ; AH mov AL, data_arr[BX] ; mov BL, 10 ; div BL ; AL=, AH= mov BX,AX add BX,3030h mov AH,2 ; 21h mov DL,BL ; int 21h mov DL, BH ; int 21h ; sub DL, DL int 21h ;;; sub BX,BX inc i ; mov BL, i loop _prev ;;;;;;;;;; MOV AH,2 ; MOV DL,0Ah INT 21h mov AX, 4c00h ; int 21h end start
Em seguida, adicione um loop que exiba os elementos da matriz como números no programa principal.
.model tiny jumps .data str_arr DB 256h DUP('$') data_arr DB 0,0,0,0,0,0,0,0,0,0,'$' i DB 0,'$' j DB 0,'$' i_stor DB 0,'$' .code ORG 100h start: mov AX, @data mov DS,AX ;;; mov ah, 3fh mov cx, 100h mov dx,OFFSET str_arr int 21h ;;; mov DL, str_arr prev: cmp DL, 24h je exit_loop cmp DL, 2Bh jne next mov BL, j inc data_arr[BX] next: cmp DL, 2Dh jne next1 mov BL, j dec data_arr[BX] next1: cmp DL, 3Eh jne next2 inc j next2: cmp DL, 3Ch jne next3 dec j next3: cmp DL, 2Eh jne next4 mov AH,2 mov BL, j mov DL, data_arr[BX] int 21h next4: cmp DL, 5Bh jne next5 ;mov BL, j ;mov DL, data_arr[BX] ;cmp DL, 00 ;jz next5 mov DL, i mov i_stor, Dl next5: cmp DL, 5Dh jne next6 mov BL, j mov DL, data_arr[BX] cmp DL, 00 jz next6 mov DL, i_stor mov i, DL next6: inc i mov BL, i mov DL, str_arr[BX] ; loop prev jmp prev exit_loop: ;;;;;;;;;;;;;;;; MOV AH,2 ; MOV DL,0Ah ; INT 21h ; ; output data_arr mov CX, 0Ah ; 10 sub AL,AL ; AL mov i, AL ; sub BX,BX ; BX _prev: ; incorrect 1st element sub AH, AH ; AH mov AL, data_arr[BX] ; ;mov AL, data_arr+1 mov BL, 10 ; div BL ; AL= AH= mov BX,AX add BX,3030h mov AH,2 ; 2 21h mov DL,BL ; int 21h mov DL, BH ; int 21h ; ( ) sub DL, DL int 21h ;;; sub BX,BX inc i ; mov BL, i loop _prev ;;;;;;;;;; MOV AH,2 ; MOV DL,0Ah ; INT 21h ; mov AX, 4c00h ; int 21h end start
HelloWorld agora se parece com isso
Como não processamos números maiores que
99 , o número
100 é exibido incorretamente, os números restantes são exibidos corretamente.
Parênteses aninhados
Para processar os colchetes aninhados, colocaremos os colchetes de abertura na pilha e os fechos na pilha.
Escreveremos um programa simples para trabalhar com a pilha em Pascal.
var a : array[1..10] of integer; size : integer; procedure push(c : integer); begin size := size + 1; a[size] := c; end; procedure pop; begin size := size - 1; end; begin size := 0; Push(1); writeln(a[size]); Push(2); writeln(a[size]); Push(3); writeln(a[size]); Pop(); writeln(a[size]); Pop(); writeln(a[size]); end.
Tomou
daqui .
Você pode conferir
aqui ou
aqui .
Altere o procedimento de
envio para que, quando
tamanho for zero, obtenhamos um link para o primeiro elemento.
procedure push(c : integer); begin a[size+1] := c; size := size + 1; end;
Adicione uma "pilha" ao programa principal.
Program bf5_stack; LABEL prev,next; var a : array[1..10] of integer; size : integer; data_arr:array[1..10] of integer; // str_arr: string; // i,j,k: integer; // i_stor: integer; //Stack procedure push(c : integer); begin a[size+1] := c; size := size + 1; end; procedure pop; begin size := size - 1; end; {---------------------------------------------------} begin j:=1; // i:=1; size := 0; { } //readln(str_arr); // //str_arr:='+++[>+++[>+<-]<-]'; // 3*3=9 str_arr:='+++[> +++[>+++[>+<-]<-] <-]'; //3^3=27; 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 Push(i); if (str_arr[i]=']') then begin Pop(); if (data_arr[j]>0) then begin i := a[size+1]; goto prev; end; end; i:=i+1; goto prev; next: for k:=1 to 10 do begin write(data_arr[k]); write(' '); end; end.
ideone.comSe encontrarmos um colchete de abertura, simplesmente colocamos seu endereço na pilha; quando encontramos um colchete de fechamento, extraímos seu endereço da pilha; se o valor na célula atual é maior que zero, retornamos ao colchete de abertura.
Um exemplo de uso de uma pilha normal / "padrão" é mostrado no programa
bf51_stack.pas"Adicionar" uma pilha ao programa assembler principal
.model tiny ; bf7_stack_decoder.asm jumps .data 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,'$' .code ORG 100h start: ; 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 ;sub DX,DX mov AL, i ; push AX next5: cmp DL, 5Dh ; ] jne next6 ; , next6 sub AX,AX pop AX mov BL, j mov DL, data_arr[BX] cmp DL, 00 ; , data_arr jz next6 ; , mov i, AL ; i_stor i mov BL, i mov DL, str_arr[BX] jmp prev next6: inc i ; mov BL, i mov DL, str_arr[BX] jmp prev exit_loop: ; ascii- MOV AH,2 ; MOV DL,0Ah ; INT 21h ; ; output data_arr mov CX, 0Ah ; 10 sub AL,AL ; AL mov i, AL ; sub BX,BX ; BX _prev: ; incorrect 1st element sub AH, AH ; AH mov AL, data_arr[BX] ; ;mov AL, data_arr+1 mov BL, 10 ; div BL ; AL= AH= mov BX,AX add BX,3030h mov AH,2 ; 2 21h mov DL,BL ; int 21h mov DL, BH ; int 21h ; ( ) sub DL, DL int 21h ;;; sub BX,BX inc i ; mov BL, i loop _prev ;;;;;;;;;; MOV AH,2 ; MOV DL,0Ah ; INT 21h ; ;;;;;;;;;;;;;;; mov AX, 4c00h ; int 21h END start
Link para o github.