[HICN-26] Windows compatibilty for libparc

Change-Id: I6ebff82a81a2bf42fa3bf210ff0e6e530ce21915
Signed-off-by: Angelo Mantellini <manangel@cisco.com>

6 files changed, 1199 insertions, 0 deletions

diff --git a/libparc/parc/windows/getopt.c b/libparc/parc/windows/getopt.c
new file mode 100644
index 00000000..1deaf81e
--- /dev/null
+++ b/libparc/parc/windows/getopt.c
@@ -0,0 +1,149 @@
+/*	$NetBSD: getopt.c,v 1.16 1999/12/02 13:15:56 kleink Exp $	*/

+

+/*

+ * Copyright (c) 1987, 1993, 1994, 1995

+ *	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. Neither the names of the copyright holders 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 COPYRIGHT HOLDERS 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.

+ */

+

+#if 0

+static char sccsid[] = "@(#)getopt.c	8.3 (Berkeley) 4/27/95";

+#endif

+

+#include <assert.h>

+#include <errno.h>

+#include <stdio.h>

+#include <string.h>

+

+#define __P(x) x

+#define _DIAGASSERT(x) assert(x)

+

+#ifdef __weak_alias

+__weak_alias(getopt,_getopt);

+#endif

+

+

+int	opterr = 1,		/* if error message should be printed */

+	optind = 1,		/* index into parent argv vector */

+	optopt,			/* character checked for validity */

+	optreset;		/* reset getopt */

+char	*optarg;		/* argument associated with option */

+

+static char * _progname __P((char *));

+int getopt_internal __P((int, char * const *, const char *));

+

+static char *

+_progname(nargv0)

+	char * nargv0;

+{

+	char * tmp;

+

+	_DIAGASSERT(nargv0 != NULL);

+

+	tmp = strrchr(nargv0, '/');

+	if (tmp)

+		tmp++;

+	else

+		tmp = nargv0;

+	return(tmp);

+}

+

+#define	BADCH	(int)'?'

+#define	BADARG	(int)':'

+#define	EMSG	""

+

+/*

+ * getopt --

+ *	Parse argc/argv argument vector.

+ */

+int

+getopt(nargc, nargv, ostr)

+	int nargc;

+	char * const nargv[];

+	const char *ostr;

+{

+	static char *__progname = 0;

+	static char *place = EMSG;		/* option letter processing */

+	char *oli;				/* option letter list index */

+        __progname = __progname?__progname:_progname(*nargv);

+

+	_DIAGASSERT(nargv != NULL);

+	_DIAGASSERT(ostr != NULL);

+

+	if (optreset || !*place) {		/* update scanning pointer */

+		optreset = 0;

+		if (optind >= nargc || *(place = nargv[optind]) != '-') {

+			place = EMSG;

+			return (-1);

+		}

+		if (place[1] && *++place == '-'	/* found "--" */

+		    && place[1] == '\0') {

+			++optind;

+			place = EMSG;

+			return (-1);

+		}

+	}					/* option letter okay? */

+	if ((optopt = (int)*place++) == (int)':' ||

+	    !(oli = strchr(ostr, optopt))) {

+		/*

+		 * if the user didn't specify '-' as an option,

+		 * assume it means -1.

+		 */

+		if (optopt == (int)'-')

+			return (-1);

+		if (!*place)

+			++optind;

+		if (opterr && *ostr != ':')

+			(void)fprintf(stderr,

+			    "%s: illegal option -- %c\n", __progname, optopt);

+		return (BADCH);

+	}

+	if (*++oli != ':') {			/* don't need argument */

+		optarg = NULL;

+		if (!*place)

+			++optind;

+	}

+	else {					/* need an argument */

+		if (*place)			/* no white space */

+			optarg = place;

+		else if (nargc <= ++optind) {	/* no arg */

+			place = EMSG;

+			if (*ostr == ':')

+				return (BADARG);

+			if (opterr)

+				(void)fprintf(stderr,

+				    "%s: option requires an argument -- %c\n",

+				    __progname, optopt);

+			return (BADCH);

+		}

+	 	else				/* white space */

+			optarg = nargv[optind];

+		place = EMSG;

+		++optind;

+	}

+	return (optopt);			/* dump back option letter */

+}

+

diff --git a/libparc/parc/windows/getopt.h b/libparc/parc/windows/getopt.h
new file mode 100644
index 00000000..6f0c19ee
--- /dev/null
+++ b/libparc/parc/windows/getopt.h
@@ -0,0 +1,33 @@
+#ifndef __GETOPT_H__

+#define __GETOPT_H__

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+extern int opterr;		/* if error message should be printed */

+extern int optind;		/* index into parent argv vector */

+extern int optopt;		/* character checked for validity */

+extern int optreset;		/* reset getopt */

+extern char *optarg;		/* argument associated with option */

+

+struct option

+{

+  const char *name;

+  int has_arg;

+  int *flag;

+  int val;

+};

+

+#define no_argument       0

+#define required_argument 1

+#define optional_argument 2

+

+int getopt(int, char**, const char*);

+int getopt_long(int, char**, const char*, const struct option*, int*);

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* __GETOPT_H__ */

