有栈协程和无栈协程

typedef struct ucontext
{
    unsigned long int uc_flags;
    struct ucontext *uc_link;
    stack_t uc_stack;
    mcontext_t uc_mcontext;
    __sigset_t uc_sigmask;
    struct _libc_fpstate __fpregs_mem;
} ucontext_t;

int swapcontext(ucontext_t *oucp, const ucontext_t *ucp);
ENTRY(__swapcontext)
    /* Save the preserved registers, the registers used for passing args,
       and the return address.  */
    movq    %rbx, oRBX(%rdi)
    movq    %rbp, oRBP(%rdi)
    movq    %r12, oR12(%rdi)
    movq    %r13, oR13(%rdi)
    movq    %r14, oR14(%rdi)
    movq    %r15, oR15(%rdi)

    movq    %rdi, oRDI(%rdi)
    movq    %rsi, oRSI(%rdi)
    movq    %rdx, oRDX(%rdi)
    movq    %rcx, oRCX(%rdi)
    movq    %r8, oR8(%rdi)
    movq    %r9, oR9(%rdi)         //这一波是把寄存器内容缓存起来，这些寄存器是传参和传递返回地址用的

    movq    (%rsp), %rcx           //因为这里函数调用，被调函数没有执行入栈操作，所以当前栈指针是执向返回地址的
    movq    %rcx, oRIP(%rdi)       //因此这里入栈其实是把返回地址给存器来了
    leaq    8(%rsp), %rcx       
    movq    %rcx, oRSP(%rdi)       //这两句是存返回地址
    leaq    oFPREGSMEM(%rdi), %rcx  //栈上面有独立的存储空间存放浮点数环境，我们用结构体中__fpregs_mem进行存储
    movq    %rcx, oFPREGS(%rdi)
    /* Save the floating-point environment.  */
    fnstenv (%rcx)                   //存浮点数环境
    stmxcsr oMXCSR(%rdi)             //存MXCSR寄存器内容
    /* The syscall destroys some registers, save them.  */
    movq    %rsi, %r12

    /* Save the current signal mask and install the new one with
       rt_sigprocmask (SIG_BLOCK, newset, oldset,_NSIG/8).  */
    leaq    oSIGMASK(%rdi), %rdx
    leaq    oSIGMASK(%rsi), %rsi
    movl    $SIG_SETMASK, %edi
    movl    $_NSIG8,%r10d
    movl    $__NR_rt_sigprocmask, %eax 
    syscall                       //这里其实是一个系统调用过程，将系统调用号存入rax中，参数存入rdx等寄存器中，并通过
    cmpq    $-4095, %rax          //syscall触发系统调用，调用完毕后通过eax获取返回值，上面的过程其实就是将当前的系统  
    jae SYSCALL_ERROR_LABEL       //调用号存起来并把新的传进去，通过rax寄存器拿到返回值判断是否成功

    /* Restore destroyed registers.  */
    movq    %r12, %rsi

    /* Restore the floating-point context.  Not the registers, only the
       rest.  */
    movq    oFPREGS(%rsi), %rcx
    fldenv  (%rcx)
    ldmxcsr oMXCSR(%rsi)

    /* Load the new stack pointer and the preserved registers.  */
    movq    oRSP(%rsi), %rsp
    movq    oRBX(%rsi), %rbx
    movq    oRBP(%rsi), %rbp
    movq    oR12(%rsi), %r12
    movq    oR13(%rsi), %r13
    movq    oR14(%rsi), %r14
    movq    oR15(%rsi), %r15

    /* The following ret should return to the address set with
    getcontext.  Therefore push the address on the stack.  */
    movq    oRIP(%rsi), %rcx
    pushq   %rcx

    /* Setup registers used for passing args.  */
    movq    oRDI(%rsi), %rdi
    movq    oRDX(%rsi), %rdx
    movq    oRCX(%rsi), %rcx
    movq    oR8(%rsi), %r8
    movq    oR9(%rsi), %r9

    /* Setup finally  %rsi.  */
    movq    oRSI(%rsi), %rsi    //要拉起的进程的寄存器恢复

    /* Clear rax to indicate success.  */
    xorl    %eax, %eax
    ret
PSEUDO_END(__swapcontext)

