Retourner une valeur manuellement - Page 2

C'est à dire

Par exemple que tu ne retournes par la liste que des nombres entiers.

Ah oui ok, c'est ce que je vais faire sinon c trop compliqué.

Quand j'utilise HeapAlloc j'alloue combien de mémoire ? J'ai essayé
HeapAlloc(taille_de_la_liste+2) mais j'obtient une variable qui fait environ 58000 octets
[edit]Edité par Bob 64 le 15-01-2002 à 20:43:02[/edit]

ouch... utilises donc malloc (ou HeapAllocPtr : c exactement la même chose, mais la première appelation en ANSI alors que la seconde est TIOS )

HeapAlloc alloue un Handle... cela dit... c peut-être ce que tu veux
(je suis un peu mort ce soir et j'ai pas le courage de lire la page précédente )

J'y arrive pas

Je veux donc retourner une liste basic à partir d'une en C. Dans mon exemple la liste 'retour' contient une seule valeur. La variable rng_return indique combien la liste contient d'élements, donc elle vaut 1. Et je n'arrive à rien :


void exe_retr(char *variable)
{
if(rng_return>0)
{
SYM_ENTRY *sym = DerefSym(SymAdd(variable));
if(sym)
{
pointeur=(char*)HeapDeref(sym->handle=HeapAlloc(rng_return+2));
pointeur[0]=0xE5;
pointeur[rng_return+1]=0xD9;
for(tmp=rng_return;tmp>1;tmp--) pointeur[tmp]=retour[rng_return-tmp];
}
}
}
Résultat :



Et si on supprime la ligne "pointeur[0]=0xE5" :

void exe_retr(char *variable)
{
if(rng_return>0)
{
SYM_ENTRY *sym = DerefSym(SymAdd(variable));
if(sym)
{
pointeur=(char*)HeapDeref(sym->handle=HeapAlloc(rng_return+2));
//pointeur[0]=0xE5;
pointeur[rng_return+1]=0xD9;
for(tmp=rng_return;tmp>1;tmp--) pointeur[tmp]=retour[rng_return-tmp];
}
}
}
Résultat :

Kevin, à l'aide...

Tu as oublié les octets de taille!
void exe_retr(char *variable)
{
if(rng_return>0)
{
SYM_ENTRY *sym = DerefSym(SymAdd(variable));
if(sym)
{
pointeur=(char*)HeapDeref(sym->handle=HeapAlloc(rng_return+4));
*(short *)pointeur=rng_return+2;
pointeur[2]=0xE5;
pointeur[rng_return+3]=0xD9;
for(tmp=rng_return+2;tmp>3;tmp--) pointeur[tmp]=retour[rng_return-tmp];
}
}
}

Et puis-je savoir pourquoi tu inverses rng_return???
Ça aussi, ça risque de poser problème!
Il faut seulement inverser l'ordre des éléments, pas le contenu des éléments!

et voila.
Merci Kevin !

Une fois de + merci ! (va falloir que je mette ton nom en gras dans les remerciements)

Et puis-je savoir pourquoi tu inverses rng_return ???
> Je ne sais plus ou j'avais entendu ça...

Je suis allé voir sur Doors.ticalc.org mais ils n'expliquent que certains types de variables, et je n'ai pas trouvé d'explications pour les listes

Squale > Lol

Pour les docs sur les formats de vars, ce qui est pour le moment le meileur est à mon avis la doc du SDK de TI

J'ai pas trouvé dedant non plus, mais j'ai peut-être pas bien cherché...

Tant que j'y suis, que veut dire la ligne : *(short *)pointeur=rng_return+2; ?

Lancement du programme, du Vars-Link, et...

YYYYYYEEEEEEEEAAAAAAAHHHHHHH

Une superbe liste de 5 octets !!!
Mais par contre quand je l'ouvre...



Pourtant voilà ce qui a été fait sur la liste :

exe_addl(ngetchx());

Le sous programme exe_addl :

void exe_addl(int valeur)
{
retour[rng_return]=valeur;
rng_return++;
}

Je croyais obtenir le code de la touche appuyée...

C'est n'importe quoi! Les entiers dans une liste TI ne sont pas au même format qu'en C.

Pour information:
0 -> 0x00 0x1f
1 -> 0x01 0x01 0x1f
2 -> 0x02 0x01 0x1f
...
255 -> 0xff 0x01 0x1f
256 -> 0x00 0x01 0x02 0x1f
257 -> 0x01 0x01 0x02 0x1f
...
65535 -> 0xff 0xff 0x02 0x1f
65536 -> 0x00 0x00 0x01 0x03 0x1f
...

Bah oui mais comment j'aurait su moi
(d'ailleurs je ne sait tjrs pas )

Essaye ça:

[i]void exe_retr(char *variable)
{
int i;
ESI top_estack_backup;
SYM_ENTRY *sym;
if(rng_return)
{
top_estack_backup=top_estack;
push_quantum(END_TAG);
for(i=rng_return-1;i;i--) push_longint(retour);
push_quantum(LIST_TAG);
sym = DerefSym(SymAdd(variable));
if(sym)
{
pointeur=(char*)HeapDeref(sym->handle=HeapAlloc(top_estack-top_estack_backup+2));
*(unsigned short *)pointeur=top_estack-top_estack_backup;
memcpy(pointeur+2,top_estack_backup+1,top_estack-top_estack_backup);
}
top_estack=top_estack_backup;
}
}

Je ne garantis pas que ça marche, mais ça m'a l'air correct.
[edit]Edité par Kevin Kofler le 17-01-2002 à 01:31:29[/edit]

Ah ouais c completement différent de mon algo de départ...
Il était vraiment totalement faux ???

Le + bizzard c'est qu'en envoyant 2 fois la même valeur dans le tableau, après la convertion en basic les élements n'étaient plus les mêmes

Ah oui aussi, dans ton algo + haut, que signifie *(short *)pointeur=rng_return+2; ?

Il force la conversion de pointeur en short * (typecasting) puis place rng_return+2 à l'adresse pointée par la variable (short*)pointeur.

Et ce short (*(short *)pointeur) correspond à la taille de la variable.

Mmm ok... donc si la liste contenait un seul élement, ça revient à
*(short *)pointeur=3;

Donc ça devient assez simple, sauf pour :
Et ce short (*(short *)pointeur) correspond à la taille de la variable.
Mais je comprendrait surement ça + tard

Bon sinon je vais peut-être jeter un coup d'oeil à Flib pour voir comment ça marche pour renvoyer des nombres dans 'fl' (mais j'ai peur que FL ne s'y soit pas prit du tout comme moi, et qu'il ait employé un système bcp mieux que je ne comprendrait pas)

Bon bah ct à prévoir, je comprends rien
Tant pis

En + je suis sur qu'il existe une solution simple !!!

[2]pointeur=(char*)HeapDeref(sym->handle=HeapAlloc(rng_return+4));
*(short *)pointeur=rng_return+2;
pointeur=0xE5;
pointeur[rng_return+3]=0xD9;
for(tmp=rng_return;tmp>0;tmp--) pointeur[tmp+2]=retour[rng_return-tmp];

J'ai testé entre chaque étape, et c'est à la partie en bleu clair que ça ne marche pas. Je ne sais pas pkoi il transforme la valeur (j'ai essayé 13) en une liste : {c}.

Il n'y aurait pas une petite transformation simple à faire pr que ça marche ???

Lis bien mes réponses ci-dessus. Il y a:
- l'explication du format à utiliser (Si tu ne comprends pas, va voir http://tigcc.ticalc.org/doc/estack.html#top_estack, peut-être que tu comprends mieux.)
- un algorithme qui passe par la pile d'expressions et qui devrait fonctionner
Soit tu crées les nombres au bon format toi-même, soit tu utilises mon algorithme (qui fait faire le travail à push_longint). Mais le format d'un char ou d'un short n'est pas du tout le format d'un entier d'AMS, donc ça ne peut pas marcher.

C'est dommage une incompatibilité pareille...

En fait je n'ai pas encore utilisé ton algo, parceque ça me vexait un peu d'avoir fait le mien pour rien () et aussi que je ne m'imaginait pas l'erreur aussi grosse...

Donc là j'ai plus trop le choix, je vais devoir recopier "betement" ton algo, ce que je n'aime pas trop faire d'habitude (j'aime bien avoir fait mon prog tt seul comme un grand ).

Je n'ai pas des connaissances en C assez grandes pour faire mon prog sans me faire aider . Il y en a déjà une grosse partie de toi : cette fonction de retour de liste, et aussi la fonction Zoom.

(je vais faire comment dans les remerciements ? Mettre ton nom en gras ? )

Tu connais pas Kévin, si tu mets son nom, il va te faire payer pour l'avoir écrit sans autorisation écrite...

"J'autorise Bob 64, auteur de sa lib de m**de, à écrire mon nom dans la partie 'Remerciements' du fichier ReadMe qui l'accompagnera.
Fait le 18/01/02 à Paris."

Signe ici :

LOL, bien sûr que tu peux mettre mon nom dans les remerciements.

Et pour le format, c'est que tu ne peux pas mettre un caractère tout seul et penser que AMS comprendra tout seul que c'est un entier: tu dois mettre (de la fin vers le début):
- Le tag indiquant que c'est un entier positif: POSINT_TAG.
- Le nombre d'octets (codé sur 1 octet) représentant le nombre. Pour un nombre de type unsigned char, c'est 0 pour 0 et 1 pour 1-255.
- La valeur de l'octet (sauf si c'est 0).

push_longint s'occupe de tout ça (même pour un unsigned long d'ailleurs), mais le résultat est placé sur la pile d'expressions, et il faut donc le récupérer, soit avec HS_popEstack, soit comme moi directement. (HS_popEstack va aussi vouloir retirer les arguments de ton programme de la pile d'expressions et les placer dans le handle résultant, et ils n'ont vraiment rien à faire dans la variable, c'est pour ça que je préfère le faire "à la main".)

Chouette il m'a autorisé

(merci pr l'explication au fait )