diff --git a/libparc/parc/windows/getopt_long.c b/libparc/parc/windows/getopt_long.c
new file mode 100644
index 00000000..23321dd1
--- /dev/null
+++ b/libparc/parc/windows/getopt_long.c
@@ -0,0 +1,233 @@
+

+/*

+ * Copyright (c) 1987, 1993, 1994, 1996

+ *	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. Neither the names of the copyright holders 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 COPYRIGHT HOLDERS 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.

+ */

+#include <assert.h>

+#include <errno.h>

+#include <stdio.h>

+#include <stdlib.h>

+#include <string.h>

+#include "getopt.h"

+

+extern int	  opterr;	/* if error message should be printed */

+extern int	  optind;	/* index into parent argv vector */

+extern int	  optopt;	/* character checked for validity */

+extern int	  optreset;	/* reset getopt */

+extern char *optarg;	/* argument associated with option */

+

+#define __P(x) x

+#define _DIAGASSERT(x) assert(x)

+

+static char * __progname __P((char *));

+int getopt_internal __P((int, char * const *, const char *));

+

+static char *

+__progname(nargv0)

+	char * nargv0;

+{

+	char * tmp;

+

+	_DIAGASSERT(nargv0 != NULL);

+

+	tmp = strrchr(nargv0, '/');

+	if (tmp)

+		tmp++;

+	else

+		tmp = nargv0;

+	return(tmp);

+}

+

+#define	BADCH	(int)'?'

+#define	BADARG	(int)':'

+#define	EMSG	""

+

+/*

+ * getopt --

+ *	Parse argc/argv argument vector.

+ */

+int

+getopt_internal(nargc, nargv, ostr)

+	int nargc;

+	char * const *nargv;

+	const char *ostr;

+{

+	static char *place = EMSG;		/* option letter processing */

+	char *oli;				/* option letter list index */

+

+	_DIAGASSERT(nargv != NULL);

+	_DIAGASSERT(ostr != NULL);

+

+	if (optreset || !*place) {		/* update scanning pointer */

+		optreset = 0;

+		if (optind >= nargc || *(place = nargv[optind]) != '-') {

+			place = EMSG;

+			return (-1);

+		}

+		if (place[1] && *++place == '-') {	/* found "--" */

+			/* ++optind; */

+			place = EMSG;

+			return (-2);

+		}

+	}					/* option letter okay? */

+	if ((optopt = (int)*place++) == (int)':' ||

+	    !(oli = strchr(ostr, optopt))) {

+		/*

+		 * if the user didn't specify '-' as an option,

+		 * assume it means -1.

+		 */

+		if (optopt == (int)'-')

+			return (-1);

+		if (!*place)

+			++optind;

+		if (opterr && *ostr != ':')

+			(void)fprintf(stderr,

+			    "%s: illegal option -- %c\n", __progname(nargv[0]), optopt);

+		return (BADCH);

+	}

+	if (*++oli != ':') {			/* don't need argument */

+		optarg = NULL;

+		if (!*place)

+			++optind;

+	} else {				/* need an argument */

+		if (*place)			/* no white space */

+			optarg = place;

+		else if (nargc <= ++optind) {	/* no arg */

+			place = EMSG;

+			if ((opterr) && (*ostr != ':'))

+				(void)fprintf(stderr,

+				    "%s: option requires an argument -- %c\n",

+				    __progname(nargv[0]), optopt);

+			return (BADARG);

+		} else				/* white space */

+			optarg = nargv[optind];

+		place = EMSG;

+		++optind;

+	}

+	return (optopt);			/* dump back option letter */

+}

+

+#if 0

+/*

+ * getopt --

+ *	Parse argc/argv argument vector.

+ */

+int

+getopt2(nargc, nargv, ostr)

+	int nargc;

+	char * const *nargv;

+	const char *ostr;

+{

+	int retval;

+

+	if ((retval = getopt_internal(nargc, nargv, ostr)) == -2) {

+		retval = -1;

+		++optind; 

+	}

+	return(retval);

+}

+#endif

+

+/*

+ * getopt_long --

+ *	Parse argc/argv argument vector.

+ */

+int

+getopt_long(nargc, nargv, options, long_options, index)

+	int nargc;

+	char ** nargv;

+	const char * options;

+	const struct option * long_options;

+	int * index;

