#pragma ident "%Z%%M% %I% %E% SMI"

#include <setjmp.h>

#include <signal.h>

#include <stdlib.h>

#include <regexpr.h>

#include <limits.h>

#include <sys/types.h>

#include <unistd.h>

#include <sys/stat.h>

#include <locale.h>

#include <stdio.h>

#include <string.h>

#include <wait.h>

#include <fcntl.h>

int setjmp();

static jmp_buf env;

extern int scrwidth(wchar_t);

#define BRKTYP char

#define BRKSIZ 8192

#define BRKTWO 4

#define BFSAND

#define BFSLIM 511

#define BFSTRU 511

#define BFSBUF 512

struct Comd {

int Cnumadr;

int Cadr[2];

char Csep;

char Cop;

};

static int Dot, Dollar;

static int markarray[26], *mark;

static int fstack[15] = {1, -1};

static int infildes = 0;

static int outfildes = 1;

static char internal[512], *intptr;

static char comdlist[100];

static char *endds;

static char charbuf = '\n';

static int peeked;

static char currex[100];

static int trunc = BFSTRU;

static int crunch = -1;

static int segblk[512], segoff[512], txtfd, prevblk, prevoff;

static int oldfd = 0;

static int flag4 = 0;

static int flag3 = 0;

static int flag2 = 0;

static int flag1 = 0;

static int flag = 0;

static int lprev = 1;

static int status[1];

static BRKTYP *lincnt;

static char *perbuf;

static char *rebuf;

static char *glbuf;

static char tty, *bigfile;

static char fle[80];

static char prompt = 1;

static char verbose = 1; /* 1=print # of bytes read in; 0=silent. */

static char varray[10][100]; /* Holds xv cmd parameters. */

static double outcnt;

static char strtmp[32];

static void reset();

static void begin(struct Comd *p);

static int bigopen(char file[]);

static void sizeprt(int blk, int off);

static void bigread(int l, char rec[]);

static int gcomd(struct Comd *p, int k);

static int fcomd(struct Comd *p);

static void ecomd();

static int kcomd(struct Comd *p);

static int xncomd(struct Comd *p);

static int pcomd(struct Comd *p);

static int qcomd();

static int xcomds(struct Comd *p);

static int xbcomd(struct Comd *p);

static int xccomd(struct Comd *p);

static int xfcomd(struct Comd *p);

static int xocomd(struct Comd *p);

static int xtcomd(struct Comd *p);

static int xvcomd();

static int wcomd(struct Comd *p);

static int nlcomd(struct Comd *p);

static int eqcomd(struct Comd *p);

static int colcomd(struct Comd *p);

static int excomd();

static int xcomdlist(struct Comd *p);

static int defaults(struct Comd *p, int prt, int max,

int def1, int def2, int setdot, int errsok);

static int getcomd(struct Comd *p, int prt);

static int getadrs(struct Comd *p, int prt);

static int getadr(struct Comd *p, int prt);

static int getnumb(struct Comd *p, int prt);

static int rdnumb(int prt);

static int getrel(struct Comd *p, int prt);

static int getmark(struct Comd *p, int prt);

static int getrex(struct Comd *p, int prt, char c);

static int hunt(int prt, char rex[], int start, int down, int wrap, int errsok);

static int jump(int prt, char label[]);

static int getstr(int prt, char buf[], char brk, char ignr, int nonl);

static int regerr(int c);

static int err(int prt, char msg[]);

static char mygetc();

static int readc(int f, char *c);

static int percent(char line[256]);

static int newfile(int prt, char f[]);

static void push(int s[], int d);

static int pop(int s[]);

static int peekc();

static void eat();

static int more();

static void quit();

static void out(char *ln);

static char *untab(char l[]);

static int patoi(char *b);

static int equal(char *a, char *b);

main(int argc, char *argv[])

