- add support for REL_FILECONFLICT
[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 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 = sat_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 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 = sat_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 rel2id(Pool *pool, Id name, Id evr, int flags, int create)
56 {
57   Hashval h;
58   unsigned int hh;
59   Hashmask hashmask;
60   int i;
61   Id id;
62   Hashtable hashtbl;
63   Reldep *ran;
64
65   hashmask = pool->relhashmask;
66   hashtbl = pool->relhashtbl;
67   ran = pool->rels;
68   
69   /* extend hashtable if needed */
70   if (pool->nrels * 2 > hashmask)
71     {
72       sat_free(pool->relhashtbl);
73       pool->relhashmask = hashmask = mkmask(pool->nrels + REL_BLOCK);
74       pool->relhashtbl = hashtbl = sat_calloc(hashmask + 1, sizeof(Id));
75       // rehash all rels into new hashtable
76       for (i = 1; i < pool->nrels; i++)
77         {
78           h = relhash(ran[i].name, ran[i].evr, ran[i].flags) & hashmask;
79           hh = HASHCHAIN_START;
80           while (hashtbl[h])
81             h = HASHCHAIN_NEXT(h, hh, hashmask);
82           hashtbl[h] = i;
83         }
84     }
85   
86   /* compute hash and check for match */
87   h = relhash(name, evr, flags) & hashmask;
88   hh = HASHCHAIN_START;
89   while ((id = hashtbl[h]) != 0)
90     {
91       if (ran[id].name == name && ran[id].evr == evr && ran[id].flags == flags)
92         break;
93       h = HASHCHAIN_NEXT(h, hh, hashmask);
94     }
95   if (id)
96     return MAKERELDEP(id);
97
98   if (!create)
99     return ID_NULL;
100
101   id = pool->nrels++;
102   /* extend rel space if needed */
103   pool->rels = sat_extend(pool->rels, id, 1, sizeof(Reldep), REL_BLOCK);
104   hashtbl[h] = id;
105   ran = pool->rels + id;
106   ran->name = name;
107   ran->evr = evr;
108   ran->flags = flags;
109
110   /* extend whatprovides_rel if needed */
111   if (pool->whatprovides_rel && (id & WHATPROVIDES_BLOCK) == 0)
112     {
113       pool->whatprovides_rel = sat_realloc2(pool->whatprovides_rel, id + (WHATPROVIDES_BLOCK + 1), sizeof(Offset));
114       memset(pool->whatprovides_rel + id, 0, (WHATPROVIDES_BLOCK + 1) * sizeof(Offset));
115     }
116   return MAKERELDEP(id);
117 }
118
119
120 // Id -> String
121 // for rels (returns name only) and strings
122 // 
123 const char *
124 id2str(Pool *pool, Id id)
125 {
126   if (ISRELDEP(id))
127     {
128       Reldep *rd = GETRELDEP(pool, id);
129       if (ISRELDEP(rd->name))
130         return "REL";
131       return pool->ss.stringspace + pool->ss.strings[rd->name];
132     }
133   return pool->ss.stringspace + pool->ss.strings[id];
134 }
135
136 static const char *rels[] = {
137   " ! ",
138   " > ",
139   " = ",
140   " >= ",
141   " < ",
142   " <> ",
143   " <= ",
144   " <=> "
145 };
146
147
148 // get operator for RelId
149 const char *
150 id2rel(Pool *pool, Id id)
151 {
152   Reldep *rd;
153   if (!ISRELDEP(id))
154     return "";
155   rd = GETRELDEP(pool, id);
156   switch (rd->flags)
157     {
158     case 0: case 1: case 2: case 3:
159     case 4: case 5: case 6: case 7:
160       return rels[rd->flags & 7];
161     case REL_AND:
162       return " & ";
163     case REL_OR:
164       return " | ";
165     case REL_WITH:
166       return " + ";
167     case REL_NAMESPACE:
168       return " NAMESPACE ";     /* actually not used in dep2str */
169     case REL_ARCH:
170       return ".";
171     case REL_FILECONFLICT:
172       return " FILECONFLICT ";
173     default:
174       break;
175     }
176   return " ??? ";
177 }
178
179
180 // get e:v.r for Id
181 // 
182 const char *
183 id2evr(Pool *pool, Id id)
184 {
185   Reldep *rd;
186   if (!ISRELDEP(id))
187     return "";
188   rd = GETRELDEP(pool, id);
189   if (ISRELDEP(rd->evr))
190     return "(REL)";
191   return pool->ss.stringspace + pool->ss.strings[rd->evr];
192 }
193
194 static int
195 dep2strlen(Pool *pool, Id id)
196 {
197   int l = 0;
198
199   while (ISRELDEP(id))
200     {
201       Reldep *rd = GETRELDEP(pool, id);
202       /* add 2 for parens */
203       l += 2 + dep2strlen(pool, rd->name) + strlen(id2rel(pool, id));
204       id = rd->evr;
205     }
206   return l + strlen(pool->ss.stringspace + pool->ss.strings[id]);
207 }
208
209 static void
210 dep2strcpy(Pool *pool, char *p, Id id, int oldrel)
211 {
212   while (ISRELDEP(id))
213     {
214       Reldep *rd = GETRELDEP(pool, id);
215       if (oldrel == REL_AND || oldrel == REL_OR || oldrel == REL_WITH)
216         if (rd->flags == REL_AND || rd->flags == REL_OR || rd->flags == REL_WITH)
217           if (oldrel != rd->flags)
218             {
219               *p++ = '(';
220               dep2strcpy(pool, p, rd->name, rd->flags);
221               p += strlen(p);
222               strcpy(p, id2rel(pool, id));
223               p += strlen(p);
224               dep2strcpy(pool, p, rd->evr, rd->flags);
225               strcat(p, ")");
226               return;
227             }
228       dep2strcpy(pool, p, rd->name, rd->flags);
229       p += strlen(p);
230       if (rd->flags == REL_NAMESPACE)
231         {
232           *p++ = '(';
233           dep2strcpy(pool, p, rd->evr, rd->flags);
234           strcat(p, ")");
235           return;
236         }
237       if (rd->flags == REL_FILECONFLICT)
238         {
239           *p = 0;
240           return;
241         }
242       strcpy(p, id2rel(pool, id));
243       p += strlen(p);
244       id = rd->evr;
245       oldrel = rd->flags;
246     }
247   strcpy(p, pool->ss.stringspace + pool->ss.strings[id]);
248 }
249
250 const char *
251 dep2str(Pool *pool, Id id)
252 {
253   char *p;
254   if (!ISRELDEP(id))
255     return pool->ss.stringspace + pool->ss.strings[id];
256   p = pool_alloctmpspace(pool, dep2strlen(pool, id) + 1);
257   dep2strcpy(pool, p, id, 0);
258   return p;
259 }
260
261 void
262 pool_shrink_strings(Pool *pool)
263 {
264   stringpool_shrink(&pool->ss);
265 }
266
267 void
268 pool_shrink_rels(Pool *pool)
269 {
270   pool->rels = sat_extend_resize(pool->rels, pool->nrels, sizeof(Reldep), REL_BLOCK);
271 }
272
273 // reset all hash tables
274 // 
275 void
276 pool_freeidhashes(Pool *pool)
277 {
278   pool->ss.stringhashtbl = sat_free(pool->ss.stringhashtbl);
279   pool->ss.stringhashmask = 0;
280   pool->relhashtbl = sat_free(pool->relhashtbl);
281   pool->relhashmask = 0;
282 }
283
284 // EOF