1 #include <u.h>
2 #include <libc.h>
3 #include <draw.h>
4 #include <thread.h>
5 #include <cursor.h>
6 #include <mouse.h>
7 #include <keyboard.h>
8 #include <frame.h>
9 #include <fcall.h>
10 #include <regexp.h>
11 #include <9pclient.h>
12 #include <plumb.h>
13 #include "dat.h"
14 #include "fns.h"
15 
16 CFid *plumbsendfid;
17 CFid *plumbeditfid;
18 
19 Window*	openfile(Text*, Expand*);
20 
21 int	nuntitled;
22 
23 void
24 plumbthread(void *v)
25 {
26 	CFid *fid;
27 	Plumbmsg *m;
28 	Timer *t;
29 
30 	USED(v);
31 	threadsetname("plumbproc");
32 	
33 	/*
34 	 * Loop so that if plumber is restarted, acme need not be.
35 	 */
36 	for(;;){
37 		/*
38 		 * Connect to plumber.
39 		 */
40 		plumbunmount();
41 		while((fid = plumbopenfid("edit", OREAD|OCEXEC)) == nil){
42 			t = timerstart(2000);
43 			recv(t->c, nil);
44 			timerstop(t);
45 		}
46 		plumbeditfid = fid;
47 		plumbsendfid = plumbopenfid("send", OWRITE|OCEXEC);
48 	
49 		/*
50 		 * Relay messages.
51 		 */
52 		for(;;){
53 			m = plumbrecvfid(plumbeditfid);
54 			if(m == nil)
55 				break;
56 			sendp(cplumb, m);
57 		}
58 
59 		/*
60 		 * Lost connection.
61 		 */
62 		fid = plumbsendfid;
63 		plumbsendfid = nil;
64 		fsclose(fid);
65 
66 		fid = plumbeditfid;
67 		plumbeditfid = nil;
68 		fsclose(fid);
69 	}
70 }
71 
72 void
73 startplumbing(void)
74 {
75 	cplumb = chancreate(sizeof(Plumbmsg*), 0);
76 	chansetname(cplumb, "cplumb");
77 	threadcreate(plumbthread, nil, STACK);
78 }
79 
80 
81 void
82 look3(Text *t, uint q0, uint q1, int external)
83 {
84 	int n, c, f, expanded;
85 	Text *ct;
86 	Expand e;
87 	Rune *r;
88 	uint p;
89 	Plumbmsg *m;
90 	Runestr dir;
91 	char buf[32];
92 
93 	ct = seltext;
94 	if(ct == nil)
95 		seltext = t;
96 	expanded = expand(t, q0, q1, &e);
97 	if(!external && t->w!=nil && t->w->nopen[QWevent]>0){
98 		/* send alphanumeric expansion to external client */
99 		if(expanded == FALSE)
100 			return;
101 		f = 0;
102 		if((e.u.at!=nil && t->w!=nil) || (e.nname>0 && lookfile(e.name, e.nname)!=nil))
103 			f = 1;		/* acme can do it without loading a file */
104 		if(q0!=e.q0 || q1!=e.q1)
105 			f |= 2;	/* second (post-expand) message follows */
106 		if(e.nname)
107 			f |= 4;	/* it's a file name */
108 		c = 'l';
109 		if(t->what == Body)
110 			c = 'L';
111 		n = q1-q0;
112 		if(n <= EVENTSIZE){
113 			r = runemalloc(n);
114 			bufread(&t->file->b, q0, r, n);
115 			winevent(t->w, "%c%d %d %d %d %.*S\n", c, q0, q1, f, n, n, r);
116 			free(r);
117 		}else
118 			winevent(t->w, "%c%d %d %d 0 \n", c, q0, q1, f, n);
119 		if(q0==e.q0 && q1==e.q1)
120 			return;
121 		if(e.nname){
122 			n = e.nname;
123 			if(e.a1 > e.a0)
124 				n += 1+(e.a1-e.a0);
125 			r = runemalloc(n);
126 			runemove(r, e.name, e.nname);
127 			if(e.a1 > e.a0){
128 				r[e.nname] = ':';
129 				bufread(&e.u.at->file->b, e.a0, r+e.nname+1, e.a1-e.a0);
130 			}
131 		}else{
132 			n = e.q1 - e.q0;
133 			r = runemalloc(n);
134 			bufread(&t->file->b, e.q0, r, n);
135 		}
136 		f &= ~2;
137 		if(n <= EVENTSIZE)
138 			winevent(t->w, "%c%d %d %d %d %.*S\n", c, e.q0, e.q1, f, n, n, r);
139 		else
140 			winevent(t->w, "%c%d %d %d 0 \n", c, e.q0, e.q1, f, n);
141 		free(r);
142 		goto Return;
143 	}
144 	if(plumbsendfid != nil){
145 		/* send whitespace-delimited word to plumber */
146 		m = emalloc(sizeof(Plumbmsg));
147 		m->src = estrdup("acme");
148 		m->dst = nil;
149 		dir = dirname(t, nil, 0);
150 		if(dir.nr==1 && dir.r[0]=='.'){	/* sigh */
151 			free(dir.r);
152 			dir.r = nil;
153 			dir.nr = 0;
154 		}
155 		if(dir.nr == 0)
156 			m->wdir = estrdup(wdir);
157 		else
158 			m->wdir = runetobyte(dir.r, dir.nr);
159 		free(dir.r);
160 		m->type = estrdup("text");
161 		m->attr = nil;
162 		buf[0] = '\0';
163 		if(q1 == q0){
164 			if(t->q1>t->q0 && t->q0<=q0 && q0<=t->q1){
165 				q0 = t->q0;
166 				q1 = t->q1;
167 			}else{
168 				p = q0;
169 				while(q0>0 && (c=tgetc(t, q0-1))!=' ' && c!='\t' && c!='\n')
170 					q0--;
171 				while(q1<t->file->b.nc && (c=tgetc(t, q1))!=' ' && c!='\t' && c!='\n')
172 					q1++;
173 				if(q1 == q0){
174 					plumbfree(m);
175 					goto Return;
176 				}
177 				sprint(buf, "click=%d", p-q0);
178 				m->attr = plumbunpackattr(buf);
179 			}
180 		}
181 		r = runemalloc(q1-q0);
182 		bufread(&t->file->b, q0, r, q1-q0);
183 		m->data = runetobyte(r, q1-q0);
184 		m->ndata = strlen(m->data);
185 		free(r);
186 		if(m->ndata<messagesize-1024 && plumbsendtofid(plumbsendfid, m) >= 0){
187 			plumbfree(m);
188 			goto Return;
189 		}
190 		plumbfree(m);
191 		/* plumber failed to match; fall through */
192 	}
193 
194 	/* interpret alphanumeric string ourselves */
195 	if(expanded == FALSE)
196 		return;
197 	if(e.name || e.u.at)
198 		openfile(t, &e);
199 	else{
200 		if(t->w == nil)
201 			return;
202 		ct = &t->w->body;
203 		if(t->w != ct->w)
204 			winlock(ct->w, 'M');
205 		if(t == ct)
206 			textsetselect(ct, e.q1, e.q1);
207 		n = e.q1 - e.q0;
208 		r = runemalloc(n);
209 		bufread(&t->file->b, e.q0, r, n);
210 		if(search(ct, r, n) && e.jump)
211 			moveto(mousectl, addpt(frptofchar(&ct->fr, ct->fr.p0), Pt(4, ct->fr.font->height-4)));
212 		if(t->w != ct->w)
213 			winunlock(ct->w);
214 		free(r);
215 	}
216 
217    Return:
218 	free(e.name);
219 	free(e.bname);
220 }
221 
222 int
223 plumbgetc(void *a, uint n)
224 {
225 	Rune *r;
226 
227 	r = a;
228 	if(n>runestrlen(r))
229 		return 0;
230 	return r[n];
231 }
232 
233 void
234 plumblook(Plumbmsg *m)
235 {
236 	Expand e;
237 	char *addr;
238 
239 	if(m->ndata >= BUFSIZE){
240 		warning(nil, "insanely long file name (%d bytes) in plumb message (%.32s...)\n", m->ndata, m->data);
241 		return;
242 	}
243 	e.q0 = 0;
244 	e.q1 = 0;
245 	if(m->data[0] == '\0')
246 		return;
247 	e.u.ar = nil;
248 	e.bname = m->data;
249 	e.name = bytetorune(e.bname, &e.nname);
250 	e.jump = TRUE;
251 	e.a0 = 0;
252 	e.a1 = 0;
253 	addr = plumblookup(m->attr, "addr");
254 	if(addr != nil){
255 		e.u.ar = bytetorune(addr, &e.a1);
256 		e.agetc = plumbgetc;
257 	}
258 	openfile(nil, &e);
259 	free(e.name);
260 	free(e.u.at);
261 	drawtopwindow();
262 }
263 
264 void
265 plumbshow(Plumbmsg *m)
266 {
267 	Window *w;
268 	Rune rb[256], *r;
269 	int nb, nr;
270 	Runestr rs;
271 	char *name, *p, namebuf[16];
272 
273 	w = makenewwindow(nil);
274 	name = plumblookup(m->attr, "filename");
275 	if(name == nil){
276 		name = namebuf;
277 		nuntitled++;
278 		snprint(namebuf, sizeof namebuf, "Untitled-%d", nuntitled);
279 	}
280 	p = nil;
281 	if(name[0]!='/' && m->wdir!=nil && m->wdir[0]!='\0'){
282 		nb = strlen(m->wdir) + 1 + strlen(name) + 1;
283 		p = emalloc(nb);
284 		snprint(p, nb, "%s/%s", m->wdir, name);
285 		name = p;
286 	}
287 	cvttorunes(name, strlen(name), rb, &nb, &nr, nil);
288 	free(p);
289 	rs = cleanrname(runestr(rb, nr));
290 	winsetname(w, rs.r, rs.nr);
291 	r = runemalloc(m->ndata);
292 	cvttorunes(m->data, m->ndata, r, &nb, &nr, nil);
293 	textinsert(&w->body, 0, r, nr, TRUE);
294 	free(r);
295 	w->body.file->mod = FALSE;
296 	w->dirty = FALSE;
297 	winsettag(w);
298 	textscrdraw(&w->body);
299 	textsetselect(&w->tag, w->tag.file->b.nc, w->tag.file->b.nc);
300 	drawtopwindow();
301 }
302 
303 int
304 search(Text *ct, Rune *r, uint n)
305 {
306 	uint q, nb, maxn;
307 	int around;
308 	Rune *s, *b, *c;
309 
310 	if(n==0 || n>ct->file->b.nc)
311 		return FALSE;
312 	if(2*n > RBUFSIZE){
313 		warning(nil, "string too long\n");
314 		return FALSE;
315 	}
316 	maxn = max(2*n, RBUFSIZE);
317 	s = fbufalloc();
318 	b = s;
319 	nb = 0;
320 	b[nb] = 0;
321 	around = 0;
322 	q = ct->q1;
323 	for(;;){
324 		if(q >= ct->file->b.nc){
325 			q = 0;
326 			around = 1;
327 			nb = 0;
328 			b[nb] = 0;
329 		}
330 		if(nb > 0){
331 			c = runestrchr(b, r[0]);
332 			if(c == nil){
333 				q += nb;
334 				nb = 0;
335 				b[nb] = 0;
336 				if(around && q>=ct->q1)
337 					break;
338 				continue;
339 			}
340 			q += (c-b);
341 			nb -= (c-b);
342 			b = c;
343 		}
344 		/* reload if buffer covers neither string nor rest of file */
345 		if(nb<n && nb!=ct->file->b.nc-q){
346 			nb = ct->file->b.nc-q;
347 			if(nb >= maxn)
348 				nb = maxn-1;
349 			bufread(&ct->file->b, q, s, nb);
350 			b = s;
351 			b[nb] = '\0';
352 		}
353 		/* this runeeq is fishy but the null at b[nb] makes it safe */
354 		if(runeeq(b, n, r, n)==TRUE){
355 			if(ct->w){
356 				textshow(ct, q, q+n, 1);
357 				winsettag(ct->w);
358 			}else{
359 				ct->q0 = q;
360 				ct->q1 = q+n;
361 			}
362 			seltext = ct;
363 			fbuffree(s);
364 			return TRUE;
365 		}
366 		--nb;
367 		b++;
368 		q++;
369 		if(around && q>=ct->q1)
370 			break;
371 	}
372 	fbuffree(s);
373 	return FALSE;
374 }
375 
376 int
377 isfilec(Rune r)
378 {
379 	static Rune Lx[] = { '.', '-', '+', '/', ':', 0 };
380 	if(isalnum(r))
381 		return TRUE;
382 	if(runestrchr(Lx, r))
383 		return TRUE;
384 	return FALSE;
385 }
386 
387 /* Runestr wrapper for cleanname */
388 Runestr
389 cleanrname(Runestr rs)
390 {
391 	char *s;
392 	int nb, nulls;
393 
394 	s = runetobyte(rs.r, rs.nr);
395 	cleanname(s);
396 	cvttorunes(s, strlen(s), rs.r, &nb, &rs.nr, &nulls);
397 	free(s);
398 	return rs;
399 }
400 
401 Runestr
402 includefile(Rune *dir, Rune *file, int nfile)
403 {
404 	int m, n;
405 	char *a;
406 	Rune *r;
407 	static Rune Lslash[] = { '/', 0 };
408 
409 	m = runestrlen(dir);
410 	a = emalloc((m+1+nfile)*UTFmax+1);
411 	sprint(a, "%S/%.*S", dir, nfile, file);
412 	n = access(a, 0);
413 	free(a);
414 	if(n < 0)
415 		return runestr(nil, 0);
416 	r = runemalloc(m+1+nfile);
417 	runemove(r, dir, m);
418 	runemove(r+m, Lslash, 1);
419 	runemove(r+m+1, file, nfile);
420 	free(file);
421 	return cleanrname(runestr(r, m+1+nfile));
422 }
423 
424 static	Rune	*objdir;
425 
426 Runestr
427 includename(Text *t, Rune *r, int n)
428 {
429 	Window *w;
430 	char buf[128];
431 	Rune Lsysinclude[] = { '/', 's', 'y', 's', '/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
432 	Rune Lusrinclude[] = { '/', 'u', 's', 'r', '/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
433 	Rune Lusrlocalinclude[] = { '/', 'u', 's', 'r', '/', 'l', 'o', 'c', 'a', 'l', 
434 			'/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
435 	Rune Lusrlocalplan9include[] = { '/', 'u', 's', 'r', '/', 'l', 'o', 'c', 'a', 'l', 
436 			'/', 'p', 'l', 'a', 'n', '9', '/', 'i', 'n', 'c', 'l', 'u', 'd', 'e', 0 };
437 	Runestr file;
438 	int i;
439 
440 	if(objdir==nil && objtype!=nil){
441 		sprint(buf, "/%s/include", objtype);
442 		objdir = bytetorune(buf, &i);
443 		objdir = runerealloc(objdir, i+1);
444 		objdir[i] = '\0';	
445 	}
446 
447 	w = t->w;
448 	if(n==0 || r[0]=='/' || w==nil)
449 		goto Rescue;
450 	if(n>2 && r[0]=='.' && r[1]=='/')
451 		goto Rescue;
452 	file.r = nil;
453 	file.nr = 0;
454 	for(i=0; i<w->nincl && file.r==nil; i++)
455 		file = includefile(w->incl[i], r, n);
456 
457 	if(file.r == nil)
458 		file = includefile(Lsysinclude, r, n);
459 	if(file.r == nil)
460 		file = includefile(Lusrlocalplan9include, r, n);
461 	if(file.r == nil)
462 		file = includefile(Lusrlocalinclude, r, n);
463 	if(file.r == nil)
464 		file = includefile(Lusrinclude, r, n);
465 	if(file.r==nil && objdir!=nil)
466 		file = includefile(objdir, r, n);
467 	if(file.r == nil)
468 		goto Rescue;
469 	return file;
470 
471     Rescue:
472 	return runestr(r, n);
473 }
474 
475 Runestr
476 dirname(Text *t, Rune *r, int n)
477 {
478 	Rune *b, c;
479 	uint m, nt;
480 	int slash;
481 	Runestr tmp;
482 
483 	b = nil;
484 	if(t==nil || t->w==nil)
485 		goto Rescue;
486 	nt = t->w->tag.file->b.nc;
487 	if(nt == 0)
488 		goto Rescue;
489 	if(n>=1 && r[0]=='/')
490 		goto Rescue;
491 	b = runemalloc(nt+n+1);
492 	bufread(&t->w->tag.file->b, 0, b, nt);
493 	slash = -1;
494 	for(m=0; m<nt; m++){
495 		c = b[m];
496 		if(c == '/')
497 			slash = m;
498 		if(c==' ' || c=='\t')
499 			break;
500 	}
501 	if(slash < 0)
502 		goto Rescue;
503 	runemove(b+slash+1, r, n);
504 	free(r);
505 	return cleanrname(runestr(b, slash+1+n));
506 
507     Rescue:
508 	free(b);
509 	tmp = runestr(r, n);
510 	if(r)
511 		return cleanrname(tmp);
512 	return tmp;
513 }
514 
515 int
516 expandfile(Text *t, uint q0, uint q1, Expand *e)
517 {
518 	int i, n, nname, colon, eval;
519 	uint amin, amax;
520 	Rune *r, c;
521 	Window *w;
522 	Runestr rs;
523 
524 	amax = q1;
525 	if(q1 == q0){
526 		colon = -1;
527 		while(q1<t->file->b.nc && isfilec(c=textreadc(t, q1))){
528 			if(c == ':'){
529 				colon = q1;
530 				break;
531 			}
532 			q1++;
533 		}
534 		while(q0>0 && (isfilec(c=textreadc(t, q0-1)) || isaddrc(c) || isregexc(c))){
535 			q0--;
536 			if(colon<0 && c==':')
537 				colon = q0;
538 		}
539 		/*
540 		 * if it looks like it might begin file: , consume address chars after :
541 		 * otherwise terminate expansion at :
542 		 */
543 		if(colon >= 0){
544 			q1 = colon;
545 			if(colon<t->file->b.nc-1 && isaddrc(textreadc(t, colon+1))){
546 				q1 = colon+1;
547 				while(q1<t->file->b.nc && isaddrc(textreadc(t, q1)))
548 					q1++;
549 			}
550 		}
551 		if(q1 > q0)
552 			if(colon >= 0){	/* stop at white space */
553 				for(amax=colon+1; amax<t->file->b.nc; amax++)
554 					if((c=textreadc(t, amax))==' ' || c=='\t' || c=='\n')
555 						break;
556 			}else
557 				amax = t->file->b.nc;
558 	}
559 	amin = amax;
560 	e->q0 = q0;
561 	e->q1 = q1;
562 	n = q1-q0;
563 	if(n == 0)
564 		return FALSE;
565 	/* see if it's a file name */
566 	r = runemalloc(n);
567 	bufread(&t->file->b, q0, r, n);
568 	/* first, does it have bad chars? */
569 	nname = -1;
570 	for(i=0; i<n; i++){
571 		c = r[i];
572 		if(c==':' && nname<0){
573 			if(q0+i+1<t->file->b.nc && (i==n-1 || isaddrc(textreadc(t, q0+i+1))))
574 				amin = q0+i;
575 			else
576 				goto Isntfile;
577 			nname = i;
578 		}
579 	}
580 	if(nname == -1)
581 		nname = n;
582 	for(i=0; i<nname; i++)
583 		if(!isfilec(r[i]))
584 			goto Isntfile;
585 	/*
586 	 * See if it's a file name in <>, and turn that into an include
587 	 * file name if so.  Should probably do it for "" too, but that's not
588 	 * restrictive enough syntax and checking for a #include earlier on the
589 	 * line would be silly.
590 	 */
591 	if(q0>0 && textreadc(t, q0-1)=='<' && q1<t->file->b.nc && textreadc(t, q1)=='>'){
592 		rs = includename(t, r, nname);
593 		r = rs.r;
594 		nname = rs.nr;
595 	}
596 	else if(amin == q0)
597 		goto Isfile;
598 	else{
599 		rs = dirname(t, r, nname);
600 		r = rs.r;
601 		nname = rs.nr;
602 	}
603 	e->bname = runetobyte(r, nname);
604 	/* if it's already a window name, it's a file */
605 	w = lookfile(r, nname);
606 	if(w != nil)
607 		goto Isfile;
608 	/* if it's the name of a file, it's a file */
609 	if(ismtpt(e->bname) || access(e->bname, 0) < 0){
610 		free(e->bname);
611 		e->bname = nil;
612 		goto Isntfile;
613 	}
614 
615   Isfile:
616 	e->name = r;
617 	e->nname = nname;
618 	e->u.at = t;
619 	e->a0 = amin+1;
620 	eval = FALSE;
621 	address(TRUE, nil, range(-1,-1), range(0,0), t, e->a0, amax, tgetc, &eval, (uint*)&e->a1);
622 	return TRUE;
623 
624    Isntfile:
625 	free(r);
626 	return FALSE;
627 }
628 
629 int
630 expand(Text *t, uint q0, uint q1, Expand *e)
631 {
632 	memset(e, 0, sizeof *e);
633 	e->agetc = tgetc;
634 	/* if in selection, choose selection */
635 	e->jump = TRUE;
636 	if(q1==q0 && t->q1>t->q0 && t->q0<=q0 && q0<=t->q1){
637 		q0 = t->q0;
638 		q1 = t->q1;
639 		if(t->what == Tag)
640 			e->jump = FALSE;
641 	}
642 
643 	if(expandfile(t, q0, q1, e))
644 		return TRUE;
645 
646 	if(q0 == q1){
647 		while(q1<t->file->b.nc && isalnum(textreadc(t, q1)))
648 			q1++;
649 		while(q0>0 && isalnum(textreadc(t, q0-1)))
650 			q0--;
651 	}
652 	e->q0 = q0;
653 	e->q1 = q1;
654 	return q1 > q0;
655 }
656 
657 Window*
658 lookfile(Rune *s, int n)
659 {
660 	int i, j, k;
661 	Window *w;
662 	Column *c;
663 	Text *t;
664 
665 	/* avoid terminal slash on directories */
666 	if(n>1 && s[n-1] == '/')
667 		--n;
668 	for(j=0; j<row.ncol; j++){
669 		c = row.col[j];
670 		for(i=0; i<c->nw; i++){
671 			w = c->w[i];
672 			t = &w->body;
673 			k = t->file->nname;
674 			if(k>1 && t->file->name[k-1] == '/')
675 				k--;
676 			if(runeeq(t->file->name, k, s, n)){
677 				w = w->body.file->curtext->w;
678 				if(w->col != nil)	/* protect against race deleting w */
679 					return w;
680 			}
681 		}
682 	}
683 	return nil;
684 }
685 
686 Window*
687 lookid(int id, int dump)
688 {
689 	int i, j;
690 	Window *w;
691 	Column *c;
692 
693 	for(j=0; j<row.ncol; j++){
694 		c = row.col[j];
695 		for(i=0; i<c->nw; i++){
696 			w = c->w[i];
697 			if(dump && w->dumpid == id)
698 				return w;
699 			if(!dump && w->id == id)
700 				return w;
701 		}
702 	}
703 	return nil;
704 }
705 
706 
707 Window*
708 openfile(Text *t, Expand *e)
709 {
710 	Range r;
711 	Window *w, *ow;
712 	int eval, i, n;
713 	Rune *rp;
714 	Runestr rs;
715 	uint dummy;
716 
717 	r.q0 = 0;
718 	r.q1 = 0;
719 	if(e->nname == 0){
720 		w = t->w;
721 		if(w == nil)
722 			return nil;
723 	}else{
724 		w = lookfile(e->name, e->nname);
725 		if(w == nil && e->name[0] != '/'){
726 			/*
727 			 * Unrooted path in new window.
728 			 * This can happen if we type a pwd-relative path
729 			 * in the topmost tag or the column tags.  
730 			 * Most of the time plumber takes care of these,
731 			 * but plumber might not be running or might not
732 			 * be configured to accept plumbed directories.
733 			 * Make the name a full path, just like we would if
734 			 * opening via the plumber.
735 			 */
736 			n = utflen(wdir)+1+e->nname+1;
737 			rp = runemalloc(n);
738 			runesnprint(rp, n, "%s/%.*S", wdir, e->nname, e->name);
739 			rs = cleanrname(runestr(rp, n-1));
740 			free(e->name);
741 			e->name = rs.r;
742 			e->nname = rs.nr;
743 			w = lookfile(e->name, e->nname);
744 		}
745 	}
746 	if(w){
747 		t = &w->body;
748 		if(!t->col->safe && t->fr.maxlines==0) /* window is obscured by full-column window */
749 			colgrow(t->col, t->col->w[0], 1);
750 	}else{
751 		ow = nil;
752 		if(t)
753 			ow = t->w;
754 		w = makenewwindow(t);
755 		t = &w->body;
756 		winsetname(w, e->name, e->nname);
757 		if(textload(t, 0, e->bname, 1) >= 0)
758 			t->file->unread = FALSE;
759 		t->file->mod = FALSE;
760 		t->w->dirty = FALSE;
761 		winsettag(t->w);
762 		textsetselect(&t->w->tag, t->w->tag.file->b.nc, t->w->tag.file->b.nc);
763 		if(ow != nil){
764 			for(i=ow->nincl; --i>=0; ){
765 				n = runestrlen(ow->incl[i]);
766 				rp = runemalloc(n);
767 				runemove(rp, ow->incl[i], n);
768 				winaddincl(w, rp, n);
769 			}
770 			w->autoindent = ow->autoindent;
771 		}else
772 			w->autoindent = globalautoindent;
773 	}
774 	if(e->a1 == e->a0)
775 		eval = FALSE;
776 	else{
777 		eval = TRUE;
778 		r = address(TRUE, t, range(-1,-1), range(t->q0, t->q1), e->u.at, e->a0, e->a1, e->agetc, &eval, &dummy);
779 		if(eval == FALSE)
780 			e->jump = FALSE;	/* don't jump if invalid address */
781 	}
782 	if(eval == FALSE){
783 		r.q0 = t->q0;
784 		r.q1 = t->q1;
785 	}
786 	textshow(t, r.q0, r.q1, 1);
787 	winsettag(t->w);
788 	seltext = t;
789 	if(e->jump)
790 		moveto(mousectl, addpt(frptofchar(&t->fr, t->fr.p0), Pt(4, font->height-4)));
791 	return w;
792 }
793 
794 void
795 new(Text *et, Text *t, Text *argt, int flag1, int flag2, Rune *arg, int narg)
796 {
797 	int ndone;
798 	Rune *a, *f;
799 	int na, nf;
800 	Expand e;
801 	Runestr rs;
802 
803 	getarg(argt, FALSE, TRUE, &a, &na);
804 	if(a){
805 		new(et, t, nil, flag1, flag2, a, na);
806 		if(narg == 0)
807 			return;
808 	}
809 	/* loop condition: *arg is not a blank */
810 	for(ndone=0; ; ndone++){
811 		a = findbl(arg, narg, &na);
812 		if(a == arg){
813 			if(ndone==0 && et->col!=nil)
814 				winsettag(coladd(et->col, nil, nil, -1));
815 			break;
816 		}
817 		nf = narg-na;
818 		f = runemalloc(nf);
819 		runemove(f, arg, nf);
820 		rs = dirname(et, f, nf);
821 		memset(&e, 0, sizeof e);
822 		e.name = rs.r;
823 		e.nname = rs.nr;
824 		e.bname = runetobyte(rs.r, rs.nr);
825 		e.jump = TRUE;
826 		openfile(et, &e);
827 		free(e.name);
828 		free(e.bname);
829 		arg = skipbl(a, na, &narg);
830 	}
831 }