op public repos

Blob

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