idlist.c - fetchmail in fetchmail

/**
 * \file idlist.c -- string list handling
 *
 * For license terms, see the file COPYING in this directory.
 */

#include "config.h"

#include <sys/stat.h>
#include <errno.h>
#include <stdio.h>
#include <limits.h>
#if defined(STDC_HEADERS)
#include <stdlib.h>
#include <string.h>
#endif
#if defined(HAVE_UNISTD_H)
#include <unistd.h>
#endif

#include "fetchmail.h"

/** Save string \a str to idlist \a idl with status \a status.
 * \return Pointer to the last element of the list to help the quick,
 * constant-time addition to the list. */
/*@shared@*/ static
struct idlist **save_str_quick(/*@shared@*/ struct idlist **idl,
			       /*@only@*/ char *str /** caller-allocated string */, flag status)
/* save a number/UID pair on the given UID list */
{
    struct idlist **end;

    /* do it nonrecursively so the list is in the right order */
    for (end = idl; *end; end = &(*end)->next)
	continue;

    *end = (struct idlist *)xmalloc(sizeof(struct idlist));
    (*end)->id = str;
    (*end)->val.status.mark = status;
    (*end)->val.status.num = 0;
    (*end)->next = NULL;

    return end;
}

/** Save string \a str to idlist \a idl with status \a status.
 * \return the end list element for direct modification. */
struct idlist *save_str(struct idlist **idl, const char *str /** implicitly strdup()ed */, flag status)
{
    return *save_str_quick(idl, str ? xstrdup(str) : NULL, status);
}

/** Free string list \a idl and free each of the id members. */
void free_str_list(struct idlist **idl)
{
    struct idlist *i = *idl;

    while(i) {
	struct idlist *t = i->next;
	free(i->id);
	free(i);
	i = t;
    }
    *idl = 0;
}

/** Save an ID pair made of \a str1 and \a str2 on the given idlist \a idl. */
void save_str_pair(struct idlist **idl, const char *str1, const char *str2)
{
    struct idlist **end;

    /* do it nonrecursively so the list is in the right order */
    for (end = idl; *end; end = &(*end)->next)
	continue;

    *end = (struct idlist *)xmalloc(sizeof(struct idlist));
    (*end)->id = str1 ? xstrdup(str1) : (char *)NULL;
    if (str2)
	(*end)->val.id2 = xstrdup(str2);
    else
	(*end)->val.id2 = (char *)NULL;
    (*end)->next = (struct idlist *)NULL;
}

#ifdef __UNUSED__
void free_str_pair_list(struct idlist **idl)
/* free the given ID pair list */
{
    if (*idl == (struct idlist *)NULL)
	return;

    free_idpair_list(&(*idl)->next);
    free ((*idl)->id);
    free ((*idl)->val.id2);
    free(*idl);
    *idl = (struct idlist *)NULL;
}
#endif

/** Check if ID \a str is in idlist \a idl. \return idlist entry if found,
 * NULL if not found. */
struct idlist *str_in_list(struct idlist **idl, const char *str,
const flag caseblind /** if true, use strcasecmp, if false, use strcmp */)
{
    struct idlist *walk;
    if (caseblind) {
	for( walk = *idl; walk; walk = walk->next )
	    if( strcasecmp( str, walk->id) == 0 )
		return walk;
    } else {
	for( walk = *idl; walk; walk = walk->next )
	    if( strcmp( str, walk->id) == 0 )
		return walk;
    }
    return NULL;
}

/** \return position of first occurrence of \a str in idlist \a idl */
int str_nr_in_list(struct idlist **idl, const char *str)
{
    int nr;
    struct idlist *walk;

    if (!str)
        return -1;
    for (walk = *idl, nr = 0; walk; nr ++, walk = walk->next)
        if (strcmp(str, walk->id) == 0)
	    return nr;
    return -1;
}

/** \return position of last occurrence of \a str in idlist \a idl */
int str_nr_last_in_list( struct idlist **idl, const char *str)
{
    int nr, ret = -1;
    struct idlist *walk;
    if ( !str )
        return -1;
    for( walk = *idl, nr = 0; walk; nr ++, walk = walk->next )
        if( strcmp( str, walk->id) == 0 )
	    ret = nr;
    return ret;
}

