#include "libxml.h"
#include <stdlib.h>
#include <string.h>
#include <libxml/xmlmemory.h>
#include <libxml/list.h>
#include <libxml/globals.h>

Include dependency graph for list.c:

Classes
struct	_xmlLink

struct	_xmlList

Macros
#define	IN_LIBXML

Functions
static void	xmlLinkDeallocator (xmlListPtr l, xmlLinkPtr lk)

static int	xmlLinkCompare (const void data0, const void data1)

static xmlLinkPtr	xmlListLowerSearch (xmlListPtr l, void *data)

static xmlLinkPtr	xmlListHigherSearch (xmlListPtr l, void *data)

static xmlLinkPtr	xmlListLinkSearch (xmlListPtr l, void *data)

static xmlLinkPtr	xmlListLinkReverseSearch (xmlListPtr l, void *data)

xmlListPtr	xmlListCreate (xmlListDeallocator deallocator, xmlListDataCompare compare)

void *	xmlListSearch (xmlListPtr l, void *data)

void *	xmlListReverseSearch (xmlListPtr l, void *data)

int	xmlListInsert (xmlListPtr l, void *data)

int	xmlListAppend (xmlListPtr l, void *data)

void	xmlListDelete (xmlListPtr l)

int	xmlListRemoveFirst (xmlListPtr l, void *data)

int	xmlListRemoveLast (xmlListPtr l, void *data)

int	xmlListRemoveAll (xmlListPtr l, void *data)

void	xmlListClear (xmlListPtr l)

int	xmlListEmpty (xmlListPtr l)

xmlLinkPtr	xmlListFront (xmlListPtr l)

xmlLinkPtr	xmlListEnd (xmlListPtr l)

int	xmlListSize (xmlListPtr l)

void	xmlListPopFront (xmlListPtr l)

void	xmlListPopBack (xmlListPtr l)

int	xmlListPushFront (xmlListPtr l, void *data)

int	xmlListPushBack (xmlListPtr l, void *data)

void *	xmlLinkGetData (xmlLinkPtr lk)

void	xmlListReverse (xmlListPtr l)

void	xmlListSort (xmlListPtr l)

void	xmlListWalk (xmlListPtr l, xmlListWalker walker, void *user)

void	xmlListReverseWalk (xmlListPtr l, xmlListWalker walker, void *user)

void	xmlListMerge (xmlListPtr l1, xmlListPtr l2)

xmlListPtr	xmlListDup (const xmlListPtr old)

int	xmlListCopy (xmlListPtr cur, const xmlListPtr old)

Macro Definition Documentation

◆ IN_LIBXML

#define IN_LIBXML

Definition at line 18 of file list.c.

Function Documentation

◆ xmlLinkCompare()

static int xmlLinkCompare	(	const void *	data0,
		const void *	data1
	)

static

xmlLinkCompare: @data0: first data @data1: second data

Compares two arbitrary data

Returns -1, 0 or 1 depending on whether data1 is greater equal or smaller than data0

Definition at line 79 of file list.c.

{
    if (data0 < data1)
        return (-1);
    else if (data0 == data1)
    return (0);
    return (1);
}

Referenced by xmlListCreate().

◆ xmlLinkDeallocator()

static void xmlLinkDeallocator	(	xmlListPtr	l,
		xmlLinkPtr	lk
	)

static

xmlLinkDeallocator: @l: a list @lk: a link

Unlink and deallocate @lk from list @l

Definition at line 59 of file list.c.

{
    (lk->prev)->next = lk->next;
    (lk->next)->prev = lk->prev;
    if(l->linkDeallocator)
        l->linkDeallocator(lk);
    xmlFree(lk);
}

Referenced by xmlListClear(), xmlListPopBack(), xmlListPopFront(), xmlListRemoveFirst(), and xmlListRemoveLast().

◆ xmlLinkGetData()

void * xmlLinkGetData ( xmlLinkPtr lk )

xmlLinkGetData: @lk: a link

See Returns.

