util.h

Go to the documentation of this file.

#ifndef FISH_UTIL_H
#define FISH_UTIL_H

#include <wchar.h>
#include <stdarg.h>
#include <unistd.h>

typedef void (*func_ptr_t)();

typedef union 
{
        long long_val;
        void *ptr_val;
        func_ptr_t func_val;
}
        anything_t;


typedef struct dyn_queue
{
        void **start;
        void **stop;
        void **put_pos;
        void **get_pos;
}
        dyn_queue_t;

typedef struct
{
        void *key;
        void *data;
}
        hash_struct_t;

typedef struct hash_table
{
        hash_struct_t *arr;
        int cache;      
        int count;
        int size;
        int (*hash_func)( void *key );
        int (*compare_func)( void *key1, void *key2 );
}
        hash_table_t;

typedef struct priority_queue
{
        void **arr;
        int count;
        int size;
        int (*compare)(void *e1, void *e2);
}
priority_queue_t;

typedef struct array_list
{
        anything_t *arr;
        
        size_t pos;

        size_t size;
}
array_list_t;

typedef struct _ll_node
{
        struct _ll_node *next,  *prev;
        void *data;
}
ll_node_t;

typedef struct buffer
{
        char *buff; 
        size_t length; 
        size_t used; 
}
buffer_t;


typedef buffer_t string_buffer_t;

void (*util_set_oom_handler( void (*h)(void *) ))(void *);

void util_die_on_oom( void *p );

int maxi( int a, int b );

int mini( int a, int b );

/*
  All the datastuctures below autoresize. The queue, stack and
  priority queue are all impemented using an array and are guaranteed
  to never be less than 50% full. 
*/

void q_init( dyn_queue_t *q );

void q_destroy( dyn_queue_t *q );

int q_put( dyn_queue_t *q, void *e );

void *q_get( dyn_queue_t *q);

void *q_peek( dyn_queue_t *q);

int q_empty( dyn_queue_t *q );

void hash_init( hash_table_t *h,
                                int (*hash_func)( void *key),
                                int (*compare_func)( void *key1, void *key2 ) );

void hash_init2( hash_table_t *h,
                                int (*hash_func)( void *key ),
                                 int (*compare_func)( void *key1, void *key2 ),
                                 size_t capacity);

void hash_destroy( hash_table_t *h );
int hash_put( hash_table_t *h, 
                          const void *key,
                          const void *data );
void *hash_get( hash_table_t *h,
                                const void *key );
void *hash_get_key( hash_table_t *h, 
                                        const void *key );

int hash_get_count( hash_table_t *h);
void hash_remove( hash_table_t *h, 
                                  const void *key, 
                                  void **old_key,
                                  void **old_data );

int hash_contains( hash_table_t *h, 
                                   const void *key );

void hash_get_keys( hash_table_t *h,
                                        array_list_t *arr );

void hash_get_data( hash_table_t *h,
                                        array_list_t *arr );

void hash_foreach( hash_table_t *h, 
                                   void (*func)( void *, void * ) );

void hash_foreach2( hash_table_t *h, void (*func)( void *, 
                                                                                                   void *, 
                                                                                                   void *), 
                                        void *aux );

int hash_str_func( void *data );
int hash_str_cmp( void *a,
                                  void *b );

int hash_wcs_func( void *data );

int hash_wcs_cmp( void *a, 
                                  void *b );

int hash_ptr_func( void *data );


int hash_ptr_cmp( void *a,
                  void *b );



void pq_init( priority_queue_t *q,
                          int (*compare)(void *e1, void *e2) );
int pq_put( priority_queue_t *q,
                        void *e );
void *pq_get( priority_queue_t *q );

void *pq_peek( priority_queue_t *q );

int pq_empty( priority_queue_t *q );

int pq_get_count( priority_queue_t *q );

void pq_destroy(  priority_queue_t *q );

array_list_t *al_new();

void al_init( array_list_t *l );

void al_destroy( array_list_t *l );

int al_push( array_list_t *l, const void *o );
int al_push_long( array_list_t *l, long o );
int al_push_func( array_list_t *l, func_ptr_t f );

int al_push_all( array_list_t *a, array_list_t *b );

int al_insert( array_list_t *a, int pos, int count );

int al_set( array_list_t *l, int pos, const void *o );
int al_set_long( array_list_t *l, int pos, long v );
int al_set_func( array_list_t *l, int pos, func_ptr_t f );

void *al_get( array_list_t *l, int pos );
long al_get_long( array_list_t *l, int pos );
func_ptr_t al_get_func( array_list_t *l, int pos );

void al_truncate( array_list_t *l, int new_sz );

void *al_pop( array_list_t *l );
long al_pop_long( array_list_t *l );
func_ptr_t al_pop_func( array_list_t *l );

int al_get_count( array_list_t *l );

void *al_peek( array_list_t *l );
long al_peek_long( array_list_t *l );
func_ptr_t al_peek_func( array_list_t *l );

int al_empty( array_list_t *l);

void al_foreach( array_list_t *l, void (*func)( void * ));

void al_foreach2( array_list_t *l, void (*func)( void *, void *), void *aux);

int wcsfilecmp( const wchar_t *a, const wchar_t *b );


/*
  String buffer functions
*/

void sb_init( string_buffer_t * );

string_buffer_t *sb_new();

void sb_append_substring( string_buffer_t *, const wchar_t *, size_t );

void sb_append_char( string_buffer_t *, wchar_t );

#define sb_append( sb,... ) sb_append_internal( sb, __VA_ARGS__, (void *)0 )

__sentinel void sb_append_internal( string_buffer_t *, ... );

int sb_printf( string_buffer_t *buffer, const wchar_t *format, ... );

int sb_vprintf( string_buffer_t *buffer, const wchar_t *format, va_list va_orig );

void sb_destroy( string_buffer_t * );

void sb_clear( string_buffer_t * );

void sb_truncate( string_buffer_t *, int chars_left );

ssize_t sb_length( string_buffer_t * );


/*
  Buffer functions
*/

void b_init( buffer_t *b);

void b_destroy( buffer_t *b );

int b_append( buffer_t *b, const void *d, ssize_t len );

long long get_time();

#endif

---