apr-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From r..@apache.org
Subject cvs commit: apr/time/unix time.c
Date Fri, 10 Aug 2001 21:04:49 GMT
rbb         01/08/10 14:04:49

  Modified:    .        CHANGES
               file_io/os2 dir.c filedup.c filestat.c flock.c open.c pipe.c
                        readwrite.c seek.c
               file_io/unix filestat.c flock.c open.c pipe.c readwrite.c
                        seek.c
               locks/beos locks.c
               locks/os2 locks.c
               locks/unix locks.c
               misc/unix getuuid.c rand.c
               network_io/beos poll.c sendrecv.c
               network_io/os2 poll.c sendrecv.c sendrecv_udp.c sockets.c
                        sockopt.c
               shmem/beos shmem.c
               shmem/os2 shmem.c
               shmem/unix shmem.c
               threadproc/beos proc.c thread.c threadpriv.c
               threadproc/os2 proc.c thread.c threadpriv.c
               threadproc/unix proc.c procsup.c signals.c thread.c
                        threadpriv.c
               time/unix time.c
  Log:
  Wrap all APR functions in APR_DECLARE macro.
  Submitted by:	Sterling Hughes <sterling@designmultimedia.com>
  
  Revision  Changes    Path
  1.134     +3 -0      apr/CHANGES
  
  Index: CHANGES
  ===================================================================
  RCS file: /home/cvs/apr/CHANGES,v
  retrieving revision 1.133
  retrieving revision 1.134
  diff -u -r1.133 -r1.134
  --- CHANGES	2001/08/07 20:24:50	1.133
  +++ CHANGES	2001/08/10 21:04:46	1.134
  @@ -1,5 +1,8 @@
   Changes with APR b1  
   
  +  *) Wrap all functions in APR_DECLARE macro. 
  +     [Sterling Hughes <sterling@designmultimedia.com>]
  +
     *) Non-blocking connects shouldn't be calling connect a second
        time.  According to Single Unix, a non-blocking connect has
        succeeded when the select pops successfully.  It has failed
  
  
  
  1.28      +10 -10    apr/file_io/os2/dir.c
  
  Index: dir.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/os2/dir.c,v
  retrieving revision 1.27
  retrieving revision 1.28
  diff -u -r1.27 -r1.28
  --- dir.c	2001/03/19 12:35:12	1.27
  +++ dir.c	2001/08/10 21:04:47	1.28
  @@ -67,7 +67,7 @@
   
   
   
  -apr_status_t apr_dir_open(apr_dir_t **new, const char *dirname, apr_pool_t *cntxt)
  +APR_DECLARE(apr_status_t) apr_dir_open(apr_dir_t **new, const char *dirname, apr_pool_t *cntxt)
   {
       apr_dir_t *thedir = (apr_dir_t *)apr_palloc(cntxt, sizeof(apr_dir_t));
       
  @@ -89,7 +89,7 @@
   
   
   
  -apr_status_t apr_dir_close(apr_dir_t *thedir)
  +APR_DECLARE(apr_status_t) apr_dir_close(apr_dir_t *thedir)
   {
       int rv = 0;
       
  @@ -106,8 +106,8 @@
   
   
   
  -apr_status_t apr_dir_read(apr_finfo_t *finfo, apr_int32_t wanted,
  -                          apr_dir_t *thedir)
  +APR_DECLARE(apr_status_t) apr_dir_read(apr_finfo_t *finfo, apr_int32_t wanted,
  +                                       apr_dir_t *thedir)
   {
       int rv;
       ULONG entries = 1;
  @@ -161,28 +161,28 @@
   
   
   
  -apr_status_t apr_dir_rewind(apr_dir_t *thedir)
  +APR_DECLARE(apr_status_t) apr_dir_rewind(apr_dir_t *thedir)
   {
       return apr_dir_close(thedir);
   }
   
   
   
  -apr_status_t apr_dir_make(const char *path, apr_fileperms_t perm, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_dir_make(const char *path, apr_fileperms_t perm, apr_pool_t *cont)
   {
       return APR_OS2_STATUS(DosCreateDir(path, NULL));
   }
   
   
   
  -apr_status_t apr_dir_remove(const char *path, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_dir_remove(const char *path, apr_pool_t *cont)
   {
       return APR_OS2_STATUS(DosDeleteDir(path));
   }
   
   
   
  -apr_status_t apr_os_dir_get(apr_os_dir_t **thedir, apr_dir_t *dir)
  +APR_DECLARE(apr_status_t) apr_os_dir_get(apr_os_dir_t **thedir, apr_dir_t *dir)
   {
       if (dir == NULL) {
           return APR_ENODIR;
  @@ -193,8 +193,8 @@
   
   
   
  -apr_status_t apr_os_dir_put(apr_dir_t **dir, apr_os_dir_t *thedir,
  -                          apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_dir_put(apr_dir_t **dir, apr_os_dir_t *thedir,
  +                                         apr_pool_t *cont)
   {
       if ((*dir) == NULL) {
           (*dir) = (apr_dir_t *)apr_pcalloc(cont, sizeof(apr_dir_t));
  
  
  
  1.23      +1 -1      apr/file_io/os2/filedup.c
  
  Index: filedup.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/os2/filedup.c,v
  retrieving revision 1.22
  retrieving revision 1.23
  diff -u -r1.22 -r1.23
  --- filedup.c	2001/07/18 19:32:29	1.22
  +++ filedup.c	2001/08/10 21:04:47	1.23
  @@ -59,7 +59,7 @@
   #include <string.h>
   #include "inherit.h"
   
  -apr_status_t apr_file_dup(apr_file_t **new_file, apr_file_t *old_file, apr_pool_t *p)
  +APR_DECLARE(apr_status_t) apr_file_dup(apr_file_t **new_file, apr_file_t *old_file, apr_pool_t *p)
   {
       int rv;
       apr_file_t *dup_file;
  
  
  
  1.22      +7 -7      apr/file_io/os2/filestat.c
  
  Index: filestat.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/os2/filestat.c,v
  retrieving revision 1.21
  retrieving revision 1.22
  diff -u -r1.21 -r1.22
  --- filestat.c	2001/02/16 04:15:35	1.21
  +++ filestat.c	2001/08/10 21:04:47	1.22
  @@ -115,8 +115,8 @@
   
   
   
  -apr_status_t apr_file_info_get(apr_finfo_t *finfo, apr_int32_t wanted, 
  -                             apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_info_get(apr_finfo_t *finfo, apr_int32_t wanted, 
  +                                   apr_file_t *thefile)
   {
       ULONG rc;
       FILESTATUS3 fstatus;
  @@ -145,14 +145,14 @@
       return APR_OS2_STATUS(rc);
   }
   
  -apr_status_t apr_file_perms_set(const char *fname, apr_fileperms_t perms)
  +APR_DECLARE(apr_status_t) apr_file_perms_set(const char *fname, apr_fileperms_t perms)
   {
       return APR_ENOTIMPL;
   }
   
   
  -apr_status_t apr_stat(apr_finfo_t *finfo, const char *fname,
  -                      apr_int32_t wanted, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_stat(apr_finfo_t *finfo, const char *fname,
  +                              apr_int32_t wanted, apr_pool_t *cont)
   {
       ULONG rc;
       FILESTATUS3 fstatus;
  @@ -177,8 +177,8 @@
   
   
   
  -apr_status_t apr_lstat(apr_finfo_t *finfo, const char *fname,
  -                       apr_int32_t wanted, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_lstat(apr_finfo_t *finfo, const char *fname,
  +                                    apr_int32_t wanted, apr_pool_t *cont)
   {
       return apr_stat(finfo, fname, wanted, cont);
   }
  
  
  
  1.4       +2 -2      apr/file_io/os2/flock.c
  
  Index: flock.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/os2/flock.c,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- flock.c	2001/02/16 04:15:35	1.3
  +++ flock.c	2001/08/10 21:04:47	1.4
  @@ -54,7 +54,7 @@
   
   #include "fileio.h"
   
  -apr_status_t apr_file_lock(apr_file_t *thefile, int type)
  +APR_DECLARE(apr_status_t) apr_file_lock(apr_file_t *thefile, int type)
   {
       FILELOCK lockrange = { 0, 0x7fffffff };
       ULONG rc;
  @@ -65,7 +65,7 @@
       return APR_FROM_OS_ERROR(rc);
   }
   
  -apr_status_t apr_file_unlock(apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_unlock(apr_file_t *thefile)
   {
       FILELOCK unlockrange = { 0, 0x7fffffff };
       ULONG rc;
  
  
  
  1.45      +11 -13    apr/file_io/os2/open.c
  
  Index: open.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/os2/open.c,v
  retrieving revision 1.44
  retrieving revision 1.45
  diff -u -r1.44 -r1.45
  --- open.c	2001/07/24 12:36:56	1.44
  +++ open.c	2001/08/10 21:04:47	1.45
  @@ -68,7 +68,7 @@
   
   
   
  -apr_status_t apr_file_open(apr_file_t **new, const char *fname, apr_int32_t flag,  apr_fileperms_t perm, apr_pool_t *cntxt)
  +APR_DECLARE(apr_status_t) apr_file_open(apr_file_t **new, const char *fname, apr_int32_t flag,  apr_fileperms_t perm, apr_pool_t *cntxt)
   {
       int oflags = 0;
       int mflags = OPEN_FLAGS_FAIL_ON_ERROR|OPEN_SHARE_DENYNONE;
  @@ -150,7 +150,7 @@
   
   
   
  -apr_status_t apr_file_close(apr_file_t *file)
  +APR_DECLARE(apr_status_t) apr_file_close(apr_file_t *file)
   {
       ULONG rc;
       apr_status_t status;
  @@ -179,7 +179,7 @@
   
   
   
  -apr_status_t apr_file_remove(const char *path, apr_pool_t *cntxt)
  +APR_DECLARE(apr_status_t) apr_file_remove(const char *path, apr_pool_t *cntxt)
   {
       ULONG rc = DosDelete(path);
       return APR_OS2_STATUS(rc);
  @@ -187,8 +187,8 @@
   
   
   
  -apr_status_t apr_file_rename(const char *from_path, const char *to_path,
  -                           apr_pool_t *p)
  +APR_DECLARE(apr_status_t) apr_file_rename(const char *from_path, const char *to_path,
  +                                   apr_pool_t *p)
   {
       ULONG rc = DosMove(from_path, to_path);
   
  @@ -205,7 +205,7 @@
   
   
   
  -apr_status_t apr_os_file_get(apr_os_file_t *thefile, apr_file_t *file)
  +APR_DECLARE(apr_status_t) apr_os_file_get(apr_os_file_t *thefile, apr_file_t *file)
   {
       *thefile = file->filedes;
       return APR_SUCCESS;
  @@ -213,7 +213,7 @@
   
   
   
  -apr_status_t apr_os_file_put(apr_file_t **file, apr_os_file_t *thefile, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_file_put(apr_file_t **file, apr_os_file_t *thefile, apr_pool_t *cont)
   {
       apr_os_file_t *dafile = thefile;
   
  @@ -229,8 +229,7 @@
   }    
   
   
  -
  -apr_status_t apr_file_eof(apr_file_t *fptr)
  +APR_DECLARE(apr_status_t) apr_file_eof(apr_file_t *fptr)
   {
       if (!fptr->isopen || fptr->eof_hit == 1) {
           return APR_EOF;
  @@ -238,9 +237,8 @@
       return APR_SUCCESS;
   }   
   
  -
   
  -apr_status_t apr_file_open_stderr(apr_file_t **thefile, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_open_stderr(apr_file_t **thefile, apr_pool_t *cont)
   {
       apr_os_file_t fd = 2;
   
  @@ -249,7 +247,7 @@
   
   
   
  -apr_status_t apr_file_open_stdout(apr_file_t **thefile, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_open_stdout(apr_file_t **thefile, apr_pool_t *cont)
   {
       apr_os_file_t fd = 1;
   
  @@ -257,7 +255,7 @@
   }
   
   
  -apr_status_t apr_file_open_stdin(apr_file_t **thefile, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_open_stdin(apr_file_t **thefile, apr_pool_t *cont)
   {
       apr_os_file_t fd = 0;
   
  
  
  
  1.33      +4 -4      apr/file_io/os2/pipe.c
  
  Index: pipe.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/os2/pipe.c,v
  retrieving revision 1.32
  retrieving revision 1.33
  diff -u -r1.32 -r1.33
  --- pipe.c	2001/02/16 04:15:35	1.32
  +++ pipe.c	2001/08/10 21:04:47	1.33
  @@ -61,7 +61,7 @@
   #include <string.h>
   #include <process.h>
   
  -apr_status_t apr_file_pipe_create(apr_file_t **in, apr_file_t **out, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in, apr_file_t **out, apr_pool_t *cont)
   {
       ULONG filedes[2];
       ULONG rc, action;
  @@ -141,7 +141,7 @@
   
   
   
  -apr_status_t apr_file_namedpipe_create(const char *filename, apr_fileperms_t perm, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_namedpipe_create(const char *filename, apr_fileperms_t perm, apr_pool_t *cont)
   {
       /* Not yet implemented, interface not suitable */
       return APR_ENOTIMPL;
  @@ -149,7 +149,7 @@
   
    
   
  -apr_status_t apr_file_pipe_timeout_set(apr_file_t *thepipe, apr_interval_time_t timeout)
  +APR_DECLARE(apr_status_t) apr_file_pipe_timeout_set(apr_file_t *thepipe, apr_interval_time_t timeout)
   {
       if (thepipe->pipe == 1) {
           thepipe->timeout = timeout;
  @@ -172,7 +172,7 @@
   
   
   
  -apr_status_t apr_file_pipe_timeout_get(apr_file_t *thepipe, apr_interval_time_t *timeout)
  +APR_DECLARE(apr_status_t) apr_file_pipe_timeout_get(apr_file_t *thepipe, apr_interval_time_t *timeout)
   {
       if (thepipe->pipe == 1) {
           *timeout = thepipe->timeout;
  
  
  
  1.43      +9 -12     apr/file_io/os2/readwrite.c
  
  Index: readwrite.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/os2/readwrite.c,v
  retrieving revision 1.42
  retrieving revision 1.43
  diff -u -r1.42 -r1.43
  --- readwrite.c	2001/04/23 15:18:30	1.42
  +++ readwrite.c	2001/08/10 21:04:47	1.43
  @@ -62,7 +62,7 @@
   
   #include <malloc.h>
   
  -apr_status_t apr_file_read(apr_file_t *thefile, void *buf, apr_size_t *nbytes)
  +APR_DECLARE(apr_status_t) apr_file_read(apr_file_t *thefile, void *buf, apr_size_t *nbytes)
   {
       ULONG rc = 0;
       ULONG bytesread;
  @@ -144,7 +144,7 @@
   
   
   
  -apr_status_t apr_file_write(apr_file_t *thefile, const void *buf, apr_size_t *nbytes)
  +APR_DECLARE(apr_status_t) apr_file_write(apr_file_t *thefile, const void *buf, apr_size_t *nbytes)
   {
       ULONG rc = 0;
       ULONG byteswritten;
  @@ -200,7 +200,7 @@
   
   #ifdef HAVE_WRITEV
   
  -apr_status_t apr_file_writev(apr_file_t *thefile, const struct iovec *vec, apr_size_t nvec, apr_size_t *nbytes)
  +APR_DECLARE(apr_status_t) apr_file_writev(apr_file_t *thefile, const struct iovec *vec, apr_size_t nvec, apr_size_t *nbytes)
   {
       int bytes;
       if ((bytes = writev(thefile->filedes, vec, nvec)) < 0) {
  @@ -216,7 +216,7 @@
   
   
   
  -apr_status_t apr_file_putc(char ch, apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_putc(char ch, apr_file_t *thefile)
   {
       ULONG rc;
       ULONG byteswritten;
  @@ -236,15 +236,14 @@
   
   
   
  -apr_status_t apr_file_ungetc(char ch, apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_ungetc(char ch, apr_file_t *thefile)
   {
       apr_off_t offset = -1;
       return apr_file_seek(thefile, APR_CUR, &offset);
   }
   
   
  -
  -apr_status_t apr_file_getc(char *ch, apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_getc(char *ch, apr_file_t *thefile)
   {
       ULONG rc;
       apr_size_t bytesread;
  @@ -270,7 +269,7 @@
   
   
   
  -apr_status_t apr_file_puts(const char *str, apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_puts(const char *str, apr_file_t *thefile)
   {
       apr_size_t len;
   
  @@ -278,9 +277,8 @@
       return apr_file_write(thefile, str, &len); 
   }
   
  -
   
  -apr_status_t apr_file_flush(apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_flush(apr_file_t *thefile)
   {
       if (thefile->buffered) {
           ULONG written = 0;
  @@ -303,9 +301,8 @@
       }
   }
   
  -
   
  -apr_status_t apr_file_gets(char *str, int len, apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_gets(char *str, int len, apr_file_t *thefile)
   {
       size_t readlen;
       apr_status_t rv = APR_SUCCESS;
  
  
  
  1.17      +2 -2      apr/file_io/os2/seek.c
  
  Index: seek.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/os2/seek.c,v
  retrieving revision 1.16
  retrieving revision 1.17
  diff -u -r1.16 -r1.17
  --- seek.c	2001/06/16 01:27:14	1.16
  +++ seek.c	2001/08/10 21:04:47	1.17
  @@ -85,7 +85,7 @@
   
   
   
  -apr_status_t apr_file_seek(apr_file_t *thefile, apr_seek_where_t where, apr_off_t *offset)
  +APR_DECLARE(apr_status_t) apr_file_seek(apr_file_t *thefile, apr_seek_where_t where, apr_off_t *offset)
   {
       if (!thefile->isopen) {
           return APR_EBADF;
  @@ -134,7 +134,7 @@
   
   
   
  -apr_status_t apr_file_trunc(apr_file_t *fp, apr_off_t offset)
  +APR_DECLARE(apr_status_t) apr_file_trunc(apr_file_t *fp, apr_off_t offset)
   {
       int rc = DosSetFileSize(fp->filedes, offset);
   
  
  
  
  1.46      +9 -6      apr/file_io/unix/filestat.c
  
  Index: filestat.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/unix/filestat.c,v
  retrieving revision 1.45
  retrieving revision 1.46
  diff -u -r1.45 -r1.46
  --- filestat.c	2001/03/02 21:07:37	1.45
  +++ filestat.c	2001/08/10 21:04:47	1.46
  @@ -105,8 +105,9 @@
        */
   }
   
  -apr_status_t apr_file_info_get(apr_finfo_t *finfo, apr_int32_t wanted,
  -                             apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_info_get(apr_finfo_t *finfo, 
  +                                            apr_int32_t wanted,
  +                                            apr_file_t *thefile)
   {
       struct stat info;
   
  @@ -121,7 +122,8 @@
       }
   }
   
  -apr_status_t apr_file_perms_set(const char *fname, apr_fileperms_t perms)
  +APR_DECLARE(apr_status_t) apr_file_perms_set(const char *fname, 
  +                                             apr_fileperms_t perms)
   {
       mode_t mode = apr_unix_perms2mode(perms);
   
  @@ -130,8 +132,9 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_stat(apr_finfo_t *finfo, const char *fname,
  -                      apr_int32_t wanted, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_stat(apr_finfo_t *finfo, 
  +                                   const char *fname, 
  +                                   apr_int32_t wanted, apr_pool_t *cont)
   {
       struct stat info;
       int srv;
  @@ -186,7 +189,7 @@
   
   /* Perhaps this becomes nothing but a macro?
    */
  -apr_status_t apr_lstat(apr_finfo_t *finfo, const char *fname,
  +APR_DECLARE(apr_status_t) apr_lstat(apr_finfo_t *finfo, const char *fname,
                         apr_int32_t wanted, apr_pool_t *cont)
   {
       return apr_stat(finfo, fname, wanted | APR_FINFO_LINK, cont);
  
  
  
  1.5       +2 -2      apr/file_io/unix/flock.c
  
  Index: flock.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/unix/flock.c,v
  retrieving revision 1.4
  retrieving revision 1.5
  diff -u -r1.4 -r1.5
  --- flock.c	2001/02/25 20:39:29	1.4
  +++ flock.c	2001/08/10 21:04:47	1.5
  @@ -61,7 +61,7 @@
   #include <sys/file.h>
   #endif
   
  -apr_status_t apr_file_lock(apr_file_t *thefile, int type)
  +APR_DECLARE(apr_status_t) apr_file_lock(apr_file_t *thefile, int type)
   {
       int rc;
   
  @@ -112,7 +112,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_file_unlock(apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_unlock(apr_file_t *thefile)
   {
       int rc;
   
  
  
  
  1.84      +12 -12    apr/file_io/unix/open.c
  
  Index: open.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/unix/open.c,v
  retrieving revision 1.83
  retrieving revision 1.84
  diff -u -r1.83 -r1.84
  --- open.c	2001/07/23 07:31:07	1.83
  +++ open.c	2001/08/10 21:04:47	1.84
  @@ -82,7 +82,7 @@
       return rv != APR_SUCCESS ? rv : flush_rv;
   }
   
  -apr_status_t apr_file_open(apr_file_t **new, const char *fname, apr_int32_t flag,  apr_fileperms_t perm, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_open(apr_file_t **new, const char *fname, apr_int32_t flag,  apr_fileperms_t perm, apr_pool_t *cont)
   {
       int oflags = 0;
   #if APR_HAS_THREADS
  @@ -172,7 +172,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_file_close(apr_file_t *file)
  +APR_DECLARE(apr_status_t) apr_file_close(apr_file_t *file)
   {
       apr_status_t rv;
   
  @@ -183,7 +183,7 @@
       return rv;
   }
   
  -apr_status_t apr_file_remove(const char *path, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_remove(const char *path, apr_pool_t *cont)
   {
       if (unlink(path) == 0) {
           return APR_SUCCESS;
  @@ -193,8 +193,8 @@
       }
   }
   
  -apr_status_t apr_file_rename(const char *from_path, const char *to_path,
  -                           apr_pool_t *p)
  +APR_DECLARE(apr_status_t) apr_file_rename(const char *from_path, const char *to_path,
  +                                          apr_pool_t *p)
   {
       if (rename(from_path, to_path) != 0) {
           return errno;
  @@ -202,14 +202,14 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_file_get(apr_os_file_t *thefile, apr_file_t *file)
  +APR_DECLARE(apr_status_t) apr_os_file_get(apr_os_file_t *thefile, apr_file_t *file)
   {
       *thefile = file->filedes;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_file_put(apr_file_t **file, apr_os_file_t *thefile,
  -                             apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_file_put(apr_file_t **file, apr_os_file_t *thefile,
  +                                          apr_pool_t *cont)
   {
       int *dafile = thefile;
       
  @@ -227,7 +227,7 @@
       return APR_SUCCESS;
   }    
   
  -apr_status_t apr_file_eof(apr_file_t *fptr)
  +APR_DECLARE(apr_status_t) apr_file_eof(apr_file_t *fptr)
   {
       if (fptr->eof_hit == 1) {
           return APR_EOF;
  @@ -235,21 +235,21 @@
       return APR_SUCCESS;
   }   
   
  -apr_status_t apr_file_open_stderr(apr_file_t **thefile, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_open_stderr(apr_file_t **thefile, apr_pool_t *cont)
   {
       int fd = STDERR_FILENO;
   
       return apr_os_file_put(thefile, &fd, cont);
   }
   
  -apr_status_t apr_file_open_stdout(apr_file_t **thefile, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_open_stdout(apr_file_t **thefile, apr_pool_t *cont)
   {
       int fd = STDOUT_FILENO;
   
       return apr_os_file_put(thefile, &fd, cont);
   }
   
  -apr_status_t apr_file_open_stdin(apr_file_t **thefile, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_open_stdin(apr_file_t **thefile, apr_pool_t *cont)
   {
       int fd = STDIN_FILENO;
   
  
  
  
  1.48      +5 -5      apr/file_io/unix/pipe.c
  
  Index: pipe.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/unix/pipe.c,v
  retrieving revision 1.47
  retrieving revision 1.48
  diff -u -r1.47 -r1.48
  --- pipe.c	2001/07/23 17:47:27	1.47
  +++ pipe.c	2001/08/10 21:04:47	1.48
  @@ -126,7 +126,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_file_pipe_timeout_set(apr_file_t *thepipe, apr_interval_time_t timeout)
  +APR_DECLARE(apr_status_t) apr_file_pipe_timeout_set(apr_file_t *thepipe, apr_interval_time_t timeout)
   {
       if (thepipe->pipe == 1) {
           thepipe->timeout = timeout;
  @@ -145,7 +145,7 @@
       return APR_EINVAL;
   }
   
  -apr_status_t apr_file_pipe_timeout_get(apr_file_t *thepipe, apr_interval_time_t *timeout)
  +APR_DECLARE(apr_status_t) apr_file_pipe_timeout_get(apr_file_t *thepipe, apr_interval_time_t *timeout)
   {
       if (thepipe->pipe == 1) {
           *timeout = thepipe->timeout;
  @@ -154,7 +154,7 @@
       return APR_EINVAL;
   }
   
  -apr_status_t apr_file_pipe_create(apr_file_t **in, apr_file_t **out, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_pipe_create(apr_file_t **in, apr_file_t **out, apr_pool_t *cont)
   {
       int filedes[2];
   
  @@ -194,8 +194,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_file_namedpipe_create(const char *filename, 
  -                                apr_fileperms_t perm, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_file_namedpipe_create(const char *filename, 
  +                                                    apr_fileperms_t perm, apr_pool_t *cont)
   {
       mode_t mode = apr_unix_perms2mode(perm);
   
  
  
  
  1.70      +10 -10    apr/file_io/unix/readwrite.c
  
  Index: readwrite.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/unix/readwrite.c,v
  retrieving revision 1.69
  retrieving revision 1.70
  diff -u -r1.69 -r1.70
  --- readwrite.c	2001/02/25 20:46:48	1.69
  +++ readwrite.c	2001/08/10 21:04:47	1.70
  @@ -102,7 +102,7 @@
   /* problems: 
    * 1) ungetchar not used for buffered files
    */
  -apr_status_t apr_file_read(apr_file_t *thefile, void *buf, apr_size_t *nbytes)
  +APR_DECLARE(apr_status_t) apr_file_read(apr_file_t *thefile, void *buf, apr_size_t *nbytes)
   {
       apr_ssize_t rv;
       apr_size_t bytes_read;
  @@ -206,7 +206,7 @@
       }
   }
   
  -apr_status_t apr_file_write(apr_file_t *thefile, const void *buf, apr_size_t *nbytes)
  +APR_DECLARE(apr_status_t) apr_file_write(apr_file_t *thefile, const void *buf, apr_size_t *nbytes)
   {
       apr_size_t rv;
   
  @@ -277,8 +277,8 @@
       }
   }
   
  -apr_status_t apr_file_writev(apr_file_t *thefile, const struct iovec *vec,
  -                      apr_size_t nvec, apr_size_t *nbytes)
  +APR_DECLARE(apr_status_t) apr_file_writev(apr_file_t *thefile, const struct iovec *vec,
  +                                          apr_size_t nvec, apr_size_t *nbytes)
   {
   #ifdef HAVE_WRITEV
       int bytes;
  @@ -297,34 +297,34 @@
   #endif
   }
   
  -apr_status_t apr_file_putc(char ch, apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_putc(char ch, apr_file_t *thefile)
   {
       apr_size_t nbytes = 1;
   
       return apr_file_write(thefile, &ch, &nbytes);
   }
   
  -apr_status_t apr_file_ungetc(char ch, apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_ungetc(char ch, apr_file_t *thefile)
   {
       thefile->ungetchar = (unsigned char)ch;
       return APR_SUCCESS; 
   }
   
  -apr_status_t apr_file_getc(char *ch, apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_getc(char *ch, apr_file_t *thefile)
   {
       apr_size_t nbytes = 1;
   
       return apr_file_read(thefile, ch, &nbytes);
   }
   
  -apr_status_t apr_file_puts(const char *str, apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_puts(const char *str, apr_file_t *thefile)
   {
       apr_size_t nbytes = strlen(str);
   
       return apr_file_write(thefile, str, &nbytes);
   }
   
  -apr_status_t apr_file_flush(apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_flush(apr_file_t *thefile)
   {
       if (thefile->buffered) {
           apr_int64_t written = 0;
  @@ -346,7 +346,7 @@
       return APR_SUCCESS; 
   }
   
  -apr_status_t apr_file_gets(char *str, int len, apr_file_t *thefile)
  +APR_DECLARE(apr_status_t) apr_file_gets(char *str, int len, apr_file_t *thefile)
   {
       apr_status_t rv = APR_SUCCESS; /* get rid of gcc warning */
       apr_size_t nbytes;
  
  
  
  1.22      +1 -1      apr/file_io/unix/seek.c
  
  Index: seek.c
  ===================================================================
  RCS file: /home/cvs/apr/file_io/unix/seek.c,v
  retrieving revision 1.21
  retrieving revision 1.22
  diff -u -r1.21 -r1.22
  --- seek.c	2001/05/23 14:49:17	1.21
  +++ seek.c	2001/08/10 21:04:47	1.22
  @@ -86,7 +86,7 @@
   }
   
   
  -apr_status_t apr_file_seek(apr_file_t *thefile, apr_seek_where_t where, apr_off_t *offset)
  +APR_DECLARE(apr_status_t) apr_file_seek(apr_file_t *thefile, apr_seek_where_t where, apr_off_t *offset)
   {
       apr_off_t rv;
   
  
  
  
  1.34      +19 -17    apr/locks/beos/locks.c
  
  Index: locks.c
  ===================================================================
  RCS file: /home/cvs/apr/locks/beos/locks.c,v
  retrieving revision 1.33
  retrieving revision 1.34
  diff -u -r1.33 -r1.34
  --- locks.c	2001/07/19 00:11:57	1.33
  +++ locks.c	2001/08/10 21:04:47	1.34
  @@ -273,9 +273,9 @@
       return stat;
   }
   
  -apr_status_t apr_lock_create(apr_lock_t **lock, apr_locktype_e type, 
  -                           apr_lockscope_e scope, const char *fname, 
  -                           apr_pool_t *pool)
  +APR_DECLARE(apr_status_t) apr_lock_create(apr_lock_t **lock, apr_locktype_e type, 
  +                                          apr_lockscope_e scope, const char *fname, 
  +                                          apr_pool_t *pool)
   {
       apr_lock_t *new;
       apr_status_t stat = APR_SUCCESS;
  @@ -302,7 +302,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_acquire(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_acquire(apr_lock_t *lock)
   {
       apr_status_t stat;
   
  @@ -328,12 +328,12 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_tryacquire(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_tryacquire(apr_lock_t *lock)
   {
       return APR_ENOTIMPL;
   }
   
  -apr_status_t apr_lock_acquire_rw(apr_lock_t *lock, apr_readerwriter_e e)
  +APR_DECLARE(apr_status_t) apr_lock_acquire_rw(apr_lock_t *lock, apr_readerwriter_e e)
   {
       switch (lock->type)
       {
  @@ -354,7 +354,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_release(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_release(apr_lock_t *lock)
   {
       apr_status_t stat = APR_SUCCESS;
   
  @@ -394,7 +394,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_destroy(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_destroy(apr_lock_t *lock)
   {
       apr_status_t stat; 
   
  @@ -411,32 +411,34 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_child_init(apr_lock_t **lock, const char *fname, 
  -			                     apr_pool_t *pool)
  +APR_DECLARE(apr_status_t) apr_lock_child_init(apr_lock_t **lock, const char *fname, 
  +			                                  apr_pool_t *pool)
   {
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_data_get(apr_lock_t *lock, const char *key, void *data)
  +APR_DECLARE(apr_status_t) apr_lock_data_get(apr_lock_t *lock, 
  +                                            const char *key, void *data)
   {
       return apr_pool_userdata_get(data, key, lock->pool);
   }
   
  -apr_status_t apr_lock_data_set(apr_lock_t *lock, void *data, const char *key,
  -                            apr_status_t (*cleanup) (void *))
  +APR_DECLARE(apr_status_t) apr_lock_data_set(apr_lock_t *lock, 
  +                                            void *data, const char *key,
  +                                            apr_status_t (*cleanup) (void *))
   {
       return apr_pool_userdata_set(data, key, cleanup, lock->pool);
   }
   
  -apr_status_t apr_os_lock_get(apr_os_lock_t *oslock, apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_os_lock_get(apr_os_lock_t *oslock, apr_lock_t *lock)
   {
       oslock->sem = lock->Lock;
       oslock->ben = lock->LockCount;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_lock_put(apr_lock_t **lock, apr_os_lock_t *thelock, 
  -                             apr_pool_t *pool)
  +APR_DECLARE(apr_status_t) apr_os_lock_put(apr_lock_t **lock, apr_os_lock_t *thelock, 
  +                                          apr_pool_t *pool)
   {
       if (pool == NULL) {
           return APR_ENOPOOL;
  @@ -450,4 +452,4 @@
   
       return APR_SUCCESS;
   }
  -    
  +
  
  
  
  1.35      +15 -15    apr/locks/os2/locks.c
  
  Index: locks.c
  ===================================================================
  RCS file: /home/cvs/apr/locks/os2/locks.c,v
  retrieving revision 1.34
  retrieving revision 1.35
  diff -u -r1.34 -r1.35
  --- locks.c	2001/08/05 10:15:46	1.34
  +++ locks.c	2001/08/10 21:04:47	1.35
  @@ -71,9 +71,9 @@
   
   
   
  -apr_status_t apr_lock_create(apr_lock_t **lock, apr_locktype_e type, 
  -                             apr_lockscope_e scope, const char *fname, 
  -                             apr_pool_t *pool)
  +APR_DECLARE(apr_status_t) apr_lock_create(apr_lock_t **lock, apr_locktype_e type, 
  +                                          apr_lockscope_e scope, const char *fname, 
  +                                          apr_pool_t *pool)
   {
       apr_lock_t *new;
       ULONG rc;
  @@ -111,7 +111,7 @@
   
   
   
  -apr_status_t apr_lock_child_init(apr_lock_t **lock, const char *fname,
  +APR_DECLARE(apr_status_t) apr_lock_child_init(apr_lock_t **lock, const char *fname,
   			       apr_pool_t *pool)
   {
       int rc;
  @@ -160,21 +160,21 @@
   
   
   
  -apr_status_t apr_lock_acquire(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_acquire(apr_lock_t *lock)
   {
       return os2_lock_acquire(lock, SEM_INDEFINITE_WAIT);
   }
   
   
   
  -apr_status_t apr_lock_tryacquire(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_tryacquire(apr_lock_t *lock)
   {
       return os2_lock_acquire(lock, SEM_IMMEDIATE_RETURN);
   }
   
   
   
  -apr_status_t apr_lock_acquire_rw(apr_lock_t *lock, apr_readerwriter_e e)
  +APR_DECLARE(apr_status_t) apr_lock_acquire_rw(apr_lock_t *lock, apr_readerwriter_e e)
   {
       switch (lock->type) {
       case APR_MUTEX:
  @@ -191,7 +191,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_release(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_release(apr_lock_t *lock)
   {
       ULONG rc;
       
  @@ -212,7 +212,7 @@
   
   
   
  -apr_status_t apr_lock_destroy(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_destroy(apr_lock_t *lock)
   {
       ULONG rc;
       apr_status_t stat = APR_SUCCESS;
  @@ -246,7 +246,7 @@
   
   
   
  -apr_status_t apr_os_lock_get(apr_os_lock_t *oslock, apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_os_lock_get(apr_os_lock_t *oslock, apr_lock_t *lock)
   {
       *oslock = lock->hMutex;
       return APR_SUCCESS;
  @@ -254,8 +254,8 @@
   
   
   
  -apr_status_t apr_os_lock_put(apr_lock_t **lock, apr_os_lock_t *thelock, 
  -                           apr_pool_t *pool)
  +APR_DECLARE(apr_status_t) apr_os_lock_put(apr_lock_t **lock, apr_os_lock_t *thelock, 
  +                                          apr_pool_t *pool)
   {
       if (pool == NULL) {
           return APR_ENOPOOL;
  @@ -270,15 +270,15 @@
   
   
   
  -apr_status_t apr_lock_data_get(apr_lock_t *lock, const char *key, void *data)
  +APR_DECLARE(apr_status_t) apr_lock_data_get(apr_lock_t *lock, const char *key, void *data)
   {
       return apr_pool_userdata_get(data, key, lock->pool);
   }
   
   
   
  -apr_status_t apr_lock_data_set(apr_lock_t *lock, void *data, const char *key,
  -                            apr_status_t (*cleanup) (void *))
  +APR_DECLARE(apr_status_t) apr_lock_data_set(apr_lock_t *lock, void *data, const char *key,
  +                                            apr_status_t (*cleanup) (void *))
   {
       return apr_pool_userdata_set(data, key, cleanup, lock->pool);
   }
  
  
  
  1.62      +19 -18    apr/locks/unix/locks.c
  
  Index: locks.c
  ===================================================================
  RCS file: /home/cvs/apr/locks/unix/locks.c,v
  retrieving revision 1.61
  retrieving revision 1.62
  diff -u -r1.61 -r1.62
  --- locks.c	2001/07/19 00:11:57	1.61
  +++ locks.c	2001/08/10 21:04:47	1.62
  @@ -230,9 +230,9 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_create_np(apr_lock_t **lock, apr_locktype_e type, 
  -                                apr_lockscope_e scope, apr_lockmech_e_np mech,
  -                                const char *fname, apr_pool_t *pool)
  +APR_DECLARE(apr_status_t) apr_lock_create_np(apr_lock_t **lock, apr_locktype_e type, 
  +                                             apr_lockscope_e scope, apr_lockmech_e_np mech,
  +                                             const char *fname, apr_pool_t *pool)
   {
       apr_lock_t *new;
       apr_status_t stat;
  @@ -253,14 +253,14 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_create(apr_lock_t **lock, apr_locktype_e type, 
  -                             apr_lockscope_e scope, const char *fname, 
  -                             apr_pool_t *pool)
  +APR_DECLARE(apr_status_t) apr_lock_create(apr_lock_t **lock, apr_locktype_e type, 
  +                                          apr_lockscope_e scope, const char *fname, 
  +                                          apr_pool_t *pool)
   {
       return apr_lock_create_np(lock, type, scope, APR_LOCK_DEFAULT, fname, pool);
   }
   
  -apr_status_t apr_lock_acquire(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_acquire(apr_lock_t *lock)
   {
       apr_status_t stat;
   
  @@ -283,7 +283,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_tryacquire(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_tryacquire(apr_lock_t *lock)
   {
       apr_status_t stat;
   
  @@ -306,7 +306,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_acquire_rw(apr_lock_t *lock, apr_readerwriter_e e)
  +APR_DECLARE(apr_status_t) apr_lock_acquire_rw(apr_lock_t *lock, 
  +                                              apr_readerwriter_e e)
   {
       switch (e)
       {
  @@ -318,7 +319,7 @@
       return APR_ENOTIMPL;
   }
   
  -apr_status_t apr_lock_release(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_release(apr_lock_t *lock)
   {
       apr_status_t stat;
   
  @@ -342,12 +343,12 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_destroy(apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_lock_destroy(apr_lock_t *lock)
   {
       return lock->meth->destroy(lock);
   }
   
  -apr_status_t apr_lock_child_init(apr_lock_t **lock, const char *fname, 
  +APR_DECLARE(apr_status_t) apr_lock_child_init(apr_lock_t **lock, const char *fname, 
                                  apr_pool_t *cont)
   {
       if ((*lock)->scope != APR_INTRAPROCESS)
  @@ -355,18 +356,18 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_lock_data_get(apr_lock_t *lock, const char *key, void *data)
  +APR_DECLARE(apr_status_t) apr_lock_data_get(apr_lock_t *lock, const char *key, void *data)
   {
       return apr_pool_userdata_get(data, key, lock->pool);
   }
   
  -apr_status_t apr_lock_data_set(apr_lock_t *lock, void *data, const char *key,
  +APR_DECLARE(apr_status_t) apr_lock_data_set(apr_lock_t *lock, void *data, const char *key,
                               apr_status_t (*cleanup) (void *))
   {
       return apr_pool_userdata_set(data, key, cleanup, lock->pool);
   }
   
  -apr_status_t apr_os_lock_get(apr_os_lock_t *oslock, apr_lock_t *lock)
  +APR_DECLARE(apr_status_t) apr_os_lock_get(apr_os_lock_t *oslock, apr_lock_t *lock)
   {
   #if APR_HAS_SYSVSEM_SERIALIZE || APR_HAS_FCNTL_SERIALIZE || APR_HAS_FLOCK_SERIALIZE
       oslock->crossproc = lock->interproc;
  @@ -383,8 +384,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_lock_put(apr_lock_t **lock, apr_os_lock_t *thelock, 
  -                           apr_pool_t *pool)
  +APR_DECLARE(apr_status_t) apr_os_lock_put(apr_lock_t **lock, apr_os_lock_t *thelock, 
  +                                          apr_pool_t *pool)
   {
       if (pool == NULL) {
           return APR_ENOPOOL;
  @@ -406,4 +407,4 @@
   #endif
       return APR_SUCCESS;
   }
  -    
  + 
  
  
  
  1.13      +1 -1      apr/misc/unix/getuuid.c
  
  Index: getuuid.c
  ===================================================================
  RCS file: /home/cvs/apr/misc/unix/getuuid.c,v
  retrieving revision 1.12
  retrieving revision 1.13
  diff -u -r1.12 -r1.13
  --- getuuid.c	2001/08/07 21:48:34	1.12
  +++ getuuid.c	2001/08/10 21:04:47	1.13
  @@ -212,7 +212,7 @@
       *timestamp = time_now + fudge;
   }
   
  -void apr_uuid_get(apr_uuid_t *uuid)
  +APR_DECLARE(void) apr_uuid_get(apr_uuid_t *uuid)
   {
       apr_uint64_t timestamp;
       unsigned char *d = uuid->data;
  
  
  
  1.7       +2 -1      apr/misc/unix/rand.c
  
  Index: rand.c
  ===================================================================
  RCS file: /home/cvs/apr/misc/unix/rand.c,v
  retrieving revision 1.6
  retrieving revision 1.7
  diff -u -r1.6 -r1.7
  --- rand.c	2001/02/25 20:39:34	1.6
  +++ rand.c	2001/08/10 21:04:47	1.7
  @@ -65,7 +65,8 @@
   #define	XSTR(x)	#x
   #define	STR(x)	XSTR(x)
   
  -apr_status_t apr_generate_random_bytes(unsigned char * buf, int length) 
  +APR_DECLARE(apr_status_t) apr_generate_random_bytes(unsigned char *buf, 
  +                                                    int length) 
   {
   #ifdef	DEV_RANDOM
   
  
  
  
  1.28      +14 -14    apr/network_io/beos/poll.c
  
  Index: poll.c
  ===================================================================
  RCS file: /home/cvs/apr/network_io/beos/poll.c,v
  retrieving revision 1.27
  retrieving revision 1.28
  diff -u -r1.27 -r1.28
  --- poll.c	2001/03/22 21:50:10	1.27
  +++ poll.c	2001/08/10 21:04:47	1.28
  @@ -67,7 +67,7 @@
    *  select for R4.5 of BeOS.  So here we use code that uses the write
    *  bits.
    */
  -apr_status_t apr_poll_setup(apr_pollfd_t **new, apr_int32_t num, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_poll_setup(apr_pollfd_t **new, apr_int32_t num, apr_pool_t *cont)
   {
       (*new) = (apr_pollfd_t *)apr_pcalloc(cont, sizeof(apr_pollfd_t) * num);
       if ((*new) == NULL) {
  @@ -90,8 +90,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_poll_socket_add(apr_pollfd_t *aprset,
  -                               apr_socket_t *sock, apr_int16_t event)
  +APR_DECLARE(apr_status_t) apr_poll_socket_add(apr_pollfd_t *aprset,
  +                                              apr_socket_t *sock, apr_int16_t event)
   {
       if (event & APR_POLLIN) {
           FD_SET(sock->socketdes, aprset->read_set);
  @@ -108,9 +108,9 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_poll_socket_mask(apr_pollfd_t *aprset, 
  -                                  apr_socket_t *sock, 
  -                                  apr_int16_t events)
  +APR_DECLARE(apr_status_t) apr_poll_socket_mask(apr_pollfd_t *aprset, 
  +                                               apr_socket_t *sock, 
  +                                               apr_int16_t events)
   {
       if (events & APR_POLLIN) {
           FD_CLR(sock->socketdes, aprset->read_set);
  @@ -124,8 +124,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_poll(apr_pollfd_t *aprset, apr_int32_t *nsds, 
  -		    apr_interval_time_t timeout)
  +APR_DECLARE(apr_status_t) apr_poll(apr_pollfd_t *aprset, apr_int32_t *nsds, 
  +		                           apr_interval_time_t timeout)
   {
       int rv;
       struct timeval tv, *tvptr;
  @@ -156,7 +156,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_poll_revents_get(apr_int16_t *event, apr_socket_t *sock, apr_pollfd_t *aprset)
  +APR_DECLARE(apr_status_t) apr_poll_revents_get(apr_int16_t *event, apr_socket_t *sock, apr_pollfd_t *aprset)
   {
       apr_int16_t revents = 0;
       char data[1];
  @@ -200,7 +200,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_poll_socket_remove(apr_pollfd_t *aprset, apr_socket_t *sock)
  +APR_DECLARE(apr_status_t) apr_poll_socket_remove(apr_pollfd_t *aprset, apr_socket_t *sock)
   {
       FD_CLR(sock->socketdes, aprset->read_set);
       FD_CLR(sock->socketdes, aprset->except_set);
  @@ -208,7 +208,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_poll_socket_clear(apr_pollfd_t *aprset, apr_int16_t event)
  +APR_DECLARE(apr_status_t) apr_poll_socket_clear(apr_pollfd_t *aprset, apr_int16_t event)
   {
       if (event & APR_POLLIN) {
           FD_ZERO(aprset->read_set);
  @@ -223,13 +223,13 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_poll_data_get(apr_pollfd_t *pollfd, const char *key, void *data)
  +APR_DECLARE(apr_status_t) apr_poll_data_get(apr_pollfd_t *pollfd, const char *key, void *data)
   {
       return apr_pool_userdata_get(data, key, pollfd->cntxt);
   }
   
  -apr_status_t apr_poll_data_set(apr_pollfd_t *pollfd, void *data, const char *key,
  -                            apr_status_t (*cleanup) (void *))
  +APR_DECLARE(apr_status_t) apr_poll_data_set(apr_pollfd_t *pollfd, void *data, const char *key,
  +                                            apr_status_t (*cleanup) (void *))
   {
       return apr_pool_userdata_set(data, key, cleanup, pollfd->cntxt);
   }
  
  
  
  1.24      +9 -9      apr/network_io/beos/sendrecv.c
  
  Index: sendrecv.c
  ===================================================================
  RCS file: /home/cvs/apr/network_io/beos/sendrecv.c,v
  retrieving revision 1.23
  retrieving revision 1.24
  diff -u -r1.23 -r1.24
  --- sendrecv.c	2001/07/27 01:27:07	1.23
  +++ sendrecv.c	2001/08/10 21:04:47	1.24
  @@ -95,7 +95,7 @@
   
   #define SEND_WAIT APR_USEC_PER_SEC / 10
   
  -apr_status_t apr_send(apr_socket_t *sock, const char *buf, apr_size_t *len)
  +APR_DECLARE(apr_status_t) apr_send(apr_socket_t *sock, const char *buf, apr_size_t *len)
   {
       ssize_t rv;
   	
  @@ -128,7 +128,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_recv(apr_socket_t *sock, char *buf, apr_size_t *len)
  +APR_DECLARE(apr_status_t) apr_recv(apr_socket_t *sock, char *buf, apr_size_t *len)
   {
       apr_ssize_t rv;
      
  @@ -160,15 +160,15 @@
   
   /* BeOS doesn't have writev for sockets so we use the following instead...
    */
  -apr_status_t apr_sendv(apr_socket_t * sock, const struct iovec *vec,
  -                     apr_int32_t nvec, apr_size_t *len)
  +APR_DECLARE(apr_status_t) apr_sendv(apr_socket_t * sock, const struct iovec *vec,
  +                                    apr_int32_t nvec, apr_size_t *len)
   {
       *len = vec[0].iov_len;
       return apr_send(sock, vec[0].iov_base, len);
   }
   
  -apr_status_t apr_sendto(apr_socket_t *sock, apr_sockaddr_t *where,
  -                        apr_int32_t flags, const char *buf, apr_size_t *len)
  +APR_DECLARE(apr_status_t) apr_sendto(apr_socket_t *sock, apr_sockaddr_t *where,
  +                                     apr_int32_t flags, const char *buf, apr_size_t *len)
   {
       ssize_t rv;
   
  @@ -200,9 +200,9 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_recvfrom(apr_sockaddr_t *from, apr_socket_t *sock,
  -                          apr_int32_t flags, char *buf,
  -                          apr_size_t *len)
  +APR_DECLARE(apr_status_t) apr_recvfrom(apr_sockaddr_t *from, apr_socket_t *sock,
  +                                       apr_int32_t flags, char *buf,
  +                                       apr_size_t *len)
   {
       ssize_t rv;
   
  
  
  
  1.23      +12 -13    apr/network_io/os2/poll.c
  
  Index: poll.c
  ===================================================================
  RCS file: /home/cvs/apr/network_io/os2/poll.c,v
  retrieving revision 1.22
  retrieving revision 1.23
  diff -u -r1.22 -r1.23
  --- poll.c	2001/03/19 12:35:14	1.22
  +++ poll.c	2001/08/10 21:04:48	1.23
  @@ -62,7 +62,7 @@
   
   /*  OS/2 doesn't have a poll function, implement using OS/2 style select */
    
  -apr_status_t apr_poll_setup(apr_pollfd_t **new, apr_int32_t num, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_poll_setup(apr_pollfd_t **new, apr_int32_t num, apr_pool_t *cont)
   {
       *new = (apr_pollfd_t *)apr_palloc(cont, sizeof(apr_pollfd_t));
   
  @@ -93,8 +93,8 @@
   
   
   
  -apr_status_t apr_poll_socket_add(apr_pollfd_t *aprset, 
  -			       apr_socket_t *sock, apr_int16_t events)
  +APR_DECLARE(apr_status_t) apr_poll_socket_add(apr_pollfd_t *aprset, 
  +			                                  apr_socket_t *sock, apr_int16_t events)
   {
       int i;
       
  @@ -124,8 +124,8 @@
   
   
   
  -apr_status_t apr_poll(apr_pollfd_t *pollfdset, apr_int32_t *nsds, 
  -                    apr_interval_time_t timeout)
  +APR_DECLARE(apr_status_t) apr_poll(apr_pollfd_t *pollfdset, apr_int32_t *nsds, 
  +                                   apr_interval_time_t timeout)
   {
       int i;
       int rv = 0;
  @@ -158,7 +158,7 @@
   
   
   
  -apr_status_t apr_poll_revents_get(apr_int16_t *event, apr_socket_t *sock, apr_pollfd_t *aprset)
  +APR_DECLARE(apr_status_t) apr_poll_revents_get(apr_int16_t *event, apr_socket_t *sock, apr_pollfd_t *aprset)
   {
       int i;
       
  @@ -180,8 +180,8 @@
   
   
   
  -apr_status_t apr_poll_socket_mask(apr_pollfd_t *aprset, 
  -                                apr_socket_t *sock, apr_int16_t events)
  +APR_DECLARE(apr_status_t) apr_poll_socket_mask(apr_pollfd_t *aprset, 
  +                                               apr_socket_t *sock, apr_int16_t events)
   {
       int start, *count, pos;
   
  @@ -218,14 +218,14 @@
   
   
   
  -apr_status_t apr_poll_socket_remove(apr_pollfd_t *aprset, apr_socket_t *sock)
  +APR_DECLARE(apr_status_t) apr_poll_socket_remove(apr_pollfd_t *aprset, apr_socket_t *sock)
   {
       return apr_poll_socket_mask(aprset, sock, APR_POLLIN|APR_POLLOUT|APR_POLLPRI);
   }
   
   
   
  -apr_status_t apr_poll_socket_clear(apr_pollfd_t *aprset, apr_int16_t events)
  +APR_DECLARE(apr_status_t) apr_poll_socket_clear(apr_pollfd_t *aprset, apr_int16_t events)
   {
       aprset->num_read = 0;
       aprset->num_write = 0;
  @@ -235,15 +235,14 @@
   }
   
   
  -
  -apr_status_t apr_poll_data_get(apr_pollfd_t *pollfd, const char *key, void *data)
  +APR_DECLARE(apr_status_t) apr_poll_data_get(apr_pollfd_t *pollfd, const char *key, void *data)
   {
       return apr_pool_userdata_get(data, key, pollfd->cntxt);
   }
   
   
   
  -apr_status_t apr_poll_data_set(apr_pollfd_t *pollfd, void *data, const char *key,
  +APR_DECLARE(apr_status_t) apr_poll_data_set(apr_pollfd_t *pollfd, void *data, const char *key,
                               apr_status_t (*cleanup) (void *))
   {
       return apr_pool_userdata_set(data, key, cleanup, pollfd->cntxt);
  
  
  
  1.21      +3 -3      apr/network_io/os2/sendrecv.c
  
  Index: sendrecv.c
  ===================================================================
  RCS file: /home/cvs/apr/network_io/os2/sendrecv.c,v
  retrieving revision 1.20
  retrieving revision 1.21
  diff -u -r1.20 -r1.21
  --- sendrecv.c	2001/03/05 14:56:04	1.20
  +++ sendrecv.c	2001/08/10 21:04:48	1.21
  @@ -59,7 +59,7 @@
   #include "apr_lib.h"
   #include <sys/time.h>
   
  -apr_status_t apr_send(apr_socket_t *sock, const char *buf, apr_size_t *len)
  +APR_DECLARE(apr_status_t) apr_send(apr_socket_t *sock, const char *buf, apr_size_t *len)
   {
       ssize_t rv;
       int fds, err = 0;
  @@ -98,7 +98,7 @@
   
   
   
  -apr_status_t apr_recv(apr_socket_t *sock, char *buf, apr_size_t *len)
  +APR_DECLARE(apr_status_t) apr_recv(apr_socket_t *sock, char *buf, apr_size_t *len)
   {
       ssize_t rv;
       int fds, err = 0;
  @@ -137,7 +137,7 @@
   
   
   
  -apr_status_t apr_sendv(apr_socket_t *sock, const struct iovec *vec, apr_int32_t nvec, apr_size_t *len)
  +APR_DECLARE(apr_status_t) apr_sendv(apr_socket_t *sock, const struct iovec *vec, apr_int32_t nvec, apr_size_t *len)
   {
       apr_status_t rv;
       struct iovec *tmpvec;
  
  
  
  1.3       +5 -5      apr/network_io/os2/sendrecv_udp.c
  
  Index: sendrecv_udp.c
  ===================================================================
  RCS file: /home/cvs/apr/network_io/os2/sendrecv_udp.c,v
  retrieving revision 1.2
  retrieving revision 1.3
  diff -u -r1.2 -r1.3
  --- sendrecv_udp.c	2001/07/24 16:05:24	1.2
  +++ sendrecv_udp.c	2001/08/10 21:04:48	1.3
  @@ -81,8 +81,8 @@
   
   
   
  -apr_status_t apr_sendto(apr_socket_t *sock, apr_sockaddr_t *where,
  -                        apr_int32_t flags, const char *buf, apr_size_t *len)
  +APR_DECLARE(apr_status_t) apr_sendto(apr_socket_t *sock, apr_sockaddr_t *where,
  +                                     apr_int32_t flags, const char *buf, apr_size_t *len)
   {
       ssize_t rv;
       int serrno;
  @@ -119,9 +119,9 @@
   
   
   
  -apr_status_t apr_recvfrom(apr_sockaddr_t *from, apr_socket_t *sock,
  -                          apr_int32_t flags, char *buf, 
  -                          apr_size_t *len)
  +APR_DECLARE(apr_status_t) apr_recvfrom(apr_sockaddr_t *from, apr_socket_t *sock,
  +                                       apr_int32_t flags, char *buf, 
  +                                       apr_size_t *len)
   {
       ssize_t rv;
       int serrno;
  
  
  
  1.47      +17 -21    apr/network_io/os2/sockets.c
  
  Index: sockets.c
  ===================================================================
  RCS file: /home/cvs/apr/network_io/os2/sockets.c,v
  retrieving revision 1.46
  retrieving revision 1.47
  diff -u -r1.46 -r1.47
  --- sockets.c	2001/07/24 16:05:24	1.46
  +++ sockets.c	2001/08/10 21:04:48	1.47
  @@ -130,8 +130,8 @@
       (*new)->remote_addr->pool = p;
   }
   
  -apr_status_t apr_socket_create(apr_socket_t **new, int ofamily, int type,
  -                               apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_socket_create(apr_socket_t **new, int ofamily, int type,
  +                                            apr_pool_t *cont)
   {
       int family = ofamily;
   
  @@ -172,7 +172,7 @@
       return APR_SUCCESS;
   } 
   
  -apr_status_t apr_shutdown(apr_socket_t *thesocket, apr_shutdown_how_e how)
  +APR_DECLARE(apr_status_t) apr_shutdown(apr_socket_t *thesocket, apr_shutdown_how_e how)
   {
       if (shutdown(thesocket->socketdes, how) == 0) {
           return APR_SUCCESS;
  @@ -182,16 +182,13 @@
       }
   }
   
  -apr_status_t apr_socket_close(apr_socket_t *thesocket)
  +APR_DECLARE(apr_status_t) apr_socket_close(apr_socket_t *thesocket)
   {
       apr_pool_cleanup_kill(thesocket->cntxt, thesocket, socket_cleanup);
       return socket_cleanup(thesocket);
   }
   
  -
  -
  -
  -apr_status_t apr_bind(apr_socket_t *sock, apr_sockaddr_t *sa)
  +APR_DECLARE(apr_status_t) apr_bind(apr_socket_t *sock, apr_sockaddr_t *sa)
   {
       if (bind(sock->socketdes, 
                (struct sockaddr *)&sa->sa,
  @@ -203,7 +200,7 @@
       }
   }
   
  -apr_status_t apr_listen(apr_socket_t *sock, apr_int32_t backlog)
  +APR_DECLARE(apr_status_t) apr_listen(apr_socket_t *sock, apr_int32_t backlog)
   {
       if (listen(sock->socketdes, backlog) == -1)
           return APR_OS2_STATUS(sock_errno());
  @@ -211,7 +208,7 @@
           return APR_SUCCESS;
   }
   
  -apr_status_t apr_accept(apr_socket_t **new, apr_socket_t *sock, apr_pool_t *connection_context)
  +APR_DECLARE(apr_status_t) apr_accept(apr_socket_t **new, apr_socket_t *sock, apr_pool_t *connection_context)
   {
       alloc_socket(new, connection_context);
       set_socket_vars(*new, sock->local_addr->sa.sin.sin_family, SOCK_STREAM);
  @@ -232,7 +229,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_connect(apr_socket_t *sock, apr_sockaddr_t *sa)
  +APR_DECLARE(apr_status_t) apr_connect(apr_socket_t *sock, apr_sockaddr_t *sa)
   {
       if ((connect(sock->socketdes, (struct sockaddr *)&sa->sa.sin, 
                    sa->salen) < 0) &&
  @@ -248,31 +245,30 @@
       }
   }
   
  -
   
  -apr_status_t apr_socket_data_get(void **data, const char *key,
  -                              apr_socket_t *socket)
  +APR_DECLARE(apr_status_t) apr_socket_data_get(void **data, const char *key,
  +                                     apr_socket_t *socket)
   {
       return apr_pool_userdata_get(data, key, socket->cntxt);
   }
   
   
   
  -apr_status_t apr_socket_data_set(apr_socket_t *socket, void *data, const char *key,
  -                              apr_status_t (*cleanup) (void *))
  +APR_DECLARE(apr_status_t) apr_socket_data_set(apr_socket_t *socket, void *data, const char *key,
  +                                     apr_status_t (*cleanup) (void *))
   {
       return apr_pool_userdata_set(data, key, cleanup, socket->cntxt);
   }
   
  -apr_status_t apr_os_sock_get(apr_os_sock_t *thesock, apr_socket_t *sock)
  +APR_DECLARE(apr_status_t) apr_os_sock_get(apr_os_sock_t *thesock, apr_socket_t *sock)
   {
       *thesock = sock->socketdes;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_sock_make(apr_socket_t **apr_sock, 
  -                              apr_os_sock_info_t *os_sock_info, 
  -                              apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_sock_make(apr_socket_t **apr_sock, 
  +                                           apr_os_sock_info_t *os_sock_info, 
  +                                           apr_pool_t *cont)
   {
       alloc_socket(apr_sock, cont);
       set_socket_vars(*apr_sock, os_sock_info->family, os_sock_info->type);
  @@ -298,7 +294,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_sock_put(apr_socket_t **sock, apr_os_sock_t *thesock, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_sock_put(apr_socket_t **sock, apr_os_sock_t *thesock, apr_pool_t *cont)
   {
       if (cont == NULL) {
           return APR_ENOPOOL;
  
  
  
  1.22      +3 -3      apr/network_io/os2/sockopt.c
  
  Index: sockopt.c
  ===================================================================
  RCS file: /home/cvs/apr/network_io/os2/sockopt.c,v
  retrieving revision 1.21
  retrieving revision 1.22
  diff -u -r1.21 -r1.22
  --- sockopt.c	2001/02/16 04:16:01	1.21
  +++ sockopt.c	2001/08/10 21:04:48	1.22
  @@ -67,7 +67,7 @@
   #include <sys/so_ioctl.h>
   
   
  -apr_status_t apr_setsocketopt(apr_socket_t *sock, apr_int32_t opt, apr_int32_t on)
  +APR_DECLARE(apr_status_t) apr_setsocketopt(apr_socket_t *sock, apr_int32_t opt, apr_int32_t on)
   {
       int one;
       struct linger li;
  @@ -124,7 +124,7 @@
   
   
   
  -apr_status_t apr_getsocketopt(apr_socket_t *sock, apr_int32_t opt, apr_int32_t *on)
  +APR_DECLARE(apr_status_t) apr_getsocketopt(apr_socket_t *sock, apr_int32_t opt, apr_int32_t *on)
   {
       switch(opt) {
       case APR_SO_TIMEOUT:
  @@ -138,7 +138,7 @@
   
   
   
  -apr_status_t apr_gethostname(char *buf, apr_int32_t len, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_gethostname(char *buf, apr_int32_t len, apr_pool_t *cont)
   {
       if (gethostname(buf, len) == -1)
           return APR_OS2_STATUS(sock_errno());
  
  
  
  1.4       +10 -10    apr/shmem/beos/shmem.c
  
  Index: shmem.c
  ===================================================================
  RCS file: /home/cvs/apr/shmem/beos/shmem.c,v
  retrieving revision 1.3
  retrieving revision 1.4
  diff -u -r1.3 -r1.4
  --- shmem.c	2001/06/07 14:55:43	1.3
  +++ shmem.c	2001/08/10 21:04:48	1.4
  @@ -205,8 +205,8 @@
       return b;
   }
   
  -apr_status_t apr_shm_init(struct shmem_t **m, apr_size_t reqsize, const char *file, 
  -                          apr_pool_t *p)
  +APR_DECLARE(apr_status_t) apr_shm_init(struct shmem_t **m, apr_size_t reqsize, const char *file, 
  +                                       apr_pool_t *p)
   {
       apr_size_t pagesize;
       area_id newid;
  @@ -232,7 +232,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_shm_destroy(struct shmem_t *m)
  +APR_DECLARE(apr_status_t) apr_shm_destroy(struct shmem_t *m)
   {
       delete_area(m->aid);
       m->avail = 0;
  @@ -242,7 +242,7 @@
       return APR_SUCCESS;
   }
   
  -void *apr_shm_malloc(struct shmem_t *m, apr_size_t reqsize)
  +APR_DEClARE(void *) apr_shm_malloc(struct shmem_t *m, apr_size_t reqsize)
   {
       struct block_t *b;
       if ((b = alloc_block(m, reqsize)) != NULL)
  @@ -250,7 +250,7 @@
       return NULL;
   }
   
  -void *apr_shm_calloc(struct shmem_t *m, apr_size_t reqsize)
  +APR_DECLARE(void *) apr_shm_calloc(struct shmem_t *m, apr_size_t reqsize)
   {
       struct block_t *b; 
       if ((b = alloc_block(m, reqsize)) != NULL){  
  @@ -260,24 +260,24 @@
       return NULL;
   }
   
  -apr_status_t apr_shm_free(struct shmem_t *m, void *entity)
  +APR_DECLARE(apr_status_t) apr_shm_free(struct shmem_t *m, void *entity)
   {
       free_block(m, entity);   
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_shm_name_get(apr_shmem_t *c, apr_shm_name_t **name)
  +APR_DECLARE(apr_status_t) apr_shm_name_get(apr_shmem_t *c, apr_shm_name_t **name)
   {
       *name = NULL;
       return APR_ANONYMOUS;
   }
   
  -apr_status_t apr_shm_name_set(apr_shmem_t *c, apr_shm_name_t *name)
  +APR_DECLARE(apr_status_t) apr_shm_name_set(apr_shmem_t *c, apr_shm_name_t *name)
   {
       return APR_ANONYMOUS;
   }
   
  -apr_status_t apr_shm_open(struct shmem_t *m)
  +APR_DECLARE(apr_status_t) apr_shm_open(struct shmem_t *m)
   {
       /* If we've forked we need a clone of the original area or we
        * will only have access to a one time copy of the data made when
  @@ -311,7 +311,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_shm_avail(struct shmem_t *m, apr_size_t *size)
  +APR_DECLARE(apr_status_t) apr_shm_avail(struct shmem_t *m, apr_size_t *size)
   {
       *size = m->avail;
       if (m->avail == 0)
  
  
  
  1.11      +9 -9      apr/shmem/os2/shmem.c
  
  Index: shmem.c
  ===================================================================
  RCS file: /home/cvs/apr/shmem/os2/shmem.c,v
  retrieving revision 1.10
  retrieving revision 1.11
  diff -u -r1.10 -r1.11
  --- shmem.c	2001/02/16 04:16:06	1.10
  +++ shmem.c	2001/08/10 21:04:48	1.11
  @@ -67,7 +67,7 @@
   
   
   
  -apr_status_t apr_shm_init(struct shmem_t **m, apr_size_t reqsize, const char *file, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_shm_init(struct shmem_t **m, apr_size_t reqsize, const char *file, apr_pool_t *cont)
   {
       int rc;
       struct shmem_t *newm = (struct shmem_t *)apr_palloc(cont, sizeof(struct shmem_t));
  @@ -89,7 +89,7 @@
   
   
   
  -apr_status_t apr_shm_destroy(struct shmem_t *m)
  +APR_DECLARE(apr_status_t) apr_shm_destroy(struct shmem_t *m)
   {
       _uclose(m->heap);
       _udestroy(m->heap, _FORCE);
  @@ -99,21 +99,21 @@
   
   
   
  -void *apr_shm_malloc(struct shmem_t *m, apr_size_t reqsize)
  +APR_DECLARE(void *) apr_shm_malloc(struct shmem_t *m, apr_size_t reqsize)
   {
       return _umalloc(m->heap, reqsize);
   }
   
   
   
  -void *apr_shm_calloc(struct shmem_t *m, apr_size_t size)
  +APR_DECLARE(void *) apr_shm_calloc(struct shmem_t *m, apr_size_t size)
   {
       return _ucalloc(m->heap, size, 1);
   }
   
   
   
  -apr_status_t apr_shm_free(struct shmem_t *m, void *entity)
  +APR_DECLARE(apr_status_t) apr_shm_free(struct shmem_t *m, void *entity)
   {
       free(entity);
       return APR_SUCCESS;
  @@ -121,7 +121,7 @@
   
   
   
  -apr_status_t apr_shm_name_get(apr_shmem_t *c, apr_shm_name_t **name)
  +APR_DECLARE(apr_status_t) apr_shm_name_get(apr_shmem_t *c, apr_shm_name_t **name)
   {
       *name = NULL;
       return APR_ANONYMOUS;
  @@ -129,14 +129,14 @@
   
   
   
  -apr_status_t apr_shm_name_set(apr_shmem_t *c, apr_shm_name_t *name)
  +APR_DECLARE(apr_status_t) apr_shm_name_set(apr_shmem_t *c, apr_shm_name_t *name)
   {
       return APR_ANONYMOUS;
   }
   
   
   
  -apr_status_t apr_shm_open(struct shmem_t *m)
  +APR_DECLARE(apr_status_t) apr_shm_open(struct shmem_t *m)
   {
       int rc;
   
  @@ -151,7 +151,7 @@
   
   
   
  -apr_status_t apr_shm_avail(struct shmem_t *c, apr_size_t *size)
  +APR_DECLARE(apr_status_t) apr_shm_avail(struct shmem_t *c, apr_size_t *size)
   {
   
       return APR_ENOTIMPL;
  
  
  
  1.23      +9 -9      apr/shmem/unix/shmem.c
  
  Index: shmem.c
  ===================================================================
  RCS file: /home/cvs/apr/shmem/unix/shmem.c,v
  retrieving revision 1.22
  retrieving revision 1.23
  diff -u -r1.22 -r1.23
  --- shmem.c	2001/05/09 16:32:26	1.22
  +++ shmem.c	2001/08/10 21:04:48	1.23
  @@ -61,7 +61,7 @@
       MM *mm;
   };
   
  -apr_status_t apr_shm_init(struct shmem_t **m, apr_size_t reqsize, const char *file, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_shm_init(struct shmem_t **m, apr_size_t reqsize, const char *file, apr_pool_t *cont)
   {
       MM *newmm = mm_create(reqsize + sizeof(**m), file, MM_ALLOCATE_ENOUGH);
       if (newmm == NULL) {
  @@ -78,13 +78,13 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_shm_destroy(struct shmem_t *m)
  +APR_DECLARE(apr_status_t) apr_shm_destroy(struct shmem_t *m)
   {
       mm_destroy(m->mm);
       return APR_SUCCESS;
   }
   
  -void *apr_shm_malloc(struct shmem_t *c, apr_size_t reqsize)
  +APR_DECLARE(void *) apr_shm_malloc(struct shmem_t *c, apr_size_t reqsize)
   {
       if (c->mm == NULL) {
           return NULL;
  @@ -92,7 +92,7 @@
       return mm_malloc(c->mm, reqsize);
   }
   
  -void *apr_shm_calloc(struct shmem_t *shared, apr_size_t size) 
  +APR_DECLARE(void *) apr_shm_calloc(struct shmem_t *shared, apr_size_t size) 
   {
       if (shared == NULL) {
           return NULL;
  @@ -100,13 +100,13 @@
       return mm_calloc(shared->mm, 1, size);
   }
   
  -apr_status_t apr_shm_free(struct shmem_t *shared, void *entity)
  +APR_DECLARE(apr_status_t) apr_shm_free(struct shmem_t *shared, void *entity)
   {
       mm_free(shared->mm, entity);
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_shm_name_get(apr_shmem_t *c, apr_shm_name_t **name)
  +APR_DECLARE(apr_status_t) apr_shm_name_get(apr_shmem_t *c, apr_shm_name_t **name)
   {
   #if APR_USES_ANONYMOUS_SHM
       *name = NULL;
  @@ -121,7 +121,7 @@
   #endif
   }
   
  -apr_status_t apr_shm_name_set(apr_shmem_t *c, apr_shm_name_t *name)
  +APR_DECLARE(apr_status_t) apr_shm_name_set(apr_shmem_t *c, apr_shm_name_t *name)
   {
   #if APR_USES_ANONYMOUS_SHM
       return APR_ANONYMOUS;
  @@ -135,7 +135,7 @@
   #endif
   }
   
  -apr_status_t apr_shm_open(struct shmem_t *c)
  +APR_DECLARE(apr_status_t) apr_shm_open(struct shmem_t *c)
   {
   #if APR_USES_ANONYMOUS_SHM
   
  @@ -153,7 +153,7 @@
   #endif
   }
   
  -apr_status_t apr_shm_avail(struct shmem_t *c, apr_size_t *size)
  +APR_DECLARE(apr_status_t) apr_shm_avail(struct shmem_t *c, apr_size_t *size)
   {
       *size = mm_available(c);
       if (*size == 0) {
  
  
  
  1.38      +24 -24    apr/threadproc/beos/proc.c
  
  Index: proc.c
  ===================================================================
  RCS file: /home/cvs/apr/threadproc/beos/proc.c,v
  retrieving revision 1.37
  retrieving revision 1.38
  diff -u -r1.37 -r1.38
  --- proc.c	2001/02/16 04:16:15	1.37
  +++ proc.c	2001/08/10 21:04:48	1.38
  @@ -61,7 +61,7 @@
   	int err;
   };
   
  -apr_status_t apr_procattr_create(apr_procattr_t **new, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_procattr_create(apr_procattr_t **new, apr_pool_t *cont)
   {
       (*new) = (apr_procattr_t *)apr_palloc(cont, 
                 sizeof(apr_procattr_t));
  @@ -82,8 +82,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_procattr_io_set(apr_procattr_t *attr, apr_int32_t in, 
  -                                 apr_int32_t out, apr_int32_t err)
  +APR_DECLARE(apr_status_t) apr_procattr_io_set(apr_procattr_t *attr, apr_int32_t in, 
  +                                              apr_int32_t out, apr_int32_t err)
   {
       apr_status_t status;
       if (in != 0) {
  @@ -146,8 +146,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_procattr_dir_set(apr_procattr_t *attr, 
  -                                 const char *dir) 
  +APR_DECLARE(apr_status_t) apr_procattr_dir_set(apr_procattr_t *attr, 
  +                                               const char *dir) 
   {
       char * cwd;
       if (strncmp("/",dir,1) != 0 ) {
  @@ -166,20 +166,20 @@
       return APR_ENOMEM;
   }
   
  -apr_status_t apr_procattr_cmdtype_set(apr_procattr_t *attr,
  -                                     apr_cmdtype_e cmd) 
  +APR_DECLARE(apr_status_t) apr_procattr_cmdtype_set(apr_procattr_t *attr,
  +                                                   apr_cmdtype_e cmd) 
   {
       attr->cmdtype = cmd;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_procattr_detach_set(apr_procattr_t *attr, apr_int32_t detach) 
  +APR_DECLARE(apr_status_t) apr_procattr_detach_set(apr_procattr_t *attr, apr_int32_t detach) 
   {
       attr->detached = detach;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_proc_fork(apr_proc_t *proc, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_proc_fork(apr_proc_t *proc, apr_pool_t *cont)
   {
       int pid;
       
  @@ -201,10 +201,10 @@
   }
   
   
  -apr_status_t apr_proc_create(apr_proc_t *new, const char *progname, 
  -                                const char * const *args,
  -                                const char * const *env, 
  -                                apr_procattr_t *attr, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_proc_create(apr_proc_t *new, const char *progname, 
  +                                          const char * const *args,
  +                                          const char * const *env, 
  +                                          apr_procattr_t *attr, apr_pool_t *cont)
   {
       int i=0,nargs=0;
       char **newargs = NULL;
  @@ -279,8 +279,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_proc_wait_all_procs(apr_proc_t *proc, apr_wait_t *status,
  -                              apr_wait_how_e waithow, apr_pool_t *p)
  +APR_DECLARE(apr_status_t) apr_proc_wait_all_procs(apr_proc_t *proc, apr_wait_t *status,
  +                                          apr_wait_how_e waithow, apr_pool_t *p)
   {
       int waitpid_options = WUNTRACED;
   
  @@ -297,8 +297,8 @@
       return errno;
   } 
   
  -apr_status_t apr_proc_wait(apr_proc_t *proc, 
  -                           apr_wait_how_e wait)
  +APR_DECLARE(apr_status_t) apr_proc_wait(apr_proc_t *proc, 
  +                                        apr_wait_how_e wait)
   {
       status_t exitval, rv;
   
  @@ -321,7 +321,7 @@
       return APR_CHILD_NOTDONE;
   } 
   
  -apr_status_t apr_procattr_child_in_set(apr_procattr_t *attr, apr_file_t *child_in,
  +APR_DECLARE(apr_status_t) apr_procattr_child_in_set(apr_procattr_t *attr, apr_file_t *child_in,
                                      apr_file_t *parent_in)
   {
       if (attr->child_in == NULL && attr->parent_in == NULL)
  @@ -336,8 +336,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_procattr_child_out_set(apr_procattr_t *attr, apr_file_t *child_out,
  -                                    apr_file_t *parent_out)
  +APR_DECLARE(apr_status_t) apr_procattr_child_out_set(apr_procattr_t *attr, apr_file_t *child_out,
  +                                                     apr_file_t *parent_out)
   {
       if (attr->child_out == NULL && attr->parent_out == NULL)
           apr_file_pipe_create(&attr->child_out, &attr->parent_out, attr->cntxt);
  @@ -351,8 +351,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_procattr_child_err_set(apr_procattr_t *attr, apr_file_t *child_err,
  -                                   apr_file_t *parent_err)
  +APR_DECLARE(apr_status_t) apr_procattr_child_err_set(apr_procattr_t *attr, apr_file_t *child_err,
  +                                                     apr_file_t *parent_err)
   {
       if (attr->child_err == NULL && attr->parent_err == NULL)
           apr_file_pipe_create(&attr->child_err, &attr->parent_err, attr->cntxt);
  @@ -366,8 +366,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_procattr_limit_set(apr_procattr_t *attr, apr_int32_t what, 
  -                          void *limit)
  +APR_DECLARE(apr_status_t) apr_procattr_limit_set(apr_procattr_t *attr, apr_int32_t what, 
  +                                                  void *limit)
   {
       return APR_ENOTIMPL;
   }
  
  
  
  1.26      +17 -17    apr/threadproc/beos/thread.c
  
  Index: thread.c
  ===================================================================
  RCS file: /home/cvs/apr/threadproc/beos/thread.c,v
  retrieving revision 1.25
  retrieving revision 1.26
  diff -u -r1.25 -r1.26
  --- thread.c	2001/08/03 00:30:53	1.25
  +++ thread.c	2001/08/10 21:04:48	1.26
  @@ -55,7 +55,7 @@
   #include "threadproc.h"
   #include "apr_portable.h"
   
  -apr_status_t apr_threadattr_create(apr_threadattr_t **new, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_threadattr_create(apr_threadattr_t **new, apr_pool_t *cont)
   {
       (*new) = (apr_threadattr_t *)apr_palloc(cont, 
                 sizeof(apr_threadattr_t));
  @@ -70,7 +70,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_threadattr_detach_set(apr_threadattr_t *attr, apr_int32_t on)
  +APR_DECLARE(apr_status_t) apr_threadattr_detach_set(apr_threadattr_t *attr, apr_int32_t on)
   {
   	if (on == 1){
   		attr->detached = 1;
  @@ -80,7 +80,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_threadattr_detach_get(apr_threadattr_t *attr)
  +APR_DECLARE(apr_status_t) apr_threadattr_detach_get(apr_threadattr_t *attr)
   {
   	if (attr->detached == 1){
   		return APR_DETACH;
  @@ -94,9 +94,9 @@
       return thd->func(thd, thd->data);
   }
   
  -apr_status_t apr_thread_create(apr_thread_t **new, apr_threadattr_t *attr,
  -                               apr_thread_start_t func, void *data,
  -                               apr_pool_t *pool)
  +APR_DECLARE(apr_status_t) apr_thread_create(apr_thread_t **new, apr_threadattr_t *attr,
  +                                            apr_thread_start_t func, void *data,
  +                                            apr_pool_t *pool)
   {
       int32 temp;
       apr_status_t stat;
  @@ -131,7 +131,7 @@
       } 
   }
   
  -apr_os_thread_t apr_os_thread_current(void)
  +APR_DECLARE(apr_os_thread_t) apr_os_thread_current(void)
   {
       return find_thread(NULL);
   }
  @@ -141,14 +141,14 @@
       return tid1 == tid2;
   }
   
  -apr_status_t apr_thread_exit(apr_thread_t *thd, apr_status_t *retval)
  +APR_DECLARE(apr_status_t) apr_thread_exit(apr_thread_t *thd, apr_status_t *retval)
   {
       apr_pool_destroy(thd->cntxt);
   	exit_thread ((status_t)retval);
   	return APR_SUCCESS;
   }
   
  -apr_status_t apr_thread_join(apr_status_t *retval, apr_thread_t *thd)
  +APR_DECLARE(apr_status_t) apr_thread_join(apr_status_t *retval, apr_thread_t *thd)
   {
       if (wait_for_thread(thd->td,(void *)&retval) == B_NO_ERROR) {
           return APR_SUCCESS;
  @@ -158,7 +158,7 @@
       }
   }
   
  -apr_status_t apr_thread_detach(apr_thread_t *thd)
  +APR_DECLARE(apr_status_t) apr_thread_detach(apr_thread_t *thd)
   {
   	if (suspend_thread(thd->td) == B_NO_ERROR){
           return APR_SUCCESS;
  @@ -172,26 +172,26 @@
   {
   }
   
  -apr_status_t apr_thread_data_get(void **data, const char *key, apr_thread_t *thread)
  +APR_DECLARE(apr_status_t) apr_thread_data_get(void **data, const char *key, apr_thread_t *thread)
   {
       return apr_pool_userdata_get(data, key, thread->cntxt);
   }
   
  -apr_status_t apr_thread_data_set(void *data, const char *key,
  -                              apr_status_t (*cleanup) (void *),
  -                              apr_thread_t *thread)
  +APR_DECLARE(apr_status_t) apr_thread_data_set(void *data, const char *key,
  +                                              apr_status_t (*cleanup) (void *),
  +                                              apr_thread_t *thread)
   {
       return apr_pool_userdata_set(data, key, cleanup, thread->cntxt);
   }
   
  -apr_status_t apr_os_thread_get(apr_os_thread_t **thethd, apr_thread_t *thd)
  +APR_DECLARE(apr_status_t) apr_os_thread_get(apr_os_thread_t **thethd, apr_thread_t *thd)
   {
       *thethd = &thd->td;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_thread_put(apr_thread_t **thd, apr_os_thread_t *thethd, 
  -                             apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_thread_put(apr_thread_t **thd, apr_os_thread_t *thethd, 
  +                                            apr_pool_t *cont)
   {
       if (cont == NULL) {
           return APR_ENOPOOL;
  
  
  
  1.17      +14 -14    apr/threadproc/beos/threadpriv.c
  
  Index: threadpriv.c
  ===================================================================
  RCS file: /home/cvs/apr/threadproc/beos/threadpriv.c,v
  retrieving revision 1.16
  retrieving revision 1.17
  diff -u -r1.16 -r1.17
  --- threadpriv.c	2001/02/16 04:16:16	1.16
  +++ threadpriv.c	2001/08/10 21:04:48	1.17
  @@ -58,8 +58,8 @@
   static struct beos_private_data *beos_data[BEOS_MAX_DATAKEYS];
   static sem_id lock;
   
  -apr_status_t apr_threadkey_private_create(apr_threadkey_t **key,
  -                                void (*dest)(void *), apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_create(apr_threadkey_t **key,
  +                                       void (*dest)(void *), apr_pool_t *cont)
   {
       (*key) = (apr_threadkey_t *)apr_palloc(cont, sizeof(apr_threadkey_t));
       if ((*key) == NULL) {
  @@ -82,7 +82,7 @@
       return APR_ENOMEM;
   }
   
  -apr_status_t apr_threadkey_private_get(void **new, apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_get(void **new, apr_threadkey_t *key)
   {
   	thread_id tid;
   	int i, index=0;
  @@ -114,7 +114,7 @@
   	return APR_SUCCESS;
   }
   
  -apr_status_t apr_threadkey_private_set(void *priv, apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_set(void *priv, apr_threadkey_t *key)
   {
   	thread_id tid;
   	int i,index = 0, ret;
  @@ -169,7 +169,7 @@
   	return APR_ENOMEM;
   }
   
  -apr_status_t apr_threadkey_private_delete(apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_delete(apr_threadkey_t *key)
   {
   	if (key->key < BEOS_MAX_DATAKEYS){
   		acquire_sem(key_table[key->key].lock);
  @@ -184,27 +184,27 @@
   	return APR_SUCCESS;
   }
   
  -apr_status_t apr_threadkey_data_get(void **data, const char *key,
  -                                 apr_threadkey_t *threadkey)
  +APR_DECLARE(apr_status_t) apr_threadkey_data_get(void **data, const char *key,
  +                                                 apr_threadkey_t *threadkey)
   {
       return apr_pool_userdata_get(data, key, threadkey->cntxt);
   }
   
  -apr_status_t apr_threadkey_data_set(void *data, const char *key,
  -                                 apr_status_t (*cleanup) (void *),
  -                                 apr_threadkey_t *threadkey)
  +APR_DECLARE(apr_status_t) apr_threadkey_data_set(void *data, const char *key,
  +                                                 apr_status_t (*cleanup) (void *),
  +                                                 apr_threadkey_t *threadkey)
   {
       return apr_pool_userdata_set(data, key, cleanup, threadkey->cntxt);
   }
   
  -apr_status_t apr_os_threadkey_get(apr_os_threadkey_t *thekey, apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_os_threadkey_get(apr_os_threadkey_t *thekey, apr_threadkey_t *key)
   {
       *thekey = key->key;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_threadkey_put(apr_threadkey_t **key, 
  -                                apr_os_threadkey_t *thekey, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_threadkey_put(apr_threadkey_t **key, 
  +                                               apr_os_threadkey_t *thekey, apr_pool_t *cont)
   {
       if (cont == NULL) {
           return APR_ENOPOOL;
  @@ -215,4 +215,4 @@
       }
       (*key)->key = *thekey;
       return APR_SUCCESS;
  -}           
  +}
  
  
  
  1.42      +24 -24    apr/threadproc/os2/proc.c
  
  Index: proc.c
  ===================================================================
  RCS file: /home/cvs/apr/threadproc/os2/proc.c,v
  retrieving revision 1.41
  retrieving revision 1.42
  diff -u -r1.41 -r1.42
  --- proc.c	2001/03/19 12:35:15	1.41
  +++ proc.c	2001/08/10 21:04:48	1.42
  @@ -72,7 +72,7 @@
   #include <process.h>
   #include <stdlib.h>
   
  -apr_status_t apr_procattr_create(apr_procattr_t **new, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_procattr_create(apr_procattr_t **new, apr_pool_t *cont)
   {
       (*new) = (apr_procattr_t *)apr_palloc(cont, 
                 sizeof(apr_procattr_t));
  @@ -93,8 +93,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_procattr_io_set(apr_procattr_t *attr, apr_int32_t in, 
  -                                 apr_int32_t out, apr_int32_t err)
  +APR_DECLARE(apr_status_t) apr_procattr_io_set(apr_procattr_t *attr, apr_int32_t in, 
  +                                              apr_int32_t out, apr_int32_t err)
   {
       apr_status_t stat;
       if (in) {
  @@ -157,8 +157,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_procattr_child_in_set(apr_procattr_t *attr, apr_file_t *child_in,
  -                                   apr_file_t *parent_in)
  +APR_DECLARE(apr_status_t) apr_procattr_child_in_set(apr_procattr_t *attr, apr_file_t *child_in,
  +                                                    apr_file_t *parent_in)
   {
       if (attr->child_in == NULL && attr->parent_in == NULL)
           apr_file_pipe_create(&attr->child_in, &attr->parent_in, attr->cntxt);
  @@ -173,8 +173,8 @@
   }
   
   
  -apr_status_t apr_procattr_child_out_set(apr_procattr_t *attr, apr_file_t *child_out,
  -                                    apr_file_t *parent_out)
  +APR_DECLARE(apr_status_t) apr_procattr_child_out_set(apr_procattr_t *attr, apr_file_t *child_out,
  +                                                     apr_file_t *parent_out)
   {
       if (attr->child_out == NULL && attr->parent_out == NULL)
           apr_file_pipe_create(&attr->child_out, &attr->parent_out, attr->cntxt);
  @@ -189,8 +189,8 @@
   }
   
   
  -apr_status_t apr_procattr_child_err_set(apr_procattr_t *attr, apr_file_t *child_err,
  -                                   apr_file_t *parent_err)
  +APR_DECLARE(apr_status_t) apr_procattr_child_err_set(apr_procattr_t *attr, apr_file_t *child_err,
  +                                                     apr_file_t *parent_err)
   {
       if (attr->child_err == NULL && attr->parent_err == NULL)
           apr_file_pipe_create(&attr->child_err, &attr->parent_err, attr->cntxt);
  @@ -205,7 +205,7 @@
   }
   
   
  -apr_status_t apr_procattr_dir_set(apr_procattr_t *attr, const char *dir)
  +APR_DECLARE(apr_status_t) apr_procattr_dir_set(apr_procattr_t *attr, const char *dir)
   {
       attr->currdir = apr_pstrdup(attr->cntxt, dir);
       if (attr->currdir) {
  @@ -214,20 +214,20 @@
       return APR_ENOMEM;
   }
   
  -apr_status_t apr_procattr_cmdtype_set(apr_procattr_t *attr,
  -                                     apr_cmdtype_e cmd) 
  +APR_DECLARE(apr_status_t) apr_procattr_cmdtype_set(apr_procattr_t *attr,
  +                                                   apr_cmdtype_e cmd) 
   {
       attr->cmdtype = cmd;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_procattr_detach_set(apr_procattr_t *attr, apr_int32_t detach) 
  +APR_DECLARE(apr_status_t) apr_procattr_detach_set(apr_procattr_t *attr, apr_int32_t detach) 
   {
       attr->detached = detach;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_proc_fork(apr_proc_t *proc, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_proc_fork(apr_proc_t *proc, apr_pool_t *cont)
   {
       int pid;
       
  @@ -278,10 +278,10 @@
   
   
   
  -apr_status_t apr_proc_create(apr_proc_t *proc, const char *progname,
  -                                const char * const *args,
  -                                const char * const *env,
  -                                apr_procattr_t *attr, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_proc_create(apr_proc_t *proc, const char *progname,
  +                                          const char * const *args,
  +                                          const char * const *env,
  +                                          apr_procattr_t *attr, apr_pool_t *cont)
   {
       int i, arg, numargs, cmdlen;
       apr_status_t status;
  @@ -495,8 +495,8 @@
   
   
   
  -apr_status_t apr_proc_wait_all_procs(apr_proc_t *proc, apr_wait_t *status,
  -                              apr_wait_how_e waithow, apr_pool_t *p)
  +APR_DECLARE(apr_status_t) apr_proc_wait_all_procs(apr_proc_t *proc, apr_wait_t *status,
  +                                                  apr_wait_how_e waithow, apr_pool_t *p)
   {
       RESULTCODES codes;
       ULONG rc;
  @@ -523,8 +523,8 @@
   
   
   
  -apr_status_t apr_proc_wait(apr_proc_t *proc,
  -                           apr_wait_how_e wait)
  +APR_DECLARE(apr_status_t) apr_proc_wait(apr_proc_t *proc,
  +                                        apr_wait_how_e wait)
   {
       RESULTCODES codes;
       ULONG rc;
  @@ -546,7 +546,7 @@
   
   
   
  -apr_status_t apr_get_os_proc(apr_os_proc_t *theproc, apr_proc_t *proc)
  +APR_DECLARE(apr_status_t) apr_get_os_proc(apr_os_proc_t *theproc, apr_proc_t *proc)
   {
       if (proc == NULL) {
           return APR_ENOPROC;
  @@ -557,7 +557,7 @@
   
   
   
  -apr_status_t apr_proc_detach()
  +APR_DECLARE(apr_status_t) apr_proc_detach()
   {
       return APR_ENOTIMPL;
   }
  
  
  
  1.25      +17 -17    apr/threadproc/os2/thread.c
  
  Index: thread.c
  ===================================================================
  RCS file: /home/cvs/apr/threadproc/os2/thread.c,v
  retrieving revision 1.24
  retrieving revision 1.25
  diff -u -r1.24 -r1.25
  --- thread.c	2001/08/03 00:31:22	1.24
  +++ thread.c	2001/08/10 21:04:48	1.25
  @@ -62,7 +62,7 @@
   #include "fileio.h"
   #include <stdlib.h>
   
  -apr_status_t apr_threadattr_create(apr_threadattr_t **new, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_threadattr_create(apr_threadattr_t **new, apr_pool_t *cont)
   {
       (*new) = (apr_threadattr_t *)apr_palloc(cont, sizeof(apr_threadattr_t));
   
  @@ -77,7 +77,7 @@
   
   
   
  -apr_status_t apr_threadattr_detach_set(apr_threadattr_t *attr, apr_int32_t on)
  +APR_DECLARE(apr_status_t) apr_threadattr_detach_set(apr_threadattr_t *attr, apr_int32_t on)
   {
       attr->attr |= APR_THREADATTR_DETACHED;
       return APR_SUCCESS;
  @@ -85,7 +85,7 @@
   
   
   
  -apr_status_t apr_threadattr_detach_get(apr_threadattr_t *attr)
  +APR_DECLARE(apr_status_t) apr_threadattr_detach_get(apr_threadattr_t *attr)
   {
       return (attr->attr & APR_THREADATTR_DETACHED) ? APR_DETACH : APR_NOTDETACH;
   }
  @@ -100,9 +100,9 @@
   
   
   
  -apr_status_t apr_thread_create(apr_thread_t **new, apr_threadattr_t *attr, 
  -                             apr_thread_start_t func, void *data, 
  -                             apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_thread_create(apr_thread_t **new, apr_threadattr_t *attr, 
  +                                            apr_thread_start_t func, void *data, 
  +                                            apr_pool_t *cont)
   {
       apr_status_t stat;
       apr_thread_t *thread;
  @@ -144,7 +144,7 @@
   
   
   
  -apr_os_thread_t apr_os_thread_current()
  +APR_DECLARE(apr_os_thread_t) apr_os_thread_current()
   {
       PIB *ppib;
       TIB *ptib;
  @@ -154,7 +154,7 @@
   
   
   
  -apr_status_t apr_thread_exit(apr_thread_t *thd, apr_status_t *retval)
  +APR_DECLARE(apr_status_t) apr_thread_exit(apr_thread_t *thd, apr_status_t *retval)
   {
       thd->rv = retval;
       _endthread();
  @@ -163,7 +163,7 @@
   
   
   
  -apr_status_t apr_thread_join(apr_status_t *retval, apr_thread_t *thd)
  +APR_DECLARE(apr_status_t) apr_thread_join(apr_status_t *retval, apr_thread_t *thd)
   {
       ULONG rc;
       TID waittid = thd->tid;
  @@ -182,7 +182,7 @@
   
   
   
  -apr_status_t apr_thread_detach(apr_thread_t *thd)
  +APR_DECLARE(apr_status_t) apr_thread_detach(apr_thread_t *thd)
   {
       thd->attr->attr |= APR_THREADATTR_DETACHED;
       return APR_SUCCESS;
  @@ -196,7 +196,7 @@
   
   
   
  -apr_status_t apr_os_thread_get(apr_os_thread_t **thethd, apr_thread_t *thd)
  +APR_DECLARE(apr_status_t) apr_os_thread_get(apr_os_thread_t **thethd, apr_thread_t *thd)
   {
       *thethd = &thd->tid;
       return APR_SUCCESS;
  @@ -204,8 +204,8 @@
   
   
   
  -apr_status_t apr_os_thread_put(apr_thread_t **thd, apr_os_thread_t *thethd, 
  -                             apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_thread_put(apr_thread_t **thd, apr_os_thread_t *thethd, 
  +                                            apr_pool_t *cont)
   {
       if ((*thd) == NULL) {
           (*thd) = (apr_thread_t *)apr_pcalloc(cont, sizeof(apr_thread_t));
  @@ -224,16 +224,16 @@
   
   
   
  -apr_status_t apr_thread_data_get(void **data, const char *key, apr_thread_t *thread)
  +APR_DECLARE(apr_status_t) apr_thread_data_get(void **data, const char *key, apr_thread_t *thread)
   {
       return apr_pool_userdata_get(data, key, thread->cntxt);
   }
   
   
   
  -apr_status_t apr_thread_data_set(void *data, const char *key,
  -                              apr_status_t (*cleanup) (void *),
  -                              apr_thread_t *thread)
  +APR_DECLARE(apr_status_t) apr_thread_data_set(void *data, const char *key,
  +                                              apr_status_t (*cleanup) (void *),
  +                                              apr_thread_t *thread)
   {
       return apr_pool_userdata_set(data, key, cleanup, thread->cntxt);
   }
  
  
  
  1.16      +15 -13    apr/threadproc/os2/threadpriv.c
  
  Index: threadpriv.c
  ===================================================================
  RCS file: /home/cvs/apr/threadproc/os2/threadpriv.c,v
  retrieving revision 1.15
  retrieving revision 1.16
  diff -u -r1.15 -r1.16
  --- threadpriv.c	2001/03/19 12:35:16	1.15
  +++ threadpriv.c	2001/08/10 21:04:48	1.16
  @@ -60,8 +60,9 @@
   #include "apr_lib.h"
   #include "fileio.h"
   
  -apr_status_t apr_threadkey_private_create(apr_threadkey_t **key,
  -                                     void (*dest)(void *), apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_create(apr_threadkey_t **key,
  +                                                       void (*dest)(void *), 
  +                                                       apr_pool_t *cont)
   {
       (*key) = (apr_threadkey_t *)apr_palloc(cont, sizeof(apr_threadkey_t));
   
  @@ -73,44 +74,45 @@
       return APR_OS2_STATUS(DosAllocThreadLocalMemory(1, &((*key)->key)));
   }
   
  -apr_status_t apr_threadkey_private_get(void **new, apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_get(void **new, apr_threadkey_t *key)
   {
       (*new) = (void *)*(key->key);
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_threadkey_private_set(void *priv, apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_set(void *priv, apr_threadkey_t *key)
   {
       *(key->key) = (ULONG)priv;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_threadkey_private_delete(apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_delete(apr_threadkey_t *key)
   {
       return APR_OS2_STATUS(DosFreeThreadLocalMemory(key->key));
   }
   
  -apr_status_t apr_threadkey_data_get(void **data, const char *key,
  -                                 apr_threadkey_t *threadkey)
  +APR_DECLARE(apr_status_t) apr_threadkey_data_get(void **data, const char *key,
  +                                                 apr_threadkey_t *threadkey)
   {
       return apr_pool_userdata_get(data, key, threadkey->cntxt);
   }
   
  -apr_status_t apr_threadkey_data_set(void *data, const char *key,
  -                                 apr_status_t (*cleanup) (void *),
  -                                 apr_threadkey_t *threadkey)
  +APR_DECLARE(apr_status_t) apr_threadkey_data_set(void *data, const char *key,
  +                                                 apr_status_t (*cleanup) (void *),
  +                                                 apr_threadkey_t *threadkey)
   {
       return apr_pool_userdata_set(data, key, cleanup, threadkey->cntxt);
   }
   
  -apr_status_t apr_os_threadkey_get(apr_os_threadkey_t *thekey, apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_os_threadkey_get(apr_os_threadkey_t *thekey, apr_threadkey_t *key)
   {
       *thekey = key->key;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_threadkey_put(apr_threadkey_t **key, 
  -                                apr_os_threadkey_t *thekey, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_threadkey_put(apr_threadkey_t **key, 
  +                                               apr_os_threadkey_t *thekey, 
  +                                               apr_pool_t *cont)
   {
       if (cont == NULL) {
           return APR_ENOPOOL;
  
  
  
  1.47      +27 -26    apr/threadproc/unix/proc.c
  
  Index: proc.c
  ===================================================================
  RCS file: /home/cvs/apr/threadproc/unix/proc.c,v
  retrieving revision 1.46
  retrieving revision 1.47
  diff -u -r1.46 -r1.47
  --- proc.c	2001/04/03 22:53:04	1.46
  +++ proc.c	2001/08/10 21:04:48	1.47
  @@ -57,7 +57,7 @@
   #include "apr_portable.h"
   #include "apr_signal.h"
   
  -apr_status_t apr_procattr_create(apr_procattr_t **new, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_procattr_create(apr_procattr_t **new, apr_pool_t *cont)
   {
       (*new) = (apr_procattr_t *)apr_pcalloc(cont, sizeof(apr_procattr_t));
   
  @@ -69,8 +69,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_procattr_io_set(apr_procattr_t *attr, apr_int32_t in, 
  -                                 apr_int32_t out, apr_int32_t err)
  +APR_DECLARE(apr_status_t) apr_procattr_io_set(apr_procattr_t *attr, apr_int32_t in, 
  +                                              apr_int32_t out, apr_int32_t err)
   {
       apr_status_t status;
       if (in != 0) {
  @@ -134,8 +134,8 @@
   }
   
   
  -apr_status_t apr_procattr_child_in_set(apr_procattr_t *attr, apr_file_t *child_in,
  -                                   apr_file_t *parent_in)
  +APR_DECLARE(apr_status_t) apr_procattr_child_in_set(apr_procattr_t *attr, apr_file_t *child_in,
  +                                                    apr_file_t *parent_in)
   {
       if (attr->child_in == NULL && attr->parent_in == NULL)
           apr_file_pipe_create(&attr->child_in, &attr->parent_in, attr->cntxt);
  @@ -150,8 +150,8 @@
   }
   
   
  -apr_status_t apr_procattr_child_out_set(apr_procattr_t *attr, apr_file_t *child_out,
  -                                    apr_file_t *parent_out)
  +APR_DECLARE(apr_status_t) apr_procattr_child_out_set(apr_procattr_t *attr, apr_file_t *child_out,
  +                                                     apr_file_t *parent_out)
   {
       if (attr->child_out == NULL && attr->parent_out == NULL)
           apr_file_pipe_create(&attr->child_out, &attr->parent_out, attr->cntxt);
  @@ -166,8 +166,8 @@
   }
   
   
  -apr_status_t apr_procattr_child_err_set(apr_procattr_t *attr, apr_file_t *child_err,
  -                                   apr_file_t *parent_err)
  +APR_DECLARE(apr_status_t) apr_procattr_child_err_set(apr_procattr_t *attr, apr_file_t *child_err,
  +                                                     apr_file_t *parent_err)
   {
       if (attr->child_err == NULL && attr->parent_err == NULL)
           apr_file_pipe_create(&attr->child_err, &attr->parent_err, attr->cntxt);
  @@ -182,8 +182,8 @@
   }
   
   
  -apr_status_t apr_procattr_dir_set(apr_procattr_t *attr, 
  -                               const char *dir) 
  +APR_DECLARE(apr_status_t) apr_procattr_dir_set(apr_procattr_t *attr, 
  +                                               const char *dir) 
   {
       attr->currdir = apr_pstrdup(attr->cntxt, dir);
       if (attr->currdir) {
  @@ -192,20 +192,21 @@
       return APR_ENOMEM;
   }
   
  -apr_status_t apr_procattr_cmdtype_set(apr_procattr_t *attr,
  -                                     apr_cmdtype_e cmd) 
  +APR_DECLARE(apr_status_t) apr_procattr_cmdtype_set(apr_procattr_t *attr,
  +                                                   apr_cmdtype_e cmd) 
   {
       attr->cmdtype = cmd;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_procattr_detach_set(apr_procattr_t *attr, apr_int32_t detach) 
  +APR_DECLARE(apr_status_t) apr_procattr_detach_set(apr_procattr_t *attr, 
  +                                                  apr_int32_t detach) 
   {
       attr->detached = detach;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_proc_fork(apr_proc_t *proc, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_proc_fork(apr_proc_t *proc, apr_pool_t *cont)
   {
       int pid;
       
  @@ -271,10 +272,10 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_proc_create(apr_proc_t *new, const char *progname, 
  -                                const char * const *args,
  -                                const char * const *env,
  -                                apr_procattr_t *attr, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_proc_create(apr_proc_t *new, const char *progname, 
  +                                          const char * const *args,
  +                                          const char * const *env,
  +                                          apr_procattr_t *attr, apr_pool_t *cont)
   {
       int i;
       const char **newargs;
  @@ -360,8 +361,8 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_proc_wait_all_procs(apr_proc_t *proc, apr_wait_t *status,
  -                              apr_wait_how_e waithow, apr_pool_t *p)
  +APR_DECLARE(apr_status_t) apr_proc_wait_all_procs(apr_proc_t *proc, apr_wait_t *status,
  +                                                  apr_wait_how_e waithow, apr_pool_t *p)
   {
       int waitpid_options = WUNTRACED;
   
  @@ -378,8 +379,8 @@
       return errno;
   } 
   
  -apr_status_t apr_proc_wait(apr_proc_t *proc, 
  -                           apr_wait_how_e waithow)
  +APR_DECLARE(apr_status_t) apr_proc_wait(apr_proc_t *proc, 
  +                                        apr_wait_how_e waithow)
   {
       pid_t status;
   
  @@ -401,8 +402,8 @@
       return errno;
   } 
   
  -apr_status_t apr_procattr_limit_set(apr_procattr_t *attr, apr_int32_t what, 
  -                          struct rlimit *limit)
  +APR_DECLARE(apr_status_t) apr_procattr_limit_set(apr_procattr_t *attr, apr_int32_t what, 
  +                                                 struct rlimit *limit)
   {
       switch(what) {
           case APR_LIMIT_CPU:
  @@ -428,4 +429,4 @@
   #endif
       }
       return APR_SUCCESS;
  -}  
  +}
  
  
  
  1.32      +1 -1      apr/threadproc/unix/procsup.c
  
  Index: procsup.c
  ===================================================================
  RCS file: /home/cvs/apr/threadproc/unix/procsup.c,v
  retrieving revision 1.31
  retrieving revision 1.32
  diff -u -r1.31 -r1.32
  --- procsup.c	2001/07/24 10:04:06	1.31
  +++ procsup.c	2001/08/10 21:04:48	1.32
  @@ -54,7 +54,7 @@
   
   #include "threadproc.h"
   
  -apr_status_t apr_proc_detach(void)
  +APR_DECLARE(apr_status_t) apr_proc_detach(void)
   {
       int x;
       pid_t pgrp;
  
  
  
  1.34      +2 -2      apr/threadproc/unix/signals.c
  
  Index: signals.c
  ===================================================================
  RCS file: /home/cvs/apr/threadproc/unix/signals.c,v
  retrieving revision 1.33
  retrieving revision 1.34
  diff -u -r1.33 -r1.34
  --- signals.c	2001/04/12 18:46:32	1.33
  +++ signals.c	2001/08/10 21:04:48	1.34
  @@ -67,7 +67,7 @@
   #include <pthread.h>
   #endif
   
  -apr_status_t apr_proc_kill(apr_proc_t *proc, int signum)
  +APR_DECLARE(apr_status_t) apr_proc_kill(apr_proc_t *proc, int signum)
   {
   #ifdef OS2
       /* SIGTERM's don't work too well in OS/2 (only affects other EMX
  @@ -95,7 +95,7 @@
    * from W. Richard Stevens' "Advanced Programming in the UNIX Environment"
    * (the version that does not automatically restart system calls).
    */
  -apr_sigfunc_t *apr_signal(int signo, apr_sigfunc_t * func)
  +APR_DECLARE(apr_sigfunc_t *) apr_signal(int signo, apr_sigfunc_t * func)
   {
       struct sigaction act, oact;
   
  
  
  
  1.45      +17 -17    apr/threadproc/unix/thread.c
  
  Index: thread.c
  ===================================================================
  RCS file: /home/cvs/apr/threadproc/unix/thread.c,v
  retrieving revision 1.44
  retrieving revision 1.45
  diff -u -r1.44 -r1.45
  --- thread.c	2001/08/03 00:31:32	1.44
  +++ thread.c	2001/08/10 21:04:48	1.45
  @@ -59,7 +59,7 @@
   #if APR_HAS_THREADS
   
   #if APR_HAVE_PTHREAD_H
  -apr_status_t apr_threadattr_create(apr_threadattr_t **new, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_threadattr_create(apr_threadattr_t **new, apr_pool_t *cont)
   {
       apr_status_t stat;
     
  @@ -82,7 +82,7 @@
       return stat;
   }
   
  -apr_status_t apr_threadattr_detach_set(apr_threadattr_t *attr, apr_int32_t on)
  +APR_DECLARE(apr_status_t) apr_threadattr_detach_set(apr_threadattr_t *attr, apr_int32_t on)
   {
       apr_status_t stat;
   #ifdef PTHREAD_ATTR_SETDETACHSTATE_ARG2_ADDR
  @@ -102,7 +102,7 @@
       }
   }
   
  -apr_status_t apr_threadattr_detach_get(apr_threadattr_t *attr)
  +APR_DECLARE(apr_status_t) apr_threadattr_detach_get(apr_threadattr_t *attr)
   {
       int state;
   
  @@ -122,9 +122,9 @@
       return thread->func(thread, thread->data);
   }
   
  -apr_status_t apr_thread_create(apr_thread_t **new, apr_threadattr_t *attr, 
  -                             apr_thread_start_t func, void *data, 
  -                             apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_thread_create(apr_thread_t **new, apr_threadattr_t *attr, 
  +                                            apr_thread_start_t func, void *data, 
  +                                            apr_pool_t *cont)
   {
       apr_status_t stat;
       pthread_attr_t *temp;
  @@ -166,24 +166,24 @@
       } 
   }
   
  -apr_os_thread_t apr_os_thread_current(void)
  +APR_DECLARE(apr_os_thread_t) apr_os_thread_current(void)
   {
       return pthread_self();
   }
   
  -int apr_os_thread_equal(apr_os_thread_t tid1, apr_os_thread_t tid2)
  +APR_DECLARE(int) apr_os_thread_equal(apr_os_thread_t tid1, apr_os_thread_t tid2)
   {
       return pthread_equal(tid1, tid2);
   }
   
  -apr_status_t apr_thread_exit(apr_thread_t *thd, apr_status_t *retval)
  +APR_DECLARE(apr_status_t) apr_thread_exit(apr_thread_t *thd, apr_status_t *retval)
   {
       apr_pool_destroy(thd->cntxt);
       pthread_exit(retval);
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_thread_join(apr_status_t *retval, apr_thread_t *thd)
  +APR_DECLARE(apr_status_t) apr_thread_join(apr_status_t *retval, apr_thread_t *thd)
   {
       apr_status_t stat;
       apr_status_t *thread_stat;
  @@ -200,7 +200,7 @@
       }
   }
   
  -apr_status_t apr_thread_detach(apr_thread_t *thd)
  +APR_DECLARE(apr_status_t) apr_thread_detach(apr_thread_t *thd)
   {
       apr_status_t stat;
   
  @@ -223,25 +223,25 @@
   {
   }
   
  -apr_status_t apr_thread_data_get(void **data, const char *key, apr_thread_t *thread)
  +APR_DECLARE(apr_status_t) apr_thread_data_get(void **data, const char *key, apr_thread_t *thread)
   {
       return apr_pool_userdata_get(data, key, thread->cntxt);
   }
   
  -apr_status_t apr_thread_data_set(void *data, const char *key,
  +APR_DECLARE(apr_status_t) apr_thread_data_set(void *data, const char *key,
                                 apr_status_t (*cleanup) (void *),
                                 apr_thread_t *thread)
   {
       return apr_pool_userdata_set(data, key, cleanup, thread->cntxt);
   }
   
  -apr_status_t apr_os_thread_get(apr_os_thread_t **thethd, apr_thread_t *thd)
  +APR_DECLARE(apr_status_t) apr_os_thread_get(apr_os_thread_t **thethd, apr_thread_t *thd)
   {
       *thethd = thd->td;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_thread_put(apr_thread_t **thd, apr_os_thread_t *thethd, 
  +APR_DECLARE(apr_status_t) apr_os_thread_put(apr_thread_t **thd, apr_os_thread_t *thethd, 
                                apr_pool_t *cont)
   {
       if (cont == NULL) {
  @@ -262,9 +262,9 @@
   
   #if !APR_HAS_THREADS
   
  -apr_status_t apr_os_thread_get(void); /* avoid warning for no prototype */
  +APR_DECLARE(apr_status_t) apr_os_thread_get(void); /* avoid warning for no prototype */
   
  -apr_status_t apr_os_thread_get(void) 
  +APR_DECLARE(apr_status_t) apr_os_thread_get(void) 
   {
       return APR_ENOTIMPL;
   }
  
  
  
  1.33      +14 -14    apr/threadproc/unix/threadpriv.c
  
  Index: threadpriv.c
  ===================================================================
  RCS file: /home/cvs/apr/threadproc/unix/threadpriv.c,v
  retrieving revision 1.32
  retrieving revision 1.33
  diff -u -r1.32 -r1.33
  --- threadpriv.c	2001/02/19 20:55:36	1.32
  +++ threadpriv.c	2001/08/10 21:04:48	1.33
  @@ -59,8 +59,8 @@
   #if APR_HAS_THREADS
   
   #if APR_HAVE_PTHREAD_H
  -apr_status_t apr_threadkey_private_create(apr_threadkey_t **key, 
  -                                     void (*dest)(void *), apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_create(apr_threadkey_t **key, 
  +                                                void (*dest)(void *), apr_pool_t *cont)
   {
       (*key) = (apr_threadkey_t *)apr_pcalloc(cont, sizeof(apr_threadkey_t));
   
  @@ -74,7 +74,7 @@
   
   }
   
  -apr_status_t apr_threadkey_private_get(void **new, apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_get(void **new, apr_threadkey_t *key)
   {
   #ifdef PTHREAD_GETSPECIFIC_TAKES_TWO_ARGS
       if (pthread_getspecific(key->key,new))
  @@ -85,7 +85,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_threadkey_private_set(void *priv, apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_set(void *priv, apr_threadkey_t *key)
   {
       apr_status_t stat;
       if ((stat = pthread_setspecific(key->key, priv)) == 0) {
  @@ -97,7 +97,7 @@
   }
   
   #ifdef HAVE_PTHREAD_KEY_DELETE
  -apr_status_t apr_threadkey_private_delete(apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_threadkey_private_delete(apr_threadkey_t *key)
   {
       apr_status_t stat;
       if ((stat = pthread_key_delete(key->key)) == 0) {
  @@ -107,27 +107,27 @@
   }
   #endif
   
  -apr_status_t apr_threadkey_data_get(void **data, const char *key,
  +APR_DECLARE(apr_status_t) apr_threadkey_data_get(void **data, const char *key,
                                    apr_threadkey_t *threadkey)
   {
       return apr_pool_userdata_get(data, key, threadkey->cntxt);
   }
   
  -apr_status_t apr_threadkey_data_set(void *data, const char *key,
  -                                 apr_status_t (*cleanup) (void *),
  -                                 apr_threadkey_t *threadkey)
  +APR_DECLARE(apr_status_t) apr_threadkey_data_set(void *data, const char *key,
  +                                         apr_status_t (*cleanup) (void *),
  +                                         apr_threadkey_t *threadkey)
   {
       return apr_pool_userdata_set(data, key, cleanup, threadkey->cntxt);
   }
   
  -apr_status_t apr_os_threadkey_get(apr_os_threadkey_t *thekey, apr_threadkey_t *key)
  +APR_DECLARE(apr_status_t) apr_os_threadkey_get(apr_os_threadkey_t *thekey, apr_threadkey_t *key)
   {
       *thekey = key->key;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_threadkey_put(apr_threadkey_t **key, 
  -                                apr_os_threadkey_t *thekey, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_threadkey_put(apr_threadkey_t **key, 
  +                                     apr_os_threadkey_t *thekey, apr_pool_t *cont)
   {
       if (cont == NULL) {
           return APR_ENOPOOL;
  @@ -143,9 +143,9 @@
   #endif /* APR_HAS_THREADS */
   
   #if !APR_HAS_THREADS
  -apr_status_t apr_os_threadkey_get(void); /* avoid warning for no prototype */
  +APR_DECLARE(apr_status_t) apr_os_threadkey_get(void); /* avoid warning for no prototype */
   
  -apr_status_t apr_os_threadkey_get(void)
  +APR_DECLARE(apr_status_t) apr_os_threadkey_get(void)
   {
       return APR_ENOTIMPL;
   }
  
  
  
  1.51      +19 -17    apr/time/unix/time.c
  
  Index: time.c
  ===================================================================
  RCS file: /home/cvs/apr/time/unix/time.c,v
  retrieving revision 1.50
  retrieving revision 1.51
  diff -u -r1.50 -r1.51
  --- time.c	2001/08/02 20:22:48	1.50
  +++ time.c	2001/08/10 21:04:49	1.51
  @@ -103,14 +103,15 @@
   #endif
   }
   
  -apr_status_t apr_ansi_time_to_apr_time(apr_time_t *result, time_t input)
  +APR_DECLARE(apr_status_t) apr_ansi_time_to_apr_time(apr_time_t *result, 
  +                                                    time_t input)
   {
       *result = (apr_time_t)input * APR_USEC_PER_SEC;
       return APR_SUCCESS;
   }
   
   /* NB NB NB NB This returns GMT!!!!!!!!!! */
  -apr_time_t apr_time_now(void)
  +APR_DECLARE(apr_time_t) apr_time_now(void)
   {
   #ifdef NETWARE
       uint64_t usec;
  @@ -155,7 +156,7 @@
       xt->tm_gmtoff = get_offset(&tm);
   }
   
  -apr_status_t apr_explode_time(apr_exploded_time_t *result, apr_time_t input,
  +APR_DECLARE(apr_status_t) apr_explode_time(apr_exploded_time_t *result, apr_time_t input,
                                 apr_int32_t offs)
   {
       explode_time(result, input, offs, 0);
  @@ -163,12 +164,12 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_explode_gmt(apr_exploded_time_t *result, apr_time_t input)
  +APR_DECLARE(apr_status_t) apr_explode_gmt(apr_exploded_time_t *result, apr_time_t input)
   {
       return apr_explode_time(result, input, 0);
   }
   
  -apr_status_t apr_explode_localtime(apr_exploded_time_t *result, apr_time_t input)
  +APR_DECLARE(apr_status_t) apr_explode_localtime(apr_exploded_time_t *result, apr_time_t input)
   {
   #if defined(__EMX__)
       /* EMX gcc (OS/2) has a timezone global we can use */
  @@ -179,7 +180,7 @@
   #endif /* __EMX__ */
   }
   
  -apr_status_t apr_implode_time(apr_time_t *t, apr_exploded_time_t *xt)
  +APR_DECLARE(apr_status_t) apr_implode_time(apr_time_t *t, apr_exploded_time_t *xt)
   {
       int year;
       time_t days;
  @@ -210,7 +211,7 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_implode_gmt(apr_time_t *t, apr_exploded_time_t *xt)
  +APR_DECLARE(apr_status_t) apr_implode_gmt(apr_time_t *t, apr_exploded_time_t *xt)
   {
       apr_status_t status = apr_implode_time(t, xt);
       if (status == APR_SUCCESS)
  @@ -218,15 +219,16 @@
       return status;
   }
   
  -apr_status_t apr_os_imp_time_get(apr_os_imp_time_t **ostime, apr_time_t *aprtime)
  +APR_DECLARE(apr_status_t) apr_os_imp_time_get(apr_os_imp_time_t **ostime, 
  +                                              apr_time_t *aprtime)
   {
       (*ostime)->tv_usec = *aprtime % APR_USEC_PER_SEC;
       (*ostime)->tv_sec = *aprtime / APR_USEC_PER_SEC;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_exp_time_get(apr_os_exp_time_t **ostime, 
  -                                 apr_exploded_time_t *aprtime)
  +APR_DECLARE(apr_status_t) apr_os_exp_time_get(apr_os_exp_time_t **ostime, 
  +                                              apr_exploded_time_t *aprtime)
   {
       (*ostime)->tm_sec  = aprtime->tm_sec;
       (*ostime)->tm_min  = aprtime->tm_min;
  @@ -245,15 +247,15 @@
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_imp_time_put(apr_time_t *aprtime, apr_os_imp_time_t **ostime,
  -                               apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_imp_time_put(apr_time_t *aprtime, apr_os_imp_time_t **ostime,
  +                                              apr_pool_t *cont)
   {
       *aprtime = (*ostime)->tv_sec * APR_USEC_PER_SEC + (*ostime)->tv_usec;
       return APR_SUCCESS;
   }
   
  -apr_status_t apr_os_exp_time_put(apr_exploded_time_t *aprtime,
  -                                 apr_os_exp_time_t **ostime, apr_pool_t *cont)
  +APR_DECLARE(apr_status_t) apr_os_exp_time_put(apr_exploded_time_t *aprtime,
  +                                              apr_os_exp_time_t **ostime, apr_pool_t *cont)
   {
       aprtime->tm_sec = (*ostime)->tm_sec;
       aprtime->tm_min = (*ostime)->tm_min;
  @@ -272,7 +274,7 @@
       return APR_SUCCESS;
   }
   
  -void apr_sleep(apr_interval_time_t t)
  +APR_DECLARE(void) apr_sleep(apr_interval_time_t t)
   {
   #ifdef OS2
       DosSleep(t/1000);
  @@ -287,8 +289,8 @@
   }
   
   #ifdef OS2
  -apr_status_t apr_os2_time_to_apr_time(apr_time_t *result, FDATE os2date, 
  -                                      FTIME os2time)
  +APR_DECLARE(apr_status_t) apr_os2_time_to_apr_time(apr_time_t *result, FDATE os2date, 
  +                                                   FTIME os2time)
   {
     struct tm tmpdate;
   
  
  
  

Mime
View raw message