{

struct Comd comdstruct, *p;

(void) setlocale(LC_ALL, "");

if (argc < 2 || argc > 3) {

(void) err(1, "arg count");

quit();

}

mark = markarray-'a';

if (argc == 3) {

verbose = 0;

}

setbuf(stdout, 0);

if (bigopen(bigfile = argv[argc-1]))

quit();

tty = isatty(0);

p = &comdstruct;

/* Look for 0 or more non-'%' char followed by a '%' */

perbuf = compile("[^%]*%", (char *)0, (char *)0);

if (regerrno)

(void) regerr(regerrno);

(void) setjmp(env);

#if defined(__STDC__)

(void) signal(SIGINT, (void (*)(int))reset);

#else

(void) signal(SIGINT, reset);

#endif

(void) err(0, "");

(void) printf("\n");

flag = 0;

prompt = 0;

/*CONSTCOND*/ for (;;)

begin(p);

}

static void

reset() /* for longjmp on signal */

{

longjmp(env, 1);

}

static void

begin(struct Comd *p)

{

char line[256];

strtagn:

if (flag == 0)

eat();

if (infildes != 100) {

if (infildes == 0 && prompt)

(void) printf("*");

flag3 = 1;

if (getstr(1, line, 0, 0, 0))

exit(1);

flag3 = 0;

if (percent(line) < 0)

goto strtagn;

(void) newfile(1, "");

}

if (!(getcomd(p, 1) < 0)) {

switch (p->Cop) {

case 'e':

if (!flag)

ecomd();

else

(void) err(0, "");

break;

case 'f':

(void) fcomd(p);

break;

case 'g':

if (flag == 0)

(void) gcomd(p, 1);

else

(void) err(0, "");

break;

case 'k':

(void) kcomd(p);

break;

case 'p':

(void) pcomd(p);

break;

case 'q':

(void) qcomd();

break;

case 'v':

if (flag == 0)

(void) gcomd(p, 0);

else

(void) err(0, "");

break;

case 'x':

if (!flag)

(void) xcomds(p);

else

(void) err(0, "");

break;

case 'w':

(void) wcomd(p);

break;

case '\n':

(void) nlcomd(p);

break;

case '=':

(void) eqcomd(p);

break;

case ':':

(void) colcomd(p);

break;

case '!':

(void) excomd();

break;

case 'P':

prompt = !prompt;

break;

default:

if (flag)

(void) err(0, "");

else

(void) err(1, "bad command");

break;

}

}

}

static int

bigopen(char file[])

{

int l, off, cnt;

int blk, newline, n, s;

char block[512];

size_t totsiz;

BRKTYP *tptr;

if ((txtfd = open(file, 0)) < 0)

return (err(1, "can't open"));

blk = -1;

newline = 1;

l = cnt = s = 0;

off = 512;

totsiz = 0;

if ((lincnt = (BRKTYP *)malloc(BRKSIZ)) == (BRKTYP *)NULL)

return (err(1, "too many lines"));

endds = (BRKTYP *)lincnt;

totsiz += BRKSIZ;

while ((n = read(txtfd, block, 512)) > 0) {

blk++;

for (off = 0; off < n; off++) {

if (newline) {

newline = 0;

if (l > 0 && !(l&07777)) {

totsiz += BRKSIZ;

tptr = (BRKTYP *)

realloc(lincnt, totsiz);

if (tptr == NULL)

return

(err(1, "too many lines"));

else

lincnt = tptr;

}

lincnt[l] = (char)cnt;

cnt = 0;

if (!(l++ & 077)) {

segblk[s] = blk;

segoff[s++] = off;

}

if (l < 0 || l > 32767)

return (err(1, "too many lines"));

}

if (block[off] == '\n') newline = 1;

cnt++;

}

}

if (!(l&07777)) {

totsiz += BRKTWO;

tptr = (BRKTYP *)realloc(lincnt, totsiz);

if (tptr == NULL)

return (err(1, "too many lines"));

else

lincnt = tptr;

}

lincnt[Dot = Dollar = l] = (char)cnt;

sizeprt(blk, off);

return (0);

}

static void

sizeprt(int blk, int off)

{

if (verbose)

(void) printf("%.0f", 512.*blk+off);

}

static int saveblk = -1;

static void

bigread(int l, char rec[])

