/* Copyright 1987 Brian Beattie Rights Reserved.
 *
 * Permission to copy and/or distribute granted under the
 * following conditions:
 *
 * 1). No charge may be made other than resonable charges
 *	for reproduction.
 *
 * 2). This notice must remain intact.
 *
 * 3). No further restrictions may be added.
 *
 */

/*	This program used to be in many little pieces, with this makefile:
.SUFFIXES:	.c .s

CFLAGS = -F

OBJS =	append.s catsub.s ckglob.s deflt.s del.s docmd.s doglob.s\
  doprnt.s doread.s dowrite.s ed.s egets.s find.s getfn.s getlst.s\
  getnum.s getone.s getptr.s getrhs.s gettxt.s ins.s join.s maksub.s\
  move.s optpat.s set.s setbuf.s subst.s getpat.s matchs.s amatch.s\
  unmkpat.s omatch.s makepat.s bitmap.s dodash.s esc.s System.s

ed:	$(OBJS)
  cc -T. -i -o ed $(OBJS)
*/

#include <sys/types.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/wait.h>
#include <stdio.h>

/****************************/

/*	tools.h	*/
/*
 *	#defines for non-printing ASCII characters
 */

#define NUL	0x00		/* ^@ */
#define EOS	0x00		/* end of string */
#define SOH	0x01		/* ^A */
#define STX	0x02		/* ^B */
#define ETX	0x03		/* ^C */
#define EOT	0x04		/* ^D */
#define ENQ	0x05		/* ^E */
#define ACK	0x06		/* ^F */
#define BEL	0x07		/* ^G */
#define BS	0x08		/* ^H */
#define HT	0x09		/* ^I */
#define LF	0x0a		/* ^J */
#define NL	'\n'
#define VT	0x0b		/* ^K */
#define FF	0x0c		/* ^L */
#define CR	0x0d		/* ^M */
#define SO	0x0e		/* ^N */
#define SI	0x0f		/* ^O */
#define DLE	0x10		/* ^P */
#define DC1	0x11		/* ^Q */
#define DC2	0x12		/* ^R */
#define DC3	0x13		/* ^S */
#define DC4	0x14		/* ^T */
#define NAK	0x15		/* ^U */
#define SYN	0x16		/* ^V */
#define ETB	0x17		/* ^W */
#define CAN	0x18		/* ^X */
#define EM	0x19		/* ^Y */
#define SUB	0x1a		/* ^Z */
#define ESC	0x1b		/* ^[ */
#define FS	0x1c		/* ^\ */
#define GS	0x1d		/* ^] */
#define RS	0x1e		/* ^^ */
#define US	0x1f		/* ^_ */
#define SP	0x20		/* space */
#define DEL	0x7f		/* DEL */


#define TRUE	1
#define FALSE	0
#define ERR	-2


/*	Definitions of meta-characters used in pattern matching
 *	routines.  LITCHAR & NCCL are only used as token identifiers;
 *	all the others are also both token identifier and actual symbol
 *	used in the regular expression.
 */


#define BOL	'^'
#define EOL	'$'
#define ANY	'.'
#define LITCHAR	'L'
#define	ESCAPE	'\\'
#define CCL	'['		/* Character class: [...] */
#define CCLEND	']'
#define NEGATE	'^'
#define NCCL	'!'		/* Negative character class [^...] */
#define CLOSURE	'*'
#define OR_SYM	'|'
#define DITTO	'&'
#define OPEN	'('
#define CLOSE	')'

/* Largest permitted size for an expanded character class.  (i.e. the class
 * [a-z] will expand into 26 symbols; [a-z0-9] will expand into 36.)
 */
#define CLS_SIZE	128

/*
 *	Tokens are used to hold pattern templates. (see makepat())
 */
typedef char BITMAP;

typedef struct token {
  char tok;
  char lchar;
  BITMAP *bitmap;
  struct token *next;
} TOKEN;

#define TOKSIZE sizeof (TOKEN)

/*
 *	An absolute maximun for strings.
 */

#define MAXSTR	132		/* Maximum numbers of characters in a line */


/* Macros */
#define max(a,b)	((a>b)?a:b)
#define min(a,b)	((a<b)?a:b)
#define toupper(c)	(c>='a'&&c<='z'?c-32:c)

/*	ed.h	*/
#define FATAL	(ERR-1)
struct line {
  int l_stat;			/* empty, mark */
  struct line *l_prev;
  struct line *l_next;
  char l_buff[1];
};

typedef struct line LINE;

#define LINFREE	1		/* entry not in use */
#define LGLOB	2		/* line marked global */

				/* max number of chars per line */
#define MAXLINE	(sizeof(int) == 2 ? 256 : 8192)
#define MAXPAT	256		/* max number of chars per replacement
				 * pattern */
				/* max file name size */
#define MAXFNAME (sizeof(int) == 2 ? 256 : 1024)

extern LINE line0;
extern int curln, lastln, line1, line2, nlines;
extern int nflg;		/* print line number flag */
extern int lflg;		/* print line in verbose mode */
extern char *inptr;		/* tty input buffer */
extern char linbuf[], *linptr;	/* current line */
extern int truncflg;		/* truncate long line flag */
extern int eightbit;		/* save eighth bit */
extern int nonascii;		/* count of non-ascii chars read */
extern int nullchar;		/* count of null chars read */
extern int truncated;		/* count of lines truncated */
extern int fchanged;		/* file changed */

#define nextln(l)	((l)+1 > lastln ? 0 : (l)+1)
#define prevln(l)	((l)-1 < 0 ? lastln : (l)-1)

/*	amatch.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */

