[thirdparty/cups.git] / cups / thread.c

/*
 * Threading primitives for CUPS.
 *
 * Copyright © 2009-2018 by Apple Inc.
 *
 * Licensed under Apache License v2.0.  See the file "LICENSE" for more
 * information.
 */

/*
 * Include necessary headers...
 */

#include "cups-private.h"
#include "thread-private.h"


#if defined(HAVE_PTHREAD_H)
/*
 * '_cupsCondBroadcast()' - Wake up waiting threads.
 */

void
_cupsCondBroadcast(_cups_cond_t *cond)	/* I - Condition */
{
  pthread_cond_broadcast(cond);
}


/*
 * '_cupsCondInit()' - Initialize a condition variable.
 */

void
_cupsCondInit(_cups_cond_t *cond)	/* I - Condition */
{
  pthread_cond_init(cond, NULL);
}


/*
 * '_cupsCondWait()' - Wait for a condition with optional timeout.
 */

void
_cupsCondWait(_cups_cond_t  *cond,	/* I - Condition */
              _cups_mutex_t *mutex,	/* I - Mutex */
	      double        timeout)	/* I - Timeout in seconds (0 or negative for none) */
{
  if (timeout > 0.0)
  {
    struct timespec abstime;		/* Timeout */

    clock_gettime(CLOCK_REALTIME, &abstime);

    abstime.tv_sec  += (long)timeout;
    abstime.tv_nsec += (long)(1000000000 * (timeout - (long)timeout));

    while (abstime.tv_nsec >= 1000000000)
    {
      abstime.tv_nsec -= 1000000000;
      abstime.tv_sec ++;
    };

    pthread_cond_timedwait(cond, mutex, &abstime);
  }
  else
    pthread_cond_wait(cond, mutex);
}


/*
 * '_cupsMutexInit()' - Initialize a mutex.
 */

void
_cupsMutexInit(_cups_mutex_t *mutex)	/* I - Mutex */
{
  pthread_mutex_init(mutex, NULL);
}


/*
 * '_cupsMutexLock()' - Lock a mutex.
 */

void
_cupsMutexLock(_cups_mutex_t *mutex)	/* I - Mutex */
{
  pthread_mutex_lock(mutex);
}


/*
 * '_cupsMutexUnlock()' - Unlock a mutex.
 */

void
_cupsMutexUnlock(_cups_mutex_t *mutex)	/* I - Mutex */
{
  pthread_mutex_unlock(mutex);
}


/*
 * '_cupsRWInit()' - Initialize a reader/writer lock.
 */

void
_cupsRWInit(_cups_rwlock_t *rwlock)	/* I - Reader/writer lock */
{
  pthread_rwlock_init(rwlock, NULL);
}


/*
 * '_cupsRWLockRead()' - Acquire a reader/writer lock for reading.
 */

void
_cupsRWLockRead(_cups_rwlock_t *rwlock)	/* I - Reader/writer lock */
{
  pthread_rwlock_rdlock(rwlock);
}


/*
 * '_cupsRWLockWrite()' - Acquire a reader/writer lock for writing.
 */

void
_cupsRWLockWrite(_cups_rwlock_t *rwlock)/* I - Reader/writer lock */
{
  pthread_rwlock_wrlock(rwlock);
}


/*
 * '_cupsRWUnlock()' - Release a reader/writer lock.
 */

void
_cupsRWUnlock(_cups_rwlock_t *rwlock)	/* I - Reader/writer lock */
{
  pthread_rwlock_unlock(rwlock);
}


/*
 * '_cupsThreadCancel()' - Cancel (kill) a thread.
 */

void
_cupsThreadCancel(_cups_thread_t thread)/* I - Thread ID */
{
  pthread_cancel(thread);
}


/*
 * '_cupsThreadCreate()' - Create a thread.
 */

_cups_thread_t				/* O - Thread ID */
_cupsThreadCreate(
    _cups_thread_func_t func,		/* I - Entry point */
    void                *arg)		/* I - Entry point context */
{
  pthread_t thread;

  if (pthread_create(&thread, NULL, (void *(*)(void *))func, arg))
    return (0);
  else
    return (thread);
}


