commit - 7551b2ec8b48e74f002ae14882f2e4f191ea0076
commit + d96da29b373306ea72f99d61e524e7337112652c
blob - fe244e9bcc4985661a48878ff9ed012fef980fa1
blob + 408bd25bcbbdda394c96ea3bee4cda19dce4f06c
--- src/cmd/acme/acme.c
+++ src/cmd/acme/acme.c
loadfile = nil;
ARGBEGIN{
+ case '$':
+ dodollarsigns = TRUE;
+ break;
case 'D':
{extern int _threaddebuglevel;
_threaddebuglevel = ~0;
blob - 19229e7a44b3c7247610bb164ba44bf3e3d7bdf0
blob + 9b1f4f44290180883587567c06919dc641971511
--- src/cmd/acme/dat.h
+++ src/cmd/acme/dat.h
int erroutfd;
int messagesize; /* negotiated in 9P version setup */
int globalautoindent;
+int dodollarsigns;
enum
{
blob - 74a381e23937bfc46daa0b4b1a707dbc672099ff
blob + 23a522285789b846c84ad18001c0c08e13145c5e
--- src/cmd/acme/fns.h
+++ src/cmd/acme/fns.h
Runestr runestr(Rune*, uint);
Range range(int, int);
+int expandenv(Rune**, uint*);
+int abbrevenv(Rune**, uint*);
+
#define runemalloc(a) (Rune*)emalloc((a)*sizeof(Rune))
#define runerealloc(a, b) (Rune*)erealloc((a), (b)*sizeof(Rune))
#define runemove(a, b, c) memmove((a), (b), (c)*sizeof(Rune))
blob - 5b6171d73471d69c47fdab7fdd40e0103d674e24
blob + 336a65fe9d0bd5c6a2839189a728c9ece76ff313
--- src/cmd/acme/wind.c
+++ src/cmd/acme/wind.c
void
winsettag1(Window *w)
{
- int i, j, k, n, bar, dirty;
- Rune *new, *old, *r;
+ int bar, dirty, i, j, k, n, ntagname;
+ Rune *new, *old, *r, *tagname;
Image *b;
uint q0, q1;
Rectangle br;
for(i=0; i<w->tag.file->b.nc; i++)
if(old[i]==' ' || old[i]=='\t')
break;
- if(runeeq(old, i, w->body.file->name, w->body.file->nname) == FALSE){
+
+ /* make sure the file name is set correctly in the tag */
+ ntagname = w->body.file->nname;
+ tagname = runemalloc(ntagname);
+ runemove(tagname, w->body.file->name, ntagname);
+ abbrevenv(&tagname, &ntagname);
+
+ if(runeeq(old, i, tagname, ntagname) == FALSE){
textdelete(&w->tag, 0, i, TRUE);
- textinsert(&w->tag, 0, w->body.file->name, w->body.file->nname, TRUE);
+ textinsert(&w->tag, 0, tagname, ntagname, TRUE);
free(old);
old = runemalloc(w->tag.file->b.nc+1);
bufread(&w->tag.file->b, 0, old, w->tag.file->b.nc);
old[w->tag.file->b.nc] = '\0';
}
- new = runemalloc(w->body.file->nname+100);
+
+ /* compute the text for the whole tag, replacing current only if it differs */
+ new = runemalloc(ntagname+100);
i = 0;
- runemove(new+i, w->body.file->name, w->body.file->nname);
- i += w->body.file->nname;
+ runemove(new+i, tagname, ntagname);
+ i += ntagname;
runemove(new+i, Ldelsnarf, 10);
i += 10;
if(w->filemenu){
if(runestrlen(new) != i)
fprint(2, "s '%S' len not %d\n", new, i);
assert(i==runestrlen(new));
+
+ /* replace tag if the new one is different */
if(runeeq(new, i, old, k) == FALSE){
n = k;
if(n > i)
}
}
}
+ free(tagname);
free(old);
free(new);
w->tag.file->mod = FALSE;
for(i=0; i<w->tag.file->b.nc; i++)
if(r[i]==' ' || r[i]=='\t')
break;
+ expandenv(&r, &i);
if(runeeq(r, i, w->body.file->name, w->body.file->nname) == FALSE){
seq++;
filemark(w->body.file);
if(x){
w->eventx = nil;
sendp(x->c, nil);
+ }
+}
+
+/*
+ * This is here as a first stab at something.
+ * Run acme with the -'$' flag to enable it.
+ *
+ * This code isn't quite right, in that it doesn't play well with
+ * the plumber and with other applications. For example:
+ *
+ * If the window tag is $home/bin and you execute script, then acme runs
+ * script in $home/bin, via the shell, so everything is fine. If you do
+ * execute "echo $home", it too goes to the shell so you see the value
+ * of $home. And if you right-click on script, then acme plumbs "script"
+ * in the directory "/home/you/bin", so that works, but if you right-click
+ * on "$home/bin/script", then what? It's not correct to expand in acme
+ * since what you're plumbing might be a price tag for all we know. So the
+ * plumber has to expand it, but in order to do that the plumber should
+ * probably publish (and allow users to change) the set of variables it is
+ * using in expansions.
+ *
+ * Rob has suggested that a better solution is to make tag lines expand
+ * automatically to fit the necessary number of lines.
+ *
+ * The best solution, of course, is to use nice short path names, but this
+ * is not always possible.
+ */
+
+int
+expandenv(Rune **rp, uint *np)
+{
+ char *s, *t;
+ Rune *p, *r, *q;
+ uint n, pref;
+ int nb, nr, slash;
+ Runestr rs;
+
+ if(!dodollarsigns)
+ return FALSE;
+
+ r = *rp;
+ n = *np;
+ if(n == 0 || r[0] != '$')
+ return FALSE;
+ for(p=r+1; *p && *p != '/'; p++)
+ ;
+ pref = p-r;
+ s = runetobyte(r+1, pref-1);
+ if((t = getenv(s)) == nil){
+ free(s);
+ return FALSE;
}
+
+ q = runemalloc(utflen(t)+(n-pref));
+ cvttorunes(t, strlen(t), q, &nb, &nr, nil);
+ assert(nr==utflen(t));
+ runemove(q+nr, p, n-pref);
+ free(r);
+ rs = runestr(q, nr+(n-pref));
+ slash = rs.nr>0 && q[rs.nr-1] == '/';
+ rs = cleanrname(rs);
+ if(slash){
+ rs.r = runerealloc(rs.r, rs.nr+1);
+ rs.r[rs.nr++] = '/';
+ }
+ *rp = rs.r;
+ *np = rs.nr;
+ free(t);
+ return TRUE;
}
+
+extern char **environ;
+Rune **runeenv;
+
+/*
+ * Weird sort order -- shorter names first,
+ * prefer lowercase over uppercase ($home over $HOME),
+ * then do normal string comparison.
+ */
+int
+runeenvcmp(const void *va, const void *vb)
+{
+ Rune *a, *b;
+ int na, nb;
+
+ a = *(Rune**)va;
+ b = *(Rune**)vb;
+ na = runestrchr(a, '=') - a;
+ nb = runestrchr(b, '=') - b;
+ if(na < nb)
+ return -1;
+ if(nb > na)
+ return 1;
+ if(na == 0)
+ return 0;
+ if(islowerrune(a[0]) && !islowerrune(b[0]))
+ return -1;
+ if(islowerrune(b[0]) && !islowerrune(a[0]))
+ return 1;
+ return runestrncmp(a, b, na);
+}
+
+void
+mkruneenv(void)
+{
+ int i, bad, n, nr;
+ char *p;
+ Rune *r, *q;
+
+ n = 0;
+ for(i=0; environ[i]; i++){
+ /*
+ * Ignore some pollution.
+ */
+ if(environ[i][0] == '_')
+ continue;
+ if(strncmp(environ[i], "PWD=", 4) == 0)
+ continue;
+ if(strncmp(environ[i], "OLDPWD=", 7) == 0)
+ continue;
+
+ /*
+ * Must be a rooted path.
+ */
+ if((p = strchr(environ[i], '=')) == nil || *(p+1) != '/')
+ continue;
+
+ /*
+ * Only use the ones that we accept in look - all isfilec
+ */
+ bad = 0;
+ r = bytetorune(environ[i], &nr);
+ for(q=r; *q != '='; q++)
+ if(!isfilec(*q)){
+ free(r);
+ bad = 1;
+ break;
+ }
+ if(!bad){
+ runeenv = erealloc(runeenv, (n+1)*sizeof(runeenv[0]));
+ runeenv[n++] = r;
+ }
+ }
+ runeenv = erealloc(runeenv, (n+1)*sizeof(runeenv[0]));
+ runeenv[n] = nil;
+ qsort(runeenv, n, sizeof(runeenv[0]), runeenvcmp);
+}
+
+int
+abbrevenv(Rune **rp, uint *np)
+{
+ int i, len, alen;
+ Rune *r, *p, *q;
+ uint n;
+
+ if(!dodollarsigns)
+ return FALSE;
+
+ r = *rp;
+ n = *np;
+ if(n == 0 || r[0] != '/')
+ return FALSE;
+
+ if(runeenv == nil)
+ mkruneenv();
+
+ for(i=0; runeenv[i]; i++){
+ p = runestrchr(runeenv[i], '=')+1;
+ len = runestrlen(p);
+ if(len <= n && (r[len]==0 || r[len]=='/') && runeeq(r, len, p, len)==TRUE){
+ alen = (p-1) - runeenv[i];
+ q = runemalloc(1+alen+n-len);
+ q[0] = '$';
+ runemove(q+1, runeenv[i], alen);
+ runemove(q+1+alen, r+len, n-len);
+ free(r);
+ *rp = q;
+ *np = 1+alen+n-len;
+ return TRUE;
+ }
+ }
+ return FALSE;
+}
+
