/*ident	"@(#)C++env:incl-master/const-headers/task.h	1.6" */
/**************************************************************************
			Copyright (c) 1984 AT&T
	  		  All Rights Reserved  	

	THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T
	
	The copyright notice above does not evidence any   	
	actual or intended publication of such source code.

*****************************************************************************/

#ifndef TASKH
#define TASKH

#pragma "ape/libap.a"
#pragma "c++/libC.a"
#pragma "c++/libtask.a"

/*	HEADER FILE FOR THE TASK SYSTEM		*/

#include <stdio.h>
#include "label.h"		/* like setjmp, but really works */

class object;
class sched;	/* : public object */
class timer;	/* : public sched  */
class task;	/* : public sched  */
class qhead;	/* : public object */
class qtail;	/* : public object */
class team;

#if defined(_SHARED_ONLY)
#define	DEFAULT_MODE	SHARED
#else
#define	DEFAULT_MODE	DEDICATED
#endif

/* error codes */
#define task_error_messages						\
macro_start								\
macro(0,E_ERROR,"")							\
macro(1,E_OLINK,"object::delete(): has chain")				\
macro(2,E_ONEXT,"object::delete(): on chain")				\
macro(3,E_GETEMPTY,"qhead::get(): empty")				\
macro(4,E_PUTOBJ,"qtail::put(): object on other queue")			\
macro(5,E_PUTFULL,"qtail::put(): full")					\
macro(6,E_BACKOBJ,"qhead::putback(): object on other queue")		\
macro(7,E_BACKFULL,"qhead::putback(): full")				\
macro(8,E_SETCLOCK,"sched::setclock(): clock!=0")			\
macro(9,E_CLOCKIDLE,"sched::schedule(): clock_task not idle")		\
macro(10,E_RESTERM,"sched::insert(): cannot schedule terminated sched")	\
macro(11,E_RESRUN,"sched::schedule(): running")				\
macro(12,E_NEGTIME,"sched::schedule(): clock<0")			\
macro(13,E_RESOBJ,"sched::schedule(): task or timer on other queue")	\
macro(14,E_HISTO,"histogram::histogram(): bad arguments")		\
macro(15,E_STACK,"task::restore() or task::task(): stack overflow")	\
macro(16,E_STORE,"new: free store exhausted")				\
macro(17,E_TASKMODE,"task::task(): bad mode")				\
macro(18,E_TASKDEL,"task::~task(): not terminated")			\
macro(19,E_TASKPRE,"task::preempt(): not running")			\
macro(20,E_TIMERDEL,"timer::~timer(): not terminated")			\
macro(21,E_SCHTIME,"sched::schedule(): runchain corrupted: bad time")	\
macro(22,E_SCHOBJ,"sched object used directly (not as base)")		\
macro(23,E_QDEL,"queue::~queue(): not empty")				\
macro(24,E_RESULT,"task::result(): thistask->result()")			\
macro(25,E_WAIT,"task::wait(): wait for self")				\
macro(26,E_FUNCS,"FrameLayout::FrameLayout(): function start")		\
macro(27,E_FRAMES,"FrameLayout::FrameLayout(): frame size")		\
macro(28,E_REGMASK,"task::fudge_return(): unexpected register mask")	\
macro(29,E_FUDGE_SIZE,"task::fudge_return(): frame too big")		\
macro(30,E_NO_HNDLR,"sigFunc - no handler for signal")			\
macro(31,E_BADSIG,"illegal signal number")				\
macro(32,E_LOSTHNDLR,"Interrupt_handler::~Interrupt_handler(): signal handler not on chain")			\
macro_end(E_LOSTHNDLR)
#define macro_start
#define macro(num,name,string) const name = num ;
#define macro_end(last_name) const MAXERR = last_name;
task_error_messages
#undef macro_start
#undef macro
#undef macro_end


typedef int (*PFIO)(int,object*);
typedef void (*PFV)();

/* print flags, used as arguments to class print functions */
#define CHAIN		1
#define VERBOSE		2
#define STACK		4

/* DATA STRUCTURES */
/*
	object --> olink --> olink ...
	   |         |         |
	  ...        V         V
	   |        task      task
	   V
	object --> ...
*/

class olink
/*	the building block for chains of task pointers */
{
friend object;
	olink*	l_next;
	task*	l_task;
		olink(task* t, olink* l) { l_task=t; l_next=l; };
};

class object
{
friend sched;
friend task;
public:
	enum objtype { OBJECT, TIMER, TASK, QHEAD, QTAIL, INTHANDLER };
private:
	olink*	o_link;
	static task*	thxstxsk;
public:
	object*	o_next;
	virtual objtype	o_type()	{ return OBJECT; }

		object()	{ o_link=0; o_next=0; }
	virtual	~object();

