#include	<stdio.h>
#include	<libraries/dos.h>
#include	<libraries/dosextens.h>
#include	<exec/memory.h>
#include	<exec/tasks.h>

/*
 * P S :	Like the UN*X command of the same name, this reports on
 *		running processes in the system. The current version only
 *		reports CLI processes, so you don't see the filesystem
 *		tasks. Written because I got tired of seeing the question
 *		marks that status spits out at every opportunity.
 *		This will build OK with 16 bit integers.
 *
 * Usage:	ps [-f]
 *
 * Author:	Dewi Williams ..!ihnp4!druca!dewi
 * Status:	Public domain.
 */
 
/* Defines */

/* Change typeless BCPL BPTR to typed C (for struct pointers). Don't
 * use this define on an APTR, that's only a badly disguised void *.
 */
#define	BPTR_TO_C(strtag, var)  ((struct strtag *)(BADDR( (ULONG) var)))

/* Use AmigaDOS i/o to keep executable size down */
#define WSTR(s)		(void)Write(OutLock, s, (long)strlen(s))
#define WCHR(s)		(void)Write(OutLock, s, 1L)	/* char w/ d. quotes */

#define TO_ASC(n)	((n) + '0')		/* make it printable! */

/* Casting conveniences */
#define	PROC(task)		((struct Process *)task)
#define ROOTNODE		((struct RootNode *)DOSBase->dl_Root)
#define CLI(proc)		(BPTR_TO_C(CommandLineInterface, proc->pr_CLI))

/* Externs */
extern struct DosLibrary *DOSBase;	/* dos library base pointer */
extern struct FileLock	 *Output();	/* get output file handle */

/* Globals */
static struct FileLock	 *OutLock;	/* used by WSTR define */
static int		 fullopt = 0;	/* set by -f command line flag */

main(argc, argv)
int	argc;
char	**argv;
{
	register ULONG	 *tt;		/* References TaskArray  	*/
	register int	 count;		/* loop variable 	 	*/
	register UBYTE	 *port;		/* msgport & ptr arith   	*/
	register struct Task *task;	/* EXEC descriptor	 	*/
	char		 strbuf[256];	/* scratch for btocstr() 	*/
	char		 *btocstr();	/* BCPL BSTR to ASCIIZ   	*/
	void		 disp_hdr();	/* display ps header	 	*/
	void		 display();	/* display data for one process */

	OutLock = Output();		/* initialize output handle 	*/

	if (argc > 1 && strcmp(argv[1], "-f") == 0) fullopt = 1;

	tt = (unsigned long *)(BADDR(ROOTNODE->rn_TaskArray));

	if (fullopt) disp_hdr();

	Forbid();		/* need linked list consistency */
	
	/* Loop through the data for the CLI processes. */
	for (count = 1; count <= (int)tt[0] ; count++) {/* or just assume 20?*/
		if (tt[count] == 0) continue;		/* nobody home */

		/* Start by pulling out MsgPort addresses from the TaskArray
		 * area. By making unwarranted assumptions about the layout
		 * of Process and Task structures, we can derive these
		 * descriptors. Every task has an associated process, since
		 * this loop drives off a CLI data area.
		 */

		port = (UBYTE *)tt[count];
		task = (struct Task *)(port - sizeof(struct Task));

		/* Sanity check just in case */
		if (PROC(task)->pr_TaskNum == 0 || PROC(task)->pr_CLI == NULL)
			continue;		/* or complain? */

		/* Pass the C string version of the command name to
		 * the display routine.
		 */
		display(count, task->tc_Node.ln_Name,
			btocstr(CLI(PROC(task))->cli_CommandName, strbuf), 
			task->tc_Node.ln_Pri);
	}
	Permit();		/* outside critical region */
	exit(0);
}

/*
 * Convert a BCPL string to a C string. To avoid scrogging in-memory
 * stuff, it copies it first. Your data area better be big enough!
 */

char *
btocstr(b, buf)
ULONG	b;
char	*buf;
{
	register char	*s;

	s = (char *)BADDR(b);	/* Shift & get length-prefixed str */
	(void)movmem(s +1, buf, s[0]);	/* a.k.a memcpy */
	buf[s[0]] = '\0';
	return buf;
}

/*
 * Display the header for the output.
 */

void 
disp_hdr()
{
	WSTR("Process #  CLI Type         Command Name         Priority\n");
}

/*
 * Display the information for a particular CLI process. Keep the format
 * string in sync with that of disp_hdr().
 */

void  
display(tnum, type, name, pri)
int	tnum;		/* CLI process number */
char	*type;		/* Initial, Background or New CLI */
char	*name;		/* Command name if CLI's running one */
int	pri;		/* priority of CLI & command */
{
	char 		*psitoa();
	char 		buf[80];
	char		*ext_len();
	register char	*p = buf;

	if (*name == '\0') name = "<Cli>";	/* Null, nothing loaded */

	if (fullopt) {
		p = ext_len(psitoa(tnum, p), 11);
		strcpy(p, type);
		p = ext_len(p, 17);
		strcpy(p, name);
		p = ext_len(p, 21);
		(void)psitoa(pri, p);
	} else {
		p = ext_len(psitoa(tnum, p), 2);
		*p++ = ':';
		*p++ = ' ';
		strcpy(p, name);
	}

	WSTR(buf);	
	WCHR("\n");
}

/*
 * Everything after here is a hack to avoid dragging in printf.
 * ------------------------------------------------------------
 */
 
/*
 * Limited itoa style function. Don't use it anywhere else! Used to keep
 * things small & avoid printf. Has a very limited range (3 digits +/- sign).
 * This hack avoids having to do the recursion & reverse of K&R itoa.
 */
 
char *
psitoa(num, into)
int	num;				/* number to convert  */
char	*into;				/* write it into here */
{
	register char	*p = into;
	
	if (num < 0) {
		*p++ = '-';
		num = -num;
	}
	if (num > 99) {
		*p++ = TO_ASC(num/100);
		*p++ = TO_ASC((num%100)/10);
		*p++ = TO_ASC(num%10);
	} else if (num > 9) {
		*p++ = TO_ASC(num/10);
		*p++ = TO_ASC(num%10);
	} else
		*p++ = TO_ASC(num);

	*p = '\0';			/* end of the string */
	return into;
}

/*
 * Extend to length. Assumes strlen(s) never greater than len.
 */

char *
ext_len(s, len)
char	*s;			/* must be large enough for extension to len */
int	len;
{
	register int	leftover;
	register int	slen = strlen(s);
	register char	*p = s + slen;	
	
	for(leftover = len - slen; leftover > 0; leftover--)
		*p++ = ' ';

	*p = '\0';		/* null terminate */
	return p;		/* return loc after string */
}