workbench/libs/codesets/src/utils.c

   1 /***************************************************************************
   2
   3  codesets.library - Amiga shared library for handling different codesets
   4  Copyright (C) 2001-2005 by Alfonso [alfie] Ranieri <alforan@tin.it>.
   5  Copyright (C) 2005-2013 by codesets.library 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  codesets.library project: http://sourceforge.net/projects/codesetslib/
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #include "lib.h"
  24 #include "debug.h"
  25
  26 /****************************************************************************/
  27
  28 #if !defined(HAVE_ALLOCVECPOOLED)
  29 APTR allocVecPooled(APTR pool,ULONG size)
  30 {
  31   ULONG *mem;
  32
  33   ENTER();
  34
  35   size += sizeof(ULONG);
  36   if((mem = AllocPooled(pool, size)))
  37     *mem++ = size;
  38
  39   RETURN(mem);
  40   return mem;
  41 }
  42 #endif
  43
  44 /****************************************************************************/
  45
  46 #if !defined(HAVE_FREEVECPOOLED)
  47 void freeVecPooled(APTR pool,APTR mem)
  48 {
  49   ENTER();
  50
  51   FreePooled(pool,(LONG *)mem - 1,*((LONG *)mem - 1));
  52
  53   LEAVE();
  54 }
  55 #endif
  56
  57 /****************************************************************************/
  58
  59 APTR reallocVecPooled(APTR pool, APTR mem, ULONG oldSize, ULONG newSize)
  60 {
  61   ULONG *newMem;
  62
  63   ENTER();
  64
  65   if((newMem = allocVecPooled(pool, newSize)) != NULL)
  66   {
  67     memcpy(newMem, mem, (oldSize < newSize) ? oldSize : newSize);
  68
  69     freeVecPooled(pool, mem);
  70   }
  71
  72   RETURN(newMem);
  73   return newMem;
  74 }
  75
  76 /****************************************************************************/
  77
  78 APTR allocArbitrateVecPooled(ULONG size)
  79 {
  80   ULONG *mem;
  81
  82   ENTER();
  83
  84   ObtainSemaphore(&CodesetsBase->poolSem);
  85   mem = allocVecPooled(CodesetsBase->pool, size);
  86   ReleaseSemaphore(&CodesetsBase->poolSem);
  87
  88   RETURN(mem);
  89   return mem;
  90 }
  91
  92 /****************************************************************************/
  93
  94 void freeArbitrateVecPooled(APTR mem)
  95 {
  96   ENTER();
  97
  98   ObtainSemaphore(&CodesetsBase->poolSem);
  99   freeVecPooled(CodesetsBase->pool, mem);
 100   ReleaseSemaphore(&CodesetsBase->poolSem);
 101
 102   LEAVE();
 103 }
 104
 105 /****************************************************************************/
 106
 107 APTR reallocArbitrateVecPooled(APTR mem, ULONG oldSize, ULONG newSize)
 108 {
 109   ENTER();
 110
 111   ObtainSemaphore(&CodesetsBase->poolSem);
 112   mem = reallocVecPooled(CodesetsBase->pool, mem, oldSize, newSize);
 113   ReleaseSemaphore(&CodesetsBase->poolSem);
 114
 115   RETURN(mem);
 116   return mem;
 117 }
 118
 119 /****************************************************************************/
 120
 121 ULONG utf16_strlen(UTF16 *ptr)
 122 {
 123   ULONG l;
 124
 125   for (l=0; ptr[l]; l++);
 126   return l<<1;
 127 }
 128
 129 /****************************************************************************/
 130
 131 ULONG utf32_strlen(UTF32 *ptr)
 132 {
 133   ULONG l;
 134
 135   for (l=0; ptr[l]; l++);
 136   return l<<2;
 137 }
 138
 139 /****************************************************************************/
 140
 141 // GetHead()
 142 // get the head element of a list
 143 #if !defined(HAVE_GETHEAD)
 144 struct Node *GetHead(struct List *list)
 145 {
 146   struct Node *result = NULL;
 147
 148   if(list != NULL && IsListEmpty(list) == FALSE)
 149     result = list->lh_Head;
 150
 151   return result;
 152 }
 153 #endif
 154
 155 /****************************************************************************/
 156
 157 // GetPred()
 158 // get a node's predecessor
 159 #if !defined(HAVE_GETPRED)
 160 struct Node *GetPred(struct Node *node)
 161 {
 162   struct Node *result = NULL;
 163
 164   if(node != NULL && node->ln_Pred != NULL && node->ln_Pred->ln_Pred != NULL)
 165     result = node->ln_Pred;
 166
 167   return result;
 168 }
 169 #endif
 170
 171 /****************************************************************************/
 172
 173 // GetSucc()
 174 // get a node's sucessor
 175 #if !defined(HAVE_GETSUCC)
 176 struct Node *GetSucc(struct Node *node)
 177 {
 178   struct Node *result = NULL;
 179
 180   if(node != NULL && node->ln_Succ != NULL && node->ln_Succ->ln_Succ != NULL)
 181     result = node->ln_Succ;
 182
 183   return result;
 184 }
 185 #endif
 186
 187 /****************************************************************************/
 188
 189 // GetTail()
 190 // get the tail element of a list
 191 #if !defined(HAVE_GETTAIL)
 192 struct Node *GetTail(struct List *list)
 193 {
 194   struct Node *result = NULL;
 195
 196   if(list != NULL && IsListEmpty(list) == FALSE)
 197     result = list->lh_TailPred;
 198
 199   return result;
 200 }
 201 #endif