[csw-devel] SF.net SVN: gar:[7193] csw/mgar/pkg/chmlib/trunk
bdwalton at users.sourceforge.net
bdwalton at users.sourceforge.net
Tue Nov 10 02:54:17 CET 2009
Revision: 7193
http://gar.svn.sourceforge.net/gar/?rev=7193&view=rev
Author: bdwalton
Date: 2009-11-10 01:54:17 +0000 (Tue, 10 Nov 2009)
Log Message:
-----------
chmlib: patch in working gnulib support and other autoconf fixes
Modified Paths:
--------------
csw/mgar/pkg/chmlib/trunk/Makefile
csw/mgar/pkg/chmlib/trunk/checksums
Added Paths:
-----------
csw/mgar/pkg/chmlib/trunk/files/0001-gnulib-import-getopt-posix.patch
csw/mgar/pkg/chmlib/trunk/files/0002-integrate-gnulib-into-the-auto-tool-files.patch
csw/mgar/pkg/chmlib/trunk/files/0003-add-dummy-config.h-file.patch
csw/mgar/pkg/chmlib/trunk/files/0004-add-autoconf-checks-for-lnsl-and-lsocket.patch
Modified: csw/mgar/pkg/chmlib/trunk/Makefile
===================================================================
--- csw/mgar/pkg/chmlib/trunk/Makefile 2009-11-10 01:25:32 UTC (rev 7192)
+++ csw/mgar/pkg/chmlib/trunk/Makefile 2009-11-10 01:54:17 UTC (rev 7193)
@@ -14,7 +14,10 @@
MASTER_SITES = http://www.jedrea.com/chmlib/
DISTFILES = $(GARNAME)-$(GARVERSION).tar.bz2
-PATCHFILES = 0001-Add-autoconf-support-from-gnulib-for-getopt.h.patch
+PATCHFILES = 0001-gnulib-import-getopt-posix.patch
+PATCHFILES += 0002-integrate-gnulib-into-the-auto-tool-files.patch
+PATCHFILES += 0003-add-dummy-config.h-file.patch
+PATCHFILES += 0004-add-autoconf-checks-for-lnsl-and-lsocket.patch
# We define upstream file regex so we can be notifed of new upstream software release
UFILES_REGEX = $(GARNAME)-(\d+(?:\.\d+)*).tar.bz2
@@ -29,6 +32,10 @@
include gar/category.mk
+pre-configure-modulated:
+ @(cd $(WORKSRC); aclocal -I gnulib/m4; autoconf -I gnulib/m4; automake)
+ @$(MAKECOOKIE)
+
post-install-modulated:
ginstall -d $(DESTDIR)$(docdir)/$(GARNAME)
$(foreach D,$(DOCS),ginstall $(WORKSRC)/$D $(DESTDIR)$(docdir)/$(GARNAME)/$D;)
Modified: csw/mgar/pkg/chmlib/trunk/checksums
===================================================================
--- csw/mgar/pkg/chmlib/trunk/checksums 2009-11-10 01:25:32 UTC (rev 7192)
+++ csw/mgar/pkg/chmlib/trunk/checksums 2009-11-10 01:54:17 UTC (rev 7193)
@@ -1,2 +1,5 @@
-b7276bc25fffbf7044018f94ebe1baf9 download/0001-Add-autoconf-support-from-gnulib-for-getopt.h.patch
-7ea49ed8c335215c1edc6fae83e6b912 download/chmlib-0.40.tar.bz2
+b454cb00abe8653f2e3c11318a884e0e 0001-gnulib-import-getopt-posix.patch
+c181447a053d0c5a83099af4a68a5510 0002-integrate-gnulib-into-the-auto-tool-files.patch
+b96303db2702dd6696ea45dfba2de5dc 0003-add-dummy-config.h-file.patch
+883567051286cd6984b7a1b23fa8e783 0004-add-autoconf-checks-for-lnsl-and-lsocket.patch
+7ea49ed8c335215c1edc6fae83e6b912 chmlib-0.40.tar.bz2
Added: csw/mgar/pkg/chmlib/trunk/files/0001-gnulib-import-getopt-posix.patch
===================================================================
--- csw/mgar/pkg/chmlib/trunk/files/0001-gnulib-import-getopt-posix.patch (rev 0)
+++ csw/mgar/pkg/chmlib/trunk/files/0001-gnulib-import-getopt-posix.patch 2009-11-10 01:54:17 UTC (rev 7193)
@@ -0,0 +1,4596 @@
+From 23637dad0fc9fb0e5e0755744d5d3726536068ee Mon Sep 17 00:00:00 2001
+From: Ben Walton <bwalton at opencsw.org>
+Date: Thu, 15 Oct 2009 21:32:41 +0200
+Subject: [PATCH 1/4] gnulib --import getopt-posix
+
+---
+ gnulib/Makefile.am | 207 ++++++++
+ gnulib/dummy.c | 42 ++
+ gnulib/getopt.c | 1186 ++++++++++++++++++++++++++++++++++++++++++++
+ gnulib/getopt.in.h | 242 +++++++++
+ gnulib/getopt1.c | 170 +++++++
+ gnulib/getopt_int.h | 130 +++++
+ gnulib/gettext.h | 279 +++++++++++
+ gnulib/m4/00gnulib.m4 | 30 ++
+ gnulib/m4/extensions.m4 | 104 ++++
+ gnulib/m4/getopt.m4 | 250 ++++++++++
+ gnulib/m4/gnulib-cache.m4 | 36 ++
+ gnulib/m4/gnulib-common.m4 | 124 +++++
+ gnulib/m4/gnulib-comp.m4 | 197 ++++++++
+ gnulib/m4/gnulib-tool.m4 | 57 +++
+ gnulib/m4/include_next.m4 | 187 +++++++
+ gnulib/m4/onceonly.m4 | 90 ++++
+ gnulib/m4/stddef_h.m4 | 45 ++
+ gnulib/m4/unistd_h.m4 | 115 +++++
+ gnulib/m4/wchar_t.m4 | 20 +
+ gnulib/stddef.in.h | 86 ++++
+ gnulib/unistd.in.h | 784 +++++++++++++++++++++++++++++
+ link-warning.h | 28 +
+ 22 files changed, 4409 insertions(+), 0 deletions(-)
+ create mode 100644 gnulib/Makefile.am
+ create mode 100644 gnulib/dummy.c
+ create mode 100644 gnulib/getopt.c
+ create mode 100644 gnulib/getopt.in.h
+ create mode 100644 gnulib/getopt1.c
+ create mode 100644 gnulib/getopt_int.h
+ create mode 100644 gnulib/gettext.h
+ create mode 100644 gnulib/m4/00gnulib.m4
+ create mode 100644 gnulib/m4/extensions.m4
+ create mode 100644 gnulib/m4/getopt.m4
+ create mode 100644 gnulib/m4/gnulib-cache.m4
+ create mode 100644 gnulib/m4/gnulib-common.m4
+ create mode 100644 gnulib/m4/gnulib-comp.m4
+ create mode 100644 gnulib/m4/gnulib-tool.m4
+ create mode 100644 gnulib/m4/include_next.m4
+ create mode 100644 gnulib/m4/onceonly.m4
+ create mode 100644 gnulib/m4/stddef_h.m4
+ create mode 100644 gnulib/m4/unistd_h.m4
+ create mode 100644 gnulib/m4/wchar_t.m4
+ create mode 100644 gnulib/stddef.in.h
+ create mode 100644 gnulib/unistd.in.h
+ create mode 100644 link-warning.h
+
+diff --git a/gnulib/Makefile.am b/gnulib/Makefile.am
+new file mode 100644
+index 0000000..ddcdb88
+--- /dev/null
++++ b/gnulib/Makefile.am
+@@ -0,0 +1,207 @@
++## 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=gnulib --m4-base=gnulib/m4 --doc-base=doc --tests-base=tests --aux-dir=. --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 =
++EXTRA_DIST += m4/gnulib-cache.m4
++
++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
++
++## 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)/./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
++
++## 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_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_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_GETPAGESIZE''@|$(REPLACE_GETPAGESIZE)|g' \
++ -e 's|@''REPLACE_LCHOWN''@|$(REPLACE_LCHOWN)|g' \
++ -e 's|@''REPLACE_LINK''@|$(REPLACE_LINK)|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
++
++## 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/gnulib/dummy.c b/gnulib/dummy.c
+new file mode 100644
+index 0000000..ccb5c26
+--- /dev/null
++++ b/gnulib/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/gnulib/getopt.c b/gnulib/getopt.c
+new file mode 100644
+index 0000000..f1e6d1f
+--- /dev/null
++++ b/gnulib/getopt.c
+@@ -0,0 +1,1186 @@
++/* 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
++ 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, char **argv, 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/gnulib/getopt.in.h b/gnulib/getopt.in.h
+new file mode 100644
+index 0000000..15c213f
+--- /dev/null
++++ b/gnulib/getopt.in.h
+@@ -0,0 +1,242 @@
++/* 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. */
++#if @HAVE_GETOPT_H@
++# @INCLUDE_NEXT@ @NEXT_GETOPT_H@
++#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)
++#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/gnulib/getopt1.c b/gnulib/getopt1.c
+new file mode 100644
+index 0000000..ba115c4
+--- /dev/null
++++ b/gnulib/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/gnulib/getopt_int.h b/gnulib/getopt_int.h
+new file mode 100644
+index 0000000..3c6628b
+--- /dev/null
++++ b/gnulib/getopt_int.h
+@@ -0,0 +1,130 @@
++/* Internal declarations for getopt.
++ Copyright (C) 1989-1994,1996-1999,2001,2003,2004
++ 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
++
++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/gnulib/gettext.h b/gnulib/gettext.h
+new file mode 100644
+index 0000000..8cf2dca
+--- /dev/null
++++ b/gnulib/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 3, 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/gnulib/m4/00gnulib.m4 b/gnulib/m4/00gnulib.m4
+new file mode 100644
+index 0000000..d4d04d1
+--- /dev/null
++++ b/gnulib/m4/00gnulib.m4
+@@ -0,0 +1,30 @@
++# 00gnulib.m4 serial 2
++dnl Copyright (C) 2009 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++dnl This file must be named something that sorts before all other
++dnl gnulib-provided .m4 files. It is needed until such time as we can
++dnl assume Autoconf 2.64, with its improved AC_DEFUN_ONCE semantics.
++
++# AC_DEFUN_ONCE([NAME], VALUE)
++# ----------------------------
++# Define NAME to expand to VALUE on the first use (whether by direct
++# expansion, or by AC_REQUIRE), and to nothing on all subsequent uses.
++# Avoid bugs in AC_REQUIRE in Autoconf 2.63 and earlier. This
++# definition is slower than the version in Autoconf 2.64, because it
++# can only use interfaces that existed since 2.59; but it achieves the
++# same effect. Quoting is necessary to avoid confusing Automake.
++m4_version_prereq([2.63.263], [],
++[m4_define([AC][_DEFUN_ONCE],
++ [AC][_DEFUN([$1],
++ [AC_REQUIRE([_gl_DEFUN_ONCE([$1])],
++ [m4_indir([_gl_DEFUN_ONCE([$1])])])])]dnl
++[AC][_DEFUN([_gl_DEFUN_ONCE([$1])], [$2])])])
++
++# gl_00GNULIB
++# -----------
++# Witness macro that this file has been included. Needed to force
++# Automake to include this file prior to all other gnulib .m4 files.
++AC_DEFUN([gl_00GNULIB])
+diff --git a/gnulib/m4/extensions.m4 b/gnulib/m4/extensions.m4
+new file mode 100644
+index 0000000..ba6d5e1
+--- /dev/null
++++ b/gnulib/m4/extensions.m4
+@@ -0,0 +1,104 @@
++# serial 8 -*- Autoconf -*-
++# Enable extensions on systems that normally disable them.
++
++# Copyright (C) 2003, 2006-2009 Free Software Foundation, Inc.
++# This file is free software; the Free Software Foundation
++# gives unlimited permission to copy and/or distribute it,
++# with or without modifications, as long as this notice is preserved.
++
++# This definition of AC_USE_SYSTEM_EXTENSIONS is stolen from CVS
++# Autoconf. Perhaps we can remove this once we can assume Autoconf
++# 2.62 or later everywhere, but since CVS Autoconf mutates rapidly
++# enough in this area it's likely we'll need to redefine
++# AC_USE_SYSTEM_EXTENSIONS for quite some time.
++
++# AC_USE_SYSTEM_EXTENSIONS
++# ------------------------
++# Enable extensions on systems that normally disable them,
++# typically due to standards-conformance issues.
++# Remember that #undef in AH_VERBATIM gets replaced with #define by
++# AC_DEFINE. The goal here is to define all known feature-enabling
++# macros, then, if reports of conflicts are made, disable macros that
++# cause problems on some platforms (such as __EXTENSIONS__).
++AC_DEFUN_ONCE([AC_USE_SYSTEM_EXTENSIONS],
++[AC_BEFORE([$0], [AC_COMPILE_IFELSE])dnl
++AC_BEFORE([$0], [AC_RUN_IFELSE])dnl
++
++ AC_REQUIRE([AC_CANONICAL_HOST])
++
++ AC_CHECK_HEADER([minix/config.h], [MINIX=yes], [MINIX=])
++ if test "$MINIX" = yes; then
++ AC_DEFINE([_POSIX_SOURCE], [1],
++ [Define to 1 if you need to in order for `stat' and other
++ things to work.])
++ AC_DEFINE([_POSIX_1_SOURCE], [2],
++ [Define to 2 if the system does not provide POSIX.1 features
++ except with this defined.])
++ AC_DEFINE([_MINIX], [1],
++ [Define to 1 if on MINIX.])
++ fi
++
++ dnl HP-UX 11.11 defines mbstate_t only if _XOPEN_SOURCE is defined to 500,
++ dnl regardless of whether the flags -Ae or _D_HPUX_SOURCE=1 are already
++ dnl provided.
++ case "$host_os" in
++ hpux*)
++ AC_DEFINE([_XOPEN_SOURCE], [500],
++ [Define to 500 only on HP-UX.])
++ ;;
++ esac
++
++ AH_VERBATIM([__EXTENSIONS__],
++[/* Enable extensions on AIX 3, Interix. */
++#ifndef _ALL_SOURCE
++# undef _ALL_SOURCE
++#endif
++/* Enable GNU extensions on systems that have them. */
++#ifndef _GNU_SOURCE
++# undef _GNU_SOURCE
++#endif
++/* Enable threading extensions on Solaris. */
++#ifndef _POSIX_PTHREAD_SEMANTICS
++# undef _POSIX_PTHREAD_SEMANTICS
++#endif
++/* Enable extensions on HP NonStop. */
++#ifndef _TANDEM_SOURCE
++# undef _TANDEM_SOURCE
++#endif
++/* Enable general extensions on Solaris. */
++#ifndef __EXTENSIONS__
++# undef __EXTENSIONS__
++#endif
++])
++ AC_CACHE_CHECK([whether it is safe to define __EXTENSIONS__],
++ [ac_cv_safe_to_define___extensions__],
++ [AC_COMPILE_IFELSE(
++ [AC_LANG_PROGRAM([[
++# define __EXTENSIONS__ 1
++ ]AC_INCLUDES_DEFAULT])],
++ [ac_cv_safe_to_define___extensions__=yes],
++ [ac_cv_safe_to_define___extensions__=no])])
++ test $ac_cv_safe_to_define___extensions__ = yes &&
++ AC_DEFINE([__EXTENSIONS__])
++ AC_DEFINE([_ALL_SOURCE])
++ AC_DEFINE([_GNU_SOURCE])
++ AC_DEFINE([_POSIX_PTHREAD_SEMANTICS])
++ AC_DEFINE([_TANDEM_SOURCE])
++])# AC_USE_SYSTEM_EXTENSIONS
++
++# gl_USE_SYSTEM_EXTENSIONS
++# ------------------------
++# Enable extensions on systems that normally disable them,
++# typically due to standards-conformance issues.
++AC_DEFUN_ONCE([gl_USE_SYSTEM_EXTENSIONS],
++[
++ dnl Require this macro before AC_USE_SYSTEM_EXTENSIONS.
++ dnl gnulib does not need it. But if it gets required by third-party macros
++ dnl after AC_USE_SYSTEM_EXTENSIONS is required, autoconf 2.62..2.63 emit a
++ dnl warning: "AC_COMPILE_IFELSE was called before AC_USE_SYSTEM_EXTENSIONS".
++ dnl Note: We can do this only for one of the macros AC_AIX, AC_GNU_SOURCE,
++ dnl AC_MINIX. If people still use AC_AIX or AC_MINIX, they are out of luck.
++ AC_REQUIRE([AC_GNU_SOURCE])
++
++ AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])
++])
+diff --git a/gnulib/m4/getopt.m4 b/gnulib/m4/getopt.m4
+new file mode 100644
+index 0000000..53a1a7e
+--- /dev/null
++++ b/gnulib/m4/getopt.m4
+@@ -0,0 +1,250 @@
++# getopt.m4 serial 22
++dnl Copyright (C) 2002-2006, 2008-2009 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++# Request a POSIX compliant getopt function.
++AC_DEFUN([gl_FUNC_GETOPT_POSIX],
++[
++ m4_divert_text([DEFAULTS], [gl_getopt_required=POSIX])
++ AC_REQUIRE([gl_UNISTD_H_DEFAULTS])
++ gl_GETOPT_IFELSE([
++ gl_REPLACE_GETOPT
++ ],
++ [])
++])
++
++# Request a POSIX compliant getopt function with GNU extensions (such as
++# options with optional arguments) and the functions getopt_long,
++# getopt_long_only.
++AC_DEFUN([gl_FUNC_GETOPT_GNU],
++[
++ m4_divert_text([INIT_PREPARE], [gl_getopt_required=GNU])
++
++ AC_REQUIRE([gl_FUNC_GETOPT_POSIX])
++])
++
++# Request the gnulib implementation of the getopt functions unconditionally.
++# argp.m4 uses this.
++AC_DEFUN([gl_REPLACE_GETOPT],
++[
++ dnl Arrange for getopt.h to be created.
++ gl_GETOPT_SUBSTITUTE_HEADER
++ dnl Arrange for unistd.h to include getopt.h.
++ GNULIB_UNISTD_H_GETOPT=1
++ dnl Arrange to compile the getopt implementation.
++ AC_LIBOBJ([getopt])
++ AC_LIBOBJ([getopt1])
++ gl_PREREQ_GETOPT
++])
++
++# emacs' configure.in uses this.
++AC_DEFUN([gl_GETOPT_IFELSE],
++[
++ AC_REQUIRE([gl_GETOPT_CHECK_HEADERS])
++ AS_IF([test -n "$gl_replace_getopt"], [$1], [$2])
++])
++
++# Determine whether to replace the entire getopt facility.
++AC_DEFUN([gl_GETOPT_CHECK_HEADERS],
++[
++ AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles
++
++ dnl Persuade Solaris <unistd.h> to declare optarg, optind, opterr, optopt.
++ AC_REQUIRE([AC_USE_SYSTEM_EXTENSIONS])
++
++ gl_CHECK_NEXT_HEADERS([getopt.h])
++ AC_CHECK_HEADERS_ONCE([getopt.h])
++ if test $ac_cv_header_getopt_h = yes; then
++ HAVE_GETOPT_H=1
++ else
++ HAVE_GETOPT_H=0
++ fi
++ AC_SUBST([HAVE_GETOPT_H])
++
++ gl_replace_getopt=
++
++ dnl Test whether <getopt.h> is available.
++ if test -z "$gl_replace_getopt" && test $gl_getopt_required = GNU; then
++ AC_CHECK_HEADERS([getopt.h], [], [gl_replace_getopt=yes])
++ fi
++
++ dnl Test whether the function getopt_long is available.
++ if test -z "$gl_replace_getopt" && test $gl_getopt_required = GNU; then
++ AC_CHECK_FUNCS([getopt_long_only], [], [gl_replace_getopt=yes])
++ fi
++
++ dnl BSD getopt_long uses an incompatible method to reset option processing,
++ dnl but the testsuite does not show a need to use this 'optreset' variable.
++ if false && test -z "$gl_replace_getopt" && test $gl_getopt_required = GNU; then
++ AC_CHECK_DECL([optreset], [gl_replace_getopt=yes], [],
++ [#include <getopt.h>])
++ fi
++
++ dnl mingw's getopt (in libmingwex.a) does weird things when the options
++ dnl strings starts with '+' and it's not the first call. Some internal state
++ dnl is left over from earlier calls, and neither setting optind = 0 nor
++ dnl setting optreset = 1 get rid of this internal state.
++ if test -z "$gl_replace_getopt"; then
++ AC_CACHE_CHECK([whether getopt is POSIX compatible],
++ [gl_cv_func_getopt_posix],
++ [
++ dnl This test fails on mingw and succeeds on all other platforms.
++ AC_RUN_IFELSE([AC_LANG_SOURCE([[
++#include <unistd.h>
++#include <stdlib.h>
++#include <string.h>
++
++/* The glibc implementation of getopt supports setting optind = 0 as a means
++ of clearing the internal state, but other implementations don't. */
++#if (__GLIBC__ >= 2)
++# define OPTIND_MIN 0
++#else
++# define OPTIND_MIN 1
++#endif
++
++int
++main ()
++{
++ {
++ int argc = 0;
++ char *argv[10];
++ int c;
++
++ argv[argc++] = "program";
++ argv[argc++] = "-a";
++ argv[argc++] = "foo";
++ argv[argc++] = "bar";
++ optind = OPTIND_MIN;
++ opterr = 0;
++
++ c = getopt (argc, argv, "ab");
++ if (!(c == 'a'))
++ return 1;
++ c = getopt (argc, argv, "ab");
++ if (!(c == -1))
++ return 2;
++ if (!(optind == 2))
++ return 3;
++ }
++ /* Some internal state exists at this point. */
++ {
++ int argc = 0;
++ char *argv[10];
++ int c;
++
++ argv[argc++] = "program";
++ argv[argc++] = "donald";
++ argv[argc++] = "-p";
++ argv[argc++] = "billy";
++ argv[argc++] = "duck";
++ argv[argc++] = "-a";
++ argv[argc++] = "bar";
++ optind = OPTIND_MIN;
++ opterr = 0;
++
++ c = getopt (argc, argv, "+abp:q:");
++ if (!(c == -1))
++ return 4;
++ if (!(strcmp (argv[0], "program") == 0))
++ return 5;
++ if (!(strcmp (argv[1], "donald") == 0))
++ return 6;
++ if (!(strcmp (argv[2], "-p") == 0))
++ return 7;
++ if (!(strcmp (argv[3], "billy") == 0))
++ return 8;
++ if (!(strcmp (argv[4], "duck") == 0))
++ return 9;
++ if (!(strcmp (argv[5], "-a") == 0))
++ return 10;
++ if (!(strcmp (argv[6], "bar") == 0))
++ return 11;
++ if (!(optind == 1))
++ return 12;
++ }
++
++ return 0;
++}
++]])],
++ [gl_cv_func_getopt_posix=yes], [gl_cv_func_getopt_posix=no],
++ [case "$host_os" in
++ mingw*) gl_cv_func_getopt_posix="guessing no";;
++ *) gl_cv_func_getopt_posix="guessing yes";;
++ esac
++ ])
++ ])
++ case "$gl_cv_func_getopt_posix" in
++ *no) gl_replace_getopt=yes ;;
++ esac
++ fi
++
++ if test -z "$gl_replace_getopt" && test $gl_getopt_required = GNU; then
++ AC_CACHE_CHECK([for working GNU getopt function], [gl_cv_func_getopt_gnu],
++ [AC_RUN_IFELSE(
++ [AC_LANG_PROGRAM([[#include <getopt.h>
++ #include <stddef.h>
++ #include <string.h>]],
++ [[
++ /* This code succeeds on glibc 2.8, OpenBSD 4.0, Cygwin, mingw,
++ and fails on MacOS X 10.5, AIX 5.2, HP-UX 11, IRIX 6.5,
++ OSF/1 5.1, Solaris 10. */
++ {
++ char *myargv[3];
++ myargv[0] = "conftest";
++ myargv[1] = "-+";
++ myargv[2] = 0;
++ opterr = 0;
++ if (getopt (2, myargv, "+a") != '?')
++ return 1;
++ }
++ /* This code succeeds on glibc 2.8, mingw,
++ and fails on MacOS X 10.5, OpenBSD 4.0, AIX 5.2, HP-UX 11,
++ IRIX 6.5, OSF/1 5.1, Solaris 10, Cygwin. */
++ {
++ char *argv[] = { "program", "-p", "foo", "bar" };
++
++ optind = 1;
++ if (getopt (4, argv, "p::") != 'p')
++ return 2;
++ if (optarg != NULL)
++ return 3;
++ if (getopt (4, argv, "p::") != -1)
++ return 4;
++ if (optind != 2)
++ return 5;
++ }
++ return 0;
++ ]])],
++ [gl_cv_func_getopt_gnu=yes],
++ [gl_cv_func_getopt_gnu=no],
++ [dnl Cross compiling. Guess based on host and declarations.
++ case "$host_os" in
++ *-gnu* | mingw*) gl_cv_func_getopt_gnu=no;;
++ *) gl_cv_func_getopt_gnu=yes;;
++ esac
++ ])
++ ])
++ if test "$gl_cv_func_getopt_gnu" = "no"; then
++ gl_replace_getopt=yes
++ fi
++ fi
++])
++
++# emacs' configure.in uses this.
++AC_DEFUN([gl_GETOPT_SUBSTITUTE_HEADER],
++[
++ GETOPT_H=getopt.h
++ AC_DEFINE([__GETOPT_PREFIX], [[rpl_]],
++ [Define to rpl_ if the getopt replacement functions and variables
++ should be used.])
++ AC_SUBST([GETOPT_H])
++])
++
++# Prerequisites of lib/getopt*.
++# emacs' configure.in uses this.
++AC_DEFUN([gl_PREREQ_GETOPT],
++[
++ AC_CHECK_DECLS_ONCE([getenv])
++])
+diff --git a/gnulib/m4/gnulib-cache.m4 b/gnulib/m4/gnulib-cache.m4
+new file mode 100644
+index 0000000..56a554b
+--- /dev/null
++++ b/gnulib/m4/gnulib-cache.m4
+@@ -0,0 +1,36 @@
++# 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.
++#
++# This file represents the specification of how gnulib-tool is used.
++# It acts as a cache: It is written and read by gnulib-tool.
++# In projects using CVS, this file is meant to be stored in CVS,
++# like the configure.ac and various Makefile.am files.
++
++
++# Specification in the form of a command-line invocation:
++# gnulib-tool --import --dir=. --lib=libgnu --source-base=gnulib --m4-base=gnulib/m4 --doc-base=doc --tests-base=tests --aux-dir=. --libtool --macro-prefix=gl --no-vc-files getopt-gnu
++
++# Specification in the form of a few gnulib-tool.m4 macro invocations:
++gl_LOCAL_DIR([])
++gl_MODULES([
++ getopt-gnu
++])
++gl_AVOID([])
++gl_SOURCE_BASE([gnulib])
++gl_M4_BASE([gnulib/m4])
++gl_PO_BASE([])
++gl_DOC_BASE([doc])
++gl_TESTS_BASE([tests])
++gl_LIB([libgnu])
++gl_MAKEFILE_NAME([])
++gl_LIBTOOL
++gl_MACRO_PREFIX([gl])
++gl_PO_DOMAIN([])
++gl_VC_FILES([false])
+diff --git a/gnulib/m4/gnulib-common.m4 b/gnulib/m4/gnulib-common.m4
+new file mode 100644
+index 0000000..c8fda20
+--- /dev/null
++++ b/gnulib/m4/gnulib-common.m4
+@@ -0,0 +1,124 @@
++# gnulib-common.m4 serial 11
++dnl Copyright (C) 2007-2009 Free Software Foundation, Inc.
++dnl This file is free software; the Free Software Foundation
++dnl gives unlimited permission to copy and/or distribute it,
++dnl with or without modifications, as long as this notice is preserved.
++
++# gl_COMMON
++# is expanded unconditionally through gnulib-tool magic.
++AC_DEFUN([gl_COMMON], [
++ dnl Use AC_REQUIRE here, so that the code is expanded once only.
++ AC_REQUIRE([gl_00GNULIB])
++ AC_REQUIRE([gl_COMMON_BODY])
++])
++AC_DEFUN([gl_COMMON_BODY], [
++ AH_VERBATIM([isoc99_inline],
++[/* Work around a bug in Apple GCC 4.0.1 build 5465: In C99 mode, it supports
++ the ISO C 99 semantics of 'extern inline' (unlike the GNU C semantics of
++ earlier versions), but does not display it by setting __GNUC_STDC_INLINE__.
++ __APPLE__ && __MACH__ test for MacOS X.
++ __APPLE_CC__ tests for the Apple compiler and its version.
++ __STDC_VERSION__ tests for the C99 mode. */
++#if defined __APPLE__ && defined __MACH__ && __APPLE_CC__ >= 5465 && !defined __cplusplus && __STDC_VERSION__ >= 199901L && !defined __GNUC_STDC_INLINE__
++# define __GNUC_STDC_INLINE__ 1
++#endif])
++ AH_VERBATIM([unused_parameter],
++[/* Define as a marker that can be attached to function parameter declarations
++ for parameters that are not used. This helps to reduce warnings, such as
++ from GCC -Wunused-parameter. */
++#if __GNUC__ >= 3 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 7)
++# define _UNUSED_PARAMETER_ __attribute__ ((__unused__))
++#else
++# define _UNUSED_PARAMETER_
++#endif
++])
++])
++
++# gl_MODULE_INDICATOR([modulename])
++# defines a C macro indicating the presence of the given module.
++AC_DEFUN([gl_MODULE_INDICATOR],
++[
++ AC_DEFINE([GNULIB_]translit([$1],[abcdefghijklmnopqrstuvwxyz./-],[ABCDEFGHIJKLMNOPQRSTUVWXYZ___]), [1],
++ [Define to 1 when using the gnulib module ]$1[.])
++])
++
++# m4_foreach_w
++# is a backport of autoconf-2.59c's m4_foreach_w.
++# Remove this macro when we can assume autoconf >= 2.60.
++m4_ifndef([m4_foreach_w],
++ [m4_define([m4_foreach_w],
++ [m4_foreach([$1], m4_split(m4_normalize([$2]), [ ]), [$3])])])
++
++# AC_PROG_MKDIR_P
++# is a backport of autoconf-2.60's AC_PROG_MKDIR_P.
++# Remove this macro when we can assume autoconf >= 2.60.
++m4_ifdef([AC_PROG_MKDIR_P], [], [
++ AC_DEFUN_ONCE([AC_PROG_MKDIR_P],
++ [AC_REQUIRE([AM_PROG_MKDIR_P])dnl defined by automake
++ MKDIR_P='$(mkdir_p)'
++ AC_SUBST([MKDIR_P])])])
++
++# AC_C_RESTRICT
++# This definition overrides the AC_C_RESTRICT macro from autoconf 2.60..2.61,
++# so that mixed use of GNU C and GNU C++ and mixed use of Sun C and Sun C++
++# works.
++# This definition can be removed once autoconf >= 2.62 can be assumed.
++AC_DEFUN([AC_C_RESTRICT],
++[AC_CACHE_CHECK([for C/C++ restrict keyword], [ac_cv_c_restrict],
++ [ac_cv_c_restrict=no
++ # The order here caters to the fact that C++ does not require restrict.
++ for ac_kw in __restrict __restrict__ _Restrict restrict; do
++ AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
++ [[typedef int * int_ptr;
++ int foo (int_ptr $ac_kw ip) {
++ return ip[0];
++ }]],
++ [[int s[1];
++ int * $ac_kw t = s;
++ t[0] = 0;
++ return foo(t)]])],
++ [ac_cv_c_restrict=$ac_kw])
++ test "$ac_cv_c_restrict" != no && break
++ done
++ ])
++ AH_VERBATIM([restrict],
++[/* Define to the equivalent of the C99 'restrict' keyword, or to
++ nothing if this is not supported. Do not define if restrict is
++ supported directly. */
++#undef restrict
++/* Work around a bug in Sun C++: it does not support _Restrict, even
++ though the corresponding Sun C compiler does, which causes
++ "#define restrict _Restrict" in the previous line. Perhaps some future
++ version of Sun C++ will work with _Restrict; if so, it'll probably
++ define __RESTRICT, just as Sun C does. */
++#if defined __SUNPRO_CC && !defined __RESTRICT
++# define _Restrict
++#endif])
++ case $ac_cv_c_restrict in
++ restrict) ;;
++ no) AC_DEFINE([restrict], []) ;;
++ *) AC_DEFINE_UNQUOTED([restrict], [$ac_cv_c_restrict]) ;;
++ esac
++])
++
++# gl_BIGENDIAN
++# is like AC_C_BIGENDIAN, except that it can be AC_REQUIREd.
++# Note that AC_REQUIRE([AC_C_BIGENDIAN]) does not work reliably because some
++# macros invoke AC_C_BIGENDIAN with arguments.
++AC_DEFUN([gl_BIGENDIAN],
++[
++ AC_C_BIGENDIAN
++])
++
++# gl_CACHE_VAL_SILENT(cache-id, command-to-set-it)
++# is like AC_CACHE_VAL(cache-id, command-to-set-it), except that it does not
++# output a spurious "(cached)" mark in the midst of other configure output.
++# This macro should be used instead of AC_CACHE_VAL when it is not surrounded
++# by an AC_MSG_CHECKING/AC_MSG_RESULT pair.
++AC_DEFUN([gl_CACHE_VAL_SILENT],
++[
++ saved_as_echo_n="$as_echo_n"
++ as_echo_n=':'
++ AC_CACHE_VAL([$1], [$2])
++ as_echo_n="$saved_as_echo_n"
++])
+diff --git a/gnulib/m4/gnulib-comp.m4 b/gnulib/m4/gnulib-comp.m4
+new file mode 100644
+index 0000000..6514552
+--- /dev/null
++++ b/gnulib/m4/gnulib-comp.m4
+@@ -0,0 +1,197 @@
++# DO NOT EDIT! GENERATED AUTOMATICALLY!
++# 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.
++#
++# This file represents the compiled summary of the specification in
++# gnulib-cache.m4. It lists the computed macro invocations that need
++# to be invoked from configure.ac.
++# In projects using CVS, this file can be treated like other built files.
++
++
++# This macro should be invoked from ./configure.in, in the section
++# "Checks for programs", right after AC_PROG_CC, and certainly before
++# any checks for libraries, header files, types and library functions.
++AC_DEFUN([gl_EARLY],
++[
++ m4_pattern_forbid([^gl_[A-Z]])dnl the gnulib macro namespace
++ m4_pattern_allow([^gl_ES$])dnl a valid locale name
++ m4_pattern_allow([^gl_LIBOBJS$])dnl a variable
++ m4_pattern_allow([^gl_LTLIBOBJS$])dnl a variable
++ AC_REQUIRE([AC_PROG_RANLIB])
++ AC_REQUIRE([gl_USE_SYSTEM_EXTENSIONS])
++])
++
++# This macro should be invoked from ./configure.in, in the section
++# "Check for header files, types and library functions".
++AC_DEFUN([gl_INIT],
++[
++ AM_CONDITIONAL([GL_COND_LIBTOOL], [true])
++ gl_cond_libtool=true
++ m4_pushdef([AC_LIBOBJ], m4_defn([gl_LIBOBJ]))
++ m4_pushdef([AC_REPLACE_FUNCS], m4_defn([gl_REPLACE_FUNCS]))
++ m4_pushdef([AC_LIBSOURCES], m4_defn([gl_LIBSOURCES]))
++ m4_pushdef([gl_LIBSOURCES_LIST], [])
++ m4_pushdef([gl_LIBSOURCES_DIR], [])
++ gl_COMMON
++ gl_source_base='gnulib'
++ gl_FUNC_GETOPT_GNU
++ gl_MODULE_INDICATOR([getopt-gnu])
++ gl_FUNC_GETOPT_POSIX
++ AC_SUBST([LIBINTL])
++ AC_SUBST([LTLIBINTL])
++ gl_STDDEF_H
++ gl_UNISTD_H
++ m4_ifval(gl_LIBSOURCES_LIST, [
++ m4_syscmd([test ! -d ]m4_defn([gl_LIBSOURCES_DIR])[ ||
++ for gl_file in ]gl_LIBSOURCES_LIST[ ; do
++ if test ! -r ]m4_defn([gl_LIBSOURCES_DIR])[/$gl_file ; then
++ echo "missing file ]m4_defn([gl_LIBSOURCES_DIR])[/$gl_file" >&2
++ exit 1
++ fi
++ done])dnl
++ m4_if(m4_sysval, [0], [],
++ [AC_FATAL([expected source file, required through AC_LIBSOURCES, not found])])
++ ])
++ m4_popdef([gl_LIBSOURCES_DIR])
++ m4_popdef([gl_LIBSOURCES_LIST])
++ m4_popdef([AC_LIBSOURCES])
++ m4_popdef([AC_REPLACE_FUNCS])
++ m4_popdef([AC_LIBOBJ])
++ AC_CONFIG_COMMANDS_PRE([
++ gl_libobjs=
++ gl_ltlibobjs=
++ if test -n "$gl_LIBOBJS"; then
++ # Remove the extension.
++ sed_drop_objext='s/\.o$//;s/\.obj$//'
++ for i in `for i in $gl_LIBOBJS; do echo "$i"; done | sed "$sed_drop_objext" | sort | uniq`; do
++ gl_libobjs="$gl_libobjs $i.$ac_objext"
++ gl_ltlibobjs="$gl_ltlibobjs $i.lo"
++ done
++ fi
++ AC_SUBST([gl_LIBOBJS], [$gl_libobjs])
++ AC_SUBST([gl_LTLIBOBJS], [$gl_ltlibobjs])
++ ])
++ gltests_libdeps=
++ gltests_ltlibdeps=
++ m4_pushdef([AC_LIBOBJ], m4_defn([gltests_LIBOBJ]))
++ m4_pushdef([AC_REPLACE_FUNCS], m4_defn([gltests_REPLACE_FUNCS]))
++ m4_pushdef([AC_LIBSOURCES], m4_defn([gltests_LIBSOURCES]))
++ m4_pushdef([gltests_LIBSOURCES_LIST], [])
++ m4_pushdef([gltests_LIBSOURCES_DIR], [])
++ gl_COMMON
++ gl_source_base='tests'
++ m4_ifval(gltests_LIBSOURCES_LIST, [
++ m4_syscmd([test ! -d ]m4_defn([gltests_LIBSOURCES_DIR])[ ||
++ for gl_file in ]gltests_LIBSOURCES_LIST[ ; do
@@ 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