.\" Copyright (c) 1993
.\"	The Regents of the University of California.  All rights reserved.
.\"
.\" Redistribution and use in source and binary forms, with or without
.\" modification, are permitted provided that the following conditions
.\" are met:
.\" 1. Redistributions of source code must retain the above copyright
.\"    notice, this list of conditions and the following disclaimer.
.\" 2. Redistributions in binary form must reproduce the above copyright
.\"    notice, this list of conditions and the following disclaimer in the
.\"    documentation and/or other materials provided with the distribution.
.\" 3. All advertising materials mentioning features or use of this software
.\"    must display the following acknowledgement:
.\"	This product includes software developed by the University of
.\"	California, Berkeley and its contributors.
.\" 4. Neither the name of the University nor the names of its contributors
.\"    may be used to endorse or promote products derived from this software
.\"    without specific prior written permission.
.\"
.\" THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
.\" ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
.\" IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
.\" ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
.\" FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
.\" DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
.\" OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
.\" HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
.\" LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
.\" OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
.\" SUCH DAMAGE.
.\"
.\"	@(#)queue.3	8.2 (Berkeley) 1/24/94
.\" %FreeBSD: src/share/man/man3/queue.3,v 1.15.2.7 2001/12/18 10:09:02 ru Exp %
.\" $FreeBSD$
.\"
.Dd January 24, 1994
.Dt QUEUE 3
.Os
.Sh ̾��
.Nm SLIST_EMPTY ,
.Nm SLIST_ENTRY ,
.Nm SLIST_FIRST ,
.Nm SLIST_FOREACH ,
.Nm SLIST_HEAD ,
.Nm SLIST_HEAD_INITIALIZER ,
.Nm SLIST_INIT ,
.Nm SLIST_INSERT_AFTER ,
.Nm SLIST_INSERT_HEAD ,
.Nm SLIST_NEXT ,
.Nm SLIST_REMOVE_HEAD ,
.Nm SLIST_REMOVE ,
.Nm STAILQ_EMPTY ,
.Nm STAILQ_ENTRY ,
.Nm STAILQ_FIRST ,
.Nm STAILQ_FOREACH ,
.Nm STAILQ_HEAD ,
.Nm STAILQ_HEAD_INITIALIZER ,
.Nm STAILQ_INIT ,
.Nm STAILQ_INSERT_AFTER ,
.Nm STAILQ_INSERT_HEAD ,
.Nm STAILQ_INSERT_TAIL ,
.Nm STAILQ_LAST ,
.Nm STAILQ_NEXT ,
.Nm STAILQ_REMOVE_HEAD ,
.Nm STAILQ_REMOVE ,
.Nm LIST_EMPTY ,
.Nm LIST_ENTRY ,
.Nm LIST_FIRST ,
.Nm LIST_FOREACH ,
.Nm LIST_HEAD ,
.Nm LIST_HEAD_INITIALIZER ,
.Nm LIST_INIT ,
.Nm LIST_INSERT_AFTER ,
.Nm LIST_INSERT_BEFORE ,
.Nm LIST_INSERT_HEAD ,
.Nm LIST_NEXT ,
.Nm LIST_REMOVE ,
.Nm TAILQ_EMPTY ,
.Nm TAILQ_ENTRY ,
.Nm TAILQ_FIRST ,
.Nm TAILQ_FOREACH ,
.Nm TAILQ_FOREACH_REVERSE ,
.Nm TAILQ_HEAD ,
.Nm TAILQ_HEAD_INITIALIZER ,
.Nm TAILQ_INIT ,
.Nm TAILQ_INSERT_AFTER ,
.Nm TAILQ_INSERT_BEFORE ,
.Nm TAILQ_INSERT_HEAD ,
.Nm TAILQ_INSERT_TAIL ,
.Nm TAILQ_LAST ,
.Nm TAILQ_NEXT ,
.Nm TAILQ_PREV ,
.Nm TAILQ_REMOVE ,
.Nm CIRCLEQ_EMPTY ,
.Nm CIRCLEQ_ENTRY ,
.Nm CIRCLEQ_FIRST ,
.Nm CIRCLEQ_FOREACH ,
.Nm CIRCLEQ_FOREACH_REVERSE ,
.Nm CIRCLEQ_HEAD ,
.Nm CIRCLEQ_HEAD_INITIALIZER ,
.Nm CIRCLEQ_INIT ,
.Nm CIRCLEQ_INSERT_AFTER ,
.Nm CIRCLEQ_INSERT_BEFORE ,
.Nm CIRCLEQ_INSERT_HEAD ,
.Nm CIRCLEQ_INSERT_TAIL ,
.Nm CIRCLE_LAST ,
.Nm CIRCLE_NEXT ,
.Nm CIRCLE_PREV ,
.Nm CIRCLEQ_REMOVE
.Nd ñ���󥯥ꥹ�ȡ�ñ���󥯥ơ��륭�塼���ꥹ�ȡ��ơ��륭�塼��
�۴ĥ��塼�μ���
.Sh ��
.In sys/queue.h
.\"
.Fn SLIST_EMPTY "SLIST_HEAD *head"
.Fn SLIST_ENTRY "TYPE"
.Fn SLIST_FIRST "SLIST_HEAD *head"
.Fn SLIST_FOREACH "TYPE *var" "SLIST_HEAD *head" "SLIST_ENTRY NAME"
.Fn SLIST_HEAD "HEADNAME" "TYPE"
.Fn SLIST_HEAD_INITIALIZER "SLIST_HEAD head"
.Fn SLIST_INIT "SLIST_HEAD *head"
.Fn SLIST_INSERT_AFTER "TYPE *listelm" "TYPE *elm" "SLIST_ENTRY NAME"
.Fn SLIST_INSERT_HEAD "SLIST_HEAD *head" "TYPE *elm" "SLIST_ENTRY NAME"
.Fn SLIST_NEXT "TYPE *elm" "SLIST_ENTRY NAME"
.Fn SLIST_REMOVE_HEAD "SLIST_HEAD *head" "SLIST_ENTRY NAME"
.Fn SLIST_REMOVE "SLIST_HEAD *head" "TYPE *elm" "TYPE" "SLIST_ENTRY NAME"
.\"
.Fn STAILQ_EMPTY "STAILQ_HEAD *head"
.Fn STAILQ_ENTRY "TYPE"
.Fn STAILQ_FIRST "STAILQ_HEAD *head"
.Fn STAILQ_FOREACH "TYPE *var" "STAILQ_HEAD *head" "STAILQ_ENTRY NAME"
.Fn STAILQ_HEAD "HEADNAME" "TYPE"
.Fn STAILQ_HEAD_INITIALIZER "STAILQ_HEAD head"
.Fn STAILQ_INIT "STAILQ_HEAD *head"
.Fn STAILQ_INSERT_AFTER "STAILQ_HEAD *head" "TYPE *listelm" "TYPE *elm" "STAILQ_ENTRY NAME"
.Fn STAILQ_INSERT_HEAD "STAILQ_HEAD *head" "TYPE *elm" "STAILQ_ENTRY NAME"
.Fn STAILQ_INSERT_TAIL "STAILQ_HEAD *head" "TYPE *elm" "STAILQ_ENTRY NAME"
.Fn STAILQ_LAST "STAILQ_HEAD *head" "TYPE" "STAILQ_ENTRY NAME"
.Fn STAILQ_NEXT "TYPE *elm" "STAILQ_ENTRY NAME"
.Fn STAILQ_REMOVE_HEAD "STAILQ_HEAD *head" "STAILQ_ENTRY NAME"
.Fn STAILQ_REMOVE "STAILQ_HEAD *head" "TYPE *elm" "TYPE" "STAILQ_ENTRY NAME"
.\"
.Fn LIST_EMPTY "LIST_HEAD *head"
.Fn LIST_ENTRY "TYPE"
.Fn LIST_FIRST "LIST_HEAD *head"
.Fn LIST_FOREACH "TYPE *var" "LIST_HEAD *head" "LIST_ENTRY NAME"
.Fn LIST_HEAD "HEADNAME" "TYPE"
.Fn LIST_HEAD_INITIALIZER "LIST_HEAD head"
.Fn LIST_INIT "LIST_HEAD *head"
.Fn LIST_INSERT_AFTER "TYPE *listelm" "TYPE *elm" "LIST_ENTRY NAME"
.Fn LIST_INSERT_BEFORE "TYPE *listelm" "TYPE *elm" "LIST_ENTRY NAME"
.Fn LIST_INSERT_HEAD "LIST_HEAD *head" "TYPE *elm" "LIST_ENTRY NAME"
.Fn LIST_NEXT "TYPE *elm" "LIST_ENTRY NAME"
.Fn LIST_REMOVE "TYPE *elm" "LIST_ENTRY NAME"
.\"
.Fn TAILQ_EMPTY "TAILQ_HEAD *head"
.Fn TAILQ_ENTRY "TYPE"
.Fn TAILQ_FIRST "TAILQ_HEAD *head"
.Fn TAILQ_FOREACH "TYPE *var" "TAILQ_HEAD *head" "TAILQ_ENTRY NAME"
.Fn TAILQ_FOREACH_REVERSE "TYPE *var" "TAILQ_HEAD *head" "HEADNAME" "TAILQ_ENTRY NAME"
.Fn TAILQ_HEAD "HEADNAME" "TYPE"
.Fn TAILQ_HEAD_INITIALIZER "TAILQ_HEAD head"
.Fn TAILQ_INIT "TAILQ_HEAD *head"
.Fn TAILQ_INSERT_AFTER "TAILQ_HEAD *head" "TYPE *listelm" "TYPE *elm" "TAILQ_ENTRY NAME"
.Fn TAILQ_INSERT_BEFORE "TYPE *listelm" "TYPE *elm" "TAILQ_ENTRY NAME"
.Fn TAILQ_INSERT_HEAD "TAILQ_HEAD *head" "TYPE *elm" "TAILQ_ENTRY NAME"
.Fn TAILQ_INSERT_TAIL "TAILQ_HEAD *head" "TYPE *elm" "TAILQ_ENTRY NAME"
.Fn TAILQ_LAST "TAILQ_HEAD *head" "HEADNAME"
.Fn TAILQ_NEXT "TYPE *elm" "TAILQ_ENTRY NAME"
.Fn TAILQ_PREV "TYPE *elm" "HEADNAME" "TAILQ_ENTRY NAME"
.Fn TAILQ_REMOVE "TAILQ_HEAD *head" "TYPE *elm" "TAILQ_ENTRY NAME"
.\"
.Fn CIRCLEQ_EMPTY "CIRCLEQ_HEAD *head"
.Fn CIRCLEQ_ENTRY "TYPE"
.Fn CIRCLEQ_FIRST "CIRCLEQ_HEAD *head"
.Fn CIRCLEQ_FOREACH "TYPE *var" "CIRCLEQ_HEAD *head" "CIRCLEQ_ENTRY NAME"
.Fn CIRCLEQ_FOREACH_REVERSE "TYPE *var" "CIRCLEQ_HEAD *head" "CIRCLEQ_ENTRY NAME"
.Fn CIRCLEQ_HEAD "HEADNAME" "TYPE"
.Fn CIRCLEQ_HEAD_INITIALIZER "CIRCLEQ_HEAD head"
.Fn CIRCLEQ_INIT "CIRCLEQ_HEAD *head"
.Fn CIRCLEQ_INSERT_AFTER "CIRCLEQ_HEAD *head" "TYPE *listelm" "TYPE *elm" "CIRCLEQ_ENTRY NAME"
.Fn CIRCLEQ_INSERT_BEFORE "CIRCLEQ_HEAD *head" "TYPE *listelm" "TYPE *elm" "CIRCLEQ_ENTRY NAME"
.Fn CIRCLEQ_INSERT_HEAD "CIRCLEQ_HEAD *head" "TYPE *elm" "CIRCLEQ_ENTRY NAME"
.Fn CIRCLEQ_INSERT_TAIL "CIRCLEQ_HEAD *head" "TYPE *elm" "CIRCLEQ_ENTRY NAME"
.Fn CIRCLEQ_LAST "CIRCLEQ_HEAD *head"
.Fn CIRCLEQ_NEXT "TYPE *elm" "CIRCLEQ_ENTRY NAME"
.Fn CIRCLE_PREV "TYPE *elm" "CIRCLEQ_ENTRY NAME"
.Fn CIRCLEQ_REMOVE "CIRCLEQ_HEAD *head" "TYPE *elm" "CIRCLEQ_ENTRY NAME"
.Sh ����
���Υޥ����ϡ�ñ���󥯥ꥹ�ȡ�ñ���󥯥ơ��륭�塼���ꥹ�ȡ�
�ơ��륭�塼���۴ĥ��塼�Ȥ�����5 ����Υǡ�����¤��������Ƥ�����ư��ޤ���
5 �ĤΥǡ�����¤�Ϥ��٤ơ��ʲ��ε�ǽ�򥵥ݡ��Ȥ��ޤ���
.Bl -enum -compact -offset indent
.It
�ꥹ�Ȥ���Ƭ�˿���������ȥ���������롣
.It
�ꥹ�Ȥ�¸�ߤ���Ǥ�դ����Ǥθ���˿���������ȥ���������롣
.It
�ꥹ�Ȥ���Ƭ���饨��ȥ�� O(1) ������롣
.It
�ꥹ�Ȥ�Ǥ�դΥ���ȥ�� O(n) ������롣
.It
�ꥹ�Ȥ��������������롣
.El
.Pp
ñ���󥯥ꥹ�Ȥϡ�5 �ĤΥǡ�����¤����ǺǤ�ñ��ǡ���� 5�Ĥε�ǽ��
�����ݡ��Ȥ��ޤ���
ñ���󥯥ꥹ�Ȥϡ�
�ǡ������åȤ��礭����������ۤȤ�ɤʤ����⤷���ϡ������ʤ����ץꥱ�������
�ޤ��� LIFO ���塼�μ���������Ū�Ǥ���
.Pp
ñ���󥯥ơ��륭�塼�ˤϰʲ��ε�ǽ�⤢��ޤ���
.Bl -enum -compact -offset indent
.It
�ꥹ�Ȥ������˥���ȥ���ɲä��롣
.El
�������ʲ������դ��Ƥ���������
.Bl -enum -compact -offset indent
.It
�ꥹ�Ȥ������Ǥϡ��ꥹ�ȤΥإåɤ�ɬ�����ꤹ��ɬ�פ����롣
.It
�ƥإåɥ���ȥ�Ǥϡ�1 �ĤǤϤʤ� 2 �ĤΥݥ��󥿤�ɬ�פǤ��롣
.It
ñ���󥯥ꥹ�Ȥ�ꡢ�����ɥ��������� 15% �礭����ư����� 20% �٤���
.El
.Pp
ñ���󥯥ơ��륭�塼�ϡ�
�ǡ������åȤ��礭����������ۤȤ�ɤʤ����⤷���ϡ������ʤ����ץꥱ�������
�ޤ���  FIFO ���塼�μ���������Ū�Ǥ���
.Pp
��ť�󥯥����פΤ��٤ƤΥǡ�����¤ (�ꥹ�ȡ��ơ��륭�塼���۴ĥ��塼) �ˤ�
�ʲ��ε�ǽ�⤢��ޤ���
.Bl -enum -compact -offset indent
.It
�ꥹ�Ȥ�¸�ߤ���Ǥ�դ����Ǥ����˿���������ȥ���������롣
.It
�ꥹ�Ȥ�Ǥ�դΥ���ȥ�� O(1) ������롣
.El
�������ʲ������դ��Ƥ���������
.Bl -enum -compact -offset indent
.It
�����Ǥˤϡ�1 �ĤǤϤʤ� 2 �ĤΥݥ��󥿤�ɬ�פǤ��롣
.It
ñ���󥯥ǡ�����¤��ꡢ�����ɥ������ȼ¹Ի��� (����Ͻ���) ���� 2 �ܤ�
�ʤ롣
.El
.Pp
��󥯥ꥹ�Ȥϡ���ť�󥯥ǡ�����¤����ǺǤ�ñ��ǡ�ñ���󥯥ꥹ�Ȥ�
��ǽ�˲ä��ƾ�ε�ǽ�������ݡ��Ȥ��ޤ���
.Pp
�ơ��륭�塼�ˤϰʲ��ε�ǽ�⤢��ޤ���
.Bl -enum -compact -offset indent
.It
�ꥹ�Ȥ������˥���ȥ���ɲä��롣
.It
����������Ƭ�ؤȵդ��������롣
.El
�������ʲ������դ��Ƥ���������
.Bl -enum -compact -offset indent
.It
�ꥹ�Ȥ������Ⱥ���Ǥϡ��ꥹ�ȤΥإåɤ�ɬ�����ꤹ��ɬ�פ����롣
.It
�ƥإåɥ���ȥ�Ǥϡ�1 �ĤǤϤʤ� 2 �ĤΥݥ��󥿤�ɬ�פǤ��롣
.It
ñ���󥯥ꥹ�Ȥ�ꡢ�����ɥ��������� 15% �礭�����������֤��� 20% Ĺ����
.El
.Pp
�۴ĥ��塼�ˤϰʲ��ε�ǽ�⤢��ޤ���
.Bl -enum -compact -offset indent
.It
�ꥹ�Ȥ������˥���ȥ���ɲä��롣
.It
����������Ƭ�ؤȵդ��������롣
.El
�������ʲ������դ��Ƥ���������
.Bl -enum -compact -offset indent
.It
�ꥹ�Ȥ������Ⱥ���Ǥϡ��ꥹ�ȤΥإåɤ�ɬ�����ꤹ��ɬ�פ����롣
.It
�ƥإåɥ���ȥ�Ǥϡ�1 �ĤǤϤʤ� 2 �ĤΥݥ��󥿤�ɬ�פǤ��롣
.It
�����ν�λ��郎���ʣ���Ǥ��롣
.It
�ꥹ�Ȥ�ꡢ�����ɥ��������� 40% �礭�����������֤��� 45% Ĺ����
.El
.Pp
�ޥ�������Ǥϡ�
.Fa TYPE
�ϥ桼�������������¤�Τ�̾���Ǥ������ι�¤�Τˤϡ�
.Fa NAME
�Ȥ���̾�����դ�����
.Li SLIST_ENTRY ,
.Li STAILQ_ENTRY ,
.Li LIST_ENTRY ,
.Li TAILQ_ENTRY ,
.Li CIRCLEQ_ENTRY
�Ȥ������Υե�����ɤ�ޤ��ɬ�פ�����ޤ���
����
.Fa HEADNAME
��
�ޥ���
.Li SLIST_HEAD ,
.Li STAILQ_HEAD ,
.Li LIST_HEAD ,
.Li TAILQ_HEAD ,
.Li CIRCLEQ_HEAD
���������ɬ�פΤ��롢�桼�������������¤�Τ�̾���Ǥ���
���Υޥ����λ���ˡ�ξܺ٤ˤĤ��Ƥϡ��ʲ��λ�����򻲾Ȥ��Ƥ���������
.Sh ñ���󥯥ꥹ��
ñ���󥯥ꥹ�Ȥκǽ�ˤϡ�
.Nm SLIST_HEAD
�ޥ������������빽¤�Τ��դ��ޤ���
���ι�¤�Τˤϡ��ꥹ�Ȥ���Ƭ�����Ǥ�ؤ��ݥ��󥿤� 1 �Ĵޤޤ�ޤ���
���Ǥϡ�Ǥ�դ����Ǥ� O(n) ��������ˤ��ơ�
���ڡ����ȥݥ������Υ����Хإåɤ��Ǿ��ˤʤ�褦��ñ���󥯤���ޤ���
���������Ǥϡ���¸�����Ǥθ�����ꥹ�Ȥ���Ƭ�ǥꥹ�Ȥ��ɲäǤ��ޤ���
.Fa SLIST_HEAD
��¤�Τϰʲ��Τ褦���������ޤ���
.Bd -literal -offset indent
SLIST_HEAD(HEADNAME, TYPE) head;
.Ed
.Pp
������
.Fa HEADNAME
��������빽¤�Τ�̾���ǡ�
.Fa TYPE
�ϥꥹ�Ȥ˥�󥯤������Ǥη��Ǥ���
�ꥹ�ȤΥإåɤΥݥ��󥿤ϡ���ǰʲ��Τ褦������Ǥ��ޤ��� 
.Bd -literal -offset indent
struct HEADNAME *headp;
.Ed
.Pp
(̾��
.Li head
��
.Li headp
�ϡ��桼�������٤ޤ���)
.Pp
�ޥ���
.Nm SLIST_HEAD_INITIALIZER
�ϥꥹ�Ȥ�
.Fa head
���������ޤ���
.Pp
�ޥ���
.Nm SLIST_EMPTY
�ϥꥹ�Ȥ����Ǥ��ʤ����˿��ˤʤ�ޤ���
.Pp
�ޥ���
.Nm SLIST_ENTRY
�ϥꥹ�Ȥ����Ǥ���³���빽¤�Τ�������ޤ���
.Pp
�ޥ���
.Nm SLIST_FIRST
�ϥꥹ�Ȥ���Ƭ�����Ǥ򡢥ꥹ�Ȥ����ʤ� NULL ���֤��ޤ���
.Pp
�ޥ���
.Nm SLIST_FOREACH
��
.Fa head
�ǻ��Ȥ����ꥹ�Ȥ򡢳����Ǥ���
.Fa var
�˳�����Ƥƽ��������������ޤ���
.Pp
�ޥ���
.Nm SLIST_INIT
��
.Fa head
�����Ȥ���ꥹ�Ȥ��������ޤ���
.Pp
�ޥ���
.Nm SLIST_INSERT_HEAD
�Ͽ���������
.Fa elm
��ꥹ�Ȥ���Ƭ���������ޤ���
.Pp
�ޥ���
.Nm SLIST_INSERT_AFTER
������
.Fa listelm
�θ���˿���������
.Fa elm
���������ޤ���
.Pp
�ޥ���
.Nm SLIST_NEXT
�ϥꥹ�Ȥμ������Ǥ��֤��ޤ���
.Pp
�ޥ���
.Nm SLIST_REMOVE_HEAD
�ϥꥹ�Ȥ���Ƭ��������
.Fa elm
�������ޤ���
��Ŭ�ʸ�Ψ�����뤿��ˡ��ꥹ�Ȥ���Ƭ�������Ǥ���������ˤ�
������
.Fa SLIST_REMOVE
�ޥ���������ˤ��Υޥ���������Ū�˻��Ѥ��٤��Ǥ���
.Pp
�ޥ���
.Nm SLIST_REMOVE
�ϥꥹ�Ȥ�������
.Fa elm
�������ޤ���
.Sh ñ���󥯥ꥹ�Ȥλ�����
.Bd -literal
SLIST_HEAD(slisthead, entry) head =
    SLIST_HEAD_INITIALIZER(head);