	void	remember(task*);	// save for alert
	void	forget(task*);	// remove all occurrences of task from chain
	void	alert();	// prepare IDLE tasks for scheduling
	virtual int	pending();  // TRUE if this object should be waited for
	virtual	void	print(int, int =0); // 1st arg VERBOSE, CHAIN, or STACK
	static int	task_error(int, object*);
				// the central error function
	int	task_error(int);	// obsolete; use static version
	static task*	this_task()	{ return thxstxsk; }
	static	PFIO	error_fct;	// user-supplied error function
};

// fake compatibility with previous version
#define thistask (object::this_task())

void _print_error(int);

class sched : public object {	// only instances of subclasses are used
friend timer;
friend task;
friend object;
friend void _print_error(int n);
//friend SIG_FUNC_TYP sigFunc;
public:
	enum statetype { IDLE=1, RUNNING=2, TERMINATED=4 };
private:
	static int	keep_waiting_count;
	static sched*	runchain;    // list of ready-to-run scheds (by s_time)
	static sched*	priority_sched;	// if non-zero, sched to run next
	static	long	clxck;
	static int	exit_status;
	long	s_time;		/* time to sched; result after cancel() */
	statetype	s_state;	/* IDLE, RUNNING, TERMINATED */
	void	schedule();	/* sched clock_task or front of runchain */
	virtual	void	resume();
	void	insert(long,object*); /* sched for long time units, t_alert=obj */
	void	remove();	/* remove from runchain & make IDLE */

protected:
		sched() : s_time(0), s_state(IDLE) {}
public:

	static void	setclock(long);
	static long	get_clock() { return clxck; }
	static sched*	get_run_chain() { return runchain; }
	static int	get_exit_status() { return exit_status; }
	static void	set_exit_status( int i ) { exit_status = i; }
	sched*	get_priority_sched() { return priority_sched; }
	static	task*	clock_task;	// awoken at each clock tick
	long	rdtime()	{ return s_time; };
	statetype	rdstate()	{ return s_state; };
	int	pending()	{ return s_state != TERMINATED; }
	int	keep_waiting()	{ return keep_waiting_count++; }
	int	dont_wait()	{ return keep_waiting_count--; }

	void	cancel(int);
	int	result();
	virtual void	setwho(object* t);  // who alerted me
	void	print(int, int =0);
	static	PFV	exit_fct;	// user-supplied exit function
};
// for compatibility with pre-2.0 releases,
// but conflicts with time.h
//#define clock (sched::get_clock())
inline void	setclock(long i) { sched::setclock(i); }

// for compatibility with pre-2.0 releases
#define run_chain (sched::get_run_chain())

class timer : public sched {
	void	resume();
public:
		timer(long);
		~timer();
	void	reset(long);
	object::objtype	o_type()	{ return TIMER; }
	void	setwho(object*)	{ }  // do nothing
	void	print(int, int =0);
};

/* check stack size if set */
extern _hwm;

class task : public sched {
friend sched;
friend void __task__init();
public:
	enum modetype { DEDICATED=1, SHARED=2 };
private:
	static task*	txsk_chxin;   	// list of all tasks
	static team*	team_to_delete;	// delete this team after task switch
	int	curr_hwm();		// "high water mark"
					//	(how high stack has risen)
	int	swap_stack(int*,int*);	// initialize child stack */
	void	fudge_return(int*);	//used in starting new tasks
	void	copy_share();		// used in starting shared tasks
	void	get_size();		// ditto -- saves size of active stack
	void	resume();
	void	swap(int);
	void	swapjmp();
	void	doswap(task *, int);
	Label	copy_task(Label, unsigned long *, unsigned long *);

	// simple check for stack overflow--not used for main task
	void	settrap();
	void	checktrap();

	/* WARNING: t_framep, th, and t_ap are manipulated as offsets from
	 * task by swap(); those, and t_basep, t_size, and t_savearea are
	 * manipulated as offsets by sswap().
	 * Do not insert new data members before these.
	 */
	Label	t_env;		// stuff needed to restore process
	unsigned long	t_size;	// size of active stack (used for SHARED)
				// holds hwm after cancel()
	long	t_trap;		// used for stack overflow check
	team	*t_team;	// stack and info for sharing
	char	*t_savearea;	// area SHARED stack saved
	char	*t_save;	// area SHARED stack saved

	modetype	t_mode;		/* DEDICATED/SHARED stack */
	int	t_stacksize;

	object*	t_alert;	/* object that inserted you */
protected:
		task(char *name=0, modetype mode=DEFAULT_MODE, int stacksize=0);
public:
		~task();

	object::objtype	o_type()	{ return TASK; }
	task*	t_next;		/* insertion in "task_chain" */
	char*	t_name;

	static task*	get_task_chain() { return txsk_chxin; }
	int	waitvec(object**);
	int	waitlist(object* ...);
	void	wait(object* ob);