{

int i;

char *r, *b;

int off;

static char savetxt[512];

if ((i = l-lprev) == 1) prevoff += lincnt[lprev]BFSAND;

else if (i >= 0 && i <= 32)

for (i = lprev; i < l; i++) prevoff += lincnt[i]BFSAND;

else if (i < 0 && i >= -32)

for (i = lprev-1; i >= l; i--) prevoff -= lincnt[i]BFSAND;

else {

prevblk = segblk[i = (l-1)>>6];

prevoff = segoff[i];

for (i = (i<<6)+1; i < l; i++) prevoff += lincnt[i]BFSAND;

}

prevblk += prevoff>>9;

prevoff &= 0777;

lprev = l;

if (prevblk != saveblk) {

(void) lseek(txtfd, ((long)(saveblk = prevblk))<<9, 0);

(void) read(txtfd, savetxt, 512);

}

r = rec;

off = prevoff;

/*CONSTCOND*/while (1) {

for (b = savetxt+off; b < savetxt+512; b++) {

if ((*r++ = *b) == '\n') {

*(r-1) = '\0';

return;

}

if (((unsigned)r - (unsigned)rec) > BFSLIM) {

(void) write(2,

"Line too long--output truncated\n", 32);

return;

}

}

(void) read(txtfd, savetxt, 512);

off = 0;

saveblk++;

}

}

static void

ecomd()

{

int i = 0;

while (peekc() == ' ')

(void) mygetc();

while ((fle[i++] = mygetc()) != '\n');

fle[--i] = '\0';

/* Without this, ~20 "e" cmds gave "can't open" msg. */

(void) close(txtfd);

free(endds);

/* Reset parameters. */

lprev = 1;

prevblk = 0;

prevoff = 0;

saveblk = -1;

if (bigopen(bigfile = fle))

quit();

(void) printf("\n");

}

static int

fcomd(struct Comd *p)

{

if (more() || defaults(p, 1, 0, 0, 0, 0, 0))

return (-1);

(void) printf("%s\n", bigfile);

return (0);

}

static int

gcomd(struct Comd *p, int k)

{

char d;

int i, end;

char line[BFSBUF];

if (defaults(p, 1, 2, 1, Dollar, 0, 0))

return (-1);

if ((d = mygetc()) == '\n')

return (err(1, "syntax"));

if (peekc() == d)

(void) mygetc();

else

if (getstr(1, currex, d, 0, 1))

return (-1);

glbuf = compile(currex, (char *)0, (char *)0);

if (regerrno) {

(void) regerr(regerrno);

return (-1);

} else {

if (glbuf)

free(glbuf);

}

if (getstr(1, comdlist, 0, 0, 0))

return (-1);

i = p->Cadr[0];

end = p->Cadr[1];

while (i <= end) {

bigread(i, line);

if (!(step(line, glbuf))) {

if (!k) {

Dot = i;

if (xcomdlist(p))

return (err(1, "bad comd list"));

}

i++;

} else {

if (k) {

Dot = i;

if (xcomdlist(p))

return (err(1, "bad comd list"));

}

i++;

}

}

return (0);

}

static int

kcomd(struct Comd *p)

{

char c;

if ((c = peekc()) < 'a' || c > 'z')

return (err(1, "bad mark"));

(void) mygetc();

if (more() || defaults(p, 1, 1, Dot, 0, 1, 0))

return (-1);

mark[c] = Dot = p->Cadr[0];

return (0);

}

static int

xncomd(struct Comd *p)

{

char c;

if (more() || defaults(p, 1, 0, 0, 0, 0, 0))

return (-1);

for (c = 'a'; c <= 'z'; c++)

if (mark[c])

(void) printf("%c\n", c);

return (0);

}

static int

pcomd(struct Comd *p)

{

int i;

char line[BFSBUF];

if (more() || defaults(p, 1, 2, Dot, Dot, 1, 0))

return (-1);

for (i = p->Cadr[0]; i <= p->Cadr[1] && i > 0; i++) {

bigread(i, line);

out(line);

}

return (0);

}

static int

qcomd()

{

if (more())

return (-1);

quit();

return (0);

}

static int

xcomds(struct Comd *p)

{

switch (mygetc()) {

case 'b': return (xbcomd(p));

case 'c': return (xccomd(p));

case 'f': return (xfcomd(p));

case 'n': return (xncomd(p));

case 'o': return (xocomd(p));

case 't': return (xtcomd(p));

case 'v': return (xvcomd());

default: return (err(1, "bad command"));

}

}

