--- Coro/Coro.pm	2001/07/17 02:21:56	1.14
+++ Coro/Coro.pm	2005/11/29 12:36:18	1.71
@@ -16,36 +16,51 @@
     # some more async code
  }
 
- yield;
+ cede;
 
 =head1 DESCRIPTION
 
 This module collection manages coroutines. Coroutines are similar to
-Threads but don't run in parallel.
+threads but don't run in parallel.
 
-This module is still experimental, see the BUGS section below.
+In this module, coroutines are defined as "callchain + lexical variables
++ @_ + $_ + $@ + $^W + C stack), that is, a coroutine has it's own
+callchain, it's own set of lexicals and it's own set of perl's most
+important global variables.
 
 =cut
 
 package Coro;
 
-use Coro::State;
+use strict;
+no warnings "uninitialized";
 
-use base Exporter;
+use Coro::State;
 
-$VERSION = 0.05;
+use base Exporter::;
 
-@EXPORT = qw(async yield schedule terminate);
-@EXPORT_OK = qw($current);
+our $idle;    # idle coroutine
+our $main;    # main coroutine
+our $current; # current coroutine
+
+our $VERSION = 1.5;
+
+our @EXPORT = qw(async cede schedule terminate current);
+our %EXPORT_TAGS = (
+      prio => [qw(PRIO_MAX PRIO_HIGH PRIO_NORMAL PRIO_LOW PRIO_IDLE PRIO_MIN)],
+);
+our @EXPORT_OK = @{$EXPORT_TAGS{prio}};
 
 {
-   use subs 'async';
-
    my @async;
+   my $init;
 
    # this way of handling attributes simply is NOT scalable ;()
    sub import {
+      no strict 'refs';
+
       Coro->export_to_level(1, @_);
+
       my $old = *{(caller)[0]."::MODIFY_CODE_ATTRIBUTES"}{CODE};
       *{(caller)[0]."::MODIFY_CODE_ATTRIBUTES"} = sub {
          my ($package, $ref) = (shift, shift);
@@ -53,28 +68,34 @@
          for (@_) {
             if ($_ eq "Coro") {
                push @async, $ref;
+               unless ($init++) {
+                  eval q{
+                     sub INIT {
+                        &async(pop @async) while @async;
+                     }
+                  };
+               }
             } else {
-               push @attrs, @_;
+               push @attrs, $_;
             }
          }
-         return $old ? $old->($package, $name, @attrs) : @attrs;
+         return $old ? $old->($package, $ref, @attrs) : @attrs;
       };
    }
 
-   sub INIT {
-      async pop @async while @async;
-   }
 }
 
+=over 4
+
 =item $main
 
 This coroutine represents the main program.
 
 =cut
 
-our $main = new Coro;
+$main = new Coro;
 
-=item $current
+=item $current (or as function: current)
 
 The current coroutine (the last coroutine switched to). The initial value is C<$main> (of course).
 
@@ -85,7 +106,9 @@
    $main->{specific} = $current->{specific};
 }
 
-our $current = $main;
+$current = $main;
+
+sub current() { $current }
 
 =item $idle
 
@@ -95,17 +118,41 @@
 =cut
 
 # should be done using priorities :(
-our $idle = new Coro sub {
+$idle = new Coro sub {
    print STDERR "FATAL: deadlock detected\n";
    exit(51);
 };
 
-# we really need priorities...
-## my @ready; #d#
-our @ready = (); # the ready queue. hehe, rather broken ;)
+# this coroutine is necessary because a coroutine
+# cannot destroy itself.
+my @destroy;
+my $manager;
+$manager = new Coro sub {
+   while () {
+      # by overwriting the state object with the manager we destroy it
+      # while still being able to schedule this coroutine (in case it has
+      # been readied multiple times. this is harmless since the manager
+      # can be called as many times as neccessary and will always
+      # remove itself from the runqueue
+      while (@destroy) {
+         my $coro = pop @destroy;
+         $coro->{status} ||= [];
+         $_->ready for @{delete $coro->{join} || []};
+
+         # the next line destroys the _coro_state, but keeps the
+         # process itself intact (we basically make it a zombie
+         # process that always runs the manager thread, so it's possible
+         # to transfer() to this process).
+         $coro->{_coro_state} = $manager->{_coro_state};
+      }
+      &schedule;
+   }
+};
 
 # static methods. not really.
 
+=back
+
 =head2 STATIC METHODS
 
 Static methods are actually functions that operate on the current process only.
@@ -123,13 +170,11 @@
       print "@_\n";
    } 1,2,3,4;
 
-The coderef you submit MUST NOT be a closure that refers to variables
-in an outer scope. This does NOT work. Pass arguments into it instead.
-
 =cut
 
 sub async(&@) {
    my $pid = new Coro @_;
+   $manager->ready; # this ensures that the stack is cloned from the manager
    $pid->ready;
    $pid;
 }
@@ -142,37 +187,22 @@
 
 =cut
 
-my $prev;
+=item cede
 
-sub schedule {
-   # should be done using priorities :(
-   ($prev, $current) = ($current, shift @ready || $idle);
-   Coro::State::transfer($prev, $current);
-}
-
-=item yield
-
-Yield to other processes. This function puts the current process into the
-ready queue and calls C<schedule>.
+"Cede" to other processes. This function puts the current process into the
+ready queue and calls C<schedule>, which has the effect of giving up the
+current "timeslice" to other coroutines of the same or higher priority.
 
 =cut
 
