/* Condition variables for multithreading.

   Copyright (C) 2005-2025 Free Software Foundation, Inc.

   This file is free software: you can redistribute it and/or modify

   it under the terms of the GNU Lesser General Public License as

   published by the Free Software Foundation; either version 2.1 of the

   License, or (at your option) any later version.

   This file is distributed in the hope that it will be useful,

   but WITHOUT ANY WARRANTY; without even the implied warranty of

   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

   GNU Lesser General Public License for more details.

   You should have received a copy of the GNU Lesser General Public License

   along with this program.  If not, see <https://www.gnu.org/licenses/>.  */

/* Written by Yoann Vandoorselaere <yoann@prelude-ids.org>, 2008.

   Based on Bruno Haible <bruno@clisp.org> lock.h */

/*

   Condition variables can be used for waiting until a condition

   becomes true. In this respect, they are similar to wait queues. But

   contrary to wait queues, condition variables have different

   semantics that allows events to be lost when there is no thread

   waiting for them.

   Condition variable:

     Type:                gl_cond_t

     Declaration:         gl_cond_define(extern, name)

     Initializer:         gl_cond_define_initialized(, name)

     Initialization:      gl_cond_init (name);

     Waiting:             gl_cond_wait (name, lock);

     Timed wait:          bool timedout = gl_cond_timedwait (name, lock, abstime);

                          where lock is a gl_lock_t variable (cf. <glthread/lock.h>)

     Signaling:           gl_cond_signal (name);

     Broadcasting:        gl_cond_broadcast (name);

     De-initialization:   gl_cond_destroy (name);

   Equivalent functions with control of error handling:

     Initialization:      err = glthread_cond_init (&name);

     Waiting:             err = glthread_cond_wait (&name);

     Timed wait:          err = glthread_cond_timedwait (&name, &lock, abstime);

     Signaling:           err = glthread_cond_signal (&name);

     Broadcasting:        err = glthread_cond_broadcast (&name);

     De-initialization:   err = glthread_cond_destroy (&name);

*/

#ifndef _GLTHREAD_COND_H

#define _GLTHREAD_COND_H

/* This file uses _GL_INLINE_HEADER_BEGIN, _GL_INLINE, HAVE_THREADS_H.  */

#if !_GL_CONFIG_H_INCLUDED

 #error "Please include config.h first."

#endif

#include <errno.h>

#include <stdlib.h>

#include <time.h>

#include "glthread/lock.h"

#if !defined c11_threads_in_use

# if HAVE_THREADS_H && USE_POSIX_THREADS_FROM_LIBC

#  define c11_threads_in_use() 1

# elif HAVE_THREADS_H && USE_POSIX_THREADS_WEAK

#  include <threads.h>

#  pragma weak thrd_exit

#  define c11_threads_in_use() (thrd_exit != NULL)

# else

#  define c11_threads_in_use() 0

# endif

#endif

_GL_INLINE_HEADER_BEGIN

#ifndef _GLTHREAD_COND_INLINE

# define _GLTHREAD_COND_INLINE _GL_INLINE

#endif

/* ========================================================================= */

#if USE_ISOC_THREADS || USE_ISOC_AND_POSIX_THREADS

/* Use the ISO C threads library.  */

# include <threads.h>

# ifdef __cplusplus

