st.h File Reference

#include "misc/util/abc_global.h"

Include dependency graph for st.h:

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

Go to the source code of this file.

Classes
struct	st__table_entry
struct	st__table
struct	st__generator

Macros
#define	st__INCLUDED
#define	EXTERN   extern
#define	ARGS(protos)
#define	st__is_member(table, key)
#define	st__count(table)
#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)
#define	st__foreach_item_int(table, gen, key, value)
#define	st__OUT_OF_MEM   -10000

Typedefs
typedef int(*	st__compare_func_type) (const char *, const char *)
typedef int(*	st__hash_func_type) (const char *, int)
typedef struct st__table_entry	st__table_entry
typedef struct st__table	st__table
typedef struct st__generator	st__generator
typedef enum st__retval(*	st__PFSR) (char *, char *, char *)
typedef int(*	st__PFI) ()

Enumerations
enum	st__retval { st__CONTINUE , st__STOP , st__DELETE }

Functions
st__table *	st__init_table_with_params (st__compare_func_type compare, st__hash_func_type hash, int size, int density, double grow_factor, int reorder_flag)
st__table *	st__init_table (st__compare_func_type, st__hash_func_type)
void	st__free_table (st__table *)
int	st__lookup (st__table *, const char *, char **)
int	st__lookup_int (st__table *, char *, int *)
int	st__insert (st__table *, const 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 *, const char **, char **)
int	st__delete_int (st__table *, long *, char **)
int	st__foreach (st__table *, st__PFSR, char *)
int	st__strhash (const char *, int)
int	st__numhash (const char *, int)
int	st__ptrhash (const char *, int)
int	st__numcmp (const char *, const char *)
int	st__ptrcmp (const char *, const char *)
st__generator *	st__init_gen (st__table *)
int	st__gen (st__generator *, const char **, char **)
int	st__gen_int (st__generator *, const char **, long *)
void	st__free_gen (st__generator *)

Macro Definition Documentation

ARGS

#define ARGS

(

protos

)

Value:

protos

Definition at line 37 of file st.h.

EXTERN

#define EXTERN   extern

Definition at line 32 of file st.h.

st__count

#define st__count

(

table

)

Value:

((table)->num_entries)

Definition at line 71 of file st.h.

st__DEFAULT_GROW_FACTOR

#define st__DEFAULT_GROW_FACTOR   2.0

Definition at line 104 of file st.h.

st__DEFAULT_INIT_TABLE_SIZE

#define st__DEFAULT_INIT_TABLE_SIZE   11

Definition at line 103 of file st.h.

st__DEFAULT_MAX_DENSITY

#define st__DEFAULT_MAX_DENSITY   5

Definition at line 102 of file st.h.

st__DEFAULT_REORDER_FLAG

#define st__DEFAULT_REORDER_FLAG   0

Definition at line 105 of file st.h.

st__foreach_item

#define st__foreach_item	(		table,
			gen,
			key,
			value )

Value:

    for(gen= st__init_gen(table); st__gen(gen,key,value) || ( st__free_gen(gen),0);)

Definition at line 107 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);)

st__foreach_item_int

#define st__foreach_item_int	(		table,
			gen,
			key,
			value )

Value:

    for(gen= st__init_gen(table); st__gen_int(gen,key,value) || ( st__free_gen(gen),0);)

Definition at line 110 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);)

st__INCLUDED

#define st__INCLUDED

Definition at line 16 of file st.h.

st__is_member

#define st__is_member	(		table,
			key )

Value:

st__lookup(table,key,(char **) 0)

Definition at line 70 of file st.h.

st__OUT_OF_MEM

#define st__OUT_OF_MEM   -10000

Definition at line 113 of file st.h.

Typedef Documentation

st__compare_func_type

typedef int(* st__compare_func_type) (const char *, const char *)

Definition at line 41 of file st.h.

st__generator

typedef struct st__generator st__generator

Definition at line 63 of file st.h.

st__hash_func_type

typedef int(* st__hash_func_type) (const char *, int)

Definition at line 42 of file st.h.

st__PFI

typedef int(* st__PFI) ()

Definition at line 76 of file st.h.

st__PFSR

typedef enum st__retval(* st__PFSR) (char *, char *, char *)

Definition at line 63 of file st.h.

st__table

typedef struct st__table st__table

Definition at line 51 of file st.h.

st__table_entry

typedef struct st__table_entry st__table_entry

Definition at line 44 of file st.h.