struct slisthead *headp;		/* ñ���󥯥ꥹ�ȥإå� */
struct entry {
	...
	SLIST_ENTRY(entry) entries;	/* ñ���󥯥ꥹ�� */
	...
} *n1, *n2, *n3, *np;

SLIST_INIT(&head);			/* �ꥹ�Ȥ����� */

n1 = malloc(sizeof(struct entry));	/* ��Ƭ������ */
SLIST_INSERT_HEAD(&head, n1, entries);

n2 = malloc(sizeof(struct entry));	/* ��������� */
SLIST_INSERT_AFTER(n1, n2, entries);

SLIST_REMOVE(&head, n2, entry, entries);/* ��� */
free(n2);

n3 = SLIST_FIRST(&head);
SLIST_REMOVE_HEAD(&head, entries);	/* ��Ƭ������ */
free(n3);
					/* ������ */
SLIST_FOREACH(np, &head, entries)
	np-> ...

while (!SLIST_EMPTY(&head)) {		/* �ꥹ�Ȥκ�� */
	n1 = SLIST_FIRST(&head);
	SLIST_REMOVE_HEAD(&head, entries);
	free(n1);
}
.Ed
.Sh ñ���󥯥ơ��륭�塼
ñ���󥯥ơ��륭�塼�κǽ�ˤϡ�
.Nm STAILQ_HEAD
�ޥ������������빽¤�Τ��Ĥ��ޤ���
���ι�¤�Τˤϥơ��륭�塼����Ƭ�����Ǥ�ؤ��ݥ��󥿤�
�ơ��륭�塼�����������Ǥ�ؤ��ݥ��󥿤� 2 �Ĥ��ޤޤ�ޤ���
���Ǥϡ�Ǥ�դ����Ǥ� O(n) ��������ˤ��ơ�
���ڡ����ȥݥ������Υ����Хإåɤ��Ǿ��ˤʤ�褦��ñ���󥯤���ޤ���
���������Ǥϡ���¸�����Ǥθ�����ơ��륭�塼����Ƭ���ơ��륭�塼��������
�ơ��륭�塼���ɲäǤ��ޤ���
.Fa STAILQ_HEAD
��¤�Τϰʲ��Τ褦���������ޤ���
.Bd -literal -offset indent
STAILQ_HEAD(HEADNAME, TYPE) head;
.Ed
.Pp
������
.Li HEADNAME
��������빽¤�Τ�̾���ǡ�
.Li TYPE
�ϥơ��륭�塼�˥�󥯤������Ǥη��Ǥ���
�ơ��륭�塼�ΥإåɤΥݥ��󥿤ϡ���ǰʲ��Τ褦������Ǥ��ޤ���
.Bd -literal -offset indent
struct HEADNAME *headp;
.Ed
.Pp
(̾��
.Li head
��
.Li headp
�ϡ��桼�������٤ޤ���)
.Pp
�ޥ���
.Nm STAILQ_HEAD_INITIALIZER
�ϥơ��륭�塼��
.Fa head
���������ޤ���
.Pp
�ޥ���
.Nm STAILQ_EMPTY
�ϥơ��륭�塼�����Ǥ��ʤ����˿��ˤʤ�ޤ���
.Pp
�ޥ���
.Nm STAILQ_ENTRY
�ϥơ��륭�塼�����Ǥ���³���빽¤�Τ�������ޤ���
.Pp
�ޥ���
.Nm STAILQ_FIRST
�ϥơ��륭�塼����Ƭ�����Ǥ򡢥ơ��륭�塼�����ʤ� NULL ���֤��ޤ���
.Pp
�ޥ���
.Nm STAILQ_FOREACH
��
.Fa head
�ǻ��Ȥ����ơ��륭�塼�򡢳����Ǥ���
.Fa var
�˳�����Ƥƽ��������������ޤ���
.Pp
�ޥ���
.Nm STAILQ_INIT
��
.Fa head
�����Ȥ���ơ��륭�塼���������ޤ���
.Pp
�ޥ���
.Nm STAILQ_INSERT_HEAD
�Ͽ���������
.Fa elm
��ơ��륭�塼����Ƭ���������ޤ���
.Pp
�ޥ���
.Nm STAILQ_INSERT_TAIL
�Ͽ���������
.Fa elm
��ơ��륭�塼���������������ޤ���
.Pp
�ޥ���
.Nm STAILQ_INSERT_AFTER
�Ͽ���������
.Fa elm
������
.Fa listelm
�θ�����������ޤ���
.Pp
�ޥ���
.Nm STAILQ_LAST
�ϥơ��륭�塼�����������Ǥ��֤��ޤ���
�ơ��륭�塼�����ʤ顢����ͤ�̤����Ǥ���
.Pp
�ޥ���
.Nm STAILQ_NEXT
�ϥơ��륭�塼�μ������Ǥ򡢤������Ǥ������ʤ� NULL ���֤��ޤ���
.Pp
�ޥ���
.Nm STAILQ_REMOVE_HEAD
�ϥơ��륭�塼����Ƭ��������
�������ޤ���
��Ŭ�ʸ�Ψ�����뤿��ˡ��ơ��륭�塼����Ƭ�������Ǥ���������ˤ�
������
.Fa STAILQ_REMOVE
�ޥ������⤳�Υޥ���������Ū�˻��Ѥ��٤��Ǥ���
.Pp
�ޥ���
.Nm STAILQ_REMOVE
�ϥơ��륭�塼��������
.Fa elm
�������ޤ���
.Sh ñ���󥯥ơ��륭�塼�λ�����
.Bd -literal
STAILQ_HEAD(stailhead, entry) head =
    STAILQ_HEAD_INITIALIZER(head);
