tree/mux_tree.c

Go to the documentation of this file.

/*
 * $Id: mux_tree.c,v 1.2 2005/06/23 22:02:14 av1-op Exp $
 *
 * Author: Markus Stenberg <fingon@iki.fi>
 *
 *  Copyright (c) 1996 Markus Stenberg
 *       All rights reserved
 *
 * Created: Mon Nov 25 11:41:43 1996 mstenber
 * Last modified: Mon Jun 22 07:27:06 1998 fingon
 *
 */

#define FATAL(msgs...) \
{ fprintf(stderr, ##msgs); exit(1); }

#define TREAD(to,len,msg) \
if (feof(f)) FATAL("ERROR READING FILE (%s): EOF.\n", msg); \
if (fread(to,1,len,f) != len) \
FATAL("ERROR READING FILE (%s): NOT ENOUGH READ!\n", msg);

#define TSAVE(from,len,msg) \
if (fwrite(from, 1, len, tree_file) != len) \
FATAL("ERROR WRITING FILE (%s): NOT ENOUGH WRITTEN(?!?)\n", msg);

/* Main aim: Attempt to provide 1-1 interface when compared to my
   old rbtc code and the new AVL code */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "tree.h"
#include "mux_tree.h"

#define Create(var,typ,count) \
if (!(var = (typ *) calloc(sizeof (typ), count))) \
{ fprintf(stderr, "Error mallocating!\n"); exit(1); }

static int NodeCompare(Node * a, Node * b)
{
    if (a->key < b->key)
        return -1;
    return (a->key > b->key);
}

static void NodeDelete(Node * a)
{
    if (a->data)
        free((void *) a->data);
    free((void *) a);
}

void AddEntry(Tree * tree, muxkey_t key, dtype_t type, dsize_t size,
    void *data)
{
    Node *foo;

    if (!tree)
        return;
    Create(foo, Node, 1);
    foo->key = key;
    foo->data = data;
    foo->type = type;
    foo->size = size;
    tree_add(tree, NodeCompare, foo, NodeDelete);
}

Node *FindNode(Tree tree, muxkey_t key)
{
    Node foo;

    foo.key = key;
    return tree_srch(&tree, NodeCompare, &foo);
}

void DeleteEntry(Tree * tree, muxkey_t key)
{
    Node foo;

    if (FindNode(*tree, key)) {
        foo.key = key;
        tree_delete(tree, NodeCompare, &foo, NodeDelete);
    }
}

static FILE *tree_file;

static int nodesave_count;

static int NodeSave(Node * n)
{
    TSAVE(&n->key, sizeof(n->key), "key");
    TSAVE(&n->type, sizeof(n->type), "type");
    TSAVE(&n->size, sizeof(n->size), "size");
    if (n->size > 0)
        TSAVE(n->data, n->size, "data");
    nodesave_count++;
    return 1;
}

int SaveTree(FILE * f, Tree tree)
{
    muxkey_t key;

    nodesave_count = 0;
    tree_file = f;
    tree_trav(&tree, NodeSave);
    key = -1;
    fwrite(&key, sizeof(key), 1, tree_file);
    return nodesave_count;
}

static void MyLoadTree(FILE * f, Tree * tree, int (*sizefunc)(int))
{
    muxkey_t key;
    dtype_t type;
    dsize_t osize;
    int nsize, rsize;
    void *data;

    TREAD(&key, sizeof(key), "first key");
    while (key >= 0 && !feof(f)) {
        TREAD(&type, sizeof(type), "type");
        TREAD(&osize, sizeof(osize), "size");
        if (sizefunc && (rsize = sizefunc(type)) >= 0) {
            nsize = osize > rsize ? osize : rsize;
        } else
            nsize = rsize = osize;
        if (nsize) {
            if (!(data = malloc(nsize))) {
                printf("Error malloccing!\n");
                exit(1);
            }
            if (osize)
                TREAD(data, osize, "data");

            if (nsize > osize)
                memset(data + osize, 0, nsize - osize);
        } else
            data = NULL;

        /* Set node size to the real type size, rather than the read size,
         * so that the object will get 'truncated' to the right size on the
         * next dump.
         */
        AddEntry(tree, key, type, rsize, data);
        TREAD(&key, sizeof(key), "new key");
    }
}


/* This is a _MONSTER_ :P */
void ClearTree(Tree * tree)
{
    tree_mung(tree, NodeDelete);
}

void LoadTree(FILE * f, Tree * tree, int (*sizefunc)(int))
{
    ClearTree(tree);
    MyLoadTree(f, tree, sizefunc);
}

void UpdateTree(FILE * f, Tree * tree, int(*sizefunc)(int))
{
    MyLoadTree(f, tree, sizefunc);
}

void GoThruTree(Tree tree, int (*func) (Node *))
{
    tree_trav(&tree, func);
}

---