Return to allocate.c CVS log

Up to [Apple XNU] / GNUtools / cctools / libstuff

Annotation of GNUtools/cctools/libstuff/allocate.c, revision 1.1.1.1

1.1       root        1: #include <stdlib.h>
                      2: #include <stdarg.h>
                      3: #include <string.h>
                      4: #include <mach/mach.h>
                      5: 
                      6: #include "stuff/allocate.h"
                      7: #include "stuff/errors.h"
                      8: /*
                      9:  * allocate() is just a wrapper around malloc that prints an error message and
                     10:  * exits if the malloc fails.
                     11:  */
                     12: void *
                     13: allocate(
                     14: unsigned long size)
                     15: {
                     16:     void *p;
                     17: 
                     18:        if(size == 0)
                     19:            return(NULL);
                     20:        if((p = malloc(size)) == NULL)
                     21:            system_fatal("virtual memory exhausted (malloc failed)");
                     22:        return(p);
                     23: }
                     24: 
                     25: /*
                     26:  * reallocate() is just a wrapper around realloc that prints and error message
                     27:  * and exits if the realloc fails.
                     28:  */
                     29: void *
                     30: reallocate(
                     31: void *p,
                     32: unsigned long size)
                     33: {
                     34:        if(p == NULL)
                     35:            return(allocate(size));
                     36:        if((p = realloc(p, size)) == NULL)
                     37:            system_fatal("virtual memory exhausted (realloc failed)");
                     38:        return(p);
                     39: }
                     40: 
                     41: /*
                     42:  * savestr() malloc's space for the string passed to it, copys the string into
                     43:  * the space and returns a pointer to that space.
                     44:  */
                     45: char *
                     46: savestr(
                     47: const char *s)
                     48: {
                     49:     long len;
                     50:     char *r;
                     51: 
                     52:        len = strlen(s) + 1;
                     53:        r = (char *)allocate(len);
                     54:        strcpy(r, s);
                     55:        return(r);
                     56: }
                     57: 
                     58: /*
                     59:  * Makestr() creates a string that is the concatenation of a variable number of
                     60:  * strings.  It is pass a variable number of pointers to strings and the last
                     61:  * pointer is NULL.  It returns the pointer to the string it created.  The
                     62:  * storage for the string is malloc()'ed can be free()'ed when nolonger needed.
                     63:  */
                     64: char *
                     65: makestr(
                     66: const char *args,
                     67: ...)
                     68: {
                     69:     va_list ap;
                     70:     char *s, *p;
                     71:     long size;
                     72: 
                     73:        size = 0;
                     74:        if(args != NULL){
                     75:            size += strlen(args);
                     76:            va_start(ap, args);
                     77:            p = (char *)va_arg(ap, char *);
                     78:            while(p != NULL){
                     79:                size += strlen(p);
                     80:                p = (char *)va_arg(ap, char *);
                     81:            }
                     82:        }
                     83:        s = allocate(size + 1);
                     84:        *s = '\0';
                     85: 
                     86:        if(args != NULL){
                     87:            (void)strcat(s, args);
                     88:            va_start(ap, args);
                     89:            p = (char *)va_arg(ap, char *);
                     90:            while(p != NULL){
                     91:                (void)strcat(s, p);
                     92:                p = (char *)va_arg(ap, char *);
                     93:            }
                     94:            va_end(ap);
                     95:        }
                     96:        return(s);
                     97: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.