extern "C" {

# endif

/* -------------------------- gl_cond_t datatype -------------------------- */

typedef struct

        {

          int volatile init_needed;

          once_flag init_once;

          void (*init_func) (void);

          cnd_t condition;

        }

        gl_cond_t;

# define gl_cond_define(STORAGECLASS, NAME) \

    STORAGECLASS gl_cond_t NAME;

# define gl_cond_define_initialized(STORAGECLASS, NAME) \

    static void _atomic_init_##NAME (void);       \

    STORAGECLASS gl_cond_t NAME =                 \

      { 1, ONCE_FLAG_INIT, _atomic_init_##NAME }; \

    static void _atomic_init_##NAME (void)        \

    {                                             \

      if (glthread_cond_init (&(NAME)))           \

        abort ();                                 \

    }

extern int glthread_cond_init (gl_cond_t *condition);

extern int glthread_cond_wait (gl_cond_t *condition, gl_lock_t *lock);

extern int glthread_cond_timedwait (gl_cond_t *condition, gl_lock_t *lock,

                                    const struct timespec *abstime);

extern int glthread_cond_signal (gl_cond_t *condition);

extern int glthread_cond_broadcast (gl_cond_t *condition);

extern int glthread_cond_destroy (gl_cond_t *condition);

# ifdef __cplusplus

}

# endif

#endif

/* ========================================================================= */

#if USE_POSIX_THREADS

/* Use the POSIX threads library.  */

# include <pthread.h>

# ifdef __cplusplus

extern "C" {

# endif

# if PTHREAD_IN_USE_DETECTION_HARD

/* The pthread_in_use() detection needs to be done at runtime.  */

#  define pthread_in_use() \

     glthread_in_use ()

extern int glthread_in_use (void);

# endif

# if USE_POSIX_THREADS_WEAK

/* Use weak references to the POSIX threads library.  */

/* Weak references avoid dragging in external libraries if the other parts

   of the program don't use them.  Here we use them, because we don't want

   every program that uses libintl to depend on libpthread.  This assumes

   that libpthread would not be loaded after libintl; i.e. if libintl is

   loaded first, by an executable that does not depend on libpthread, and

   then a module is dynamically loaded that depends on libpthread, libintl

   will not be multithread-safe.  */

/* The way to test at runtime whether libpthread is present is to test

   whether a function pointer's value, such as &pthread_mutex_init, is

   non-NULL.  However, some versions of GCC have a bug through which, in

   PIC mode, &foo != NULL always evaluates to true if there is a direct

   call to foo(...) in the same function.  To avoid this, we test the

   address of a function in libpthread that we don't use.  */

#  pragma weak pthread_cond_init

#  pragma weak pthread_cond_wait

#  pragma weak pthread_cond_timedwait

#  pragma weak pthread_cond_signal

#  pragma weak pthread_cond_broadcast

#  pragma weak pthread_cond_destroy

#  ifndef pthread_self

#   pragma weak pthread_self

#  endif

#  if !PTHREAD_IN_USE_DETECTION_HARD

#   pragma weak pthread_mutexattr_gettype

#   define pthread_in_use() \

      (pthread_mutexattr_gettype != NULL || c11_threads_in_use ())

#  endif

# else

#  if !PTHREAD_IN_USE_DETECTION_HARD

#   define pthread_in_use() 1

#  endif

# endif

/* -------------------------- gl_cond_t datatype -------------------------- */

typedef pthread_cond_t gl_cond_t;

# define gl_cond_define(STORAGECLASS, NAME) \

    STORAGECLASS gl_cond_t NAME;

# define gl_cond_define_initialized(STORAGECLASS, NAME) \

    STORAGECLASS gl_cond_t NAME = gl_cond_initializer;

# define gl_cond_initializer \

    PTHREAD_COND_INITIALIZER

# define glthread_cond_init(COND) \

    (pthread_in_use () ? pthread_cond_init (COND, NULL) : 0)

# define glthread_cond_wait(COND, LOCK) \

    (pthread_in_use () ? pthread_cond_wait (COND, LOCK) : 0)

# define glthread_cond_timedwait(COND, LOCK, ABSTIME) \

    (pthread_in_use () ? pthread_cond_timedwait (COND, LOCK, ABSTIME) : 0)

# define glthread_cond_signal(COND) \

    (pthread_in_use () ? pthread_cond_signal (COND) : 0)

# define glthread_cond_broadcast(COND) \

    (pthread_in_use () ? pthread_cond_broadcast (COND) : 0)

# define glthread_cond_destroy(COND) \

    (pthread_in_use () ? pthread_cond_destroy (COND) : 0)

# ifdef __cplusplus

}

# endif

#endif

/* ========================================================================= */

#if USE_WINDOWS_THREADS

# define WIN32_LEAN_AND_MEAN  /* avoid including junk */

# include <windows.h>

# include "windows-cond.h"

# ifdef __cplusplus

extern "C" {

# endif

/* -------------------------- gl_cond_t datatype -------------------------- */

typedef glwthread_cond_t gl_cond_t;

# define gl_cond_define(STORAGECLASS, NAME) \

    STORAGECLASS gl_cond_t NAME;

# define gl_cond_define_initialized(STORAGECLASS, NAME) \

    STORAGECLASS gl_cond_t NAME = gl_cond_initializer;

# define gl_cond_initializer \

    GLWTHREAD_COND_INIT

# define glthread_cond_init(COND) \

    glwthread_cond_init (COND)

# define glthread_cond_wait(COND, LOCK) \

    glwthread_cond_wait (COND, LOCK, \

                         (int (*) (void *)) glwthread_mutex_lock, \

                         (int (*) (void *)) glwthread_mutex_unlock)

# define glthread_cond_timedwait(COND, LOCK, ABSTIME) \

    glwthread_cond_timedwait (COND, LOCK, \

                              (int (*) (void *)) glwthread_mutex_lock, \

                              (int (*) (void *)) glwthread_mutex_unlock, \

                              ABSTIME)

# define glthread_cond_signal(COND) \

    glwthread_cond_signal (COND)

# define glthread_cond_broadcast(COND) \

    glwthread_cond_broadcast (COND)

# define glthread_cond_destroy(COND) \

    glwthread_cond_destroy (COND)

# ifdef __cplusplus

}

# endif

#endif

/* ========================================================================= */

#if !(USE_ISOC_THREADS || USE_POSIX_THREADS || USE_ISOC_AND_POSIX_THREADS || USE_WINDOWS_THREADS)

/* Provide dummy implementation if threads are not supported.  */

typedef int gl_cond_t;

# define gl_cond_define(STORAGECLASS, NAME)

# define gl_cond_define_initialized(STORAGECLASS, NAME)

# define glthread_cond_init(COND) 0

# define glthread_cond_wait(COND, LOCK) 0

# define glthread_cond_timedwait(COND, LOCK, ABSTIME) 0

# define glthread_cond_signal(COND) 0

# define glthread_cond_broadcast(COND) 0

# define glthread_cond_destroy(COND) 0

#endif

/* ========================================================================= */

/* Macros with built-in error handling.  */

#ifdef __cplusplus

extern "C" {

#endif

#define gl_cond_init(COND)             \

   do                                  \

     {                                 \

       if (glthread_cond_init (&COND)) \

         abort ();                     \

     }                                 \

   while (0)

#define gl_cond_wait(COND, LOCK)              \

   do                                         \

     {                                        \

       if (glthread_cond_wait (&COND, &LOCK)) \

         abort ();                            \

     }                                        \

   while (0)

#define gl_cond_timedwait(COND, LOCK, ABSTIME) \

  gl_cond_timedwait_func (&COND, &LOCK, ABSTIME)

_GLTHREAD_COND_INLINE bool

gl_cond_timedwait_func (gl_cond_t *cond, gl_lock_t *lock, struct timespec *abstime)

{

  int err = glthread_cond_timedwait (cond, lock, abstime);

  if (err == ETIMEDOUT)

    return true;

  if (err != 0)

    abort ();

  return false;

}

#define gl_cond_signal(COND)             \

   do                                    \

     {                                   \

       if (glthread_cond_signal (&COND)) \

         abort ();                       \

     }                                   \

   while (0)

#define gl_cond_broadcast(COND)             \

   do                                       \

     {                                      \

       if (glthread_cond_broadcast (&COND)) \

         abort ();                          \

     }                                      \

   while (0)

#define gl_cond_destroy(COND)             \

   do                                     \

     {                                    \

       if (glthread_cond_destroy (&COND)) \

         abort ();                        \

     }                                    \

   while (0)

#ifdef __cplusplus

}

#endif

_GL_INLINE_HEADER_END

#endif /* _GLTHREAD_COND_H */