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