Implementing co-routines (co-operative multitasking) requires

• The ability to create a context (call stack and execution pointer).
• The ability to swap the active context with another.
• The ability to free a context.

(Example of a C co-routine implementation achieved using makecontext, swapcontext, getcontext and setcontext.)

goto &foo does not help with any of that.

On the other hand, it can be used to eliminate tail calls, and tail call elimination is something LISP does.

The OP uses goto &sub for tail call elimination.

I disagree, most probably your assumptions are based on some C lang specific conventions including call stack manipulations. (?)

And I can't deal with your C code either, especially as it's far from short.

But I looked into the WP page for Coroutines which has an abstract definition and boils it down to two simple criteria which can be very easily mapped to Perl.

The first yield-to example with routines translates 1to1

The next example showing a generator is a bit more complex, it requires to store the exit point in a closure-var as lable-name and to goto to that lable after rentry.

This is essentially the semantic of gather-take in Perl6

NB: I didn't say using goto &NAME and goto LABEL are efficient.

Cheers Rolf
_{(addicted to the Perl Programming Language :)
see Wikisyntax for the Monastery}

Update

The post I replied to was considerably extended while I wrote this

And I can't deal with your C code either, especially as it's far from short.

I never claimed that creating a multi-tasking system would be trivial? 60 lines is pretty short, and I presented it in even smaller sections.

Besides, the point is the following producer-consumer example runs and I only used the principles I said I used:

void *main_thread( void* dummy ) {
   (void)dummy;

   // Create the threads.
   ThreadId thread1_id = create_thread( func1, NULL );
   ThreadId thread2_id = create_thread( func2, NULL );

   // Wait for them to finish.
   wait_for_thread( thread1_id );
   wait_for_thread( thread2_id );

   return NULL;
}

void *func1( void *dummy ) {
   (void)dummy;

   for ( int i=5; i--; ) {
      printf( "func1\n" );
      if ( i )
         thread_sleep( 1 );
   }

   return NULL;
}

void *func2( void *dummy ) {
   (void)dummy;

   for ( int i=5; i--; ) {
      printf( "func2\n" );
      if ( i )
         thread_sleep( 1 );
   }

   return NULL;
}
[download]

I disagree, most probably your assumptions are based on some C lang specific conventions including call stack manipulations.

The first line from your link: "Coroutines are computer program components that allow execution to be suspended and resumed".

Suspending and resuming a function requires saving where it's at (execution pointer) and it's state (call stack incl lexicals).

Nothing about C or any other language here. You'll find the same thing in Perl coros (Coro) and everywhere else coros exist.

The first yield-to example with routines translates 1to1

Neither examples can be achieved using goto &sub. goto &sub can't be used to jump into the middle of a sub from outside a sub, much less restore the existing lexical state that existed when that point in the sub was previously reached. And I have no idea what you think would save that state in the first place.