mirror of
https://github.com/llvm/llvm-project.git
synced 2025-04-29 10:46:06 +00:00
cdbec7baf1
Performed en-masse via:
$ grep -rn "#include <ll" libc/include -l | \
xargs perl -pi -e 's/#include <ll(.*)>/#include "ll$1"/'
$ grep -rn "#include <__" libc/include -l | \
xargs perl -pi -e 's/#include <__(.*)>/#include "__$1"/'
Link: #83463
Link: #83210
263 lines
14 KiB
C++
263 lines
14 KiB
C++
//===-- Macros defined in sys/queue.h header file -------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_LIBC_MACROS_SYS_QUEUE_MACROS_H
|
|
#define LLVM_LIBC_MACROS_SYS_QUEUE_MACROS_H
|
|
|
|
#include "llvm-libc-macros/containerof-macro.h"
|
|
#include "llvm-libc-macros/null-macro.h"
|
|
|
|
#ifdef __cplusplus
|
|
#define QUEUE_TYPEOF(type) type
|
|
#else
|
|
#define QUEUE_TYPEOF(type) struct type
|
|
#endif
|
|
|
|
// Singly-linked list definitions.
|
|
|
|
#define SLIST_HEAD(name, type) \
|
|
struct name { \
|
|
struct type *slh_first; \
|
|
}
|
|
|
|
#define SLIST_CLASS_HEAD(name, type) \
|
|
struct name { \
|
|
class type *slh_first; \
|
|
}
|
|
|
|
#define SLIST_HEAD_INITIALIZER(head) \
|
|
{ NULL }
|
|
|
|
#define SLIST_ENTRY(type) \
|
|
struct { \
|
|
struct type *next; \
|
|
}
|
|
|
|
#define SLIST_CLASS_ENTRY(type) \
|
|
struct { \
|
|
class type *next; \
|
|
}
|
|
|
|
// Singly-linked list access methods.
|
|
|
|
#define SLIST_EMPTY(head) ((head)->slh_first == NULL)
|
|
#define SLIST_FIRST(head) ((head)->slh_first)
|
|
#define SLIST_NEXT(elem, field) ((elem)->field.next)
|
|
|
|
#define SLIST_FOREACH(var, head, field) \
|
|
for ((var) = SLIST_FIRST(head); (var); (var) = SLIST_NEXT(var, field))
|
|
|
|
#define SLIST_FOREACH_FROM(var, head, field) \
|
|
if (!(var)) \
|
|
(var) = SLIST_FIRST(head); \
|
|
for (; (var); (var) = SLIST_NEXT(var, field))
|
|
|
|
#define SLIST_FOREACH_SAFE(var, head, field, tvar) \
|
|
for ((var) = SLIST_FIRST(head); \
|
|
(var) && ((tvar) = SLIST_NEXT(var, field), 1); (var) = (tvar))
|
|
|
|
#define SLIST_FOREACH_FROM_SAFE(var, head, field, tvar) \
|
|
if (!(var)) \
|
|
(var) = SLIST_FIRST(head); \
|
|
for (; (var) && ((tvar) = SLIST_NEXT(var, field), 1); (var) = (tvar))
|
|
|
|
// Singly-linked list functions.
|
|
|
|
#define SLIST_CONCAT(head1, head2, type, field) \
|
|
do { \
|
|
if (SLIST_EMPTY(head1)) { \
|
|
if ((SLIST_FIRST(head1) = SLIST_FIRST(head2)) != NULL) \
|
|
SLIST_INIT(head2); \
|
|
} else if (!SLIST_EMPTY(head2)) { \
|
|
QUEUE_TYPEOF(type) *cur = SLIST_FIRST(head1); \
|
|
while (SLIST_NEXT(cur, field) != NULL) \
|
|
cur = SLIST_NEXT(cur, field); \
|
|
SLIST_NEXT(cur, field) = SLIST_FIRST(head2); \
|
|
SLIST_INIT(head2); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define SLIST_INIT(head) \
|
|
do { \
|
|
SLIST_FIRST(head) = NULL; \
|
|
} while (0)
|
|
|
|
#define SLIST_INSERT_AFTER(slistelem, elem, field) \
|
|
do { \
|
|
SLIST_NEXT(elem, field) = SLIST_NEXT(slistelem, field); \
|
|
SLIST_NEXT(slistelem, field) = (elem); \
|
|
} while (0)
|
|
|
|
#define SLIST_INSERT_HEAD(head, elem, field) \
|
|
do { \
|
|
SLIST_NEXT(elem, field) = SLIST_FIRST(head); \
|
|
SLIST_FIRST(head) = (elem); \
|
|
} while (0)
|
|
|
|
#define SLIST_REMOVE(head, elem, type, field) \
|
|
do { \
|
|
if (SLIST_FIRST(head) == (elem)) { \
|
|
SLIST_REMOVE_HEAD(head, field); \
|
|
} else { \
|
|
QUEUE_TYPEOF(type) *cur = SLIST_FIRST(head); \
|
|
while (SLIST_NEXT(cur, field) != (elem)) \
|
|
cur = SLIST_NEXT(cur, field); \
|
|
SLIST_REMOVE_AFTER(cur, field); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define SLIST_REMOVE_AFTER(elem, field) \
|
|
do { \
|
|
SLIST_NEXT(elem, field) = SLIST_NEXT(SLIST_NEXT(elem, field), field); \
|
|
} while (0)
|
|
|
|
#define SLIST_REMOVE_HEAD(head, field) \
|
|
do { \
|
|
SLIST_FIRST(head) = SLIST_NEXT(SLIST_FIRST(head), field); \
|
|
} while (0)
|
|
|
|
#define SLIST_SWAP(head1, head2, type) \
|
|
do { \
|
|
QUEUE_TYPEOF(type) *first = SLIST_FIRST(head1); \
|
|
SLIST_FIRST(head1) = SLIST_FIRST(head2); \
|
|
SLIST_FIRST(head2) = first; \
|
|
} while (0)
|
|
|
|
// Singly-linked tail queue definitions.
|
|
|
|
#define STAILQ_HEAD(name, type) \
|
|
struct name { \
|
|
struct type *stqh_first; \
|
|
struct type **stqh_last; \
|
|
}
|
|
|
|
#define STAILQ_CLASS_HEAD(name, type) \
|
|
struct name { \
|
|
class type *stqh_first; \
|
|
class type **stqh_last; \
|
|
}
|
|
|
|
#define STAILQ_HEAD_INITIALIZER(head) \
|
|
{ NULL, &(head).stqh_first }
|
|
|
|
#define STAILQ_ENTRY(type) \
|
|
struct { \
|
|
struct type *next; \
|
|
}
|
|
|
|
#define STAILQ_CLASS_ENTRY(type) \
|
|
struct { \
|
|
class type *next; \
|
|
}
|
|
|
|
// Singly-linked tail queue access methods.
|
|
|
|
#define STAILQ_EMPTY(head) ((head)->stqh_first == NULL)
|
|
#define STAILQ_FIRST(head) ((head)->stqh_first)
|
|
#define STAILQ_LAST(head, type, field) \
|
|
(STAILQ_EMPTY(head) \
|
|
? NULL \
|
|
: __containerof((head)->stqh_last, QUEUE_TYPEOF(type), field.next))
|
|
#define STAILQ_NEXT(elem, field) ((elem)->field.next)
|
|
|
|
#define STAILQ_FOREACH(var, head, field) \
|
|
for ((var) = STAILQ_FIRST(head); (var); (var) = STAILQ_NEXT(var, field))
|
|
|
|
#define STAILQ_FOREACH_FROM(var, head, field) \
|
|
if (!(var)) \
|
|
(var) = STAILQ_FIRST(head); \
|
|
for (; (var); (var) = STAILQ_NEXT(var, field))
|
|
|
|
#define STAILQ_FOREACH_SAFE(var, head, field, tvar) \
|
|
for ((var) = STAILQ_FIRST(head); \
|
|
(var) && ((tvar) = STAILQ_NEXT(var, field), 1); (var) = (tvar))
|
|
|
|
#define STAILQ_FOREACH_FROM_SAFE(var, head, field, tvar) \
|
|
if (!(var)) \
|
|
(var) = STAILQ_FIRST(head); \
|
|
for (; (var) && ((tvar) = STAILQ_NEXT(var, field), 1); (var) = (tvar))
|
|
|
|
// Singly-linked tail queue functions.
|
|
|
|
#define STAILQ_CONCAT(head1, head2, type, field) \
|
|
do { \
|
|
if (!STAILQ_EMPTY(head2)) { \
|
|
*(head1)->stqh_last = (head2)->stqh_first; \
|
|
(head1)->stqh_last = (head2)->stqh_last; \
|
|
STAILQ_INIT(head2); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define STAILQ_INIT(head) \
|
|
do { \
|
|
STAILQ_FIRST(head) = NULL; \
|
|
(head)->stqh_last = &STAILQ_FIRST(head); \
|
|
} while (0)
|
|
|
|
#define STAILQ_INSERT_AFTER(head, listelem, elem, field) \
|
|
do { \
|
|
if ((STAILQ_NEXT(elem, field) = STAILQ_NEXT(listelem, field)) == NULL) \
|
|
(head)->stqh_last = &STAILQ_NEXT(elem, field); \
|
|
STAILQ_NEXT(listelem, field) = (elem); \
|
|
} while (0)
|
|
|
|
#define STAILQ_INSERT_HEAD(head, elem, field) \
|
|
do { \
|
|
if ((STAILQ_NEXT(elem, field) = STAILQ_FIRST(head)) == NULL) \
|
|
(head)->stqh_last = &STAILQ_NEXT(elem, field); \
|
|
STAILQ_FIRST(head) = (elem); \
|
|
} while (0)
|
|
|
|
#define STAILQ_INSERT_TAIL(head, elem, field) \
|
|
do { \
|
|
STAILQ_NEXT(elem, field) = NULL; \
|
|
*(head)->stqh_last = (elem); \
|
|
(head)->stqh_last = &STAILQ_NEXT(elem, field); \
|
|
} while (0)
|
|
|
|
#define STAILQ_REMOVE(head, elem, type, field) \
|
|
do { \
|
|
if (STAILQ_FIRST(head) == (elem)) { \
|
|
STAILQ_REMOVE_HEAD(head, field); \
|
|
} else { \
|
|
QUEUE_TYPEOF(type) *cur = STAILQ_FIRST(head); \
|
|
while (STAILQ_NEXT(cur, field) != (elem)) \
|
|
cur = STAILQ_NEXT(cur, field); \
|
|
STAILQ_REMOVE_AFTER(head, cur, field); \
|
|
} \
|
|
} while (0)
|
|
|
|
#define STAILQ_REMOVE_AFTER(head, elem, field) \
|
|
do { \
|
|
if ((STAILQ_NEXT(elem, field) = \
|
|
STAILQ_NEXT(STAILQ_NEXT(elem, field), field)) == NULL) \
|
|
(head)->stqh_last = &STAILQ_NEXT(elem, field); \
|
|
} while (0)
|
|
|
|
#define STAILQ_REMOVE_HEAD(head, field) \
|
|
do { \
|
|
if ((STAILQ_FIRST(head) = STAILQ_NEXT(STAILQ_FIRST(head), field)) == NULL) \
|
|
(head)->stqh_last = &STAILQ_FIRST(head); \
|
|
} while (0)
|
|
|
|
#define STAILQ_SWAP(head1, head2, type) \
|
|
do { \
|
|
QUEUE_TYPEOF(type) *first = STAILQ_FIRST(head1); \
|
|
QUEUE_TYPEOF(type) **last = (head1)->stqh_last; \
|
|
STAILQ_FIRST(head1) = STAILQ_FIRST(head2); \
|
|
(head1)->stqh_last = (head2)->stqh_last; \
|
|
STAILQ_FIRST(head2) = first; \
|
|
(head2)->stqh_last = last; \
|
|
if (STAILQ_EMPTY(head1)) \
|
|
(head1)->stqh_last = &STAILQ_FIRST(head1); \
|
|
if (STAILQ_EMPTY(head2)) \
|
|
(head2)->stqh_last = &STAILQ_FIRST(head2); \
|
|
} while (0)
|
|
|
|
#endif // LLVM_LIBC_MACROS_SYS_QUEUE_MACROS_H
|