#include "opkg_message.h"
#include "pkg_parse.h"
#include "hash_table.h"
+#include "libbb/libbb.h"
static int parseDepends(compound_depend_t *compound_depend, hash_table_t * hash, char * depend_str);
static depend_t * depend_init(void);
-static void depend_deinit(depend_t *d);
static char ** add_unresolved_dep(pkg_t * pkg, char ** the_lost, int ref_ndx);
static char ** merge_unresolved(char ** oldstuff, char ** newstuff);
static int is_pkg_in_pkg_vec(pkg_vec_t * vec, pkg_t * pkg);
pkg_vec_t *unsatisfied, char *** unresolved)
{
pkg_t * satisfier_entry_pkg;
- register int i, j, k;
+ int i, j, k;
int count, found;
char ** the_lost;
abstract_pkg_t * ab_pkg;
compound_depend_t * conflicts;
depend_t ** possible_satisfiers;
depend_t * possible_satisfier;
- register int i, j, k;
+ int i, j, k;
int count;
abstract_pkg_t * ab_pkg;
pkg_t **pkg_scouts;
static int is_pkg_in_pkg_vec(pkg_vec_t * vec, pkg_t * pkg)
{
- register int i;
+ int i;
pkg_t ** pkgs = vec->pkgs;
for(i = 0; i < vec->len; i++)
{
int oldlen = 0, newlen = 0;
char ** result;
- register int i, j;
+ int i, j;
if(!newstuff)
return oldstuff;
-
+
while(oldstuff && oldstuff[oldlen]) oldlen++;
while(newstuff && newstuff[newlen]) newlen++;
-
- result = (char **)realloc(oldstuff, sizeof(char *) * (oldlen + newlen + 1));
- if (result == NULL) {
- fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
- return NULL;
- }
-
+
+ result = xrealloc(oldstuff, sizeof(char *) * (oldlen + newlen + 1));
+
for(i = oldlen, j = 0; i < (oldlen + newlen); i++, j++)
*(result + i) = *(newstuff + j);
-
+
*(result + i) = NULL;
return result;
}
-
+
/*
* a kinda kludgy way to back out depends str from two different arrays (reg'l'r 'n pre)
* this is null terminated, no count is carried around
while(the_lost && the_lost[count]) count++;
count++; /* need one to hold the null */
- resized = (char **)realloc(the_lost, sizeof(char *) * (count + 1));
- if (resized == NULL) {
- fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
- return NULL;
- }
- resized[count - 1] = strdup(depend_str);
+ resized = xrealloc(the_lost, sizeof(char *) * (count + 1));
+ resized[count - 1] = xstrdup(depend_str);
resized[count] = NULL;
return resized;
}
-
-void printDepends(pkg_t * pkg)
-{
- register int i, j;
- compound_depend_t * depend;
- int count;
-
- count = pkg->pre_depends_count + pkg->depends_count;
-
- depend = pkg->depends;
- if(!depend){
- fprintf(stderr, "Depends pointer is NULL\n");
- return;
- }
- for(i = 0; i < count; i++){
- fprintf(stderr, "%s has %d possibilities:\n",
- (depend->type == GREEDY_DEPEND) ? "Greedy-Depend" : ((depend->type == DEPEND) ? "Depend" : "Pre-Depend"),
- depend->possibility_count);
- for(j = 0; j < depend->possibility_count; j++)
- fprintf(stderr, "\t%s version %s (%d)\n",
- depend->possibilities[j]->pkg->name,
- depend->possibilities[j]->version,
- depend->possibilities[j]->constraint);
- depend++;
- }
-}
-int buildProvides(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
+void buildProvides(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
{
- register int i, j;
+ int i;
/* every pkg provides itself */
abstract_pkg_vec_insert(ab_pkg->provided_by, ab_pkg);
if (!pkg->provides_count)
- return 0;
- if (pkg->provides)
- return 0;
-
- pkg->provides = (abstract_pkg_t **)calloc((pkg->provides_count + 1), sizeof(abstract_pkg_t *));
- if (pkg->provides == NULL) {
- fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
- return -1 ;
- }
- pkg->provides[0] = ab_pkg;
+ return;
- // if (strcmp(ab_pkg->name, pkg->name))
- // fprintf(stderr, __FUNCTION__ ": ab_pkg=%s pkg=%s\n", ab_pkg->name, pkg->name);
+ pkg->provides = xcalloc((pkg->provides_count + 1), sizeof(abstract_pkg_t *));
+ pkg->provides[0] = ab_pkg;
for(i = 0; i < pkg->provides_count; i++){
- abstract_pkg_t *provided_abpkg = ensure_abstract_pkg_by_name(hash, pkg->provides_str[i]);
+ abstract_pkg_t *provided_abpkg = ensure_abstract_pkg_by_name(hash, pkg->provides_str[i]);
pkg->provides[i+1] = provided_abpkg;
- j = 0;
abstract_pkg_vec_insert(provided_abpkg->provided_by, ab_pkg);
}
- return 0;
}
/* Abhaya: added conflicts support */
-int buildConflicts(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
+void buildConflicts(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
{
- register int i;
+ int i;
compound_depend_t * conflicts;
if (!pkg->conflicts_count)
- return 0;
+ return;
- conflicts = pkg->conflicts = calloc(pkg->conflicts_count, sizeof(compound_depend_t));
- if (conflicts == NULL) {
- fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
- return -1;
- }
+ conflicts = pkg->conflicts = xcalloc(pkg->conflicts_count, sizeof(compound_depend_t));
for (i = 0; i < pkg->conflicts_count; i++) {
conflicts->type = CONFLICTS;
parseDepends(conflicts, hash,
pkg->conflicts_str[i]);
conflicts++;
}
- return 0;
}
-int buildReplaces(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
+void buildReplaces(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
{
- register int i, j;
+ int i;
if (!pkg->replaces_count)
- return 0;
+ return;
- pkg->replaces = (abstract_pkg_t **)calloc(pkg->replaces_count, sizeof(abstract_pkg_t *));
- if (pkg->replaces == NULL) {
- fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
- return -1;
- }
+ pkg->replaces = xcalloc(pkg->replaces_count, sizeof(abstract_pkg_t *));
for(i = 0; i < pkg->replaces_count; i++){
abstract_pkg_t *old_abpkg = ensure_abstract_pkg_by_name(hash, pkg->replaces_str[i]);
pkg->replaces[i] = old_abpkg;
- j = 0;
if (!old_abpkg->replaced_by)
old_abpkg->replaced_by = abstract_pkg_vec_alloc();
- if ( old_abpkg->replaced_by == NULL ){
- return -1;
- }
/* if a package pkg both replaces and conflicts old_abpkg,
* then add it to the replaced_by vector so that old_abpkg
* will be upgraded to ab_pkg automatically */
if (pkg_conflicts_abstract(pkg, old_abpkg))
abstract_pkg_vec_insert(old_abpkg->replaced_by, ab_pkg);
}
- return 0;
}
-int buildDepends(hash_table_t * hash, pkg_t * pkg)
+void buildDepends(hash_table_t * hash, pkg_t * pkg)
{
int count;
- register int i;
+ int i;
compound_depend_t * depends;
if(!(count = pkg->pre_depends_count + pkg->depends_count + pkg->recommends_count + pkg->suggests_count))
- return 0;
+ return;
- if (0 && pkg->pre_depends_count)
- fprintf(stderr, "pkg=%s pre_depends_count=%d depends_count=%d\n",
- pkg->name, pkg->pre_depends_count, pkg->depends_count);
- depends = pkg->depends = calloc(count, sizeof(compound_depend_t));
- if (depends == NULL) {
- fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
- return -1;
- }
-
+ depends = pkg->depends = xcalloc(count, sizeof(compound_depend_t));
for(i = 0; i < pkg->pre_depends_count; i++){
parseDepends(depends, hash, pkg->pre_depends_str[i]);
- if (0 && pkg->pre_depends_count)
- fprintf(stderr, " pre_depends_str=%s depends=%p possibility_count=%x\n",
- pkg->pre_depends_str[i], depends, depends->possibility_count);
depends->type = PREDEPEND;
depends++;
}
for(i = 0; i < pkg->recommends_count; i++){
parseDepends(depends, hash, pkg->recommends_str[i]);
- if (0 && pkg->recommends_count)
- fprintf(stderr, " recommends_str=%s depends=%p possibility_count=%x\n",
- pkg->recommends_str[i], depends, depends->possibility_count);
depends->type = RECOMMEND;
depends++;
}
for(i = 0; i < pkg->suggests_count; i++){
parseDepends(depends, hash, pkg->suggests_str[i]);
- if (0 && pkg->suggests_count)
- fprintf(stderr, " suggests_str=%s depends=%p possibility_count=%x\n",
- pkg->suggests_str[i], depends, depends->possibility_count);
depends->type = SUGGEST;
depends++;
}
for(i = 0; i < pkg->depends_count; i++){
parseDepends(depends, hash, pkg->depends_str[i]);
- if (0 && pkg->depends_count)
- fprintf(stderr, " depends_str=%s depends=%p possibility_count=%x\n",
- pkg->depends_str[i], depends, depends->possibility_count);
depends++;
}
- return 0;
-}
+}
/*
* pkg_depend_string: returns the depends string specified by index.
return NULL;
}
-void freeDepends(pkg_t *pkg)
-{
- int i;
-
- if (pkg == NULL || pkg->depends == NULL) {
- return;
- }
-
- fprintf(stderr, "Freeing depends=%p\n", pkg->depends);
- for (i=0; i < pkg->depends->possibility_count; i++) {
- depend_deinit(pkg->depends->possibilities[i]);
- }
- free(pkg->depends->possibilities);
- free(pkg->depends);
- pkg->depends = NULL;
-}
-
void buildDependedUponBy(pkg_t * pkg, abstract_pkg_t * ab_pkg)
{
compound_depend_t * depends;
int count, othercount;
- register int i, j;
+ int i, j;
abstract_pkg_t * ab_depend;
abstract_pkg_t ** temp;
count = pkg->pre_depends_count + pkg->depends_count;
depends = pkg->depends;
- if (0 && pkg->pre_depends_count)
- fprintf(stderr, "pkg=%s pre_depends_count=%d depends_count=%d\n",
- pkg->name, pkg->pre_depends_count, pkg->depends_count);
for (i = 0; i < count; i++) {
- if (0 && pkg->pre_depends_count)
- fprintf(stderr, " i=%d possibility_count=%x depends=%p\n", i, depends->possibility_count, depends);
for (j = 0; j < depends->possibility_count; j++){
ab_depend = depends->possibilities[j]->pkg;
if(!ab_depend->depended_upon_by)
- ab_depend->depended_upon_by = (abstract_pkg_t **)calloc(1, sizeof(abstract_pkg_t *));
+ ab_depend->depended_upon_by = xcalloc(1, sizeof(abstract_pkg_t *));
temp = ab_depend->depended_upon_by;
othercount = 1;
}
*temp = ab_pkg;
- ab_depend->depended_upon_by = (abstract_pkg_t **)realloc(ab_depend->depended_upon_by,
+ ab_depend->depended_upon_by = xrealloc(ab_depend->depended_upon_by,
(othercount + 1) * sizeof(abstract_pkg_t *));
/* the array may have moved */
temp = ab_depend->depended_upon_by + othercount;
static depend_t * depend_init(void)
{
- depend_t * d = (depend_t *)calloc(1, sizeof(depend_t));
- if ( d==NULL ){
- fprintf(stderr, "%s: out of memory\n", __FUNCTION__);
- return NULL;
- }
+ depend_t * d = xcalloc(1, sizeof(depend_t));
d->constraint = NONE;
d->version = NULL;
d->pkg = NULL;
return d;
}
-static void depend_deinit(depend_t *d)
-{
- free(d);
-}
-
static int parseDepends(compound_depend_t *compound_depend,
hash_table_t * hash, char * depend_str)
{
char * pkg_name, buffer[2048];
int num_of_ors = 0;
- register int i;
- register char * src, * dest;
+ int i;
+ char * src, * dest;
depend_t ** possibilities;
/* first count the number of ored possibilities for satisfying dependency */
compound_depend->type = DEPEND;
compound_depend->possibility_count = num_of_ors + 1;
- possibilities = (depend_t **)calloc((num_of_ors + 1), sizeof(depend_t *) );
- if (!possibilities)
- return -ENOMEM;
+ possibilities = xcalloc((num_of_ors + 1), sizeof(depend_t *) );
compound_depend->possibilities = possibilities;
src = depend_str;
for(i = 0; i < num_of_ors + 1; i++){
possibilities[i] = depend_init();
- if (!possibilities[i])
- return -ENOMEM;
/* gobble up just the name first */
dest = buffer;
while(*src &&
projects / oweals / opkg-lede.git / blobdiff