[Python-checkins] CVS: python/dist/src/Objects obmalloc.c,2.2,2.3

Neil Schemenauer nascheme@users.sourceforge.net
Mon, 18 Mar 2002 10:13:44 -0800


Update of /cvsroot/python/python/dist/src/Objects
In directory usw-pr-cvs1:/tmp/cvs-serv3957/Objects

Modified Files:
	obmalloc.c 
Log Message:
Simpilify PyCore_* macros by assuming the function prototypes for
malloc() and free() don't change.


Index: obmalloc.c
===================================================================
RCS file: /cvsroot/python/python/dist/src/Objects/obmalloc.c,v
retrieving revision 2.2
retrieving revision 2.3
diff -C2 -d -r2.2 -r2.3
*** obmalloc.c	11 Mar 2001 18:36:13 -0000	2.2
--- obmalloc.c	18 Mar 2002 18:13:41 -0000	2.3
***************
*** 55,94 ****
  
  /*
-  * Public functions exported by this allocator.
-  *
-  * -- Define and use these names in your code to obtain or release memory --
-  */
- #define _THIS_MALLOC		PyCore_OBJECT_MALLOC_FUNC
- #define _THIS_CALLOC		/* unused */
- #define _THIS_REALLOC		PyCore_OBJECT_REALLOC_FUNC
- #define _THIS_FREE		PyCore_OBJECT_FREE_FUNC
- 
- /*
-  * Underlying allocator's functions called by this allocator.
-  * The underlying allocator is usually the one which comes with libc.
-  *
-  * -- Don't use these functions in your code (to avoid mixing allocators) --
-  *
-  * Redefine these __only__ if you are using a 3rd party general purpose
-  * allocator which exports functions with names _other_ than the standard
-  * malloc, calloc, realloc, free.
-  */
- #define _SYSTEM_MALLOC		PyCore_MALLOC_FUNC
- #define _SYSTEM_CALLOC		/* unused */
- #define _SYSTEM_REALLOC		PyCore_REALLOC_FUNC
- #define _SYSTEM_FREE		PyCore_FREE_FUNC
- 
- /*
-  * If malloc hooks are needed, names of the hooks' set & fetch
-  * functions exported by this allocator.
-  */
- #ifdef WITH_MALLOC_HOOKS
- #define _SET_HOOKS		_PyCore_ObjectMalloc_SetHooks
- #define _FETCH_HOOKS		_PyCore_ObjectMalloc_FetchHooks
- #endif
- 
- /*==========================================================================*/
- 
- /*
   * Allocation strategy abstract:
   *
--- 55,58 ----
***************
*** 386,390 ****
  
  void *
! _THIS_MALLOC(size_t nbytes)
  {
  	block *bp;
--- 350,354 ----
  
  void *
! _PyCore_ObjectMalloc(size_t nbytes)
  {
  	block *bp;
***************
*** 516,520 ****
  		 * per arena due to the required alignment on page boundaries.
  		 */
! 		bp = (block *)_SYSTEM_MALLOC(ARENA_SIZE + SYSTEM_PAGE_SIZE);
  		if (bp == NULL) {
  			UNLOCK();
--- 480,484 ----
  		 * per arena due to the required alignment on page boundaries.
  		 */
! 		bp = (block *)PyCore_MALLOC(ARENA_SIZE + SYSTEM_PAGE_SIZE);
  		if (bp == NULL) {
  			UNLOCK();
***************
*** 547,551 ****
  	 * has been reached.
  	 */
! 	return (void *)_SYSTEM_MALLOC(nbytes);
  }
  
--- 511,515 ----
  	 * has been reached.
  	 */
! 	return (void *)PyCore_MALLOC(nbytes);
  }
  
***************
*** 553,557 ****
  
  void
