From d63056b10b1e45112a0f5e47732b8358af720ebe Mon Sep 17 00:00:00 2001 From: Harald Radi Date: Mon, 10 Jun 2002 13:09:46 +0000 Subject: [PATCH] fix the build # these files were blank, i suppose this happened by accident --- ext/mysql/libmysql/my_wincond.c | 128 ++++++++++++++++++++++++++++++ ext/mysql/libmysql/my_winthread.c | 105 ++++++++++++++++++++++++ 2 files changed, 233 insertions(+) diff --git a/ext/mysql/libmysql/my_wincond.c b/ext/mysql/libmysql/my_wincond.c index e69de29bb2..555ab3bcf7 100644 --- a/ext/mysql/libmysql/my_wincond.c +++ b/ext/mysql/libmysql/my_wincond.c @@ -0,0 +1,128 @@ +/* Copyright Abandoned 1996 TCX DataKonsult AB & Monty Program KB & Detron HB +This file is public domain and comes with NO WARRANTY of any kind */ + +/***************************************************************************** +** The following is a simple implementation of posix conditions +*****************************************************************************/ + +#undef SAFE_MUTEX /* Avoid safe_mutex redefinitions */ +#include "mysys_priv.h" +#if defined(THREAD) && defined(__WIN__) +#include +#undef getpid +#include +#include + +int pthread_cond_init(pthread_cond_t *cond, const pthread_condattr_t *attr) +{ + cond->waiting=0; + cond->semaphore=CreateSemaphore(NULL,0,0x7FFFFFFF,NullS); + if (!cond->semaphore) + return ENOMEM; + return 0; +} + +int pthread_cond_destroy(pthread_cond_t *cond) +{ + return CloseHandle(cond->semaphore) ? 0 : EINVAL; +} + + +int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex) +{ + InterlockedIncrement(&cond->waiting); + LeaveCriticalSection(mutex); + WaitForSingleObject(cond->semaphore,INFINITE); + InterlockedDecrement(&cond->waiting); + EnterCriticalSection(mutex); + return 0 ; +} + +int pthread_cond_timedwait(pthread_cond_t *cond, pthread_mutex_t *mutex, + struct timespec *abstime) +{ + struct _timeb curtime; + int result; + long timeout; + _ftime(&curtime); + timeout= ((long) (abstime->tv_sec - curtime.time)*1000L + + (long)((abstime->tv_nsec/1000) - curtime.millitm)/1000L); + if (timeout < 0) /* Some safety */ + timeout = 0L; + InterlockedIncrement(&cond->waiting); + LeaveCriticalSection(mutex); + result=WaitForSingleObject(cond->semaphore,timeout); + InterlockedDecrement(&cond->waiting); + EnterCriticalSection(mutex); + + return result == WAIT_TIMEOUT ? ETIMEDOUT : 0; +} + + +int pthread_cond_signal(pthread_cond_t *cond) +{ + long prev_count; + if (cond->waiting) + ReleaseSemaphore(cond->semaphore,1,&prev_count); + return 0; +} + + +int pthread_cond_broadcast(pthread_cond_t *cond) +{ + long prev_count; + if (cond->waiting) + ReleaseSemaphore(cond->semaphore,cond->waiting,&prev_count); + return 0 ; +} + + +int pthread_attr_init(pthread_attr_t *connect_att) +{ + connect_att->dwStackSize = 0; + connect_att->dwCreatingFlag = 0; + connect_att->priority = 0; + return 0; +} + +int pthread_attr_setstacksize(pthread_attr_t *connect_att,DWORD stack) +{ + connect_att->dwStackSize=stack; + return 0; +} + +int pthread_attr_setprio(pthread_attr_t *connect_att,int priority) +{ + connect_att->priority=priority; + return 0; +} + +int pthread_attr_destroy(pthread_attr_t *connect_att) +{ + bzero((gptr) connect_att,sizeof(*connect_att)); + return 0; +} + +/**************************************************************************** +** Fix localtime_r() to be a bit safer +****************************************************************************/ + +struct tm *localtime_r(const time_t *timep,struct tm *tmp) +{ + if (*timep == (time_t) -1) /* This will crash win32 */ + { + bzero(tmp,sizeof(*tmp)); + } + else + { + struct tm *res=localtime(timep); + if (!res) /* Wrong date */ + { + bzero(tmp,sizeof(*tmp)); /* Keep things safe */ + return 0; + } + *tmp= *res; + } + return tmp; +} +#endif /* __WIN__ */ diff --git a/ext/mysql/libmysql/my_winthread.c b/ext/mysql/libmysql/my_winthread.c index e69de29bb2..5d06b698ee 100644 --- a/ext/mysql/libmysql/my_winthread.c +++ b/ext/mysql/libmysql/my_winthread.c @@ -0,0 +1,105 @@ +/* Copyright Abandoned 1996 TCX DataKonsult AB & Monty Program KB & Detron HB +This file is public domain and comes with NO WARRANTY of any kind */ + +/***************************************************************************** +** Simulation of posix threads calls for WIN95 and NT +*****************************************************************************/ + +/* SAFE_MUTEX will not work until the thread structure is up to date */ +#undef SAFE_MUTEX + +#include "mysys_priv.h" +#if defined(THREAD) && defined(__WIN__) +#include +#undef getpid +#include + +static pthread_mutex_t THR_LOCK_thread; + +struct pthread_map +{ + HANDLE pthreadself; + pthread_handler func; + void *param; +}; + +void win_pthread_init(void) +{ + pthread_mutex_init(&THR_LOCK_thread,MY_MUTEX_INIT_FAST); +} + +/* +** We have tried to use '_beginthreadex' instead of '_beginthread' here +** but in this case the program leaks about 512 characters for each +** created thread ! +** As we want to save the created thread handler for other threads to +** use and to be returned by pthread_self() (instead of the Win32 pseudo +** handler), we have to go trough pthread_start() to catch the returned handler +** in the new thread. +*/ + +static pthread_handler_decl(pthread_start,param) +{ + pthread_handler func=((struct pthread_map *) param)->func; + void *func_param=((struct pthread_map *) param)->param; + my_thread_init(); /* Will always succeed in windows */ + pthread_mutex_lock(&THR_LOCK_thread); /* Wait for beginthread to return */ + win_pthread_self=((struct pthread_map *) param)->pthreadself; + pthread_mutex_unlock(&THR_LOCK_thread); + free((char*) param); /* Free param from create */ + pthread_exit((void*) (*func)(func_param)); + return 0; /* Safety */ +} + + +int pthread_create(pthread_t *thread_id, pthread_attr_t *attr, + pthread_handler func, void *param) +{ + HANDLE hThread; + struct pthread_map *map; + DBUG_ENTER("pthread_create"); + + if (!(map=malloc(sizeof(*map)))) + DBUG_RETURN(-1); + map->func=func; + map->param=param; + pthread_mutex_lock(&THR_LOCK_thread); +#ifdef __BORLANDC__ + hThread=(HANDLE)_beginthread((void(_USERENTRY *)(void *)) pthread_start, + attr->dwStackSize ? attr->dwStackSize : + 65535, (void*) map); +#else + hThread=(HANDLE)_beginthread((void( __cdecl *)(void *)) pthread_start, + attr->dwStackSize ? attr->dwStackSize : + 65535, (void*) map); +#endif + DBUG_PRINT("info", ("hThread=%lu",(long) hThread)); + *thread_id=map->pthreadself=hThread; + pthread_mutex_unlock(&THR_LOCK_thread); + + if (hThread == (HANDLE) -1) + { + int error=errno; + DBUG_PRINT("error", + ("Can't create thread to handle request (error %d)",error)); + DBUG_RETURN(error ? error : -1); + } + VOID(SetThreadPriority(hThread, attr->priority)) ; + DBUG_RETURN(0); +} + + +void pthread_exit(void *a) +{ + _endthread(); +} + +/* This is neaded to get the macro pthread_setspecific to work */ + +int win_pthread_setspecific(void *a,void *b,uint length) +{ + memcpy(a,b,length); + return 0; +} + +#endif -- 2.40.0