Chce zapisać drzewo w pliku i binarnie i je odczytać:

Kod:
struct section /*deklaracja struktury działu*/
{
    char title[21]; /*tytuł działu*/
    struct section *fs; /*pierwszy dział*/
    struct section *ls; /*ostatni dział*/
    struct section *next; /*następny dział*/
    struct section *previous; /*poprzedni dział*/
    struct section *parent; /*dział, w którym się znajduje*/
    struct photo *fp; /*pierwsze zdjęcie*/
    struct photo *lp; /*ostatnie zdjęcie*/
};
struct photo /*deklaracja struktury zdjęcia*/
{
    char surname[21]; /*nazwisko autora*/
    char name[21]; /*imię autora*/
    unsigned id; /*numer zdjęcia*/
    struct photo *next; /*następne zdjęcie*/
    struct photo *previous; /*poprzednie zdjęcie*/
};
struct section *root;
const size_t sectionSize = sizeof (struct section);
const size_t photoSize = sizeof (struct photo);
Mój zapis (binarnie tylko tam, gdzie i = 1):

Kod:
 if (i == 0)
                {
                    fprintf(f, "%s\n", root->title);
                }
                else
                {
                    fwrite(root->title, sizeof (root->title), 1, f);
                }
                cs = root;
                while (1)
                {
                    const char space = ' ';
                   (...)
                    if (i == 1 && cs != root)
                    {
                        const char plus = '+';
                        fwrite(&plus, sizeof plus, 1, f);
                        fwrite(&space, sizeof space, 1, f);
                        fwrite(cs->title, sizeof (cs->title), 1, f);
                    }
                    for (p = cs->fp; p != NULL; p = p->next)
                    {
                        if (i == 0)
                        {
                            fprintf(f, "z %s,%s,%u\n", p->surname, p->name, p->id);
                        }
                        else
                        {
                            const char z = 'z';
                            fwrite(&z, sizeof z, 1, f);
                            fwrite(&space, sizeof space, 1, f);
                            fwrite(&p, sizeof p, 1, f);
                        }
                    }
                    if (root->fs == NULL)
                    {
                        break;
                    }
                    if (cs->fs != NULL) /*poziom wyżej*/
                    {
                        cs = cs->fs;
                        continue;
                    }
                    if (cs->next == NULL) /*nie ma następnego*/
                    {
                        End(cs->title, f, i);
                        if (cs->parent == root)
                        {
                            break;
                        }
                        if (cs->parent->next == NULL)
                        {
                            End(cs->parent->title, f, i);
                            for (cs = cs->parent->parent; cs != root; End(cs->title, f, i), cs = cs->parent)
                            {
                                if (cs->next != NULL)
                                {
                                    cs = cs->next;
                                    break;
                                }
                            }
                            break;
                        }
                        else
                        {
                            cs = cs->parent->next;
                        }
                    }
                    else /*jest następny*/
                    {
                        End(cs->title, f, i);
                        cs = cs->next;
                    }
                }
                if (i == 1)
                {
                    const char tc = '$';
                    fwrite(&tc, sizeof tc, 1, f);
                }
                fflush(f);
Zapis binarnie w funkcji void End(char title[21], FILE *f, int binarily) (która zamyka dział):

Kod:
const char minus = '-', space = ' ';
        fwrite(&minus, sizeof minus, 1, f);
        fwrite(&space, sizeof space, 1, f);
        fwrite(title, sizeof (title), 1, f);
Odczyt binarnie (Copy to funkcja kopiująca wszystkie znaki z pierwszej struktury do drugiej):

Kod:
struct section *cs;
(...)
cs = root;
(...)
 for (fread(&c, sizeof (char), 1, f); c != '$'; fread(&c, sizeof (char), 1, f))
                {
                    char t;
                    fread(&t, sizeof (char), 1, f);
                    switch (c)
                    {
                        case '+':
                            fread(temp, sizeof temp, 1, f);
                            if (cs->ls == NULL) /*w przypadku działu bez poddziałów*/
                            {
                                cs->fs = malloc(sectionSize);
                                cs->ls = cs->fs;
                                cs->fs->previous = NULL;
                            }
                            else /*w przypadku działu z poddziałami*/
                            {
                                cs->ls->next = malloc(sectionSize);
                                cs->ls->next->previous = cs->ls;
                                cs->ls = cs->ls->next;
                            }
                            Copy(temp, cs->ls->title);
                            cs->ls->parent = cs;
                            cs = cs->ls;
                            break;
                        case '-':
                            fread(temp, sizeof temp, 1, f);
                            SortSections(cs);
                            SortPhotos(cs);
                            cs = cs->parent;
                            break;
                        case 'z':
                            if (cs->lp == NULL) /*jeśli ostatnie zdjęcie nie istnieje*/
                            {
                                cs->fp = malloc(photoSize);
                                cs->lp = cs->fp;
                                cs->fp->previous = NULL;
                            }
                            else
                            {
                                cs->lp->next = malloc(photoSize);
                                cs->lp->next->previous = cs->lp;
                                cs->lp = cs->lp->next;
                            }
                            fread(cs->lp, photoSize, 1, f);
                    }
                }
Pętla działa w nieskończoność. Dlaczego? Jak odczytać plik, który zapisałem binarnie w podany wcześniej sposób?

Czy jest może łatwiejszy sposób zapisu i odczytu tego drzewa?


System, na którym programuje: OpenSolaris 2008.11 x86
System docelowy: Solaris 9 SPARC