/* * alpm_list.c * * Copyright (c) 2002-2006 by Judd Vinet <jvinet@zeroflux.org> * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by * the Free Software Foundation; either version 2 of the License, or * (at your option) any later version. * * This program is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program; if not, write to the Free Software * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, * USA. */ #include "config.h" #include <stdlib.h> #include <string.h> #include <stdio.h> /* libalpm */ #include "alpm_list.h" #include "util.h" /** * @addtogroup alpm_list List Functions * @brief Functions to manipulate alpm_list_t lists. * * These functions are designed to create, destroy, and modify lists of * type alpm_list_t. This is an internal list type used by libalpm that is * publicly exposed for use by frontends if desired. * * @{ */ /* Allocation */ /** * @brief Allocate a new alpm_list_t. * * @return a new alpm_list_t item, or NULL on failure */ alpm_list_t *alpm_list_new() { alpm_list_t *list = NULL; list = malloc(sizeof(alpm_list_t)); if(list) { list->data = NULL; list->prev = NULL; list->next = NULL; } return(list); } /** * @brief Free a list, but not the contained data. * * @param list the list to free */ void SYMEXPORT alpm_list_free(alpm_list_t *list) { alpm_list_t *it = list; while(it) { alpm_list_t *tmp = it->next; free(it); it = tmp; } } /** * @brief Free the internal data of a list structure. * * @param list the list to free * @param fn a free function for the internal data */ void SYMEXPORT alpm_list_free_inner(alpm_list_t *list, alpm_list_fn_free fn) { alpm_list_t *it = list; while(it) { if(fn && it->data) { fn(it->data); } it = it->next; } } /* Mutators */ /** * @brief Add a new item to the list. * * @param list the list to add to * @param data the new item to be added to the list * * @return the resultant list */ alpm_list_t SYMEXPORT *alpm_list_add(alpm_list_t *list, void *data) { alpm_list_t *ptr, *lp; ptr = list; if(ptr == NULL) { ptr = alpm_list_new(); if(ptr == NULL) { return(NULL); } } lp = alpm_list_last(ptr); if(lp == ptr && lp->data == NULL) { /* nada */ } else { lp->next = alpm_list_new(); if(lp->next == NULL) { return(NULL); } lp->next->prev = lp; lp = lp->next; } lp->data = data; return(ptr); } /** * @brief Add items to a list in sorted order. * * @param list the list to add to * @param data the new item to be added to the list * @param fn the comparison function to use to determine order * * @return the resultant list */ alpm_list_t *alpm_list_add_sorted(alpm_list_t *list, void *data, alpm_list_fn_cmp fn) { if(!fn) { return alpm_list_add(list, data); } else { alpm_list_t *add = NULL, *prev = NULL, *next = list; add = alpm_list_new(); add->data = data; /* Find insertion point. */ while(next) { if(fn(add->data, next->data) <= 0) break; prev = next; next = next->next; } /* Insert node before insertion point. */ add->prev = prev; add->next = next; if(next != NULL) { next->prev = add; /* Not at end. */ } if(prev != NULL) { prev->next = add; /* In middle. */ } else { list = add; /* At beginning, or new list */ } return(list); } } /** * @brief Merge the two sorted sublists into one sorted list. * * @param left the first list * @param right the second list * @param fn comparison function for determining merge order * * @return the resultant list */ alpm_list_t *alpm_list_mmerge(alpm_list_t *left, alpm_list_t *right, alpm_list_fn_cmp fn) { alpm_list_t *newlist, *lp; if (left == NULL) return right; if (right == NULL) return left; if (fn(left->data, right->data) <= 0) { newlist = left; left = left->next; } else { newlist = right; right = right->next; } newlist->prev = NULL; newlist->next = NULL; lp = newlist; while ((left != NULL) && (right != NULL)) { if (fn(left->data, right->data) <= 0) { lp->next = left; left->prev = lp; left = left->next; } else { lp->next = right; right->prev = lp; right = right->next; } lp = lp->next; lp->next = NULL; } if (left != NULL) { lp->next = left; left->prev = lp; } else if (right != NULL) { lp->next = right; right->prev = lp; } return(newlist); } /** * @brief Sort a list of size `n` using mergesort algorithm. * * @param list the list to sort * @param n the size of the list * @param fn the comparison function for determining order * * @return the resultant list */ alpm_list_t* alpm_list_msort(alpm_list_t *list, int n, alpm_list_fn_cmp fn) { if (n > 1) { alpm_list_t *left = list; alpm_list_t *lastleft = alpm_list_nth(list, n/2 - 1); alpm_list_t *right = lastleft->next; /* terminate first list */ lastleft->next = NULL; left = alpm_list_msort(left, n/2, fn); right = alpm_list_msort(right, n - (n/2), fn); list = alpm_list_mmerge(left, right, fn); } return(list); } /** * @brief Remove an item from the list. * * @param haystack the list to remove the item from * @param needle the data member of the item we're removing * @param fn the comparison function for searching * @param data output parameter containing data of the removed item * * @return the resultant list */ alpm_list_t *alpm_list_remove(alpm_list_t *haystack, const void *needle, alpm_list_fn_cmp fn, void **data) { /* TODO I modified this to remove ALL matching items. Do we need a remove_first? */ alpm_list_t *i = haystack, *tmp = NULL; if(data) { *data = NULL; } while(i) { if(i->data == NULL) { continue; } tmp = i->next; if(fn(needle, i->data) == 0) { /* we found a matching item */ if(i->next) { i->next->prev = i->prev; } if(i->prev) { i->prev->next = i->next; } if(i == haystack) { /* The item found is the first in the chain */ haystack = haystack->next; } if(data) { *data = i->data; } i->data = NULL; free(i); } i = tmp; } return(haystack); } /** * @brief Remove the node from the list that it belongs to. * * This DOES NOT free the node. * * @param node the list node we're removing * * @return the node which took the place of this one */ alpm_list_t *alpm_list_remove_node(alpm_list_t *node) { if(!node) return(NULL); alpm_list_t *ret = NULL; if(node->prev) { node->prev->next = node->next; ret = node->prev; node->prev = NULL; } if(node->next) { node->next->prev = node->prev; ret = node->next; node->next = NULL; } return(ret); } /** * @brief Create a new list without any duplicates. * * This does NOT copy data members. * * @param list the list to copy * * @return a new list containing non-duplicate items */ alpm_list_t SYMEXPORT *alpm_list_remove_dupes(alpm_list_t *list) { /* TODO does removing the strdup here cause invalid free's anywhere? */ alpm_list_t *lp = list, *newlist = NULL; while(lp) { if(!alpm_list_find(newlist, lp->data)) { newlist = alpm_list_add(newlist, lp->data); } lp = lp->next; } return(newlist); } /** * @brief Copy a string list, including data. * * This is gross, assumes string data members. * * @param list the list to copy * * @return a copy of the original list */ alpm_list_t *alpm_list_strdup(alpm_list_t *list) { alpm_list_t *lp = list, *newlist = NULL; while(lp) { newlist = alpm_list_add(newlist, strdup(lp->data)); lp = lp->next; } return(newlist); } /** * @brief Create a new list in reverse order. * * @param list the list to copy * * @return a new list in reverse order */ alpm_list_t *alpm_list_reverse(alpm_list_t *list) { /* TODO any invalid free's from NOT duplicating data here? */ alpm_list_t *lp, *newlist = NULL; lp = alpm_list_last(list); while(lp) { newlist = alpm_list_add(newlist, lp->data); lp = lp->prev; } return(newlist); } /* Accessors */ /** * @brief Get the first element of a list. * * @param list the list * * @return the first element in the list */ inline alpm_list_t SYMEXPORT *alpm_list_first(alpm_list_t *list) { return(list); } /** * @brief Return nth element from list (starting from 0). * * @param list the list * @param n the index of the item to find * * @return an alpm_list_t node for index `n` */ alpm_list_t *alpm_list_nth(alpm_list_t *list, int n) { alpm_list_t *i = list; while(n--) { i = i->next; } return(i); } /** * @brief Get the next element of a list. * * @param node the list node * * @return the next element, or NULL when no more elements exist */ inline alpm_list_t SYMEXPORT *alpm_list_next(alpm_list_t *node) { return(node->next); } /** * @brief Get the last item in the list. * * @param list the list * * @return the last element in the list */ alpm_list_t *alpm_list_last(alpm_list_t *list) { alpm_list_t *i = list; while(i && i->next) { i = i->next; } return(i); } /** * @brief Get the data member of a list node. * * @param node the list node * * @return the contained data, or NULL if none */ void SYMEXPORT *alpm_list_getdata(const alpm_list_t *node) { if(node == NULL) return(NULL); return(node->data); } /* Misc */ /** * @brief Get the number of items in a list. * * @param list the list * * @return the number of list items */ int SYMEXPORT alpm_list_count(const alpm_list_t *list) { unsigned int i = 0; const alpm_list_t *lp = list; while(lp) { ++i; lp = lp->next; } return(i); } /** * @brief Find an item in a list. * * Search for the item whos data matches that of the `needle`. * * @param needle the data to search for (== comparison) * @param haystack the list * * @return 1 if `needle` is found, 0 otherwise */ int SYMEXPORT alpm_list_find(alpm_list_t *haystack, const void *needle) { alpm_list_t *lp = haystack; while(lp) { if(lp->data == needle) { return(1); } lp = lp->next; } return(0); } /** * @brief Find a string in a list. * Optimization of alpm_list_find for strings. * * @param needle the string to search for * @param haystack the list * * @return 1 if `needle` is found, 0 otherwise */ int SYMEXPORT alpm_list_find_str(alpm_list_t *haystack, const char *needle) { alpm_list_t *lp = haystack; while(lp) { if(lp->data && strcmp((const char *)lp->data, needle) == 0) { return(1); } lp = lp->next; } return(0); } /** * @brief Find the items in list `lhs` that are not present in list `rhs`. * * Entries are not duplicated. Operation is O(m*n). The first list is stepped * through one node at a time, and for each node in the first list, each node * in the second list is compared to it. * * @param lhs the first list * @param rhs the second list * @param fn the comparison function * * @return a list containing all items in `lhs` not present in `rhs` */ alpm_list_t *alpm_list_diff(alpm_list_t *lhs, alpm_list_t *rhs, alpm_list_fn_cmp fn) { alpm_list_t *i, *j, *ret = NULL; for(i = lhs; i; i = i->next) { int found = 0; for(j = rhs; j; j = j->next) { if(fn(i->data, j->data) == 0) { found = 1; break; } } if(!found) { ret = alpm_list_add(ret, i->data); } } return(ret); } /** @} */ /* vim: set ts=2 sw=2 noet: */