Coroutine Examples

#include <stdio.h>

int fn1, fn2, state = 1; // global variables
int fib() {
	int fn;
	switch ( state ) {
	  case 1:
		fn = 0; fn1 = fn; state = 2;
		break;
	  case 2:
		fn = 1; fn2 = fn1; fn1 = fn; state = 3;
		break;
	  case 3:
		fn = fn1 + fn2; fn2 = fn1; fn1 = fn;
		break;
	}
	return fn;
}
int main() {

	for ( int i = 0; i < 10; i += 1 ) {
		printf( "%d\n", fib() );
	}
}

#include <fstream.hfa>
#include <coroutine.hfa>
coroutine Fibonacci { int fn; };		// used for communication
void main( Fibonacci & fib ) with( fib ) { // called on first resume
	int fn1, fn2;						// retained between resumes
	fn = 0;  fn1 = fn;					// 1st case
	suspend;							// restart last resume
	fn = 1;  fn2 = fn1;  fn1 = fn;		// 2nd case
	suspend;							// restart last resume
	for () {
		fn = fn1 + fn2;  fn2 = fn1;  fn1 = fn; // general case
		suspend;						// restart last resume
	}
}
int next( Fibonacci & fib ) with( fib ) {
	resume( fib );						// restart last suspend
	return fn;
}
int main() {
	Fibonacci f1, f2;
	for ( 10 ) {						// print N Fibonacci values
		sout | next( f1 ) | next( f2 );
	}
}

#include <stdio.h>
typedef struct { int fn1, fn; } Fib;
#define FibCtor { 0, 1 }
int fib( Fib * f ) {


	int ret = f->fn1;
	f->fn1 = f->fn;
	f->fn = f->fn + fn;
	return ret;

}



int main() {
	Fib f1 = FibCtor, f2 = FibCtor;
	for ( int i = 0; i < 10; i += 1 ) {
		printf( "%d %d\n", fib( &f1 ), fib( &f2 ) );
	}
}

#include <fstream.hfa>
#include <coroutine.hfa>
coroutine Fibonacci { int fn1; };	// used for communication
void main( Fibonacci & fib ) with( fib ) { // called on first resume
	int fn;
	[fn1, fn] = [0, 1];				// precompute first two states
	for () {
		suspend;					// restart last resume
		[fn1, fn] = [fn, fn1 + fn];	// general case
	}
}
int ?()( Fibonacci & fib ) with( fib ) { // function call operator
	resume( fib );					// restart last suspend
	return fn1;
}
int main() {
	Fibonacci f1, f2;
	for ( 10 ) {					// print N Fibonacci values
		sout | f1() | f2();
	}
}

#include <stdio.h>

struct Format {
	char ch;
	int g, b;
};
void format( struct Format * fmt ) {
	if ( fmt->ch != -1 ) {			// not EOF ?
		printf( "%c", fmt->ch );
		fmt->b += 1;
		if ( fmt->b == 4 ) {		// block ?
			printf( "  " );			// separator
			fmt->b = 0;
			fmt->g += 1;
		}
		if ( fmt->g == 5 ) {		// group ?
			printf( "\n" );			// separator
			fmt->g = 0;
		}
	} else {
		if ( fmt->g != 0 || fmt->b != 0 ) printf( "\n" );
	}
}


int main() {
	struct Format fmt = { 0, 0, 0 };
	for () {
		scanf( "%c", &fmt.ch );
	if ( feof( stdin ) ) break;
		format( &fmt );
	}
	fmt.ch = -1;
	format( &fmt );
}

#include <fstream.hfa>
#include <coroutine.hfa>
coroutine Format {
	char ch;						// used for communication
	int g, b;						// global because used in destructor
};
void main( Format & fmt ) with( fmt ) {
	for () {						// for as many characters
		for ( g = 0; g < 5; g += 1 ) { // groups of 5 blocks
			for ( b = 0; b < 4; b += 1 ) { // blocks of 4 characters
				suspend;
				sout | ch | nonl;	// print character
			}
			sout | "  " | nonl;		// print block separator
		}
		sout | nl;					// print group separator
	}
}
void ?{}( Format & fmt ) { resume( fmt ); } // prime (start) coroutine
void ^?{}( Format & fmt ) with( fmt ) {
	if ( g != 0 || b != 0 ) sout | nl;
}
void prt( Format & fmt ) {
	resume( fmt );
}
int main() {
	Format fmt;
	try {
		for () {					// read until end of file
			sin | fmt.ch;			// read one character
			prt( fmt );				// push character for formatting
		}
	} catch( end_of_file * ) {		// end-of-file raised
	}
}

#include <fstream.hfa>
#include <coroutine.hfa>
#include <stdlib.hfa>				// random
#include <unistd.h>					// getpid

coroutine Cons;						// forward
int delivery( Cons & cons, int p1, int p2 );
void stop( Cons & cons );

coroutine Prod {
	Cons & c;
	int N, money, receipt;
};
void main( Prod & prod ) with( prod ) {	// starter ::main
	// 1st resume starts here
	for ( i; N ) {					// N pairs of values
		int p1 = random( 100 ), p2 = random( 100 );
		sout | p1 | " " | p2;
		int status = delivery( c, p1, p2 );
		sout | " $" | money | nl | status;
		receipt += 1;
	}
	stop( c );
	sout | "prod stops";
}
int payment( Prod & prod, int money ) {
	prod.money = money;
	resume( prod );					// main 1st time, then
	return prod.receipt;			// prod in delivery
}
void start( Prod & prod, int N, Cons &c ) {
	&prod.c = &c;
	prod.[N, receipt] = [N, 0];
	resume( prod );					// activate main
}

coroutine Cons {
	Prod & p;
	int p1, p2, status;
	_Bool done;
};
void ?{}( Cons & cons, Prod & p ) {
	&cons.p = &p;
	cons.[status, done ] = [0, false];
}
void ^?{}( Cons & cons ) {}
void main( Cons & cons ) with( cons ) {  // starter prod
	// 1st resume starts here
	int money = 1, receipt;
	for ( ; ! done; ) {
		sout | p1 | " " | p2 | nl | " $" | money;
		status += 1;
		receipt = payment( p, money );
		sout | " #" | receipt;
		money += 1;
	}
	sout | "cons stops";
}
int delivery( Cons & cons, int p1, int p2 ) {
	cons.[p1, p2] = [p1, p2];
	resume( cons );					// main 1st time, then
	return cons.status;				// cons in payment
}
void stop( Cons & cons ) {
	cons.done = true;
	resume( cons );					// activate payment
}
int main() {
	Prod prod;
	Cons cons = { prod };
	srandom( getpid() );
	start( prod, 5, cons );
}