Returns a pointer to the data referenced from this link

Definition at line 604 of file list.c.

{
    if (lk == NULL)
        return(NULL);
    return lk->data;
}

Referenced by xmlFreeRef().

◆ xmlListAppend()

int xmlListAppend	(	xmlListPtr	l,
		void *	data
	)

xmlListAppend: @l: a list @data: the data

Insert data in the ordered list at the end for this value

Returns 0 in case of success, 1 in case of failure

Definition at line 305 of file list.c.

{
    xmlLinkPtr lkPlace, lkNew;
 
    if (l == NULL)
        return(1);
    lkPlace = xmlListHigherSearch(l, data);
    /* Add the new link */
    lkNew = (xmlLinkPtr) xmlMalloc(sizeof(xmlLink));
    if (lkNew == NULL) {
        xmlGenericError(xmlGenericErrorContext,
                "Cannot initialize memory for new link");
        return (1);
    }
    lkNew->data = data;
    lkNew->next = lkPlace->next;
    (lkPlace->next)->prev = lkNew;
    lkPlace->next = lkNew;
    lkNew->prev = lkPlace;
    return 0;
}

Referenced by xmlAddRef().

◆ xmlListClear()

void xmlListClear ( xmlListPtr l )

xmlListClear: @l: a list

Remove the all data in the list

Definition at line 422 of file list.c.

{
    xmlLinkPtr  lk;
 
    if (l == NULL)
        return;
    lk = l->sentinel->next;
    while(lk != l->sentinel) {
        xmlLinkPtr next = lk->next;
 
        xmlLinkDeallocator(l, lk);
        lk = next;
    }
}

Referenced by xmlListDelete(), xmlListMerge(), and xmlListSort().

◆ xmlListCopy()

int xmlListCopy	(	xmlListPtr	cur,
		const xmlListPtr	old
	)

xmlListCopy: @cur: the new list @old: the old list

Move all the element from the old list in the new list

Returns 0 in case of success 1 in case of error

Definition at line 761 of file list.c.

{
    /* Walk the old tree and insert the data into the new one */
    xmlLinkPtr lk;
 
    if ((old == NULL) || (cur == NULL))
        return(1);
    for(lk = old->sentinel->next; lk != old->sentinel; lk = lk->next) {
        if (0 !=xmlListInsert(cur, lk->data)) {
            xmlListDelete(cur);
            return (1);
        }
    }
    return (0);
}

Referenced by xmlListDup(), and xmlListMerge().

◆ xmlListCreate()

xmlListPtr xmlListCreate	(	xmlListDeallocator	deallocator,
		xmlListDataCompare	compare
	)

xmlListCreate: @deallocator: an optional deallocator function @compare: an optional comparison function

Create a new list

Returns the new list or NULL in case of error

Definition at line 188 of file list.c.

{
    xmlListPtr l;
    if (NULL == (l = (xmlListPtr )xmlMalloc( sizeof(xmlList)))) {
        xmlGenericError(xmlGenericErrorContext,
                "Cannot initialize memory for list");
        return (NULL);
    }
    /* Initialize the list to NULL */
    memset(l, 0, sizeof(xmlList));
 
    /* Add the sentinel */
    if (NULL ==(l->sentinel = (xmlLinkPtr )xmlMalloc(sizeof(xmlLink)))) {
        xmlGenericError(xmlGenericErrorContext,
                "Cannot initialize memory for sentinel");
    xmlFree(l);
        return (NULL);
    }
    l->sentinel->next = l->sentinel;
    l->sentinel->prev = l->sentinel;
    l->sentinel->data = NULL;
 
    /* If there is a link deallocator, use it */
    if (deallocator != NULL)
        l->linkDeallocator = deallocator;
    /* If there is a link comparator, use it */
    if (compare != NULL)
        l->linkCompare = compare;
    else /* Use our own */
        l->linkCompare = xmlLinkCompare;
    return l;
}

Referenced by xmlAddRef(), and xmlListDup().

◆ xmlListDelete()