+{

+	int retval;

+

+	_DIAGASSERT(nargv != NULL);

+	_DIAGASSERT(options != NULL);

+	_DIAGASSERT(long_options != NULL);

+	/* index may be NULL */

+

+	if ((retval = getopt_internal(nargc, nargv, options)) == -2) {

+		char *current_argv = nargv[optind++] + 2, *has_equal;

+		int i, current_argv_len, match = -1;

+

+		if (*current_argv == '\0') {

+			return(-1);

+		}

+		if ((has_equal = strchr(current_argv, '=')) != NULL) {

+			current_argv_len = (int)(has_equal - current_argv);

+			has_equal++;

+		} else

+			current_argv_len = (int)strlen(current_argv);

+

+		for (i = 0; long_options[i].name; i++) { 

+			if (strncmp(current_argv, long_options[i].name, current_argv_len))

+				continue;

+

+			if (strlen(long_options[i].name) == (unsigned)current_argv_len) { 

+				match = i;

+				break;

+			}

+			if (match == -1)

+				match = i;

+		}

+		if (match != -1) {

+			if (long_options[match].has_arg == required_argument ||

+			    long_options[match].has_arg == optional_argument) {

+				if (has_equal)

+					optarg = has_equal;

+				else

+					optarg = nargv[optind++];

+			}

+			if ((long_options[match].has_arg == required_argument)

+			    && (optarg == NULL)) {

+				/*

+				 * Missing argument, leading :

+				 * indicates no error should be generated

+				 */

+				if ((opterr) && (*options != ':'))

+					(void)fprintf(stderr,

+				      "%s: option requires an argument -- %s\n",

+				      __progname(nargv[0]), current_argv);

+				return (BADARG);

+			}

+		} else { /* No matching argument */

+			if ((opterr) && (*options != ':'))

+				(void)fprintf(stderr,

+				    "%s: illegal option -- %s\n", __progname(nargv[0]), current_argv);

+			return (BADCH);

+		}

+		if (long_options[match].flag) {

+			*long_options[match].flag = long_options[match].val;

+			retval = 0;

+		} else 

+			retval = long_options[match].val;

+		if (index)

+			*index = match;

+	}

+	return(retval);

+}

diff --git a/libparc/parc/windows/parc_Utils.c b/libparc/parc/windows/parc_Utils.c
new file mode 100644
index 00000000..8daf57fd
--- /dev/null
+++ b/libparc/parc/windows/parc_Utils.c
@@ -0,0 +1,128 @@
+

+/*

+ * Copyright (c) 2019 Cisco and/or its affiliates.

+ * 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.

+ */

+

+#include <parc/windows/parc_Utils.h>

+#include <Windows.h>

+#include <stdint.h>

+#include <stdio.h>

+#ifndef _vscprintf

+/* For some reason, MSVC fails to honour this #ifndef. */

+/* Hence function renamed to _vscprintf_so(). */

+int _vscprintf_so(const char *format, va_list pargs)

+{

+    int retval;

+    va_list argcopy;

+    va_copy(argcopy, pargs);

+    retval = vsnprintf(NULL, 0, format, argcopy);

+    va_end(argcopy);

+    return retval;

+}

+#endif // _vscprintf

+

+#ifndef vasprintf

+int vasprintf(char **strp, const char *fmt, va_list ap)

+{

+    int len = _vscprintf_so(fmt, ap);

+    if (len == -1)

+        return -1;

+    char *str = malloc((size_t)len + 1);

+    if (!str)

+        return -1;

+    int r = vsnprintf(str, len + 1, fmt, ap); /* "secure" version of vsprintf */

+    if (r == -1)

+        return free(str), -1;

+    *strp = str;

+    return r;

+}

+#endif // vasprintf

+

+#ifndef dprintf

+int dprintf(int fd, char *fmt, ...) {

+    va_list ap;

+    FILE *f = _fdopen( fd, "rw" );

+    int rc;

+

+    va_start(ap, &fmt);

+    rc = vfprintf(f, fmt, ap);

+    fclose(f);

+    va_end(ap);

+    return rc;

+}

+#endif

+

+#ifndef asprintf

+int asprintf(char *strp[], const char *fmt, ...)

+{

+    va_list ap;

+    va_start(ap, fmt);

+    int r = vasprintf(strp, fmt, ap);

+    va_end(ap);

+    return r;

+}

+#endif // asprintf

+

+

+int gettimeofday(struct timeval * tp, struct timezone * tzp)

+{

+    // Note: some broken versions only have 8 trailing zero's, the correct epoch has 9 trailing zero's

+    // This magic number is the number of 100 nanosecond intervals since January 1, 1601 (UTC)

+    // until 00:00:00 January 1, 1970

+    static const uint64_t EPOCH = ((uint64_t) 116444736000000000ULL);

+

+    SYSTEMTIME  system_time;

+    FILETIME    file_time;

+    uint64_t    time;

+

+    GetSystemTime( &system_time );

+    SystemTimeToFileTime( &system_time, &file_time );

+    time =  ((uint64_t)file_time.dwLowDateTime )      ;

+    time += ((uint64_t)file_time.dwHighDateTime) << 32;

+

+    tp->tv_sec  = (long) ((time - EPOCH) / 10000000L);

+    tp->tv_usec = (long) (system_time.wMilliseconds * 1000);

+    return 0;

+}

+

+#ifndef strndup

+char *strndup(const char *str, size_t chars)

+{

+    char *buffer;

+    int n;

+

+    buffer = (char *) malloc(chars +1);

+    if (buffer)

+    {

+        for (n = 0; ((n < chars) && (str[n] != 0)) ; n++) buffer[n] = str[n];

+        buffer[n] = 0;

+    }

+

+    return buffer;

+}

+#endif

+

+

+void usleep(__int64 usec)

