--- libev/ev.pod	2008/02/06 18:34:24	1.130
+++ libev/ev.pod	2008/03/08 07:04:56	1.134
@@ -508,6 +508,10 @@
 C<ev_loop_new>. Yes, you have to call this on every allocated event loop
 after fork, and how you do this is entirely your own problem.
 
+=item int ev_is_default_loop (loop)
+
+Returns true when the given loop actually is the default loop, false otherwise.
+
 =item unsigned int ev_loop_count (loop)
 
 Returns the count of loop iterations for the loop, which is identical to
@@ -1154,7 +1158,7 @@
 the timer (because it takes longer than those 10 seconds to do stuff) the
 timer will not fire more than once per event loop iteration.
 
-=item ev_timer_again (loop)
+=item ev_timer_again (loop, ev_timer *)
 
 This will act as if the timer timed out and restart it again if it is
 repeating. The exact semantics are:
@@ -1273,7 +1277,7 @@
 that is, if it is to be run at January 1st 2011 then it will run when the
 system time reaches or surpasses this time.
 
-=item * non-repeating interval timer (at = offset, interval > 0, reschedule_cb = 0)
+=item * repeating interval timer (at = offset, interval > 0, reschedule_cb = 0)
 
 In this mode the watcher will always be scheduled to time out at the next
 C<at + N * interval> time (for some integer N, which can also be negative)
@@ -1434,11 +1438,50 @@
 
 =back
 
+=head3 Examples
+
+Example: Try to exit cleanly on SIGINT and SIGTERM.
+
+  static void
+  sigint_cb (struct ev_loop *loop, struct ev_signal *w, int revents)
+  {
+    ev_unloop (loop, EVUNLOOP_ALL);
+  }
+
+  struct ev_signal signal_watcher;
+  ev_signal_init (&signal_watcher, sigint_cb, SIGINT);
+  ev_signal_start (loop, &sigint_cb);
+
 
 =head2 C<ev_child> - watch out for process status changes
 
 Child watchers trigger when your process receives a SIGCHLD in response to
-some child status changes (most typically when a child of yours dies).
+some child status changes (most typically when a child of yours dies). It
+is permissible to install a child watcher I<after> the child has been
+forked (which implies it might have already exited), as long as the event
+loop isn't entered (or is continued from a watcher).
+
+Only the default event loop is capable of handling signals, and therefore
+you can only rgeister child watchers in the default event loop.
+
+=head3 Process Interaction
+
+Libev grabs C<SIGCHLD> as soon as the default event loop is
+initialised. This is necessary to guarantee proper behaviour even if
+the first child watcher is started after the child exits. The occurance
+of C<SIGCHLD> is recorded asynchronously, but child reaping is done
+synchronously as part of the event loop processing. Libev always reaps all
+children, even ones not watched.
+
+=head3 Overriding the Built-In Processing
+
+Libev offers no special support for overriding the built-in child
+processing, but if your application collides with libev's default child
+handler, you can override it easily by installing your own handler for
+C<SIGCHLD> after initialising the default loop, and making sure the
+default loop never gets destroyed. You are encouraged, however, to use an
+event-based approach to child reaping and thus use libev's support for
+that, so other libev users can use C<ev_child> watchers freely.
 
 =head3 Watcher-Specific Functions and Data Members
 
@@ -1474,17 +1517,32 @@
 
 =head3 Examples
 
-Example: Try to exit cleanly on SIGINT and SIGTERM.
+Example: C<fork()> a new process and install a child handler to wait for
+its completion.
+
+  ev_child cw;
 
   static void
-  sigint_cb (struct ev_loop *loop, struct ev_signal *w, int revents)
+  child_cb (EV_P_ struct ev_child *w, int revents)
   {
-    ev_unloop (loop, EVUNLOOP_ALL);
+    ev_child_stop (EV_A_ w);
+    printf ("process %d exited with status %x\n", w->rpid, w->rstatus);
   }
 
-  struct ev_signal signal_watcher;
-  ev_signal_init (&signal_watcher, sigint_cb, SIGINT);
-  ev_signal_start (loop, &sigint_cb);
+  pid_t pid = fork ();
+
+  if (pid < 0)
+    // error
+  else if (pid == 0)
+    {
+      // the forked child executes here
+      exit (1);
+    }
+  else
+    {
+      ev_child_init (&cw, child_cb, pid, 0);
+      ev_child_start (EV_DEFAULT_ &cw);
+    }
 
 
 =head2 C<ev_stat> - did the file attributes just change?
@@ -1574,7 +1632,7 @@
 relative to the attributes at the time the watcher was started (or the
 last change was detected).
 
-=item ev_stat_stat (ev_stat *)
+=item ev_stat_stat (loop, ev_stat *)
 
 Updates the stat buffer immediately with new values. If you change the
 watched path in your callback, you could call this fucntion to avoid
@@ -2100,7 +2158,7 @@
 
      // no locking etc.
      queue_put (data);
-     ev_async_send (DEFAULT_ &mysig);
+     ev_async_send (EV_DEFAULT_ &mysig);
    }
 
    static void
@@ -2141,7 +2199,7 @@
      queue_put (data);
      pthread_mutex_unlock (&mymutex);
 
-     ev_async_send (DEFAULT_ &mysig);
+     ev_async_send (EV_DEFAULT_ &mysig);
    }
 
    static void