void xmlListDelete ( xmlListPtr l )

xmlListDelete: @l: a list

Deletes the list and its associated data

Definition at line 333 of file list.c.

{
    if (l == NULL)
        return;
 
    xmlListClear(l);
    xmlFree(l->sentinel);
    xmlFree(l);
}

Referenced by xmlAddRef(), xmlFreeRefTableEntry(), xmlListCopy(), and xmlListSort().

◆ xmlListDup()

xmlListPtr xmlListDup ( const xmlListPtr old )

xmlListDup: @old: the list

Duplicate the list

Returns a new copy of the list or NULL in case of error

Definition at line 732 of file list.c.

{
    xmlListPtr cur;
 
    if (old == NULL)
        return(NULL);
    /* Hmmm, how to best deal with allocation issues when copying
     * lists. If there is a de-allocator, should responsibility lie with
     * the new list or the old list. Surely not both. I'll arbitrarily
     * set it to be the old list for the time being whilst I work out
     * the answer
     */
    if (NULL ==(cur = xmlListCreate(NULL, old->linkCompare)))
        return (NULL);
    if (0 != xmlListCopy(cur, old))
        return NULL;
    return cur;
}

Referenced by xmlListSort().

◆ xmlListEmpty()

int xmlListEmpty ( xmlListPtr l )

xmlListEmpty: @l: a list

Is the list empty ?

Returns 1 if the list is empty, 0 if not empty and -1 in case of error

Definition at line 446 of file list.c.

{
    if (l == NULL)
        return(-1);
    return (l->sentinel->next == l->sentinel);
}

Referenced by xmlListPopBack(), xmlListPopFront(), xmlListSort(), and xmlRemoveRef().

◆ xmlListEnd()

xmlLinkPtr xmlListEnd ( xmlListPtr l )

xmlListEnd: @l: a list

Get the last element in the list

Returns the last element in the list, or NULL

Definition at line 478 of file list.c.

{
    if (l == NULL)
        return(NULL);
    return (l->sentinel->prev);
}

◆ xmlListFront()

xmlLinkPtr xmlListFront ( xmlListPtr l )

xmlListFront: @l: a list

Get the first element in the list

Returns the first element in the list, or NULL

Definition at line 462 of file list.c.

{
    if (l == NULL)
        return(NULL);
    return (l->sentinel->next);
}

◆ xmlListHigherSearch()

static xmlLinkPtr xmlListHigherSearch	(	xmlListPtr	l,
		void *	data
	)

static

xmlListHigherSearch: @l: a list @data: a data

Search data in the ordered list walking backward from the end

Returns the link containing the data or NULL

Definition at line 118 of file list.c.

{
    xmlLinkPtr lk;
 
    if (l == NULL)
        return(NULL);
    for(lk = l->sentinel->prev;lk != l->sentinel && l->linkCompare(lk->data, data) >0 ;lk = lk->prev);
    return lk;
}

Referenced by xmlListAppend(), and xmlListLinkReverseSearch().

◆ xmlListInsert()

int xmlListInsert	(	xmlListPtr	l,
		void *	data
	)

xmlListInsert: @l: a list @data: the data

Insert data in the ordered list at the beginning for this value

Returns 0 in case of success, 1 in case of failure

Definition at line 273 of file list.c.

{
    xmlLinkPtr lkPlace, lkNew;
 
    if (l == NULL)
        return(1);
    lkPlace = xmlListLowerSearch(l, data);
    /* Add the new link */
    lkNew = (xmlLinkPtr) xmlMalloc(sizeof(xmlLink));
    if (lkNew == NULL) {
        xmlGenericError(xmlGenericErrorContext,
                "Cannot initialize memory for new link");
        return (1);
    }
    lkNew->data = data;
    lkPlace = lkPlace->prev;
    lkNew->next = lkPlace->next;
    (lkPlace->next)->prev = lkNew;
    lkPlace->next = lkNew;
    lkNew->prev = lkPlace;
    return 0;
}

