Convert various APU_DECLARE into APR_DECLARE.

git-svn-id: https://svn.apache.org/repos/asf/apr/apr/trunk@794523 13f79535-47bb-0310-9956-ffa450edef68

6 files changed, 57 insertions, 57 deletions

diff --git a/util-misc/apr_date.c b/util-misc/apr_date.c
index 28086e334..e28e967fb 100644
--- a/util-misc/apr_date.c
+++ b/util-misc/apr_date.c
@@ -52,7 +52,7 @@
  *   * - swallow remaining characters 
  *  <x> - exact match for any other character
  */
-APU_DECLARE(int) apr_date_checkmask(const char *data, const char *mask)
+APR_DECLARE(int) apr_date_checkmask(const char *data, const char *mask)
 {
     int i;
     char d;
@@ -142,7 +142,7 @@ APU_DECLARE(int) apr_date_checkmask(const char *data, const char *mask)
  * but many changes since then.
  *
  */
-APU_DECLARE(apr_time_t) apr_date_parse_http(const char *date)
+APR_DECLARE(apr_time_t) apr_date_parse_http(const char *date)
 {
     apr_time_exp_t ds;
     apr_time_t result;
@@ -316,7 +316,7 @@ APU_DECLARE(apr_time_t) apr_date_parse_http(const char *date)
                       timstr[6],timstr[7]);                 \
     }
 
