[unix-history] / usr / contrib / jove / iproc.c

/*************************************************************************
 * This program is copyright (C) 1985, 1986 by Jonathan Payne.  It is    *
 * provided to you without charge for use only on a licensed Unix        *
 * system.  You may copy JOVE provided that this notice is included with *
 * the copy.  You may not sell copies of this program or versions        *
 * modified for use on microcomputer systems, unless the copies are      *
 * included with a Unix system distribution and the source is provided.  *
 *************************************************************************/

#include "jove.h"

#ifdef IPROCS

int	proc_child();

#ifdef PIPEPROCS
#   include "iproc-pipes.c"
#else
#   include "iproc-ptys.c"
#endif

KillProcs()
{
	register Process	*p;
	int	killem = -1;		/* -1 means undetermined */
	char	*yorn;

	for (p = procs; p != 0; p = p->p_next)
		if (!isdead(p)) {
			if (killem == -1) {
				yorn = ask("y", "Should I kill your i-processes? ");
				killem = (Upper(*yorn) == 'Y');
			}
			if (killem)
				proc_kill(p, SIGKILL);
		}
}

static Process *
proc_exists(name)
char	*name;
{
	register Process	*p;

	for (p = procs; p != 0; p = p->p_next)
		if (strcmp(proc_buf(p), name) == 0) {
			(void) pstate(p);
			if (p->p_eof) {
				DealWDeath();
				return 0;
			}
			break;
		}

	return p;
}

assign_p()
{
	register Process	*p;

	for (p = procs; p != 0; p = p->p_next)
		if (p->p_buffer == curbuf) {
			cur_proc = p;
			break;
		}
}

pbuftiedp(b)
Buffer	*b;
{
	register Process	*p;

	for (p = procs; p != 0; p = p->p_next)
		if (p->p_buffer == b && !p->p_eof)
			complain("[There is a process tied to %s]", proc_buf(p));
}

/* Process receive: receives the characters in buf, and appends them to
   the buffer associated with p. */

static
proc_rec(p, buf)
register Process	*p;
char	*buf;
{
	Buffer	*saveb = curbuf;
	Window	*w;
	Mark	*savepoint;
	int	sameplace = 0,
		do_disp = 0;

	if (curwind->w_bufp == p->p_buffer)
		w = curwind;
	else
		w = windbp(p->p_buffer);	/* Is this window visible? */
	if (w != 0)
		do_disp = (in_window(w, p->p_mark->m_line) != -1);
	SetBuf(p->p_buffer);
	savepoint = MakeMark(curline, curchar, FLOATER);
	ToMark(p->p_mark);	/* Where output last stopped. */
	if (savepoint->m_line == curline && savepoint->m_char == curchar)
		sameplace++;

	ins_str(buf, YES);
	if (do_disp) {
		w->w_line = curline;
		w->w_char = curchar;
		redisplay();
	}
	MarkSet(p->p_mark, curline, curchar);
	if (!sameplace)
		ToMark(savepoint);	/* Back to where we were. */
	DelMark(savepoint);
	SetBuf(saveb);
}

proc_kill(p, sig)
Process	*p;
{
	if (p == 0 || p->p_state == DEAD)
		return;
	if (killpg(p->p_pid, sig) == -1)
		s_mess("Cannot kill %s!", proc_buf(p));
}

/* Deal with a process' death.  proc_rec turns on the FREEUP bit when it
   it gets the "EOF" from portsrv.  FREEUP'd processes get unlinked from
   the list, and the proc stucture and proc_buf(p) get free'd up, here. */

static
DealWDeath()
{
	register Process	*p,
				*next,
				*prev = 0;
	
	for (p = procs; p != 0; p = next) {
		next = p->p_next;
		if (!p->p_eof) {
			prev = p;
			continue;
		}
		if (cur_proc == p)
			cur_proc = next ? next : prev;
		proc_close(p);
		free((char *) p->p_name);
		free((char *) p);
		if (prev)
			prev->p_next = next;
		else
			procs = next;
	}
}

ProcList()
{
	register Process	*p;
	char	*fmt = "%-15s  %-15s  %-8s %s",
		pidstr[10];

	if (procs == 0) {
		message("[No subprocesses]");
		return;
	}
	TOstart("Process list", TRUE);

	Typeout(fmt, "Buffer", "Status", "Pid ", "Command");
	Typeout(fmt, "------", "------", "--- ", "-------");
	for (p = procs; p != 0; p = p->p_next) {
		sprintf(pidstr, "%d", p->p_pid);
		Typeout(fmt, proc_buf(p), pstate(p), pidstr, p->p_name);
	}
	DealWDeath();
	TOstop();
}

