Rename all the "cntxt" members of the thread and proc structures to

"pool".


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

3 files changed, 44 insertions, 44 deletions

diff --git a/threadproc/netware/proc.c b/threadproc/netware/proc.c
index 56cd25faf..d10b76f51 100644
--- a/threadproc/netware/proc.c
+++ b/threadproc/netware/proc.c
@@ -67,14 +67,14 @@ apr_status_t apr_netware_proc_cleanup(void *theproc)
     return APR_SUCCESS;
 }
 
-APR_DECLARE(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 *pool)
 {
-    (*new) = (apr_procattr_t *)apr_pcalloc(cont, sizeof(apr_procattr_t));
+    (*new) = (apr_procattr_t *)apr_pcalloc(pool, sizeof(apr_procattr_t));
 
     if ((*new) == NULL) {
         return APR_ENOMEM;
     }
-    (*new)->cntxt = cont;
+    (*new)->pool = pool;
     (*new)->cmdtype = APR_PROGRAM;
     return APR_SUCCESS;
 
@@ -86,7 +86,7 @@ APR_DECLARE(apr_status_t) apr_procattr_io_set(apr_procattr_t *attr, apr_int32_t
     apr_status_t status;
     if (in != 0) {
         if ((status = apr_file_pipe_create(&attr->child_in, &attr->parent_in, 
-                                   attr->cntxt)) != APR_SUCCESS) {
+                                   attr->pool)) != APR_SUCCESS) {
             return status;
         }
         switch (in) {
@@ -105,7 +105,7 @@ APR_DECLARE(apr_status_t) apr_procattr_io_set(apr_procattr_t *attr, apr_int32_t
     } 
     if (out) {
         if ((status = apr_file_pipe_create(&attr->parent_out, &attr->child_out, 
-                                   attr->cntxt)) != APR_SUCCESS) {
+                                   attr->pool)) != APR_SUCCESS) {
             return status;
         }
         switch (out) {
@@ -124,7 +124,7 @@ APR_DECLARE(apr_status_t) apr_procattr_io_set(apr_procattr_t *attr, apr_int32_t
     } 
     if (err) {
         if ((status = apr_file_pipe_create(&attr->parent_err, &attr->child_err, 
-                                   attr->cntxt)) != APR_SUCCESS) {
+                                   attr->pool)) != APR_SUCCESS) {
             return status;
         }
         switch (err) {
@@ -149,13 +149,13 @@ APR_DECLARE(apr_status_t) apr_procattr_child_in_set(apr_procattr_t *attr, apr_fi
                                    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);
+        apr_file_pipe_create(&attr->child_in, &attr->parent_in, attr->pool);
 
     if (child_in != NULL)
-        apr_file_dup2(attr->child_in, child_in, attr->cntxt);
+        apr_file_dup2(attr->child_in, child_in, attr->pool);
 
     if (parent_in != NULL)
-        apr_file_dup2(attr->parent_in, parent_in, attr->cntxt);
+        apr_file_dup2(attr->parent_in, parent_in, attr->pool);
 
     return APR_SUCCESS;
 }
@@ -165,13 +165,13 @@ APR_DECLARE(apr_status_t) apr_procattr_child_out_set(apr_procattr_t *attr, apr_f
                                     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);
+        apr_file_pipe_create(&attr->child_out, &attr->parent_out, attr->pool);
 
     if (child_out != NULL)
-        apr_file_dup2(attr->child_out, child_out, attr->cntxt);
+        apr_file_dup2(attr->child_out, child_out, attr->pool);
 
     if (parent_out != NULL)
-        apr_file_dup2(attr->parent_out, parent_out, attr->cntxt);
+        apr_file_dup2(attr->parent_out, parent_out, attr->pool);
 
     return APR_SUCCESS;
 }
@@ -181,13 +181,13 @@ APR_DECLARE(apr_status_t) apr_procattr_child_err_set(apr_procattr_t *attr, apr_f
                                    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);
+        apr_file_pipe_create(&attr->child_err, &attr->parent_err, attr->pool);
 
     if (child_err != NULL)
-        apr_file_dup2(attr->child_err, child_err, attr->cntxt);
+        apr_file_dup2(attr->child_err, child_err, attr->pool);
 
     if (parent_err != NULL)
