* README.win32: More text.
* config.h.win32 glibconfig.h.win32: Update to match the
corresponding generated files on Unix.
* makefile.msc: Update with new source files, and gthread
library. Use the compiler flag -MD instead of using -D_DLL and
"/nodefaultlib:libc msvcrt.lib" in the link phase.
* glib.def: Include new functions, drop removed ones.
* glib.h: Add comments about main loop and polling on Win32. (In
general, it's only for the GIMP's use.) Add Win32 IO Channel
functions. Remove the obsoleted old IO Channel stuff (which was
in #if 0 already).
* giowin32.c: New file.
* gmain.c: Include config.h, conditionalize <sys/time.h>
inclusion. Add g_poll implementation for Win32 (only for the
GIMP's needs for now, it's hard or even impossible to be as clean
and generic as on Unix). Implement g_get_current_time on Win32. If
threads aren't supported, don't try to wake up main thread's
loop. On Win32, use a semaphore and not a pipe to wake up the main
loop.
* gmessages.c: On Win32, allocate a console window if the standard
output handle is invalid before writing to stdout, and reopen stdout
to that console window.
* giochannel.c: Conditionalize unistd.h inclusion. Some indentation
cleanup.
* gstrfuncs.c: Include <signal.h>.
* gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
environment variables.
* gmodule-dl.c gmodule-dld.c: In
_g_module_build_path, don't add the "lib" prefix and
".so" or ".sl" suffix if already there.
* gmodule-win32.c: Likewise for the ".dll" suffix.
* gthread-posix.c: Conditionalize <sys/time.h> inclusion.
+1999-01-16 Tor Lillqvist <tml@iki.fi>
+
+ * Merge in current Win32 version:
+
+ * README.win32: More text.
+
+ * config.h.win32 glibconfig.h.win32: Update to match the
+ corresponding generated files on Unix.
+
+ * makefile.msc: Update with new source files, and gthread
+ library. Use the compiler flag -MD instead of using -D_DLL and
+ /nodefaultlib:libc msvcrt.lib in the link phase.
+
+ * glib.def: Update to include new functions, drop removed ones.
+
+ * glib.h: Add comments about main loop and polling on Win32. (In
+ general, it's only for the GIMP's use.) Add Win32 IO Channel
+ functions. Remove the obsoleted old IO Channel stuff (which was
+ in #if 0 already).
+
+ * giowin32.c: New file.
+
+ * gmain.c: Include config.h, conditionalize <sys/time.h>
+ inclusion. Add g_poll implementation for Win32 (only for the
+ GIMP's needs for now, it's hard or even impossible to be as clean
+ and generic as on Unix). Implement g_get_current_time on Win32. If
+ threads aren't supported, don't try to wake up main thread's
+ loop. On Win32, use a semaphore and not a pipe to wake up the main
+ loop.
+
+ * gmessages.c: On Win32, allocate a console window if the standard
+ output handle is invalid before writing to stdout, and reopen stdout
+ to that console window.
+
+ * giochannel.c: Conditionalize unistd.h inclusion. Some indentation
+ cleanup.
+
+ * gstrfuncs.c: Include <signal.h>.
+
+ * gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
+ environment variables.
+
Sun Jan 17 01:06:38 1999 Timur Bakeyev <mc@bat.ru>
* configure.in: Add support for FreeBSD 2.2.x macro _THREAD_SAFE.
+1999-01-16 Tor Lillqvist <tml@iki.fi>
+
+ * Merge in current Win32 version:
+
+ * README.win32: More text.
+
+ * config.h.win32 glibconfig.h.win32: Update to match the
+ corresponding generated files on Unix.
+
+ * makefile.msc: Update with new source files, and gthread
+ library. Use the compiler flag -MD instead of using -D_DLL and
+ /nodefaultlib:libc msvcrt.lib in the link phase.
+
+ * glib.def: Update to include new functions, drop removed ones.
+
+ * glib.h: Add comments about main loop and polling on Win32. (In
+ general, it's only for the GIMP's use.) Add Win32 IO Channel
+ functions. Remove the obsoleted old IO Channel stuff (which was
+ in #if 0 already).
+
+ * giowin32.c: New file.
+
+ * gmain.c: Include config.h, conditionalize <sys/time.h>
+ inclusion. Add g_poll implementation for Win32 (only for the
+ GIMP's needs for now, it's hard or even impossible to be as clean
+ and generic as on Unix). Implement g_get_current_time on Win32. If
+ threads aren't supported, don't try to wake up main thread's
+ loop. On Win32, use a semaphore and not a pipe to wake up the main
+ loop.
+
+ * gmessages.c: On Win32, allocate a console window if the standard
+ output handle is invalid before writing to stdout, and reopen stdout
+ to that console window.
+
+ * giochannel.c: Conditionalize unistd.h inclusion. Some indentation
+ cleanup.
+
+ * gstrfuncs.c: Include <signal.h>.
+
+ * gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
+ environment variables.
+
Sun Jan 17 01:06:38 1999 Timur Bakeyev <mc@bat.ru>
* configure.in: Add support for FreeBSD 2.2.x macro _THREAD_SAFE.
+1999-01-16 Tor Lillqvist <tml@iki.fi>
+
+ * Merge in current Win32 version:
+
+ * README.win32: More text.
+
+ * config.h.win32 glibconfig.h.win32: Update to match the
+ corresponding generated files on Unix.
+
+ * makefile.msc: Update with new source files, and gthread
+ library. Use the compiler flag -MD instead of using -D_DLL and
+ /nodefaultlib:libc msvcrt.lib in the link phase.
+
+ * glib.def: Update to include new functions, drop removed ones.
+
+ * glib.h: Add comments about main loop and polling on Win32. (In
+ general, it's only for the GIMP's use.) Add Win32 IO Channel
+ functions. Remove the obsoleted old IO Channel stuff (which was
+ in #if 0 already).
+
+ * giowin32.c: New file.
+
+ * gmain.c: Include config.h, conditionalize <sys/time.h>
+ inclusion. Add g_poll implementation for Win32 (only for the
+ GIMP's needs for now, it's hard or even impossible to be as clean
+ and generic as on Unix). Implement g_get_current_time on Win32. If
+ threads aren't supported, don't try to wake up main thread's
+ loop. On Win32, use a semaphore and not a pipe to wake up the main
+ loop.
+
+ * gmessages.c: On Win32, allocate a console window if the standard
+ output handle is invalid before writing to stdout, and reopen stdout
+ to that console window.
+
+ * giochannel.c: Conditionalize unistd.h inclusion. Some indentation
+ cleanup.
+
+ * gstrfuncs.c: Include <signal.h>.
+
+ * gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
+ environment variables.
+
Sun Jan 17 01:06:38 1999 Timur Bakeyev <mc@bat.ru>
* configure.in: Add support for FreeBSD 2.2.x macro _THREAD_SAFE.
+1999-01-16 Tor Lillqvist <tml@iki.fi>
+
+ * Merge in current Win32 version:
+
+ * README.win32: More text.
+
+ * config.h.win32 glibconfig.h.win32: Update to match the
+ corresponding generated files on Unix.
+
+ * makefile.msc: Update with new source files, and gthread
+ library. Use the compiler flag -MD instead of using -D_DLL and
+ /nodefaultlib:libc msvcrt.lib in the link phase.
+
+ * glib.def: Update to include new functions, drop removed ones.
+
+ * glib.h: Add comments about main loop and polling on Win32. (In
+ general, it's only for the GIMP's use.) Add Win32 IO Channel
+ functions. Remove the obsoleted old IO Channel stuff (which was
+ in #if 0 already).
+
+ * giowin32.c: New file.
+
+ * gmain.c: Include config.h, conditionalize <sys/time.h>
+ inclusion. Add g_poll implementation for Win32 (only for the
+ GIMP's needs for now, it's hard or even impossible to be as clean
+ and generic as on Unix). Implement g_get_current_time on Win32. If
+ threads aren't supported, don't try to wake up main thread's
+ loop. On Win32, use a semaphore and not a pipe to wake up the main
+ loop.
+
+ * gmessages.c: On Win32, allocate a console window if the standard
+ output handle is invalid before writing to stdout, and reopen stdout
+ to that console window.
+
+ * giochannel.c: Conditionalize unistd.h inclusion. Some indentation
+ cleanup.
+
+ * gstrfuncs.c: Include <signal.h>.
+
+ * gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
+ environment variables.
+
Sun Jan 17 01:06:38 1999 Timur Bakeyev <mc@bat.ru>
* configure.in: Add support for FreeBSD 2.2.x macro _THREAD_SAFE.
+1999-01-16 Tor Lillqvist <tml@iki.fi>
+
+ * Merge in current Win32 version:
+
+ * README.win32: More text.
+
+ * config.h.win32 glibconfig.h.win32: Update to match the
+ corresponding generated files on Unix.
+
+ * makefile.msc: Update with new source files, and gthread
+ library. Use the compiler flag -MD instead of using -D_DLL and
+ /nodefaultlib:libc msvcrt.lib in the link phase.
+
+ * glib.def: Update to include new functions, drop removed ones.
+
+ * glib.h: Add comments about main loop and polling on Win32. (In
+ general, it's only for the GIMP's use.) Add Win32 IO Channel
+ functions. Remove the obsoleted old IO Channel stuff (which was
+ in #if 0 already).
+
+ * giowin32.c: New file.
+
+ * gmain.c: Include config.h, conditionalize <sys/time.h>
+ inclusion. Add g_poll implementation for Win32 (only for the
+ GIMP's needs for now, it's hard or even impossible to be as clean
+ and generic as on Unix). Implement g_get_current_time on Win32. If
+ threads aren't supported, don't try to wake up main thread's
+ loop. On Win32, use a semaphore and not a pipe to wake up the main
+ loop.
+
+ * gmessages.c: On Win32, allocate a console window if the standard
+ output handle is invalid before writing to stdout, and reopen stdout
+ to that console window.
+
+ * giochannel.c: Conditionalize unistd.h inclusion. Some indentation
+ cleanup.
+
+ * gstrfuncs.c: Include <signal.h>.
+
+ * gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
+ environment variables.
+
Sun Jan 17 01:06:38 1999 Timur Bakeyev <mc@bat.ru>
* configure.in: Add support for FreeBSD 2.2.x macro _THREAD_SAFE.
+1999-01-16 Tor Lillqvist <tml@iki.fi>
+
+ * Merge in current Win32 version:
+
+ * README.win32: More text.
+
+ * config.h.win32 glibconfig.h.win32: Update to match the
+ corresponding generated files on Unix.
+
+ * makefile.msc: Update with new source files, and gthread
+ library. Use the compiler flag -MD instead of using -D_DLL and
+ /nodefaultlib:libc msvcrt.lib in the link phase.
+
+ * glib.def: Update to include new functions, drop removed ones.
+
+ * glib.h: Add comments about main loop and polling on Win32. (In
+ general, it's only for the GIMP's use.) Add Win32 IO Channel
+ functions. Remove the obsoleted old IO Channel stuff (which was
+ in #if 0 already).
+
+ * giowin32.c: New file.
+
+ * gmain.c: Include config.h, conditionalize <sys/time.h>
+ inclusion. Add g_poll implementation for Win32 (only for the
+ GIMP's needs for now, it's hard or even impossible to be as clean
+ and generic as on Unix). Implement g_get_current_time on Win32. If
+ threads aren't supported, don't try to wake up main thread's
+ loop. On Win32, use a semaphore and not a pipe to wake up the main
+ loop.
+
+ * gmessages.c: On Win32, allocate a console window if the standard
+ output handle is invalid before writing to stdout, and reopen stdout
+ to that console window.
+
+ * giochannel.c: Conditionalize unistd.h inclusion. Some indentation
+ cleanup.
+
+ * gstrfuncs.c: Include <signal.h>.
+
+ * gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
+ environment variables.
+
Sun Jan 17 01:06:38 1999 Timur Bakeyev <mc@bat.ru>
* configure.in: Add support for FreeBSD 2.2.x macro _THREAD_SAFE.
+1999-01-16 Tor Lillqvist <tml@iki.fi>
+
+ * Merge in current Win32 version:
+
+ * README.win32: More text.
+
+ * config.h.win32 glibconfig.h.win32: Update to match the
+ corresponding generated files on Unix.
+
+ * makefile.msc: Update with new source files, and gthread
+ library. Use the compiler flag -MD instead of using -D_DLL and
+ /nodefaultlib:libc msvcrt.lib in the link phase.
+
+ * glib.def: Update to include new functions, drop removed ones.
+
+ * glib.h: Add comments about main loop and polling on Win32. (In
+ general, it's only for the GIMP's use.) Add Win32 IO Channel
+ functions. Remove the obsoleted old IO Channel stuff (which was
+ in #if 0 already).
+
+ * giowin32.c: New file.
+
+ * gmain.c: Include config.h, conditionalize <sys/time.h>
+ inclusion. Add g_poll implementation for Win32 (only for the
+ GIMP's needs for now, it's hard or even impossible to be as clean
+ and generic as on Unix). Implement g_get_current_time on Win32. If
+ threads aren't supported, don't try to wake up main thread's
+ loop. On Win32, use a semaphore and not a pipe to wake up the main
+ loop.
+
+ * gmessages.c: On Win32, allocate a console window if the standard
+ output handle is invalid before writing to stdout, and reopen stdout
+ to that console window.
+
+ * giochannel.c: Conditionalize unistd.h inclusion. Some indentation
+ cleanup.
+
+ * gstrfuncs.c: Include <signal.h>.
+
+ * gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
+ environment variables.
+
Sun Jan 17 01:06:38 1999 Timur Bakeyev <mc@bat.ru>
* configure.in: Add support for FreeBSD 2.2.x macro _THREAD_SAFE.
+1999-01-16 Tor Lillqvist <tml@iki.fi>
+
+ * Merge in current Win32 version:
+
+ * README.win32: More text.
+
+ * config.h.win32 glibconfig.h.win32: Update to match the
+ corresponding generated files on Unix.
+
+ * makefile.msc: Update with new source files, and gthread
+ library. Use the compiler flag -MD instead of using -D_DLL and
+ /nodefaultlib:libc msvcrt.lib in the link phase.
+
+ * glib.def: Update to include new functions, drop removed ones.
+
+ * glib.h: Add comments about main loop and polling on Win32. (In
+ general, it's only for the GIMP's use.) Add Win32 IO Channel
+ functions. Remove the obsoleted old IO Channel stuff (which was
+ in #if 0 already).
+
+ * giowin32.c: New file.
+
+ * gmain.c: Include config.h, conditionalize <sys/time.h>
+ inclusion. Add g_poll implementation for Win32 (only for the
+ GIMP's needs for now, it's hard or even impossible to be as clean
+ and generic as on Unix). Implement g_get_current_time on Win32. If
+ threads aren't supported, don't try to wake up main thread's
+ loop. On Win32, use a semaphore and not a pipe to wake up the main
+ loop.
+
+ * gmessages.c: On Win32, allocate a console window if the standard
+ output handle is invalid before writing to stdout, and reopen stdout
+ to that console window.
+
+ * giochannel.c: Conditionalize unistd.h inclusion. Some indentation
+ cleanup.
+
+ * gstrfuncs.c: Include <signal.h>.
+
+ * gutils.c: On Win32, also check the HOMEDRIVE and HOMEPATH
+ environment variables.
+
Sun Jan 17 01:06:38 1999 Timur Bakeyev <mc@bat.ru>
* configure.in: Add support for FreeBSD 2.2.x macro _THREAD_SAFE.
-For more information about the Windows port, see
-http://www.iki.fi/tml/gimp/win32/ .
+For more information about the port or GLib, GTk+ and the GIMP to
+native Windows, see http://www.iki.fi/tml/gimp/win32/ . ("Native"
+means that we use the Win32 API only, and not any POSIX emulation
+layer except that provided by the Microsoft runtime C library, and the
+pthreads emulation library from Cygnus.)
-As for now, only Microsoft C is really supported. Before compiling,
-check the BIN definition in makefile.msc. Compile with `nmake -f
-makefile.msc`. Install with `nmake -f makefile.msc install`. Gnu-Win32
-with egcs and maybe LCC-Win32 support will be added later.
+As for now, only the Microsoft compiler and tools are really
+supported. Before compiling, check the BIN definition in
+makefile.msc. Compile with `nmake -f makefile.msc`. Install with
+`nmake -f makefile.msc install`. Cygwin (without cygwin runtime,
+i.e. "mingw32") and maybe LCC-Win32 support will be added later. Note
+that when using the cygwin compiler and other tools *with* the cygwin
+runtime the normal Unix configuration method should work.
+
+The thread support uses the pthreads package from Cygnus, which isn't
+ready yet, and thus really should not be relied upon.
/* #undef ENABLE_MEM_PROFILE */
#define G_COMPILED_WITH_DEBUGGING "minimum"
+
/* #undef HAVE_BROKEN_WCTYPE */
/* #undef HAVE_DOPRNT */
#define HAVE_FLOAT_H 1
#define HAVE_LIMITS_H 1
+/* #undef HAVE_LOCALTIME_R */
/* #undef HAVE_LONG_DOUBLE */
+/* #undef HAVE_POLL */
/* #undef HAVE_PWD_H */
/* #undef HAVE_SYS_PARAM_H */
+/* #undef HAVE_SYS_POLL_H */
/* #undef HAVE_SYS_SELECT_H */
/* #undef HAVE_SYS_TIME_H */
/* #undef HAVE_SYS_TIMES_H */
#define GLIB_MAJOR_VERSION 1
#define GLIB_MINOR_VERSION 1
-#define GLIB_MICRO_VERSION 4
+#define GLIB_MICRO_VERSION 12
#define GLIB_INTERFACE_AGE 0
#define GLIB_BINARY_AGE 0
+#define G_THREAD_SOURCE "gthread-posix.c"
+#define G_THREADS_IMPL_POSIX
+
/* The number of bytes in a char. */
#define SIZEOF_CHAR 1
* MT safe
*/
+#include "config.h"
+
#include "glib.h"
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif
void
g_io_channel_init (GIOChannel *channel)
}
guint
-g_io_add_watch_full (GIOChannel *channel,
+g_io_add_watch_full (GIOChannel *channel,
gint priority,
GIOCondition condition,
GIOFunc func,
}
guint
-g_io_add_watch (GIOChannel *channel,
+g_io_add_watch (GIOChannel *channel,
GIOCondition condition,
GIOFunc func,
gpointer user_data)
--- /dev/null
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * giowin32.c: IO Channels for Win32.
+ * Copyright 1998 Owen Taylor and Tor Lillqvist
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+#include "glib.h"
+#include <windows.h>
+#include <winsock.h> /* Not everybody has winsock2 */
+#include <fcntl.h>
+#include <io.h>
+#include <errno.h>
+#include <sys/types.h>
+
+#include <stdio.h>
+
+typedef struct _GIOWin32Channel GIOWin32Channel;
+typedef struct _GIOWin32Watch GIOWin32Watch;
+
+guint g_pipe_readable_msg;
+
+typedef enum {
+ G_IO_WINDOWS_MESSAGES, /* Windows messages */
+ G_IO_FILE_DESC, /* Unix-like file descriptors from _open*/
+ G_IO_PIPE, /* pipe, with windows messages for signalling */
+ G_IO_STREAM_SOCKET /* Stream sockets */
+} GIOWin32ChannelType;
+
+struct _GIOWin32Channel {
+ GIOChannel channel;
+ gint fd; /* Either a Unix-like file handle as provided
+ * by the Microsoft C runtime, or a SOCKET
+ * as provided by WinSock.
+ */
+ GIOWin32ChannelType type;
+
+ /* This is used by G_IO_WINDOWS_MESSAGES channels */
+ HWND hwnd; /* handle of window, or NULL */
+
+ /* This is used by G_IO_PIPE channels */
+ guint peer; /* thread id of reader */
+ guint peer_fd; /* fd in the reader */
+ guint offset; /* counter of accumulated bytes */
+ guint need_wakeups; /* in output channels whether the
+ * reader needs wakeups
+ */
+};
+
+struct _GIOWin32Watch {
+ GPollFD pollfd;
+ GIOChannel *channel;
+ GIOCondition condition;
+ GIOFunc callback;
+};
+
+static gboolean g_io_win32_msg_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout);
+static gboolean g_io_win32_msg_check (gpointer source_data,
+ GTimeVal *current_time);
+static gboolean g_io_win32_msg_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data);
+
+static gboolean g_io_win32_fd_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout);
+static gboolean g_io_win32_fd_check (gpointer source_data,
+ GTimeVal *current_time);
+static gboolean g_io_win32_fd_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data);
+
+static gboolean g_io_win32_pipe_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout);
+static gboolean g_io_win32_pipe_check (gpointer source_data,
+ GTimeVal *current_time);
+static gboolean g_io_win32_pipe_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data);
+static void g_io_win32_pipe_destroy (gpointer source_data);
+
+static gboolean g_io_win32_sock_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout);
+static gboolean g_io_win32_sock_check (gpointer source_data,
+ GTimeVal *current_time);
+static gboolean g_io_win32_sock_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data);
+
+static void g_io_win32_destroy (gpointer source_data);
+
+static GIOError g_io_win32_msg_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+
+static GIOError g_io_win32_msg_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static GIOError g_io_win32_msg_seek (GIOChannel *channel,
+ gint offset,
+ GSeekType type);
+static void g_io_win32_msg_close (GIOChannel *channel);
+static guint g_io_win32_msg_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify);
+
+static GIOError g_io_win32_fd_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static GIOError g_io_win32_fd_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static GIOError g_io_win32_fd_seek (GIOChannel *channel,
+ gint offset,
+ GSeekType type);
+static void g_io_win32_fd_close (GIOChannel *channel);
+
+static void g_io_win32_free (GIOChannel *channel);
+
+static guint g_io_win32_fd_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify);
+
+static GIOError g_io_win32_no_seek (GIOChannel *channel,
+ gint offset,
+ GSeekType type);
+
+static GIOError g_io_win32_pipe_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static GIOError g_io_win32_pipe_write (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static void g_io_win32_pipe_close (GIOChannel *channel);
+static guint g_io_win32_pipe_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify);
+static void g_io_win32_pipe_free (GIOChannel *channel);
+
+static GIOError g_io_win32_sock_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static GIOError g_io_win32_sock_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static void g_io_win32_sock_close (GIOChannel *channel);
+static guint g_io_win32_sock_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify);
+
+GSourceFuncs win32_watch_msg_funcs = {
+ g_io_win32_msg_prepare,
+ g_io_win32_msg_check,
+ g_io_win32_msg_dispatch,
+ g_io_win32_destroy
+};
+
+GSourceFuncs win32_watch_fd_funcs = {
+ g_io_win32_fd_prepare,
+ g_io_win32_fd_check,
+ g_io_win32_fd_dispatch,
+ g_io_win32_destroy
+};
+
+GSourceFuncs win32_watch_pipe_funcs = {
+ g_io_win32_pipe_prepare,
+ g_io_win32_pipe_check,
+ g_io_win32_pipe_dispatch,
+ g_io_win32_pipe_destroy
+};
+
+GSourceFuncs win32_watch_sock_funcs = {
+ g_io_win32_sock_prepare,
+ g_io_win32_sock_check,
+ g_io_win32_sock_dispatch,
+ g_io_win32_destroy
+};
+
+GIOFuncs win32_channel_msg_funcs = {
+ g_io_win32_msg_read,
+ g_io_win32_msg_write,
+ g_io_win32_no_seek,
+ g_io_win32_msg_close,
+ g_io_win32_msg_add_watch,
+ g_io_win32_free
+};
+
+GIOFuncs win32_channel_fd_funcs = {
+ g_io_win32_fd_read,
+ g_io_win32_fd_write,
+ g_io_win32_fd_seek,
+ g_io_win32_fd_close,
+ g_io_win32_fd_add_watch,
+ g_io_win32_free
+};
+
+GIOFuncs win32_channel_pipe_funcs = {
+ g_io_win32_pipe_read,
+ g_io_win32_pipe_write,
+ g_io_win32_no_seek,
+ g_io_win32_pipe_close,
+ g_io_win32_pipe_add_watch,
+ g_io_win32_pipe_free
+};
+
+GIOFuncs win32_channel_sock_funcs = {
+ g_io_win32_sock_read,
+ g_io_win32_sock_write,
+ g_io_win32_no_seek,
+ g_io_win32_sock_close,
+ g_io_win32_sock_add_watch,
+ g_io_win32_free
+};
+
+#define N_WATCHED_PIPES 4
+
+static struct {
+ gint fd;
+ GIOWin32Watch *watch;
+ GIOWin32Channel *channel;
+ gpointer user_data;
+} watched_pipes[N_WATCHED_PIPES];
+
+static gint n_watched_pipes = 0;
+
+static gboolean
+g_io_win32_msg_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout)
+{
+ GIOWin32Watch *data = source_data;
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) data->channel;
+ MSG msg;
+
+ *timeout = -1;
+
+ return PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_NOREMOVE) == TRUE;
+}
+
+static gboolean
+g_io_win32_msg_check (gpointer source_data,
+ GTimeVal *current_time)
+{
+ GIOWin32Watch *data = source_data;
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) data->channel;
+ MSG msg;
+
+ return PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_NOREMOVE) == TRUE;
+}
+
+static gboolean
+g_io_win32_msg_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data)
+
+{
+ GIOWin32Watch *data = source_data;
+
+ return (*data->callback)(data->channel,
+ data->pollfd.revents & data->condition,
+ user_data);
+}
+
+static void
+g_io_win32_destroy (gpointer source_data)
+{
+ GIOWin32Watch *data = source_data;
+
+ g_main_remove_poll (&data->pollfd);
+ g_io_channel_unref (data->channel);
+ g_free (data);
+}
+
+static gboolean
+g_io_win32_fd_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout)
+{
+ *timeout = -1;
+
+ return FALSE;
+}
+
+static gboolean
+g_io_win32_fd_check (gpointer source_data,
+ GTimeVal *current_time)
+{
+ GIOWin32Watch *data = source_data;
+
+ return (data->pollfd.revents & data->condition);
+}
+
+static gboolean
+g_io_win32_fd_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data)
+
+{
+ GIOWin32Watch *data = source_data;
+
+ return (*data->callback)(data->channel,
+ data->pollfd.revents & data->condition,
+ user_data);
+}
+
+static GIOError
+g_io_win32_msg_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_read)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ MSG msg; /* In case of alignment problems */
+
+ if (count < sizeof (MSG))
+ return G_IO_ERROR_INVAL;
+
+ if (!PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_REMOVE))
+ return G_IO_ERROR_AGAIN;
+
+ memmove (buf, &msg, sizeof (MSG));
+ *bytes_read = sizeof (MSG);
+ return G_IO_ERROR_NONE;
+}
+
+static GIOError
+g_io_win32_msg_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ MSG msg;
+ gint result;
+
+ if (count != sizeof (MSG))
+ return G_IO_ERROR_INVAL;
+
+ /* In case of alignment problems */
+ memmove (&msg, buf, sizeof (MSG));
+ if (!PostMessage (win32_channel->hwnd, msg.message, msg.wParam, msg.lParam))
+ return G_IO_ERROR_UNKNOWN;
+
+ *bytes_written = sizeof (MSG);
+ return G_IO_ERROR_NONE;
+}
+
+static GIOError
+g_io_win32_no_seek (GIOChannel *channel,
+ gint offset,
+ GSeekType type)
+{
+ g_warning ("g_io_win32_no_seek: unseekable IO channel type");
+ return G_IO_ERROR_UNKNOWN;
+}
+
+
+static void
+g_io_win32_msg_close (GIOChannel *channel)
+{
+ /* Nothing to be done. Or should we set hwnd to some invalid value? */
+}
+
+static void
+g_io_win32_free (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ g_free (win32_channel);
+}
+
+static guint
+g_io_win32_msg_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify)
+{
+ GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ watch->channel = channel;
+ g_io_channel_ref (channel);
+
+ watch->callback = func;
+ watch->condition = condition;
+
+ watch->pollfd.fd = G_WIN32_MSG_HANDLE;
+ watch->pollfd.events = condition;
+
+ g_main_add_poll (&watch->pollfd, priority);
+
+ return g_source_add (priority, TRUE, &win32_watch_msg_funcs,
+ watch, user_data, notify);
+}
+
+static gboolean
+g_io_win32_pipe_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout)
+{
+ *timeout = -1;
+
+ return FALSE;
+}
+
+static gboolean
+g_io_win32_pipe_check (gpointer source_data,
+ GTimeVal *current_time)
+{
+ GIOWin32Watch *data = source_data;
+ return FALSE;
+}
+
+static gboolean
+g_io_win32_pipe_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data)
+
+{
+ GIOWin32Watch *data = source_data;
+
+ return (*data->callback)(data->channel,
+ data->pollfd.revents & data->condition,
+ user_data);
+}
+
+static void
+g_io_win32_pipe_destroy (gpointer source_data)
+{
+ GIOWin32Watch *data = source_data;
+
+ g_io_channel_unref (data->channel);
+ g_free (data);
+}
+
+static gboolean
+g_io_win32_sock_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout)
+{
+ *timeout = -1;
+
+ return FALSE;
+}
+
+static gboolean
+g_io_win32_sock_check (gpointer source_data,
+ GTimeVal *current_time)
+{
+ GIOWin32Watch *data = source_data;
+
+ return (data->pollfd.revents & data->condition);
+}
+
+static gboolean
+g_io_win32_sock_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data)
+
+{
+ GIOWin32Watch *data = source_data;
+
+ return (*data->callback)(data->channel,
+ data->pollfd.revents & data->condition,
+ user_data);
+}
+
+static GIOError
+g_io_win32_fd_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_read)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint result;
+
+ result = read (win32_channel->fd, buf, count);
+ if (result < 0)
+ {
+ *bytes_read = 0;
+ switch (errno)
+ {
+ case EINVAL:
+ return G_IO_ERROR_INVAL;
+ case EAGAIN:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ *bytes_read = result;
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static GIOError
+g_io_win32_fd_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint result;
+
+ result = write (win32_channel->fd, buf, count);
+
+ if (result < 0)
+ {
+ *bytes_written = 0;
+ switch (errno)
+ {
+ case EINVAL:
+ return G_IO_ERROR_INVAL;
+ case EAGAIN:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ *bytes_written = result;
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static GIOError
+g_io_win32_fd_seek (GIOChannel *channel,
+ gint offset,
+ GSeekType type)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ int whence;
+ off_t result;
+
+ switch (type)
+ {
+ case G_SEEK_SET:
+ whence = SEEK_SET;
+ break;
+ case G_SEEK_CUR:
+ whence = SEEK_CUR;
+ break;
+ case G_SEEK_END:
+ whence = SEEK_END;
+ break;
+ default:
+ g_warning ("g_io_win32_fd_seek: unknown seek type");
+ return G_IO_ERROR_UNKNOWN;
+ }
+
+ result = lseek (win32_channel->fd, offset, whence);
+
+ if (result < 0)
+ {
+ switch (errno)
+ {
+ case EINVAL:
+ return G_IO_ERROR_INVAL;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ return G_IO_ERROR_NONE;
+}
+
+static void
+g_io_win32_fd_close (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ close (win32_channel->fd);
+ return;
+}
+
+static guint
+g_io_win32_fd_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify)
+{
+ GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ watch->channel = channel;
+ g_io_channel_ref (channel);
+
+ watch->callback = func;
+ watch->condition = condition;
+
+ /* This probably does not work, except for CONIN$. */
+ watch->pollfd.fd = _get_osfhandle (win32_channel->fd);
+ watch->pollfd.events = condition;
+
+ g_main_add_poll (&watch->pollfd, priority);
+
+ return g_source_add (priority, TRUE, &win32_watch_fd_funcs,
+ watch, user_data, notify);
+}
+
+static GIOError
+g_io_win32_pipe_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_read)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ HANDLE handle;
+ DWORD avail;
+ gint result;
+
+ handle = (HANDLE) _get_osfhandle (win32_channel->fd);
+ if (!PeekNamedPipe (handle, NULL, 0, NULL, &avail, NULL))
+ {
+ return G_IO_ERROR_UNKNOWN;
+ }
+
+ count = MIN (count, avail);
+
+ count = MAX (count, 1); /* Must read at least one byte, or
+ * caller will think it's EOF.
+ */
+ /* g_print ("g_io_win32_pipe_read: %d %d\n", win32_channel->fd, count); */
+ if (count == 0)
+ result = 0;
+ else
+ result = read (win32_channel->fd, buf, count);
+ if (result < 0)
+ {
+ *bytes_read = 0;
+ switch (errno)
+ {
+ case EINVAL:
+ return G_IO_ERROR_INVAL;
+ case EAGAIN:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ *bytes_read = result;
+ win32_channel->offset += result;
+ /* g_print ("=%d (%d)\n", result, win32_channel->offset); */
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static GIOError
+g_io_win32_pipe_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ LONG prevcnt;
+ gint result;
+
+ /* g_print ("g_io_win32_pipe_write: %d %d\n", win32_channel->fd, count); */
+ result = write (win32_channel->fd, buf, count);
+ if (result < 0)
+ {
+ *bytes_written = 0;
+ switch (errno)
+ {
+ case EINVAL:
+ return G_IO_ERROR_INVAL;
+ case EAGAIN:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ if (g_pipe_readable_msg == 0)
+ g_pipe_readable_msg = RegisterWindowMessage ("g-pipe-readable");
+
+ win32_channel->offset += result;
+ /* g_print ("=%d (%d)\n", result, win32_channel->offset); */
+ if (win32_channel->need_wakeups)
+ {
+ PostThreadMessage (win32_channel->peer,
+ g_pipe_readable_msg,
+ win32_channel->peer_fd,
+ win32_channel->offset);
+ }
+ *bytes_written = result;
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static void
+g_io_win32_pipe_close (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ /* g_print ("g_io_win32_pipe_close: %#x %d\n", channel, win32_channel->fd); */
+
+ close (win32_channel->fd);
+ return;
+}
+
+static guint
+g_io_win32_pipe_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify)
+{
+ GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint i;
+
+ /* g_print ("g_io_win32_pipe_add_watch: %d\n", win32_channel->fd); */
+
+ watch->channel = channel;
+ g_io_channel_ref (channel);
+
+ watch->callback = func;
+ watch->condition = condition;
+
+ watch->pollfd.fd = win32_channel->fd;
+ watch->pollfd.events = condition;
+
+ for (i = 0; i < n_watched_pipes; i++)
+ if (watched_pipes[i].fd == -1)
+ break;
+ if (i == N_WATCHED_PIPES)
+ g_error ("Too many watched pipes");
+ else
+ {
+ watched_pipes[i].fd = win32_channel->fd;
+ watched_pipes[i].watch = watch;
+ watched_pipes[i].channel = win32_channel;
+ watched_pipes[i].user_data = user_data;
+ n_watched_pipes = MAX (i + 1, n_watched_pipes);
+ }
+ return g_source_add (priority, FALSE, &win32_watch_pipe_funcs, watch, user_data, notify);
+}
+
+static void
+g_io_win32_pipe_free (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint i;
+
+ /* g_print ("g_io_win32_pipe_free: %#x %#x\n", channel, channel->channel_data); */
+
+ for (i = 0; i < n_watched_pipes; i++)
+ if (watched_pipes[i].fd == win32_channel->fd)
+ {
+ watched_pipes[i].fd = -1;
+ break;
+ }
+ g_io_win32_free (channel);
+}
+
+static GIOError
+g_io_win32_sock_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_read)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint result;
+
+ result = recv (win32_channel->fd, buf, count, 0);
+ if (result == SOCKET_ERROR)
+ {
+ *bytes_read = 0;
+ switch (WSAGetLastError ())
+ {
+ case WSAEINVAL:
+ return G_IO_ERROR_INVAL;
+ case WSAEWOULDBLOCK:
+ case WSAEINTR:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ *bytes_read = result;
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static GIOError
+g_io_win32_sock_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint result;
+
+ result = send (win32_channel->fd, buf, count, 0);
+
+ if (result == SOCKET_ERROR)
+ {
+ *bytes_written = 0;
+ switch (WSAGetLastError ())
+ {
+ case WSAEINVAL:
+ return G_IO_ERROR_INVAL;
+ case WSAEWOULDBLOCK:
+ case WSAEINTR:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ *bytes_written = result;
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static void
+g_io_win32_sock_close (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ closesocket (win32_channel->fd);
+ return;
+}
+
+static guint
+g_io_win32_sock_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify)
+{
+ GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ watch->channel = channel;
+ g_io_channel_ref (channel);
+
+ watch->callback = func;
+ watch->condition = condition;
+
+ watch->pollfd.fd = win32_channel->fd;
+ watch->pollfd.events = condition;
+
+ g_main_add_poll (&watch->pollfd, priority);
+
+ return g_source_add (priority, TRUE, &win32_watch_sock_funcs, watch, user_data, notify);
+}
+
+GIOChannel *
+g_io_channel_win32_new_messages (guint hwnd)
+{
+ GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
+ GIOChannel *channel = (GIOChannel *) win32_channel;
+
+ g_io_channel_init (channel);
+ channel->funcs = &win32_channel_msg_funcs;
+ win32_channel->fd = -1;
+ win32_channel->type = G_IO_WINDOWS_MESSAGES;
+ win32_channel->hwnd = (HWND) hwnd;
+
+ return channel;
+}
+
+GIOChannel *
+g_io_channel_unix_new (gint fd)
+{
+ GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
+ GIOChannel *channel = (GIOChannel *) win32_channel;
+
+ g_io_channel_init (channel);
+ channel->funcs = &win32_channel_fd_funcs;
+ win32_channel->fd = fd;
+ win32_channel->type = G_IO_FILE_DESC;
+
+ return channel;
+}
+
+gint
+g_io_channel_unix_get_fd (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ return win32_channel->fd;
+}
+
+GIOChannel *
+g_io_channel_win32_new_pipe_with_wakeups (int fd,
+ guint peer,
+ int peer_fd)
+{
+ GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
+ GIOChannel *channel = (GIOChannel *) win32_channel;
+
+ /* g_print ("g_io_channel_win32_new_pipe_with_wakeups %d %#x %d\n", fd, peer, peer_fd); */
+
+ g_io_channel_init (channel);
+ channel->funcs = &win32_channel_pipe_funcs;
+ win32_channel->fd = fd;
+ win32_channel->type = G_IO_PIPE;
+ win32_channel->peer = peer;
+ win32_channel->peer_fd = peer_fd;
+ win32_channel->offset = 0;
+ win32_channel->need_wakeups = TRUE;
+
+ return channel;
+}
+
+GIOChannel *
+g_io_channel_win32_new_pipe (int fd)
+{
+ GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
+ GIOChannel *channel = (GIOChannel *) win32_channel;
+
+ g_io_channel_init (channel);
+ channel->funcs = &win32_channel_pipe_funcs;
+ win32_channel->fd = fd;
+ win32_channel->type = G_IO_PIPE;
+ win32_channel->offset = 0;
+ win32_channel->need_wakeups = FALSE;
+
+ return channel;
+}
+
+GIOChannel *
+g_io_channel_win32_new_stream_socket (int socket)
+{
+ GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
+ GIOChannel *channel = (GIOChannel *) win32_channel;
+
+ g_io_channel_init (channel);
+ channel->funcs = &win32_channel_sock_funcs;
+ win32_channel->fd = socket;
+ win32_channel->type = G_IO_STREAM_SOCKET;
+
+ return channel;
+}
+
+gint
+g_io_channel_win32_get_fd (GIOChannel *channel)
+{
+ return g_io_channel_unix_get_fd (channel);
+}
+
+void
+g_io_channel_win32_pipe_request_wakeups (GIOChannel *channel,
+ guint peer,
+ int peer_fd)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ win32_channel->peer = peer;
+ win32_channel->peer_fd = peer_fd;
+ win32_channel->need_wakeups = TRUE;
+}
+
+void
+g_io_channel_win32_pipe_readable (gint fd,
+ guint offset)
+{
+ gint i;
+
+ for (i = 0; i < n_watched_pipes; i++)
+ if (watched_pipes[i].fd == fd)
+ {
+ if (watched_pipes[i].channel->offset < offset)
+ (*watched_pipes[i].watch->callback) (watched_pipes[i].watch->channel,
+ G_IO_IN,
+ watched_pipes[i].user_data);
+ break;
+ }
+}
EXPORTS
g_array_append_vals
g_array_free
+ g_array_insert_vals
g_array_new
g_array_prepend_vals
g_array_remove_index
g_dataset_id_get_data
g_dataset_id_remove_no_notify
g_dataset_id_set_data_full
+ g_date_add_days
+ g_date_add_months
+ g_date_add_years
+ g_date_clear
+ g_date_compare
+ g_date_day
+ g_date_day_of_year
+ g_date_days_in_month
+ g_date_free
+ g_date_is_first_of_month
+ g_date_is_last_of_month
+ g_date_is_leap_year
+ g_date_julian
+ g_date_julian
+ g_date_monday_week_of_year
+ g_date_monday_weeks_in_year
+ g_date_new
+ g_date_new_dmy
+ g_date_new_julian
+ g_date_month
+ g_date_set_day
+ g_date_set_dmy
+ g_date_set_julian
+ g_date_set_month
+ g_date_set_parse
+ g_date_set_time
+ g_date_set_year
+ g_date_strftime
+ g_date_subtract_days
+ g_date_subtract_months
+ g_date_subtract_years
+ g_date_sunday_week_of_year
+ g_date_sunday_weeks_in_year
+ g_date_to_struct_tm
+ g_date_valid
+ g_date_valid_day
+ g_date_valid_dmy
+ g_date_valid_julian
+ g_date_valid_month
+ g_date_valid_weekday
+ g_date_valid_year
+ g_date_weekday
+ g_date_year
g_direct_equal
g_direct_hash
g_dirname
g_free
g_get_current_dir
+ g_get_current_time
g_get_home_dir
g_get_prgname
g_get_real_name
g_hook_list_invoke
g_hook_list_invoke_check
g_hook_list_marshal
+ g_hook_list_marshal_check
g_hook_list_clear
g_hook_next_valid
g_hook_prepend
g_hook_ref
g_hook_unref
+ g_idle_add
+ g_idle_add_full
g_int_equal
g_int_hash
- g_iochannel_new
- g_iochannel_free
- g_iochannel_close_and_free
- g_iochannel_wakeup_peer
+ g_io_add_watch
+ g_io_add_watch_full
+ g_io_channel_close
+ g_io_channel_init
+ g_io_channel_read
+ g_io_channel_ref
+ g_io_channel_seek
+ g_io_channel_unix_get_fd
+ g_io_channel_unix_new
+ g_io_channel_unref
+ g_io_channel_win32_get_fd
+ g_io_channel_win32_new_messages
+ g_io_channel_win32_new_pipe
+ g_io_channel_win32_new_pipe_with_wakeups
+ g_io_channel_win32_new_stream_socket
+ g_io_channel_win32_pipe_readable
+ g_io_channel_win32_pipe_request_wakeups
+ g_io_channel_write
g_list_alloc
- g_list_allocator_free
- g_list_allocator_new
g_list_append
g_list_concat
+ g_list_copy
g_list_find
g_list_find_custom
g_list_first
g_list_remove
g_list_remove_link
g_list_reverse
- g_list_set_allocator
g_list_sort
g_log
g_log_default_handler
g_log_set_fatal_mask
g_log_set_handler
g_logv
+ g_main_add_poll
+ g_main_destroy
+ g_main_is_running
+ g_main_iteration
+ g_main_new
+ g_main_pending
+ g_main_remove_poll
+ g_main_quit
+ g_main_run
+ g_main_set_poll_func
g_malloc
g_malloc0
g_mem_check
g_mem_chunk_new
g_mem_chunk_print
g_mem_chunk_reset
+ g_mem_init
g_mem_profile
g_memdup
+ g_messages_init
+ g_mutex_init
g_node_child_index
g_node_child_position
g_node_children_foreach
g_parse_debug_string
g_path_is_absolute
g_path_skip_root
+ g_pipe_readable_msg
g_print
g_printerr
g_printf_string_upper_bound
g_slist_alloc
g_slist_append
g_slist_concat
+ g_slist_copy
g_slist_find
g_slist_find_custom
g_slist_foreach
g_slist_remove
g_slist_remove_link
g_slist_reverse
- g_slist_set_allocator
g_slist_sort
g_snprintf
+ g_source_add
+ g_source_remove
+ g_source_remove_by_source_data
+ g_source_remove_by_user_data
+ g_static_mutex_get_mutex_impl
+ g_static_private_get
+ g_static_private_set
g_str_equal
g_str_hash
g_strcasecmp
g_strsplit
g_strtod
g_strup
+ g_timeout_add
+ g_timeout_add_full
g_timer_destroy
g_timer_elapsed
g_timer_new
/* GPollFD
*
- * Unix-specific IO and main loop calls
+ * System-specific IO and main loop calls
+ *
+ * On Win32, the fd in a GPollFD should be Win32 HANDLE (*not* a file
+ * descriptor as provided by the C runtime) that can be used by
+ * MsgWaitForMultipleObjects. This does *not* include file handles
+ * from CreateFile, SOCKETs, nor pipe handles. (But you can use
+ * WSAEventSelect to signal events when a SOCKET is readable).
+ *
+ * On Win32, fd can also be the special value G_WIN32_MSG_HANDLE to
+ * indicate polling for messages. These message queue GPollFDs should
+ * be added with the g_main_poll_win32_msg_add function.
+ *
+ * But note that G_WIN32_MSG_HANDLE GPollFDs should not be used by GDK
+ * (GTK) programs, as GDK itself wants to read messages and convert them
+ * to GDK events.
+ *
+ * So, unless you really know what you are doing, it's best not to try
+ * to use the main loop polling stuff for your own needs on
+ * Win32. It's really only written for the GIMP's needs so
+ * far.
*/
typedef struct _GPollFD GPollFD;
void g_main_remove_poll (GPollFD *fd);
void g_main_set_poll_func (GPollFunc func);
+/* On Unix, IO channels created with this function for any file
+ * descriptor or socket.
+ *
+ * On Win32, use this only for plain files opened with the MSVCRT (the
+ * Microsoft run-time C library) _open(), including file descriptors
+ * 0, 1 and 2 (corresponding to stdin, stdout and stderr).
+ * Actually, don't do even that, this code isn't done yet.
+ *
+ * The term file descriptor as used in the context of Win32 refers to
+ * the emulated Unix-like file descriptors MSVCRT provides.
+ */
GIOChannel* g_io_channel_unix_new (int fd);
gint g_io_channel_unix_get_fd (GIOChannel *channel);
+#ifdef NATIVE_WIN32
+
+GUTILS_C_VAR guint g_pipe_readable_msg;
-/* old IO Channels */
-#if 0
-/* IO Channels.
- * These are used for plug-in communication in the GIMP, for instance.
- * On Unix, it's simply an encapsulated file descriptor (a pipe).
- * On Windows, it's a handle to an anonymouos pipe, *and* (in the case
- * of the writable end) a thread id to post a message to when you have written
- * stuff.
+#define G_WIN32_MSG_HANDLE 19981206
+
+/* This is used to add polling for Windows messages. GDK (GTk+) programs
+ * should *not* use this. (In fact, I can't think of any program that
+ * would want to use this, but it's here just for completeness's sake.
*/
-struct _GIOChannel
-{
- gint fd; /* file handle (pseudo such in Win32) */
-#ifdef NATIVE_WIN32
- guint peer; /* thread to post message to */
- guint peer_fd; /* read handle (in the other process) */
- guint offset; /* counter of accumulated bytes, to
- * be included in the message posted
- * so we keep in sync.
- */
- guint need_wakeups; /* in output channels whether the reader
- * needs wakeups
- */
-#endif
-};
-GIOChannel *g_iochannel_new (gint fd);
-void g_iochannel_free (GIOChannel *channel);
-void g_iochannel_close_and_free (GIOChannel *channel);
-void g_iochannel_wakeup_peer (GIOChannel *channel);
-#ifndef NATIVE_WIN32
-# define g_iochannel_wakeup_peer(channel) G_STMT_START { } G_STMT_END
-#endif
-#endif /* old IO Channels */
+void g_main_poll_win32_msg_add(gint priority,
+ GPollFD *fd,
+ guint hwnd);
+
+/* An IO channel for Windows messages for window handle hwnd. */
+GIOChannel *g_io_channel_win32_new_messages (guint hwnd);
+
+/* An IO channel for an anonymous pipe as returned from the MSVCRT
+ * _pipe(), with no mechanism for the writer to tell the reader when
+ * there is data in the pipe.
+ *
+ * This is not really implemented yet.
+ */
+GIOChannel *g_io_channel_win32_new_pipe (int fd);
+/* An IO channel for a pipe as returned from the MSVCRT _pipe(), with
+ * Windows user messages used to signal data in the pipe for the
+ * reader.
+ *
+ * fd is the file descriptor. For the write end, peer is the thread id
+ * of the reader, and peer_fd is his file descriptor for the read end
+ * of the pipe.
+ *
+ * This is used by the GIMP, and works.
+ */
+GIOChannel *g_io_channel_win32_new_pipe_with_wakeups (int fd,
+ guint peer,
+ int peer_fd);
+
+void g_io_channel_win32_pipe_request_wakeups (GIOChannel *channel,
+ guint peer,
+ int peer_fd);
+
+void g_io_channel_win32_pipe_readable (int fd,
+ guint offset);
+
+/* Get the C runtime file descriptor of a channel. */
+gint g_io_channel_win32_get_fd (GIOChannel *channel);
+
+/* An IO channel for a SOCK_STREAM winsock socket. The parameter is
+ * actually a SOCKET.
+ */
+GIOChannel *g_io_channel_win32_new_stream_socket (int socket);
+
+#endif
-/* Windows emulation stubs for common unix functions
+/* Windows emulation stubs for common Unix functions
*/
#ifdef NATIVE_WIN32
# define MAXPATHLEN 1024
* MT safe
*/
+#include "config.h"
+
#include "glib.h"
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif
void
g_io_channel_init (GIOChannel *channel)
}
guint
-g_io_add_watch_full (GIOChannel *channel,
+g_io_add_watch_full (GIOChannel *channel,
gint priority,
GIOCondition condition,
GIOFunc func,
}
guint
-g_io_add_watch (GIOChannel *channel,
+g_io_add_watch (GIOChannel *channel,
GIOCondition condition,
GIOFunc func,
gpointer user_data)
--- /dev/null
+/* GLIB - Library of useful routines for C programming
+ * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
+ *
+ * giowin32.c: IO Channels for Win32.
+ * Copyright 1998 Owen Taylor and Tor Lillqvist
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library 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
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include "config.h"
+#include "glib.h"
+#include <windows.h>
+#include <winsock.h> /* Not everybody has winsock2 */
+#include <fcntl.h>
+#include <io.h>
+#include <errno.h>
+#include <sys/types.h>
+
+#include <stdio.h>
+
+typedef struct _GIOWin32Channel GIOWin32Channel;
+typedef struct _GIOWin32Watch GIOWin32Watch;
+
+guint g_pipe_readable_msg;
+
+typedef enum {
+ G_IO_WINDOWS_MESSAGES, /* Windows messages */
+ G_IO_FILE_DESC, /* Unix-like file descriptors from _open*/
+ G_IO_PIPE, /* pipe, with windows messages for signalling */
+ G_IO_STREAM_SOCKET /* Stream sockets */
+} GIOWin32ChannelType;
+
+struct _GIOWin32Channel {
+ GIOChannel channel;
+ gint fd; /* Either a Unix-like file handle as provided
+ * by the Microsoft C runtime, or a SOCKET
+ * as provided by WinSock.
+ */
+ GIOWin32ChannelType type;
+
+ /* This is used by G_IO_WINDOWS_MESSAGES channels */
+ HWND hwnd; /* handle of window, or NULL */
+
+ /* This is used by G_IO_PIPE channels */
+ guint peer; /* thread id of reader */
+ guint peer_fd; /* fd in the reader */
+ guint offset; /* counter of accumulated bytes */
+ guint need_wakeups; /* in output channels whether the
+ * reader needs wakeups
+ */
+};
+
+struct _GIOWin32Watch {
+ GPollFD pollfd;
+ GIOChannel *channel;
+ GIOCondition condition;
+ GIOFunc callback;
+};
+
+static gboolean g_io_win32_msg_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout);
+static gboolean g_io_win32_msg_check (gpointer source_data,
+ GTimeVal *current_time);
+static gboolean g_io_win32_msg_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data);
+
+static gboolean g_io_win32_fd_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout);
+static gboolean g_io_win32_fd_check (gpointer source_data,
+ GTimeVal *current_time);
+static gboolean g_io_win32_fd_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data);
+
+static gboolean g_io_win32_pipe_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout);
+static gboolean g_io_win32_pipe_check (gpointer source_data,
+ GTimeVal *current_time);
+static gboolean g_io_win32_pipe_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data);
+static void g_io_win32_pipe_destroy (gpointer source_data);
+
+static gboolean g_io_win32_sock_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout);
+static gboolean g_io_win32_sock_check (gpointer source_data,
+ GTimeVal *current_time);
+static gboolean g_io_win32_sock_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data);
+
+static void g_io_win32_destroy (gpointer source_data);
+
+static GIOError g_io_win32_msg_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+
+static GIOError g_io_win32_msg_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static GIOError g_io_win32_msg_seek (GIOChannel *channel,
+ gint offset,
+ GSeekType type);
+static void g_io_win32_msg_close (GIOChannel *channel);
+static guint g_io_win32_msg_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify);
+
+static GIOError g_io_win32_fd_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static GIOError g_io_win32_fd_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static GIOError g_io_win32_fd_seek (GIOChannel *channel,
+ gint offset,
+ GSeekType type);
+static void g_io_win32_fd_close (GIOChannel *channel);
+
+static void g_io_win32_free (GIOChannel *channel);
+
+static guint g_io_win32_fd_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify);
+
+static GIOError g_io_win32_no_seek (GIOChannel *channel,
+ gint offset,
+ GSeekType type);
+
+static GIOError g_io_win32_pipe_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static GIOError g_io_win32_pipe_write (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static void g_io_win32_pipe_close (GIOChannel *channel);
+static guint g_io_win32_pipe_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify);
+static void g_io_win32_pipe_free (GIOChannel *channel);
+
+static GIOError g_io_win32_sock_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static GIOError g_io_win32_sock_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written);
+static void g_io_win32_sock_close (GIOChannel *channel);
+static guint g_io_win32_sock_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify);
+
+GSourceFuncs win32_watch_msg_funcs = {
+ g_io_win32_msg_prepare,
+ g_io_win32_msg_check,
+ g_io_win32_msg_dispatch,
+ g_io_win32_destroy
+};
+
+GSourceFuncs win32_watch_fd_funcs = {
+ g_io_win32_fd_prepare,
+ g_io_win32_fd_check,
+ g_io_win32_fd_dispatch,
+ g_io_win32_destroy
+};
+
+GSourceFuncs win32_watch_pipe_funcs = {
+ g_io_win32_pipe_prepare,
+ g_io_win32_pipe_check,
+ g_io_win32_pipe_dispatch,
+ g_io_win32_pipe_destroy
+};
+
+GSourceFuncs win32_watch_sock_funcs = {
+ g_io_win32_sock_prepare,
+ g_io_win32_sock_check,
+ g_io_win32_sock_dispatch,
+ g_io_win32_destroy
+};
+
+GIOFuncs win32_channel_msg_funcs = {
+ g_io_win32_msg_read,
+ g_io_win32_msg_write,
+ g_io_win32_no_seek,
+ g_io_win32_msg_close,
+ g_io_win32_msg_add_watch,
+ g_io_win32_free
+};
+
+GIOFuncs win32_channel_fd_funcs = {
+ g_io_win32_fd_read,
+ g_io_win32_fd_write,
+ g_io_win32_fd_seek,
+ g_io_win32_fd_close,
+ g_io_win32_fd_add_watch,
+ g_io_win32_free
+};
+
+GIOFuncs win32_channel_pipe_funcs = {
+ g_io_win32_pipe_read,
+ g_io_win32_pipe_write,
+ g_io_win32_no_seek,
+ g_io_win32_pipe_close,
+ g_io_win32_pipe_add_watch,
+ g_io_win32_pipe_free
+};
+
+GIOFuncs win32_channel_sock_funcs = {
+ g_io_win32_sock_read,
+ g_io_win32_sock_write,
+ g_io_win32_no_seek,
+ g_io_win32_sock_close,
+ g_io_win32_sock_add_watch,
+ g_io_win32_free
+};
+
+#define N_WATCHED_PIPES 4
+
+static struct {
+ gint fd;
+ GIOWin32Watch *watch;
+ GIOWin32Channel *channel;
+ gpointer user_data;
+} watched_pipes[N_WATCHED_PIPES];
+
+static gint n_watched_pipes = 0;
+
+static gboolean
+g_io_win32_msg_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout)
+{
+ GIOWin32Watch *data = source_data;
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) data->channel;
+ MSG msg;
+
+ *timeout = -1;
+
+ return PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_NOREMOVE) == TRUE;
+}
+
+static gboolean
+g_io_win32_msg_check (gpointer source_data,
+ GTimeVal *current_time)
+{
+ GIOWin32Watch *data = source_data;
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) data->channel;
+ MSG msg;
+
+ return PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_NOREMOVE) == TRUE;
+}
+
+static gboolean
+g_io_win32_msg_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data)
+
+{
+ GIOWin32Watch *data = source_data;
+
+ return (*data->callback)(data->channel,
+ data->pollfd.revents & data->condition,
+ user_data);
+}
+
+static void
+g_io_win32_destroy (gpointer source_data)
+{
+ GIOWin32Watch *data = source_data;
+
+ g_main_remove_poll (&data->pollfd);
+ g_io_channel_unref (data->channel);
+ g_free (data);
+}
+
+static gboolean
+g_io_win32_fd_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout)
+{
+ *timeout = -1;
+
+ return FALSE;
+}
+
+static gboolean
+g_io_win32_fd_check (gpointer source_data,
+ GTimeVal *current_time)
+{
+ GIOWin32Watch *data = source_data;
+
+ return (data->pollfd.revents & data->condition);
+}
+
+static gboolean
+g_io_win32_fd_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data)
+
+{
+ GIOWin32Watch *data = source_data;
+
+ return (*data->callback)(data->channel,
+ data->pollfd.revents & data->condition,
+ user_data);
+}
+
+static GIOError
+g_io_win32_msg_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_read)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ MSG msg; /* In case of alignment problems */
+
+ if (count < sizeof (MSG))
+ return G_IO_ERROR_INVAL;
+
+ if (!PeekMessage (&msg, win32_channel->hwnd, 0, 0, PM_REMOVE))
+ return G_IO_ERROR_AGAIN;
+
+ memmove (buf, &msg, sizeof (MSG));
+ *bytes_read = sizeof (MSG);
+ return G_IO_ERROR_NONE;
+}
+
+static GIOError
+g_io_win32_msg_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ MSG msg;
+ gint result;
+
+ if (count != sizeof (MSG))
+ return G_IO_ERROR_INVAL;
+
+ /* In case of alignment problems */
+ memmove (&msg, buf, sizeof (MSG));
+ if (!PostMessage (win32_channel->hwnd, msg.message, msg.wParam, msg.lParam))
+ return G_IO_ERROR_UNKNOWN;
+
+ *bytes_written = sizeof (MSG);
+ return G_IO_ERROR_NONE;
+}
+
+static GIOError
+g_io_win32_no_seek (GIOChannel *channel,
+ gint offset,
+ GSeekType type)
+{
+ g_warning ("g_io_win32_no_seek: unseekable IO channel type");
+ return G_IO_ERROR_UNKNOWN;
+}
+
+
+static void
+g_io_win32_msg_close (GIOChannel *channel)
+{
+ /* Nothing to be done. Or should we set hwnd to some invalid value? */
+}
+
+static void
+g_io_win32_free (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ g_free (win32_channel);
+}
+
+static guint
+g_io_win32_msg_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify)
+{
+ GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ watch->channel = channel;
+ g_io_channel_ref (channel);
+
+ watch->callback = func;
+ watch->condition = condition;
+
+ watch->pollfd.fd = G_WIN32_MSG_HANDLE;
+ watch->pollfd.events = condition;
+
+ g_main_add_poll (&watch->pollfd, priority);
+
+ return g_source_add (priority, TRUE, &win32_watch_msg_funcs,
+ watch, user_data, notify);
+}
+
+static gboolean
+g_io_win32_pipe_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout)
+{
+ *timeout = -1;
+
+ return FALSE;
+}
+
+static gboolean
+g_io_win32_pipe_check (gpointer source_data,
+ GTimeVal *current_time)
+{
+ GIOWin32Watch *data = source_data;
+ return FALSE;
+}
+
+static gboolean
+g_io_win32_pipe_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data)
+
+{
+ GIOWin32Watch *data = source_data;
+
+ return (*data->callback)(data->channel,
+ data->pollfd.revents & data->condition,
+ user_data);
+}
+
+static void
+g_io_win32_pipe_destroy (gpointer source_data)
+{
+ GIOWin32Watch *data = source_data;
+
+ g_io_channel_unref (data->channel);
+ g_free (data);
+}
+
+static gboolean
+g_io_win32_sock_prepare (gpointer source_data,
+ GTimeVal *current_time,
+ gint *timeout)
+{
+ *timeout = -1;
+
+ return FALSE;
+}
+
+static gboolean
+g_io_win32_sock_check (gpointer source_data,
+ GTimeVal *current_time)
+{
+ GIOWin32Watch *data = source_data;
+
+ return (data->pollfd.revents & data->condition);
+}
+
+static gboolean
+g_io_win32_sock_dispatch (gpointer source_data,
+ GTimeVal *current_time,
+ gpointer user_data)
+
+{
+ GIOWin32Watch *data = source_data;
+
+ return (*data->callback)(data->channel,
+ data->pollfd.revents & data->condition,
+ user_data);
+}
+
+static GIOError
+g_io_win32_fd_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_read)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint result;
+
+ result = read (win32_channel->fd, buf, count);
+ if (result < 0)
+ {
+ *bytes_read = 0;
+ switch (errno)
+ {
+ case EINVAL:
+ return G_IO_ERROR_INVAL;
+ case EAGAIN:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ *bytes_read = result;
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static GIOError
+g_io_win32_fd_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint result;
+
+ result = write (win32_channel->fd, buf, count);
+
+ if (result < 0)
+ {
+ *bytes_written = 0;
+ switch (errno)
+ {
+ case EINVAL:
+ return G_IO_ERROR_INVAL;
+ case EAGAIN:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ *bytes_written = result;
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static GIOError
+g_io_win32_fd_seek (GIOChannel *channel,
+ gint offset,
+ GSeekType type)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ int whence;
+ off_t result;
+
+ switch (type)
+ {
+ case G_SEEK_SET:
+ whence = SEEK_SET;
+ break;
+ case G_SEEK_CUR:
+ whence = SEEK_CUR;
+ break;
+ case G_SEEK_END:
+ whence = SEEK_END;
+ break;
+ default:
+ g_warning ("g_io_win32_fd_seek: unknown seek type");
+ return G_IO_ERROR_UNKNOWN;
+ }
+
+ result = lseek (win32_channel->fd, offset, whence);
+
+ if (result < 0)
+ {
+ switch (errno)
+ {
+ case EINVAL:
+ return G_IO_ERROR_INVAL;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ return G_IO_ERROR_NONE;
+}
+
+static void
+g_io_win32_fd_close (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ close (win32_channel->fd);
+ return;
+}
+
+static guint
+g_io_win32_fd_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify)
+{
+ GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ watch->channel = channel;
+ g_io_channel_ref (channel);
+
+ watch->callback = func;
+ watch->condition = condition;
+
+ /* This probably does not work, except for CONIN$. */
+ watch->pollfd.fd = _get_osfhandle (win32_channel->fd);
+ watch->pollfd.events = condition;
+
+ g_main_add_poll (&watch->pollfd, priority);
+
+ return g_source_add (priority, TRUE, &win32_watch_fd_funcs,
+ watch, user_data, notify);
+}
+
+static GIOError
+g_io_win32_pipe_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_read)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ HANDLE handle;
+ DWORD avail;
+ gint result;
+
+ handle = (HANDLE) _get_osfhandle (win32_channel->fd);
+ if (!PeekNamedPipe (handle, NULL, 0, NULL, &avail, NULL))
+ {
+ return G_IO_ERROR_UNKNOWN;
+ }
+
+ count = MIN (count, avail);
+
+ count = MAX (count, 1); /* Must read at least one byte, or
+ * caller will think it's EOF.
+ */
+ /* g_print ("g_io_win32_pipe_read: %d %d\n", win32_channel->fd, count); */
+ if (count == 0)
+ result = 0;
+ else
+ result = read (win32_channel->fd, buf, count);
+ if (result < 0)
+ {
+ *bytes_read = 0;
+ switch (errno)
+ {
+ case EINVAL:
+ return G_IO_ERROR_INVAL;
+ case EAGAIN:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ *bytes_read = result;
+ win32_channel->offset += result;
+ /* g_print ("=%d (%d)\n", result, win32_channel->offset); */
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static GIOError
+g_io_win32_pipe_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ LONG prevcnt;
+ gint result;
+
+ /* g_print ("g_io_win32_pipe_write: %d %d\n", win32_channel->fd, count); */
+ result = write (win32_channel->fd, buf, count);
+ if (result < 0)
+ {
+ *bytes_written = 0;
+ switch (errno)
+ {
+ case EINVAL:
+ return G_IO_ERROR_INVAL;
+ case EAGAIN:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ if (g_pipe_readable_msg == 0)
+ g_pipe_readable_msg = RegisterWindowMessage ("g-pipe-readable");
+
+ win32_channel->offset += result;
+ /* g_print ("=%d (%d)\n", result, win32_channel->offset); */
+ if (win32_channel->need_wakeups)
+ {
+ PostThreadMessage (win32_channel->peer,
+ g_pipe_readable_msg,
+ win32_channel->peer_fd,
+ win32_channel->offset);
+ }
+ *bytes_written = result;
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static void
+g_io_win32_pipe_close (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ /* g_print ("g_io_win32_pipe_close: %#x %d\n", channel, win32_channel->fd); */
+
+ close (win32_channel->fd);
+ return;
+}
+
+static guint
+g_io_win32_pipe_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify)
+{
+ GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint i;
+
+ /* g_print ("g_io_win32_pipe_add_watch: %d\n", win32_channel->fd); */
+
+ watch->channel = channel;
+ g_io_channel_ref (channel);
+
+ watch->callback = func;
+ watch->condition = condition;
+
+ watch->pollfd.fd = win32_channel->fd;
+ watch->pollfd.events = condition;
+
+ for (i = 0; i < n_watched_pipes; i++)
+ if (watched_pipes[i].fd == -1)
+ break;
+ if (i == N_WATCHED_PIPES)
+ g_error ("Too many watched pipes");
+ else
+ {
+ watched_pipes[i].fd = win32_channel->fd;
+ watched_pipes[i].watch = watch;
+ watched_pipes[i].channel = win32_channel;
+ watched_pipes[i].user_data = user_data;
+ n_watched_pipes = MAX (i + 1, n_watched_pipes);
+ }
+ return g_source_add (priority, FALSE, &win32_watch_pipe_funcs, watch, user_data, notify);
+}
+
+static void
+g_io_win32_pipe_free (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint i;
+
+ /* g_print ("g_io_win32_pipe_free: %#x %#x\n", channel, channel->channel_data); */
+
+ for (i = 0; i < n_watched_pipes; i++)
+ if (watched_pipes[i].fd == win32_channel->fd)
+ {
+ watched_pipes[i].fd = -1;
+ break;
+ }
+ g_io_win32_free (channel);
+}
+
+static GIOError
+g_io_win32_sock_read (GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_read)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint result;
+
+ result = recv (win32_channel->fd, buf, count, 0);
+ if (result == SOCKET_ERROR)
+ {
+ *bytes_read = 0;
+ switch (WSAGetLastError ())
+ {
+ case WSAEINVAL:
+ return G_IO_ERROR_INVAL;
+ case WSAEWOULDBLOCK:
+ case WSAEINTR:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ *bytes_read = result;
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static GIOError
+g_io_win32_sock_write(GIOChannel *channel,
+ gchar *buf,
+ guint count,
+ guint *bytes_written)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+ gint result;
+
+ result = send (win32_channel->fd, buf, count, 0);
+
+ if (result == SOCKET_ERROR)
+ {
+ *bytes_written = 0;
+ switch (WSAGetLastError ())
+ {
+ case WSAEINVAL:
+ return G_IO_ERROR_INVAL;
+ case WSAEWOULDBLOCK:
+ case WSAEINTR:
+ return G_IO_ERROR_AGAIN;
+ default:
+ return G_IO_ERROR_UNKNOWN;
+ }
+ }
+ else
+ {
+ *bytes_written = result;
+ return G_IO_ERROR_NONE;
+ }
+}
+
+static void
+g_io_win32_sock_close (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ closesocket (win32_channel->fd);
+ return;
+}
+
+static guint
+g_io_win32_sock_add_watch (GIOChannel *channel,
+ gint priority,
+ GIOCondition condition,
+ GIOFunc func,
+ gpointer user_data,
+ GDestroyNotify notify)
+{
+ GIOWin32Watch *watch = g_new (GIOWin32Watch, 1);
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ watch->channel = channel;
+ g_io_channel_ref (channel);
+
+ watch->callback = func;
+ watch->condition = condition;
+
+ watch->pollfd.fd = win32_channel->fd;
+ watch->pollfd.events = condition;
+
+ g_main_add_poll (&watch->pollfd, priority);
+
+ return g_source_add (priority, TRUE, &win32_watch_sock_funcs, watch, user_data, notify);
+}
+
+GIOChannel *
+g_io_channel_win32_new_messages (guint hwnd)
+{
+ GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
+ GIOChannel *channel = (GIOChannel *) win32_channel;
+
+ g_io_channel_init (channel);
+ channel->funcs = &win32_channel_msg_funcs;
+ win32_channel->fd = -1;
+ win32_channel->type = G_IO_WINDOWS_MESSAGES;
+ win32_channel->hwnd = (HWND) hwnd;
+
+ return channel;
+}
+
+GIOChannel *
+g_io_channel_unix_new (gint fd)
+{
+ GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
+ GIOChannel *channel = (GIOChannel *) win32_channel;
+
+ g_io_channel_init (channel);
+ channel->funcs = &win32_channel_fd_funcs;
+ win32_channel->fd = fd;
+ win32_channel->type = G_IO_FILE_DESC;
+
+ return channel;
+}
+
+gint
+g_io_channel_unix_get_fd (GIOChannel *channel)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ return win32_channel->fd;
+}
+
+GIOChannel *
+g_io_channel_win32_new_pipe_with_wakeups (int fd,
+ guint peer,
+ int peer_fd)
+{
+ GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
+ GIOChannel *channel = (GIOChannel *) win32_channel;
+
+ /* g_print ("g_io_channel_win32_new_pipe_with_wakeups %d %#x %d\n", fd, peer, peer_fd); */
+
+ g_io_channel_init (channel);
+ channel->funcs = &win32_channel_pipe_funcs;
+ win32_channel->fd = fd;
+ win32_channel->type = G_IO_PIPE;
+ win32_channel->peer = peer;
+ win32_channel->peer_fd = peer_fd;
+ win32_channel->offset = 0;
+ win32_channel->need_wakeups = TRUE;
+
+ return channel;
+}
+
+GIOChannel *
+g_io_channel_win32_new_pipe (int fd)
+{
+ GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
+ GIOChannel *channel = (GIOChannel *) win32_channel;
+
+ g_io_channel_init (channel);
+ channel->funcs = &win32_channel_pipe_funcs;
+ win32_channel->fd = fd;
+ win32_channel->type = G_IO_PIPE;
+ win32_channel->offset = 0;
+ win32_channel->need_wakeups = FALSE;
+
+ return channel;
+}
+
+GIOChannel *
+g_io_channel_win32_new_stream_socket (int socket)
+{
+ GIOWin32Channel *win32_channel = g_new (GIOWin32Channel, 1);
+ GIOChannel *channel = (GIOChannel *) win32_channel;
+
+ g_io_channel_init (channel);
+ channel->funcs = &win32_channel_sock_funcs;
+ win32_channel->fd = socket;
+ win32_channel->type = G_IO_STREAM_SOCKET;
+
+ return channel;
+}
+
+gint
+g_io_channel_win32_get_fd (GIOChannel *channel)
+{
+ return g_io_channel_unix_get_fd (channel);
+}
+
+void
+g_io_channel_win32_pipe_request_wakeups (GIOChannel *channel,
+ guint peer,
+ int peer_fd)
+{
+ GIOWin32Channel *win32_channel = (GIOWin32Channel *) channel;
+
+ win32_channel->peer = peer;
+ win32_channel->peer_fd = peer_fd;
+ win32_channel->need_wakeups = TRUE;
+}
+
+void
+g_io_channel_win32_pipe_readable (gint fd,
+ guint offset)
+{
+ gint i;
+
+ for (i = 0; i < n_watched_pipes; i++)
+ if (watched_pipes[i].fd == fd)
+ {
+ if (watched_pipes[i].channel->offset < offset)
+ (*watched_pipes[i].watch->callback) (watched_pipes[i].watch->channel,
+ G_IO_IN,
+ watched_pipes[i].user_data);
+ break;
+ }
+}
EXPORTS
g_array_append_vals
g_array_free
+ g_array_insert_vals
g_array_new
g_array_prepend_vals
g_array_remove_index
g_dataset_id_get_data
g_dataset_id_remove_no_notify
g_dataset_id_set_data_full
+ g_date_add_days
+ g_date_add_months
+ g_date_add_years
+ g_date_clear
+ g_date_compare
+ g_date_day
+ g_date_day_of_year
+ g_date_days_in_month
+ g_date_free
+ g_date_is_first_of_month
+ g_date_is_last_of_month
+ g_date_is_leap_year
+ g_date_julian
+ g_date_julian
+ g_date_monday_week_of_year
+ g_date_monday_weeks_in_year
+ g_date_new
+ g_date_new_dmy
+ g_date_new_julian
+ g_date_month
+ g_date_set_day
+ g_date_set_dmy
+ g_date_set_julian
+ g_date_set_month
+ g_date_set_parse
+ g_date_set_time
+ g_date_set_year
+ g_date_strftime
+ g_date_subtract_days
+ g_date_subtract_months
+ g_date_subtract_years
+ g_date_sunday_week_of_year
+ g_date_sunday_weeks_in_year
+ g_date_to_struct_tm
+ g_date_valid
+ g_date_valid_day
+ g_date_valid_dmy
+ g_date_valid_julian
+ g_date_valid_month
+ g_date_valid_weekday
+ g_date_valid_year
+ g_date_weekday
+ g_date_year
g_direct_equal
g_direct_hash
g_dirname
g_free
g_get_current_dir
+ g_get_current_time
g_get_home_dir
g_get_prgname
g_get_real_name
g_hook_list_invoke
g_hook_list_invoke_check
g_hook_list_marshal
+ g_hook_list_marshal_check
g_hook_list_clear
g_hook_next_valid
g_hook_prepend
g_hook_ref
g_hook_unref
+ g_idle_add
+ g_idle_add_full
g_int_equal
g_int_hash
- g_iochannel_new
- g_iochannel_free
- g_iochannel_close_and_free
- g_iochannel_wakeup_peer
+ g_io_add_watch
+ g_io_add_watch_full
+ g_io_channel_close
+ g_io_channel_init
+ g_io_channel_read
+ g_io_channel_ref
+ g_io_channel_seek
+ g_io_channel_unix_get_fd
+ g_io_channel_unix_new
+ g_io_channel_unref
+ g_io_channel_win32_get_fd
+ g_io_channel_win32_new_messages
+ g_io_channel_win32_new_pipe
+ g_io_channel_win32_new_pipe_with_wakeups
+ g_io_channel_win32_new_stream_socket
+ g_io_channel_win32_pipe_readable
+ g_io_channel_win32_pipe_request_wakeups
+ g_io_channel_write
g_list_alloc
- g_list_allocator_free
- g_list_allocator_new
g_list_append
g_list_concat
+ g_list_copy
g_list_find
g_list_find_custom
g_list_first
g_list_remove
g_list_remove_link
g_list_reverse
- g_list_set_allocator
g_list_sort
g_log
g_log_default_handler
g_log_set_fatal_mask
g_log_set_handler
g_logv
+ g_main_add_poll
+ g_main_destroy
+ g_main_is_running
+ g_main_iteration
+ g_main_new
+ g_main_pending
+ g_main_remove_poll
+ g_main_quit
+ g_main_run
+ g_main_set_poll_func
g_malloc
g_malloc0
g_mem_check
g_mem_chunk_new
g_mem_chunk_print
g_mem_chunk_reset
+ g_mem_init
g_mem_profile
g_memdup
+ g_messages_init
+ g_mutex_init
g_node_child_index
g_node_child_position
g_node_children_foreach
g_parse_debug_string
g_path_is_absolute
g_path_skip_root
+ g_pipe_readable_msg
g_print
g_printerr
g_printf_string_upper_bound
g_slist_alloc
g_slist_append
g_slist_concat
+ g_slist_copy
g_slist_find
g_slist_find_custom
g_slist_foreach
g_slist_remove
g_slist_remove_link
g_slist_reverse
- g_slist_set_allocator
g_slist_sort
g_snprintf
+ g_source_add
+ g_source_remove
+ g_source_remove_by_source_data
+ g_source_remove_by_user_data
+ g_static_mutex_get_mutex_impl
+ g_static_private_get
+ g_static_private_set
g_str_equal
g_str_hash
g_strcasecmp
g_strsplit
g_strtod
g_strup
+ g_timeout_add
+ g_timeout_add_full
g_timer_destroy
g_timer_elapsed
g_timer_new
/* GPollFD
*
- * Unix-specific IO and main loop calls
+ * System-specific IO and main loop calls
+ *
+ * On Win32, the fd in a GPollFD should be Win32 HANDLE (*not* a file
+ * descriptor as provided by the C runtime) that can be used by
+ * MsgWaitForMultipleObjects. This does *not* include file handles
+ * from CreateFile, SOCKETs, nor pipe handles. (But you can use
+ * WSAEventSelect to signal events when a SOCKET is readable).
+ *
+ * On Win32, fd can also be the special value G_WIN32_MSG_HANDLE to
+ * indicate polling for messages. These message queue GPollFDs should
+ * be added with the g_main_poll_win32_msg_add function.
+ *
+ * But note that G_WIN32_MSG_HANDLE GPollFDs should not be used by GDK
+ * (GTK) programs, as GDK itself wants to read messages and convert them
+ * to GDK events.
+ *
+ * So, unless you really know what you are doing, it's best not to try
+ * to use the main loop polling stuff for your own needs on
+ * Win32. It's really only written for the GIMP's needs so
+ * far.
*/
typedef struct _GPollFD GPollFD;
void g_main_remove_poll (GPollFD *fd);
void g_main_set_poll_func (GPollFunc func);
+/* On Unix, IO channels created with this function for any file
+ * descriptor or socket.
+ *
+ * On Win32, use this only for plain files opened with the MSVCRT (the
+ * Microsoft run-time C library) _open(), including file descriptors
+ * 0, 1 and 2 (corresponding to stdin, stdout and stderr).
+ * Actually, don't do even that, this code isn't done yet.
+ *
+ * The term file descriptor as used in the context of Win32 refers to
+ * the emulated Unix-like file descriptors MSVCRT provides.
+ */
GIOChannel* g_io_channel_unix_new (int fd);
gint g_io_channel_unix_get_fd (GIOChannel *channel);
+#ifdef NATIVE_WIN32
+
+GUTILS_C_VAR guint g_pipe_readable_msg;
-/* old IO Channels */
-#if 0
-/* IO Channels.
- * These are used for plug-in communication in the GIMP, for instance.
- * On Unix, it's simply an encapsulated file descriptor (a pipe).
- * On Windows, it's a handle to an anonymouos pipe, *and* (in the case
- * of the writable end) a thread id to post a message to when you have written
- * stuff.
+#define G_WIN32_MSG_HANDLE 19981206
+
+/* This is used to add polling for Windows messages. GDK (GTk+) programs
+ * should *not* use this. (In fact, I can't think of any program that
+ * would want to use this, but it's here just for completeness's sake.
*/
-struct _GIOChannel
-{
- gint fd; /* file handle (pseudo such in Win32) */
-#ifdef NATIVE_WIN32
- guint peer; /* thread to post message to */
- guint peer_fd; /* read handle (in the other process) */
- guint offset; /* counter of accumulated bytes, to
- * be included in the message posted
- * so we keep in sync.
- */
- guint need_wakeups; /* in output channels whether the reader
- * needs wakeups
- */
-#endif
-};
-GIOChannel *g_iochannel_new (gint fd);
-void g_iochannel_free (GIOChannel *channel);
-void g_iochannel_close_and_free (GIOChannel *channel);
-void g_iochannel_wakeup_peer (GIOChannel *channel);
-#ifndef NATIVE_WIN32
-# define g_iochannel_wakeup_peer(channel) G_STMT_START { } G_STMT_END
-#endif
-#endif /* old IO Channels */
+void g_main_poll_win32_msg_add(gint priority,
+ GPollFD *fd,
+ guint hwnd);
+
+/* An IO channel for Windows messages for window handle hwnd. */
+GIOChannel *g_io_channel_win32_new_messages (guint hwnd);
+
+/* An IO channel for an anonymous pipe as returned from the MSVCRT
+ * _pipe(), with no mechanism for the writer to tell the reader when
+ * there is data in the pipe.
+ *
+ * This is not really implemented yet.
+ */
+GIOChannel *g_io_channel_win32_new_pipe (int fd);
+/* An IO channel for a pipe as returned from the MSVCRT _pipe(), with
+ * Windows user messages used to signal data in the pipe for the
+ * reader.
+ *
+ * fd is the file descriptor. For the write end, peer is the thread id
+ * of the reader, and peer_fd is his file descriptor for the read end
+ * of the pipe.
+ *
+ * This is used by the GIMP, and works.
+ */
+GIOChannel *g_io_channel_win32_new_pipe_with_wakeups (int fd,
+ guint peer,
+ int peer_fd);
+
+void g_io_channel_win32_pipe_request_wakeups (GIOChannel *channel,
+ guint peer,
+ int peer_fd);
+
+void g_io_channel_win32_pipe_readable (int fd,
+ guint offset);
+
+/* Get the C runtime file descriptor of a channel. */
+gint g_io_channel_win32_get_fd (GIOChannel *channel);
+
+/* An IO channel for a SOCK_STREAM winsock socket. The parameter is
+ * actually a SOCKET.
+ */
+GIOChannel *g_io_channel_win32_new_stream_socket (int socket);
+
+#endif
-/* Windows emulation stubs for common unix functions
+/* Windows emulation stubs for common Unix functions
*/
#ifdef NATIVE_WIN32
# define MAXPATHLEN 1024
* MT safe
*/
+#include "config.h"
+
#include "glib.h"
#include <sys/types.h>
+#include <time.h>
+#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
+#endif
#ifdef GLIB_HAVE_SYS_POLL_H
# include <sys/poll.h>
# undef events /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
# undef revents /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
#endif /* GLIB_HAVE_SYS_POLL_H */
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif
#include <errno.h>
-#include "config.h"
+
+#ifdef NATIVE_WIN32
+#define STRICT
+#include <windows.h>
+#endif
+
+#ifdef _MSC_VER
+#include <fcntl.h>
+#include <io.h>
+#endif
/* Types */
static GMemChunk *poll_chunk;
static guint n_poll_records = 0;
+#ifdef G_THREADS_ENABLED
+#ifndef NATIVE_WIN32
/* this pipe is used to wake up the main loop when a source is added.
*/
static gint wake_up_pipe[2] = { -1, -1 };
+#else
+static HANDLE wake_up_semaphore = NULL;
+#endif
static GPollFD wake_up_rec;
static gboolean poll_waiting = FALSE;
+#endif
#ifdef HAVE_POLL
static GPollFunc poll_func = (GPollFunc) poll;
#else /* !HAVE_POLL */
+#ifdef NATIVE_WIN32
+
+static gint
+g_poll (GPollFD *fds, guint nfds, gint timeout)
+{
+ HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+ GPollFD *f;
+ DWORD ready;
+ MSG msg;
+ UINT timer;
+ LONG prevcnt;
+ gint poll_msgs = -1;
+ gint nhandles = 0;
+
+ for (f = fds; f < &fds[nfds]; ++f)
+ if (f->fd >= 0)
+ {
+ if (f->events & G_IO_IN)
+ if (f->fd == G_WIN32_MSG_HANDLE)
+ poll_msgs = f - fds;
+ else
+ {
+ /* g_print ("g_poll: waiting for handle %#x\n", f->fd); */
+ handles[nhandles++] = (HANDLE) f->fd;
+ }
+ }
+
+ if (timeout == -1)
+ timeout = INFINITE;
+
+ if (poll_msgs >= 0)
+ {
+ /* Waiting for messages, and maybe events */
+ if (nhandles == 0)
+ {
+ if (timeout == INFINITE)
+ {
+ /* Waiting just for messages, infinite timeout
+ * -> Use PeekMessage, then WaitMessage
+ */
+ /* g_print ("WaitMessage, PeekMessage\n"); */
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else if (!WaitMessage ())
+ g_warning ("g_poll: WaitMessage failed");
+ ready = WAIT_OBJECT_0;
+ }
+ else if (timeout == 0)
+ {
+ /* Waiting just for messages, zero timeout
+ * -> Use PeekMessage
+ */
+ /* g_print ("PeekMessage\n"); */
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else
+ ready = WAIT_TIMEOUT;
+ }
+ else
+ {
+ /* Waiting just for messages, some timeout
+ * -> First try PeekMessage, then set a timer, wait for message,
+ * kill timer, use PeekMessage
+ */
+ /* g_print ("PeekMessage\n"); */
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else if ((timer = SetTimer (NULL, 0, timeout, NULL)) == 0)
+ g_warning ("g_poll: SetTimer failed");
+ else
+ {
+ /* g_print ("WaitMessage\n"); */
+ WaitMessage ();
+ KillTimer (NULL, timer);
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else
+ ready = WAIT_TIMEOUT;
+ }
+ }
+ }
+ else
+ {
+ /* Wait for either message or event
+ * -> Use MsgWaitForMultipleObjects
+ */
+ /* g_print ("MsgWaitForMultipleObjects(%d, %d)\n", nhandles, timeout); */
+ ready = MsgWaitForMultipleObjects (nhandles, handles, FALSE,
+ timeout, QS_ALLINPUT);
+ /* g_print("=%d\n", ready); */
+ if (ready == WAIT_FAILED)
+ g_warning ("g_poll: MsgWaitForMultipleObjects failed");
+ }
+ }
+ else if (nhandles == 0)
+ {
+ /* Wait for nothing (huh?) */
+ return 0;
+ }
+ else
+ {
+ /* Wait for just events
+ * -> Use WaitForMultipleObjects
+ */
+ /* g_print ("WaitForMultipleObjects(%d, %d)\n", nhandles, timeout); */
+ ready = WaitForMultipleObjects (nhandles, handles, FALSE, timeout);
+ /* g_print("=%d\n", ready); */
+ if (ready == WAIT_FAILED)
+ g_warning ("g_poll: WaitForMultipleObjects failed");
+ }
+
+ for (f = fds; f < &fds[nfds]; ++f)
+ f->revents = 0;
+
+ if (ready == WAIT_FAILED)
+ return -1;
+ else if (poll_msgs >= 0 && ready == WAIT_OBJECT_0 + nhandles)
+ {
+ fds[poll_msgs].revents |= G_IO_IN;
+ }
+ else if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles)
+ for (f = fds; f < &fds[nfds]; ++f)
+ {
+ if ((f->events & G_IO_IN)
+ && f->fd == (gint) handles[ready - WAIT_OBJECT_0])
+ {
+ f->revents |= G_IO_IN;
+ /* g_print ("event %#x\n", f->fd); */
+ ResetEvent ((HANDLE) f->fd);
+ }
+ }
+
+ if (ready == WAIT_TIMEOUT)
+ return 0;
+ else
+ return 1;
+}
+
+#else /* !NATIVE_WIN32 */
/* The following implementation of poll() comes from the GNU C Library.
* Copyright (C) 1994, 1996, 1997 Free Software Foundation, Inc.
return ready;
}
+#endif /* !NATIVE_WIN32 */
+
static GPollFunc poll_func = g_poll;
#endif /* !HAVE_POLL */
return_val = source->hook.hook_id;
+#ifdef G_THREADS_ENABLED
/* Now wake up the main loop if it is waiting in the poll() */
if (poll_waiting)
{
poll_waiting = FALSE;
+#ifndef NATIVE_WIN32
write (wake_up_pipe[1], "A", 1);
+#else
+ ReleaseSemaphore (wake_up_semaphore, 1, NULL);
+#endif
}
-
+#endif
G_UNLOCK (main_loop);
return return_val;
void
g_get_current_time (GTimeVal *result)
{
+#ifndef _MSC_VER
struct timeval r;
g_return_if_fail (result != NULL);
gettimeofday (&r, NULL);
result->tv_sec = r.tv_sec;
result->tv_usec = r.tv_usec;
+#else
+ /* Avoid calling time() except for the first time.
+ * GetTickCount() should be pretty fast and low-level?
+ * I could also use ftime() but it seems unnecessarily overheady.
+ */
+ static DWORD start_tick = 0;
+ static time_t start_time;
+ DWORD tick;
+ time_t t;
+
+ g_return_if_fail (result != NULL);
+
+ if (start_tick == 0)
+ {
+ start_tick = GetTickCount ();
+ time (&start_time);
+ }
+
+ tick = GetTickCount ();
+
+ result->tv_sec = (tick - start_tick) / 1000 + start_time;
+ result->tv_usec = ((tick - start_tick) % 1000) * 1000;
+#endif
}
/* Running the main loop */
gint i;
gint npoll;
-
+#ifdef G_THREADS_ENABLED
+#ifndef NATIVE_WIN32
if (wake_up_pipe[0] < 0)
{
if (pipe (wake_up_pipe) < 0)
wake_up_rec.events = G_IO_IN;
g_main_add_poll_unlocked (0, &wake_up_rec);
}
-
+#else
+ if (wake_up_semaphore == NULL)
+ {
+ if ((wake_up_semaphore = CreateSemaphore (NULL, 0, 100, NULL)) == NULL)
+ g_error ("Cannot create wake-up semaphore: %d", GetLastError ());
+ wake_up_rec.fd = (gint) wake_up_semaphore;
+ wake_up_rec.events = G_IO_IN;
+ g_main_add_poll_unlocked (0, &wake_up_rec);
+ }
+#endif
+#endif
fd_array = g_new (GPollFD, n_poll_records);
pollrec = poll_records;
pollrec = pollrec->next;
i++;
}
-
+#ifdef G_THREADS_ENABLED
poll_waiting = TRUE;
-
+#endif
G_UNLOCK (main_loop);
npoll = i;
(*poll_func) (fd_array, npoll, timeout);
G_LOCK (main_loop);
+#ifdef G_THREADS_ENABLED
if (!poll_waiting)
{
+#ifndef NATIVE_WIN32
gchar c;
read (wake_up_pipe[0], &c, 1);
+#endif
}
else
poll_waiting = FALSE;
+#endif
pollrec = poll_records;
i = 0;
#endif
#ifdef NATIVE_WIN32
+#define STRICT
+#include <windows.h>
+
/* Just use stdio. If we're out of memory, we're hosed anyway. */
#undef write
}
#endif /* NATIVE_WIN32 */
+static void
+ensure_stdout_valid (void)
+{
+#ifdef NATIVE_WIN32
+ HANDLE handle;
+
+ handle = GetStdHandle (STD_OUTPUT_HANDLE);
+
+ if (handle == INVALID_HANDLE_VALUE)
+ {
+ AllocConsole ();
+ freopen ("CONOUT$", "w", stdout);
+ }
+#endif
+}
+
/* --- structures --- */
typedef struct _GLogDomain GLogDomain;
* DOS prompt.
*/
fd = stdout;
+ ensure_stdout_valid ();
#else
fd = (log_level >= G_LOG_LEVEL_MESSAGE) ? 1 : 2;
#endif
local_glib_print_func (string);
else
{
+ ensure_stdout_valid ();
fputs (string, stdout);
fflush (stdout);
}
#include <string.h>
#include <locale.h>
#include <ctype.h> /* For tolower() */
+#include <signal.h>
#include "glib.h"
/* do not include <unistd.h> in this place since it
* inteferes with g_strsignal() on some OSes
#endif /* NATIVE_WIN32 */
}
+#ifdef NATIVE_WIN32
+ /* The official way to specify a home directory on NT is
+ * the HOMEDRIVE and HOMEPATH environment variables.
+ *
+ * This is inside #ifdef NATIVE_WIN32 because with the cygwin dll,
+ * HOME should be a POSIX style pathname.
+ */
+
+ if (getenv ("HOMEDRIVE") != NULL && getenv ("HOMEPATH") != NULL)
+ {
+ gchar *homedrive, *homepath;
+
+ homedrive = g_strdup (g_getenv ("HOMEDRIVE"));
+ homepath = g_strdup (g_getenv ("HOMEPATH"));
+
+ g_home_dir = g_strconcat (homedrive, homepath, NULL);
+ g_free (homedrive);
+ g_free (homepath);
+ }
+ if (!g_home_dir)
+ g_home_dir = g_strdup (g_getenv ("HOME"));
+#else
g_home_dir = g_strdup (g_getenv ("HOME"));
+#endif
#ifdef HAVE_PWD_H
/* FIXME: we must actually use the getpwuid_r function here, as
#pragma warning(disable:4101)
#pragma warning(error:4150)
-#pragma warning(disable:4244) /* No possible loss of data warnings, please */
+#pragma warning(disable:4244) /* No possible loss of data warnings */
+#pragma warning(disable:4305) /* No truncation from int to char warnings */
#endif /* _MSC_VER */
#include <limits.h>
#include <float.h>
-#define G_MINFLOAT FLT_MIN
-#define G_MAXFLOAT FLT_MAX
-#define G_MINDOUBLE DBL_MIN
-#define G_MAXDOUBLE DBL_MAX
-#define G_MINSHORT SHRT_MIN
-#define G_MAXSHORT SHRT_MAX
-#define G_MININT INT_MIN
-#define G_MAXINT INT_MAX
-#define G_MINLONG LONG_MIN
-#define G_MAXLONG LONG_MAX
+#define G_MINFLOAT FLT_MIN
+#define G_MAXFLOAT FLT_MAX
+#define G_MINDOUBLE DBL_MIN
+#define G_MAXDOUBLE DBL_MAX
+#define G_MINSHORT SHRT_MIN
+#define G_MAXSHORT SHRT_MAX
+#define G_MININT INT_MIN
+#define G_MAXINT INT_MAX
+#define G_MINLONG LONG_MIN
+#define G_MAXLONG LONG_MAX
typedef signed char gint8;
typedef unsigned char guint8;
typedef unsigned short guint16;
typedef signed int gint32;
typedef unsigned int guint32;
+
#define G_HAVE_GINT64 1
typedef __int64 gint64;
typedef unsigned __int64 guint64;
-#define G_GINT64_CONSTANT(val) (val)
+#define G_GINT64_CONSTANT(val) (val##i64)
#define GPOINTER_TO_INT(p) ((gint)(p))
#define GPOINTER_TO_UINT(p) ((guint)(p))
#define g_memmove(d,s,n) G_STMT_START { memmove ((d), (s), (n)); } G_STMT_END
+#define G_HAVE_ALLOCA 1
+#define alloca _alloca
+
#define GLIB_MAJOR_VERSION 1
#define GLIB_MINOR_VERSION 1
-#define GLIB_MICRO_VERSION 4
-
-#define G_COMPILED_WITH_DEBUGGING "minimum"
+#define GLIB_MICRO_VERSION 12
+#ifdef __cplusplus
+#define G_HAVE_INLINE 1
+#else /* !__cplusplus */
#define G_HAVE___INLINE 1
+#endif
+
+#define G_THREADS_ENABLED
+typedef struct _GStaticMutex GStaticMutex;
+struct _GStaticMutex
+{
+ struct _GMutex *runtime_mutex;
+ union {
+ char pad[24];
+ double dummy_double;
+ void *dummy_pointer;
+ long dummy_long;
+ } aligned_pad_u;
+};
+#define G_STATIC_MUTEX_INIT { NULL, { { 0, 0, 0, 0, 0 } } }
+#define g_static_mutex_get_mutex(mutex) \
+ (g_thread_use_default_impl ? ((GMutex*) &(mutex).aligned_pad_u) : \
+ g_static_mutex_get_mutex_impl (&(mutex).runtime_mutex))
#define G_BYTE_ORDER G_LITTLE_ENDIAN
#define GINT_TO_BE(val) ((gint) GINT32_TO_BE (val))
#define GUINT_TO_BE(val) ((guint) GUINT32_TO_BE (val))
+#define GLIB_SYSDEF_POLLIN = 1
+#define GLIB_SYSDEF_POLLOUT = 4
+#define GLIB_SYSDEF_POLLPRI = 2
+#define GLIB_SYSDEF_POLLERR = 8
+#define GLIB_SYSDEF_POLLHUP = 16
+#define GLIB_SYSDEF_POLLNVAL = 32
+
#define G_HAVE_WCHAR_H 1
#define G_HAVE_WCTYPE_H 1
-/* Define if this is Win32, possibly using the GNU-Win32 emulation layer. */
+/* Define if this is Win32, possibly using the Cygwin emulation layer. */
#define WIN32 1
-/* Define if this is Win32 without GNU-Win32. */
+/* Define if this is Win32 without Cygwin. */
#define NATIVE_WIN32 1
#ifdef __cplusplus
* MT safe
*/
+#include "config.h"
+
#include "glib.h"
#include <sys/types.h>
+#include <time.h>
+#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
+#endif
#ifdef GLIB_HAVE_SYS_POLL_H
# include <sys/poll.h>
# undef events /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
# undef revents /* AIX 4.1.5 & 4.3.2 define this for SVR3,4 compatibility */
#endif /* GLIB_HAVE_SYS_POLL_H */
+#ifdef HAVE_UNISTD_H
#include <unistd.h>
+#endif
#include <errno.h>
-#include "config.h"
+
+#ifdef NATIVE_WIN32
+#define STRICT
+#include <windows.h>
+#endif
+
+#ifdef _MSC_VER
+#include <fcntl.h>
+#include <io.h>
+#endif
/* Types */
static GMemChunk *poll_chunk;
static guint n_poll_records = 0;
+#ifdef G_THREADS_ENABLED
+#ifndef NATIVE_WIN32
/* this pipe is used to wake up the main loop when a source is added.
*/
static gint wake_up_pipe[2] = { -1, -1 };
+#else
+static HANDLE wake_up_semaphore = NULL;
+#endif
static GPollFD wake_up_rec;
static gboolean poll_waiting = FALSE;
+#endif
#ifdef HAVE_POLL
static GPollFunc poll_func = (GPollFunc) poll;
#else /* !HAVE_POLL */
+#ifdef NATIVE_WIN32
+
+static gint
+g_poll (GPollFD *fds, guint nfds, gint timeout)
+{
+ HANDLE handles[MAXIMUM_WAIT_OBJECTS];
+ GPollFD *f;
+ DWORD ready;
+ MSG msg;
+ UINT timer;
+ LONG prevcnt;
+ gint poll_msgs = -1;
+ gint nhandles = 0;
+
+ for (f = fds; f < &fds[nfds]; ++f)
+ if (f->fd >= 0)
+ {
+ if (f->events & G_IO_IN)
+ if (f->fd == G_WIN32_MSG_HANDLE)
+ poll_msgs = f - fds;
+ else
+ {
+ /* g_print ("g_poll: waiting for handle %#x\n", f->fd); */
+ handles[nhandles++] = (HANDLE) f->fd;
+ }
+ }
+
+ if (timeout == -1)
+ timeout = INFINITE;
+
+ if (poll_msgs >= 0)
+ {
+ /* Waiting for messages, and maybe events */
+ if (nhandles == 0)
+ {
+ if (timeout == INFINITE)
+ {
+ /* Waiting just for messages, infinite timeout
+ * -> Use PeekMessage, then WaitMessage
+ */
+ /* g_print ("WaitMessage, PeekMessage\n"); */
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else if (!WaitMessage ())
+ g_warning ("g_poll: WaitMessage failed");
+ ready = WAIT_OBJECT_0;
+ }
+ else if (timeout == 0)
+ {
+ /* Waiting just for messages, zero timeout
+ * -> Use PeekMessage
+ */
+ /* g_print ("PeekMessage\n"); */
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else
+ ready = WAIT_TIMEOUT;
+ }
+ else
+ {
+ /* Waiting just for messages, some timeout
+ * -> First try PeekMessage, then set a timer, wait for message,
+ * kill timer, use PeekMessage
+ */
+ /* g_print ("PeekMessage\n"); */
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else if ((timer = SetTimer (NULL, 0, timeout, NULL)) == 0)
+ g_warning ("g_poll: SetTimer failed");
+ else
+ {
+ /* g_print ("WaitMessage\n"); */
+ WaitMessage ();
+ KillTimer (NULL, timer);
+ if (PeekMessage (&msg, NULL, 0, 0, PM_NOREMOVE))
+ ready = WAIT_OBJECT_0;
+ else
+ ready = WAIT_TIMEOUT;
+ }
+ }
+ }
+ else
+ {
+ /* Wait for either message or event
+ * -> Use MsgWaitForMultipleObjects
+ */
+ /* g_print ("MsgWaitForMultipleObjects(%d, %d)\n", nhandles, timeout); */
+ ready = MsgWaitForMultipleObjects (nhandles, handles, FALSE,
+ timeout, QS_ALLINPUT);
+ /* g_print("=%d\n", ready); */
+ if (ready == WAIT_FAILED)
+ g_warning ("g_poll: MsgWaitForMultipleObjects failed");
+ }
+ }
+ else if (nhandles == 0)
+ {
+ /* Wait for nothing (huh?) */
+ return 0;
+ }
+ else
+ {
+ /* Wait for just events
+ * -> Use WaitForMultipleObjects
+ */
+ /* g_print ("WaitForMultipleObjects(%d, %d)\n", nhandles, timeout); */
+ ready = WaitForMultipleObjects (nhandles, handles, FALSE, timeout);
+ /* g_print("=%d\n", ready); */
+ if (ready == WAIT_FAILED)
+ g_warning ("g_poll: WaitForMultipleObjects failed");
+ }
+
+ for (f = fds; f < &fds[nfds]; ++f)
+ f->revents = 0;
+
+ if (ready == WAIT_FAILED)
+ return -1;
+ else if (poll_msgs >= 0 && ready == WAIT_OBJECT_0 + nhandles)
+ {
+ fds[poll_msgs].revents |= G_IO_IN;
+ }
+ else if (ready >= WAIT_OBJECT_0 && ready < WAIT_OBJECT_0 + nhandles)
+ for (f = fds; f < &fds[nfds]; ++f)
+ {
+ if ((f->events & G_IO_IN)
+ && f->fd == (gint) handles[ready - WAIT_OBJECT_0])
+ {
+ f->revents |= G_IO_IN;
+ /* g_print ("event %#x\n", f->fd); */
+ ResetEvent ((HANDLE) f->fd);
+ }
+ }
+
+ if (ready == WAIT_TIMEOUT)
+ return 0;
+ else
+ return 1;
+}
+
+#else /* !NATIVE_WIN32 */
/* The following implementation of poll() comes from the GNU C Library.
* Copyright (C) 1994, 1996, 1997 Free Software Foundation, Inc.
return ready;
}
+#endif /* !NATIVE_WIN32 */
+
static GPollFunc poll_func = g_poll;
#endif /* !HAVE_POLL */
return_val = source->hook.hook_id;
+#ifdef G_THREADS_ENABLED
/* Now wake up the main loop if it is waiting in the poll() */
if (poll_waiting)
{
poll_waiting = FALSE;
+#ifndef NATIVE_WIN32
write (wake_up_pipe[1], "A", 1);
+#else
+ ReleaseSemaphore (wake_up_semaphore, 1, NULL);
+#endif
}
-
+#endif
G_UNLOCK (main_loop);
return return_val;
void
g_get_current_time (GTimeVal *result)
{
+#ifndef _MSC_VER
struct timeval r;
g_return_if_fail (result != NULL);
gettimeofday (&r, NULL);
result->tv_sec = r.tv_sec;
result->tv_usec = r.tv_usec;
+#else
+ /* Avoid calling time() except for the first time.
+ * GetTickCount() should be pretty fast and low-level?
+ * I could also use ftime() but it seems unnecessarily overheady.
+ */
+ static DWORD start_tick = 0;
+ static time_t start_time;
+ DWORD tick;
+ time_t t;
+
+ g_return_if_fail (result != NULL);
+
+ if (start_tick == 0)
+ {
+ start_tick = GetTickCount ();
+ time (&start_time);
+ }
+
+ tick = GetTickCount ();
+
+ result->tv_sec = (tick - start_tick) / 1000 + start_time;
+ result->tv_usec = ((tick - start_tick) % 1000) * 1000;
+#endif
}
/* Running the main loop */
gint i;
gint npoll;
-
+#ifdef G_THREADS_ENABLED
+#ifndef NATIVE_WIN32
if (wake_up_pipe[0] < 0)
{
if (pipe (wake_up_pipe) < 0)
wake_up_rec.events = G_IO_IN;
g_main_add_poll_unlocked (0, &wake_up_rec);
}
-
+#else
+ if (wake_up_semaphore == NULL)
+ {
+ if ((wake_up_semaphore = CreateSemaphore (NULL, 0, 100, NULL)) == NULL)
+ g_error ("Cannot create wake-up semaphore: %d", GetLastError ());
+ wake_up_rec.fd = (gint) wake_up_semaphore;
+ wake_up_rec.events = G_IO_IN;
+ g_main_add_poll_unlocked (0, &wake_up_rec);
+ }
+#endif
+#endif
fd_array = g_new (GPollFD, n_poll_records);
pollrec = poll_records;
pollrec = pollrec->next;
i++;
}
-
+#ifdef G_THREADS_ENABLED
poll_waiting = TRUE;
-
+#endif
G_UNLOCK (main_loop);
npoll = i;
(*poll_func) (fd_array, npoll, timeout);
G_LOCK (main_loop);
+#ifdef G_THREADS_ENABLED
if (!poll_waiting)
{
+#ifndef NATIVE_WIN32
gchar c;
read (wake_up_pipe[0], &c, 1);
+#endif
}
else
poll_waiting = FALSE;
+#endif
pollrec = poll_records;
i = 0;
#endif
#ifdef NATIVE_WIN32
+#define STRICT
+#include <windows.h>
+
/* Just use stdio. If we're out of memory, we're hosed anyway. */
#undef write
}
#endif /* NATIVE_WIN32 */
+static void
+ensure_stdout_valid (void)
+{
+#ifdef NATIVE_WIN32
+ HANDLE handle;
+
+ handle = GetStdHandle (STD_OUTPUT_HANDLE);
+
+ if (handle == INVALID_HANDLE_VALUE)
+ {
+ AllocConsole ();
+ freopen ("CONOUT$", "w", stdout);
+ }
+#endif
+}
+
/* --- structures --- */
typedef struct _GLogDomain GLogDomain;
* DOS prompt.
*/
fd = stdout;
+ ensure_stdout_valid ();
#else
fd = (log_level >= G_LOG_LEVEL_MESSAGE) ? 1 : 2;
#endif
local_glib_print_func (string);
else
{
+ ensure_stdout_valid ();
fputs (string, stdout);
fflush (stdout);
}
+1999-01-16 Tor Lillqvist <tml@iki.fi>
+
+ * gmodule-dl.c gmodule-dld.c: In
+ _g_module_build_path, don't add the "lib" prefix and
+ ".so" or ".sl" suffix if already there.
+
+ * gmodule-win32.c: Likewise for the ".dll" suffix.
+
1998-12-10 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* gmodule.c: Made it MT safe, the g_module_error() is now thread
_g_module_build_path (const gchar *directory,
const gchar *module_name)
{
- if (directory)
- return g_strconcat (directory, "/lib", module_name, ".so", NULL);
+ if (directory && *directory)
+ if (strncmp (module_name, "lib", 3) == 0)
+ return g_strconcat (directory, "/", module_name, NULL);
+ else
+ return g_strconcat (directory, "/lib", module_name, ".so", NULL);
+ else if (strncmp (module_name, "lib", 3) == 0)
+ return g_strdup (module_name);
else
return g_strconcat ("lib", module_name, ".so", NULL);
}
_g_module_build_path (const gchar *directory,
const gchar *module_name)
{
- if (directory)
- return g_strconcat (directory, "/", module_name, ".sl", NULL);
+ if (directory && *directory)
+ if (strncmp (module_name, "lib", 3) == 0)
+ return g_strconcat (directory, "/", module_name, NULL);
+ else
+ return g_strconcat (directory, "/lib", module_name, ".sl", NULL);
+ else if (strncmp (module_name, "lib", 3) == 0)
+ return g_strdup (module_name);
else
- return g_strconcat (module_name, ".sl", NULL);
+ return g_strconcat ("lib", module_name, ".sl", NULL);
}
_g_module_build_path (const gchar *directory,
const gchar *module_name)
{
- if (directory)
- return g_strconcat (directory, "\\", module_name, ".dll", NULL);
+ gint k;
+
+ k = strlen (module_name);
+ if (directory && *directory)
+ if (k > 4 && g_strcasecmp (module_name + k - 4, ".dll") == 0)
+ return g_strconcat (directory, "\\", module_name, NULL);
+ else
+ return g_strconcat (directory, "\\", module_name, ".dll", NULL);
+ else if (k > 4 && g_strcasecmp (module_name + k - 4, ".dll") == 0)
+ return g_strdup (module_name);
else
return g_strconcat (module_name, ".dll", NULL);
}
#include <string.h>
#include <locale.h>
#include <ctype.h> /* For tolower() */
+#include <signal.h>
#include "glib.h"
/* do not include <unistd.h> in this place since it
* inteferes with g_strsignal() on some OSes
+1999-01-16 1999 Tor Lillqvist <tml@iki.fi>
+
+ * gthread-posix.c: Conditionalize <sys/time.h> inclusion.
+
1999-01-07 Sebastian Wilhelmi <wilhelmi@ira.uka.de>
* testgthread.c: conditionally compile according to the
#include <pthread.h>
#include <errno.h>
#include <stdlib.h>
+#ifdef HAVE_SYS_TIME_H
#include <sys/time.h>
+#endif
#define posix_print_error( name, num ) \
g_error( "file %s: line %d (%s): error %s during %s", \
#endif /* NATIVE_WIN32 */
}
+#ifdef NATIVE_WIN32
+ /* The official way to specify a home directory on NT is
+ * the HOMEDRIVE and HOMEPATH environment variables.
+ *
+ * This is inside #ifdef NATIVE_WIN32 because with the cygwin dll,
+ * HOME should be a POSIX style pathname.
+ */
+
+ if (getenv ("HOMEDRIVE") != NULL && getenv ("HOMEPATH") != NULL)
+ {
+ gchar *homedrive, *homepath;
+
+ homedrive = g_strdup (g_getenv ("HOMEDRIVE"));
+ homepath = g_strdup (g_getenv ("HOMEPATH"));
+
+ g_home_dir = g_strconcat (homedrive, homepath, NULL);
+ g_free (homedrive);
+ g_free (homepath);
+ }
+ if (!g_home_dir)
+ g_home_dir = g_strdup (g_getenv ("HOME"));
+#else
g_home_dir = g_strdup (g_getenv ("HOME"));
+#endif
#ifdef HAVE_PWD_H
/* FIXME: we must actually use the getpwuid_r function here, as
-## Makefile for building the GLib and gmodule dll with Microsoft C
+## Makefile for building the GLib, gmodule and gthread dlls with Microsoft C
## Use: nmake -f makefile.msc install
# Change this to wherever you want to install the DLLs. This directory
# should be in your PATH.
BIN = C:\bin
+# This is the Cygnus pthread-win32,
+# see http://sourceware.cygnus.com/pthreads-win32/
+PTHREAD_LIB = ..\lib\pthread.lib
+PTHREAD_INC = ..\include
+
################################################################
# Nothing much configurable below
# cl -? described the options
-CC = cl -G5 -GF -Ox -W3 -D_DLL -nologo
+CC = cl -G5 -GF -Ox -W3 -MD -nologo
-LDFLAGS = /link /nodefaultlib:libc msvcrt.lib # /debug:full /debugtype:cv
+# No general LDFLAGS needes
+LDFLAGS = /link
INSTALL = copy
-TOUCH = copy makefile.msc+nul
GLIB_VER = 1.1
-CFLAGS = -I.
+CFLAGS = -I. -DHAVE_CONFIG_H
all : \
glibconfig.h \
glib-$(GLIB_VER).dll \
gmodule\gmoduleconf.h \
gmodule-$(GLIB_VER).dll \
+ gthread-$(GLIB_VER).dll \
testglib.exe \
- testgmodule.exe
+ testgmodule.exe \
+ testgdate.exe \
+ testgdateparser.exe \
+ testgthread.exe
install : all
$(INSTALL) glib-$(GLIB_VER).dll $(BIN)
$(INSTALL) gmodule-$(GLIB_VER).dll $(BIN)
+ $(INSTALL) gthread-$(GLIB_VER).dll $(BIN)
glib_OBJECTS = \
garray.obj \
gcache.obj \
gcompletion.obj \
gdataset.obj \
+ gdate.obj \
gerror.obj \
ghook.obj \
ghash.obj \
+ giochannel.obj \
+ giowin32.obj \
glist.obj \
+ gmain.obj \
gmem.obj \
gmessages.obj \
+ gmutex.obj \
gnode.obj \
gprimes.obj \
gslist.obj \
gscanner.obj \
gutils.obj
-glib-$(GLIB_VER).dll : $(glib_OBJECTS)
- $(CC) $(CFLAGS) -MD -LD -Feglib-$(GLIB_VER).dll $(glib_OBJECTS) user32.lib advapi32.lib $(LDFLAGS) /def:glib.def
+glib-$(GLIB_VER).dll : $(glib_OBJECTS) glib.def
+ $(CC) $(CFLAGS) -LD -Feglib-$(GLIB_VER).dll $(glib_OBJECTS) user32.lib advapi32.lib wsock32.lib $(LDFLAGS) /def:glib.def
glibconfig.h: glibconfig.h.win32
copy glibconfig.h.win32 glibconfig.h
copy config.h.win32 config.h
.c.obj :
- $(CC) $(CFLAGS) -GD -c -DHAVE_CONFIG_H -DGLIB_COMPILATION -DG_LOG_DOMAIN=g_log_domain_glib $<
+ $(CC) $(CFLAGS) -GD -c -DGLIB_COMPILATION -DG_LOG_DOMAIN=g_log_domain_glib $<
gmodule_OBJECTS = \
gmodule.obj
gmodule-$(GLIB_VER).dll : $(gmodule_OBJECTS)
- $(CC) $(CFLAGS) -MD -LD -Fegmodule-$(GLIB_VER).dll $(gmodule_OBJECTS) glib-$(GLIB_VER).lib $(LDFLAGS) /def:gmodule\gmodule.def
+ $(CC) $(CFLAGS) -LD -Fegmodule-$(GLIB_VER).dll $(gmodule_OBJECTS) glib-$(GLIB_VER).lib $(LDFLAGS) /def:gmodule\gmodule.def
gmodule.obj : gmodule\gmodule.c gmodule\gmodule-win32.c
- $(CC) $(CFLAGS) -Igmodule -c -DG_LIB_DOMAIN=g_log_domain_gmodule gmodule\gmodule.c
+ $(CC) $(CFLAGS) -GD -Igmodule -c -DG_LOG_DOMAIN=g_log_domain_gmodule gmodule\gmodule.c
gmodule\gmoduleconf.h: gmodule\gmoduleconf.h.win32
copy gmodule\gmoduleconf.h.win32 gmodule\gmoduleconf.h
+gthread_OBJECTS = \
+ gthread.obj
+
+gthread-$(GLIB_VER).dll : $(gthread_OBJECTS)
+ $(CC) $(CFLAGS) -LD -Fegthread-$(GLIB_VER).dll $(gthread_OBJECTS) glib-$(GLIB_VER).lib $(PTHREAD_LIB) glib-$(GLIB_VER).lib $(LDFLAGS) /def:gthread\gthread.def
+
+gthread.obj : gthread\gthread.c gthread\gthread-posix.c
+ $(CC) $(CFLAGS) -GD -I$(PTHREAD_INC) -DG_LOG_DOMAIN=\"GThread\" -c gthread\gthread.c
+
testglib.exe : glib-$(GLIB_VER).dll testglib.obj
- $(CC) $(CFLAGS) -MD -Fetestglib.exe testglib.obj glib-$(GLIB_VER).lib $(LDFLAGS) /map
+ $(CC) $(CFLAGS) -Fetestglib.exe testglib.obj glib-$(GLIB_VER).lib $(LDFLAGS) /subsystem:console
testglib.obj : testglib.c
$(CC) -c $(CFLAGS) testglib.c
+testgdate.exe : glib-$(GLIB_VER).dll testgdate.obj
+ $(CC) $(CFLAGS) -Fetestgdate.exe testgdate.obj glib-$(GLIB_VER).lib $(LDFLAGS) /subsystem:console
+
+testgdate.obj : testgdate.c
+ $(CC) -c $(CFLAGS) testgdate.c
+
+testgdateparser.exe : glib-$(GLIB_VER).dll testgdateparser.obj
+ $(CC) $(CFLAGS) -Fetestgdateparser.exe testgdateparser.obj glib-$(GLIB_VER).lib $(LDFLAGS) /subsystem:console
+
+testgdateparser.obj : testgdateparser.c
+ $(CC) -c $(CFLAGS) testgdateparser.c
+
testgmodule.exe : glib-$(GLIB_VER).dll gmodule-$(GLIB_VER).dll testgmodule.obj libgplugin_a.dll libgplugin_b.dll
- $(CC) $(CFLAGS) -MD testgmodule.obj glib-$(GLIB_VER).lib gmodule-$(GLIB_VER).lib $(LDFLAGS)
+ $(CC) $(CFLAGS) testgmodule.obj glib-$(GLIB_VER).lib gmodule-$(GLIB_VER).lib $(LDFLAGS) /subsystem:console
testgmodule.obj : gmodule\testgmodule.c
$(CC) $(CFLAGS) -Igmodule -c gmodule\testgmodule.c
libgplugin_a.dll : libgplugin_a.obj
- $(CC) $(CFLAGS) -MD -LD libgplugin_a.obj glib-$(GLIB_VER).lib gmodule-$(GLIB_VER).lib $(LDFLAGS)
+ $(CC) $(CFLAGS) -LD libgplugin_a.obj glib-$(GLIB_VER).lib gmodule-$(GLIB_VER).lib $(LDFLAGS)
libgplugin_a.obj : gmodule\libgplugin_a.c
$(CC) $(CFLAGS) -Igmodule -c gmodule\libgplugin_a.c
libgplugin_b.dll : libgplugin_b.obj
- $(CC) $(CFLAGS) -MD -LD libgplugin_b.obj glib-$(GLIB_VER).lib gmodule-$(GLIB_VER).lib $(LDFLAGS)
+ $(CC) $(CFLAGS) -LD libgplugin_b.obj glib-$(GLIB_VER).lib gmodule-$(GLIB_VER).lib $(LDFLAGS)
libgplugin_b.obj : gmodule\libgplugin_b.c
$(CC) $(CFLAGS) -Igmodule -c gmodule\libgplugin_b.c
+testgthread.exe : glib-$(GLIB_VER).dll gthread-$(GLIB_VER).dll testgthread.obj
+ $(CC) $(CFLAGS) testgthread.obj glib-$(GLIB_VER).lib gthread-$(GLIB_VER).lib $(PTHREAD_LIB) $(LDFLAGS) /subsystem:console
+
+testgthread.obj : gthread\testgthread.c
+ $(CC) $(CFLAGS) -I$(PTHREAD_INC) -c gthread\testgthread.c
+
clean:
del config.h
del glibconfig.h
projects / dana / cg-glib.git / commitdiff