gmain.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * gmain.c: Main loop abstraction, timeouts, and idle functions
   5  * Copyright 1998 Owen Taylor
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 /*
  24  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
  25  * file for a list of people on the GLib Team.  See the ChangeLog
  26  * files for a list of changes.  These files are distributed with
  27  * GLib at ftp://ftp.gtk.org/pub/gtk/.
  28  */
  29
  30 /*
  31  * MT safe
  32  */
  33
  34 #include "config.h"
  35
  36 /* uncomment the next line to get poll() debugging info */
  37 /* #define G_MAIN_POLL_DEBUG */
  38
  39 #include "glib.h"
  40 #include <sys/types.h>
  41 #include <time.h>
  42 #ifdef HAVE_SYS_TIME_H
  43 #include <sys/time.h>
  44 #endif /* HAVE_SYS_TIME_H */
  45 #ifdef GLIB_HAVE_SYS_POLL_H
  46 #  include <sys/poll.h>
  47 #  undef events  /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
  48 #  undef revents /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
  49 #endif /* GLIB_HAVE_SYS_POLL_H */
  50 #ifdef HAVE_UNISTD_H
  51 #include <unistd.h>
  52 #endif /* HAVE_UNISTD_H */
  53 #include <errno.h>
  54
  55 #ifdef G_OS_WIN32
  56 #define STRICT
  57 #include <windows.h>
  58 #endif /* G_OS_WIN32 */
  59
  60 #ifdef G_OS_BEOS
  61 #include <net/socket.h>
  62 #endif /* G_OS_BEOS */
  63
  64 /* Types */
  65
  66 typedef struct _GTimeoutData GTimeoutData;
  67 typedef struct _GSource GSource;
  68 typedef struct _GPollRec GPollRec;
  69
  70 typedef enum
  71 {
  72   G_SOURCE_READY = 1 << G_HOOK_FLAG_USER_SHIFT,
  73   G_SOURCE_CAN_RECURSE = 1 << (G_HOOK_FLAG_USER_SHIFT + 1)
  74 } GSourceFlags;
  75
  76 struct _GSource
  77 {
  78   GHook hook;
  79   gint priority;
  80   gpointer source_data;
  81 };
  82
  83 struct _GMainLoop
  84 {
  85   gboolean is_running;
  86 };
  87
  88 struct _GTimeoutData
  89 {
  90   GTimeVal    expiration;
  91   gint        interval;
  92   GSourceFunc callback;
  93 };
  94
  95 struct _GPollRec
  96 {
  97   gint priority;
  98   GPollFD *fd;
  99   GPollRec *next;
 100 };
 101
 102 /* Forward declarations */
 103
 104 static gint     g_source_compare          (GHook      *a,
 105                                            GHook      *b);
 106 static void     g_source_destroy_func     (GHookList  *hook_list,
 107                                            GHook      *hook);
 108 static void     g_main_poll               (gint      timeout,
 109                                            gboolean  use_priority,
 110                                            gint      priority);
 111 static void     g_main_add_poll_unlocked  (gint      priority,
 112                                            GPollFD  *fd);
 113 static void     g_main_wakeup             (void);
 114
 115 static gboolean g_timeout_prepare      (gpointer  source_data,
 116                                         GTimeVal *current_time,
 117                                         gint     *timeout,
 118                                         gpointer  user_data);
 119 static gboolean g_timeout_check        (gpointer  source_data,
 120                                         GTimeVal *current_time,
 121                                         gpointer  user_data);
 122 static gboolean g_timeout_dispatch     (gpointer  source_data,
 123                                         GTimeVal *dispatch_time,
 124                                         gpointer  user_data);
 125 static gboolean g_idle_prepare         (gpointer  source_data,
 126                                         GTimeVal *current_time,
 127                                         gint     *timeout,
 128                                         gpointer  user_data);
 129 static gboolean g_idle_check           (gpointer  source_data,
 130                                         GTimeVal *current_time,
 131                                         gpointer  user_data);
 132 static gboolean g_idle_dispatch        (gpointer  source_data,
 133                                         GTimeVal *dispatch_time,
 134                                         gpointer  user_data);
 135
 136 /* Data */
 137
 138 static GSList *pending_dispatches = NULL;
 139 static GHookList source_list = { 0 };
 140 static gint in_check_or_prepare = 0;
 141
 142 /* The following lock is used for both the list of sources
 143  * and the list of poll records
 144  */
 145 G_LOCK_DEFINE_STATIC (main_loop);
 146
 147 static GSourceFuncs timeout_funcs =
 148 {
 149   g_timeout_prepare,
 150   g_timeout_check,
 151   g_timeout_dispatch,
 152   g_free,
 153 };
 154
 155 static GSourceFuncs idle_funcs =
 156 {
 157   g_idle_prepare,
 158   g_idle_check,
 159   g_idle_dispatch,
 160   NULL,
 161 };
 162
 163 static GPollRec *poll_records = NULL;
 164 static GPollRec *poll_free_list = NULL;
 165 static GMemChunk *poll_chunk;
 166 static guint n_poll_records = 0;
 167
 168 #ifdef G_THREADS_ENABLED
 169 #ifndef G_OS_WIN32
 170 /* this pipe is used to wake up the main loop when a source is added.
 171  */
 172 static gint wake_up_pipe[2] = { -1, -1 };
 173 #else /* G_OS_WIN32 */
 174 static HANDLE wake_up_semaphore = NULL;
 175 #endif /* G_OS_WIN32 */
 176 static GPollFD wake_up_rec;
 177 static gboolean poll_waiting = FALSE;
 178
 179 /* Flag indicating whether the set of fd's changed during a poll */
 180 static gboolean poll_changed = FALSE;
 181 #endif /* G_THREADS_ENABLED */
 182
 183 #ifdef HAVE_POLL
 184 /* SunOS has poll, but doesn't provide a prototype. */
 185 #  if defined (sun) && !defined (__SVR4)
 186 extern gint poll (GPollFD *ufds, guint nfsd, gint timeout);
 187 #  endif  /* !sun */
 188 static GPollFunc poll_func = (GPollFunc) poll;
 189 #else   /* !HAVE_POLL */
 190 #ifdef G_OS_WIN32
 191
 192 static gint
 193 g_poll (GPollFD *fds,
 194         guint    nfds,
 195         gint     timeout)
 196 {
 197   HANDLE handles[MAXIMUM_WAIT_OBJECTS];
 198   gboolean poll_msgs = FALSE;
 199   GPollFD *f;
 200   DWORD ready;
 201   MSG msg;
 202   UINT timer;
 203   gint nhandles = 0;
 204
 205   for (f = fds; f < &fds[nfds]; ++f)
 206     if (f->fd >= 0)
 207       {
 208         if (f->events & G_IO_IN)
 209           {
 210             if (f->fd == G_WIN32_MSG_HANDLE)
 211               poll_msgs = TRUE;
 212             else
 213               {
 214 #ifdef G_MAIN_POLL_DEBUG
 215                 g_print ("g_poll: waiting for %#x\n", f->fd);
 216 #endif
 217                 handles[nhandles++] = (HANDLE) f->fd;
 218               }
 219           }
 220       }
 221
 222   if (timeout == -1)
 223     timeout = INFINITE;
 224
 225   if (poll_msgs)
 226     {
 227       /* Waiting for messages, and maybe events */
 228       if (nhandles == 0)
 229         {
 230           if (timeout == INFINITE)
 231             {
 232               /* Waiting just for messages, infinite timeout
 233                * -> Use PeekMessage, then WaitMessage
 234                */
 235 #ifdef G_MAIN_POLL_DEBUG
 236               g_print ("PeekMessage, then WaitMessage\n");
 237 #endif
 238               if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
 239                 ready = WAIT_OBJECT_0;
 240               else if (!WaitMessage ())
 241                 g_warning ("g_poll: WaitMessage failed");
 242               ready = WAIT_OBJECT_0;
 243             }
 244           else if (timeout == 0)
 245             {
 246               /* Waiting just for messages, zero timeout
 247                * -> Use PeekMessage
 248                */
 249 #ifdef G_MAIN_POLL_DEBUG
 250               g_print ("PeekMessage\n");
 251 #endif
 252               if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
 253                 ready = WAIT_OBJECT_0;
 254               else
 255                 ready = WAIT_TIMEOUT;
 256             }
 257           else
 258             {
 259               /* Waiting just for messages, some timeout
 260                * -> First try PeekMessage, then set a timer, wait for message,
 261                * kill timer, use PeekMessage
 262                */
 263 #ifdef G_MAIN_POLL_DEBUG
 264               g_print ("PeekMessage\n");
 265 #endif
 266               if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
 267                 ready = WAIT_OBJECT_0;
 268               else if ((timer = SetTimer (NULL, 0, timeout, NULL)) == 0)
 269                 g_warning ("g_poll: SetTimer failed");
 270               else
 271                 {
 272 #ifdef G_MAIN_POLL_DEBUG
 273                   g_print ("WaitMessage\n");
 274 #endif
 275                   WaitMessage ();
 276                   KillTimer (NULL, timer);
 277                   if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE)
 278                       && msg.message != WM_TIMER)
 279                     ready = WAIT_OBJECT_0;
 280                   else
 281                     ready = WAIT_TIMEOUT;
 282                 }
 283             }
 284         }
 285       else
 286         {
 287           /* Wait for either message or event
 288            * -> Use MsgWaitForMultipleObjects
 289            */
 290 #ifdef G_MAIN_POLL_DEBUG
 291           g_print ("MsgWaitForMultipleObjects(%d, %d)\n", nhandles, timeout);
 292 #endif
 293           ready = MsgWaitForMultipleObjects (nhandles, handles, FALSE,
 294                                              timeout, QS_ALLINPUT);
 295
 296           if (ready == WAIT_FAILED)
 297             g_warning ("g_poll: MsgWaitForMultipleObjects failed");
 298         }
 299     }
 300   else if (nhandles == 0)
 301     {
 302       /* Wait for nothing (huh?) */
 303       return 0;
 304     }
 305   else
 306     {
 307       /* Wait for just events
 308        * -> Use WaitForMultipleObjects
 309        */
 310 #ifdef G_MAIN_POLL_DEBUG
 311       g_print ("WaitForMultipleObjects(%d, %d)\n", nhandles, timeout);
 312 #endif
 313       ready = WaitForMultipleObjects (nhandles, handles, FALSE, timeout);
 314       if (ready == WAIT_FAILED)
 315         g_warning ("g_poll: WaitForMultipleObjects failed");
 316     }
 317
 318   for (f = fds; f < &fds[nfds]; ++f)
 319     f->revents = 0;
 320
 321   if (ready == WAIT_FAILED)
 322     return -1;
 323   else if (ready == WAIT_TIMEOUT)
 324     return 0;
 325   else if (poll_msgs && ready == WAIT_OBJECT_0 + nhandles)
 326     {
 327       for (f = fds; f < &fds[nfds]; ++f)
 328         if (f->fd >= 0)
 329           {
 330             if (f->events & G_IO_IN)
 331               if (f->fd == G_WIN32_MSG_HANDLE)
 332                 f->revents |= G_IO_IN;
 333           }
 334     }
 335   else if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles)
 336     for (f = fds; f < &fds[nfds]; ++f)
 337       {
 338         if ((f->events & G_IO_IN)
 339             && f->fd == (gint) handles[ready - WAIT_OBJECT_0])
 340           {
 341             f->revents |= G_IO_IN;
 342 #ifdef G_MAIN_POLL_DEBUG
 343             g_print ("g_poll: got event %#x\n", f->fd);
 344 #endif
 345 #if 0
 346             ResetEvent ((HANDLE) f->fd);
 347 #endif
 348           }
 349       }
 350
 351   if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles)
 352     return ready - WAIT_OBJECT_0 + 1;
 353   else
 354     return 0;
 355 }
 356
 357 #else  /* !G_OS_WIN32 */
 358
 359 /* The following implementation of poll() comes from the GNU C Library.
 360  * Copyright (C) 1994, 1996, 1997 Free Software Foundation, Inc.
 361  */
 362
 363 #include <string.h> /* for bzero on BSD systems */
 364
 365 #ifdef HAVE_SYS_SELECT_H
 366 #include <sys/select.h>
 367 #endif /* HAVE_SYS_SELECT_H */
 368
 369 #ifdef G_OS_BEOS
 370 #undef NO_FD_SET
 371 #endif /* G_OS_BEOS */
 372
 373 #ifndef NO_FD_SET
 374 #  define SELECT_MASK fd_set
 375 #else /* !NO_FD_SET */
 376 #  ifndef _AIX
 377 typedef long fd_mask;
 378 #  endif /* _AIX */
 379 #  ifdef _IBMR2
 380 #    define SELECT_MASK void
 381 #  else /* !_IBMR2 */
 382 #    define SELECT_MASK int
 383 #  endif /* !_IBMR2 */
 384 #endif /* !NO_FD_SET */
 385
 386 static gint
 387 g_poll (GPollFD *fds,
 388         guint    nfds,
 389         gint     timeout)
 390 {
 391   struct timeval tv;
 392   SELECT_MASK rset, wset, xset;
 393   GPollFD *f;
 394   int ready;
 395   int maxfd = 0;
 396
 397   FD_ZERO (&rset);
 398   FD_ZERO (&wset);
 399   FD_ZERO (&xset);
 400
 401   for (f = fds; f < &fds[nfds]; ++f)
 402     if (f->fd >= 0)
 403       {
 404         if (f->events & G_IO_IN)
 405           FD_SET (f->fd, &rset);
 406         if (f->events & G_IO_OUT)
 407           FD_SET (f->fd, &wset);
 408         if (f->events & G_IO_PRI)
 409           FD_SET (f->fd, &xset);
 410         if (f->fd > maxfd && (f->events & (G_IO_IN|G_IO_OUT|G_IO_PRI)))
 411           maxfd = f->fd;
 412       }
 413
 414   tv.tv_sec = timeout / 1000;
 415   tv.tv_usec = (timeout % 1000) * 1000;
 416
 417   ready = select (maxfd + 1, &rset, &wset, &xset,
 418                   timeout == -1 ? NULL : &tv);
 419   if (ready > 0)
 420     for (f = fds; f < &fds[nfds]; ++f)
 421       {
 422         f->revents = 0;
 423         if (f->fd >= 0)
 424           {
 425             if (FD_ISSET (f->fd, &rset))
 426               f->revents |= G_IO_IN;
 427             if (FD_ISSET (f->fd, &wset))
 428               f->revents |= G_IO_OUT;
 429             if (FD_ISSET (f->fd, &xset))
 430               f->revents |= G_IO_PRI;
 431           }
 432       }
 433
 434   return ready;
 435 }
 436
 437 #endif /* !G_OS_WIN32 */
 438
 439 static GPollFunc poll_func = g_poll;
 440 #endif  /* !HAVE_POLL */
 441
 442 /* Hooks for adding to the main loop */
 443
 444 /* Use knowledge of insert_sorted algorithm here to make
 445  * sure we insert at the end of equal priority items
 446  */
 447 static gint
 448 g_source_compare (GHook *a,
 449                   GHook *b)
 450 {
 451   GSource *source_a = (GSource *)a;
 452   GSource *source_b = (GSource *)b;
 453
 454   return (source_a->priority < source_b->priority) ? -1 : 1;
 455 }
 456
 457 /* HOLDS: main_loop lock */
 458 static void
 459 g_source_destroy_func (GHookList *hook_list,
 460                        GHook     *hook)
 461 {
 462   GSource *source = (GSource*) hook;
 463   GDestroyNotify destroy;
 464
 465   G_UNLOCK (main_loop);
 466
 467   destroy = hook->destroy;
 468   if (destroy)
 469     destroy (hook->data);
 470
 471   destroy = ((GSourceFuncs*) hook->func)->destroy;
 472   if (destroy)
 473     destroy (source->source_data);
 474
 475   G_LOCK (main_loop);
 476 }
 477
 478 guint
 479 g_source_add (gint           priority,
 480               gboolean       can_recurse,
 481               GSourceFuncs  *funcs,
 482               gpointer       source_data,
 483               gpointer       user_data,
 484               GDestroyNotify notify)
 485 {
 486   guint return_val;
 487   GSource *source;
 488
 489   G_LOCK (main_loop);
 490
 491   if (!source_list.is_setup)
 492     {
 493       g_hook_list_init (&source_list, sizeof (GSource));
 494
 495       source_list.hook_destroy = G_HOOK_DEFERRED_DESTROY;
 496       source_list.hook_free = g_source_destroy_func;
 497     }
 498
 499   source = (GSource*) g_hook_alloc (&source_list);
 500   source->priority = priority;
 501   source->source_data = source_data;
 502   source->hook.func = funcs;
 503   source->hook.data = user_data;
 504   source->hook.destroy = notify;
 505
 506   g_hook_insert_sorted (&source_list,
 507                         (GHook *)source,
 508                         g_source_compare);
 509
 510   if (can_recurse)
 511     source->hook.flags |= G_SOURCE_CAN_RECURSE;
 512
 513   return_val = source->hook.hook_id;
 514
 515 #ifdef G_THREADS_ENABLED
 516   /* Now wake up the main loop if it is waiting in the poll() */
 517   g_main_wakeup ();
 518 #endif
 519
 520   G_UNLOCK (main_loop);
 521
 522   return return_val;
 523 }
 524
 525 gboolean
 526 g_source_remove (guint tag)
 527 {
 528   GHook *hook;
 529
 530   g_return_val_if_fail (tag > 0, FALSE);
 531
 532   G_LOCK (main_loop);
 533
 534   hook = g_hook_get (&source_list, tag);
 535   if (hook)
 536     g_hook_destroy_link (&source_list, hook);
 537
 538   G_UNLOCK (main_loop);
 539
 540   return hook != NULL;
 541 }
 542
 543 gboolean
 544 g_source_remove_by_user_data (gpointer user_data)
 545 {
 546   GHook *hook;
 547
 548   G_LOCK (main_loop);
 549
 550   hook = g_hook_find_data (&source_list, TRUE, user_data);
 551   if (hook)
 552     g_hook_destroy_link (&source_list, hook);
 553
 554   G_UNLOCK (main_loop);
 555
 556   return hook != NULL;
 557 }
 558
 559 static gboolean
 560 g_source_find_source_data (GHook        *hook,
 561                            gpointer      data)
 562 {
 563   GSource *source = (GSource *)hook;
 564
 565   return (source->source_data == data);
 566 }
 567
 568 gboolean
 569 g_source_remove_by_source_data (gpointer source_data)
 570 {
 571   GHook *hook;
 572
 573   G_LOCK (main_loop);
 574
 575   hook = g_hook_find (&source_list, TRUE,
 576                       g_source_find_source_data, source_data);
 577   if (hook)
 578     g_hook_destroy_link (&source_list, hook);
 579
 580   G_UNLOCK (main_loop);
 581
 582   return hook != NULL;
 583 }
 584
 585 static gboolean
 586 g_source_find_funcs_user_data (GHook   *hook,
 587                                gpointer data)
 588 {
 589   gpointer *d = data;
 590
 591   return hook->func == d[0] && hook->data == d[1];
 592 }
 593
 594 gboolean
 595 g_source_remove_by_funcs_user_data (GSourceFuncs *funcs,
 596                                     gpointer      user_data)
 597 {
 598   gpointer d[2];
 599   GHook *hook;
 600
 601   g_return_val_if_fail (funcs != NULL, FALSE);
 602
 603   G_LOCK (main_loop);
 604
 605   d[0] = funcs;
 606   d[1] = user_data;
 607
 608   hook = g_hook_find (&source_list, TRUE,
 609                       g_source_find_funcs_user_data, d);
 610   if (hook)
 611     g_hook_destroy_link (&source_list, hook);
 612
 613   G_UNLOCK (main_loop);
 614
 615   return hook != NULL;
 616 }
 617
 618 void
 619 g_get_current_time (GTimeVal *result)
 620 {
 621 #ifndef G_OS_WIN32
 622   struct timeval r;
 623
 624   g_return_if_fail (result != NULL);
 625
 626   /*this is required on alpha, there the timeval structs are int's
 627     not longs and a cast only would fail horribly*/
 628   gettimeofday (&r, NULL);
 629   result->tv_sec = r.tv_sec;
 630   result->tv_usec = r.tv_usec;
 631 #else
 632   FILETIME filetime;
 633   gint64 t;
 634
 635   g_return_if_fail (result != NULL);
 636
 637   GetSystemTimeAsFileTime (&filetime);
 638   t = ((gint64) filetime.dwLowDateTime) +
 639     ((gint64) filetime.dwHighDateTime) * G_GINT64_CONSTANT (0x100000000);
 640
 641   result->tv_sec = (t - G_GINT64_CONSTANT (0x19db1ded53e8000)) / 10000000;
 642   result->tv_usec = (t % 10000000) / 10;
 643 #endif
 644 }
 645
 646 /* Running the main loop */
 647
 648 /* HOLDS: main_loop_lock */
 649 static void
 650 g_main_dispatch (GTimeVal *dispatch_time)
 651 {
 652   while (pending_dispatches != NULL)
 653     {
 654       gboolean need_destroy;
 655       GSource *source = pending_dispatches->data;
 656       GSList *tmp_list;
 657
 658       tmp_list = pending_dispatches;
 659       pending_dispatches = g_slist_remove_link (pending_dispatches, pending_dispatches);
 660       g_slist_free_1 (tmp_list);
 661
 662       if (G_HOOK_IS_VALID (source))
 663         {
 664           gboolean was_in_call;
 665           gpointer hook_data = source->hook.data;
 666           gpointer source_data = source->source_data;
 667           gboolean (*dispatch) (gpointer,
 668                                 GTimeVal *,
 669                                 gpointer);
 670
 671           dispatch = ((GSourceFuncs *) source->hook.func)->dispatch;
 672
 673           was_in_call = G_HOOK_IN_CALL (source);
 674           source->hook.flags |= G_HOOK_FLAG_IN_CALL;
 675
 676           G_UNLOCK (main_loop);
 677           need_destroy = ! dispatch (source_data,
 678                                      dispatch_time,
 679                                      hook_data);
 680           G_LOCK (main_loop);
 681
 682           if (!was_in_call)
 683             source->hook.flags &= ~G_HOOK_FLAG_IN_CALL;
 684
 685           if (need_destroy && G_HOOK_IS_VALID (source))
 686             g_hook_destroy_link (&source_list, (GHook *) source);
 687         }
 688
 689       g_hook_unref (&source_list, (GHook*) source);
 690     }
 691 }
 692
 693 /* g_main_iterate () runs a single iteration of the mainloop, or,
 694  * if !dispatch checks to see if any sources need dispatching.
 695  * basic algorithm for dispatch=TRUE:
 696  *
 697  * 1) while the list of currently pending sources is non-empty,
 698  *    we call (*dispatch) on those that are !IN_CALL or can_recurse,
 699  *    removing sources from the list after each returns.
 700  *    the return value of (*dispatch) determines whether the source
 701  *    itself is kept alive.
 702  *
 703  * 2) call (*prepare) for sources that are not yet SOURCE_READY and
 704  *    are !IN_CALL or can_recurse. a return value of TRUE determines
 705  *    that the source would like to be dispatched immediatedly, it
 706  *    is then flagged as SOURCE_READY.
 707  *
 708  * 3) poll with the pollfds from all sources at the priority of the
 709  *    first source flagged as SOURCE_READY. if there are any sources
 710  *    flagged as SOURCE_READY, we use a timeout of 0 or the minimum
 711  *    of all timouts otherwise.
 712  *
 713  * 4) for each source !IN_CALL or can_recurse, if SOURCE_READY or
 714  *    (*check) returns true, add the source to the pending list.
 715  *    once one source returns true, stop after checking all sources
 716  *    at that priority.
 717  *
 718  * 5) while the list of currently pending sources is non-empty,
 719  *    call (*dispatch) on each source, removing the source
 720  *    after the call.
 721  *
 722  */
 723 static gboolean
 724 g_main_iterate (gboolean block,
 725                 gboolean dispatch)
 726 {
 727   GHook *hook;
 728   GTimeVal current_time  = { 0, 0 };
 729   gint n_ready = 0;
 730   gint current_priority = 0;
 731   gint timeout;
 732   gboolean retval = FALSE;
 733
 734   g_return_val_if_fail (!block || dispatch, FALSE);
 735
 736   g_get_current_time (&current_time);
 737
 738   G_LOCK (main_loop);
 739
 740 #ifdef G_THREADS_ENABLED
 741   if (poll_waiting)
 742     {
 743       g_warning("g_main_iterate(): main loop already active in another thread");
 744       G_UNLOCK (main_loop);
 745       return FALSE;
 746     }
 747 #endif G_THREADS_ENABLED
 748
 749   /* If recursing, finish up current dispatch, before starting over */
 750   if (pending_dispatches)
 751     {
 752       if (dispatch)
 753         g_main_dispatch (&current_time);
 754
 755       G_UNLOCK (main_loop);
 756
 757       return TRUE;
 758     }
 759
 760   /* Prepare all sources */
 761
 762   timeout = block ? -1 : 0;
 763
 764   hook = g_hook_first_valid (&source_list, TRUE);
 765   while (hook)
 766     {
 767       GSource *source = (GSource*) hook;
 768       gint source_timeout = -1;
 769
 770       if ((n_ready > 0) && (source->priority > current_priority))
 771         {
 772           g_hook_unref (&source_list, hook);
 773           break;
 774         }
 775       if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
 776         {
 777           hook = g_hook_next_valid (&source_list, hook, TRUE);
 778           continue;
 779         }
 780
 781       if (!(hook->flags & G_SOURCE_READY))
 782         {
 783           gboolean (*prepare)  (gpointer  source_data,
 784                                 GTimeVal *current_time,
 785                                 gint     *timeout,
 786                                 gpointer  user_data);
 787
 788           prepare = ((GSourceFuncs *) hook->func)->prepare;
 789           in_check_or_prepare++;
 790           G_UNLOCK (main_loop);
 791
 792           if ((*prepare) (source->source_data, &current_time, &source_timeout, source->hook.data))
 793             hook->flags |= G_SOURCE_READY;
 794
 795           G_LOCK (main_loop);
 796           in_check_or_prepare--;
 797         }
 798
 799       if (hook->flags & G_SOURCE_READY)
 800         {
 801           if (!dispatch)
 802             {
 803               g_hook_unref (&source_list, hook);
 804               G_UNLOCK (main_loop);
 805
 806               return TRUE;
 807             }
 808           else
 809             {
 810               n_ready++;
 811               current_priority = source->priority;
 812               timeout = 0;
 813             }
 814         }
 815
 816       if (source_timeout >= 0)
 817         {
 818           if (timeout < 0)
 819             timeout = source_timeout;
 820           else
 821             timeout = MIN (timeout, source_timeout);
 822         }
 823
 824       hook = g_hook_next_valid (&source_list, hook, TRUE);
 825     }
 826
 827   /* poll(), if necessary */
 828
 829   g_main_poll (timeout, n_ready > 0, current_priority);
 830
 831   if (timeout != 0)
 832     g_get_current_time (&current_time);
 833
 834   /* Check to see what sources need to be dispatched */
 835
 836   n_ready = 0;
 837
 838   hook = g_hook_first_valid (&source_list, TRUE);
 839   while (hook)
 840     {
 841       GSource *source = (GSource *)hook;
 842
 843       if ((n_ready > 0) && (source->priority > current_priority))
 844         {
 845           g_hook_unref (&source_list, hook);
 846           break;
 847         }
 848       if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
 849         {
 850           hook = g_hook_next_valid (&source_list, hook, TRUE);
 851           continue;
 852         }
 853
 854       if (!(hook->flags & G_SOURCE_READY))
 855         {
 856           gboolean (*check) (gpointer  source_data,
 857                              GTimeVal *current_time,
 858                              gpointer  user_data);
 859
 860           check = ((GSourceFuncs *) hook->func)->check;
 861           in_check_or_prepare++;
 862           G_UNLOCK (main_loop);
 863
 864           if ((*check) (source->source_data, &current_time, source->hook.data))
 865             hook->flags |= G_SOURCE_READY;
 866
 867           G_LOCK (main_loop);
 868           in_check_or_prepare--;
 869         }
 870
 871       if (hook->flags & G_SOURCE_READY)
 872         {
 873           if (dispatch)
 874             {
 875               hook->flags &= ~G_SOURCE_READY;
 876               g_hook_ref (&source_list, hook);
 877               pending_dispatches = g_slist_prepend (pending_dispatches, source);
 878               current_priority = source->priority;
 879               n_ready++;
 880             }
 881           else
 882             {
 883               g_hook_unref (&source_list, hook);
 884               G_UNLOCK (main_loop);
 885
 886               return TRUE;
 887             }
 888         }
 889
 890       hook = g_hook_next_valid (&source_list, hook, TRUE);
 891     }
 892
 893   /* Now invoke the callbacks */
 894
 895   if (pending_dispatches)
 896     {
 897       pending_dispatches = g_slist_reverse (pending_dispatches);
 898       g_main_dispatch (&current_time);
 899       retval = TRUE;
 900     }
 901
 902   G_UNLOCK (main_loop);
 903
 904   return retval;
 905 }
 906
 907 /* See if any events are pending
 908  */
 909 gboolean
 910 g_main_pending (void)
 911 {
 912   return in_check_or_prepare ? FALSE : g_main_iterate (FALSE, FALSE);
 913 }
 914
 915 /* Run a single iteration of the mainloop. If block is FALSE,
 916  * will never block
 917  */
 918 gboolean
 919 g_main_iteration (gboolean block)
 920 {
 921   if (in_check_or_prepare)
 922     {
 923       g_warning ("g_main_iteration(): called recursively from within a source's check() or "
 924                  "prepare() member or from a second thread, iteration not possible");
 925       return FALSE;
 926     }
 927   else
 928     return g_main_iterate (block, TRUE);
 929 }
 930
 931 GMainLoop*
 932 g_main_new (gboolean is_running)
 933 {
 934   GMainLoop *loop;
 935
 936   loop = g_new0 (GMainLoop, 1);
 937   loop->is_running = is_running != FALSE;
 938
 939   return loop;
 940 }
 941
 942 void
 943 g_main_run (GMainLoop *loop)
 944 {
 945   g_return_if_fail (loop != NULL);
 946
 947   if (in_check_or_prepare)
 948     {
 949       g_warning ("g_main_run(): called recursively from within a source's check() or "
 950                  "prepare() member or from a second thread, iteration not possible");
 951       return;
 952     }
 953
 954   loop->is_running = TRUE;
 955   while (loop->is_running)
 956     g_main_iterate (TRUE, TRUE);
 957 }
 958
 959 void
 960 g_main_quit (GMainLoop *loop)
 961 {
 962   g_return_if_fail (loop != NULL);
 963
 964   loop->is_running = FALSE;
 965 }
 966
 967 void
 968 g_main_destroy (GMainLoop *loop)
 969 {
 970   g_return_if_fail (loop != NULL);
 971
 972   g_free (loop);
 973 }
 974
 975 gboolean
 976 g_main_is_running (GMainLoop *loop)
 977 {
 978   g_return_val_if_fail (loop != NULL, FALSE);
 979
 980   return loop->is_running;
 981 }
 982
 983 /* HOLDS: main_loop_lock */
 984 static void
 985 g_main_poll (gint     timeout,
 986              gboolean use_priority,
 987              gint     priority)
 988 {
 989 #ifdef  G_MAIN_POLL_DEBUG
 990   GTimer *poll_timer;
 991 #endif
 992   GPollFD *fd_array;
 993   GPollRec *pollrec;
 994   gint i;
 995   gint npoll;
 996
 997 #ifdef G_THREADS_ENABLED
 998 #ifndef G_OS_WIN32
 999   if (wake_up_pipe[0] < 0)
1000     {
1001       if (pipe (wake_up_pipe) < 0)
1002         g_error ("Cannot create pipe main loop wake-up: %s\n",
1003                  g_strerror (errno));
1004
1005       wake_up_rec.fd = wake_up_pipe[0];
1006       wake_up_rec.events = G_IO_IN;
1007       g_main_add_poll_unlocked (0, &wake_up_rec);
1008     }
1009 #else
1010   if (wake_up_semaphore == NULL)
1011     {
1012       if ((wake_up_semaphore = CreateSemaphore (NULL, 0, 100, NULL)) == NULL)
1013         g_error ("Cannot create wake-up semaphore: %s", g_win32_error_message (GetLastError ()));
1014       wake_up_rec.fd = (gint) wake_up_semaphore;
1015       wake_up_rec.events = G_IO_IN;
1016 #ifdef G_MAIN_POLL_DEBUG
1017       g_print ("wake-up semaphore: %#x\n", (guint) wake_up_semaphore);
1018 #endif
1019       g_main_add_poll_unlocked (0, &wake_up_rec);
1020     }
1021 #endif
1022 #endif
1023   fd_array = g_new (GPollFD, n_poll_records);
1024
1025   pollrec = poll_records;
1026   i = 0;
1027   while (pollrec && (!use_priority || priority >= pollrec->priority))
1028     {
1029       if (pollrec->fd->events)
1030         {
1031           fd_array[i].fd = pollrec->fd->fd;
1032           /* In direct contradiction to the Unix98 spec, IRIX runs into
1033            * difficulty if you pass in POLLERR, POLLHUP or POLLNVAL
1034            * flags in the events field of the pollfd while it should
1035            * just ignoring them. So we mask them out here.
1036            */
1037           fd_array[i].events = pollrec->fd->events & ~(G_IO_ERR|G_IO_HUP|G_IO_NVAL);
1038           fd_array[i].revents = 0;
1039           i++;
1040         }
1041
1042       pollrec = pollrec->next;
1043     }
1044 #ifdef G_THREADS_ENABLED
1045   poll_waiting = TRUE;
1046   poll_changed = FALSE;
1047 #endif
1048
1049   npoll = i;
1050   if (npoll || timeout != 0)
1051     {
1052 #ifdef  G_MAIN_POLL_DEBUG
1053       g_print ("g_main_poll(%d) timeout: %d\n", npoll, timeout);
1054       poll_timer = g_timer_new ();
1055 #endif
1056
1057       G_UNLOCK (main_loop);
1058       if ((*poll_func) (fd_array, npoll, timeout) < 0)
1059         g_warning ("poll(2) failed due to: %s.",
1060                    g_strerror (errno));
1061       G_LOCK (main_loop);
1062
1063 #ifdef  G_MAIN_POLL_DEBUG
1064       g_print ("g_main_poll(%d) timeout: %d - elapsed %12.10f seconds",
1065                npoll,
1066                timeout,
1067                g_timer_elapsed (poll_timer, NULL));
1068       g_timer_destroy (poll_timer);
1069       pollrec = poll_records;
1070       i = 0;
1071       while (i < npoll)
1072         {
1073           if (pollrec->fd->events)
1074             {
1075               if (fd_array[i].revents)
1076                 {
1077                   g_print (" [%d:", fd_array[i].fd);
1078                   if (fd_array[i].revents & G_IO_IN)
1079                     g_print ("i");
1080                   if (fd_array[i].revents & G_IO_OUT)
1081                     g_print ("o");
1082                   if (fd_array[i].revents & G_IO_PRI)
1083                     g_print ("p");
1084                   if (fd_array[i].revents & G_IO_ERR)
1085                     g_print ("e");
1086                   if (fd_array[i].revents & G_IO_HUP)
1087                     g_print ("h");
1088                   if (fd_array[i].revents & G_IO_NVAL)
1089                     g_print ("n");
1090                   g_print ("]");
1091                 }
1092               i++;
1093             }
1094           pollrec = pollrec->next;
1095         }
1096       g_print ("\n");
1097 #endif
1098     } /* if (npoll || timeout != 0) */
1099
1100 #ifdef G_THREADS_ENABLED
1101   if (!poll_waiting)
1102     {
1103 #ifndef G_OS_WIN32
1104       gchar c;
1105       read (wake_up_pipe[0], &c, 1);
1106 #endif
1107     }
1108   else
1109     poll_waiting = FALSE;
1110
1111   /* If the set of poll file descriptors changed, bail out
1112    * and let the main loop rerun
1113    */
1114   if (poll_changed)
1115     {
1116       g_free (fd_array);
1117       return;
1118     }
1119 #endif
1120
1121   pollrec = poll_records;
1122   i = 0;
1123   while (i < npoll)
1124     {
1125       if (pollrec->fd->events)
1126         {
1127           pollrec->fd->revents = fd_array[i].revents;
1128           i++;
1129         }
1130       pollrec = pollrec->next;
1131     }
1132
1133   g_free (fd_array);
1134 }
1135
1136 void
1137 g_main_add_poll (GPollFD *fd,
1138                  gint     priority)
1139 {
1140   G_LOCK (main_loop);
1141   g_main_add_poll_unlocked (priority, fd);
1142   G_UNLOCK (main_loop);
1143 }
1144
1145 /* HOLDS: main_loop_lock */
1146 static void
1147 g_main_add_poll_unlocked (gint     priority,
1148                           GPollFD *fd)
1149 {
1150   GPollRec *lastrec, *pollrec, *newrec;
1151
1152   if (!poll_chunk)
1153     poll_chunk = g_mem_chunk_create (GPollRec, 32, G_ALLOC_ONLY);
1154
1155   if (poll_free_list)
1156     {
1157       newrec = poll_free_list;
1158       poll_free_list = newrec->next;
1159     }
1160   else
1161     newrec = g_chunk_new (GPollRec, poll_chunk);
1162
1163   newrec->fd = fd;
1164   newrec->priority = priority;
1165
1166   lastrec = NULL;
1167   pollrec = poll_records;
1168   while (pollrec && priority >= pollrec->priority)
1169     {
1170       lastrec = pollrec;
1171       pollrec = pollrec->next;
1172     }
1173
1174   if (lastrec)
1175     lastrec->next = newrec;
1176   else
1177     poll_records = newrec;
1178
1179   newrec->next = pollrec;
1180
1181   n_poll_records++;
1182
1183 #ifdef G_THREADS_ENABLED
1184   poll_changed = TRUE;
1185
1186   /* Now wake up the main loop if it is waiting in the poll() */
1187   g_main_wakeup ();
1188 #endif
1189 }
1190
1191 void
1192 g_main_remove_poll (GPollFD *fd)
1193 {
1194   GPollRec *pollrec, *lastrec;
1195
1196   G_LOCK (main_loop);
1197
1198   lastrec = NULL;
1199   pollrec = poll_records;
1200
1201   while (pollrec)
1202     {
1203       if (pollrec->fd == fd)
1204         {
1205           if (lastrec != NULL)
1206             lastrec->next = pollrec->next;
1207           else
1208             poll_records = pollrec->next;
1209
1210 #ifdef ENABLE_GC_FRIENDLY
1211           pollrec->fd = NULL;
1212 #endif /* ENABLE_GC_FRIENDLY */
1213
1214           pollrec->next = poll_free_list;
1215           poll_free_list = pollrec;
1216
1217           n_poll_records--;
1218           break;
1219         }
1220       lastrec = pollrec;
1221       pollrec = pollrec->next;
1222     }
1223
1224 #ifdef G_THREADS_ENABLED
1225   poll_changed = TRUE;
1226
1227   /* Now wake up the main loop if it is waiting in the poll() */
1228   g_main_wakeup ();
1229 #endif
1230
1231   G_UNLOCK (main_loop);
1232 }
1233
1234 void
1235 g_main_set_poll_func (GPollFunc func)
1236 {
1237   if (func)
1238     poll_func = func;
1239   else
1240 #ifdef HAVE_POLL
1241     poll_func = (GPollFunc) poll;
1242 #else
1243     poll_func = (GPollFunc) g_poll;
1244 #endif
1245 }
1246
1247 #ifdef G_OS_WIN32
1248
1249 /* Useful on other platforms, too? */
1250
1251 GPollFunc
1252 g_main_win32_get_poll_func (void)
1253 {
1254   return poll_func;
1255 }
1256
1257 #endif
1258
1259 /* Wake the main loop up from a poll() */
1260 static void
1261 g_main_wakeup (void)
1262 {
1263 #ifdef G_THREADS_ENABLED
1264   if (poll_waiting)
1265     {
1266       poll_waiting = FALSE;
1267 #ifndef G_OS_WIN32
1268       write (wake_up_pipe[1], "A", 1);
1269 #else
1270       ReleaseSemaphore (wake_up_semaphore, 1, NULL);
1271 #endif
1272     }
1273 #endif
1274 }
1275
1276 /* Timeouts */
1277
1278 static void
1279 g_timeout_set_expiration (GTimeoutData *data,
1280                           GTimeVal     *current_time)
1281 {
1282   guint seconds = data->interval / 1000;
1283   guint msecs = data->interval - seconds * 1000;
1284
1285   data->expiration.tv_sec = current_time->tv_sec + seconds;
1286   data->expiration.tv_usec = current_time->tv_usec + msecs * 1000;
1287   if (data->expiration.tv_usec >= 1000000)
1288     {
1289       data->expiration.tv_usec -= 1000000;
1290       data->expiration.tv_sec++;
1291     }
1292 }
1293
1294 static gboolean
1295 g_timeout_prepare  (gpointer  source_data,
1296                     GTimeVal *current_time,
1297                     gint     *timeout,
1298                     gpointer  user_data)
1299 {
1300   glong msec;
1301   GTimeoutData *data = source_data;
1302
1303   msec = ((data->expiration.tv_sec  - current_time->tv_sec) * 1000 +
1304           (data->expiration.tv_usec - current_time->tv_usec) / 1000);
1305
1306   if (msec < 0)
1307     msec = 0;
1308   else if (msec > data->interval)
1309     {
1310       /* The system time has been set backwards, so we
1311        * reset the expiration time to now + data->interval;
1312        * this at least avoids hanging for long periods of time.
1313        */
1314       g_timeout_set_expiration (data, current_time);
1315       msec = data->interval;
1316     }
1317
1318   *timeout = msec;
1319
1320   return msec == 0;
1321 }
1322
1323 static gboolean
1324 g_timeout_check (gpointer  source_data,
1325                  GTimeVal *current_time,
1326                  gpointer  user_data)
1327 {
1328   GTimeoutData *data = source_data;
1329
1330   return ((data->expiration.tv_sec < current_time->tv_sec) ||
1331           ((data->expiration.tv_sec == current_time->tv_sec) &&
1332            (data->expiration.tv_usec <= current_time->tv_usec)));
1333 }
1334
1335 static gboolean
1336 g_timeout_dispatch (gpointer source_data,
1337                     GTimeVal *dispatch_time,
1338                     gpointer user_data)
1339 {
1340   GTimeoutData *data = source_data;
1341
1342   if (data->callback (user_data))
1343     {
1344       g_timeout_set_expiration (data, dispatch_time);
1345
1346       return TRUE;
1347     }
1348   else
1349     return FALSE;
1350 }
1351
1352 guint
1353 g_timeout_add_full (gint           priority,
1354                     guint          interval,
1355                     GSourceFunc    function,
1356                     gpointer       data,
1357                     GDestroyNotify notify)
1358 {
1359   GTimeoutData *timeout_data = g_new (GTimeoutData, 1);
1360   GTimeVal current_time;
1361
1362   timeout_data->interval = interval;
1363   timeout_data->callback = function;
1364   g_get_current_time (&current_time);
1365
1366   g_timeout_set_expiration (timeout_data, &current_time);
1367
1368   return g_source_add (priority, FALSE, &timeout_funcs, timeout_data, data, notify);
1369 }
1370
1371 guint
1372 g_timeout_add (guint32        interval,
1373                GSourceFunc    function,
1374                gpointer       data)
1375 {
1376   return g_timeout_add_full (G_PRIORITY_DEFAULT,
1377                              interval, function, data, NULL);
1378 }
1379
1380 /* Idle functions */
1381
1382 static gboolean
1383 g_idle_prepare  (gpointer  source_data,
1384                  GTimeVal *current_time,
1385                  gint     *timeout,
1386                  gpointer  user_data)
1387 {
1388   *timeout = 0;
1389
1390   return TRUE;
1391 }
1392
1393 static gboolean
1394 g_idle_check    (gpointer  source_data,
1395                  GTimeVal *current_time,
1396                  gpointer  user_data)
1397 {
1398   return TRUE;
1399 }
1400
1401 static gboolean
1402 g_idle_dispatch (gpointer source_data,
1403                  GTimeVal *dispatch_time,
1404                  gpointer user_data)
1405 {
1406   GSourceFunc func = source_data;
1407
1408   return func (user_data);
1409 }
1410
1411 guint
1412 g_idle_add_full (gint           priority,
1413                  GSourceFunc    function,
1414                  gpointer       data,
1415                  GDestroyNotify notify)
1416 {
1417   g_return_val_if_fail (function != NULL, 0);
1418
1419   return g_source_add (priority, FALSE, &idle_funcs, function, data, notify);
1420 }
1421
1422 guint
1423 g_idle_add (GSourceFunc    function,
1424             gpointer       data)
1425 {
1426   return g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, function, data, NULL);
1427 }
1428
1429 gboolean
1430 g_idle_remove_by_data (gpointer data)
1431 {
1432   return g_source_remove_by_funcs_user_data (&idle_funcs, data);
1433 }