2199 lines
43 KiB
C
Executable file
2199 lines
43 KiB
C
Executable file
/* 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" */
|
|
|
|
_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;
|
|
}
|
|
}
|
|
}
|