mothra: fix alt display resizing, filter control characters in panel entries, use...

[plan9front.git] / sys / src / cmd / hgfs / tree.c

diff --git a/sys/src/cmd/hgfs/tree.c b/sys/src/cmd/hgfs/tree.c
index 6e1d348314a2ad0cdb4d868862bd3975f60a1f9c..bb4fcb40c525044c73f867cea68c87748178d49f 100644 (file)
--- a/sys/src/cmd/hgfs/tree.c
+++ b/sys/src/cmd/hgfs/tree.c
@@ -5,7 +5,7 @@
 #include "fns.h"
 
 char*
-nodepath(char *s, char *e, Revnode *nd)
+nodepath(char *s, char *e, Revnode *nd, int mangle)
 {
        static char *frogs[] = {
                "con", "prn", "aux", "nul",
@@ -13,18 +13,21 @@ nodepath(char *s, char *e, Revnode *nd)
                "lpt1", "lpt2", "lpt3", "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9",
        };
        char *p;
-       int i;
+       int i, l;
 
        if(nd == nil || nd->name == nil)
                return s;
 
-       s = seprint(nodepath(s, e, nd->up), e, "/");
-
+       s = seprint(nodepath(s, e, nd->up, mangle), e, "/");
        p = nd->name;
-       for(i=0; i<nelem(frogs); i++)
-               if(strcmp(frogs[i], p) == 0)
-                       return seprint(s, e, "%.2s~%.2x%s", p, p[2], p+3);
+       if(!mangle)
+               return seprint(s, e, "%s", p);
 
+       for(i=0; i<nelem(frogs); i++){
+               l = strlen(frogs[i]);
+               if((strncmp(frogs[i], p, l) == 0) && (p[l] == 0 || p[l] == '.'))
+                       return seprint(s, e, "%.2s~%.2x%s", p, p[2], p+3);
+       }
        for(; s+4 < e && *p; p++){
                if(*p == '_'){
                        *s++ = '_';
@@ -43,10 +46,31 @@ nodepath(char *s, char *e, Revnode *nd)
        return s;
 }
 
+Revnode*
+mknode(char *name, uchar *hash, char mode)
+{
+       Revnode *d;
+       char *s;
+
+       d = malloc(sizeof(*d) + (hash ? HASHSZ : 0) + (name ? strlen(name)+1 : 0));
+       memset(d, 0, sizeof(*d));
+       s = (char*)&d[1];
+       if(hash){
+               d->path = hash2qid(hash);
+               memmove(d->hash = (uchar*)s, hash, HASHSZ);
+               s += HASHSZ;
+       }else
+               d->path = 1;
+       if(name)
+               strcpy(d->name = s, name);
+       d->mode = mode;
+       return d;
+}
+
 static void
 addnode(Revnode *d, char *path, uchar *hash, char mode)
 {
-       char *slash, *x;
+       char *slash;
        Revnode *c, *p;
 
        while(path && *path){
@@ -57,20 +81,8 @@ addnode(Revnode *d, char *path, uchar *hash, char mode)
                        if(strcmp(c->name, path) == 0)
                                break;
                if(c == nil){
-                       c = malloc(sizeof(*c) + (!slash ? HASHSZ : 0) + strlen(path)+1);
-                       c->path = 1;
-                       x = (char*)&c[1];
-                       if(!slash){
-                               c->mode = mode;
-                               memmove(c->hash = (uchar*)x, hash, HASHSZ);
-                               x += HASHSZ;
-                       }else{
-                               c->mode = 0;
-                               c->hash = nil;
-                       }
-                       strcpy(c->name = x, path);
+                       c = mknode(path, slash ? nil : hash, slash ? 0 : mode);
                        c->up = d;
-                       c->down = nil;
                        if(p){
                                c->next = p->next;
                                p->next = c;
@@ -78,11 +90,9 @@ addnode(Revnode *d, char *path, uchar *hash, char mode)
                                c->next = d->down;
                                d->down = c;
                        }
-
-                       if(c->hash){
+                       if(!slash){
                                p = c;
-                               p->path = *((uvlong*)c->hash);
-                               while(d->up){
+                               while(d){
                                        d->path += p->path;
                                        p = d;
                                        d = d->up;
@@ -133,7 +143,7 @@ loadmanifest(Revnode *root, int fd, Hashstr **ht, int nh)
 
                        x = buf;
                        x += strlen(x) + 1;
-                       strhash(x, hash);
+                       hex2hash(x, hash);
                        x += HASHSZ*2;
 
                        if(ht == nil)
@@ -170,21 +180,12 @@ loadtree(Revlog *manifest, Revinfo *ri, Hashstr **ht, int nh)
        t = malloc(sizeof(*t));
        memset(t, 0, sizeof(*t));
        incref(t);
-
-       t->root = malloc(sizeof(Revnode));
-       t->root->path = 0;
-       t->root->name = 0;
-       t->root->up = nil;
-       t->root->down = nil;
-       t->root->next = nil;
-       t->root->hash = nil;
-
+       t->root = mknode(nil, nil, 0);
        if(loadmanifest(t->root, fd, ht, nh) < 0){
                close(fd);
                closerevtree(t);
                return nil;
        }
-
        close(fd);
 
        return t;
@@ -201,41 +202,41 @@ loadchangestree(Revlog *changelog, Revlog *manifest, Revinfo *ri)
 {
        char buf[BUFSZ], *p, *e;
        Hashstr *ht[256], *he, **hp;
-       int fd, done, line, n;
+       int fd, n;
        Revtree *t;
+       vlong off;
 
        if((fd = revlogopentemp(changelog, hashrev(changelog, ri->chash))) < 0)
                return nil;
 
-       done = 0;
-       line = 0;
+       off = seek(fd, ri->logoff, 0);
+       if(off < 0){
+               close(fd);
+               return nil;
+       }
+
        memset(ht, 0, sizeof(ht));
 
        p = buf;
        e = buf + BUFSZ;
-       while((n = read(fd, p, e - p)) > 0){
+       while((off - ri->logoff) < ri->loglen){
+               if((n = read(fd, p, e - p)) <= 0)
+                       break;
                p += n;
                while((p > buf) && (e = memchr(buf, '\n', p - buf))){
                        *e++ = 0;
 
-                       if(++line >= 4){
-                               if(*buf == 0){
-                                       done = 1;
-                                       break;
-                               }
-
-                               he = malloc(sizeof(*he) + strlen(buf)+1);
-                               hp = &ht[hashstr(strcpy(he->str, buf)) % nelem(ht)];
-                               he->next = *hp;
-                               *hp = he;
-                       }
+                       he = malloc(sizeof(*he) + strlen(buf)+1);
+                       hp = &ht[hashstr(strcpy(he->str, buf)) % nelem(ht)];
+                       he->next = *hp;
+                       *hp = he;
 
-                       p -= e - buf;
+                       n = e - buf;
+                       p -= n;
                        if(p > buf)
                                memmove(buf, e, p - buf);
+                       off += n;
                }
-               if(done)
-                       break;
                e = buf + BUFSZ;
        }
        close(fd);
@@ -259,6 +260,7 @@ freenode(Revnode *nd)
                return;
        freenode(nd->down);
        freenode(nd->next);
+       freenode(nd->before);
        free(nd);
 }