workbench/classes/zune/betterstring/mcc/AllocFunctions.c

   1 /***************************************************************************
   2
   3  BetterString.mcc - A better String gadget MUI Custom Class
   4  Copyright (C) 1997-2000 Allan Odgaard
   5  Copyright (C) 2005-2013 by BetterString.mcc Open Source Team
   6
   7  This library is free software; you can redistribute it and/or
   8  modify it under the terms of the GNU Lesser General Public
   9  License as published by the Free Software Foundation; either
  10  version 2.1 of the License, or (at your option) any later version.
  11
  12  This library is distributed in the hope that it will be useful,
  13  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  Lesser General Public License for more details.
  16
  17  BetterString class Support Site:  http://www.sf.net/projects/bstring-mcc/
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #include <string.h>
  24
  25 #include <proto/exec.h>
  26
  27 #include "private.h"
  28
  29 #include "Debug.h"
  30
  31 static APTR sharedPool;
  32 #if !defined(__amigaos4__) && !defined(__MORPHOS__)
  33 static struct SignalSemaphore sharedPoolSema;
  34 #endif
  35
  36 BOOL CreateSharedPool(void)
  37 {
  38   BOOL success = FALSE;
  39
  40   ENTER();
  41
  42   #if defined(__amigaos4__)
  43   sharedPool = AllocSysObjectTags(ASOT_MEMPOOL, ASOPOOL_MFlags, MEMF_SHARED,
  44                                                 ASOPOOL_Puddle, 512,
  45                                                 ASOPOOL_Threshold, 256,
  46                                                 ASOPOOL_Name, "BetterString.mcc shared pool",
  47                                                 ASOPOOL_Protected, TRUE,
  48                                                 ASOPOOL_LockMem, FALSE,
  49                                                 TAG_DONE);
  50   #elif defined(__MORPHOS__)
  51   sharedPool = CreatePool(MEMF_SEM_PROTECTED, 512, 256);
  52   #else
  53   sharedPool = CreatePool(MEMF_ANY, 512, 256);
  54   memset(&sharedPoolSema, 0, sizeof(sharedPoolSema));
  55   InitSemaphore(&sharedPoolSema);
  56   #endif
  57
  58   if(sharedPool != NULL)
  59     success = TRUE;
  60
  61   RETURN(success);
  62   return success;
  63 }
  64
  65 void DeleteSharedPool(void)
  66 {
  67   ENTER();
  68
  69   if(sharedPool != NULL)
  70   {
  71     #if defined(__amigaos4__)
  72     FreeSysObject(ASOT_MEMPOOL, sharedPool);
  73     #else
  74     DeletePool(sharedPool);
  75     #endif
  76     sharedPool = NULL;
  77   }
  78
  79   LEAVE();
  80 }
  81
  82 #if defined(__amigaos3__)
  83 static APTR AllocVecPooled(APTR poolHeader, ULONG memSize)
  84 {
  85   ULONG *memory;
  86
  87   ENTER();
  88
  89   // add the number of bytes used to store the size information
  90   memSize += sizeof(ULONG);
  91
  92   // allocate memory from the pool
  93   if((memory = (ULONG *)AllocPooled(poolHeader, memSize)) != NULL)
  94   {
  95     // and finally store the size of the memory block, including the size itself
  96     *memory++ = memSize;
  97   }
  98
  99   RETURN(memory);
 100   return memory;
 101 }
 102 #endif
 103
 104 APTR SharedPoolAlloc(ULONG length)
 105 {
 106   ULONG *mem;
 107
 108   ENTER();
 109
 110   #if !defined(__amigaos4__) && !defined(__MORPHOS__)
 111   ObtainSemaphore(&sharedPoolSema);
 112   #endif
 113
 114   mem = AllocVecPooled(sharedPool, length);
 115
 116   #if !defined(__amigaos4__) && !defined(__MORPHOS__)
 117   ReleaseSemaphore(&sharedPoolSema);
 118   #endif
 119
 120   RETURN(mem);
 121   return mem;
 122 }
 123
 124 #if defined(__amigaos3__)
 125 static void FreeVecPooled(APTR poolHeader, APTR memory)
 126 {
 127   ULONG *mem = (ULONG *)memory;
 128   ULONG memSize;
 129
 130   ENTER();
 131
 132   // skip back over the stored size information
 133   memSize = *(--mem);
 134
 135   // an return the memory block to the pool
 136   FreePooled(poolHeader, mem, memSize);
 137
 138   LEAVE();
 139 }
 140 #endif
 141
 142 void SharedPoolFree(APTR mem)
 143 {
 144   ENTER();
 145
 146   #if !defined(__amigaos4__) && !defined(__MORPHOS__)
 147   ObtainSemaphore(&sharedPoolSema);
 148   #endif
 149
 150   FreeVecPooled(sharedPool, mem);
 151
 152   #if !defined(__amigaos4__) && !defined(__MORPHOS__)
 153   ReleaseSemaphore(&sharedPoolSema);
 154   #endif
 155
 156   LEAVE();
 157 }
 158
 159 struct ContentString
 160 {
 161   ULONG size;
 162   char string[0];
 163 };
 164
 165 #define STR_TO_CSTR(str)    (struct ContentString *)(((size_t)(str)) - sizeof(struct ContentString))
 166 #define CSTR_TO_STR(cstr)   (&(cstr)->string[0])
 167
 168 static struct ContentString *AllocContentStringInternal(ULONG size)
 169 {
 170   struct ContentString *cstr;
 171
 172   ENTER();
 173
 174   if((cstr = SharedPoolAlloc(sizeof(*cstr) + size)) != NULL)
 175   {
 176     cstr->size = size;
 177     cstr->string[0] = '\0';
 178   }
 179
 180   RETURN(cstr);
 181   return cstr;
 182 }
 183
 184 char *AllocContentString(ULONG size)
 185 {
 186   struct ContentString *cstr;
 187   char *result = NULL;
 188
 189   ENTER();
 190
 191   if((cstr = AllocContentStringInternal(size)) != NULL)
 192   {
 193     result = CSTR_TO_STR(cstr);
 194   }
 195
 196   RETURN(result);
 197   return result;
 198 }
 199
 200 void FreeContentString(char *str)
 201 {
 202   ENTER();
 203
 204   if(str != NULL)
 205   {
 206     struct ContentString *cstr = STR_TO_CSTR(str);
 207
 208     SharedPoolFree(cstr);
 209   }
 210
 211   LEAVE();
 212 }
 213
 214 ULONG ContentStringSize(char *str)
 215 {
 216   ULONG size = 0;
 217
 218   ENTER();
 219
 220   if(str != NULL)
 221   {
 222     struct ContentString *cstr = STR_TO_CSTR(str);
 223
 224     size = cstr->size;
 225   }
 226
 227   RETURN(size);
 228   return size;
 229 }
 230
 231 BOOL ExpandContentString(char **str, ULONG extra)
 232 {
 233   BOOL success = FALSE;
 234
 235   ENTER();
 236
 237   if(*str != NULL)
 238   {
 239     struct ContentString *cstr = STR_TO_CSTR(*str);
 240     ULONG newsize = strlen(cstr->string) + 1 + extra;
 241
 242     // check if we have to expand our contents string
 243     if(cstr->size < newsize)
 244     {
 245       struct ContentString *newcstr;
 246
 247       // add another 32 bytes for less expansions in the future
 248       newsize += 32;
 249       if((newcstr = AllocContentStringInternal(newsize)) != NULL)
 250       {
 251         strlcpy(newcstr->string, cstr->string, newsize);
 252         FreeContentString(*str);
 253         *str = CSTR_TO_STR(newcstr);
 254
 255         success = TRUE;
 256       }
 257     }
 258     else
 259     {
 260       // no expansion necessary, instant success
 261       success = TRUE;
 262     }
 263   }
 264   else
 265   {
 266     // allocate a new content string
 267     if((*str = AllocContentString(extra)) != NULL)
 268       success = TRUE;
 269   }
 270
 271   RETURN(success);
 272   return success;
 273 }