MASSIMO UBERTINI ASSEMBLER

Transcript

1 MASSIMO UBERTINI ASSEMBLER

2 ;Nome del programma: inser.asm ;Programmatore: ;Descrizione ;Programma che inserisce un valore nel registro AX. DOSSEG.MODEL SMALL.STACK 200H.DATA.CODE BEGIN: MOV AX,0FFFFH MOV AX,4C00H END BEGIN Il programma non ha output, per verificare il suo funzionamento si deve usare il TurboDebugger (td.exe). Eseguire il programma con Run/Trace into F7, AX=FFFF (65535). #include <stdio.h> #include <conio.h> int main (void) { clrscr(); asm MOV AX,0FFFFH printf ("%X",_AX); getch(); return (0); TASM um 1 di 175

3 } ;Nome del programma: scambia.asm ;Programmatore: ;Descrizione ;Programma che scambia il valore di due variabili. DOSSEG.MODEL SMALL.STACK 200H.DATA PRIMO DW 0FFH SECONDO DW 0AAH.CODE BEGIN: MOV MOV DS,AX MOV AX,PRIMO MOV BX,SECONDO XCHG AX,BX MOV AX,4C00H END BEGIN #include <stdio.h> #include <conio.h> int main (void) { clrscr(); asm { MOV AX,0FFH MOV BX,0AAH } printf ("AX = %X BX = %X\n",_AX,_BX); asm { MOV AX,0FFH MOV BX,0AAH XCHG AX,BX } printf ("AX = %X BX = %X",_AX,_BX); getch(); return (0); } TASM um 2 di 175

4 ;Nome del programma: somma.asm ;Programmatore: ;Descrizione ;Programma che addiziona due byte senza segno con il risultato in una word. DOSSEG.MODEL SMALL.STACK 200H.DATA ADD1 DB 0FFH ADD2 DB 1H SOMMA DW?.CODE BEGIN: MOV MOV DS,AX MOV AX,00H MOV AL,ADD1 ADD AL,ADD2 ADC AH,0 MOV SOMMA,AX MOV AX,4C00H END BEGIN #include <stdio.h> #include <conio.h> int main (void) { unsigned int SOMMA=0; clrscr(); asm { MOV AX,00H MOV AL,0FFH ADD AL,1 ADC AH,0 MOV SOMMA,AX } printf ("La somma vale = %X",SOMMA); getch(); return (0); } TASM um 3 di 175

5 ;Nome del programma: muldiv.asm ;Programmatore: ;Descrizione ;Programma che moltiplica e divide due byte senza segno. DOSSEG.MODEL SMALL.STACK 200H.DATA NUM2 DB 02H PRODOTTO DW? QUOZIENTE DB? RESTO DB?.CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV AL,08H MUL NUM2 MOV PRODOTTO,AX MOV AX,0008H MOV AH,00H DIV NUM2 MOV QUOZIENTE,AL MOV RESTO,AH MOV AX,4C00H END BEGIN #include <stdio.h> #include <conio.h> int main (void) { unsigned int NUM2=0x2; unsigned int PRODOTTO; clrscr(); asm { MOV AX,0008H MUL NUM2 MOV PRODOTTO,AX } printf ("Il prodotto vale = %X (%d)\n",prodotto, PRODOTTO); asm { TASM um 4 di 175

6 MOV AX,0008H MOV AH,00H DIV NUM2 } printf ("Il quoziente vale = %X (%d)\n",_al, _AL); printf ("Il resto vale = %X (%d)",_ah, _AH); getch(); return (0); } TASM um 5 di 175

7 ;Nome del programma: sottrazione.asm ;Programmatore: ;Descrizione ;Programma che sottrae in valore assoluto due numeri. DOSSEG.MODEL SMALL.STACK 200H.DATA NUM1 DW 15H NUM2 DW 20H DIFFERENZA DW?.CODE BEGIN: MOV MOV DS,AX MOV AX,NUM2 CMP NUM1,AX JNAE THEN MOV AX,NUM1 MOV DIFFERENZA,AX SUB DIFFERENZA,AX JMP IFEND THEN: SUB AX,NUM1 MOV DIFFERENZA,AX IFEND: MOV AX,4C00H END BEGIN #include <stdio.h> #include <conio.h> int main (void) { unsigned int NUM1=0x15; unsigned int NUM2=0x20; unsigned int DIFFERENZA; clrscr(); asm { MOV AX,NUM2 CMP NUM1,AX TASM um 6 di 175

8 JNAE THEN MOV AX,NUM1 MOV DIFFERENZA,AX SUB DIFFERENZA,AX JMP IFEND } THEN: asm { SUB AX,NUM1 MOV DIFFERENZA,AX } IFEND: printf ("La sottrazione vale = %X (%d)\n",differenza); getch(); return (0); } TASM um 7 di 175

9 ;Nome del programma: mul.asm ;Programmatore: ;Descrizione ;Programma che moltiplica due numeri per somme successive. DOSSEG.MODEL SMALL.STACK 200H.DATA NUM1 DW 15H NUM2 DW 20H PRODOTTO DW 0.CODE BEGIN: MOV MOV DS,AX MOV AX,NUM1 MOV BX,0 MENTRE: CMP BX,NUM2 JNB ENDMENTRE ADD PRODOTTO,AX INC BX JMP MENTRE ENDMENTRE: MOV AX,4C00H END BEGIN #include <stdio.h> #include <conio.h> int main (void) { unsigned int NUM1=0x15; unsigned int NUM2=0x20; unsigned int PRODOTTO=0; clrscr(); asm { MOV AX,NUM1 MOV BX,0 } TASM um 8 di 175

10 MENTRE: asm { CMP BX,NUM2 JNB ENDMENTRE ADD PRODOTTO,AX INC BX JMP MENTRE } ENDMENTRE: printf ("Il prodotto vale = %X (%d)\n",prodotto); getch(); return (0); } TASM um 9 di 175

11 ;Nome del programma: mulloop.asm ;Programmatore: ;Descrizione ;Programma che moltiplica due numeri con l'istruzione LOOP. DOSSEG.MODEL SMALL.STACK 200H.DATA NUM1 DW 15H NUM2 DW 20H PRODOTTO DW 0H.CODE BEGIN: MOV MOV DS,AX MOV AX,NUM1 MOV CX,NUM2 CICLO: ADD PRODOTTO,AX LOOP CICLO MOV AX,4C00H END BEGIN #include <stdio.h> #include <conio.h> int main (void) { unsigned int NUM1=0x15; unsigned int NUM2=0x20; unsigned int PRODOTTO=0; clrscr(); asm { MOV AX,NUM1 MOV CX,NUM2 } CICLO: asm { ADD PRODOTTO,AX LOOP CICLO TASM um 10 di 175

12 } printf ("Il prodotto vale = %X (%d)\n",prodotto); getch(); return (0); } TASM um 11 di 175

13 ;Nome del programma: rw.asm ;Programmatore: ;Descrizione: direttive semplificate ;Programma che legge caratteri dalla tastiera fino alla pressione di INVIO. DOSSEG ;RAGGRUPPO I SEGMENTI SECONDO LO STANDARD MICROSOFT.MODEL SMALL ;MODELLO DI MEMORIA.STACK.DATA ;SEGMENTO DATI CAR DB 20 DUP(?) ;RISERVIAMO 20 BYTES.CODE BEGIN: MOV AX,@DATA ;CARICO IN AX L'INDIRIZZO DEL SEGMENTO DATA MOV DS,AX ;CARICO DS ;MOV BX,0 ;NECESSARIO CONTARE IL NUMERO DI CARATTERI CARICA: MOV AH,08 ;FUNZIONE CHE LEGGE UN CARATTERE DA TASTIERA ;LANCIO LA FUNZIONE 08H MOV CAR[BX],AL ;CARICO IL CARATTERE IN MEMORIA INC BX ;INCREMENTO BX CMP AL,13 ;CONTROLLA SE IL TASTO PREMUTO È CR JE FINE ;SE È CR ESCE DAL CICLO CMP BX,18 ;SI POSSONO CARICARE MAX 20 CARATTERI JE FINE JMP CARICA; ALTRIMENTI CARICA UN ALTRO CARATTERE FINE: MOV CX,36 ;$ TERMINATORE DI FINE STRINGA MOV [BX],CX ;LO METTO IN FONDO ALLA STRINGA MOV DX,OFFSET CAR ;CARICA IN DX L'INDIRIZZO DI PARTENZA DI CAR MOV AH,09 ;FUNZIONE CHE STAMPA UNA STRINGA A VIDEO ;LANCIO LA FUNZIONE 09H MOV AX,4C00H ;FUNZIONE DI TERMINAZIONE DEL PROGRAMMA ;LANCIO LA FUNZIONE END BEGIN TASM um 12 di 175

14 ;Nome del programma: rw.asm ;Programmatore: ;Descrizione: direttive standard ;Programma che legge caratteri dalla tastiera fino alla pressione di INVIO. SSTACK SEGMENT STACK 'STACK' ;SEGMENTO STACK SSTACK ENDS DATA SEGMENT ;SEGMENTO DATI CAR DB 20 DUP(?) ;RISERVIAMO 20 BYTES DATA ENDS CODE SEGMENT ASSUME CS:CODE, DS:DATA, SS:SSTACK ;ASSEGNO I NOMI AI REGISTRI BEGIN: MOV AX,DATA ;CARICO IN AX L'INDIRIZZO DEL SEGMENTO DATA MOV DS,AX ;CARICO DS MOV AX,SSTACK ;CARICO IN AX L'INDIRIZZO DEL SEGMENTO STACK MOV SS,AX ;CARICO SS CARICA: MOV AH,08 ;FUNZIONE CHE LEGGE UN CARATTERE DA TASTIERA ;LANCIO LA FUNZIONE 08H MOV CAR[BX],AL ;CARICO IL CARATTERE IN MEMORIA INC BX ;INCREMENTO BX CMP AL,13 ;CONTROLLA SE IL TASTO PREMUTO È CR JE FINE ;SE È CR ESCE DAL CICLO CMP BX,18 ;SI POSSONO CARICARE MAX 20 CARATTERI JE FINE JMP CARICA; ALTRIMENTI CARICA UN ALTRO CARATTERE FINE: MOV CX,36 ;$ TERMINATORE DI FINE STRINGA MOV [BX],CX ;LO METTO IN FONDO ALLA STRINGA MOV DX,OFFSET CAR ;CARICA IN DX L'INDIRIZZO DI PARTENZA DI CAR MOV AH,09 ;FUNZIONE CHE STAMPA UNA STRINGA A VIDEO ;LANCIO LA FUNZIONE 09H MOV AX,4C00H ;FUNZIONE DI TERMINAZIONE DEL PROGRAMMA ;LANCIO LA FUNZIONE END BEGIN TASM um 13 di 175

15 ;Nome del programma: rw.asm ;Programmatore: ;Descrizione ;Programma che legge caratteri dalla tastiera fino alla pressione di INVIO. ;Quindi stampa ;la stringa letta al centro dello schermo. DOSSEG.MODEL SMALL.STACK.DATA CAR DB 20 DUP(?).CODE BEGIN: MOV MOV DS,AX CARICA: MOV AH,08 MOV CAR[BX],AL INC BX CMP AL,13 JE FINE CMP BX,18 JE FINE JMP CARICA FINE: MOV CX,36 MOV [BX],CX MOV AX,80 ;NUMERO DI COLONNE SUB AX,BX ;CALCOLO L'ASCISSA DI CENTRO SCHERMO MOV DL,2 DIV DL MOV CL,AL ;CARICO IL NUMERO DI SPAZI DA INSERIRE FOR: MOV DL,20H ;CODICE ASCII DI BLANK MOV AH,02 ;FUNZIONE CHE VISUALIZZA UN CARATTERE LOOP FOR ;GIRA MOV DX,OFFSET CAR ;CARICA IN DX L'INDIRIZZO DI PARTENZA DI CAR MOV AH,09 ;FUNZIONE CHE STAMPA UNA STRINGA A VIDEO ;LANCIO LA FUNZIONE 09H MOV AX,4C00H ;FUNZIONE DI TERMINAZIONE DEL PROGRAMMA ;LANCIO LA FUNZIONE END BEGIN TASM um 14 di 175

16 ;Nome del programma:input.asm ;Programmatore: ;Descrizione: ;Programma: legge un numero di due cifre da tastiera il numero convertito da ASCII a ;binario è posto in AL modifica solo AX; AH è azzerato. DOSSEG.MODEL SMALL STACK 200H.DATA TEXT DB, 'INSERISCI UN NUMERO DI DUE CIFRE [99]. ',13,10,'$'.CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV DX,OFFSET TEXT ; DS:DX PUNTA AL MESSAGGIO MOV AH,9 ; FUNZIONE 9 VISUALIZZA STRINGA ; CHIAMA IL SERVIZIO DEL DOS MOV AH,01H ;LEGGE LE DECINE SUB AL,30H MOV BL,10 MUL BL MOV BL,AL MOV AH,01H ;LEGGE LE UNITÀ E LE SOMMA SUB AL,30H ADD AL,BL MOV AH,0 MOV AX,4C00H END BEGIN TASM um 15 di 175

17 ;Nome del programma: io.asm ;Programmatore: ;Descrizione: ;Programma: di input/output. DOSSEG.MODEL SMALL STACK 200H.DATA CR EQU 13 ; ENTER (CODICE DEL TASTO INVIO) LF EQU 10 ; LINE-FEED (CODICE DI NUOVA LINEA) MESSAGE DB "UN SEMPLICE PROGRAMMA DI INPUT/OUTPUT.$" PROMPT DB CR,LF,"QUESTO E' IL PRIMO PROMPT.$" AGAIN DB CR,LF,"VUOI ANCORA UN ALTRO PROMPT? $" ANOTHER DB CR,LF,"QUESTO E' UN ALTRO PROMPT!$" GOODBYE DB CR,LF,"ARRIVEDERCI.$".CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV DX,OFFSET MESSAGE MOV AH,9 MOV DX,OFFSET PROMPT MOV AH,9 JMP FIRST_TIME PROMPT_AGAIN: MOV DX,OFFSET ANOTHER MOV AH,9 FIRST_TIME: MOV DX,OFFSET AGAIN MOV AH,9 XOR AH,AH ;LA FUNZIONE 00H DELL'NTERRUPT 16H OTTIENE UN CARATTERE INT 16H MOV BL,AL ; SALVIAMOLO IN BL MOV DL,AL ;COPIAMO AL IN DL PER POTERLO STAMPARE MOV AH,02H ; FUNZIONE 02H - VISUALIZZA CARATTERE ; CHIAMA IL SERVIZIO DOS CMP BL,'S' ; AL=S? JE PROMPT_AGAIN ; SE SI ALLORA VISUALIZZA DI NUOVO IL PROMPT CMP BL,'S' ; AL=S? JE PROMPT_AGAIN ; SE SI ALLORA VISUALIZZA DI NUOVO IL PROMPT THEEND: MOV DX,OFFSET GOODBYE MOV AH,9 MOV AX,4C00H END BEGIN TASM um 16 di 175

18 ;Nome del programma: rw.asm ;Programmatore: ;Descrizione ;Programma che legge e stampa un carattere. DOSSEG.MODEL SMALL.STACK 200H.DATA CARATTERE DB?.CODE BEGIN: MOV AX,@DATA MOV DS,AX ;stampa del prompt MOV DL,"?" MOV AH,02H ;lettura del carattere MOV AH,01 MOV CARATTERE,AL ;ritorno a capo MOV DL,0AH MOV AH,02H MOV DL,0DH MOV AH,02H ;stampa carattere MOV DL,CARATTERE MOV AH,02H MOV AX,4C00H END BEGIN C:\Compiler\BORLANDC\Output>rw?z z C:\Compiler\BORLANDC\Output> TASM um 17 di 175

19 ;Nome del programma: stampa.asm ;Programmatore: ;Descrizione ;Programma che legge e stampa un messaggio. DOSSEG.MODEL SMALL.STACK 200H.DATA MESSAGGIO DB "Ciao, mondo $".CODE BEGIN: MOV AX,@DATA MOV DS,AX LEA DX, MESSAGGIO MOV AH,09H MOV AX,4C00H END BEGIN TASM um 18 di 175

20 ;Nome del programma: stampa.asm ;Programmatore: ;Descrizione ;Programma che stampa una stringa. DOSSEG.MODEL SMALL STACK 200H.DATA TEXT DB, 'CIAO, MONDO. ',13,10,'$'.CODE BEGIN: MOV MOV DS,AX MOV BX,OFFSET TEXT CICLO: MOV AL,[BX] ;CARICA IL BX L'I_ESIMO CARATTERE DI "STRINGA" IN AL CMP AL,2EH ;CONFRONTA IL CONTENUTO DI AL CON 46 JE FINE ;SALTO CONDIZIONATO A "FINE" MOV AH,2 ;ISTRUZIONE DI LETTURA CARATTERE MOV DL,AL ;METTE IL CONTENUTO DI AL NEL REGISTRO DL MOV DL,10 MOV AH,2 INC BX ; INCREMENTO DEL CONTENUTO DEL REGISTRO BX JMP CICLO FINE: MOV AX,4C00H END BEGIN TASM um 19 di 175

21 ;Nome del programma: rw.asm ;Programmatore: ;Descrizione ;Programma che legge e stampa una stringa. DOSSEG.MODEL SMALL.STACK 200H.DATA STRINGA DB 52, 0, 50 DUP (00H).CODE BEGIN: MOV AX,@DATA MOV DS,AX ;lettura della stringa LEA DX,STRINGA MOV AH,0AH ;impostazione in DI del numero di caratteri inseriti LEA BX,STRINGA MOV AH,0AH MOV AH,0 MOV AL,[BX+1] MOV DI,AX ;sostituzione di invio per il simbolo $ MOV BYTE PTR [BX+DI+2],"$" ;ritorno a capo MOV DL,0AH MOV AH,02H MOV DL,0DH MOV AH,02H ;stampa stringa LEA DX,STRINGA+2 MOV AH,09H MOV AX,4C00H END BEGIN TASM um 20 di 175

22 ;Nome del programma: stringa.asm ;Programmatore: ;Descrizione ;Programma che acquisisce una stringa e la visualizza al contrario. DOSSEG.MODEL SMALL STACK 200H.DATA STRINGA DB ' '.CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV CX,0 MOV SI,OFFSET STRINGA CICLO: MOV AH,01H MOV [SI],AL INC SI INC CX CMP AL,13 ;STRINGA VUOTA ; AX PUNTA AL DATA SEGMENT ; DS PUNTA AL DATA SEGMENT ;ACQUISISCO LA STRINGA CARATTERE PER CARATTERE ;URN HO TERMINATO JNE CICLO MOV AH,02H MOV DL,13 ;SALTA UNA RIGA PER NON SOVRASCRIVERE LA STRINGA: CR MOV AH,02H MOV DL,10 ;SALTA UNA RIGA PER NON SOVRASCRIVERE LA STRINGA: LF STAMPA: MOV SI,CX MOV BX,OFFSET STRINGA MOV DL,[BX+SI] MOV AH,02H DEC CX CMP CX,0 JNE STAMPA MOV AX,4C00H END BEGIN TASM um 21 di 175

23 ;Nome del programma: stringa.asm ;Programmatore: ;Descrizione: ;Programma che acquisisce una stringa (minore di 10 caratteri ) e visualizza la sua ;lunghezza. DOSSEG.MODEL SMALL STACK 200H.DATA STRINGA DB ' '.CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV CL,0 MOV SI,OFFSET STRINGA CICLO: MOV AH,01H MOV [SI],AL INC SI INC CL CMP AL,13 JNE CICLO ;STRINGA VUOTA ; AX PUNTA AL DATA SEGMENT ; DS PUNTA AL DATA SEGMENT ;ACQUISISCO LA STRINGA CARATTERE PER CARATTERE ;URN HO TERMINATO DEC CL ;TOLGO IL CR ADD CL,'0' ;SOMMO AL NUMERO IL CODICE ASCII 0 MOV AH,02H MOV DL,13 ;SALTA UNA RIGA PER NON SOVRASCRIVERE LA STRINGA: CR MOV AH,02H MOV DL,10 ;SALTA UNA RIGA PER NON SOVRASCRIVERE LA STRINGA: LF MOV AH,02 MOV DL,CL MOV AX,4C00H END BEGIN ;STAMPO CL LA LUNGHEZZA DELLA STRINGA TASM um 22 di 175

24 ;Nome del programma: bios.asm ;Programmatore: ;Descrizione: ;Programma che legge la data del BIOS, dalla locazione FFFF:0005 alla FFFF:000C. DOSSEG.MODEL SMALL STACK 200H.DATA M DB 13,13,'DATA DI RILASCIO DEL BIOS:.CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV DX,OFFSET M MOV AH,9 MOV AX,0FFFFH MOV DS,AX MOV BX,0005H MOV CX,8 MOV AH,2 STAMPA: MOV DL,[BX] INC BX LOOP STAMPA MOV AX,4C00H END BEGIN C:\Compiler\BORLANDC\Output>bios DATA DI RILASCIO DEL BIOS: 09/22/06 C:\Compiler\BORLANDC\Output> $' TASM um 23 di 175

25 ;Nome del programma: stampan.asm ;Programmatore: ;Descrizione ;Programma che legge e stampa una cifra. DOSSEG.MODEL SMALL.STACK 200H.DATA CIFRA DB?.CODE BEGIN: MOV AX,@DATA MOV DS,AX ;stampa del prompt MOV DL,"?" MOV AH,02H ;lettura della cifra MOV AH,01 SUB AL,30H MOV CIFRA,AL ;ritorno a capo MOV DL,0AH MOV AH,02H MOV DL,0DH MOV AH,02H ;stampa della cifra MOV DL,CIFRA ADD DL,30H MOV AH,02H MOV AX,4C00H END BEGIN TASM um 24 di 175

26 ;Nome del programma: stampab.asm ;Programmatore: ;Descrizione ;Programma che legge e stampa un numero di un byte. DOSSEG.MODEL SMALL.STACK 200H.DATA NUMERO DB 0 CIFRA DB?.CODE BEGIN: MOV AX,@DATA MOV DS,AX ;stampa del prompt MOV DL,"?" MOV AH,02H ;lettura del numero MOV AH,01 MENTRE: CMP AL,13D JE FINEMENTRE SUB AL,30H MOV CIFRA,AL MOV AL,NUMERO MOV BL,10 MUL BL ADD AL,CIFRA MOV NUMERO,AL MOV AH,01H JMP MENTRE FINEMENTRE: ;ritorno a capo MOV DL,0AH MOV AH,02H MOV DL,0DH MOV AH,02H ;stampa del numero con le cifre dall'ultima alla prima STAMPA: MOV AH,0 MOV AL,NUMERO MOV BL,10 DIV BL MOV NUMERO,AL MOV DL,AH ADD DL,30H MOV AH,02H CMP NUMERO,0 TASM um 25 di 175

27 JNE STAMPA MOV AX,4C00H END BEGIN TASM um 26 di 175

28 ;Nome del programma: stampa.asm ;Programmatore: ;Descrizione ;Programma che legge e stampa una stringa sulla stampante. DOSSEG.MODEL SMALL.STACK 200h.DATA HelloMessage DB 'Hello, world',13,10,12 HELLO_MESSAGE_LENGTH EQU $ - HelloMessage.CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV AH,40H ;FUNZIONE DOS PER SCRIVERE SUL DEVICE MOV BX,4 ;GESTIONE PRINTER: 4=HANDLE PRINTER MOV CX,HELLO_MESSAGE_LENGTH ;NUMERO DI CHAR DA STAMPARE MOV DX,OFFSET HELLOMESSAGE MOV AX,4C00H END BEGIN ;STRINGA DA STAMPARE TASM um 27 di 175

29 ;Nome del programma: ordina.asm ;Programmatore: ;Descrizione ;Programma che legge tre numeri e li ordina in modo decrescente e crescente. DOSSEG.MODEL SMALL.STACK 200H.DATA INSERT1 DB 13,10, 'INTRODUCI IL 1Ø NUMERO ',13,10,'$' INSERT2 DB 13,10, 'INTRODUCI IL 2Ø NUMERO ',13,10,'$' INSERT3 DB 13,10, 'INTRODUCI IL 3Ø NUMERO ',13,10,'$' STAMPADEC DB 13,10, 'LA STAMPA DEI NUMERI IN ORDINE DECRESCENTE E''',13,10,'$' STAMPACRE DB 13,10, 'LA STAMPA DEI NUMERI IN ORDINE CRESCENTE E''',13,10,'$'.CODE BEGIN: MOV AX,@DATA MOV DS,AX ; CARICA IL SEGMENTO DATI MOV AH,9 ; FUNZIONE DI STAMPA STRINGA MOV DX,OFFSET INSERT1 ; VISUALIZZA LA STRINGA "INSERT1" ; CHIAMATA AL DOS MOV AH,1 ; FUNZIONE DI LETTURA CARATTERE MOV BL,AL ; PONE IL CONTENUTO DEL REGISTRO AL IN BL MOV AH,9 MOV DX,OFFSET INSERT2 ; VISUALIZZA LA STRINGA "INSERT2" MOV AH,1 MOV BH,AL ; PONE IL CONTENUTO DEL REGISTRO AL IN BH MOV AH,9 MOV DX,OFFSET INSERT3 MOV AH,1 CMP AL,BL JL NONSCAMBIA1 XCHG AL,BL NONSCAMBIA1: CMP AL,BH JL NONSCAMBIA2 XCHG AL,BH XCHG BH,BL NONSCAMBIA2: CMP BH,BL JL NONSCAMBIA3 XCHG BL,BH NONSCAMBIA3: MOV CL,AL MOV AH,9 MOV DX,OFFSET STAMPADEC TASM um 28 di 175

30 MOV AH,2 MOV DL,BL MOV DL,BH MOV DL,CL MOV AH,9 MOV DX, OFFSET STAMPACRE MOV AH,2 MOV DL,CL MOV DL,BH MOV DL,BL MOV AH,4CH END BEGIN C:\Compiler\BORLANDC\Output>ordina Introduci il 1 numero 9 Introduci il 2 numero 7 Introduci il 3 numero 1 La stampa dei numeri in ordine decrescente e' 971 La stampa dei numeri in ordine crescente e' 179 C:\Compiler\BORLANDC\Output> TASM um 29 di 175

31 ;Nome del programma: add.asm ;Programmatore: ;Descrizione: ;Programma che somma una serie di numeri di una cifra. DOSSEG.MODEL SMALL.STACK 200H.DATA SPAZIO DB,13,10,'$' TESTO1 DB,13,10,'******* SOMMA DI N NUMERI DI UNA CIFRA*******$' TESTO2 DB,13,10,'PREMI * PER FINIRE $' INPUT1 DB,13,10,'DAMMI IL NUMERO... ','$' OUTPUT DB,13,10,'IL RISULTATO DELLA SOMMA VALE ''... ','$' ERROR DB,13,10,' *** ERRORE RIPETERE ***$'.CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV AH,9 MOV DX,OFFSET SPAZIO MOV DX,OFFSET TESTO1 MOV DX,OFFSET SPAZIO MOV DX,OFFSET TESTO2 MOV DX,OFFSET SPAZIO MOV BL,0 ;AZZERA IL REGISTRO CONTATORE CHIEDENUMERO: MOV AH,9 MOV DX,OFFSET INPUT1 MOV AH,1 CMP AL,'*' JZ FINECICLO CMP AL,'9' JA MESSAGGIO1 CMP AL,'0' JB MESSAGGIO1 SUB AL,48 ADD BL,AL JMP CHIEDENUMERO MESSAGGIO1: MOV DX,OFFSET ERROR MOV AH,9 JMP CHIEDENUMERO FINECICLO: MOV AH,9 MOV DX,OFFSET SPAZIO ;CICLO DI RICHIESTA DI UN NUMERO ;SE È UGUALE A '*' SALTA ALLA FINE TASM um 30 di 175

32 MOV DX,OFFSET OUTPUT MOV BH,0 CMP BL,200 JB CENTO SUB BL,200 MOV DL,50 MOV AH,2 MOV BH,1 JMP DECINE CENTO: CMP BL,100 JB DECINE SUB BL,100 MOV DL,49 MOV AH,2 MOV BH,1 DECINE: MOV AL,90 MOV DL,57 CICLO: CMP BL,AL JB MINORE SUB BL,AL MOV AH,2 JMP UNITA MINORE: SUB AL,10 SUB DL,1 CMP AL,0 JE USCITA JMP CICLO USCITA: CMP BH,0 JE UNITA MOV AH,2 UNITA: MOV DL,BL ADD DL,48 MOV AH,2 MOV AH,4CH END BEGIN TASM um 31 di 175

33 C:\Compiler\BORLANDC\Output>add ******* SOMMA DI N NUMERI DI UNA CIFRA******* Premi * per finire Dammi il numero... 2 Dammi il numero... 4 Dammi il numero... 4 Dammi il numero... * Il risultato della somma vale ' C:\Compiler\BORLANDC\Output> TASM um 32 di 175

34 ;Nome del programma: add.asm ;Programmatore: ;Descrizione: ;Programma che somma due numeri di una cifra. DOSSEG.MODEL SMALL STACK 200H.DATA CR EQU 13 ;ENTER (CODICE DEL TASTO INVIO) LF EQU 10 ;LINE-FEED (CODICE DI NUOVA LINEA) SOMMA DB 'SOMMA DI DUE NUMERI DI UNA CIFRA ',CR,LF,'$' PRIMO DB 'INTRODUCI IL PRIMO ADDENDO (MAX 1 CIFRA) $' SECONDO DB CR,LF,'INTRODUCI IL SECONDO ADDENDO (MAX 1 CIFRA) $' RISULTATO DB CR,LF,'SOMMA =.CODE BEGIN: MOV AX,@DATA ; AX PUNTA AL DATA SEGMENT MOV DS,AX ; DS PUNTA AL DATA SEGMENT MOV DX,OFFSET SOMMA ;METTE IN DX LA STRINGA "SOMMA DI DUE NUMERI DI UNA CIFRA" MOV AH,9 ;ISTRUZIONE DI STAMPA STRINGA MOV DX,OFFSET PRIMO ;METTE IN DX LA STRINGA "INTRODUCI IL PRIMO ADDENDO" MOV AH,9 MOV AH,1 ;LEGGE UN CARATTERE DA TASTIERA E LO METTE IN AL SUB AL,30H ;CONVERTE IL CODICE ASCII NEL NUMERO CORRISPONDENTE MOV BL,AL MOV DX,OFFSET SECONDO ;METTE IN DX LA STRINGA "INTRODUCI IL SECONDO ADDENDO" MOV AH,9 MOV AH,1 SUB AL,30H ADD AL,BL ;AL=AL+BL ;PER VISUALIZZARE LA SOMMA BISOGNA SAPERE DI QUANTE CIFRE È ;COMPOSTA, ESSENDO LA SOMMA DI DUE NUMERI ;AD UNA CIFRA POTRÀ ESSERE: (3 + 2 = 5) OPPURE (5 + 7 = 12) CMP AL,9 ;LA SOMMA È DI 2 CIFRE? VERO = DUECIFRE JA DUECIFRE ADD AL,30H ;CONVERTE IL NUMERO IN CODICE ASCII MOV CL,AL ;SALVO LA SOMMA IN CL PERCHÈ SPORCA AX MOV DX,OFFSET RISULTATO ;METTE IN DX LA STRINGA "SOMMA" MOV AH,9 MOV DL,CL MOV AH,2 ;VISUALIZZA UN CARATTERE A VIDEO JMP FINE TASM um 33 di 175 $'

35 ;PER SEPARARE LE DUE CIFRE BISOGNA DIVIDERE LA SOMMA PER 10, LA CIFRA ;DELLE DECINE È DATA DAL QUOZIENTE DELLA DIVISIONE ;E QUELLA DELLE UNITÀ È DATA DAL RESTO. PER ESEMPIO, 17 DIVISO 10 = 1 ;(QUOZIENTE, DECINE) 7 (RESTO, UNITÀ) DUECIFRE: MOV AH,0 ;AZZERO LA PARTE ALTA DI AX (DIVIDENDO) MOV CL,10 ;DIVISORE IN CL DIV CL ;AL = QUOZIENTE, AH = RESTO MOV BL,AH ;BL = RESTO, AH È USATO PER VISUALIZZARE LA PRIMA CIFRA MOV CL,AL ;SALVO LA SOMMA IN CL PERCHÈ SPORCA AX MOV DX,OFFSET RISULTATO ;METTE IN DX LA STRINGA "SOMMA" MOV AH,9 MOV DL,CL ;CARICO LA CIFRA IN DL ADD DL,30H MOV AH,2 MOV DL,BL ADD DL,30H MOV AH,2 FINE: MOV AX,4C00H END BEGIN C:\Compiler\BORLANDC\Output>add SOMMA DI DUE NUMERI DI UNA CIFRA Introduci il primo addendo (max 1 cifra) 8 Introduci il secondo addendo (max 1 cifra) 7 Somma = 15 C:\Compiler\BORLANDC\Output> TASM um 34 di 175

