v09i039: MicroEMACS 3.8b, Part07/14

[sources...@mirror.uucp]

Submitted by: ihnp4!itivax!duncan!lawrence (Daniel Lawrence)
Mod.sources: Volume 9, Issue 39
Archive-name: uemacs3.8b/Part07

#! /bin/sh
# This is a shell archive. Remove anything before this line,
# then unpack it by saving it in a file and typing "sh file".
# If this archive is complete, you will see the message:
# "End of archive 7 (of 14)."
# Contents: exec.c spawn.c window.c
# Wrapped by rs@mirror on Fri Mar 13 13:24:22 1987
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
echo shar: Extracting \"exec.c\" \(16413 characters\)
if test -f exec.c ; then
echo shar: Will not over-write existing file \"exec.c\"
else
sed "s/^X//" >exec.c <<'END_OF_exec.c'
X/* This file is for functions dealing with execution of
X commands, command lines, buffers, files and startup files
X
X written 1986 by Daniel Lawrence */
X
X#include <stdio.h>
X#include "estruct.h"
X#include "edef.h"
X
X#if MEGAMAX & ST520
Xoverlay "exec"
X#endif
X
X#if DEBUGM
Xchar outline[NSTRING]; /* global string to hold debug line text */
X#endif
X
X/* namedcmd: execute a named command even if it is not bound */
X
Xnamedcmd(f, n)
X
Xint f, n; /* command arguments [passed through to command executed] */
X
X{
X register (*kfunc)(); /* ptr to the requexted function to bind to */
X int (*getname())();
X
X /* prompt the user to type a named command */
X mlwrite(": ");
X
X /* and now get the function name to execute */
X kfunc = getname();
X if (kfunc == NULL) {
X mlwrite("[No such function]");
X return(FALSE);
X }
X
X /* and then execute the command */
X return((*kfunc)(f, n));
X}
X
X/* execcmd: Execute a command line command to be typed in
X by the user */
X
Xexeccmd(f, n)
X
Xint f, n; /* default Flag and Numeric argument */
X
X{
X register int status; /* status return */
X char cmdstr[NSTRING]; /* string holding command to execute */
X
X /* get the line wanted */
X if ((status = mlreply(": ", cmdstr, NSTRING)) != TRUE)
X return(status);
X
X execlevel = 0;
X return(docmd(cmdstr));
X}
X
X/* docmd: take a passed string as a command line and translate
X it to be executed as a command. This function will be
X used by execute-command-line and by all source and
X startup files. Lastflag/thisflag is also updated.
X
X format of the command line is:
X
X {# arg} <command-name> {<argument string(s)>}
X
X Directives start with a "!" and include:
X
X !endm End a macro
X !if (cond) conditional execution
X !else
X !endif
X !return Return (terminating current macro)
X !goto <label> Jump to a label in the current macro
X
X Line Labels begin with a "*" in column 1, like:
X
X *LBL01
X*/
X
Xdocmd(cline)
X
Xchar *cline; /* command line to execute */
X
X{
X register int f; /* default argument flag */
X register int n; /* numeric repeat value */
X register int i;
X int (*fnc)(); /* function to execute */
X int status; /* return status of function */
X int oldcle; /* old contents of clexec flag */
X int llen; /* length of cline */
X int force; /* force TRUE result? */
X char *tmp; /* tmp pointer into cline */
X struct LINE *lp; /* a line pointer */
X char *oldestr; /* original exec string */
X char token[NSTRING]; /* next token off of command line */
X int (*fncmatch())();
X#if DEBUGM
X /* if $debug == TRUE, every line to execute
X gets echoed and a key needs to be pressed to continue
X ^G will abort the command */
X register char *sp; /* pointer into buf to expand %s */
X
X if (macbug) {
X strcpy(outline, "<<<");
X#if 1 /* debug if levels */
X strcat(outline, itoa(execlevel));
X strcat(outline, ":");
X#endif
X strcat(outline, cline);
X strcat(outline, ">>>");
X
X /* change all '%' to ':' so mlwrite won't expect arguments */
X sp = outline;
X while (*sp) {
X if (*sp++ == '%')
X *(sp-1) = ':';
X }
X
X /* write out the debug line */
X mlwrite(outline);
X update(TRUE);
X
X /* and get the keystroke */
X if (tgetc() == 7) {
X mlwrite("[Macro aborted]");
X return(FALSE);
X }
X }
X#endif
X
X /* dump comments and labels here */
X if (*cline == ';' || *cline == '*')
X return(TRUE);
X
X /* eat leading spaces */
X while (*cline == ' ' || *cline == '\t')
X ++cline;
X
X /* check to see if this line turns macro storage off */
X if (cline[0] == '!' && strncmp(&cline[1], "endm", 4) == 0) {
X mstore = FALSE;
X bstore = NULL;
X return(TRUE);
X }
X
X /* if macro store is on, just salt this away */
X if (mstore) {
X /* allocate the space for the line */
X llen = strlen(cline);
X if ((lp=lalloc(llen)) == NULL) {
X mlwrite("Out of memory while storing macro");
X return (FALSE);
X }
X
X /* copy the text into the new line */
X for (i=0; i<llen; ++i)
X lputc(lp, i, cline[i]);
X
X /* attach the line to the end of the buffer */
X bstore->b_linep->l_bp->l_fp = lp;
X lp->l_bp = bstore->b_linep->l_bp;
X bstore->b_linep->l_bp = lp;
X lp->l_fp = bstore->b_linep;
X return (TRUE);
X }
X
X force = FALSE;
X oldestr = execstr; /* save last ptr to string to execute */
X execstr = cline; /* and set this one as current */
X
X /* process directives */
X if (*cline == '!') {
X /* save directive location and skip it */
X tmp = cline;
X while (*execstr && *execstr != ' ' && *execstr != '\t')
X ++execstr;
X
X if (tmp[1] == 'f' && tmp[2] == 'o') {
X force = TRUE;
X goto do001;
X
X } else if (tmp[1] == 'i' && tmp[2] == 'f') {
X
X /* IF directive */
X /* grab the value of the logical exp */
X if (execlevel == 0) {
X if ((status = macarg(token)) != TRUE) {
X execstr = oldestr;
X return(status);
X }
X status = stol(token);
X } else
X status = TRUE;
X
X if (status) {
X
X /* IF (TRUE) */
X if (execlevel != 0)
X ++execlevel;
X } else {
X
X /* IF (FALSE) */
X ++execlevel;
X }
X
X } else if (tmp[1] == 'e' && tmp[2] == 'l') {
X
X /* ELSE directive */
X if (execlevel == 1)
X --execlevel;
X else if (execlevel == 0 )
X ++execlevel;
X
X } else if (tmp[1] == 'e' && tmp[2] == 'n') {
X
X /* ENDIF directive */
X if (execlevel)
X --execlevel;
X
X } else if (tmp[1] == 'r' && tmp[2] == 'e') {
X
X /* RETURN directive */
X execstr = oldestr;
X return(RET);
X
X } else if (tmp[1] == 'g' && tmp[2] == 'o') {
X
X /* GOTO directive */
X /* .....only if we are currently executing */
X if (execlevel) {
X execstr = oldestr;
X return(TRUE);
X }
X
X while (*execstr == ' ' || *execstr == '\t')
X ++execstr;
X strncpy(golabel, execstr, NPAT - 1);
X return(GOLINE);
X
X } else {
X mlwrite("%%Unknown Directive");
X return(FALSE);
X }
X
X /* restore execstr and exit */
X execstr = oldestr;
X return(TRUE);
X }
X
Xdo001: /* if we are scanning and not executing..go back here */
X if (execlevel) {
X execstr = oldestr;
X return(TRUE);
X }
X
X /* first set up the default command values */
X f = FALSE;
X n = 1;
X lastflag = thisflag;
X thisflag = 0;
X
X if ((status = macarg(token)) != TRUE) { /* and grab the first token */
X execstr = oldestr;
X return(status);
X }
X
X /* process leadin argument */
X if (gettyp(token) != TKCMD) {
X f = TRUE;
X n = atoi(getval(token));
X
X /* and now get the command to execute */
X if ((status = macarg(token)) != TRUE) {
X execstr = oldestr;
X return(status);
X }
X }
X
X /* and match the token to see if it exists */
X if ((fnc = fncmatch(token)) == NULL) {
X mlwrite("[No such Function]");
X execstr = oldestr;
X return(FALSE);
X }
X
X /* save the arguments and go execute the command */
X oldcle = clexec; /* save old clexec flag */
X clexec = TRUE; /* in cline execution */
X status = (*fnc)(f, n); /* call the function */
X cmdstatus = status; /* save the status */
X if (force) /* force the status */
X status = TRUE;
X clexec = oldcle; /* restore clexec flag */
X execstr = oldestr;
X return(status);
X}
X
X/* token: chop a token off a string
X return a pointer past the token
X*/
X
Xchar *token(src, tok)
X
Xchar *src, *tok; /* source string, destination token string */
X
X{
X register int quotef; /* is the current string quoted? */
X
X /* first scan past any whitespace in the source string */
X while (*src == ' ' || *src == '\t')
X ++src;
X
X /* scan through the source string */
X quotef = FALSE;
X while (*src) {
X /* process special characters */
X if (*src == '~') {
X ++src;
X if (*src == 0)
X break;
X switch (*src++) {
X case 'r': *tok++ = 13; break;
X case 'n': *tok++ = 10; break;
X case 't': *tok++ = 9; break;
X case 'b': *tok++ = 8; break;
X case 'f': *tok++ = 12; break;
X default: *tok++ = *(src-1);
X }
X } else {
X /* check for the end of the token */
X if (quotef) {
X if (*src == '"')
X break;
X } else {
X if (*src == ' ' || *src == '\t')
X break;
X }
X
X /* set quote mode if qoute found */
X if (*src == '"')
X quotef = TRUE;
X
X /* record the character */
X *tok++ = *src++;
X }
X }
X
X /* terminate the token and exit */
X if (*src)
X ++src;
X *tok = 0;
X return(src);
X}
X
Xmacarg(tok) /* get a macro line argument */
X
Xchar *tok; /* buffer to place argument */
X
X{
X int savcle; /* buffer to store original clexec */
X int status;
X
X savcle = clexec; /* save execution mode */
X clexec = TRUE; /* get the argument */
X status = nextarg("", tok, NSTRING, ctoec('\n'));
X clexec = savcle; /* restore execution mode */
X return(status);
X}
X
X/* nextarg: get the next argument */
X
Xnextarg(prompt, buffer, size, terminator)
X
Xchar *prompt; /* prompt to use if we must be interactive */
Xchar *buffer; /* buffer to put token into */
Xchar *size; /* size of the buffer */
Xint terminator; /* terminating char to be used on interactive fetch */
X
X{
X /* if we are interactive, go get it! */
X if (clexec == FALSE)
X return(getstring(prompt, buffer, size, terminator));
X
X /* grab token and advance past */
X execstr = token(execstr, buffer);
X
X /* evaluate it */
X strcpy(buffer, getval(buffer));
X return(TRUE);
X}
X
X/* storemac: Set up a macro buffer and flag to store all
X executed command lines there */
X
Xstoremac(f, n)
X
Xint f; /* default flag */
Xint n; /* macro number to use */
X
X{
X register struct BUFFER *bp; /* pointer to macro buffer */
X char bname[NBUFN]; /* name of buffer to use */
X
X /* must have a numeric argument to this function */
X if (f == FALSE) {
X mlwrite("No macro specified");
X return(FALSE);
X }
X
X /* range check the macro number */
X if (n < 1 || n > 40) {
X mlwrite("Macro number out of range");
X return(FALSE);
X }
X
X /* construct the macro buffer name */
X strcpy(bname, "[Macro xx]");
X bname[7] = '0' + (n / 10);
X bname[8] = '0' + (n % 10);
X
X /* set up the new macro buffer */
X if ((bp = bfind(bname, TRUE, BFINVS)) == NULL) {
X mlwrite("Can not create macro");
X return(FALSE);
X }
X
X /* and make sure it is empty */
X bclear(bp);
X
X /* and set the macro store pointers to it */
X mstore = TRUE;
X bstore = bp;
X return(TRUE);
X}
X
X/* execbuf: Execute the contents of a buffer of commands */
X
Xexecbuf(f, n)
X
Xint f, n; /* default flag and numeric arg */
X
X{
X register BUFFER *bp; /* ptr to buffer to execute */
X register int status; /* status return */
X char bufn[NBUFN]; /* name of buffer to execute */
X
X /* find out what buffer the user wants to execute */
X if ((status = mlreply("Execute buffer: ", bufn, NBUFN)) != TRUE)
X return(status);
X
X /* find the pointer to that buffer */
X if ((bp=bfind(bufn, FALSE, 0)) == NULL) {
X mlwrite("No such buffer");
X return(FALSE);
X }
X
X /* and now execute it as asked */
X while (n-- > 0)
X if ((status = dobuf(bp)) != TRUE)
X return(status);
X return(TRUE);
X}
X
X/* dobuf: execute the contents of the buffer pointed to
X by the passed BP */
X
Xdobuf(bp)
X
XBUFFER *bp; /* buffer to execute */
X
X{
X register int status; /* status return */
X register LINE *lp; /* pointer to line to execute */
X register LINE *hlp; /* pointer to line header */
X register LINE *glp; /* line to goto */
X register int linlen; /* length of line to execute */
X register WINDOW *wp; /* ptr to windows to scan */
X char *eline; /* text of line to execute */
X
X /* clear IF level flags */
X execlevel = 0;
X
X /* starting at the beginning of the buffer */
X hlp = bp->b_linep;
X lp = hlp->l_fp;
X while (lp != hlp) {
X /* allocate eline and copy macro line to it */
X linlen = lp->l_used;
X if ((eline = malloc(linlen+1)) == NULL) {
X mlwrite("%%Out of Memory during macro execution");
X return(FALSE);
X }
X strncpy(eline, lp->l_text, linlen);
X eline[linlen] = 0; /* make sure it ends */
X
X /* trim leading whitespace */
X while (eline[0] == ' ' || eline[0] == '\t')
X strcpy(eline, &eline[1]);
X
X /* if it is not a comment, execute it */
X if (eline[0] != 0 && eline[0] != ';') {
X status = docmd(eline);
X
X /* if it is a !GOTO directive, deal with it */
X if (status == GOLINE) {
X linlen = strlen(golabel);
X glp = hlp->l_fp;
X while (glp != hlp) {
X if (*glp->l_text == '*' &&
X (strncmp(&glp->l_text[1], golabel,
X linlen) == 0)) {
X lp = glp;
X status = TRUE;
X }
X glp = glp->l_fp;
X }
X }
X
X if (status == GOLINE) {
X mlwrite("%%No such label");
X return(FALSE);
X }
X
X /* if it is a !RETURN directive...do so */
X if (status == RET) {
X free(eline);
X break;
X }
X
X /* check for a command error */
X if (status != TRUE) {
X /* look if buffer is showing */
X wp = wheadp;
X while (wp != NULL) {
X if (wp->w_bufp == bp) {
X /* and point it */
X wp->w_dotp = lp;
X wp->w_doto = 0;
X wp->w_flag |= WFHARD;
X }
X wp = wp->w_wndp;
X }
X /* in any case set the buffer . */
X bp->b_dotp = lp;
X bp->b_doto = 0;
X free(eline);
X execlevel = 0;
X return(status);
X }
X }
X
X /* on to the next line */
X free(eline);
X lp = lp->l_fp;
X }
X
X /* exit the current function */
X execlevel = 0;
X return(TRUE);
X}
X
Xexecfile(f, n) /* execute a series of commands in a file
X*/
X
Xint f, n; /* default flag and numeric arg to pass on to file */
X
X{
X register int status; /* return status of name query */
X char *fname[NSTRING]; /* name of file to execute */
X
X if ((status = mlreply("File to execute: ", fname, NSTRING -1)) != TRUE)
X return(status);
X
X /* otherwise, execute it */
X while (n-- > 0)
X if ((status=dofile(fname)) != TRUE)
X return(status);
X
X return(TRUE);
X}
X
X/* dofile: yank a file into a buffer and execute it
X if there are no errors, delete the buffer on exit */
X
Xdofile(fname)
X
Xchar *fname; /* file name to execute */
X
X{
X register BUFFER *bp; /* buffer to place file to exeute */
X register BUFFER *cb; /* temp to hold current buf while we read */
X register int status; /* results of various calls */
X char bname[NBUFN]; /* name of buffer */
X
X makename(bname, fname); /* derive the name of the buffer */
X if ((bp = bfind(bname, TRUE, 0)) == NULL) /* get the needed buffer */
X return(FALSE);
X
X bp->b_mode = MDVIEW; /* mark the buffer as read only */
X cb = curbp; /* save the old buffer */
X curbp = bp; /* make this one current */
X /* and try to read in the file to execute */
X if ((status = readin(fname, FALSE)) != TRUE) {
X curbp = cb; /* restore the current buffer */
X return(status);
X }
X
X /* go execute it! */
X curbp = cb; /* restore the current buffer */
X if ((status = dobuf(bp)) != TRUE)
X return(status);
X
X /* if not displayed, remove the now unneeded buffer and exit */
X if (bp->b_nwnd == 0)
X zotbuf(bp);
X return(TRUE);
X}
X
X/* cbuf: Execute the contents of a numbered buffer */
X
Xcbuf(f, n, bufnum)
X
Xint f, n; /* default flag and numeric arg */
Xint bufnum; /* number of buffer to execute */
X
X{
X register BUFFER *bp; /* ptr to buffer to execute */
X register int status; /* status return */
X static char bufname[] = "[Macro xx]";
X
X /* make the buffer name */
X bufname[7] = '0' + (bufnum / 10);
X bufname[8] = '0' + (bufnum % 10);
X
X /* find the pointer to that buffer */
X if ((bp=bfind(bufname, FALSE, 0)) == NULL) {
X mlwrite("Macro not defined");
X return(FALSE);
X }
X
X /* and now execute it as asked */
X while (n-- > 0)
X if ((status = dobuf(bp)) != TRUE)
X return(status);
X return(TRUE);
X}
X
Xcbuf1(f, n)
X
X{
X cbuf(f, n, 1);
X}
X
Xcbuf2(f, n)
X
X{
X cbuf(f, n, 2);
X}
X
Xcbuf3(f, n)
X
X{
X cbuf(f, n, 3);
X}
X
Xcbuf4(f, n)
X
X{
X cbuf(f, n, 4);
X}
X
Xcbuf5(f, n)
X
X{
X cbuf(f, n, 5);
X}
X
Xcbuf6(f, n)
X
X{
X cbuf(f, n, 6);
X}
X
Xcbuf7(f, n)
X
X{
X cbuf(f, n, 7);
X}
X
Xcbuf8(f, n)
X
X{
X cbuf(f, n, 8);
X}
X
Xcbuf9(f, n)
X
X{
X cbuf(f, n, 9);
X}
X
Xcbuf10(f, n)
X
X{
X cbuf(f, n, 10);
X}
X
Xcbuf11(f, n)
X
X{
X cbuf(f, n, 11);
X}
X
Xcbuf12(f, n)
X
X{
X cbuf(f, n, 12);
X}
X
Xcbuf13(f, n)
X
X{
X cbuf(f, n, 13);
X}
X
Xcbuf14(f, n)
X
X{
X cbuf(f, n, 14);
X}
X
Xcbuf15(f, n)
X
X{
X cbuf(f, n, 15);
X}
X
Xcbuf16(f, n)
X
X{
X cbuf(f, n, 16);
X}
X
Xcbuf17(f, n)
X
X{
X cbuf(f, n, 17);
X}
X
Xcbuf18(f, n)
X
X{
X cbuf(f, n, 18);
X}
X
Xcbuf19(f, n)
X
X{
X cbuf(f, n, 19);
X}
X
Xcbuf20(f, n)
X
X{
X cbuf(f, n, 20);
X}
X
Xcbuf21(f, n)
X
X{
X cbuf(f, n, 21);
X}
X
Xcbuf22(f, n)
X
X{
X cbuf(f, n, 22);
X}
X
Xcbuf23(f, n)
X
X{
X cbuf(f, n, 23);
X}
X
Xcbuf24(f, n)
X
X{
X cbuf(f, n, 24);
X}
X
Xcbuf25(f, n)
X
X{
X cbuf(f, n, 25);
X}
X
Xcbuf26(f, n)
X
X{
X cbuf(f, n, 26);
X}
X
Xcbuf27(f, n)
X
X{
X cbuf(f, n, 27);
X}
X
Xcbuf28(f, n)
X
X{
X cbuf(f, n, 28);
X}
X
Xcbuf29(f, n)
X
X{
X cbuf(f, n, 29);
X}
X
Xcbuf30(f, n)
X
X{
X cbuf(f, n, 30);
X}
X
Xcbuf31(f, n)
X
X{
X cbuf(f, n, 31);
X}
X
Xcbuf32(f, n)
X
X{
X cbuf(f, n, 32);
X}
X
Xcbuf33(f, n)
X
X{
X cbuf(f, n, 33);
X}
X
Xcbuf34(f, n)
X
X{
X cbuf(f, n, 34);
X}
X
Xcbuf35(f, n)
X
X{
X cbuf(f, n, 35);
X}
X
Xcbuf36(f, n)
X
X{
X cbuf(f, n, 36);
X}
X
Xcbuf37(f, n)
X
X{
X cbuf(f, n, 37);
X}
X
Xcbuf38(f, n)
X
X{
X cbuf(f, n, 38);
X}
X
Xcbuf39(f, n)
X
X{
X cbuf(f, n, 39);
X}
X
Xcbuf40(f, n)
X
X{
X cbuf(f, n, 40);
X}
X
X
END_OF_exec.c
if test 16413 -ne `wc -c <exec.c`; then
echo shar: \"exec.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: Extracting \"spawn.c\" \(16459 characters\)
if test -f spawn.c ; then
echo shar: Will not over-write existing file \"spawn.c\"
else
sed "s/^X//" >spawn.c <<'END_OF_spawn.c'
X/* Spawn: various DOS access commands
X for MicroEMACS
X*/
X
X#include <stdio.h>
X#include "estruct.h"
X#include "edef.h"
X
X#if AMIGA
X#define NEW 1006
X#endif
X
X#if ST520
X#include <osbind.h>
X#include <string.h>
X#define LOAD_EXEC 0 /* load and execute the program */
Xchar *STcmd, /* the command filename & path */
X *STargs, /* command args (if any) */
X *STenv, /* environment */
X *STwork; /* work area */
X#endif
X
X#if VMS
X#define EFN 0 /* Event flag. */
X
X#include <ssdef.h> /* Random headers. */
X#include <stsdef.h>
X#include <descrip.h>
X#include <iodef.h>
X
Xextern int oldmode[3]; /* In "termio.c" */
Xextern int newmode[3]; /* In "termio.c" */
Xextern short iochan; /* In "termio.c" */
X#endif
X
X#if V7 | USG | BSD
X#include <signal.h>
Xextern int vttidy();
X#endif
X
X#if MSDOS & MSC
X#include <process.h>
X#define system(a) spawnlp(P_WAIT, a, NULL)
X#endif
X
X/*
X * Create a subjob with a copy of the command intrepreter in it. When the
X * command interpreter exits, mark the screen as garbage so that you do a full
X * repaint. Bound to "^X C". The message at the start in VMS puts out a newline.
X * Under some (unknown) condition, you don't get one free when DCL starts up.
X */
Xspawncli(f, n)
X{
X#if AMIGA
X long newcli;
X#endif
X
X#if V7 | USG | BSD
X register char *cp;
X char *getenv();
X#endif
X
X /* don't allow this command if restricted */
X if (restflag)
X return(resterr());
X
X#if AMIGA
X newcli = Open("CON:1/1/639/199/MicroEmacs Subprocess", NEW);
X mlwrite("[Starting new CLI]");
X sgarbf = TRUE;
X Execute("", newcli, 0);
X Close(newcli);
X return(TRUE);
X#endif
X
X#if VMS
X movecursor(term.t_nrow, 0); /* In last line. */
X mlputs("[Starting DCL]\r\n");
X TTflush(); /* Ignore "ttcol". */
X sgarbf = TRUE;
X return (sys(NULL)); /* NULL => DCL. */
X#endif
X#if CPM
X mlwrite("Not in CP/M-86");
X#endif
X#if ST520
X mlwrite("Not in TOS");
X#endif
X#if MSDOS & AZTEC
X movecursor(term.t_nrow, 0); /* Seek to last line. */
X TTflush();
X TTkclose();
X system("command.com");
X TTkopen();
X sgarbf = TRUE;
X return(TRUE);
X#endif
X#if MSDOS & LATTICE
X movecursor(term.t_nrow, 0); /* Seek to last line. */
X TTflush();
X TTkclose();
X sys("\\command.com", ""); /* Run CLI. */
X TTkopen();
X sgarbf = TRUE;
X return(TRUE);
X#endif
X#if V7 | USG | BSD
X movecursor(term.t_nrow, 0); /* Seek to last line. */
X TTflush();
X TTclose(); /* stty to old settings */
X if ((cp = getenv("SHELL")) != NULL && *cp != '\0')
X system(cp);
X else
X#if BSD
X system("exec /bin/csh");
X#else
X system("exec /bin/sh");
X#endif
X sgarbf = TRUE;
X sleep(2);
X TTopen();
X return(TRUE);
X#endif
X}
X
X#if BSD
X
Xbktoshell() /* suspend MicroEMACS and wait to wake up */
X{
X int pid;
X
X vttidy();
X pid = getpid();
X kill(pid,SIGTSTP);
X}
X
Xrtfrmshell()
X{
X TTopen();
X curwp->w_flag = WFHARD;
X sgarbf = TRUE;
X}
X#endif
X
X/*
X * Run a one-liner in a subjob. When the command returns, wait for a single
X * character to be typed, then mark the screen as garbage so a full repaint is
X * done. Bound to "C-X !".
X */
Xspawn(f, n)
X{
X register int s;
X char line[NLINE];
X
X#if ST520
X int i,j,k;
X char *sptr,*tptr;
X#endif
X
X#if AMIGA
X long newcli;
X#endif
X
X /* don't allow this command if restricted */
X if (restflag)
X return(resterr());
X
X#if AMIGA
X if ((s=mlreply("!", line, NLINE)) != TRUE)
X return (s);
X newcli = Open("CON:1/1/639/199/MicroEmacs Subprocess", NEW);
X Execute(line,0,newcli);
X Close(newcli);
X tgetc(); /* Pause. */
X sgarbf = TRUE;
X return(TRUE);
X#endif
X#if ST520
X if ((s=mlreply("!", line, NLINE)) != TRUE)
X return(s);
X movecursor(term.t_nrow - 1, 0);
X TTclose();
X/*
X * break the line into the command and its args
X * be cute about it, if there is no '.' in the filename, try
X * to find .prg, .tos or .ttp in that order
X * in any case check to see that the file exists before we run
X * amok
X */
X STenv = NULL;
X if((tptr = index(&line[0],' ')) == NULL) { /* no args */
X STcmd = (char *)malloc(strlen(line) + 1);
X strcpy(STcmd,line);
X STargs = NULL;
X }
X else { /* seperate out the args from the command */
X /* resist the temptation to do ptr arithmetic */
X STcmd = (char *)malloc(strlen(line) + 1);
X for(i = 0,sptr = &line[0]; sptr != tptr; sptr++,i++)
X STcmd[i] = *sptr;
X STcmd[i] = '\0';
X for(; *tptr == ' ' || *tptr == '\t'; tptr++);
X if(*tptr == '\0')
X STargs = NULL;
X else {
X STargs = (char *)malloc(strlen(tptr) + 2);
X/* first byte of STargs is the length of the string */
X STargs[0] = strlen(tptr);
X STargs[1] = NULL; /* fake it for strcat */
X strcat(STargs,tptr);
X }
X }
X/*
X * before we issue the command look for the '.', if it's not there
X * try adding .prg, .tos and .ttp to see if they exist, if not
X * issue the command as is
X */
X if((tptr = index(STcmd,'.')) == NULL) {
X STwork = (char *)malloc(strlen(STcmd) + 4);
X strcpy(STwork,STcmd);
X strcat(STwork,".prg");
X tptr = index(STwork,'.');
X if(Fsfirst(1,STwork) != 0) { /* try .tos */
X strcpy(tptr,".tos");
X if(Fsfirst(1,STwork) != 0) { /* try .ttp */
X strcpy(tptr,".ttp");
X if(Fsfirst(1,STwork) != 0) /* never mind */
X *STwork = NULL;
X }
X }
X }
X if(*STwork != NULL)
X Pexec(LOAD_EXEC,STwork,STargs,STenv);
X else
X Pexec(LOAD_EXEC,STcmd,STargs,STenv);
X TTopen();
X mlputs("\r\n\n[End]"); /* Pause. */
X TTgetc(); /* Pause. */
X sgarbf = TRUE;
X return (TRUE);
X#endif
X#if VMS
X if ((s=mlreply("!", line, NLINE)) != TRUE)
X return (s);
X TTputc('\n'); /* Already have '\r' */
X TTflush();
X s = sys(line); /* Run the command. */
X mlputs("\r\n\n[End]"); /* Pause. */
X TTflush();
X tgetc();
X sgarbf = TRUE;
X return (s);
X#endif
X#if CPM
X mlwrite("Not in CP/M-86");
X return (FALSE);
X#endif
X#if MSDOS
X if ((s=mlreply("!", line, NLINE)) != TRUE)
X return(s);
X movecursor(term.t_nrow - 1, 0);
X TTkclose();
X system(line);
X TTkopen();
X /* if we are interactive, pause here */
X if (clexec == FALSE) {
X mlputs("\r\n\n[End]");
X tgetc();
X }
X sgarbf = TRUE;
X return (TRUE);
X#endif
X#if V7 | USG | BSD
X if ((s=mlreply("!", line, NLINE)) != TRUE)
X return (s);
X TTputc('\n'); /* Already have '\r' */
X TTflush();
X TTclose(); /* stty to old modes */
X system(line);
X TTopen();
X mlputs("[End]"); /* Pause. */
X TTflush();
X while ((s = tgetc()) != '\r' && s != ' ')
X ;
X sgarbf = TRUE;
X return (TRUE);
X#endif
X}
X
X/*
X * Pipe a one line command into a window
X * Bound to ^X @
X */
Xpipe(f, n)
X{
X register int s; /* return status from CLI */
X register WINDOW *wp; /* pointer to new window */
X register BUFFER *bp; /* pointer to buffer to zot */
X char line[NLINE]; /* command line send to shell */
X static char bname[] = "command";
X
X#if AMIGA
X static char filnam[] = "ram:command";
X long newcli;
X#else
X static char filnam[] = "command";
X#endif
X
X#if MSDOS
X char *tmp;
X char *getenv();
X FILE *fp;
X FILE *fopen();
X#endif
X
X /* don't allow this command if restricted */
X if (restflag)
X return(resterr());
X
X#if MSDOS
X if ((tmp = getenv("TMP")) == NULL)
X strcpy(filnam, "command");
X else
X strcpy(filnam, tmp);
X#endif
X
X#if VMS
X mlwrite("Not availible under VMS");
X return(FALSE);
X#endif
X#if CPM
X mlwrite("Not availible under CP/M-86");
X return(FALSE);
X#endif
X
X /* get the command to pipe in */
X if ((s=mlreply("@", line, NLINE)) != TRUE)
X return(s);
X
X /* get rid of the command output buffer if it exists */
X if ((bp=bfind(bname, FALSE, 0)) != FALSE) {
X /* try to make sure we are off screen */
X wp = wheadp;
X while (wp != NULL) {
X if (wp->w_bufp == bp) {
X onlywind(FALSE, 1);
X break;
X }
X wp = wp->w_wndp;
X }
X if (zotbuf(bp) != TRUE)
X return(FALSE);
X }
X
X#if AMIGA
X newcli = Open("CON:1/1/639/199/MicroEmacs Subprocess", NEW);
X strcat(line, " >");
X strcat(line, filnam);
X Execute(line,0,newcli);
X s = TRUE;
X Close(newcli);
X sgarbf = TRUE;
X#endif
X#if MSDOS
X strcat(line," >>");
X strcat(line,filnam);
X movecursor(term.t_nrow - 1, 0);
X TTkclose();
X system(line);
X TTkopen();
X sgarbf = TRUE;
X if ((fp = fopen(filnam, "r")) == NULL) {
X s = FALSE;
X } else {
X fclose(fp);
X s = TRUE;
X }
X#endif
X#if V7 | USG | BSD
X TTputc('\n'); /* Already have '\r' */
X TTflush();
X TTclose(); /* stty to old modes */
X strcat(line,">");
X strcat(line,filnam);
X system(line);
X TTopen();
X TTflush();
X sgarbf = TRUE;
X s = TRUE;
X#endif
X
X if (s != TRUE)
X return(s);
X
X /* split the current window to make room for the command output */
X if (splitwind(FALSE, 1) == FALSE)
X return(FALSE);
X
X /* and read the stuff in */
X if (getfile(filnam, FALSE) == FALSE)
X return(FALSE);
X
X /* make this window in VIEW mode, update all mode lines */
X curwp->w_bufp->b_mode |= MDVIEW;
X wp = wheadp;
X while (wp != NULL) {
X wp->w_flag |= WFMODE;
X wp = wp->w_wndp;
X }
X
X /* and get rid of the temporary file */
X unlink(filnam);
X return(TRUE);
X}
X
X/*
X * filter a buffer through an external DOS program
X * Bound to ^X #
X */
Xfilter(f, n)
X
X{
X register int s; /* return status from CLI */
X register BUFFER *bp; /* pointer to buffer to zot */
X char line[NLINE]; /* command line send to shell */
X char tmpnam[NFILEN]; /* place to store real file name */
X static char bname1[] = "fltinp";
X
X#if AMIGA
X static char filnam1[] = "ram:fltinp";
X static char filnam2[] = "ram:fltout";
X long newcli;
X#else
X static char filnam1[] = "fltinp";
X static char filnam2[] = "fltout";
X#endif
X
X /* don't allow this command if restricted */
X if (restflag)
X return(resterr());
X
X if (curbp->b_mode&MDVIEW) /* don't allow this command if */
X return(rdonly()); /* we are in read only mode */
X
X#if VMS
X mlwrite("Not availible under VMS");
X return(FALSE);
X#endif
X#if CPM
X mlwrite("Not availible under CP/M-86");
X return(FALSE);
X#endif
X
X /* get the filter name and its args */
X if ((s=mlreply("#", line, NLINE)) != TRUE)
X return(s);
X
X /* setup the proper file names */
X bp = curbp;
X strcpy(tmpnam, bp->b_fname); /* save the original name */
X strcpy(bp->b_fname, bname1); /* set it to our new one */
X
X /* write it out, checking for errors */
X if (writeout(filnam1) != TRUE) {
X mlwrite("[Cannot write filter file]");
X strcpy(bp->b_fname, tmpnam);
X return(FALSE);
X }
X
X#if AMIGA
X newcli = Open("CON:1/1/639/199/MicroEmacs Subprocess", NEW);
X strcat(line, " <ram:fltinp >ram:fltout");
X Execute(line,0,newcli);
X s = TRUE;
X Close(newcli);
X sgarbf = TRUE;
X#endif
X#if MSDOS
X strcat(line," <fltinp >fltout");
X movecursor(term.t_nrow - 1, 0);
X TTkclose();
X system(line);
X TTkopen();
X sgarbf = TRUE;
X s = TRUE;
X#endif
X#if V7 | USG | BSD
X TTputc('\n'); /* Already have '\r' */
X TTflush();
X TTclose(); /* stty to old modes */
X strcat(line," <fltinp >fltout");
X system(line);
X TTopen();
X TTflush();
X sgarbf = TRUE;
X s = TRUE;
X#endif
X
X /* on failure, escape gracefully */
X if (s != TRUE || (readin(filnam2,FALSE) == FALSE)) {
X mlwrite("[Execution failed]");
X strcpy(bp->b_fname, tmpnam);
X unlink(filnam1);
X unlink(filnam2);
X return(s);
X }
X
X /* reset file name */
X strcpy(bp->b_fname, tmpnam); /* restore name */
X bp->b_flag |= BFCHG; /* flag it as changed */
X
X /* and get rid of the temporary file */
X unlink(filnam1);
X unlink(filnam2);
X return(TRUE);
X}
X
X#if VMS
X/*
X * Run a command. The "cmd" is a pointer to a command string, or NULL if you
X * want to run a copy of DCL in the subjob (this is how the standard routine
X * LIB$SPAWN works. You have to do wierd stuff with the terminal on the way in
X * and the way out, because DCL does not want the channel to be in raw mode.
X */
Xsys(cmd)
Xregister char *cmd;
X{
X struct dsc$descriptor cdsc;
X struct dsc$descriptor *cdscp;
X long status;
X long substatus;
X long iosb[2];
X
X status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
X oldmode, sizeof(oldmode), 0, 0, 0, 0);
X if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
X return (FALSE);
X cdscp = NULL; /* Assume DCL. */
X if (cmd != NULL) { /* Build descriptor. */
X cdsc.dsc$a_pointer = cmd;
X cdsc.dsc$w_length = strlen(cmd);
X cdsc.dsc$b_dtype = DSC$K_DTYPE_T;
X cdsc.dsc$b_class = DSC$K_CLASS_S;
X cdscp = &cdsc;
X }
X status = LIB$SPAWN(cdscp, 0, 0, 0, 0, 0, &substatus, 0, 0, 0);
X if (status != SS$_NORMAL)
X substatus = status;
X status = SYS$QIOW(EFN, iochan, IO$_SETMODE, iosb, 0, 0,
X newmode, sizeof(newmode), 0, 0, 0, 0);
X if (status!=SS$_NORMAL || (iosb[0]&0xFFFF)!=SS$_NORMAL)
X return (FALSE);
X if ((substatus&STS$M_SUCCESS) == 0) /* Command failed. */
X return (FALSE);
X return (TRUE);
X}
X#endif
X
X#if ~AZTEC & MSDOS
X
X/*
X * This routine, once again by Bob McNamara, is a C translation of the "system"
X * routine in the MWC-86 run time library. It differs from the "system" routine
X * in that it does not unconditionally append the string ".exe" to the end of
X * the command name. We needed to do this because we want to be able to spawn
X * off "command.com". We really do not understand what it does, but if you don't
X * do it exactly "malloc" starts doing very very strange things.
X */
Xsys(cmd, tail)
Xchar *cmd;
Xchar *tail;
X{
X#if MWC_86
X register unsigned n;
X extern char *__end;
X
X n = __end + 15;
X n >>= 4;
X n = ((n + dsreg() + 16) & 0xFFF0) + 16;
X return(execall(cmd, tail, n));
X#endif
X
X#if LATTICE
X return(forklp(cmd, tail, (char *)NULL));
X#endif
X
X#if MSC
X return(spawnlp(P_WAIT, cmd, tail, NULL));
X#endif
X}
X#endif
X
X#if MSDOS & LATTICE
X/* System: a modified version of lattice's system() function
X that detects the proper switchar and uses it
X written by Dana Hogget */
X
Xsystem(cmd)
X
Xchar *cmd; /* Incoming command line to execute */
X
X{
X char *getenv();
X static char *swchar = "/C"; /* Execution switch */
X union REGS inregs; /* parameters for dos call */
X union REGS outregs; /* Return results from dos call */
X char *shell; /* Name of system command processor */
X char *p; /* Temporary pointer */
X int ferr; /* Error condition if any */
X
X /* get name of system shell */
X if ((shell = getenv("COMSPEC")) == NULL) {
X return (-1); /* No shell located */
X }
X
X p = cmd;
X while (isspace(*p)) { /* find out if null command */
X p++;
X }
X
X /** If the command line is not empty, bring up the shell **/
X /** and execute the command. Otherwise, bring up the **/
X /** shell in interactive mode. **/
X
X if (p && *p) {
X /** detect current switch character and us it **/
X inregs.h.ah = 0x37; /* get setting data */
X inregs.h.al = 0x00; /* get switch character */
X intdos(&inregs, &outregs);
X *swchar = outregs.h.dl;
X ferr = forkl(shell, "command", swchar, cmd, (char *)NULL);
X } else {
X ferr = forkl(shell, "command", (char *)NULL);
X }
X
X return (ferr ? ferr : wait());
X}
X#endif
X
END_OF_spawn.c
if test 16459 -ne `wc -c <spawn.c`; then
echo shar: \"spawn.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: Extracting \"window.c\" \(18023 characters\)
if test -f window.c ; then
echo shar: Will not over-write existing file \"window.c\"
else
sed "s/^X//" >window.c <<'END_OF_window.c'
X/*
X * Window management. Some of the functions are internal, and some are
X * attached to keys that the user actually types.
X */
X
X#include <stdio.h>
X#include "estruct.h"
X#include "edef.h"
X
X#if MEGAMAX & ST520
Xoverlay "window"
X#endif
X
X/*
X * Reposition dot in the current window to line "n". If the argument is
X * positive, it is that line. If it is negative it is that line from the
X * bottom. If it is 0 the window is centered (this is what the standard
X * redisplay code does). With no argument it defaults to 0. Bound to M-!.
X */
Xreposition(f, n)
X {
X if (f == FALSE) /* default to 0 to center screen */
X n = 0;
X curwp->w_force = n;
X curwp->w_flag |= WFFORCE;
X return (TRUE);
X }
X
X/*
X * Refresh the screen. With no argument, it just does the refresh. With an
X * argument it recenters "." in the current window. Bound to "C-L".
X */
Xrefresh(f, n)
X {
X if (f == FALSE)
X sgarbf = TRUE;
X else
X {
X curwp->w_force = 0; /* Center dot. */
X curwp->w_flag |= WFFORCE;
X }
X
X return (TRUE);
X }
X
X/*
X * The command make the next window (next => down the screen) the current
X * window. There are no real errors, although the command does nothing if
X * there is only 1 window on the screen. Bound to "C-X C-N".
X *
X * with an argument this command finds the <n>th window from the top
X *
X */
Xnextwind(f, n)
X
Xint f, n; /* default flag and numeric argument */
X
X{
X register WINDOW *wp;
X register int nwindows; /* total number of windows */
X
X if (f) {
X
X /* first count the # of windows */
X wp = wheadp;
X nwindows = 1;
X while (wp->w_wndp != NULL) {
X nwindows++;
X wp = wp->w_wndp;
X }
X
X /* if the argument is negative, it is the nth window
X from the bottom of the screen */
X if (n < 0)
X n = nwindows + n + 1;
X
X /* if an argument, give them that window from the top */
X if (n > 0 && n <= nwindows) {
X wp = wheadp;
X while (--n)
X wp = wp->w_wndp;
X } else {
X mlwrite("Window number out of range");
X return(FALSE);
X }
X } else
X if ((wp = curwp->w_wndp) == NULL)
X wp = wheadp;
X curwp = wp;
X curbp = wp->w_bufp;
X upmode();
X return (TRUE);
X}
X
X/*
X * This command makes the previous window (previous => up the screen) the
X * current window. There arn't any errors, although the command does not do a
X * lot if there is 1 window.
X */
Xprevwind(f, n)
X{
X register WINDOW *wp1;
X register WINDOW *wp2;
X
X /* if we have an argument, we mean the nth window from the bottom */
X if (f)
X return(nextwind(f, -n));
X
X wp1 = wheadp;
X wp2 = curwp;
X
X if (wp1 == wp2)
X wp2 = NULL;
X
X while (wp1->w_wndp != wp2)
X wp1 = wp1->w_wndp;
X
X curwp = wp1;
X curbp = wp1->w_bufp;
X upmode();
X return (TRUE);
X}
X
X/*
X * This command moves the current window down by "arg" lines. Recompute the
X * top line in the window. The move up and move down code is almost completely
X * the same; most of the work has to do with reframing the window, and picking
X * a new dot. We share the code by having "move down" just be an interface to
X * "move up". Magic. Bound to "C-X C-N".
X */
Xmvdnwind(f, n)
X
Xint n;
X
X{
X return (mvupwind(f, -n));
X}
X
X/*
X * Move the current window up by "arg" lines. Recompute the new top line of
X * the window. Look to see if "." is still on the screen. If it is, you win.
X * If it isn't, then move "." to center it in the new framing of the window
X * (this command does not really move "."; it moves the frame). Bound to
X * "C-X C-P".
X */
Xmvupwind(f, n)
X int n;
X {
X register LINE *lp;
X register int i;
X
X lp = curwp->w_linep;
X
X if (n < 0)
X {
X while (n++ && lp!=curbp->b_linep)
X lp = lforw(lp);
X }
X else
X {
X while (n-- && lback(lp)!=curbp->b_linep)
X lp = lback(lp);
X }
X
X curwp->w_linep = lp;
X curwp->w_flag |= WFHARD; /* Mode line is OK. */
X
X for (i = 0; i < curwp->w_ntrows; ++i)
X {
X if (lp == curwp->w_dotp)
X return (TRUE);
X if (lp == curbp->b_linep)
X break;
X lp = lforw(lp);
X }
X
X lp = curwp->w_linep;
X i = curwp->w_ntrows/2;
X
X while (i-- && lp != curbp->b_linep)
X lp = lforw(lp);
X
X curwp->w_dotp = lp;
X curwp->w_doto = 0;
X return (TRUE);
X }
X
X/*
X * This command makes the current window the only window on the screen. Bound
X * to "C-X 1". Try to set the framing so that "." does not have to move on the
X * display. Some care has to be taken to keep the values of dot and mark in
X * the buffer structures right if the distruction of a window makes a buffer
X * become undisplayed.
X */
Xonlywind(f, n)
X{
X register WINDOW *wp;
X register LINE *lp;
X register int i;
X
X while (wheadp != curwp) {
X wp = wheadp;
X wheadp = wp->w_wndp;
X if (--wp->w_bufp->b_nwnd == 0) {
X wp->w_bufp->b_dotp = wp->w_dotp;
X wp->w_bufp->b_doto = wp->w_doto;
X wp->w_bufp->b_markp = wp->w_markp;
X wp->w_bufp->b_marko = wp->w_marko;
X }
X free((char *) wp);
X }
X while (curwp->w_wndp != NULL) {
X wp = curwp->w_wndp;
X curwp->w_wndp = wp->w_wndp;
X if (--wp->w_bufp->b_nwnd == 0) {
X wp->w_bufp->b_dotp = wp->w_dotp;
X wp->w_bufp->b_doto = wp->w_doto;
X wp->w_bufp->b_markp = wp->w_markp;
X wp->w_bufp->b_marko = wp->w_marko;
X }
X free((char *) wp);
X }
X lp = curwp->w_linep;
X i = curwp->w_toprow;
X while (i!=0 && lback(lp)!=curbp->b_linep) {
X --i;
X lp = lback(lp);
X }
X curwp->w_toprow = 0;
X curwp->w_ntrows = term.t_nrow-1;
X curwp->w_linep = lp;
X curwp->w_flag |= WFMODE|WFHARD;
X return (TRUE);
X}
X
X/*
X * Delete the current window, placing its space in the window above,
X * or, if it is the top window, the window below. Bound to C-X 0.
X */
X
Xdelwind(f,n)
X
Xint f, n; /* arguments are ignored for this command */
X
X{
X register WINDOW *wp; /* window to recieve deleted space */
X register WINDOW *lwp; /* ptr window before curwp */
X register int target; /* target line to search for */
X
X /* if there is only one window, don't delete it */
X if (wheadp->w_wndp == NULL) {
X mlwrite("Can not delete this window");
X return(FALSE);
X }
X
X /* find window before curwp in linked list */
X wp = wheadp;
X lwp = NULL;
X while (wp != NULL) {
X if (wp == curwp)
X break;
X lwp = wp;
X wp = wp->w_wndp;
X }
X
X /* find recieving window and give up our space */
X wp = wheadp;
X if (curwp->w_toprow == 0) {
X /* find the next window down */
X target = curwp->w_ntrows + 1;
X while (wp != NULL) {
X if (wp->w_toprow == target)
X break;
X wp = wp->w_wndp;
X }
X if (wp == NULL)
X return(FALSE);
X wp->w_toprow = 0;
X wp->w_ntrows += target;
X } else {
X /* find the next window up */
X target = curwp->w_toprow - 1;
X while (wp != NULL) {
X if ((wp->w_toprow + wp->w_ntrows) == target)
X break;
X wp = wp->w_wndp;
X }
X if (wp == NULL)
X return(FALSE);
X wp->w_ntrows += 1 + curwp->w_ntrows;
X }
X
X /* get rid of the current window */
X if (--curwp->w_bufp->b_nwnd == 0) {
X curwp->w_bufp->b_dotp = curwp->w_dotp;
X curwp->w_bufp->b_doto = curwp->w_doto;
X curwp->w_bufp->b_markp = curwp->w_markp;
X curwp->w_bufp->b_marko = curwp->w_marko;
X }
X if (lwp == NULL)
X wheadp = curwp->w_wndp;
X else
X lwp->w_wndp = curwp->w_wndp;
X free((char *)curwp);
X curwp = wp;
X wp->w_flag |= WFHARD;
X curbp = wp->w_bufp;
X upmode();
X return(TRUE);
X}
X
X/*
X
XSplit the current window. A window smaller than 3 lines cannot be
Xsplit. An argument of 1 forces the cursor into the upper window, an
Xargument of two forces the cursor to the lower window. The only other
Xerror that is possible is a "malloc" failure allocating the structure
Xfor the new window. Bound to "C-X 2".
X
X */
Xsplitwind(f, n)
X
Xint f, n; /* default flag and numeric argument */
X
X{
X register WINDOW *wp;
X register LINE *lp;
X register int ntru;
X register int ntrl;
X register int ntrd;
X register WINDOW *wp1;
X register WINDOW *wp2;
X char *malloc();
X
X if (curwp->w_ntrows < 3) {
X mlwrite("Cannot split a %d line window", curwp->w_ntrows);
X return (FALSE);
X }
X if ((wp = (WINDOW *) malloc(sizeof(WINDOW))) == NULL) {
X mlwrite("Cannot allocate WINDOW block");
X return (FALSE);
X }
X ++curbp->b_nwnd; /* Displayed twice. */
X wp->w_bufp = curbp;
X wp->w_dotp = curwp->w_dotp;
X wp->w_doto = curwp->w_doto;
X wp->w_markp = curwp->w_markp;
X wp->w_marko = curwp->w_marko;
X wp->w_flag = 0;
X wp->w_force = 0;
X#if COLOR
X /* set the colors of the new window */
X wp->w_fcolor = gfcolor;
X wp->w_bcolor = gbcolor;
X#endif
X ntru = (curwp->w_ntrows-1) / 2; /* Upper size */
X ntrl = (curwp->w_ntrows-1) - ntru; /* Lower size */
X lp = curwp->w_linep;
X ntrd = 0;
X while (lp != curwp->w_dotp) {
X ++ntrd;
X lp = lforw(lp);
X }
X lp = curwp->w_linep;
X if (((f == FALSE) && (ntrd <= ntru)) || ((f == TRUE) && (n == 1))) {
X /* Old is upper window. */
X if (ntrd == ntru) /* Hit mode line. */
X lp = lforw(lp);
X curwp->w_ntrows = ntru;
X wp->w_wndp = curwp->w_wndp;
X curwp->w_wndp = wp;
X wp->w_toprow = curwp->w_toprow+ntru+1;
X wp->w_ntrows = ntrl;
X } else { /* Old is lower window */
X wp1 = NULL;
X wp2 = wheadp;
X while (wp2 != curwp) {
X wp1 = wp2;
X wp2 = wp2->w_wndp;
X }
X if (wp1 == NULL)
X wheadp = wp;
X else
X wp1->w_wndp = wp;
X wp->w_wndp = curwp;
X wp->w_toprow = curwp->w_toprow;
X wp->w_ntrows = ntru;
X ++ntru; /* Mode line. */
X curwp->w_toprow += ntru;
X curwp->w_ntrows = ntrl;
X while (ntru--)
X lp = lforw(lp);
X }
X curwp->w_linep = lp; /* Adjust the top lines */
X wp->w_linep = lp; /* if necessary. */
X curwp->w_flag |= WFMODE|WFHARD;
X wp->w_flag |= WFMODE|WFHARD;
X return (TRUE);
X}
X
X/*
X * Enlarge the current window. Find the window that loses space. Make sure it
X * is big enough. If so, hack the window descriptions, and ask redisplay to do
X * all the hard work. You don't just set "force reframe" because dot would
X * move. Bound to "C-X Z".
X */
Xenlargewind(f, n)
X{
X register WINDOW *adjwp;
X register LINE *lp;
X register int i;
X
X if (n < 0)
X return (shrinkwind(f, -n));
X if (wheadp->w_wndp == NULL) {
X mlwrite("Only one window");
X return (FALSE);
X }
X if ((adjwp=curwp->w_wndp) == NULL) {
X adjwp = wheadp;
X while (adjwp->w_wndp != curwp)
X adjwp = adjwp->w_wndp;
X }
X if (adjwp->w_ntrows <= n) {
X mlwrite("Impossible change");
X return (FALSE);
X }
X if (curwp->w_wndp == adjwp) { /* Shrink below. */
X lp = adjwp->w_linep;
X for (i=0; i<n && lp!=adjwp->w_bufp->b_linep; ++i)
X lp = lforw(lp);
X adjwp->w_linep = lp;
X adjwp->w_toprow += n;
X } else { /* Shrink above. */
X lp = curwp->w_linep;
X for (i=0; i<n && lback(lp)!=curbp->b_linep; ++i)
X lp = lback(lp);
X curwp->w_linep = lp;
X curwp->w_toprow -= n;
X }
X curwp->w_ntrows += n;
X adjwp->w_ntrows -= n;
X curwp->w_flag |= WFMODE|WFHARD;
X adjwp->w_flag |= WFMODE|WFHARD;
X return (TRUE);
X}
X
X/*
X * Shrink the current window. Find the window that gains space. Hack at the
X * window descriptions. Ask the redisplay to do all the hard work. Bound to
X * "C-X C-Z".
X */
Xshrinkwind(f, n)
X{
X register WINDOW *adjwp;
X register LINE *lp;
X register int i;
X
X if (n < 0)
X return (enlargewind(f, -n));
X if (wheadp->w_wndp == NULL) {
X mlwrite("Only one window");
X return (FALSE);
X }
X if ((adjwp=curwp->w_wndp) == NULL) {
X adjwp = wheadp;
X while (adjwp->w_wndp != curwp)
X adjwp = adjwp->w_wndp;
X }
X if (curwp->w_ntrows <= n) {
X mlwrite("Impossible change");
X return (FALSE);
X }
X if (curwp->w_wndp == adjwp) { /* Grow below. */
X lp = adjwp->w_linep;
X for (i=0; i<n && lback(lp)!=adjwp->w_bufp->b_linep; ++i)
X lp = lback(lp);
X adjwp->w_linep = lp;
X adjwp->w_toprow -= n;
X } else { /* Grow above. */
X lp = curwp->w_linep;
X for (i=0; i<n && lp!=curbp->b_linep; ++i)
X lp = lforw(lp);
X curwp->w_linep = lp;
X curwp->w_toprow += n;
X }
X curwp->w_ntrows -= n;
X adjwp->w_ntrows += n;
X curwp->w_flag |= WFMODE|WFHARD;
X adjwp->w_flag |= WFMODE|WFHARD;
X return (TRUE);
X}
X
X/* Resize the current window to the requested size */
X
Xresize(f, n)
X
Xint f, n; /* default flag and numeric argument */
X
X{
X int clines; /* current # of lines in window */
X
X /* must have a non-default argument, else ignore call */
X if (f == FALSE)
X return(TRUE);
X
X /* find out what to do */
X clines = curwp->w_ntrows;
X
X /* already the right size? */
X if (clines == n)
X return(TRUE);
X
X return(enlargewind(TRUE, n - clines));
X}
X
X/*
X * Pick a window for a pop-up. Split the screen if there is only one window.
X * Pick the uppermost window that isn't the current window. An LRU algorithm
X * might be better. Return a pointer, or NULL on error.
X */
XWINDOW *
Xwpopup()
X{
X register WINDOW *wp;
X
X if (wheadp->w_wndp == NULL /* Only 1 window */
X && splitwind(FALSE, 0) == FALSE) /* and it won't split */
X return (NULL);
X wp = wheadp; /* Find window to use */
X while (wp!=NULL && wp==curwp)
X wp = wp->w_wndp;
X return (wp);
X}
X
Xscrnextup(f, n) /* scroll the next window up (back) a page */
X
X{
X nextwind(FALSE, 1);
X backpage(f, n);
X prevwind(FALSE, 1);
X}
X
Xscrnextdw(f, n) /* scroll the next window down (forward) a page */
X
X{
X nextwind(FALSE, 1);
X forwpage(f, n);
X prevwind(FALSE, 1);
X}
X
Xsavewnd(f, n) /* save ptr to current window */
X
X{
X swindow = curwp;
X return(TRUE);
X}
X
Xrestwnd(f, n) /* restore the saved screen */
X
X{
X register WINDOW *wp;
X
X /* find the window */
X wp = wheadp;
X while (wp != NULL) {
X if (wp == swindow) {
X curwp = wp;
X curbp = wp->w_bufp;
X upmode();
X return (TRUE);
X }
X wp = wp->w_wndp;
X }
X
X mlwrite("[No such window exists]");
X return(FALSE);
X}
X
Xnewsize(f, n) /* resize the screen, re-writing the screen */
X
Xint f; /* default flag */
Xint n; /* numeric argument */
X
X{
X WINDOW *wp; /* current window being examined */
X WINDOW *nextwp; /* next window to scan */
X WINDOW *lastwp; /* last window scanned */
X int lastline; /* screen line of last line of current window */
X
X /* if the command defaults, assume the largest */
X if (f == FALSE)
X n = term.t_mrow + 1;
X
X /* make sure it's in range */
X if (n < 3 || n > term.t_mrow + 1) {
X mlwrite("%%Screen size out of range");
X return(FALSE);
X }
X
X if (term.t_nrow == n - 1)
X return(TRUE);
X else if (term.t_nrow < n - 1) {
X
X /* go to the last window */
X wp = wheadp;
X while (wp->w_wndp != NULL)
X wp = wp->w_wndp;
X
X /* and enlarge it as needed */
X wp->w_ntrows = n - wp->w_toprow - 2;
X wp->w_flag |= WFHARD|WFMODE;
X
X } else {
X
X /* rebuild the window structure */
X nextwp = wheadp;
X wp = NULL;
X lastwp = NULL;
X while (nextwp != NULL) {
X wp = nextwp;
X nextwp = wp->w_wndp;
X
X /* get rid of it if it is too low */
X if (wp->w_toprow > n - 2) {
X
X /* save the point/mark if needed */
X if (--wp->w_bufp->b_nwnd == 0) {
X wp->w_bufp->b_dotp = wp->w_dotp;
X wp->w_bufp->b_doto = wp->w_doto;
X wp->w_bufp->b_markp = wp->w_markp;
X wp->w_bufp->b_marko = wp->w_marko;
X }
X
X /* update curwp and lastwp if needed */
X if (wp == curwp)
X curwp = wheadp;
X curbp = curwp->w_bufp;
X if (lastwp != NULL)
X lastwp->w_wndp = NULL;
X
X /* free the structure */
X free((char *)wp);
X wp = NULL;
X
X } else {
X /* need to change this window size? */
X lastline = wp->w_toprow + wp->w_ntrows - 1;
X if (lastline >= n - 2) {
X wp->w_ntrows = n - wp->w_toprow - 2;
X wp->w_flag |= WFHARD|WFMODE;
X }
X }
X
X lastwp = wp;
X }
X }
X
X /* screen is garbage */
X term.t_nrow = n - 1;
X sgarbf = TRUE;
X return(TRUE);
X}
X
Xnewwidth(f, n) /* resize the screen, re-writing the screen */
X
Xint f; /* default flag */
Xint n; /* numeric argument */
X
X{
X /* if the command defaults, assume the largest */
X if (f == FALSE)
X n = term.t_mcol;
X
X /* make sure it's in range */
X if (n < 10 || n > term.t_mcol) {
X mlwrite("%%Screen width out of range");
X return(FALSE);
X }
X
X /* otherwise, just re-width it (no big deal) */
X term.t_ncol = n;
X term.t_margin = n / 10;
X term.t_scrsiz = n - (term.t_margin * 2);
X curwp->w_flag |= WFHARD | WFMOVE;
X sgarbf = TRUE;
X return(TRUE);
X}
END_OF_window.c
if test 18023 -ne `wc -c <window.c`; then
echo shar: \"window.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of archive 7 \(of 14\).
cp /dev/null ark7isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked all 14 archives.
echo "See the readme file"
rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0