+{

+	HANDLE timer;

+	LARGE_INTEGER ft;

+

+	ft.QuadPart = -(10 * usec); // Convert to 100 nanosecond interval, negative value indicates relative time

+

+	timer = CreateWaitableTimer(NULL, TRUE, NULL);

+	SetWaitableTimer(timer, &ft, 0, NULL, NULL, 0);

+	WaitForSingleObject(timer, INFINITE);

+	CloseHandle(timer);

+}
\ No newline at end of file
diff --git a/libparc/parc/windows/parc_Utils.h b/libparc/parc/windows/parc_Utils.h
new file mode 100644
index 00000000..975eae0f
--- /dev/null
+++ b/libparc/parc/windows/parc_Utils.h
@@ -0,0 +1,168 @@
+/*

+ * Copyright (c) 2019 Cisco and/or its affiliates.

+ * 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.

+ */

+

+#ifndef PARC_UTILS_H

+#define PARC_UTILS_H

+#define WIN32_LEAN_AND_MEAN

+#define HAVE_STRUCT_TIMESPEC

+#include <Windows.h>

+#include <stdint.h>

+#include <io.h>

+#include <stdlib.h>

+#include <winsock2.h>

+#include <WS2tcpip.h>

+#include <parc/windows/getopt.h>

+#include <parc/windows/queue.h>

+

+#ifndef IOVEC

+#define IOVEC

+struct iovec {

+	void* iov_base;

+	size_t iov_len;

+};

+#endif

+

+typedef uint16_t in_port_t;

+

+#ifndef SLEEP

+#define SLEEP

+#define sleep Sleep

+#endif

+

+#ifndef USLEEP

+#define USLEEP

+void usleep(__int64 usec);

+#endif

+

+#ifndef S_ISDIR

+#define S_ISDIR(mode)  (((mode) & S_IFMT) == S_IFDIR)

+#endif

+

+#define PARCLibrary_DISABLE_ATOMICS

+#include <BaseTsd.h>

+typedef SSIZE_T ssize_t;

+

+#ifndef __ATTRIBUTE__

+#define __ATTRIBUTE__

+#define __attribute__(A)

+#endif

+

+#ifndef RESTRICT

+#define RESTRICT

+#define restrict __restrict

+#endif

+

+#ifndef _vscprintf

+/* For some reason, MSVC fails to honour this #ifndef. */

+/* Hence function renamed to _vscprintf_so(). */

+int _vscprintf_so(const char *format, va_list pargs);

+#endif // _vscprintf

+

+#ifndef vasprintf

+int vasprintf(char **strp, const char *fmt, va_list ap);

+#endif // vasprintf

+

+#ifndef asprintf

+int asprintf(char *strp[], const char *fmt, ...);

+#endif // asprintf

+

+#ifndef GETTIMEOFDAY

+#define GETTIMEOFDAY

+int gettimeofday(struct timeval * tp, struct timezone * tzp);

+#endif

+

+#ifndef strndup

+char *strndup(const char *str, size_t chars);

+#endif

+

+#ifndef dprintf

+int dprintf(int fd, char *fmt, ...);

+#endif

+

+#ifndef timersub

+#define timersub(a, b, result) \

+        do { \

+                (result)->tv_sec = (a)->tv_sec - (b)->tv_sec; \

+                (result)->tv_usec = (a)->tv_usec - (b)->tv_usec; \

+                if ((result)->tv_usec < 0) { \

+                        --(result)->tv_sec; \

+                        (result)->tv_usec += 1000000; \

+                } \

+        } while (0)

+#endif // timersub

+

+#ifndef dup

+#define dup _dup

+#endif

+

+#ifndef access

+#define access _access

+#endif

+

+#ifndef close

+#define close _close

+#endif

+

+#ifndef write

+#define write _write

+#endif

+

+#ifndef open

+#define open _open

+#endif

+

+#ifndef unlink

+#define unlink _unlink

+#endif

+

+#ifndef read

+#define read _read

+#endif

+

+#ifndef strcasecmp

+#define strncasecmp _strnicmp

+#endif

+

+#ifndef strcasecmp

+

+#define strcasecmp _stricmp

+#endif

+

+#ifndef S_ISREG

+#define S_ISREG(mode)  (((mode) & S_IFMT) == S_IFREG)

+#endif

+#ifndef R_OK

+#define R_OK    4       /* Test for read permission.  */

+#endif

+#ifndef  W_OK

+#define W_OK    2       /* Test for write permission.  */

+#endif

+#ifndef F_OK

+#define F_OK    0

+#endif

+

+#ifndef STDIN_FILENO

+#define STDIN_FILENO _fileno(stdin)

+#endif

+

+#ifndef STDOUT_FILENO

+#define STDOUT_FILENO _fileno(stdout)

+#endif

+

+#ifndef STDERR_FILENO

+#define STDERR_FILENO _fileno(stderr)

+#endif

+

+#endif
\ No newline at end of file
diff --git a/libparc/parc/windows/queue.h b/libparc/parc/windows/queue.h
new file mode 100644
index 00000000..925ccf14
--- /dev/null
+++ b/libparc/parc/windows/queue.h
@@ -0,0 +1,488 @@
+/*	$OpenBSD: queue.h,v 1.16 2000/09/07 19:47:59 art Exp $	*/

