Convert various APU_DECLARE into APR_DECLARE.

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

37 files changed, 354 insertions, 354 deletions

diff --git a/include/apr_base64.h b/include/apr_base64.h
index b4b2b88fe..29f486696 100644
--- a/include/apr_base64.h
+++ b/include/apr_base64.h
@@ -56,7 +56,7 @@ extern "C" {
  * @param len the length of an unencrypted string.
  * @return the length of the string after it is encrypted
  */ 
-APU_DECLARE(int) apr_base64_encode_len(int len);
+APR_DECLARE(int) apr_base64_encode_len(int len);
 
 /**
  * Encode a text string using base64encoding.
@@ -65,7 +65,7 @@ APU_DECLARE(int) apr_base64_encode_len(int len);
  * @param len_plain_src The length of the plain text string
  * @return the length of the encoded string
  */ 
-APU_DECLARE(int) apr_base64_encode(char * coded_dst, const char *plain_src, 
+APR_DECLARE(int) apr_base64_encode(char * coded_dst, const char *plain_src, 
                                  int len_plain_src);
 
 /**
@@ -75,7 +75,7 @@ APU_DECLARE(int) apr_base64_encode(char * coded_dst, const char *plain_src,
  * @param len_plain_src The length of the plain text string
  * @return the length of the encoded string
  */ 
-APU_DECLARE(int) apr_base64_encode_binary(char * coded_dst, 
+APR_DECLARE(int) apr_base64_encode_binary(char * coded_dst, 
                                         const unsigned char *plain_src,
                                         int len_plain_src);
 
@@ -85,7 +85,7 @@ APU_DECLARE(int) apr_base64_encode_binary(char * coded_dst,
  * @param coded_src The encoded string
  * @return the maximum required buffer length for the plain text string
  */ 
-APU_DECLARE(int) apr_base64_decode_len(const char * coded_src);
+APR_DECLARE(int) apr_base64_decode_len(const char * coded_src);
 
 /**
  * Decode a string to plain text
@@ -93,7 +93,7 @@ APU_DECLARE(int) apr_base64_decode_len(const char * coded_src);
  * @param coded_src The encoded string 
  * @return the length of the plain text string
  */ 
-APU_DECLARE(int) apr_base64_decode(char * plain_dst, const char *coded_src);
+APR_DECLARE(int) apr_base64_decode(char * plain_dst, const char *coded_src);
 
 /**
  * Decode an EBCDIC string to plain text
@@ -101,7 +101,7 @@ APU_DECLARE(int) apr_base64_decode(char * plain_dst, const char *coded_src);
  * @param coded_src The encoded string 
  * @return the length of the plain text string
  */ 
-APU_DECLARE(int) apr_base64_decode_binary(unsigned char * plain_dst, 
+APR_DECLARE(int) apr_base64_decode_binary(unsigned char * plain_dst, 
                                         const char *coded_src);
 
 /** @} */
diff --git a/include/apr_buckets.h b/include/apr_buckets.h
index fb87635ca..e192a9c56 100644
--- a/include/apr_buckets.h
+++ b/include/apr_buckets.h
@@ -655,7 +655,7 @@ union apr_bucket_structs {
  * @param list The bucket allocator to use
  * @return The empty bucket brigade
  */
-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);
 
 /**
@@ -663,7 +663,7 @@ APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p,
  * buckets within the bucket brigade's bucket list. 
  * @param b The bucket brigade to destroy
  */
-APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b);
+APR_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b);
 
 /**
  * empty out an entire bucket brigade.  This includes destroying all of the
@@ -676,7 +676,7 @@ APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b);
  *         you wish to reuse many times by destroying all of the buckets in
  *         the brigade and putting new buckets into it later.
  */
-APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data);
+APR_DECLARE(apr_status_t) apr_brigade_cleanup(void *data);
 
 /**
  * Move the buckets from the tail end of the existing brigade @param b into
@@ -691,7 +691,7 @@ APU_DECLARE(apr_status_t) apr_brigade_cleanup(void *data);
  * @warning Note that this function allocates a new brigade if @param a is
  * NULL so memory consumption should be carefully considered.
  */
-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);
 
@@ -706,7 +706,7 @@ APU_DECLARE(apr_bucket_brigade *) apr_brigade_split_ex(apr_bucket_brigade *b,
  * @warning Note that this function always allocates a new brigade
  * so memory consumption should be carefully considered.
  */
-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);
 
 /**
@@ -721,7 +721,7 @@ APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b,
  * @remark if APR_INCOMPLETE is returned, @a after_point will be set to
  * the brigade sentinel.
  */
-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);
 
@@ -733,7 +733,7 @@ APU_DECLARE(apr_status_t) apr_brigade_partition(apr_bucket_brigade *b,
  *               to a bucket read error), or -1 if the brigade has buckets
  *               of indeterminate length and read_all is 0.
  */
-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);
 
@@ -744,7 +744,7 @@ APU_DECLARE(apr_status_t) apr_brigade_length(apr_bucket_brigade *bb,
  * @param len The maximum length of the char array. On return, it is the
  *            actual length of the char array.
  */
-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);
 
@@ -755,7 +755,7 @@ APU_DECLARE(apr_status_t) apr_brigade_flatten(apr_bucket_brigade *bb,
  * @param len On return, the length of the char array.
  * @param pool The pool to allocate the string from.
  */
-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);
@@ -768,7 +768,7 @@ APU_DECLARE(apr_status_t) apr_brigade_pflatten(apr_bucket_brigade *bb,
  * @param maxbytes The maximum bytes to read.  If this many bytes are seen
  *                 without a LF, the brigade will contain a partial line.
  */
-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);
@@ -782,7 +782,7 @@ APU_DECLARE(apr_status_t) apr_brigade_split_line(apr_bucket_brigade *bbOut,
  * @param nvec The number of elements in the iovec. On return, it is the
  *             number of iovec elements actually filled out.
  */
-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);
 
 /**
@@ -793,7 +793,7 @@ APU_DECLARE(apr_status_t) apr_brigade_to_iovec(apr_bucket_brigade *b,
  * @param va A list of strings to add
  * @return APR_SUCCESS or error code.
  */
-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);
@@ -821,7 +821,7 @@ APU_DECLARE(apr_status_t) apr_brigade_vputstrs(apr_bucket_brigade *b,
  * @param nbyte The number of bytes to write
  * @return APR_SUCCESS or error code
  */
-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);
 
@@ -834,7 +834,7 @@ APU_DECLARE(apr_status_t) apr_brigade_write(apr_bucket_brigade *b,
  * @param nvec The number of entries in iovec
  * @return APR_SUCCESS or error code
  */
-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,
@@ -848,7 +848,7 @@ APU_DECLARE(apr_status_t) apr_brigade_writev(apr_bucket_brigade *b,
  * @param str The string to add
  * @return APR_SUCCESS or error code
  */
-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);
 
@@ -860,7 +860,7 @@ APU_DECLARE(apr_status_t) apr_brigade_puts(apr_bucket_brigade *bb,
  * @param c The character to add
  * @return APR_SUCCESS or error code
  */
-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);
 
@@ -872,7 +872,7 @@ APU_DECLARE(apr_status_t) apr_brigade_putc(apr_bucket_brigade *b,
  * @param ... The strings to add
  * @return APR_SUCCESS or error code
  */
-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, ...);
 
@@ -886,7 +886,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_brigade_putstrs(apr_bucket_brigade *b,
  * @param ... The arguments to fill out the format
  * @return APR_SUCCESS or error code
  */
-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, ...)
@@ -902,7 +902,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_brigade_printf(apr_bucket_brigade *b,
  * @param va The arguments to fill out the format
  * @return APR_SUCCESS or error code
  */
-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);
@@ -919,7 +919,7 @@ APU_DECLARE(apr_status_t) apr_brigade_vprintf(apr_bucket_brigade *b,
  * @param p pool from which file buckets are allocated
  * @return the last bucket inserted
  */
-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 len,
@@ -941,7 +941,7 @@ APU_DECLARE(apr_bucket *) apr_brigade_insert_file(apr_bucket_brigade *bb,
  *          footprint growth that would occur if we allocated from the pool.
  * @warning The allocator must never be used by more than one thread at a time.
  */
-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);
 
 /**
  * Create a bucket allocator.
@@ -951,26 +951,26 @@ APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create(apr_pool_t *p);
  *          apr_allocator_t -- no automatic cleanups will happen.
  * @warning The allocator must never be used by more than one thread at a time.
  */
-APU_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(apr_allocator_t *allocator);
+APR_DECLARE_NONSTD(apr_bucket_alloc_t *) apr_bucket_alloc_create_ex(apr_allocator_t *allocator);
 
 /**
  * Destroy a bucket allocator.
  * @param list The allocator to be destroyed
  */
-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);
 
 /**
  * Allocate memory for use by the buckets.
  * @param size The amount to allocate.
  * @param list The allocator from which to allocate the memory.
  */
-APU_DECLARE_NONSTD(void *) apr_bucket_alloc(apr_size_t size, apr_bucket_alloc_t *list);
+APR_DECLARE_NONSTD(void *) apr_bucket_alloc(apr_size_t size, apr_bucket_alloc_t *list);
 
 /**
  * Free memory previously allocated with apr_bucket_alloc().
  * @param block The block of memory to be freed.
  */
-APU_DECLARE_NONSTD(void) apr_bucket_free(void *block);
+APR_DECLARE_NONSTD(void) apr_bucket_free(void *block);
 
 
 /*  *****  Bucket Functions  *****  */
@@ -1108,7 +1108,7 @@ APU_DECLARE_NONSTD(void) apr_bucket_free(void *block);
  * @param pool The pool defining the desired lifetime of the bucket data
  * @return APR_SUCCESS
  */ 
-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);
 
 /**
@@ -1118,7 +1118,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_noop(apr_bucket *data,
  * @param pool The pool defining the desired lifetime of the bucket data
  * @return APR_ENOTIMPL
  */ 
-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);
 
 /**
@@ -1128,7 +1128,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data,
  * @param point The location to split the bucket
  * @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);
 
 /**
@@ -1138,7 +1138,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data,
  * @param c Returns a pointer to the new bucket
  * @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);
 
 /**
@@ -1150,7 +1150,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e,
  * points directly to the apr_file_t.
  * @param data The bucket data to destroy
  */ 
-APU_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data);
+APR_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data);
 
 /**
  * There is no apr_bucket_destroy_notimpl, because destruction is required
@@ -1167,54 +1167,54 @@ APU_DECLARE_NONSTD(void) apr_bucket_destroy_noop(void *data);
  * The flush bucket type.  This signifies that all data should be flushed to
  * the next filter.  The flush bucket should be sent with the other buckets.
  */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_flush;
+APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_flush;
 /**
  * The EOS bucket type.  This signifies that there will be no more data, ever.
  * All filters MUST send all data to the next filter when they receive a
  * bucket of this type
  */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_eos;
+APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_eos;
 /**
  * The FILE bucket type.  This bucket represents a file on disk
  */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_file;
+APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_file;
 /**
  * The HEAP bucket type.  This bucket represents a data allocated from the
  * heap.
  */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_heap;
+APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_heap;
 #if APR_HAS_MMAP
 /**
  * The MMAP bucket type.  This bucket represents an MMAP'ed file
  */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_mmap;
+APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_mmap;
 #endif
 /**
  * The POOL bucket type.  This bucket represents a data that was allocated
  * from a pool.  IF this bucket is still available when the pool is cleared,
  * the data is copied on to the heap.
  */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pool;
+APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pool;
 /**
  * The PIPE bucket type.  This bucket represents a pipe to another program.
  */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pipe;
+APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_pipe;
 /**
  * The IMMORTAL bucket type.  This bucket represents a segment of data that
  * the creator is willing to take responsibility for.  The core will do
  * nothing with the data in an immortal bucket
  */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_immortal;
+APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_immortal;
 /**
  * The TRANSIENT bucket type.  This bucket represents a data allocated off
  * the stack.  When the setaside function is called, this data is copied on
  * to the heap
  */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_transient;
+APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_transient;
 /**
  * The SOCKET bucket type.  This bucket represents a socket to another machine
  */
-APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_socket;
+APR_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_socket;
 
 
 /*  *****  Simple buckets  *****  */
@@ -1230,7 +1230,7 @@ APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_socket;
  *         APR_ENOMEM if allocation failed;
  *         or APR_SUCCESS
  */
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *b,
+APR_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *b,
                                                          apr_size_t point);
 
 /**
@@ -1243,7 +1243,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_split(apr_bucket *b,
  * @return APR_ENOMEM if allocation failed;
  *         or APR_SUCCESS
  */
-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);
 
 
@@ -1263,7 +1263,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_bucket_simple_copy(apr_bucket *a,
  * @param length The length of the data in the bucket
  * @return The new bucket, or NULL if allocation failed
  */
-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);
 
@@ -1275,7 +1275,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_shared_make(apr_bucket *b, void *data,
  *         zero, indicating that the shared resource itself can
  *         be destroyed by the caller.
  */
-APU_DECLARE(int) apr_bucket_shared_destroy(void *data);
+APR_DECLARE(int) apr_bucket_shared_destroy(void *data);
 
 /**
  * Split a bucket into two at the given point, and adjust the refcount
@@ -1288,7 +1288,7 @@ APU_DECLARE(int) apr_bucket_shared_destroy(void *data);
  *         APR_ENOMEM if allocation failed;
  *         or APR_SUCCESS
  */
-APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *b,
+APR_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *b,
                                                          apr_size_t point);
 
 /**
@@ -1300,7 +1300,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_split(apr_bucket *b,
  * @return APR_ENOMEM if allocation failed;
            or 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);
 
 
@@ -1322,7 +1322,7 @@ APU_DECLARE_NONSTD(apr_status_t) apr_bucket_shared_copy(apr_bucket *a,
  * @param list The freelist from which this bucket should be allocated
  * @return The new bucket, or NULL if allocation failed
  */
-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);
 
 /**
  * Make the bucket passed in an EOS bucket.  This indicates that there is no 
@@ -1331,7 +1331,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_eos_create(apr_bucket_alloc_t *list);
  * @param b The bucket to make into an EOS bucket
  * @return The new bucket, or NULL if allocation failed
  */
-APU_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b);
+APR_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b);
 
 /**
  * Create a flush  bucket.  This indicates that filters should flush their
@@ -1340,7 +1340,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_eos_make(apr_bucket *b);
  * @param list The freelist from which this bucket should be allocated
  * @return The new bucket, or NULL if allocation failed
  */
-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);
 
 /**
  * Make the bucket passed in a FLUSH  bucket.  This indicates that filters 
@@ -1349,7 +1349,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_flush_create(apr_bucket_alloc_t *list);
  * @param b The bucket to make into a FLUSH bucket
  * @return The new bucket, or NULL if allocation failed
  */
-APU_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b);
+APR_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b);
 
 /**
  * Create a bucket referring to long-lived data.
@@ -1358,7 +1358,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_flush_make(apr_bucket *b);
  * @param list The freelist from which this bucket should be allocated
  * @return The new bucket, or NULL if allocation failed
  */
-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 nbyte,
                                                      apr_bucket_alloc_t *list);
 
@@ -1369,7 +1369,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_immortal_create(const char *buf,
  * @param nbyte The size of the data to insert.
  * @return The new bucket, or NULL if allocation failed
  */
-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 nbyte);
 
@@ -1380,7 +1380,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_immortal_make(apr_bucket *b,
  * @param list The freelist from which this bucket should be allocated
  * @return The new bucket, or NULL if allocation failed
  */
-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 nbyte,
                                                       apr_bucket_alloc_t *list);
 
@@ -1391,7 +1391,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_transient_create(const char *buf,
  * @param nbyte The size of the data to insert.
  * @return The new bucket, or NULL if allocation failed
  */
-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 nbyte);
 
@@ -1409,7 +1409,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_transient_make(apr_bucket *b,
  * @param list The freelist from which this bucket should be allocated
  * @return The new bucket, or NULL if allocation failed
  */
-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 nbyte,
                                                  void (*free_func)(void *data),
                                                  apr_bucket_alloc_t *list);
@@ -1422,7 +1422,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_heap_create(const char *buf,
  *                  bucket should make a copy of the data
  * @return The new bucket, or NULL if allocation failed
  */
-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 nbyte,
                                                void (*free_func)(void *data));
 
@@ -1435,7 +1435,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_heap_make(apr_bucket *b, const char *buf,
  * @param list The freelist from which this bucket should be allocated
  * @return The new bucket, or NULL if allocation failed
  */
-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);
@@ -1448,7 +1448,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_pool_create(const char *buf,
  * @param pool The pool the memory was allocated from
  * @return The new bucket, or NULL if allocation failed
  */
-APU_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b, const char *buf,
+APR_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b, const char *buf,
                                                apr_size_t length, 
                                                apr_pool_t *pool);
 
