Use Offset instead of unsigned int.
[platform/upstream/libsolv.git] / 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