struct args { int n;};
static void foo(struct schedule * S, void *ud) {
	struct args * arg = ud;
	int start = arg->n;
	int i;
	for (i=0;i<5;i++) {
		printf("coroutine %d : %d\n",coroutine_running(S) , start + i);
		coroutine_yield(S);
	}
}
static void test(struct schedule *S) {
	struct args arg1 = {0};
	struct args arg2 = {100};
	// 创建两个协程
	int co1 = coroutine_new(S, foo, &arg1);
	int co2 = coroutine_new(S, foo, &arg2);
	while (coroutine_status(S,co1) && coroutine_status(S,co2)) {
		coroutine_resume(S,co1);// 使用协程 co1
		coroutine_resume(S,co2);// 使用协程 co2
	}
}

int main() {
	struct schedule * S = coroutine_open();// 创建一个协程调度器
	test(S);
	coroutine_close(S);// 关闭协程调度器
	return 0;
}

struct schedule {
	char stack[STACK_SIZE];
	ucontext_t main;
	int nco;
	int cap;
	int running;
	struct coroutine **co;
};

struct coroutine {
	coroutine_func func;
	void *ud;
	ucontext_t ctx;
	struct schedule * sch;
	ptrdiff_t cap;
	ptrdiff_t size;
	int status;
	char *stack;
};

static void mainfunc(uint32_t low32, uint32_t hi32) {
	uintptr_t ptr = (uintptr_t)low32 | ((uintptr_t)hi32 << 32);
	struct schedule *S = (struct schedule *)ptr;
	int id = S->running;
	struct coroutine *C = S->co[id];
	C->func(S,C->ud);
	_co_delete(C);
	S->co[id] = NULL;
	--S->nco;
	S->running = -1;
}

