tmp_vec,
&newstuff);
if (newstuff == NULL) {
- int i;
+ int m;
int ok = 1;
- for (i = 0; i < rc; i++) {
- pkg_t *p = tmp_vec->pkgs[i];
+ for (m = 0; m < rc; m++) {
+ pkg_t *p = tmp_vec->pkgs[m];
if (p->state_want == SW_INSTALL)
continue;
opkg_message(conf, OPKG_DEBUG, "not installing %s due to requirement for %s\n", pkg_scout->name, p->name);
temp = pkg_new();
- parseVersion(temp, depends->version);
+ parse_version(temp, depends->version);
comparison = pkg_compare_versions(pkg, temp);
return 0;
}
-
-#ifdef DeadCode
-/**
- * pkg_has_common_provides returns 1 if pkg and replacee both provide
- * the same abstract package and 0 otherwise.
- */
-int pkg_has_common_provides(pkg_t *pkg, pkg_t *replacee)
-{
- abstract_pkg_t **provides = pkg->provides;
- int provides_count = pkg->provides_count;
- abstract_pkg_t **replacee_provides = replacee->provides;
- int replacee_provides_count = replacee->provides_count;
- int i, j;
- for (i = 0; i < provides_count; i++) {
- abstract_pkg_t *apkg = provides[i];
- for (j = 0; j < replacee_provides_count; j++) {
- abstract_pkg_t *replacee_apkg = replacee_provides[i];
- if (apkg == replacee_apkg)
- return 1;
- }
- }
- return 0;
-}
-#endif
-
-/**
- * pkg_provides_abstract returns 1 if pkg->provides contains providee
- * and 0 otherwise.
- */
-int pkg_provides_abstract(pkg_t *pkg, abstract_pkg_t *providee)
-{
- abstract_pkg_t **provides = pkg->provides;
- int provides_count = pkg->provides_count;
- int i;
- for (i = 0; i < provides_count; i++) {
- if (provides[i] == providee)
- return 1;
- }
- return 0;
-}
-
/**
* pkg_replaces returns 1 if pkg->replaces contains one of replacee's provides and 0
* otherwise.
{
abstract_pkg_t **replaces = pkg->replaces;
int replaces_count = pkg->replaces_count;
- /* abstract_pkg_t **replacee_provides = pkg->provides;
- int replacee_provides_count = pkg->provides_count; */
+ int replacee_provides_count = replacee->provides_count;
int i, j;
for (i = 0; i < replaces_count; i++) {
abstract_pkg_t *abstract_replacee = replaces[i];
- for (j = 0; j < replaces_count; j++) {
- /* opkg_message(NULL, OPKG_DEBUG2, "Searching pkg-name %s repprovname %s absrepname %s \n",
- pkg->name,replacee->provides[j]->name, abstract_replacee->name); */
+ for (j = 0; j < replacee_provides_count; j++) {
if (replacee->provides[j] == abstract_replacee)
return 1;
}
{
int count;
char ** resized;
- char *depend_str = pkg_depend_str(pkg, ref_ndx);
count = 0;
while(the_lost && the_lost[count]) count++;
count++; /* need one to hold the null */
resized = xrealloc(the_lost, sizeof(char *) * (count + 1));
- resized[count - 1] = xstrdup(depend_str);
+ resized[count - 1] = pkg_depend_str(pkg, ref_ndx);
resized[count] = NULL;
return resized;
int i;
/* every pkg provides itself */
+ pkg->provides_count++;
abstract_pkg_vec_insert(ab_pkg->provided_by, ab_pkg);
-
- if (!pkg->provides_count)
- return;
-
- pkg->provides = xcalloc((pkg->provides_count + 1), sizeof(abstract_pkg_t *));
+ pkg->provides = xcalloc(pkg->provides_count, 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]);
+ for (i=1; i<pkg->provides_count; i++) {
+ abstract_pkg_t *provided_abpkg = ensure_abstract_pkg_by_name(hash,
+ pkg->provides_str[i-1]);
+ free(pkg->provides_str[i-1]);
- pkg->provides[i+1] = provided_abpkg;
+ pkg->provides[i] = provided_abpkg;
abstract_pkg_vec_insert(provided_abpkg->provided_by, ab_pkg);
}
+ if (pkg->provides_str)
+ free(pkg->provides_str);
}
/* Abhaya: added conflicts support */
conflicts->type = CONFLICTS;
parseDepends(conflicts, hash,
pkg->conflicts_str[i]);
+ free(pkg->conflicts_str[i]);
conflicts++;
}
+ if (pkg->conflicts_str)
+ free(pkg->conflicts_str);
}
void buildReplaces(hash_table_t * hash, abstract_pkg_t * ab_pkg, pkg_t * pkg)
abstract_pkg_t *old_abpkg = ensure_abstract_pkg_by_name(hash, pkg->replaces_str[i]);
pkg->replaces[i] = old_abpkg;
+ free(pkg->replaces_str[i]);
if (!old_abpkg->replaced_by)
old_abpkg->replaced_by = abstract_pkg_vec_alloc();
if (pkg_conflicts_abstract(pkg, old_abpkg))
abstract_pkg_vec_insert(old_abpkg->replaced_by, ab_pkg);
}
+
+ if (pkg->replaces_str)
+ free(pkg->replaces_str);
}
void buildDepends(hash_table_t * hash, pkg_t * pkg)
for(i = 0; i < pkg->pre_depends_count; i++){
parseDepends(depends, hash, pkg->pre_depends_str[i]);
+ free(pkg->pre_depends_str[i]);
depends->type = PREDEPEND;
depends++;
}
+ if (pkg->pre_depends_str)
+ free(pkg->pre_depends_str);
+
+ for(i = 0; i < pkg->depends_count; i++){
+ parseDepends(depends, hash, pkg->depends_str[i]);
+ free(pkg->depends_str[i]);
+ depends++;
+ }
+ if (pkg->depends_str)
+ free(pkg->depends_str);
for(i = 0; i < pkg->recommends_count; i++){
parseDepends(depends, hash, pkg->recommends_str[i]);
+ free(pkg->recommends_str[i]);
depends->type = RECOMMEND;
depends++;
}
+ if(pkg->recommends_str)
+ free(pkg->recommends_str);
for(i = 0; i < pkg->suggests_count; i++){
parseDepends(depends, hash, pkg->suggests_str[i]);
+ free(pkg->suggests_str[i]);
depends->type = SUGGEST;
depends++;
}
+ if(pkg->suggests_str)
+ free(pkg->suggests_str);
+}
- for(i = 0; i < pkg->depends_count; i++){
- parseDepends(depends, hash, pkg->depends_str[i]);
- depends++;
- }
+const char*
+constraint_to_str(enum version_constraint c)
+{
+ switch (c) {
+ case NONE:
+ return "";
+ case EARLIER:
+ return "< ";
+ case EARLIER_EQUAL:
+ return "<= ";
+ case EQUAL:
+ return "= ";
+ case LATER_EQUAL:
+ return ">= ";
+ case LATER:
+ return "> ";
+ }
+
+ return "";
}
/*
- * pkg_depend_string: returns the depends string specified by index.
- * All 4 kinds of dependences: dependence, pre-dependence, recommend, and suggest are number starting from 0.
- * [0,npredepends) -> returns pre_depends_str[index]
- * [npredepends,npredepends+nrecommends) -> returns recommends_str[index]
- * [npredepends+nrecommends,npredepends+nrecommends+nsuggests) -> returns recommends_str[index]
- * [npredepends+nrecommends+nsuggests,npredepends+nrecommends+nsuggests+ndepends) -> returns depends_str[index]
+ * Returns a printable string for pkg's dependency at the specified index. The
+ * resultant string must be passed to free() by the caller.
*/
-char *pkg_depend_str(pkg_t *pkg, int index)
+char *
+pkg_depend_str(pkg_t *pkg, int index)
{
- if (index < pkg->pre_depends_count) {
- return pkg->pre_depends_str[index];
- }
- index -= pkg->pre_depends_count;
+ int i, len;
+ char *str;
+ compound_depend_t *cdep;
+ depend_t *dep;
- if (index < pkg->recommends_count) {
- return pkg->recommends_str[index];
- }
- index -= pkg->recommends_count;
+ len = 0;
+ cdep = &pkg->depends[index];
- if (index < pkg->suggests_count) {
- return pkg->suggests_str[index];
- }
- index -= pkg->suggests_count;
+ /* calculate string length */
+ for (i=0; i<cdep->possibility_count; i++) {
+ dep = cdep->possibilities[i];
- if (index < pkg->depends_count) {
- return pkg->depends_str[index];
- }
- fprintf(stderr, "pkg_depend_str: index %d out of range for pkg=%s\n", index, pkg->name);
- return NULL;
+ if (i != 0)
+ len += 3; /* space, pipe, space */
+
+ len += strlen(dep->pkg->name);
+
+ if (dep->version) {
+ len += 2; /* space, left parenthesis */
+ len += 3; /* constraint string (<=, >=, etc), space */
+ len += strlen(dep->version);
+ len += 1; /* right parenthesis */
+ }
+ }
+
+ str = xmalloc(len + 1); /* +1 for the NULL terminator */
+ str[0] = '\0';
+
+ for (i=0; i<cdep->possibility_count; i++) {
+ dep = cdep->possibilities[i];
+
+ if (i != 0)
+ strncat(str, " | ", len);
+
+ strncat(str, dep->pkg->name, len);
+
+ if (dep->version) {
+ strncat(str, " (", len);
+ strncat(str, constraint_to_str(dep->constraint), len);
+ strncat(str, dep->version, len);
+ strncat(str, ")", len);
+ }
+ }
+
+ return str;
}
+/*
+ * WARNING: This function assumes pre_depends and depends are at the
+ * start of the pkg->depends array.
+ */
void buildDependedUponBy(pkg_t * pkg, abstract_pkg_t * ab_pkg)
{
compound_depend_t * depends;
(*src != '|'))
*dest++ = *src++;
*dest = '\0';
- pkg_name = trim_alloc(buffer);
+ pkg_name = trim_xstrdup(buffer);
if (pkg_name == NULL )
return -ENOMEM;
*dest++ = *src++;
*dest = '\0';
- possibilities[i]->version = trim_alloc(buffer);
+ possibilities[i]->version = trim_xstrdup(buffer);
/* fprintf(stderr, "let's print the depends version string:");
fprintf(stderr, "version %s\n", possibilities[i]->version);*/
if (possibilities[i]->version == NULL )
projects / oweals / opkg-lede.git / blobdiff