/usr/src/redhat/BUILD/httpd-2.2.3/srclib/apr/include/apr_ring.h

説明を見る。

/* Copyright 2000-2005 The Apache Software Foundation or its licensors, as
 * applicable.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

/*
 * This code draws heavily from the 4.4BSD <sys/queue.h> macros
 * and Dean Gaudet's "splim/ring.h".
 * <http://www.freebsd.org/cgi/cvsweb.cgi/src/sys/sys/queue.h>
 * <http://www.arctic.org/~dean/splim/>
 *
 * We'd use Dean's code directly if we could guarantee the
 * availability of inline functions.
 */

#ifndef APR_RING_H
#define APR_RING_H

/*
 * for offsetof()
 */
#include "apr_general.h"

#define APR_RING_ENTRY(elem)                                            \
    struct {                                                            \
        struct elem *next;                                              \
        struct elem *prev;                                              \
    }

#define APR_RING_HEAD(head, elem)                                       \
    struct head {                                                       \
        struct elem *next;                                              \
        struct elem *prev;                                              \
    }

#define APR_RING_SENTINEL(hp, elem, link)                               \
    (struct elem *)((char *)(hp) - APR_OFFSETOF(struct elem, link))

#define APR_RING_FIRST(hp)      (hp)->next

#define APR_RING_LAST(hp)       (hp)->prev

#define APR_RING_NEXT(ep, link) (ep)->link.next

#define APR_RING_PREV(ep, link) (ep)->link.prev


#define APR_RING_INIT(hp, elem, link) do {                              \
        APR_RING_FIRST((hp)) = APR_RING_SENTINEL((hp), elem, link);     \
        APR_RING_LAST((hp))  = APR_RING_SENTINEL((hp), elem, link);     \
    } while (0)

#define APR_RING_EMPTY(hp, elem, link)                                  \
    (APR_RING_FIRST((hp)) == APR_RING_SENTINEL((hp), elem, link))

#define APR_RING_ELEM_INIT(ep, link) do {                               \
        APR_RING_NEXT((ep), link) = (ep);                               \
        APR_RING_PREV((ep), link) = (ep);                               \
    } while (0)


#define APR_RING_SPLICE_BEFORE(lep, ep1, epN, link) do {                \
        APR_RING_NEXT((epN), link) = (lep);                             \
        APR_RING_PREV((ep1), link) = APR_RING_PREV((lep), link);        \
        APR_RING_NEXT(APR_RING_PREV((lep), link), link) = (ep1);        \
        APR_RING_PREV((lep), link) = (epN);                             \
    } while (0)

#define APR_RING_SPLICE_AFTER(lep, ep1, epN, link) do {                 \
        APR_RING_PREV((ep1), link) = (lep);                             \
        APR_RING_NEXT((epN), link) = APR_RING_NEXT((lep), link);        \
        APR_RING_PREV(APR_RING_NEXT((lep), link), link) = (epN);        \
        APR_RING_NEXT((lep), link) = (ep1);                             \
    } while (0)

#define APR_RING_INSERT_BEFORE(lep, nep, link)                          \
        APR_RING_SPLICE_BEFORE((lep), (nep), (nep), link)

#define APR_RING_INSERT_AFTER(lep, nep, link)                           \
        APR_RING_SPLICE_AFTER((lep), (nep), (nep), link)


#define APR_RING_SPLICE_HEAD(hp, ep1, epN, elem, link)                  \
        APR_RING_SPLICE_AFTER(APR_RING_SENTINEL((hp), elem, link),      \
                             (ep1), (epN), link)

#define APR_RING_SPLICE_TAIL(hp, ep1, epN, elem, link)                  \
        APR_RING_SPLICE_BEFORE(APR_RING_SENTINEL((hp), elem, link),     \
                             (ep1), (epN), link)

#define APR_RING_INSERT_HEAD(hp, nep, elem, link)                       \
        APR_RING_SPLICE_HEAD((hp), (nep), (nep), elem, link)

#define APR_RING_INSERT_TAIL(hp, nep, elem, link)                       \
        APR_RING_SPLICE_TAIL((hp), (nep), (nep), elem, link)

