[Assembly] Problema di visualizzazione

[Tamiel Longbeard]

Salve ragazzi, fra di voi c'è un qualche esperto di Assembly? io spero ardente di si ... devo fare un simpatico programmino per l'università che calcola il prodotto di due matrici 2x2, ora il mio programma gira e fa il calcolo corretto ma quando cerco di fargli stampare i risultati mi mostra il carattere ascii associato (o nell'ultima versione addirittura nulla) ho provato a farlo dividere per 10 ma non sembra funzionare ... qualcuno mi può dare una mano magari con un esempio di procedura (anche quella con divisione per dieci va benissimo così magari guardo se ho sbagliato qualcosa) grazie.

[Kenger]

Che ne dici di iniziare mettendo il codice che hai già fatto?

[cionci]

Non ci hai nemmeno detto a quale assembly ti riferisci.

[Tamiel Longbeard]

scusate ma ho scritto il messaggio un po in fretta e si vede ... cmq è un intel 8086 emulato ...smanettando qui e la sono riuscito a far visualizzare al massimo due cifre ... ma dopo mi sbaglia perchè "credo" che mi vada in overflow ax ... in ogni caso ecco il codice che ho scritto fin'ora (tralasciate i commenti che sono scritti piuttosto a caso ...)

TITLE - Calcolo prodotto di matrici (2x2)

;Definizione costanti
HT           	equ     09h    ;tab
LF           	equ     0Ah    ;line feed	
CR           	equ     0Dh    ;carriage return

PAGINA       	equ     00h    ;pagina corrente	
BIOS_VIDEO      equ 	10h
SET_VIDEO_MODE  equ 	00h    ;in AH
MODO_TESTO      equ  	03h    ;in AL
CLEAR		    equ 	06h    ;per usare la funzione del BIOS per pulire lo schermo
DOS         	equ     21h    ;per stampare su video
PRINT_STRING 	equ     09h    ;per stampare una stringa
SET_CURSOR   	equ     02h    ;in AH
R_KEY_CHR    	equ     01h    ;per leggere da tastiera con echo
R_KEY_CHR_NE    equ     07h    ;per leggere da tastiera senza echo
W_CHR_TTY    	equ     0Eh    ;per stampare un carattere a video (in AH)
SCREEN_ROWS     equ 	25     ;lo schermo DOS ha 25 righe
SCREEN_COLS	    equ 	80     ;e 80 colonne
GRAY            equ     07h    ;colore del font 
DECI            equ     10
CENTI           equ     100

;Definizioni variabili
dseg segment para public 'data'
CORSO	     db	   'CORSO DI CALCOLATORI ELETTRONICI A - PROGETTO NUMERO 17$'
TITOLO       db    'Calcolo del prodotto fra matrici 2x2$'
VALMATRICEA  db    CR,LF,'Inserisci i valori della Matrice A: $'
VALMATRICEB  db  CR,LF,CR,LF,'Inserisci i valori della Matrice B: $'
VALMATRICEC  db  CR,LF,CR,LF,'La matrice risultante C risulta: $'
matricea      db 4 dup (?);Definiamo prima un array multidimensionale per la matrice A
matriceb      db 4 dup (?);Definiamo prima un array multidimensionale per la matrice A

num_stampa  db 0
num_due 	     db  0

dseg ends

stackm segment para stack 'stack'
         db 64 dup('12345678')     ;64*8 bytes allocati per lo stack
stackm ends

assume cs:cseg,ds:dseg,ss:stackm

cseg segment para public 'code'

main proc far
             push ds             ;*
             mov ax,00h          ;*da mettere sempre all'inizio dei programmi
             push ax             ;*

             call init   
             call mess_valmatricea	        ;chiediamo di inserire i valori della matrice A
	         call leggi_valmatricea		    	;leggiamo i valori della matrice A
	         call mess_valmatriceb           	;chiediamo di inserire i valori della matrice B
	         call leggi_valmatriceb      		;leggiamo i valori della matrice B
	         call calcola_prodotto             ;calcoliamo (e stampiamo) il prodotto C
         ret
main endp

;PROCEDURE

init proc near
             mov ax, dseg	      ;inizializzo il data-segment	
             mov ds, ax

             mov ah, SET_VIDEO_MODE
             mov al, MODO_TESTO       ;modo testo: schermo 80*25, a colori
             int BIOS_VIDEO

             mov dx, 000Eh            ;imposta riga (DH) e colonna (DL)
             call sposta_cursore      ;alla posizione scelta sopra

	     mov dx, offset CORSO     ;sceglie la stringa CORSO
             call stampa_stringa      ;e la stampa

	     mov dx, 0200h            ;imposta riga (DH) e colonna (DL)
             call sposta_cursore      ;alla posizione scelta sopra

             mov dx, offset TITOLO    ;sceglie la stringa TITOLO
             call stampa_stringa      ;e la stampa

             mov dx, 0400h            ;imposta riga (DH) e colonna (DL)
             call sposta_cursore      ;alla posizione scelta sopra
             ret
init endp

stampa_stringa proc near
               mov ah,PRINT_STRING   ;la stringa è puntata da ds:dx
               int DOS
               ret
stampa_stringa endp

sposta_cursore proc near
               mov bh, PAGINA        ;pagina video attiva
               mov ah, SET_CURSOR    ;set cursor position
               int BIOS_VIDEO
               ret
sposta_cursore endp

mess_valmatricea proc near
             mov dx, offset VALMATRICEA      ;sceglie la stringa di richiesta dei valori della matrice A
             call stampa_stringa      	      ;e la stampa
             ret
mess_valmatricea endp

mess_valmatriceb proc near
             mov dx, offset VALMATRICEB           ;sceglie la stringa PAROLA
             call stampa_stringa       	           ;e la stampa
             ret
mess_valmatriceb endp

mess_valmatricec proc near
             mov dx, offset VALMATRICEC      ;sceglie la stringa di richiesta dei valori della matrice A
             call stampa_stringa      	      ;e la stampa
             ret
mess_valmatricec endp

leggi_valmatricea proc near
           mov dx, 0600h            ;imposta riga (DH) e colonna (DL)
             call sposta_cursore      ;alla posizione scelta sopra
ReadCharLoop:
         mov ah,R_KEY_CHR_NE           ;read keyboard char
             int DOS
	     cmp al,'0'			;se il tasto premuto è minore di 1 non lo ritiene valido.
	     jl ReadCharLoop
	     cmp al,'9'			;se il tasto premuto è maggiore di 9 lo richiede
	     jg ReadCharLoop
         call stampa_num
        mov matricea[0],al  		;metto il carattere letto nella variabile a
	     sub matricea[0],'0'		;conversione da ASCII a decimale	      
           mov dx, 0604h            ;imposta riga (DH) e colonna (DL)
           call sposta_cursore      ;alla posizione scelta sopra
ReadCharLoop2:         
         mov ah,R_KEY_CHR_NE           ;read keyboard char
             int DOS
	     cmp al,'0'			;se il tasto premuto è minore di 1 non lo ritiene valido.
	     jl ReadCharLoop2
	     cmp al,'9'			;se il tasto premuto è maggiore di 9 lo richiede
	     jg ReadCharLoop2
         call stampa_num
             mov matricea[1],al  		;metto il carattere letto nella variabile a
	     sub matricea[1],'0'		;conversione da ASCII a decimale	        
           mov dx, 0700h            ;imposta riga (DH) e colonna (DL)
          call sposta_cursore      ;alla posizione scelta sopra
ReadCharLoop3:           
         mov ah,R_KEY_CHR_NE           ;read keyboard char
             int DOS
	     cmp al,'0'			;se il tasto premuto è minore di 1 non lo ritiene valido.
	     jl ReadCharLoop3
	     cmp al,'9'			;se il tasto premuto è maggiore di 9 lo richiede
	     jg ReadCharLoop3
         call stampa_num         
         mov matricea[2],al  		;metto il carattere letto nella variabile a
	     sub matricea[2],'0'		;conversione da ASCII a decimale	        
         mov dx, 0704h            ;imposta riga (DH) e colonna (DL)
        call sposta_cursore      ;alla posizione scelta sopra
ReadCharLoop4:            
        mov ah,R_KEY_CHR_NE           ;read keyboard char
             int DOS
	     cmp al,'0'			;se il tasto premuto è minore di 1 non lo ritiene valido.
	     jl ReadCharLoop4
	     cmp al,'9'			;se il tasto premuto è maggiore di 9 lo richiede
	     jg ReadCharLoop4
         call stampa_num         
             mov matricea[3],al  		;metto il carattere letto nella variabile a
	     sub matricea[3],'0'		;conversione da ASCII a decimale	        
             ret
leggi_valmatricea endp

leggi_valmatriceb proc near
	          mov dx, 0A00h            ;imposta riga (DH) e colonna (DL)
             call sposta_cursore      ;alla posizione scelta sopra
ReadCharLoopb:
         mov ah,R_KEY_CHR_NE           ;read keyboard char
             int DOS
	     cmp al,'0'			;se il tasto premuto è minore di 1 non lo ritiene valido.
	     jl ReadCharLoopb
	     cmp al,'9'			;se il tasto premuto è maggiore di 9 lo richiede
	     jg ReadCharLoopb
         call stampa_num             
             mov matriceb[0],al  		;metto il carattere letto nella variabile a
	     sub matriceb[0],'0'		;conversione da ASCII a decimale	     
         mov dx, 0A04h            ;imposta riga (DH) e colonna (DL)
        call sposta_cursore      ;alla posizione scelta sopra
ReadCharLoopb2:         
         mov ah,R_KEY_CHR_NE           ;read keyboard char
             int DOS
	     cmp al,'0'			;se il tasto premuto è minore di 1 non lo ritiene valido.
	     jl ReadCharLoopb2
	     cmp al,'9'			;se il tasto premuto è maggiore di 9 lo richiede
	     jg ReadCharLoopb2
         call stampa_num        
        mov matriceb[1],al  		;metto il carattere letto nella variabile a
	     sub matriceb[1],'0'		;conversione da ASCII a decimale	        
        mov dx, 0B00h            ;imposta riga (DH) e colonna (DL)
        call sposta_cursore      ;alla posizione scelta sopra
ReadCharLoopb3:             
         mov ah,R_KEY_CHR_NE           ;read keyboard char
             int DOS
	     cmp al,'0'			;se il tasto premuto è minore di 1 non lo ritiene valido.
	     jl ReadCharLoopb3
	     cmp al,'9'			;se il tasto premuto è maggiore di 9 lo richiede
	     jg ReadCharLoopb3
         call stampa_num         
             mov matriceb[2],al  		;metto il carattere letto nella variabile a
	     sub matriceb[2],'0'		;conversione da ASCII a decimale	        
        mov dx, 0B04h            ;imposta riga (DH) e colonna (DL)
        call sposta_cursore      ;alla posizione scelta sopra
ReadCharLoopb4:             
        mov ah,R_KEY_CHR_NE           ;read keyboard char
             int DOS
	     cmp al,'0'			;se il tasto premuto è minore di 1 non lo ritiene valido.
	     jl ReadCharLoopb4
	     cmp al,'9'			;se il tasto premuto è maggiore di 9 lo richiede
	     jg ReadCharLoopb4
         call stampa_num             
             mov matriceb[3],al  		;metto il carattere letto nella variabile a
	     sub matriceb[3],'0'		;conversione da ASCII a decimale	        
             ret
leggi_valmatriceb endp


calcola_prodotto proc near
             call mess_valmatricec
StartCal:       
             mov dx, 0E00h            ;imposta riga (DH) e colonna (DL)
             call sposta_cursore      ;alla posizione scelta sopra
             mov al,matricea[0]
             mul matriceb[0]
             mov bl,al
             mov al,matricea[1]
             mul matriceb[2]
             add al,bl
	     ;call stampa_num
             call stampa_tre_cifre_uber
             
             mov dx, 0E04h            ;imposta riga (DH) e colonna (DL)
             call sposta_cursore      ;alla posizione scelta sopra
             mov al,matricea[0]
             mul matriceb[1]
             mov bl,al
             mov al,matricea[1]
             mul matriceb[3]
             add al,bl
             call stampa_num
             
             mov dx, 0F00h            ;imposta riga (DH) e colonna (DL)
             call sposta_cursore      ;alla posizione scelta sopra
             mov al,matricea[2]
             mul matriceb[1]
             mov bl,al
             mov al,matricea[3]
             mul matriceb[3]
             add al,bl
             call stampa_num
             
             mov dx, 0F04h            ;imposta riga (DH) e colonna (DL)
             call sposta_cursore      ;alla posizione scelta sopra
             mov al,matricea[2]
             mul matriceb[1]
             mov bl,al
             mov al,matricea[3]
             mul matriceb[3]
             add al,bl
             call stampa_num
ret
calcola_prodotto endp

stampa_num proc near              
              mov ah,W_CHR_TTY
              int BIOS_VIDEO
              ret
stampa_num endp


stampa_tre_cifre_uber proc near
	cmp al,10
	jl  una_cifra
	cmp al,100
	jl due_cifre
	jmp tre_cifre
	
una_cifra:	
	add al,'0'
    call stampa_num
	jmp fine_stampa

due_cifre:
	mov dl,DECI
	idiv dl
	
	push ax
	
	add al,'0'
    call stampa_num
	
	pop ax
	
	mov al,ah
	add al,'0'
    call stampa_num
    
	jmp fine_stampa

tre_cifre:
    mov dl, CENTI
    idiv dl
    
    push ax
     
    add al,'0'
    call stampa_num
    
    pop ax
    mov al,ah
    jmp due_cifre    
    
fine_stampa:
ret
stampa_tre_cifre_uber endp

cseg ends

end main

Lo so come codice non è un granchè però se potete darmi una mano mi fate un favore ...

[gugoXX]

Vuoi un trucco?
Scrivilo in C, compilalo su un C vecchio per DOS (Come TurboC 2.0), disassembly e vedi cosa ti propone lui quando raggiunge il punto in cui deve stampare l'output.

[banryu79]

Originariamente inviato da gugoXX

Vuoi un trucco?
Scrivilo in C, compilalo su un C vecchio per DOS (Come TurboC 2.0), disassembly e vedi cosa ti propone lui quando raggiunge il punto in cui deve stampare l'output.

Vecchia volpe