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

13 files changed, 66 insertions, 66 deletions

diff --git a/buckets/apr_brigade.c b/buckets/apr_brigade.c
index 77adefff9..4519f6419 100644
--- a/buckets/apr_brigade.c
+++ b/buckets/apr_brigade.c
@@ -34,7 +34,7 @@ static apr_status_t brigade_cleanup(void *data)
     return apr_brigade_cleanup(data);
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data)
+APR_DECLARE(apr_status_t) apr_brigade_cleanup(void *data)
 {
     apr_bucket_brigade *b = data;
     apr_bucket *e;
@@ -47,13 +47,13 @@ APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data)
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b)
+APR_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b)
 {
     apr_pool_cleanup_kill(b->p, b, brigade_cleanup);
     return apr_brigade_cleanup(b);
 }
 
-APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p,
+APR_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p,
                                                      apr_bucket_alloc_t *list)
 {
     apr_bucket_brigade *b;
@@ -68,7 +68,7 @@ APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p,
     return b;
 }
 
-APU_DECLARE(apr_bucket_brigade *) apr_brigade_split_ex(apr_bucket_brigade *b,
+APR_DECLARE(apr_bucket_brigade *) apr_brigade_split_ex(apr_bucket_brigade *b,
                                                        apr_bucket *e,
                                                        apr_bucket_brigade *a)
 {
@@ -95,13 +95,13 @@ APU_DECLARE(apr_bucket_brigade *) apr_brigade_split_ex(apr_bucket_brigade *b,
     return a;
 }
 
-APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b,
+APR_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b,
                                                     apr_bucket *e)
 {
     return apr_brigade_split_ex(b, e, NULL);
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b,
+APR_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b,
                                                 apr_off_t point,
                                                 apr_bucket **after_point)
 {
@@ -187,7 +187,7 @@ APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b,
     return APR_INCOMPLETE;
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb,
+APR_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb,
                                              int read_all, apr_off_t *length)
 {
     apr_off_t total = 0;
@@ -220,7 +220,7 @@ APU_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb,
     return status;
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb,
+APR_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb,
                                               char *c, apr_size_t *len)
 {
     apr_size_t actual = 0;
@@ -265,7 +265,7 @@ APU_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb,
+APR_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb,
                                                char **c,
                                                apr_size_t *len,
                                                apr_pool_t *pool)
@@ -301,7 +301,7 @@ APU_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut,
+APR_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut,
                                                  apr_bucket_brigade *bbIn,
                                                  apr_read_type_e block,
                                                  apr_off_t maxbytes)
@@ -343,7 +343,7 @@ APU_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut,
 }
 
 
-APU_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b, 
+APR_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b, 
                                                struct iovec *vec, int *nvec)
 {
     int left = *nvec;
@@ -375,7 +375,7 @@ APU_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b, 
+APR_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b, 
                                                apr_brigade_flush flush,
                                                void *ctx,
                                                va_list va)
@@ -395,14 +395,14 @@ APU_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_putc(apr_bucket_brigade *b,
+APR_DECLARE(apr_status_t) apr_brigade_putc(apr_bucket_brigade *b,
                                            apr_brigade_flush flush, void *ctx,
                                            const char c)
 {
     return apr_brigade_write(b, flush, ctx, &c, 1);
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b,
+APR_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b,
                                             apr_brigade_flush flush,
                                             void *ctx, 
                                             const char *str, apr_size_t nbyte)
@@ -456,7 +456,7 @@ APU_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b,
+APR_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b,
                                              apr_brigade_flush flush,
                                              void *ctx,
                                              const struct iovec *vec,
@@ -576,7 +576,7 @@ APU_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb,
+APR_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb,
                                            apr_brigade_flush flush, void *ctx,
                                            const char *str)
 {
@@ -605,7 +605,7 @@ APU_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb,
     return apr_brigade_write(bb, flush, ctx, str, len);
 }
 
-APU_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b, 
+APR_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b, 
                                                      apr_brigade_flush flush,
                                                      void *ctx, ...)
 {
@@ -618,7 +618,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b,
     return rv;
 }
 
