src/st-utils.c

   1 /*
   2  * st-utils.c
   3  *
   4  * Copyright (C) 2008 Vincent Geddes
   5  *
   6  * Permission is hereby granted, free of charge, to any person obtaining a copy
   7  * of this software and associated documentation files (the "Software"), to deal
   8  * in the Software without restriction, including without limitation the rights
   9  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  10  * copies of the Software, and to permit persons to whom the Software is
  11  * furnished to do so, subject to the following conditions:
  12  *
  13  * The above copyright notice and this permission notice shall be included in
  14  * all copies or substantial portions of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  17  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  18  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  19  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  20  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  21  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  22  * THE SOFTWARE.
  23 */
  24
  25 #include "st-utils.h"
  26
  27 #include <sys/stat.h>
  28 #include <string.h>
  29 #include <stdio.h>
  30 #include <errno.h>
  31 #include <error.h>
  32 #include <stdint.h>
  33 #include <stdio.h>
  34 #include <stdlib.h>
  35 #include <fcntl.h>
  36 #include <unistd.h>
  37 #include <stdarg.h>
  38
  39 int vasprintf(char **strp, const char *fmt, va_list ap);
  40
  41 extern char *program_invocation_short_name;
  42
  43 st_pointer
  44 st_malloc (size_t size)
  45 {
  46     void *ptr;
  47
  48     ptr = malloc (size);
  49     if (ST_UNLIKELY (ptr == NULL))
  50         abort ();
  51
  52     return ptr;
  53 }
  54
  55 st_pointer
  56 st_malloc0 (size_t size)
  57 {
  58     void *ptr;
  59
  60     ptr = calloc (1, size);
  61     if (ST_UNLIKELY (ptr == NULL))
  62         abort ();
  63
  64     return ptr;
  65 }
  66
  67 st_pointer
  68 st_realloc (st_pointer mem, size_t size)
  69 {
  70    void *ptr;
  71
  72     ptr = realloc (mem, size);
  73     if (ST_UNLIKELY (ptr == NULL))
  74         abort ();
  75
  76     return ptr;
  77 }
  78
  79 void
  80 st_free (st_pointer mem)
  81 {
  82     if (ST_UNLIKELY (mem != NULL))
  83         free (mem);
  84 }
  85
  86 bool
  87 st_file_get_contents (const char *filename,
  88                       char      **buffer)
  89 {
  90     struct stat info;
  91     size_t  total;
  92     ssize_t count;
  93     char   *temp;
  94     int     fd;
  95
  96     st_assert (filename != NULL);
  97
  98     *buffer = NULL;
  99
 100     if (stat (filename, &info) != 0) {
 101         fprintf (stderr, "%s: error: `%s': %s\n", program_invocation_short_name, filename, strerror (errno));
 102         return false;
 103     }
 104
 105     if (!S_ISREG (info.st_mode)) {
 106         fprintf (stderr, "%s: error: `%s': Not a regular file\n", program_invocation_short_name, filename);
 107         return false;
 108     }
 109
 110     fd = open (filename, O_RDONLY);
 111     if (fd < 0) {
 112         fprintf (stderr, "%s: error: `%s': %s\n", program_invocation_short_name, filename, strerror (errno));
 113         return false;
 114     }
 115
 116     total = 0;
 117     temp = st_malloc (info.st_size + 1);
 118     while (total < info.st_size) {
 119         count = read (fd, temp + total, info.st_size - total);
 120         if (count < 0) {
 121             fprintf (stderr, "%s: error: %s: %s\n", program_invocation_short_name, filename, strerror (errno));
 122             st_free (temp);
 123             close (fd);
 124             return false;
 125         }
 126         total += count;
 127     }
 128
 129     close (fd);
 130
 131     temp[info.st_size] = 0;
 132     *buffer = temp;
 133
 134     return true;
 135 }
 136
 137 /* Derived from eglib (part of Mono)
 138  * Copyright (C) 2006 Novell, Inc.
 139  */
 140 char *
 141 st_strdup (const char *string)
 142 {
 143     size_t  size;
 144     char   *copy;
 145
 146     st_assert (string != NULL);
 147
 148     size = strlen (string);
 149     copy = st_malloc (size + 1);
 150     strcpy (copy, string);
 151
 152     return copy;
 153 }
 154
 155 /* Derived from eglib (part of Mono)
 156  * Copyright (C) 2006 Novell, Inc.
 157  */
 158 char *
 159 st_strdup_vprintf (const char *format, va_list args)
 160 {
 161         int n;
 162         char *ret;
 163
 164         n = vasprintf (&ret, format, args);
 165         if (n == -1)
 166                 return NULL;
 167
 168         return ret;
 169 }
 170
 171 /* Derived from eglib (part of Mono)
 172  * Copyright (C) 2006 Novell, Inc.
 173  */
 174 char *
 175 st_strdup_printf (const char *format, ...)
 176 {
 177         char *ret;
 178         va_list args;
 179         int n;
 180
 181         va_start (args, format);
 182         n = vasprintf (&ret, format, args);
 183         va_end (args);
 184         if (n == -1)
 185                 return NULL;
 186
 187         return ret;
 188 }
 189
 190 /* Derived from eglib (part of Mono)
 191  * Copyright (C) 2006 Novell, Inc.
 192  */
 193 char *
 194 st_strconcat (const char *first, ...)
 195 {
 196         va_list args;
 197         size_t total = 0;
 198         char *s, *ret;
 199
 200         total += strlen (first);
 201         va_start (args, first);
 202         for (s = va_arg (args, char *); s != NULL; s = va_arg(args, char *)){
 203                 total += strlen (s);
 204         }
 205         va_end (args);
 206
 207         ret = st_malloc (total + 1);
 208         if (ret == NULL)
 209                 return NULL;
 210
 211         ret [total] = 0;
 212         strcpy (ret, first);
 213         va_start (args, first);
 214         for (s = va_arg (args, char *); s != NULL; s = va_arg(args, char *)){
 215                 strcat (ret, s);
 216         }
 217         va_end (args);
 218
 219         return ret;
 220 }
 221
 222
 223 double
 224 st_timespec_to_double_seconds (struct timespec *interval)
 225 {
 226     /* print in seconds */
 227     return interval->tv_sec + (interval->tv_nsec / 1.e9);
 228 }
 229
 230 void
 231 st_timespec_difference (struct timespec *start, struct timespec *end, struct timespec *diff)
 232 {
 233     if ((end->tv_nsec - start->tv_nsec) < 0) {
 234         diff->tv_sec = end->tv_sec - start->tv_sec - 1;
 235         diff->tv_nsec = 1000000000 + end->tv_nsec - start->tv_nsec;
 236     } else {
 237         diff->tv_sec = end->tv_sec - start->tv_sec;
 238         diff->tv_nsec = end->tv_nsec - start->tv_nsec;
 239     }
 240 }
 241
 242 void
 243 st_timespec_add (struct timespec *t1, struct timespec *t2, struct timespec *result)
 244 {
 245     if ((t1->tv_nsec + t2->tv_nsec) >=  1000000000) {
 246         result->tv_sec = t1->tv_sec + t2->tv_sec + 1;
 247         result->tv_nsec = t1->tv_nsec + t2->tv_nsec - 1000000000;
 248     } else {
 249         result->tv_sec = t1->tv_sec + t2->tv_sec;
 250         result->tv_nsec = t1->tv_nsec + t2->tv_nsec;
 251     }
 252 }
 253
 254 st_list *
 255 st_list_append  (st_list *list, st_pointer data)
 256 {
 257     st_list *new_list, *l;
 258
 259     new_list = st_new (st_list);
 260     new_list->data = data;
 261     new_list->next = NULL;
 262
 263     if (list == NULL)
 264         return new_list;
 265
 266     l = list;
 267     while (l->next)
 268         l = l->next;
 269
 270     l->next = new_list;
 271
 272     return list;
 273 }
 274
 275 st_list *
 276 st_list_prepend (st_list *list, st_pointer data)
 277 {
 278     st_list *new_list;
 279
 280     new_list = st_new (st_list);
 281     new_list->data = data;
 282     new_list->next = list;
 283
 284     return new_list;
 285 }
 286
 287 st_list *
 288 st_list_reverse (st_list *list)
 289 {
 290     st_list *next, *prev = NULL;
 291
 292     while (list) {
 293         next = list->next;
 294
 295         list->next = prev;
 296
 297         prev = list;
 298         list = next;
 299     }
 300
 301     return prev;
 302 }
 303
 304 st_list *
 305 st_list_concat  (st_list *list1, st_list *list2)
 306 {
 307     st_list *l;
 308
 309     if (list1 == NULL)
 310         return list2;
 311
 312     if (list2 == NULL)
 313         return list1;
 314
 315     l = list1;
 316     while (l->next)
 317         l = l->next;
 318     l->next = list2;
 319
 320     return list1;
 321 }
 322
 323 st_uint
 324 st_list_length (st_list *list)
 325 {
 326     st_list *l = list;
 327     st_uint len = 0;
 328
 329     for (; l; l = l->next)
 330         ++len;
 331
 332     return len;
 333 }
 334
 335 void
 336 st_list_foreach (st_list *list, st_list_foreach_func func)
 337 {
 338     for (st_list *l = list; l; l = l->next)
 339         func (l->data);
 340 }
 341
 342 void
 343 st_list_destroy (st_list *list)
 344 {
 345     st_list *next, *current;
 346
 347     current = list;
 348
 349     while (current) {
 350         next = current->next;
 351         st_free (current);
 352         current = next;
 353     }
 354 }
 355
 356 /* Derived from eglib (part of Mono)
 357  * Copyright (C) 2006 Novell, Inc.
 358  */
 359 static void
 360 add_to_vector (char ***vector, int size, char *token)
 361 {
 362         *vector = *vector == NULL ?
 363                 (char **)st_malloc(2 * sizeof(*vector)) :
 364                 (char **)st_realloc(*vector, (size + 1) * sizeof(*vector));
 365
 366         (*vector)[size - 1] = token;
 367 }
 368
 369 /* Derived from eglib (part of Mono)
 370  * Copyright (C) 2006 Novell, Inc.
 371  */
 372 char **
 373 st_strsplit (const char *string, const char *delimiter, int max_tokens)
 374 {
 375         const char *c;
 376         char *token, **vector;
 377         int size = 1;
 378
 379         if (strncmp (string, delimiter, strlen (delimiter)) == 0) {
 380                 vector = (char **)st_malloc (2 * sizeof(vector));
 381                 vector[0] = st_strdup ("");
 382                 size++;
 383                 string += strlen (delimiter);
 384         } else {
 385                 vector = NULL;
 386         }
 387
 388         while (*string && !(max_tokens > 0 && size >= max_tokens)) {
 389                 c = string;
 390                 if (strncmp (string, delimiter, strlen (delimiter)) == 0) {
 391                         token = st_strdup ("");
 392                         string += strlen (delimiter);
 393                 } else {
 394                         while (*string && strncmp (string, delimiter, strlen (delimiter)) != 0) {
 395                                 string++;
 396                         }
 397
 398                         if (*string) {
 399                                 size_t toklen = (string - c);
 400                                 token = st_strndup (c, toklen);
 401
 402                                 /* Need to leave a trailing empty
 403                                  * token if the delimiter is the last
 404                                  * part of the string
 405                                  */
 406                                 if (strcmp (string, delimiter) != 0) {
 407                                         string += strlen (delimiter);
 408                                 }
 409                         } else {
 410                                 token = st_strdup (c);
 411                         }
 412                 }
 413
 414                 add_to_vector (&vector, size, token);
 415                 size++;
 416         }
 417
 418         if (*string) {
 419                 /* Add the rest of the string as the last element */
 420                 add_to_vector (&vector, size, st_strdup (string));
 421                 size++;
 422         }
 423
 424         if (vector == NULL) {
 425                 vector = (char **) st_malloc (2 * sizeof (vector));
 426                 vector [0] = NULL;
 427         } else if (size > 0) {
 428                 vector[size - 1] = NULL;
 429         }
 430
 431         return vector;
 432 }
 433
 434 /* Derived from eglib (part of Mono)
 435  * Copyright (C) 2006 Novell, Inc.
 436  */
 437 void
 438 st_strfreev (char **str_array)
 439 {
 440         char **orig = str_array;
 441         if (str_array == NULL)
 442                 return;
 443         while (*str_array != NULL){
 444                 st_free (*str_array);
 445                 str_array++;
 446         }
 447         st_free (orig);
 448 }
 449
 450
 451 /* Derived from eglib (part of Mono)
 452  * Copyright (C) 2006 Novell, Inc.
 453  */
 454 /* This is not a macro, because I dont want to put _GNU_SOURCE in the glib.h header */
 455 char *
 456 st_strndup (const char *str, size_t n)
 457 {
 458 #ifdef HAVE_STRNDUP
 459         return strndup (str, n);
 460 #else
 461         if (str) {
 462                 char *retval = malloc(n+1);
 463                 if (retval) {
 464                         strncpy(retval, str, n)[n] = 0;
 465                 }
 466                 return retval;
 467         }
 468         return NULL;
 469 #endif
 470 }
 471
 472 st_uint
 473 st_string_hash (const char *string)
 474 {
 475     const signed char *p = (signed char *) string;
 476     st_uint h = *p;
 477
 478     if (*p == 0)
 479         return h;
 480
 481     while (*p) {
 482         h = (h << 5) - h + *p++;
 483     }
 484
 485     return h;
 486 }
 487
 488 void
 489 st_log (const char * restrict domain, const char * restrict format, ...)
 490 {
 491     char    *fmt;
 492     va_list  args;
 493
 494     st_assert (domain != NULL);
 495     if (!st_get_verbose_mode ())
 496         return;
 497
 498     fmt = st_strconcat ("** ", domain, ": ", format, "\n", NULL);
 499
 500     va_start (args, format);
 501     vfprintf (stderr, fmt, args);
 502     va_end (args);
 503     st_free (fmt);
 504 }