-sub yield {
-   $current->ready;
-   &schedule;
-}
-
-=item terminate
+=item terminate [arg...]
 
-Terminates the current process.
-
-Future versions of this function will allow result arguments.
+Terminates the current process with the given status values (see L<cancel>).
 
 =cut
 
 sub terminate {
-   $current->{_results} = [@_];
-   &schedule;
+   $current->cancel (@_);
 }
 
 =back
@@ -188,11 +218,9 @@
 =item new Coro \&sub [, @args...]
 
 Create a new process and return it. When the sub returns the process
-automatically terminates. To start the process you must first put it into
-the ready queue by calling the ready method.
-
-The coderef you submit MUST NOT be a closure that refers to variables
-in an outer scope. This does NOT work. Pass arguments into it instead.
+automatically terminates as if C<terminate> with the returned values were
+called. To make the process run you must first put it into the ready queue
+by calling the ready method.
 
 =cut
 
@@ -209,12 +237,94 @@
 
 =item $process->ready
 
-Put the current process into the ready queue.
+Put the given process into the ready queue.
+
+=cut
+
+=item $process->cancel (arg...)
+
+Temrinates the given process and makes it return the given arguments as
+status (default: the empty list).
+
+=cut
+
+sub cancel {
+   my $self = shift;
+   $self->{status} = [@_];
+   push @destroy, $self;
+   $manager->ready;
+   &schedule if $current == $self;
+}
+
+=item $process->join
+
+Wait until the coroutine terminates and return any values given to the
+C<terminate> or C<cancel> functions. C<join> can be called multiple times
+from multiple processes.
 
 =cut
 
-sub ready {
-   push @ready, $_[0];
+sub join {
+   my $self = shift;
+   unless ($self->{status}) {
+      push @{$self->{join}}, $current;
+      &schedule;
+   }
+   wantarray ? @{$self->{status}} : $self->{status}[0];
+}
+
+=item $oldprio = $process->prio($newprio)
+
+Sets (or gets, if the argument is missing) the priority of the
+process. Higher priority processes get run before lower priority
+processes. Priorities are small signed integers (currently -4 .. +3),
+that you can refer to using PRIO_xxx constants (use the import tag :prio
+to get then):
+
+   PRIO_MAX > PRIO_HIGH > PRIO_NORMAL > PRIO_LOW > PRIO_IDLE > PRIO_MIN
+       3    >     1     >      0      >    -1    >    -3     >    -4
+
+   # set priority to HIGH
+   current->prio(PRIO_HIGH);
+
+The idle coroutine ($Coro::idle) always has a lower priority than any
+existing coroutine.
+
+Changing the priority of the current process will take effect immediately,
+but changing the priority of processes in the ready queue (but not
+running) will only take effect after the next schedule (of that
+process). This is a bug that will be fixed in some future version.
+
+=cut
+
+sub prio {
+   my $old = $_[0]{prio};
+   $_[0]{prio} = $_[1] if @_ > 1;
+   $old;
+}
+
+=item $newprio = $process->nice($change)
+
+Similar to C<prio>, but subtract the given value from the priority (i.e.
+higher values mean lower priority, just as in unix).
+
+=cut
+
+sub nice {
+   $_[0]{prio} -= $_[1];
+}
+
+=item $olddesc = $process->desc($newdesc)
+
+Sets (or gets in case the argument is missing) the description for this
+process. This is just a free-form string you can associate with a process.
+
+=cut
+
+sub desc {
+   my $old = $_[0]{desc};
+   $_[0]{desc} = $_[1] if @_ > 1;
+   $old;
 }
 
 =back
@@ -223,23 +333,30 @@
 
 1;
 
-=head1 BUGS
+=head1 BUGS/LIMITATIONS
+
+ - you must make very sure that no coro is still active on global
+   destruction. very bad things might happen otherwise (usually segfaults).
 
- - could be faster, especially when the core would introduce special
-   support for coroutines (like it does for threads).
- - there is still a memleak on coroutine termination that I could not
-   identify. Could be as small as a single SV.
- - this module is not well-tested.
+ - this module is not thread-safe. You should only ever use this module
+   from the same thread (this requirement might be losened in the future
+   to allow per-thread schedulers, but Coro::State does not yet allow
+   this).
 
 =head1 SEE ALSO
 
-L<Coro::Channel>, L<Coro::Cont>, L<Coro::Specific>, L<Coro::Semaphore>,
-L<Coro::Signal>, L<Coro::State>, L<Coro::Event>.
+Support/Utility: L<Coro::Cont>, L<Coro::Specific>, L<Coro::State>, L<Coro::Util>.
+
+Locking/IPC: L<Coro::Signal>, L<Coro::Channel>, L<Coro::Semaphore>, L<Coro::SemaphoreSet>, L<Coro::RWLock>.
+
+Event/IO: L<Coro::Timer>, L<Coro::Event>, L<Coro::Handle>, L<Coro::Socket>, L<Coro::Select>.
+
+Embedding: L<Coro:MakeMaker>
 
 =head1 AUTHOR
 
- Marc Lehmann <pcg@goof.com>
- http://www.goof.com/pcg/marc/
+ Marc Lehmann <schmorp@schmorp.de>
+ http://home.schmorp.de/
 
 =cut