xgselect.c 4.13 KB
Newer Older
1
/* Function for handling the GLib event loop.
2

3
Copyright (C) 2009-2012  Free Software Foundation, Inc.
4 5 6 7 8 9 10 11 12 13 14 15 16 17

This file is part of GNU Emacs.

GNU Emacs is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
18
along with GNU Emacs.  If not, see <http§://www.gnu.org/licenses/>.  */
19

Dan Nicolaescu's avatar
Dan Nicolaescu committed
20
#include <config.h>
21

22 23 24
#include <setjmp.h>
#include "xgselect.h"

25
#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
26

27 28 29
#include <glib.h>
#include <errno.h>
#include <setjmp.h>
30
#include "xterm.h"
31 32

static GPollFD *gfds;
33
static ptrdiff_t gfds_size;
34 35

int
36
xg_select (int fds_lim, SELECT_TYPE *rfds, SELECT_TYPE *wfds, SELECT_TYPE *efds,
37
	   EMACS_TIME *timeout, sigset_t *sigmask)
38 39 40 41
{
  SELECT_TYPE all_rfds, all_wfds;
  EMACS_TIME tmo, *tmop = timeout;

42
  GMainContext *context;
43
  int have_wfds = wfds != NULL;
44
  int n_gfds = 0, retval = 0, our_fds = 0, max_fds = fds_lim - 1;
45
  int i, nfds, tmo_in_millisec;
46

47
  if (!x_in_use)
48
    return pselect (fds_lim, rfds, wfds, efds, tmop, sigmask);
49

50 51 52 53 54 55
  if (rfds) memcpy (&all_rfds, rfds, sizeof (all_rfds));
  else FD_ZERO (&all_rfds);
  if (wfds) memcpy (&all_wfds, wfds, sizeof (all_rfds));
  else FD_ZERO (&all_wfds);

  /* Update event sources in GLib. */
56
  context = g_main_context_default ();
57 58 59
  g_main_context_pending (context);

  do {
60
    if (n_gfds > gfds_size)
61 62
      {
        xfree (gfds);
63 64
	gfds = xpalloc (0, &gfds_size, n_gfds - gfds_size, INT_MAX,
			sizeof *gfds);
65 66 67 68 69 70 71 72 73
      }

    n_gfds = g_main_context_query (context,
                                   G_PRIORITY_LOW,
                                   &tmo_in_millisec,
                                   gfds,
                                   gfds_size);
  } while (n_gfds > gfds_size);

74
  for (i = 0; i < n_gfds; ++i)
75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92
    {
      if (gfds[i].events & G_IO_IN)
        {
          FD_SET (gfds[i].fd, &all_rfds);
          if (gfds[i].fd > max_fds) max_fds = gfds[i].fd;
        }
      if (gfds[i].events & G_IO_OUT)
        {
          FD_SET (gfds[i].fd, &all_wfds);
          if (gfds[i].fd > max_fds) max_fds = gfds[i].fd;
          have_wfds = 1;
        }
    }

  if (tmo_in_millisec >= 0)
    {
      EMACS_SET_SECS_USECS (tmo, tmo_in_millisec/1000,
                            1000 * (tmo_in_millisec % 1000));
93 94
      if (!timeout || EMACS_TIME_LT (tmo, *timeout))
	tmop = &tmo;
95 96
    }

97
  fds_lim = max_fds + 1;
98 99
  nfds = pselect (fds_lim, &all_rfds, have_wfds ? &all_wfds : NULL,
		  efds, tmop, sigmask);
100 101 102

  if (nfds < 0)
    retval = nfds;
103
  else if (nfds > 0)
104
    {
105
      for (i = 0; i < fds_lim; ++i)
106 107 108 109 110 111
        {
          if (FD_ISSET (i, &all_rfds))
            {
              if (rfds && FD_ISSET (i, rfds)) ++retval;
              else ++our_fds;
            }
112 113 114
          else if (rfds)
            FD_CLR (i, rfds);

115 116 117 118 119
          if (have_wfds && FD_ISSET (i, &all_wfds))
            {
              if (wfds && FD_ISSET (i, wfds)) ++retval;
              else ++our_fds;
            }
120 121 122
          else if (wfds)
            FD_CLR (i, wfds);

123 124 125 126 127
          if (efds && FD_ISSET (i, efds))
            ++retval;
        }
    }

128
  if (our_fds > 0 || (nfds == 0 && tmop == &tmo))
129
    {
130

131 132 133 134 135 136 137 138 139
      /* If Gtk+ is in use eventually gtk_main_iteration will be called,
         unless retval is zero.  */
#ifdef USE_GTK
      if (retval == 0)
#endif
        while (g_main_context_pending (context))
          g_main_context_dispatch (context);

      /* To not have to recalculate timeout, return like this.  */
140
      if (retval == 0)
141 142 143 144 145 146 147 148
        {
          retval = -1;
          errno = EINTR;
        }
    }

  return retval;
}
149
#endif /* USE_GTK || HAVE_GCONF || HAVE_GSETTINGS */
150 151

void
152
xgselect_initialize (void)
153
{
154
#if defined (USE_GTK) || defined (HAVE_GCONF) || defined (HAVE_GSETTINGS)
155 156
  gfds_size = 128;
  gfds = xmalloc (sizeof (*gfds)*gfds_size);
157
#endif
158
}