static int

xbcomd(struct Comd *p)

{

int fail, n;

char d;

char str[50];

fail = 0;

if (defaults(p, 0, 2, Dot, Dot, 0, 1))

fail = 1;

else {

if ((d = mygetc()) == '\n')

return (err(1, "syntax"));

if (d == 'z') {

if (status[0] != 0)

return (0);

(void) mygetc();

if (getstr(1, str, 0, 0, 0))

return (-1);

return (jump(1, str));

}

if (d == 'n') {

if (status[0] == 0)

return (0);

(void) mygetc();

if (getstr(1, str, 0, 0, 0))

return (-1);

return (jump(1, str));

}

if (getstr(1, str, d, ' ', 0))

return (-1);

if ((n = hunt(0, str, p->Cadr[0]-1, 1, 0, 1)) < 0)

fail = 1;

if (getstr(1, str, 0, 0, 0))

return (-1);

if (more())

return (err(1, "syntax"));

}

if (!fail) {

Dot = n;

return (jump(1, str));

}

return (0);

}

static int

xccomd(struct Comd *p)

{

char arg[100];

if (getstr(1, arg, 0, ' ', 0) || defaults(p, 1, 0, 0, 0, 0, 0))

return (-1);

if (equal(arg, ""))

crunch = -crunch;

else if (equal(arg, "0"))

crunch = -1;

else if (equal(arg, "1"))

crunch = 1;

else

return (err(1, "syntax"));

return (0);

}

static int

xfcomd(struct Comd *p)

{

char fl[100];

char *f;

if (defaults(p, 1, 0, 0, 0, 0, 0))

return (-1);

while (peekc() == ' ')

(void) mygetc();

for (f = fl; (*f = mygetc()) != '\n'; f++);

if (f == fl)

return (err(1, "no file"));

*f = '\0';

return (newfile(1, fl));

}

static int

xocomd(struct Comd *p)

{

int fd;

char arg[100];

if (getstr(1, arg, 0, ' ', 0) || defaults(p, 1, 0, 0, 0, 0, 0))

return (-1);

if (!arg[0]) {

if (outfildes == 1)

return (err(1, "no diversion"));

(void) close(outfildes);

outfildes = 1;

} else {

if (outfildes != 1)

return (err(1, "already diverted"));

if ((fd = open(arg, O_WRONLY|O_CREAT|O_TRUNC,

(S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH))) < 0)

return (err(1, "can't create"));

outfildes = fd;

}

return (0);

}

static int

xtcomd(struct Comd *p)

{

int t;

while (peekc() == ' ')

(void) mygetc();

if ((t = rdnumb(1)) < 0 || more() || defaults(p, 1, 0, 0, 0, 0, 0))

return (-1);

trunc = t;

return (0);

}

static int

xvcomd()

{

char c;

int i;

int temp0, temp1, temp2;

int fildes[2];

if ((c = peekc()) < '0' || c > '9')

return (err(1, "digit required"));

(void) mygetc();

c -= '0';

while (peekc() == ' ')

(void) mygetc();

if (peekc() == '\\')

(void) mygetc();

else if (peekc() == '!') {

if (pipe(fildes) < 0) {

(void) printf("Try again");

return (-1);

}

temp0 = dup(0);

temp1 = dup(1);

temp2 = infildes;

(void) close(0);

(void) dup(fildes[0]);

(void) close(1);

(void) dup(fildes[1]);

(void) close(fildes[0]);

(void) close(fildes[1]);

(void) mygetc();

flag4 = 1;

(void) excomd();

(void) close(1);

infildes = 0;

}

for (i = 0; (varray[c][i] = mygetc()) != '\n'; i++);

varray[c][i] = '\0';

if (flag4) {

infildes = temp2;

(void) close(0);

(void) dup(temp0);

(void) close(temp0);

(void) dup(temp1);

(void) close(temp1);

flag4 = 0;

charbuf = ' ';

}

return (0);

}

static int

wcomd(struct Comd *p)

