apr-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From dr...@apache.org
Subject cvs commit: apr/memory/unix apr_sms.c apr_sms_std.c apr_sms_tracking.c
Date Sun, 10 Jun 2001 14:45:33 GMT
dreid       01/06/10 07:45:33

  Modified:    include  apr_sms.h
               memory/unix apr_sms.c apr_sms_std.c apr_sms_tracking.c
  Log:
  Renaming of sms to use shorter names, no functional change.
  
  mem_sys => sms
  parent_mem_sys => parent
  child_mem_sys => child
  ref_mem_sys => ref
  accounting_mem_sys => accounting
  sibling_mem_sys => sibling
  
  Revision  Changes    Path
  1.14      +66 -66    apr/include/apr_sms.h
  
  Index: apr_sms.h
  ===================================================================
  RCS file: /home/cvs/apr/include/apr_sms.h,v
  retrieving revision 1.13
  retrieving revision 1.14
  diff -u -r1.13 -r1.14
  --- apr_sms.h	2001/06/08 02:34:23	1.13
  +++ apr_sms.h	2001/06/10 14:45:32	1.14
  @@ -89,11 +89,11 @@
    */
   struct apr_sms_t
   {
  -    apr_sms_t  *parent_mem_sys;
  -    apr_sms_t  *child_mem_sys;
  -    apr_sms_t  *sibling_mem_sys;
  -    apr_sms_t **ref_mem_sys;
  -    apr_sms_t  *accounting_mem_sys;
  +    apr_sms_t  *parent;
  +    apr_sms_t  *child;
  +    apr_sms_t  *sibling;
  +    apr_sms_t **ref;
  +    apr_sms_t  *accounting;
       const char *identity; /* a string identifying the module */
   
       apr_pool_t *pool;
  @@ -101,16 +101,16 @@
       
       struct apr_sms_cleanup *cleanups;
   
  -    void * (*malloc_fn)            (apr_sms_t *mem_sys, apr_size_t size);
  -    void * (*calloc_fn)            (apr_sms_t *mem_sys, apr_size_t size);
  -    void * (*realloc_fn)           (apr_sms_t *mem_sys, void *memory, 
  +    void * (*malloc_fn)            (apr_sms_t *sms, apr_size_t size);
  +    void * (*calloc_fn)            (apr_sms_t *sms, apr_size_t size);
  +    void * (*realloc_fn)           (apr_sms_t *sms, void *memory, 
                                       apr_size_t size);
  -    apr_status_t (*free_fn)        (apr_sms_t *mem_sys, void *memory);
  -    apr_status_t (*reset_fn)       (apr_sms_t *mem_sys);
  -    apr_status_t (*pre_destroy_fn) (apr_sms_t *mem_sys);
  -    apr_status_t (*destroy_fn)     (apr_sms_t *mem_sys);
  -    apr_status_t (*lock_fn)        (apr_sms_t *mem_sys);
  -    apr_status_t (*unlock_fn)      (apr_sms_t *mem_sys);
  +    apr_status_t (*free_fn)        (apr_sms_t *sms, void *memory);
  +    apr_status_t (*reset_fn)       (apr_sms_t *sms);
  +    apr_status_t (*pre_destroy_fn) (apr_sms_t *sms);
  +    apr_status_t (*destroy_fn)     (apr_sms_t *sms);
  +    apr_status_t (*lock_fn)        (apr_sms_t *sms);
  +    apr_status_t (*unlock_fn)      (apr_sms_t *sms);
   };
   
   /*
  @@ -119,46 +119,46 @@
   
   /**
    * Allocate a block of memory using a certain memory system
  - * @param mem_sys The memory system to use
  + * @param sms The memory system to use
    * @param size The (minimal required) size of the block to be allocated
    * @return pointer to a newly allocated block of memory, NULL if insufficient
    *         memory available
  - * @deffunc void *apr_sms_malloc(apr_sms_t *mem_sys, apr_size_t size)
  + * @deffunc void *apr_sms_malloc(apr_sms_t *sms, apr_size_t size)
    */
  -APR_DECLARE(void *) apr_sms_malloc(apr_sms_t *mem_sys, apr_size_t size);
  +APR_DECLARE(void *) apr_sms_malloc(apr_sms_t *sms, apr_size_t size);
   
   /**
    * Allocate a block of zeroed memory using a certain memory system
  - * @param mem_sys The memory system to use
  + * @param sms The memory system to use
    * @param size The (minimal required) size of the block to be allocated
    * @return pointer to a newly allocated block of memory, NULL if insufficient
    *         memory available
  - * @deffunc void *apr_sms_calloc(apr_sms_t *mem_sys, apr_size_t size)
  + * @deffunc void *apr_sms_calloc(apr_sms_t *sms, apr_size_t size)
    */
  -APR_DECLARE(void *) apr_sms_calloc(apr_sms_t *mem_sys, apr_size_t size);
  +APR_DECLARE(void *) apr_sms_calloc(apr_sms_t *sms, apr_size_t size);
   
   /**
    * Change the size of a previously allocated block of memory
  - * @param mem_sys The memory system to use (should be the same as the
  + * @param sms The memory system to use (should be the same as the
    *        one that returned the block)
    * @param mem Pointer to the previously allocated block. If NULL, this
    *        function acts like apr_sms_malloc.
    * @param size The (minimal required) size of the block to be allocated
    * @return pointer to a newly allocated block of memory, NULL if insufficient
    *         memory available
  - * @deffunc void *apr_sms_realloc(apr_sms_t *mem_sys, void *mem, apr_size_t size)
  + * @deffunc void *apr_sms_realloc(apr_sms_t *sms, void *mem, apr_size_t size)
    */
  -APR_DECLARE(void *) apr_sms_realloc(apr_sms_t *mem_sys, void *mem, apr_size_t size);
  +APR_DECLARE(void *) apr_sms_realloc(apr_sms_t *sms, void *mem, apr_size_t size);
   
   /**
    * Free a block of memory
  - * @param mem_sys The memory system to use (should be the same as the
  + * @param sms The memory system to use (should be the same as the
    *        one that returned the block)
    * @param mem The block of memory to be freed
  - * @deffunc void apr_sms_free(apr_sms_t *mem_sys,
  + * @deffunc void apr_sms_free(apr_sms_t *sms,
    *					void *mem)
    */
  -APR_DECLARE(apr_status_t) apr_sms_free(apr_sms_t *mem_sys, void *mem);
  +APR_DECLARE(apr_status_t) apr_sms_free(apr_sms_t *sms, void *mem);
   
   /*
    * memory system functions
  @@ -170,27 +170,27 @@
    *          to serve as a memory system structure from your 
    *          apr_xxx_sms_create. Only use this function when you are
    *          implementing a memory system.
  - * @param mem_sys The memory system created
  - * @param parent_mem_sys The parent memory system
  + * @param sms The memory system created
  + * @param parent_sms The parent memory system
    * @deffunc apr_status_t apr_sms_init(apr_sms_t *sms,
  - *				      apr_sms_t *parent_mem_sys)
  + *				      apr_sms_t *parent_sms)
    */
  -APR_DECLARE(apr_status_t) apr_sms_init(apr_sms_t *mem_sys, 
  -                                       apr_sms_t *parent_mem_sys);
  +APR_DECLARE(apr_status_t) apr_sms_init(apr_sms_t *sms, 
  +                                       apr_sms_t *parent_sms);
   
   /**
    * Check if a memory system is obeying all rules. 
    * @caution Call this function as the last statement before returning a new
    *          memory system from your apr_xxx_sms_create.
  - * @deffunc void apr_sms_validate(apr_sms_t *mem_sys)
  + * @deffunc void apr_sms_validate(apr_sms_t *sms)
    */
   #ifdef APR_ASSERT_MEMORY
  -APR_DECLARE(void) apr_sms_assert(apr_sms_t *mem_sys);
  +APR_DECLARE(void) apr_sms_assert(apr_sms_t *sms);
   #else
   #ifdef apr_sms_assert
   #undef apr_sms_assert
   #endif
  -#define apr_sms_assert(mem_sys)
  +#define apr_sms_assert(sms)
   #endif /* APR_ASSERT_MEMORY */
   
   /**
  @@ -199,33 +199,33 @@
    * @warning This function will fail if there is no reset function available
    *          for the given memory system (i.e. the memory system is non-
    *          tracking).
  - * @param mem_sys The memory system to be reset
  - * @deffunc apr_status_t apr_sms_reset(apr_sms_t *mem_sys)
  + * @param sms The memory system to be reset
  + * @deffunc apr_status_t apr_sms_reset(apr_sms_t *sms)
    */
  -APR_DECLARE(apr_status_t) apr_sms_reset(apr_sms_t *mem_sys);
  +APR_DECLARE(apr_status_t) apr_sms_reset(apr_sms_t *sms);
   
   /**
    * Destroy a memory system, effectively freeing all of its memory, and itself. 
    * This will also run all cleanup functions associated with the memory system.
    * @caution Be carefull when using this function with a non-tracking memory
    *          system
  - * @param mem_sys The memory system to be destroyed
  - * @deffunc apr_status_t apr_sms_destroy(apr_sms_t *mem_sys)
  + * @param sms The memory system to be destroyed
  + * @deffunc apr_status_t apr_sms_destroy(apr_sms_t *sms)
    */
  -APR_DECLARE(apr_status_t) apr_sms_destroy(apr_sms_t *mem_sys);
  +APR_DECLARE(apr_status_t) apr_sms_destroy(apr_sms_t *sms);
   
   /**
    * Perform thread-safe locking required whilst this memory system is modified
  - * @param mem_sys The memory system to be locked for thread-safety
  + * @param sms The memory system to be locked for thread-safety
    */
  -APR_DECLARE(apr_status_t) apr_sms_lock(apr_sms_t *mem_sys);
  +APR_DECLARE(apr_status_t) apr_sms_lock(apr_sms_t *sms);
   
   /**
    * Release thread-safe locking required whilst this memory system was
    * being modified
  - * @param mem_sys The memory system to be released from thread-safety
  + * @param sms The memory system to be released from thread-safety
    */
  -APR_DECLARE(apr_status_t) apr_sms_unlock(apr_sms_t *mem_sys);
  +APR_DECLARE(apr_status_t) apr_sms_unlock(apr_sms_t *sms);
   
   /**
    * Determine if memory system a is an ancestor of memory system b
  @@ -239,10 +239,10 @@
   
   /** 
    * Get the memory_system identity
  - * @param mem_sys The memory system to use
  - * @deffunc const char * apr_sms_identity(apr_sms_t *mem_sys);
  + * @param sms The memory system to use
  + * @deffunc const char * apr_sms_identity(apr_sms_t *sms);
    */
  -APR_DECLARE(const char *) apr_sms_identity(apr_sms_t *mem_sys);
  +APR_DECLARE(const char *) apr_sms_identity(apr_sms_t *sms);
   
   /*
    * memory system cleanup management functions
  @@ -250,75 +250,75 @@
   
   /**
    * Register a function to be called when a memory system is reset or destroyed
  - * @param mem_sys The memory system to register the cleanup function with
  + * @param sms The memory system to register the cleanup function with
    * @param type The type of cleanup to register
    * @param data The data to pass to the cleanup function
    * @param cleanup_fn The function to call when the memory system is reset or
    *        destroyed
  - * @deffunc void apr_sms_cleanup_register(apr_sms_t *mem_sys, apr_int32_t type,
  + * @deffunc void apr_sms_cleanup_register(apr_sms_t *sms, apr_int32_t type,
    *		   void *data, apr_status_t (*cleanup_fn)(void *));
    */
  -APR_DECLARE(apr_status_t) apr_sms_cleanup_register(apr_sms_t *mem_sys, apr_int32_t type,
  +APR_DECLARE(apr_status_t) apr_sms_cleanup_register(apr_sms_t *sms, apr_int32_t type,
                                                      void *data, 
                                                      apr_status_t (*cleanup_fn)(void *));
   
   /**
    * Unregister a previously registered cleanup function
  - * @param mem_sys The memory system the cleanup function is registered
  + * @param sms The memory system the cleanup function is registered
    *        with
    * @param type The type of the cleanup to unregister
    * @param data The data associated with the cleanup function
    * @param cleanup_fn The registered cleanup function
  - * @deffunc void apr_sms_cleanup_unregister(apr_sms_t *mem_sys,
  + * @deffunc void apr_sms_cleanup_unregister(apr_sms_t *sms,
    *		   void *data, apr_status_t (*cleanup_fn)(void *));
    */
  -APR_DECLARE(apr_status_t) apr_sms_cleanup_unregister(apr_sms_t *mem_sys, apr_int32_t type,
  +APR_DECLARE(apr_status_t) apr_sms_cleanup_unregister(apr_sms_t *sms, apr_int32_t type,
                                                        void *data,
                                                        apr_status_t (*cleanup)(void *));
   
   /**
    * Unregister all previously registered cleanup functions of the specified type
  - * @param mem_sys The memory system the cleanup functions are registered with
  + * @param sms The memory system the cleanup functions are registered with
    * @param type The type associated with the cleanup function. Pass 0 to 
    *        unregister all cleanup functions.
  - * @deffunc apr_status_t apr_sms_cleanup_unregister_type(apr_sms_t *mem_sys,
  + * @deffunc apr_status_t apr_sms_cleanup_unregister_type(apr_sms_t *sms,
    *                 apr_int32_t type);
    */
  -APR_DECLARE(apr_status_t) apr_sms_cleanup_unregister_type(apr_sms_t *mem_sys,
  +APR_DECLARE(apr_status_t) apr_sms_cleanup_unregister_type(apr_sms_t *sms,
                                                              apr_int32_t type);
   
   /**
    * Run the specified cleanup function immediately and unregister it
  - * @param mem_sys The memory system the cleanup function is registered
  + * @param sms The memory system the cleanup function is registered
    *        with
  - * @param mem_sys The memory system the cleanup function is registered with
  + * @param sms The memory system the cleanup function is registered with
    * @param type The type associated with the cleanup function. Pass 0 to ignore type.
    * @param data The data associated with the cleanup function
    * @param cleanup The registered cleanup function
  - * @deffunc apr_status_t apr_sms_cleanup_run(apr_sms_t *mem_sys, 
  + * @deffunc apr_status_t apr_sms_cleanup_run(apr_sms_t *sms, 
    *                 apr_int32_t type, void *data, apr_status_t (*cleanup)(void *));
    */
  -APR_DECLARE(apr_status_t) apr_sms_cleanup_run(apr_sms_t *mem_sys, 
  +APR_DECLARE(apr_status_t) apr_sms_cleanup_run(apr_sms_t *sms, 
                                                 apr_int32_t type, void *data,
                                                 apr_status_t (*cleanup)(void *));
   
   /**
    * Run the specified type of cleanup functions immediately and unregister them
  - * @param mem_sys The memory system the cleanup functions are registered with
  + * @param sms The memory system the cleanup functions are registered with
    * @param type The category of cleanup functions to run. Pass 0 to run all
    *        cleanup functions.
  - * @deffunc apr_status_t apr_sms_cleanup_run_type(apr_sms_t *mem_sys,
  + * @deffunc apr_status_t apr_sms_cleanup_run_type(apr_sms_t *sms,
    *	           apr_int32_t type);
    */
  -APR_DECLARE(apr_status_t) apr_sms_cleanup_run_type(apr_sms_t *mem_sys, 
  +APR_DECLARE(apr_status_t) apr_sms_cleanup_run_type(apr_sms_t *sms, 
                                                      apr_int32_t type);
   
   /**
    * Create a standard malloc/realloc/free memory system
  - * @param mem_sys A pointer to the created apr_sms_t*
  - * @deffunc apr_status_t apr_sms_std_create(apr_sms_t **mem_sys);
  + * @param sms A pointer to the created apr_sms_t*
  + * @deffunc apr_status_t apr_sms_std_create(apr_sms_t **sms);
    */
  -APR_DECLARE(apr_status_t) apr_sms_std_create(apr_sms_t **mem_sys);
  +APR_DECLARE(apr_status_t) apr_sms_std_create(apr_sms_t **sms);
   
   #ifdef __cplusplus
   }
  
  
  
  1.18      +147 -147  apr/memory/unix/apr_sms.c
  
  Index: apr_sms.c
  ===================================================================
  RCS file: /home/cvs/apr/memory/unix/apr_sms.c,v
  retrieving revision 1.17
  retrieving revision 1.18
  diff -u -r1.17 -r1.18
  --- apr_sms.c	2001/06/10 14:37:38	1.17
  +++ apr_sms.c	2001/06/10 14:45:32	1.18
  @@ -88,53 +88,53 @@
    * memory allocation functions
    */
   
  -APR_DECLARE(void *) apr_sms_malloc(apr_sms_t *mem_sys,
  +APR_DECLARE(void *) apr_sms_malloc(apr_sms_t *sms,
                                      apr_size_t size)
   {
       if (size == 0)
           return NULL;
   
  -    return mem_sys->malloc_fn(mem_sys, size);
  +    return sms->malloc_fn(sms, size);
   }
   
  -APR_DECLARE(void *) apr_sms_calloc(apr_sms_t *mem_sys,
  +APR_DECLARE(void *) apr_sms_calloc(apr_sms_t *sms,
                                      apr_size_t size)
   {
       if (size == 0)
           return NULL;
   
  -    if (!mem_sys->calloc_fn) {
  +    if (!sms->calloc_fn) {
           /* Assumption - if we don't have calloc we have
            * malloc, might be bogus...
            */
  -        void *mem = mem_sys->malloc_fn(mem_sys, size);
  +        void *mem = sms->malloc_fn(sms, size);
           memset(mem, '\0', size);
           return mem;
       }
       
  -    return mem_sys->calloc_fn(mem_sys, size);
  +    return sms->calloc_fn(sms, size);
   
   }
   
  -APR_DECLARE(void *) apr_sms_realloc(apr_sms_t *mem_sys, void *mem,
  +APR_DECLARE(void *) apr_sms_realloc(apr_sms_t *sms, void *mem,
                                       apr_size_t size)
   {
       if (!mem)
  -        return apr_sms_malloc(mem_sys, size);
  +        return apr_sms_malloc(sms, size);
   
       if (size == 0) {
  -        apr_sms_free(mem_sys, mem);
  +        apr_sms_free(sms, mem);
           return NULL;
       }
   
  -    return mem_sys->realloc_fn(mem_sys, mem, size);
  +    return sms->realloc_fn(sms, mem, size);
   }
   
  -APR_DECLARE(apr_status_t) apr_sms_free(apr_sms_t *mem_sys,
  +APR_DECLARE(apr_status_t) apr_sms_free(apr_sms_t *sms,
                                          void *mem)
   {
  -    if (mem_sys->free_fn)
  -        return mem_sys->free_fn(mem_sys, mem);  
  +    if (sms->free_fn)
  +        return sms->free_fn(sms, mem);  
   
       return APR_ENOTIMPL;
   }
  @@ -143,16 +143,16 @@
    * memory system functions
    */
   
  -static int apr_sms_is_tracking(apr_sms_t *mem_sys)
  +static int apr_sms_is_tracking(apr_sms_t *sms)
   {
       /*
        * The presense of a reset function gives us the clue that this is a 
        * tracking memory system.
        */
  -    return mem_sys->reset_fn != NULL;
  +    return sms->reset_fn != NULL;
   }
   
  -APR_DECLARE(apr_status_t) apr_sms_init(apr_sms_t *mem_sys, 
  +APR_DECLARE(apr_status_t) apr_sms_init(apr_sms_t *sms, 
                                          apr_sms_t *pms)
   {
       /* XXX - I've assumed that memory passed in will be zeroed,
  @@ -163,9 +163,9 @@
        * an assumption to make as it sounds :)
        */
   
  -    mem_sys->parent_mem_sys = pms;
  -    mem_sys->accounting_mem_sys = mem_sys;
  -    mem_sys->child_mem_sys = NULL;
  +    sms->parent = pms;
  +    sms->accounting = sms;
  +    sms->child = NULL;
   
       /*
        * Child memory systems are always linked to their parents.  This works
  @@ -192,34 +192,34 @@
            */
           apr_lock_acquire(pms->sms_lock);
           
  -        if ((mem_sys->sibling_mem_sys = pms->child_mem_sys) != NULL)
  -            mem_sys->sibling_mem_sys->ref_mem_sys = &mem_sys->sibling_mem_sys;
  +        if ((sms->sibling = pms->child) != NULL)
  +            sms->sibling->ref = &sms->sibling;
   
  -        mem_sys->ref_mem_sys = &pms->child_mem_sys;
  -        pms->child_mem_sys = mem_sys;
  +        sms->ref = &pms->child;
  +        pms->child = sms;
   
           apr_lock_release(pms->sms_lock);    
       }
   
       /* XXX - This should eventually be removed */
  -    apr_pool_create(&mem_sys->pool, pms ? pms->pool : NULL);
  +    apr_pool_create(&sms->pool, pms ? pms->pool : NULL);
       
       /* Create the lock we'll use to protect cleanups and child lists */
  -    apr_lock_create(&mem_sys->sms_lock, APR_MUTEX, APR_LOCKALL, NULL,
  -                    mem_sys->pool);
  +    apr_lock_create(&sms->sms_lock, APR_MUTEX, APR_LOCKALL, NULL,
  +                    sms->pool);
                           
       return APR_SUCCESS;
   }
   
   #ifdef APR_ASSERT_MEMORY
  -APR_DECLARE(void) apr_sms_assert(apr_sms_t *mem_sys)
  +APR_DECLARE(void) apr_sms_assert(apr_sms_t *sms)
   {
       apr_sms_t *parent;
   
       /*
        * A memory system without a malloc won't do us much good
        */
  -    assert(mem_sys->malloc_fn);
  +    assert(sms->malloc_fn);
   
       /* 
        * Check to see if this is either a non-tracking or
  @@ -227,19 +227,19 @@
        * or destroy function. And to avoid half implementations
        * we require reset to be present when destroy is.
        */
  -    assert(mem_sys->free_fn || (mem_sys->destroy_fn && mem_sys->reset_fn));
  +    assert(sms->free_fn || (sms->destroy_fn && sms->reset_fn));
   
  -    assert(!mem_sys->destroy_fn || mem_sys->reset_fn);
  +    assert(!sms->destroy_fn || sms->reset_fn);
     
  -    assert(!mem_sys->reset_fn || mem_sys->destroy_fn);
  +    assert(!sms->reset_fn || sms->destroy_fn);
   
       /*
        * Make sure all accounting memory dies with the memory system.
        * To be more specific, make sure the accounting memort system
        * is either the memory system itself or a direct child.
        */
  -    assert(mem_sys->accounting_mem_sys == mem_sys ||
  -           mem_sys->accounting_mem_sys->parent_mem_sys == mem_sys);
  +    assert(sms->accounting == sms ||
  +           sms->accounting->parent == sms);
   
       /*
        * A non-tracking memory system can be the child of
  @@ -247,15 +247,15 @@
        * tracking ancestors, but in that specific case we issue a
        * warning.
        */
  -    if (!mem_sys->parent_mem_sys)
  +    if (!sms->parent)
           return;
   
  -    parent = mem_sys;
  +    parent = sms;
       while (parent) {
           if (apr_sms_is_tracking(parent))
               return; /* Tracking memory system found, return satisfied ;-) */
   
  -        parent = parent->parent_mem_sys;
  +        parent = parent->parent;
       }
   
       /* issue a warning: 
  @@ -273,11 +273,11 @@
    *
    * Call all the cleanup routines registered with a memory system.
    */
  -static void apr_sms_do_cleanups(apr_sms_t *mem_sys)
  +static void apr_sms_do_cleanups(apr_sms_t *sms)
   {
       struct apr_sms_cleanup *cleanup;
   
  -    cleanup = mem_sys->cleanups;
  +    cleanup = sms->cleanups;
       while (cleanup) {
           cleanup->cleanup_fn(cleanup->data);
           cleanup = cleanup->next;
  @@ -291,44 +291,44 @@
    *
    * This not only calls do_cleanups, but also calls the pre_destroy(!)
    */
  -static void apr_sms_do_child_cleanups(apr_sms_t *mem_sys)
  +static void apr_sms_do_child_cleanups(apr_sms_t *sms)
   {
  -    if (!mem_sys)
  +    if (!sms)
           return;
   
  -    mem_sys = mem_sys->child_mem_sys;
  -    while (mem_sys) {
  -        apr_sms_do_child_cleanups(mem_sys);
  -        apr_sms_do_cleanups(mem_sys);
  +    sms = sms->child;
  +    while (sms) {
  +        apr_sms_do_child_cleanups(sms);
  +        apr_sms_do_cleanups(sms);
   
  -        if (mem_sys->pre_destroy_fn != NULL)
  -            mem_sys->pre_destroy_fn(mem_sys);
  +        if (sms->pre_destroy_fn != NULL)
  +            sms->pre_destroy_fn(sms);
   
  -        mem_sys = mem_sys->sibling_mem_sys;
  +        sms = sms->sibling;
       }
   }
   
  -APR_DECLARE(apr_status_t) apr_sms_reset(apr_sms_t *mem_sys)
  +APR_DECLARE(apr_status_t) apr_sms_reset(apr_sms_t *sms)
   {
       apr_status_t rv;
       
  -    if (!mem_sys->reset_fn)
  +    if (!sms->reset_fn)
           return APR_ENOTIMPL;
   
  -    apr_lock_acquire(mem_sys->sms_lock);
  +    apr_lock_acquire(sms->sms_lock);
       
       /* 
        * Run the cleanups of all child memory systems _including_
        * the accounting memory system.
        */
  -    apr_sms_do_child_cleanups(mem_sys);
  +    apr_sms_do_child_cleanups(sms);
   
       /* Run all cleanups, the memory will be freed by the reset */
  -    apr_sms_do_cleanups(mem_sys);
  -    mem_sys->cleanups = NULL;
  +    apr_sms_do_cleanups(sms);
  +    sms->cleanups = NULL;
   
       /* We don't have any child memory systems after the reset */
  -    mem_sys->child_mem_sys = NULL;
  +    sms->child = NULL;
   
       /* Reset the accounting memory system to ourselves, any
        * child memory system _including_ the accounting memory
  @@ -336,152 +336,152 @@
        * strikerXXX: Maybe this should be the responsibility of
        *             the reset function(?).
        */
  -    mem_sys->accounting_mem_sys = mem_sys;
  +    sms->accounting = sms;
   
       /* Let the memory system handle the actual reset */
  -    rv = mem_sys->reset_fn(mem_sys);
  +    rv = sms->reset_fn(sms);
   
  -    apr_lock_release(mem_sys->sms_lock);
  +    apr_lock_release(sms->sms_lock);
       
       return rv;
   }
   
  -APR_DECLARE(apr_status_t) apr_sms_destroy(apr_sms_t *mem_sys)
  +APR_DECLARE(apr_status_t) apr_sms_destroy(apr_sms_t *sms)
   {
  -    apr_sms_t *child_mem_sys;
  -    apr_sms_t *sibling_mem_sys;
  +    apr_sms_t *child;
  +    apr_sms_t *sibling;
       apr_sms_t *pms;
       struct apr_sms_cleanup *cleanup;
       struct apr_sms_cleanup *next_cleanup;
   
  -    apr_lock_acquire(mem_sys->sms_lock);
  +    apr_lock_acquire(sms->sms_lock);
       
  -    if (apr_sms_is_tracking(mem_sys)) {
  +    if (apr_sms_is_tracking(sms)) {
           /* 
            * Run the cleanups of all child memory systems _including_
            * the accounting memory system.
            */
  -        apr_sms_do_child_cleanups(mem_sys);
  +        apr_sms_do_child_cleanups(sms);
   
           /* Run all cleanups, the memory will be freed by the destroy */
  -        apr_sms_do_cleanups(mem_sys);
  +        apr_sms_do_cleanups(sms);
       }
       else {
  -        if (mem_sys->accounting_mem_sys != mem_sys) {
  -            child_mem_sys = mem_sys->accounting_mem_sys;
  +        if (sms->accounting != sms) {
  +            child = sms->accounting;
               
               /* 
                * Remove the accounting memory system from the memory systems 
                * child list (we will explicitly destroy it later in this block).
                */
  -            if (child_mem_sys->sibling_mem_sys != NULL)
  -                child_mem_sys->sibling_mem_sys->ref_mem_sys =
  -                    child_mem_sys->ref_mem_sys;
  +            if (child->sibling != NULL)
  +                child->sibling->ref =
  +                    child->ref;
   
  -            *child_mem_sys->ref_mem_sys = child_mem_sys->sibling_mem_sys;
  +            *child->ref = child->sibling;
   
               /* Set this fields so destroy will work */
  -            child_mem_sys->ref_mem_sys = NULL;
  -            child_mem_sys->sibling_mem_sys = NULL;
  +            child->ref = NULL;
  +            child->sibling = NULL;
           }
   
           /* Visit all children and destroy them */
  -        child_mem_sys = mem_sys->child_mem_sys;
  +        child = sms->child;
   
  -        while (child_mem_sys) {
  -            sibling_mem_sys = child_mem_sys->sibling_mem_sys;
  -            apr_sms_destroy(child_mem_sys);
  -            child_mem_sys = sibling_mem_sys;
  +        while (child) {
  +            sibling = child->sibling;
  +            apr_sms_destroy(child);
  +            child = sibling;
           }
   
           /*
            * If the accounting memory system _is_ tracking, we also know that
            * it is not the memory system itself.
            */
  -        if (apr_sms_is_tracking(mem_sys->accounting_mem_sys)) {
  +        if (apr_sms_is_tracking(sms->accounting)) {
               /* 
                * Run all cleanups, the memory will be freed by the destroying
                * of the accounting memory system.
                */
  -            apr_sms_do_cleanups(mem_sys);
  +            apr_sms_do_cleanups(sms);
   
               /* Destroy the accounting memory system */
  -            apr_sms_destroy(mem_sys->accounting_mem_sys);
  +            apr_sms_destroy(sms->accounting);
   
               /* 
                * Set the accounting memory system back to the parent memory
                * system just in case...
                */
  -            mem_sys->accounting_mem_sys = mem_sys;
  +            sms->accounting = sms;
           }
           else {
               /* Run all cleanups, free'ing memory as we go */
  -            cleanup = mem_sys->cleanups;
  +            cleanup = sms->cleanups;
   
               while (cleanup) {
                   cleanup->cleanup_fn(cleanup->data);
                   next_cleanup = cleanup->next;
  -                apr_sms_free(mem_sys->accounting_mem_sys, cleanup);
  +                apr_sms_free(sms->accounting, cleanup);
                   cleanup = next_cleanup;
               }
   
  -            if (mem_sys->accounting_mem_sys != mem_sys) {
  +            if (sms->accounting != sms) {
                   /* Destroy the accounting memory system */
  -                apr_sms_destroy(mem_sys->accounting_mem_sys);
  +                apr_sms_destroy(sms->accounting);
                   
                   /* 
                    * Set the accounting memory system back to the parent memory
                    * system just in case...
                    */
  -                mem_sys->accounting_mem_sys = mem_sys;
  +                sms->accounting = sms;
               }
           }
       }
   
  -    pms = mem_sys->parent_mem_sys;
  +    pms = sms->parent;
       
       /* Remove the memory system from the parent memory systems child list */
       if (pms)
           apr_lock_acquire(pms->sms_lock);
           
  -    if (mem_sys->sibling_mem_sys)
  -        mem_sys->sibling_mem_sys->ref_mem_sys = mem_sys->ref_mem_sys;
  +    if (sms->sibling)
  +        sms->sibling->ref = sms->ref;
   
  -    if (mem_sys->ref_mem_sys)
  -        *mem_sys->ref_mem_sys = mem_sys->sibling_mem_sys;
  +    if (sms->ref)
  +        *sms->ref = sms->sibling;
   
       if (pms)
           apr_lock_release(pms->sms_lock);
           
       /* Call the pre-destroy if present */
  -    if (mem_sys->pre_destroy_fn)
  -        mem_sys->pre_destroy_fn(mem_sys);
  +    if (sms->pre_destroy_fn)
  +        sms->pre_destroy_fn(sms);
   
  -    apr_lock_destroy(mem_sys->sms_lock);
  +    apr_lock_destroy(sms->sms_lock);
       
       /* XXX - This should eventually be removed */
  -    apr_pool_destroy(mem_sys->pool);
  +    apr_pool_destroy(sms->pool);
       
       /* 1 - If we have a self destruct, use it */
  -    if (mem_sys->destroy_fn)
  -        return mem_sys->destroy_fn(mem_sys);
  +    if (sms->destroy_fn)
  +        return sms->destroy_fn(sms);
   
       /* 2 - If we don't have a parent, free using ourselves */
  -    if (!mem_sys->parent_mem_sys)
  -        return mem_sys->free_fn(mem_sys, mem_sys);
  +    if (!sms->parent)
  +        return sms->free_fn(sms, sms);
   
       /* 3 - If we do have a parent and it has a free function, use it */
  -    if (mem_sys->parent_mem_sys->free_fn)
  -        return apr_sms_free(mem_sys->parent_mem_sys, mem_sys);
  +    if (sms->parent->free_fn)
  +        return apr_sms_free(sms->parent, sms);
   
       /* 4 - Assume we are the child of a tracking memory system, do nothing */
   #ifdef APR_ASSERT_MEMORY
  -    mem_sys = mem_sys->parent_mem_sys;
  -    while (mem_sys) {
  -        if (apr_sms_is_tracking(mem_sys))
  +    sms = sms->parent;
  +    while (sms) {
  +        if (apr_sms_is_tracking(sms))
               return APR_SUCCESS;
   
  -        mem_sys = mem_sys->parent_mem_sys;
  +        sms = sms->parent;
       }
       assert(0); /* Made the wrong assumption, so we assert */
   #endif /* APR_ASSERT_MEMORY */
  @@ -497,39 +497,39 @@
   #endif
           
       while (b && b != a)
  -        b = b->parent_mem_sys;
  +        b = b->parent;
   
       /* APR_SUCCESS = 0, so if they agree we should return that... */
       return !(b == a); 
   }
   
  -APR_DECLARE(apr_status_t) apr_sms_lock(apr_sms_t *mem_sys)
  +APR_DECLARE(apr_status_t) apr_sms_lock(apr_sms_t *sms)
   {
       /* If we don't have a lock_fn then we probably don't need one,
        * so this is OK and we just return APR_SUCCESS
        */
  -    if (!mem_sys->lock_fn)
  +    if (!sms->lock_fn)
           return APR_SUCCESS;
   
  -    return mem_sys->lock_fn(mem_sys);
  +    return sms->lock_fn(sms);
   }
   
  -APR_DECLARE(apr_status_t) apr_sms_unlock(apr_sms_t *mem_sys)
  +APR_DECLARE(apr_status_t) apr_sms_unlock(apr_sms_t *sms)
   {
       /* If we don't have a lock_fn then we probably don't need one,
        * so this is OK and we just return APR_SUCCESS
        */
  -    if (!mem_sys->unlock_fn)
  +    if (!sms->unlock_fn)
           return APR_SUCCESS;
           
  -    return mem_sys->unlock_fn(mem_sys);
  +    return sms->unlock_fn(sms);
   }
   
   /*
    * memory system cleanup management functions
    */
   
  -APR_DECLARE(apr_status_t) apr_sms_cleanup_register(apr_sms_t *mem_sys, 
  +APR_DECLARE(apr_status_t) apr_sms_cleanup_register(apr_sms_t *sms, 
                                                      apr_int32_t type,
                                                      void *data,
                                                      apr_status_t
  @@ -540,14 +540,14 @@
       if (!cleanup_fn)
           return APR_ENOTIMPL;
       
  -    apr_lock_acquire(mem_sys->sms_lock);
  +    apr_lock_acquire(sms->sms_lock);
       
       cleanup = (struct apr_sms_cleanup *)
  -                  apr_sms_malloc(mem_sys->accounting_mem_sys,
  +                  apr_sms_malloc(sms->accounting,
                                    sizeof(struct apr_sms_cleanup));
   
       if (!cleanup){
  -        apr_lock_release(mem_sys->sms_lock);
  +        apr_lock_release(sms->sms_lock);
           return APR_ENOMEM;
       }
   
  @@ -555,15 +555,15 @@
       cleanup->type = type;
       cleanup->cleanup_fn = cleanup_fn;
   
  -    cleanup->next = mem_sys->cleanups;
  -    mem_sys->cleanups = cleanup;
  +    cleanup->next = sms->cleanups;
  +    sms->cleanups = cleanup;
   
  -    apr_lock_release(mem_sys->sms_lock);
  +    apr_lock_release(sms->sms_lock);
       
       return APR_SUCCESS;
   }
   
  -APR_DECLARE(apr_status_t) apr_sms_cleanup_unregister(apr_sms_t *mem_sys,
  +APR_DECLARE(apr_status_t) apr_sms_cleanup_unregister(apr_sms_t *sms,
                                                        apr_int32_t type,
                                                        void *data,
                                                        apr_status_t
  @@ -573,19 +573,19 @@
       struct apr_sms_cleanup **cleanup_ref;
       apr_status_t rv = APR_EINVAL;
       
  -    apr_lock_acquire(mem_sys->sms_lock);
  +    apr_lock_acquire(sms->sms_lock);
       
  -    cleanup = mem_sys->cleanups;
  -    cleanup_ref = &mem_sys->cleanups;
  +    cleanup = sms->cleanups;
  +    cleanup_ref = &sms->cleanups;
       while (cleanup) {
           if ((type == 0 || cleanup->type == type) &&
               cleanup->data == data && cleanup->cleanup_fn == cleanup_fn) {
               *cleanup_ref = cleanup->next;
   
  -            mem_sys = mem_sys->accounting_mem_sys;
  +            sms = sms->accounting;
   
  -            if (mem_sys->free_fn)
  -                apr_sms_free(mem_sys, cleanup);
  +            if (sms->free_fn)
  +                apr_sms_free(sms, cleanup);
   
               rv = APR_SUCCESS;
           } else {
  @@ -594,30 +594,30 @@
           }
       }
   
  -    apr_lock_release(mem_sys->sms_lock);
  +    apr_lock_release(sms->sms_lock);
   
       /* The cleanup function must have been registered previously */
       return rv;
   }
   
  -APR_DECLARE(apr_status_t) apr_sms_cleanup_unregister_type(apr_sms_t *mem_sys, 
  +APR_DECLARE(apr_status_t) apr_sms_cleanup_unregister_type(apr_sms_t *sms, 
                                                             apr_int32_t type)
   {
       struct apr_sms_cleanup *cleanup;
       struct apr_sms_cleanup **cleanup_ref;
       apr_status_t rv = APR_EINVAL;
   
  -    apr_lock_acquire(mem_sys->sms_lock);
  +    apr_lock_acquire(sms->sms_lock);
       
  -    cleanup = mem_sys->cleanups;
  -    cleanup_ref = &mem_sys->cleanups;
  -    mem_sys = mem_sys->accounting_mem_sys;
  +    cleanup = sms->cleanups;
  +    cleanup_ref = &sms->cleanups;
  +    sms = sms->accounting;
       while (cleanup) {
           if (type == 0 || cleanup->type == type) {
               *cleanup_ref = cleanup->next;
   
  -            if (mem_sys->free_fn)
  -                apr_sms_free(mem_sys, cleanup);
  +            if (sms->free_fn)
  +                apr_sms_free(sms, cleanup);
   
               cleanup = *cleanup_ref;
               rv = APR_SUCCESS;
  @@ -628,13 +628,13 @@
           }
       }
   
  -    apr_lock_release(mem_sys->sms_lock);
  +    apr_lock_release(sms->sms_lock);
       
       /* The cleanup function must have been registered previously */
       return rv;
   }
   
  -APR_DECLARE(apr_status_t) apr_sms_cleanup_run(apr_sms_t *mem_sys,
  +APR_DECLARE(apr_status_t) apr_sms_cleanup_run(apr_sms_t *sms,
                                                 apr_int32_t type,
                                                 void *data, 
                                                 apr_status_t
  @@ -642,33 +642,33 @@
   {
       apr_status_t rv;
   
  -    if ((rv = apr_sms_cleanup_unregister(mem_sys, type,
  +    if ((rv = apr_sms_cleanup_unregister(sms, type,
                                            data, cleanup_fn)) != APR_SUCCESS)
           return rv;
   
       return cleanup_fn(data);
   }
   
  -APR_DECLARE(apr_status_t) apr_sms_cleanup_run_type(apr_sms_t *mem_sys, 
  +APR_DECLARE(apr_status_t) apr_sms_cleanup_run_type(apr_sms_t *sms, 
                                                      apr_int32_t type)
   {
       struct apr_sms_cleanup *cleanup;
       struct apr_sms_cleanup **cleanup_ref;
       apr_status_t rv = APR_EINVAL;
       
  -    apr_lock_acquire(mem_sys->sms_lock);
  +    apr_lock_acquire(sms->sms_lock);
       
  -    cleanup = mem_sys->cleanups;
  -    cleanup_ref = &mem_sys->cleanups;
  -    mem_sys = mem_sys->accounting_mem_sys;
  +    cleanup = sms->cleanups;
  +    cleanup_ref = &sms->cleanups;
  +    sms = sms->accounting;
       while (cleanup) {
           if (type == 0 || cleanup->type == type) {
               *cleanup_ref = cleanup->next;
   
               cleanup->cleanup_fn(cleanup->data);
               
  -            if (mem_sys->free_fn)
  -                apr_sms_free(mem_sys, cleanup);
  +            if (sms->free_fn)
  +                apr_sms_free(sms, cleanup);
   
               cleanup = *cleanup_ref;
               rv = APR_SUCCESS;
  @@ -679,13 +679,13 @@
           }
       }
   
  -    apr_lock_release(mem_sys->sms_lock);
  +    apr_lock_release(sms->sms_lock);
   
       /* The cleanup function should have been registered previously */
       return rv;
   }
   
  -APR_DECLARE(const char*) apr_sms_identity(apr_sms_t *mem_sys)
  +APR_DECLARE(const char*) apr_sms_identity(apr_sms_t *sms)
   {
  -    return mem_sys->identity;
  +    return sms->identity;
   }
  
  
  
  1.9       +17 -17    apr/memory/unix/apr_sms_std.c
  
  Index: apr_sms_std.c
  ===================================================================
  RCS file: /home/cvs/apr/memory/unix/apr_sms_std.c,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- apr_sms_std.c	2001/06/08 00:44:52	1.8
  +++ apr_sms_std.c	2001/06/10 14:45:32	1.9
  @@ -71,13 +71,13 @@
    * standard memory system
    */
   
  -static void *apr_sms_std_malloc(apr_sms_t *mem_sys,
  +static void *apr_sms_std_malloc(apr_sms_t *sms,
                                   apr_size_t size)
   {
       return malloc(size);
   }
   
  -static void *apr_sms_std_calloc(apr_sms_t *mem_sys,
  +static void *apr_sms_std_calloc(apr_sms_t *sms,
                                   apr_size_t size)
   {
   #if HAVE_CALLOC
  @@ -91,50 +91,50 @@
   }
   
   
  -static void *apr_sms_std_realloc(apr_sms_t *mem_sys,
  +static void *apr_sms_std_realloc(apr_sms_t *sms,
                                    void *mem, apr_size_t size)
   {
       return realloc(mem, size);
   }
   
  -static apr_status_t apr_sms_std_free(apr_sms_t *mem_sys,
  +static apr_status_t apr_sms_std_free(apr_sms_t *sms,
                                        void *mem)
   {
       free(mem);
       return APR_SUCCESS;
   }
   
  -APR_DECLARE(apr_status_t) apr_sms_std_create(apr_sms_t **mem_sys)
  +APR_DECLARE(apr_status_t) apr_sms_std_create(apr_sms_t **sms)
   {
  -    apr_sms_t *new_mem_sys;
  +    apr_sms_t *new_sms;
       apr_status_t rv;
   
  -    *mem_sys = NULL;
  +    *sms = NULL;
       /* We don't have a parent so we allocate the memory
        * for the structure ourselves...
        */
  -    new_mem_sys = apr_sms_std_calloc(NULL, sizeof(apr_sms_t));
  +    new_sms = apr_sms_std_calloc(NULL, sizeof(apr_sms_t));
   
  -    if (!new_mem_sys)
  +    if (!new_sms)
           return APR_ENOMEM;
   
  -    if ((rv = apr_sms_init(new_mem_sys, NULL)) != APR_SUCCESS)
  +    if ((rv = apr_sms_init(new_sms, NULL)) != APR_SUCCESS)
           return rv;
   
  -    new_mem_sys->malloc_fn  = apr_sms_std_malloc;
  -    new_mem_sys->calloc_fn  = apr_sms_std_calloc;
  -    new_mem_sys->realloc_fn = apr_sms_std_realloc;
  -    new_mem_sys->free_fn    = apr_sms_std_free;
  -    new_mem_sys->identity   = module_identity;
  +    new_sms->malloc_fn  = apr_sms_std_malloc;
  +    new_sms->calloc_fn  = apr_sms_std_calloc;
  +    new_sms->realloc_fn = apr_sms_std_realloc;
  +    new_sms->free_fn    = apr_sms_std_free;
  +    new_sms->identity   = module_identity;
   
       /* as we're not a tracking memory module, i.e. we don't keep
        * track of our allocations, we don't have apr_sms_reset or
        * apr_sms_destroy functions.
        */
       
  -    apr_sms_assert(new_mem_sys);
  +    apr_sms_assert(new_sms);
   
  -    *mem_sys = new_mem_sys;
  +    *sms = new_sms;
       return APR_SUCCESS;
   }
   
  
  
  
  1.9       +24 -24    apr/memory/unix/apr_sms_tracking.c
  
  Index: apr_sms_tracking.c
  ===================================================================
  RCS file: /home/cvs/apr/memory/unix/apr_sms_tracking.c,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- apr_sms_tracking.c	2001/06/08 00:44:52	1.8
  +++ apr_sms_tracking.c	2001/06/10 14:45:32	1.9
  @@ -88,18 +88,18 @@
       apr_lock_t          *lock;
   } apr_sms_tracking_t;
   
  -static void *apr_sms_tracking_malloc(apr_sms_t *mem_sys,
  +static void *apr_sms_tracking_malloc(apr_sms_t *sms,
                                        apr_size_t size)
   {
       apr_sms_tracking_t *tms;
       apr_track_node_t *node;
   
  -    node = apr_sms_malloc(mem_sys->parent_mem_sys,
  +    node = apr_sms_malloc(sms->parent,
                             size + sizeof(apr_track_node_t));
       if (!node)
           return NULL;
   
  -    tms = (apr_sms_tracking_t *)mem_sys;
  +    tms = (apr_sms_tracking_t *)sms;
       apr_lock_acquire(tms->lock);
   
       node->next = tms->nodes;
  @@ -115,18 +115,18 @@
       return (void *)node;
   }
   
  -static void *apr_sms_tracking_calloc(apr_sms_t *mem_sys, 
  +static void *apr_sms_tracking_calloc(apr_sms_t *sms, 
                                        apr_size_t size)
   {
       apr_sms_tracking_t *tms;
       apr_track_node_t *node;
     
  -    node = apr_sms_calloc(mem_sys->parent_mem_sys,
  +    node = apr_sms_calloc(sms->parent,
                             size + sizeof(apr_track_node_t));
       if (!node)
           return NULL;
   
  -    tms = (apr_sms_tracking_t *)mem_sys;
  +    tms = (apr_sms_tracking_t *)sms;
       apr_lock_acquire(tms->lock);
   
       node->next = tms->nodes;
  @@ -142,13 +142,13 @@
       return (void *)node;
   }
   
  -static void *apr_sms_tracking_realloc(apr_sms_t *mem_sys,
  +static void *apr_sms_tracking_realloc(apr_sms_t *sms,
                                         void *mem, apr_size_t size)
   {
       apr_sms_tracking_t *tms;
       apr_track_node_t *node;
   
  -    tms = (apr_sms_tracking_t *)mem_sys;
  +    tms = (apr_sms_tracking_t *)sms;
   
   
       node = (apr_track_node_t *)mem;
  @@ -164,7 +164,7 @@
           apr_lock_release(tms->lock);
       }
   
  -    node = apr_sms_realloc(mem_sys->parent_mem_sys,
  +    node = apr_sms_realloc(sms->parent,
                              node, size + sizeof(apr_track_node_t));
       if (!node)
           return NULL;
  @@ -184,7 +184,7 @@
       return (void *)node;
   }
   
  -static apr_status_t apr_sms_tracking_free(apr_sms_t *mem_sys,
  +static apr_status_t apr_sms_tracking_free(apr_sms_t *sms,
                                             void *mem)
   {
       apr_track_node_t *node;
  @@ -193,7 +193,7 @@
       node = (apr_track_node_t *)mem;
       node--;
   
  -    tms = (apr_sms_tracking_t *)mem_sys;
  +    tms = (apr_sms_tracking_t *)sms;
    
       apr_lock_acquire(tms->lock);
   
  @@ -203,16 +203,16 @@
    
       apr_lock_release(tms->lock);
            
  -    return apr_sms_free(mem_sys->parent_mem_sys, node);
  +    return apr_sms_free(sms->parent, node);
   }
   
  -static apr_status_t apr_sms_tracking_reset(apr_sms_t *mem_sys)
  +static apr_status_t apr_sms_tracking_reset(apr_sms_t *sms)
   {
       apr_sms_tracking_t *tms;
       apr_track_node_t *node;
       apr_status_t rv;
    
  -    tms = (apr_sms_tracking_t *)mem_sys;
  +    tms = (apr_sms_tracking_t *)sms;
   
       apr_lock_acquire(tms->lock);
       
  @@ -221,7 +221,7 @@
           *(node->ref) = node->next;
           if (node->next)
               node->next->ref = node->ref;
  -        if ((rv = apr_sms_free(mem_sys->parent_mem_sys, 
  +        if ((rv = apr_sms_free(sms->parent, 
                                  node)) != APR_SUCCESS) {
               apr_lock_release(tms->lock);
               return rv;
  @@ -233,7 +233,7 @@
       return APR_SUCCESS;
   }
   
  -static apr_status_t apr_sms_tracking_pre_destroy(apr_sms_t *mem_sys)
  +static apr_status_t apr_sms_tracking_pre_destroy(apr_sms_t *sms)
   {
       /* This function WILL alwways be called.  However, be aware that the
        * main sms destroy function knows that it's not wise to try and destroy
  @@ -243,7 +243,7 @@
        */
       apr_sms_tracking_t *tms;
    
  -    tms = (apr_sms_tracking_t *)mem_sys;
  +    tms = (apr_sms_tracking_t *)sms;
       apr_lock_acquire(tms->lock);
       apr_lock_destroy(tms->lock);
       tms->lock = NULL;
  @@ -251,13 +251,13 @@
       return APR_SUCCESS;    
   }
   
  -static apr_status_t apr_sms_tracking_destroy(apr_sms_t *mem_sys)
  +static apr_status_t apr_sms_tracking_destroy(apr_sms_t *sms)
   {
       apr_status_t rv;
       apr_sms_tracking_t *tms;
       apr_track_node_t *node;
       
  -    tms = (apr_sms_tracking_t *)mem_sys;
  +    tms = (apr_sms_tracking_t *)sms;
    
       /* XXX - As we've already had the lock we've been using destroyed
        * in the pre_destroy function we can't use it.  However, if we
  @@ -269,22 +269,22 @@
           *(node->ref) = node->next;
           if (node->next)
               node->next->ref = node->ref;
  -        if ((rv = apr_sms_free(mem_sys->parent_mem_sys, node)) != APR_SUCCESS)
  +        if ((rv = apr_sms_free(sms->parent, node)) != APR_SUCCESS)
               return rv;
       }
       
  -    return apr_sms_free(mem_sys->parent_mem_sys, mem_sys);
  +    return apr_sms_free(sms->parent, sms);
   }
   
   
  -APR_DECLARE(apr_status_t) apr_sms_tracking_create(apr_sms_t **mem_sys, 
  +APR_DECLARE(apr_status_t) apr_sms_tracking_create(apr_sms_t **sms, 
                                                     apr_sms_t *pms)
   {
       apr_sms_t *new_sms;
       apr_sms_tracking_t *tms;
       apr_status_t rv;
   
  -    *mem_sys = NULL;
  +    *sms = NULL;
       /* We're not a top level module, ie we have a parent, so
        * we allocate the memory for the structure from our parent.
        * This is safe as we shouldn't outlive our parent...
  @@ -313,7 +313,7 @@
   
       apr_sms_assert(new_sms);
   
  -    *mem_sys = new_sms;
  +    *sms = new_sms;
       return APR_SUCCESS;
   }
   
  
  
  

Mime
View raw message