Asamblare - All Forums

Cautare nr de subsiruri

Tue, 06 Nov 2018 22:56:59 +0200

presupunem ca avem sir sursa: ABBABBACBAB si vrem sa verificam de cate ori apare subsirul: AB => 3 ori

.model small
.stack 100
.data
sirSursa db 'ABBABBACBAB'
dimSirSursa equ $-sirSursa
sirCautat db 'AB'
dimSirCautat equ $-sirCautat

loc_offsetCurent dw 0
loc_numarPotriviri dw 0

text1 db 'Numarul de aparitii: $'

.code

; pasam prin al caracterul cautat
; pasam prin bx offsetul catre sirul sursa din segmentul curent
; pasam prin cx dimensiunea sirului
; returnam prin ax offsetul la care a fost gasit
; caracterul sau -1 daca nu a fost gasit

; // ax cautaOffsetCaracter(al, bx, cx)
; int cautaOffsetCaracter(char carCautat, char *sir, int lungime)
; {
; int i = 0;
; char gasit = 0; ; // zero flag
;
; for (i = 0; i < lungime; ++i)
; {
; if (sir[i] == carCautat)
; {
; gasit = 1;
; break;
; }
; }
;
; if (gasit == 1)
; {
; return lungime - i; // ax = lungime - i
; }
; else
; {
; return -1; // ax = -1 (0xFFFF)
; }
;
; }
cautaOffsetCaracter proc
push di ; salvam registrii folositi si modificati
push cx
push dx

mov dx, cx
mov di, bx

repne scasb

jz gasit_car ; verificam daca ultima potrivire a fost ok.

mov ax, 0FFFFh ; returnam -1
jmp sfarsit_cautare

gasit_car:
sub dx, cx ; calculam offsetul din lugimea intiala
dec dx ; vrem ca offsetul sa inceapa de la 0, nu 1
mov ax, dx ; returnam offsetul la care a fost gasit caracterul

sfarsit_cautare:
pop dx
pop cx
pop di
ret
cautaOffsetCaracter endp

; pasam prin ax sirul cautat
; pasam prin bx sirul sursa
; pasam prin cx dimensiunea sirului
; returnam prin ax dimensiunea potrivirii
; csau -1 daca sirurile difera

; // ax verificaPotrivire(ax, bx, cx)
; int verificaPotrivire(char *sirCautat, char *sirSursa, int lungime)
verificaPotrivire proc
push si
push di
push cx
push dx

mov dx, cx
mov si, ax
mov di, bx

repe cmpsb

jz potrivire

mov dx, 0FFFFh

potrivire:
mov ax, dx
pop dx
pop cx
pop di
pop si
ret
verificaPotrivire endp

; returnam prin ax numarul de ori in care sirCautat se regaseste in sirSursa
cautaNrPotriviri proc

; seteaza date initiale
; folosim globale, desi am putea-o face si pe stiva
mov loc_numarPotriviri, 0 ; numar potriviri
mov loc_offsetCurent, 0 ; offset curent in sirSursa; initial 0

reia:

mov al, sirCautat ; cautam sir2[0] : 'A'
mov bx, offset sirSursa ; cautam in sir1 : 'ABBABBABA'
mov cx, dimSirSursa ; pt intreaga dimensiune a sirului : 9

add bx, loc_offsetCurent ; muta indexul in sirul sursa la offsetul curent
sub cx, loc_offsetCurent ; seteaza cx conform cu numarul ramas de caractere.

call cautaOffsetCaracter

; verifica daca functia a returnat -1 sau un offset valid.
cmp ax, 0FFFFh
jz terminat ; daca functia a returnat -1 am terminat cautarea

; daca nu, actualizam offsetul
add loc_offsetCurent, ax ; actualizeaza offsetul curent

; si verificam daca exista o potrivire incepand de la offsetul curent
mov ax, offset sirCautat ; cautam sirul 2 : 'AB'
mov bx, offset sirSursa ; cautam in sir1 : 'ABBABBABA'
add bx, loc_offsetCurent ; de la offsetul curent
mov cx, dimSirCautat ; pt dimensiunea celui de'al doilea sir : 2

call verificaPotrivire

