src/poolid.c

   1 /*
   2  * poolid.c
   3  *
   4  * Id management
   5  */
   6
   7 #include <stdlib.h>
   8 #include <string.h>
   9 #include <stdio.h>
  10
  11 #include "pool.h"
  12 #include "poolid.h"
  13 #include "poolid_private.h"
  14 #include "util.h"
  15
  16
  17 // intern string into pool
  18 // return Id
  19
  20 Id
  21 str2id(Pool *pool, const char *str, int create)
  22 {
  23   Hashval h;
  24   unsigned int hh;
  25   Hashmask hashmask;
  26   int i, space_needed;
  27   Id id;
  28   Hashtable hashtbl;
  29
  30   // check string
  31   if (!str)
  32     return ID_NULL;
  33   if (!*str)
  34     return ID_EMPTY;
  35
  36   hashmask = pool->stringhashmask;
  37   hashtbl = pool->stringhashtbl;
  38
  39   // expand hashtable if needed
  40   //
  41   //
  42   if (pool->nstrings * 2 > hashmask)
  43     {
  44       xfree(hashtbl);
  45
  46       // realloc hash table
  47       pool->stringhashmask = hashmask = mkmask(pool->nstrings + STRING_BLOCK);
  48       pool->stringhashtbl = hashtbl = (Hashtable)xcalloc(hashmask + 1, sizeof(Id));
  49
  50       // rehash all strings into new hashtable
  51       for (i = 1; i < pool->nstrings; i++)
  52         {
  53           h = strhash(pool->stringspace + pool->strings[i]) & hashmask;
  54           hh = HASHCHAIN_START;
  55           while (hashtbl[h] != ID_NULL)  // follow overflow chain
  56             h = HASHCHAIN_NEXT(h, hh, hashmask);
  57           hashtbl[h] = i;
  58         }
  59     }
  60
  61   // compute hash and check for match
  62
  63   h = strhash(str) & hashmask;
  64   hh = HASHCHAIN_START;
  65   while ((id = hashtbl[h]) != ID_NULL)  // follow hash overflow chain
  66     {
  67       // break if string already hashed
  68       if(!strcmp(pool->stringspace + pool->strings[id], str))
  69         break;
  70       h = HASHCHAIN_NEXT(h, hh, hashmask);
  71     }
  72   if (id || !create)    // exit here if string found
  73     return id;
  74
  75   pool_freewhatprovides(pool);
  76
  77   // generate next id and save in table
  78   id = pool->nstrings++;
  79   hashtbl[h] = id;
  80
  81   //
  82   if ((id & STRING_BLOCK) == 0)
  83     pool->strings = xrealloc(pool->strings, ((pool->nstrings + STRING_BLOCK) & ~STRING_BLOCK) * sizeof(Hashval));
  84   // 'pointer' into stringspace is Offset of next free pos: sstrings
  85   pool->strings[id] = pool->sstrings;
  86
  87   space_needed = strlen(str) + 1;
  88
  89   // resize string buffer if needed
  90   if (((pool->sstrings + space_needed - 1) | STRINGSPACE_BLOCK) != ((pool->sstrings - 1) | STRINGSPACE_BLOCK))
  91     pool->stringspace = xrealloc(pool->stringspace, (pool->sstrings + space_needed + STRINGSPACE_BLOCK) & ~STRINGSPACE_BLOCK);
  92   // copy new string into buffer
  93   memcpy(pool->stringspace + pool->sstrings, str, space_needed);
  94   // next free pos is behind new string
  95   pool->sstrings += space_needed;
  96
  97   return id;
  98 }
  99
 100
 101 Id
 102 rel2id(Pool *pool, Id name, Id evr, int flags, int create)
 103 {
 104   Hashval h;
 105   unsigned int hh;
 106   Hashmask hashmask;
 107   int i;
 108   Id id;
 109   Hashtable hashtbl;
 110   Reldep *ran;
 111
 112   hashmask = pool->relhashmask;
 113   hashtbl = pool->relhashtbl;
 114   ran = pool->rels;
 115
 116   // extend hashtable if needed
 117   if (pool->nrels * 2 > hashmask)
 118     {
 119       xfree(pool->relhashtbl);
 120       pool->relhashmask = hashmask = mkmask(pool->nstrings + REL_BLOCK);
 121       pool->relhashtbl = hashtbl = xcalloc(hashmask + 1, sizeof(Id));
 122       // rehash all rels into new hashtable
 123       for (i = 1; i < pool->nrels; i++)
 124         {
 125           h = relhash(ran[i].name, ran[i].evr, ran[i].flags) & hashmask;
 126           hh = HASHCHAIN_START;
 127           while (hashtbl[h])
 128             h = HASHCHAIN_NEXT(h, hh, hashmask);
 129           hashtbl[h] = i;
 130         }
 131     }
 132
 133   // compute hash and check for match
 134
 135   h = relhash(name, evr, flags) & hashmask;
 136   hh = HASHCHAIN_START;
 137   while ((id = hashtbl[h]) != 0)
 138     {
 139       if (ran[id].name == name && ran[id].evr == evr && ran[id].flags == flags)
 140         break;
 141       h = HASHCHAIN_NEXT(h, hh, hashmask);
 142     }
 143   if (id)
 144     return MAKERELDEP(id);
 145
 146   if (!create)
 147     return ID_NULL;
 148
 149   pool_freewhatprovides(pool);
 150
 151   id = pool->nrels++;
 152   // extend rel space if needed
 153   if ((id & REL_BLOCK) == 0)
 154     pool->rels = xrealloc(pool->rels, ((pool->nrels + REL_BLOCK) & ~REL_BLOCK) * sizeof(Reldep));
 155   hashtbl[h] = id;
 156   ran = pool->rels + id;
 157   ran->name = name;
 158   ran->evr = evr;
 159   ran->flags = flags;
 160   return MAKERELDEP(id);
 161 }
 162
 163
 164 // Id -> String
 165 // for rels (returns name only) and strings
 166 //
 167 const char *
 168 id2str(Pool *pool, Id id)
 169 {
 170   if (ISRELDEP(id))
 171     {
 172       Reldep *rd = GETRELDEP(pool, id);
 173       if (ISRELDEP(rd->name))
 174         return "REL";
 175       return pool->stringspace + pool->strings[rd->name];
 176     }
 177   return pool->stringspace + pool->strings[id];
 178 }
 179
 180 static const char *rels[] = {
 181   " ! ",
 182   " > ",
 183   " = ",
 184   " >= ",
 185   " < ",
 186   " <> ",
 187   " <= ",
 188   " <=> "
 189 };
 190
 191
 192 // get operator for RelId
 193 const char *
 194 id2rel(Pool *pool, Id id)
 195 {
 196   Reldep *rd;
 197   if (!ISRELDEP(id))
 198     return "";
 199   rd = GETRELDEP(pool, id);
 200   switch (rd->flags)
 201     {
 202     case 0: case 1: case 2: case 3:
 203     case 4: case 5: case 6: case 7:
 204       return rels[rd->flags & 7];
 205     case REL_AND:
 206       return " AND ";
 207     case REL_OR:
 208       return " OR ";
 209     case REL_WITH:
 210       return " WITH ";
 211     case REL_NAMESPACE:
 212       return " NAMESPACE ";
 213     default:
 214       break;
 215     }
 216   return " ??? ";
 217 }
 218
 219
 220 // get e:v.r for Id
 221 //
 222 const char *
 223 id2evr(Pool *pool, Id id)
 224 {
 225   Reldep *rd;
 226   if (!ISRELDEP(id))
 227     return "";
 228   rd = GETRELDEP(pool, id);
 229   if (ISRELDEP(rd->evr))
 230     return "REL";
 231   return pool->stringspace + pool->strings[rd->evr];
 232 }
 233
 234 const char *
 235 dep2str(Pool *pool, Id id)
 236 {
 237   Reldep *rd;
 238   const char *sr;
 239   char *s1, *s2;
 240   int n, l, ls1, ls2, lsr;
 241
 242   if (!ISRELDEP(id))
 243     return pool->stringspace + pool->strings[id];
 244   rd = GETRELDEP(pool, id);
 245   n = pool->dep2strn;
 246
 247   sr = id2rel(pool, id);
 248   lsr = strlen(sr);
 249
 250   s2 = (char *)dep2str(pool, rd->evr);
 251   pool->dep2strn = n;
 252   ls2 = strlen(s2);
 253
 254   s1 = (char *)dep2str(pool, rd->name);
 255   pool->dep2strn = n;
 256   ls1 = strlen(s1);
 257
 258   if (rd->flags == REL_NAMESPACE)
 259     {
 260       sr = "(";
 261       lsr = 1;
 262       ls2++;
 263     }
 264
 265   l = ls1 + ls2 + lsr;
 266   if (l + 1 > pool->dep2strlen[n])
 267     {
 268       if (s1 != pool->dep2strbuf[n])
 269         pool->dep2strbuf[n] = xrealloc(pool->dep2strbuf[n], l + 32);
 270       else
 271         {
 272           pool->dep2strbuf[n] = xrealloc(pool->dep2strbuf[n], l + 32);
 273           s1 = pool->dep2strbuf[n];
 274         }
 275       pool->dep2strlen[n] = l + 32;
 276     }
 277   if (s1 != pool->dep2strbuf[n])
 278     {
 279       strcpy(pool->dep2strbuf[n], s1);
 280       s1 = pool->dep2strbuf[n];
 281     }
 282   strcpy(s1 + ls1, sr);
 283   pool->dep2strbuf[n] = s1 + ls1 + lsr;
 284   s2 = (char *)dep2str(pool, rd->evr);
 285   if (s2 != pool->dep2strbuf[n])
 286     strcpy(pool->dep2strbuf[n], s2);
 287   pool->dep2strbuf[n] = s1;
 288   if (rd->flags == REL_NAMESPACE)
 289     {
 290       s1[ls1 + ls2 + lsr - 1] = ')';
 291       s1[ls1 + ls2 + lsr] = 0;
 292     }
 293   pool->dep2strn = (n + 1) % DEP2STRBUF;
 294   return s1;
 295 }
 296
 297
 298 void
 299 pool_shrink_strings(Pool *pool)
 300 {
 301   pool->stringspace = (char *)xrealloc(pool->stringspace, (pool->sstrings + STRINGSPACE_BLOCK) & ~STRINGSPACE_BLOCK);
 302   pool->strings = (Offset *)xrealloc(pool->strings, ((pool->nstrings + STRING_BLOCK) & ~STRING_BLOCK) * sizeof(Offset));
 303 }
 304
 305 void
 306 pool_shrink_rels(Pool *pool)
 307 {
 308   pool->rels = (Reldep *)xrealloc(pool->rels, ((pool->nrels + REL_BLOCK) & ~REL_BLOCK) * sizeof(Reldep));
 309 }
 310
 311 // reset all hash tables
 312 //
 313 void
 314 pool_freeidhashes(Pool *pool)
 315 {
 316   pool->stringhashtbl = xfree(pool->stringhashtbl);
 317   pool->relhashtbl = xfree(pool->relhashtbl);
 318   pool->stringhashmask = 0;
 319   pool->relhashmask = 0;
 320 }
 321
 322 // EOF