void dump_variants(int outfd, stringptr* section_name, variant_info_list* variants,
stringptrlist* block_strings, size_t level, size_t previous_membercount, ssize_t backindent) {
if(variants == NULL) return;
variant_info* vp;
stringptr* act, normalized;
char norm_buf[1024];
size_t membercount;
size_t* id;
int switched = 0;
sblist_iter(variants, vp) {
membercount = sblist_getsize(vp->members);
if(membercount == previous_membercount) {
print_level_tabs(outfd, level - backindent);
ulz_fprintf(outfd, "if(str[%zu]!='%c') goto main_default;\n", level, vp->c);
backindent++;
} else {
if(!switched) {
print_level_tabs(outfd, level - backindent);
ulz_fprintf(outfd, "switch(str[%zu]) {\n", level);
switched = 1;
backindent--;
}
print_level_tabs(outfd, level - backindent);
ulz_fprintf(outfd, "case '%c':\n", vp->c);
}
if(!vp->variants) {
print_level_tabs(outfd, level - backindent);
id = sblist_get(vp->members, 0);
act = sblist_get(block_strings, *id);
normalized = normalize(act, norm_buf, sizeof(norm_buf));
log_put(outfd, VARISL("\treturn stringswitch_enumerator_member_name("),
VARIS(section_name), VARISL(", "), VARIS(&normalized), VARISL(");"), NULL);
}
dump_variants(outfd, section_name, vp->variants, block_strings, level+1, membercount, backindent);
}
int in_member_list(variant_info* variant, size_t index) {
size_t i, *r;
for(i = 0; i < sblist_getsize(variant->members); i++) {
r = sblist_get(variant->members, i);
if (*r == index) return 1;
}
return 0;
}
variant_info* find_variant(sblist* variants, int c) {
size_t i;
variant_info* res;
for(i = 0; i < sblist_getsize(variants); i++) {
res = sblist_get(variants, i);
if(res->c == c) return res;
}
return NULL;
}
int is_in_queue(stringptr* packagename, sblist* queue) {
size_t i;
pkg_exec* listitem;
for(i = 0; i < sblist_getsize(queue); i++) {
listitem = sblist_get(queue, i);
if(EQ(listitem->name, packagename))
return 1;
}
return 0;
}
// checks if all dependencies are installed
// then checks if the tarball is downloaded
// then checks if its either a metapackage or doesnt require a tarball.
int has_all_deps(pkgstate* state, pkgdata* item) {
size_t i;
pkg_exec* dlitem;
for(i = 0; i < stringptrlist_getsize(item->deps); i++)
if(!is_installed(state->installed_packages, stringptrlist_get(item->deps, i))) return 0;
for(i = 0; i < sblist_getsize(state->dl_queue); i++) {
dlitem = sblist_get(state->dl_queue, i);
if(EQ(dlitem->name, item->name)) {
return (dlitem->pid == 0); //download finished?
}
}
return (!stringptrlist_getsize(item->mirrors) || has_tarball(&state->cfg, item));
}
// initialise with members list, containing all ids
variant_info_list* get_variants(size_t_ptrlist* members, stringptr* last_prefix, stringptrlist* block_strings, size_t block_len) {
size_t i;
variant_info vr, *vp;
stringptr* next_prefix, *act;
size_t* id;
if(last_prefix->size == block_len) return NULL;
variant_info_list* res = NULL;
stringptr temp;
char c;
for(i = 0; i < sblist_getsize(members); i++) {
id = sblist_get(members, i);
act = stringptrlist_get(block_strings, *id);
if(last_prefix->size == 0 || stringptr_here(act, 0, last_prefix)) {
if(!res) res = sblist_new(sizeof(variant_info), 16);
if(!(vp = find_variant(res, act->ptr[last_prefix->size]))) {
vr.c = act->ptr[last_prefix->size];
vr.members = sblist_new(sizeof(size_t), stringptrlist_getsize(members));
vr.variants = NULL;
sblist_add(res, &vr);
vp = find_variant(res, vr.c);
}
sblist_add(vp->members, id);
}
}
if(res) {
for (i = 0; i < sblist_getsize(res); i++) {
vp = sblist_get(res, i);
c = vp->c;
temp.size = 1;
temp.ptr = &c;
next_prefix = stringptr_concat(last_prefix, &temp, NULL);
vp->variants = get_variants(vp->members, next_prefix, block_strings, block_len);
}
}
return res;
}
void fill_slots(jobtype ptype, pkgstate* state) {
size_t i;
pkg_exec* item;
pkgdata* pkg;
int* slots = (ptype == JT_DOWNLOAD) ? &state->slots.dl_slots : &state->slots.build_slots;
sblist* queue = (ptype == JT_DOWNLOAD) ? state->dl_queue : state->build_queue;
for(i = 0; *slots && i < sblist_getsize(queue); i++) {
item = sblist_get(queue, i);
if(item->pid == -1) {
pkg = packagelist_get(state->package_list, item->name, stringptr_hash(item->name));
if(ptype == JT_DOWNLOAD || has_all_deps(state, pkg)) {
if(ptype == JT_BUILD && !pkg->verified) {
if (! (pkg->verified = !(verify_tarball(&state->cfg, pkg)))) {
log_put(2, VARISL("WARNING: "), VARIS(item->name), VARISL(" failed to verify! please delete its tarball and retry downloading it."), NULL);
continue;
}
}
launch_thread(ptype, state, item, pkg);
(*slots)--;
}
}
}
}
void sblist_delete(sblist* l, size_t item) {
if (l->count && item < l->count) {
memmove(sblist_item_from_index(l, item), sblist_item_from_index(l, item + 1), (sblist_getsize(l) - (item + 1)) * l->itemsize);
l->count--;
}
}