Enumeration Type Documentation

st__retval

enum st__retval

Enumerator
st__CONTINUE
st__STOP
st__DELETE

Definition at line 73 of file st.h.

{ st__CONTINUE, st__STOP, st__DELETE};

Function Documentation

st__add_direct()

int st__add_direct ( st__table * table, char * key, char * value )

extern

Definition at line 205 of file st.c.

{
    int hash_val;
    st__table_entry *newEntry;
    
    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);
    newEntry = ABC_ALLOC( st__table_entry, 1);
    if (newEntry == NULL) {
    return st__OUT_OF_MEM;
    }
    newEntry->key = key;
    newEntry->record = value;
    newEntry->next = table->bins[hash_val];
    table->bins[hash_val] = newEntry;
    table->num_entries++;
    return 1;
}

st__copy()

st__table * st__copy ( st__table * old_table )

extern

Definition at line 330 of file st.c.

{
    st__table *newEntry_table;
    st__table_entry *ptr, *newEntryptr, *next, *newEntry;
    int i, j, num_bins = old_table->num_bins;
 
    newEntry_table = ABC_ALLOC( st__table, 1);
    if (newEntry_table == NULL) {
    return NULL;
    }
    
    *newEntry_table = *old_table;
    newEntry_table->bins = ABC_ALLOC( st__table_entry *, num_bins);
    if (newEntry_table->bins == NULL) {
    ABC_FREE(newEntry_table);
    return NULL;
    }
    for(i = 0; i < num_bins ; i++) {
    newEntry_table->bins[i] = NULL;
    ptr = old_table->bins[i];
    while (ptr != NULL) {
        newEntry = ABC_ALLOC( st__table_entry, 1);
        if (newEntry == NULL) {
        for (j = 0; j <= i; j++) {
            newEntryptr = newEntry_table->bins[j];
            while (newEntryptr != NULL) {
            next = newEntryptr->next;
            ABC_FREE(newEntryptr);
            newEntryptr = next;
            }
        }
        ABC_FREE(newEntry_table->bins);
        ABC_FREE(newEntry_table);
        return NULL;
        }
        *newEntry = *ptr;
        newEntry->next = newEntry_table->bins[i];
        newEntry_table->bins[i] = newEntry;
        ptr = ptr->next;
    }
    }
    return newEntry_table;
}

st__delete()

int st__delete ( st__table * table, const char ** keyp, char ** value )

extern

Definition at line 375 of file st.c.

{
    int hash_val;
    const char *key = *keyp;
    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;
    ABC_FREE(ptr);
    table->num_entries--;
    return 1;
}

Here is the caller graph for this function:

st__delete_int()

int st__delete_int ( st__table * table, long * keyp, char ** value )

extern

Definition at line 398 of file st.c.

{
    int hash_val;
    char *key = (char *) *keyp;
    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;
    ABC_FREE(ptr);
    table->num_entries--;
    return 1;
}

st__find()

int st__find ( st__table * table, char * key, char *** slot )

extern

Definition at line 264 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;
    }
}

Here is the caller graph for this function:

st__find_or_add()

int st__find_or_add ( st__table * table, char * key, char *** slot )

extern

Definition at line 230 of file st.c.

{
    int hash_val;
    st__table_entry *newEntry, *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);
    }
    newEntry = ABC_ALLOC( st__table_entry, 1);
    if (newEntry == NULL) {
        return st__OUT_OF_MEM;
    }
    newEntry->key = key;
    newEntry->record = (char *) 0;
    newEntry->next = table->bins[hash_val];
    table->bins[hash_val] = newEntry;
    table->num_entries++;
    if (slot != NULL) *slot = &newEntry->record;
    return 0;
    } else {
    if (slot != NULL) *slot = &ptr->record;
    return 1;
    }
}

Here is the caller graph for this function:

st__foreach()

int st__foreach ( st__table * , st__PFSR , char *  )

extern

st__free_gen()

void st__free_gen ( st__generator * gen )

extern

Definition at line 555 of file st.c.

{
    ABC_FREE(gen);
}

Here is the caller graph for this function:

st__free_table()

void st__free_table ( st__table * table )

extern

Definition at line 81 of file st.c.

{
    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;
        ABC_FREE(ptr);
        ptr = next;
    }
    }
    ABC_FREE(table->bins);
    ABC_FREE(table);
}

Here is the caller graph for this function:

st__gen()

int st__gen ( st__generator * gen, const char ** key_p, char ** value_p )