+/*	$NetBSD: queue.h,v 1.11 1996/05/16 05:17:14 mycroft Exp $	*/

+

+/*

+ * Copyright (c) 1991, 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. 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.h	8.5 (Berkeley) 8/20/94

+ */

+

+#ifndef	SYS_QUEUE_H__

+#define	SYS_QUEUE_H__

+

+ /*

+  * This file defines five types of data structures: singly-linked lists,

+  * lists, simple queues, tail queues, and circular queues.

+  *

+  *

+  * A singly-linked list is headed by a single forward pointer. The elements

+  * are singly linked for minimum space and pointer manipulation overhead at

+  * the expense of O(n) removal for arbitrary elements. New elements can be

+  * added to the list after an existing element or at the head of the list.

+  * Elements being removed from the head of the list should use the explicit

+  * macro for this purpose for optimum efficiency. A singly-linked list may

+  * only be traversed in the forward direction.  Singly-linked lists are ideal

+  * for applications with large datasets and few or no removals or for

+  * implementing a LIFO queue.

+  *

+  * A list is headed by a single forward pointer (or an array of forward

+  * pointers for a hash table header). The elements are doubly linked

+  * so that an arbitrary element can be removed without a need to

+  * traverse the list. New elements can be added to the list before

+  * or after an existing element or at the head of the list. A list

+  * may only be traversed in the forward direction.

+  *

+  * A simple queue is headed by a pair of pointers, one the head of the

+  * list and the other to the tail of the list. The elements are singly

+  * linked to save space, so elements can only be removed from the

+  * head of the list. New elements can be added to the list before or after

+  * an existing element, at the head of the list, or at the end of the

+  * list. A simple queue may only be traversed in the forward direction.

+  *

+  * A tail queue is headed by a pair of pointers, one to the head of the

+  * list and the other to the tail of the list. The elements are doubly

+  * linked so that an arbitrary element can be removed without a need to

+  * traverse the list. New elements can be added to the list before or

+  * after an existing element, at the head of the list, or at the end of

+  * the list. A tail queue may be traversed in either direction.

+  *

+  * A circle queue is headed by a pair of pointers, one to the head of the

+  * list and the other to the tail of the list. The elements are doubly

+  * linked so that an arbitrary element can be removed without a need to

+  * traverse the list. New elements can be added to the list before or after

+  * an existing element, at the head of the list, or at the end of the list.

+  * A circle queue may be traversed in either direction, but has a more

+  * complex end of list detection.

+  *

+  * For details on the use of these macros, see the queue(3) manual page.

+  */

+

+  /*

+   * Singly-linked List definitions.

+   */

+#define SLIST_HEAD(name, type)						\

+struct name {								\

+	struct type *slh_first;	/* first element */			\

+}

+

+#define	SLIST_HEAD_INITIALIZER(head)					\

+	{ NULL }

+

+#ifndef _WIN32

+#define SLIST_ENTRY(type)						\

+struct {								\

+	struct type *sle_next;	/* next element */			\

+}

+#endif

+

+   /*

+	* Singly-linked List access methods.

+	*/

+#define	SLIST_FIRST(head)	((head)->slh_first)

+#define	SLIST_END(head)		NULL

+#define	SLIST_EMPTY(head)	(SLIST_FIRST(head) == SLIST_END(head))

+#define	SLIST_NEXT(elm, field)	((elm)->field.sle_next)

+

+#define	SLIST_FOREACH(var, head, field)					\

+	for((var) = SLIST_FIRST(head);					\

+	    (var) != SLIST_END(head);					\

+	    (var) = SLIST_NEXT(var, field))

+

+	/*

+	 * Singly-linked List functions.

+	 */

+#define	SLIST_INIT(head) {						\

+	SLIST_FIRST(head) = SLIST_END(head);				\

+}

+

+#define	SLIST_INSERT_AFTER(slistelm, elm, field) do {			\

+	(elm)->field.sle_next = (slistelm)->field.sle_next;		\

+	(slistelm)->field.sle_next = (elm);				\

+} while (0)

+

+#define	SLIST_INSERT_HEAD(head, elm, field) do {			\

+	(elm)->field.sle_next = (head)->slh_first;			\

+	(head)->slh_first = (elm);					\

+} while (0)

+

+#define	SLIST_REMOVE_HEAD(head, field) do {				\

+	(head)->slh_first = (head)->slh_first->field.sle_next;		\

+} while (0)

+

+	 /*

+	  * List definitions.

+	  */

+#define LIST_HEAD(name, type)						\

+struct name {								\

+	struct type *lh_first;	/* first element */			\

+}

+

+#define LIST_HEAD_INITIALIZER(head)					\

+	{ NULL }

+

+#define LIST_ENTRY(type)						\

+struct {								\

+	struct type *le_next;	/* next element */			\

+	struct type **le_prev;	/* address of previous next element */	\

+}

+

+	  /*

+	   * List access methods

+	   */

+#define	LIST_FIRST(head)		((head)->lh_first)

+#define	LIST_END(head)			NULL

+#define	LIST_EMPTY(head)		(LIST_FIRST(head) == LIST_END(head))