struct stailhead *headp;		/* ñ���󥯥ơ��륭�塼�إå� */
struct entry {
	...
	STAILQ_ENTRY(entry) entries;	/* �ơ��륭�塼 */
	...
} *n1, *n2, *n3, *np;

STAILQ_INIT(&head);			/* ���塼������ */

n1 = malloc(sizeof(struct entry));	/* ��Ƭ������ */
STAILQ_INSERT_HEAD(&head, n1, entries);

n1 = malloc(sizeof(struct entry));	/* ���������� */
STAILQ_INSERT_TAIL(&head, n1, entries);

n2 = malloc(sizeof(struct entry));	/* ��������� */
STAILQ_INSERT_AFTER(&head, n1, n2, entries);
					/* ��� */
STAILQ_REMOVE(&head, n2, entry, entries);
free(n2);
					/* ��Ƭ������ */
n3 = STAILQ_FIRST(&head);
STAILQ_REMOVE_HEAD(&head, entries);
free(n3);
					/* ������ */
STAILQ_FOREACH(np, &head, entries)
	np-> ...
					/* �ơ��륭�塼�κ�� */
while (!STAILQ_EMPTY(&head)) {
	n1 = STAILQ_FIRST(&head);
	STAILQ_REMOVE_HEAD(&head, entries);
	free(n1);
}
					/* �ơ��륭�塼�ι�®�ʺ�� */
