op public repos

Blob

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