apps/plugins/mikmod/mmio/old_mmalloc.c

   1 /*      MikMod sound library\r
   2         (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for\r
   3         complete list.\r
   4 \r
   5         This library is free software; you can redistribute it and/or modify\r
   6         it under the terms of the GNU Library General Public License as\r
   7         published by the Free Software Foundation; either version 2 of\r
   8         the License, or (at your option) any later version.\r
   9  \r
  10         This program is distributed in the hope that it will be useful,\r
  11         but WITHOUT ANY WARRANTY; without even the implied warranty of\r
  12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
  13         GNU Library General Public License for more details.\r
  14  \r
  15         You should have received a copy of the GNU Library General Public\r
  16         License along with this library; if not, write to the Free Software\r
  17         Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA\r
  18         02111-1307, USA.\r
  19 */\r
  20 \r
  21 /*==============================================================================\r
  22 \r
  23   $Id: mmalloc.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $\r
  24 \r
  25   Dynamic memory routines\r
  26 \r
  27 ==============================================================================*/\r
  28 \r
  29 #ifdef HAVE_CONFIG_H\r
  30 #include "config.h"\r
  31 #endif\r
  32 \r
  33 #include "mikmod_internals.h"\r
  34 \r
  35 \r
  36 size_t mem_offset = 0;\r
  37 char *mallocbuf = NULL;\r
  38 size_t mallocbuflen = 0;\r
  39 \r
  40 #define OTMAX 8192\r
  41 size_t offsettable[OTMAX];\r
  42 int otcounter = 0;\r
  43 \r
  44 size_t mikmod_get_mbuffsize(void *buff)\r
  45 {\r
  46         int i;\r
  47 \r
  48         for (i = 0; i < otcounter; i++)\r
  49         {\r
  50                 if (offsettable[i] == (size_t)buff - (size_t)mallocbuf)\r
  51                 {\r
  52                         if (i < (otcounter - 1))\r
  53                         {\r
  54                                 return (size_t)(offsettable[i + 1] - offsettable[i]);\r
  55                         }\r
  56                         else // i == (otcounter - 1)\r
  57                         {\r
  58                                 return mem_offset - offsettable[i];\r
  59                         }\r
  60                 }\r
  61         }\r
  62 \r
  63         return 0; // i >= otcounter\r
  64 }\r
  65 \r
  66 \r
  67 void mikmod_prepare_malloc(char *buff, int bufsize)\r
  68 {\r
  69         mallocbuf = buff;\r
  70         mallocbuflen = bufsize;\r
  71         mem_offset = 0;\r
  72         otcounter = 0;\r
  73 }\r
  74 \r
  75 long mikmod_get_malloc_usage(void)\r
  76 {\r
  77         return mem_offset;\r
  78 }\r
  79 \r
  80 int mikmod_abs(int num)\r
  81 {\r
  82         if (num < 0)\r
  83                 return (num * -1);\r
  84         else\r
  85                 return (num);\r
  86 }\r
  87 \r
  88 void* mikmod_memset(char *buf, int val, size_t count)\r
  89 {\r
  90         size_t i;\r
  91 \r
  92         for (i = 0; i < count; i++)\r
  93         {\r
  94                 buf[i] = val;\r
  95         }\r
  96         return buf;\r
  97 }\r
  98 \r
  99 /* 'Poor man's malloc' taken from rockbox codeclib.c */\r
 100 void* mikmod_malloc(size_t size)\r
 101 {\r
 102     void* x;\r
 103 \r
 104         if (!mallocbuf)\r
 105                 return NULL;\r
 106     if (mem_offset + (long)size > mallocbuflen)\r
 107         return NULL;\r
 108     \r
 109     x = &mallocbuf[mem_offset];\r
 110 \r
 111 \r
 112         if (otcounter < OTMAX)\r
 113         {\r
 114                 offsettable[otcounter] = mem_offset;\r
 115                 otcounter++;\r
 116         }\r
 117         else\r
 118         {\r
 119                 if (otcounter == OTMAX)\r
 120                 {\r
 121                         rb->splash(HZ * 2, "Offset Table FULL !\n");\r
 122                 }\r
 123         }\r
 124         mem_offset += (size + 3) & ~3; /* Keep memory 32-bit aligned */\r
 125 \r
 126 \r
 127         memset(x, 0, size);\r
 128 \r
 129     return(x);\r
 130 }\r
 131 \r
 132 void* mikmod_calloc(size_t nmemb, size_t size)\r
 133 {\r
 134     void *x;\r
 135     x = mikmod_malloc(nmemb * size);\r
 136     if (x == NULL)\r
 137         return NULL;\r
 138     //memset(x, 0, nmemb*size);\r
 139     return(x);\r
 140 }\r
 141 \r
 142 void mikmod_free(void* ptr) {\r
 143     (void)ptr;\r
 144 }\r
 145 \r
 146 void* mikmod_realloc(void* ptr, size_t size)\r
 147 {\r
 148     void* x;\r
 149     //(void)ptr;\r
 150     x = mikmod_malloc(size);\r
 151         if (ptr != NULL)\r
 152         {\r
 153                 if (mikmod_get_mbuffsize(ptr))\r
 154                 {\r
 155                         memcpy(x, ptr, mikmod_get_mbuffsize(ptr));\r
 156                 }\r
 157                 else\r
 158                 {\r
 159                         memcpy(x, ptr, size); //FIXME: size has to be the size of the original buffer.....\r
 160                 }\r
 161         }\r
 162     return(x);\r
 163 }\r
 164 \r
 165 unsigned int mikmod_strlen(const char *string)\r
 166 {\r
 167         unsigned int i;\r
 168         for (i = 0; string[i] != 0; i++);\r
 169         return i;\r
 170 }\r
 171 \r
 172 char* mikmod_strdup(const char *srcbuf)\r
 173 {\r
 174         char *newbuf;\r
 175         unsigned int i, len;\r
 176 \r
 177         len = mikmod_strlen(srcbuf);\r
 178         newbuf = mikmod_malloc(len + 1);\r
 179         \r
 180         if (newbuf)\r
 181         {\r
 182                 for (i = 0; i <= len; i++)\r
 183                         newbuf[i] = srcbuf[i];\r
 184         }\r
 185         return newbuf;\r
 186 }\r
 187 \r
 188 char* mikmod_strncat(char *dest, const char *src, size_t count)\r
 189 {\r
 190         size_t i, j;\r
 191         j = mikmod_strlen(dest);\r
 192 \r
 193         for(i = 0; i < count; i++)\r
 194         {\r
 195                 if (src[i] == 0)\r
 196                         break;\r
 197                 dest[i + j] = src[i];\r
 198         }\r
 199         return dest;\r
 200 }\r
 201 \r
 202 int mikmod_memcmp(const char *buf1, const char *buf2, size_t count)\r
 203 {\r
 204         size_t i;\r
 205 \r
 206         for(i = 0; i < count; i++)\r
 207         {\r
 208                 if (buf1[i] > buf2[i])\r
 209                         return 1;\r
 210                 if (buf1[i] < buf2[i])\r
 211                         return -1;\r
 212         }\r
 213         return 0;\r
 214 }\r
 215 \r
 216 char* mikmod_strstr(char *str, char *search)\r
 217 {\r
 218         size_t i, j, k;\r
 219 \r
 220         if (!mikmod_strlen(search))\r
 221                 return str;\r
 222 \r
 223         j = mikmod_strlen(str);\r
 224         k = mikmod_strlen(search);\r
 225 \r
 226         for (i = 0; i < (j - k); i++)\r
 227         {\r
 228                 if (!mikmod_memcmp(str, search, k))\r
 229                         return &str[i];\r
 230         }\r
 231         return NULL;\r
 232 }\r
 233 \r
 234 int mikmod_toupper(int character)\r
 235 {\r
 236         if ((character > 96) && (character < 123))\r
 237                 return (character - 32);\r
 238         else\r
 239                 return character;\r
 240 }\r
 241 \r
 242 int mikmod_isalnum(int character)\r
 243 {\r
 244         if ((character > 96) && (character < 123))\r
 245                 return character;\r
 246         if ((character > 64) && (character < 91))\r
 247                 return character;\r
 248         if ((character > 47) && (character < 58))\r
 249                 return character;\r
 250         return 0;\r
 251 }\r
 252 \r
 253 int mikmod_isdigit(char c)\r
 254 {\r
 255     return (c >= '0') && (c <= '9');\r
 256 }\r
 257 \r
 258 \r
 259 /****************************************************\r
 260  * 'Original' MikMod code goes here\r
 261  *\r
 262  ****************************************************/\r
 263 \r
 264 /* Same as malloc, but sets error variable _mm_error when fails */\r
 265 void* _mm_malloc(size_t size)\r
 266 {\r
 267         void *d;\r
 268 \r
 269         //if(!(d=mikmod_malloc(size))) {\r
 270         if(!(d=mikmod_malloc(size))) {\r
 271                 _mm_errno = MMERR_OUT_OF_MEMORY;\r
 272                 if(_mm_errorhandler) _mm_errorhandler();\r
 273         }\r
 274         memset(d, 0, size);\r
 275         return d;\r
 276 }\r
 277 \r
 278 /* Same as calloc, but sets error variable _mm_error when fails */\r
 279 void* _mm_calloc(size_t nitems,size_t size)\r
 280 {\r
 281         void *d;\r
 282    \r
 283         if(!(d=mikmod_calloc(nitems,size))) {\r
 284                 _mm_errno = MMERR_OUT_OF_MEMORY;\r
 285                 if(_mm_errorhandler) _mm_errorhandler();\r
 286         }\r
 287         return d;\r
 288 }\r
 289 \r
 290 /* ex:set ts=4: */\r