#define pthread_sigmask(A,B,C) sigthreadmask((A),(B),(C))#endif#if !defined(HAVE_SIGWAIT) && !defined(HAVE_mit_thread) && !defined(HAVE_rts_threads) && !defined(sigwait) && !defined(alpha_linux_port) && !defined(HAVE_NONPOSIX_SIGWAIT) && !defined(HAVE_DEC_3_2_THREADS) && !defined(_AIX)int sigwait(sigset_t *setp, int *sigp);		/* Use our implemention */#endif#if !defined(HAVE_SIGSET) && !defined(HAVE_mit_thread) && !defined(sigset)#define sigset(A,B) do { struct sigaction s; sigset_t set;              \                         sigemptyset(&set);                             \                         s.sa_handler = (B);                            \                         s.sa_mask    = set;                            \                         s.sa_flags   = 0;                              \                         sigaction((A), &s, (struct sigaction *) NULL); \                       } while (0)#endif#ifndef my_pthread_setprio#if defined(HAVE_PTHREAD_SETPRIO_NP)		/* FSU threads */#define my_pthread_setprio(A,B) pthread_setprio_np((A),(B))#elif defined(HAVE_PTHREAD_SETPRIO)#define my_pthread_setprio(A,B) pthread_setprio((A),(B))#elseextern void my_pthread_setprio(pthread_t thread_id,int prior);#endif#endif#ifndef my_pthread_attr_setprio#ifdef HAVE_PTHREAD_ATTR_SETPRIO#define my_pthread_attr_setprio(A,B) pthread_attr_setprio((A),(B))#elseextern void my_pthread_attr_setprio(pthread_attr_t *attr, int priority);#endif#endif#if !defined(HAVE_PTHREAD_ATTR_SETSCOPE) || defined(HAVE_DEC_3_2_THREADS)#define pthread_attr_setscope(A,B)#undef	HAVE_GETHOSTBYADDR_R			/* No definition */#endif#ifndef HAVE_NONPOSIX_PTHREAD_GETSPECIFIC#define my_pthread_getspecific(A,B) ((A) pthread_getspecific(B))#else#define my_pthread_getspecific(A,B) ((A) my_pthread_getspecific_imp(B))void *my_pthread_getspecific_imp(pthread_key_t key);#endif#ifndef HAVE_LOCALTIME_Rstruct tm *localtime_r(const time_t *clock, struct tm *res);#endif#ifdef HAVE_PTHREAD_CONDATTR_CREATE/* DCE threads on HPUX 10.20 */#define pthread_condattr_init pthread_condattr_create#define pthread_condattr_destroy pthread_condattr_delete#endif#ifdef HAVE_CTHREADS_WRAPPER			/* For MacOSX */#define pthread_cond_destroy(A) pthread_dummy(0)#define pthread_mutex_destroy(A) pthread_dummy(0)#define pthread_attr_delete(A) pthread_dummy(0)#define pthread_condattr_delete(A) pthread_dummy(0)#define pthread_attr_setstacksize(A,B) pthread_dummy(0)#define pthread_equal(A,B) ((A) == (B))#define pthread_cond_timedwait(a,b,c) pthread_cond_wait((a),(b))#define pthread_attr_init(A) pthread_attr_create(A)#define pthread_attr_destroy(A) pthread_attr_delete(A)#define pthread_attr_setdetachstate(A,B) pthread_dummy(0)#define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))#define pthread_kill(A,B) pthread_dummy(0)#undef	pthread_detach_this_thread#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }#endif#if ((defined(HAVE_PTHREAD_ATTR_CREATE) && !defined(HAVE_SIGWAIT)) || defined(HAVE_DEC_3_2_THREADS)) && !defined(HAVE_CTHREADS_WRAPPER)/* This is set on AIX_3_2 and Siemens unix (and DEC OSF/1 3.2 too) */#define pthread_key_create(A,B) \		pthread_keycreate(A,(B) ?\				  (pthread_destructor_t) (B) :\				  (pthread_destructor_t) pthread_dummy)#define pthread_attr_init(A) pthread_attr_create(A)#define pthread_attr_destroy(A) pthread_attr_delete(A)#define pthread_attr_setdetachstate(A,B) pthread_dummy(0)#define pthread_create(A,B,C,D) pthread_create((A),*(B),(C),(D))#ifndef pthread_sigmask#define pthread_sigmask(A,B,C) sigprocmask((A),(B),(C))#endif#define pthread_kill(A,B) pthread_dummy(0)#undef	pthread_detach_this_thread#define pthread_detach_this_thread() { pthread_t tmp=pthread_self() ; pthread_detach(&tmp); }#else /* HAVE_PTHREAD_ATTR_CREATE && !HAVE_SIGWAIT */#define HAVE_PTHREAD_KILL#endif#if defined(HAVE_PTHREAD_ATTR_CREATE) || defined(_AIX) || defined(HAVE_GLIBC2_STYLE_GETHOSTBYNAME_R)#if !defined(HPUX)struct hostent;#endif /* HPUX */struct hostent *my_gethostbyname_r(const char *name,				   struct hostent *result, char *buffer,				   int buflen, int *h_errnop);#if defined(HAVE_GLIBC2_STYLE_GETHOSTBYNAME_R)#define GETHOSTBYNAME_BUFF_SIZE 2048#else#define GETHOSTBYNAME_BUFF_SIZE sizeof(struct hostent_data)#endif /* defined(HAVE_GLIBC2_STYLE_GETHOSTBYNAME_R) */#else#ifdef HAVE_GETHOSTBYNAME_R_WITH_HOSTENT_DATA#define GETHOSTBYNAME_BUFF_SIZE sizeof(hostent_data)#define my_gethostbyname_r(A,B,C,D,E) gethostbyname_r((A),(B),(hostent_data*) (C))#else#define GETHOSTBYNAME_BUFF_SIZE 2048#define my_gethostbyname_r(A,B,C,D,E) gethostbyname_r((A),(B),(C),(D),(E))#endif /* HAVE_GETHOSTBYNAME_R_WITH_HOSTENT_DATA */#endif /* defined(HAVE_PTHREAD_ATTR_CREATE) || defined(_AIX) || defined(HAVE_GLIBC2_STYLE_GETHOSTBYNAME_R) */#endif /* defined(__WIN__) */	/* safe_mutex adds checking to mutex for easier debugging */typedef struct st_safe_mutex_t{  pthread_mutex_t global,mutex;  char *file;  uint line,count;  pthread_t thread;} safe_mutex_t;int safe_mutex_init(safe_mutex_t *mp, const pthread_mutexattr_t *attr);int safe_mutex_lock(safe_mutex_t *mp,const char *file, uint line);int safe_mutex_unlock(safe_mutex_t *mp,const char *file, uint line);int safe_mutex_destroy(safe_mutex_t *mp,const char *file, uint line);int safe_cond_wait(pthread_cond_t *cond, safe_mutex_t *mp,const char *file,		   uint line);int safe_cond_timedwait(pthread_cond_t *cond, safe_mutex_t *mp,			struct timespec *abstime, const char *file, uint line);	/* Wrappers if safe mutex is actually used */#ifdef SAFE_MUTEX#undef pthread_mutex_init#undef pthread_mutex_lock#undef pthread_mutex_unlock#undef pthread_mutex_destroy#undef pthread_mutex_wait#undef pthread_mutex_timedwait#undef pthread_mutex_t#define pthread_mutex_init(A,B) safe_mutex_init((A),(B))#define pthread_mutex_lock(A) safe_mutex_lock((A),__FILE__,__LINE__)#define pthread_mutex_unlock(A) safe_mutex_unlock((A),__FILE__,__LINE__)#define pthread_mutex_destroy(A) safe_mutex_destroy((A),__FILE__,__LINE__)#define pthread_cond_wait(A,B) safe_cond_wait((A),(B),__FILE__,__LINE__)#define pthread_cond_timedwait(A,B,C) safe_cond_timedwait((A),(B),(C),__FILE__,__LINE__)#define pthread_mutex_t safe_mutex_t#endif /* SAFE_MUTEX */	/* READ-WRITE thread locking */#if defined(USE_MUTEX_INSTEAD_OF_RW_LOCKS)/* use these defs for simple mutex locking */#define rw_lock_t pthread_mutex_t#define my_rwlock_init(A,B) pthread_mutex_init((A),(B))#define rw_rdlock(A) pthread_mutex_lock((A))#define rw_wrlock(A) pthread_mutex_lock((A))#define rw_unlock(A) pthread_mutex_unlock((A))#define rwlock_destroy(A) pthread_mutex_destroy((A))#elif defined(HAVE_PTHREAD_RWLOCK_RDLOCK)#define rw_lock_t pthread_rwlock_t#define my_rwlock_init(A,B) pthread_rwlock_init((A),(B))#define rw_rdlock(A) pthread_rwlock_rdlock(A)#define rw_wrlock(A) pthread_rwlock_wrlock(A)#define rw_unlock(A) pthread_rwlock_unlock(A)#define rwlock_destroy(A) pthread_rwlock_destroy(A)#elif defined(HAVE_RWLOCK_INIT)#ifdef HAVE_RWLOCK_T				/* For example Solaris 2.6-> */#define rw_lock_t rwlock_t#endif#define my_rwlock_init(A,B) rwlock_init((A),USYNC_THREAD,0)#else/* Use our own version of read/write locks */typedef struct _my_rw_lock_t {	pthread_mutex_t lock;		/* lock for structure		*/	pthread_cond_t	readers;	/* waiting readers		*/	pthread_cond_t	writers;	/* waiting writers		*/	int		state;		/* -1:writer,0:free,>0:readers	*/	int		waiters;	/* number of waiting writers	*/} my_rw_lock_t;#define rw_lock_t my_rw_lock_t#define rw_rdlock(A) my_rw_rdlock((A))#define rw_wrlock(A) my_rw_wrlock((A))#define rw_unlock(A) my_rw_unlock((A))#define rwlock_destroy(A) my_rwlock_destroy((A))extern	int	my_rwlock_init( my_rw_lock_t *, void * );extern	int	my_rwlock_destroy( my_rw_lock_t * );extern	int	my_rw_rdlock( my_rw_lock_t * );extern	int	my_rw_wrlock( my_rw_lock_t * );extern	int	my_rw_unlock( my_rw_lock_t * );#endif /* USE_MUTEX_INSTEAD_OF_RW_LOCKS */#define GETHOSTBYADDR_BUFF_SIZE 2048#ifndef HAVE_THR_SETCONCURRENCY#define thr_setconcurrency(A) pthread_dummy(0)#endif#if !defined(HAVE_PTHREAD_ATTR_SETSTACKSIZE) && ! defined(pthread_attr_setstacksize)#define pthread_attr_setstacksize(A,B) pthread_dummy(0)#endifextern my_bool my_thread_global_init(void);extern void my_thread_global_end(void);extern my_bool my_thread_init(void);extern void my_thread_end(void);extern char *my_thread_name(void);extern long my_thread_id(void);extern int pthread_no_free(void *);extern int pthread_dummy(int);/* All thread specific variables are in the following struct */#define THREAD_NAME_SIZE 10#if defined(__ia64__)#define DEFAULT_THREAD_STACK	(128*1024)#else#define DEFAULT_THREAD_STACK	(64*1024)#endifstruct st_my_thread_var{  int thr_errno;  pthread_cond_t suspend, *current_cond;  pthread_mutex_t mutex,  *current_mutex;  pthread_t pthread_self;  long id;  int cmp_length;  volatile int abort;#ifndef DBUG_OFF  gptr dbug;  char name[THREAD_NAME_SIZE+1];#endif};extern struct st_my_thread_var *_my_thread_var(void) __attribute__ ((const));#define my_thread_var (_my_thread_var())#define my_errno my_thread_var->thr_errno	/* statistics_xxx functions are for not essential statistic */#ifndef thread_safe_increment#ifdef HAVE_ATOMIC_ADD#define thread_safe_increment(V,L) atomic_add(1,(atomic_t*) &V);#define thread_safe_add(V,C,L)     atomic_add((C),(atomic_t*) &V);#define thread_safe_sub(V,C,L)     atomic_sub((C),(atomic_t*) &V);#define statistic_increment(V,L)   thread_safe_increment((V),(L))#define statistic_add(V,C,L)       thread_safe_add((V),(C),(L))#else#define thread_safe_increment(V,L) \	pthread_mutex_lock((L)); (V)++; pthread_mutex_unlock((L));#define thread_safe_add(V,C,L) \	pthread_mutex_lock((L)); (V)+=(C); pthread_mutex_unlock((L));#define thread_safe_sub(V,C,L) \	pthread_mutex_lock((L)); (V)-=(C); pthread_mutex_unlock((L));#ifdef SAFE_STATISTICS#define statistic_increment(V,L)   thread_safe_increment((V),(L))#define statistic_add(V,C,L)       thread_safe_add((V),(C),(L))#else#define statistic_increment(V,L) (V)++#define statistic_add(V,C,L)     (V)+=(C)#endif /* SAFE_STATISTICS */#endif /* HAVE_ATOMIC_ADD */#endif /* thread_safe_increment */#endif /* _my_ptread_h */