%include "asm_io.inc"
	
SECTION .data

 msg:	        db      "Message en minuscules?",10,0
 min:           db      'a'             ; code ascii de a
 maj:           db      'A'             ; code ascii de A
 blanc:         db      ' '             ; code ascii de l'espace

SECTION .bss

 msg_min:       resb    100             ; espace réservé pour lire la chaine en minuscules au clavier
 msg_maj:       resb    100             ; espace réservé pour sauvegarder la chaine en majuscules
 lg:	        resd    1               ; longueur
 moins:	        resd    1               ; décalage

SECTION .text		   	 
	global main	    
	
main:
        ;; calcul du nombre à retirer
        mov     eax, [min]              ; eax <- le code ascii de a
        sub     eax, [maj               ; eax <- eax - le code ascii de A
        mov     [moins],eax             ; [moins] <- la valeur qu'il faut retrancher 
                                        ; à une lettre minuscule pour la transformer en majuscule

	;; récupération du message
	mov 	eax, msg
	call	print_string

	push 	msg_min                 ; 1er argument: adresse de la chaine à lire
	push 	lg                      ; 2ème argument: adresse de la longueur à sauvegarder
	call	read_string             ; appel de la fonction read_string
	add 	esp, 8                  ; dépilement des paramètres

	
	;; mise en MAJUSCULES
	mov     ebx, 0			; i: compteur, les tableaux commencent a zéro 
nxt:	mov     al, [msg_min+ebx]       ; al <- la i-ème lettre de la chaine msg_min  
	cmp     al, [blanc]             ; on vérifie si c'est un espace... 
	je      espace	                ; un espace ne doit pas être transformé en majuscule
	sub 	al, [moins]             ; sinon, on retranche le décalage permettant de transformer en majuscule
espace:	mov 	[msg_maj+ebx], al       ; dans tous les cas, le code ascii obtenu est copié à la i-ème position de msg_maj
	inc     ebx                     ; i++
	cmp     ebx, [lg]        	; boucle tant que i<lg
	jne  	nxt			;
	mov 	byte [msg_maj+ebx], 0   ; on n'oublie pas le zéro final

        ;; affichage de la chaine en majuscules
	mov 	eax, msg_maj
	call	print_string
	
	call 	print_nl
	
fin:	mov	ebx, 0		
	mov	eax, 1		
	int	0x80

;; fonction permettant de lire une chaine de caractères au clavier
;; arguments: 
;;  - adresse (pointeur) de la chaine que l'on sauvegarde (avec suffisamment d'espace réservé)
;;  - adresse (pointeur) d'un dword pour sauvegarder la longueur de la chaine.
;; aucun registre modifié
read_string:
	push 	ebp                     ; sauvegarde de l'ancienne base de la pile
	mov	ebp, esp

	pusha                           ; sauvegarde de tous les registres généraux sur la pile 
	
	mov 	edx, [ebp+12]           ; adresse de la chaine
	mov 	ecx, 99			; 100-1, pour le 0 final
	mov 	ebx, 0                  ; compteur
nxt_rs:	call 	read_char               ; boucle de lecture des caractères
	mov	[edx+ebx], al           ; sauvegarde du caractère lu à la position donnée
	                                ; par le compteur dans la chaine de destination
	inc 	ebx                     ; compteur++
	cmp 	al, 10                  ; la boucle s'arrête quand le caractère lu est un "retour à la ligne"
	loopne 	nxt_rs
	
	mov	byte [edx+ebx], 0       ; ne pas oublier de terminer la chaine par 0	
 
 	dec 	ebx                     ; compteur-- (on ne compte pas le zéro dans la longueur de la chaine)
	mov	edx, [ebp+8]            ; on place l'adresse à laquelle on veut sauvegarder la longueur dans un registre
	mov 	[edx], ebx              ; et on sauvegarde la longueur à cette adresse
	
	popa                            ; restauration des registre à leur état d'origine
	
fin_read_string:
	pop	ebp                     ; rétablissement de l'ancienne base de la pile
	ret

	