void  coroutine_resume(struct schedule * S, int id) {
	struct coroutine *C = S->co[id];
	switch(C->status) {
	case COROUTINE_READY:
		getcontext(&C->ctx);
		C->ctx.uc_stack.ss_sp = S->stack;
		C->ctx.uc_stack.ss_size = STACK_SIZE;
		C->ctx.uc_link = &S->main;
		S->running = id;
		C->status = COROUTINE_RUNNING;
		uintptr_t ptr = (uintptr_t)S;
		makecontext(&C->ctx,(void (*)(void))mainfunc,2,(uint32_t)ptr,(uint32_t(ptr>>32));
		swapcontext(&S->main, &C->ctx);
		break;
	case COROUTINE_SUSPEND:
		memcpy(S->stack + STACK_SIZE - C->size, C->stack, C->size);
		S->running = id;
		C->status = COROUTINE_RUNNING;
		swapcontext(&S->main, &C->ctx);
		break;
	default:
		assert(0);
	}
}

static void _save_stack(struct coroutine *C, char *top) {
	char dummy = 0;
	assert(top - &dummy <= STACK_SIZE);
	if (C->cap < top - &dummy) {
		free(C->stack);
		C->cap = top-&dummy;
		C->stack = malloc(C->cap);
	}
	C->size = top - &dummy;
	memcpy(C->stack, &dummy, C->size);
}
                    
void coroutine_yield(struct schedule * S) {
	int id = S->running;
	struct coroutine * C = S->co[id];
	_save_stack(C,S->stack + STACK_SIZE);
	C->status = COROUTINE_SUSPEND;
	S->running = -1;
	swapcontext(&C->ctx , &S->main);
}

struct stTask_t {
	int id;
};
struct stEnv_t {
	stCoCond_t* cond;
	queue<stTask_t*> task_queue;
};
void* Producer(void* args) {
	co_enable_hook_sys();
	stEnv_t* env=  (stEnv_t*)args;
	int id = 0;
	while (true) {
		stTask_t* task = (stTask_t*)calloc(1, sizeof(stTask_t));
		task->id = id++;
		env->task_queue.push(task);
		co_cond_signal(env->cond);
		poll(NULL, 0, 1000);
	}
	return NULL;
}
void* Consumer(void* args) {
	co_enable_hook_sys();
	stEnv_t* env = (stEnv_t*)args;
	while (true) {
		if (env->task_queue.empty())
		{
			co_cond_timedwait(env->cond, -1);
			continue;
		}
		stTask_t* task = env->task_queue.front();
		env->task_queue.pop();
		free(task);
	}
	return NULL;
}
int main() {
	stEnv_t* env = new stEnv_t;
	env->cond = co_cond_alloc();

	stCoRoutine_t* consumer_routine;
	co_create(&consumer_routine, NULL, Consumer, env);
	co_resume(consumer_routine);

	stCoRoutine_t* producer_routine;
	co_create(&producer_routine, NULL, Producer, env);
	co_resume(producer_routine);
	
	co_eventloop(co_get_epoll_ct(), NULL, NULL);
	return 0;
}

struct stCoRoutineAttr_t {
	int stack_size;
	stShareStack_t*  share_stack;
	stCoRoutineAttr_t()
	{
		stack_size = 128 * 1024;
		share_stack = NULL;
	}
}__attribute__ ((packed));

struct stCoRoutineEnv_t{
	stCoRoutine_t *pCallStack[ 128 ];
	int iCallStackSize;
	stCoEpoll_t *pEpoll;
	stCoRoutine_t* pending_co;
	stCoRoutine_t* occupy_co;
};

struct stCoRoutine_t
{
	stCoRoutineEnv_t *env;
	pfn_co_routine_t pfn;
	void *arg;
	coctx_t ctx;
	char cStart;
	char cEnd;
	char cIsMain;
	char cEnableSysHook;
	char cIsShareStack;
	void *pvEnv;
	stStackMem_t* stack_mem;
	//save satck buffer while confilct on same stack_buffer;
	char* stack_sp; 
	unsigned int save_size;
	char* save_buffer;
	stCoSpec_t aSpec[1024];
};

struct coctx_t
{
#if defined(__i386__)
	void *regs[ 8 ];
#else
	void *regs[ 14 ];
#endif
	size_t ss_size;
	char *ss_sp;
	
};

stCoRoutineEnv_t *co_get_curr_thread_env() {
	return gCoEnvPerThread;
}

void co_init_curr_thread_env() {
	gCoEnvPerThread = (stCoRoutineEnv_t*)calloc( 1, sizeof(stCoRoutineEnv_t) );
	stCoRoutineEnv_t *env = gCoEnvPerThread;
	env->iCallStackSize = 0;
	struct stCoRoutine_t *self = co_create_env( env, NULL, NULL,NULL );
	self->cIsMain = 1;
	env->pending_co = NULL;
	env->occupy_co = NULL;
	coctx_init( &self->ctx );
	env->pCallStack[ env->iCallStackSize++ ] = self;
	stCoEpoll_t *ev = AllocEpoll();
	SetEpoll( env,ev );
}


int co_create( stCoRoutine_t **ppco,const stCoRoutineAttr_t *attr,pfn_co_routine_t pfn,void *arg ) {
	if( !co_get_curr_thread_env() ) {
		co_init_curr_thread_env();
	}
	stCoRoutine_t *co = co_create_env( co_get_curr_thread_env(), attr, pfn,arg );
	*ppco = co;
	return 0;
}

struct stCoRoutine_t *co_create_env( stCoRoutineEnv_t * env, const stCoRoutineAttr_t* attr,
		pfn_co_routine_t pfn,void *arg ) {
	stCoRoutineAttr_t at;
	if( attr ) {
		memcpy( &at,attr,sizeof(at) );
	}
	if( at.stack_size <= 0 ) {
		at.stack_size = 128 * 1024; 
	}
	else if( at.stack_size > 1024 * 1024 * 8 ) {
		at.stack_size = 1024 * 1024 * 8;
	}
	if( at.stack_size & 0xFFF )  {
		at.stack_size &= ~0xFFF;
		at.stack_size += 0x1000;
	}
	stCoRoutine_t *lp = (stCoRoutine_t*)malloc( sizeof(stCoRoutine_t) );
	memset( lp,0,(long)(sizeof(stCoRoutine_t))); 
	lp->env = env;
	lp->pfn = pfn;
	lp->arg = arg;
	stStackMem_t* stack_mem = NULL;
	if( at.share_stack ) {
		... ...
	}
	else {
		// 如果没有采用共享栈，则分配内存
		stack_mem = co_alloc_stackmem(at.stack_size);
	}
	lp->stack_mem = stack_mem;
	// 设置该协程的context
	lp->ctx.ss_sp = stack_mem->stack_buffer; // 栈地址
	lp->ctx.ss_size = at.stack_size; // 栈大小
	lp->cStart = 0;
	lp->cEnd = 0;
	lp->cIsMain = 0;
	lp->cEnableSysHook = 0;	// 默认不开启hook
	lp->cIsShareStack = at.share_stack != NULL;
	return lp;
}

#if defined(__i386__)
... ...
#elif defined(__x86_64__)
int coctx_make( coctx_t *ctx,coctx_pfn_t pfn,const void *s,const void *s1 )
{
	char *sp = ctx->ss_sp + ctx->ss_size;
	sp = (char*) ((unsigned long)sp & -16LL  );
	memset(ctx->regs, 0, sizeof(ctx->regs));
	ctx->regs[ kRSP ] = sp - 8;
	ctx->regs[ kRETAddr] = (char*)pfn;
	ctx->regs[ kRDI ] = (char*)s;
	ctx->regs[ kRSI ] = (char*)s1;
	return 0;
}

void co_resume( stCoRoutine_t *co )
{
	stCoRoutineEnv_t *env = co->env;
	// 找到当前运行的协程, 从数组最后一位拿出当前运行的协程，如果目前没有协程，那就是主线程
	stCoRoutine_t *lpCurrRoutine = env->pCallStack[ env->iCallStackSize - 1 ];
	if( !co->cStart ) {
		// 如果当前协程还没有开始运行，为其构建上下文
		coctx_make( &co->ctx,(coctx_pfn_t)CoRoutineFunc,co, 0 );
		co->cStart = 1;
	}
	// 将指定协程放入线程的协程队列末尾
	env->pCallStack[ env->iCallStackSize++ ] = co;
	// 将当前运行的上下文保存到lpCurrRoutine中，同时将协程co的上下文替换进去
	co_swap( lpCurrRoutine, co );
}

void co_swap(stCoRoutine_t* curr, stCoRoutine_t* pending_co)
{
 	stCoRoutineEnv_t* env = co_get_curr_thread_env();
	//get curr stack sp
	//这里非常重要!!!： 这个c变量的实现，作用是为了找到目前的栈底，因为c变量是最后一个放入栈中的内容。
	char c;
	curr->stack_sp= &c;
	if (!pending_co->cIsShareStack) {  
		env->pending_co = NULL;
		env->occupy_co = NULL;
	}
	else { // 如果采用了共享栈
	    ... ...
	}
	// swap context
	coctx_swap(&(curr->ctx),&(pending_co->ctx) );
	// 上一步coctx_swap会进入到pending_co的协程环境中运行
	// 但是pengdin_co也是这一步换出的，所以被换入的时候也是从这一步继续往后执行
	// 而yield回此协程之前，env->pending_co会被上一层协程设置为此协程
	// 因此可以顺利执行: 将之前保存起来的栈内容，恢复到运行栈上
	//stack buffer may be overwrite, so get again;
	stCoRoutineEnv_t* curr_env = co_get_curr_thread_env();
	stCoRoutine_t* update_occupy_co =  curr_env->occupy_co;
	stCoRoutine_t* update_pending_co = curr_env->pending_co;
	// 将栈的内容恢复，如果不是共享栈的话，每个协程都有自己独立的栈空间，则不用恢复。
	if (update_occupy_co && update_pending_co && update_occupy_co != update_pending_co) {
         ... ...
	}
}

.globl coctx_swap
// coctx_swap(coctx_t curr,coctx_t pending)

#if defined(__i386__)
	... ...
#elif defined(__x86_64__)
	leaq 8(%rsp),%rax   // 父函数栈帧中除返回地址外栈帧顶的位置
	
	leaq 112(%rdi),%rsp ;rdi寄存器存的是第一个参数的地址，其112个字节后，是regs数组后的位置。
	                    ;所以这一步是把栈指针设置为regs数组地址
	// 将寄存器保存到入栈,因为此时栈的地址指向数组，因此实际上就是讲各个寄存器填充到数组中
	pushq %rax  // rax -> regs[13]，也就是当前的rsp -> regs[13]
	pushq %rbx  // rbx -> regs[12]
	pushq %rcx  // rcx -> regs[11]
	pushq %rdx  // rdx -> regs[10]
	pushq -8(%rax) // ret func addr  返回地址 -> regs[9]
	pushq %rsi  // rsi -> regs[8]
	pushq %rdi  // rdi -> regs[7]
	pushq %rbp  // rbp -> regs[6]
	pushq %r8   // r8 -> regs[5]
	pushq %r9   // r9 -> regs[4]
	pushq %r12   // r12 -> regs[3]
	pushq %r13    // r13 -> regs[2]
	pushq %r14   // r14 -> regs[1]
	pushq %r15   // r15 -> regs[0]  // r15是程序计数器
	// 截止到此，所有的协程上下文保存成功 
	// rsi中是第二个参数，我们需要将第二个参数的上下文载入到寄存器和栈里面
	// rsi的首地址就是整个regs[]参数的地址,从0开始，所以当pop的时候，将从0将参数pop出来。
	movq %rsi, %rsp
	popq %r15         ;以下为倒序还原
	popq %r14
	popq %r13
	popq %r12
	popq %r9
	popq %r8
	popq %rbp
	popq %rdi
	popq %rsi
	popq %rax //ret func addr
	popq %rdx
	popq %rcx
	popq %rbx
	popq %rsp
	pushq %rax // 将返回地址入栈
	// 将eax寄存器清零，eax是rax的低32位，也就是将rax的低32位清零。也就是return 0的意思。
	xorl %eax, %eax
	// 返回函数
	ret
#endif

/*
*
* 主动将当前运行的协程挂起，并恢复到上一层的协程
*
* @param env 协程管理器 
*/
void co_yield_env( stCoRoutineEnv_t *env )
{
	// 这里直接取了iCallStackSize - 2，那么万一icallstacksize < 2呢？
	// 所以这里实际上有个约束，就是co_yield之前必须先co_resume, 这样就不会造成这个问题了
	// last就是 找到上次调用co_resume(curr)的协程
	stCoRoutine_t *last = env->pCallStack[ env->iCallStackSize - 2 ];
	// 当前栈
	stCoRoutine_t *curr = env->pCallStack[ env->iCallStackSize - 1 ];
	env->iCallStackSize--;
	// 把上下文当前的存储到curr中，并切换成last的上下文
	co_swap( curr, last);
}

void co_yield( stCoRoutine_t *co )
{
	co_yield_env( co->env );
}

send(to, from, count)
	register short *to, *from;
	register count;
	{
		do
			*to = *from++;
		while(--count>0);
	}

send(to, from, count)
register short *to, *from;
register count;
{
	register n = (count + 7) / 8;
	switch (count % 8) {
	case 0:	do { *to = *from++;
	case 7:		 *to = *from++;
	case 6:		 *to = *from++;
	case 5:		 *to = *from++;
	case 4:	     *to = *from++;
	case 3:      *to = *from++;
	case 2:      *to = *from++;
	case 1:      *to = *from++;
	        } while (--n > 0);
	}
}

send(to, from, count)
register short *to, *from;
register count;
{
    register n = (count + 7) / 8;
    switch (count % 8) {
        case 0: *to = *from++;
        case 7: *to = *from++;
        case 6: *to = *from++;
        case 5: *to = *from++;
        case 4: *to = *from++;
        case 3: *to = *from++;
        case 2: *to = *from++;
        case 1: *to = *from++;
    }
    while (--n > 0) {
        *to = *from++;
        *to = *from++;
        *to = *from++;
        *to = *from++;
        *to = *from++;
        *to = *from++;
        *to = *from++;
        *to = *from++;
    }
}

int function() {
    switch(condition-state){
        case state1: {
              statement-1;
              break;
        }
        case state2: {
              statement-2;
              break;
        }
        ... ...
        default: {
              statement-n;
        }
    }
}

int function(void) {
    static int state = 0;
    static int i = 0;
    switch(state){
        case 0: goto LABEL0;
        case 1: goto LABEL1;
        case 2: goto LABEL2;
    }
    LABEL0:
    for(i=0;i<10;++i){
        state = 1;
        return i;
        LABEL1:
        state = 2;
        i+=1;
        return i;
        LABEL2:
        state = 3;
    }
}

int main() {
    int i =function();
    printf("i:%d\n",i);
    i = function();
    printf("i:%d\n",i);
    i = function();
    printf("i:%d\n",i);
    i = function();
    printf("i:%d\n",i);
    i = function();
    printf("i:%d\n",i);
    return 0;
}

[centos ~/test/label_test]$ ./main       
i:0
i:1
i:2
i:3
i:4

#define LC_INIT(s) s = 0;

#define LC_RESUME(s) switch(s) { case 0:

#define LC_SET(s) s = __LINE__; case __LINE__:

#define LC_END(s) }

typedef unsigned short lc_t;
//用于定义一个描述protothread实例的结构体，每一个无栈协程用这个结构体进行描述
struct pt {
  lc_t lc;
};

/**
 初始化一个protothread实例，无栈协程实例，核心就是将指令标签设置为0
 */
#define PT_INIT(pt)   LC_INIT((pt)->lc)

/**
 * 这里用于定义一个protothread实例的接口，name_args是一个包含函数名和形参列表的字符串
 * 且这个接口的返回值得是char型
 */
#define PT_THREAD(name_args) char name_args

/**
 * 用于定义一个protothread的起始执行位置，其实就是在prototype前面套了一个switch
 */
#define PT_BEGIN(pt) { char PT_YIELD_FLAG = 1; LC_RESUME((pt)->lc)

/**
 * 用于界定protothread的终止位置，就是在后面加了一个}，并对结构体进行初始化
 */
#define PT_END(pt) LC_END((pt)->lc); PT_YIELD_FLAG = 0; \
                   PT_INIT(pt); return PT_ENDED; }

