Ttykuu

As many of you know goto is usually signs of code smell. However I thought this could be an appropriate case, and would like confirmation or criticism.

Unnecessary section such as the called functions were removed. Every non-standard function returns an int as status, 0 is "OK"; except linkedlist_open() which returns a pointer which could be NULL if the system runs out of memory.

packagetarget_close() does implement the necessary NULL checks.

packagetarget *packagetarget_open()

 packagetarget *target = (packagetarget*) malloc(sizeof(packagetarget));

 if (!target) return NULL;

 if (packagetarget_setname(target, ""))
 goto disposer;
 if (packagetarget_setsys(target, PACKAGETARGET_SYS))
 goto disposer;
 if (packagetarget_setarch(target, PACKAGETARGET_ARCH))
 goto disposer;
 if (packagetarget_setmin(target, PACKAGETARGET_MIN))
 goto disposer;
 if (packagetarget_setver(target, PACKAGETARGET_VER))
 goto disposer;
 if (packagetarget_setmax(target, PACKAGETARGET_MAX))
 goto disposer;

 linkedlist *comp = linkedlist_open();

 if (!comp) goto disposer;

 target->comp = comp;

 return target; 

 disposer:
 packagetarget_close(target);
 return NULL;

Each setter function follows a simple pattern. Since each setter is identical, I will only put the code for packagetarget_setname.

int packagetarget_setname(packagetarget *target, char *name)

 if (!target) return 1;

 if (!name) return 2;

 target->name = realloc(target->name, strlen(name) * sizeof(char));

 if (!target->name) return 3;

 strcpy(target->name, name);

 return 0;

Here is the packagetarget_close function:

void packagetarget_close(packagetarget *target)

 if (!target) return;

 if (target->name) free(target->name);
 if (target->sys) free(target->sys);
 if (target->arch) free(target->arch);
 if (target->min) free(target->min);
 if (target->ver) free(target->ver);
 if (target->min) free(target->min);
 if (target->comp) linkedlist_close(target->comp);

 free(target);

 return;

linkedlist_open is a similar function to the packagetarget_open.

linkedlist *linkedlist_open()

 linkedlist *list = (linkedlist*) malloc(sizeof(linkedlist));

 if (!list) return NULL;

 list->head = NULL;
 list->length = 0;
 list->remhook = NULL;

 return list;

The one thing most of these functions is they may fail when the system runs out of memory. So I have implemented checks for each step.