text: #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 <regexp.h>
  #include <9pclient.h>
  #include <plumb.h>
  #include <libsec.h>
  #include "dat.h"
  #include "fns.h"
  
  CFid *plumbsendfid;
  CFid *plumbeditfid;
  
  Window*	openfile(Text*, Expand*);
  
  int	nuntitled;
  
  void
  plumbthread(void *v)
  {
  	CFid *fid;
  	Plumbmsg *m;
  	Timer *t;
  
  	USED(v);
  	threadsetname("plumbproc");
  
  	/*
  	 * Loop so that if plumber is restarted, acme need not be.
  	 */
  	for(;;){
  		/*
  		 * Connect to plumber.
  		 */
  		plumbunmount();
  		while((fid = plumbopenfid("edit", OREAD|OCEXEC)) == nil){
  			t = timerstart(2000);
  			recv(t->c, nil);
  			timerstop(t);
  		}
  		plumbeditfid = fid;
  		plumbsendfid = plumbopenfid("send", OWRITE|OCEXEC);
  
  		/*
  		 * Relay messages.
  		 */
  		for(;;){
  			m = plumbrecvfid(plumbeditfid);
  			if(m == nil)
  				break;
  			sendp(cplumb, m);
  		}
  
  		/*
  		 * Lost connection.
  		 */
  		fid = plumbsendfid;
  		plumbsendfid = nil;
  		fsclose(fid);
  
  		fid = plumbeditfid;
  		plumbeditfid = nil;
  		fsclose(fid);
  	}
  }
  
  void
  startplumbing(void)
  {
  	cplumb = chancreate(sizeof(Plumbmsg*), 0);
  	chansetname(cplumb, "cplumb");
  	threadcreate(plumbthread, nil, STACK);
  }
  
  
  void
  look3(Text *t, uint q0, uint q1, int external)
  {
  	int n, c, f, expanded;
  	Text *ct;
  	Expand e;
  	Rune *r;
  	uint p;
  	Plumbmsg *m;
  	Runestr dir;
  	char buf[32];
  
  	ct = seltext;
  	if(ct == nil)
  		seltext = t;
  	expanded = expand(t, q0, q1, &e);
  	if(!external && t->w!=nil && t->w->nopen[QWevent]>0){
  		/* send alphanumeric expansion to external client */
  		if(expanded == FALSE)
  			return;
  		f = 0;
  		if((e.u.at!=nil && t->w!=nil) || (e.nname>0 && lookfile(e.name, e.nname)!=nil))
  			f = 1;		/* acme can do it without loading a file */
  		if(q0!=e.q0 || q1!=e.q1)
  			f |= 2;	/* second (post-expand) message follows */
  		if(e.nname)
  			f |= 4;	/* it's a file name */
  		c = 'l';
  		if(t->what == Body)
  			c = 'L';
  		n = q1-q0;
  		if(n <= EVENTSIZE){
  			r = runemalloc(n);
  			bufread(&t->file->b, q0, r, n);
  			winevent(t->w, "%c%d %d %d %d %.*S\n", c, q0, q1, f, n, n, r);
  			free(r);
  		}else
  			winevent(t->w, "%c%d %d %d 0 \n", c, q0, q1, f, n);
  		if(q0==e.q0 && q1==e.q1)
  			return;
  		if(e.nname){
  			n = e.nname;
  			if(e.a1 > e.a0)
  				n += 1+(e.a1-e.a0);
  			r = runemalloc(n);
  			runemove(r, e.name, e.nname);
  			if(e.a1 > e.a0){
  				r[e.nname] = ':';
  				bufread(&e.u.at->file->b, e.a0, r+e.nname+1, e.a1-e.a0);
  			}
  		}else{
  			n = e.q1 - e.q0;
  			r = runemalloc(n);
  			bufread(&t->file->b, e.q0, r, n);
  		}
  		f &= ~2;
  		if(n <= EVENTSIZE)
  			winevent(t->w, "%c%d %d %d %d %.*S\n", c, e.q0, e.q1, f, n, n, r);
  		else
  			winevent(t->w, "%c%d %d %d 0 \n", c, e.q0, e.q1, f, n);
  		free(r);
  		goto Return;
  	}
  	if(plumbsendfid != nil){
  		/* send whitespace-delimited word to plumber */
  		m = emalloc(sizeof(Plumbmsg));
  		m->src = estrdup("acme");
  		m->dst = nil;
  		dir = dirname(t, nil, 0);
  		if(dir.nr==1 && dir.r[0]=='.'){	/* sigh */
  			free(dir.r);
  			dir.r = nil;
  			dir.nr = 0;
  		}
  		if(dir.nr == 0)
  			m->wdir = estrdup(wdir);
  		else
  			m->wdir = runetobyte(dir.r, dir.nr);
  		free(dir.r);
  		m->type = estrdup("text");
  		m->attr = nil;
  		buf[0] = '\0';
  		if(q1 == q0){
  			if(t->q1>t->q0 && t->q0<=q0 && q0<=t->q1){
  				q0 = t->q0;
  				q1 = t->q1;
  			}else{
  				p = q0;
  				while(q0>0 && (c=tgetc(t, q0-1))!=' ' && c!='\t' && c!='\n')
  					q0--;
  				while(q1<t->file->b.nc && (c=tgetc(t, q1))!=' ' && c!='\t' && c!='\n')
  					q1++;
  				if(q1 == q0){
  					plumbfree(m);
  					goto Return;
  				}
  				sprint(buf, "click=%d", p-q0);
  				m->attr = plumbunpackattr(buf);
  			}
  		}
  		r = runemalloc(q1-q0);
  		bufread(&t->file->b, q0, r, q1-q0);
  		m->data = runetobyte(r, q1-q0);
  		m->ndata = strlen(m->data);
  		free(r);
  		if(m->ndata<messagesize-1024 && plumbsendtofid(plumbsendfid, m) >= 0){
  			plumbfree(m);
  			goto Return;
  		}
  		plumbfree(m);
  		/* plumber failed to match; fall through */
  	}
  
  	/* interpret alphanumeric string ourselves */
  	if(expanded == FALSE)
  		return;
  	if(e.name || e.u.at)
  		openfile(t, &e);
  	else{
  		if(t->w == nil)
  			return;
  		ct = &t->w->body;
  		if(t->w != ct->w)
  			winlock(ct->w, 'M');
  		if(t == ct)
  			textsetselect(ct, e.q1, e.q1);
  		n = e.q1 - e.q0;
  		r = runemalloc(n);
  		bufread(&t->file->b, e.q0, r, n);
  		if(search(ct, r, n) && e.jump)
  			moveto(mousectl, addpt(frptofchar(&ct->fr, ct->fr.p0), Pt(4, ct->fr.font->height-4)));
  		if(t->w != ct->w)
  			winunlock(ct->w);
  		free(r);
  	}
  
     Return:
  	free(e.name);
  	free(e.bname);
  }
  
  int
  plumbgetc(void *a, uint n)
  {
  	Rune *r;
  
  	r = a;
  	if(n>runestrlen(r))
  		return 0;
  	return r[n];
  }
  
  void
  plumblook(Plumbmsg *m)
  {
  	Expand e;
  	char *addr;
  
  	if(m->ndata >= BUFSIZE){
  		warning(nil, "insanely long file name (%d bytes) in plumb message (%.32s...)\n", m->ndata, m->data);
  		return;
  	}
  	e.q0 = 0;
  	e.q1 = 0;
  	if(m->data[0] == '\0')
  		return;
  	e.u.ar = nil;
  	e.bname = m->data;
  	e.name = bytetorune(e.bname, &e.nname);
  	e.jump = TRUE;
  	e.a0 = 0;
  	e.a1 = 0;
  	addr = plumblookup(m->attr, "addr");
  	if(addr != nil){
  		e.u.ar = bytetorune(addr, &e.a1);
  		e.agetc = plumbgetc;
  	}
  	drawtopwindow();
  	openfile(nil, &e);
  	free(e.name);
  	free(e.u.at);
  }
  
  void
  plumbshow(Plumbmsg *m)
  {
  	Window *w;
  	Rune rb[256], *r;
  	int nb, nr;
  	Runestr rs;
  	char *name, *p, namebuf[16];
  
  	drawtopwindow();
  	w = makenewwindow(nil);
  	name = plumblookup(m->attr, "filename");
  	if(name == nil){
  		name = namebuf;
  		nuntitled++;
  		snprint(namebuf, sizeof namebuf, "Untitled-%d", nuntitled);
  	}
  	p = nil;
  	if(name[0]!='/' && m->wdir!=nil && m->wdir[0]!='\0'){
  		nb = strlen(m->wdir) + 1 + strlen(name) + 1;
  		p = emalloc(nb);
  		snprint(p, nb, "%s/%s", m->wdir, name);
  		name = p;
  	}
  	cvttorunes(name, strlen(name), rb, &nb, &nr, nil);
  	free(p);
  	rs = cleanrname(runestr(rb, nr));
  	winsetname(w, rs.r, rs.nr);
  	r = runemalloc(m->ndata);
  	cvttorunes(m->data, m->ndata, r, &nb, &nr, nil);
  	textinsert(&w->body, 0, r, nr, TRUE);
  	free(r);
  	w->body.file->mod = FALSE;
  	w->dirty = FALSE;
  	winsettag(w);
  	textscrdraw(&w->body);
  	textsetselect(&w->tag, w->tag.file->b.nc, w->tag.file->b.nc);
  	xfidlog(w, "new");
  }
  
  int
  search(Text *ct, Rune *r, uint n)
  {
  	uint q, nb, maxn;
  	int around;
  	Rune *s, *b, *c;
  
  	if(n==0 || n>ct->file->b.nc)
  		return FALSE;
  	if(2*n > RBUFSIZE){
  		warning(nil, "string too long\n");
  		return FALSE;
  	}
  	maxn = max(2*n, RBUFSIZE);
  	s = fbufalloc();
  	b = s;
  	nb = 0;
  	b[nb] = 0;
  	around = 0;
  	q = ct->q1;
  	for(;;){
  		if(q >= ct->file->b.nc){
  			q = 0;
  			around = 1;
  			nb = 0;
  			b[nb] = 0;
  		}
  		if(nb > 0){
  			c = runestrchr(b, r[0]);
  			if(c == nil){
  				q += nb;
  				nb = 0;
  				b[nb] = 0;
  				if(around && q>=ct->q1)
  					break;
  				continue;
  			}
  			q += (c-b);
  			nb -= (c-b);
  			b = c;
  		}
  		/* reload if buffer covers neither string nor rest of file */
  		if(nb<n && nb!=ct->file->b.nc-q){
  			nb = ct->file->b.nc-q;
  			if(nb >= maxn)
  				nb = maxn-1;
  			bufread(&ct->file->b, q, s, nb);
  			b = s;
  			b[nb] = '\0';
  		}
  		/* this runeeq is fishy but the null at b[nb] makes it safe */
  		if(runeeq(b, n, r, n)==TRUE){
  			if(ct->w){
  				textshow(ct, q, q+n, 1);
  				winsettag(ct->w);
  			}else{
  				ct->q0 = q;
  				ct->q1 = q+n;
  			}
  			seltext = ct;
  			fbuffree(s);
  			return TRUE;
  		}
  		--nb;
  		b++;
  		q++;
  		if(around && q>=ct->q1)
  			break;
  	}
  	fbuffree(s);
  	return FALSE;
  }
  
  int
  isfilec(Rune r)
  {
  	static Rune Lx[] = { '.', '-', '+', '/', ':', 0 };
  	if(isalnum(r))
  		return TRUE;
  	if(runestrchr(Lx, r))
  		return TRUE;
  	return FALSE;
  }
  
  /* Runestr wrapper for cleanname */
  Runestr
  cleanrname(Runestr rs)
  {
  	char *s;
  	int nb, nulls;
  
  	s = runetobyte(rs.r, rs.nr);
  	cleanname(s);
  	cvttorunes(s, strlen(s), rs.r, &nb, &rs.nr, &nulls);
  	free(s);
  	return rs;
  }
  
  Runestr
  includefile(Rune *dir, Rune *file, int nfile)
  {
  	int m, n;
  	char *a;
  	Rune *r;
  	static Rune Lslash[] = { '/', 0 };
  
  	m = runestrlen(dir);
  	a = emalloc((m+1+nfile)*UTFmax+1);
  	sprint(a, "%S/%.*S", dir, nfile, file);
  	n = access(a, 0);
  	free(a);
  	if(n < 0)
  		return runestr(nil, 0);
  	r = runemalloc(m+1+nfile);
  	runemove(r, dir, m);
  	runemove(r+m, Lslash, 1);
  	runemove(r+m+1, file, nfile);
  	free(file);
  	return cleanrname(runestr(r, m+1+nfile));
  }
  
  static	Rune	*objdir;
  
  Runestr
  includename(Text *t, Rune *r, int n)
  {
  	Window *w;
  	char buf[128];
  	Rune Lsysinclude[] = { '/', 's', 'y', 's', '/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
  	Rune Lusrinclude[] = { '/', 'u', 's', 'r', '/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
  	Rune Lusrlocalinclude[] = { '/', 'u', 's', 'r', '/', 'l', 'o', 'c', 'a', 'l',
  			'/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
  	Rune Lusrlocalplan9include[] = { '/', 'u', 's', 'r', '/', 'l', 'o', 'c', 'a', 'l',
  			'/', 'p', 'l', 'a', 'n', '9', '/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
  	Runestr file;
  	int i;
  
  	if(objdir==nil && objtype!=nil){
  		sprint(buf, "/%s/include", objtype);
  		objdir = bytetorune(buf, &i);
  		objdir = runerealloc(objdir, i+1);
  		objdir[i] = '\0';
  	}
  
  	w = t->w;
  	if(n==0 || r[0]=='/' || w==nil)
  		goto Rescue;
  	if(n>2 && r[0]=='.' && r[1]=='/')
  		goto Rescue;
  	file.r = nil;
  	file.nr = 0;
  	for(i=0; i<w->nincl && file.r==nil; i++)
  		file = includefile(w->incl[i], r, n);
  
  	if(file.r == nil)
  		file = includefile(Lsysinclude, r, n);
  	if(file.r == nil)
  		file = includefile(Lusrlocalplan9include, r, n);
  	if(file.r == nil)
  		file = includefile(Lusrlocalinclude, r, n);
  	if(file.r == nil)
  		file = includefile(Lusrinclude, r, n);
  	if(file.r==nil && objdir!=nil)
  		file = includefile(objdir, r, n);
  	if(file.r == nil)
  		goto Rescue;
  	return file;
  
      Rescue:
  	return runestr(r, n);
  }
  
  Runestr
  dirname(Text *t, Rune *r, int n)
  {
  	Rune *b;
  	uint nt;
  	int slash, i;
  	Runestr tmp;
  
  	b = nil;
  	if(t==nil || t->w==nil)
  		goto Rescue;
  	nt = t->w->tag.file->b.nc;
  	if(nt == 0)
  		goto Rescue;
  	if(n>=1 && r[0]=='/')
  		goto Rescue;
  	b = parsetag(t->w, n, &i);
  	slash = -1;
  	for(i--; i >= 0; i--){
  		if(b[i] == '/'){
  			slash = i;
  			break;
  		}
  	}
  	if(slash < 0)
  		goto Rescue;
  	runemove(b+slash+1, r, n);
  	free(r);
  	return cleanrname(runestr(b, slash+1+n));
  
      Rescue:
  	free(b);
  	tmp = runestr(r, n);
  	if(r)
  		return cleanrname(tmp);
  	return tmp;
  }
  
  static int
  texthas(Text *t, uint q0, Rune *r)
  {
  	int i;
  
  	if((int)q0 < 0)
  		return FALSE;
  	for(i=0; r[i]; i++)
  		if(q0+i >= t->file->b.nc || textreadc(t, q0+i) != r[i])
  			return FALSE;
  	return TRUE;
  }
  
  int
  expandfile(Text *t, uint q0, uint q1, Expand *e)
  {
  	int i, n, nname, colon, eval;
  	uint amin, amax;
  	Rune *r, c;
  	Window *w;
  	Runestr rs;
  	Rune Lhttpcss[] = {'h', 't', 't', 'p', ':', '/', '/', 0};
  	Rune Lhttpscss[] = {'h', 't', 't', 'p', 's', ':', '/', '/', 0};
  
  	amax = q1;
  	if(q1 == q0){
  		colon = -1;
  		while(q1<t->file->b.nc && isfilec(c=textreadc(t, q1))){
  			if(c == ':' && !texthas(t, q1-4, Lhttpcss) && !texthas(t, q1-5, Lhttpscss)){
  				colon = q1;
  				break;
  			}
  			q1++;
  		}
  		while(q0>0 && (isfilec(c=textreadc(t, q0-1)) || isaddrc(c) || isregexc(c))){
  			q0--;
  			if(colon<0 && c==':' && !texthas(t, q0-4, Lhttpcss) && !texthas(t, q0-5, Lhttpscss))
  				colon = q0;
  		}
  		/*
  		 * if it looks like it might begin file: , consume address chars after :
  		 * otherwise terminate expansion at :
  		 */
  		if(colon >= 0){
  			q1 = colon;
  			if(colon<t->file->b.nc-1 && isaddrc(textreadc(t, colon+1))){
  				q1 = colon+1;
  				while(q1<t->file->b.nc && isaddrc(textreadc(t, q1)))
  					q1++;
  			}
  		}
  		if(q1 > q0)
  			if(colon >= 0){	/* stop at white space */
  				for(amax=colon+1; amax<t->file->b.nc; amax++)
  					if((c=textreadc(t, amax))==' ' || c=='\t' || c=='\n')
  						break;
  			}else
  				amax = t->file->b.nc;
  	}
  	amin = amax;
  	e->q0 = q0;
  	e->q1 = q1;
  	n = q1-q0;
  	if(n == 0)
  		return FALSE;
  	/* see if it's a file name */
  	r = runemalloc(n+1);
  	bufread(&t->file->b, q0, r, n);
  	r[n] = 0;
  	/* is it a URL? look for http:// and https:// prefix */
  	if(runestrncmp(r, Lhttpcss, 7) == 0 || runestrncmp(r, Lhttpscss, 8) == 0){
  		// Avoid capturing end-of-sentence punctuation.
  		if(r[n-1] == '.') {
  			e->q1--;
  			n--;
  		}
  		e->name = r;
  		e->nname = n;
  		e->u.at = t;
  		e->a0 = e->q1;
  		e->a1 = e->q1;
  		return TRUE;
  	}
  	/* first, does it have bad chars? */
  	nname = -1;
  	for(i=0; i<n; i++){
  		c = r[i];
  		if(c==':' && nname<0){
  			if(q0+i+1<t->file->b.nc && (i==n-1 || isaddrc(textreadc(t, q0+i+1))))
  				amin = q0+i;
  			else
  				goto Isntfile;
  			nname = i;
  		}
  	}
  	if(nname == -1)
  		nname = n;
  	for(i=0; i<nname; i++)
  		if(!isfilec(r[i]) && r[i] != ' ')
  			goto Isntfile;
  	/*
  	 * See if it's a file name in <>, and turn that into an include
  	 * file name if so.  Should probably do it for "" too, but that's not
  	 * restrictive enough syntax and checking for a #include earlier on the
  	 * line would be silly.
  	 */
  	if(q0>0 && textreadc(t, q0-1)=='<' && q1<t->file->b.nc && textreadc(t, q1)=='>'){
  		rs = includename(t, r, nname);
  		r = rs.r;
  		nname = rs.nr;
  	}
  	else if(amin == q0)
  		goto Isfile;
  	else{
  		rs = dirname(t, r, nname);
  		r = rs.r;
  		nname = rs.nr;
  	}
  	e->bname = runetobyte(r, nname);
  	/* if it's already a window name, it's a file */
  	w = lookfile(r, nname);
  	if(w != nil)
  		goto Isfile;
  	/* if it's the name of a file, it's a file */
  	if(ismtpt(e->bname) || access(e->bname, 0) < 0){
  		free(e->bname);
  		e->bname = nil;
  		goto Isntfile;
  	}
  
    Isfile:
  	e->name = r;
  	e->nname = nname;
  	e->u.at = t;
  	e->a0 = amin+1;
  	eval = FALSE;
  	address(TRUE, nil, range(-1,-1), range(0,0), t, e->a0, amax, tgetc, &eval, (uint*)&e->a1);
  	return TRUE;
  
     Isntfile:
  	free(r);
  	return FALSE;
  }
  
  int
  expand(Text *t, uint q0, uint q1, Expand *e)
  {
  	memset(e, 0, sizeof *e);
  	e->agetc = tgetc;
  	/* if in selection, choose selection */
  	e->jump = TRUE;
  	if(q1==q0 && t->q1>t->q0 && t->q0<=q0 && q0<=t->q1){
  		q0 = t->q0;
  		q1 = t->q1;
  		if(t->what == Tag)
  			e->jump = FALSE;
  	}
  
  	if(expandfile(t, q0, q1, e))
  		return TRUE;
  
  	if(q0 == q1){
  		while(q1<t->file->b.nc && isalnum(textreadc(t, q1)))
  			q1++;
  		while(q0>0 && isalnum(textreadc(t, q0-1)))
  			q0--;
  	}
  	e->q0 = q0;
  	e->q1 = q1;
  	return q1 > q0;
  }
  
  Window*
  lookfile(Rune *s, int n)
  {
  	int i, j, k;
  	Window *w;
  	Column *c;
  	Text *t;
  
  	/* avoid terminal slash on directories */
  	if(n>1 && s[n-1] == '/')
  		--n;
  	for(j=0; j<row.ncol; j++){
  		c = row.col[j];
  		for(i=0; i<c->nw; i++){
  			w = c->w[i];
  			t = &w->body;
  			k = t->file->nname;
  			if(k>1 && t->file->name[k-1] == '/')
  				k--;
  			if(runeeq(t->file->name, k, s, n)){
  				w = w->body.file->curtext->w;
  				if(w->col != nil)	/* protect against race deleting w */
  					return w;
  			}
  		}
  	}
  	return nil;
  }
  
  Window*
  lookid(int id, int dump)
  {
  	int i, j;
  	Window *w;
  	Column *c;
  
  	for(j=0; j<row.ncol; j++){
  		c = row.col[j];
  		for(i=0; i<c->nw; i++){
  			w = c->w[i];
  			if(dump && w->dumpid == id)
  				return w;
  			if(!dump && w->id == id)
  				return w;
  		}
  	}
  	return nil;
  }
  
  
  Window*
  openfile(Text *t, Expand *e)
  {
  	Range r;
  	Window *w, *ow;
  	int eval, i, n;
  	Rune *rp;
  	Runestr rs;
  	uint dummy;
  
  	r.q0 = 0;
  	r.q1 = 0;
  	if(e->nname == 0){
  		w = t->w;
  		if(w == nil)
  			return nil;
  	}else{
  		w = lookfile(e->name, e->nname);
  		if(w == nil && e->name[0] != '/'){
  			/*
  			 * Unrooted path in new window.
  			 * This can happen if we type a pwd-relative path
  			 * in the topmost tag or the column tags.
  			 * Most of the time plumber takes care of these,
  			 * but plumber might not be running or might not
  			 * be configured to accept plumbed directories.
  			 * Make the name a full path, just like we would if
  			 * opening via the plumber.
  			 */
  			n = utflen(wdir)+1+e->nname+1;
  			rp = runemalloc(n);
  			runesnprint(rp, n, "%s/%.*S", wdir, e->nname, e->name);
  			rs = cleanrname(runestr(rp, n-1));
  			free(e->name);
  			e->name = rs.r;
  			e->nname = rs.nr;
  			w = lookfile(e->name, e->nname);
  		}
  	}
  	if(w){
  		t = &w->body;
  		if(!t->col->safe && t->fr.maxlines==0) /* window is obscured by full-column window */
  			colgrow(t->col, t->col->w[0], 1);
  	}else{
  		ow = nil;
  		if(t)
  			ow = t->w;
  		w = makenewwindow(t);
  		t = &w->body;
  		winsetname(w, e->name, e->nname);
  		if(textload(t, 0, e->bname, 1) >= 0)
  			t->file->unread = FALSE;
  		t->file->mod = FALSE;
  		t->w->dirty = FALSE;
  		winsettag(t->w);
  		textsetselect(&t->w->tag, t->w->tag.file->b.nc, t->w->tag.file->b.nc);
  		if(ow != nil){
  			for(i=ow->nincl; --i>=0; ){
  				n = runestrlen(ow->incl[i]);
  				rp = runemalloc(n);
  				runemove(rp, ow->incl[i], n);
  				winaddincl(w, rp, n);
  			}
  			w->autoindent = ow->autoindent;
  		}else
  			w->autoindent = globalautoindent;
  		xfidlog(w, "new");
  	}
  	if(e->a1 == e->a0)
  		eval = FALSE;
  	else{
  		eval = TRUE;
  		r = address(TRUE, t, range(-1,-1), range(t->q0, t->q1), e->u.at, e->a0, e->a1, e->agetc, &eval, &dummy);
  		if(r.q0 > r.q1) {
  			eval = FALSE;
  			warning(nil, "addresses out of order\n");
  		}
  		if(eval == FALSE)
  			e->jump = FALSE;	/* don't jump if invalid address */
  	}
  	if(eval == FALSE){
  		r.q0 = t->q0;
  		r.q1 = t->q1;
  	}
  	textshow(t, r.q0, r.q1, 1);
  	winsettag(t->w);
  	seltext = t;
  	if(e->jump)
  		moveto(mousectl, addpt(frptofchar(&t->fr, t->fr.p0), Pt(4, font->height-4)));
  	return w;
  }
  
  void
  new(Text *et, Text *t, Text *argt, int flag1, int flag2, Rune *arg, int narg)
  {
  	int ndone;
  	Rune *a, *f;
  	int na, nf;
  	Expand e;
  	Runestr rs;
  	Window *w;
  
  	getarg(argt, FALSE, TRUE, &a, &na);
  	if(a){
  		new(et, t, nil, flag1, flag2, a, na);
  		if(narg == 0)
  			return;
  	}
  	/* loop condition: *arg is not a blank */
  	for(ndone=0; ; ndone++){
  		a = findbl(arg, narg, &na);
  		if(a == arg){
  			if(ndone==0 && et->col!=nil) {
  				w = coladd(et->col, nil, nil, -1);
  				winsettag(w);
  				xfidlog(w, "new");
  			}
  			break;
  		}
  		nf = narg-na;
  		f = runemalloc(nf);
  		runemove(f, arg, nf);
  		rs = dirname(et, f, nf);
  		memset(&e, 0, sizeof e);
  		e.name = rs.r;
  		e.nname = rs.nr;
  		e.bname = runetobyte(rs.r, rs.nr);
  		e.jump = TRUE;
  		openfile(et, &e);
  		free(e.name);
  		free(e.bname);
  		arg = skipbl(a, na, &narg);
  	}
  }
  