Beispiel #1
0
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;
}
Beispiel #2
0
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;
}
Beispiel #3
0
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;
}
Beispiel #4
0
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;
}
Beispiel #5
0
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;
}
Beispiel #6
0
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;
}
Beispiel #7
0
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;
}
Beispiel #8
0
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;
}