Imported Upstream version 0.6.5
[platform/upstream/libsolv.git] / src / poolid.c
1 /*
2  * Copyright (c) 2007, Novell Inc.
3  *
4  * This program is licensed under the BSD license, read LICENSE.BSD
5  * for further information
6  */
7
8 /*
9  * poolid.c
10  *
11  * Id management
12  */
13
14 #include <stdlib.h>
15 #include <string.h>
16 #include <stdio.h>
17
18 #include "pool.h"
19 #include "poolid.h"
20 #include "poolid_private.h"
21 #include "util.h"
22
23
24 /* intern string into pool, return id */
25
26 Id
27 pool_str2id(Pool *pool, const char *str, int create)
28 {
29   int oldnstrings = pool->ss.nstrings;
30   Id id = stringpool_str2id(&pool->ss, str, create);
31   if (create && pool->whatprovides && oldnstrings != pool->ss.nstrings && (id & WHATPROVIDES_BLOCK) == 0)
32     {
33       /* grow whatprovides array */
34       pool->whatprovides = solv_realloc(pool->whatprovides, (id + (WHATPROVIDES_BLOCK + 1)) * sizeof(Offset));
35       memset(pool->whatprovides + id, 0, (WHATPROVIDES_BLOCK + 1) * sizeof(Offset));
36     }
37   return id;
38 }
39
40 Id
41 pool_strn2id(Pool *pool, const char *str, unsigned int len, int create)
42 {
43   int oldnstrings = pool->ss.nstrings;
44   Id id = stringpool_strn2id(&pool->ss, str, len, create);
45   if (create && pool->whatprovides && oldnstrings != pool->ss.nstrings && (id & WHATPROVIDES_BLOCK) == 0)
46     {
47       /* grow whatprovides array */
48       pool->whatprovides = solv_realloc(pool->whatprovides, (id + (WHATPROVIDES_BLOCK + 1)) * sizeof(Offset));
49       memset(pool->whatprovides + id, 0, (WHATPROVIDES_BLOCK + 1) * sizeof(Offset));
50     }
51   return id;
52 }
53
54 Id
55 pool_rel2id(Pool *pool, Id name, Id evr, int flags, int create)
56 {
57   Hashval h, hh, hashmask;
58   int i;
59   Id id;
60   Hashtable hashtbl;
61   Reldep *ran;
62
63   hashmask = pool->relhashmask;
64   hashtbl = pool->relhashtbl;
65   ran = pool->rels;
66
67   /* extend hashtable if needed */
68   if ((Hashval)pool->nrels * 2 > hashmask)
69     {
70       solv_free(pool->relhashtbl);
71       pool->relhashmask = hashmask = mkmask(pool->nrels + REL_BLOCK);
72       pool->relhashtbl = hashtbl = solv_calloc(hashmask + 1, sizeof(Id));
73       /* rehash all rels into new hashtable */
74       for (i = 1; i < pool->nrels; i++)
75         {
76           h = relhash(ran[i].name, ran[i].evr, ran[i].flags) & hashmask;
77           hh = HASHCHAIN_START;
78           while (hashtbl[h])
79             h = HASHCHAIN_NEXT(h, hh, hashmask);
80           hashtbl[h] = i;
81         }
82     }
83
84   /* compute hash and check for match */
85   h = relhash(name, evr, flags) & hashmask;
86   hh = HASHCHAIN_START;
87   while ((id = hashtbl[h]) != 0)
88     {
89       if (ran[id].name == name && ran[id].evr == evr && ran[id].flags == flags)
90         break;
91       h = HASHCHAIN_NEXT(h, hh, hashmask);
92     }
93   if (id)
94     return MAKERELDEP(id);
95
96   if (!create)
97     return ID_NULL;
98
99   id = pool->nrels++;
100   /* extend rel space if needed */
101   pool->rels = solv_extend(pool->rels, id, 1, sizeof(Reldep), REL_BLOCK);
102   hashtbl[h] = id;
103   ran = pool->rels + id;
104   ran->name = name;
105   ran->evr = evr;
106   ran->flags = flags;
107
108   /* extend whatprovides_rel if needed */
109   if (pool->whatprovides_rel && (id & WHATPROVIDES_BLOCK) == 0)
110     {
111       pool->whatprovides_rel = solv_realloc2(pool->whatprovides_rel, id + (WHATPROVIDES_BLOCK + 1), sizeof(Offset));
112       memset(pool->whatprovides_rel + id, 0, (WHATPROVIDES_BLOCK + 1) * sizeof(Offset));
113     }
114   return MAKERELDEP(id);
115 }
116
117
118 /* Id -> String
119  * for rels (returns name only) and strings
120  */
121 const char *
122 pool_id2str(const Pool *pool, Id id)
123 {
124   while (ISRELDEP(id))
125     {
126       Reldep *rd = GETRELDEP(pool, id);
127       id = rd->name;
128     }
129   return pool->ss.stringspace + pool->ss.strings[id];
130 }
131
132 static const char *rels[] = {
133   " ! ",
134   " > ",
135   " = ",
136   " >= ",
137   " < ",
138   " <> ",
139   " <= ",
140   " <=> "
141 };
142
143
144 /* get operator for RelId */
145 const char *
146 pool_id2rel(const Pool *pool, Id id)
147 {
148   Reldep *rd;
149   if (!ISRELDEP(id))
150     return "";
151   rd = GETRELDEP(pool, id);
152   switch (rd->flags)
153     {
154     /* debian special cases < and > */
155     /* haiku special cases <> (maybe we should use != for the others as well */
156     case 0: case REL_EQ: case REL_GT | REL_EQ:
157     case REL_LT | REL_EQ: case REL_LT | REL_EQ | REL_GT:
158 #if !defined(DEBIAN) && !defined(MULTI_SEMANTICS)
159     case REL_LT: case REL_GT:
160 #endif
161 #if !defined(HAIKU) && !defined(MULTI_SEMANTICS)
162     case REL_LT | REL_GT:
163 #endif
164       return rels[rd->flags];
165 #if defined(DEBIAN) || defined(MULTI_SEMANTICS)
166     case REL_GT:
167       return pool->disttype == DISTTYPE_DEB ? " >> " : rels[rd->flags];
168     case REL_LT:
169       return pool->disttype == DISTTYPE_DEB ? " << " : rels[rd->flags];
170 #endif
171 #if defined(HAIKU) || defined(MULTI_SEMANTICS)
172     case REL_LT | REL_GT:
173       return pool->disttype == DISTTYPE_HAIKU ? " != " : rels[rd->flags];
174 #endif
175     case REL_AND:
176       return " & ";
177     case REL_OR:
178       return " | ";
179     case REL_WITH:
180       return " + ";
181     case REL_NAMESPACE:
182       return " NAMESPACE ";     /* actually not used in dep2str */
183     case REL_ARCH:
184       return ".";
185     case REL_MULTIARCH:
186       return ":";
187     case REL_FILECONFLICT:
188       return " FILECONFLICT ";
189     case REL_COND:
190       return " IF ";
191     case REL_COMPAT:
192       return " compat >= ";
193     case REL_KIND:
194       return " KIND ";
195     default:
196       break;
197     }
198   return " ??? ";
199 }
200
201
202 /* get e:v.r for Id */
203 const char *
204 pool_id2evr(const Pool *pool, Id id)
205 {
206   Reldep *rd;
207   if (!ISRELDEP(id))
208     return "";
209   rd = GETRELDEP(pool, id);
210   if (ISRELDEP(rd->evr))
211     return "(REL)";
212   return pool->ss.stringspace + pool->ss.strings[rd->evr];
213 }
214
215 static int
216 dep2strlen(const Pool *pool, Id id)
217 {
218   int l = 0;
219
220   while (ISRELDEP(id))
221     {
222       Reldep *rd = GETRELDEP(pool, id);
223       /* add 2 for parens */
224       l += 2 + dep2strlen(pool, rd->name) + strlen(pool_id2rel(pool, id));
225       id = rd->evr;
226     }
227   return l + strlen(pool->ss.stringspace + pool->ss.strings[id]);
228 }
229
230 static void
231 dep2strcpy(const Pool *pool, char *p, Id id, int oldrel)
232 {
233   while (ISRELDEP(id))
234     {
235       Reldep *rd = GETRELDEP(pool, id);
236       if (oldrel == REL_AND || oldrel == REL_OR || oldrel == REL_WITH)
237         if (rd->flags == REL_AND || rd->flags == REL_OR || rd->flags == REL_WITH)
238           if (oldrel != rd->flags)
239             {
240               *p++ = '(';
241               dep2strcpy(pool, p, rd->name, rd->flags);
242               p += strlen(p);
243               strcpy(p, pool_id2rel(pool, id));
244               p += strlen(p);
245               dep2strcpy(pool, p, rd->evr, rd->flags);
246               strcat(p, ")");
247               return;
248             }
249       if (rd->flags == REL_KIND)
250         {
251           dep2strcpy(pool, p, rd->evr, rd->flags);
252           p += strlen(p);
253           *p++ = ':';
254           id = rd->name;
255           oldrel = rd->flags;
256           continue;
257         }
258       dep2strcpy(pool, p, rd->name, rd->flags);
259       p += strlen(p);
260       if (rd->flags == REL_NAMESPACE)
261         {
262           *p++ = '(';
263           dep2strcpy(pool, p, rd->evr, rd->flags);
264           strcat(p, ")");
265           return;
266         }
267       if (rd->flags == REL_FILECONFLICT)
268         {
269           *p = 0;
270           return;
271         }
272       strcpy(p, pool_id2rel(pool, id));
273       p += strlen(p);
274       id = rd->evr;
275       oldrel = rd->flags;
276     }
277   strcpy(p, pool->ss.stringspace + pool->ss.strings[id]);
278 }
279
280 const char *
281 pool_dep2str(Pool *pool, Id id)
282 {
283   char *p;
284   if (!ISRELDEP(id))
285     return pool->ss.stringspace + pool->ss.strings[id];
286   p = pool_alloctmpspace(pool, dep2strlen(pool, id) + 1);
287   dep2strcpy(pool, p, id, 0);
288   return p;
289 }
290
291 void
292 pool_shrink_strings(Pool *pool)
293 {
294   stringpool_shrink(&pool->ss);
295 }
296
297 void
298 pool_shrink_rels(Pool *pool)
299 {
300   pool->rels = solv_extend_resize(pool->rels, pool->nrels, sizeof(Reldep), REL_BLOCK);
301 }
302
303 /* free all hash tables */
304 void
305 pool_freeidhashes(Pool *pool)
306 {
307   stringpool_freehash(&pool->ss);
308   pool->relhashtbl = solv_free(pool->relhashtbl);
309   pool->relhashmask = 0;
310 }
311
312 /* EOF */