LECTURE DE DISQUETTE

dosseg
model small
.stack
.data

       public secteur

       	entete1 db 'Disque:',0
	entete2 db 'Piste:',0
	entete3 db 'Secteur:',0
	entete4 db 'Tete:',0
	entete5 db 'menu2.exe  programmer par Eric Gagnon',0

	disque	db 'A',0
	piste 	db '5',0
	sector db '3',0
	tete 	db '0',0

	bs equ 08; backspace
	escape equ 1b; sortir


	CR EQU 13; CARRACTERE QUI REVIENT AU DEBUT DE LA LIGNE
	LF EQU 10; CHANGE DE LIGNE	
	num db  00h,01h,02h,03h,04h,05h,06h,07h,08h,09h,0Ah,0Bh,0Ch,0Dh,0Eh,0Fh
	toprow db 0c9h, 12 dup(0cdh), 0cbh, 11 dup(0cdh), 0cbh,11 dup(0cdh),0cbh,12 dup(0cdh),0bbh,0c9h,16 dup(0cdh),0bbh
	
	secteur db 512 dup (?)

	buttrow db 0c8h,12 dup(0cdh),0cah,11 dup(0cdh),0cah,11 dup(0cdh),0cah,12 dup(0cdh),0bch,0c8h,16 dup(0cdh),0bch
	tichiffre db '0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'
	
	curseur_fantome_x db 00
	curseur_fantome_y db 00
	vrai_curseur_x db 00
	vrai_curseur_y db 00
	
	dispatch_table	db 48h
			dw offset fantome_haut;dw offset_text: fantome_haut
			db 50h
			dw offset fantome_bas
			db 4bh
			dw offset fantome_gauche
			db 77
			dw offset fantome_droit
			db 0;fin du dispatch
	
	keyboard_input label byte
		char_num_limit db 0; va etre setter a 2 pour notre programme
		num_char_read db 0
		char db 80 dup (0)
		;cr equ 13; carriage return CRLR
		


	
	
	
.code
main proc
	xor bx,bx
	mov dx,0000h
	call gotoxy
	call clear
	mov ax,dgroup; place laddresse du segment de donnee dans ax
	mov ds,ax; fait pointer ds au datastack
	mov es,ax
	call readdisk
	xor bx,bx; initialise BX a 0
	lea di,num
	call clear
	call afficheligne1
	call CRLF
	call CRLF
	mov cx,16
	mov dl,' '
	call ecrire_char
	call ecrire_char
	call ecrire_char
	call ecrire_char

numbertop:
	
	mov dl,num[bx]
	call ecrire_hex
	mov dl,' '
	call ecrire_char
	inc bx
	loop numbertop
	mov cx,16
	xor bx,bx
	mov dl,' '
	call ecrire_char
	call ecrire_char
chiffre:
	mov dl,tichiffre[bx]
	call ecrire_char
	inc bx
	loop chiffre
	
	call CRLF
	mov cx,69
	
	mov dl,' '
	call ecrire_char
	call ecrire_char
	xor bx,bx
toprows:
	
	mov dl,toprow[bx]
	call ecrire_char
	inc bx
	loop toprows
	
	call CRLF
	mov cx,16
	xor bx,bx

bouclette1:
	mov dl,[di]
	call ecrire_hex
	inc di
	mov dl,0bah
	call ecrire_char
	call donne
	mov dl,0bah
	call ecrire_char
	call ecrire_char
	call donne2
	mov dl,0bah
	call ecrire_char
	call CRLF
	loop bouclette1
	
	xor bx,bx
	mov cx,69
	mov dl,' '
	call ecrire_char
	call ecrire_char
buttrows:
	
	mov dl,buttrow[bx]
	call ecrire_char
	inc bx
	loop buttrows
	
	call affiche_curseur_fantome
	call dispatcher
	call writedisk
	
	mov ah,4ch
	int 21h
	
	
;------------------------------------------------------------------------------------------------	

donne proc
	push cx
	mov cx,16
	mov dl,' '
	call ecrire_char

bouclette2:	
	mov dl,secteur[bx]
	call ecrire_hex
        mov dl,' '
	call ecrire_char
	inc bx
	loop bouclette2
	
	pop cx
	ret
donne endp

;-------------------------------------------------------------------------------------------------
donne2 proc
	push cx
	push bx
	mov cx,16
	
	
bouclette3:
	mov dl,secteur[bx-16]
	call ecrire_char
	inc bx
	loop bouclette3
	
	pop bx
	pop cx
	ret
donne2 endp

	



