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 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> ARRAYS <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 139
 140
 141 bool binary_search_array( int *array, int array_size, int val )
 142 {
 143     /* Martin A. Hansen, June 2008 */
 144
 145     /* Binary search an array of integers for an integer value. */
 146
 147     int high;
 148     int low;
 149     int try;
 150
 151     high = array_size;
 152     low  = 0;
 153
 154     while ( low < high )
 155     {
 156         try = ( ( high + low ) / 2 );
 157
 158         if ( val < array[ try ] ) {
 159             high = try;
 160         } else if ( val > array[ try ] ) {
 161             low = try + 1;
 162         } else {
 163             return TRUE;
 164         }
 165     }
 166
 167     return FALSE;
 168 }
 169
 170
 171 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> MISC <<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/
 172
 173
 174 void chop( char *string )
 175 {
 176     /* Martin A. Hansen, June 2008 */
 177
 178     /* Removes the last char from a string. */
 179
 180     int len;
 181
 182     len = strlen( string );
 183
 184     string[ len - 1 ] = '\0';
 185 }
 186
 187
 188 void chomp( char *string )
 189 {
 190     /* Martin A. Hansen, June 2008 */
 191
 192     /* Removes the last char from a string if the char is a newline. */
 193
 194     int len;
 195
 196     len = strlen( string );
 197
 198     if ( string[ len - 1 ] == '\n' ) {
 199         string[ len - 1 ] = '\0';
 200     }
 201 }
 202
 203
 204 void split( char *string, char delimit, struct list **fields )
 205 {
 206     /* Martin A. Hansen, June 2008 */
 207
 208     /* Split a given line and a delimiter return the split result as a list. */
 209
 210     int i;
 211     int j;
 212
 213     char field[ 256 ] = "";
 214     char *field_copy;
 215
 216     j = 0;
 217
 218     for ( i = 0; string[ i ]; i++ )
 219     {
 220         if ( string[ i ] != delimit )
 221         {
 222             field[ j ] = string[ i ];
 223
 224             j++;
 225         }
 226         else
 227         {
 228             field_copy = mem_clone( field, j + 1 );
 229
 230             list_add( fields, field_copy );
 231
 232             ZERO( field );
 233
 234             j = 0;
 235         }
 236     }
 237
 238     field_copy = mem_clone( field, j + 1 );
 239
 240     list_add( fields, field_copy );
 241
 242     list_reverse( fields );
 243 }
 244
 245
 246 char *substr( char *string, int offset, int len )
 247 {
 248     /* Martin A. Hansen, May 2008 */
 249
 250     /* Create equavalent of Perls substr command. */
 251     /* Currently implemented without optional length */
 252     /* and the replace feature. */
 253
 254     int  string_len;
 255     int  i;
 256     int  j;
 257     char *substr;
 258
 259     string_len = strlen( string );
 260
 261     if ( offset < 0 ) {
 262         die( "substr offset < 0." );
 263     } else if ( len < 0 ) {
 264         die( "substr length < 0." );
 265     } else if ( offset > string_len ) {
 266         die( "substr offset outside string." );
 267     } else if ( offset + len > string_len ) {
 268         die( "substr offset + len outside string." );
 269     }
 270
 271     substr = mem_get( len + 1 );
 272
 273     i = offset;
 274     j = 0;
 275
 276     while ( i < offset + len )
 277     {
 278         substr[ j ] = string[ i ];
 279
 280         i++;
 281         j++;
 282     }
 283
 284     substr[ j ] = '\0';
 285
 286     return substr;
 287 }
 288
 289
 290 char *bits2string( uint bin )
 291 {
 292     /* Martin A. Hansen, June 2008 */
 293
 294     /* Return a binary number as a string of 1's and 0's. */
 295
 296     int   i;
 297     uint  j;
 298     char *string;
 299
 300     string = mem_get( ( sizeof( uint ) * 8 ) + 1 );
 301
 302     j = 1;
 303
 304     for ( i = 0; i < sizeof( uint ) * 8; i++ )
 305     {
 306
 307         if ( ( bin & j ) != 0 ) {
 308             string[ 31 - i ] = '1';
 309         } else {
 310             string[ 31 - i ] = '0';
 311         }
 312
 313         j <<= 1;
 314     }
 315
 316     string[ i ] = '\0';
 317
 318     return string;
 319 }
 320
 321
 322 /* >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<*/