8000 minix/commands/ed/ed.c at R3.2.0 · fyy3/minix · GitHub
[go: up one dir, main page]

Skip to content

Latest commit

 

History

History
2198 lines (1852 loc) · 43 KB

ed.c

File metadata and controls

2198 lines (1852 loc) · 43 KB
/* 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) {
0