kenmirrors/asterisk
1
0
Fork 0
mirror of https://github.com/asterisk/asterisk.git synced 2025-10-26 06:26:41 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove as much trailing whitespace as possible.

Browse Source 
Change-Id: I873c1c6d00f447269bd841494459efccdd2c19c0
This commit is contained in:
Sean Bright
2017-12-22 09:23:22 -05:00
parent 9ef97b5a91
commit fd0ca1c3f9
700 changed files with 9249 additions and 9661 deletions
Download Patch File Download Diff File Expand all files Collapse all files

335
addons/ooh323c/src/memheap.c
View File

@@ -1,15 +1,15 @@
/*
* Copyright (C) 1997-2004 by Objective Systems, Inc.
*
* This software is furnished under an open source license and may be
* used and copied only in accordance with the terms of this license.
* The text of the license may generally be found in the root
* directory of this installation in the LICENSE.txt file. It
* This software is furnished under an open source license and may be
* used and copied only in accordance with the terms of this license.
* The text of the license may generally be found in the root
* directory of this installation in the LICENSE.txt file. It
* can also be viewed online at the following URL:
*
* http://www.obj-sys.com/open/license.html
*
* Any redistributions of this file including modified versions must
* Any redistributions of this file including modified versions must
* maintain this copyright notice.
*
*****************************************************************************/
@@ -21,7 +21,7 @@
ASN1UINT g_defBlkSize = XM_K_MEMBLKSIZ;
static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink,
static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink,
void* pMemBlk, int blockType);
typedef void OSMemElemDescr;
@@ -110,39 +110,39 @@ pMemBlk->freeElemOff = (ASN1USINT)(QOFFSETOF (pElem, pMemBlk->data) + 1); \
#define SET_FREE_ELEM(pMemBlk, pElem) setLastElem (pMemBlk, pElem)
/* Memory debugging macros */
#define RTMEMDIAG1(msg)
#define RTMEMDIAG2(msg,a)
#define RTMEMDIAG1(msg)
#define RTMEMDIAG2(msg,a)
#define RTMEMDIAG3(msg,a,b)
#define RTMEMDIAG4(msg,a,b,c)
#define FILLFREEMEM(mem,size)
#define FILLNEWMEM(mem,size)
#define FILLNEWMEM(mem,size)
#define CHECKMEMELEM(memblk,elem)
#define CHECKMEMBLOCK(memheap,memblk)
#define CHECKMEMHEAP(memheap)
#define CHECKMEMHEAP(memheap)
#define TRACEMEMELEM(memblk, elem, name)
#define TRACEFREE(memlink,name)
static void setLastElem (OSMemBlk* pMemBlk, OSMemElemDescr* pElem)
static void setLastElem (OSMemBlk* pMemBlk, OSMemElemDescr* pElem)
{
if (pElem == 0) {
pMemBlk->freeElemOff = 0;
return;
if (pElem == 0) {
pMemBlk->freeElemOff = 0;
return;
}
else if (ISLAST (pElem))
return;
else if (ISLAST (pElem))
return;
else if (pMemBlk->freeElemOff > QOFFSETOF (pElem, pMemBlk->data) + 1) {
pElem_nextFreeOff (pElem) = QOFFSETOF (GET_FREE_ELEM (pMemBlk), pElem);
FORCE_SET_FREE_ELEM (pMemBlk, pElem);
}
else if (pMemBlk->freeElemOff == 0) {
pElem_nextFreeOff (pElem) = 0;
FORCE_SET_FREE_ELEM (pMemBlk, pElem);
}
else {
SET_FREE (pElem);
pElem_nextFreeOff (pElem) = 0;
pElem_nextFreeOff (pElem) = QOFFSETOF (GET_FREE_ELEM (pMemBlk), pElem);
FORCE_SET_FREE_ELEM (pMemBlk, pElem);
}
else if (pMemBlk->freeElemOff == 0) {
pElem_nextFreeOff (pElem) = 0;
FORCE_SET_FREE_ELEM (pMemBlk, pElem);
}
else {
SET_FREE (pElem);
pElem_nextFreeOff (pElem) = 0;
}
}
@@ -171,7 +171,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
ppMemLink = &pMemHeap->phead;
/* if size is greater than 2**19, then allocate as RAW block */
if (nunits > (1<<16) - 2) {
void *data;
@@ -189,9 +189,9 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
/* save size of the RAW memory block behind the pMemLink */
*(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = nbytes;
ast_mutex_unlock(&pMemHeap->pLock);
return data;
return data;
}
RTMEMDIAG2 ("memHeapAlloc: adjusted nbytes = %d\n", nbytes);
/* Try to allocate a slot from an existing block on the list */
@@ -217,26 +217,26 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
pElem_flags (pElem) = 0;
if (pMemBlk->lastElemOff != 0)
pElem_prevOff (pElem) =
pElem_prevOff (pElem) =
(ASN1USINT)(pMemBlk->free_x - pMemBlk->lastElemOff + 1);
else
else
pElem_prevOff (pElem) = 0;
pPrevElem = GET_LAST_ELEM (pMemBlk);
if (pPrevElem != 0)
CLEAR_LAST (pPrevElem);
pElem_nunits (pElem) = (ASN1USINT)nunits;
pElem_nunits (pElem) = (ASN1USINT)nunits;
pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data);
pMemBlk->lastElemOff = (ASN1USINT)(pMemBlk->free_x + 1);
mem_p = (void*) (pElem_data (pElem));
/* sizeof (OSMemElemDescr) == 1 unit */
pMemBlk->free_x += nunits + 1;
pMemBlk->free_x += nunits + 1;
SET_LAST_ELEM (pMemBlk, pElem);
FILLNEWMEM (mem_p, nunits * 8u);
TRACEMEMELEM(pMemBlk, pElem, "Allocated");
CHECKMEMELEM (pMemBlk, pElem);
@@ -250,54 +250,54 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
if (0 == mem_p) {
for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnext) {
if (pMemLink->blockType & RTMEMRAW) continue;
pMemBlk = (OSMemBlk*) pMemLink->pMemBlk;
if (nunits <= (ASN1UINT)pMemBlk->freeMem) {
OSMemElemDescr* pElem = GET_FREE_ELEM(pMemBlk), *pPrevFree = 0;
RTMEMDIAG2
("memHeapAlloc: try to reuse empty elems in pMemBlk = 0x%x...\n",
RTMEMDIAG2
("memHeapAlloc: try to reuse empty elems in pMemBlk = 0x%x...\n",
pMemBlk);
while (pElem != 0) {
if (ISFREE (pElem)) {
if (ISFREE (pElem)) {
if (nunits <= (ASN1UINT)pElem_nunits (pElem)) {
RTMEMDIAG3
RTMEMDIAG3
("memHeapAlloc: "
"found an exisiting free element 0x%x, size %d\n",
"found an exisiting free element 0x%x, size %d\n",
pElem, (pElem_nunits (pElem) * 8u));
if (pMemBlk->freeElemOff ==
QOFFSETOF (pElem, pMemBlk->data) + 1)
if (pMemBlk->freeElemOff ==
QOFFSETOF (pElem, pMemBlk->data) + 1)
{
/* modify the pMemBlk->freeElemOff value if necsry */
OSMemElemDescr* nextFree = GET_NEXT_FREE (pElem);
FORCE_SET_FREE_ELEM (pMemBlk, nextFree);
FORCE_SET_FREE_ELEM (pMemBlk, nextFree);
}
else if (pPrevFree != 0) {
OSMemElemDescr* pNextFree = GET_NEXT_FREE (pElem);
if (pNextFree != 0)
pElem_nextFreeOff (pPrevFree) = QOFFSETOF (pNextFree,
pElem_nextFreeOff (pPrevFree) = QOFFSETOF (pNextFree,
pPrevFree);
else
pElem_nextFreeOff (pPrevFree) = 0;
}
}
CLEAR_FREE (pElem);
/* set beginOff value */
pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data);
pMemBlk->freeMem -= pElem_nunits (pElem);
CHECKMEMELEM (pMemBlk, pElem);
CHECKMEMBLOCK (pMemHeap, pMemBlk);
mem_p = memHeapRealloc
mem_p = memHeapRealloc
(ppvMemHeap, pElem_data (pElem), nunits * 8u);
if (mem_p != 0) {
FILLNEWMEM (mem_p, nunits * 8u);
@@ -311,7 +311,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
}
if (mem_p != 0) break;
}
}
}
}
/* If not successful, malloc a new block and alloc from it */
@@ -323,16 +323,16 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
RTMEMDIAG1 ("memHeapAlloc: alloc block..\n");
allocSize = (ASN1UINT) ((((ASN1UINT)nunits) * 8u) +
allocSize = (ASN1UINT) ((((ASN1UINT)nunits) * 8u) +
sizeof (OSMemBlk) + sizeof_OSMemElemDescr);
allocSize = (ASN1UINT) (allocSize < defBlkSize) ? defBlkSize :
allocSize = (ASN1UINT) (allocSize < defBlkSize) ? defBlkSize :
((allocSize + defBlkSize - 1) / defBlkSize * defBlkSize);
dataUnits = (ASN1UINT)((allocSize - sizeof (OSMemBlk)) >> 3u);
if (dataUnits >= (1u<<16)) {
dataUnits = (ASN1UINT)((1u<<16) - 1);
allocSize = (ASN1UINT)
((((ASN1UINT)dataUnits) * 8u) + sizeof (OSMemBlk));
}
}
pmem = (ASN1OCTET*) ast_malloc(allocSize + sizeof (OSMemLink));
if (0 != pmem) {
@@ -348,7 +348,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data);
/* sizeof (OSMemElemDescr) == 1 unit */
pMemBlk->free_x = (ASN1USINT)(nunits + 1);
pMemBlk->free_x = (ASN1USINT)(nunits + 1);
pMemBlk->freeMem = 0;
pMemBlk->nunits = (ASN1USINT)dataUnits;
@@ -356,7 +356,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
pMemBlk->freeElemOff = 0;
pMemBlk->nsaved = 0;
if (memHeapAddBlock (ppMemLink, pMemBlk, RTMEMSTD | RTMEMLINK) == 0)
if (memHeapAddBlock (ppMemLink, pMemBlk, RTMEMSTD | RTMEMLINK) == 0)
{
ast_free(pmem);
ast_mutex_unlock(&pMemHeap->pLock);
@@ -379,7 +379,7 @@ void* memHeapAlloc (void** ppvMemHeap, int nbytes)
}
RTMEMDIAG2 ("memHeapAlloc: pMemBlk = 0x%x\n", pMemBlk);
RTMEMDIAG2 ("memHeapAlloc: pMemBlk->free_x = %d\n", pMemBlk->free_x);
RTMEMDIAG2 ("memHeapAlloc: pMemBlk->size = %d\n",
RTMEMDIAG2 ("memHeapAlloc: pMemBlk->size = %d\n",
pMemBlk->nunits * 8u);
RTMEMDIAG2 ("memHeapAlloc: mem_p = 0x%x\n", mem_p);
RTMEMDIAG2 ("memHeapAlloc: sizeof (short) = %d\n", sizeof(short));
@@ -395,7 +395,7 @@ void* memHeapAllocZ (void** ppvMemHeap, int nbytes)
return ptr;
}
void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
{
OSMemHeap* pMemHeap;
OSMemLink** ppMemLink;
@@ -417,7 +417,7 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnextRaw) {
if ((pMemLink->blockType & RTMEMRAW) &&
pMemLink->pMemBlk == mem_p)
pMemLink->pMemBlk == mem_p)
{
if(pMemLink->pnext != 0) {
pMemLink->pnext->pprev = pMemLink->pprev;
@@ -430,12 +430,12 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
}
if (pPrevMemLink != 0)
pPrevMemLink->pnextRaw = pMemLink->pnextRaw;
else if (*ppMemLink != 0 && (*ppMemLink)->pnextRaw == 0 &&
else if (*ppMemLink != 0 && (*ppMemLink)->pnextRaw == 0 &&
*ppMemLink != pMemLink->pnextRaw)
{
(*ppMemLink)->pnextRaw = pMemLink->pnextRaw;
}
if ((pMemLink->blockType & RTMEMLINK) &&
if ((pMemLink->blockType & RTMEMLINK) &&
(pMemLink->blockType & RTMEMMALLOC))
{
ast_free(pMemLink);
@@ -461,7 +461,7 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
RTMEMDIAG2 ("memHeapFreePtr: "
"the element 0x%x is already freed!\n", pElem);
ast_mutex_unlock(&pMemHeap->pLock);
return;
return;
}
if (ISSAVED (pElem)) {
@@ -475,17 +475,17 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
CHECKMEMBLOCK(pMemHeap, pMemBlk);
RTMEMDIAG2 ("memHeapFreePtr: pMemBlk = 0x%x\n", pMemBlk);
RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->size = %d\n",
RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->size = %d\n",
pMemBlk->nunits * 8u);
if (ISLAST (pElem)) { /* is it the last? */
OSMemElemDescr* pPrevElem = GETPREV (pElem);
CHECKMEMELEM (pMemBlk, pPrevElem);
pMemBlk->free_x -= (pElem_nunits (pElem) + 1);
FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u],
FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u],
(pElem_nunits (pElem) + 1) * 8u);
if (pPrevElem != 0 && ISFREE (pPrevElem)) {
@@ -494,10 +494,10 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
pMemBlk->free_x -= (pElem_nunits (pPrevElem) + 1);
pMemBlk->freeMem -= pElem_nunits (pPrevElem);
SET_LAST_ELEM (pMemBlk, GETPREV (pPrevElem));
/* wasn't it the last elem in block? */
if (pMemBlk->lastElemOff != 0) {
if (pMemBlk->lastElemOff != 0) {
/* correct nextFreeOff for previous free element */
pFreeElem = GET_FREE_ELEM (pMemBlk);
@@ -506,7 +506,7 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
}
else {
OSMemElemDescr* pNextFree = 0;
while (pFreeElem < pPrevElem) {
pNextFree = pFreeElem;
pFreeElem = GET_NEXT_FREE (pFreeElem);
@@ -519,15 +519,15 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
SET_LAST_ELEM (pMemBlk, pPrevElem);
}
RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->free_x = %d\n",
RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->free_x = %d\n",
pMemBlk->free_x);
/* The question is: do we really want to get rid of the */
/* block or should we keep it around for reuse? */
if (pMemBlk->lastElemOff == 0) { /* was it the last elem in block? */
if ((pMemHeap->flags & RT_MH_DONTKEEPFREE) ||
(pMemHeap->keepFreeUnits > 0 &&
(pMemHeap->keepFreeUnits > 0 &&
pMemHeap->freeUnits + pMemBlk->nunits > pMemHeap->keepFreeUnits))
{
ASN1OCTET blockType = pMemBlk->plink->blockType;
@@ -544,7 +544,7 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
pMemBlk->plink->pprev->pnext = pMemBlk->plink->pnext;
}
else { /* head */
if (pMemBlk->plink->pnext != 0 &&
if (pMemBlk->plink->pnext != 0 &&
!(pMemBlk->plink->pnext->blockType & RTMEMRAW))
{
pMemBlk->plink->pnext->pnextRaw = (*ppMemLink)->pnextRaw;
@@ -553,14 +553,14 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
}
FILLFREEMEM (pMemBlk->plink, sizeof (*pMemBlk->plink));
FILLFREEMEM (pMemBlk->data, (pMemBlk->nunits * 8u));
ast_free(pMemBlk->plink);
if (!(blockType & RTMEMLINK)) {
FILLFREEMEM (pMemBlk, sizeof (*pMemBlk));
ast_free(pMemBlk);
}
RTMEMDIAG2 ("memHeapFreePtr: pMemBlk = 0x%x was freed\n",
RTMEMDIAG2 ("memHeapFreePtr: pMemBlk = 0x%x was freed\n",
pMemBlk);
}
else {
@@ -576,7 +576,7 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
}
else {
SET_LAST (GET_LAST_ELEM (pMemBlk));
FILLFREEMEM (((char*) &pMemBlk->data[0]) + (pMemBlk->free_x * 8u),
FILLFREEMEM (((char*) &pMemBlk->data[0]) + (pMemBlk->free_x * 8u),
(pMemBlk->nunits - pMemBlk->free_x) * 8u);
CHECKMEMBLOCK (pMemHeap, pMemBlk);
}
@@ -587,25 +587,25 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
SET_FREE_ELEM(pMemBlk, pElem);
pMemBlk->freeMem += pElem_nunits (pElem);
RTMEMDIAG2 ("memHeapFreePtr: element 0x%x marked as free.\n",
RTMEMDIAG2 ("memHeapFreePtr: element 0x%x marked as free.\n",
pElem);
/* try to unite free blocks, if possible */
if (!ISFIRST (pElem)) {
if (ISFREE (GETPREV (pElem))) {
OSMemElemDescr* prevelem_p = GETPREV (pElem);
/* +1 because the OSMemElemDescr has size ONE unit (8 bytes) */
pElem_nunits (prevelem_p) += pElem_nunits (pElem) + 1;
pElem_nunits (prevelem_p) += pElem_nunits (pElem) + 1;
pElem = prevelem_p;
pMemBlk->freeMem ++; /* sizeof (OSMemElemDescr) == 1 unit */
}
else {
/* look for nearest previous free block to correct nextFreeOff */
OSMemElemDescr* prevelem_p = pElem;
do {
prevelem_p = GETPREV (prevelem_p);
}
@@ -613,32 +613,32 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
if (prevelem_p != 0) {
OSMemElemDescr* pNextFree = GET_NEXT_FREE (prevelem_p);
if (pNextFree != 0)
if (pNextFree != 0)
pElem_nextFreeOff (pElem) = QOFFSETOF (pNextFree, pElem);
else
pElem_nextFreeOff (pElem) = 0;
pElem_nextFreeOff (prevelem_p) = QOFFSETOF (pElem, prevelem_p);
CHECKMEMELEM (pMemBlk, prevelem_p);
}
}
}
if (!ISLAST (pElem) && ISFREE (GETNEXT (pElem))) {
OSMemElemDescr* nextelem_p = GETNEXT (pElem);
/* +1 because the OSMemElemDescr has size ONE unit (8 bytes) */
pElem_nunits (pElem) += pElem_nunits (nextelem_p) + 1;
pElem_nunits (pElem) += pElem_nunits (nextelem_p) + 1;
if (pElem_nextFreeOff (nextelem_p) == 0)
pElem_nextFreeOff (pElem) = 0;
else
pElem_nextFreeOff (pElem) =
pElem_nextFreeOff (pElem) =
QOFFSETOF (GET_NEXT_FREE (nextelem_p), pElem);
pMemBlk->freeMem ++;
}
/* correct the prevOff field of next element */
if (!ISLAST (pElem)) {
if (!ISLAST (pElem)) {
OSMemElemDescr* nextelem_p = GETNEXT (pElem);
pElem_prevOff (nextelem_p) = QOFFSETOF (nextelem_p, pElem);
}
@@ -649,10 +649,10 @@ void memHeapFreePtr (void** ppvMemHeap, void* mem_p)
CHECKMEMBLOCK (pMemHeap, pMemBlk);
}
ast_mutex_unlock(&pMemHeap->pLock);
}
}
static void initNewFreeElement (OSMemBlk* pMemBlk,
OSMemElemDescr* pNewElem, OSMemElemDescr* pElem)
static void initNewFreeElement (OSMemBlk* pMemBlk,
OSMemElemDescr* pNewElem, OSMemElemDescr* pElem)
{
OSMemElemDescr *pNextElem, *pPrevElem = 0;
@@ -663,11 +663,11 @@ static void initNewFreeElement (OSMemBlk* pMemBlk,
pElem_prevOff (pNewElem) = QOFFSETOF (pNewElem, pElem);
if (pMemBlk->freeElemOff != 0 &&
if (pMemBlk->freeElemOff != 0 &&
pMemBlk->freeElemOff < QOFFSETOF (pElem, pMemBlk->data) + 1)
{
/* look for nearest previous free block to correct its nextFreeOff */
pPrevElem = pElem;
do {
@@ -678,21 +678,21 @@ static void initNewFreeElement (OSMemBlk* pMemBlk,
if (pPrevElem != 0) { /* if it is not first free element... */
/* correct nextFreeOff for prev free element */
pElem_nextFreeOff (pPrevElem) = QOFFSETOF (pNewElem, pPrevElem);
}
else { /* if it is first free element in the block */
FORCE_SET_FREE_ELEM (pMemBlk, pNewElem);
}
pNextElem = GETNEXT (pNewElem);
if (ISFREE (pNextElem)) {
/* if the next elem is free, then unite them together */
pElem_nunits (pNewElem) += pElem_nunits (pNextElem) + 1;
if (pElem_nextFreeOff (pNextElem) != 0)
pElem_nextFreeOff (pNewElem) = QOFFSETOF (GET_NEXT_FREE (pNextElem),
pElem_nextFreeOff (pNewElem) = QOFFSETOF (GET_NEXT_FREE (pNextElem),
pNewElem);
else
pElem_nextFreeOff (pNewElem) = 0;
@@ -710,7 +710,7 @@ static void initNewFreeElement (OSMemBlk* pMemBlk,
pNextElem = GETNEXT (pNextElem);
/* set nextFreeOff for new element */
if (pNextElem != 0)
pElem_nextFreeOff (pNewElem) = QOFFSETOF (pNextElem, pNewElem);
else
@@ -746,15 +746,15 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnextRaw) {
if ((pMemLink->blockType & RTMEMRAW) &&
pMemLink->pMemBlk == mem_p)
pMemLink->pMemBlk == mem_p)
{
if (pMemLink->blockType & RTMEMMALLOC) {
void *newMemBlk = ast_realloc(pMemLink->pMemBlk, nbytes_);
if (newMemBlk == 0)
if (newMemBlk == 0)
return 0;
pMemLink->pMemBlk = newMemBlk;
}
else
else
return 0;
*(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = nbytes_;
return pMemLink->pMemBlk;
@@ -768,7 +768,7 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
pElem = (OSMemElemDescr*) (((char*)mem_p) - sizeof_OSMemElemDescr);
RTMEMDIAG3 ("memHeapRealloc: mem_p = 0x%x, old size = %d,", mem_p,
RTMEMDIAG3 ("memHeapRealloc: mem_p = 0x%x, old size = %d,", mem_p,
pElem_nunits (pElem) * 8u);
RTMEMDIAG2 (" new nbytes = %d\n", nbytes);
@@ -781,39 +781,39 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
CHECKMEMBLOCK(pMemHeap, pMemBlk);
if ((unsigned)pElem_nunits (pElem) < nunits) { /* expanding */
if (nunits - pElem_nunits (pElem) <= (unsigned)pMemBlk->nunits) {
/* Try to expand the existing element in the existing block */
if (ISLAST (pElem)) { /* if the last element in the block */
/* if the free space in the block is enough */
if ((int)(nunits - pElem_nunits (pElem)) <=
(int)(pMemBlk->nunits - pMemBlk->free_x))
{
if ((int)(nunits - pElem_nunits (pElem)) <=
(int)(pMemBlk->nunits - pMemBlk->free_x))
{
pMemBlk->free_x += nunits - pElem_nunits (pElem);
pElem_nunits (pElem) = (ASN1USINT)nunits;
RTMEMDIAG1 ("memHeapRealloc: "
"memory element is expanded.\n");
FILLNEWMEM (&pMemBlk->data [(pMemBlk->free_x -
(nunits - pElem_nunits (pElem))) * 8u],
FILLNEWMEM (&pMemBlk->data [(pMemBlk->free_x -
(nunits - pElem_nunits (pElem))) * 8u],
(nunits - pElem_nunits (pElem)) * 8u);
TRACEMEMELEM (pMemBlk, pElem, "Reallocated");
CHECKMEMELEM (pMemBlk, pElem);
CHECKMEMBLOCK (pMemHeap, pMemBlk);
return (mem_p);
}
}
}
else {
OSMemElemDescr* pNextElem, *pFreeElem;
OSMemElemDescr* pNextElem, *pFreeElem;
unsigned sumSize = pElem_nunits (pElem), freeMem = 0;
RTMEMDIAG1 ("memHeapRealloc: look for free element after "
"current block.\n");
@@ -822,10 +822,10 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
pNextElem = GETNEXT (pElem);
if (ISFREE (pNextElem)) {
/* +1 'cos sizeof (OSMemElemDescr) == 1 unit */
sumSize += pElem_nunits (pNextElem) + 1;
sumSize += pElem_nunits (pNextElem) + 1;
freeMem++;
}
if (sumSize >= nunits) {
RTMEMDIAG1 ("memHeapRealloc: reuse free element.\n");
@@ -836,15 +836,15 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
FORCE_SET_FREE_ELEM (pMemBlk, GET_NEXT_FREE (pNextElem));
}
else if (pFreeElem < pElem) {
/* look for previous free elem to correct nextFreeOff */
for (; pFreeElem != 0 && pFreeElem < pNextElem;) {
OSMemElemDescr* pNextFreeElem =
OSMemElemDescr* pNextFreeElem =
GET_NEXT_FREE (pFreeElem);
if (pNextFreeElem == pNextElem) {
if (pElem_nextFreeOff (pNextElem) != 0)
pElem_nextFreeOff (pFreeElem) = QOFFSETOF
pElem_nextFreeOff (pFreeElem) = QOFFSETOF
(GET_NEXT_FREE (pNextElem), pFreeElem);
else
pElem_nextFreeOff (pFreeElem) = 0;
@@ -857,15 +857,15 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
}
/* reuse empty elements after the pElem */
pMemBlk->freeMem += freeMem;
if (sumSize - nunits > 1) {
OSMemElemDescr* pNewElem;
/* if sumSize is too large, then create new empty element */
pNewElem = (OSMemElemDescr*)
pNewElem = (OSMemElemDescr*)
(pElem_data (pElem) + nbytes);
pElem_nunits (pNewElem) = (ASN1USINT)(sumSize - nunits - 1);
@@ -885,7 +885,7 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
if (pNextElem != 0)
pElem_prevOff (pNextElem) = QOFFSETOF (pNextElem, pElem);
}
TRACEMEMELEM (pMemBlk, pElem, "Reallocated");
CHECKMEMELEM (pMemBlk, pElem);
CHECKMEMELEM (pMemBlk, (!ISLAST (pElem)) ? GETNEXT (pElem) : 0);
@@ -902,14 +902,14 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
CHECKMEMHEAP (pMemHeap);
newMem_p = memHeapAlloc (ppvMemHeap, nbytes);
if (newMem_p == 0)
return 0;
/* if the old memory block is marked as saved then mark the new block
as saved as well. */
if (ISSAVED (pElem))
if (ISSAVED (pElem))
memHeapMarkSaved (ppvMemHeap, newMem_p, TRUE);
CHECKMEMHEAP (pMemHeap);
@@ -928,7 +928,7 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
}
else { /* shrinking */
RTMEMDIAG1 ("memHeapRealloc: shrinking ...\n");
/* just free the pointer, if nbytes == 0 */
if (nbytes == 0) {
@@ -940,15 +940,15 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
/* do not shrink, if size diff is too small */
/* sizeof (OSMemElemDescr) == 1 unit */
if (pElem_nunits (pElem) - nunits > 1) {
/* if it is the last element in the block, then just change the size
if (pElem_nunits (pElem) - nunits > 1) {
/* if it is the last element in the block, then just change the size
and free_x. */
if (ISLAST (pElem)) {
pMemBlk->free_x -= (pElem_nunits (pElem) - nunits);
FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u],
FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u],
(pElem_nunits (pElem) - nunits) * 8u);
}
else {
@@ -959,14 +959,14 @@ void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_)
pNewElem = (OSMemElemDescr*) (pElem_data (pElem) + nbytes);
/* sizeof (OSMemElemDescr) == 1 unit */
pElem_nunits (pNewElem) = (ASN1USINT)(pElem_nunits (pElem) - nunits - 1);
pElem_nunits (pNewElem) = (ASN1USINT)(pElem_nunits (pElem) - nunits - 1);
initNewFreeElement (pMemBlk, pNewElem, pElem);
pMemBlk->freeMem += (pElem_nunits (pElem) - nunits) - 1;
}
pElem_nunits (pElem) = (ASN1USINT)nunits;
TRACEMEMELEM (pMemBlk, pElem, "Reallocated");
CHECKMEMELEM (pMemBlk, pElem);
CHECKMEMELEM (pMemBlk, (!ISLAST (pElem)) ? GETNEXT (pElem) : pElem);
@@ -1000,9 +1000,9 @@ void memHeapFreeAll (void** ppvMemHeap)
pMemLink2 = pMemLink;
pMemLink = pMemLink2->pnext;
RTMEMDIAG3 ("memHeapFreeAll: pMemLink2 = 0x%x, pMemLink = 0x%x\n",
RTMEMDIAG3 ("memHeapFreeAll: pMemLink2 = 0x%x, pMemLink = 0x%x\n",
pMemLink2, pMemLink);
#ifdef _MEMDEBUG
if (pMemLink2->blockType & RTMEMSTD) {
OSMemBlk* pMemBlk = (OSMemBlk*) pMemLink2->pMemBlk;
@@ -1036,9 +1036,9 @@ void memHeapFreeAll (void** ppvMemHeap)
/* free link and block */
if (((pMemLink2->blockType & RTMEMSTD) ||
if (((pMemLink2->blockType & RTMEMSTD) ||
(pMemLink2->blockType & RTMEMMALLOC)) &&
!(pMemLink2->blockType & RTMEMLINK))
!(pMemLink2->blockType & RTMEMLINK))
ast_free(pMemLink2->pMemBlk);
ast_free(pMemLink2);
}
@@ -1089,11 +1089,11 @@ void memHeapRelease (void** ppvMemHeap)
/* This function is used for marking memory block as "saved". It means
* that the memory block containing the specified memory pointer won't be
* freed after calls to memHeapFreeAll/memHeapReset. User is responsible
* freed after calls to memHeapFreeAll/memHeapReset. User is responsible
* for freeing the marked memory block by call to memFreeBlock */
void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p,
ASN1BOOL saved)
void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p,
ASN1BOOL saved)
{
OSMemHeap* pMemHeap;
OSMemLink* pMemLink;
@@ -1101,7 +1101,7 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p,
RTMEMDIAG2 ("memHeapMarkSaved: for mem_p = 0x%x\n", mem_p);
if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0)
if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0)
return 0;
pMemHeap = *(OSMemHeap**)ppvMemHeap;
@@ -1114,7 +1114,7 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p,
for (; pMemLink != 0; pMemLink = pMemLink->pnextRaw) {
if ((pMemLink->blockType & RTMEMRAW) &&
pMemLink->pMemBlk == mem_p)
pMemLink->pMemBlk == mem_p)
{
break;
}
@@ -1132,7 +1132,7 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p,
"already free!\n", pElem);
ast_mutex_unlock(&pMemHeap->pLock);
return 0;
return 0;
}
if ((ISSAVED (pElem) && !saved) || (!ISSAVED (pElem) && saved)) {
@@ -1144,7 +1144,7 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p,
pMemLink = pMemBlk->plink;
if (saved)
if (saved)
SET_SAVED (pMemBlk, pElem);
else
CLEAR_SAVED (pMemBlk, pElem);
@@ -1154,7 +1154,7 @@ void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p,
ast_mutex_unlock(&pMemHeap->pLock);
return 0;
}
if (saved && nsaved > 0)
if (saved && nsaved > 0)
pMemLink->blockType |= RTMEMSAVED;
else if (nsaved == 0)
pMemLink->blockType &= (~RTMEMSAVED);
@@ -1204,16 +1204,16 @@ void memHeapReset (void** ppvMemHeap)
/* add memory block to list */
static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink,
static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink,
void* pMemBlk, int blockType)
{
OSMemLink* pMemLink;
/* if pMemBlk has RTMEMLINK flags it means that it is allocated
/* if pMemBlk has RTMEMLINK flags it means that it is allocated
* cooperatively with OSMemLink, and we don't need to do additional
* allocations for it. Just use pointer's arithemtic. */
if (blockType & RTMEMLINK)
if (blockType & RTMEMLINK)
pMemLink = (OSMemLink*) (((ASN1OCTET*)pMemBlk) - sizeof (OSMemLink));
else {
pMemLink = ast_malloc(sizeof(OSMemLink) + sizeof(int));
@@ -1222,7 +1222,7 @@ static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink,
to perform rtMemRealloc through malloc/memcpy/free */
*(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = (int)-1;
}
if (pMemLink == NULL)
if (pMemLink == NULL)
return NULL;
pMemLink->blockType = (ASN1OCTET)blockType;
pMemLink->pMemBlk = pMemBlk;
@@ -1241,15 +1241,15 @@ static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink,
pMemLink->pnextRaw = 0;
}
*ppMemLink = pMemLink;
*ppMemLink = pMemLink;
if (pMemLink->pnext != 0)
pMemLink->pnext->pprev = pMemLink;
((OSMemBlk*)pMemBlk)->plink = pMemLink; /*!AB */
RTMEMDIAG2 ("memHeapAddBlock: pMemLink = 0x%x\n", pMemLink);
RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pnext = 0x%x\n",
RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pnext = 0x%x\n",
pMemLink->pnext);
RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pprev = 0x%x\n",
RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pprev = 0x%x\n",
pMemLink->pprev);
return pMemLink;
@@ -1262,7 +1262,7 @@ int memHeapCheckPtr (void** ppvMemHeap, void* mem_p)
RTMEMDIAG2 ("memHeapCheckPtr: for mem_p = 0x%x\n", mem_p);
if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0)
if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0)
return 0;
pMemHeap = *(OSMemHeap**)ppvMemHeap;
@@ -1272,7 +1272,7 @@ int memHeapCheckPtr (void** ppvMemHeap, void* mem_p)
for (; pMemLink != 0; pMemLink = pMemLink->pnext) {
if (pMemLink->blockType & RTMEMRAW) {
/* if RAW block, the pointer should be stored in pMemBlk */
if (pMemLink->pMemBlk == mem_p) {
@@ -1282,17 +1282,17 @@ int memHeapCheckPtr (void** ppvMemHeap, void* mem_p)
}
else {
OSMemBlk* pMemBlk = (OSMemBlk*)pMemLink->pMemBlk;
/* Check, is the pointer inside this memory page */
if (mem_p > pMemLink->pMemBlk &&
if (mem_p > pMemLink->pMemBlk &&
mem_p < (void*)(((ASN1OCTET*)pMemLink->pMemBlk) + pMemBlk->nunits * 8u))
{
/* Check, is the pointer a correct element of the mem page */
OSMemElemDescr* pElem = (OSMemElemDescr*) pMemBlk->data;
for (; pElem != 0; pElem = GETNEXT (pElem)) {
void* curMem_p = (void*) pElem_data (pElem);
if (curMem_p == mem_p && !ISFREE (pElem)) {
ast_mutex_unlock(&pMemHeap->pLock);
@@ -1311,7 +1311,7 @@ void memHeapSetProperty (void** ppvMemHeap, ASN1UINT propId, void* pProp)
{
OSMemHeap* pMemHeap;
if (ppvMemHeap == 0)
if (ppvMemHeap == 0)
return;
if (*ppvMemHeap == 0)
@@ -1332,9 +1332,9 @@ void memHeapSetProperty (void** ppvMemHeap, ASN1UINT propId, void* pProp)
break;
}
ast_mutex_unlock(&pMemHeap->pLock);
}
}
int memHeapCreate (void** ppvMemHeap)
int memHeapCreate (void** ppvMemHeap)
{
OSMemHeap* pMemHeap;
if (ppvMemHeap == 0) return ASN_E_INVPARAM;
@@ -1349,4 +1349,3 @@ int memHeapCreate (void** ppvMemHeap)
*ppvMemHeap = (void*)pMemHeap;
return ASN_OK;
}