; verifica daca sirurile sunt identice
cmp ax, 0FFFFh
jnz potrivire_gasita
; daca nu sunt, ne mutam pur si simplu pe urmatorul caracter si reluam verificariile
add loc_offsetCurent, 1
jmp reia

potrivire_gasita:
; daca sunt identice, ne mutam dupa potrivire
add loc_offsetCurent, ax
inc loc_numarPotriviri
jmp reia

terminat:
mov ax, loc_numarPotriviri
ret
cautaNrPotriviri endp

start:
mov ax, @data
mov ds, ax
mov es, ax

; afisare mesaj rezultat:
mov ah, 9
lea dx, text1
int 21h

call cautaNrPotriviri

mov dx, ax ; pune rezultatul cautariilor in dx;
add dx, '0' ; transforma rezultatul din dx in ascii [presupunem ca e doar o valoarea intre 0 si 9]

mov ah, 2h ; dos 21h: 'Write character to STDOUT' ; continutul lui dl
int 21h

; procedura exit
mov ah, 4ch
int 21h
end start

end start

Concatenare siruri

Wed, 31 Oct 2018 23:29:35 +0200

.model small
.stack 100
.data
    text3 db '$'
    lenText3 equ $ - text3
    text2 db 'World'
    lenText2 equ $ - text2
    text1 db 'Hello '
    lenText1 equ $ - text1
    buffer db 100 dup(0)
.code
; param [in] si sursa
; param [in] di destinatie
; param [in] cx lungime
; datele de intrare sunt restaurate la iesirea din procedura
copy proc
    push si
    push di
    push cx
    cld
    rep movsb
    pop cx
    pop di
    pop si
    ret
copy endp

start:
    mov ax, @data
    mov ds, ax
    mov es, ax

    cld ; setam directia decopiere
    mov si, offset text1 ; setam sursa
    mov di, offset buffer ; setam destinatia
    mov cx, lenText1 ; setam numarul de caractere ce urmeaza a fi copiate
    rep movsb    ; copiem
    ; buffer = Hello

    ; Concatenam: "World" la textul anterior
    mov si, offset text2 ; setam sursa
    ; destinatia ramane nemodificata. a fost actualizata de instructiunea anterioara: 'movsb'
    mov cx, lenText2    ; setam numarul de caractere ce urmeaza a fi copiate
    rep movsb ; copiem
    ; buffer = Hello World

    ; Concatenam: "$" / caracter terminal pt prin string
    mov si, offset text3 ; sursa
    ; destinatie ramane di
    mov cx, lenText3    ; setam numarul de caractere ce urmeaza a fi copiate
    call copy    ; apelam o metoda de copiere
    ; buffer = Hello World$

    ; afisam datele copiate
    mov ah, 9
    lea dx, buffer
    int 21h

; rutina exit
    mov ah, 4ch
    int 21h

end start

Aplicatie

Wed, 31 Oct 2018 22:20:53 +0200

Se citesc 2 caractere in hexa: ex. FF
Programul va afisa rezultatul: ex. 255

.model small
.stack 100
.data
text1 db 10, 13, 'Introduceti un numar in hexa: $'
text2 db 10, 13, 'Rezultat: $'
text3 db 10, 13, 'Caracter invalid, introdu altul: $'
.code
ascii_to_hex proc
   push dx
   cmp al, '0'
   jb eroare

   cmp al, '9'
   jb interval_0_9

   cmp al, 'A'
   jb eroare

   cmp al, 'F'
   jbe interval_A_F_uppercase

   cmp al, 'a'
   jb eroare

   cmp al, 'f'
   jbe interval_a_f_lowercase

eroare:
   ; afisare: Caracter invalid
   mov ah, 9
   lea dx, text3
   int 21h

   ; setam valoarea 0
   mov al, 10h
   jmp done
interval_a_f_lowercase:
   sub al, 87 ; 'A' - 10
   jmp done
interval_A_F_uppercase:
   sub al, 55 ; 'A' - 10
   jmp done

interval_0_9:
   sub al, '0'
   jmp done
done:
   pop dx
   ret
ascii_to_hex endp