#define APR_RING_CONCAT(h1, h2, elem, link) do {                        \
        if (!APR_RING_EMPTY((h2), elem, link)) {                        \
            APR_RING_SPLICE_BEFORE(APR_RING_SENTINEL((h1), elem, link), \
                                  APR_RING_FIRST((h2)),                 \
                                  APR_RING_LAST((h2)), link);           \
            APR_RING_INIT((h2), elem, link);                            \
        }                                                               \
    } while (0)

#define APR_RING_PREPEND(h1, h2, elem, link) do {                       \
        if (!APR_RING_EMPTY((h2), elem, link)) {                        \
            APR_RING_SPLICE_AFTER(APR_RING_SENTINEL((h1), elem, link),  \
                                  APR_RING_FIRST((h2)),                 \
                                  APR_RING_LAST((h2)), link);           \
            APR_RING_INIT((h2), elem, link);                            \
        }                                                               \
    } while (0)

#define APR_RING_UNSPLICE(ep1, epN, link) do {                          \
        APR_RING_NEXT(APR_RING_PREV((ep1), link), link) =               \
                     APR_RING_NEXT((epN), link);                        \
        APR_RING_PREV(APR_RING_NEXT((epN), link), link) =               \
                     APR_RING_PREV((ep1), link);                        \
    } while (0)

#define APR_RING_REMOVE(ep, link)                                       \
    APR_RING_UNSPLICE((ep), (ep), link)


/* Debugging tools: */

#ifdef APR_RING_DEBUG
#include <stdio.h>
#include <assert.h>

#define APR_RING_CHECK_ONE(msg, ptr)                                    \
        fprintf(stderr, "*** %s %p\n", msg, ptr)

#define APR_RING_CHECK(hp, elem, link, msg)                             \
        APR_RING_CHECK_ELEM(APR_RING_SENTINEL(hp, elem, link), elem, link, msg)

#define APR_RING_CHECK_ELEM(ep, elem, link, msg) do {                   \
        struct elem *start = (ep);                                      \
        struct elem *here = start;                                      \
        fprintf(stderr, "*** ring check start -- %s\n", msg);           \
        do {                                                            \
            fprintf(stderr, "\telem %p\n", here);                       \
            fprintf(stderr, "\telem->next %p\n",                        \
                    APR_RING_NEXT(here, link));                         \
            fprintf(stderr, "\telem->prev %p\n",                        \
                    APR_RING_PREV(here, link));                         \
            fprintf(stderr, "\telem->next->prev %p\n",                  \
                    APR_RING_PREV(APR_RING_NEXT(here, link), link));    \
            fprintf(stderr, "\telem->prev->next %p\n",                  \
                    APR_RING_NEXT(APR_RING_PREV(here, link), link));    \
            if (APR_RING_PREV(APR_RING_NEXT(here, link), link) != here) { \
                fprintf(stderr, "\t*** elem->next->prev != elem\n");    \
                break;                                                  \
            }                                                           \
            if (APR_RING_NEXT(APR_RING_PREV(here, link), link) != here) { \
                fprintf(stderr, "\t*** elem->prev->next != elem\n");    \
                break;                                                  \
            }                                                           \
            here = APR_RING_NEXT(here, link);                           \
        } while (here != start);                                        \
        fprintf(stderr, "*** ring check end\n");                        \
    } while (0)

#define APR_RING_CHECK_CONSISTENCY(hp, elem, link)                      \
        APR_RING_CHECK_ELEM_CONSISTENCY(APR_RING_SENTINEL(hp, elem, link),\
                                        elem, link)

#define APR_RING_CHECK_ELEM_CONSISTENCY(ep, elem, link) do {            \
        struct elem *start = (ep);                                      \
        struct elem *here = start;                                      \
        do {                                                            \
            assert(APR_RING_PREV(APR_RING_NEXT(here, link), link) == here); \
            assert(APR_RING_NEXT(APR_RING_PREV(here, link), link) == here); \
            here = APR_RING_NEXT(here, link);                           \
        } while (here != start);                                        \
    } while (0)

#else

#define APR_RING_CHECK_ONE(msg, ptr)

#define APR_RING_CHECK(hp, elem, link, msg)

#define APR_RING_CHECK_CONSISTENCY(hp, elem, link)

#define APR_RING_CHECK_ELEM(ep, elem, link, msg)

#define APR_RING_CHECK_ELEM_CONSISTENCY(ep, elem, link)
#endif

#endif /* !APR_RING_H */

---