;------------------------------------------------------------------------
;procedure pour ecrire un caractere ou ecrire un hexadecimal
ecrire_hex proc
	push cx
	push dx
	mov dh,dl
	mov cx,4
	shr dl,cl
	call ecrire_nombre_hex
	mov dl,dh
	and dl,0fh
	call ecrire_nombre_hex
	pop dx
	pop cx
	ret
ecrire_hex endp

	public ecrire_nombre_hex

ecrire_nombre_hex proc

	push dx
	cmp dl,10
	jae lettre_hex
	add dl,"0"
	jmp affiche_nombre
lettre_hex:
	add dl,"A"-10
affiche_nombre:
	call ecrire_char
	pop dx
	ret
ecrire_nombre_hex endp


	public ecrire_char

ecrire_char proc

	push ax
	mov ah,02
	cmp dl,09
	je point
	cmp dl,08
	je point
	cmp dl,07
	je point
	cmp dl,06
	je point
	cmp dl,13
	je point
	cmp dl,10
	jne print
point:
	mov dl,2eh
print:	
	int 21h
	pop ax
	ret
ecrire_char endp

;-----------------------------------------------------------------------------------------
;fonction pour passer a la ligne suivante
CRLF proc
	push AX
	PUSH DX
	MOV AH,02H
	MOV DL,CR
	INT 21H
	MOV DL,LF
	INT 21H
	POP DX
	POP AX
	RET
CRLF ENDP
;-----------------------------------------------------------------------------------------
;fonction pour lire sur le drive a:
readdisk proc

	mov ah,02h
	mov al,01;	mov al,01
	lea bx,secteur
	mov ch,05h; 	mov ch,05
	mov cl,03;	mov cl,03
	mov dh,00
	mov dl,00h ; 00h = drive A      80h = drive c:
	int 13h
	ret

readdisk endp	
	
;-----------------------------------------------------------------------------------------
writedisk proc

	mov ah,03h
	mov al,01;	mov al,01
	lea bx,secteur
	mov ch,05h; 	mov ch,05
	mov cl,03;	mov cl,03
	mov dh,00
	mov dl,00h ; 00h = drive A      80h = drive c:
	int 13h
	ret

writedisk endp	
;-------------------------------------------------------------------------------------------
;fonction pour afficher une chaine de caractere
ecrire_chaine proc
	push ax
	push bx
	push si
	pushF
	cld  ; set direction flag pour compter en augmentant
	mov si,dx ; place l'adresse de la chaine dans si
loop_chaine:
	lodsb ; load string byte - place le contenu de la byte a l'adresse pointe par si dans al
	or al,al ; pour savoir si on a trouver le 0
	jz fin_de_chaine ; oui va a  la fin de la chaine
	mov dl,al	;non, affiche le caractere
	call ecrire_char
	jmp loop_chaine
fin_de_chaine:
	popF
	pop si
	pop DX
	pop AX
	ret
ecrire_chaine endp
;-------------------------------------------------------------------------------------------
;fonction qui affiche les entetes
afficheligne1 proc
	lea dx,entete1
	call ecrire_chaine
	lea dx,disque
	call ecrire_chaine
	mov dx,' '
	call ecrire_char
	lea dx,entete2
	call ecrire_chaine
	lea dx,piste
	call ecrire_chaine
	mov dx,' '
	call ecrire_char
	lea dx,entete3
	call ecrire_chaine
	lea dx,sector
	call ecrire_chaine
	mov dx,' '
	call ecrire_char
	lea dx,entete4
	call ecrire_chaine
	lea dx,tete
	call ecrire_chaine
	mov dx,' '
	call ecrire_char
	call ecrire_char
	call ecrire_char
	call ecrire_char
	call ecrire_char
	lea dx,entete5
	call ecrire_chaine
	ret
afficheligne1 endp
;------------------------------------------------------------------------------------------------
;cette fonction clear tous ce qu il a a lecran
clear proc
	push ax
	push bx
	push cx
	push dx
	mov ah,0bh
	mov bh,05h  ;  couleur du background + foreground   02 au depart
	mov cx,0000h
	mov dx,404fh
	int 10h
	pop dx
	pop cx
	pop bx
	pop ax
	ret
clear endp

;-------------------------------------------------------------------------------------------------
;x = dh,   y = dl

gotoxy proc
	push ax
	push bx
	mov ah,02h
	mov bh,00
	int 10h
	pop bx
	pop ax
	ret
gotoxy endp
;-------------------------------------------------------------------------------------------------
; cx = nombre de caractere   dl = nouvelle attribu

