libdebian-installer
Data Structures | Typedefs | Functions | Variables
Di_packages

Data Structures

struct  di_packages
 Packages file. More...
 
struct  di_packages_allocator
 Packages file - Allocator. More...
 
struct  di_packages_resolve_dependencies_check
 
struct  di_packages_resolve_dependencies_do_real_list_append_data
 

Typedefs

typedef bool di_packages_resolve_dependencies_check_package(di_packages_resolve_dependencies_check *r, di_package *package, di_package_dependency *d)
 
typedef di_package_dependencydi_packages_resolve_dependencies_check_provide(di_package *package, di_package_dependency *best, di_package_dependency *d, void *data)
 
typedef void di_packages_resolve_dependencies_do_package(di_package *package, void *data)
 

Functions

di_packagesdi_packages_alloc (void)
 
void di_packages_free (di_packages *packages)
 
di_packages_allocatordi_packages_allocator_alloc (void)
 
void di_packages_allocator_free (di_packages_allocator *packages)
 
void di_packages_append_package (di_packages *packages, di_package *package, di_packages_allocator *allocator)
 
di_packagedi_packages_get_package (di_packages *packages, const char *name, size_t n)
 
di_packagedi_packages_get_package_new (di_packages *packages, di_packages_allocator *allocator, char *name, size_t n)
 
di_slistdi_packages_resolve_dependencies (di_packages *packages, di_slist *list, di_packages_allocator *allocator)
 
di_slistdi_packages_resolve_dependencies_array (di_packages *packages, di_package **array, di_packages_allocator *allocator)
 
void di_packages_resolve_dependencies_mark (di_packages *packages)
 
di_packages_allocatorinternal_di_packages_allocator_alloc (void)
 
di_slistdi_packages_resolve_dependencies_special (di_packages *packages, di_slist *list, di_packages_resolve_dependencies_check *s, di_packages_allocator *allocator)
 
di_slistdi_packages_resolve_dependencies_array_special (di_packages *packages, di_package **array, di_packages_resolve_dependencies_check *s, di_packages_allocator *allocator)
 
void di_packages_resolve_dependencies_mark_special (di_packages *packages, di_packages_resolve_dependencies_check *s)
 
void di_packages_resolve_dependencies_marker (di_packages *packages)
 
bool di_packages_resolve_dependencies_recurse (di_packages_resolve_dependencies_check *r, di_package *package, di_package *dependend_package)
 

Variables

di_packages_resolve_dependencies_check_package di_packages_resolve_dependencies_check_real
 
di_packages_resolve_dependencies_check_package di_packages_resolve_dependencies_check_non_existant
 
di_packages_resolve_dependencies_check_package di_packages_resolve_dependencies_check_non_existant_quiet
 
di_packages_resolve_dependencies_check_package di_packages_resolve_dependencies_check_non_existant_permissive
 
di_packages_resolve_dependencies_check_provide di_packages_resolve_dependencies_check_virtual
 
di_packages_resolve_dependencies_do_package di_packages_resolve_dependencies_do_real_list_append
 
di_packages_resolve_dependencies_do_package di_packages_resolve_dependencies_do_real_mark
 

Detailed Description

Function Documentation

◆ di_packages_alloc()

di_packages * di_packages_alloc ( void  )

Allocate di_packages

36{
37 di_packages *ret;
38
39 ret = di_new0 (di_packages, 1);
40 ret->table = di_hash_table_new_full (di_rstring_hash, di_rstring_equal, NULL, internal_di_package_destroy_func);
41
42 return ret;
43}
di_hash_table * di_hash_table_new_full(di_hash_func hash_func, di_equal_func key_equal_func, di_destroy_notify key_destroy_func, di_destroy_notify value_destroy_func)
Definition: hash.c:113
#define di_new0(struct_type, n_structs)
Definition: mem.h:79
di_destroy_notify internal_di_package_destroy_func
Definition: package_internal.h:80
Packages file.
Definition: packages.h:42
di_hash_table * table
Definition: packages.h:43

References di_hash_table_new_full(), di_new0, and table.

◆ di_packages_allocator_alloc()

di_packages_allocator * di_packages_allocator_alloc ( void  )

Allocate di_packages_allocator

