op public repos

Blob

Date:: Mon Oct 31 18:45:06 2005 UTC
Message:: More prep.
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 <plumb.h>
11 #include "dat.h"
12 #include "fns.h"
13 
14 int	winid;
15 
16 void
17 wininit(Window *w, Window *clone, Rectangle r)
18 {
19 	Rectangle r1, br;
20 	File *f;
21 	Reffont *rf;
22 	Rune *rp;
23 	int nc;
24 
25 	w->tag.w = w;
26 	w->taglines = 1;
27 	w->body.w = w;
28 	w->id = ++winid;
29 	incref(&w->ref);
30 	if(globalincref)
31 		incref(&w->ref);
32 	w->ctlfid = ~0;
33 	w->utflastqid = -1;
34 	r1 = r;
35 
36 	w->tagtop = r;
37 	w->tagtop.max.y = r.min.y + font->height;
38 
39 	r1.max.y = r1.min.y + w->taglines*font->height;
40 	incref(&reffont.ref);
41 	f = fileaddtext(nil, &w->tag);
42 	textinit(&w->tag, f, r1, &reffont, tagcols);
43 	w->tag.what = Tag;
44 	/* tag is a copy of the contents, not a tracked image */
45 	if(clone){
46 		textdelete(&w->tag, 0, w->tag.file->b.nc, TRUE);
47 		nc = clone->tag.file->b.nc;
48 		rp = runemalloc(nc);
49 		bufread(&clone->tag.file->b, 0, rp, nc);
50 		textinsert(&w->tag, 0, rp, nc, TRUE);
51 		free(rp);
52 		filereset(w->tag.file);
53 		textsetselect(&w->tag, nc, nc);
54 	}
55 //assert(w->body.w == w);
56 	r1 = r;
57 	r1.min.y += w->taglines*font->height + 1;
58 	if(r1.max.y < r1.min.y)
59 		r1.max.y = r1.min.y;
60 	f = nil;
61 	if(clone){
62 		f = clone->body.file;
63 		w->body.org = clone->body.org;
64 		w->isscratch = clone->isscratch;
65 		rf = rfget(FALSE, FALSE, FALSE, clone->body.reffont->f->name);
66 	}else
67 		rf = rfget(FALSE, FALSE, FALSE, nil);
68 //assert(w->body.w == w);
69 	f = fileaddtext(f, &w->body);
70 	w->body.what = Body;
71 	textinit(&w->body, f, r1, rf, textcols);
72 	r1.min.y -= 1;
73 	r1.max.y = r1.min.y+1;
74 	draw(screen, r1, tagcols[BORD], nil, ZP);
75 	textscrdraw(&w->body);
76 	w->r = r;
77 	br.min = w->tag.scrollr.min;
78 	br.max.x = br.min.x + Dx(button->r);
79 	br.max.y = br.min.y + Dy(button->r);
80 	draw(screen, br, button, nil, button->r.min);
81 	w->filemenu = TRUE;
82 	w->maxlines = w->body.fr.maxlines;
83 	w->autoindent = globalautoindent;
84 //assert(w->body.w == w);
85 	if(clone){
86 		w->dirty = clone->dirty;
87 		w->autoindent = clone->autoindent;
88 		textsetselect(&w->body, clone->body.q0, clone->body.q1);
89 		winsettag(w);
90 	}
91 }
92 
93 /*
94  * Compute number of tag lines required
95  * to display entire tag text.
96  */
97 int
98 wintaglines(Window *w, Rectangle r)
99 {
100 	int n;
101 	Rune rune;
102 
103 	if(!w->tagexpand)
104 		return 1;
105 	w->tag.fr.noredraw = 1;
106 	textresize(&w->tag, r, TRUE);
107 	w->tag.fr.noredraw = 0;
108 	if(w->tag.fr.nlines >= w->tag.fr.maxlines)
109 		return w->tag.fr.maxlines;
110 	n = w->tag.fr.nlines;
111 	bufread(&w->tag.file->b, w->tag.file->b.nc-1, &rune, 1);
112 	if(rune == '\n')
113 		n++;
114 	return n;
115 }
116 
117 int
118 winresize(Window *w, Rectangle r, int safe, int keepextra)
119 {
120 	int y;
121 	Image *b;
122 	Rectangle br, r1;
123 
124 	w->tagtop = r;
125 	w->tagtop.max.y = r.min.y+font->height;
126 
127 	r1 = r;
128 	r1.max.y = min(r.max.y, r1.min.y + w->taglines*font->height);
129 	y = r1.max.y;
130 	if(1 || !safe || !eqrect(w->tag.all, r1)){
131 		textresize(&w->tag, r1, TRUE);
132 		y = w->tag.fr.r.max.y;
133 		b = button;
134 		if(w->body.file->mod && !w->isdir && !w->isscratch)
135 			b = modbutton;
136 		br.min = w->tag.scrollr.min;
137 		br.max.x = br.min.x + Dx(b->r);
138 		br.max.y = br.min.y + Dy(b->r);
139 		draw(screen, br, b, nil, b->r.min);
140 	}
141 	
142 	r1 = r;
143 	r1.min.y = y;
144 	if(!safe || !eqrect(w->body.all, r1)){
145 		if(y+1+w->body.fr.font->height <= r.max.y){	/* room for one line */
146 			r1.min.y = y;
147 			r1.max.y = y+1;
148 			draw(screen, r1, tagcols[BORD], nil, ZP);
149 			y++;
150 			r1.min.y = min(y, r.max.y);
151 			r1.max.y = r.max.y;
152 		}else{
153 			r1.min.y = y;
154 			r1.max.y = y;
155 		}
156 		w->r = r;
157 		w->r.max.y = textresize(&w->body, r1, keepextra);
158 		textscrdraw(&w->body);
159 	}
160 	w->maxlines = min(w->body.fr.nlines, max(w->maxlines, w->body.fr.maxlines));
161 	return w->r.max.y;
162 }
163 
164 void
165 winlock1(Window *w, int owner)
166 {
167 	incref(&w->ref);
168 	qlock(&w->lk);
169 	w->owner = owner;
170 }
171 
172 void
173 winlock(Window *w, int owner)
174 {
175 	int i;
176 	File *f;
177 
178 	f = w->body.file;
179 	for(i=0; i<f->ntext; i++)
180 		winlock1(f->text[i]->w, owner);
181 }
182 
183 void
184 winunlock(Window *w)
185 {
186 	int i;
187 	File *f;
188 
189 	/*
190 	 * subtle: loop runs backwards to avoid tripping over
191 	 * winclose indirectly editing f->text and freeing f
192 	 * on the last iteration of the loop.
193 	 */
194 	f = w->body.file;
195 	for(i=f->ntext-1; i>=0; i--){
196 		w = f->text[i]->w;
197 		w->owner = 0;
198 		qunlock(&w->lk);
199 		winclose(w);
200 	}
201 }
202 
203 void
204 winmousebut(Window *w)
205 {
206 	moveto(mousectl, addpt(w->tag.scrollr.min, 
207 		divpt(Pt(Dx(w->tag.scrollr), font->height), 2)));
208 }
209 
210 void
211 windirfree(Window *w)
212 {
213 	int i;
214 	Dirlist *dl;
215 
216 	if(w->isdir){
217 		for(i=0; i<w->ndl; i++){
218 			dl = w->dlp[i];
219 			free(dl->r);
220 			free(dl);
221 		}
222 		free(w->dlp);
223 	}
224 	w->dlp = nil;
225 	w->ndl = 0;
226 }
227 
228 void
229 winclose(Window *w)
230 {
231 	int i;
232 
233 	if(decref(&w->ref) == 0){
234 		windirfree(w);
235 		textclose(&w->tag);
236 		textclose(&w->body);
237 		if(activewin == w)
238 			activewin = nil;
239 		for(i=0; i<w->nincl; i++)
240 			free(w->incl[i]);
241 		free(w->incl);
242 		free(w->events);
243 		free(w);
244 	}
245 }
246 
247 void
248 windelete(Window *w)
249 {
250 	Xfid *x;
251 
252 	x = w->eventx;
253 	if(x){
254 		w->nevents = 0;
255 		free(w->events);
256 		w->events = nil;
257 		w->eventx = nil;
258 		sendp(x->c, nil);	/* wake him up */
259 	}
260 }
261 
262 void
263 winundo(Window *w, int isundo)
264 {
265 	Text *body;
266 	int i;
267 	File *f;
268 	Window *v;
269 
270 	w->utflastqid = -1;
271 	body = &w->body;
272 	fileundo(body->file, isundo, &body->q0, &body->q1);
273 	textshow(body, body->q0, body->q1, 1);
274 	f = body->file;
275 	for(i=0; i<f->ntext; i++){
276 		v = f->text[i]->w;
277 		v->dirty = (f->seq != v->putseq);
278 		if(v != w){
279 			v->body.q0 = v->body.fr.p0+v->body.org;
280 			v->body.q1 = v->body.fr.p1+v->body.org;
281 		}
282 	}
283 	winsettag(w);
284 }
285 
286 void
287 winsetname(Window *w, Rune *name, int n)
288 {
289 	Text *t;
290 	Window *v;
291 	int i;
292 	static Rune Lslashguide[] = { '/', 'g', 'u', 'i', 'd', 'e', 0 };
293 	static Rune Lpluserrors[] = { '+', 'E', 'r', 'r', 'o', 'r', 's', 0 };
294 	t = &w->body;
295 	if(runeeq(t->file->name, t->file->nname, name, n) == TRUE)
296 		return;
297 	w->isscratch = FALSE;
298 	if(n>=6 && runeeq(Lslashguide, 6, name+(n-6), 6))
299 		w->isscratch = TRUE;
300 	else if(n>=7 && runeeq(Lpluserrors, 7, name+(n-7), 7))
301 		w->isscratch = TRUE;
302 	filesetname(t->file, name, n);
303 	for(i=0; i<t->file->ntext; i++){
304 		v = t->file->text[i]->w;
305 		winsettag(v);
306 		v->isscratch = w->isscratch;
307 	}
308 }
309 
310 void
311 wintype(Window *w, Text *t, Rune r)
312 {
313 	int i;
314 
315 	texttype(t, r);
316 	if(t->what == Body)
317 		for(i=0; i<t->file->ntext; i++)
318 			textscrdraw(t->file->text[i]);
319 	winsettag(w);
320 }
321 
322 void
323 wincleartag(Window *w)
324 {
325 	int i, n;
326 	Rune *r;
327 
328 	/* w must be committed */
329 	n = w->tag.file->b.nc;
330 	r = runemalloc(n);
331 	bufread(&w->tag.file->b, 0, r, n);
332 	for(i=0; i<n; i++)
333 		if(r[i]==' ' || r[i]=='\t')
334 			break;
335 	for(; i<n; i++)
336 		if(r[i] == '|')
337 			break;
338 	if(i == n)
339 		return;
340 	i++;
341 	textdelete(&w->tag, i, n, TRUE);
342 	free(r);
343 	w->tag.file->mod = FALSE;
344 	if(w->tag.q0 > i)
345 		w->tag.q0 = i;
346 	if(w->tag.q1 > i)
347 		w->tag.q1 = i;
348 	textsetselect(&w->tag, w->tag.q0, w->tag.q1);
349 }
350 
351 void
352 winsettag1(Window *w)
353 {
354 	int bar, dirty, i, j, k, n, ntagname;
355 	Rune *new, *old, *r, *tagname;
356 	Image *b;
357 	uint q0, q1;
358 	Rectangle br;
359 	static Rune Ldelsnarf[] = { ' ', 'D', 'e', 'l', ' ',
360 		'S', 'n', 'a', 'r', 'f', 0 };
361 	static Rune Lundo[] = { ' ', 'U', 'n', 'd', 'o', 0 };
362 	static Rune Lredo[] = { ' ', 'R', 'e', 'd', 'o', 0 };
363 	static Rune Lget[] = { ' ', 'G', 'e', 't', 0 };
364 	static Rune Lput[] = { ' ', 'P', 'u', 't', 0 };
365 	static Rune Llook[] = { ' ', 'L', 'o', 'o', 'k', ' ', 0 };
366 	static Rune Lpipe[] = { ' ', '|', 0 };
367 	/* there are races that get us here with stuff in the tag cache, so we take extra care to sync it */
368 	if(w->tag.ncache!=0 || w->tag.file->mod)
369 		wincommit(w, &w->tag);	/* check file name; also guarantees we can modify tag contents */
370 	old = runemalloc(w->tag.file->b.nc+1);
371 	bufread(&w->tag.file->b, 0, old, w->tag.file->b.nc);
372 	old[w->tag.file->b.nc] = '\0';
373 	for(i=0; i<w->tag.file->b.nc; i++)
374 		if(old[i]==' ' || old[i]=='\t')
375 			break;
376 	
377 	/* make sure the file name is set correctly in the tag */
378 	ntagname = w->body.file->nname;
379 	tagname = runemalloc(ntagname);
380 	runemove(tagname, w->body.file->name, ntagname);
381 	abbrevenv(&tagname, (uint*)&ntagname);
382 
383 	/*
384 	 * XXX Why is this here instead of letting the code
385 	 * down below do the work?
386 	 */
387 	if(runeeq(old, i, tagname, ntagname) == FALSE){
388 		q0 = w->tag.q0;
389 		q1 = w->tag.q1;
390 		textdelete(&w->tag, 0, i, TRUE);
391 		textinsert(&w->tag, 0, tagname, ntagname, TRUE);
392 		free(old);
393 		old = runemalloc(w->tag.file->b.nc+1);
394 		bufread(&w->tag.file->b, 0, old, w->tag.file->b.nc);
395 		old[w->tag.file->b.nc] = '\0';
396 		if(q0 >= i){
397 			/*
398 			 * XXX common case - typing at end of name
399 			 */
400 			w->tag.q0 = q0+ntagname-i;
401 			w->tag.q1 = q1+ntagname-i;
402 		}
403 	}
404 	
405 	/* compute the text for the whole tag, replacing current only if it differs */
406 	new = runemalloc(ntagname+100);
407 	i = 0;
408 	runemove(new+i, tagname, ntagname);
409 	i += ntagname;
410 	runemove(new+i, Ldelsnarf, 10);
411 	i += 10;
412 	if(w->filemenu){
413 		if(w->body.file->delta.nc>0 || w->body.ncache){
414 			runemove(new+i, Lundo, 5);
415 			i += 5;
416 		}
417 		if(w->body.file->epsilon.nc > 0){
418 			runemove(new+i, Lredo, 5);
419 			i += 5;
420 		}
421 		dirty = w->body.file->nname && (w->body.ncache || w->body.file->seq!=w->putseq);
422 		if(!w->isdir && dirty){
423 			runemove(new+i, Lput, 4);
424 			i += 4;
425 		}
426 	}
427 	if(w->isdir){
428 		runemove(new+i, Lget, 4);
429 		i += 4;
430 	}
431 	runemove(new+i, Lpipe, 2);
432 	i += 2;
433 	r = runestrchr(old, '|');
434 	if(r)
435 		k = r-old+1;
436 	else{
437 		k = w->tag.file->b.nc;
438 		if(w->body.file->seq == 0){
439 			runemove(new+i, Llook, 6);
440 			i += 6;
441 		}
442 	}
443 	new[i] = 0;
444 	if(runestrlen(new) != i)
445 		fprint(2, "s '%S' len not %d\n", new, i);
446 	assert(i==runestrlen(new));
447 	
448 	/* replace tag if the new one is different */
449 	if(runeeq(new, i, old, k) == FALSE){
450 		n = k;
451 		if(n > i)
452 			n = i;
453 		for(j=0; j<n; j++)
454 			if(old[j] != new[j])
455 				break;
456 		q0 = w->tag.q0;
457 		q1 = w->tag.q1;
458 		textdelete(&w->tag, j, k, TRUE);
459 		textinsert(&w->tag, j, new+j, i-j, TRUE);
460 		/* try to preserve user selection */
461 		r = runestrchr(old, '|');
462 		if(r){
463 			bar = r-old;
464 			if(q0 > bar){
465 				bar = (runestrchr(new, '|')-new)-bar;
466 				w->tag.q0 = q0+bar;
467 				w->tag.q1 = q1+bar;
468 			}
469 		}
470 	}
471 	free(tagname);
472 	free(old);
473 	free(new);
474 	w->tag.file->mod = FALSE;
475 	n = w->tag.file->b.nc+w->tag.ncache;
476 	if(w->tag.q0 > n)
477 		w->tag.q0 = n;
478 	if(w->tag.q1 > n)
479 		w->tag.q1 = n;
480 	textsetselect(&w->tag, w->tag.q0, w->tag.q1);
481 	b = button;
482 	if(!w->isdir && !w->isscratch && (w->body.file->mod || w->body.ncache))
483 		b = modbutton;
484 	br.min = w->tag.scrollr.min;
485 	br.max.x = br.min.x + Dx(b->r);
486 	br.max.y = br.min.y + Dy(b->r);
487 	draw(screen, br, b, nil, b->r.min);
488 }
489 
490 void
491 winsettag(Window *w)
492 {
493 	int i;
494 	File *f;
495 	Window *v;
496 
497 	f = w->body.file;
498 	for(i=0; i<f->ntext; i++){
499 		v = f->text[i]->w;
500 		if(v->col->safe || v->body.fr.maxlines>0)
501 			winsettag1(v);
502 	}
503 }
504 
505 void
506 wincommit(Window *w, Text *t)
507 {
508 	Rune *r;
509 	int i;
510 	File *f;
511 
512 	textcommit(t, TRUE);
513 	f = t->file;
514 	if(f->ntext > 1)
515 		for(i=0; i<f->ntext; i++)
516 			textcommit(f->text[i], FALSE);	/* no-op for t */
517 	if(t->what == Body)
518 		return;
519 	r = runemalloc(w->tag.file->b.nc);
520 	bufread(&w->tag.file->b, 0, r, w->tag.file->b.nc);
521 	for(i=0; i<w->tag.file->b.nc; i++)
522 		if(r[i]==' ' || r[i]=='\t')
523 			break;
524 	expandenv(&r, (uint*)&i);
525 	if(runeeq(r, i, w->body.file->name, w->body.file->nname) == FALSE){
526 		seq++;
527 		filemark(w->body.file);
528 		w->body.file->mod = TRUE;
529 		w->dirty = TRUE;
530 		winsetname(w, r, i);
531 		winsettag(w);
532 	}
533 	free(r);
534 }
535 
536 void
537 winaddincl(Window *w, Rune *r, int n)
538 {
539 	char *a;
540 	Dir *d;
541 	Runestr rs;
542 
543 	a = runetobyte(r, n);
544 	d = dirstat(a);
545 	if(d == nil){
546 		if(a[0] == '/')
547 			goto Rescue;
548 		rs = dirname(&w->body, r, n);
549 		r = rs.r;
550 		n = rs.nr;
551 		free(a);
552 		a = runetobyte(r, n);
553 		d = dirstat(a);
554 		if(d == nil)
555 			goto Rescue;
556 		r = runerealloc(r, n+1);
557 		r[n] = 0;
558 	}
559 	free(a);
560 	if((d->qid.type&QTDIR) == 0){
561 		free(d);
562 		warning(nil, "%s: not a directory\n", a);
563 		free(r);
564 		return;
565 	}
566 	free(d);
567 	w->nincl++;
568 	w->incl = realloc(w->incl, w->nincl*sizeof(Rune*));
569 	memmove(w->incl+1, w->incl, (w->nincl-1)*sizeof(Rune*));
570 	w->incl[0] = runemalloc(n+1);
571 	runemove(w->incl[0], r, n);
572 	free(r);
573 	return;
574 
575 Rescue:
576 	warning(nil, "%s: %r\n", a);
577 	free(r);
578 	free(a);
579 	return;
580 }
581 
582 int
583 winclean(Window *w, int conservative)	/* as it stands, conservative is always TRUE */
584 {
585 	if(w->isscratch || w->isdir)	/* don't whine if it's a guide file, error window, etc. */
586 		return TRUE;
587 	if(!conservative && w->nopen[QWevent]>0)
588 		return TRUE;
589 	if(w->dirty){
590 		if(w->body.file->nname)
591 			warning(nil, "%.*S modified\n", w->body.file->nname, w->body.file->name);
592 		else{
593 			if(w->body.file->b.nc < 100)	/* don't whine if it's too small */
594 				return TRUE;
595 			warning(nil, "unnamed file modified\n");
596 		}
597 		w->dirty = FALSE;
598 		return FALSE;
599 	}
600 	return TRUE;
601 }
602 
603 char*
604 winctlprint(Window *w, char *buf, int fonts)
605 {
606 	sprint(buf, "%11d %11d %11d %11d %11d ", w->id, w->tag.file->b.nc,
607 		w->body.file->b.nc, w->isdir, w->dirty);
608 	if(fonts)
609 		return smprint("%s%11d %q %11d ", buf, Dx(w->body.fr.r), 
610 			w->body.reffont->f->name, w->body.fr.maxtab);
611 	return buf;
612 }
613 
614 void
615 winevent(Window *w, char *fmt, ...)
616 {
617 	int n;
618 	char *b;
619 	Xfid *x;
620 	va_list arg;
621 
622 	if(w->nopen[QWevent] == 0)
623 		return;
624 	if(w->owner == 0)
625 		error("no window owner");
626 	va_start(arg, fmt);
627 	b = vsmprint(fmt, arg);
628 	va_end(arg);
629 	if(b == nil)
630 		error("vsmprint failed");
631 	n = strlen(b);
632 	w->events = realloc(w->events, w->nevents+1+n);
633 	w->events[w->nevents++] = w->owner;
634 	memmove(w->events+w->nevents, b, n);
635 	free(b);
636 	w->nevents += n;
637 	x = w->eventx;
638 	if(x){
639 		w->eventx = nil;
640 		sendp(x->c, nil);
641 	}
642 }
643 
644 /*
645  * This is here as a first stab at something. 
646  * Run acme with the -'$' flag to enable it.
647  * 
648  * This code isn't quite right, in that it doesn't play well with 
649  * the plumber and with other applications.  For example:
650  *
651  * If the window tag is $home/bin and you execute script, then acme runs
652  * script in $home/bin, via the shell, so everything is fine.  If you do
653  * execute "echo $home", it too goes to the shell so you see the value
654  * of $home.  And if you right-click on script, then acme plumbs "script"
655  * in the directory "/home/you/bin", so that works, but if you right-click
656  * on "$home/bin/script", then what?  It's not correct to expand in acme
657  * since what you're plumbing might be a price tag for all we know.  So the
658  * plumber has to expand it, but in order to do that the plumber should
659  * probably publish (and allow users to change) the set of variables it is
660  * using in expansions.
661  * 
662  * Rob has suggested that a better solution is to make tag lines expand
663  * automatically to fit the necessary number of lines.
664  * 
665  * The best solution, of course, is to use nice short path names, but this
666  * is not always possible.
667  */
668 
669 int
670 expandenv(Rune **rp, uint *np)
671 {
672 	char *s, *t;
673 	Rune *p, *r, *q;
674 	uint n, pref;
675 	int nb, nr, slash;
676 	Runestr rs;
677 
678 	if(!dodollarsigns)
679 		return FALSE;
680 
681 	r = *rp;
682 	n = *np;
683 	if(n == 0 || r[0] != '$')
684 		return FALSE;
685 	for(p=r+1; *p && *p != '/'; p++)
686 		;
687 	pref = p-r;
688 	s = runetobyte(r+1, pref-1);
689 	if((t = getenv(s)) == nil){
690 		free(s);
691 		return FALSE;
692 	}
693 
694 	q = runemalloc(utflen(t)+(n-pref));
695 	cvttorunes(t, strlen(t), q, &nb, &nr, nil);
696 	assert(nr==utflen(t));
697 	runemove(q+nr, p, n-pref);
698 	free(r);
699 	rs = runestr(q, nr+(n-pref));
700 	slash = rs.nr>0 && q[rs.nr-1] == '/';
701 	rs = cleanrname(rs);
702 	if(slash){
703 		rs.r = runerealloc(rs.r, rs.nr+1);
704 		rs.r[rs.nr++] = '/';
705 	}
706 	*rp = rs.r;
707 	*np = rs.nr;
708 	free(t);
709 	return TRUE;
710 }
711 
712 extern char **environ;
713 Rune **runeenv;
714 
715 /*
716  * Weird sort order -- shorter names first, 
717  * prefer lowercase over uppercase ($home over $HOME),
718  * then do normal string comparison.
719  */
720 int
721 runeenvcmp(const void *va, const void *vb)
722 {
723 	Rune *a, *b;
724 	int na, nb;
725 
726 	a = *(Rune**)va;
727 	b = *(Rune**)vb;
728 	na = runestrchr(a, '=') - a;
729 	nb = runestrchr(b, '=') -  b;
730 	if(na < nb)
731 		return -1;
732 	if(nb > na)
733 		return 1;
734 	if(na == 0)
735 		return 0;
736 	if(islowerrune(a[0]) && !islowerrune(b[0]))
737 		return -1;
738 	if(islowerrune(b[0]) && !islowerrune(a[0]))
739 		return 1;
740 	return runestrncmp(a, b, na);
741 }
742 
743 void
744 mkruneenv(void)
745 {
746 	int i, bad, n, nr;
747 	char *p;
748 	Rune *r, *q;
749 
750 	n = 0;
751 	for(i=0; environ[i]; i++){
752 		/*
753 		 * Ignore some pollution.
754 		 */
755 		if(environ[i][0] == '_')
756 			continue;
757 		if(strncmp(environ[i], "PWD=", 4) == 0)
758 			continue;
759 		if(strncmp(environ[i], "OLDPWD=", 7) == 0)
760 			continue;
761 
762 		/*
763 		 * Must be a rooted path.
764 		 */
765 		if((p = strchr(environ[i], '=')) == nil || *(p+1) != '/')
766 			continue;
767 
768 		/*
769 		 * Only use the ones that we accept in look - all isfilec
770 		 */
771 		bad = 0;
772 		r = bytetorune(environ[i], &nr);
773 		for(q=r; *q != '='; q++)
774 			if(!isfilec(*q)){
775 				free(r);
776 				bad = 1;
777 				break;
778 			}
779 		if(!bad){
780 			runeenv = erealloc(runeenv, (n+1)*sizeof(runeenv[0]));
781 			runeenv[n++] = r;
782 		}
783 	}
784 	runeenv = erealloc(runeenv, (n+1)*sizeof(runeenv[0]));
785 	runeenv[n] = nil;
786 	qsort(runeenv, n, sizeof(runeenv[0]), runeenvcmp);
787 }
788 
789 int
790 abbrevenv(Rune **rp, uint *np)
791 {
792 	int i, len, alen;
793 	Rune *r, *p, *q;
794 	uint n;
795 
796 	if(!dodollarsigns)
797 		return FALSE;
798 
799 	r = *rp;
800 	n = *np;
801 	if(n == 0 || r[0] != '/')
802 		return FALSE;
803 
804 	if(runeenv == nil)
805 		mkruneenv();
806 
807 	for(i=0; runeenv[i]; i++){
808 		p = runestrchr(runeenv[i], '=')+1;
809 		len = runestrlen(p);
810 		if(len <= n && (r[len]==0 || r[len]=='/') && runeeq(r, len, p, len)==TRUE){
811 			alen = (p-1) - runeenv[i];
812 			q = runemalloc(1+alen+n-len);
813 			q[0] = '$';
814 			runemove(q+1, runeenv[i], alen);
815 			runemove(q+1+alen, r+len, n-len);
816 			free(r);
817 			*rp = q;
818 			*np = 1+alen+n-len;
819 			return TRUE;
820 		}
821 	}
822 	return FALSE;
823 }
824