src/common/list.c

/*
 * Copyright (C) 1998,1999,2000  Ross Combs (rocombs@cs.nmsu.edu)
 *
 * 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.
 */
#define LIST_INTERNAL_ACCESS
#include "common/setup_before.h"
#ifdef HAVE_STDDEF_H
# include <stddef.h>
#else
# ifndef NULL
#  define NULL ((void *)0)
# endif
#endif
#ifdef STDC_HEADERS
# include <stdlib.h>
#else
# ifdef HAVE_MALLOC_H
#  include <malloc.h>
# endif
#endif
#ifdef HAVE_ASSERT_H
# include <assert.h>
#endif
#include "common/eventlog.h"
#include "common/xalloc.h"
#include "common/list.h"
#include "common/setup_after.h"


static t_elem listhead;


extern t_list * list_create(void)
{
    t_list * new;
    
    new = xmalloc(sizeof(t_list));
    new->head = NULL;
    new->tail = NULL;
    new->len = 0;
    
    return new;
}


extern int list_destroy(t_list * list)
{
    if (!list)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
        return -1;
    }
    
    if (list->head)
        eventlog(eventlog_level_error,__FUNCTION__,"got non-empty list");
    
    xfree(list);
    
    return 0;
}

extern unsigned int list_get_length(t_list const * list)
{
    if (!list)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
        return 0;
    }
    
    return list->len;
}


extern int list_prepend_data(t_list * list, void * data)
{
    t_elem * elem;
    
    assert(list != NULL);

    elem = xmalloc(sizeof(t_elem));
    elem->data = data;

    if (list->head)
       list->head->prev = elem;
    elem->next = list->head;
    elem->prev = NULL;
    list->head = elem;
    if (!list->tail)
        list->tail = elem;
    list->len++;
    
    return 0;
}


extern int list_append_data(t_list * list, void * data)
{
    t_elem * elem;
    
    assert(list != NULL);

    elem = xmalloc(sizeof(t_elem));
    elem->data = data;

    elem->next = NULL;
    if (!list->head)
        {
          list->head = elem;
          elem->prev = NULL;
        }
    if (list->tail)
        {
          elem->prev = list->tail;
          list->tail->next = elem;
        }
    list->tail = elem;
    list->len++;
    
    return 0;
}


extern t_elem * list_get_elem_by_data(t_list const * list, void const * data)
{
    t_elem * curr;
    
    if (!list)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
        return NULL;
    }
    
    LIST_TRAVERSE(list,curr)
        if (curr->data==data)
            return curr;
    
    return NULL;
}


extern t_elem const * list_get_elem_by_data_const(t_list const * list, void const * data)
{
    t_elem const * curr;
    
    if (!list)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
        return NULL;
    }
    
    LIST_TRAVERSE_CONST(list,curr)
        if (curr->data==data)
            return curr;
    
    return NULL;
}


extern int list_remove_elem(t_list * list, t_elem ** elem)
{
    t_elem * target;
    
    if (!list)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
        return -1;
    }

    if (!elem)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL *elem");
        return -1;
    }

    target = *elem; 

    if (target->prev)
    {
      target->prev->next = target->next;
    }
    if (target->next)
    {
      target->next->prev = target->prev;
    }

    if (target == list->tail)
    {
      list->tail = target->prev;
    }
    if (target == list->head)
    {
      list->head = target->next;
      *elem = &listhead;
    }
    else
      *elem = target->prev;

    target->next = NULL;
    target->prev = NULL;
    xfree(target);
    
    list->len--;
    
    return 0;
}


extern int list_remove_data(t_list * list, void const * data, t_elem ** elem)
{
    if (!list)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
        return -1;
    }
    
    if (!(*elem = list_get_elem_by_data(list,data)))
        return -1;
    
    return list_remove_elem(list,elem);
}


extern int elem_set_data(t_elem * elem, void * data)
{
    if (!elem)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem");
        return -1;
    }
    
    elem->data = data;
    
    return 0;
}


extern void * elem_get_data(t_elem const * elem)
{
    if (!elem)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem");
        return NULL;
    }
    
    return elem->data;
}


extern void * list_get_data_by_pos(t_list const * list, unsigned int pos)
{
    t_elem const * curr;
    unsigned int   len;
    
    len = 0;
    LIST_TRAVERSE_CONST(list,curr)
        if (len++==pos)
            return curr->data;
    
    eventlog(eventlog_level_error,__FUNCTION__,"requested position %u but len=%u",pos,len);
    return NULL;
}