-        apr_file_dup2(attr->parent_err, parent_err, attr->cntxt);
+        apr_file_dup2(attr->parent_err, parent_err, attr->pool);
 
     return APR_SUCCESS;
 }
@@ -196,7 +196,7 @@ APR_DECLARE(apr_status_t) apr_procattr_child_err_set(apr_procattr_t *attr, apr_f
 APR_DECLARE(apr_status_t) apr_procattr_dir_set(apr_procattr_t *attr, 
                                const char *dir) 
 {
-    attr->currdir = apr_pstrdup(attr->cntxt, dir);
+    attr->currdir = apr_pstrdup(attr->pool, dir);
     if (attr->currdir) {
         return APR_SUCCESS;
     }
@@ -219,7 +219,7 @@ APR_DECLARE(apr_status_t) apr_procattr_detach_set(apr_procattr_t *attr, apr_int3
 }
 
 #if APR_HAS_FORK
-APR_DECLARE(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 *pool)
 {
     int pid;
     
@@ -291,7 +291,7 @@ APR_DECLARE(apr_status_t) apr_proc_create(apr_proc_t *newproc,
 									const char * const *args, 
 									const char * const *env,
                               		apr_procattr_t *attr, 
-                              		apr_pool_t *cont)
+                              		apr_pool_t *pool)
 {
     int i, envCount=0;
     const char **newargs;
@@ -420,7 +420,7 @@ APR_DECLARE(apr_status_t) apr_proc_create(apr_proc_t *newproc,
     	    attr->parent_err->filedes = pipe_open(attr->parent_err->fname, O_RDONLY);
         }
 
-        apr_pool_cleanup_register(cont, (void *)newproc, apr_netware_proc_cleanup,
+        apr_pool_cleanup_register(pool, (void *)newproc, apr_netware_proc_cleanup,
                          apr_pool_cleanup_null);
     }
     /*if (sysenv)
diff --git a/threadproc/netware/thread.c b/threadproc/netware/thread.c
index a9ad8c9fd..119bba9dc 100644
--- a/threadproc/netware/thread.c
+++ b/threadproc/netware/thread.c
@@ -60,16 +60,16 @@
 static int thread_count = 0;
 
 apr_status_t apr_threadattr_create(apr_threadattr_t **new,
-                                                apr_pool_t *cont)
+                                                apr_pool_t *pool)
 {
-    (*new) = (apr_threadattr_t *)apr_palloc(cont, 
+    (*new) = (apr_threadattr_t *)apr_palloc(pool, 
               sizeof(apr_threadattr_t));
 
     if ((*new) == NULL) {
         return APR_ENOMEM;
     }
 
-    (*new)->cntxt = cont;
+    (*new)->pool = pool;
     (*new)->stack_size = APR_DEFAULT_STACK_SIZE;
     (*new)->detach = 0;
     (*new)->thread_name = NULL;
@@ -99,7 +99,7 @@ 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_pool_t *pool)
 {
     apr_status_t stat;
     long flags = NX_THR_BIND_CONTEXT;
@@ -122,18 +122,18 @@ apr_status_t apr_thread_create(apr_thread_t **new,
         stack_size = attr->stack_size;
     }
     
-    (*new) = (apr_thread_t *)apr_palloc(cont, sizeof(apr_thread_t));
+    (*new) = (apr_thread_t *)apr_palloc(pool, sizeof(apr_thread_t));
 
     if ((*new) == NULL) {
         return APR_ENOMEM;
     }
     
-    (*new)->cntxt = cont;
+    (*new)->pool = pool;
     (*new)->data = data;
     (*new)->func = func;
-    (*new)->thread_name = (char*)apr_pstrdup(cont, threadName);
+    (*new)->thread_name = (char*)apr_pstrdup(pool, threadName);
     
-    stat = apr_pool_create(&(*new)->cntxt, cont);
+    stat = apr_pool_create(&(*new)->pool, pool);
     if (stat != APR_SUCCESS) {
         return stat;
     }
@@ -185,7 +185,7 @@ apr_status_t apr_thread_exit(apr_thread_t *thd,
                              apr_status_t retval)
 {
     thd->exitval = retval;
-    apr_pool_destroy(thd->cntxt);
+    apr_pool_destroy(thd->pool);
     NXThreadExit(NULL);
     return APR_SUCCESS;
 }
@@ -214,7 +214,7 @@ apr_status_t apr_thread_data_get(void **data, const char *key,
                                              apr_thread_t *thread)
 {
     if (thread != NULL) {
-            return apr_pool_userdata_get(data, key, thread->cntxt);
+            return apr_pool_userdata_get(data, key, thread->pool);
     }
     else {
         data = NULL;
@@ -227,7 +227,7 @@ apr_status_t apr_thread_data_set(void *data, const char *key,
                               apr_thread_t *thread)
 {
     if (thread != NULL) {
-       return apr_pool_userdata_set(data, key, cleanup, thread->cntxt);
+       return apr_pool_userdata_set(data, key, cleanup, thread->pool);
     }
     else {
         data = NULL;
@@ -247,14 +247,14 @@ APR_DECLARE(apr_status_t) apr_os_thread_get(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)
+                                            apr_pool_t *pool)
 {
-    if (cont == NULL) {
+    if (pool == NULL) {
         return APR_ENOPOOL;
     }
     if ((*thd) == NULL) {
-        (*thd) = (apr_thread_t *)apr_palloc(cont, sizeof(apr_thread_t));
-        (*thd)->cntxt = cont;
+        (*thd) = (apr_thread_t *)apr_palloc(pool, sizeof(apr_thread_t));
+        (*thd)->pool = pool;
     }
     (*thd)->td = *thethd;
     return APR_SUCCESS;
@@ -272,6 +272,6 @@ APR_DECLARE(apr_status_t) apr_thread_once(apr_thread_once_t *control,
     return APR_ENOTIMPL;
 }
 
-APR_POOL_IMPLEMENT_ACCESSOR_X(thread, cntxt)
+APR_POOL_IMPLEMENT_ACCESSOR(thread)
 
 
diff --git a/threadproc/netware/threadpriv.c b/threadproc/netware/threadpriv.c
index 30b3b47c3..d5ff659ce 100644
--- a/threadproc/netware/threadpriv.c
+++ b/threadproc/netware/threadpriv.c
@@ -56,16 +56,16 @@
 #include "threadproc.h"
 
 apr_status_t apr_threadkey_private_create(apr_threadkey_t **key, 
-                                        void (*dest)(void *), apr_pool_t *cont) 
+                                        void (*dest)(void *), apr_pool_t *pool) 
 {
     apr_status_t stat;
     
-    (*key) = (apr_threadkey_t *)apr_palloc(cont, sizeof(apr_threadkey_t));
+    (*key) = (apr_threadkey_t *)apr_palloc(pool, sizeof(apr_threadkey_t));
 	if ((*key) == NULL) {
         return APR_ENOMEM;
     }
 
-    (*key)->cntxt = cont;
+    (*key)->pool = pool;
 
     if ((stat = NXKeyCreate(NULL, dest, &(*key)->key)) == 0) {
         return stat;
@@ -107,14 +107,14 @@ apr_status_t apr_threadkey_private_delete(apr_threadkey_t *key)
 
 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);
+    return apr_pool_userdata_get(data, key, threadkey->pool);
 }
 
 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);
+    return apr_pool_userdata_set(data, key, cleanup, threadkey->pool);
 }
 
 apr_status_t apr_os_threadkey_get(apr_os_threadkey_t *thekey,
@@ -125,14 +125,14 @@ apr_status_t apr_os_threadkey_get(apr_os_threadkey_t *thekey,
 }
 
 apr_status_t apr_os_threadkey_put(apr_threadkey_t **key, 
-                                apr_os_threadkey_t *thekey, apr_pool_t *cont)
+                                apr_os_threadkey_t *thekey, apr_pool_t *pool)
 {
-    if (cont == NULL) {
+    if (pool == NULL) {
         return APR_ENOPOOL;
     }
     if ((*key) == NULL) {
-        (*key) = (apr_threadkey_t *)apr_palloc(cont, sizeof(apr_threadkey_t));
-        (*key)->cntxt = cont;
+        (*key) = (apr_threadkey_t *)apr_palloc(pool, sizeof(apr_threadkey_t));
+        (*key)->pool = pool;
     }
     (*key)->key = *thekey;
     return APR_SUCCESS;