{

int i, fd, savefd;

int savecrunch, savetrunc;

char arg[100], line[BFSBUF];

if (getstr(1, arg, 0, ' ', 0) || defaults(p, 1, 2, 1, Dollar, 1, 0))

return (-1);

if (!arg[0])

return (err(1, "no file name"));

if (equal(arg, bigfile))

return (err(1, "no change indicated"));

if ((fd = open(arg, O_WRONLY|O_CREAT|O_TRUNC,

(S_IRUSR|S_IWUSR|S_IRGRP|S_IWGRP|S_IROTH|S_IWOTH))) < 0)

return (err(1, "can't create"));

savefd = outfildes;

savetrunc = trunc;

savecrunch = crunch;

outfildes = fd;

trunc = BFSTRU;

crunch = -1;

outcnt = 0;

for (i = p->Cadr[0]; i <= p->Cadr[1] && i > 0; i++) {

bigread(i, line);

out(line);

}

if (verbose)

(void) printf("%.0f\n", outcnt);

(void) close(fd);

outfildes = savefd;

trunc = savetrunc;

crunch = savecrunch;

return (0);

}

static int

nlcomd(struct Comd *p)

{

if (defaults(p, 1, 2, Dot+1, Dot+1, 1, 0)) {

(void) mygetc();

return (-1);

}

return (pcomd(p));

}

static int

eqcomd(struct Comd *p)

{

if (more() || defaults(p, 1, 1, Dollar, 0, 0, 0))

return (-1);

(void) printf("%d\n", p->Cadr[0]);

return (0);

}

static int

colcomd(struct Comd *p)

{

return (defaults(p, 1, 0, 0, 0, 0, 0));

}

static int

xcomdlist(struct Comd *p)

{

flag = 1;

flag2 = 1;

(void) newfile(1, "");

while (flag2)

begin(p);

if (flag == 0)

return (1);

flag = 0;

return (0);

}

static int

excomd()

{

pid_t i;

int j;

if (infildes != 100)

charbuf = '\n';

while ((i = fork()) < (pid_t)0)

(void) sleep(10);

if (i == (pid_t)0) {

/* Guarantees child can be intr. */

(void) signal(SIGINT, SIG_DFL);

if (infildes == 100 || flag4) {

(void) execl("/usr/bin/sh", "sh", "-c", intptr, 0);

exit(0);

}

if (infildes != 0) {

(void) close(0);

(void) dup(infildes);

}

for (j = 3; j < 15; j++) (void) close(j);

(void) execl("/usr/bin/sh", "sh", "-t", 0);

exit(0);

}

(void) signal(SIGINT, SIG_IGN);

while (wait(status) != i);

status[0] = status[0] >> 8;

#if defined(__STDC__)

(void) signal(SIGINT, (void (*)(int))reset);

#else

(void) signal(SIGINT, reset); /* Restore signal to previous status */

#endif

if (((infildes == 0) || ((infildes == 100) &&

(fstack[fstack[0]] == 0)))&& verbose && (!flag4))

(void) printf("!\n");

return (0);

}

static int

defaults(struct Comd *p, int prt, int max,

int def1, int def2, int setdot, int errsok)

{

if (!def1)

def1 = Dot;

if (!def2)

def2 = def1;

if (p->Cnumadr >= max)

return (errsok?-1:err(prt, "adr count"));

if (p->Cnumadr < 0) {

p->Cadr[++p->Cnumadr] = def1;

p->Cadr[++p->Cnumadr] = def2;

} else if (p->Cnumadr < 1)

p->Cadr[++p->Cnumadr] = p->Cadr[0];

if (p->Cadr[0] < 1 || p->Cadr[0] > Dollar ||

p->Cadr[1] < 1 || p->Cadr[1] > Dollar)

return (errsok?-1:err(prt, "range"));

if (p->Cadr[0] > p->Cadr[1])

return (errsok?-1:err(prt, "adr1 > adr2"));

if (setdot)

Dot = p->Cadr[1];

return (0);

}

static int

getcomd(struct Comd *p, int prt)

