src/misc/st/st.h File Reference

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Data Structures
struct	st_table_entry
struct	st_table
struct	st_generator
Defines
#define	st_is_member(table, key)   st_lookup(table,key,(char **) 0)
#define	st_count(table)   ((table)->num_entries)
#define	ST_DEFAULT_MAX_DENSITY   5
#define	ST_DEFAULT_INIT_TABLE_SIZE   11
#define	ST_DEFAULT_GROW_FACTOR   2.0
#define	ST_DEFAULT_REORDER_FLAG   0
#define	st_foreach_item(table, gen, key, value)   for(gen=st_init_gen(table); st_gen(gen,key,value) || (st_free_gen(gen),0);)
#define	st_foreach_item_int(table, gen, key, value)   for(gen=st_init_gen(table); st_gen_int(gen,key,value) || (st_free_gen(gen),0);)
#define	ST_OUT_OF_MEM   -10000
Typedefs
typedef struct st_table_entry	st_table_entry
typedef struct st_table	st_table
typedef struct st_generator	st_generator
typedef int(*	ST_PFI )()
Enumerations
enum	st_retval { ST_CONTINUE, ST_STOP, ST_DELETE }
Functions
st_table *	st_init_table_with_params (ST_PFI, ST_PFI, int, int, double, int)
st_table *	st_init_table (ST_PFI, ST_PFI)
void	st_free_table (st_table *)
int	st_lookup (st_table *, char *, char **)
int	st_lookup_int (st_table *, char *, int *)
int	st_insert (st_table *, char *, char *)
int	st_add_direct (st_table *, char *, char *)
int	st_find_or_add (st_table *, char *, char ***)
int	st_find (st_table *, char *, char ***)
st_table *	st_copy (st_table *)
int	st_delete (st_table *, char **, char **)
int	st_delete_int (st_table *, long *, char **)
int	st_foreach (st_table *, ST_PFSR, char *)
int	st_strhash (char *, int)
int	st_numhash (char *, int)
int	st_ptrhash (char *, int)
int	st_numcmp (char *, char *)
int	st_ptrcmp (char *, char *)
st_generator *	st_init_gen (st_table *)
int	st_gen (st_generator *, char **, char **)
int	st_gen_int (st_generator *, char **, long *)
void	st_free_gen (st_generator *)
Variables
enum st_retval(*	ST_PFSR )()

---

Define Documentation

#define st_count

(

table

)

((table)->num_entries)

Definition at line 48 of file st.h.

#define ST_DEFAULT_GROW_FACTOR   2.0

Definition at line 81 of file st.h.

#define ST_DEFAULT_INIT_TABLE_SIZE   11

Definition at line 80 of file st.h.

#define ST_DEFAULT_MAX_DENSITY   5

Definition at line 79 of file st.h.

#define ST_DEFAULT_REORDER_FLAG   0

Definition at line 82 of file st.h.

#define st_foreach_item	(	table,
		gen,
		key,
		value		)	for(gen=st_init_gen(table); st_gen(gen,key,value) || (st_free_gen(gen),0);)

Definition at line 84 of file st.h.

#define st_foreach_item_int	(	table,
		gen,
		key,
		value		)	for(gen=st_init_gen(table); st_gen_int(gen,key,value) || (st_free_gen(gen),0);)

Definition at line 87 of file st.h.

#define st_is_member	(	table,
		key		)	st_lookup(table,key,(char **) 0)

Definition at line 47 of file st.h.

#define ST_OUT_OF_MEM   -10000

Definition at line 90 of file st.h.

---

Typedef Documentation

typedef struct st_generator st_generator

Definition at line 40 of file st.h.

typedef int(* ST_PFI)()

Definition at line 53 of file st.h.

typedef struct st_table st_table

Definition at line 28 of file st.h.

typedef struct st_table_entry st_table_entry

Definition at line 21 of file st.h.

---

Enumeration Type Documentation

enum st_retval

Enumerator:

ST_CONTINUE
ST_STOP
ST_DELETE

Definition at line 50 of file st.h.

{ST_CONTINUE, ST_STOP, ST_DELETE};

---

Function Documentation

int st_add_direct	(	st_table *	,
		char *	,
		char *
	)

Definition at line 233 of file st.c.

{
    int hash_val;
    st_table_entry *new;
    
    hash_val = do_hash(key, table);
    if (table->num_entries / table->num_bins >= table->max_density) {
        if (rehash(table) == ST_OUT_OF_MEM) {
            return ST_OUT_OF_MEM;
        }
    }
    hash_val = do_hash(key, table);
    new = ALLOC(st_table_entry, 1);
    if (new == NULL) {
        return ST_OUT_OF_MEM;
    }
    new->key = key;
    new->record = value;
    new->next = table->bins[hash_val];
    table->bins[hash_val] = new;
    table->num_entries++;
    return 1;
}

