sanchayanmaity/minix
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
minix/commands/simple/ed.c
Tomas Hruby ae75f9d4e5 Removal of the executable flag from files that cannot be executed 
- 755 -> 644
2009-11-09 10:26:00 +00:00

2198 lines
43 KiB
C
Raw Blame History

/* 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;
}
}
}
Reference in a new issue View git blame Copy permalink