[unix-history] / usr / src / new / jove / iproc.c

/***************************************************************************
 * This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne.  JOVE *
 * is provided to you without charge, and with no warranty.  You may give  *
 * away copies of JOVE, including sources, provided that this notice is    *
 * included in all the files.                                              *
 ***************************************************************************/

#include "jove.h"
#include "re.h"
#include <varargs.h>

#ifdef IPROCS

int	proc_child();

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

char	proc_prompt[128] = "% ";

KillProcs()
{
	register Process	*p;
	register int	killem = -1;		/* -1 means undetermined */
	register 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 = (CharUpcase(*yorn) == 'Y');
			}
			if (killem)
				proc_kill(p, SIGKILL);
		}
}

pbuftiedp(b)
register Buffer	*b;
{
	register Process	*p = b->b_process;

	if (!isdead(p))
		complain("Process %s, attached to %b, is %s.",
			 proc_cmd(p), b, pstate(p));
}

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

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

	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, M_FLOATER);
	ToMark(p->p_mark);		/* where output last stopped */
	if (savepoint->m_line == curline && savepoint->m_char == curchar)
		sameplace = YES;

	ins_str(buf, YES);
	MarkSet(p->p_mark, curline, curchar);
	if (!sameplace)
		ToMark(savepoint);	/* back to where we were */
	DelMark(savepoint);
	/* redisplay now, instead of right after the ins_str, so that
	   we don't get a bouncing effect if point is not the same as
	   the process output position */
	if (do_disp) {
		w->w_line = curline;
		w->w_char = curchar;
		redisplay();
	}
	SetBuf(saveb);
}

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

/* Free process CHILD.  Do all the necessary cleaning up (closing fd's,
   etc.). */

free_proc(child)
Process	*child;
{
	register Process	*p,
				*prev = 0;

	if (!isdead(child))
		return;	
	for (p = procs; p != child; prev = p, p = p->p_next)
		;
	if (prev == 0)
		procs = child->p_next;
	else
		prev->p_next = child->p_next;
	proc_close(child);		/* if not already closed */
	
	/* It's possible that the buffer has been given another process
	   between the time CHILD dies and CHILD's death is noticed (via
	   list-processes).  So we only set it the buffer's process to
	   0 if CHILD is still the controlling process. */
	if (child->p_buffer->b_process == child) {
		child->p_buffer->b_process = 0;
		if (curbuf == child->p_buffer)
			PopPBs();
	}
	{
		Buffer	*old = curbuf;

		SetBuf(child->p_buffer);
		DelMark(child->p_mark);
		SetBuf(old);
	}
	free((char *) child->p_name);
	free((char *) child);
}

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

	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 = next) {
		next = p->p_next;
		sprintf(pidstr, "%d", p->p_pid);
		Typeout(fmt, proc_buf(p), pstate(p), pidstr, p->p_name);
		if (isdead(p)) {
			free_proc(p);
			UpdModLine = YES;
		}
	}
	TOstop();
}

ProcNewline()
{
#ifdef ABBREV
	MaybeAbbrevExpand();
#endif
	SendData(YES);
}

ProcSendData()
{
#ifdef ABBREV
	MaybeAbbrevExpand();
#endif
	SendData(NO);
}