#define _PROTOTYPE(a, b) a b
_PROTOTYPE(int main, (int argc, char **argv));
_PROTOTYPE(static char *match, (char *lin, TOKEN *pat, char *boln));
_PROTOTYPE(char *amatch, (char *lin, TOKEN *pat, char *boln));
_PROTOTYPE(int append, (int line, int glob));
_PROTOTYPE(BITMAP *makebitmap, (unsigned size));
_PROTOTYPE(int setbit, (unsigned c, char *map, unsigned val));
_PROTOTYPE(int testbit, (unsigned c, char *map));
_PROTOTYPE(char *catsub, (char *from, char *to, char *sub, char *new, char *newend));
_PROTOTYPE(int ckglob, (void));
_PROTOTYPE(int deflt, (int def1, int def2));
_PROTOTYPE(int del, (int from, int to));
_PROTOTYPE(int docmd, (int glob));
_PROTOTYPE(int dolst, (int line1, int line2));
_PROTOTYPE(char *dodash, (int delim, char *src, char *map));
_PROTOTYPE(int doglob, (void));
_PROTOTYPE(int doprnt, (int from, int to));
_PROTOTYPE(void prntln, (char *str, int vflg, int lin));
_PROTOTYPE(void putcntl, (int c, FILE *stream));
_PROTOTYPE(int doread, (int lin, char *fname));
_PROTOTYPE(int dowrite, (int from, int to, char *fname, int apflg));
_PROTOTYPE(void intr, (int sig));
_PROTOTYPE(int egets, (char *str, int size, FILE *stream));
_PROTOTYPE(int esc, (char **s));
_PROTOTYPE(int find, (TOKEN *pat, int dir));
_PROTOTYPE(char *getfn, (void));
_PROTOTYPE(int getlst, (void));
_PROTOTYPE(int getnum, (int first));
_PROTOTYPE(int getone, (void));
_PROTOTYPE(TOKEN *getpat, (char *arg));
_PROTOTYPE(LINE *getptr, (int num));
_PROTOTYPE(int getrhs, (char *sub));
_PROTOTYPE(char *gettxt, (int num));
_PROTOTYPE(int ins, (char *str));
_PROTOTYPE(int System, (char *c));
_PROTOTYPE(int join, (int first, int last));
_PROTOTYPE(TOKEN *makepat, (char *arg, int delim));
_PROTOTYPE(char *maksub, (char *sub, int subsz));
_PROTOTYPE(char *matchs, (char *line, TOKEN *pat, int ret_endp));
_PROTOTYPE(int move, (int num));
_PROTOTYPE(int transfer, (int num));
_PROTOTYPE(int omatch, (char **linp, TOKEN *pat, char *boln));
_PROTOTYPE(TOKEN *optpat, (void));
_PROTOTYPE(int set, (void));
_PROTOTYPE(int show, (void));
_PROTOTYPE(void relink, (LINE *a, LINE *x, LINE *y, LINE *b));
_PROTOTYPE(void clrbuf, (void));
_PROTOTYPE(void set_buf, (void));
_PROTOTYPE(int subst, (TOKEN *pat, char *sub, int gflg, int pflag));
_PROTOTYPE(void unmakepat, (TOKEN *head));

/*     Scans throught the pattern template looking for a match
 * with lin.  Each element of lin is compared with the template
 * until either a mis-match is found or the end of the template
 * is reached.  In the former case a 0 is returned; in the latter,
 * a pointer into lin (pointing to the character following the
 * matched pattern) is returned.
 *
 *	"lin"	is a pointer to the line being searched.
 *	"pat"	is a pointer to a template made by makepat().
 *	"boln"	is a pointer into "lin" which points at the
 *			character at the beginning of the line.
 */

char *paropen[9], *parclose[9];
int between, parnum;

char *amatch(lin, pat, boln)
char *lin;
TOKEN *pat;
char *boln;
{
  between = 0;
  parnum = 0;

  lin = match(lin, pat, boln);

  if (between) return 0;

  while (parnum < 9) {
	paropen[parnum] = parclose[parnum] = "";
	parnum++;
  }
  return lin;
}

static char *match(lin, pat, boln)
char *lin;
TOKEN *pat;
char *boln;
{
  register char *bocl, *rval, *strstart;

  if (pat == 0) return 0;

  strstart = lin;

  while (pat) {
	if (pat->tok == CLOSURE && pat->next) {
		/* Process a closure: first skip over the closure
		 * token to the object to be repeated.  This object
		 * can be a character class. */

		pat = pat->next;

		/* Now match as many occurrences of the closure
		 * pattern as possible. */
		bocl = lin;

		while (*lin && omatch(&lin, pat, boln));

		/* 'Lin' now points to the character that made made
		 * us fail.  Now go on to process the rest of the
		 * string.  A problem here is a character following
		 * the closure which could have been in the closure.
		 * For example, in the pattern "[a-z]*t" (which
		 * matches any lower-case word ending in a t), the
		 * final 't' will be sucked up in the while loop.
		 * So, if the match fails, we back up a notch and try
		 * to match the rest of the string again, repeating
		 * this process recursively until we get back to the
		 * beginning of the closure.  The recursion goes, at
		 * most two levels deep. */

		if (pat = pat->next) {
			int savbtwn = between;
			int savprnm = parnum;

			while (bocl <= lin) {
				if (rval = match(lin, pat, boln)) {
					/* Success */
					return(rval);
				} else {
					--lin;
					between = savbtwn;
					parnum = savprnm;
				}
			}
			return(0);	/* match failed */
		}
	} else if (pat->tok == OPEN) {
		if (between || parnum >= 9) return 0;
		paropen[parnum] = lin;
		between = 1;
		pat = pat->next;
	} else if (pat->tok == CLOSE) {
		if (!between) return 0;
		parclose[parnum++] = lin;
		between = 0;
		pat = pat->next;
	} else if (omatch(&lin, pat, boln)) {
		pat = pat->next;
	} else {
		return(0);
	}
  }

  /* Note that omatch() advances lin to point at the next character to
   * be matched.  Consequently, when we reach the end of the template,
   * lin will be pointing at the character following the last character
   * matched.  The exceptions are templates containing only a BOLN or
   * EOLN token.  In these cases omatch doesn't advance.
   * 
   * A philosophical point should be mentioned here.  Is $ a position or a
   * character? (i.e. does $ mean the EOL character itself or does it
   * mean the character at the end of the line.)  I decided here to
   * make it mean the former, in order to make the behavior of match()
   * consistent.  If you give match the pattern ^$ (match all lines
   * consisting only of an end of line) then, since something has to be
   * returned, a pointer to the end of line character itself is
   * returned. */

  return((char *) max(strstart, lin));
}

/*	append.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int append(line, glob)
int line, glob;
{
  int stat;
  char lin[MAXLINE];

  if (glob) return(ERR);
  curln = line;
  while (1) {
	if (nflg) printf("%6d. ", curln + 1);

	if (fgets(lin, MAXLINE, stdin) == NULL) return(EOF);
	if (lin[0] == '.' && lin[1] == '\n') return (0);
	stat = ins(lin);
	if (stat < 0) return(ERR);

  }
}

/*	bitmap.c	*/
/*
 *	BITMAP.C -	makebitmap, setbit, testbit
 *			bit-map manipulation routines.
 *
 *	Copyright (c) Allen I. Holub, all rights reserved.  This program may
 *		for copied for personal, non-profit use only.
 *
 */

#ifdef DEBUG
/* #include <stdio.h> */
#endif

/* #include "tools.h" */