citeste_hex proc
introdu_alt_nr:
   mov ah, 1
   int 21h
   call ascii_to_hex

   cmp al, 10h
   jae introdu_alt_nr
   ret
citeste_hex endp
start:
   mov ax, @data
   mov ds, ax
   ; afisare: Introduceti un numar in hexa:
   mov ah, 9
   lea dx, text1
   int 21h
   ; citire caracter1
   call citeste_hex
   mov bl, al ; salvam rezultatul in bl
   shl bl, 4   ; mutam rezultatul in partea high a bl

   ; citire caracter2
   call citeste_hex
   or bl, al   ; bl = bl | al;


   mov cx, 0
   mov al, bl
   mov dx, 0

reia:
   mov ah, 0
   mov dl, 10
   div dl     ; impartim la 10
   mov dl, ah ; salvam restul impartirii in dl
   push dx    ; salvam restul impartirii pe stiva
   inc cx     ; salvam numarul de caractere impinse pe stiva
   cmp al, 0
   jne reia
   ; in principiu daca numarul intial era 126,
   ; pe stiva am fi pus : 6 2 1 iar in cx am avea valoarea 3

   ; afisare: Rezultat
   mov ah, 9
   lea dx, text2
   int 21h

afiseaza_rez:
   pop dx     ; pop de pe stiva a resturilor / 'in ordine inversa'
   add dl, 48 ; dl + '0' conversie in ascii
   mov ah, 2
   int 21h
loop afiseaza_rez

   ; procedura exit
   mov ah, 4ch
   int 21h
   end start

end start

Tema

Thu, 25 Oct 2018 09:46:27 +0300

Problema1:
Se vor citi de la tastatura 2 caractere reprezentand un numar decimal. (=> caractere posibile: '0123456789')
Se va afisa ca rezultat valoarea hexadecimala.

exemplu:
Introduceti valoarea: 32
Rezultatule este: 0x20

Parcurs pobleme ramase in 'lucrarea 4'

Linkuri utile

Mon, 22 Oct 2018 23:21:02 +0300

Arhitectura 8086

Dos Interrupts (int 21h)

Aplicatii

Mon, 22 Oct 2018 21:49:26 +0300

.model small
.stack 100
.data
tabel db 1, 2, 3, 4, 5, 11 dup (?)
numar1 dd 145A789Fh
numar2 dd 92457ABCh

numarbcd1 dw 1234h
numarbcd2 dw 5678h

numarbcddesp1 dw 0102h
numarbcddesp2 dw 0009h

asciiTable db '0123456789ABCDEF'
.code

; ne astepam ca in ax sa avem un numar in BCD impachetat
; de exemplu 0x1234 => printam 1234
afisWord proc
push cx
mov cx, 4
reiaAfis:
rol ax, 4 ; mutam cei mai semnificativi 4 biti pe ultima pozitie
call afisareCaracter
; sau precum ati vrut: loop cx
dec cx
cmp cx, 0
jnz reiaAfis
; rotatie completa => nu e nevoie sa salvam ax
pop cx
ret
afisWord endp

; ne astepam ca in ax sa avem un numar in BCD despachetat
; de exemplu 0x0108 => printam 18
afisWordDesp proc
push cx
mov cx, 2
reiaAfisWord:
rol ax, 8 ; mutam cei mai semnificativi 8 biti pe ultima pozitie
call afisareCaracter
loop reiaAfisWord
; rotatie completa => nu e nevoie sa salvam ax
pop cx
ret
afisWordDesp endp

afisareCaracter proc
push ax
push bx
push dx
lea bx, asciiTable
and al, 0Fh ; folosim o masca pt a pastra doar ultimii octeti
xlat ; luam in al caracterul ascii din asciiTable al <- ds:[bx+al];
mov ah, 2h ; dos 21h: 'Write character to STDOUT'
mov dl, al
int 21h
pop dx ; restauram registrii
pop bx
pop ax
ret
afisareCaracter endp

start:
mov ax, @data
mov ds, ax

; random
mov ax, 12h
mov bx, 0h
not ax
and bx, ax

; aplicatia 1
mov al, 10011110b
mov cl, 3
rol al, cl

