luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2024-11-14 13:26:16 +01:00
Code Issues Packages Projects Releases Wiki Activity
357c5a47d5
glib/tests/gio-test.c

438 lines
10 KiB
C
Raw Normal View History

Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
/* GLIB - Library of useful routines for C programming
* Copyright (C) 2000 Tor Lillqvist
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
tests/: LGPLv2+ -> LGPLv2.1+ gen-casefold-txt.pl and gen-casemap-txt.pl are licensed under GPLv2+, so they are not touched by this commit. A lot of *.c files in tests/ don't have a license header. https://bugzilla.gnome.org/show_bug.cgi?id=776504
2017-05-28 14:09:39 +02:00
* version 2.1 of the License, or (at your option) any later version.
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
Updated FSF's address
2014-01-23 12:58:29 +01:00
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
*/
/* A test program for the main loop and IO channel code.
New function, that calls g_source_remove(). Check return value of 2000-08-07 Tor Lillqvist <tml@iki.fi> * tests/gio-test.c (shutdown_source): New function, that calls g_source_remove(). Check return value of g_source_remove(), and decrement running subprocess counter only if g_source_remove() actually did remove the source. (recv_message): Call shutdown_source() on EOF condition. Return FALSE on G_IO_HUP and G_IO_ERR condition. Fix printf format typo.
2000-08-07 01:33:29 +02:00
* Just run it. Optional parameter is number of sub-processes.
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
*/
Added #undef G_DISABLE_ASSERT and #undef G_LOG_DOMAIN throughout the 2002-07-04 Sebastian Wilhelmi <wilhelmi@ira.uka.de> * tests/*.c: Added #undef G_DISABLE_ASSERT and #undef G_LOG_DOMAIN throughout the files, which didn't already have them. (#87312)
2002-07-04 17:19:30 +02:00
#undef G_DISABLE_ASSERT
#undef G_LOG_DOMAIN
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
#include "config.h"
#include <glib.h>
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#ifdef G_OS_WIN32
#include <io.h>
#include <fcntl.h>
#include <process.h>
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
#define STRICT
#include <windows.h>
Not needed, just use -DPCRE_STATIC. 2007-11-07 Tor Lillqvist <tml@novell.com> * glib/update-pcre/notdll.patch: Not needed, just use -DPCRE_STATIC. * glib/update-pcre/Makefile.am: Drop notdll.patch. * glib/update-pcre/Makefile.am-1 * glib/update-pcre/update.sh * glib/pcre/Makefile.am * glib/Makefile.am: Use -DPCRE_STATIC. * tests/gio-test.c * tests/mainloop-test.c * tests/spawn-test.c: #define pipe(fds) _pipe(fds, 4096, _O_BINARY) on Windows. * tests/regex-test.c (test_expand): Don't print NULL with %s. svn path=/trunk/; revision=5805
2007-11-07 10:49:25 +01:00
#define pipe(fds) _pipe(fds, 4096, _O_BINARY)
Replace #ifdef HAVE_UNISTD_H checks with #ifdef G_OS_UNIX In Windows development environments that have it, <unistd.h> is mostly just a wrapper around several other native headers (in particular, <io.h>, which contains read(), close(), etc, and <process.h>, which contains getpid()). But given that some Windows dev environments don't have <unistd.h>, everything that uses those functions on Windows already needed to include the correct Windows header as well, and so there is never any point to including <unistd.h> on Windows. Also, remove some <unistd.h> includes (and a few others) that were unnecessary even on unix. https://bugzilla.gnome.org/show_bug.cgi?id=710519
2013-10-19 19:04:00 +02:00
#endif
#ifdef G_OS_UNIX
#include <unistd.h>
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
#endif
static int nrunning;
static GMainLoop *main_loop;
#define BUFSIZE 5000 /* Larger than the circular buffer in
* giowin32.c on purpose.
*/
static int nkiddies;
static struct {
int fd;
int seq;
} *seqtab;
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
static GIOError
read_all (int fd,
GIOChannel *channel,
char *buffer,
guint nbytes,
guint *bytes_read)
{
guint left = nbytes;
Use gsize instead of gint. From Miroslaw Dobrzanski-Neumann 2002-04-08 Sebastian Wilhelmi <wilhelmi@ira.uka.de> * tests/gio-test.c, tests/markup-test.c: Use gsize instead of gint. From Miroslaw Dobrzanski-Neumann <mne@mosaic-ag.com>. (#77982)
2002-04-08 10:36:35 +02:00
gsize nb;
Fix a couple of trivial bugs that were causing warnings. Mon Aug 21 14:46:23 2000 Owen Taylor <otaylor@redhat.com> * tests/gio-test.c: Fix a couple of trivial bugs that were causing warnings. Mon Aug 21 14:39:36 2000 Owen Taylor <otaylor@redhat.com> * glib.h: Use C99 varargs macros where possible (check __STDC_VERSION__), otherwise, on gcc, use an alternate form of gcc varargs which is more likely to be supported going forward. (Based on some code from Raja Harinath)
2000-08-21 20:46:52 +02:00
GIOError error = G_IO_ERROR_NONE;
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
char *bufp = buffer;
/* g_io_channel_read() doesn't necessarily return all the
* data we want at once.
*/
*bytes_read = 0;
while (left)
{
error = g_io_channel_read (channel, bufp, left, &nb);
if (error != G_IO_ERROR_NONE)
{
Cosmetic changes
2012-06-11 13:19:42 +02:00
g_print ("gio-test: ...from %d: %d\n", fd, error);
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
if (error == G_IO_ERROR_AGAIN)
continue;
break;
}
if (nb == 0)
return error;
left -= nb;
bufp += nb;
*bytes_read += nb;
}
return error;
}
New function, that calls g_source_remove(). Check return value of 2000-08-07 Tor Lillqvist <tml@iki.fi> * tests/gio-test.c (shutdown_source): New function, that calls g_source_remove(). Check return value of g_source_remove(), and decrement running subprocess counter only if g_source_remove() actually did remove the source. (recv_message): Call shutdown_source() on EOF condition. Return FALSE on G_IO_HUP and G_IO_ERR condition. Fix printf format typo.
2000-08-07 01:33:29 +02:00
static void
shutdown_source (gpointer data)
{
if (g_source_remove (*(guint *) data))
{
nrunning--;
if (nrunning == 0)
add -DG_DISABLED_DEPRECATED Tue Oct 15 15:07:45 2002 Manish Singh <yosh@gimp.org> * gmodule/Makefile.am gobject/Makefile.am gthread/Makefile.am: add -DG_DISABLED_DEPRECATED * tests/gio-test.c tests/mainloop-test.c tests/string-test.c tests/testglib.c test/tree-test.c tests/unicode-collate.c tests/unicode-normalize.c: Deprecation cleanup
2002-10-16 00:16:57 +02:00
g_main_loop_quit (main_loop);
New function, that calls g_source_remove(). Check return value of 2000-08-07 Tor Lillqvist <tml@iki.fi> * tests/gio-test.c (shutdown_source): New function, that calls g_source_remove(). Check return value of g_source_remove(), and decrement running subprocess counter only if g_source_remove() actually did remove the source. (recv_message): Call shutdown_source() on EOF condition. Return FALSE on G_IO_HUP and G_IO_ERR condition. Fix printf format typo.
2000-08-07 01:33:29 +02:00
}
}
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
static gboolean
recv_message (GIOChannel *channel,
GIOCondition cond,
gpointer data)
{
gint fd = g_io_channel_unix_get_fd (channel);
New function, that calls g_source_remove(). Check return value of 2000-08-07 Tor Lillqvist <tml@iki.fi> * tests/gio-test.c (shutdown_source): New function, that calls g_source_remove(). Check return value of g_source_remove(), and decrement running subprocess counter only if g_source_remove() actually did remove the source. (recv_message): Call shutdown_source() on EOF condition. Return FALSE on G_IO_HUP and G_IO_ERR condition. Fix printf format typo.
2000-08-07 01:33:29 +02:00
gboolean retval = TRUE;
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#ifdef VERBOSE
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
g_print ("gio-test: ...from %d:%s%s%s%s\n", fd,
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
(cond & G_IO_ERR) ? " ERR" : "",
(cond & G_IO_HUP) ? " HUP" : "",
(cond & G_IO_IN) ? " IN" : "",
(cond & G_IO_PRI) ? " PRI" : "");
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#endif
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
if (cond & (G_IO_ERR | G_IO_HUP))
{
New function, that calls g_source_remove(). Check return value of 2000-08-07 Tor Lillqvist <tml@iki.fi> * tests/gio-test.c (shutdown_source): New function, that calls g_source_remove(). Check return value of g_source_remove(), and decrement running subprocess counter only if g_source_remove() actually did remove the source. (recv_message): Call shutdown_source() on EOF condition. Return FALSE on G_IO_HUP and G_IO_ERR condition. Fix printf format typo.
2000-08-07 01:33:29 +02:00
shutdown_source (data);
retval = FALSE;
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
}
if (cond & G_IO_IN)
{
char buf[BUFSIZE];
guint nbytes;
guint nb;
int i, j, seq;
GIOError error;
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
error = read_all (fd, channel, (gchar *) &seq, sizeof (seq), &nb);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
if (error == G_IO_ERROR_NONE)
{
if (nb == 0)
{
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#ifdef VERBOSE
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
g_print ("gio-test: ...from %d: EOF\n", fd);
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#endif
New function, that calls g_source_remove(). Check return value of 2000-08-07 Tor Lillqvist <tml@iki.fi> * tests/gio-test.c (shutdown_source): New function, that calls g_source_remove(). Check return value of g_source_remove(), and decrement running subprocess counter only if g_source_remove() actually did remove the source. (recv_message): Call shutdown_source() on EOF condition. Return FALSE on G_IO_HUP and G_IO_ERR condition. Fix printf format typo.
2000-08-07 01:33:29 +02:00
shutdown_source (data);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
return FALSE;
}
g_assert (nb == sizeof (nbytes));
for (i = 0; i < nkiddies; i++)
if (seqtab[i].fd == fd)
{
Cosmetic changes
2012-06-11 13:19:42 +02:00
g_assert_cmpint (seq, ==, seqtab[i].seq);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
seqtab[i].seq++;
break;
}
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
error = read_all (fd, channel, (gchar *) &nbytes, sizeof (nbytes), &nb);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
}
if (error != G_IO_ERROR_NONE)
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
return FALSE;
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
if (nb == 0)
{
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#ifdef VERBOSE
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
g_print ("gio-test: ...from %d: EOF\n", fd);
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#endif
New function, that calls g_source_remove(). Check return value of 2000-08-07 Tor Lillqvist <tml@iki.fi> * tests/gio-test.c (shutdown_source): New function, that calls g_source_remove(). Check return value of g_source_remove(), and decrement running subprocess counter only if g_source_remove() actually did remove the source. (recv_message): Call shutdown_source() on EOF condition. Return FALSE on G_IO_HUP and G_IO_ERR condition. Fix printf format typo.
2000-08-07 01:33:29 +02:00
shutdown_source (data);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
return FALSE;
}
g_assert (nb == sizeof (nbytes));
Cosmetic changes
2012-06-11 13:19:42 +02:00
g_assert_cmpint (nbytes, <, BUFSIZE);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
g_assert (nbytes >= 0 && nbytes < BUFSIZE);
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#ifdef VERBOSE
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
g_print ("gio-test: ...from %d: %d bytes\n", fd, nbytes);
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#endif
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
if (nbytes > 0)
{
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
error = read_all (fd, channel, buf, nbytes, &nb);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
if (error != G_IO_ERROR_NONE)
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
return FALSE;
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
if (nb == 0)
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
{
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#ifdef VERBOSE
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
g_print ("gio-test: ...from %d: EOF\n", fd);
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#endif
New function, that calls g_source_remove(). Check return value of 2000-08-07 Tor Lillqvist <tml@iki.fi> * tests/gio-test.c (shutdown_source): New function, that calls g_source_remove(). Check return value of g_source_remove(), and decrement running subprocess counter only if g_source_remove() actually did remove the source. (recv_message): Call shutdown_source() on EOF condition. Return FALSE on G_IO_HUP and G_IO_ERR condition. Fix printf format typo.
2000-08-07 01:33:29 +02:00
shutdown_source (data);
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
return FALSE;
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
}
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
for (j = 0; j < nbytes; j++)
Cosmetic changes
2012-06-11 13:19:42 +02:00
g_assert (buf[j] == ' ' + ((nbytes + j) % 95));
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#ifdef VERBOSE
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
g_print ("gio-test: ...from %d: OK\n", fd);
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#endif
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
}
}
New function, that calls g_source_remove(). Check return value of 2000-08-07 Tor Lillqvist <tml@iki.fi> * tests/gio-test.c (shutdown_source): New function, that calls g_source_remove(). Check return value of g_source_remove(), and decrement running subprocess counter only if g_source_remove() actually did remove the source. (recv_message): Call shutdown_source() on EOF condition. Return FALSE on G_IO_HUP and G_IO_ERR condition. Fix printf format typo.
2000-08-07 01:33:29 +02:00
return retval;
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
}
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
#ifdef G_OS_WIN32
static gboolean
recv_windows_message (GIOChannel *channel,
GIOCondition cond,
gpointer data)
{
GIOError error;
MSG msg;
tests W32: Fix Windows values casting LPARAM is LONG_PTR which is the same as INT_PTR on Windows. WPARAM is UINT_PTR. HWND is a pointer. (%p prints pointers without 0x prefix, hence the extra 0x).
2018-09-20 07:18:51 +02:00
gsize nb;
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
while (1)
{
tests W32: Cast the MSG struct as (gchar *) for g_io_channel_read
2018-09-20 07:17:02 +02:00
error = g_io_channel_read (channel, (gchar *) &msg, sizeof (MSG), &nb);
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
if (error != G_IO_ERROR_NONE)
{
g_print ("gio-test: ...reading Windows message: G_IO_ERROR_%s\n",
(error == G_IO_ERROR_AGAIN ? "AGAIN" :
(error == G_IO_ERROR_INVAL ? "INVAL" :
(error == G_IO_ERROR_UNKNOWN ? "UNKNOWN" : "???"))));
if (error == G_IO_ERROR_AGAIN)
continue;
}
break;
}
tests W32: Fix Windows values casting LPARAM is LONG_PTR which is the same as INT_PTR on Windows. WPARAM is UINT_PTR. HWND is a pointer. (%p prints pointers without 0x prefix, hence the extra 0x).
2018-09-20 07:18:51 +02:00
g_print ("gio-test: ...Windows message for 0x%p: %d,%" G_GUINTPTR_FORMAT ",%" G_GINTPTR_FORMAT "\n",
msg.hwnd, msg.message, msg.wParam, (gintptr)msg.lParam);
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
return TRUE;
}
tests W32: Fix Windows values casting LPARAM is LONG_PTR which is the same as INT_PTR on Windows. WPARAM is UINT_PTR. HWND is a pointer. (%p prints pointers without 0x prefix, hence the extra 0x).
2018-09-20 07:18:51 +02:00
LRESULT CALLBACK window_procedure (HWND hwnd,
UINT message,
WPARAM wparam,
LPARAM lparam);
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
LRESULT CALLBACK
window_procedure (HWND hwnd,
UINT message,
WPARAM wparam,
LPARAM lparam)
{
tests W32: Fix Windows values casting LPARAM is LONG_PTR which is the same as INT_PTR on Windows. WPARAM is UINT_PTR. HWND is a pointer. (%p prints pointers without 0x prefix, hence the extra 0x).
2018-09-20 07:18:51 +02:00
g_print ("gio-test: window_procedure for 0x%p: %d,%" G_GUINTPTR_FORMAT ",%" G_GINTPTR_FORMAT "\n",
hwnd, message, wparam, (gintptr)lparam);
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
return DefWindowProc (hwnd, message, wparam, lparam);
}
#endif
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
int
main (int argc,
char **argv)
{
if (argc < 3)
{
/* Parent */
GIOChannel *my_read_channel;
gchar *cmdline;
guint *id;
int i;
#ifdef G_OS_WIN32
GTimeVal start, end;
Fix the Win32-only code to use current API, 2000-10-06 Tor Lillqvist <tml@iki.fi> * tests/gio-test.c (main): Fix the Win32-only code to use current API, g_io_channel_win32_make_pollfd() and g_io_channel_win32_poll().
2000-10-06 23:43:25 +02:00
GPollFD pollfd;
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
int pollresult;
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
ATOM klass;
static WNDCLASS wcl;
HWND hwnd;
GIOChannel *windows_messages_channel;
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
#endif
nkiddies = (argc == 1 ? 1 : atoi(argv[1]));
seqtab = g_malloc (nkiddies * 2 * sizeof (int));
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
#ifdef G_OS_WIN32
wcl.style = 0;
wcl.lpfnWndProc = window_procedure;
wcl.cbClsExtra = 0;
wcl.cbWndExtra = 0;
wcl.hInstance = GetModuleHandle (NULL);
wcl.hIcon = NULL;
wcl.hCursor = NULL;
wcl.hbrBackground = NULL;
wcl.lpszMenuName = NULL;
wcl.lpszClassName = "gio-test";
klass = RegisterClass (&wcl);
if (!klass)
{
g_print ("gio-test: RegisterClass failed\n");
exit (1);
}
make it compile again 2001-07-20 Hans Breuer <hans@breuer.org> * glib/glib/giowin32.c : make it compile again * glib/glib.def : updated exports * glib/makefile.msc.in : * glib/makefile.mingw.in : * tests/makefile.msc.in : reflect glib move * tests/mainloop-test.c : #include <io.h> for _pipe() * tests/gio-test.c : casts for strict compiler settings * makefile.msc.in : new master makefile reflecting the glib move. The '.in' isn't really needed anymore, because there is no version number in it
2001-07-20 19:13:52 +02:00
hwnd = CreateWindow (MAKEINTATOM(klass), "gio-test", 0, 0, 0, 10, 10,
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
NULL, NULL, wcl.hInstance, NULL);
if (!hwnd)
{
g_print ("gio-test: CreateWindow failed\n");
exit (1);
}
make it compile again 2001-07-20 Hans Breuer <hans@breuer.org> * glib/glib/giowin32.c : make it compile again * glib/glib.def : updated exports * glib/makefile.msc.in : * glib/makefile.mingw.in : * tests/makefile.msc.in : reflect glib move * tests/mainloop-test.c : #include <io.h> for _pipe() * tests/gio-test.c : casts for strict compiler settings * makefile.msc.in : new master makefile reflecting the glib move. The '.in' isn't really needed anymore, because there is no version number in it
2001-07-20 19:13:52 +02:00
windows_messages_channel = g_io_channel_win32_new_messages ((guint)hwnd);
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
g_io_add_watch (windows_messages_channel, G_IO_IN, recv_windows_message, 0);
#endif
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
for (i = 0; i < nkiddies; i++)
{
int pipe_to_sub[2], pipe_from_sub[2];
if (pipe (pipe_to_sub) == -1 ||
pipe (pipe_from_sub) == -1)
perror ("pipe"), exit (1);
seqtab[i].fd = pipe_from_sub[0];
seqtab[i].seq = 0;
my_read_channel = g_io_channel_unix_new (pipe_from_sub[0]);
id = g_new (guint, 1);
*id =
g_io_add_watch (my_read_channel,
G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP,
recv_message,
id);
nrunning++;
#ifdef G_OS_WIN32
tests W32: Fix Windows values casting LPARAM is LONG_PTR which is the same as INT_PTR on Windows. WPARAM is UINT_PTR. HWND is a pointer. (%p prints pointers without 0x prefix, hence the extra 0x).
2018-09-20 07:18:51 +02:00
cmdline = g_strdup_printf ("%d:%d:0x%p",
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
pipe_to_sub[0],
pipe_from_sub[1],
hwnd);
_spawnl (_P_NOWAIT, argv[0], argv[0], "--child", cmdline, NULL);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
#else
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
cmdline = g_strdup_printf ("%s --child %d:%d &", argv[0],
pipe_to_sub[0], pipe_from_sub[1]);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
system (cmdline);
gio-test: Fix leaks in tests https://bugzilla.gnome.org/show_bug.cgi?id=711751
2013-11-09 20:26:15 +01:00
g_free (cmdline);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
#endif
close (pipe_to_sub[0]);
close (pipe_from_sub [1]);
#ifdef G_OS_WIN32
g_get_current_time (&start);
Fix the Win32-only code to use current API, 2000-10-06 Tor Lillqvist <tml@iki.fi> * tests/gio-test.c (main): Fix the Win32-only code to use current API, g_io_channel_win32_make_pollfd() and g_io_channel_win32_poll().
2000-10-06 23:43:25 +02:00
g_io_channel_win32_make_pollfd (my_read_channel, G_IO_IN, &pollfd);
pollresult = g_io_channel_win32_poll (&pollfd, 1, 100);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
g_get_current_time (&end);
if (end.tv_usec < start.tv_usec)
end.tv_sec--, end.tv_usec += 1000000;
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
g_print ("gio-test: had to wait %ld.%03ld s, result:%d\n",
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
end.tv_sec - start.tv_sec,
(end.tv_usec - start.tv_usec) / 1000,
pollresult);
#endif
gio-test: Fix leaks in tests https://bugzilla.gnome.org/show_bug.cgi?id=711751
2013-11-09 20:26:15 +01:00
g_io_channel_unref (my_read_channel);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
}
add -DG_DISABLED_DEPRECATED Tue Oct 15 15:07:45 2002 Manish Singh <yosh@gimp.org> * gmodule/Makefile.am gobject/Makefile.am gthread/Makefile.am: add -DG_DISABLED_DEPRECATED * tests/gio-test.c tests/mainloop-test.c tests/string-test.c tests/testglib.c test/tree-test.c tests/unicode-collate.c tests/unicode-normalize.c: Deprecation cleanup
2002-10-16 00:16:57 +02:00
main_loop = g_main_loop_new (NULL, FALSE);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
add -DG_DISABLED_DEPRECATED Tue Oct 15 15:07:45 2002 Manish Singh <yosh@gimp.org> * gmodule/Makefile.am gobject/Makefile.am gthread/Makefile.am: add -DG_DISABLED_DEPRECATED * tests/gio-test.c tests/mainloop-test.c tests/string-test.c tests/testglib.c test/tree-test.c tests/unicode-collate.c tests/unicode-normalize.c: Deprecation cleanup
2002-10-16 00:16:57 +02:00
g_main_loop_run (main_loop);
gio-test: Fix leaks in tests https://bugzilla.gnome.org/show_bug.cgi?id=711751
2013-11-09 20:26:15 +01:00
g_main_loop_unref (main_loop);
g_free (seqtab);
g_free (id);
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
}
else if (argc == 3)
{
/* Child */
int readfd, writefd;
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
#ifdef G_OS_WIN32
HWND hwnd;
#endif
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
int i, j;
char buf[BUFSIZE];
int buflen;
GTimeVal tv;
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
int n;
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
g_get_current_time (&tv);
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
sscanf (argv[2], "%d:%d%n", &readfd, &writefd, &n);
#ifdef G_OS_WIN32
tests W32: Fix Windows values casting LPARAM is LONG_PTR which is the same as INT_PTR on Windows. WPARAM is UINT_PTR. HWND is a pointer. (%p prints pointers without 0x prefix, hence the extra 0x).
2018-09-20 07:18:51 +02:00
sscanf (argv[2] + n, ":0x%p", &hwnd);
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
#endif
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
srand (tv.tv_sec ^ (tv.tv_usec / 1000) ^ readfd ^ (writefd << 4));
for (i = 0; i < 20 + rand() % 20; i++)
{
g_usleep (100 + (rand() % 10) * 5000);
buflen = rand() % BUFSIZE;
for (j = 0; j < buflen; j++)
buf[j] = ' ' + ((buflen + j) % 95);
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#ifdef VERBOSE
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
g_print ("gio-test: child writing %d+%d bytes to %d\n",
Add a check for the Darwin dynamic linker. Use AC_TRY_LINK when checking * configure.in: Add a check for the Darwin dynamic linker. Use AC_TRY_LINK when checking for "nonposix getpwuid_r" so it notices "no getpwuid_r" correctly. * testglib.c (main): Make template[] bigger to prevent an overrun. Remove an unused variable. Initialize error to NULL. * tests/gio-test.c (main): Add a cast to prevent a warning when size_t is a long. * tests/type-test.c (main): Add an #ifdef to prevent a warning when G_HAVE_GINT64 is defined and G_GINT64_FORMAT isn't.
2001-04-20 19:08:57 +02:00
(int)(sizeof(i) + sizeof(buflen)), buflen, writefd);
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#endif
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
write (writefd, &i, sizeof (i));
write (writefd, &buflen, sizeof (buflen));
write (writefd, buf, buflen);
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
#ifdef G_OS_WIN32
if (rand() % 100 < 5)
{
int msg = WM_USER + (rand() % 100);
WPARAM wparam = rand ();
LPARAM lparam = rand ();
tests W32: Fix Windows values casting LPARAM is LONG_PTR which is the same as INT_PTR on Windows. WPARAM is UINT_PTR. HWND is a pointer. (%p prints pointers without 0x prefix, hence the extra 0x).
2018-09-20 07:18:51 +02:00
g_print ("gio-test: child posting message %d,%" G_GUINTPTR_FORMAT ",%" G_GINTPTR_FORMAT " to 0x%p\n",
msg, wparam, (gintptr)lparam, hwnd);
Socket support rewritten. It was utterly broken, and untested in fact. We 2001-01-25 Tor Lillqvist <tml@iki.fi> * giowin32.c: Socket support rewritten. It was utterly broken, and untested in fact. We still do use a thread for each socket being watched, but instead of blocking in recv() (which of course was plain stupid for sockets being liste()ed on), we block in select(). The read method for sockets calls recv(). It is now possible for the application to call accept(), recv() or send() in the callback, just like on Unix. Tested with code kindly provided by Andrew Lanoix. Rename g_io_channel_win32_new_stream_socket() to g_io_channel_win32_new_socket() as it isn't restricted to stream sockets. * gmain.c (g_poll): Related changes in the Win32 version of g_poll(). When polling for messages, always do a PeekMessage() first. We used to miss messages if several were posted between calls to g_poll(). * giochannel.h: Improve Win32-related comments. * gutf8.c: (Win32) Include <stdio.h> for sprintf. * tests/gio-test.c: (Win32) Add tests for polling for Windows messages. * tests/makefile.mingw.in: Remove superfluous compilation command line.
2001-01-25 22:16:46 +01:00
PostMessage (hwnd, msg, wparam, lparam);
}
#endif
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
}
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#ifdef VERBOSE
Compile in the debugging code all the time, but only output debug messages 2000-07-30 Tor Lillqvist <tml@iki.fi> * giowin32.c: Compile in the debugging code all the time, but only output debug messages if told so. Add (unadvertised) function to turn on/off debug messages for a channel. (buffer_read): Don't loop. It is expected behaviour to return a short read occasionally, for instance when reading from pipes. It's the calling code that should loop if it *knows* how much the writer has written. * tests/gio-test.c: Correct the program's name in the output. (recv_message): Loop calling g_io_channel_read() (in a new function read_all()) until we have all the bytes we want (that we know the writer has written/will write).
2000-07-30 02:27:39 +02:00
g_print ("gio-test: child exiting, closing %d\n", writefd);
Make the tests silent on success. 2005-07-14 Matthias Clasen <mclasen@redhat.com> * tests/spawn-test.c: * tests/uri-test.c: * tests/thread-test.c: * tests/queue-test.c: * tests/mainloop-test.c: * tests/iochannel-test.c: * tests/gio-test.c: * tests/child-test.c: Make the tests silent on success.
2005-07-14 07:20:14 +02:00
#endif
Finally, a new and improved IO Channel and condition watch implementation 2000-07-30 Tor Lillqvist <tml@iki.fi> Finally, a new and improved IO Channel and condition watch implementation for Win32. Based on code provided by Craig Setera. When watching file descriptors, for which there is no select() like functionality on Win32 that would work on all Win32 platforms for all types of file descriptors (including anonymous pipes), we start a new thread that blocks while trying to read from the file descriptor. When the read returns, a Win32 Event is signalled that the polling routine eventually notices. Meanwhile, the data being read is stored in a circular buffer, from where the IO channel's read() method picks it up. If the buffer fills up the reading thread has to wait for space becoming available. For this another Win32 Event is used. The IO Channel's read() method signals this when it has read some data out of the buffer. The separate reader thread(s), and the circular buffer(s) with associated events mean lots of possibilities for fun parallellism errors. But it seems to work OK, i.e. GIMP runs. * gmain.c: Small changes to the Win32 polling function. (g_main_win32_get_poll_func): New function. Perhaps it would be a good idea to provide this on all platforms. * giowin32.c: The bulk of the new implementation. (g_io_channel_win32_wait_for_condition): New function. To be used where on Unix one does a select() on the channel's fd, like libgimp's gimp_extension_process(). Could be provided on all platforms. * glib.h: Update documentation for IO Channels on Win32. Remove the declarations for the as of now obsolete old functions related to IO Channels for pipes with "wakeup" messages. * glib.def: Some new functions. * tests/gio-test.c: New file, to test GIOChannel and main loop. * tests/Makefile.am * tests/makefile.mingw.in: Add it.
2000-07-29 22:59:07 +02:00
close (writefd);
}
else
g_print ("Huh?\n");
return 0;
}
Reference in New Issue Copy Permalink