36 ;Nome del programma: add.asm ;Programmatore: ;Descrizione: ;Programma che somma due numeri di due cifre. DOSSEG.MODEL SMALL STACK 200H.DATA CR EQU 13 ;ENTER (CODICE DEL TASTO INVIO) LF EQU 10 ;LINE-FEED (CODICE DI NUOVA LINEA) SOMMA DB 'SOMMA DI DUE NUMERI DI DUE CIFRE ',CR,LF,'$' PRIMO DB 'INTRODUCI IL PRIMO ADDENDO (MAX 2 CIFRE) $' SECONDO DB CR,LF,'INTRODUCI IL SECONDO ADDENDO (MAX 2 CIFRE) $' RISULTATO DB CR,LF,'SOMMA = $' NUM1 DW 0 NUM2 DW 0 TOTALE DW 0 ;LA SOMA NON PUÒ SUPERARE 99!.CODE BEGIN: MOV AX,@DATA ; AX PUNTA AL DATA SEGMENT MOV DS,AX ; DS PUNTA AL DATA SEGMENT MOV DX,OFFSET SOMMA ;METTE IN DX LA STRINGA "SOMMA DI DUE NUMERI DI DUE CIFRE" MOV AH,9 ;ISTRUZIONE DI STAMPA STRINGA ;LETTURA DEL PRIMO ADDENDO MOV DX,OFFSET PRIMO ;METTE IN DX LA STRINGA "INTRODUCI IL PRIMO ADDENDO" MOV AH,9 MOV AH,1 ;LEGGE UN CARATTERE DA TASTIERA E LO METTE IN AL MOV SI,0 LEGGI_1: CMP AL,CR ;INVIO? JE FINE_1 SUB AL,30H ;CONVERTE IL CODICE ASCII NEL NUMERO CORRISPONDENTE MOV BYTE PTR NUM1[SI],AL INC SI JMP LEGGI_1 FINE_1: ;LETTURA DEL SECONDO ADDENDO MOV DX,OFFSET SECONDO ;METTE IN DX LA STRINGA "INTRODUCI IL SECONDO ADDENDO" MOV AH,9 MOV AH,1 MOV SI,0 LEGGI_2: CMP AL,CR JE FINE_2 SUB AL,30H MOV BYTE PTR NUM2[SI],AL INC SI TASM um 35 di 175

37 JMP LEGGI_2 FINE_2: MOV AH,2 MOV DL,13 MOV DL,10 MOV AX,NUM2 ADD AX,NUM1 AAA MOV TOTALE,AX ADD BYTE PTR TOTALE[0],30H ADD BYTE PTR TOTALE[1],30H ;SALTA UNA RIGA ;SOMMA DEI DUE NUMERI ;CIFRA DEL NUM2 ;CIFRA DEL NUM1 ;METTO A POSTO LE CIFRE MOV AL,'$' ;TERMINATORE DI FINE STRINGA MOV BYTE PTR TOTALE[2],AL MOV DX,OFFSET RISULTATO ;METTE IN DX LA STRINGA "SOMMA" MOV AH,9 MOV DX,OFFSET TOTALE MOV AH,9 MOV AX,4C00H END BEGIN C:\Compiler\BORLANDC\Output>add SOMMA DI DUE NUMERI DI DUE CIFRE Introduci il primo addendo (max 2 cifre) 11 Introduci il secondo addendo (max 2 cifre) 11 Somma = 22 C:\Compiler\BORLANDC\Output> TASM um 36 di 175

38 ;Nome del programma: sub.asm ;Programmatore: ;Descrizione: ;Programma che sottrae (minuendo a due cifre e sottraendo ad una cifra) due numeri. DOSSEG.MODEL SMALL STACK 200H.DATA CR EQU 13 ;ENTER (CODICE DEL TASTO INVIO) LF EQU 10 ;LINE-FEED (CODICE DI NUOVA LINEA) SOMMA DB 'SOTTRARRE DI DUE NUMERI ',CR,LF,'$'.CODE BEGIN: PRIMO DB 'INTRODUCI IL MINUENDO (MAX 2 CIFRA) $' SECONDO DB CR,LF,'INTRODUCI IL SOTTRAENDO (MAX 1 CIFRA) $' RISULTATO DB CR,LF,'DIFFERENZA = $' MOV AX,@DATA ; AX PUNTA AL DATA SEGMENT MOV DS,AX ; DS PUNTA AL DATA SEGMENT MOV DX,OFFSET SOMMA ;METTE IN DX LA STRINGA "SOTTRARRE DI DUE NUMERI" MOV AH,9 ;ISTRUZIONE DI STAMPA STRINGA ;PER COSTRUIRE UN NUMERO A DUE CIFRE È NECESSARIO MOLTIPLICARE LA ;PRIMA CIFRA (DECINE) PER 10 ED AGGIUNGERE LA SECONDA CIFRA (UNITÀ). ;PER ESEMPIO, 37 È INSERITA LA PRIMA CIFRA DELLE DECINE (3) VA ;MOLTIPLICATA PER 10 (E SI OTTIENE 30) POI SI INSERISCE LA CIFRA DELLE ;UNITÀ (7) E SI SOMMA AL VALORE PRECEDENTE ( = 37) MOV DX,OFFSET PRIMO ;METTE IN DX LA STRINGA "INTRODUCI IL MINUENDO" MOV AH,9 MOV BH,0 MOV AH,1 SUB AL,30H ;CONVERTE IL CODICE ASCII NEL NUMERO CORRISPONDENTE MOV CL,10 MUL CL MOV BH,AL MOV AH,1 SUB AL,30H ;BH=0 ;LEGGE UN CARATTERE DA TASTIERA E LO METTE IN AL ADD BH,AL ;BH=BH+AL MOV DX,OFFSET SECONDO ;METTE IN DX LA STRINGA "INTRODUCI IL SOTTRAENDO" MOV AH,9 MOV AH,1 SUB AL,30H SUB BH,AL MOV AL,BH CMP AL,9 JA DUECIFRE ;LA DIFFERENZA È DI 2 CIFRE? VERO = DUECIFRE TASM um 37 di 175

39 ADD AL,30H ;CONVERTE IL NUMERO IN CODICE ASCII MOV CL,AL ;SALVO LA DIFFERENZA IN CL PERCHÈ SPORCA AX MOV DX,OFFSET RISULTATO ;METTE IN DX LA STRINGA "DIFFERENZA" MOV AH,9 MOV DL,CL MOV AH,2 ;VISUALIZZA UN CARATTERE A VIDEO JMP FINE ;PER SEPARARE LE DUE CIFRE BISOGNA DIVIDERE LA SOMMA PER 10, LA CIFRA ;DELLE DECINE È DATA DAL QUOZIENTE DELLA DIVISIONE E QUELLA DELLE ;UNITÀ È DATA DAL RESTO. PER ESEMPIO, 17 DIVISO 10 = 1 (QUOZIENTE, ;DECINE) 7 (RESTO, UNITÀ) DUECIFRE: MOV AH,0 ;AZZERO LA PARTE ALTA DI AX (DIVIDENDO) MOV CL,10 ;DIVISORE IN CL DIV CL ;AL = QUOZIENTE, AH = RESTO MOV BL,AH ;BL = RESTO, AH È USATO PER VISUALIZZARE LA PRIMA CIFRA MOV CL,AL ;SALVO LA SOMMA IN CL PERCHÈ SPORCA AX MOV DX,OFFSET RISULTATO ;METTE IN DX LA STRINGA "SOMMA" MOV AH,9 MOV DL,CL ;CARICO LA CIFRA IN DL ADD DL,30H MOV AH,2 MOV DL,BL ADD DL,30H MOV AH,2 FINE: MOV AX,4C00H END BEGIN C:\Compiler\BORLANDC\Output>sub SOTTRARRE DI DUE NUMERI Introduci il minuendo (max 2 cifra) 56 Introduci il sottraendo (max 1 cifra) 6 Differenza = 50 C:\Compiler\BORLANDC\Output> TASM um 38 di 175

40 ;Nome del programma: mul.asm ;Programmatore: ;Descrizione: ;Programma che moltiplica due numeri di una cifra. DOSSEG.MODEL SMALL STACK 200H.DATA CR EQU 13 ;ENTER (CODICE DEL TASTO INVIO) LF EQU 10 ;LINE-FEED (CODICE DI NUOVA LINEA) SOMMA DB 'PRODOTTO DI DUE NUMERI DI UNA CIFRA ',CR,LF,'$' PRIMO DB 'INTRODUCI IL PRIMO FATTORE(MAX 1 CIFRA) $' SECONDO DB CR,LF,'INTRODUCI IL SECONDO FATTORE(MAX 1 CIFRA) $' RISULTATO DB CR,LF,'PRODOTTO =.CODE BEGIN: MOV AX,@DATA ; AX PUNTA AL DATA SEGMENT MOV DS,AX ; DS PUNTA AL DATA SEGMENT MOV DX,OFFSET SOMMA ;METTE IN DX LA STRINGA "PRODOTTO DI DUE NUMERI DI UNA CIFRA" MOV AH,9 ;ISTRUZIONE DI STAMPA STRINGA MOV DX,OFFSET PRIMO ;METTE IN DX LA STRINGA "INTRODUCI IL PRIMO FATTORE" MOV AH,9 MOV AH,1 ;LEGGE UN CARATTERE DA TASTIERA E LO METTE IN AL SUB AL,30H ;CONVERTE IL CODICE ASCII NEL NUMERO CORRISPONDENTE MOV BL,AL MOV DX,OFFSET SECONDO ;METTE IN DX LA STRINGA "INTRODUCI IL SECONDO FATTORE" MOV AH,9 MOV AH,1 SUB AL,30H MUL BL ;AX=AL*BL ;PER VISUALIZZARE IL PRODOTTO BISOGNA SAPERE DI QUANTE CIFRE È ;COMPOSTO, ESSENDO IL PRODOTTO DI DUE NUMERI AD UNA CIFRA POTRÀ ;ESSERE: (3 * 2 = 6) OPPURE (5 * 7 = 35) CMP AL,9 ;IL PRODOTTO È DI 2 CIFRE? VERO = DUECIFRE JA DUECIFRE ADD AL,30H ;CONVERTE IL NUMERO IN CODICE ASCII MOV CL,AL ;SALVO IL PRODOTTO IN CL PERCHÈ SPORCA AX MOV DX,OFFSET RISULTATO ;METTE IN DX LA STRINGA "PRODOTTO" MOV AH,9 MOV DL,CL MOV AH,2 ;VISUALIZZA UN CARATTERE A VIDEO TASM um 39 di 175 $'

41 JMP FINE ;PER SEPARARE LE DUE CIFRE BISOGNA DIVIDERE LA SOMMA PER 10, LA CIFRA ;DELLE DECINE È DATA DAL QUOZIENTE DELLA DIVISIONE E QUELLA DELLE ;UNITÀ È DATA DAL RESTO. PER ESEMPIO, 17 DIVISO 10 = 1 (QUOZIENTE, ;DECINE) 7 (RESTO, UNITÀ) DUECIFRE: MOV AH,0 ;AZZERO LA PARTE ALTA DI AX (DIVIDENDO) MOV CL,10 ;DIVISORE IN CL DIV CL ;AL = QUOZIENTE, AH = RESTO MOV BL,AH ;BL = RESTO, AH È USATO PER VISUALIZZARE LA PRIMA CIFRA MOV CL,AL ;SALVO IL PRODOTTO IN CL PERCHÈ SPORCA AX MOV DX,OFFSET RISULTATO ;METTE IN DX LA STRINGA "PRODOTTO" MOV AH,9 MOV DL,CL ;CARICO LA CIFRA IN DL ADD DL,30H MOV AH,2 MOV DL,BL ADD DL,30H MOV AH,2 FINE: MOV AX,4C00H END BEGIN C:\Compiler\BORLANDC\Output>mul PRODOTTO DI DUE NUMERI DI UNA CIFRA Introduci il primo fattore(max 1 cifra) 4 Introduci il secondo fattore(max 1 cifra) 4 Prodotto = 16 C:\Compiler\BORLANDC\Output> TASM um 40 di 175

42 ;Nome del programma: dividi.asm ;Programmatore: ;Descrizione ;Programma che esegue la divisione intera. DOSSEG.MODEL SMALL.STACK 200H.DATA TITLEMESSAGE DB'DIVISIONE DI DUE NUMERI',13,10,'$' INPUT1MESSAGE DB'INTRODUCI IL DIVIDENDO (MAX 1 CIFRA) : ','$' INPUT2MESSAGE DB,13,10,'INTRODUCI IL DIVISORE (MAX 1 CIFRA) : ','$' OUTPUT1MESSAGE DB,13,10,'RISULTATO : ','$' OUTPUT2MESSAGE DB,13,10,'RESTO : ','$'.CODE BEGIN: MOV AX,@DATA MOV DS,AX ;CARICA IL SEGMENTO DATI MOV AH,9 ;ISTRUZIONE DI STAMPA STRINGA MOV DX,OFFSET TITLEMESSAGE ;METTE IN DX LA STRINGA "TITLEMESSAGE" ;CHIAMATA AL DOS MOV DX,OFFSET INPUT1MESSAGE ;METTE IN DX LA STRINGA "INPUT1MESSAGE" MOV AH,9 MOV AH,1 ;ISTRUZIONE DI LETTURA CARATTERE MOV CL,AL ;METTE IL CONTENUTO DI AL NEL REGISTRO CL SUB CL,48 ;SOTTRAE 48 AL CONTENUTO DEL REGISTRO CL MOV DX,OFFSET INPUT2MESSAGE ;METTE IN DX LA STRINGA "INPUT2MESSAGE" MOV AH,9 MOV AH,1 MOV BL,AL ;METTE IL CONTENUTO DI AL NEL REGISTRO BL SUB BL,48 ;SOTTRAE 48 AL CONTENUTO DEL REGISTRO BL MOV AH,0 ;METTE 0 NEL CONTENUTO DEL REGISTRO AH MOV AL,CL ;METTE IL CONTENUTO DI CL NEL REGISTRO AL DIV BL ;DIVIDI L'ACCUMULATORE PER IL REGISTRO BL ADD AH,48 ;AGGIUNGE 48 AL REGISTRO AH ADD AL,48 ;AGGIUNGE 48 AL REGISTRO AL MOV CL,AL ;METTE IL CONTENUTO DI AL NEL REGISTRO CL MOV CH,AH ;METTE IL CONTENUTO DI AH NEL REGISTRO CH MOV AH,9 MOV DX,OFFSET OUTPUT1MESSAGE ;METTE IN DX LA STRINGA "OUTPUT1MESSAGE" MOV DL,CL ;METTE IL CONTENUTO DI CL NEL REGISTRO DL MOV AH,2 ;ISTRUZIONE DI STAMPA CARATTERE MOV AH,9 MOV DX,OFFSET OUTPUT2MESSAGE ;METTE IN DX LA STRINGA "OUTPUT2MESSAGE" TASM um 41 di 175

43 MOV AH,2 MOV DL,CH MOV AX,4C00H END BEGIN ;METTE IL CONTENUTO DI CH NEL REGISTRO DL C:\Compiler\BORLANDC\Output>dividi Divisione di due numeri Introduci il dividendo (Max 1 cifra) : 7 Introduci il divisore (Max 1 cifra) : 3 Risultato : 2 Resto : 1 C:\Compiler\BORLANDC\Output> TASM um 42 di 175

44 ;Nome del programma: dividi.asm ;Programmatore: ;Descrizione ;Programma che esegue la divisione reale. DOSSEG.MODEL SMALL.STACK 200H.DATA TITLEMESSAGE DB'DIVISIONE DI DUE NUMERI',13,10,'$' INPUT1MESSAGE DB'INTRODUCI IL DIVIDENDO (MAX 1 CIFRA) : ','$' INPUT2MESSAGE DB,13,10,'INTRODUCI IL DIVISORE (MAX 1 CIFRA) : ','$' OUTPUT1MESSAGE DB,13,10,'RISULTATO : ','$'.CODE BEGIN: MOV AX,@DATA MOV DS,AX ;CARICA IL SEGMENTO DATI MOV AH,9 ;ISTRUZIONE DI STAMPA STRINGA MOV DX,OFFSET TITLEMESSAGE ;METTE IN DX LA STRINGA "TITLEMESSAGE" ;CHIAMATA AL DOS MOV DX,OFFSET INPUT1MESSAGE ;METTE IN DX LA STRINGA "INPUT1MESSAGE" MOV AH,1 ;ISTRUZIONE DI LETTURA CARATTERE MOV CL,AL ;METTE IL CONTENUTO DI AL NEL REGISTRO CL SUB CL,48 ;SOTTRAE 48 AL CONTENUTO DEL REGISTRO CL MOV DX,OFFSET INPUT2MESSAGE ;METTE IN DX LA STRINGA "INPUT2MESSAGE" MOV AH,9 MOV AH,1 MOV BL,AL ;METTE IL CONTENUTO DI AL NEL REGISTRO BL SUB BL,48 ;SOTTRAE 48 AL CONTENUTO DEL REGISTRO BL MOV AH,0 ;METTE 0 NEL CONTENUTO DEL REGISTRO AH MOV AL,CL ;METTE IL CONTENUTO DI CL NEL REGISTRO AL DIV BL ;DIVIDI L'ACCUMULATORE PER IL REGISTRO BL ADD AL,48 ;AGGIUNGE 48 AL REGISTRO AL MOV CL,AL ;METTE IL CONTENUTO DI AL NEL REGISTRO CL MOV CH,AH ;METTE IL CONTENUTO DI AH NEL REGISTRO CH MOV AH,9 MOV DX,OFFSET OUTPUT1MESSAGE ;METTE IN DX LA STRINGA "OUTPUT1MESSAGE" MOV DL,CL ;METTE IL CONTENUTO DI CL NEL REGISTRO DL MOV AH,2 ;ISTRUZIONE DI STAMPA CARATTERE MOV DL,'.' ;STAMPA IL PUNTO DECIMALE DECIMALE: INC DH ;INCREMENTA DH PER CONTROLLO DECIMALI MOV AL,10 MUL CH ;MOLTIPLICA IL RESTO PER 10 E LO METTE IN AL TASM um 43 di 175

45 MOV AH,0 DIV BL ADD AL,48 MOV CL,AL MOV CH,AH MOV DL,CL MOV AH,2 CMP DH,3 JNE DECIMALE MOV AX,4C00H END BEGIN ;DIVIDE L'ACCUMULATORE PER IL REGISTRO AL ;MUOVE IL CONTENUTO DI AL IN CL (QUOZIENTE) ;MUOVE IL CONTENUTO DI AH IN CH (RESTO) ;CONFRONTA IL NUMERO DI DECIMALI CON QUELLO ;DEFINITO E RIPETE I CALCOLI SE NON E' UGUALE C:\Compiler\BORLANDC\Output>dividi Divisione di due numeri Introduci il dividendo (Max 1 cifra) : 7 Introduci il divisore (Max 1 cifra) : 3 Risultato : C:\Compiler\BORLANDC\Output> TASM um 44 di 175

46 ;Nome del programma: dividi.asm ;Programmatore: ;Descrizione ;Programma che chiede da tastiera un numero di 2 cifre ;calcola e stampa risultato e resto ;della divisione per 2. DOSSEG.MODEL SMALL.STACK.DATA MESS1 DB 13,10,"BATTI UN NUMERO (DI DUE CIFRE) MINORE DI 100 N=$" MESS2 DB 13,10,"IL RISULTATO ED IL RESTO DI N/2 VALGONO:" DB 13,10," RIS = " RIS DB " RESTO = " RESTO DB " ",13,10,"IL RISULTATO ESATTO VALE: N/2 = " ESATTO DB ". $".CODE BEGIN: ;ACQUISISCE DA TASTIERA UN NUMERO N<100 E LO CONVERTE IN BINARIO MOV AH,9 MOV DX,OFFSET MESS1 ;LEGGE PRIMA CIFRA MOV AH,1 SUB AL,30H MOV BL,10 MUL BL MOV BL,AL ;LEGGE SECONDA CIFRA MOV AH,1 SUB AL,30H ;NUMERO LETTO IN AL ADD AL,BL ;DIVIDE PER 2 MOV AH,0 MOV BL,2 DIV BL ;MEMORIZZA IL RESTO IN ASCII MOV RESTO,AH ADD RESTO,30H MOV ESATTO+3,30H ;MEMORIZZA UNA CIFRA DECIMALE DI VALORE 0 SE RESTO = 0 ;DI VALORE 5 SE RESTO = 1 CMP AH,0 JZ ZERO MOV ESATTO+3,35H ;CALCOLA IL RISULTATO IN ASCII, TROVANDO DECINE E UNITA' ZERO: MOV AH,0 MOV BL,10 DIV BL ADD AX,3030H MOV WORD PTR RIS,AX MOV WORD PTR ESATTO,AX TASM um 45 di 175

47 ;STAMPA I RISULTATI FINALI MOV AH,9 MOV DX,OFFSET MESS2.EXIT END BEGIN C:\Compiler\BORLANDC\Output>dividi Batti un numero (di due cifre) minore di 100 N=67 Il risultato ed il resto di N/2 valgono: Ris = 33 Resto = 1 Il risultato esatto vale: N/2 = 33.5 C:\Compiler\BORLANDC\Output> TASM um 46 di 175

48 ;Nome del programma: fatt.asm ;Programmatore: ;Descrizione ;Programma che calcola il fattoriale. DOSSEG.MODEL SMALL.STACK 200H.DATA SPAZIO DB 13,10,'$' TESTO1 DB 13,10,'******* FATTORIALE *******$' TESTO2 DB 13,10,'NUMERO NON SUPERIORE A 5 $' INPUT1 DB 13,10,'DAMMI IL NUMERO... ','$' OUTPUT DB 13,10,'IL RISULTATO DEL FATTORIALE E''... ','$' ERROR DB 13,10,' *** ERRORE RIPETERE ***$'.CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV AH,9 MOV DX,OFFSET SPAZIO MOV DX,OFFSET TESTO1 MOV DX,OFFSET SPAZIO MOV DX,OFFSET TESTO2 MOV DX,OFFSET SPAZIO CHIEDENUMERO: MOV AH,9 MOV DX,OFFSET INPUT1 MOV AH,1 CMP AL,'9' JA MESSAGGIO1 CMP AL,'0' JB MESSAGGIO1 JMP CALCOLA MESSAGGIO1: MOV DX,OFFSET ERROR MOV AH,9 JMP CHIEDENUMERO CALCOLA: SUB AL,48 MOV BL,AL MOV AL,1 CMP BL,1 JBE STAMPA ; SALTA SE INFERIORE O UGUALE MOV CL,1 ; CL = MOLTIPLICATORE CICLOFATT: ADD CL,1 TASM um 47 di 175

49 MUL CL ; AL = AL*CL CMP CL,BL JNZ CICLOFATT ; RIPETE IL CICLO SE CL <> BL STAMPA: MOV BL,AL MOV AH,9 MOV DX,OFFSET SPAZIO MOV DX,OFFSET OUTPUT MOV BH,0 CMP BL,200 JB CENTO SUB BL,200 MOV DL,50 MOV AH,2 MOV BH,1 JMP DECINE CENTO: CMP BL,100 JB DECINE SUB BL,100 MOV DL,49 MOV AH,2 MOV BH,1 DECINE: MOV AL,90 MOV DL,57 CICLO: CMP BL,AL JB MINORE SUB BL,AL MOV AH,2 JMP UNITA MINORE: SUB AL,10 SUB DL,1 CMP AL,0 JE USCITA JMP CICLO USCITA: CMP BH,0 JE UNITA MOV AH,2 UNITA: MOV DL,BL ADD DL,48 MOV AH,2 MOV AX,4C00H TASM um 48 di 175

50 END BEGIN C:\Compiler\BORLANDC\Output>fatt ******* FATTORIALE ******* Numero non superiore a 5 Dammi il numero... 4 Il risultato del fattoriale e' C:\Compiler\BORLANDC\Output> TASM um 49 di 175

51 ;Nome del programma: palla.asm ;Programmatore: ;Descrizione ;Programma che visualizza una palla sul video che si muove nello schermo rimbalzando ;nelle pareti. DOSSEG.MODEL SMALL.STACK 200H.DATA.CODE BEGIN: MOV MOV DS, AX ; IMPOSTO LA MODALITÀ GRAFICA 80X25 MOV AH, 00H MOV AL, 03H INT 10H ; SONOO USATI 2 FLAG (CH E CL) CHE POSSONO AVERE VALORE 0 O 1 ; IL VALORE DI QUESTI DUE È IMPOSTATO A SECONDA DEL VALORE ATTUALE ;DEL CURSORE ; I FLAG SERVONO A STABILIRE SE SUL CONTATORE DI RIGA O COLONNA VA ;FATTA UN OPERAZIONE DI INCREMENTO O DECREMENTO ; VALORI DEI FLAG: ; CH = 0: DECREMENTO DELLE COLONNE ; CH = 1: INCREMENTO DELLE COLONNE ; CL = 0: DECREMENTO DELLE RIGHE ; CL = 1: INCREMENTO DELLE RIGHE MOV AX, 0B800H ; SEGMENTO EXTRA PER LA MEMORIA VIDEO (IL 1CARATTERE IN ALTO A DX È ;CONTENUTO IN QUESTO INDIRIZZO IN RAM VIDEO) MOV ES, AX ; BX: PUNTO DI PARTENZA MOV BH, 0 ; BH: RIGHE MOV BL, 0 ; BL: COLONNE ; DX: CARATTERE DA STAMPARE E ATTRIBUTO MOV DH, 'O' ; CODICE ASCII MOV DL, 0EH ; ATTRIBUTO ; INIZIALMENTE IMPOSTO I FLAG A 1 POICHE INCREMENTO TUTTI I CONTATORI MOV CH, 1 MOV CL, 1 CICLO1: MOV AH, ES:[SI] MOV AL, ES:[SI+1] MOV BP, AX MOV DI, BX MOV AL, 80 MOV AH, 0 MUL BL XCHG BH, BL MOV BH, 0 ADD AX, BX MOV BX, SI MOV BL, 2 MOV BH, 0 TASM um 50 di 175

52 MOV SI, DX MUL BX MOV DX, SI MOV SI, AX MOV ES:[SI], DH MOV ES:[SI+1], DL MOV BX, DI CALL SLEEP ; SETTO I FLAG (CX) CMP BL, 24 JNE PRIG2 MOV CL, 0 JMP PCOL1 PRIG2: CMP BL, 0 JNE PCOL1 MOV CL, 1 PCOL1: CMP BH, 79 JNE PCOL2 MOV CH, 0 JMP CONTINUA PCOL2: CMP BH, 0 JNE CONTINUA MOV CH, 1 CONTINUA: CMP CH, 0 JNE V2 ; DECREMENTA COLONNE DEC BH JMP COLONNE V2: ; INCREMENTA COLONNE INC BH COLONNE: CMP CL, 0 JNE V3 ; DECREMENTA RIGHE DEC BL JMP SALTA V3: ; DECREMENTA RIGHE INC BL JMP SALTA SALTA: MOV AX, BP MOV ES:[SI], AH MOV ES:[SI+1], AL JMP CICLO1 MOV AH, 4CH ; SLEEP: EFFETTUA 10^8 PUSH (15 CK) E POP (15 CK) SLEEP PROC TASM um 51 di 175

53 PUSH CX MOV CX, CICLOSLEEP: PUSH CX MOV CX, CICLO2: LOOP CICLO2 POP CX LOOP CICLOSLEEP POP CX SLEEP ENDP END BEGIN TASM um 52 di 175

54 ;Nome del programma: pass.asm ;Programmatore: ;Descrizione ;Programma che gestisce la password. DOSSEG.MODEL SMALL.STACK 150H.DATA MESSAGGIO DB 'INSERISCI LA PASSWORD (MAX 5 CARATTERI)$' ERRORE DB 'PASSWORD NON CORTA',10,13,'$' CORTO DB 'PASSWORD CORTA',10,13,'$' PAROLA DB 'SUIGO$' STRX DB 5 DUP (?).CODE BEGIN: MOV AX,@DATA MOV DS,AX RITORNO: MOV DX,OFFSET MESSAGGIO MOV AH,9 MOV CX,5 MOV DI,0 PASSLOOP : MOV AH,08H MOV (STRX+DI),AL INC DI DEC CX JNZ PASSLOOP MOV SI,OFFSET PAROLA MOV AX,SEG PAROLA MOV DS,AX MOV DI,OFFSET STRX MOV AX,SEG STRX MOV ES,AX MOV CX,5 CLD REP CMPSB JNE DIVERSO JE VERO DIVERSO : MOV DX,OFFSET ERRORE MOV AH,9 JMP RITORNO VERO : MOV DX,OFFSET CORTO MOV AH,9 MOV AH,4CH END BEGIN TASM um 53 di 175

55 MACRO ;Nome del programma: rwm.asm ;Programmatore: ;Descrizione ;Programma che legge e stampa un carattere con return gestito da una macro. DOSSEG.MODEL SMALL.STACK 200H.DATA CARATTERE DB.CODE URN MACRO ;ritorno a capo MOV DL,0AH MOV AH,02H MOV DL,0DH MOV AH,02H ENDM BEGIN: MOV AX,@DATA MOV DS,AX ;stampa del prompt MOV DL,"?" MOV AH,02H ;lettura del carattere MOV AH,01 MOV CARATTERE,AL ;ritorno a capo URN ;stampa carattere MOV DL,CARATTERE MOV AH,02H MOV AX,4C00H END BEGIN TASM um 54 di 175

56 ;Nome del programma: stringa.asm ;Programmatore: ;Programma: scrivere un programma che visualizzi 10 asterischi in verticale. ;Descrizione: se la scelta è verticale inserire una riga tra gli asterischi ; se la scelta è orizzontale inserire uno spazio tra gli asterischi. ; Scrivere 2 macro salta riga e salta colonna menu: ; verticale, orizzontale, fine. DOSSEG.MODEL SMALL STACK 200H.DATA SCELTA DB? MENU DB 'SCEGLI: ',10,13,'1- VERTICALE;',10,13,'2- ORIZZONTALE;',10,13,'3- FINE',10,13,'$'.CODE BEGIN: MOV AX,@DATA ; AX PUNTA AL DATA SEGMENT MOV DS,AX ; DS PUNTA AL DATA SEGMENT SALTARIGA MACRO MOV AH,02H MOV DL,13 MOV AH,02H MOV DL,10 ENDM SALTACOLONNA MACRO MOV AH,02H MOV DL,20H ENDM VAI: MOV AH,09H MOV DX, OFFSET MENU MOV AH,01H MOV SI,OFFSET SCELTA MOV [SI],AL CMP SCELTA,'1' JNE CONTROLLA SALTARIGA MOV CX,10 INIZIO: MOV AH,02H MOV DL,'*' ;STAMPA ASTERISCHI IN VERTICALE SALTARIGA LOOP INIZIO JMP VAI CONTROLLA: CMP SCELTA,'2' JNE CONTROLLA2 SALTARIGA TASM um 55 di 175

57 MOV CX,10 INIZIO2: MOV AH,02H MOV DL,'*' SALTACOLONNA LOOP INIZIO2 SALTARIGA CONTROLLA2: CMP SCELTA,'3' JE FINE JMP VAI FINE: MOV AX,4C00H END BEGIN 1- Verticale; 2- Orizzontale; 3- Fine 1 * * * * * * * * * * Scegli: 1- Verticale; 2- Orizzontale; 3- Fine 2 * * * * * * * * * * Scegli: 1- Verticale; 2- Orizzontale; 3- Fine 3 C:\Compiler\BORLANDC\Output> TASM um 56 di 175

58 ;Nome del programma: cerca.asm ;Programmatore: ;Descrizione ;Programma che legge da tastiera una parola (max 20 caratteri) ;e poi una frase (max 100 ;caratteri) ricerca la presenza della parola nella frase e stampa su video il risultato della ;ricerca. DOSSEG.MODEL SMALL.STACK.DATA MESS1 DB 13,10," RICERCA DI UNA PAROLA IN UNA FRASE",13,10 DB 13,10,"INSERIRE LA PAROLA DA CERCARE (MAX 20 CARATTERI)" DB 13,10,"UNA LETTERA PER VOLTA QUANDO COMPARE * " DB 13,10,"TERMINARE CON INVIO $" MESS2 DB 13,10,"*$" MESS3 DB 13,10,"INSERIRE LA FRASE CON NUMERO DI CARATTERI" DB 13,10,"NON SUPERIORE A 100 COMPRESI GLI SPAZI" DB 13,10," --TERMINA CON INVIO--",13,10,"$" RIS1 DB 13,10,"HO TROVATO LA PAROLA$" RIS2 DB 13,10,"NON HO TROVATO LA PAROLA$" FRASE DB 100 DUP(0) PAROLA DB 20 DUP(0) POS DW 0 NPAR DW 0 NFRASE DW 0.CODE INCLUDE MACRO.INC BEGIN: ;STAMPA MESS1 ;MEMORIZZA I CARATTERI DELLA PAROLA ;MEMORIZZA IN NPAR IL NUMERO DI CARATTERI MOV DI,OFFSET PAROLA MOV NPAR,0 INIZIO: MOV DX,OFFSET MESS2 MOV AH,9 ;STAMPA UN * PRIMA DI OGNI CARATTERE MOV AH,1 CMP AL,13 ;TERMINA CON INVIO JZ FINE INC NPAR MOV [DI],AL INC DI JMP INIZIO MESS3 ;HA STAMPATO MESS3 MOV DI,OFFSET FRASE MOV NFRASE,0 INIZ1: MOV AH,1 TASM um 57 di 175

59 ;LEGGE E MEMORIZZA I CARATTERI DELLA FRASE CMP AL,13 ;TERMINA CON INVIO JZ FINE1 INC NFRASE ;CONTA I CARATTERI MOV [DI],AL INC DI JMP INIZ1 FINE1: MOV DI,OFFSET FRASE ;PUNTA CON DI AI CARATTERI DELLA FRASE ;IN CX MEMORIZZA IL NUMERO DI RICERCHE DA FARE ;CHE SONO (NFRASE-NPAR+1) MOV CX,NFRASE MOV DX,NPAR SUB CX,DX INC CX ;SE IL NUMERO DI RICERCHE È NEGATIVO OPPURE 0 ESCE CMP CX,0 JLE NO ;PUNTA CON SI AI CARATTERI DELLA PAROLA ;CON BX PROCEDE NELLA RICERCA DOPO OGNI CARATTERE ;UGUALE TROVATO SUCC: MOV SI,OFFSET PAROLA MOV BX,0 ANCORA: MOV AL,[DI+BX] CMP AL,[SI+BX] JNE NOUG ;SE TROVA CARATTERI UGUALI CONFRONTA ;I CARATTERI SUCCESSIVI DELLA PAROLA E DELLA FRASE INC BX CMP BX,NPAR JZ OK ;SE HA CONFRONTATO CON SUCCESSO NPAR CARATTERI ;HA TROVATO LA PAROLA E TERMINA SE NUMERO DI CARATTERI CONFRONTATI ;È MINORE DI NPAR PROSEGUE JNZ ANCORA NOUG: INC DI ;SE TROVA 1 CARATTERE DIVERSO PROCEDE NELLA FRASE ;SE TERMINA LA RICERCA SENZA AVER TROVATO STAMPA IL MESSAGGIO RIS2 LOOP SUCC RIS2 JMP ESCI OK: MOV RIS1 ESCI:.EXIT END BEGIN C:\Compiler\BORLANDC\Output>cerca TASM um 58 di 175