	void	delay(long);
	long	preempt();
	void	sleep(object* t =0);	// t is remembered
	void	resultis(int);
	void	cancel(int);
	void	setwho(object* t)	{ t_alert = t; }
	void	print(int, int =0);
	object*	who_alerted_me()	{ return t_alert; }
};
// for compatibility
#define task_chain (task::get_task_chain())

// an Interrupt_handler supplies an interrupt routine that runs when the
// interrupt occurs (real time).  Also the Interrupt_handler can be waited for.
class Interrupt_handler : public object {
friend	class Interrupt_alerter;
//friend SIG_FUNC_TYP sigFunc;
	int	id;		// signal or interrupt number
	int	got_interrupt;  // an interrupt has been received
				// but not alerted
	Interrupt_handler	*old;	// previous handler for this signal
	virtual void	interrupt();	// runs at real time
public:
		Interrupt_handler(int sig_num);
		~Interrupt_handler();
	object::objtype	o_type()	{ return INTHANDLER; }
	int	pending();	// FALSE once after interrupt
};


/* QUEUE MANIPULATION (see queue.c) */
/*
	qhead <--> oqueue <--> qtail   (qhead, qtail independent)
	oqueue ->> circular queue of objects
*/

/* qh_modes */
enum qmodetype { EMODE, WMODE, ZMODE };

class oqueue
{
friend qhead;
friend qtail;
	int	q_max;
	int	q_count;
	object*	q_ptr;
	qhead*	q_head;
	qtail*	q_tail;

		oqueue(int m)	{ q_max=m; q_count=0; q_head=0; q_tail=0; };
		~oqueue()	{ (q_count)?object::task_error(E_QDEL,0):0; };

	void	print(int);
};

class qhead : public object
{
friend qtail;
	qmodetype	qh_mode;	/* EMODE,WMODE,ZMODE */
	oqueue*		qh_queue;
public:
			qhead(qmodetype = WMODE, int = 10000);
			~qhead();

	object::objtype		o_type()	{ return QHEAD; }
	object*		get();
	int		putback(object*);

	int		rdcount()	{ return qh_queue->q_count; }
	int		rdmax()		{ return qh_queue->q_max; }
	qmodetype	rdmode()	{ return qh_mode; }
	qtail*		tail();

	qhead*		cut();
	void		splice(qtail*);

	void		setmode(qmodetype m)	{ qh_mode = m; };
	void		setmax(int m)	{ qh_queue->q_max = m; };
	int		pending()	{ return rdcount() == 0; }
	void		print(int, int =0);
};

class qtail : public object
{
friend qhead;
	qmodetype	qt_mode;
	oqueue*		qt_queue;
public:
			qtail(qmodetype = WMODE, int = 10000);
			~qtail();

	object::objtype		o_type()	{ return QTAIL; }
	int		put(object*);

	int		rdspace()	
			{ return qt_queue->q_max - qt_queue->q_count; };
	int		rdmax()		{ return qt_queue->q_max; };
	qmodetype	rdmode()	{ return qt_mode; };

	qtail*		cut();
	void 		splice(qhead*);

	qhead*		head();

	void		setmode(qmodetype m)	{ qt_mode = m; };
	void		setmax(int m)	{ qt_queue->q_max = m; };
	int		pending()	{ return rdspace() == 0; }

	void		print(int, int =0);
};


struct histogram
/*
	"nbin" bins covering the range [l:r] uniformly
	nbin*binsize == r-l
*/
{
	int	l, r;
	int	binsize;
	int	nbin;
	int*	h;
	long	sum;
	long	sqsum;
		histogram(int=16, int=0, int=16);

	void	add(int);
	void	print();
};

/*	the result of randint() is always >= 0	*/

#define DRAW (randx = randx*1103515245 + 12345)
#define ABS(x)	(x&0x7fffffff)
#define MASK(x) ABS(x)

class randint
/*	uniform distribution in the interval [0,MAXINT_AS_FLOAT] */
{
	long	randx;
public:
		randint(long s = 0)	{ randx=s; }
	void	seed(long s)	{ randx=s; }
	int	draw()		{ return MASK(DRAW); }
	float	fdraw();
};

class urand : public randint
/*	uniform distribution in the interval [low,high]	*/
{
public:
	int	low, high;
		urand(int l, int h)	{ low=l; high=h; }
	int	draw();
};

class erand : public randint
/*	exponential distribution random number generator */
{
public:
	int	mean;
		erand(int m) { mean=m; };
	int	draw();
};

// This task will alert Interrupt_handler objects.
class Interrupt_alerter : public task {
public:
		Interrupt_alerter();
		~Interrupt_alerter() { cancel (0); }
};

extern Interrupt_alerter	interrupt_alerter;

#endif