You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
144 lines
4.3 KiB
144 lines
4.3 KiB
/*
|
|
* Copyright 2006, 2007 Daniel Silverstone <dsilvers@digital-scurf.org>
|
|
*
|
|
* This file is part of NetSurf, http://www.netsurf-browser.org/
|
|
*
|
|
* NetSurf 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; version 2 of the License.
|
|
*
|
|
* NetSurf 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, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/** \file
|
|
* Ring list structure.
|
|
*
|
|
* Rings are structures which have an r_next pointer and an r_prev
|
|
* pointer which are always initialised and always point at the next
|
|
* or previous element respectively.
|
|
*
|
|
* The degenerate case of a single element in the ring simply points
|
|
* at itself in both directions. A zero element ring is NULL.
|
|
*
|
|
* Some of the ring functions are specific to the fetcher but may be
|
|
* of use to others and are thus included here.
|
|
*/
|
|
|
|
#ifndef _NETSURF_UTILS_RING_H_
|
|
#define _NETSURF_UTILS_RING_H_
|
|
|
|
|
|
/** Insert the given item into the specified ring.
|
|
* Assumes that the element is zeroed as appropriate.
|
|
*/
|
|
#define RING_INSERT(ring,element) \
|
|
/*LOG("RING_INSERT(%s, %p(%s))", #ring, element, element->host);*/ \
|
|
if (ring) { \
|
|
element->r_next = ring; \
|
|
element->r_prev = ring->r_prev; \
|
|
ring->r_prev = element; \
|
|
element->r_prev->r_next = element; \
|
|
} else \
|
|
ring = element->r_prev = element->r_next = element
|
|
|
|
/** Remove the given element from the specified ring.
|
|
* Will zero the element as needed
|
|
*/
|
|
#define RING_REMOVE(ring, element) \
|
|
/*LOG("RING_REMOVE(%s, %p(%s)", #ring, element, element->host);*/ \
|
|
if (element->r_next != element ) { \
|
|
/* Not the only thing in the ring */ \
|
|
element->r_next->r_prev = element->r_prev; \
|
|
element->r_prev->r_next = element->r_next; \
|
|
if (ring == element) ring = element->r_next; \
|
|
} else { \
|
|
/* Only thing in the ring */ \
|
|
ring = 0; \
|
|
} \
|
|
element->r_next = element->r_prev = 0
|
|
|
|
/** Find the element (by hostname) in the given ring, leave it in the
|
|
* provided element variable
|
|
*/
|
|
#define RING_FINDBYLWCHOST(ring, element, lwc_hostname) \
|
|
/*LOG("RING_FINDBYHOST(%s, %s)", #ring, hostname);*/ \
|
|
if (ring) { \
|
|
bool found = false; \
|
|
element = ring; \
|
|
do { \
|
|
if (lwc_string_isequal(element->host, lwc_hostname, \
|
|
&found) == lwc_error_ok && \
|
|
found == true) { \
|
|
break; \
|
|
} \
|
|
element = element->r_next; \
|
|
} while (element != ring); \
|
|
if (!found) element = 0; \
|
|
} else element = 0
|
|
|
|
/** Measure the size of a ring and put it in the supplied variable */
|
|
#define RING_GETSIZE(ringtype, ring, sizevar) \
|
|
/*LOG("RING_GETSIZE(%s)", #ring);*/ \
|
|
if (ring) { \
|
|
ringtype *p = ring; \
|
|
sizevar = 0; \
|
|
do { \
|
|
sizevar++; \
|
|
p = p->r_next; \
|
|
} while (p != ring); \
|
|
} else sizevar = 0
|
|
|
|
/** Count the number of elements in the ring which match the provided lwc_hostname */
|
|
#define RING_COUNTBYLWCHOST(ringtype, ring, sizevar, lwc_hostname) \
|
|
/*LOG("RING_COUNTBYHOST(%s, %s)", #ring, hostname);*/ \
|
|
if (ring) { \
|
|
ringtype *p = ring; \
|
|
sizevar = 0; \
|
|
do { \
|
|
bool matches = false; \
|
|
/* nsurl guarantees lowercase host */ \
|
|
if (lwc_string_isequal(p->host, lwc_hostname, \
|
|
&matches) == lwc_error_ok) \
|
|
if (matches) \
|
|
sizevar++; \
|
|
p = p->r_next; \
|
|
} while (p != ring); \
|
|
} else sizevar = 0
|
|
|
|
/*
|
|
* Ring iteration works as follows:
|
|
*
|
|
* RING_ITERATE_START(ringtype, ring, iteratorptr) {
|
|
* code_using(iteratorptr);
|
|
* } RING_ITERATE_END(ring, iteratorptr);
|
|
*
|
|
* If you want to stop iterating (e.g. you found your answer)
|
|
* RING_ITERATE_STOP(ring, iteratorptr);
|
|
* You *MUST* abort the iteration if you do something to modify
|
|
* the ring such as deleting or adding an element.
|
|
*/
|
|
|
|
#define RING_ITERATE_START(ringtype, ring, iteratorptr) \
|
|
if (ring != NULL) { \
|
|
ringtype *iteratorptr = ring; \
|
|
do { \
|
|
do { \
|
|
|
|
#define RING_ITERATE_STOP(ring, iteratorptr) \
|
|
goto iteration_end_ring##_##iteratorptr
|
|
|
|
#define RING_ITERATE_END(ring, iteratorptr) \
|
|
} while (false); \
|
|
iteratorptr = iteratorptr->r_next; \
|
|
} while (iteratorptr != ring); \
|
|
} \
|
|
iteration_end_ring##_##iteratorptr:
|
|
|
|
#endif
|