apr-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From wr...@apache.org
Subject cvs commit: apr-util/include apr_base64.h apr_buckets.h apr_generic_hook.h apr_hooks.h apr_ring.h apr_sdbm.h apr_sha1.h apu.h.in apu.hw ap_base64.h ap_buckets.h ap_generic_hook.h ap_hooks.h ap_ring.h ap_sha1.h
Date Fri, 19 Jan 2001 07:01:27 GMT
wrowe       01/01/18 23:01:27

  Modified:    include  apr_base64.h apr_buckets.h apr_generic_hook.h
                        apr_hooks.h apr_ring.h apr_sdbm.h apr_sha1.h
                        apu.h.in apu.hw
  Removed:     include  ap_base64.h ap_buckets.h ap_generic_hook.h
                        ap_hooks.h ap_ring.h ap_sha1.h
  Log:
    Changes at-a-glance for the symbol rename.  Files removed now per
    comments that the two copies in the tree break the build.
  
  Revision  Changes    Path
  1.13      +12 -12    apr-util/include/apr_base64.h
  
  Index: apr_base64.h
  ===================================================================
  RCS file: /home/cvs/apr-util/include/apr_base64.h,v
  retrieving revision 1.12
  retrieving revision 1.13
  diff -u -r1.12 -r1.13
  --- apr_base64.h	2001/01/18 23:30:56	1.12
  +++ apr_base64.h	2001/01/19 07:01:26	1.13
  @@ -88,9 +88,9 @@
    * encrypted string.
    * @param len the length of an unencrypted string.
    * @return the length of the string after it is encrypted
  - * @deffunc int ap_base64encode_len(int len)
  + * @deffunc int apr_base64encode_len(int len)
    */ 
  -APU_DECLARE(int) ap_base64encode_len(int len);
  +APU_DECLARE(int) apr_base64encode_len(int len);
   
   /**
    * Encode a text string using base64encoding.
  @@ -98,9 +98,9 @@
    * @param plain_src The original string in plain text
    * @param len_plain_src The length of the plain text string
    * @return the length of the encoded string
  - * @deffunc int ap_base64encode(char *coded_dst, const char *plain_src, int len_plain_src)
  + * @deffunc int apr_base64encode(char *coded_dst, const char *plain_src, int len_plain_src)
    */ 
  -APU_DECLARE(int) ap_base64encode(char * coded_dst, const char *plain_src, 
  +APU_DECLARE(int) apr_base64encode(char * coded_dst, const char *plain_src, 
                                    int len_plain_src);
   
   /**
  @@ -109,9 +109,9 @@
    * @param plain_src The original string in plain text
    * @param len_plain_src The length of the plain text string
    * @return the length of the encoded string
  - * @deffunc int ap_base64encode_binary(char *coded_dst, const char *plain_src, int len_plain_src)
  + * @deffunc int apr_base64encode_binary(char *coded_dst, const char *plain_src, int len_plain_src)
    */ 
  -APU_DECLARE(int) ap_base64encode_binary(char * coded_dst, 
  +APU_DECLARE(int) apr_base64encode_binary(char * coded_dst, 
                                           const unsigned char *plain_src,
                                           int len_plain_src);
   
  @@ -119,27 +119,27 @@
    * Determine the length of a plain text string given the encoded version
    * @param coded_src The encoded string
    * @return the length of the plain text string
  - * @deffunc int ap_base64decode_len(const char *coded_src)
  + * @deffunc int apr_base64decode_len(const char *coded_src)
    */ 
  -APU_DECLARE(int) ap_base64decode_len(const char * coded_src);
  +APU_DECLARE(int) apr_base64decode_len(const char * coded_src);
   
   /**
    * Decode a string to plain text
    * @param plain_dst The destination string for the plain text
    * @param coded_src The encoded string 
    * @return the length of the plain text string
  - * @deffunc int ap_base64decode(char *plain_dst, const char *coded_src)
  + * @deffunc int apr_base64decode(char *plain_dst, const char *coded_src)
    */ 
  -APU_DECLARE(int) ap_base64decode(char * plain_dst, const char *coded_src);
  +APU_DECLARE(int) apr_base64decode(char * plain_dst, const char *coded_src);
   
   /**
    * Decode an EBCDIC string to plain text
    * @param plain_dst The destination string for the plain text
    * @param coded_src The encoded string 
    * @return the length of the plain text string
  - * @deffunc int ap_base64decode_binary(char *plain_dst, const char *coded_src)
  + * @deffunc int apr_base64decode_binary(char *plain_dst, const char *coded_src)
    */ 
  -APU_DECLARE(int) ap_base64decode_binary(unsigned char * plain_dst, 
  +APU_DECLARE(int) apr_base64decode_binary(unsigned char * plain_dst, 
                                           const char *coded_src);
   
   #ifdef __cplusplus
  
  
  
  1.64      +236 -236  apr-util/include/apr_buckets.h
  
  Index: apr_buckets.h
  ===================================================================
  RCS file: /home/cvs/apr-util/include/apr_buckets.h,v
  retrieving revision 1.63
  retrieving revision 1.64
  diff -u -r1.63 -r1.64
  --- apr_buckets.h	2001/01/18 23:30:56	1.63
  +++ apr_buckets.h	2001/01/19 07:01:26	1.64
  @@ -52,8 +52,8 @@
    * <http://www.apache.org/>.
    */
   
  -#ifndef AP_BUCKETS_H
  -#define AP_BUCKETS_H
  +#ifndef APR_BUCKETS_H
  +#define APR_BUCKETS_H
   
   #include "apu.h"
   #include "apr_network_io.h"
  @@ -61,7 +61,7 @@
   #include "apr_general.h"
   #include "apr_mmap.h"
   #include "apr_errno.h"
  -#include "ap_ring.h"
  +#include "apr_ring.h"
   #include "apr.h"
   #if APR_HAVE_SYS_UIO_H
   #include <sys/uio.h>	/* for struct iovec */
  @@ -78,7 +78,7 @@
    * @package Bucket Brigades
    */
   
  -typedef enum {AP_BLOCK_READ, AP_NONBLOCK_READ} ap_read_type;
  +typedef enum {APR_BLOCK_READ, APR_NONBLOCK_READ} apr_read_type_e;
   
   /*
    * The one-sentence buzzword-laden overview: Bucket brigades represent
  @@ -121,8 +121,8 @@
    * destroy maintains the reference counts on the resources used by a
    * bucket and frees them if necessary.
    *
  - * Note: all of the above functions have wrapper macros (ap_bucket_read(),
  - * ap_bucket_destroy(), etc), and those macros should be used rather
  + * Note: all of the above functions have wrapper macros (apr_bucket_read(),
  + * apr_bucket_destroy(), etc), and those macros should be used rather
    * than using the function pointers directly.
    *
    * To write a bucket brigade, they are first made into an iovec, so that we
  @@ -136,12 +136,12 @@
    * Forward declaration of the main types.
    */
   
  -typedef struct ap_bucket_brigade ap_bucket_brigade;
  +typedef struct apr_bucket_brigade apr_bucket_brigade;
   
  -typedef struct ap_bucket ap_bucket;
  +typedef struct apr_bucket apr_bucket;
   
  -typedef struct ap_bucket_type ap_bucket_type;
  -struct ap_bucket_type {
  +typedef struct apr_bucket_type_t apr_bucket_type_t;
  +struct apr_bucket_type_t {
       /**
        * The name of the bucket type
        */
  @@ -167,9 +167,9 @@
        * @param len The amount of data read.
        * @param block Should this read function block if there is more data that
        *              cannot be read immediately.
  -     * @deffunc apr_status_t read(ap_bucket *b, const char **str, apr_size_t *len, ap_read_type block)
  +     * @deffunc apr_status_t read(apr_bucket *b, const char **str, apr_size_t *len, apr_read_type_e block)
        */
  -    apr_status_t (*read)(ap_bucket *b, const char **str, apr_size_t *len, ap_read_type block);
  +    apr_status_t (*read)(apr_bucket *b, const char **str, apr_size_t *len, apr_read_type_e block);
       
       /**
        * Make it possible to set aside the data. Buckets containing data that
  @@ -177,9 +177,9 @@
        *  bucket. For most bucket types, though, this is a no-op and this
        *  function will return APR_ENOTIMPL.
        * @param e The bucket to convert
  -     * @deffunc apr_status_t setaside(ap_bucket *e)
  +     * @deffunc apr_status_t setaside(apr_bucket *e)
        */
  -    apr_status_t (*setaside)(ap_bucket *e);
  +    apr_status_t (*setaside)(apr_bucket *e);
   
       /**
        * Split one bucket in two at the specified position by duplicating
  @@ -187,12 +187,12 @@
        *  start/end/offset information.  If it's not possible to do this
        *  for the bucket type (perhaps the length of the data is indeterminate,
        *  as with pipe and socket buckets), then APR_ENOTIMPL is returned.
  -     * @see ap_bucket_split_any().
  +     * @see apr_bucket_split_any().
        * @param e The bucket to split
        * @param point The offset of the first byte in the new bucket
  -     * @deffunc apr_status_t split(ap_bucket *e, apr_off_t point)
  +     * @deffunc apr_status_t split(apr_bucket *e, apr_off_t point)
        */
  -    apr_status_t (*split)(ap_bucket *e, apr_off_t point);
  +    apr_status_t (*split)(apr_bucket *e, apr_off_t point);
   
       /**
        * Copy the bucket structure (not the data), assuming that this is
  @@ -201,24 +201,24 @@
        * @param c Returns a pointer to the new bucket
        * @deffunc apr_status_t copy
        */
  -    apr_status_t (*copy)(ap_bucket *e, ap_bucket **c);
  +    apr_status_t (*copy)(apr_bucket *e, apr_bucket **c);
   
   };
   
   /**
  - * ap_bucket_t structures are allocated on the malloc() heap and
  - * their lifetime is controlled by the parent ap_bucket_brigade
  + * apr_bucket_t structures are allocated on the malloc() heap and
  + * their lifetime is controlled by the parent apr_bucket_brigade
    * structure. Buckets can move from one brigade to another e.g. by
  - * calling ap_brigade_concat(). In general the data in a bucket has
  + * calling apr_brigade_concat(). In general the data in a bucket has
    * the same lifetime as the bucket and is freed when the bucket is
    * destroyed; if the data is shared by more than one bucket (e.g.
    * after a split) the data is freed when the last bucket goes away.
    */
  -struct ap_bucket {
  +struct apr_bucket {
       /** Links to the rest of the brigade */
  -    AP_RING_ENTRY(ap_bucket) link;
  +    APR_RING_ENTRY(apr_bucket) link;
       /** The type of bucket.  */
  -    const ap_bucket_type *type;
  +    const apr_bucket_type_t *type;
       /** The length of the data in the bucket.  This could have been implemented
        *  with a function, but this is an optimization, because the most
        *  common thing to do will be to get the length.  If the length is unknown,
  @@ -230,7 +230,7 @@
   };
   
   /** A list of buckets */
  -struct ap_bucket_brigade {
  +struct apr_bucket_brigade {
       /** The pool to associate the brigade with.  The data is not allocated out
        *  of the pool, but a cleanup is registered with this pool.  If the 
        *  brigade is destroyed by some mechanism other than pool destruction,
  @@ -239,13 +239,13 @@
       apr_pool_t *p;
       /** The buckets in the brigade are on this list. */
       /*
  -     * XXX: the ap_bucket_list structure doesn't actually need a name tag
  -     * because it has no existence independent of struct ap_bucket_brigade;
  +     * XXX: the apr_bucket_list structure doesn't actually need a name tag
  +     * because it has no existence independent of struct apr_bucket_brigade;
        * the ring macros are designed so that you can leave the name tag
        * argument empty in this situation but apparently the Windows compiler
        * doesn't like that.
        */
  -    AP_RING_HEAD(ap_bucket_list, ap_bucket) list;
  +    APR_RING_HEAD(apr_bucket_list, apr_bucket) list;
   };
   
   /**
  @@ -256,32 +256,32 @@
    * Determine if this bucket is the start of the list
    * @param b The bucket to test
    * @return true or false
  - * @deffunc int AP_BRIGADE_SENTINEL(ap_bucket *b)
  + * @deffunc int APR_BRIGADE_SENTINEL(apr_bucket *b)
    */
  -#define AP_BRIGADE_SENTINEL(b)	AP_RING_SENTINEL(&(b)->list, ap_bucket, link)
  +#define APR_BRIGADE_SENTINEL(b)	APR_RING_SENTINEL(&(b)->list, apr_bucket, link)
   
   /**
    * Determine if the bucket brigade is empty
    * @param b The brigade to check
    * @return true or false
  - * @deffunc AP_BRIGADE_EMPTY(ap_bucket_brigade *b)
  + * @deffunc APR_BRIGADE_EMPTY(apr_bucket_brigade *b)
    */
  -#define AP_BRIGADE_EMPTY(b)	AP_RING_EMPTY(&(b)->list, ap_bucket, link)
  +#define APR_BRIGADE_EMPTY(b)	APR_RING_EMPTY(&(b)->list, apr_bucket, link)
   
   /**
    * Return the first bucket in a brigade
    * @param b The brigade to query
    * @return The first bucket in the brigade
  - * @deffunc ap_bucket *AP_BUCKET_FIRST(ap_bucket_brigade *b)
  + * @deffunc apr_bucket *APR_BUCKET_FIRST(apr_bucket_brigade *b)
    */
  -#define AP_BRIGADE_FIRST(b)	AP_RING_FIRST(&(b)->list)
  +#define APR_BRIGADE_FIRST(b)	APR_RING_FIRST(&(b)->list)
   /**
    * Return the last bucket in a brigade
    * @param b The brigade to query
    * @return The last bucket in the brigade
  - * @deffunc ap_bucket *AP_BUCKET_LAST(ap_bucket_brigade *b)
  + * @deffunc apr_bucket *APR_BUCKET_LAST(apr_bucket_brigade *b)
    */
  -#define AP_BRIGADE_LAST(b)	AP_RING_LAST(&(b)->list)
  +#define APR_BRIGADE_LAST(b)	APR_RING_LAST(&(b)->list)
   
   /**
    * Iterate through a bucket brigade
  @@ -289,155 +289,155 @@
    * @param b The brigade to iterate over
    * @tip This is the same as either:
    * <pre>
  - *		e = AP_BUCKET_FIRST(b);
  - * 		while (!AP_BUCKET_SENTINEL(e)) {
  + *		e = APR_BUCKET_FIRST(b);
  + * 		while (!APR_BUCKET_SENTINEL(e)) {
    *		    ...
  - * 		    e = AP_BUCKET_NEXT(e);
  + * 		    e = APR_BUCKET_NEXT(e);
    * 		}
    *     OR
  - * 		for (e = AP_BUCKET_FIRST(b); !AP_BUCKET_SENTINEL(e); e = AP_BUCKET_NEXT(e)) {
  + * 		for (e = APR_BUCKET_FIRST(b); !APR_BUCKET_SENTINEL(e); e = APR_BUCKET_NEXT(e)) {
    *		    ...
    * 		}
  - * @deffunc void AP_BRIGADE_FOREACH(ap_bucket *e, ap_bucket_brigade *b)
  + * @deffunc void APR_BRIGADE_FOREACH(apr_bucket *e, apr_bucket_brigade *b)
    */
  -#define AP_BRIGADE_FOREACH(e, b)					\
  -	AP_RING_FOREACH((e), &(b)->list, ap_bucket, link)
  +#define APR_BRIGADE_FOREACH(e, b)					\
  +	APR_RING_FOREACH((e), &(b)->list, apr_bucket, link)
   
   /**
    * Insert a list of buckets at the front of a brigade
    * @param b The brigade to add to
    * @param e The first bucket in a list of buckets to insert
  - * @deffunc void AP_BRIGADE_INSERT_HEAD(ap_bucket_brigade *b, ap_bucket *e)
  + * @deffunc void APR_BRIGADE_INSERT_HEAD(apr_bucket_brigade *b, apr_bucket *e)
    */
  -#define AP_BRIGADE_INSERT_HEAD(b, e)					\
  -	AP_RING_INSERT_HEAD(&(b)->list, (e), ap_bucket, link)
  +#define APR_BRIGADE_INSERT_HEAD(b, e)					\
  +	APR_RING_INSERT_HEAD(&(b)->list, (e), apr_bucket, link)
   /**
    * Insert a list of buckets at the end of a brigade
    * @param b The brigade to add to
    * @param e The first bucket in a list of buckets to insert
  - * @deffunc void AP_BRIGADE_INSERT_HEAD(ap_bucket_brigade *b, ap_bucket *e)
  + * @deffunc void APR_BRIGADE_INSERT_HEAD(apr_bucket_brigade *b, apr_bucket *e)
    */
  -#define AP_BRIGADE_INSERT_TAIL(b, e)					\
  -	AP_RING_INSERT_TAIL(&(b)->list, (e), ap_bucket, link)
  +#define APR_BRIGADE_INSERT_TAIL(b, e)					\
  +	APR_RING_INSERT_TAIL(&(b)->list, (e), apr_bucket, link)
   
   /**
    * Concatenate two brigades together
    * @param a The first brigade
    * @param b The second brigade
  - * @deffunc void AP_BRIGADE_CONCAT(ap_bucket_brigade *a, ap_bucket_brigade *b)
  + * @deffunc void APR_BRIGADE_CONCAT(apr_bucket_brigade *a, apr_bucket_brigade *b)
    */
  -#define AP_BRIGADE_CONCAT(a, b)						\
  -	AP_RING_CONCAT(&(a)->list, &(b)->list, ap_bucket, link)
  +#define APR_BRIGADE_CONCAT(a, b)						\
  +	APR_RING_CONCAT(&(a)->list, &(b)->list, apr_bucket, link)
   
   /**
    * Insert a list of buckets before a specified bucket
    * @param a The buckets to insert
    * @param b The bucket to insert before
  - * @deffunc void AP_BUCKET_INSERT_BEFORE(ap_bucket *a, ap_bucket *b)
  + * @deffunc void APR_BUCKET_INSERT_BEFORE(apr_bucket *a, apr_bucket *b)
    */
  -#define AP_BUCKET_INSERT_BEFORE(a, b)					\
  -	AP_RING_INSERT_BEFORE((a), (b), link)
  +#define APR_BUCKET_INSERT_BEFORE(a, b)					\
  +	APR_RING_INSERT_BEFORE((a), (b), link)
   /**
    * Insert a list of buckets after a specified bucket
    * @param a The buckets to insert
    * @param b The bucket to insert after
  - * @deffunc void AP_BUCKET_INSERT_AFTER(ap_bucket *a, ap_bucket *b)
  + * @deffunc void APR_BUCKET_INSERT_AFTER(apr_bucket *a, apr_bucket *b)
    */
  -#define AP_BUCKET_INSERT_AFTER(a, b)					\
  -	AP_RING_INSERT_AFTER((a), (b), link)
  +#define APR_BUCKET_INSERT_AFTER(a, b)					\
  +	APR_RING_INSERT_AFTER((a), (b), link)
   
   /**
    * Get the next bucket in the list
    * @param e The current bucket
    * @return The next bucket
  - * @deffunc ap_bucket *AP_BUCKET_NEXT(ap_bucket *e)
  + * @deffunc apr_bucket *APR_BUCKET_NEXT(apr_bucket *e)
    */
  -#define AP_BUCKET_NEXT(e)	AP_RING_NEXT((e), link)
  +#define APR_BUCKET_NEXT(e)	APR_RING_NEXT((e), link)
   /**
    * Get the previous bucket in the list
    * @param e The current bucket
    * @return The previous bucket
  - * @deffunc ap_bucket *AP_BUCKET_PREV(ap_bucket *e)
  + * @deffunc apr_bucket *APR_BUCKET_PREV(apr_bucket *e)
    */
  -#define AP_BUCKET_PREV(e)	AP_RING_PREV((e), link)
  +#define APR_BUCKET_PREV(e)	APR_RING_PREV((e), link)
   
   /**
    * Remove a bucket from its bucket brigade
    * @param e The bucket to remove
  - * @deffunc void AP_BUCKET_REMOVE(ap_bucket *e)
  + * @deffunc void APR_BUCKET_REMOVE(apr_bucket *e)
    */
  -#define AP_BUCKET_REMOVE(e)	AP_RING_REMOVE((e), link)
  +#define APR_BUCKET_REMOVE(e)	APR_RING_REMOVE((e), link)
   
   /**
    * Determine if a bucket is a FLUSH bucket
    * @param e The bucket to inspect
    * @return true or false
  - * @deffunc int AP_BUCKET_IS_FLUSH(ap_bucket *e)
  + * @deffunc int APR_BUCKET_IS_FLUSH(apr_bucket *e)
    */
  -#define AP_BUCKET_IS_FLUSH(e)       (e->type == &ap_flush_type)
  +#define APR_BUCKET_IS_FLUSH(e)       (e->type == &apr_bucket_type_flush)
   /**
    * Determine if a bucket is an EOS bucket
    * @param e The bucket to inspect
    * @return true or false
  - * @deffunc int AP_BUCKET_IS_EOS(ap_bucket *e)
  + * @deffunc int APR_BUCKET_IS_EOS(apr_bucket *e)
    */
  -#define AP_BUCKET_IS_EOS(e)         (e->type == &ap_eos_type)
  +#define APR_BUCKET_IS_EOS(e)         (e->type == &apr_bucket_type_eos)
   /**
    * Determine if a bucket is a FILE bucket
    * @param e The bucket to inspect
    * @return true or false
  - * @deffunc int AP_BUCKET_IS_FILE(ap_bucket *e)
  + * @deffunc int APR_BUCKET_IS_FILE(apr_bucket *e)
    */
  -#define AP_BUCKET_IS_FILE(e)        (e->type == &ap_file_type)
  +#define APR_BUCKET_IS_FILE(e)        (e->type == &apr_bucket_type_file)
   /**
    * Determine if a bucket is a PIPE bucket
    * @param e The bucket to inspect
    * @return true or false
  - * @deffunc int AP_BUCKET_IS_PIPE(ap_bucket *e)
  + * @deffunc int APR_BUCKET_IS_PIPE(apr_bucket *e)
    */
  -#define AP_BUCKET_IS_PIPE(e)        (e->type == &ap_pipe_type)
  +#define APR_BUCKET_IS_PIPE(e)        (e->type == &apr_bucket_type_pipe)
   /**
    * Determine if a bucket is a SOCKET bucket
    * @param e The bucket to inspect
    * @return true or false
  - * @deffunc int AP_BUCKET_IS_SOCKET(ap_bucket *e)
  + * @deffunc int APR_BUCKET_IS_SOCKET(apr_bucket *e)
    */
  -#define AP_BUCKET_IS_SOCKET(e)      (e->type == &ap_socket_type)
  +#define APR_BUCKET_IS_SOCKET(e)      (e->type == &apr_bucket_type_socket)
   /**
    * Determine if a bucket is a HEAP bucket
    * @param e The bucket to inspect
    * @return true or false
  - * @deffunc int AP_BUCKET_IS_HEAP(ap_bucket *e)
  + * @deffunc int APR_BUCKET_IS_HEAP(apr_bucket *e)
    */
  -#define AP_BUCKET_IS_HEAP(e)        (e->type == &ap_heap_type)
  +#define APR_BUCKET_IS_HEAP(e)        (e->type == &apr_bucket_type_heap)
   /**
    * Determine if a bucket is a TRANSIENT bucket
    * @param e The bucket to inspect
    * @return true or false
  - * @deffunc int AP_BUCKET_IS_TRANSIENT(ap_bucket *e)
  + * @deffunc int APR_BUCKET_IS_TRANSIENT(apr_bucket *e)
    */
  -#define AP_BUCKET_IS_TRANSIENT(e)   (e->type == &ap_transient_type)
  +#define APR_BUCKET_IS_TRANSIENT(e)   (e->type == &apr_bucket_type_transient)
   /**
    * Determine if a bucket is a IMMORTAL bucket
    * @param e The bucket to inspect
    * @return true or false
  - * @deffunc int AP_BUCKET_IS_IMMORTAL(ap_bucket *e)
  + * @deffunc int APR_BUCKET_IS_IMMORTAL(apr_bucket *e)
    */
  -#define AP_BUCKET_IS_IMMORTAL(e)    (e->type == &ap_immortal_type)
  +#define APR_BUCKET_IS_IMMORTAL(e)    (e->type == &apr_bucket_type_immortal)
   /**
    * Determine if a bucket is a MMAP bucket
    * @param e The bucket to inspect
    * @return true or false
  - * @deffunc int AP_BUCKET_IS_MMAP(ap_bucket *e)
  + * @deffunc int APR_BUCKET_IS_MMAP(apr_bucket *e)
    */
  -#define AP_BUCKET_IS_MMAP(e)        (e->type == &ap_mmap_type)
  +#define APR_BUCKET_IS_MMAP(e)        (e->type == &apr_bucket_type_mmap)
   /**
    * Determine if a bucket is a POOL bucket
    * @param e The bucket to inspect
    * @return true or false
  - * @deffunc int AP_BUCKET_IS_POOL(ap_bucket *e)
  + * @deffunc int APR_BUCKET_IS_POOL(apr_bucket *e)
    */
  -#define AP_BUCKET_IS_POOL(e)        (e->type == &ap_pool_type)
  +#define APR_BUCKET_IS_POOL(e)        (e->type == &apr_bucket_type_pool)
   
   /*
    * General-purpose reference counting for the varous bucket types.
  @@ -449,84 +449,84 @@
    * occur because of bucket splits or buckets that refer to globally
    * cached data. */
   
  -typedef struct ap_bucket_refcount ap_bucket_refcount;
  +typedef struct apr_bucket_refcount apr_bucket_refcount;
   /**
    * The structure used to manage the shared resource must start with an
  - * ap_bucket_refcount which is updated by the general-purpose refcount
  + * apr_bucket_refcount which is updated by the general-purpose refcount
    * code. A pointer to the bucket-type-dependent private data structure
  - * can be cast to a pointer to an ap_bucket_refcount and vice versa.
  + * can be cast to a pointer to an apr_bucket_refcount and vice versa.
    */
  -struct ap_bucket_refcount {
  +struct apr_bucket_refcount {
       /** The number of references to this bucket */
       int          refcount;
   };
   
  -typedef struct ap_bucket_shared ap_bucket_shared;
  +typedef struct apr_bucket_shared apr_bucket_shared;
   /**
    * The data pointer of a refcounted bucket points to an
  - * ap_bucket_shared structure which describes the region of the shared
  - * object that this bucket refers to. The ap_bucket_shared isn't a
  + * apr_bucket_shared structure which describes the region of the shared
  + * object that this bucket refers to. The apr_bucket_shared isn't a
    * fully-fledged bucket type: it is a utility type that proper bucket
    * types are based on.
    */
  -struct ap_bucket_shared {
  +struct apr_bucket_shared {
       /** start of the data in the bucket relative to the private base pointer */
       apr_off_t start;
       /** end of the data in the bucket relative to the private base pointer */
       apr_off_t end;
       /** pointer to the real private data of the bucket,
  -     * which starts with an ap_bucket_refcount */
  +     * which starts with an apr_bucket_refcount */
       void *data;
   };
   
   /*  *****  Non-reference-counted bucket types  *****  */
   
   
  -typedef struct ap_bucket_simple ap_bucket_simple;
  +typedef struct apr_bucket_simple apr_bucket_simple;
   /**
    * TRANSIENT and IMMORTAL buckets don't have much to do with looking
    * after the memory that they refer to so they share a lot of their
    * implementation.
    */
  -struct ap_bucket_simple {
  +struct apr_bucket_simple {
       /** The start of the data in the bucket */
       const char    *start;
       /** The end of the data in the bucket */
       const char    *end;
   };
   
  -typedef struct ap_bucket_pool ap_bucket_pool;
  +typedef struct apr_bucket_pool apr_bucket_pool;
   /**
    * A bucket referring to data allocated out of a pool
    */
  -struct ap_bucket_pool {
  +struct apr_bucket_pool {
       /** Number of buckets using this memory */
  -    ap_bucket_refcount  refcount;
  +    apr_bucket_refcount  refcount;
       /** The start of the data actually allocated.  This should never be
        * modified, it is only used to free the bucket.
        */
       const char *base;
       /** The pool the data was allocated out of */
       apr_pool_t  *p;
  -    /** This is a hack, because we call ap_destroy_bucket with the ->data
  +    /** This is a hack, because we call apr_destroy_bucket with the ->data
        *  pointer, so the pool cleanup needs to be registered with that pointer,
        *  but the whole point of the cleanup is to convert the bucket to another
        *  type.  To do that conversion, we need a pointer to the bucket itself.
        *  This gives us a pointer to the original bucket.
        */
  -    ap_bucket *b;
  +    apr_bucket *b;
   };
   
   /*  *****  Reference-counted bucket types  *****  */
   
   
  -typedef struct ap_bucket_heap ap_bucket_heap;
  +typedef struct apr_bucket_heap apr_bucket_heap;
   /**
    * A bucket referring to data allocated off the heap.
    */
  -struct ap_bucket_heap {
  +struct apr_bucket_heap {
       /** Number of buckets using this memory */
  -    ap_bucket_refcount  refcount;
  +    apr_bucket_refcount  refcount;
       /** The start of the data actually allocated.  This should never be
        * modified, it is only used to free the bucket.
        */
  @@ -535,22 +535,22 @@
       size_t  alloc_len;
   };
   
  -typedef struct ap_bucket_mmap ap_bucket_mmap;
  +typedef struct apr_bucket_mmap apr_bucket_mmap;
   /**
    * A bucket referring to an mmap()ed file
    */
  -struct ap_bucket_mmap {
  +struct apr_bucket_mmap {
       /** Number of buckets using this memory */
  -    ap_bucket_refcount  refcount;
  +    apr_bucket_refcount  refcount;
       /** The mmap this sub_bucket refers to */
       apr_mmap_t *mmap;
   };
   
  -typedef struct ap_bucket_file ap_bucket_file;
  +typedef struct apr_bucket_file apr_bucket_file;
   /**
    * A bucket referring to an file
    */
  -struct ap_bucket_file {
  +struct apr_bucket_file {
       /** The file this bucket refers to */
       apr_file_t *fd;
       /** The offset into the file */
  @@ -563,17 +563,17 @@
    * @param The pool to associate with the brigade.  Data is not allocated out
    *        of the pool, but a cleanup is registered.
    * @return The empty bucket brigade
  - * @deffunc ap_bucket_brigade *ap_brigade_create(apr_pool_t *p)
  + * @deffunc apr_bucket_brigade *apr_brigade_create(apr_pool_t *p)
    */
  -APU_DECLARE(ap_bucket_brigade *) ap_brigade_create(apr_pool_t *p);
  +APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p);
   
   /**
    * destroy an entire bucket brigade.  This includes destroying all of the
    * buckets within the bucket brigade's bucket list. 
    * @param b The bucket brigade to destroy
  - * @deffunc apr_status_t ap_brigade_destroy(ap_bucket_brigade *b)
  + * @deffunc apr_status_t apr_brigade_destroy(apr_bucket_brigade *b)
    */
  -APU_DECLARE(apr_status_t) ap_brigade_destroy(ap_bucket_brigade *b);
  +APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b);
   
   /**
    * Split a bucket brigade into two, such that the given bucket is the
  @@ -583,10 +583,10 @@
    * @param b The brigade to split
    * @param e The first element of the new brigade
    * @return The new brigade
  - * @deffunc ap_bucket_brigade *ap_brigade_split(ap_bucket_brigade *b, ap_bucket *e)
  + * @deffunc apr_bucket_brigade *apr_brigade_split(apr_bucket_brigade *b, apr_bucket *e)
    */
  -APU_DECLARE(ap_bucket_brigade *) ap_brigade_split(ap_bucket_brigade *b,
  -						  ap_bucket *e);
  +APU_DECLARE(apr_bucket_brigade *) apr_brigade_split(apr_bucket_brigade *b,
  +						  apr_bucket *e);
   
   /**
    * Partition a bucket brigade at a given offset (in bytes from the start of
  @@ -596,19 +596,19 @@
    * @param point The offset at which to partition the brigade
    * @return A pointer to the first bucket after the partition;
    *         or NULL in any error condition (including partition past the end)
  - * @deffunc ap_bucket *ap_brigade_partition(ap_bucket_brigade *b, apr_off_t point)
  + * @deffunc apr_bucket *apr_brigade_partition(apr_bucket_brigade *b, apr_off_t point)
    */
  -APU_DECLARE(ap_bucket *) ap_brigade_partition(ap_bucket_brigade *b, apr_off_t point);
  +APU_DECLARE(apr_bucket *) apr_brigade_partition(apr_bucket_brigade *b, apr_off_t point);
   
   #if APR_NOT_DONE_YET
   /**
  - * consume nbytes from beginning of b -- call ap_bucket_destroy as
  + * consume nbytes from beginning of b -- call apr_bucket_destroy as
    * appropriate, and/or modify start on last element 
    * @param b The brigade to consume data from
    * @param nbytes The number of bytes to consume
  - * @deffunc void ap_brigade_consume(ap_bucket_brigade *b, int nbytes)
  + * @deffunc void apr_brigade_consume(apr_bucket_brigade *b, int nbytes)
    */
  -APU_DECLARE(void) ap_brigade_consume(ap_bucket_brigade *b, int nbytes);
  +APU_DECLARE(void) apr_brigade_consume(apr_bucket_brigade *b, int nbytes);
   #endif
   
   /**
  @@ -619,9 +619,9 @@
    * @param The iovec to create
    * @param The number of elements in the iovec
    * @return The number of iovec elements actually filled out.
  - * @deffunc int ap_brigade_to_iovec(ap_bucket_brigade *b, struct iovec *vec, int nvec);
  + * @deffunc int apr_brigade_to_iovec(apr_bucket_brigade *b, struct iovec *vec, int nvec);
    */
  -APU_DECLARE(int) ap_brigade_to_iovec(ap_bucket_brigade *b, 
  +APU_DECLARE(int) apr_brigade_to_iovec(apr_bucket_brigade *b, 
   				     struct iovec *vec, int nvec);
   
   /**
  @@ -630,9 +630,9 @@
    * @param b The bucket brigade to add to
    * @param va A list of strings to add
    * @return The number of bytes added to the brigade
  - * @deffunc int ap_brigade_vputstrs(ap_bucket_brigade *b, va_list va)
  + * @deffunc int apr_brigade_vputstrs(apr_bucket_brigade *b, va_list va)
    */
  -APU_DECLARE(int) ap_brigade_vputstrs(ap_bucket_brigade *b, va_list va);
  +APU_DECLARE(int) apr_brigade_vputstrs(apr_bucket_brigade *b, va_list va);
   
   /**
    * This function writes an unspecified number of strings into a bucket brigade.
  @@ -640,9 +640,9 @@
    * @param b The bucket brigade to add to
    * @param ... The strings to add
    * @return The number of bytes added to the brigade
  - * @deffunc int ap_brigade_putstrs(ap_bucket_brigade *b, ...)
  + * @deffunc int apr_brigade_putstrs(apr_bucket_brigade *b, ...)
    */
  -APU_DECLARE_NONSTD(int) ap_brigade_putstrs(ap_bucket_brigade *b, ...);
  +APU_DECLARE_NONSTD(int) apr_brigade_putstrs(apr_bucket_brigade *b, ...);
   
   /**
    * Evaluate a printf and put the resulting string into a bucket at the end 
  @@ -651,9 +651,9 @@
    * @param fmt The format of the string to write
    * @param ... The arguments to fill out the format
    * @return The number of bytes added to the brigade
  - * @deffunc int ap_brigade_printf(ap_bucket_brigade *b, const char *fmt, ...) 
  + * @deffunc int apr_brigade_printf(apr_bucket_brigade *b, const char *fmt, ...) 
    */
  -APU_DECLARE_NONSTD(int) ap_brigade_printf(ap_bucket_brigade *b, 
  +APU_DECLARE_NONSTD(int) apr_brigade_printf(apr_bucket_brigade *b, 
                                             const char *fmt, ...);
   
   /**
  @@ -663,9 +663,9 @@
    * @param fmt The format of the string to write
    * @param va The arguments to fill out the format
    * @return The number of bytes added to the brigade
  - * @deffunc int ap_brigade_vprintf(ap_bucket_brigade *b, const char *fmt, va_list va) 
  + * @deffunc int apr_brigade_vprintf(apr_bucket_brigade *b, const char *fmt, va_list va) 
    */
  -APU_DECLARE(int) ap_brigade_vprintf(ap_bucket_brigade *b, 
  +APU_DECLARE(int) apr_brigade_vprintf(apr_bucket_brigade *b, 
                                       const char *fmt, va_list va);
   
   
  @@ -674,17 +674,17 @@
    * Initialize the core implemented bucket types.  Once this is done,
    * it is possible to add new bucket types to the server
    * @param p The pool to allocate the array out of.
  - * @deffunc void ap_init_bucket_types(apr_pool_t *p)
  + * @deffunc void apr_init_bucket_types(apr_pool_t *p)
    */
  -APU_DECLARE(void) ap_init_bucket_types(apr_pool_t *p);
  +APU_DECLARE(void) apr_init_bucket_types(apr_pool_t *p);
   
   /**
    * free the resources used by a bucket. If multiple buckets refer to
    * the same resource it is freed when the last one goes away.
    * @param e The bucket to destroy
  - * @deffunc void ap_bucket_destroy(ap_bucket *e)
  + * @deffunc void apr_bucket_destroy(apr_bucket *e)
    */
  -#define ap_bucket_destroy(e) \
  +#define apr_bucket_destroy(e) \
       { \
       e->type->destroy(e->data); \
       free(e); \
  @@ -696,33 +696,33 @@
    * @param str The location to store the data in
    * @param len The amount of data read
    * @param block Whether the read function blocks
  - * @deffunc apr_status_t ap_bucket_read(ap_bucket *e, const char **str, apr_size_t *len, ap_read_type block)
  + * @deffunc apr_status_t apr_bucket_read(apr_bucket *e, const char **str, apr_size_t *len, apr_read_type_e block)
    */
  -#define ap_bucket_read(e,str,len,block) e->type->read(e, str, len, block)
  +#define apr_bucket_read(e,str,len,block) e->type->read(e, str, len, block)
   
   /**
    * Setaside data so that stack data is not destroyed on returning from
    * the function
    * @param e The bucket to setaside
  - * @deffunc apr_status_t ap_bucket_setaside(ap_bucket *e)
  + * @deffunc apr_status_t apr_bucket_setaside(apr_bucket *e)
    */
  -#define ap_bucket_setaside(e) e->type->setaside(e)
  +#define apr_bucket_setaside(e) e->type->setaside(e)
   
   /**
    * Split one bucket in two.
    * @param e The bucket to split
    * @param point The offset to split the bucket at
  - * @deffunc apr_status_t ap_bucket_split(ap_bucket *e, apr_off_t point)
  + * @deffunc apr_status_t apr_bucket_split(apr_bucket *e, apr_off_t point)
    */
  -#define ap_bucket_split(e,point) e->type->split(e, point)
  +#define apr_bucket_split(e,point) e->type->split(e, point)
   
   /**
    * Copy a bucket.
    * @param e The bucket to copy
    * @param c Returns a pointer to the new bucket
  - * @deffunc apr_status_t ap_bucket_copy(ap_bucket *e, ap_bucket **c)
  + * @deffunc apr_status_t apr_bucket_copy(apr_bucket *e, apr_bucket **c)
    */
  -#define ap_bucket_copy(e,c) e->type->copy(e, c)
  +#define apr_bucket_copy(e,c) e->type->copy(e, c)
   
   /* Bucket type handling */
   
  @@ -731,9 +731,9 @@
    * implemented for this bucket
    * @param data The bucket to setaside
    * @return APR_ENOTIMPL
  - * @deffunc apr_status_t ap_bucket_setaside_notimpl(ap_bucket *data)
  + * @deffunc apr_status_t apr_bucket_setaside_notimpl(apr_bucket *data)
    */ 
  -APU_DECLARE_NONSTD(apr_status_t) ap_bucket_setaside_notimpl(ap_bucket *data);
  +APU_DECLARE_NONSTD(apr_status_t) apr_bucket_setaside_notimpl(apr_bucket *data);
   
   /**
    * A place holder function that signifies that the split function was not
  @@ -741,10 +741,10 @@
    * @param data The bucket to split
    * @param point The location to split the bucket
    * @return APR_ENOTIMPL
  - * @deffunc apr_status_t ap_bucket_split_notimpl(ap_bucket *data, apr_off_t point)
  + * @deffunc apr_status_t apr_bucket_split_notimpl(apr_bucket *data, apr_off_t point)
    */ 
   APU_DECLARE_NONSTD(apr_status_t) 
  -                       ap_bucket_split_notimpl(ap_bucket *data, 
  +                       apr_bucket_split_notimpl(apr_bucket *data, 
                                                  apr_off_t point);
   
   /**
  @@ -753,20 +753,20 @@
    * @param e The bucket to copy
    * @param c Returns a pointer to the new bucket
    * @return APR_ENOTIMPL
  - * @deffunc apr_status_t ap_bucket_copy_notimpl(ap_bucket *e, ap_bucket **c)
  + * @deffunc apr_status_t apr_bucket_copy_notimpl(apr_bucket *e, apr_bucket **c)
    */
   APU_DECLARE_NONSTD(apr_status_t) 
  -                       ap_bucket_copy_notimpl(ap_bucket *e, ap_bucket **c);
  +                       apr_bucket_copy_notimpl(apr_bucket *e, apr_bucket **c);
   
   /**
    * A place holder function that signifies that the destroy function was not
    * implemented for this bucket
    * @param data The bucket to destroy
  - * @deffunc void ap_bucket_destroy(ap_bucket *data)
  + * @deffunc void apr_bucket_destroy(apr_bucket *data)
    */ 
  -APU_DECLARE_NONSTD(void) ap_bucket_destroy_notimpl(void *data);
  +APU_DECLARE_NONSTD(void) apr_bucket_destroy_notimpl(void *data);
   
  -/* There is no ap_bucket_read_notimpl, because it is a required function
  +/* There is no apr_bucket_read_notimpl, because it is a required function
    */
   
   /**
  @@ -774,59 +774,59 @@
    * @param type The new bucket type to register
    * @return The offset into the array in which the bucket types are stored
    */
  -int ap_insert_bucket_type(const ap_bucket_type *type);
  +int apr_insert_bucket_type(const apr_bucket_type_t *type);
   
   /* All of the bucket types implemented by the core */
   /**
    * 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 ap_bucket_type ap_flush_type;
  +APU_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 ap_bucket_type ap_eos_type;
  +APU_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 ap_bucket_type ap_file_type;
  +APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_file;
   /**
    * The HEAP bucket type.  This bucket represents a data allocated out of the
    * heap.
    */
  -APU_DECLARE_DATA extern const ap_bucket_type ap_heap_type;
  +APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_heap;
   /**
    * The MMAP bucket type.  This bucket represents an MMAP'ed file
    */
  -APU_DECLARE_DATA extern const ap_bucket_type ap_mmap_type;
  +APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_mmap;
   /**
    * The POOL bucket type.  This bucket represents a data that was allocated
    * out of 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 ap_bucket_type ap_pool_type;
  +APU_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 ap_bucket_type ap_pipe_type;
  +APU_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 responsability for.  The core will do
    * nothing with the data in an immortal bucket
    */
  -APU_DECLARE_DATA extern const ap_bucket_type ap_immortal_type;
  +APU_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 ap_bucket_type ap_transient_type;
  +APU_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 ap_bucket_type ap_socket_type;
  +APU_DECLARE_DATA extern const apr_bucket_type_t apr_bucket_type_socket;
   
   /*  *****  Shared reference-counted buckets  *****  */
   
  @@ -845,23 +845,23 @@
    * @param end The end of the data in the bucket
    *            relative to the private base pointer
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_make_shared(ap_bucket_refcount *r, apr_off_t start, apr_off_t end) 
  + * @deffunc apr_bucket *apr_bucket_make_shared(apr_bucket_refcount *r, apr_off_t start, apr_off_t end) 
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_make_shared(ap_bucket *b, void *data,
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_make_shared(apr_bucket *b, void *data,
   				      apr_off_t start, apr_off_t end);
   
   /**
    * Decrement the refcount of the data in the bucket and free the
  - * ap_bucket_shared structure. This function should only be called by
  + * apr_bucket_shared structure. This function should only be called by
    * type-specific bucket destruction functions.
    * @param data The private data pointer from the bucket to be destroyed
    * @return NULL if nothing needs to be done,
    *         otherwise a pointer to the private data structure which
    *         must be destroyed because its reference count is zero
  - * @deffunc void *ap_bucket_destroy_shared(ap_bucket *b)
  + * @deffunc void *apr_bucket_destroy_shared(apr_bucket *b)
    */
  -APU_DECLARE(void *) ap_bucket_destroy_shared(void *data);
  +APU_DECLARE(void *) apr_bucket_destroy_shared(void *data);
   
   /**
    * Split a bucket into two at the given point, and adjust the refcount
  @@ -873,10 +873,10 @@
    * @return APR_EINVAL if the point is not within the bucket;
    *         APR_ENOMEM if allocation failed;
    *         or APR_SUCCESS
  - * @deffunc apr_status_t ap_bucket_split_shared(ap_bucket *b, apr_off_t point)
  + * @deffunc apr_status_t apr_bucket_split_shared(apr_bucket *b, apr_off_t point)
    */
   APU_DECLARE_NONSTD(apr_status_t) 
  -                       ap_bucket_split_shared(ap_bucket *b, apr_off_t point);
  +                       apr_bucket_split_shared(apr_bucket *b, apr_off_t point);
   
   /**
    * Copy a refcounted bucket, incrementing the reference count. Most
  @@ -886,30 +886,30 @@
    * @param c Returns a pointer to the new bucket
    * @return APR_ENOMEM if allocation failed;
              or APR_SUCCESS
  - * @deffunc apr_status_t ap_bucket_copy_shared(ap_bucket *a, ap_bucket **c)
  + * @deffunc apr_status_t apr_bucket_copy_shared(apr_bucket *a, apr_bucket **c)
    */
   APU_DECLARE_NONSTD(apr_status_t) 
  -                       ap_bucket_copy_shared(ap_bucket *a, ap_bucket **c);
  +                       apr_bucket_copy_shared(apr_bucket *a, apr_bucket **c);
   
   
   /*  *****  Functions to Create Buckets of varying type  *****  */
   /*
    * Each bucket type foo has two initialization functions:
  - * ap_bucket_make_foo which sets up some already-allocated memory as a
  - * bucket of type foo; and ap_bucket_create_foo which allocates memory
  - * for the bucket, calls ap_bucket_make_foo, and initializes the
  - * bucket's list pointers. The ap_bucket_make_foo functions are used
  + * apr_bucket_make_foo which sets up some already-allocated memory as a
  + * bucket of type foo; and apr_bucket_create_foo which allocates memory
  + * for the bucket, calls apr_bucket_make_foo, and initializes the
  + * bucket's list pointers. The apr_bucket_make_foo functions are used
    * inside the bucket code to change the type of buckets in place;
  - * other code should call ap_bucket_create_foo. All the initialization
  + * other code should call apr_bucket_create_foo. All the initialization
    * functions change nothing if they fail.
    */
   
   /*
  - * This macro implements the guts of ap_bucket_create_foo
  + * This macro implements the guts of apr_bucket_create_foo
    */
  -#define ap_bucket_do_create(do_make)		\
  +#define apr_bucket_do_create(do_make)		\
       do {					\
  -	ap_bucket *b, *ap__b;			\
  +	apr_bucket *b, *ap__b;			\
   	b = calloc(1, sizeof(*b));		\
   	if (b == NULL) {			\
   	    return NULL;			\
  @@ -919,7 +919,7 @@
   	    free(b);				\
   	    return NULL;			\
   	}					\
  -	AP_RING_ELEM_INIT(ap__b, link);		\
  +	APR_RING_ELEM_INIT(ap__b, link);		\
   	return ap__b;				\
       } while(0)
   
  @@ -927,9 +927,9 @@
    * Create an End of Stream bucket.  This indicates that there is no more data
    * coming from down the filter stack.  All filters should flush at this point.
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_create_eos(void)
  + * @deffunc apr_bucket *apr_bucket_create_eos(void)
    */
  -APU_DECLARE(ap_bucket *) ap_bucket_create_eos(void);
  +APU_DECLARE(apr_bucket *) apr_bucket_create_eos(void);
   
   /**
    * Make the bucket passed in an EOS bucket.  This indicates that there is no 
  @@ -937,18 +937,18 @@
    * this point.
    * @param b The bucket to make into an EOS bucket
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_make_eos(ap_bucket *b)
  + * @deffunc apr_bucket *apr_bucket_make_eos(apr_bucket *b)
    */
  -APU_DECLARE(ap_bucket *) ap_bucket_make_eos(ap_bucket *b);
  +APU_DECLARE(apr_bucket *) apr_bucket_make_eos(apr_bucket *b);
   
   /**
    * Create a flush  bucket.  This indicates that filters should flush their
    * data.  There is no guarantee that they will flush it, but this is the
    * best we can do.
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_create_flush(void)
  + * @deffunc apr_bucket *apr_bucket_create_flush(void)
    */
  -APU_DECLARE(ap_bucket *) ap_bucket_create_flush(void);
  +APU_DECLARE(apr_bucket *) apr_bucket_create_flush(void);
   
   /**
    * Make the bucket passed in a FLUSH  bucket.  This indicates that filters 
  @@ -956,19 +956,19 @@
    * but this is the best we can do.
    * @param b The bucket to make into a FLUSH bucket
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_make_flush(ap_bucket *b)
  + * @deffunc apr_bucket *apr_bucket_make_flush(apr_bucket *b)
    */
  -APU_DECLARE(ap_bucket *) ap_bucket_make_flush(ap_bucket *b);
  +APU_DECLARE(apr_bucket *) apr_bucket_make_flush(apr_bucket *b);
   
   /**
    * Create a bucket referring to long-lived data.
    * @param buf The data to insert into the bucket
    * @param nbyte The size of the data to insert.
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_create_immortal(const char *buf, apr_size_t nbyte, apr_size_t *w)
  + * @deffunc apr_bucket *apr_bucket_create_immortal(const char *buf, apr_size_t nbyte, apr_size_t *w)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_create_immortal(const char *buf, apr_size_t nbyte);
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_create_immortal(const char *buf, apr_size_t nbyte);
   
   /**
    * Make the bucket passed in a bucket refer to long-lived data
  @@ -977,10 +977,10 @@
    * @param nbyte The size of the data to insert.
    * @param w The number of bytes added to the bucket
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_make_immortal(ap_bucket *b, const char *buf, apr_size_t nbyte, apr_size_t *w)
  + * @deffunc apr_bucket *apr_bucket_make_immortal(apr_bucket *b, const char *buf, apr_size_t nbyte, apr_size_t *w)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_make_immortal(ap_bucket *b, const char *buf, 
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_make_immortal(apr_bucket *b, const char *buf, 
                                           apr_size_t nbyte);
   
   /**
  @@ -988,10 +988,10 @@
    * @param buf The data to insert into the bucket
    * @param nbyte The size of the data to insert.
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_create_transient(const char *buf, apr_size_t nbyte, apr_size_t *w)
  + * @deffunc apr_bucket *apr_bucket_create_transient(const char *buf, apr_size_t nbyte, apr_size_t *w)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_create_transient(const char *buf, apr_size_t nbyte);
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_create_transient(const char *buf, apr_size_t nbyte);
   
   /**
    * Make the bucket passed in a bucket refer to stack data
  @@ -999,10 +999,10 @@
    * @param buf The data to insert into the bucket
    * @param nbyte The size of the data to insert.
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_make_transient(ap_bucket *b, const char *buf, apr_size_t nbyte)
  + * @deffunc apr_bucket *apr_bucket_make_transient(apr_bucket *b, const char *buf, apr_size_t nbyte)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_make_transient(ap_bucket *b, const char *buf,
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_make_transient(apr_bucket *b, const char *buf,
                                            apr_size_t nbyte);
   
   /**
  @@ -1018,10 +1018,10 @@
    * @param w The number of bytes actually copied into the bucket.
    *          If copy is zero then this return value can be ignored by passing a NULL pointer.
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_create_heap(const char *buf, apr_size_t nbyte, int copy, apr_size_t *w)
  + * @deffunc apr_bucket *apr_bucket_create_heap(const char *buf, apr_size_t nbyte, int copy, apr_size_t *w)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_create_heap(const char *buf, apr_size_t nbyte, 
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_create_heap(const char *buf, apr_size_t nbyte, 
                                         int copy, apr_size_t *w);
   /**
    * Make the bucket passed in a bucket refer to heap data
  @@ -1032,10 +1032,10 @@
    * @param w The number of bytes actually copied into the bucket.
    *          If copy is zero then this return value can be ignored by passing a NULL pointer.
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_make_heap(ap_bucket *b, const char *buf, apr_size_t nbyte, int copy, apr_size_t *w)
  + * @deffunc apr_bucket *apr_bucket_make_heap(apr_bucket *b, const char *buf, apr_size_t nbyte, int copy, apr_size_t *w)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_make_heap(ap_bucket *b, const char *buf,
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_make_heap(apr_bucket *b, const char *buf,
                                       apr_size_t nbyte, int copy, apr_size_t *w);
   
   /**
  @@ -1043,10 +1043,10 @@
    * @param buf The buffer to insert into the bucket
    * @param p The pool the memory was allocated out of
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_create_pool(const char *buf, apr_size_t *length, apr_pool_t *p)
  + * @deffunc apr_bucket *apr_bucket_create_pool(const char *buf, apr_size_t *length, apr_pool_t *p)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_create_pool(const char *buf, apr_size_t length,
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_create_pool(const char *buf, apr_size_t length,
                                         apr_pool_t *p);
   
   /**
  @@ -1055,10 +1055,10 @@
    * @param buf The buffer to insert into the bucket
    * @param p The pool the memory was allocated out of
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_make_pool(ap_bucket *b, const char *buf, apr_size_t *length, apr_pool_t *p)
  + * @deffunc apr_bucket *apr_bucket_make_pool(apr_bucket *b, const char *buf, apr_size_t *length, apr_pool_t *p)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_make_pool(ap_bucket *b, const char *buf, 
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_make_pool(apr_bucket *b, const char *buf, 
                                       apr_size_t length, apr_pool_t *p);
   
   /**
  @@ -1068,10 +1068,10 @@
    *              that this bucket refers to
    * @param length The number of bytes referred to by this bucket
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_create_mmap(const apr_mmap_t *mm, apr_size_t start, apr_size_t length)
  + * @deffunc apr_bucket *apr_bucket_create_mmap(const apr_mmap_t *mm, apr_size_t start, apr_size_t length)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_create_mmap(apr_mmap_t *mm, apr_off_t start,
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_create_mmap(apr_mmap_t *mm, apr_off_t start,
                                         apr_size_t length);
   
   /**
  @@ -1082,46 +1082,46 @@
    *              that this bucket refers to
    * @param length The number of bytes referred to by this bucket
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_make_mmap(ap_bucket *b, const apr_mmap_t *mm, apr_size_t start, apr_size_t length)
  + * @deffunc apr_bucket *apr_bucket_make_mmap(apr_bucket *b, const apr_mmap_t *mm, apr_size_t start, apr_size_t length)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_make_mmap(ap_bucket *b, apr_mmap_t *mm, 
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_make_mmap(apr_bucket *b, apr_mmap_t *mm, 
                                       apr_off_t start, apr_size_t length);
   
   /**
    * Create a bucket referring to a socket.
    * @param thissocket The socket to put in the bucket
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_create_socket(apr_socket_t *thissocket)
  + * @deffunc apr_bucket *apr_bucket_create_socket(apr_socket_t *thissocket)
    */
  -APU_DECLARE(ap_bucket *) ap_bucket_create_socket(apr_socket_t *thissock);
  +APU_DECLARE(apr_bucket *) apr_bucket_create_socket(apr_socket_t *thissock);
   /**
    * Make the bucket passed in a bucket refer to a socket
    * @param b The bucket to make into a SOCKET bucket
    * @param thissocket The socket to put in the bucket
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_make_socket(ap_bucket *b, apr_socket_t *thissocket)
  + * @deffunc apr_bucket *apr_bucket_make_socket(apr_bucket *b, apr_socket_t *thissocket)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_make_socket(ap_bucket *b, apr_socket_t *thissock);
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_make_socket(apr_bucket *b, apr_socket_t *thissock);
   
   /**
    * Create a bucket referring to a pipe.
    * @param thispipe The pipe to put in the bucket
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_create_pipe(apr_file_t *thispipe)
  + * @deffunc apr_bucket *apr_bucket_create_pipe(apr_file_t *thispipe)
    */
  -APU_DECLARE(ap_bucket *) ap_bucket_create_pipe(apr_file_t *thispipe);
  +APU_DECLARE(apr_bucket *) apr_bucket_create_pipe(apr_file_t *thispipe);
   
   /**
    * Make the bucket passed in a bucket refer to a pipe
    * @param b The bucket to make into a PIPE bucket
    * @param thispipe The pipe to put in the bucket
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_make_pipe(ap_bucket *b, apr_file_t *thispipe)
  + * @deffunc apr_bucket *apr_bucket_make_pipe(apr_bucket *b, apr_file_t *thispipe)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_make_pipe(ap_bucket *b, apr_file_t *thispipe);
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_make_pipe(apr_bucket *b, apr_file_t *thispipe);
   
   /**
    * Create a bucket referring to a file.
  @@ -1129,10 +1129,10 @@
    * @param offset The offset where the data of interest begins in the file
    * @param len The amount of data in the file we are interested in
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_create_file(apr_file_t *fd, apr_off_t offset, apr_size_t len)
  + * @deffunc apr_bucket *apr_bucket_create_file(apr_file_t *fd, apr_off_t offset, apr_size_t len)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_create_file(apr_file_t *fd, apr_off_t offset,
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_create_file(apr_file_t *fd, apr_off_t offset,
                                         apr_size_t len);
   
   /**
  @@ -1142,14 +1142,14 @@
    * @param offset The offset where the data of interest begins in the file
    * @param len The amount of data in the file we are interested in
    * @return The new bucket, or NULL if allocation failed
  - * @deffunc ap_bucket *ap_bucket_make_file(ap_bucket *b, apr_file_t *fd, apr_off_t offset, apr_size_t len)
  + * @deffunc apr_bucket *apr_bucket_make_file(apr_bucket *b, apr_file_t *fd, apr_off_t offset, apr_size_t len)
    */
  -APU_DECLARE(ap_bucket *) 
  -                ap_bucket_make_file(ap_bucket *b, apr_file_t *fd,
  +APU_DECLARE(apr_bucket *) 
  +                apr_bucket_make_file(apr_bucket *b, apr_file_t *fd,
                                       apr_off_t offset, apr_size_t len);
   
   #ifdef __cplusplus
   }
   #endif
   
  -#endif /* !AP_BUCKETS_H */
  +#endif /* !APR_BUCKETS_H */
  
  
  
  1.3       +25 -17    apr-util/include/apr_generic_hook.h
  
  Index: apr_generic_hook.h
  ===================================================================
  RCS file: /home/cvs/apr-util/include/apr_generic_hook.h,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- apr_generic_hook.h	2001/01/08 15:42:04	1.2
  +++ apr_generic_hook.h	2001/01/19 07:01:26	1.3
  @@ -52,21 +52,25 @@
    * <http://www.apache.org/>.
    */
   
  -#ifndef APACHE_AP_GENERIC_HOOK_H
  -#define APACHE_AP_GENERIC_HOOK_H
  +#ifndef APR_GENERIC_HOOK_H
  +#define APR_GENERIC_HOOK_H
   
   #include "apr_tables.h"
   
  +#ifdef __cplusplus
  +extern "C" {
  +#endif
  +
   /**
    * @package Apache hooks functions
    */
   
  -#define APU_DECLARE_GENERIC_HOOK(link,ret,name,args) \
  -typedef ret HOOK_##name args;
  +#define APR_DECLARE_GENERIC_HOOK(ns,ret,name,args) \
  +typedef ret ns##_HOOK_##name args;
   
  -APU_DECLARE(void) ap_hook_generic(const char *szName,void (*pfn)(void),
  -				 const char * const *aszPre,
  -				 const char * const *aszSucc,int nOrder);
  +APU_DECLARE(void) apr_hook_generic(const char *szName,void (*pfn)(void),
  +				   const char * const *aszPre,
  +				   const char * const *aszSucc,int nOrder);
   
   /**
    * Hook to a generic hook.
  @@ -78,12 +82,12 @@
    * @param nOrder an integer determining order before honouring aszPre and aszSucc (for example HOOK_MIDDLE)
    */
   
  -#define AP_HOOK_GENERIC(name,pfn,aszPre,aszSucc,nOrder) \
  +#define APR_HOOK_GENERIC(name,pfn,aszPre,aszSucc,nOrder) \
       ((void (*)(const char *,HOOK_##name *,const char * const *, \
  -	       const char * const *,int))&ap_hook_generic)(#name,pfn,aszPre, \
  +	       const char * const *,int))&apr_hook_generic)(#name,pfn,aszPre, \
   							   aszSucc, nOrder)
   
  -APU_DECLARE(apr_array_header_t *) ap_generic_hook_get(const char *szName);
  +APU_DECLARE(apr_array_header_t *) apr_generic_hook_get(const char *szName);
   
   /**
    * Implement a generic hook that runs until one of the functions
  @@ -93,20 +97,20 @@
    * @param name The name of the hook
    * @param args_decl The declaration of the arguments for the hook
    * @param args_used The names for the arguments for the hook
  - * @deffunc int AP_IMPLEMENT_EXTERNAL_HOOK_RUN_ALL(link, name, args_decl, args_use)
  + * @deffunc int APR_IMPLEMENT_EXTERNAL_HOOK_RUN_ALL(link, name, args_decl, args_use)
    */
  -#define AP_IMPLEMENT_GENERIC_HOOK_RUN_ALL(ret,name,args_decl,args_use,ok,decline) \
  -APU_DECLARE(ret) ap_run_##name args_decl \
  +#define APR_IMPLEMENT_GENERIC_HOOK_RUN_ALL(ns,link,ret,name,args_decl,args_use,ok,decline) \
  +link##_DECLARE(ret) ns##_run_##name args_decl \
       { \
  -    LINK_##name *pHook; \
  +    ns##_LINK_##name *pHook; \
       int n; \
       ret rv; \
  -    apr_array_header_t *pHookArray=ap_generic_hook_get(#name); \
  +    apr_array_header_t *pHookArray=apr_generic_hook_get(#name); \
   \
       if(!pHookArray) \
   	return ok; \
   \
  -    pHook=(LINK_##name *)pHookArray->elts; \
  +    pHook=(ns##_LINK_##name *)pHookArray->elts; \
       for(n=0 ; n < pHookArray->nelts ; ++n) \
   	{ \
   	rv=pHook[n].pFunc args_use; \
  @@ -116,5 +120,9 @@
   	} \
       return ok; \
       }
  +
  +#ifdef __cplusplus
  +}
  +#endif
   
  -#endif /* def APACHE_AP_GENERIC_HOOK_H */
  +#endif /* APR_GENERIC_HOOK_H */
  
  
  
  1.34      +64 -60    apr-util/include/apr_hooks.h
  
  Index: apr_hooks.h
  ===================================================================
  RCS file: /home/cvs/apr-util/include/apr_hooks.h,v
  retrieving revision 1.33
  retrieving revision 1.34
  diff -u -r1.33 -r1.34
  --- apr_hooks.h	2001/01/18 23:30:56	1.33
  +++ apr_hooks.h	2001/01/19 07:01:26	1.34
  @@ -52,8 +52,8 @@
    * <http://www.apache.org/>.
    */
   
  -#ifndef APACHE_AP_HOOKS_H
  -#define APACHE_AP_HOOKS_H
  +#ifndef APR_HOOKS_H
  +#define APR_HOOKS_H
   
   #include "apu.h"
   /* For apr_array_header_t */
  @@ -67,69 +67,71 @@
    * @package Apache hooks functions
    */
   
  -#define AP_DECLARE_EXTERNAL_HOOK(link,ret,name,args) \
  -typedef ret HOOK_##name args; \
  -link##_DECLARE(void) ap_hook_##name(HOOK_##name *pf, const char* const* aszPre, \
  -                                    const char * const *aszSucc, int nOrder); \
  -link##_DECLARE(ret) ap_run_##name args; \
  -typedef struct _LINK_##name \
  +#define APR_DECLARE_EXTERNAL_HOOK(ns,link,ret,name,args) \
  +typedef ret ns##_HOOK_##name##_t args; \
  +link##_DECLARE(void) ns##_hook_##name(ns##_HOOK_##name##_t *pf, \
  +                                      const char* const* aszPre, \
  +                                      const char * const *aszSucc, int nOrder); \
  +link##_DECLARE(ret) ns##_run_##name args; \
  +typedef struct ns##_LINK_##name##_t \
       { \
  -    HOOK_##name *pFunc; \
  +    ns##_HOOK_##name##_t *pFunc; \
       const char *szName; \
       const char * const *aszPredecessors; \
       const char * const *aszSuccessors; \
       int nOrder; \
  -    } LINK_##name;
  +    } ns##_LINK_##name##_t;
   
  -#define AP_HOOK_STRUCT(members) \
  +#define APR_HOOK_STRUCT(members) \
   static struct { members } _hooks;
   
  -#define AP_HOOK_LINK(name) \
  +#define APR_HOOK_LINK(name) \
       apr_array_header_t *link_##name;
   
  -#define AP_IMPLEMENT_EXTERNAL_HOOK_BASE(link,name) \
  -link##_DECLARE(void) ap_hook_##name(HOOK_##name *pf,const char * const *aszPre, \
  -                                    const char * const *aszSucc,int nOrder) \
  +#define APR_IMPLEMENT_EXTERNAL_HOOK_BASE(ns,link,name) \
  +link##_DECLARE(void) ns##_hook_##name(ns##_HOOK_##name##_t *pf,const char * const *aszPre, \
  +                                      const char * const *aszSucc,int nOrder) \
       { \
  -    LINK_##name *pHook; \
  +    ns##_LINK_##name##_t *pHook; \
       if(!_hooks.link_##name) \
   	{ \
  -	_hooks.link_##name=apr_make_array(ap_global_hook_pool,1,sizeof(LINK_##name)); \
  -	ap_hook_sort_register(#name,&_hooks.link_##name); \
  +	_hooks.link_##name=apr_make_array(apr_global_hook_pool,1,sizeof(ns##_LINK_##name##_t)); \
  +	apr_hook_sort_register(#name,&_hooks.link_##name); \
   	} \
       pHook=apr_push_array(_hooks.link_##name); \
       pHook->pFunc=pf; \
       pHook->aszPredecessors=aszPre; \
       pHook->aszSuccessors=aszSucc; \
       pHook->nOrder=nOrder; \
  -    pHook->szName=ap_current_hooking_module; \
  -    if(ap_debug_module_hooks) \
  -	ap_show_hook(#name,aszPre,aszSucc); \
  +    pHook->szName=apr_debug_module_name; \
  +    if(apr_debug_module_hooks) \
  +	apr_show_hook(#name,aszPre,aszSucc); \
       }
   
   /**
    * Implement a hook that has no return code, and therefore runs all of the
    * registered functions
  + * @param ns The namespace prefix of the hook functions
    * @param link The linkage declaration prefix of the hook
    * @param name The name of the hook
    * @param args_decl The declaration of the arguments for the hook
    * @param args_used The names for the arguments for the hook
  - * @deffunc void AP_IMPLEMENT_EXTERNAL_HOOK_VOID(link, name, args_decl, args_use)
  + * @deffunc void APR_IMPLEMENT_EXTERNAL_HOOK_VOID(ns, link, name, args_decl, args_use)
    * @tip The link prefix FOO corresponds to FOO_DECLARE() macros, which
    * provide export linkage from the module that IMPLEMENTs the hook, and
    * import linkage from external modules that link to the hook's module.
    */
  -#define AP_IMPLEMENT_EXTERNAL_HOOK_VOID(link,name,args_decl,args_use) \
  -AP_IMPLEMENT_EXTERNAL_HOOK_BASE(link,name) \
  -link##_DECLARE(void) ap_run_##name args_decl \
  +#define APR_IMPLEMENT_EXTERNAL_HOOK_VOID(ns,link,name,args_decl,args_use) \
  +APR_IMPLEMENT_EXTERNAL_HOOK_BASE(ns,link,name) \
  +link##_DECLARE(void) ns##_run_##name args_decl \
       { \
  -    LINK_##name *pHook; \
  +    ns##_LINK_##name##_t *pHook; \
       int n; \
   \
       if(!_hooks.link_##name) \
   	return; \
   \
  -    pHook=(LINK_##name *)_hooks.link_##name->elts; \
  +    pHook=(ns##_LINK_##name##_t *)_hooks.link_##name->elts; \
       for(n=0 ; n < _hooks.link_##name->nelts ; ++n) \
   	pHook[n].pFunc args_use; \
       }
  @@ -140,27 +142,28 @@
   /**
    * Implement a hook that runs until one of the functions returns something
    * other than OK or DECLINE
  + * @param ns The namespace prefix of the hook functions
    * @param link The linkage declaration prefix of the hook
    * @param name The name of the hook
    * @param args_decl The declaration of the arguments for the hook
    * @param args_used The names for the arguments for the hook
  - * @deffunc int AP_IMPLEMENT_EXTERNAL_HOOK_RUN_ALL(link, name, args_decl, args_use)
  + * @deffunc int APR_IMPLEMENT_EXTERNAL_HOOK_RUN_ALL(ns, link, name, args_decl, args_use)
    * @tip The link prefix FOO corresponds to FOO_DECLARE() macros, which
    * provide export linkage from the module that IMPLEMENTs the hook, and
    * import linkage from external modules that link to the hook's module.
    */
  -#define AP_IMPLEMENT_EXTERNAL_HOOK_RUN_ALL(link,ret,name,args_decl,args_use,ok,decline) \
  -AP_IMPLEMENT_EXTERNAL_HOOK_BASE(link,name) \
  -link##_DECLARE(ret) ap_run_##name args_decl \
  +#define APR_IMPLEMENT_EXTERNAL_HOOK_RUN_ALL(ns,link,ret,name,args_decl,args_use,ok,decline) \
  +APR_IMPLEMENT_EXTERNAL_HOOK_BASE(ns,link,name) \
  +link##_DECLARE(ret) ns##_run_##name args_decl \
       { \
  -    LINK_##name *pHook; \
  +    ns##_LINK_##name##_t *pHook; \
       int n; \
       ret rv; \
   \
       if(!_hooks.link_##name) \
   	return ok; \
   \
  -    pHook=(LINK_##name *)_hooks.link_##name->elts; \
  +    pHook=(ns##_LINK_##name##_t *)_hooks.link_##name->elts; \
       for(n=0 ; n < _hooks.link_##name->nelts ; ++n) \
   	{ \
   	rv=pHook[n].pFunc args_use; \
  @@ -174,28 +177,29 @@
   
   /**
    * Implement a hook that runs until the first function returns something
  - * other than DECLINE
  + * other than the value of decline
  + * @param ns The namespace prefix of the hook functions
    * @param link The linkage declaration prefix of the hook
    * @param name The name of the hook
    * @param args_decl The declaration of the arguments for the hook
    * @param args_used The names for the arguments for the hook
  - * @deffunc int AP_IMPLEMENT_HOOK_RUN_FIRST(link, name, args_decl, args_use)
  + * @deffunc int APR_IMPLEMENT_HOOK_RUN_FIRST(ns, link, name, args_decl, args_use, decline)
    * @tip The link prefix FOO corresponds to FOO_DECLARE() macros, which
    * provide export linkage from the module that IMPLEMENTs the hook, and
    * import linkage from external modules that link to the hook's module.
    */
  -#define AP_IMPLEMENT_EXTERNAL_HOOK_RUN_FIRST(link,ret,name,args_decl,args_use,decline) \
  -AP_IMPLEMENT_EXTERNAL_HOOK_BASE(link,name) \
  -link##_DECLARE(ret) ap_run_##name args_decl \
  +#define APR_IMPLEMENT_EXTERNAL_HOOK_RUN_FIRST(ns,link,ret,name,args_decl,args_use,decline) \
  +APR_IMPLEMENT_EXTERNAL_HOOK_BASE(ns,link,name) \
  +link##_DECLARE(ret) ns##_run_##name args_decl \
       { \
  -    LINK_##name *pHook; \
  +    ns##_LINK_##name##_t *pHook; \
       int n; \
       ret rv; \
   \
       if(!_hooks.link_##name) \
   	return decline; \
   \
  -    pHook=(LINK_##name *)_hooks.link_##name->elts; \
  +    pHook=(ns##_LINK_##name##_t *)_hooks.link_##name->elts; \
       for(n=0 ; n < _hooks.link_##name->nelts ; ++n) \
   	{ \
   	rv=pHook[n].pFunc args_use; \
  @@ -207,44 +211,44 @@
       }
   
        /* Hook orderings */
  -#define AP_HOOK_REALLY_FIRST	(-10)
  -#define AP_HOOK_FIRST		0
  -#define AP_HOOK_MIDDLE		10
  -#define AP_HOOK_LAST		20
  -#define AP_HOOK_REALLY_LAST	30
  +#define APR_HOOK_REALLY_FIRST	(-10)
  +#define APR_HOOK_FIRST		0
  +#define APR_HOOK_MIDDLE		10
  +#define APR_HOOK_LAST		20
  +#define APR_HOOK_REALLY_LAST	30
   
   /**
    * The global pool used to allocate any memory needed by the hooks.
  - * @defvar apr_pool_t *ap_global_hook_pool
  + * @defvar apr_pool_t *apr_global_hook_pool
    */ 
  -extern APU_DECLARE_DATA apr_pool_t *ap_global_hook_pool;
  +extern APU_DECLARE_DATA apr_pool_t *apr_global_hook_pool;
   
   /**
    * A global variable to determine if debugging information about the
    * hooks functions should be printed
  - * @defvar apr_pool_t *ap_debug_module_hooks
  + * @defvar apr_pool_t *apr_debug_module_hooks
    */ 
  -extern APU_DECLARE_DATA int ap_debug_module_hooks;
  +extern APU_DECLARE_DATA int apr_debug_module_hooks;
   
   /**
    * The name of the module that is currently registering a function
  - * @defvar apr_pool_t *ap_debug_module_name
  + * @defvar apr_pool_t *apr_debug_module_name
    */ 
  -extern APU_DECLARE_DATA const char *ap_current_hooking_module;
  +extern APU_DECLARE_DATA const char *apr_debug_module_name;
   
   /**
    * 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
  - * @deffunc void ap_hook_sort_register(const char *szHookName, ap_arry_header_t **aHooks)
  + * @deffunc void apr_hook_sort_register(const char *szHookName, apr_array_header_t **aHooks)
    */
  -APU_DECLARE(void) ap_hook_sort_register(const char *szHookName, 
  +APU_DECLARE(void) apr_hook_sort_register(const char *szHookName, 
                                           apr_array_header_t **aHooks);
   /**
    * Sort all of the registerd functions for a given hook
  - * @deffunc void ap_sort_hooks(void)
  + * @deffunc void apr_sort_hooks(void)
    */
  -APU_DECLARE(void) ap_sort_hooks(void);
  +APU_DECLARE(void) apr_sort_hooks(void);
   
   /**
    * Print all of the information about the current hook.  This is used for
  @@ -252,19 +256,19 @@
    * @param szName The name of the hook
    * @param aszPre All of the functions in the predecessor array
    * @param aszSucc All of the functions in the successor array
  - * @deffunc void ap_show_hook(const char *szName, const char *const *aszPre, const char *const *aszSucc)
  + * @deffunc void apr_show_hook(const char *szName, const char *const *aszPre, const char *const *aszSucc)
    */
  -APU_DECLARE(void) ap_show_hook(const char *szName,const char * const *aszPre,
  +APU_DECLARE(void) apr_show_hook(const char *szName,const char * const *aszPre,
                                  const char * const *aszSucc);
   
   /**
    * Remove all currently registered functions.
  - * @deffunc void ap_hook_deregister_all(void)
  + * @deffunc void apr_hook_deregister_all(void)
    */
  -APU_DECLARE(void) ap_hook_deregister_all(void);
  +APU_DECLARE(void) apr_hook_deregister_all(void);
   
   #ifdef __cplusplus
   }
   #endif
   
  -#endif /* ndef(AP_HOOKS_H) */
  +#endif /* APR_HOOKS_H */
  
  
  
  1.6       +81 -81    apr-util/include/apr_ring.h
  
  Index: apr_ring.h
  ===================================================================
  RCS file: /home/cvs/apr-util/include/apr_ring.h,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- apr_ring.h	2000/09/09 06:13:50	1.5
  +++ apr_ring.h	2001/01/19 07:01:27	1.6
  @@ -62,8 +62,8 @@
    * availability of inline functions.
    */
   
  -#ifndef AP_RING_H
  -#define AP_RING_H
  +#ifndef APR_RING_H
  +#define APR_RING_H
   
   /*
    * for offsetof()
  @@ -80,15 +80,15 @@
    * elements in the ring, e.g.
    *
    *      struct my_item_t {
  - *          AP_RING_ENTRY(my_item_t) link;
  + *          APR_RING_ENTRY(my_item_t) link;
    *          int foo;
    *          char *bar;
    *      };
    *
    * A struct may be put on more than one ring if it has more than one
  - * AP_RING_ENTRY field.
  + * APR_RING_ENTRY field.
    */
  -#define AP_RING_ENTRY(elem)						\
  +#define APR_RING_ENTRY(elem)						\
       struct {								\
   	struct elem *next;						\
   	struct elem *prev;						\
  @@ -97,7 +97,7 @@
   /*
    * Each ring is managed via its head, which is a struct declared like this:
    *
  - *      AP_RING_HEAD(my_ring_t, my_item_t);
  + *      APR_RING_HEAD(my_ring_t, my_item_t);
    *      struct my_ring_t ring, *ringp;
    *
    * This struct looks just like the element link struct so that we can
  @@ -106,7 +106,7 @@
    * The first element in the ring is next after the head, and the last
    * element is just before the head.
    */
  -#define AP_RING_HEAD(head, elem)					\
  +#define APR_RING_HEAD(head, elem)					\
       struct head {							\
   	struct elem *next;						\
   	struct elem *prev;						\
  @@ -120,11 +120,11 @@
    * elements in the ring, computed from the address of the ring's head.
    *
    * Note that for strict C standards compliance you should put the
  - * AP_RING_ENTRY first in struct elem unless the head is always part
  + * APR_RING_ENTRY first in struct elem unless the head is always part
    * of a larger object with enough earlier fields to accommodate the
    * offsetof() computed below. You can usually ignore this caveat.
    */
  -#define AP_RING_SENTINEL(hp, elem, link)				\
  +#define APR_RING_SENTINEL(hp, elem, link)				\
       (struct elem *)((char *)(hp) - offsetof(struct elem, link))
   
   /*
  @@ -132,77 +132,77 @@
    * structures directly so that you can more easily change to a
    * different flavour of list from BSD's <sys/queue.h>.
    */
  -#define AP_RING_FIRST(hp)	(hp)->next
  -#define AP_RING_LAST(hp)	(hp)->prev
  -#define AP_RING_NEXT(ep, link)	(ep)->link.next
  -#define AP_RING_PREV(ep, link)	(ep)->link.prev
  +#define APR_RING_FIRST(hp)	(hp)->next
  +#define APR_RING_LAST(hp)	(hp)->prev
  +#define APR_RING_NEXT(ep, link)	(ep)->link.next
  +#define APR_RING_PREV(ep, link)	(ep)->link.prev
   
   /*
    * Empty rings and singleton elements.
    */
  -#define AP_RING_INIT(hp, elem, link) do {				\
  -	AP_RING_FIRST((hp)) = AP_RING_SENTINEL((hp), elem, link);	\
  -	AP_RING_LAST((hp))  = AP_RING_SENTINEL((hp), elem, link);	\
  +#define APR_RING_INIT(hp, elem, link) do {				\
  +	APR_RING_FIRST((hp)) = APR_RING_SENTINEL((hp), elem, link);	\
  +	APR_RING_LAST((hp))  = APR_RING_SENTINEL((hp), elem, link);	\
       } while (0)
   
  -#define AP_RING_EMPTY(hp, elem, link)					\
  -    (AP_RING_FIRST((hp)) == AP_RING_SENTINEL((hp), elem, link))
  +#define APR_RING_EMPTY(hp, elem, link)					\
  +    (APR_RING_FIRST((hp)) == APR_RING_SENTINEL((hp), elem, link))
   
  -#define AP_RING_ELEM_INIT(ep, link) do {				\
  -	AP_RING_NEXT((ep), link) = (ep);				\
  -	AP_RING_PREV((ep), link) = (ep);				\
  +#define APR_RING_ELEM_INIT(ep, link) do {				\
  +	APR_RING_NEXT((ep), link) = (ep);				\
  +	APR_RING_PREV((ep), link) = (ep);				\
       } while (0)
   
   /*
    * Adding elements.
    */
  -#define AP_RING_SPLICE_BEFORE(lep, ep1, epN, link) do {			\
  -	AP_RING_NEXT((epN), link) = (lep);				\
  -	AP_RING_PREV((ep1), link) = AP_RING_PREV((lep), link);		\
  -	AP_RING_NEXT(AP_RING_PREV((lep), link), link) = (ep1);		\
  -	AP_RING_PREV((lep), link) = (epN);				\
  +#define APR_RING_SPLICE_BEFORE(lep, ep1, epN, link) do {			\
  +	APR_RING_NEXT((epN), link) = (lep);				\
  +	APR_RING_PREV((ep1), link) = APR_RING_PREV((lep), link);		\
  +	APR_RING_NEXT(APR_RING_PREV((lep), link), link) = (ep1);		\
  +	APR_RING_PREV((lep), link) = (epN);				\
       } while (0)
   
  -#define AP_RING_SPLICE_AFTER(lep, ep1, epN, link) do {			\
  -	AP_RING_PREV((ep1), link) = (lep);				\
  -	AP_RING_NEXT((epN), link) = AP_RING_NEXT((lep), link);		\
  -	AP_RING_PREV(AP_RING_NEXT((lep), link), link) = (epN);		\
  -	AP_RING_NEXT((lep), link) = (ep1);				\
  +#define APR_RING_SPLICE_AFTER(lep, ep1, epN, link) do {			\
  +	APR_RING_PREV((ep1), link) = (lep);				\
  +	APR_RING_NEXT((epN), link) = APR_RING_NEXT((lep), link);		\
  +	APR_RING_PREV(APR_RING_NEXT((lep), link), link) = (epN);		\
  +	APR_RING_NEXT((lep), link) = (ep1);				\
       } while (0)
   
  -#define AP_RING_INSERT_BEFORE(lep, nep, link)				\
  -	AP_RING_SPLICE_BEFORE((lep), (nep), (nep), link)
  +#define APR_RING_INSERT_BEFORE(lep, nep, link)				\
  +	APR_RING_SPLICE_BEFORE((lep), (nep), (nep), link)
   
  -#define AP_RING_INSERT_AFTER(lep, nep, link)				\
  -	AP_RING_SPLICE_AFTER((lep), (nep), (nep), link)
  +#define APR_RING_INSERT_AFTER(lep, nep, link)				\
  +	APR_RING_SPLICE_AFTER((lep), (nep), (nep), link)
   
   /*
    * These macros work when the ring is empty: inserting before the head
    * or after the tail of an empty ring using the macros above doesn't work.
    */
  -#define AP_RING_SPLICE_HEAD(hp, ep1, epN, elem, link)			\
  -	AP_RING_SPLICE_AFTER(AP_RING_SENTINEL((hp), elem, link),	\
  +#define APR_RING_SPLICE_HEAD(hp, ep1, epN, elem, link)			\
  +	APR_RING_SPLICE_AFTER(APR_RING_SENTINEL((hp), elem, link),	\
   			     (ep1), (epN), link)
   
  -#define AP_RING_SPLICE_TAIL(hp, ep1, epN, elem, link)			\
  -	AP_RING_SPLICE_BEFORE(AP_RING_SENTINEL((hp), elem, link),	\
  +#define APR_RING_SPLICE_TAIL(hp, ep1, epN, elem, link)			\
  +	APR_RING_SPLICE_BEFORE(APR_RING_SENTINEL((hp), elem, link),	\
   			     (ep1), (epN), link)
   
  -#define AP_RING_INSERT_HEAD(hp, nep, elem, link)			\
  -	AP_RING_SPLICE_HEAD((hp), (nep), (nep), elem, link)
  +#define APR_RING_INSERT_HEAD(hp, nep, elem, link)			\
  +	APR_RING_SPLICE_HEAD((hp), (nep), (nep), elem, link)
   
  -#define AP_RING_INSERT_TAIL(hp, nep, elem, link)			\
  -	AP_RING_SPLICE_TAIL((hp), (nep), (nep), elem, link)
  +#define APR_RING_INSERT_TAIL(hp, nep, elem, link)			\
  +	APR_RING_SPLICE_TAIL((hp), (nep), (nep), elem, link)
   
   /*
    * Concatenating ring h2 onto the end of ring h1 leaves h2 empty.
    */
  -#define AP_RING_CONCAT(h1, h2, elem, link) do {				\
  -	if (!AP_RING_EMPTY((h2), elem, link)) {				\
  -	    AP_RING_SPLICE_BEFORE(AP_RING_SENTINEL((h1), elem, link),	\
  -				  AP_RING_FIRST((h2)),			\
  -				  AP_RING_LAST((h2)), link);		\
  -	    AP_RING_INIT((h2), elem, link);				\
  +#define APR_RING_CONCAT(h1, h2, elem, link) do {				\
  +	if (!APR_RING_EMPTY((h2), elem, link)) {				\
  +	    APR_RING_SPLICE_BEFORE(APR_RING_SENTINEL((h1), elem, link),	\
  +				  APR_RING_FIRST((h2)),			\
  +				  APR_RING_LAST((h2)), link);		\
  +	    APR_RING_INIT((h2), elem, link);				\
   	}								\
       } while (0)
   
  @@ -210,65 +210,65 @@
    * Removing elements. Be warned that the unspliced elements are left
    * with dangling pointers at either end!
    */
  -#define AP_RING_UNSPLICE(ep1, epN, link) do {				\
  -	AP_RING_NEXT(AP_RING_PREV((ep1), link), link) =			\
  -		     AP_RING_NEXT((epN), link);				\
  -	AP_RING_PREV(AP_RING_NEXT((epN), link), link) =			\
  -		     AP_RING_PREV((ep1), link);				\
  +#define APR_RING_UNSPLICE(ep1, epN, link) do {				\
  +	APR_RING_NEXT(APR_RING_PREV((ep1), link), link) =			\
  +		     APR_RING_NEXT((epN), link);				\
  +	APR_RING_PREV(APR_RING_NEXT((epN), link), link) =			\
  +		     APR_RING_PREV((ep1), link);				\
       } while (0)
   
  -#define AP_RING_REMOVE(ep, link)					\
  -    AP_RING_UNSPLICE((ep), (ep), link)
  +#define APR_RING_REMOVE(ep, link)					\
  +    APR_RING_UNSPLICE((ep), (ep), link)
   
   /*
    * Iteration.
    */
  -#define AP_RING_FOREACH(ep, hp, elem, link)				\
  -    for ((ep)  = AP_RING_FIRST((hp));					\
  -	 (ep) != AP_RING_SENTINEL((hp), elem, link);			\
  -	 (ep)  = AP_RING_NEXT((ep), link))
  -
  -#define AP_RING_FOREACH_REVERSE(ep, hp, elem, link)			\
  -    for ((ep)  = AP_RING_LAST((hp));					\
  -	 (ep) != AP_RING_SENTINEL((hp), elem, link);			\
  -	 (ep)  = AP_RING_PREV((ep), link))
  +#define APR_RING_FOREACH(ep, hp, elem, link)				\
  +    for ((ep)  = APR_RING_FIRST((hp));					\
  +	 (ep) != APR_RING_SENTINEL((hp), elem, link);			\
  +	 (ep)  = APR_RING_NEXT((ep), link))
  +
  +#define APR_RING_FOREACH_REVERSE(ep, hp, elem, link)			\
  +    for ((ep)  = APR_RING_LAST((hp));					\
  +	 (ep) != APR_RING_SENTINEL((hp), elem, link);			\
  +	 (ep)  = APR_RING_PREV((ep), link))
   
  -#ifdef AP_RING_DEBUG
  +#ifdef APR_RING_DEBUG
   #include <stdio.h>
  -#define AP_RING_CHECK_ONE(msg, ptr)					\
  +#define APR_RING_CHECK_ONE(msg, ptr)					\
   	fprintf(stderr, "*** %s %p\n", msg, ptr)
  -#define AP_RING_CHECK(hp, elem, link, msg)				\
  -	AP_RING_CHECK_ELEM(AP_RING_SENTINEL(hp, elem, link), elem, link, msg)
  -#define AP_RING_CHECK_ELEM(ep, elem, link, msg) do {			\
  +#define APR_RING_CHECK(hp, elem, link, msg)				\
  +	APR_RING_CHECK_ELEM(APR_RING_SENTINEL(hp, elem, link), elem, link, msg)
  +#define APR_RING_CHECK_ELEM(ep, elem, link, msg) do {			\
   	struct elem *start = (ep);					\
   	struct elem *this = start;					\
   	fprintf(stderr, "*** ring check start -- %s\n", msg);		\
   	do {								\
   	    fprintf(stderr, "\telem %p\n", this);			\
   	    fprintf(stderr, "\telem->next %p\n",			\
  -		    AP_RING_NEXT(this, link));				\
  +		    APR_RING_NEXT(this, link));				\
   	    fprintf(stderr, "\telem->prev %p\n",			\
  -		    AP_RING_PREV(this, link));				\
  +		    APR_RING_PREV(this, link));				\
   	    fprintf(stderr, "\telem->next->prev %p\n",			\
  -		    AP_RING_PREV(AP_RING_NEXT(this, link), link));	\
  +		    APR_RING_PREV(APR_RING_NEXT(this, link), link));	\
   	    fprintf(stderr, "\telem->prev->next %p\n",			\
  -		    AP_RING_NEXT(AP_RING_PREV(this, link), link));	\
  -	    if (AP_RING_PREV(AP_RING_NEXT(this, link), link) != this) {	\
  +		    APR_RING_NEXT(APR_RING_PREV(this, link), link));	\
  +	    if (APR_RING_PREV(APR_RING_NEXT(this, link), link) != this) {	\
   		fprintf(stderr, "\t*** this->next->prev != this\n");	\
   		break;							\
   	    }								\
  -	    if (AP_RING_NEXT(AP_RING_PREV(this, link), link) != this) {	\
  +	    if (APR_RING_NEXT(APR_RING_PREV(this, link), link) != this) {	\
   		fprintf(stderr, "\t*** this->prev->next != this\n");	\
   		break;							\
   	    }								\
  -	    this = AP_RING_NEXT(this, link);				\
  +	    this = APR_RING_NEXT(this, link);				\
   	} while (this != start);					\
   	fprintf(stderr, "*** ring check end\n");			\
       } while (0)
   #else
  -#define AP_RING_CHECK_ONE(msg, ptr)
  -#define AP_RING_CHECK(hp, elem, link, msg)
  -#define AP_RING_CHECK_ELEM(ep, elem, link, msg)
  +#define APR_RING_CHECK_ONE(msg, ptr)
  +#define APR_RING_CHECK(hp, elem, link, msg)
  +#define APR_RING_CHECK_ELEM(ep, elem, link, msg)
   #endif
   
  -#endif /* !AP_RING_H */
  +#endif /* !APR_RING_H */
  
  
  
  1.2       +3 -3      apr-util/include/apr_sdbm.h
  
  Index: apr_sdbm.h
  ===================================================================
  RCS file: /home/cvs/apr-util/include/apr_sdbm.h,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- apr_sdbm.h	2000/12/02 16:13:47	1.1
  +++ apr_sdbm.h	2001/01/19 07:01:27	1.2
  @@ -59,8 +59,8 @@
    * status: ex-public domain
    */
   
  -#ifndef SDBM_H
  -#define SDBM_H
  +#ifndef APR_SDBM_H
  +#define APR_SDBM_H
   
   #include "apr_errno.h"
   #include "apr_file_io.h"   /* for apr_fileperms_t */
  @@ -107,4 +107,4 @@
   
   long sdbm_hash(const char *str, int len);
   
  -#endif /* SDBM_H */
  +#endif /* APR_SDBM_H */
  
  
  
  1.16      +20 -20    apr-util/include/apr_sha1.h
  
  Index: apr_sha1.h
  ===================================================================
  RCS file: /home/cvs/apr-util/include/apr_sha1.h,v
  retrieving revision 1.15
  retrieving revision 1.16
  diff -u -r1.15 -r1.16
  --- apr_sha1.h	2001/01/18 23:30:57	1.15
  +++ apr_sha1.h	2001/01/19 07:01:27	1.16
  @@ -58,8 +58,8 @@
    * 	This code is hereby placed in the public domain
    */
   
  -#ifndef APACHE_SHA1_H
  -#define APACHE_SHA1_H
  +#ifndef APR_SHA1_H
  +#define APR_SHA1_H
   
   #include "apu.h"
   #include "apr_general.h"
  @@ -72,22 +72,22 @@
    * @package SHA1 library
    */
   
  -#define SHA_DIGESTSIZE 20
  +#define APR_SHA1_DIGESTSIZE 20
   
   /**
    * Define the Magic String prefix that identifies a password as being
    * hashed using our algorithm.
  - * @defvar AP_SHA1PW_ID "{SHA}"
  + * @defvar APR_SHA1PW_ID "{SHA}"
    */
  -#define AP_SHA1PW_ID "{SHA}"
  -#define AP_SHA1PW_IDLEN 5
  +#define APR_SHA1PW_ID "{SHA}"
  +#define APR_SHA1PW_IDLEN 5
   
  -typedef struct AP_SHA1_CTX AP_SHA1_CTX;
  +typedef struct apr_sha1_ctx_t apr_sha1_ctx_t;
   
   /**
    * SHA1 context structure
    */
  -struct AP_SHA1_CTX {
  +struct apr_sha1_ctx_t {
       /** message digest */
       apr_uint32_t digest[5];
       /** 64-bit bit counts */
  @@ -112,25 +112,25 @@
    *     uses plain SHA1 without a salt, so the same password
    *     will always generate the same hash, making it easier
    *     to break since the search space is smaller.
  - * @deffunc void ap_sha1_base64(const char *clear, int len, char *out)
  + * @deffunc void apr_sha1_base64(const char *clear, int len, char *out)
    */
  -APU_DECLARE(void) ap_sha1_base64(const char *clear, int len, char *out);
  +APU_DECLARE(void) apr_sha1_base64(const char *clear, int len, char *out);
   
   /**
    * Initialize the SHA digest
    * @param context The SHA context to initialize
  - * @deffunc void ap_SHA1Init(AP_SHA1_CTX *context);
  + * @deffunc void apr_SHA1Init(apr_sha1_ctx_t *context);
    */
  -APU_DECLARE(void) ap_SHA1Init(AP_SHA1_CTX *context);
  +APU_DECLARE(void) apr_SHA1Init(apr_sha1_ctx_t *context);
   
   /**
    * Update the SHA digest
    * @param context The SHA1 context to update
    * @param input The buffer to add to the SHA digest
    * @param inputLen The length of the input buffer
  - * @deffunc void ap_SHA1Update(AP_SHA1_CTX *context, const char *input, unsigned int inputLen)
  + * @deffunc void apr_SHA1Update(apr_sha1_ctx_t *context, const char *input, unsigned int inputLen)
    */
  -APU_DECLARE(void) ap_SHA1Update(AP_SHA1_CTX *context, const char *input,
  +APU_DECLARE(void) apr_SHA1Update(apr_sha1_ctx_t *context, const char *input,
                                   unsigned int inputLen);
   
   /**
  @@ -138,9 +138,9 @@
    * @param context The SHA1 context to update
    * @param input The buffer to add to the SHA digest
    * @param inputLen The length of the input buffer
  - * @deffunc void ap_SHA1Update_binary(AP_SHA1_CTX *context, const unsigned char *input, unsigned int inputLen)
  + * @deffunc void apr_SHA1Update_binary(apr_sha1_ctx_t *context, const unsigned char *input, unsigned int inputLen)
    */
  -APU_DECLARE(void) ap_SHA1Update_binary(AP_SHA1_CTX *context,
  +APU_DECLARE(void) apr_SHA1Update_binary(apr_sha1_ctx_t *context,
                                          const unsigned char *input,
                                          unsigned int inputLen);
   
  @@ -148,13 +148,13 @@
    * Finish computing the SHA digest
    * @param digest the output buffer in which to store the digest
    * @param context The context to finalize
  - * @deffunc void ap_SHA1Final(unsigned char digest[SHA_DIGESTSIZE], AP_SHA1_CTX *context)
  + * @deffunc void apr_SHA1Final(unsigned char digest[APR_SHA1_DIGESTSIZE], apr_sha1_ctx_t *context)
    */
  -APU_DECLARE(void) ap_SHA1Final(unsigned char digest[SHA_DIGESTSIZE],
  -                               AP_SHA1_CTX *context);
  +APU_DECLARE(void) apr_SHA1Final(unsigned char digest[APR_SHA1_DIGESTSIZE],
  +                               apr_sha1_ctx_t *context);
   
   #ifdef __cplusplus
   }
   #endif
   
  -#endif	/* !APACHE_SHA1_H */
  +#endif	/* APR_SHA1_H */
  
  
  
  1.3       +2 -2      apr-util/include/apu.h.in
  
  Index: apu.h.in
  ===================================================================
  RCS file: /home/cvs/apr-util/include/apu.h.in,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- apu.h.in	2000/12/21 18:39:02	1.2
  +++ apu.h.in	2001/01/19 07:01:27	1.3
  @@ -83,13 +83,13 @@
   #define APU_DECLARE(type)            type
   /**
    * The public APR-UTIL functions using variable arguments are declared with 
  - * AP_DECLARE(), as they must use the C language calling convention.
  + * APU_DECLARE_NONSTD(), as they must use the C language calling convention.
    *
    * @deffunc APU_DECLARE_NONSTD(rettype) apr_func(args, ...);
    */
   #define APU_DECLARE_NONSTD(type)     type
   /**
  - * The public APR-UTIL variables are declared with AP_MODULE_DECLARE_DATA.
  + * The public APR-UTIL variables are declared with APU_DECLARE_DATA.
    * This assures the appropriate indirection is invoked at compile time.
    *
    * @deffunc APU_DECLARE_DATA type apr_variable;
  
  
  
  1.2       +2 -2      apr-util/include/apu.hw
  
  Index: apu.hw
  ===================================================================
  RCS file: /home/cvs/apr-util/include/apu.hw,v
  retrieving revision 1.1
  retrieving revision 1.2
  diff -u -r1.1 -r1.2
  --- apu.hw	2000/12/21 18:16:32	1.1
  +++ apu.hw	2001/01/19 07:01:27	1.2
  @@ -85,13 +85,13 @@
   #define APU_DECLARE(type)            type
   /**
    * The public APR-UTIL functions using variable arguments are declared with 
  - * AP_DECLARE(), as they must use the C language calling convention.
  + * APU_DECLARE_NONSTD(), as they must use the C language calling convention.
    *
    * @deffunc APU_DECLARE_NONSTD(rettype) apr_func(args, ...);
    */
   #define APU_DECLARE_NONSTD(type)     type
   /**
  - * The public APR-UTIL variables are declared with AP_MODULE_DECLARE_DATA.
  + * The public APR-UTIL variables are declared with APU_DECLARE_DATA.
    * This assures the appropriate indirection is invoked at compile time.
    *
    * @deffunc APU_DECLARE_DATA type apr_variable;
  
  
  

Mime
View raw message