+/* Copyright (c) 1979 Regents of the University of California */
+#include "ex.h"
+#include "ex_argv.h"
+#include "ex_temp.h"
+#include "ex_tty.h"
+
+#ifdef TRACE
+char tttrace[] = { '/','d','e','v','/','t','t','y','x','x',0 };
+#endif
+
+/*
+ * The code for ex is divided as follows:
+ *
+ * ex.c Entry point and routines handling interrupt, hangup
+ * signals; initialization code.
+ *
+ * ex_addr.c Address parsing routines for command mode decoding.
+ * Routines to set and check address ranges on commands.
+ *
+ * ex_cmds.c Command mode command decoding.
+ *
+ * ex_cmds2.c Subroutines for command decoding and processing of
+ * file names in the argument list. Routines to print
+ * messages and reset state when errors occur.
+ *
+ * ex_cmdsub.c Subroutines which implement command mode functions
+ * such as append, delete, join.
+ *
+ * ex_data.c Initialization of options.
+ *
+ * ex_get.c Command mode input routines.
+ *
+ * ex_io.c General input/output processing: file i/o, unix
+ * escapes, filtering, source commands, preserving
+ * and recovering.
+ *
+ * ex_put.c Terminal driving and optimizing routines for low-level
+ * output (cursor-positioning); output line formatting
+ * routines.
+ *
+ * ex_re.c Global commands, substitute, regular expression
+ * compilation and execution.
+ *
+ * ex_set.c The set command.
+ *
+ * ex_subr.c Loads of miscellaneous subroutines.
+ *
+ * ex_temp.c Editor buffer routines for main buffer and also
+ * for named buffers (Q registers if you will.)
+ *
+ * ex_tty.c Terminal dependent initializations from termcap
+ * data base, grabbing of tty modes (at beginning
+ * and after escapes).
+ *
+ * ex_v*.c Visual/open mode routines... see ex_v.c for a
+ * guide to the overall organization.
+ */
+
+/*
+ * Main procedure. Process arguments and then
+ * transfer control to the main command processing loop
+ * in the routine commands. We are entered as either "ex", "edit" or "vi"
+ * and the distinction is made here. Actually, we are "vi" if
+ * there is a 'v' in our name, and "edit" if there is a 'd' in our
+ * name. For edit we just diddle options; for vi we actually
+ * force an early visual command, setting the external initev so
+ * the q command in visual doesn't give command mode.
+ */
+main(ac, av)
+ register int ac;
+ register char *av[];
+{
+ char *erpath = EXSTRINGS;
+ register char *cp;
+ register int c;
+ bool recov = 0;
+ bool ivis = any('v', av[0]);
+ bool itag = 0;
+ bool fast = 0;
+#ifdef TRACE
+ register char *tracef;
+#endif
+
+ /*
+ * Immediately grab the tty modes so that we wont
+ * get messed up if an interrupt comes in quickly.
+ */
+ gTTY(1);
+ normf = tty.sg_flags;
+
+ /*
+ * For debugging take files out of . if name is a.out.
+ * If a 'd' in our name, then set options for edit.
+ */
+ if (av[0][0] == 'a')
+ erpath += 9;
+ if (ivis) {
+ options[MAGIC].odefault = value(MAGIC) = 0;
+ options[BEAUTIFY].odefault = value(BEAUTIFY) = 1;
+ } else if (any('d', av[0])) {
+ value(OPEN) = 0;
+ value(REPORT) = 1;
+ value(MAGIC) = 0;
+ }
+
+ /*
+ * Open the error message file.
+ */
+ draino();
+ erfile = open(erpath, 0);
+ if (erfile < 0) {
+ flush();
+ exit(1);
+ }
+ pstop();
+
+ /*
+ * Initialize interrupt handling.
+ */
+ oldhup = signal(SIGHUP, SIG_IGN);
+ if (oldhup == SIG_DFL)
+ signal(SIGHUP, onhup);
+ oldquit = signal(SIGQUIT, SIG_IGN);
+ ruptible = signal(SIGINT, SIG_IGN) == SIG_DFL;
+ if (signal(SIGTERM, SIG_IGN) == SIG_DFL)
+ signal(SIGTERM, onhup);
+
+ /*
+ * Initialize end of core pointers.
+ * Normally we avoid breaking back to fendcore after each
+ * file since this can be expensive (much core-core copying).
+ * If your system can scatter load processes you could do
+ * this as ed does, saving a little core, but it will probably
+ * not often make much difference.
+ */
+ fendcore = (line *) sbrk(0);
+ endcore = fendcore - 2;
+
+ /*
+ * Process flag arguments.
+ */
+ ac--, av++;
+ while (ac && av[0][0] == '-') {
+ c = av[0][1];
+ if (c == 0) {
+ hush = 1;
+ value(AUTOPRINT) = 0;
+ fast++;
+ } else switch (c) {
+
+#ifdef TRACE
+ case 'T':
+ if (av[0][2] == 0)
+ tracef = "trace";
+ else {
+ tracef = tttrace;
+ tracef[8] = av[0][2];
+ if (tracef[8])
+ tracef[9] = av[0][3];
+ else
+ tracef[9] = 0;
+ }
+ trace = fopen(tracef, "w");
+ if (trace == NULL)
+ printf("Trace create error\n");
+ setbuf(trace, tracbuf);
+ break;
+
+#endif
+
+#ifdef LISP
+ case 'l':
+ value(LISP) = 1;
+ value(SHOWMATCH) = 1;
+ break;
+#endif
+
+ case 'r':
+ recov++;
+ break;
+
+ case 't':
+ if (ac > 1 && av[1][0] != '-') {
+ ac--, av++;
+ itag = 1;
+ /* BUG: should check for too long tag. */
+ CP(lasttag, av[0]);
+ }
+ break;
+
+ case 'v':
+ globp = "";
+ ivis = 1;
+ break;
+
+ default:
+ smerror("Unknown option %s\n", av[0]);
+ break;
+ }
+ ac--, av++;
+ }
+ if (ac && av[0][0] == '+') {
+ firstln = getn(av[0] + 1);
+ if (firstln == 0)
+ firstln = 20000;
+ ac--, av++;
+ }
+
+ /*
+ * If we are doing a recover and no filename
+ * was given, then execute an exrecover command with
+ * the -r option to type out the list of saved file names.
+ * Otherwise set the remembered file name to the first argument
+ * file name so the "recover" initial command will find it.
+ */
+ if (recov) {
+ if (ac == 0) {
+ die++;
+ setrupt();
+ execl(EXRECOVER, "exrecover", "-r", 0);
+ filioerr(EXRECOVER);
+ exit(1);
+ }
+ CP(savedfile, *av++), ac--;
+ }
+
+ /*
+ * Initialize the argument list.
+ */
+ argv0 = av;
+ argc0 = ac;
+ args0 = av[0];
+ erewind();
+
+ /*
+ * Initialize a temporary file (buffer) and
+ * set up terminal environment. Read user startup commands.
+ */
+ init();
+ if (setexit() == 0) {
+ setrupt();
+ intty = isatty(0);
+ if (fast || !intty)
+ setterm("dumb");
+ else {
+ gettmode();
+ if ((cp = getenv("TERM")) != 0)
+ setterm(cp);
+ if ((cp = getenv("HOME")) != 0)
+ source(strcat(strcpy(genbuf, cp), "/.exrc"), 1);
+ }
+ }
+
+ /*
+ * Initial processing. Handle tag, recover, and file argument
+ * implied next commands. If going in as 'vi', then don't do
+ * anything, just set initev so we will do it later (from within
+ * visual).
+ */
+ if (setexit() == 0) {
+ if (recov)
+ globp = "recover";
+ else if (itag)
+ globp = ivis ? "tag" : "tag|p";
+ else if (argc)
+ globp = "next";
+ if (ivis)
+ initev = globp;
+ else if (globp) {
+ inglobal = 1;
+ commands(1, 1);
+ inglobal = 0;
+ }
+ }
+
+ /*
+ * Vi command... go into visual.
+ * Strange... everything in vi usually happens
+ * before we ever "start".
+ */
+ if (ivis) {
+ /*
+ * Don't have to be upward compatible with stupidity
+ * of starting editing at line $.
+ */
+ if (dol > zero)
+ dot = one;
+ globp = "visual";
+ if (setexit() == 0)
+ commands(1, 1);
+ }
+
+ /*
+ * Clear out trash in state accumulated by startup,
+ * and then do the main command loop for a normal edit.
+ * If you quit out of a 'vi' command by doing Q or ^\,
+ * you also fall through to here.
+ */
+ ungetchar(0);
+ globp = 0;
+ initev = 0;
+ setlastchar('\n');
+ setexit();
+ commands(0, 0);
+ cleanup(1);
+ exit(0);
+}
+
+/*
+ * Initialization, before editing a new file.
+ * Main thing here is to get a new buffer (in fileinit),
+ * rest is peripheral state resetting.
+ */
+init()
+{
+ register int i;
+
+ fileinit();
+ dot = zero = truedol = unddol = dol = fendcore;
+ one = zero+1;
+ undkind = UNDNONE;
+ chng = 0;
+ edited = 0;
+ for (i = 0; i <= 'z'-'a'+1; i++)
+ names[i] = 1;
+ anymarks = 0;
+}
+
+/*
+ * When a hangup occurs our actions are similar to a preserve
+ * command. If the buffer has not been [Modified], then we do
+ * nothing but remove the temporary files and exit.
+ * Otherwise, we sync the temp file and then attempt a preserve.
+ * If the preserve succeeds, we unlink our temp files.
+ * If the preserve fails, we leave the temp files as they are
+ * as they are a backup even without preservation if they
+ * are not removed.
+ */
+onhup()
+{
+
+ if (chng == 0) {
+ cleanup(1);
+ exit(0);
+ }
+ if (setexit() == 0) {
+ if (preserve()) {
+ cleanup(1);
+ exit(0);
+ }
+ }
+ exit(1);
+}
+
+/*
+ * An interrupt occurred. Drain any output which
+ * is still in the output buffering pipeline.
+ * Catch interrupts again. Unless we are in visual
+ * reset the output state (out of -nl mode, e.g).
+ * Then like a normal error (with the \n before Interrupt
+ * suppressed in visual mode).
+ */
+onintr()
+{
+
+#ifdef V6
+ signal(SIGINT, onintr);
+#else
+ signal(SIGINT, inopen ? vintr : onintr);
+#endif
+ draino();
+ if (!inopen) {
+ pstop();
+ setlastchar('\n');
+#ifndef V6
+ }
+#else
+ } else
+ vraw();
+#endif
+ error("\nInterrupt" + inopen);
+}
+
+/*
+ * If we are interruptible, enable interrupts again.
+ * In some critical sections we turn interrupts off,
+ * but not very often.
+ */
+setrupt()
+{
+
+ if (ruptible)
+#ifdef V6
+ signal(SIGINT, onintr);
+#else
+ signal(SIGINT, inopen ? vintr : onintr);
+#endif
+}
+
+preserve()
+{
+
+ synctmp();
+ pid = fork();
+ if (pid < 0)
+ return (0);
+ if (pid == 0) {
+ close(0);
+ dup(tfile);
+ execl(EXPRESERVE, "expreserve", (char *) 0);
+ exit(1);
+ }
+ waitfor();
+ if (rpid == pid && status == 0)
+ return (1);
+ return (0);
+}
+
+#ifndef V6
+exit(i)
+ int i;
+{
+
+ _exit(i);
+}
+#endif
projects / unix-history / commitdiff