/*
 * '_cupsThreadDetach()' - Tell the OS that the thread is running independently.
 */

void
_cupsThreadDetach(_cups_thread_t thread)/* I - Thread ID */
{
  pthread_detach(thread);
}


/*
 * '_cupsThreadWait()' - Wait for a thread to exit.
 */

void *					/* O - Return value */
_cupsThreadWait(_cups_thread_t thread)	/* I - Thread ID */
{
  void	*ret;				/* Return value */


  if (pthread_join(thread, &ret))
    return (NULL);
  else
    return (ret);
}


#elif defined(_WIN32)
#  include <process.h>


/*
 * '_cupsCondBroadcast()' - Wake up waiting threads.
 */

void
_cupsCondBroadcast(_cups_cond_t *cond)	/* I - Condition */
{
  // TODO: Implement me
}


/*
 * '_cupsCondInit()' - Initialize a condition variable.
 */

void
_cupsCondInit(_cups_cond_t *cond)	/* I - Condition */
{
  // TODO: Implement me
}


/*
 * '_cupsCondWait()' - Wait for a condition with optional timeout.
 */

void
_cupsCondWait(_cups_cond_t  *cond,	/* I - Condition */
              _cups_mutex_t *mutex,	/* I - Mutex */
	      double        timeout)	/* I - Timeout in seconds (0 or negative for none) */
{
  // TODO: Implement me
}


/*
 * '_cupsMutexInit()' - Initialize a mutex.
 */

void
_cupsMutexInit(_cups_mutex_t *mutex)	/* I - Mutex */
{
  InitializeCriticalSection(&mutex->m_criticalSection);
  mutex->m_init = 1;
}


/*
 * '_cupsMutexLock()' - Lock a mutex.
 */

void
_cupsMutexLock(_cups_mutex_t *mutex)	/* I - Mutex */
{
  if (!mutex->m_init)
  {
    _cupsGlobalLock();

    if (!mutex->m_init)
    {
      InitializeCriticalSection(&mutex->m_criticalSection);
      mutex->m_init = 1;
    }

    _cupsGlobalUnlock();
  }

  EnterCriticalSection(&mutex->m_criticalSection);
}


/*
 * '_cupsMutexUnlock()' - Unlock a mutex.
 */

void
_cupsMutexUnlock(_cups_mutex_t *mutex)	/* I - Mutex */
{
  LeaveCriticalSection(&mutex->m_criticalSection);
}


/*
 * '_cupsRWInit()' - Initialize a reader/writer lock.
 */

void
_cupsRWInit(_cups_rwlock_t *rwlock)	/* I - Reader/writer lock */
{
  _cupsMutexInit((_cups_mutex_t *)rwlock);
}


/*
 * '_cupsRWLockRead()' - Acquire a reader/writer lock for reading.
 */

void
_cupsRWLockRead(_cups_rwlock_t *rwlock)	/* I - Reader/writer lock */
{
  _cupsMutexLock((_cups_mutex_t *)rwlock);
}


/*
 * '_cupsRWLockWrite()' - Acquire a reader/writer lock for writing.
 */

void
_cupsRWLockWrite(_cups_rwlock_t *rwlock)/* I - Reader/writer lock */
{
  _cupsMutexLock((_cups_mutex_t *)rwlock);
}


/*
 * '_cupsRWUnlock()' - Release a reader/writer lock.
 */

void
_cupsRWUnlock(_cups_rwlock_t *rwlock)	/* I - Reader/writer lock */
{
  _cupsMutexUnlock((_cups_mutex_t *)rwlock);
}


/*
 * '_cupsThreadCancel()' - Cancel (kill) a thread.
 */

void
_cupsThreadCancel(_cups_thread_t thread)/* I - Thread ID */
{
  // TODO: Implement me
}


/*
 * '_cupsThreadCreate()' - Create a thread.
 */

_cups_thread_t				/* O - Thread ID */
_cupsThreadCreate(
    _cups_thread_func_t func,		/* I - Entry point */
    void                *arg)		/* I - Entry point context */
{
  return (_beginthreadex(NULL, 0, (LPTHREAD_START_ROUTINE)func, arg, 0, NULL));
}


