trucchi-com

assembler per principianti

Cap. 7 Un esempio

A proposito di utility, che ne dite di un esempio di programmino in assembler che può anche tornare utile in qualche modo? Dunque partiamo:

Vi piacerebbe un programma di pochi bytes che vi da' la data del giorno di Pasqua per l'anno che voi desiderate?. Ci proviamo?. OK, let's go.

Org 0100 ;Istruzione per il compilatore è un .COM

Jmp start ; salta a start

Ag DB ? ;variabile ag con valore indefinito tipo byte

Bg DB ?

Cg DB ?

Hg DB ?

Dg DB ?

Fg DB ?

Kg DB ?

Eg DB ?

Gg DB ?

Mg DB ?

Anno DW ? ;variabile di tipo word

Nocom DB 'Inserire un anno per calcolare la data di Pasqua$'

Noanno DB 'Inserire un anno a 4 cifre (es. 1998)!$'

Messaggio DB 'Il giorno di Pasqua cade il: '

Giorno DB '00/'

Mese DB '00$'

Start:

mov al,[080]; ;all'indirizzo 80 la lunghezza del comando.

cmp al,5 ; se è diverso da 5, non abbiamo inserito la data

jz ok

mov dx, offset Noanno ;punta alla stringa di errore

mov ah, 9 ;per il DOS 9 in ah significa stampa

int 33 ;chiama il DOS

mov ax, 04c00 ;per il DOS 04c in ah significa esci dal progr.

int 33 ;chiama il DOS

Ok: ;questa è l'etichetta a cui saltare

xor bx, bx ;azzera bx

xor ah, ah ;ed anche ah

mov cx, 1000

mov al, [082] ;in al la cifra dei millenni (1 nel nostro caso)

sub al, 48 ;convertila nell'intervallo 0-9

mul cx ;moltiplica per cx

mov bx, ax ;e spostala in bx

xor ah, ah ;azzera di nuovo ah

mov al, [083] ;leggi le centinaia

sub al, 48 ;convertila

mov cx, 100 ;moltiplicatore in cx

mul cx ;esegui la moltiplicazione

add bx, ax ; ed aggiungila alle migliaia

xor ah, ah ; ripeti tutto per le decine

mov cx, 10

mov al, [084]

sub al, 48

mul cx

add bx, ax

mov al, [085]

sub al, 48

xor ah, ah

add ax, bx ;il risultato finale in ax

mov anno, ax ;salvalo in anno

;ora eseguiamo il calcolo vero e proprio

mov dx, 0

mov cx, 19

div cx ;anno /19 quoziente in ax e resto in dx

mov ag, dl

mov dx, 0

mov ax, anno

mov cx, 4

div cx ;anno/4 come sopra

mov bg, dl

mov ax, anno

mov dx, 0

mov cx, 7 ;anno/7

div cx

mov cg, dl

mov al, ag ;hg=19*ag+24

mov ah, 0

mov cl, 19

mul cl

add ax, 24

mov hg, al

mov dx, 0 ;dg=hg mod 30

mov cx, 30

div cx

mov dg, dl

mov al, bg ;kg=5+2*bg+4*cg+6*dg

add al, al

add al, 5

mov bl, al

mov al, cg

mov ah,0

mov cl, 4

mul cl

add bl, al

mov al, dg

mov cl, 6

mul cl

add bl, al

mov kg, bl

mov al, bl ;eg=kg mod 7

mov ah, 0

mov cl, 7

mul cl

mov eg, ah

mov bl, dg ;mg=dg+eg

add ah, bl

mov mg, ah

cmp ah, 9 ;se mg>9 allora vai a L1

ja L1

mov al, 22

mov ah, mg

sub al, ah

mov giorno, al

mov mese, 3 ;marzo

jmp fine

L1:

mov al, mg

sub al, 9

mov fg, al

cmp al, 26

jne L2

mov giorno, 19

move mese, 4 ;aprile

jmp fine

L2:

mov al, fg

cmp al, 25

jne L5

mov ah, dg

cmp ah, 28

je L3

mov giorno, al

mov mese, 4

jmp fine

L3:

mov giorno, 18

mov mese, 4

jmp fine

L5:

mov al, fg

mov giorno, al

mov mese, 4

Fine:

mov bx, offset giorno ;trasforma i numeri in caratteri

mov ah, 0

mov al, gg

mov dx, 0

mov cx, 10

div cx

add dl, 48

add al, 48

mov [bx], al

inc bx

mov [bx], dl

mov bx offset mese

mov al, mese

mov ah, 0

mov dx, 0

mov cx, 0

div cx

add dl, 48

add al, 48

mov [bx], al

inc bx

mov [bx], dl

mov dx, offset messaggio

mov ah, 9

Int 33

Exit:

mov ax, 04c00

int 33

Fine del listato.

Come potete vedere in assembler è molto più complicato e lungo scrivere dei programmi, anche piccoli, per questo ho detto subito che serve per piccole routine dove occorre il controllo sulle operazioni da fare oppure una grande velocità, he si perché in assembler l'esecuzione del programma è velocissima, oserei dire che questo programmino viene eseguito quasi istantaneamente (BOOOOM).

Vi sarete chiesti perché c'è un carattere '$' alla fine delle stringhe da stampare, ebbene è un indicatore che indica al DOS la fine della stringa, infatti non viene neanche stampato.

Bene dopo tutto questo tormentone, vi sembrerà di avere in mano il vostro processore, ma ecco che arriva la randellata:

Ebbene il sistema di programmazione che abbiamo considerato si chiama 'Modo reale'. In che senso? Nel senso che opera in modo aperto verso il sistema, è l'unico programma in esecuzione sul vostro computer, ed inoltre può fare della memoria quello che gli pare. Non vi sembra una cosa potenzialmente pericolosa? pensate con un programmino del genere potrei cancellare il DOS e costringere l'utente a resettare il computer. In fondo i primi virus ci sguazzavano in queste cose.

Ebbene la Intel, dal 80386 in poi ha costruito una nuova serie di processori che oltre a possedere delle nuove istruzioni più potenti consentivano al sistema operativo (leggi Windows 95 o altro) di operare in modalità protetta.

Cioè? Be la modalità protetta è una cosa alquanto complicata, essa prevede che solo il sistema operativo può effettuare determinate operazioni, inoltre i registri di segmento non possono più indirizzare direttamente i segmenti, ma solo indicare il segmento desiderato al processore, sarà questi poi a verificare se il programma che ha chiesto l'accesso alla memoria è autorizzato a farlo o no, se avete windows 95 sicuramente vi sarà capitato con qualche programma di ricevere il seguente messaggio "Questo programma ha eseguito un'operazione non valida e sarà terminato", ebbene quel programma ha tentato di accedere ad un segmento di memoria su cui non era stato autorizzato da Windows.

Questo fatto comporta molte cose, che più programmi possono essere contemporaneamente in esecuzione, ognuno nel suo spazio assegnatogli, che non potrà interferire con altre applicazioni né tanto meno cancellare Windows.

Ed il nostro programmino?: Bè, Windows gli assegnerà una finestra in modo virtuale, ossia una parvenza di reale, e lui non si accorgerà di niente e farà il suo dovere. A presto!!!

P.S. Per compilare i programmi assembler avete bisogno ovviamente di un compilatore. Con una ricerca sul web potrete trovarne decine in formato shareware o freeware, oppure se disponete di visual C++ il compilatore è già compreso nel pacchetto. Buon divertimento.

Corso di assembler per principianti scritto da Gennaro Cifariello.

Da http://corsoassembler.dadacasa.supereva.it/default.htm?p