BITMAP *makebitmap(size)
unsigned size;
{
  /* Make a bit map with "size" bits.  The first entry in the map is an
   * "unsigned int" representing the maximum bit.  The map itself is
   * concatenated to this integer. Return a pointer to a map on
   * success, 0 if there's not enough memory. */

  unsigned *map, numbytes;

  numbytes = (size >> 3) + ((size & 0x07) ? 1 : 0);

#ifdef DEBUG
  printf("Making a %d bit map (%d bytes required)\n", size, numbytes);
#endif

  if (map = (unsigned *) malloc(numbytes + sizeof(unsigned))) {
	*map = size;
	memset(map + 1, 0, numbytes);
  }

  return((BITMAP *) map);
}

int setbit(c, map, val)
unsigned c, val;
char *map;
{
  /* Set bit c in the map to val. If c > map-size, 0 is returned, else
   * 1 is returned. */

  if (c >= *(unsigned *) map)	/* if c >= map size */
	return 0;

  map += sizeof(unsigned);	/* skip past size */

  if (val)
	map[c >> 3] |= 1 << (c & 0x07);
  else
	map[c >> 3] &= ~(1 << (c & 0x07));

  return 1;
}

int testbit(c, map)
unsigned c;
char *map;
{
  /* Return 1 if the bit corresponding to c in map is set. 0 if it is not. */

  if (c >= *(unsigned *) map) return 0;

  map += sizeof(unsigned);

  return(map[c >> 3] & (1 << (c & 0x07)));
}

/*	catsub.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

extern char *paropen[9], *parclose[9];

char *catsub(from, to, sub, new, newend)
char *from, *to, *sub, *new, *newend;
{
  char *cp, *cp2;

  for (cp = new; *sub != EOS && cp < newend;) {
	if (*sub == DITTO) for (cp2 = from; cp2 < to;) {
			*cp++ = *cp2++;
			if (cp >= newend) break;
		}
	else if (*sub == ESCAPE) {
		sub++;
		if ('1' <= *sub && *sub <= '9') {
			char *parcl = parclose[*sub - '1'];

			for (cp2 = paropen[*sub - '1']; cp2 < parcl;) {
				*cp++ = *cp2++;
				if (cp >= newend) break;
			}
		} else
			*cp++ = *sub;
	} else
		*cp++ = *sub;

	sub++;
  }

  return(cp);
}

/*	ckglob.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int ckglob()
{
  TOKEN *glbpat;
  char c, delim;
  char lin[MAXLINE];
  int num;
  LINE *ptr;

  c = *inptr;

  if (c != 'g' && c != 'v') return(0);

  if (deflt(1, lastln) < 0) return(ERR);

  delim = *++inptr;
  if (delim <= ' ') return(ERR);

  glbpat = optpat();

  if (*inptr == delim) inptr++;

  ptr = getptr(1);
  for (num = 1; num <= lastln; num++) {
	ptr->l_stat &= ~LGLOB;
	if (line1 <= num && num <= line2) {
		strcpy(lin, ptr->l_buff);
		strcat(lin, "\n");
		if (matchs(lin, glbpat, 0)) {
			if (c == 'g') ptr->l_stat |= LGLOB;
		} else {
			if (c == 'v') ptr->l_stat |= LGLOB;
		}
	}
	ptr = ptr->l_next;
  }
  return(1);
}

/*	deflt.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int deflt(def1, def2)
int def1, def2;
{
  if (nlines == 0) {
	line1 = def1;
	line2 = def2;
  }
  if (line1 > line2 || line1 <= 0) return(ERR);
  return(0);
}

/*	del.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int del(from, to)
int from, to;
{
  LINE *first, *last, *next, *tmp;

  if (from < 1) from = 1;
  first = getptr(prevln(from));
  last = getptr(nextln(to));
  next = first->l_next;
  while (next != last && next != &line0) {
	tmp = next->l_next;
	free((char *) next);
	next = tmp;
  }
  relink(first, last, first, last);
  lastln -= (to - from) + 1;
  curln = prevln(from);
  return(0);
}

/*	docmd.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

char fname[MAXFNAME];
int fchanged;
extern int nofname;

extern int mark[];

int docmd(glob)
int glob;
{
  static char rhs[MAXPAT];
  TOKEN *subpat;
  int c, err, line3;
  int apflg, pflag, gflag;
  int nchng;
  char *fptr;

  pflag = FALSE;
  while (*inptr == SP || *inptr == HT) inptr++;

  c = *inptr++;

  switch (c) {
      case NL:
	if (nlines == 0) {
		if ((line2 = nextln(curln)) == 0) return(ERR);
	}
	curln = line2;
	return(1);
	break;

      case '=':	printf("%d\n", line2);	break;

      case 'a':
	if (*inptr != NL || nlines > 1) return(ERR);

	if (append(line1, glob) < 0) return(ERR);;
	fchanged = TRUE;
	break;

      case 'c':
	if (*inptr != NL) return(ERR);

	if (deflt(curln, curln) < 0) return(ERR);

	if (del(line1, line2) < 0) return(ERR);
	if (append(curln, glob) < 0) return (ERR);
	fchanged = TRUE;
	break;

      case 'd':
	if (*inptr != NL) return(ERR);

	if (deflt(curln, curln) < 0) return(ERR);

	if (del(line1, line2) < 0) return(ERR);
	if (nextln(curln) != 0) curln = nextln(curln);
	fchanged = TRUE;
	break;

      case 'e':
	if (nlines > 0) return(ERR);
	if (fchanged) {
		fchanged = FALSE;
		return(ERR);
	}

	/* FALL THROUGH */
      case 'E':
	if (nlines > 0) return(ERR);

	if (*inptr != ' ' && *inptr != HT && *inptr != NL) return(ERR);

	if ((fptr = getfn()) == NULL) return(ERR);

	clrbuf();
	if ((err = doread(0, fptr)) < 0) return(err);

	strcpy(fname, fptr);
	fchanged = FALSE;
	break;

      case 'f':
	if (nlines > 0) return(ERR);

	if (*inptr != ' ' && *inptr != HT && *inptr != NL) return(ERR);

	if ((fptr = getfn()) == NULL) return(ERR);

	if (nofname)
		printf("%s\n", fname);
	else
		strcpy(fname, fptr);
	break;

      case 'i':
	if (*inptr != NL || nlines > 1) return(ERR);

	if (append(prevln(line1), glob) < 0) return(ERR);
	fchanged = TRUE;
	break;

      case 'j':
	if (*inptr != NL || deflt(curln, curln + 1) < 0) return(ERR);

	if (join(line1, line2) < 0) return(ERR);
	break;

      case 'k':
	while (*inptr == ' ' || *inptr == HT) inptr++;

	if (*inptr < 'a' || *inptr > 'z') return ERR;
	c = *inptr++;

	if (*inptr != ' ' && *inptr != HT && *inptr != NL) return(ERR);

	mark[c - 'a'] = line1;
	break;

      case 'l':
	if (*inptr != NL) return(ERR);
	if (deflt(curln, curln) < 0) return (ERR);
	if (dolst(line1, line2) < 0) return (ERR);
	break;

      case 'm':
	if ((line3 = getone()) < 0) return(ERR);
	if (deflt(curln, curln) < 0) return (ERR);
	if (move(line3) < 0) return (ERR);
	fchanged = TRUE;
	break;

      case 'P':
      case 'p':
	if (*inptr != NL) return(ERR);
	if (deflt(curln, curln) < 0) return (ERR);
	if (doprnt(line1, line2) < 0) return (ERR);
	break;

      case 'q':
	if (fchanged) {
		fchanged = FALSE;
		return(ERR);
	}

	/* FALL THROUGH */
      case 'Q':
	if (*inptr == NL && nlines == 0 && !glob)
		return(EOF);
	else
		return(ERR);

      case 'r':
	if (nlines > 1) return(ERR);

	if (nlines == 0) line2 = lastln;

	if (*inptr != ' ' && *inptr != HT && *inptr != NL) return(ERR);

	if ((fptr = getfn()) == NULL) return(ERR);

	if ((err = doread(line2, fptr)) < 0) return(err);
	fchanged = TRUE;
	break;

      case 's':
	if (*inptr == 'e') return(set());
	while (*inptr == SP || *inptr == HT) inptr++;
	if ((subpat = optpat()) == NULL) return (ERR);
	if ((gflag = getrhs(rhs)) < 0) return (ERR);
	if (*inptr == 'p') pflag++;
	if (deflt(curln, curln) < 0) return (ERR);
	if ((nchng = subst(subpat, rhs, gflag, pflag)) < 0) return (ERR);
	if (nchng) fchanged = TRUE;
	break;

      case 't':
	if ((line3 = getone()) < 0) return(ERR);
	if (deflt(curln, curln) < 0) return (ERR);
	if (transfer(line3) < 0) return (ERR);
	fchanged = TRUE;
	break;

      case 'W':
      case 'w':
	apflg = (c == 'W');

	if (*inptr != ' ' && *inptr != HT && *inptr != NL) return(ERR);

	if ((fptr = getfn()) == NULL) return(ERR);

	if (deflt(1, lastln) < 0) return(ERR);
	if (dowrite(line1, line2, fptr, apflg) < 0) return (ERR);
	fchanged = FALSE;
	break;

      case 'x':
	if (*inptr == NL && nlines == 0 && !glob) {
		if ((fptr = getfn()) == NULL) return(ERR);
		if (dowrite(1, lastln, fptr, 0) >= 0) return (EOF);
	}
	return(ERR);

      case 'z':
	if (deflt(curln, curln) < 0) return(ERR);

	switch (*inptr) {
	    case '-':
		if (doprnt(line1 - 21, line1) < 0) return(ERR);
		break;

	    case '.':
		if (doprnt(line1 - 11, line1 + 10) < 0) return(ERR);
		break;

	    case '+':
	    case '\n':
		if (doprnt(line1, line1 + 21) < 0) return(ERR);
		break;
	}
	break;

      default:	return(ERR);
}
  return(0);
}

