WINGs/memory.c

   1 /*
   2  *  Window Maker miscelaneous function library
   3  *
   4  *  Copyright (c) 1997 Alfredo K. Kojima
   5  *
   6  *  This program is free software; you can redistribute it and/or modify
   7  *  it under the terms of the GNU General Public License as published by
   8  *  the Free Software Foundation; either version 2 of the License, or
   9  *  (at your option) any later version.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21
  22 #include "../src/config.h"
  23
  24 #include "WUtil.h"
  25
  26 #include <stdlib.h>
  27 #include <sys/types.h>
  28 #include <unistd.h>
  29 #include <stdio.h>
  30 #include <string.h>
  31 #include <assert.h>
  32 #include <signal.h>
  33
  34 #ifndef False
  35 # define False 0
  36 #endif
  37 #ifndef True
  38 # define True 1
  39 #endif
  40
  41
  42 static void
  43 defaultHandler(int bla)
  44 {
  45     if (bla)
  46         raise(SIGABRT);
  47     else
  48         exit(1);
  49 }
  50
  51
  52 static waborthandler *aborthandler = (waborthandler*)defaultHandler;
  53
  54 #define wAbort(a) (*aborthandler)(a)
  55
  56
  57 waborthandler*
  58 wsetabort(waborthandler *handler)
  59 {
  60     waborthandler *old = aborthandler;
  61
  62     aborthandler = handler;
  63
  64     return old;
  65 }
  66
  67
  68
  69 static int Aborting=0; /* if we're in the middle of an emergency exit */
  70
  71
  72 static WMHashTable *table = NULL;
  73
  74
  75 void *wmalloc(size_t size)
  76 {
  77     void *tmp;
  78
  79     tmp = malloc(size);
  80     if (tmp == NULL) {
  81         wwarning("malloc() failed. Retrying after 2s.");
  82         sleep(2);
  83         tmp = malloc(size);
  84         if (tmp == NULL) {
  85             if (Aborting) {
  86                 puts("Real Bad Error: recursive malloc() failure.");
  87                 exit(-1);
  88             } else {
  89                 wfatal("virtual memory exhausted");
  90                 Aborting=1;
  91                 wAbort(False);
  92             }
  93         }
  94     }
  95     return tmp;
  96 }
  97
  98
  99 void *wrealloc(void *ptr, size_t newsize)
 100 {
 101     void *nptr;
 102
 103     if (!ptr) {
 104         nptr = malloc(newsize);
 105     } else {
 106         nptr=realloc(ptr, newsize);
 107     }
 108     if (nptr==NULL) {
 109         printf("Could not do realloc");
 110         return NULL;
 111     }
 112     return nptr;
 113 }
 114
 115
 116 void*
 117 wretain(void *ptr)
 118 {
 119     int *refcount;
 120
 121     if (!table) {
 122         table = WMCreateHashTable(WMIntHashCallbacks);
 123     }
 124
 125     refcount = WMHashGet(table, ptr);
 126     if (!refcount) {
 127         refcount = wmalloc(sizeof(int));
 128         *refcount = 1;
 129         WMHashInsert(table, ptr, refcount);
 130 #ifdef VERBOSE
 131         printf("== %i (%p)\n", *refcount, ptr);
 132 #endif
 133     } else {
 134         (*refcount)++;
 135 #ifdef VERBOSE
 136         printf("+ %i (%p)\n", *refcount, ptr);
 137 #endif
 138     }
 139
 140     return ptr;
 141 }
 142
 143
 144 void
 145 wrelease(void *ptr)
 146 {
 147     int *refcount;
 148
 149     refcount = WMHashGet(table, ptr);
 150     if (!refcount) {
 151         wwarning("trying to release unexisting data %p", ptr);
 152     } else {
 153         (*refcount)--;
 154         if (*refcount < 1) {
 155 #ifdef VERBOSE
 156             printf("RELEASING %p\n", ptr);
 157 #endif
 158             WMHashRemove(table, ptr);
 159             free(refcount);
 160             free(ptr);
 161         }
 162 #ifdef VERBOSE
 163         else {
 164             printf("- %i (%p)\n", *refcount, ptr);
 165         }
 166 #endif
 167     }
 168 }
 169
 170
 171 char*
 172 wstrdup(char *str)
 173 {
 174     assert(str!=NULL);
 175
 176     return strcpy(wmalloc(strlen(str)+1), str);
 177 }
 178
 179
 180 char*
 181 wstrappend(char *dst, char *src)
 182 {
 183     char *str;
 184
 185     if (!dst)
 186         return wstrdup(src);
 187     else if (!src)
 188         return wstrdup(dst);
 189
 190     str = wmalloc(strlen(dst)+strlen(src)+1);
 191     strcpy(str, dst);
 192     strcat(str, src);
 193
 194     return str;
 195 }
 196