n1 = STAILQ_FIRST(&head);
while (n1 != NULL) {
	n2 = STAILQ_NEXT(n1, entries);
	free(n1);
	n1 = n2;
}
STAILQ_INIT(&head);
.Ed
.Sh �ꥹ��
�ꥹ�Ȥκǽ�ˤϡ�
.Nm LIST_HEAD
�ޥ������������빽¤�Τ��դ��ޤ���
���ι�¤�Τˤϡ��ꥹ�Ȥ���Ƭ�����Ǥ�ؤ��ݥ��󥿤� 1 �Ĵޤޤ�ޤ���
���Ǥ���Ť˥�󥯤���Ƥ���Τǡ��ꥹ�Ȥ�����������Ǥ�դ����Ǥ����Ǥ��ޤ���
���������Ǥϡ���¸�����Ǥ�������¸�����Ǥθ塢�ꥹ�Ȥ���Ƭ��
�ꥹ�Ȥ��ɲäǤ��ޤ���
.Fa LIST_HEAD
��¤�Τϡ��ʲ��Τ褦���������ޤ���
.Bd -literal -offset indent
LIST_HEAD(HEADNAME, TYPE) head;
.Ed
.Pp
������
.Fa HEADNAME
��������빽¤�Τ�̾���ǡ�
.Fa TYPE
�ϥꥹ�Ȥ˥�󥯤������Ǥη��Ǥ���
�ꥹ�ȤΥإåɤΥݥ��󥿤ϡ���ǰʲ��Τ褦������Ǥ��ޤ���
.Bd -literal -offset indent
struct HEADNAME *headp;
.Ed
.Pp
(̾��
.Li head
��
.Li headp
�ϡ��桼�������٤ޤ���)
.Pp
�ޥ���
.Nm LIST_HEAD_INITIALIZER
�ϥꥹ�Ȥ�
.Fa head
���������ޤ���
.Pp
�ޥ���
.Nm LIST_EMPTY
�ϥꥹ�Ȥ����Ǥ��ʤ����˿��ˤʤ�ޤ���
.Pp
�ޥ���
.Nm LIST_ENTRY
�ϥꥹ�Ȥ����Ǥ���³���빽¤�Τ�������ޤ���
.Pp
�ޥ���
.Nm LIST_FIRST
�ϥꥹ�Ȥκǽ�����Ǥ򡢥ꥹ�Ȥ����ʤ� NULL ���֤��ޤ���
.Pp
�ޥ���
.Nm LIST_FOREACH
��
.Fa head
�ǻ��Ȥ����ꥹ�Ȥ򡢳����Ǥ���
.Fa var
�˳�����Ƥƽ��������������ޤ���
.Pp
�ޥ���
.Nm LIST_INIT
��
.Fa head
�����Ȥ���ꥹ�Ȥ��������ޤ���
.Pp
�ޥ���
.Nm LIST_INSERT_HEAD
�Ͽ���������
.Fa elm
��ꥹ�Ȥ���Ƭ���������ޤ���
.Pp
�ޥ���
.Nm LIST_INSERT_AFTER
�Ͽ���������
.Fa elm
������
.Fa listelm
�θ�����������ޤ���
.Pp
�ޥ���
.Nm LIST_INSERT_BEFORE
�Ͽ���������
.Fa elm
������
.Fa listelm
�������������ޤ���
.Pp
�ޥ���
.Nm LIST_NEXT
�ϥꥹ�Ȥμ������Ǥ򡢤������Ǥ������ʤ� NULL ���֤��ޤ���
.Pp
�ޥ���
.Nm LIST_REMOVE
������
.Fa elm
��ꥹ�Ȥ��������ޤ���
.Sh �ꥹ�Ȥλ�����
.Bd -literal
LIST_HEAD(listhead, entry) head =
    LIST_HEAD_INITIALIZER(head);