-APU_DECLARE(apr_time_t) apr_date_parse_rfc(const char *date)
+APR_DECLARE(apr_time_t) apr_date_parse_rfc(const char *date)
 {
     apr_time_exp_t ds;
     apr_time_t result;
diff --git a/util-misc/apr_queue.c b/util-misc/apr_queue.c
index b74fdf852..a1682f8f2 100644
--- a/util-misc/apr_queue.c
+++ b/util-misc/apr_queue.c
@@ -98,7 +98,7 @@ static apr_status_t queue_destroy(void *data)
 /**
  * Initialize the apr_queue_t.
  */
-APU_DECLARE(apr_status_t) apr_queue_create(apr_queue_t **q, 
+APR_DECLARE(apr_status_t) apr_queue_create(apr_queue_t **q, 
                                            unsigned int queue_capacity, 
                                            apr_pool_t *a)
 {
@@ -145,7 +145,7 @@ APU_DECLARE(apr_status_t) apr_queue_create(apr_queue_t **q,
  * the push operation has completed, it signals other threads waiting
  * in apr_queue_pop() that they may continue consuming sockets.
  */
-APU_DECLARE(apr_status_t) apr_queue_push(apr_queue_t *queue, void *data)
+APR_DECLARE(apr_status_t) apr_queue_push(apr_queue_t *queue, void *data)
 {
     apr_status_t rv;
 
@@ -206,7 +206,7 @@ APU_DECLARE(apr_status_t) apr_queue_push(apr_queue_t *queue, void *data)
  * the push operation completes successfully, it signals other threads
  * waiting in apr_queue_pop() that they may continue consuming sockets.
  */
-APU_DECLARE(apr_status_t) apr_queue_trypush(apr_queue_t *queue, void *data)
+APR_DECLARE(apr_status_t) apr_queue_trypush(apr_queue_t *queue, void *data)
 {
     apr_status_t rv;
 
@@ -244,7 +244,7 @@ APU_DECLARE(apr_status_t) apr_queue_trypush(apr_queue_t *queue, void *data)
 /**
  * not thread safe
  */
-APU_DECLARE(unsigned int) apr_queue_size(apr_queue_t *queue) {
+APR_DECLARE(unsigned int) apr_queue_size(apr_queue_t *queue) {
     return queue->nelts;
 }
 
@@ -254,7 +254,7 @@ APU_DECLARE(unsigned int) apr_queue_size(apr_queue_t *queue) {
  * Once retrieved, the item is placed into the address specified by
  * 'data'.
  */
-APU_DECLARE(apr_status_t) apr_queue_pop(apr_queue_t *queue, void **data)
+APR_DECLARE(apr_status_t) apr_queue_pop(apr_queue_t *queue, void **data)
 {
     apr_status_t rv;
 
@@ -316,7 +316,7 @@ APU_DECLARE(apr_status_t) apr_queue_pop(apr_queue_t *queue, void **data)
  * items available, return APR_EAGAIN.  Once retrieved,
  * the item is placed into the address specified by 'data'.
  */
-APU_DECLARE(apr_status_t) apr_queue_trypop(apr_queue_t *queue, void **data)
+APR_DECLARE(apr_status_t) apr_queue_trypop(apr_queue_t *queue, void **data)
 {
     apr_status_t rv;
 
@@ -351,7 +351,7 @@ APU_DECLARE(apr_status_t) apr_queue_trypop(apr_queue_t *queue, void **data)
     return rv;
 }
 
-APU_DECLARE(apr_status_t) apr_queue_interrupt_all(apr_queue_t *queue)
+APR_DECLARE(apr_status_t) apr_queue_interrupt_all(apr_queue_t *queue)
 {
     apr_status_t rv;
     Q_DBG("intr all", queue);    
@@ -368,7 +368,7 @@ APU_DECLARE(apr_status_t) apr_queue_interrupt_all(apr_queue_t *queue)
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_queue_term(apr_queue_t *queue)
+APR_DECLARE(apr_status_t) apr_queue_term(apr_queue_t *queue)
 {
     apr_status_t rv;
 
diff --git a/util-misc/apr_reslist.c b/util-misc/apr_reslist.c
index 0c43e0747..f44484935 100644
--- a/util-misc/apr_reslist.c
+++ b/util-misc/apr_reslist.c
@@ -173,7 +173,7 @@ static apr_status_t reslist_cleanup(void *data_)
  * Perform routine maintenance on the resource list. This call
  * may instantiate new resources or expire old resources.
  */
-APU_DECLARE(apr_status_t) apr_reslist_maintain(apr_reslist_t *reslist)
+APR_DECLARE(apr_status_t) apr_reslist_maintain(apr_reslist_t *reslist)
 {
     apr_time_t now;
     apr_status_t rv;
@@ -248,7 +248,7 @@ APU_DECLARE(apr_status_t) apr_reslist_maintain(apr_reslist_t *reslist)
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_reslist_create(apr_reslist_t **reslist,
+APR_DECLARE(apr_status_t) apr_reslist_create(apr_reslist_t **reslist,
                                              int min, int smax, int hmax,
                                              apr_interval_time_t ttl,
                                              apr_reslist_constructor con,
@@ -318,12 +318,12 @@ APU_DECLARE(apr_status_t) apr_reslist_create(apr_reslist_t **reslist,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_reslist_destroy(apr_reslist_t *reslist)
+APR_DECLARE(apr_status_t) apr_reslist_destroy(apr_reslist_t *reslist)
 {
     return apr_pool_cleanup_run(reslist->pool, reslist, reslist_cleanup);
 }
 
-APU_DECLARE(apr_status_t) apr_reslist_acquire(apr_reslist_t *reslist,
+APR_DECLARE(apr_status_t) apr_reslist_acquire(apr_reslist_t *reslist,
                                               void **resource)
 {
     apr_status_t rv;
@@ -405,7 +405,7 @@ APU_DECLARE(apr_status_t) apr_reslist_acquire(apr_reslist_t *reslist,
     }
 }
 
-APU_DECLARE(apr_status_t) apr_reslist_release(apr_reslist_t *reslist,
+APR_DECLARE(apr_status_t) apr_reslist_release(apr_reslist_t *reslist,
                                               void *resource)
 {
     apr_res_t *res;
@@ -424,13 +424,13 @@ APU_DECLARE(apr_status_t) apr_reslist_release(apr_reslist_t *reslist,
     return apr_reslist_maintain(reslist);
 }
 
-APU_DECLARE(void) apr_reslist_timeout_set(apr_reslist_t *reslist,
+APR_DECLARE(void) apr_reslist_timeout_set(apr_reslist_t *reslist,
                                           apr_interval_time_t timeout)
 {
     reslist->timeout = timeout;
 }
 
-APU_DECLARE(apr_uint32_t) apr_reslist_acquired_count(apr_reslist_t *reslist)
+APR_DECLARE(apr_uint32_t) apr_reslist_acquired_count(apr_reslist_t *reslist)
 {
     apr_uint32_t count;
 
@@ -445,7 +445,7 @@ APU_DECLARE(apr_uint32_t) apr_reslist_acquired_count(apr_reslist_t *reslist)
     return count;
 }
 
-APU_DECLARE(apr_status_t) apr_reslist_invalidate(apr_reslist_t *reslist,
+APR_DECLARE(apr_status_t) apr_reslist_invalidate(apr_reslist_t *reslist,
                                                  void *resource)
 {
     apr_status_t ret;
@@ -461,7 +461,7 @@ APU_DECLARE(apr_status_t) apr_reslist_invalidate(apr_reslist_t *reslist,
     return ret;
 }
 
-APU_DECLARE(void) apr_reslist_cleanup_order_set(apr_reslist_t *rl,
+APR_DECLARE(void) apr_reslist_cleanup_order_set(apr_reslist_t *rl,
                                                 apr_uint32_t mode)
 {
     apr_pool_cleanup_kill(rl->pool, rl, reslist_cleanup);
diff --git a/util-misc/apr_rmm.c b/util-misc/apr_rmm.c
index ed67dc25c..e90be1e7c 100644
--- a/util-misc/apr_rmm.c
+++ b/util-misc/apr_rmm.c
@@ -210,7 +210,7 @@ static void move_block(apr_rmm_t *rmm, apr_rmm_off_t this, int free)
     }
 }
 
-APU_DECLARE(apr_status_t) apr_rmm_init(apr_rmm_t **rmm, apr_anylock_t *lock, 
+APR_DECLARE(apr_status_t) apr_rmm_init(apr_rmm_t **rmm, apr_anylock_t *lock, 
                                        void *base, apr_size_t size,
                                        apr_pool_t *p)
 {
@@ -245,7 +245,7 @@ APU_DECLARE(apr_status_t) apr_rmm_init(apr_rmm_t **rmm, apr_anylock_t *lock,
     return APR_ANYLOCK_UNLOCK(lock);
 }
 
-APU_DECLARE(apr_status_t) apr_rmm_destroy(apr_rmm_t *rmm)
+APR_DECLARE(apr_status_t) apr_rmm_destroy(apr_rmm_t *rmm)
 {
     apr_status_t rv;
     rmm_block_t *blk;
@@ -278,7 +278,7 @@ APU_DECLARE(apr_status_t) apr_rmm_destroy(apr_rmm_t *rmm)
     return APR_ANYLOCK_UNLOCK(&rmm->lock);
 }
 
-APU_DECLARE(apr_status_t) apr_rmm_attach(apr_rmm_t **rmm, apr_anylock_t *lock,
+APR_DECLARE(apr_status_t) apr_rmm_attach(apr_rmm_t **rmm, apr_anylock_t *lock,
                                          void *base, apr_pool_t *p)
 {
     apr_anylock_t nulllock;
@@ -298,13 +298,13 @@ APU_DECLARE(apr_status_t) apr_rmm_attach(apr_rmm_t **rmm, apr_anylock_t *lock,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_rmm_detach(apr_rmm_t *rmm) 
+APR_DECLARE(apr_status_t) apr_rmm_detach(apr_rmm_t *rmm) 
 {
     /* A noop until we introduce locked/refcounts */
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_rmm_off_t) apr_rmm_malloc(apr_rmm_t *rmm, apr_size_t reqsize)
+APR_DECLARE(apr_rmm_off_t) apr_rmm_malloc(apr_rmm_t *rmm, apr_size_t reqsize)
 {
     apr_rmm_off_t this;
     
@@ -323,7 +323,7 @@ APU_DECLARE(apr_rmm_off_t) apr_rmm_malloc(apr_rmm_t *rmm, apr_size_t reqsize)
     return this;
 }
 
-APU_DECLARE(apr_rmm_off_t) apr_rmm_calloc(apr_rmm_t *rmm, apr_size_t reqsize)
+APR_DECLARE(apr_rmm_off_t) apr_rmm_calloc(apr_rmm_t *rmm, apr_size_t reqsize)
 {
     apr_rmm_off_t this;
         
@@ -343,7 +343,7 @@ APU_DECLARE(apr_rmm_off_t) apr_rmm_calloc(apr_rmm_t *rmm, apr_size_t reqsize)
     return this;
 }
 
-APU_DECLARE(apr_rmm_off_t) apr_rmm_realloc(apr_rmm_t *rmm, void *entity,
+APR_DECLARE(apr_rmm_off_t) apr_rmm_realloc(apr_rmm_t *rmm, void *entity,
                                            apr_size_t reqsize)
 {
     apr_rmm_off_t this;
@@ -372,7 +372,7 @@ APU_DECLARE(apr_rmm_off_t) apr_rmm_realloc(apr_rmm_t *rmm, void *entity,
     return this;
 }
 
-APU_DECLARE(apr_status_t) apr_rmm_free(apr_rmm_t *rmm, apr_rmm_off_t this)
+APR_DECLARE(apr_status_t) apr_rmm_free(apr_rmm_t *rmm, apr_rmm_off_t this)
 {
     apr_status_t rv;
     struct rmm_block_t *blk;
@@ -420,14 +420,14 @@ APU_DECLARE(apr_status_t) apr_rmm_free(apr_rmm_t *rmm, apr_rmm_off_t this)
     return APR_ANYLOCK_UNLOCK(&rmm->lock);
 }
 
-APU_DECLARE(void *) apr_rmm_addr_get(apr_rmm_t *rmm, apr_rmm_off_t entity) 
+APR_DECLARE(void *) apr_rmm_addr_get(apr_rmm_t *rmm, apr_rmm_off_t entity) 
 {
     /* debug-sanity checking here would be good
      */
     return (void*)((char*)rmm->base + entity);
 }
 
-APU_DECLARE(apr_rmm_off_t) apr_rmm_offset_get(apr_rmm_t *rmm, void* entity)
+APR_DECLARE(apr_rmm_off_t) apr_rmm_offset_get(apr_rmm_t *rmm, void* entity)
 {
     /* debug, or always, sanity checking here would be good
      * since the primitive is apr_rmm_off_t, I don't mind penalizing
@@ -437,7 +437,7 @@ APU_DECLARE(apr_rmm_off_t) apr_rmm_offset_get(apr_rmm_t *rmm, void* entity)
     return ((char*)entity - (char*)rmm->base);
 }
 
-APU_DECLARE(apr_size_t) apr_rmm_overhead_get(int n) 
+APR_DECLARE(apr_size_t) apr_rmm_overhead_get(int n) 
 {
     /* overhead per block is at most APR_ALIGN_DEFAULT(1) wasted bytes
      * for alignment overhead, plus the size of the rmm_block_t
diff --git a/util-misc/apr_thread_pool.c b/util-misc/apr_thread_pool.c
index 693518d10..22c544d0b 100644
--- a/util-misc/apr_thread_pool.c
+++ b/util-misc/apr_thread_pool.c
@@ -355,7 +355,7 @@ static apr_status_t thread_pool_cleanup(void *me)
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_thread_pool_create(apr_thread_pool_t ** me,
+APR_DECLARE(apr_status_t) apr_thread_pool_create(apr_thread_pool_t ** me,
                                                  apr_size_t init_threads,
                                                  apr_size_t max_threads,
                                                  apr_pool_t * pool)
@@ -395,7 +395,7 @@ APU_DECLARE(apr_status_t) apr_thread_pool_create(apr_thread_pool_t ** me,
     return rv;
 }
 
-APU_DECLARE(apr_status_t) apr_thread_pool_destroy(apr_thread_pool_t * me)
+APR_DECLARE(apr_status_t) apr_thread_pool_destroy(apr_thread_pool_t * me)
 {
     return apr_pool_cleanup_run(me->pool, me, thread_pool_cleanup);
 }
@@ -588,7 +588,7 @@ static apr_status_t add_task(apr_thread_pool_t *me, apr_thread_start_t func,
     return rv;
 }
 
-APU_DECLARE(apr_status_t) apr_thread_pool_push(apr_thread_pool_t *me,
+APR_DECLARE(apr_status_t) apr_thread_pool_push(apr_thread_pool_t *me,
                                                apr_thread_start_t func,
                                                void *param,
                                                apr_byte_t priority,
@@ -597,7 +597,7 @@ APU_DECLARE(apr_status_t) apr_thread_pool_push(apr_thread_pool_t *me,
     return add_task(me, func, param, priority, 1, owner);
 }
 
-APU_DECLARE(apr_status_t) apr_thread_pool_schedule(apr_thread_pool_t *me,
+APR_DECLARE(apr_status_t) apr_thread_pool_schedule(apr_thread_pool_t *me,
                                                    apr_thread_start_t func,
                                                    void *param,
                                                    apr_interval_time_t time,
@@ -606,7 +606,7 @@ APU_DECLARE(apr_status_t) apr_thread_pool_schedule(apr_thread_pool_t *me,
     return schedule_task(me, func, param, owner, time);
 }
 
-APU_DECLARE(apr_status_t) apr_thread_pool_top(apr_thread_pool_t *me,
+APR_DECLARE(apr_status_t) apr_thread_pool_top(apr_thread_pool_t *me,
                                               apr_thread_start_t func,
                                               void *param,
                                               apr_byte_t priority,
@@ -698,7 +698,7 @@ static void wait_on_busy_threads(apr_thread_pool_t *me, void *owner)
     return;
 }
 
-APU_DECLARE(apr_status_t) apr_thread_pool_tasks_cancel(apr_thread_pool_t *me,
+APR_DECLARE(apr_status_t) apr_thread_pool_tasks_cancel(apr_thread_pool_t *me,
                                                        void *owner)
 {
     apr_status_t rv = APR_SUCCESS;
@@ -716,63 +716,63 @@ APU_DECLARE(apr_status_t) apr_thread_pool_tasks_cancel(apr_thread_pool_t *me,
     return rv;
 }
 
-APU_DECLARE(apr_size_t) apr_thread_pool_tasks_count(apr_thread_pool_t *me)
+APR_DECLARE(apr_size_t) apr_thread_pool_tasks_count(apr_thread_pool_t *me)
 {
     return me->task_cnt;
 }
 
-APU_DECLARE(apr_size_t)
+APR_DECLARE(apr_size_t)
     apr_thread_pool_scheduled_tasks_count(apr_thread_pool_t *me)
 {
     return me->scheduled_task_cnt;
 }
 
-APU_DECLARE(apr_size_t) apr_thread_pool_threads_count(apr_thread_pool_t *me)
+APR_DECLARE(apr_size_t) apr_thread_pool_threads_count(apr_thread_pool_t *me)
 {
     return me->thd_cnt;
 }
 
-APU_DECLARE(apr_size_t) apr_thread_pool_busy_count(apr_thread_pool_t *me)
+APR_DECLARE(apr_size_t) apr_thread_pool_busy_count(apr_thread_pool_t *me)
 {
     return me->thd_cnt - me->idle_cnt;
 }
 
-APU_DECLARE(apr_size_t) apr_thread_pool_idle_count(apr_thread_pool_t *me)
+APR_DECLARE(apr_size_t) apr_thread_pool_idle_count(apr_thread_pool_t *me)
 {
     return me->idle_cnt;
 }
 
-APU_DECLARE(apr_size_t)
+APR_DECLARE(apr_size_t)
     apr_thread_pool_tasks_run_count(apr_thread_pool_t * me)
 {
     return me->tasks_run;
 }
 
-APU_DECLARE(apr_size_t)
+APR_DECLARE(apr_size_t)
     apr_thread_pool_tasks_high_count(apr_thread_pool_t * me)
 {
     return me->tasks_high;
 }
 
-APU_DECLARE(apr_size_t)
+APR_DECLARE(apr_size_t)
     apr_thread_pool_threads_high_count(apr_thread_pool_t * me)
 {
     return me->thd_high;
 }
 
-APU_DECLARE(apr_size_t)
+APR_DECLARE(apr_size_t)
     apr_thread_pool_threads_idle_timeout_count(apr_thread_pool_t * me)
 {
     return me->thd_timed_out;
 }
 
 
-APU_DECLARE(apr_size_t) apr_thread_pool_idle_max_get(apr_thread_pool_t *me)
+APR_DECLARE(apr_size_t) apr_thread_pool_idle_max_get(apr_thread_pool_t *me)
 {
     return me->idle_max;
 }
 
-APU_DECLARE(apr_interval_time_t)
+APR_DECLARE(apr_interval_time_t)
     apr_thread_pool_idle_wait_get(apr_thread_pool_t * me)
 {
     return me->idle_wait;
@@ -872,7 +872,7 @@ static apr_size_t trim_busy_threads(apr_thread_pool_t *me, apr_size_t cnt)
     return cnt;
 }
 
-APU_DECLARE(apr_size_t) apr_thread_pool_idle_max_set(apr_thread_pool_t *me,
+APR_DECLARE(apr_size_t) apr_thread_pool_idle_max_set(apr_thread_pool_t *me,
                                                      apr_size_t cnt)
 {
     me->idle_max = cnt;
@@ -880,7 +880,7 @@ APU_DECLARE(apr_size_t) apr_thread_pool_idle_max_set(apr_thread_pool_t *me,
     return cnt;
 }
 
-APU_DECLARE(apr_interval_time_t)
+APR_DECLARE(apr_interval_time_t)
     apr_thread_pool_idle_wait_set(apr_thread_pool_t * me,
                                   apr_interval_time_t timeout)
 {
@@ -892,7 +892,7 @@ APU_DECLARE(apr_interval_time_t)
     return oldtime;
 }
 
-APU_DECLARE(apr_size_t) apr_thread_pool_thread_max_get(apr_thread_pool_t *me)
+APR_DECLARE(apr_size_t) apr_thread_pool_thread_max_get(apr_thread_pool_t *me)
 {
     return me->thd_max;
 }
@@ -901,7 +901,7 @@ APU_DECLARE(apr_size_t) apr_thread_pool_thread_max_get(apr_thread_pool_t *me)
  * This function stop extra working threads to the new limit.
  * NOTE: There could be busy threads become idle during this function
  */
-APU_DECLARE(apr_size_t) apr_thread_pool_thread_max_set(apr_thread_pool_t *me,
+APR_DECLARE(apr_size_t) apr_thread_pool_thread_max_set(apr_thread_pool_t *me,
                                                        apr_size_t cnt)
 {
     unsigned int n;
@@ -922,12 +922,12 @@ APU_DECLARE(apr_size_t) apr_thread_pool_thread_max_set(apr_thread_pool_t *me,
     return n;
 }
 
-APU_DECLARE(apr_size_t) apr_thread_pool_threshold_get(apr_thread_pool_t *me)
+APR_DECLARE(apr_size_t) apr_thread_pool_threshold_get(apr_thread_pool_t *me)
 {
     return me->threshold;
 }
 
-APU_DECLARE(apr_size_t) apr_thread_pool_threshold_set(apr_thread_pool_t *me,
+APR_DECLARE(apr_size_t) apr_thread_pool_threshold_set(apr_thread_pool_t *me,
                                                       apr_size_t val)
 {
     apr_size_t ov;
@@ -937,7 +937,7 @@ APU_DECLARE(apr_size_t) apr_thread_pool_threshold_set(apr_thread_pool_t *me,
     return ov;
 }
 
-APU_DECLARE(apr_status_t) apr_thread_pool_task_owner_get(apr_thread_t *thd,
+APR_DECLARE(apr_status_t) apr_thread_pool_task_owner_get(apr_thread_t *thd,
                                                          void **owner)
 {
     apr_status_t rv;
diff --git a/util-misc/apu_version.c b/util-misc/apu_version.c
index 97e730997..033a1eefb 100644
--- a/util-misc/apu_version.c
+++ b/util-misc/apu_version.c
@@ -19,7 +19,7 @@
 #include "apu.h"
 #include "apu_version.h"
 
-APU_DECLARE(void) apu_version(apr_version_t *pvsn)
+APR_DECLARE(void) apu_version(apr_version_t *pvsn)
 {
     pvsn->major = APU_MAJOR_VERSION;
     pvsn->minor = APU_MINOR_VERSION;
@@ -31,7 +31,7 @@ APU_DECLARE(void) apu_version(apr_version_t *pvsn)
 #endif
 }
 
-APU_DECLARE(const char *) apu_version_string(void)
+APR_DECLARE(const char *) apu_version_string(void)
 {
     return APU_VERSION_STRING;
 }