;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
; Synopsis: Affiche une chaîne de caractères se terminant par NULL	;;
; Entree:   SI -> pointe sur la chaîne à afficher					;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
afficheChaine:
	push	eax
	xor		eax, eax
.caractereSuivant:
	lodsb			; ds:esi -> al
	or		al, al	; fin chaine ?
	jz		.fin
	cmp		al, 112
	jne 	.ligneOK
	call retourChariot
	jmp 	.caractereSuivant
.ligneOK:
	call afficheCaractere
	jmp 	.caractereSuivant
.fin:
	pop 	eax
	ret

retourChariot:
	push ax
	xor ah, ah
	mov al, [lignesParCaractere]
	add		word [curseur], ax
	mov		word [curseur + 2], 0
	pop ax
	ret
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; nombreVersChaine													;;
;;------------------------------------------------------------------;;
;; Ecrit dans la chaîne pointée par EDI le nombre contenu dans EAX	;;
;;;; si CL est à un, on écrit un caractère terminal					;;
;; CH contient le nombre minimal de caractères à utiliser			;;
;; EBX contient la base												;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
nombreVersChaine:
	push 	edx
	push 	ecx
	xor		cl, cl
.stocke_digit:
	xor 	edx, edx
	div 	ebx
	push 	edx 			; Sauve le reste dans la pile
	inc 	cl
	or 		eax, eax		; Si le quotient n'est pas nul
	jne 	.stocke_digit	; on recommence
;Les digits sont stockés dans la pile
.ajout_zero:
	cmp 	ch, cl
	jbe		.clearCH
	push 	0				; Identifiant du caractère de remplissage moins 1
	inc 	cl
	jmp 	.ajout_zero
.clearCH:
	xor 	ch, ch
;Affichage du chiffre : On en affiche au moins un : zéro
.affiche_digit:
	pop 	eax
	add 	al, 1			;Transform le chiffre en caractère
	stosb 					; met AL dans l'octet pointé par EDI et incrémente EDI
	loop 	.affiche_digit
	pop 	ecx 			; on récupère le paramètre cx
;	test 	cl, 0b1 		; s'il est à 1, on écrit un caractère terminal
;	jz 		.depile
	mov 	byte [edi], 0
;.depile:
	pop 	edx
ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;	Fin nombreVersChaine											;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; litChaine														;;
;;------------------------------------------------------------------;;
;; Ecrit dans la chaîne pointée par EDI les caractères écrits au 	;;
;; clavier, jusqu'à un retour chariot. 								;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
litChaine:
	push 	eax
	push 	ebx
	push	ecx
	push 	edi	; Sauvegarde d'EDI pour ne pas remonter avant le début de la chaîne

	mov 	byte [derniereTouche], 0
.attend_clavier:
	cmp 	byte [derniereTouche], 0
	jz .attend_clavier
	xor 	eax, eax
	mov 	al, [derniereTouche]
	mov 	byte [derniereTouche], 0

	mov 	ebx, traductionASCII
	add 	ebx, eax
	mov 	al, [ebx] ; Le caractère est dans AL

	cmp 	al, 110			;Traitement de l'espace arrière
	jb .toucheStandard
	je .espaceArriere

	cmp 	al, 111			;Traitement de la tabulation avant
	je	.tab

	cmp 	al, 112
	je .fin_attend_clavier

.toucheStandard:
	test byte[touchesActives + 5], 0b0000100 ;On teste le shift gauche enfoncé
	jnz .shift
	test byte[touchesActives + 6], 0b1000000 ;On teste le shift droit enfoncé
	jz .RAS
.shift:
	cmp al, 114			;On ne stocke pas un Shift gauche comme touche
	je .attend_clavier
	cmp al, 115			;On ne stocke pas un Shift droit comme touche
	je .attend_clavier

	add al, 73
.RAS:
	stosb
	call afficheCaractere
.boucle:
	loop .attend_clavier
.fin_attend_clavier:
	xor 	al, al		;Stocke une fin de chaîne
	stosb
	mov 	al, 51		;Supprime le curseur à la fin de la ligne
	call afficheCaractere
	add		word [curseur], 7
	mov		word [curseur+2], 0
	dec 	edi

.retour:
	pop		ebx
	pop		ecx
	pop 	ebx
	pop 	eax
	ret

.tab:
	mov 	eax, (51<<24)+(51<<16)+(51<<8)+51 ; La tabulation avant est remplacée par 4 espaces dans la chaîne
	stosd
	push	ecx
	mov eax, 51
	mov ecx, 4
.afficheTab:
	call afficheCaractere
	loop .afficheTab
	pop		ecx
	sub ecx, 3
	jle .fin_attend_clavier ; Ca teste si ZeroFlag == 0 & Sign Flag <> Overflow Flag. Comme OF == 0 a priori
	jmp .boucle

.espaceArriere:
	pop eax
	push eax
	cmp eax, edi
	jae .attend_clavier
	dec 	edi
	inc ecx	;On enlève un caractère
	mov al, 51
	call afficheCaractere
	sub		word [curseur+2], 0x10 ; On recule le curseur de 2 caractères
	js	.bordGauche
	jmp .attend_clavier ;Comme si on n'avait rien fait, on recommence

.bordGauche:
	mov		ax, word [XResolution]
	sub 	ax, 8
	mov 	word [curseur+2], ax
	xor		ah, ah
	mov		al, byte [lignesParCaractere]
	sub		word [curseur], ax
	jmp .attend_clavier
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Fin litChaine													;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

afficheRegistreCX:
	pushad
	mov esi, chaine
	mov edi, chaine
	mov eax, ecx
	mov ebx, 16
	mov ecx, 1
	call nombreVersChaine
	call afficheChaine
	popad
	ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; tailleChaineB													;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ECX renvoie la longueur de la chaîne EDI							;;
;; AL est mis à 0													;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
tailleChaineB:
	xor al, al
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; indexChaineB														;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ECX renvoie l'index du caractère AL dans la chaîne EDI			;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
indexChaineB:
	push edi
	or ecx, 0xFFFFFFFF
	repne scasb
	neg ecx
	dec ecx
	pop edi
	ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; tailleChaineD													;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ECX renvoie la longueur de la chaîne EDI							;;
;; EAX est mis à 0													;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
tailleChaineD:
	xor eax, eax
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; indexChaineD														;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; ECX renvoie l'index du caractère EAX dans la chaîne EDI			;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
indexChaineD:
	push edi
	or ecx, 0xFFFFFFFF
	repne scasd
	neg ecx
	dec ecx
	pop edi
	ret

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; conversionASCII													;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
conversionASCII:
	pushad
	mov edi, esi
	or ecx, 0xFFFFFFFF
.convertit:
	lodsb
	cmp al, 0
	je .quitte
	pushfd
	sub al, 'a'-11
	jns .stocke
	add al, 105
.stocke:
	stosb
	popfd
	loopnz .convertit
.quitte:
	stosb
	popad
	ret
