int
SASSimpleStackDealloc (SASSimpleStack_t heap, void *stack_pointer)
{
SASSimpleStackHeader *headerBlock = (SASSimpleStackHeader *) heap;
node_size_t new_sp = (node_size_t) stack_pointer;
int rc = -1;
if (SOMSASCheckBlockSigAndType ((SASBlockHeader *) headerBlock,
SAS_RUNTIME_SIMPLESTACK))
{
SASLock (headerBlock, SasUserLock__WRITE);
if ((new_sp >= headerBlock->start_stack)
&& (new_sp <= headerBlock->end_stack))
{
new_sp &= headerBlock->align_mask;
if (new_sp == (node_size_t) stack_pointer)
{
headerBlock->next_stack = new_sp;
rc = 0;
}
else
{
rc = -3;
#ifdef __SASDebugPrint__
sas_printf
("SASSimpleStackDealloc(%p, %p) alignment check failed\n",
heap, stack_pointer);
#endif
}
}
else
{
rc = -2;
#ifdef __SASDebugPrint__
sas_printf
("SASSimpleStackDealloc(%p, %p) contained check failed\n", heap,
stack_pointer);
#endif
}
SASUnlock (headerBlock);
#ifdef __SASDebugPrint__
}
else
{
sas_printf ("SASSimpleStackDealloc(%p, %p) type check failed\n",
heap, stack_pointer);
#endif
}
return rc;
}
SASStringBTreeEnum_t
SASStringBTreeEnumCreateStartAt (SASStringBTree_t tree, char *start_key)
{
__SBEnumeration *stringenum = NULL;
char *maxkey;
size_t startkey_len = strlen (start_key) + 1;
stringenum =
(__SBEnumeration *) malloc (sizeof (__SBEnumeration) + startkey_len);
if (stringenum != NULL)
{
SASLock (tree, SasUserLock__WRITE);
maxkey = SASStringBTreeGetMaxKey (tree);
if ((maxkey != NULL) && (strcmp (start_key, maxkey) < 0))
{
stringenum->curmod = SASStringBTreeGetModCount (tree);
stringenum->curcount = SASStringBTreeGetCurCount (tree);
if (stringenum->curmod != 0L)
{
stringenum->hasmore = (strcmp (start_key, maxkey) < 0);
stringenum->tree = tree;
stringenum->ref.node = NULL;
stringenum->ref.pos = 0;
memcpy ((char *) &stringenum->entryString[0],
start_key, startkey_len);
if (stringenum->entryString[0] != '\0')
stringenum->entryString[startkey_len - 2] -= 1;
stringenum->curkey = &stringenum->entryString[0];
}
else
{
free (stringenum);
stringenum = NULL;
}
}
else
{
free (stringenum);
stringenum = NULL;
}
SASUnlock (tree);
}
return (SASStringBTreeEnum_t) stringenum;
}
void *
SASSimpleStackNearAlloc (void *nearObj, block_size_t alloc_size)
{
SASBlockHeader *nearHeader = SASFindHeader (nearObj);
void *stack_alloc = NULL;
if (nearHeader != NULL)
{
if (SOMSASCheckBlockSig (nearHeader))
{
if (SOMSASCheckBlockSigAndType ((SASBlockHeader *) nearHeader,
SAS_RUNTIME_SIMPLESTACK))
{
SASSimpleStack_t nearStack = (SASSimpleStack_t) nearHeader;
SASLock (nearHeader, SasUserLock__WRITE);
stack_alloc = SASSimpleStackAllocNoLock (nearStack, alloc_size);
SASUnlock (nearHeader);
#ifdef __SASDebugPrint__
}
else
{
sas_printf
("SASSimpleStackNearAlloc(%p, %zu) type check failed @%p\n",
nearObj, alloc_size, nearHeader);
#endif
}
#ifdef __SASDebugPrint__
}
else
{
sas_printf
("SASSimpleStackNearAlloc(%p, %zu) block check failed @%p\n",
nearObj, alloc_size, nearHeader);
#endif
}
#ifdef __SASDebugPrint__
}
else
{
sas_printf ("SASSimpleStackNearAlloc(%p, %zu) find header failed\n",
nearObj, alloc_size);
#endif
}
return stack_alloc;
}
int
SPHLogPortalDestroy(SPHLogPortal_t portal)
{
SASBlockHeader *headerBlock = (SASBlockHeader*) portal;
int rc;
if (SOMSASCheckBlockSigAndTypeAndSubtype(headerBlock, SAS_RUNTIME_LOGPORTAL)) {
SASLock(portal, SasUserLock__WRITE);
rc = SPFLogPortalDestroyNoLock(portal);
SASUnlock(portal);
} else {
#ifdef __SASDebugPrint__
sas_printf("SPHLogPortalDestroy(%p) does not match type/subtype\n", portal);
#endif
rc = -1;
}
return rc;
}
void *
SASSimpleStackAlloc (SASSimpleStack_t heap, block_size_t alloc_size)
{
SASBlockHeader *headerBlock = (SASBlockHeader *) heap;
void *stack_alloc = NULL;
if (SOMSASCheckBlockSigAndType (headerBlock, SAS_RUNTIME_SIMPLESTACK))
{
SASLock (heap, SasUserLock__WRITE);
stack_alloc = SASSimpleStackAllocNoLock (heap, alloc_size);
SASUnlock (heap);
#ifdef __SASDebugPrint__
}
else
{
sas_printf ("SASSimpleStackAlloc(%p, %zu) type check failed\n",
heap, alloc_size);
#endif
}
return stack_alloc;
}
block_size_t
SASSimpleStackFreeSpace (SASSimpleStack_t heap)
{
SASBlockHeader *headerBlock = (SASBlockHeader *) heap;
block_size_t heapFree = 0;
if (SOMSASCheckBlockSigAndType ((SASBlockHeader *) headerBlock,
SAS_SIMPLESTACK_TYPE))
{
SASLock (heap, SasUserLock__WRITE);
heapFree = SASSimpleStackFreeSpaceNoLock (heap);
SASUnlock (heap);
#ifdef __SASDebugPrint__
}
else
{
sas_printf ("SASSimpleStackFreeSpace(%p) does not match type/subtype\n",
heap);
#endif
}
return heapFree;
}
int
SASSimpleStackDestroy (SASSimpleStack_t heap)
{
SASBlockHeader *headerBlock = (SASBlockHeader *) heap;
int rc;
if (SOMSASCheckBlockSigAndTypeAndSubtype (headerBlock,
SAS_RUNTIME_SIMPLESTACK))
{
SASLock (heap, SasUserLock__WRITE);
rc = SASSimpleStackDestroyNoLock (heap);
SASUnlock (heap);
}
else
{
#ifdef __SASDebugPrint__
sas_printf ("SASSimpleStackDestroy(%p) does not match type/subtype\n",
heap);
#endif
rc = -1;
}
return rc;
}
void *
SASStringBTreeEnumNext (SASStringBTreeEnum_t sbtenum)
{
__SBEnumeration *stringenum = (__SBEnumeration *) sbtenum;
void *result = NULL;
bool found = false;
char *maxkey;
SASLock (stringenum->tree, SasUserLock__WRITE);
maxkey = SASStringBTreeGetMaxKey (stringenum->tree);
#if __SASDebugPrint__ > 1
sas_printf ("SASStringBTreeEnumNext; enum->tree=%p maxkey=%s\n",
stringenum->tree, maxkey);
#endif
if (maxkey != NULL)
{
stringenum->hasmore = (strcmp (stringenum->curkey, maxkey) < 0);
if (stringenum->hasmore)
{
SASStringBTreeNode_t curnode = stringenum->ref.node;
long treemod = SASStringBTreeGetModCount (stringenum->tree);
if ((curnode != NULL) && (treemod == stringenum->curmod))
{
short curpos = stringenum->ref.pos;
SASStringBTreeNodeHeader *curSBnode =
(SASStringBTreeNodeHeader *) curnode;
if (curpos < curSBnode->count)
{
if (curSBnode->branch[curpos] == NULL)
{
curpos++;
stringenum->ref.pos = curpos;
result = curSBnode->vals[curpos];
stringenum->curkey = curSBnode->keys[curpos];
stringenum->hasmore =
(strcmp (stringenum->curkey, maxkey) < 0);
found = true;
}
else
{
found =
SASStringBTreeNodeSearchGT (curnode,
stringenum->curkey,
&stringenum->ref);
if (found)
{
curnode = stringenum->ref.node;
curSBnode = (SASStringBTreeNodeHeader *) curnode;
curpos = stringenum->ref.pos;
result = curSBnode->vals[curpos];
stringenum->curkey = curSBnode->keys[curpos];
stringenum->curcount -= 1;
stringenum->hasmore =
(strcmp (stringenum->curkey, maxkey) < 0);
}
}
if (stringenum->hasmore)
stringenum->curcount -= 1;
else if (found)
stringenum->curcount = 1;
else
stringenum->curcount = 0;
}
}
if (!found)
{
#if __SASDebugPrint__ > 1
sas_printf ("SASStringBTreeEnumNext; !found enum->tree=%s\n",
stringenum->tree, stringenum->curkey);
#endif
SASStringBTreeNode_t curnode =
SASStringBTreeGetRootNode (stringenum->tree);
if (stringenum->ref.node == NULL)
{
found =
SASStringBTreeNodeSearchGE (curnode, stringenum->curkey,
&stringenum->ref);
#if __SASDebugPrint__ > 1
sas_printf ("SASStringBTreeEnumNext; !found curnode=%p SearchGE=%d\n",
curnode, found);
#endif
} else {
found =
SASStringBTreeNodeSearchGT (curnode, stringenum->curkey,
&stringenum->ref);
#if __SASDebugPrint__ > 1
sas_printf ("SASStringBTreeEnumNext; !found curnode=%p SearchGT=%d\n",
curnode, found);
#endif
}
if (found)
{
short curpos = stringenum->ref.pos;
SASStringBTreeNodeHeader *curSBnode =
(SASStringBTreeNodeHeader *) stringenum->ref.node;
result = curSBnode->vals[curpos];
stringenum->curkey = curSBnode->keys[curpos];
stringenum->curmod = treemod;
stringenum->curcount =
SASStringBTreeGetCurCount (stringenum->tree);
stringenum->hasmore =
(strcmp (stringenum->curkey, maxkey) < 0);
#if __SASDebugPrint__ > 1
sas_printf ("SASStringBTreeEnumNext; curpos=%hd node=%p result=%p\n",
curpos, curSBnode, result);
#endif
}
else
{
stringenum->hasmore = false;
}
}
}
#ifdef __SASDebugPrint__
}
else
{
sas_printf ("SASStringBTreeEnumNext; enum->tree=%p invalid\n",
stringenum->tree);
#endif
}
SASUnlock (stringenum->tree);
// sas_printf("{%s,%s,%d}",stringenum->curkey, maxkey, stringenum->hasmore);
return result;
}
