// SPDX-License-Identifier: MIT

/** list.h - intrusive linked lists
 */
#pragma once

// offsetof
#include <stddef.h>

typedef struct list
{
	struct list *next;
	struct list *prev;
} list_t;

#define LIST_INIT(x) { (&x), (&x) }
	
#define container_of(ptr, ty, field) \
	((ty*)((char*)(ptr)-offsetof(ty, field)))
	
// Iterate over a list. Note that items cannot be
// deleted while in this macro, because this will
// break the next link in the chain. If you wish
// to delete items, use list_foreach_safe at the
// expense of having to separately store the next ptr.
#define list_foreach(head, node) \
	for (node = (head)->next; node != (head); node = (node)->next)


// Iterate over a list. Requires an extra next ptr
// to make deletion safe.
#define list_foreach_safe(head, node, next_) \
	for (node = (head)->next, next_ = node->next; \
		 node != (head); \
		 node = next_, next_ = node->next)

#define list_foreach_safe_rev(head, node, prev_) \
	for (node = (head)->prev, prev_ = node->prev; \
		 node != (head); \
		 node = prev_, prev_ = node->prev)

static inline void list_init(list_t* lst)
{
	lst->next = lst->prev = lst;
}

static inline short list_empty(list_t* head)
{
	return head->next == head;
}

static inline list_t* list_head(list_t* head)
{
	return (head->next == head) ? NULL : head->next;
}

static inline list_t* list_tail(list_t* head)
{
	return (head->prev == head) ? NULL : head->prev;
}

static inline list_t* list_next(list_t* head, list_t* node)
{
	return (node->next == head) ? NULL : node->next;
}

static inline list_t* list_prev(list_t* head, list_t* node)
{
	return (node->prev == head) ? NULL : node->prev;
}

void list_del(list_t* node);

void list_add(list_t* node, list_t* to_insert);
void list_add_tail(list_t* node, list_t* to_insert);

list_t* list_pop(list_t* head);
list_t* list_pop_tail(list_t* head);

void list_move(list_t* dst, list_t* src);