/** Update the mark of an id \a str in idlist \a idl to given value \a val. */
void str_set_mark( struct idlist **idl, const char *str, const flag val)
{
    int nr;
    struct idlist *walk;
    if (!str)
        return;
    for(walk = *idl, nr = 0; walk; nr ++, walk = walk->next)
        if (strcmp(str, walk->id) == 0)
	    walk->val.status.mark = val;
}

/** Count the number of elements in the idlist \a idl. 
 * \return number of elements */
int count_list(struct idlist **idl)
{
	int i = 0;
	struct idlist *it;

	for (it = *idl ; it ; it = it->next)
		++i;

	return i;
}

/** return the \a number'th id string on idlist \a idl */
/*@null@*/ char *str_from_nr_list(struct idlist **idl, long number)
{
    if( !*idl  || number < 0)
        return 0;
    if( number == 0 )
        return (*idl)->id;
    return str_from_nr_list(&(*idl)->next, number-1);
}


/** Search idlist \a idl for entry with given \a number.
 * \return id member of idlist entry. */
char *str_find(struct idlist **idl, long number)
{
    if (*idl == (struct idlist *) 0)
	return((char *) 0);
    else if (number == (*idl)->val.status.num)
	return((*idl)->id);
    else
	return(str_find(&(*idl)->next, number));
}

/** Search idlist \a idl for entry with given \a number.
 * \return idlist entry. */
struct idlist *id_find(struct idlist **idl, long number)
{
    struct idlist	*idp;
    for (idp = *idl; idp; idp = idp->next)
	if (idp->val.status.num == number)
	    return(idp);
    return(0);
}

/** Return the id of the given \a id in the given idlist \a idl, comparing
 * case insensitively. \returns the respective other \a idlist member (the one
 * that was not searched for). */
char *idpair_find(struct idlist **idl, const char *id)
{
    if (*idl == (struct idlist *) 0)
	return((char *) 0);
    else if (strcasecmp(id, (*idl)->id) == 0)
	return((*idl)->val.id2 ? (*idl)->val.id2 : (*idl)->id);
    else
	return(idpair_find(&(*idl)->next, id));
}

/** Mark message number \a num on given idlist \a idl as deleted.
 * \return 1 if found, 0 if not found. */
int delete_str(struct idlist **idl, long num)
{
    struct idlist	*idp;

    for (idp = *idl; idp; idp = idp->next)
	if (idp->val.status.num == num)
	{
	    idp->val.status.mark = UID_DELETED;
	    return(1);
	}
    return(0);
}

/** Copy the given UID list \a idl. \return A newly malloc()ed copy of the list. */
struct idlist *copy_str_list(struct idlist *idl)
{
    struct idlist *newnode ;

    if (idl == (struct idlist *)NULL)
	return(NULL);
    else
    {
	newnode = (struct idlist *)xmalloc(sizeof(struct idlist));
	memcpy(newnode, idl, sizeof(struct idlist));
	newnode->next = copy_str_list(idl->next);
	return(newnode);
    }
}

/** Append \a nidl to \a idl (does not copy *) */
void append_str_list(struct idlist **idl, struct idlist **nidl)
{
    if ((*nidl) == (struct idlist *)NULL || *nidl == *idl)
	return;
    else if ((*idl) == (struct idlist *)NULL)
	*idl = *nidl;
    else if ((*idl)->next == (struct idlist *)NULL)
	(*idl)->next = *nidl;
    else if ((*idl)->next != *nidl)
	append_str_list(&(*idl)->next, nidl);
}

/* idlist.c ends here */