st_table* st_copy

(

st_table *

)

Definition at line 368 of file st.c.

{
    st_table *new_table;
    st_table_entry *ptr, *newptr, *next, *new;
    int i, j, num_bins = old_table->num_bins;

    new_table = ALLOC(st_table, 1);
    if (new_table == NULL) {
        return NULL;
    }
    
    *new_table = *old_table;
    new_table->bins = ALLOC(st_table_entry *, num_bins);
    if (new_table->bins == NULL) {
        FREE(new_table);
        return NULL;
    }
    for(i = 0; i < num_bins ; i++) {
        new_table->bins[i] = NULL;
        ptr = old_table->bins[i];
        while (ptr != NULL) {
            new = ALLOC(st_table_entry, 1);
            if (new == NULL) {
                for (j = 0; j <= i; j++) {
                    newptr = new_table->bins[j];
                    while (newptr != NULL) {
                        next = newptr->next;
                        FREE(newptr);
                        newptr = next;
                    }
                }
                FREE(new_table->bins);
                FREE(new_table);
                return NULL;
            }
            *new = *ptr;
            new->next = new_table->bins[i];
            new_table->bins[i] = new;
            ptr = ptr->next;
        }
    }
    return new_table;
}

int st_delete	(	st_table *	,
		char **	,
		char **
	)

Definition at line 414 of file st.c.

{
    int hash_val;
    char *key = *keyp;
    register st_table_entry *ptr, **last;

    hash_val = do_hash(key, table);

    FIND_ENTRY(table, hash_val, key, ptr ,last);
    
    if (ptr == NULL) {
        return 0;
    }

    *last = ptr->next;
    if (value != NULL) *value = ptr->record;
    *keyp = ptr->key;
    FREE(ptr);
    table->num_entries--;
    return 1;
}

int st_delete_int	(	st_table *	,
		long *	,
		char **
	)

Definition at line 440 of file st.c.

{
    int hash_val;
    char *key = (char *) *keyp;
    register st_table_entry *ptr, **last;

    hash_val = do_hash(key, table);

    FIND_ENTRY(table, hash_val, key, ptr ,last);

    if (ptr == NULL) {
        return 0;
    }

    *last = ptr->next;
    if (value != NULL) *value = ptr->record;
    *keyp = (long) ptr->key;
    FREE(ptr);
    table->num_entries--;
    return 1;
}

int st_find	(	st_table *	,
		char *	,
		char ***
	)

Definition at line 298 of file st.c.

{
    int hash_val;
    st_table_entry *ptr, **last;

    hash_val = do_hash(key, table);

    FIND_ENTRY(table, hash_val, key, ptr, last);

    if (ptr == NULL) {
        return 0;
    } else {
        if (slot != NULL) {
            *slot = &ptr->record;
        }
        return 1;
    }
}

int st_find_or_add	(	st_table *	,
		char *	,
		char ***
	)

Definition at line 261 of file st.c.

{
    int hash_val;
    st_table_entry *new, *ptr, **last;

    hash_val = do_hash(key, table);

    FIND_ENTRY(table, hash_val, key, ptr, last);

    if (ptr == NULL) {
        if (table->num_entries / table->num_bins >= table->max_density) {
            if (rehash(table) == ST_OUT_OF_MEM) {
                return ST_OUT_OF_MEM;
            }
            hash_val = do_hash(key, table);
        }
        new = ALLOC(st_table_entry, 1);
        if (new == NULL) {
            return ST_OUT_OF_MEM;
        }
        new->key = key;
        new->record = (char *) 0;
        new->next = table->bins[hash_val];
        table->bins[hash_val] = new;
        table->num_entries++;
        if (slot != NULL) *slot = &new->record;
        return 0;
    } else {
        if (slot != NULL) *slot = &ptr->record;
        return 1;
    }
}

int st_foreach	(	st_table *	,
		ST_PFSR	,
		char *
	)

void st_free_gen

(

st_generator *

)

Definition at line 621 of file st.c.

{
    FREE(gen);
}

void st_free_table

(

st_table *

)

Definition at line 99 of file st.c.

{
    register st_table_entry *ptr, *next;
    int i;

    for(i = 0; i < table->num_bins ; i++) {
        ptr = table->bins[i];
        while (ptr != NULL) {
            next = ptr->next;
            FREE(ptr);
            ptr = next;
        }
    }
    FREE(table->bins);
    FREE(table);
}

