; Pour afficher directement a l'ecran en mode 32 bits (mode protege)
;
;       Auteur: Benoit Papillault
;       Creation: Lundi 23 Juin 1997
;       Derniere modification: Mercredi 25 Juin 1997

;       Historique:

;       25/06/1997: ajout de la fonction crlf32 pour passer a la ligne

include print32.inc
include selector.inc

MEM_VIDEO32       equ     0b8000h
LARGEUR_ECRAN   equ     80
HAUTEUR_ECRAN   equ     25
ATTRIBUTS       equ     03h

.386

seg_zero        segment at 0
        org     MEM_VIDEO32
ecran   label byte
seg_zero        ends
        
_DATA   segment public 'DATA'
_x32    dw      0
_y32    dw      10


str32   db 'Hello from the 32 bits World!',0

_DATA   ends

code32  segment para public  use32
        assume  cs:code32

; pour imprimer juste un seul caractere mis dans le registre al
; mets a jour les variables _x32 et _y32

print_car32     proc near
        push    ebp
        mov     ebp,esp

        push    eax
        push    ebx
        push    ecx
        push    ds
        push    es

; on sauve al dans cl
        mov     cl,al
        mov     ax,fdata_sel
        mov     es,ax
        assume  es:seg_zero

        mov     ax,data32_sel
        mov     ds,ax
        assume  ds:_DATA

        cmp     cl,10   ; retour chariot
        je      short retour_chariot
        mov     ax,_y32
        mov     bl,LARGEUR_ECRAN
        mul     bl      ; ax = al * bl
        add     ax,_x32
        add     ax,ax   ; chaque caractere occupe deux octets en memoire video
        xor     ebx,ebx
        mov     bx,ax
        mov     ecran[ebx][0],cl
        mov     ecran[ebx][1],ATTRIBUTS
        inc     _x32               ;  !!!!!!!! on ne peut pas ecrire
                                   ;  !!!!!!!! dans le segment de code
        cmp     _x32,LARGEUR_ECRAN
        jl      short print_car32_end

retour_chariot:
        mov     _x32,0
        inc     _y32
        cmp     _y32,HAUTEUR_ECRAN
        jl      short print_car32_end
        mov     _y32,0

print_car32_end:
        pop     es
        pop     ds
        pop     ecx
        pop     ebx
        pop     eax
        assume  ds:nothing
        assume  es:nothing

        pop     ebp
        ret
print_car32     endp

; pour imprimer un retour chariot
; ne prend aucun parametre, ne modifie pas de registre

crlf32  proc near
        push    eax
        mov     al,10
        call    print_car32
        pop     eax
        ret
crlf32  endp

; pour imprimer une chaine de caractere a partir de la position courante
; a declarer en C avec void print_st32(const char *s)
; l'offset 32 bits de la chaine dans _DATA (data32_sel)

        public  _print_st32

_print_st32        proc near
; code d'entree d'une fonction C
        push    ebp
        mov     ebp,esp

; sauvegarde des registres utilises
        push    ds
        push    eax
        push    esi

        mov     ax,data32_sel
        mov     ds,ax
        mov     esi,[ebp+8]

; on examine les caracteres un par un
boucle_st32:
        mov     al,ds:[esi]
        inc     si
        cmp     al,0
        je      short fin_st32
        call    print_car32
        jmp     short boucle_st32

fin_st32:

; restauration des registres utilises
        pop     esi
        pop     eax
        pop     ds

; code de sortie d'une fonction C
        pop     ebp
        ret
_print_st32        endp

; imprime un octet (passe dans le registre al)

        public  _print_al32

_print_al32     proc near
        push    ebp
        mov     ebp,esp

        push    ax
        push    cx

        mov     cl,al   ; on sauvegarde
                        ; on affiche les bits de poids forts en premier
        shr     al,4
        cmp     al,10
        jl      short print_al32_ok
        add     al,7
print_al32_ok:
        add     al,'0'
        call    print_car32

        mov     al,cl
        and     al,0fh
        cmp     al,10
        jl      short print_al32_ok2
        add     al,7
print_al32_ok2:
        add     al,'0'
        call    print_car32

        pop     cx
        pop     ax

        pop     ebp
        ret
_print_al32     endp

        public  _print_ax32

_print_ax32     proc near
        push    ebp
        mov     ebp,esp

        xchg    ah,al
        call    _print_al32
        xchg    ah,al
        call    _print_al32

        pop     ebp
        ret
_print_ax32     endp

        public  _print_eax32

_print_eax32    proc near
        push    ebp
        mov     ebp,esp

        ror     eax,16
        call    _print_ax32
        ror     eax,16
        call    _print_ax32

        pop     ebp
        ret
_print_eax32    endp

        public  test_asm32

test_asm32       proc near
        push    ebp
        mov     ebp,esp

        push    eax
        push    ebx

        mov     eax,0fafbfcfdh
        call    _print_al32
        call    _print_ax32
        call    _print_eax32

        mov     al,10
        call    print_car32

        mov     eax,offset str32
        call    _print_eax32

        push    eax
        mov     al,10
        call    print_car32
        call    _print_st32
        pop     eax

        mov     al,10
        call    print_car32

        pop     ebx
        pop     eax

        pop     ebp
        ret
test_asm32       endp

code32  ends
        end