/*
 * '_cupsThreadDetach()' - Tell the OS that the thread is running independently.
 */

void
_cupsThreadDetach(_cups_thread_t thread)/* I - Thread ID */
{
  // TODO: Implement me
  (void)thread;
}


/*
 * '_cupsThreadWait()' - Wait for a thread to exit.
 */

void *					/* O - Return value */
_cupsThreadWait(_cups_thread_t thread)	/* I - Thread ID */
{
  // TODO: Implement me
  (void)thread;

  return (NULL);
}


#else /* No threading */
/*
 * '_cupsCondBroadcast()' - Wake up waiting threads.
 */

void
_cupsCondBroadcast(_cups_cond_t *cond)	/* I - Condition */
{
  // TODO: Implement me
}


/*
 * '_cupsCondInit()' - Initialize a condition variable.
 */

void
_cupsCondInit(_cups_cond_t *cond)	/* I - Condition */
{
  // TODO: Implement me
}


/*
 * '_cupsCondWait()' - Wait for a condition with optional timeout.
 */

void
_cupsCondWait(_cups_cond_t  *cond,	/* I - Condition */
              _cups_mutex_t *mutex,	/* I - Mutex */
	      double        timeout)	/* I - Timeout in seconds (0 or negative for none) */
{
  // TODO: Implement me
}


/*
 * '_cupsMutexInit()' - Initialize a mutex.
 */

void
_cupsMutexInit(_cups_mutex_t *mutex)	/* I - Mutex */
{
  (void)mutex;
}


/*
 * '_cupsMutexLock()' - Lock a mutex.
 */

void
_cupsMutexLock(_cups_mutex_t *mutex)	/* I - Mutex */
{
  (void)mutex;
}


/*
 * '_cupsMutexUnlock()' - Unlock a mutex.
 */

void
_cupsMutexUnlock(_cups_mutex_t *mutex)	/* I - Mutex */
{
  (void)mutex;
}


/*
 * '_cupsRWInit()' - Initialize a reader/writer lock.
 */

void
_cupsRWInit(_cups_rwlock_t *rwlock)	/* I - Reader/writer lock */
{
  (void)rwlock;
}


/*
 * '_cupsRWLockRead()' - Acquire a reader/writer lock for reading.
 */

void
_cupsRWLockRead(_cups_rwlock_t *rwlock)	/* I - Reader/writer lock */
{
  (void)rwlock;
}


/*
 * '_cupsRWLockWrite()' - Acquire a reader/writer lock for writing.
 */

void
_cupsRWLockWrite(_cups_rwlock_t *rwlock)/* I - Reader/writer lock */
{
  (void)rwlock;
}


/*
 * '_cupsRWUnlock()' - Release a reader/writer lock.
 */

void
_cupsRWUnlock(_cups_rwlock_t *rwlock)	/* I - Reader/writer lock */
{
  (void)rwlock;
}


/*
 * '_cupsThreadCancel()' - Cancel (kill) a thread.
 */

void
_cupsThreadCancel(_cups_thread_t thread)/* I - Thread ID */
{
  (void)thread;
}


/*
 * '_cupsThreadCreate()' - Create a thread.
 */

_cups_thread_t				/* O - Thread ID */
_cupsThreadCreate(
    _cups_thread_func_t func,		/* I - Entry point */
    void                *arg)		/* I - Entry point context */
{
  fputs("DEBUG: CUPS was compiled without threading support, no thread created.\n", stderr);

  (void)func;
  (void)arg;

  return (0);
}


/*
 * '_cupsThreadDetach()' - Tell the OS that the thread is running independently.
 */

void
_cupsThreadDetach(_cups_thread_t thread)/* I - Thread ID */
{
  (void)thread;
}


/*
 * '_cupsThreadWait()' - Wait for a thread to exit.
 */

void *					/* O - Return value */
_cupsThreadWait(_cups_thread_t thread)	/* I - Thread ID */
{
  (void)thread;

  return (NULL);
}

