ref: 5edeca01b0622463a65c126ebcc29314013fd928
dir: /appl/cmd/ed.b/
#
# Editor
#
implement Editor;
include "sys.m";
sys: Sys;
include "draw.m";
include "bufio.m";
bufio: Bufio;
Iobuf: import bufio;
include "regex.m";
regex: Regex;
Re: import regex;
include "sh.m";
sh: Sh;
Editor: module {
init: fn(nil: ref Draw->Context, args: list of string);
};
FNSIZE: con 128; # file name
LBSIZE: con 4096; # max line size
BLKSIZE: con 4096; # block size in temp file
NBLK: con 8191; # max size of temp file
ESIZE: con 256; # max size of reg exp
GBSIZE: con 256; # max size of global command
MAXSUB: con 9; # max number of sub reg exp
ESCFLG: con 16rFFFF; # escape Rune - user defined code
EOF: con -1;
BytesPerRune: con 2;
RunesPerBlock: con BLKSIZE / BytesPerRune;
APPEND_GETTTY, APPEND_GETSUB, APPEND_GETCOPY, APPEND_GETFILE: con iota;
Subexp: adt {
rsp, rep: int;
};
Globp: adt {
s: string;
isnil: int;
};
addr1: int;
addr2: int;
anymarks: int;
col: int;
count: int;
dol: int;
dot: int;
fchange: int;
file: string;
genbuf := array[LBSIZE] of int;
given: int;
globp: Globp;
iblock: int;
ichanged: int;
io: ref Sys->FD;
iobuf: ref Iobuf;
lastc: int;
line := array [70] of byte;
linebp := -1;
linebuf := array [LBSIZE] of int;
listf: int;
listn: int;
loc1: int;
loc2: int;
names := array [26] of int;
oblock: int;
oflag: int;
pattern: Re;
peekc: int;
pflag: int;
rescuing: int;
rhsbuf := array [LBSIZE/2] of int;
savedfile: string;
subnewa: int;
subolda: int;
subexp: array of Subexp;
tfname: string;
tline: int;
waiting: int;
wrapp: int;
zero: array of int;
drawctxt: ref Draw->Context;
Q: con "";
T: con "TMP";
WRERR: con "WRITE ERROR";
bpagesize := 20;
hex: con "0123456789abcdef";
linp: int;
nlall := 128;
tfile: ref Sys->FD;
vflag := 1;
debug(s: string)
{
sys->print("%s", s);
}
init(ctxt: ref Draw->Context, args: list of string)
{
drawctxt = ctxt;
sys = load Sys Sys->PATH;
bufio = load Bufio Bufio->PATH;
if (bufio == nil) {
sys->fprint(sys->fildes(2), "can't load %s\n", Bufio->PATH);
return;
}
regex = load Regex Regex->PATH;
if (regex == nil) {
sys->fprint(sys->fildes(2), "can't load %s\n", Regex->PATH);
return;
}
# notify(notifyf);
if (args != nil)
args = tl args;
if (args != nil && hd args == "-o") {
oflag = 1;
vflag = 0;
args = tl args;
}
if (args != nil && hd args == "-") {
vflag = 0;
args = tl args;
}
if (oflag) {
savedfile = "/fd/1";
globp = ("a", 0);
} else if (args != nil) {
savedfile = hd args;
globp = ("r", 0);
}
else
globp = (nil, 1);
zero = array [nlall + 5] of int;
tfname = mktemp("/tmp/eXXXXX");
# debug(sys->sprint("tfname %s\n", tfname));
_init();
for(;;){
{
commands();
quit();
}exception{
"savej" =>
;
}
}
}
casee(c: int)
{
setnoaddr();
if(vflag && fchange) {
fchange = 0;
error(Q);
}
filename(c);
_init();
addr2 = 0;
caseread();
}
casep()
{
newline();
printcom();
}
caseq()
{
setnoaddr();
newline();
quit();
}
caseread()
{
#debug("caseread " + file);
if((io=sys->open(file, Sys->OREAD)) == nil) {
lastc = '\n';
error(file);
}
iobuf = bufio->fopen(io, Sys->OREAD);
setwide();
squeeze(0);
c := 0 != dol;
append(APPEND_GETFILE, addr2);
exfile(Sys->OREAD);
fchange = c;
}
commands()
{
a1: int;
c, temp: int;
lastsep: int;
for(;;) {
if(pflag) {
pflag = 0;
addr1 = addr2 = dot;
printcom();
}
c = '\n';
for(addr1 = -1;;) {
lastsep = c;
a1 = address();
c = getchr();
if(c != ',' && c != ';')
break;
if(lastsep == ',')
error(Q);
if(a1 < 0) {
a1 = 1;
if(a1 > dol)
a1--;
}
addr1 = a1;
if(c == ';')
dot = a1;
}
if(lastsep != '\n' && a1 < 0)
a1 = dol;
if((addr2=a1) < 0) {
given = 0;
addr2 = dot;
} else
given = 1;
if(addr1 < 0)
addr1 = addr2;
#debug(sys->sprint("%d,%d %c\n", addr1, addr2, c));
case c {
'a' =>
add(0);
continue;
'b' =>
nonzero();
browse();
continue;
'c' =>
nonzero();
newline();
rdelete(addr1, addr2);
append(APPEND_GETTTY, addr1-1);
continue;
'd' =>
nonzero();
newline();
rdelete(addr1, addr2);
continue;
'E' =>
fchange = 0;
c = 'e';
casee(c);
continue;
'e' =>
casee(c);
continue;
'f' =>
setnoaddr();
filename(c);
putst(savedfile);
continue;
'g' =>
global(1);
continue;
'i' =>
add(-1);
continue;
'j' =>
if(!given)
addr2++;
newline();
join();
continue;
'k' =>
nonzero();
c = getchr();
if(c < 'a' || c > 'z')
error(Q);
newline();
names[c-'a'] = zero[addr2] & ~16r1;
anymarks |= 16r1;
continue;
'm' =>
move(0);
continue;
'n' =>
listn++;
newline();
printcom();
continue;
'\n' =>
if(a1 < 0) {
a1 = dot+1;
addr2 = a1;
addr1 = a1;
}
if(lastsep==';')
addr1 = a1;
printcom();
continue;
'l' =>
listf++;
casep();
continue;
'p' or 'P' =>
casep();
continue;
'Q' =>
fchange = 0;
caseq();
continue;
'q' =>
caseq();
continue;
'r' =>
filename(c);
caseread();
continue;
's' =>
nonzero();
substitute(!globp.isnil);
continue;
't' =>
move(1);
continue;
'u' =>
nonzero();
newline();
if((zero[addr2]&~8r01) != subnewa)
error(Q);
zero[addr2] = subolda;
dot = addr2;
continue;
'v' =>
global(0);
continue;
'W' or 'w' =>
if (c == 'W')
wrapp++;
setwide();
squeeze(dol>0);
temp = getchr();
if(temp != 'q' && temp != 'Q') {
peekc = temp;
temp = 0;
}
filename(c);
if(!wrapp ||
((io = sys->open(file, Sys->OWRITE)) == nil) ||
((sys->seek(io, big 0, Sys->SEEKEND)) < big 0))
if((io = sys->create(file, Sys->OWRITE, 8r0666)) == nil)
error(file);
iobuf = bufio->fopen(io, Sys->OWRITE);
wrapp = 0;
if(dol > 0)
putfile();
exfile(Sys->OWRITE);
if(addr1<=1 && addr2==dol)
fchange = 0;
if(temp == 'Q')
fchange = 0;
if(temp)
quit();
continue;
'=' =>
setwide();
squeeze(0);
newline();
count = addr2 - 0;
putd();
putchr('\n');
continue;
'!' =>
callunix();
continue;
EOF =>
return;
}
error(Q);
}
}
printcom()
{
a1: int;
nonzero();
a1 = addr1;
do {
if(listn) {
count = a1-0;
putd();
putchr('\t');
}
putshst(getline(zero[a1++]));
} while(a1 <= addr2);
dot = addr2;
listf = 0;
listn = 0;
pflag = 0;
}
address(): int
{
sign, a, opcnt, nextopand, b, c: int;
nextopand = -1;
sign = 1;
opcnt = 0;
a = dot;
do {
do {
c = getchr();
} while(c == ' ' || c == '\t');
if(c >= '0' && c <= '9') {
peekc = c;
if(!opcnt)
a = 0;
a += sign*getnum();
} else
case c {
'$' or '.' =>
if (c == '$')
a = dol;
if(opcnt)
error(Q);
'\'' =>
c = getchr();
if(opcnt || c < 'a' || c > 'z')
error(Q);
a = 0;
do {
a++;
} while(a <= dol && names[c-'a'] != (zero[a] & ~8r01));
'?' or '/' =>
if (c == '?')
sign = -sign;
compile(c);
b = a;
for(;;) {
a += sign;
if(a <= 0)
a = dol;
if(a > dol)
a = 0;
if(match(a))
break;
if(a == b)
error(Q);
}
break;
* =>
if(nextopand == opcnt) {
a += sign;
if(a < 0 || dol < a)
continue; # error(Q);
}
if(c != '+' && c != '-' && c != '^') {
peekc = c;
if(opcnt == 0)
a = -1;
return a;
}
sign = 1;
if(c != '+')
sign = -sign;
nextopand = ++opcnt;
continue;
}
sign = 1;
opcnt++;
} while(0 <= a && a <= dol);
error(Q);
return -1;
}
getnum(): int
{
r, c: int;
r = 0;
for(;;) {
c = getchr();
if(c < '0' || c > '9')
break;
r = r*10 + (c-'0');
}
peekc = c;
return r;
}
setwide()
{
if(!given) {
addr1 = 0 + (dol>0);
addr2 = dol;
}
}
setnoaddr()
{
if(given)
error(Q);
}
nonzero()
{
squeeze(1);
}
squeeze(i: int)
{
if(addr1 < 0+i || addr2 > dol || addr1 > addr2)
error(Q);
}
newline()
{
c: int;
c = getchr();
if(c == '\n' || c == EOF)
return;
if(c == 'p' || c == 'l' || c == 'n') {
pflag++;
if(c == 'l')
listf++;
else
if(c == 'n')
listn++;
c = getchr();
if(c == '\n')
return;
}
error(Q);
}
filename(comm: int)
{
rune: int;
c: int;
count = 0;
c = getchr();
if(c == '\n' || c == EOF) {
if(savedfile == nil && comm != 'f')
error(Q);
file = savedfile;
return;
}
if(c != ' ')
error(Q);
while((c=getchr()) == ' ')
;
if(c == '\n')
error(Q);
file = nil;
do {
if(c == ' ' || c == EOF)
error(Q);
rune = c;
file[len file] = c;
} while((c=getchr()) != '\n');
if(savedfile == nil || comm == 'e' || comm == 'f')
savedfile = file;
}
exfile(om: int)
{
if(om == Sys->OWRITE)
if(iobuf.flush() < 0)
error(Q);
iobuf.close();
iobuf = nil;
io = nil;
if(vflag) {
putd();
putchr('\n');
}
}
error1(s: string)
{
c: int;
wrapp = 0;
listf = 0;
listn = 0;
count = 0;
sys->seek(sys->fildes(0), big 0, Sys->SEEKEND); # what does this do?
pflag = 0;
if(!globp.isnil)
lastc = '\n';
globp = (nil, 1);
peekc = lastc;
if(lastc)
for(;;) {
c = getchr();
if(c == '\n' || c == EOF)
break;
}
if(io != nil)
io = nil;
putchr('?');
putst(s);
}
error(s: string)
{
error1(s);
raise "savej";
}
rescue()
{
rescuing = 1;
if(dol > 0) {
addr1 = 0+1;
addr2 = dol;
io = sys->create("ed.hup", Sys->OWRITE, 8r0666);
if(io != nil){
iobuf = bufio->fopen(io, Sys->OWRITE);
putfile();
}
}
fchange = 0;
quit();
}
# void
# notifyf(void *a, char *s)
# {
# if(strcmp(s, "interrupt") == 0){
# if(rescuing || waiting)
# noted(NCONT);
# putchr(L'\n');
# lastc = '\n';
# error1(Q);
# notejmp(a, savej, 0);
# }
# if(strcmp(s, "hangup") == 0){
# if(rescuing)
# noted(NDFLT);
# rescue();
# }
# fprint(2, "ed: note: %s\n", s);
# abort();
# }
getchr(): int
{
s := array [Sys->UTFmax] of byte;
i: int;
r: int;
status: int;
if(lastc = peekc) {
peekc = 0;
#debug(sys->sprint("getchr: peekc %c\n", lastc));
return lastc;
}
if(!globp.isnil) {
if (globp.s != nil) {
lastc = globp.s[0];
globp.s = globp.s[1:];
#debug(sys->sprint("getchr: globp %c remaining %d\n", lastc, len globp.s));
return lastc;
}
globp = (nil, 1);
#debug(sys->sprint("getchr: globp end\n"));
return EOF;
}
#debug("globp nil\n");
for(i=0;;) {
if(sys->read(sys->fildes(0), s[i:], 1) <= 0)
return lastc = EOF;
i++;
(r, nil, status) = sys->byte2char(s, 0);
if (status > 0)
break;
}
lastc = r;
return lastc;
}
gety(): int
{
c: int;
gf: int;
p: int;
p = 0;
gf = !globp.isnil;
for(;;) {
c = getchr();
if(c == '\n') {
linebuf[p] = 0;
return 0;
}
if(c == EOF) {
if(gf)
peekc = c;
return c;
}
if(c == 0)
continue;
linebuf[p++] = c;
if(p >= len linebuf)
error(Q);
}
return 0;
}
gettty(): int
{
rc: int;
rc = gety();
if(rc)
return rc;
if(linebuf[0] == '.' && linebuf[1] == 0)
return EOF;
return 0;
}
getfile(): int
{
c: int;
lp: int;
lp = 0;
do {
c = iobuf.getc();
if(c < 0) {
if(lp > 0) {
putst("'\\n' appended");
c = '\n';
} else
return EOF;
}
if(lp >= len linebuf) {
lastc = '\n';
error(Q);
}
linebuf[lp++] = c;
count++;
} while(c != '\n');
linebuf[lp - 1] = 0;
#debug(sys->sprint("getline read %d\n", lp));
return 0;
}
putfile()
{
a1: int;
lp: int;
c: int;
a1 = addr1;
do {
lp = getline(zero[a1++]);
for(;;) {
count++;
c = linebuf[lp++];
if(c == 0) {
if (iobuf.putc('\n') < 0)
error(Q);
break;
}
if (iobuf.putc(c) < 0)
error(Q);
}
} while(a1 <= addr2);
if(iobuf.flush() < 0)
error(Q);
}
append(f: int, a: int): int
{
a1, a2, rdot, nline, _tl: int;
rv: int;
nline = 0;
dot = a;
for (;;) {
case f {
APPEND_GETTTY => rv = gettty();
APPEND_GETSUB => rv = getsub();
APPEND_GETCOPY => rv = getcopy();
APPEND_GETFILE => rv = getfile();
}
if (rv != 0)
break;
if(dol >= nlall) {
nlall += 512;
newzero := array [nlall + 5] of int;
if(newzero == nil) {
error("MEM?");
rescue();
}
newzero[0:] = zero;
zero = newzero;
}
_tl = putline();
nline++;
a1 = ++dol;
a2 = a1+1;
rdot = ++dot;
zero[rdot:] = zero[rdot - 1: a1];
zero[rdot] = _tl;
}
#debug(sys->sprint("end of append - dot %d\n", dot));
return nline;
}
add(i: int)
{
if(i && (given || dol > 0)) {
addr1--;
addr2--;
}
squeeze(0);
newline();
append(APPEND_GETTTY, addr2);
}
bformat, bnum: int;
browse()
{
forward, n: int;
forward = 1;
peekc = getchr();
if(peekc != '\n'){
if(peekc == '-' || peekc == '+') {
if(peekc == '-')
forward = 0;
getchr();
}
n = getnum();
if(n > 0)
bpagesize = n;
}
newline();
if(pflag) {
bformat = listf;
bnum = listn;
} else {
listf = bformat;
listn = bnum;
}
if(forward) {
addr1 = addr2;
addr2 += bpagesize;
if(addr2 > dol)
addr2 = dol;
} else {
addr1 = addr2-bpagesize;
if(addr1 <= 0)
addr1 = 0+1;
}
printcom();
}
callunix()
{
buf: string;
c: int;
if (sh == nil)
sh = load Sh Sh->PATH;
if (sh == nil) {
putst("can't load shell");
return;
}
setnoaddr();
while((c=getchr()) != EOF && c != '\n')
buf[len buf] = c;
sh->system(drawctxt, buf);
if(vflag)
putst("!");
}
quit()
{
if(vflag && fchange && dol!=0) {
fchange = 0;
error(Q);
}
sys->remove(tfname);
exit;
}
onquit(nil: int)
{
quit();
}
rdelete(ad1, ad2: int)
{
a1, a2, a3: int;
a1 = ad1;
a2 = ad2+1;
a3 = dol;
dol -= a2 - a1;
do {
zero[a1++] = zero[a2++];
} while (a2 <= a3);
a1 = ad1;
if(a1 > dol)
a1 = dol;
dot = a1;
fchange = 1;
}
gdelete()
{
a1, a2, a3: int;
a3 = dol;
for(a1=0; (zero[a1]&8r01)==0; a1++)
if(a1>=a3)
return;
for(a2=a1+1; a2<=a3;) {
if(zero[a2] & 8r01) {
a2++;
dot = a1;
} else
zero[a1++] = zero[a2++];
}
dol = a1-1;
if(dot > dol)
dot = dol;
fchange = 1;
}
getline(_tl: int): int
{
lp, bp: int;
nl: int;
block: array of int;
#debug(sys->sprint("getline %d\n", _tl));
lp = 0;
(block, bp) = getblock(_tl, Sys->OREAD);
nl = len block - bp;
_tl &= ~(RunesPerBlock - 1);
while(linebuf[lp++] = block[bp++]) {
nl--;
if(nl == 0) {
(block, bp) = getblock(_tl += RunesPerBlock, Sys->OREAD);
nl = len block;
}
}
return 0;
}
putline(): int
{
lp, bp: int;
nl, _tl: int;
block: array of int;
fchange = 1;
lp = 0;
_tl = tline;
(block, bp) = getblock(_tl, Sys->OWRITE);
nl = len block - bp;
_tl &= ~(RunesPerBlock-1); # _tl is now at the beginning of the block
while(block[bp] = linebuf[lp++]) {
if(block[bp++] == '\n') {
block[bp-1] = 0;
linebp = lp;
break;
}
nl--;
if(nl == 0) {
_tl += RunesPerBlock;
(block, bp) = getblock(_tl, Sys->OWRITE);
nl = len block;
}
}
nl = tline;
tline += ((lp) + 8r03) & 8r077776;
return nl;
}
tbuf := array [BLKSIZE] of byte;
getrune(buf: array of byte): int
{
return int buf[0] + (int buf[1] << 8);
}
putrune(buf: array of byte, v: int)
{
buf[0] = byte (v);
buf[1] = byte (v >> 8);
}
blkio(b: int, buf: array of int, writefunc: int)
{
sys->seek(tfile, big b * big BLKSIZE, Sys->SEEKSTART);
if (writefunc) {
# flatten buf into tbuf
for (x := 0; x < RunesPerBlock; x++)
putrune(tbuf[x * BytesPerRune:], buf[x]);
if (sys->write(tfile, tbuf, BLKSIZE) != len tbuf) {
error(T);
}
}
else {
if (sys->read(tfile, tbuf, len tbuf) != len tbuf) {
error(T);
}
for (x := 0; x < RunesPerBlock; x++)
buf[x] = getrune(tbuf[x * BytesPerRune:]);
}
}
ibuff := array [RunesPerBlock] of int;
obuff := array [RunesPerBlock] of int;
getblock(atl, iof: int): (array of int, int)
{
bno, off: int;
bno = atl / RunesPerBlock;
off = (atl * BytesPerRune) & (BLKSIZE-1) & ~8r03;
if(bno >= NBLK) {
lastc = '\n';
error(T);
}
off /= BytesPerRune;
if(bno == iblock) {
ichanged |= iof;
#debug(sys->sprint("getblock(%d, %d): returns ibuff offset %d\n", atl, iof, off));
return (ibuff, off);
}
if(bno == oblock) {
#debug(sys->sprint("getblock(%d, %d): returns obuff offset %d\n", atl, iof, off));
return (obuff, off);
}
if(iof == Sys->OREAD) {
if(ichanged)
blkio(iblock, ibuff, 1);
ichanged = 0;
iblock = bno;
blkio(bno, ibuff, 0);
#debug(sys->sprint("getblock(%d, %d): returns ibuff offset %d\n", atl, iof, off));
return (ibuff, off);
}
if(oblock >= 0)
blkio(oblock, obuff, 1);
oblock = bno;
#debug(sys->sprint("getblock(%d, %d): returns offset %d\n", atl, iof, off));
return (obuff, off);
}
_init()
{
markp: int;
tfile = nil;
tline = RunesPerBlock;
for(markp = 0; markp < len names; markp++)
names[markp] = 0;
subnewa = 0;
anymarks = 0;
iblock = -1;
oblock = -1;
ichanged = 0;
if((tfile = sys->create(tfname, Sys->ORDWR, 8r0600)) == nil){
error1(T);
exit;
}
dot = dol = 0;
}
global(k: int)
{
globuf: string;
c, a1: int;
if(!globp.isnil)
error(Q);
setwide();
squeeze(dol > 0);
c = getchr();
if(c == '\n')
error(Q);
compile(c);
globuf = nil;
while((c=getchr()) != '\n') {
if(c == EOF)
error(Q);
if(c == '\\') {
c = getchr();
if(c != '\n')
globuf[len globuf] = '\\';
}
globuf[len globuf] = c;
}
if(globuf == nil)
globuf = "p";
globuf[len globuf] = '\n';
for(a1=0; a1<=dol; a1++) {
zero[a1] &= ~8r01;
if(a1 >= addr1 && a1 <= addr2 && match(a1) == k)
zero[a1] |= 8r01;
}
#
# Special case: g/.../d (avoid n^2 algorithm)
if(globuf == "d\n") {
gdelete();
return;
}
for(a1=0; a1<=dol; a1++) {
if(zero[a1] & 8r01) {
zero[a1] &= ~8r01;
dot = a1;
globp = (globuf, 0);
commands();
a1 = 0;
}
}
}
join()
{
gp, lp: int;
a1: int;
nonzero();
gp = 0;
for(a1=addr1; a1<=addr2; a1++) {
lp = getline(zero[a1]);
while(genbuf[gp] = linebuf[lp++])
if(gp++ >= LBSIZE-2)
error(Q);
}
lp = 0;
gp = 0;
while(linebuf[lp++] = genbuf[gp++])
;
zero[addr1] = putline();
if(addr1 < addr2)
rdelete(addr1+1, addr2);
dot = addr1;
}
substitute(inglob: int)
{
mp, a1, nl, gsubf, n: int;
n = getnum(); # OK even if n==0
gsubf = compsub();
for(a1 = addr1; a1 <= addr2; a1++) {
if(match(a1)){
m := n;
do {
span := loc2-loc1;
if(--m <= 0) {
dosub();
if(!gsubf)
break;
if(span == 0) { # null RE match
if(zero[loc2] == 0)
break;
loc2++;
}
}
} while(match(-1));
if(m <= 0) {
inglob |= 8r01;
subnewa = putline();
zero[a1] &= ~8r01;
if(anymarks) {
for(mp=0; mp<len names; mp++)
if(names[mp] == zero[a1])
names[mp] = subnewa;
}
subolda = zero[a1];
zero[a1] = subnewa;
#debug(sys->sprint("append-getsub linebp = %d\n", linebp));
nl = append(APPEND_GETSUB, a1);
addr2 += nl;
}
}
}
if(inglob == 0)
error(Q);
}
compsub(): int
{
seof, c: int;
p: int;
seof = getchr();
if(seof == '\n' || seof == ' ')
error(Q);
compile(seof);
p = 0;
for(;;) {
c = getchr();
if(c == '\\') {
c = getchr();
rhsbuf[p++] = ESCFLG;
if(p >= LBSIZE / 2)
error(Q);
} else
if(c == '\n' && (globp.isnil || globp.s == nil)) {
peekc = c;
pflag++;
break;
} else
if(c == seof)
break;
rhsbuf[p++] = c;
if(p >= LBSIZE / 2)
error(Q);
}
rhsbuf[p] = 0;
peekc = getchr();
if(peekc == 'g') {
peekc = 0;
newline();
return 1;
}
newline();
return 0;
}
getsub(): int
{
p1, p2: int;
p1 = 0;
if((p2 = linebp) == -1)
return EOF;
while(linebuf[p1++] = linebuf[p2++])
;
linebp = -1;
return 0;
}
dosub()
{
lp, sp, rp: int;
c, n: int;
# lp = linebuf;
# sp = genbuf;
# rp = rhsbuf;
lp = 0;
sp = 0;
rp = 0;
while(lp < loc1)
genbuf[sp++] = linebuf[lp++];
while(c = rhsbuf[rp++]) {
if(c == '&'){
sp = place(sp, loc1, loc2);
continue;
}
if(c == ESCFLG && (c = rhsbuf[rp++]) >= '1' && c < MAXSUB+'0') {
n = c-'0';
if(n < len subexp && subexp[n].rsp >= 0 && subexp[n].rep >= 0) {
sp = place(sp, subexp[n].rsp, subexp[n].rep);
continue;
}
error(Q);
}
genbuf[sp++] = c;
if(sp >= LBSIZE)
error(Q);
}
lp = loc2;
loc2 = sp;
while(genbuf[sp++] = linebuf[lp++])
if(sp >= LBSIZE)
error(Q);
linebuf[0:] = genbuf[0: sp];
}
place(sp: int, l1: int, l2: int): int
{
while(l1 < l2) {
genbuf[sp++] = linebuf[l1++];
if(sp >= LBSIZE)
error(Q);
}
return sp;
}
move(cflag: int)
{
_adt, ad1, ad2: int;
nonzero();
if((_adt = address()) < 0) # address() guarantees addr is in range
error(Q);
newline();
if(cflag) {
ad1 = dol;
append(APPEND_GETCOPY, ad1++);
ad2 = dol;
} else {
ad2 = addr2;
for(ad1 = addr1; ad1 <= ad2;)
zero[ad1++] &= ~8r01;
ad1 = addr1;
}
ad2++;
if(_adt<ad1) {
dot = _adt + (ad2-ad1);
if((++_adt)==ad1)
return;
reverse(_adt, ad1);
reverse(ad1, ad2);
reverse(_adt, ad2);
} else
if(_adt >= ad2) {
dot = _adt++;
reverse(ad1, ad2);
reverse(ad2, _adt);
reverse(ad1, _adt);
} else
error(Q);
fchange = 1;
}
reverse(a1, a2: int)
{
t: int;
for(;;) {
t = zero[--a2];
if(a2 <= a1)
return;
zero[a2] = zero[a1];
zero[a1++] = t;
}
}
getcopy(): int
{
if(addr1 > addr2)
return EOF;
getline(zero[addr1++]);
return 0;
}
compile(eof: int)
{
c: int;
if((c = getchr()) == '\n') {
peekc = c;
c = eof;
}
if(c == eof) {
if(pattern == nil)
error(Q);
return;
}
pattern = nil;
program := "";
do {
if(c == '\\') {
program[len program] = '\\';
if((c = getchr()) == '\n') {
error(Q);
return;
}
}
program[len program] = c;
} while((c = getchr()) != eof && c != '\n');
if(c == '\n')
peekc = c;
diag: string;
#debug("program " + program + "\n");
(pattern, diag) = regex->compile(program, 1);
#if (diag != nil)
# debug("diag " + diag + "\n");
if (diag != nil)
pattern = nil;
}
mkstring(a: array of int): string
{
s: string;
for (x := 0; x < len a; x++) {
if (a[x] == 0)
break;
s[x] = a[x];
}
return s;
}
match(addr: int): int
{
rsp: int;
if(pattern == nil)
return 0;
if(addr >= 0){
if(addr == 0)
return 0;
rsp = getline(zero[addr]);
} else
rsp = loc2;
s := mkstring(linebuf);
subexp = regex->executese(pattern, s, (rsp, len s), rsp == 0, 1);
if(subexp != nil) {
(loc1, loc2) = subexp[0];
return 1;
}
loc1 = loc2 = -1;
return 0;
}
putd()
{
r: int;
r = count%10;
count /= 10;
if(count)
putd();
putchr(r + '0');
}
putst(s: string)
{
col = 0;
for(x := 0; x < len s; x++)
putchr(s[x]);
putchr('\n');
}
putshst(sp: int)
{
col = 0;
while(linebuf[sp]) {
putchr(linebuf[sp++]);
}
putchr('\n');
}
putchr(ac: int)
{
lp: int;
c: int;
rune: int;
lp = linp;
c = ac;
if(listf) {
if(c == '\n') {
if(linp != 0 && line[linp - 1] == byte ' ') {
line[lp++] = byte '\\';
line[lp++] = byte 'n';
}
} else {
if(col > (72-6-2)) {
col = 8;
line[lp++] = byte '\\';
line[lp++] = byte '\n';
line[lp++] = byte '\t';
}
col++;
if(c=='\b' || c=='\t' || c=='\\') {
line[lp++] = byte '\\';
if(c == '\b')
c = 'b';
else
if(c == '\t')
c = 't';
col++;
} else
if(c<' ' || c>=8r0177) {
line[lp++] = byte '\\';
line[lp++] = byte 'x';
line[lp++] = byte hex[c>>12];
line[lp++] = byte hex[c>>8&16rF];
line[lp++] = byte hex[c>>4&16rF];
c = hex[c&16rF];
col += 5;
}
}
}
rune = c;
lp += sys->char2byte(rune, line, lp);
if(c == '\n' || lp >= len line - 5) {
linp = 0;
if (oflag)
sys->write(sys->fildes(2), line, lp);
else
sys->write(sys->fildes(1), line, lp);
return;
}
linp = lp;
}
stringfromint(i: int): string
{
s: string;
s[0] = i;
return s;
}
mktemp(as: string): string
{
pid: int;
s: string;
s = nil;
pid = sys->pctl(0, nil);
for (x := len as - 1; x >= 0; x--)
if (as[x] == 'X') {
s = stringfromint('0' + pid % 10) + s;
pid /= 10;
}
else
s = stringfromint(as[x]) + s;
s[len s] = 'a';
for (;;) {
(rv, nil) := sys->stat(s);
if (rv < 0)
break;
if (s[len s - 1] == 'z')
return "/";
s[len s - 1]++;
}
return s;
}