@@ -1462,7 +1462,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_pool_make(apr_bucket *b, const char *buf,
  * @param list The freelist from which this bucket should be allocated
  * @return The new bucket, or NULL if allocation failed
  */
-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);
@@ -1476,7 +1476,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_mmap_create(apr_mmap_t *mm,
  * @param length The number of bytes referred to by this bucket
  * @return The new bucket, or NULL if allocation failed
  */
-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);
 #endif
@@ -1487,7 +1487,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_mmap_make(apr_bucket *b, apr_mmap_t *mm,
  * @param list The freelist from which this bucket should be allocated
  * @return The new bucket, or NULL if allocation failed
  */
-APU_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *thissock,
+APR_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *thissock,
                                                    apr_bucket_alloc_t *list);
 /**
  * Make the bucket passed in a bucket refer to a socket
@@ -1495,7 +1495,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_socket_create(apr_socket_t *thissock,
  * @param thissock The socket to put in the bucket
  * @return The new bucket, or NULL if allocation failed
  */
-APU_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, 
+APR_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b, 
                                                  apr_socket_t *thissock);
 
 /**
@@ -1504,7 +1504,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_socket_make(apr_bucket *b,
  * @param list The freelist from which this bucket should be allocated
  * @return The new bucket, or NULL if allocation failed
  */
-APU_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *thispipe,
+APR_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *thispipe,
                                                  apr_bucket_alloc_t *list);
 
 /**
@@ -1513,7 +1513,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_pipe_create(apr_file_t *thispipe,
  * @param thispipe The pipe to put in the bucket
  * @return The new bucket, or NULL if allocation failed
  */
-APU_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, 
+APR_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b, 
                                                apr_file_t *thispipe);
 
 /**
@@ -1532,7 +1532,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_pipe_make(apr_bucket *b,
  * insert files into brigades, since that function can correctly
  * handle large file issues.
  */
-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,
@@ -1548,7 +1548,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_file_create(apr_file_t *fd,
  *          while reading from this file bucket
  * @return The new bucket, or NULL if allocation failed
  */
-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);
 