60 RICERCA DI UNA PAROLA IN UNA FRASE INSERIRE LA PAROLA DA CERCARE (MAX 20 CARATTERI) UNA LETTERA PER VOLTA QUANDO COMPARE * TERMINARE CON INVIO *b *e *l *l *a * INSERIRE LA FRASE CON NUMERO DI CARATTERI NON SUPERIORE A 100 COMPRESI GLI SPAZI --TERMINA CON INVIO-- io possiedo una bella bicicletta per pedalare veloce HO TROVATO LA PAROLA C:\Compiler\BORLANDC\Output> TASM um 59 di 175

61 MACRO.INC verifica se tasto premuto; usa AH, AL, flag di ZERO se premuto AL = codice ;tasto ZF =1 se nessun tasto premuto AL=0 ZF = MACRO PUSH DX MOV DL,0FFH MOV AH,6 POP DX ENDM ;@LEGGI1:legge un numero di una cifra e lo trasforma in binario su AL (da 0 a 9);varia MACRO MOV AH,1 SUB AL,30H ENDM ;@MESSAG ETICH: scrive su video il messaggio posto all'indirizzo MACRO ETICH PUSH AX PUSH DX LEA DX,ETICH MOV AH,9 POP DX POP AX ENDM ;@ACAPO: manda a capo il MACRO PUSH AX PUSH DX MOV DL,13 MOV AH,2 MOV DL,10 MOV AH,2 POP DX POP AX ENDM ;@RIT GIRI: loop di ritardo breve (un solo ciclo) conteggio MACRO GIRI LOCAL AAA0 PUSH CX MOV CX,GIRI AAA0: NOP LOOP AAA0 POP CX ENDM TASM um 60 di 175

62 GIRI: loop di ritardo lungo (due cicli annidati) conteggio GIRI * MACRO GIRI LOCAL AAA0, AAA1 PUSH BX PUSH CX MOV CX,GIRI AAA0: MOV BX,65535 AAA1: DEC BX JNZ AAA1 LOOP AAA0 POP CX POP BX ENDM ;@LEGGI2: legge un numero di due cifre da tastiera il numero convertito da ASCII a ;binario è posto in AL modifica solo AX; AH è MACRO PUSH BX ;LEGGE MOV BL,10 MUL BL MOV BL,AL ;LEGGE UNITÀ E LE ADD AL,BL MOV AH,0 POP BX ENDM ;@LEGGI3: legge un numero di tre cifre da tastiera il numero convertito da ASCII a binario ;è posto in AX modifica solo MACRO PUSH BX PUSH CX ;LEGGE MOV BL,100 MUL BL MOV CX,AX ;LEGGE DECINE E ADD AX,CX POP CX POP BX ENDM ;@STAMP1: stampa un numero di una cifra su video alla posizione corrente del cursore la ;routine riceve il dato in AL; non modifica alcun MACRO PUSH AX TASM um 61 di 175

63 PUSH DX ;STAMPA NUMERO ADD AL,30H MOV DL,AL MOV AH,2 POP DX POP AX ENDM stampa un numero di tre cifre su video( da 0 a 999) alla posizione corrente del cursore la routine riceve il dato in AX e modifica solo MACRO PUSH BX PUSH DX ;TROVA CENTINAIA MOV BL,100 DIV BL ;SALVA IN BL DECINE E UNIT MOV BL,AH ;STAMPA ;CALCOLA DECINE E UNIT MOV AL,BL MOV AH,0 MOV BL,10 DIV BL MOV BL,AH ;UNIT SALVATE IN BL, STAMPA ;STAMPA UNIT MOV POP DX POP BX ENDM TASM um 62 di 175

64 VETTORI ;Nome del programma: array.asm ;Programmatore: ;Descrizione ;Programma che legge e stampa un array di caratteri. DOSSEG.MODEL SMALL.STACK 200H.DATA MESSAGGIO DB "INSERIRE 5 CHAR ",10D,13D,"$" V DB 5 DUP (?) CINQUE EQU 5H.CODE URN MACRO ;ritorno a capo MOV DL,0AH MOV AH,02H MOV DL,0DH MOV AH,02H ENDM BEGIN: MOV AX,@DATA MOV DS,AX LEA DX, MESSAGGIO ;stampa del messaggio MOV AH,09H MOV SI,0 ;lettura dell'array di char MOV CX,CINQUE CICLO: MOV AH,01 MOV V[SI],AL INC SI LOOP CICLO URN MOV SI,0 ;stampa dell'array di char MOV CX,CINQUE STAMPA: MOV DL,V[SI] MOV AH,02H INC SI LOOP STAMPA MOV AX,4C00H END BEGIN TASM um 63 di 175

65 ROUTINE ;Nome del programma: stampar.asm ;Programmatore: ;Descrizione ;Programma che stampa un messaggio. DOSSEG.MODEL SMALL.STACK 200H.DATA MESSAGGIO DB "Ciao, mondo $".CODE BEGIN: MOV MOV DS,AX CALL STAMPA MOV AX,4C00H ;Routine che stampa un messaggio ;Input: puntatore alla stringa da stampare ;Output: ;Registri distrutti: STAMPA PROC NEAR LEA DX, MESSAGGIO MOV AH,09H STAMPA ENDP END BEGIN TASM um 64 di 175

66 ;Nome del programma: somma.asm ;Programmatore: ;Descrizione ;Programma che addiziona due byte senza segno con il risultato in una word. DOSSEG.MODEL SMALL.STACK 200H.DATA ADD1 DB 0FFH ADD2 DB 1H SOMMA DW?.CODE BEGIN: MOV MOV DS,AX MOV AL,ADD1 MOV AH,ADD2 CALL TOTALE MOV SOMMA,BX MOV AX,4C00H ;Routine con passaggio parametri tramite registri ;Input: registro AX ;Output: registro BX ;Registri distrutti: TOTALE PROC NEAR PUSH AX MOV BH,0 MOV BL,AL ADD BL,AH ADC BH,0 POP BX TOTALE ENDP END BEGIN #include <stdio.h> #include <conio.h> TASM um 65 di 175

67 int somma (void); int main (void) { clrscr(); printf ("La somma vale = %X %d",somma(),somma()); getch(); return (0); } int somma (void) { asm { MOV AL,0FFH MOV AH,1H MOV BH,0 MOV BL,AL ADD BL,AH ADC BH,0 } return (_BX); } TASM um 66 di 175

68 ;Nome del programma: somma.asm ;Programmatore: ;Descrizione ;Programma che addiziona due byte senza segno con il risultato in una word. DOSSEG.MODEL SMALL.STACK 200H.DATA ADD1 DB 0FFH ADD2 DB 1H SOMMA DW?.CODE BEGIN: MOV MOV DS,AX MOV AX,0 PUSH AX MOV AL,ADD2 PUSH AX MOV AL,ADD1 PUSH AX CALL TOTALE POP AX POP AX POP SOMMA MOV AX,4C00H ;Routine con passaggio parametri tramite mediante lo stack ;Input: ;Output: ;Registri distrutti: TOTALE PROC NEAR PUSH BP MOV BP,SP PARAMETRO1 EQU [BP+4] PARAMETRO2 EQU [BP+6] PARAMETRO3 EQU [BP+8] MOV AX,PARAMETRO1 ADD AX,PARAMETRO2 MOV PARAMETRO3,AX POP BP TOTALE ENDP END BEGIN TASM um 67 di 175

69 TASM um 68 di 175

70 ;Nome del programma: ritardo.asm ;Programmatore: ;Descrizione ;Programma che genera un loop di ritardo. DOSSEG.MODEL SMALL.STACK 200H.CODE BEGIN: CALL RITARDO MOV AX,4C00H ;Routine di ritardo lunga 64K! ;Input: ;Output: ;Registri distrutti: RITARDO PROC NEAR MOV CX,0 DELAYLOOP: LOOP DELAYLOOP RITARDO ENDP END BEGIN TASM um 69 di 175

71 ;Nome del programma: proc1.asm ;Programmatore: ;Descrizione: ;Programma che stampa un carattere quadrato sullo schermo. DOSSEG.MODEL SMALL.CODE BEGIN: MOV DH,4 ; (NUMERO DI) RIGA IN CUI STAMPARE IL CARATTERE MOV DL,5 ; COLONNA DOVE VA STAMPATO IL CARATTERE MOV AL,254 ; VALORE ASCII DEL BLOCCHETTO DA VISUALIZZARE MOV BL,4 ; COLORE DI VISUALIZZAZIONE CALL PRINTCHAR ; STAMPA IL NOSTRO CARATTERE MOV AX,4C00H ;Routine che usa i registri per il passaggio dei parametri, (che sono la posizione in cui ;stamparlo, il colore, il codice ASCII del carattere da stampare). ;Input: ;Output: ;Registri distrutti: PRINTCHAR PROC NEAR PUSH BX ; SALVA I REGISTRI CHE VERRANNO DISTRUTTI PUSH CX XOR BH,BH ; AZZERA BH - PAGINA VIDEO 0 MOV AH,2 ; FUNZIONE 2 - SPOSTA IL CURSORE INT 10H ; LA RIGA E LA COLONNA SONO GIÀ IN DX XOR BH,BH ; PAGINA DI VISUALIZZAZIONE - 0 MOV AH,9 ; FUNZIONE 09H SCRIVE CARATTERE & ATTRIBUTO MOV CX,1 ; VISUALIZZALO UNA SOLA VOLTA INT 10H ; CHIAMA IL SERVIZIO DEL BIOS POP CX ; RIPRISTINA I REGISTRI POP BX ; RITORNA DOVE ERA STATA CHIAMATA PRINTCHAR ENDP END BEGIN TASM um 70 di 175

72 ;Nome del programma: proc2.asm ;Programmatore: ;Descrizione: ;Programma che stampa un carattere quadrato sullo schermo. DOSSEG.MODEL SMALL.CODE BEGIN: MOV DH,4 ; RIGA MOV DL,5 ; COLONNA MOV AL,254 ; CODICE ASCII DEL CARATTERE MOV BL,4 ; SUO COLORE PUSH DX AX BX ; METTE I PARAMETRI SULLO STACK CALL PRINTCHAR ; STAMPA IL CARATTERE POP BX AX DX ;RIPRISTINA I VALORI INIZIALI DEI REGISTRI MOV AX,4C00H ;Routine che usa usa lo stack per il passaggio dei parametri, (che sono la posizione in cui ;stamparlo, il colore, il codice ASCII del carattere da stampare). ;Input: ;Output: ;Registri distrutti: PRINTCHAR PROC NEAR PUSH BP ; SALVA IL VALORE DI BP MOV BP,SP ; COPIA SP DENTRO BP PUSH CX ; SALVA I REGISTRI CHE SARANNO MODIFICATI XOR BH,BH ; AZZERA BH - PAGINA VIDEO 0 MOV AH,2 ; FUNZIONE 2 - SPOSTA IL CURSORE MOV DX,[BP+8] ; RIPRISTINA IL PARAMETRO DX DALLO STACK INT 10H ; CHIAMA IL SERVIZIO DEL BIOS MOV AX,[BP+6] ; RIPRISTINA IL PARAMETRO CARATTERE MOV BX,[BP+4] ; E L'ATTRIBUTO XOR BH,BH ; PAGINA DEL DISPLAY - 0 MOV AH,9 ; FUNZIONE 09H STAMPA CAR & ATTRIBUTO MOV CX,1 ; LO STAMPA UNA SOLA VOLTA INT 10H ; CHIAMA IL SERVIZIO DEL BIOS POP CX ; RESTORE DEI REGISTRI POP BP ; RITORNA AL CHIAMANTE PRINTCHAR ENDP END BEGIN TASM um 71 di 175

73 ;Nome del programma: mul.asm ;Programmatore: ;Descrizione: ;Programma che moltiplica due byte usando solo istruzioni di somma. DOSSEG.MODEL SMALL STACK 200H.DATA INPMPD DB 13,13,'INTRODURRE IL MOLTIPLICANDO (0-255): $' INPMPR DB 13,'INTRODURRE IL MOLTIPLICATORE (0-255): $' OUTRES DB 13,'IL PRODOTTO VALE: $' STRING DB 100 DUP ('$').CODE BEGIN: MOV MOV DS,AX MOV DX,OFFSET INPMPD MOV AH,9 MOV DX,OFFSET STRING CALL READSTR MOV BX,OFFSET STRING CALL CHNUMB ;CALCOLA IL VALORE NUMERICO DELLA STRINGA MOV AH,0 PUSH AX ;MEMORIZZA MPD NELLO STACK MOV DX,OFFSET INPMPR MOV AH,9 MOV DX,OFFSET STRING CALL READSTR MOV BX,OFFSET STRING CALL CHNUMB MOV AH,0 PUSH AX ;MEMORIZZA MPR NELLO STACK MOV DX,OFFSET OUTRES MOV AH,9 POP AX ;ESTRAE MPR DALLO STACK MOV BH,AL ;POSIZIONA MPR PER LA MOLTIPLICAZIONE POP AX ;ESTRAE MPD DALLO STACK MOV BL,AL ;POSIZIONA MPD PER LA MOLTIPLICAZIONE MOV AX,0 MOV DX,AX MOV CX,8 ;CONTATORE DI BIT MULT: SHR BH,1 ;PRENDE IL BIT DI MPR JAE NOADD ;SE E' ZERO NON SOMMARE MOV AL,BL ADD DX,AX NOADD: SAL BL,1 ;SCORRE IL RISULTATO VERSO SINISTRA RCL AH,1 ;RECUPERA IL BIT LOOP MULT MOV AX,DX TASM um 72 di 175

74 CALL PRTNBR ;STAMPA IL NUMERO DONE: MOV AX,4C00H ;Routine che legge una stringa che deve terminare con CR ;Input: ;Output: la memorizza all'offset contenuto in DX ;Registri distrutti: READSTR PROC NEAR MOV AH,3FH ;LETTURA STRINGA MOV BX,0 MOV CX,100 ;LUNGHEZZA MASSIMA DELLA STRINGA READSTR ENDP ;Routine che esamina la stringa, se trova caratteri alfanumerici o numeri > ;esce con CF=1 condizione di errore, altrimenti esce con CF=0 ;Input: offset in BX ;Output: AX caricato con il numero letto ;Registri distrutti: CHNUMB PROC NEAR MOV CL,0 ;PREPARA IL CICLO RICERCA FINE STRINGA MOV AX,0 ;INIZIALIZZA IL RISULTATO RICERCA CHLOOP: MOV DL,[BX] ;ESAMINA IL PROSSIMO CARATTERE CMP DL,13 ;E' CR? JE FND ;SI SALTA A CR INC BX ;ALTRIMENTI CONTINUA INC CL JMP CHLOOP FND: MOV CH,CL ;TROVATO CR SALVA LA LUNGHEZZA DELLA STRINGA CMP CL,0 ;SE LA STRINGA E' NULLA ESCE CON AX=0 CLC ;E IL BIT DI RIPORTO AZZERATO JE EXTCHNU CMP CL,5 ;SE E' LUNGA 5 CARATTERI CONTROLLO IL VALORE ESATTO JE CONTR CMP CL,6 ;SE E' MINORE ALLORA SALTA ALLA CONVERSIONE NUMERICA JB CONVNBR EXERR: STC ;USCITA ERRORE PER TROPPE CIFRE JMP EXTCHNU CONTR: PUSH BX ;SALVA IL PUNTATORE ALLA STRINGA SUB BX,5 ;TORNA A INIZIO STRINGA MOV CL,[BX] ;ESAMINA IL PRIMO CARATTERE CMP CL,54 ;CONFRONTA CON 6 JBE CNTCON ;SE E' MINORE O UGUALE PROSEGUE ALTRIMENTI ESCE CON ERRORE EXERR1: POP BX JMP EXERR CNTCON: JNE CONVNUM ;SALTA A CONVERSIONE SE E' DIVERSO DA 6 TASM um 73 di 175

75 INC BX ;PROSEGUE IL CONTROLLO CON LA PROSSIMA CIFRA MOV CL,[BX] ;PRENDE LA CIFRA CMP CL,53 ;E' UN 5? JA EXERR1 ;MAGGIORE ESCE CON ERRORE JB CONVNUM ;MINORE SALTA A CONVERSIONE INC BX ;UGUALE PROSEGUE CON LA TERZA CIFRA MOV CL,[BX] ;PRENDE LA CIFRA CMP CL,53 ;E' UN ALTRO 5? JA EXERR1 ;MAGGIORE ESCE CON ERRORE JB CONVNUM ;MINORE SALTA A CONVERSIONE INC BX ;UGUALE PROSEGUE CON LA QUARTA CIFRA MOV CL,[BX] ;PRENDE LA CIFRA CMP CL,51 ;E' UN 3? JA EXERR1 ;MAGGIORE ESCE CON ERRORE JB CONVNUM ;MINORE SALTA A CONVERSIONE INC BX ;UGUALE PROSEGUE CON L'ULTIMA CIFRA MOV CL,[BX] ;PRENDE LA CIFRA CMP CL,53 ;E' UN ALTRO 5? JA EXERR1 ;MAGGIORE ESCE CON ERRORE CONVNUM: POP BX ;CONVERSIONE NUMERICA CONVNBR: MOV SI,0 ;SI CONTIENE IL RISULTATO DELLA CONVERSIONE MOV DI,1 ;DI E' IL PESO DELLE CIFRE DECIMALI MOV BP,10 ;BP E' LA BASE NUMERICA DEC BX ;POSIZIONE SULLA PRIMA CIFRA A DESTRA MOLL: MOV AL,[BX] ;PRENDE LA CIFRA CORRENTE CMP AL,48 ;CONFRONTA CON 0 JAE RANX1 ;SE MAGGIORE O UGUALE CONTINUA ERRAN: JMP EXERR ;ALTRIMENTI ESCE CON ERRORE RANX1: CMP AL,57 ;CONFRONTA CON 9 JA ERRAN ;SE MAGGIORE ESCI CON ERRORE SUB AL,48 ;CONVERTE DA ASCII A NUMERO MOV AH,0 ;AZZERA IL BYTE ALTO PER LA MOLTIPLICAZIONE MUL DI ;CONFERISCE ALLA CIFRA IL GIUSTO PESO ADD SI,AX ;SOMMA LA CIFRA SHIFTATA AL TOTALE MOV AX,DI ;AGGIORNA IL PESO CORRENTE PER CONVERTIRE LA PROSSIMA CIFRA MUL BP MOV DI,AX DEC BX ;PROSSIMA CIFRA DEC CH ;FINITO? JNE MOLL ;NO ALLORA RIPETI IL CICLO MOV AX,SI ;IN USCITA COPIA IL RISULTATO IN AX CLC EXTCHNU: CHNUMB ENDP ;Routine che stampa a video un numero intero compreso tra 0 e ;Input: AX ;Output: TASM um 74 di 175

76 ;Registri distrutti: PRTNBR PROC NEAR MOV CH,0 MOV SI,10 LDIV1: MOV DX,0 DIV SI ADD DL,48 PUSH DX INC CH CMP AX,0 JNE LDIV1 LOS1: POP DX MOV AH,2 DEC CH JNE LOS1 PRTNBR ENDP END BEGIN ;CONTATORE DELLE CIFRE ;BASE NUMERICA ;PREPARA PER LA SCOMPOSIZIONE ;DIVISIONE DEL NUMERO PER LA BASE ;CONVERTE DA NUMERO AD ASCII ;MEMORIZZA LA CIFRA NELLO STACK ;INCREMENTA IL CONTATORE DELLE CIFRE ;FINITO? ;NO ALLORA RIPETI IL CICLO ;PRELEVA LA CIFRA DALLO STACK ;FINITO? ;NO ALLORA RIPETI IL CICLO C:\Compiler\BORLANDC\Output>mul INTRODURRE IL MOLTIPLICANDO (0-255): 34 INTRODURRE IL MOLTIPLICATORE (0-255): 56 IL PRODOTTO VALE: 1904 C:\Compiler\BORLANDC\Output> TASM um 75 di 175

77 ;Nome del programma: binesa.asm ;Programmatore: ;Descrizione ;Programma che chiede da tastiera un numero minore di 256 (base 10) e lo converte da ;ASCII a BINARIO, stampa su video il valore binario e quello esadecimale. DOSSEG.MODEL SMALL.STACK.DATA NUM DB 0 FATT DB 100,10,1 MESS1 DB 13,10,"BATTI UN NUMERO MINORE DI 256 N=$" MESS2 DB 13,10,"IL VALORE BINARIO E' B=" BINAR DB " E IL VALORE ESADECIMALE E' H=" ESAD DB " $".CODE BEGIN: ;ACQUISISCE DA TASTIERA UN NUMERO N<256 ;LO CONVERTE IN BINARIO E LO MEMORIZZA IN NUM MOV AH,9 MOV DX,OFFSET MESS1 MOV SI,OFFSET FATT MOV CX,3 INIZ: MOV AH,1 SUB AL,30H MUL BYTE PTR [SI] ADD NUM,AL INC SI LOOP INIZ ;ESEGUE LA CONVERSIONE IN 8 CARATTERI ASCII ;CHE RAPPRESENTANO IL VALORE BINARIO DI NUM CALL BIN ;CALCOLA LE DUE CIFRE ESADECIMALI CORRISPONDENTI A NUM, ;LE TRASFORMA IN CARATTERI ASCII MEMORIZZATI IN ESA CALL ESA ;STAMPA IL CODICE ASCII COL SUO VALORE DECIMALE MOV AH,9 MOV DX,OFFSET MESS2 ;CHIAMA LA FUNZIONE DI USCITA AL DOS.EXIT ;Routine che trasforma un numero ad 8 bit contenuto in num, in 8 caratteri ASCII che ne ;rappresentano il valore binario memorizzati nella stringa binaria ;Input: ;Output: ;Registri distrutti: BIN PROC NEAR PUSH CX PUSH AX PUSH SI MOV SI,OFFSET BINAR TASM um 76 di 175

78 MOV AL,NUM CLC MOV CX,8 B: SHL AL,1 ;MEMORIZZA IL CARATTERE 0 (30H) MOV BYTE PTR [SI],30H ;SE CF=0 30H E' ESATTO JNC ZERO ;ALTRIMENTI LO INCREMENTA (31H, CARATTERE 1) INC BYTE PTR [SI] ZERO: INC SI LOOP B POP SI POP AX POP CX BIN ENDP ;Routine che calcola le due cifre esadecimali corrispondenti a num, le memorizza in codice ;ASCII nella stringa esad ;Input: ;Output: ;Registri distrutti: ESA PROC NEAR PUSH CX MOV CH,NUM MOV CL,4 SHR CH,CL ADD CH,30H CMP CH,39H JBE DECIM ADD CH,7 DECIM: MOV ESAD,CH MOV CH,NUM AND CH,0FH ADD CH,30H CMP CH,39H JBE DECIM1 ADD CH,7 DECIM1: MOV ESAD+1,CH POP CX ESA ENDP END BEGIN TASM um 77 di 175

79 ;Nome del programma: palette.asm ;Programmatore: ;Descrizione ;Programma per la modifica delle palette. (modalità 320x colori.) ;Legenda: * ;[q] = aumenta componente rossa, [a] = decrementa componente rossa ;[w] = aumenta componente verde, [s] = decrementa componente verde ;[e] = aumenta componente blue, [d] = decrementa componente blue ;[+],[-] = cambiano il registro da modificare ;[x] = uscita DOSSEG.286.MODEL SMALL.STACK 200H.DATA TITOLO DB ' PALETTE MODIFIER','$' TASTO_A DB 'A= DECREMENTS RED COMPONENT','$' TASTO_S DB 'S= DECREMENTS GREEN COMPONENT','$' TASTO_D DB 'D= DECREMENTS BLUE COMPONENT','$' TASTO_Q DB 'Q= INCREMENTS RED COMPONENT','$' TASTO_W DB 'W= INCREMENTS GREEN COMPONENT','$' TASTO_E DB 'E= INCREMENTS BLUE COMPONENT','$' TASTO_P_M DB '+,-= CHANGE REGISTER TO MODIFY','$' TASTO_X DB 'X= TO QUIT','$' REG_ON DB 'MODIFIED COLOR NØ ','$' RED_VAL DB 'VALUE OF THE RED COMPONENT:','$' GREEN_VAL DB 'VALUE OF THE GREEN COMPONENT:','$' BLUE_VAL DB 'VALUE OF THE BLUE COMPONENT:','$' WARNING DB 'WARNING!COLOR 0 IS COLOR OF BACKGROUND','$' QUIT DB 'PRESS X TO QUIT.','$' X DW? ;VALORE X DISP_X DW? ;VALORE ARRIVO DI X OLD_X DW? ;VALORE DI PARTENZA X Y DW? ;VALORE Y DISP_Y DW? ;VALORE ARRIVO Y COLORE DB? ;VALORE COLORE RED DB? ;VALORE COMP. ROSSA GREEN DB? ;VALORE COMP. VERDE BLUE DB? ;VALORE COMP. BLUE CENTINAIA DB? DECINE DB? UNITA DB? REG DB? ;VALORE REG MODIFICATO POS_CUR DB? ;POSIZIONE CURSORE.CODE ; ROUTINE DI PLOTTAGGIO DI 256 TANGOLI COLORATI CON I RISPETTIVI COLORI. BEGIN: MOV AX,@DATA MOV DS,AX ; FA PUNTARE DS AL SEG. DATI MOV AX,0A000H MOV ES,AX ; FA PUNTARE ES AL SEG. DI MEMEORIA VIDEO MOV AH,0 MOV AL,13H TASM um 78 di 175

80 INT 10H ; IMPOSTA LA MODALIT 320X COLORI MOV COLORE,0 ; \ MOV X,0 ; \ MOV DISP_X,15 ; \ MOV OLD_X,0 ; INIZIALIZZA VARIABILI MOV Y,0 ; / MOV DISP_Y,9 ; / MOV REG,0 ; / MOV POS_CUR,0 CALL _CLRSCR CICLO: XOR AX,AX ; AZZERA AX MOV AX,320 ; IMPOSTA AX 320 \ MUL Y ; MOLTIPLICA AX PER Y CALCOLO OFFSET ADD AX,X ; SOMMA AD AX X / MOV BX,AX ; SPOSTA L'OFFSET IN BX MOV CL,COLORE ; IMPOSTA CL CON IL NUMERO DEL COLORE MOV ES:[BX],CL ; SCRIVE IN MEMORIA VIDEO MOV AX,X MOV BX,DISP_X CMP AX,BX ; CONTROLLA SE Š STATA DISEGNATA UNA LINEA JE RESTART ; SE SI SALTA A RESTART INC X ; INCREMENTA LA X JMP CICLO RESTART: MOV AX,Y MOV BX,DISP_Y CMP AX,BX ; CONTROLLA SE Š STATA DISEGNATA L'ULTIMA RIGA JE MAIN ; SE SI SALTA A MAIN MOV AX,OLD_X MOV X,AX ; REIMPOSTA LA X CON IL SUO VALORE INIZIALE INC Y ; INCREMENTA LA Y JMP CICLO ; RICOMINCIA MAIN: CMP COLORE,255 ; CONTROLLA SE Š STATO DISEGNATO L'ULTIMO TANGOLO JE A_SETTA ; SE SI SALTA A A_SETTA INC COLORE ; INCREMENTA IL COLORE CMP Y,149 ; CONTROLLA SE E STATA DISEGNATA UNA COLONNA JE MAIN_2 ; SE SI SALTA A MAIN_2 INC Y ; INCREMENTA LA Y ADD DISP_Y,10 ; INCREMENTA IL VALORE DI ARRIVO DELLA Y MOV AX,OLD_X MOV X,AX ; REIMPOSTA LA X CON IL SUO VALORE INIZIALE JMP CICLO ; RICOMINCIA MAIN_2: MOV Y,0 ; \ MOV DISP_Y,9 ; \ INC X ; \ ADD DISP_X,16 ; REIMPOSTA TUTTE LA VARIABILI MOV AX,X ; / MOV OLD_X,AX ; / JMP CICLO ; / ;PROGRAMMA PRINCIPALE CHE CONTROLLA QUALE TASTO E' STATO PREMUTO TASM um 79 di 175

81 A_SETTA: CALL _STAMPA_FRASI SETTA: CALL _READ_REG ; LEGGE IL REGISTRO SELEZIONATO CALL _STAMPA ; STAMPA LE INFORMAZIONI MOV AH,08H ; SYSTEM CALL ; LEGGE UN CARATTERE DALLO STANDARD INPUT CMP AL,'Q' JE MOD_DH CMP AL,'W' JE MOD_CH CMP AL,'E' JE MOD_CL CMP AL,'A' JE DEC_DH CMP AL,'S' JE DEC_CH CMP AL,'D' JE DEC_CL CMP AL,'+' JE INC_REG CMP AL,'-' JE DEC_REG CMP AL,'X' ; CONTROLLA SE E' STATA PREMUTA LA X JNE SETTA ; SE NO RICOMINCIA MOV AX,0003H INT 10H ; ALTRIMENTI SETTA LA MODALITA' STANDARD MOV AH,4CH ; RITORNA AL DOS MOD_DH: INC RED ; INCREMENTA RED CALL _SALVA ; SALVA I CAMBIAMENTI JMP SETTA ; RICOMINCIA MOD_CH: INC GREEN ; INCREMENTA GREEN CALL _SALVA ; SALVA I CAMBIAMENTI JMP SETTA ; RICOMINCIA MOD_CL: INC BLUE ; INCREMENTA BLUE CALL _SALVA ; SALVA I CAMBIAMENTI JMP SETTA ; RICOMINCIA DEC_DH: DEC RED ; DECREMENTA RED CALL _SALVA ; SALVA I CAMBIAMENTI JMP SETTA ; RICOMINCIA DEC_CH: DEC GREEN ; DECREMENTA GREEN CALL _SALVA ; SALVA I CAMBIAMENTI JMP SETTA ; RICOMINCIA DEC_CL: DEC BLUE ; DECREMENTA BLUE CALL _SALVA ; SALVA I CAMBIAMENTI JMP SETTA ; RICOMINCIA INC_REG: TASM um 80 di 175

82 INC REG ; INCREMENTA REG JMP SETTA ; RICOMINCIA DEC_REG: DEC REG ; DECREMENTA REG JMP SETTA ; RICOMINCIA ; PROCEDURA PER LEGGERE UN REGISTRO DELLA VGA _READ_REG PROC NEAR MOV DX,3C7H ; PEL ADDRESS (READ MODE) MOV AL,REG ; NUMERO DEL REGISTRO DA LEGGERE OUT DX,AL ; SCRITTURA DATO MOV DX,3C9H ; PEL DATA REGISTER IN AL,DX ; LETTURA DATO MOV RED,AL ; \ IN AL,DX ; \ MOV GREEN,AL ; SALVATAGGIO DATI (R.G.B.) IN AL,DX ; / MOV BLUE,AL ; / CODE _READ_REG ENDP ; PROCEDURA PER MODIFICARE UN REGISTRO DELLA VGA _SALVA PROC NEAR MOV DX,3C8H ; PEL ADDRESS (WRITE MODE) MOV AL,REG ; NUMERO DEL REGISTRO DA MODIFICARE OUT DX,AL ; SCRITTURA DATO MOV DX,3C9H ; PEL DATA REGISTER MOV AL,RED ; \ OUT DX,AL ; \ MOV AL,GREEN ; \ OUT DX,AL ; SCRITTURA DATI MOV AL,BLUE ; / OUT DX,AL ; / CODE ; / _SALVA ENDP ; PROCEDURA PER STAMPARE SU VIDEO LE INFORMAZIONI _STAMPA_FRASI PROC NEAR CALL _SET_CUR_POS MOV AX,0900H ; SYSTEM CALL MOV DX,OFFSET REG_ON ; OFFSET STRINGA ; STAMPA FRASE CALL _SET_CUR_POS MOV AX,0900H ; SYSTEM CALL MOV DX,OFFSET RED_VAL ; OFFSET STRINGA ; STAMPA FRASE CALL _SET_CUR_POS MOV AX,0900H ; SYSTEM CALL MOV DX,OFFSET GREEN_VAL ; OFFSET STRINGA ; STAMPA FRASE CALL _SET_CUR_POS MOV AX,0900H ; SYSTEM CALL MOV DX,OFFSET BLUE_VAL ; OFFSET STRINGA ; STAMPA FRASE CALL _SET_CUR_POS MOV AX,0900H ; SYSTEM CALL MOV DX,OFFSET WARNING ; OFFSET STRINGA TASM um 81 di 175

