POSIX - address namespace clash issues

[Gary Thomas <gary at mlbassoc dot com>]

Index: compat/posix/current/ChangeLog
===================================================================
RCS file: /misc/cvsfiles/ecos/packages/compat/posix/current/ChangeLog,v
retrieving revision 1.41
diff -u -5 -p -b -r1.41 ChangeLog
--- compat/posix/current/ChangeLog	3 Mar 2003 16:57:54 -0000	1.41
+++ compat/posix/current/ChangeLog	4 Mar 2003 17:22:47 -0000
@@ -1,5 +1,9 @@
+2003-03-04  Gary Thomas  <gary at mlbassoc dot com>
+
+	* include/pthread.h: Rework prototypes to minimize namespace problems.
+
 2003-03-03  Jonathan Larmour  <jifl at eCosCentric dot com>
 
 	* tests/signal2.c (cause_illegal_access): PowerPC only generates
 	alignment exceptions in little-endian mode, so make that a special
 	case.
Index: compat/posix/current/include/pthread.h
===================================================================
RCS file: /misc/cvsfiles/ecos/packages/compat/posix/current/include/pthread.h,v
retrieving revision 1.7
diff -u -5 -p -b -r1.7 pthread.h
--- compat/posix/current/include/pthread.h	23 May 2002 22:59:57 -0000	1.7
+++ compat/posix/current/include/pthread.h	4 Mar 2003 15:32:08 -0000
@@ -81,32 +81,32 @@
 
 //-----------------------------------------------------------------------------
 // Thread creation and management.
 
 // Create a thread.
-externC int pthread_create ( pthread_t *thread,
-                             const pthread_attr_t *attr,
-                             void *(*start_routine) (void *),
-                             void *arg);
+__externC int pthread_create (pthread_t *__thread,
+                              const pthread_attr_t *__attr,
+                              void *(*__start_routine) (void *),
+                              void *__arg);
 
 // Get current thread id.
-externC pthread_t pthread_self ( void );
+__externC pthread_t pthread_self (void);
 
 // Compare two thread identifiers.
-externC int pthread_equal (pthread_t thread1, pthread_t thread2);
+__externC int pthread_equal (pthread_t __thread1, pthread_t __thread2);
 
 // Terminate current thread.
-externC void pthread_exit (void *retval) CYGBLD_ATTRIB_NORET;
+__externC void pthread_exit (void *__retval) CYGBLD_ATTRIB_NORET;
 
 // Wait for the thread to terminate. If thread_return is not NULL then
 // the retval from the thread's call to pthread_exit() is stored at
 // *thread_return.
-externC int pthread_join (pthread_t thread, void **thread_return);
+__externC int pthread_join (pthread_t __thread, void **__thread_return);
 
 // Set the detachstate of the thread to "detached". The thread then does not
 // need to be joined and its resources will be freed when it exits.
-externC int pthread_detach (pthread_t thread);
+__externC int pthread_detach (pthread_t __thread);
 
 //-----------------------------------------------------------------------------
 // Thread attribute handling.
 
 // Initialize attributes object with default attributes:
@@ -116,122 +116,122 @@ externC int pthread_detach (pthread_t th
 // schedpolicy          == SCHED_OTHER
 // schedparam           == unset
 // stackaddr            == unset
 // stacksize            == 0
 // 
-externC int pthread_attr_init (pthread_attr_t *attr);
+__externC int pthread_attr_init (pthread_attr_t *__attr);
 
 // Destroy thread attributes object
-externC int pthread_attr_destroy (pthread_attr_t *attr);
+__externC int pthread_attr_destroy (pthread_attr_t *__attr);
 

 // Set the detachstate attribute
-externC int pthread_attr_setdetachstate (pthread_attr_t *attr,
-                                         int detachstate);
+__externC int pthread_attr_setdetachstate (pthread_attr_t *__attr,
+                                           int __detachstate);
 
 // Get the detachstate attribute
-externC int pthread_attr_getdetachstate (const pthread_attr_t *attr,
-                                         int *detachstate);
+__externC int pthread_attr_getdetachstate (const pthread_attr_t *__attr,
+                                           int *__detachstate);
 

 // Set scheduling contention scope
-externC int pthread_attr_setscope (pthread_attr_t *attr, int scope);
+__externC int pthread_attr_setscope (pthread_attr_t *__attr, int __scope);
 
 // Get scheduling contention scope
-externC int pthread_attr_getscope (const pthread_attr_t *attr, int *scope);
+__externC int pthread_attr_getscope (const pthread_attr_t *__attr, int *__scope);
 

 // Set scheduling inheritance attribute
-externC int pthread_attr_setinheritsched (pthread_attr_t *attr, int inherit);
+__externC int pthread_attr_setinheritsched (pthread_attr_t *__attr, int __inherit);
 
 // Get scheduling inheritance attribute
-externC int pthread_attr_getinheritsched (const pthread_attr_t *attr,
-                                          int *inherit);
+__externC int pthread_attr_getinheritsched (const pthread_attr_t *__attr,
+                                            int *__inherit);
 

 // Set scheduling policy
-externC int pthread_attr_setschedpolicy (pthread_attr_t *attr, int policy);
+__externC int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy);
 
 // Get scheduling policy
-externC int pthread_attr_getschedpolicy (const pthread_attr_t *attr,
-                                         int *policy);
+__externC int pthread_attr_getschedpolicy (const pthread_attr_t *__attr,
+                                           int *__policy);
 

 // Set scheduling parameters
-externC int pthread_attr_setschedparam (pthread_attr_t *attr,
-				        const struct sched_param *param);
+__externC int pthread_attr_setschedparam (pthread_attr_t *__attr,
+                                          const struct sched_param *__param);
 
 // Get scheduling parameters
-externC int pthread_attr_getschedparam (const pthread_attr_t *attr,
-                                        struct sched_param *param);
+__externC int pthread_attr_getschedparam (const pthread_attr_t *__attr,
+                                          struct sched_param *__param);
 

 // Set starting address of stack. Whether this is at the start or end of
 // the memory block allocated for the stack depends on whether the stack
 // grows up or down.
-externC int pthread_attr_setstackaddr (pthread_attr_t *attr, void *stackaddr);
+__externC int pthread_attr_setstackaddr (pthread_attr_t *__attr, void *__stackaddr);
 
 // Get any previously set stack address.
-externC int pthread_attr_getstackaddr (const pthread_attr_t *attr,
-                                       void **stackaddr);
+__externC int pthread_attr_getstackaddr (const pthread_attr_t *__attr,
+                                         void **__stackaddr);
 

 // Set minimum creation stack size.
-externC int pthread_attr_setstacksize (pthread_attr_t *attr,
-                                       size_t stacksize);
+__externC int pthread_attr_setstacksize (pthread_attr_t *__attr,
+                                         size_t __stacksize);
 
 // Get current minimal stack size.
-externC int pthread_attr_getstacksize (const pthread_attr_t *attr,
-                                       size_t *stacksize);
+__externC int pthread_attr_getstacksize (const pthread_attr_t *__attr,
+                                         size_t *__stacksize);
 
 //-----------------------------------------------------------------------------
 // Thread scheduling controls
 
 // Set scheduling policy and parameters for the thread
-externC int pthread_setschedparam (pthread_t thread,
-                                   int policy,
-                                   const struct sched_param *param);
+__externC int pthread_setschedparam (pthread_t __thread,
+                                     int __policy,
+                                     const struct sched_param *__param);
 
 // Get scheduling policy and parameters for the thread
-externC int pthread_getschedparam (pthread_t thread,
-                                   int *policy,
-                                   struct sched_param *param);
+__externC int pthread_getschedparam (pthread_t __thread,
+                                     int *__policy,
+                                     struct sched_param *__param);
 


 //=============================================================================
 // Dynamic package initialization
 
 // Initializer for pthread_once_t instances
 #define PTHREAD_ONCE_INIT       0
 
 // Call init_routine just the once per control variable.
-externC int pthread_once (pthread_once_t *once_control,
-                          void (*init_routine) (void));
+__externC int pthread_once (pthread_once_t *__once_control,
+                            void (*__init_routine) (void));
 


 //=============================================================================
 //Thread specific data
 
 // Create a key to identify a location in the thread specific data area.
 // Each thread has its own distinct thread-specific data area but all are
 // addressed by the same keys. The destructor function is called whenever a
 // thread exits and the value associated with the key is non-NULL.
-externC int pthread_key_create (pthread_key_t *key,
-                                void (*destructor) (void *));
+__externC int pthread_key_create (pthread_key_t *__key,
+                                  void (*__destructor) (void *));
 
 // Delete key.
-externC int pthread_key_delete (pthread_key_t key);
+__externC int pthread_key_delete (pthread_key_t __key);
 
 // Store the pointer value in the thread-specific data slot addressed
 // by the key.