#ifdef LIST_DEBUG
extern t_elem * list_get_first_real(t_list const * list, char const * fn, unsigned int ln)
#else
extern t_elem * list_get_first(t_list const * list)
#endif
{
    if (!list)
    {
#ifdef LIST_DEBUG
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL list from %s:%u",fn,ln);
#else
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
#endif
        return NULL;
    }
    
    
    return list->head;
}


#ifdef LIST_DEBUG
extern t_elem const * list_get_first_const_real(t_list const * list, char const * fn, unsigned int ln)
#else
extern t_elem const * list_get_first_const(t_list const * list)
#endif
{
    if (!list)
    {
#ifdef LIST_DEBUG
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL list from %s:%u",fn,ln);
#else
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
#endif
        return NULL;
    }
    
    return list->head;
}


extern t_elem * elem_get_next_real(t_list const * list, t_elem const * elem, char const * fn, unsigned int ln)
{
    if (!elem)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem from %s:%u",fn,ln);
        return NULL;
    }
    
    if (elem == &listhead)
        return list->head;
    else
        return elem->next;
}


extern t_elem const * elem_get_next_const(t_list const * list, t_elem const * elem)
{
    if (!elem)
    {
        eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem");
        return NULL;
    }
    
    if (elem == &listhead)
        return list->head;
    else
        return elem->next;
}
1	sysadm	1.1	/*
2			* Copyright (C) 1998,1999,2000 Ross Combs (rocombs@cs.nmsu.edu)
3			*
4			* This program is free software; you can redistribute it and/or
5			* modify it under the terms of the GNU General Public License
6			* as published by the Free Software Foundation; either version 2
7			* of the License, or (at your option) any later version.
8			*
9			* This program is distributed in the hope that it will be useful,
10			* but WITHOUT ANY WARRANTY; without even the implied warranty of
11			* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12			* GNU General Public License for more details.
13			*
14			* You should have received a copy of the GNU General Public License
15			* along with this program; if not, write to the Free Software
16			* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
17			*/
18			#define LIST_INTERNAL_ACCESS
19			#include "common/setup_before.h"
20			#ifdef HAVE_STDDEF_H
21			# include <stddef.h>
22			#else
23			# ifndef NULL
24			# define NULL ((void *)0)
25			# endif
26			#endif
27			#ifdef STDC_HEADERS
28			# include <stdlib.h>
29			#else
30			# ifdef HAVE_MALLOC_H
31			# include <malloc.h>
32			# endif
33			#endif
34			#ifdef HAVE_ASSERT_H
35			# include <assert.h>
36			#endif
37			#include "common/eventlog.h"
38			#include "common/xalloc.h"
39			#include "common/list.h"
40			#include "common/setup_after.h"
41
42
43			static t_elem listhead;
44
45
46			extern t_list * list_create(void)
47			{
48			t_list * new;
49
50			new = xmalloc(sizeof(t_list));
51			new->head = NULL;
52			new->tail = NULL;
53			new->len = 0;
54
55			return new;
56			}
57
58
59			extern int list_destroy(t_list * list)
60			{
61			if (!list)
62			{
63			eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
64			return -1;
65			}
66
67			if (list->head)
68			eventlog(eventlog_level_error,__FUNCTION__,"got non-empty list");
69
70			xfree(list);
71
72			return 0;
73			}
74
75			extern unsigned int list_get_length(t_list const * list)
76			{
77			if (!list)
78			{
79			eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
80			return 0;
81			}
82
83			return list->len;
84			}
85
86
87			extern int list_prepend_data(t_list * list, void * data)
88			{
89			t_elem * elem;
90
91			assert(list != NULL);
92
93			elem = xmalloc(sizeof(t_elem));
94			elem->data = data;
95
96			if (list->head)
97			list->head->prev = elem;
98			elem->next = list->head;
99			elem->prev = NULL;
100			list->head = elem;
101			if (!list->tail)
102			list->tail = elem;
103			list->len++;
104
105			return 0;
106			}
107
108
109			extern int list_append_data(t_list * list, void * data)
110			{
111			t_elem * elem;
112
113			assert(list != NULL);
114
115			elem = xmalloc(sizeof(t_elem));
116			elem->data = data;
117
118			elem->next = NULL;
119			if (!list->head)
120			{
121			list->head = elem;
122			elem->prev = NULL;
123			}
124			if (list->tail)
125			{
126			elem->prev = list->tail;
127			list->tail->next = elem;
128			}
129			list->tail = elem;
130			list->len++;
131
132			return 0;
133			}
134
135
136			extern t_elem * list_get_elem_by_data(t_list const * list, void const * data)
137			{
138			t_elem * curr;
139
140			if (!list)
141			{
142			eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
143			return NULL;
144			}
145
146			LIST_TRAVERSE(list,curr)
147			if (curr->data==data)
148			return curr;
149
150			return NULL;
151			}
152
153
154			extern t_elem const * list_get_elem_by_data_const(t_list const * list, void const * data)
155			{
156			t_elem const * curr;
157
158			if (!list)
159			{
160			eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
161			return NULL;
162			}
163
164			LIST_TRAVERSE_CONST(list,curr)
165			if (curr->data==data)
166			return curr;
167
168			return NULL;
169			}
170
171
172			extern int list_remove_elem(t_list * list, t_elem ** elem)
173			{
174			t_elem * target;
175
176			if (!list)
177			{
178			eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
179			return -1;
180			}
181
182			if (!elem)
183			{
184			eventlog(eventlog_level_error,__FUNCTION__,"got NULL *elem");
185			return -1;
186			}
187
188			target = *elem;
189
190			if (target->prev)
191			{
192			target->prev->next = target->next;
193			}
194			if (target->next)
195			{
196			target->next->prev = target->prev;
197			}
198
199			if (target == list->tail)
200			{
201			list->tail = target->prev;
202			}
203			if (target == list->head)
204			{
205			list->head = target->next;
206			*elem = &listhead;
207			}
208			else
209			*elem = target->prev;
210
211			target->next = NULL;
212			target->prev = NULL;
213			xfree(target);
214
215			list->len--;
216
217			return 0;
218			}
219
220
221			extern int list_remove_data(t_list * list, void const * data, t_elem ** elem)
222			{
223			if (!list)
224			{
225			eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
226			return -1;
227			}
228
229			if (!(*elem = list_get_elem_by_data(list,data)))
230			return -1;
231
232			return list_remove_elem(list,elem);
233			}
234
235
236			extern int elem_set_data(t_elem * elem, void * data)
237			{
238			if (!elem)
239			{
240			eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem");
241			return -1;
242			}
243
244			elem->data = data;
245
246			return 0;
247			}
248
249
250			extern void * elem_get_data(t_elem const * elem)
251			{
252			if (!elem)
253			{
254			eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem");
255			return NULL;
256			}
257
258			return elem->data;
259			}
260
261
262			extern void * list_get_data_by_pos(t_list const * list, unsigned int pos)
263			{
264			t_elem const * curr;
265			unsigned int len;
266
267			len = 0;
268			LIST_TRAVERSE_CONST(list,curr)
269			if (len++==pos)
270			return curr->data;
271
272			eventlog(eventlog_level_error,__FUNCTION__,"requested position %u but len=%u",pos,len);
273			return NULL;
274			}
275
276
277			#ifdef LIST_DEBUG
278			extern t_elem * list_get_first_real(t_list const * list, char const * fn, unsigned int ln)
279			#else
280			extern t_elem * list_get_first(t_list const * list)
281			#endif
282			{
283			if (!list)
284			{
285			#ifdef LIST_DEBUG
286			eventlog(eventlog_level_error,__FUNCTION__,"got NULL list from %s:%u",fn,ln);
287			#else
288			eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
289			#endif
290			return NULL;
291			}
292
293
294			return list->head;
295			}
296
297
298			#ifdef LIST_DEBUG
299			extern t_elem const * list_get_first_const_real(t_list const * list, char const * fn, unsigned int ln)
300			#else
301			extern t_elem const * list_get_first_const(t_list const * list)
302			#endif
303			{
304			if (!list)
305			{
306			#ifdef LIST_DEBUG
307			eventlog(eventlog_level_error,__FUNCTION__,"got NULL list from %s:%u",fn,ln);
308			#else
309			eventlog(eventlog_level_error,__FUNCTION__,"got NULL list");
310			#endif
311			return NULL;
312			}
313
314			return list->head;
315			}
316
317
318			extern t_elem * elem_get_next_real(t_list const * list, t_elem const * elem, char const * fn, unsigned int ln)
319			{
320			if (!elem)
321			{
322			eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem from %s:%u",fn,ln);
323			return NULL;
324			}
325
326			if (elem == &listhead)
327			return list->head;
328			else
329			return elem->next;
330			}
331
332
333			extern t_elem const * elem_get_next_const(t_list const * list, t_elem const * elem)
334			{
335			if (!elem)
336			{
337			eventlog(eventlog_level_error,__FUNCTION__,"got NULL elem");
338			return NULL;
339			}
340
341			if (elem == &listhead)
342			return list->head;
343			else
344			return elem->next;
345			}
webmaster@leafok.com	ViewVC Help
Powered by ViewVC 1.3.0-beta1