#endif /* HAVE_PTHREAD_H */
Commit	Line	Data
c7017ecc	1	/*
6539a0af	2	* Threading primitives for CUPS.
c7017ecc	3	*
13ceaad2	4	* Copyright © 2009-2018 by Apple Inc.
c7017ecc	5	*
13ceaad2 MS	6	* Licensed under Apache License v2.0. See the file "LICENSE" for more
13ceaad2 MS	7	* information.
c7017ecc MS	8	*/
	9
	10	/*
	11	* Include necessary headers...
	12	*/
	13
	14	#include "cups-private.h"
	15	#include "thread-private.h"
	16
	17
	18	#if defined(HAVE_PTHREAD_H)
ad7daa25 MS	19	/*
	20	* '_cupsCondBroadcast()' - Wake up waiting threads.
	21	*/
	22
	23	void
	24	_cupsCondBroadcast(_cups_cond_t cond) / I - Condition */
	25	{
	26	pthread_cond_broadcast(cond);
	27	}
	28
	29
	30	/*
	31	* '_cupsCondInit()' - Initialize a condition variable.
	32	*/
	33
	34	void
	35	_cupsCondInit(_cups_cond_t cond) / I - Condition */
	36	{
	37	pthread_cond_init(cond, NULL);
	38	}
	39
	40
	41	/*
	42	* '_cupsCondWait()' - Wait for a condition with optional timeout.
	43	*/
	44
	45	void
	46	_cupsCondWait(_cups_cond_t cond, / I - Condition */
	47	_cups_mutex_t mutex, / I - Mutex */
	48	double timeout) /* I - Timeout in seconds (0 or negative for none) */
	49	{
	50	if (timeout > 0.0)
	51	{
	52	struct timespec abstime; /* Timeout */
	53
84047a01	54	clock_gettime(CLOCK_REALTIME, &abstime);
13ceaad2	55
84047a01 MS	56	abstime.tv_sec += (long)timeout;
84047a01 MS	57	abstime.tv_nsec += (long)(1000000000 * (timeout - (long)timeout));
13ceaad2 MS	58
	59	while (abstime.tv_nsec >= 1000000000)
	60	{
	61	abstime.tv_nsec -= 1000000000;
	62	abstime.tv_sec ++;
	63	};
ad7daa25 MS	64
	65	pthread_cond_timedwait(cond, mutex, &abstime);
	66	}
	67	else
	68	pthread_cond_wait(cond, mutex);
	69	}
	70
	71
1106b00e MS	72	/*
	73	* '_cupsMutexInit()' - Initialize a mutex.
	74	*/
	75
	76	void
	77	_cupsMutexInit(_cups_mutex_t mutex) / I - Mutex */
	78	{
	79	pthread_mutex_init(mutex, NULL);
	80	}
	81
	82
c7017ecc MS	83	/*
	84	* '_cupsMutexLock()' - Lock a mutex.
	85	*/
	86
	87	void
	88	_cupsMutexLock(_cups_mutex_t mutex) / I - Mutex */
	89	{
	90	pthread_mutex_lock(mutex);
	91	}
	92
	93
	94	/*
	95	* '_cupsMutexUnlock()' - Unlock a mutex.
	96	*/
	97
	98	void
	99	_cupsMutexUnlock(_cups_mutex_t mutex) / I - Mutex */
	100	{
	101	pthread_mutex_unlock(mutex);
	102	}
	103
	104
1106b00e MS	105	/*
	106	* '_cupsRWInit()' - Initialize a reader/writer lock.
	107	*/
	108
	109	void
	110	_cupsRWInit(_cups_rwlock_t rwlock) / I - Reader/writer lock */
	111	{
	112	pthread_rwlock_init(rwlock, NULL);
	113	}
	114
	115
	116	/*
	117	* '_cupsRWLockRead()' - Acquire a reader/writer lock for reading.
	118	*/
	119
	120	void
	121	_cupsRWLockRead(_cups_rwlock_t rwlock) / I - Reader/writer lock */
	122	{
	123	pthread_rwlock_rdlock(rwlock);
	124	}
	125
	126
	127	/*
	128	* '_cupsRWLockWrite()' - Acquire a reader/writer lock for writing.
	129	*/
	130
	131	void
	132	_cupsRWLockWrite(_cups_rwlock_t rwlock)/ I - Reader/writer lock */
	133	{
	134	pthread_rwlock_wrlock(rwlock);
	135	}
	136
	137
	138	/*
	139	* '_cupsRWUnlock()' - Release a reader/writer lock.
	140	*/
	141
	142	void
	143	_cupsRWUnlock(_cups_rwlock_t rwlock) / I - Reader/writer lock */
	144	{
	145	pthread_rwlock_unlock(rwlock);
	146	}
	147
	148