{

int r;

int c;

p->Cnumadr = -1;

p->Csep = ' ';

switch (c = peekc()) {

case ',':

case ';': p->Cop = mygetc();

return (0);

}

if ((r = getadrs(p, prt)) < 0)

return (r);

if ((c = peekc()) < 0)

return (err(prt, "syntax"));

if (c == '\n')

p->Cop = '\n';

else

p->Cop = mygetc();

return (0);

}

static int

getadrs(struct Comd *p, int prt)

{

int r;

char c;

if ((r = getadr(p, prt)) < 0)

return (r);

switch (c = peekc()) {

case ';':

Dot = p->Cadr[0];

(void) mygetc();

p->Csep = c;

return (getadr(p, prt));

case ',':

(void) mygetc();

p->Csep = c;

return (getadr(p, prt));

}

return (0);

}

static int

getadr(struct Comd *p, int prt)

{

int r;

char c;

r = 0;

while (peekc() == ' ')

(void) mygetc(); /* Ignore leading spaces */

switch (c = peekc()) {

case '\n':

case ',':

case ';': return (0);

case '\'': (void) mygetc();

r = getmark(p, prt);

break;

case '0':

case '1':

case '2':

case '3':

case '4':

case '5':

case '6':

case '7':

case '8':

case '9': r = getnumb(p, prt);

break;

case '.': (void) mygetc();

p->Cadr[++p->Cnumadr] = Dot;

break;

case '+':

case '-': p->Cadr[++p->Cnumadr] = Dot;

break;

case '$': (void) mygetc();

p->Cadr[++p->Cnumadr] = Dollar;

break;

case '^': (void) mygetc();

p->Cadr[++p->Cnumadr] = Dot - 1;

break;

case '/':

case '?':

case '>':

case '<': (void) mygetc();

r = getrex(p, prt, c);

break;

default: return (0);

}

if (r == 0)

r = getrel(p, prt);

return (r);

}

static int

getnumb(struct Comd *p, int prt)

{

int i;

if ((i = rdnumb(prt)) < 0)

return (-1);

p->Cadr[++p->Cnumadr] = i;

return (0);

}

static int

rdnumb(int prt)

{

char num[20], *n;

int i;

n = num;

while ((*n = peekc()) >= '0' && *n <= '9') {

n++;

(void) mygetc();

}

*n = '\0';

if ((i = patoi(num)) >= 0)

return (i);

return (err(prt, "bad num"));

}

static int

getrel(struct Comd *p, int prt)

{

int op, n;

char c;

int j;

n = 0;

op = 1;

while ((c = peekc()) == '+' || c == '-') {

if (c == '+')

n++;

else

n--;

(void) mygetc();

}

j = n;

if (n < 0)

op = -1;

if (c == '\n')

p->Cadr[p->Cnumadr] += n;

else {

if ((n = rdnumb(0)) > 0 && p->Cnumadr >= 0) {

p->Cadr[p->Cnumadr] += op*n;

(void) getrel(p, prt);

} else {

p->Cadr[p->Cnumadr] += j;

}

}

return (0);

}

static int

getmark(struct Comd *p, int prt)

{

char c;

if ((c = peekc()) < 'a' || c > 'z')

return (err(prt, "bad mark"));

(void) mygetc();

if (!mark[c])

return (err(prt, "undefined mark"));

p->Cadr[++p->Cnumadr] = mark[c];

return (0);

}

static int

getrex(struct Comd *p, int prt, char c)

{

int down, wrap, start;

if (peekc() == c)

(void) mygetc();

else if (getstr(prt, currex, c, 0, 1))

return (-1);

switch (c) {

case '/': down = 1; wrap = 1; break;

case '?': down = 0; wrap = 1; break;

case '>': down = 1; wrap = 0; break;

case '<': down = 0; wrap = 0; break;

}

if (p->Csep == ';')

start = p->Cadr[0];

else

start = Dot;

if ((p->Cadr[++p->Cnumadr] = hunt(prt, currex, start, down, wrap, 0))

< 0)

return (-1);

return (0);

}

static int

hunt(int prt, char rex[], int start, int down, int wrap, int errsok)

