+/***************************************************************************
+ * 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 "io.h"
+#include "termcap.h"
+
+#include <signal.h>
+#include <varargs.h>
+
+#ifdef MSDOS
+# include <io.h>
+# include <process.h>
+#endif
+
+
+#ifdef LINT_ARGS
+private void
+ DoShell(char *, char *),
+ com_finish(int, char *),
+ toerror(int, int),
+ closepipe(void);
+
+private int
+ okay_error(void),
+ openforpipe(void),
+ reopenforpipe(void);
+
+private struct error
+ * AddError(struct error *, Line *, Buffer *, Line *, int);
+#else
+private void
+ DoShell(),
+ com_finish(),
+ toerror(),
+ closepipe();
+
+private int
+ openforpipe(),
+ okay_error(),
+ reopenforpipe();
+
+private struct error
+ * AddError();
+#endif
+
+
+/* This disgusting RE search string parses output from the GREP
+ family, from the pdp11 compiler, pcc, and lint. Jay (HACK)
+ Fenlasen changed this to work for the lint errors. */
+char ErrFmtStr[256] = "^\\{\",\\}\\([^:\"( \t]*\\)\\{\"\\, line ,:,(\\} *\\([0-9][0-9]*\\)[:)]\
+\\|:: *\\([^(]*\\)(\\([0-9]*\\))$\
+\\|( \\([^(]*\\)(\\([0-9]*\\)) ),";
+
+struct error {
+ Buffer *er_buf; /* Buffer error is in */
+ Line *er_mess, /* Actual error message */
+ *er_text; /* Actual error */
+ int er_char; /* char pos of error */
+ struct error *er_prev, /* List of errors */
+ *er_next;
+};
+
+struct error *cur_error = 0,
+ *errorlist = 0;
+Buffer *perr_buf = 0; /* Buffer with error messages */
+
+int WtOnMk = 1; /* Write the modified files when we make */
+
+/* Add an error to the end of the list of errors. This is used for
+ parse-{C,LINT}-errors and for the spell-buffer command */
+
+private struct error *
+AddError(laste, errline, buf, line, charpos)
+struct error *laste;
+Line *errline,
+ *line;
+Buffer *buf;
+{
+ struct error *new = (struct error *) emalloc(sizeof *new);
+
+ new->er_prev = laste;
+ if (laste)
+ laste->er_next = new;
+ else {
+ if (errorlist) /* Free up old errors */
+ ErrFree();
+ cur_error = errorlist = new;
+ }
+ laste = new;
+ new->er_next = 0;
+ new->er_buf = buf;
+ new->er_text = line;
+ new->er_char = charpos;
+ new->er_mess = errline;
+
+ return new;
+}
+
+/* Parse errors of the form specified in ErrFmtStr in the current
+ buffer. Do a show error of the first error. This is neat because this
+ will work for any kind of output that prints a file name and a line
+ number on the same line. */
+
+void
+ErrParse()
+{
+ Bufpos *bp;
+ char fname[FILESIZE],
+ lineno[10],
+ REbuf[256],
+ *REalts[10];
+ int lnum,
+ last_lnum = -1;
+ struct error *ep = 0;
+ Buffer *buf,
+ *lastb = 0;
+ Line *err_line;
+
+ ErrFree(); /* This is important! */
+ ToFirst();
+ perr_buf = curbuf;
+ REcompile(ErrFmtStr, 1, REbuf, REalts);
+ /* Find a line with a number on it. */
+ while (bp = docompiled(FORWARD, REbuf, REalts)) {
+ SetDot(bp);
+ putmatch(1, fname, sizeof fname);
+ putmatch(2, lineno, sizeof lineno);
+ buf = do_find((Window *) 0, fname, 1);
+ if (buf != lastb) {
+ lastb = buf;
+ last_lnum = -1; /* signals new file */
+ err_line = buf->b_first;
+ }
+ (void) chr_to_int(lineno, 10, NO, &lnum);
+ if (lnum == last_lnum) /* one error per line is nicer */
+ continue;
+ if (last_lnum == -1)
+ last_lnum = 1; /* that's where we really are */
+ err_line = next_line(err_line, lnum - last_lnum);
+ ep = AddError(ep, curline, buf, err_line, 0);
+ last_lnum = lnum;
+ }
+ if (cur_error != 0)
+ ShowErr();
+}
+
+/* Free up all the errors */
+
+void
+ErrFree()
+{
+ register struct error *ep;
+
+ for (ep = errorlist; ep != 0; ep = ep->er_next)
+ free((char *) ep);
+ errorlist = cur_error = 0;
+}
+
+/* Internal next error sets cur_error to the next error, taking the
+ argument count, supplied by the user, into consideration. */
+
+private char errbounds[] = "You're at the %s error.",
+ noerrs[] = "No errors!";
+
+private void
+toerror(forward, num)
+{
+ register struct error *e = cur_error;
+
+ if (e == 0)
+ complain(noerrs);
+ if ((forward && (e->er_next == 0)) ||
+ (!forward && (e->er_prev == 0)))
+ complain(errbounds, forward ? "last" : "first");
+
+ while (--num >= 0) {
+ if ((e = forward ? e->er_next : e->er_prev) == 0)
+ break;
+ cur_error = e;
+ }
+}
+
+void
+NextError()
+{
+ ToError(1);
+}
+
+void
+PrevError()
+{
+ ToError(0);
+}
+
+private int
+okay_error()
+{
+ return ((inlist(perr_buf->b_first, cur_error->er_mess)) &&
+ (inlist(cur_error->er_buf->b_first, cur_error->er_text)));
+}
+
+/* Go the the next error, if there is one. Put the error buffer in
+ one window and the buffer with the error in another window.
+ It checks to make sure that the error actually exists. */
+
+void
+ToError(forward)
+{
+ do {
+ toerror(forward, arg_value());
+ } while (!okay_error());
+ ShowErr();
+}
+
+int EWSize = 20; /* percentage of screen the error window
+ should be */
+
+void
+set_wsize(wsize)
+int wsize;
+{
+ wsize = (LI * wsize) / 100;
+ if (wsize >= 1 && !one_windp())
+ WindSize(curwind, wsize - (curwind->w_height - 1));
+}
+
+/* Show the current error, i.e. put the line containing the error message
+ in one window, and the buffer containing the actual error in another
+ window. */
+
+void
+ShowErr()
+{
+ Window *err_wind,
+ *buf_wind;
+
+ if (cur_error == 0)
+ complain(noerrs);
+ if (!okay_error()) {
+ rbell();
+ return;
+ }
+ err_wind = windbp(perr_buf);
+ buf_wind = windbp(cur_error->er_buf);
+
+ if (err_wind && !buf_wind) {
+ SetWind(err_wind);
+ pop_wind(cur_error->er_buf->b_name, NO, -1);
+ buf_wind = curwind;
+ } else if (!err_wind && buf_wind) {
+ SetWind(buf_wind);
+ pop_wind(perr_buf->b_name, NO, -1);
+ err_wind = curwind;
+ } else if (!err_wind && !buf_wind) {
+ pop_wind(perr_buf->b_name, NO, -1);
+ err_wind = curwind;
+ pop_wind(cur_error->er_buf->b_name, NO, -1);
+ buf_wind = curwind;
+ }
+
+ /* Put the current error message at the top of its Window */
+ SetWind(err_wind);
+ SetLine(cur_error->er_mess);
+ SetTop(curwind, (curwind->w_line = cur_error->er_mess));
+ set_wsize(EWSize);
+
+ /* now go to the the line with the error in the other window */
+ SetWind(buf_wind);
+ DotTo(cur_error->er_text, cur_error->er_char);
+}
+
+char ShcomBuf[128] = {0};
+
+/* Make a buffer name given the command `command', i.e. "fgrep -n foo *.c"
+ will return the buffer name "fgrep". */
+
+char *
+MakeName(command)
+char *command;
+{
+ static char bufname[50];
+ register char *cp = bufname,
+ c;
+
+ while ((c = *command++) && (c == ' ' || c == '\t'))
+ ;
+ do
+ *cp++ = c;
+ while ((c = *command++) && (c != ' ' && c != '\t'));
+ *cp = 0;
+ strcpy(bufname, basename(bufname));
+
+ return bufname;
+}
+
+/* Run make, first writing all the modified buffers (if the WtOnMk flag is
+ non-zero), parse the errors, and go the first error. */
+
+char make_cmd[128] = "make";
+
+void
+MakeErrors()
+{
+ Window *old = curwind;
+ int status,
+ compilation;
+
+ if (WtOnMk)
+ put_bufs(0);
+ /* When we're not doing make or cc (i.e., the last command
+ was probably a grep or something) and the user just types
+ C-X C-E, he probably (possibly, hopefully, usually (in my
+ case)) doesn't want to do the grep again but rather wants
+ to do a make again; so we ring the bell and insert the
+ default command and let the person decide. */
+
+ compilation = (sindex("make", make_cmd) || sindex("cc", make_cmd));
+ if (is_an_arg() || !compilation) {
+ if (!compilation) {
+ rbell();
+ Inputp = make_cmd; /* insert the default for the user */
+ }
+ null_ncpy(make_cmd, ask(make_cmd, "Compilation command: "),
+ sizeof (make_cmd) - 1);
+ }
+ status = UnixToBuf(MakeName(make_cmd), YES, EWSize, YES, Shell, ShFlags, make_cmd, (char *) 0);
+ com_finish(status, make_cmd);
+
+ ErrParse();
+
+ if (!cur_error)
+ SetWind(old);
+}
+
+#ifdef SPELL
+
+void
+SpelBuffer()
+{
+ char *Spell = "Spell",
+ com[100];
+ Window *savewp = curwind;
+
+ put_bufs(0);
+ sprintf(com, "spell %s", curbuf->b_fname);
+ (void) UnixToBuf(Spell, YES, EWSize, YES, Shell, ShFlags, com, (char *) 0);
+ message("[Delete the irrelevant words and then type C-X C-C]");
+ ToFirst();
+ Recur();
+ SetWind(savewp);
+ SpelParse(Spell);
+}
+
+void
+SpelWords()
+{
+ char *buftospel;
+ Buffer *wordsb = curbuf;
+
+ if ((buftospel = ask_buf((Buffer *) 0)) == 0)
+ return;
+ SetBuf(do_select(curwind, buftospel));
+ SpelParse(wordsb->b_name);
+}
+
+void
+SpelParse(bname)
+char *bname;
+{
+ Buffer *buftospel,
+ *wordsb;
+ char wordspel[100];
+ Bufpos *bp;
+ struct error *ep = 0;
+
+ ErrFree(); /* This is important! */
+
+ buftospel = curbuf;
+ wordsb = buf_exists(bname);
+ perr_buf = wordsb; /* This is important (buffer containing
+ error messages) */
+ SetBuf(wordsb);
+ ToFirst();
+ f_mess("Finding misspelled words ... ");
+ while (!lastp(curline)) {
+ sprintf(wordspel, "\\<%s\\>", linebuf);
+ SetBuf(buftospel);
+ ToFirst();
+ while (bp = dosearch(wordspel, 1, 1)) {
+ SetDot(bp);
+ ep = AddError(ep, wordsb->b_dot, buftospel,
+ curline, curchar);
+ }
+ SetBuf(wordsb);
+ line_move(FORWARD, 1, NO);
+ }
+ add_mess("Done.");
+ SetBuf(buftospel);
+ ShowErr();
+}
+
+#endif /* SPELL */
+
+void
+ShToBuf()
+{
+ char bufname[128],
+ cmd[128];
+
+ strcpy(bufname, ask((char *) 0, "Buffer: "));
+ strcpy(cmd, ask(ShcomBuf, "Command: "));
+ DoShell(bufname, cmd);
+}
+
+void
+ShellCom()
+{
+ null_ncpy(ShcomBuf, ask(ShcomBuf, ProcFmt), (sizeof ShcomBuf) - 1);
+ DoShell(MakeName(ShcomBuf), ShcomBuf);
+}
+
+ShNoBuf()
+{
+ int status;
+
+ null_ncpy(ShcomBuf, ask(ShcomBuf, ProcFmt), (sizeof ShcomBuf) - 1);
+ status = UnixToBuf((char *) 0, NO, 0, NO, Shell, ShFlags, ShcomBuf, (char *) 0);
+ com_finish(status, ShcomBuf);
+}
+
+Shtypeout()
+{
+ int status;
+
+ null_ncpy(ShcomBuf, ask(ShcomBuf, ProcFmt), (sizeof ShcomBuf) - 1);
+ status = UnixToBuf((char *) 0, YES, 0, NO, Shell, ShFlags, ShcomBuf, (char *) 0);
+ if (status == 0)
+ Typeout("[%s: completed successfully]", ShcomBuf);
+ else
+ Typeout("[%s: exited (%d)]", ShcomBuf, status);
+ TOstop();
+}
+
+/* Run the shell command into `bufname'. Empty the buffer except when we
+ give a numeric argument, in which case it inserts the output at the
+ current position in the buffer. */
+
+private void
+DoShell(bufname, command)
+char *bufname,
+ *command;
+{
+ Window *savewp = curwind;
+ int status;
+
+ status = UnixToBuf(bufname, YES, 0, !is_an_arg(), Shell,
+ ShFlags, command, (char *) 0);
+ com_finish(status, command);
+ SetWind(savewp);
+}
+
+private void
+com_finish(status, cmd)
+int status;
+char *cmd;
+{
+ s_mess("[%s: ", cmd);
+ if (status == 0)
+ add_mess("completed successfully");
+ else
+ add_mess("exited (%d)", status);
+ add_mess("]");
+}
+
+#ifndef MSDOS
+void
+dowait(pid, status)
+int pid,
+ *status;
+{
+# ifndef IPROCS
+
+ int rpid;
+
+ while ((rpid = wait(status)) != pid)
+ ;
+# else
+
+# ifdef BSD4_2
+# include <sys/wait.h>
+# else
+# include <wait.h>
+# endif
+
+ union wait w;
+ int rpid;
+
+ for (;;) {
+# ifndef BSD4_2
+ rpid = wait2(&w.w_status, 0);
+# else
+ rpid = wait3(&w, 0, (struct rusage *) 0);
+# endif
+ if (rpid == pid) {
+ if (status)
+ *status = w.w_status;
+ break;
+ } else
+ kill_off(rpid, w);
+ }
+# endif /* IPROCS */
+}
+#endif /* MSDOS */
+
+/* Run the command to bufname, erase the buffer if clobber is non-zero,
+ and redisplay if disp is non-zero. Leaves current buffer in `bufname'
+ and leaves any windows it creates lying around. It's up to the caller
+ to fix everything up after we're done. (Usually there's nothing to
+ fix up.) */
+
+/* VARARGS5 */
+
+int
+UnixToBuf(bufname, disp, wsize, clobber, va_alist)
+char *bufname;
+va_dcl
+{
+#ifndef MSDOS
+ int p[2],
+ pid,
+ status,
+#else /* MSDOS */
+ int p0,
+ oldo,
+ olde,
+ retcode,
+#endif /* MSDOS */
+ eof;
+ va_list ap;
+ char *argv[32],
+ *mess;
+ File *fp;
+ int (*old_int)();
+
+ va_start(ap);
+ make_argv(argv, ap);
+ va_end(ap);
+ if (bufname != 0 && clobber == YES)
+ isprocbuf(bufname);
+ if (disp) {
+ if (bufname != 0)
+ message("Starting up...");
+ else {
+ TOstart(argv[0], TRUE);
+ Typeout("Starting up...");
+ }
+ if (bufname != 0) {
+ pop_wind(bufname, clobber, clobber ? B_PROCESS : B_FILE);
+ set_wsize(wsize);
+ redisplay();
+ }
+ }
+ /* Now I will attempt to describe how I deal with signals during
+ the execution of the shell command. My desire was to be able
+ to interrupt the shell command AS SOON AS the window pops up.
+ So, if we have JOB_CONTROL (i.e., the new signal mechanism) I
+ hold SIGINT, meaning if we interrupt now, we will eventually
+ see the interrupt, but not before we are ready for it. We
+ fork, the child releases the interrupt, it then sees the
+ interrupt, and so exits. Meanwhile the parent ignores the
+ signal, so if there was a pending one, it's now lost.
+
+ With no JOB_CONTROL, the best behavior you can expect is, when
+ you type ^] too very quickly after the window pops up, it may
+ be ignored. The behavior BEFORE was that it would interrupt
+ JOVE and then you would have to continue JOVE and wait a
+ little while longer before trying again. Now that is fixed,
+ in that you just have to type it twice. */
+
+#ifndef MSDOS
+# ifdef IPROCS
+ sighold(SIGCHLD);
+# endif
+# ifdef JOB_CONTROL
+ sighold(SIGINT);
+# else
+ old_int = signal(SIGINT, SIG_IGN),
+# endif
+ dopipe(p);
+ pid = fork();
+ if (pid == -1) {
+ pclose(p);
+ complain("[Fork failed]");
+ }
+ if (pid == 0) {
+# ifdef IPROCS
+ sigrelse(SIGCHLD); /* don't know if this matters */
+# endif /* IPROCS */
+ (void) signal(SIGINT, SIG_DFL);
+# ifdef JOB_CONTROL
+ sigrelse(SIGINT);
+# endif
+ (void) close(0);
+ (void) open("/dev/null", 0);
+ (void) close(1);
+ (void) close(2);
+ (void) dup(p[1]);
+ (void) dup(p[1]);
+ pclose(p);
+ execv(argv[0], &argv[1]);
+ (void) write(1, "Execl failed.\n", 14);
+ _exit(1);
+ }
+# ifdef JOB_CONTROL
+ old_int = signal(SIGINT, SIG_IGN);
+# endif
+ (void) close(p[1]);
+ fp = fd_open(argv[1], F_READ, p[0], iobuff, LBSIZE);
+#else /* MSDOS */
+ if ((p0 = openforpipe()) < 0)
+ complain("cannot make pipe for filter");
+
+ oldo = dup(1);
+ olde = dup(2);
+ close(1);
+ close(2);
+ dup(p0);
+ dup(1);
+ close(p0);
+ retcode = spawnv(0, argv[0], &argv[1]);
+ p0 = reopenforpipe();
+ close(1);
+ close(2);
+ dup(oldo);
+ dup(olde);
+ close(oldo);
+ close(olde);
+
+ if (retcode < 0)
+ complain("[Spawn failed]");
+
+ fp = fd_open(argv[1], F_READ, p0, iobuff, LBSIZE);
+#endif /* MSDOS */
+ do {
+#ifndef MSDOS
+ inIOread = 1;
+#endif
+ eof = f_gets(fp, genbuf, LBSIZE);
+#ifndef MSDOS
+ inIOread = 0;
+#endif
+ if (bufname != 0) {
+ ins_str(genbuf, YES);
+ if (!eof)
+ LineInsert(1);
+ } else if (disp == YES)
+ Typeout("%s", genbuf);
+ if (bufname != 0 && disp != 0 && fp->f_cnt <= 0) {
+#ifdef LOAD_AV
+ {
+ double theavg;
+
+ get_la(&theavg);
+ if (theavg < 2.0)
+ mess = "Screaming along...";
+ else if (theavg < 5.0)
+ mess = "Chugging along...";
+ else
+ mess = "Crawling along...";
+ }
+#else
+ mess = "Chugging along...";
+#endif /* LOAD_AV */
+ if (bufname != 0) {
+ message(mess);
+ redisplay();
+ }
+ }
+ } while (!eof);
+ if (disp)
+ DrawMesg(NO);
+ close_file(fp);
+#ifndef MSDOS
+ dowait(pid, &status);
+# ifdef JOB_CONTROL
+ (void) sigrelse(SIGINT);
+# endif
+#else /* MSDOS */
+ closepipe();
+#endif /* MSDOS */
+ (void) signal(SIGINT, old_int);
+#ifndef MSDOS
+# ifdef IPROCS
+ sigrelse(SIGCHLD);
+# endif
+ return status;
+#else /* MSDOS */
+# ifdef CHDIR
+ getCWD();
+# endif
+ return retcode;
+#endif /* MSDOS */
+}
+
+#ifndef MSDOS
+#ifdef BSD4_2
+
+private long SigMask = 0;
+
+#ifndef sigmask
+# define sigmask(s) (1L << ((s)-1))
+#endif
+
+sighold(sig)
+{
+ (void) sigblock(SigMask |= sigmask(sig));
+}
+
+sigrelse(sig)
+{
+ (void) sigsetmask(SigMask &= ~sigmask(sig));
+}
+
+#endif
+
+#endif /* MSDOS */
+
+void
+FilterRegion()
+{
+ char *cmd = ask((char *) 0, ": %f (through command) ", ProcFmt);
+
+ RegToUnix(curbuf, cmd);
+}
+
+/* Send the current region to CMD and insert the output from the
+ command into OUT_BUF. */
+
+void
+RegToUnix(outbuf, cmd)
+Buffer *outbuf;
+char *cmd;
+{
+ Mark *m = CurMark();
+#ifndef MSDOS
+ char *tname = mktemp("/tmp/jfilterXXXXXX"),
+ combuf[128];
+#endif /* MSDOS */
+ Window *save_wind = curwind;
+ int status,
+ error = NO;
+#ifdef MSDOS
+ int p0, oldi;
+#endif /* MSDOS */
+ File *fp;
+
+#ifndef MSDOS
+ fp = open_file(tname, iobuff, F_WRITE, COMPLAIN, QUIET);
+#else /* MSDOS */
+ p0 = openforpipe();
+#endif /* MSDOS */
+ CATCH
+#ifdef MSDOS
+ fp = fd_open(cmd, F_WRITE, p0, iobuff, LBSIZE);
+#endif /* MSDOS */
+ putreg(fp, m->m_line, m->m_char, curline, curchar, YES);
+ DelReg();
+#ifndef MSDOS
+ sprintf(combuf, "%s < %s", cmd, tname);
+#else /* MSDOS */
+ f_close(fp);
+ p0 = reopenforpipe();
+ oldi = dup(0);
+ close(0);
+ dup(p0);
+ close(p0);
+#endif /* MSDOS */
+ status = UnixToBuf(outbuf->b_name, NO, 0, outbuf->b_type == B_SCRATCH,
+#ifndef MSDOS
+ Shell, ShFlags, combuf, (char *) 0);
+#else /* MSDOS */
+ Shell, ShFlags, cmd, (char *) 0);
+#endif /* MSDOS */
+ ONERROR
+ error = YES;
+ ENDCATCH
+#ifndef MSDOS
+ f_close(fp);
+ (void) unlink(tname);
+#else /* MSDOS */
+ close(0);
+ open("con", 0); /* dup(oldi); */
+ close(oldi);
+ closepipe();
+#endif /* MSDOS */
+ SetWind(save_wind);
+ if (error == NO)
+#ifndef MSDOS
+ com_finish(status, combuf);
+#else
+ com_finish(status, cmd);
+#endif
+}
+
+void
+isprocbuf(bufname)
+char *bufname;
+{
+ Buffer *bp;
+
+ if ((bp = buf_exists(bufname)) != 0 && bp->b_type != B_PROCESS)
+ confirm("Over-write buffer %s?", bufname);
+}
+
+#ifdef MSDOS
+/* msdos specific hacks to allow for pipes */
+
+#include <dos.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+
+static char pipeiname[64];
+static char pipeoname[64];
+static int pipehandle;
+
+extern char TmpFilePath[];
+
+private int
+openforpipe()
+{
+ sprintf(pipeiname, "%s/%s", TmpFilePath, "Jove-I");
+ sprintf(pipeoname, "%s/%s", TmpFilePath, "Jove-O");
+
+ return(pipehandle = creat(pipeoname, S_IWRITE|S_IREAD));
+}
+
+private int
+reopenforpipe()
+{
+ close(pipehandle);
+ unlink(pipeiname);
+ rename(pipeoname, pipeiname);
+ if ((pipehandle = open(pipeiname, 0)) >= 0)
+ return(pipehandle);
+ closepipe();
+ return(-1);
+}
+
+private void
+closepipe()
+{
+ unlink(pipeoname);
+ unlink(pipeiname);
+}
+
+char
+switchar()
+{
+ union REGS regs;
+
+ regs.h.ah = 0x37;
+ regs.h.al = 0;
+ intdos(®s, ®s);
+ return(regs.h.dl);
+}
+#endif /* MSDOS */
projects / unix-history / commitdiff