int dolst(line1, line2)
int line1, line2;
{
  int oldlflg = lflg, p;

  lflg = 1;
  p = doprnt(line1, line2);
  lflg = oldlflg;

  return p;
}

/*	dodash.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */

/*	Expand the set pointed to by *src into dest.
 *	Stop at delim.  Return 0 on error or size of
 *	character class on success.  Update *src to
 *	point at delim.  A set can have one element
 *	{x} or several elements ( {abcdefghijklmnopqrstuvwxyz}
 *	and {a-z} are equivalent ).  Note that the dash
 *	notation is expanded as sequential numbers.
 *	This means (since we are using the ASCII character
 *	set) that a-Z will contain the entire alphabet
 *	plus the symbols: [\]^_`.  The maximum number of
 *	characters in a character class is defined by maxccl.
 */
char *dodash(delim, src, map)
int delim;
char *src, *map;
{

  register int first, last;
  char *start;

  start = src;

  while (*src && *src != delim) {
	if (*src != '-') setbit(esc(&src), map, 1);

	else if (src == start || *(src + 1) == delim)
		setbit('-', map, 1);
	else {
		src++;

		if (*src < *(src - 2)) {
			first = *src;
			last = *(src - 2);
		} else {
			first = *(src - 2);
			last = *src;
		}

		while (++first <= last) setbit(first, map, 1);

	}
	src++;
  }
  return(src);
}

/*	doglob.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int doglob()
{
  int lin, stat;
  char *cmd;
  LINE *ptr;

  cmd = inptr;

  while (1) {
	ptr = getptr(1);
	for (lin = 1; lin <= lastln; lin++) {
		if (ptr->l_stat & LGLOB) break;
		ptr = ptr->l_next;
	}
	if (lin > lastln) break;

	ptr->l_stat &= ~LGLOB;
	curln = lin;
	inptr = cmd;
	if ((stat = getlst()) < 0) return(stat);
	if ((stat = docmd(1)) < 0) return (stat);
  }
  return(curln);
}

/*	doprnt.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int doprnt(from, to)
int from, to;
{
  int i;
  LINE *lptr;

  from = from < 1 ? 1 : from;
  to = to > lastln ? lastln : to;

  if (to != 0) {
	lptr = getptr(from);
	for (i = from; i <= to; i++) {
		prntln(lptr->l_buff, lflg, (nflg ? i : 0));
		lptr = lptr->l_next;
	}
	curln = to;
  }
  return(0);
}

void prntln(str, vflg, lin)
char *str;
int vflg, lin;
{
  if (lin) printf("%7d ", lin);
  while (*str && *str != NL) {
	if (*str < ' ' || *str >= 0x7f) {
		switch (*str) {
		    case '\t':
			if (vflg)
				putcntl(*str, stdout);
			else
				putc(*str, stdout);
			break;

		    case DEL:
			putc('^', stdout);
			putc('?', stdout);
			break;

		    default:
			putcntl(*str, stdout);
			break;
		}
	} else
		putc(*str, stdout);
	str++;
  }
  if (vflg) putc('$', stdout);
  putc('\n', stdout);
}

void putcntl(c, stream)
char c;
FILE *stream;
{
  putc('^', stream);
  putc((c & 31) | '@', stream);
}

/*	doread.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

extern int diag;

int doread(lin, fname)
int lin;
char *fname;
{
  FILE *fp;
  int err;
  long bytes;
  int lines;
  static char str[MAXLINE];

  err = 0;
  nonascii = nullchar = truncated = 0;

  if (diag) printf("\"%s\" ", fname);
  if ((fp = fopen(fname, "r")) == NULL) {
	printf("file open err\n");
	return(ERR);
  }
  curln = lin;
  for (lines = 0, bytes = 0; (err = egets(str, MAXLINE, fp)) > 0;) {
	bytes += strlen(str);
	if (ins(str) < 0) {
		printf("file insert error\n");
		err++;
		break;
	}
	lines++;
  }
  fclose(fp);
  if (err < 0) return(err);
  if (diag) {
	printf("%d lines %ld bytes", lines, bytes);
	if (nonascii) printf(" [%d non-ascii]", nonascii);
	if (nullchar) printf(" [%d nul]", nullchar);
	if (truncated) printf(" [%d lines truncated]", truncated);
	printf("\n");
  }
  return(err);
}

/*	dowrite.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int dowrite(from, to, fname, apflg)
int from, to;
char *fname;
int apflg;
{
  FILE *fp;
  int lin, err;
  int lines;
  long bytes;
  char *str;
  LINE *lptr;

  err = 0;

  lines = bytes = 0;
  if (diag) printf("\"%s\" ", fname);
  if ((fp = fopen(fname, (apflg ? "a" : "w"))) == NULL) {
	printf("file open error\n");
	return(ERR);
  }
  lptr = getptr(from);
  for (lin = from; lin <= to; lin++) {
	str = lptr->l_buff;
	lines++;
	bytes += strlen(str) + 1;
	if (fputs(str, fp) == EOF) {
		printf("file write error\n");
		err++;
		break;
	}
	fputc('\n', fp);
	lptr = lptr->l_next;
  }
  if (diag) printf("%d lines %ld bytes\n", lines, bytes);
  fclose(fp);
  return(err);
}

/*	ed.c	*/
/* Copyright 1987 Brian Beattie Rights Reserved.
 *
 * Permission to copy and/or distribute granted under the
 * following conditions:
 *
 * 1). No charge may be made other than resonable charges
 *	for reproduction.
 *
 * 2). This notice must remain intact.
 *
 * 3). No further restrictions may be added.
 *
 */
