code_c/Maasha/src/lib/common.c

   1 #include "common.h"
   2 #include "list.h"
   3
   4
   5 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ERROR HANDLING <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
   6
   7
   8 void die( char *msg )
   9 {
  10     /* Martin A. Hansen, May 2008 */
  11
  12     /* Print error message and exits. */
  13
  14     fprintf( stderr, "ERROR: %s\n", msg );
  15
  16     exit( 1 );
  17 }
  18
  19
  20 void warn( char *msg )
  21 {
  22     /* Martin A. Hansen, May 2008 */
  23
  24     /* Print warning message and exits. */
  25
  26     fprintf( stderr, "WARNING: %s\n", msg );
  27 }
  28
  29
  30 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MEMORY HANDLING <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
  31
  32
  33 void *mem_get( size_t size )
  34 {
  35     /* Martin A. Hansen, May 2008 */
  36
  37     /* Allocate a given chunk of memory to a pointer that is returned. */
  38
  39     void *pt;
  40
  41     if ( size == 0 ) {
  42         die( "could not allocate 0 bytes of memory." );
  43     } else if ( ( pt = malloc( size ) ) == NULL ) {
  44         die( "could not allocate memory." );
  45     }
  46
  47     return pt;
  48 }
  49
  50
  51 void *mem_get_zero( size_t size )
  52 {
  53     /* Martin A. Hansen, May 2008 */
  54
  55     /* Allocate a given chunk of zero'ed memory to a pointer that is returned. */
  56
  57     void *pt;
  58
  59     if ( size == 0 ) {
  60         die( "could not allocate 0 bytes of memory." );
  61     } else if ( ( pt = malloc( size ) ) == NULL ) {
  62         die( "could not allocate memory." );
  63     }
  64
  65     memset( pt, '\0', size );
  66
  67     return pt;
  68 }
  69
  70
  71 void *mem_resize( void *pt, size_t size )
  72 {
  73     /* Martin A. Hansen, May 2008 */
  74
  75     /* Resize an allocated chunk of memory for a given pointer and new size. */
  76
  77     void *pt_new;
  78
  79     if ( size == 0 ) {
  80         die( "could not re-allocate 0 bytes of memory." );
  81     } else if ( ( pt_new = realloc( pt, size ) ) == NULL ) {
  82         die( "could not re-allocate memory." );
  83     }
  84
  85     return pt_new;
  86 }
  87
  88
  89 void *mem_resize_zero( void *pt, size_t old_size, size_t new_size )
  90 {
  91     /* Martin A. Hansen, May 2008 */
  92
  93     /* Resize an allocated chunk of memory for a given pointer and zero any extra memory. */
  94
  95     void *pt_new;
  96
  97     pt_new = mem_resize( pt, new_size );
  98
  99     if ( new_size > old_size ) {
 100         memset( ( ( void * ) pt_new ) + old_size, '\0', new_size - old_size );
 101     }
 102
 103     return pt_new;
 104 }
 105
 106
 107 void *mem_clone( void *old_pt, size_t size )
 108 {
 109     /* Martin A. Hansen, June 2008 */
 110
 111     /* Clone a structure in memory and return a pointer to the clone. */
 112
 113     void *new_pt;
 114
 115     new_pt = mem_get( size );
 116
 117     memcpy( new_pt, old_pt, size );
 118
 119     return new_pt;
 120 }
 121
 122
 123 void mem_free( void *pt )
 124 {
 125     /* Martin A. Hansen, May 2008 */
 126
 127     /* Free memory from a given pointer. */
 128
 129     if ( pt != NULL )
 130     {
 131         free( pt );
 132
 133         pt = NULL;
 134     }
 135 }
 136
 137
 138 void mem_free_zero( void *pt )
 139 {
 140     /* Martin A. Hansen, July 2008 */
 141
 142     /* Zero and then free memory from a given pointer. */
 143
 144     if ( pt != NULL )
 145     {
 146         ZERO( pt );
 147         free( pt );
 148
 149         pt = NULL;
 150     }
 151 }
 152
 153
 154 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ARRAYS <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 155
 156
 157 bool binary_search_array( int *array, int array_size, int val )
 158 {
 159     /* Martin A. Hansen, June 2008 */
 160
 161     /* Binary search an array of integers for an integer value. */
 162
 163     int high;
 164     int low;
 165     int try;
 166
 167     high = array_size;
 168     low  = 0;
 169
 170     while ( low < high )
 171     {
 172         try = ( ( high + low ) / 2 );
 173
 174         if ( val < array[ try ] ) {
 175             high = try;
 176         } else if ( val > array[ try ] ) {
 177             low = try + 1;
 178         } else {
 179             return TRUE;
 180         }
 181     }
 182
 183     return FALSE;
 184 }
 185
 186
 187 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MISC <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 188
 189
 190 void chop( char *string )
 191 {
 192     /* Martin A. Hansen, June 2008 */
 193
 194     /* Removes the last char from a string. */
 195
 196     int len;
 197
 198     len = strlen( string );
 199
 200     string[ len - 1 ] = '\0';
 201 }
 202
 203
 204 void chomp( char *string )
 205 {
 206     /* Martin A. Hansen, June 2008 */
 207
 208     /* Removes the last char from a string if the char is a newline. */
 209
 210     int len;
 211
 212     len = strlen( string );
 213
 214     if ( string[ len - 1 ] == '\n' ) {
 215         string[ len - 1 ] = '\0';
 216     }
 217 }
 218
 219
 220 void split( char *string, char delimit, struct list **fields )
 221 {
 222     /* Martin A. Hansen, June 2008 */
 223
 224     /* Split a given line and a delimiter return the split result as a list. */
 225
 226     int i;
 227     int j;
 228
 229     char field[ 256 ] = "";
 230     char *field_copy;
 231
 232     j = 0;
 233
 234     for ( i = 0; string[ i ]; i++ )
 235     {
 236         if ( string[ i ] != delimit )
 237         {
 238             field[ j ] = string[ i ];
 239
 240             j++;
 241         }
 242         else
 243         {
 244             field_copy = mem_clone( field, j + 1 );
 245
 246             list_add( fields, field_copy );
 247
 248             ZERO( field );
 249
 250             j = 0;
 251         }
 252     }
 253
 254     field_copy = mem_clone( field, j + 1 );
 255
 256     list_add( fields, field_copy );
 257
 258     list_reverse( fields );
 259 }
 260
 261
 262 char *substr( char *string, int offset, int len )
 263 {
 264     /* Martin A. Hansen, May 2008 */
 265
 266     /* Create equavalent of Perls substr command. */
 267     /* Currently implemented without optional length */
 268     /* and the replace feature. */
 269
 270     int  string_len;
 271     int  i;
 272     int  j;
 273     char *substr;
 274
 275     string_len = strlen( string );
 276
 277     if ( offset < 0 ) {
 278         die( "substr offset < 0." );
 279     } else if ( len < 0 ) {
 280         die( "substr length < 0." );
 281     } else if ( offset > string_len ) {
 282         die( "substr offset outside string." );
 283     } else if ( offset + len > string_len ) {
 284         die( "substr offset + len outside string." );
 285     }
 286
 287     substr = mem_get( len + 1 );
 288
 289     i = offset;
 290     j = 0;
 291
 292     while ( i < offset + len )
 293     {
 294         substr[ j ] = string[ i ];
 295
 296         i++;
 297         j++;
 298     }
 299
 300     substr[ j ] = '\0';
 301
 302     return substr;
 303 }
 304
 305
 306 char *bits2string( uint bin )
 307 {
 308     /* Martin A. Hansen, June 2008 */
 309
 310     /* Return a binary number as a string of 1's and 0's. */
 311
 312     int   i;
 313     uint  j;
 314     char *string;
 315
 316     string = mem_get( ( sizeof( uint ) * 8 ) + 1 );
 317
 318     j = 1;
 319
 320     for ( i = 0; i < sizeof( uint ) * 8; i++ )
 321     {
 322
 323         if ( ( bin & j ) != 0 ) {
 324             string[ 31 - i ] = '1';
 325         } else {
 326             string[ 31 - i ] = '0';
 327         }
 328
 329         j <<= 1;
 330     }
 331
 332     string[ i ] = '\0';
 333
 334     return string;
 335 }
 336
 337
 338 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/