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