; aplicatia 2
mov bx, sp
mov cx, 2134h
push cx
mov byte ptr ss:[bx-2], 22h
pop cx

; aplicatia 3
mov cl, 4
mov ax, 0702h
shl al, cl
shr ax, cl

; aplicatia 4
mov cx, 1234H
push cx
mov bx, 2359h
push bx
mov ax, 4257h
mov bp, sp
mov byte ptr [bp], al
pop ax

; aplicatia 5
; incarcam partea low din numere si le adunam
mov cx, word ptr numar1
add cx, word ptr numar2 ; rezultatul adunarii pastrat in cx

; incarcam partea high din numere si le adunam tinand cont de cary flag
mov bx, word ptr numar1[2]
adc bx, word ptr numar2[2] ; rezultatul adunarii pastrat in bx

; afisam partea high, pastrata in bx
mov ax, bx
call afisWord

; afisam partea low, pastrata in cx
mov ax, cx
call afisWord

; rand nou
mov ah, 2h ; dos 21h: 'Write character to STDOUT'
mov dl, 10 ; '\r'
int 21h
mov dl, 13 ; '\n' ... sau invers
int 21h

; aplicatia 6
mov al, byte ptr numarbcd1 ; copiem partea low in al 0x34
mov bl, byte ptr numarbcd2 ; copiem partea low in bl 0x78
add al, bl ; al = 0x34+0x78 = 0xAC => numar ce nu e valid in BCD
daa ; ajustam rezultatul => 112 => CF = 1 si al=12
mov cl, al ; salvam rezultatul in cl
mov al, byte ptr numarbcd1[1] ; copiem partea high in al
mov bl, byte ptr numarbcd2[1] ; copiem partea high in bl
adc al, bl ; al = al + bl + CF = 0x12+0x56 + 0x1 = 0x69
daa ; ajustam rezultatul => 0x69
mov ch, al ; salvam rezultatul in ch

; afisam numarul
mov ax, cx
call afisWord

mov ah, 4ch
int 21H
end start

Aplicatie 4

Mon, 22 Oct 2018 21:47:07 +0300

Code:
.model small

.stack 100

.data   

adr1 dw 1234h

adr2 dw 5678h

adr3 dw 9012h

adr4 dw 3456h

tabela dd adr1, adr2, adr3, adr4

.code

start: mov  ax, @data

mov  ds, ax

mov cx, 1

mov  bx, cx

add  bx, bx

add bx, bx

les  di, tabela[bx]

mov ax, es:[di]

mov ah, 4ch

int  21h

end start

Aplicatie 1

Mon, 22 Oct 2018 21:46:09 +0300

Code:
.model small

.stack 100 

.data   

tabc db '0123456789ABCDEF' 

.code 

start: 

mov ax,@data   

mov ds,ax   

mov al,0   ;iniţializează AL 

repet: 

mov bx,offset tabc  ;pune în BX adresa efectivă tabc   

push ax   ;salvează AL în stivă   

xlat    ;pune în AL octetul de la adresa efectivă [BX+AL] 

call afisare   ;apelul procedurii afisare   

pop ax   

inc al   

cmp al,10H   ;se verifică dacă s-au afişat toate caracterele   

jz sfarsit   

jmp repet 

afisare proc   

mov dl,al   ;pune în DL codul caracterului care trebuie afişat   

mov     ah,2h   ;funcţia DOS pentru afişarea caracterului din DL   

int 21h   

mov dl,' '   

mov     ah,2h   

int 21h 

ret ;afisare 

endp 

sfarsit: 

mov ax,4c00h  ;funcţia DOS de ieşire în sistemul de operare   

int 21h   

end start

Setup environment

Mon, 22 Oct 2018 21:29:41 +0300

Pasi de instalat DosBox + Bc3.1: https://www.youtube.com/watch?v=bdLHtvOBjmQ

Borland 3.1: https://winworldpc.com/product/borland-c/30
DosBox: https://sourceforge.net/projects/dosbox/files/dosbox/

Indrumar laborator

Mon, 22 Oct 2018 21:22:58 +0300

Suport laborator

Indrumar_asamblare_stud.pdf (Size: 457.43 KB / Downloads: 1)