1

5.1. Media aritmetica a unor cuvinte cu semn (semn) ;intrari (AX:CX) = primul operand (CX:DX) = al doilea operand ;iesiri (CX:DX) = rezultat (CF) = 1, daca rezultatul este mai mare de 32 biti (OF) = 1, daca rezultatul depaseste domeniul (in complement fata de 2) AX, BX – nemodificate comp macro highreg, lowreg not lowreg ;se completeaza partea ‘low’ a registrului add lowrg, 1 not highreg adc highreg, 0 endm adds32 proc near push ax push bx push cx or cx, ax pop cx js negative add dx, bx adc cx,ax jmp gata test ax, cx ;test daca ambele sunt negative jns opuse comp ax, bx comp cx, dx add dx, bx adc cx, ax jo gata ;daca avem depasire vom pozitiona CF = 1 jmp reface add dx, bx adc cx, ax clc jmp iesire reface: comp cx, dx gata: stc jo iesire clc iesire: pop bx pop ax ret adds32 endp 5.2. Adunarea a doua valori intregi cu semn, de 32 biti ;intrari (AX:CX) = primul operand (CX:DX) = al doilea operand ;iesiri (CX:DX) = rezultat (CF) = 1, daca rezultatul este mai mare de 32 biti (OF) = 1, daca rezultatul depaseste domeniul (in complement fata de 2) AX, BX – nemodificate comp macro highreg, lowreg not lowreg add lowreg,1 not highreg adc highreg, 0 endm adds32 proc near push ax push bx push cx or cx, ax pop cx

2

js negative add dx, bx adc cx, ax jmp gata test ax, cx jns opuse comp ax, bx comp cx, dx add dx, bx adc cx, ax jmp reface opuse: test ax, 8000h jns neg_operand2 comp ax, bx sub dx, bx sub cx, ax sbb cx, ax jmp gata neg_operand2: comp cx, dx sub dx, bx sbb cx, ax cmp cx, 0 jnz reface cmp dx, 0 jz gata reface: comp cx, dx gata: pop bx pop ax ret adds32 endp 5.3. Înmulţirea, fara semn, a doi operanzi, de 32 biti ;intrări: (DX,AX) = deînmulţit ; (CX,BX) = înmulţitor ;ieşiri: (DX,CX,BX,AX) = rezultatul înmulţirii rezultat dd 4 dup(?) ;aici se vor depune rez parţiale ale înm. şi calcula rez fin, care ;va fi return în

