C++ (Cpp) _trmem_realloc 예제들

예제 #1

파일: memfuncs.c 프로젝트: ABratovic/open-watcom-v2

void *MemRealloc( void *ptr, size_t size )
/****************************************/
{
    MemPtr  *mptr;
    if( ptr ) {
        mptr = ptr;
        mptr--;
        if( mptr == memPtr ) {
            memPtr = mptr->next;
        }
        if( mptr->prev ) {
            mptr->prev->next = mptr->next;
        }
        if( mptr->next ) {
            mptr->next->prev = mptr->prev;
        }
        ptr = mptr;
    }
#ifdef TRMEM
    mptr = _trmem_realloc( ptr, size + sizeof( MemPtr ), _trmem_guess_who(), TRMemHandle );
#else
    mptr = realloc( ptr, size + sizeof( MemPtr ) );
#endif
    if( mptr == NULL )
        FatalError( ERR_NO_MEMORY );
    mptr->next = memPtr;
    mptr->prev = NULL;
    if( memPtr ) {
        memPtr->prev = mptr;
    }
    memPtr = mptr;

    return( mptr + 1 );
}

예제 #2

void *WRAPI WRMemRealloc( void *ptr, size_t size )
{
#ifdef TRMEM
    return( _trmem_realloc( ptr, size, _trmem_guess_who(), TRMemHandle ) );
#else
    return( realloc( ptr, size ) );
#endif
}

예제 #3

파일: trmemcvr.c 프로젝트: Azarien/open-watcom-v2

extern void * TRMemRealloc( void * ptr, size_t size )
/***************************************************/
{
#ifdef TRMEM
    return( _trmem_realloc( ptr, size, _trmem_guess_who(), TRMemHandle ) );
#else
    return( realloc( ptr, size ) );
#endif
}

예제 #4

파일: mem.c 프로젝트: Azarien/open-watcom-v2

/*
 * doMemReallocUnsafe - reallocate a block, return NULL if it fails
 */
static void *doMemReAllocUnsafe( void *ptr, size_t size, WHO_PTR who )
{
    void        *tmp;

    size_t      orig_size;
#ifdef __WATCOMC__
    size_t      tsize;
#endif

    if( ptr != NULL ) {
#ifdef __WATCOMC__
        orig_size = MSIZE( ptr );
#else
        orig_size = 0xffffffff;
#endif
    } else {
        orig_size = 0;
    }

#ifdef TRMEM
    tmp = _trmem_realloc( ptr, size, who, trmemHandle );
#else
    who = who;
    tmp = realloc( ptr, size );
#endif
#ifdef __WATCOMC__
    if( tmp == NULL ) {
        tmp = doMemAllocUnsafe( size, who );
        if( tmp == NULL ) {
            return( NULL );
        }
        size = MSIZE( tmp );
        if( orig_size != 0 ) {
            tsize = orig_size;
            if( tsize > size ) {
                tsize = size;
            }
            memcpy( tmp, ptr, tsize );
            MemFree( ptr );
        }
    } else
#endif
    {
#ifdef __WATCOMC__
        size = MSIZE( tmp );
#endif
        if( size > orig_size ) {
            memset( &(((char *)tmp)[orig_size]), 0, size - orig_size );
        }
    }
    return( tmp );

} /* doMemReAllocUnsafe */

예제 #5

파일: memfuncs.c 프로젝트: ABratovic/open-watcom-v2

void *MemReallocGlobal( void *ptr, size_t size )
/**********************************************/
{
#ifdef TRMEM
    ptr = _trmem_realloc( ptr, size, _trmem_guess_who(), TRMemHandle );
#else
    ptr = realloc( ptr, size );
#endif
    if( ptr == NULL && size != 0 )
        FatalError( ERR_NO_MEMORY );
    return( ptr );
}

예제 #6

void *MemRealloc( void *ptr, size_t size )
{
    void *p;

#ifdef TRMEM
    p = _trmem_realloc( ptr, size, _trmem_guess_who(), TRMemHandle );
#else
    p = realloc( ptr, size );
#endif

    return( p );
}

예제 #7

파일: rcmem.c 프로젝트: Ukusbobra/open-watcom-v2

void * RcMemRealloc( void * old_ptr, size_t newsize )
/***************************************************/
{
    void *  ptr;

#ifdef RC_USE_TRMEM
    ptr = _trmem_realloc( old_ptr, newsize, _trmem_guess_who(), RcMemHandle );
#else
    ptr = RCMemLayer1Realloc( old_ptr, newsize );
#endif

    if (ptr == NULL && newsize != 0) {
        RcFatalError( ERR_OUT_OF_MEMORY );
    }

    return( ptr );
}

예제 #8

void * WBRRealloc( void * p, size_t size )
/****************************************/
// note: code cloned from above since we need to be able to trace
// calling functions when the memory tracker is in.
{
#ifdef TRACKER
    _trmem_who  caller;

    caller = _trmem_guess_who();
#endif

#ifdef TRACKER
    p = _trmem_realloc( p, size, caller, TrHdl );
#else
    p = realloc( p, size );
#endif
    return p;
}

예제 #9

void *LnkReAlloc( void *src, size_t size )
/****************************************/
// reallocate a block of memory.
{
    void    *dest;
#ifdef TRMEM
    void        (*ra)( void );

    ra = _trmem_guess_who(); /* must be first thing */
#endif
    for( ;; ) {
#ifdef TRMEM
        dest = _trmem_realloc( src, size, ra, TrHdl );
#else
        dest = realloc( src, size );
#endif
        if( dest != NULL ) break;
        if( !CacheRelease() && !SwapOutVirt() && !SwapOutRelocs() ) {
            LnkMsg( FTL + MSG_NO_DYN_MEM, NULL );       // see note 1 below
        }
    }
    return( dest );
}

예제 #10

파일: dynmem.c 프로젝트: NoSuchProcess/open-watcom-v2

static void * TRMemRealloc( void * ptr, size_t size )
/***************************************************/
{
    return( _trmem_realloc( ptr, size, _trmem_guess_who(), TRMemHandle ) );
}