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/hooks Makefile.in apr_hooks.c ap_hooks.c
Date Fri, 19 Jan 2001 07:02:02 GMT
wrowe       01/01/18 23:02:02

  Modified:    .        STATUS aprutil.dsp libaprutil.dsp
               buckets  Makefile.in apr_brigade.c apr_buckets.c
                        apr_buckets_eos.c apr_buckets_file.c
                        apr_buckets_flush.c apr_buckets_heap.c
                        apr_buckets_mmap.c apr_buckets_pipe.c
                        apr_buckets_pool.c apr_buckets_refcount.c
                        apr_buckets_simple.c apr_buckets_socket.c
               crypto   Makefile.in apr_sha1.c
               encoding Makefile.in apr_base64.c
               hooks    Makefile.in apr_hooks.c
  Removed:     buckets  ap_brigade.c ap_buckets.c ap_buckets_eos.c
                        ap_buckets_file.c ap_buckets_flush.c
                        ap_buckets_heap.c ap_buckets_mmap.c
                        ap_buckets_pipe.c ap_buckets_pool.c
                        ap_buckets_refcount.c ap_buckets_simple.c
                        ap_buckets_socket.c
               crypto   ap_sha1.c
               encoding ap_base64.c
               hooks    ap_hooks.c
  Log:
    apr-util rename of ap_ symbols to apr_ notation.  Part 2 of the change.
  
  Revision  Changes    Path
  1.18      +3 -12     apr-util/STATUS
  
  Index: STATUS
  ===================================================================
  RCS file: /home/cvs/apr-util/STATUS,v
  retrieving revision 1.17
  retrieving revision 1.18
  diff -u -r1.17 -r1.18
  --- STATUS	2001/01/19 03:09:53	1.17
  +++ STATUS	2001/01/19 07:01:58	1.18
  @@ -1,5 +1,5 @@
   APRUTIL LIBRARY STATUS:						-*-text-*-
  -Last modified at [$Date: 2001/01/19 03:09:53 $]
  +Last modified at [$Date: 2001/01/19 07:01:58 $]
   
   Release:
       ...on the 12th as part of Apache 2.0a9  [need specifics here]
  @@ -11,6 +11,8 @@
         top-level SUBDIRS list, but definitely get it cleaned for the
         dev guys.  (Greg volunteers)
   
  +    * we distribute 2 (3?) copies of sdbm in apr, and these are -public-?
  +      get organized.
   
   RELEASE NON-SHOWSTOPPERS BUT WOULD BE REAL NICE TO WRAP THESE UP:
   
  @@ -46,14 +48,3 @@
   
   Open Issues:
   
  -    * Compatibility header to deal with renamed symbols.
  -      NOTE:
  -	OtherBill suggests that Apache, APR, and APR-utils all have
  -	compat headers, and Apache's includes APR-util's which includes
  -	APR's.  OtherBill would like apache-2.0/src/include/ap_compat.h to
  -        include apr-util/include/apu_compat.h, which itself includes
  -        apr/include/apr_compat.h.  If the user employs apr_compat, and
  -        only uses features moved to apr, they only need the apr package.
  -      Status:
  -        apr-util/include/: Ryan +1, Greg +0, OtherBill +1, David +1
  -	apache-2.0/src/include/: Greg +1, Ryan -0.5, OtherBill -0.5
  
  
  
  1.16      +20 -20    apr-util/aprutil.dsp
  
  Index: aprutil.dsp
  ===================================================================
  RCS file: /home/cvs/apr-util/aprutil.dsp,v
  retrieving revision 1.15
  retrieving revision 1.16
  diff -u -r1.15 -r1.16
  --- aprutil.dsp	2001/01/18 23:30:52	1.15
  +++ aprutil.dsp	2001/01/19 07:01:58	1.16
  @@ -90,51 +90,51 @@
   # PROP Default_Filter ""
   # Begin Source File
   
  -SOURCE=.\buckets\ap_brigade.c
  +SOURCE=.\buckets\apr_brigade.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets.c
  +SOURCE=.\buckets\apr_buckets.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_eos.c
  +SOURCE=.\buckets\apr_buckets_eos.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_file.c
  +SOURCE=.\buckets\apr_buckets_file.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_flush.c
  +SOURCE=.\buckets\apr_buckets_flush.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_heap.c
  +SOURCE=.\buckets\apr_buckets_heap.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_mmap.c
  +SOURCE=.\buckets\apr_buckets_mmap.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_pipe.c
  +SOURCE=.\buckets\apr_buckets_pipe.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_pool.c
  +SOURCE=.\buckets\apr_buckets_pool.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_refcount.c
  +SOURCE=.\buckets\apr_buckets_refcount.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_simple.c
  +SOURCE=.\buckets\apr_buckets_simple.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_socket.c
  +SOURCE=.\buckets\apr_buckets_socket.c
   # End Source File
   # End Group
   # Begin Group "crypto"
  @@ -142,7 +142,7 @@
   # PROP Default_Filter ""
   # Begin Source File
   
  -SOURCE=.\crypto\ap_sha1.c
  +SOURCE=.\crypto\apr_sha1.c
   # End Source File
   # End Group
   # Begin Group "dbm"
  @@ -190,7 +190,7 @@
   # PROP Default_Filter ""
   # Begin Source File
   
  -SOURCE=.\encoding\ap_base64.c
  +SOURCE=.\encoding\apr_base64.c
   # End Source File
   # End Group
   # Begin Group "hooks"
  @@ -198,7 +198,7 @@
   # PROP Default_Filter ""
   # Begin Source File
   
  -SOURCE=.\hooks\ap_hooks.c
  +SOURCE=.\hooks\apr_hooks.c
   # End Source File
   # End Group
   # Begin Group "uri"
  @@ -281,23 +281,23 @@
   # PROP Default_Filter ""
   # Begin Source File
   
  -SOURCE=.\include\ap_base64.h
  +SOURCE=.\include\apr_base64.h
   # End Source File
   # Begin Source File
   
  -SOURCE=.\include\ap_buckets.h
  +SOURCE=.\include\apr_buckets.h
   # End Source File
   # Begin Source File
   
  -SOURCE=.\include\ap_hooks.h
  +SOURCE=.\include\apr_hooks.h
   # End Source File
   # Begin Source File
   
  -SOURCE=.\include\ap_ring.h
  +SOURCE=.\include\apr_ring.h
   # End Source File
   # Begin Source File
   
  -SOURCE=.\include\ap_sha1.h
  +SOURCE=.\include\apr_sha1.h
   # End Source File
   # Begin Source File
   
  
  
  
  1.8       +20 -20    apr-util/libaprutil.dsp
  
  Index: libaprutil.dsp
  ===================================================================
  RCS file: /home/cvs/apr-util/libaprutil.dsp,v
  retrieving revision 1.7
  retrieving revision 1.8
  diff -u -r1.7 -r1.8
  --- libaprutil.dsp	2001/01/18 23:30:52	1.7
  +++ libaprutil.dsp	2001/01/19 07:01:58	1.8
  @@ -95,51 +95,51 @@
   # PROP Default_Filter ""
   # Begin Source File
   
  -SOURCE=.\buckets\ap_brigade.c
  +SOURCE=.\buckets\apr_brigade.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets.c
  +SOURCE=.\buckets\apr_buckets.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_eos.c
  +SOURCE=.\buckets\apr_buckets_eos.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_file.c
  +SOURCE=.\buckets\apr_buckets_file.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_flush.c
  +SOURCE=.\buckets\apr_buckets_flush.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_heap.c
  +SOURCE=.\buckets\apr_buckets_heap.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_mmap.c
  +SOURCE=.\buckets\apr_buckets_mmap.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_pipe.c
  +SOURCE=.\buckets\apr_buckets_pipe.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_pool.c
  +SOURCE=.\buckets\apr_buckets_pool.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_refcount.c
  +SOURCE=.\buckets\apr_buckets_refcount.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_simple.c
  +SOURCE=.\buckets\apr_buckets_simple.c
   # End Source File
   # Begin Source File
   
  -SOURCE=.\buckets\ap_buckets_socket.c
  +SOURCE=.\buckets\apr_buckets_socket.c
   # End Source File
   # End Group
   # Begin Group "crypto"
  @@ -147,7 +147,7 @@
   # PROP Default_Filter ""
   # Begin Source File
   
  -SOURCE=.\crypto\ap_sha1.c
  +SOURCE=.\crypto\apr_sha1.c
   # End Source File
   # End Group
   # Begin Group "dbm"
  @@ -195,7 +195,7 @@
   # PROP Default_Filter ""
   # Begin Source File
   
  -SOURCE=.\encoding\ap_base64.c
  +SOURCE=.\encoding\apr_base64.c
   # End Source File
   # End Group
   # Begin Group "hooks"
  @@ -203,7 +203,7 @@
   # PROP Default_Filter ""
   # Begin Source File
   
  -SOURCE=.\hooks\ap_hooks.c
  +SOURCE=.\hooks\apr_hooks.c
   # End Source File
   # End Group
   # Begin Group "uri"
  @@ -286,23 +286,23 @@
   # PROP Default_Filter ""
   # Begin Source File
   
  -SOURCE=.\include\ap_base64.h
  +SOURCE=.\include\apr_base64.h
   # End Source File
   # Begin Source File
   
  -SOURCE=.\include\ap_buckets.h
  +SOURCE=.\include\apr_buckets.h
   # End Source File
   # Begin Source File
   
  -SOURCE=.\include\ap_hooks.h
  +SOURCE=.\include\apr_hooks.h
   # End Source File
   # Begin Source File
   
  -SOURCE=.\include\ap_ring.h
  +SOURCE=.\include\apr_ring.h
   # End Source File
   # Begin Source File
   
  -SOURCE=.\include\ap_sha1.h
  +SOURCE=.\include\apr_sha1.h
   # End Source File
   # Begin Source File
   
  
  
  
  1.10      +4 -4      apr-util/buckets/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/Makefile.in,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- Makefile.in	2001/01/17 04:29:26	1.9
  +++ Makefile.in	2001/01/19 07:01:59	1.10
  @@ -1,8 +1,8 @@
   
  -TARGETS = ap_buckets_file.lo ap_buckets_pool.lo ap_buckets_flush.lo \
  -ap_buckets_refcount.lo ap_buckets_heap.lo ap_buckets_simple.lo ap_buckets.lo \
  -ap_buckets_mmap.lo ap_buckets_socket.lo ap_buckets_eos.lo ap_buckets_pipe.lo \
  -ap_brigade.lo
  +TARGETS = apr_buckets_file.lo apr_buckets_pool.lo apr_buckets_flush.lo \
  +apr_buckets_refcount.lo apr_buckets_heap.lo apr_buckets_simple.lo apr_buckets.lo \
  +apr_buckets_mmap.lo apr_buckets_socket.lo apr_buckets_eos.lo apr_buckets_pipe.lo \
  +apr_brigade.lo
   
   # bring in rules.mk for standard functionality
   @INCLUDE_RULES@
  
  
  
  1.3       +52 -52    apr-util/buckets/apr_brigade.c
  
  Index: apr_brigade.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_brigade.c,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- apr_brigade.c	2001/01/17 04:29:26	1.2
  +++ apr_brigade.c	2001/01/19 07:01:59	1.3
  @@ -66,100 +66,100 @@
   #include <sys/uio.h>
   #endif
   
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   
  -static apr_status_t ap_brigade_cleanup(void *data)
  +static apr_status_t apr_brigade_cleanup(void *data)
   {
  -    ap_bucket_brigade *b = data;
  -    ap_bucket *e;
  +    apr_bucket_brigade *b = data;
  +    apr_bucket *e;
   
       /*
  -     * Bah! We can't use AP_RING_FOREACH here because this bucket has
  +     * Bah! We can't use APR_RING_FOREACH here because this bucket has
        * gone away when we dig inside it to get the next one.
        */
  -    while (!AP_BRIGADE_EMPTY(b)) {
  -	e = AP_BRIGADE_FIRST(b);
  -	AP_BUCKET_REMOVE(e);
  -	ap_bucket_destroy(e);
  +    while (!APR_BRIGADE_EMPTY(b)) {
  +	e = APR_BRIGADE_FIRST(b);
  +	APR_BUCKET_REMOVE(e);
  +	apr_bucket_destroy(e);
       }
       /*
        * We don't need to free(bb) because it's allocated from a pool.
        */
       return APR_SUCCESS;
   }
  -APU_DECLARE(apr_status_t) ap_brigade_destroy(ap_bucket_brigade *b)
  +APU_DECLARE(apr_status_t) apr_brigade_destroy(apr_bucket_brigade *b)
   {
  -    apr_kill_cleanup(b->p, b, ap_brigade_cleanup);
  -    return ap_brigade_cleanup(b);
  +    apr_kill_cleanup(b->p, b, apr_brigade_cleanup);
  +    return apr_brigade_cleanup(b);
   }
   
  -APU_DECLARE(ap_bucket_brigade *) ap_brigade_create(apr_pool_t *p)
  +APU_DECLARE(apr_bucket_brigade *) apr_brigade_create(apr_pool_t *p)
   {
  -    ap_bucket_brigade *b;
  +    apr_bucket_brigade *b;
   
       b = apr_palloc(p, sizeof(*b));
       b->p = p;
  -    AP_RING_INIT(&b->list, ap_bucket, link);
  +    APR_RING_INIT(&b->list, apr_bucket, link);
   
  -    apr_register_cleanup(b->p, b, ap_brigade_cleanup, ap_brigade_cleanup);
  +    apr_register_cleanup(b->p, b, apr_brigade_cleanup, apr_brigade_cleanup);
       return b;
   }
   
  -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)
   {
  -    ap_bucket_brigade *a;
  -    ap_bucket *f;
  +    apr_bucket_brigade *a;
  +    apr_bucket *f;
   
  -    a = ap_brigade_create(b->p);
  +    a = apr_brigade_create(b->p);
       /* Return an empty brigade if there is nothing left in 
        * the first brigade to split off 
        */
  -    if (e != AP_BRIGADE_SENTINEL(b)) {
  -        f = AP_RING_LAST(&b->list);
  -        AP_RING_UNSPLICE(e, f, link);
  -        AP_RING_SPLICE_HEAD(&a->list, e, f, ap_bucket, link);
  +    if (e != APR_BRIGADE_SENTINEL(b)) {
  +        f = APR_RING_LAST(&b->list);
  +        APR_RING_UNSPLICE(e, f, link);
  +        APR_RING_SPLICE_HEAD(&a->list, e, f, apr_bucket, link);
       }
       return a;
   }
   
  -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)
   {
  -    ap_bucket *e;
  +    apr_bucket *e;
       const char *s;
       apr_size_t len;
   
       if (point < 0)
           return NULL;
   
  -    AP_BRIGADE_FOREACH(e, b) {
  +    APR_BRIGADE_FOREACH(e, b) {
           /* bucket is of a known length */
           if ((point > e->length) && (e->length != -1)) {
  -            if (AP_BUCKET_IS_EOS(e))
  +            if (APR_BUCKET_IS_EOS(e))
                   return NULL;
               point -= e->length;
           }
           else if (point == e->length) {
  -            return AP_BUCKET_NEXT(e);
  +            return APR_BUCKET_NEXT(e);
           }
           else {
               /* try to split the bucket natively */
  -            if (ap_bucket_split(e, point) != APR_ENOTIMPL)
  -                return AP_BUCKET_NEXT(e);
  +            if (apr_bucket_split(e, point) != APR_ENOTIMPL)
  +                return APR_BUCKET_NEXT(e);
   
               /* if the bucket cannot be split, we must read from it,
                * changing its type to one that can be split */
  -            if (ap_bucket_read(e, &s, &len, AP_BLOCK_READ) != APR_SUCCESS)
  +            if (apr_bucket_read(e, &s, &len, APR_BLOCK_READ) != APR_SUCCESS)
                   return NULL;
   
               if (point < len) {
  -                if (ap_bucket_split(e, point) == APR_SUCCESS)
  -                    return AP_BUCKET_NEXT(e);
  +                if (apr_bucket_split(e, point) == APR_SUCCESS)
  +                    return APR_BUCKET_NEXT(e);
                   else
                       return NULL;
               }
               else if (point == len)
  -                return AP_BUCKET_NEXT(e);
  +                return APR_BUCKET_NEXT(e);
               else
                   point -= len;
           }
  @@ -167,27 +167,27 @@
       return NULL;
   }
   
  -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)
   {
  -    ap_bucket *e;
  +    apr_bucket *e;
       struct iovec *orig;
       apr_size_t iov_len;
   
       orig = vec;
  -    AP_BRIGADE_FOREACH(e, b) {
  +    APR_BRIGADE_FOREACH(e, b) {
   	if (nvec-- == 0)
               break;
  -	ap_bucket_read(e, (const char **)&vec->iov_base, &iov_len, AP_NONBLOCK_READ);
  +	apr_bucket_read(e, (const char **)&vec->iov_base, &iov_len, APR_NONBLOCK_READ);
           vec->iov_len = iov_len; /* set indirectly in case size differs */
   	++vec;
       }
       return vec - orig;
   }
   
  -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)
   {
  -    ap_bucket *r;
  +    apr_bucket *r;
       const char *x;
       int j, k;
       apr_size_t i;
  @@ -199,54 +199,54 @@
           j = strlen(x);
          
   	/* XXX: copy or not? let the caller decide? */
  -        r = ap_bucket_create_heap(x, j, 1, &i);
  +        r = apr_bucket_create_heap(x, j, 1, &i);
           if (i != j) {
               /* Do we need better error reporting?  */
               return -1;
           }
           k += i;
   
  -        AP_BRIGADE_INSERT_TAIL(b, r);
  +        APR_BRIGADE_INSERT_TAIL(b, r);
       }
   
       return k;
   }
   
  -APU_DECLARE_NONSTD(int) ap_brigade_putstrs(ap_bucket_brigade *b, ...)
  +APU_DECLARE_NONSTD(int) apr_brigade_putstrs(apr_bucket_brigade *b, ...)
   {
       va_list va;
       int written;
   
       va_start(va, b);
  -    written = ap_brigade_vputstrs(b, va);
  +    written = apr_brigade_vputstrs(b, va);
       va_end(va);
       return written;
   }
   
  -APU_DECLARE_NONSTD(int) ap_brigade_printf(ap_bucket_brigade *b, const char *fmt, ...)
  +APU_DECLARE_NONSTD(int) apr_brigade_printf(apr_bucket_brigade *b, const char *fmt, ...)
   {
       va_list ap;
       int res;
   
       va_start(ap, fmt);
  -    res = ap_brigade_vprintf(b, fmt, ap);
  +    res = apr_brigade_vprintf(b, fmt, ap);
       va_end(ap);
       return res;
   }
   
  -APU_DECLARE(int) ap_brigade_vprintf(ap_bucket_brigade *b, const char *fmt, va_list va)
  +APU_DECLARE(int) apr_brigade_vprintf(apr_bucket_brigade *b, const char *fmt, va_list va)
   {
       /* XXX:  This needs to be replaced with a function to printf
        * directly into a bucket.  I'm being lazy right now.  RBB
        */
       char buf[4096];
  -    ap_bucket *r;
  +    apr_bucket *r;
       int res;
   
       res = apr_vsnprintf(buf, 4096, fmt, va);
   
  -    r = ap_bucket_create_heap(buf, strlen(buf), 1, NULL);
  -    AP_BRIGADE_INSERT_TAIL(b, r);
  +    r = apr_bucket_create_heap(buf, strlen(buf), 1, NULL);
  +    APR_BRIGADE_INSERT_TAIL(b, r);
   
       return res;
   }
  
  
  
  1.44      +18 -18    apr-util/buckets/apr_buckets.c
  
  Index: apr_buckets.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_buckets.c,v
  retrieving revision 1.43
  retrieving revision 1.44
  diff -u -r1.43 -r1.44
  --- apr_buckets.c	2001/01/18 23:30:54	1.43
  +++ apr_buckets.c	2001/01/19 07:02:00	1.44
  @@ -66,50 +66,50 @@
   #include <sys/uio.h>
   #endif
   
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   
   static apr_array_header_t *bucket_types;
   
  -APU_DECLARE(void) ap_init_bucket_types(apr_pool_t *p)
  +APU_DECLARE(void) apr_init_bucket_types(apr_pool_t *p)
   {
  -    bucket_types = apr_make_array(p, 8, sizeof(ap_bucket_type));
  +    bucket_types = apr_make_array(p, 8, sizeof(apr_bucket_type_t));
   
  -    ap_insert_bucket_type(&ap_eos_type);
  -    ap_insert_bucket_type(&ap_file_type);
  -    ap_insert_bucket_type(&ap_heap_type);
  +    apr_insert_bucket_type(&apr_bucket_type_eos);
  +    apr_insert_bucket_type(&apr_bucket_type_file);
  +    apr_insert_bucket_type(&apr_bucket_type_heap);
   #if APR_HAS_MMAP
  -    ap_insert_bucket_type(&ap_mmap_type);
  +    apr_insert_bucket_type(&apr_bucket_type_mmap);
   #endif
  -    ap_insert_bucket_type(&ap_pipe_type);
  -    ap_insert_bucket_type(&ap_immortal_type);
  -    ap_insert_bucket_type(&ap_transient_type);
  -    ap_insert_bucket_type(&ap_socket_type);
  +    apr_insert_bucket_type(&apr_bucket_type_pipe);
  +    apr_insert_bucket_type(&apr_bucket_type_immortal);
  +    apr_insert_bucket_type(&apr_bucket_type_transient);
  +    apr_insert_bucket_type(&apr_bucket_type_socket);
   }
   
  -int ap_insert_bucket_type(const ap_bucket_type *type)
  +int apr_insert_bucket_type(const apr_bucket_type_t *type)
   {
  -    const ap_bucket_type **newone;
  +    const apr_bucket_type_t **newone;
   
  -    newone = (const ap_bucket_type **)apr_push_array(bucket_types);
  +    newone = (const apr_bucket_type_t **)apr_push_array(bucket_types);
       newone = &type;
   
       return bucket_types->nelts - 1;
   }
   
  -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)
   {
       return APR_ENOTIMPL;
   }
   
  -APU_DECLARE_NONSTD(apr_status_t) ap_bucket_split_notimpl(ap_bucket *data, apr_off_t point)
  +APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_notimpl(apr_bucket *data, apr_off_t point)
   {
       return APR_ENOTIMPL;
   }
  -APU_DECLARE_NONSTD(apr_status_t) ap_bucket_copy_notimpl(ap_bucket *e, ap_bucket **c)
  +APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_notimpl(apr_bucket *e, apr_bucket **c)
   {
       return APR_ENOTIMPL;
   }
  -APU_DECLARE_NONSTD(void) ap_bucket_destroy_notimpl(void *data)
  +APU_DECLARE_NONSTD(void) apr_bucket_destroy_notimpl(void *data)
   {
       return;
   }
  
  
  
  1.18      +13 -13    apr-util/buckets/apr_buckets_eos.c
  
  Index: apr_buckets_eos.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_buckets_eos.c,v
  retrieving revision 1.17
  retrieving revision 1.18
  diff -u -r1.17 -r1.18
  --- apr_buckets_eos.c	2000/12/21 18:06:15	1.17
  +++ apr_buckets_eos.c	2001/01/19 07:02:00	1.18
  @@ -52,43 +52,43 @@
    * <http://www.apache.org/>.
    */
   
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   #include <stdlib.h>
   
  -static apr_status_t eos_read(ap_bucket *b, const char **str, 
  -                                apr_size_t *len, ap_read_type block)
  +static apr_status_t eos_read(apr_bucket *b, const char **str, 
  +                                apr_size_t *len, apr_read_type_e block)
   {
       *str = NULL;
       *len = 0;
       return APR_SUCCESS;
   }
   
  -static apr_status_t eos_copy(ap_bucket *e, ap_bucket **c)
  +static apr_status_t eos_copy(apr_bucket *e, apr_bucket **c)
   {
  -    *c = ap_bucket_create_eos();
  +    *c = apr_bucket_create_eos();
       return APR_SUCCESS;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_make_eos(ap_bucket *b)
  +APU_DECLARE(apr_bucket *) apr_bucket_make_eos(apr_bucket *b)
   {
       b->length    = 0;
       b->data      = NULL;
   
  -    b->type      = &ap_eos_type;
  +    b->type      = &apr_bucket_type_eos;
       
       return b;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_create_eos(void)
  +APU_DECLARE(apr_bucket *) apr_bucket_create_eos(void)
   {
  -    ap_bucket_do_create(ap_bucket_make_eos(b));
  +    apr_bucket_do_create(apr_bucket_make_eos(b));
   }
   
  -APU_DECLARE_DATA const ap_bucket_type ap_eos_type = {
  +APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_eos = {
       "EOS", 5,
  -    ap_bucket_destroy_notimpl,
  +    apr_bucket_destroy_notimpl,
       eos_read,
  -    ap_bucket_setaside_notimpl,
  -    ap_bucket_split_notimpl,
  +    apr_bucket_setaside_notimpl,
  +    apr_bucket_split_notimpl,
       eos_copy
   };
  
  
  
  1.20      +19 -19    apr-util/buckets/apr_buckets_file.c
  
  Index: apr_buckets_file.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_buckets_file.c,v
  retrieving revision 1.19
  retrieving revision 1.20
  diff -u -r1.19 -r1.20
  --- apr_buckets_file.c	2001/01/05 18:18:30	1.19
  +++ apr_buckets_file.c	2001/01/19 07:02:00	1.20
  @@ -56,7 +56,7 @@
   #include "apr_general.h"
   #include "apr_lib.h"
   #include "apr_file_io.h"
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   #include <stdlib.h>
   
   /* Allow Apache to use ap_mmap */
  @@ -86,12 +86,12 @@
   
   
   /* XXX: We should obey the block flag */
  -static apr_status_t file_read(ap_bucket *e, const char **str,
  -			      apr_size_t *len, ap_read_type block)
  +static apr_status_t file_read(apr_bucket *e, const char **str,
  +			      apr_size_t *len, apr_read_type_e block)
   {
  -    ap_bucket_file *a = (ap_bucket_file *)e->data;
  +    apr_bucket_file *a = (apr_bucket_file *)e->data;
       apr_file_t *f = (apr_file_t *) a->fd;
  -    ap_bucket *b = NULL;
  +    apr_bucket *b = NULL;
       char *buf;
       apr_status_t rv;
   #if APR_HAS_MMAP
  @@ -114,8 +114,8 @@
           mm = NULL;
       }
       if (mm) {
  -        ap_bucket_make_mmap(e, mm, 0, e->length); /*XXX: check for failure? */
  -        return ap_bucket_read(e, str, len, block);
  +        apr_bucket_make_mmap(e, mm, 0, e->length); /*XXX: check for failure? */
  +        return apr_bucket_read(e, str, len, block);
       }
       else {
   #endif
  @@ -150,12 +150,12 @@
            * Change the current bucket to refer to what we read,
            * even if we read nothing because we hit EOF.
            */
  -        ap_bucket_make_heap(e, buf, *len, 0, NULL); /*XXX: check for failure? */
  +        apr_bucket_make_heap(e, buf, *len, 0, NULL); /*XXX: check for failure? */
   
           /* If we have more to read from the file, then create another bucket */
           if (*len > 0) {
  -            b = ap_bucket_create_file(f, 0, e->length);
  -            AP_BUCKET_INSERT_AFTER(e, b);
  +            b = apr_bucket_create_file(f, 0, e->length);
  +            APR_BUCKET_INSERT_AFTER(e, b);
           }
   #if APR_HAS_MMAP
       }
  @@ -163,10 +163,10 @@
       return APR_SUCCESS;
   }
   
  -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)
   {
  -    ap_bucket_file *f;
  +    apr_bucket_file *f;
   
       f = malloc(sizeof(*f));
       if (f == NULL) {
  @@ -176,24 +176,24 @@
       f->fd = fd;
       f->offset = offset;
   
  -    b->type = &ap_file_type;
  +    b->type = &apr_bucket_type_file;
       b->data = f;
       b->length = len;
   
       return b;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_create_file(apr_file_t *fd,
  +APU_DECLARE(apr_bucket *) apr_bucket_create_file(apr_file_t *fd,
                                                 apr_off_t offset, apr_size_t len)
   {
  -    ap_bucket_do_create(ap_bucket_make_file(b, fd, offset, len));
  +    apr_bucket_do_create(apr_bucket_make_file(b, fd, offset, len));
   }
   
  -APU_DECLARE_DATA const ap_bucket_type ap_file_type = {
  +APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_file = {
       "FILE", 5,
       free,
       file_read,
  -    ap_bucket_setaside_notimpl,
  -    ap_bucket_split_notimpl,
  -    ap_bucket_copy_notimpl
  +    apr_bucket_setaside_notimpl,
  +    apr_bucket_split_notimpl,
  +    apr_bucket_copy_notimpl
   };
  
  
  
  1.10      +13 -13    apr-util/buckets/apr_buckets_flush.c
  
  Index: apr_buckets_flush.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_buckets_flush.c,v
  retrieving revision 1.9
  retrieving revision 1.10
  diff -u -r1.9 -r1.10
  --- apr_buckets_flush.c	2000/12/21 18:06:15	1.9
  +++ apr_buckets_flush.c	2001/01/19 07:02:00	1.10
  @@ -52,43 +52,43 @@
    * <http://www.apache.org/>.
    */
   
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   #include <stdlib.h>
   
  -static apr_status_t flush_read(ap_bucket *b, const char **str, 
  -                                apr_size_t *len, ap_read_type block)
  +static apr_status_t flush_read(apr_bucket *b, const char **str, 
  +                                apr_size_t *len, apr_read_type_e block)
   {
       *str = NULL;
       *len = 0;
       return APR_SUCCESS;
   }
   
  -static apr_status_t flush_copy(ap_bucket *e, ap_bucket **c)
  +static apr_status_t flush_copy(apr_bucket *e, apr_bucket **c)
   {
  -    *c = ap_bucket_create_flush();
  +    *c = apr_bucket_create_flush();
       return APR_SUCCESS;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_make_flush(ap_bucket *b)
  +APU_DECLARE(apr_bucket *) apr_bucket_make_flush(apr_bucket *b)
   {
       b->length    = 0;
       b->data      = NULL;
   
  -    b->type      = &ap_flush_type;
  +    b->type      = &apr_bucket_type_flush;
       
       return b;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_create_flush(void)
  +APU_DECLARE(apr_bucket *) apr_bucket_create_flush(void)
   {
  -    ap_bucket_do_create(ap_bucket_make_flush(b));
  +    apr_bucket_do_create(apr_bucket_make_flush(b));
   }
   
  -APU_DECLARE_DATA const ap_bucket_type ap_flush_type = {
  +APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_flush = {
       "FLUSH", 5,
  -    ap_bucket_destroy_notimpl,
  +    apr_bucket_destroy_notimpl,
       flush_read,
  -    ap_bucket_setaside_notimpl,
  -    ap_bucket_split_notimpl,
  +    apr_bucket_setaside_notimpl,
  +    apr_bucket_split_notimpl,
       flush_copy
   };
  
  
  
  1.23      +17 -17    apr-util/buckets/apr_buckets_heap.c
  
  Index: apr_buckets_heap.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_buckets_heap.c,v
  retrieving revision 1.22
  retrieving revision 1.23
  diff -u -r1.22 -r1.23
  --- apr_buckets_heap.c	2000/12/29 14:01:52	1.22
  +++ apr_buckets_heap.c	2001/01/19 07:02:00	1.23
  @@ -52,7 +52,7 @@
    * <http://www.apache.org/>.
    */
   
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   #include <stdlib.h>
   #if APR_HAVE_STRINGS_H
   #include <strings.h>
  @@ -72,11 +72,11 @@
   ((x) >= (y) ? (x) : (y))
   #endif
   
  -static apr_status_t heap_read(ap_bucket *b, const char **str, 
  -			      apr_size_t *len, ap_read_type block)
  +static apr_status_t heap_read(apr_bucket *b, const char **str, 
  +			      apr_size_t *len, apr_read_type_e block)
   {
  -    ap_bucket_shared *s = b->data;
  -    ap_bucket_heap *h = s->data;
  +    apr_bucket_shared *s = b->data;
  +    apr_bucket_heap *h = s->data;
   
       *str = h->base + s->start;
       *len = s->end - s->start;
  @@ -85,9 +85,9 @@
   
   static void heap_destroy(void *data)
   {
  -    ap_bucket_heap *h;
  +    apr_bucket_heap *h;
   
  -    h = ap_bucket_destroy_shared(data);
  +    h = apr_bucket_destroy_shared(data);
       if (h == NULL) {
   	return;
       }
  @@ -95,10 +95,10 @@
       free(h);
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_make_heap(ap_bucket *b,
  +APU_DECLARE(apr_bucket *) apr_bucket_make_heap(apr_bucket *b,
   		const char *buf, apr_size_t length, int copy, apr_size_t *w)
   {
  -    ap_bucket_heap *h;
  +    apr_bucket_heap *h;
   
       h = malloc(sizeof(*h));
       if (h == NULL) {
  @@ -122,7 +122,7 @@
   	h->alloc_len = length;
       }
   
  -    b = ap_bucket_make_shared(b, h, 0, length);
  +    b = apr_bucket_make_shared(b, h, 0, length);
       if (b == NULL) {
   	if (copy) {
   	    free(h->base);
  @@ -131,7 +131,7 @@
   	return NULL;
       }
   
  -    b->type = &ap_heap_type;
  +    b->type = &apr_bucket_type_heap;
   
       if (w)
           *w = length;
  @@ -139,17 +139,17 @@
       return b;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_create_heap(
  +APU_DECLARE(apr_bucket *) apr_bucket_create_heap(
   		const char *buf, apr_size_t length, int copy, apr_size_t *w)
   {
  -    ap_bucket_do_create(ap_bucket_make_heap(b, buf, length, copy, w));
  +    apr_bucket_do_create(apr_bucket_make_heap(b, buf, length, copy, w));
   }
   
  -APU_DECLARE_DATA const ap_bucket_type ap_heap_type = {
  +APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_heap = {
       "HEAP", 5,
       heap_destroy,
       heap_read,
  -    ap_bucket_setaside_notimpl,
  -    ap_bucket_split_shared,
  -    ap_bucket_copy_shared
  +    apr_bucket_setaside_notimpl,
  +    apr_bucket_split_shared,
  +    apr_bucket_copy_shared
   };
  
  
  
  1.25      +17 -17    apr-util/buckets/apr_buckets_mmap.c
  
  Index: apr_buckets_mmap.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_buckets_mmap.c,v
  retrieving revision 1.24
  retrieving revision 1.25
  diff -u -r1.24 -r1.25
  --- apr_buckets_mmap.c	2000/12/21 18:06:15	1.24
  +++ apr_buckets_mmap.c	2001/01/19 07:02:00	1.25
  @@ -52,14 +52,14 @@
    * <http://www.apache.org/>.
    */
   
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   #include <stdlib.h>
   
  -static apr_status_t mmap_read(ap_bucket *b, const char **str, 
  -			      apr_size_t *length, ap_read_type block)
  +static apr_status_t mmap_read(apr_bucket *b, const char **str, 
  +			      apr_size_t *length, apr_read_type_e block)
   {
  -    ap_bucket_shared *s = b->data;
  -    ap_bucket_mmap *m = s->data;
  +    apr_bucket_shared *s = b->data;
  +    apr_bucket_mmap *m = s->data;
       apr_status_t ok;
       void *addr;
       
  @@ -74,9 +74,9 @@
   
   static void mmap_destroy(void *data)
   {
  -    ap_bucket_mmap *m;
  +    apr_bucket_mmap *m;
   
  -    m = ap_bucket_destroy_shared(data);
  +    m = apr_bucket_destroy_shared(data);
       if (m == NULL) {
   	return;
       }
  @@ -86,10 +86,10 @@
   /*
    * XXX: are the start and length arguments useful?
    */
  -APU_DECLARE(ap_bucket *) ap_bucket_make_mmap(ap_bucket *b,
  +APU_DECLARE(apr_bucket *) apr_bucket_make_mmap(apr_bucket *b,
   		apr_mmap_t *mm, apr_off_t start, apr_size_t length)
   {
  -    ap_bucket_mmap *m;
  +    apr_bucket_mmap *m;
   
       m = malloc(sizeof(*m));
       if (m == NULL) {
  @@ -97,29 +97,29 @@
       }
       m->mmap = mm;
   
  -    b = ap_bucket_make_shared(b, m, start, start+length);
  +    b = apr_bucket_make_shared(b, m, start, start+length);
       if (b == NULL) {
   	free(m);
   	return NULL;
       }
   
  -    b->type     = &ap_mmap_type;
  +    b->type     = &apr_bucket_type_mmap;
   
       return b;
   }
   
   
  -APU_DECLARE(ap_bucket *) ap_bucket_create_mmap(
  +APU_DECLARE(apr_bucket *) apr_bucket_create_mmap(
   		apr_mmap_t *mm, apr_off_t start, apr_size_t length)
   {
  -    ap_bucket_do_create(ap_bucket_make_mmap(b, mm, start, length));
  +    apr_bucket_do_create(apr_bucket_make_mmap(b, mm, start, length));
   }
   
  -APU_DECLARE_DATA const ap_bucket_type ap_mmap_type = {
  +APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_mmap = {
       "MMAP", 5,
       mmap_destroy,
       mmap_read,
  -    ap_bucket_setaside_notimpl,
  -    ap_bucket_split_shared,
  -    ap_bucket_copy_shared
  +    apr_bucket_setaside_notimpl,
  +    apr_bucket_split_shared,
  +    apr_bucket_copy_shared
   };
  
  
  
  1.26      +19 -19    apr-util/buckets/apr_buckets_pipe.c
  
  Index: apr_buckets_pipe.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_buckets_pipe.c,v
  retrieving revision 1.25
  retrieving revision 1.26
  diff -u -r1.25 -r1.26
  --- apr_buckets_pipe.c	2000/12/22 05:56:37	1.25
  +++ apr_buckets_pipe.c	2001/01/19 07:02:00	1.26
  @@ -53,19 +53,19 @@
    */
   
   #include "apr_lib.h"
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   #include <stdlib.h>
   
  -static apr_status_t pipe_read(ap_bucket *a, const char **str,
  -			      apr_size_t *len, ap_read_type block)
  +static apr_status_t pipe_read(apr_bucket *a, const char **str,
  +			      apr_size_t *len, apr_read_type_e block)
   {
       apr_file_t *p = a->data;
  -    ap_bucket *b;
  +    apr_bucket *b;
       char *buf;
       apr_status_t rv;
       apr_interval_time_t timeout;
   
  -    if (block == AP_NONBLOCK_READ) {
  +    if (block == APR_NONBLOCK_READ) {
           apr_get_pipe_timeout(p, &timeout);
           apr_set_pipe_timeout(p, 0);
       }
  @@ -75,7 +75,7 @@
       *len = HUGE_STRING_LEN;
       rv = apr_read(p, buf, len);
   
  -    if (block == AP_NONBLOCK_READ) {
  +    if (block == APR_NONBLOCK_READ) {
           apr_set_pipe_timeout(p, timeout);
       }
   
  @@ -88,7 +88,7 @@
        * Change the current bucket to refer to what we read,
        * even if we read nothing because we hit EOF.
        */
  -    ap_bucket_make_heap(a, buf, *len, 0, NULL);  /* XXX: check for failure? */
  +    apr_bucket_make_heap(a, buf, *len, 0, NULL);  /* XXX: check for failure? */
       /*
        * If there's more to read we have to keep the rest of the pipe
        * for later.  Otherwise, we'll close the pipe.
  @@ -102,17 +102,17 @@
        * new bucket.
        */
       if (*len > 0) {
  -        b = ap_bucket_create_pipe(p);
  -	AP_BUCKET_INSERT_AFTER(a, b);
  +        b = apr_bucket_create_pipe(p);
  +	APR_BUCKET_INSERT_AFTER(a, b);
       }
       else if (rv == APR_EOF) {
           apr_close(p);
  -        return (block == AP_NONBLOCK_READ) ? APR_EOF : APR_SUCCESS;
  +        return (block == APR_NONBLOCK_READ) ? APR_EOF : APR_SUCCESS;
       }
       return APR_SUCCESS;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_make_pipe(ap_bucket *b, apr_file_t *p)
  +APU_DECLARE(apr_bucket *) apr_bucket_make_pipe(apr_bucket *b, apr_file_t *p)
   {
       /*
        * A pipe is closed when the end is reached in pipe_read().  If the
  @@ -127,23 +127,23 @@
        * stream so the bucket(s) that it sets aside will be the heap
        * buckets created by pipe_read() above.
        */
  -    b->type     = &ap_pipe_type;
  +    b->type     = &apr_bucket_type_pipe;
       b->length   = -1;
       b->data     = p;
   
       return b;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_create_pipe(apr_file_t *p)
  +APU_DECLARE(apr_bucket *) apr_bucket_create_pipe(apr_file_t *p)
   {
  -    ap_bucket_do_create(ap_bucket_make_pipe(b, p));
  +    apr_bucket_do_create(apr_bucket_make_pipe(b, p));
   }
   
  -APU_DECLARE_DATA const ap_bucket_type ap_pipe_type = {
  +APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_pipe = {
       "PIPE", 5,
  -    ap_bucket_destroy_notimpl,
  +    apr_bucket_destroy_notimpl,
       pipe_read,
  -    ap_bucket_setaside_notimpl,
  -    ap_bucket_split_notimpl,
  -    ap_bucket_copy_notimpl
  +    apr_bucket_setaside_notimpl,
  +    apr_bucket_split_notimpl,
  +    apr_bucket_copy_notimpl
   };
  
  
  
  1.9       +24 -24    apr-util/buckets/apr_buckets_pool.c
  
  Index: apr_buckets_pool.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_buckets_pool.c,v
  retrieving revision 1.8
  retrieving revision 1.9
  diff -u -r1.8 -r1.9
  --- apr_buckets_pool.c	2000/12/21 18:06:15	1.8
  +++ apr_buckets_pool.c	2001/01/19 07:02:00	1.9
  @@ -52,32 +52,32 @@
    * <http://www.apache.org/>.
    */
   
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   #include <stdlib.h>
   
   static apr_status_t pool_bucket_cleanup(void *data)
   {
  -    ap_bucket_shared *s = data;
  -    ap_bucket_shared *new;
  -    ap_bucket_pool *h = s->data;
  -    ap_bucket *b = h->b;
  +    apr_bucket_shared *s = data;
  +    apr_bucket_shared *new;
  +    apr_bucket_pool *h = s->data;
  +    apr_bucket *b = h->b;
       apr_size_t w;
   
  -    ap_bucket_make_heap(b, h->base, b->length, 1, &w);
  +    apr_bucket_make_heap(b, h->base, b->length, 1, &w);
       new = b->data;
   
       new->start = s->start;
       new->end = s->end;
   
  -    ap_bucket_destroy_shared(s);
  +    apr_bucket_destroy_shared(s);
       return APR_SUCCESS;
   }
   
  -static apr_status_t pool_read(ap_bucket *b, const char **str, 
  -			      apr_size_t *len, ap_read_type block)
  +static apr_status_t pool_read(apr_bucket *b, const char **str, 
  +			      apr_size_t *len, apr_read_type_e block)
   {
  -    ap_bucket_shared *s = b->data;
  -    ap_bucket_pool *h = s->data;
  +    apr_bucket_shared *s = b->data;
  +    apr_bucket_pool *h = s->data;
   
       *str = h->base + s->start;
       *len = s->end - s->start;
  @@ -86,21 +86,21 @@
   
   static void pool_destroy(void *data)
   {
  -    ap_bucket_shared *s = data;
  -    ap_bucket_pool *h = s->data;
  +    apr_bucket_shared *s = data;
  +    apr_bucket_pool *h = s->data;
   
       apr_kill_cleanup(h->p, data, pool_bucket_cleanup);
  -    h = ap_bucket_destroy_shared(data);
  +    h = apr_bucket_destroy_shared(data);
       if (h == NULL) {
   	return;
       }
       free(h);
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_make_pool(ap_bucket *b,
  +APU_DECLARE(apr_bucket *) apr_bucket_make_pool(apr_bucket *b,
   		const char *buf, apr_size_t length, apr_pool_t *p)
   {
  -    ap_bucket_pool *h;
  +    apr_bucket_pool *h;
   
       h = malloc(sizeof(*h));
       if (h == NULL) {
  @@ -113,30 +113,30 @@
       h->base = (char *) buf;
       h->p    = p;
   
  -    b = ap_bucket_make_shared(b, h, 0, length);
  +    b = apr_bucket_make_shared(b, h, 0, length);
       if (b == NULL) {
   	free(h);
   	return NULL;
       }
   
  -    b->type = &ap_pool_type;
  +    b->type = &apr_bucket_type_pool;
       h->b = b;
   
       apr_register_cleanup(h->p, b->data, pool_bucket_cleanup, apr_null_cleanup);
       return b;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_create_pool(
  +APU_DECLARE(apr_bucket *) apr_bucket_create_pool(
   		const char *buf, apr_size_t length, apr_pool_t *p)
   {
  -    ap_bucket_do_create(ap_bucket_make_pool(b, buf, length, p));
  +    apr_bucket_do_create(apr_bucket_make_pool(b, buf, length, p));
   }
   
  -APU_DECLARE_DATA const ap_bucket_type ap_pool_type = {
  +APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_pool = {
       "POOL", 5,
       pool_destroy,
       pool_read,
  -    ap_bucket_setaside_notimpl,
  -    ap_bucket_split_shared,
  -    ap_bucket_copy_shared
  +    apr_bucket_setaside_notimpl,
  +    apr_bucket_split_shared,
  +    apr_bucket_copy_shared
   };
  
  
  
  1.12      +16 -16    apr-util/buckets/apr_buckets_refcount.c
  
  Index: apr_buckets_refcount.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_buckets_refcount.c,v
  retrieving revision 1.11
  retrieving revision 1.12
  diff -u -r1.11 -r1.12
  --- apr_buckets_refcount.c	2000/12/21 18:06:15	1.11
  +++ apr_buckets_refcount.c	2001/01/19 07:02:00	1.12
  @@ -56,19 +56,19 @@
   
   #include "apr_errno.h"
   
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   
  -APU_DECLARE_NONSTD(apr_status_t) ap_bucket_split_shared(ap_bucket *a, apr_off_t point)
  +APU_DECLARE_NONSTD(apr_status_t) apr_bucket_split_shared(apr_bucket *a, apr_off_t point)
   {
  -    ap_bucket *b;
  -    ap_bucket_shared *ad, *bd;
  +    apr_bucket *b;
  +    apr_bucket_shared *ad, *bd;
       apr_status_t rv;
   
       if (point < 0 || point > a->length) {
   	return APR_EINVAL;
       }
   
  -    rv = ap_bucket_copy_shared(a, &b);
  +    rv = apr_bucket_copy_shared(a, &b);
       if (rv != APR_SUCCESS) {
           return rv;
       }
  @@ -81,16 +81,16 @@
       b->length -= point;
       bd->start += point;
   
  -    AP_BUCKET_INSERT_AFTER(a, b);
  +    APR_BUCKET_INSERT_AFTER(a, b);
   
       return APR_SUCCESS;
   }
   
  -APU_DECLARE_NONSTD(apr_status_t) ap_bucket_copy_shared(ap_bucket *a, ap_bucket **c)
  +APU_DECLARE_NONSTD(apr_status_t) apr_bucket_copy_shared(apr_bucket *a, apr_bucket **c)
   {
  -    ap_bucket *b;
  -    ap_bucket_shared *ad, *bd;
  -    ap_bucket_refcount *r;
  +    apr_bucket *b;
  +    apr_bucket_shared *ad, *bd;
  +    apr_bucket_refcount *r;
   
       b = malloc(sizeof(*b));
       if (b == NULL) {
  @@ -114,10 +114,10 @@
       return APR_SUCCESS;
   }
   
  -APU_DECLARE(void *) ap_bucket_destroy_shared(void *data)
  +APU_DECLARE(void *) apr_bucket_destroy_shared(void *data)
   {
  -    ap_bucket_shared *s = data;
  -    ap_bucket_refcount *r = s->data;
  +    apr_bucket_shared *s = data;
  +    apr_bucket_refcount *r = s->data;
   
       free(s);
       r->refcount -= 1;
  @@ -129,11 +129,11 @@
       }
   }
   
  -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)
   {
  -    ap_bucket_shared *s;
  -    ap_bucket_refcount *r = data;
  +    apr_bucket_shared *s;
  +    apr_bucket_refcount *r = data;
   
       s = malloc(sizeof(*s));
       if (s == NULL) {
  
  
  
  1.19      +29 -29    apr-util/buckets/apr_buckets_simple.c
  
  Index: apr_buckets_simple.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_buckets_simple.c,v
  retrieving revision 1.18
  retrieving revision 1.19
  diff -u -r1.18 -r1.19
  --- apr_buckets_simple.c	2001/01/05 18:18:30	1.18
  +++ apr_buckets_simple.c	2001/01/19 07:02:00	1.19
  @@ -52,17 +52,17 @@
    * <http://www.apache.org/>.
    */
   
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   #include <stdlib.h>
   
   /*
  - * We can't simplify this function by using an ap_bucket_make function
  + * We can't simplify this function by using an apr_bucket_make function
    * because we aren't sure of the exact type of this bucket.
    */
  -static apr_status_t simple_copy(ap_bucket *a, ap_bucket **c)
  +static apr_status_t simple_copy(apr_bucket *a, apr_bucket **c)
   {
  -    ap_bucket *b;
  -    ap_bucket_simple *ad, *bd;
  +    apr_bucket *b;
  +    apr_bucket_simple *ad, *bd;
   
       b = malloc(sizeof(*b)); 
       if (b == NULL) {
  @@ -83,10 +83,10 @@
       return APR_SUCCESS;
   }
   
  -static apr_status_t simple_split(ap_bucket *a, apr_off_t point)
  +static apr_status_t simple_split(apr_bucket *a, apr_off_t point)
   {
  -    ap_bucket *b;
  -    ap_bucket_simple *ad, *bd;
  +    apr_bucket *b;
  +    apr_bucket_simple *ad, *bd;
       apr_status_t rv;
   
       if (point < 0 || point > a->length) {
  @@ -106,24 +106,24 @@
       b->length -= point;
       bd->start += point;
   
  -    AP_BUCKET_INSERT_AFTER(a, b);
  +    APR_BUCKET_INSERT_AFTER(a, b);
   
       return APR_SUCCESS;
   }
   
  -static apr_status_t simple_read(ap_bucket *b, const char **str, 
  -				apr_size_t *len, ap_read_type block)
  +static apr_status_t simple_read(apr_bucket *b, const char **str, 
  +				apr_size_t *len, apr_read_type_e block)
   {
  -    ap_bucket_simple *bd = b->data;
  +    apr_bucket_simple *bd = b->data;
       *str = bd->start;
       *len = bd->end - bd->start;
       return APR_SUCCESS;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_make_immortal(ap_bucket *b,
  +APU_DECLARE(apr_bucket *) apr_bucket_make_immortal(apr_bucket *b,
   		const char *buf, apr_size_t length)
   {
  -    ap_bucket_simple *bd;
  +    apr_bucket_simple *bd;
   
       bd = malloc(sizeof(*bd));
       if (bd == NULL) {
  @@ -133,17 +133,17 @@
       bd->start   = buf;
       bd->end     = buf+length;
   
  -    b->type     = &ap_immortal_type;
  +    b->type     = &apr_bucket_type_immortal;
       b->length   = length;
       b->data     = bd;
   
       return b;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_create_immortal(
  +APU_DECLARE(apr_bucket *) apr_bucket_create_immortal(
   		const char *buf, apr_size_t length)
   {
  -    ap_bucket_do_create(ap_bucket_make_immortal(b, buf, length));
  +    apr_bucket_do_create(apr_bucket_make_immortal(b, buf, length));
   }
   
   /*
  @@ -151,13 +151,13 @@
    * usage in various cases, e.g. share buffers in the heap between all
    * the buckets that are set aside, or even spool set-aside data to
    * disk if it gets too voluminous (but if it does then that's probably
  - * a bug elsewhere). There should probably be a ap_brigade_setaside()
  + * a bug elsewhere). There should probably be a apr_brigade_setaside()
    * function that co-ordinates the action of all the bucket setaside
    * functions to improve memory efficiency.
    */
  -static apr_status_t transient_setaside(ap_bucket *b)
  +static apr_status_t transient_setaside(apr_bucket *b)
   {
  -    ap_bucket_simple *bd;
  +    apr_bucket_simple *bd;
       const char *start, *end;
       apr_size_t w;
       
  @@ -165,7 +165,7 @@
       start = bd->start;
       end = bd->end;
       /* XXX: handle small heap buckets */
  -    b = ap_bucket_make_heap(b, start, end-start, 1, &w);
  +    b = apr_bucket_make_heap(b, start, end-start, 1, &w);
       if (b == NULL || w != end-start) {
   	return APR_ENOMEM;
       }
  @@ -173,33 +173,33 @@
       return APR_SUCCESS;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_make_transient(ap_bucket *b,
  +APU_DECLARE(apr_bucket *) apr_bucket_make_transient(apr_bucket *b,
   		const char *buf, apr_size_t length)
   {
  -    b = ap_bucket_make_immortal(b, buf, length);
  +    b = apr_bucket_make_immortal(b, buf, length);
       if (b == NULL) {
   	return NULL;
       }
  -    b->type = &ap_transient_type;
  +    b->type = &apr_bucket_type_transient;
       return b;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_create_transient(
  +APU_DECLARE(apr_bucket *) apr_bucket_create_transient(
   		const char *buf, apr_size_t length)
   {
  -    ap_bucket_do_create(ap_bucket_make_transient(b, buf, length));
  +    apr_bucket_do_create(apr_bucket_make_transient(b, buf, length));
   }
   
  -const ap_bucket_type ap_immortal_type = {
  +const apr_bucket_type_t apr_bucket_type_immortal = {
       "IMMORTAL", 5,
       free,
       simple_read,
  -    ap_bucket_setaside_notimpl,
  +    apr_bucket_setaside_notimpl,
       simple_split,
       simple_copy
   };
   
  -APU_DECLARE_DATA const ap_bucket_type ap_transient_type = {
  +APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_transient = {
       "TRANSIENT", 5,
       free, 
       simple_read,
  
  
  
  1.15      +19 -19    apr-util/buckets/apr_buckets_socket.c
  
  Index: apr_buckets_socket.c
  ===================================================================
  RCS file: /home/cvs/apr-util/buckets/apr_buckets_socket.c,v
  retrieving revision 1.14
  retrieving revision 1.15
  diff -u -r1.14 -r1.15
  --- apr_buckets_socket.c	2000/12/22 05:56:37	1.14
  +++ apr_buckets_socket.c	2001/01/19 07:02:00	1.15
  @@ -53,20 +53,20 @@
    */
   
   #include "apr_lib.h"
  -#include "ap_buckets.h"
  +#include "apr_buckets.h"
   #include <stdlib.h>
   
   /* XXX: We should obey the block flag */
  -static apr_status_t socket_read(ap_bucket *a, const char **str,
  -			      apr_size_t *len, ap_read_type block)
  +static apr_status_t socket_read(apr_bucket *a, const char **str,
  +			      apr_size_t *len, apr_read_type_e block)
   {
       apr_socket_t *p = a->data;
  -    ap_bucket *b;
  +    apr_bucket *b;
       char *buf;
       apr_status_t rv;
       apr_int32_t timeout;
   
  -    if (block == AP_NONBLOCK_READ) {
  +    if (block == APR_NONBLOCK_READ) {
           apr_getsocketopt(p, APR_SO_TIMEOUT, &timeout);
           apr_setsocketopt(p, APR_SO_TIMEOUT, 0);
       }
  @@ -76,7 +76,7 @@
       *len = HUGE_STRING_LEN;
       rv = apr_recv(p, buf, len);
   
  -    if (block == AP_NONBLOCK_READ) {
  +    if (block == APR_NONBLOCK_READ) {
           apr_setsocketopt(p, APR_SO_TIMEOUT, timeout);
       }
   
  @@ -89,7 +89,7 @@
        * Change the current bucket to refer to what we read,
        * even if we read nothing because we hit EOF.
        */
  -    ap_bucket_make_heap(a, buf, *len, 0, NULL);  /* XXX: check for failure? */
  +    apr_bucket_make_heap(a, buf, *len, 0, NULL);  /* XXX: check for failure? */
       /*
        * If there's more to read we have to keep the rest of the socket
        * for later. XXX: Note that more complicated bucket types that
  @@ -106,16 +106,16 @@
        * down for reading, but there is no benefit to doing so.
        */
       if (*len > 0) {
  -        b = ap_bucket_create_socket(p);
  -	AP_BUCKET_INSERT_AFTER(a, b);
  +        b = apr_bucket_create_socket(p);
  +	APR_BUCKET_INSERT_AFTER(a, b);
       }
  -    else if (rv == APR_EOF && block == AP_NONBLOCK_READ) {
  +    else if (rv == APR_EOF && block == APR_NONBLOCK_READ) {
           return APR_EOF;
       }
       return APR_SUCCESS;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_make_socket(ap_bucket *b, apr_socket_t *p)
  +APU_DECLARE(apr_bucket *) apr_bucket_make_socket(apr_bucket *b, apr_socket_t *p)
   {
       /*
        * XXX: We rely on a cleanup on some pool or other to actually
  @@ -125,23 +125,23 @@
        * Note that typically the socket is allocated from the connection pool
        * so it will disappear when the connection is finished. 
        */
  -    b->type     = &ap_socket_type;
  +    b->type     = &apr_bucket_type_socket;
       b->length   = -1;
       b->data     = p;
   
       return b;
   }
   
  -APU_DECLARE(ap_bucket *) ap_bucket_create_socket(apr_socket_t *p)
  +APU_DECLARE(apr_bucket *) apr_bucket_create_socket(apr_socket_t *p)
   {
  -    ap_bucket_do_create(ap_bucket_make_socket(b, p));
  +    apr_bucket_do_create(apr_bucket_make_socket(b, p));
   }
   
  -APU_DECLARE_DATA const ap_bucket_type ap_socket_type = {
  +APU_DECLARE_DATA const apr_bucket_type_t apr_bucket_type_socket = {
       "SOCKET", 5,
  -    ap_bucket_destroy_notimpl,
  +    apr_bucket_destroy_notimpl,
       socket_read,
  -    ap_bucket_setaside_notimpl, 
  -    ap_bucket_split_notimpl,
  -    ap_bucket_copy_notimpl
  +    apr_bucket_setaside_notimpl, 
  +    apr_bucket_split_notimpl,
  +    apr_bucket_copy_notimpl
   };
  
  
  
  1.5       +1 -1      apr-util/crypto/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  RCS file: /home/cvs/apr-util/crypto/Makefile.in,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- Makefile.in	2001/01/07 01:35:50	1.4
  +++ Makefile.in	2001/01/19 07:02:01	1.5
  @@ -1,5 +1,5 @@
   
  -TARGETS = ap_sha1.lo
  +TARGETS = apr_sha1.lo
   
   # bring in rules.mk for standard functionality
   @INCLUDE_RULES@
  
  
  
  1.21      +35 -37    apr-util/crypto/apr_sha1.c
  
  Index: apr_sha1.c
  ===================================================================
  RCS file: /home/cvs/apr-util/crypto/apr_sha1.c,v
  retrieving revision 1.20
  retrieving revision 1.21
  diff -u -r1.20 -r1.21
  --- apr_sha1.c	2000/12/21 18:06:17	1.20
  +++ apr_sha1.c	2001/01/19 07:02:02	1.21
  @@ -55,7 +55,7 @@
   /*
    * The exported function:
    *
  - * 	 ap_sha1_base64(const char *clear, int len, char *out);
  + * 	 apr_sha1_base64(const char *clear, int len, char *out);
    *
    * provides a means to SHA1 crypt/encode a plaintext password in
    * a way which makes password files compatible with those commonly
  @@ -82,8 +82,8 @@
    *	This code is hereby placed in the public domain
    */
   
  -#include "ap_sha1.h"
  -#include "ap_base64.h"
  +#include "apr_sha1.h"
  +#include "apr_base64.h"
   #include "apr_strings.h"
   #include "apr_lib.h"
   #if APR_CHARSET_EBCDIC
  @@ -122,7 +122,7 @@
   #if APR_CHARSET_EBCDIC
   static apr_xlate_t *ebcdic2ascii_xlate;
   
  -APU_DECLARE(apr_status_t) ap_SHA1InitEBCDIC(apr_xlate_t *x)
  +APU_DECLARE(apr_status_t) apr_SHA1InitEBCDIC(apr_xlate_t *x)
   {
       apr_status_t rv;
       int onoff;
  @@ -141,10 +141,8 @@
   }
   #endif
   
  -typedef unsigned char AP_BYTE;
  -
   /* do SHA transformation */
  -static void sha_transform(AP_SHA1_CTX *sha_info)
  +static void sha_transform(apr_sha1_ctx_t *sha_info)
   {
       int i;
       apr_uint32_t temp, A, B, C, D, E, W[80];
  @@ -222,11 +220,11 @@
   static void maybe_byte_reverse(apr_uint32_t *buffer, int count)
   {
       int i;
  -    AP_BYTE ct[4], *cp;
  +    apr_byte_t ct[4], *cp;
   
       if (isLittleEndian()) {	/* do the swap only if it is little endian */
   	count /= sizeof(apr_uint32_t);
  -	cp = (AP_BYTE *) buffer;
  +	cp = (apr_byte_t *) buffer;
   	for (i = 0; i < count; ++i) {
   	    ct[0] = cp[0];
   	    ct[1] = cp[1];
  @@ -243,7 +241,7 @@
   
   /* initialize the SHA digest */
   
  -APU_DECLARE(void) ap_SHA1Init(AP_SHA1_CTX *sha_info)
  +APU_DECLARE(void) apr_SHA1Init(apr_sha1_ctx_t *sha_info)
   {
       sha_info->digest[0] = 0x67452301L;
       sha_info->digest[1] = 0xefcdab89L;
  @@ -257,7 +255,7 @@
   
   /* update the SHA digest */
   
  -APU_DECLARE(void) ap_SHA1Update_binary(AP_SHA1_CTX *sha_info,
  +APU_DECLARE(void) apr_SHA1Update_binary(apr_sha1_ctx_t *sha_info,
                                        const unsigned char *buffer,
                                        unsigned int count)
   {
  @@ -273,7 +271,7 @@
   	if (i > count) {
   	    i = count;
   	}
  -	memcpy(((AP_BYTE *) sha_info->data) + sha_info->local, buffer, i);
  +	memcpy(((apr_byte_t *) sha_info->data) + sha_info->local, buffer, i);
   	count -= i;
   	buffer += i;
   	sha_info->local += i;
  @@ -296,12 +294,12 @@
       sha_info->local = count;
   }
   
  -APU_DECLARE(void) ap_SHA1Update(AP_SHA1_CTX *sha_info, const char *buf,
  +APU_DECLARE(void) apr_SHA1Update(apr_sha1_ctx_t *sha_info, const char *buf,
                                 unsigned int count)
   {
   #if APR_CHARSET_EBCDIC
       int i;
  -    const AP_BYTE *buffer = (const AP_BYTE *) buf;
  +    const apr_byte_t *buffer = (const apr_byte_t *) buf;
       apr_size_t inbytes_left, outbytes_left;
   
       if ((sha_info->count_lo + ((apr_uint32_t) count << 3)) < sha_info->count_lo) {
  @@ -317,7 +315,7 @@
   	}
           inbytes_left = outbytes_left = i;
           apr_xlate_conv_buffer(ebcdic2ascii_xlate, buffer, &inbytes_left,
  -                              ((AP_BYTE *) sha_info->data) + sha_info->local,
  +                              ((apr_byte_t *) sha_info->data) + sha_info->local,
                                 &outbytes_left);
   	count -= i;
   	buffer += i;
  @@ -333,7 +331,7 @@
       while (count >= SHA_BLOCKSIZE) {
           inbytes_left = outbytes_left = SHA_BLOCKSIZE;
           apr_xlate_conv_buffer(ebcdic2ascii_xlate, buffer, &inbytes_left,
  -                              (AP_BYTE *) sha_info->data, &outbytes_left);
  +                              (apr_byte_t *) sha_info->data, &outbytes_left);
   	buffer += SHA_BLOCKSIZE;
   	count -= SHA_BLOCKSIZE;
   	maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
  @@ -341,17 +339,17 @@
       }
       inbytes_left = outbytes_left = count;
       apr_xlate_conv_buffer(ebcdic2ascii_xlate, buffer, &inbytes_left,
  -                          (AP_BYTE *) sha_info->data, &outbytes_left);
  +                          (apr_byte_t *) sha_info->data, &outbytes_left);
       sha_info->local = count;
   #else
  -    ap_SHA1Update_binary(sha_info, (const unsigned char *) buf, count);
  +    apr_SHA1Update_binary(sha_info, (const unsigned char *) buf, count);
   #endif
   }
   
   /* finish computing the SHA digest */
   
  -APU_DECLARE(void) ap_SHA1Final(unsigned char digest[SHA_DIGESTSIZE],
  -                             AP_SHA1_CTX *sha_info)
  +APU_DECLARE(void) apr_SHA1Final(unsigned char digest[APR_SHA1_DIGESTSIZE],
  +                             apr_sha1_ctx_t *sha_info)
   {
       int count, i, j;
       apr_uint32_t lo_bit_count, hi_bit_count, k;
  @@ -359,15 +357,15 @@
       lo_bit_count = sha_info->count_lo;
       hi_bit_count = sha_info->count_hi;
       count = (int) ((lo_bit_count >> 3) & 0x3f);
  -    ((AP_BYTE *) sha_info->data)[count++] = 0x80;
  +    ((apr_byte_t *) sha_info->data)[count++] = 0x80;
       if (count > SHA_BLOCKSIZE - 8) {
  -	memset(((AP_BYTE *) sha_info->data) + count, 0, SHA_BLOCKSIZE - count);
  +	memset(((apr_byte_t *) sha_info->data) + count, 0, SHA_BLOCKSIZE - count);
   	maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
   	sha_transform(sha_info);
  -	memset((AP_BYTE *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
  +	memset((apr_byte_t *) sha_info->data, 0, SHA_BLOCKSIZE - 8);
       }
       else {
  -	memset(((AP_BYTE *) sha_info->data) + count, 0,
  +	memset(((apr_byte_t *) sha_info->data) + count, 0,
   	       SHA_BLOCKSIZE - 8 - count);
       }
       maybe_byte_reverse(sha_info->data, SHA_BLOCKSIZE);
  @@ -375,7 +373,7 @@
       sha_info->data[15] = lo_bit_count;
       sha_transform(sha_info);
   
  -    for (i = 0, j = 0; j < SHA_DIGESTSIZE; i++) {
  +    for (i = 0, j = 0; j < APR_SHA1_DIGESTSIZE; i++) {
   	k = sha_info->digest[i];
   	digest[j++] = (unsigned char) ((k >> 24) & 0xff);
   	digest[j++] = (unsigned char) ((k >> 16) & 0xff);
  @@ -385,28 +383,28 @@
   }
   
   
  -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)
   {
       int l;
  -    AP_SHA1_CTX context;
  -    AP_BYTE digest[SHA_DIGESTSIZE];
  +    apr_sha1_ctx_t context;
  +    apr_byte_t digest[APR_SHA1_DIGESTSIZE];
   
  -    if (strncmp(clear, AP_SHA1PW_ID, AP_SHA1PW_IDLEN) == 0) {
  -	clear += AP_SHA1PW_IDLEN;
  +    if (strncmp(clear, APR_SHA1PW_ID, APR_SHA1PW_IDLEN) == 0) {
  +	clear += APR_SHA1PW_IDLEN;
       }
   
  -    ap_SHA1Init(&context);
  -    ap_SHA1Update(&context, clear, len);
  -    ap_SHA1Final(digest, &context);
  +    apr_SHA1Init(&context);
  +    apr_SHA1Update(&context, clear, len);
  +    apr_SHA1Final(digest, &context);
   
       /* private marker. */
  -    apr_cpystrn(out, AP_SHA1PW_ID, AP_SHA1PW_IDLEN + 1);
  +    apr_cpystrn(out, APR_SHA1PW_ID, APR_SHA1PW_IDLEN + 1);
   
       /* SHA1 hash is always 20 chars */
  -    l = ap_base64encode_binary(out + AP_SHA1PW_IDLEN, digest, sizeof(digest));
  -    out[l + AP_SHA1PW_IDLEN] = '\0';
  +    l = apr_base64encode_binary(out + APR_SHA1PW_IDLEN, digest, sizeof(digest));
  +    out[l + APR_SHA1PW_IDLEN] = '\0';
   
       /*
  -     * output of base64 encoded SHA1 is always 28 chars + AP_SHA1PW_IDLEN
  +     * output of base64 encoded SHA1 is always 28 chars + APR_SHA1PW_IDLEN
        */
   }
  
  
  
  1.6       +1 -1      apr-util/encoding/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  RCS file: /home/cvs/apr-util/encoding/Makefile.in,v
  retrieving revision 1.5
  retrieving revision 1.6
  diff -u -r1.5 -r1.6
  --- Makefile.in	2001/01/07 01:35:50	1.5
  +++ Makefile.in	2001/01/19 07:02:02	1.6
  @@ -1,5 +1,5 @@
   
  -TARGETS = ap_base64.lo
  +TARGETS = apr_base64.lo
   
   # bring in rules.mk for standard functionality
   @INCLUDE_RULES@
  
  
  
  1.19      +14 -14    apr-util/encoding/apr_base64.c
  
  Index: apr_base64.c
  ===================================================================
  RCS file: /home/cvs/apr-util/encoding/apr_base64.c,v
  retrieving revision 1.18
  retrieving revision 1.19
  diff -u -r1.18 -r1.19
  --- apr_base64.c	2000/12/21 18:06:18	1.18
  +++ apr_base64.c	2001/01/19 07:02:02	1.19
  @@ -57,12 +57,12 @@
    */
   
   /* base64 encoder/decoder. Originally part of main/util.c
  - * but moved here so that support/ab and ap_sha1.c could
  + * but moved here so that support/ab and apr_sha1.c could
    * use it. This meant removing the apr_palloc()s and adding
    * ugly 'len' functions, which is quite a nasty cost.
    */
   
  -#include "ap_base64.h"
  +#include "apr_base64.h"
   #if APR_CHARSET_EBCDIC
   #include "apr_xlate.h"
   #endif				/* APR_CHARSET_EBCDIC */
  @@ -113,7 +113,7 @@
   static apr_xlate_t *xlate_to_ebcdic;
   static unsigned char os_toascii[256];
   
  -APU_DECLARE(apr_status_t) ap_base64init_ebcdic(apr_xlate_t *to_ascii,
  +APU_DECLARE(apr_status_t) apr_base64init_ebcdic(apr_xlate_t *to_ascii,
                                                apr_xlate_t *to_ebcdic)
   {
       int i;
  @@ -149,7 +149,7 @@
   }
   #endif /*APR_CHARSET_EBCDIC*/
   
  -APU_DECLARE(int) ap_base64decode_len(const char *bufcoded)
  +APU_DECLARE(int) apr_base64decode_len(const char *bufcoded)
   {
       int nbytesdecoded;
       register const unsigned char *bufin;
  @@ -164,14 +164,14 @@
       return nbytesdecoded + 1;
   }
   
  -APU_DECLARE(int) ap_base64decode(char *bufplain, const char *bufcoded)
  +APU_DECLARE(int) apr_base64decode(char *bufplain, const char *bufcoded)
   {
   #if APR_CHARSET_EBCDIC
       apr_size_t inbytes_left, outbytes_left;
   #endif				/* APR_CHARSET_EBCDIC */
       int len;
       
  -    len = ap_base64decode_binary((unsigned char *) bufplain, bufcoded);
  +    len = apr_base64decode_binary((unsigned char *) bufplain, bufcoded);
   #if APR_CHARSET_EBCDIC
       inbytes_left = outbytes_left = len;
       apr_xlate_conv_buffer(xlate_to_ebcdic, bufplain, &inbytes_left,
  @@ -181,10 +181,10 @@
       return len;
   }
   
  -/* This is the same as ap_base64decode() except on EBCDIC machines, where
  +/* This is the same as apr_base64decode() except on EBCDIC machines, where
    * the conversion of the output to ebcdic is left out.
    */
  -APU_DECLARE(int) ap_base64decode_binary(unsigned char *bufplain,
  +APU_DECLARE(int) apr_base64decode_binary(unsigned char *bufplain,
   				   const char *bufcoded)
   {
       int nbytesdecoded;
  @@ -232,16 +232,16 @@
   static const char basis_64[] =
       "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
   
  -APU_DECLARE(int) ap_base64encode_len(int len)
  +APU_DECLARE(int) apr_base64encode_len(int len)
   {
       return ((len + 2) / 3 * 4) + 1;
   }
   
  -APU_DECLARE(int) ap_base64encode(char *encoded, const char *string, int len)
  +APU_DECLARE(int) apr_base64encode(char *encoded, const char *string, int len)
   {
   #if !APR_CHARSET_EBCDIC
  -    return ap_base64encode_binary(encoded, (const unsigned char *) string, len);
  -#else				/* AP_CHARSET_EBCDIC */
  +    return apr_base64encode_binary(encoded, (const unsigned char *) string, len);
  +#else /* APR_CHARSET_EBCDIC */
       int i;
       char *p;
   
  @@ -273,10 +273,10 @@
   #endif				/* APR_CHARSET_EBCDIC */
   }
   
  -/* This is the same as ap_base64encode() except on EBCDIC machines, where
  +/* This is the same as apr_base64encode() except on EBCDIC machines, where
    * the conversion of the input to ascii is left out.
    */
  -APU_DECLARE(int) ap_base64encode_binary(char *encoded,
  +APU_DECLARE(int) apr_base64encode_binary(char *encoded,
                                         const unsigned char *string, int len)
   {
       int i;
  
  
  
  1.5       +1 -1      apr-util/hooks/Makefile.in
  
  Index: Makefile.in
  ===================================================================
  RCS file: /home/cvs/apr-util/hooks/Makefile.in,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- Makefile.in	2001/01/07 01:35:51	1.4
  +++ Makefile.in	2001/01/19 07:02:02	1.5
  @@ -1,5 +1,5 @@
   
  -TARGETS = ap_hooks.lo
  +TARGETS = apr_hooks.lo
   
   # bring in rules.mk for standard functionality
   @INCLUDE_RULES@
  
  
  
  1.29      +27 -27    apr-util/hooks/apr_hooks.c
  
  Index: apr_hooks.c
  ===================================================================
  RCS file: /home/cvs/apr-util/hooks/apr_hooks.c,v
  retrieving revision 1.28
  retrieving revision 1.29
  diff -u -r1.28 -r1.29
  --- apr_hooks.c	2001/01/06 20:43:50	1.28
  +++ apr_hooks.c	2001/01/19 07:02:02	1.29
  @@ -59,9 +59,9 @@
   #include "apr_pools.h"
   #include "apr_tables.h"
   #include "apr.h"
  -#include "ap_hooks.h"
  +#include "apr_hooks.h"
   #include "apr_hash.h"
  -#include "ap_generic_hook.h"
  +#include "apr_generic_hook.h"
   
   #if APR_HAVE_STRINGS_H
   #include <strings.h>
  @@ -71,9 +71,9 @@
   #define apr_palloc(pool,size)	malloc(size)
   #endif
   
  -APU_DECLARE_DATA apr_pool_t *ap_global_hook_pool = NULL;
  -APU_DECLARE_DATA int ap_debug_module_hooks = 0;
  -APU_DECLARE_DATA const char *ap_current_hooking_module = NULL;
  +APU_DECLARE_DATA apr_pool_t *apr_global_hook_pool = NULL;
  +APU_DECLARE_DATA int apr_debug_module_hooks = 0;
  +APU_DECLARE_DATA const char *apr_debug_module_name = NULL;
   
   /* NB: This must echo the LINK_##name structure */
   typedef struct
  @@ -188,21 +188,21 @@
       apr_array_header_t *pNew;
       int n;
   
  -    apr_create_pool(&p, ap_global_hook_pool);
  +    apr_create_pool(&p, apr_global_hook_pool);
       pSort=prepare(p,(TSortData *)pHooks->elts,pHooks->nelts);
       pSort=tsort(pSort,pHooks->nelts);
  -    pNew=apr_make_array(ap_global_hook_pool,pHooks->nelts,sizeof(TSortData));
  -    if(ap_debug_module_hooks)
  +    pNew=apr_make_array(apr_global_hook_pool,pHooks->nelts,sizeof(TSortData));
  +    if(apr_debug_module_hooks)
   	printf("Sorting %s:",szName);
       for(n=0 ; pSort ; pSort=pSort->pNext,++n) {
   	TSortData *pHook;
   	assert(n < pHooks->nelts);
   	pHook=apr_push_array(pNew);
   	memcpy(pHook,pSort->pData,sizeof *pHook);
  -	if(ap_debug_module_hooks)
  +	if(apr_debug_module_hooks)
   	    printf(" %s",pHook->szName);
       }
  -    if(ap_debug_module_hooks)
  +    if(apr_debug_module_hooks)
   	fputc('\n',stdout);
       return pNew;
   }
  @@ -214,19 +214,19 @@
       apr_array_header_t **paHooks;
   } HookSortEntry;
   
  -APU_DECLARE(void) ap_hook_sort_register(const char *szHookName,
  +APU_DECLARE(void) apr_hook_sort_register(const char *szHookName,
   					apr_array_header_t **paHooks)
   {
       HookSortEntry *pEntry;
   
       if(!s_aHooksToSort)
  -	s_aHooksToSort=apr_make_array(ap_global_hook_pool,1,sizeof(HookSortEntry));
  +	s_aHooksToSort=apr_make_array(apr_global_hook_pool,1,sizeof(HookSortEntry));
       pEntry=apr_push_array(s_aHooksToSort);
       pEntry->szHookName=szHookName;
       pEntry->paHooks=paHooks;
   }
   
  -APU_DECLARE(void) ap_sort_hooks()
  +APU_DECLARE(void) apr_sort_hooks()
   {
       int n;
   
  @@ -238,7 +238,7 @@
       
   static apr_hash_t *s_phGenericHooks;
   
  -APU_DECLARE(void) ap_hook_deregister_all(void)
  +APU_DECLARE(void) apr_hook_deregister_all(void)
   {
       int n;    
   
  @@ -250,7 +250,7 @@
       s_phGenericHooks=NULL;
   }
   
  -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)
   {
       int nFirst;
  @@ -285,9 +285,9 @@
   
   /* Generic hook support */
   
  -AP_DECLARE_EXTERNAL_HOOK(APU,void,_generic,(void))
  +APR_DECLARE_EXTERNAL_HOOK(apr,APU,void,_generic,(void))
   
  -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)
   {
       apr_array_header_t **ppArray;
   
  @@ -299,32 +299,32 @@
       return *ppArray;
   }
   
  -APU_DECLARE(void) ap_hook_generic(const char *szName,void (*pfn)(void),
  +APU_DECLARE(void) apr_hook_generic(const char *szName,void (*pfn)(void),
   				  const char * const *aszPre,
   				  const char * const *aszSucc,int nOrder)
   {
  -    apr_array_header_t *pArray=ap_generic_hook_get(szName);
  -    LINK__generic *pHook;
  +    apr_array_header_t *pArray=apr_generic_hook_get(szName);
  +    apr_LINK__generic_t *pHook;
   
       if(!pArray) {
   	apr_array_header_t **ppArray;
   
  -	pArray=apr_make_array(ap_global_hook_pool,1,sizeof(LINK__generic));
  +	pArray=apr_make_array(apr_global_hook_pool,1,sizeof(apr_LINK__generic_t));
   	if(!s_phGenericHooks)
  -	    s_phGenericHooks=apr_make_hash(ap_global_hook_pool);
  -	ppArray=apr_palloc(ap_global_hook_pool,sizeof *ppArray);
  +	    s_phGenericHooks=apr_make_hash(apr_global_hook_pool);
  +	ppArray=apr_palloc(apr_global_hook_pool,sizeof *ppArray);
   	*ppArray=pArray;
   	apr_hash_set(s_phGenericHooks,szName,strlen(szName),ppArray);
  -	ap_hook_sort_register(szName,ppArray);
  +	apr_hook_sort_register(szName,ppArray);
       }
       pHook=apr_push_array(pArray);
       pHook->pFunc=pfn;
       pHook->aszPredecessors=aszPre;
       pHook->aszSuccessors=aszSucc;
       pHook->nOrder=nOrder;
  -    pHook->szName=ap_current_hooking_module;
  -    if(ap_debug_module_hooks)
  -	ap_show_hook(szName,aszPre,aszSucc);
  +    pHook->szName=apr_debug_module_name;
  +    if(apr_debug_module_hooks)
  +	apr_show_hook(szName,aszPre,aszSucc);
   }
   
   #if 0
  
  
  

Mime
View raw message