sys/src/libdtracy/pack.c

   1 #include <u.h>
   2 #include <libc.h>
   3 #include <dtracy.h>
   4
   5 static void
   6 dtepack(Fmt *f, DTExpr *e)
   7 {
   8         int i;
   9
  10         fmtprint(f, "e%d\n", e->n);
  11         for(i = 0; i < e->n; i++)
  12                 fmtprint(f, "%#.8ux\n", e->b[i]);
  13 }
  14
  15 void
  16 dtgpack(Fmt *f, DTActGr *g)
  17 {
  18         int i;
  19
  20         fmtprint(f, "g%ud\n", g->id);
  21         if(g->pred != nil){
  22                 fmtprint(f, "p");
  23                 dtepack(f, g->pred);
  24         }
  25         fmtprint(f, "a%d\n", g->nact);
  26         for(i = 0; i < g->nact; i++){
  27                 fmtprint(f, "t%d\n", g->acts[i].type);
  28                 fmtprint(f, "s%d\n", g->acts[i].size);
  29                 dtepack(f, g->acts[i].p);
  30         }
  31         fmtprint(f, "G");
  32 }
  33
  34 void
  35 dtclpack(Fmt *f, DTClause *c)
  36 {
  37         int i;
  38
  39         fmtprint(f, "c%d\n", c->nprob);
  40         for(i = 0; i < c->nprob; i++)
  41                 fmtprint(f, "%s\n", c->probs[i]);
  42         dtgpack(f, c->gr);
  43 }
  44
  45 static char *
  46 u32unpack(char *s, u32int *np)
  47 {
  48         char *r;
  49
  50         *np = strtoul(s, &r, 0);
  51         if(r == s || *r != '\n') return nil;
  52         return r + 1;
  53 }
  54
  55 static char *
  56 dteunpack(char *s, DTExpr **rp)
  57 {
  58         int i;
  59         u32int n;
  60         DTExpr *e;
  61
  62         *rp = nil;
  63         if(*s++ != 'e') return nil;
  64         s = u32unpack(s, &n);
  65         if(s == nil) return nil;
  66         e = dtmalloc(sizeof(DTExpr) + n * sizeof(u32int));
  67         e->n = n;
  68         e->b = (void*)(e + 1);
  69         for(i = 0; i < n; i++){
  70                 s = u32unpack(s, &e->b[i]);
  71                 if(s == nil){
  72                         dtfree(e);
  73                         return nil;
  74                 }
  75         }
  76         *rp = e;
  77         return s;
  78 }
  79
  80 void
  81 dtgfree(DTActGr *g)
  82 {
  83         int i;
  84
  85         if(g == nil) return;
  86         for(i = 0; i < g->nact; i++)
  87                 dtfree(g->acts[i].p);
  88         dtfree(g->acts);
  89         dtfree(g->pred);
  90         dtfree(g);
  91
  92 }
  93
  94 char *
  95 dtgunpack(char *s, DTActGr **rp)
  96 {
  97         DTActGr *g;
  98         u32int n;
  99         int i;
 100
 101         *rp = nil;
 102         g = dtmalloc(sizeof(DTActGr));
 103         g->reclen = 12;
 104         g->ref = 1;
 105         if(*s++ != 'g') goto fail;
 106         s = u32unpack(s, &g->id);
 107         if(s == nil) goto fail;
 108         for(;;)
 109                 switch(*s++){
 110                 case 'p':
 111                         s = dteunpack(s, &g->pred);
 112                         if(s == nil) goto fail;
 113                         break;
 114                 case 'a':
 115                         s = u32unpack(s, &n);
 116                         if(s == nil) goto fail;
 117                         g->acts = dtmalloc(n * sizeof(DTAct));
 118                         g->nact = n;
 119                         for(i = 0; i < n; i++){
 120                                 if(*s++ != 't') goto fail;
 121                                 s = u32unpack(s, (u32int *) &g->acts[i].type);
 122                                 if(s == nil) goto fail;
 123                                 if(*s++ != 's') goto fail;
 124                                 s = u32unpack(s, (u32int *) &g->acts[i].size);
 125                                 if(s == nil) goto fail;
 126                                 s = dteunpack(s, &g->acts[i].p);
 127                                 if(s == nil) goto fail;
 128                                 switch(g->acts[i].type){
 129                                 case ACTTRACE:
 130                                         g->reclen += g->acts[i].size;
 131                                         break;
 132                                 case ACTTRACESTR:
 133                                         g->reclen += g->acts[i].size;
 134                                         break;
 135                                 default:
 136                                         goto fail;
 137                                 }
 138                         }
 139                         break;
 140                 case 'G':
 141                         *rp = g;
 142                         return s;
 143                 default: goto fail;
 144                 }
 145 fail:
 146         dtgfree(g);
 147         return nil;
 148 }
 149
 150 char *
 151 dtclunpack(char *s, DTClause **rp)
 152 {
 153         DTClause *c;
 154         char *e;
 155         int i;
 156
 157         *rp = nil;
 158         c = dtmalloc(sizeof(DTClause));
 159         if(*s++ != 'c') goto fail;
 160         s = u32unpack(s, (u32int*) &c->nprob);
 161         if(s == nil) goto fail;
 162         c->probs = dtmalloc(sizeof(char *) * c->nprob);
 163         for(i = 0; i < c->nprob; i++){
 164                 e = strchr(s, '\n');
 165                 if(e == nil) goto fail;
 166                 c->probs[i] = dtmalloc(e - s + 1);
 167                 memmove(c->probs[i], s, e - s);
 168                 s = e + 1;
 169         }
 170         s = dtgunpack(s, &c->gr);
 171         if(s == nil) goto fail;
 172         *rp = c;
 173         return s;
 174 fail:
 175         dtclfree(c);
 176         return nil;
 177 }
 178
 179 void
 180 dtclfree(DTClause *c)
 181 {
 182         int i;
 183
 184         if(c == nil) return;
 185         if(--c->gr->ref == 0)
 186                 dtgfree(c->gr);
 187         for(i = 0; i < c->nprob; i++)
 188                 free(c->probs[i]);
 189         free(c->probs);
 190         free(c);
 191 }