luc14n0/glib
1
0
Fork 0
mirror of https://gitlab.gnome.org/GNOME/glib.git synced 2025-03-12 02:35:28 +01:00
Code Issues Packages Projects Releases Wiki Activity

Minor cosmetic change to previous ChangeLog entry.

Browse Source
This commit is contained in:
Tor Lillqvist 2001-01-09 20:48:20 +00:00
parent 9d27e6b7d5
commit 85537f0c8a
8 changed files with 64 additions and 72 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
ChangeLog
View File

@ -1,14 +1,13 @@
2001-01-09 Tor Lillqvist <tml@iki.fi>
* giowin32.c (create_reader_thread): Rework the changes needed to
pass mainloop-test. Now we don't need to call TerminateThread()
after all, which is a relief, as the docs have a BIG RED WARNING
SIGN about using that API. Instead, when closing a fd channel that
has a reader thread running, just mark it as non-running and
additionally mark the fd as ripe for closing. When the reader
thread hopefully eventually gets something (and EOF or some actual
data), it will note that it shouldn't be running, break out of the
loop, and close the fd.
* giowin32.c: Rework the changes needed to pass mainloop-test. Now
we don't need to call TerminateThread() after all, which is a
relief, as the docs have a BIG RED WARNING SIGN about using that
API. Instead, when closing a fd channel that has a reader thread
running, just mark it as non-running and additionally mark the fd
as ripe for closing. When the reader thread hopefully eventually
gets something (and EOF or some actual data), it will note that it
shouldn't be running, break out of the loop, and close the fd.
The socket channel closing code should probably be changed
similarily, but that will have to wait until I have a test case.

17
ChangeLog.pre-2-0
View File

@ -1,14 +1,13 @@
2001-01-09 Tor Lillqvist <tml@iki.fi>
* giowin32.c (create_reader_thread): Rework the changes needed to
pass mainloop-test. Now we don't need to call TerminateThread()
after all, which is a relief, as the docs have a BIG RED WARNING
SIGN about using that API. Instead, when closing a fd channel that
has a reader thread running, just mark it as non-running and
additionally mark the fd as ripe for closing. When the reader
thread hopefully eventually gets something (and EOF or some actual
data), it will note that it shouldn't be running, break out of the
loop, and close the fd.
* giowin32.c: Rework the changes needed to pass mainloop-test. Now
we don't need to call TerminateThread() after all, which is a
relief, as the docs have a BIG RED WARNING SIGN about using that
API. Instead, when closing a fd channel that has a reader thread
running, just mark it as non-running and additionally mark the fd
as ripe for closing. When the reader thread hopefully eventually
gets something (and EOF or some actual data), it will note that it
shouldn't be running, break out of the loop, and close the fd.
The socket channel closing code should probably be changed
similarily, but that will have to wait until I have a test case.

17
ChangeLog.pre-2-10
View File

@ -1,14 +1,13 @@
2001-01-09 Tor Lillqvist <tml@iki.fi>
* giowin32.c (create_reader_thread): Rework the changes needed to
pass mainloop-test. Now we don't need to call TerminateThread()
after all, which is a relief, as the docs have a BIG RED WARNING
SIGN about using that API. Instead, when closing a fd channel that
has a reader thread running, just mark it as non-running and
additionally mark the fd as ripe for closing. When the reader
thread hopefully eventually gets something (and EOF or some actual
data), it will note that it shouldn't be running, break out of the
loop, and close the fd.
* giowin32.c: Rework the changes needed to pass mainloop-test. Now
we don't need to call TerminateThread() after all, which is a
relief, as the docs have a BIG RED WARNING SIGN about using that
API. Instead, when closing a fd channel that has a reader thread
running, just mark it as non-running and additionally mark the fd
as ripe for closing. When the reader thread hopefully eventually
gets something (and EOF or some actual data), it will note that it
shouldn't be running, break out of the loop, and close the fd.
The socket channel closing code should probably be changed
similarily, but that will have to wait until I have a test case.

17
ChangeLog.pre-2-12
View File

@ -1,14 +1,13 @@
2001-01-09 Tor Lillqvist <tml@iki.fi>
* giowin32.c (create_reader_thread): Rework the changes needed to
pass mainloop-test. Now we don't need to call TerminateThread()
after all, which is a relief, as the docs have a BIG RED WARNING
SIGN about using that API. Instead, when closing a fd channel that
has a reader thread running, just mark it as non-running and
additionally mark the fd as ripe for closing. When the reader
thread hopefully eventually gets something (and EOF or some actual
data), it will note that it shouldn't be running, break out of the
loop, and close the fd.
* giowin32.c: Rework the changes needed to pass mainloop-test. Now
we don't need to call TerminateThread() after all, which is a
relief, as the docs have a BIG RED WARNING SIGN about using that
API. Instead, when closing a fd channel that has a reader thread
running, just mark it as non-running and additionally mark the fd
as ripe for closing. When the reader thread hopefully eventually
gets something (and EOF or some actual data), it will note that it
shouldn't be running, break out of the loop, and close the fd.
The socket channel closing code should probably be changed
similarily, but that will have to wait until I have a test case.