ecrire_attribu_n_fois proc
	push ax
	push bx
	push cx ;!
	push dx
	mov bl,dl
	xor  bh,bh
	mov dx,cx ; mov dx,cx
	
boucle_attr:
	mov cx,1
	mov ah,08;lire le caractere sous le curseur
	int 10h
	mov ah,09;ecrire le caractere avec sa nouvelle attribu
	int 10h
	call curseur_droit
	dec dx
	jnz boucle_attr
	pop dx
	pop cx
	pop bx
	pop ax
	ret
ecrire_attribu_n_fois endp
;-----------------------------------------------------------------------------------------
curseur_droit proc
	push ax
	push bx
	push cx
	push dx
	mov ah,03h
	mov bh,00
	int 10h
	inc dl
	call gotoxy
	pop dx
	pop cx
	pop bx
	pop ax
	ret
	
curseur_droit endp
;------------------------------------------------------------------------------------------	
move_to_hex_position proc
	push ax
	push cx
	push dx
	xor ah,ah
	mov dh,2;ranger au dessus du display
	add dh,02
	add dh,curseur_fantome_y
	mov dl,04;colonne  a gauche du display
	mov cl,03 ; 3 car chaque valeur est compose de 3 caracteur
	mov al,curseur_fantome_x
	mul cl
	add dl,al
	call gotoxy
	pop dx
	pop cx
	pop ax
	ret
move_to_hex_position endp
;------------------------------------------------------------------------------------------	
move_to_ascii_position proc
	push ax
	push dx
	mov dh,02;ranger au dessus du display
	add dh,02
	add dh,curseur_fantome_y
	mov dl,54 ; 59 peut varier
	add dl,curseur_fantome_x
	call gotoxy
	pop dx
	pop ax
	ret
move_to_ascii_position endp
;------------------------------------------------------------------------------------------
save_real_cursor proc
	push ax
	push bx
	push cx
	push dx
	mov ah,03; read cursor position
	xor bh,bh
	int 10h; retourne ydans dl et x dans dh
	mov vrai_curseur_x,dh
	mov vrai_curseur_y,dl
	pop dx
	pop cx
	pop bx
	pop ax
	ret
save_real_cursor endp
;------------------------------------------------------------------------------------------
restore_real_cursor proc
	push dx
	mov dl,vrai_curseur_y
	mov dh,vrai_curseur_x
	call gotoxy
	pop dx
	ret
restore_real_cursor endp
;------------------------------------------------------------------------------------------


affiche_curseur_fantome proc
	push ax
	push bx	
	push cx
	push dx
	call save_real_cursor
	call move_to_hex_position
	mov cx,3; curseur fantome 3 caractere de large
	mov dl,70h	;video inverse
	call ecrire_attribu_n_fois
	call move_to_ascii_position
	mov cx,1
	call ecrire_attribu_n_fois
	call restore_real_cursor
	pop dx
	pop cx
	pop bx
	pop ax
	ret
affiche_curseur_fantome endp



;------------------------------------------------------------------------------------------
efface_curseur_fantome proc
	
	push cx
	push dx
	call save_real_cursor
	call move_to_hex_position
	mov cx,3; curseur fantome 3 caractere de large
	mov dl,02	;video normale
	call ecrire_attribu_n_fois
	call move_to_ascii_position
	mov cx,01
	mov dl,02
	call ecrire_attribu_n_fois
	call restore_real_cursor
	pop dx
	pop cx
	ret
efface_curseur_fantome endp
;------------------------------------------------------------------------------------------
;==========================================================================================
;control procedure

;input proc
;	push ax
;	push bx
;	push cx
;	push dx
;masterboucle:
;	mov ah,10h
;	int 16h
;	cmp ah,48h ;touche haut??
;	je fantome_haut 
;
;	cmp ah,50h; touche bas??
;	je fantome_bas
;
;	cmp ah,4bh
;	je fantome_gauche ; touche gasuche???
;
;	cmp ah,4dh
;	je fantome_droit ; touche droite ???
;
;	cmp ah,1b
;	je exit ; touche esc???


fantome_haut	proc
	call efface_curseur_fantome
	dec curseur_fantome_y
	jns plusgrand
	mov curseur_fantome_y,15
plusgrand:
	call affiche_curseur_fantome
	;jmp masterboucle
	ret
fantome_haut endp

fantome_bas	proc
	call efface_curseur_fantome
	inc curseur_fantome_y
	cmp curseur_fantome_y,16
	jl plusgrand2
	;mov sector_offset,16
	call touteafficherbas
	call efface_curseur_fantome
	mov curseur_fantome_y,0
plusgrand2:
	call affiche_curseur_fantome
	;jmp masterboucle
	ret