struct listhead *headp;			/* �ꥹ�ȥإå� */
struct entry {
	...
	LIST_ENTRY(entry) entries;	/* �ꥹ�� */
	...
} *n1, *n2, *n3, *np;

LIST_INIT(&head);			/* �ꥹ�Ȥ����� */

n1 = malloc(sizeof(struct entry));	/* ��Ƭ������ */
LIST_INSERT_HEAD(&head, n1, entries);

n2 = malloc(sizeof(struct entry));	/* ��������� */
LIST_INSERT_AFTER(n1, n2, entries);

n3 = malloc(sizeof(struct entry));	/* �������� */
LIST_INSERT_BEFORE(n2, n3, entries);

LIST_REMOVE(n2, entries);		/* ��� */
free(n2);
					/* ������ */
LIST_FOREACH(np, &head, entries)
	np-> ...

while (!LIST_EMPTY(&head)) {		/* �ꥹ�Ȥκ�� */
	n1 = LIST_FIRST(&head);
	LIST_REMOVE(n1, entries);
	free(n1);
}

n1 = LIST_FIRST(&head);			/* �ꥹ�Ȥι�®�ʺ�� */
while (n1 != NULL) {
	n2 = LIST_NEXT(n1, entries);
	free(n1);
	n1 = n2;
}
LIST_INIT(&head);
.Ed
.Sh �ơ��륭�塼
�ơ��륭�塼�κǽ�ˤϡ�
.Nm TAILQ_HEAD
�ޥ������������빽¤�Τ��դ��ޤ���
���ι�¤�Τˤϡ��ơ��륭�塼�κǽ�����Ǥ�ؤ��ݥ��󥿤�
�ơ��륭�塼����Ƭ�����Ǥ�ؤ��ݥ��󥿤� 2 �Ĥ��ޤޤ�ޤ���
���Ǥ���Ť˥�󥯤���Ƥ���Τǡ��ơ��륭�塼������������
Ǥ�դ����Ǥ����Ǥ��ޤ���
���������Ǥϡ���¸�����Ǥ�������¸�����Ǥθ塢�ơ��륭�塼����Ƭ��
�ơ��륭�塼�������ǥơ��륭�塼���ɲäǤ��ޤ���
.Fa TAILQ_HEAD
��¤�Τϡ��ʲ��Τ褦���������Ƥ��ޤ���
.Bd -literal -offset indent
TAILQ_HEAD(HEADNAME, TYPE) head;
.Ed
.Pp
������
.Li HEADNAME
��������빽¤�Τ�̾���ǡ�
.Li TYPE
�ϥơ��륭�塼�˥�󥯤������Ǥη��Ǥ���
�ơ��륭�塼�ΥإåɤΥݥ��󥿤ϡ���ǰʲ��Τ褦���������ޤ���
.Bd -literal -offset indent
struct HEADNAME *headp;
.Ed
.Pp
(̾��
.Li head
��
.Li headp
�ϡ��桼�������٤ޤ���)
.Pp
�ޥ���
.Nm TAILQ_HEAD_INITIALIZER
�ϥơ��륭�塼��
.Fa head
���������ޤ���
.Pp
�ޥ���
.Nm TAILQ_EMPTY
�ϥơ��륭�塼�����Ǥ��ʤ����˿��ˤʤ�ޤ���
.Pp
�ޥ���
.Nm TAILQ_ENTRY
�ϥơ��륭�塼�����Ǥ���³���빽¤�Τ�������ޤ���
.Pp
�ޥ���
.Nm TAILQ_FIRST
�ϥơ��륭�塼�κǽ�����Ǥ򡢥ơ��륭�塼�����ʤ� NULL ���֤��ޤ���
.Pp
�ޥ���
.Nm TAILQ_FOREACH
��
.Fa head
�ǻ��Ȥ����ơ��륭�塼�򡢳����Ǥ���
.Fa var
�˳�����Ƥƽ��������������ޤ���
.Pp
�ޥ���
.Nm TAILQ_FOREACH_REVERSE
��
.Fa head
�ǻ��Ȥ����ơ��륭�塼�򡢳����Ǥ���
.Fa var
�˳�����ƤƵ��������������ޤ���
.Pp
�ޥ���
.Nm TAILQ_INIT
��
.Fa head
�����Ȥ���ơ��륭�塼���������ޤ���
.Pp
�ޥ���
.Nm TAILQ_INSERT_HEAD
�Ͽ���������
.Fa elm
��ơ��륭�塼����Ƭ���������ޤ���
.Pp
�ޥ���
.Nm TAILQ_INSERT_TAIL
�Ͽ���������
.Fa elm
��ơ��륭�塼���������������ޤ���
.Pp
�ޥ���
.Nm TAILQ_INSERT_AFTER
�Ͽ���������
.Fa elm
������
.Fa listelm
�θ�����������ޤ���
.Pp
�ޥ���
.Nm TAILQ_INSERT_BEFORE
�Ͽ���������
.Fa elm
������
.Fa listelm
�������������ޤ���
.Pp
�ޥ���
.Nm TAILQ_LAST
�ϥơ��륭�塼�����������Ǥ��֤��ޤ���
�ơ��륭�塼�����ξ�硢����ͤ�̤����Ǥ��� 
.Pp
�ޥ���
.Nm TAILQ_NEXT
�ϥơ��륭�塼�μ������Ǥ򡢤������Ǥ������ξ��� NULL ���֤��ޤ���
.Pp
�ޥ���
.Nm TAILQ_PREV
�ϥơ��륭�塼���������Ǥ򡢤������Ǥ���Ƭ�ξ��� NULL ���֤��ޤ���
.Pp
�ޥ���
.Nm TAILQ_REMOVE
������
.Fa elm
��ơ��륭�塼���������ޤ���
.Sh �ơ��륭�塼�λ�����
.Bd -literal
TAILQ_HEAD(tailhead, entry) head =
    TAILQ_HEAD_INITIALIZER(head);