extern

Definition at line 501 of file st.c.

{
    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;
}

Here is the caller graph for this function:

st__gen_int()

int st__gen_int ( st__generator * gen, const char ** key_p, long * value_p )

extern

Definition at line 528 of file st.c.

{
    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__init_gen()

st__generator * st__init_gen ( st__table * table )

extern

Definition at line 485 of file st.c.

{
    st__generator *gen;
 
    gen = ABC_ALLOC( st__generator, 1);
    if (gen == NULL) {
    return NULL;
    }
    gen->table = table;
    gen->entry = NULL;
    gen->index = 0;
    return gen;
}

Here is the caller graph for this function:

st__init_table()

st__table * st__init_table ( st__compare_func_type compare, st__hash_func_type hash )

extern

Definition at line 72 of file st.c.

{
    return st__init_table_with_params(compare, hash, st__DEFAULT_INIT_TABLE_SIZE,
                     st__DEFAULT_MAX_DENSITY,
                     st__DEFAULT_GROW_FACTOR,
                     st__DEFAULT_REORDER_FLAG);
}

Here is the call graph for this function:

Here is the caller graph for this function:

st__init_table_with_params()

st__table * st__init_table_with_params ( st__compare_func_type compare, st__hash_func_type hash, int size, int density, double grow_factor, int reorder_flag )

extern

Definition at line 41 of file st.c.

{
    int i;
    st__table *newTable;
 
    newTable = ABC_ALLOC( st__table, 1);
    if (newTable == NULL) {
    return NULL;
    }
    newTable->compare = compare;
    newTable->hash = hash;
    newTable->num_entries = 0;
    newTable->max_density = density;
    newTable->grow_factor = grow_factor;
    newTable->reorder_flag = reorder_flag;
    if (size <= 0) {
    size = 1;
    }
    newTable->num_bins = size;
    newTable->bins = ABC_ALLOC( st__table_entry *, size);
    if (newTable->bins == NULL) {
    ABC_FREE(newTable);
    return NULL;
    }
    for(i = 0; i < size; i++) {
    newTable->bins[i] = 0;
    }
    return newTable;
}

Here is the caller graph for this function:

st__insert()

int st__insert ( st__table * table, const char * key, char * value )

extern

Definition at line 171 of file st.c.

{
    int hash_val;
    st__table_entry *newEntry;
    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);
    }
    newEntry = ABC_ALLOC( st__table_entry, 1);
    if (newEntry == NULL) {
        return st__OUT_OF_MEM;
    }
    newEntry->key = (char *)key;
    newEntry->record = value;
    newEntry->next = table->bins[hash_val];
    table->bins[hash_val] = newEntry;
    table->num_entries++;
    return 0;
    } else {
    ptr->record = value;
    return 1;
    }
}

Here is the caller graph for this function:

st__lookup()

int st__lookup ( st__table * table, const char * key, char ** value )

extern

Definition at line 114 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 (value != NULL) {
        *value = ptr->record; 
    }
    return 1;
    }
}

Here is the caller graph for this function:

st__lookup_int()

int st__lookup_int ( st__table * table, char * key, int * value )

extern

Definition at line 134 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 (value != 0) {
        *value = (long) ptr->record;
    }
    return 1;
    }
}

Here is the caller graph for this function:

st__numcmp()

int st__numcmp ( const char * x, const char * y )

extern

Definition at line 473 of file st.c.

{
    return st__NUMCMP(x, y);
}

Here is the caller graph for this function:

st__numhash()

int st__numhash ( const char * x, int size )

extern

Definition at line 461 of file st.c.

{
    return st__NUMHASH(x, size);
}

Here is the caller graph for this function:

st__ptrcmp()

int st__ptrcmp ( const char * x, const char * y )

extern

Definition at line 479 of file st.c.

{
    return st__NUMCMP(x, y);
}

Here is the caller graph for this function:

st__ptrhash()

int st__ptrhash ( const char * x, int size )

extern

Definition at line 467 of file st.c.

{
    return st__PTRHASH(x, size);
}

Here is the caller graph for this function:

st__strhash()

int st__strhash ( const char * string, int modulus )

extern

Definition at line 449 of file st.c.

{
    unsigned char * ustring = (unsigned char *)string;
    unsigned c, val = 0;
    assert( modulus > 0 );    
    while ((c = *ustring++) != '\0') {
        val = val*997 + c;
    }
    return (int)(val%modulus);
}

Here is the caller graph for this function: