/******************************************************************************

  pthreads.d:    Posix threads module for the D programming language
  
  Based on Linux C headers by Xavier Leroy

  D module by John Reimer 2004-12-01
		 
  -------------------------------------------------------------------
  
  2004-12-04 ADDED:  Semaphores and fixed module formatting - John Reimer
  
  ****************************************************************************/
    
module std.c.unix.pthread;

version(USE_UNIX98)
{
	version = USE_UNIX98_OR_XOPEN2K;
}

version(USE_XOPEN2K)
{
	version = USE_UNIX98_OR_XOPEN2K;
}

typedef uint __time_t;
	
struct timespec
{
	__time_t tv_sec;
	uint	 tv_nsec;
}

/******************************************** 

  bits/pthreadtypes

*********************************************/

/* pthread types */

struct _pthread_fastlock
{
	int __status;
	int __spinlock;
}

// TODO: _pthread_descr_struct* _pthread_descr;
// How do I declare _pthread_desc_struct* for a 
// structure that isn't defined in the headers?
// For now, I just define the symbol.  I guess 
// that _pthread_descr_struct is never referenced
// except by pointer so there should be no issue
// here.

extern(C) struct _pthread_descr_struct {};

typedef _pthread_descr_struct* _pthread_descr;

struct sched_param 
{
	int __sched_priority;
}

struct pthread_attr_t
{
	int 	__detachstate;
	int 	__schedpolicy;
	sched_param __schedparam;
	int 	__inheritsched;
	int 	__scope;
	size_t 	__guardsize;
	int 	__stackaddr_set;
	void*	__stackaddr;
	size_t 	__stacksize;
}

// Not sure if it should be uint or long
typedef long __pthread_cond_align_t;

struct pthread_cond_t 
{
	_pthread_fastlock __c_lock;
	_pthread_descr	  __c_waiting;
	char[48 - _pthread_fastlock.sizeof
		- _pthread_descr.sizeof
		- __pthread_cond_align_t.sizeof] __padding;
	__pthread_cond_align_t __align;
}

struct pthread_condattr_t
{
	int __dummy;
}

typedef uint pthread_key_t;

struct pthread_mutex_t
{
	int 		__m_reserved;
	int 		__m_count;
	_pthread_descr	__m_owner;
	int 		__m_kind;
	_pthread_fastlock __m_lock;
}

struct pthread_mutexattr_t
{
	int __mutexkind;
}

typedef int pthread_once_t;

version(USE_UNIX98_OR_XOPEN2K)
{
	struct pthread_rwlock_t
	{
		_pthread_fastlock __rw_lock;
		int 		  __rw_readers;
		_pthread_descr	  __rw_writer;
		_pthread_descr	  __rw_read_waiting;
		_pthread_descr	  __rw_write_waiting;
		int		  __rw_pshared;
	}

	struct pthread_rwlockattr_t
	{
		int __lockkind;
		int __pshared;
	}
}

version(USE_XOPEN2K)
{
	typedef int pthread_spinlock_t;

	struct pthread_barrier_t
	{
		_pthread_fastlock __ba_lock;
		int 		  __ba_required;
		int 		  __ba_present;
		_pthread_descr 	  __va_waiting;
	}

	struct pthread_barrierattr_t
	{
		int __pshared;
	}
}

typedef uint pthread_t;

/************************************************

   End of bits/pthreadtypes

*************************************************/


/************************************************

  pthread start
  
************************************************/

enum
{
	PTHREAD_CREATE_JOINABLE,
	PTHREAD_CREATE_DETACHED
}
        
enum
{
	PTHREAD_INHERIT_SCHED,
	PTHREAD_EXPLICIT_SCHED
}

enum
{
	PTHREAD_SCOPE_SYSTEM,
	PTHREAD_SCOPE_PROCESS
}

enum 
{
	PTHREAD_MUTEX_TIMED_NP,
	PTHREAD_MUTEX_RECURSIVE_NP,
	PTHREAD_MUTEX_ERRORCHECK_NP,
	PTHREAD_MUTEX_ADAPTIVE_NP
}

version(USE_GNU) enum 
{
	PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_ADAPTIVE_NP	
}

version(USE_UNIX98) enum 
{	
	PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_TIMED_NP,
	PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
	PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
	PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
}

enum
{
	PTHREAD_PROCESS_PRIVATE,
	PTHREAD_PROCESS_SHARED
}


version(USE_UNIX98_OR_XOPEN2K) enum
{
	PTHREAD_RWLOCK_PREFER_READER_NP,
	PTHREAD_RWLOCK_PREFER_WRITER_NP,
	PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP,
	PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP
}

const int PTHREAD_ONCE_INIT = 0;