{

int i, end1, incr;

int start1, start2;

char line[BFSBUF];

if (down) {

start1 = start + 1;

end1 = Dollar;

start2 = 1;

incr = 1;

} else {

start1 = start - 1;

end1 = 1;

start2 = Dollar;

incr = -1;

}

rebuf = compile(rex, (char *)0, (char *)0);

if (regerrno)

(void) regerr(regerrno);

else

if (rebuf)

free(rebuf);

for (i = start1; i != end1+incr; i += incr) {

bigread(i, line);

if (step(line, rebuf)) {

return (i);

}

}

if (!wrap)

return (errsok?-1:err(prt, "not found"));

for (i = start2; i != start1; i += incr) {

bigread(i, line);

if (step(line, rebuf)) {

return (i);

}

}

return (errsok?-1:err(prt, "not found"));

}

static int

jump(int prt, char label[])

{

char *l;

char line[256];

if (infildes == 0 && tty)

return (err(prt, "jump on tty"));

if (infildes == 100)

intptr = internal;

else

(void) lseek(infildes, 0L, 0);

(void) snprintf(strtmp,

sizeof (strtmp) * sizeof (char), "^: *%s$", label);

rebuf = compile(strtmp, (char *)0, (char *)0);

if (regerrno) {

(void) regerr(regerrno);

return (-1);

}

for (l = line; readc(infildes, l); l++) {

if (*l == '\n') {

*l = '\0';

if (step(line, rebuf)) {

charbuf = '\n';

return (peeked = 0);

}

l = line - 1;

}

}

return (err(prt, "label not found"));

}

static int

getstr(int prt, char buf[], char brk, char ignr, int nonl)

{

char *b, c, prevc;

prevc = 0;

for (b = buf; c = peekc(); prevc = c) {

if (c == '\n') {

if (prevc == '\\' && (!flag3)) *(b-1) = mygetc();

else if (prevc == '\\' && flag3) {

*b++ = mygetc();

} else if (nonl)

break;

else

return (*b = '\0');

} else {

(void) mygetc();

if (c == brk) {

if (prevc == '\\') *(b-1) = c;

else return (*b = '\0');

} else if (b != buf || c != ignr) *b++ = c;

}

}

return (err(prt, "syntax"));

}

static int

regerr(int c)

{

if (prompt) {

switch (c) {

case 11: (void) printf("Range endpoint too large.\n");

break;

case 16: (void) printf("Bad number.\n");

break;

case 25: (void) printf("``\\digit'' out of range.\n");

break;

case 41: (void) printf("No remembered search string.\n");

break;

case 42: (void) printf("() imbalance.\n");

break;

case 43: (void) printf("Too many (.\n");

break;

case 44: (void) printf("More than 2 numbers given in { }.\n");

break;

case 45: (void) printf("} expected after \\.\n");

break;

case 46: (void) printf("First number exceeds second in { }.\n");

break;

case 49: (void) printf("[] imbalance.\n");

break;

case 50: (void) printf("Regular expression overflow.\n");

break;

case 67: (void) printf("Illegal byte sequence.\n");

break;

default: (void) printf("RE error.\n");

break;

}

} else {

(void) printf("?\n");

}

return (-1);

}

static int

err(int prt, char msg[])

{

if (prt) (prompt? (void) printf("%s\n", msg): (void) printf("?\n"));

if (infildes != 0) {

infildes = pop(fstack);

charbuf = '\n';

peeked = 0;

flag3 = 0;

flag2 = 0;

flag = 0;

}

return (-1);

}

static char

mygetc()

{

if (!peeked) {

while ((!(infildes == oldfd && flag)) && (!flag1) &&

(!readc(infildes, &charbuf))) {

if (infildes == 100 && (!flag)) flag1 = 1;

if ((infildes = pop(fstack)) == -1) quit();

if ((!flag1) && infildes == 0 && flag3 && prompt)

(void) printf("*");

}

if (infildes == oldfd && flag) flag2 = 0;

flag1 = 0;

} else peeked = 0;

return (charbuf);

}

static int

readc(int f, char *c)

{

if (f == 100) {

if (!(*c = *intptr++)) {

intptr--;

charbuf = '\n';

return (0);

}

} else if (read(f, c, 1) != 1) {

(void) close(f);

charbuf = '\n';

return (0);

}

return (1);

}

static int

percent(char line[256])

