salut a ts
 
voila je me pose certaine questions sur la memmoire  
 
par ex qd on declare un variable ds un prog , qu'es-ce qui se passe qd le prog se termine ? la var reste ds la mem ou est elle est supp ?    
 
je crois que normalement le compilo tourne en mode reel , mais un 1mo de mem sa fait pas un peu limite ? comment on peu passer en mode protégé ? et quelle changement sa apporte sur la prog ?
deplus j'ai des ptit pb avec les macro , j'ai fait une macro avec des  
 
variables locales mais apres un certain nb d'appel de cette macro j'ai des pb avec la mem .  pk es-ce que cette macro a utilisé de la mem alors que les variables étaient locales ? comment faire pr evité sa ?  
 
merci d'avance  
@+

fait un petit effort de rédaction, et on en fera l'effort de t'expliquer.

- mode reel au boot, puis mode protege au chargement de l'OS
- lit la doc d'intel (procédure + ce qui change), utilise google
- quelle macro ? on n'est pas devins...
- de rien

Bjone je suis desolé pour l'orthographe  
HelloWorld , voila la macro dont je parlais
 
Selection_son macro val_selection?,frequence?,msg?
local non, boucle, msg, boucle2
 
code segment use16
 
pusha
 
        cmp selec, val_selection?
        jne non
        Son frequence?
 
         ; on efface la ligne pr qu'il n'y est pas de merde qui traine
         Def_pos_curseur 0 11
  Ecrire_plusieurs_fois_caractere ' ' 80
         ; puis on affiche le msg info
  ; calcul de la taille de la chaine
  xor di, di
         boucle2:
                 inc di  
         cmp msg+di, '$'
         jne boucle2
         ; puis de la pos du msg en fonction de sa taille
         mov ax, 80
         sub ax, di
         shr ax, 1
         sub ax, 6
         ; et on affiche le tt
         Def_pos_curseur al 11
         Ecrire_offset_chaine_couleur <offset msg> 0Bh
         Ecrire_nb frequence?
         Ecrire_chaine <" htz">
 
 non:
 
popa
 
code ends
 
data segment use16
 
 msg db msg?,'$'
 
data ends

Va falloir attendre Harko.

Alors,
 
Il faut savoir que l'allocation mémoire (si on peut appeler ça comme ça) style  

ne réserve pas 200 octets de mémoire, mais place 200 "blancs" dans le header du programme. En gros, ces octets existent dans ton programme, tu n'as pas à les libérer.
 
Donc si tu déclares tes variables comme ceci, il ne s'agit pas du tout d'allocation mémoire. Ca fait éventuellement grossir ton exécutable (si tes db réservent des données initialisées).
 
Ensuite, que contiennent les fonctions Ecrire_xxx en fin de macro ? Là encore, on n'est pas devins...
 
Si tu tiens à coder en 16 bits sous DOS, le mieux est d'utiliser les fonctions 48h, 49h et 4Ah de l'interruption 21h du DOS (allocation, libération et réallocation de mémoire)

=======>   Ecrire_nb
 
 
Ecrire_nb macro nb?,groupement_chiffres?
local boucle,boucle2,fin,non,non2,non_param1,non_param2,non_param3,non_param4,param2
 
code segment use16
 
pushf
pusha
 
 ; si le 2eme param est != 0 , on va se servir de di donc
 cmp param2,1
 jne non_param1
 ; on le met a 0
 xor di, di
 non_param1:
 ; transferer le param ds ax  
 mov ax, nb?
 
 ; mettre un repere ds la pile
 push 10
 
 ; 1ere boucle pr diviser le nb en chiffre a afficher
 boucle:
        ; mettre dx a 0 pr diviser juste ax
         xor dx, dx
         ; diviser par 10
        mov bx, 10
        div bx
        ; mettre le reste ds la pile
        push dx
         ; si le param est != 0 , on incremente di
         cmp param2,1
         jne non_param2
          inc di
         non_param2:  
        ; rien besoin de changer pr la prochaine division car
        ; le quotient est placer ds ax
        ; comparer le quotient a 0
        cmp ax, 0
  ; si il n'est pas egal on continue
 jne boucle
 
 cmp param2,1
 jne non_param3
 
  ; diviser par 3 le nb total de chiffres empilés,
   ; pr savoir au bout de combien de chiffres il faut mettre le 1ère espace
  mov ax, di
  xor dx, dx
  mov bx, 3
  div bx
  mov di, dx
  ; mais si le nb total de chiffres empilés est 1 multiple de 3,
   ; le reste sera = 0 , donc il faut le mettre a 3 car sinon ,
    ; il mettra 1 espace avant de commencer a afficher le nb
  cmp di, 0
  jne non2
  mov di, 3
  non2:
 
 non_param3:
 
 ; 2eme boucle pr afficher les chiffre contenue ds la pile
 boucle2:
 
         ; si le param est != 0
  cmp param2,1
         jne non_param4  
   
          ; on met ds bp le pointeur sur le sommet de la pile
          mov bp, sp
           
     ; on compare di avec 0 pr savoir si il faut afficher un espace
          cmp di, 0
          jne non
          ; on vérifie si le prochain chiffre dépilé est 10 , si c'est le cas c'est notre indice,
          ; cela signifie que l'on est a la fin du nb
          cmp [bp], 10
          ; et qu'il ne faut donc pas écrire d'espace
          je non
          ; mettre a 3 notre indice
          mov di, 3
          ; afficher un espace
          Ecrire_chaine <' '>
          non:
           
          ; sinon on décrémenter notre indice  
                 dec di
 
                non_param4:
 
        ; on restaure le dernier chiffre empiler ds bx
        pop bx
        ; puis on le compare a 10 notre indice
        cmp bx, 10
        ; pr savoir si on a fini
        je fin
        ; puis on ajoute 48 au chiffre pr obtenir le code ascii
        add bx, 48
        ; puis on met la partie basse de bx ds dl
        mov dl, bl
        ; et enfin on appel l'interruption pr afficher un caractere
        mov ah, 02h    
        int 21h  
  ; si on arrive ici c'est qu'on a pas fini dc un saut inconditionnel
 jmp boucle2
 
 fin:
 
popa
popf
 
code ends
 
 
data segment use16
 
     ; pr le cas ou l'utilisateur ne rentrerai aucun 2eme param
     param2 db groupement_chiffres?
 
data ends
 
endm
 
 
 
 
=======>   Ecrire_chaine  
 
 
Ecrire_chaine macro text?
local texte
 
pushf
pusha
 
data segment use16
 
     texte db text?,'$'
 
data ends
 
code segment use16
 
     ; num de la fonction
     mov ah, 09h
     ; on met ds dx l'offset de la chaine
     mov dx, offset texte
     ; appel de l'interruption
     int 21h
 
code ends
 
popa
popf
 
endm
 
et pr le dernier macro cest pareil que sauf qu'il faut passé en param l'offset d'1 chaine  
 
 
 
en fait tt ces macros font partie d'1 librairie que je créer depuis que j'ai commencer l'asm et je me demandais si je pouvais pas les arrangé ?

balises [code] plz!

=======>   Ecrire_nb  
 

 
 
 
 
=======>   Ecrire_chaine  
 

 
et pr le dernier macro cest pareil que sauf qu'il faut passé en param l'offset d'1 chaine  
 
 
 
en fait tt ces macros font partie d'1 librairie que je créer depuis que j'ai commencer l'asm et je me demandais si je pouvais pas les arrangé ?