Referenced by xmlListCopy().

◆ xmlListLinkReverseSearch()

static xmlLinkPtr xmlListLinkReverseSearch	(	xmlListPtr	l,
		void *	data
	)

static

xmlListLinkReverseSearch: @l: a list @data: a data

Search data in the list processing backward

Returns the link containing the data or NULL

Definition at line 163 of file list.c.

{
    xmlLinkPtr lk;
    if (l == NULL)
        return(NULL);
    lk = xmlListHigherSearch(l, data);
    if (lk == l->sentinel)
        return NULL;
    else {
        if (l->linkCompare(lk->data, data) ==0)
            return lk;
        return NULL;
    }
}

Referenced by xmlListRemoveLast(), and xmlListReverseSearch().

◆ xmlListLinkSearch()

static xmlLinkPtr xmlListLinkSearch	(	xmlListPtr	l,
		void *	data
	)

static

xmlListSearch: @l: a list @data: a data

Search data in the list

Returns the link containing the data or NULL

Definition at line 138 of file list.c.

{
    xmlLinkPtr lk;
    if (l == NULL)
        return(NULL);
    lk = xmlListLowerSearch(l, data);
    if (lk == l->sentinel)
        return NULL;
    else {
        if (l->linkCompare(lk->data, data) ==0)
            return lk;
        return NULL;
    }
}

Referenced by xmlListRemoveFirst(), and xmlListSearch().

◆ xmlListLowerSearch()

static xmlLinkPtr xmlListLowerSearch	(	xmlListPtr	l,
		void *	data
	)

static

xmlListLowerSearch: @l: a list @data: a data

Search data in the ordered list walking from the beginning

Returns the link containing the data or NULL

Definition at line 98 of file list.c.

{
    xmlLinkPtr lk;
 
    if (l == NULL)
        return(NULL);
    for(lk = l->sentinel->next;lk != l->sentinel && l->linkCompare(lk->data, data) <0 ;lk = lk->next);
    return lk;
}

Referenced by xmlListInsert(), and xmlListLinkSearch().

◆ xmlListMerge()

void xmlListMerge	(	xmlListPtr	l1,
		xmlListPtr	l2
	)

xmlListMerge: @l1: the original list @l2: the new list

include all the elements of the second list in the first one and clear the second list

Definition at line 717 of file list.c.

{
    xmlListCopy(l1, l2);
    xmlListClear(l2);
}

Referenced by xmlListSort().

◆ xmlListPopBack()

void xmlListPopBack ( xmlListPtr l )

xmlListPopBack: @l: a list

Removes the last element in the list

Definition at line 526 of file list.c.

{
    if(!xmlListEmpty(l))
        xmlLinkDeallocator(l, l->sentinel->prev);
}

◆ xmlListPopFront()

void xmlListPopFront ( xmlListPtr l )

xmlListPopFront: @l: a list

Removes the first element in the list

Definition at line 513 of file list.c.

{
    if(!xmlListEmpty(l))
        xmlLinkDeallocator(l, l->sentinel->next);
}

◆ xmlListPushBack()

int xmlListPushBack	(	xmlListPtr	l,
		void *	data
	)

xmlListPushBack: @l: a list @data: new data

add the new data at the end of the list

Returns 1 if successful, 0 otherwise

Definition at line 574 of file list.c.

{
    xmlLinkPtr lkPlace, lkNew;
 
    if (l == NULL)
        return(0);
    lkPlace = l->sentinel->prev;
    /* Add the new link */
    if (NULL ==(lkNew = (xmlLinkPtr )xmlMalloc(sizeof(xmlLink)))) {
        xmlGenericError(xmlGenericErrorContext,
                "Cannot initialize memory for new link");
        return (0);
    }
    lkNew->data = data;
    lkNew->next = lkPlace->next;
    (lkPlace->next)->prev = lkNew;
    lkPlace->next = lkNew;
    lkNew->prev = lkPlace;
    return 1;
}

◆ xmlListPushFront()