struct tailhead *headp;			/* �ơ��륭�塼�إå� */
struct entry {
	...
	TAILQ_ENTRY(entry) entries;	/* �ơ��륭�塼 */
	...
} *n1, *n2, *n3, *np;

TAILQ_INIT(&head);			/* ���塼������ */

n1 = malloc(sizeof(struct entry));	/* ��Ƭ������ */
TAILQ_INSERT_HEAD(&head, n1, entries);

n1 = malloc(sizeof(struct entry));	/* ���������� */
TAILQ_INSERT_TAIL(&head, n1, entries);

n2 = malloc(sizeof(struct entry));	/* ��������� */
TAILQ_INSERT_AFTER(&head, n1, n2, entries);

n3 = malloc(sizeof(struct entry));	/* �������� */
TAILQ_INSERT_BEFORE(n2, n3, entries);

TAILQ_REMOVE(&head, n2, entries);	/* ��� */
free(n2);
					/* ������ */
TAILQ_FOREACH(np, &head, entries)
	np-> ...
					/* ������ */
TAILQ_FOREACH_REVERSE(np, &head, tailhead, entries)
	np-> ...
					/* �ơ��륭�塼�κ�� */
while (!TAILQ_EMPTY(&head)) {
	n1 = TAILQ_FIRST(&head);
	TAILQ_REMOVE(&head, n1, entries);
	free(n1);
}
					/* �ơ��륭�塼�ι�®�ʺ�� */