/* #include <stdio.h> */
/* #include <signal.h> */
/* #include "tools.h" */
/* #include "ed.h" */
#include <setjmp.h>
jmp_buf env;

LINE line0;
int curln = 0;
int lastln = 0;
char *inptr;
static char inlin[MAXLINE];
int nflg, lflg;
int line1, line2, nlines;
extern char fname[];
int version = 1;
int diag = 1;

void intr(sig)
int sig;
{
  printf("?\n");
  longjmp(env, 1);
}

int main(argc, argv)
int argc;
char **argv;
{
  int stat, i, doflush;

  set_buf();
  doflush = isatty(1);

  if (argc > 1 && (strcmp(argv[1], "-") == 0 || strcmp(argv[1], "-s") == 0)) {
	diag = 0;
	argc--;
	argv++;
  }
  if (argc > 1) {
	for (i = 1; i < argc; i++) {
		if (doread(0, argv[i]) == 0) {
			curln = 1;
			strcpy(fname, argv[i]);
			break;
		}
	}
  }
  while (1) {
	setjmp(env);
	if (signal(SIGINT, SIG_IGN) != SIG_IGN) signal(SIGINT, intr);

	if (doflush) fflush(stdout);

	if (fgets(inlin, sizeof(inlin), stdin) == NULL) {
		break;
	}
	for (;;) {
		inptr = strchr(inlin, EOS);
		if (inptr >= inlin+2 && inptr[-2] == '\\' && inptr[-1] == NL) {
			inptr[-1] = 'n';
			if (fgets(inptr, sizeof(inlin) - (inptr - inlin),
						stdin) == NULL) break;
		} else {
			break;
		}
	}
	if (*inlin == '!') {
		if ((inptr = strchr(inlin, NL)) != NULL) *inptr = EOS;
		System(inlin + 1);
		continue;
	}
	inptr = inlin;
	if (getlst() >= 0)
		if ((stat = ckglob()) != 0) {
			if (stat >= 0 && (stat = doglob()) >= 0) {
				curln = stat;
				continue;
			}
		} else {
			if ((stat = docmd(0)) >= 0) {
				if (stat == 1) doprnt(curln, curln);
				continue;
			}
		}
	if (stat == EOF) {
		exit(0);
	}
	if (stat == FATAL) {
		fputs("FATAL ERROR\n", stderr);
		exit(1);
	}
	printf("?\n");
  }
  return(0);
}

/*	egets.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int eightbit = 1;		/* save eight bit */
int nonascii, nullchar, truncated;
int egets(str, size, stream)
char *str;
int size;
FILE *stream;
{
  int c, count;
  char *cp;

  for (count = 0, cp = str; size > count;) {
	c = getc(stream);
	if (c == EOF) {
		*cp++ = '\n';
		*cp = EOS;
		if (count) {
			printf("[Incomplete last line]\n");
		}
		return(count);
	}
	if (c == NL) {
		*cp++ = c;
		*cp = EOS;
		return(++count);
	}
	if (c > 127) {
		if (!eightbit)	/* if not saving eighth bit */
			c = c & 127;	/* strip eigth bit */
		nonascii++;	/* count it */
	}
	if (c) {
		*cp++ = c;	/* not null, keep it */
		count++;
	} else
		nullchar++;	/* count nulls */
  }
  str[count - 1] = EOS;
  if (c != NL) {
	printf("truncating line\n");
	truncated++;
	while ((c = getc(stream)) != EOF)
		if (c == NL) break;
  }
  return(count);
}

/*	esc.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */

/* Map escape sequences into their equivalent symbols.  Returns the
 * correct ASCII character.  If no escape prefix is present then s
 * is untouched and *s is returned, otherwise **s is advanced to point
 * at the escaped character and the translated character is returned.
 */
int esc(s)
char **s;
{
  register int rval;


  if (**s != ESCAPE) {
	rval = **s;
  } else {
	(*s)++;

	switch (toupper(**s)) {
	    case '\000':	rval = ESCAPE;	break;
	    case 'S':	rval = ' ';	break;
	    case 'N':	rval = '\n';	break;
	    case 'T':	rval = '\t';	break;
	    case 'B':	rval = '\b';	break;
	    case 'R':	rval = '\r';	break;
	    default:	rval = **s;	break;
	}
  }

  return(rval);
}