version(XOPEN2K) const int PTHREAD_BARRIER_SERIAL_THREAD = -1;

/* Cleanup buffers */
	
struct _pthread_cleanup_buffer
{
	void function(void*) __routine;		// Function to call.
	void *		 __arg;			// Its argument. 
	int   		 __canceltype;		// Saved cancellation type.
	_pthread_cleanup_buffer *__prev;	// Chaining of cleanup functions
}

/* Canellation */

enum
{
	PTHREAD_CANCEL_ENABLE,
	PTHREAD_CANCEL_DISABLE
}

enum
{
	PTHREAD_CANCEL_DEFERRED,
	PTHREAD_CANCEL_ASYNCHRONOUS
}

const void* PTHREAD_CANCELED = cast(void*)-1;


extern(C)
{

int	pthread_create(	pthread_t*, pthread_attr_t*, void* function(void*),void*);
pthread_t 	pthread_self ();
int	pthread_equal( pthread_t, pthread_t );
void	pthread_exit( void* );
int	pthread_join( pthread_t, void** );
int	pthread_detach( pthread_t );

int	pthread_attr_init( pthread_attr_t* );
int	pthread_attr_destroy( pthread_attr_t* );
int	pthread_attr_setdetachstate( pthread_attr_t*, int );
int	pthread_attr_getdetachstate( pthread_attr_t*, int* );
int	pthread_attr_setschedparam( pthread_attr_t*, sched_param* );
int	pthread_attr_getschedparam( pthread_attr_t*, sched_param* );
int	pthread_attr_setschedpolicy( pthread_attr_t*, int );
int	pthread_attr_getschedpolicy( pthread_attr_t*, int* );
int	pthread_attr_setinheritsched( pthread_attr_t*, int );
int	pthread_attr_getinheritsched( pthread_attr_t*, int* );
int	pthread_attr_setscope( pthread_attr_t*, int );    
int	pthread_attr_getscope( pthread_attr_t*, int* );

version(USE_UNIX98) 
{				    
	int	pthread_attr_setguardsize( pthread_attr_t*, size_t );
	int	pthread_attr_getguardsize( pthread_attr_t*, size_t* );
}

int	pthread_attr_setstackaddr( pthread_attr_t*, void* );
int	pthread_attr_getstackaddr( pthread_attr_t*, void** );
					  
version(USE_XOPEN2K)
{
	int	pthread_attr_setstack( pthread_attr_t*, void*, size_t );
	int 	pthread_attr_getstack( pthread_attr_t*, void**, size_t* );
}

int	pthread_attr_setstacksize( pthread_attr_t*, size_t );
int	pthread_attr_getstacksize( pthread_attr_t*, size_t* );
				
version(USE_GNU)
{
	int	pthread_getattr_np ( pthread_t, pthread_attr_t* );
}

int	pthread_setschedparam( pthread_t, int, sched_param* );
int	pthread_getschedparam( pthread_t, int*, sched_param* );
				       
version(USE_UNIX98)
{
	int	pthread_getconcurrency();
	int	pthread_setconcurrency( int );
}

version(USE_GNU)
{
	int	pthread_yield();
}

int	pthread_mutex_init( pthread_mutex_t*, pthread_mutexattr_t* );
int	pthread_mutex_destroy( pthread_mutex_t* );
int	pthread_mutex_trylock( pthread_mutex_t* );
int	pthread_mutex_lock( pthread_mutex_t* );

version(USE_XOPEN2K) 
{
	int	pthread_mutex_timedlock( pthread_mutex_t*, timespec* );
}

int	pthread_mutex_unlock( pthread_mutex_t* );

int	pthread_mutexattr_init( pthread_mutexattr_t* );
int	pthread_mutexattr_destroy( pthread_mutexattr_t* );
int	pthread_mutexattr_getpshared( pthread_mutexattr_t*, int* );
int	pthread_mutexattr_setpshared( pthread_mutexattr_t*, int );
					      
version(USE_UNIX98) 
{
	int	pthread_mutexattr_settype( pthread_mutexattr_t*, int );
	int	pthread_mutexattr_gettype( pthread_mutexattr_t*, int* );
}

int	pthread_cond_init( pthread_cond_t*, pthread_condattr_t* );
int	pthread_cond_destroy( pthread_cond_t* );
int	pthread_cond_signal( pthread_cond_t* );
int	pthread_cond_wait( pthread_cond_t*, pthread_mutex_t* );
int	pthread_cond_timewait( pthread_cond_t*, pthread_mutex_t*, timespec* );
	
int	pthread_condattr_init( pthread_condattr_t* );
int	pthread_condattr_destroy( pthread_condattr_t* );
int	pthread_condattr_getpshared( pthread_condattr_t*, int* );
int	pthread_condattr_setpshared( pthread_condattr_t*, int );
					
version (USE_UNIX98_OR_XOPEN2K)
{
	int 	pthread_rwlock_init( pthread_rwlock_t*,pthread_rwlockattr_t* );
	int 	pthread_rwlock_destroy( pthread_rwlock_t* );
	int	pthread_rwlock_rdlock( pthread_rwlock_t* );
	int	pthread_rwlock_tryrdlock( pthread_rwlock_t* );
	int	pthread_rwlock_wrlock( pthread_rwlock_t* );
	int	pthread_rwlock_trywrlock( pthread_rwlock_t* );
	int	pthread_rwlock_unlock( pthread_rwlock_t* );

	int	pthread_rwlockattr_init( pthread_rwlockattr_t* );
	int	pthread_rwlockattr_destroy( pthread_rwlockattr_t* );
	int	pthread_rwlockattr_getpshared( pthread_rwlockattr_t*, int* );
	int	pthread_rwlockattr_setpshared( pthread_rwlockattr_t*, int );
	int	pthread_rwlockattr_getkind_np( pthread_rwlockattr_t*, int* );
	int	pthread_rwlockattr_setkind_np( pthread_rwlockattr_t*, int );
}

version(USE_XOPEN2K) 
{
	int	pthread_rwlock_timedrdlock( pthread_rwlock_t*, timespec* );
	int	pthread_rwlock_timedwrlock( pthread_rwlock_t*, timespec* );

/*  Spinlocks -- IEEE Std. 1003.1j-2000. */

	int	pthread_spin_init( pthread_spinlock_t*, int );
	int	pthread_spin_destroy( pthread_spinlock_t* );
	int	pthread_spin_lock( pthread_spinlock_t* );
	int	pthread_spin_trylock( pthread_spinlock_t* );
	int	pthread_spin_unlock( pthread_spinlock_t* );

/* Barriers -- IEEE Std. 1003.1j-2000. */

	int	pthread_barrier_init( pthread_barrier_t*, pthread_barrierattr_t*, uint );
	int	pthread_barrier_destory( pthread_barrier_t* );
	int	pthread_barrerattr_init( pthread_barrierattr_t* );
	int	pthread_barrerattr_destroy( pthread_barrierattr_t* );
	int	pthread_barrierattr_getpshared( pthread_barrierattr_t*,int* );
	int	pthread_barrierattr_setpshared( pthread_barrierattr_t*,int );
	int	pthread_barrier_wait( pthread_barrier_t* __barrier );	
}

int	pthread_key_create( pthread_key_t*, void (*)(void*) );
int	pthread_key_delete( pthread_key_t );
int	pthread_setspecific( pthread_key_t, void* );
void*	pthread_getspecific( pthread_key_t );

int	pthread_once( pthread_once_t*, void (*)() );

int	pthread_setcancelstate( int, int* );
int	pthread_setcanceltype( int, int* );
int	pthread_cancel( pthread_t );
void	pthread_testcancel();
void	_pthread_cleanup_push( _pthread_cleanup_buffer*,void function(void*),void* );
void	_pthread_cleanup_pop( _pthread_cleanup_buffer*, int );

	
version(USE_XOPEN2K) 
{
	typedef int	__clockid_t;	

	int	pthread_getcpuclockid( pthread_t, __clockid_t* );
}

version(USE_UNIX98) 
{
	struct __sigset_t
	{
		uint[1024/(8*uint.sizeof)] __val;
	}

	int	pthread_sigmask( int, __sigset_t*, __sigset_t* );
	int	pthread_kill( pthread_t, int );
}

int	pthread_atfork( void function(), void function(), void function() );
void	pthread_kill_other_threads_np();

} // extern(C)      

/***************************************************************

	Semaphores -- part of pthreads

 ***************************************************************/

/* System specific semaphore definition. */

version(linux)
{
	struct sem_t
	{
		_pthread_fastlock __sem_lock;
		int 		  __sem_value;
		_pthread_descr	  __sem_waiting;
	}
} 

else 
{
	struct sem_t{};  // other versions should implement
}

const sem_t* SEM_FAILED = null;
const uint   SEM_VALUE_MAX = 2_147_483_647;

/* Semaphores */

extern(C)
{
int	sem_init( sem_t *, int );
int	sem_destory( sem_t* );
sem_t* sem_open( char*, int, ... );
int	sem_close( sem_t* );
int	sem_unlink( char* );
int	sem_wait( sem_t* );
	
version(USE_XOPEN2K)
	int sem_timedwait(sem_t*, timespec* );

int	sem_trywait( sem_t* );
int	sem_post( sem_t* );
int	sem_getvalue( sem_t*, int* );

} // extern(C)