~ubuntu-branches/ubuntu/utopic/coreutils/utopic-proposed

/* Implement a trivial subset of POSIX 1003.1-2008 pthread.h.

 

 

   This program is free software; you can redistribute it and/or modify

   it under the terms of the GNU General Public License as published by

#ifndef _@GUARD_PREFIX@_PTHREAD_H_

#define _@GUARD_PREFIX@_PTHREAD_H_

 

#include <errno.h>

#include <sched.h>

#include <sys/types.h>

#include <time.h>

 

#if ! @HAVE_PTHREAD_T@

# if !GNULIB_defined_pthread_types

 typedef int pthread_t;

   know what to do, so that they elicit a compile-time error for

   now.  */

 

pthread_cond_destroy (pthread_cond_t *cond)

{

  /* COND is never seriously used.  */

  return 0;

}

 

pthread_cond_init (pthread_cond_t *restrict cond,

                   pthread_condattr_t const *restrict attr)

{

  return 0;

}

 

pthread_cond_signal (pthread_cond_t *cond)

{

  /* No threads can currently be blocked on COND.  */

  return 0;

}

 

pthread_cond_wait (pthread_cond_t *restrict cond,

                   pthread_mutex_t *restrict mutex)

{

  return 0;

}

 

pthread_create (pthread_t *restrict thread,

                pthread_attr_t const *restrict attr,

                void * (*start_routine) (void*), void *restrict arg)

  return EAGAIN;

}

 

pthread_exit (void *value)

{

  /* There is just one thread, so the process exits.  */

  exit (0);

}

 

pthread_join (pthread_t thread, void **pvalue)

{

  /* Properly-written applications never come here.  */

  return 0;

}

 

pthread_mutexattr_destroy (pthread_mutexattr_t *attr)

{

  return 0;

}

 

pthread_mutexattr_init (pthread_mutexattr_t *attr)

{

  return 0;

}

 

pthread_mutexattr_settype (pthread_mutexattr_t *attr, int attr_type)

{

  return 0;

}

 

pthread_mutex_destroy (pthread_mutex_t *mutex)

{

  /* MUTEX is never seriously used.  */

  return 0;

}

 

pthread_mutex_init (pthread_mutex_t *restrict mutex,

                    pthread_mutexattr_t const *restrict attr)

{

  return 0;

}

 

pthread_mutex_lock (pthread_mutex_t *mutex)

{

  /* There is only one thread, so it always gets the lock.  This

  return 0;

}

 

pthread_mutex_trylock (pthread_mutex_t *mutex)

{

  return pthread_mutex_lock (mutex);

}

 

pthread_mutex_unlock (pthread_mutex_t *mutex)

{

  /* There is only one thread, so it always unlocks successfully.

 

typedef pthread_mutex_t pthread_spinlock_t;

 

pthread_spin_init (pthread_spinlock_t *lock, int pshared)

{

  return pthread_mutex_init (lock, NULL);

}

 

pthread_spin_destroy (pthread_spinlock_t *lock)

{

  return pthread_mutex_destroy (lock);

}

 

pthread_spin_lock (pthread_spinlock_t *lock)

{

  return pthread_mutex_lock (lock);

}

 

pthread_spin_trylock (pthread_spinlock_t *lock)

{

  return pthread_mutex_trylock (lock);

}

 

pthread_spin_unlock (pthread_spinlock_t *lock)

{

  return pthread_mutex_unlock (lock);

 

#endif

 

#endif /* _@GUARD_PREFIX@_PTHREAD_H_ */

#endif /* _@GUARD_PREFIX@_PTHREAD_H_ */