fantome_bas endp

fantome_gauche proc
	call efface_curseur_fantome
	dec curseur_fantome_x
	jns plusgrand3
	mov curseur_fantome_x,15
plusgrand3:
	call affiche_curseur_fantome
	;jmp masterboucle
	ret
fantome_gauche endp

fantome_droit	proc
	call efface_curseur_fantome
	inc curseur_fantome_x
	cmp curseur_fantome_x,16
	jl plusgrand4
	mov curseur_fantome_x,0
plusgrand4:
	call affiche_curseur_fantome
	;jmp masterboucle
	ret
fantome_droit endp
;exit:	
;	push dx
;	push cx
;	push bx
;	push ax
;	ret
;input endp

;==========================================================================================	
;cette fonction lit un caractere ascii en retourne dans ALle code du caractere sauf si
;AH est = 1
;AH = 0 si caractere ascii
;AH = 1 si clef etendue
readbyte proc
	xor ah,ah
	int 16h
	or al,al; est-ce un caractere etendue?
	jz caractere_etendue1
non_etendu:
	xor ah,ah;retourne seulement le code ascii

findelecture:
	ret
caractere_etendue1:
	mov al,ah
	mov ah,01
	jmp findelecture
readbyte endp
;------------------------------------------------------------------------------------------
dispatcher proc
	push ax
	push bx
dispatch_loop:
	
	call lire
	or ah,ah
	js dispatch_loop
	jnz clef_etendue
	;si caractere ascii pour linstant on fait rien avec
	;si le caractere lue n'est pas une clef speciale
	mov dl,al
	call edit_byte
clef_etendue:
	cmp al,68; clef de sortie  1b = esc   ou 68 = f10
	je fin
	lea bx,dispatch_table
boucle_recherche:
	cmp byte ptr[bx],0 ;fin de table
	je pas_dans_la_table
	cmp al,[bx] ; est-cette entre de la table?
	je dispatch ; fait appelle a la fonction
	add bx,03 ; non? try the other one!!
	jmp boucle_recherche
dispatch:
	inc bx; pointe a ladresse de la procedure
	call word ptr[bx]; fait appelle a la bonne proc
	jmp dispatch_loop
pas_dans_la_table:
	jmp dispatch_loop
fin:
	pop bx
	pop ax
	ret

dispatcher endp


;=========================================================================


;----------------------------------------------------------------------------------------
read_string proc
	;	extrn ecrire_char proc
	;ds:dx addresse du keyboard buffer
	;retourne 0  si pas de caractere lu
	;retourne -1 si caractere special
	;retourne le nombre de caractere lu
	push ax
	push bx
	push si
	mov si,dx ; utilise "si" comme index

 start:
	mov bx,02; bx soit le offset qui pointe le debut du buffer
	call readbyte	; lire une clef du keyboard
	or ah,ah ;est-ce un caractere etendu???  
	jnz caractere_etendu

chaine_non_etendue:
	cmp al,cr	; carriage return??
	je fin_input
	cmp al,bs
	jne pas_bs
	call backspace
	cmp bl,02 ; est-ce que le buffer est vide?
	je start
	jmp lire_caractere_suivant

pas_bs:
	cmp al,escape
	je efface_buffer
	cmp bl,[si] ;verifier si le buffer est plein
	ja bufferplein; jump above
	mov [si+bx],al ; mov [si+bx]mettre le caractere dans le buffer
	inc bx ; bx pointe au prochain caractere

;affiche le caractere a lecran
	push dx
	mov dl,al
	call ecrire_char
	pop dx
	
lire_caractere_suivant:
	call readbyte
	or ah,ah;un caractere etendu n'est pas acceptable si le buffer n'est pas vide
	jz chaine_non_etendue
	;signale une erreur en emmetant un beep sonore au display (chr$(7))

signale_erreur:
	push dx
	mov dl,07
	mov ah,02
	int 21h
	pop dx
	jmp lire_caractere_suivant

efface_buffer:
	push cx
	mov cl,[si];recule le nombremax de caractere
	xor ch,ch

boucle_efface:
	call backspace
	loop boucle_efface
	
	pop cx
	jmp start

bufferplein:
	jmp signale_erreur

caractere_etendu:
	mov [si+2],al;place le caractere dans le buffer
	mov bl,0ffh;nombre de caractgere lue = -1(caractere etendue)
	jmp fin_chaine

fin_input:
	sub bl,02
fin_chaine:
	mov [si+1],bl
	pop si
	pop bx
	pop ax
	ret
read_string endp