private
SendData(newlinep)
{
	register Process	*p = curbuf->b_process;
	register char	*lp,
			*gp;	/* JF fix for better prompt handling */

	if (isdead(p))
		return;
	/* If the process mark was involved in a big deletion, because
	   the user hit ^W or something, then let's do some magic with
	   the process mark.  Problem is that if the user yanks back the
	   text he deleted, the mark stays at the beginning of the region,
	   and so the next time SendData() is called the entire region
	   will be sent.  That's not good.  So, to deal with that we reset
	   the mark to the last line, after skipping over the prompt, etc. */
	if (p->p_mark->m_flags & M_BIG_DELETE) {
		Bufpos	bp;

		p->p_mark->m_flags &= ~M_BIG_DELETE;

		DOTsave(&bp);
		ToLast();
		Bol();
		/* While we're looking at a prompt, and while we're
		   moving forward.  This is for people who accidently
		   set their process-prompt to ">*" which will always
		   match! */
		while ((LookingAt(proc_prompt, linebuf, curchar)) &&
 		       (REeom > curchar))
			curchar = REeom;
		MarkSet(p->p_mark, curline, curchar);
		SetDot(&bp);
	}

	if (lastp(curline)) {
		Eol();
		if (newlinep)
			LineInsert(1);
		do_rtp(p->p_mark);
		MarkSet(p->p_mark, curline, curchar);
	} else {
		/* Either we're looking at a prompt, or we're not, in
		   which case we want to strip off the beginning of the
		   line anything that looks like what the prompt at the
		   end of the file is.  In other words, if "(dbx) stop in
		   ProcessNewline" is the line we're on, and the last
		   line in the buffer is "(dbx) ", then we strip off the
		   leading "(dbx) " from this line, because we know it's
		   part of the prompt.  But this only happens if "(dbx) "
		   isn't one of the process prompts ... follow what I'm
		   saying? */
		Bol();
		if (LookingAt(proc_prompt, linebuf, curchar)) {
			do
				curchar = REeom;
			while ((LookingAt(proc_prompt, linebuf, curchar)) &&
			       (REeom > curchar));
			strcpy(genbuf, linebuf + curchar);
			Eof();
			ins_str(genbuf, NO);
		} else {
			strcpy(genbuf, linebuf + curchar);
			Eof();
			gp = genbuf;
			lp = linebuf;
			while (*lp == *gp && *lp != '\0') {
				lp += 1;
				gp += 1;
			}
			ins_str(gp, NO);
		}
	}
}

ShellProc()
{
	char	*shbuf = "*shell*";
	register Buffer	*b;

	b = buf_exists(shbuf);
	if (b == 0 || isdead(b->b_process))
		proc_strt(shbuf, NO, Shell, "-i", (char *) 0);
	pop_wind(shbuf, NO, -1);
}

Iprocess()
{
	extern char	ShcomBuf[100],
			*MakeName();
	register char	*command;
	char	scratch[64],
		*bufname;
	int	cnt = 1;
	Buffer	*bp;

	command = ask(ShcomBuf, ProcFmt);
	null_ncpy(ShcomBuf, command, (sizeof ShcomBuf) - 1);
	bufname = MakeName(command);
	strcpy(scratch, bufname);
	while ((bp = buf_exists(scratch)) && !isdead(bp->b_process))
		sprintf(scratch, "%s.%d", bufname, cnt++);
	proc_strt(scratch, YES, Shell, ShFlags, command, (char *) 0);
}

proc_child()
{
	union wait	w;
	register int	pid;

	for (;;) {
#ifndef BSD4_2
		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)
register int	pid;
union wait	w;
{
	register Process	*child;

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

	UpdModLine = YES;		/* we're changing state ... */
	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;
		}
		{
			Buffer	*save = curbuf;
			char	mesg[128];

			/* insert status message now */
			sprintf(mesg, "[Process %s: %s]\n",
				proc_cmd(child),
				pstate(child));
			SetBuf(child->p_buffer);
			ins_str(mesg, NO);
			SetBuf(save);
			redisplay();
		}
	}
}

