1 files changed, 252 insertions, 0 deletions
diff --git a/src/examples/pthread_windows.c b/src/examples/pthread_windows.c
new file mode 100644
index 00000000..ed519ebc
--- /dev/null
+++ b/src/examples/pthread_windows.c
@@ -0,0 +1,252 @@
+#include "pthread_windows.h"
+#include <Windows.h>
+struct _pthread_t
+{
+  HANDLE thread;
+};
+struct _pthread_cond_t
+{
+  HANDLE event;
+};
+struct _pthread_mutex_t
+{
+  HANDLE mutex;
+};
+struct StdCallThread
+{
+  void *(__cdecl *start) (void *);
+  void *arg;
+};
+DWORD WINAPI
+ThreadProc (LPVOID lpParameter)
+{
+  struct StdCallThread st = *((struct StdCallThread*) lpParameter);
+  free (lpParameter);
+  st.start (st.arg);
+  return 0;
+}
+int
+pthread_create (pthread_t *pt,
+                const void *attr,
+                void *(__cdecl *start)(void *),
+                void *arg)
+{
+  pthread_t pt_ = (pthread_t) malloc (sizeof(struct _pthread_t));
+  if (NULL == pt_)
+    return 1;
+  struct StdCallThread *sct;
+  sct = (struct StdCallThread*) malloc (sizeof(struct StdCallThread));
+  if (NULL == sct)
+  {
+    free (pt_);
+    return 1;
+  }
+  sct->start = start;
+  sct->arg   = arg;
+  pt_->thread = CreateThread (NULL, 0, ThreadProc, sct, 0, NULL);
+  if (NULL == pt_->thread)
+  {
+    free (sct);
+    free (pt_);
+    return 1;
+  }
+  *pt = pt_;
+  return 0;
+}
+int
+pthread_detach (pthread_t pt)
+{
+  if (pt)
+  {
+    CloseHandle (pt->thread);
+    free (pt);
+  }
+  return 0;
+}
+int
+pthread_join (pthread_t pt,
+              void **value_ptr)
+{
+  if (NULL == pt)
+    return 1;
+  if (value_ptr)
+  {
+    *value_ptr = NULL;
+  }
+  WaitForSingleObject (pt->thread, INFINITE);
+  CloseHandle (pt->thread);
+  free (pt);
+  return 0;
+}
+int
+pthread_mutex_init (pthread_mutex_t *mutex,
+                    const void *attr)
+{
+  pthread_mutex_t mutex_ = (pthread_mutex_t) malloc (sizeof(struct
+                                                            _pthread_mutex_t));
+  if (NULL == mutex_)
+    return 1;
+  mutex_->mutex = CreateMutex (NULL, FALSE, NULL);
+  if (NULL == mutex_->mutex)
+  {
+    free (mutex_);
+    return 1;
+  }
+  *mutex = mutex_;
+  return 0;
+}
+int
+pthread_mutex_destroy (pthread_mutex_t *mutex)
+{
+  if (NULL == mutex)
+    return 1;
+  if ((NULL == *mutex) || (PTHREAD_MUTEX_INITIALIZER == *mutex))
+    return 0;
+  CloseHandle ((*mutex)->mutex);
+  free (*mutex);
+  *mutex = NULL;
+  return 0;
+}
+int
+pthread_mutex_lock (pthread_mutex_t *mutex)
+{
+  if (NULL == mutex)
+    return 1;
+  if (NULL == *mutex)
+    return 1;
+  if (PTHREAD_MUTEX_INITIALIZER == *mutex)
+  {
+    int ret = pthread_mutex_init (mutex, NULL);
+    if (0 != ret)
+      return ret;
+  }
+  if (WAIT_OBJECT_0 != WaitForSingleObject ((*mutex)->mutex, INFINITE))
+    return 1;
+  return 0;
+}
+int
+pthread_mutex_unlock (pthread_mutex_t *mutex)
+{
+  if (NULL == mutex)
+    return 1;
+  if ((NULL == *mutex) || (PTHREAD_MUTEX_INITIALIZER == *mutex))
+    return 1;
+  if (0 == ReleaseMutex ((*mutex)->mutex))
+    return 1;
+  return 0;
+}
+int
+pthread_cond_init (pthread_cond_t *cond,
+                   const void *attr)
+{
+  pthread_cond_t cond_ = (pthread_cond_t) malloc (sizeof(struct
+                                                         _pthread_cond_t));
+  if (NULL == cond_)
+    return 1;
+  cond_->event = CreateEvent (NULL, FALSE, FALSE, NULL);
+  if (NULL == cond_->event)
+  {
+    free (cond_);
+    return 1;
+  }
+  *cond = cond_;
+  return 0;
+}
+int
+pthread_cond_destroy (pthread_cond_t *cond)
+{
+  if (NULL == cond)
+    return 1;
+  if ((NULL == *cond) || (PTHREAD_COND_INITIALIZER == *cond))
+    return 1;
+  CloseHandle ((*cond)->event);
+  free (*cond);
+  return 0;
+}
+int
+pthread_cond_wait (pthread_cond_t *cond,
+                   pthread_mutex_t *mutex)
+{
+  if ((NULL == cond) || (NULL == mutex))
+    return 1;
+  if ((NULL == *cond) || (NULL == *mutex))
+    return 1;
+  if (PTHREAD_COND_INITIALIZER == *cond)
+  {
+    int ret = pthread_cond_init (cond, NULL);
+    if (0 != ret)
+      return ret;
+  }
+  if (PTHREAD_MUTEX_INITIALIZER == *mutex)
+  {
+    int ret = pthread_mutex_init (mutex, NULL);
+    if (0 != ret)
+      return ret;
+  }
+  ReleaseMutex ((*mutex)->mutex);
+  if (WAIT_OBJECT_0 != WaitForSingleObject ((*cond)->event, INFINITE))
+    return 1;
+  if (WAIT_OBJECT_0 != WaitForSingleObject ((*mutex)->mutex, INFINITE))
+    return 1;
+  return 0;
+}
+int
+pthread_cond_signal (pthread_cond_t *cond)
+{
+  if (NULL == cond)
+    return 1;
+  if ((NULL == *cond) || (PTHREAD_COND_INITIALIZER == *cond))
+    return 1;
+  if (0 == SetEvent ((*cond)->event))
+    return 1;
+  return 0;
+}
+int
+pthread_cond_broadcast (pthread_cond_t *cond)
+{
+  return pthread_cond_signal (cond);
+}

