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   g_return_if_fail (result != NULL);
 623
 624   /*this is required on alpha, there the timeval structs are int's
 625     not longs and a cast only would fail horribly*/
 626   gettimeofday (&r, NULL);
 627   result->tv_sec = r.tv_sec;
 628   result->tv_usec = r.tv_usec;
 629 #else
 630   /* Avoid calling time() except for the first time.
 631    * GetTickCount() should be pretty fast and low-level?
 632    * I could also use ftime() but it seems unnecessarily overheady.
 633    */
 634   static DWORD start_tick = 0;
 635   static time_t start_time;
 636   DWORD tick;
 637
 638   g_return_if_fail (result != NULL);
 639
 640   if (start_tick == 0)
 641     {
 642       start_tick = GetTickCount ();
 643       time (&start_time);
 644     }
 645
 646   tick = GetTickCount ();
 647
 648   result->tv_sec = (tick - start_tick) / 1000 + start_time;
 649   result->tv_usec = ((tick - start_tick) % 1000) * 1000;
 650 #endif
 651 }
 652
 653 /* Running the main loop */
 654
 655 /* HOLDS: main_loop_lock */
 656 static void
 657 g_main_dispatch (GTimeVal *dispatch_time)
 658 {
 659   while (pending_dispatches != NULL)
 660     {
 661       gboolean need_destroy;
 662       GSource *source = pending_dispatches->data;
 663       GSList *tmp_list;
 664
 665       tmp_list = pending_dispatches;
 666       pending_dispatches = g_slist_remove_link (pending_dispatches, pending_dispatches);
 667       g_slist_free_1 (tmp_list);
 668
 669       if (G_HOOK_IS_VALID (source))
 670         {
 671           gboolean was_in_call;
 672           gpointer hook_data = source->hook.data;
 673           gpointer source_data = source->source_data;
 674           gboolean (*dispatch) (gpointer,
 675                                 GTimeVal *,
 676                                 gpointer);
 677
 678           dispatch = ((GSourceFuncs *) source->hook.func)->dispatch;
 679
 680           was_in_call = G_HOOK_IN_CALL (source);
 681           source->hook.flags |= G_HOOK_FLAG_IN_CALL;
 682
 683           G_UNLOCK (main_loop);
 684           need_destroy = ! dispatch (source_data,
 685                                      dispatch_time,
 686                                      hook_data);
 687           G_LOCK (main_loop);
 688
 689           if (!was_in_call)
 690             source->hook.flags &= ~G_HOOK_FLAG_IN_CALL;
 691
 692           if (need_destroy && G_HOOK_IS_VALID (source))
 693             g_hook_destroy_link (&source_list, (GHook *) source);
 694         }
 695
 696       g_hook_unref (&source_list, (GHook*) source);
 697     }
 698 }
 699
 700 /* g_main_iterate () runs a single iteration of the mainloop, or,
 701  * if !dispatch checks to see if any sources need dispatching.
 702  * basic algorithm for dispatch=TRUE:
 703  *
 704  * 1) while the list of currently pending sources is non-empty,
 705  *    we call (*dispatch) on those that are !IN_CALL or can_recurse,
 706  *    removing sources from the list after each returns.
 707  *    the return value of (*dispatch) determines whether the source
 708  *    itself is kept alive.
 709  *
 710  * 2) call (*prepare) for sources that are not yet SOURCE_READY and
 711  *    are !IN_CALL or can_recurse. a return value of TRUE determines
 712  *    that the source would like to be dispatched immediatedly, it
 713  *    is then flagged as SOURCE_READY.
 714  *
 715  * 3) poll with the pollfds from all sources at the priority of the
 716  *    first source flagged as SOURCE_READY. if there are any sources
 717  *    flagged as SOURCE_READY, we use a timeout of 0 or the minimum
 718  *    of all timouts otherwise.
 719  *
 720  * 4) for each source !IN_CALL or can_recurse, if SOURCE_READY or
 721  *    (*check) returns true, add the source to the pending list.
 722  *    once one source returns true, stop after checking all sources
 723  *    at that priority.
 724  *
 725  * 5) while the list of currently pending sources is non-empty,
 726  *    call (*dispatch) on each source, removing the source
 727  *    after the call.
 728  *
 729  */
 730 static gboolean
 731 g_main_iterate (gboolean block,
 732                 gboolean dispatch)
 733 {
 734   GHook *hook;
 735   GTimeVal current_time  = { 0, 0 };
 736   gint n_ready = 0;
 737   gint current_priority = 0;
 738   gint timeout;
 739   gboolean retval = FALSE;
 740
 741   g_return_val_if_fail (!block || dispatch, FALSE);
 742
 743   g_get_current_time (&current_time);
 744
 745   G_LOCK (main_loop);
 746
 747 #ifdef G_THREADS_ENABLED
 748   if (poll_waiting)
 749     {
 750       g_warning("g_main_iterate(): main loop already active in another thread");
 751       G_UNLOCK (main_loop);
 752       return FALSE;
 753     }
 754 #endif G_THREADS_ENABLED
 755
 756   /* If recursing, finish up current dispatch, before starting over */
 757   if (pending_dispatches)
 758     {
 759       if (dispatch)
 760         g_main_dispatch (&current_time);
 761
 762       G_UNLOCK (main_loop);
 763
 764       return TRUE;
 765     }
 766
 767   /* Prepare all sources */
 768
 769   timeout = block ? -1 : 0;
 770
 771   hook = g_hook_first_valid (&source_list, TRUE);
 772   while (hook)
 773     {
 774       GSource *source = (GSource*) hook;
 775       gint source_timeout = -1;
 776
 777       if ((n_ready > 0) && (source->priority > current_priority))
 778         {
 779           g_hook_unref (&source_list, hook);
 780           break;
 781         }
 782       if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
 783         {
 784           hook = g_hook_next_valid (&source_list, hook, TRUE);
 785           continue;
 786         }
 787
 788       if (!(hook->flags & G_SOURCE_READY))
 789         {
 790           gboolean (*prepare)  (gpointer  source_data,
 791                                 GTimeVal *current_time,
 792                                 gint     *timeout,
 793                                 gpointer  user_data);
 794
 795           prepare = ((GSourceFuncs *) hook->func)->prepare;
 796           in_check_or_prepare++;
 797           G_UNLOCK (main_loop);
 798
 799           if ((*prepare) (source->source_data, &current_time, &source_timeout, source->hook.data))
 800             hook->flags |= G_SOURCE_READY;
 801
 802           G_LOCK (main_loop);
 803           in_check_or_prepare--;
 804         }
 805
 806       if (hook->flags & G_SOURCE_READY)
 807         {
 808           if (!dispatch)
 809             {
 810               g_hook_unref (&source_list, hook);
 811               G_UNLOCK (main_loop);
 812
 813               return TRUE;
 814             }
 815           else
 816             {
 817               n_ready++;
 818               current_priority = source->priority;
 819               timeout = 0;
 820             }
 821         }
 822
 823       if (source_timeout >= 0)
 824         {
 825           if (timeout < 0)
 826             timeout = source_timeout;
 827           else
 828             timeout = MIN (timeout, source_timeout);
 829         }
 830
 831       hook = g_hook_next_valid (&source_list, hook, TRUE);
 832     }
 833
 834   /* poll(), if necessary */
 835
 836   g_main_poll (timeout, n_ready > 0, current_priority);
 837
 838   if (timeout != 0)
 839     g_get_current_time (&current_time);
 840
 841   /* Check to see what sources need to be dispatched */
 842
 843   n_ready = 0;
 844
 845   hook = g_hook_first_valid (&source_list, TRUE);
 846   while (hook)
 847     {
 848       GSource *source = (GSource *)hook;
 849
 850       if ((n_ready > 0) && (source->priority > current_priority))
 851         {
 852           g_hook_unref (&source_list, hook);
 853           break;
 854         }
 855       if (G_HOOK_IN_CALL (hook) && !(hook->flags & G_SOURCE_CAN_RECURSE))
 856         {
 857           hook = g_hook_next_valid (&source_list, hook, TRUE);
 858           continue;
 859         }
 860
 861       if (!(hook->flags & G_SOURCE_READY))
 862         {
 863           gboolean (*check) (gpointer  source_data,
 864                              GTimeVal *current_time,
 865                              gpointer  user_data);
 866
 867           check = ((GSourceFuncs *) hook->func)->check;
 868           in_check_or_prepare++;
 869           G_UNLOCK (main_loop);
 870
 871           if ((*check) (source->source_data, &current_time, source->hook.data))
 872             hook->flags |= G_SOURCE_READY;
 873
 874           G_LOCK (main_loop);
 875           in_check_or_prepare--;
 876         }
 877
 878       if (hook->flags & G_SOURCE_READY)
 879         {
 880           if (dispatch)
 881             {
 882               hook->flags &= ~G_SOURCE_READY;
 883               g_hook_ref (&source_list, hook);
 884               pending_dispatches = g_slist_prepend (pending_dispatches, source);
 885               current_priority = source->priority;
 886               n_ready++;
 887             }
 888           else
 889             {
 890               g_hook_unref (&source_list, hook);
 891               G_UNLOCK (main_loop);
 892
 893               return TRUE;
 894             }
 895         }
 896
 897       hook = g_hook_next_valid (&source_list, hook, TRUE);
 898     }
 899
 900   /* Now invoke the callbacks */
 901
 902   if (pending_dispatches)
 903     {
 904       pending_dispatches = g_slist_reverse (pending_dispatches);
 905       g_main_dispatch (&current_time);
 906       retval = TRUE;
 907     }
 908
 909   G_UNLOCK (main_loop);
 910
 911   return retval;
 912 }
 913
 914 /* See if any events are pending
 915  */
 916 gboolean
 917 g_main_pending (void)
 918 {
 919   return in_check_or_prepare ? FALSE : g_main_iterate (FALSE, FALSE);
 920 }
 921
 922 /* Run a single iteration of the mainloop. If block is FALSE,
 923  * will never block
 924  */
 925 gboolean
 926 g_main_iteration (gboolean block)
 927 {
 928   if (in_check_or_prepare)
 929     {
 930       g_warning ("g_main_iteration(): called recursively from within a source's check() or "
 931                  "prepare() member or from a second thread, iteration not possible");
 932       return FALSE;
 933     }
 934   else
 935     return g_main_iterate (block, TRUE);
 936 }
 937
 938 GMainLoop*
 939 g_main_new (gboolean is_running)
 940 {
 941   GMainLoop *loop;
 942
 943   loop = g_new0 (GMainLoop, 1);
 944   loop->is_running = is_running != FALSE;
 945
 946   return loop;
 947 }
 948
 949 void
 950 g_main_run (GMainLoop *loop)
 951 {
 952   g_return_if_fail (loop != NULL);
 953
 954   if (in_check_or_prepare)
 955     {
 956       g_warning ("g_main_run(): called recursively from within a source's check() or "
 957                  "prepare() member or from a second thread, iteration not possible");
 958       return;
 959     }
 960
 961   loop->is_running = TRUE;
 962   while (loop->is_running)
 963     g_main_iterate (TRUE, TRUE);
 964 }
 965
 966 void
 967 g_main_quit (GMainLoop *loop)
 968 {
 969   g_return_if_fail (loop != NULL);
 970
 971   loop->is_running = FALSE;
 972 }
 973
 974 void
 975 g_main_destroy (GMainLoop *loop)
 976 {
 977   g_return_if_fail (loop != NULL);
 978
 979   g_free (loop);
 980 }
 981
 982 gboolean
 983 g_main_is_running (GMainLoop *loop)
 984 {
 985   g_return_val_if_fail (loop != NULL, FALSE);
 986
 987   return loop->is_running;
 988 }
 989
 990 /* HOLDS: main_loop_lock */
 991 static void
 992 g_main_poll (gint     timeout,
 993              gboolean use_priority,
 994              gint     priority)
 995 {
 996 #ifdef  G_MAIN_POLL_DEBUG
 997   GTimer *poll_timer;
 998 #endif
 999   GPollFD *fd_array;
1000   GPollRec *pollrec;
1001   gint i;
1002   gint npoll;
1003
1004 #ifdef G_THREADS_ENABLED
1005 #ifndef G_OS_WIN32
1006   if (wake_up_pipe[0] < 0)
1007     {
1008       if (pipe (wake_up_pipe) < 0)
1009         g_error ("Cannot create pipe main loop wake-up: %s\n",
1010                  g_strerror (errno));
1011
1012       wake_up_rec.fd = wake_up_pipe[0];
1013       wake_up_rec.events = G_IO_IN;
1014       g_main_add_poll_unlocked (0, &wake_up_rec);
1015     }
1016 #else
1017   if (wake_up_semaphore == NULL)
1018     {
1019       if ((wake_up_semaphore = CreateSemaphore (NULL, 0, 100, NULL)) == NULL)
1020         g_error ("Cannot create wake-up semaphore: %s", g_win32_error_message (GetLastError ()));
1021       wake_up_rec.fd = (gint) wake_up_semaphore;
1022       wake_up_rec.events = G_IO_IN;
1023 #ifdef G_MAIN_POLL_DEBUG
1024       g_print ("wake-up semaphore: %#x\n", (guint) wake_up_semaphore);
1025 #endif
1026       g_main_add_poll_unlocked (0, &wake_up_rec);
1027     }
1028 #endif
1029 #endif
1030   fd_array = g_new (GPollFD, n_poll_records);
1031
1032   pollrec = poll_records;
1033   i = 0;
1034   while (pollrec && (!use_priority || priority >= pollrec->priority))
1035     {
1036       if (pollrec->fd->events)
1037         {
1038           fd_array[i].fd = pollrec->fd->fd;
1039           /* In direct contradiction to the Unix98 spec, IRIX runs into
1040            * difficulty if you pass in POLLERR, POLLHUP or POLLNVAL
1041            * flags in the events field of the pollfd while it should
1042            * just ignoring them. So we mask them out here.
1043            */
1044           fd_array[i].events = pollrec->fd->events & ~(G_IO_ERR|G_IO_HUP|G_IO_NVAL);
1045           fd_array[i].revents = 0;
1046           i++;
1047         }
1048
1049       pollrec = pollrec->next;
1050     }
1051 #ifdef G_THREADS_ENABLED
1052   poll_waiting = TRUE;
1053   poll_changed = FALSE;
1054 #endif
1055
1056   npoll = i;
1057   if (npoll || timeout != 0)
1058     {
1059 #ifdef  G_MAIN_POLL_DEBUG
1060       g_print ("g_main_poll(%d) timeout: %d\n", npoll, timeout);
1061       poll_timer = g_timer_new ();
1062 #endif
1063
1064       G_UNLOCK (main_loop);
1065       if ((*poll_func) (fd_array, npoll, timeout) < 0)
1066         g_warning ("poll(2) failed due to: %s.",
1067                    g_strerror (errno));
1068       G_LOCK (main_loop);
1069
1070 #ifdef  G_MAIN_POLL_DEBUG
1071       g_print ("g_main_poll(%d) timeout: %d - elapsed %12.10f seconds",
1072                npoll,
1073                timeout,
1074                g_timer_elapsed (poll_timer, NULL));
1075       g_timer_destroy (poll_timer);
1076       pollrec = poll_records;
1077       i = 0;
1078       while (i < npoll)
1079         {
1080           if (pollrec->fd->events)
1081             {
1082               if (fd_array[i].revents)
1083                 {
1084                   g_print (" [%d:", fd_array[i].fd);
1085                   if (fd_array[i].revents & G_IO_IN)
1086                     g_print ("i");
1087                   if (fd_array[i].revents & G_IO_OUT)
1088                     g_print ("o");
1089                   if (fd_array[i].revents & G_IO_PRI)
1090                     g_print ("p");
1091                   if (fd_array[i].revents & G_IO_ERR)
1092                     g_print ("e");
1093                   if (fd_array[i].revents & G_IO_HUP)
1094                     g_print ("h");
1095                   if (fd_array[i].revents & G_IO_NVAL)
1096                     g_print ("n");
1097                   g_print ("]");
1098                 }
1099               i++;
1100             }
1101           pollrec = pollrec->next;
1102         }
1103       g_print ("\n");
1104 #endif
1105     } /* if (npoll || timeout != 0) */
1106
1107 #ifdef G_THREADS_ENABLED
1108   if (!poll_waiting)
1109     {
1110 #ifndef G_OS_WIN32
1111       gchar c;
1112       read (wake_up_pipe[0], &c, 1);
1113 #endif
1114     }
1115   else
1116     poll_waiting = FALSE;
1117
1118   /* If the set of poll file descriptors changed, bail out
1119    * and let the main loop rerun
1120    */
1121   if (poll_changed)
1122     {
1123       g_free (fd_array);
1124       return;
1125     }
1126 #endif
1127
1128   pollrec = poll_records;
1129   i = 0;
1130   while (i < npoll)
1131     {
1132       if (pollrec->fd->events)
1133         {
1134           pollrec->fd->revents = fd_array[i].revents;
1135           i++;
1136         }
1137       pollrec = pollrec->next;
1138     }
1139
1140   g_free (fd_array);
1141 }
1142
1143 void
1144 g_main_add_poll (GPollFD *fd,
1145                  gint     priority)
1146 {
1147   G_LOCK (main_loop);
1148   g_main_add_poll_unlocked (priority, fd);
1149   G_UNLOCK (main_loop);
1150 }
1151
1152 /* HOLDS: main_loop_lock */
1153 static void
1154 g_main_add_poll_unlocked (gint     priority,
1155                           GPollFD *fd)
1156 {
1157   GPollRec *lastrec, *pollrec, *newrec;
1158
1159   if (!poll_chunk)
1160     poll_chunk = g_mem_chunk_create (GPollRec, 32, G_ALLOC_ONLY);
1161
1162   if (poll_free_list)
1163     {
1164       newrec = poll_free_list;
1165       poll_free_list = newrec->next;
1166     }
1167   else
1168     newrec = g_chunk_new (GPollRec, poll_chunk);
1169
1170   newrec->fd = fd;
1171   newrec->priority = priority;
1172
1173   lastrec = NULL;
1174   pollrec = poll_records;
1175   while (pollrec && priority >= pollrec->priority)
1176     {
1177       lastrec = pollrec;
1178       pollrec = pollrec->next;
1179     }
1180
1181   if (lastrec)
1182     lastrec->next = newrec;
1183   else
1184     poll_records = newrec;
1185
1186   newrec->next = pollrec;
1187
1188   n_poll_records++;
1189
1190 #ifdef G_THREADS_ENABLED
1191   poll_changed = TRUE;
1192
1193   /* Now wake up the main loop if it is waiting in the poll() */
1194   g_main_wakeup ();
1195 #endif
1196 }
1197
1198 void
1199 g_main_remove_poll (GPollFD *fd)
1200 {
1201   GPollRec *pollrec, *lastrec;
1202
1203   G_LOCK (main_loop);
1204
1205   lastrec = NULL;
1206   pollrec = poll_records;
1207
1208   while (pollrec)
1209     {
1210       if (pollrec->fd == fd)
1211         {
1212           if (lastrec != NULL)
1213             lastrec->next = pollrec->next;
1214           else
1215             poll_records = pollrec->next;
1216
1217 #ifdef ENABLE_GC_FRIENDLY
1218           pollrec->fd = NULL;
1219 #endif /* ENABLE_GC_FRIENDLY */
1220
1221           pollrec->next = poll_free_list;
1222           poll_free_list = pollrec;
1223
1224           n_poll_records--;
1225           break;
1226         }
1227       lastrec = pollrec;
1228       pollrec = pollrec->next;
1229     }
1230
1231 #ifdef G_THREADS_ENABLED
1232   poll_changed = TRUE;
1233
1234   /* Now wake up the main loop if it is waiting in the poll() */
1235   g_main_wakeup ();
1236 #endif
1237
1238   G_UNLOCK (main_loop);
1239 }
1240
1241 void
1242 g_main_set_poll_func (GPollFunc func)
1243 {
1244   if (func)
1245     poll_func = func;
1246   else
1247 #ifdef HAVE_POLL
1248     poll_func = (GPollFunc) poll;
1249 #else
1250     poll_func = (GPollFunc) g_poll;
1251 #endif
1252 }
1253
1254 #ifdef G_OS_WIN32
1255
1256 /* Useful on other platforms, too? */
1257
1258 GPollFunc
1259 g_main_win32_get_poll_func (void)
1260 {
1261   return poll_func;
1262 }
1263
1264 #endif
1265
1266 /* Wake the main loop up from a poll() */
1267 static void
1268 g_main_wakeup (void)
1269 {
1270 #ifdef G_THREADS_ENABLED
1271   if (poll_waiting)
1272     {
1273       poll_waiting = FALSE;
1274 #ifndef G_OS_WIN32
1275       write (wake_up_pipe[1], "A", 1);
1276 #else
1277       ReleaseSemaphore (wake_up_semaphore, 1, NULL);
1278 #endif
1279     }
1280 #endif
1281 }
1282
1283 /* Timeouts */
1284
1285 static void
1286 g_timeout_set_expiration (GTimeoutData *data,
1287                           GTimeVal     *current_time)
1288 {
1289   guint seconds = data->interval / 1000;
1290   guint msecs = data->interval - seconds * 1000;
1291
1292   data->expiration.tv_sec = current_time->tv_sec + seconds;
1293   data->expiration.tv_usec = current_time->tv_usec + msecs * 1000;
1294   if (data->expiration.tv_usec >= 1000000)
1295     {
1296       data->expiration.tv_usec -= 1000000;
1297       data->expiration.tv_sec++;
1298     }
1299 }
1300
1301 static gboolean
1302 g_timeout_prepare  (gpointer  source_data,
1303                     GTimeVal *current_time,
1304                     gint     *timeout,
1305                     gpointer  user_data)
1306 {
1307   glong msec;
1308   GTimeoutData *data = source_data;
1309
1310   msec = ((data->expiration.tv_sec  - current_time->tv_sec) * 1000 +
1311           (data->expiration.tv_usec - current_time->tv_usec) / 1000);
1312
1313   if (msec < 0)
1314     msec = 0;
1315   else if (msec > data->interval)
1316     {
1317       /* The system time has been set backwards, so we
1318        * reset the expiration time to now + data->interval;
1319        * this at least avoids hanging for long periods of time.
1320        */
1321       g_timeout_set_expiration (data, current_time);
1322       msec = data->interval;
1323     }
1324
1325   *timeout = msec;
1326
1327   return msec == 0;
1328 }
1329
1330 static gboolean
1331 g_timeout_check (gpointer  source_data,
1332                  GTimeVal *current_time,
1333                  gpointer  user_data)
1334 {
1335   GTimeoutData *data = source_data;
1336
1337   return ((data->expiration.tv_sec < current_time->tv_sec) ||
1338           ((data->expiration.tv_sec == current_time->tv_sec) &&
1339            (data->expiration.tv_usec <= current_time->tv_usec)));
1340 }
1341
1342 static gboolean
1343 g_timeout_dispatch (gpointer source_data,
1344                     GTimeVal *dispatch_time,
1345                     gpointer user_data)
1346 {
1347   GTimeoutData *data = source_data;
1348
1349   if (data->callback (user_data))
1350     {
1351       g_timeout_set_expiration (data, dispatch_time);
1352
1353       return TRUE;
1354     }
1355   else
1356     return FALSE;
1357 }
1358
1359 guint
1360 g_timeout_add_full (gint           priority,
1361                     guint          interval,
1362                     GSourceFunc    function,
1363                     gpointer       data,
1364                     GDestroyNotify notify)
1365 {
1366   GTimeoutData *timeout_data = g_new (GTimeoutData, 1);
1367   GTimeVal current_time;
1368
1369   timeout_data->interval = interval;
1370   timeout_data->callback = function;
1371   g_get_current_time (&current_time);
1372
1373   g_timeout_set_expiration (timeout_data, &current_time);
1374
1375   return g_source_add (priority, FALSE, &timeout_funcs, timeout_data, data, notify);
1376 }
1377
1378 guint
1379 g_timeout_add (guint32        interval,
1380                GSourceFunc    function,
1381                gpointer       data)
1382 {
1383   return g_timeout_add_full (G_PRIORITY_DEFAULT,
1384                              interval, function, data, NULL);
1385 }
1386
1387 /* Idle functions */
1388
1389 static gboolean
1390 g_idle_prepare  (gpointer  source_data,
1391                  GTimeVal *current_time,
1392                  gint     *timeout,
1393                  gpointer  user_data)
1394 {
1395   *timeout = 0;
1396
1397   return TRUE;
1398 }
1399
1400 static gboolean
1401 g_idle_check    (gpointer  source_data,
1402                  GTimeVal *current_time,
1403                  gpointer  user_data)
1404 {
1405   return TRUE;
1406 }
1407
1408 static gboolean
1409 g_idle_dispatch (gpointer source_data,
1410                  GTimeVal *dispatch_time,
1411                  gpointer user_data)
1412 {
1413   GSourceFunc func = source_data;
1414
1415   return func (user_data);
1416 }
1417
1418 guint
1419 g_idle_add_full (gint           priority,
1420                  GSourceFunc    function,
1421                  gpointer       data,
1422                  GDestroyNotify notify)
1423 {
1424   g_return_val_if_fail (function != NULL, 0);
1425
1426   return g_source_add (priority, FALSE, &idle_funcs, function, data, notify);
1427 }
1428
1429 guint
1430 g_idle_add (GSourceFunc    function,
1431             gpointer       data)
1432 {
1433   return g_idle_add_full (G_PRIORITY_DEFAULT_IDLE, function, data, NULL);
1434 }
1435
1436 gboolean
1437 g_idle_remove_by_data (gpointer data)
1438 {
1439   return g_source_remove_by_funcs_user_data (&idle_funcs, data);
1440 }