/*	find.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int find(pat, dir)
TOKEN *pat;
int dir;
{
  int i, num;
  char lin[MAXLINE];
  LINE *ptr;

  num = curln;
  ptr = getptr(curln);
  num = (dir ? nextln(num) : prevln(num));
  ptr = (dir ? ptr->l_next : ptr->l_prev);
  for (i = 0; i < lastln; i++) {
	if (num == 0) {
		num = (dir ? nextln(num) : prevln(num));
		ptr = (dir ? ptr->l_next : ptr->l_prev);
	}
	strcpy(lin, ptr->l_buff);
	strcat(lin, "\n");
	if (matchs(lin, pat, 0)) {
		return(num);
	}
	num = (dir ? nextln(num) : prevln(num));
	ptr = (dir ? ptr->l_next : ptr->l_prev);
  }
  return(ERR);
}

/*	getfn.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

extern char fname[MAXFNAME];
int nofname;

char *getfn()
{
  static char file[256];
  char *cp;

  if (*inptr == NL) {
	nofname = TRUE;
	strcpy(file, fname);
  } else {
	nofname = FALSE;
	while (*inptr == SP || *inptr == HT) inptr++;

	cp = file;
	while (*inptr && *inptr != NL && *inptr != SP && *inptr != HT) {
		*cp++ = *inptr++;
	}
	*cp = '\0';

	if (strlen(file) == 0) {
		printf("bad file name\n");
		return(NULL);
	}
  }

  if (strlen(file) == 0) {
	printf("no file name\n");
	return(NULL);
  }
  return(file);
}

/*	getlst.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int getlst()
{
  int num;

  line2 = 0;
  for (nlines = 0; (num = getone()) >= 0;) {
	line1 = line2;
	line2 = num;
	nlines++;
	if (*inptr != ',' && *inptr != ';') break;
	if (*inptr == ';') curln = num;
	inptr++;
  }
  nlines = min(nlines, 2);
  if (nlines == 0) line2 = curln;
  if (nlines <= 1) line1 = line2;

  if (num == ERR)
	return(num);
  else
	return(nlines);
}

/*	getnum.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int mark['z' - 'a' + 1];

int getnum(first)
int first;
{
  TOKEN *srchpat;
  int num;
  char c;

  while (*inptr == SP || *inptr == HT) inptr++;

  if (*inptr >= '0' && *inptr <= '9') {	/* line number */
	for (num = 0; *inptr >= '0' && *inptr <= '9';) {
		num = (num * 10) + *inptr - '0';
		inptr++;
	}
	return num;
  }
  switch (c = *inptr) {
      case '.':
	inptr++;
	return(curln);

      case '$':
	inptr++;
	return(lastln);

      case '/':
      case '?':
	srchpat = optpat();
	if (*inptr == c) inptr++;
	return(find(srchpat, c == '/' ? 1 : 0));

      case '-':
      case '+':
	return(first ? curln : 1);

      case '\'':
	inptr++;
	if (*inptr < 'a' || *inptr > 'z') return(EOF);

	return mark[*inptr++ - 'a'];

      default:
	return(first ? EOF : 1);/* unknown address */
  }
}

/*	getone.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

#define FIRST 1
#define NOTFIRST 0

int getone()
{
  int c, i, num;

  if ((num = getnum(FIRST)) >= 0) {
	while (1) {
		while (*inptr == SP || *inptr == HT) inptr++;

		if (*inptr != '+' && *inptr != '-') break;
		c = *inptr++;

		if ((i = getnum(NOTFIRST)) < 0) return(i);

		if (c == '+') {
			num += i;
		} else {
			num -= i;
		}
	}
  }
  return(num > lastln ? ERR : num);
}

/*	getpat.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */

/* Translate arg into a TOKEN string */
TOKEN *
 getpat(arg)
char *arg;
{

  return(makepat(arg, '\000'));
}

/*	getptr.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

LINE *
 getptr(num)
int num;
{
  LINE *ptr;
  int j;

  if (2 * num > lastln && num <= lastln) {	/* high line numbers */
	ptr = line0.l_prev;
	for (j = lastln; j > num; j--) ptr = ptr->l_prev;
  } else {			/* low line numbers */
	ptr = &line0;
	for (j = 0; j < num; j++) ptr = ptr->l_next;
  }
  return(ptr);
}

/*	getrhs.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int getrhs(sub)
char *sub;
{
  if (inptr[0] == NL || inptr[1] == NL)	/* check for eol */
	return(ERR);

  if (maksub(sub, MAXPAT) == NULL) return(ERR);

  inptr++;			/* skip over delimter */
  while (*inptr == SP || *inptr == HT) inptr++;
  if (*inptr == 'g') {
	inptr++;
	return(1);
  }
  return(0);
}

/*	gettxt.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

char *
 gettxt(num)
int num;
{
  LINE *lin;
  static char txtbuf[MAXLINE];

  lin = getptr(num);
  strcpy(txtbuf, lin->l_buff);
  strcat(txtbuf, "\n");
  return(txtbuf);
}

/*	ins.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int ins(str)
char *str;
{
  char buf[MAXLINE], *cp;
  LINE *new, *cur, *nxt;

  cp = buf;
  while (1) {
	if ((*cp = *str++) == NL) *cp = EOS;
	if (*cp) {
		cp++;
		continue;
	}
	if ((new = (LINE *) malloc(sizeof(LINE) + strlen(buf))) == NULL)
		return(ERR);	/* no memory */

	new->l_stat = 0;
	strcpy(new->l_buff, buf);	/* build new line */
	cur = getptr(curln);	/* get current line */
	nxt = cur->l_next;	/* get next line */
	relink(cur, new, new, nxt);	/* add to linked list */
	relink(new, nxt, cur, new);
	lastln++;
	curln++;

	if (*str == EOS)	/* end of line ? */
		return(1);

	cp = buf;
  }
}

/*	join.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

extern int fchanged;

int join(first, last)
int first, last;
{
  char buf[MAXLINE];
  char *cp = buf, *str;
  int num;

  if (first <= 0 || first > last || last > lastln) return(ERR);
  if (first == last) {
	curln = first;
	return 0;
  }
  for (num = first; num <= last; num++) {
	str = gettxt(num);

	while (*str != NL && cp < buf + MAXLINE - 1) *cp++ = *str++;

	if (cp == buf + MAXLINE - 1) {
		printf("line too long\n");
		return(ERR);
	}
  }
  *cp++ = NL;
  *cp = EOS;
  del(first, last);
  curln = first - 1;
  ins(buf);
  fchanged = TRUE;
  return 0;
}

/*	makepat.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */

/* Make a pattern template from the strinng pointed to by arg.  Stop
 * when delim or '\000' or '\n' is found in arg.  Return a pointer to
 * the pattern template.
 *
 * The pattern template used here are somewhat different than those
 * used in the "Software Tools" book; each token is a structure of
 * the form TOKEN (see tools.h).  A token consists of an identifier,
 * a pointer to a string, a literal character and a pointer to another
 * token.  This last is 0 if there is no subsequent token.
 *
 * The one strangeness here is caused (again) by CLOSURE which has
 * to be put in front of the previous token.  To make this insertion a
 * little easier, the 'next' field of the last to point at the chain
 * (the one pointed to by 'tail) is made to point at the previous node.
 * When we are finished, tail->next is set to 0.
 */
