/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MISC <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
-/* Split a given line and a delimiter return the split result as a list. */
-void split( char *string, char delimit, struct list **fields );
-
-/* Mockup version of Perl substr. */
-char *substr( char *string, int offset, int len );
-
/* Return a binary number as a string of 1's and 0's. */
char *bits2string( uint bin );
-/* Macro for dynamic allocation of memory. */
-#define MEM_GET( pt ) ( pt = mem_get( sizeof( *pt ) ) )
-
-/* Macro for resetting a pointer to all \0's. */
-#define MEM_ZERO( pt ) ( memset( pt, '\0', sizeof( *pt ) ) )
-
-/* Macro for cloning a structure in memroy. */
-#define MEM_CLONE( pt ) mem_clone( pt, sizeof( ( pt )[ 0 ] ) )
-
/* Get a pointer with a given size of allocated memory. */
void *mem_get( size_t size );
void *mem_get_zero( size_t size );
/* Resize allocated memory for a given pointer. */
-void *mem_resize( void* pt, size_t size );
+void *mem_resize( void *pt, size_t size );
/* Resize allocated memory for a given pointer with extra memory zero'ed. */
-void *mem_resize_zero( void* pt, size_t old_size, size_t new_size );
+void *mem_resize_zero( void *pt, size_t old_size, size_t new_size );
/* Clone a structure in memory and return a pointer to the clone. */
void *mem_clone( void *old_pt, size_t size );
/* Free memory from a given pointer. */
-void mem_free( void *pt );
-
-/* Zero and then free memory from a given pointer. */
-void mem_free_zero( void *pt );
+void mem_free( void **ppt );
/* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MISC <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
-void split( char *string, char delimit, struct list **fields )
-{
- /* Martin A. Hansen, June 2008 */
-
- /* Split a given line and a delimiter return the split result as a list. */
-
- int i;
- int j;
-
- char field[ 256 ] = "";
- char *field_copy;
-
- j = 0;
-
- for ( i = 0; string[ i ]; i++ )
- {
- if ( string[ i ] != delimit )
- {
- field[ j ] = string[ i ];
-
- j++;
- }
- else
- {
- field_copy = mem_clone( field, j + 1 );
-
- list_add( fields, field_copy );
-
- MEM_ZERO( field );
-
- j = 0;
- }
- }
-
- field_copy = mem_clone( field, j + 1 );
-
- list_add( fields, field_copy );
-
- list_reverse( fields );
-}
-
-
-char *substr( char *string, int offset, int len )
-{
- /* Martin A. Hansen, May 2008 */
-
- /* Create equavalent of Perls substr command. */
- /* Currently implemented without optional length */
- /* and the replace feature. */
-
- int string_len;
- int i;
- int j;
- char *substr;
-
- string_len = strlen( string );
-
- if ( offset < 0 ) {
- die( "substr offset < 0." );
- } else if ( len < 0 ) {
- die( "substr length < 0." );
- } else if ( offset > string_len ) {
- die( "substr offset outside string." );
- } else if ( offset + len > string_len ) {
- die( "substr offset + len outside string." );
- }
-
- substr = mem_get( len + 1 );
-
- i = offset;
- j = 0;
-
- while ( i < offset + len )
- {
- substr[ j ] = string[ i ];
-
- i++;
- j++;
- }
-
- substr[ j ] = '\0';
-
- return substr;
-}
-
-
char *bits2string( uint bin )
{
/* Martin A. Hansen, June 2008 */
char *seq_name = NULL;
char *seq = NULL;
- MEM_GET( entry );
+ entry = mem_get( sizeof( entry ) );
offset = ftell( fp );
while ( 1 )
{
- MEM_GET( entry );
+ entry = mem_get( sizeof( entry ) );
if ( ! fasta_get_entry( fp, entry ) ) {
break;
/* Deallocates memory from a seq_entry. */
- mem_free( entry->seq_name );
- mem_free( entry->seq );
- mem_free( entry );
+ mem_free( ( void * ) &entry->seq_name );
+ mem_free( ( void * ) &entry->seq );
+ mem_free( ( void * ) &entry );
}
char *str;
bool eof;
- MEM_GET( buffer );
+ buffer = mem_get( sizeof( buffer ) );
fp = read_open( file );
buffer->end = new_end;
- mem_free( str );
+ mem_free( ( void * ) &str );
}
close_stream( buffer->fp );
- mem_free( buffer->str );
- mem_free( buffer );
+ mem_free( ( void * ) &buffer->str );
+ mem_free( ( void * ) &buffer );
}
struct hash *new_hash;
int table_size;
- MEM_GET( new_hash );
+ new_hash = mem_get( sizeof( new_hash ) );
table_size = 1 << size; /* table_size = ( 2 ** size ) */
}
else
{
- MEM_GET( new_elem );
+ new_elem = mem_get( sizeof( new_elem ) );
hash_index = ( hash_key( key ) & myhash->mask );
{
for ( bucket = myhash->table[ i ]; bucket != NULL; bucket = bucket->next )
{
- mem_free( bucket->key );
+ mem_free( ( void * ) &bucket->key );
// mem_free( bucket->val );
- mem_free( bucket );
+ mem_free( ( void * ) &bucket );
}
}
- mem_free( myhash->table );
- mem_free( myhash );
+ mem_free( ( void * ) &myhash->table );
+ mem_free( ( void * ) &myhash );
}
struct list *elem = NULL;
- MEM_GET( elem );
+ elem = mem_get( sizeof( elem ) );
elem->val = val;
elem->next = *( list_ppt );
struct list_int *elem = NULL;
- MEM_GET( elem );
+ elem = mem_get( sizeof( elem ) );
elem->val = val;
// elem->next = *( list_ppt );
struct list *elem;
- MEM_GET( elem );
+ elem = mem_get( sizeof( elem ) );
for ( elem = list_pt; elem != NULL; elem = elem->next )
{
struct list_int *elem;
- MEM_GET( elem );
+ elem = mem_get( sizeof( elem ) );
// for ( elem = list_pt; elem != NULL; elem = elem->next )
{
{
elem = next;
next = elem->next;
- mem_free( elem );
+ mem_free( ( void * ) &elem );
}
ppt = NULL;
if ( ( pt = malloc( size ) ) == NULL )
{
- fprintf( stderr, "ERROR: Could not allocate %ld byte(s): %s\n", size, strerror( errno ) );
+ fprintf( stderr, "ERROR: Could not allocate %zu byte(s): %s\n", size, strerror( errno ) );
abort();
}
{
/* Martin A. Hansen, May 2008 */
+ /* Unit test done.*/
+
/* Resize an allocated chunk of memory for a given pointer and new size. */
void *pt_new;
- if ( size == 0 ) {
- die( "could not re-allocate 0 bytes of memory." );
- } else if ( ( pt_new = realloc( pt, size ) ) == NULL ) {
- die( "could not re-allocate memory." );
+ assert( size > 0 );
+
+ if ( ( pt_new = realloc( pt, size ) ) == NULL )
+ {
+ fprintf( stderr, "ERROR: Could not re-allocate %zu byte(s)\n", size );
+ abort();
}
return pt_new;
{
/* Martin A. Hansen, May 2008 */
+ /* Unit test done.*/
+
/* Resize an allocated chunk of memory for a given pointer and zero any extra memory. */
void *pt_new;
{
/* Martin A. Hansen, June 2008 */
+ /* Unit test done.*/
+
/* Clone a structure in memory and return a pointer to the clone. */
void *new_pt;
+ assert( size > 0 );
+
new_pt = mem_get( size );
memcpy( new_pt, old_pt, size );
}
-void mem_free( void *pt )
+void mem_free( void **ppt )
{
/* Martin A. Hansen, May 2008 */
- /* Free memory from a given pointer. */
-
- if ( pt != NULL )
- {
- free( pt );
-
- pt = NULL;
- }
-}
-
-
-void mem_free_zero( void *pt )
-{
- /* Martin A. Hansen, July 2008 */
+ /* Unit test done.*/
- /* Zero and then free memory from a given pointer. */
+ /* Free memory from a given pointer. */
- if ( pt != NULL )
- {
- MEM_ZERO( pt );
- free( pt );
+ free( *ppt );
- pt = NULL;
- }
+ *ppt = NULL;
}
-
-
/* Removes the last char from a string if the char is a newline. */
/* Returns the length of the chomped string or -1 is no newline was found. */
- int len;
+ size_t len;
assert( string != NULL );
assert( string[ 0 ] != '\0' );
char bed_buffer[ BED_BUFFER ];
struct bed_entry12 *bed12 = NULL;
- MEM_GET( bed12 );
+ bed12 = mem_get( sizeof( bed12 ) );
if ( ( fgets( bed_buffer, sizeof( bed_buffer ), fp ) != NULL ) )
{
mask = mask_create( OLIGO_SIZE );
- MEM_GET( entry );
+ entry = mem_get( sizeof( entry ) );
fp = read_open( path );
uint *block;
uint block_pos;
uint block_beg;
+ uint block_size;
uint chr_pos;
mask = mask_create( OLIGO_SIZE );
- MEM_GET( entry );
+ entry = mem_get( sizeof( entry ) );
fp = read_open( path );
{
fprintf( stderr, "Writing results for: %s ... ", entry->seq_name );
- bin = 0;
- j = 0;
- block_pos = 0;
- block = mem_get_zero( sizeof( uint ) * ( entry->seq_len + OLIGO_SIZE ) );
+ bin = 0;
+ j = 0;
+ block_pos = 0;
+ block_size = sizeof( uint ) * ( entry->seq_len + OLIGO_SIZE );
+ block = mem_get_zero( block_size );
for ( i = 0; entry->seq[ i ]; i++ )
{
if ( block_pos == 0 )
{
- MEM_ZERO( block );
+ memset( block, '\0', block_size );
block_beg = chr_pos;
{
fixedstep_put_entry( entry->seq_name, block_beg, 1, block, block_pos );
- mem_free( block );
+ mem_free( ( void * ) &block );
}
fprintf( stderr, "done.\n" );
static void test_mem_get();
static void test_mem_get_zero();
+static void test_mem_resize();
+static void test_mem_resize_zero();
+static void test_mem_clone();
static void test_mem_free();
test_mem_get();
test_mem_get_zero();
+ test_mem_resize();
+ test_mem_resize_zero();
+ test_mem_clone();
test_mem_free();
fprintf( stderr, "Done\n\n" );
size_t len = 1000000000;
char *pt = mem_get( len );
- mem_free( pt );
+ mem_free( ( void * ) &pt );
fprintf( stderr, "OK\n" );
}
assert( pt[ i ] == '\0' );
}
- mem_free( pt );
+ mem_free( ( void * ) &pt );
+
+ fprintf( stderr, "OK\n" );
+}
+
+
+void test_mem_resize()
+{
+ fprintf( stderr, " Testing mem_resize ... " );
+
+ char *pt0 = "foo";
+ char *pt1 = NULL;
+
+ pt1 = mem_get( 3 + 1 );
+
+ memcpy( pt1, pt0, 3 );
+
+ pt1 = mem_resize( pt1, 1 );
+
+ mem_free( ( void * ) &pt1 );
+
+ fprintf( stderr, "OK\n" );
+}
+
+
+void test_mem_resize_zero()
+{
+ fprintf( stderr, " Testing mem_resize_zero ... " );
+
+ size_t i;
+ size_t size_before = 10;
+ size_t size_after = 100000;
+
+ char *pt = NULL;
+
+ pt = mem_get( size_before );
+
+ memset( pt, '1', size_before );
+
+ assert( strlen( pt ) == size_before );
+
+ pt = mem_resize_zero( pt, size_before, size_after );
+
+ assert( strlen( pt ) == size_before );
+
+ for ( i = size_before; i <= size_after; i++ ) {
+ assert( pt[ i ] == '\0' );
+ }
+
+ mem_free( ( void * ) &pt );
+
+ fprintf( stderr, "OK\n" );
+}
+
+
+void test_mem_clone()
+{
+ fprintf( stderr, " Testing mem_clone ... " );
+
+ char *pt;
+ char *pt_clone;
+ size_t pt_size = 10000;
+ size_t i;
+
+ pt = mem_get( pt_size );
+
+ memset( pt, 'X', pt_size );
+
+ pt_clone = mem_clone( pt, pt_size );
+
+ assert( pt_clone != pt );
+ assert( &pt_clone != &pt );
+
+ for ( i = 0; i < pt_size; i++ ) {
+ assert( pt[ i ] == pt_clone[ i ] );
+ }
+
+ mem_free( ( void * ) &pt );
+ mem_free( ( void * ) &pt_clone );
fprintf( stderr, "OK\n" );
}
{
fprintf( stderr, " Testing mem_free ... " );
- void *pt = mem_get( 100 );
+ char *pt0 = "foo";
+ void *pt1 = NULL;
+ char *pt2 = NULL;
+
+ assert( pt0 != NULL );
+ assert( pt1 == NULL );
+ assert( pt2 == NULL );
+
+ pt1 = mem_get( 100 );
+ pt2 = mem_get( 100 );
+
+ assert( pt1 != NULL );
+ assert( pt2 != NULL );
- mem_free( pt );
+ memcpy( pt2, pt0, 3 );
- printf( "pt: %s\n", ( char * ) pt );
+ mem_free( &pt1 );
+ mem_free( &pt1 );
+ mem_free( ( void * ) &pt1 );
+ mem_free( ( void * ) &pt2 );
- assert( pt == NULL );
+ assert( pt1 == NULL );
+ assert( pt2 == NULL );
fprintf( stderr, "OK\n" );
}
projects / biopieces.git / commitdiff