;------------------------------------------------------------------------------------------
backspace proc
	push ax
	push dx
	cmp bx,02
	je end_bs
	dec bx
	mov dl,bs
	mov ah,02
	int 21h
	mov dl,20h;blank espace
	int 21h
	call fantome_gauche
end_bs:
	pop dx
	pop ax
	ret
backspace endp
;--------------------------------------------------------------------------------------------
;public lire
;lire un caractere ascii ou un nombre hex
;retourne al code du caractere (amoin que ah=0)
;ah=0 si caractere ascii ou nombre hex
;ah=1 si clef special
;ah=-1 si pas rien lu


lire proc 
	push dx
	mov char_num_limit,2 ; mov char_num_limit,3
	lea dx,keyboard_input
	call read_string
	cmp num_char_read,1
	je ascii_input
	jb pas_de_caractere ; jump below
	cmp byte ptr num_char_read,0ffh ; clef special
	je clef_special
	;ajouter code pour traiter nombre hex
pas_de_caractere:
	xor ah,ah
	not ah
	jmp fin2

ascii_input:
	mov al,char
	xor ah,ah
	jmp fin2
	clef_special:
	mov al,char[0]	
	mov ah,1
fin2:
	pop dx
	ret


lire endp
;===============================================================================
edit_byte proc
	push dx
	call save_real_cursor
	call move_to_hex_position
	;call curseur_droit
	call ecrire_hex
        call move_to_ascii_position
	call ecrire_char
	call restore_real_cursor
        call affiche_curseur_fantome
	call ecrire_en_memoire
	pop dx
	ret
edit_byte endp
;-----------------------------------------------------------------------------------
ecrire_en_memoire proc
	push ax
	push bx
	push cx
	lea bx,secteur
	mov al,curseur_fantome_y
	xor ah,ah
	mov cl,04
	shl ax,cl
	add bx,ax
	mov al,curseur_fantome_x
	xor ah,ah
	add bx,ax
	mov secteur[bx-161],dl;mov secteur[bx-161]
	pop cx
	pop bx
	pop ax
	ret
ecrire_en_memoire endp
;-------------------------------------------------------------------------------------
scrolldown proc
	push dx
	call efface_curseur_fantome
	call save_real_cursor
	xor dl,dl
	mov dh,00;lines_before_sector
	add dh,02
	call gotoxy
	mov bx,256
	call CRLf
	call touteafficherbas
	;mov sector_offset,dx
	call donne
	call donne2
	call restore_real_cursor
	mov curseur_fantome_y,0
	call affiche_curseur_fantome
	pop dx
	ret
scrolldown endp	

;---------------------------------------------------------------------------------------
touteafficherbas proc
	
	mov dx,0000h
	call gotoxy
	call clear
	mov ax,dgroup; place laddresse du segment de donnee dans ax
	mov ds,ax; fait pointer ds au datastack
	mov es,ax

	call readdisk
	xor bx,bx; initialise BX a 0
	lea di,num
	call clear
	call afficheligne1
	call CRLF
	call CRLF
	mov cx,16
	mov dl,' '
	call ecrire_char
	call ecrire_char
	call ecrire_char
	call ecrire_char

numbertop2:
	
	mov dl,num[bx]
	call ecrire_hex
	mov dl,' '
	call ecrire_char
	inc bx
	loop numbertop2
	mov cx,16
	xor bx,bx
	mov dl,' '
	call ecrire_char
	call ecrire_char
chiffre2:
	mov dl,tichiffre[bx]
	call ecrire_char
	inc bx
	loop chiffre2
	
	call CRLF
	mov cx,69
	
	mov dl,' '
	call ecrire_char
	call ecrire_char
	xor bx,bx
toprows2:
	
	mov dl,toprow[bx]
	call ecrire_char
	inc bx
	loop toprows2
	
	call CRLF
	mov cx,16
	mov bx,256;256

bouclette12:
	mov dl,[di]
	call ecrire_hex
	inc di
	mov dl,0bah
	call ecrire_char
	call donne
	mov dl,0bah
	call ecrire_char
	call ecrire_char
	call donne2
	mov dl,0bah
	call ecrire_char
	call CRLF
	loop bouclette12
	
	mov bx,00;xor bx,bx
	mov cx,69
	mov dl,' '
	call ecrire_char
	call ecrire_char
	xor bx,bx
buttrows2:
	
	mov dl,buttrow[bx]
	call ecrire_char
	inc bx
	loop buttrows2
	
	call affiche_curseur_fantome
	ret

touteafficherbas endp
;----------------------------------------------------------------------------

main endp
end


;program by Eric Gagnon
;INFO2003
;02/04