TOKEN *
 makepat(arg, delim)
char *arg;
int delim;
{
  TOKEN *head, *tail, *ntok;
  int error;

  /* Check for characters that aren't legal at the beginning of a template. */

  if (*arg == '\0' || *arg == delim || *arg == '\n' || *arg == CLOSURE)
	return(0);

  error = 0;
  tail = head = NULL;

  while (*arg && *arg != delim && *arg != '\n' && !error) {
	ntok = (TOKEN *) malloc(TOKSIZE);
	ntok->lchar = '\000';
	ntok->next = 0;

	switch (*arg) {
	    case ANY:	ntok->tok = ANY;	break;

	    case BOL:
		if (head == 0)	/* then this is the first symbol */
			ntok->tok = BOL;
		else
			ntok->tok = LITCHAR;
		ntok->lchar = BOL;
		break;

	    case EOL:
		if (*(arg + 1) == delim || *(arg + 1) == '\000' ||
		    *(arg + 1) == '\n') {
			ntok->tok = EOL;
		} else {
			ntok->tok = LITCHAR;
			ntok->lchar = EOL;
		}
		break;

	    case CLOSURE:
		if (head != 0) {
			switch (tail->tok) {
			    case BOL:
			    case EOL:
			    case CLOSURE:
				return(0);

			    default:
				ntok->tok = CLOSURE;
			}
		}
		break;

	    case CCL:

		if (*(arg + 1) == NEGATE) {
			ntok->tok = NCCL;
			arg += 2;
		} else {
			ntok->tok = CCL;
			arg++;
		}

		if (ntok->bitmap = makebitmap(CLS_SIZE))
			arg = dodash(CCLEND, arg, ntok->bitmap);
		else {
			fprintf(stderr, "Not enough memory for pat\n");
			error = 1;
		}
		break;

	    default:
		if (*arg == ESCAPE && *(arg + 1) == OPEN) {
			ntok->tok = OPEN;
			arg++;
		} else if (*arg == ESCAPE && *(arg + 1) == CLOSE) {
			ntok->tok = CLOSE;
			arg++;
		} else {
			ntok->tok = LITCHAR;
			ntok->lchar = esc(&arg);
		}
	}

	if (error || ntok == 0) {
		unmakepat(head);
		return(0);
	} else if (head == 0) {
		/* This is the first node in the chain. */

		ntok->next = 0;
		head = tail = ntok;
	} else if (ntok->tok != CLOSURE) {
		/* Insert at end of list (after tail) */

		tail->next = ntok;
		ntok->next = tail;
		tail = ntok;
	} else if (head != tail) {
		/* More than one node in the chain.  Insert the
		 * CLOSURE node immediately in front of tail. */

		(tail->next)->next = ntok;
		ntok->next = tail;
	} else {
		/* Only one node in the chain,  Insert the CLOSURE
		 * node at the head of the linked list. */

		ntok->next = head;
		tail->next = ntok;
		head = ntok;
	}
	arg++;
  }

  tail->next = 0;
  return(head);
}

/*	maksub.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

char *
 maksub(sub, subsz)
char *sub;
int subsz;
{
  int size;
  char delim, *cp;

  size = 0;
  cp = sub;

  delim = *inptr++;
  for (size = 0; *inptr != delim && *inptr != NL && size < subsz; size++) {
	if (*inptr == '&') {
		*cp++ = DITTO;
		inptr++;
	} else if ((*cp++ = *inptr++) == ESCAPE) {
		if (size >= subsz) return(NULL);

		switch (toupper(*inptr)) {
		    case NL:	*cp++ = ESCAPE;		break;
			break;
		    case 'S':
			*cp++ = SP;
			inptr++;
			break;
		    case 'N':
			*cp++ = NL;
			inptr++;
			break;
		    case 'T':
			*cp++ = HT;
			inptr++;
			break;
		    case 'B':
			*cp++ = BS;
			inptr++;
			break;
		    case 'R':
			*cp++ = CR;
			inptr++;
			break;
		    case '0':{
				int i = 3;
				*cp = 0;
				do {
					if (*++inptr < '0' || *inptr > '7')
						break;

					*cp = (*cp << 3) | (*inptr - '0');
				} while (--i != 0);
				cp++;
			} break;
		    default:	*cp++ = *inptr++;	break;
		}
	}
  }
  if (size >= subsz) return(NULL);

  *cp = EOS;
  return(sub);
}

/*	matchs.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */

/* Compares line and pattern.  Line is a character string while pat
 * is a pattern template made by getpat().
 * Returns:
 *	1. A zero if no match was found.
 *
 *	2. A pointer to the last character satisfing the match
 *	   if ret_endp is non-zero.
 *
 *	3. A pointer to the beginning of the matched string if
 *	   ret_endp is zero.
 *
 * e.g.:
 *
 *	matchs ("1234567890", getpat("4[0-9]*7), 0);
 * will return a pointer to the '4', while:
 *
 *	matchs ("1234567890", getpat("4[0-9]*7), 1);
 * will return a pointer to the '7'.
 */
char *
 matchs(line, pat, ret_endp)
char *line;
TOKEN *pat;
int ret_endp;
{

  char *rval, *bptr;
  char *line2;
  TOKEN *pat2;
  char c;
  short ok;

  bptr = line;

  while (*line) {

	if (pat && pat->tok == LITCHAR) {
		while (*line) {
			pat2 = pat;
			line2 = line;
			if (*line2 != pat2->lchar) {
				c = pat2->lchar;
				while (*line2 && *line2 != c) ++line2;
				line = line2;
				if (*line2 == '\0') break;
			}
			ok = 1;
			++line2;
			pat2 = pat2->next;
			while (pat2 && pat2->tok == LITCHAR) {
				if (*line2 != pat2->lchar) {
					ok = 0;
					break;
				}
				++line2;
				pat2 = pat2->next;
			}
			if (!pat2) {
				if (ret_endp)
					return(--line2);
				else
					return(line);
			} else if (ok)
				break;
			++line;
		}
		if (*line == '\0') return(0);
	} else {
		line2 = line;
		pat2 = pat;
	}
	if ((rval = amatch(line2, pat2, bptr)) == 0) {
		if (pat && pat->tok == BOL) break;
		line++;
	} else {
		if (rval > bptr && rval > line)
			rval--;	/* point to last char matched */
		rval = ret_endp ? rval : line;
		break;
	}
  }
  return(rval);
}