-externC int pthread_setspecific (pthread_key_t key, const void *pointer);
+__externC int pthread_setspecific (pthread_key_t __key, const void *__pointer);
 
 // Retrieve the pointer value in the thread-specific data slot addressed
 // by the key.
-externC void *pthread_getspecific (pthread_key_t key);
+__externC void *pthread_getspecific (pthread_key_t __key);
 


 //=============================================================================
 // Thread Cancellation
@@ -251,11 +251,11 @@ struct pthread_cleanup_buffer
 // This is a value returned as the retval in pthread_join() of a
 // thread that has been cancelled. By making it the address of a
 // location we define we can ensure that it differs from NULL and any
 // other valid pointer (as required by the standard).
 
-externC int pthread_canceled_dummy_var;
+__externC int pthread_canceled_dummy_var;
 
 #define PTHREAD_CANCELED                ((void *)(&pthread_canceled_dummy_var))
 
 //-----------------------------------------------------------------------------
 // Cancelability enable and type
@@ -269,52 +269,52 @@ externC int pthread_canceled_dummy_var;
 //-----------------------------------------------------------------------------
 // Functions
 
 // Set cancel state of current thread to ENABLE or DISABLE.
 // Returns old state in *oldstate.
-externC int pthread_setcancelstate (int state, int *oldstate);
+__externC int pthread_setcancelstate (int __state, int *__oldstate);
 
 // Set cancel type of current thread to ASYNCHRONOUS or DEFERRED.
 // Returns old type in *oldtype.
-externC int pthread_setcanceltype (int type, int *oldtype);
+__externC int pthread_setcanceltype (int __type, int *__oldtype);
 
 // Cancel the thread.
-externC int pthread_cancel (pthread_t thread);
+__externC int pthread_cancel (pthread_t __thread);
 
 // Test for a pending cancellation for the current thread and terminate
 // the thread if there is one.
-externC void pthread_testcancel (void);
+__externC void pthread_testcancel (void);
 
 // Install a cleanup routine.
 // Note that pthread_cleanup_push() and pthread_cleanup_pop() are macros that
 // must be used in matching pairs and at the same brace nesting level.
-#define pthread_cleanup_push(routine,arg)                       \
+#define pthread_cleanup_push(__routine, __arg)                          \
     {                                                           \
         struct pthread_cleanup_buffer _buffer_;                 \
-        pthread_cleanup_push_inner (&_buffer_, (routine), (arg));
+        pthread_cleanup_push_inner (&_buffer_, (__routine), (__arg));
 
 // Remove a cleanup handler installed by the matching pthread_cleanup_push().
 // If execute is non-zero, the handler function is called.
-#define pthread_cleanup_pop(execute)                            \
-        pthread_cleanup_pop_inner (&_buffer_, (execute));       \
+#define pthread_cleanup_pop(__execute)                          \
+        pthread_cleanup_pop_inner (&_buffer_, (__execute));     \
     }
 

 // These two functions actually implement the cleanup push and pop functionality.
-externC void pthread_cleanup_push_inner (struct pthread_cleanup_buffer *buffer,
-                                         void (*routine) (void *),
-                                         void *arg);
+__externC void pthread_cleanup_push_inner (struct pthread_cleanup_buffer *__buffer,
+                                           void (*__routine) (void *),
+                                           void *__arg);
 
-externC void pthread_cleanup_pop_inner (struct pthread_cleanup_buffer *buffer,
-                                        int execute);
+__externC void pthread_cleanup_pop_inner (struct pthread_cleanup_buffer *__buffer,
+                                          int __execute);
 

 // -------------------------------------------------------------------------
 // eCos-specific function to measure stack usage of the supplied thread
 
 #ifdef CYGFUN_KERNEL_THREADS_STACK_MEASUREMENT
-externC size_t pthread_measure_stack_usage (pthread_t thread);
+__externC size_t pthread_measure_stack_usage (pthread_t __thread);
 #endif
 
 //-----------------------------------------------------------------------------
 #endif // ifndef CYGONCE_PTHREAD_H
 // End of pthread.h


-- 
------------------------------------------------------------
Gary Thomas                 |
MLB Associates              |  Consulting for the
+1 (970) 229-1963           |    Embedded world
http://www.mlbassoc.com/    |
email: <gary at mlbassoc dot com>  |
gpg: http://www.chez-thomas.org/gary/gpg_key.asc
------------------------------------------------------------