17
ChangeLog.pre-2-2
View File

@ -1,14 +1,13 @@
2001-01-09 Tor Lillqvist <tml@iki.fi>
* giowin32.c (create_reader_thread): Rework the changes needed to
pass mainloop-test. Now we don't need to call TerminateThread()
after all, which is a relief, as the docs have a BIG RED WARNING
SIGN about using that API. Instead, when closing a fd channel that
has a reader thread running, just mark it as non-running and
additionally mark the fd as ripe for closing. When the reader
thread hopefully eventually gets something (and EOF or some actual
data), it will note that it shouldn't be running, break out of the
loop, and close the fd.
* giowin32.c: Rework the changes needed to pass mainloop-test. Now
we don't need to call TerminateThread() after all, which is a
relief, as the docs have a BIG RED WARNING SIGN about using that
API. Instead, when closing a fd channel that has a reader thread
running, just mark it as non-running and additionally mark the fd
as ripe for closing. When the reader thread hopefully eventually
gets something (and EOF or some actual data), it will note that it
shouldn't be running, break out of the loop, and close the fd.
The socket channel closing code should probably be changed
similarily, but that will have to wait until I have a test case.

17
ChangeLog.pre-2-4
View File

@ -1,14 +1,13 @@
2001-01-09 Tor Lillqvist <tml@iki.fi>
* giowin32.c (create_reader_thread): Rework the changes needed to
pass mainloop-test. Now we don't need to call TerminateThread()
after all, which is a relief, as the docs have a BIG RED WARNING
SIGN about using that API. Instead, when closing a fd channel that
has a reader thread running, just mark it as non-running and
additionally mark the fd as ripe for closing. When the reader
thread hopefully eventually gets something (and EOF or some actual
data), it will note that it shouldn't be running, break out of the
loop, and close the fd.
* giowin32.c: Rework the changes needed to pass mainloop-test. Now
we don't need to call TerminateThread() after all, which is a
relief, as the docs have a BIG RED WARNING SIGN about using that
API. Instead, when closing a fd channel that has a reader thread
running, just mark it as non-running and additionally mark the fd
as ripe for closing. When the reader thread hopefully eventually
gets something (and EOF or some actual data), it will note that it
shouldn't be running, break out of the loop, and close the fd.
The socket channel closing code should probably be changed
similarily, but that will have to wait until I have a test case.

17
ChangeLog.pre-2-6
View File

@ -1,14 +1,13 @@
2001-01-09 Tor Lillqvist <tml@iki.fi>
* giowin32.c (create_reader_thread): Rework the changes needed to
pass mainloop-test. Now we don't need to call TerminateThread()
after all, which is a relief, as the docs have a BIG RED WARNING
SIGN about using that API. Instead, when closing a fd channel that
has a reader thread running, just mark it as non-running and
additionally mark the fd as ripe for closing. When the reader
thread hopefully eventually gets something (and EOF or some actual
data), it will note that it shouldn't be running, break out of the
loop, and close the fd.
* giowin32.c: Rework the changes needed to pass mainloop-test. Now
we don't need to call TerminateThread() after all, which is a
relief, as the docs have a BIG RED WARNING SIGN about using that
API. Instead, when closing a fd channel that has a reader thread
running, just mark it as non-running and additionally mark the fd
as ripe for closing. When the reader thread hopefully eventually
gets something (and EOF or some actual data), it will note that it
shouldn't be running, break out of the loop, and close the fd.
The socket channel closing code should probably be changed
similarily, but that will have to wait until I have a test case.

17
ChangeLog.pre-2-8
View File

@ -1,14 +1,13 @@
2001-01-09 Tor Lillqvist <tml@iki.fi>
* giowin32.c (create_reader_thread): Rework the changes needed to
pass mainloop-test. Now we don't need to call TerminateThread()
after all, which is a relief, as the docs have a BIG RED WARNING
SIGN about using that API. Instead, when closing a fd channel that
has a reader thread running, just mark it as non-running and
additionally mark the fd as ripe for closing. When the reader
thread hopefully eventually gets something (and EOF or some actual
data), it will note that it shouldn't be running, break out of the
loop, and close the fd.
* giowin32.c: Rework the changes needed to pass mainloop-test. Now
we don't need to call TerminateThread() after all, which is a
relief, as the docs have a BIG RED WARNING SIGN about using that
API. Instead, when closing a fd channel that has a reader thread
running, just mark it as non-running and additionally mark the fd
as ripe for closing. When the reader thread hopefully eventually
gets something (and EOF or some actual data), it will note that it
shouldn't be running, break out of the loop, and close the fd.
The socket channel closing code should probably be changed
similarily, but that will have to wait until I have a test case.