/**
 *阻塞直到条件为true，实际应用中返回PT_WAITING表示当前进程阻塞让出执行权，其他表示未被阻塞继续执行
 */
#define PT_WAIT_UNTIL(pt, condition)	        \
  do {						\
    LC_SET((pt)->lc);				\
    if(!(condition)) {				\
      return PT_WAITING;			\
    }						\
  } while(0)

/**
 * 调度一个prototype协程，当返回PT_WAITING，表示调度器阻塞了，让出执行权限给里面的进程
 */
#define PT_SCHEDULE(f) ((f) == PT_WAITING)

/**
 * 让出执行权限，本质上就是在让出位置打一个标签，并直接return，把执行权限交给主调接口
 */
#define PT_YIELD(pt)				\
  do {						\
    PT_YIELD_FLAG = 0;				\
    LC_SET((pt)->lc);				\
    if(PT_YIELD_FLAG == 0) {			\
      return PT_YIELDED;			\
    }						\
  } while(0)

/**
 */
#define PT_YIELD_UNTIL(pt, cond)		\
  do {						\
    PT_YIELD_FLAG = 0;				\
    LC_SET((pt)->lc);				\
    if((PT_YIELD_FLAG == 0) || !(cond)) {	\
      return PT_YIELDED;			\
    }						\
  } while(0)

