sources-request@mirror.UUCP (03/13/87)
Submitted by: genrad!mlf
Mod.sources: Volume 9, Issue 30
Archive-name: teco/Part03
#! /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 3 (of 4)."
# Contents: te_exec1.c te_exec2.c
# Wrapped by rs@mirror on Thu Mar 12 19:54:32 1987
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
echo shar: Extracting \"te_exec1.c\" \(21012 characters\)
if test -f te_exec1.c ; then
echo shar: Will not over-write existing file \"te_exec1.c\"
else
sed "s/^X//" >te_exec1.c <<'END_OF_te_exec1.c'
X/* TECO for Ultrix Copyright 1986 Matt Fichtenbaum */
X/* This program and its components belong to GenRad Inc, Concord MA 01742 */
X/* They may be copied if this copyright notice is included */
X
X/* te_exec1.c continue executing commands 1/8/87 */
X#include "te_defs.h"
X
Xexec_cmds1()
X {
X char command; /* command character */
X int cond; /* conditional in progress */
X
X switch (command = mapch_l[cmdc])
X {
X/* operators */
X
X case '+':
X esp->exp = (esp->flag1) ? esp->val1 : 0;
X esp->flag1 = 0;
X esp->op = OP_ADD;
X break;
X
X case '-':
X esp->exp = (esp->flag1) ? esp->val1 : 0;
X esp->flag1 = 0;
X esp->op = OP_SUB;
X break;
X
X case '*':
X esp->exp = (esp->flag1) ? esp->val1 : 0;
X esp->flag1 = 0;
X esp->op = OP_MULT;
X break;
X
X case '/':
X esp->exp = (esp->flag1) ? esp->val1 : 0;
X esp->flag1 = 0;
X esp->op = OP_DIV;
X break;
X
X case '&':
X esp->exp = (esp->flag1) ? esp->val1 : 0;
X esp->flag1 = 0;
X esp->op = OP_AND;
X break;
X
X case '#':
X esp->exp = (esp->flag1) ? esp->val1 : 0;
X esp->flag1 = 0;
X esp->op = OP_OR;
X break;
X
X case ')':
X if ((!esp->flag1) || (esp <= &estack[0])) ERROR(E_NAP);
X --esp;
X esp->val1 = (esp+1)->val1; /* carry value from inside () */
X esp->flag1 = 1;
X break;
X case ',':
X if (!esp->flag1) ERROR(E_NAC);
X else esp->val2 = esp->val1;
X esp->flag2 = 1;
X esp->flag1 = 0;
X break;
X
X case CTL (_):
X if (!esp->flag1) ERROR(E_NAB);
X else esp->val1 = ~esp->val1;
X break;
X
X/* radix control */
X
X case CTL (D):
X ctrl_r = 10;
X esp->flag1 = 0;
X esp->op = OP_START;
X break;
X
X case CTL (O):
X ctrl_r = 8;
X esp->flag1 = 0;
X esp->op = OP_START;
X break;
X
X case CTL (R):
X if (!esp->flag1) /* fetch it */
X {
X esp->val1 = ctrl_r;
X esp->flag1 = 1;
X }
X else
X {
X if ((esp->val1 != 8) && (esp->val1 != 10) && (esp->val1 != 16)) ERROR(E_IRA);
X ctrl_r = esp->val1;
X esp->flag1 = 0;
X esp->op = OP_START;
X }
X break;
X
X/* other commands */
X
X case CTL (C): /* 1 ^C stops macro execution, 2 exit */
X if (peekcmdc(CTL (C))) exitflag = -1; /* 2 ^C: stop execution and exit */
X else if (msp <= &mstack[0]) exitflag = 1; /* 1 ^C: in command string: stop execution */
X else --msp; /* in a macro - pop it */
X break;
X
X case CTL (X): /* search mode flag */
X set_var(&ctrl_x);
X break;
X
X case 'e':
X do_e();
X break;
X
X case 'f':
X do_f();
X break;
X /* macro call, iteration, conditional */
X
X case 'm': /* macro call */
X mm = getqspec(0, getcmdc(trace_sw)); /* read the macro name */
X if (msp > &mstack[MSTACKSIZE-1]) ERROR(E_PDO); /* check room for another level */
X ++msp; /* push stack */
X cptr.p = qreg[mm].f; /* to stack entry, put q-reg text start */
X cptr.flag = cptr.c = cptr.dot = 0; /* initial char position, iteration flag */
X cptr.z = qreg[mm].z; /* number of chars in macro */
X break;
X
X case '<': /* begin iteration */
X if ((esp->flag1) && (esp->val1 <= 0)) /* if this is not to be executed */
X find_enditer(); /* just skip the intervening stuff */
X else
X {
X if (!cptr.il) /* does this macro have an iteration list? */
X {
X cptr.il = (struct is *) get_dcell(); /* no, make one for it */
X cptr.il->b = NULL; /* with NULL reverse pointer */
X }
X else if (cptr.flag & F_ITER) /* is there an iteration in process? */
X {
X if (!cptr.il->f) /* yes, if it has no forward pointer */
X {
X cptr.il->f = (struct is *) get_dcell(); /* append a cell to the iteration list */
X cptr.il->f->b = cptr.il; /* and link it in */
X }
X cptr.il = cptr.il->f; /* and advance the iteration list pointer to it */
X }
X cptr.flag |= F_ITER; /* set iteration flag */
X cptr.il->p = cptr.p; /* save start of iteration */
X cptr.il->c = cptr.c;
X cptr.il->dot = cptr.dot;
X if (cptr.il->dflag = esp->flag1) /* if there is an argument, set the "def iter" flag */
X {
X cptr.il->count = esp->val1; /* save the count */
X esp->flag1 = 0; /* and consume the arg */
X }
X }
X break;
X
X case '>': /* end iteration */
X if (!(cptr.flag & F_ITER)) ERROR(E_BNI); /* error if > not in iteration */
X pop_iteration(0); /* decrement count and pop conditionally */
X esp->flag1 = esp->flag2 = 0; /* consume arguments */
X esp->op = OP_START;
X break;
X
X case ';': /* semicolon iteration exit */
X if (!(cptr.flag &F_ITER)) ERROR(E_SNI); /* error if ; not in iteration */
X if ( ( ((esp->flag1) ? esp->val1 : srch_result) >= 0) ? (!colonflag) : colonflag) /* if exit */
X {
X find_enditer(); /* get to end of iteration */
X pop_iteration(1); /* and pop unconditionally */
X }
X esp->flag1 = colonflag = 0; /* consume arg and colon */
X esp->op = OP_START;
X break;
X /* conditionals */
X
X case '"':
X if (!esp->flag1) ERROR(E_NAQ); /* must be an argument */
X esp->flag1 = 0; /* consume argument */
X esp->op = OP_START;
X switch (mapch_l[getcmdc(trace_sw)])
X {
X case 'a':
X cond = isalpha(esp->val1);
X break;
X
X case 'c':
X cond = isalpha(esp->val1) | (esp->val1 == '$') | (esp->val1 == '.');
X break;
X
X case 'd':
X cond = isdigit(esp->val1);
X break;
X
X case 'e':
X case 'f':
X case 'u':
X case '=':
X cond = !(esp->val1);
X break;
X
X case 'g':
X case '>':
X cond = (esp->val1 > 0);
X break;
X
X case 'l':
X case 's':
X case 't':
X case '<':
X cond = (esp->val1 < 0);
X break;
X
X case 'n':
X cond = esp->val1;
X break;
X
X case 'r':
X cond = isalnum(esp->val1);
X break;
X
X case 'v':
X cond = islower(esp->val1);
X break;
X
X case 'w':
X cond = isupper(esp->val1);
X break;
X
X default:
X ERROR(E_IQC);
X }
X if (!cond) /* if this conditional isn't satisfied */
X {
X for (ll = 1; ll > 0;) /* read to matching | or ' */
X {
X while ((skipto(0) != '"') && (skipc != '|') && (skipc != '\'')); /* skip chars */
X if (skipc == '"') ++ll; /* start another level */
X else if (skipc == '\'') --ll; /* end a level */
X else if (ll == 1) break; /* "else" (|): if on this level, start executing */
X }
X }
X break;
X
X case '\'': /* end of conditional */
X break; /* ignore it if executing */
X
X case '|': /* "else" clause */
X for (ll = 1; ll > 0;) /* skip to matching ' */
X {
X while ((skipto(0) != '"') && (skipc != '\'')); /* skip chars */
X if (skipc == '"') ++ll; /* start another level */
X else --ll; /* end a level */
X }
X break;
X /* q-register numeric operations */
X
X case 'u':
X if (!esp->flag1) ERROR(E_NAU); /* error if no arg */
X else qreg[getqspec(0, getcmdc(trace_sw))].v = esp->val1;
X esp->flag1 = esp->flag2; /* command's "value" is 2nd arg */
X esp->val1 = esp->val2;
X esp->flag2 = 0; /* clear 2nd arg */
X esp->op = OP_START;
X break;
X
X case 'q': /* Qn is numeric val, :Qn is # of chars, mQn is mth char */
X mm = getqspec((colonflag || esp->flag1), getcmdc(trace_sw)); /* read register name */
X if (!(esp->flag1))
X {
X esp->val1 = (colonflag) ? qreg[mm].z : qreg[mm].v;
X esp->flag1 = 1;
X }
X else /* esp->flag1 is already set */
X {
X if ((esp->val1 >= 0) && (esp->val1 < qreg[mm].z)) /* char subscript within range? */
X {
X for (ll = 0, aa.p = qreg[mm].f; ll < (esp->val1 / CELLSIZE); ll++) aa.p = aa.p->f;
X esp->val1 = (int) aa.p->ch[esp->val1 % CELLSIZE];
X }
X else esp->val1 = -1; /* char position out of range */
X esp->op = OP_START; /* consume argument */
X }
X colonflag = 0;
X break;
X
X case '%':
X esp->val1 = (qreg[getqspec(0, getcmdc(trace_sw))].v += get_value(1)); /* add to q reg */
X esp->flag1 = 1;
X break;
X /* move pointer */
X
X case 'c':
X if (((tdot = dot + get_value(1)) < 0) || (tdot > z))
X ERROR(E_POP); /* add arg to dot, default 1 */
X else dot = tdot;
X esp->flag2 = 0;
X break;
X
X case 'r':
X if (((tdot = dot - get_value(1)) < 0) || (tdot > z))
X ERROR(E_POP); /* add arg to dot, default 1 */
X else dot = tdot;
X esp->flag2 = 0;
X break;
X
X case 'j':
X if (((tdot = get_value(0)) < 0) || (tdot > z))
X ERROR(E_POP); /* add arg to dot, default 1 */
X else dot = tdot;
X esp->flag2 = 0;
X break;
X
X case 'l':
X dot += lines(get_value(1));
X break;
X
X/* number of chars until nth line feed */
X
X case CTL (Q):
X esp->val1 = lines(get_value(1));
X esp->flag1 = 1;
X break;
X
X/* print numeric value */
X
X case '=':
X if (!esp->flag1) ERROR(E_NAE); /* error if no arg */
X else
X {
X if (peekcmdc('=')) /* at least one more '=' */
X {
X getcmdc(trace_sw); /* read past it */
X if (peekcmdc('=')) /* another? */
X {
X getcmdc(trace_sw); /* yes, read it too */
X printf("%x", esp->val1); /* print in hex */
X }
X else printf("%o", esp->val1); /* print in octal */
X }
X else printf("%d", esp->val1);
X if (!colonflag) crlf();
X esp->flag1 = esp->flag2 = colonflag = 0;
X esp->op = OP_START;
X if (!WN_scroll) window(WIN_REDRAW); /* if not in scroll mode, force full redraw on next refresh */
X }
X break;
X /* insert text */
X
X case TAB: /* insert tab, then text */
X if (ez_val & EZ_NOTABI) break; /* tab disabled */
X if (esp->flag1) ERROR(E_IIA); /* can't have arg */
X
X case 'i': /* insert text at pointer */
X term_char = (atflag) ? getcmdc(trace_sw) : ESC; /* set terminator */
X if (esp->flag1) /* if a nI$ command */
X {
X if (!peekcmdc(term_char)) ERROR(E_IIA); /* next char must be term */
X insert1(); /* first part of insert */
X bb.p->ch[bb.c] = esp->val1 & 0177; /* insert character */
X fwdcx(&bb); /* advance pointer and extend buffer if necessary */
X ins_count = 1; /* save string length */
X esp->op = OP_START; /* consume argument */
X }
X else /* not a nI command: insert text */
X {
X insert1(); /* initial insert operations */
X
X if (command == TAB) /* TAB insert puts in a tab first */
X {
X bb.p->ch[bb.c] = TAB; /* insert a tab */
X fwdcx(&bb); /* advance pointer and maybe extend buffer */
X }
X moveuntil(&cptr, &bb, term_char, &ins_count, cptr.z - cptr.dot, trace_sw); /* copy cmd str -> buffer */
X if (command == TAB) ++ins_count; /* add 1 if a tab inserted */
X cptr.dot += ins_count; /* indicate advance over that many chars */
X }
X insert2(ins_count); /* finish insert */
X getcmdc(trace_sw); /* flush terminating char */
X colonflag = atflag = esp->flag1 = esp->flag2 = 0; /* clear args */
X break;
X
X/* type text from text buffer */
X
X case 't':
X for (ll = line_args(0, &aa); ll > 0; ll--) /* while there are chars to type */
X {
X type_char(aa.p->ch[aa.c]);
X fwdc(&aa);
X }
X if (!WN_scroll) window(WIN_REDRAW); /* if not in scroll mode, force full redraw on next refresh */
X break;
X
X case 'v':
X if ((ll = get_value(1)) > 0) /* arg must be positive */
X {
X mm = lines(1 - ll); /* find start */
X nn = lines(ll) - mm; /* and number of chars */
X set_pointer(dot + mm, &aa); /* pointer to start of text */
X for (; nn > 0; nn--) /* as above */
X {
X type_char(aa.p->ch[aa.c]);
X fwdc(&aa);
X }
X }
X if (!WN_scroll) window(WIN_REDRAW); /* if not in scroll mode, force full redraw on next refresh */
X break;
X /* type text from command string */
X
X case CTL (A):
X term_char = (atflag) ? getcmdc(trace_sw) : CTL(A); /* set terminator */
X while (getcmdc(0) != term_char) type_char(cmdc); /* output chars */
X atflag = colonflag = esp->flag2 = esp->flag1 = 0;
X esp->op = OP_START;
X if (!WN_scroll) window(WIN_REDRAW); /* if not in scroll mode, force full redraw on next refresh */
X break;
X
X /* delete text */
X
X case 'd':
X if (!esp->flag2) /* if only one argument */
X {
X delete1(get_value(1)); /* delete chars (default is 1) */
X break;
X } /* if two args, fall through to treat m,nD as m,nK */
X
X case 'k': /* delete lines or chars */
X ll = line_args(1, &aa); /* aa points to start, ll chars, leave dot at beginning */
X delete1(ll); /* delete ll chars */
X break;
X
X/* q-register text loading commands */
X
X case CTL (U):
X mm = getqspec(0, getcmdc(trace_sw));
X if (!colonflag) /* X, ^U commands destroy previous contents */
X {
X dly_free_blist(qreg[mm].f);
X qreg[mm].f = NULL;
X qreg[mm].z = 0;
X }
X term_char = (atflag) ? getcmdc(trace_sw) : ESC; /* set terminator */
X atflag = 0; /* clear flag */
X
X if ((esp->flag1) || (!peekcmdc(term_char))) /* if an arg or a nonzero insert, find register */
X {
X make_buffer(&qreg[mm]); /* attach a text buffer to the q register */
X for (bb.p = qreg[mm].f; bb.p->f != NULL; bb.p = bb.p->f); /* find end of reg */
X bb.c = (colonflag) ? qreg[mm].z % CELLSIZE : 0;
X }
X if (!(esp->flag1))
X {
X moveuntil(&cptr, &bb, term_char, &ll, cptr.z - cptr.dot, trace_sw);
X cptr.dot += ll; /* indicate advance over that many chars */
X qreg[mm].z += ll; /* update q-reg char count */
X getcmdc(trace_sw); /* skip terminator */
X }
X else
X {
X if (getcmdc(trace_sw) != term_char) ERROR(E_IIA); /* must be zero length string */
X bb.p->ch[bb.c] = esp->val1; /* store char */
X fwdcx(&bb); /* extend the register */
X ++qreg[mm].z;
X esp->flag1 = 0; /* consume argument */
X }
X colonflag = 0;
X break;
X case 'x':
X mm = getqspec(0, getcmdc(trace_sw));
X if (!colonflag) /* X, ^U commands destroy previous contents */
X {
X dly_free_blist(qreg[mm].f); /* return, but delayed (in case executing now) */
X qreg[mm].f = NULL;
X qreg[mm].z = 0;
X }
X
X if (ll = line_args(0, &aa)) /* read args and move chars, if any */
X {
X make_buffer(&qreg[mm]); /* attach a text buffer to the q register */
X for (bb.p = qreg[mm].f; bb.p->f != NULL; bb.p = bb.p->f); /* find end of reg */
X bb.c = (colonflag) ? qreg[mm].z % CELLSIZE : 0;
X
X movenchars(&aa, &bb, ll);
X qreg[mm].z += ll; /* update q-reg char count */
X }
X colonflag = 0;
X break;
X
X case 'g': /* get q register */
X if (qreg[mm = getqspec(1, getcmdc(trace_sw))].z) /* if any chars in it */
X {
X cc.p = qreg[mm].f; /* point cc to start of reg */
X cc.c = 0;
X if (colonflag) /* :Gx types q-reg */
X {
X for (ll = qreg[mm].z; ll > 0; ll--)
X {
X type_char(cc.p->ch[cc.c]); /* type char */
X fwdc(&cc);
X }
X }
X else
X {
X insert1(); /* set up for insert */
X movenchars(&cc, &bb, qreg[mm].z); /* copy q reg text */
X insert2(qreg[mm].z); /* finish insert */
X }
X }
X colonflag = 0;
X break;
X /* q-register push and pop */
X
X case '[':
X if (qsp > &qstack[QSTACKSIZE-1]) ERROR(E_PDO); /* stack full */
X else
X {
X make_buffer(++qsp); /* increment stack ptr and put a text buffer there */
X mm = getqspec(1, getcmdc(trace_sw)); /* get the q reg name */
X
X aa.p = qreg[mm].f; /* point to the q register */
X aa.c = 0;
X bb.p = qsp->f; /* point to the new list */
X bb.c = 0;
X movenchars(&aa, &bb, qreg[mm].z); /* copy the text */
X qsp->z = qreg[mm].z; /* and the length */
X qsp->v = qreg[mm].v; /* and the value */
X }
X break;
X
X case ']':
X mm = getqspec(1, getcmdc(trace_sw)); /* get reg name */
X if (qsp < &qstack[0]) /* if stack empty */
X {
X if (colonflag) /* :] returns 0 */
X {
X esp->flag1 = 1;
X esp->val1 = 0;
X colonflag = 0;
X }
X else ERROR(E_CPQ); /* ] makes an error */
X }
X else /* stack not empty */
X {
X free_blist(qreg[mm].f); /* return orig contents of reg */
X qreg[mm].f = qsp->f; /* substitute stack entry */
X qsp->f->b = (struct buffcell *) &qreg[mm];
X qsp->f = NULL; /* null out stack entry */
X qreg[mm].z = qsp->z;
X qreg[mm].v = qsp->v;
X if (colonflag)
X {
X esp->flag1 = 1; /* :] returns -1 */
X esp->val1 = -1;
X colonflag = 0;
X }
X --qsp;
X }
X break;
X case '\\':
X if (!(esp->flag1)) /* no argument; read number */
X {
X ll = esp->val1 = 0; /* sign flag and initial value */
X for (ctrl_s = 0; dot <= z; dot++, ctrl_s--) /* count digits; don't read beyond buffer */
X {
X set_pointer(dot, &aa); /* point to dot */
X if ((aa.p->ch[aa.c] == '+') || (aa.p->ch[aa.c] == '-'))
X {
X if (ll) break; /* second sign: quit */
X else ll = aa.p->ch[aa.c]; /* first sign: save it */
X }
X else
X {
X if (ctrl_r != 16) /* octal or decimal */
X { /* stop if not a valid digit */
X if ((!isdigit(aa.p->ch[aa.c])) || (aa.p->ch[aa.c] - '0' >= ctrl_r)) break;
X esp->val1 = esp->val1 * ctrl_r + (aa.p->ch[aa.c] - '0');
X }
X else
X {
X if (!isxdigit(aa.p->ch[aa.c])) break;
X esp->val1 = esp->val1 * 16 + ( (isdigit(aa.p->ch[aa.c])) ?
X aa.p->ch[aa.c] - '0' : mapch_l[aa.p->ch[aa.c]] - 'a' + 10);
X } /* end of hex */
X } /* end of digit processing */
X } /* end of "for each char" */
X if (ll == '-') esp->val1 = -(esp->val1); /* if minus sign */
X esp->flag1 = 1; /* always returns a value */
X }
X
X else /* argument: insert it as a digit string */
X {
X if (ctrl_r == 8) sprintf(t_bcell.ch, "%o", esp->val1); /* print as digits */
X else if (ctrl_r == 10) sprintf(t_bcell.ch, "%d", esp->val1);
X else sprintf(t_bcell.ch, "%x", esp->val1);
X insert1(); /* start insert */
X cc.p = &t_bcell; /* point cc to the temp cell */
X cc.c = 0;
X moveuntil(&cc, &bb, '\0', &ins_count, CELLSIZE-1, 0); /* copy the char string */
X insert2(ins_count); /* finish the insert */
X esp->flag1 = 0; /* consume argument */
X esp->op = OP_START;
X }
X break;
X case CTL (T): /* type or input character */
X if (esp->flag1) /* type */
X {
X type_char(esp->val1);
X esp->flag1 = 0;
X if (!WN_scroll) window(WIN_REDRAW); /* if not in scroll mode, force full redraw on next refresh */
X }
X else
X {
X esp->val1 = (et_val & ET_NOWAIT) ? gettty_nowait() : gettty();
X if (!(et_val & ET_NOECHO) && (esp->val1 > 0) && !inp_noterm) type_char(esp->val1); /* echo */
X esp->flag1 = 1;
X }
X break;
X
X/* search commands */
X
X case 's': /* search within buffer */
X build_string(&sbuf); /* read the search string */
X end_search ( do_search( setup_search() ) ); /* search */
X break;
X
X case 'n': /* search through rest of file */
X case '_':
X do_nsearch(command); /* call routine for N, _, E_ */
X break;
X
X case 'o': /* branch to tag */
X do_o();
X break;
X /* file I/O commands */
X
X case 'p': /* write a page, get next (ignore args for now) */
X if (esp->flag1 && esp->flag2) /* if two args */
X write_file(&aa, line_args(0, &aa), 0); /* write spec'd buffer with no FF */
X else /* one arg */
X {
X for (ll = get_value(1); ll > 0; ll--) /* get count and loop */
X {
X set_pointer(0, &aa);
X if (peekcmdc('w')) write_file(&aa, z, 1); /* PW writes buffer, then FF */
X else
X {
X write_file(&aa, z, ctrl_e); /* P writes buffer, FF if read in, then gets next page */
X dot = z = 0; /* empty the buffer */
X set_pointer(0, &aa); /* set a pointer to the beginning of the buffer */
X buff_mod = 0; /* mark where new buffer starts */
X esp->val1 = read_file(&aa, &z, (ed_val & ED_EXPMEM ? -1 : 0) ); /* read a page */
X esp->flag1 = colonflag;
X }
X }
X }
X if (peekcmdc('w')) getcmdc(trace_sw); /* if a PW command, consume the W */
X colonflag = 0;
X break;
X
X case 'y': /* get a page into buffer */
X if (esp->flag1) ERROR(E_NYA);
X if ((z) && (!(ed_val & ED_YPROT))) ERROR(E_YCA); /* don't lose text */
X dot = z = 0; /* clear buffer */
X set_pointer(0, &aa); /* set a pointer to the beginning of the buffer */
X buff_mod = 0; /* mark where new buffer starts */
X read_file(&aa, &z, (ed_val & ED_EXPMEM ? -1 : 0) ); /* read a page */
X esp->flag1 = colonflag;
X esp->op = OP_START;
X colonflag = 0;
X break;
X case 'a': /* append, or ascii value */
X if (esp->flag1 && !colonflag) /* ascii value */
X {
X ll = dot + esp->val1; /* set a pointer before addr'd char */
X if ((ll >= 0) && (ll < z)) /* if character lies within buffer */
X {
X set_pointer(ll, &aa);
X esp->val1 = (int) aa.p->ch[aa.c]; /* get char (flag already set) */
X }
X else esp->val1 = -1; /* otherwise return -1 */
X }
X else
X {
X set_pointer(z, &aa); /* set pointer to end of buffer */
X if (z < buff_mod) buff_mod = z; /* mark where new buffer starts */
X if (esp->flag1 && (esp->val1 <= 0)) ERROR(E_IAA); /* neg or 0 arg to :A */
X read_file(&aa, &z, (esp->flag1 ? esp->val1 : 0) ); /* read a page */
X esp->flag1 = colonflag;
X colonflag = 0;
X }
X esp->op = OP_START;
X break;
X
X/* window commands */
X
X case 'w':
X do_window(0); /* this stuff is with the window driver */
X break;
X
X case CTL (W):
X do_window(1); /* this is, too */
X break;
X
X default:
X ERROR(E_ILL); /* invalid command */
X
X } /* end of "switch" */
X return; /* normal exit */
X } /* end of exec_cmds1 */
X
END_OF_te_exec1.c
if test 21012 -ne `wc -c <te_exec1.c`; then
echo shar: \"te_exec1.c\" unpacked with wrong size!?
fi
# end of overwriting check
fi
echo shar: Extracting \"te_exec2.c\" \(29256 characters\)
if test -f te_exec2.c ; then
echo shar: Will not over-write existing file \"te_exec2.c\"
else
sed "s/^X//" >te_exec2.c <<'END_OF_te_exec2.c'
X/* TECO for Ultrix Copyright 1986 Matt Fichtenbaum */
X/* This program and its components belong to GenRad Inc, Concord MA 01742 */
X/* They may be copied if this copyright notice is included */
X
X/* te_exec2.c process "E" and "F" commands 2/26/87 */
X#include "te_defs.h"
X#include <sys/wait.h>
X
Xstruct qh oldcstring; /* hold command string during ei */
X
X/* file stuff for input/output files */
X
Xstruct infiledata pi_file = { NULL, -1 }; /* input files */
Xstruct infiledata si_file = { NULL, -1 };
Xstruct infiledata *infile = &pi_file; /* pointer to currently active input file structure */
Xstruct outfiledata po_file, so_file; /* output files */
Xstruct outfiledata *outfile = &po_file; /* pointer to currently active output file structure */
XFILE *eisw; /* indirect command file pointer */
X
X/* process E commands */
X
Xdo_e()
X {
X char c; /* temps */
X int old_var;
X FILE *t_eisw;
X
X switch (mapch_l[getcmdc(trace_sw)]) /* read next character and dispatch */
X {
X
X/* numeric values */
X
X case 'd': /* ED */
X set_var(&ed_val);
X break;
X
X case 's': /* ES */
X set_var(&es_val);
X break;
X
X case 't': /* ET */
X old_var = et_val;
X set_var(&et_val);
X et_val = (et_val & 0100651) | 001006; /* force read_only bits */
X if ((et_val ^ old_var) & ET_TRUNC) window(WIN_REDRAW); /* redraw if ET & 256 changes */
X break;
X
X case 'u': /* EU */
X set_var(&eu_val);
X break;
X
X case 'v': /* EV */
X set_var(&ev_val);
X break;
X
X case 'z': /* EZ */
X old_var = ez_val;
X set_var(&ez_val);
X tabmask = (ez_val & EZ_TAB4) ? 3 : 7; /* set tab mask */
X if ((ez_val ^ old_var) & EZ_TAB4) window(WIN_REDRAW); /* force window redisplay if EZ_TAB4 changes */
X break;
X /* E_ search */
X
X case '_':
X do_nsearch('e');
X break;
X
X/* file I/O commands */
X
X case 'a': /* set secondary output */
X outfile = &so_file;
X break;
X
X case 'b': /* open read/write with backup */
X if (!read_filename(1, 'r')) ERROR(E_NFI); /* read the name */
X if (infile->fd) fclose(infile->fd); /* close previously-open file */
X if (!(infile->fd = fopen(fbuf.f->ch, "r")))
X {
X if (!colonflag) ERROR(E_FNF);
X }
X else
X {
X if (outfile->fd) ERROR(E_OFO); /* output file already open */
X for (ll = 0; ll < CELLSIZE; ll++) /* save file string */
X if ((outfile->t_name[ll] = outfile->f_name[ll] = fbuf.f->ch[ll]) == '\0') break;
X outfile->name_size = ll;
X outfile->t_name[ll++] = '.';
X outfile->t_name[ll++] = 't';
X outfile->t_name[ll++] = 'm';
X outfile->t_name[ll++] = 'p';
X outfile->t_name[ll] = '\0';
X if (!(outfile->fd = fopen(outfile->t_name, "w"))) ERROR(E_COF);
X outfile->bak = 1; /* set backup mode */
X }
X infile->eofsw = -1 - (esp->val1 = (infile->fd) ? -1 : 0);
X esp->flag1 = colonflag;
X colonflag = 0;
X break;
X
X case 'x': /* finish edit and exit */
X exitflag = -1;
X
X /* --- fall through to "EC" --- */
X
X case 'c': /* finish edit */
X set_pointer(0, &aa); /* set a pointer to start of text buffer */
X write_file(&aa, z, ctrl_e); /* write the current buffer */
X dot = z = 0; /* empty the buffer */
X window(WIN_REDRAW); /* force window redraw */
X if ((outfile->fd) && (infile->fd) && !(infile->eofsw)) /* if any input remaining, copy it to output */
X while ((c = getc(infile->fd)) != EOF) putc(c, outfile->fd);
X
X /* --- fall through to "EF" --- */
X case 'f': /* close output file */
X if (outfile->fd) /* only if one is open */
X {
X fclose(outfile->fd);
X if (outfile->bak & 1) /* if this is "backup" mode */
X {
X outfile->f_name[outfile->name_size] = '.';
X outfile->f_name[outfile->name_size+1] = 'b';
X outfile->f_name[outfile->name_size+2] = 'a';
X outfile->f_name[outfile->name_size+3] = 'k';
X outfile->f_name[outfile->name_size+4] = '\0';
X outfile->t_name[outfile->name_size] = '\0';
X rename(outfile->t_name, outfile->f_name); /* rename orig file */
X }
X
X if (!(outfile->bak & 8)) /* if output file had ".tmp" extension */
X { /* remove it */
X outfile->t_name[outfile->name_size] = '.';
X outfile->f_name[outfile->name_size] = '\0';
X rename(outfile->t_name, outfile->f_name); /* rename output */
X }
X }
X outfile->fd = NULL; /* mark "no output file open" */
X break;
X
X case 'i': /* indirect file execution */
X if (!read_filename(1, 'i')) /* if no filename specified, reset command input */
X {
X if (eisw) /* if ending a file execute, restore the previous "old command string" */
X {
X fclose(eisw); /* return the file descriptor */
X dly_free_blist(cbuf.f); /* return the command string used by the file (after execution done) */
X cbuf.f = oldcstring.f;
X cbuf.z = oldcstring.z;
X }
X t_eisw = 0;
X }
X else if (!(t_eisw = fopen(fbuf.f->ch, "r")))
X {
X if (!colonflag) ERROR(E_FNF);
X }
X else if (!eisw) /* if this "ei" came from the command string */
X {
X oldcstring.f = cbuf.f; /* save current command string */
X oldcstring.z = cbuf.z;
X cbuf.f = NULL; /* and make it inaccessible to "rdcmd" */
X }
X if (eisw) fclose(eisw); /* if a command file had been open, close it */
X esp->val1 = (eisw = t_eisw) ? -1 : 0;
X esp->flag1 = colonflag;
X colonflag = 0;
X esp->op = OP_START;
X break;
X case 'k': /* kill output file */
X kill_output(outfile);
X break;
X
X case 'p': /* switch to secondary input */
X infile = &si_file;
X break;
X
X case 'r': /* specify input file, or switch to primary input */
X if (!read_filename(0, 'r')) infile = &pi_file; /* no name, switch to primary input */
X else
X {
X if (infile->fd) fclose(infile->fd); /* close previously-open file */
X if (!(infile->fd = fopen(fbuf.f->ch, "r")))
X {
X if (!colonflag) ERROR(E_FNF);
X }
X }
X infile->eofsw = -1 - (esp->val1 = (infile->fd) ? -1 : 0);
X esp->flag1 = colonflag;
X colonflag = 0;
X esp->op = OP_START;
X break;
X
X case 'w': /* specify output file, or switch to primary output */
X if(!read_filename(0, 'w')) outfile = &po_file;
X else
X {
X if (outfile->fd) ERROR(E_OFO); /* output file already open */
X for (ll = 0; ll < CELLSIZE; ll++) /* save file string */
X if ((outfile->t_name[ll] = outfile->f_name[ll] = fbuf.f->ch[ll]) == '\0') break;
X outfile->name_size = ll;
X if (!(ez_val & EZ_NOTMPFIL)) /* if not using literal output name */
X {
X outfile->t_name[ll++] = '.'; /* use provisional suffix ".tmp" */
X outfile->t_name[ll++] = 't';
X outfile->t_name[ll++] = 'm';
X outfile->t_name[ll++] = 'p';
X outfile->t_name[ll] = '\0';
X }
X if (!(outfile->fd = fopen(outfile->t_name, "w"))) ERROR(E_COF);
X outfile->bak = ez_val & EZ_NOTMPFIL; /* save "temp suffix" status */
X }
X break;
X
X case 'y': /* EY is Y without protection */
X if (esp->flag1) ERROR(E_NYA);
X dot = z = 0; /* clear buffer */
X set_pointer(0, &aa);
X read_file(&aa, &z, (ed_val & ED_EXPMEM ? -1 : 0) );
X esp->flag1 = colonflag;
X colonflag = 0;
X esp->op = OP_START;
X break;
X case 'n': /* wildcard filespec */
X esp->val1 = do_en();
X esp->flag1 = colonflag;
X colonflag = 0;
X esp->op = OP_START;
X break;
X
X case 'q': /* system command */
X esp->val1 = do_eq(); /* do this as a separate routine */
X esp->flag1 = colonflag;
X colonflag = 0;
X esp->op = OP_START;
X break;
X
X default:
X ERROR(E_IEC);
X }
X }
X /* routine to execute a system command */
X/* this is done by forking off another process */
X/* to execute a shell via 'execl' */
X/* routine returns -1 if success, 0 if error in fork */
X
Xint do_eq()
X {
X int t;
X union wait status;
X char *pname; /* pointer to name of shell */
X extern char *getenv();
X
X build_string(&sysbuf);
X if (sysbuf.z > CELLSIZE-2) ERROR(E_STL); /* command must fit within one cell */
X sysbuf.f->ch[sysbuf.z] = '\0'; /* store terminating null */
X if (!(pname = getenv("SHELL"))) ERROR(E_SYS); /* read shell name */
X
X if (!esp->flag1) /* if not m,nEQ command */
X {
X if (win_data[7]) window(WIN_SUSP); /* restore full screen */
X crlf(); /* force characters out */
X setup_tty(TTY_SUSP); /* restore terminal to normal mode */
X
X t = vfork(); /* fork a new process */
X if (t == 0) /* if this is the child */
X {
X execl(pname, pname, "-c", &sysbuf.f->ch[0], 0); /* call the named Unix routine */
X printf("Error in 'execl'\n"); /* normally shouldn't get here */
X exit(1);
X }
X
X while (wait(&status) != t); /* if parent, wait for child to finish */
X if (status.w_retcode) t = -1; /* keep failure indication from child */
X
X setup_tty(TTY_RESUME); /* restore terminal to teco mode */
X if (win_data[7]) /* if window was enabled */
X {
X vt(VT_SETSPEC1); /* set reverse video */
X fputs("Type RETURN to continue", stdout); /* require CR before continuing */
X vt(VT_CLRSPEC); /* reverse video off */
X while (gettty() != LF);
X putchar(CR); /* back to beginning of line */
X vt(VT_EEOL); /* and erase the message */
X window(WIN_RESUME); /* re-enable window */
X window(WIN_REDRAW); /* and make it redraw afterwards */
X }
X }
X
X else t = do_eq1(pname); /* m,nEQ command */
X
X return( (t == -1) ? 0 : -1); /* return failure if fork failed or proc status nonzero */
X }
X /* Execute m,nEQtext$ command. Run "text" as a Unix command that */
X/* receives its std input from chars m through n of teco's buffer. */
X/* Output from the command is placed in Q#. */
X
Xint do_eq1(shell)
X char *shell; /* arg is pointer to shell name */
X {
X int ff, pipe_in[2], pipe_out[2]; /* fork result and two pipes */
X FILE *xx_in, *xx_out; /* std in and out for called process */
X FILE *fdopen();
X union wait status;
X
X ll = line_args(1, &aa); /* set aa to start of text, ll to number of chars */
X dot += ll; /* set pointer at end of text */
X ctrl_s = -ll; /* set ^S to - # of chars */
X
X if (pipe(pipe_out)) ERROR(E_SYS); /* make input pipe; failure if can't */
X
X if (win_data[7]) window(WIN_SUSP); /* disable split screen */
X setup_tty(TTY_SUSP); /* put console back to original state */
X if ((ff = fork()) == -1) /* fork first child: if error, quit */
X {
X close(pipe_out[0]);
X close(pipe_out[1]);
X setup_tty(TTY_RESUME);
X if (win_data[7]) window(WIN_RESUME), window(WIN_REDRAW);
X ERROR(E_SYS);
X }
X
X if (ff) /* if this is the parent, the task is to read into q# */
X {
X make_buffer(&timbuf); /* initialize the q# header */
X bb.p = timbuf.f; /* init bb to point to q# */
X timbuf.z = bb.c = 0;
X
X close(pipe_out[1]); /* parent won't write to this pipe */
X
X if ((xx_out = fdopen(pipe_out[0], "r")) == 0) /* open the "std out" pipe for reading */
X {
X close(pipe_out[0]); /* if can't open output pipe */
X setup_tty(TTY_RESUME);
X if (win_data[7]) window(WIN_RESUME), window(WIN_REDRAW);
X ERROR(E_SYS); /* "open" failure */
X }
X read_stream(xx_out, 0, &bb, &timbuf.z, 0, 0, 1); /* read from pipe to q# */
X close(pipe_out[0]);
X
X while (wait(&status) != ff); /* wait for children to finish */
X setup_tty(TTY_RESUME);
X if (win_data[7]) window(WIN_RESUME), window(WIN_REDRAW);
X return(status.w_retcode ? -1 : 0);
X }
X /* This is the child. It in turn forks into two processes, of which the "parent" */
X/* (original child) writes the specified part of the buffer to the pipe, and the */
X/* new child (grandchild to the original teco) execl's the Unix command. */
X
X else /* this is the child */
X {
X close(pipe_out[0]); /* won't read from "output" pipe */
X if (pipe(pipe_in)) exit(1); /* make the "std in" pipe for the process, quit if can't */
X
X if ((ff = fork()) == -1) exit(1); /* fork to two processes (total 3), exit if error */
X
X if (ff) /* parent - will send chars */
X {
X close(pipe_in[0]); /* won't read from this pipe */
X
X /* open pipe for writing; exit if open fails */
X
X if ((xx_in = fdopen(pipe_in[1], "w")) == 0) exit(1);
X
X write_stream(xx_in, &aa, ll, 0); /* write to stream, CRLF becomes LF */
X fclose(xx_in);
X
X while (wait(&status) != ff); /* wait for child */
X exit(status.w_retcode); /* exit with child's status */
X }
X
X else /* this process is the grandchild */
X {
X close(pipe_in[1]); /* close "input" for writing */
X dup2(pipe_in[0], fileno(stdin)); /* substitute pipe_in for stdin */
X dup2(pipe_out[1], fileno(stdout)); /* and pipe_out for stdout */
X close(pipe_in[0]); /* close original descriptors */
X close(pipe_out[1]);
X
X execl(shell, shell, "-c", &sysbuf.f->ch[0], 0); /* execute specified routine */
X fputs("execl failed\n", stderr);
X exit(1);
X }
X }
X }
X /* Routines to handle EN wild-card file specification */
X/* ENfilespec$ defines file class, leaving 'filespec' */
X/* in filespec buffer and reading expanded list of */
X/* files into local buffer. EN$ gets next filespec */
X/* into filespec buffer. */
X
Xstruct qh en_buf; /* header for storage for file list */
Xstruct qp en_ptr; /* pointer to load/read file list */
Xstatic char glob_cmd0[] = { 'g', 'l', 'o', 'b', ' ' } ;
X
Xint do_en()
X {
X int t;
X
X if (build_string(&fbuf)) /* if a file string is specified */
X {
X if (fbuf.z > CELLSIZE-2) ERROR(E_STL); /* upper limit on string length */
X fbuf.f->ch[fbuf.z] = '\0'; /* terminating null */
X t = do_glob(&en_buf); /* glob the result */
X en_ptr.p = en_buf.f; /* set the buffer pointer to the beginning of the buffer */
X en_ptr.dot = en_ptr.c = 0;
X }
X else /* if no string, get next filename */
X {
X do_en_next();
X t = (fbuf.z) ? -1 : 0; /* t zero if no more filespecs */
X if (!t && !colonflag) ERROR(E_NFI); /* if no colon, end of spec is an error */
X }
X return (t);
X }
X
X/* routine to expand the string in the filespec buffer */
X/* argument is the address of a qh that gets the expanded string */
X/* argument->v gets set to the number of file specs found */
X
Xint do_glob(buff)
X struct qh *buff;
X {
X char glob_cmd[CELLSIZE+5]; /* "glob filespec" command string */
X int t;
X char c;
X int glob_pipe[2]; /* pipe to forked shell for expanding filenames */
X struct qp glob_ptr; /* pointer for loading result buffer */
X FILE *xx_out; /* stream for reading chars from pipe */
X FILE *fdopen();
X union wait status;
X
X make_buffer(buff); /* initialize expanded file buffer */
X glob_ptr.p = buff->f; /* initialize pointer to buffer */
X glob_ptr.c = glob_ptr.dot = buff->z = buff->v = 0;
X for (t = 0; t < 5; t++) glob_cmd[t] = glob_cmd0[t]; /* set up "glob filespec" command */
X for (t = 0; t < fbuf.z +1; t++) glob_cmd[t+5] = fbuf.f->ch[t];
X
X if (pipe(glob_pipe)) ERROR(E_SYS); /* make a pipe */
X setup_tty(TTY_SUSP); /* put console back to normal */
X if ((t = fork()) == -1) /* spawn a child... if failure */
X {
X close(glob_pipe[0]); /* undo the pipe */
X close(glob_pipe[1]);
X setup_tty(TTY_RESUME);
X ERROR(E_SYS); /* and exit with failure */
X }
X
X if (t) /* if this is the parent */
X {
X close(glob_pipe[1]); /* parent won't write */
X if ((xx_out = fdopen(glob_pipe[0], "r")) == 0) /* open pipe for read */
X {
X close(glob_pipe[0]); /* failure to open */
X setup_tty(TTY_RESUME);
X ERROR(E_SYS);
X }
X
X while ((c = getc(xx_out)) != EOF) /* read characters from pipe */
X {
X if (c == '\0') ++buff->v; /* count null chars that separate file specs */
X glob_ptr.p->ch[glob_ptr.c] = c; /* store them in buffer */
X fwdcx(&glob_ptr);
X }
X
X fclose(xx_out); /* through with stream */
X buff->z = glob_ptr.dot; /* save character count */
X while (wait(&status) != t); /* wait for child to finish */
X setup_tty(TTY_RESUME);
X return(status.w_retcode ? 0 : -1); /* return success unless child exited nonzero */
X }
X else /* this is the child */
X {
X close(glob_pipe[0]); /* child won't read */
X dup2(glob_pipe[1], fileno(stdout)); /* substitute pipe for standard out */
X close(glob_pipe[1]); /* don't need that anymore */
X execl("/bin/csh", "csh", "-fc", glob_cmd, 0); /* execute the "glob" */
X fputs("execl failed\n", stderr);
X exit(1);
X }
X }
X
X/* routine to get next file spec from "EN" list into filespec buffer */
X
Xdo_en_next()
X {
X char c;
X
X make_buffer(&fbuf); /* initialize the filespec buffer */
X fbuf.z = 0;
X
X while(en_ptr.dot < en_buf.z) /* stop at end of string */
X {
X c = en_ptr.p->ch[en_ptr.c];
X fwdc(&en_ptr);
X if (!c) break; /* null is terminator between file specs */
X fbuf.f->ch[fbuf.z++] = c; /* store char */
X if (fbuf.z >= CELLSIZE-1) ERROR(E_STL); /* limit on filespec size */
X }
X
X fbuf.f->ch[fbuf.z] = '\0'; /* filespec ends with NULL */
X }
X
X/* routine to read a file name */
X/* reads it into fbuf text area */
X/* returns nonzero if a name, 0 if none */
X/* flag nonzero => empty name clears filespec buffer */
X/* func is 'r' for ER or EB cmds, 'i' for EI, 'w' for EW */
X
Xint read_filename(flag, func)
X int flag;
X char func;
X {
X int i, t, expand;
X char c;
X struct qh temp_buff; /* temp buffer for globbing filespec */
X
X if (!(t = build_string(&fbuf))) /* if no name spec'd */
X {
X if (flag) fbuf.z = 0; /* if no name spec'd, set length to 0 */
X }
X else
X {
X if (fbuf.z > CELLSIZE-2) ERROR(E_STL);
X fbuf.f->ch[fbuf.z] = '\0'; /* store terminating NULL */
X
X/* check for characters to be expanded by the shell */
X
X for (i = 0; i < fbuf.z; i++)
X if ((c = fbuf.f->ch[i]) == '*' || c == '?' || c == '[' || c == 0173) break;
X if ( (expand = (i < fbuf.z)) || fbuf.f->ch[0] == '~') /* one of these was found, or first char is ~ */
X {
X temp_buff.f = NULL; /* make a temp buffer to glob filename into */
X make_buffer(temp_buff);
X do_glob(&temp_buff); /* expand the file name */
X if (temp_buff.z == 0) /* no match */
X {
X free_blist(temp_buff.f); /* return the storage */
X ERROR(func == 'w' ? E_COF : E_FNF); /* "can't open" or "file not found" */
X }
X else if (temp_buff.v == 0) /* if exactly one file name */
X {
X free_blist(fbuf.f); /* return the old file spec */
X fbuf.f = temp_buff.f; /* put the temp buffer there instead */
X fbuf.z = temp_buff.z;
X if (fbuf.z > CELLSIZE-2) ERROR(E_STL);
X fbuf.f->ch[fbuf.z] = '\0';
X
X if (func == 'w' && expand) /* if this is EW and 'twas from a wildcard expansion */
X {
X vt(VT_SETSPEC1); /* "file XXXX already exists: overwrite? [yn]" */
X fputs("File ", stdout);
X fputs(fbuf.f->ch, stdout);
X fputs(" already exists: overwrite? [ny] ", stdout);
X vt(VT_CLRSPEC);
X c = gettty(); /* read user's response */
X putchar(CR);
X vt(VT_EEOL); /* clean up the screen */
X if (c != 'y') ERROR(E_COF); /* abort here */
X }
X }
X
X else /* multiple file specs */
X {
X if (func != 'r' || !(ez_val & EZ_MULT)) /* if multiple file specs here aren't allowed */
X {
X free_blist(temp_buff.f); /* return the storage */
X ERROR(E_AMB);
X }
X free_blist(en_buf.f); /* substitute the expansion for the "EN" list */
X en_ptr.p = en_buf.f = temp_buff.f; /* and initialize the "EN" list pointer */
X en_buf.z = temp_buff.z;
X en_ptr.dot = en_ptr.c = 0;
X do_en_next(); /* get the first file */
X }
X }
X }
X return(t);
X }
X
X
X
X/* fetch or set variable */
X
Xset_var(arg)
X int *arg; /* argument is pointer to variable */
X {
X if (esp->flag1) /* if an argument, then set the variable */
X {
X if (esp->flag2) /* if two arguments, then <clr>, <set> */
X *arg = (*arg & ~esp->val2) | esp->val1;
X else *arg = esp->val1; /* one arg is new value */
X esp->flag2 = esp->flag1 = 0; /* consume argument */
X }
X else /* otherwise fetch the variable's value */
X {
X esp->val1 = *arg;
X esp->flag1 = 1;
X }
X }
X
X
X
X/* read from selected input file stream into specified buffer */
X/* terminate on end-of-file or form feed */
X/* if endsw > 0 terminates after that many lines */
X/* if endsw < 0 stops if z > BUFF_LIMIT */
X/* returns -1 if read EOF, 0 otherwise */
X
Xint read_file(buff, nchars, endsw)
X struct qp *buff;
X int *nchars, endsw;
X {
X if (!infile->fd) infile->eofsw = -1, ctrl_e = 0; /* return if no input file open */
X else infile->eofsw = read_stream(infile->fd, &ctrl_e, buff, nchars, endsw, ez_val & EZ_CRLF, ez_val & EZ_READFF);
X return(esp->val1 = infile->eofsw);
X }
X /* read from an I/O stream into specified buffer */
X/* this is used by read_file and by "eq" pipe from other Unix processes */
X/* args buff, nchars, endsw as above; file is stream pointer, ff_found is */
X/* address of a switch to set if read ended with a FF, crlf_sw is lf->crlf */
X/* conversion, ff_sw indicates whether to stop on a form feed. */
X
Xint read_stream(file, ff_found, buff, nchars, endsw, crlf_sw, ff_sw)
X FILE *file;
X struct qp *buff;
X int *ff_found, *nchars, endsw, crlf_sw, ff_sw;
X {
X char chr;
X int crflag;
X register struct buffcell *p;
X register int c;
X
X p = (*buff).p; /* copy pointer locally */
X c = (*buff).c;
X crflag = 0; /* "last char wasn't CR" */
X while (((chr = getc(file)) != EOF) && ((chr != FF) || ff_sw))
X {
X if ((chr == LF) && !crflag && !crlf_sw) /* automatic cr before lf */
X {
X p->ch[c] = CR; /* store a cr */
X ++(*nchars); /* increment buffer count */
X if (++c > CELLSIZE-1) /* next cell? */
X {
X if (!p->f) /* need a new cell? */
X {
X p->f = get_bcell();
X p->f->b = p;
X }
X p = p->f;
X c = 0;
X }
X }
X p->ch[c] = chr; /* store char */
X ++(*nchars); /* increment character count */
X if (++c > CELLSIZE-1) /* next cell? */
X {
X if (!p->f) /* need a new cell? */
X {
X p->f = get_bcell();
X p->f->b = p;
X }
X p = p->f;
X c = 0;
X }
X crflag = (chr == CR); /* flag set if last char was CR */
X if ((chr == LF) && ((endsw < 0 && z > BUFF_LIMIT) || (endsw > 0 && --endsw == 0))) break; /* term after N lines */
X }
X (*buff).p = p; /* update pointer */
X (*buff).c = c;
X if (ff_found) *ff_found = (chr == FF) ? -1 : 0; /* set flag to indicate whether FF found */
X return( (chr == EOF) ? -1 : 0); /* and return "eof found" value */
X }
X /* routine to write text buffer out to selected output file */
X/* arguments are qp to start of text, number of characters, */
X/* and an "append FF" switch */
X
Xwrite_file(buff, nchars, ffsw)
X struct qp *buff;
X int nchars, ffsw;
X {
X if (!outfile->fd && (nchars)) ERROR(E_NFO);
X else write_stream(outfile->fd, buff, nchars, ez_val & EZ_CRLF);
X if (outfile->fd && ffsw) putc(FF, outfile->fd);
X }
X
X
X/* routine to write text buffer to I/O stream. Used by */
X/* write_file, above, and by "eq" write to pipe to other */
X/* Unix processes. Arguments buff, nchars as above; file */
X/* is stream pointer, crlf_sw zero converts CRLF to LF */
X
Xwrite_stream(file, buff, nchars, crlf_sw)
X FILE *file;
X struct qp *buff;
X int nchars, crlf_sw;
X {
X char c;
X int crflag;
X
X crflag = 0;
X for (; nchars > 0; nchars--)
X {
X if ((c = (*buff).p->ch[(*buff).c]) == CR) crflag = 1; /* set flag if a c.r. */
X else
X {
X if ((crflag) && ((c != LF) || crlf_sw)) /* if c.r. not before lf, or if not in */
X putc(CR, file); /* "no cr" mode, output the c.r. */
X crflag = 0;
X putc(c, file);
X }
X if (++(*buff).c > CELLSIZE-1)
X {
X (*buff).p = (*buff).p->f;
X (*buff).c = 0;
X }
X }
X }
X
X
X/* routine to kill output file: argument is pointer to an output file structure */
X
Xkill_output(outptr)
X struct outfiledata *outptr;
X {
X if (outptr->fd)
X {
X fclose(outptr->fd);
X unlink(outptr->t_name);
X outptr->fd = NULL;
X }
X }
X /* "panic" routine called when "hangup" signal occurs */
X/* this routine saves the text buffer and closes the output files */
X
Xchar panic_name[] = "TECO_SAVED.tmp"; /* name of file created to save buffer */
X
Xpanic()
X {
X if (!outfile->fd && z) outfile->fd = fopen(panic_name, "w"); /* if buffer nonempty and no file open, make one */
X
X set_pointer(0, &aa); /* set a pointer to start of text buffer */
X if (outfile->fd && z) write_file(&aa, z, 0); /* and write out buffer unless "open" failed */
X
X if (po_file.fd) fclose(po_file.fd), po_file.fd = NULL; /* close any open output files */
X if (so_file.fd) fclose(so_file.fd), so_file.fd = NULL;
X }
X /* do "F" commands */
X
Xdo_f()
X {
X struct buffcell *delete_p;
X
X switch (mapch_l[getcmdc(trace_sw)]) /* read next character and dispatch */
X {
X case '<': /* back to beginning of current iteration */
X if (cptr.flag & F_ITER) /* if in iteration */
X {
X cptr.p = cptr.il->p; /* restore */
X cptr.c = cptr.il->c;
X cptr.dot = cptr.il->dot;
X }
X else for (cptr.dot = cptr.c = 0; cptr.p->b->b != NULL; cptr.p = cptr.p->b); /* else, restart current macro */
X break;
X
X case '>': /* to end of current iteration */
X find_enditer(); /* find it */
X if ( ( ((esp->flag1) ? esp->val1 : srch_result) >= 0) ? (~colonflag) : colonflag) /* if exit */
X pop_iteration(0); /* and exit if appropriate */
X break;
X
X case '\'': /* to end of conditional */
X case '|': /* to "else," or end */
X find_endcond(cmdc);
X break;
X
X/* "F" search commands */
X
X case 'b': /* bounded search, alternative args */
X do_fb();
X break;
X
X case 'c': /* bounded search, alternative args, then "FR" */
X if (do_fb()) goto do_fr;
X while (getcmdc(trace_sw) != term_char); /* otherwise skip insert string */
X break;
X
X case 'n': /* do "N" and then "FR" */
X if (do_nsearch('n')) goto do_fr;
X while (getcmdc(trace_sw) != term_char); /* otherwise skip insert string */
X break;
X
X case '_': /* do "_" and then "FR" */
X if (do_nsearch('_')) goto do_fr;
X while (getcmdc(trace_sw) != term_char); /* otherwise skip insert string */
X break;
X
X case 's': /* search and replace: search, then do "FR" */
X build_string(&sbuf); /* read search string and terminator */
X if (end_search( do_search( setup_search() ) )) goto do_fr; /* if search passed, do "FR" */
X while (getcmdc(trace_sw) != term_char); /* otherwise skip insert string */
X break;
X case 'r': /* replace last insert, search, etc. */
X if (esp->flag1) ERROR(E_NFR); /* shouldn't have argument */
X term_char = (atflag) ? getcmdc(trace_sw) : ESC; /* set terminator */
X atflag = 0;
X do_fr: /* entry from FN, F_, and FC */
X set_pointer(dot, &cc); /* save a pointer to the current spot */
X dot += ctrl_s; /* back dot up over the string */
X set_pointer(dot, &aa); /* code from "insert1": convert dot to a qp */
X delete_p = aa.p; /* save beginning of original cell */
X if (dot < buff_mod) buff_mod = dot; /* update earliest char loc touched */
X insert_p = bb.p = get_bcell(); /* get a new cell */
X bb.c = 0;
X ins_count = aa.c; /* save char position of dot in cell */
X aa.c = 0;
X
X movenchars(&aa, &bb, ins_count); /* copy cell up to dot */
X moveuntil(&cptr, &bb, term_char, &ins_count, cptr.z-cptr.dot, trace_sw); /* insert */
X cptr.dot += ins_count; /* advance command-string pointer */
X getcmdc(trace_sw); /* skip terminator */
X
X z += ctrl_s; /* subtract delete length from buffer count */
X delete_p->b->f = insert_p; /* put the new cell where the old one was */
X insert_p->b = delete_p->b; /* code borrowed from "insert2" */
X insert_p = NULL;
X
X if (bb.c == cc.c) /* if replacement text was same length, we can save time */
X {
X for (; bb.c < CELLSIZE; bb.c++) bb.p->ch[bb.c] = cc.p->ch[bb.c]; /* copy rest of cell */
X bb.p->f = cc.p->f; /* replace orig cell's place in chain with end of new list */
X if (bb.p->f) bb.p->f->b = bb.p;
X cc.p->f = NULL; /* terminate the part snipped out */
X free_blist(delete_p); /* return the old part */
X }
X
X else /* different positions: shift the remainder of the buffer */
X {
X bb.p->f = delete_p; /* splice rest of buffer to end */
X delete_p->b = bb.p;
X movenchars(&cc, &bb, z-dot); /* squeeze buffer */
X free_blist(bb.p->f); /* return unused cells */
X bb.p->f = NULL; /* and end the buffer */
X }
X
X z += ins_count; /* add # of chars inserted */
X dot += ins_count;
X ctrl_s = -ins_count; /* save string length */
X esp->flag1 = esp->flag2 = 0; /* and consume arguments */
X esp->op = OP_START;
X break;
X
X default:
X ERROR(E_IFC);
X }
X }
X /* routines for macro iteration */
X/* pop iteration: if arg nonzero, exit unconditionally */
X/* else check exit conditions and exit or reiterate */
X
Xpop_iteration(arg)
X int arg;
X {
X if (!arg && (!cptr.il->dflag || (--(cptr.il->count) > 0)) ) /* if reiteration */
X {
X cptr.p = cptr.il->p; /* restore */
X cptr.c = cptr.il->c;
X cptr.dot = cptr.il->dot;
X }
X else
X {
X if (cptr.il->b) cptr.il = cptr.il->b; /* if not last thing on stack, back up */
X else cptr.flag &= ~F_ITER; /* else clear "iteration" flag */
X }
X }
X
X
X/* find end of iteration - read over arbitrary <> and one > */
X
Xfind_enditer()
X {
X register int icnt;
X
X for (icnt = 1; icnt > 0;) /* scan for matching > */
X {
X while ((skipto(0) != '<') && (skipc != '>')); /* scan for next < or > */
X if (skipc == '<') ++icnt; /* and keep track of macro level */
X else --icnt;
X }
X }
X
X
X
X/* find end of conditional */
Xchar find_endcond(arg)
X char arg;
X {
X register int icnt;
X
X for (icnt = 1; icnt > 0;)
X {
X while ((skipto(0) != '"') && (skipc != '\'') && (skipc != '|'));
X if (skipc == '"') ++icnt;
X else if (skipc == '\'') -- icnt;
X else if ((icnt == 1) && (arg == '|')) break;
X }
X }
X
END_OF_te_exec2.c
if test 29256 -ne `wc -c <te_exec2.c`; then
echo shar: \"te_exec2.c\" unpacked with wrong size!?
fi
# end of overwriting check
fi
echo shar: End of archive 3 \(of 4\).
cp /dev/null ark3isdone
DONE=true
for I in 1 2 3 4 ; do
if test ! -f ark${I}isdone ; then
echo shar: You still need to run archive ${I}.
DONE=false
fi
done
if test "$DONE" = "true" ; then
echo You have unpacked all 4 archives.
echo "See the *.doc files"
rm -f ark[1-9]isdone
fi
## End of shell archive.
exit 0