+#define	LIST_NEXT(elm, field)		((elm)->field.le_next)

+

+#define LIST_FOREACH(var, head, field)					\

+	for((var) = LIST_FIRST(head);					\

+	    (var)!= LIST_END(head);					\

+	    (var) = LIST_NEXT(var, field))

+

+	   /*

+		* List functions.

+		*/

+#define	LIST_INIT(head) do {						\

+	LIST_FIRST(head) = LIST_END(head);				\

+} while (0)

+

+#define LIST_INSERT_AFTER(listelm, elm, field) do {			\

+	if (((elm)->field.le_next = (listelm)->field.le_next) != NULL)	\

+		(listelm)->field.le_next->field.le_prev =		\

+		    &(elm)->field.le_next;				\

+	(listelm)->field.le_next = (elm);				\

+	(elm)->field.le_prev = &(listelm)->field.le_next;		\

+} while (0)

+

+#define	LIST_INSERT_BEFORE(listelm, elm, field) do {			\

+	(elm)->field.le_prev = (listelm)->field.le_prev;		\

+	(elm)->field.le_next = (listelm);				\

+	*(listelm)->field.le_prev = (elm);				\

+	(listelm)->field.le_prev = &(elm)->field.le_next;		\

+} while (0)

+

+#define LIST_INSERT_HEAD(head, elm, field) do {				\

+	if (((elm)->field.le_next = (head)->lh_first) != NULL)		\

+		(head)->lh_first->field.le_prev = &(elm)->field.le_next;\

+	(head)->lh_first = (elm);					\

+	(elm)->field.le_prev = &(head)->lh_first;			\

+} while (0)

+

+#define LIST_REMOVE(elm, field) do {					\

+	if ((elm)->field.le_next != NULL)				\

+		(elm)->field.le_next->field.le_prev =			\

+		    (elm)->field.le_prev;				\

+	*(elm)->field.le_prev = (elm)->field.le_next;			\

+} while (0)

+

+#define LIST_REPLACE(elm, elm2, field) do {				\

+	if (((elm2)->field.le_next = (elm)->field.le_next) != NULL)	\

+		(elm2)->field.le_next->field.le_prev =			\

+		    &(elm2)->field.le_next;				\

+	(elm2)->field.le_prev = (elm)->field.le_prev;			\

+	*(elm2)->field.le_prev = (elm2);				\

+} while (0)

+

+		/*

+		 * Simple queue definitions.

+		 */

+#define SIMPLEQ_HEAD(name, type)					\

+struct name {								\

+	struct type *sqh_first;	/* first element */			\

+	struct type **sqh_last;	/* addr of last next element */		\

+}

+

+#define SIMPLEQ_HEAD_INITIALIZER(head)					\

+	{ NULL, &(head).sqh_first }

+

+#define SIMPLEQ_ENTRY(type)						\

+struct {								\

+	struct type *sqe_next;	/* next element */			\

+}

+

+		 /*

+		  * Simple queue access methods.

+		  */

+#define	SIMPLEQ_FIRST(head)	    ((head)->sqh_first)

+#define	SIMPLEQ_END(head)	    NULL

+#define	SIMPLEQ_EMPTY(head)	    (SIMPLEQ_FIRST(head) == SIMPLEQ_END(head))

+#define	SIMPLEQ_NEXT(elm, field)    ((elm)->field.sqe_next)

+

+#define SIMPLEQ_FOREACH(var, head, field)				\

+	for((var) = SIMPLEQ_FIRST(head);				\

+	    (var) != SIMPLEQ_END(head);					\

+	    (var) = SIMPLEQ_NEXT(var, field))

+

+		  /*

+		   * Simple queue functions.

+		   */

+#define	SIMPLEQ_INIT(head) do {						\

+	(head)->sqh_first = NULL;					\

+	(head)->sqh_last = &(head)->sqh_first;				\

+} while (0)

+

+#define SIMPLEQ_INSERT_HEAD(head, elm, field) do {			\

+	if (((elm)->field.sqe_next = (head)->sqh_first) == NULL)	\

+		(head)->sqh_last = &(elm)->field.sqe_next;		\

+	(head)->sqh_first = (elm);					\

+} while (0)

+

+#define SIMPLEQ_INSERT_TAIL(head, elm, field) do {			\

+	(elm)->field.sqe_next = NULL;					\

+	*(head)->sqh_last = (elm);					\

+	(head)->sqh_last = &(elm)->field.sqe_next;			\

+} while (0)

+

+#define SIMPLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\

+	if (((elm)->field.sqe_next = (listelm)->field.sqe_next) == NULL)\

+		(head)->sqh_last = &(elm)->field.sqe_next;		\

+	(listelm)->field.sqe_next = (elm);				\

+} while (0)

+

+#define SIMPLEQ_REMOVE_HEAD(head, elm, field) do {			\

+	if (((head)->sqh_first = (elm)->field.sqe_next) == NULL)	\

+		(head)->sqh_last = &(head)->sqh_first;			\

+} while (0)

+

+		   /*

+			* Tail queue definitions.

+			*/

+#define TAILQ_HEAD(name, type)						\