n1 = TAILQ_FIRST(&head);
while (n1 != NULL) {
	n2 = TAILQ_NEXT(n1, entries);
	free(n1);
	n1 = n2;
}
TAILQ_INIT(&head);
.Ed
.Sh �۴ĥ��塼
�۴ĥ��塼�κǽ�ˤϡ�
.Nm CIRCLEQ_HEAD
�ޥ������������빽¤�Τ��դ��ޤ���
���ι�¤�Τˤϡ��۴ĥ��塼����Ƭ�����Ǥ�ؤ��ݥ��󥿤�
�۴ĥ��塼�����������Ǥ�ؤ��ݥ��󥿤� 2 �Ĥ��ޤޤ�ޤ���
���Ǥ���Ť˥�󥯤���Ƥ���Τǡ����塼������������
Ǥ�դ����Ǥ����Ǥ��ޤ���
���������Ǥϡ���¸�����Ǥ�������¸�����Ǥθ�����۴ĥ��塼����Ƭ��
�۴ĥ��塼�������ǽ۴ĥ��塼���ɲäǤ��ޤ���
.Fa CIRCLEQ_HEAD
��¤�Τϰʲ��Τ褦���������ޤ���
.Bd -literal -offset indent
CIRCLEQ_HEAD(HEADNAME, TYPE) head;
.Ed
.Pp
������
.Li HEADNAME
��������빽¤�Τ�̾���ǡ�
.Li TYPE
�Ͻ۴ĥ��塼�˥�󥯤������Ǥη��Ǥ���
�۴ĥ��塼�ΥإåɤΥݥ��󥿤ϡ���ǰʲ��Τ褦������Ǥ��ޤ���
.Bd -literal -offset indent
struct HEADNAME *headp;
.Ed
.Pp
(̾��
.Li head
��
.Li headp
�ϡ��桼�������٤ޤ���)
.Pp
�ޥ���
.Nm CIRCLEQ_HEAD_INITIALIZER
�Ͻ۴ĥ��塼��
.Fa head
���������ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_EMPTY
�Ͻ۴ĥ��塼�����Ǥ��ʤ����˿��ˤʤ�ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_ENTRY
�Ͻ۴ĥ��塼�����Ǥ���³���빽¤�Τ�������ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_FIRST
�Ͻ۴ĥ��塼����Ƭ�����Ǥ��֤��ޤ���
.Pp
�ޥ���
.Nm CICRLEQ_FOREACH
��
.Fa head
�ǻ��Ȥ����۴ĥ��塼�򡢳����Ǥ���
.Fa var
�˳�����Ƥƽ��������������ޤ���
.Pp
�ޥ���
.Nm CICRLEQ_FOREACH_REVERSE
��
.Fa head
�ǻ��Ȥ����۴ĥ��塼�򡢳����Ǥ���
.Fa var
�˳�����ƤƵ��������������ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_INIT
��
.Fa head
�����Ȥ���۴ĥ��塼���������ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_INSERT_HEAD
�Ͽ���������
.Fa elm
��۴ĥ��塼����Ƭ���������ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_INSERT_TAIL
�Ͽ���������
.Fa elm
��۴ĥ��塼���������������ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_INSERT_AFTER
�Ͽ���������
.Fa elm
������
.Fa listelm
�θ�����������ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_INSERT_BEFORE
�Ͽ���������
.Fa elm
������
.Fa listelm
�������������ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_LAST
�Ͻ۴ĥ��塼�����������Ǥ��֤��ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_NEXT
�Ͻ۴ĥ��塼�μ������Ǥ��֤��ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_PREV
�Ͻ۴ĥ��塼���������Ǥ��֤��ޤ���
.Pp
�ޥ���
.Nm CIRCLEQ_REMOVE
������
.Fa elm
��۴ĥ��塼���������ޤ���
.Sh �۴ĥ��塼�λ�����
.Bd -literal
CIRCLEQ_HEAD(circlehead, entry) head =
    CIRCLEQ_HEAD_INITIALIZER(head);
