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;
