Vertyos
a écrit :
Avec le while tu ne fais que tester un seul octet ? Je croyais qu'on devait trouver un mot nul ?
Non, je teste un mot entier, mais octet par octet parce que l'adresse pourrait être impaire:
while(*(p--) || *p) p--; // cherche le mot nul (pas while(*--p || *--p) à cause de l'évaluation paresseuse)
Le code en rouge teste le deuxième octet du mot et décale le pointeur.
Si le deuxième octet était nul, le code en vert teste le premier octet pour voir s'il est également nul.
Si au moins un des octets est non-nul (donc si le mot est non nul), le code en bleu redécale le pointeur pour tomber sur le deuxième octet du mot d'avant.
Si les 2 octets étaient nuls, on se retrouve sur le premier octet du mot nul.
Et puis char *p=oldtagptr-1; : Le premier mot à tester est {p-1,p} ou bien {p,p+1} ?
Le premier mot à tester est {oldtagptr-2,oldtagptr-1}, c'est-à-dire {p-1,p}.
Edit #1
: Je comprends pas comment ça marche, mais ça marche 
Quelques explications sur ce que j'ai dit au dessus seraient néanmoins les bienvenues 
C'est fait.
Edit #2
: Arf en fait ça marche à moitié... J'ai un prog qui "allonge" un ASM de 10 octets à chaque lancement, mais ça ne marche que quelques fois, ensuite l'asm est corrompu...
Ton code est faux:
// Pointe "old" sur le tag avant redimention
char *old=(handle+*(unsigned short*)handle+1);
Ici, tu crées un pointeur vers le bloc.
// Pointe "p" sur l'octet precedant le tag
char *p=old-1;
Ici, tu en déduis un autre pointeur vers le bloc.
// Ajoute 10 octets à la variable
short add=10,size=*(unsigned short*)handle;
*(unsigned short*)HeapDeref(sym->handle=HeapRealloc(sym->handle,size+add+2))=size+add;
Ici, tu agrandis le bloc, donc il peut être
déplacé! Donc
tous les pointeurs vers ton bloc ne sont plus valables à ce moment et doivent être recalculés!
// cherche le mot nul (pas while(*--p || *--p) à cause de l'évaluation paresseuse)
while(*(p--) || *p) p--;
// déplace la table de relogements
memmove(p+10,p,old-p);
Ici, tu utilise le pointeur désormais invalidé.
Essaye:
// Stoque le SYM_ENTRY de la variable dans "sym" et un pointeur vers son handle dans "handle"
handle=vat_heap(sym=(vat_open("asmprog")));
// Ajoute 10 octets à la variable (partie 1)
short add=10,size=*(unsigned short*)handle;
// Met à jour le pointeur handle
handle=HeapDeref(sym->handle=HeapRealloc(sym->handle,size+add+2));
// Pointe "old" sur le tag avant redimensionnement
char *old=(handle+*(unsigned short*)handle+1);
// Ajoute 10 octets à la variable (partie 2)
*(unsigned short*)handle=size+add;
// Pointe "p" sur l'octet precedant le tag
char *p=old-1;
// cherche le mot nul (pas while(*--p || *--p) à cause de l'évaluation paresseuse)
while(*(p--) || *p) p--;
// déplace la table de relogements
memmove(p+add,p,old-p);
// Réécrit le tag
*(unsigned char*)(handle+*(unsigned short*)handle+1)=243;
Je viens de te donner l'algo !