diff --git a/src/examples/pthread_windows.c b/src/examples/pthread_windows.c new file mode 100644 index 00000000..ed519ebc --- /dev/null +++ b/src/examples/pthread_windows.c
@@ -0,0 +1,252 @@
	1	#include "pthread_windows.h"
	2	#include <Windows.h>
	3
	4	struct _pthread_t
	5	{
	6	HANDLE thread;
	7	};
	8
	9	struct _pthread_cond_t
	10	{
	11	HANDLE event;
	12	};
	13
	14	struct _pthread_mutex_t
	15	{
	16	HANDLE mutex;
	17	};
	18
	19	struct StdCallThread
	20	{
	21	void (__cdecl start) (void *);
	22	void *arg;
	23	};
	24
	25	DWORD WINAPI
	26	ThreadProc (LPVOID lpParameter)
	27	{
	28	struct StdCallThread st = ((struct StdCallThread) lpParameter);
	29	free (lpParameter);
	30	st.start (st.arg);
	31	return 0;
	32	}
	33
	34
	35	int
	36	pthread_create (pthread_t *pt,
	37	const void *attr,
	38	void (__cdecl start)(void *),
	39	void *arg)
	40	{
	41	pthread_t pt_ = (pthread_t) malloc (sizeof(struct _pthread_t));
	42	if (NULL == pt_)
	43	return 1;
	44	struct StdCallThread *sct;
	45	sct = (struct StdCallThread*) malloc (sizeof(struct StdCallThread));
	46	if (NULL == sct)
	47	{
	48	free (pt_);
	49	return 1;
	50	}
	51
	52	sct->start = start;
	53	sct->arg = arg;
	54	pt_->thread = CreateThread (NULL, 0, ThreadProc, sct, 0, NULL);
	55	if (NULL == pt_->thread)
	56	{
	57	free (sct);
	58	free (pt_);
	59	return 1;
	60	}
	61	*pt = pt_;
	62
	63	return 0;
	64	}
	65
	66
	67	int
	68	pthread_detach (pthread_t pt)
	69	{
	70	if (pt)
	71	{
	72	CloseHandle (pt->thread);
	73	free (pt);
	74	}
	75	return 0;
	76	}
	77
	78
	79	int
	80	pthread_join (pthread_t pt,
	81	void **value_ptr)
	82	{
	83	if (NULL == pt)
	84	return 1;
	85
	86	if (value_ptr)
	87	{
	88	*value_ptr = NULL;
	89	}
	90	WaitForSingleObject (pt->thread, INFINITE);
	91	CloseHandle (pt->thread);
	92	free (pt);
	93
	94	return 0;
	95	}
	96
	97
	98	int
	99	pthread_mutex_init (pthread_mutex_t *mutex,
	100	const void *attr)
	101	{
	102	pthread_mutex_t mutex_ = (pthread_mutex_t) malloc (sizeof(struct
	103	_pthread_mutex_t));
	104	if (NULL == mutex_)
	105	return 1;
	106	mutex_->mutex = CreateMutex (NULL, FALSE, NULL);
	107	if (NULL == mutex_->mutex)
	108	{
	109	free (mutex_);
	110	return 1;
	111	}
	112	*mutex = mutex_;
	113
	114	return 0;
	115	}
	116
	117
	118	int
	119	pthread_mutex_destroy (pthread_mutex_t *mutex)
	120	{
	121	if (NULL == mutex)
	122	return 1;
	123	if ((NULL == mutex) \|\| (PTHREAD_MUTEX_INITIALIZER == mutex))
	124	return 0;
	125
	126	CloseHandle ((*mutex)->mutex);
	127	free (*mutex);
	128	*mutex = NULL;
	129
	130	return 0;
	131	}
	132
	133
	134	int
	135	pthread_mutex_lock (pthread_mutex_t *mutex)
	136	{
	137	if (NULL == mutex)
	138	return 1;
	139	if (NULL == *mutex)
	140	return 1;
	141	if (PTHREAD_MUTEX_INITIALIZER == *mutex)
	142	{
	143	int ret = pthread_mutex_init (mutex, NULL);
	144	if (0 != ret)
	145	return ret;
	146	}
	147	if (WAIT_OBJECT_0 != WaitForSingleObject ((*mutex)->mutex, INFINITE))
	148	return 1;
	149	return 0;
	150	}
	151
	152
	153	int
	154	pthread_mutex_unlock (pthread_mutex_t *mutex)
	155	{
	156	if (NULL == mutex)
	157	return 1;
	158	if ((NULL == mutex) \|\| (PTHREAD_MUTEX_INITIALIZER == mutex))
	159	return 1;
	160
	161	if (0 == ReleaseMutex ((*mutex)->mutex))
	162	return 1;
	163
	164	return 0;
	165	}
	166
	167
	168	int
	169	pthread_cond_init (pthread_cond_t *cond,
	170	const void *attr)
	171	{
	172	pthread_cond_t cond_ = (pthread_cond_t) malloc (sizeof(struct
	173	_pthread_cond_t));
	174	if (NULL == cond_)
	175	return 1;
	176	cond_->event = CreateEvent (NULL, FALSE, FALSE, NULL);
	177	if (NULL == cond_->event)
	178	{
	179	free (cond_);
	180	return 1;
	181	}
	182	*cond = cond_;
	183
	184	return 0;
	185	}
	186
	187
	188	int
	189	pthread_cond_destroy (pthread_cond_t *cond)
	190	{
	191	if (NULL == cond)
	192	return 1;
	193	if ((NULL == cond) \|\| (PTHREAD_COND_INITIALIZER == cond))
	194	return 1;
	195
	196	CloseHandle ((*cond)->event);
	197	free (*cond);
	198
	199	return 0;
	200	}
	201
	202
	203	int
	204	pthread_cond_wait (pthread_cond_t *cond,
	205	pthread_mutex_t *mutex)
	206	{
	207	if ((NULL == cond) \|\| (NULL == mutex))
	208	return 1;
	209	if ((NULL == cond) \|\| (NULL == mutex))
	210	return 1;
	211	if (PTHREAD_COND_INITIALIZER == *cond)
	212	{
	213	int ret = pthread_cond_init (cond, NULL);
	214	if (0 != ret)
	215	return ret;
	216	}
	217	if (PTHREAD_MUTEX_INITIALIZER == *mutex)
	218	{
	219	int ret = pthread_mutex_init (mutex, NULL);
	220	if (0 != ret)
	221	return ret;
	222	}
	223	ReleaseMutex ((*mutex)->mutex);
	224	if (WAIT_OBJECT_0 != WaitForSingleObject ((*cond)->event, INFINITE))
	225	return 1;
	226	if (WAIT_OBJECT_0 != WaitForSingleObject ((*mutex)->mutex, INFINITE))
	227	return 1;
	228
	229	return 0;
	230	}
	231
	232
	233	int
	234	pthread_cond_signal (pthread_cond_t *cond)
	235	{
	236	if (NULL == cond)
	237	return 1;
	238	if ((NULL == cond) \|\| (PTHREAD_COND_INITIALIZER == cond))
	239	return 1;
	240
	241	if (0 == SetEvent ((*cond)->event))
	242	return 1;
	243
	244	return 0;
	245	}
	246
	247
	248	int
	249	pthread_cond_broadcast (pthread_cond_t *cond)
	250	{
	251	return pthread_cond_signal (cond);
	252	}