registrii public multfs32 multfs32 proc push dx ;salvarea valorilor initiale ale operanzilor push ax ;necesare in aceasta ordien pentru efectuarea inmultirilor push dx ;conform algoritmului descris mul bx ;efectuarea inmultirii: (AX)*(BX)->(DX,AX) mov word ptr rezultat[0],ax ;salvare rezultat partial mov word ptr rezultat[2],dx pop ax ;refacerea valorii initiale a registrului (DX) mul bx ;efectuarea inmultiri: (BX)*(DX) -> (DX,AX) add word ptr rezultat[2], ax ;actualizare rezultat partial adc word ptr rezultat[4], dx ;cu propagarea eventualului transport pop ax; ; refacerea valorii initiale pentru (AX) mul cx; ; efectuarea inmultiri: (CX)*(AX)->(DX,AX) add word ptr rezultat[2], ax ;actualizare rezultat partial adc word ptr rezultat[4], dx ;cu propagarea transport pop ax; ; refacerea valorii initiale pentru (DX), în registrul (AX) mul cx; ; efectuarea inmultiri: (CX)*(AX)->(DX,AX) add word ptr rezultat[4], ax ;actualizare rezultat final (s-a efectuat ultima inmultire adc word ptr rezultat[6], dx ;cu propagarea transportului mov ax, word ptr rezultat[0]; depunerea rezultatului in registrele specificate

mov bx, word ptr rezultat[2] mov cx, word ptr rezultat[4] mov dx, word ptr rezultat[6] ret

multfs32 endp

3

Daca dorim sa nu utilizam o zona de memorie pentru salvarea rezultatelor partiale (locatia ‚rezultat’) şi sa utilizam numai stiva, atunci avem; ;aceeasi ipoteza

public multus32 multus32 proc near push di ;salvarea registrilor de lucru push si push bp mov di,dx ;salvare deinmultit mov si,ax mul bx ;(dx,ax) <-(AX*BX), registrele notate cu litere mari push ax ;repreznta valorile asociate acestora la intrarea push dx ;in procedura. Salvarea (BX*AX) in stiva mov ax,di mul bx ;(dx,ax) <- (DX*BX) push ax ;salvarea acestui rezultat intermediar in stiva push dx ;in ordinea cuvntul mai putin semnificativ, si apoi mov ax,si ;cel mai semnificativ; refacerea lui (AX) mul cx ;(dx,ax) <- (AX*CX) push ax ;(salvarea rezultatului ultimei inmultiri) push dx mov ax,di ;inmultirea lui (DX) cu (CX) mul cx ;(dx,ax) <- (DX*CX) mov si,ax ;(dx,si) = (DX*CX) pop di ;refacerea rezultatului inmultirii pop ax ;(di,ax) = (AX*CX) pop cx ;refacere rezultat inmultire pop bp ;(cx,bp) = (DX*BX) pop bx ;refacerea primii 16 biti ai produsului (AX*BX) add bx, bp adc cx,0 ;propagare transoprt la rangurile urmatoare adc dx,0 add bx,ax adc cx,0 ;propagare transoprt la rangurile urmatoare adc dx,0 add cx,di adc dx,0 add cx,si adc dx,0 ;transport la ultimul rang (ultimii 16 biti) pop ax ;refacere rezultat final in (DX<CX<BX<AX) pop bp ;refacerea registrelor salvare pop si pop di ret multus32 endp 5.4 Îmnultirea su semn a doi operanzi de 32 biti ;ipoteza aceeasi public mults32 extrn multus32: near mults32 proc near mov semn_rez,0 ;se initializeaza semnul cu 0 (adica +) cmp dx,0 ;se testeaza semnul deinmultituluijns test_op_doi jns test_op_doi ;daca este pozitiv se va testa al doilea operand mov semn_rez,1 ;primul operand este negativ, si se completeaza neg ax ;incepand cu al doilea cuvant jnc negdx ;daca acesta este 0, se va completa primul cuvant not dx ;astfel se vor inversa toti bitii primului cuvant jmp test_op_doi ;test cel de-al doilea operand negdx : neg dx ;se complementeaza primul cuvant al operandului jc depasire ;daca (CF)=1 => nu se poate complementa cel mai mic

4

;nr negativ, ce se paote reprezenta pe 32 biti test_op_doi: cmp cx,0 ;se testeaza semnul celui de-al 2 lea operand, si daca jns multiply ;este pozitiv realizeaza inmultirea xor cs:semn_rez,1 ;semn_rez este complementat (0->1,1->0) compl2: neg bx ;si se completeaza al 2 lea operand, la fel ca primul jnc negcx not cx jmp multiply negcx: neg cx jc depasire multiply: call multus32 dec cs:semn_rez ;daca rez = 0, => nr se completeaza jnz gata ;daca est <>0, nr obtinut este cel corect (rez pozitiv) neg ax ;se incepe complementarea rez cu ultmul cuvant jc notbx ;daca (AX)<>0 se vor nega celelalte registre neg bx ;daca (AX)=0, se va complementa (BX) jc notcx ;daca (BX)<>0 se vor nega registrele ramase neg cx ;daca (BX)=0, se va completa (CX) jc notdx ;daca (CX)<>0, se va nega registrul (DX), ultimul neg dx ;se complementeaza (DX); nu putem avea depasire jmp gata notbx: not bx notcx: not cx notdx: not dx gata: clc ;(CF)=0, rezultat corect depasire: ret ;(CF)=1, unul dintre operanzi nu poate fi complementat semn_rez db 0 mults32 endp 5.5. Împartirea fara semn a unui deimpartit de 32 biti la un impartitor de 16 biti ---- catul este pe 32 biti, iar restul pe 16 biti Procedura de impartire primeste: (DX,AX)=(A1,A0) – deimpartit (32 biti), (BX) = (B) – impartitor (16 biti), si va returna (BX,AX)=(Q1,Q0) – catul, (DX)=(R0) – restul. Împartirea se realizeaza astfel A1*216+A0=(Q1*216+Q0)*B+R0, unde Q1=[A1/B] si deci A1=Q1*B+R1. Inlocuind => R1*216 + A0 = Q0 * B + R0 div32 proc push cx cmp bx, 0 ;impartitor = 0? jnz cdiv int 0 jmp eroare cdiv: push ax mov ax, dx sub dx, dx div bx pop cx push ax mov ax, cx div bx pop bx pop cx ret eroare: push dx lea dx, mes_err_div mov ah, 9 int 21h pop dx pop cx ret div32 endp 6.1. Adunarea a doua numere zecimal neimpachetate (ASCII)

5

addzn16 proc near push cx mov ch, ah add al, bl aaa xchg al, ch adc al, bh aaa mov ah, al pop cx addzn16 endp 6.2. Inmultirea a doua numere zecimal neimpachetat (de cate doua cifre) ; (BX) = inmultitor zecimal neimpachetat (2 cifre) ; (AX) = deinmult zecimal neimpachetat (2 cifre) ; (DX:AX) = rez neimp (4 cifre: DH,DL,AH,AL ) multzn16 proc near push bx push cx aad mov ch, al mov ax, bx aad mov bl, al mov al, ch mul bl cwd mov cx, 1000 dir cx xchg ax, dx mov dh, dl mov cl, 100 div cl mov dl, al mov al, ah cbw mov cl, 10 div cl xchg ah, al pop cx pop bx ret multzn16 endp 6.3. Împartirea a doua numere, zecimal neimpachetate pe 16 biti (divzn16) divzn16 proc near push bx push cx aad mov cx, ax mov ax, dx aad mov dl, 100 mul dl add cx, ax mov ax, bx aad mov bl, al mov ax, cx div bl mov bl, 99 cmp bl, al

6

jc gata cmp bl, ah jc gata mov bl, al mov al, ah aam mov dx, ax mov al, bl aam clc gata: pop cx pop bx ret divzn16 endp 6.4. Conversie din binar (16 biti) in zecimal neimpachetat/impachetat (binzn/binbcd) binzn proc near push bx push dx push di mov bx, 100 mov dx, 0 div dx push ax mov ax, dx aam stosb mov al, ah stosb

pop ax mov dx, 0 div bx push ax mov ax, dx aam stosb pop al, ah stosb pop ax stosb pop di pop dx pop bx ret

binzn endp 6.5. Conversie zecimal impachetat – binary (bcdbin) bcdbin proc near push cx push dx push di push si mov si, ax sub ax, ax call conv_bcd_bin pop si pop di pop dx pop cx ret bcdbin endp conv_bcd_bin proc near mov cx, 4 nextcif:push cx

7

mov cx, 4 mov di, 0 nextdig:shl si, 1 rcl di, 1 loop nextdig mov cx, 10 mul cx add ax, di pop cx loop nextcif ret conv_bcd_bin endp 7.1. Deplasare la stanga, pt un operand de 32 biti (sal32) sal32 proc near cmp cl, 0 je gata push cx push di push si sub di, di sub ch, ch shift: sal ax, 1 rcl dx, 1 jno cont continua mov di, 800h cont: loop shift pushf pop si or si, di push si popf pop si pop di pop cx gata: ret sal32 endp 7.2. Deplasare aritmetica la dr, pt un operand de 32 biti (sar32) sar32 proc near cmp cl, 0 je gata push cx sub ch, ch shift: sar dx, 1 rcr ax, 1 loop shift pop cx gata: ret sar32 endp 7.3. Rotire la stanga (dreapta) pt valori de 32 biti, fara ‘carry’ (rol32/ror32) rol32 proc near cmp cl, 0 je gata push cx sub ch, ch rotire: sal dx, 1 pushf rcl ax, 1 adc dx, 0 popf

8

loop rotire pop cx gata: ret rol32 endp ror32 proc near cmp cl, 0 je gata push cx sub ch, ch rotire: shr ax, 1 pushf rcr dx, 1 jnc refa_cf or ax, 8000h refa_cf: popf loop rotire pop cx gata: ret ror32 endp 7.4. Rotire la stanga(dreapta) pt valori de 32 biti, cu ‘carry’ (rol32/ror32) rcl32 proc near pushf cmp cl, 0 jne cont popf ret cont: popf push cx mov ch, 0 rot: rcl ax, 1 rcl dx, 1 loop rot pop cx ret rcl32 endp rcr32 proc near pushf cmp cl, 0 jne cont popf ret cont: popf push cx mov ch, 0 rot: rcr dx, 1 rcr ax, 1 loop rot pop cx ret rcr32 endp 9.1. Concatenarea a doua siruri Cel de-al 2 –lea şir este concatenat la sfarsitul primului, iar sirurile sunt considerate în aceleaşi segment, DS=ES. ;intrari (DI)=offset sir1, (BX)=lungimea sir1 (sirurile sunt in acelasi segment) (SI)=offser sir2, (CX)=lungimea sir2 ;iesiri (ZF)=0, operatia efectuata, (SI)=noul offset al celui de-al 2 lea sir, (BX)=lungimea toatala, dupa concatenare (ZF)=1, operatie neefectuata, fie un sir este vid, fie el 2-lea este deja concatenat cu primul; registrele vor ramane nemodificate

9

dim2 dw ? ;salvare dimensiune initiala cel de-al doilea sir (CX) off1 dw ? ;salvare offset initial primul sir (DI) concat proc near jcxz iesire ;daca unul din siruri este vid se termina procedura cmp bx,0 je iesire mov dim2, cx ;salvare dimensiune sir 2 mov off1, di ;salvare offset sir 1 add di,bx ;adresa de concatenare a celui de-al doilea sir cmp si,di ;test daca cel de-al doilea sir se afla deja aici je gata ;adrese diferite -> nu este -> se concateneaza conc: cld rep movsb ;concatenarea celui de-al doilea sir sub di,dim2 ;adresa de inceput a sirului concatenat mov si, di ;se returneaza in (SI) add bx, dim2 ;actualizarea adresei celui de-al doilea sir gata: mov di, off1 ;refacerea registrelor modificate mov cx, dim2 iesire: ret concat endp 9.2. Cautarea unui subsir într-un sir ;intrari: (DI)=offset sir in care se cauta, (BX)=lungime sir ; (SI)=offset subsir gasit, (CX)=lungime subsir ;iesiri: (ZF)=0, subsir gasit, (DX)= offset-ul sirului gasit (ZF)=1, subsirul nu a fost gasit:(DX)=offsetul de inceput pt ultima cautare, sau (DX) = 0, daca subsir >sir stop dw ? ;locatie oprire cautare aici dw ? ;locatie curenta de cautare salv_si dw ? ;salvare (SI) initial salv_cx dw ? ;salvare (CX) initial cautsub proc jcxz gata ;subsir vid cmp bx, 0 ;test lungime sir je gata ;sir vid cmp cx,bx ;compar lungime subsir cu cea a sirului in care se cauta jc caut ;daca lungime subsir <sir, se continua cautarea je caut ;se cauta si daca cele doua lungimi sunt egale sub dx,dx ;daca lungime subsir > sir -> DX=0, ZF=1 jz gata caut: push bx push di mov salv_si, si mov salv_cx,cx add bx, di ;locatia de terminare a cautarii in sir sub bx, cx ;locatia de inceput a ultimei cautarii: sf_sir – lung_sir + 1 inc bx mov stop, bx ;salvata la adresa ‚stop’ mov aici, di ;salvare adresa de inceput a cautarii cld cautare: repe cmpsb ;repeta cautarea cat timp sunt egale je gasit ;daca la terminarea repetarii (ZF)=1 s-a gasit subsirul inc aici ;astfel nu s-a gasit, se continua cautarea cu urmatoarea locatie mov di, aici cmp di, stop ;s-a ajuns la sfarsit ? je ref_reg ;da si nu s-a gasit subsirul, se refac registrele mov cx, salv_cx ;se reia cautarea mov si, salv_si jmp cautare gasit: or cx,1 ;s-a gasit se pune (ZF) = 0 ref_reg: ;se refac registrele salvate mov dx, aici ;adresa unde a ajuns ultima cautare

10

pop di pop bx mov cx, salv_cx mov si, salv_si gata: ret cautsub endp 9.3 Stergerea unui subsir dintr-un sir ;intrari: (DI)=offset, (BX)=lungime sir ; (SI)=offset, (CX)=lungime subsir ;iesiri: (ZF)=0, operatie efectuata, (bX)= lungimea curenta a sirului obtinut (ZF)=1 nu s-a efectuat operatia de stergere (subsir > sir, offset subsir în afara sirului, siruri vide) si (BX) = nemodificat sf_sir dw ? ;offset sfarsit sir + 1 sterge_sub proc jcxz gata ;subsir vid cmp bx,0 je gata ;sir vid cmp cx, bx ;se compara cele doua dimensiuni (subsir/sir) ja pune_zf ;subsirul este mai mare decat sirul cmp si, di ;este subsirul in afara limitelor jb pune_zf ;daca da se termina proc şi seteaza (ZF) mov sf_sir, di ;salvarea offsetului sirului add sf_sir, bx ;s-a determinat adresa de sfarsit +1, a sirului cmp si, sf_sir ;depaseste subsirul limita sirului ? jb sterge ;daca nu se efectueaza stergerea pune_zf: cmp cx,cx ;(ZF) = 1 jmp gata sterge: ;eliminarea subsirului se face prin mutarea, din sirul dat, ;subsirul de la adresa (SI) + (CX) la adresa (SI) push di ;salvarea registrelor de lucru push si push cx cld ;directia de parcurgere mov di, si ;se initializeaza destinatia add si, cx ;si sursa transferului sub sf_sir, si ;contor numar de octeti de transferat mov cx, sf_sir shr cx,1 ;facem transferul pe cuvinete (mai rapid/sau pe dublu cuv) jnc transf_cuv ;avem un nr par de octeti movsb ;se transfera un octet (daca nr lor este impar) jcxz term_transf ;s-a terminat tranf ( a fost un singur octet) transf_cuv: rep movsw ;se transfera subsirul, la nivel de cuvant term_transf: pop cx ;refacerea resurselor salvate pop si pop di sub bx,cx ;actualiz lungime sir, dupa stergerea subsir, (ZF) = 0 gata: ret sterge_sub endp 9.4. Inserarea unui sir într-un alt sir ;intrari: (DI)=offset, (BX)=lungime sir, in care se insereaza (SI)=offset, (CX)=lungime sir deinserat (BP)=offsetul punctului de inserarea ;iesiri: (ZF) =0, oper efect, (BX) = lung totala a sirului obtinut (SI) = noul offset al sirului inserat (ZF) = 1nu s-a efectuat oper de ins (lungimi 0, al doilea sir era deja inserat, offs. de inserare este in afara sirului) off1 dw ? ;spatiu intre offset sir si

11

dim2 dw ? ;dimensiune subsir de inserat insert_sir proc jcxz gata ;sirul de inserat este vid cmp bx, 0 je gata ;sirul in care se insereaza este vid mov dim2, cx mov off1, di add di, bx ;offsetul de sfarsit (+1) al primului sir cmp si, di ;este al 2-;ea sir deja inserat? (adr. Inceput sir1 > sf. Sir2) ja insert ;nu, se face inserarea push si add si,cx ;offsetul de sfarsit (+1) al celui de-al 2 lea sir cmp si, off1 ;se testeaza daca adresa de inceput a sirului 2 este in primul pop si jbe insert ;daca nu, se face inserarea sub di, di ;daca da, nu se mai insereaza si (ZF) =1 jz iesire insert: std ;directie de parcurgere este de la sfarsit la inceput, pt push si ;a nu se scrie peste urmatorii octeti dec di ;initializare adrese pentru a crea spatiu pt sirul inserat mov si,di add di,cx ;adresa de sfarsit a subsirului transferat rep movsb ;transfera restul din primul sir la sfarsit cld ;se va insera sirul de la inceputul zonei eliberate pop si ;refacerea adresei de inceput a sirului de inserat mov cx, dim2 ;contor numar de octeti transferati mov di, bp ;offsetul destinatie al transferului rep movsb ;inserarea propriu-zisa mov si,bp ;noul offset al sirului inserat add bx, dim2 ;actualizare lungime sir 1 iesire: mov di,off1 ;refacere (DI) mov cx,dim2 ;si (CX) gata: ret insert_sir endp 9.5. Copierea unui subsir într-un sir ;intrari: (DI)=offset, (BX)=lungime sir, in care se copiaza (SI)=offset, (CX)=lungime sir de copiat (BP)=offsetul de destinite in sir, pt copiera ;iesiri: (ZF) =0, oper efect, (BX) = lung este nemodificata (SI) = noul offset al sirului copiat (BP) = offset subsir copiat (ZF) = 1nu s-a copiat (siruri vide, subsirul este in sir sau subsirul >sir) off1 dw ? ;salvare offset sir (DI) dim2 dw ? ;salvare lungime subsir (CX) estrn mutabloc: near copiere_subsir proc jcxz gata ;sirul de copiat este vid cmp bx, 0 je gata ;sirul in care se copiaza este vid mov dim2, cx mov off1, di cmp cx,bx ;este subsirul mai mic decat sirul? jae err_cop ;nu -> nu se face copierea add di, bx ;offsetul de sfarsit (+1) al sirului cmp di, si ;este subsirul in sir? jae err_cop ;da -> nu se mai copiaza cmp si, off1 ;este subsirul in sir? jb err_cop ;da -> nu se mai copiaza add cx, si ;(CX) pozitionat la sfarsitul subsirului (+!) cmp bp,di ;este dest <= sfarsit sir? jae err_cop ;nu -> nu se mai copiaza

cmp bp,off1 ;este dest <= sfarsit sir?

12

jb err_cop ;nu -> nu se mai copiaza mov ax,di ;test depasire spatiu rezervat sirului in care se copiaza sub ax, bp ;octetii ramasi disponibili pt copiere cmp ax, dim2 jc err_cop ;daca nu, se termina mov cx, dim2 mov di, bp call mutabloc mov si, bp ;noul offset subsir gata: mov di, off1 mov cx, dim2 iesire: ret err_cop:

sub di, di ;eroare -> (ZF) =1 ret copiere_subsir endp 9.6. Determinarea maximului (minimului) -dintr-un sir de cuvinte (octeti), fara semn (cu semn) ;intrari: (SI),(CX) = offsetul si lungimea sirului în care se cauta ;iesiri (ZF)=1, s-a determ maximul (min), returnat in (AX), (ZF) =0, sir vid cuv_det_maxim proc cmp cx, 0 ;sir vid ? jnz maxim ;nu, se determina maximul cmp cx, 1 ;(ZF) = 0, sir vid, se termina procedura ret maxim: push bx push si lodsw ;prima valoare din sir mov bx, ax ;se initializeaza maximul din sir jcxz gata ;s-a terminat sirul (a avut o sing valoare) caut_max: lodsw ;citeste urmatoarea valoare din sir cmp ax,bx ;compar cu maximul {pt min in loc de „jbe”->”jae”} jbe next ;daca este <= maxim se trece la urmatorul (pt valorile cu semn ;atunci in loc de „jbe” se pune „jle” {minim „jge”} mov bx, ax ;daca ete > se inlocuieste maximul anterior cu cel nou gasit next: loop caut_max ;se continua pana (CX) = 0 gata: mov ax, bx ;returnez maximul in (AX) cmp ax,ax ;(ZF) =1 semnaleaza ca procedura returneaza maximul pop si pop bx ret cuv_det_maxim endp Înlocuind registrul (AX) cu (AL) se obtine procedura de det max pt o valoare de tip octet, într-un sir de octeti (idem pt AX cu EAX -> det max de tip dublu cuv). 9.7. Adauagarea unui cuvant (octet) la sfarsitul unui sir ;intrari (SI), (CX) = offsetul si lungimea sirului in care se adauga (AX( = valoarea de adaugat la sfarsitul sirului ;iesiri (CX) <- (CX) + 1 cuv_adaug_sir proc push si add si, cx ;adresa unde trebuie adaugat cuvantul mov [si],ax inc cx ;actualizare contor sir pop si ret cuv_adaug_sir endp

13

Înlocuind registrul (AX) cu (AL) se obtine procedura de adaugare pt o valoare de tip octet, într-un sir de octeti (idem pt AX cu EAX -> adaugare de tip dublu cuv). 9.8. Stergerea unui octet dintr-un sir, de octeti, neordonat ;intrari (SI), (CX) = offsetul si lungimea sirului in care se cauta (SI) = offsetul elementului de sters ;iesiri (CF) = 1, nu s-a sters val -> (SI)=offsetul ei in afara sirului (sau sir vid) (CF) = 0, (CX) <- (CX) – 1 oct_sterg proc push cx add cx, si ;adresa ultimului element din sir (+1) cmp di, cx ;compar offset elem de sters cu ultimul din sir jae afara ;daca este in afara sirului se termina proc cmp di,si ;compar cu primul element din sir jae sterg ;este dupa primul, deci se poate sterge afara: stc ;nu este in sir si deci se term proc pop cx ret ;stergerea se face prin deplasarea elementelor urmatoare celui ;de sters cu o pozitie la stanga sterg: push si sub cx,di ;se determina nr de elemente de deplasat dec cx mov si, di ;sursa este dest +1 inc si cld rep movsb ;deplasarea sirului cu un octet, peste cel de sters pop cx dec cx ;actualizare contor sir pop si ret oct_sterg endp 9.9 Ordonarea crescatoare a unui sir de cuvinte (octeti) -folosind metoda bulelor (inversiunilor) ;intrari (SI),(CX) = offsetul si lungimea sirului de ordonat Se considera cuvintele fara semn inv dw ? ;se memoreaza daca au avut loc inversiui ord_bule proc jcxz revin cmp cx,1 ;daca sirul are un singur element se termina procedur jz revin ;intrucat nu avem ce ordona push cx dec cx ;nr de comparatii este = lungime_sir – 1 cld ;diretie de parcurgere reia_ord: push si ;salvare adresa de inceput a sirului si push cx ;contorul (nr) de comparatii mov inv, 0 ;initializare indicator de inversiuni cont_ord: lodsw ;citire cuvant in (AX); (SI) actualizat automat – va referi cmp ax, [si] ;urmatorul element, apoi se compara (AX) cu acesta jbe next ;daca e ord. Trece la urm. (cu semn, in loc de „jbe”->”jle”) xchg ax,[si] ;daca nu, se inverseaza cele 2 cuv si mov [si-2],ax ; mov inv,1 ;se memoreaza ca s-a facut cel putin o inversiune next: loop cont_ord ;se continua parcurgerea sirului pana la sfarsit pop cx ;se reface contorul si adresa de inceput a sirului pop si cmp inv,1 ;au fost inversiuni jz reia_ord ;daca da, se reia odonarea de la inceput pop cx ;refacerea contorului initial revin: ret ord_bule endp

14

9.10. Ordonarea crescatoare a unui sir de octeti .mode small .stack 100h .data Vector db ‚130874563108746510354’,13,10 ;Vectorul de sortat + CRLF nElem EQU $ - Vector – 2 ;nr de elemente de sortat .code start: mov ax, @data ;setare segment de date mov ds, ax xor di,di ;di = primul index cmp di, nElem ;verifica daca sunt elemente in vector jge iesire ;daca nu, iesire prematura for_i_start: mov si,di ;si = al doilea index inc si cmp si, nElem jge for_i_stop for_i_start: mov al,Vector[di] cmp al,Vector[si] ;verifica ordinea jbe for_i_stop xchg al,Vector[si] ;inverseaza elementele mov Vector[di], al for_i_stop: inc si cmp si, nElem jl for_i_start for_i_stop: inc si cmp di, nElem jl for_i_start ;afisare elemente sortate mov ah, 40h ;scrie la handle mov bx, 1 ;handle = ecran (stdout) mov cx, nElem ;nr de caractere de scris add cx,2 ;adauga linie noua (CRLF) mov dx, offset Vector int 21h ;scrie elementele iesire: mov ax, 4c00h ;iesire program int 21h end start 9.11. Cautarea unei octet (cuvant) intr-un sir ordonat crescator - pt cautare se utilizeaza o metoda de cautare binara ;intrari (DI),(CX)=offsetul si lungimea sirului in care se cauta (AL) sau (AX) = valoare cautata ;iesiri (ZF) = 1, s-a gasit valoarea cautat -> (SI)=offsetul acesteia (ZF) = 0, nu s-a gasit valoarea, (SI) = offsetul ultimului elem din sir contor dw ? ;salvare contor sir caut_bin proc mov si,di ;copie offset mov ontor,cx ;salvare contor sir jcxz nu_gasit ;sir id -> termin cautarea cmp al, [di] ;(AL) <= primul element je gasit jb nu_gasit ;este mai mica decat prima val sin sir (cea mai mica) add si,cx ;offsetul ultimului element (+1) dec si

15

cmp al, [si] ;se compara cu ultimul elem din sir je gasit ;este chiar ultimul ja nu_gasit ;este > cel mai mare elem din sir ;aici incepe cautarea propriu-zisa mov si, di ;se compara cu elem din mijl sirului shr cx,1 ;index/2, cautarea ia sfarsit cand este gasit sau cand index = 0 add si, cx ;offsetul elem din mijloc compar: jcxz nu_gasit ;index = 0 se termina cautarea cmp al,[si] ; este valoarea = elementul curent ? je gasit ;da, s-a gasit ja urmator ;nu, se continua cautara in jumatatea superioara ;valoarea cautata poate fi in prima jumatate (rmasa din sir prin injumatatiri succesive) shr cx,1 ;injumatatire index sub si,cx ;modificarea adresei de inceput a cautarii(este in 1 jum) jmp compar ;reia cautarea urmator: shr cx,1 ;injumatatire index add si,cx ;actualizarea adresei de cautare (este in cea de-a 2 jum) jmp compar ;reia cautarea nu_gasit:

or cx,1 ;nu s-a gasit, se pune (ZF) = 0 gata: mov cx,contor ;refacera contorului caut_binar endp Înlocuind registrul (AX) cu (AL) se obtine procedura de cauate binara pt o valoare de tip cuv, într-un sir de cuv (idem pt AX cu EAX -> cauatare dublu cuv). 9.13. Inserarea unui octet (cuvant) intr-un sir ordonat ;intrari (DI),(CX) = offsetul si lungimea sirului in care se cauta (AL) sau (AX) = valoarea de inserat ;iesiri (ZF) =1, valoarea este deja in sir -> (SI) = offsetul acesteia, (ZF) =0,s-a inserat valoarea, (SI) = offsetul acesteia, (CX) <- (CX) + 1 extrn caut_binar: near public oct_insert_bin oct_insert_bin proc cmp cx,0 ;este sirul vid ? jnz caut ;daca nu, se cauta pozitia de inserare mov [di],al ;se memoreaza octetul la prima adresa (sirul era vid) jz gatai caut: push cx call caut_binar ;apel procedura de cautare binara jnz compara ;testez (ZF), daca (ZF) = 1 valoarea exista pop cx ;si nu mai trebuie sa o inseram ret ;nu s-a gasit, determinam daca se insereaza chiar prima sau dupa ultima valoare din sir compara cmp al, [si] ;este octetul curent > valoarea de inserat? jb face_lo ;nu -> trebuie pus pe prima pozitie -> se face loc inc si ;da -> muta elementul cautat ;se face loc pt noul octet si se insereaza face_loc: push es ;salvare (ES) push ds pop es ;initializare (ES)=(DS) push di ;salvare offset de inceput push si ;si pointerul curent add di, cx ;destinatia transferului: adr. Sfarsit + 1 inc di sub cx, si ;nr de octeti de mutat inc cx mov si,di ;adresa sursei ec si std ;transferul se face incepand cu sfarsitul sirului

16

rep movsb ;transferul propriu-zis pop si ;pozitia de inserare mov [si], al ;inserare pop di ;refacere resurse pop es ;refacere (ES) pop cx inc cx ;actualizarea contor sir cmp cx,cx ;pozitia (ZF) =0, adica operatia efectuata gatai: ret oct_insert_bin endp 9.14. Stergerea unui octet (cuvant) dintr-un sir ordonat crescator ;intrari (DI),(CX) = offsetul si lungimea sirului in care se cauta (AL) sau (AX) = valoare de eliminat ;iesiri (ZF) = 0, valaorea nu este in sir (ZF) = 1, s-a eliminat valoarea, (CX) <- (CX) -1 (DI) si (AL) sau (AX) nu vor fi modificate extrn caut_binar: near public oct_sterge_bin oct_sterge_bin proc push si push cx jcxz not_gasit ;sir vid call caut_binar jz sterge ;daca l-a gasit il sterg, (ZF)=1 not_gasit: or cx,1 ;(ZF) =0, deci valoarea nu este in sir pop cx ;daca nu l-a gasit se termina procedura pop si ret ;s-a gasit valoarea in sir si de sterge prin deplasarea elementelor din dreapta sa sterge: push di push es ;salvare (ES) push ds pop es ;initializare (ES)=(DS) add cx,di ;se calculeaza nr de octeti de mutat sub cx,di ;(DI)+(CX)-(SI)-1 dec cx ;contor numar de octeti de deplasat mov di,si ;destinatia incepe de la pozitia celui sters inc si ;sursa transferului incepe de la primul octet, dupa cel sters cld rep movsb ;deplasarea la stanga cu un octet pop es pop di pop cx dec cx ;actualizare contor, dupa stergere cmp cx,cx ;pozitionare (ZF) =1, adica operatie realizata pop si ret oct_sterge_bin endp 9.15. Construirea unei liste inlantuite (de tip coada) de cuvinte .model small .data dim_cuvant equ 15 lista_tip_coada struc next dw 0 cuvant db dim_cuvant dup (odh); dimensiune maxima cuvant lista_tip_coada ends lung_lista equ 80 lista lista_tip_coada lung_lista dup (<>) mesprg

17

9.17. Evaluarea expresiilor in notatie postfixata .model small .stack 100h .data expresie db ‚1234+++4*9-9-9-9-9-1*8+’, 0 .code mov ax, @data ;setare segment de date mov ds,ax mov si, offset expresie bucla: lodsb ;ia un caracter din string or al,al ;e caracter terminator? jz iesire ;daca da, iesire din program cmp al, ‘+’ ;e plus? je plus cmp al, ‘-‘ je minus ;e minus? cmp al, ‘*’ je inmultire sub al, ‘0’ ;aici testam pt un operand xor ah,ah ;il extindem pe 16 biti push ax ;si il punem pe stiva jmp bucla plus: pop bx ;aduna pop ax add ax,bx push ax jmp bucla minus: pop bx pop ax sub ax,bx push ax jmp bucla inmultire: pop bx pop ax imul bx push ax jmp bucla iesire: pop ax ;extrage rezultat din stiva mov ax, 4c00h ;iesire in DOS int 21h end 8.1. Conversie din binar in zecimal impachetat (BCD) – (bin2bcd) ;intrare (AL) = nr de convertit (<100) ;iesire daca (CF) = 0, rez corect, in (AL) sunt cele 2 cifre Daca (CF) =1, nr prea mare, in (AL) este valoarea initiala bin2bcd proc near cmp al, 99 ;este valoarea corecta jbe conv ;daca da se converteste stc ;altfel se seteaza (CF) jc gata ;si se termina procedura conv: push cx ;salvare registru de lucru push ax ;salvare registru de lucru (AH),valoarea de convertit este in (AL) aam ;conversia propriu-zisa: (AH)=cifra zecilor,(AL)=cifra unitatilor mov cl,4 ;contor deplasare cifra zecilor or al, ah ;impachetarea celor doua cifre

18

pop cx ;refacerea registrului (AX) salvat, in (CX) mov ah, ch ;refacere (AH) pop cx ;refacere (CX) gata: ret bin2bcd endp 8.2. Conversie din BCD impachetat in binar (bcd2bin) ;intrare (AL) = nr BCD, de convertit (maxim 99) ;iesire daca (CF) = 0, rezultat corect, in (AL) valoarea binara daca (CF) = 1,nr prea mare, in (AL) este valoarea initiala bcd2bin proc cmp al, 99h ;este valoarea zecimala corecta pt conversie? jbe conv ;daca da se converteste stc ;altfel se seteaza (CF) jc gata ;si se termina proc conv: push cx ;salvare registru de lucru push ax ;salv reg de lucru (AH), val de convertit este in (AL) mov cl,4 ;contor deplasari pt cifra zecilor shr al, cl ;deplasare cifra zecilor mov ah,al ;cifra zecilor in (AH) pop cx ;refacerea lui (AX) in (CX); intereseaza doar (AL) and cl, oFh ;se retine doar cifra unitatilor mov al,cl ;cifra unitatilor este in (AL) aad ;(AL) = (AH) * 10 + (AL) mov ah, ch ;refacere (AH) pop cx ;refacere (CX) gata: ret bcd2bin endp 8.3. Conversie din binar in hexazecimal (ASCII) (binhex) ;intrari (AL) – valoare intre 0-15 ;iesiri (AL) un caracter ASCII (‘0’-‘9’ sau ‘A’-‘F’) daca valoarea este coreta (CF) = 0, (AL) = caract ASCII daca valoarea este invalida (CF) = 1 si (AL) nemodificat binhex proc cmp al,9 ja litera add al, 30h ;codul ASCII pentru cifre ret litera: cmp al, 15 ja eroare ;daca este mai mare ->eroare add al,37h ;codul ASCII pt litere A-F ret eroare: stc ;iesire cu eroare (CF = 1) ret binhex endp Conversia se poate realiza utilizând si instructiunea de conversie de cod (XLAT), cu exemplul urmator, care afiseaza, in hexazecimal, valoarea de la adresa ‘val’, din segm de dim ‘hexa’. hexa segment word public ‘data’ val dw oabcdh; valoare de convertit si afizat in hexazecimal val_hexa db 4dup (?),0dh,0ah,’$’; rezervare pt codurile ASCII tab db ‘0123456789acdef’ ;tabela de conversie hexa ends prog segment word public ‘code’ assume cs:prog, ds:hexa start: mov ax,hexa ;initializare registru segment DS mov ds,ax ;cu adresa segmentului de date: hexa mov dx,val ;valoarea de tiparit in hexazecimal

19

and dx, 0ff00h ;se retin doar primele doua cifre hexa mov dl,dh ;deci primii 8 biti, se se transmit in DL lea si, val_hexa ;adresa unde se depun codurile ASCII call conv ;proc de conversie binar-hexa (ASCII) mov dx, val ;se refacere valoarea initiala and dx, 0ffh ;se retin ultimii 8 biti (ultimele 2 cifre hexa) call conv ;conversia ultimelor doua cifre hexa lea dx, val_hexa ;adresa codurilor ASCII ale cifrelor ASCII mov ax, 9 ;apel functia 9, DOS, de tiparire mesaj int 21h mov ax, 4c00h ;revenire dos int 21h conv: proc ;procedura tipareste in hexa valoarea din DL mov al, dl ;se transfera in AL mov cl,4 ;se vor deplasa (logic) primi patru biti shr al, cl ;pr ultimele 4 pozitii lea bx,tab xlat tab ;se face conversia acestei valori la codul ASCII mov [si],al ;se depune prima cifra ASCII la adresa val_hexa inc si ;se incrementeaza adresa pt urmatoarea cifra mov al, dl ;se reface valoarea transmisa in DL and al,0fh ;si se vor retine din aceasta doar ultimii 4 biti xlat tab ;se face conversia acestei tetrade in ASCII mov [si], al ;se depune codul in memorie la adresa urmatoare inc si ;se actualizeaza adresa pt urmatoarele cifre ret ;revenire din procedura conv: endp prog ends stiva segment word stack ‘stack’ dw 100 dup(?) ;rezervare memorie pt segm de stiva stiva ends 8.4. Conversie din binar in octal (ASCII) date_oct segment word public ‘data’ val dw 12345q date_oct ends prog segment word public ‘code’ assume cs:prog, ds: date_oct start: mov ax, date_oct mov ds, ax mov dx, val rol dx, 1 mov al, dl and al, 1 add al, 30h call tip_car mov cx, 5 reia: push cx mov cl, 3 rol dx, cl mov al, dl and al, 7 add al, 30h call tip_car pop cx loop reia mov ax, 4c00h int 21h tip_car proc near push dx mov dl, al mov ah, 2 int 21h

20

pop dx ret tip_car endp prog ends stiva segment word stack ‘stack’ dw 100 dup(?) stiva ends end start 8.5. Conversie din hexazecimal (ASCII) in binar (hexbin) hexbin proc cmp al, ‘0’ jc gata cmp al, ‘9’ jbe cifra cmp al, ‘A’ jc gata cmp al, ‘F’ jbe litera stc ret cifra: and al, 0fh ret litera: and al, 0fh add al, 9 gata: ret hexbin endp 8.5. Conversie nr binar, fara semn (16 biti), in zecimal-ASCII(ubin2ascii) public ubin2ascii ubin2ascii proc near push bx push dx push ax mov bx, 100 mov dx, 0 div bx push ax mov ax, dx aam add ax, 3030h mov [di+4], al mov [di+3], ah pop ax mov dx, 0 div bx push ax mov ax, dx aam add ax, 3030h mov [di+2], al mov [di+1], ah pop ax add al, 30h mov [di], al mov byte ptr [di+5], 0 pop ax pop dx pop bx ret ubin2ascii endp 8.7. Conversie numar binar, cu semn (16 biti), in zecimal-ASCII (sbin2ascii)

21

extrn ubin2ascii:near sbin2ascii proc near push di push ax mov byte ptr [di], ‘+’ cmp ax, 0 jge cont mov byte ptr [di], ‘-‘ neg ax cont: inc di call ubin2ascii pop ax pop di ret sbin2ascii endp 13.1. Scheletul unui program TSR ---Demonstratie instalare/dezinstalare/functionare TSR .model TINY .code org 100h ;program .COM Start: jmp short Initializare StringID db “TSR_ID_CLK” ;acest ID este utilizat in identificarea ;programului in lantul de intreruperi LungimeStringID equ $ - StringID ;lungimea ID-ului pauza equ 5 ;se poate ajusta video equ 0B800h ;adresa video text contor db pauza ;contor pt pauza AdresaVeche: dd ? ;adresa vechii rutine de intrerupere NouaAdresa: cli dec cs:contor ;DS poate fi oriunde jnz Continua ;Contorul nu a ajuns la 0 push ax ;suntem in intrerupere…. push es mov al,pauza mov cs:contor, al ;reseteaza contorul mov ax,video ;aici executam “tinta” intreruperii mov es,ax inc es:byte ptr [0] ;in cazul nostru incrementam primul caract in ecran pop es pop ax Continua: sti ;cheama adresa veche jmp cs:dword ptr [Adresa Veche] SfarsitINT: ;programul va fi rezident pana la aceasta adresa ;restul poare fi ignorat dupa initialiazare ;aici testam linia de comanda si executam in consecinta Initializare: mov ax,0351Ch int 21h ;preluare si stocare adresa veche mov word ptr [Adresa Veche], bx mov word ptr [Adresa Veche + 2], es mov cl, byte ptr ds:[080h] ;lungimea liniei de comanda xor ch,ch mov di,081h ;inceputul liniei de comanda mov al, ‘/’

22

cld mov si,di push es push ds pop es repne scasb ;scaneaza pt ‘/’ pop es jnz Eroare mov al, [di] ;preluare caracter dupa ‘/’ and al,0DFh ;converteste la litere mari cmp al, ‘D’ je Dezinstaleaza cmp al, ‘T’ je Instaleaza Eroare: mov dx, offset MesajEroare Iesire: mov ah, 09 int 21h ;tipareste mesaj mov ax, 04c00h int 21h ;iese din sistem ;aici se instaleaza rutina de intrerupere Instaleaza: call VerificaInstalare ;verifica daca deja rezident jz EsteDejaInstalat mov ax, 0251 Ch push cs pop ds mov dx, offset NouaAdresa int 21h ;instaleaza rutina proprie in lantul de intreruperi mov dx, offset InstalatOK mov ah,09h int 21h ;tipareste mesaj mov dx, offset SfarsitINT ;se ia sfarsitul rutinei mov cl,4 ;se imparte la 16 si se shr dx,cl ;calculeaza necesarul de memorie in paragrafe inc dx ;Adaugam 1 pentru erori de rotunjire mov ax, 03100h int 21h ;iesire din program rezident Dezinstaleaza: call VerificaInstalare jnz AFostNeinstalat push ds ;ES acum arata catre copia rezidenta in lant mov dx, word ptr es: [AdresaVeche] mov ax, word ptr es: [AdresaVeche + 2] ;de aici luam adresa vechii mov ds, ax ;intreruperi din lant mov ax,0251ch ;si o reinstalam int 21h ;ca prima in lant pop ds ;am scos rutina noastra din lant mov ah, 049h ;ce mai avem de facut este int 21h ;sa dealocam memoria ocupata mov dx, offset DezinstalatOK jmp Iesire ;si executia se termina ;------Rutine utilizate EsteDejaInstalat: mov dx, offset DejaRezident jmp Iesire ;tipareste Mesaj Eroare AFostNeinstalat: mov dx, offset Neinstalat jmp Iesire ;tipareste Mesaj Eroare VerificaInstalare: push bx add bx, StringID – NouaAdresa ;adauga offest pt gasire ID mov di,bx

23

pop bx mov si, offset StringID mov cl, LungimeStringID xor ch,ch repe cmpsb ret ;returneaza True/False in Flag-uri ;------ Declaratii date MesajEroare db ‘Eroare: Parametru incorect!’,0AH,0DH db ‘ Alegeti: /I-instalade sau /D-dezinst!$’ DejaRezident db ‘Eroare: TSR deja rezident!$’ Neinstalat DezinstalatOK InstalatOK end Start 13.2. Program TSR care nr intreruperile de la tastaura .model tiny ;tsr_tast.asm – TSR activ, ce nr intreruperile de la tastatura, dupa ce a fost activat pt a det nr de taste apasate intre 2 apeluri succesive ;se va genera un progr de tipul .COM: tlink/t tast .code org 100h Start: jmp Instalare MyInt9h proc far ;Componenta activa inc cs:KeyCont ;incrementare contor nr de intreruperi tastat jmp cs:OldInt9h ;apelul vechii intreruperi, salvata la OldInt9h MyInt9h endp MyInt9h proc far ;Componenta pasiva a TSR cmp ah,0FFh ;se solicita valoarea contorului? je ReturnCont ;daca da, se returneaza valoarea lu jmp cs:OldInt16h ;altfel urmeaza planul intrerperii originale ReturnCont: mov ax, cs:KeyCont mov cs:KeyCont, 0 ;reinitializare contor la fiecare apel iret MyInt16h endp KeyCont dw 0 ;variabila ce nr intreruperile de la tastatura OldInt9h dd ? ;locatiile unde se salveaza vechii vectori de intrerupere OldInt16h dd ? mesaj db ‘S-a instalat programul ce nr “Nr de taste” apasate.’,0Dh,0Ah,’$’ Instalare: push ds ;salvare DS push cs pop ds ;initializare DS cu CS (unde sunt datele) mov ax, 0 mov es, ax ;initializare ES cu adresa segment a Tab. Vect. Intr(0000h) cli ;dezactivare intreruperi mov ax, es:[9*4] ;citire offset rutina pt Int 9h si mov word ptr OldInt9h, ax ;salvare la OldInt9h mov ax, es:[9*4 + 2] ;citire segment rutina pt Int9h si mov word ptr OldInt9h[2], ax ;salvare la OldInt9h+2 mov word ptr es:[9*4], offset MyInt9h ;inlocuire vector vechi cu cel nou mov word ptr es:[9*4+2],cs mov ax, es:[16h*4] ;aceleasi operatii pt Int 16h mov word ptr OldInt16h, ax mov ax, es:[16h*4+2] mov word ptr OldInt16h[2], ax mov word ptr es:[16h*4+2],offset MyInt16h

24

mov word ptr es:[16h*4+2],cs sti ;reactivare intreruperi ;se termina partea de instalare cu lansarea rezidenta a codului mov ah, 9 ;tiparire mesaj de instalare cod TSR lea dx, mesaj int 21h pop ds ;refacere DS mov dx, offset Instalare + 15 ;se calculeaza spatiul de memorie mov cl,4 ;ocupat de codul rezident, ca nr de paragrafe shr dx, cl mov ax, 3100h ;si se apeleaza functia ce lasa rezident codul int 21h ;din segm curent, pana la offsetul ‘Instalare’ end start ;tsr_tapl.asm – acest program insoteste progr trs_tast.com, ce nr cate taste s-au apasat. ;acesta apeleaza rutina MyInt16h, din tsr_tast, ce a inlocuit Int 16h, pt a afisa nr ;de taste, apasate de la tastatura, aproximat prin nr de intreruperi tasta/2 cseg segment para public ‘code’ assume cs:cseg, ds: cseg mov ax, cseg ;initializare DS mov dx, ax mov ah,9 ;tiparire mesaj lea dx, mes_p int 21h mov ah, 0FF ;apelul Int 16h, cu AH=0FFh, va returna in AX contorul tastelor int 16h ;orice alta valoare in AH va apela vechea Int 16h shr ax,1 ;se imparte la 2 (2 intreruperi pt fiecare tasta apasata) aam ;conversie binar -> zecimal neimpac (contor, AX, este <100) add ax, 3030h ;converie la codurile ASCII mov nr_apasari, ah ;se depun cele 2 cifre in zona textului mov nr_apasari[1],al lea ah,9 int 21h mov ax,4c00h ;revenire DOS int 21h mes_p db 0Dh, 0Ah, ‘Nr aproximativ de taste apasate:’,’$’ nr_apasari db 30h,30h ;valoarea contorului de tiparit db 0Dh, 0Ah,09h, ‘(dupa care contorul este reinitializat cu 0)’, ‘0Dh, 0Ah, ‘$’ cseg ends stiva segment para stack ‘stack’ varf_stiva db 512 dup (‘stack’) stiva ends end

25

5.1. Media aritmetica a unor cuvinte cu semn (semn) ..............................................................1 5.2. Adunarea a doua valori intregi cu semn, de 32 biti ...........................................................1 5.3. Înmulţirea, fara semn, a doi operanzi, de 32 biti ...............................................................2 5.4 Îmnultirea su semn a doi operanzi de 32 biti .....................................................................3 5.5. Împartirea fara semn a unui deimpartit de 32 biti la un impartitor de 16 biti .....................4 6.1. Adunarea a doua numere zecimal neimpachetate (ASCII) ................................................4 6.2. Inmultirea a doua numere zecimal neimpachetat (de cate doua cifre) ...............................5 6.3. Împartirea a doua numere, zecimal neimpachetate pe 16 biti (divzn16) ............................5 6.4. Conversie din binar (16 biti) in zecimal neimpachetat/impachetat (binzn/binbcd) ............6 6.5. Conversie zecimal impachetat – binary (bcdbin) ..............................................................6 7.1. Deplasare la stanga, pt un operand de 32 biti (sal32) ........................................................7 7.2. Deplasare aritmetica la dr, pt un operand de 32 biti (sar32) ..............................................7 7.3. Rotire la stanga (dreapta) pt valori de 32 biti, fara ‘carry’ (rol32/ror32) ...........................7 7.4. Rotire la stanga(dreapta) pt valori de 32 biti, cu ‘carry’ (rol32/ror32) ...............................8 9.1. Concatenarea a doua siruri ...............................................................................................8 9.2. Cautarea unui subsir într-un sir ........................................................................................9 9.3 Stergerea unui subsir dintr-un sir .................................................................................... 10 9.4. Inserarea unui sir într-un alt sir ...................................................................................... 10 9.5. Copierea unui subsir într-un sir ...................................................................................... 11 9.6. Determinarea maximului (minimului) ............................................................................ 12 9.7. Adauagarea unui cuvant (octet) la sfarsitul unui sir ........................................................ 12 9.8. Stergerea unui octet dintr-un sir, de octeti, neordonat ..................................................... 13 9.9 Ordonarea crescatoare a unui sir de cuvinte (octeti) ........................................................ 13 9.10. Ordonarea crescatoare a unui sir de octeti .................................................................... 14 9.11. Cautarea unei octet (cuvant) intr-un sir ordonat crescator ............................................. 14 9.13. Inserarea unui octet (cuvant) intr-un sir ordonat ........................................................... 15 9.14. Stergerea unui octet (cuvant) dintr-un sir ordonat crescator .......................................... 16 9.15. Construirea unei liste inlantuite (de tip coada) de cuvinte ............................................. 16 9.17. Evaluarea expresiilor in notatie postfixata .................................................................... 17 8.1. Conversie din binar in zecimal impachetat (BCD) – (bin2bcd) ....................................... 17 8.2. Conversie din BCD impachetat in binar (bcd2bin) ......................................................... 18 8.3. Conversie din binar in hexazecimal (ASCII) (binhex) .................................................... 18 8.4. Conversie din binar in octal (ASCII) .............................................................................. 19 8.5. Conversie din hexazecimal (ASCII) in binar (hexbin) .................................................... 20 8.5. Conversie nr binar, fara semn (16 biti), in zecimal-ASCII(ubin2ascii)............................ 20 8.7. Conversie numar binar, cu semn (16 biti), in zecimal-ASCII (sbin2ascii) ....................... 20 13.1. Scheletul unui program TSR ........................................................................................ 21 13.2. Program TSR care nr intreruperile de la tastaura .......................................................... 23