ad7daa25 MS	149	/*
	150	* '_cupsThreadCancel()' - Cancel (kill) a thread.
	151	*/
	152
	153	void
	154	_cupsThreadCancel(_cups_thread_t thread)/* I - Thread ID */
	155	{
	156	pthread_cancel(thread);
	157	}
	158
	159
c7017ecc MS	160	/*
	161	* '_cupsThreadCreate()' - Create a thread.
	162	*/
	163
ad7daa25	164	_cups_thread_t /* O - Thread ID */
c7017ecc MS	165	_cupsThreadCreate(
	166	_cups_thread_func_t func, /* I - Entry point */
	167	void arg) / I - Entry point context */
	168	{
	169	pthread_t thread;
	170
ad7daa25 MS	171	if (pthread_create(&thread, NULL, (void ()(void *))func, arg))
	172	return (0);
	173	else
	174	return (thread);
	175	}
	176
	177
b908d72c MS	178	/*
	179	* '_cupsThreadDetach()' - Tell the OS that the thread is running independently.
	180	*/
	181
	182	void
	183	_cupsThreadDetach(_cups_thread_t thread)/* I - Thread ID */
	184	{
	185	pthread_detach(thread);
	186	}
	187
	188
ad7daa25 MS	189	/*
	190	* '_cupsThreadWait()' - Wait for a thread to exit.
	191	*/
	192
	193	void * /* O - Return value */
	194	_cupsThreadWait(_cups_thread_t thread) /* I - Thread ID */
	195	{
	196	void ret; / Return value */
	197
	198
	199	if (pthread_join(thread, &ret))
	200	return (NULL);
	201	else
	202	return (ret);
c7017ecc MS	203	}
	204
	205
19dc16f7	206	#elif defined(_WIN32)
c7017ecc MS	207	# include <process.h>
	208
	209
aa747d18 MS	210	/*
	211	* '_cupsCondBroadcast()' - Wake up waiting threads.
	212	*/
	213
	214	void
	215	_cupsCondBroadcast(_cups_cond_t cond) / I - Condition */
	216	{
	217	// TODO: Implement me
	218	}
	219
	220
	221	/*
	222	* '_cupsCondInit()' - Initialize a condition variable.
	223	*/
	224
	225	void
	226	_cupsCondInit(_cups_cond_t cond) / I - Condition */
	227	{
	228	// TODO: Implement me
	229	}
	230
	231
	232	/*
	233	* '_cupsCondWait()' - Wait for a condition with optional timeout.
	234	*/
	235
	236	void
	237	_cupsCondWait(_cups_cond_t cond, / I - Condition */
	238	_cups_mutex_t mutex, / I - Mutex */
	239	double timeout) /* I - Timeout in seconds (0 or negative for none) */
	240	{
	241	// TODO: Implement me
	242	}
	243
	244
1106b00e MS	245	/*
	246	* '_cupsMutexInit()' - Initialize a mutex.
	247	*/
	248
	249	void
	250	_cupsMutexInit(_cups_mutex_t mutex) / I - Mutex */
	251	{
	252	InitializeCriticalSection(&mutex->m_criticalSection);
	253	mutex->m_init = 1;
	254	}
	255
	256
c7017ecc MS	257	/*
	258	* '_cupsMutexLock()' - Lock a mutex.
	259	*/
	260
	261	void
	262	_cupsMutexLock(_cups_mutex_t mutex) / I - Mutex */
	263	{
	264	if (!mutex->m_init)
	265	{
	266	_cupsGlobalLock();
	267
	268	if (!mutex->m_init)
	269	{
	270	InitializeCriticalSection(&mutex->m_criticalSection);
	271	mutex->m_init = 1;
	272	}
	273
	274	_cupsGlobalUnlock();
	275	}
	276
	277	EnterCriticalSection(&mutex->m_criticalSection);
	278	}
	279
	280
	281	/*
	282	* '_cupsMutexUnlock()' - Unlock a mutex.
	283	*/
	284
	285	void
	286	_cupsMutexUnlock(_cups_mutex_t mutex) / I - Mutex */
	287	{
	288	LeaveCriticalSection(&mutex->m_criticalSection);
	289	}
	290
	291
