yop
quelques questions :

1.
quand on a :

    HANDLE handle;
    char *ptrFILE;
    SYM_ENTRY *sym;
    handle = HeapAlloc(16);
    if (!handle)   return;
    sym = DerefSym(SymAdd(SYM_STR("tuto")));
    if (!sym)  {HeapFree(handle);       return;}
    
    sym->handle = handle;
    ptrFILE = HeapDeref(handle);
    *(short*)ptrFILE = 14;
    ptrFILE[10] = 0;
    strcpy(ptrFILE+11,"TUT");
    ptrFILE[15]=OTH_TAG;

(tuto de Benji sur TI-Gen)
Une fois le fichier crée, on a bien 8 octets disponibles pour écrire quelque chose ?

+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+-----------+------+
|  0 |  1 |  2 | 3 |  4 |  5 |  6 | 7  | 8 |  9 | 10|11 |12| 13|14 |   15        |16    |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+-----------+------+
| taille   |      données                           |  0 | T  | U |  T |  0 |OTH_TAG| 0(?) |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+-----------+------+
|     2    |               8                              |  1 |        3      |  1 |      1       |   1    |
+---+---+---+---+---+---+---+---+---+---+---+---+---+---+---+-----------+------+

2. Je veux créer un fichier qui stockera les données des sprites que j'utilise :
le fichier est sous cette forme :

       taille : 2 octets
       nombre de données à lire par sprite (lignes) : 1 octet
       données : s octets
       autres : 0 // SPR // 0 // OTH_TAG // 0 (?) : 7 octets

soit :
+---+---+---+---+---+---+---+---+-----+------+------+----+------+------+-----+-----------+------+
|  0 |  1 |  2 | 3 |  4 |  ...            | s+1|  s+2 | s+3 |s+4 | s+5 | s+6 | s+7 | s+8        | s+9  |
+---+---+---+---+---+---+---+---+-----+------+------+---- +-----+------+------+-----------+------+
| taille   |     |            données                     |  0    | T     | U    |  T    |  0     |OTH_TAG| 0(?) |
+---+---+---+---+---+---+---+---+-----+------+------+---+---+---+-----+------+-----------+------+
|     2    | 1  |                    s                         |  1     |        3      |  1    |   1   |       1     |     1   |
+---+---+---+---+---+---+---+---+-----+------+------+---+---+---+---+--------+------+---+-------+

La taille du fichier est donc bien de s+9 octets ?
J'ai essayé ce code

SYM_ENTRY *sym = SymFindPtr(SYM_STR("spr",0);

if (!sym)
{
    HANDLE handle;
    char *ptrFILE;
    handle = HeapAlloc(s+9);
    if (!handle)   return;
    sym = DerefSym(SymAdd(SYM_STR("spr")));
    if (!sym)  {HeapFree(handle);       return;}
    
    sym->handle = handle;
    ptrFILE = HeapDeref(handle);
    *(short*)ptrFILE = s+7;
    ptrFILE[s+3] = 0;
    strcpy(ptrFILE+s+4,"TUT");
    ptrFILE[s+8]=OTH_TAG;
}

... //écriture des données ici, c'est un tableau de [i]char[/i]

mais ça me donne des résultats bizarres dans le Var-Link...




3.Comment créer un tableau de char à dimension s, s étant une variable de type short ?
comme ça :

char *spr = (char*) malloc(s*sizeof(char));

?

et une fois le tableau crée, comment pouvoir récupérer les données avec memcpy() ?
parce que

... //suite du code précédent
memcpy(spr, ptrFILE + 4, ptrFILE + 3);

ne me donne pas les bonnes données ; sinon, y a toujours moyen de le faire avec une boucle for, "à la main", mais j'préfère éviter


voilà voilà, merci pour les éventuelles réponses ^^



(désolé pour le décalage pour les tableaux ....)