#include "pt.h"
struct MessageBuffer {
    int change_flag;
    string content;
} g_message_buffer;

typedef struct RoleData {
    int id;
    int step;
    string name;   
    pt  thread_inst_pt;
    int recv_message;
} tagRoleData;

std::map<std::string,RoleData> g_role_set;

void Timer() {
    printf("timer work\n");
    return;
}

MessageBuffer recv_message() {
    MessageBuffer msg = g_message_buffer;
    reset_message();
    return msg;
}

int receive_message(tagRoleData& data) {
    if(data.recv_message > 0) {
        data.recv_message = 0;
        return 1;
    }
    return 0;
}

int process_online_data(tagRoleData& data){
    printf("process online  name[%s] current step[%d]\n",data.name.c_str(),data.step);
    data.step += 1;
    return 0;
}

int process_profile_data(tagRoleData& data){
    printf("process profile  name[%s] current step[%d]\n",data.name.c_str(),data.step);
    data.step += 1;
    return 0;
}

static PT_THREAD(login_thread(tagRoleData& data)) {
    PT_BEGIN(&data.thread_inst_pt);
    while(data.step < 4) {
        PT_WAIT_UNTIL(&data.thread_inst_pt, receive_message(data));
        process_online_data(data);
        PT_WAIT_UNTIL(&data.thread_inst_pt, receive_message(data));
        process_profile_data(data);
    }
    PT_EXIT(&data.thread_inst_pt);
    PT_END(&data.thread_inst_pt);
}