1106b00e MS	292	/*
	293	* '_cupsRWInit()' - Initialize a reader/writer lock.
	294	*/
	295
	296	void
	297	_cupsRWInit(_cups_rwlock_t rwlock) / I - Reader/writer lock */
	298	{
	299	_cupsMutexInit((_cups_mutex_t *)rwlock);
	300	}
	301
	302
	303	/*
	304	* '_cupsRWLockRead()' - Acquire a reader/writer lock for reading.
	305	*/
	306
	307	void
	308	_cupsRWLockRead(_cups_rwlock_t rwlock) / I - Reader/writer lock */
	309	{
	310	_cupsMutexLock((_cups_mutex_t *)rwlock);
	311	}
	312
	313
	314	/*
	315	* '_cupsRWLockWrite()' - Acquire a reader/writer lock for writing.
	316	*/
	317
	318	void
	319	_cupsRWLockWrite(_cups_rwlock_t rwlock)/ I - Reader/writer lock */
	320	{
	321	_cupsMutexLock((_cups_mutex_t *)rwlock);
	322	}
	323
	324
	325	/*
	326	* '_cupsRWUnlock()' - Release a reader/writer lock.
	327	*/
	328
	329	void
	330	_cupsRWUnlock(_cups_rwlock_t rwlock) / I - Reader/writer lock */
	331	{
	332	_cupsMutexUnlock((_cups_mutex_t *)rwlock);
	333	}
	334
	335
ad7daa25 MS	336	/*
	337	* '_cupsThreadCancel()' - Cancel (kill) a thread.
	338	*/
	339
	340	void
	341	_cupsThreadCancel(_cups_thread_t thread)/* I - Thread ID */
	342	{
	343	// TODO: Implement me
	344	}
	345
	346
c7017ecc MS	347	/*
	348	* '_cupsThreadCreate()' - Create a thread.
	349	*/
	350
ad7daa25	351	_cups_thread_t /* O - Thread ID */
c7017ecc MS	352	_cupsThreadCreate(
	353	_cups_thread_func_t func, /* I - Entry point */
	354	void arg) / I - Entry point context */
	355	{
ad7daa25 MS	356	return (_beginthreadex(NULL, 0, (LPTHREAD_START_ROUTINE)func, arg, 0, NULL));
	357	}
	358
	359
2d947886 MS	360	/*
	361	* '_cupsThreadDetach()' - Tell the OS that the thread is running independently.
	362	*/
	363
	364	void
	365	_cupsThreadDetach(_cups_thread_t thread)/* I - Thread ID */
	366	{
	367	// TODO: Implement me
	368	(void)thread;
	369	}
	370
	371
ad7daa25 MS	372	/*
	373	* '_cupsThreadWait()' - Wait for a thread to exit.
	374	*/
	375
	376	void * /* O - Return value */
	377	_cupsThreadWait(_cups_thread_t thread) /* I - Thread ID */
	378	{
	379	// TODO: Implement me
26598dba MS	380	(void)thread;
	381
	382	return (NULL);
c7017ecc MS	383	}
	384
	385
aa747d18 MS	386	#else /* No threading */
	387	/*
	388	* '_cupsCondBroadcast()' - Wake up waiting threads.
	389	*/
	390
	391	void
	392	_cupsCondBroadcast(_cups_cond_t cond) / I - Condition */
	393	{
	394	// TODO: Implement me
	395	}
	396
	397
	398	/*
	399	* '_cupsCondInit()' - Initialize a condition variable.
	400	*/
	401
	402	void
	403	_cupsCondInit(_cups_cond_t cond) / I - Condition */
	404	{
	405	// TODO: Implement me
	406	}
	407
	408
	409	/*
	410	* '_cupsCondWait()' - Wait for a condition with optional timeout.
	411	*/
	412
	413	void
	414	_cupsCondWait(_cups_cond_t cond, / I - Condition */
	415	_cups_mutex_t mutex, / I - Mutex */
	416	double timeout) /* I - Timeout in seconds (0 or negative for none) */
	417	{
	418	// TODO: Implement me
	419	}
	420
	421