+struct name {								\

+	struct type *tqh_first;	/* first element */			\

+	struct type **tqh_last;	/* addr of last next element */		\

+}

+

+#define TAILQ_HEAD_INITIALIZER(head)					\

+	{ NULL, &(head).tqh_first }

+

+#define TAILQ_ENTRY(type)						\

+struct {								\

+	struct type *tqe_next;	/* next element */			\

+	struct type **tqe_prev;	/* address of previous next element */	\

+}

+

+			/*

+			 * tail queue access methods

+			 */

+#define	TAILQ_FIRST(head)		((head)->tqh_first)

+#define	TAILQ_END(head)			NULL

+#define	TAILQ_NEXT(elm, field)		((elm)->field.tqe_next)

+#define TAILQ_LAST(head, headname)					\

+	(*(((struct headname *)((head)->tqh_last))->tqh_last))

+			 /* XXX */

+#define TAILQ_PREV(elm, headname, field)				\

+	(*(((struct headname *)((elm)->field.tqe_prev))->tqh_last))

+#define	TAILQ_EMPTY(head)						\

+	(TAILQ_FIRST(head) == TAILQ_END(head))

+

+#define TAILQ_FOREACH(var, head, field)					\

+	for((var) = TAILQ_FIRST(head);					\

+	    (var) != TAILQ_END(head);					\

+	    (var) = TAILQ_NEXT(var, field))

+

+#define TAILQ_FOREACH_REVERSE(var, head, headname, field)		\

+	for((var) = TAILQ_LAST(head, headname);				\

+	    (var) != TAILQ_END(head);					\

+	    (var) = TAILQ_PREV(var, headname, field))

+

+/*

+ * Tail queue functions.

+ */

+#define	TAILQ_INIT(head) do {						\

+	(head)->tqh_first = NULL;					\

+	(head)->tqh_last = &(head)->tqh_first;				\

+} while (0)

+

+#define TAILQ_INSERT_HEAD(head, elm, field) do {			\

+	if (((elm)->field.tqe_next = (head)->tqh_first) != NULL)	\

+		(head)->tqh_first->field.tqe_prev =			\

+		    &(elm)->field.tqe_next;				\

+	else								\

+		(head)->tqh_last = &(elm)->field.tqe_next;		\

+	(head)->tqh_first = (elm);					\

+	(elm)->field.tqe_prev = &(head)->tqh_first;			\

+} while (0)

+

+#define TAILQ_INSERT_TAIL(head, elm, field) do {			\

+	(elm)->field.tqe_next = NULL;					\

+	(elm)->field.tqe_prev = (head)->tqh_last;			\

+	*(head)->tqh_last = (elm);					\

+	(head)->tqh_last = &(elm)->field.tqe_next;			\

+} while (0)

+

+#define TAILQ_INSERT_AFTER(head, listelm, elm, field) do {		\

+	if (((elm)->field.tqe_next = (listelm)->field.tqe_next) != NULL)\

+		(elm)->field.tqe_next->field.tqe_prev =			\

+		    &(elm)->field.tqe_next;				\

+	else								\

+		(head)->tqh_last = &(elm)->field.tqe_next;		\

+	(listelm)->field.tqe_next = (elm);				\

+	(elm)->field.tqe_prev = &(listelm)->field.tqe_next;		\

+} while (0)

+

+#define	TAILQ_INSERT_BEFORE(listelm, elm, field) do {			\

+	(elm)->field.tqe_prev = (listelm)->field.tqe_prev;		\

+	(elm)->field.tqe_next = (listelm);				\

+	*(listelm)->field.tqe_prev = (elm);				\

+	(listelm)->field.tqe_prev = &(elm)->field.tqe_next;		\

+} while (0)

+

+#define TAILQ_REMOVE(head, elm, field) do {				\

+	if (((elm)->field.tqe_next) != NULL)				\

+		(elm)->field.tqe_next->field.tqe_prev =			\

+		    (elm)->field.tqe_prev;				\

+	else								\

+		(head)->tqh_last = (elm)->field.tqe_prev;		\

+	*(elm)->field.tqe_prev = (elm)->field.tqe_next;			\

+} while (0)

+

+#define TAILQ_REPLACE(head, elm, elm2, field) do {			\

+	if (((elm2)->field.tqe_next = (elm)->field.tqe_next) != NULL)	\

+		(elm2)->field.tqe_next->field.tqe_prev =		\

+		    &(elm2)->field.tqe_next;				\

+	else								\

+		(head)->tqh_last = &(elm2)->field.tqe_next;		\

+	(elm2)->field.tqe_prev = (elm)->field.tqe_prev;			\

+	*(elm2)->field.tqe_prev = (elm2);				\

+} while (0)

+

+ /*

+  * Circular queue definitions.

+  */

+#define CIRCLEQ_HEAD(name, type)					\

+struct name {								\

+	struct type *cqh_first;		/* first element */		\

+	struct type *cqh_last;		/* last element */		\

+}

+

+#define CIRCLEQ_HEAD_INITIALIZER(head)					\

+	{ CIRCLEQ_END(&head), CIRCLEQ_END(&head) }

+

+#define CIRCLEQ_ENTRY(type)						\