1	/**
2	* \file idlist.c -- string list handling
3	*
4	* For license terms, see the file COPYING in this directory.
5	*/
6
7	#include "config.h"
8
9	#include <sys/stat.h>
10	#include <errno.h>
11	#include <stdio.h>
12	#include <limits.h>
13	#if defined(STDC_HEADERS)
14	#include <stdlib.h>
15	#include <string.h>
16	#endif
17	#if defined(HAVE_UNISTD_H)
18	#include <unistd.h>
19	#endif
20
21	#include "fetchmail.h"
22
23	/** Save string \a str to idlist \a idl with status \a status.
24	* \return Pointer to the last element of the list to help the quick,
25	* constant-time addition to the list. */
26	/@shared@/ static
27	struct idlist *save_str_quick(/@shared@/ struct idlist *idl,
28	/@only@/ char str /* caller-allocated string */, flag status)
29	/* save a number/UID pair on the given UID list */
30	{
31	struct idlist **end;
32
33	/* do it nonrecursively so the list is in the right order */
34	for (end = idl; end; end = &(end)->next)
35	continue;
36
37	end = (struct idlist )xmalloc(sizeof(struct idlist));
38	(*end)->id = str;
39	(*end)->val.status.mark = status;
40	(*end)->val.status.num = 0;
41	(*end)->next = NULL;
42
43	return end;
44	}
45
46	/** Save string \a str to idlist \a idl with status \a status.
47	* \return the end list element for direct modification. */
48	struct idlist save_str(struct idlist idl, const char str /** implicitly strdup()ed */, flag status)
49	{
50	return *save_str_quick(idl, str ? xstrdup(str) : NULL, status);
51	}
52
53	/** Free string list \a idl and free each of the id members. */
54	void free_str_list(struct idlist **idl)
55	{
56	struct idlist i = idl;
57
58	while(i) {
59	struct idlist *t = i->next;
60	free(i->id);
61	free(i);
62	i = t;
63	}
64	*idl = 0;
65	}
66
67	/** Save an ID pair made of \a str1 and \a str2 on the given idlist \a idl. */
68	void save_str_pair(struct idlist *idl, const char str1, const char *str2)
69	{
70	struct idlist **end;
71
72	/* do it nonrecursively so the list is in the right order */
73	for (end = idl; end; end = &(end)->next)
74	continue;
75
76	end = (struct idlist )xmalloc(sizeof(struct idlist));
77	(end)->id = str1 ? xstrdup(str1) : (char )NULL;
78	if (str2)
79	(*end)->val.id2 = xstrdup(str2);
80	else
81	(end)->val.id2 = (char )NULL;
82	(end)->next = (struct idlist )NULL;
83	}
84
85	#ifdef __UNUSED__
86	void free_str_pair_list(struct idlist **idl)
87	/* free the given ID pair list */
88	{
89	if (idl == (struct idlist )NULL)
90	return;
91
92	free_idpair_list(&(*idl)->next);
93	free ((*idl)->id);
94	free ((*idl)->val.id2);
95	free(*idl);
96	idl = (struct idlist )NULL;
97	}
98	#endif
99
100	/** Check if ID \a str is in idlist \a idl. \return idlist entry if found,
101	* NULL if not found. */
102	struct idlist str_in_list(struct idlist idl, const char str,
103	const flag caseblind /** if true, use strcasecmp, if false, use strcmp */)
104	{
105	struct idlist *walk;
106	if (caseblind) {
107	for( walk = *idl; walk; walk = walk->next )
108	if( strcasecmp( str, walk->id) == 0 )
109	return walk;
110	} else {
111	for( walk = *idl; walk; walk = walk->next )
112	if( strcmp( str, walk->id) == 0 )
113	return walk;
114	}
115	return NULL;
116	}
117
118	/** \return position of first occurrence of \a str in idlist \a idl */
119	int str_nr_in_list(struct idlist *idl, const char str)
120	{
121	int nr;
122	struct idlist *walk;
123
124	if (!str)
125	return -1;
126	for (walk = *idl, nr = 0; walk; nr ++, walk = walk->next)
127	if (strcmp(str, walk->id) == 0)
128	return nr;
129	return -1;
130	}
131
132	/** \return position of last occurrence of \a str in idlist \a idl */
133	int str_nr_last_in_list( struct idlist *idl, const char str)
134	{
135	int nr, ret = -1;
136	struct idlist *walk;
137	if ( !str )
138	return -1;
139	for( walk = *idl, nr = 0; walk; nr ++, walk = walk->next )
140	if( strcmp( str, walk->id) == 0 )
141	ret = nr;
142	return ret;
143	}
144
145	/** Update the mark of an id \a str in idlist \a idl to given value \a val. */
146	void str_set_mark( struct idlist *idl, const char str, const flag val)
147	{
148	int nr;
149	struct idlist *walk;
150	if (!str)
151	return;
152	for(walk = *idl, nr = 0; walk; nr ++, walk = walk->next)
153	if (strcmp(str, walk->id) == 0)
154	walk->val.status.mark = val;
155	}
156
157	/** Count the number of elements in the idlist \a idl.
158	* \return number of elements */
159	int count_list(struct idlist **idl)
160	{
161	int i = 0;
162	struct idlist *it;
163
164	for (it = *idl ; it ; it = it->next)
165	++i;
166
167	return i;
168	}
169
170	/** return the \a number'th id string on idlist \a idl */
171	/@null@/ char str_from_nr_list(struct idlist *idl, long number)
172	{
173	if( !*idl \|\| number < 0)
174	return 0;
175	if( number == 0 )
176	return (*idl)->id;
177	return str_from_nr_list(&(*idl)->next, number-1);
178	}
179
180
181	/** Search idlist \a idl for entry with given \a number.
182	* \return id member of idlist entry. */
183	char str_find(struct idlist *idl, long number)
184	{
185	if (idl == (struct idlist ) 0)
186	return((char *) 0);
187	else if (number == (*idl)->val.status.num)
188	return((*idl)->id);
189	else
190	return(str_find(&(*idl)->next, number));
191	}
192
193	/** Search idlist \a idl for entry with given \a number.
194	* \return idlist entry. */
195	struct idlist id_find(struct idlist *idl, long number)
196	{
197	struct idlist *idp;
198	for (idp = *idl; idp; idp = idp->next)
199	if (idp->val.status.num == number)
200	return(idp);
201	return(0);
202	}
203
204	/** Return the id of the given \a id in the given idlist \a idl, comparing
205	* case insensitively. \returns the respective other \a idlist member (the one
206	* that was not searched for). */
207	char idpair_find(struct idlist idl, const char id)
208	{
209	if (idl == (struct idlist ) 0)
210	return((char *) 0);
211	else if (strcasecmp(id, (*idl)->id) == 0)
212	return((idl)->val.id2 ? (idl)->val.id2 : (*idl)->id);
213	else
214	return(idpair_find(&(*idl)->next, id));
215	}
216
217	/** Mark message number \a num on given idlist \a idl as deleted.
218	* \return 1 if found, 0 if not found. */
219	int delete_str(struct idlist **idl, long num)
220	{
221	struct idlist *idp;
222
223	for (idp = *idl; idp; idp = idp->next)
224	if (idp->val.status.num == num)
225	{
226	idp->val.status.mark = UID_DELETED;
227	return(1);
228	}
229	return(0);
230	}
231
232	/** Copy the given UID list \a idl. \return A newly malloc()ed copy of the list. */
233	struct idlist copy_str_list(struct idlist idl)
234	{
235	struct idlist *newnode ;
236
237	if (idl == (struct idlist *)NULL)
238	return(NULL);
239	else
240	{
241	newnode = (struct idlist *)xmalloc(sizeof(struct idlist));
242	memcpy(newnode, idl, sizeof(struct idlist));
243	newnode->next = copy_str_list(idl->next);
244	return(newnode);
245	}
246	}
247
248	/** Append \a nidl to \a idl (does not copy ) /
249	void append_str_list(struct idlist idl, struct idlist nidl)
250	{
251	if ((nidl) == (struct idlist )NULL \|\| nidl == idl)
252	return;
253	else if ((idl) == (struct idlist )NULL)
254	idl = nidl;
255	else if ((idl)->next == (struct idlist )NULL)
256	(idl)->next = nidl;
257	else if ((idl)->next != nidl)
258	append_str_list(&(*idl)->next, nidl);
259	}
260
261	/* idlist.c ends here */

Gitorious