/* Copyright (c) 1980 Regents of the University of California */

/*

static char *sccsid = "%W% %G%";

*/

#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_unix.c Routines for the ! command and its variations.

*

* 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", "vi"

* or "view" and the distinction is made here. Actually, we are "vi" if

* there is a 'v' in our name, "view" is there is a 'w', 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.

*/

int

main(int ac, char **av)

{

#ifndef VMUNIX

char *erpath = EXSTRINGS;

#endif

register char *cp;

register int c;

bool recov = 0;

bool ivis;

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);

#ifndef USG3TTY

normf = tty.sg_flags;

#else

normf = tty;

#endif

ppid = getpid();

/*

* Defend against d's, v's, w's, and a's in directories of

* path leading to our true name.

*/

av[0] = tailpath(av[0]);

/*

* Figure out how we were invoked: ex, edit, vi, view.

*/

ivis = any('v', av[0]); /* "vi" */

if (any('w', av[0])) /* "view" */

value(READONLY) = 1;

if (any('d', av[0])) { /* "edit" */

value(OPEN) = 0;

value(REPORT) = 1;

value(MAGIC) = 0;

}

#ifndef VMUNIX

/*

* For debugging take files out of . if name is a.out.

*/

if (av[0][0] == 'a')

erpath = tailpath(erpath);

#endif

/*

* Open the error message file.

*/

draino();

#ifndef VMUNIX

erfile = open(erpath+4, O_RDONLY);

if (erfile < 0) {

erfile = open(erpath, O_RDONLY);

}

#endif

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);

#ifdef SIGEMT

if (signal(SIGEMT, SIG_IGN) == SIG_DFL)

signal(SIGEMT, onemt);

#endif

/*

* 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.

*/

#ifdef UNIX_SBRK

fendcore = (line *) sbrk(0);

endcore = fendcore - 2;

#else

# define LINELIMIT 0x8000

fendcore = malloc(LINELIMIT * sizeof(line *));

endcore = fendcore + LINELIMIT - 1;

#endif

/*

* 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) {

case 'R':

value(READONLY) = 1;

break;

#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)

ex_printf("Trace create error\n");

setbuf(trace, tracbuf);

break;

#endif

#ifdef LISPCODE

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':

ivis = 1;

break;

case 'w':

defwind = 0;

if (av[0][2] == 0) defwind = 3;

else for (cp = &av[0][2]; isdigit((int)*cp); cp++)

defwind = 10*defwind + *cp - '0';

break;

#ifdef CRYPT

case 'x':

/* -x: encrypted mode */

xflag = 1;

break;

#endif

default:

smerror("Unknown option %s\n", av[0]);

break;

}

ac--, av++;

}

#ifdef SIGTSTP

if (!hush && signal(SIGTSTP, SIG_IGN) == SIG_DFL)

signal(SIGTSTP, onsusp), dosusp++;

#endif

if (ac && av[0][0] == '+') {

firstpat = &av[0][1];

ac--, av++;

}

#ifdef CRYPT

if(xflag){

key = getpass(KEYPROMPT);

kflag = crinit(key, perm);

}

#endif

/*

* 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) {

ppid = 0;

setrupt();

execl(EXRECOVER, "exrecover", "-r", NULL);

filioerr(EXRECOVER);

ex_exit(1);

}

CP(savedfile, *av);

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.

*/

if (setexit() == 0) {

setrupt();

intty = isatty(0);

value(PROMPT) = intty;

if ((cp = getenv("SHELL")))

CP(shell, cp);

if (fast || !intty)

setterm("dumb");

else {

gettmode();

if ((cp = getenv("TERM")) != 0 && *cp)

setterm(cp);

}

}

if (setexit() == 0 && !fast && intty) {

if ((globp = getenv("EXINIT")) && *globp)

commands(1,1);

else {

globp = 0;

if ((cp = getenv("HOME")) != 0 && *cp)

source(strcat(strcpy(genbuf, cp), "/.exrc"), 1);

}

}

init(); /* moved after prev 2 chunks to fix directory option */

/*

* 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.

*/

seenprompt = 1;

ungetchar(0);

globp = 0;

initev = 0;

setlastchar('\n');

setexit();

commands(0, 0);

cleanup(1);

return 0;

}

/*

* Initialization, before editing a new file.

* Main thing here is to get a new buffer (in fileinit),

* rest is peripheral state resetting.

*/

void

init(void)

{

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;

#ifdef CRYPT

if(xflag) {

xtflag = 1;

makekey(key, tperm);

}

#endif

}

/*

* 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.

*/

void

onhup(int i)

{

(void)i;

/*

* USG tty driver can send multiple HUP's!!

*/

signal(SIGINT, SIG_IGN);

signal(SIGHUP, SIG_IGN);

if (chng == 0) {

cleanup(1);

ex_exit(0);

}

if (setexit() == 0) {

if (preserve()) {

cleanup(1);

ex_exit(0);

}

}

ex_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).

*/

void

onintr(int i)

{

char *s = "\nInterrupt";

(void)i;

#ifndef CBREAK

signal(SIGINT, onintr);

#else

signal(SIGINT, inopen ? vintr : onintr);

#endif

draino();

if (!inopen) {

pstop();

setlastchar('\n');

#ifdef CBREAK

}

#else

} else

vraw();

#endif

error(inopen ? s + 1 : s);

}

/*

* If we are interruptible, enable interrupts again.

* In some critical sections we turn interrupts off,

* but not very often.

*/

void

setrupt(void)

{

if (ruptible) {

#ifndef CBREAK

signal(SIGINT, onintr);

#else

signal(SIGINT, inopen ? vintr : onintr);

#endif

#ifdef SIGTSTP

if (dosusp)

signal(SIGTSTP, onsusp);

#endif

}

}

int

preserve(void)

{

#ifdef VMUNIX

tflush();

#endif

synctmp();

pid = fork();

if (pid < 0)

return (0);

if (pid == 0) {

close(0);

dup(tfile);

execl(EXPRESERVE, "expreserve", (char *) 0);

ex_exit(1);

}

waitfor();

if (rpid == pid && status == 0)

return (1);

return (0);

}

#ifndef V6

void

ex_exit(int i)

{

# ifdef TRACE

if (trace)

fclose(trace);

# endif

_exit(i);

}

#endif

/*

* Return last component of unix path name p.

*/

char *

tailpath(char *p)

{

register char *r;

for (r=p; *p; p++)

if (*p == '/')

r = p+1;

return(r);

}