[GitHub/mt8127/android_kernel_alcatel_ttab.git] / scripts / kconfig / list.h

#ifndef LIST_H
#define LIST_H

/*
 * Copied from include/linux/...
 */

#undef offsetof
#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)

/**
 * container_of - cast a member of a structure out to the containing structure
 * @ptr:        the pointer to the member.
 * @type:       the type of the container struct this is embedded in.
 * @member:     the name of the member within the struct.
 *
 */
#define container_of(ptr, type, member) ({                      \
	const typeof( ((type *)0)->member ) *__mptr = (ptr);    \
	(type *)( (char *)__mptr - offsetof(type,member) );})


struct list_head {
	struct list_head *next, *prev;
};


#define LIST_HEAD_INIT(name) { &(name), &(name) }

#define LIST_HEAD(name) \
	struct list_head name = LIST_HEAD_INIT(name)

/**
 * list_entry - get the struct for this entry
 * @ptr:	the &struct list_head pointer.
 * @type:	the type of the struct this is embedded in.
 * @member:	the name of the list_struct within the struct.
 */
#define list_entry(ptr, type, member) \
	container_of(ptr, type, member)

/**
 * list_for_each_entry	-	iterate over list of given type
 * @pos:	the type * to use as a loop cursor.
 * @head:	the head for your list.
 * @member:	the name of the list_struct within the struct.
 */
#define list_for_each_entry(pos, head, member)				\
	for (pos = list_entry((head)->next, typeof(*pos), member);	\
	     &pos->member != (head); 	\
	     pos = list_entry(pos->member.next, typeof(*pos), member))

/**
 * list_empty - tests whether a list is empty
 * @head: the list to test.
 */
static inline int list_empty(const struct list_head *head)
{
	return head->next == head;
}

/*
 * Insert a new entry between two known consecutive entries.
 *
 * This is only for internal list manipulation where we know
 * the prev/next entries already!
 */
static inline void __list_add(struct list_head *_new,
			      struct list_head *prev,
			      struct list_head *next)
{
	next->prev = _new;
	_new->next = next;
	_new->prev = prev;
	prev->next = _new;
}

/**
 * list_add_tail - add a new entry
 * @new: new entry to be added
 * @head: list head to add it before
 *
 * Insert a new entry before the specified head.
 * This is useful for implementing queues.
 */
static inline void list_add_tail(struct list_head *_new, struct list_head *head)
{
	__list_add(_new, head->prev, head);
}

#endif
Commit	Line	Data
bad9955d BP	1	#ifndef LIST_H
	2	#define LIST_H
	3
	4	/*
	5	* Copied from include/linux/...
	6	*/
	7
	8	#undef offsetof
	9	#define offsetof(TYPE, MEMBER) ((size_t) &((TYPE *)0)->MEMBER)
	10
	11	/**
	12	* container_of - cast a member of a structure out to the containing structure
	13	* @ptr: the pointer to the member.
	14	* @type: the type of the container struct this is embedded in.
	15	* @member: the name of the member within the struct.
	16	*
	17	*/
	18	#define container_of(ptr, type, member) ({ \
	19	const typeof( ((type )0)->member ) __mptr = (ptr); \
	20	(type )( (char )__mptr - offsetof(type,member) );})
	21
	22
	23	struct list_head {
	24	struct list_head next, prev;
	25	};
	26
	27
	28	#define LIST_HEAD_INIT(name) { &(name), &(name) }
	29
	30	#define LIST_HEAD(name) \
	31	struct list_head name = LIST_HEAD_INIT(name)
	32
	33	/**
	34	* list_entry - get the struct for this entry
	35	* @ptr: the &struct list_head pointer.
	36	* @type: the type of the struct this is embedded in.
	37	* @member: the name of the list_struct within the struct.
	38	*/
	39	#define list_entry(ptr, type, member) \
	40	container_of(ptr, type, member)
	41
	42	/**
	43	* list_for_each_entry - iterate over list of given type
	44	* @pos: the type * to use as a loop cursor.
	45	* @head: the head for your list.
	46	* @member: the name of the list_struct within the struct.
	47	*/
	48	#define list_for_each_entry(pos, head, member) \
	49	for (pos = list_entry((head)->next, typeof(*pos), member); \
	50	&pos->member != (head); \
	51	pos = list_entry(pos->member.next, typeof(*pos), member))
	52
	53	/**
	54	* list_empty - tests whether a list is empty
	55	* @head: the list to test.
	56	*/
	57	static inline int list_empty(const struct list_head *head)
	58	{
	59	return head->next == head;
	60	}
	61
	62	/*
	63	* Insert a new entry between two known consecutive entries.
	64	*
65	* This is only for internal list manipulation where we know
66	* the prev/next entries already!
67	*/
68	static inline void __list_add(struct list_head *_new,
69	struct list_head *prev,
70	struct list_head *next)
71	{
72	next->prev = _new;
73	_new->next = next;
74	_new->prev = prev;
75	prev->next = _new;
76	}
77
78	/**
79	* list_add_tail - add a new entry
80	* @new: new entry to be added
81	* @head: list head to add it before
82	*
83	* Insert a new entry before the specified head.
84	* This is useful for implementing queues.
85	*/
86	static inline void list_add_tail(struct list_head _new, struct list_head head)
87	{
88	__list_add(_new, head->prev, head);
89	}
90
91	#endif