fd_set fds;
struct timeval tv;
static char c[100] = {0};
static PT_THREAD(network_thread(struct pt *pt))
{
    FD_ZERO(&fds);
    FD_SET(0,&fds);
    PT_BEGIN(pt);
    while(1) {
        PT_WAIT_UNTIL(pt,select(1,&fds,NULL,NULL,&tv) > 0);
        read(0,c,100);
        g_message_buffer.content = string(c);
        g_message_buffer.change_flag = 1;
        if (g_role_set.find(g_message_buffer.content) == g_role_set.end()){
            RoleData role_data;
            role_data.step = 0;
            role_data.name = g_message_buffer.content;
            PT_INIT(&role_data.thread_inst_pt);
            g_role_set.insert(std::pair<std::string,RoleData>(g_message_buffer.content,role_data));
        }
        std::map<std::string,RoleData>::iterator role_iter = g_role_set.find(g_message_buffer.content);
        role_iter->second.recv_message = 1;
        PT_SCHEDULE(login_thread(role_iter->second));
    }
    PT_EXIT(pt);
    PT_END(pt);
}

static struct timer codelock_timer, input_timer;
static PT_THREAD(timer_thread(struct pt *pt))
{
    PT_BEGIN(pt);
    timer_set(&input_timer, 1000);
    PT_WAIT_UNTIL(pt, timer_expired(&input_timer));
    PT_EXIT(pt);
    PT_END(pt);
}