ProcNewline()
{
	if (isdead(cur_proc))
		return;
	if (lastp(curline)) {
		Eol();
		LineInsert();
		do_rtp(cur_proc->p_mark);
		MarkSet(cur_proc->p_mark, curline, curchar);
	} else {
		Bol();
		while (LookingAt(proc_prompt, linebuf, curchar))
			SetDot(dosearch(proc_prompt, 1, 1));
		strcpy(genbuf, linebuf + curchar);
		ToLast();
		ins_str(genbuf, NO);
	}
}

IShell()
{
	char	shell[30];
	int	number = 1;

	do
		sprintf(shell, "shell-%d", number++);
	while (proc_exists(shell));

	proc_strt(shell, "i-shell", Shell, basename(Shell), "-i", 0);
	SetWind(windlook(shell));
}

Iprocess()
{
	extern char	ShcomBuf[100],
			*MakeName();
	char	*command;

	command = ask(ShcomBuf, ProcFmt);
	null_ncpy(ShcomBuf, command, (sizeof ShcomBuf) - 1);
	proc_strt(MakeName(command), command, Shell, basename(Shell), ShFlags, command, 0);
}

proc_child()
{
	union wait	w;
	int	pid;

	for (;;) {
#ifndef VMUNIX
		pid = wait2(&w.w_status, (WNOHANG | WUNTRACED));
#else
		pid = wait3(&w, (WNOHANG | WUNTRACED), (struct rusage *) 0);
#endif
		if (pid <= 0)
			break;
		kill_off(pid, w);
	}
}

kill_off(pid, w)
int	pid;
union wait	w;
{
	Process	*child;

	if ((child = proc_pid(pid)) == 0)
		return;

	if (WIFSTOPPED(w))
		child->p_state = STOPPED;
	else {
		child->p_state = DEAD;
		if (WIFEXITED(w))
			child->p_howdied = EXITED;
		else if (WIFSIGNALED(w)) {
			child->p_reason = w.w_termsig;
			child->p_howdied = KILLED;
		}
		proc_close(child);
	}
	s_mess("%s [%s]    %s", pstate(child), proc_buf(child), proc_cmd(child));
}

/* Push/pod process bindings.  I openly acknowledge that this is a
   kludge, but I can't be bothered making it right. */

struct proc_bind {
	int		pb_key;
	data_obj	**pb_map;
	data_obj	*pb_push;
	data_obj	*pb_cmd;
	struct proc_bind *pb_next;
};

struct proc_bind *PBinds = 0;

PopPBs()
{
	register struct proc_bind *p;

	for (p = PBinds; p != 0; p = p->pb_next)
		p->pb_map[p->pb_key] = p->pb_push;
}

PushPBs()
{
	register struct proc_bind *p;

	for (p = PBinds; p != 0; p = p->pb_next) {
		p->pb_push = p->pb_map[p->pb_key];
		p->pb_map[p->pb_key] = p->pb_cmd;
	}
}
/* VARARGS0 */

ProcBind()
{
	data_obj	*d;

	if ((d = findcom(ProcFmt, NOTHING)) == 0)
		return;
	s_mess(": %f %s ", d->Name);
	ProcB2(mainmap, EOF, d);
}

ProcB2(map, lastkey, cmd)
data_obj	**map,
		*cmd;
{
	register struct proc_bind *p;
	data_obj	**nextmap;
	int	c;

	c = addgetc();
	if (c == EOF) {
		if (lastkey == EOF)
			complain("[Empty key sequence]");
		complain("[Unexpected end-of-line]");
	} else {
		if (nextmap = IsPrefix(map[c]))
			ProcB2(nextmap, c, cmd);
		else {
			if (curbuf->b_type == B_IPROCESS)
				PopPBs();

			for (p = PBinds; p != 0; p = p->pb_next)
				if (p->pb_key == c && p->pb_map == map)
					break;
			if (p == 0) {
				p = (struct proc_bind *) emalloc(sizeof *p);
				p->pb_next = PBinds;
				PBinds = p;
			}
			p->pb_map = map;
			p->pb_key = c;
			p->pb_cmd = cmd;

			if (curbuf->b_type == B_IPROCESS)
				PushPBs();
		}
	}
}