83 ; STAMPA FRASE CALL _SET_CUR_POS MOV AX,0900H ; SYSTEM CALL MOV DX,OFFSET QUIT ; OFFSET STRINGA ; STAMPA FRASE CODE _STAMPA_FRASI ENDP ; PROCEDURA PER STAMPARE SOLO I VALORI DEI REGISTRI VGA _STAMPA PROC NEAR XOR AX,AX ; AZZERA AX MOV AL,REG CALL _CONV_REG ; CONVERTE IL NUMERO IN REG IN CODICE ASCII MOV AX,0200H ; SYSTEM CALL MOV BH,0 ; COLONNA MOV DX,1312H ; RIGA INT 10H ; POSIZIONA IL CURSORE MOV AX,0200H ; SYSTEM CALL MOV DL,CENTINAIA ; CARATTERE DA STAMPARE ; STAMPA IL CARATTERE CALL _STAMPA_NUM ; STAMPA LE ALTRE DUE CIFRE XOR AX,AX ; AZZERA AX MOV AL,RED CALL _CONV_REG ; CONVERTE IL NUMERO IN RED IN CODICE ASCII MOV AX,0200H ; SYSTEM CALL MOV BH,0 ; COLONNA MOV DX,141BH ; RIGA INT 10H ; POSIZIONA IL CURSORE CALL _STAMPA_NUM ; STAMPA LE DUE CIFRE XOR AX,AX ; AZZERA AX MOV AL,GREEN CALL _CONV_REG ; CONVERTE IL NUMERO IN GREEN IN CODICE ASCII MOV AX,0200H ; SYSTEM CALL MOV BH,0 ; COLONNA MOV DX,151DH ; RIGA INT 10H ; POSIZIONA IL CURSORE CALL _STAMPA_NUM ; STAMPA I DUE NUMERI XOR AX,AX ; AZZERA AX MOV AL,BLUE CALL _CONV_REG ; CONVERTE IL NUMERO IN BLUE IN CODICE ASCII MOV AX,0200H ; SYSTEM CALL MOV BH,0 ; COLONNA MOV DX,161CH ; RIGA INT 10H ; POSIZIONA IL CURSORE CALL _STAMPA_NUM ; STAMPA I DUE NUMERI CODE _STAMPA ENDP ; PROCEDURA PER CONVERTIRE UN NUMERO (0..99) IN CODICE ASCII _CONV PROC NEAR MOV CL,10 ; IMPOSTA CL A 10 DIV CL ; DIVIDE AL PER CL ADD AX,3030H ; SOMMA SI AD AL CHE AD AH 48 MOV DECINE,AL ; MEMORIZZA IL RESTO MOV UNITA,AH ; MEMORIZZA IL QUOZIENTE CODE TASM um 82 di 175

84 _CONV ENDP ; PROCEDURA PER STAMPARE DUE NUMERI _STAMPA_NUM PROC NEAR MOV AX,0200H ; SYSTEM CALL MOV DL,DECINE ; CARATTERE DA STAMPARE ; STAMPA CARATTERE MOV AX,0200H ; SYSTEM CALL MOV DL,UNITA ; CARATTERE DA STAMPARE ; STAMPA CARATTERE CODE _STAMPA_NUM ENDP ; PROCEDURA PER CONVERTIRE UN NUMERO (0..999) IN CODICE ASCII _CONV_REG PROC NEAR MOV CL,10 ; IMPOSTA CL A 10 DIV CL ; DIVIDE AL PER CL ADD AH,30H ; SOMMA AL RESTO 48 MOV UNITA,AH ; MEMORIZZA IL RESTO MOV AH,0 ; IMPOSTA AH A 0 DIV CL ; DIVIDE AL PER 10 ADD AX,3030H ; SOMMA SIA AD AL CHE AH 48 MOV DECINE,AH ; MEMORIZZA IL RESTO MOV CENTINAIA,AL ; MEMORIZZA IL QUOZIENTE CODE _CONV_REG ENDP _SET_CUR_POS PROC NEAR MOV AX,0200H ; SYSTEM CALL MOV BH,0 ; COLONNA MOV DH,POS_CUR ; RIGA MOV DL,00H ; COLONNA INT 10H ; POSIZIONA IL CURSORE INC POS_CUR CODE _SET_CUR_POS ENDP _CLRSCR PROC NEAR CALL _SET_CUR_POS MOV AX,0900H MOV DX,OFFSET TITOLO CALL _SET_CUR_POS CALL _SET_CUR_POS MOV AX,0900H MOV DX,OFFSET TASTO_A CALL _SET_CUR_POS MOV AX,0900H MOV DX,OFFSET TASTO_S CALL _SET_CUR_POS MOV AX,0900H MOV DX,OFFSET TASTO_D CALL _SET_CUR_POS CALL _SET_CUR_POS MOV AX,0900H TASM um 83 di 175

85 MOV DX,OFFSET TASTO_Q CALL _SET_CUR_POS MOV AX,0900H MOV DX,OFFSET TASTO_W CALL _SET_CUR_POS MOV AX,0900H MOV DX,OFFSET TASTO_E CALL _SET_CUR_POS CALL _SET_CUR_POS MOV AX,0900H MOV DX,OFFSET TASTO_P_M CALL _SET_CUR_POS CALL _SET_CUR_POS MOV AX,0900H MOV DX,OFFSET TASTO_X MOV AX,0800H MOV POS_CUR,19 CODE _CLRSCR ENDP END BEGIN TASM um 84 di 175

