#include "h/const.h"
#include "h/types.h"
#include "e/libumps.e"

HIDDEN pcb_t *pcbFree_h;

void initPcbs();
void freePcb(pcb_t *p);
pcb_t *allocPcb();
pcb_t *mkEmptyProcQ();
int emptyProcQ(pcb_t *tp);
void insertProcQ(pcb_t **tp, pcb_t *p);
pcb_t *removeProcQ(pcb_t **tp);
pcb_t *outProcQ(pcb_t **tp, pcb_t *p);
pcb_t *headProcQ(pcb_t *tp);
void test();
int emptyChild(pcb_t *p);
void insertChild(pcb_t *prnt, pcb_t *p);
pcb_t *removeChild(pcb_t *p);
pcb_t *outChild(pcb_t *p);


void initPcbs() {
	int i = 0;
	static pcb_t pcbTable[MAXPROC];

	pcbFree_h = NULL;

	for (i = 0; i < MAXPROC; i++)
		freePcb(&pcbTable[i]); 	
}

void freePcb(pcb_t *p) { 
	p->p_next = pcbFree_h;
	pcbFree_h = p;	
}

pcb_t *allocPcb() {
	pcb_t *a = NULL;
	int i = 0;
	
	if (pcbFree_h != NULL) {
		a = pcbFree_h;
		pcbFree_h = pcbFree_h->p_next;
	
		a->p_next = NULL;
		a->p_prnt = NULL;
		a->p_child = NULL;
		a->p_sib = NULL;
		a->p_s.s_asid = 0;
		a->p_s.s_cause = 0;
		a->p_s.s_status = 0;
		a->p_s.s_pc = 0;
		for (i = 0; i < STATEREGNUM; i++) 
			a->p_s.s_reg[i] = 0;
		a->p_semAdd = NULL;	
	}
	
	return a; 
}

pcb_t *mkEmptyProcQ() {
	pcb_t *tail = NULL;
	return tail; 
}

int emptyProcQ(pcb_t *tp) {
	if (tp == NULL)
		return TRUE;
	else
		return FALSE;
}

void insertProcQ(pcb_t **tp, pcb_t *p) {
	if (emptyProcQ(*tp)) {
		p->p_next = p;
		*tp = p;
	}
	else {
		p->p_next = (*tp)->p_next;
		(*tp)->p_next = p;
		*tp = p;
	}
}

pcb_t *removeProcQ(pcb_t **tp) {
	pcb_t *rem = NULL;		

	if (emptyProcQ(*tp)) 
		return NULL;
	else {
		rem = (*tp)->p_next;

		if (rem == *tp) 
			*tp = NULL;
		else 
			(*tp)->p_next = rem->p_next;						
		
		return rem;
	}
}

pcb_t *outProcQ(pcb_t **tp, pcb_t *p) {
	pcb_t *proc = NULL;
	pcb_t *prev = NULL;		

	if (emptyProcQ(*tp)) 
		return NULL;
	else {
		prev = *tp;
		proc = (*tp)->p_next;
		
		while ((proc != *tp) && (proc != p)) {	
			prev = proc;	
			proc = proc->p_next;						
		}
		
		if (proc == p) {
			if ((proc == *tp) && (prev == proc))
				*tp = NULL;
			else 				
				prev->p_next = proc->p_next;

			return p;
		}
		else
			return NULL;
	}	
}

pcb_t *headProcQ(pcb_t *tp) {	
	if (emptyProcQ(tp)) 
		return NULL;
	else 
		return (tp)->p_next;	
}

int emptyChild(pcb_t *p) {
	if (p->p_child == NULL)
		return TRUE;
	else 
		return FALSE;
}

void insertChild(pcb_t *prnt, pcb_t *p) {
	p->p_sib = prnt->p_child;
	prnt->p_child = p;
	p->p_prnt = prnt;
}

pcb_t *removeChild(pcb_t *p) {
	pcb_t *ret = NULL;

	if (emptyChild(p))
		return NULL;
	else {
		ret = p->p_child;
		p->p_child = ret->p_sib;
		ret->p_sib = NULL;
		ret->p_prnt = NULL;
		return ret; 
	}		
}

pcb_t *outChild(pcb_t *p) {
	pcb_t *curr = NULL;
	
	if (p->p_prnt == NULL)
		return NULL;
	else {
		/* go thru list to find which sib needs to be replaced. */

		curr = (p->p_prnt)->p_child;

		/* there is only one child	 */
		if (curr == p) {
			(p->p_prnt)->p_child = NULL;
			p->p_sib = NULL;
			p->p_prnt = NULL;
			return p;
		}
			
		while (p != curr->p_sib)
			curr = curr->p_sib;
		
		curr->p_sib = p->p_sib;
		p->p_sib = NULL;
		p->p_prnt = NULL;			
		return p;			
	}
}