int xmlListPushFront	(	xmlListPtr	l,
		void *	data
	)

xmlListPushFront: @l: a list @data: new data

add the new data at the beginning of the list

Returns 1 if successful, 0 otherwise

Definition at line 542 of file list.c.

{
    xmlLinkPtr lkPlace, lkNew;
 
    if (l == NULL)
        return(0);
    lkPlace = l->sentinel;
    /* Add the new link */
    lkNew = (xmlLinkPtr) xmlMalloc(sizeof(xmlLink));
    if (lkNew == NULL) {
        xmlGenericError(xmlGenericErrorContext,
                "Cannot initialize memory for new link");
        return (0);
    }
    lkNew->data = data;
    lkNew->next = lkPlace->next;
    (lkPlace->next)->prev = lkNew;
    lkPlace->next = lkNew;
    lkNew->prev = lkPlace;
    return 1;
}

◆ xmlListRemoveAll()

int xmlListRemoveAll	(	xmlListPtr	l,
		void *	data
	)

xmlListRemoveAll: @l: a list @data: list data

Remove the all instance associated to data in the list

Returns the number of deallocation, or 0 if not found

Definition at line 403 of file list.c.

{
    int count=0;
 
    if (l == NULL)
        return(0);
 
    while(xmlListRemoveFirst(l, data))
        count++;
    return count;
}

◆ xmlListRemoveFirst()

int xmlListRemoveFirst	(	xmlListPtr	l,
		void *	data
	)

xmlListRemoveFirst: @l: a list @data: list data

Remove the first instance associated to data in the list

Returns 1 if a deallocation occurred, or 0 if not found

Definition at line 353 of file list.c.

{
    xmlLinkPtr lk;
 
    if (l == NULL)
        return(0);
    /*Find the first instance of this data */
    lk = xmlListLinkSearch(l, data);
    if (lk != NULL) {
        xmlLinkDeallocator(l, lk);
        return 1;
    }
    return 0;
}

Referenced by xmlListRemoveAll(), and xmlWalkRemoveRef().

◆ xmlListRemoveLast()

int xmlListRemoveLast	(	xmlListPtr	l,
		void *	data
	)

xmlListRemoveLast: @l: a list @data: list data

Remove the last instance associated to data in the list

Returns 1 if a deallocation occurred, or 0 if not found

Definition at line 378 of file list.c.

{
    xmlLinkPtr lk;
 
    if (l == NULL)
        return(0);
    /*Find the last instance of this data */
    lk = xmlListLinkReverseSearch(l, data);
    if (lk != NULL) {
    xmlLinkDeallocator(l, lk);
        return 1;
    }
    return 0;
}

◆ xmlListReverse()

void xmlListReverse ( xmlListPtr l )

xmlListReverse: @l: a list

Reverse the order of the elements in the list

Definition at line 618 of file list.c.

{
    xmlLinkPtr lk;
    xmlLinkPtr lkPrev;
 
    if (l == NULL)
        return;
    lkPrev = l->sentinel;
    for (lk = l->sentinel->next; lk != l->sentinel; lk = lk->next) {
        lkPrev->next = lkPrev->prev;
        lkPrev->prev = lk;
        lkPrev = lk;
    }
    /* Fix up the last node */
    lkPrev->next = lkPrev->prev;
    lkPrev->prev = lk;
}

◆ xmlListReverseSearch()

void * xmlListReverseSearch	(	xmlListPtr	l,
		void *	data
	)

xmlListReverseSearch: @l: a list @data: a search value

Search the list in reverse order for an existing value of @data

Returns the value associated to @data or NULL in case of error

Definition at line 252 of file list.c.

{
    xmlLinkPtr lk;
    if (l == NULL)
        return(NULL);
    lk = xmlListLinkReverseSearch(l, data);
    if (lk)
        return (lk->data);
    return NULL;
}

◆ xmlListReverseWalk()

void xmlListReverseWalk	(	xmlListPtr	l,
		xmlListWalker	walker,
		void *	user
	)