49{
51
53 ret->package_mem_chunk = di_mem_chunk_new (sizeof (di_package), 16384);
54
55 return ret;
56}
di_mem_chunk * di_mem_chunk_new(di_ksize_t atom_size, di_ksize_t area_size)
Definition: mem_chunk.c:87
di_packages_allocator * internal_di_packages_allocator_alloc(void)
Definition: packages.c:62
Package.
Definition: package.h:96
Packages file - Allocator.
Definition: packages.h:53
di_mem_chunk * package_mem_chunk
Definition: packages.h:54

References di_mem_chunk_new(), internal_di_packages_allocator_alloc(), and di_packages_allocator::package_mem_chunk.

◆ di_packages_allocator_free()

void di_packages_allocator_free ( di_packages_allocator allocator)

Free di_packages_allocator

88{
89 di_mem_chunk_destroy (allocator->package_mem_chunk);
90 di_mem_chunk_destroy (allocator->package_dependency_mem_chunk);
91 di_mem_chunk_destroy (allocator->slist_node_mem_chunk);
92 di_free (allocator);
93}
void di_free(void *mem)
Definition: mem.c:60
di_mem_chunk * slist_node_mem_chunk
Definition: packages.h:56
di_mem_chunk * package_dependency_mem_chunk
Definition: packages.h:55

◆ di_packages_append_package()

void di_packages_append_package ( di_packages packages,
di_package package,
di_packages_allocator allocator 
)

append a package.

