addresses invalides - Page 1

J'ai des données d'un programme à passer en variable TIOS indépendante. Celles-ci contiennent notamment des adresses pointant sur des données situées un peu plus loin dans le fichier:

	dc.l	adr1,adr2
	dc.w	0,0,0
	dc.w	0,0,0
	dc.w	0,0,1
	dc.w	70
	
adr1
	dc.l	0
	dc.w	0,0,0
	dc.w	0,0,0
adr2
	dc.l	0
	dc.w	0,0,0
	dc.w	0,0,0

struction du fichier externe, la ligne dc.l adr1,adr2Lors de la conient invalide, puisque adr1 devadr2 et ne sont plus exprimées "relativement" au début du fichier, mais contiennent l'adresse de chacun des deux labels au moment de la construction du fichier externe (pas facile à expliquer ). Y a-t-il un moyen simple (je parle d'une astuce purement technique, pas d'un algorithme) pour éviter ça, et que les deux adresses soient finalement correctes lorsque le fichier externe de données sera créé?

Ok, je vais voir ça.

Je ne comprends pas ce que EX_patch fait.

relocates relocatable items in the assembly program

Donc d'après ce que j'ai lu, EX_patch se sert de la table de relocation qui se situe à la fin d'un programme (je ne savais pas qu'il y en avait une) pour corriger les adresses.
Mais comment sont différentiées adresses et autres données dans le fichier .89z?

C'est tout bête:
adresse = quelque chose qui a une entrée dans la table de relogements
autres données = tout le reste

Ok, mais à ce moment-là, quelle est la structure d'une table de relogement? Techniquement, comment EX_patch fait pour corriger les adresses à partir de cette table?

Pourquoi as-tu besoin de savoir ça? Appelle EX_patch tout simplement!

Oui, mais en même temps j'ai envie de savoir comment ça fonctionne

Bon je vais étudier le code de EX_patch, elle n'a pas l'air très compliquée à analyser.
Merci Kevin (une fois de plus )

Par contre si tu veux que l'adresse soit relative, tu peux faire

Reference:
puis
dc.l adr1-Reference, adr2-reference

et si c'est un truc de données, tu utilises comme référence le début du fichier (pointeur que ton prog principal utilise nécessairement) et t'as qu'à y ajouter le adr1-Reference pour retrouver l'addresse de adr1.

C'est ce que je fais, ça évite d'utiliser la realocation Table. Tout dépend du format que tu choisis pour ta variable externe.

Et en effet, l'utilisation d'adresses relatives a l'avantage de fonctionner même si le fichier externe est archivé. (Avec le relogement, il faut le désarchiver ou le copier en RAM.)

et t'as qu'à y ajouter le adr1-Reference pour retrouver l'addresse de adr1.

C'est justement ce que je veux éviter.

c'est pas trop lourd d'ajouter un pointeur à chaque fois
tu fais

long *Tmp_Ptr=File_Begin;
void*MyTable[[i]Pointers_Number[/i]];
int i;for(i=0;i<Pointers_Number;i++)
{
MyTable[[i]i[/i]]=File_Begin+*Tmp_Ptr++;
}

et tu utilise MyTablepour tes pointers.

Je préfère que ma partie du programme qui reçoit les données n'aie pas besoin de les manipuler plus qu'elle ne le fait déja. J'avais testé la solution que tu me proposes, mais dans mon cas, elle fait ralentir mon programme, ce que je veux éviter

EX_patch ne fonctionne pas (pourtant en regardant avec le debugger, il "parse" bien tout le fichier externe).
En fait voilà ce que je veux faire: j'ai un programme (.89z, pas un programme pc) qui me créé une variable tios, alloue de la place pour les données, et copie y des données + tag du fichier. Le problème est que ces données n'auront pas les mêmes adresses dans le programme qui créé la variable tios et dans la variable tios elle-même. Donc à chaque fois que mon programme copie une l'adresse d'une donnée dans la mémoire allouée pour la var., celle-ci n'est pas exacte. J'applique donc EX_patch en fin de programme à la variable que je viens de créer, mais les adresses ne sont pas corrigées..

1. Il faut compiler la variable comme un programme à part si tu veux pouvoir la reloger à part.
2. C'est à l'ouverture qu'il faut reloger, pas à l'enregistrement.
3. La solution de C Bien est nettement plus simple.

Bon, je vais trouver une autre solution.
Pour le 2), je ne peux pas, puisqu'il faut fournir un pointeur sur le tag du fichier à EX_patch?

C'est à ça que sert HToESI.

Hum ok.

[edit: rien.]

Ton programme qui crée la variable, tu as su lui faire faire une table d'allocation ?
(sinon je doute que EX_PATCH marche, il sert juste (ai-je cru comprendre) à actualiser les pointers d'un fichiant ayant une table de réalocation)

Nan, je ne connais pas la structure d'une table de relogements.

C bien> finalement j'ai fais ce que tu m'a suggéré dans ton post ./14, merci

De toute façon, tu ne peux pas mettre les adresses lors de la sauvegarde de la variable, elles ne seront plus valides lors de l'ouverture, parce que le fichier pourrait avoir bougé en mémoire entretemps!

Ah oui, je n'avais pas pensé à ça, donc en fait ça ne marchera pas... il faut que je le fasse lors de l'ouverture de la variable externe par mon programme, ok

Donc, soit je corrige les adresses "manuellement" lorsque mon programme les utilise (mais je voudrais éviter ça), soit je créé une table de relogement lors de la sauvegarde de ma variable, que je parcours en début de programme pour corriger toutes les adresses relatives (ce doit être ce que fait EX_patch d'ailleurs, puisque là il faut que ma variable soit désarchivée)?

Oui.