struct circleq *headp;			/* �۴ĥ��塼�إå� */
struct entry {
	...
	CIRCLEQ_ENTRY(entry) entries;	/* �۴ĥ��塼 */
	...
} *n1, *n2, *np;

CIRCLEQ_INIT(&head);			/* �۴ĥ��塼������ */

n1 = malloc(sizeof(struct entry));	/* ��Ƭ������ */
CIRCLEQ_INSERT_HEAD(&head, n1, entries);

n1 = malloc(sizeof(struct entry));	/* ���������� */
CIRCLEQ_INSERT_TAIL(&head, n1, entries);

n2 = malloc(sizeof(struct entry));	/* ��������� */
CIRCLEQ_INSERT_AFTER(&head, n1, n2, entries);

n2 = malloc(sizeof(struct entry));	/* �������� */
CIRCLEQ_INSERT_BEFORE(&head, n1, n2, entries);

CIRCLEQ_REMOVE(&head, n1, entries);	/* ��� */
free(n1);
					/* ������ */
CIRCLEQ_FOREACH(np, &head, entries)
	np-> ...
					/* ������ */
CIRCLEQ_FOREACH_REVERSE(np, &head, entries)
	np-> ...
					/* �۴ĥ��塼�κ�� */
while (CIRCLEQ_FIRST(&head) != (void *)&head) {
	n1 = CIRCLEQ_HEAD(&head);
	CIRCLEQ_REMOVE(&head, n1, entries);
	free(n1);
}
					/* �۴ĥ��塼�ι�®�ʺ�� */
n1 = CIRCLEQ_FIRST(&head);
while (n1 != (void *)&head) {
	n2 = CIRCLEQ_NEXT(n1, entries);
	free(n1);
	n1 = n2;
}
CIRCLEQ_INIT(&head);
.Ed
.Sh ���
.Nm queue
�ؿ���
.Bx 4.4
�ǤϤ�����о줷�ޤ�����