Parameters
packagesa di_packages
101{
102 di_package *tmp;
103
104 tmp = di_packages_get_package (packages, package->package, 0);
105
106 if (!tmp)
107 di_slist_append_chunk (&packages->list, package, allocator->slist_node_mem_chunk);
108
109 di_hash_table_insert (packages->table, &package->key, package);
110}
void di_hash_table_insert(di_hash_table *hash_table, void *key, void *value)
Definition: hash.c:178
di_package * di_packages_get_package(di_packages *packages, const char *name, size_t n)
Definition: packages.c:121
void di_slist_append_chunk(di_slist *slist, void *data, di_mem_chunk *mem_chunk) __attribute__((nonnull(1
di_rstring key
Definition: package.h:100
char * package
Definition: package.h:99
di_slist list
Definition: packages.h:44

References di_hash_table_insert(), di_packages_get_package(), di_slist_append_chunk(), di_package::key, list, di_package::package, di_packages_allocator::slist_node_mem_chunk, and table.

◆ di_packages_free()

void di_packages_free ( di_packages packages)

Free di_packages

77{
78 if (!packages)
79 return;
80 di_hash_table_destroy (packages->table);
81 di_free (packages);
82}
void di_hash_table_destroy(di_hash_table *hash_table)
Definition: hash.c:134

References di_free(), di_hash_table_destroy(), and table.

◆ di_packages_get_package()

di_package * di_packages_get_package ( di_packages packages,
const char *  name,
size_t  n 
)

get a named package.

Parameters
packagesa di_packages
namethe name of the package
nsize of the name or 0
Returns
the package or NULL
122{
123 di_rstring key;
124 size_t size;
125
126 if (n)
127 size = n;
128 else
129 size = strlen (name);
130
131 /* i know that is bad, but i know it is not written by the lookup */
132 key.string = (char *) name;
133 key.size = size;
134
135 return di_hash_table_lookup (packages->table, &key);
136}
void * di_hash_table_lookup(di_hash_table *hash_table, const void *key)
Definition: hash.c:169
raw string
Definition: string.h:38
di_ksize_t size
Definition: string.h:40
char * string
Definition: string.h:39

References di_hash_table_lookup(), di_rstring::size, di_rstring::string, and table.

Referenced by di_packages_append_package(), and di_packages_get_package_new().

◆ di_packages_get_package_new()

di_package * di_packages_get_package_new ( di_packages packages,
di_packages_allocator allocator,
char *  name,
size_t  n 
)

get a named package. creates a new one if non-existant.

Parameters
packagesa di_packages
namethe name of the package
nsize of the name
Returns
the package
149{
150 di_package *ret = di_packages_get_package (packages, name, n);
151
152 if (!ret)
153 {
154 ret = di_package_alloc (allocator);
155 ret->key.string = di_stradup (name, n);
156 ret->key.size = n;
157
158 di_hash_table_insert (packages->table, &ret->key, ret);
159 }
160
161 return ret;
162}
char * di_stradup(const char *s, size_t n)
Definition: string.c:45

References di_packages_get_package().

◆ di_packages_resolve_dependencies()

di_slist * di_packages_resolve_dependencies ( di_packages packages,
di_slist list,
di_packages_allocator allocator 
)
362{
364 {
365 di_packages_resolve_dependencies_check_real,
366 di_packages_resolve_dependencies_check_virtual,
367 di_packages_resolve_dependencies_check_non_existant,
368 di_packages_resolve_dependencies_do_real_list_append,
369 0,
370 NULL,
371 NULL,
372 };
373
374 return di_packages_resolve_dependencies_special (packages, list, &s, allocator);
375}
Definition: packages_internal.h:41

◆ di_packages_resolve_dependencies_array()

di_slist * di_packages_resolve_dependencies_array ( di_packages packages,
di_package **  array,
di_packages_allocator allocator 
)
401{
403 {
404 di_packages_resolve_dependencies_check_real,
405 di_packages_resolve_dependencies_check_virtual,
406 di_packages_resolve_dependencies_check_non_existant,
407 di_packages_resolve_dependencies_do_real_list_append,
408 0,
409 NULL,
410 NULL,
411 };
412
413 return di_packages_resolve_dependencies_array_special (packages, array, &s, allocator);
414}

◆ di_packages_resolve_dependencies_array_special()

di_slist * di_packages_resolve_dependencies_array_special ( di_packages packages,
di_package **  array,
di_packages_resolve_dependencies_check s,
di_packages_allocator allocator 
)
378{
380 {
381 { NULL, NULL },
382 allocator,
383 };
384
385 di_slist *install = di_slist_alloc ();
386
387 s->do_real_data = &data;
388
389 di_packages_resolve_dependencies_marker (packages);
390
391 s->resolver = packages->resolver;
392
393 while (*array)
394 if (di_packages_resolve_dependencies_recurse (s, *array++, NULL))
395 internal_di_slist_append_list (install, &data.list);
396
397 return install;
398}
void internal_di_slist_append_list(di_slist *slist, di_slist *slist_append)
Definition: slist.c:99
di_slist * di_slist_alloc(void)
Definition: slist.c:26
unsigned int resolver
Definition: packages.h:45
Single-linked list.
Definition: slist.h:37

◆ di_packages_resolve_dependencies_mark()

void di_packages_resolve_dependencies_mark ( di_packages packages)
433{
435 {
436 di_packages_resolve_dependencies_check_real,
437 di_packages_resolve_dependencies_check_virtual,
438 di_packages_resolve_dependencies_check_non_existant_quiet,
439 di_packages_resolve_dependencies_do_real_mark,
440 0,
441 NULL,
442 NULL,
443 };
444
445 di_packages_resolve_dependencies_mark_special (packages, &s);
446}

◆ di_packages_resolve_dependencies_mark_special()

void di_packages_resolve_dependencies_mark_special ( di_packages packages,
di_packages_resolve_dependencies_check s 
)
417{
418 di_slist_node *node;
419
420 di_packages_resolve_dependencies_marker (packages);
421
422 s->resolver = packages->resolver;
423
424 for (node = packages->list.head; node; node = node->next)
425 {
426 di_package *package = node->data;
427 if (!(package->resolver & packages->resolver) && package->status_want == di_package_status_want_install)
428 di_packages_resolve_dependencies_recurse (s, package, NULL);
429 }
430}
Node of a single-linked list.
Definition: slist.h:46
di_slist_node * next
Definition: slist.h:47
di_slist_node * head
Definition: slist.h:38

◆ di_packages_resolve_dependencies_marker()

void di_packages_resolve_dependencies_marker ( di_packages packages)
321{
322 if (!packages->resolver)
323 packages->resolver = 1;
324 else if (packages->resolver > (INT_MAX >> 2))
325 {
326 di_hash_table_foreach (packages->table, resolve_dependencies_marker_reset, NULL);
327 packages->resolver = 1;
328 }
329 else
330 packages->resolver <<= 3;
331
332}
void di_hash_table_foreach(di_hash_table *hash_table, di_hfunc *func, void *user_data)
Definition: hash.c:246

◆ di_packages_resolve_dependencies_recurse()

bool di_packages_resolve_dependencies_recurse ( di_packages_resolve_dependencies_check r,
di_package package,
di_package dependend_package 
)
165{
166 di_slist_node *node;
167
168 /* did we already check this package? */
169 if (package->resolver & r->resolver)
170 {
171#ifdef ENABLE_EXTENSIVE_DEBUG
172 if (package->resolver & (r->resolver << 1))
173 di_log (DI_LOG_LEVEL_DEBUG, "resolver (%s): already done, okay", package->package);
174 else
175 di_log (DI_LOG_LEVEL_DEBUG, "resolver (%s): already done, not okay", package->package);
176#endif
177 return package->resolver & (r->resolver << 1);
178 }
179
180 package->resolver |= r->resolver;
181 package->resolver |= (r->resolver << 1);
182
183#ifdef ENABLE_EXTENSIVE_DEBUG
184 di_log (DI_LOG_LEVEL_DEBUG, "resolver (%s): start", package->package);
185#endif
186
187 switch (package->type)
188 {
190 for (node = package->depends.head; node; node = node->next)
191 {
192 di_package_dependency *d = node->data;
193
196 !r->check_real (r, package, d))
197 goto error;
198 }
199
200#ifdef ENABLE_EXTENSIVE_DEBUG
201 if (dependend_package)
202 di_log (DI_LOG_LEVEL_DEBUG, "resolver (%s): mark, dependency from %s", package->package, dependend_package->package);
203 else
204 di_log (DI_LOG_LEVEL_DEBUG, "resolver (%s): mark", package->package);
205#endif
206
207 r->do_real (package, r->do_real_data);
208 break;
209
211
212#ifdef ENABLE_EXTENSIVE_DEBUG
213 if (dependend_package)
214 di_log (DI_LOG_LEVEL_DEBUG, "resolver (%s): search, dependency from %s", package->package, dependend_package->package);
215 else
216 di_log (DI_LOG_LEVEL_DEBUG, "resolver (%s): search", package->package);
217#endif
218
219 for (node = package->depends.head; node; node = node->next)
220 {
221 di_package_dependency *d = node->data;
222
224 package->resolver &= ~(r->resolver << 2);
225 }
226
227 while (1)
228 {
229 di_package_dependency *best_provide = NULL;
230
231 for (node = package->depends.head; node; node = node->next)
232 {
233 di_package_dependency *d = node->data;
234
236 {
237 if (!(package->resolver & (r->resolver << 2)))
238 best_provide = r->check_virtual (package, best_provide, d, r->check_virtual_data);
239 }
240 }
241
242 if (best_provide)
243 {
244 if (r->check_real (r, dependend_package, best_provide))
245 break;
246 else
247 package->resolver |= (r->resolver << 2);
248 }
249 else if (!r->check_non_existant (r, package, NULL))
250 goto error;
251 else
252 break;
253 }
254
255 break;
256
258 if (!r->check_non_existant (r, package, NULL))
259 goto error;
260 }
261
262 return true;
263
264error:
265#ifdef ENABLE_EXTENSIVE_DEBUG
266 di_log (DI_LOG_LEVEL_DEBUG, "resolver (%s): not okay", package->package);
267#endif
268 package->resolver &= ~(r->resolver << 1);
269 return false;
270}
void di_log(di_log_level_flags log_level, const char *format,...) __attribute__((format(printf
@ DI_LOG_LEVEL_DEBUG
Definition: log.h:42
@ di_package_type_virtual_package
Definition: package.h:88
@ di_package_type_real_package
Definition: package.h:89
@ di_package_type_non_existent
Definition: package.h:87
@ di_package_dependency_type_pre_depends
Definition: package.h:129
@ di_package_dependency_type_depends
Definition: package.h:128
@ di_package_dependency_type_reverse_provides
Definition: package.h:134
Package dependency.
Definition: package.h:142
di_package_dependency_type type
Definition: package.h:143
di_slist depends
Definition: package.h:112
unsigned int resolver
Definition: package.h:118
di_package_type type
Definition: package.h:102
void * data
Definition: slist.h:48

◆ di_packages_resolve_dependencies_special()

di_slist * di_packages_resolve_dependencies_special ( di_packages packages,
di_slist list,
di_packages_resolve_dependencies_check s,
di_packages_allocator allocator 
)
335{
337 {
338 { NULL, NULL },
339 allocator,
340 };
341
342 di_slist *install = di_slist_alloc ();
343 di_slist_node *node;
344
345 s->do_real_data = &data;
346
347 di_packages_resolve_dependencies_marker (packages);
348
349 s->resolver = packages->resolver;
350
351 for (node = list->head; node; node = node->next)
352 {
353 di_package *p = node->data;
354 if (di_packages_resolve_dependencies_recurse (s, p, NULL))
355 internal_di_slist_append_list (install, &data.list);
356 }
357
358 return install;
359}

◆ internal_di_packages_allocator_alloc()

di_packages_allocator * internal_di_packages_allocator_alloc ( void  )