La solution est tres simple:
#include <kernel.h>
Ca m'a pris 5 minutes d'implémenter la gestion des zip dans TIM. Pour enstein, t'as qu'a faire une version kernel compatible zip et une nostub qui gere que le komp ou même mieux une version mistub.
en tt cs, moins que les notions sur les pointeurs au début !
l'utilisation de CompLib est tres bien, mais c vrrai que si il programme kernel, il faut utiliser ziplib, pour éviter une perte inutile de place !
Moumou demandait aussi si j'utilisait tjrs DoorsOS, pk ?Parce que DoorsOS est complètement dépassé. utilise plustôt PreOS de PpHd http://www.timetoteam.fr.st
et j'ai peur que ce topic dévie a force, enfin, si KK amène son nez ici
(je récapitule) :
!!
trust a écrit :
la seul methode pour gagner de la place etant de mettre les fonctions que tu utilises dans un header, la tu gagneras un peu de place, mais sinon ca sert a rien
Vertyos
a écrit : Reste à voir comment hibou prendra ça... En tout cas voilà bien un exemple qui montre pourquoi je ne distribuerais jamais mes sources dans le zip, mais uniquement après demande pour me rappeller qui les as...
flow a écrit :
Ca c'est très intéressant pour nous en revanche. Reste à voir quelle signature et comment la recueillir.
Kevin Kofler
a écrit : Quant aux modifications apportées, ce sont des modifications pour améliorer l'intégration en son programme; en quoi cela te dérange-t'il?
// nested function :
void atteindre_feuilles(tNeud *neud) // fonction qui sauvegarde l'arbre dans tree_svg
{
if (neud->fils_zero != NULL) // si on n'a pas atteind une feuille
{
ajouter_bit(tree_svg_ptr, 1); // on enregistre le neud (codé par un 1)
atteindre_feuilles(neud->fils_zero); // on descend sur le fils d'indice zéro
atteindre_feuilles(neud->fils_un); // puis sur le fils d'indice un
}
else // si on a atteind une feuille
{
ajouter_bit(tree_svg_ptr, 0); // on signale la feuille (codée par un 0)
*encode++= neud->octet; // on écrit l'octet que représente la feuille
sortie->data.nb_leaf_m1++; // on compte le nouvel octet
}
}
(...)
j= 256; while (j--) pbase++->frequence= 0; // initialisation des fréquences de la base
(...)
while (i--) base[*entree++].frequence++; // comptage des occurences de chaque octet du fichier
racine= construire_arbre(base, bloc_neuds, TRUE); // construction de l'arbre
atteindre_feuilles(racine); // sauvegarde de l'arbre
j= tree_svg_ptr - tree_svg; // nombre d'octets contenant la sauvegarde, arrondit à l'octet inférieur (on peut avoir 5 octets et 3 bits, par exemple)
tree_svg_ptr= tree_svg;
while (j--) *encode++= *tree_svg_ptr++; // copie de la sauvegarde, octet par octet
// s'il reste des bits après ces octets, ils seront écrits pendant la compression, à la première complétion du buffer // nested function :
tNeud *reconstruire_arbre(tNeud *pere, short bit)
{
tNeud *adresse;
if (lire_bit() != 0) // neud
{
adresse= prochain_neud++;
adresse->pere= pere;
adresse->fils_zero= reconstruire_arbre(adresse, 0);
adresse->fils_un= reconstruire_arbre(adresse, 1);
adresse->bit= bit;
}
else // feuille
{
unsigned short octet= *octets++;
adresse= octet2feuille(octet);
adresse->pere= pere;
adresse->fils_zero= NULL;
adresse->octet= octet;
adresse->bit= bit;
}
return adresse;
}
(...)
compressed= entree->data.compressed + entree->data.nb_leaf_m1 + 1; // les bits sont après la liste des octets codés par l'arbre
racine= reconstruire_arbre(NULL, 0); // reconstruction de l'arbre
).