static struct pt network_thread_pt;
static struct pt timer_thread_pt;
void Proc() {
    PT_INIT(&network_thread_pt);
    while(PT_SCHEDULE(network_thread(&network_thread_pt))) {
        PT_SCHEDULE(timer_thread(&timer_thread_pt));
        sleep(1);
    } 
}

int main() {
    Proc();
    return 0;
}

switch(Line){
    case 0:{
        state1-1;
        s=Line1-2;
    }
    case Line1-2:{
        if(!cond){
            return;
        }
        state1-3;
        s=Line1-3
    }
    case Line1-3:{
        if(!cond){
            return;
        }
        state1-4;
    }
}

switch(Line){
    case 0:{
        state2-1;
        s=Line2-2;
    }
    case Line2-2:{
        if(!cond){
            return;
        }
        state2-3;
        s=Line2-3
    }
    case Line2-3:{
        if(!cond){
            return;
        }
        state2-4;
    }
}

#include "stdio.h"
void* ptr = NULL;
int Test()
{
    printf("local:%d,global:%d:global2:%d\n",&&test_local,&&test_global,&&test_global2);
    if(NULL == ptr) {
         printf("here\n");
         ptr = &&test_local;
    }
    goto *ptr;
    test_local:
        ptr = &&test_global;
        printf("local test %d\n",ptr);
        return 0;
    test_global:
        ptr = &&test_global2;
        printf("global test\n");
        return 0;
    test_global2:
        ptr = &&test_local;
        printf("global2 test\n");
        return 0;
    return 0;
}
int main()
{
    Test();
    Test();
    Test();
    return 0;
}

local:4196026,global:4196069:global2:4196097
here
local test 4196069
local:4196026,global:4196069:global2:4196097
global test
local:4196026,global:4196069:global2:4196097
global2 test

typedef void * lc_t;

#define LC_CONCAT2(s1, s2) s1##s2
#define LC_CONCAT(s1, s2) LC_CONCAT2(s1, s2)

#define LC_RESUME(s)                            \
  do {                                          \
    if(s != NULL) {                             \
      goto *s;                                  \
    }                                           \
  } while(0)

#define LC_SET(s,label)                         \
  do {                                          \
    LC_CONCAT(label, __LINE__):                 \
    (s) = &&LC_CONCAT(label, __LINE__); \
  } while(0)
//block until 
#define PT_WAIT_UNTIL(pt, label, condition)             \
  do {                                          \
    LC_SET((pt)->lc, label);                            \
    if(!(condition)) {                          \
      return PT_WAITING;                        \
    }                                           \
  } while(0)

static
PT_THREAD(login_thread(tagRoleData& data))
{
    PT_BEGIN(&data.thread_inst_pt);
    while(data.step < 4) {
        PT_WAIT_UNTIL(&data.thread_inst_pt, online_label, receive_message(data));
    online_label:    process_online_data(data);
        PT_WAIT_UNTIL(&data.thread_inst_pt,profile_label, receive_message(data));
    profile_label:    process_profile_data(data);
        PT_WAIT_UNTIL(&data.thread_inst_pt, online_label2, receive_message(data));
    online_label2:    process_online_data(data);
        PT_WAIT_UNTIL(&data.thread_inst_pt, online_label3, receive_message(data));
    online_label3:    process_online_data(data);
    }
    PT_EXIT(&data.thread_inst_pt);
    PT_END(&data.thread_inst_pt);
}

