#include<stdlib.h>
typedef void *stack;
typedef struct {
	int size;
	void *interface;
	__code  (*ret)(void*, stack) ;
} frame, *framep;

/* quickstart main routine. */
typedef struct {
	int *v;
	int s;
	int e;
} QS_IF ;
typedef __code  (*RET)(void*);

#include"quicksort_cbc.h"


typedef struct {
	__code  (*ret)(void*);
	void *ret_arg;
	stack *sp;
} QS_FINISH;

extern int *IFv;
extern int IFs;
extern int IFe;
extern RET IFret;
extern void *IFarg;
extern stack IFsp;
extern int IFsize;

static void(*exitfunc)(void*);
__code exitter(void *arg) {
	exitfunc(arg);
}

__code quicksort_finish_IF(void *arg, stack sp);

void
quicksort_IF()
{
	printf("v=%p\n", IFv);
	printf("s=%d\n", IFs);
	printf("e=%d\n", IFe);
	printf("ret=%p\n", IFret);
	printf("arg=%p\n", IFarg);
	printf("sp=%p\n", IFsp);
	printf("size=%d\n", IFsize);
	exitfunc = IFret;

	goto quicksort_IF0(IFv, IFs, IFe, exitter, IFarg, IFsp, IFsize);
}

__code 
quicksort_IF0(int *v, int s, int e,  RET ret, void *arg, stack sp0,int size)
{
	framep fp;
	stack sp;
	sp = sp0 + size;
	QS_FINISH *finish_if;
	QS_IF *outif;

	printf("v=%p\n", v);
	printf("s=%d\n", s);
	printf("e=%d\n", e);
	printf("ret=%p\n", ret);
	printf("arg=%p\n", arg);
	printf("sp=%p\n", sp0);
	printf("size=%d\n", size);
	
	/* interface for quicksort_finish.  */
	finish_if = (sp -= sizeof(QS_FINISH));
	finish_if->ret = ret;
	finish_if->ret_arg = arg;
	finish_if->sp = sp0;

	/* interface for quicksort_start.  */
	outif = (sp -= sizeof(QS_IF));
	outif->v = v;
	outif->s = s;
	outif->e = e;
	/* frame for quicksort_finish.  */
	fp = (sp -= sizeof(frame));
	fp->ret = quicksort_finish_IF;
	fp->interface = finish_if;
	fp->size = sizeof(frame)+sizeof(QS_IF);

	goto quicksort_start(outif, sp);
}

__code 
quicksort_finish_IF(void *arg, stack sp)
{
	QS_FINISH interface;
	interface = *(QS_FINISH*)arg;
	//assert((void*)interface.sp==(void*)mustbefreed);
	goto interface.ret(interface.ret_arg);
}