1106b00e MS	422	/*
	423	* '_cupsMutexInit()' - Initialize a mutex.
	424	*/
	425
	426	void
	427	_cupsMutexInit(_cups_mutex_t mutex) / I - Mutex */
	428	{
	429	(void)mutex;
	430	}
	431
	432
c7017ecc MS	433	/*
	434	* '_cupsMutexLock()' - Lock a mutex.
	435	*/
	436
	437	void
	438	_cupsMutexLock(_cups_mutex_t mutex) / I - Mutex */
	439	{
1106b00e	440	(void)mutex;
c7017ecc MS	441	}
	442
	443
	444	/*
	445	* '_cupsMutexUnlock()' - Unlock a mutex.
	446	*/
	447
	448	void
	449	_cupsMutexUnlock(_cups_mutex_t mutex) / I - Mutex */
	450	{
1106b00e MS	451	(void)mutex;
	452	}
	453
	454
	455	/*
	456	* '_cupsRWInit()' - Initialize a reader/writer lock.
	457	*/
	458
	459	void
	460	_cupsRWInit(_cups_rwlock_t rwlock) / I - Reader/writer lock */
	461	{
	462	(void)rwlock;
	463	}
	464
	465
	466	/*
	467	* '_cupsRWLockRead()' - Acquire a reader/writer lock for reading.
	468	*/
	469
	470	void
	471	_cupsRWLockRead(_cups_rwlock_t rwlock) / I - Reader/writer lock */
	472	{
	473	(void)rwlock;
	474	}
	475
	476
	477	/*
	478	* '_cupsRWLockWrite()' - Acquire a reader/writer lock for writing.
	479	*/
	480
	481	void
	482	_cupsRWLockWrite(_cups_rwlock_t rwlock)/ I - Reader/writer lock */
	483	{
	484	(void)rwlock;
	485	}
	486
	487
	488	/*
	489	* '_cupsRWUnlock()' - Release a reader/writer lock.
	490	*/
	491
	492	void
	493	_cupsRWUnlock(_cups_rwlock_t rwlock) / I - Reader/writer lock */
	494	{
	495	(void)rwlock;
c7017ecc	496	}
f3c17241 MS	497
f3c17241 MS	498
ad7daa25 MS	499	/*
	500	* '_cupsThreadCancel()' - Cancel (kill) a thread.
	501	*/
	502
	503	void
	504	_cupsThreadCancel(_cups_thread_t thread)/* I - Thread ID */
	505	{
	506	(void)thread;
	507	}
	508
	509
f3c17241 MS	510	/*
	511	* '_cupsThreadCreate()' - Create a thread.
	512	*/
	513
ad7daa25	514	_cups_thread_t /* O - Thread ID */
f3c17241 MS	515	_cupsThreadCreate(
	516	_cups_thread_func_t func, /* I - Entry point */
	517	void arg) / I - Entry point context */
	518	{
4d8e89a6	519	fputs("DEBUG: CUPS was compiled without threading support, no thread created.\n", stderr);
f3c17241 MS	520
	521	(void)func;
	522	(void)arg;
	523
	524	return (0);
	525	}
ad7daa25 MS	526
ad7daa25 MS	527
4d8e89a6 MS	528	/*
	529	* '_cupsThreadDetach()' - Tell the OS that the thread is running independently.
	530	*/
	531
	532	void
	533	_cupsThreadDetach(_cups_thread_t thread)/* I - Thread ID */
	534	{
	535	(void)thread;
	536	}
	537
	538
ad7daa25 MS	539	/*
	540	* '_cupsThreadWait()' - Wait for a thread to exit.
	541	*/
	542
	543	void * /* O - Return value */
	544	_cupsThreadWait(_cups_thread_t thread) /* I - Thread ID */
	545	{
	546	(void)thread;
	547
	548	return (NULL);
	549	}
	550
c7017ecc	551	#endif /* HAVE_PTHREAD_H */