/* 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()
{
	register data_obj	*d;

	if ((d = findcom(ProcFmt)) == 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;
	register 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_process)
				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_process)
				PushPBs();
		}
	}
}

#endif /* IPROCS */
Commit	Line	Data
6ca833f5 C	1	/***************************************************************************
	2	* This program is Copyright (C) 1986, 1987, 1988 by Jonathan Payne. JOVE *
	3	* is provided to you without charge, and with no warranty. You may give *
	4	* away copies of JOVE, including sources, provided that this notice is *
	5	* included in all the files. *
	6	***************************************************************************/
	7
	8	#include "jove.h"
	9	#include "re.h"
	10	#include <varargs.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	char proc_prompt[128] = "% ";
	23
	24	KillProcs()
	25	{
	26	register Process *p;
	27	register int killem = -1; /* -1 means undetermined */
	28	register char *yorn;
	29
	30	for (p = procs; p != 0; p = p->p_next)
	31	if (!isdead(p)) {
	32	if (killem == -1) {
	33	yorn = ask("y", "Should I kill your i-processes? ");
	34	killem = (CharUpcase(*yorn) == 'Y');
	35	}
	36	if (killem)
	37	proc_kill(p, SIGKILL);
	38	}
	39	}
	40
	41	pbuftiedp(b)
	42	register Buffer *b;
	43	{
	44	register Process *p = b->b_process;
	45
	46	if (!isdead(p))
	47	complain("Process %s, attached to %b, is %s.",
	48	proc_cmd(p), b, pstate(p));
	49	}
	50
	51	/* Process receive: receives the characters in buf, and appends them to
	52	the buffer associated with p. */
	53
	54	private
	55	proc_rec(p, buf)
	56	register Process *p;
	57	char *buf;
	58	{
	59	Buffer *saveb = curbuf;
	60	register Window *w;
	61	register Mark *savepoint;
	62	int sameplace = NO,
	63	do_disp = NO;
	64
65	if (curwind->w_bufp == p->p_buffer)
66	w = curwind;
67	else
68	w = windbp(p->p_buffer); /* Is this window visible? */
69	if (w != 0)
70	do_disp = (in_window(w, p->p_mark->m_line) != -1);
71	SetBuf(p->p_buffer);
72	savepoint = MakeMark(curline, curchar, M_FLOATER);
73	ToMark(p->p_mark); /* where output last stopped */
74	if (savepoint->m_line == curline && savepoint->m_char == curchar)
75	sameplace = YES;
76
77	ins_str(buf, YES);
78	MarkSet(p->p_mark, curline, curchar);
79	if (!sameplace)
80	ToMark(savepoint); /* back to where we were */
81	DelMark(savepoint);
82	/* redisplay now, instead of right after the ins_str, so that
83	we don't get a bouncing effect if point is not the same as
84	the process output position */
85	if (do_disp) {
86	w->w_line = curline;
87	w->w_char = curchar;
88	redisplay();
89	}
90	SetBuf(saveb);
91	}
92
93	proc_kill(p, sig)
94	register Process *p;
95	{
96	if (isdead(p))
97	return;
98	if (killpg(p->p_pid, sig) == -1)
99	s_mess("Cannot kill %s!", proc_buf(p));
100	}
101
102	/* Free process CHILD. Do all the necessary cleaning up (closing fd's,
103	etc.). */
104
105	free_proc(child)
106	Process *child;
107	{
108	register Process *p,
109	*prev = 0;
110
111	if (!isdead(child))
112	return;
113	for (p = procs; p != child; prev = p, p = p->p_next)
114	;
115	if (prev == 0)
116	procs = child->p_next;
117	else
118	prev->p_next = child->p_next;
119	proc_close(child); /* if not already closed */
120
121	/* It's possible that the buffer has been given another process
122	between the time CHILD dies and CHILD's death is noticed (via
123	list-processes). So we only set it the buffer's process to
124	0 if CHILD is still the controlling process. */
125	if (child->p_buffer->b_process == child) {
126	child->p_buffer->b_process = 0;
127	if (curbuf == child->p_buffer)
128	PopPBs();
129	}
130	{
131	Buffer *old = curbuf;
132
133	SetBuf(child->p_buffer);
134	DelMark(child->p_mark);
135	SetBuf(old);
136	}
137	free((char *) child->p_name);
138	free((char *) child);
139	}
140
141	ProcList()
142	{
143	register Process *p,
144	*next;
145	char *fmt = "%-15s %-15s %-8s %s",
146	pidstr[16];
147
148	if (procs == 0) {
149	message("[No subprocesses]");
150	return;
151	}
152	TOstart("Process list", TRUE);
153
154	Typeout(fmt, "Buffer", "Status", "Pid ", "Command");
155	Typeout(fmt, "------", "------", "--- ", "-------");
156	for (p = procs; p != 0; p = next) {
157	next = p->p_next;
158	sprintf(pidstr, "%d", p->p_pid);
159	Typeout(fmt, proc_buf(p), pstate(p), pidstr, p->p_name);
160	if (isdead(p)) {
161	free_proc(p);
162	UpdModLine = YES;
163	}
164	}
165	TOstop();
166	}
167
168	ProcNewline()
169	{
170	#ifdef ABBREV
171	MaybeAbbrevExpand();
172	#endif
173	SendData(YES);
174	}
175
176	ProcSendData()
177	{
178	#ifdef ABBREV
179	MaybeAbbrevExpand();
180	#endif
181	SendData(NO);
182	}
183
184	private
185	SendData(newlinep)
186	{
187	register Process *p = curbuf->b_process;
188	register char *lp,
189	gp; / JF fix for better prompt handling */
190
191	if (isdead(p))
192	return;
193	/* If the process mark was involved in a big deletion, because
194	the user hit ^W or something, then let's do some magic with
195	the process mark. Problem is that if the user yanks back the
196	text he deleted, the mark stays at the beginning of the region,
197	and so the next time SendData() is called the entire region
198	will be sent. That's not good. So, to deal with that we reset
199	the mark to the last line, after skipping over the prompt, etc. */
200	if (p->p_mark->m_flags & M_BIG_DELETE) {
201	Bufpos bp;
202
203	p->p_mark->m_flags &= ~M_BIG_DELETE;
204
205	DOTsave(&bp);
206	ToLast();
207	Bol();
208	/* While we're looking at a prompt, and while we're
209	moving forward. This is for people who accidently
210	set their process-prompt to ">*" which will always
211	match! */
212	while ((LookingAt(proc_prompt, linebuf, curchar)) &&
213	(REeom > curchar))
214	curchar = REeom;
215	MarkSet(p->p_mark, curline, curchar);
216	SetDot(&bp);
217	}
218
219	if (lastp(curline)) {
220	Eol();
221	if (newlinep)
222	LineInsert(1);
223	do_rtp(p->p_mark);
224	MarkSet(p->p_mark, curline, curchar);
225	} else {
226	/* Either we're looking at a prompt, or we're not, in
227	which case we want to strip off the beginning of the
228	line anything that looks like what the prompt at the
229	end of the file is. In other words, if "(dbx) stop in
230	ProcessNewline" is the line we're on, and the last
231	line in the buffer is "(dbx) ", then we strip off the
232	leading "(dbx) " from this line, because we know it's
233	part of the prompt. But this only happens if "(dbx) "
234	isn't one of the process prompts ... follow what I'm
235	saying? */
236	Bol();
237	if (LookingAt(proc_prompt, linebuf, curchar)) {
238	do
239	curchar = REeom;
240	while ((LookingAt(proc_prompt, linebuf, curchar)) &&
241	(REeom > curchar));
242	strcpy(genbuf, linebuf + curchar);
243	Eof();
244	ins_str(genbuf, NO);
245	} else {
246	strcpy(genbuf, linebuf + curchar);
247	Eof();
248	gp = genbuf;
249	lp = linebuf;
250	while (lp == gp && *lp != '\0') {
251	lp += 1;
252	gp += 1;
253	}
254	ins_str(gp, NO);
255	}
256	}
257	}
258
259	ShellProc()
260	{
261	char shbuf = "shell*";
262	register Buffer *b;
263
264	b = buf_exists(shbuf);
265	if (b == 0 \|\| isdead(b->b_process))
266	proc_strt(shbuf, NO, Shell, "-i", (char *) 0);
267	pop_wind(shbuf, NO, -1);
268	}
269
270	Iprocess()
271	{
272	extern char ShcomBuf[100],
273	*MakeName();
274	register char *command;
275	char scratch[64],
276	*bufname;
277	int cnt = 1;
278	Buffer *bp;
279
280	command = ask(ShcomBuf, ProcFmt);
281	null_ncpy(ShcomBuf, command, (sizeof ShcomBuf) - 1);
282	bufname = MakeName(command);
283	strcpy(scratch, bufname);
284	while ((bp = buf_exists(scratch)) && !isdead(bp->b_process))
285	sprintf(scratch, "%s.%d", bufname, cnt++);
286	proc_strt(scratch, YES, Shell, ShFlags, command, (char *) 0);
287	}
288
289	proc_child()
290	{
291	union wait w;
292	register int pid;
293
294	for (;;) {
295	#ifndef BSD4_2
296	pid = wait2(&w.w_status, (WNOHANG \| WUNTRACED));
297	#else
298	pid = wait3(&w, (WNOHANG \| WUNTRACED), (struct rusage *) 0);
299	#endif
300	if (pid <= 0)
301	break;
302	kill_off(pid, w);
303	}
304	}
305
306	kill_off(pid, w)
307	register int pid;
308	union wait w;
309	{
310	register Process *child;
311
312	if ((child = proc_pid(pid)) == 0)
313	return;
314
315	UpdModLine = YES; /* we're changing state ... */
316	if (WIFSTOPPED(w))
317	child->p_state = STOPPED;
318	else {
319	child->p_state = DEAD;
320	if (WIFEXITED(w))
321	child->p_howdied = EXITED;
322	else if (WIFSIGNALED(w)) {
323	child->p_reason = w.w_termsig;
324	child->p_howdied = KILLED;
325	}
326	{
327	Buffer *save = curbuf;
328	char mesg[128];
329
330	/* insert status message now */
331	sprintf(mesg, "[Process %s: %s]\n",
332	proc_cmd(child),
333	pstate(child));
334	SetBuf(child->p_buffer);
335	ins_str(mesg, NO);
336	SetBuf(save);
337	redisplay();
338	}
339	}
340	}
341
342	/* Push/pod process bindings. I openly acknowledge that this is a
343	kludge, but I can't be bothered making it right. */
344
345	struct proc_bind {
346	int pb_key;
347	data_obj **pb_map;
348	data_obj *pb_push;
349	data_obj *pb_cmd;
350	struct proc_bind *pb_next;
351	};
352
353	struct proc_bind *PBinds = 0;
354
355	PopPBs()
356	{
357	register struct proc_bind *p;
358
359	for (p = PBinds; p != 0; p = p->pb_next)
360	p->pb_map[p->pb_key] = p->pb_push;
361	}
362
363	PushPBs()
364	{
365	register struct proc_bind *p;
366
367	for (p = PBinds; p != 0; p = p->pb_next) {
368	p->pb_push = p->pb_map[p->pb_key];
369	p->pb_map[p->pb_key] = p->pb_cmd;
370	}
371	}
372	/* VARARGS0 */
373
374	ProcBind()
375	{
376	register data_obj *d;
377
378	if ((d = findcom(ProcFmt)) == 0)
379	return;
380	s_mess(": %f %s ", d->Name);
381	ProcB2(mainmap, EOF, d);
382	}
383
384	ProcB2(map, lastkey, cmd)
385	data_obj **map,
386	*cmd;
387	{
388	register struct proc_bind *p;
389	register data_obj **nextmap;
390	int c;
391
392	c = addgetc();
393	if (c == EOF) {
394	if (lastkey == EOF)
395	complain("[Empty key sequence]");
396	complain("[Unexpected end-of-line]");
397	} else {
398	if (nextmap = IsPrefix(map[c]))
399	ProcB2(nextmap, c, cmd);
400	else {
401	if (curbuf->b_process)
402	PopPBs();
403
404	for (p = PBinds; p != 0; p = p->pb_next)
405	if (p->pb_key == c && p->pb_map == map)
406	break;
407	if (p == 0) {
408	p = (struct proc_bind ) emalloc(sizeof p);
409	p->pb_next = PBinds;
410	PBinds = p;
411	}
412	p->pb_map = map;
413	p->pb_key = c;
414	p->pb_cmd = cmd;
415
416	if (curbuf->b_process)
417	PushPBs();
418	}
419	}
420	}
421
422	#endif /* IPROCS */
423