[csw-devel] SF.net SVN: gar:[13802] csw/mgar/pkg/tre/trunk/files

wahwah at users.sourceforge.net wahwah at users.sourceforge.net
Tue Mar 15 00:35:06 CET 2011


Revision: 13802
          http://gar.svn.sourceforge.net/gar/?rev=13802&view=rev
Author:   wahwah
Date:     2011-03-14 23:35:05 +0000 (Mon, 14 Mar 2011)

Log Message:
-----------
tre: patches

Added Paths:
-----------
    csw/mgar/pkg/tre/trunk/files/0001-gnulib-import-getopt-gnu.patch
    csw/mgar/pkg/tre/trunk/files/0002-manual-gnulib-integration-steps.patch

Added: csw/mgar/pkg/tre/trunk/files/0001-gnulib-import-getopt-gnu.patch
===================================================================
--- csw/mgar/pkg/tre/trunk/files/0001-gnulib-import-getopt-gnu.patch	                        (rev 0)
+++ csw/mgar/pkg/tre/trunk/files/0001-gnulib-import-getopt-gnu.patch	2011-03-14 23:35:05 UTC (rev 13802)
@@ -0,0 +1,4721 @@
+From d482ea9ccf3f449a627e30750b209b5983fc6aca Mon Sep 17 00:00:00 2001
+From: Maciej Blizinski <maciej at opencsw.org>
+Date: Mon, 14 Mar 2011 22:16:29 +0100
+Subject: [PATCH 1/2] gnulib import getopt-gnu
+
+---
+ lib/Makefile.am      |  254 ++++++++++--
+ lib/Makefile.am~     |   34 ++
+ lib/dummy.c          |   42 ++
+ lib/getopt.c         | 1187 ++++++++++++++++++++++++++++++++++++++++++++++++++
+ lib/getopt.in.h      |  247 +++++++++++
+ lib/getopt1.c        |  170 +++++++
+ lib/getopt_int.h     |  132 ++++++
+ lib/gettext.h        |  279 ++++++++++++
+ lib/stddef.in.h      |   86 ++++
+ lib/unistd.in.h      |  810 ++++++++++++++++++++++++++++++++++
+ m4/00gnulib.m4       |   30 ++
+ m4/extensions.m4     |  104 +++++
+ m4/getopt.m4         |  250 +++++++++++
+ m4/gnulib-cache.m4   |   36 ++
+ m4/gnulib-common.m4  |  124 ++++++
+ m4/gnulib-comp.m4    |  197 +++++++++
+ m4/gnulib-tool.m4    |   57 +++
+ m4/include_next.m4   |  187 ++++++++
+ m4/onceonly.m4       |   90 ++++
+ m4/stddef_h.m4       |   45 ++
+ m4/unistd_h.m4       |  119 +++++
+ m4/wchar_t.m4        |   20 +
+ utils/link-warning.h |   28 ++
+ 23 files changed, 4494 insertions(+), 34 deletions(-)
+ create mode 100644 lib/Makefile.am~
+ create mode 100644 lib/dummy.c
+ create mode 100644 lib/getopt.c
+ create mode 100644 lib/getopt.in.h
+ create mode 100644 lib/getopt1.c
+ create mode 100644 lib/getopt_int.h
+ create mode 100644 lib/gettext.h
+ create mode 100644 lib/stddef.in.h
+ create mode 100644 lib/unistd.in.h
+ create mode 100644 m4/00gnulib.m4
+ create mode 100644 m4/extensions.m4
+ create mode 100644 m4/getopt.m4
+ create mode 100644 m4/gnulib-cache.m4
+ create mode 100644 m4/gnulib-common.m4
+ create mode 100644 m4/gnulib-comp.m4
+ create mode 100644 m4/gnulib-tool.m4
+ create mode 100644 m4/include_next.m4
+ create mode 100644 m4/onceonly.m4
+ create mode 100644 m4/stddef_h.m4
+ create mode 100644 m4/unistd_h.m4
+ create mode 100644 m4/wchar_t.m4
+ create mode 100644 utils/link-warning.h
+
+diff --git a/lib/Makefile.am b/lib/Makefile.am
+index 2c5b4df..09b655c 100644
+--- a/lib/Makefile.am
++++ b/lib/Makefile.am
+@@ -1,34 +1,220 @@
+-## Process this file with automake to produce Makefile.in
+-
+-lib_LTLIBRARIES = libtre.la
+-libtre_la_LDFLAGS = -no-undefined -version-info 5:0:0 $(LDFLAGS)
+-libtre_la_LIBADD = $(LTLIBINTL)
+-
+-noinst_HEADERS =		\
+-	tre-ast.h		\
+-	tre-compile.h		\
+-	tre-internal.h		\
+-	tre-match-utils.h	\
+-	tre-mem.h		\
+-	tre-parse.h		\
+-	tre-stack.h		\
+-	xmalloc.h
+-
+-libtre_la_SOURCES =		\
+-	tre-ast.c		\
+-	tre-compile.c		\
+-	tre-match-backtrack.c	\
+-	tre-match-parallel.c	\
+-	tre-mem.c		\
+-	tre-parse.c		\
+-	tre-stack.c		\
+-	regcomp.c		\
+-	regexec.c		\
+-	regerror.c
+-
+-if TRE_APPROX
+-libtre_la_SOURCES += tre-match-approx.c
+-endif TRE_APPROX
+-
+-dist_pkginclude_HEADERS = tre.h regex.h
+-nodist_pkginclude_HEADERS = tre-config.h
++## DO NOT EDIT! GENERATED AUTOMATICALLY!
++## Process this file with automake to produce Makefile.in.
++# Copyright (C) 2002-2009 Free Software Foundation, Inc.
++#
++# This file is free software, distributed under the terms of the GNU
++# General Public License.  As a special exception to the GNU General
++# Public License, this file may be distributed as part of a program
++# that contains a configuration script generated by Autoconf, under
++# the same distribution terms as the rest of that program.
++#
++# Generated by gnulib-tool.
++# Reproduce by: gnulib-tool --import --dir=. --lib=libgnu --source-base=lib --m4-base=m4 --doc-base=doc --tests-base=tests --aux-dir=utils --libtool --macro-prefix=gl --no-vc-files getopt-gnu
++
++AUTOMAKE_OPTIONS = 1.5 gnits
++
++SUBDIRS =
++noinst_HEADERS =
++noinst_LIBRARIES =
++noinst_LTLIBRARIES =
++EXTRA_DIST =
++BUILT_SOURCES =
++SUFFIXES =
++MOSTLYCLEANFILES = core *.stackdump
++MOSTLYCLEANDIRS =
++CLEANFILES =
++DISTCLEANFILES =
++MAINTAINERCLEANFILES =
++
++AM_CPPFLAGS =
++AM_CFLAGS =
++
++noinst_LTLIBRARIES += libgnu.la
++
++libgnu_la_SOURCES =
++libgnu_la_LIBADD = $(gl_LTLIBOBJS)
++libgnu_la_DEPENDENCIES = $(gl_LTLIBOBJS)
++EXTRA_libgnu_la_SOURCES =
++libgnu_la_LDFLAGS = $(AM_LDFLAGS)
++
++## begin gnulib module getopt-posix
++
++BUILT_SOURCES += $(GETOPT_H)
++
++# We need the following in order to create <getopt.h> when the system
++# doesn't have one that works with the given compiler.
++getopt.h: getopt.in.h
++	$(AM_V_GEN)rm -f $@-t $@ && \
++	{ echo '/* DO NOT EDIT! GENERATED AUTOMATICALLY! */'; \
++	  sed -e 's|@''HAVE_GETOPT_H''@|$(HAVE_GETOPT_H)|g' \
++	      -e 's|@''INCLUDE_NEXT''@|$(INCLUDE_NEXT)|g' \
++	      -e 's|@''PRAGMA_SYSTEM_HEADER''@|@PRAGMA_SYSTEM_HEADER@|g' \
++	      -e 's|@''NEXT_GETOPT_H''@|$(NEXT_GETOPT_H)|g' \
++	      -e '/definition of GL_LINK_WARNING/r $(LINK_WARNING_H)' \
++	      < $(srcdir)/getopt.in.h; \
++	} > $@-t && \
++	mv -f $@-t $@
++MOSTLYCLEANFILES += getopt.h getopt.h-t
++
++EXTRA_DIST += getopt.c getopt.in.h getopt1.c getopt_int.h
++
++EXTRA_libgnu_la_SOURCES += getopt.c getopt1.c
++
++## end   gnulib module getopt-posix
++
++## begin gnulib module gettext-h
++
++libgnu_la_SOURCES += gettext.h
++
++## end   gnulib module gettext-h
++
++## begin gnulib module link-warning
++
++LINK_WARNING_H=$(top_srcdir)/utils/link-warning.h
++
++EXTRA_DIST += $(top_srcdir)/utils/link-warning.h
++
++## end   gnulib module link-warning
++
++## begin gnulib module stddef
++
++BUILT_SOURCES += $(STDDEF_H)
++
++# We need the following in order to create <stddef.h> when the system
++# doesn't have one that works with the given compiler.
++stddef.h: stddef.in.h
++	$(AM_V_GEN)rm -f $@-t $@ && \
++	{ echo '/* DO NOT EDIT! GENERATED AUTOMATICALLY! */' && \
++	  sed -e 's|@''INCLUDE_NEXT''@|$(INCLUDE_NEXT)|g' \
++	      -e 's|@''PRAGMA_SYSTEM_HEADER''@|@PRAGMA_SYSTEM_HEADER@|g' \
++	      -e 's|@''NEXT_STDDEF_H''@|$(NEXT_STDDEF_H)|g' \
++	      -e 's|@''HAVE_WCHAR_T''@|$(HAVE_WCHAR_T)|g' \
++	      -e 's|@''REPLACE_NULL''@|$(REPLACE_NULL)|g' \
++	      < $(srcdir)/stddef.in.h; \
++	} > $@-t && \
++	mv $@-t $@
++MOSTLYCLEANFILES += stddef.h stddef.h-t
++
++EXTRA_DIST += stddef.in.h
++
++## end   gnulib module stddef
++
++## begin gnulib module unistd
++
++BUILT_SOURCES += unistd.h
++
++# We need the following in order to create an empty placeholder for
++# <unistd.h> when the system doesn't have one.
++unistd.h: unistd.in.h
++	$(AM_V_GEN)rm -f $@-t $@ && \
++	{ echo '/* DO NOT EDIT! GENERATED AUTOMATICALLY! */'; \
++	  sed -e 's|@''HAVE_UNISTD_H''@|$(HAVE_UNISTD_H)|g' \
++	      -e 's|@''INCLUDE_NEXT''@|$(INCLUDE_NEXT)|g' \
++	      -e 's|@''PRAGMA_SYSTEM_HEADER''@|@PRAGMA_SYSTEM_HEADER@|g' \
++	      -e 's|@''NEXT_UNISTD_H''@|$(NEXT_UNISTD_H)|g' \
++	      -e 's|@''GNULIB_CHOWN''@|$(GNULIB_CHOWN)|g' \
++	      -e 's|@''GNULIB_CLOSE''@|$(GNULIB_CLOSE)|g' \
++	      -e 's|@''GNULIB_DUP2''@|$(GNULIB_DUP2)|g' \
++	      -e 's|@''GNULIB_DUP3''@|$(GNULIB_DUP3)|g' \
++	      -e 's|@''GNULIB_ENVIRON''@|$(GNULIB_ENVIRON)|g' \
++	      -e 's|@''GNULIB_EUIDACCESS''@|$(GNULIB_EUIDACCESS)|g' \
++	      -e 's|@''GNULIB_FACCESSAT''@|$(GNULIB_FACCESSAT)|g' \
++	      -e 's|@''GNULIB_FCHDIR''@|$(GNULIB_FCHDIR)|g' \
++	      -e 's|@''GNULIB_FCHOWNAT''@|$(GNULIB_FCHOWNAT)|g' \
++	      -e 's|@''GNULIB_FSYNC''@|$(GNULIB_FSYNC)|g' \
++	      -e 's|@''GNULIB_FTRUNCATE''@|$(GNULIB_FTRUNCATE)|g' \
++	      -e 's|@''GNULIB_GETCWD''@|$(GNULIB_GETCWD)|g' \
++	      -e 's|@''GNULIB_GETDOMAINNAME''@|$(GNULIB_GETDOMAINNAME)|g' \
++	      -e 's|@''GNULIB_GETDTABLESIZE''@|$(GNULIB_GETDTABLESIZE)|g' \
++	      -e 's|@''GNULIB_GETGROUPS''@|$(GNULIB_GETGROUPS)|g' \
++	      -e 's|@''GNULIB_GETHOSTNAME''@|$(GNULIB_GETHOSTNAME)|g' \
++	      -e 's|@''GNULIB_GETLOGIN_R''@|$(GNULIB_GETLOGIN_R)|g' \
++	      -e 's|@''GNULIB_GETPAGESIZE''@|$(GNULIB_GETPAGESIZE)|g' \
++	      -e 's|@''GNULIB_GETUSERSHELL''@|$(GNULIB_GETUSERSHELL)|g' \
++	      -e 's|@''GNULIB_LCHOWN''@|$(GNULIB_LCHOWN)|g' \
++	      -e 's|@''GNULIB_LINK''@|$(GNULIB_LINK)|g' \
++	      -e 's|@''GNULIB_LINKAT''@|$(GNULIB_LINKAT)|g' \
++	      -e 's|@''GNULIB_LSEEK''@|$(GNULIB_LSEEK)|g' \
++	      -e 's|@''GNULIB_PIPE2''@|$(GNULIB_PIPE2)|g' \
++	      -e 's|@''GNULIB_READLINK''@|$(GNULIB_READLINK)|g' \
++	      -e 's|@''GNULIB_READLINKAT''@|$(GNULIB_READLINKAT)|g' \
++	      -e 's|@''GNULIB_RMDIR''@|$(GNULIB_RMDIR)|g' \
++	      -e 's|@''GNULIB_SLEEP''@|$(GNULIB_SLEEP)|g' \
++	      -e 's|@''GNULIB_SYMLINK''@|$(GNULIB_SYMLINK)|g' \
++	      -e 's|@''GNULIB_SYMLINKAT''@|$(GNULIB_SYMLINKAT)|g' \
++	      -e 's|@''GNULIB_UNISTD_H_GETOPT''@|$(GNULIB_UNISTD_H_GETOPT)|g' \
++	      -e 's|@''GNULIB_UNISTD_H_SIGPIPE''@|$(GNULIB_UNISTD_H_SIGPIPE)|g' \
++	      -e 's|@''GNULIB_UNLINK''@|$(GNULIB_UNLINK)|g' \
++	      -e 's|@''GNULIB_UNLINKAT''@|$(GNULIB_UNLINKAT)|g' \
++	      -e 's|@''GNULIB_WRITE''@|$(GNULIB_WRITE)|g' \
++	      -e 's|@''HAVE_DUP2''@|$(HAVE_DUP2)|g' \
++	      -e 's|@''HAVE_DUP3''@|$(HAVE_DUP3)|g' \
++	      -e 's|@''HAVE_EUIDACCESS''@|$(HAVE_EUIDACCESS)|g' \
++	      -e 's|@''HAVE_FACCESSAT''@|$(HAVE_FACCESSAT)|g' \
++	      -e 's|@''HAVE_FCHOWNAT''@|$(HAVE_FCHOWNAT)|g' \
++	      -e 's|@''HAVE_FSYNC''@|$(HAVE_FSYNC)|g' \
++	      -e 's|@''HAVE_FTRUNCATE''@|$(HAVE_FTRUNCATE)|g' \
++	      -e 's|@''HAVE_GETDOMAINNAME''@|$(HAVE_GETDOMAINNAME)|g' \
++	      -e 's|@''HAVE_GETDTABLESIZE''@|$(HAVE_GETDTABLESIZE)|g' \
++	      -e 's|@''HAVE_GETGROUPS''@|$(HAVE_GETGROUPS)|g' \
++	      -e 's|@''HAVE_GETHOSTNAME''@|$(HAVE_GETHOSTNAME)|g' \
++	      -e 's|@''HAVE_GETPAGESIZE''@|$(HAVE_GETPAGESIZE)|g' \
++	      -e 's|@''HAVE_GETUSERSHELL''@|$(HAVE_GETUSERSHELL)|g' \
++	      -e 's|@''HAVE_LINK''@|$(HAVE_LINK)|g' \
++	      -e 's|@''HAVE_LINKAT''@|$(HAVE_LINKAT)|g' \
++	      -e 's|@''HAVE_PIPE2''@|$(HAVE_PIPE2)|g' \
++	      -e 's|@''HAVE_READLINK''@|$(HAVE_READLINK)|g' \
++	      -e 's|@''HAVE_READLINKAT''@|$(HAVE_READLINKAT)|g' \
++	      -e 's|@''HAVE_SLEEP''@|$(HAVE_SLEEP)|g' \
++	      -e 's|@''HAVE_SYMLINK''@|$(HAVE_SYMLINK)|g' \
++	      -e 's|@''HAVE_SYMLINKAT''@|$(HAVE_SYMLINKAT)|g' \
++	      -e 's|@''HAVE_UNLINKAT''@|$(HAVE_UNLINKAT)|g' \
++	      -e 's|@''HAVE_DECL_ENVIRON''@|$(HAVE_DECL_ENVIRON)|g' \
++	      -e 's|@''HAVE_DECL_GETLOGIN_R''@|$(HAVE_DECL_GETLOGIN_R)|g' \
++	      -e 's|@''HAVE_OS_H''@|$(HAVE_OS_H)|g' \
++	      -e 's|@''HAVE_SYS_PARAM_H''@|$(HAVE_SYS_PARAM_H)|g' \
++	      -e 's|@''REPLACE_CHOWN''@|$(REPLACE_CHOWN)|g' \
++	      -e 's|@''REPLACE_CLOSE''@|$(REPLACE_CLOSE)|g' \
++	      -e 's|@''REPLACE_DUP''@|$(REPLACE_DUP)|g' \
++	      -e 's|@''REPLACE_DUP2''@|$(REPLACE_DUP2)|g' \
++	      -e 's|@''REPLACE_FCHDIR''@|$(REPLACE_FCHDIR)|g' \
++	      -e 's|@''REPLACE_FCHOWNAT''@|$(REPLACE_FCHOWNAT)|g' \
++	      -e 's|@''REPLACE_GETCWD''@|$(REPLACE_GETCWD)|g' \
++	      -e 's|@''REPLACE_GETGROUPS''@|$(REPLACE_GETGROUPS)|g' \
++	      -e 's|@''REPLACE_GETPAGESIZE''@|$(REPLACE_GETPAGESIZE)|g' \
++	      -e 's|@''REPLACE_LCHOWN''@|$(REPLACE_LCHOWN)|g' \
++	      -e 's|@''REPLACE_LINK''@|$(REPLACE_LINK)|g' \
++	      -e 's|@''REPLACE_LINKAT''@|$(REPLACE_LINKAT)|g' \
++	      -e 's|@''REPLACE_LSEEK''@|$(REPLACE_LSEEK)|g' \
++	      -e 's|@''REPLACE_READLINK''@|$(REPLACE_READLINK)|g' \
++	      -e 's|@''REPLACE_RMDIR''@|$(REPLACE_RMDIR)|g' \
++	      -e 's|@''REPLACE_SYMLINK''@|$(REPLACE_SYMLINK)|g' \
++	      -e 's|@''REPLACE_UNLINK''@|$(REPLACE_UNLINK)|g' \
++	      -e 's|@''REPLACE_UNLINKAT''@|$(REPLACE_UNLINKAT)|g' \
++	      -e 's|@''REPLACE_WRITE''@|$(REPLACE_WRITE)|g' \
++	      -e 's|@''UNISTD_H_HAVE_WINSOCK2_H''@|$(UNISTD_H_HAVE_WINSOCK2_H)|g' \
++	      -e 's|@''UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS''@|$(UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS)|g' \
++	      -e '/definition of GL_LINK_WARNING/r $(LINK_WARNING_H)' \
++	      < $(srcdir)/unistd.in.h; \
++	} > $@-t && \
++	mv $@-t $@
++MOSTLYCLEANFILES += unistd.h unistd.h-t
++
++EXTRA_DIST += unistd.in.h
++
++## end   gnulib module unistd
++
++## begin gnulib module dummy
++
++libgnu_la_SOURCES += dummy.c
++
++## end   gnulib module dummy
++
++
++mostlyclean-local: mostlyclean-generic
++	@for dir in '' $(MOSTLYCLEANDIRS); do \
++	  if test -n "$$dir" && test -d $$dir; then \
++	    echo "rmdir $$dir"; rmdir $$dir; \
++	  fi; \
++	done; \
++	:
+diff --git a/lib/Makefile.am~ b/lib/Makefile.am~
+new file mode 100644
+index 0000000..2c5b4df
+--- /dev/null
++++ b/lib/Makefile.am~
+@@ -0,0 +1,34 @@
++## Process this file with automake to produce Makefile.in
++
++lib_LTLIBRARIES = libtre.la
++libtre_la_LDFLAGS = -no-undefined -version-info 5:0:0 $(LDFLAGS)
++libtre_la_LIBADD = $(LTLIBINTL)
++
++noinst_HEADERS =		\
++	tre-ast.h		\
++	tre-compile.h		\
++	tre-internal.h		\
++	tre-match-utils.h	\
++	tre-mem.h		\
++	tre-parse.h		\
++	tre-stack.h		\
++	xmalloc.h
++
++libtre_la_SOURCES =		\
++	tre-ast.c		\
++	tre-compile.c		\
++	tre-match-backtrack.c	\
++	tre-match-parallel.c	\
++	tre-mem.c		\
++	tre-parse.c		\
++	tre-stack.c		\
++	regcomp.c		\
++	regexec.c		\
++	regerror.c
++
++if TRE_APPROX
++libtre_la_SOURCES += tre-match-approx.c
++endif TRE_APPROX
++
++dist_pkginclude_HEADERS = tre.h regex.h
++nodist_pkginclude_HEADERS = tre-config.h
+diff --git a/lib/dummy.c b/lib/dummy.c
+new file mode 100644
+index 0000000..ccb5c26
+--- /dev/null
++++ b/lib/dummy.c
+@@ -0,0 +1,42 @@
++/* A dummy file, to prevent empty libraries from breaking builds.
++   Copyright (C) 2004, 2007 Free Software Foundation, Inc.
++
++   This program is free software: you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 3 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
++
++/* Some systems, reportedly OpenBSD and Mac OS X, refuse to create
++   libraries without any object files.  You might get an error like:
++
++   > ar cru .libs/libgl.a
++   > ar: no archive members specified
++
++   Compiling this file, and adding its object file to the library, will
++   prevent the library from being empty.  */
++
++/* Some systems, such as Solaris with cc 5.0, refuse to work with libraries
++   that don't export any symbol.  You might get an error like:
++
++   > cc ... libgnu.a
++   > ild: (bad file) garbled symbol table in archive ../gllib/libgnu.a
++
++   Compiling this file, and adding its object file to the library, will
++   prevent the library from exporting no symbols.  */
++
++#ifdef __sun
++/* This declaration ensures that the library will export at least 1 symbol.  */
++int gl_dummy_symbol;
++#else
++/* This declaration is solely to ensure that after preprocessing
++   this file is never empty.  */
++typedef int dummy;
++#endif
+diff --git a/lib/getopt.c b/lib/getopt.c
+new file mode 100644
+index 0000000..797d166
+--- /dev/null
++++ b/lib/getopt.c
+@@ -0,0 +1,1187 @@
++/* Getopt for GNU.
++   NOTE: getopt is now part of the C library, so if you don't know what
++   "Keep this file name-space clean" means, talk to drepper at gnu.org
++   before changing it!
++   Copyright (C) 1987,88,89,90,91,92,93,94,95,96,98,99,2000,2001,2002,2003,2004,2006,2008,2009
++	Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   This program is free software: you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 3 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
++
++#ifndef _LIBC
++# include <config.h>
++#endif
++
++#include "getopt.h"
++
++#include <stdio.h>
++#include <stdlib.h>
++#include <string.h>
++#include <unistd.h>
++
++#ifdef _LIBC
++# include <libintl.h>
++#else
++# include "gettext.h"
++# define _(msgid) gettext (msgid)
++#endif
++
++#if defined _LIBC && defined USE_IN_LIBIO
++# include <wchar.h>
++#endif
++
++#ifndef attribute_hidden
++# define attribute_hidden
++#endif
++
++/* Unlike standard Unix `getopt', functions like `getopt_long'
++   let the user intersperse the options with the other arguments.
++
++   As `getopt_long' works, it permutes the elements of ARGV so that,
++   when it is done, all the options precede everything else.  Thus
++   all application programs are extended to handle flexible argument order.
++
++   Using `getopt' or setting the environment variable POSIXLY_CORRECT
++   disables permutation.
++   Then the application's behavior is completely standard.
++
++   GNU application programs can use a third alternative mode in which
++   they can distinguish the relative order of options and other arguments.  */
++
++#include "getopt_int.h"
++
++/* For communication from `getopt' to the caller.
++   When `getopt' finds an option that takes an argument,
++   the argument value is returned here.
++   Also, when `ordering' is RETURN_IN_ORDER,
++   each non-option ARGV-element is returned here.  */
++
++char *optarg;
++
++/* Index in ARGV of the next element to be scanned.
++   This is used for communication to and from the caller
++   and for communication between successive calls to `getopt'.
++
++   On entry to `getopt', zero means this is the first call; initialize.
++
++   When `getopt' returns -1, this is the index of the first of the
++   non-option elements that the caller should itself scan.
++
++   Otherwise, `optind' communicates from one call to the next
++   how much of ARGV has been scanned so far.  */
++
++/* 1003.2 says this must be 1 before any call.  */
++int optind = 1;
++
++/* Callers store zero here to inhibit the error message
++   for unrecognized options.  */
++
++int opterr = 1;
++
++/* Set to an option character which was unrecognized.
++   This must be initialized on some systems to avoid linking in the
++   system's own getopt implementation.  */
++
++int optopt = '?';
++
++/* Keep a global copy of all internal members of getopt_data.  */
++
++static struct _getopt_data getopt_data;
++
++
++#if defined HAVE_DECL_GETENV && !HAVE_DECL_GETENV
++extern char *getenv ();
++#endif
++
++#ifdef _LIBC
++/* Stored original parameters.
++   XXX This is no good solution.  We should rather copy the args so
++   that we can compare them later.  But we must not use malloc(3).  */
++extern int __libc_argc;
++extern char **__libc_argv;
++
++/* Bash 2.0 gives us an environment variable containing flags
++   indicating ARGV elements that should not be considered arguments.  */
++
++# ifdef USE_NONOPTION_FLAGS
++/* Defined in getopt_init.c  */
++extern char *__getopt_nonoption_flags;
++# endif
++
++# ifdef USE_NONOPTION_FLAGS
++#  define SWAP_FLAGS(ch1, ch2) \
++  if (d->__nonoption_flags_len > 0)					      \
++    {									      \
++      char __tmp = __getopt_nonoption_flags[ch1];			      \
++      __getopt_nonoption_flags[ch1] = __getopt_nonoption_flags[ch2];	      \
++      __getopt_nonoption_flags[ch2] = __tmp;				      \
++    }
++# else
++#  define SWAP_FLAGS(ch1, ch2)
++# endif
++#else	/* !_LIBC */
++# define SWAP_FLAGS(ch1, ch2)
++#endif	/* _LIBC */
++
++/* Exchange two adjacent subsequences of ARGV.
++   One subsequence is elements [first_nonopt,last_nonopt)
++   which contains all the non-options that have been skipped so far.
++   The other is elements [last_nonopt,optind), which contains all
++   the options processed since those non-options were skipped.
++
++   `first_nonopt' and `last_nonopt' are relocated so that they describe
++   the new indices of the non-options in ARGV after they are moved.  */
++
++static void
++exchange (char **argv, struct _getopt_data *d)
++{
++  int bottom = d->__first_nonopt;
++  int middle = d->__last_nonopt;
++  int top = d->optind;
++  char *tem;
++
++  /* Exchange the shorter segment with the far end of the longer segment.
++     That puts the shorter segment into the right place.
++     It leaves the longer segment in the right place overall,
++     but it consists of two parts that need to be swapped next.  */
++
++#if defined _LIBC && defined USE_NONOPTION_FLAGS
++  /* First make sure the handling of the `__getopt_nonoption_flags'
++     string can work normally.  Our top argument must be in the range
++     of the string.  */
++  if (d->__nonoption_flags_len > 0 && top >= d->__nonoption_flags_max_len)
++    {
++      /* We must extend the array.  The user plays games with us and
++	 presents new arguments.  */
++      char *new_str = malloc (top + 1);
++      if (new_str == NULL)
++	d->__nonoption_flags_len = d->__nonoption_flags_max_len = 0;
++      else
++	{
++	  memset (__mempcpy (new_str, __getopt_nonoption_flags,
++			     d->__nonoption_flags_max_len),
++		  '\0', top + 1 - d->__nonoption_flags_max_len);
++	  d->__nonoption_flags_max_len = top + 1;
++	  __getopt_nonoption_flags = new_str;
++	}
++    }
++#endif
++
++  while (top > middle && middle > bottom)
++    {
++      if (top - middle > middle - bottom)
++	{
++	  /* Bottom segment is the short one.  */
++	  int len = middle - bottom;
++	  register int i;
++
++	  /* Swap it with the top part of the top segment.  */
++	  for (i = 0; i < len; i++)
++	    {
++	      tem = argv[bottom + i];
++	      argv[bottom + i] = argv[top - (middle - bottom) + i];
++	      argv[top - (middle - bottom) + i] = tem;
++	      SWAP_FLAGS (bottom + i, top - (middle - bottom) + i);
++	    }
++	  /* Exclude the moved bottom segment from further swapping.  */
++	  top -= len;
++	}
++      else
++	{
++	  /* Top segment is the short one.  */
++	  int len = top - middle;
++	  register int i;
++
++	  /* Swap it with the bottom part of the bottom segment.  */
++	  for (i = 0; i < len; i++)
++	    {
++	      tem = argv[bottom + i];
++	      argv[bottom + i] = argv[middle + i];
++	      argv[middle + i] = tem;
++	      SWAP_FLAGS (bottom + i, middle + i);
++	    }
++	  /* Exclude the moved top segment from further swapping.  */
++	  bottom += len;
++	}
++    }
++
++  /* Update records for the slots the non-options now occupy.  */
++
++  d->__first_nonopt += (d->optind - d->__last_nonopt);
++  d->__last_nonopt = d->optind;
++}
++
++/* Initialize the internal data when the first call is made.  */
++
++static const char *
++_getopt_initialize (int argc _UNUSED_PARAMETER_,
++		    char **argv _UNUSED_PARAMETER_, const char *optstring,
++		    int posixly_correct, struct _getopt_data *d)
++{
++  /* Start processing options with ARGV-element 1 (since ARGV-element 0
++     is the program name); the sequence of previously skipped
++     non-option ARGV-elements is empty.  */
++
++  d->__first_nonopt = d->__last_nonopt = d->optind;
++
++  d->__nextchar = NULL;
++
++  d->__posixly_correct = posixly_correct || !!getenv ("POSIXLY_CORRECT");
++
++  /* Determine how to handle the ordering of options and nonoptions.  */
++
++  if (optstring[0] == '-')
++    {
++      d->__ordering = RETURN_IN_ORDER;
++      ++optstring;
++    }
++  else if (optstring[0] == '+')
++    {
++      d->__ordering = REQUIRE_ORDER;
++      ++optstring;
++    }
++  else if (d->__posixly_correct)
++    d->__ordering = REQUIRE_ORDER;
++  else
++    d->__ordering = PERMUTE;
++
++#if defined _LIBC && defined USE_NONOPTION_FLAGS
++  if (!d->__posixly_correct
++      && argc == __libc_argc && argv == __libc_argv)
++    {
++      if (d->__nonoption_flags_max_len == 0)
++	{
++	  if (__getopt_nonoption_flags == NULL
++	      || __getopt_nonoption_flags[0] == '\0')
++	    d->__nonoption_flags_max_len = -1;
++	  else
++	    {
++	      const char *orig_str = __getopt_nonoption_flags;
++	      int len = d->__nonoption_flags_max_len = strlen (orig_str);
++	      if (d->__nonoption_flags_max_len < argc)
++		d->__nonoption_flags_max_len = argc;
++	      __getopt_nonoption_flags =
++		(char *) malloc (d->__nonoption_flags_max_len);
++	      if (__getopt_nonoption_flags == NULL)
++		d->__nonoption_flags_max_len = -1;
++	      else
++		memset (__mempcpy (__getopt_nonoption_flags, orig_str, len),
++			'\0', d->__nonoption_flags_max_len - len);
++	    }
++	}
++      d->__nonoption_flags_len = d->__nonoption_flags_max_len;
++    }
++  else
++    d->__nonoption_flags_len = 0;
++#endif
++
++  return optstring;
++}
++
++/* Scan elements of ARGV (whose length is ARGC) for option characters
++   given in OPTSTRING.
++
++   If an element of ARGV starts with '-', and is not exactly "-" or "--",
++   then it is an option element.  The characters of this element
++   (aside from the initial '-') are option characters.  If `getopt'
++   is called repeatedly, it returns successively each of the option characters
++   from each of the option elements.
++
++   If `getopt' finds another option character, it returns that character,
++   updating `optind' and `nextchar' so that the next call to `getopt' can
++   resume the scan with the following option character or ARGV-element.
++
++   If there are no more option characters, `getopt' returns -1.
++   Then `optind' is the index in ARGV of the first ARGV-element
++   that is not an option.  (The ARGV-elements have been permuted
++   so that those that are not options now come last.)
++
++   OPTSTRING is a string containing the legitimate option characters.
++   If an option character is seen that is not listed in OPTSTRING,
++   return '?' after printing an error message.  If you set `opterr' to
++   zero, the error message is suppressed but we still return '?'.
++
++   If a char in OPTSTRING is followed by a colon, that means it wants an arg,
++   so the following text in the same ARGV-element, or the text of the following
++   ARGV-element, is returned in `optarg'.  Two colons mean an option that
++   wants an optional arg; if there is text in the current ARGV-element,
++   it is returned in `optarg', otherwise `optarg' is set to zero.
++
++   If OPTSTRING starts with `-' or `+', it requests different methods of
++   handling the non-option ARGV-elements.
++   See the comments about RETURN_IN_ORDER and REQUIRE_ORDER, above.
++
++   Long-named options begin with `--' instead of `-'.
++   Their names may be abbreviated as long as the abbreviation is unique
++   or is an exact match for some defined option.  If they have an
++   argument, it follows the option name in the same ARGV-element, separated
++   from the option name by a `=', or else the in next ARGV-element.
++   When `getopt' finds a long-named option, it returns 0 if that option's
++   `flag' field is nonzero, the value of the option's `val' field
++   if the `flag' field is zero.
++
++   LONGOPTS is a vector of `struct option' terminated by an
++   element containing a name which is zero.
++
++   LONGIND returns the index in LONGOPT of the long-named option found.
++   It is only valid when a long-named option has been found by the most
++   recent call.
++
++   If LONG_ONLY is nonzero, '-' as well as '--' can introduce
++   long-named options.
++
++   If POSIXLY_CORRECT is nonzero, behave as if the POSIXLY_CORRECT
++   environment variable were set.  */
++
++int
++_getopt_internal_r (int argc, char **argv, const char *optstring,
++		    const struct option *longopts, int *longind,
++		    int long_only, int posixly_correct, struct _getopt_data *d)
++{
++  int print_errors = d->opterr;
++  if (optstring[0] == ':')
++    print_errors = 0;
++
++  if (argc < 1)
++    return -1;
++
++  d->optarg = NULL;
++
++  if (d->optind == 0 || !d->__initialized)
++    {
++      if (d->optind == 0)
++	d->optind = 1;	/* Don't scan ARGV[0], the program name.  */
++      optstring = _getopt_initialize (argc, argv, optstring,
++				      posixly_correct, d);
++      d->__initialized = 1;
++    }
++
++  /* Test whether ARGV[optind] points to a non-option argument.
++     Either it does not have option syntax, or there is an environment flag
++     from the shell indicating it is not an option.  The later information
++     is only used when the used in the GNU libc.  */
++#if defined _LIBC && defined USE_NONOPTION_FLAGS
++# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0' \
++		      || (d->optind < d->__nonoption_flags_len		      \
++			  && __getopt_nonoption_flags[d->optind] == '1'))
++#else
++# define NONOPTION_P (argv[d->optind][0] != '-' || argv[d->optind][1] == '\0')
++#endif
++
++  if (d->__nextchar == NULL || *d->__nextchar == '\0')
++    {
++      /* Advance to the next ARGV-element.  */
++
++      /* Give FIRST_NONOPT & LAST_NONOPT rational values if OPTIND has been
++	 moved back by the user (who may also have changed the arguments).  */
++      if (d->__last_nonopt > d->optind)
++	d->__last_nonopt = d->optind;
++      if (d->__first_nonopt > d->optind)
++	d->__first_nonopt = d->optind;
++
++      if (d->__ordering == PERMUTE)
++	{
++	  /* If we have just processed some options following some non-options,
++	     exchange them so that the options come first.  */
++
++	  if (d->__first_nonopt != d->__last_nonopt
++	      && d->__last_nonopt != d->optind)
++	    exchange ((char **) argv, d);
++	  else if (d->__last_nonopt != d->optind)
++	    d->__first_nonopt = d->optind;
++
++	  /* Skip any additional non-options
++	     and extend the range of non-options previously skipped.  */
++
++	  while (d->optind < argc && NONOPTION_P)
++	    d->optind++;
++	  d->__last_nonopt = d->optind;
++	}
++
++      /* The special ARGV-element `--' means premature end of options.
++	 Skip it like a null option,
++	 then exchange with previous non-options as if it were an option,
++	 then skip everything else like a non-option.  */
++
++      if (d->optind != argc && !strcmp (argv[d->optind], "--"))
++	{
++	  d->optind++;
++
++	  if (d->__first_nonopt != d->__last_nonopt
++	      && d->__last_nonopt != d->optind)
++	    exchange ((char **) argv, d);
++	  else if (d->__first_nonopt == d->__last_nonopt)
++	    d->__first_nonopt = d->optind;
++	  d->__last_nonopt = argc;
++
++	  d->optind = argc;
++	}
++
++      /* If we have done all the ARGV-elements, stop the scan
++	 and back over any non-options that we skipped and permuted.  */
++
++      if (d->optind == argc)
++	{
++	  /* Set the next-arg-index to point at the non-options
++	     that we previously skipped, so the caller will digest them.  */
++	  if (d->__first_nonopt != d->__last_nonopt)
++	    d->optind = d->__first_nonopt;
++	  return -1;
++	}
++
++      /* If we have come to a non-option and did not permute it,
++	 either stop the scan or describe it to the caller and pass it by.  */
++
++      if (NONOPTION_P)
++	{
++	  if (d->__ordering == REQUIRE_ORDER)
++	    return -1;
++	  d->optarg = argv[d->optind++];
++	  return 1;
++	}
++
++      /* We have found another option-ARGV-element.
++	 Skip the initial punctuation.  */
++
++      d->__nextchar = (argv[d->optind] + 1
++		  + (longopts != NULL && argv[d->optind][1] == '-'));
++    }
++
++  /* Decode the current option-ARGV-element.  */
++
++  /* Check whether the ARGV-element is a long option.
++
++     If long_only and the ARGV-element has the form "-f", where f is
++     a valid short option, don't consider it an abbreviated form of
++     a long option that starts with f.  Otherwise there would be no
++     way to give the -f short option.
++
++     On the other hand, if there's a long option "fubar" and
++     the ARGV-element is "-fu", do consider that an abbreviation of
++     the long option, just like "--fu", and not "-f" with arg "u".
++
++     This distinction seems to be the most useful approach.  */
++
++  if (longopts != NULL
++      && (argv[d->optind][1] == '-'
++	  || (long_only && (argv[d->optind][2]
++			    || !strchr (optstring, argv[d->optind][1])))))
++    {
++      char *nameend;
++      const struct option *p;
++      const struct option *pfound = NULL;
++      int exact = 0;
++      int ambig = 0;
++      int indfound = -1;
++      int option_index;
++
++      for (nameend = d->__nextchar; *nameend && *nameend != '='; nameend++)
++	/* Do nothing.  */ ;
++
++      /* Test all long options for either exact match
++	 or abbreviated matches.  */
++      for (p = longopts, option_index = 0; p->name; p++, option_index++)
++	if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
++	  {
++	    if ((unsigned int) (nameend - d->__nextchar)
++		== (unsigned int) strlen (p->name))
++	      {
++		/* Exact match found.  */
++		pfound = p;
++		indfound = option_index;
++		exact = 1;
++		break;
++	      }
++	    else if (pfound == NULL)
++	      {
++		/* First nonexact match found.  */
++		pfound = p;
++		indfound = option_index;
++	      }
++	    else if (long_only
++		     || pfound->has_arg != p->has_arg
++		     || pfound->flag != p->flag
++		     || pfound->val != p->val)
++	      /* Second or later nonexact match found.  */
++	      ambig = 1;
++	  }
++
++      if (ambig && !exact)
++	{
++	  if (print_errors)
++	    {
++#if defined _LIBC && defined USE_IN_LIBIO
++	      char *buf;
++
++	      if (__asprintf (&buf, _("%s: option `%s' is ambiguous\n"),
++			      argv[0], argv[d->optind]) >= 0)
++		{
++		  _IO_flockfile (stderr);
++
++		  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
++		  ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
++
++		  __fxprintf (NULL, "%s", buf);
++
++		  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
++		  _IO_funlockfile (stderr);
++
++		  free (buf);
++		}
++#else
++	      fprintf (stderr, _("%s: option `%s' is ambiguous\n"),
++		       argv[0], argv[d->optind]);
++#endif
++	    }
++	  d->__nextchar += strlen (d->__nextchar);
++	  d->optind++;
++	  d->optopt = 0;
++	  return '?';
++	}
++
++      if (pfound != NULL)
++	{
++	  option_index = indfound;
++	  d->optind++;
++	  if (*nameend)
++	    {
++	      /* Don't test has_arg with >, because some C compilers don't
++		 allow it to be used on enums.  */
++	      if (pfound->has_arg)
++		d->optarg = nameend + 1;
++	      else
++		{
++		  if (print_errors)
++		    {
++#if defined _LIBC && defined USE_IN_LIBIO
++		      char *buf;
++		      int n;
++#endif
++
++		      if (argv[d->optind - 1][1] == '-')
++			{
++			  /* --option */
++#if defined _LIBC && defined USE_IN_LIBIO
++			  n = __asprintf (&buf, _("\
++%s: option `--%s' doesn't allow an argument\n"),
++					  argv[0], pfound->name);
++#else
++			  fprintf (stderr, _("\
++%s: option `--%s' doesn't allow an argument\n"),
++				   argv[0], pfound->name);
++#endif
++			}
++		      else
++			{
++			  /* +option or -option */
++#if defined _LIBC && defined USE_IN_LIBIO
++			  n = __asprintf (&buf, _("\
++%s: option `%c%s' doesn't allow an argument\n"),
++					  argv[0], argv[d->optind - 1][0],
++					  pfound->name);
++#else
++			  fprintf (stderr, _("\
++%s: option `%c%s' doesn't allow an argument\n"),
++				   argv[0], argv[d->optind - 1][0],
++				   pfound->name);
++#endif
++			}
++
++#if defined _LIBC && defined USE_IN_LIBIO
++		      if (n >= 0)
++			{
++			  _IO_flockfile (stderr);
++
++			  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
++			  ((_IO_FILE *) stderr)->_flags2
++			    |= _IO_FLAGS2_NOTCANCEL;
++
++			  __fxprintf (NULL, "%s", buf);
++
++			  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
++			  _IO_funlockfile (stderr);
++
++			  free (buf);
++			}
++#endif
++		    }
++
++		  d->__nextchar += strlen (d->__nextchar);
++
++		  d->optopt = pfound->val;
++		  return '?';
++		}
++	    }
++	  else if (pfound->has_arg == 1)
++	    {
++	      if (d->optind < argc)
++		d->optarg = argv[d->optind++];
++	      else
++		{
++		  if (print_errors)
++		    {
++#if defined _LIBC && defined USE_IN_LIBIO
++		      char *buf;
++
++		      if (__asprintf (&buf, _("\
++%s: option `%s' requires an argument\n"),
++				      argv[0], argv[d->optind - 1]) >= 0)
++			{
++			  _IO_flockfile (stderr);
++
++			  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
++			  ((_IO_FILE *) stderr)->_flags2
++			    |= _IO_FLAGS2_NOTCANCEL;
++
++			  __fxprintf (NULL, "%s", buf);
++
++			  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
++			  _IO_funlockfile (stderr);
++
++			  free (buf);
++			}
++#else
++		      fprintf (stderr,
++			       _("%s: option `%s' requires an argument\n"),
++			       argv[0], argv[d->optind - 1]);
++#endif
++		    }
++		  d->__nextchar += strlen (d->__nextchar);
++		  d->optopt = pfound->val;
++		  return optstring[0] == ':' ? ':' : '?';
++		}
++	    }
++	  d->__nextchar += strlen (d->__nextchar);
++	  if (longind != NULL)
++	    *longind = option_index;
++	  if (pfound->flag)
++	    {
++	      *(pfound->flag) = pfound->val;
++	      return 0;
++	    }
++	  return pfound->val;
++	}
++
++      /* Can't find it as a long option.  If this is not getopt_long_only,
++	 or the option starts with '--' or is not a valid short
++	 option, then it's an error.
++	 Otherwise interpret it as a short option.  */
++      if (!long_only || argv[d->optind][1] == '-'
++	  || strchr (optstring, *d->__nextchar) == NULL)
++	{
++	  if (print_errors)
++	    {
++#if defined _LIBC && defined USE_IN_LIBIO
++	      char *buf;
++	      int n;
++#endif
++
++	      if (argv[d->optind][1] == '-')
++		{
++		  /* --option */
++#if defined _LIBC && defined USE_IN_LIBIO
++		  n = __asprintf (&buf, _("%s: unrecognized option `--%s'\n"),
++				  argv[0], d->__nextchar);
++#else
++		  fprintf (stderr, _("%s: unrecognized option `--%s'\n"),
++			   argv[0], d->__nextchar);
++#endif
++		}
++	      else
++		{
++		  /* +option or -option */
++#if defined _LIBC && defined USE_IN_LIBIO
++		  n = __asprintf (&buf, _("%s: unrecognized option `%c%s'\n"),
++				  argv[0], argv[d->optind][0], d->__nextchar);
++#else
++		  fprintf (stderr, _("%s: unrecognized option `%c%s'\n"),
++			   argv[0], argv[d->optind][0], d->__nextchar);
++#endif
++		}
++
++#if defined _LIBC && defined USE_IN_LIBIO
++	      if (n >= 0)
++		{
++		  _IO_flockfile (stderr);
++
++		  int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
++		  ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
++
++		  __fxprintf (NULL, "%s", buf);
++
++		  ((_IO_FILE *) stderr)->_flags2 = old_flags2;
++		  _IO_funlockfile (stderr);
++
++		  free (buf);
++		}
++#endif
++	    }
++	  d->__nextchar = (char *) "";
++	  d->optind++;
++	  d->optopt = 0;
++	  return '?';
++	}
++    }
++
++  /* Look at and handle the next short option-character.  */
++
++  {
++    char c = *d->__nextchar++;
++    char *temp = strchr (optstring, c);
++
++    /* Increment `optind' when we start to process its last character.  */
++    if (*d->__nextchar == '\0')
++      ++d->optind;
++
++    if (temp == NULL || c == ':')
++      {
++	if (print_errors)
++	  {
++#if defined _LIBC && defined USE_IN_LIBIO
++	      char *buf;
++	      int n;
++#endif
++
++	    if (d->__posixly_correct)
++	      {
++		/* 1003.2 specifies the format of this message.  */
++#if defined _LIBC && defined USE_IN_LIBIO
++		n = __asprintf (&buf, _("%s: illegal option -- %c\n"),
++				argv[0], c);
++#else
++		fprintf (stderr, _("%s: illegal option -- %c\n"), argv[0], c);
++#endif
++	      }
++	    else
++	      {
++#if defined _LIBC && defined USE_IN_LIBIO
++		n = __asprintf (&buf, _("%s: invalid option -- %c\n"),
++				argv[0], c);
++#else
++		fprintf (stderr, _("%s: invalid option -- %c\n"), argv[0], c);
++#endif
++	      }
++
++#if defined _LIBC && defined USE_IN_LIBIO
++	    if (n >= 0)
++	      {
++		_IO_flockfile (stderr);
++
++		int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
++		((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
++
++		__fxprintf (NULL, "%s", buf);
++
++		((_IO_FILE *) stderr)->_flags2 = old_flags2;
++		_IO_funlockfile (stderr);
++
++		free (buf);
++	      }
++#endif
++	  }
++	d->optopt = c;
++	return '?';
++      }
++    /* Convenience. Treat POSIX -W foo same as long option --foo */
++    if (temp[0] == 'W' && temp[1] == ';')
++      {
++	char *nameend;
++	const struct option *p;
++	const struct option *pfound = NULL;
++	int exact = 0;
++	int ambig = 0;
++	int indfound = 0;
++	int option_index;
++
++	/* This is an option that requires an argument.  */
++	if (*d->__nextchar != '\0')
++	  {
++	    d->optarg = d->__nextchar;
++	    /* If we end this ARGV-element by taking the rest as an arg,
++	       we must advance to the next element now.  */
++	    d->optind++;
++	  }
++	else if (d->optind == argc)
++	  {
++	    if (print_errors)
++	      {
++		/* 1003.2 specifies the format of this message.  */
++#if defined _LIBC && defined USE_IN_LIBIO
++		char *buf;
++
++		if (__asprintf (&buf,
++				_("%s: option requires an argument -- %c\n"),
++				argv[0], c) >= 0)
++		  {
++		    _IO_flockfile (stderr);
++
++		    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
++		    ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
++
++		    __fxprintf (NULL, "%s", buf);
++
++		    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
++		    _IO_funlockfile (stderr);
++
++		    free (buf);
++		  }
++#else
++		fprintf (stderr, _("%s: option requires an argument -- %c\n"),
++			 argv[0], c);
++#endif
++	      }
++	    d->optopt = c;
++	    if (optstring[0] == ':')
++	      c = ':';
++	    else
++	      c = '?';
++	    return c;
++	  }
++	else
++	  /* We already incremented `d->optind' once;
++	     increment it again when taking next ARGV-elt as argument.  */
++	  d->optarg = argv[d->optind++];
++
++	/* optarg is now the argument, see if it's in the
++	   table of longopts.  */
++
++	for (d->__nextchar = nameend = d->optarg; *nameend && *nameend != '=';
++	     nameend++)
++	  /* Do nothing.  */ ;
++
++	/* Test all long options for either exact match
++	   or abbreviated matches.  */
++	for (p = longopts, option_index = 0; p->name; p++, option_index++)
++	  if (!strncmp (p->name, d->__nextchar, nameend - d->__nextchar))
++	    {
++	      if ((unsigned int) (nameend - d->__nextchar) == strlen (p->name))
++		{
++		  /* Exact match found.  */
++		  pfound = p;
++		  indfound = option_index;
++		  exact = 1;
++		  break;
++		}
++	      else if (pfound == NULL)
++		{
++		  /* First nonexact match found.  */
++		  pfound = p;
++		  indfound = option_index;
++		}
++	      else
++		/* Second or later nonexact match found.  */
++		ambig = 1;
++	    }
++	if (ambig && !exact)
++	  {
++	    if (print_errors)
++	      {
++#if defined _LIBC && defined USE_IN_LIBIO
++		char *buf;
++
++		if (__asprintf (&buf, _("%s: option `-W %s' is ambiguous\n"),
++				argv[0], argv[d->optind]) >= 0)
++		  {
++		    _IO_flockfile (stderr);
++
++		    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
++		    ((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
++
++		    __fxprintf (NULL, "%s", buf);
++
++		    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
++		    _IO_funlockfile (stderr);
++
++		    free (buf);
++		  }
++#else
++		fprintf (stderr, _("%s: option `-W %s' is ambiguous\n"),
++			 argv[0], argv[d->optind]);
++#endif
++	      }
++	    d->__nextchar += strlen (d->__nextchar);
++	    d->optind++;
++	    return '?';
++	  }
++	if (pfound != NULL)
++	  {
++	    option_index = indfound;
++	    if (*nameend)
++	      {
++		/* Don't test has_arg with >, because some C compilers don't
++		   allow it to be used on enums.  */
++		if (pfound->has_arg)
++		  d->optarg = nameend + 1;
++		else
++		  {
++		    if (print_errors)
++		      {
++#if defined _LIBC && defined USE_IN_LIBIO
++			char *buf;
++
++			if (__asprintf (&buf, _("\
++%s: option `-W %s' doesn't allow an argument\n"),
++					argv[0], pfound->name) >= 0)
++			  {
++			    _IO_flockfile (stderr);
++
++			    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
++			    ((_IO_FILE *) stderr)->_flags2
++			      |= _IO_FLAGS2_NOTCANCEL;
++
++			    __fxprintf (NULL, "%s", buf);
++
++			    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
++			    _IO_funlockfile (stderr);
++
++			    free (buf);
++			  }
++#else
++			fprintf (stderr, _("\
++%s: option `-W %s' doesn't allow an argument\n"),
++				 argv[0], pfound->name);
++#endif
++		      }
++
++		    d->__nextchar += strlen (d->__nextchar);
++		    return '?';
++		  }
++	      }
++	    else if (pfound->has_arg == 1)
++	      {
++		if (d->optind < argc)
++		  d->optarg = argv[d->optind++];
++		else
++		  {
++		    if (print_errors)
++		      {
++#if defined _LIBC && defined USE_IN_LIBIO
++			char *buf;
++
++			if (__asprintf (&buf, _("\
++%s: option `%s' requires an argument\n"),
++					argv[0], argv[d->optind - 1]) >= 0)
++			  {
++			    _IO_flockfile (stderr);
++
++			    int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
++			    ((_IO_FILE *) stderr)->_flags2
++			      |= _IO_FLAGS2_NOTCANCEL;
++
++			    __fxprintf (NULL, "%s", buf);
++
++			    ((_IO_FILE *) stderr)->_flags2 = old_flags2;
++			    _IO_funlockfile (stderr);
++
++			    free (buf);
++			  }
++#else
++			fprintf (stderr,
++				 _("%s: option `%s' requires an argument\n"),
++				 argv[0], argv[d->optind - 1]);
++#endif
++		      }
++		    d->__nextchar += strlen (d->__nextchar);
++		    return optstring[0] == ':' ? ':' : '?';
++		  }
++	      }
++	    d->__nextchar += strlen (d->__nextchar);
++	    if (longind != NULL)
++	      *longind = option_index;
++	    if (pfound->flag)
++	      {
++		*(pfound->flag) = pfound->val;
++		return 0;
++	      }
++	    return pfound->val;
++	  }
++	  d->__nextchar = NULL;
++	  return 'W';	/* Let the application handle it.   */
++      }
++    if (temp[1] == ':')
++      {
++	if (temp[2] == ':')
++	  {
++	    /* This is an option that accepts an argument optionally.  */
++	    if (*d->__nextchar != '\0')
++	      {
++		d->optarg = d->__nextchar;
++		d->optind++;
++	      }
++	    else
++	      d->optarg = NULL;
++	    d->__nextchar = NULL;
++	  }
++	else
++	  {
++	    /* This is an option that requires an argument.  */
++	    if (*d->__nextchar != '\0')
++	      {
++		d->optarg = d->__nextchar;
++		/* If we end this ARGV-element by taking the rest as an arg,
++		   we must advance to the next element now.  */
++		d->optind++;
++	      }
++	    else if (d->optind == argc)
++	      {
++		if (print_errors)
++		  {
++		    /* 1003.2 specifies the format of this message.  */
++#if defined _LIBC && defined USE_IN_LIBIO
++		    char *buf;
++
++		    if (__asprintf (&buf, _("\
++%s: option requires an argument -- %c\n"),
++				    argv[0], c) >= 0)
++		      {
++			_IO_flockfile (stderr);
++
++			int old_flags2 = ((_IO_FILE *) stderr)->_flags2;
++			((_IO_FILE *) stderr)->_flags2 |= _IO_FLAGS2_NOTCANCEL;
++
++			__fxprintf (NULL, "%s", buf);
++
++			((_IO_FILE *) stderr)->_flags2 = old_flags2;
++			_IO_funlockfile (stderr);
++
++			free (buf);
++		      }
++#else
++		    fprintf (stderr,
++			     _("%s: option requires an argument -- %c\n"),
++			     argv[0], c);
++#endif
++		  }
++		d->optopt = c;
++		if (optstring[0] == ':')
++		  c = ':';
++		else
++		  c = '?';
++	      }
++	    else
++	      /* We already incremented `optind' once;
++		 increment it again when taking next ARGV-elt as argument.  */
++	      d->optarg = argv[d->optind++];
++	    d->__nextchar = NULL;
++	  }
++      }
++    return c;
++  }
++}
++
++int
++_getopt_internal (int argc, char **argv, const char *optstring,
++		  const struct option *longopts, int *longind,
++		  int long_only, int posixly_correct)
++{
++  int result;
++
++  getopt_data.optind = optind;
++  getopt_data.opterr = opterr;
++
++  result = _getopt_internal_r (argc, argv, optstring, longopts, longind,
++			       long_only, posixly_correct, &getopt_data);
++
++  optind = getopt_data.optind;
++  optarg = getopt_data.optarg;
++  optopt = getopt_data.optopt;
++
++  return result;
++}
++
++/* glibc gets a LSB-compliant getopt.
++   Standalone applications get a POSIX-compliant getopt.  */
++#if _LIBC
++enum { POSIXLY_CORRECT = 0 };
++#else
++enum { POSIXLY_CORRECT = 1 };
++#endif
++
++int
++getopt (int argc, char *const *argv, const char *optstring)
++{
++  return _getopt_internal (argc, (char **) argv, optstring, NULL, NULL, 0,
++			   POSIXLY_CORRECT);
++}
++
++
++#ifdef TEST
++
++/* Compile with -DTEST to make an executable for use in testing
++   the above definition of `getopt'.  */
++
++int
++main (int argc, char **argv)
++{
++  int c;
++  int digit_optind = 0;
++
++  while (1)
++    {
++      int this_option_optind = optind ? optind : 1;
++
++      c = getopt (argc, argv, "abc:d:0123456789");
++      if (c == -1)
++	break;
++
++      switch (c)
++	{
++	case '0':
++	case '1':
++	case '2':
++	case '3':
++	case '4':
++	case '5':
++	case '6':
++	case '7':
++	case '8':
++	case '9':
++	  if (digit_optind != 0 && digit_optind != this_option_optind)
++	    printf ("digits occur in two different argv-elements.\n");
++	  digit_optind = this_option_optind;
++	  printf ("option %c\n", c);
++	  break;
++
++	case 'a':
++	  printf ("option a\n");
++	  break;
++
++	case 'b':
++	  printf ("option b\n");
++	  break;
++
++	case 'c':
++	  printf ("option c with value `%s'\n", optarg);
++	  break;
++
++	case '?':
++	  break;
++
++	default:
++	  printf ("?? getopt returned character code 0%o ??\n", c);
++	}
++    }
++
++  if (optind < argc)
++    {
++      printf ("non-option ARGV-elements: ");
++      while (optind < argc)
++	printf ("%s ", argv[optind++]);
++      printf ("\n");
++    }
++
++  exit (0);
++}
++
++#endif /* TEST */
+diff --git a/lib/getopt.in.h b/lib/getopt.in.h
+new file mode 100644
+index 0000000..7377f3c
+--- /dev/null
++++ b/lib/getopt.in.h
+@@ -0,0 +1,247 @@
++/* Declarations for getopt.
++   Copyright (C) 1989-1994,1996-1999,2001,2003,2004,2005,2006,2007,2009
++   Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   This program is free software: you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 3 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
++
++#ifndef _GL_GETOPT_H
++
++#if __GNUC__ >= 3
++ at PRAGMA_SYSTEM_HEADER@
++#endif
++
++/* The include_next requires a split double-inclusion guard.  We must
++   also inform the replacement unistd.h to not recursively use
++   <getopt.h>; our definitions will be present soon enough.  */
++#if @HAVE_GETOPT_H@
++# define _GL_SYSTEM_GETOPT
++# @INCLUDE_NEXT@ @NEXT_GETOPT_H@
++# undef _GL_SYSTEM_GETOPT
++#endif
++
++#ifndef _GL_GETOPT_H
++
++#ifndef __need_getopt
++# define _GL_GETOPT_H 1
++#endif
++
++/* Standalone applications should #define __GETOPT_PREFIX to an
++   identifier that prefixes the external functions and variables
++   defined in this header.  When this happens, include the
++   headers that might declare getopt so that they will not cause
++   confusion if included after this file (if the system had <getopt.h>,
++   we have already included it).  Then systematically rename
++   identifiers so that they do not collide with the system functions
++   and variables.  Renaming avoids problems with some compilers and
++   linkers.  */
++#if defined __GETOPT_PREFIX && !defined __need_getopt
++# if !@HAVE_GETOPT_H@
++#  include <stdlib.h>
++#  include <stdio.h>
++#  include <unistd.h>
++# endif
++# undef __need_getopt
++# undef getopt
++# undef getopt_long
++# undef getopt_long_only
++# undef optarg
++# undef opterr
++# undef optind
++# undef optopt
++# undef option
++# define __GETOPT_CONCAT(x, y) x ## y
++# define __GETOPT_XCONCAT(x, y) __GETOPT_CONCAT (x, y)
++# define __GETOPT_ID(y) __GETOPT_XCONCAT (__GETOPT_PREFIX, y)
++# define getopt __GETOPT_ID (getopt)
++# define getopt_long __GETOPT_ID (getopt_long)
++# define getopt_long_only __GETOPT_ID (getopt_long_only)
++# define optarg __GETOPT_ID (optarg)
++# define opterr __GETOPT_ID (opterr)
++# define optind __GETOPT_ID (optind)
++# define optopt __GETOPT_ID (optopt)
++# define option __GETOPT_ID (option)
++# define _getopt_internal __GETOPT_ID (getopt_internal)
++#endif
++
++/* Standalone applications get correct prototypes for getopt_long and
++   getopt_long_only; they declare "char **argv".  libc uses prototypes
++   with "char *const *argv" that are incorrect because getopt_long and
++   getopt_long_only can permute argv; this is required for backward
++   compatibility (e.g., for LSB 2.0.1).
++
++   This used to be `#if defined __GETOPT_PREFIX && !defined __need_getopt',
++   but it caused redefinition warnings if both unistd.h and getopt.h were
++   included, since unistd.h includes getopt.h having previously defined
++   __need_getopt.
++
++   The only place where __getopt_argv_const is used is in definitions
++   of getopt_long and getopt_long_only below, but these are visible
++   only if __need_getopt is not defined, so it is quite safe to rewrite
++   the conditional as follows:
++*/
++#if !defined __need_getopt
++# if defined __GETOPT_PREFIX
++#  define __getopt_argv_const /* empty */
++# else
++#  define __getopt_argv_const const
++# endif
++#endif
++
++/* If __GNU_LIBRARY__ is not already defined, either we are being used
++   standalone, or this is the first header included in the source file.
++   If we are being used with glibc, we need to include <features.h>, but
++   that does not exist if we are standalone.  So: if __GNU_LIBRARY__ is
++   not defined, include <ctype.h>, which will pull in <features.h> for us
++   if it's from glibc.  (Why ctype.h?  It's guaranteed to exist and it
++   doesn't flood the namespace with stuff the way some other headers do.)  */
++#if !defined __GNU_LIBRARY__
++# include <ctype.h>
++#endif
++
++#ifndef __THROW
++# ifndef __GNUC_PREREQ
++#  define __GNUC_PREREQ(maj, min) (0)
++# endif
++# if defined __cplusplus && __GNUC_PREREQ (2,8)
++#  define __THROW	throw ()
++# else
++#  define __THROW
++# endif
++#endif
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++/* For communication from `getopt' to the caller.
++   When `getopt' finds an option that takes an argument,
++   the argument value is returned here.
++   Also, when `ordering' is RETURN_IN_ORDER,
++   each non-option ARGV-element is returned here.  */
++
++extern char *optarg;
++
++/* Index in ARGV of the next element to be scanned.
++   This is used for communication to and from the caller
++   and for communication between successive calls to `getopt'.
++
++   On entry to `getopt', zero means this is the first call; initialize.
++
++   When `getopt' returns -1, this is the index of the first of the
++   non-option elements that the caller should itself scan.
++
++   Otherwise, `optind' communicates from one call to the next
++   how much of ARGV has been scanned so far.  */
++
++extern int optind;
++
++/* Callers store zero here to inhibit the error message `getopt' prints
++   for unrecognized options.  */
++
++extern int opterr;
++
++/* Set to an option character which was unrecognized.  */
++
++extern int optopt;
++
++#ifndef __need_getopt
++/* Describe the long-named options requested by the application.
++   The LONG_OPTIONS argument to getopt_long or getopt_long_only is a vector
++   of `struct option' terminated by an element containing a name which is
++   zero.
++
++   The field `has_arg' is:
++   no_argument		(or 0) if the option does not take an argument,
++   required_argument	(or 1) if the option requires an argument,
++   optional_argument	(or 2) if the option takes an optional argument.
++
++   If the field `flag' is not NULL, it points to a variable that is set
++   to the value given in the field `val' when the option is found, but
++   left unchanged if the option is not found.
++
++   To have a long-named option do something other than set an `int' to
++   a compiled-in constant, such as set a value from `optarg', set the
++   option's `flag' field to zero and its `val' field to a nonzero
++   value (the equivalent single-letter option character, if there is
++   one).  For long options that have a zero `flag' field, `getopt'
++   returns the contents of the `val' field.  */
++
++struct option
++{
++  const char *name;
++  /* has_arg can't be an enum because some compilers complain about
++     type mismatches in all the code that assumes it is an int.  */
++  int has_arg;
++  int *flag;
++  int val;
++};
++
++/* Names for the values of the `has_arg' field of `struct option'.  */
++
++# define no_argument		0
++# define required_argument	1
++# define optional_argument	2
++#endif	/* need getopt */
++
++
++/* Get definitions and prototypes for functions to process the
++   arguments in ARGV (ARGC of them, minus the program name) for
++   options given in OPTS.
++
++   Return the option character from OPTS just read.  Return -1 when
++   there are no more options.  For unrecognized options, or options
++   missing arguments, `optopt' is set to the option letter, and '?' is
++   returned.
++
++   The OPTS string is a list of characters which are recognized option
++   letters, optionally followed by colons, specifying that that letter
++   takes an argument, to be placed in `optarg'.
++
++   If a letter in OPTS is followed by two colons, its argument is
++   optional.  This behavior is specific to the GNU `getopt'.
++
++   The argument `--' causes premature termination of argument
++   scanning, explicitly telling `getopt' that there are no more
++   options.
++
++   If OPTS begins with `-', then non-option arguments are treated as
++   arguments to the option '\1'.  This behavior is specific to the GNU
++   `getopt'.  If OPTS begins with `+', or POSIXLY_CORRECT is set in
++   the environment, then do not permute arguments.  */
++
++extern int getopt (int ___argc, char *const *___argv, const char *__shortopts)
++       __THROW;
++
++#ifndef __need_getopt
++extern int getopt_long (int ___argc, char *__getopt_argv_const *___argv,
++			const char *__shortopts,
++		        const struct option *__longopts, int *__longind)
++       __THROW;
++extern int getopt_long_only (int ___argc, char *__getopt_argv_const *___argv,
++			     const char *__shortopts,
++		             const struct option *__longopts, int *__longind)
++       __THROW;
++
++#endif
++
++#ifdef __cplusplus
++}
++#endif
++
++/* Make sure we later can get all the definitions and declarations.  */
++#undef __need_getopt
++
++#endif /* getopt.h */
++#endif /* getopt.h */
+diff --git a/lib/getopt1.c b/lib/getopt1.c
+new file mode 100644
+index 0000000..ba115c4
+--- /dev/null
++++ b/lib/getopt1.c
+@@ -0,0 +1,170 @@
++/* getopt_long and getopt_long_only entry points for GNU getopt.
++   Copyright (C) 1987,88,89,90,91,92,93,94,96,97,98,2004,2006,2009
++     Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   This program is free software: you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 3 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
++
++#ifdef _LIBC
++# include <getopt.h>
++#else
++# include <config.h>
++# include "getopt.h"
++#endif
++#include "getopt_int.h"
++
++#include <stdio.h>
++
++/* This needs to come after some library #include
++   to get __GNU_LIBRARY__ defined.  */
++#ifdef __GNU_LIBRARY__
++#include <stdlib.h>
++#endif
++
++#ifndef	NULL
++#define NULL 0
++#endif
++
++int
++getopt_long (int argc, char *__getopt_argv_const *argv, const char *options,
++	     const struct option *long_options, int *opt_index)
++{
++  return _getopt_internal (argc, (char **) argv, options, long_options,
++			   opt_index, 0, 0);
++}
++
++int
++_getopt_long_r (int argc, char **argv, const char *options,
++		const struct option *long_options, int *opt_index,
++		struct _getopt_data *d)
++{
++  return _getopt_internal_r (argc, argv, options, long_options, opt_index,
++			     0, 0, d);
++}
++
++/* Like getopt_long, but '-' as well as '--' can indicate a long option.
++   If an option that starts with '-' (not '--') doesn't match a long option,
++   but does match a short option, it is parsed as a short option
++   instead.  */
++
++int
++getopt_long_only (int argc, char *__getopt_argv_const *argv,
++		  const char *options,
++		  const struct option *long_options, int *opt_index)
++{
++  return _getopt_internal (argc, (char **) argv, options, long_options,
++			   opt_index, 1, 0);
++}
++
++int
++_getopt_long_only_r (int argc, char **argv, const char *options,
++		     const struct option *long_options, int *opt_index,
++		     struct _getopt_data *d)
++{
++  return _getopt_internal_r (argc, argv, options, long_options, opt_index,
++			     1, 0, d);
++}
++
++
++#ifdef TEST
++
++#include <stdio.h>
++
++int
++main (int argc, char **argv)
++{
++  int c;
++  int digit_optind = 0;
++
++  while (1)
++    {
++      int this_option_optind = optind ? optind : 1;
++      int option_index = 0;
++      static const struct option long_options[] =
++      {
++	{"add", 1, 0, 0},
++	{"append", 0, 0, 0},
++	{"delete", 1, 0, 0},
++	{"verbose", 0, 0, 0},
++	{"create", 0, 0, 0},
++	{"file", 1, 0, 0},
++	{0, 0, 0, 0}
++      };
++
++      c = getopt_long (argc, argv, "abc:d:0123456789",
++		       long_options, &option_index);
++      if (c == -1)
++	break;
++
++      switch (c)
++	{
++	case 0:
++	  printf ("option %s", long_options[option_index].name);
++	  if (optarg)
++	    printf (" with arg %s", optarg);
++	  printf ("\n");
++	  break;
++
++	case '0':
++	case '1':
++	case '2':
++	case '3':
++	case '4':
++	case '5':
++	case '6':
++	case '7':
++	case '8':
++	case '9':
++	  if (digit_optind != 0 && digit_optind != this_option_optind)
++	    printf ("digits occur in two different argv-elements.\n");
++	  digit_optind = this_option_optind;
++	  printf ("option %c\n", c);
++	  break;
++
++	case 'a':
++	  printf ("option a\n");
++	  break;
++
++	case 'b':
++	  printf ("option b\n");
++	  break;
++
++	case 'c':
++	  printf ("option c with value `%s'\n", optarg);
++	  break;
++
++	case 'd':
++	  printf ("option d with value `%s'\n", optarg);
++	  break;
++
++	case '?':
++	  break;
++
++	default:
++	  printf ("?? getopt returned character code 0%o ??\n", c);
++	}
++    }
++
++  if (optind < argc)
++    {
++      printf ("non-option ARGV-elements: ");
++      while (optind < argc)
++	printf ("%s ", argv[optind++]);
++      printf ("\n");
++    }
++
++  exit (0);
++}
++
++#endif /* TEST */
+diff --git a/lib/getopt_int.h b/lib/getopt_int.h
+new file mode 100644
+index 0000000..69cdf0d
+--- /dev/null
++++ b/lib/getopt_int.h
+@@ -0,0 +1,132 @@
++/* Internal declarations for getopt.
++   Copyright (C) 1989-1994,1996-1999,2001,2003,2004,2009
++   Free Software Foundation, Inc.
++   This file is part of the GNU C Library.
++
++   This program is free software: you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 3 of the License, or
++   (at your option) any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
++
++#ifndef _GETOPT_INT_H
++#define _GETOPT_INT_H	1
++
++#include <getopt.h>
++
++extern int _getopt_internal (int ___argc, char **___argv,
++			     const char *__shortopts,
++		             const struct option *__longopts, int *__longind,
++			     int __long_only, int __posixly_correct);
++
++
++/* Reentrant versions which can handle parsing multiple argument
++   vectors at the same time.  */
++
++/* Data type for reentrant functions.  */
++struct _getopt_data
++{
++  /* These have exactly the same meaning as the corresponding global
++     variables, except that they are used for the reentrant
++     versions of getopt.  */
++  int optind;
++  int opterr;
++  int optopt;
++  char *optarg;
++
++  /* Internal members.  */
++
++  /* True if the internal members have been initialized.  */
++  int __initialized;
++
++  /* The next char to be scanned in the option-element
++     in which the last option character we returned was found.
++     This allows us to pick up the scan where we left off.
++
++     If this is zero, or a null string, it means resume the scan
++     by advancing to the next ARGV-element.  */
++  char *__nextchar;
++
++  /* Describe how to deal with options that follow non-option ARGV-elements.
++
++     If the caller did not specify anything,
++     the default is REQUIRE_ORDER if the environment variable
++     POSIXLY_CORRECT is defined, PERMUTE otherwise.
++
++     REQUIRE_ORDER means don't recognize them as options;
++     stop option processing when the first non-option is seen.
++     This is what Unix does.
++     This mode of operation is selected by either setting the environment
++     variable POSIXLY_CORRECT, or using `+' as the first character
++     of the list of option characters, or by calling getopt.
++
++     PERMUTE is the default.  We permute the contents of ARGV as we
++     scan, so that eventually all the non-options are at the end.
++     This allows options to be given in any order, even with programs
++     that were not written to expect this.
++
++     RETURN_IN_ORDER is an option available to programs that were
++     written to expect options and other ARGV-elements in any order
++     and that care about the ordering of the two.  We describe each
++     non-option ARGV-element as if it were the argument of an option
++     with character code 1.  Using `-' as the first character of the
++     list of option characters selects this mode of operation.
++
++     The special argument `--' forces an end of option-scanning regardless
++     of the value of `ordering'.  In the case of RETURN_IN_ORDER, only
++     `--' can cause `getopt' to return -1 with `optind' != ARGC.  */
++
++  enum
++    {
++      REQUIRE_ORDER, PERMUTE, RETURN_IN_ORDER
++    } __ordering;
++
++  /* If the POSIXLY_CORRECT environment variable is set
++     or getopt was called.  */
++  int __posixly_correct;
++
++
++  /* Handle permutation of arguments.  */
++
++  /* Describe the part of ARGV that contains non-options that have
++     been skipped.  `first_nonopt' is the index in ARGV of the first
++     of them; `last_nonopt' is the index after the last of them.  */
++
++  int __first_nonopt;
++  int __last_nonopt;
++
++#if defined _LIBC && defined USE_NONOPTION_FLAGS
++  int __nonoption_flags_max_len;
++  int __nonoption_flags_len;
++# endif
++};
++
++/* The initializer is necessary to set OPTIND and OPTERR to their
++   default values and to clear the initialization flag.  */
++#define _GETOPT_DATA_INITIALIZER	{ 1, 1 }
++
++extern int _getopt_internal_r (int ___argc, char **___argv,
++			       const char *__shortopts,
++			       const struct option *__longopts, int *__longind,
++			       int __long_only, int __posixly_correct,
++			       struct _getopt_data *__data);
++
++extern int _getopt_long_r (int ___argc, char **___argv,
++			   const char *__shortopts,
++			   const struct option *__longopts, int *__longind,
++			   struct _getopt_data *__data);
++
++extern int _getopt_long_only_r (int ___argc, char **___argv,
++				const char *__shortopts,
++				const struct option *__longopts,
++				int *__longind,
++				struct _getopt_data *__data);
++
++#endif /* getopt_int.h */
+diff --git a/lib/gettext.h b/lib/gettext.h
+new file mode 100644
+index 0000000..a5b85c7
+--- /dev/null
++++ b/lib/gettext.h
+@@ -0,0 +1,279 @@
++/* Convenience header for conditional use of GNU <libintl.h>.
++   Copyright (C) 1995-1998, 2000-2002, 2004-2006, 2009 Free Software Foundation, Inc.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2, or (at your option)
++   any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License along
++   with this program; if not, write to the Free Software Foundation,
++   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
++
++#ifndef _LIBGETTEXT_H
++#define _LIBGETTEXT_H 1
++
++/* NLS can be disabled through the configure --disable-nls option.  */
++#if ENABLE_NLS
++
++/* Get declarations of GNU message catalog functions.  */
++# include <libintl.h>
++
++/* You can set the DEFAULT_TEXT_DOMAIN macro to specify the domain used by
++   the gettext() and ngettext() macros.  This is an alternative to calling
++   textdomain(), and is useful for libraries.  */
++# ifdef DEFAULT_TEXT_DOMAIN
++#  undef gettext
++#  define gettext(Msgid) \
++     dgettext (DEFAULT_TEXT_DOMAIN, Msgid)
++#  undef ngettext
++#  define ngettext(Msgid1, Msgid2, N) \
++     dngettext (DEFAULT_TEXT_DOMAIN, Msgid1, Msgid2, N)
++# endif
++
++#else
++
++/* Solaris /usr/include/locale.h includes /usr/include/libintl.h, which
++   chokes if dcgettext is defined as a macro.  So include it now, to make
++   later inclusions of <locale.h> a NOP.  We don't include <libintl.h>
++   as well because people using "gettext.h" will not include <libintl.h>,
++   and also including <libintl.h> would fail on SunOS 4, whereas <locale.h>
++   is OK.  */
++#if defined(__sun)
++# include <locale.h>
++#endif
++
++/* Many header files from the libstdc++ coming with g++ 3.3 or newer include
++   <libintl.h>, which chokes if dcgettext is defined as a macro.  So include
++   it now, to make later inclusions of <libintl.h> a NOP.  */
++#if defined(__cplusplus) && defined(__GNUG__) && (__GNUC__ >= 3)
++# include <cstdlib>
++# if (__GLIBC__ >= 2) || _GLIBCXX_HAVE_LIBINTL_H
++#  include <libintl.h>
++# endif
++#endif
++
++/* Disabled NLS.
++   The casts to 'const char *' serve the purpose of producing warnings
++   for invalid uses of the value returned from these functions.
++   On pre-ANSI systems without 'const', the config.h file is supposed to
++   contain "#define const".  */
++# undef gettext
++# define gettext(Msgid) ((const char *) (Msgid))
++# undef dgettext
++# define dgettext(Domainname, Msgid) ((void) (Domainname), gettext (Msgid))
++# undef dcgettext
++# define dcgettext(Domainname, Msgid, Category) \
++    ((void) (Category), dgettext (Domainname, Msgid))
++# undef ngettext
++# define ngettext(Msgid1, Msgid2, N) \
++    ((N) == 1 \
++     ? ((void) (Msgid2), (const char *) (Msgid1)) \
++     : ((void) (Msgid1), (const char *) (Msgid2)))
++# undef dngettext
++# define dngettext(Domainname, Msgid1, Msgid2, N) \
++    ((void) (Domainname), ngettext (Msgid1, Msgid2, N))
++# undef dcngettext
++# define dcngettext(Domainname, Msgid1, Msgid2, N, Category) \
++    ((void) (Category), dngettext(Domainname, Msgid1, Msgid2, N))
++# undef textdomain
++# define textdomain(Domainname) ((const char *) (Domainname))
++# undef bindtextdomain
++# define bindtextdomain(Domainname, Dirname) \
++    ((void) (Domainname), (const char *) (Dirname))
++# undef bind_textdomain_codeset
++# define bind_textdomain_codeset(Domainname, Codeset) \
++    ((void) (Domainname), (const char *) (Codeset))
++
++#endif
++
++/* A pseudo function call that serves as a marker for the automated
++   extraction of messages, but does not call gettext().  The run-time
++   translation is done at a different place in the code.
++   The argument, String, should be a literal string.  Concatenated strings
++   and other string expressions won't work.
++   The macro's expansion is not parenthesized, so that it is suitable as
++   initializer for static 'char[]' or 'const char[]' variables.  */
++#define gettext_noop(String) String
++
++/* The separator between msgctxt and msgid in a .mo file.  */
++#define GETTEXT_CONTEXT_GLUE "\004"
++
++/* Pseudo function calls, taking a MSGCTXT and a MSGID instead of just a
++   MSGID.  MSGCTXT and MSGID must be string literals.  MSGCTXT should be
++   short and rarely need to change.
++   The letter 'p' stands for 'particular' or 'special'.  */
++#ifdef DEFAULT_TEXT_DOMAIN
++# define pgettext(Msgctxt, Msgid) \
++   pgettext_aux (DEFAULT_TEXT_DOMAIN, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, LC_MESSAGES)
++#else
++# define pgettext(Msgctxt, Msgid) \
++   pgettext_aux (NULL, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, LC_MESSAGES)
++#endif
++#define dpgettext(Domainname, Msgctxt, Msgid) \
++  pgettext_aux (Domainname, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, LC_MESSAGES)
++#define dcpgettext(Domainname, Msgctxt, Msgid, Category) \
++  pgettext_aux (Domainname, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, Category)
++#ifdef DEFAULT_TEXT_DOMAIN
++# define npgettext(Msgctxt, Msgid, MsgidPlural, N) \
++   npgettext_aux (DEFAULT_TEXT_DOMAIN, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, LC_MESSAGES)
++#else
++# define npgettext(Msgctxt, Msgid, MsgidPlural, N) \
++   npgettext_aux (NULL, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, LC_MESSAGES)
++#endif
++#define dnpgettext(Domainname, Msgctxt, Msgid, MsgidPlural, N) \
++  npgettext_aux (Domainname, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, LC_MESSAGES)
++#define dcnpgettext(Domainname, Msgctxt, Msgid, MsgidPlural, N, Category) \
++  npgettext_aux (Domainname, Msgctxt GETTEXT_CONTEXT_GLUE Msgid, Msgid, MsgidPlural, N, Category)
++
++#ifdef __GNUC__
++__inline
++#else
++#ifdef __cplusplus
++inline
++#endif
++#endif
++static const char *
++pgettext_aux (const char *domain,
++	      const char *msg_ctxt_id, const char *msgid,
++	      int category)
++{
++  const char *translation = dcgettext (domain, msg_ctxt_id, category);
++  if (translation == msg_ctxt_id)
++    return msgid;
++  else
++    return translation;
++}
++
++#ifdef __GNUC__
++__inline
++#else
++#ifdef __cplusplus
++inline
++#endif
++#endif
++static const char *
++npgettext_aux (const char *domain,
++	       const char *msg_ctxt_id, const char *msgid,
++	       const char *msgid_plural, unsigned long int n,
++	       int category)
++{
++  const char *translation =
++    dcngettext (domain, msg_ctxt_id, msgid_plural, n, category);
++  if (translation == msg_ctxt_id || translation == msgid_plural)
++    return (n == 1 ? msgid : msgid_plural);
++  else
++    return translation;
++}
++
++/* The same thing extended for non-constant arguments.  Here MSGCTXT and MSGID
++   can be arbitrary expressions.  But for string literals these macros are
++   less efficient than those above.  */
++
++#include <string.h>
++
++#define _LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS \
++  (((__GNUC__ >= 3 || __GNUG__ >= 2) && !__STRICT_ANSI__) \
++   /* || __STDC_VERSION__ >= 199901L */ )
++
++#if !_LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS
++#include <stdlib.h>
++#endif
++
++#define pgettext_expr(Msgctxt, Msgid) \
++  dcpgettext_expr (NULL, Msgctxt, Msgid, LC_MESSAGES)
++#define dpgettext_expr(Domainname, Msgctxt, Msgid) \
++  dcpgettext_expr (Domainname, Msgctxt, Msgid, LC_MESSAGES)
++
++#ifdef __GNUC__
++__inline
++#else
++#ifdef __cplusplus
++inline
++#endif
++#endif
++static const char *
++dcpgettext_expr (const char *domain,
++		 const char *msgctxt, const char *msgid,
++		 int category)
++{
++  size_t msgctxt_len = strlen (msgctxt) + 1;
++  size_t msgid_len = strlen (msgid) + 1;
++  const char *translation;
++#if _LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS
++  char msg_ctxt_id[msgctxt_len + msgid_len];
++#else
++  char buf[1024];
++  char *msg_ctxt_id =
++    (msgctxt_len + msgid_len <= sizeof (buf)
++     ? buf
++     : (char *) malloc (msgctxt_len + msgid_len));
++  if (msg_ctxt_id != NULL)
++#endif
++    {
++      memcpy (msg_ctxt_id, msgctxt, msgctxt_len - 1);
++      msg_ctxt_id[msgctxt_len - 1] = '\004';
++      memcpy (msg_ctxt_id + msgctxt_len, msgid, msgid_len);
++      translation = dcgettext (domain, msg_ctxt_id, category);
++#if !_LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS
++      if (msg_ctxt_id != buf)
++	free (msg_ctxt_id);
++#endif
++      if (translation != msg_ctxt_id)
++	return translation;
++    }
++  return msgid;
++}
++
++#define npgettext_expr(Msgctxt, Msgid, MsgidPlural, N) \
++  dcnpgettext_expr (NULL, Msgctxt, Msgid, MsgidPlural, N, LC_MESSAGES)
++#define dnpgettext_expr(Domainname, Msgctxt, Msgid, MsgidPlural, N) \
++  dcnpgettext_expr (Domainname, Msgctxt, Msgid, MsgidPlural, N, LC_MESSAGES)
++
++#ifdef __GNUC__
++__inline
++#else
++#ifdef __cplusplus
++inline
++#endif
++#endif
++static const char *
++dcnpgettext_expr (const char *domain,
++		  const char *msgctxt, const char *msgid,
++		  const char *msgid_plural, unsigned long int n,
++		  int category)
++{
++  size_t msgctxt_len = strlen (msgctxt) + 1;
++  size_t msgid_len = strlen (msgid) + 1;
++  const char *translation;
++#if _LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS
++  char msg_ctxt_id[msgctxt_len + msgid_len];
++#else
++  char buf[1024];
++  char *msg_ctxt_id =
++    (msgctxt_len + msgid_len <= sizeof (buf)
++     ? buf
++     : (char *) malloc (msgctxt_len + msgid_len));
++  if (msg_ctxt_id != NULL)
++#endif
++    {
++      memcpy (msg_ctxt_id, msgctxt, msgctxt_len - 1);
++      msg_ctxt_id[msgctxt_len - 1] = '\004';
++      memcpy (msg_ctxt_id + msgctxt_len, msgid, msgid_len);
++      translation = dcngettext (domain, msg_ctxt_id, msgid_plural, n, category);
++#if !_LIBGETTEXT_HAVE_VARIABLE_SIZE_ARRAYS
++      if (msg_ctxt_id != buf)
++	free (msg_ctxt_id);
++#endif
++      if (!(translation == msg_ctxt_id || translation == msgid_plural))
++	return translation;
++    }
++  return (n == 1 ? msgid : msgid_plural);
++}
++
++#endif /* _LIBGETTEXT_H */
+diff --git a/lib/stddef.in.h b/lib/stddef.in.h
+new file mode 100644
+index 0000000..8744207
+--- /dev/null
++++ b/lib/stddef.in.h
+@@ -0,0 +1,86 @@
++/* A substitute for POSIX 2008 <stddef.h>, for platforms that have issues.
++
++   Copyright (C) 2009 Free Software Foundation, Inc.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2, or (at your option)
++   any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software Foundation,
++   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
++
++/* Written by Eric Blake.  */
++
++/*
++ * POSIX 2008 <stddef.h> for platforms that have issues.
++ * <http://www.opengroup.org/susv3xbd/stddef.h.html>
++ */
++
++#if __GNUC__ >= 3
++ at PRAGMA_SYSTEM_HEADER@
++#endif
++
++#if defined __need_wchar_t || defined __need_size_t  \
++  || defined __need_ptrdiff_t || defined __need_NULL \
++  || defined __need_wint_t
++/* Special invocation convention inside gcc header files.  In
++   particular, gcc provides a version of <stddef.h> that blindly
++   redefines NULL even when __need_wint_t was defined, even though
++   wint_t is not normally provided by <stddef.h>.  Hence, we must
++   remember if special invocation has ever been used to obtain wint_t,
++   in which case we need to clean up NULL yet again.  */
++
++# if !(defined _GL_STDDEF_H && defined _GL_STDDEF_WINT_T)
++#  ifdef __need_wint_t
++#   undef _GL_STDDEF_H
++#   define _GL_STDDEF_WINT_T
++#  endif
++#  @INCLUDE_NEXT@ @NEXT_STDDEF_H@
++# endif
++
++#else
++/* Normal invocation convention.  */
++
++# ifndef _GL_STDDEF_H
++
++/* The include_next requires a split double-inclusion guard.  */
++
++#  @INCLUDE_NEXT@ @NEXT_STDDEF_H@
++
++#  ifndef _GL_STDDEF_H
++#   define _GL_STDDEF_H
++
++/* On NetBSD 5.0, the definition of NULL lacks proper parentheses.  */
++#if @REPLACE_NULL@
++# undef NULL
++# ifdef __cplusplus
++   /* ISO C++ says that the macro NULL must expand to an integer constant
++      expression, hence '((void *) 0)' is not allowed in C++.  */
++#  if __GNUG__ >= 3
++    /* GNU C++ has a __null macro that behaves like an integer ('int' or
++       'long') but has the same size as a pointer.  Use that, to avoid
++       warnings.  */
++#   define NULL __null
++#  else
++#   define NULL 0L
++#  endif
++# else
++#  define NULL ((void *) 0)
++# endif
++#endif
++
++/* Some platforms lack wchar_t.  */
++#if !@HAVE_WCHAR_T@
++# define wchar_t int
++#endif
++
++#  endif /* _GL_STDDEF_H */
++# endif /* _GL_STDDEF_H */
++#endif /* __need_XXX */
+diff --git a/lib/unistd.in.h b/lib/unistd.in.h
+new file mode 100644
+index 0000000..c321987
+--- /dev/null
++++ b/lib/unistd.in.h
+@@ -0,0 +1,810 @@
++/* Substitute for and wrapper around <unistd.h>.
++   Copyright (C) 2003-2009 Free Software Foundation, Inc.
++
++   This program is free software; you can redistribute it and/or modify
++   it under the terms of the GNU General Public License as published by
++   the Free Software Foundation; either version 2, or (at your option)
++   any later version.
++
++   This program is distributed in the hope that it will be useful,
++   but WITHOUT ANY WARRANTY; without even the implied warranty of
++   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
++   GNU General Public License for more details.
++
++   You should have received a copy of the GNU General Public License
++   along with this program; if not, write to the Free Software Foundation,
++   Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
++
++#ifndef _GL_UNISTD_H
++
++#if __GNUC__ >= 3
++ at PRAGMA_SYSTEM_HEADER@
++#endif
++
++/* The include_next requires a split double-inclusion guard.  */
++#if @HAVE_UNISTD_H@
++# @INCLUDE_NEXT@ @NEXT_UNISTD_H@
++#endif
++
++#ifndef _GL_UNISTD_H
++#define _GL_UNISTD_H
++
++/* NetBSD 5.0 mis-defines NULL.  Also get size_t.  */
++#include <stddef.h>
++
++/* mingw doesn't define the SEEK_* or *_FILENO macros in <unistd.h>.  */
++#if !(defined SEEK_CUR && defined SEEK_END && defined SEEK_SET)
++# include <stdio.h>
++#endif
++
++/* mingw fails to declare _exit in <unistd.h>.  */
++/* mingw, BeOS, Haiku declare environ in <stdlib.h>, not in <unistd.h>.  */
++#include <stdlib.h>
++
++#if ((@GNULIB_WRITE@ && @REPLACE_WRITE@ && @GNULIB_UNISTD_H_SIGPIPE@)   \
++     || (@GNULIB_READLINK@ && (!@HAVE_READLINK@ || @REPLACE_READLINK@)) \
++     || (@GNULIB_READLINKAT@ && !@HAVE_READLINKAT@))
++/* Get ssize_t.  */
++# include <sys/types.h>
++#endif
++
++/* Get getopt(), optarg, optind, opterr, optopt.  */
++#if @GNULIB_UNISTD_H_GETOPT@ && !defined _GL_SYSTEM_GETOPT
++# include <getopt.h>
++#endif
++
++#if @GNULIB_GETHOSTNAME@
++/* Get all possible declarations of gethostname().  */
++# if @UNISTD_H_HAVE_WINSOCK2_H@
++#  include <winsock2.h>
++#  if !defined _GL_SYS_SOCKET_H
++#   undef socket
++#   define socket		socket_used_without_including_sys_socket_h
++#   undef connect
++#   define connect		connect_used_without_including_sys_socket_h
++#   undef accept
++#   define accept		accept_used_without_including_sys_socket_h
++#   undef bind
++#   define bind			bind_used_without_including_sys_socket_h
++#   undef getpeername
++#   define getpeername		getpeername_used_without_including_sys_socket_h
++#   undef getsockname
++#   define getsockname		getsockname_used_without_including_sys_socket_h
++#   undef getsockopt
++#   define getsockopt		getsockopt_used_without_including_sys_socket_h
++#   undef listen
++#   define listen		listen_used_without_including_sys_socket_h
++#   undef recv
++#   define recv			recv_used_without_including_sys_socket_h
++#   undef send
++#   define send			send_used_without_including_sys_socket_h
++#   undef recvfrom
++#   define recvfrom		recvfrom_used_without_including_sys_socket_h
++#   undef sendto
++#   define sendto		sendto_used_without_including_sys_socket_h
++#   undef setsockopt
++#   define setsockopt		setsockopt_used_without_including_sys_socket_h
++#   undef shutdown
++#   define shutdown		shutdown_used_without_including_sys_socket_h
++#  endif
++#  if !defined _GL_SYS_SELECT_H
++#   undef select
++#   define select		select_used_without_including_sys_select_h
++#  endif
++# endif
++#endif
++
++/* The definition of GL_LINK_WARNING is copied here.  */
++
++
++/* OS/2 EMX lacks these macros.  */
++#ifndef STDIN_FILENO
++# define STDIN_FILENO 0
++#endif
++#ifndef STDOUT_FILENO
++# define STDOUT_FILENO 1
++#endif
++#ifndef STDERR_FILENO
++# define STDERR_FILENO 2
++#endif
++
++/* Ensure *_OK macros exist.  */
++#ifndef F_OK
++# define F_OK 0
++# define X_OK 1
++# define W_OK 2
++# define R_OK 4
++#endif
++
++
++/* Declare overridden functions.  */
++
++#ifdef __cplusplus
++extern "C" {
++#endif
++
++
++#if @GNULIB_CHOWN@
++# if @REPLACE_CHOWN@
++#  ifndef REPLACE_CHOWN
++#   define REPLACE_CHOWN 1
++#  endif
++#  if REPLACE_CHOWN
++/* Change the owner of FILE to UID (if UID is not -1) and the group of FILE
++   to GID (if GID is not -1).  Follow symbolic links.
++   Return 0 if successful, otherwise -1 and errno set.
++   See the POSIX:2001 specification
++   <http://www.opengroup.org/susv3xsh/chown.html>.  */
++#   define chown rpl_chown
++extern int chown (const char *file, uid_t uid, gid_t gid);
++#  endif
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef chown
++# define chown(f,u,g) \
++    (GL_LINK_WARNING ("chown fails to follow symlinks on some systems and " \
++                      "doesn't treat a uid or gid of -1 on some systems - " \
++                      "use gnulib module chown for portability"), \
++     chown (f, u, g))
++#endif
++
++
++#if @GNULIB_CLOSE@
++# if @REPLACE_CLOSE@
++/* Automatically included by modules that need a replacement for close.  */
++#  undef close
++#  define close rpl_close
++extern int close (int);
++# endif
++#elif @UNISTD_H_HAVE_WINSOCK2_H_AND_USE_SOCKETS@
++# undef close
++# define close close_used_without_requesting_gnulib_module_close
++#elif defined GNULIB_POSIXCHECK
++# undef close
++# define close(f) \
++    (GL_LINK_WARNING ("close does not portably work on sockets - " \
++                      "use gnulib module close for portability"), \
++     close (f))
++#endif
++
++
++#if @REPLACE_DUP@
++# define dup rpl_dup
++extern int dup (int);
++#endif
++
++
++#if @GNULIB_DUP2@
++# if @REPLACE_DUP2@
++#  define dup2 rpl_dup2
++# endif
++# if !@HAVE_DUP2@ || @REPLACE_DUP2@
++/* Copy the file descriptor OLDFD into file descriptor NEWFD.  Do nothing if
++   NEWFD = OLDFD, otherwise close NEWFD first if it is open.
++   Return newfd if successful, otherwise -1 and errno set.
++   See the POSIX:2001 specification
++   <http://www.opengroup.org/susv3xsh/dup2.html>.  */
++extern int dup2 (int oldfd, int newfd);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef dup2
++# define dup2(o,n) \
++    (GL_LINK_WARNING ("dup2 is unportable - " \
++                      "use gnulib module dup2 for portability"), \
++     dup2 (o, n))
++#endif
++
++
++#if @GNULIB_DUP3@
++/* Copy the file descriptor OLDFD into file descriptor NEWFD, with the
++   specified flags.
++   The flags are a bitmask, possibly including O_CLOEXEC (defined in <fcntl.h>)
++   and O_TEXT, O_BINARY (defined in "binary-io.h").
++   Close NEWFD first if it is open.
++   Return newfd if successful, otherwise -1 and errno set.
++   See the Linux man page at
++   <http://www.kernel.org/doc/man-pages/online/pages/man2/dup3.2.html>.  */
++# if @HAVE_DUP3@
++#  define dup3 rpl_dup3
++# endif
++extern int dup3 (int oldfd, int newfd, int flags);
++#elif defined GNULIB_POSIXCHECK
++# undef dup3
++# define dup3(o,n,f) \
++    (GL_LINK_WARNING ("dup3 is unportable - " \
++                      "use gnulib module dup3 for portability"), \
++     dup3 (o, n, f))
++#endif
++
++
++#if @GNULIB_ENVIRON@
++# if !@HAVE_DECL_ENVIRON@
++/* Set of environment variables and values.  An array of strings of the form
++   "VARIABLE=VALUE", terminated with a NULL.  */
++#  if defined __APPLE__ && defined __MACH__
++#   include <crt_externs.h>
++#   define environ (*_NSGetEnviron ())
++#  else
++extern char **environ;
++#  endif
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef environ
++# define environ \
++    (GL_LINK_WARNING ("environ is unportable - " \
++                      "use gnulib module environ for portability"), \
++     environ)
++#endif
++
++
++#if @GNULIB_EUIDACCESS@
++# if !@HAVE_EUIDACCESS@
++/* Like access(), except that it uses the effective user id and group id of
++   the current process.  */
++extern int euidaccess (const char *filename, int mode);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef euidaccess
++# define euidaccess(f,m) \
++    (GL_LINK_WARNING ("euidaccess is unportable - " \
++                      "use gnulib module euidaccess for portability"), \
++     euidaccess (f, m))
++#endif
++
++
++#if @GNULIB_FACCESSAT@
++# if !@HAVE_FACCESSAT@
++int faccessat (int fd, char const *file, int mode, int flag);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef faccessat
++# define faccessat(d,n,m,f)			    \
++    (GL_LINK_WARNING ("faccessat is not portable - " \
++                      "use gnulib module faccessat for portability"), \
++     faccessat (d, n, m, f))
++#endif
++
++
++#if @GNULIB_FCHDIR@
++# if @REPLACE_FCHDIR@
++/* Change the process' current working directory to the directory on which
++   the given file descriptor is open.
++   Return 0 if successful, otherwise -1 and errno set.
++   See the POSIX:2001 specification
++   <http://www.opengroup.org/susv3xsh/fchdir.html>.  */
++extern int fchdir (int /*fd*/);
++
++/* Gnulib internal hooks needed to maintain the fchdir metadata.  */
++extern int _gl_register_fd (int fd, const char *filename);
++extern void _gl_unregister_fd (int fd);
++extern int _gl_register_dup (int oldfd, int newfd);
++extern const char *_gl_directory_name (int fd);
++
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef fchdir
++# define fchdir(f) \
++    (GL_LINK_WARNING ("fchdir is unportable - " \
++                      "use gnulib module fchdir for portability"), \
++     fchdir (f))
++#endif
++
++
++#if @GNULIB_FCHOWNAT@
++# if @REPLACE_FCHOWNAT@
++#  undef fchownat
++#  define fchownat rpl_fchownat
++# endif
++# if !@HAVE_FCHOWNAT@ || @REPLACE_FCHOWNAT@
++extern int fchownat (int fd, char const *file, uid_t owner, gid_t group, int flag);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef fchownat
++# define fchownat(d,n,o,g,f)			    \
++    (GL_LINK_WARNING ("fchownat is not portable - " \
++                      "use gnulib module openat for portability"), \
++     fchownat (d, n, o, g, f))
++#endif
++
++
++#if @GNULIB_FSYNC@
++/* Synchronize changes to a file.
++   Return 0 if successful, otherwise -1 and errno set.
++   See POSIX:2001 specification
++   <http://www.opengroup.org/susv3xsh/fsync.html>.  */
++# if !@HAVE_FSYNC@
++extern int fsync (int fd);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef fsync
++# define fsync(fd) \
++    (GL_LINK_WARNING ("fsync is unportable - " \
++                      "use gnulib module fsync for portability"), \
++     fsync (fd))
++#endif
++
++
++#if @GNULIB_FTRUNCATE@
++# if !@HAVE_FTRUNCATE@
++/* Change the size of the file to which FD is opened to become equal to LENGTH.
++   Return 0 if successful, otherwise -1 and errno set.
++   See the POSIX:2001 specification
++   <http://www.opengroup.org/susv3xsh/ftruncate.html>.  */
++extern int ftruncate (int fd, off_t length);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef ftruncate
++# define ftruncate(f,l) \
++    (GL_LINK_WARNING ("ftruncate is unportable - " \
++                      "use gnulib module ftruncate for portability"), \
++     ftruncate (f, l))
++#endif
++
++
++#if @GNULIB_GETCWD@
++/* Include the headers that might declare getcwd so that they will not
++   cause confusion if included after this file.  */
++# include <stdlib.h>
++# if @REPLACE_GETCWD@
++/* Get the name of the current working directory, and put it in SIZE bytes
++   of BUF.
++   Return BUF if successful, or NULL if the directory couldn't be determined
++   or SIZE was too small.
++   See the POSIX:2001 specification
++   <http://www.opengroup.org/susv3xsh/getcwd.html>.
++   Additionally, the gnulib module 'getcwd' guarantees the following GNU
++   extension: If BUF is NULL, an array is allocated with 'malloc'; the array
++   is SIZE bytes long, unless SIZE == 0, in which case it is as big as
++   necessary.  */
++#  define getcwd rpl_getcwd
++extern char * getcwd (char *buf, size_t size);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef getcwd
++# define getcwd(b,s) \
++    (GL_LINK_WARNING ("getcwd is unportable - " \
++                      "use gnulib module getcwd for portability"), \
++     getcwd (b, s))
++#endif
++
++
++#if @GNULIB_GETDOMAINNAME@
++/* Return the NIS domain name of the machine.
++   WARNING! The NIS domain name is unrelated to the fully qualified host name
++            of the machine.  It is also unrelated to email addresses.
++   WARNING! The NIS domain name is usually the empty string or "(none)" when
++            not using NIS.
++
++   Put up to LEN bytes of the NIS domain name into NAME.
++   Null terminate it if the name is shorter than LEN.
++   If the NIS domain name is longer than LEN, set errno = EINVAL and return -1.
++   Return 0 if successful, otherwise set errno and return -1.  */
++# if !@HAVE_GETDOMAINNAME@
++extern int getdomainname(char *name, size_t len);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef getdomainname
++# define getdomainname(n,l) \
++    (GL_LINK_WARNING ("getdomainname is unportable - " \
++                      "use gnulib module getdomainname for portability"), \
++     getdomainname (n, l))
++#endif
++
++
++#if @GNULIB_GETDTABLESIZE@
++# if !@HAVE_GETDTABLESIZE@
++/* Return the maximum number of file descriptors in the current process.
++   In POSIX, this is same as sysconf (_SC_OPEN_MAX).  */
++extern int getdtablesize (void);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef getdtablesize
++# define getdtablesize() \
++    (GL_LINK_WARNING ("getdtablesize is unportable - " \
++                      "use gnulib module getdtablesize for portability"), \
++     getdtablesize ())
++#endif
++
++
++#if @GNULIB_GETGROUPS@
++# if @REPLACE_GETGROUPS@
++#  undef getgroups
++#  define getgroups rpl_getgroups
++# endif
++# if !@HAVE_GETGROUPS@ || @REPLACE_GETGROUPS@
++/* Return the supplemental groups that the current process belongs to.
++   It is unspecified whether the effective group id is in the list.
++   If N is 0, return the group count; otherwise, N describes how many
++   entries are available in GROUPS.  Return -1 and set errno if N is
++   not 0 and not large enough.  Fails with ENOSYS on some systems.  */
++int getgroups (int n, gid_t *groups);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef getgroups
++# define getgroups(n,g)                                                 \
++    (GL_LINK_WARNING ("getgroups is unportable - "                      \
++                      "use gnulib module getgroups for portability"),   \
++     getgroups (n, g))
++#endif
++
++
++#if @GNULIB_GETHOSTNAME@
++/* Return the standard host name of the machine.
++   WARNING! The host name may or may not be fully qualified.
++
++   Put up to LEN bytes of the host name into NAME.
++   Null terminate it if the name is shorter than LEN.
++   If the host name is longer than LEN, set errno = EINVAL and return -1.
++   Return 0 if successful, otherwise set errno and return -1.  */
++# if @UNISTD_H_HAVE_WINSOCK2_H@
++#  undef gethostname
++#  define gethostname rpl_gethostname
++# endif
++# if @UNISTD_H_HAVE_WINSOCK2_H@ || !@HAVE_GETHOSTNAME@
++extern int gethostname(char *name, size_t len);
++# endif
++#elif @UNISTD_H_HAVE_WINSOCK2_H@
++# undef gethostname
++# define gethostname gethostname_used_without_requesting_gnulib_module_gethostname
++#elif defined GNULIB_POSIXCHECK
++# undef gethostname
++# define gethostname(n,l) \
++    (GL_LINK_WARNING ("gethostname is unportable - " \
++                      "use gnulib module gethostname for portability"), \
++     gethostname (n, l))
++#endif
++
++
++#if @GNULIB_GETLOGIN_R@
++/* Copies the user's login name to NAME.
++   The array pointed to by NAME has room for SIZE bytes.
++
++   Returns 0 if successful.  Upon error, an error number is returned, or -1 in
++   the case that the login name cannot be found but no specific error is
++   provided (this case is hopefully rare but is left open by the POSIX spec).
++
++   See <http://www.opengroup.org/susv3xsh/getlogin.html>.
++ */
++# if !@HAVE_DECL_GETLOGIN_R@
++extern int getlogin_r (char *name, size_t size);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef getlogin_r
++# define getlogin_r(n,s) \
++    (GL_LINK_WARNING ("getlogin_r is unportable - " \
++                      "use gnulib module getlogin_r for portability"), \
++     getlogin_r (n, s))
++#endif
++
++
++#if @GNULIB_GETPAGESIZE@
++# if @REPLACE_GETPAGESIZE@
++#  define getpagesize rpl_getpagesize
++extern int getpagesize (void);
++# elif !@HAVE_GETPAGESIZE@
++/* This is for POSIX systems.  */
++#  if !defined getpagesize && defined _SC_PAGESIZE
++#   if ! (defined __VMS && __VMS_VER < 70000000)
++#    define getpagesize() sysconf (_SC_PAGESIZE)
++#   endif
++#  endif
++/* This is for older VMS.  */
++#  if !defined getpagesize && defined __VMS
++#   ifdef __ALPHA
++#    define getpagesize() 8192
++#   else
++#    define getpagesize() 512
++#   endif
++#  endif
++/* This is for BeOS.  */
++#  if !defined getpagesize && @HAVE_OS_H@
++#   include <OS.h>
++#   if defined B_PAGE_SIZE
++#    define getpagesize() B_PAGE_SIZE
++#   endif
++#  endif
++/* This is for AmigaOS4.0.  */
++#  if !defined getpagesize && defined __amigaos4__
++#   define getpagesize() 2048
++#  endif
++/* This is for older Unix systems.  */
++#  if !defined getpagesize && @HAVE_SYS_PARAM_H@
++#   include <sys/param.h>
++#   ifdef EXEC_PAGESIZE
++#    define getpagesize() EXEC_PAGESIZE
++#   else
++#    ifdef NBPG
++#     ifndef CLSIZE
++#      define CLSIZE 1
++#     endif
++#     define getpagesize() (NBPG * CLSIZE)
++#    else
++#     ifdef NBPC
++#      define getpagesize() NBPC
++#     endif
++#    endif
++#   endif
++#  endif
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef getpagesize
++# define getpagesize() \
++    (GL_LINK_WARNING ("getpagesize is unportable - " \
++                      "use gnulib module getpagesize for portability"), \
++     getpagesize ())
++#endif
++
++
++#if @GNULIB_GETUSERSHELL@
++# if !@HAVE_GETUSERSHELL@
++/* Return the next valid login shell on the system, or NULL when the end of
++   the list has been reached.  */
++extern char *getusershell (void);
++/* Rewind to pointer that is advanced at each getusershell() call.  */
++extern void setusershell (void);
++/* Free the pointer that is advanced at each getusershell() call and
++   associated resources.  */
++extern void endusershell (void);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef getusershell
++# define getusershell() \
++    (GL_LINK_WARNING ("getusershell is unportable - " \
++                      "use gnulib module getusershell for portability"), \
++     getusershell ())
++# undef setusershell
++# define setusershell() \
++    (GL_LINK_WARNING ("setusershell is unportable - " \
++                      "use gnulib module getusershell for portability"), \
++     setusershell ())
++# undef endusershell
++# define endusershell() \
++    (GL_LINK_WARNING ("endusershell is unportable - " \
++                      "use gnulib module getusershell for portability"), \
++     endusershell ())
++#endif
++
++
++#if @GNULIB_LCHOWN@
++# if @REPLACE_LCHOWN@
++/* Change the owner of FILE to UID (if UID is not -1) and the group of FILE
++   to GID (if GID is not -1).  Do not follow symbolic links.
++   Return 0 if successful, otherwise -1 and errno set.
++   See the POSIX:2001 specification
++   <http://www.opengroup.org/susv3xsh/lchown.html>.  */
++#  define lchown rpl_lchown
++extern int lchown (char const *file, uid_t owner, gid_t group);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef lchown
++# define lchown(f,u,g) \
++    (GL_LINK_WARNING ("lchown is unportable to pre-POSIX.1-2001 " \
++                      "systems - use gnulib module lchown for portability"), \
++     lchown (f, u, g))
++#endif
++
++
++#if @GNULIB_LINK@
++# if @REPLACE_LINK@
++#  define link rpl_link
++# endif
++/* Create a new hard link for an existing file.
++   Return 0 if successful, otherwise -1 and errno set.
++   See POSIX:2001 specification
++   <http://www.opengroup.org/susv3xsh/link.html>.  */
++# if !@HAVE_LINK@ || @REPLACE_LINK@
++extern int link (const char *path1, const char *path2);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef link
++# define link(path1,path2) \
++    (GL_LINK_WARNING ("link is unportable - " \
++                      "use gnulib module link for portability"), \
++     link (path1, path2))
++#endif
++
++#if @GNULIB_LINKAT@
++# if @REPLACE_LINKAT@
++#  undef linkat
++#  define linkat rpl_linkat
++# endif
++/* Create a new hard link for an existing file, relative to two
++   directories.  FLAG controls whether symlinks are followed.
++   Return 0 if successful, otherwise -1 and errno set.  */
++# if !@HAVE_LINKAT@ || @REPLACE_LINKAT@
++extern int linkat (int fd1, const char *path1, int fd2, const char *path2,
++		   int flag);
++# endif
++#elif defined GNULIB_POSIXCHECK
++# undef linkat

@@ Diff output truncated at 100000 characters. @@

This was sent by the SourceForge.net collaborative development platform, the world's largest Open Source development site.


More information about the devel mailing list