! _THIS_FREE(void *p)
  {
  	poolp pool;
--- 517,521 ----
  
  void
! _PyCore_ObjectFree(void *p)
  {
  	poolp pool;
***************
*** 573,577 ****
  	pool = (poolp )((block *)p - offset);
  	if (pool->pooladdr != pool || pool->magic != (uint )POOL_MAGIC) {
! 		_SYSTEM_FREE(p);
  		return;
  	}
--- 537,541 ----
  	pool = (poolp )((block *)p - offset);
  	if (pool->pooladdr != pool || pool->magic != (uint )POOL_MAGIC) {
! 		PyCore_FREE(p);
  		return;
  	}
***************
*** 632,636 ****
  
  void *
! _THIS_REALLOC(void *p, size_t nbytes)
  {
  	block *bp;
--- 596,600 ----
  
  void *
! _PyCore_ObjectRealloc(void *p, size_t nbytes)
  {
  	block *bp;
***************
*** 644,648 ****
  
  	if (p == NULL)
! 		return _THIS_MALLOC(nbytes);
  
  	/* realloc(p, 0) on big blocks is redirected. */
--- 608,612 ----
  
  	if (p == NULL)
! 		return _PyCore_ObjectMalloc(nbytes);
  
  	/* realloc(p, 0) on big blocks is redirected. */
***************
*** 655,659 ****
  			goto malloc_copy_free;
  		}
! 		bp = (block *)_SYSTEM_REALLOC(p, nbytes);
  	}
  	else {
--- 619,623 ----
  			goto malloc_copy_free;
  		}
! 		bp = (block *)PyCore_REALLOC(p, nbytes);
  	}
  	else {
***************
*** 664,668 ****
  			   except for realloc(p, 0) == free(p), ret NULL */
  			if (nbytes == 0) {
! 				_THIS_FREE(p);
  				bp = NULL;
  			}
--- 628,632 ----
  			   except for realloc(p, 0) == free(p), ret NULL */
  			if (nbytes == 0) {
! 				_PyCore_ObjectFree(p);
  				bp = NULL;
  			}
***************
*** 674,681 ****
  		malloc_copy_free:
  
! 			bp = (block *)_THIS_MALLOC(nbytes);
  			if (bp != NULL) {
  				memcpy(bp, p, size);
! 				_THIS_FREE(p);
  			}
  		}
--- 638,645 ----
  		malloc_copy_free:
  
! 			bp = (block *)_PyCore_ObjectMalloc(nbytes);
  			if (bp != NULL) {
  				memcpy(bp, p, size);
! 				_PyCore_ObjectFree(p);
  			}
  		}
***************
*** 688,692 ****
  /* -- unused --
  void *
! _THIS_CALLOC(size_t nbel, size_t elsz)
  {
          void *p;
--- 652,656 ----
  /* -- unused --
  void *
! _PyCore_ObjectCalloc(size_t nbel, size_t elsz)
  {
          void *p;
***************
*** 699,703 ****
  
  	nbytes = nbel * elsz;
! 	p = _THIS_MALLOC(nbytes);
  	if (p != NULL)
  		memset(p, 0, nbytes);
--- 663,667 ----
  
  	nbytes = nbel * elsz;
! 	p = _PyCore_ObjectMalloc(nbytes);
  	if (p != NULL)
  		memset(p, 0, nbytes);
***************
*** 715,722 ****
  
  void
! _SET_HOOKS( void *(*malloc_func)(size_t),
! 	    void *(*calloc_func)(size_t, size_t),
! 	    void *(*realloc_func)(void *, size_t),
! 	    void (*free_func)(void *) )
  {
  	LOCK();
--- 679,686 ----
  
  void
! _PyCore_ObjectMalloc_SetHooks( void *(*malloc_func)(size_t),
! 			       void *(*calloc_func)(size_t, size_t),
! 			       void *(*realloc_func)(void *, size_t),
! 			       void (*free_func)(void *) )
  {
  	LOCK();
***************
*** 729,736 ****
  
  void
! _FETCH_HOOKS( void *(**malloc_funcp)(size_t),
! 	      void *(**calloc_funcp)(size_t, size_t),
!               void *(**realloc_funcp)(void *, size_t),
!               void (**free_funcp)(void *) )
  {
  	LOCK();
--- 693,700 ----
  
  void
! _PyCore_ObjectMalloc_FetchHooks( void *(**malloc_funcp)(size_t),
! 				 void *(**calloc_funcp)(size_t, size_t),
! 				 void *(**realloc_funcp)(void *, size_t),
! 				 void (**free_funcp)(void *) )
  {
  	LOCK();