+struct {								\

+	struct type *cqe_next;		/* next element */		\

+	struct type *cqe_prev;		/* previous element */		\

+}

+

+  /*

+   * Circular queue access methods

+   */

+#define	CIRCLEQ_FIRST(head)		((head)->cqh_first)

+#define	CIRCLEQ_LAST(head)		((head)->cqh_last)

+#define	CIRCLEQ_END(head)		((void *)(head))

+#define	CIRCLEQ_NEXT(elm, field)	((elm)->field.cqe_next)

+#define	CIRCLEQ_PREV(elm, field)	((elm)->field.cqe_prev)

+#define	CIRCLEQ_EMPTY(head)						\

+	(CIRCLEQ_FIRST(head) == CIRCLEQ_END(head))

+

+#define CIRCLEQ_FOREACH(var, head, field)				\

+	for((var) = CIRCLEQ_FIRST(head);				\

+	    (var) != CIRCLEQ_END(head);					\

+	    (var) = CIRCLEQ_NEXT(var, field))

+

+#define CIRCLEQ_FOREACH_REVERSE(var, head, field)			\

+	for((var) = CIRCLEQ_LAST(head);					\

+	    (var) != CIRCLEQ_END(head);					\

+	    (var) = CIRCLEQ_PREV(var, field))

+

+   /*

+	* Circular queue functions.

+	*/

+#define	CIRCLEQ_INIT(head) do {						\

+	(head)->cqh_first = CIRCLEQ_END(head);				\

+	(head)->cqh_last = CIRCLEQ_END(head);				\

+} while (0)

+

+#define CIRCLEQ_INSERT_AFTER(head, listelm, elm, field) do {		\

+	(elm)->field.cqe_next = (listelm)->field.cqe_next;		\

+	(elm)->field.cqe_prev = (listelm);				\

+	if ((listelm)->field.cqe_next == CIRCLEQ_END(head))		\

+		(head)->cqh_last = (elm);				\

+	else								\

+		(listelm)->field.cqe_next->field.cqe_prev = (elm);	\

+	(listelm)->field.cqe_next = (elm);				\

+} while (0)

+

+#define CIRCLEQ_INSERT_BEFORE(head, listelm, elm, field) do {		\

+	(elm)->field.cqe_next = (listelm);				\

+	(elm)->field.cqe_prev = (listelm)->field.cqe_prev;		\

+	if ((listelm)->field.cqe_prev == CIRCLEQ_END(head))		\

+		(head)->cqh_first = (elm);				\

+	else								\

+		(listelm)->field.cqe_prev->field.cqe_next = (elm);	\

+	(listelm)->field.cqe_prev = (elm);				\

+} while (0)

+

+#define CIRCLEQ_INSERT_HEAD(head, elm, field) do {			\

+	(elm)->field.cqe_next = (head)->cqh_first;			\

+	(elm)->field.cqe_prev = CIRCLEQ_END(head);			\

+	if ((head)->cqh_last == CIRCLEQ_END(head))			\

+		(head)->cqh_last = (elm);				\

+	else								\

+		(head)->cqh_first->field.cqe_prev = (elm);		\

+	(head)->cqh_first = (elm);					\

+} while (0)

+

+#define CIRCLEQ_INSERT_TAIL(head, elm, field) do {			\

+	(elm)->field.cqe_next = CIRCLEQ_END(head);			\

+	(elm)->field.cqe_prev = (head)->cqh_last;			\

+	if ((head)->cqh_first == CIRCLEQ_END(head))			\

+		(head)->cqh_first = (elm);				\

+	else								\

+		(head)->cqh_last->field.cqe_next = (elm);		\

+	(head)->cqh_last = (elm);					\

+} while (0)

+

+#define	CIRCLEQ_REMOVE(head, elm, field) do {				\

+	if ((elm)->field.cqe_next == CIRCLEQ_END(head))			\

+		(head)->cqh_last = (elm)->field.cqe_prev;		\

+	else								\

+		(elm)->field.cqe_next->field.cqe_prev =			\

+		    (elm)->field.cqe_prev;				\

+	if ((elm)->field.cqe_prev == CIRCLEQ_END(head))			\

+		(head)->cqh_first = (elm)->field.cqe_next;		\

+	else								\

+		(elm)->field.cqe_prev->field.cqe_next =			\

+		    (elm)->field.cqe_next;				\

+} while (0)

+

+#define CIRCLEQ_REPLACE(head, elm, elm2, field) do {			\

+	if (((elm2)->field.cqe_next = (elm)->field.cqe_next) ==		\

+	    CIRCLEQ_END(head))						\

+		(head).cqh_last = (elm2);				\

+	else								\

+		(elm2)->field.cqe_next->field.cqe_prev = (elm2);	\

+	if (((elm2)->field.cqe_prev = (elm)->field.cqe_prev) ==		\

+	    CIRCLEQ_END(head))						\

+		(head).cqh_first = (elm2);				\

+	else								\

+		(elm2)->field.cqe_prev->field.cqe_next = (elm2);	\

+} while (0)

+

+#endif	/* !SYS_QUEUE_H__ */
\ No newline at end of file