/*	move.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int move(num)
int num;
{
  LINE *k0, *k1, *k2, *k3;

  if (line1 <= 0 || line2 < line1 || (line1 <= num && num <= line2))
	return(ERR);
  k0 = getptr(prevln(line1));
  k1 = getptr(line1);
  k2 = getptr(line2);
  k3 = getptr(nextln(line2));

  relink(k0, k3, k0, k3);
  lastln -= line2 - line1 + 1;

  if (num > line1) num -= line2 - line1 + 1;

  curln = num + (line2 - line1 + 1);

  k0 = getptr(num);
  k3 = getptr(nextln(num));

  relink(k0, k1, k2, k3);
  relink(k2, k3, k0, k1);
  lastln += line2 - line1 + 1;

  return(1);
}

int transfer(num)
int num;
{
  int mid, lin, ntrans;

  if (line1 <= 0 || line1 > line2) return(ERR);

  mid = num < line2 ? num : line2;

  curln = num;
  ntrans = 0;

  for (lin = line1; lin <= mid; lin++) {
	ins(gettxt(lin));
	ntrans++;
  }
  lin += ntrans;
  line2 += ntrans;

  for (; lin <= line2; lin += 2) {
	ins(gettxt(lin));
	line2++;
  }
  return(1);
}

/*	omatch.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */

/* Match one pattern element, pointed at by pat, with the character at
 * **linp.  Return non-zero on match.  Otherwise, return 0.  *Linp is
 * advanced to skip over the matched character; it is not advanced on
 * failure.  The amount of advance is 0 for patterns that match null
 * strings, 1 otherwise.  "boln" should point at the position that will
 * match a BOL token.
 */
int omatch(linp, pat, boln)
char **linp;
TOKEN *pat;
char *boln;
{

  register int advance;

  advance = -1;

  if (**linp) {
	switch (pat->tok) {
	    case LITCHAR:
		if (**linp == pat->lchar) advance = 1;
		break;

	    case BOL:
		if (*linp == boln) advance = 0;
		break;

	    case ANY:
		if (**linp != '\n') advance = 1;
		break;

	    case EOL:
		if (**linp == '\n') advance = 0;
		break;

	    case CCL:
		if (testbit(**linp, pat->bitmap)) advance = 1;
		break;

	    case NCCL:
		if (!testbit(**linp, pat->bitmap)) advance = 1;
		break;
	}
  }
  if (advance >= 0) *linp += advance;

  return(++advance);
}

/*	optpat.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

TOKEN *oldpat;

TOKEN *
 optpat()
{
  char delim, str[MAXPAT], *cp;

  delim = *inptr++;
  cp = str;
  while (*inptr != delim && *inptr != NL) {
	if (*inptr == ESCAPE && inptr[1] != NL) *cp++ = *inptr++;
	*cp++ = *inptr++;
  }

  *cp = EOS;
  if (*str == EOS) return(oldpat);
  if (oldpat) unmakepat(oldpat);
  oldpat = getpat(str);
  return(oldpat);
}

/*	set.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

struct tbl {
  char *t_str;
  int *t_ptr;
  int t_val;
} *t, tbl[] = {

  "number", &nflg, TRUE,
  "nonumber", &nflg, FALSE,
  "list", &lflg, TRUE,
  "nolist", &lflg, FALSE,
  "eightbit", &eightbit, TRUE,
  "noeightbit", &eightbit, FALSE,
  0
};

int set()
{
  char word[16];
  int i;

  inptr++;
  if (*inptr != 't') {
	if (*inptr != SP && *inptr != HT && *inptr != NL) return(ERR);
  } else
	inptr++;

  if (*inptr == NL) return(show());
  /* Skip white space */
  while (*inptr == SP || *inptr == HT) inptr++;

  for (i = 0; *inptr != SP && *inptr != HT && *inptr != NL;)
	word[i++] = *inptr++;
  word[i] = EOS;
  for (t = tbl; t->t_str; t++) {
	if (strcmp(word, t->t_str) == 0) {
		*t->t_ptr = t->t_val;
		return(0);
	}
  }
  return(0);
}

int show()
{
  extern int version;

  printf("ed version %d.%d\n", version / 100, version % 100);
  printf("number %s, list %s\n", nflg ? "ON" : "OFF", lflg ? "ON" : "OFF");
  return(0);
}

/*	setbuf.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

void relink(a, x, y, b)
LINE *a, *x, *y, *b;
{
  x->l_prev = a;
  y->l_next = b;
}

void clrbuf()
{
  del(1, lastln);
}

void set_buf()
{
  relink(&line0, &line0, &line0, &line0);
  curln = lastln = 0;
}

/*	subst.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */
/* #include "ed.h" */

int subst(pat, sub, gflg, pflag)
TOKEN *pat;
char *sub;
int gflg, pflag;
{
  int lin, chngd, nchngd;
  char *txtptr, *txt;
  char *lastm, *m, *new, buf[MAXLINE];

  if (line1 <= 0) return(ERR);
  nchngd = 0;			/* reset count of lines changed */
  for (lin = line1; lin <= line2; lin++) {
	txt = txtptr = gettxt(lin);
	new = buf;
	chngd = 0;
	lastm = NULL;
	while (*txtptr) {
		if (gflg || !chngd)
			m = amatch(txtptr, pat, txt);
		else
			m = NULL;
		if (m != NULL && lastm != m) {
			chngd++;
			new = catsub(txtptr, m, sub, new,
				     buf + MAXLINE);
			lastm = m;
		}
		if (m == NULL || m == txtptr) {
			*new++ = *txtptr++;
		} else {
			txtptr = m;
		}
	}
	if (chngd) {
		if (new >= buf + MAXLINE) return(ERR);
		*new++ = EOS;
		del(lin, lin);
		ins(buf);
		nchngd++;
		if (pflag) doprnt(curln, curln);
	}
  }
  if (nchngd == 0 && !gflg) {
	return(ERR);
  }
  return(nchngd);
}

/*	System.c	*/
#define SHELL	"/bin/sh"
#define SHELL2	"/usr/bin/sh"

int System(c)
char *c;
{
  int pid, status;

  switch (pid = fork()) {
      case -1:
	return -1;
      case 0:
	execl(SHELL, "sh", "-c", c, (char *) 0);
	execl(SHELL2, "sh", "-c", c, (char *) 0);
	exit(-1);
      default:	while (wait(&status) != pid);
}
  return status;
}

/*	unmkpat.c	*/
/* #include <stdio.h> */
/* #include "tools.h" */

/* Free up the memory usde for token string */
void unmakepat(head)
TOKEN *head;
{

  register TOKEN *old_head;

  while (head) {
	switch (head->tok) {
	    case CCL:
	    case NCCL:
		free(head->bitmap);
		/* Fall through to default */

	    default:
		old_head = head;
		head = head->next;
		free((char *) old_head);
		break;
	}
  }
}