xmlListReverseWalk: @l: a list @walker: a processing function @user: a user parameter passed to the walker function

Walk all the element of the list in reverse order and apply the walker function to it

Definition at line 697 of file list.c.

                                                                   {
    xmlLinkPtr lk;
 
    if ((l == NULL) || (walker == NULL))
        return;
    for(lk = l->sentinel->prev; lk != l->sentinel; lk = lk->prev) {
        if((walker(lk->data, user)) == 0)
                break;
    }
}

◆ xmlListSearch()

void * xmlListSearch	(	xmlListPtr	l,
		void *	data
	)

xmlListSearch: @l: a list @data: a search value

Search the list for an existing value of @data

Returns the value associated to @data or NULL in case of error

Definition at line 231 of file list.c.

{
    xmlLinkPtr lk;
    if (l == NULL)
        return(NULL);
    lk = xmlListLinkSearch(l, data);
    if (lk)
        return (lk->data);
    return NULL;
}

◆ xmlListSize()

int xmlListSize ( xmlListPtr l )

xmlListSize: @l: a list

Get the number of elements in the list

Returns the number of elements in the list or -1 in case of error

Definition at line 494 of file list.c.

{
    xmlLinkPtr lk;
    int count=0;
 
    if (l == NULL)
        return(-1);
    /* TODO: keep a counter in xmlList instead */
    for(lk = l->sentinel->next; lk != l->sentinel; lk = lk->next, count++);
    return count;
}

◆ xmlListSort()

void xmlListSort ( xmlListPtr l )

xmlListSort: @l: a list

Sort all the elements in the list

Definition at line 643 of file list.c.

{
    xmlListPtr lTemp;
 
    if (l == NULL)
        return;
    if(xmlListEmpty(l))
        return;
 
    /* I think that the real answer is to implement quicksort, the
     * alternative is to implement some list copying procedure which
     * would be based on a list copy followed by a clear followed by
     * an insert. This is slow...
     */
 
    if (NULL ==(lTemp = xmlListDup(l)))
        return;
    xmlListClear(l);
    xmlListMerge(l, lTemp);
    xmlListDelete(lTemp);
    return;
}

◆ xmlListWalk()

void xmlListWalk	(	xmlListPtr	l,
		xmlListWalker	walker,
		void *	user
	)

xmlListWalk: @l: a list @walker: a processing function @user: a user parameter passed to the walker function

Walk all the element of the first from first to last and apply the walker function to it

Definition at line 676 of file list.c.

                                                            {
    xmlLinkPtr lk;
 
    if ((l == NULL) || (walker == NULL))
        return;
    for(lk = l->sentinel->next; lk != l->sentinel; lk = lk->next) {
        if((walker(lk->data, user)) == 0)
                break;
    }
}

Referenced by xmlRemoveRef().

Classes

Macros

Functions

Macro Definition Documentation

◆ IN_LIBXML

Function Documentation

◆ xmlLinkCompare()

◆ xmlLinkDeallocator()

◆ xmlLinkGetData()

◆ xmlListAppend()

◆ xmlListClear()

◆ xmlListCopy()

◆ xmlListCreate()

◆ xmlListDelete()

◆ xmlListDup()

◆ xmlListEmpty()

◆ xmlListEnd()

◆ xmlListFront()

◆ xmlListHigherSearch()

◆ xmlListInsert()

◆ xmlListLinkReverseSearch()

◆ xmlListLinkSearch()

◆ xmlListLowerSearch()

◆ xmlListMerge()

◆ xmlListPopBack()

◆ xmlListPopFront()

◆ xmlListPushBack()

◆ xmlListPushFront()

◆ xmlListRemoveAll()

◆ xmlListRemoveFirst()

◆ xmlListRemoveLast()

◆ xmlListReverse()

◆ xmlListReverseSearch()

◆ xmlListReverseWalk()

◆ xmlListSearch()

◆ xmlListSize()

◆ xmlListSort()

◆ xmlListWalk()