{

char *lp, *var;

char *front, *per, c[2], *olp, p[2], fr[256];

int i, j;

per = p;

var = c;

front = fr;

j = 0;

while (!j) {

j = 1;

olp = line;

intptr = internal;

while (step(olp, perbuf)) {

while (loc1 < loc2) *front++ = *loc1++;

*(--front) = '\0';

front = fr;

*per++ = '%';

*per = '\0';

per = p;

*var = *loc2;

if ((i = 1 + strlen(front)) >= 2 && fr[i-2] == '\\') {

(void) strcat(front, "");

--intptr;

(void) strcat(per, "");

} else {

if (!(*var >= '0' && *var <= '9'))

return (err(1, "usage: %digit"));

(void) strcat(front, "");

(void) strcat(varray[*var-'0'], "");

j = 0;

loc2++; /* Compensate for removing --lp above */

}

olp = loc2;

}

(void) strcat(olp, "");

*intptr = '\0';

if (!j) {

intptr = internal;

lp = line;

(void)

strncpy(intptr, lp, sizeof (intptr)*sizeof (char));

}

}

return (0);

}

static int

newfile(int prt, char f[])

{

int fd;

if (!*f) {

if (flag != 0) {

oldfd = infildes;

intptr = comdlist;

} else intptr = internal;

fd = 100;

} else if ((fd = open(f, 0)) < 0) {

(void) snprintf(strtmp, sizeof (strtmp) * sizeof (char),

"cannot open %s", f);

return (err(prt, strtmp));

}

push(fstack, infildes);

if (flag4) oldfd = fd;

infildes = fd;

return (peeked = 0);

}

static void

push(int s[], int d)

{

s[++s[0]] = d;

}

static int

pop(int s[])

{

return (s[s[0]--]);

}

static int

peekc()

{

int c;

c = mygetc();

peeked = 1;

return (c);

}

static void

eat()

{

if (charbuf != '\n')

while (mygetc() != '\n');

peeked = 0;

}

static int

more()

{

if (mygetc() != '\n')

return (err(1, "syntax"));

return (0);

}

static void

quit()

{

exit(0);

}

static void

out(char *ln)

{

char *rp, *wp, prev;

int w, width;

char *oldrp;

wchar_t cl;

int p;

ptrdiff_t lim;

if (crunch > 0) {

ln = untab(ln);

rp = wp = ln - 1;

prev = ' ';

while (*++rp) {

if (prev != ' ' || *rp != ' ')

*++wp = *rp;

prev = *rp;

}

*++wp = '\n';

lim = (ptrdiff_t)wp - (ptrdiff_t)ln;

*++wp = '\0';

if (*ln == '\n')

return;

} else

ln[lim = strlen(ln)] = '\n';

if (MB_CUR_MAX <= 1) {

if (lim > trunc)

ln[lim = trunc] = '\n';

} else {

if ((trunc < (BFSBUF -1)) || (lim > trunc)) {

w = 0;

oldrp = rp = ln;

/*CONSTCOND*/while (1) {

if ((p = mbtowc(&cl, rp, MB_LEN_MAX)) == 0) {

break;

}

if (p == -1) {

width = p = 1;

} else {

width = scrwidth(cl);

if (width == 0)

width = 1;

}

if ((w += width) > trunc)

break;

rp += p;

}

*rp = '\n';

lim = (ptrdiff_t)rp - (ptrdiff_t)oldrp;

}

}

outcnt += write(outfildes, ln, lim+1);

}

static char *

untab(char l[])

{

static char line[BFSBUF];

char *q, *s;

s = l;

q = line;

do {

if (*s == '\t')

do

*q++ = ' ';

while (((ptrdiff_t)q-(ptrdiff_t)line)%8);

else *q++ = *s;

} while (*s++);

return (line);

}

static int

patoi(char *b)

{

int i;

char *a;

a = b;

i = 0;

while (*a >= '0' && *a <= '9') i = 10 * i + *a++ - '0';

if (*a)

return (-1);

return (i);

}

static int

equal(char *a, char *b)

{

char *x, *y;

x = a;

y = b;

while (*x == *y++)

if (*x++ == 0)

return (1);

return (0);

}