#define LC_SET(s, evt_id) s = evt_id; case evt_id:
#define PT_WAIT_UNTIL(pt, evt_id, condition)            \
  do {                                          \
    LC_SET((pt)->lc, evt_id);                           \
    if(!(condition)) {                          \
      return PT_WAITING;                        \
    }                                           \
  } while(0)

using namespace std;

struct MessageBuffer {
    int change_flag;
    string content;
} g_message_buffer;

typedef struct RoleData {
    int id;
    int step;
    string name;   
    pt  thread_inst_pt;
    int recv_message;
} tagRoleData;

std::map<std::string,RoleData> g_role_set;

int receive_message(tagRoleData& data) {
    if(data.recv_message > 0) {
        data.recv_message = 0;
        return 1;
    }
    return 0;
}

int process_online_data(tagRoleData& data){
    printf("process online  name[%s] current step[%d]\n",data.name.c_str(),data.step);
    data.step += 1;
    return 0;
}

int process_profile_data(tagRoleData& data){
    printf("process profile  name[%s] current step[%d]\n",data.name.c_str(),data.step);
    data.step += 1;
    return 0;
}

#define MSG_ONLINE_RSP 1
#define MSG_PROFILE_RSP 2
#define MSG_ONLINE_RSP_2 3
#define MSG_ONLINE_RSP_3 4
static PT_THREAD(login_thread(tagRoleData& data))
{
    PT_BEGIN(&data.thread_inst_pt);
    while(data.step < 4) {
        PT_WAIT_UNTIL(&data.thread_inst_pt, MSG_ONLINE_RSP, receive_message(data));
        process_online_data(data);
        PT_WAIT_UNTIL(&data.thread_inst_pt, MSG_PROFILE_RSP, receive_message(data));
        process_profile_data(data);
        PT_WAIT_UNTIL(&data.thread_inst_pt, MSG_ONLINE_RSP_2, receive_message(data));
        process_online_data(data);
        PT_WAIT_UNTIL(&data.thread_inst_pt, MSG_ONLINE_RSP_3, receive_message(data));
        process_online_data(data);
    }
    PT_EXIT(&data.thread_inst_pt);
    PT_END(&data.thread_inst_pt);
}


#define NETWORK_EVTID 200
fd_set fds;
struct timeval tv;
static PT_THREAD(network_thread(struct pt *pt))
{
    FD_ZERO(&fds);
    FD_SET(0,&fds);

    PT_BEGIN(pt);
    tv.tv_sec=0;
    tv.tv_usec=0;
    while(1) {
        PT_WAIT_UNTIL(pt, NETWORK_EVTID, select(1,&fds,NULL,NULL,&tv) > 0);
        read(0,d,100);
        memcpy(c,d,strlen(d)-1);
        g_message_buffer.content = string(c);
        g_message_buffer.change_flag = 1;
        if (g_role_set.find(g_message_buffer.content) == g_role_set.end()){
            RoleData role_data;
            role_data.step = 0;
            role_data.name = g_message_buffer.content;
            PT_INIT(&role_data.thread_inst_pt);
            g_role_set.insert(std::pair<std::string,RoleData>(g_message_buffer.content,role_data));
        }
        std::map<std::string,RoleData>::iterator role_iter = g_role_set.find(g_message_buffer.content);
        role_iter->second.recv_message = 1;
        PT_SCHEDULE(login_thread(role_iter->second));
    }
    PT_EXIT(pt);
    PT_END(pt);
}

#define TIMER_EVTID  100 
static PT_THREAD(timer_thread(struct pt *pt))
{
    PT_BEGIN(pt);
    timer_set(&input_timer, 1000);
    PT_WAIT_UNTIL(pt, TIMER_EVTID, timer_expired(&input_timer));
    PT_EXIT(pt);
    PT_END(pt);
}

static struct pt network_thread_pt;
static struct pt timer_thread_pt;
void Proc() {
    PT_INIT(&network_thread_pt);
    while(PT_SCHEDULE(network_thread(&network_thread_pt))) {
        PT_SCHEDULE(timer_thread(&timer_thread_pt));
        sleep(1);
    } 
}

int main() {
    Proc();
    return 0;
}