Adunarea a *n* cuvinte

; Se adună n cuvinte începând de la adresa 3000:200,

; cu rezultat de lungime tot cuvânt (16 biţi),

; fără detectarea depăşirii.

.model small

.code

prog segment word public 'code'

assume cs:prog, ds:date

start: mov ax,date

mov ds,ax

lea si,sir

mov ax,0

mov cx,lung_sir

reia_add:

add ax,[si]

add si,2

loop reia_add

mov rezultat,ax

rev_DOS:

mov ax,4c00h

int 21

afis_mesaj:

mov ah,9

int 21

jmp rev_Dos

prog ends

.data

date segment

sir dw 0f54h,20000,0ff56h,8000

lung_sir equ ($-sir)/2

rezultat dw 2 dup(?)

date ends

end start

Afisare in binar continutul reg. BX

; Afisarea în binar a continutului registrului BX.

.model small

.data

continut dw 0f834h

.code

start:

mov ax, @data

mov ds, ax

mov bx, [continut]

mov cx, 16

mov ah, 2h

bucla:

shl bx, 1 ; shift left 1 pozitie in BX

mov dl, '0'

jnc ezero

mov dl, '1'

ezero:

int 21h

loop bucla

mov ax, 4c00h

int 21h

end start

Registrele

Concatenarea a doua siruri (asm)

date segment word public 'data'

sir1 db 'Primul sir '

lung1 equ $-sir1

sir2 db 'cel de-al doilea sir'

lung2 equ $-sir2

loc_sir2 db 13,10,'$'

mesaj db 13,10,'Sirurile concatenate sunt ',13,10,'$'

date ends

prog segment word public 'code'

assume cs:prog, ds:date

start:

mov ax,date

mov ds,ax

lea dx, sir1

mov ah, 9 ; tiparire primul sir

int 21h

lea dx, sir2

mov ah,9 ; tiparire al doilea sir

int 21h

lea di, sir1 ; incepe proc de concatenare, initializare date

mov bx, lung1 ; sir1 intra in DI (destinatie), sir2 intra in SI (sursa)

lea si, sir2

mov cx, lung2

push ds

pop es ; es = ds

call concat

jz gata ; ZF = 1, terminare cu insucces

lea dx, mesaj ; altfel tiparire rezultat

mov ah, 9

int 21h

lea dx, sir1 ; tiparire sir1 care contine concatenare

mov ah, 9

int 21h

gata:

mov ax, 4c00h

int 21h ; terminare prog

; procedura de concatenare

; intrari: sir1 : (DI, BX)

; sir2 : (SI, CX)

; iesiri: succes: ZF = 0, SI = noul offset pt sir2, BX = lungime totala dupa concat

; insucces: ZF = 1, fie un sir este vid, fie deja a avut loc concatenarea

dim2 dw ?

off1 dw ?

concat proc near

jcxz iesire ; unul din siruri e vid => terminare

cmp bx, 0

je iesire

mov dim2, cx ; salvare dimensiune sir2

mov off1, di ; salvare offset sir1

add di, bx ; de unde va incepe al doilea

cmp si,di ; compara sa vada daca al doilea sir se afla deja aici

je gata ; daca da, se termina

conc:

cld ; curata flagul pt address

rep movsb ; muta din SI in DI, in mod repetat

sub di, dim2 ; adresa de inceput al celui de-al doilea sir

mov si, di ; se returneaza in SI

add bx, dim2 ; lungimea sirului total

gata:

mov di, off1

mov cx, dim2

iesire:

ret

concat endp

prog ends

stiva segment stack 'stack'

dw 100 dup(?)

stiva ends

end start

Aflare maxim dintr-un sir (asm)

; aflare maxim dintr-un sir / sau minim

date segment word public 'data'

sir dw 16, 41, 40, 3 ; sau val lor in hexa

lung equ $-sir

max dw ?

mesaj db 13,10,'sir vid de valori - nu exista maxim',13,10,'$'

date ends

prog segment word public 'code'

assume cs:prog, ds:date

start:

mov ax, date

mov ds, ax

lea si,sir ; aduce offsetul sirului

mov cx, lung

call afla_max

jz depune_max ; daca ZF = 1, terminare cu succes

lea dx, mesaj ; in caz contrar

mov ah, 9 ; afisare mesaj

int 21h

jmp gata

depune_max:

mov max, ax ; maximul va fi initial in ax

gata:

mov ax, 4c00h

int 21h ; terminare

; intrari: SI, CX = offset si lungime sir in care se cauta

; iesiri: ZF = 1 daca s-a aflat max, returnat in AX

; ZF = 0, sir vid

afla_max:

cmp cx, 0 ; test sir vid

jnz maxim ; nu e vid, se determina maximul

; in caz contrar

cmp cx, 1 ; ZF devine 0, sir vid , se termina

ret

maxim:

push bx

push si

lodsw ; preia prima val. din sir, intra in AX, implicit CX = CX - 1

mov bx, ax ; init maxim temporar, care va fi in BX

jcxz gata ; daca CX == 0, a fost o singura val si deci e maxim

caut_maxim:

lodsw ; urmatoarea val din sir, intra in AX

cmp ax, bx ; compar cu maximul temporar aflat in BX

; daca aveam de gasit minimul, scriem jae in loc de jbe

jbe next ; daca AX mai mic sau egal cu BX (maximul temporar) trec la next

mov bx, ax ; altfel se actualizeaza noul maxim temporar

next: loop caut_maxim

gata:

mov ax, bx ; maximul temporar se pune in AX

cmp ax, ax ; ZF = 1

; refacere registri

pop si

pop bx

afla_max endp

prog ends

stiva segment stack 'stack'

dw 100 dup(?)

stiva ends

end start