[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