![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to iproc.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove|
Return to iproc.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / jove |
1.1 root 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:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.