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 = xrealloc(the_lost, sizeof(char *) * (count + 1));
resized[count - 1] = xstrdup(depend_str);
resized[count] = NULL;
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 = xcalloc((pkg->provides_count + 1), sizeof(abstract_pkg_t *));
pkg->provides[0] = ab_pkg;
// if (strcmp(ab_pkg->name, pkg->name))
if (!pkg->conflicts_count)
return 0;
- 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,
if (!pkg->replaces_count)
return 0;
- 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]);
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 (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]);
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;
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 &&