#endif IPROCS
Commit	Line	Data
394a1d25 C	1	/*************************************************************************
	2	* This program is copyright (C) 1985, 1986 by Jonathan Payne. It is *
	3	* provided to you without charge for use only on a licensed Unix *
	4	* system. You may copy JOVE provided that this notice is included with *
	5	* the copy. You may not sell copies of this program or versions *
	6	* modified for use on microcomputer systems, unless the copies are *
	7	* included with a Unix system distribution and the source is provided. *
	8	*************************************************************************/
	9
	10	#include "jove.h"
	11
	12	#ifdef IPROCS
	13
	14	int proc_child();
	15
	16	#ifdef PIPEPROCS
	17	# include "iproc-pipes.c"
	18	#else
	19	# include "iproc-ptys.c"
	20	#endif
	21
	22	KillProcs()
	23	{
	24	register Process *p;
	25	int killem = -1; /* -1 means undetermined */
	26	char *yorn;
	27
	28	for (p = procs; p != 0; p = p->p_next)
	29	if (!isdead(p)) {
	30	if (killem == -1) {
	31	yorn = ask("y", "Should I kill your i-processes? ");
	32	killem = (Upper(*yorn) == 'Y');
	33	}
	34	if (killem)
	35	proc_kill(p, SIGKILL);
	36	}
	37	}
	38
	39	static Process *
	40	proc_exists(name)
	41	char *name;
	42	{
	43	register Process *p;
	44
	45	for (p = procs; p != 0; p = p->p_next)
	46	if (strcmp(proc_buf(p), name) == 0) {
	47	(void) pstate(p);
	48	if (p->p_eof) {
	49	DealWDeath();
	50	return 0;
	51	}
	52	break;
	53	}
	54
	55	return p;
	56	}
	57
	58	assign_p()
	59	{
	60	register Process *p;
	61
	62	for (p = procs; p != 0; p = p->p_next)
	63	if (p->p_buffer == curbuf) {
	64	cur_proc = p;
65	break;
66	}
67	}
68
69	pbuftiedp(b)
70	Buffer *b;
71	{
72	register Process *p;
73
74	for (p = procs; p != 0; p = p->p_next)
75	if (p->p_buffer == b && !p->p_eof)
76	complain("[There is a process tied to %s]", proc_buf(p));
77	}
78
79	/* Process receive: receives the characters in buf, and appends them to
80	the buffer associated with p. */
81
82	static
83	proc_rec(p, buf)
84	register Process *p;
85	char *buf;
86	{
87	Buffer *saveb = curbuf;
88	Window *w;
89	Mark *savepoint;
90	int sameplace = 0,
91	do_disp = 0;
92
93	if (curwind->w_bufp == p->p_buffer)
94	w = curwind;
95	else
96	w = windbp(p->p_buffer); /* Is this window visible? */
97	if (w != 0)
98	do_disp = (in_window(w, p->p_mark->m_line) != -1);
99	SetBuf(p->p_buffer);
100	savepoint = MakeMark(curline, curchar, FLOATER);
101	ToMark(p->p_mark); /* Where output last stopped. */
102	if (savepoint->m_line == curline && savepoint->m_char == curchar)
103	sameplace++;
104
105	ins_str(buf, YES);
106	if (do_disp) {
107	w->w_line = curline;
108	w->w_char = curchar;
109	redisplay();
110	}
111	MarkSet(p->p_mark, curline, curchar);
112	if (!sameplace)
113	ToMark(savepoint); /* Back to where we were. */
114	DelMark(savepoint);
115	SetBuf(saveb);
116	}
117
118	proc_kill(p, sig)
119	Process *p;
120	{
121	if (p == 0 \|\| p->p_state == DEAD)
122	return;
123	if (killpg(p->p_pid, sig) == -1)
124	s_mess("Cannot kill %s!", proc_buf(p));
125	}
126
127	/* Deal with a process' death. proc_rec turns on the FREEUP bit when it
128	it gets the "EOF" from portsrv. FREEUP'd processes get unlinked from
129	the list, and the proc stucture and proc_buf(p) get free'd up, here. */
130
131	static
132	DealWDeath()
133	{
134	register Process *p,
135	*next,
136	*prev = 0;
137
138	for (p = procs; p != 0; p = next) {
139	next = p->p_next;
140	if (!p->p_eof) {
141	prev = p;
142	continue;
143	}
144	if (cur_proc == p)
145	cur_proc = next ? next : prev;
146	proc_close(p);
147	free((char *) p->p_name);
148	free((char *) p);
149	if (prev)
150	prev->p_next = next;
151	else
152	procs = next;
153	}
154	}
155
156	ProcList()
157	{
158	register Process *p;
159	char *fmt = "%-15s %-15s %-8s %s",
160	pidstr[10];
161
162	if (procs == 0) {
163	message("[No subprocesses]");
164	return;
165	}
166	TOstart("Process list", TRUE);
167
168	Typeout(fmt, "Buffer", "Status", "Pid ", "Command");
169	Typeout(fmt, "------", "------", "--- ", "-------");
170	for (p = procs; p != 0; p = p->p_next) {
171	sprintf(pidstr, "%d", p->p_pid);
172	Typeout(fmt, proc_buf(p), pstate(p), pidstr, p->p_name);
173	}
174	DealWDeath();
175	TOstop();
176	}
177
178	ProcNewline()
179	{
180	if (isdead(cur_proc))
181	return;
182	if (lastp(curline)) {
183	Eol();
184	LineInsert();
185	do_rtp(cur_proc->p_mark);
186	MarkSet(cur_proc->p_mark, curline, curchar);
187	} else {
188	Bol();
189	while (LookingAt(proc_prompt, linebuf, curchar))
190	SetDot(dosearch(proc_prompt, 1, 1));
191	strcpy(genbuf, linebuf + curchar);
192	ToLast();
193	ins_str(genbuf, NO);
194	}
195	}
196
197	IShell()
198	{
199	char shell[30];
200	int number = 1;
201
202	do
203	sprintf(shell, "shell-%d", number++);
204	while (proc_exists(shell));
205
206	proc_strt(shell, "i-shell", Shell, basename(Shell), "-i", 0);
207	SetWind(windlook(shell));
208	}
209
210	Iprocess()
211	{
212	extern char ShcomBuf[100],
213	*MakeName();
214	char *command;
215
216	command = ask(ShcomBuf, ProcFmt);
217	null_ncpy(ShcomBuf, command, (sizeof ShcomBuf) - 1);
218	proc_strt(MakeName(command), command, Shell, basename(Shell), ShFlags, command, 0);
219	}
220
221	proc_child()
222	{
223	union wait w;
224	int pid;
225
226	for (;;) {
227	#ifndef VMUNIX
228	pid = wait2(&w.w_status, (WNOHANG \| WUNTRACED));
229	#else
230	pid = wait3(&w, (WNOHANG \| WUNTRACED), (struct rusage *) 0);
231	#endif
232	if (pid <= 0)
233	break;
234	kill_off(pid, w);
235	}
236	}
237
238	kill_off(pid, w)
239	int pid;
240	union wait w;
241	{
242	Process *child;
243
244	if ((child = proc_pid(pid)) == 0)
245	return;
246
247	if (WIFSTOPPED(w))
248	child->p_state = STOPPED;
249	else {
250	child->p_state = DEAD;
251	if (WIFEXITED(w))
252	child->p_howdied = EXITED;
253	else if (WIFSIGNALED(w)) {
254	child->p_reason = w.w_termsig;
255	child->p_howdied = KILLED;
256	}
257	proc_close(child);
258	}
259	s_mess("%s [%s] %s", pstate(child), proc_buf(child), proc_cmd(child));
260	}
261
262	/* Push/pod process bindings. I openly acknowledge that this is a
263	kludge, but I can't be bothered making it right. */
264
265	struct proc_bind {
266	int pb_key;
267	data_obj **pb_map;
268	data_obj *pb_push;
269	data_obj *pb_cmd;
270	struct proc_bind *pb_next;
271	};
272
273	struct proc_bind *PBinds = 0;
274
275	PopPBs()
276	{
277	register struct proc_bind *p;
278
279	for (p = PBinds; p != 0; p = p->pb_next)
280	p->pb_map[p->pb_key] = p->pb_push;
281	}
282
283	PushPBs()
284	{
285	register struct proc_bind *p;
286
287	for (p = PBinds; p != 0; p = p->pb_next) {
288	p->pb_push = p->pb_map[p->pb_key];
289	p->pb_map[p->pb_key] = p->pb_cmd;
290	}
291	}
292	/* VARARGS0 */
293
294	ProcBind()
295	{
296	data_obj *d;
297
298	if ((d = findcom(ProcFmt, NOTHING)) == 0)
299	return;
300	s_mess(": %f %s ", d->Name);
301	ProcB2(mainmap, EOF, d);
302	}
303
304	ProcB2(map, lastkey, cmd)
305	data_obj **map,
306	*cmd;
307	{
308	register struct proc_bind *p;
309	data_obj **nextmap;
310	int c;
311
312	c = addgetc();
313	if (c == EOF) {
314	if (lastkey == EOF)
315	complain("[Empty key sequence]");
316	complain("[Unexpected end-of-line]");
317	} else {
318	if (nextmap = IsPrefix(map[c]))
319	ProcB2(nextmap, c, cmd);
320	else {
321	if (curbuf->b_type == B_IPROCESS)
322	PopPBs();
323
324	for (p = PBinds; p != 0; p = p->pb_next)
325	if (p->pb_key == c && p->pb_map == map)
326	break;
327	if (p == 0) {
328	p = (struct proc_bind ) emalloc(sizeof p);
329	p->pb_next = PBinds;
330	PBinds = p;
331	}
332	p->pb_map = map;
333	p->pb_key = c;
334	p->pb_cmd = cmd;
335
336	if (curbuf->b_type == B_IPROCESS)
337	PushPBs();
338	}
339	}
340	}
341
342	#endif IPROCS