@@ -1558,7 +1558,7 @@ APU_DECLARE(apr_bucket *) apr_bucket_file_make(apr_bucket *b, apr_file_t *fd,
  * @param enabled Whether memory-mapping should be enabled
  * @return APR_SUCCESS normally, or an error code if the operation fails
  */
-APU_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *b,
+APR_DECLARE(apr_status_t) apr_bucket_file_enable_mmap(apr_bucket *b,
                                                       int enabled);
 
 /** @} */
diff --git a/include/apr_crypto.h b/include/apr_crypto.h
index 2577248c1..207450806 100644
--- a/include/apr_crypto.h
+++ b/include/apr_crypto.h
@@ -195,7 +195,7 @@ typedef struct apr_crypto_t {
  * @param pool - pool to register any shutdown cleanups, etc
  * @return APR_NOTIMPL in case of no crypto support.
  */
-APU_DECLARE(apr_status_t) apr_crypto_init(apr_pool_t *pool,
+APR_DECLARE(apr_status_t) apr_crypto_init(apr_pool_t *pool,
         const apr_array_header_t *params);
 
 /**
@@ -209,7 +209,7 @@ APU_DECLARE(apr_status_t) apr_crypto_init(apr_pool_t *pool,
  * @return APR_EDSOOPEN if DSO driver file can't be opened
  * @return APR_ESYMNOTFOUND if the driver file doesn't contain a driver
  */
-APU_DECLARE(apr_status_t) apr_crypto_get_driver(apr_pool_t *pool, const char *name,
+APR_DECLARE(apr_status_t) apr_crypto_get_driver(apr_pool_t *pool, const char *name,
         const apr_crypto_driver_t **driver, const apr_array_header_t *params,
         const apu_err_t **result);
 
@@ -219,7 +219,7 @@ APU_DECLARE(apr_status_t) apr_crypto_get_driver(apr_pool_t *pool, const char *na
  * @param driver - The driver in use.
  * @return The name of the driver.
  */
-APU_DECLARE(const char *)apr_crypto_driver_name (const apr_crypto_driver_t *driver);
+APR_DECLARE(const char *)apr_crypto_driver_name (const apr_crypto_driver_t *driver);
 
 /**
  * @brief Get the result of the last operation on a factory. If the result
@@ -229,7 +229,7 @@ APU_DECLARE(const char *)apr_crypto_driver_name (const apr_crypto_driver_t *driv
  * @param result - the result structure
  * @return APR_SUCCESS for success
  */
-APU_DECLARE(apr_status_t) apr_crypto_error(const apr_crypto_t *f,
+APR_DECLARE(apr_status_t) apr_crypto_error(const apr_crypto_t *f,
         const apu_err_t **result);
 
 /**
@@ -244,7 +244,7 @@ APU_DECLARE(apr_status_t) apr_crypto_error(const apr_crypto_t *f,
  * @return APR_ENOENGINE when the engine specified does not exist. APR_EINITENGINE
  * if the engine cannot be initialised.
  */
-APU_DECLARE(apr_status_t) apr_crypto_factory(const apr_crypto_driver_t *driver,
+APR_DECLARE(apr_status_t) apr_crypto_factory(const apr_crypto_driver_t *driver,
         apr_pool_t *pool, const apr_array_header_t *params, apr_crypto_t **f);
 
 /**
@@ -275,7 +275,7 @@ APU_DECLARE(apr_status_t) apr_crypto_factory(const apr_crypto_driver_t *driver,
  *         not known. APR_EPADDING if padding was requested but is not supported.
  *         APR_ENOTIMPL if not implemented.
  */
-APU_DECLARE(apr_status_t) apr_crypto_passphrase(const apr_crypto_driver_t *driver,
+APR_DECLARE(apr_status_t) apr_crypto_passphrase(const apr_crypto_driver_t *driver,
         apr_pool_t *p, const apr_crypto_t *f, const char *pass,
         apr_size_t passLen, const unsigned char * salt, apr_size_t saltLen,
         const apr_crypto_block_key_type_e type,
@@ -300,7 +300,7 @@ APU_DECLARE(apr_status_t) apr_crypto_passphrase(const apr_crypto_driver_t *drive
  *         Returns APR_EINIT if the backend failed to initialise the context. Returns
  *         APR_ENOTIMPL if not implemented.
  */
-APU_DECLARE(apr_status_t) apr_crypto_block_encrypt_init(
+APR_DECLARE(apr_status_t) apr_crypto_block_encrypt_init(
         const apr_crypto_driver_t *driver, apr_pool_t *p,
         const apr_crypto_t *f, const apr_crypto_key_t *key,
         const unsigned char **iv, apr_crypto_block_t **ctx,
@@ -325,7 +325,7 @@ APU_DECLARE(apr_status_t) apr_crypto_block_encrypt_init(
  * @return APR_ECRYPT if an error occurred. Returns APR_ENOTIMPL if
  *         not implemented.
  */
-APU_DECLARE(apr_status_t) apr_crypto_block_encrypt(
+APR_DECLARE(apr_status_t) apr_crypto_block_encrypt(
         const apr_crypto_driver_t *driver, apr_crypto_block_t *ctx,
         unsigned char **out, apr_size_t *outlen, const unsigned char *in,
         apr_size_t inlen);
@@ -349,7 +349,7 @@ APU_DECLARE(apr_status_t) apr_crypto_block_encrypt(
  *         formatted.
  * @return APR_ENOTIMPL if not implemented.
  */
-APU_DECLARE(apr_status_t) apr_crypto_block_encrypt_finish(
+APR_DECLARE(apr_status_t) apr_crypto_block_encrypt_finish(
         const apr_crypto_driver_t *driver, apr_crypto_block_t *ctx,
         unsigned char *out, apr_size_t *outlen);
 
@@ -368,7 +368,7 @@ APU_DECLARE(apr_status_t) apr_crypto_block_encrypt_finish(
  *         Returns APR_EINIT if the backend failed to initialise the context. Returns
  *         APR_ENOTIMPL if not implemented.
  */
-APU_DECLARE(apr_status_t) apr_crypto_block_decrypt_init(
+APR_DECLARE(apr_status_t) apr_crypto_block_decrypt_init(
         const apr_crypto_driver_t *driver, apr_pool_t *p,
         const apr_crypto_t *f, const apr_crypto_key_t *key,
         const unsigned char *iv, apr_crypto_block_t **ctx,
@@ -393,7 +393,7 @@ APU_DECLARE(apr_status_t) apr_crypto_block_decrypt_init(
  * @return APR_ECRYPT if an error occurred. Returns APR_ENOTIMPL if
  *         not implemented.
  */
-APU_DECLARE(apr_status_t) apr_crypto_block_decrypt(
+APR_DECLARE(apr_status_t) apr_crypto_block_decrypt(
         const apr_crypto_driver_t *driver, apr_crypto_block_t *ctx,
         unsigned char **out, apr_size_t *outlen, const unsigned char *in,
         apr_size_t inlen);
@@ -417,7 +417,7 @@ APU_DECLARE(apr_status_t) apr_crypto_block_decrypt(
  *         formatted.
  * @return APR_ENOTIMPL if not implemented.
  */
-APU_DECLARE(apr_status_t) apr_crypto_block_decrypt_finish(
+APR_DECLARE(apr_status_t) apr_crypto_block_decrypt_finish(
         const apr_crypto_driver_t *driver, apr_crypto_block_t *ctx,
         unsigned char *out, apr_size_t *outlen);
 
@@ -428,7 +428,7 @@ APU_DECLARE(apr_status_t) apr_crypto_block_decrypt_finish(
  * @param ctx The block context to use.
  * @return Returns APR_ENOTIMPL if not supported.
  */
-APU_DECLARE(apr_status_t) apr_crypto_block_cleanup(
+APR_DECLARE(apr_status_t) apr_crypto_block_cleanup(
         const apr_crypto_driver_t *driver, apr_crypto_block_t *ctx);
 
 /**
@@ -438,7 +438,7 @@ APU_DECLARE(apr_status_t) apr_crypto_block_cleanup(
  * @param f The factory to use.
  * @return Returns APR_ENOTIMPL if not supported.
  */
-APU_DECLARE(apr_status_t) apr_crypto_cleanup(const apr_crypto_driver_t *driver,
+APR_DECLARE(apr_status_t) apr_crypto_cleanup(const apr_crypto_driver_t *driver,
         apr_crypto_t *f);
 
 /**
@@ -448,7 +448,7 @@ APU_DECLARE(apr_status_t) apr_crypto_cleanup(const apr_crypto_driver_t *driver,
  * @param p The pool to use.
  * @return Returns APR_ENOTIMPL if not supported.
  */
-APU_DECLARE(apr_status_t) apr_crypto_shutdown(const apr_crypto_driver_t *driver,
+APR_DECLARE(apr_status_t) apr_crypto_shutdown(const apr_crypto_driver_t *driver,
         apr_pool_t *p);
 
 #endif /* APU_HAVE_CRYPTO */
diff --git a/include/apr_date.h b/include/apr_date.h
index b098b5429..c9ac19925 100644
--- a/include/apr_date.h
+++ b/include/apr_date.h
@@ -57,7 +57,7 @@ extern "C" {
  * @remark The mask tests for an exact match for any other character
  * @return 1 if the string matches, 0 otherwise
  */
-APU_DECLARE(int) apr_date_checkmask(const char *data, const char *mask);
+APR_DECLARE(int) apr_date_checkmask(const char *data, const char *mask);
 
 /**
  * Parses an HTTP date in one of three standard forms:
@@ -70,7 +70,7 @@ APU_DECLARE(int) apr_date_checkmask(const char *data, const char *mask);
  * @return the apr_time_t number of microseconds since 1 Jan 1970 GMT, or
  *         0 if this would be out of range or if the date is invalid.
  */
-APU_DECLARE(apr_time_t) apr_date_parse_http(const char *date);
+APR_DECLARE(apr_time_t) apr_date_parse_http(const char *date);
 
 /**
  * Parses a string resembling an RFC 822 date.  This is meant to be
@@ -96,7 +96,7 @@ APU_DECLARE(apr_time_t) apr_date_parse_http(const char *date);
  * @return the apr_time_t number of microseconds since 1 Jan 1970 GMT, or
  *         0 if this would be out of range or if the date is invalid.
  */
-APU_DECLARE(apr_time_t) apr_date_parse_rfc(const char *date);
+APR_DECLARE(apr_time_t) apr_date_parse_rfc(const char *date);
 
 /** @} */
 #ifdef __cplusplus
diff --git a/include/apr_dbd.h b/include/apr_dbd.h
index f30977daf..5eb6e1c34 100644
--- a/include/apr_dbd.h
+++ b/include/apr_dbd.h
@@ -90,7 +90,7 @@ typedef struct apr_dbd_prepared_t apr_dbd_prepared_t;
  *
  *  @param pool - pool to register any shutdown cleanups, etc
  */
-APU_DECLARE(apr_status_t) apr_dbd_init(apr_pool_t *pool);
+APR_DECLARE(apr_status_t) apr_dbd_init(apr_pool_t *pool);
 
 /** apr_dbd_get_driver: get the driver struct for a name
  *
@@ -102,7 +102,7 @@ APU_DECLARE(apr_status_t) apr_dbd_init(apr_pool_t *pool);
  *  @return APR_EDSOOPEN if DSO driver file can't be opened
  *  @return APR_ESYMNOTFOUND if the driver file doesn't contain a driver
  */
-APU_DECLARE(apr_status_t) apr_dbd_get_driver(apr_pool_t *pool, const char *name,
+APR_DECLARE(apr_status_t) apr_dbd_get_driver(apr_pool_t *pool, const char *name,
                                              const apr_dbd_driver_t **driver);
 
 /** apr_dbd_open_ex: open a connection to a backend
@@ -140,7 +140,7 @@ APU_DECLARE(apr_status_t) apr_dbd_get_driver(apr_pool_t *pool, const char *name,
  *  "dbname", "host", "charset", "lang" and "server" keys, each followed by an
  *  equal sign and a value.
  */
-APU_DECLARE(apr_status_t) apr_dbd_open_ex(const apr_dbd_driver_t *driver,
+APR_DECLARE(apr_status_t) apr_dbd_open_ex(const apr_dbd_driver_t *driver,
                                           apr_pool_t *pool, const char *params,
                                           apr_dbd_t **handle,
                                           const char **error);
@@ -155,7 +155,7 @@ APU_DECLARE(apr_status_t) apr_dbd_open_ex(const apr_dbd_driver_t *driver,
  *  @return APR_EGENERAL if driver exists but connection failed
  *  @see apr_dbd_open_ex
  */
-APU_DECLARE(apr_status_t) apr_dbd_open(const apr_dbd_driver_t *driver,
+APR_DECLARE(apr_status_t) apr_dbd_open(const apr_dbd_driver_t *driver,
                                        apr_pool_t *pool, const char *params,
                                        apr_dbd_t **handle);
 
@@ -165,7 +165,7 @@ APU_DECLARE(apr_status_t) apr_dbd_open(const apr_dbd_driver_t *driver,
  *  @param driver - driver struct.
  *  @return APR_SUCCESS for success or error status
  */
-APU_DECLARE(apr_status_t) apr_dbd_close(const apr_dbd_driver_t *driver,
+APR_DECLARE(apr_status_t) apr_dbd_close(const apr_dbd_driver_t *driver,
                                         apr_dbd_t *handle);
 
 /* apr-function-shaped versions of things */
@@ -175,7 +175,7 @@ APU_DECLARE(apr_status_t) apr_dbd_close(const apr_dbd_driver_t *driver,
  *  @param driver - the driver
  *  @return - name
  */
-APU_DECLARE(const char*) apr_dbd_name(const apr_dbd_driver_t *driver);
+APR_DECLARE(const char*) apr_dbd_name(const apr_dbd_driver_t *driver);
 
 /** apr_dbd_native_handle: get native database handle of the underlying db
  *
@@ -183,7 +183,7 @@ APU_DECLARE(const char*) apr_dbd_name(const apr_dbd_driver_t *driver);
  *  @param handle - apr_dbd handle
  *  @return - native handle
  */
-APU_DECLARE(void*) apr_dbd_native_handle(const apr_dbd_driver_t *driver,
+APR_DECLARE(void*) apr_dbd_native_handle(const apr_dbd_driver_t *driver,
                                          apr_dbd_t *handle);
 
 /** check_conn: check status of a database connection
@@ -193,7 +193,7 @@ APU_DECLARE(void*) apr_dbd_native_handle(const apr_dbd_driver_t *driver,
  *  @param handle - the connection to check
  *  @return APR_SUCCESS or error
  */
-APU_DECLARE(int) apr_dbd_check_conn(const apr_dbd_driver_t *driver, apr_pool_t *pool,
+APR_DECLARE(int) apr_dbd_check_conn(const apr_dbd_driver_t *driver, apr_pool_t *pool,
                                     apr_dbd_t *handle);
 
 /** apr_dbd_set_dbname: select database name.  May be a no-op if not supported.
@@ -204,7 +204,7 @@ APU_DECLARE(int) apr_dbd_check_conn(const apr_dbd_driver_t *driver, apr_pool_t *
  *  @param name - the database to select
  *  @return 0 for success or error code
  */
-APU_DECLARE(int) apr_dbd_set_dbname(const apr_dbd_driver_t *driver, apr_pool_t *pool,
+APR_DECLARE(int) apr_dbd_set_dbname(const apr_dbd_driver_t *driver, apr_pool_t *pool,
                                     apr_dbd_t *handle, const char *name);
 
 /** apr_dbd_transaction_start: start a transaction.  May be a no-op.
@@ -221,7 +221,7 @@ APU_DECLARE(int) apr_dbd_set_dbname(const apr_dbd_driver_t *driver, apr_pool_t *
  *  query/select calls will fail immediately. Put transaction in "ignore
  *  errors" mode to avoid that. Use "rollback" mode to do explicit rollback.
  */
-APU_DECLARE(int) apr_dbd_transaction_start(const apr_dbd_driver_t *driver,
+APR_DECLARE(int) apr_dbd_transaction_start(const apr_dbd_driver_t *driver,
                                            apr_pool_t *pool,
                                            apr_dbd_t *handle,
                                            apr_dbd_transaction_t **trans);
@@ -235,7 +235,7 @@ APU_DECLARE(int) apr_dbd_transaction_start(const apr_dbd_driver_t *driver,
  *  @param trans - the transaction.
  *  @return 0 for success or error code
  */
-APU_DECLARE(int) apr_dbd_transaction_end(const apr_dbd_driver_t *driver,
+APR_DECLARE(int) apr_dbd_transaction_end(const apr_dbd_driver_t *driver,
                                          apr_pool_t *pool,
                                          apr_dbd_transaction_t *trans);
 
@@ -249,7 +249,7 @@ APU_DECLARE(int) apr_dbd_transaction_end(const apr_dbd_driver_t *driver,
  *  @param trans  - the transaction
  *  @return mode of transaction
  */
-APU_DECLARE(int) apr_dbd_transaction_mode_get(const apr_dbd_driver_t *driver,
+APR_DECLARE(int) apr_dbd_transaction_mode_get(const apr_dbd_driver_t *driver,
                                               apr_dbd_transaction_t *trans);
 
 /** apr_dbd_transaction_mode_set: set the mode of transaction
@@ -259,7 +259,7 @@ APU_DECLARE(int) apr_dbd_transaction_mode_get(const apr_dbd_driver_t *driver,
  *  @param mode   - new mode of the transaction
  *  @return the mode of transaction in force after the call
  */
-APU_DECLARE(int) apr_dbd_transaction_mode_set(const apr_dbd_driver_t *driver,
+APR_DECLARE(int) apr_dbd_transaction_mode_set(const apr_dbd_driver_t *driver,
                                               apr_dbd_transaction_t *trans,
                                               int mode);
 
@@ -271,7 +271,7 @@ APU_DECLARE(int) apr_dbd_transaction_mode_set(const apr_dbd_driver_t *driver,
  *  @param statement - the SQL statement to execute
  *  @return 0 for success or error code
  */
-APU_DECLARE(int) apr_dbd_query(const apr_dbd_driver_t *driver, apr_dbd_t *handle,
+APR_DECLARE(int) apr_dbd_query(const apr_dbd_driver_t *driver, apr_dbd_t *handle,
                                int *nrows, const char *statement);
 
 /** apr_dbd_select: execute an SQL query that returns a result set
@@ -286,7 +286,7 @@ APU_DECLARE(int) apr_dbd_query(const apr_dbd_driver_t *driver, apr_dbd_t *handle
  *                    (async access - faster)
  *  @return 0 for success or error code
  */
-APU_DECLARE(int) apr_dbd_select(const apr_dbd_driver_t *driver, apr_pool_t *pool,
+APR_DECLARE(int) apr_dbd_select(const apr_dbd_driver_t *driver, apr_pool_t *pool,
                                 apr_dbd_t *handle, apr_dbd_results_t **res,
                                 const char *statement, int random);
 
@@ -296,7 +296,7 @@ APU_DECLARE(int) apr_dbd_select(const apr_dbd_driver_t *driver, apr_pool_t *pool
  *  @param res - result set.
  *  @return number of columns
  */
-APU_DECLARE(int) apr_dbd_num_cols(const apr_dbd_driver_t *driver,
+APR_DECLARE(int) apr_dbd_num_cols(const apr_dbd_driver_t *driver,
                                   apr_dbd_results_t *res);
 
 /** apr_dbd_num_tuples: get the number of rows in a results set
@@ -306,7 +306,7 @@ APU_DECLARE(int) apr_dbd_num_cols(const apr_dbd_driver_t *driver,
  *  @param res - result set.
  *  @return number of rows, or -1 if the results are asynchronous
  */
-APU_DECLARE(int) apr_dbd_num_tuples(const apr_dbd_driver_t *driver,
+APR_DECLARE(int) apr_dbd_num_tuples(const apr_dbd_driver_t *driver,
                                     apr_dbd_results_t *res);
 
 /** apr_dbd_get_row: get a row from a result set
@@ -319,7 +319,7 @@ APU_DECLARE(int) apr_dbd_num_tuples(const apr_dbd_driver_t *driver,
  *                  Ignored if random access is not supported.
  *  @return 0 for success, -1 for rownum out of range or data finished
  */
-APU_DECLARE(int) apr_dbd_get_row(const apr_dbd_driver_t *driver, apr_pool_t *pool,
+APR_DECLARE(int) apr_dbd_get_row(const apr_dbd_driver_t *driver, apr_pool_t *pool,
                                  apr_dbd_results_t *res, apr_dbd_row_t **row,
                                  int rownum);
 
@@ -330,7 +330,7 @@ APU_DECLARE(int) apr_dbd_get_row(const apr_dbd_driver_t *driver, apr_pool_t *poo
  *  @param col - entry number
  *  @return value from the row, or NULL if col is out of bounds.
  */
-APU_DECLARE(const char*) apr_dbd_get_entry(const apr_dbd_driver_t *driver,
+APR_DECLARE(const char*) apr_dbd_get_entry(const apr_dbd_driver_t *driver,
                                            apr_dbd_row_t *row, int col);
 
 /** apr_dbd_get_name: get an entry name from a result set
@@ -340,7 +340,7 @@ APU_DECLARE(const char*) apr_dbd_get_entry(const apr_dbd_driver_t *driver,
  *  @param col - entry number
  *  @return name of the entry, or NULL if col is out of bounds.
  */
-APU_DECLARE(const char*) apr_dbd_get_name(const apr_dbd_driver_t *driver,
+APR_DECLARE(const char*) apr_dbd_get_name(const apr_dbd_driver_t *driver,
                                           apr_dbd_results_t *res, int col);
 
 
@@ -352,7 +352,7 @@ APU_DECLARE(const char*) apr_dbd_get_name(const apr_dbd_driver_t *driver,
  *  @return the database current error message, or message for errnum
  *          (implementation-dependent whether errnum is ignored)
  */
-APU_DECLARE(const char*) apr_dbd_error(const apr_dbd_driver_t *driver,
+APR_DECLARE(const char*) apr_dbd_error(const apr_dbd_driver_t *driver,
                                        apr_dbd_t *handle, int errnum);
 
 /** apr_dbd_escape: escape a string so it is safe for use in query/select
@@ -363,7 +363,7 @@ APU_DECLARE(const char*) apr_dbd_error(const apr_dbd_driver_t *driver,
  *  @param handle - the connection
  *  @return the escaped, safe string
  */
-APU_DECLARE(const char*) apr_dbd_escape(const apr_dbd_driver_t *driver,
+APR_DECLARE(const char*) apr_dbd_escape(const apr_dbd_driver_t *driver,
                                         apr_pool_t *pool, const char *string,
                                         apr_dbd_t *handle);
 
@@ -395,7 +395,7 @@ APU_DECLARE(const char*) apr_dbd_escape(const apr_dbd_driver_t *driver,
  *  possible. A \% followed by any letter not in the above list will be
  *  interpreted as VARCHAR (i.e. \%s).
  */
-APU_DECLARE(int) apr_dbd_prepare(const apr_dbd_driver_t *driver, apr_pool_t *pool,
+APR_DECLARE(int) apr_dbd_prepare(const apr_dbd_driver_t *driver, apr_pool_t *pool,
                                  apr_dbd_t *handle, const char *query,
                                  const char *label,
                                  apr_dbd_prepared_t **statement);
@@ -412,7 +412,7 @@ APU_DECLARE(int) apr_dbd_prepare(const apr_dbd_driver_t *driver, apr_pool_t *poo
  *  @param args - args to prepared statement
  *  @return 0 for success or error code
  */
-APU_DECLARE(int) apr_dbd_pquery(const apr_dbd_driver_t *driver, apr_pool_t *pool,
+APR_DECLARE(int) apr_dbd_pquery(const apr_dbd_driver_t *driver, apr_pool_t *pool,
                                 apr_dbd_t *handle, int *nrows,
                                 apr_dbd_prepared_t *statement, int nargs,
                                 const char **args);
@@ -429,7 +429,7 @@ APU_DECLARE(int) apr_dbd_pquery(const apr_dbd_driver_t *driver, apr_pool_t *pool
  *  @param args - args to prepared statement
  *  @return 0 for success or error code
  */
-APU_DECLARE(int) apr_dbd_pselect(const apr_dbd_driver_t *driver, apr_pool_t *pool,
+APR_DECLARE(int) apr_dbd_pselect(const apr_dbd_driver_t *driver, apr_pool_t *pool,
                                  apr_dbd_t *handle, apr_dbd_results_t **res,
                                  apr_dbd_prepared_t *statement, int random,
                                  int nargs, const char **args);
@@ -444,7 +444,7 @@ APU_DECLARE(int) apr_dbd_pselect(const apr_dbd_driver_t *driver, apr_pool_t *poo
  *  @param ... - varargs list
  *  @return 0 for success or error code
  */
-APU_DECLARE_NONSTD(int) apr_dbd_pvquery(const apr_dbd_driver_t *driver, 
+APR_DECLARE_NONSTD(int) apr_dbd_pvquery(const apr_dbd_driver_t *driver, 
                                         apr_pool_t *pool,
                                         apr_dbd_t *handle, int *nrows,
                                         apr_dbd_prepared_t *statement, ...);
@@ -460,7 +460,7 @@ APU_DECLARE_NONSTD(int) apr_dbd_pvquery(const apr_dbd_driver_t *driver,
  *  @param ... - varargs list
  *  @return 0 for success or error code
  */
-APU_DECLARE_NONSTD(int) apr_dbd_pvselect(const apr_dbd_driver_t *driver,
+APR_DECLARE_NONSTD(int) apr_dbd_pvselect(const apr_dbd_driver_t *driver,
                                          apr_pool_t *pool, apr_dbd_t *handle,
                                          apr_dbd_results_t **res,
                                          apr_dbd_prepared_t *statement,
@@ -476,7 +476,7 @@ APU_DECLARE_NONSTD(int) apr_dbd_pvselect(const apr_dbd_driver_t *driver,
  *  @param args - binary args to prepared statement
  *  @return 0 for success or error code
  */
-APU_DECLARE(int) apr_dbd_pbquery(const apr_dbd_driver_t *driver,
+APR_DECLARE(int) apr_dbd_pbquery(const apr_dbd_driver_t *driver,
                                  apr_pool_t *pool, apr_dbd_t *handle,
                                  int *nrows, apr_dbd_prepared_t *statement,
                                  const void **args);
@@ -492,7 +492,7 @@ APU_DECLARE(int) apr_dbd_pbquery(const apr_dbd_driver_t *driver,
  *  @param args - binary args to prepared statement
  *  @return 0 for success or error code
  */
-APU_DECLARE(int) apr_dbd_pbselect(const apr_dbd_driver_t *driver,
+APR_DECLARE(int) apr_dbd_pbselect(const apr_dbd_driver_t *driver,
                                   apr_pool_t *pool,
                                   apr_dbd_t *handle, apr_dbd_results_t **res,
                                   apr_dbd_prepared_t *statement, int random,
@@ -508,7 +508,7 @@ APU_DECLARE(int) apr_dbd_pbselect(const apr_dbd_driver_t *driver,
  *  @param ... - varargs list of binary args
  *  @return 0 for success or error code
  */
-APU_DECLARE_NONSTD(int) apr_dbd_pvbquery(const apr_dbd_driver_t *driver,
+APR_DECLARE_NONSTD(int) apr_dbd_pvbquery(const apr_dbd_driver_t *driver,
                                          apr_pool_t *pool,
                                          apr_dbd_t *handle, int *nrows,
                                          apr_dbd_prepared_t *statement, ...);
@@ -524,7 +524,7 @@ APU_DECLARE_NONSTD(int) apr_dbd_pvbquery(const apr_dbd_driver_t *driver,
  *  @param ... - varargs list of binary args
  *  @return 0 for success or error code
  */
-APU_DECLARE_NONSTD(int) apr_dbd_pvbselect(const apr_dbd_driver_t *driver,
+APR_DECLARE_NONSTD(int) apr_dbd_pvbselect(const apr_dbd_driver_t *driver,
                                           apr_pool_t *pool, apr_dbd_t *handle,
                                           apr_dbd_results_t **res,
                                           apr_dbd_prepared_t *statement,
@@ -539,7 +539,7 @@ APU_DECLARE_NONSTD(int) apr_dbd_pvbselect(const apr_dbd_driver_t *driver,
  *  @param data - pointer to data, allocated by the caller
  *  @return APR_SUCCESS on success, APR_ENOENT if data is NULL or APR_EGENERAL
  */
-APU_DECLARE(apr_status_t) apr_dbd_datum_get(const apr_dbd_driver_t *driver,
+APR_DECLARE(apr_status_t) apr_dbd_datum_get(const apr_dbd_driver_t *driver,
                                             apr_dbd_row_t *row, int col,
                                             apr_dbd_type_e type, void *data);
 
diff --git a/include/apr_dbm.h b/include/apr_dbm.h
index ad1b4f391..47beef108 100644
--- a/include/apr_dbm.h
+++ b/include/apr_dbm.h
@@ -86,7 +86,7 @@ typedef struct
  * the correct case (lower case for all bundled providers)
  */
 
-APU_DECLARE(apr_status_t) apr_dbm_open_ex(apr_dbm_t **dbm, const char* type, 
+APR_DECLARE(apr_status_t) apr_dbm_open_ex(apr_dbm_t **dbm, const char* type, 
                                        const char *name, 
                                        apr_int32_t mode, apr_fileperms_t perm,
                                        apr_pool_t *cntxt);
@@ -108,7 +108,7 @@ APU_DECLARE(apr_status_t) apr_dbm_open_ex(apr_dbm_t **dbm, const char* type,
  * @remark The dbm name may not be a true file name, as many dbm packages
  * append suffixes for seperate data and index files.
  */
-APU_DECLARE(apr_status_t) apr_dbm_open(apr_dbm_t **dbm, const char *name, 
+APR_DECLARE(apr_status_t) apr_dbm_open(apr_dbm_t **dbm, const char *name, 
                                        apr_int32_t mode, apr_fileperms_t perm,
                                        apr_pool_t *cntxt);
 
@@ -116,7 +116,7 @@ APU_DECLARE(apr_status_t) apr_dbm_open(apr_dbm_t **dbm, const char *name,
  * Close a dbm file previously opened by apr_dbm_open
  * @param dbm The database to close
  */
-APU_DECLARE(void) apr_dbm_close(apr_dbm_t *dbm);
+APR_DECLARE(void) apr_dbm_close(apr_dbm_t *dbm);
 
 /**
  * Fetch a dbm record value by key
@@ -124,7 +124,7 @@ APU_DECLARE(void) apr_dbm_close(apr_dbm_t *dbm);
  * @param key The key datum to find this record
  * @param pvalue The value datum retrieved for this record
  */
-APU_DECLARE(apr_status_t) apr_dbm_fetch(apr_dbm_t *dbm, apr_datum_t key,
+APR_DECLARE(apr_status_t) apr_dbm_fetch(apr_dbm_t *dbm, apr_datum_t key,
                                         apr_datum_t *pvalue);
 /**
  * Store a dbm record value by key
@@ -132,7 +132,7 @@ APU_DECLARE(apr_status_t) apr_dbm_fetch(apr_dbm_t *dbm, apr_datum_t key,
  * @param key The key datum to store this record by
  * @param value The value datum to store in this record
  */
-APU_DECLARE(apr_status_t) apr_dbm_store(apr_dbm_t *dbm, apr_datum_t key, 
+APR_DECLARE(apr_status_t) apr_dbm_store(apr_dbm_t *dbm, apr_datum_t key, 
                                         apr_datum_t value);
 
 /**
@@ -141,35 +141,35 @@ APU_DECLARE(apr_status_t) apr_dbm_store(apr_dbm_t *dbm, apr_datum_t key,
  * @param key The key datum of the record to delete
  * @remark It is not an error to delete a non-existent record.
  */
-APU_DECLARE(apr_status_t) apr_dbm_delete(apr_dbm_t *dbm, apr_datum_t key);
+APR_DECLARE(apr_status_t) apr_dbm_delete(apr_dbm_t *dbm, apr_datum_t key);
 
 /**
  * Search for a key within the dbm
  * @param dbm The database 
  * @param key The datum describing a key to test
  */
-APU_DECLARE(int) apr_dbm_exists(apr_dbm_t *dbm, apr_datum_t key);
+APR_DECLARE(int) apr_dbm_exists(apr_dbm_t *dbm, apr_datum_t key);
 
 /**
  * Retrieve the first record key from a dbm
  * @param dbm The database 
  * @param pkey The key datum of the first record
  */
-APU_DECLARE(apr_status_t) apr_dbm_firstkey(apr_dbm_t *dbm, apr_datum_t *pkey);
+APR_DECLARE(apr_status_t) apr_dbm_firstkey(apr_dbm_t *dbm, apr_datum_t *pkey);
 
 /**
  * Retrieve the next record key from a dbm
  * @param dbm The database 
  * @param pkey The key datum of the next record
  */
-APU_DECLARE(apr_status_t) apr_dbm_nextkey(apr_dbm_t *dbm, apr_datum_t *pkey);
+APR_DECLARE(apr_status_t) apr_dbm_nextkey(apr_dbm_t *dbm, apr_datum_t *pkey);
 
 /**
  * Proactively toss any memory associated with the apr_datum_t.
  * @param dbm The database 
  * @param data The datum to free.
  */
-APU_DECLARE(void) apr_dbm_freedatum(apr_dbm_t *dbm, apr_datum_t data);
+APR_DECLARE(void) apr_dbm_freedatum(apr_dbm_t *dbm, apr_datum_t data);
 
 /**
  * Report more information when an apr_dbm function fails.
@@ -180,7 +180,7 @@ APU_DECLARE(void) apr_dbm_freedatum(apr_dbm_t *dbm, apr_datum_t data);
  * @param errbufsize The size of the provided buffer
  * @return The errbuf parameter, for convenience.
  */
-APU_DECLARE(char *) apr_dbm_geterror(apr_dbm_t *dbm, int *errcode,
+APR_DECLARE(char *) apr_dbm_geterror(apr_dbm_t *dbm, int *errcode,
                                      char *errbuf, apr_size_t errbufsize);
 /**
  * If the specified file/path were passed to apr_dbm_open(), return the
@@ -196,7 +196,7 @@ APU_DECLARE(char *) apr_dbm_geterror(apr_dbm_t *dbm, int *errcode,
  * @remark The dbm file(s) don't need to exist. This function only manipulates
  *      the pathnames.
  */
-APU_DECLARE(apr_status_t) apr_dbm_get_usednames_ex(apr_pool_t *pool,
+APR_DECLARE(apr_status_t) apr_dbm_get_usednames_ex(apr_pool_t *pool,
                                                    const char *type,
                                                    const char *pathname,
                                                    const char **used1,
@@ -214,7 +214,7 @@ APU_DECLARE(apr_status_t) apr_dbm_get_usednames_ex(apr_pool_t *pool,
  * @remark The dbm file(s) don't need to exist. This function only manipulates
  *      the pathnames.
  */
-APU_DECLARE(void) apr_dbm_get_usednames(apr_pool_t *pool,
+APR_DECLARE(void) apr_dbm_get_usednames(apr_pool_t *pool,
                                         const char *pathname,
                                         const char **used1,
                                         const char **used2);
diff --git a/include/apr_hooks.h b/include/apr_hooks.h
index 9f2a80751..614c2fe9a 100644
--- a/include/apr_hooks.h
+++ b/include/apr_hooks.h
@@ -247,30 +247,30 @@ link##_DECLARE(ret) ns##_run_##name args_decl \
 /**
  * The global pool used to allocate any memory needed by the hooks.
  */ 
-APU_DECLARE_DATA extern apr_pool_t *apr_hook_global_pool;
+APR_DECLARE_DATA extern apr_pool_t *apr_hook_global_pool;
 
 /**
  * A global variable to determine if debugging information about the
  * hooks functions should be printed
  */ 
-APU_DECLARE_DATA extern int apr_hook_debug_enabled;
+APR_DECLARE_DATA extern int apr_hook_debug_enabled;
 
 /**
  * The name of the module that is currently registering a function
  */ 
-APU_DECLARE_DATA extern const char *apr_hook_debug_current;
+APR_DECLARE_DATA extern const char *apr_hook_debug_current;
 
 /**
  * Register a hook function to be sorted
  * @param szHookName The name of the Hook the function is registered for
  * @param aHooks The array which stores all of the functions for this hook
  */
-APU_DECLARE(void) apr_hook_sort_register(const char *szHookName, 
+APR_DECLARE(void) apr_hook_sort_register(const char *szHookName, 
                                         apr_array_header_t **aHooks);
 /**
  * Sort all of the registerd functions for a given hook
  */
-APU_DECLARE(void) apr_hook_sort_all(void);
+APR_DECLARE(void) apr_hook_sort_all(void);
 
 /**
  * Print all of the information about the current hook.  This is used for
@@ -279,14 +279,14 @@ APU_DECLARE(void) apr_hook_sort_all(void);
  * @param aszPre All of the functions in the predecessor array
  * @param aszSucc All of the functions in the successor array
  */
-APU_DECLARE(void) apr_hook_debug_show(const char *szName,
+APR_DECLARE(void) apr_hook_debug_show(const char *szName,
                                       const char * const *aszPre,
                                       const char * const *aszSucc);
 
 /**
  * Remove all currently registered functions.
  */
-APU_DECLARE(void) apr_hook_deregister_all(void);
+APR_DECLARE(void) apr_hook_deregister_all(void);
 
 /** @} */
 #ifdef __cplusplus
diff --git a/include/apr_ldap.h.in b/include/apr_ldap.h.in
index 6087783d8..baed01072 100644
--- a/include/apr_ldap.h.in
+++ b/include/apr_ldap.h.in
@@ -182,9 +182,9 @@ typedef struct apr_ldap_err_t {
 #define apr_ldap_rebind_add apr__ldap_rebind_add
 #define apr_ldap_rebind_remove apr__ldap_rebind_remove
 
-#define APU_DECLARE_LDAP(type) type
+#define APR_DECLARE_LDAP(type) type
 #else
-#define APU_DECLARE_LDAP(type) APU_DECLARE(type)
+#define APR_DECLARE_LDAP(type) APR_DECLARE(type)
 #endif
 
 #include "apr_ldap_url.h"
diff --git a/include/apr_ldap.hnw b/include/apr_ldap.hnw
index c93014ae6..0b5663cfd 100644
--- a/include/apr_ldap.hnw
+++ b/include/apr_ldap.hnw
@@ -142,9 +142,9 @@ typedef struct apr_ldap_err_t {
 #define apr_ldap_rebind_add apr__ldap_rebind_add
 #define apr_ldap_rebind_remove apr__ldap_rebind_remove
 
-#define APU_DECLARE_LDAP(type) type
+#define APR_DECLARE_LDAP(type) type
 #else
-#define APU_DECLARE_LDAP(type) APU_DECLARE(type)
+#define APR_DECLARE_LDAP(type) APR_DECLARE(type)
 #endif
 
 #include "apr_ldap_url.h"
diff --git a/include/apr_ldap.hw b/include/apr_ldap.hw
index c1bd0d4b6..2103c260c 100644
--- a/include/apr_ldap.hw
+++ b/include/apr_ldap.hw
@@ -182,9 +182,9 @@ typedef struct apr_ldap_err_t {
 #define apr_ldap_rebind_add apr__ldap_rebind_add
 #define apr_ldap_rebind_remove apr__ldap_rebind_remove
 
-#define APU_DECLARE_LDAP(type) type
+#define APR_DECLARE_LDAP(type) type
 #else
-#define APU_DECLARE_LDAP(type) APU_DECLARE(type)
+#define APR_DECLARE_LDAP(type) APR_DECLARE(type)
 #endif
 
 #include "apr_ldap_url.h"
diff --git a/include/apr_ldap_init.h b/include/apr_ldap_init.h
index aeb6d9bb1..0dd66747c 100644
--- a/include/apr_ldap_init.h
+++ b/include/apr_ldap_init.h
@@ -86,7 +86,7 @@ extern "C" {
  * apr_ldap_set_option() APR_LDAP_OPT_TLS_CERT option for details.
  * @param result_err The returned result
  */
-APU_DECLARE_LDAP(int) apr_ldap_ssl_init(apr_pool_t *pool,
+APR_DECLARE_LDAP(int) apr_ldap_ssl_init(apr_pool_t *pool,
                                         const char *cert_auth_file,
                                         int cert_file_type,
                                         apr_ldap_err_t **result_err);
@@ -100,7 +100,7 @@ APU_DECLARE_LDAP(int) apr_ldap_ssl_init(apr_pool_t *pool,
  * @todo currently we do not check whether apr_ldap_ssl_init()
  * has been called first - we probably should.
  */
-APU_DECLARE_LDAP(int) apr_ldap_ssl_deinit(void);
+APR_DECLARE_LDAP(int) apr_ldap_ssl_deinit(void);
 
 /**
  * APR LDAP initialise function
@@ -136,7 +136,7 @@ APU_DECLARE_LDAP(int) apr_ldap_ssl_deinit(void);
  * @param secure The security mode to set
  * @param result_err The returned result
  */
-APU_DECLARE_LDAP(int) apr_ldap_init(apr_pool_t *pool,
+APR_DECLARE_LDAP(int) apr_ldap_init(apr_pool_t *pool,
                                     LDAP **ldap,
                                     const char *hostname,
                                     int portno,
@@ -151,7 +151,7 @@ APU_DECLARE_LDAP(int) apr_ldap_init(apr_pool_t *pool,
  * @param pool The pool to use
  * @param result_err The returned result
  */
-APU_DECLARE_LDAP(int) apr_ldap_info(apr_pool_t *pool,
+APR_DECLARE_LDAP(int) apr_ldap_info(apr_pool_t *pool,
                                     apr_ldap_err_t **result_err);
 
 #ifdef __cplusplus
diff --git a/include/apr_ldap_option.h b/include/apr_ldap_option.h
index 0ff8a8622..e4ebdb506 100644
--- a/include/apr_ldap_option.h
+++ b/include/apr_ldap_option.h
@@ -214,7 +214,7 @@ struct apr_ldap_opt_tls_cert_t {
  * @param result_err The apr_ldap_err_t structure contained detailed results
  *        of the operation.
  */
-APU_DECLARE_LDAP(int) apr_ldap_get_option(apr_pool_t *pool,
+APR_DECLARE_LDAP(int) apr_ldap_get_option(apr_pool_t *pool,
                                           LDAP *ldap,
                                           int option,
                                           void *outvalue,
@@ -236,7 +236,7 @@ APU_DECLARE_LDAP(int) apr_ldap_get_option(apr_pool_t *pool,
  * @param result_err The apr_ldap_err_t structure contained detailed results
  *        of the operation.
  */
-APU_DECLARE_LDAP(int) apr_ldap_set_option(apr_pool_t *pool,
+APR_DECLARE_LDAP(int) apr_ldap_set_option(apr_pool_t *pool,
                                           LDAP *ldap,
                                           int option,
                                           const void *invalue,
diff --git a/include/apr_ldap_rebind.h b/include/apr_ldap_rebind.h
index 342a17c38..bdd5b3af6 100644
--- a/include/apr_ldap_rebind.h
+++ b/include/apr_ldap_rebind.h
@@ -48,7 +48,7 @@
  * This function creates the lock for controlling access to the xref list..
  * @param pool Pool to use when creating the xref_lock.
  */
-APU_DECLARE_LDAP(apr_status_t) apr_ldap_rebind_init(apr_pool_t *pool);
+APR_DECLARE_LDAP(apr_status_t) apr_ldap_rebind_init(apr_pool_t *pool);
 
 
 /**
@@ -72,7 +72,7 @@ APU_DECLARE_LDAP(apr_status_t) apr_ldap_rebind_init(apr_pool_t *pool);
  * @param bindPW The bind Password to be used for any binds while 
  *               chasing referrals on this ldap connection.
  */
-APU_DECLARE_LDAP(apr_status_t) apr_ldap_rebind_add(apr_pool_t *pool,
+APR_DECLARE_LDAP(apr_status_t) apr_ldap_rebind_add(apr_pool_t *pool,
                                                    LDAP *ld,
                                                    const char *bindDN,
                                                    const char *bindPW);
@@ -88,7 +88,7 @@ APU_DECLARE_LDAP(apr_status_t) apr_ldap_rebind_add(apr_pool_t *pool,
  *
  * @param ld The LDAP connectionhandle
  */
-APU_DECLARE_LDAP(apr_status_t) apr_ldap_rebind_remove(LDAP *ld);
+APR_DECLARE_LDAP(apr_status_t) apr_ldap_rebind_remove(LDAP *ld);
 
 #endif /* APR_HAS_LDAP */
 
diff --git a/include/apr_ldap_url.h b/include/apr_ldap_url.h
index a71f5b3cb..77543ef82 100644
--- a/include/apr_ldap_url.h
+++ b/include/apr_ldap_url.h
@@ -71,19 +71,19 @@ typedef struct apr_ldap_url_desc_t {
  * Is this URL an ldap url? ldap://
  * @param url The url to test
  */
-APU_DECLARE(int) apr_ldap_is_ldap_url(const char *url);
+APR_DECLARE(int) apr_ldap_is_ldap_url(const char *url);
 
 /**
  * Is this URL an SSL ldap url? ldaps://
  * @param url The url to test
  */
-APU_DECLARE(int) apr_ldap_is_ldaps_url(const char *url);
+APR_DECLARE(int) apr_ldap_is_ldaps_url(const char *url);
 
 /**
  * Is this URL an ldap socket url? ldapi://
  * @param url The url to test
  */
-APU_DECLARE(int) apr_ldap_is_ldapi_url(const char *url);
+APR_DECLARE(int) apr_ldap_is_ldapi_url(const char *url);
 
 /**
  * Parse an LDAP URL.
@@ -92,7 +92,7 @@ APU_DECLARE(int) apr_ldap_is_ldapi_url(const char *url);
  * @param ludpp The structure to return the exploded URL
  * @param result_err The result structure of the operation
  */
-APU_DECLARE(int) apr_ldap_url_parse_ext(apr_pool_t *pool,
+APR_DECLARE(int) apr_ldap_url_parse_ext(apr_pool_t *pool,
                                         const char *url_in,
                                         apr_ldap_url_desc_t **ludpp,
                                         apr_ldap_err_t **result_err);
@@ -104,7 +104,7 @@ APU_DECLARE(int) apr_ldap_url_parse_ext(apr_pool_t *pool,
  * @param ludpp The structure to return the exploded URL
  * @param result_err The result structure of the operation
  */
-APU_DECLARE(int) apr_ldap_url_parse(apr_pool_t *pool,
+APR_DECLARE(int) apr_ldap_url_parse(apr_pool_t *pool,
                                     const char *url_in,
                                     apr_ldap_url_desc_t **ludpp,
                                     apr_ldap_err_t **result_err);
diff --git a/include/apr_md4.h b/include/apr_md4.h
index 43fb33e30..f6bcfc2c4 100644
--- a/include/apr_md4.h
+++ b/include/apr_md4.h
@@ -81,7 +81,7 @@ struct apr_md4_ctx_t {
  * MD4 Initialize.  Begins an MD4 operation, writing a new context.
  * @param context The MD4 context to initialize.
  */
-APU_DECLARE(apr_status_t) apr_md4_init(apr_md4_ctx_t *context);
+APR_DECLARE(apr_status_t) apr_md4_init(apr_md4_ctx_t *context);
 
 #if APR_HAS_XLATE
 /**
@@ -90,7 +90,7 @@ APU_DECLARE(apr_status_t) apr_md4_init(apr_md4_ctx_t *context);
  * @param context The MD4 content to set the translation for.
  * @param xlate The translation handle to use for this MD4 context 
  */
-APU_DECLARE(apr_status_t) apr_md4_set_xlate(apr_md4_ctx_t *context,
+APR_DECLARE(apr_status_t) apr_md4_set_xlate(apr_md4_ctx_t *context,
                                             apr_xlate_t *xlate);
 #else
 #define apr_md4_set_xlate(context, xlate) APR_ENOTIMPL
@@ -103,7 +103,7 @@ APU_DECLARE(apr_status_t) apr_md4_set_xlate(apr_md4_ctx_t *context,
  * @param input next message block to update
  * @param inputLen The length of the next message block
  */
-APU_DECLARE(apr_status_t) apr_md4_update(apr_md4_ctx_t *context,
+APR_DECLARE(apr_status_t) apr_md4_update(apr_md4_ctx_t *context,
                                          const unsigned char *input,
                                          apr_size_t inputLen);
 
@@ -113,7 +113,7 @@ APU_DECLARE(apr_status_t) apr_md4_update(apr_md4_ctx_t *context,
  * @param digest The final MD4 digest
  * @param context The MD4 content we are finalizing.
  */
-APU_DECLARE(apr_status_t) apr_md4_final(
+APR_DECLARE(apr_status_t) apr_md4_final(
                                     unsigned char digest[APR_MD4_DIGESTSIZE],
                                     apr_md4_ctx_t *context);
 
@@ -123,7 +123,7 @@ APU_DECLARE(apr_status_t) apr_md4_final(
  * @param input message block to use
  * @param inputLen The length of the message block
  */
-APU_DECLARE(apr_status_t) apr_md4(unsigned char digest[APR_MD4_DIGESTSIZE],
+APR_DECLARE(apr_status_t) apr_md4(unsigned char digest[APR_MD4_DIGESTSIZE],
                                   const unsigned char *input,
                                   apr_size_t inputLen);
 
diff --git a/include/apr_md5.h b/include/apr_md5.h
index 367324a76..68bd30ead 100644
--- a/include/apr_md5.h
+++ b/include/apr_md5.h
@@ -88,7 +88,7 @@ struct apr_md5_ctx_t {
  * MD5 Initialize.  Begins an MD5 operation, writing a new context.
  * @param context The MD5 context to initialize.
  */
-APU_DECLARE(apr_status_t) apr_md5_init(apr_md5_ctx_t *context);
+APR_DECLARE(apr_status_t) apr_md5_init(apr_md5_ctx_t *context);
 
 /**
  * MD5 translation setup.  Provides the APR translation handle to be used 
@@ -96,7 +96,7 @@ APU_DECLARE(apr_status_t) apr_md5_init(apr_md5_ctx_t *context);
  * @param context The MD5 content to set the translation for.
  * @param xlate The translation handle to use for this MD5 context 
  */
-APU_DECLARE(apr_status_t) apr_md5_set_xlate(apr_md5_ctx_t *context,
+APR_DECLARE(apr_status_t) apr_md5_set_xlate(apr_md5_ctx_t *context,
                                             apr_xlate_t *xlate);
 
 /**
@@ -106,7 +106,7 @@ APU_DECLARE(apr_status_t) apr_md5_set_xlate(apr_md5_ctx_t *context,
  * @param input next message block to update
  * @param inputLen The length of the next message block
  */
-APU_DECLARE(apr_status_t) apr_md5_update(apr_md5_ctx_t *context,
+APR_DECLARE(apr_status_t) apr_md5_update(apr_md5_ctx_t *context,
                                          const void *input,
                                          apr_size_t inputLen);
 
@@ -116,7 +116,7 @@ APU_DECLARE(apr_status_t) apr_md5_update(apr_md5_ctx_t *context,
  * @param digest The final MD5 digest
  * @param context The MD5 content we are finalizing.
  */
-APU_DECLARE(apr_status_t) apr_md5_final(unsigned char digest[APR_MD5_DIGESTSIZE],
+APR_DECLARE(apr_status_t) apr_md5_final(unsigned char digest[APR_MD5_DIGESTSIZE],
                                         apr_md5_ctx_t *context);
 
 /**
@@ -125,7 +125,7 @@ APU_DECLARE(apr_status_t) apr_md5_final(unsigned char digest[APR_MD5_DIGESTSIZE]
  * @param input The message block to use
  * @param inputLen The length of the message block
  */
-APU_DECLARE(apr_status_t) apr_md5(unsigned char digest[APR_MD5_DIGESTSIZE],
+APR_DECLARE(apr_status_t) apr_md5(unsigned char digest[APR_MD5_DIGESTSIZE],
                                   const void *input,
                                   apr_size_t inputLen);
 
@@ -136,7 +136,7 @@ APU_DECLARE(apr_status_t) apr_md5(unsigned char digest[APR_MD5_DIGESTSIZE],
  * @param result The string to store the encoded password in
  * @param nbytes The size of the result buffer
  */
-APU_DECLARE(apr_status_t) apr_md5_encode(const char *password, const char *salt,
+APR_DECLARE(apr_status_t) apr_md5_encode(const char *password, const char *salt,
                                          char *result, apr_size_t nbytes);
 
 
@@ -150,7 +150,7 @@ APU_DECLARE(apr_status_t) apr_md5_encode(const char *password, const char *salt,
  * @param passwd The password to validate
  * @param hash The password to validate against
  */
-APU_DECLARE(apr_status_t) apr_password_validate(const char *passwd, 
+APR_DECLARE(apr_status_t) apr_password_validate(const char *passwd, 
                                                 const char *hash);
 
 
diff --git a/include/apr_memcache.h b/include/apr_memcache.h
index 85287be86..cc459ac90 100644
--- a/include/apr_memcache.h
+++ b/include/apr_memcache.h
@@ -125,21 +125,21 @@ typedef struct
  * @return crc32 hash of data
  * @remark The crc32 hash is not compatible with old memcached clients.
  */
-APU_DECLARE(apr_uint32_t) apr_memcache_hash(apr_memcache_t *mc,
+APR_DECLARE(apr_uint32_t) apr_memcache_hash(apr_memcache_t *mc,
                                             const char *data,
                                             const apr_size_t data_len);
 
 /**
  * Pure CRC32 Hash. Used by some clients.
  */
-APU_DECLARE(apr_uint32_t) apr_memcache_hash_crc32(void *baton,
+APR_DECLARE(apr_uint32_t) apr_memcache_hash_crc32(void *baton,
                                                   const char *data,
                                                   const apr_size_t data_len);
 
 /**
  * hash compatible with the standard Perl Client.
  */
-APU_DECLARE(apr_uint32_t) apr_memcache_hash_default(void *baton,
+APR_DECLARE(apr_uint32_t) apr_memcache_hash_default(void *baton,
                                                     const char *data,
                                                     const apr_size_t data_len);
 
@@ -150,13 +150,13 @@ APU_DECLARE(apr_uint32_t) apr_memcache_hash_default(void *baton,
  * @return server that controls specified hash
  * @see apr_memcache_hash
  */
-APU_DECLARE(apr_memcache_server_t *) apr_memcache_find_server_hash(apr_memcache_t *mc, 
+APR_DECLARE(apr_memcache_server_t *) apr_memcache_find_server_hash(apr_memcache_t *mc, 
                                                                    const apr_uint32_t hash);
 
 /**
  * server selection compatible with the standard Perl Client.
  */
-APU_DECLARE(apr_memcache_server_t *)
+APR_DECLARE(apr_memcache_server_t *)
 apr_memcache_find_server_hash_default(void *baton,
                                       apr_memcache_t *mc, 
                                       const apr_uint32_t hash);
@@ -169,7 +169,7 @@ apr_memcache_find_server_hash_default(void *baton,
  * @warning Changing servers after startup may cause keys to go to
  * different servers.
  */
-APU_DECLARE(apr_status_t) apr_memcache_add_server(apr_memcache_t *mc,
+APR_DECLARE(apr_status_t) apr_memcache_add_server(apr_memcache_t *mc,
                                                   apr_memcache_server_t *server);
 
 
@@ -180,7 +180,7 @@ APU_DECLARE(apr_status_t) apr_memcache_add_server(apr_memcache_t *mc,
  * @param port Port of the server
  * @return Server with matching Hostname and Port, or NULL if none was found.
  */
-APU_DECLARE(apr_memcache_server_t *) apr_memcache_find_server(apr_memcache_t *mc,
+APR_DECLARE(apr_memcache_server_t *) apr_memcache_find_server(apr_memcache_t *mc,
                                                               const char *host,
                                                               apr_port_t port);
 
@@ -189,7 +189,7 @@ APU_DECLARE(apr_memcache_server_t *) apr_memcache_find_server(apr_memcache_t *mc
  * @param mc The memcache client object to use
  * @param ms Server to Activate
  */
-APU_DECLARE(apr_status_t) apr_memcache_enable_server(apr_memcache_t *mc,
+APR_DECLARE(apr_status_t) apr_memcache_enable_server(apr_memcache_t *mc,
                                                      apr_memcache_server_t *ms);
 
 
@@ -198,7 +198,7 @@ APU_DECLARE(apr_status_t) apr_memcache_enable_server(apr_memcache_t *mc,
  * @param mc The memcache client object to use
  * @param ms Server to Disable
  */
-APU_DECLARE(apr_status_t) apr_memcache_disable_server(apr_memcache_t *mc,
+APR_DECLARE(apr_status_t) apr_memcache_disable_server(apr_memcache_t *mc,
                                                       apr_memcache_server_t *ms);
 
 /**
@@ -214,7 +214,7 @@ APU_DECLARE(apr_status_t) apr_memcache_disable_server(apr_memcache_t *mc,
  * @see apr_reslist_create
  * @remark min, smax, and max are only used when APR_HAS_THREADS
  */
-APU_DECLARE(apr_status_t) apr_memcache_server_create(apr_pool_t *p,
+APR_DECLARE(apr_status_t) apr_memcache_server_create(apr_pool_t *p,
                                                      const char *host,
                                                      apr_port_t port,
                                                      apr_uint32_t min,
@@ -229,7 +229,7 @@ APU_DECLARE(apr_status_t) apr_memcache_server_create(apr_pool_t *p,
  * @param flags Not currently used
  * @param mc   location of the new memcache client object
  */
-APU_DECLARE(apr_status_t) apr_memcache_create(apr_pool_t *p,
+APR_DECLARE(apr_status_t) apr_memcache_create(apr_pool_t *p,
                                               apr_uint16_t max_servers,
                                               apr_uint32_t flags,
                                               apr_memcache_t **mc);
@@ -244,7 +244,7 @@ APU_DECLARE(apr_status_t) apr_memcache_create(apr_pool_t *p,
  * @param flags any flags set by the client for this key
  * @return 
  */
-APU_DECLARE(apr_status_t) apr_memcache_getp(apr_memcache_t *mc, 
+APR_DECLARE(apr_status_t) apr_memcache_getp(apr_memcache_t *mc, 
                                             apr_pool_t *p,
                                             const char* key,
                                             char **baton,
@@ -260,7 +260,7 @@ APU_DECLARE(apr_status_t) apr_memcache_getp(apr_memcache_t *mc,
  * @param values hash of keys and values that this key will be added to
  * @return
  */
-APU_DECLARE(void) apr_memcache_add_multget_key(apr_pool_t *data_pool,
+APR_DECLARE(void) apr_memcache_add_multget_key(apr_pool_t *data_pool,
                                                const char* key,
                                                apr_hash_t **values);
 
@@ -274,7 +274,7 @@ APU_DECLARE(void) apr_memcache_add_multget_key(apr_pool_t *data_pool,
  *        result of the multiget call.
  * @return
  */
-APU_DECLARE(apr_status_t) apr_memcache_multgetp(apr_memcache_t *mc,
+APR_DECLARE(apr_status_t) apr_memcache_multgetp(apr_memcache_t *mc,
                                                 apr_pool_t *temp_pool,
                                                 apr_pool_t *data_pool,
                                                 apr_hash_t *values);
@@ -288,7 +288,7 @@ APU_DECLARE(apr_status_t) apr_memcache_multgetp(apr_memcache_t *mc,
  * @param timeout time in seconds for the data to live on the server
  * @param flags any flags set by the client for this key
  */
-APU_DECLARE(apr_status_t) apr_memcache_set(apr_memcache_t *mc,
+APR_DECLARE(apr_status_t) apr_memcache_set(apr_memcache_t *mc,
                                            const char *key,
                                            char *baton,
                                            const apr_size_t data_size,
@@ -306,7 +306,7 @@ APU_DECLARE(apr_status_t) apr_memcache_set(apr_memcache_t *mc,
  * @return APR_SUCCESS if the key was added, APR_EEXIST if the key 
  * already exists on the server.
  */
-APU_DECLARE(apr_status_t) apr_memcache_add(apr_memcache_t *mc,
+APR_DECLARE(apr_status_t) apr_memcache_add(apr_memcache_t *mc,
                                            const char *key,
                                            char *baton,
                                            const apr_size_t data_size,
@@ -324,7 +324,7 @@ APU_DECLARE(apr_status_t) apr_memcache_add(apr_memcache_t *mc,
  * @return APR_SUCCESS if the key was added, APR_EEXIST if the key 
  * did not exist on the server.
  */
-APU_DECLARE(apr_status_t) apr_memcache_replace(apr_memcache_t *mc,
+APR_DECLARE(apr_status_t) apr_memcache_replace(apr_memcache_t *mc,
                                                const char *key,
                                                char *data,
                                                const apr_size_t data_size,
@@ -336,7 +336,7 @@ APU_DECLARE(apr_status_t) apr_memcache_replace(apr_memcache_t *mc,
  * @param key   null terminated string containing the key
  * @param timeout time for the delete to stop other clients from adding
  */
-APU_DECLARE(apr_status_t) apr_memcache_delete(apr_memcache_t *mc,
+APR_DECLARE(apr_status_t) apr_memcache_delete(apr_memcache_t *mc,
                                               const char *key,
                                               apr_uint32_t timeout);
 
@@ -347,7 +347,7 @@ APU_DECLARE(apr_status_t) apr_memcache_delete(apr_memcache_t *mc,
  * @param n     number to increment by
  * @param nv    new value after incrmenting
  */
-APU_DECLARE(apr_status_t) apr_memcache_incr(apr_memcache_t *mc, 
+APR_DECLARE(apr_status_t) apr_memcache_incr(apr_memcache_t *mc, 
                                             const char *key,
                                             apr_int32_t n,
                                             apr_uint32_t *nv);
@@ -359,7 +359,7 @@ APU_DECLARE(apr_status_t) apr_memcache_incr(apr_memcache_t *mc,
  * @param n     number to decrement by
  * @param nv    new value after decrementing
  */
-APU_DECLARE(apr_status_t) apr_memcache_decr(apr_memcache_t *mc, 
+APR_DECLARE(apr_status_t) apr_memcache_decr(apr_memcache_t *mc, 
                                             const char *key,
                                             apr_int32_t n,
                                             apr_uint32_t *new_value);
@@ -371,7 +371,7 @@ APU_DECLARE(apr_status_t) apr_memcache_decr(apr_memcache_t *mc,
  * @param baton location to store server version string
  * @param len   length of the server version string
  */
-APU_DECLARE(apr_status_t) apr_memcache_version(apr_memcache_server_t *ms,
+APR_DECLARE(apr_status_t) apr_memcache_version(apr_memcache_server_t *ms,
                                                apr_pool_t *p,
                                                char **baton);
 
@@ -430,7 +430,7 @@ typedef struct
  * @param p     Pool to allocate answer from
  * @param stats location of the new statistics structure
  */
-APU_DECLARE(apr_status_t) apr_memcache_stats(apr_memcache_server_t *ms, 
+APR_DECLARE(apr_status_t) apr_memcache_stats(apr_memcache_server_t *ms, 
                                              apr_pool_t *p,
                                              apr_memcache_stats_t **stats);
 
diff --git a/include/apr_optional.h b/include/apr_optional.h
index 3301d66e6..4f2a40f86 100644
--- a/include/apr_optional.h
+++ b/include/apr_optional.h
@@ -58,7 +58,7 @@ typedef ret (APR_OPTIONAL_FN_TYPE(name)) args
 
 typedef void (apr_opt_fn_t)(void);
 /** @internal */
-APU_DECLARE_NONSTD(void) apr_dynamic_fn_register(const char *szName, 
+APR_DECLARE_NONSTD(void) apr_dynamic_fn_register(const char *szName, 
                                                   apr_opt_fn_t *pfn);
 
 /**
@@ -75,7 +75,7 @@ APU_DECLARE_NONSTD(void) apr_dynamic_fn_register(const char *szName,
 /** @internal
  * Private function! DO NOT USE! 
  */
-APU_DECLARE(apr_opt_fn_t *) apr_dynamic_fn_retrieve(const char *szName);
+APR_DECLARE(apr_opt_fn_t *) apr_dynamic_fn_retrieve(const char *szName);
 
 /**
  * Retrieve an optional function. Returns NULL if the function is not present.
diff --git a/include/apr_optional_hooks.h b/include/apr_optional_hooks.h
index 54bf65eff..1e3801a8e 100644
--- a/include/apr_optional_hooks.h
+++ b/include/apr_optional_hooks.h
@@ -45,7 +45,7 @@ extern "C" {
  */
 
 
-APU_DECLARE(void) apr_optional_hook_add(const char *szName,void (*pfn)(void),
+APR_DECLARE(void) apr_optional_hook_add(const char *szName,void (*pfn)(void),
 					const char * const *aszPre,
 					const char * const *aszSucc,
 					int nOrder);
@@ -71,7 +71,7 @@ APU_DECLARE(void) apr_optional_hook_add(const char *szName,void (*pfn)(void),
  * @param szName - the name of the function
  * @return the hook structure for a given hook
  */
-APU_DECLARE(apr_array_header_t *) apr_optional_hook_get(const char *szName);
+APR_DECLARE(apr_array_header_t *) apr_optional_hook_get(const char *szName);
 
 /**
  * Implement an optional hook that runs until one of the functions
diff --git a/include/apr_queue.h b/include/apr_queue.h
index bf5df74d9..58a2e71fe 100644
--- a/include/apr_queue.h
+++ b/include/apr_queue.h
@@ -52,7 +52,7 @@ typedef struct apr_queue_t apr_queue_t;
  * @param queue_capacity maximum size of the queue
  * @param a pool to allocate queue from
  */
-APU_DECLARE(apr_status_t) apr_queue_create(apr_queue_t **queue, 
+APR_DECLARE(apr_status_t) apr_queue_create(apr_queue_t **queue, 
                                            unsigned int queue_capacity, 
                                            apr_pool_t *a);
 
@@ -65,7 +65,7 @@ APU_DECLARE(apr_status_t) apr_queue_create(apr_queue_t **queue,
  * @returns APR_EOF the queue has been terminated
  * @returns APR_SUCCESS on a successful push
  */
-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);
 
 /**
  * pop/get an object from the queue, blocking if the queue is already empty
@@ -76,7 +76,7 @@ APU_DECLARE(apr_status_t) apr_queue_push(apr_queue_t *queue, void *data);
  * @returns APR_EOF if the queue has been terminated
  * @returns APR_SUCCESS on a successful pop
  */
-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);
 
 /**
  * push/add an object to the queue, returning immediately if the queue is full
@@ -88,7 +88,7 @@ APU_DECLARE(apr_status_t) apr_queue_pop(apr_queue_t *queue, void **data);
  * @returns APR_EOF the queue has been terminated
  * @returns APR_SUCCESS on a successful push
  */
-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);
 
 /**
  * pop/get an object to the queue, returning immediately if the queue is empty
@@ -100,7 +100,7 @@ APU_DECLARE(apr_status_t) apr_queue_trypush(apr_queue_t *queue, void *data);
  * @returns APR_EOF the queue has been terminated
  * @returns APR_SUCCESS on a successful push
  */
-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);
 
 /**
  * returns the size of the queue.
@@ -110,14 +110,14 @@ APU_DECLARE(apr_status_t) apr_queue_trypop(apr_queue_t *queue, void **data);
  * @param queue the queue
  * @returns the size of the queue
  */
-APU_DECLARE(unsigned int) apr_queue_size(apr_queue_t *queue);
+APR_DECLARE(unsigned int) apr_queue_size(apr_queue_t *queue);
 
 /**
  * interrupt all the threads blocking on this queue.
  *
  * @param queue the queue
  */
-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);
 
 /**
  * terminate the queue, sending an interrupt to all the
@@ -125,7 +125,7 @@ APU_DECLARE(apr_status_t) apr_queue_interrupt_all(apr_queue_t *queue);
  *
  * @param queue the queue
  */
-APU_DECLARE(apr_status_t) apr_queue_term(apr_queue_t *queue);
+APR_DECLARE(apr_status_t) apr_queue_term(apr_queue_t *queue);
 
 #ifdef __cplusplus
 }
diff --git a/include/apr_reslist.h b/include/apr_reslist.h
index 72349ff09..895776925 100644
--- a/include/apr_reslist.h
+++ b/include/apr_reslist.h
@@ -84,7 +84,7 @@ typedef apr_status_t (*apr_reslist_destructor)(void *resource, void *params,
  *         automatically set to 1 and values of min and smax will be forced to
  *         1 for any non-zero value.
  */
-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,
@@ -103,20 +103,20 @@ APU_DECLARE(apr_status_t) apr_reslist_create(apr_reslist_t **reslist,
  *        have been released to the list before calling this function.
  * @param reslist The reslist to destroy
  */
-APU_DECLARE(apr_status_t) apr_reslist_destroy(apr_reslist_t *reslist);
+APR_DECLARE(apr_status_t) apr_reslist_destroy(apr_reslist_t *reslist);
 
 /**
  * Retrieve a resource from the list, creating a new one if necessary.
  * If we have met our maximum number of resources, we will block
  * until one becomes available.
  */
-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);
 
 /**
  * Return a resource back to the list of available resources.
  */
-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);
 
 /**
@@ -125,21 +125,21 @@ APU_DECLARE(apr_status_t) apr_reslist_release(apr_reslist_t *reslist,
  * @param reslist The resource list.
  * @param timeout Timeout to wait. The zero waits forever.
  */
-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);
 
 /**
  * Return the number of outstanding resources.
  * @param reslist The resource list.
  */
-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);
 
 /**
  * Invalidate a resource in the pool - e.g. a database connection
  * that returns a "lost connection" error and can't be restored.
  * Use this instead of apr_reslist_release if the resource is bad.
  */
-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);
 
 /**
@@ -147,7 +147,7 @@ APU_DECLARE(apr_status_t) apr_reslist_invalidate(apr_reslist_t *reslist,
  * may instantiate new resources or expire old resources.
  * @param reslist The resource list.
  */
-APU_DECLARE(apr_status_t) apr_reslist_maintain(apr_reslist_t *reslist);
+APR_DECLARE(apr_status_t) apr_reslist_maintain(apr_reslist_t *reslist);
 
 /**
  * Set reslist cleanup order.
@@ -162,7 +162,7 @@ APU_DECLARE(apr_status_t) apr_reslist_maintain(apr_reslist_t *reslist);
  * are destroyed. This allows to explicitly destroy the child pools
  * inside reslist destructors.
  */
-APU_DECLARE(void) apr_reslist_cleanup_order_set(apr_reslist_t *reslist,
+APR_DECLARE(void) apr_reslist_cleanup_order_set(apr_reslist_t *reslist,
                                                 apr_uint32_t mode);
 
 #ifdef __cplusplus
diff --git a/include/apr_rmm.h b/include/apr_rmm.h
index 976fe9c59..25a368bd1 100644
--- a/include/apr_rmm.h
+++ b/include/apr_rmm.h
@@ -53,7 +53,7 @@ typedef apr_size_t   apr_rmm_off_t;
  * @remark Both @param membuf and @param memsize must be aligned
  * (for instance using APR_ALIGN_DEFAULT).
  */
-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 *membuf, apr_size_t memsize, 
                                        apr_pool_t *cont);
 
@@ -61,7 +61,7 @@ APU_DECLARE(apr_status_t) apr_rmm_init(apr_rmm_t **rmm, apr_anylock_t *lock,
  * Destroy a managed memory block.
  * @param rmm The relocatable memory block to destroy
  */
-APU_DECLARE(apr_status_t) apr_rmm_destroy(apr_rmm_t *rmm);
+APR_DECLARE(apr_status_t) apr_rmm_destroy(apr_rmm_t *rmm);
 
 /**
  * Attach to a relocatable memory block already managed by the apr_rmm API.
@@ -70,21 +70,21 @@ APU_DECLARE(apr_status_t) apr_rmm_destroy(apr_rmm_t *rmm);
  * @param membuf The block of relocatable memory already under management
  * @param cont The pool to use for local storage and management
  */
-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 *membuf, apr_pool_t *cont);
 
 /**
  * Detach from the managed block of memory.
  * @param rmm The relocatable memory block to detach from
  */
-APU_DECLARE(apr_status_t) apr_rmm_detach(apr_rmm_t *rmm);
+APR_DECLARE(apr_status_t) apr_rmm_detach(apr_rmm_t *rmm);
 
 /**
  * Allocate memory from the block of relocatable memory.
  * @param rmm The relocatable memory block
  * @param reqsize How much memory to allocate
  */
-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);
 
 /**
  * Realloc memory from the block of relocatable memory.
@@ -92,21 +92,21 @@ APU_DECLARE(apr_rmm_off_t) apr_rmm_malloc(apr_rmm_t *rmm, apr_size_t reqsize);
  * @param entity The memory allocation to realloc
  * @param reqsize The new size
  */
-APU_DECLARE(apr_rmm_off_t) apr_rmm_realloc(apr_rmm_t *rmm, void *entity, apr_size_t reqsize);
+APR_DECLARE(apr_rmm_off_t) apr_rmm_realloc(apr_rmm_t *rmm, void *entity, apr_size_t reqsize);
 
 /**
  * Allocate memory from the block of relocatable memory and initialize it to zero.
  * @param rmm The relocatable memory block
  * @param reqsize How much memory to allocate
  */
-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);
 
 /**
  * Free allocation returned by apr_rmm_malloc or apr_rmm_calloc.
  * @param rmm The relocatable memory block
  * @param entity The memory allocation to free
  */
-APU_DECLARE(apr_status_t) apr_rmm_free(apr_rmm_t *rmm, apr_rmm_off_t entity);
+APR_DECLARE(apr_status_t) apr_rmm_free(apr_rmm_t *rmm, apr_rmm_off_t entity);
 
 /**
  * Retrieve the physical address of a relocatable allocation of memory
@@ -114,20 +114,20 @@ APU_DECLARE(apr_status_t) apr_rmm_free(apr_rmm_t *rmm, apr_rmm_off_t entity);
  * @param entity The memory allocation to free
  * @return address The address, aligned with APR_ALIGN_DEFAULT.
  */
-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);
 
 /**
  * Compute the offset of a relocatable allocation of memory
  * @param rmm The relocatable memory block
  * @param entity The physical address to convert to an offset
  */
-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);
 
 /**
  * Compute the required overallocation of memory needed to fit n allocs
  * @param n The number of alloc/calloc regions desired
  */
-APU_DECLARE(apr_size_t) apr_rmm_overhead_get(int n);
+APR_DECLARE(apr_size_t) apr_rmm_overhead_get(int n);
 
 #ifdef __cplusplus
 }
diff --git a/include/apr_sdbm.h b/include/apr_sdbm.h
index 5759508b1..59fd3488a 100644
--- a/include/apr_sdbm.h
+++ b/include/apr_sdbm.h
@@ -83,7 +83,7 @@ typedef struct {
  * @remark The sdbm name is not a true file name, as sdbm appends suffixes 
  * for seperate data and index files.
  */
-APU_DECLARE(apr_status_t) apr_sdbm_open(apr_sdbm_t **db, const char *name, 
+APR_DECLARE(apr_status_t) apr_sdbm_open(apr_sdbm_t **db, const char *name, 
                                         apr_int32_t mode, 
                                         apr_fileperms_t perms, apr_pool_t *p);
 
@@ -91,7 +91,7 @@ APU_DECLARE(apr_status_t) apr_sdbm_open(apr_sdbm_t **db, const char *name,
  * Close an sdbm file previously opened by apr_sdbm_open
  * @param db The database to close
  */
-APU_DECLARE(apr_status_t) apr_sdbm_close(apr_sdbm_t *db);
+APR_DECLARE(apr_status_t) apr_sdbm_close(apr_sdbm_t *db);
 
 /**
  * Lock an sdbm database for concurency of multiple operations
@@ -108,13 +108,13 @@ APU_DECLARE(apr_status_t) apr_sdbm_close(apr_sdbm_t *db);
  * The apr_sdbm_lock call requires the database to be opened with the
  * APR_SHARELOCK mode value.
  */
-APU_DECLARE(apr_status_t) apr_sdbm_lock(apr_sdbm_t *db, int type);
+APR_DECLARE(apr_status_t) apr_sdbm_lock(apr_sdbm_t *db, int type);
 
 /**
  * Release an sdbm lock previously aquired by apr_sdbm_lock
  * @param db The database to unlock
  */
-APU_DECLARE(apr_status_t) apr_sdbm_unlock(apr_sdbm_t *db);
+APR_DECLARE(apr_status_t) apr_sdbm_unlock(apr_sdbm_t *db);
 
 /**
  * Fetch an sdbm record value by key
@@ -122,7 +122,7 @@ APU_DECLARE(apr_status_t) apr_sdbm_unlock(apr_sdbm_t *db);
  * @param value The value datum retrieved for this record
  * @param key The key datum to find this record
  */
-APU_DECLARE(apr_status_t) apr_sdbm_fetch(apr_sdbm_t *db, 
+APR_DECLARE(apr_status_t) apr_sdbm_fetch(apr_sdbm_t *db, 
                                          apr_sdbm_datum_t *value, 
                                          apr_sdbm_datum_t key);
 
@@ -137,7 +137,7 @@ APU_DECLARE(apr_status_t) apr_sdbm_fetch(apr_sdbm_t *db,
  *           APR_SDBM_REPLACE    overwrite any existing record for key
  * </PRE>
  */
-APU_DECLARE(apr_status_t) apr_sdbm_store(apr_sdbm_t *db, apr_sdbm_datum_t key,
+APR_DECLARE(apr_status_t) apr_sdbm_store(apr_sdbm_t *db, apr_sdbm_datum_t key,
                                          apr_sdbm_datum_t value, int opt);
 
 /**
@@ -146,7 +146,7 @@ APU_DECLARE(apr_status_t) apr_sdbm_store(apr_sdbm_t *db, apr_sdbm_datum_t key,
  * @param key The key datum of the record to delete
  * @remark It is not an error to delete a non-existent record.
  */
-APU_DECLARE(apr_status_t) apr_sdbm_delete(apr_sdbm_t *db, 
+APR_DECLARE(apr_status_t) apr_sdbm_delete(apr_sdbm_t *db, 
                                           const apr_sdbm_datum_t key);
 
 /**
@@ -158,19 +158,19 @@ APU_DECLARE(apr_status_t) apr_sdbm_delete(apr_sdbm_t *db,
  * prior to retrieving the first record, and hold the lock until after the
  * last call to apr_sdbm_nextkey.
  */
-APU_DECLARE(apr_status_t) apr_sdbm_firstkey(apr_sdbm_t *db, apr_sdbm_datum_t *key);
+APR_DECLARE(apr_status_t) apr_sdbm_firstkey(apr_sdbm_t *db, apr_sdbm_datum_t *key);
 
 /**
  * Retrieve the next record key from an sdbm
  * @param db The database 
  * @param key The key datum of the next record
  */
-APU_DECLARE(apr_status_t) apr_sdbm_nextkey(apr_sdbm_t *db, apr_sdbm_datum_t *key);
+APR_DECLARE(apr_status_t) apr_sdbm_nextkey(apr_sdbm_t *db, apr_sdbm_datum_t *key);
 
 /**
  * Returns true if the sdbm database opened for read-only access
  * @param db The database to test
  */
-APU_DECLARE(int) apr_sdbm_rdonly(apr_sdbm_t *db);
+APR_DECLARE(int) apr_sdbm_rdonly(apr_sdbm_t *db);
 /** @} */
 #endif /* APR_SDBM_H */
diff --git a/include/apr_sha1.h b/include/apr_sha1.h
index 2a4edf368..c7ba3cf3c 100644
--- a/include/apr_sha1.h
+++ b/include/apr_sha1.h
@@ -79,13 +79,13 @@ struct apr_sha1_ctx_t {
  *     will always generate the same hash, making it easier
  *     to break since the search space is smaller.
  */
-APU_DECLARE(void) apr_sha1_base64(const char *clear, int len, char *out);
+APR_DECLARE(void) apr_sha1_base64(const char *clear, int len, char *out);
 
 /**
  * Initialize the SHA digest
  * @param context The SHA context to initialize
  */
-APU_DECLARE(void) apr_sha1_init(apr_sha1_ctx_t *context);
+APR_DECLARE(void) apr_sha1_init(apr_sha1_ctx_t *context);
 
 /**
  * Update the SHA digest
@@ -93,7 +93,7 @@ APU_DECLARE(void) apr_sha1_init(apr_sha1_ctx_t *context);
  * @param input The buffer to add to the SHA digest
  * @param inputLen The length of the input buffer
  */
-APU_DECLARE(void) apr_sha1_update(apr_sha1_ctx_t *context, const char *input,
+APR_DECLARE(void) apr_sha1_update(apr_sha1_ctx_t *context, const char *input,
                                 unsigned int inputLen);
 
 /**
@@ -102,7 +102,7 @@ APU_DECLARE(void) apr_sha1_update(apr_sha1_ctx_t *context, const char *input,
  * @param input The buffer to add to the SHA digest
  * @param inputLen The length of the input buffer
  */
-APU_DECLARE(void) apr_sha1_update_binary(apr_sha1_ctx_t *context,
+APR_DECLARE(void) apr_sha1_update_binary(apr_sha1_ctx_t *context,
                                        const unsigned char *input,
                                        unsigned int inputLen);
 
@@ -111,7 +111,7 @@ APU_DECLARE(void) apr_sha1_update_binary(apr_sha1_ctx_t *context,
  * @param digest the output buffer in which to store the digest
  * @param context The context to finalize
  */
-APU_DECLARE(void) apr_sha1_final(unsigned char digest[APR_SHA1_DIGESTSIZE],
+APR_DECLARE(void) apr_sha1_final(unsigned char digest[APR_SHA1_DIGESTSIZE],
                                apr_sha1_ctx_t *context);
 
 #ifdef __cplusplus
diff --git a/include/apr_strmatch.h b/include/apr_strmatch.h
index 53fadad56..3b23a9d64 100644
--- a/include/apr_strmatch.h
+++ b/include/apr_strmatch.h
@@ -58,7 +58,7 @@ struct apr_strmatch_pattern {
  * @return A pointer to the first instance of the pattern in s, or
  *         NULL if not found
  */
-APU_DECLARE(const char *) apr_strmatch(const apr_strmatch_pattern *pattern,
+APR_DECLARE(const char *) apr_strmatch(const apr_strmatch_pattern *pattern,
                                        const char *s, apr_size_t slen);
 #else
 #define apr_strmatch(pattern, s, slen) (*((pattern)->compare))((pattern), (s), (slen))
@@ -71,7 +71,7 @@ APU_DECLARE(const char *) apr_strmatch(const apr_strmatch_pattern *pattern,
  * @param case_sensitive Whether the matching should be case-sensitive
  * @return a pointer to the compiled pattern, or NULL if compilation fails
  */
-APU_DECLARE(const apr_strmatch_pattern *) apr_strmatch_precompile(apr_pool_t *p, const char *s, int case_sensitive);
+APR_DECLARE(const apr_strmatch_pattern *) apr_strmatch_precompile(apr_pool_t *p, const char *s, int case_sensitive);
 
 /** @} */
 #ifdef __cplusplus
diff --git a/include/apr_thread_pool.h b/include/apr_thread_pool.h
index cbf382b3d..8fbb19d0e 100644
--- a/include/apr_thread_pool.h
+++ b/include/apr_thread_pool.h
@@ -74,7 +74,7 @@ typedef struct apr_thread_pool apr_thread_pool_t;
  * @return APR_SUCCESS if the thread pool was created successfully. Otherwise,
  * the error code.
  */
-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);
@@ -83,7 +83,7 @@ APU_DECLARE(apr_status_t) apr_thread_pool_create(apr_thread_pool_t **me,
  * Destroy the thread pool and stop all the threads
  * @return APR_SUCCESS if all threads are stopped.
  */
-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);
 
 /**
  * Schedule a task to the bottom of the tasks of same priority.
@@ -94,7 +94,7 @@ APU_DECLARE(apr_status_t) apr_thread_pool_destroy(apr_thread_pool_t *me);
  * @param owner Owner of this task.
  * @return APR_SUCCESS if the task had been scheduled successfully
  */
-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,
@@ -108,7 +108,7 @@ APU_DECLARE(apr_status_t) apr_thread_pool_push(apr_thread_pool_t *me,
  * @param owner Owner of this task.
  * @return APR_SUCCESS if the task had been scheduled successfully
  */
-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,
@@ -123,7 +123,7 @@ APU_DECLARE(apr_status_t) apr_thread_pool_schedule(apr_thread_pool_t *me,
  * @param owner Owner of this task.
  * @return APR_SUCCESS if the task had been scheduled successfully
  */
-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,
@@ -138,7 +138,7 @@ APU_DECLARE(apr_status_t) apr_thread_pool_top(apr_thread_pool_t *me,
  * @note The task function should not be calling cancel, otherwise the function
  * may get stuck forever. The function assert if it detect such a case.
  */
-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);
 
 /**
@@ -146,35 +146,35 @@ APU_DECLARE(apr_status_t) apr_thread_pool_tasks_cancel(apr_thread_pool_t *me,
  * @param me The thread pool
  * @return Number of tasks in the queue
  */
-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);
 
 /**
  * Get the current number of scheduled tasks waiting in the queue
  * @param me The thread pool
  * @return Number of scheduled tasks in the queue
  */
-APU_DECLARE(apr_size_t) apr_thread_pool_scheduled_tasks_count(apr_thread_pool_t *me);
+APR_DECLARE(apr_size_t) apr_thread_pool_scheduled_tasks_count(apr_thread_pool_t *me);
 
 /**
  * Get the current number of threads
  * @param me The thread pool
  * @return Total number of threads
  */
-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);
 
 /**
  * Get the current number of busy threads
  * @param me The thread pool
  * @return Number of busy threads
  */
-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);
 
 /**
  * Get the current number of idle threads
  * @param me The thread pool
  * @return Number of idle threads
  */
-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);
 
 /**
  * Access function for the maximum number of idle threads. Number of current
@@ -183,7 +183,7 @@ APU_DECLARE(apr_size_t) apr_thread_pool_idle_count(apr_thread_pool_t *me);
  * @param cnt The number
  * @return The number of threads that were stopped.
  */
-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);
 
 /**
@@ -191,7 +191,7 @@ APU_DECLARE(apr_size_t) apr_thread_pool_idle_max_set(apr_thread_pool_t *me,
  * @param me The thread pool
  * @return Number of tasks that have run
  */
-APU_DECLARE(apr_size_t)
+APR_DECLARE(apr_size_t)
     apr_thread_pool_tasks_run_count(apr_thread_pool_t * me);
 
 /**
@@ -199,7 +199,7 @@ APU_DECLARE(apr_size_t)
  * @param me The thread pool
  * @return High water mark of tasks waiting to run
  */
-APU_DECLARE(apr_size_t)
+APR_DECLARE(apr_size_t)
     apr_thread_pool_tasks_high_count(apr_thread_pool_t * me);
 
 /**
@@ -207,7 +207,7 @@ APU_DECLARE(apr_size_t)
  * @param me The thread pool
  * @return High water mark of threads in thread pool
  */
-APU_DECLARE(apr_size_t)
+APR_DECLARE(apr_size_t)
     apr_thread_pool_threads_high_count(apr_thread_pool_t * me);
 
 /**
@@ -215,7 +215,7 @@ APU_DECLARE(apr_size_t)
  * @param me The thread pool
  * @return Number of idle threads that timed out
  */
-APU_DECLARE(apr_size_t)
+APR_DECLARE(apr_size_t)
     apr_thread_pool_threads_idle_timeout_count(apr_thread_pool_t * me);
 
 /**
@@ -223,7 +223,7 @@ APU_DECLARE(apr_size_t)
  * @param me The thread pool
  * @return The current maximum number
  */
-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);
 
 /**
  * Access function for the maximum number of threads.
@@ -231,7 +231,7 @@ APU_DECLARE(apr_size_t) apr_thread_pool_idle_max_get(apr_thread_pool_t *me);
  * @param cnt Number of threads
  * @return The original maximum number of threads
  */
-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);
 
 /**
@@ -244,7 +244,7 @@ APU_DECLARE(apr_size_t) apr_thread_pool_thread_max_set(apr_thread_pool_t *me,
  * till it reaps itself
  * @return The original maximum wait time
  */
-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);
 
@@ -254,7 +254,7 @@ APU_DECLARE(apr_interval_time_t)
  * @param me The thread pool
  * @return The current maximum wait time
  */
-APU_DECLARE(apr_interval_time_t)
+APR_DECLARE(apr_interval_time_t)
     apr_thread_pool_idle_wait_get(apr_thread_pool_t * me);
 
 /**
@@ -262,7 +262,7 @@ APU_DECLARE(apr_interval_time_t)
  * @param me The thread pool
  * @return The current maximum number
  */
-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);
 
 /**
  * Access function for the threshold of tasks in queue to trigger a new thread.
@@ -270,7 +270,7 @@ APU_DECLARE(apr_size_t) apr_thread_pool_thread_max_get(apr_thread_pool_t *me);
  * @param cnt The new threshold
  * @return The original 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);
 
 /**
@@ -278,7 +278,7 @@ APU_DECLARE(apr_size_t) apr_thread_pool_threshold_set(apr_thread_pool_t *me,
  * @param me The thread pool
  * @return The current threshold
  */
-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);
 
 /**
  * Get owner of the task currently been executed by the thread.
@@ -286,7 +286,7 @@ APU_DECLARE(apr_size_t) apr_thread_pool_threshold_get(apr_thread_pool_t * me);
  * @param owner Pointer to receive owner of the task.
  * @return APR_SUCCESS if the owner is retrieved successfully
  */
-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);
 
 /** @} */
diff --git a/include/apr_uri.h b/include/apr_uri.h
index 02908a9d3..63b3e207f 100644
--- a/include/apr_uri.h
+++ b/include/apr_uri.h
@@ -124,7 +124,7 @@ struct apr_uri_t {
  * @param scheme_str The string that contains the current scheme
  * @return The default port for this scheme
  */ 
-APU_DECLARE(apr_port_t) apr_uri_port_of_scheme(const char *scheme_str);
+APR_DECLARE(apr_port_t) apr_uri_port_of_scheme(const char *scheme_str);
 
 /**
  * Unparse a apr_uri_t structure to an URI string.  Optionally 
@@ -143,7 +143,7 @@ APU_DECLARE(apr_port_t) apr_uri_port_of_scheme(const char *scheme_str);
  * </PRE>
  * @return The uri as a string
  */
-APU_DECLARE(char *) apr_uri_unparse(apr_pool_t *p, 
+APR_DECLARE(char *) apr_uri_unparse(apr_pool_t *p, 
                                     const apr_uri_t *uptr,
                                     unsigned flags);
 
@@ -156,7 +156,7 @@ APU_DECLARE(char *) apr_uri_unparse(apr_pool_t *p,
  * @param uptr The apr_uri_t to fill out
  * @return APR_SUCCESS for success or error code
  */
-APU_DECLARE(apr_status_t) apr_uri_parse(apr_pool_t *p, const char *uri, 
+APR_DECLARE(apr_status_t) apr_uri_parse(apr_pool_t *p, const char *uri, 
                                         apr_uri_t *uptr);
 
 /**
@@ -166,7 +166,7 @@ APU_DECLARE(apr_status_t) apr_uri_parse(apr_pool_t *p, const char *uri,
  * @param uptr The apr_uri_t to fill out
  * @return APR_SUCCESS for success or error code
  */
-APU_DECLARE(apr_status_t) apr_uri_parse_hostinfo(apr_pool_t *p, 
+APR_DECLARE(apr_status_t) apr_uri_parse_hostinfo(apr_pool_t *p, 
                                                  const char *hostinfo, 
                                                  apr_uri_t *uptr);
 
diff --git a/include/apr_uuid.h b/include/apr_uuid.h
index 5312a9f62..bb8841f1c 100644
--- a/include/apr_uuid.h
+++ b/include/apr_uuid.h
@@ -50,7 +50,7 @@ typedef struct {
  * Generate and return a (new) UUID
  * @param uuid The resulting UUID
  */ 
-APU_DECLARE(void) apr_uuid_get(apr_uuid_t *uuid);
+APR_DECLARE(void) apr_uuid_get(apr_uuid_t *uuid);
 
 /**
  * Format a UUID into a string, following the standard format
@@ -59,14 +59,14 @@ APU_DECLARE(void) apr_uuid_get(apr_uuid_t *uuid);
  *               the formatted UUID and a null terminator
  * @param uuid The UUID to format
  */ 
-APU_DECLARE(void) apr_uuid_format(char *buffer, const apr_uuid_t *uuid);
+APR_DECLARE(void) apr_uuid_format(char *buffer, const apr_uuid_t *uuid);
 
 /**
  * Parse a standard-format string into a UUID
  * @param uuid The resulting UUID
  * @param uuid_str The formatted UUID
  */ 
-APU_DECLARE(apr_status_t) apr_uuid_parse(apr_uuid_t *uuid, const char *uuid_str);
+APR_DECLARE(apr_status_t) apr_uuid_parse(apr_uuid_t *uuid, const char *uuid_str);
 
 /** @} */
 #ifdef __cplusplus
diff --git a/include/apr_xlate.h b/include/apr_xlate.h
index 326366853..6f27fda0b 100644
--- a/include/apr_xlate.h
+++ b/include/apr_xlate.h
@@ -63,7 +63,7 @@ typedef struct apr_xlate_t            apr_xlate_t;
  *  if charset transcoding is not available in this instance of
  *  apr-util at all (i.e., APR_HAS_XLATE is undefined).
  */
-APU_DECLARE(apr_status_t) apr_xlate_open(apr_xlate_t **convset, 
+APR_DECLARE(apr_status_t) apr_xlate_open(apr_xlate_t **convset, 
                                          const char *topage, 
                                          const char *frompage, 
                                          apr_pool_t *pool);
@@ -90,7 +90,7 @@ APU_DECLARE(apr_status_t) apr_xlate_open(apr_xlate_t **convset,
  *  Return APR_ENOTIMPL if charset transcoding is not available
  *  in this instance of apr-util (i.e., APR_HAS_XLATE is undefined).
  */
-APU_DECLARE(apr_status_t) apr_xlate_sb_get(apr_xlate_t *convset, int *onoff);
+APR_DECLARE(apr_status_t) apr_xlate_sb_get(apr_xlate_t *convset, int *onoff);
 
 /**
  * Convert a buffer of text from one codepage to another.
@@ -114,7 +114,7 @@ APU_DECLARE(apr_status_t) apr_xlate_sb_get(apr_xlate_t *convset, int *onoff);
  * the inbuf and inbytes_left parameters as NULL.  (Note that this
  * mode only works from version 1.1.0 onwards)
  */
-APU_DECLARE(apr_status_t) apr_xlate_conv_buffer(apr_xlate_t *convset, 
+APR_DECLARE(apr_status_t) apr_xlate_conv_buffer(apr_xlate_t *convset, 
                                                 const char *inbuf, 
                                                 apr_size_t *inbytes_left, 
                                                 char *outbuf,
@@ -131,7 +131,7 @@ APU_DECLARE(apr_status_t) apr_xlate_conv_buffer(apr_xlate_t *convset,
  * @param inchar The character to convert
  * @param outchar The converted character
  */
-APU_DECLARE(apr_status_t) apr_xlate_conv_char(apr_xlate_t *convset, 
+APR_DECLARE(apr_status_t) apr_xlate_conv_char(apr_xlate_t *convset, 
                                               char inchar, char outchar);
 #endif
 
@@ -143,7 +143,7 @@ APU_DECLARE(apr_status_t) apr_xlate_conv_char(apr_xlate_t *convset,
  * @warning This only works when converting between single-byte character sets.
  *          -1 will be returned if the conversion can't be performed.
  */
-APU_DECLARE(apr_int32_t) apr_xlate_conv_byte(apr_xlate_t *convset, 
+APR_DECLARE(apr_int32_t) apr_xlate_conv_byte(apr_xlate_t *convset, 
                                              unsigned char inchar);
 
 /**
@@ -153,7 +153,7 @@ APU_DECLARE(apr_int32_t) apr_xlate_conv_byte(apr_xlate_t *convset,
  *  Return APR_ENOTIMPL if charset transcoding is not available
  *  in this instance of apr-util (i.e., APR_HAS_XLATE is undefined).
  */
-APU_DECLARE(apr_status_t) apr_xlate_close(apr_xlate_t *convset);
+APR_DECLARE(apr_status_t) apr_xlate_close(apr_xlate_t *convset);
 
 /** @} */
 #ifdef __cplusplus
diff --git a/include/apr_xml.h b/include/apr_xml.h
index 2a43b283e..62fed68d1 100644
--- a/include/apr_xml.h
+++ b/include/apr_xml.h
@@ -74,7 +74,7 @@ struct apr_text_header {
  * @param hdr The text header to append to
  * @param text The new text to append
  */
-APU_DECLARE(void) apr_text_append(apr_pool_t *p, apr_text_header *hdr,
+APR_DECLARE(void) apr_text_append(apr_pool_t *p, apr_text_header *hdr,
                                   const char *text);
 
 
@@ -212,7 +212,7 @@ typedef struct apr_xml_parser apr_xml_parser;
  * @param pool The pool for allocating the parser and the parse results.
  * @return The new parser.
  */
-APU_DECLARE(apr_xml_parser *) apr_xml_parser_create(apr_pool_t *pool);
+APR_DECLARE(apr_xml_parser *) apr_xml_parser_create(apr_pool_t *pool);
 
 /**
  * Parse a File, producing a xml_doc
@@ -224,7 +224,7 @@ APU_DECLARE(apr_xml_parser *) apr_xml_parser_create(apr_pool_t *pool);
  * @param buffer_length Buffer length which would be suitable 
  * @return Any errors found during parsing.
  */
-APU_DECLARE(apr_status_t) apr_xml_parse_file(apr_pool_t *p,
+APR_DECLARE(apr_status_t) apr_xml_parse_file(apr_pool_t *p,
                                              apr_xml_parser **parser,
                                              apr_xml_doc **ppdoc,
                                              apr_file_t *xmlfd,
@@ -239,7 +239,7 @@ APU_DECLARE(apr_status_t) apr_xml_parse_file(apr_pool_t *p,
  * @return Any errors found during parsing.
  * @remark Use apr_xml_parser_geterror() to get more error information.
  */
-APU_DECLARE(apr_status_t) apr_xml_parser_feed(apr_xml_parser *parser,
+APR_DECLARE(apr_status_t) apr_xml_parser_feed(apr_xml_parser *parser,
                                               const char *data,
                                               apr_size_t len);
 
@@ -251,7 +251,7 @@ APU_DECLARE(apr_status_t) apr_xml_parser_feed(apr_xml_parser *parser,
  * @return Any errors found during the final stage of parsing.
  * @remark Use apr_xml_parser_geterror() to get more error information.
  */
-APU_DECLARE(apr_status_t) apr_xml_parser_done(apr_xml_parser *parser,
+APR_DECLARE(apr_status_t) apr_xml_parser_done(apr_xml_parser *parser,
                                               apr_xml_doc **pdoc);
 
 /**
@@ -261,7 +261,7 @@ APU_DECLARE(apr_status_t) apr_xml_parser_done(apr_xml_parser *parser,
  * @param errbufsize The length of the error text buffer.
  * @return The error buffer
  */
-APU_DECLARE(char *) apr_xml_parser_geterror(apr_xml_parser *parser,
+APR_DECLARE(char *) apr_xml_parser_geterror(apr_xml_parser *parser,
                                             char *errbuf,
                                             apr_size_t errbufsize);
 
@@ -282,7 +282,7 @@ APU_DECLARE(char *) apr_xml_parser_geterror(apr_xml_parser *parser,
  * @param pbuf Buffer to put the converted text into
  * @param psize Size of the converted text
  */
-APU_DECLARE(void) apr_xml_to_text(apr_pool_t *p, const apr_xml_elem *elem,
+APR_DECLARE(void) apr_xml_to_text(apr_pool_t *p, const apr_xml_elem *elem,
                                   int style, apr_array_header_t *namespaces,
                                   int *ns_map, const char **pbuf,
                                   apr_size_t *psize);
@@ -299,7 +299,7 @@ APU_DECLARE(void) apr_xml_to_text(apr_pool_t *p, const apr_xml_elem *elem,
  * @param elem The XML element to empty
  * @return the string that was stored in the XML element
  */
-APU_DECLARE(const char *) apr_xml_empty_elem(apr_pool_t *p,
+APR_DECLARE(const char *) apr_xml_empty_elem(apr_pool_t *p,
                                              const apr_xml_elem *elem);
 
 /**
@@ -312,7 +312,7 @@ APU_DECLARE(const char *) apr_xml_empty_elem(apr_pool_t *p,
  * @note If the string does not contain special characters, it is not
  * duplicated into the pool and the original string is returned.
  */
-APU_DECLARE(const char *) apr_xml_quote_string(apr_pool_t *p, const char *s,
+APR_DECLARE(const char *) apr_xml_quote_string(apr_pool_t *p, const char *s,
                                                int quotes);
 
 /**
@@ -320,7 +320,7 @@ APU_DECLARE(const char *) apr_xml_quote_string(apr_pool_t *p, const char *s,
  * @param p The pool to allocate out of
  * @param elem The element to quote
  */
-APU_DECLARE(void) apr_xml_quote_elem(apr_pool_t *p, apr_xml_elem *elem);
+APR_DECLARE(void) apr_xml_quote_elem(apr_pool_t *p, apr_xml_elem *elem);
 
 /* manage an array of unique URIs: apr_xml_insert_uri() and APR_XML_URI_ITEM() */
 
@@ -330,7 +330,7 @@ APU_DECLARE(void) apr_xml_quote_elem(apr_pool_t *p, apr_xml_elem *elem);
  * @param uri The uri to insert
  * @return int The uri's index
  */
-APU_DECLARE(int) apr_xml_insert_uri(apr_array_header_t *uri_array,
+APR_DECLARE(int) apr_xml_insert_uri(apr_array_header_t *uri_array,
                                     const char *uri);
 
 /** Get the URI item for this XML element */
@@ -344,7 +344,7 @@ APU_DECLARE(int) apr_xml_insert_uri(apr_array_header_t *uri_array,
  * @param xlate The translation handle to use.
  * @return Any errors found during conversion.
  */
-APU_DECLARE(apr_status_t) apr_xml_parser_convert_doc(apr_pool_t *p,
+APR_DECLARE(apr_status_t) apr_xml_parser_convert_doc(apr_pool_t *p,
                                                      apr_xml_doc *pdoc,
                                                      apr_xlate_t *convset);
 #endif
diff --git a/include/apu.h.in b/include/apu.h.in
index 4037094da..572f3bdd0 100644
--- a/include/apu.h.in
+++ b/include/apu.h.in
@@ -30,42 +30,42 @@
 #define APU_H
 
 /**
- * APU_DECLARE_EXPORT is defined when building the APR-UTIL dynamic library,
+ * APR_DECLARE_EXPORT is defined when building the APR-UTIL dynamic library,
  * so that all public symbols are exported.
  *
- * APU_DECLARE_STATIC is defined when including the APR-UTIL public headers,
+ * APR_DECLARE_STATIC is defined when including the APR-UTIL public headers,
  * to provide static linkage when the dynamic library may be unavailable.
  *
- * APU_DECLARE_STATIC and APU_DECLARE_EXPORT are left undefined when
+ * APR_DECLARE_STATIC and APR_DECLARE_EXPORT are left undefined when
  * including the APR-UTIL public headers, to import and link the symbols from 
  * the dynamic APR-UTIL library and assure appropriate indirection and calling
  * conventions at compile time.
  */
 
 /**
- * The public APR-UTIL functions are declared with APU_DECLARE(), so they may
+ * The public APR-UTIL functions are declared with APR_DECLARE(), so they may
  * use the most appropriate calling convention.  Public APR functions with 
- * variable arguments must use APU_DECLARE_NONSTD().
+ * variable arguments must use APR_DECLARE_NONSTD().
  *
- * @fn APU_DECLARE(rettype) apr_func(args);
+ * @fn APR_DECLARE(rettype) apr_func(args);
  */
-#define APU_DECLARE(type)            type
+#define APR_DECLARE(type)            type
 /**
  * The public APR-UTIL functions using variable arguments are declared with 
- * APU_DECLARE_NONSTD(), as they must use the C language calling convention.
+ * APR_DECLARE_NONSTD(), as they must use the C language calling convention.
  *
- * @fn APU_DECLARE_NONSTD(rettype) apr_func(args, ...);
+ * @fn APR_DECLARE_NONSTD(rettype) apr_func(args, ...);
  */
-#define APU_DECLARE_NONSTD(type)     type
+#define APR_DECLARE_NONSTD(type)     type
 /**
- * The public APR-UTIL variables are declared with APU_DECLARE_DATA.
+ * The public APR-UTIL variables are declared with APR_DECLARE_DATA.
  * This assures the appropriate indirection is invoked at compile time.
  *
- * @fn APU_DECLARE_DATA type apr_variable;
- * @note APU_DECLARE_DATA extern type apr_variable; syntax is required for
+ * @fn APR_DECLARE_DATA type apr_variable;
+ * @note APR_DECLARE_DATA extern type apr_variable; syntax is required for
  * declarations within headers to properly import the variable.
  */
-#define APU_DECLARE_DATA
+#define APR_DECLARE_DATA
 
 #if !defined(WIN32) || defined(APU_MODULE_DECLARE_STATIC)
 /**
diff --git a/include/apu.hnw b/include/apu.hnw
index 31c0dfb41..aca6227f2 100644
--- a/include/apu.hnw
+++ b/include/apu.hnw
@@ -32,42 +32,42 @@
 
 
 /**
- * APU_DECLARE_EXPORT is defined when building the APR-UTIL dynamic library,
+ * APR_DECLARE_EXPORT is defined when building the APR-UTIL dynamic library,
  * so that all public symbols are exported.
  *
- * APU_DECLARE_STATIC is defined when including the APR-UTIL public headers,
+ * APR_DECLARE_STATIC is defined when including the APR-UTIL public headers,
  * to provide static linkage when the dynamic library may be unavailable.
  *
- * APU_DECLARE_STATIC and APU_DECLARE_EXPORT are left undefined when
+ * APR_DECLARE_STATIC and APR_DECLARE_EXPORT are left undefined when
  * including the APR-UTIL public headers, to import and link the symbols from 
  * the dynamic APR-UTIL library and assure appropriate indirection and calling
  * conventions at compile time.
  */
 
 /**
- * The public APR-UTIL functions are declared with APU_DECLARE(), so they may
+ * The public APR-UTIL functions are declared with APR_DECLARE(), so they may
  * use the most appropriate calling convention.  Public APR functions with 
- * variable arguments must use APU_DECLARE_NONSTD().
+ * variable arguments must use APR_DECLARE_NONSTD().
  *
- * @fn APU_DECLARE(rettype) apr_func(args);
+ * @fn APR_DECLARE(rettype) apr_func(args);
  */
-#define APU_DECLARE(type)            type
+#define APR_DECLARE(type)            type
 /**
  * The public APR-UTIL functions using variable arguments are declared with 
- * APU_DECLARE_NONSTD(), as they must use the C language calling convention.
+ * APR_DECLARE_NONSTD(), as they must use the C language calling convention.
  *
- * @fn APU_DECLARE_NONSTD(rettype) apr_func(args, ...);
+ * @fn APR_DECLARE_NONSTD(rettype) apr_func(args, ...);
  */
-#define APU_DECLARE_NONSTD(type)     type
+#define APR_DECLARE_NONSTD(type)     type
 /**
- * The public APR-UTIL variables are declared with APU_DECLARE_DATA.
+ * The public APR-UTIL variables are declared with APR_DECLARE_DATA.
  * This assures the appropriate indirection is invoked at compile time.
  *
- * @fn APU_DECLARE_DATA type apr_variable;
- * @note APU_DECLARE_DATA extern type apr_variable; syntax is required for
+ * @fn APR_DECLARE_DATA type apr_variable;
+ * @note APR_DECLARE_DATA extern type apr_variable; syntax is required for
  * declarations within headers to properly import the variable.
  */
-#define APU_DECLARE_DATA
+#define APR_DECLARE_DATA
 
 /**
  * Declare a dso module's exported module structure as APU_MODULE_DECLARE_DATA.
diff --git a/include/apu.hw b/include/apu.hw
index 5be70de60..591fb76ae 100644
--- a/include/apu.hw
+++ b/include/apu.hw
@@ -30,13 +30,13 @@
 #define APU_H
 
 /**
- * APU_DECLARE_EXPORT is defined when building the APR-UTIL dynamic library,
+ * APR_DECLARE_EXPORT is defined when building the APR-UTIL dynamic library,
  * so that all public symbols are exported.
  *
- * APU_DECLARE_STATIC is defined when including the APR-UTIL public headers,
+ * APR_DECLARE_STATIC is defined when including the APR-UTIL public headers,
  * to provide static linkage when the dynamic library may be unavailable.
  *
- * APU_DECLARE_STATIC and APU_DECLARE_EXPORT are left undefined when
+ * APR_DECLARE_STATIC and APR_DECLARE_EXPORT are left undefined when
  * including the APR-UTIL public headers, to import and link the symbols from 
  * the dynamic APR-UTIL library and assure appropriate indirection and calling
  * conventions at compile time.
@@ -44,41 +44,41 @@
 
 #if defined(DOXYGEN) || !defined(WIN32)
 /**
- * The public APR-UTIL functions are declared with APU_DECLARE(), so they may
+ * The public APR-UTIL functions are declared with APR_DECLARE(), so they may
  * use the most appropriate calling convention.  Public APR functions with 
- * variable arguments must use APU_DECLARE_NONSTD().
+ * variable arguments must use APR_DECLARE_NONSTD().
  *
- * @fn APU_DECLARE(rettype) apr_func(args);
+ * @fn APR_DECLARE(rettype) apr_func(args);
  */
-#define APU_DECLARE(type)            type
+#define APR_DECLARE(type)            type
 /**
  * The public APR-UTIL functions using variable arguments are declared with 
- * APU_DECLARE_NONSTD(), as they must use the C language calling convention.
+ * APR_DECLARE_NONSTD(), as they must use the C language calling convention.
  *
- * @fn APU_DECLARE_NONSTD(rettype) apr_func(args, ...);
+ * @fn APR_DECLARE_NONSTD(rettype) apr_func(args, ...);
  */
-#define APU_DECLARE_NONSTD(type)     type
+#define APR_DECLARE_NONSTD(type)     type
 /**
- * The public APR-UTIL variables are declared with APU_DECLARE_DATA.
+ * The public APR-UTIL variables are declared with APR_DECLARE_DATA.
  * This assures the appropriate indirection is invoked at compile time.
  *
- * @fn APU_DECLARE_DATA type apr_variable;
- * @note extern APU_DECLARE_DATA type apr_variable; syntax is required for
+ * @fn APR_DECLARE_DATA type apr_variable;
+ * @note extern APR_DECLARE_DATA type apr_variable; syntax is required for
  * declarations within headers to properly import the variable.
  */
-#define APU_DECLARE_DATA
-#elif defined(APU_DECLARE_STATIC)
-#define APU_DECLARE(type)            type __stdcall
-#define APU_DECLARE_NONSTD(type)     type __cdecl
-#define APU_DECLARE_DATA
-#elif defined(APU_DECLARE_EXPORT)
-#define APU_DECLARE(type)            __declspec(dllexport) type __stdcall
-#define APU_DECLARE_NONSTD(type)     __declspec(dllexport) type __cdecl
-#define APU_DECLARE_DATA             __declspec(dllexport)
+#define APR_DECLARE_DATA
+#elif defined(APR_DECLARE_STATIC)
+#define APR_DECLARE(type)            type __stdcall
+#define APR_DECLARE_NONSTD(type)     type __cdecl
+#define APR_DECLARE_DATA
+#elif defined(APR_DECLARE_EXPORT)
+#define APR_DECLARE(type)            __declspec(dllexport) type __stdcall
+#define APR_DECLARE_NONSTD(type)     __declspec(dllexport) type __cdecl
+#define APR_DECLARE_DATA             __declspec(dllexport)
 #else
-#define APU_DECLARE(type)            __declspec(dllimport) type __stdcall
-#define APU_DECLARE_NONSTD(type)     __declspec(dllimport) type __cdecl
-#define APU_DECLARE_DATA             __declspec(dllimport)
+#define APR_DECLARE(type)            __declspec(dllimport) type __stdcall
+#define APR_DECLARE_NONSTD(type)     __declspec(dllimport) type __cdecl
+#define APR_DECLARE_DATA             __declspec(dllimport)
 #endif
 
 #if !defined(WIN32) || defined(APU_MODULE_DECLARE_STATIC)
diff --git a/include/apu_version.h b/include/apu_version.h
index 9db3f81a1..66f3e818d 100644
--- a/include/apu_version.h
+++ b/include/apu_version.h
@@ -120,10 +120,10 @@ extern "C" {
  *  @param pvsn Pointer to a version structure for returning the version
  *              information.
  */
-APU_DECLARE(void) apu_version(apr_version_t *pvsn);
+APR_DECLARE(void) apu_version(apr_version_t *pvsn);
 
 /** Return APU's version information as a string. */
-APU_DECLARE(const char *) apu_version_string(void);
+APR_DECLARE(const char *) apu_version_string(void);
 
 #ifdef __cplusplus
 }
diff --git a/include/private/apr_dbd_internal.h b/include/private/apr_dbd_internal.h
index 671ffb218..3d50cc603 100644
--- a/include/private/apr_dbd_internal.h
+++ b/include/private/apr_dbd_internal.h
@@ -355,8 +355,8 @@ struct apr_dbd_driver_t {
  * deprecated; create a per-dbd mutex within the (*init) function
  * to avoid blocking other providers running on other threads
  */
-APU_DECLARE(apr_status_t) apr_dbd_mutex_lock(void);
-APU_DECLARE(apr_status_t) apr_dbd_mutex_unlock(void);
+APR_DECLARE(apr_status_t) apr_dbd_mutex_lock(void);
+APR_DECLARE(apr_status_t) apr_dbd_mutex_unlock(void);
 
 #ifdef __cplusplus
 }
diff --git a/include/private/apr_dbm_private.h b/include/private/apr_dbm_private.h
index 020d3a6b8..a4db5fe0f 100644
--- a/include/private/apr_dbm_private.h
+++ b/include/private/apr_dbm_private.h
@@ -39,7 +39,7 @@ extern "C" {
  * Most DBM libraries take a POSIX mode for creating files.  Don't trust
  * the mode_t type, some platforms may not support it, int is safe.
  */
-APU_DECLARE(int) apr_posix_perms2mode(apr_fileperms_t perm);
+APR_DECLARE(int) apr_posix_perms2mode(apr_fileperms_t perm);
 
 /**
  * Structure to describe the operations of the DBM
diff --git a/include/private/apu_config.hw b/include/private/apu_config.hw
index 015dd5263..45b4c2af3 100644
--- a/include/private/apu_config.hw
+++ b/include/private/apu_config.hw
@@ -25,7 +25,7 @@
 #define APU_CONFIG_H
 
 /* Compile win32 with DSO support for .dll builds */
-#ifdef APU_DECLARE_STATIC
+#ifdef APR_DECLARE_STATIC
 #define APU_DSO_BUILD           0
 #else
 #define APU_DSO_BUILD           1