plan9port

ecmd.c (26091B)

---

 #include <u.h>
 #include <libc.h>
 #include <draw.h>
 #include <thread.h>
 #include <cursor.h>
 #include <mouse.h>
 #include <keyboard.h>
 #include <frame.h>
 #include <fcall.h>
 #include <plumb.h>
 #include <libsec.h>
 #include "dat.h"
 #include "edit.h"
 #include "fns.h"
 
 int	Glooping;
 int	nest;
 char	Enoname[] = "no file name given";
 
 Address	addr;
 File	*menu;
 Rangeset	sel;
 extern	Text*	curtext;
 Rune	*collection;
 int	ncollection;
 
 int	append(File*, Cmd*, long);
 int	pdisplay(File*);
 void	pfilename(File*);
 void	looper(File*, Cmd*, int);
 void	filelooper(Text*, Cmd*, int);
 void	linelooper(File*, Cmd*);
 Address	lineaddr(long, Address, int);
 int	filematch(File*, String*);
 File	*tofile(String*);
 Rune*	cmdname(File *f, String *s, int);
 void	runpipe(Text*, int, Rune*, int, int);
 
 void
 clearcollection(void)
 {
 	free(collection);
 	collection = nil;
 	ncollection = 0;
 }
 
 void
 resetxec(void)
 {
 	Glooping = nest = 0;
 	clearcollection();
 }
 
 void
 mkaddr(Address *a, File *f)
 {
 	a->r.q0 = f->curtext->q0;
 	a->r.q1 = f->curtext->q1;
 	a->f = f;
 }
 
 int
 cmdexec(Text *t, Cmd *cp)
 {
 	int i;
 	Addr *ap;
 	File *f;
 	Window *w;
 	Address dot;
 
 	if(t == nil)
 		w = nil;
 	else
 		w = t->w;
 	if(w==nil && (cp->addr==0 || cp->addr->type!='"') &&
 	    !utfrune("bBnqUXY!", cp->cmdc) &&
 	    !(cp->cmdc=='D' && cp->u.text))
 		editerror("no current window");
 	i = cmdlookup(cp->cmdc);	/* will be -1 for '{' */
 	f = nil;
 	if(t && t->w){
 		t = &t->w->body;
 		f = t->file;
 		f->curtext = t;
 	}
 	if(i>=0 && cmdtab[i].defaddr != aNo){
 		if((ap=cp->addr)==0 && cp->cmdc!='\n'){
 			cp->addr = ap = newaddr();
 			ap->type = '.';
 			if(cmdtab[i].defaddr == aAll)
 				ap->type = '*';
 		}else if(ap && ap->type=='"' && ap->next==0 && cp->cmdc!='\n'){
 			ap->next = newaddr();
 			ap->next->type = '.';
 			if(cmdtab[i].defaddr == aAll)
 				ap->next->type = '*';
 		}
 		if(cp->addr){	/* may be false for '\n' (only) */
 			static Address none = {0,0,nil};
 			if(f){
 				mkaddr(&dot, f);
 				addr = cmdaddress(ap, dot, 0);
 			}else	/* a " */
 				addr = cmdaddress(ap, none, 0);
 			f = addr.f;
 			t = f->curtext;
 		}
 	}
 	switch(cp->cmdc){
 	case '{':
 		mkaddr(&dot, f);
 		if(cp->addr != nil)
 			dot = cmdaddress(cp->addr, dot, 0);
 		for(cp = cp->u.cmd; cp; cp = cp->next){
 			if(dot.r.q1 > t->file->b.nc)
 				editerror("dot extends past end of buffer during { command");
 			t->q0 = dot.r.q0;
 			t->q1 = dot.r.q1;
 			cmdexec(t, cp);
 		}
 		break;
 	default:
 		if(i < 0)
 			editerror("unknown command %c in cmdexec", cp->cmdc);
 		i = (*cmdtab[i].fn)(t, cp);
 		return i;
 	}
 	return 1;
 }
 
 char*
 edittext(Window *w, int q, Rune *r, int nr)
 {
 	File *f;
 
 	f = w->body.file;
 	switch(editing){
 	case Inactive:
 		return "permission denied";
 	case Inserting:
 		eloginsert(f, q, r, nr);
 		return nil;
 	case Collecting:
 		collection = runerealloc(collection, ncollection+nr+1);
 		runemove(collection+ncollection, r, nr);
 		ncollection += nr;
 		collection[ncollection] = '\0';
 		return nil;
 	default:
 		return "unknown state in edittext";
 	}
 }
 
 /* string is known to be NUL-terminated */
 Rune*
 filelist(Text *t, Rune *r, int nr)
 {
 	if(nr == 0)
 		return nil;
 	r = skipbl(r, nr, &nr);
 	if(r[0] != '<')
 		return runestrdup(r);
 	/* use < command to collect text */
 	clearcollection();
 	runpipe(t, '<', r+1, nr-1, Collecting);
 	return collection;
 }
 
 int
 a_cmd(Text *t, Cmd *cp)
 {
 	return append(t->file, cp, addr.r.q1);
 }
 
 int
 b_cmd(Text *t, Cmd *cp)
 {
 	File *f;
 
 	USED(t);
 	f = tofile(cp->u.text);
 	if(nest == 0)
 		pfilename(f);
 	curtext = f->curtext;
 	return TRUE;
 }
 
 int
 B_cmd(Text *t, Cmd *cp)
 {
 	Rune *list, *r, *s;
 	int nr;
 
 	list = filelist(t, cp->u.text->r, cp->u.text->n);
 	if(list == nil)
 		editerror(Enoname);
 	r = list;
 	nr = runestrlen(r);
 	r = skipbl(r, nr, &nr);
 	if(nr == 0)
 		new(t, t, nil, 0, 0, r, 0);
 	else while(nr > 0){
 		s = findbl(r, nr, &nr);
 		*s = '\0';
 		new(t, t, nil, 0, 0, r, runestrlen(r));
 		if(nr > 0)
 			r = skipbl(s+1, nr-1, &nr);
 	}
 	clearcollection();
 	return TRUE;
 }
 
 int
 c_cmd(Text *t, Cmd *cp)
 {
 	elogreplace(t->file, addr.r.q0, addr.r.q1, cp->u.text->r, cp->u.text->n);
 	t->q0 = addr.r.q0;
 	t->q1 = addr.r.q1;
 	return TRUE;
 }
 
 int
 d_cmd(Text *t, Cmd *cp)
 {
 	USED(cp);
 	if(addr.r.q1 > addr.r.q0)
 		elogdelete(t->file, addr.r.q0, addr.r.q1);
 	t->q0 = addr.r.q0;
 	t->q1 = addr.r.q0;
 	return TRUE;
 }
 
 void
 D1(Text *t)
 {
 	if(t->w->body.file->ntext>1 || winclean(t->w, FALSE))
 		colclose(t->col, t->w, TRUE);
 }
 
 int
 D_cmd(Text *t, Cmd *cp)
 {
 	Rune *list, *r, *s, *n;
 	int nr, nn;
 	Window *w;
 	Runestr dir, rs;
 	char buf[128];
 
 	list = filelist(t, cp->u.text->r, cp->u.text->n);
 	if(list == nil){
 		D1(t);
 		return TRUE;
 	}
 	dir = dirname(t, nil, 0);
 	r = list;
 	nr = runestrlen(r);
 	r = skipbl(r, nr, &nr);
 	do{
 		s = findbl(r, nr, &nr);
 		*s = '\0';
 		/* first time through, could be empty string, meaning delete file empty name */
 		nn = runestrlen(r);
 		if(r[0]=='/' || nn==0 || dir.nr==0){
 			rs.r = runestrdup(r);
 			rs.nr = nn;
 		}else{
 			n = runemalloc(dir.nr+1+nn);
 			runemove(n, dir.r, dir.nr);
 			n[dir.nr] = '/';
 			runemove(n+dir.nr+1, r, nn);
 			rs = cleanrname(runestr(n, dir.nr+1+nn));
 		}
 		w = lookfile(rs.r, rs.nr);
 		if(w == nil){
 			snprint(buf, sizeof buf, "no such file %.*S", rs.nr, rs.r);
 			free(rs.r);
 			editerror(buf);
 		}
 		free(rs.r);
 		D1(&w->body);
 		if(nr > 0)
 			r = skipbl(s+1, nr-1, &nr);
 	}while(nr > 0);
 	clearcollection();
 	free(dir.r);
 	return TRUE;
 }
 
 static int
 readloader(void *v, uint q0, Rune *r, int nr)
 {
 	if(nr > 0)
 		eloginsert(v, q0, r, nr);
 	return 0;
 }
 
 int
 e_cmd(Text *t, Cmd *cp)
 {
 	Rune *name;
 	File *f;
 	int i, isdir, q0, q1, fd, nulls, samename, allreplaced;
 	char *s, tmp[128];
 	Dir *d;
 
 	f = t->file;
 	q0 = addr.r.q0;
 	q1 = addr.r.q1;
 	if(cp->cmdc == 'e'){
 		if(winclean(t->w, TRUE)==FALSE)
 			editerror("");	/* winclean generated message already */
 		q0 = 0;
 		q1 = f->b.nc;
 	}
 	allreplaced = (q0==0 && q1==f->b.nc);
 	name = cmdname(f, cp->u.text, cp->cmdc=='e');
 	if(name == nil)
 		editerror(Enoname);
 	i = runestrlen(name);
 	samename = runeeq(name, i, t->file->name, t->file->nname);
 	s = runetobyte(name, i);
 	free(name);
 	fd = open(s, OREAD);
 	if(fd < 0){
 		snprint(tmp, sizeof tmp, "can't open %s: %r", s);
 		free(s);
 		editerror(tmp);
 	}
 	d = dirfstat(fd);
 	isdir = (d!=nil && (d->qid.type&QTDIR));
 	free(d);
 	if(isdir){
 		close(fd);
 		snprint(tmp, sizeof tmp, "%s is a directory", s);
 		free(s);
 		editerror(tmp);
 	}
 	elogdelete(f, q0, q1);
 	nulls = 0;
 	loadfile(fd, q1, &nulls, readloader, f, nil);
 	free(s);
 	close(fd);
 	if(nulls)
 		warning(nil, "%s: NUL bytes elided\n", s);
 	else if(allreplaced && samename)
 		f->editclean = TRUE;
 	return TRUE;
 }
 
 static Rune Lempty[] = { 0 };
 int
 f_cmd(Text *t, Cmd *cp)
 {
 	Rune *name;
 	String *str;
 	String empty;
 
 	if(cp->u.text == nil){
 		empty.n = 0;
 		empty.r = Lempty;
 		str = &empty;
 	}else
 		str = cp->u.text;
 	name = cmdname(t->file, str, TRUE);
 	free(name);
 	pfilename(t->file);
 	return TRUE;
 }
 
 int
 g_cmd(Text *t, Cmd *cp)
 {
 	if(t->file != addr.f){
 		warning(nil, "internal error: g_cmd f!=addr.f\n");
 		return FALSE;
 	}
 	if(rxcompile(cp->re->r) == FALSE)
 		editerror("bad regexp in g command");
 	if(rxexecute(t, nil, addr.r.q0, addr.r.q1, &sel) ^ cp->cmdc=='v'){
 		t->q0 = addr.r.q0;
 		t->q1 = addr.r.q1;
 		return cmdexec(t, cp->u.cmd);
 	}
 	return TRUE;
 }
 
 int
 i_cmd(Text *t, Cmd *cp)
 {
 	return append(t->file, cp, addr.r.q0);
 }
 
 void
 copy(File *f, Address addr2)
 {
 	long p;
 	int ni;
 	Rune *buf;
 
 	buf = fbufalloc();
 	for(p=addr.r.q0; p<addr.r.q1; p+=ni){
 		ni = addr.r.q1-p;
 		if(ni > RBUFSIZE)
 			ni = RBUFSIZE;
 		bufread(&f->b, p, buf, ni);
 		eloginsert(addr2.f, addr2.r.q1, buf, ni);
 	}
 	fbuffree(buf);
 }
 
 void
 move(File *f, Address addr2)
 {
 	if(addr.f!=addr2.f || addr.r.q1<=addr2.r.q0){
 		elogdelete(f, addr.r.q0, addr.r.q1);
 		copy(f, addr2);
 	}else if(addr.r.q0 >= addr2.r.q1){
 		copy(f, addr2);
 		elogdelete(f, addr.r.q0, addr.r.q1);
 	}else if(addr.r.q0==addr2.r.q0 && addr.r.q1==addr2.r.q1){
 		; /* move to self; no-op */
 	}else
 		editerror("move overlaps itself");
 }
 
 int
 m_cmd(Text *t, Cmd *cp)
 {
 	Address dot, addr2;
 
 	mkaddr(&dot, t->file);
 	addr2 = cmdaddress(cp->u.mtaddr, dot, 0);
 	if(cp->cmdc == 'm')
 		move(t->file, addr2);
 	else
 		copy(t->file, addr2);
 	return TRUE;
 }
 
 int
 p_cmd(Text *t, Cmd *cp)
 {
 	USED(cp);
 	return pdisplay(t->file);
 }
 
 int
 s_cmd(Text *t, Cmd *cp)
 {
 	int i, j, k, c, m, n, nrp, didsub;
 	long p1, op, delta;
 	String *buf;
 	Rangeset *rp;
 	char *err;
 	Rune *rbuf;
 
 	n = cp->num;
 	op= -1;
 	if(rxcompile(cp->re->r) == FALSE)
 		editerror("bad regexp in s command");
 	nrp = 0;
 	rp = nil;
 	delta = 0;
 	didsub = FALSE;
 	for(p1 = addr.r.q0; p1<=addr.r.q1 && rxexecute(t, nil, p1, addr.r.q1, &sel); ){
 		if(sel.r[0].q0 == sel.r[0].q1){	/* empty match? */
 			if(sel.r[0].q0 == op){
 				p1++;
 				continue;
 			}
 			p1 = sel.r[0].q1+1;
 		}else
 			p1 = sel.r[0].q1;
 		op = sel.r[0].q1;
 		if(--n>0)
 			continue;
 		nrp++;
 		rp = erealloc(rp, nrp*sizeof(Rangeset));
 		rp[nrp-1] = sel;
 	}
 	rbuf = fbufalloc();
 	buf = allocstring(0);
 	for(m=0; m<nrp; m++){
 		buf->n = 0;
 		buf->r[0] = '\0';
 		sel = rp[m];
 		for(i = 0; i<cp->u.text->n; i++)
 			if((c = cp->u.text->r[i])=='\\' && i<cp->u.text->n-1){
 				c = cp->u.text->r[++i];
 				if('1'<=c && c<='9') {
 					j = c-'0';
 					if(sel.r[j].q1-sel.r[j].q0>RBUFSIZE){
 						err = "replacement string too long";
 						goto Err;
 					}
 					bufread(&t->file->b, sel.r[j].q0, rbuf, sel.r[j].q1-sel.r[j].q0);
 					for(k=0; k<sel.r[j].q1-sel.r[j].q0; k++)
 						Straddc(buf, rbuf[k]);
 				}else
 				 	Straddc(buf, c);
 			}else if(c!='&')
 				Straddc(buf, c);
 			else{
 				if(sel.r[0].q1-sel.r[0].q0>RBUFSIZE){
 					err = "right hand side too long in substitution";
 					goto Err;
 				}
 				bufread(&t->file->b, sel.r[0].q0, rbuf, sel.r[0].q1-sel.r[0].q0);
 				for(k=0; k<sel.r[0].q1-sel.r[0].q0; k++)
 					Straddc(buf, rbuf[k]);
 			}
 		elogreplace(t->file, sel.r[0].q0, sel.r[0].q1,  buf->r, buf->n);
 		delta -= sel.r[0].q1-sel.r[0].q0;
 		delta += buf->n;
 		didsub = 1;
 		if(!cp->flag)
 			break;
 	}
 	free(rp);
 	freestring(buf);
 	fbuffree(rbuf);
 	if(!didsub && nest==0)
 		editerror("no substitution");
 	t->q0 = addr.r.q0;
 	t->q1 = addr.r.q1;
 	return TRUE;
 
 Err:
 	free(rp);
 	freestring(buf);
 	fbuffree(rbuf);
 	editerror(err);
 	return FALSE;
 }
 
 int
 u_cmd(Text *t, Cmd *cp)
 {
 	int n, oseq, flag;
 
 	n = cp->num;
 	flag = TRUE;
 	if(n < 0){
 		n = -n;
 		flag = FALSE;
 	}
 	oseq = -1;
 	while(n-->0 && t->file->seq!=oseq){
 		oseq = t->file->seq;
 		undo(t, nil, nil, flag, 0, nil, 0);
 	}
 	return TRUE;
 }
 
 int
 w_cmd(Text *t, Cmd *cp)
 {
 	Rune *r;
 	File *f;
 
 	f = t->file;
 	if(f->seq == seq)
 		editerror("can't write file with pending modifications");
 	r = cmdname(f, cp->u.text, FALSE);
 	if(r == nil)
 		editerror("no name specified for 'w' command");
 	putfile(f, addr.r.q0, addr.r.q1, r, runestrlen(r));
 	/* r is freed by putfile */
 	return TRUE;
 }
 
 int
 x_cmd(Text *t, Cmd *cp)
 {
 	if(cp->re)
 		looper(t->file, cp, cp->cmdc=='x');
 	else
 		linelooper(t->file, cp);
 	return TRUE;
 }
 
 int
 X_cmd(Text *t, Cmd *cp)
 {
 	USED(t);
 
 	filelooper(t, cp, cp->cmdc=='X');
 	return TRUE;
 }
 
 void
 runpipe(Text *t, int cmd, Rune *cr, int ncr, int state)
 {
 	Rune *r, *s;
 	int n;
 	Runestr dir;
 	Window *w;
 	QLock *q;
 
 	r = skipbl(cr, ncr, &n);
 	if(n == 0)
 		editerror("no command specified for %c", cmd);
 	w = nil;
 	if(state == Inserting){
 		w = t->w;
 		t->q0 = addr.r.q0;
 		t->q1 = addr.r.q1;
 		if(cmd == '<' || cmd=='|')
 			elogdelete(t->file, t->q0, t->q1);
 	}
 	s = runemalloc(n+2);
 	s[0] = cmd;
 	runemove(s+1, r, n);
 	n++;
 	dir.r = nil;
 	dir.nr = 0;
 	if(t != nil)
 		dir = dirname(t, nil, 0);
 	if(dir.nr==1 && dir.r[0]=='.'){	/* sigh */
 		free(dir.r);
 		dir.r = nil;
 		dir.nr = 0;
 	}
 	editing = state;
 	if(t!=nil && t->w!=nil)
 		incref(&t->w->ref);	/* run will decref */
 	run(w, runetobyte(s, n), dir.r, dir.nr, TRUE, nil, nil, TRUE);
 	free(s);
 	if(t!=nil && t->w!=nil)
 		winunlock(t->w);
 	qunlock(&row.lk);
 	recvul(cedit);
 	/*
 	 * The editoutlk exists only so that we can tell when
 	 * the editout file has been closed.  It can get closed *after*
 	 * the process exits because, since the process cannot be
 	 * connected directly to editout (no 9P kernel support),
 	 * the process is actually connected to a pipe to another
 	 * process (arranged via 9pserve) that reads from the pipe
 	 * and then writes the data in the pipe to editout using
 	 * 9P transactions.  This process might still have a couple
 	 * writes left to copy after the original process has exited.
 	 */
 	if(w)
 		q = &w->editoutlk;
 	else
 		q = &editoutlk;
 	qlock(q);	/* wait for file to close */
 	qunlock(q);
 	qlock(&row.lk);
 	editing = Inactive;
 	if(t!=nil && t->w!=nil)
 		winlock(t->w, 'M');
 }
 
 int
 pipe_cmd(Text *t, Cmd *cp)
 {
 	runpipe(t, cp->cmdc, cp->u.text->r, cp->u.text->n, Inserting);
 	return TRUE;
 }
 
 long
 nlcount(Text *t, long q0, long q1, long *pnr)
 {
 	long nl, start;
 	Rune *buf;
 	int i, nbuf;
 
 	buf = fbufalloc();
 	nbuf = 0;
 	i = nl = 0;
 	start = q0;
 	while(q0 < q1){
 		if(i == nbuf){
 			nbuf = q1-q0;
 			if(nbuf > RBUFSIZE)
 				nbuf = RBUFSIZE;
 			bufread(&t->file->b, q0, buf, nbuf);
 			i = 0;
 		}
 		if(buf[i++] == '\n') {
 			start = q0+1;
 			nl++;
 		}
 		q0++;
 	}
 	fbuffree(buf);
 	if(pnr != nil)
 		*pnr = q0 - start;
 	return nl;
 }
 
 enum {
 	PosnLine = 0,
 	PosnChars = 1,
 	PosnLineChars = 2,
 };
 
 void
 printposn(Text *t, int mode)
 {
 	long l1, l2, r1, r2;
 
 	if (t != nil && t->file != nil && t->file->name != nil)
 		warning(nil, "%.*S:", t->file->nname, t->file->name);
 
 	switch(mode) {
 	case PosnChars:
 		warning(nil, "#%d", addr.r.q0);
 		if(addr.r.q1 != addr.r.q0)
 			warning(nil, ",#%d", addr.r.q1);
 		warning(nil, "\n");
 		return;
 
 	default:
 	case PosnLine:
 		l1 = 1+nlcount(t, 0, addr.r.q0, nil);
 		l2 = l1+nlcount(t, addr.r.q0, addr.r.q1, nil);
 		/* check if addr ends with '\n' */
 		if(addr.r.q1>0 && addr.r.q1>addr.r.q0 && textreadc(t, addr.r.q1-1)=='\n')
 			--l2;
 		warning(nil, "%lud", l1);
 		if(l2 != l1)
 			warning(nil, ",%lud", l2);
 		warning(nil, "\n");
 		return;
 
 	case PosnLineChars:
 		l1 = 1+nlcount(t, 0, addr.r.q0, &r1);
 		l2 = l1+nlcount(t, addr.r.q0, addr.r.q1, &r2);
 		if(l2 == l1)
 			r2 += r1;
 		warning(nil, "%lud+#%d", l1, r1);
 		if(l2 != l1)
 			warning(nil, ",%lud+#%d", l2, r2);
 		warning(nil, "\n");
 		return;
 	}
 }
 
 int
 eq_cmd(Text *t, Cmd *cp)
 {
 	int mode;
 
 	switch(cp->u.text->n){
 	case 0:
 		mode = PosnLine;
 		break;
 	case 1:
 		if(cp->u.text->r[0] == '#'){
 			mode = PosnChars;
 			break;
 		}
 		if(cp->u.text->r[0] == '+'){
 			mode = PosnLineChars;
 			break;
 		}
 	default:
 		SET(mode);
 		editerror("newline expected");
 	}
 	printposn(t, mode);
 	return TRUE;
 }
 
 int
 nl_cmd(Text *t, Cmd *cp)
 {
 	Address a;
 	File *f;
 
 	f = t->file;
 	if(cp->addr == 0){
 		/* First put it on newline boundaries */
 		mkaddr(&a, f);
 		addr = lineaddr(0, a, -1);
 		a = lineaddr(0, a, 1);
 		addr.r.q1 = a.r.q1;
 		if(addr.r.q0==t->q0 && addr.r.q1==t->q1){
 			mkaddr(&a, f);
 			addr = lineaddr(1, a, 1);
 		}
 	}
 	textshow(t, addr.r.q0, addr.r.q1, 1);
 	return TRUE;
 }
 
 int
 append(File *f, Cmd *cp, long p)
 {
 	if(cp->u.text->n > 0)
 		eloginsert(f, p, cp->u.text->r, cp->u.text->n);
 	f->curtext->q0 = p;
 	f->curtext->q1 = p;
 	return TRUE;
 }
 
 int
 pdisplay(File *f)
 {
 	long p1, p2;
 	int np;
 	Rune *buf;
 
 	p1 = addr.r.q0;
 	p2 = addr.r.q1;
 	if(p2 > f->b.nc)
 		p2 = f->b.nc;
 	buf = fbufalloc();
 	while(p1 < p2){
 		np = p2-p1;
 		if(np>RBUFSIZE-1)
 			np = RBUFSIZE-1;
 		bufread(&f->b, p1, buf, np);
 		buf[np] = '\0';
 		warning(nil, "%S", buf);
 		p1 += np;
 	}
 	fbuffree(buf);
 	f->curtext->q0 = addr.r.q0;
 	f->curtext->q1 = addr.r.q1;
 	return TRUE;
 }
 
 void
 pfilename(File *f)
 {
 	int dirty;
 	Window *w;
 
 	w = f->curtext->w;
 	/* same check for dirty as in settag, but we know ncache==0 */
 	dirty = !w->isdir && !w->isscratch && f->mod;
 	warning(nil, "%c%c%c %.*S\n", " '"[dirty],
 		'+', " ."[curtext!=nil && curtext->file==f], f->nname, f->name);
 }
 
 void
 loopcmd(File *f, Cmd *cp, Range *rp, long nrp)
 {
 	long i;
 
 	for(i=0; i<nrp; i++){
 		f->curtext->q0 = rp[i].q0;
 		f->curtext->q1 = rp[i].q1;
 		cmdexec(f->curtext, cp);
 	}
 }
 
 void
 looper(File *f, Cmd *cp, int xy)
 {
 	long p, op, nrp;
 	Range r, tr;
 	Range *rp;
 
 	r = addr.r;
 	op= xy? -1 : r.q0;
 	nest++;
 	if(rxcompile(cp->re->r) == FALSE)
 		editerror("bad regexp in %c command", cp->cmdc);
 	nrp = 0;
 	rp = nil;
 	for(p = r.q0; p<=r.q1; ){
 		if(!rxexecute(f->curtext, nil, p, r.q1, &sel)){ /* no match, but y should still run */
 			if(xy || op>r.q1)
 				break;
 			tr.q0 = op, tr.q1 = r.q1;
 			p = r.q1+1;	/* exit next loop */
 		}else{
 			if(sel.r[0].q0==sel.r[0].q1){	/* empty match? */
 				if(sel.r[0].q0==op){
 					p++;
 					continue;
 				}
 				p = sel.r[0].q1+1;
 			}else
 				p = sel.r[0].q1;
 			if(xy)
 				tr = sel.r[0];
 			else
 				tr.q0 = op, tr.q1 = sel.r[0].q0;
 		}
 		op = sel.r[0].q1;
 		nrp++;
 		rp = erealloc(rp, nrp*sizeof(Range));
 		rp[nrp-1] = tr;
 	}
 	loopcmd(f, cp->u.cmd, rp, nrp);
 	free(rp);
 	--nest;
 }
 
 void
 linelooper(File *f, Cmd *cp)
 {
 	long nrp, p;
 	Range r, linesel;
 	Address a, a3;
 	Range *rp;
 
 	nest++;
 	nrp = 0;
 	rp = nil;
 	r = addr.r;
 	a3.f = f;
 	a3.r.q0 = a3.r.q1 = r.q0;
 	a = lineaddr(0, a3, 1);
 	linesel = a.r;
 	for(p = r.q0; p<r.q1; p = a3.r.q1){
 		a3.r.q0 = a3.r.q1;
 		if(p!=r.q0 || linesel.q1==p){
 			a = lineaddr(1, a3, 1);
 			linesel = a.r;
 		}
 		if(linesel.q0 >= r.q1)
 			break;
 		if(linesel.q1 >= r.q1)
 			linesel.q1 = r.q1;
 		if(linesel.q1 > linesel.q0)
 			if(linesel.q0>=a3.r.q1 && linesel.q1>a3.r.q1){
 				a3.r = linesel;
 				nrp++;
 				rp = erealloc(rp, nrp*sizeof(Range));
 				rp[nrp-1] = linesel;
 				continue;
 			}
 		break;
 	}
 	loopcmd(f, cp->u.cmd, rp, nrp);
 	free(rp);
 	--nest;
 }
 
 struct Looper
 {
 	Cmd *cp;
 	int	XY;
 	Window	**w;
 	int	nw;
 } loopstruct;	/* only one; X and Y can't nest */
 
 void
 alllooper(Window *w, void *v)
 {
 	Text *t;
 	struct Looper *lp;
 	Cmd *cp;
 
 	lp = v;
 	cp = lp->cp;
 /*	if(w->isscratch || w->isdir) */
 /*		return; */
 	t = &w->body;
 	/* only use this window if it's the current window for the file */
 	if(t->file->curtext != t)
 		return;
 /*	if(w->nopen[QWevent] > 0) */
 /*		return; */
 	/* no auto-execute on files without names */
 	if(cp->re==nil && t->file->nname==0)
 		return;
 	if(cp->re==nil || filematch(t->file, cp->re)==lp->XY){
 		lp->w = erealloc(lp->w, (lp->nw+1)*sizeof(Window*));
 		lp->w[lp->nw++] = w;
 	}
 }
 
 void
 alllocker(Window *w, void *v)
 {
 	if(v)
 		incref(&w->ref);
 	else
 		winclose(w);
 }
 
 void
 filelooper(Text *t, Cmd *cp, int XY)
 {
 	int i;
 	Text *targ;
 
 	if(Glooping++)
 		editerror("can't nest %c command", "YX"[XY]);
 	nest++;
 
 	loopstruct.cp = cp;
 	loopstruct.XY = XY;
 	if(loopstruct.w)	/* error'ed out last time */
 		free(loopstruct.w);
 	loopstruct.w = nil;
 	loopstruct.nw = 0;
 	allwindows(alllooper, &loopstruct);
 	/*
 	 * add a ref to all windows to keep safe windows accessed by X
 	 * that would not otherwise have a ref to hold them up during
 	 * the shenanigans.  note this with globalincref so that any
 	 * newly created windows start with an extra reference.
 	 */
 	allwindows(alllocker, (void*)1);
 	globalincref = 1;
 	
 	/*
 	 * Unlock the window running the X command.
 	 * We'll need to lock and unlock each target window in turn.
 	 */
 	if(t && t->w)
 		winunlock(t->w);
 	
 	for(i=0; i<loopstruct.nw; i++) {
 		targ = &loopstruct.w[i]->body;
 		if(targ && targ->w)
 			winlock(targ->w, cp->cmdc);
 		cmdexec(targ, cp->u.cmd);
 		if(targ && targ->w)
 			winunlock(targ->w);
 	}
 
 	if(t && t->w)
 		winlock(t->w, cp->cmdc);
 
 	allwindows(alllocker, (void*)0);
 	globalincref = 0;
 	free(loopstruct.w);
 	loopstruct.w = nil;
 
 	--Glooping;
 	--nest;
 }
 
 void
 nextmatch(File *f, String *r, long p, int sign)
 {
 	if(rxcompile(r->r) == FALSE)
 		editerror("bad regexp in command address");
 	if(sign >= 0){
 		if(!rxexecute(f->curtext, nil, p, 0x7FFFFFFFL, &sel))
 			editerror("no match for regexp");
 		if(sel.r[0].q0==sel.r[0].q1 && sel.r[0].q0==p){
 			if(++p>f->b.nc)
 				p = 0;
 			if(!rxexecute(f->curtext, nil, p, 0x7FFFFFFFL, &sel))
 				editerror("address");
 		}
 	}else{
 		if(!rxbexecute(f->curtext, p, &sel))
 			editerror("no match for regexp");
 		if(sel.r[0].q0==sel.r[0].q1 && sel.r[0].q1==p){
 			if(--p<0)
 				p = f->b.nc;
 			if(!rxbexecute(f->curtext, p, &sel))
 				editerror("address");
 		}
 	}
 }
 
 File	*matchfile(String*);
 Address	charaddr(long, Address, int);
 Address	lineaddr(long, Address, int);
 
 Address
 cmdaddress(Addr *ap, Address a, int sign)
 {
 	File *f = a.f;
 	Address a1, a2;
 
 	do{
 		switch(ap->type){
 		case 'l':
 		case '#':
 			a = (*(ap->type=='#'?charaddr:lineaddr))(ap->num, a, sign);
 			break;
 
 		case '.':
 			mkaddr(&a, f);
 			break;
 
 		case '$':
 			a.r.q0 = a.r.q1 = f->b.nc;
 			break;
 
 		case '\'':
 editerror("can't handle '");
 /*			a.r = f->mark; */
 			break;
 
 		case '?':
 			sign = -sign;
 			if(sign == 0)
 				sign = -1;
 			/* fall through */
 		case '/':
 			nextmatch(f, ap->u.re, sign>=0? a.r.q1 : a.r.q0, sign);
 			a.r = sel.r[0];
 			break;
 
 		case '"':
 			f = matchfile(ap->u.re);
 			mkaddr(&a, f);
 			break;
 
 		case '*':
 			a.r.q0 = 0, a.r.q1 = f->b.nc;
 			return a;
 
 		case ',':
 		case ';':
 			if(ap->u.left)
 				a1 = cmdaddress(ap->u.left, a, 0);
 			else
 				a1.f = a.f, a1.r.q0 = a1.r.q1 = 0;
 			if(ap->type == ';'){
 				f = a1.f;
 				a = a1;
 				f->curtext->q0 = a1.r.q0;
 				f->curtext->q1 = a1.r.q1;
 			}
 			if(ap->next)
 				a2 = cmdaddress(ap->next, a, 0);
 			else
 				a2.f = a.f, a2.r.q0 = a2.r.q1 = f->b.nc;
 			if(a1.f != a2.f)
 				editerror("addresses in different files");
 			a.f = a1.f, a.r.q0 = a1.r.q0, a.r.q1 = a2.r.q1;
 			if(a.r.q1 < a.r.q0)
 				editerror("addresses out of order");
 			return a;
 
 		case '+':
 		case '-':
 			sign = 1;
 			if(ap->type == '-')
 				sign = -1;
 			if(ap->next==0 || ap->next->type=='+' || ap->next->type=='-')
 				a = lineaddr(1L, a, sign);
 			break;
 		default:
 			error("cmdaddress");
 			return a;
 		}
 	}while(ap = ap->next);	/* assign = */
 	return a;
 }
 
 struct Tofile{
 	File		*f;
 	String	*r;
 };
 
 void
 alltofile(Window *w, void *v)
 {
 	Text *t;
 	struct Tofile *tp;
 
 	tp = v;
 	if(tp->f != nil)
 		return;
 	if(w->isscratch || w->isdir)
 		return;
 	t = &w->body;
 	/* only use this window if it's the current window for the file */
 	if(t->file->curtext != t)
 		return;
 /*	if(w->nopen[QWevent] > 0) */
 /*		return; */
 	if(runeeq(tp->r->r, tp->r->n, t->file->name, t->file->nname))
 		tp->f = t->file;
 }
 
 File*
 tofile(String *r)
 {
 	struct Tofile t;
 	String rr;
 
 	rr.r = skipbl(r->r, r->n, &rr.n);
 	t.f = nil;
 	t.r = &rr;
 	allwindows(alltofile, &t);
 	if(t.f == nil)
 		editerror("no such file\"%S\"", rr.r);
 	return t.f;
 }
 
 void
 allmatchfile(Window *w, void *v)
 {
 	struct Tofile *tp;
 	Text *t;
 
 	tp = v;
 	if(w->isscratch || w->isdir)
 		return;
 	t = &w->body;
 	/* only use this window if it's the current window for the file */
 	if(t->file->curtext != t)
 		return;
 /*	if(w->nopen[QWevent] > 0) */
 /*		return; */
 	if(filematch(w->body.file, tp->r)){
 		if(tp->f != nil)
 			editerror("too many files match \"%S\"", tp->r->r);
 		tp->f = w->body.file;
 	}
 }
 
 File*
 matchfile(String *r)
 {
 	struct Tofile tf;
 
 	tf.f = nil;
 	tf.r = r;
 	allwindows(allmatchfile, &tf);
 
 	if(tf.f == nil)
 		editerror("no file matches \"%S\"", r->r);
 	return tf.f;
 }
 
 int
 filematch(File *f, String *r)
 {
 	char *buf;
 	Rune *rbuf;
 	Window *w;
 	int match, i, dirty;
 	Rangeset s;
 
 	/* compile expr first so if we get an error, we haven't allocated anything */
 	if(rxcompile(r->r) == FALSE)
 		editerror("bad regexp in file match");
 	buf = fbufalloc();
 	w = f->curtext->w;
 	/* same check for dirty as in settag, but we know ncache==0 */
 	dirty = !w->isdir && !w->isscratch && f->mod;
 	snprint(buf, BUFSIZE, "%c%c%c %.*S\n", " '"[dirty],
 		'+', " ."[curtext!=nil && curtext->file==f], f->nname, f->name);
 	rbuf = bytetorune(buf, &i);
 	fbuffree(buf);
 	match = rxexecute(nil, rbuf, 0, i, &s);
 	free(rbuf);
 	return match;
 }
 
 Address
 charaddr(long l, Address addr, int sign)
 {
 	if(sign == 0)
 		addr.r.q0 = addr.r.q1 = l;
 	else if(sign < 0)
 		addr.r.q1 = addr.r.q0 -= l;
 	else if(sign > 0)
 		addr.r.q0 = addr.r.q1 += l;
 	if(addr.r.q0<0 || addr.r.q1>addr.f->b.nc)
 		editerror("address out of range");
 	return addr;
 }
 
 Address
 lineaddr(long l, Address addr, int sign)
 {
 	int n;
 	int c;
 	File *f = addr.f;
 	Address a;
 	long p;
 
 	a.f = f;
 	if(sign >= 0){
 		if(l == 0){
 			if(sign==0 || addr.r.q1==0){
 				a.r.q0 = a.r.q1 = 0;
 				return a;
 			}
 			a.r.q0 = addr.r.q1;
 			p = addr.r.q1-1;
 		}else{
 			if(sign==0 || addr.r.q1==0){
 				p = 0;
 				n = 1;
 			}else{
 				p = addr.r.q1-1;
 				n = textreadc(f->curtext, p++)=='\n';
 			}
 			while(n < l){
 				if(p >= f->b.nc)
 					editerror("address out of range");
 				if(textreadc(f->curtext, p++) == '\n')
 					n++;
 			}
 			a.r.q0 = p;
 		}
 		while(p < f->b.nc && textreadc(f->curtext, p++)!='\n')
 			;
 		a.r.q1 = p;
 	}else{
 		p = addr.r.q0;
 		if(l == 0)
 			a.r.q1 = addr.r.q0;
 		else{
 			for(n = 0; n<l; ){	/* always runs once */
 				if(p == 0){
 					if(++n != l)
 						editerror("address out of range");
 				}else{
 					c = textreadc(f->curtext, p-1);
 					if(c != '\n' || ++n != l)
 						p--;
 				}
 			}
 			a.r.q1 = p;
 			if(p > 0)
 				p--;
 		}
 		while(p > 0 && textreadc(f->curtext, p-1)!='\n')	/* lines start after a newline */
 			p--;
 		a.r.q0 = p;
 	}
 	return a;
 }
 
 struct Filecheck
 {
 	File	*f;
 	Rune	*r;
 	int nr;
 };
 
 void
 allfilecheck(Window *w, void *v)
 {
 	struct Filecheck *fp;
 	File *f;
 
 	fp = v;
 	f = w->body.file;
 	if(w->body.file == fp->f)
 		return;
 	if(runeeq(fp->r, fp->nr, f->name, f->nname))
 		warning(nil, "warning: duplicate file name \"%.*S\"\n", fp->nr, fp->r);
 }
 
 Rune*
 cmdname(File *f, String *str, int set)
 {
 	Rune *r, *s;
 	int n;
 	struct Filecheck fc;
 	Runestr newname;
 
 	r = nil;
 	n = str->n;
 	s = str->r;
 	if(n == 0){
 		/* no name; use existing */
 		if(f->nname == 0)
 			return nil;
 		r = runemalloc(f->nname+1);
 		runemove(r, f->name, f->nname);
 		return r;
 	}
 	s = skipbl(s, n, &n);
 	if(n == 0)
 		goto Return;
 
 	if(s[0] == '/'){
 		r = runemalloc(n+1);
 		runemove(r, s, n);
 	}else{
 		newname = dirname(f->curtext, runestrdup(s), n);
 		n = newname.nr;
 		r = runemalloc(n+1);	/* NUL terminate */
 		runemove(r, newname.r, n);
 		free(newname.r);
 	}
 	fc.f = f;
 	fc.r = r;
 	fc.nr = n;
 	allwindows(allfilecheck, &fc);
 	if(f->nname == 0)
 		set = TRUE;
 
     Return:
 	if(set && !runeeq(r, n, f->name, f->nname)){
 		filemark(f);
 		f->mod = TRUE;
 		f->curtext->w->dirty = TRUE;
 		winsetname(f->curtext->w, r, n);
 	}
 	return r;
 }