86 ;Nome del programma: passwd.asm ;Programmatore: ;Descrizione ;Programma per la gestione della password. DOSSEG.MODEL SMALL.STACK 200H.DATA PRESENTA1 DB ' ÉÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ»',13,10,'$' PRESENTA2 DB ' º P A S S W O R D ',13,10,'$' PRESENTA3 DB ' º ',13,10,'$' PRESENTA4 DB ' º ',13,10,'$' PRESENTA5 DB ' ÈÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍͼ',13,10,'$' ;MESSAGGIO PER LA RICHIESTA DELLA DEFINIZIONE DELLA PASSWORD PRIPWD DB 'DEFINISCI LA PASSWORD : $' ;MESSAGGIO PER LA RICHESTA DI CONFERMA DELLA PASSWORD SECPWD DB 'CONFERMA LA PASSWORD : $' ;MESSAGGIO PER LA RICHIESTA DELLA PASSWD RICCHI DB 'Ø TENTATIVO. INSERISCI LA PASSWORD : $' ;MESSAGGIO DI RICONOSCIMENTO DELLA PASSWD GIUSTO DB 'PASSWORD RICONOSCIUTA.',13,10,'ACCESSO CONCESSO.',13,10,'$' ;MESSAGGIO DI NON RICINOSCIMENTO DELLA PASSWD SBAGLIATO DB 'PASSWORD NON RICONOSCIUTA.',13,10,'ACCESSO NEGATO.',13,10,'$' ;MESSAGGIO DI ERRATA RIPETIZIONE DELLA PASSWORD ERRINS DB 'ERRATA DEFINIZIONE DELLA PASSWORD.',10,13,'$' ;MESSAGGIO DI CONTROL-C CONTROLC DB 'INTERRUZIONE NON CONCESSA. INSERISCI LA PASSWORD.',10,13,'$' ;CARATTERI DA NON INTERPARE SKIP DB 0,1,2,3,4,5,6,7,11,12,14,15,17,18,22,23,24,25,26,'$' NASCONDI DB 'X' ;CODICE CARATTERE CHE NASCONDE LE LETTERE DELLA ;PASSWORD SPACE DB ' ' ;CODICE CARATTERE SPACE NCHI DB '0' ;CODICE CARATTERE 0 NCHI3 DB '3' ;CODICE CARATTERE 3 URN DB 10,13,'$' ;SEQUENZA DI CARATTERI PER ANDARE A CAPO BUFF DB 8 DUP (?) ;8 BYTE (CARATTERI) PRIPASSWD DB 8 DUP (?) ;8 BYTE (CARATTERI) SECPASSWD DB 8 DUP (?) ;8 BYTE (CARATTERI) PASSWD DB 8 DUP (?) ;8 BYTE (CARATTERI) APPL DB 1 DUP (?) ;1 BYTE (VARIABILE DI APPOGGIO DI 1 BYTE) APPH DB 1 DUP (?) ;1 BYTE (VARIABILE DI APPOGGIO DI 1 BYTE) XPOS DB 1 DUP (?) ;1 BYTE (NØ COLONNA DEL CURSORE) XPOS2 DB 1 DUP (?) ;1 BYTE (NØ COLONNA DEL CURSORE) IXPOS DB 1 DUP (?) ;1 BYTE (NØ COLONNA DEL CURSORE YPOS DB 1 DUP (?) ;1 BYTE (NØ RIGA DEL CURSORE) YPOS2 DB 1 DUP (?) ;1 BYTE (NØ RIGA DEL CURSORE) IYPOS DB 1 DUP (?) ;1 BYTE (NØ RIGA DEL CURSORE) PAGINA DB 1 DUP (?) ;1 BYTE (NØ PAGINA VIDEO) FBREAK DB 1 DUP (?) ;1 BYTE (FLAG DI CONTROL-C) MODO DB 1 DUP (?) ;FLAG DI 1 BYTE SE 1 MOSTRA IL CARATTERE LETTO TASM um 85 di 175

87 ; SE 0 NASCONDE IL CARATTERE LETTO.CODE BEGIN: ;SETTAGGIO DEI REGISTRI E DELLE VARIABILI UTILIZZATE MOV AX,@CODE ;IMPOSTAZIONE DELLA PROCEDURA DELL MOV DS,AX ;INTERRUPT 23H (CONTROL-C) DEL DOS MOV DX,OFFSET BREAK ;UTILIZZANDO LA FUNZIONE 25H DELL' MOV AH,25H ;INTERRUPT 21H DEL DOS MOV AL,23H MOV AX,@DATA MOV DS,AX MOV ES,AX MOV AH,0FH ;LEGGE LA PAGINA VIDEO CORRENTE INT 10H ;UTILIZZANDO LA FUNZIONE 0FH DELL' MOV PAGINA,BH ;INTERRUPT 10H DEL BIOS MOV AH,00 ;IMPOSTA LO SCERMO 80X25 MOV AL,02 ;UTILIZZANDO LA FUNZIONE 00H DELL' INT 10H ;INTERUPT 10H DEL BIOS MOV XPOS,00 ;POSIZIONA IL CURSORE PER SCRIVERE MOV YPOS,02 ;LA PRESENTAZIONE CALL POSCURS MOV DX,OFFSET PRESENTA1 ;SCRIVE LA PRESENTAZIONE CALL SCRIVIMESS MOV DX,OFFSET PRESENTA2 CALL SCRIVIMESS MOV DX,OFFSET PRESENTA3 CALL SCRIVIMESS MOV DX,OFFSET PRESENTA4 CALL SCRIVIMESS MOV DX,OFFSET PRESENTA5 CALL SCRIVIMESS MOV YPOS,13 ;POSIZIONA IL CURSORE CALL POSCURS PRIMAPWD: MOV CL,03 ;CANCELLA LE RIGHE SU CUI DEVE CALL DELRIG ;SCRIVERE MOV DX,OFFSET PRIPWD ;SCRIVE MESSAGGIO DI DEFINIZIONE CALL SCRIVIMESS ;DELLA PASSWORD MOV MODO,00 ;LEGGE LA PASSWORD NASCONDO I CALL INPUTPWD ;CARATTERI MOV SI,OFFSET BUFF MOV DI,OFFSET PRIPASSWD MOV CX,08 REP MOVSB MOV DX,OFFSET SECPWD ;SCRIVE MESSAGGIO DI CONFERMA CALL SCRIVIMESS ;DELLA PASSWORD MOV MODO,00 ;LEGGE LA PASSWORD NASCONDENDO I CALL INPUTPWD ;CARATTERI MOV SI,OFFSET BUFF MOV DI,OFFSET SECPASSWD MOV CX,08 REP MOVSB MOV SI,OFFSET PRIPASSWD ;CONFRONTA LA PASSWORD CON LA TASM um 86 di 175

88 MOV DI,OFFSET SECPASSWD ;SUA RIPETIZIONE MOV CX,08 REP CMPSB JNE ERRORE ;SE SONO DIVERSE SALTA A ERRORE MOV DX,OFFSET URN CALL SCRIVIMESS INPUTCHI: INC NCHI ;INCREMENTA IL CONTATORE TENTATIVI MOV DL,NCHI ;SCRIVE NØ TENTATIVI CALL SCRIVICAR MOV DX,OFFSET RICCHI ;SE SONO UGUALI CALL SCRIVIMESS ;SCRIVE MESSAGGIO DI RICHIESTA MOV MODO,01 ;DELLA PASSWD CALL INPUTPWD ;LEGGE LA PASSWD MOSTRANDO I MOV SI,OFFSET BUFF ;CARATTERI MOV DI,OFFSET PASSWD MOV CX,08 REP MOVSB MOV SI,OFFSET PRIPASSWD ;CONFRONTA LA PASSWORD DEFINITA CON MOV DI,OFFSET PASSWD ;LA PASSWORD INSERITA MOV CX,08 REP CMPSB JNE DIVERSE ;SE SONO DIVERSE SALTA A DIVERSE MOV DX,OFFSET GIUSTO CALL SCRIVIMESS ;SE SONO UGUALI SCRIVE MESSAGGIO JMP EXIT ;DI ACCESSO CONCESSO E TERMINA DIVERSE: MOV DX,OFFSET SBAGLIATO ;SE SONO DIVERSE SCRIVE MESSAGGIO CALL SCRIVIMESS ;DI ACCESSO NEGATO CALL PAUSA ;EFFETTUA UNA PAUSA MOV CL,03 CALL DELRIG MOV AL,NCHI ;CONTROLLA SI SONO FATTI TRE CMP AL,NCHI3 ;TENTATIVI JNE INPUTCHI ;SE NO RICHIEDE LA PASSWORD SALTA MOV AH,00 ;A INPUTCHI MOV AL,02 INT 10H INT 19H ;SE SI RESETTA IL PC ;CHIAMANDO L'INTERRUPUT 19H DEL DOS ERRORE: MOV DX,OFFSET ERRINS ;SE SONO DIVERSE SCRIVE MESSAGGIO CALL SCRIVIMESS ;DI ERRORE CALL PAUSA ;PAUSA JMP PRIMAPWD ;RICHIEDE LA PASSWORD (PRIMAPWD) EXIT: MOV AH,4CH ;PROCEDURA DELL'INTERRUPT 23H VIENE ESEGUTA QUANDO SI VERIFICA UN ;CONTROL-C PROC BREAK CALL SALVAREG ;SALVA I REGISTRI MOV AH,YPOS ;SALVA LA POSIZIONE DEL CURSORE TASM um 87 di 175

89 MOV AL,XPOS ;PRIMA DEL CONTROL-C MOV YPOS2,AH MOV XPOS2,AL CALL POSCURS ;POSIZIONA CURSORE MOV CL,02 ;CANCELLA IL SIMBOLO DI CONTROL-C MOV DL,SPACE ;(^C) CICLO1: CALL SCRIVICAR DEC CL CMP CL,00 JNE CICLO1 CMP FBREAK,01 ;CONTROLLA SE DURANTE L'INSRIMENTO JE CICLO2 ;SI Š GI INCONTRATO UN CONTROL-C MOV YPOS,21 ;SE SI SALTA A SALTA8 MOV XPOS,13 ;SE NO SCRIVE IL MESSAGGIO DI CALL POSCURS ;INTERRUZIONE NON CONCESSA MOV DX,OFFSET CONTROLC CALL SCRIVIMESS MOV AH,YPOS2 ;RIPRISTINA LA POSIZIONE DEL MOV AL,XPOS2 ;CURSORE PRIMA DEL CONTROL-C MOV XPOS,AL MOV YPOS,AH MOV FBREAK,01 ;SETTA IL FLAG DI MESSAGGIO CICLO2: CALL POSCURS ;POSIZIONA CURSORE CALL CARICAREG ;RIPRISTINA I VECCHI REGISTRI I ;FINE FUNZIONE ENDP BREAK ;FUNZIONE CHE CANCELLA NØ LINEE SPECIFICATE DA CL SOPRA LA POSIZIONE CORRENTE DEL CURSORE E SI POSIZIONA SULLA PRIMA LINEA CANCELLATA PROC DELRIG CALL SALVAREG ;SALVA I REGISTRI CALL LPOSCURS ;LEGGE LA POSIZIONE DEL CURSORE MOV AL,YPOS ;SOTTRAE ALLA ORDINATA DEL CRSORE SUB AL,CL ;IL NUMERO DI LINEE DA CANCELLARE MOV YPOS,AL CALL POSCURS ;POSIZIONE IL CURSORE CICLO3: MOV CH,50H ;SCRIVE 80 SPAZI PER RIGA MOV DL,SPACE CICLO4: CALL SCRIVICAR DEC CH CMP CH,00 JNE CICLO4 DEC CL CMP CL,00 ;SALTA A CICLO3 FINO A QUANDO CL JNE CICLO3 ;E MAGGIORE DI 0 CALL POSCURS ;RIPOSIZIONA IL CURSORE AL INIZIO CALL CARICAREG ;RIPRIVTINA I VECCHI REGISTRI ;FINE FUNZIONE ENDP DELRIG ;FUNZIONE CHE EFFETTUA UNA PAUSA PER LASCIARE IL TEMPO DI LEGGERE I ;MESSAGGI TASM um 88 di 175

90 PROC PAUSA CALL SALVAREG ;SALVA I REGISTRI MOV AX,0FH ;ESEGUE UN DOPPIO CICLO MOV CX,00 ;DECREMENTANDO CX DA 0 A FFFFH PER CICLO5: DEC CX ;0FH VOLTE (AX) CMP CX,00 JNE CICLO5 DEC AX CMP AX,00 JNE CICLO5 CALL CARICAREG ;RIPRISTINA I VECCHI REGISTRI ;FINE FUNZIONE ENDP PAUSA ;PROCEDUTA CHE SCRIVE UN MESSAGGIO UTILIZZANDO LA FUNZIONE 9H ;DELL'INTERRUPT 21H DEL DOS PROC SCRIVIMESS CALL SALVAREG ;SALVA I REGISTRI MOV AH,09 ;SETTA LA FUNZIONE 9 ;CHIAMA L'INTERRUPT 21H CALL CARICAREG ;RIPRISTINA I VECCHI REGISTRI ;FINE FUNZIONE ENDP SCRIVIMESS ;PROCEDURA CHE SCRIVE UN CARATTERE SUL VIDEO UTILIZZANDO LA ;FUNZIONE 2 DELL'INTERRUPT 21H DEL DOS PROC SCRIVICAR CALL SALVAREG ;SALVA I REGISTRI MOV AH,02 ;SETTA LA FUNZIONE 2 ;CHIAMA L'INTERRUPT 21H CALL CARICAREG ;RIPRISTINA I VECCHI REGISTRI ;FINE FUNZIONE ENDP SCRIVICAR ;FUNZIONE CHE POSIZIONA IL CURSORE ALLA POSIZIONE XPOS E YPOS SULLA ;PAGINA ;VIDEO SPECIFICATA UTILIZZANDO LA FUNZIONE 2 DELL'INT 10H DEL BIOS PROC POSCURS CALL SALVAREG ;SALVA I REGISTRI MOV BH,PAGINA ;SETTA LA PAGINA VIDEO MOV AH,02 ;SETTA LA FUNZIONE 2 MOV DH,YPOS ;SETTA IL NUMERO DELLA RIGA MOV DL,XPOS ;SETTA IL NUMERO DELLA COLONNA INT 10H ;CHIAMA L'INTERRUPT 10H CALL CARICAREG ;RIPRISTINA I VECCHI REGISTRI ;FINE FUNZIONE ENDP POSCURS ;FUNZIONE CHE CANCELLA IL MESSAGGIO SCRITTO DURANTE IL VERIFICARSI DI ;UN CONTROL-C PROC DBREAK CALL SALVAREG ;SALVA I REGISTRI CALL LPOSCURS ;LEGGE LA POSIZIONE DEL CURSORE MOV AL,XPOS ;LA APPOGGIA IN YPOS2 E XPOS2 MOV AH,YPOS MOV YPOS2,AH MOV XPOS2,AL TASM um 89 di 175

91 MOV YPOS,22 ;POSIZIONA IL CURSORE SOTTO LA MOV XPOS,13 ;LINEA DEL MESSAGGIO DI CONTROL-C CALL POSCURS MOV CL,01 ;CANCELLA UNA RIGA CALL DELRIG MOV AH,YPOS2 ;POSIZIONA IL CURSORE ALLA POSIZIONE MOV AL,XPOS2 ;SALVATA IN YPOS2 E XPOS2 MOV XPOS,AL MOV YPOS,AH CALL POSCURS MOV FBREAK,00 ;SETTA IL FLAG DI CONTROL-C AVENUTO CALL CARICAREG ;RIPRISTINA I VECCHI REGISTRI ;FINE FUNZIONE ENDP DBREAK ;FUNZIONE CHE LEGGE LA POSIZIONE CORRENTE DEL CURSORE NELLA PAGINA ;VIDEO ;SPOCIFICATA IMPOSTANDO XPOS E YPOS UTILIZZANDO LA FUNZIONE 3 ;DELL'INTERRUPT 10H DEL BIOS PROC LPOSCURS CALL SALVAREG ;SALVA I REGISTRI MOV BH,PAGINA ;SETTA LA PAGINA VIDEO MOV AH,03 ;SETTA LA FUNZIONE INT 10H ;CHIAMA L'INTERRUPT 10H MOV XPOS,DL ;LEGGE IL NUMERO DI COLONNE MOV YPOS,DH ;LEGGE IL NUMERO DI RIGHE CALL CARICAREG ;RIPRISTINA I VECCHI REGISTRI ;FINE FUNZIONE ENDP LPOSCURS ;PROCEDURA CHE LEGGE DA TASTIERA UNA STRINGA DI 8 CARATTERI (BUFF) ;UTILIZZANDO LE FUNZIONE CH (AZZERA IL BUFF DELLA TASTIERA) E 8 (LEGGE ;UN CARATTERE DA TASTIERA) DELL'INTERRUPT 21H DEL DOS PROC INPUTPWD START: CALL SALVAREG ;SALVA I REGISTRI MOV CL,00 ;CONTATORE DI CARATTERI LETTI MOV CH,00 CALL LPOSCURS ;LEGGE LA POSIZIONE DEL CURSORE MOV AL,XPOS MOV AH,YPOS MOV IXPOS,AL ;APOGGIA IN IXPOS E IXPOS LA MOV IYPOS,AH ;POSIZIONE DEL PRIMO CARATTERE DELA ;PASSWORD DA LEGGERE INPUT: CALL LPOSCURS ;LEGGE LA POSIZIONE DEL CURSORE MOV AH,0CH ;SETTA LA FUNZIONE CH MOV AL,08 ;SETTA LA FUNZIONE 8 ;CHIAMA L'INTERRUPT 21H MOV SI,00 ;CONTROLLA CHE LI CARATTERE LETTO ;SIA DIVERSO DAI CARATTERI DELLA SALTA1: ;STRINGA SKIP ($ Š FINE STRINGA) CMP (SI+SKIP),24H ;SE SI Š ARRIVATRI ALLA FINE DELLA JE SALTA2 ;STRINGA SKIP IL CARATTERE Š ;ACCETABILE SALTA A SALTA2 CMP (SI+SKIP),AL ;SE SI TROVA IN SKIP UN CARATTERE JE INPUT ;UGUALE A QUELLO LETTO LEGGE UN TASM um 90 di 175

92 INC SI ;NUOVO CARATTERE SALTA A INPUT JMP SALTA1 ;ALTRIMENTI SI INCREMENTA SI ;(CONTATORE CARATTERI CONFRONTATI) ;E SI RIESEGUONO I CONTOLLI SALTA A ;SALTA1 SALTA2: MOV DI,CX ;COPIA IL CARATTERE NELLA STRINGA MOV (DI+BUFF),AL ;BUFF ALLA POSIZIONE CL INC CL ;INCREMENTA I CARATTERI LETTI CMP MODO,00 ;CONTROLLA MODO DI VISUALIZZAZIONE JNE SALTA3 ;SE MODO 1 SALTA ASALTA3 MOV (DL),NASCONDI ;SE MODO CONTIENE 0 NASCONE I CALL SCRIVICAR ;CARATTERI LETTI JMP SALTA6 ;SALTA A SALTA6 SALTA3: CMP AL,0DH ;CONTROLLA SE IL CARATTERE Š URN JNE SALTA4 ;SE NO (SALTA4) MOV AL,IXPOS ;SE SI POSIZIONA IL CURSORE ALL' MOV AH,IYPOS ;INIZIO DELLA PASSWORD RIPRISTINANDO MOV XPOS,AL ;I VALORI DI IXPOS E IYPOS MOV YPOS,AH CALL POSCURS JMP SALTA6 ;SALTA A SALTA6 SALTA4: CMP AL,08 ;CONTROLLA IL CARATTERE Š BACKSPACE JNE SALTA5 ;SE NO SALTA A SALTA5 MOV AH,XPOS ;SE SI ROCEDE FINO A IXPOS NON CMP AH,IXPOS ;VISUALIZZA IL BACKSPACE JLE SALTA6 ;SE NO SALTA A SALTA6 SALTA5: MOV DL,AL ;SE MODO CONTIENE 1 MOSTRA I CALL SCRIVICAR ;CARATTERI LETTI SALTA6: CMP CL,08 ;CONTROLLA SE SI SONO LETTI 8 CAR. JNE SALTA7 ;SE NO SALTA A SALTA7 MOV DX,OFFSET URN ;SE SI VA A CAPO CALL SCRIVIMESS CALL DBREAK ;CANCELLA IL MESSAGGIO DI CONTROL-C CALL CARICAREG ;RIPRISTINA I VECCHI REGISTRI ;FINE FUNZIONE SALTA7: JMP INPUT ;SALTA A INPUT ENDP INPUTPWD ;FUNZIONE CHE SALVA IL VALORE DEI REGISTRI PRINCIPALI NELLO STACK PER ;RENDERE ;I REGISTRI LOCALI ALLA FUNZIONE CHE LI UTILIZZA E NON FAR INTERFERIRE ;UNA FUNZINE CON L'ALTRA PROC SALVAREG MOV APPH,AH ;APPOGGIA IL VALORE DI AH E AL IN MOV APPL,AL ;APPH E APPL VISTO CHE AX VIENE POP AX ;UTILIZZATO PER SALVARE L'INDRIZZO XCHG AL,APPL ;DI RITORNO DI QUESTA FUNZIONE E XCHG AH,APPH ;METTERLO POI IN CIMA ALLA STACK PUSH AX ;METTE NELLA STACK AX PUSH BX ;METTE NELLA STACK BX PUSH CX ;METTE NELLA STACK CX PUSH DX ;METTE NELLA STACK DX PUSH SI ;METTE NELLA STACK SI PUSH DI ;METTE NELLA STACK DI TASM um 91 di 175

93 XCHG AL,APPL ;RIMETTE IL VALORE DI RITORNO DI XCHG AH,APPH ;QUESTA FUNZIONE IN CILA ALLA STACK PUSH AX XCHG AL,APPL XCHG AH,APPH ;FINE FUNZIONE ENDP SALVAREG ;FUNZIONE CHE RIPRISTINA I VALORI DEI REGISTRI PRINCIPALI DALLA STACK PROC CARICAREG MOV APPL,AL ;APPOGGIA IL VALORE DI AH E AL IN MOV APPH,AH ;APPH E APPL VISTO CHE AX VIENE POP AX ;UTILIZZATO PER SALVARE L'INDRIZZO XCHG APPL,AL ;DI RITORNO DI QUESTA FUNZIONE E XCHG APPH,AH ;METTERLO POI IN CIMA ALLA STACK POP DI ;PRELEVA DALLA STACK DI POP SI ;PRELEVA DALLA STACK SI POP DX ;PRELEVA DALLA STACK DX POP CX ;PRELEVA DALLA STACK CX POP BX ;PRELEVA DALLA STACK BX POP AX ;PRELEVA DALLA STACK AX XCHG APPL,AL ;RIMETTE IL VALORE DI RITORNO DI XCHG APPH,AH ;QUESTA FUNZIONE IN CILA ALLA STACK PUSH AX XCHG APPL,AL XCHG APPH,AH ;FINE FUNZIONE ENDP CARICAREG END BEGIN TASM um 92 di 175

94 ;Nome del programma: random.asm ;Programmatore: ;Descrizione ;Programma che indovina un numero casuale..286 DOSSEG.MODEL SMALL.STACK 200H.DATA ; DICHIARAZIONI COSTANTI PER I COLORI BLUE DB 1 GREEN DB 2 RED DB 4 ; DICHIARAZIONE STRINGHE DA USARE CON L' INTERRUPT BIOS CORN DB 'É',78 DUP ('Í'),'»º',78 DUP (32),'ºÈ',8 DUP ('Í'),'Ë',69 DUP ('Í'),'¼' INTESTAZIONE DB 'INDOVINA IL NUMERO ' DIVISIONE DB 21 DUP (' º',13,10) LINEA_FINE DB 9 DUP('Í'),'Ê',69 DUP ('Í') CARATTERE DB 'º' SCRITTA_FINE DB 'PREMERE UN TASTO PER TORNARE AL DOS' ; DICHIARAZIONE STRINGHE DA USARE CON L' INTERRUPT DOS MINORE DB 'HO PENSATO UN NUMERO MINORE DI QUESTO.',13,10,'$' MAGGIORE DB 'HO PENSATO UN NUMERO MAGGIORE DI QUESTO.',13,10,'$' GIUSTO DB 'HAI INDOVINATO IL NUMERO CHE HO PENSATO IN TENTATIVI.',13,10,'$' ; DICHIARAZIONI VARIABILI NUMERO DW 0 NUMERO_RANDOM DW 0 NUMERO_LETTO DW 0 CONT DW 0 LOC DW 0 INDOVINATO DW 0.CODE ;* LA PROCEDURA ESEGUE LA CANCELLAZIONE DELLO SCHERMO FACENDOLO SCROLLARE VERSO L' ALTO DI 24 LINEE. ;* INPUT: NESSUNO * ;* OUTPUT: NESSUNO * ;* REGISTRI DISTRUTTI: NESSUNO * CLS PROC NEAR PUSHA XOR AL,AL XOR CX,CX MOV DH,24 MOV DL, 79 MOV BH, 7 MOV AH, 6 INT 10H ; CANCELLA LO SCHERMO MOV AH, 2 XOR DX,DX XOR BX,BX INT 10H ; SI POSIZIONA PER L' INPUT DEL NUMERO DA INDOVINARE POPA CLS ENDP TASM um 93 di 175

95 ;* LA PROCEDURA STAMPA L' INTESTAZIONE DEL PROGRAMMA E POSIZIONA IL ;CURSORE ALLA LINEA 4 E ALLA COLONNA 2 DEL VIDEO TRAMITE LA PROC. ;LOCATE ;* INPUT: NESSUNO * ;* OUTPUT: NESSUNO * ;* REGISTRI DISTRUTTI: NESSUNO * INTEST PROC NEAR PUSHA MOV AX,1301H MOV BP,OFFSET CORN ; STAMPA LA CORNICE MOV BL,BLUE MOV CX,240 XOR DX,DX INT 10H MOV BP,OFFSET INTESTAZIONE ; STAMPA L' INTESTAZIONE. MOV AX,1301H MOV BL,GREEN MOV CX,76 MOV DX,0102H INT 10H MOV BP,OFFSET DIVISIONE ; STAMPA LA LINEA DI DIVISIONE. MOV AX,1301H MOV BL,BLUE MOV CX,252 MOV DX,0300H INT 10H MOV BP,OFFSET LINEA_FINE ; STAMPA LA LINEA IN FONDO ALLO MOV AX,1301H ; SCHERMO. MOV CX,79 MOV BL,BLUE MOV DH,24 XOR DL,DL INT 10H MOV DX,0300H ; SI POSIZIONA PER L' INPUT DEL CALL LOCATE ; NUMERO. POPA INTEST ENDP ;* LA PROCEDURA POSIZIONA IL CURSORE IN UNA QUALSIASI PARTE DELLO ;SCHERMO, INDICATA NEL REGISTRO DX ;* INPUT: RIGHA (DL) E COLONNA (DH) DOVE POSIZIONARE IL CURSORE * ;* OUTPUT: NESSUNO * ;* REGISTRI DISTRUTTI: NESSUNO * LOCATE PROC NEAR PUSHA MOV AH,2H MOV BX,0 INT 10H ; SI POSIZIONA SU VIDEO ALLA LOCAZIONE PUNTATA DA DX POPA LOCATE ENDP ;* LA PROCEDURA GENERA UN NUMERO CASUALE LUNGO 1 BYTE E LO ;MEMORIZZA NELLA VARIABILE NUMERO_RANDOM. ;* INPUT: NESSUNO * TASM um 94 di 175

96 ;* OUTPUT: IL NUMERO CASUALE IN NUMERO_RANDOM * ;* REGISTRI DISTRUTTI: NESSUNO * ;* PROCEDURE RICHIAMATE: DECIMAL (CONVERSIONE HEX TO DEC) * RANDOM PROC NEAR PUSHA MOV AH,2CH PUSH DX MOV AH,2CH PUSH DX MOV AH,2CH POP AX POP BX MOV AH, 0 MOV BH, 0 MOV DH, 0 ADD AX,BX ADD AX,DX ; HO LA SOMMA ESADECIMALE DEL NUMERO MOV BX, 255 ; CASUALE IN AX MUL BX MOV BX, 297 DIV BX ; RANGE PORTATO FRA CALL DECIMAL MOV AX,NUMERO MOV NUMERO_RANDOM,AX ; IL NUMERO CASUALE Š IN POPA ; NUMERO_RANDOM RANDOM ENDP ;* LA PROCEDURA CONVERTE IL NUMERO ESADECIMALE CONTENUTO IN AX E LO ;RIPORTA IN DECIMALE NELLA VARIABILE NUMERO. ;* INPUT: IL NUMERO DA CONVERTIRE (AX) * ;* OUTPUT: IL NUMERO IN DECIMALE (NUMERO) * ;* REGISTRI DISTRUTTI: NESSUNO * ;* PROCEDURE RICHIAMATE: MEMO * DECIMAL PROC NEAR PUSHA MOV NUMERO,0 MOV SI, 10 XOR CX,CX NON_ZERO: XOR DX,DX DIV SI PUSH DX INC CX OR AX,AX JNE NON_ZERO MEM_DIGIT: POP DX CALL MEMO LOOP MEM_DIGIT POPA TASM um 95 di 175

97 DECIMAL ENDP ;* LA PROCEDURA E' PARTE INTEGRANTE DELLA PROCEDURA DECIMAL. ;* INPUT: // * ;* OUTPUT: // * ;* REGISTRI DISTRUTTI: NESSUNO * MEMO PROC NEAR PUSHA MOV AX,NUMERO SHL AX, 4 OR AX,DX MOV NUMERO, AX POPA MEMO ENDP ;* LA PROCEDURA CONFRONTA I DUE NUMERI NUMERO_RANDOM E ;NUMERO_LETTO. ;* SE SONO UGUALI PONE INDOVINATO A 1 ALTRIMENTI STAMPA L' ADEGUATO ;MESSAGGIO. ;* INPUT: NUMERO_RANDOM, NUMERO_LETTO * ;* OUTPUT: MESSAGGI VARI * ;* REGISTRI DISTRUTTI: NESSUNO * ;* PROCEDURE RICHIAMATE: VINTO, SCROLL, LOCATE. * CONFRONTA PROC NEAR PUSHA MOV AX,NUMERO_RANDOM MOV BX,NUMERO_LETTO CMP AX,BX JL CONFRONTA_MINORE CMP AX,BX JA CONFRONTA_MAGGIORE CALL VINTO MOV DX,OFFSET GIUSTO MOV INDOVINATO, 1 JMP CONFRONTA_FINE CONFRONTA_MINORE: MOV DX,OFFSET MINORE JMP CONFRONTA_FINE CONFRONTA_MAGGIORE: MOV DX,OFFSET MAGGIORE CONFRONTA_FINE: PUSH DX PUSH AX XOR AX,AX MOV AL,2H CMP LOC,21 JL NO_SCROLL CALL SCROLL NO_SCROLL: ADD AX,LOC MOV DH,AL MOV DL,10H CALL LOCATE POP AX POP DX TASM um 96 di 175

98 MOV AH,9H POPA CONFRONTA ENDP ;* LA PROCEDURA ESEGUE LO SCROLL DELLA FINESTRA DI LAVORO DEL ;PROGRAMMA, COMPRESA FRA I DUE ANGOLI (4,0) E (23,79), DI 1 LINEA ;* QUANDO L' OUTPUT DELLE FRASI RAGGIUNGE LA 23Ø LINEA. QUANDO VIENE ;FATTO LO SCROLL, IL PROGRAMMA AGGIUNGE SU QUELLA ;* LINEA IL CARATTERE DELLA DIVISIONE. ;* INPUT: NESSUNO * ;* OUTPUT: NESSUNO * ;* REGISTRI DISTRUTTI: NESSUNO * SCROLL PROC NEAR PUSHA MOV AX,LOC DEC AX MOV LOC,AX MOV AH,6H MOV AL,1H MOV BH,0 MOV CX,400H MOV DH,23 MOV DL,79 INT 10H MOV BP,OFFSET CARATTERE MOV AX,1301H MOV BL,BLUE MOV CX,1 MOV DH,23 MOV DL,09 INT 10H POPA SCROLL ENDP ;* LA PROCEDURA MODIFICA LA LOCAZIONE DI MEMORIA DOVE E' CONTENUTA LA ;FRASE CHE INDICA LA VINCITA INSERENDO AL POSTO DEGLI SPAZI IL ;* NUMERO DI TENTATIVI FATTI PER OTTENERE LA VINCITA. ;* INPUT: IL NUMERO DI TENTATIVI FATTI (CONT) * ;* OUTPUT: NESSUNO * ;* REGISTRI DISTRUTTI: NESSUNO * ;* PROCEDURE RICHIAMATE: DECIMAL * VINTO PROC NEAR PUSHA MOV DI,OFFSET GIUSTO ADD DI,43 MOV CALL MOV SHR ADD CMP JNZ AX,CONT DECIMAL AX,NUMERO AX,12 AX,48 AX,48 NON_SOSTITUISCI1 TASM um 97 di 175

99 MOV AX,32 NON_SOSTITUISCI1: STOSB MOV AX,CONT CALL DECIMAL MOV AX,NUMERO SHR AX,8 ADD AX,48 CMP AX,48 JNZ NON_SOSTITUISCI2 MOV AX,32 NON_SOSTITUISCI2: STOSB MOV AX,CONT CALL DECIMAL MOV AX,NUMERO SHR AX,4 ADD AX,48 CMP AX,48 JNZ NON_SOSTITUISCI3 MOV AX,8 NON_SOSTITUISCI3: STOSB MOV AX,CONT CALL DECIMAL MOV AX,NUMERO SHL AX,12 SHR AX,12 ADD AX,48 STOSB POPA VINTO ENDP ;* LA PROCEDURA LEGGE UN NUMERO DI UN BYTE DA TASTIERA E LO ;MEMORIZZA NELLA VARIABILE NUMERO_LETTO. ;* INPUT: 3 CIFRE DA TASTIERA. * ;* OUTPUT: NUMERO_LETTO * ;* REGISTRI DISTRUTTI: NESSUNO * LEGGI PROC NEAR PUSH AX MOV AX,CONT INC AX MOV CONT,AX MOV AX,LOC CMP AX,21 JE NON_INCREMENTA INC AX NON_INCREMENTA: MOV LOC,AX POP AX XOR DX, DX INSER1: MOV AH,1 TASM um 98 di 175

100 SUB AL,30H CMP AL,9 JA INSER1 CMP AL,0 JL INSER1 INSER2: MOV DL,AL SHL DX,4 MOV AH,1 CMP AL,13 JE LEGGI_FINE SUB AL,30H CMP AL,9 JA INSER2 CMP AL,0 JL INSER2 INSER3: OR DL,AL MOV AH,1 CMP AL,13 JE LEGGI_FINE SUB AL,30H CMP AL,9 JA INSER3 CMP AL,0 JL INSER3 MOV AH,0 SHL DX,4 OR DX,AX LEGGI_FINE: MOV NUMERO_LETTO,DX LEGGI ENDP ;* LA PROCEDURA SCRIVE IL MESSAGGIO DI FINE PROGRAMMA A VIDEO ED ;ATTENDE UN CARATTERE DALLA TASTIERA PER TERMINARE IL PROGRAMMA. ;* INPUT: CARATTERE DA TASTIERA * ;* OUTPUT: LA SCRITTA SCRITTA_FINE * ;* REGISTRI DISTRUTTI: NESSUNO * FINEPROG PROC NEAR PUSHA MOV AX,1301H XOR BH,BH MOV BL,RED MOV CX,35 MOV DH,23 MOV DL,24 MOV BP,OFFSET SCRITTA_FINE INT 10H XOR AH,AH INT 16H POPA TASM um 99 di 175

101 FINEPROG ENDP BEGIN: MOV MOV DS,AX ; CARICA I REGISTRI DS ED ES. MOV ES,AX MOV NUMERO_LETTO, 0 MOV NUMERO_RANDOM, 0 CALL CLS ; CANCELLA LO SCHERMO CALL INTEST ; STAMPA A VIDEO L' INTESTAZIONE DEL PROG. CALL RANDOM ; GENERA UN NUMERO CASUALE (IN NUMERO_RANDOM) RIPETI: CALL LEGGI ; LEGGE UN NUMERO DA TASTIERA (NUMERO_LETTO) CALL CONFRONTA ; CONFRONTA I DUE NUMERI MOV AX, INDOVINATO ; INDOVINATO Š UN BOOLEAN CHE VALE 1 SE GIUSTO CMP AX, 0 JZ RIPETI FINE: CALL FINEPROG ; ATTENDE UN CARATTERE DA TASTIERA CALL CLS ; CANCELLA LO SCHERMO MOV AH,4CH END BEGIN TASM um 100 di 175

102 ;Nome del programma: quadrati.asm ;Programmatore: ;Descrizione ;Programma che calcola i quadrati di 10 numeri a 16 bit, stampa su video il valore dei ;numeri e dei quadrati in codice esadecimale. DOSSEG.MODEL SMALL.STACK.DATA DATI DW 32767,315,22222,12755,4096,256,97,19999,29999,313 MESS DB 13,10,13,10,"IL NUMERO VALE N = " N DB " H E IL QUADRATO VALE Q = " QUAD DB " H$" DIVIS DW 1000H,100H,10H,1.CODE BEGIN: MOV CX,10 MOV DI,OFFSET DATI INIZ: MOV SI,OFFSET N MOV AX,[DI] CALL ESA ;ESEGUO IL QUADRATO MOV AX,[DI] MUL AX ;SALVO IN BX LA PARTE BASSA MOV BX,AX ;TRASFORMO IN ASCII LA PARTE ALTA MOV AX,DX MOV SI,OFFSET QUAD CALL ESA ;TRASFORMO IN ASCII LA PARTE BASSA MOV AX,BX MOV SI,OFFSET QUAD+4 CALL ESA ;STAMPA IL NUMERO ED IL SUO QUADRATO MOV AH,9 MOV DX,OFFSET MESS INC DI INC DI LOOP INIZ ;CHIAMA LA FUNZIONE DI USCITA AL DOS.EXIT ;Routine che calcola le 4 cifre esadecimali corrispondenti al dato memorizzato ;in ax e le ;memorizza in codice ascii nella stringa puntata da [si] ;Input: ;Output: ;Registri distrutti: ESA PROC NEAR PUSH BX PUSH DX PUSH CX MOV CX,4 MOV BX,OFFSET DIVIS DIV0: MOV DX,0 DIV WORD PTR [BX] ADD AL,30H CMP AL,39H TASM um 101 di 175

103 JBE POI ADD AL,7 POI: MOV [SI],AL INC SI INC BX INC BX MOV AX,DX LOOP DIV0 POP CX POP DX POP BX ESA ENDP END BEGIN C:\Compiler\BORLANDC\Output>quadrati Il numero vale N = 7FFFH e il quadrato vale Q = 3FFF0001H Il numero vale N = 013BH e il quadrato vale Q = H Il numero vale N = 56CEH e il quadrato vale Q = 1D6F0DC4H Il numero vale N = 31D3H e il quadrato vale Q = 09B273E9H Il numero vale N = 1000H e il quadrato vale Q = H Il numero vale N = 0100H e il quadrato vale Q = H Il numero vale N = 0061H e il quadrato vale Q = C1H Il numero vale N = 4E1FH e il quadrato vale Q = 17D6E7C1H Il numero vale N = 752FH e il quadrato vale Q = 35A3FEA1H Il numero vale N = 0139H e il quadrato vale Q = 00017EB1H C:\Compiler\BORLANDC\Output> TASM um 102 di 175

104 ;routine che genera un numero esadecimale casuale ;DL = numero casuale GENERA PROC NEAR PUSH DS PUSH AX MOV AX,0 MOV DS,AX MOV DL,DS:046CH POP AX POP DS GENERA ENDP ;routine che posiziona il cursore ;INPUT: nessuno ;OUTPUT: nessuno GOTOXY PROC NEAR PUSH AX PUSH BX PUSH DX MOV BH,0 MOV DH,RIGA MOV DL,COLONNA MOV AH,02H INT 10H POP DX POP BX POP AX GOTOXY ENDP ;NUMERO DELLA PAGINA VIDEO ;POSIZIONAMENTO CURSORE ;routine che pulisce lo schermo ;INPUT: nessuno ;OUTPUT: nessuno CLS PROC PUSH AX PUSH BX PUSH CX PUSH DX XOR AL, AL ;CANCELLA INTERA FINESTRA XOR CX, CX ;ANGOLO SUPERIORE SINISTRO: (0,0) MOV DX, 184FH ;ANGOLO INFERIORE DESTRO: (24, 79) MOV BH, 7 ;ATTRIBUTO NORMALE PER SPAZI MOV AH, 6 ;FUNZIONE SCROLL-UP INT 10H ;CANCELLA LA FINESTRA POP DX POP CX POP BX POP AX CLS ENDP ;routine che pulisce lo schermo ;1 metodo: modificare il contenuto del buffer video, dipende dalla scheda grafica TASM um 103 di 175

105 ;2 metodo: sfruttare la funzione 06H del BIOS CLRSCR PROC NEAR PUSH AX PUSH DX MOV CH,0 ;CX CONTINE RIGA E COLONNA ANGOLO IN ALTO A SINISTRA MOV CL,0 MOV DH,42 ;DX CONTINE RIGA E COLONNA ANGOLO IN BASSO A DESTRA MOV DL,79 MOV BH,07 ;ATTRIBUTI DEL CARATTERE MOV AL,0 ;NUMERO DI LINEE DA SCORRERE (0 TUTTO LO SCHERMO) MOV AH,06H ;FUNZIONE DI SCROLL INT 10H POP DX POP AX CLRSCR ENDP ;routine che sposta il cursore nella posizione indicata in INPUT ;INPUT: poscurx e poscury ;OUTPUT: nessuno GOTOXY PROC PUSH AX PUSH BX PUSH DX MOV AH, 2 ;FUNZIONE IMPOSTA POSIZIONE CURSORE XOR BH, BH ;PAGINA 0 MOV DL, POSCURX ;RIGA MOV DH, POSCURY ;COLONNA INT 10H ;VAI POP DX POP BX POP AX GOTOXY ENDP ;routine che stampa un carattere ;INPUT: AL=codice carattere, BL=attributo ;OUTPUT: nessuno PRINTCHAR PROC PUSH AX PUSH BX PUSH CX MOV AH, 09H ;FUNZIONE 09H - SCRIVE UN CARATTERE MOV CX, 1 ;SCRIVI UN SOLO CARATTERE XOR BH, BH ;SCRIVI SULLA PRIMA PAGINA INT 10H ;SCRIVE CARATTERE POP CX POP BX POP AX PRINTCHAR ENDP ;routine che avanza il cursore di una posizione a destra ;INPUT: poscurx e poscury TASM um 104 di 175

106 ;OUTPUT: poscurx ;NOTE: non controlla che la riga sia finita CURSRIGHT PROC PUSH AX PUSH BX PUSH DX MOV AH, 02H ;FUNZIONE 02H - POSIZIONA IL CURSORE XOR BH,BH ;DELLA PAGINA 0 INC POSCURX MOV DL, POSCURX MOV DH, POSCURY INT 10H ;SU (DH,DL) POP DX POP BX POP AX CURSRIGHT ENDP ;routine che porta il cursore all'inizio della riga successiva ;INPUT: nessuno ;OUTPUT: poscurx=0 e poscury incrementato CR EQU 13 ;RITORNO A CAPO LF EQU 10 ;AVANZAMENTO RIGA ACCAPO PROC PUSH AX PUSH DX MOV AH,2 MOV DL, CR ;FUNZIONE DOS MOV DL, LF INC POSCURY ;AGGIORNA MOV POSCURX, XINIZ POP DX POP AX ACCAPO ENDP ;COORDINATE LOGICHE ; routine che converte il valore in AL in hex ASCII ;INPUT: dato in AL ;OUTPUT: codice ASCII della parte alta in AH, parte bassa in AL ;REGISTRI MODIFICATI: AX BIN_HEX PROC NEAR PUSH CX ;SALVA IL REGISTRO CHE VERRA' USATO MOV AH,AL ;SALVA IL DATO IN AL MOV CL,4 ;ISOLA IL NIBBLE MSB SHR AL,CL ;.186 SHR AL,4!!!!!! ADD AL,90H ;CONVERSIONE DAA ADC AL,40H DAA ;ASCII DEL NIBBLE E' IN AL XCHG AL,AH ;DATO IN AL, PRIMO BYTE CONVERTITO IN AH AND AL,0FH ;ISOLA IL NIBBLE LSB ADD AL,90H ;CONVERSIONE TASM um 105 di 175

107 DAA ADC AL,40H DAA ;ASCII DEL NIBBLE E' IN AL POP CX ENDP BIN_HEX ; routine che converte il valore in AL in decimale ASCII ;INPUT: dato in AL ;OUTPUT: codice ASCII centinaia in AL, decine in AH, unità in BL ;REGISTRI MODIFICATI: AX,BX BIN_DEC PROC NEAR MOV BH,10 ;DIVISORE BASE 10 MOV AH,0 ;AZZERO PARTE ALTA DIVIDENDO DIV BH ADD AH,'0' ;CONVERSIONE ASCII UNITA' MOV BL,AH MOV AH,0 DIV BH ADD AH,'0' ;CONVERSIONE ASCII DECINE ADD AL,'0' ;CONVERSIONE ASCII CENTINAIA ENDP BIN_DEC END BEGIN ; routine che converte il byte nel registro DL in esadecimale e scrive le due cifre ;esadecimali alla posizione corrente del cursore. DL byte da convertire in esadecimale. WRITE_HEX PROC NEAR ;PUNTO DI INTRODUZIONE PUSH CX ;SALVA REGISTRI USATI IN QUESTA PROCEDURA PUSH DX MOV DH,DL ;CREA COPIA DEL BYTE MOV CX,4 ;PRELEVA IL SEMIBYTE SUPERIORE IN DL SHR DL,CL CALL WRITE_HEX_DIGIT ;VISUALIZZA PRIMA CIFRA ESADECIMALE MOV DL,DH ;PRELEVA IL SEMIBYTE INFERIORE IN DL AND DL,0FH ;CANCELLA IL SEMIBYTE SUPERIORE CALL WRITE_HEX_DIGIT ;VISUALIZZA SECONDA CIFRA ESADECIMALE POP DX POP CX WRITE_HEX ENDP ;routine che converte i 4 bit inferiori di DL in cifra esadecimale; e la scrive sullo ;schermo. DL i 4 bit inferiori contengono numero da stampare in esadecimale WRITE_HEX_DIGIT PROC NEAR PUSH DX ;SALVA I REGISTRI UTILIZZATI CMP DL,10 ;QUESTO SEMIBYTE E' <10? JAE HEX_LETTER ;NO, CONVERTIRE IN LETTERA ADD DL,"0" ;SI, CONVERTIRE IN CIFRA JMP SHORT WRITE_DIGIT ;ORA SCRIVI QUESTO CARATTERE HEX_LETTER: ADD DL,"A"-10 ;CONVERTE IN LETTERA ESADECIMALE WRITE_DIGIT: CALL WRITE_CHAR ;VISUALIZZA LA LETTERA SULLO SCHERMO TASM um 106 di 175

108 POP DX ;RIPRISTINA VECCHIO VALORE DI AX WRITE_HEX_DIGIT ENDP ;routine che stampa un carattere sullo schermo usando la chiamata di funzione del ;DOS. DL byte da stampare sullo schermo. WRITE_CHAR PROC NEAR PUSH AX MOV AH,2 ;CHIAMATA PER OUTPUT CARATTERE ;OUTPUT CARATTERE NEL REGISTRO DL POP AX ;RIPRISTINA VECCHIO VALORE IN AX ;E RIENTRA WRITE_CHAR ENDP ; routine che introduce un ritardo per visualizzare per circa un secondo (su 386 a 33 ;MHz), l'intestazione del programma (SIV, Show Interrupt). Modificare il valore da caricare ;in DX per modificare il ritardo. DELAY PROC NEAR MOV DX,55 ;RITARDO = 1" PER 386 A 33 MHZ CICLO2: MOV CX,0FFFFH ;CICLO ESTERNO CICLO1: LOOP CICLO1 ;CICLO INTERNO DEC DX DELAY ENDP JNZ CICLO2 ;ESEGUI CICLO ESTERNO 55 VOLTE ;routine che stampa un messaggio su video ;Input: DS:DX = indirizzo della stringa ;Output: la stringa è stampata su video a partire dalla posizione corrente del cursore ;Registri distrutti : nessuno DISPLAY PROC NEAR PUSH AX ;SALVA IL REGISTRO DI LAVORO MOV AH,9 ;FUNZIONE STAMPA STRINGA DEL DOS ;CHIAMA LE FUNZIONI DEL DOS POP AX ;RIPRISTINA AX ;RITORNA AL CHIAMANTE DISPLAY ENDP ; routine che converte il digit esadecimale contenuto nel registro AL nel corrispondente ;carattere ASCII. ;Input: AL = digit esadecimale da convertire in ascii ;Output: AL = carattere ascii del digit esadecimale ESA1ASC PROC NEAR PUSH BX ;SALVA BX AND AL,0FH ;AZZERA NIBBLE SUPERIORE LEA BX,ASCII_ESA XLAT ;CONVERTI IL DIGIT IN ASCII POP BX ;RIPRISTINA BX ;RITORNA AL CHIAMANTE ASCII_ESA DB " ABCDEF" ESA1ASC ENDP TASM um 107 di 175

109 ;routine che converte un numero binario a 8 bit in esadecimale ASCII (2 byte) e lo ;memorizza in memoria all'indirizzo specificato dal chiamante. ;Input: AL = numero a 8 bit da convertire ; DI = indirizzo per la memorizzazione ;Output: DI = inalterato, punta ai due byte ASCII risultato conversione ; DL = inalterato ;Registri distrutti: nessuno EXTRN ESA1ASC:NEAR ESA2ASCM PROC NEAR MOV VAR_AL,AL ;SALVA IL NUMERO ORIGINALE ROL AL,1 ;INIZIA DAL PI SIGNIFICATIVO ROL AL,1 ROL AL,1 ROL AL,1 CALL ESA1ASC ;CONVERTI E MOV [DI],AL ;MEMORIZZA IL DIGIT MOV AL,VAR_AL ;RIPRISTINA IL NUMERO ORIGINALE CALL ESA1ASC ;CONVERTI IL MENO SIGNIFICATIVO E MOV [DI+1],AL ;MEMORIZZALO MOV AL,VAR_AL ;RIPRISTINA IL NUMERO ORIGINALE ;RITORNA AL CHIAMANTE VAR_AL DB? ESA2ASCM ENDP ;routine che converte un numero binario a 16 bit in esadecimale ASCII (4 byte) e ;memorizza la stringa ASCII all'indirizzo specificato dal chiamante ;Input: DX = numero binario a 16 bit da convertire ; DI = indirizzo per la memorizzazione ;Output: DI = inalterato, indirizzo stringa ASCII risultato conversione ; DX = inalterato ; Registri distrutti: nessuno EXTRN ESA1ASC:NEAR ESA4ASCM PROC NEAR PUSH DI ;SALVA I REGISTRI DI LAVORO PUSH CX PUSH AX MOV CL,4 ;QUATTRO CIFRE ESA DA CONVERTIRE NXT_DGT: ROL DX,1 ;FORMA IL DIGIT ESA DA CONVERTIRE ROL DX,1 ;REGISTRO DL FACENDO RUOTARE DX DI ROL DX,1 ;QUATTRO BIT A SINISTRA MOV AL,DL ;SPOSTA IL DIGIT IN AL E CALL ESA1ASC ;CONVERTI E MOV [DI],AL ;MEMORIZZA IL DIGIT INC DI ;AGGIORNA I PUNTATORE LOOP NXT_DGT ;CONVERTI TUTTE LE CIFRE POP AX ;RIPRISTINA I REGISTRI DI LAVORO POP CX POP DI ;RITORNA AL CHIAMANTE ESA4ASCM ENDP ;routine che converte un carattere ASCII esadecimale nel corrispondente numero binario ;Input: AL = carattere ASCII (0..F) ;Output:se CF = 0 allora AL = numero binario (0..15) TASM um 108 di 175

110 ; se CF = 1 allora ASCII non valido in input ; AL inalterato $E1BIN PROC NEAR CMP AL,"9" ;TEST PER CARATTERI ESADECIMALI JBE STRIP CMP AL,"A" JB INVALIDO CMP AL,"F" JBE ADD_9 CMP AL,"A" JB INVALIDO CMP AL,"F" JA INVALIDO ADD_9: ADD AL,9 ;AGGIUNGI 9 AI CARATTERI TRA A E F STRIP: AND AL,0FH ;AZZERA IL NIBBLE SUPERIORE JMP EXIT ;ESCI INVALIDO: STC ;CARATTERE ASCII INVALIDO SETTA CF EXIT: $E1BIN ENDP ;routine che converte un numero BCD a 2 digit in un numero binario ;Input: AL = numero BCD ;Output:AL = numero binario BCD8BIN PROC NEAR MOV SAVEAH,AH ;SALVA I REGISTRI DI LAVORO MOV SAVECX,CX MOV CH,AL ;MEMORIZZA IL DIGIT BASSOIN CH AND CH,0FH ;MASCHERANDO IL DIGIT ALTO MOV CL,4 ;SPOSTA IL DIGIT ALTO IN QUELLOBASSO SHR AL,CL MOV CL,10 ;MOLTIPLICALO PER 10 MUL CL ADD AL,CH ;SOMMA I DIGIT MOV AH,SAVEAH ;RIPRISTINA I REGISTRI MOV CX,SAVECX SAVEAH DB? SAVECX DW? BCD8BIN ENDP ;routine che converte un numero BCD di 4 digit in un numero binario a 16 bit ;Input: AX = numero BCD a 16 bit ;Output:AX = valore binario a 16 bit BCD16BIN PROC NEAR PUSH CX ;SALVA I REGISTRI DI LAVORO PUSH DX PUSH DI PUSH SI MOV SI,AX ;SALVA IL NUMERO BCD IN SI SUB AX,AX ;AZZERA IL TOTALE CALL ADD_DIG ;CONVERTI DAL DIGIT PI CALL ADD_DIG ;ALTO A QUELLO CALL ADD_DIG ;PI BASSO TASM um 109 di 175

111 CALL ADD_DIG POP SI POP DI POP DX POP CX BCD16BIN ENDP ;routine che converte un digit BCD in binario (DI) e lo ;somma al totale in AX ADD_DIG PROC NEAR MOV DI,0 ;AZZERA DI MOV CX,4 ;SHIFTA IL PROSSIMO DIGIT IN DI... NXTDIG: SHL SI,1 ;... UN BIT ALLA VOLTA RCL DI,1 LOOP NXTDIG MOV CX,10 ;MOLTIPLICA IL TOTALE PER 10 E MUL CX ADD AX,DI ;SOMMAGLI IL NUOVO DIGIT ADD_DIG ENDP ;routine che converte una cifra esadecimale in un carattere ASCII ;Input: nibble basso di AL = numero binario (0..15) ;Output:AL = carattere ASCII (0..F) BIN1$E PROC NEAR PUSH BX ;SALVA REGISTRO DI LAVORO AND AL,0FH ;MASCHERA NIBBLE SUPERIORE DI AL LEA BX,ASCII ;ESTRAI IL CARATTERE ASCII DALLA TABELLA XLAT ASCII POP BX ASCII DB " ABCDEF" BIN1$E ENDP ;routine che converte un numero binario a 8 bit (max 99 decimale) in un numero BCD ;Input: AL = numero da convertire ;Output:se CF = 0, allora AL = numero BCD ; se CF = 1, insuccesso (numero binario > 99) ; AL inalterato BIN8BCD PROC NEAR CMP AL,99 ;NUMERO FUORI RANGE? JBE SAVEAH STC ;SI. SETTA CF JC EXIT ;ED ESCI SAVEAH: MOV AHLOC,AH ;SALVA I REGISTRI DI LAVORO MOV CLLOC,CL CBW ;ESTENDI AL ATTRAVERSO AH MOV CL,10 ;DIVIDI PER 10 DIV CL ;DIGIT ALTO IN AL, BASSO IN AH MOV CL,4 ;SHIFTA IL DIGIT ALTO A SINISTRA DI 4 SHL AL,CL OR AL,AH ;E COMBINALO CON IL DIGIT BASSO MOV AH,AHLOC ;RIPRISTINA I REGISTRI DI LAVORO MOV CL,CLLOC TASM um 110 di 175

112 EXIT: AHLOC DB? CLLOC DB? BIN8BCD ENDP ;routine che converte un numero binario di 16 bit in BCD impaccato ;Input: AX = numero binario ;Output:Se CF = 0, allora AX = numero BCD (Max 9999) ; Se CF = 1, errore numero in ingresso fuori dal range ; AX contiene il numero binario BIN16BCD PROC NEAR CMP AX,9999 ;NUMERO FUORI DAL RANGE JBE PUSHCX STC ;SI. SETTA CF ED ESCI JC EXIT PUSHCX: PUSH CX ;SALVA I REGISTRI DI LAVORO PUSH DX SUB DX,DX ;PREPARA DX PER LA DIVISIONE MOV CX,1000 ;CALCOLA LACIFRA DELLE MIGLIAIA DIV CX XCHG AX,DX ;METTI IL RESTO IN AX E LA CIFRA IN DX MOV CL,4 ;SHIFTA IL TOTALE PARZIALE DI 4 BIT A SINISTRA SHL DX,CL MOV CL,100 ;CALCOLA LA CIFRA DELLE CENTINAIA E... DIV CL ADD DL,AL ;... SOMMALA AL TOTALE PARZIALE MOV CL,4 ;SHIFTA IL TOTALE PARZIALE DI 4 BIT A SINISTRA SHL DX,CL XCHG AL,AH ;METTI IL RESTO IN AL E SUB AH,AH ;PULISCI AH MOV CL,10 ;CALCOLA LA CIFRA DELLE DECINE E... DIV CL ADD DL,AL ;... SOMMALA AL TOTALE PARZIALE MOV CL,4 ;SHIFTA IL TOTALE PARZIALE DI 4 BIT A SINISTRA SHL DX,CL ADD DL,AH ;SOMMAGLI LA CIFRA DELLE UNIT MOV AX,DX ;SPOSTA IL RISULTATO FINALE IN AX POP DX POP CX EXIT: BIN16BCD ENDP ;routine che somma due numeri BCD impaccati a 16 bit ;Input: BX = primo operando ; AX = secondo operando ;Output:se CF = 0 allora AX = risultato ; se CF = 1 il risultato eccede i 16 bit ; BX inalterato ADD16DI PROC NEAR PUSH CX ;SALVA IL REGISTRO DI LAVORO MOV CH,AH ;SALVA AH IN CH ADD AL,BL ;SOMMA I BYTE DI ORDINE BASSO E DAA ;IMPACCA IL RISULTATO XCHG AL,CH ;PREPARAZIONE PER LA SECNDA ADDIZIONE TASM um 111 di 175

113 ADC AL,BH ;SOMMA I BYTE DI ORDINE ALTO E DAA ;IMPACCA IL RISULTATO MOV AH,AL ;SISTEMA I BYTE NELL'ORDINE CORTO MOV AL,CH POP CX ;RIPRISTINA CX ADD16DI ENDP ;routine che somma a 16 bit di due numeri BCD non impaccati ;Input: AX = primo operando ; BX = secondo operando ;Output:AX = risultato ; Se la somma non sta in AX (overfolow), allora CF = 1 ; BX inalterato ADD16DNI PROC NEAR PUSH CX ;SALVA IL REGISTRO DI LAVORO MOV AH,CH ;SALVA AH IN CH ADD AL,BL ;SOMMA I BYTE DI ORDINE BASSO AAA ;E CORREGGI PER OTTENERE BCD NON IMPACCATO XCHG AL,CH ;PREPARAZIONE PER LA SECONDA ADDIZIONE ADC AL,BH ;SOMMA I BYTE DI ORDINE ALTO AAA ;E CORREGGI PER OTTENERE BCD NON IMPACCATO MOV AH,AL ;RIORDINA I BYTE MOV AL,CH POP CX ;RIPRISTINA CX ;RITORNO AL CHIAMANTE ADD16DNI ENDP ;routine che sottrae due numeri BCD impaccati a 16 bit ;Input: BX = sottraendo ; AX = minuendo ;Output:se CF = 0 allora AX = risultato ; se CF = 1 allora BX > AX e AX = risultato negativo SOT16DI PROC NEAR PUSH CX ;SALVA IL REGISTRO DI LAVORO MOV CH,AH ;SALVA AH IN CH SUB AL,BL ;SOTTRAI I BYTE DI ORDINE BASSO E DAS ;IMPACCA IL RISULTATO XCHG AL,CH ;PREPARATI PER LA SECONDA SOTTRAZIONE SBB AL,BH ;SOTTRAI I BYTE DI ORDINE ALTO E DAS ;IMPACCA IL RISULTATO MOV AH,AL ;SISTEMA I BYTE NEL CORTO ORDINE MOV AL,CH POP CX ;RIPRISTINA CX SOT16DI ENDP ;routine che sottrae a 16 bit di due numeri BCD non impaccati ;Input: BX = sottraendo ; AX = minuendo ;Output:AX = risultato ; Se il risultato Š negativo (BX > AX) allora CF = 1 ; BX inalterato SOT16DNI PROC NEAR TASM um 112 di 175

114 PUSH CX ;SALVA IL REGISTRO DI LAVORO MOV CH,AH ;SALVA AH IN CH SUB AL,BL ;SOTTRAI I BYTE DI ORDINE BASSO AAS ;E CORREGGI PER BCD NON IMPACCATO XCHG AL,CH ;PREPARAZIONE PER LA SECONDA SOTTRAZIONE SBB AL,BH ;SOTTRAI I BYTE DI ORDINE ALTO AAS ;E CORREGGI PER BCD NON IMPACCATO MOV AH,AL ;RIORDINA I BYTE MOV AL,CH POP CX ;RIPRISTINA CX SOT16DNI ENDP ;routine che esegue il prodotto di due numeri a 16 bit BCD non impaccato ;Genera risultato 32 bit ;Input: BX = moltiplicatore ; AX = moltiplicando ;Output:Prodotto in AX (parte alta) e AX (parte bassa) ; BX inalterato MOL16DNI PROC NEAR ;Converti il moltiplicando BCD in AX in un numero binario in AL PUSH BX ;SALVA I REGISTRI IN INPUT PUSH CX MOV CH,AL ;SALVA AL IN CH MOV AL,AH ;MOLTIPLICA AH PER 10 E... MOV CL,10 MUL CL ADD AL,CL ;... SOMMAGLI AL INIZIALE MOV CH,AL ;SALVA IL MOLTIPLICANDO IN CH ;Converti il moltiplicatore BCD in BX, in un numero binario in BL MOV AL,BH ;MOLTIPLICA BH PER 10 E... MUL CL ADD BL,AL ;... SOMMALO A BL ;Moltiplica gli operandi per ottenere un prodotto a 16 bit in AX ;quindi converti AX in un numero BCD non impaccato in DX:AX MOV AL,CH ;RECUPERA IL MOLTIPLICANDO MUL BL ;MOLTIPLICAIN BINARIO CWD ;ALLARGA DA 16 A 32 BIT IN DX:AX MOV CX,1000 ;CALCOLA LA CIFRA DELLE MIGLIAIA DIV CX XCHG AX,DX ;IL RESTO IN AX MOV DH,DL ;CIFRA DELLE MIGLIAIA IN DH MOV CL,100 ;CALCOLA LA CIFRA DELLE CENTINAIA E... DIV CL MOV DL,AL ;... METTILA IN DL MOV AL,AH ;SPOSTA IL RESTO IN AL E... CBW ;... ESTENDILO A 16 BIT MOV CL,10 ;CALCOLA LE CIFRE DI DECINE E UNIT DIV CL XCHG AH,AL ;ORDINA LE CIFRE POP CX ;RIPRISTINAI REGISTRI DI LAVORO POP BX MOL16DNI ENDP TASM um 113 di 175

115 ;routine che divide numeri BCD nn impaccati ;Input: DX:AX = dividendo a 32 bit ; BX = divisore a 16 bit ;Output:AX = quoziente ; DX = resto ; Se il quoziente o il resto sono pi grandi di 99 allora CF = 1 ; Se il divisore 0 o il dividendo 256 volte pi grande del divisore, ; la CPU attiva un divide-by-zero interrupt ; BX inalterato DIV16DNI PROC NEAR ;Converti il dividendo BCD in DX:AX in un numero binario in CX PUSH BX ;SALVA I REGISTRI IN INPUT PUSH CX AAD ;CONVERTI LA MET BASSA IN BINARIO IN AL E MOV CX,AX ;SALVALA IN CX MOV AX,DX ;SPOSTA LA MET ALTA IN AX AAD ;CONVERTILA IN BINARIO IN AL E MOV DL,100 ;MOLTIPLICALA PER 100 MUL DL ;(IL PRODOTTO IN AX) ADD CX,AX ;SPOSTA IL DIVIDENDO FINALE IN AX ;Converti il divisore BCD in BX in un numero binario in BL MOV AX,BX ;SPOSTA IL DIVISORE IN AX AAD ;CONVERTILO IN BINARIO IN AL E MOV BL,AL ;SPOSTALO IN BL ;Dividi AX per BL per produrre un quoziente e un resto binari in AL ;e AH, poi convertili nei corrispondenti BCD non impaccati in AX e DX MOV AX,CX ;METTI IL DIVIDENDO IN AX DIV BL ;ESEGUI LA DIVISIONE BINARIA MOV BL,99 ;TEST PER OVERFLOW DEI RISULTATI CMP BL,AL JC EXIT CMP BL,AH JC EXIT MOV BL,AL ;SALVA IL QUOZIENTE IN BL MOV AL,AH ;GENERA BCD NON IMPACCATO PER IL RESTO... SUB AH,AH MOV CL,10 ;... DIVIDENDOLO PER 10 DIV CL MOV DX,AX ;SPOSTA IL RESTO IN DX E XCHG DH,DL ;SISTEMA LE CIFRE CORTAMENTE MOV AL,BL ;GENERA BCD NON IMPACCATO PER IL QUOZIENTE SUB AH,AH DIV CL XCHG AH,AL ;SISTEMA LE CIFRE CORTAMENTE EXIT: POP CX ;RIPRISTINA I REGISTRI DI LAVORO POP BX DIV16DNI ENDP ;routine che compara due numeri senza segno o con segno di 32 bit ;Input: AX:BX = primo operando ; CX:DX = secondo operando ;Output (SENZA SEGNO): ZF = 1 op1 = op2 TASM um 114 di 175

116 ; ZF = 0, CF = 0 op1 > op2 ; ZF = 0, CF = 1 op1 < op2 ;Output (CON SEGNO): ZF = 1 op1 = op2 ; ZF = 0, SF = 0 op1 > op2 ; ZF = 0, SF = 1 op1 < op2 COMP32 PROC NEAR CMP AX,CX ;COMPARA I 16 BIT DI ORDINE ALTO JNZ EXIT CMP BX,DX ;COMPARA I 16 BIT DI ORDINE BASSO EXIT: COMP32 ENDP ;routine che somma due numeri senza segno a 32 bit ;Input: AX:BX = primo operando ; CX:DX = secondo operando ;Output:CX:DX = risultato ; Se il risultato non sta in CX:DX (overflow) allora CF = 1 ; AX e BX inalterati SOMMA32U PROC NEAR ADD DX,BX ;SOMMA I 16 BIT DI ORDINE BASSO ADC CX,AX ;SOMMA I 16 BIT DI ORDINE ALTO (CON CARRY PREC) ;RITORNA AL CHIAMANTE SOMMA32U ENDP ;routine che sottrae due numeri senza segno a 32 bit ;Input: AX:BX = numero da sottrarre al secondo operando ; CX:DX = secondo operando ;Output:CX:DX = riputato ; Se il risultato Š negativo (AX:BX>CX:DX), allora CF = 1 ; AX e BX inalterati DIFF32U PROC NEAR SUB DX,BX ;SOTTRAE I 16 BIT DI ORDINE BASSO SBB CX,AX ;SOTTRAE I 16 BIT DI ORDINE ALTO (CON BORROW PREC.) ;RITORNO AL CHIAMANTE DIFF32U ENDP ;routine che converte da numero binario a 32 bit in stringa. Tutti i registri sono preservati, ;salvo ;quelli per il passaggio parametri, tutti i parametri sono passati attraverso i registri ;DX.AX= numero da convertire; CX= numero base ; (1 to 16); DI= stringa finale. CONVERT_DIGS DB ' ABCDEF' CONVERT_NUM PROC NEAR PUSHF PUSH AX PUSH BX PUSH CX PUSH DX PUSH DI PUSH SI PUSH BP SUB SP, 4 MOV BP, SP CLD MOV SI, DI PUSH SI TASM um 115 di 175

117 ;--- LOOP FOR EACH DIGIT SUB BH, BH MOV WORD PTR [BP], AX ;SAVE LOW WORD MOV WORD PTR [BP+2], DX ;SAVE HIGH WORD SUB SI, SI ;COUNT DIGITS CONNUM1: INC SI MOV AX, WORD PTR [BP+2] ;HIGH WORD OF VALUE SUB DX, DX ;CLEAR FOR DIVIDE DIV CX ;DIVIDE, DX GETS REMAINDER MOV WORD PTR [BP+2], AX ;SAVE QUOTIENT (NEW HIGH WORD) MOV AX, WORD PTR [BP] ;LOW WORD OF VALUE DIV CX ;DIVIDE, DX GETS REMAINDER (THE DIGIT) MOV WORD PTR [BP], AX ;SAVE QUOTIENT (NEW LOW WORD) MOV BL, DL MOV AL, BYTE PTR [CONVERT_DIGS+BX] ;GET THE DIGIT STOSB ;STORE CMP WORD PTR [BP], 0 ;CHECK IF LOW WORD ZERO JNE CONNUM1 ;JUMP IF NOT CMP WORD PTR [BP+2], 0 ;CHECK IF HIGH WORD ZERO JNE CONNUM1 ;JUMP IF NOT SUB AL, AL STOSB ;STORE THE TERMINATOR ;--- REVERSE DIGITS POP CX ;RESTORE START OF STRING XCHG CX, SI SHR CX, 1 ;NUMBER OF REVERSES JZ CONNUM3 ;JUMP IF NONE XCHG DI, SI SUB SI, 2 ;POINT TO LAST DIGIT CONNUM2 : MOV AL, BYTE PTR [DI] ;LOAD FRONT CHARACTER XCHG AL, BYTE PTR [SI] ;SWAP WITH END CHARACTER STOSB ;STORE NEW FRONT CHARACTER DEC SI ;BACK UP LOOP CONNUM2 ;LOOP BACK FOR EACH DIGIT ;--- FINISHED CONNUM3 : ADD SP, 4 POP BP POP SI POP DI POP DX POP CX POP BX POP AX POPF ENDP CONVERT_NUM ;routine che converte da floating point a integer. ;Si aspetta il numero da convertire in ST and e il numero di bit significativi in AX. FLT2DEC PROC NEAR PUSH BP TASM um 116 di 175

118 SUB SP, 8 MOV BP, SP FSTCW WORD PTR [BP] ;SAVE CONTROL WORD MOV WORD PTR [BP+2], 03BFH ;NEW CONTROL WORD, ROUND TO NEAREST FLDCW WORD PTR [BP+2] ;LOAD CONTROL WORD MOV WORD PTR [BP+4], AX ;--- CONVERT NUMBER FLD ST(0) FXTRACT ;EXTRACT EXPONENT FSTP ST(0) ;POP TOP (SIGNIFICAND) FISUBR WORD PTR [BP+4] ;SUBTRACT BITS FOR SIGNIFICAND FLDL2T ;LOAD LOG2(10) FDIV ;DIVIDE, GET 10**X FRNDINT ;ROUND TO NEAREST FIST WORD PTR [BP+6] ;SAVE EXPONENT CALL EXP10 ;GET EXPONENT FACTOR FMUL ;ADJUST REAL NUMBER FOR EXPONENT ;--- FINISHED FLDCW WORD PTR [BP] ;RESTORE CONTROL WORD ADD SP, 6 POP AX NEG AX POP BP ENDP FLT2DEC ; CALCULATE 10 TO THE POWER OF ST. URN RESULT IN ST. USES 10**N = 2**(N*LOG2(10)). EXP10 PROC NEAR FLDL2T ;LOAD LOG2(10) FMUL ;MULTIPLY CALL EXP2 ;RAISE 2 TO ST POWER. ENDP EXP10 ; CALCULATE 2 TO THE POWER OF ST. URN RESULT IN ST(0). EXP2 PROC NEAR PUSH BP SUB SP, 6 ;ROOM FOR LOCAL DATA MOV BP, SP ;START OF LOCAL DATA FSTCW WORD PTR [BP] ;SAVE CONTROL WORD MOV WORD PTR [BP+2], 03BFH ;NEW CONTROL WORD, ROUND TO NEAREST FLDCW WORD PTR [BP+2] ;LOAD CONTROL WORD ;--- FOR 2**X, WHERE X = W + F OR X = W - F, WHERE W IS A WHOLE NUMBER AND ;--- F IS BETWEEN 0 AND.5 (INCLUSIVE), ST GETS F AND ST(1) GETS W FLD ST(0) ;DUPLICATE NUMBER FRNDINT ;ROUND TO INTEGER, ST => W FXCH ;EXCHANGE FSUB ST, ST(1) ;GET DIFFERENCE, ST => F ;--- CHECK SIGN OF FRACTIONAL PORTION (F) FTST ;SET FLAGS FSTSW WORD PTR [BP+4] ;SAVE FLAGS FWAIT AND BYTE PTR [BP+5], 45H ;MASK RELEVANT BITS TASM um 117 di 175

119 CMP BYTE PTR [BP+5], 1 ;CHECK NEGATIVE BIT JA EXP2ERR ;JUMP IF OTHER BITS SET, ERROR JE EXP2NEG ;JUMP IF NEGATIVE ;--- FRACTIONAL PART IS POSITIVE FOR F2XM1 ;ST => (2**F) - 1 FLD1 ;LOAD ONE FADD ;ST => 2**F FXCH ;PUT WHOLE PORTION (W) ON TOP FLD1 ;LOAD ONE FSCALE ;ST => 2**W FMULP ST(2), ST ;ST(2) => (2**F) * (2**W) FSTP ST(0) ;POP STACK JMP SHORT EXP2DON ;--- FRACTIONAL PART IS NEGATIVE EXP2NEG : FABS ;TAKE ABSOLUTE VALUE F2XM1 ;ST => (2**F) - 1 FLD1 ;LOAD ONE FADD ;ST => 2**F FXCH ;PUT WHOLE PORTION (W) ON TOP FLD1 ;LOAD ONE FSCALE ;ST => 2**W FDIVRP ST(2), ST ;ST(2) => (2**W) / (2**F) FSTP ST(0) ;POP STACK ;--- FINISHED EXP2DON : FLDCW WORD PTR [BP] ;RESTORE CONTROL WORD ADD SP, 6 POP BP ;--- ZERO OR ERROR EXP2ERR : FSTP ST(0) FSTP ST(0) ;CLEAR STACK FLD1 ;URN ONE JMP EXP2DON ENDP EXP2 ;routine che compara due blocchi di byte in memoria ;Input:SI = offset blocco sorgente ; DI = offset blocco target ; CX = numero dei byte da confrontare ;Output: ZF = 1 i blocchi sono uguali e DI rimane inalterato ; ZF = 0 mismatch di un byte, DI ne indica la posizione ; SI e CX sempre inalterati CMPMB PROC NEAR JCXZ QUIT ;ESCI SE CX = 0 PUSH CX ;SALVA I REGISTRI IN INPUT PUSH SI PUSH DI CLD ;LAVORA IN AVANTI REPE CMPSB ;COMPARA I BLOCCHI JZ MATCH ;I BLOCCHI SONO UGUALI? PUSHF ;NO, SALVA LO ZF NELLO STACK TASM um 118 di 175

120 SUB DI,1 POPF POP CX JMP EXIT MATCH: POP DI ;SI, RIPRISTINA DI E EXIT: POP SI ;I REGISTRI SI E CX POP CX ;SISTEMA DI PER PUNTARE AL BYTE DISUGUALE ;RIPRISTINA ZF ;SCARICA DALLO STACK IL VECCHIO VALORE DI DI QUIT: ;RITORNA AL CHIAMANTE CMPMB ENDP ;routine che compara due blocchi di word in memoria ;Input: SI = offset blocco sorgente ; DI = offset blocco target ; CX = numero delle word da comparare ;Output: ZF = 1 i blocchi sono uguali e DI rimane inalterato ; ZF = 0 mismatch di una word, DI ne indica la posizione ; SI e CX sempre inalterati CMPMW PROC NEAR JCXZ QUIT ;ESCI SE CX = 0 PUSH CX ;SALVA I REGISTRI IN INPUT PUSH SI PUSH DI CLD ;LAVORA IN AVANTI REPE CMPSB ;COMPARA I BLOCCHI JZ MATCH ;I BLOCCHI SONO UGUALI? PUSHF ;NO, SALVA LO ZF NELLO STACK SUB DI,2 ;SISTEMA DI PER PUNTARE ALLA WORD DISUGUALE POPF ;RIPRISTINA ZF POP CX JMP EXIT MATCH: POP DI ;SI, RIPRISTINA DI E EXIT: POP SI ;I REGISTRI SI E CX POP CX ;SCARICA DALLO STACK IL VECCHIO VALORE DI DI QUIT: ;RITORNO AL CHIAMANTE CMPMW ENDP ;routine che riempie un blocco di memoria con una costante byte ;Input: DI = offset inizio blocco ; AL = costante byte ; CX = numero di byte del blocco ;Output: il blocco viene inizializzato con il byte specificato ; Registri inalterati FILLB PROC NEAR JCXZ EXIT ;USCITA SE CX=0 PUSH DI ;SALVATAGGIO REGISTRI PUSH CX ;DI LAVORO CLD ;DIREZIONE IN AVANTI REP STOSB ;RIPETI STOSB CX VOLTE POP CX ;RIPRISTINA POP DI ;I REGISTRI EXIT: ;RITORNO AL CHIAMANTE FILLB ENDP ;routine che riempie un blocco di memoria con una costante word TASM um 119 di 175

121 ;input DI = offset inizio blocco ; AX = costante word ; CX = numero di word del blocco ;Output: il blocco viene inizializzato con la word specificata ; Registri inalterati FILLW PROC NEAR JCXZ EXIT ;USCITA SE CX=0 PUSH DI ;SALVATAGGIO REGISTRI DI LAVORO PUSH CX ;DI LAVORO CLD ;DIREZIONE IN AVANTI REP STOSW ;RIPETI STOSW CX VOLTE POP CX ;RIPRISTINA POP DI ;I REGISTRI EXIT: FILLW ENDP ;routine che ricerca uno specificato byte in un blocco di memoria ;Input: DI = offset inizio blocco ; AL = byte di ricerca ; CX = numero di byte per la ricerca ;Output:ZF = 0 byte non trovato, DI inalterato ; ZF = 1 byte trovato, DI ne indica la posizione ; AL e CX sempre inalterati FINDB PROC NEAR JCXZ QUIT ;ESCI SE CX = 0 PUSH CX ;SALVA I REGISTRI IN INPUT PUSH DI CLD ;RICERCA IN AVANTI REPNE SCASB ;ESAMINA IL BLOCCO JNZ NOT_FOUND ;TROVATO IL BYTE? PUSHF ;SI, SALVA ZF NELLO STACK SUB DI,1 ;CORREGGI DI PER PUNTARE AL BYTE POPF ;RIPRISTINA ZF POP CX ;SCARICA IL VECCHIO DI DALLO STACK JMP EXIT NOT_FOUND: POP DI ;NO, RIPRISTINA DI EXIT: POP CX ;RIPRISTINA CX QUIT: ;RITORNO AL CHIAMANTE FINDB ENDP ;routine che ricerca una specificata word in un blocco di memoria ;Input: DI = offset inizio blocco ; AX = word di ricerca ; CX = numero di word per la ricerca ;Output:ZF = 0 word non trovata, DI inalterato ; ZF = 1 word trovata, DI ne indica al posizione ; AX e CX sempre inalterati FINDW PROC NEAR JCXZ QUIT ;ESCI SE CX = 0 PUSH CX ;SALVA I REGISTRI IN INPUT PUSH DI CLD ;RICERCA IN AVANTI REPNE SCASW ;ESAMINA IL BLOCCO TASM um 120 di 175

122 JNZ NOT_FOUND ;TROVATA LA WORD? PUSHF ;SI, SALVA ZF NELLO STACK SUB DI,2 ;CORREGGI DI PER PUNTARE ALLA WORD POPF ;RIPRISTINA ZF POP CX ;SCARICA IL VECCHIO DI DALLO STACK JMP EXIT NOT_FOUND: POP DI ;NO, RIPRISTINA DI EXIT: POP CX ;RIPRISTINA CX QUIT: ;RITORNO AL CHIAMANTE FINDW ENDP ;routine che calcola la media di uno specificato numero di parole con segno ;Input: BX = offset della prima parola ; CX = contatore parole ;Output:AX = media (numero intero) ; DX = resto della media ; BX e CX inalterati MEDIAS PROC NEAR JCXZ EXIT ;ESCI SE CX = 0 PUSH BX ;SALVA L'INDIRIZZO INIZIALE XOR AX,AX ;PULISCI IL DIVIDENDO XOR DX,DX PUSH CX ;SALVA CONTATORE PAROLE NELLO STACK ADD_W: ADD AX,[BX] ;SOMMA UNA PAROLA AL TOTALE JS NEGATIVE ;IL RISULTATO POSITIVO? ADC DX,0 ;SI, PROPAGAZIONE DEL CARRY IN DX JMP NEXT_WORD NEGATIVE: CMP DX,0 ;NO, RENDI DX NEGATIVO JS NEXT_WORD ;SE NON LO Š GI ADD DX,0FFFFH NEXT_WORD: ADD BX,2 ;PUNTA ALLA PROSSIMA PAROLA LOOP ADD_W ;SOMMATE TUTTE? POP CX ;SI, RIPRISTINA IL CONTATORE DELLE PAROLE IDIV CX ;CALCOLA LA MEDIA POP BX ;RIPRISTINA L'INDIRIZZO INIZIALE EXIT: ;RITORNO AL CHIAMANTE MEDIAS ENDP ;routine che calcola la media di uno specificato numero di parole senza segno ;Input: BX = offset della prima parola ; CX = contatore parole ;Output:AX = media (numero intero) ; DX = resto della media ; BX e CX inalterati MEDIAU PROC NEAR JCXZ EXIT ;ESCI SE CX = 0 PUSH BX ;SALVA L'INDIRIZZO INIZIALE SUB AX,AX ;PULISCI IL DIVIDENDO SUB DX,DX PUSH CX ;SALVA CONTATORE PAROLE NELLO STACK ADD_W: ADD AX,[BX] ;SOMMA UNA PAROLA AL TOTALE TASM um 121 di 175

123 ADC DX,0 ;PROPAGAZIONE DEL CARRY IN DX ADD BX,2 ;PUNTA ALLA PROSSIMA PAROLA LOOP ADD_W ;SOMMATE TUTTE? POP CX ;SI, RIPRISTINA IL CONTATORE DELLE PAROLE DIV CX ;CALCOLA LA MEDIA POP BX ;RIPRISTINA L'INDIRIZZO INIZIALE EXIT: ;RITORNO AL CHIAMANTE MEDIAU ENDP ;routine che muove un blocco di byte in memoria ;Input: SI = offset blocco sorgente ; DI = offset blocco destinazione ; CX = numero di byte da muovere ;Output: il numero di byte specificato viene copiato ; dalla sorgente alla destinazione. Registri inalterati MOVBL PROC NEAR PUSH DI ;SALVATAGGIO PUSH SI ;DEI REGISTRI PUSH CX ;DI LAVORO CMP DI,SI ;LA DESTINAZIONE Š PIU ALTA IN MEMORIA JBE LOWER STD ;S. MUOVI DALLA FINE ADD SI,CX ;OFFSET INIZIALE =OFFSET FINALE + CX -1 DEC SI ADD DI,CX DEC DI JMP MOVEM LOWER: CLD ;NO. MUOVI DALL'INIZIO MOVEM: REP MOVSB POP CX ;RIPRISTINA I REGISTRI POP SI POP DI ;RITORNO AL CHIAMANTE MOVBL ENDP ;routine che calcola la versione e la revisione del DOS ;Input: nessuno ;Output:AL = numero versione AH = numero revisione DOSVER PROC NEAR MOV AH,30H DOSVER ENDP ;routine che legge un vettore di interrupt ;Input: AL = numero dell'interrupt (0..255) ;Output:ES:BX = vettore dell'interrupt ; AL inalterato RDINTV PROC NEAR PUSH AX MOV AH,35H POP AX TASM um 122 di 175

124 RDINTV ENDP ;routine che apre un qualsiasi file, read-only, per la lettura, scrittura o per ;entrambe ;Input: DX = offset pathname nomefile (ASCIIZ) ; AL = codice accesso: 0 = read, 1 = write, 2 = read-write ;Output: Se CF = 1, allora AX = codice errore ; Se CF = 0, allora AX = file handle ; DX inalterato APRIF PROC NEAR CMP AL,2 ;CODICE D'ACCESSO VALIDO JBE OKAY STC ;NO. ALLORA SETTAS CF MOV AX,1 ;METTI IL CODICE ERRORE 1 IN AX JMP QUIT ;ED ESCI OKAY: MOV AH,3DH ;FUNZIONE DOS 3DH QUIT: APRIF ENDP ;routine che chiude un file aperto con le routine CREAF o APRIF ;Input: BX = file handle ;Output:se CF = 1, allora AX = codice errore ; se CF = 0 la chiusura Š corretta ; DX inalterato CHIUDIF PROC NEAR MOV AH,3EH CHIUDIF ENDP ;routine che crea un nuovo file e lo apre in R/W. Se il file era già esistente, CREAF scarica ;il suo contenuto assegnandogli lunghezza zero ;Input: offset pathname (ASCIIZ) ;Output:Se CF = 1, file gi esistente ; Se CF = 0, AX = file handle ; DX inalterato CREAF PROC NEAR PUSH CX MOV AL,0 ;GUARDA SE IL FILE ESISTE MOV AH,43H ;CERCANDO DI LEGGERE I SUOI ATTRIBUTI JC CREATE ;IL FILE ESISTE GI? STC ;SI. SETTA IL FLAG DI CARRY JC QUIT ;ED ESCI CREATE: XOR CX,CX ;NO. ATTRIBUTI PER R/W MOV AL,3CH ;FUNZIONE DOS 3CH QUIT: POP CX CREAF ENDP END ;routine che legge uno specificato numero di byte da un file a un buffer dati ;Input: BX = file handle TASM um 123 di 175

125 ; CX = numero dei byte da leggere ; DX = offset del buffer dati ;Output:se CF = 1, allora AX = codice errore ; se CF = 0, allora AX = numero dei byte letti ; registri inalterati LEGGIF PROC NEAR CMP CX,0 ;SE CX = 0, ABBANDONA JZ EXIT MOV AH,3FH EXIT: LEGGIF ENDP ;FUNZIONE DOS 3FH ;routine che sposta il file pointer ;Input: AL = modo di gestione del file pointer (DOS 42H ; 0 = dall'inizio del file pi offset ; 1 = dalla posizione corrente pi offset ; 2 = dalla fine del file pi offset ; BX = file handle ; CX:DX = distanza in byte (offset) ;Output:se CF = 1, allora AX = codice errore ; se CF = 0, allora DX:AX = nuova locaz. del file pointer ; BX inalterato MOVPTR PROC NEAR MOV AH,42H MOVPTR ENDP ;routine che scrive byte in un file ;Input: BX = file handle ; CX = numero dei byte da scrivere ; DX = offset del buffer dei dati ;Output:se CF = 1, allora AX = codice errore ; se CF = 0, allora AX = numero dei byte scritti ; registri inalterati SCRIVIF PROC NEAR CMP CX,0 ;SE CX = 0 ABBANDONA JZ EXIT MOV AH,40H EXIT: SCRIVIF ENDP ;FUNZIONE DOS 40H ;routine che stampa un carattere sulla stampante ;Input: DL = carattere ;Output;Nessuno, DL inalterato PRINTCAR PROC NEAR PUSH AX MOV AH,5 POP AX PRINTCAR ENDP TASM um 124 di 175

126 ;routine che trasmette un carattere sulla porta seriale COM1 ;Input: DL = carattere ;Output:Nessuno, DL inalterato TXCAR PROC NEAR PUSH AX MOV AH,4 ;FUNZIONE 4 DEL DOS POP AX TXCAR ENDP ;routine che riceve un carattere dalla porta seriale COM1 ;Input: Nessuno ;Output:AL = carattere RXCAR PROC NEAR PUSH AX MOV AH,3 ;FUNZIONE 3 DEL DOS POP AX RXCAR ENDP ;routine che emette un beep dallo speaker ;Input: Nessuno ;Output:Beep sullo speaker BEEP PROC NEAR PUSH AX PUSH DX MOV DL,7 MOV AH,2 POP DX POP AX BEEP ENDP ;DL = CARATTERE BEEP ;FUNZIONE 2 DEL DOS TASM um 125 di 175

127 FILE ;Nome del programma: create.asm ;Programmatore: ;Descrizione ;Programma che crea il file in c:\new.txt; se il file esiste già il vecchio contenuto è perso. DOSSEG.MODEL SMALL.STACK.DATA CR EQU 13 LF EQU 10 STARTMESSAGE DB "IL PROGRAMMA CREA IL FILE NEW.TXT" DB,"NEL DRIVE C.$" ENDMESSAGE DB CR,LF,"FILE CREATO OK, CONTROLLA IL FILE" DB,"PER SICUREZZA.$" WRITEMESSAGE DB "ERRORE: SCRITTURA FILE$" OPENMESSAGE DB "ERRORE: APERTURA FILE$" CREATEMESSAGE DB "ERRORE: CREAZIONE FILE$" WRITEME DB "CIAO, MONDO GIORNATA MERAVIGLIOSA DI.",0 FILENAME DB "C:\NEW.TXT",0 ; NAME OF FILE TO OPEN HANDLE DW? ; TO STORE FILE HANDLE.CODE BEGIN: MOV AX,@DATA MOV DS,AX ; MOV DX,OFFSET STARTMESSAGE MOV AH,09H MOV DX,OFFSET FILENAME ; METTE L'OFFSET DI FILENAME IN DX XOR CX,CX ; AZZERA CX - CREA UN FILE ORDINARIO MOV AH,3CH ; FUNZIONE 3CH - CREA UN FILE ; CHIAMA IL SERVIZIO DOS JC CREATEERROR ; GESTISCI L'EVENTUALE ERRORE MOV BX,AX ; METTE IL FILE HANDLE IN BX MOV AH,3EH ; FUNZIONE 3EH - CHIUDE UN FILE ; LA CHIAMA MOV DX,OFFSET FILENAME ; OFFSET DI FILENAME IN DX MOV AL,2 ; ACCESS MODE -READ AND WRITE MOV AH,3DH ; FUNZIONE 3DH - APRE UN FILE ; CHIAMATA AL DOS JC OPENERROR ; SALTA SE SI VERIFICA UN ERRORE MOV HANDLE,AX ; SALVA IL VALORE DELL' HANDLE MOV DX,OFFSET WRITEME ; INDIRIZZO DEI DATI DA SCRIVERE MOV BX,HANDLE ; FILE HANDLE PER IL FILE MOV CX,38 ; DEVONO ESSERE SCRITTI 38 BYTE MOV AH,40H ; FUNZIONE 40H - SCRIVE SU UN FILE ; LA CHIAMA JC WRITEERROR ; SALTA QUI IN CASO DI ERRORE CMP AX,CX ; SONO STATI SCRITTI TUTTI I DATI? JNE WRITEERROR ; NO - ERRORE! MOV BX,HANDLE ; METTE IL FILE HANDLE IN BX TASM um 126 di 175

128 MOV AH,3EH ; FUNZIONE 3EH - CHIUDE UN FILE ; LA CHIAMA MOV DX,OFFSET ENDMESSAGE MOV AH,09H URNTODOS: MOV AX,4C00H ; TERMINA IL PROGRAMMA WRITEERROR: MOV DX,OFFSET WRITEMESSAGE JMP ENDERROR OPENERROR: MOV DX,OFFSET OPENMESSAGE JMP ENDERROR CREATEERROR: MOV DX,OFFSET CREATEMESSAGE ENDERROR: MOV AH,09H MOV AX,4C01H END BEGIN TASM um 127 di 175

129 ;Nome del programma: delete.asm ;Programmatore: ;Descrizione ;Programma che cancella il file in c:\new.txt; si controlla se il file esista prima di ;cancellarlo. DOSSEG.MODEL SMALL.STACK.DATA CR EQU 13 LF EQU 10 FILE DB "C:\NEW.TXT",0 DELETED DB "CANCELLAZIONE FILE C:\NEW.TXT$" NOFILE DB "C:\NEW.TXT NON ESISTE$" ERRDEL DB "NON E' POSSIBILE CANCELLARE IL FILE - ERRORE: PROTEZIONE DA SCRITTURA$".CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV DX,OFFSET FILE ; INDIRIZZO DEL FILENAME CHE CERCHIAMO MOV CX,3FH ; FILE MASK 3FH - QUALSIASI TIPO DI FILE MOV AH,4EH ; FUNZIONE 4EH - FIND FIRST FILE ; CHIAMA IL SERVIZIO DOS JC FILEDONTEXIST MOV DX,OFFSET FILE ; DS:DX PUNTA AL FILE DA DISTRUGGERE MOV AH,41H ; FUNZIONE 41H - DELETE FILE ; LA CHIAMA JC ERRORDELETING ; SALTA IN CASO DI ERRORE MOV DX,OFFSET DELETED ; VISUALIZZA IL MESSAGGIO JMP ENDIT ERRORDELETING: MOV DX,OFFSET ERRDEL JMP ENDIT FILEDONTEXIST: MOV DX,OFFSET NOFILE ENDIT: MOV AH,9 MOV AX,4C00H ; TERMINA IL PROGRAM ED ESCI AL DOS ; CHIAMA IL SERVIZIO DOS END BEGIN TASM um 128 di 175

130 ;Nome del programma: read.asm ;Programmatore: ;Descrizione ;Programma che stampa i primi 100 byte di un file. DOSSEG.MODEL SMALL.STACK.DATA HANDLE DW? ; MEMORIZZARE IL FILE HANDLE FILENAME DB "C:\TEST.TXT",0 ; FILE DA APRIRE OPENERROR DB "ERRORE: APERTURA FILE!$" READERROR DB "ERRORE: LETTURA FILE!$" BUFFER DB 100 DUP (?) ; BUFFER PER MEMORIZZARE I DATI LETTI.CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV DX,OFFSET FILENAME ; METTE L'INDIRIZZO DI FILENAME IN DX MOV AL,2 ; MODALITÀ D'ACCESSO - LETTURA E SCRITTURA MOV AH,3DH ; FUNZIONE 3DH - APRE IL FILE ; CHIAMA IL SERVIZIO DOS MOV HANDLE,AX ; SALVA IL SAVE FILE HANDLE PER DOPO JC ERROROPENING ; SALTA SE IL CARRY FLAG È SETTATO - ERRORE! MOV DX,OFFSET BUFFER ; INDIRIZZO DEL BUFFER IN DX MOV BX,HANDLE ; HANDLE IN BX MOV CX,100 ; QUANTITÀ DI BYTE DA LEGGERE MOV AH,3FH ; FUNZIONE 3FH - LEGGE DA UN FILE ; CHIAMA IL SERVIZIO DOS JC ERRORREADING ; SALTA SE IL CARRY FLAG È ON - ERRORE! ;AGGIUNGERE PUSH AX MOV BX,HANDLE ; METTE IL FILE HANDLE IN BX MOV AH,3EH ; FUNZIONE 3EH - CHIUDE UN FILE ; CHIAMA IL SERVIZIO DOS ;SOSTITUIRE CON POP CX MOV CX,100 ; LUNGHEZZA DELLA STRINGA MOV SI,OFFSET BUFFER ; DS:SI - INDIRIZZO DELLA STRINGA XOR BH,BH ; PAGINA VIDEO - 0 MOV AH,0EH ; FUNZIONE 0EH - SCRIVE UN CARATTERE NEXTCHAR: LODSB ; AL = PROSSIMO CARATTERE NELLA STRINGA INT 10H ; CHIAMA IL SERVIZIO DEL BIOS LOOP NEXTCHAR MOV AX,4C00H ; FAI TERMINARE IL PROGRAMMA ERROROPENING: MOV DX,OFFSET OPENERROR ; VISUALIZZA UN ERRORE MOV AH,09H ; USANDO LA FUNZIONE 09H ; CHIAMATA AL DOS MOV AX,4C01H ; TERMINA IL PROGRAMMA CON UN ERRORLEVEL =1 ERRORREADING: MOV DX,OFFSET READERROR ; VISUALIZZA UN ERRORE MOV AH,09H ; USA IL SERVIZIO 09H ; DEL DOS TASM um 129 di 175

131 MOV AX,4C02H ; IL PRG TERMINA CON UN LIVELLO DI ERRORE =2 END BEGIN TASM um 130 di 175

132 ;Nome del programma: dirc.asm ;Programmatore: ;Descrizione ;Programma che stampa in output tutti i nomi dei file e delle sub-directory sulla root del ;drive C:\. DOSSEG.MODEL SMALL.STACK.DATA CR EQU 13 LF EQU 10 FILENAME DB "C:\*.*",0 ;NOMI DEI FILE DTA DB 128 DUP(?) ;BUFFER CHE CONTIENE IL DTA ERRORMSG DB "ERRORE.$" NOFILES DB "NESSUN FILES TROVATO.$".CODE BEGIN: MOV AX,@DATA MOV DS,AX MOV ES,AX MOV DX,OFFSET DTA ; DS:DX PUNTA AL DTA MOV AH,1AH ; FUNZIONE 1AH - IMPOSTA IL DTA ; CALL DOS SERVICE MOV CX,3FH ; ATTRIBUTE MASK - TUTTI I FILE MOV DX,OFFSET FILENAME ;DS:DX PUNTA ALLA STRINGA ASCIZ DEL FILENAME MOV AH,4EH ; FUNZIONE 4EH - FIND FIRST JC ERROR ; SALTA SE IL CARRY FLAG È IMPOSTATO A 1 LOOPCYCLE: MOV CX,13 ; LUNGHEZZA DEL CAMPO NOME DEL FILE NEL DTA MOV SI,OFFSET DTA+30 ; DS:SI PUNTA AL NOME DEL FILE NEL DTA XOR BH,BH ; VIDEO PAGE - 0 MOV AH,0EH ; FUNZIONE 0EH - WRITE CHARACTER NEXTCHAR: LODSB ; AL = PROSSIMO CARATTERE DELLA STRINGA INT 10H ; CHIAMA IL SERVIZIO DEL BIOS LOOP NEXTCHAR ;VAI A CAPO ;MOV AL,CR ;INT 10H ;MOV AL,LF ;INT 10H ;SOSTITUIRE CON MOV AL,' ' INT 10H MOV AL,' ' INT 10H MOV AL,' ' INT 10H ; PER AVERE UNA LISTA COMPATTA MOV DI,OFFSET DTA+30 ; ES:DI PUNTA AL NOMEFILE NEL DTA MOV CX,13 ; LUNGHEZZA DEL CAMPO FILENAME XOR AL,A ; RIEMPILO CON ZERI TASM um 131 di 175

133 REP STOSB MOV DX,OFFSET FILENAME ; DS:DX PUNTA AL NOME DEL FILE MOV AH,4FH ; FUNZIONE 4FH - FIND NEXT ; CHIAMA SERVIZIO DOS JC EXIT ; ESCI SE IL CARRY FLAG È ON JMP LOOPCYCLE ; CONTINUA A CERCARE ERROR: CMP AX,12H JNZ WRITE_ERR MOV DX,OFFSET NOFILES JMP PRINT WRITE_ERR: MOV DX,OFFSET ERRORMSG ; VISUALIZZA MESSAGGIO DI ERRORE PRINT: MOV AH,9 EXIT: MOV AX,4C00H END BEGIN TASM um 132 di 175

134 ;Nome del programma: cripta.asm ;Programmatore: ;Descrizione ;Programma che cripta un file. ASSUME CS : PROG, DS : DATI, SS : STACKSEG DATI SEGMENT PATHNAME_IN DB 'SICY ',0,'$' PATHNAME_OUT DB 'ROSI ',0,'$' FHANDLEIN DW 1 FHANDLEOUT DW 1 CHAR DB 0 ; BUFFER BUFFERPAROLA LABEL WORD L_MAX DB 30 L_ATT DB 0 ; CR ESCLUSO PASSWORD LABEL BYTE PAROLA DB 30 DUP (32) DB '$' PASSWDMSG DB 'PASSWORD : ','$' FILEINMSG DB 'FILE DI INPUT: $ ' FILEOUTMSG DB ' FILE DI OUTPUT: $' STRINGA DB 'CIAO!!! ',0DH,0AH,'$' EOL DB 0DH,0AH,'$' ERROR_MSG DB 'CARRY IS SET - ABORT ',0DH,0AH,'$' PUNTO1 DB ' APERTURA FILE SICY',0DH,0AH,'$' PUNTO2 DB ' APERTURA FILE ROSI',0DH,0AH,'$' PUNTO3 DB ' LETTURA DA SICY ',0DH,0AH,'$' PUNTO4 DB ' SCRITTURA SU ROSI',0DH,0AH,'$' DATI ENDS STACKSEG SEGMENT DW 800H DUP (?) STK_TOP LABEL WORD STACKSEG ENDS PROG SEGMENT LEGGI MACRO BUFFER,MAX_L PUSH AX PUSH BX PUSH DX MOV AH,0AH MOV DX,OFFSET BUFFER MOV BUFFER,MAX_L ; LASCIA IN BUFFER UN < CR > ALLA FINE DELLA STRINGA POP DX POP BX POP AX ENDM CREATE_HANDLE MACRO PATH,ATTRIB ; 3CH CREATE AND OPEN PUSH CX PUSH DX MOV DX,OFFSET PATH MOV CX, ATTRIB MOV AH,3CH POP DX POP CX TASM um 133 di 175

135 ENDM ; IN AX HANDLE OPEN_HANDLE MACRO PATH,ACCESS ; 3DH MOV DX,OFFSET PATH MOV AL,ACCESS MOV AH, 3DH ENDM CLOSE_HANDLE MACRO HANDLE ; 3EH PUSH BX MOV BX,HANDLE MOV AH,3EH POP BX ENDM READ_HANDLE MACRO HANDLE, BUFFER, BYTES ; 3FH PUSH BX PUSH CX PUSH DX MOV BX,HANDLE MOV CX,BYTES MOV DX,OFFSET BUFFER MOV AH,3FH POP DX POP CX POP BX CMP AX,0 ; SE AX È 0, EOF(HANDLE) JE CLOSEFILES ENDM WRITE_HANDLE MACRO HANDLE,DATA,BYTES ; 40H PUSH AX PUSH BX PUSH CX PUSH DX MOV BX,HANDLE MOV CX,BYTES MOV DX,OFFSET DATA MOV AH,40H POP DX POP CX POP BX POP AX ENDM FINE MACRO MOV AH,4DH ; GET URN CODE ;. CODE IN AX MOV AH,4CH ENDM CLEAR PROC PUSH CX PUSH BX PUSH AX TASM um 134 di 175

136 MOV CX,30 MOV AL,32 MOV BX,0 LOOPLAB: MOV PASSWORD[BX],AL INC BX LOOP LOOPLAB POP AX POP BX POP CX CLEAR ENDP DIS PROC ; IN DX SI ASPETTA L'OFFSET DELLA STRINGA PUSH AX MOV AH,9 ; N.O DELLA SYSTEM CALL POP AX DIS ENDP ERROR2 : MOV DX, OFFSET ERROR_MSG CALL DIS MOV DX, OFFSET PUNTO2 CALL DIS MOV SI,OFFSET FINEPROG JMP SI ERROR1 : MOV DX, OFFSET ERROR_MSG CALL DIS MOV DX, OFFSET PUNTO1 CALL DIS MOV DX, OFFSET PATHNAME_IN CALL DIS MOV SI,OFFSET FINEPROG JMP SI INIZIO : MOV AX,DATI MOV DS,AX MOV AX,STACKSEG MOV SS,AX MOV SP, OFFSET STK_TOP MOV DX, OFFSET FILEINMSG CALL DIS LEGGI BUFFERPAROLA,13 ; FILE DI INPUT --> PATHNAME_IN MOV DX, OFFSET EOL CALL DIS MOV BX,0 MOVE1: MOV AL,BYTE PTR BUFFERPAROLA[BX+2] MOV PATHNAME_IN[BX],AL INC BL CMP AL,0DH JNE MOVE1 MOV PATHNAME_IN[BX-1],0 CALL CLEAR TASM um 135 di 175

137 MOV DX, OFFSET FILEOUTMSG CALL DIS LEGGI BUFFERPAROLA,13 ; FILE DI OUTPUT --> PATHNAME_OUT MOV DX, OFFSET EOL CALL DIS MOV BX,0 MOVE: MOV AL,BYTE PTR BUFFERPAROLA[BX+2] MOV PATHNAME_OUT[BX],AL INC BL CMP AL,0DH JNE MOVE MOV PATHNAME_OUT[BX-1],0 CALL CLEAR MOV DX, OFFSET PASSWDMSG CALL DIS ; LEGGI PASSWORD,30 LEGGI D UN'ECO SU VIDEO (AHIMŠ!!!) MOV CX,30 XOR BX,BX GET_PASS: MOV AH,8 ; READ KEYBOARD MOV PASSWORD[BX],AL INC BX CMP AL,0DH JE AVANTI ; PASSWORD DI MAX 30 CARATTERI - TERMINA CON CR LOOP GET_PASS AVANTI: MOV BX,0 OPEN_HANDLE PATHNAME_IN,0 ; APERTURA DEL FILE DI INPUT ( SICY ) JNC GO MOV SI,OFFSET ERROR1 JMP SI GO : MOV FHANDLEIN,AX CREATE_HANDLE PATHNAME_OUT,0 JNC GO_ON2 JMP ERROR2 GO_ON2: MOV FHANDLEOUT,AX XOR BX,BX CICLO: READ_HANDLE FHANDLEIN,CHAR,1 MOV AL,PASSWORD[BX] XOR CHAR,AL ; CRYPT&DECRYPT WRITE_HANDLE FHANDLEOUT,CHAR,1 INC BX ; PROSSIMO CARATTERE CMP BL,L_ATT JNE CICLO MOV BX,0 JMP CICLO CLOSEFILES: CLOSE_HANDLE FHANDLEIN CLOSE_HANDLE FHANDLEOUT TASM um 136 di 175

138 MOV DX,OFFSET STRINGA CALL DIS FINEPROG : FINE PROG ENDS END INIZIO C:\Compiler\BORLANDC\Output>cripta FILE DI INPUT: conta.txt FILE DI OUTPUT: pippo.txt PASSWORD: CIAO!!! C:\Compiler\BORLANDC\Output> TASM um 137 di 175

139 INTERRUZIONE HARDWARE ;Nome del programma: vectors.asm ;Programmatore: ;Descrizione: ;Programma che stampa i vettori d interrupt. DOSSEG.MODEL SMALL.STACK.DATA ROW DB 02 COLUMN DB 00 INTCOUNT DB 00 OUTPUT DB 'INT ' INTNUM DW 0000 DB 'H $' ADDRESS EQU THIS BYTE SEGNUM DW 0000,0000 DB ':' OFFNUM DW 0000,0000 DB '$' UNUSED DB '[UNUSED]$' TOPLINE DB ' SYSTEM INTERRUPT VECTORS$' PAUSE DB 'PREMI UN TASTO QUALSIASI PER CONTINUARE...$'.CODE BEGIN: VECTORS PROC CALL NEWSCREEN MOV BX,0 MOV ES,BX MOV INTCOUNT,0 MOV CX,255 VLOOP: MOV AL,INTCOUNT CALL CONHEX MOV INTNUM,AX MOV AX,ES:[BX] CALL CONHEXLONG MOV OFFNUM[0],AX MOV OFFNUM[2],DX INC BX INC BX MOV AX,ES:[BX] CALL CONHEXLONG MOV SEGNUM[0],AX MOV SEGNUM[2],DX INC BX INC BX CALL SHOWVECTOR INC INTCOUNT ; INTERRUPT SUCCESSIVO JNE VLOOP CALL PAGEPAUSE CALL CLS TASM um 138 di 175

140 .EXIT VECTORS ENDP ;Routine che visualizza i vettori d interrupt sullo schermo ;Input: ;Output: ;Registri distrutti: SHOWVECTOR PROC USES AX BX DX MOV DH,ROW MOV DL,COLUMN MOV BH,0 MOV AH,2 ;POSIZIONE DEL CURSORE INT 10H MOV DX,OFFSET OUTPUT ;PUNTO DI INIZIO DELLA VISUALIZZAZIONE MOV AH,9 MOV DX,OFFSET ADDRESS CMP SEGNUM[0],3030H JNE SV1 CMP SEGNUM[2],3030H JNE SV1 CMP OFFNUM[0],3030H JNE SV1 CMP OFFNUM[2],3030H JNE SV1 MOV DX,OFFSET UNUSED SV1: MOV AH,9 INC ROW ;RIGA SUCCESSIVA CMP ROW,21 JLE SVOK MOV ROW,2 ADD COLUMN,20 CMP COLUMN,80 ;IL VIDEO È PIENO? JL SVOK ;NO, CONTINUA MOV COLUMN,0 CALL PAGEPAUSE CALL NEWSCREEN SVOK: SHOWVECTOR ENDP ;Routine che setta leinformazioni sullo schermo ;Input: ;Output: ;Registri distrutti: NEWSCREEN PROC USES AX BX DX CALL CLS MOV DX,0 MOV BH,0 MOV AH,2 INT 10H MOV DX,OFFSET TOPLINE MOV AH,9 NEWSCREEN ENDP TASM um 139 di 175

141 ;Routine clrscr() ;Input: ;Output: ;Registri distrutti: CLS PROC USES AX BX CX DX MOV AH,6 MOV AL,0 MOV BH,7 MOV CX,0 MOV DH,24 MOV DL,79 INT 10H CLS ENDP ;Routine che ferma la stampa della pagina ;Input: ;Output: ;Registri distrutti: PAGEPAUSE PROC USES AX BX DX MOV DH,23 MOV DL,0 MOV BH,0 MOV AH,2 INT 10H MOV DX,OFFSET PAUSE MOV AH,9 MOV AH,0 INT 16H PAGEPAUSE ENDP ;Routine che converte il numero in AL in ASCII ;Input: ;Output: ;Registri distrutti: CONHEX PROC USES CX MOV CL,10H MOV AH,0 DIV CL ;DIVIDO PER 16 ADD AL,30H ADD AH,30H CMP AL,'9' ;È MAGGIORE DI 9? JBE CA4 ;NO, CONTINUA ADD AL,7 CA4: CMP AH,'9' ; È UGUALE A 9? JBE CA5 ;NO, CONTINUA ADD AH,7 CA5: CONHEX ENDP ;Routine che converte il numero in AX in ASCII ;Input: ;Output: ;Registri distrutti: CONHEXLONG PROC TASM um 140 di 175

142 PUSH AX CALL CONHEX MOV DX,AX POP AX MOV AL,AH CALL CONHEX CONHEXLONG ENDP END BEGIN System Interrupt Vectors Int 00h 00A7:1068 Int 14h 0210:09B0 Int 28h 00A7:10B8 Int 3Ch 00A7:10B8 Int 01h 0070:018B Int 15h 02DF:020D Int 29h 0070:0254 Int 3Dh 00A7:10B8 Int 02h 03CD:0016 Int 16h 0210:09C4 Int 2Ah D28D:04F2 Int 3Eh 00A7:10B8 Int 03h 0070:018B Int 17h 0210:058B Int 2Bh 00A7:10B8 Int 3Fh 00A7:10B8 Int 04h 0070:018B Int 18h 0210:0C0E Int 2Ch 00A7:10B8 Int 40h 0210:048A Int 05h 0210:06B9 Int 19h 0210:0C14 Int 2Dh 00A7:10B8 Int 41h 0210:03FF Int 06h 0210:0740 Int 1Ah 0210:0C1F Int 2Eh 044C:0140 Int 42h 0210:0976 Int 07h 0210:03FF Int 1Bh 0210:06AD Int 2Fh 05B3:0E10 Int 43h C000:DA82 Int 08h 0210:0746 Int 1Ch 0210:06AD Int 30h A710:AEEA Int 44h F000:E819 Int 09h 05B3:06EC Int 1Dh F000:F0A4 Int 31h F000:E800 Int 45h F000:E819 Int 0Ah 03CD:003A Int 1Eh 0210:0537 Int 32h 00A7:10B8 Int 46h F000:6240 Int 0Bh 03CD:0054 Int 1Fh C000:D682 Int 33h CF02:23C4 Int 47h F000:E819 Int 0Ch 03CD:006E Int 20h 00A7:1072 Int 34h 00A7:10B8 Int 48h F000:E819 Int 0Dh 03CD:0088 Int 21h 032E:0225 Int 35h 00A7:10B8 Int 49h F000:E819 Int 0Eh 03CD:00A2 Int 22h 044C:01DE Int 36h 00A7:10B8 Int 4Ah F000:E819 Int 0Fh 0210:03FF Int 23h 044C:014B Int 37h 00A7:10B8 Int 4Bh F000:E819 Int 10h 0210:08A9 Int 24h 044C:0156 Int 38h 00A7:10B8 Int 4Ch F000:E819 Int 11h 0210:09A4 Int 25h 00A7:1086 Int 39h 00A7:10B8 Int 4Dh F000:E819 Int 12h 0210:09AA Int 26h 00A7:1090 Int 3Ah 00A7:10B8 Int 4Eh F000:E819 Int 13h 0210:045D Int 27h 00A7:109A Int 3Bh 00A7:10B8 Int 4Fh F000:E819 Press any key to continue... TASM um 141 di 175

143 ;Nome del programma: int.asm ;Programmatore: ;Descrizione: ;Programma che blocca l'orologio interno per 10 secondi sostituendo la routine di servizio ;INT8 con una routine che decrementa solo CX e non svolge alcun altro compito ;l'orologio ;non è aggiornato per 182 volte. INCLUDE C:\COMPILER\BORLANDC\OUTPUT\INTMACRO.INC DOSSEG.MODEL SMALL.STACK.DATA OLDIP DW 0 OLDCS DW 0 OLDIMR1 DB 0 OLDIMR2 DB 8, 0FEH, INTER, MOV CX,182 ;FERMA L'OROLOGIO PER 10 SECONDI (182 = 10*18.2) PIPPO:CMP CX,0 JNZ 8 ;TORNA AL DOS.EXIT INTER PROC FAR DEC CX ;CONTEGGIO MOV DX,20H ;EOI MOV AL,20H OUT DX,AL I INTER ENDP END MACRO VETT, MASK, SERV, TIMER PUSH AX PUSH BX PUSH DX PUSH ES ;PRELEVA IMR1 LO SALVA IN AL,21H MOV OLDIMR1,AL ;DISATTIVA PIC1, PONENDO A 1 I BIT DI IMR MOV AL,0FFH OUT 21H,AL ;PRELEVA IMR2, LO SALVA, DISATTIVA PIC2 IN AL,0A1H MOV OLDIMR2,AL MOV AL,0FFH OUT 0A1H,AL ;PRELEVA DALLE LOCAZIONI VETTORE*4 E SEGG. IL PRECEDENTE PUNTATORE ;MEMORIZZA IN OLDCS E OLDIP IL VALORE DI CS E IP MOV AH,35H MOV AL,VETT MOV OLDCS,ES MOV OLDIP,BX ;SALVA DS E INSERISCE NELLA TABELLA DEI VETTORI L'INDIRIZZO INIZIALE TASM um 142 di 175

144 ;DELLA NUOVA ROUTINE DI SERVIZIO PUSH DS MOV DX,OFFSET SERV MOV AX,SEG SERV MOV DS,AX MOV AH,25H MOV AL,VETT POP DS ;RIPROGRAMMA IL TIMER, INVIANDO AL CONTATORE 0 (INDIRIZZO 40H) ;IL NUMERO RICEVUTO DAL PROGRAMMA CHE USA LA MACRO MOV AX,TIMER OUT 40H,AL MOV AL,AH OUT 40H,AL ;ABILITA IRQn PONENDO A ZERO IL BIT n DI IMR GLI ALTRI BIT SONO DISATTIVATI MOV AL,MASK OUT 21H,AL POP ES POP DX POP BX POP AX MACRO VETT PUSH AX PUSH DX ;DISATTIVA IL PIC1 MOV AL,0FFH OUT 21H,AL ;RIPRISTINA IL PUNTATATORE AL PRECEDENTE SERVIZIO PUSH DS MOV DX,OLDIP MOV AX,OLDCS MOV DS,AX MOV AH,25H MOV AL,VETT POP DS ;RIPRISTINA IL VALORE NEL CONTATORE 0 DEL TIMER 8254 MOV AL,0FFH OUT 40H,AL OUT 40H,AL ;PRELEVA OLDIMR1 E OLDIMR2 E LI RIPRISTINA MOV AL,OLDIMR2 OUT 0A1H,AL MOV AL,OLDIMR1 OUT 21H,AL POP DX POP AX ENDM TASM um 143 di 175

145 ;Nome del programma: int.asm ;Programmatore: ;Descrizione: ;Programma che genera INT80H. DOSSEG.MODEL SMALL.STACK.DATA ;RISERVA 4 CELLE PER MEMORIZZARE IL VETTORE PRECEDENTE OLDCS DW 0 OLDIP DW 0 ;UTILIZZA IL VETTORE 80H PER LA PROVA VETT EQU 80H MESS DB 13,10,"HAI CHIAMATO INT 80H",13,10 DB "ARRIVEDERCI!$".CODE BEGIN: ;SALVA IL PRECEDENTE VALORE PUNTATO DAL VETTORE CHIAMANDO LA ;FUNZIONE 35H DI CHE RESTITUISCE IN ES E BX GLI INDIRIZZI PUNTATI ;PRECEDENTEMENTE DA INT 80H MOV AH,35H MOV AL,VETT MOV OLDCS,ES MOV OLDIP,BX ;POSIZIONA NELLE APPOSITE LOCAZIONI INDICATE DAL VETTORE ;I VALORI DI CS E IP RELATIVI ALLA NUOVA ROUTINE DI SERVIZIO PUSH DS MOV DX,OFFSET SERVINT MOV AX,SEG SERVINT MOV DS,AX ;IN DS:DX SONO STATI MEMORIZZATI I VALORI DI ;CS E IP RELATIVI ALLA NUOVA ROUTINE MOV AH,25H MOV AL,VETT POP DS INT 80H ;MEMORIZZA NUOVAMENTE OLDCS E OLDIP NELLE ;LOCAZIONI INDICATE DAL VETTORE 80H MOV DX,OLDIP ;<--PUNTO DI RITORNO DOPO I ;SI CARICA PRIMA OLDIP, IL CAMBIAMENTO DI DS CREA PROBLEMI PER LA ;RICERCA DI DATI IN MEMORIA NON SI SALVA DS PERCHE' IL PROGRAMMA E' ;TERMINATO MOV AX,OLDCS MOV DS,AX MOV AH,25H MOV AL,VETT ;CHIAMATA FUNZIONE DI USCITA AL DOS.EXIT SERVINT PROC FAR STI MOV AH,9 TASM um 144 di 175

146 MOV DX,OFFSET MESS I SERVINT ENDP END BEGIN TASM um 145 di 175

147 ;VISUALIZZA L ORA DI SISTEMA NELL AMGOLO IN ALTO A DESTRA DIV_ORE EQU ;32772*2=65544=60*60* DIV_MIN EQU 546 ;546*2=1092=60* DIV_SEC EQU 91 ;91*2=182 CIOE' CIRCA *10 DATI SEGMENT BUF_VIDEO DW? PORTA_STATO DW? VECCHIO_VETTORE DD? COLONNA DW 0000H DATI ENDS CODICE SEGMENT ASSUME CS:CODICE,DS:DATI CONV PROC NEAR ;CONVERTE UN NUMERO MINORE MOV CL,10 ;DI 100 IN AX NEI DUE CARATTERI DIV CL ;ASCII CORRISPONDENTI IN AL E AH ADD AX,3030H CONV ENDP VISUALIZZA PROC NEAR PUSHF PUSH DX ;SALVA ANCHE DX NELLO STACK MOV DX,PORTA_STATO ;E CARICA PORTA_STATO IN DX PUSH AX CLI CLD CICLO_1:IN AL,DX TEST AL,1 JNZ CICLO_1 CICLO_2:IN AL,DX TEST AL,1 JZ CICLO_2 POP AX MOV AH,1EH ;SFONDO BLU E CARATTERE GIALLO STOSW POP DX ;RIPRISTINA DX POPF VISUALIZZA ENDP PARTE_RES: PUSH CX ;SALVA CX, DI ED ES PUSH DI ;AX, DX E DS SONO GIA' STATI PUSH ES ;SALVATI DAL SISTEMA OPERATIVO MOV AX,DATI ;CARICA IN AX IL SEGMENTO DATI MOV DS,AX ;E LO SPOSTA IN DS MOV AX,BUF_VIDEO ;CARICA BUF_VIDEO IN AX MOV ES,AX ;E LO SPOSTA IN ES MOV DI,COLONNA ;CARICA LA COLONNA DI INIZIO IN DI MOV AL,' ' ;IN AL UNO SPAZIO CALL VISUALIZZA ;E VISUALIZZA A PARTIRE DA COLONNA MOV AH,0 ;CARICA 0 IN AH INT 1AH ;E RICHIAMA IL BIOS PER LA LETTURA ;DEL CONTATORE DEI TICK DI SISTEMA SHR DX,1 ;DIVIDI PER DUE DX SHR CX,1 ;E CX JNC L_0 ;SE IL BIT MENO SIGNIFICATIVO DI CX TASM um 146 di 175

148 ;ERA A 0 SALTA A L_0 ALTRIMENTI OR DX,8000H ;METTI AD 1 IL BIT PIU' ;SIGNIFICATIVO DI DX L_0: XCHG DX,CX ;SCAMBIA DX CON CX MOV AX,CX ;E SPOSTA CX IN AX (ORA I TICK DI ;SISTEMA SI TROVANO NELLA COPPIA ;DX:AX) MOV CX,DIV_ORE ;CARICA IN CX DIV CX ;E DIVIDI CMP AX,24 ;CONFRONTA CON 24 JNE L_1 ;SE NON UGUALE SALTA ALTRIMENTI XOR AX,AX ;CONSIDERA ZERO IL QUOZIENTE L_1: CALL CONV ;CHIAMA LA PROCEDURA DI CONVERSIONE MOV CH,AH ;SPOSTA TEMPORANEAMENTE AH IN CH CALL VISUALIZZA ;E VISUALIZZA PRIMA CIFRA ORE MOV AL,CH ;RECUPERA CH E VISUALIZZA CALL VISUALIZZA ;SECONDA CIFRA ORE MOV AL,':' ;VISUALIZZA IL CALL VISUALIZZA ;CARATTERE ":" XOR AX,AX ;AZZERA AX XCHG AX,DX ;SPOSTA IL RESTO IN AX E 0 IN DX MOV CX,DIV_MIN ;CARICA 546 IN CX DIV CX ;E DIVIDI PER CX CMP AX,60 ;CONFRONTA CON 60 JNE L_2 ;SE NON UGUALE SALTA ALTRIMENTI XOR AX,AX ;CONSIDERA 0 IL QUOZIENTE L_2: CALL CONV ;CHIAMA LA PROCEDURA DI CONVERSIONE MOV CH,AH ;SALVA TEMPORANEAMENTE AH IN CH CALL VISUALIZZA ;VISUALIZZA PRIMA CIFRA MINUTI MOV AL,CH ;RECUPERA CH E VISUALIZZA CALL VISUALIZZA ;SECONDA CIFRA MINUTI MOV AL,':' ;VISUALIZZA IL CALL VISUALIZZA ;CARATTERE ":" MOV AX,DX ;SPOSTA IL RESTO IN AX XOR DX,DX ;AZZERA DX MOV CX,10 ;CARICA 10 IN CX MUL CX ;E MOLTIPLICA MOV CX,DIV_SEC ;CARICA 91 IN CX DIV CX ;E DIVIDI PER CX CMP AX,60 ;CONFRONTA CON 60 JNE L_3 ;SE NON UGUALE SALTA ALTRIMENTI XOR AX,AX ;CONSIDERA 0 IL QUOZIENTE L_3: CALL CONV ;CHIAMA LA PROCEDURA DI CONVERSIONE MOV CH,AH ;SALVA TEMPORANEAMENTE AH IN CH CALL VISUALIZZA ;E VISUALIZZA PRIMA CIFRA SECONDI MOV AL,CH ;RECUPERA CH CALL VISUALIZZA ;E VISUALIZZA SECONDA CIFRA MOV AL,' ' ;VISUALIZZA UNO CALL VISUALIZZA ;SPAZIO POP ES ;RIPRISTINA I POP DI ;REGISTRI ES POP CX ;DI E CX E JMP VECCHIO_VETTORE ;SALTA ALL'INDIRIZZO CONTENUTO IN ;VECCHIO_VETTORE TASM um 147 di 175

149 PARTE_TRANS PROC NEAR MOV AX,DATI ;CARICA IL SEGMENTO DATI IN AX MOV DS,AX ;E LO SPOSTA IN DS CALL DET_PORTA_STATO ;CHIAMA LA PROCEDURA CHE ;DETERMINA L'INDIRIZZO DELLA ;PORTA DI STATO DEL CRT ;CONTROLLER MOV PORTA_STATO,DX ;E LO SALVA IN PORTA_STATO CALL DET_BUF_VIDEO ;CHIAMA LA PROCEDURA CHE ;DETERMINA L'INDIRIZZO DEL ;BUFFER VIDEO MOV BUF_VIDEO,DX ;E LO SALVA IN BUF_VIDEO SUB COLONNA,10 ;SOTTRAE 10 (SPAZIO UTILIZZATO ;PER STAMPARE L'ORA) A COLONNA SHL COLONNA,1 ;E MOLTIPLICA PER DUE (INFATTI ;OGNI CARATTERE VIENE ;RAPPRESENTATO NEL BUFFER VIDEO ;CON DUE BYTE, UNO DI CODICE ED ;UNO PER L'ATTRIBUTO) MOV AL,1CH ;LEGGE IL VETTORE CORRENTE MOV AH,35H ;DELL'INTERRUPT 1CH E LO SALVA ;IN VECCHIO_VETTORE MOV WORD PTR VECCHIO_VETTORE,BX MOV WORD PTR VECCHIO_VETTORE+2,ES MOV AX,CODICE ;CARICA SEGMENTO CODICE IN AX MOV DS,AX ;E LO SPOSTA IN DS MOV DX,OFFSET PARTE_RES ;OFFSET DI PARTE_RES IN DX MOV AL,1CH ;MODIFICA IL VETTORE 1CH IN MOV AH,25H ;MODO CHE PUNTI A PARTE_RES MOV DX,30 ;CARICA IN DX IL NUMERO DI ;PARAGRAFI NECESSARI ALLA PARTE ;RESIDENTE (480 BYTE) MOV AL,0 ;CARICA IN AL IL CODICE DI ;TERMINAZIONE MOV AH,31H ;CARICA 31H IN AH ;E TERMINA RIMANENDO RESIDENTE PARTE_TRANS ENDP DET_BUF_VIDEO PROC NEAR PUSH BX PUSH AX MOV AH,0FH INT 10H MOV BYTE PTR COLONNA,AH ;SALVA AH (NUMERO DI CARATTERI PER RIGA) NELLA VARIABILE COLONNA MOV DX,128 CMP AH,40 JE NO80 SHL DX,1 NO80:XCHG DX,AX MUL BH CMP DL,06 JG MONO ADD AX,0800H TASM um 148 di 175

150 MONO:ADD AX,0B000H MOV DX,AX POP AX POP BX DET_BUF_VIDEO ENDP DET_PORTA_STATO PROC NEAR PUSH DS XOR DX,DX MOV DS,DX MOV DX,WORD PTR DS:[0463H] ADD DX,6 POP DS DET_PORTA_STATO ENDP CODICE ENDS END PARTE_TRANS TASM um 149 di 175

151 MOUSE ;Nome del programma: mouse.asm ;Programmatore: ;Descrizione ;Programma che setta il mouse, cliccando sul tasto sinistro del mouse visualizza a video ;un carattere mentre cliccando sul tasto destro del mouse si esce dal programma. DOSSEG.MODEL SMALL.STACK ;DEFAULT 1KB STACK.DATA XPOS DB 'COORDINATA X : $' YPOS DB ' COORDINATA Y: $' BLANK DB ' $' MSG DB 'PREMI IL TASTO DESTRO DEL MOUSE PER USCIRE$' OLDX DW 0000 OLDY DW 0000.CODE.STARTUP MOUSE1 PROC CALL CHKMOUSE ;CONTROLLA SE C'È IL MOUSE JC ALLDONE ;ERRORE, ESCI CALL CLS ;PULISCI LO SCHERMO MOV DH,24 ;RIGA 24 MOV DL,0 ;A SINISTRA MOV BH,0 ;ASSUME PAGE 0 MOV AH,2 ;SETTA LA POSIZIONE DEL CURSORE INT 10H MOV DX,OFFSET MSG ;CARICO L' INDIRIZZO DEL MESSAGGIO MOV AH,9 ;SERVIZIO CHE LO STAMPA CALL SHOWMOUSE ;MOSTRA LA POSIZIONE DEL MOUSE MLOOP: MOV AX,3 ;LEGGO LO STATO DEL MOUSE INT 33H CMP BX,2 ;CONTROLLO SE È STATO PREMUTO TASTO DX JE EXIT ;SI: ESCI CMP BX,1 ;CONTROLLO SE È STATO PREMUTO TASTO SX JNE CONTINUA ;NO. CONTINUO IL LOOP MOV BL,8 ;PER CONVERTIRE PIXEL IN RIGHE/COLONNE MOV AX,CX ;CARICO IN AX L'ASCISSA DEL MOUSE DIV BL ;CONVERTO PIXEL IN RIGHE/COLONNE MOV BH,AL ;SALVO L'ESITO DELLA DIVISIONE MOV AX,DX ;CARICO IN AX L'ORDINATA DEL MOUSE DIV BL ;CONVERTO PIXEL IN RIGHE/COLONNE MOV DL,BH ;METTO IN DL LA COLONNA DEL CURSORE MOV DH,AL ;METTO IN DH LA RIGA DEL CURSORE MOV CX,0 ;NUMERO DI CARATTERI DA STAMPARE MOV BH,00H ;MODALITÀ VIDEO MOV AH,02 ;SERVIZIO RICHIESTO A INT 10H INT 10H ;LANCIO IL SUDDETTO INTERRUPT MOV DL,25H TASM um 150 di 175

152 MOV AH,2 CONTINUA: CMP CX,OLDX ;CONTROLLA SE È VARIATA LA POS. X JNE CHANGE ;SI - SALTA A CHANGE CMP DX,OLDY ;CONTROLLA SE È VARIATA LA POS. Y JE MLOOP ;NO, CONTINUA IL GIRO CHANGE: MOV OLDX,CX ;SALVA LA POSIZIONE X MOV OLDY,DX ;SALVA LA POSIZIONE Y CALL COORDS ;MOSTRA LE NUOVE COORDINATE JMP MLOOP ;ITERA EXIT: MOV AX,0 ;RESETTA IL MOUSE INT 33H CALL CLS ;PULISCI LO SCHERMO ALLDONE:.EXIT MOUSE1 ENDP ;ROUTINE CHE CONTROLLA LA PRESENZA DEL MOUSE.DATA NODRIVER DB 13,10,'SORRY, THE MOUSE DRIVER WAS NOT LOADED$' NOMOUSE DB 13,10,'A MOUSE IS NOT ATTACHED TO THE SYSTEM$'.CODE CHKMOUSE PROC USES AX BX DX ES MOV AH,35H ;VETTORE DI INTERRUPT MOV AL,33H ;MOUSE INTERRUPT OR AX,BX ;CONTROLLA SE È RITORNATO UN INDIRIZZO JZ CM1 ;NO CMP BYTE PTR ES:[BX],0CFH ; È SEMPLICEMENTE I? JNE CM2 ;NO C' È UN DRIVER È INSTALLATO CM1: MOV DX,OFFSET NODRIVER ;INDIRIZZO IL MESSAGGIO DI ERRORE JMP CM3 ;E VADO A STAMPARLO CM2: MOV AX,0 ;INIZIALIZZO IL MOUSE INT 33H CMP AX,0 ;RITORNA ZERO SE NON C' È MOUSE JNE CM4 ;MOUSE C'È MOV DX,OFFSET NOMOUSE ;CARICO IL MESSAGGIO D'ERRORE CM3: MOV AH,9 ;DISPLAY A STRING USING DOS STC ;SETTO L'INDICAZIONE D'ERRORE JC CMDONE CM4: CLC CMDONE: CHKMOUSE ENDP ;ROUTINNE CHE SELEZIONE IL CURSORE DEL MOUSE HIDEMOUSE PROC USES AX MOV AX,2 INT 33H HIDEMOUSE ENDP ;ROUTINE CHE MOSTRA IL CURSORE DEL MOUSE SHOWMOUSE PROC USES AX MOV AX,1 INT 33H TASM um 151 di 175

153 SHOWMOUSE ENDP ;ROUTINE CHE PULISCE LO SCHERMO CLS PROC USES AX BX CX DX MOV AH,6 ;SCROLL WINDOW MOV AL,0 ;SCROLL FULL SCREEN MOV BH,7 ;SCHERMO BIANCO - NERO MOV CX,0 ;ANGOLO ALTO-SX MOV DH,24 ;BOTTONE DESTRO MOV DL,79 INT 10H CLS ENDP ;ROUTINE CHE AGGIORNA LE COORDINATE SULLO SCHERMO ;METTE LA POSIZIONE X IN CX E LA POSIZIONE Y IN DX COORDS PROC USES AX BX CX DX CALL HIDEMOUSE ;EVIDENZIA THE MOUSE CURSOR PUSH DX ;SALVA LA POSIZIONE Y PUSH CX ;SALVA LA POSIZIONE X MOV DH,22 ;RIGA 22 MOV DL,0 ;A SX MOV BH,0 ;ASSUME PAGE 0 MOV AH,2 ;SETTA LA POSIZIONE CURSORE INT 10H MOV DX,OFFSET XPOS ;INDIRIZZA MESSAGGIO PER X MOV AH,9 ;SERVIZIO DOS PER STAMPARLO POP AX ;RIPRENDE LA POSIZIONE X CALL PRTDEC ;VA A STAMPARLA MOV DX,OFFSET YPOS ;INDIRIZZA MESSAGGIO PER X MOV AH,9 ;SERVIZIO DOS PER STAMPARLO POP AX ;RIPRENDE LA POSIZIONE Y CALL PRTDEC ;VA A STAMPARLA MOV DX,OFFSET BLANK ;STRINGA VUOTA MOV AH,9 ;VA A STAMPARLA CALL SHOWMOUSE ;REDISEGNA MOUSE CURSOR COORDS ENDP ;ROUTINE CHE STAMPA IL VALORE IN AX IN DECIMALE PRTDEC PROC USES AX CX DX MOV CX,0FFFFH ;ENDING FLAG PUSH CX MOV CX,10 PD1: MOV DX,0 DIV CX ;DIVIDE PER 10 ADD DL,30H ;CONVERTI IN FORMATO ASCII PUSH DX ;STORE REMAINDER CMP AX,0 ;FINITO? JNE PD1 ;NO, CONTINUA PD2: POP DX ;METTO IL CAR. IN DL CMP DX,0FFFFH ; È L'ENDING FLAG? JE PD3 ;SÌ, CONTINUA TASM um 152 di 175

154 MOV AH,02H ;STAMPA UN CARATTERE JMP PD2 ;ITERA PD3: PRTDEC ENDP END MOUSE Non esiste uno standard unico per l'interfaccia verso questo dispositivo. Si trovano in commercio tre tipi differenti di dispositivi con interfacce differenti. Mouse seriale È dotato d interfaccia seriale RS-232 completa, con connettore a 25 Pin. Presenta la massima flessibilità di utilizzo, unita però ad un costo superiore. I segnali del connettore di collegamento sono quelli standard della interfaccia RS-232. Mouse a bus È provvisto di una opportuna scheda da inserire in uno slot libero del PC. I segnali che sono gestiti sono quelli che provengono direttamente dagli switches e dai sensori di posizione del mouse. Il pin-out del connettore di collegamento è il seguente: SEGNALI DI INTERFACCIA MOUSE Pin Segnale Descrizione 1 +5V Alimentazione mouse 2 XAA Sensore spostamento X 3 XBB Sensore spostamento X 4 YAA Sensore spostamento Y 5 YBB Sensore spostamento Y 6 LFT Pulsante sinistro 7 Libero 8 RGH Pulsante destro 9 GND Mouse tipo PS/2 È stato introdotto dalla IBM con la linea dei PS/2, è un mouse di tipo seriale semplificato. Esso utilizza una comunicazione di tipo seriale analoga a quella della tastiera. Il pin-out del connettore di collegamento è il seguente: SEGNALI DI INTERFACCIA MOUSE PS2 Pin Segnale Descrizione 1 Data Dati dal mouse 2 Riservato 3 GND Massa 4 +5V Alimentazione 5 Clock Clock di lettura dati 6 Riservato INT 33 - MS MOUSE - RESET DRIVER AND READ STATUS AX = 0000h Return: AX = status 0000h hardware/driver not installed FFFFh hardware/driver installed BX = number of buttons FFFFh two buttons 0000h other than two TASM um 153 di 175

155 0003h Mouse Systems mouse Note: to use mouse on a Hercules-compatible monographics card in graphics mode, you must first set 0040h:0049h to 6 for page 0 or 5 for page 1, and then call this function INT 33 - MS MOUSE - SHOW MOUSE CURSOR AX = 0001h INT 33 - MS MOUSE - HIDE MOUSE CURSOR AX = 0002h Note: multiple calls to hide the cursor will require multiple calls to function 01h to unhide it INT 33 - MS MOUSE - URN POSITION AND BUTTON STATUS AX = 0003h Return: BX = button status bit 0 left button pressed if 1 bit 1 right button pressed if 1 bit 2 middle button pressed if 1 (Mouse Systems mouse) CX = column DX = row INT 33 - MS MOUSE - POSITION MOUSE CURSOR AX = 0004h CX = column DX = row Note: the row and column are truncated to the next lower multiple of the cell size; however, some versions of the Microsoft documentation incorrectly state that the coordinates are rounded INT 33 - MS MOUSE - URN BUTTON PRESS DATA AX = 0005h BX = button 0000h left 0001h right 0002h middle (Mouse Systems mouse) Return: AX = button states bit 0 left button pressed if 1 bit 1 right button pressed if 1 bit 2 middle button pressed if 1 (Mouse Systems mouse) BX = number of times specified button has been pressed since last call CX = column at time specified button was last pressed DX = row at time specified button was last pressed INT 33 - MS MOUSE - URN BUTTON RELEASE DATA AX = 0006h BX = button 0000h left 0001h right 0002h middle (Mouse Systems mouse) Return: AX = button states bit 0 left button pressed if 1 bit 1 right button pressed if 1 bit 2 middle button pressed if 1 (Mouse Systems mouse) TASM um 154 di 175

156 BX = number of times specified button has been released since last call CX = column at time specified button was last released DX = row at time specified button was last released INT 33 - MS MOUSE - DEFINE HORIZONTAL CURSOR RANGE AX = 0007h CX = minimum column DX = maximum column INT 33 - MS MOUSE - DEFINE VERTICAL CURSOR RANGE AX = 0008h CX = minimum row DX = maximum row INT 33 - MS MOUSE - DEFINE GRAPHICS CURSOR AX = 0009h BX = column of cursor hot spot in bitmap (-16 to 16) CX = row of cursor hot spot (-16 to 16) ES:DX -> bitmap 16 words screen mask 16 words cursor mask each word defines the sixteen pixels of a row, low bit rightmost INT 33 - MS MOUSE - DEFINE TEXT CURSOR AX = 000Ah BX = hardware/software text cursor 0000h software CX = screen mask DX = cursor mask 0001h hardware CX = start scan line DX = end scan line Note: when the software cursor is selected, the char/attribute data at the current screen position is ANDed with the screen mask and then XORed with the cursor mask INT 33 - MS MOUSE - READ MOTION COUNTERS AX = 000Bh Return: CX = number of mickeys mouse moved horizontally since last call DX = number of mickeys mouse moved vertically Notes: a mickey is the smallest increment the mouse can sense positive values indicate down/right INT 33 - MS MOUSE - DEFINE INTERRUPT SUBROUTINE PARAMETERS AX = 000Ch CX = call mask bit 0 call if mouse moves bit 1 call if left button pressed bit 2 call if left button released bit 3 call if right button pressed bit 4 call if right button released bit 5 call if middle button pressed (Mouse Systems mouse) bit 6 call if middle button released (Mouse Systems mouse) TASM um 155 di 175

157 ES:DX -> FAR routine Notes: when the subroutine is called, it is passed the following values: AX = condition mask (same bit assignments as call mask) BX = button state CX = cursor column DX = cursor row SI = horizontal mickey count DI = vertical mickey count some versions of the Microsoft documentation incorrectly state that CX bit 0 means call if mouse cursor moves, and swap the meanings of SI and DI INT 33 - MS MOUSE - LIGHT PEN EMULATION ON AX = 000Dh INT 33 - MS MOUSE - LIGHT PEN EMULATION OFF AX = 000Eh INT 33 - MS MOUSE - DEFINE MICKEY/PIXEL RATIO AX = 000Fh CX = number of mickeys per 8 pixels horizontally (default 8) DX = number of mickeys per 8 pixels vertically (default 16) INT 33 - MS MOUSE - DEFINE SCREEN REGION FOR UPDATING AX = 0010h CX,DX = X,Y coordinates of upper left corner SI,DI = X,Y coordinates of lower right corner Note: mouse cursor is hidden during updating, and needs to be explicitly turned on again INT 33 - PCMOUSE - SET LARGE GRAPHICS CURSOR BLOCK AX = 0012h BH = cursor width in words CH = rows in cursor BL = horizontal hot spot (-16 to 16) CL = vertical hot spot (-16 to 16) ES:DX -> bit map of screen and cursor maps Return: AX = -1 if successful INT 33 - MS MOUSE - DEFINE DOUBLE-SPEED THRESHOLD AX = 0013h DX = threshold speed in mickeys/second, 0000h = default of 64/second Note: if speed exceeds threshold, the cursor's on-screen motion is doubled INT 33 - MS MOUSE - EXCHANGE INTERRUPT SUBROUTINES AX = 0014h CX = call mask (see AX=000Ch) ES:DX -> FAR routine Return: CX = call mask of previous interrupt routine ES:DX = FAR address of previous interrupt routine INT 33 - MS MOUSE - URN DRIVER STORAGE REQUIREMENTS AX = 0015h Return: BX = size of buffer needed to store driver state TASM um 156 di 175

158 INT 33 - MS MOUSE - SAVE DRIVER STATE AX = 0016h ES:DX -> buffer for driver state INT 33 - MS MOUSE - RESTORE DRIVER STATE AX = 0017h ES:DX -> buffer containing saved state INT 33 - MS MOUSE - SET ALTERNATE MOUSE USER HANDLER AX = 0018h CX = call mask bit 0 call if alt key pressed during event bit 1 call if ctrl key pressed during event bit 2 call if shift button pressed during event bit 3 call if right button released bit 4 call if right button pressed bit 5 call if left button released bit 6 call if left button pressed bit 7 call if mouse moves BX(???):DX = address of FAR routine Notes: when the subroutine is called, it is passed the following values: AX = condition mask (same bit assignments as call mask) BX = button state CX = cursor column DX = cursor row DI = horizontal mickey count SI = vertical mickey count up to three handlers can be defined by separate calls to this function INT 33 - MS MOUSE - URN USER ALTERNATE INTERRUPT VECTOR AX = 0019h CX = call mask Return: BX:DX = user interrupt vector CX = call mask (0 if not found) Note: attempts to find a user event handler (defined by function 18h) whose call mask matches CX INT 33 - MS MOUSE - SET MOUSE SENSITIVITY AX = 001Ah BX = horizontal speed \ CX = vertical speed / (see AX=000Fh) DX = double speed threshold (see AX=0013h) INT 33 - MS MOUSE - URN MOUSE SENSITIVITY AX = 001Bh Return: BX = horizontal speed CX = vertical speed DX = double speed threshold INT 33 - MS MOUSE - SET INTERRUPT RATE AX = 001Ch BX = rate 00h no interrupts allowed TASM um 157 di 175

159 01h 30 per second 02h 50 per second 03h 100 per second 04h 200 per second Notes: only available on InPort mouse values greater than 4 may cause unpredictable driver behavior INT 33 - MS MOUSE - DEFINE DISPLAY PAGE NUMBER AX = 001Dh BX = display page number Note: the cursor will be displayed on the specified page INT 33 - MS MOUSE - URN DISPLAY PAGE NUMBER AX = 001Eh Return: BX = display page number INT 33 - MS MOUSE - DISABLE MOUSE DRIVER AX = 001Fh Return: AX = 001Fh successful FFFFh unsuccessful ES:BX = vector for Int 33h before mouse driver was first installed Note: restores vectors for Int 10h and Int 71h (8086) or Int 74h (286/386) if you restore Int 33h to ES:BX, driver will be completely disabled INT 33 - MS MOUSE - ENABLE MOUSE DRIVER AX = 0020h Note: restores vectors for Int 10h and Int 71h (8086) or Int 74h (286/386) which were removed by function 1Fh INT 33 - MS MOUSE - SOFTWARE RESET AX = 0021h Return: AX = FFFFh if mouse driver installed 0021h if mouse driver not installed BX = 2 if mouse driver is installed Note: identical to funtion 00h, but does not reset the mouse INT 33 - MS MOUSE - SET LANGUAGE FOR MESSAGES AX = 0022h BX = language 0 English 1 French 2 Dutch 3 German 4 Swedish 5 Finnish 6 Spanish 7 Portugese 8 Italian Note: only available on internation version of the driver, US versions ignore this call INT 33 - MS MOUSE - GET LANGUAGE FOR MESSAGES AX = 0023h Return: BX = language (see AX=0022h) TASM um 158 di 175

160 Note: the US version of the driver always returns zero INT 33 - MS MOUSE - GET SOFTWARE VERSION AND MOUSE TYPE AX = 0024h Return: AX = FFFFh on error otherwise, BH = major version BL = minor version CH = type (1=bus, 2=serial, 3=InPort, 4=PS/2, 5=HP) CL = interrupt (0=PS/2, 2=IRQ2, 3=IRQ3,...,7=IRQ7) INT 33 - PCMOUSE - GET MSMOUSE STORAGE REQUIREMENTS AX = 0042h Return: AX = FFFFh successful BX = buffer size in bytes for functions 50h and 52h = 0000h MSMOUSE not installed = 0042h functions 42h, 50h, and 52h not supported INT 33 - PCMOUSE - SAVE MSMOUSE STATE AX = 0050h BX = buffer size ES:DX -> buffer Return: AX = FFFFh if successful INT 33 - PCMOUSE - RESTORE MSMOUSE STATE AX = 0052h BX = buffer size ES:DX -> buffer Return: AX = FFFFh if successful TASM um 159 di 175

161 CPU 386 ;Nome del programma: 386.asm ;Programmatore: ;Descrizione ;Programma che gira su CPU 386 (c>tasm 386 c>tlink /3 386)..386C STACKSEG SEGMENT STACK USE32 'STACK' DB 200 DUP(?) STACKSEG ENDS DATA SEGMENT USE32 MESSAGE DB 'HELLO, WORLD',13,10,'$' DATA ENDS CODE SEGMENT USE32 ASSUME CS:CODE,DS:DATA,SS:STACKSEG BEGIN: MOV AX,DATA MOV DS,AX MOV EDX,OFFSET MESSAGE MOV AH,09H MOV EAX,4C00H CODE ENDS END BEGIN TASM um 160 di 175

162 PSP (PROGRAM SEGMENT PREFIX) ;Nome del programma: psp.asm ;Programmatore: ;Descrizione ;Programma che stampa un argomento passato al programma sulla linea di comando. ;Gli argomenti sono messi nel PSP all'indirizzo 81H ;iniziano ;con un blank (20H) e la ;lunghezza compreso il blank è memorizzata all'indirizzo 80H. DOSSEG.MODEL SMALL.STACK 200H.DATA ARGOMENTO DB 128 DUP (00H) ;spazio per l'argomento.code BEGIN: MOV AX,@DATA MOV ES,AX ;spostamento dell'argomento dal PSP al segmento dati MOV SI,82H LEA DI, ARGOMENTO ;caricamento in CX della lunghezza della stringa MOV CH,0 MOV CL,DS:80H ;copia della stringa dell'argomento inserito nella stringa del segmento dati DEC CX MOV BX,CX CLD REP MOVSB ;modifica di DS in modo che punti al segmento dati MOV DS,AX MOV ARGOMENTO [BX],"$" ;per la stampa della stringa LEA DX, ARGOMENTO MOV AH,09 MOV AX,4C00H END BEGIN C:\Compiler\BORLANDC\Output>psp argomento argomento C:\Compiler\BORLANDC\Output> TASM um 161 di 175

163 ASSEMBLY INLINE #include <stdio.h> #include <string.h> #include <conio.h> void stampa (char testo []); int main(void) { char prova [16];strcpy (prova,"ciao, mondo\r\n$"); clrscr(); printf ("%s\n", prova); stampa (prova); getch();return (0); } void stampa (char testo []) { asm { MOV DX, WORD PTR testo MOV AH,9 } } TASM um 162 di 175

164 #include<stdio.h> #include<conio.h> #include<math.h> #define N 5 int media(int *tabella[], int numval); int varianza(int *tabella[], int numval,int med); int main(void) { int tabella[n]={10,15,20,15,10}; clrscr(); printf("la media vale : %d\n",media(tabella,n)); printf("la varianza vale : %d\n",varianza(tabella,n,media(tabella,n))); printf("la deviazione standard vale : %f\n",sqrt(varianza(tabella,n,media(tabella,n)))); getch(); return (0); } int media (int *tabella[], int numval) { asm { } ciclo: asm { MOV SI,WORD PTR tabella MOV AX,0 MOV DX,0 MOV CX,numval ADD AX,[SI] ADC DX,0 ADD SI,2 LOOP ciclo MOV DX,0 MOV CX,numval IDIV CX } return (_AX); } int varianza(int *tabella[], int numval,int med) { } asm { } ciclo: asm { MOV SI,WORD PTR tabella MOV AX,0 MOV CX,numval MOV BX,[SI] SUB BX,med PUSH AX MOV AX,BX IMUL BX MOV BX,AX POP AX ADD AX,BX INC SI INC SI LOOP ciclo MOV DX,0 MOV CX,numval IDIV CX } return(_ax); TASM um 163 di 175

165 #include<stdio.h> #include<conio.h> #define N 5 int password(char codice[],char crittogramma[],int numcar); int main(void) { char crittogramma[n]={'k','e','m','n','n'}; /* password corretta -> P I P P O */ char codice[n]; int i,esatto; clrscr(); printf("inserire password:"); for (i=0;i<n;i++) { codice[i]=getch(); printf("*"); } printf("\n"); if (password(codice,crittogramma,n)) printf("password errata!\n"); getch(); return 0; } int password(char codice[],char crittogramma[],int numcar) { asm { MOV SI, WORD PTR crittogramma MOV DI, WORD PTR crittogramma MOV CX,numcar /* decodifica crittogramma */ } ciclo_decod: asm { LODSB /* carica stringa SI in AL */ ADD AL,CL /* decodifica carattere */ STOSB /* memorizza AL in stringa DI */ LOOP ciclo_decod MOV SI, WORD PTR crittogramma MOV DI, WORD PTR codice MOV CX,numcar /* confronta con password utente */ } ciclo_comp: asm { CMPSB /* contronta stringa SI con str. DI */ JNE errore /* salta se ho caratteri diversi */ LOOP ciclo_comp MOV AX,0 JMP esce } errore: asm { MOV AX,1 /* restituisce AX=1 se pwd errata */ } esce: return(_ax); } TASM um 164 di 175

166 #include<stdio.h> #include<conio.h> #define N 5 int controlla(int tabella[], int numval,int vmax); int main(void) { int tabella[n]={43,91,13,21,33},valmax; clrscr(); printf("immettere valore massimo: ");scanf("%d",&valmax); printf("rilevati %d elementi superiori!\n",controlla(tabella,n,valmax)); getch(); return (0); } /* Routine assembly che conta gli elementi dell'array TABELLA superiori ad un valore VMAX */ int controlla(int tabella[], int numval,int vmax) { asm { MOV SI,WORD PTR tabella MOV AX,0 MOV BX,vmax MOV CX,numval } ciclo: asm { CMP BX,[SI] /* confronta l'elemento con vmax */ JGE fineciclo /* salta se vmax>=tabella[si] */ INC AX } fineciclo: asm { INC SI INC SI LOOP ciclo } return(_ax); } TASM um 165 di 175

167 #include<stdio.h> #include<conio.h> #define N 5 int minimo(int *tabella[], int numval); int main(void) { int tabella[n]={43,91,13,21,33}; clrscr(); printf("il valore minimo vale: %d\n",minimo(tabella, N)); getch(); return 0; } /*Procedura assembly per il calcolo dell valore minimo su un array di numeri interi*/ int minimo(int *tabella[], int numval) { } asm { } ciclo: asm { } fineciclo: asm { MOV SI,WORD PTR tabella MOV AX,32767 /* AX=massimo valore intero */ MOV CX,numval /* ciclo su numval elementi */ CMP AX,[SI] JLE fineciclo: /* salta se AX<=tabella[SI] */ MOV AX,[SI] INC SI INC SI LOOP ciclo } return(_ax); TASM um 166 di 175

168 ASSEMBLY - C #include <stdio.h> #include <conio.h> extern int far doppio (int x); int main (void) { unsigned int i=10; clrscr(); printf ("Il doppio di %i vale %i ",i,doppio(i)); getch(); return (0); } ;Nome del programma: inser.asm ;Programmatore: ;Descrizione ;Programma che calcola il doppio. DOSSEG.MODEL SMALL.CODE PUBLIC _doppio ;Routine doppio ;Input: ;Output: ;Registri distrutti: _doppio PROC FAR PUSH BP MOV BP,SP MOV AX,[BP+6] MOV BX,2 MUL BX POP BP _doppio ENDP END Il doppio di 10 vale 20 TASM um 167 di 175

169 #include <stdio.h> #include <conio.h> extern int valore; extern void far imposta (void); int main (void) { valore=0; clrscr(); imposta(); printf ("Il valore vale %i ",valore); getch(); return (0); } ;Nome del programma: imposta.asm ;Programmatore: ;Descrizione ;Programma che imposta un valore. DOSSEG.MODEL SMALL.DATA _valore DW?.CODE PUBLIC _imposta, _valore ;Routine imposta ;Input: ;Output: ;Registri distrutti: _imposta PROC FAR PUSH DS MOV AX,@DATA MOV DS,AX MOV _valore,07h POP DS _imposta ENDP END TASM um 168 di 175

170 #include <stdio.h> #include <conio.h> extern int ToggleFlag(void); int Flag=1; int main(void) { clrscr(); printf("flag = %d",toggleflag()); getch(); return (0); } ;Nome del programma: flag.asm ;Programmatore: ;Descrizione ;Programma che imposta un flag. DOSSEG.MODEL SMALL.DATA EXTRN _Flag:WORD.CODE PUBLIC _ToggleFlag ;Routine flag ;Input: ;Output: ;Registri distrutti: _ToggleFlag PROC CMP [Flag],0 JZ SETFLAG MOV [Flag],0 JMP SHORT ENDTOGGLEFLAG SETFLAG: MOV [Flag],1 ENDTOGGLEFLAG: _toggleflag ENDP END TASM um 169 di 175

171 #include <stdio.h> #include <conio.h> extern unsigned int LineCount (char *StringToCount, unsigned int *CharacterCountPtr); char *TestString="Line 1\nline 2\nline 3"; int main (void) { unsigned int LCount=0;unsigned int CCount=0; clrscr(); LCount = LineCount(TestString, &CCount); printf("linee: %d\ncaratteri: %d\n", LCount, CCount); getch(); return (0); } NEWLINE EQU 0AH DOSSEG.MODEL SMALL.CODE PUBLIC _LINECOUNT _LINECOUNT PROC PUSH BP MOV BP,SP PUSH SI ;PRESERVE CALLING PROGRAM'S REGISTER VARIABLE, IF ANY MOV SI,[BP+4] ;POINT SI TO THE STRING SUB CX,CX ;SET CHARACTER COUNT TO 0 MOV DX,CX ;SET LINE COUNT TO 0 LINECOUNTLOOP: LODSB ;GET THE NEXT CHARACTER AND AL,AL ;IS IT NULL, TO END THE STRING? JZ ENDLINECOUNT ;YES, WE'RE DONE INC CX ;NO, COUNT ANOTHER CHARACTER CMP AL,NEWLINE ;IS IT A NEWLINE? JNZ LINECOUNTLOOP ;NO, CHECK THE NEXT CHARACTER INC DX ;YES, COUNT ANOTHER LINE JMP LINECOUNTLOOP ENDLINECOUNT: INC DX ;COUNT THE LINE THAT ENDS WITH THE ; NULL CHARACTER MOV BX,[BP+6] ;POINT TO THE LOCATION AT WHICH TO ; URN THE CHARACTER COUNT MOV [BX],CX ;SET THE CHARACTER COUNT VARIABLE MOV AX,DX ;URN LINE COUNT AS FUNCTION VALUE POP SI ;RESTORE CALLING PROGRAM'S REGISTER ; VARIABLE, IF ANY POP BP _LINECOUNT ENDP END TASM um 170 di 175

172 /*Confronta tra loro 2 vettori di n elementi stabilendo se sono uguali oppure no*/ #include <stdio.h> #include <conio.h> #include <stdlib.h> extern int far siste(int *a,int n,int *b); int main (void) { int vet1[5],vet2[5];int n,u,i; clrscr(); printf ("\ninserisci lunghezza vettore : "); scanf ("%d", &n); for (i=0;i<n;i++) { printf ("\ninserisci valore del vettore 1: "); scanf ("%d",&vet1[i]); } for (i=0;i<n;i++) { printf ("\ninserisci valore del vettore 2: "); scanf ("%d",&vet2[i]); } u=siste(&vet1[0],n,&vet2[0]); /* la procedura siste.asm restituisce 0 se i vettori sono uguali 1 se sono diversi*/ if (u==0) printf ("\ni vettori sono uguali"); else printf ("\ni vettori sono diversi"); getch(); return 0; } DOSSEG.MODEL SMALL PUBLIC _SISTE.CODE BEGIN: _SISTE PROC FAR PUSH BP MOV BP,SP MOV BX,[BP+10] MOV CX,[BP+8] MOV SI,[BP+6] COND: MOV DX,[BX] CMP DX,[SI] JNE NOTT ADD BX,2 ADD SI,2 MOV AX,0 LOOP COND JMP FINE NOTT: MOV AX,1 FINE: POP BP _SISTE ENDP END BEGIN TASM um 171 di 175

173 /*Richiede quale delle quattro operazioni si vuole svolgere e richiama l'apposita routine assembler che esegue l'operazione. Ogni routine riceve due dati e restituisce il risultato dell'operazione in AX*/ #include <stdio.h> #include <conio.h> extern int somproc1(int,int); extern int sottr1(int,int); extern int moltip1(int,int); extern int divis1(int,int); int main (void) { int n, a, b; clrscr(); printf ("\nvalore di A= "); scanf ("%d",&a); printf ("\n\nvalore di B = "); scanf ("%d",&b); printf ("\nscelta dell'operazione da svolgere\n\n"); printf ("\n1 - SOMMA\n\n2 - SOTTRAZIONE\n"); printf ("\n3 - MOLTIPLICAZIONE\n\n4 - DIVISIONE\n\n"); printf ("SCELTA N --> "); scanf ("%d",&n); switch (n) { case 1: printf ("\n\nla somma di A e B vale %d\n",somproc1(a,b)); break; case 2: printf ("\n\nla sottrazione A - B vale %d\n",sottr1(a,b)); break; case 3: printf ("\n\nil prodotto tra A e B vale %d\n",moltip1(a,b)); break; case 4: printf ("\n\nil rapporto intero tra A e B vale %d\n",divis1(a,b)); break; default: break; } return (0); } DOSSEG.MODEL SMALL,C.CODE PUBLIC SOMPROC1 SOMPROC1 PROC PUSH BP MOV BP,SP MOV AX,[BP+6] ADD AX,[BP+4] POP BP SOMPROC1 ENDP END DOSSEG.MODEL SMALL,C.CODE PUBLIC SOTTR1 SOTTR1 PROC PUSH BP TASM um 172 di 175

174 MOV BP,SP MOV AX,[BP+4] SUB AX,[BP+6] POP BP SOTTR1 ENDP END DOSSEG.MODEL SMALL,C.CODE PUBLIC MOLTIP1 MOLTIP1 PROC PUSH BP MOV BP,SP MOV AX,[BP+6] MUL WORD PTR [BP+4] POP BP MOLTIP1 ENDP END DOSSEG.MODEL SMALL,C.CODE PUBLIC DIVIS1 DIVIS1 PROC PUSH BP MOV BP,SP PUSH DX MOV DX,0 MOV AX,[BP+4] DIV WORD PTR [BP+6] ;RISULTATO IN AX POP DX POP BP DIVIS1 ENDP END TASM um 173 di 175

175 #include <stdio.h> #include <conio.h> extern unsigned XRAND; extern unsigned RANDOM(void); int main(void) { int i,j;xrand = 23965;clrscr(); for (i=1; i!= 10; ++i) { for (j=1; j!= 5; ++j) printf(" %d\t",random()); printf("\n"); } getch();return(0); } DOSSEG.MODEL SMALL.DATA PUBLIC _XRAND _XRAND DW 0 MULTIP DW 2053 MODULUS DW CODE PUBLIC _RANDOM _RANDOM PROC NEAR PUSH BP MOV BP,SP MOV AX,_XRAND CMP AX,0 JNE GETNXT MOV AH,2CH MOV AX,DX GETNXT: NEG AX MUL MULTIP MOV _XRAND,AX SUB DX,_XRAND JS EXIT INC AX INC AX ADD AX,MODULUS EXIT: POP BP _RANDOM ENDP END TASM um 174 di 175

176 #include <stdio.h> #include <conio.h> extern int StartingValue; extern int DoTotal (void); int Repetitions; int main (void) { int i;clrscr(); Repetitions=10; StartingValue = 2; printf("valore = %d\n", DoTotal()); getch();return (0); } DOSSEG.MODEL SMALL.DATA EXTRN _REPETITIONS:WORD PUBLIC _STARTINGVALUE _STARTINGVALUE DW 0 RUNNINGTOTAL DW?.CODE PUBLIC _DOTOTAL _DOTOTAL PROC ;DEFINITO ESTERNAMENTE ;DISPONIBILE PER ALTRI MODULI MOV CX,[_REPETITIONS] ;# DI CONTEGGI DA ESEGUIRE MOV AX,[_STARTINGVALUE] MOV [RUNNINGTOTAL],AX ;IMPOSTA IL VALORE INIZIALE TOTALLOOP: INC [RUNNINGTOTAL] ;RUNNINGTOTAL++ LOOP TOTALLOOP MOV AX,[RUNNINGTOTAL] ;VALORE DI RITORNO _DOTOTAL ENDP END TASM um 175 di 175

177 UBERTINI MASSIMO Dip. Informatica Industriale I.T.I.S. "Giacomo Fauser" Via Ricci, Novara Italy tel fax