int st_gen	(	st_generator *	,
		char **	,
		char **
	)

Definition at line 561 of file st.c.

{
    register int i;

    if (gen->entry == NULL) {
        /* try to find next entry */
        for(i = gen->index; i < gen->table->num_bins; i++) {
            if (gen->table->bins[i] != NULL) {
                gen->index = i+1;
                gen->entry = gen->table->bins[i];
                break;
            }
        }
        if (gen->entry == NULL) {
            return 0;           /* that's all folks ! */
        }
    }
    *key_p = gen->entry->key;
    if (value_p != 0) {
        *value_p = gen->entry->record;
    }
    gen->entry = gen->entry->next;
    return 1;
}

int st_gen_int	(	st_generator *	,
		char **	,
		long *
	)

Definition at line 591 of file st.c.

{
    register int i;

    if (gen->entry == NULL) {
        /* try to find next entry */
        for(i = gen->index; i < gen->table->num_bins; i++) {
            if (gen->table->bins[i] != NULL) {
                gen->index = i+1;
                gen->entry = gen->table->bins[i];
                break;
            }
        }
        if (gen->entry == NULL) {
            return 0;           /* that's all folks ! */
        }
    }
    *key_p = gen->entry->key;
    if (value_p != 0) {
        *value_p = (long) gen->entry->record;
    }
    gen->entry = gen->entry->next;
    return 1;
}

st_generator* st_init_gen

(

st_table *

)

Definition at line 544 of file st.c.

{
    st_generator *gen;

    gen = ALLOC(st_generator, 1);
    if (gen == NULL) {
        return NULL;
    }
    gen->table = table;
    gen->entry = NULL;
    gen->index = 0;
    return gen;
}

st_table* st_init_table	(	ST_PFI	,
		ST_PFI
	)

st_table* st_init_table_with_params	(	ST_PFI	,
		ST_PFI	,
		int	,
		int	,
		double	,
		int
	)

int st_insert	(	st_table *	,
		char *	,
		char *
	)

Definition at line 196 of file st.c.

{
    int hash_val;
    st_table_entry *new;
    register st_table_entry *ptr, **last;

    hash_val = do_hash(key, table);

    FIND_ENTRY(table, hash_val, key, ptr, last);

    if (ptr == NULL) {
        if (table->num_entries/table->num_bins >= table->max_density) {
            if (rehash(table) == ST_OUT_OF_MEM) {
                return ST_OUT_OF_MEM;
            }
            hash_val = do_hash(key, table);
        }
        new = ALLOC(st_table_entry, 1);
        if (new == NULL) {
            return ST_OUT_OF_MEM;
        }
        new->key = key;
        new->record = value;
        new->next = table->bins[hash_val];
        table->bins[hash_val] = new;
        table->num_entries++;
        return 0;
    } else {
        ptr->record = value;
        return 1;
    }
}

int st_lookup	(	st_table *	,
		char *	,
		char **
	)

Definition at line 133 of file st.c.

{
    int hash_val;
    register st_table_entry *ptr, **last;

    hash_val = do_hash(key, table);

    FIND_ENTRY(table, hash_val, key, ptr, last);
    
    if (ptr == NULL) {
        return 0;
    } else {
        if (value != NULL) {
            *value = ptr->record; 
        }
        return 1;
    }
}

int st_lookup_int	(	st_table *	,
		char *	,
		int *
	)

Definition at line 156 of file st.c.

{
    int hash_val;
    register st_table_entry *ptr, **last;

    hash_val = do_hash(key, table);

    FIND_ENTRY(table, hash_val, key, ptr, last);
    
    if (ptr == NULL) {
        return 0;
    } else {
        if (value != 0) {
            *value = (long) ptr->record;
        }
        return 1;
    }
}

int st_numcmp	(	char *	,
		char *
	)

Definition at line 528 of file st.c.

{
    return ST_NUMCMP(x, y);
}

int st_numhash	(	char *	,
		int
	)

Definition at line 512 of file st.c.

{
    return ST_NUMHASH(x, size);
}

int st_ptrcmp	(	char *	,
		char *
	)

Definition at line 536 of file st.c.

{
    return ST_NUMCMP(x, y);
}

int st_ptrhash	(	char *	,
		int
	)

Definition at line 520 of file st.c.

{
    return ST_PTRHASH(x, size);
}

int st_strhash	(	char *	,
		int
	)

Definition at line 497 of file st.c.

{
    register int val = 0;
    register int c;
    
    while ((c = *string++) != '\0') {
        val = val*997 + c;
    }

    return ((val < 0) ? -val : val)%modulus;
}

---

Variable Documentation

enum st_retval(* ST_PFSR)()