-APU_DECLARE_NONSTD(apr_status_t) apr_brigade_printf(apr_bucket_brigade *b, 
+APR_DECLARE_NONSTD(apr_status_t) apr_brigade_printf(apr_bucket_brigade *b, 
                                                     apr_brigade_flush flush,
                                                     void *ctx, 
                                                     const char *fmt, ...)
@@ -666,7 +666,7 @@ static apr_status_t brigade_flush(apr_vformatter_buff_t *buff)
     return res;
 }
 
-APU_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b,
+APR_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b,
                                               apr_brigade_flush flush,
                                               void *ctx,
                                               const char *fmt, va_list va)
@@ -696,7 +696,7 @@ APU_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b,
 /* A "safe" maximum bucket size, 1Gb */
 #define MAX_BUCKET_SIZE (0x40000000)
 
-APU_DECLARE(apr_bucket *) apr_brigade_insert_file(apr_bucket_brigade *bb,
+APR_DECLARE(apr_bucket *) apr_brigade_insert_file(apr_bucket_brigade *bb,
                                                   apr_file_t *f,
                                                   apr_off_t start,
                                                   apr_off_t length,
diff --git a/buckets/apr_buckets.c b/buckets/apr_buckets.c
index 802f4e259..0c2caa375 100644
--- a/buckets/apr_buckets.c
+++ b/buckets/apr_buckets.c
@@ -16,31 +16,31 @@
 
 #include "apr_buckets.h"
 
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_noop(apr_bucket *data,
+APR_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_noop(apr_bucket *data,
                                                           apr_pool_t *pool)
 {
     return APR_SUCCESS;
 }
 
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data,
+APR_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data,
                                                              apr_pool_t *pool)
 {
     return APR_ENOTIMPL;
 }
 
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data,
+APR_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data,
                                                           apr_size_t point)
 {
     return APR_ENOTIMPL;
 }
 
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e,
+APR_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e,
                                                          apr_bucket **c)
 {
     return APR_ENOTIMPL;
 }
 
-APU_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data)
+APR_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data)
 {
     return;
 }
diff --git a/buckets/apr_buckets_alloc.c b/buckets/apr_buckets_alloc.c
index 4ed516672..08c350cdb 100644
--- a/buckets/apr_buckets_alloc.c
+++ b/buckets/apr_buckets_alloc.c
@@ -52,7 +52,7 @@ static apr_status_t alloc_cleanup(void *data)
     return APR_SUCCESS;
 }
 
-APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p)
+APR_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p)
 {
     apr_allocator_t *allocator;
     apr_bucket_alloc_t *list;
@@ -69,7 +69,7 @@ APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p)
     return list;
 }
 
-APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(
+APR_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(
                                              apr_allocator_t *allocator)
 {
     apr_bucket_alloc_t *list;
@@ -89,7 +89,7 @@ APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(
     return list;
 }
 
-APU_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list)
+APR_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list)
 {
     if (list->pool) {
         apr_pool_cleanup_kill(list->pool, list, alloc_cleanup);
@@ -99,7 +99,7 @@ APU_DECLARE_NONSTD(void) apr_bucket_alloc_destroy(apr_bucket_alloc_t *list)
 
 }
 
-APU_DECLARE_NONSTD(void *) apr_bucket_alloc(apr_size_t size, 
+APR_DECLARE_NONSTD(void *) apr_bucket_alloc(apr_size_t size, 
                                             apr_bucket_alloc_t *list)
 {
     node_header_t *node;
@@ -163,7 +163,7 @@ static void check_not_already_free(node_header_t *node)
 #define check_not_already_free(node)
 #endif
 
-APU_DECLARE_NONSTD(void) apr_bucket_free(void *mem)
+APR_DECLARE_NONSTD(void) apr_bucket_free(void *mem)
 {
     node_header_t *node = (node_header_t *)((char *)mem - SIZEOF_NODE_HEADER_T);
     apr_bucket_alloc_t *list = node->alloc;
diff --git a/buckets/apr_buckets_eos.c b/buckets/apr_buckets_eos.c
index 25cff7562..446cd3c23 100644
--- a/buckets/apr_buckets_eos.c
+++ b/buckets/apr_buckets_eos.c
@@ -24,7 +24,7 @@ static apr_status_t eos_bucket_read(apr_bucket *b, const char **str,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b)
+APR_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b)
 {
     b->length      = 0;
     b->start       = 0;
@@ -34,7 +34,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b)
     return b;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_eos_create(apr_bucket_alloc_t *list)
+APR_DECLARE(apr_bucket *) apr_bucket_eos_create(apr_bucket_alloc_t *list)
 {
     apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
 
@@ -44,7 +44,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_eos_create(apr_bucket_alloc_t *list)
     return apr_bucket_eos_make(b);
 }
 
-APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_eos = {
+APR_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_eos = {
     "EOS", 5, APR_BUCKET_METADATA,
     apr_bucket_destroy_noop,
     eos_bucket_read,
diff --git a/buckets/apr_buckets_file.c b/buckets/apr_buckets_file.c
index 214b53d23..7df138a60 100644
--- a/buckets/apr_buckets_file.c
+++ b/buckets/apr_buckets_file.c
@@ -153,7 +153,7 @@ static apr_status_t file_bucket_read(apr_bucket *e, const char **str,
     return rv;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd,
+APR_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd,
                                                apr_off_t offset,
                                                apr_size_t len, apr_pool_t *p)
 {
@@ -172,7 +172,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd,
     return b;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd,
+APR_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd,
                                                  apr_off_t offset,
                                                  apr_size_t len, apr_pool_t *p,
                                                  apr_bucket_alloc_t *list)
@@ -185,7 +185,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd,
     return apr_bucket_file_make(b, fd, offset, len, p);
 }
 
-APU_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *e,
+APR_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *e,
                                                       int enabled)
 {
 #if APR_HAS_MMAP
@@ -218,7 +218,7 @@ static apr_status_t file_bucket_setaside(apr_bucket *data, apr_pool_t *reqpool)
     return APR_SUCCESS;
 }
 
-APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_file = {
+APR_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_file = {
     "FILE", 5, APR_BUCKET_DATA,
     file_bucket_destroy,
     file_bucket_read,
diff --git a/buckets/apr_buckets_flush.c b/buckets/apr_buckets_flush.c
index a5d84d755..dbb4fb9ba 100644
--- a/buckets/apr_buckets_flush.c
+++ b/buckets/apr_buckets_flush.c
@@ -24,7 +24,7 @@ static apr_status_t flush_bucket_read(apr_bucket *b, const char **str,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b)
+APR_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b)
 {
     b->length      = 0;
     b->start       = 0;
@@ -34,7 +34,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b)
     return b;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_flush_create(apr_bucket_alloc_t *list)
+APR_DECLARE(apr_bucket *) apr_bucket_flush_create(apr_bucket_alloc_t *list)
 {
     apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
 
@@ -44,7 +44,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_flush_create(apr_bucket_alloc_t *list)
     return apr_bucket_flush_make(b);
 }
 
-APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_flush = {
+APR_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_flush = {
     "FLUSH", 5, APR_BUCKET_METADATA, 
     apr_bucket_destroy_noop,
     flush_bucket_read,
diff --git a/buckets/apr_buckets_heap.c b/buckets/apr_buckets_heap.c
index 00f9808b9..7405d2caf 100644
--- a/buckets/apr_buckets_heap.c
+++ b/buckets/apr_buckets_heap.c
@@ -40,7 +40,7 @@ static void heap_bucket_destroy(void *data)
 
 /* Warning: if you change this function, be sure to
  * change apr_bucket_pool_make() too! */
-APU_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf,
+APR_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf,
                                                apr_size_t length,
                                                void (*free_func)(void *data))
 {
@@ -73,7 +73,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf,
     return b;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf,
+APR_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf,
                                                  apr_size_t length,
                                                  void (*free_func)(void *data),
                                                  apr_bucket_alloc_t *list)
@@ -86,7 +86,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf,
     return apr_bucket_heap_make(b, buf, length, free_func);
 }
 
-APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_heap = {
+APR_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_heap = {
     "HEAP", 5, APR_BUCKET_DATA,
     heap_bucket_destroy,
     heap_bucket_read,
diff --git a/buckets/apr_buckets_mmap.c b/buckets/apr_buckets_mmap.c
index 19de291b5..116b78868 100644
--- a/buckets/apr_buckets_mmap.c
+++ b/buckets/apr_buckets_mmap.c
@@ -68,7 +68,7 @@ static void mmap_bucket_destroy(void *data)
 /*
  * XXX: are the start and length arguments useful?
  */
-APU_DECLARE(apr_bucket *) apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm, 
+APR_DECLARE(apr_bucket *) apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm, 
                                                apr_off_t start, 
                                                apr_size_t length)
 {
@@ -87,7 +87,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm,
 }
 
 
-APU_DECLARE(apr_bucket *) apr_bucket_mmap_create(apr_mmap_t *mm, 
+APR_DECLARE(apr_bucket *) apr_bucket_mmap_create(apr_mmap_t *mm, 
                                                  apr_off_t start, 
                                                  apr_size_t length,
                                                  apr_bucket_alloc_t *list)
@@ -132,7 +132,7 @@ static apr_status_t mmap_bucket_setaside(apr_bucket *b, apr_pool_t *p)
     return APR_SUCCESS;
 }
 
-APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_mmap = {
+APR_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_mmap = {
     "MMAP", 5, APR_BUCKET_DATA,
     mmap_bucket_destroy,
     mmap_bucket_read,
diff --git a/buckets/apr_buckets_pipe.c b/buckets/apr_buckets_pipe.c
index 46b469705..574610b02 100644
--- a/buckets/apr_buckets_pipe.c
+++ b/buckets/apr_buckets_pipe.c
@@ -75,7 +75,7 @@ static apr_status_t pipe_bucket_read(apr_bucket *a, const char **str,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, apr_file_t *p)
+APR_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, apr_file_t *p)
 {
     /*
      * A pipe is closed when the end is reached in pipe_bucket_read().  If
@@ -98,7 +98,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, apr_file_t *p)
     return b;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *p,
+APR_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *p,
                                                  apr_bucket_alloc_t *list)
 {
     apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
@@ -109,7 +109,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *p,
     return apr_bucket_pipe_make(b, p);
 }
 
-APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_pipe = {
+APR_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_pipe = {
     "PIPE", 5, APR_BUCKET_DATA, 
     apr_bucket_destroy_noop,
     pipe_bucket_read,
diff --git a/buckets/apr_buckets_pool.c b/buckets/apr_buckets_pool.c
index 56ba585e0..da6029072 100644
--- a/buckets/apr_buckets_pool.c
+++ b/buckets/apr_buckets_pool.c
@@ -90,7 +90,7 @@ static void pool_bucket_destroy(void *data)
     }
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b,
+APR_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b,
                       const char *buf, apr_size_t length, apr_pool_t *pool)
 {
     apr_bucket_pool *p;
@@ -119,7 +119,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b,
     return b;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf,
+APR_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf,
                                                  apr_size_t length,
                                                  apr_pool_t *pool,
                                                  apr_bucket_alloc_t *list)
@@ -132,7 +132,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf,
     return apr_bucket_pool_make(b, buf, length, pool);
 }
 
-APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_pool = {
+APR_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_pool = {
     "POOL", 5, APR_BUCKET_DATA,
     pool_bucket_destroy,
     pool_bucket_read,
diff --git a/buckets/apr_buckets_refcount.c b/buckets/apr_buckets_refcount.c
index 0e765d94a..b1b57897b 100644
--- a/buckets/apr_buckets_refcount.c
+++ b/buckets/apr_buckets_refcount.c
@@ -16,7 +16,7 @@
 
 #include "apr_buckets.h"
 
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *a,
+APR_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *a,
                                                          apr_size_t point)
 {
     apr_bucket_refcount *r = a->data;
@@ -30,7 +30,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *a,
     return APR_SUCCESS;
 }
 
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_copy(apr_bucket *a,
+APR_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_copy(apr_bucket *a,
                                                         apr_bucket **b)
 {
     apr_bucket_refcount *r = a->data;
@@ -41,14 +41,14 @@ APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_copy(apr_bucket *a,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(int) apr_bucket_shared_destroy(void *data)
+APR_DECLARE(int) apr_bucket_shared_destroy(void *data)
 {
     apr_bucket_refcount *r = data;
     r->refcount--;
     return (r->refcount == 0);
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_shared_make(apr_bucket *b, void *data,
+APR_DECLARE(apr_bucket *) apr_bucket_shared_make(apr_bucket *b, void *data,
                                                  apr_off_t start,
                                                  apr_size_t length)
 {
diff --git a/buckets/apr_buckets_simple.c b/buckets/apr_buckets_simple.c
index cef748be7..14f11ba7d 100644
--- a/buckets/apr_buckets_simple.c
+++ b/buckets/apr_buckets_simple.c
@@ -16,7 +16,7 @@
 
 #include "apr_buckets.h"
 
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_copy(apr_bucket *a,
+APR_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_copy(apr_bucket *a,
                                                         apr_bucket **b)
 {
     *b = apr_bucket_alloc(sizeof(**b), a->list); /* XXX: check for failure? */
@@ -25,7 +25,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_copy(apr_bucket *a,
     return APR_SUCCESS;
 }
 
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *a,
+APR_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *a,
                                                          apr_size_t point)
 {
     apr_bucket *b;
@@ -53,7 +53,7 @@ static apr_status_t simple_bucket_read(apr_bucket *b, const char **str,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_immortal_make(apr_bucket *b,
+APR_DECLARE(apr_bucket *) apr_bucket_immortal_make(apr_bucket *b,
                                                    const char *buf,
                                                    apr_size_t length)
 {
@@ -65,7 +65,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_immortal_make(apr_bucket *b,
     return b;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_immortal_create(const char *buf,
+APR_DECLARE(apr_bucket *) apr_bucket_immortal_create(const char *buf,
                                                      apr_size_t length,
                                                      apr_bucket_alloc_t *list)
 {
@@ -95,7 +95,7 @@ static apr_status_t transient_bucket_setaside(apr_bucket *b, apr_pool_t *pool)
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_transient_make(apr_bucket *b,
+APR_DECLARE(apr_bucket *) apr_bucket_transient_make(apr_bucket *b,
                                                     const char *buf,
                                                     apr_size_t length)
 {
@@ -106,7 +106,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_transient_make(apr_bucket *b,
     return b;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_transient_create(const char *buf,
+APR_DECLARE(apr_bucket *) apr_bucket_transient_create(const char *buf,
                                                       apr_size_t length,
                                                       apr_bucket_alloc_t *list)
 {
@@ -127,7 +127,7 @@ const apr_bucket_type_t apr_bucket_type_immortal = {
     apr_bucket_simple_copy
 };
 
-APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_transient = {
+APR_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_transient = {
     "TRANSIENT", 5, APR_BUCKET_DATA,
     apr_bucket_destroy_noop, 
     simple_bucket_read,
diff --git a/buckets/apr_buckets_socket.c b/buckets/apr_buckets_socket.c
index 68eae43be..556304962 100644
--- a/buckets/apr_buckets_socket.c
+++ b/buckets/apr_buckets_socket.c
@@ -75,7 +75,7 @@ static apr_status_t socket_bucket_read(apr_bucket *a, const char **str,
     return APR_SUCCESS;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, apr_socket_t *p)
+APR_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, apr_socket_t *p)
 {
     /*
      * XXX: We rely on a cleanup on some pool or other to actually
@@ -93,7 +93,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, apr_socket_t *p)
     return b;
 }
 
-APU_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *p,
+APR_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *p,
                                                    apr_bucket_alloc_t *list)
 {
     apr_bucket *b = apr_bucket_alloc(sizeof(*b), list);
@@ -104,7 +104,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *p,
     return apr_bucket_socket_make(b, p);
 }
 
-APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_socket = {
+APR_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_socket = {
     "SOCKET", 5, APR_BUCKET_DATA,
     apr_bucket_destroy_noop,
     socket_bucket_read,