diff --git a/sources/plugins/cardinal/debian/cardinal-data.install b/sources/plugins/cardinal/debian/cardinal-data.install new file mode 100644 index 0000000..8a62a0f --- /dev/null +++ b/sources/plugins/cardinal/debian/cardinal-data.install @@ -0,0 +1 @@ +/usr/share diff --git a/sources/plugins/cardinal/debian/cardinal-lv2.install b/sources/plugins/cardinal/debian/cardinal-lv2.install new file mode 100644 index 0000000..c51d4b5 --- /dev/null +++ b/sources/plugins/cardinal/debian/cardinal-lv2.install @@ -0,0 +1 @@ +/usr/lib/lv2 diff --git a/sources/plugins/cardinal/debian/cardinal-vst2.install b/sources/plugins/cardinal/debian/cardinal-vst2.install new file mode 100644 index 0000000..af33a97 --- /dev/null +++ b/sources/plugins/cardinal/debian/cardinal-vst2.install @@ -0,0 +1 @@ +/usr/lib/vst diff --git a/sources/plugins/cardinal/debian/cardinal-vst3.install b/sources/plugins/cardinal/debian/cardinal-vst3.install new file mode 100644 index 0000000..25b1fb2 --- /dev/null +++ b/sources/plugins/cardinal/debian/cardinal-vst3.install @@ -0,0 +1 @@ +/usr/lib/vst3 diff --git a/sources/plugins/cardinal/debian/cardinal.install b/sources/plugins/cardinal/debian/cardinal.install new file mode 100644 index 0000000..415f082 --- /dev/null +++ b/sources/plugins/cardinal/debian/cardinal.install @@ -0,0 +1 @@ +/usr/bin diff --git a/sources/plugins/cardinal/debian/changelog b/sources/plugins/cardinal/debian/changelog new file mode 100644 index 0000000..a026b1e --- /dev/null +++ b/sources/plugins/cardinal/debian/changelog @@ -0,0 +1,5 @@ +cardinal (5:22.07-1kxstudio2) focal; urgency=medium + + * Initial package + + -- falkTX Sun, 17 Apr 2022 15:05:47 +0100 diff --git a/sources/plugins/cardinal/debian/control b/sources/plugins/cardinal/debian/control new file mode 100644 index 0000000..584fae3 --- /dev/null +++ b/sources/plugins/cardinal/debian/control @@ -0,0 +1,137 @@ +Source: cardinal +Section: sound +Priority: optional +Maintainer: falkTX +Build-Depends: debhelper-compat (= 13), + kxstudio-audio-plugin-tester, + debhelper (>= 9~), + libdbus-1-dev, + libgl1-mesa-dev | libgl-dev, + libmagic-dev, + libx11-dev, + libxcursor-dev, + libxext-dev, + libxrandr-dev, + cmake, + wget, + liblo-static, + libsndfile-static, + fftw3-static, + zlib-static, + python3 +Homepage: https://github.com/DISTRHO/Cardinal +Standards-Version: 4.5.0 +Rules-Requires-Root: no + +Package: cardinal +Architecture: any +Depends: ${shlibs:Depends}, ${misc:Depends}, cardinal-data +Provides: standalone-plugin +Recommends: carla | carla-git, mpv +Description: virtual modular synthesizer plugin + Free and open-source virtual modular synthesizer plugin, + available as JACK standalone and LV2, VST2 and VST3 audio plugin for FreeBSD, Linux, macOS and Windows. + It is based on the popular VCV Rack but with a focus on being a fully self-contained plugin version. + . + Cardinal contains Rack, some 3rd-party modules and a few internal utilities all in a single binary. + All "Core" modules from Rack have been replaced by Cardinal equivalents, simplified to better work for an audio plugin. + . + Cardinal does not load external modules and does not connect to the official Rack library/store. + All VCV branding has been removed (to the best of authors knowledge) in order to avoid any trademark issues. + . + Cardinal provides 3 plugin variants - "main", Synth and FX. + They are all equivalent in performance and behaviour, with only the IO and metadata that changes. + FX and Synth variants both have 2 audio outputs, while "main" has 8. + All variants have MIDI input and output support. + . + This package provides the standalone application. + +Package: cardinal-data +Architecture: all +Depends: ${misc:Depends} +Description: virtual modular synthesizer plugin + Free and open-source virtual modular synthesizer plugin, + available as JACK standalone and LV2, VST2 and VST3 audio plugin for FreeBSD, Linux, macOS and Windows. + It is based on the popular VCV Rack but with a focus on being a fully self-contained plugin version. + . + Cardinal contains Rack, some 3rd-party modules and a few internal utilities all in a single binary. + All "Core" modules from Rack have been replaced by Cardinal equivalents, simplified to better work for an audio plugin. + . + Cardinal does not load external modules and does not connect to the official Rack library/store. + All VCV branding has been removed (to the best of authors knowledge) in order to avoid any trademark issues. + . + Cardinal provides 3 plugin variants - "main", Synth and FX. + They are all equivalent in performance and behaviour, with only the IO and metadata that changes. + FX and Synth variants both have 2 audio outputs, while "main" has 8. + All variants have MIDI input and output support. + . + This package provides the architecture independent resources, shared between all Cardinal packages. + +Package: cardinal-lv2 +Architecture: any +Depends: ${shlibs:Depends}, ${misc:Depends}, cardinal-data +Provides: lv2-plugin +Recommends: carla | carla-git, mpv +Description: virtual modular synthesizer plugin + Free and open-source virtual modular synthesizer plugin, + available as JACK standalone and LV2, VST2 and VST3 audio plugin for FreeBSD, Linux, macOS and Windows. + It is based on the popular VCV Rack but with a focus on being a fully self-contained plugin version. + . + Cardinal contains Rack, some 3rd-party modules and a few internal utilities all in a single binary. + All "Core" modules from Rack have been replaced by Cardinal equivalents, simplified to better work for an audio plugin. + . + Cardinal does not load external modules and does not connect to the official Rack library/store. + All VCV branding has been removed (to the best of authors knowledge) in order to avoid any trademark issues. + . + Cardinal provides 3 plugin variants - "main", Synth and FX. + They are all equivalent in performance and behaviour, with only the IO and metadata that changes. + FX and Synth variants both have 2 audio outputs, while "main" has 8. + All variants have MIDI input and output support. + . + This package provides the LV2 plugin. + +Package: cardinal-vst2 +Architecture: any +Depends: ${shlibs:Depends}, ${misc:Depends}, cardinal-data +Provides: vst-plugin +Recommends: carla | carla-git, mpv +Description: virtual modular synthesizer plugin + Free and open-source virtual modular synthesizer plugin, + available as JACK standalone and LV2, VST2 and VST3 audio plugin for FreeBSD, Linux, macOS and Windows. + It is based on the popular VCV Rack but with a focus on being a fully self-contained plugin version. + . + Cardinal contains Rack, some 3rd-party modules and a few internal utilities all in a single binary. + All "Core" modules from Rack have been replaced by Cardinal equivalents, simplified to better work for an audio plugin. + . + Cardinal does not load external modules and does not connect to the official Rack library/store. + All VCV branding has been removed (to the best of authors knowledge) in order to avoid any trademark issues. + . + Cardinal provides 3 plugin variants - "main", Synth and FX. + They are all equivalent in performance and behaviour, with only the IO and metadata that changes. + FX and Synth variants both have 2 audio outputs, while "main" has 8. + All variants have MIDI input and output support. + . + This package provides the VST2 plugin. + +Package: cardinal-vst3 +Architecture: any +Depends: ${shlibs:Depends}, ${misc:Depends}, cardinal-data +Provides: vst3-plugin +Recommends: carla | carla-git, mpv +Description: virtual modular synthesizer plugin + Free and open-source virtual modular synthesizer plugin, + available as JACK standalone and LV2, VST2 and VST3 audio plugin for FreeBSD, Linux, macOS and Windows. + It is based on the popular VCV Rack but with a focus on being a fully self-contained plugin version. + . + Cardinal contains Rack, some 3rd-party modules and a few internal utilities all in a single binary. + All "Core" modules from Rack have been replaced by Cardinal equivalents, simplified to better work for an audio plugin. + . + Cardinal does not load external modules and does not connect to the official Rack library/store. + All VCV branding has been removed (to the best of authors knowledge) in order to avoid any trademark issues. + . + Cardinal provides 3 plugin variants - "main", Synth and FX. + They are all equivalent in performance and behaviour, with only the IO and metadata that changes. + FX and Synth variants both have 2 audio outputs, while "main" has 8. + All variants have MIDI input and output support. + . + This package provides the VST3 plugin. Please note the VST3 version is considered experimental. diff --git a/sources/plugins/cardinal/debian/patches/01_vendored-libs.patch b/sources/plugins/cardinal/debian/patches/01_vendored-libs.patch new file mode 100644 index 0000000..4a29436 --- /dev/null +++ b/sources/plugins/cardinal/debian/patches/01_vendored-libs.patch @@ -0,0 +1,24680 @@ +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/jansson-2.12/test/bin/Makefile.am +@@ -0,0 +1,5 @@ ++check_PROGRAMS = json_process ++ ++AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src ++LDFLAGS = -static # for speed and Valgrind ++LDADD = $(top_builddir)/src/libjansson.la +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/jansson-2.12/test/bin/Makefile.in +@@ -0,0 +1,596 @@ ++# Makefile.in generated by automake 1.16.1 from Makefile.am. ++# @configure_input@ ++ ++# Copyright (C) 1994-2018 Free Software Foundation, Inc. ++ ++# This Makefile.in 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 program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY, to the extent permitted by law; without ++# even the implied warranty of MERCHANTABILITY or FITNESS FOR A ++# PARTICULAR PURPOSE. ++ ++@SET_MAKE@ ++VPATH = @srcdir@ ++am__is_gnu_make = { \ ++ if test -z '$(MAKELEVEL)'; then \ ++ false; \ ++ elif test -n '$(MAKE_HOST)'; then \ ++ true; \ ++ elif test -n '$(MAKE_VERSION)' && test -n '$(CURDIR)'; then \ ++ true; \ ++ else \ ++ false; \ ++ fi; \ ++} ++am__make_running_with_option = \ ++ case $${target_option-} in \ ++ ?) ;; \ ++ *) echo "am__make_running_with_option: internal error: invalid" \ ++ "target option '$${target_option-}' specified" >&2; \ ++ exit 1;; \ ++ esac; \ ++ has_opt=no; \ ++ sane_makeflags=$$MAKEFLAGS; \ ++ if $(am__is_gnu_make); then \ ++ sane_makeflags=$$MFLAGS; \ ++ else \ ++ case $$MAKEFLAGS in \ ++ *\\[\ \ ]*) \ ++ bs=\\; \ ++ sane_makeflags=`printf '%s\n' "$$MAKEFLAGS" \ ++ | sed "s/$$bs$$bs[$$bs $$bs ]*//g"`;; \ ++ esac; \ ++ fi; \ ++ skip_next=no; \ ++ strip_trailopt () \ ++ { \ ++ flg=`printf '%s\n' "$$flg" | sed "s/$$1.*$$//"`; \ ++ }; \ ++ for flg in $$sane_makeflags; do \ ++ test $$skip_next = yes && { skip_next=no; continue; }; \ ++ case $$flg in \ ++ *=*|--*) continue;; \ ++ -*I) strip_trailopt 'I'; skip_next=yes;; \ ++ -*I?*) strip_trailopt 'I';; \ ++ -*O) strip_trailopt 'O'; skip_next=yes;; \ ++ -*O?*) strip_trailopt 'O';; \ ++ -*l) strip_trailopt 'l'; skip_next=yes;; \ ++ -*l?*) strip_trailopt 'l';; \ ++ -[dEDm]) skip_next=yes;; \ ++ -[JT]) skip_next=yes;; \ ++ esac; \ ++ case $$flg in \ ++ *$$target_option*) has_opt=yes; break;; \ ++ esac; \ ++ done; \ ++ test $$has_opt = yes ++am__make_dryrun = (target_option=n; $(am__make_running_with_option)) ++am__make_keepgoing = (target_option=k; $(am__make_running_with_option)) ++pkgdatadir = $(datadir)/@PACKAGE@ ++pkgincludedir = $(includedir)/@PACKAGE@ ++pkglibdir = $(libdir)/@PACKAGE@ ++pkglibexecdir = $(libexecdir)/@PACKAGE@ ++am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd ++install_sh_DATA = $(install_sh) -c -m 644 ++install_sh_PROGRAM = $(install_sh) -c ++install_sh_SCRIPT = $(install_sh) -c ++INSTALL_HEADER = $(INSTALL_DATA) ++transform = $(program_transform_name) ++NORMAL_INSTALL = : ++PRE_INSTALL = : ++POST_INSTALL = : ++NORMAL_UNINSTALL = : ++PRE_UNINSTALL = : ++POST_UNINSTALL = : ++build_triplet = @build@ ++host_triplet = @host@ ++check_PROGRAMS = json_process$(EXEEXT) ++subdir = test/bin ++ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 ++am__aclocal_m4_deps = $(top_srcdir)/configure.ac ++am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ ++ $(ACLOCAL_M4) ++DIST_COMMON = $(srcdir)/Makefile.am $(am__DIST_COMMON) ++mkinstalldirs = $(install_sh) -d ++CONFIG_HEADER = $(top_builddir)/jansson_private_config.h ++CONFIG_CLEAN_FILES = ++CONFIG_CLEAN_VPATH_FILES = ++json_process_SOURCES = json_process.c ++json_process_OBJECTS = json_process.$(OBJEXT) ++json_process_LDADD = $(LDADD) ++json_process_DEPENDENCIES = $(top_builddir)/src/libjansson.la ++AM_V_lt = $(am__v_lt_@AM_V@) ++am__v_lt_ = $(am__v_lt_@AM_DEFAULT_V@) ++am__v_lt_0 = --silent ++am__v_lt_1 = ++AM_V_P = $(am__v_P_@AM_V@) ++am__v_P_ = $(am__v_P_@AM_DEFAULT_V@) ++am__v_P_0 = false ++am__v_P_1 = : ++AM_V_GEN = $(am__v_GEN_@AM_V@) ++am__v_GEN_ = $(am__v_GEN_@AM_DEFAULT_V@) ++am__v_GEN_0 = @echo " GEN " $@; ++am__v_GEN_1 = ++AM_V_at = $(am__v_at_@AM_V@) ++am__v_at_ = $(am__v_at_@AM_DEFAULT_V@) ++am__v_at_0 = @ ++am__v_at_1 = ++DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) ++depcomp = $(SHELL) $(top_srcdir)/depcomp ++am__maybe_remake_depfiles = depfiles ++am__depfiles_remade = ./$(DEPDIR)/json_process.Po ++am__mv = mv -f ++COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ ++ $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) ++LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ ++ $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ ++ $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ ++ $(AM_CFLAGS) $(CFLAGS) ++AM_V_CC = $(am__v_CC_@AM_V@) ++am__v_CC_ = $(am__v_CC_@AM_DEFAULT_V@) ++am__v_CC_0 = @echo " CC " $@; ++am__v_CC_1 = ++CCLD = $(CC) ++LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ ++ $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ ++ $(AM_LDFLAGS) $(LDFLAGS) -o $@ ++AM_V_CCLD = $(am__v_CCLD_@AM_V@) ++am__v_CCLD_ = $(am__v_CCLD_@AM_DEFAULT_V@) ++am__v_CCLD_0 = @echo " CCLD " $@; ++am__v_CCLD_1 = ++SOURCES = json_process.c ++DIST_SOURCES = json_process.c ++am__can_run_installinfo = \ ++ case $$AM_UPDATE_INFO_DIR in \ ++ n|no|NO) false;; \ ++ *) (install-info --version) >/dev/null 2>&1;; \ ++ esac ++am__tagged_files = $(HEADERS) $(SOURCES) $(TAGS_FILES) $(LISP) ++# Read a list of newline-separated strings from the standard input, ++# and print each of them once, without duplicates. Input order is ++# *not* preserved. ++am__uniquify_input = $(AWK) '\ ++ BEGIN { nonempty = 0; } \ ++ { items[$$0] = 1; nonempty = 1; } \ ++ END { if (nonempty) { for (i in items) print i; }; } \ ++' ++# Make sure the list of sources is unique. This is necessary because, ++# e.g., the same source file might be shared among _SOURCES variables ++# for different programs/libraries. ++am__define_uniq_tagged_files = \ ++ list='$(am__tagged_files)'; \ ++ unique=`for i in $$list; do \ ++ if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ ++ done | $(am__uniquify_input)` ++ETAGS = etags ++CTAGS = ctags ++am__DIST_COMMON = $(srcdir)/Makefile.in $(top_srcdir)/depcomp ++DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) ++ACLOCAL = @ACLOCAL@ ++AMTAR = @AMTAR@ ++AM_CFLAGS = @AM_CFLAGS@ ++AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ ++AR = @AR@ ++AUTOCONF = @AUTOCONF@ ++AUTOHEADER = @AUTOHEADER@ ++AUTOMAKE = @AUTOMAKE@ ++AWK = @AWK@ ++CC = @CC@ ++CCDEPMODE = @CCDEPMODE@ ++CFLAGS = @CFLAGS@ ++CPP = @CPP@ ++CPPFLAGS = @CPPFLAGS@ ++CYGPATH_W = @CYGPATH_W@ ++DEFS = @DEFS@ ++DEPDIR = @DEPDIR@ ++DLLTOOL = @DLLTOOL@ ++DSYMUTIL = @DSYMUTIL@ ++DUMPBIN = @DUMPBIN@ ++ECHO_C = @ECHO_C@ ++ECHO_N = @ECHO_N@ ++ECHO_T = @ECHO_T@ ++EGREP = @EGREP@ ++EXEEXT = @EXEEXT@ ++FGREP = @FGREP@ ++GREP = @GREP@ ++INSTALL = @INSTALL@ ++INSTALL_DATA = @INSTALL_DATA@ ++INSTALL_PROGRAM = @INSTALL_PROGRAM@ ++INSTALL_SCRIPT = @INSTALL_SCRIPT@ ++INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ ++JSON_BSYMBOLIC_LDFLAGS = @JSON_BSYMBOLIC_LDFLAGS@ ++LD = @LD@ ++LDFLAGS = -static # for speed and Valgrind ++LIBOBJS = @LIBOBJS@ ++LIBS = @LIBS@ ++LIBTOOL = @LIBTOOL@ ++LIPO = @LIPO@ ++LN_S = @LN_S@ ++LTLIBOBJS = @LTLIBOBJS@ ++LT_SYS_LIBRARY_PATH = @LT_SYS_LIBRARY_PATH@ ++MAKEINFO = @MAKEINFO@ ++MANIFEST_TOOL = @MANIFEST_TOOL@ ++MKDIR_P = @MKDIR_P@ ++NM = @NM@ ++NMEDIT = @NMEDIT@ ++OBJDUMP = @OBJDUMP@ ++OBJEXT = @OBJEXT@ ++OTOOL = @OTOOL@ ++OTOOL64 = @OTOOL64@ ++PACKAGE = @PACKAGE@ ++PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ ++PACKAGE_NAME = @PACKAGE_NAME@ ++PACKAGE_STRING = @PACKAGE_STRING@ ++PACKAGE_TARNAME = @PACKAGE_TARNAME@ ++PACKAGE_URL = @PACKAGE_URL@ ++PACKAGE_VERSION = @PACKAGE_VERSION@ ++PATH_SEPARATOR = @PATH_SEPARATOR@ ++RANLIB = @RANLIB@ ++SED = @SED@ ++SET_MAKE = @SET_MAKE@ ++SHELL = @SHELL@ ++STRIP = @STRIP@ ++VERSION = @VERSION@ ++abs_builddir = @abs_builddir@ ++abs_srcdir = @abs_srcdir@ ++abs_top_builddir = @abs_top_builddir@ ++abs_top_srcdir = @abs_top_srcdir@ ++ac_ct_AR = @ac_ct_AR@ ++ac_ct_CC = @ac_ct_CC@ ++ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ ++am__include = @am__include@ ++am__leading_dot = @am__leading_dot@ ++am__quote = @am__quote@ ++am__tar = @am__tar@ ++am__untar = @am__untar@ ++bindir = @bindir@ ++build = @build@ ++build_alias = @build_alias@ ++build_cpu = @build_cpu@ ++build_os = @build_os@ ++build_vendor = @build_vendor@ ++builddir = @builddir@ ++datadir = @datadir@ ++datarootdir = @datarootdir@ ++docdir = @docdir@ ++dvidir = @dvidir@ ++exec_prefix = @exec_prefix@ ++host = @host@ ++host_alias = @host_alias@ ++host_cpu = @host_cpu@ ++host_os = @host_os@ ++host_vendor = @host_vendor@ ++htmldir = @htmldir@ ++includedir = @includedir@ ++infodir = @infodir@ ++install_sh = @install_sh@ ++json_have_atomic_builtins = @json_have_atomic_builtins@ ++json_have_localeconv = @json_have_localeconv@ ++json_have_long_long = @json_have_long_long@ ++json_have_sync_builtins = @json_have_sync_builtins@ ++json_inline = @json_inline@ ++libdir = @libdir@ ++libexecdir = @libexecdir@ ++localedir = @localedir@ ++localstatedir = @localstatedir@ ++mandir = @mandir@ ++mkdir_p = @mkdir_p@ ++oldincludedir = @oldincludedir@ ++pdfdir = @pdfdir@ ++prefix = @prefix@ ++program_transform_name = @program_transform_name@ ++psdir = @psdir@ ++sbindir = @sbindir@ ++sharedstatedir = @sharedstatedir@ ++srcdir = @srcdir@ ++sysconfdir = @sysconfdir@ ++target_alias = @target_alias@ ++top_build_prefix = @top_build_prefix@ ++top_builddir = @top_builddir@ ++top_srcdir = @top_srcdir@ ++AM_CPPFLAGS = -I$(top_builddir)/src -I$(top_srcdir)/src ++LDADD = $(top_builddir)/src/libjansson.la ++all: all-am ++ ++.SUFFIXES: ++.SUFFIXES: .c .lo .o .obj ++$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps) ++ @for dep in $?; do \ ++ case '$(am__configure_deps)' in \ ++ *$$dep*) \ ++ ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ ++ && { if test -f $@; then exit 0; else break; fi; }; \ ++ exit 1;; \ ++ esac; \ ++ done; \ ++ echo ' cd $(top_srcdir) && $(AUTOMAKE) --foreign test/bin/Makefile'; \ ++ $(am__cd) $(top_srcdir) && \ ++ $(AUTOMAKE) --foreign test/bin/Makefile ++Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status ++ @case '$?' in \ ++ *config.status*) \ ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ ++ *) \ ++ echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles)'; \ ++ cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__maybe_remake_depfiles);; \ ++ esac; ++ ++$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++ ++$(top_srcdir)/configure: $(am__configure_deps) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++$(ACLOCAL_M4): $(am__aclocal_m4_deps) ++ cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ++$(am__aclocal_m4_deps): ++ ++clean-checkPROGRAMS: ++ @list='$(check_PROGRAMS)'; test -n "$$list" || exit 0; \ ++ echo " rm -f" $$list; \ ++ rm -f $$list || exit $$?; \ ++ test -n "$(EXEEXT)" || exit 0; \ ++ list=`for p in $$list; do echo "$$p"; done | sed 's/$(EXEEXT)$$//'`; \ ++ echo " rm -f" $$list; \ ++ rm -f $$list ++ ++json_process$(EXEEXT): $(json_process_OBJECTS) $(json_process_DEPENDENCIES) $(EXTRA_json_process_DEPENDENCIES) ++ @rm -f json_process$(EXEEXT) ++ $(AM_V_CCLD)$(LINK) $(json_process_OBJECTS) $(json_process_LDADD) $(LIBS) ++ ++mostlyclean-compile: ++ -rm -f *.$(OBJEXT) ++ ++distclean-compile: ++ -rm -f *.tab.c ++ ++@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/json_process.Po@am__quote@ # am--include-marker ++ ++$(am__depfiles_remade): ++ @$(MKDIR_P) $(@D) ++ @echo '# dummy' >$@-t && $(am__mv) $@-t $@ ++ ++am--depfiles: $(am__depfiles_remade) ++ ++.c.o: ++@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< ++@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ ++@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ $< ++ ++.c.obj: ++@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` ++@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ ++@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(COMPILE) -c -o $@ `$(CYGPATH_W) '$<'` ++ ++.c.lo: ++@am__fastdepCC_TRUE@ $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< ++@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ $(AM_V_CC)source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ ++@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ ++@am__fastdepCC_FALSE@ $(AM_V_CC@am__nodep@)$(LTCOMPILE) -c -o $@ $< ++ ++mostlyclean-libtool: ++ -rm -f *.lo ++ ++clean-libtool: ++ -rm -rf .libs _libs ++ ++ID: $(am__tagged_files) ++ $(am__define_uniq_tagged_files); mkid -fID $$unique ++tags: tags-am ++TAGS: tags ++ ++tags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) ++ set x; \ ++ here=`pwd`; \ ++ $(am__define_uniq_tagged_files); \ ++ shift; \ ++ if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ ++ test -n "$$unique" || unique=$$empty_fix; \ ++ if test $$# -gt 0; then \ ++ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ ++ "$$@" $$unique; \ ++ else \ ++ $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ ++ $$unique; \ ++ fi; \ ++ fi ++ctags: ctags-am ++ ++CTAGS: ctags ++ctags-am: $(TAGS_DEPENDENCIES) $(am__tagged_files) ++ $(am__define_uniq_tagged_files); \ ++ test -z "$(CTAGS_ARGS)$$unique" \ ++ || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ ++ $$unique ++ ++GTAGS: ++ here=`$(am__cd) $(top_builddir) && pwd` \ ++ && $(am__cd) $(top_srcdir) \ ++ && gtags -i $(GTAGS_ARGS) "$$here" ++cscopelist: cscopelist-am ++ ++cscopelist-am: $(am__tagged_files) ++ list='$(am__tagged_files)'; \ ++ case "$(srcdir)" in \ ++ [\\/]* | ?:[\\/]*) sdir="$(srcdir)" ;; \ ++ *) sdir=$(subdir)/$(srcdir) ;; \ ++ esac; \ ++ for i in $$list; do \ ++ if test -f "$$i"; then \ ++ echo "$(subdir)/$$i"; \ ++ else \ ++ echo "$$sdir/$$i"; \ ++ fi; \ ++ done >> $(top_builddir)/cscope.files ++ ++distclean-tags: ++ -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags ++ ++distdir: $(BUILT_SOURCES) ++ $(MAKE) $(AM_MAKEFLAGS) distdir-am ++ ++distdir-am: $(DISTFILES) ++ @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ ++ topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ ++ list='$(DISTFILES)'; \ ++ dist_files=`for file in $$list; do echo $$file; done | \ ++ sed -e "s|^$$srcdirstrip/||;t" \ ++ -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ ++ case $$dist_files in \ ++ */*) $(MKDIR_P) `echo "$$dist_files" | \ ++ sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ ++ sort -u` ;; \ ++ esac; \ ++ for file in $$dist_files; do \ ++ if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ ++ if test -d $$d/$$file; then \ ++ dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ ++ if test -d "$(distdir)/$$file"; then \ ++ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ ++ fi; \ ++ if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ ++ cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ ++ find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ ++ fi; \ ++ cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ ++ else \ ++ test -f "$(distdir)/$$file" \ ++ || cp -p $$d/$$file "$(distdir)/$$file" \ ++ || exit 1; \ ++ fi; \ ++ done ++check-am: all-am ++ $(MAKE) $(AM_MAKEFLAGS) $(check_PROGRAMS) ++check: check-am ++all-am: Makefile ++installdirs: ++install: install-am ++install-exec: install-exec-am ++install-data: install-data-am ++uninstall: uninstall-am ++ ++install-am: all-am ++ @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am ++ ++installcheck: installcheck-am ++install-strip: ++ if test -z '$(STRIP)'; then \ ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ ++ install; \ ++ else \ ++ $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ ++ install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ ++ "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'" install; \ ++ fi ++mostlyclean-generic: ++ ++clean-generic: ++ ++distclean-generic: ++ -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) ++ -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) ++ ++maintainer-clean-generic: ++ @echo "This command is intended for maintainers to use" ++ @echo "it deletes files that may require special tools to rebuild." ++clean: clean-am ++ ++clean-am: clean-checkPROGRAMS clean-generic clean-libtool \ ++ mostlyclean-am ++ ++distclean: distclean-am ++ -rm -f ./$(DEPDIR)/json_process.Po ++ -rm -f Makefile ++distclean-am: clean-am distclean-compile distclean-generic \ ++ distclean-tags ++ ++dvi: dvi-am ++ ++dvi-am: ++ ++html: html-am ++ ++html-am: ++ ++info: info-am ++ ++info-am: ++ ++install-data-am: ++ ++install-dvi: install-dvi-am ++ ++install-dvi-am: ++ ++install-exec-am: ++ ++install-html: install-html-am ++ ++install-html-am: ++ ++install-info: install-info-am ++ ++install-info-am: ++ ++install-man: ++ ++install-pdf: install-pdf-am ++ ++install-pdf-am: ++ ++install-ps: install-ps-am ++ ++install-ps-am: ++ ++installcheck-am: ++ ++maintainer-clean: maintainer-clean-am ++ -rm -f ./$(DEPDIR)/json_process.Po ++ -rm -f Makefile ++maintainer-clean-am: distclean-am maintainer-clean-generic ++ ++mostlyclean: mostlyclean-am ++ ++mostlyclean-am: mostlyclean-compile mostlyclean-generic \ ++ mostlyclean-libtool ++ ++pdf: pdf-am ++ ++pdf-am: ++ ++ps: ps-am ++ ++ps-am: ++ ++uninstall-am: ++ ++.MAKE: check-am install-am install-strip ++ ++.PHONY: CTAGS GTAGS TAGS all all-am am--depfiles check check-am clean \ ++ clean-checkPROGRAMS clean-generic clean-libtool cscopelist-am \ ++ ctags ctags-am distclean distclean-compile distclean-generic \ ++ distclean-libtool distclean-tags distdir dvi dvi-am html \ ++ html-am info info-am install install-am install-data \ ++ install-data-am install-dvi install-dvi-am install-exec \ ++ install-exec-am install-html install-html-am install-info \ ++ install-info-am install-man install-pdf install-pdf-am \ ++ install-ps install-ps-am install-strip installcheck \ ++ installcheck-am installdirs maintainer-clean \ ++ maintainer-clean-generic mostlyclean mostlyclean-compile \ ++ mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \ ++ tags tags-am uninstall uninstall-am ++ ++.PRECIOUS: Makefile ++ ++ ++# Tell versions [3.59,3.63) of GNU make to not export all variables. ++# Otherwise a system limit (for SysV at least) may be exceeded. ++.NOEXPORT: +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/jansson-2.12/test/bin/json_process.c +@@ -0,0 +1,385 @@ ++/* ++ * Copyright (c) 2009-2016 Petri Lehtinen ++ * ++ * Jansson is free software; you can redistribute it and/or modify ++ * it under the terms of the MIT license. See LICENSE for details. ++ */ ++ ++#ifdef HAVE_CONFIG_H ++#include ++#endif ++ ++#include ++#include ++#include ++#include ++#include ++ ++#ifdef HAVE_LOCALE_H ++#include ++ #endif ++ ++#if _WIN32 ++#include /* for _setmode() */ ++#include /* for _O_BINARY */ ++ ++static const char dir_sep = '\\'; ++#else ++static const char dir_sep = '/'; ++#endif ++ ++ ++struct config { ++ int indent; ++ int compact; ++ int preserve_order; ++ int ensure_ascii; ++ int sort_keys; ++ int strip; ++ int use_env; ++ int have_hashseed; ++ int hashseed; ++ int precision; ++} conf; ++ ++#define l_isspace(c) ((c) == ' ' || (c) == '\n' || (c) == '\r' || (c) == '\t') ++ ++/* Return a pointer to the first non-whitespace character of str. ++ Modifies str so that all trailing whitespace characters are ++ replaced by '\0'. */ ++static const char *strip(char *str) ++{ ++ size_t length; ++ char *result = str; ++ while (*result && l_isspace(*result)) ++ result++; ++ ++ length = strlen(result); ++ if (length == 0) ++ return result; ++ ++ while (l_isspace(result[length - 1])) ++ result[--length] = '\0'; ++ ++ return result; ++} ++ ++ ++static char *loadfile(FILE *file) ++{ ++ long fsize, ret; ++ char *buf; ++ ++ fseek(file, 0, SEEK_END); ++ fsize = ftell(file); ++ fseek(file, 0, SEEK_SET); ++ ++ buf = malloc(fsize+1); ++ ret = fread(buf, 1, fsize, file); ++ if (ret != fsize) ++ exit(1); ++ buf[fsize] = '\0'; ++ ++ return buf; ++} ++ ++ ++static void read_conf(FILE *conffile) ++{ ++ char *buffer, *line, *val; ++ ++ buffer = loadfile(conffile); ++ for (line = strtok(buffer, "\r\n"); line; line = strtok(NULL, "\r\n")) { ++ if (!strncmp(line, "export ", 7)) ++ continue; ++ val = strchr(line, '='); ++ if (!val) { ++ printf("invalid configuration line\n"); ++ break; ++ } ++ *val++ = '\0'; ++ ++ if (!strcmp(line, "JSON_INDENT")) ++ conf.indent = atoi(val); ++ if (!strcmp(line, "JSON_COMPACT")) ++ conf.compact = atoi(val); ++ if (!strcmp(line, "JSON_ENSURE_ASCII")) ++ conf.ensure_ascii = atoi(val); ++ if (!strcmp(line, "JSON_PRESERVE_ORDER")) ++ conf.preserve_order = atoi(val); ++ if (!strcmp(line, "JSON_SORT_KEYS")) ++ conf.sort_keys = atoi(val); ++ if (!strcmp(line, "JSON_REAL_PRECISION")) ++ conf.precision = atoi(val); ++ if (!strcmp(line, "STRIP")) ++ conf.strip = atoi(val); ++ if (!strcmp(line, "HASHSEED")) { ++ conf.have_hashseed = 1; ++ conf.hashseed = atoi(val); ++ } else { ++ conf.have_hashseed = 0; ++ } ++ } ++ ++ free(buffer); ++} ++ ++ ++static int cmpfile(const char *str, const char *path, const char *fname) ++{ ++ char filename[1024], *buffer; ++ int ret; ++ FILE *file; ++ ++ sprintf(filename, "%s%c%s", path, dir_sep, fname); ++ file = fopen(filename, "rb"); ++ if (!file) { ++ if (conf.strip) ++ strcat(filename, ".strip"); ++ else ++ strcat(filename, ".normal"); ++ file = fopen(filename, "rb"); ++ } ++ if (!file) { ++ printf("Error: test result file could not be opened.\n"); ++ exit(1); ++ } ++ ++ buffer = loadfile(file); ++ if (strcmp(buffer, str) != 0) ++ ret = 1; ++ else ++ ret = 0; ++ free(buffer); ++ fclose(file); ++ ++ return ret; ++} ++ ++int use_conf(char *test_path) ++{ ++ int ret; ++ size_t flags = 0; ++ char filename[1024], errstr[1024]; ++ char *buffer; ++ FILE *infile, *conffile; ++ json_t *json; ++ json_error_t error; ++ ++ sprintf(filename, "%s%cinput", test_path, dir_sep); ++ if (!(infile = fopen(filename, "rb"))) { ++ fprintf(stderr, "Could not open \"%s\"\n", filename); ++ return 2; ++ } ++ ++ sprintf(filename, "%s%cenv", test_path, dir_sep); ++ conffile = fopen(filename, "rb"); ++ if (conffile) { ++ read_conf(conffile); ++ fclose(conffile); ++ } ++ ++ if (conf.indent < 0 || conf.indent > 31) { ++ fprintf(stderr, "invalid value for JSON_INDENT: %d\n", conf.indent); ++ fclose(infile); ++ return 2; ++ } ++ if (conf.indent) ++ flags |= JSON_INDENT(conf.indent); ++ ++ if (conf.compact) ++ flags |= JSON_COMPACT; ++ ++ if (conf.ensure_ascii) ++ flags |= JSON_ENSURE_ASCII; ++ ++ if (conf.preserve_order) ++ flags |= JSON_PRESERVE_ORDER; ++ ++ if (conf.sort_keys) ++ flags |= JSON_SORT_KEYS; ++ ++ if (conf.precision < 0 || conf.precision > 31) { ++ fprintf(stderr, "invalid value for JSON_REAL_PRECISION: %d\n", ++ conf.precision); ++ fclose(infile); ++ return 2; ++ } ++ if (conf.precision) ++ flags |= JSON_REAL_PRECISION(conf.precision); ++ ++ if (conf.have_hashseed) ++ json_object_seed(conf.hashseed); ++ ++ if (conf.strip) { ++ /* Load to memory, strip leading and trailing whitespace */ ++ buffer = loadfile(infile); ++ json = json_loads(strip(buffer), 0, &error); ++ free(buffer); ++ } ++ else ++ json = json_loadf(infile, 0, &error); ++ ++ fclose(infile); ++ ++ if (!json) { ++ sprintf(errstr, "%d %d %d\n%s\n", ++ error.line, error.column, error.position, ++ error.text); ++ ++ ret = cmpfile(errstr, test_path, "error"); ++ return ret; ++ } ++ ++ buffer = json_dumps(json, flags); ++ ret = cmpfile(buffer, test_path, "output"); ++ free(buffer); ++ json_decref(json); ++ ++ return ret; ++} ++ ++static int getenv_int(const char *name) ++{ ++ char *value, *end; ++ long result; ++ ++ value = getenv(name); ++ if(!value) ++ return 0; ++ ++ result = strtol(value, &end, 10); ++ if(*end != '\0') ++ return 0; ++ ++ return (int)result; ++} ++ ++int use_env() ++{ ++ int indent, precision; ++ size_t flags = 0; ++ json_t *json; ++ json_error_t error; ++ ++ #ifdef _WIN32 ++ /* On Windows, set stdout and stderr to binary mode to avoid ++ outputting DOS line terminators */ ++ _setmode(_fileno(stdout), _O_BINARY); ++ _setmode(_fileno(stderr), _O_BINARY); ++ #endif ++ ++ indent = getenv_int("JSON_INDENT"); ++ if(indent < 0 || indent > 31) { ++ fprintf(stderr, "invalid value for JSON_INDENT: %d\n", indent); ++ return 2; ++ } ++ if(indent > 0) ++ flags |= JSON_INDENT(indent); ++ ++ if(getenv_int("JSON_COMPACT") > 0) ++ flags |= JSON_COMPACT; ++ ++ if(getenv_int("JSON_ENSURE_ASCII")) ++ flags |= JSON_ENSURE_ASCII; ++ ++ if(getenv_int("JSON_PRESERVE_ORDER")) ++ flags |= JSON_PRESERVE_ORDER; ++ ++ if(getenv_int("JSON_SORT_KEYS")) ++ flags |= JSON_SORT_KEYS; ++ ++ precision = getenv_int("JSON_REAL_PRECISION"); ++ if(precision < 0 || precision > 31) { ++ fprintf(stderr, "invalid value for JSON_REAL_PRECISION: %d\n", ++ precision); ++ return 2; ++ } ++ ++ if(getenv("HASHSEED")) ++ json_object_seed(getenv_int("HASHSEED")); ++ ++ if(precision > 0) ++ flags |= JSON_REAL_PRECISION(precision); ++ ++ if(getenv_int("STRIP")) { ++ /* Load to memory, strip leading and trailing whitespace */ ++ size_t size = 0, used = 0; ++ char *buffer = NULL, *buf_ck = NULL; ++ ++ while(1) { ++ size_t count; ++ ++ size = (size == 0 ? 128 : size * 2); ++ buf_ck = realloc(buffer, size); ++ if(!buf_ck) { ++ fprintf(stderr, "Unable to allocate %d bytes\n", (int)size); ++ free(buffer); ++ return 1; ++ } ++ buffer = buf_ck; ++ ++ count = fread(buffer + used, 1, size - used, stdin); ++ if(count < size - used) { ++ buffer[used + count] = '\0'; ++ break; ++ } ++ used += count; ++ } ++ ++ json = json_loads(strip(buffer), 0, &error); ++ free(buffer); ++ } ++ else ++ json = json_loadf(stdin, 0, &error); ++ ++ if(!json) { ++ fprintf(stderr, "%d %d %d\n%s\n", ++ error.line, error.column, ++ error.position, error.text); ++ return 1; ++ } ++ ++ json_dumpf(json, stdout, flags); ++ json_decref(json); ++ ++ return 0; ++} ++ ++int main(int argc, char *argv[]) ++{ ++ int i; ++ char *test_path = NULL; ++ ++ #ifdef HAVE_SETLOCALE ++ setlocale(LC_ALL, ""); ++ #endif ++ ++ if (argc < 2) { ++ goto usage; ++ } ++ ++ for (i = 1; i < argc; i++) { ++ if (!strcmp(argv[i], "--strip")) ++ conf.strip = 1; ++ else if (!strcmp(argv[i], "--env")) ++ conf.use_env = 1; ++ else ++ test_path = argv[i]; ++ } ++ ++ if (conf.use_env) ++ return use_env(); ++ else ++ { ++ if (!test_path) ++ goto usage; ++ ++ return use_conf(test_path); ++ } ++ ++usage: ++ fprintf(stderr, "argc =%d\n", argc); ++ fprintf(stderr, "usage: %s [--strip] [--env] test_dir\n", argv[0]); ++ return 2; ++} +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/ax_append_compile_flags.m4 +@@ -0,0 +1,67 @@ ++# =========================================================================== ++# http://www.gnu.org/software/autoconf-archive/ax_append_compile_flags.html ++# =========================================================================== ++# ++# SYNOPSIS ++# ++# AX_APPEND_COMPILE_FLAGS([FLAG1 FLAG2 ...], [FLAGS-VARIABLE], [EXTRA-FLAGS], [INPUT]) ++# ++# DESCRIPTION ++# ++# For every FLAG1, FLAG2 it is checked whether the compiler works with the ++# flag. If it does, the flag is added FLAGS-VARIABLE ++# ++# If FLAGS-VARIABLE is not specified, the current language's flags (e.g. ++# CFLAGS) is used. During the check the flag is always added to the ++# current language's flags. ++# ++# If EXTRA-FLAGS is defined, it is added to the current language's default ++# flags (e.g. CFLAGS) when the check is done. The check is thus made with ++# the flags: "CFLAGS EXTRA-FLAGS FLAG". This can for example be used to ++# force the compiler to issue an error when a bad flag is given. ++# ++# INPUT gives an alternative input source to AC_COMPILE_IFELSE. ++# ++# NOTE: This macro depends on the AX_APPEND_FLAG and ++# AX_CHECK_COMPILE_FLAG. Please keep this macro in sync with ++# AX_APPEND_LINK_FLAGS. ++# ++# LICENSE ++# ++# Copyright (c) 2011 Maarten Bosmans ++# ++# 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 . ++# ++# As a special exception, the respective Autoconf Macro's copyright owner ++# gives unlimited permission to copy, distribute and modify the configure ++# scripts that are the output of Autoconf when processing the Macro. You ++# need not follow the terms of the GNU General Public License when using ++# or distributing such scripts, even though portions of the text of the ++# Macro appear in them. The GNU General Public License (GPL) does govern ++# all other use of the material that constitutes the Autoconf Macro. ++# ++# This special exception to the GPL applies to versions of the Autoconf ++# Macro released by the Autoconf Archive. When you make and distribute a ++# modified version of the Autoconf Macro, you may extend this special ++# exception to the GPL to apply to your modified version as well. ++ ++#serial 5 ++ ++AC_DEFUN([AX_APPEND_COMPILE_FLAGS], ++[AX_REQUIRE_DEFINED([AX_CHECK_COMPILE_FLAG]) ++AX_REQUIRE_DEFINED([AX_APPEND_FLAG]) ++for flag in $1; do ++ AX_CHECK_COMPILE_FLAG([$flag], [AX_APPEND_FLAG([$flag], [$2])], [], [$3], [$4]) ++done ++])dnl AX_APPEND_COMPILE_FLAGS +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/ax_append_flag.m4 +@@ -0,0 +1,71 @@ ++# =========================================================================== ++# http://www.gnu.org/software/autoconf-archive/ax_append_flag.html ++# =========================================================================== ++# ++# SYNOPSIS ++# ++# AX_APPEND_FLAG(FLAG, [FLAGS-VARIABLE]) ++# ++# DESCRIPTION ++# ++# FLAG is appended to the FLAGS-VARIABLE shell variable, with a space ++# added in between. ++# ++# If FLAGS-VARIABLE is not specified, the current language's flags (e.g. ++# CFLAGS) is used. FLAGS-VARIABLE is not changed if it already contains ++# FLAG. If FLAGS-VARIABLE is unset in the shell, it is set to exactly ++# FLAG. ++# ++# NOTE: Implementation based on AX_CFLAGS_GCC_OPTION. ++# ++# LICENSE ++# ++# Copyright (c) 2008 Guido U. Draheim ++# Copyright (c) 2011 Maarten Bosmans ++# ++# 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 . ++# ++# As a special exception, the respective Autoconf Macro's copyright owner ++# gives unlimited permission to copy, distribute and modify the configure ++# scripts that are the output of Autoconf when processing the Macro. You ++# need not follow the terms of the GNU General Public License when using ++# or distributing such scripts, even though portions of the text of the ++# Macro appear in them. The GNU General Public License (GPL) does govern ++# all other use of the material that constitutes the Autoconf Macro. ++# ++# This special exception to the GPL applies to versions of the Autoconf ++# Macro released by the Autoconf Archive. When you make and distribute a ++# modified version of the Autoconf Macro, you may extend this special ++# exception to the GPL to apply to your modified version as well. ++ ++#serial 6 ++ ++AC_DEFUN([AX_APPEND_FLAG], ++[dnl ++AC_PREREQ(2.64)dnl for _AC_LANG_PREFIX and AS_VAR_SET_IF ++AS_VAR_PUSHDEF([FLAGS], [m4_default($2,_AC_LANG_PREFIX[FLAGS])]) ++AS_VAR_SET_IF(FLAGS,[ ++ AS_CASE([" AS_VAR_GET(FLAGS) "], ++ [*" $1 "*], [AC_RUN_LOG([: FLAGS already contains $1])], ++ [ ++ AS_VAR_APPEND(FLAGS,[" $1"]) ++ AC_RUN_LOG([: FLAGS="$FLAGS"]) ++ ]) ++ ], ++ [ ++ AS_VAR_SET(FLAGS,[$1]) ++ AC_RUN_LOG([: FLAGS="$FLAGS"]) ++ ]) ++AS_VAR_POPDEF([FLAGS])dnl ++])dnl AX_APPEND_FLAG +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/ax_check_compile_flag.m4 +@@ -0,0 +1,74 @@ ++# =========================================================================== ++# http://www.gnu.org/software/autoconf-archive/ax_check_compile_flag.html ++# =========================================================================== ++# ++# SYNOPSIS ++# ++# AX_CHECK_COMPILE_FLAG(FLAG, [ACTION-SUCCESS], [ACTION-FAILURE], [EXTRA-FLAGS], [INPUT]) ++# ++# DESCRIPTION ++# ++# Check whether the given FLAG works with the current language's compiler ++# or gives an error. (Warnings, however, are ignored) ++# ++# ACTION-SUCCESS/ACTION-FAILURE are shell commands to execute on ++# success/failure. ++# ++# If EXTRA-FLAGS is defined, it is added to the current language's default ++# flags (e.g. CFLAGS) when the check is done. The check is thus made with ++# the flags: "CFLAGS EXTRA-FLAGS FLAG". This can for example be used to ++# force the compiler to issue an error when a bad flag is given. ++# ++# INPUT gives an alternative input source to AC_COMPILE_IFELSE. ++# ++# NOTE: Implementation based on AX_CFLAGS_GCC_OPTION. Please keep this ++# macro in sync with AX_CHECK_{PREPROC,LINK}_FLAG. ++# ++# LICENSE ++# ++# Copyright (c) 2008 Guido U. Draheim ++# Copyright (c) 2011 Maarten Bosmans ++# ++# 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 . ++# ++# As a special exception, the respective Autoconf Macro's copyright owner ++# gives unlimited permission to copy, distribute and modify the configure ++# scripts that are the output of Autoconf when processing the Macro. You ++# need not follow the terms of the GNU General Public License when using ++# or distributing such scripts, even though portions of the text of the ++# Macro appear in them. The GNU General Public License (GPL) does govern ++# all other use of the material that constitutes the Autoconf Macro. ++# ++# This special exception to the GPL applies to versions of the Autoconf ++# Macro released by the Autoconf Archive. When you make and distribute a ++# modified version of the Autoconf Macro, you may extend this special ++# exception to the GPL to apply to your modified version as well. ++ ++#serial 4 ++ ++AC_DEFUN([AX_CHECK_COMPILE_FLAG], ++[AC_PREREQ(2.64)dnl for _AC_LANG_PREFIX and AS_VAR_IF ++AS_VAR_PUSHDEF([CACHEVAR],[ax_cv_check_[]_AC_LANG_ABBREV[]flags_$4_$1])dnl ++AC_CACHE_CHECK([whether _AC_LANG compiler accepts $1], CACHEVAR, [ ++ ax_check_save_flags=$[]_AC_LANG_PREFIX[]FLAGS ++ _AC_LANG_PREFIX[]FLAGS="$[]_AC_LANG_PREFIX[]FLAGS $4 $1" ++ AC_COMPILE_IFELSE([m4_default([$5],[AC_LANG_PROGRAM()])], ++ [AS_VAR_SET(CACHEVAR,[yes])], ++ [AS_VAR_SET(CACHEVAR,[no])]) ++ _AC_LANG_PREFIX[]FLAGS=$ax_check_save_flags]) ++AS_VAR_IF(CACHEVAR,yes, ++ [m4_default([$2], :)], ++ [m4_default([$3], :)]) ++AS_VAR_POPDEF([CACHEVAR])dnl ++])dnl AX_CHECK_COMPILE_FLAGS +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/ax_require_defined.m4 +@@ -0,0 +1,37 @@ ++# =========================================================================== ++# http://www.gnu.org/software/autoconf-archive/ax_require_defined.html ++# =========================================================================== ++# ++# SYNOPSIS ++# ++# AX_REQUIRE_DEFINED(MACRO) ++# ++# DESCRIPTION ++# ++# AX_REQUIRE_DEFINED is a simple helper for making sure other macros have ++# been defined and thus are available for use. This avoids random issues ++# where a macro isn't expanded. Instead the configure script emits a ++# non-fatal: ++# ++# ./configure: line 1673: AX_CFLAGS_WARN_ALL: command not found ++# ++# It's like AC_REQUIRE except it doesn't expand the required macro. ++# ++# Here's an example: ++# ++# AX_REQUIRE_DEFINED([AX_CHECK_LINK_FLAG]) ++# ++# LICENSE ++# ++# Copyright (c) 2014 Mike Frysinger ++# ++# Copying and distribution of this file, with or without modification, are ++# permitted in any medium without royalty provided the copyright notice ++# and this notice are preserved. This file is offered as-is, without any ++# warranty. ++ ++#serial 1 ++ ++AC_DEFUN([AX_REQUIRE_DEFINED], [dnl ++ m4_ifndef([$1], [m4_fatal([macro ]$1[ is not defined; is a m4 file missing?])]) ++])dnl AX_REQUIRE_DEFINED +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/check_stdcall_func.m4 +@@ -0,0 +1,51 @@ ++# AC_LANG_STDCALL_FUNC_LINK_TRY(FUNCTION, SIGNATURE) ++# ------------------------------- ++# Produce a source which links correctly iff the FUNCTION exists. ++AC_DEFUN([AC_LANG_STDCALL_FUNC_LINK_TRY], ++[_AC_LANG_DISPATCH([$0], _AC_LANG, $@)]) ++ ++# AC_CHECK_STDCALL_FUNC(FUNCTION, SIGNATURE, [ACTION-IF-FOUND], [ACTION-IF-NOT-FOUND]) ++# ----------------------------------------------------------------- ++AC_DEFUN([AC_CHECK_STDCALL_FUNC], ++[AS_VAR_PUSHDEF([ac_var], [ac_cv_func_$1])dnl ++AC_CACHE_CHECK([for $1], ac_var, ++[AC_LINK_IFELSE([AC_LANG_STDCALL_FUNC_LINK_TRY([$1],[$2])], ++ [AS_VAR_SET(ac_var, yes)], ++ [AS_VAR_SET(ac_var, no)])]) ++AS_IF([test AS_VAR_GET(ac_var) = yes], [$3], [$4])dnl ++AS_VAR_POPDEF([ac_var])dnl ++])# AC_CHECK_FUNC ++ ++# AC_LANG_STDCALL_FUNC_LINK_TRY(C)(FUNCTION, SIGNATURE) ++# ---------------------------------- ++# Don't include because on OSF/1 3.0 it includes ++# which includes which contains a ++# prototype for select. Similarly for bzero. ++m4_define([AC_LANG_STDCALL_FUNC_LINK_TRY(C)], ++[AC_LANG_PROGRAM( ++[/* System header to define __stub macros and hopefully few prototypes, ++ which can conflict with char __stdcall $1 ( $2 ) below. */ ++#include ++/* Override any gcc2 internal prototype to avoid an error. */ ++#ifdef __cplusplus ++extern "C" ++#endif ++/* We use char because int might match the return type of a gcc2 ++ builtin and then its argument prototype would still apply. */ ++char __stdcall $1 ( $2 ); ++char (*f) ( $2 ); ++], ++[/* The GNU C library defines this for functions which it implements ++ to always fail with ENOSYS. Some functions are actually named ++ something starting with __ and the normal name is an alias. */ ++#if defined (__stub_$1) || defined (__stub___$1) ++choke me ++#else ++f = $1; ++#endif ++])]) ++ ++# AC_LANG_STDCALL_FUNC_LINK_TRY(C++)(FUNCTION) ++# ------------------------------------ ++m4_copy([AC_LANG_STDCALL_FUNC_LINK_TRY(C)], [AC_LANG_STDCALL_FUNC_LINK_TRY(C++)]) ++ +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/compile +@@ -0,0 +1,347 @@ ++#! /bin/sh ++# Wrapper for compilers which do not understand '-c -o'. ++ ++scriptversion=2012-10-14.11; # UTC ++ ++# Copyright (C) 1999-2014 Free Software Foundation, Inc. ++# Written by Tom Tromey . ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2, or (at your option) ++# any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++ ++# As a special exception to the GNU General Public License, if you ++# distribute this file as part of a program that contains a ++# configuration script generated by Autoconf, you may include it under ++# the same distribution terms that you use for the rest of that program. ++ ++# This file is maintained in Automake, please report ++# bugs to or send patches to ++# . ++ ++nl=' ++' ++ ++# We need space, tab and new line, in precisely that order. Quoting is ++# there to prevent tools from complaining about whitespace usage. ++IFS=" "" $nl" ++ ++file_conv= ++ ++# func_file_conv build_file lazy ++# Convert a $build file to $host form and store it in $file ++# Currently only supports Windows hosts. If the determined conversion ++# type is listed in (the comma separated) LAZY, no conversion will ++# take place. ++func_file_conv () ++{ ++ file=$1 ++ case $file in ++ / | /[!/]*) # absolute file, and not a UNC file ++ if test -z "$file_conv"; then ++ # lazily determine how to convert abs files ++ case `uname -s` in ++ MINGW*) ++ file_conv=mingw ++ ;; ++ CYGWIN*) ++ file_conv=cygwin ++ ;; ++ *) ++ file_conv=wine ++ ;; ++ esac ++ fi ++ case $file_conv/,$2, in ++ *,$file_conv,*) ++ ;; ++ mingw/*) ++ file=`cmd //C echo "$file " | sed -e 's/"\(.*\) " *$/\1/'` ++ ;; ++ cygwin/*) ++ file=`cygpath -m "$file" || echo "$file"` ++ ;; ++ wine/*) ++ file=`winepath -w "$file" || echo "$file"` ++ ;; ++ esac ++ ;; ++ esac ++} ++ ++# func_cl_dashL linkdir ++# Make cl look for libraries in LINKDIR ++func_cl_dashL () ++{ ++ func_file_conv "$1" ++ if test -z "$lib_path"; then ++ lib_path=$file ++ else ++ lib_path="$lib_path;$file" ++ fi ++ linker_opts="$linker_opts -LIBPATH:$file" ++} ++ ++# func_cl_dashl library ++# Do a library search-path lookup for cl ++func_cl_dashl () ++{ ++ lib=$1 ++ found=no ++ save_IFS=$IFS ++ IFS=';' ++ for dir in $lib_path $LIB ++ do ++ IFS=$save_IFS ++ if $shared && test -f "$dir/$lib.dll.lib"; then ++ found=yes ++ lib=$dir/$lib.dll.lib ++ break ++ fi ++ if test -f "$dir/$lib.lib"; then ++ found=yes ++ lib=$dir/$lib.lib ++ break ++ fi ++ if test -f "$dir/lib$lib.a"; then ++ found=yes ++ lib=$dir/lib$lib.a ++ break ++ fi ++ done ++ IFS=$save_IFS ++ ++ if test "$found" != yes; then ++ lib=$lib.lib ++ fi ++} ++ ++# func_cl_wrapper cl arg... ++# Adjust compile command to suit cl ++func_cl_wrapper () ++{ ++ # Assume a capable shell ++ lib_path= ++ shared=: ++ linker_opts= ++ for arg ++ do ++ if test -n "$eat"; then ++ eat= ++ else ++ case $1 in ++ -o) ++ # configure might choose to run compile as 'compile cc -o foo foo.c'. ++ eat=1 ++ case $2 in ++ *.o | *.[oO][bB][jJ]) ++ func_file_conv "$2" ++ set x "$@" -Fo"$file" ++ shift ++ ;; ++ *) ++ func_file_conv "$2" ++ set x "$@" -Fe"$file" ++ shift ++ ;; ++ esac ++ ;; ++ -I) ++ eat=1 ++ func_file_conv "$2" mingw ++ set x "$@" -I"$file" ++ shift ++ ;; ++ -I*) ++ func_file_conv "${1#-I}" mingw ++ set x "$@" -I"$file" ++ shift ++ ;; ++ -l) ++ eat=1 ++ func_cl_dashl "$2" ++ set x "$@" "$lib" ++ shift ++ ;; ++ -l*) ++ func_cl_dashl "${1#-l}" ++ set x "$@" "$lib" ++ shift ++ ;; ++ -L) ++ eat=1 ++ func_cl_dashL "$2" ++ ;; ++ -L*) ++ func_cl_dashL "${1#-L}" ++ ;; ++ -static) ++ shared=false ++ ;; ++ -Wl,*) ++ arg=${1#-Wl,} ++ save_ifs="$IFS"; IFS=',' ++ for flag in $arg; do ++ IFS="$save_ifs" ++ linker_opts="$linker_opts $flag" ++ done ++ IFS="$save_ifs" ++ ;; ++ -Xlinker) ++ eat=1 ++ linker_opts="$linker_opts $2" ++ ;; ++ -*) ++ set x "$@" "$1" ++ shift ++ ;; ++ *.cc | *.CC | *.cxx | *.CXX | *.[cC]++) ++ func_file_conv "$1" ++ set x "$@" -Tp"$file" ++ shift ++ ;; ++ *.c | *.cpp | *.CPP | *.lib | *.LIB | *.Lib | *.OBJ | *.obj | *.[oO]) ++ func_file_conv "$1" mingw ++ set x "$@" "$file" ++ shift ++ ;; ++ *) ++ set x "$@" "$1" ++ shift ++ ;; ++ esac ++ fi ++ shift ++ done ++ if test -n "$linker_opts"; then ++ linker_opts="-link$linker_opts" ++ fi ++ exec "$@" $linker_opts ++ exit 1 ++} ++ ++eat= ++ ++case $1 in ++ '') ++ echo "$0: No command. Try '$0 --help' for more information." 1>&2 ++ exit 1; ++ ;; ++ -h | --h*) ++ cat <<\EOF ++Usage: compile [--help] [--version] PROGRAM [ARGS] ++ ++Wrapper for compilers which do not understand '-c -o'. ++Remove '-o dest.o' from ARGS, run PROGRAM with the remaining ++arguments, and rename the output as expected. ++ ++If you are trying to build a whole package this is not the ++right script to run: please start by reading the file 'INSTALL'. ++ ++Report bugs to . ++EOF ++ exit $? ++ ;; ++ -v | --v*) ++ echo "compile $scriptversion" ++ exit $? ++ ;; ++ cl | *[/\\]cl | cl.exe | *[/\\]cl.exe ) ++ func_cl_wrapper "$@" # Doesn't return... ++ ;; ++esac ++ ++ofile= ++cfile= ++ ++for arg ++do ++ if test -n "$eat"; then ++ eat= ++ else ++ case $1 in ++ -o) ++ # configure might choose to run compile as 'compile cc -o foo foo.c'. ++ # So we strip '-o arg' only if arg is an object. ++ eat=1 ++ case $2 in ++ *.o | *.obj) ++ ofile=$2 ++ ;; ++ *) ++ set x "$@" -o "$2" ++ shift ++ ;; ++ esac ++ ;; ++ *.c) ++ cfile=$1 ++ set x "$@" "$1" ++ shift ++ ;; ++ *) ++ set x "$@" "$1" ++ shift ++ ;; ++ esac ++ fi ++ shift ++done ++ ++if test -z "$ofile" || test -z "$cfile"; then ++ # If no '-o' option was seen then we might have been invoked from a ++ # pattern rule where we don't need one. That is ok -- this is a ++ # normal compilation that the losing compiler can handle. If no ++ # '.c' file was seen then we are probably linking. That is also ++ # ok. ++ exec "$@" ++fi ++ ++# Name of file we expect compiler to create. ++cofile=`echo "$cfile" | sed 's|^.*[\\/]||; s|^[a-zA-Z]:||; s/\.c$/.o/'` ++ ++# Create the lock directory. ++# Note: use '[/\\:.-]' here to ensure that we don't use the same name ++# that we are using for the .o file. Also, base the name on the expected ++# object file name, since that is what matters with a parallel build. ++lockdir=`echo "$cofile" | sed -e 's|[/\\:.-]|_|g'`.d ++while true; do ++ if mkdir "$lockdir" >/dev/null 2>&1; then ++ break ++ fi ++ sleep 1 ++done ++# FIXME: race condition here if user kills between mkdir and trap. ++trap "rmdir '$lockdir'; exit 1" 1 2 15 ++ ++# Run the compile. ++"$@" ++ret=$? ++ ++if test -f "$cofile"; then ++ test "$cofile" = "$ofile" || mv "$cofile" "$ofile" ++elif test -f "${cofile}bj"; then ++ test "${cofile}bj" = "$ofile" || mv "${cofile}bj" "$ofile" ++fi ++ ++rmdir "$lockdir" ++exit $ret ++ ++# Local Variables: ++# mode: shell-script ++# sh-indentation: 2 ++# eval: (add-hook 'write-file-hooks 'time-stamp) ++# time-stamp-start: "scriptversion=" ++# time-stamp-format: "%:y-%02m-%02d.%02H" ++# time-stamp-time-zone: "UTC" ++# time-stamp-end: "; # UTC" ++# End: +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/config.guess +@@ -0,0 +1,1480 @@ ++#! /bin/sh ++# Attempt to guess a canonical system name. ++# Copyright 1992-2018 Free Software Foundation, Inc. ++ ++timestamp='2018-02-24' ++ ++# This file 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 . ++# ++# As a special exception to the GNU General Public License, if you ++# distribute this file as part of a program that contains a ++# configuration script generated by Autoconf, you may include it under ++# the same distribution terms that you use for the rest of that ++# program. This Exception is an additional permission under section 7 ++# of the GNU General Public License, version 3 ("GPLv3"). ++# ++# Originally written by Per Bothner; maintained since 2000 by Ben Elliston. ++# ++# You can get the latest version of this script from: ++# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.guess ++# ++# Please send patches to . ++ ++ ++me=`echo "$0" | sed -e 's,.*/,,'` ++ ++usage="\ ++Usage: $0 [OPTION] ++ ++Output the configuration name of the system \`$me' is run on. ++ ++Options: ++ -h, --help print this help, then exit ++ -t, --time-stamp print date of last modification, then exit ++ -v, --version print version number, then exit ++ ++Report bugs and patches to ." ++ ++version="\ ++GNU config.guess ($timestamp) ++ ++Originally written by Per Bothner. ++Copyright 1992-2018 Free Software Foundation, Inc. ++ ++This is free software; see the source for copying conditions. There is NO ++warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." ++ ++help=" ++Try \`$me --help' for more information." ++ ++# Parse command line ++while test $# -gt 0 ; do ++ case $1 in ++ --time-stamp | --time* | -t ) ++ echo "$timestamp" ; exit ;; ++ --version | -v ) ++ echo "$version" ; exit ;; ++ --help | --h* | -h ) ++ echo "$usage"; exit ;; ++ -- ) # Stop option processing ++ shift; break ;; ++ - ) # Use stdin as input. ++ break ;; ++ -* ) ++ echo "$me: invalid option $1$help" >&2 ++ exit 1 ;; ++ * ) ++ break ;; ++ esac ++done ++ ++if test $# != 0; then ++ echo "$me: too many arguments$help" >&2 ++ exit 1 ++fi ++ ++trap 'exit 1' 1 2 15 ++ ++# CC_FOR_BUILD -- compiler used by this script. Note that the use of a ++# compiler to aid in system detection is discouraged as it requires ++# temporary files to be created and, as you can see below, it is a ++# headache to deal with in a portable fashion. ++ ++# Historically, `CC_FOR_BUILD' used to be named `HOST_CC'. We still ++# use `HOST_CC' if defined, but it is deprecated. ++ ++# Portable tmp directory creation inspired by the Autoconf team. ++ ++set_cc_for_build=' ++trap "exitcode=\$?; (rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null) && exit \$exitcode" 0 ; ++trap "rm -f \$tmpfiles 2>/dev/null; rmdir \$tmp 2>/dev/null; exit 1" 1 2 13 15 ; ++: ${TMPDIR=/tmp} ; ++ { tmp=`(umask 077 && mktemp -d "$TMPDIR/cgXXXXXX") 2>/dev/null` && test -n "$tmp" && test -d "$tmp" ; } || ++ { test -n "$RANDOM" && tmp=$TMPDIR/cg$$-$RANDOM && (umask 077 && mkdir $tmp) ; } || ++ { tmp=$TMPDIR/cg-$$ && (umask 077 && mkdir $tmp) && echo "Warning: creating insecure temp directory" >&2 ; } || ++ { echo "$me: cannot create a temporary directory in $TMPDIR" >&2 ; exit 1 ; } ; ++dummy=$tmp/dummy ; ++tmpfiles="$dummy.c $dummy.o $dummy.rel $dummy" ; ++case $CC_FOR_BUILD,$HOST_CC,$CC in ++ ,,) echo "int x;" > "$dummy.c" ; ++ for c in cc gcc c89 c99 ; do ++ if ($c -c -o "$dummy.o" "$dummy.c") >/dev/null 2>&1 ; then ++ CC_FOR_BUILD="$c"; break ; ++ fi ; ++ done ; ++ if test x"$CC_FOR_BUILD" = x ; then ++ CC_FOR_BUILD=no_compiler_found ; ++ fi ++ ;; ++ ,,*) CC_FOR_BUILD=$CC ;; ++ ,*,*) CC_FOR_BUILD=$HOST_CC ;; ++esac ; set_cc_for_build= ;' ++ ++# This is needed to find uname on a Pyramid OSx when run in the BSD universe. ++# (ghazi@noc.rutgers.edu 1994-08-24) ++if (test -f /.attbin/uname) >/dev/null 2>&1 ; then ++ PATH=$PATH:/.attbin ; export PATH ++fi ++ ++UNAME_MACHINE=`(uname -m) 2>/dev/null` || UNAME_MACHINE=unknown ++UNAME_RELEASE=`(uname -r) 2>/dev/null` || UNAME_RELEASE=unknown ++UNAME_SYSTEM=`(uname -s) 2>/dev/null` || UNAME_SYSTEM=unknown ++UNAME_VERSION=`(uname -v) 2>/dev/null` || UNAME_VERSION=unknown ++ ++case "$UNAME_SYSTEM" in ++Linux|GNU|GNU/*) ++ # If the system lacks a compiler, then just pick glibc. ++ # We could probably try harder. ++ LIBC=gnu ++ ++ eval "$set_cc_for_build" ++ cat <<-EOF > "$dummy.c" ++ #include ++ #if defined(__UCLIBC__) ++ LIBC=uclibc ++ #elif defined(__dietlibc__) ++ LIBC=dietlibc ++ #else ++ LIBC=gnu ++ #endif ++ EOF ++ eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^LIBC' | sed 's, ,,g'`" ++ ++ # If ldd exists, use it to detect musl libc. ++ if command -v ldd >/dev/null && \ ++ ldd --version 2>&1 | grep -q ^musl ++ then ++ LIBC=musl ++ fi ++ ;; ++esac ++ ++# Note: order is significant - the case branches are not exclusive. ++ ++case "$UNAME_MACHINE:$UNAME_SYSTEM:$UNAME_RELEASE:$UNAME_VERSION" in ++ *:NetBSD:*:*) ++ # NetBSD (nbsd) targets should (where applicable) match one or ++ # more of the tuples: *-*-netbsdelf*, *-*-netbsdaout*, ++ # *-*-netbsdecoff* and *-*-netbsd*. For targets that recently ++ # switched to ELF, *-*-netbsd* would select the old ++ # object file format. This provides both forward ++ # compatibility and a consistent mechanism for selecting the ++ # object file format. ++ # ++ # Note: NetBSD doesn't particularly care about the vendor ++ # portion of the name. We always set it to "unknown". ++ sysctl="sysctl -n hw.machine_arch" ++ UNAME_MACHINE_ARCH=`(uname -p 2>/dev/null || \ ++ "/sbin/$sysctl" 2>/dev/null || \ ++ "/usr/sbin/$sysctl" 2>/dev/null || \ ++ echo unknown)` ++ case "$UNAME_MACHINE_ARCH" in ++ armeb) machine=armeb-unknown ;; ++ arm*) machine=arm-unknown ;; ++ sh3el) machine=shl-unknown ;; ++ sh3eb) machine=sh-unknown ;; ++ sh5el) machine=sh5le-unknown ;; ++ earmv*) ++ arch=`echo "$UNAME_MACHINE_ARCH" | sed -e 's,^e\(armv[0-9]\).*$,\1,'` ++ endian=`echo "$UNAME_MACHINE_ARCH" | sed -ne 's,^.*\(eb\)$,\1,p'` ++ machine="${arch}${endian}"-unknown ++ ;; ++ *) machine="$UNAME_MACHINE_ARCH"-unknown ;; ++ esac ++ # The Operating System including object format, if it has switched ++ # to ELF recently (or will in the future) and ABI. ++ case "$UNAME_MACHINE_ARCH" in ++ earm*) ++ os=netbsdelf ++ ;; ++ arm*|i386|m68k|ns32k|sh3*|sparc|vax) ++ eval "$set_cc_for_build" ++ if echo __ELF__ | $CC_FOR_BUILD -E - 2>/dev/null \ ++ | grep -q __ELF__ ++ then ++ # Once all utilities can be ECOFF (netbsdecoff) or a.out (netbsdaout). ++ # Return netbsd for either. FIX? ++ os=netbsd ++ else ++ os=netbsdelf ++ fi ++ ;; ++ *) ++ os=netbsd ++ ;; ++ esac ++ # Determine ABI tags. ++ case "$UNAME_MACHINE_ARCH" in ++ earm*) ++ expr='s/^earmv[0-9]/-eabi/;s/eb$//' ++ abi=`echo "$UNAME_MACHINE_ARCH" | sed -e "$expr"` ++ ;; ++ esac ++ # The OS release ++ # Debian GNU/NetBSD machines have a different userland, and ++ # thus, need a distinct triplet. However, they do not need ++ # kernel version information, so it can be replaced with a ++ # suitable tag, in the style of linux-gnu. ++ case "$UNAME_VERSION" in ++ Debian*) ++ release='-gnu' ++ ;; ++ *) ++ release=`echo "$UNAME_RELEASE" | sed -e 's/[-_].*//' | cut -d. -f1,2` ++ ;; ++ esac ++ # Since CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM: ++ # contains redundant information, the shorter form: ++ # CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM is used. ++ echo "$machine-${os}${release}${abi}" ++ exit ;; ++ *:Bitrig:*:*) ++ UNAME_MACHINE_ARCH=`arch | sed 's/Bitrig.//'` ++ echo "$UNAME_MACHINE_ARCH"-unknown-bitrig"$UNAME_RELEASE" ++ exit ;; ++ *:OpenBSD:*:*) ++ UNAME_MACHINE_ARCH=`arch | sed 's/OpenBSD.//'` ++ echo "$UNAME_MACHINE_ARCH"-unknown-openbsd"$UNAME_RELEASE" ++ exit ;; ++ *:LibertyBSD:*:*) ++ UNAME_MACHINE_ARCH=`arch | sed 's/^.*BSD\.//'` ++ echo "$UNAME_MACHINE_ARCH"-unknown-libertybsd"$UNAME_RELEASE" ++ exit ;; ++ *:MidnightBSD:*:*) ++ echo "$UNAME_MACHINE"-unknown-midnightbsd"$UNAME_RELEASE" ++ exit ;; ++ *:ekkoBSD:*:*) ++ echo "$UNAME_MACHINE"-unknown-ekkobsd"$UNAME_RELEASE" ++ exit ;; ++ *:SolidBSD:*:*) ++ echo "$UNAME_MACHINE"-unknown-solidbsd"$UNAME_RELEASE" ++ exit ;; ++ macppc:MirBSD:*:*) ++ echo powerpc-unknown-mirbsd"$UNAME_RELEASE" ++ exit ;; ++ *:MirBSD:*:*) ++ echo "$UNAME_MACHINE"-unknown-mirbsd"$UNAME_RELEASE" ++ exit ;; ++ *:Sortix:*:*) ++ echo "$UNAME_MACHINE"-unknown-sortix ++ exit ;; ++ *:Redox:*:*) ++ echo "$UNAME_MACHINE"-unknown-redox ++ exit ;; ++ mips:OSF1:*.*) ++ echo mips-dec-osf1 ++ exit ;; ++ alpha:OSF1:*:*) ++ case $UNAME_RELEASE in ++ *4.0) ++ UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $3}'` ++ ;; ++ *5.*) ++ UNAME_RELEASE=`/usr/sbin/sizer -v | awk '{print $4}'` ++ ;; ++ esac ++ # According to Compaq, /usr/sbin/psrinfo has been available on ++ # OSF/1 and Tru64 systems produced since 1995. I hope that ++ # covers most systems running today. This code pipes the CPU ++ # types through head -n 1, so we only detect the type of CPU 0. ++ ALPHA_CPU_TYPE=`/usr/sbin/psrinfo -v | sed -n -e 's/^ The alpha \(.*\) processor.*$/\1/p' | head -n 1` ++ case "$ALPHA_CPU_TYPE" in ++ "EV4 (21064)") ++ UNAME_MACHINE=alpha ;; ++ "EV4.5 (21064)") ++ UNAME_MACHINE=alpha ;; ++ "LCA4 (21066/21068)") ++ UNAME_MACHINE=alpha ;; ++ "EV5 (21164)") ++ UNAME_MACHINE=alphaev5 ;; ++ "EV5.6 (21164A)") ++ UNAME_MACHINE=alphaev56 ;; ++ "EV5.6 (21164PC)") ++ UNAME_MACHINE=alphapca56 ;; ++ "EV5.7 (21164PC)") ++ UNAME_MACHINE=alphapca57 ;; ++ "EV6 (21264)") ++ UNAME_MACHINE=alphaev6 ;; ++ "EV6.7 (21264A)") ++ UNAME_MACHINE=alphaev67 ;; ++ "EV6.8CB (21264C)") ++ UNAME_MACHINE=alphaev68 ;; ++ "EV6.8AL (21264B)") ++ UNAME_MACHINE=alphaev68 ;; ++ "EV6.8CX (21264D)") ++ UNAME_MACHINE=alphaev68 ;; ++ "EV6.9A (21264/EV69A)") ++ UNAME_MACHINE=alphaev69 ;; ++ "EV7 (21364)") ++ UNAME_MACHINE=alphaev7 ;; ++ "EV7.9 (21364A)") ++ UNAME_MACHINE=alphaev79 ;; ++ esac ++ # A Pn.n version is a patched version. ++ # A Vn.n version is a released version. ++ # A Tn.n version is a released field test version. ++ # A Xn.n version is an unreleased experimental baselevel. ++ # 1.2 uses "1.2" for uname -r. ++ echo "$UNAME_MACHINE"-dec-osf"`echo "$UNAME_RELEASE" | sed -e 's/^[PVTX]//' | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz`" ++ # Reset EXIT trap before exiting to avoid spurious non-zero exit code. ++ exitcode=$? ++ trap '' 0 ++ exit $exitcode ;; ++ Amiga*:UNIX_System_V:4.0:*) ++ echo m68k-unknown-sysv4 ++ exit ;; ++ *:[Aa]miga[Oo][Ss]:*:*) ++ echo "$UNAME_MACHINE"-unknown-amigaos ++ exit ;; ++ *:[Mm]orph[Oo][Ss]:*:*) ++ echo "$UNAME_MACHINE"-unknown-morphos ++ exit ;; ++ *:OS/390:*:*) ++ echo i370-ibm-openedition ++ exit ;; ++ *:z/VM:*:*) ++ echo s390-ibm-zvmoe ++ exit ;; ++ *:OS400:*:*) ++ echo powerpc-ibm-os400 ++ exit ;; ++ arm:RISC*:1.[012]*:*|arm:riscix:1.[012]*:*) ++ echo arm-acorn-riscix"$UNAME_RELEASE" ++ exit ;; ++ arm*:riscos:*:*|arm*:RISCOS:*:*) ++ echo arm-unknown-riscos ++ exit ;; ++ SR2?01:HI-UX/MPP:*:* | SR8000:HI-UX/MPP:*:*) ++ echo hppa1.1-hitachi-hiuxmpp ++ exit ;; ++ Pyramid*:OSx*:*:* | MIS*:OSx*:*:* | MIS*:SMP_DC-OSx*:*:*) ++ # akee@wpdis03.wpafb.af.mil (Earle F. Ake) contributed MIS and NILE. ++ if test "`(/bin/universe) 2>/dev/null`" = att ; then ++ echo pyramid-pyramid-sysv3 ++ else ++ echo pyramid-pyramid-bsd ++ fi ++ exit ;; ++ NILE*:*:*:dcosx) ++ echo pyramid-pyramid-svr4 ++ exit ;; ++ DRS?6000:unix:4.0:6*) ++ echo sparc-icl-nx6 ++ exit ;; ++ DRS?6000:UNIX_SV:4.2*:7* | DRS?6000:isis:4.2*:7*) ++ case `/usr/bin/uname -p` in ++ sparc) echo sparc-icl-nx7; exit ;; ++ esac ;; ++ s390x:SunOS:*:*) ++ echo "$UNAME_MACHINE"-ibm-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`" ++ exit ;; ++ sun4H:SunOS:5.*:*) ++ echo sparc-hal-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" ++ exit ;; ++ sun4*:SunOS:5.*:* | tadpole*:SunOS:5.*:*) ++ echo sparc-sun-solaris2"`echo "$UNAME_RELEASE" | sed -e 's/[^.]*//'`" ++ exit ;; ++ i86pc:AuroraUX:5.*:* | i86xen:AuroraUX:5.*:*) ++ echo i386-pc-auroraux"$UNAME_RELEASE" ++ exit ;; ++ i86pc:SunOS:5.*:* | i86xen:SunOS:5.*:*) ++ eval "$set_cc_for_build" ++ SUN_ARCH=i386 ++ # If there is a compiler, see if it is configured for 64-bit objects. ++ # Note that the Sun cc does not turn __LP64__ into 1 like gcc does. ++ # This test works for both compilers. ++ if [ "$CC_FOR_BUILD" != no_compiler_found ]; then ++ if (echo '#ifdef __amd64'; echo IS_64BIT_ARCH; echo '#endif') | \ ++ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ ++ grep IS_64BIT_ARCH >/dev/null ++ then ++ SUN_ARCH=x86_64 ++ fi ++ fi ++ echo "$SUN_ARCH"-pc-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" ++ exit ;; ++ sun4*:SunOS:6*:*) ++ # According to config.sub, this is the proper way to canonicalize ++ # SunOS6. Hard to guess exactly what SunOS6 will be like, but ++ # it's likely to be more like Solaris than SunOS4. ++ echo sparc-sun-solaris3"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" ++ exit ;; ++ sun4*:SunOS:*:*) ++ case "`/usr/bin/arch -k`" in ++ Series*|S4*) ++ UNAME_RELEASE=`uname -v` ++ ;; ++ esac ++ # Japanese Language versions have a version number like `4.1.3-JL'. ++ echo sparc-sun-sunos"`echo "$UNAME_RELEASE"|sed -e 's/-/_/'`" ++ exit ;; ++ sun3*:SunOS:*:*) ++ echo m68k-sun-sunos"$UNAME_RELEASE" ++ exit ;; ++ sun*:*:4.2BSD:*) ++ UNAME_RELEASE=`(sed 1q /etc/motd | awk '{print substr($5,1,3)}') 2>/dev/null` ++ test "x$UNAME_RELEASE" = x && UNAME_RELEASE=3 ++ case "`/bin/arch`" in ++ sun3) ++ echo m68k-sun-sunos"$UNAME_RELEASE" ++ ;; ++ sun4) ++ echo sparc-sun-sunos"$UNAME_RELEASE" ++ ;; ++ esac ++ exit ;; ++ aushp:SunOS:*:*) ++ echo sparc-auspex-sunos"$UNAME_RELEASE" ++ exit ;; ++ # The situation for MiNT is a little confusing. The machine name ++ # can be virtually everything (everything which is not ++ # "atarist" or "atariste" at least should have a processor ++ # > m68000). The system name ranges from "MiNT" over "FreeMiNT" ++ # to the lowercase version "mint" (or "freemint"). Finally ++ # the system name "TOS" denotes a system which is actually not ++ # MiNT. But MiNT is downward compatible to TOS, so this should ++ # be no problem. ++ atarist[e]:*MiNT:*:* | atarist[e]:*mint:*:* | atarist[e]:*TOS:*:*) ++ echo m68k-atari-mint"$UNAME_RELEASE" ++ exit ;; ++ atari*:*MiNT:*:* | atari*:*mint:*:* | atarist[e]:*TOS:*:*) ++ echo m68k-atari-mint"$UNAME_RELEASE" ++ exit ;; ++ *falcon*:*MiNT:*:* | *falcon*:*mint:*:* | *falcon*:*TOS:*:*) ++ echo m68k-atari-mint"$UNAME_RELEASE" ++ exit ;; ++ milan*:*MiNT:*:* | milan*:*mint:*:* | *milan*:*TOS:*:*) ++ echo m68k-milan-mint"$UNAME_RELEASE" ++ exit ;; ++ hades*:*MiNT:*:* | hades*:*mint:*:* | *hades*:*TOS:*:*) ++ echo m68k-hades-mint"$UNAME_RELEASE" ++ exit ;; ++ *:*MiNT:*:* | *:*mint:*:* | *:*TOS:*:*) ++ echo m68k-unknown-mint"$UNAME_RELEASE" ++ exit ;; ++ m68k:machten:*:*) ++ echo m68k-apple-machten"$UNAME_RELEASE" ++ exit ;; ++ powerpc:machten:*:*) ++ echo powerpc-apple-machten"$UNAME_RELEASE" ++ exit ;; ++ RISC*:Mach:*:*) ++ echo mips-dec-mach_bsd4.3 ++ exit ;; ++ RISC*:ULTRIX:*:*) ++ echo mips-dec-ultrix"$UNAME_RELEASE" ++ exit ;; ++ VAX*:ULTRIX*:*:*) ++ echo vax-dec-ultrix"$UNAME_RELEASE" ++ exit ;; ++ 2020:CLIX:*:* | 2430:CLIX:*:*) ++ echo clipper-intergraph-clix"$UNAME_RELEASE" ++ exit ;; ++ mips:*:*:UMIPS | mips:*:*:RISCos) ++ eval "$set_cc_for_build" ++ sed 's/^ //' << EOF > "$dummy.c" ++#ifdef __cplusplus ++#include /* for printf() prototype */ ++ int main (int argc, char *argv[]) { ++#else ++ int main (argc, argv) int argc; char *argv[]; { ++#endif ++ #if defined (host_mips) && defined (MIPSEB) ++ #if defined (SYSTYPE_SYSV) ++ printf ("mips-mips-riscos%ssysv\\n", argv[1]); exit (0); ++ #endif ++ #if defined (SYSTYPE_SVR4) ++ printf ("mips-mips-riscos%ssvr4\\n", argv[1]); exit (0); ++ #endif ++ #if defined (SYSTYPE_BSD43) || defined(SYSTYPE_BSD) ++ printf ("mips-mips-riscos%sbsd\\n", argv[1]); exit (0); ++ #endif ++ #endif ++ exit (-1); ++ } ++EOF ++ $CC_FOR_BUILD -o "$dummy" "$dummy.c" && ++ dummyarg=`echo "$UNAME_RELEASE" | sed -n 's/\([0-9]*\).*/\1/p'` && ++ SYSTEM_NAME=`"$dummy" "$dummyarg"` && ++ { echo "$SYSTEM_NAME"; exit; } ++ echo mips-mips-riscos"$UNAME_RELEASE" ++ exit ;; ++ Motorola:PowerMAX_OS:*:*) ++ echo powerpc-motorola-powermax ++ exit ;; ++ Motorola:*:4.3:PL8-*) ++ echo powerpc-harris-powermax ++ exit ;; ++ Night_Hawk:*:*:PowerMAX_OS | Synergy:PowerMAX_OS:*:*) ++ echo powerpc-harris-powermax ++ exit ;; ++ Night_Hawk:Power_UNIX:*:*) ++ echo powerpc-harris-powerunix ++ exit ;; ++ m88k:CX/UX:7*:*) ++ echo m88k-harris-cxux7 ++ exit ;; ++ m88k:*:4*:R4*) ++ echo m88k-motorola-sysv4 ++ exit ;; ++ m88k:*:3*:R3*) ++ echo m88k-motorola-sysv3 ++ exit ;; ++ AViiON:dgux:*:*) ++ # DG/UX returns AViiON for all architectures ++ UNAME_PROCESSOR=`/usr/bin/uname -p` ++ if [ "$UNAME_PROCESSOR" = mc88100 ] || [ "$UNAME_PROCESSOR" = mc88110 ] ++ then ++ if [ "$TARGET_BINARY_INTERFACE"x = m88kdguxelfx ] || \ ++ [ "$TARGET_BINARY_INTERFACE"x = x ] ++ then ++ echo m88k-dg-dgux"$UNAME_RELEASE" ++ else ++ echo m88k-dg-dguxbcs"$UNAME_RELEASE" ++ fi ++ else ++ echo i586-dg-dgux"$UNAME_RELEASE" ++ fi ++ exit ;; ++ M88*:DolphinOS:*:*) # DolphinOS (SVR3) ++ echo m88k-dolphin-sysv3 ++ exit ;; ++ M88*:*:R3*:*) ++ # Delta 88k system running SVR3 ++ echo m88k-motorola-sysv3 ++ exit ;; ++ XD88*:*:*:*) # Tektronix XD88 system running UTekV (SVR3) ++ echo m88k-tektronix-sysv3 ++ exit ;; ++ Tek43[0-9][0-9]:UTek:*:*) # Tektronix 4300 system running UTek (BSD) ++ echo m68k-tektronix-bsd ++ exit ;; ++ *:IRIX*:*:*) ++ echo mips-sgi-irix"`echo "$UNAME_RELEASE"|sed -e 's/-/_/g'`" ++ exit ;; ++ ????????:AIX?:[12].1:2) # AIX 2.2.1 or AIX 2.1.1 is RT/PC AIX. ++ echo romp-ibm-aix # uname -m gives an 8 hex-code CPU id ++ exit ;; # Note that: echo "'`uname -s`'" gives 'AIX ' ++ i*86:AIX:*:*) ++ echo i386-ibm-aix ++ exit ;; ++ ia64:AIX:*:*) ++ if [ -x /usr/bin/oslevel ] ; then ++ IBM_REV=`/usr/bin/oslevel` ++ else ++ IBM_REV="$UNAME_VERSION.$UNAME_RELEASE" ++ fi ++ echo "$UNAME_MACHINE"-ibm-aix"$IBM_REV" ++ exit ;; ++ *:AIX:2:3) ++ if grep bos325 /usr/include/stdio.h >/dev/null 2>&1; then ++ eval "$set_cc_for_build" ++ sed 's/^ //' << EOF > "$dummy.c" ++ #include ++ ++ main() ++ { ++ if (!__power_pc()) ++ exit(1); ++ puts("powerpc-ibm-aix3.2.5"); ++ exit(0); ++ } ++EOF ++ if $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` ++ then ++ echo "$SYSTEM_NAME" ++ else ++ echo rs6000-ibm-aix3.2.5 ++ fi ++ elif grep bos324 /usr/include/stdio.h >/dev/null 2>&1; then ++ echo rs6000-ibm-aix3.2.4 ++ else ++ echo rs6000-ibm-aix3.2 ++ fi ++ exit ;; ++ *:AIX:*:[4567]) ++ IBM_CPU_ID=`/usr/sbin/lsdev -C -c processor -S available | sed 1q | awk '{ print $1 }'` ++ if /usr/sbin/lsattr -El "$IBM_CPU_ID" | grep ' POWER' >/dev/null 2>&1; then ++ IBM_ARCH=rs6000 ++ else ++ IBM_ARCH=powerpc ++ fi ++ if [ -x /usr/bin/lslpp ] ; then ++ IBM_REV=`/usr/bin/lslpp -Lqc bos.rte.libc | ++ awk -F: '{ print $3 }' | sed s/[0-9]*$/0/` ++ else ++ IBM_REV="$UNAME_VERSION.$UNAME_RELEASE" ++ fi ++ echo "$IBM_ARCH"-ibm-aix"$IBM_REV" ++ exit ;; ++ *:AIX:*:*) ++ echo rs6000-ibm-aix ++ exit ;; ++ ibmrt:4.4BSD:*|romp-ibm:4.4BSD:*) ++ echo romp-ibm-bsd4.4 ++ exit ;; ++ ibmrt:*BSD:*|romp-ibm:BSD:*) # covers RT/PC BSD and ++ echo romp-ibm-bsd"$UNAME_RELEASE" # 4.3 with uname added to ++ exit ;; # report: romp-ibm BSD 4.3 ++ *:BOSX:*:*) ++ echo rs6000-bull-bosx ++ exit ;; ++ DPX/2?00:B.O.S.:*:*) ++ echo m68k-bull-sysv3 ++ exit ;; ++ 9000/[34]??:4.3bsd:1.*:*) ++ echo m68k-hp-bsd ++ exit ;; ++ hp300:4.4BSD:*:* | 9000/[34]??:4.3bsd:2.*:*) ++ echo m68k-hp-bsd4.4 ++ exit ;; ++ 9000/[34678]??:HP-UX:*:*) ++ HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'` ++ case "$UNAME_MACHINE" in ++ 9000/31?) HP_ARCH=m68000 ;; ++ 9000/[34]??) HP_ARCH=m68k ;; ++ 9000/[678][0-9][0-9]) ++ if [ -x /usr/bin/getconf ]; then ++ sc_cpu_version=`/usr/bin/getconf SC_CPU_VERSION 2>/dev/null` ++ sc_kernel_bits=`/usr/bin/getconf SC_KERNEL_BITS 2>/dev/null` ++ case "$sc_cpu_version" in ++ 523) HP_ARCH=hppa1.0 ;; # CPU_PA_RISC1_0 ++ 528) HP_ARCH=hppa1.1 ;; # CPU_PA_RISC1_1 ++ 532) # CPU_PA_RISC2_0 ++ case "$sc_kernel_bits" in ++ 32) HP_ARCH=hppa2.0n ;; ++ 64) HP_ARCH=hppa2.0w ;; ++ '') HP_ARCH=hppa2.0 ;; # HP-UX 10.20 ++ esac ;; ++ esac ++ fi ++ if [ "$HP_ARCH" = "" ]; then ++ eval "$set_cc_for_build" ++ sed 's/^ //' << EOF > "$dummy.c" ++ ++ #define _HPUX_SOURCE ++ #include ++ #include ++ ++ int main () ++ { ++ #if defined(_SC_KERNEL_BITS) ++ long bits = sysconf(_SC_KERNEL_BITS); ++ #endif ++ long cpu = sysconf (_SC_CPU_VERSION); ++ ++ switch (cpu) ++ { ++ case CPU_PA_RISC1_0: puts ("hppa1.0"); break; ++ case CPU_PA_RISC1_1: puts ("hppa1.1"); break; ++ case CPU_PA_RISC2_0: ++ #if defined(_SC_KERNEL_BITS) ++ switch (bits) ++ { ++ case 64: puts ("hppa2.0w"); break; ++ case 32: puts ("hppa2.0n"); break; ++ default: puts ("hppa2.0"); break; ++ } break; ++ #else /* !defined(_SC_KERNEL_BITS) */ ++ puts ("hppa2.0"); break; ++ #endif ++ default: puts ("hppa1.0"); break; ++ } ++ exit (0); ++ } ++EOF ++ (CCOPTS="" $CC_FOR_BUILD -o "$dummy" "$dummy.c" 2>/dev/null) && HP_ARCH=`"$dummy"` ++ test -z "$HP_ARCH" && HP_ARCH=hppa ++ fi ;; ++ esac ++ if [ "$HP_ARCH" = hppa2.0w ] ++ then ++ eval "$set_cc_for_build" ++ ++ # hppa2.0w-hp-hpux* has a 64-bit kernel and a compiler generating ++ # 32-bit code. hppa64-hp-hpux* has the same kernel and a compiler ++ # generating 64-bit code. GNU and HP use different nomenclature: ++ # ++ # $ CC_FOR_BUILD=cc ./config.guess ++ # => hppa2.0w-hp-hpux11.23 ++ # $ CC_FOR_BUILD="cc +DA2.0w" ./config.guess ++ # => hppa64-hp-hpux11.23 ++ ++ if echo __LP64__ | (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | ++ grep -q __LP64__ ++ then ++ HP_ARCH=hppa2.0w ++ else ++ HP_ARCH=hppa64 ++ fi ++ fi ++ echo "$HP_ARCH"-hp-hpux"$HPUX_REV" ++ exit ;; ++ ia64:HP-UX:*:*) ++ HPUX_REV=`echo "$UNAME_RELEASE"|sed -e 's/[^.]*.[0B]*//'` ++ echo ia64-hp-hpux"$HPUX_REV" ++ exit ;; ++ 3050*:HI-UX:*:*) ++ eval "$set_cc_for_build" ++ sed 's/^ //' << EOF > "$dummy.c" ++ #include ++ int ++ main () ++ { ++ long cpu = sysconf (_SC_CPU_VERSION); ++ /* The order matters, because CPU_IS_HP_MC68K erroneously returns ++ true for CPU_PA_RISC1_0. CPU_IS_PA_RISC returns correct ++ results, however. */ ++ if (CPU_IS_PA_RISC (cpu)) ++ { ++ switch (cpu) ++ { ++ case CPU_PA_RISC1_0: puts ("hppa1.0-hitachi-hiuxwe2"); break; ++ case CPU_PA_RISC1_1: puts ("hppa1.1-hitachi-hiuxwe2"); break; ++ case CPU_PA_RISC2_0: puts ("hppa2.0-hitachi-hiuxwe2"); break; ++ default: puts ("hppa-hitachi-hiuxwe2"); break; ++ } ++ } ++ else if (CPU_IS_HP_MC68K (cpu)) ++ puts ("m68k-hitachi-hiuxwe2"); ++ else puts ("unknown-hitachi-hiuxwe2"); ++ exit (0); ++ } ++EOF ++ $CC_FOR_BUILD -o "$dummy" "$dummy.c" && SYSTEM_NAME=`"$dummy"` && ++ { echo "$SYSTEM_NAME"; exit; } ++ echo unknown-hitachi-hiuxwe2 ++ exit ;; ++ 9000/7??:4.3bsd:*:* | 9000/8?[79]:4.3bsd:*:*) ++ echo hppa1.1-hp-bsd ++ exit ;; ++ 9000/8??:4.3bsd:*:*) ++ echo hppa1.0-hp-bsd ++ exit ;; ++ *9??*:MPE/iX:*:* | *3000*:MPE/iX:*:*) ++ echo hppa1.0-hp-mpeix ++ exit ;; ++ hp7??:OSF1:*:* | hp8?[79]:OSF1:*:*) ++ echo hppa1.1-hp-osf ++ exit ;; ++ hp8??:OSF1:*:*) ++ echo hppa1.0-hp-osf ++ exit ;; ++ i*86:OSF1:*:*) ++ if [ -x /usr/sbin/sysversion ] ; then ++ echo "$UNAME_MACHINE"-unknown-osf1mk ++ else ++ echo "$UNAME_MACHINE"-unknown-osf1 ++ fi ++ exit ;; ++ parisc*:Lites*:*:*) ++ echo hppa1.1-hp-lites ++ exit ;; ++ C1*:ConvexOS:*:* | convex:ConvexOS:C1*:*) ++ echo c1-convex-bsd ++ exit ;; ++ C2*:ConvexOS:*:* | convex:ConvexOS:C2*:*) ++ if getsysinfo -f scalar_acc ++ then echo c32-convex-bsd ++ else echo c2-convex-bsd ++ fi ++ exit ;; ++ C34*:ConvexOS:*:* | convex:ConvexOS:C34*:*) ++ echo c34-convex-bsd ++ exit ;; ++ C38*:ConvexOS:*:* | convex:ConvexOS:C38*:*) ++ echo c38-convex-bsd ++ exit ;; ++ C4*:ConvexOS:*:* | convex:ConvexOS:C4*:*) ++ echo c4-convex-bsd ++ exit ;; ++ CRAY*Y-MP:*:*:*) ++ echo ymp-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' ++ exit ;; ++ CRAY*[A-Z]90:*:*:*) ++ echo "$UNAME_MACHINE"-cray-unicos"$UNAME_RELEASE" \ ++ | sed -e 's/CRAY.*\([A-Z]90\)/\1/' \ ++ -e y/ABCDEFGHIJKLMNOPQRSTUVWXYZ/abcdefghijklmnopqrstuvwxyz/ \ ++ -e 's/\.[^.]*$/.X/' ++ exit ;; ++ CRAY*TS:*:*:*) ++ echo t90-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' ++ exit ;; ++ CRAY*T3E:*:*:*) ++ echo alphaev5-cray-unicosmk"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' ++ exit ;; ++ CRAY*SV1:*:*:*) ++ echo sv1-cray-unicos"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' ++ exit ;; ++ *:UNICOS/mp:*:*) ++ echo craynv-cray-unicosmp"$UNAME_RELEASE" | sed -e 's/\.[^.]*$/.X/' ++ exit ;; ++ F30[01]:UNIX_System_V:*:* | F700:UNIX_System_V:*:*) ++ FUJITSU_PROC=`uname -m | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz` ++ FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` ++ FUJITSU_REL=`echo "$UNAME_RELEASE" | sed -e 's/ /_/'` ++ echo "${FUJITSU_PROC}-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" ++ exit ;; ++ 5000:UNIX_System_V:4.*:*) ++ FUJITSU_SYS=`uname -p | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/\///'` ++ FUJITSU_REL=`echo "$UNAME_RELEASE" | tr ABCDEFGHIJKLMNOPQRSTUVWXYZ abcdefghijklmnopqrstuvwxyz | sed -e 's/ /_/'` ++ echo "sparc-fujitsu-${FUJITSU_SYS}${FUJITSU_REL}" ++ exit ;; ++ i*86:BSD/386:*:* | i*86:BSD/OS:*:* | *:Ascend\ Embedded/OS:*:*) ++ echo "$UNAME_MACHINE"-pc-bsdi"$UNAME_RELEASE" ++ exit ;; ++ sparc*:BSD/OS:*:*) ++ echo sparc-unknown-bsdi"$UNAME_RELEASE" ++ exit ;; ++ *:BSD/OS:*:*) ++ echo "$UNAME_MACHINE"-unknown-bsdi"$UNAME_RELEASE" ++ exit ;; ++ *:FreeBSD:*:*) ++ UNAME_PROCESSOR=`/usr/bin/uname -p` ++ case "$UNAME_PROCESSOR" in ++ amd64) ++ UNAME_PROCESSOR=x86_64 ;; ++ i386) ++ UNAME_PROCESSOR=i586 ;; ++ esac ++ echo "$UNAME_PROCESSOR"-unknown-freebsd"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`" ++ exit ;; ++ i*:CYGWIN*:*) ++ echo "$UNAME_MACHINE"-pc-cygwin ++ exit ;; ++ *:MINGW64*:*) ++ echo "$UNAME_MACHINE"-pc-mingw64 ++ exit ;; ++ *:MINGW*:*) ++ echo "$UNAME_MACHINE"-pc-mingw32 ++ exit ;; ++ *:MSYS*:*) ++ echo "$UNAME_MACHINE"-pc-msys ++ exit ;; ++ i*:PW*:*) ++ echo "$UNAME_MACHINE"-pc-pw32 ++ exit ;; ++ *:Interix*:*) ++ case "$UNAME_MACHINE" in ++ x86) ++ echo i586-pc-interix"$UNAME_RELEASE" ++ exit ;; ++ authenticamd | genuineintel | EM64T) ++ echo x86_64-unknown-interix"$UNAME_RELEASE" ++ exit ;; ++ IA64) ++ echo ia64-unknown-interix"$UNAME_RELEASE" ++ exit ;; ++ esac ;; ++ i*:UWIN*:*) ++ echo "$UNAME_MACHINE"-pc-uwin ++ exit ;; ++ amd64:CYGWIN*:*:* | x86_64:CYGWIN*:*:*) ++ echo x86_64-unknown-cygwin ++ exit ;; ++ prep*:SunOS:5.*:*) ++ echo powerpcle-unknown-solaris2"`echo "$UNAME_RELEASE"|sed -e 's/[^.]*//'`" ++ exit ;; ++ *:GNU:*:*) ++ # the GNU system ++ echo "`echo "$UNAME_MACHINE"|sed -e 's,[-/].*$,,'`-unknown-$LIBC`echo "$UNAME_RELEASE"|sed -e 's,/.*$,,'`" ++ exit ;; ++ *:GNU/*:*:*) ++ # other systems with GNU libc and userland ++ echo "$UNAME_MACHINE-unknown-`echo "$UNAME_SYSTEM" | sed 's,^[^/]*/,,' | tr "[:upper:]" "[:lower:]"``echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`-$LIBC" ++ exit ;; ++ i*86:Minix:*:*) ++ echo "$UNAME_MACHINE"-pc-minix ++ exit ;; ++ aarch64:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ aarch64_be:Linux:*:*) ++ UNAME_MACHINE=aarch64_be ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ alpha:Linux:*:*) ++ case `sed -n '/^cpu model/s/^.*: \(.*\)/\1/p' < /proc/cpuinfo` in ++ EV5) UNAME_MACHINE=alphaev5 ;; ++ EV56) UNAME_MACHINE=alphaev56 ;; ++ PCA56) UNAME_MACHINE=alphapca56 ;; ++ PCA57) UNAME_MACHINE=alphapca56 ;; ++ EV6) UNAME_MACHINE=alphaev6 ;; ++ EV67) UNAME_MACHINE=alphaev67 ;; ++ EV68*) UNAME_MACHINE=alphaev68 ;; ++ esac ++ objdump --private-headers /bin/sh | grep -q ld.so.1 ++ if test "$?" = 0 ; then LIBC=gnulibc1 ; fi ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ arc:Linux:*:* | arceb:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ arm*:Linux:*:*) ++ eval "$set_cc_for_build" ++ if echo __ARM_EABI__ | $CC_FOR_BUILD -E - 2>/dev/null \ ++ | grep -q __ARM_EABI__ ++ then ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ else ++ if echo __ARM_PCS_VFP | $CC_FOR_BUILD -E - 2>/dev/null \ ++ | grep -q __ARM_PCS_VFP ++ then ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabi ++ else ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC"eabihf ++ fi ++ fi ++ exit ;; ++ avr32*:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ cris:Linux:*:*) ++ echo "$UNAME_MACHINE"-axis-linux-"$LIBC" ++ exit ;; ++ crisv32:Linux:*:*) ++ echo "$UNAME_MACHINE"-axis-linux-"$LIBC" ++ exit ;; ++ e2k:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ frv:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ hexagon:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ i*86:Linux:*:*) ++ echo "$UNAME_MACHINE"-pc-linux-"$LIBC" ++ exit ;; ++ ia64:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ k1om:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ m32r*:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ m68*:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ mips:Linux:*:* | mips64:Linux:*:*) ++ eval "$set_cc_for_build" ++ sed 's/^ //' << EOF > "$dummy.c" ++ #undef CPU ++ #undef ${UNAME_MACHINE} ++ #undef ${UNAME_MACHINE}el ++ #if defined(__MIPSEL__) || defined(__MIPSEL) || defined(_MIPSEL) || defined(MIPSEL) ++ CPU=${UNAME_MACHINE}el ++ #else ++ #if defined(__MIPSEB__) || defined(__MIPSEB) || defined(_MIPSEB) || defined(MIPSEB) ++ CPU=${UNAME_MACHINE} ++ #else ++ CPU= ++ #endif ++ #endif ++EOF ++ eval "`$CC_FOR_BUILD -E "$dummy.c" 2>/dev/null | grep '^CPU'`" ++ test "x$CPU" != x && { echo "$CPU-unknown-linux-$LIBC"; exit; } ++ ;; ++ mips64el:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ openrisc*:Linux:*:*) ++ echo or1k-unknown-linux-"$LIBC" ++ exit ;; ++ or32:Linux:*:* | or1k*:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ padre:Linux:*:*) ++ echo sparc-unknown-linux-"$LIBC" ++ exit ;; ++ parisc64:Linux:*:* | hppa64:Linux:*:*) ++ echo hppa64-unknown-linux-"$LIBC" ++ exit ;; ++ parisc:Linux:*:* | hppa:Linux:*:*) ++ # Look for CPU level ++ case `grep '^cpu[^a-z]*:' /proc/cpuinfo 2>/dev/null | cut -d' ' -f2` in ++ PA7*) echo hppa1.1-unknown-linux-"$LIBC" ;; ++ PA8*) echo hppa2.0-unknown-linux-"$LIBC" ;; ++ *) echo hppa-unknown-linux-"$LIBC" ;; ++ esac ++ exit ;; ++ ppc64:Linux:*:*) ++ echo powerpc64-unknown-linux-"$LIBC" ++ exit ;; ++ ppc:Linux:*:*) ++ echo powerpc-unknown-linux-"$LIBC" ++ exit ;; ++ ppc64le:Linux:*:*) ++ echo powerpc64le-unknown-linux-"$LIBC" ++ exit ;; ++ ppcle:Linux:*:*) ++ echo powerpcle-unknown-linux-"$LIBC" ++ exit ;; ++ riscv32:Linux:*:* | riscv64:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ s390:Linux:*:* | s390x:Linux:*:*) ++ echo "$UNAME_MACHINE"-ibm-linux-"$LIBC" ++ exit ;; ++ sh64*:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ sh*:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ sparc:Linux:*:* | sparc64:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ tile*:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ vax:Linux:*:*) ++ echo "$UNAME_MACHINE"-dec-linux-"$LIBC" ++ exit ;; ++ x86_64:Linux:*:*) ++ if objdump -f /bin/sh | grep -q elf32-x86-64; then ++ echo "$UNAME_MACHINE"-pc-linux-"$LIBC"x32 ++ else ++ echo "$UNAME_MACHINE"-pc-linux-"$LIBC" ++ fi ++ exit ;; ++ xtensa*:Linux:*:*) ++ echo "$UNAME_MACHINE"-unknown-linux-"$LIBC" ++ exit ;; ++ i*86:DYNIX/ptx:4*:*) ++ # ptx 4.0 does uname -s correctly, with DYNIX/ptx in there. ++ # earlier versions are messed up and put the nodename in both ++ # sysname and nodename. ++ echo i386-sequent-sysv4 ++ exit ;; ++ i*86:UNIX_SV:4.2MP:2.*) ++ # Unixware is an offshoot of SVR4, but it has its own version ++ # number series starting with 2... ++ # I am not positive that other SVR4 systems won't match this, ++ # I just have to hope. -- rms. ++ # Use sysv4.2uw... so that sysv4* matches it. ++ echo "$UNAME_MACHINE"-pc-sysv4.2uw"$UNAME_VERSION" ++ exit ;; ++ i*86:OS/2:*:*) ++ # If we were able to find `uname', then EMX Unix compatibility ++ # is probably installed. ++ echo "$UNAME_MACHINE"-pc-os2-emx ++ exit ;; ++ i*86:XTS-300:*:STOP) ++ echo "$UNAME_MACHINE"-unknown-stop ++ exit ;; ++ i*86:atheos:*:*) ++ echo "$UNAME_MACHINE"-unknown-atheos ++ exit ;; ++ i*86:syllable:*:*) ++ echo "$UNAME_MACHINE"-pc-syllable ++ exit ;; ++ i*86:LynxOS:2.*:* | i*86:LynxOS:3.[01]*:* | i*86:LynxOS:4.[02]*:*) ++ echo i386-unknown-lynxos"$UNAME_RELEASE" ++ exit ;; ++ i*86:*DOS:*:*) ++ echo "$UNAME_MACHINE"-pc-msdosdjgpp ++ exit ;; ++ i*86:*:4.*:*) ++ UNAME_REL=`echo "$UNAME_RELEASE" | sed 's/\/MP$//'` ++ if grep Novell /usr/include/link.h >/dev/null 2>/dev/null; then ++ echo "$UNAME_MACHINE"-univel-sysv"$UNAME_REL" ++ else ++ echo "$UNAME_MACHINE"-pc-sysv"$UNAME_REL" ++ fi ++ exit ;; ++ i*86:*:5:[678]*) ++ # UnixWare 7.x, OpenUNIX and OpenServer 6. ++ case `/bin/uname -X | grep "^Machine"` in ++ *486*) UNAME_MACHINE=i486 ;; ++ *Pentium) UNAME_MACHINE=i586 ;; ++ *Pent*|*Celeron) UNAME_MACHINE=i686 ;; ++ esac ++ echo "$UNAME_MACHINE-unknown-sysv${UNAME_RELEASE}${UNAME_SYSTEM}{$UNAME_VERSION}" ++ exit ;; ++ i*86:*:3.2:*) ++ if test -f /usr/options/cb.name; then ++ UNAME_REL=`sed -n 's/.*Version //p' /dev/null >/dev/null ; then ++ UNAME_REL=`(/bin/uname -X|grep Release|sed -e 's/.*= //')` ++ (/bin/uname -X|grep i80486 >/dev/null) && UNAME_MACHINE=i486 ++ (/bin/uname -X|grep '^Machine.*Pentium' >/dev/null) \ ++ && UNAME_MACHINE=i586 ++ (/bin/uname -X|grep '^Machine.*Pent *II' >/dev/null) \ ++ && UNAME_MACHINE=i686 ++ (/bin/uname -X|grep '^Machine.*Pentium Pro' >/dev/null) \ ++ && UNAME_MACHINE=i686 ++ echo "$UNAME_MACHINE"-pc-sco"$UNAME_REL" ++ else ++ echo "$UNAME_MACHINE"-pc-sysv32 ++ fi ++ exit ;; ++ pc:*:*:*) ++ # Left here for compatibility: ++ # uname -m prints for DJGPP always 'pc', but it prints nothing about ++ # the processor, so we play safe by assuming i586. ++ # Note: whatever this is, it MUST be the same as what config.sub ++ # prints for the "djgpp" host, or else GDB configure will decide that ++ # this is a cross-build. ++ echo i586-pc-msdosdjgpp ++ exit ;; ++ Intel:Mach:3*:*) ++ echo i386-pc-mach3 ++ exit ;; ++ paragon:*:*:*) ++ echo i860-intel-osf1 ++ exit ;; ++ i860:*:4.*:*) # i860-SVR4 ++ if grep Stardent /usr/include/sys/uadmin.h >/dev/null 2>&1 ; then ++ echo i860-stardent-sysv"$UNAME_RELEASE" # Stardent Vistra i860-SVR4 ++ else # Add other i860-SVR4 vendors below as they are discovered. ++ echo i860-unknown-sysv"$UNAME_RELEASE" # Unknown i860-SVR4 ++ fi ++ exit ;; ++ mini*:CTIX:SYS*5:*) ++ # "miniframe" ++ echo m68010-convergent-sysv ++ exit ;; ++ mc68k:UNIX:SYSTEM5:3.51m) ++ echo m68k-convergent-sysv ++ exit ;; ++ M680?0:D-NIX:5.3:*) ++ echo m68k-diab-dnix ++ exit ;; ++ M68*:*:R3V[5678]*:*) ++ test -r /sysV68 && { echo 'm68k-motorola-sysv'; exit; } ;; ++ 3[345]??:*:4.0:3.0 | 3[34]??A:*:4.0:3.0 | 3[34]??,*:*:4.0:3.0 | 3[34]??/*:*:4.0:3.0 | 4400:*:4.0:3.0 | 4850:*:4.0:3.0 | SKA40:*:4.0:3.0 | SDS2:*:4.0:3.0 | SHG2:*:4.0:3.0 | S7501*:*:4.0:3.0) ++ OS_REL='' ++ test -r /etc/.relid \ ++ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` ++ /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ ++ && { echo i486-ncr-sysv4.3"$OS_REL"; exit; } ++ /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ ++ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; ++ 3[34]??:*:4.0:* | 3[34]??,*:*:4.0:*) ++ /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ ++ && { echo i486-ncr-sysv4; exit; } ;; ++ NCR*:*:4.2:* | MPRAS*:*:4.2:*) ++ OS_REL='.3' ++ test -r /etc/.relid \ ++ && OS_REL=.`sed -n 's/[^ ]* [^ ]* \([0-9][0-9]\).*/\1/p' < /etc/.relid` ++ /bin/uname -p 2>/dev/null | grep 86 >/dev/null \ ++ && { echo i486-ncr-sysv4.3"$OS_REL"; exit; } ++ /bin/uname -p 2>/dev/null | /bin/grep entium >/dev/null \ ++ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ++ /bin/uname -p 2>/dev/null | /bin/grep pteron >/dev/null \ ++ && { echo i586-ncr-sysv4.3"$OS_REL"; exit; } ;; ++ m68*:LynxOS:2.*:* | m68*:LynxOS:3.0*:*) ++ echo m68k-unknown-lynxos"$UNAME_RELEASE" ++ exit ;; ++ mc68030:UNIX_System_V:4.*:*) ++ echo m68k-atari-sysv4 ++ exit ;; ++ TSUNAMI:LynxOS:2.*:*) ++ echo sparc-unknown-lynxos"$UNAME_RELEASE" ++ exit ;; ++ rs6000:LynxOS:2.*:*) ++ echo rs6000-unknown-lynxos"$UNAME_RELEASE" ++ exit ;; ++ PowerPC:LynxOS:2.*:* | PowerPC:LynxOS:3.[01]*:* | PowerPC:LynxOS:4.[02]*:*) ++ echo powerpc-unknown-lynxos"$UNAME_RELEASE" ++ exit ;; ++ SM[BE]S:UNIX_SV:*:*) ++ echo mips-dde-sysv"$UNAME_RELEASE" ++ exit ;; ++ RM*:ReliantUNIX-*:*:*) ++ echo mips-sni-sysv4 ++ exit ;; ++ RM*:SINIX-*:*:*) ++ echo mips-sni-sysv4 ++ exit ;; ++ *:SINIX-*:*:*) ++ if uname -p 2>/dev/null >/dev/null ; then ++ UNAME_MACHINE=`(uname -p) 2>/dev/null` ++ echo "$UNAME_MACHINE"-sni-sysv4 ++ else ++ echo ns32k-sni-sysv ++ fi ++ exit ;; ++ PENTIUM:*:4.0*:*) # Unisys `ClearPath HMP IX 4000' SVR4/MP effort ++ # says ++ echo i586-unisys-sysv4 ++ exit ;; ++ *:UNIX_System_V:4*:FTX*) ++ # From Gerald Hewes . ++ # How about differentiating between stratus architectures? -djm ++ echo hppa1.1-stratus-sysv4 ++ exit ;; ++ *:*:*:FTX*) ++ # From seanf@swdc.stratus.com. ++ echo i860-stratus-sysv4 ++ exit ;; ++ i*86:VOS:*:*) ++ # From Paul.Green@stratus.com. ++ echo "$UNAME_MACHINE"-stratus-vos ++ exit ;; ++ *:VOS:*:*) ++ # From Paul.Green@stratus.com. ++ echo hppa1.1-stratus-vos ++ exit ;; ++ mc68*:A/UX:*:*) ++ echo m68k-apple-aux"$UNAME_RELEASE" ++ exit ;; ++ news*:NEWS-OS:6*:*) ++ echo mips-sony-newsos6 ++ exit ;; ++ R[34]000:*System_V*:*:* | R4000:UNIX_SYSV:*:* | R*000:UNIX_SV:*:*) ++ if [ -d /usr/nec ]; then ++ echo mips-nec-sysv"$UNAME_RELEASE" ++ else ++ echo mips-unknown-sysv"$UNAME_RELEASE" ++ fi ++ exit ;; ++ BeBox:BeOS:*:*) # BeOS running on hardware made by Be, PPC only. ++ echo powerpc-be-beos ++ exit ;; ++ BeMac:BeOS:*:*) # BeOS running on Mac or Mac clone, PPC only. ++ echo powerpc-apple-beos ++ exit ;; ++ BePC:BeOS:*:*) # BeOS running on Intel PC compatible. ++ echo i586-pc-beos ++ exit ;; ++ BePC:Haiku:*:*) # Haiku running on Intel PC compatible. ++ echo i586-pc-haiku ++ exit ;; ++ x86_64:Haiku:*:*) ++ echo x86_64-unknown-haiku ++ exit ;; ++ SX-4:SUPER-UX:*:*) ++ echo sx4-nec-superux"$UNAME_RELEASE" ++ exit ;; ++ SX-5:SUPER-UX:*:*) ++ echo sx5-nec-superux"$UNAME_RELEASE" ++ exit ;; ++ SX-6:SUPER-UX:*:*) ++ echo sx6-nec-superux"$UNAME_RELEASE" ++ exit ;; ++ SX-7:SUPER-UX:*:*) ++ echo sx7-nec-superux"$UNAME_RELEASE" ++ exit ;; ++ SX-8:SUPER-UX:*:*) ++ echo sx8-nec-superux"$UNAME_RELEASE" ++ exit ;; ++ SX-8R:SUPER-UX:*:*) ++ echo sx8r-nec-superux"$UNAME_RELEASE" ++ exit ;; ++ SX-ACE:SUPER-UX:*:*) ++ echo sxace-nec-superux"$UNAME_RELEASE" ++ exit ;; ++ Power*:Rhapsody:*:*) ++ echo powerpc-apple-rhapsody"$UNAME_RELEASE" ++ exit ;; ++ *:Rhapsody:*:*) ++ echo "$UNAME_MACHINE"-apple-rhapsody"$UNAME_RELEASE" ++ exit ;; ++ *:Darwin:*:*) ++ UNAME_PROCESSOR=`uname -p` || UNAME_PROCESSOR=unknown ++ eval "$set_cc_for_build" ++ if test "$UNAME_PROCESSOR" = unknown ; then ++ UNAME_PROCESSOR=powerpc ++ fi ++ if test "`echo "$UNAME_RELEASE" | sed -e 's/\..*//'`" -le 10 ; then ++ if [ "$CC_FOR_BUILD" != no_compiler_found ]; then ++ if (echo '#ifdef __LP64__'; echo IS_64BIT_ARCH; echo '#endif') | \ ++ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ ++ grep IS_64BIT_ARCH >/dev/null ++ then ++ case $UNAME_PROCESSOR in ++ i386) UNAME_PROCESSOR=x86_64 ;; ++ powerpc) UNAME_PROCESSOR=powerpc64 ;; ++ esac ++ fi ++ # On 10.4-10.6 one might compile for PowerPC via gcc -arch ppc ++ if (echo '#ifdef __POWERPC__'; echo IS_PPC; echo '#endif') | \ ++ (CCOPTS="" $CC_FOR_BUILD -E - 2>/dev/null) | \ ++ grep IS_PPC >/dev/null ++ then ++ UNAME_PROCESSOR=powerpc ++ fi ++ fi ++ elif test "$UNAME_PROCESSOR" = i386 ; then ++ # Avoid executing cc on OS X 10.9, as it ships with a stub ++ # that puts up a graphical alert prompting to install ++ # developer tools. Any system running Mac OS X 10.7 or ++ # later (Darwin 11 and later) is required to have a 64-bit ++ # processor. This is not true of the ARM version of Darwin ++ # that Apple uses in portable devices. ++ UNAME_PROCESSOR=x86_64 ++ fi ++ echo "$UNAME_PROCESSOR"-apple-darwin"$UNAME_RELEASE" ++ exit ;; ++ *:procnto*:*:* | *:QNX:[0123456789]*:*) ++ UNAME_PROCESSOR=`uname -p` ++ if test "$UNAME_PROCESSOR" = x86; then ++ UNAME_PROCESSOR=i386 ++ UNAME_MACHINE=pc ++ fi ++ echo "$UNAME_PROCESSOR"-"$UNAME_MACHINE"-nto-qnx"$UNAME_RELEASE" ++ exit ;; ++ *:QNX:*:4*) ++ echo i386-pc-qnx ++ exit ;; ++ NEO-*:NONSTOP_KERNEL:*:*) ++ echo neo-tandem-nsk"$UNAME_RELEASE" ++ exit ;; ++ NSE-*:NONSTOP_KERNEL:*:*) ++ echo nse-tandem-nsk"$UNAME_RELEASE" ++ exit ;; ++ NSR-*:NONSTOP_KERNEL:*:*) ++ echo nsr-tandem-nsk"$UNAME_RELEASE" ++ exit ;; ++ NSV-*:NONSTOP_KERNEL:*:*) ++ echo nsv-tandem-nsk"$UNAME_RELEASE" ++ exit ;; ++ NSX-*:NONSTOP_KERNEL:*:*) ++ echo nsx-tandem-nsk"$UNAME_RELEASE" ++ exit ;; ++ *:NonStop-UX:*:*) ++ echo mips-compaq-nonstopux ++ exit ;; ++ BS2000:POSIX*:*:*) ++ echo bs2000-siemens-sysv ++ exit ;; ++ DS/*:UNIX_System_V:*:*) ++ echo "$UNAME_MACHINE"-"$UNAME_SYSTEM"-"$UNAME_RELEASE" ++ exit ;; ++ *:Plan9:*:*) ++ # "uname -m" is not consistent, so use $cputype instead. 386 ++ # is converted to i386 for consistency with other x86 ++ # operating systems. ++ if test "$cputype" = 386; then ++ UNAME_MACHINE=i386 ++ else ++ UNAME_MACHINE="$cputype" ++ fi ++ echo "$UNAME_MACHINE"-unknown-plan9 ++ exit ;; ++ *:TOPS-10:*:*) ++ echo pdp10-unknown-tops10 ++ exit ;; ++ *:TENEX:*:*) ++ echo pdp10-unknown-tenex ++ exit ;; ++ KS10:TOPS-20:*:* | KL10:TOPS-20:*:* | TYPE4:TOPS-20:*:*) ++ echo pdp10-dec-tops20 ++ exit ;; ++ XKL-1:TOPS-20:*:* | TYPE5:TOPS-20:*:*) ++ echo pdp10-xkl-tops20 ++ exit ;; ++ *:TOPS-20:*:*) ++ echo pdp10-unknown-tops20 ++ exit ;; ++ *:ITS:*:*) ++ echo pdp10-unknown-its ++ exit ;; ++ SEI:*:*:SEIUX) ++ echo mips-sei-seiux"$UNAME_RELEASE" ++ exit ;; ++ *:DragonFly:*:*) ++ echo "$UNAME_MACHINE"-unknown-dragonfly"`echo "$UNAME_RELEASE"|sed -e 's/[-(].*//'`" ++ exit ;; ++ *:*VMS:*:*) ++ UNAME_MACHINE=`(uname -p) 2>/dev/null` ++ case "$UNAME_MACHINE" in ++ A*) echo alpha-dec-vms ; exit ;; ++ I*) echo ia64-dec-vms ; exit ;; ++ V*) echo vax-dec-vms ; exit ;; ++ esac ;; ++ *:XENIX:*:SysV) ++ echo i386-pc-xenix ++ exit ;; ++ i*86:skyos:*:*) ++ echo "$UNAME_MACHINE"-pc-skyos"`echo "$UNAME_RELEASE" | sed -e 's/ .*$//'`" ++ exit ;; ++ i*86:rdos:*:*) ++ echo "$UNAME_MACHINE"-pc-rdos ++ exit ;; ++ i*86:AROS:*:*) ++ echo "$UNAME_MACHINE"-pc-aros ++ exit ;; ++ x86_64:VMkernel:*:*) ++ echo "$UNAME_MACHINE"-unknown-esx ++ exit ;; ++ amd64:Isilon\ OneFS:*:*) ++ echo x86_64-unknown-onefs ++ exit ;; ++esac ++ ++echo "$0: unable to guess system type" >&2 ++ ++case "$UNAME_MACHINE:$UNAME_SYSTEM" in ++ mips:Linux | mips64:Linux) ++ # If we got here on MIPS GNU/Linux, output extra information. ++ cat >&2 <&2 </dev/null || echo unknown` ++uname -r = `(uname -r) 2>/dev/null || echo unknown` ++uname -s = `(uname -s) 2>/dev/null || echo unknown` ++uname -v = `(uname -v) 2>/dev/null || echo unknown` ++ ++/usr/bin/uname -p = `(/usr/bin/uname -p) 2>/dev/null` ++/bin/uname -X = `(/bin/uname -X) 2>/dev/null` ++ ++hostinfo = `(hostinfo) 2>/dev/null` ++/bin/universe = `(/bin/universe) 2>/dev/null` ++/usr/bin/arch -k = `(/usr/bin/arch -k) 2>/dev/null` ++/bin/arch = `(/bin/arch) 2>/dev/null` ++/usr/bin/oslevel = `(/usr/bin/oslevel) 2>/dev/null` ++/usr/convex/getsysinfo = `(/usr/convex/getsysinfo) 2>/dev/null` ++ ++UNAME_MACHINE = "$UNAME_MACHINE" ++UNAME_RELEASE = "$UNAME_RELEASE" ++UNAME_SYSTEM = "$UNAME_SYSTEM" ++UNAME_VERSION = "$UNAME_VERSION" ++EOF ++ ++exit 1 ++ ++# Local variables: ++# eval: (add-hook 'write-file-functions 'time-stamp) ++# time-stamp-start: "timestamp='" ++# time-stamp-format: "%:y-%02m-%02d" ++# time-stamp-end: "'" ++# End: +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/config.rpath +@@ -0,0 +1,696 @@ ++#! /bin/sh ++# ++# NOTE: This file was brought from ++# http://git.savannah.gnu.org/cgit/gnulib.git/plain/build-aux/config.rpath ++# You should sometimes check if the file is updated and bring it to ++# our trunk and copy this note to the top of that file. ++# ++# Output a system dependent set of variables, describing how to set the ++# run time search path of shared libraries in an executable. ++# ++# Copyright 1996-2011 Free Software Foundation, Inc. ++# Taken from GNU libtool, 2001 ++# Originally by Gordon Matzigkeit , 1996 ++# ++# 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. ++# ++# The first argument passed to this file is the canonical host specification, ++# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM ++# or ++# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM ++# The environment variables CC, GCC, LDFLAGS, LD, with_gnu_ld ++# should be set by the caller. ++# ++# The set of defined variables is at the end of this script. ++ ++# Known limitations: ++# - On IRIX 6.5 with CC="cc", the run time search patch must not be longer ++# than 256 bytes, otherwise the compiler driver will dump core. The only ++# known workaround is to choose shorter directory names for the build ++# directory and/or the installation directory. ++ ++# All known linkers require a `.a' archive for static linking (except MSVC, ++# which needs '.lib'). ++libext=a ++shrext=.so ++ ++host="$1" ++host_cpu=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\1/'` ++host_vendor=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\2/'` ++host_os=`echo "$host" | sed 's/^\([^-]*\)-\([^-]*\)-\(.*\)$/\3/'` ++ ++# Code taken from libtool.m4's _LT_CC_BASENAME. ++ ++for cc_temp in $CC""; do ++ case $cc_temp in ++ compile | *[\\/]compile | ccache | *[\\/]ccache ) ;; ++ distcc | *[\\/]distcc | purify | *[\\/]purify ) ;; ++ \-*) ;; ++ *) break;; ++ esac ++done ++cc_basename=`echo "$cc_temp" | sed -e 's%^.*/%%'` ++ ++# Code taken from libtool.m4's _LT_COMPILER_PIC. ++ ++wl= ++if test "$GCC" = yes; then ++ wl='-Wl,' ++else ++ case "$host_os" in ++ aix*) ++ wl='-Wl,' ++ ;; ++ mingw* | cygwin* | msys* | pw32* | os2* | cegcc*) ++ ;; ++ hpux9* | hpux10* | hpux11*) ++ wl='-Wl,' ++ ;; ++ irix5* | irix6* | nonstopux*) ++ wl='-Wl,' ++ ;; ++ linux* | k*bsd*-gnu | kopensolaris*-gnu) ++ case $cc_basename in ++ ecc*) ++ wl='-Wl,' ++ ;; ++ icc* | ifort*) ++ wl='-Wl,' ++ ;; ++ lf95*) ++ wl='-Wl,' ++ ;; ++ nagfor*) ++ wl='-Wl,-Wl,,' ++ ;; ++ pgcc* | pgf77* | pgf90* | pgf95* | pgfortran*) ++ wl='-Wl,' ++ ;; ++ ccc*) ++ wl='-Wl,' ++ ;; ++ xl* | bgxl* | bgf* | mpixl*) ++ wl='-Wl,' ++ ;; ++ como) ++ wl='-lopt=' ++ ;; ++ *) ++ case `$CC -V 2>&1 | sed 5q` in ++ *Sun\ F* | *Sun*Fortran*) ++ wl= ++ ;; ++ *Sun\ C*) ++ wl='-Wl,' ++ ;; ++ esac ++ ;; ++ esac ++ ;; ++ newsos6) ++ ;; ++ *nto* | *qnx*) ++ ;; ++ osf3* | osf4* | osf5*) ++ wl='-Wl,' ++ ;; ++ rdos*) ++ ;; ++ solaris*) ++ case $cc_basename in ++ f77* | f90* | f95* | sunf77* | sunf90* | sunf95*) ++ wl='-Qoption ld ' ++ ;; ++ *) ++ wl='-Wl,' ++ ;; ++ esac ++ ;; ++ sunos4*) ++ wl='-Qoption ld ' ++ ;; ++ sysv4 | sysv4.2uw2* | sysv4.3*) ++ wl='-Wl,' ++ ;; ++ sysv4*MP*) ++ ;; ++ sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*) ++ wl='-Wl,' ++ ;; ++ unicos*) ++ wl='-Wl,' ++ ;; ++ uts4*) ++ ;; ++ esac ++fi ++ ++# Code taken from libtool.m4's _LT_LINKER_SHLIBS. ++ ++hardcode_libdir_flag_spec= ++hardcode_libdir_separator= ++hardcode_direct=no ++hardcode_minus_L=no ++ ++case "$host_os" in ++ cygwin* | msys* | mingw* | pw32* | cegcc*) ++ # FIXME: the MSVC++ port hasn't been tested in a loooong time ++ # When not using gcc, we currently assume that we are using ++ # Microsoft Visual C++. ++ if test "$GCC" != yes; then ++ with_gnu_ld=no ++ fi ++ ;; ++ interix*) ++ # we just hope/assume this is gcc and not c89 (= MSVC++) ++ with_gnu_ld=yes ++ ;; ++ openbsd*) ++ with_gnu_ld=no ++ ;; ++esac ++ ++ld_shlibs=yes ++if test "$with_gnu_ld" = yes; then ++ # Set some defaults for GNU ld with shared library support. These ++ # are reset later if shared libraries are not supported. Putting them ++ # here allows them to be overridden if necessary. ++ # Unlike libtool, we use -rpath here, not --rpath, since the documented ++ # option of GNU ld is called -rpath, not --rpath. ++ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' ++ case "$host_os" in ++ aix[3-9]*) ++ # On AIX/PPC, the GNU linker is very broken ++ if test "$host_cpu" != ia64; then ++ ld_shlibs=no ++ fi ++ ;; ++ amigaos*) ++ case "$host_cpu" in ++ powerpc) ++ ;; ++ m68k) ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_minus_L=yes ++ ;; ++ esac ++ ;; ++ beos*) ++ if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then ++ : ++ else ++ ld_shlibs=no ++ fi ++ ;; ++ cygwin* | msys* | mingw* | pw32* | cegcc*) ++ # hardcode_libdir_flag_spec is actually meaningless, as there is ++ # no search path for DLLs. ++ hardcode_libdir_flag_spec='-L$libdir' ++ if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then ++ : ++ else ++ ld_shlibs=no ++ fi ++ ;; ++ haiku*) ++ ;; ++ interix[3-9]*) ++ hardcode_direct=no ++ hardcode_libdir_flag_spec='${wl}-rpath,$libdir' ++ ;; ++ gnu* | linux* | tpf* | k*bsd*-gnu | kopensolaris*-gnu) ++ if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then ++ : ++ else ++ ld_shlibs=no ++ fi ++ ;; ++ netbsd*) ++ ;; ++ solaris*) ++ if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then ++ ld_shlibs=no ++ elif $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then ++ : ++ else ++ ld_shlibs=no ++ fi ++ ;; ++ sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*) ++ case `$LD -v 2>&1` in ++ *\ [01].* | *\ 2.[0-9].* | *\ 2.1[0-5].*) ++ ld_shlibs=no ++ ;; ++ *) ++ if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then ++ hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`' ++ else ++ ld_shlibs=no ++ fi ++ ;; ++ esac ++ ;; ++ sunos4*) ++ hardcode_direct=yes ++ ;; ++ *) ++ if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then ++ : ++ else ++ ld_shlibs=no ++ fi ++ ;; ++ esac ++ if test "$ld_shlibs" = no; then ++ hardcode_libdir_flag_spec= ++ fi ++else ++ case "$host_os" in ++ aix3*) ++ # Note: this linker hardcodes the directories in LIBPATH if there ++ # are no directories specified by -L. ++ hardcode_minus_L=yes ++ if test "$GCC" = yes; then ++ # Neither direct hardcoding nor static linking is supported with a ++ # broken collect2. ++ hardcode_direct=unsupported ++ fi ++ ;; ++ aix[4-9]*) ++ if test "$host_cpu" = ia64; then ++ # On IA64, the linker does run time linking by default, so we don't ++ # have to do anything special. ++ aix_use_runtimelinking=no ++ else ++ aix_use_runtimelinking=no ++ # Test if we are trying to use run time linking or normal ++ # AIX style linking. If -brtl is somewhere in LDFLAGS, we ++ # need to do runtime linking. ++ case $host_os in aix4.[23]|aix4.[23].*|aix[5-9]*) ++ for ld_flag in $LDFLAGS; do ++ if (test $ld_flag = "-brtl" || test $ld_flag = "-Wl,-brtl"); then ++ aix_use_runtimelinking=yes ++ break ++ fi ++ done ++ ;; ++ esac ++ fi ++ hardcode_direct=yes ++ hardcode_libdir_separator=':' ++ if test "$GCC" = yes; then ++ case $host_os in aix4.[012]|aix4.[012].*) ++ collect2name=`${CC} -print-prog-name=collect2` ++ if test -f "$collect2name" && \ ++ strings "$collect2name" | grep resolve_lib_name >/dev/null ++ then ++ # We have reworked collect2 ++ : ++ else ++ # We have old collect2 ++ hardcode_direct=unsupported ++ hardcode_minus_L=yes ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_libdir_separator= ++ fi ++ ;; ++ esac ++ fi ++ # Begin _LT_AC_SYS_LIBPATH_AIX. ++ echo 'int main () { return 0; }' > conftest.c ++ ${CC} ${LDFLAGS} conftest.c -o conftest ++ aix_libpath=`dump -H conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } ++}'` ++ if test -z "$aix_libpath"; then ++ aix_libpath=`dump -HX64 conftest 2>/dev/null | sed -n -e '/Import File Strings/,/^$/ { /^0/ { s/^0 *\(.*\)$/\1/; p; } ++}'` ++ fi ++ if test -z "$aix_libpath"; then ++ aix_libpath="/usr/lib:/lib" ++ fi ++ rm -f conftest.c conftest ++ # End _LT_AC_SYS_LIBPATH_AIX. ++ if test "$aix_use_runtimelinking" = yes; then ++ hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" ++ else ++ if test "$host_cpu" = ia64; then ++ hardcode_libdir_flag_spec='${wl}-R $libdir:/usr/lib:/lib' ++ else ++ hardcode_libdir_flag_spec='${wl}-blibpath:$libdir:'"$aix_libpath" ++ fi ++ fi ++ ;; ++ amigaos*) ++ case "$host_cpu" in ++ powerpc) ++ ;; ++ m68k) ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_minus_L=yes ++ ;; ++ esac ++ ;; ++ bsdi[45]*) ++ ;; ++ cygwin* | msys* | mingw* | pw32* | cegcc*) ++ # When not using gcc, we currently assume that we are using ++ # Microsoft Visual C++. ++ # hardcode_libdir_flag_spec is actually meaningless, as there is ++ # no search path for DLLs. ++ hardcode_libdir_flag_spec=' ' ++ libext=lib ++ ;; ++ darwin* | rhapsody*) ++ hardcode_direct=no ++ if { case $cc_basename in ifort*) true;; *) test "$GCC" = yes;; esac; }; then ++ : ++ else ++ ld_shlibs=no ++ fi ++ ;; ++ dgux*) ++ hardcode_libdir_flag_spec='-L$libdir' ++ ;; ++ freebsd2.2*) ++ hardcode_libdir_flag_spec='-R$libdir' ++ hardcode_direct=yes ++ ;; ++ freebsd2*) ++ hardcode_direct=yes ++ hardcode_minus_L=yes ++ ;; ++ freebsd* | dragonfly*) ++ hardcode_libdir_flag_spec='-R$libdir' ++ hardcode_direct=yes ++ ;; ++ hpux9*) ++ hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' ++ hardcode_libdir_separator=: ++ hardcode_direct=yes ++ # hardcode_minus_L: Not really in the search PATH, ++ # but as the default location of the library. ++ hardcode_minus_L=yes ++ ;; ++ hpux10*) ++ if test "$with_gnu_ld" = no; then ++ hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' ++ hardcode_libdir_separator=: ++ hardcode_direct=yes ++ # hardcode_minus_L: Not really in the search PATH, ++ # but as the default location of the library. ++ hardcode_minus_L=yes ++ fi ++ ;; ++ hpux11*) ++ if test "$with_gnu_ld" = no; then ++ hardcode_libdir_flag_spec='${wl}+b ${wl}$libdir' ++ hardcode_libdir_separator=: ++ case $host_cpu in ++ hppa*64*|ia64*) ++ hardcode_direct=no ++ ;; ++ *) ++ hardcode_direct=yes ++ # hardcode_minus_L: Not really in the search PATH, ++ # but as the default location of the library. ++ hardcode_minus_L=yes ++ ;; ++ esac ++ fi ++ ;; ++ irix5* | irix6* | nonstopux*) ++ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' ++ hardcode_libdir_separator=: ++ ;; ++ netbsd*) ++ hardcode_libdir_flag_spec='-R$libdir' ++ hardcode_direct=yes ++ ;; ++ newsos6) ++ hardcode_direct=yes ++ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' ++ hardcode_libdir_separator=: ++ ;; ++ *nto* | *qnx*) ++ ;; ++ openbsd*) ++ if test -f /usr/libexec/ld.so; then ++ hardcode_direct=yes ++ if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then ++ hardcode_libdir_flag_spec='${wl}-rpath,$libdir' ++ else ++ case "$host_os" in ++ openbsd[01].* | openbsd2.[0-7] | openbsd2.[0-7].*) ++ hardcode_libdir_flag_spec='-R$libdir' ++ ;; ++ *) ++ hardcode_libdir_flag_spec='${wl}-rpath,$libdir' ++ ;; ++ esac ++ fi ++ else ++ ld_shlibs=no ++ fi ++ ;; ++ os2*) ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_minus_L=yes ++ ;; ++ osf3*) ++ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' ++ hardcode_libdir_separator=: ++ ;; ++ osf4* | osf5*) ++ if test "$GCC" = yes; then ++ hardcode_libdir_flag_spec='${wl}-rpath ${wl}$libdir' ++ else ++ # Both cc and cxx compiler support -rpath directly ++ hardcode_libdir_flag_spec='-rpath $libdir' ++ fi ++ hardcode_libdir_separator=: ++ ;; ++ solaris*) ++ hardcode_libdir_flag_spec='-R$libdir' ++ ;; ++ sunos4*) ++ hardcode_libdir_flag_spec='-L$libdir' ++ hardcode_direct=yes ++ hardcode_minus_L=yes ++ ;; ++ sysv4) ++ case $host_vendor in ++ sni) ++ hardcode_direct=yes # is this really true??? ++ ;; ++ siemens) ++ hardcode_direct=no ++ ;; ++ motorola) ++ hardcode_direct=no #Motorola manual says yes, but my tests say they lie ++ ;; ++ esac ++ ;; ++ sysv4.3*) ++ ;; ++ sysv4*MP*) ++ if test -d /usr/nec; then ++ ld_shlibs=yes ++ fi ++ ;; ++ sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[01].[10]* | unixware7* | sco3.2v5.0.[024]*) ++ ;; ++ sysv5* | sco3.2v5* | sco5v6*) ++ hardcode_libdir_flag_spec='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`' ++ hardcode_libdir_separator=':' ++ ;; ++ uts4*) ++ hardcode_libdir_flag_spec='-L$libdir' ++ ;; ++ *) ++ ld_shlibs=no ++ ;; ++ esac ++fi ++ ++# Check dynamic linker characteristics ++# Code taken from libtool.m4's _LT_SYS_DYNAMIC_LINKER. ++# Unlike libtool.m4, here we don't care about _all_ names of the library, but ++# only about the one the linker finds when passed -lNAME. This is the last ++# element of library_names_spec in libtool.m4, or possibly two of them if the ++# linker has special search rules. ++library_names_spec= # the last element of library_names_spec in libtool.m4 ++libname_spec='lib$name' ++case "$host_os" in ++ aix3*) ++ library_names_spec='$libname.a' ++ ;; ++ aix[4-9]*) ++ library_names_spec='$libname$shrext' ++ ;; ++ amigaos*) ++ case "$host_cpu" in ++ powerpc*) ++ library_names_spec='$libname$shrext' ;; ++ m68k) ++ library_names_spec='$libname.a' ;; ++ esac ++ ;; ++ beos*) ++ library_names_spec='$libname$shrext' ++ ;; ++ bsdi[45]*) ++ library_names_spec='$libname$shrext' ++ ;; ++ cygwin* | msys* | mingw* | pw32* | cegcc*) ++ shrext=.dll ++ library_names_spec='$libname.dll.a $libname.lib' ++ ;; ++ darwin* | rhapsody*) ++ shrext=.dylib ++ library_names_spec='$libname$shrext' ++ ;; ++ dgux*) ++ library_names_spec='$libname$shrext' ++ ;; ++ freebsd* | dragonfly*) ++ case "$host_os" in ++ freebsd[123]*) ++ library_names_spec='$libname$shrext$versuffix' ;; ++ *) ++ library_names_spec='$libname$shrext' ;; ++ esac ++ ;; ++ gnu*) ++ library_names_spec='$libname$shrext' ++ ;; ++ haiku*) ++ library_names_spec='$libname$shrext' ++ ;; ++ hpux9* | hpux10* | hpux11*) ++ case $host_cpu in ++ ia64*) ++ shrext=.so ++ ;; ++ hppa*64*) ++ shrext=.sl ++ ;; ++ *) ++ shrext=.sl ++ ;; ++ esac ++ library_names_spec='$libname$shrext' ++ ;; ++ interix[3-9]*) ++ library_names_spec='$libname$shrext' ++ ;; ++ irix5* | irix6* | nonstopux*) ++ library_names_spec='$libname$shrext' ++ case "$host_os" in ++ irix5* | nonstopux*) ++ libsuff= shlibsuff= ++ ;; ++ *) ++ case $LD in ++ *-32|*"-32 "|*-melf32bsmip|*"-melf32bsmip ") libsuff= shlibsuff= ;; ++ *-n32|*"-n32 "|*-melf32bmipn32|*"-melf32bmipn32 ") libsuff=32 shlibsuff=N32 ;; ++ *-64|*"-64 "|*-melf64bmip|*"-melf64bmip ") libsuff=64 shlibsuff=64 ;; ++ *) libsuff= shlibsuff= ;; ++ esac ++ ;; ++ esac ++ ;; ++ linux*oldld* | linux*aout* | linux*coff*) ++ ;; ++ linux* | k*bsd*-gnu | kopensolaris*-gnu) ++ library_names_spec='$libname$shrext' ++ ;; ++ knetbsd*-gnu) ++ library_names_spec='$libname$shrext' ++ ;; ++ netbsd*) ++ library_names_spec='$libname$shrext' ++ ;; ++ newsos6) ++ library_names_spec='$libname$shrext' ++ ;; ++ *nto* | *qnx*) ++ library_names_spec='$libname$shrext' ++ ;; ++ openbsd*) ++ library_names_spec='$libname$shrext$versuffix' ++ ;; ++ os2*) ++ libname_spec='$name' ++ shrext=.dll ++ library_names_spec='$libname.a' ++ ;; ++ osf3* | osf4* | osf5*) ++ library_names_spec='$libname$shrext' ++ ;; ++ rdos*) ++ ;; ++ solaris*) ++ library_names_spec='$libname$shrext' ++ ;; ++ sunos4*) ++ library_names_spec='$libname$shrext$versuffix' ++ ;; ++ sysv4 | sysv4.3*) ++ library_names_spec='$libname$shrext' ++ ;; ++ sysv4*MP*) ++ library_names_spec='$libname$shrext' ++ ;; ++ sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*) ++ library_names_spec='$libname$shrext' ++ ;; ++ tpf*) ++ library_names_spec='$libname$shrext' ++ ;; ++ uts4*) ++ library_names_spec='$libname$shrext' ++ ;; ++esac ++ ++sed_quote_subst='s/\(["`$\\]\)/\\\1/g' ++escaped_wl=`echo "X$wl" | sed -e 's/^X//' -e "$sed_quote_subst"` ++shlibext=`echo "$shrext" | sed -e 's,^\.,,'` ++escaped_libname_spec=`echo "X$libname_spec" | sed -e 's/^X//' -e "$sed_quote_subst"` ++escaped_library_names_spec=`echo "X$library_names_spec" | sed -e 's/^X//' -e "$sed_quote_subst"` ++escaped_hardcode_libdir_flag_spec=`echo "X$hardcode_libdir_flag_spec" | sed -e 's/^X//' -e "$sed_quote_subst"` ++ ++LC_ALL=C sed -e 's/^\([a-zA-Z0-9_]*\)=/acl_cv_\1=/' <. ++# ++# As a special exception to the GNU General Public License, if you ++# distribute this file as part of a program that contains a ++# configuration script generated by Autoconf, you may include it under ++# the same distribution terms that you use for the rest of that ++# program. This Exception is an additional permission under section 7 ++# of the GNU General Public License, version 3 ("GPLv3"). ++ ++ ++# Please send patches to . ++# ++# Configuration subroutine to validate and canonicalize a configuration type. ++# Supply the specified configuration type as an argument. ++# If it is invalid, we print an error message on stderr and exit with code 1. ++# Otherwise, we print the canonical config type on stdout and succeed. ++ ++# You can get the latest version of this script from: ++# https://git.savannah.gnu.org/gitweb/?p=config.git;a=blob_plain;f=config.sub ++ ++# This file is supposed to be the same for all GNU packages ++# and recognize all the CPU types, system types and aliases ++# that are meaningful with *any* GNU software. ++# Each package is responsible for reporting which valid configurations ++# it does not support. The user should be able to distinguish ++# a failure to support a valid configuration from a meaningless ++# configuration. ++ ++# The goal of this file is to map all the various variations of a given ++# machine specification into a single specification in the form: ++# CPU_TYPE-MANUFACTURER-OPERATING_SYSTEM ++# or in some cases, the newer four-part form: ++# CPU_TYPE-MANUFACTURER-KERNEL-OPERATING_SYSTEM ++# It is wrong to echo any other type of specification. ++ ++me=`echo "$0" | sed -e 's,.*/,,'` ++ ++usage="\ ++Usage: $0 [OPTION] CPU-MFR-OPSYS or ALIAS ++ ++Canonicalize a configuration name. ++ ++Options: ++ -h, --help print this help, then exit ++ -t, --time-stamp print date of last modification, then exit ++ -v, --version print version number, then exit ++ ++Report bugs and patches to ." ++ ++version="\ ++GNU config.sub ($timestamp) ++ ++Copyright 1992-2018 Free Software Foundation, Inc. ++ ++This is free software; see the source for copying conditions. There is NO ++warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE." ++ ++help=" ++Try \`$me --help' for more information." ++ ++# Parse command line ++while test $# -gt 0 ; do ++ case $1 in ++ --time-stamp | --time* | -t ) ++ echo "$timestamp" ; exit ;; ++ --version | -v ) ++ echo "$version" ; exit ;; ++ --help | --h* | -h ) ++ echo "$usage"; exit ;; ++ -- ) # Stop option processing ++ shift; break ;; ++ - ) # Use stdin as input. ++ break ;; ++ -* ) ++ echo "$me: invalid option $1$help" ++ exit 1 ;; ++ ++ *local*) ++ # First pass through any local machine types. ++ echo "$1" ++ exit ;; ++ ++ * ) ++ break ;; ++ esac ++done ++ ++case $# in ++ 0) echo "$me: missing argument$help" >&2 ++ exit 1;; ++ 1) ;; ++ *) echo "$me: too many arguments$help" >&2 ++ exit 1;; ++esac ++ ++# Separate what the user gave into CPU-COMPANY and OS or KERNEL-OS (if any). ++# Here we must recognize all the valid KERNEL-OS combinations. ++maybe_os=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\2/'` ++case $maybe_os in ++ nto-qnx* | linux-gnu* | linux-android* | linux-dietlibc | linux-newlib* | \ ++ linux-musl* | linux-uclibc* | uclinux-uclibc* | uclinux-gnu* | kfreebsd*-gnu* | \ ++ knetbsd*-gnu* | netbsd*-gnu* | netbsd*-eabi* | \ ++ kopensolaris*-gnu* | cloudabi*-eabi* | \ ++ storm-chaos* | os2-emx* | rtmk-nova*) ++ os=-$maybe_os ++ basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'` ++ ;; ++ android-linux) ++ os=-linux-android ++ basic_machine=`echo "$1" | sed 's/^\(.*\)-\([^-]*-[^-]*\)$/\1/'`-unknown ++ ;; ++ *) ++ basic_machine=`echo "$1" | sed 's/-[^-]*$//'` ++ if [ "$basic_machine" != "$1" ] ++ then os=`echo "$1" | sed 's/.*-/-/'` ++ else os=; fi ++ ;; ++esac ++ ++### Let's recognize common machines as not being operating systems so ++### that things like config.sub decstation-3100 work. We also ++### recognize some manufacturers as not being operating systems, so we ++### can provide default operating systems below. ++case $os in ++ -sun*os*) ++ # Prevent following clause from handling this invalid input. ++ ;; ++ -dec* | -mips* | -sequent* | -encore* | -pc532* | -sgi* | -sony* | \ ++ -att* | -7300* | -3300* | -delta* | -motorola* | -sun[234]* | \ ++ -unicom* | -ibm* | -next | -hp | -isi* | -apollo | -altos* | \ ++ -convergent* | -ncr* | -news | -32* | -3600* | -3100* | -hitachi* |\ ++ -c[123]* | -convex* | -sun | -crds | -omron* | -dg | -ultra | -tti* | \ ++ -harris | -dolphin | -highlevel | -gould | -cbm | -ns | -masscomp | \ ++ -apple | -axis | -knuth | -cray | -microblaze*) ++ os= ++ basic_machine=$1 ++ ;; ++ -bluegene*) ++ os=-cnk ++ ;; ++ -sim | -cisco | -oki | -wec | -winbond) ++ os= ++ basic_machine=$1 ++ ;; ++ -scout) ++ ;; ++ -wrs) ++ os=-vxworks ++ basic_machine=$1 ++ ;; ++ -chorusos*) ++ os=-chorusos ++ basic_machine=$1 ++ ;; ++ -chorusrdb) ++ os=-chorusrdb ++ basic_machine=$1 ++ ;; ++ -hiux*) ++ os=-hiuxwe2 ++ ;; ++ -sco6) ++ os=-sco5v6 ++ basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ++ ;; ++ -sco5) ++ os=-sco3.2v5 ++ basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ++ ;; ++ -sco4) ++ os=-sco3.2v4 ++ basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ++ ;; ++ -sco3.2.[4-9]*) ++ os=`echo $os | sed -e 's/sco3.2./sco3.2v/'` ++ basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ++ ;; ++ -sco3.2v[4-9]*) ++ # Don't forget version if it is 3.2v4 or newer. ++ basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ++ ;; ++ -sco5v6*) ++ # Don't forget version if it is 3.2v4 or newer. ++ basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ++ ;; ++ -sco*) ++ os=-sco3.2v2 ++ basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ++ ;; ++ -udk*) ++ basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ++ ;; ++ -isc) ++ os=-isc2.2 ++ basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ++ ;; ++ -clix*) ++ basic_machine=clipper-intergraph ++ ;; ++ -isc*) ++ basic_machine=`echo "$1" | sed -e 's/86-.*/86-pc/'` ++ ;; ++ -lynx*178) ++ os=-lynxos178 ++ ;; ++ -lynx*5) ++ os=-lynxos5 ++ ;; ++ -lynx*) ++ os=-lynxos ++ ;; ++ -ptx*) ++ basic_machine=`echo "$1" | sed -e 's/86-.*/86-sequent/'` ++ ;; ++ -psos*) ++ os=-psos ++ ;; ++ -mint | -mint[0-9]*) ++ basic_machine=m68k-atari ++ os=-mint ++ ;; ++esac ++ ++# Decode aliases for certain CPU-COMPANY combinations. ++case $basic_machine in ++ # Recognize the basic CPU types without company name. ++ # Some are omitted here because they have special meanings below. ++ 1750a | 580 \ ++ | a29k \ ++ | aarch64 | aarch64_be \ ++ | alpha | alphaev[4-8] | alphaev56 | alphaev6[78] | alphapca5[67] \ ++ | alpha64 | alpha64ev[4-8] | alpha64ev56 | alpha64ev6[78] | alpha64pca5[67] \ ++ | am33_2.0 \ ++ | arc | arceb \ ++ | arm | arm[bl]e | arme[lb] | armv[2-8] | armv[3-8][lb] | armv7[arm] \ ++ | avr | avr32 \ ++ | ba \ ++ | be32 | be64 \ ++ | bfin \ ++ | c4x | c8051 | clipper \ ++ | d10v | d30v | dlx | dsp16xx \ ++ | e2k | epiphany \ ++ | fido | fr30 | frv | ft32 \ ++ | h8300 | h8500 | hppa | hppa1.[01] | hppa2.0 | hppa2.0[nw] | hppa64 \ ++ | hexagon \ ++ | i370 | i860 | i960 | ia16 | ia64 \ ++ | ip2k | iq2000 \ ++ | k1om \ ++ | le32 | le64 \ ++ | lm32 \ ++ | m32c | m32r | m32rle | m68000 | m68k | m88k \ ++ | maxq | mb | microblaze | microblazeel | mcore | mep | metag \ ++ | mips | mipsbe | mipseb | mipsel | mipsle \ ++ | mips16 \ ++ | mips64 | mips64el \ ++ | mips64octeon | mips64octeonel \ ++ | mips64orion | mips64orionel \ ++ | mips64r5900 | mips64r5900el \ ++ | mips64vr | mips64vrel \ ++ | mips64vr4100 | mips64vr4100el \ ++ | mips64vr4300 | mips64vr4300el \ ++ | mips64vr5000 | mips64vr5000el \ ++ | mips64vr5900 | mips64vr5900el \ ++ | mipsisa32 | mipsisa32el \ ++ | mipsisa32r2 | mipsisa32r2el \ ++ | mipsisa32r6 | mipsisa32r6el \ ++ | mipsisa64 | mipsisa64el \ ++ | mipsisa64r2 | mipsisa64r2el \ ++ | mipsisa64r6 | mipsisa64r6el \ ++ | mipsisa64sb1 | mipsisa64sb1el \ ++ | mipsisa64sr71k | mipsisa64sr71kel \ ++ | mipsr5900 | mipsr5900el \ ++ | mipstx39 | mipstx39el \ ++ | mn10200 | mn10300 \ ++ | moxie \ ++ | mt \ ++ | msp430 \ ++ | nds32 | nds32le | nds32be \ ++ | nios | nios2 | nios2eb | nios2el \ ++ | ns16k | ns32k \ ++ | open8 | or1k | or1knd | or32 \ ++ | pdp10 | pj | pjl \ ++ | powerpc | powerpc64 | powerpc64le | powerpcle \ ++ | pru \ ++ | pyramid \ ++ | riscv32 | riscv64 \ ++ | rl78 | rx \ ++ | score \ ++ | sh | sh[1234] | sh[24]a | sh[24]aeb | sh[23]e | sh[234]eb | sheb | shbe | shle | sh[1234]le | sh3ele \ ++ | sh64 | sh64le \ ++ | sparc | sparc64 | sparc64b | sparc64v | sparc86x | sparclet | sparclite \ ++ | sparcv8 | sparcv9 | sparcv9b | sparcv9v \ ++ | spu \ ++ | tahoe | tic4x | tic54x | tic55x | tic6x | tic80 | tron \ ++ | ubicom32 \ ++ | v850 | v850e | v850e1 | v850e2 | v850es | v850e2v3 \ ++ | visium \ ++ | wasm32 \ ++ | x86 | xc16x | xstormy16 | xtensa \ ++ | z8k | z80) ++ basic_machine=$basic_machine-unknown ++ ;; ++ c54x) ++ basic_machine=tic54x-unknown ++ ;; ++ c55x) ++ basic_machine=tic55x-unknown ++ ;; ++ c6x) ++ basic_machine=tic6x-unknown ++ ;; ++ leon|leon[3-9]) ++ basic_machine=sparc-$basic_machine ++ ;; ++ m6811 | m68hc11 | m6812 | m68hc12 | m68hcs12x | nvptx | picochip) ++ basic_machine=$basic_machine-unknown ++ os=-none ++ ;; ++ m88110 | m680[12346]0 | m683?2 | m68360 | m5200 | v70 | w65) ++ ;; ++ ms1) ++ basic_machine=mt-unknown ++ ;; ++ ++ strongarm | thumb | xscale) ++ basic_machine=arm-unknown ++ ;; ++ xgate) ++ basic_machine=$basic_machine-unknown ++ os=-none ++ ;; ++ xscaleeb) ++ basic_machine=armeb-unknown ++ ;; ++ ++ xscaleel) ++ basic_machine=armel-unknown ++ ;; ++ ++ # We use `pc' rather than `unknown' ++ # because (1) that's what they normally are, and ++ # (2) the word "unknown" tends to confuse beginning users. ++ i*86 | x86_64) ++ basic_machine=$basic_machine-pc ++ ;; ++ # Object if more than one company name word. ++ *-*-*) ++ echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2 ++ exit 1 ++ ;; ++ # Recognize the basic CPU types with company name. ++ 580-* \ ++ | a29k-* \ ++ | aarch64-* | aarch64_be-* \ ++ | alpha-* | alphaev[4-8]-* | alphaev56-* | alphaev6[78]-* \ ++ | alpha64-* | alpha64ev[4-8]-* | alpha64ev56-* | alpha64ev6[78]-* \ ++ | alphapca5[67]-* | alpha64pca5[67]-* | arc-* | arceb-* \ ++ | arm-* | armbe-* | armle-* | armeb-* | armv*-* \ ++ | avr-* | avr32-* \ ++ | ba-* \ ++ | be32-* | be64-* \ ++ | bfin-* | bs2000-* \ ++ | c[123]* | c30-* | [cjt]90-* | c4x-* \ ++ | c8051-* | clipper-* | craynv-* | cydra-* \ ++ | d10v-* | d30v-* | dlx-* \ ++ | e2k-* | elxsi-* \ ++ | f30[01]-* | f700-* | fido-* | fr30-* | frv-* | fx80-* \ ++ | h8300-* | h8500-* \ ++ | hppa-* | hppa1.[01]-* | hppa2.0-* | hppa2.0[nw]-* | hppa64-* \ ++ | hexagon-* \ ++ | i*86-* | i860-* | i960-* | ia16-* | ia64-* \ ++ | ip2k-* | iq2000-* \ ++ | k1om-* \ ++ | le32-* | le64-* \ ++ | lm32-* \ ++ | m32c-* | m32r-* | m32rle-* \ ++ | m68000-* | m680[012346]0-* | m68360-* | m683?2-* | m68k-* \ ++ | m88110-* | m88k-* | maxq-* | mcore-* | metag-* \ ++ | microblaze-* | microblazeel-* \ ++ | mips-* | mipsbe-* | mipseb-* | mipsel-* | mipsle-* \ ++ | mips16-* \ ++ | mips64-* | mips64el-* \ ++ | mips64octeon-* | mips64octeonel-* \ ++ | mips64orion-* | mips64orionel-* \ ++ | mips64r5900-* | mips64r5900el-* \ ++ | mips64vr-* | mips64vrel-* \ ++ | mips64vr4100-* | mips64vr4100el-* \ ++ | mips64vr4300-* | mips64vr4300el-* \ ++ | mips64vr5000-* | mips64vr5000el-* \ ++ | mips64vr5900-* | mips64vr5900el-* \ ++ | mipsisa32-* | mipsisa32el-* \ ++ | mipsisa32r2-* | mipsisa32r2el-* \ ++ | mipsisa32r6-* | mipsisa32r6el-* \ ++ | mipsisa64-* | mipsisa64el-* \ ++ | mipsisa64r2-* | mipsisa64r2el-* \ ++ | mipsisa64r6-* | mipsisa64r6el-* \ ++ | mipsisa64sb1-* | mipsisa64sb1el-* \ ++ | mipsisa64sr71k-* | mipsisa64sr71kel-* \ ++ | mipsr5900-* | mipsr5900el-* \ ++ | mipstx39-* | mipstx39el-* \ ++ | mmix-* \ ++ | mt-* \ ++ | msp430-* \ ++ | nds32-* | nds32le-* | nds32be-* \ ++ | nios-* | nios2-* | nios2eb-* | nios2el-* \ ++ | none-* | np1-* | ns16k-* | ns32k-* \ ++ | open8-* \ ++ | or1k*-* \ ++ | orion-* \ ++ | pdp10-* | pdp11-* | pj-* | pjl-* | pn-* | power-* \ ++ | powerpc-* | powerpc64-* | powerpc64le-* | powerpcle-* \ ++ | pru-* \ ++ | pyramid-* \ ++ | riscv32-* | riscv64-* \ ++ | rl78-* | romp-* | rs6000-* | rx-* \ ++ | sh-* | sh[1234]-* | sh[24]a-* | sh[24]aeb-* | sh[23]e-* | sh[34]eb-* | sheb-* | shbe-* \ ++ | shle-* | sh[1234]le-* | sh3ele-* | sh64-* | sh64le-* \ ++ | sparc-* | sparc64-* | sparc64b-* | sparc64v-* | sparc86x-* | sparclet-* \ ++ | sparclite-* \ ++ | sparcv8-* | sparcv9-* | sparcv9b-* | sparcv9v-* | sv1-* | sx*-* \ ++ | tahoe-* \ ++ | tic30-* | tic4x-* | tic54x-* | tic55x-* | tic6x-* | tic80-* \ ++ | tile*-* \ ++ | tron-* \ ++ | ubicom32-* \ ++ | v850-* | v850e-* | v850e1-* | v850es-* | v850e2-* | v850e2v3-* \ ++ | vax-* \ ++ | visium-* \ ++ | wasm32-* \ ++ | we32k-* \ ++ | x86-* | x86_64-* | xc16x-* | xps100-* \ ++ | xstormy16-* | xtensa*-* \ ++ | ymp-* \ ++ | z8k-* | z80-*) ++ ;; ++ # Recognize the basic CPU types without company name, with glob match. ++ xtensa*) ++ basic_machine=$basic_machine-unknown ++ ;; ++ # Recognize the various machine names and aliases which stand ++ # for a CPU type and a company and sometimes even an OS. ++ 386bsd) ++ basic_machine=i386-pc ++ os=-bsd ++ ;; ++ 3b1 | 7300 | 7300-att | att-7300 | pc7300 | safari | unixpc) ++ basic_machine=m68000-att ++ ;; ++ 3b*) ++ basic_machine=we32k-att ++ ;; ++ a29khif) ++ basic_machine=a29k-amd ++ os=-udi ++ ;; ++ abacus) ++ basic_machine=abacus-unknown ++ ;; ++ adobe68k) ++ basic_machine=m68010-adobe ++ os=-scout ++ ;; ++ alliant | fx80) ++ basic_machine=fx80-alliant ++ ;; ++ altos | altos3068) ++ basic_machine=m68k-altos ++ ;; ++ am29k) ++ basic_machine=a29k-none ++ os=-bsd ++ ;; ++ amd64) ++ basic_machine=x86_64-pc ++ ;; ++ amd64-*) ++ basic_machine=x86_64-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ amdahl) ++ basic_machine=580-amdahl ++ os=-sysv ++ ;; ++ amiga | amiga-*) ++ basic_machine=m68k-unknown ++ ;; ++ amigaos | amigados) ++ basic_machine=m68k-unknown ++ os=-amigaos ++ ;; ++ amigaunix | amix) ++ basic_machine=m68k-unknown ++ os=-sysv4 ++ ;; ++ apollo68) ++ basic_machine=m68k-apollo ++ os=-sysv ++ ;; ++ apollo68bsd) ++ basic_machine=m68k-apollo ++ os=-bsd ++ ;; ++ aros) ++ basic_machine=i386-pc ++ os=-aros ++ ;; ++ asmjs) ++ basic_machine=asmjs-unknown ++ ;; ++ aux) ++ basic_machine=m68k-apple ++ os=-aux ++ ;; ++ balance) ++ basic_machine=ns32k-sequent ++ os=-dynix ++ ;; ++ blackfin) ++ basic_machine=bfin-unknown ++ os=-linux ++ ;; ++ blackfin-*) ++ basic_machine=bfin-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ os=-linux ++ ;; ++ bluegene*) ++ basic_machine=powerpc-ibm ++ os=-cnk ++ ;; ++ c54x-*) ++ basic_machine=tic54x-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ c55x-*) ++ basic_machine=tic55x-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ c6x-*) ++ basic_machine=tic6x-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ c90) ++ basic_machine=c90-cray ++ os=-unicos ++ ;; ++ cegcc) ++ basic_machine=arm-unknown ++ os=-cegcc ++ ;; ++ convex-c1) ++ basic_machine=c1-convex ++ os=-bsd ++ ;; ++ convex-c2) ++ basic_machine=c2-convex ++ os=-bsd ++ ;; ++ convex-c32) ++ basic_machine=c32-convex ++ os=-bsd ++ ;; ++ convex-c34) ++ basic_machine=c34-convex ++ os=-bsd ++ ;; ++ convex-c38) ++ basic_machine=c38-convex ++ os=-bsd ++ ;; ++ cray | j90) ++ basic_machine=j90-cray ++ os=-unicos ++ ;; ++ craynv) ++ basic_machine=craynv-cray ++ os=-unicosmp ++ ;; ++ cr16 | cr16-*) ++ basic_machine=cr16-unknown ++ os=-elf ++ ;; ++ crds | unos) ++ basic_machine=m68k-crds ++ ;; ++ crisv32 | crisv32-* | etraxfs*) ++ basic_machine=crisv32-axis ++ ;; ++ cris | cris-* | etrax*) ++ basic_machine=cris-axis ++ ;; ++ crx) ++ basic_machine=crx-unknown ++ os=-elf ++ ;; ++ da30 | da30-*) ++ basic_machine=m68k-da30 ++ ;; ++ decstation | decstation-3100 | pmax | pmax-* | pmin | dec3100 | decstatn) ++ basic_machine=mips-dec ++ ;; ++ decsystem10* | dec10*) ++ basic_machine=pdp10-dec ++ os=-tops10 ++ ;; ++ decsystem20* | dec20*) ++ basic_machine=pdp10-dec ++ os=-tops20 ++ ;; ++ delta | 3300 | motorola-3300 | motorola-delta \ ++ | 3300-motorola | delta-motorola) ++ basic_machine=m68k-motorola ++ ;; ++ delta88) ++ basic_machine=m88k-motorola ++ os=-sysv3 ++ ;; ++ dicos) ++ basic_machine=i686-pc ++ os=-dicos ++ ;; ++ djgpp) ++ basic_machine=i586-pc ++ os=-msdosdjgpp ++ ;; ++ dpx20 | dpx20-*) ++ basic_machine=rs6000-bull ++ os=-bosx ++ ;; ++ dpx2*) ++ basic_machine=m68k-bull ++ os=-sysv3 ++ ;; ++ e500v[12]) ++ basic_machine=powerpc-unknown ++ os=$os"spe" ++ ;; ++ e500v[12]-*) ++ basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ os=$os"spe" ++ ;; ++ ebmon29k) ++ basic_machine=a29k-amd ++ os=-ebmon ++ ;; ++ elxsi) ++ basic_machine=elxsi-elxsi ++ os=-bsd ++ ;; ++ encore | umax | mmax) ++ basic_machine=ns32k-encore ++ ;; ++ es1800 | OSE68k | ose68k | ose | OSE) ++ basic_machine=m68k-ericsson ++ os=-ose ++ ;; ++ fx2800) ++ basic_machine=i860-alliant ++ ;; ++ genix) ++ basic_machine=ns32k-ns ++ ;; ++ gmicro) ++ basic_machine=tron-gmicro ++ os=-sysv ++ ;; ++ go32) ++ basic_machine=i386-pc ++ os=-go32 ++ ;; ++ h3050r* | hiux*) ++ basic_machine=hppa1.1-hitachi ++ os=-hiuxwe2 ++ ;; ++ h8300hms) ++ basic_machine=h8300-hitachi ++ os=-hms ++ ;; ++ h8300xray) ++ basic_machine=h8300-hitachi ++ os=-xray ++ ;; ++ h8500hms) ++ basic_machine=h8500-hitachi ++ os=-hms ++ ;; ++ harris) ++ basic_machine=m88k-harris ++ os=-sysv3 ++ ;; ++ hp300-*) ++ basic_machine=m68k-hp ++ ;; ++ hp300bsd) ++ basic_machine=m68k-hp ++ os=-bsd ++ ;; ++ hp300hpux) ++ basic_machine=m68k-hp ++ os=-hpux ++ ;; ++ hp3k9[0-9][0-9] | hp9[0-9][0-9]) ++ basic_machine=hppa1.0-hp ++ ;; ++ hp9k2[0-9][0-9] | hp9k31[0-9]) ++ basic_machine=m68000-hp ++ ;; ++ hp9k3[2-9][0-9]) ++ basic_machine=m68k-hp ++ ;; ++ hp9k6[0-9][0-9] | hp6[0-9][0-9]) ++ basic_machine=hppa1.0-hp ++ ;; ++ hp9k7[0-79][0-9] | hp7[0-79][0-9]) ++ basic_machine=hppa1.1-hp ++ ;; ++ hp9k78[0-9] | hp78[0-9]) ++ # FIXME: really hppa2.0-hp ++ basic_machine=hppa1.1-hp ++ ;; ++ hp9k8[67]1 | hp8[67]1 | hp9k80[24] | hp80[24] | hp9k8[78]9 | hp8[78]9 | hp9k893 | hp893) ++ # FIXME: really hppa2.0-hp ++ basic_machine=hppa1.1-hp ++ ;; ++ hp9k8[0-9][13679] | hp8[0-9][13679]) ++ basic_machine=hppa1.1-hp ++ ;; ++ hp9k8[0-9][0-9] | hp8[0-9][0-9]) ++ basic_machine=hppa1.0-hp ++ ;; ++ hppaosf) ++ basic_machine=hppa1.1-hp ++ os=-osf ++ ;; ++ hppro) ++ basic_machine=hppa1.1-hp ++ os=-proelf ++ ;; ++ i370-ibm* | ibm*) ++ basic_machine=i370-ibm ++ ;; ++ i*86v32) ++ basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` ++ os=-sysv32 ++ ;; ++ i*86v4*) ++ basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` ++ os=-sysv4 ++ ;; ++ i*86v) ++ basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` ++ os=-sysv ++ ;; ++ i*86sol2) ++ basic_machine=`echo "$1" | sed -e 's/86.*/86-pc/'` ++ os=-solaris2 ++ ;; ++ i386mach) ++ basic_machine=i386-mach ++ os=-mach ++ ;; ++ vsta) ++ basic_machine=i386-unknown ++ os=-vsta ++ ;; ++ iris | iris4d) ++ basic_machine=mips-sgi ++ case $os in ++ -irix*) ++ ;; ++ *) ++ os=-irix4 ++ ;; ++ esac ++ ;; ++ isi68 | isi) ++ basic_machine=m68k-isi ++ os=-sysv ++ ;; ++ leon-*|leon[3-9]-*) ++ basic_machine=sparc-`echo "$basic_machine" | sed 's/-.*//'` ++ ;; ++ m68knommu) ++ basic_machine=m68k-unknown ++ os=-linux ++ ;; ++ m68knommu-*) ++ basic_machine=m68k-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ os=-linux ++ ;; ++ magnum | m3230) ++ basic_machine=mips-mips ++ os=-sysv ++ ;; ++ merlin) ++ basic_machine=ns32k-utek ++ os=-sysv ++ ;; ++ microblaze*) ++ basic_machine=microblaze-xilinx ++ ;; ++ mingw64) ++ basic_machine=x86_64-pc ++ os=-mingw64 ++ ;; ++ mingw32) ++ basic_machine=i686-pc ++ os=-mingw32 ++ ;; ++ mingw32ce) ++ basic_machine=arm-unknown ++ os=-mingw32ce ++ ;; ++ miniframe) ++ basic_machine=m68000-convergent ++ ;; ++ *mint | -mint[0-9]* | *MiNT | *MiNT[0-9]*) ++ basic_machine=m68k-atari ++ os=-mint ++ ;; ++ mips3*-*) ++ basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'` ++ ;; ++ mips3*) ++ basic_machine=`echo "$basic_machine" | sed -e 's/mips3/mips64/'`-unknown ++ ;; ++ monitor) ++ basic_machine=m68k-rom68k ++ os=-coff ++ ;; ++ morphos) ++ basic_machine=powerpc-unknown ++ os=-morphos ++ ;; ++ moxiebox) ++ basic_machine=moxie-unknown ++ os=-moxiebox ++ ;; ++ msdos) ++ basic_machine=i386-pc ++ os=-msdos ++ ;; ++ ms1-*) ++ basic_machine=`echo "$basic_machine" | sed -e 's/ms1-/mt-/'` ++ ;; ++ msys) ++ basic_machine=i686-pc ++ os=-msys ++ ;; ++ mvs) ++ basic_machine=i370-ibm ++ os=-mvs ++ ;; ++ nacl) ++ basic_machine=le32-unknown ++ os=-nacl ++ ;; ++ ncr3000) ++ basic_machine=i486-ncr ++ os=-sysv4 ++ ;; ++ netbsd386) ++ basic_machine=i386-unknown ++ os=-netbsd ++ ;; ++ netwinder) ++ basic_machine=armv4l-rebel ++ os=-linux ++ ;; ++ news | news700 | news800 | news900) ++ basic_machine=m68k-sony ++ os=-newsos ++ ;; ++ news1000) ++ basic_machine=m68030-sony ++ os=-newsos ++ ;; ++ news-3600 | risc-news) ++ basic_machine=mips-sony ++ os=-newsos ++ ;; ++ necv70) ++ basic_machine=v70-nec ++ os=-sysv ++ ;; ++ next | m*-next) ++ basic_machine=m68k-next ++ case $os in ++ -nextstep* ) ++ ;; ++ -ns2*) ++ os=-nextstep2 ++ ;; ++ *) ++ os=-nextstep3 ++ ;; ++ esac ++ ;; ++ nh3000) ++ basic_machine=m68k-harris ++ os=-cxux ++ ;; ++ nh[45]000) ++ basic_machine=m88k-harris ++ os=-cxux ++ ;; ++ nindy960) ++ basic_machine=i960-intel ++ os=-nindy ++ ;; ++ mon960) ++ basic_machine=i960-intel ++ os=-mon960 ++ ;; ++ nonstopux) ++ basic_machine=mips-compaq ++ os=-nonstopux ++ ;; ++ np1) ++ basic_machine=np1-gould ++ ;; ++ neo-tandem) ++ basic_machine=neo-tandem ++ ;; ++ nse-tandem) ++ basic_machine=nse-tandem ++ ;; ++ nsr-tandem) ++ basic_machine=nsr-tandem ++ ;; ++ nsv-tandem) ++ basic_machine=nsv-tandem ++ ;; ++ nsx-tandem) ++ basic_machine=nsx-tandem ++ ;; ++ op50n-* | op60c-*) ++ basic_machine=hppa1.1-oki ++ os=-proelf ++ ;; ++ openrisc | openrisc-*) ++ basic_machine=or32-unknown ++ ;; ++ os400) ++ basic_machine=powerpc-ibm ++ os=-os400 ++ ;; ++ OSE68000 | ose68000) ++ basic_machine=m68000-ericsson ++ os=-ose ++ ;; ++ os68k) ++ basic_machine=m68k-none ++ os=-os68k ++ ;; ++ pa-hitachi) ++ basic_machine=hppa1.1-hitachi ++ os=-hiuxwe2 ++ ;; ++ paragon) ++ basic_machine=i860-intel ++ os=-osf ++ ;; ++ parisc) ++ basic_machine=hppa-unknown ++ os=-linux ++ ;; ++ parisc-*) ++ basic_machine=hppa-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ os=-linux ++ ;; ++ pbd) ++ basic_machine=sparc-tti ++ ;; ++ pbb) ++ basic_machine=m68k-tti ++ ;; ++ pc532 | pc532-*) ++ basic_machine=ns32k-pc532 ++ ;; ++ pc98) ++ basic_machine=i386-pc ++ ;; ++ pc98-*) ++ basic_machine=i386-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ pentium | p5 | k5 | k6 | nexgen | viac3) ++ basic_machine=i586-pc ++ ;; ++ pentiumpro | p6 | 6x86 | athlon | athlon_*) ++ basic_machine=i686-pc ++ ;; ++ pentiumii | pentium2 | pentiumiii | pentium3) ++ basic_machine=i686-pc ++ ;; ++ pentium4) ++ basic_machine=i786-pc ++ ;; ++ pentium-* | p5-* | k5-* | k6-* | nexgen-* | viac3-*) ++ basic_machine=i586-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ pentiumpro-* | p6-* | 6x86-* | athlon-*) ++ basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ pentiumii-* | pentium2-* | pentiumiii-* | pentium3-*) ++ basic_machine=i686-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ pentium4-*) ++ basic_machine=i786-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ pn) ++ basic_machine=pn-gould ++ ;; ++ power) basic_machine=power-ibm ++ ;; ++ ppc | ppcbe) basic_machine=powerpc-unknown ++ ;; ++ ppc-* | ppcbe-*) ++ basic_machine=powerpc-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ ppcle | powerpclittle) ++ basic_machine=powerpcle-unknown ++ ;; ++ ppcle-* | powerpclittle-*) ++ basic_machine=powerpcle-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ ppc64) basic_machine=powerpc64-unknown ++ ;; ++ ppc64-*) basic_machine=powerpc64-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ ppc64le | powerpc64little) ++ basic_machine=powerpc64le-unknown ++ ;; ++ ppc64le-* | powerpc64little-*) ++ basic_machine=powerpc64le-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ ps2) ++ basic_machine=i386-ibm ++ ;; ++ pw32) ++ basic_machine=i586-unknown ++ os=-pw32 ++ ;; ++ rdos | rdos64) ++ basic_machine=x86_64-pc ++ os=-rdos ++ ;; ++ rdos32) ++ basic_machine=i386-pc ++ os=-rdos ++ ;; ++ rom68k) ++ basic_machine=m68k-rom68k ++ os=-coff ++ ;; ++ rm[46]00) ++ basic_machine=mips-siemens ++ ;; ++ rtpc | rtpc-*) ++ basic_machine=romp-ibm ++ ;; ++ s390 | s390-*) ++ basic_machine=s390-ibm ++ ;; ++ s390x | s390x-*) ++ basic_machine=s390x-ibm ++ ;; ++ sa29200) ++ basic_machine=a29k-amd ++ os=-udi ++ ;; ++ sb1) ++ basic_machine=mipsisa64sb1-unknown ++ ;; ++ sb1el) ++ basic_machine=mipsisa64sb1el-unknown ++ ;; ++ sde) ++ basic_machine=mipsisa32-sde ++ os=-elf ++ ;; ++ sei) ++ basic_machine=mips-sei ++ os=-seiux ++ ;; ++ sequent) ++ basic_machine=i386-sequent ++ ;; ++ sh5el) ++ basic_machine=sh5le-unknown ++ ;; ++ simso-wrs) ++ basic_machine=sparclite-wrs ++ os=-vxworks ++ ;; ++ sps7) ++ basic_machine=m68k-bull ++ os=-sysv2 ++ ;; ++ spur) ++ basic_machine=spur-unknown ++ ;; ++ st2000) ++ basic_machine=m68k-tandem ++ ;; ++ stratus) ++ basic_machine=i860-stratus ++ os=-sysv4 ++ ;; ++ strongarm-* | thumb-*) ++ basic_machine=arm-`echo "$basic_machine" | sed 's/^[^-]*-//'` ++ ;; ++ sun2) ++ basic_machine=m68000-sun ++ ;; ++ sun2os3) ++ basic_machine=m68000-sun ++ os=-sunos3 ++ ;; ++ sun2os4) ++ basic_machine=m68000-sun ++ os=-sunos4 ++ ;; ++ sun3os3) ++ basic_machine=m68k-sun ++ os=-sunos3 ++ ;; ++ sun3os4) ++ basic_machine=m68k-sun ++ os=-sunos4 ++ ;; ++ sun4os3) ++ basic_machine=sparc-sun ++ os=-sunos3 ++ ;; ++ sun4os4) ++ basic_machine=sparc-sun ++ os=-sunos4 ++ ;; ++ sun4sol2) ++ basic_machine=sparc-sun ++ os=-solaris2 ++ ;; ++ sun3 | sun3-*) ++ basic_machine=m68k-sun ++ ;; ++ sun4) ++ basic_machine=sparc-sun ++ ;; ++ sun386 | sun386i | roadrunner) ++ basic_machine=i386-sun ++ ;; ++ sv1) ++ basic_machine=sv1-cray ++ os=-unicos ++ ;; ++ symmetry) ++ basic_machine=i386-sequent ++ os=-dynix ++ ;; ++ t3e) ++ basic_machine=alphaev5-cray ++ os=-unicos ++ ;; ++ t90) ++ basic_machine=t90-cray ++ os=-unicos ++ ;; ++ tile*) ++ basic_machine=$basic_machine-unknown ++ os=-linux-gnu ++ ;; ++ tx39) ++ basic_machine=mipstx39-unknown ++ ;; ++ tx39el) ++ basic_machine=mipstx39el-unknown ++ ;; ++ toad1) ++ basic_machine=pdp10-xkl ++ os=-tops20 ++ ;; ++ tower | tower-32) ++ basic_machine=m68k-ncr ++ ;; ++ tpf) ++ basic_machine=s390x-ibm ++ os=-tpf ++ ;; ++ udi29k) ++ basic_machine=a29k-amd ++ os=-udi ++ ;; ++ ultra3) ++ basic_machine=a29k-nyu ++ os=-sym1 ++ ;; ++ v810 | necv810) ++ basic_machine=v810-nec ++ os=-none ++ ;; ++ vaxv) ++ basic_machine=vax-dec ++ os=-sysv ++ ;; ++ vms) ++ basic_machine=vax-dec ++ os=-vms ++ ;; ++ vpp*|vx|vx-*) ++ basic_machine=f301-fujitsu ++ ;; ++ vxworks960) ++ basic_machine=i960-wrs ++ os=-vxworks ++ ;; ++ vxworks68) ++ basic_machine=m68k-wrs ++ os=-vxworks ++ ;; ++ vxworks29k) ++ basic_machine=a29k-wrs ++ os=-vxworks ++ ;; ++ w65*) ++ basic_machine=w65-wdc ++ os=-none ++ ;; ++ w89k-*) ++ basic_machine=hppa1.1-winbond ++ os=-proelf ++ ;; ++ x64) ++ basic_machine=x86_64-pc ++ ;; ++ xbox) ++ basic_machine=i686-pc ++ os=-mingw32 ++ ;; ++ xps | xps100) ++ basic_machine=xps100-honeywell ++ ;; ++ xscale-* | xscalee[bl]-*) ++ basic_machine=`echo "$basic_machine" | sed 's/^xscale/arm/'` ++ ;; ++ ymp) ++ basic_machine=ymp-cray ++ os=-unicos ++ ;; ++ none) ++ basic_machine=none-none ++ os=-none ++ ;; ++ ++# Here we handle the default manufacturer of certain CPU types. It is in ++# some cases the only manufacturer, in others, it is the most popular. ++ w89k) ++ basic_machine=hppa1.1-winbond ++ ;; ++ op50n) ++ basic_machine=hppa1.1-oki ++ ;; ++ op60c) ++ basic_machine=hppa1.1-oki ++ ;; ++ romp) ++ basic_machine=romp-ibm ++ ;; ++ mmix) ++ basic_machine=mmix-knuth ++ ;; ++ rs6000) ++ basic_machine=rs6000-ibm ++ ;; ++ vax) ++ basic_machine=vax-dec ++ ;; ++ pdp11) ++ basic_machine=pdp11-dec ++ ;; ++ we32k) ++ basic_machine=we32k-att ++ ;; ++ sh[1234] | sh[24]a | sh[24]aeb | sh[34]eb | sh[1234]le | sh[23]ele) ++ basic_machine=sh-unknown ++ ;; ++ cydra) ++ basic_machine=cydra-cydrome ++ ;; ++ orion) ++ basic_machine=orion-highlevel ++ ;; ++ orion105) ++ basic_machine=clipper-highlevel ++ ;; ++ mac | mpw | mac-mpw) ++ basic_machine=m68k-apple ++ ;; ++ pmac | pmac-mpw) ++ basic_machine=powerpc-apple ++ ;; ++ *-unknown) ++ # Make sure to match an already-canonicalized machine name. ++ ;; ++ *) ++ echo Invalid configuration \`"$1"\': machine \`"$basic_machine"\' not recognized 1>&2 ++ exit 1 ++ ;; ++esac ++ ++# Here we canonicalize certain aliases for manufacturers. ++case $basic_machine in ++ *-digital*) ++ basic_machine=`echo "$basic_machine" | sed 's/digital.*/dec/'` ++ ;; ++ *-commodore*) ++ basic_machine=`echo "$basic_machine" | sed 's/commodore.*/cbm/'` ++ ;; ++ *) ++ ;; ++esac ++ ++# Decode manufacturer-specific aliases for certain operating systems. ++ ++if [ x"$os" != x"" ] ++then ++case $os in ++ # First match some system type aliases that might get confused ++ # with valid system types. ++ # -solaris* is a basic system type, with this one exception. ++ -auroraux) ++ os=-auroraux ++ ;; ++ -solaris1 | -solaris1.*) ++ os=`echo $os | sed -e 's|solaris1|sunos4|'` ++ ;; ++ -solaris) ++ os=-solaris2 ++ ;; ++ -unixware*) ++ os=-sysv4.2uw ++ ;; ++ -gnu/linux*) ++ os=`echo $os | sed -e 's|gnu/linux|linux-gnu|'` ++ ;; ++ # es1800 is here to avoid being matched by es* (a different OS) ++ -es1800*) ++ os=-ose ++ ;; ++ # Now accept the basic system types. ++ # The portable systems comes first. ++ # Each alternative MUST end in a * to match a version number. ++ # -sysv* is not here because it comes later, after sysvr4. ++ -gnu* | -bsd* | -mach* | -minix* | -genix* | -ultrix* | -irix* \ ++ | -*vms* | -sco* | -esix* | -isc* | -aix* | -cnk* | -sunos | -sunos[34]*\ ++ | -hpux* | -unos* | -osf* | -luna* | -dgux* | -auroraux* | -solaris* \ ++ | -sym* | -kopensolaris* | -plan9* \ ++ | -amigaos* | -amigados* | -msdos* | -newsos* | -unicos* | -aof* \ ++ | -aos* | -aros* | -cloudabi* | -sortix* \ ++ | -nindy* | -vxsim* | -vxworks* | -ebmon* | -hms* | -mvs* \ ++ | -clix* | -riscos* | -uniplus* | -iris* | -rtu* | -xenix* \ ++ | -hiux* | -knetbsd* | -mirbsd* | -netbsd* \ ++ | -bitrig* | -openbsd* | -solidbsd* | -libertybsd* \ ++ | -ekkobsd* | -kfreebsd* | -freebsd* | -riscix* | -lynxos* \ ++ | -bosx* | -nextstep* | -cxux* | -aout* | -elf* | -oabi* \ ++ | -ptx* | -coff* | -ecoff* | -winnt* | -domain* | -vsta* \ ++ | -udi* | -eabi* | -lites* | -ieee* | -go32* | -aux* \ ++ | -chorusos* | -chorusrdb* | -cegcc* | -glidix* \ ++ | -cygwin* | -msys* | -pe* | -psos* | -moss* | -proelf* | -rtems* \ ++ | -midipix* | -mingw32* | -mingw64* | -linux-gnu* | -linux-android* \ ++ | -linux-newlib* | -linux-musl* | -linux-uclibc* \ ++ | -uxpv* | -beos* | -mpeix* | -udk* | -moxiebox* \ ++ | -interix* | -uwin* | -mks* | -rhapsody* | -darwin* \ ++ | -openstep* | -oskit* | -conix* | -pw32* | -nonstopux* \ ++ | -storm-chaos* | -tops10* | -tenex* | -tops20* | -its* \ ++ | -os2* | -vos* | -palmos* | -uclinux* | -nucleus* \ ++ | -morphos* | -superux* | -rtmk* | -windiss* \ ++ | -powermax* | -dnix* | -nx6 | -nx7 | -sei* | -dragonfly* \ ++ | -skyos* | -haiku* | -rdos* | -toppers* | -drops* | -es* \ ++ | -onefs* | -tirtos* | -phoenix* | -fuchsia* | -redox* | -bme* \ ++ | -midnightbsd*) ++ # Remember, each alternative MUST END IN *, to match a version number. ++ ;; ++ -qnx*) ++ case $basic_machine in ++ x86-* | i*86-*) ++ ;; ++ *) ++ os=-nto$os ++ ;; ++ esac ++ ;; ++ -nto-qnx*) ++ ;; ++ -nto*) ++ os=`echo $os | sed -e 's|nto|nto-qnx|'` ++ ;; ++ -sim | -xray | -os68k* | -v88r* \ ++ | -windows* | -osx | -abug | -netware* | -os9* \ ++ | -macos* | -mpw* | -magic* | -mmixware* | -mon960* | -lnews*) ++ ;; ++ -mac*) ++ os=`echo "$os" | sed -e 's|mac|macos|'` ++ ;; ++ -linux-dietlibc) ++ os=-linux-dietlibc ++ ;; ++ -linux*) ++ os=`echo $os | sed -e 's|linux|linux-gnu|'` ++ ;; ++ -sunos5*) ++ os=`echo "$os" | sed -e 's|sunos5|solaris2|'` ++ ;; ++ -sunos6*) ++ os=`echo "$os" | sed -e 's|sunos6|solaris3|'` ++ ;; ++ -opened*) ++ os=-openedition ++ ;; ++ -os400*) ++ os=-os400 ++ ;; ++ -wince*) ++ os=-wince ++ ;; ++ -utek*) ++ os=-bsd ++ ;; ++ -dynix*) ++ os=-bsd ++ ;; ++ -acis*) ++ os=-aos ++ ;; ++ -atheos*) ++ os=-atheos ++ ;; ++ -syllable*) ++ os=-syllable ++ ;; ++ -386bsd) ++ os=-bsd ++ ;; ++ -ctix* | -uts*) ++ os=-sysv ++ ;; ++ -nova*) ++ os=-rtmk-nova ++ ;; ++ -ns2) ++ os=-nextstep2 ++ ;; ++ -nsk*) ++ os=-nsk ++ ;; ++ # Preserve the version number of sinix5. ++ -sinix5.*) ++ os=`echo $os | sed -e 's|sinix|sysv|'` ++ ;; ++ -sinix*) ++ os=-sysv4 ++ ;; ++ -tpf*) ++ os=-tpf ++ ;; ++ -triton*) ++ os=-sysv3 ++ ;; ++ -oss*) ++ os=-sysv3 ++ ;; ++ -svr4*) ++ os=-sysv4 ++ ;; ++ -svr3) ++ os=-sysv3 ++ ;; ++ -sysvr4) ++ os=-sysv4 ++ ;; ++ # This must come after -sysvr4. ++ -sysv*) ++ ;; ++ -ose*) ++ os=-ose ++ ;; ++ -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) ++ os=-mint ++ ;; ++ -zvmoe) ++ os=-zvmoe ++ ;; ++ -dicos*) ++ os=-dicos ++ ;; ++ -pikeos*) ++ # Until real need of OS specific support for ++ # particular features comes up, bare metal ++ # configurations are quite functional. ++ case $basic_machine in ++ arm*) ++ os=-eabi ++ ;; ++ *) ++ os=-elf ++ ;; ++ esac ++ ;; ++ -nacl*) ++ ;; ++ -ios) ++ ;; ++ -none) ++ ;; ++ *) ++ # Get rid of the `-' at the beginning of $os. ++ os=`echo $os | sed 's/[^-]*-//'` ++ echo Invalid configuration \`"$1"\': system \`"$os"\' not recognized 1>&2 ++ exit 1 ++ ;; ++esac ++else ++ ++# Here we handle the default operating systems that come with various machines. ++# The value should be what the vendor currently ships out the door with their ++# machine or put another way, the most popular os provided with the machine. ++ ++# Note that if you're going to try to match "-MANUFACTURER" here (say, ++# "-sun"), then you have to tell the case statement up towards the top ++# that MANUFACTURER isn't an operating system. Otherwise, code above ++# will signal an error saying that MANUFACTURER isn't an operating ++# system, and we'll never get to this point. ++ ++case $basic_machine in ++ score-*) ++ os=-elf ++ ;; ++ spu-*) ++ os=-elf ++ ;; ++ *-acorn) ++ os=-riscix1.2 ++ ;; ++ arm*-rebel) ++ os=-linux ++ ;; ++ arm*-semi) ++ os=-aout ++ ;; ++ c4x-* | tic4x-*) ++ os=-coff ++ ;; ++ c8051-*) ++ os=-elf ++ ;; ++ hexagon-*) ++ os=-elf ++ ;; ++ tic54x-*) ++ os=-coff ++ ;; ++ tic55x-*) ++ os=-coff ++ ;; ++ tic6x-*) ++ os=-coff ++ ;; ++ # This must come before the *-dec entry. ++ pdp10-*) ++ os=-tops20 ++ ;; ++ pdp11-*) ++ os=-none ++ ;; ++ *-dec | vax-*) ++ os=-ultrix4.2 ++ ;; ++ m68*-apollo) ++ os=-domain ++ ;; ++ i386-sun) ++ os=-sunos4.0.2 ++ ;; ++ m68000-sun) ++ os=-sunos3 ++ ;; ++ m68*-cisco) ++ os=-aout ++ ;; ++ mep-*) ++ os=-elf ++ ;; ++ mips*-cisco) ++ os=-elf ++ ;; ++ mips*-*) ++ os=-elf ++ ;; ++ or32-*) ++ os=-coff ++ ;; ++ *-tti) # must be before sparc entry or we get the wrong os. ++ os=-sysv3 ++ ;; ++ sparc-* | *-sun) ++ os=-sunos4.1.1 ++ ;; ++ pru-*) ++ os=-elf ++ ;; ++ *-be) ++ os=-beos ++ ;; ++ *-ibm) ++ os=-aix ++ ;; ++ *-knuth) ++ os=-mmixware ++ ;; ++ *-wec) ++ os=-proelf ++ ;; ++ *-winbond) ++ os=-proelf ++ ;; ++ *-oki) ++ os=-proelf ++ ;; ++ *-hp) ++ os=-hpux ++ ;; ++ *-hitachi) ++ os=-hiux ++ ;; ++ i860-* | *-att | *-ncr | *-altos | *-motorola | *-convergent) ++ os=-sysv ++ ;; ++ *-cbm) ++ os=-amigaos ++ ;; ++ *-dg) ++ os=-dgux ++ ;; ++ *-dolphin) ++ os=-sysv3 ++ ;; ++ m68k-ccur) ++ os=-rtu ++ ;; ++ m88k-omron*) ++ os=-luna ++ ;; ++ *-next) ++ os=-nextstep ++ ;; ++ *-sequent) ++ os=-ptx ++ ;; ++ *-crds) ++ os=-unos ++ ;; ++ *-ns) ++ os=-genix ++ ;; ++ i370-*) ++ os=-mvs ++ ;; ++ *-gould) ++ os=-sysv ++ ;; ++ *-highlevel) ++ os=-bsd ++ ;; ++ *-encore) ++ os=-bsd ++ ;; ++ *-sgi) ++ os=-irix ++ ;; ++ *-siemens) ++ os=-sysv4 ++ ;; ++ *-masscomp) ++ os=-rtu ++ ;; ++ f30[01]-fujitsu | f700-fujitsu) ++ os=-uxpv ++ ;; ++ *-rom68k) ++ os=-coff ++ ;; ++ *-*bug) ++ os=-coff ++ ;; ++ *-apple) ++ os=-macos ++ ;; ++ *-atari*) ++ os=-mint ++ ;; ++ *) ++ os=-none ++ ;; ++esac ++fi ++ ++# Here we handle the case where we know the os, and the CPU type, but not the ++# manufacturer. We pick the logical manufacturer. ++vendor=unknown ++case $basic_machine in ++ *-unknown) ++ case $os in ++ -riscix*) ++ vendor=acorn ++ ;; ++ -sunos*) ++ vendor=sun ++ ;; ++ -cnk*|-aix*) ++ vendor=ibm ++ ;; ++ -beos*) ++ vendor=be ++ ;; ++ -hpux*) ++ vendor=hp ++ ;; ++ -mpeix*) ++ vendor=hp ++ ;; ++ -hiux*) ++ vendor=hitachi ++ ;; ++ -unos*) ++ vendor=crds ++ ;; ++ -dgux*) ++ vendor=dg ++ ;; ++ -luna*) ++ vendor=omron ++ ;; ++ -genix*) ++ vendor=ns ++ ;; ++ -mvs* | -opened*) ++ vendor=ibm ++ ;; ++ -os400*) ++ vendor=ibm ++ ;; ++ -ptx*) ++ vendor=sequent ++ ;; ++ -tpf*) ++ vendor=ibm ++ ;; ++ -vxsim* | -vxworks* | -windiss*) ++ vendor=wrs ++ ;; ++ -aux*) ++ vendor=apple ++ ;; ++ -hms*) ++ vendor=hitachi ++ ;; ++ -mpw* | -macos*) ++ vendor=apple ++ ;; ++ -*mint | -mint[0-9]* | -*MiNT | -MiNT[0-9]*) ++ vendor=atari ++ ;; ++ -vos*) ++ vendor=stratus ++ ;; ++ esac ++ basic_machine=`echo "$basic_machine" | sed "s/unknown/$vendor/"` ++ ;; ++esac ++ ++echo "$basic_machine$os" ++exit ++ ++# Local variables: ++# eval: (add-hook 'write-file-functions 'time-stamp) ++# time-stamp-start: "timestamp='" ++# time-stamp-format: "%:y-%02m-%02d" ++# time-stamp-end: "'" ++# End: +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/depcomp +@@ -0,0 +1,791 @@ ++#! /bin/sh ++# depcomp - compile a program generating dependencies as side-effects ++ ++scriptversion=2016-01-11.22; # UTC ++ ++# Copyright (C) 1999-2017 Free Software Foundation, Inc. ++ ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2, or (at your option) ++# any later version. ++ ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++ ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++ ++# As a special exception to the GNU General Public License, if you ++# distribute this file as part of a program that contains a ++# configuration script generated by Autoconf, you may include it under ++# the same distribution terms that you use for the rest of that program. ++ ++# Originally written by Alexandre Oliva . ++ ++case $1 in ++ '') ++ echo "$0: No command. Try '$0 --help' for more information." 1>&2 ++ exit 1; ++ ;; ++ -h | --h*) ++ cat <<\EOF ++Usage: depcomp [--help] [--version] PROGRAM [ARGS] ++ ++Run PROGRAMS ARGS to compile a file, generating dependencies ++as side-effects. ++ ++Environment variables: ++ depmode Dependency tracking mode. ++ source Source file read by 'PROGRAMS ARGS'. ++ object Object file output by 'PROGRAMS ARGS'. ++ DEPDIR directory where to store dependencies. ++ depfile Dependency file to output. ++ tmpdepfile Temporary file to use when outputting dependencies. ++ libtool Whether libtool is used (yes/no). ++ ++Report bugs to . ++EOF ++ exit $? ++ ;; ++ -v | --v*) ++ echo "depcomp $scriptversion" ++ exit $? ++ ;; ++esac ++ ++# Get the directory component of the given path, and save it in the ++# global variables '$dir'. Note that this directory component will ++# be either empty or ending with a '/' character. This is deliberate. ++set_dir_from () ++{ ++ case $1 in ++ */*) dir=`echo "$1" | sed -e 's|/[^/]*$|/|'`;; ++ *) dir=;; ++ esac ++} ++ ++# Get the suffix-stripped basename of the given path, and save it the ++# global variable '$base'. ++set_base_from () ++{ ++ base=`echo "$1" | sed -e 's|^.*/||' -e 's/\.[^.]*$//'` ++} ++ ++# If no dependency file was actually created by the compiler invocation, ++# we still have to create a dummy depfile, to avoid errors with the ++# Makefile "include basename.Plo" scheme. ++make_dummy_depfile () ++{ ++ echo "#dummy" > "$depfile" ++} ++ ++# Factor out some common post-processing of the generated depfile. ++# Requires the auxiliary global variable '$tmpdepfile' to be set. ++aix_post_process_depfile () ++{ ++ # If the compiler actually managed to produce a dependency file, ++ # post-process it. ++ if test -f "$tmpdepfile"; then ++ # Each line is of the form 'foo.o: dependency.h'. ++ # Do two passes, one to just change these to ++ # $object: dependency.h ++ # and one to simply output ++ # dependency.h: ++ # which is needed to avoid the deleted-header problem. ++ { sed -e "s,^.*\.[$lower]*:,$object:," < "$tmpdepfile" ++ sed -e "s,^.*\.[$lower]*:[$tab ]*,," -e 's,$,:,' < "$tmpdepfile" ++ } > "$depfile" ++ rm -f "$tmpdepfile" ++ else ++ make_dummy_depfile ++ fi ++} ++ ++# A tabulation character. ++tab=' ' ++# A newline character. ++nl=' ++' ++# Character ranges might be problematic outside the C locale. ++# These definitions help. ++upper=ABCDEFGHIJKLMNOPQRSTUVWXYZ ++lower=abcdefghijklmnopqrstuvwxyz ++digits=0123456789 ++alpha=${upper}${lower} ++ ++if test -z "$depmode" || test -z "$source" || test -z "$object"; then ++ echo "depcomp: Variables source, object and depmode must be set" 1>&2 ++ exit 1 ++fi ++ ++# Dependencies for sub/bar.o or sub/bar.obj go into sub/.deps/bar.Po. ++depfile=${depfile-`echo "$object" | ++ sed 's|[^\\/]*$|'${DEPDIR-.deps}'/&|;s|\.\([^.]*\)$|.P\1|;s|Pobj$|Po|'`} ++tmpdepfile=${tmpdepfile-`echo "$depfile" | sed 's/\.\([^.]*\)$/.T\1/'`} ++ ++rm -f "$tmpdepfile" ++ ++# Avoid interferences from the environment. ++gccflag= dashmflag= ++ ++# Some modes work just like other modes, but use different flags. We ++# parameterize here, but still list the modes in the big case below, ++# to make depend.m4 easier to write. Note that we *cannot* use a case ++# here, because this file can only contain one case statement. ++if test "$depmode" = hp; then ++ # HP compiler uses -M and no extra arg. ++ gccflag=-M ++ depmode=gcc ++fi ++ ++if test "$depmode" = dashXmstdout; then ++ # This is just like dashmstdout with a different argument. ++ dashmflag=-xM ++ depmode=dashmstdout ++fi ++ ++cygpath_u="cygpath -u -f -" ++if test "$depmode" = msvcmsys; then ++ # This is just like msvisualcpp but w/o cygpath translation. ++ # Just convert the backslash-escaped backslashes to single forward ++ # slashes to satisfy depend.m4 ++ cygpath_u='sed s,\\\\,/,g' ++ depmode=msvisualcpp ++fi ++ ++if test "$depmode" = msvc7msys; then ++ # This is just like msvc7 but w/o cygpath translation. ++ # Just convert the backslash-escaped backslashes to single forward ++ # slashes to satisfy depend.m4 ++ cygpath_u='sed s,\\\\,/,g' ++ depmode=msvc7 ++fi ++ ++if test "$depmode" = xlc; then ++ # IBM C/C++ Compilers xlc/xlC can output gcc-like dependency information. ++ gccflag=-qmakedep=gcc,-MF ++ depmode=gcc ++fi ++ ++case "$depmode" in ++gcc3) ++## gcc 3 implements dependency tracking that does exactly what ++## we want. Yay! Note: for some reason libtool 1.4 doesn't like ++## it if -MD -MP comes after the -MF stuff. Hmm. ++## Unfortunately, FreeBSD c89 acceptance of flags depends upon ++## the command line argument order; so add the flags where they ++## appear in depend2.am. Note that the slowdown incurred here ++## affects only configure: in makefiles, %FASTDEP% shortcuts this. ++ for arg ++ do ++ case $arg in ++ -c) set fnord "$@" -MT "$object" -MD -MP -MF "$tmpdepfile" "$arg" ;; ++ *) set fnord "$@" "$arg" ;; ++ esac ++ shift # fnord ++ shift # $arg ++ done ++ "$@" ++ stat=$? ++ if test $stat -ne 0; then ++ rm -f "$tmpdepfile" ++ exit $stat ++ fi ++ mv "$tmpdepfile" "$depfile" ++ ;; ++ ++gcc) ++## Note that this doesn't just cater to obsosete pre-3.x GCC compilers. ++## but also to in-use compilers like IMB xlc/xlC and the HP C compiler. ++## (see the conditional assignment to $gccflag above). ++## There are various ways to get dependency output from gcc. Here's ++## why we pick this rather obscure method: ++## - Don't want to use -MD because we'd like the dependencies to end ++## up in a subdir. Having to rename by hand is ugly. ++## (We might end up doing this anyway to support other compilers.) ++## - The DEPENDENCIES_OUTPUT environment variable makes gcc act like ++## -MM, not -M (despite what the docs say). Also, it might not be ++## supported by the other compilers which use the 'gcc' depmode. ++## - Using -M directly means running the compiler twice (even worse ++## than renaming). ++ if test -z "$gccflag"; then ++ gccflag=-MD, ++ fi ++ "$@" -Wp,"$gccflag$tmpdepfile" ++ stat=$? ++ if test $stat -ne 0; then ++ rm -f "$tmpdepfile" ++ exit $stat ++ fi ++ rm -f "$depfile" ++ echo "$object : \\" > "$depfile" ++ # The second -e expression handles DOS-style file names with drive ++ # letters. ++ sed -e 's/^[^:]*: / /' \ ++ -e 's/^['$alpha']:\/[^:]*: / /' < "$tmpdepfile" >> "$depfile" ++## This next piece of magic avoids the "deleted header file" problem. ++## The problem is that when a header file which appears in a .P file ++## is deleted, the dependency causes make to die (because there is ++## typically no way to rebuild the header). We avoid this by adding ++## dummy dependencies for each header file. Too bad gcc doesn't do ++## this for us directly. ++## Some versions of gcc put a space before the ':'. On the theory ++## that the space means something, we add a space to the output as ++## well. hp depmode also adds that space, but also prefixes the VPATH ++## to the object. Take care to not repeat it in the output. ++## Some versions of the HPUX 10.20 sed can't process this invocation ++## correctly. Breaking it into two sed invocations is a workaround. ++ tr ' ' "$nl" < "$tmpdepfile" \ ++ | sed -e 's/^\\$//' -e '/^$/d' -e "s|.*$object$||" -e '/:$/d' \ ++ | sed -e 's/$/ :/' >> "$depfile" ++ rm -f "$tmpdepfile" ++ ;; ++ ++hp) ++ # This case exists only to let depend.m4 do its work. It works by ++ # looking at the text of this script. This case will never be run, ++ # since it is checked for above. ++ exit 1 ++ ;; ++ ++sgi) ++ if test "$libtool" = yes; then ++ "$@" "-Wp,-MDupdate,$tmpdepfile" ++ else ++ "$@" -MDupdate "$tmpdepfile" ++ fi ++ stat=$? ++ if test $stat -ne 0; then ++ rm -f "$tmpdepfile" ++ exit $stat ++ fi ++ rm -f "$depfile" ++ ++ if test -f "$tmpdepfile"; then # yes, the sourcefile depend on other files ++ echo "$object : \\" > "$depfile" ++ # Clip off the initial element (the dependent). Don't try to be ++ # clever and replace this with sed code, as IRIX sed won't handle ++ # lines with more than a fixed number of characters (4096 in ++ # IRIX 6.2 sed, 8192 in IRIX 6.5). We also remove comment lines; ++ # the IRIX cc adds comments like '#:fec' to the end of the ++ # dependency line. ++ tr ' ' "$nl" < "$tmpdepfile" \ ++ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' \ ++ | tr "$nl" ' ' >> "$depfile" ++ echo >> "$depfile" ++ # The second pass generates a dummy entry for each header file. ++ tr ' ' "$nl" < "$tmpdepfile" \ ++ | sed -e 's/^.*\.o://' -e 's/#.*$//' -e '/^$/ d' -e 's/$/:/' \ ++ >> "$depfile" ++ else ++ make_dummy_depfile ++ fi ++ rm -f "$tmpdepfile" ++ ;; ++ ++xlc) ++ # This case exists only to let depend.m4 do its work. It works by ++ # looking at the text of this script. This case will never be run, ++ # since it is checked for above. ++ exit 1 ++ ;; ++ ++aix) ++ # The C for AIX Compiler uses -M and outputs the dependencies ++ # in a .u file. In older versions, this file always lives in the ++ # current directory. Also, the AIX compiler puts '$object:' at the ++ # start of each line; $object doesn't have directory information. ++ # Version 6 uses the directory in both cases. ++ set_dir_from "$object" ++ set_base_from "$object" ++ if test "$libtool" = yes; then ++ tmpdepfile1=$dir$base.u ++ tmpdepfile2=$base.u ++ tmpdepfile3=$dir.libs/$base.u ++ "$@" -Wc,-M ++ else ++ tmpdepfile1=$dir$base.u ++ tmpdepfile2=$dir$base.u ++ tmpdepfile3=$dir$base.u ++ "$@" -M ++ fi ++ stat=$? ++ if test $stat -ne 0; then ++ rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" ++ exit $stat ++ fi ++ ++ for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" ++ do ++ test -f "$tmpdepfile" && break ++ done ++ aix_post_process_depfile ++ ;; ++ ++tcc) ++ # tcc (Tiny C Compiler) understand '-MD -MF file' since version 0.9.26 ++ # FIXME: That version still under development at the moment of writing. ++ # Make that this statement remains true also for stable, released ++ # versions. ++ # It will wrap lines (doesn't matter whether long or short) with a ++ # trailing '\', as in: ++ # ++ # foo.o : \ ++ # foo.c \ ++ # foo.h \ ++ # ++ # It will put a trailing '\' even on the last line, and will use leading ++ # spaces rather than leading tabs (at least since its commit 0394caf7 ++ # "Emit spaces for -MD"). ++ "$@" -MD -MF "$tmpdepfile" ++ stat=$? ++ if test $stat -ne 0; then ++ rm -f "$tmpdepfile" ++ exit $stat ++ fi ++ rm -f "$depfile" ++ # Each non-empty line is of the form 'foo.o : \' or ' dep.h \'. ++ # We have to change lines of the first kind to '$object: \'. ++ sed -e "s|.*:|$object :|" < "$tmpdepfile" > "$depfile" ++ # And for each line of the second kind, we have to emit a 'dep.h:' ++ # dummy dependency, to avoid the deleted-header problem. ++ sed -n -e 's|^ *\(.*\) *\\$|\1:|p' < "$tmpdepfile" >> "$depfile" ++ rm -f "$tmpdepfile" ++ ;; ++ ++## The order of this option in the case statement is important, since the ++## shell code in configure will try each of these formats in the order ++## listed in this file. A plain '-MD' option would be understood by many ++## compilers, so we must ensure this comes after the gcc and icc options. ++pgcc) ++ # Portland's C compiler understands '-MD'. ++ # Will always output deps to 'file.d' where file is the root name of the ++ # source file under compilation, even if file resides in a subdirectory. ++ # The object file name does not affect the name of the '.d' file. ++ # pgcc 10.2 will output ++ # foo.o: sub/foo.c sub/foo.h ++ # and will wrap long lines using '\' : ++ # foo.o: sub/foo.c ... \ ++ # sub/foo.h ... \ ++ # ... ++ set_dir_from "$object" ++ # Use the source, not the object, to determine the base name, since ++ # that's sadly what pgcc will do too. ++ set_base_from "$source" ++ tmpdepfile=$base.d ++ ++ # For projects that build the same source file twice into different object ++ # files, the pgcc approach of using the *source* file root name can cause ++ # problems in parallel builds. Use a locking strategy to avoid stomping on ++ # the same $tmpdepfile. ++ lockdir=$base.d-lock ++ trap " ++ echo '$0: caught signal, cleaning up...' >&2 ++ rmdir '$lockdir' ++ exit 1 ++ " 1 2 13 15 ++ numtries=100 ++ i=$numtries ++ while test $i -gt 0; do ++ # mkdir is a portable test-and-set. ++ if mkdir "$lockdir" 2>/dev/null; then ++ # This process acquired the lock. ++ "$@" -MD ++ stat=$? ++ # Release the lock. ++ rmdir "$lockdir" ++ break ++ else ++ # If the lock is being held by a different process, wait ++ # until the winning process is done or we timeout. ++ while test -d "$lockdir" && test $i -gt 0; do ++ sleep 1 ++ i=`expr $i - 1` ++ done ++ fi ++ i=`expr $i - 1` ++ done ++ trap - 1 2 13 15 ++ if test $i -le 0; then ++ echo "$0: failed to acquire lock after $numtries attempts" >&2 ++ echo "$0: check lockdir '$lockdir'" >&2 ++ exit 1 ++ fi ++ ++ if test $stat -ne 0; then ++ rm -f "$tmpdepfile" ++ exit $stat ++ fi ++ rm -f "$depfile" ++ # Each line is of the form `foo.o: dependent.h', ++ # or `foo.o: dep1.h dep2.h \', or ` dep3.h dep4.h \'. ++ # Do two passes, one to just change these to ++ # `$object: dependent.h' and one to simply `dependent.h:'. ++ sed "s,^[^:]*:,$object :," < "$tmpdepfile" > "$depfile" ++ # Some versions of the HPUX 10.20 sed can't process this invocation ++ # correctly. Breaking it into two sed invocations is a workaround. ++ sed 's,^[^:]*: \(.*\)$,\1,;s/^\\$//;/^$/d;/:$/d' < "$tmpdepfile" \ ++ | sed -e 's/$/ :/' >> "$depfile" ++ rm -f "$tmpdepfile" ++ ;; ++ ++hp2) ++ # The "hp" stanza above does not work with aCC (C++) and HP's ia64 ++ # compilers, which have integrated preprocessors. The correct option ++ # to use with these is +Maked; it writes dependencies to a file named ++ # 'foo.d', which lands next to the object file, wherever that ++ # happens to be. ++ # Much of this is similar to the tru64 case; see comments there. ++ set_dir_from "$object" ++ set_base_from "$object" ++ if test "$libtool" = yes; then ++ tmpdepfile1=$dir$base.d ++ tmpdepfile2=$dir.libs/$base.d ++ "$@" -Wc,+Maked ++ else ++ tmpdepfile1=$dir$base.d ++ tmpdepfile2=$dir$base.d ++ "$@" +Maked ++ fi ++ stat=$? ++ if test $stat -ne 0; then ++ rm -f "$tmpdepfile1" "$tmpdepfile2" ++ exit $stat ++ fi ++ ++ for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" ++ do ++ test -f "$tmpdepfile" && break ++ done ++ if test -f "$tmpdepfile"; then ++ sed -e "s,^.*\.[$lower]*:,$object:," "$tmpdepfile" > "$depfile" ++ # Add 'dependent.h:' lines. ++ sed -ne '2,${ ++ s/^ *// ++ s/ \\*$// ++ s/$/:/ ++ p ++ }' "$tmpdepfile" >> "$depfile" ++ else ++ make_dummy_depfile ++ fi ++ rm -f "$tmpdepfile" "$tmpdepfile2" ++ ;; ++ ++tru64) ++ # The Tru64 compiler uses -MD to generate dependencies as a side ++ # effect. 'cc -MD -o foo.o ...' puts the dependencies into 'foo.o.d'. ++ # At least on Alpha/Redhat 6.1, Compaq CCC V6.2-504 seems to put ++ # dependencies in 'foo.d' instead, so we check for that too. ++ # Subdirectories are respected. ++ set_dir_from "$object" ++ set_base_from "$object" ++ ++ if test "$libtool" = yes; then ++ # Libtool generates 2 separate objects for the 2 libraries. These ++ # two compilations output dependencies in $dir.libs/$base.o.d and ++ # in $dir$base.o.d. We have to check for both files, because ++ # one of the two compilations can be disabled. We should prefer ++ # $dir$base.o.d over $dir.libs/$base.o.d because the latter is ++ # automatically cleaned when .libs/ is deleted, while ignoring ++ # the former would cause a distcleancheck panic. ++ tmpdepfile1=$dir$base.o.d # libtool 1.5 ++ tmpdepfile2=$dir.libs/$base.o.d # Likewise. ++ tmpdepfile3=$dir.libs/$base.d # Compaq CCC V6.2-504 ++ "$@" -Wc,-MD ++ else ++ tmpdepfile1=$dir$base.d ++ tmpdepfile2=$dir$base.d ++ tmpdepfile3=$dir$base.d ++ "$@" -MD ++ fi ++ ++ stat=$? ++ if test $stat -ne 0; then ++ rm -f "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" ++ exit $stat ++ fi ++ ++ for tmpdepfile in "$tmpdepfile1" "$tmpdepfile2" "$tmpdepfile3" ++ do ++ test -f "$tmpdepfile" && break ++ done ++ # Same post-processing that is required for AIX mode. ++ aix_post_process_depfile ++ ;; ++ ++msvc7) ++ if test "$libtool" = yes; then ++ showIncludes=-Wc,-showIncludes ++ else ++ showIncludes=-showIncludes ++ fi ++ "$@" $showIncludes > "$tmpdepfile" ++ stat=$? ++ grep -v '^Note: including file: ' "$tmpdepfile" ++ if test $stat -ne 0; then ++ rm -f "$tmpdepfile" ++ exit $stat ++ fi ++ rm -f "$depfile" ++ echo "$object : \\" > "$depfile" ++ # The first sed program below extracts the file names and escapes ++ # backslashes for cygpath. The second sed program outputs the file ++ # name when reading, but also accumulates all include files in the ++ # hold buffer in order to output them again at the end. This only ++ # works with sed implementations that can handle large buffers. ++ sed < "$tmpdepfile" -n ' ++/^Note: including file: *\(.*\)/ { ++ s//\1/ ++ s/\\/\\\\/g ++ p ++}' | $cygpath_u | sort -u | sed -n ' ++s/ /\\ /g ++s/\(.*\)/'"$tab"'\1 \\/p ++s/.\(.*\) \\/\1:/ ++H ++$ { ++ s/.*/'"$tab"'/ ++ G ++ p ++}' >> "$depfile" ++ echo >> "$depfile" # make sure the fragment doesn't end with a backslash ++ rm -f "$tmpdepfile" ++ ;; ++ ++msvc7msys) ++ # This case exists only to let depend.m4 do its work. It works by ++ # looking at the text of this script. This case will never be run, ++ # since it is checked for above. ++ exit 1 ++ ;; ++ ++#nosideeffect) ++ # This comment above is used by automake to tell side-effect ++ # dependency tracking mechanisms from slower ones. ++ ++dashmstdout) ++ # Important note: in order to support this mode, a compiler *must* ++ # always write the preprocessed file to stdout, regardless of -o. ++ "$@" || exit $? ++ ++ # Remove the call to Libtool. ++ if test "$libtool" = yes; then ++ while test "X$1" != 'X--mode=compile'; do ++ shift ++ done ++ shift ++ fi ++ ++ # Remove '-o $object'. ++ IFS=" " ++ for arg ++ do ++ case $arg in ++ -o) ++ shift ++ ;; ++ $object) ++ shift ++ ;; ++ *) ++ set fnord "$@" "$arg" ++ shift # fnord ++ shift # $arg ++ ;; ++ esac ++ done ++ ++ test -z "$dashmflag" && dashmflag=-M ++ # Require at least two characters before searching for ':' ++ # in the target name. This is to cope with DOS-style filenames: ++ # a dependency such as 'c:/foo/bar' could be seen as target 'c' otherwise. ++ "$@" $dashmflag | ++ sed "s|^[$tab ]*[^:$tab ][^:][^:]*:[$tab ]*|$object: |" > "$tmpdepfile" ++ rm -f "$depfile" ++ cat < "$tmpdepfile" > "$depfile" ++ # Some versions of the HPUX 10.20 sed can't process this sed invocation ++ # correctly. Breaking it into two sed invocations is a workaround. ++ tr ' ' "$nl" < "$tmpdepfile" \ ++ | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \ ++ | sed -e 's/$/ :/' >> "$depfile" ++ rm -f "$tmpdepfile" ++ ;; ++ ++dashXmstdout) ++ # This case only exists to satisfy depend.m4. It is never actually ++ # run, as this mode is specially recognized in the preamble. ++ exit 1 ++ ;; ++ ++makedepend) ++ "$@" || exit $? ++ # Remove any Libtool call ++ if test "$libtool" = yes; then ++ while test "X$1" != 'X--mode=compile'; do ++ shift ++ done ++ shift ++ fi ++ # X makedepend ++ shift ++ cleared=no eat=no ++ for arg ++ do ++ case $cleared in ++ no) ++ set ""; shift ++ cleared=yes ;; ++ esac ++ if test $eat = yes; then ++ eat=no ++ continue ++ fi ++ case "$arg" in ++ -D*|-I*) ++ set fnord "$@" "$arg"; shift ;; ++ # Strip any option that makedepend may not understand. Remove ++ # the object too, otherwise makedepend will parse it as a source file. ++ -arch) ++ eat=yes ;; ++ -*|$object) ++ ;; ++ *) ++ set fnord "$@" "$arg"; shift ;; ++ esac ++ done ++ obj_suffix=`echo "$object" | sed 's/^.*\././'` ++ touch "$tmpdepfile" ++ ${MAKEDEPEND-makedepend} -o"$obj_suffix" -f"$tmpdepfile" "$@" ++ rm -f "$depfile" ++ # makedepend may prepend the VPATH from the source file name to the object. ++ # No need to regex-escape $object, excess matching of '.' is harmless. ++ sed "s|^.*\($object *:\)|\1|" "$tmpdepfile" > "$depfile" ++ # Some versions of the HPUX 10.20 sed can't process the last invocation ++ # correctly. Breaking it into two sed invocations is a workaround. ++ sed '1,2d' "$tmpdepfile" \ ++ | tr ' ' "$nl" \ ++ | sed -e 's/^\\$//' -e '/^$/d' -e '/:$/d' \ ++ | sed -e 's/$/ :/' >> "$depfile" ++ rm -f "$tmpdepfile" "$tmpdepfile".bak ++ ;; ++ ++cpp) ++ # Important note: in order to support this mode, a compiler *must* ++ # always write the preprocessed file to stdout. ++ "$@" || exit $? ++ ++ # Remove the call to Libtool. ++ if test "$libtool" = yes; then ++ while test "X$1" != 'X--mode=compile'; do ++ shift ++ done ++ shift ++ fi ++ ++ # Remove '-o $object'. ++ IFS=" " ++ for arg ++ do ++ case $arg in ++ -o) ++ shift ++ ;; ++ $object) ++ shift ++ ;; ++ *) ++ set fnord "$@" "$arg" ++ shift # fnord ++ shift # $arg ++ ;; ++ esac ++ done ++ ++ "$@" -E \ ++ | sed -n -e '/^# [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \ ++ -e '/^#line [0-9][0-9]* "\([^"]*\)".*/ s:: \1 \\:p' \ ++ | sed '$ s: \\$::' > "$tmpdepfile" ++ rm -f "$depfile" ++ echo "$object : \\" > "$depfile" ++ cat < "$tmpdepfile" >> "$depfile" ++ sed < "$tmpdepfile" '/^$/d;s/^ //;s/ \\$//;s/$/ :/' >> "$depfile" ++ rm -f "$tmpdepfile" ++ ;; ++ ++msvisualcpp) ++ # Important note: in order to support this mode, a compiler *must* ++ # always write the preprocessed file to stdout. ++ "$@" || exit $? ++ ++ # Remove the call to Libtool. ++ if test "$libtool" = yes; then ++ while test "X$1" != 'X--mode=compile'; do ++ shift ++ done ++ shift ++ fi ++ ++ IFS=" " ++ for arg ++ do ++ case "$arg" in ++ -o) ++ shift ++ ;; ++ $object) ++ shift ++ ;; ++ "-Gm"|"/Gm"|"-Gi"|"/Gi"|"-ZI"|"/ZI") ++ set fnord "$@" ++ shift ++ shift ++ ;; ++ *) ++ set fnord "$@" "$arg" ++ shift ++ shift ++ ;; ++ esac ++ done ++ "$@" -E 2>/dev/null | ++ sed -n '/^#line [0-9][0-9]* "\([^"]*\)"/ s::\1:p' | $cygpath_u | sort -u > "$tmpdepfile" ++ rm -f "$depfile" ++ echo "$object : \\" > "$depfile" ++ sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::'"$tab"'\1 \\:p' >> "$depfile" ++ echo "$tab" >> "$depfile" ++ sed < "$tmpdepfile" -n -e 's% %\\ %g' -e '/^\(.*\)$/ s::\1\::p' >> "$depfile" ++ rm -f "$tmpdepfile" ++ ;; ++ ++msvcmsys) ++ # This case exists only to let depend.m4 do its work. It works by ++ # looking at the text of this script. This case will never be run, ++ # since it is checked for above. ++ exit 1 ++ ;; ++ ++none) ++ exec "$@" ++ ;; ++ ++*) ++ echo "Unknown depmode $depmode" 1>&2 ++ exit 1 ++ ;; ++esac ++ ++exit 0 ++ ++# Local Variables: ++# mode: shell-script ++# sh-indentation: 2 ++# eval: (add-hook 'write-file-hooks 'time-stamp) ++# time-stamp-start: "scriptversion=" ++# time-stamp-format: "%:y-%02m-%02d.%02H" ++# time-stamp-time-zone: "UTC0" ++# time-stamp-end: "; # UTC" ++# End: +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/iconv.m4 +@@ -0,0 +1,271 @@ ++# iconv.m4 serial 19 (gettext-0.18.2) ++dnl Copyright (C) 2000-2002, 2007-2014 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 From Bruno Haible. ++ ++AC_DEFUN([AM_ICONV_LINKFLAGS_BODY], ++[ ++ dnl Prerequisites of AC_LIB_LINKFLAGS_BODY. ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ AC_REQUIRE([AC_LIB_RPATH]) ++ ++ dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV ++ dnl accordingly. ++ AC_LIB_LINKFLAGS_BODY([iconv]) ++]) ++ ++AC_DEFUN([AM_ICONV_LINK], ++[ ++ dnl Some systems have iconv in libc, some have it in libiconv (OSF/1 and ++ dnl those with the standalone portable GNU libiconv installed). ++ AC_REQUIRE([AC_CANONICAL_HOST]) dnl for cross-compiles ++ ++ dnl Search for libiconv and define LIBICONV, LTLIBICONV and INCICONV ++ dnl accordingly. ++ AC_REQUIRE([AM_ICONV_LINKFLAGS_BODY]) ++ ++ dnl Add $INCICONV to CPPFLAGS before performing the following checks, ++ dnl because if the user has installed libiconv and not disabled its use ++ dnl via --without-libiconv-prefix, he wants to use it. The first ++ dnl AC_LINK_IFELSE will then fail, the second AC_LINK_IFELSE will succeed. ++ am_save_CPPFLAGS="$CPPFLAGS" ++ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INCICONV]) ++ ++ AC_CACHE_CHECK([for iconv], [am_cv_func_iconv], [ ++ am_cv_func_iconv="no, consider installing GNU libiconv" ++ am_cv_lib_iconv=no ++ AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[ ++#include ++#include ++ ]], ++ [[iconv_t cd = iconv_open("",""); ++ iconv(cd,NULL,NULL,NULL,NULL); ++ iconv_close(cd);]])], ++ [am_cv_func_iconv=yes]) ++ if test "$am_cv_func_iconv" != yes; then ++ am_save_LIBS="$LIBS" ++ LIBS="$LIBS $LIBICONV" ++ AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[ ++#include ++#include ++ ]], ++ [[iconv_t cd = iconv_open("",""); ++ iconv(cd,NULL,NULL,NULL,NULL); ++ iconv_close(cd);]])], ++ [am_cv_lib_iconv=yes] ++ [am_cv_func_iconv=yes]) ++ LIBS="$am_save_LIBS" ++ fi ++ ]) ++ if test "$am_cv_func_iconv" = yes; then ++ AC_CACHE_CHECK([for working iconv], [am_cv_func_iconv_works], [ ++ dnl This tests against bugs in AIX 5.1, AIX 6.1..7.1, HP-UX 11.11, ++ dnl Solaris 10. ++ am_save_LIBS="$LIBS" ++ if test $am_cv_lib_iconv = yes; then ++ LIBS="$LIBS $LIBICONV" ++ fi ++ am_cv_func_iconv_works=no ++ for ac_iconv_const in '' 'const'; do ++ AC_RUN_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[ ++#include ++#include ++ ++#ifndef ICONV_CONST ++# define ICONV_CONST $ac_iconv_const ++#endif ++ ]], ++ [[int result = 0; ++ /* Test against AIX 5.1 bug: Failures are not distinguishable from successful ++ returns. */ ++ { ++ iconv_t cd_utf8_to_88591 = iconv_open ("ISO8859-1", "UTF-8"); ++ if (cd_utf8_to_88591 != (iconv_t)(-1)) ++ { ++ static ICONV_CONST char input[] = "\342\202\254"; /* EURO SIGN */ ++ char buf[10]; ++ ICONV_CONST char *inptr = input; ++ size_t inbytesleft = strlen (input); ++ char *outptr = buf; ++ size_t outbytesleft = sizeof (buf); ++ size_t res = iconv (cd_utf8_to_88591, ++ &inptr, &inbytesleft, ++ &outptr, &outbytesleft); ++ if (res == 0) ++ result |= 1; ++ iconv_close (cd_utf8_to_88591); ++ } ++ } ++ /* Test against Solaris 10 bug: Failures are not distinguishable from ++ successful returns. */ ++ { ++ iconv_t cd_ascii_to_88591 = iconv_open ("ISO8859-1", "646"); ++ if (cd_ascii_to_88591 != (iconv_t)(-1)) ++ { ++ static ICONV_CONST char input[] = "\263"; ++ char buf[10]; ++ ICONV_CONST char *inptr = input; ++ size_t inbytesleft = strlen (input); ++ char *outptr = buf; ++ size_t outbytesleft = sizeof (buf); ++ size_t res = iconv (cd_ascii_to_88591, ++ &inptr, &inbytesleft, ++ &outptr, &outbytesleft); ++ if (res == 0) ++ result |= 2; ++ iconv_close (cd_ascii_to_88591); ++ } ++ } ++ /* Test against AIX 6.1..7.1 bug: Buffer overrun. */ ++ { ++ iconv_t cd_88591_to_utf8 = iconv_open ("UTF-8", "ISO-8859-1"); ++ if (cd_88591_to_utf8 != (iconv_t)(-1)) ++ { ++ static ICONV_CONST char input[] = "\304"; ++ static char buf[2] = { (char)0xDE, (char)0xAD }; ++ ICONV_CONST char *inptr = input; ++ size_t inbytesleft = 1; ++ char *outptr = buf; ++ size_t outbytesleft = 1; ++ size_t res = iconv (cd_88591_to_utf8, ++ &inptr, &inbytesleft, ++ &outptr, &outbytesleft); ++ if (res != (size_t)(-1) || outptr - buf > 1 || buf[1] != (char)0xAD) ++ result |= 4; ++ iconv_close (cd_88591_to_utf8); ++ } ++ } ++#if 0 /* This bug could be worked around by the caller. */ ++ /* Test against HP-UX 11.11 bug: Positive return value instead of 0. */ ++ { ++ iconv_t cd_88591_to_utf8 = iconv_open ("utf8", "iso88591"); ++ if (cd_88591_to_utf8 != (iconv_t)(-1)) ++ { ++ static ICONV_CONST char input[] = "\304rger mit b\366sen B\374bchen ohne Augenma\337"; ++ char buf[50]; ++ ICONV_CONST char *inptr = input; ++ size_t inbytesleft = strlen (input); ++ char *outptr = buf; ++ size_t outbytesleft = sizeof (buf); ++ size_t res = iconv (cd_88591_to_utf8, ++ &inptr, &inbytesleft, ++ &outptr, &outbytesleft); ++ if ((int)res > 0) ++ result |= 8; ++ iconv_close (cd_88591_to_utf8); ++ } ++ } ++#endif ++ /* Test against HP-UX 11.11 bug: No converter from EUC-JP to UTF-8 is ++ provided. */ ++ if (/* Try standardized names. */ ++ iconv_open ("UTF-8", "EUC-JP") == (iconv_t)(-1) ++ /* Try IRIX, OSF/1 names. */ ++ && iconv_open ("UTF-8", "eucJP") == (iconv_t)(-1) ++ /* Try AIX names. */ ++ && iconv_open ("UTF-8", "IBM-eucJP") == (iconv_t)(-1) ++ /* Try HP-UX names. */ ++ && iconv_open ("utf8", "eucJP") == (iconv_t)(-1)) ++ result |= 16; ++ return result; ++]])], ++ [am_cv_func_iconv_works=yes], , ++ [case "$host_os" in ++ aix* | hpux*) am_cv_func_iconv_works="guessing no" ;; ++ *) am_cv_func_iconv_works="guessing yes" ;; ++ esac]) ++ test "$am_cv_func_iconv_works" = no || break ++ done ++ LIBS="$am_save_LIBS" ++ ]) ++ case "$am_cv_func_iconv_works" in ++ *no) am_func_iconv=no am_cv_lib_iconv=no ;; ++ *) am_func_iconv=yes ;; ++ esac ++ else ++ am_func_iconv=no am_cv_lib_iconv=no ++ fi ++ if test "$am_func_iconv" = yes; then ++ AC_DEFINE([HAVE_ICONV], [1], ++ [Define if you have the iconv() function and it works.]) ++ fi ++ if test "$am_cv_lib_iconv" = yes; then ++ AC_MSG_CHECKING([how to link with libiconv]) ++ AC_MSG_RESULT([$LIBICONV]) ++ else ++ dnl If $LIBICONV didn't lead to a usable library, we don't need $INCICONV ++ dnl either. ++ CPPFLAGS="$am_save_CPPFLAGS" ++ LIBICONV= ++ LTLIBICONV= ++ fi ++ AC_SUBST([LIBICONV]) ++ AC_SUBST([LTLIBICONV]) ++]) ++ ++dnl Define AM_ICONV using AC_DEFUN_ONCE for Autoconf >= 2.64, in order to ++dnl avoid warnings like ++dnl "warning: AC_REQUIRE: `AM_ICONV' was expanded before it was required". ++dnl This is tricky because of the way 'aclocal' is implemented: ++dnl - It requires defining an auxiliary macro whose name ends in AC_DEFUN. ++dnl Otherwise aclocal's initial scan pass would miss the macro definition. ++dnl - It requires a line break inside the AC_DEFUN_ONCE and AC_DEFUN expansions. ++dnl Otherwise aclocal would emit many "Use of uninitialized value $1" ++dnl warnings. ++m4_define([gl_iconv_AC_DEFUN], ++ m4_version_prereq([2.64], ++ [[AC_DEFUN_ONCE( ++ [$1], [$2])]], ++ [m4_ifdef([gl_00GNULIB], ++ [[AC_DEFUN_ONCE( ++ [$1], [$2])]], ++ [[AC_DEFUN( ++ [$1], [$2])]])])) ++gl_iconv_AC_DEFUN([AM_ICONV], ++[ ++ AM_ICONV_LINK ++ if test "$am_cv_func_iconv" = yes; then ++ AC_MSG_CHECKING([for iconv declaration]) ++ AC_CACHE_VAL([am_cv_proto_iconv], [ ++ AC_COMPILE_IFELSE( ++ [AC_LANG_PROGRAM( ++ [[ ++#include ++#include ++extern ++#ifdef __cplusplus ++"C" ++#endif ++#if defined(__STDC__) || defined(_MSC_VER) || defined(__cplusplus) ++size_t iconv (iconv_t cd, char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft); ++#else ++size_t iconv(); ++#endif ++ ]], ++ [[]])], ++ [am_cv_proto_iconv_arg1=""], ++ [am_cv_proto_iconv_arg1="const"]) ++ am_cv_proto_iconv="extern size_t iconv (iconv_t cd, $am_cv_proto_iconv_arg1 char * *inbuf, size_t *inbytesleft, char * *outbuf, size_t *outbytesleft);"]) ++ am_cv_proto_iconv=`echo "[$]am_cv_proto_iconv" | tr -s ' ' | sed -e 's/( /(/'` ++ AC_MSG_RESULT([ ++ $am_cv_proto_iconv]) ++ AC_DEFINE_UNQUOTED([ICONV_CONST], [$am_cv_proto_iconv_arg1], ++ [Define as const if the declaration of iconv() needs const.]) ++ dnl Also substitute ICONV_CONST in the gnulib generated . ++ m4_ifdef([gl_ICONV_H_DEFAULTS], ++ [AC_REQUIRE([gl_ICONV_H_DEFAULTS]) ++ if test -n "$am_cv_proto_iconv_arg1"; then ++ ICONV_CONST="const" ++ fi ++ ]) ++ fi ++]) +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/install-sh +@@ -0,0 +1,508 @@ ++#!/bin/sh ++# install - install a program, script, or datafile ++ ++scriptversion=2014-09-12.12; # UTC ++ ++# This originates from X11R5 (mit/util/scripts/install.sh), which was ++# later released in X11R6 (xc/config/util/install.sh) with the ++# following copyright and license. ++# ++# Copyright (C) 1994 X Consortium ++# ++# Permission is hereby granted, free of charge, to any person obtaining a copy ++# of this software and associated documentation files (the "Software"), to ++# deal in the Software without restriction, including without limitation the ++# rights to use, copy, modify, merge, publish, distribute, sublicense, and/or ++# sell copies of the Software, and to permit persons to whom the Software is ++# furnished to do so, subject to the following conditions: ++# ++# The above copyright notice and this permission notice shall be included in ++# all copies or substantial portions of the Software. ++# ++# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR ++# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, ++# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE ++# X CONSORTIUM BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN ++# AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNEC- ++# TION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ++# ++# Except as contained in this notice, the name of the X Consortium shall not ++# be used in advertising or otherwise to promote the sale, use or other deal- ++# ings in this Software without prior written authorization from the X Consor- ++# tium. ++# ++# ++# FSF changes to this file are in the public domain. ++# ++# Calling this script install-sh is preferred over install.sh, to prevent ++# 'make' implicit rules from creating a file called install from it ++# when there is no Makefile. ++# ++# This script is compatible with the BSD install script, but was written ++# from scratch. ++ ++tab=' ' ++nl=' ++' ++IFS=" $tab$nl" ++ ++# Set DOITPROG to "echo" to test this script. ++ ++doit=${DOITPROG-} ++doit_exec=${doit:-exec} ++ ++# Put in absolute file names if you don't have them in your path; ++# or use environment vars. ++ ++chgrpprog=${CHGRPPROG-chgrp} ++chmodprog=${CHMODPROG-chmod} ++chownprog=${CHOWNPROG-chown} ++cmpprog=${CMPPROG-cmp} ++cpprog=${CPPROG-cp} ++mkdirprog=${MKDIRPROG-mkdir} ++mvprog=${MVPROG-mv} ++rmprog=${RMPROG-rm} ++stripprog=${STRIPPROG-strip} ++ ++posix_mkdir= ++ ++# Desired mode of installed file. ++mode=0755 ++ ++chgrpcmd= ++chmodcmd=$chmodprog ++chowncmd= ++mvcmd=$mvprog ++rmcmd="$rmprog -f" ++stripcmd= ++ ++src= ++dst= ++dir_arg= ++dst_arg= ++ ++copy_on_change=false ++is_target_a_directory=possibly ++ ++usage="\ ++Usage: $0 [OPTION]... [-T] SRCFILE DSTFILE ++ or: $0 [OPTION]... SRCFILES... DIRECTORY ++ or: $0 [OPTION]... -t DIRECTORY SRCFILES... ++ or: $0 [OPTION]... -d DIRECTORIES... ++ ++In the 1st form, copy SRCFILE to DSTFILE. ++In the 2nd and 3rd, copy all SRCFILES to DIRECTORY. ++In the 4th, create DIRECTORIES. ++ ++Options: ++ --help display this help and exit. ++ --version display version info and exit. ++ ++ -c (ignored) ++ -C install only if different (preserve the last data modification time) ++ -d create directories instead of installing files. ++ -g GROUP $chgrpprog installed files to GROUP. ++ -m MODE $chmodprog installed files to MODE. ++ -o USER $chownprog installed files to USER. ++ -s $stripprog installed files. ++ -t DIRECTORY install into DIRECTORY. ++ -T report an error if DSTFILE is a directory. ++ ++Environment variables override the default commands: ++ CHGRPPROG CHMODPROG CHOWNPROG CMPPROG CPPROG MKDIRPROG MVPROG ++ RMPROG STRIPPROG ++" ++ ++while test $# -ne 0; do ++ case $1 in ++ -c) ;; ++ ++ -C) copy_on_change=true;; ++ ++ -d) dir_arg=true;; ++ ++ -g) chgrpcmd="$chgrpprog $2" ++ shift;; ++ ++ --help) echo "$usage"; exit $?;; ++ ++ -m) mode=$2 ++ case $mode in ++ *' '* | *"$tab"* | *"$nl"* | *'*'* | *'?'* | *'['*) ++ echo "$0: invalid mode: $mode" >&2 ++ exit 1;; ++ esac ++ shift;; ++ ++ -o) chowncmd="$chownprog $2" ++ shift;; ++ ++ -s) stripcmd=$stripprog;; ++ ++ -t) ++ is_target_a_directory=always ++ dst_arg=$2 ++ # Protect names problematic for 'test' and other utilities. ++ case $dst_arg in ++ -* | [=\(\)!]) dst_arg=./$dst_arg;; ++ esac ++ shift;; ++ ++ -T) is_target_a_directory=never;; ++ ++ --version) echo "$0 $scriptversion"; exit $?;; ++ ++ --) shift ++ break;; ++ ++ -*) echo "$0: invalid option: $1" >&2 ++ exit 1;; ++ ++ *) break;; ++ esac ++ shift ++done ++ ++# We allow the use of options -d and -T together, by making -d ++# take the precedence; this is for compatibility with GNU install. ++ ++if test -n "$dir_arg"; then ++ if test -n "$dst_arg"; then ++ echo "$0: target directory not allowed when installing a directory." >&2 ++ exit 1 ++ fi ++fi ++ ++if test $# -ne 0 && test -z "$dir_arg$dst_arg"; then ++ # When -d is used, all remaining arguments are directories to create. ++ # When -t is used, the destination is already specified. ++ # Otherwise, the last argument is the destination. Remove it from $@. ++ for arg ++ do ++ if test -n "$dst_arg"; then ++ # $@ is not empty: it contains at least $arg. ++ set fnord "$@" "$dst_arg" ++ shift # fnord ++ fi ++ shift # arg ++ dst_arg=$arg ++ # Protect names problematic for 'test' and other utilities. ++ case $dst_arg in ++ -* | [=\(\)!]) dst_arg=./$dst_arg;; ++ esac ++ done ++fi ++ ++if test $# -eq 0; then ++ if test -z "$dir_arg"; then ++ echo "$0: no input file specified." >&2 ++ exit 1 ++ fi ++ # It's OK to call 'install-sh -d' without argument. ++ # This can happen when creating conditional directories. ++ exit 0 ++fi ++ ++if test -z "$dir_arg"; then ++ if test $# -gt 1 || test "$is_target_a_directory" = always; then ++ if test ! -d "$dst_arg"; then ++ echo "$0: $dst_arg: Is not a directory." >&2 ++ exit 1 ++ fi ++ fi ++fi ++ ++if test -z "$dir_arg"; then ++ do_exit='(exit $ret); exit $ret' ++ trap "ret=129; $do_exit" 1 ++ trap "ret=130; $do_exit" 2 ++ trap "ret=141; $do_exit" 13 ++ trap "ret=143; $do_exit" 15 ++ ++ # Set umask so as not to create temps with too-generous modes. ++ # However, 'strip' requires both read and write access to temps. ++ case $mode in ++ # Optimize common cases. ++ *644) cp_umask=133;; ++ *755) cp_umask=22;; ++ ++ *[0-7]) ++ if test -z "$stripcmd"; then ++ u_plus_rw= ++ else ++ u_plus_rw='% 200' ++ fi ++ cp_umask=`expr '(' 777 - $mode % 1000 ')' $u_plus_rw`;; ++ *) ++ if test -z "$stripcmd"; then ++ u_plus_rw= ++ else ++ u_plus_rw=,u+rw ++ fi ++ cp_umask=$mode$u_plus_rw;; ++ esac ++fi ++ ++for src ++do ++ # Protect names problematic for 'test' and other utilities. ++ case $src in ++ -* | [=\(\)!]) src=./$src;; ++ esac ++ ++ if test -n "$dir_arg"; then ++ dst=$src ++ dstdir=$dst ++ test -d "$dstdir" ++ dstdir_status=$? ++ else ++ ++ # Waiting for this to be detected by the "$cpprog $src $dsttmp" command ++ # might cause directories to be created, which would be especially bad ++ # if $src (and thus $dsttmp) contains '*'. ++ if test ! -f "$src" && test ! -d "$src"; then ++ echo "$0: $src does not exist." >&2 ++ exit 1 ++ fi ++ ++ if test -z "$dst_arg"; then ++ echo "$0: no destination specified." >&2 ++ exit 1 ++ fi ++ dst=$dst_arg ++ ++ # If destination is a directory, append the input filename; won't work ++ # if double slashes aren't ignored. ++ if test -d "$dst"; then ++ if test "$is_target_a_directory" = never; then ++ echo "$0: $dst_arg: Is a directory" >&2 ++ exit 1 ++ fi ++ dstdir=$dst ++ dst=$dstdir/`basename "$src"` ++ dstdir_status=0 ++ else ++ dstdir=`dirname "$dst"` ++ test -d "$dstdir" ++ dstdir_status=$? ++ fi ++ fi ++ ++ obsolete_mkdir_used=false ++ ++ if test $dstdir_status != 0; then ++ case $posix_mkdir in ++ '') ++ # Create intermediate dirs using mode 755 as modified by the umask. ++ # This is like FreeBSD 'install' as of 1997-10-28. ++ umask=`umask` ++ case $stripcmd.$umask in ++ # Optimize common cases. ++ *[2367][2367]) mkdir_umask=$umask;; ++ .*0[02][02] | .[02][02] | .[02]) mkdir_umask=22;; ++ ++ *[0-7]) ++ mkdir_umask=`expr $umask + 22 \ ++ - $umask % 100 % 40 + $umask % 20 \ ++ - $umask % 10 % 4 + $umask % 2 ++ `;; ++ *) mkdir_umask=$umask,go-w;; ++ esac ++ ++ # With -d, create the new directory with the user-specified mode. ++ # Otherwise, rely on $mkdir_umask. ++ if test -n "$dir_arg"; then ++ mkdir_mode=-m$mode ++ else ++ mkdir_mode= ++ fi ++ ++ posix_mkdir=false ++ case $umask in ++ *[123567][0-7][0-7]) ++ # POSIX mkdir -p sets u+wx bits regardless of umask, which ++ # is incompatible with FreeBSD 'install' when (umask & 300) != 0. ++ ;; ++ *) ++ # $RANDOM is not portable (e.g. dash); use it when possible to ++ # lower collision chance ++ tmpdir=${TMPDIR-/tmp}/ins$RANDOM-$$ ++ trap 'ret=$?; rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" 2>/dev/null; exit $ret' 0 ++ ++ # As "mkdir -p" follows symlinks and we work in /tmp possibly; so ++ # create the $tmpdir first (and fail if unsuccessful) to make sure ++ # that nobody tries to guess the $tmpdir name. ++ if (umask $mkdir_umask && ++ $mkdirprog $mkdir_mode "$tmpdir" && ++ exec $mkdirprog $mkdir_mode -p -- "$tmpdir/a/b") >/dev/null 2>&1 ++ then ++ if test -z "$dir_arg" || { ++ # Check for POSIX incompatibilities with -m. ++ # HP-UX 11.23 and IRIX 6.5 mkdir -m -p sets group- or ++ # other-writable bit of parent directory when it shouldn't. ++ # FreeBSD 6.1 mkdir -m -p sets mode of existing directory. ++ test_tmpdir="$tmpdir/a" ++ ls_ld_tmpdir=`ls -ld "$test_tmpdir"` ++ case $ls_ld_tmpdir in ++ d????-?r-*) different_mode=700;; ++ d????-?--*) different_mode=755;; ++ *) false;; ++ esac && ++ $mkdirprog -m$different_mode -p -- "$test_tmpdir" && { ++ ls_ld_tmpdir_1=`ls -ld "$test_tmpdir"` ++ test "$ls_ld_tmpdir" = "$ls_ld_tmpdir_1" ++ } ++ } ++ then posix_mkdir=: ++ fi ++ rmdir "$tmpdir/a/b" "$tmpdir/a" "$tmpdir" ++ else ++ # Remove any dirs left behind by ancient mkdir implementations. ++ rmdir ./$mkdir_mode ./-p ./-- "$tmpdir" 2>/dev/null ++ fi ++ trap '' 0;; ++ esac;; ++ esac ++ ++ if ++ $posix_mkdir && ( ++ umask $mkdir_umask && ++ $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir" ++ ) ++ then : ++ else ++ ++ # The umask is ridiculous, or mkdir does not conform to POSIX, ++ # or it failed possibly due to a race condition. Create the ++ # directory the slow way, step by step, checking for races as we go. ++ ++ case $dstdir in ++ /*) prefix='/';; ++ [-=\(\)!]*) prefix='./';; ++ *) prefix='';; ++ esac ++ ++ oIFS=$IFS ++ IFS=/ ++ set -f ++ set fnord $dstdir ++ shift ++ set +f ++ IFS=$oIFS ++ ++ prefixes= ++ ++ for d ++ do ++ test X"$d" = X && continue ++ ++ prefix=$prefix$d ++ if test -d "$prefix"; then ++ prefixes= ++ else ++ if $posix_mkdir; then ++ (umask=$mkdir_umask && ++ $doit_exec $mkdirprog $mkdir_mode -p -- "$dstdir") && break ++ # Don't fail if two instances are running concurrently. ++ test -d "$prefix" || exit 1 ++ else ++ case $prefix in ++ *\'*) qprefix=`echo "$prefix" | sed "s/'/'\\\\\\\\''/g"`;; ++ *) qprefix=$prefix;; ++ esac ++ prefixes="$prefixes '$qprefix'" ++ fi ++ fi ++ prefix=$prefix/ ++ done ++ ++ if test -n "$prefixes"; then ++ # Don't fail if two instances are running concurrently. ++ (umask $mkdir_umask && ++ eval "\$doit_exec \$mkdirprog $prefixes") || ++ test -d "$dstdir" || exit 1 ++ obsolete_mkdir_used=true ++ fi ++ fi ++ fi ++ ++ if test -n "$dir_arg"; then ++ { test -z "$chowncmd" || $doit $chowncmd "$dst"; } && ++ { test -z "$chgrpcmd" || $doit $chgrpcmd "$dst"; } && ++ { test "$obsolete_mkdir_used$chowncmd$chgrpcmd" = false || ++ test -z "$chmodcmd" || $doit $chmodcmd $mode "$dst"; } || exit 1 ++ else ++ ++ # Make a couple of temp file names in the proper directory. ++ dsttmp=$dstdir/_inst.$$_ ++ rmtmp=$dstdir/_rm.$$_ ++ ++ # Trap to clean up those temp files at exit. ++ trap 'ret=$?; rm -f "$dsttmp" "$rmtmp" && exit $ret' 0 ++ ++ # Copy the file name to the temp name. ++ (umask $cp_umask && $doit_exec $cpprog "$src" "$dsttmp") && ++ ++ # and set any options; do chmod last to preserve setuid bits. ++ # ++ # If any of these fail, we abort the whole thing. If we want to ++ # ignore errors from any of these, just make sure not to ignore ++ # errors from the above "$doit $cpprog $src $dsttmp" command. ++ # ++ { test -z "$chowncmd" || $doit $chowncmd "$dsttmp"; } && ++ { test -z "$chgrpcmd" || $doit $chgrpcmd "$dsttmp"; } && ++ { test -z "$stripcmd" || $doit $stripcmd "$dsttmp"; } && ++ { test -z "$chmodcmd" || $doit $chmodcmd $mode "$dsttmp"; } && ++ ++ # If -C, don't bother to copy if it wouldn't change the file. ++ if $copy_on_change && ++ old=`LC_ALL=C ls -dlL "$dst" 2>/dev/null` && ++ new=`LC_ALL=C ls -dlL "$dsttmp" 2>/dev/null` && ++ set -f && ++ set X $old && old=:$2:$4:$5:$6 && ++ set X $new && new=:$2:$4:$5:$6 && ++ set +f && ++ test "$old" = "$new" && ++ $cmpprog "$dst" "$dsttmp" >/dev/null 2>&1 ++ then ++ rm -f "$dsttmp" ++ else ++ # Rename the file to the real destination. ++ $doit $mvcmd -f "$dsttmp" "$dst" 2>/dev/null || ++ ++ # The rename failed, perhaps because mv can't rename something else ++ # to itself, or perhaps because mv is so ancient that it does not ++ # support -f. ++ { ++ # Now remove or move aside any old file at destination location. ++ # We try this two ways since rm can't unlink itself on some ++ # systems and the destination file might be busy for other ++ # reasons. In this case, the final cleanup might fail but the new ++ # file should still install successfully. ++ { ++ test ! -f "$dst" || ++ $doit $rmcmd -f "$dst" 2>/dev/null || ++ { $doit $mvcmd -f "$dst" "$rmtmp" 2>/dev/null && ++ { $doit $rmcmd -f "$rmtmp" 2>/dev/null; :; } ++ } || ++ { echo "$0: cannot unlink or rename $dst" >&2 ++ (exit 1); exit 1 ++ } ++ } && ++ ++ # Now rename the file to the real destination. ++ $doit $mvcmd "$dsttmp" "$dst" ++ } ++ fi || exit 1 ++ ++ trap '' 0 ++ fi ++done ++ ++# Local variables: ++# eval: (add-hook 'write-file-hooks 'time-stamp) ++# time-stamp-start: "scriptversion=" ++# time-stamp-format: "%:y-%02m-%02d.%02H" ++# time-stamp-time-zone: "UTC" ++# time-stamp-end: "; # UTC" ++# End: +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/la_uid_t.m4 +@@ -0,0 +1,20 @@ ++# la_TYPE_UID_T ++# ------------- ++AC_DEFUN([la_TYPE_UID_T], ++[AC_REQUIRE([AC_CANONICAL_HOST])dnl ++AC_CACHE_CHECK(for uid_t in sys/types.h, la_cv_type_uid_t, ++[AC_EGREP_HEADER(uid_t, sys/types.h, ++ la_cv_type_uid_t=yes, la_cv_type_uid_t=no)]) ++if test $la_cv_type_uid_t = no; then ++ case $host in ++ *mingw*) def_uid_t=short ;; ++ *) def_uid_t=int ;; ++ esac ++ AC_DEFINE_UNQUOTED(uid_t, [$def_uid_t], ++ [Define to match typeof st_uid field of struct stat if doesn't define.]) ++ AC_DEFINE_UNQUOTED(gid_t, [$def_uid_t], ++ [Define to match typeof st_gid field of struct stat if doesn't define.]) ++fi ++]) ++AU_ALIAS([AC_TYPE_UID_T], [la_TYPE_UID_T]) ++ +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/lib-ld.m4 +@@ -0,0 +1,109 @@ ++# lib-ld.m4 serial 5 (gettext-0.18.2) ++dnl Copyright (C) 1996-2003, 2009-2011 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 Subroutines of libtool.m4, ++dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision ++dnl with libtool.m4. ++ ++dnl From libtool-1.4. Sets the variable with_gnu_ld to yes or no. ++AC_DEFUN([AC_LIB_PROG_LD_GNU], ++[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], [acl_cv_prog_gnu_ld], ++[# I'd rather use --version here, but apparently some GNU ld's only accept -v. ++case `$LD -v 2>&1 /dev/null 2>&1 \ ++ && { (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 \ ++ || PATH_SEPARATOR=';' ++ } ++fi ++ac_prog=ld ++if test "$GCC" = yes; then ++ # Check if gcc -print-prog-name=ld gives a path. ++ AC_MSG_CHECKING([for ld used by GCC]) ++ case $host in ++ *-*-mingw*) ++ # gcc leaves a trailing carriage return which upsets mingw ++ ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;; ++ *) ++ ac_prog=`($CC -print-prog-name=ld) 2>&5` ;; ++ esac ++ case $ac_prog in ++ # Accept absolute paths. ++ [[\\/]* | [A-Za-z]:[\\/]*)] ++ [re_direlt='/[^/][^/]*/\.\./'] ++ # Canonicalize the path of ld ++ ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'` ++ while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do ++ ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"` ++ done ++ test -z "$LD" && LD="$ac_prog" ++ ;; ++ "") ++ # If it fails, then pretend we aren't using GCC. ++ ac_prog=ld ++ ;; ++ *) ++ # If it is relative, then search for the first ld in PATH. ++ with_gnu_ld=unknown ++ ;; ++ esac ++elif test "$with_gnu_ld" = yes; then ++ AC_MSG_CHECKING([for GNU ld]) ++else ++ AC_MSG_CHECKING([for non-GNU ld]) ++fi ++AC_CACHE_VAL([acl_cv_path_LD], ++[if test -z "$LD"; then ++ IFS="${IFS= }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}" ++ for ac_dir in $PATH; do ++ test -z "$ac_dir" && ac_dir=. ++ if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then ++ acl_cv_path_LD="$ac_dir/$ac_prog" ++ # Check to see if the program is GNU ld. I'd rather use --version, ++ # but apparently some GNU ld's only accept -v. ++ # Break only if it was the GNU/non-GNU ld that we prefer. ++ case `"$acl_cv_path_LD" -v 2>&1 < /dev/null` in ++ *GNU* | *'with BFD'*) ++ test "$with_gnu_ld" != no && break ;; ++ *) ++ test "$with_gnu_ld" != yes && break ;; ++ esac ++ fi ++ done ++ IFS="$ac_save_ifs" ++else ++ acl_cv_path_LD="$LD" # Let the user override the test with a path. ++fi]) ++LD="$acl_cv_path_LD" ++if test -n "$LD"; then ++ AC_MSG_RESULT([$LD]) ++else ++ AC_MSG_RESULT([no]) ++fi ++test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH]) ++AC_LIB_PROG_LD_GNU ++]) +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/lib-link.m4 +@@ -0,0 +1,777 @@ ++# lib-link.m4 serial 26 (gettext-0.18.2) ++dnl Copyright (C) 2001-2011 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 From Bruno Haible. ++ ++AC_PREREQ([2.54]) ++ ++dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and ++dnl the libraries corresponding to explicit and implicit dependencies. ++dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and ++dnl augments the CPPFLAGS variable. ++dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname ++dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem. ++AC_DEFUN([AC_LIB_LINKFLAGS], ++[ ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ AC_REQUIRE([AC_LIB_RPATH]) ++ pushdef([Name],[m4_translit([$1],[./+-], [____])]) ++ pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) ++ AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [ ++ AC_LIB_LINKFLAGS_BODY([$1], [$2]) ++ ac_cv_lib[]Name[]_libs="$LIB[]NAME" ++ ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME" ++ ac_cv_lib[]Name[]_cppflags="$INC[]NAME" ++ ac_cv_lib[]Name[]_prefix="$LIB[]NAME[]_PREFIX" ++ ]) ++ LIB[]NAME="$ac_cv_lib[]Name[]_libs" ++ LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs" ++ INC[]NAME="$ac_cv_lib[]Name[]_cppflags" ++ LIB[]NAME[]_PREFIX="$ac_cv_lib[]Name[]_prefix" ++ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME) ++ AC_SUBST([LIB]NAME) ++ AC_SUBST([LTLIB]NAME) ++ AC_SUBST([LIB]NAME[_PREFIX]) ++ dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the ++ dnl results of this search when this library appears as a dependency. ++ HAVE_LIB[]NAME=yes ++ popdef([NAME]) ++ popdef([Name]) ++]) ++ ++dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode, [missing-message]) ++dnl searches for libname and the libraries corresponding to explicit and ++dnl implicit dependencies, together with the specified include files and ++dnl the ability to compile and link the specified testcode. The missing-message ++dnl defaults to 'no' and may contain additional hints for the user. ++dnl If found, it sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} ++dnl and LTLIB${NAME} variables and augments the CPPFLAGS variable, and ++dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs ++dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty. ++dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname ++dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem. ++AC_DEFUN([AC_LIB_HAVE_LINKFLAGS], ++[ ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ AC_REQUIRE([AC_LIB_RPATH]) ++ pushdef([Name],[m4_translit([$1],[./+-], [____])]) ++ pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) ++ ++ dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME ++ dnl accordingly. ++ AC_LIB_LINKFLAGS_BODY([$1], [$2]) ++ ++ dnl Add $INC[]NAME to CPPFLAGS before performing the following checks, ++ dnl because if the user has installed lib[]Name and not disabled its use ++ dnl via --without-lib[]Name-prefix, he wants to use it. ++ ac_save_CPPFLAGS="$CPPFLAGS" ++ AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME) ++ ++ AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [ ++ ac_save_LIBS="$LIBS" ++ dnl If $LIB[]NAME contains some -l options, add it to the end of LIBS, ++ dnl because these -l options might require -L options that are present in ++ dnl LIBS. -l options benefit only from the -L options listed before it. ++ dnl Otherwise, add it to the front of LIBS, because it may be a static ++ dnl library that depends on another static library that is present in LIBS. ++ dnl Static libraries benefit only from the static libraries listed after ++ dnl it. ++ case " $LIB[]NAME" in ++ *" -l"*) LIBS="$LIBS $LIB[]NAME" ;; ++ *) LIBS="$LIB[]NAME $LIBS" ;; ++ esac ++ AC_LINK_IFELSE( ++ [AC_LANG_PROGRAM([[$3]], [[$4]])], ++ [ac_cv_lib[]Name=yes], ++ [ac_cv_lib[]Name='m4_if([$5], [], [no], [[$5]])']) ++ LIBS="$ac_save_LIBS" ++ ]) ++ if test "$ac_cv_lib[]Name" = yes; then ++ HAVE_LIB[]NAME=yes ++ AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the lib][$1 library.]) ++ AC_MSG_CHECKING([how to link with lib[]$1]) ++ AC_MSG_RESULT([$LIB[]NAME]) ++ else ++ HAVE_LIB[]NAME=no ++ dnl If $LIB[]NAME didn't lead to a usable library, we don't need ++ dnl $INC[]NAME either. ++ CPPFLAGS="$ac_save_CPPFLAGS" ++ LIB[]NAME= ++ LTLIB[]NAME= ++ LIB[]NAME[]_PREFIX= ++ fi ++ AC_SUBST([HAVE_LIB]NAME) ++ AC_SUBST([LIB]NAME) ++ AC_SUBST([LTLIB]NAME) ++ AC_SUBST([LIB]NAME[_PREFIX]) ++ popdef([NAME]) ++ popdef([Name]) ++]) ++ ++dnl Determine the platform dependent parameters needed to use rpath: ++dnl acl_libext, ++dnl acl_shlibext, ++dnl acl_libname_spec, ++dnl acl_library_names_spec, ++dnl acl_hardcode_libdir_flag_spec, ++dnl acl_hardcode_libdir_separator, ++dnl acl_hardcode_direct, ++dnl acl_hardcode_minus_L. ++AC_DEFUN([AC_LIB_RPATH], ++[ ++ dnl Tell automake >= 1.10 to complain if config.rpath is missing. ++ m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([config.rpath])]) ++ AC_REQUIRE([AC_PROG_CC]) dnl we use $CC, $GCC, $LDFLAGS ++ AC_REQUIRE([AC_LIB_PROG_LD]) dnl we use $LD, $with_gnu_ld ++ AC_REQUIRE([AC_CANONICAL_HOST]) dnl we use $host ++ AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir ++ AC_CACHE_CHECK([for shared library run path origin], [acl_cv_rpath], [ ++ CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \ ++ ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh ++ . ./conftest.sh ++ rm -f ./conftest.sh ++ acl_cv_rpath=done ++ ]) ++ wl="$acl_cv_wl" ++ acl_libext="$acl_cv_libext" ++ acl_shlibext="$acl_cv_shlibext" ++ acl_libname_spec="$acl_cv_libname_spec" ++ acl_library_names_spec="$acl_cv_library_names_spec" ++ acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec" ++ acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator" ++ acl_hardcode_direct="$acl_cv_hardcode_direct" ++ acl_hardcode_minus_L="$acl_cv_hardcode_minus_L" ++ dnl Determine whether the user wants rpath handling at all. ++ AC_ARG_ENABLE([rpath], ++ [ --disable-rpath do not hardcode runtime library paths], ++ :, enable_rpath=yes) ++]) ++ ++dnl AC_LIB_FROMPACKAGE(name, package) ++dnl declares that libname comes from the given package. The configure file ++dnl will then not have a --with-libname-prefix option but a ++dnl --with-package-prefix option. Several libraries can come from the same ++dnl package. This declaration must occur before an AC_LIB_LINKFLAGS or similar ++dnl macro call that searches for libname. ++AC_DEFUN([AC_LIB_FROMPACKAGE], ++[ ++ pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) ++ define([acl_frompackage_]NAME, [$2]) ++ popdef([NAME]) ++ pushdef([PACK],[$2]) ++ pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) ++ define([acl_libsinpackage_]PACKUP, ++ m4_ifdef([acl_libsinpackage_]PACKUP, [m4_defn([acl_libsinpackage_]PACKUP)[, ]],)[lib$1]) ++ popdef([PACKUP]) ++ popdef([PACK]) ++]) ++ ++dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and ++dnl the libraries corresponding to explicit and implicit dependencies. ++dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables. ++dnl Also, sets the LIB${NAME}_PREFIX variable to nonempty if libname was found ++dnl in ${LIB${NAME}_PREFIX}/$acl_libdirstem. ++AC_DEFUN([AC_LIB_LINKFLAGS_BODY], ++[ ++ AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) ++ pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) ++ pushdef([PACK],[m4_ifdef([acl_frompackage_]NAME, [acl_frompackage_]NAME, lib[$1])]) ++ pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-], ++ [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])]) ++ pushdef([PACKLIBS],[m4_ifdef([acl_frompackage_]NAME, [acl_libsinpackage_]PACKUP, lib[$1])]) ++ dnl Autoconf >= 2.61 supports dots in --with options. ++ pushdef([P_A_C_K],[m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]),[2.61]),[-1],[m4_translit(PACK,[.],[_])],PACK)]) ++ dnl By default, look in $includedir and $libdir. ++ use_additional=yes ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ ]) ++ AC_ARG_WITH(P_A_C_K[-prefix], ++[[ --with-]]P_A_C_K[[-prefix[=DIR] search for ]PACKLIBS[ in DIR/include and DIR/lib ++ --without-]]P_A_C_K[[-prefix don't search for ]PACKLIBS[ in includedir and libdir]], ++[ ++ if test "X$withval" = "Xno"; then ++ use_additional=no ++ else ++ if test "X$withval" = "X"; then ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ ]) ++ else ++ additional_includedir="$withval/include" ++ additional_libdir="$withval/$acl_libdirstem" ++ if test "$acl_libdirstem2" != "$acl_libdirstem" \ ++ && ! test -d "$withval/$acl_libdirstem"; then ++ additional_libdir="$withval/$acl_libdirstem2" ++ fi ++ fi ++ fi ++]) ++ dnl Search the library and its dependencies in $additional_libdir and ++ dnl $LDFLAGS. Using breadth-first-seach. ++ LIB[]NAME= ++ LTLIB[]NAME= ++ INC[]NAME= ++ LIB[]NAME[]_PREFIX= ++ dnl HAVE_LIB${NAME} is an indicator that LIB${NAME}, LTLIB${NAME} have been ++ dnl computed. So it has to be reset here. ++ HAVE_LIB[]NAME= ++ rpathdirs= ++ ltrpathdirs= ++ names_already_handled= ++ names_next_round='$1 $2' ++ while test -n "$names_next_round"; do ++ names_this_round="$names_next_round" ++ names_next_round= ++ for name in $names_this_round; do ++ already_handled= ++ for n in $names_already_handled; do ++ if test "$n" = "$name"; then ++ already_handled=yes ++ break ++ fi ++ done ++ if test -z "$already_handled"; then ++ names_already_handled="$names_already_handled $name" ++ dnl See if it was already located by an earlier AC_LIB_LINKFLAGS ++ dnl or AC_LIB_HAVE_LINKFLAGS call. ++ uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./+-|ABCDEFGHIJKLMNOPQRSTUVWXYZ____|'` ++ eval value=\"\$HAVE_LIB$uppername\" ++ if test -n "$value"; then ++ if test "$value" = yes; then ++ eval value=\"\$LIB$uppername\" ++ test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value" ++ eval value=\"\$LTLIB$uppername\" ++ test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value" ++ else ++ dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined ++ dnl that this library doesn't exist. So just drop it. ++ : ++ fi ++ else ++ dnl Search the library lib$name in $additional_libdir and $LDFLAGS ++ dnl and the already constructed $LIBNAME/$LTLIBNAME. ++ found_dir= ++ found_la= ++ found_so= ++ found_a= ++ eval libname=\"$acl_libname_spec\" # typically: libname=lib$name ++ if test -n "$acl_shlibext"; then ++ shrext=".$acl_shlibext" # typically: shrext=.so ++ else ++ shrext= ++ fi ++ if test $use_additional = yes; then ++ dir="$additional_libdir" ++ dnl The same code as in the loop below: ++ dnl First look for a shared library. ++ if test -n "$acl_shlibext"; then ++ if test -f "$dir/$libname$shrext"; then ++ found_dir="$dir" ++ found_so="$dir/$libname$shrext" ++ else ++ if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then ++ ver=`(cd "$dir" && \ ++ for f in "$libname$shrext".*; do echo "$f"; done \ ++ | sed -e "s,^$libname$shrext\\\\.,," \ ++ | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ ++ | sed 1q ) 2>/dev/null` ++ if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then ++ found_dir="$dir" ++ found_so="$dir/$libname$shrext.$ver" ++ fi ++ else ++ eval library_names=\"$acl_library_names_spec\" ++ for f in $library_names; do ++ if test -f "$dir/$f"; then ++ found_dir="$dir" ++ found_so="$dir/$f" ++ break ++ fi ++ done ++ fi ++ fi ++ fi ++ dnl Then look for a static library. ++ if test "X$found_dir" = "X"; then ++ if test -f "$dir/$libname.$acl_libext"; then ++ found_dir="$dir" ++ found_a="$dir/$libname.$acl_libext" ++ fi ++ fi ++ if test "X$found_dir" != "X"; then ++ if test -f "$dir/$libname.la"; then ++ found_la="$dir/$libname.la" ++ fi ++ fi ++ fi ++ if test "X$found_dir" = "X"; then ++ for x in $LDFLAGS $LTLIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ case "$x" in ++ -L*) ++ dir=`echo "X$x" | sed -e 's/^X-L//'` ++ dnl First look for a shared library. ++ if test -n "$acl_shlibext"; then ++ if test -f "$dir/$libname$shrext"; then ++ found_dir="$dir" ++ found_so="$dir/$libname$shrext" ++ else ++ if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then ++ ver=`(cd "$dir" && \ ++ for f in "$libname$shrext".*; do echo "$f"; done \ ++ | sed -e "s,^$libname$shrext\\\\.,," \ ++ | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \ ++ | sed 1q ) 2>/dev/null` ++ if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then ++ found_dir="$dir" ++ found_so="$dir/$libname$shrext.$ver" ++ fi ++ else ++ eval library_names=\"$acl_library_names_spec\" ++ for f in $library_names; do ++ if test -f "$dir/$f"; then ++ found_dir="$dir" ++ found_so="$dir/$f" ++ break ++ fi ++ done ++ fi ++ fi ++ fi ++ dnl Then look for a static library. ++ if test "X$found_dir" = "X"; then ++ if test -f "$dir/$libname.$acl_libext"; then ++ found_dir="$dir" ++ found_a="$dir/$libname.$acl_libext" ++ fi ++ fi ++ if test "X$found_dir" != "X"; then ++ if test -f "$dir/$libname.la"; then ++ found_la="$dir/$libname.la" ++ fi ++ fi ++ ;; ++ esac ++ if test "X$found_dir" != "X"; then ++ break ++ fi ++ done ++ fi ++ if test "X$found_dir" != "X"; then ++ dnl Found the library. ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name" ++ if test "X$found_so" != "X"; then ++ dnl Linking with a shared library. We attempt to hardcode its ++ dnl directory into the executable's runpath, unless it's the ++ dnl standard /usr/lib. ++ if test "$enable_rpath" = no \ ++ || test "X$found_dir" = "X/usr/$acl_libdirstem" \ ++ || test "X$found_dir" = "X/usr/$acl_libdirstem2"; then ++ dnl No hardcoding is needed. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ else ++ dnl Use an explicit option to hardcode DIR into the resulting ++ dnl binary. ++ dnl Potentially add DIR to ltrpathdirs. ++ dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. ++ haveit= ++ for x in $ltrpathdirs; do ++ if test "X$x" = "X$found_dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ ltrpathdirs="$ltrpathdirs $found_dir" ++ fi ++ dnl The hardcoding into $LIBNAME is system dependent. ++ if test "$acl_hardcode_direct" = yes; then ++ dnl Using DIR/libNAME.so during linking hardcodes DIR into the ++ dnl resulting binary. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ else ++ if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then ++ dnl Use an explicit option to hardcode DIR into the resulting ++ dnl binary. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ dnl Potentially add DIR to rpathdirs. ++ dnl The rpathdirs will be appended to $LIBNAME at the end. ++ haveit= ++ for x in $rpathdirs; do ++ if test "X$x" = "X$found_dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ rpathdirs="$rpathdirs $found_dir" ++ fi ++ else ++ dnl Rely on "-L$found_dir". ++ dnl But don't add it if it's already contained in the LDFLAGS ++ dnl or the already constructed $LIBNAME ++ haveit= ++ for x in $LDFLAGS $LIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$found_dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir" ++ fi ++ if test "$acl_hardcode_minus_L" != no; then ++ dnl FIXME: Not sure whether we should use ++ dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" ++ dnl here. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so" ++ else ++ dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH ++ dnl here, because this doesn't fit in flags passed to the ++ dnl compiler. So give up. No hardcoding. This affects only ++ dnl very old systems. ++ dnl FIXME: Not sure whether we should use ++ dnl "-L$found_dir -l$name" or "-L$found_dir $found_so" ++ dnl here. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" ++ fi ++ fi ++ fi ++ fi ++ else ++ if test "X$found_a" != "X"; then ++ dnl Linking with a static library. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a" ++ else ++ dnl We shouldn't come here, but anyway it's good to have a ++ dnl fallback. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name" ++ fi ++ fi ++ dnl Assume the include files are nearby. ++ additional_includedir= ++ case "$found_dir" in ++ */$acl_libdirstem | */$acl_libdirstem/) ++ basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'` ++ if test "$name" = '$1'; then ++ LIB[]NAME[]_PREFIX="$basedir" ++ fi ++ additional_includedir="$basedir/include" ++ ;; ++ */$acl_libdirstem2 | */$acl_libdirstem2/) ++ basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem2/"'*$,,'` ++ if test "$name" = '$1'; then ++ LIB[]NAME[]_PREFIX="$basedir" ++ fi ++ additional_includedir="$basedir/include" ++ ;; ++ esac ++ if test "X$additional_includedir" != "X"; then ++ dnl Potentially add $additional_includedir to $INCNAME. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/include, ++ dnl 2. if it's /usr/local/include and we are using GCC on Linux, ++ dnl 3. if it's already present in $CPPFLAGS or the already ++ dnl constructed $INCNAME, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$additional_includedir" != "X/usr/include"; then ++ haveit= ++ if test "X$additional_includedir" = "X/usr/local/include"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux* | gnu* | k*bsd*-gnu) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ for x in $CPPFLAGS $INC[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-I$additional_includedir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test -d "$additional_includedir"; then ++ dnl Really add $additional_includedir to $INCNAME. ++ INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir" ++ fi ++ fi ++ fi ++ fi ++ fi ++ dnl Look for dependencies. ++ if test -n "$found_la"; then ++ dnl Read the .la file. It defines the variables ++ dnl dlname, library_names, old_library, dependency_libs, current, ++ dnl age, revision, installed, dlopen, dlpreopen, libdir. ++ save_libdir="$libdir" ++ case "$found_la" in ++ */* | *\\*) . "$found_la" ;; ++ *) . "./$found_la" ;; ++ esac ++ libdir="$save_libdir" ++ dnl We use only dependency_libs. ++ for dep in $dependency_libs; do ++ case "$dep" in ++ -L*) ++ additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'` ++ dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/lib, ++ dnl 2. if it's /usr/local/lib and we are using GCC on Linux, ++ dnl 3. if it's already present in $LDFLAGS or the already ++ dnl constructed $LIBNAME, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$additional_libdir" != "X/usr/$acl_libdirstem" \ ++ && test "X$additional_libdir" != "X/usr/$acl_libdirstem2"; then ++ haveit= ++ if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem" \ ++ || test "X$additional_libdir" = "X/usr/local/$acl_libdirstem2"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux* | gnu* | k*bsd*-gnu) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ haveit= ++ for x in $LDFLAGS $LIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$additional_libdir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test -d "$additional_libdir"; then ++ dnl Really add $additional_libdir to $LIBNAME. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir" ++ fi ++ fi ++ haveit= ++ for x in $LDFLAGS $LTLIB[]NAME; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$additional_libdir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test -d "$additional_libdir"; then ++ dnl Really add $additional_libdir to $LTLIBNAME. ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir" ++ fi ++ fi ++ fi ++ fi ++ ;; ++ -R*) ++ dir=`echo "X$dep" | sed -e 's/^X-R//'` ++ if test "$enable_rpath" != no; then ++ dnl Potentially add DIR to rpathdirs. ++ dnl The rpathdirs will be appended to $LIBNAME at the end. ++ haveit= ++ for x in $rpathdirs; do ++ if test "X$x" = "X$dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ rpathdirs="$rpathdirs $dir" ++ fi ++ dnl Potentially add DIR to ltrpathdirs. ++ dnl The ltrpathdirs will be appended to $LTLIBNAME at the end. ++ haveit= ++ for x in $ltrpathdirs; do ++ if test "X$x" = "X$dir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ ltrpathdirs="$ltrpathdirs $dir" ++ fi ++ fi ++ ;; ++ -l*) ++ dnl Handle this in the next round. ++ names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'` ++ ;; ++ *.la) ++ dnl Handle this in the next round. Throw away the .la's ++ dnl directory; it is already contained in a preceding -L ++ dnl option. ++ names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'` ++ ;; ++ *) ++ dnl Most likely an immediate library name. ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep" ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep" ++ ;; ++ esac ++ done ++ fi ++ else ++ dnl Didn't find the library; assume it is in the system directories ++ dnl known to the linker and runtime loader. (All the system ++ dnl directories known to the linker should also be known to the ++ dnl runtime loader, otherwise the system is severely misconfigured.) ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name" ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name" ++ fi ++ fi ++ fi ++ done ++ done ++ if test "X$rpathdirs" != "X"; then ++ if test -n "$acl_hardcode_libdir_separator"; then ++ dnl Weird platform: only the last -rpath option counts, the user must ++ dnl pass all path elements in one option. We can arrange that for a ++ dnl single library, but not when more than one $LIBNAMEs are used. ++ alldirs= ++ for found_dir in $rpathdirs; do ++ alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir" ++ done ++ dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl. ++ acl_save_libdir="$libdir" ++ libdir="$alldirs" ++ eval flag=\"$acl_hardcode_libdir_flag_spec\" ++ libdir="$acl_save_libdir" ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" ++ else ++ dnl The -rpath options are cumulative. ++ for found_dir in $rpathdirs; do ++ acl_save_libdir="$libdir" ++ libdir="$found_dir" ++ eval flag=\"$acl_hardcode_libdir_flag_spec\" ++ libdir="$acl_save_libdir" ++ LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag" ++ done ++ fi ++ fi ++ if test "X$ltrpathdirs" != "X"; then ++ dnl When using libtool, the option that works for both libraries and ++ dnl executables is -R. The -R options are cumulative. ++ for found_dir in $ltrpathdirs; do ++ LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir" ++ done ++ fi ++ popdef([P_A_C_K]) ++ popdef([PACKLIBS]) ++ popdef([PACKUP]) ++ popdef([PACK]) ++ popdef([NAME]) ++]) ++ ++dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR, ++dnl unless already present in VAR. ++dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes ++dnl contains two or three consecutive elements that belong together. ++AC_DEFUN([AC_LIB_APPENDTOVAR], ++[ ++ for element in [$2]; do ++ haveit= ++ for x in $[$1]; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X$element"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ [$1]="${[$1]}${[$1]:+ }$element" ++ fi ++ done ++]) ++ ++dnl For those cases where a variable contains several -L and -l options ++dnl referring to unknown libraries and directories, this macro determines the ++dnl necessary additional linker options for the runtime path. ++dnl AC_LIB_LINKFLAGS_FROM_LIBS([LDADDVAR], [LIBSVALUE], [USE-LIBTOOL]) ++dnl sets LDADDVAR to linker options needed together with LIBSVALUE. ++dnl If USE-LIBTOOL evaluates to non-empty, linking with libtool is assumed, ++dnl otherwise linking without libtool is assumed. ++AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS], ++[ ++ AC_REQUIRE([AC_LIB_RPATH]) ++ AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) ++ $1= ++ if test "$enable_rpath" != no; then ++ if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then ++ dnl Use an explicit option to hardcode directories into the resulting ++ dnl binary. ++ rpathdirs= ++ next= ++ for opt in $2; do ++ if test -n "$next"; then ++ dir="$next" ++ dnl No need to hardcode the standard /usr/lib. ++ if test "X$dir" != "X/usr/$acl_libdirstem" \ ++ && test "X$dir" != "X/usr/$acl_libdirstem2"; then ++ rpathdirs="$rpathdirs $dir" ++ fi ++ next= ++ else ++ case $opt in ++ -L) next=yes ;; ++ -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'` ++ dnl No need to hardcode the standard /usr/lib. ++ if test "X$dir" != "X/usr/$acl_libdirstem" \ ++ && test "X$dir" != "X/usr/$acl_libdirstem2"; then ++ rpathdirs="$rpathdirs $dir" ++ fi ++ next= ;; ++ *) next= ;; ++ esac ++ fi ++ done ++ if test "X$rpathdirs" != "X"; then ++ if test -n ""$3""; then ++ dnl libtool is used for linking. Use -R options. ++ for dir in $rpathdirs; do ++ $1="${$1}${$1:+ }-R$dir" ++ done ++ else ++ dnl The linker is used for linking directly. ++ if test -n "$acl_hardcode_libdir_separator"; then ++ dnl Weird platform: only the last -rpath option counts, the user ++ dnl must pass all path elements in one option. ++ alldirs= ++ for dir in $rpathdirs; do ++ alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir" ++ done ++ acl_save_libdir="$libdir" ++ libdir="$alldirs" ++ eval flag=\"$acl_hardcode_libdir_flag_spec\" ++ libdir="$acl_save_libdir" ++ $1="$flag" ++ else ++ dnl The -rpath options are cumulative. ++ for dir in $rpathdirs; do ++ acl_save_libdir="$libdir" ++ libdir="$dir" ++ eval flag=\"$acl_hardcode_libdir_flag_spec\" ++ libdir="$acl_save_libdir" ++ $1="${$1}${$1:+ }$flag" ++ done ++ fi ++ fi ++ fi ++ fi ++ fi ++ AC_SUBST([$1]) ++]) +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/lib-prefix.m4 +@@ -0,0 +1,224 @@ ++# lib-prefix.m4 serial 7 (gettext-0.18) ++dnl Copyright (C) 2001-2005, 2008-2011 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 From Bruno Haible. ++ ++dnl AC_LIB_ARG_WITH is synonymous to AC_ARG_WITH in autoconf-2.13, and ++dnl similar to AC_ARG_WITH in autoconf 2.52...2.57 except that is doesn't ++dnl require excessive bracketing. ++ifdef([AC_HELP_STRING], ++[AC_DEFUN([AC_LIB_ARG_WITH], [AC_ARG_WITH([$1],[[$2]],[$3],[$4])])], ++[AC_DEFUN([AC_][LIB_ARG_WITH], [AC_ARG_WITH([$1],[$2],[$3],[$4])])]) ++ ++dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed ++dnl to access previously installed libraries. The basic assumption is that ++dnl a user will want packages to use other packages he previously installed ++dnl with the same --prefix option. ++dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate ++dnl libraries, but is otherwise very convenient. ++AC_DEFUN([AC_LIB_PREFIX], ++[ ++ AC_BEFORE([$0], [AC_LIB_LINKFLAGS]) ++ AC_REQUIRE([AC_PROG_CC]) ++ AC_REQUIRE([AC_CANONICAL_HOST]) ++ AC_REQUIRE([AC_LIB_PREPARE_MULTILIB]) ++ AC_REQUIRE([AC_LIB_PREPARE_PREFIX]) ++ dnl By default, look in $includedir and $libdir. ++ use_additional=yes ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ ]) ++ AC_LIB_ARG_WITH([lib-prefix], ++[ --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib ++ --without-lib-prefix don't search for libraries in includedir and libdir], ++[ ++ if test "X$withval" = "Xno"; then ++ use_additional=no ++ else ++ if test "X$withval" = "X"; then ++ AC_LIB_WITH_FINAL_PREFIX([ ++ eval additional_includedir=\"$includedir\" ++ eval additional_libdir=\"$libdir\" ++ ]) ++ else ++ additional_includedir="$withval/include" ++ additional_libdir="$withval/$acl_libdirstem" ++ fi ++ fi ++]) ++ if test $use_additional = yes; then ++ dnl Potentially add $additional_includedir to $CPPFLAGS. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/include, ++ dnl 2. if it's already present in $CPPFLAGS, ++ dnl 3. if it's /usr/local/include and we are using GCC on Linux, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$additional_includedir" != "X/usr/include"; then ++ haveit= ++ for x in $CPPFLAGS; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-I$additional_includedir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test "X$additional_includedir" = "X/usr/local/include"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux* | gnu* | k*bsd*-gnu) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ if test -d "$additional_includedir"; then ++ dnl Really add $additional_includedir to $CPPFLAGS. ++ CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir" ++ fi ++ fi ++ fi ++ fi ++ dnl Potentially add $additional_libdir to $LDFLAGS. ++ dnl But don't add it ++ dnl 1. if it's the standard /usr/lib, ++ dnl 2. if it's already present in $LDFLAGS, ++ dnl 3. if it's /usr/local/lib and we are using GCC on Linux, ++ dnl 4. if it doesn't exist as a directory. ++ if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then ++ haveit= ++ for x in $LDFLAGS; do ++ AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"]) ++ if test "X$x" = "X-L$additional_libdir"; then ++ haveit=yes ++ break ++ fi ++ done ++ if test -z "$haveit"; then ++ if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then ++ if test -n "$GCC"; then ++ case $host_os in ++ linux*) haveit=yes;; ++ esac ++ fi ++ fi ++ if test -z "$haveit"; then ++ if test -d "$additional_libdir"; then ++ dnl Really add $additional_libdir to $LDFLAGS. ++ LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir" ++ fi ++ fi ++ fi ++ fi ++ fi ++]) ++ ++dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix, ++dnl acl_final_exec_prefix, containing the values to which $prefix and ++dnl $exec_prefix will expand at the end of the configure script. ++AC_DEFUN([AC_LIB_PREPARE_PREFIX], ++[ ++ dnl Unfortunately, prefix and exec_prefix get only finally determined ++ dnl at the end of configure. ++ if test "X$prefix" = "XNONE"; then ++ acl_final_prefix="$ac_default_prefix" ++ else ++ acl_final_prefix="$prefix" ++ fi ++ if test "X$exec_prefix" = "XNONE"; then ++ acl_final_exec_prefix='${prefix}' ++ else ++ acl_final_exec_prefix="$exec_prefix" ++ fi ++ acl_save_prefix="$prefix" ++ prefix="$acl_final_prefix" ++ eval acl_final_exec_prefix=\"$acl_final_exec_prefix\" ++ prefix="$acl_save_prefix" ++]) ++ ++dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the ++dnl variables prefix and exec_prefix bound to the values they will have ++dnl at the end of the configure script. ++AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX], ++[ ++ acl_save_prefix="$prefix" ++ prefix="$acl_final_prefix" ++ acl_save_exec_prefix="$exec_prefix" ++ exec_prefix="$acl_final_exec_prefix" ++ $1 ++ exec_prefix="$acl_save_exec_prefix" ++ prefix="$acl_save_prefix" ++]) ++ ++dnl AC_LIB_PREPARE_MULTILIB creates ++dnl - a variable acl_libdirstem, containing the basename of the libdir, either ++dnl "lib" or "lib64" or "lib/64", ++dnl - a variable acl_libdirstem2, as a secondary possible value for ++dnl acl_libdirstem, either the same as acl_libdirstem or "lib/sparcv9" or ++dnl "lib/amd64". ++AC_DEFUN([AC_LIB_PREPARE_MULTILIB], ++[ ++ dnl There is no formal standard regarding lib and lib64. ++ dnl On glibc systems, the current practice is that on a system supporting ++ dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under ++ dnl $prefix/lib64 and 32-bit libraries go under $prefix/lib. We determine ++ dnl the compiler's default mode by looking at the compiler's library search ++ dnl path. If at least one of its elements ends in /lib64 or points to a ++ dnl directory whose absolute pathname ends in /lib64, we assume a 64-bit ABI. ++ dnl Otherwise we use the default, namely "lib". ++ dnl On Solaris systems, the current practice is that on a system supporting ++ dnl 32-bit and 64-bit instruction sets or ABIs, 64-bit libraries go under ++ dnl $prefix/lib/64 (which is a symlink to either $prefix/lib/sparcv9 or ++ dnl $prefix/lib/amd64) and 32-bit libraries go under $prefix/lib. ++ AC_REQUIRE([AC_CANONICAL_HOST]) ++ acl_libdirstem=lib ++ acl_libdirstem2= ++ case "$host_os" in ++ solaris*) ++ dnl See Solaris 10 Software Developer Collection > Solaris 64-bit Developer's Guide > The Development Environment ++ dnl . ++ dnl "Portable Makefiles should refer to any library directories using the 64 symbolic link." ++ dnl But we want to recognize the sparcv9 or amd64 subdirectory also if the ++ dnl symlink is missing, so we set acl_libdirstem2 too. ++ AC_CACHE_CHECK([for 64-bit host], [gl_cv_solaris_64bit], ++ [AC_EGREP_CPP([sixtyfour bits], [ ++#ifdef _LP64 ++sixtyfour bits ++#endif ++ ], [gl_cv_solaris_64bit=yes], [gl_cv_solaris_64bit=no]) ++ ]) ++ if test $gl_cv_solaris_64bit = yes; then ++ acl_libdirstem=lib/64 ++ case "$host_cpu" in ++ sparc*) acl_libdirstem2=lib/sparcv9 ;; ++ i*86 | x86_64) acl_libdirstem2=lib/amd64 ;; ++ esac ++ fi ++ ;; ++ *) ++ searchpath=`(LC_ALL=C $CC -print-search-dirs) 2>/dev/null | sed -n -e 's,^libraries: ,,p' | sed -e 's,^=,,'` ++ if test -n "$searchpath"; then ++ acl_save_IFS="${IFS= }"; IFS=":" ++ for searchdir in $searchpath; do ++ if test -d "$searchdir"; then ++ case "$searchdir" in ++ */lib64/ | */lib64 ) acl_libdirstem=lib64 ;; ++ */../ | */.. ) ++ # Better ignore directories of this form. They are misleading. ++ ;; ++ *) searchdir=`cd "$searchdir" && pwd` ++ case "$searchdir" in ++ */lib64 ) acl_libdirstem=lib64 ;; ++ esac ;; ++ esac ++ fi ++ done ++ IFS="$acl_save_IFS" ++ fi ++ ;; ++ esac ++ test -n "$acl_libdirstem2" || acl_libdirstem2="$acl_libdirstem" ++]) +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/ltmain.sh +@@ -0,0 +1,11156 @@ ++#! /bin/sh ++## DO NOT EDIT - This file generated from ./build-aux/ltmain.in ++## by inline-source v2014-01-03.01 ++ ++# libtool (GNU libtool) 2.4.6 ++# Provide generalized library-building support services. ++# Written by Gordon Matzigkeit , 1996 ++ ++# Copyright (C) 1996-2015 Free Software Foundation, Inc. ++# This is free software; see the source for copying conditions. There is NO ++# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ++ ++# GNU Libtool is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2 of the License, or ++# (at your option) any later version. ++# ++# As a special exception to the GNU General Public License, ++# if you distribute this file as part of a program or library that ++# is built using GNU Libtool, you may include this file under the ++# same distribution terms that you use for the rest of that program. ++# ++# GNU Libtool 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 . ++ ++ ++PROGRAM=libtool ++PACKAGE=libtool ++VERSION="2.4.6 Debian-2.4.6-2" ++package_revision=2.4.6 ++ ++ ++## ------ ## ++## Usage. ## ++## ------ ## ++ ++# Run './libtool --help' for help with using this script from the ++# command line. ++ ++ ++## ------------------------------- ## ++## User overridable command paths. ## ++## ------------------------------- ## ++ ++# After configure completes, it has a better idea of some of the ++# shell tools we need than the defaults used by the functions shared ++# with bootstrap, so set those here where they can still be over- ++# ridden by the user, but otherwise take precedence. ++ ++: ${AUTOCONF="autoconf"} ++: ${AUTOMAKE="automake"} ++ ++ ++## -------------------------- ## ++## Source external libraries. ## ++## -------------------------- ## ++ ++# Much of our low-level functionality needs to be sourced from external ++# libraries, which are installed to $pkgauxdir. ++ ++# Set a version string for this script. ++scriptversion=2015-01-20.17; # UTC ++ ++# General shell script boiler plate, and helper functions. ++# Written by Gary V. Vaughan, 2004 ++ ++# Copyright (C) 2004-2015 Free Software Foundation, Inc. ++# This is free software; see the source for copying conditions. There is NO ++# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ++ ++# 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. ++ ++# As a special exception to the GNU General Public License, if you distribute ++# this file as part of a program or library that is built using GNU Libtool, ++# you may include this file under the same distribution terms that you use ++# for the rest of that program. ++ ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNES 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 . ++ ++# Please report bugs or propose patches to gary@gnu.org. ++ ++ ++## ------ ## ++## Usage. ## ++## ------ ## ++ ++# Evaluate this file near the top of your script to gain access to ++# the functions and variables defined here: ++# ++# . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh ++# ++# If you need to override any of the default environment variable ++# settings, do that before evaluating this file. ++ ++ ++## -------------------- ## ++## Shell normalisation. ## ++## -------------------- ## ++ ++# Some shells need a little help to be as Bourne compatible as possible. ++# Before doing anything else, make sure all that help has been provided! ++ ++DUALCASE=1; export DUALCASE # for MKS sh ++if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then : ++ emulate sh ++ NULLCMD=: ++ # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which ++ # is contrary to our usage. Disable this feature. ++ alias -g '${1+"$@"}'='"$@"' ++ setopt NO_GLOB_SUBST ++else ++ case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac ++fi ++ ++# NLS nuisances: We save the old values in case they are required later. ++_G_user_locale= ++_G_safe_locale= ++for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES ++do ++ eval "if test set = \"\${$_G_var+set}\"; then ++ save_$_G_var=\$$_G_var ++ $_G_var=C ++ export $_G_var ++ _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\" ++ _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\" ++ fi" ++done ++ ++# CDPATH. ++(unset CDPATH) >/dev/null 2>&1 && unset CDPATH ++ ++# Make sure IFS has a sensible default ++sp=' ' ++nl=' ++' ++IFS="$sp $nl" ++ ++# There are apparently some retarded systems that use ';' as a PATH separator! ++if test "${PATH_SEPARATOR+set}" != set; then ++ PATH_SEPARATOR=: ++ (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && { ++ (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 || ++ PATH_SEPARATOR=';' ++ } ++fi ++ ++ ++ ++## ------------------------- ## ++## Locate command utilities. ## ++## ------------------------- ## ++ ++ ++# func_executable_p FILE ++# ---------------------- ++# Check that FILE is an executable regular file. ++func_executable_p () ++{ ++ test -f "$1" && test -x "$1" ++} ++ ++ ++# func_path_progs PROGS_LIST CHECK_FUNC [PATH] ++# -------------------------------------------- ++# Search for either a program that responds to --version with output ++# containing "GNU", or else returned by CHECK_FUNC otherwise, by ++# trying all the directories in PATH with each of the elements of ++# PROGS_LIST. ++# ++# CHECK_FUNC should accept the path to a candidate program, and ++# set $func_check_prog_result if it truncates its output less than ++# $_G_path_prog_max characters. ++func_path_progs () ++{ ++ _G_progs_list=$1 ++ _G_check_func=$2 ++ _G_PATH=${3-"$PATH"} ++ ++ _G_path_prog_max=0 ++ _G_path_prog_found=false ++ _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:} ++ for _G_dir in $_G_PATH; do ++ IFS=$_G_save_IFS ++ test -z "$_G_dir" && _G_dir=. ++ for _G_prog_name in $_G_progs_list; do ++ for _exeext in '' .EXE; do ++ _G_path_prog=$_G_dir/$_G_prog_name$_exeext ++ func_executable_p "$_G_path_prog" || continue ++ case `"$_G_path_prog" --version 2>&1` in ++ *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;; ++ *) $_G_check_func $_G_path_prog ++ func_path_progs_result=$func_check_prog_result ++ ;; ++ esac ++ $_G_path_prog_found && break 3 ++ done ++ done ++ done ++ IFS=$_G_save_IFS ++ test -z "$func_path_progs_result" && { ++ echo "no acceptable sed could be found in \$PATH" >&2 ++ exit 1 ++ } ++} ++ ++ ++# We want to be able to use the functions in this file before configure ++# has figured out where the best binaries are kept, which means we have ++# to search for them ourselves - except when the results are already set ++# where we skip the searches. ++ ++# Unless the user overrides by setting SED, search the path for either GNU ++# sed, or the sed that truncates its output the least. ++test -z "$SED" && { ++ _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/ ++ for _G_i in 1 2 3 4 5 6 7; do ++ _G_sed_script=$_G_sed_script$nl$_G_sed_script ++ done ++ echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed ++ _G_sed_script= ++ ++ func_check_prog_sed () ++ { ++ _G_path_prog=$1 ++ ++ _G_count=0 ++ printf 0123456789 >conftest.in ++ while : ++ do ++ cat conftest.in conftest.in >conftest.tmp ++ mv conftest.tmp conftest.in ++ cp conftest.in conftest.nl ++ echo '' >> conftest.nl ++ "$_G_path_prog" -f conftest.sed conftest.out 2>/dev/null || break ++ diff conftest.out conftest.nl >/dev/null 2>&1 || break ++ _G_count=`expr $_G_count + 1` ++ if test "$_G_count" -gt "$_G_path_prog_max"; then ++ # Best one so far, save it but keep looking for a better one ++ func_check_prog_result=$_G_path_prog ++ _G_path_prog_max=$_G_count ++ fi ++ # 10*(2^10) chars as input seems more than enough ++ test 10 -lt "$_G_count" && break ++ done ++ rm -f conftest.in conftest.tmp conftest.nl conftest.out ++ } ++ ++ func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin ++ rm -f conftest.sed ++ SED=$func_path_progs_result ++} ++ ++ ++# Unless the user overrides by setting GREP, search the path for either GNU ++# grep, or the grep that truncates its output the least. ++test -z "$GREP" && { ++ func_check_prog_grep () ++ { ++ _G_path_prog=$1 ++ ++ _G_count=0 ++ _G_path_prog_max=0 ++ printf 0123456789 >conftest.in ++ while : ++ do ++ cat conftest.in conftest.in >conftest.tmp ++ mv conftest.tmp conftest.in ++ cp conftest.in conftest.nl ++ echo 'GREP' >> conftest.nl ++ "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' conftest.out 2>/dev/null || break ++ diff conftest.out conftest.nl >/dev/null 2>&1 || break ++ _G_count=`expr $_G_count + 1` ++ if test "$_G_count" -gt "$_G_path_prog_max"; then ++ # Best one so far, save it but keep looking for a better one ++ func_check_prog_result=$_G_path_prog ++ _G_path_prog_max=$_G_count ++ fi ++ # 10*(2^10) chars as input seems more than enough ++ test 10 -lt "$_G_count" && break ++ done ++ rm -f conftest.in conftest.tmp conftest.nl conftest.out ++ } ++ ++ func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin ++ GREP=$func_path_progs_result ++} ++ ++ ++## ------------------------------- ## ++## User overridable command paths. ## ++## ------------------------------- ## ++ ++# All uppercase variable names are used for environment variables. These ++# variables can be overridden by the user before calling a script that ++# uses them if a suitable command of that name is not already available ++# in the command search PATH. ++ ++: ${CP="cp -f"} ++: ${ECHO="printf %s\n"} ++: ${EGREP="$GREP -E"} ++: ${FGREP="$GREP -F"} ++: ${LN_S="ln -s"} ++: ${MAKE="make"} ++: ${MKDIR="mkdir"} ++: ${MV="mv -f"} ++: ${RM="rm -f"} ++: ${SHELL="${CONFIG_SHELL-/bin/sh}"} ++ ++ ++## -------------------- ## ++## Useful sed snippets. ## ++## -------------------- ## ++ ++sed_dirname='s|/[^/]*$||' ++sed_basename='s|^.*/||' ++ ++# Sed substitution that helps us do robust quoting. It backslashifies ++# metacharacters that are still active within double-quoted strings. ++sed_quote_subst='s|\([`"$\\]\)|\\\1|g' ++ ++# Same as above, but do not quote variable references. ++sed_double_quote_subst='s/\(["`\\]\)/\\\1/g' ++ ++# Sed substitution that turns a string into a regex matching for the ++# string literally. ++sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g' ++ ++# Sed substitution that converts a w32 file name or path ++# that contains forward slashes, into one that contains ++# (escaped) backslashes. A very naive implementation. ++sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g' ++ ++# Re-'\' parameter expansions in output of sed_double_quote_subst that ++# were '\'-ed in input to the same. If an odd number of '\' preceded a ++# '$' in input to sed_double_quote_subst, that '$' was protected from ++# expansion. Since each input '\' is now two '\'s, look for any number ++# of runs of four '\'s followed by two '\'s and then a '$'. '\' that '$'. ++_G_bs='\\' ++_G_bs2='\\\\' ++_G_bs4='\\\\\\\\' ++_G_dollar='\$' ++sed_double_backslash="\ ++ s/$_G_bs4/&\\ ++/g ++ s/^$_G_bs2$_G_dollar/$_G_bs&/ ++ s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g ++ s/\n//g" ++ ++ ++## ----------------- ## ++## Global variables. ## ++## ----------------- ## ++ ++# Except for the global variables explicitly listed below, the following ++# functions in the '^func_' namespace, and the '^require_' namespace ++# variables initialised in the 'Resource management' section, sourcing ++# this file will not pollute your global namespace with anything ++# else. There's no portable way to scope variables in Bourne shell ++# though, so actually running these functions will sometimes place ++# results into a variable named after the function, and often use ++# temporary variables in the '^_G_' namespace. If you are careful to ++# avoid using those namespaces casually in your sourcing script, things ++# should continue to work as you expect. And, of course, you can freely ++# overwrite any of the functions or variables defined here before ++# calling anything to customize them. ++ ++EXIT_SUCCESS=0 ++EXIT_FAILURE=1 ++EXIT_MISMATCH=63 # $? = 63 is used to indicate version mismatch to missing. ++EXIT_SKIP=77 # $? = 77 is used to indicate a skipped test to automake. ++ ++# Allow overriding, eg assuming that you follow the convention of ++# putting '$debug_cmd' at the start of all your functions, you can get ++# bash to show function call trace with: ++# ++# debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name ++debug_cmd=${debug_cmd-":"} ++exit_cmd=: ++ ++# By convention, finish your script with: ++# ++# exit $exit_status ++# ++# so that you can set exit_status to non-zero if you want to indicate ++# something went wrong during execution without actually bailing out at ++# the point of failure. ++exit_status=$EXIT_SUCCESS ++ ++# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh ++# is ksh but when the shell is invoked as "sh" and the current value of ++# the _XPG environment variable is not equal to 1 (one), the special ++# positional parameter $0, within a function call, is the name of the ++# function. ++progpath=$0 ++ ++# The name of this program. ++progname=`$ECHO "$progpath" |$SED "$sed_basename"` ++ ++# Make sure we have an absolute progpath for reexecution: ++case $progpath in ++ [\\/]*|[A-Za-z]:\\*) ;; ++ *[\\/]*) ++ progdir=`$ECHO "$progpath" |$SED "$sed_dirname"` ++ progdir=`cd "$progdir" && pwd` ++ progpath=$progdir/$progname ++ ;; ++ *) ++ _G_IFS=$IFS ++ IFS=${PATH_SEPARATOR-:} ++ for progdir in $PATH; do ++ IFS=$_G_IFS ++ test -x "$progdir/$progname" && break ++ done ++ IFS=$_G_IFS ++ test -n "$progdir" || progdir=`pwd` ++ progpath=$progdir/$progname ++ ;; ++esac ++ ++ ++## ----------------- ## ++## Standard options. ## ++## ----------------- ## ++ ++# The following options affect the operation of the functions defined ++# below, and should be set appropriately depending on run-time para- ++# meters passed on the command line. ++ ++opt_dry_run=false ++opt_quiet=false ++opt_verbose=false ++ ++# Categories 'all' and 'none' are always available. Append any others ++# you will pass as the first argument to func_warning from your own ++# code. ++warning_categories= ++ ++# By default, display warnings according to 'opt_warning_types'. Set ++# 'warning_func' to ':' to elide all warnings, or func_fatal_error to ++# treat the next displayed warning as a fatal error. ++warning_func=func_warn_and_continue ++ ++# Set to 'all' to display all warnings, 'none' to suppress all ++# warnings, or a space delimited list of some subset of ++# 'warning_categories' to display only the listed warnings. ++opt_warning_types=all ++ ++ ++## -------------------- ## ++## Resource management. ## ++## -------------------- ## ++ ++# This section contains definitions for functions that each ensure a ++# particular resource (a file, or a non-empty configuration variable for ++# example) is available, and if appropriate to extract default values ++# from pertinent package files. Call them using their associated ++# 'require_*' variable to ensure that they are executed, at most, once. ++# ++# It's entirely deliberate that calling these functions can set ++# variables that don't obey the namespace limitations obeyed by the rest ++# of this file, in order that that they be as useful as possible to ++# callers. ++ ++ ++# require_term_colors ++# ------------------- ++# Allow display of bold text on terminals that support it. ++require_term_colors=func_require_term_colors ++func_require_term_colors () ++{ ++ $debug_cmd ++ ++ test -t 1 && { ++ # COLORTERM and USE_ANSI_COLORS environment variables take ++ # precedence, because most terminfo databases neglect to describe ++ # whether color sequences are supported. ++ test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"} ++ ++ if test 1 = "$USE_ANSI_COLORS"; then ++ # Standard ANSI escape sequences ++ tc_reset='' ++ tc_bold=''; tc_standout='' ++ tc_red=''; tc_green='' ++ tc_blue=''; tc_cyan='' ++ else ++ # Otherwise trust the terminfo database after all. ++ test -n "`tput sgr0 2>/dev/null`" && { ++ tc_reset=`tput sgr0` ++ test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold` ++ tc_standout=$tc_bold ++ test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso` ++ test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1` ++ test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2` ++ test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4` ++ test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5` ++ } ++ fi ++ } ++ ++ require_term_colors=: ++} ++ ++ ++## ----------------- ## ++## Function library. ## ++## ----------------- ## ++ ++# This section contains a variety of useful functions to call in your ++# scripts. Take note of the portable wrappers for features provided by ++# some modern shells, which will fall back to slower equivalents on ++# less featureful shells. ++ ++ ++# func_append VAR VALUE ++# --------------------- ++# Append VALUE onto the existing contents of VAR. ++ ++ # We should try to minimise forks, especially on Windows where they are ++ # unreasonably slow, so skip the feature probes when bash or zsh are ++ # being used: ++ if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then ++ : ${_G_HAVE_ARITH_OP="yes"} ++ : ${_G_HAVE_XSI_OPS="yes"} ++ # The += operator was introduced in bash 3.1 ++ case $BASH_VERSION in ++ [12].* | 3.0 | 3.0*) ;; ++ *) ++ : ${_G_HAVE_PLUSEQ_OP="yes"} ++ ;; ++ esac ++ fi ++ ++ # _G_HAVE_PLUSEQ_OP ++ # Can be empty, in which case the shell is probed, "yes" if += is ++ # useable or anything else if it does not work. ++ test -z "$_G_HAVE_PLUSEQ_OP" \ ++ && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \ ++ && _G_HAVE_PLUSEQ_OP=yes ++ ++if test yes = "$_G_HAVE_PLUSEQ_OP" ++then ++ # This is an XSI compatible shell, allowing a faster implementation... ++ eval 'func_append () ++ { ++ $debug_cmd ++ ++ eval "$1+=\$2" ++ }' ++else ++ # ...otherwise fall back to using expr, which is often a shell builtin. ++ func_append () ++ { ++ $debug_cmd ++ ++ eval "$1=\$$1\$2" ++ } ++fi ++ ++ ++# func_append_quoted VAR VALUE ++# ---------------------------- ++# Quote VALUE and append to the end of shell variable VAR, separated ++# by a space. ++if test yes = "$_G_HAVE_PLUSEQ_OP"; then ++ eval 'func_append_quoted () ++ { ++ $debug_cmd ++ ++ func_quote_for_eval "$2" ++ eval "$1+=\\ \$func_quote_for_eval_result" ++ }' ++else ++ func_append_quoted () ++ { ++ $debug_cmd ++ ++ func_quote_for_eval "$2" ++ eval "$1=\$$1\\ \$func_quote_for_eval_result" ++ } ++fi ++ ++ ++# func_append_uniq VAR VALUE ++# -------------------------- ++# Append unique VALUE onto the existing contents of VAR, assuming ++# entries are delimited by the first character of VALUE. For example: ++# ++# func_append_uniq options " --another-option option-argument" ++# ++# will only append to $options if " --another-option option-argument " ++# is not already present somewhere in $options already (note spaces at ++# each end implied by leading space in second argument). ++func_append_uniq () ++{ ++ $debug_cmd ++ ++ eval _G_current_value='`$ECHO $'$1'`' ++ _G_delim=`expr "$2" : '\(.\)'` ++ ++ case $_G_delim$_G_current_value$_G_delim in ++ *"$2$_G_delim"*) ;; ++ *) func_append "$@" ;; ++ esac ++} ++ ++ ++# func_arith TERM... ++# ------------------ ++# Set func_arith_result to the result of evaluating TERMs. ++ test -z "$_G_HAVE_ARITH_OP" \ ++ && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \ ++ && _G_HAVE_ARITH_OP=yes ++ ++if test yes = "$_G_HAVE_ARITH_OP"; then ++ eval 'func_arith () ++ { ++ $debug_cmd ++ ++ func_arith_result=$(( $* )) ++ }' ++else ++ func_arith () ++ { ++ $debug_cmd ++ ++ func_arith_result=`expr "$@"` ++ } ++fi ++ ++ ++# func_basename FILE ++# ------------------ ++# Set func_basename_result to FILE with everything up to and including ++# the last / stripped. ++if test yes = "$_G_HAVE_XSI_OPS"; then ++ # If this shell supports suffix pattern removal, then use it to avoid ++ # forking. Hide the definitions single quotes in case the shell chokes ++ # on unsupported syntax... ++ _b='func_basename_result=${1##*/}' ++ _d='case $1 in ++ */*) func_dirname_result=${1%/*}$2 ;; ++ * ) func_dirname_result=$3 ;; ++ esac' ++ ++else ++ # ...otherwise fall back to using sed. ++ _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`' ++ _d='func_dirname_result=`$ECHO "$1" |$SED "$sed_dirname"` ++ if test "X$func_dirname_result" = "X$1"; then ++ func_dirname_result=$3 ++ else ++ func_append func_dirname_result "$2" ++ fi' ++fi ++ ++eval 'func_basename () ++{ ++ $debug_cmd ++ ++ '"$_b"' ++}' ++ ++ ++# func_dirname FILE APPEND NONDIR_REPLACEMENT ++# ------------------------------------------- ++# Compute the dirname of FILE. If nonempty, add APPEND to the result, ++# otherwise set result to NONDIR_REPLACEMENT. ++eval 'func_dirname () ++{ ++ $debug_cmd ++ ++ '"$_d"' ++}' ++ ++ ++# func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT ++# -------------------------------------------------------- ++# Perform func_basename and func_dirname in a single function ++# call: ++# dirname: Compute the dirname of FILE. If nonempty, ++# add APPEND to the result, otherwise set result ++# to NONDIR_REPLACEMENT. ++# value returned in "$func_dirname_result" ++# basename: Compute filename of FILE. ++# value retuned in "$func_basename_result" ++# For efficiency, we do not delegate to the functions above but instead ++# duplicate the functionality here. ++eval 'func_dirname_and_basename () ++{ ++ $debug_cmd ++ ++ '"$_b"' ++ '"$_d"' ++}' ++ ++ ++# func_echo ARG... ++# ---------------- ++# Echo program name prefixed message. ++func_echo () ++{ ++ $debug_cmd ++ ++ _G_message=$* ++ ++ func_echo_IFS=$IFS ++ IFS=$nl ++ for _G_line in $_G_message; do ++ IFS=$func_echo_IFS ++ $ECHO "$progname: $_G_line" ++ done ++ IFS=$func_echo_IFS ++} ++ ++ ++# func_echo_all ARG... ++# -------------------- ++# Invoke $ECHO with all args, space-separated. ++func_echo_all () ++{ ++ $ECHO "$*" ++} ++ ++ ++# func_echo_infix_1 INFIX ARG... ++# ------------------------------ ++# Echo program name, followed by INFIX on the first line, with any ++# additional lines not showing INFIX. ++func_echo_infix_1 () ++{ ++ $debug_cmd ++ ++ $require_term_colors ++ ++ _G_infix=$1; shift ++ _G_indent=$_G_infix ++ _G_prefix="$progname: $_G_infix: " ++ _G_message=$* ++ ++ # Strip color escape sequences before counting printable length ++ for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan" ++ do ++ test -n "$_G_tc" && { ++ _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"` ++ _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"` ++ } ++ done ++ _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`" " ## exclude from sc_prohibit_nested_quotes ++ ++ func_echo_infix_1_IFS=$IFS ++ IFS=$nl ++ for _G_line in $_G_message; do ++ IFS=$func_echo_infix_1_IFS ++ $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2 ++ _G_prefix=$_G_indent ++ done ++ IFS=$func_echo_infix_1_IFS ++} ++ ++ ++# func_error ARG... ++# ----------------- ++# Echo program name prefixed message to standard error. ++func_error () ++{ ++ $debug_cmd ++ ++ $require_term_colors ++ ++ func_echo_infix_1 " $tc_standout${tc_red}error$tc_reset" "$*" >&2 ++} ++ ++ ++# func_fatal_error ARG... ++# ----------------------- ++# Echo program name prefixed message to standard error, and exit. ++func_fatal_error () ++{ ++ $debug_cmd ++ ++ func_error "$*" ++ exit $EXIT_FAILURE ++} ++ ++ ++# func_grep EXPRESSION FILENAME ++# ----------------------------- ++# Check whether EXPRESSION matches any line of FILENAME, without output. ++func_grep () ++{ ++ $debug_cmd ++ ++ $GREP "$1" "$2" >/dev/null 2>&1 ++} ++ ++ ++# func_len STRING ++# --------------- ++# Set func_len_result to the length of STRING. STRING may not ++# start with a hyphen. ++ test -z "$_G_HAVE_XSI_OPS" \ ++ && (eval 'x=a/b/c; ++ test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \ ++ && _G_HAVE_XSI_OPS=yes ++ ++if test yes = "$_G_HAVE_XSI_OPS"; then ++ eval 'func_len () ++ { ++ $debug_cmd ++ ++ func_len_result=${#1} ++ }' ++else ++ func_len () ++ { ++ $debug_cmd ++ ++ func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len` ++ } ++fi ++ ++ ++# func_mkdir_p DIRECTORY-PATH ++# --------------------------- ++# Make sure the entire path to DIRECTORY-PATH is available. ++func_mkdir_p () ++{ ++ $debug_cmd ++ ++ _G_directory_path=$1 ++ _G_dir_list= ++ ++ if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then ++ ++ # Protect directory names starting with '-' ++ case $_G_directory_path in ++ -*) _G_directory_path=./$_G_directory_path ;; ++ esac ++ ++ # While some portion of DIR does not yet exist... ++ while test ! -d "$_G_directory_path"; do ++ # ...make a list in topmost first order. Use a colon delimited ++ # list incase some portion of path contains whitespace. ++ _G_dir_list=$_G_directory_path:$_G_dir_list ++ ++ # If the last portion added has no slash in it, the list is done ++ case $_G_directory_path in */*) ;; *) break ;; esac ++ ++ # ...otherwise throw away the child directory and loop ++ _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"` ++ done ++ _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'` ++ ++ func_mkdir_p_IFS=$IFS; IFS=: ++ for _G_dir in $_G_dir_list; do ++ IFS=$func_mkdir_p_IFS ++ # mkdir can fail with a 'File exist' error if two processes ++ # try to create one of the directories concurrently. Don't ++ # stop in that case! ++ $MKDIR "$_G_dir" 2>/dev/null || : ++ done ++ IFS=$func_mkdir_p_IFS ++ ++ # Bail out if we (or some other process) failed to create a directory. ++ test -d "$_G_directory_path" || \ ++ func_fatal_error "Failed to create '$1'" ++ fi ++} ++ ++ ++# func_mktempdir [BASENAME] ++# ------------------------- ++# Make a temporary directory that won't clash with other running ++# libtool processes, and avoids race conditions if possible. If ++# given, BASENAME is the basename for that directory. ++func_mktempdir () ++{ ++ $debug_cmd ++ ++ _G_template=${TMPDIR-/tmp}/${1-$progname} ++ ++ if test : = "$opt_dry_run"; then ++ # Return a directory name, but don't create it in dry-run mode ++ _G_tmpdir=$_G_template-$$ ++ else ++ ++ # If mktemp works, use that first and foremost ++ _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null` ++ ++ if test ! -d "$_G_tmpdir"; then ++ # Failing that, at least try and use $RANDOM to avoid a race ++ _G_tmpdir=$_G_template-${RANDOM-0}$$ ++ ++ func_mktempdir_umask=`umask` ++ umask 0077 ++ $MKDIR "$_G_tmpdir" ++ umask $func_mktempdir_umask ++ fi ++ ++ # If we're not in dry-run mode, bomb out on failure ++ test -d "$_G_tmpdir" || \ ++ func_fatal_error "cannot create temporary directory '$_G_tmpdir'" ++ fi ++ ++ $ECHO "$_G_tmpdir" ++} ++ ++ ++# func_normal_abspath PATH ++# ------------------------ ++# Remove doubled-up and trailing slashes, "." path components, ++# and cancel out any ".." path components in PATH after making ++# it an absolute path. ++func_normal_abspath () ++{ ++ $debug_cmd ++ ++ # These SED scripts presuppose an absolute path with a trailing slash. ++ _G_pathcar='s|^/\([^/]*\).*$|\1|' ++ _G_pathcdr='s|^/[^/]*||' ++ _G_removedotparts=':dotsl ++ s|/\./|/|g ++ t dotsl ++ s|/\.$|/|' ++ _G_collapseslashes='s|/\{1,\}|/|g' ++ _G_finalslash='s|/*$|/|' ++ ++ # Start from root dir and reassemble the path. ++ func_normal_abspath_result= ++ func_normal_abspath_tpath=$1 ++ func_normal_abspath_altnamespace= ++ case $func_normal_abspath_tpath in ++ "") ++ # Empty path, that just means $cwd. ++ func_stripname '' '/' "`pwd`" ++ func_normal_abspath_result=$func_stripname_result ++ return ++ ;; ++ # The next three entries are used to spot a run of precisely ++ # two leading slashes without using negated character classes; ++ # we take advantage of case's first-match behaviour. ++ ///*) ++ # Unusual form of absolute path, do nothing. ++ ;; ++ //*) ++ # Not necessarily an ordinary path; POSIX reserves leading '//' ++ # and for example Cygwin uses it to access remote file shares ++ # over CIFS/SMB, so we conserve a leading double slash if found. ++ func_normal_abspath_altnamespace=/ ++ ;; ++ /*) ++ # Absolute path, do nothing. ++ ;; ++ *) ++ # Relative path, prepend $cwd. ++ func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath ++ ;; ++ esac ++ ++ # Cancel out all the simple stuff to save iterations. We also want ++ # the path to end with a slash for ease of parsing, so make sure ++ # there is one (and only one) here. ++ func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ ++ -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"` ++ while :; do ++ # Processed it all yet? ++ if test / = "$func_normal_abspath_tpath"; then ++ # If we ascended to the root using ".." the result may be empty now. ++ if test -z "$func_normal_abspath_result"; then ++ func_normal_abspath_result=/ ++ fi ++ break ++ fi ++ func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \ ++ -e "$_G_pathcar"` ++ func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \ ++ -e "$_G_pathcdr"` ++ # Figure out what to do with it ++ case $func_normal_abspath_tcomponent in ++ "") ++ # Trailing empty path component, ignore it. ++ ;; ++ ..) ++ # Parent dir; strip last assembled component from result. ++ func_dirname "$func_normal_abspath_result" ++ func_normal_abspath_result=$func_dirname_result ++ ;; ++ *) ++ # Actual path component, append it. ++ func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent" ++ ;; ++ esac ++ done ++ # Restore leading double-slash if one was found on entry. ++ func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result ++} ++ ++ ++# func_notquiet ARG... ++# -------------------- ++# Echo program name prefixed message only when not in quiet mode. ++func_notquiet () ++{ ++ $debug_cmd ++ ++ $opt_quiet || func_echo ${1+"$@"} ++ ++ # A bug in bash halts the script if the last line of a function ++ # fails when set -e is in force, so we need another command to ++ # work around that: ++ : ++} ++ ++ ++# func_relative_path SRCDIR DSTDIR ++# -------------------------------- ++# Set func_relative_path_result to the relative path from SRCDIR to DSTDIR. ++func_relative_path () ++{ ++ $debug_cmd ++ ++ func_relative_path_result= ++ func_normal_abspath "$1" ++ func_relative_path_tlibdir=$func_normal_abspath_result ++ func_normal_abspath "$2" ++ func_relative_path_tbindir=$func_normal_abspath_result ++ ++ # Ascend the tree starting from libdir ++ while :; do ++ # check if we have found a prefix of bindir ++ case $func_relative_path_tbindir in ++ $func_relative_path_tlibdir) ++ # found an exact match ++ func_relative_path_tcancelled= ++ break ++ ;; ++ $func_relative_path_tlibdir*) ++ # found a matching prefix ++ func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir" ++ func_relative_path_tcancelled=$func_stripname_result ++ if test -z "$func_relative_path_result"; then ++ func_relative_path_result=. ++ fi ++ break ++ ;; ++ *) ++ func_dirname $func_relative_path_tlibdir ++ func_relative_path_tlibdir=$func_dirname_result ++ if test -z "$func_relative_path_tlibdir"; then ++ # Have to descend all the way to the root! ++ func_relative_path_result=../$func_relative_path_result ++ func_relative_path_tcancelled=$func_relative_path_tbindir ++ break ++ fi ++ func_relative_path_result=../$func_relative_path_result ++ ;; ++ esac ++ done ++ ++ # Now calculate path; take care to avoid doubling-up slashes. ++ func_stripname '' '/' "$func_relative_path_result" ++ func_relative_path_result=$func_stripname_result ++ func_stripname '/' '/' "$func_relative_path_tcancelled" ++ if test -n "$func_stripname_result"; then ++ func_append func_relative_path_result "/$func_stripname_result" ++ fi ++ ++ # Normalisation. If bindir is libdir, return '.' else relative path. ++ if test -n "$func_relative_path_result"; then ++ func_stripname './' '' "$func_relative_path_result" ++ func_relative_path_result=$func_stripname_result ++ fi ++ ++ test -n "$func_relative_path_result" || func_relative_path_result=. ++ ++ : ++} ++ ++ ++# func_quote_for_eval ARG... ++# -------------------------- ++# Aesthetically quote ARGs to be evaled later. ++# This function returns two values: ++# i) func_quote_for_eval_result ++# double-quoted, suitable for a subsequent eval ++# ii) func_quote_for_eval_unquoted_result ++# has all characters that are still active within double ++# quotes backslashified. ++func_quote_for_eval () ++{ ++ $debug_cmd ++ ++ func_quote_for_eval_unquoted_result= ++ func_quote_for_eval_result= ++ while test 0 -lt $#; do ++ case $1 in ++ *[\\\`\"\$]*) ++ _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;; ++ *) ++ _G_unquoted_arg=$1 ;; ++ esac ++ if test -n "$func_quote_for_eval_unquoted_result"; then ++ func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg" ++ else ++ func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg" ++ fi ++ ++ case $_G_unquoted_arg in ++ # Double-quote args containing shell metacharacters to delay ++ # word splitting, command substitution and variable expansion ++ # for a subsequent eval. ++ # Many Bourne shells cannot handle close brackets correctly ++ # in scan sets, so we specify it separately. ++ *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") ++ _G_quoted_arg=\"$_G_unquoted_arg\" ++ ;; ++ *) ++ _G_quoted_arg=$_G_unquoted_arg ++ ;; ++ esac ++ ++ if test -n "$func_quote_for_eval_result"; then ++ func_append func_quote_for_eval_result " $_G_quoted_arg" ++ else ++ func_append func_quote_for_eval_result "$_G_quoted_arg" ++ fi ++ shift ++ done ++} ++ ++ ++# func_quote_for_expand ARG ++# ------------------------- ++# Aesthetically quote ARG to be evaled later; same as above, ++# but do not quote variable references. ++func_quote_for_expand () ++{ ++ $debug_cmd ++ ++ case $1 in ++ *[\\\`\"]*) ++ _G_arg=`$ECHO "$1" | $SED \ ++ -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;; ++ *) ++ _G_arg=$1 ;; ++ esac ++ ++ case $_G_arg in ++ # Double-quote args containing shell metacharacters to delay ++ # word splitting and command substitution for a subsequent eval. ++ # Many Bourne shells cannot handle close brackets correctly ++ # in scan sets, so we specify it separately. ++ *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"") ++ _G_arg=\"$_G_arg\" ++ ;; ++ esac ++ ++ func_quote_for_expand_result=$_G_arg ++} ++ ++ ++# func_stripname PREFIX SUFFIX NAME ++# --------------------------------- ++# strip PREFIX and SUFFIX from NAME, and store in func_stripname_result. ++# PREFIX and SUFFIX must not contain globbing or regex special ++# characters, hashes, percent signs, but SUFFIX may contain a leading ++# dot (in which case that matches only a dot). ++if test yes = "$_G_HAVE_XSI_OPS"; then ++ eval 'func_stripname () ++ { ++ $debug_cmd ++ ++ # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are ++ # positional parameters, so assign one to ordinary variable first. ++ func_stripname_result=$3 ++ func_stripname_result=${func_stripname_result#"$1"} ++ func_stripname_result=${func_stripname_result%"$2"} ++ }' ++else ++ func_stripname () ++ { ++ $debug_cmd ++ ++ case $2 in ++ .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;; ++ *) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;; ++ esac ++ } ++fi ++ ++ ++# func_show_eval CMD [FAIL_EXP] ++# ----------------------------- ++# Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is ++# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP ++# is given, then evaluate it. ++func_show_eval () ++{ ++ $debug_cmd ++ ++ _G_cmd=$1 ++ _G_fail_exp=${2-':'} ++ ++ func_quote_for_expand "$_G_cmd" ++ eval "func_notquiet $func_quote_for_expand_result" ++ ++ $opt_dry_run || { ++ eval "$_G_cmd" ++ _G_status=$? ++ if test 0 -ne "$_G_status"; then ++ eval "(exit $_G_status); $_G_fail_exp" ++ fi ++ } ++} ++ ++ ++# func_show_eval_locale CMD [FAIL_EXP] ++# ------------------------------------ ++# Unless opt_quiet is true, then output CMD. Then, if opt_dryrun is ++# not true, evaluate CMD. If the evaluation of CMD fails, and FAIL_EXP ++# is given, then evaluate it. Use the saved locale for evaluation. ++func_show_eval_locale () ++{ ++ $debug_cmd ++ ++ _G_cmd=$1 ++ _G_fail_exp=${2-':'} ++ ++ $opt_quiet || { ++ func_quote_for_expand "$_G_cmd" ++ eval "func_echo $func_quote_for_expand_result" ++ } ++ ++ $opt_dry_run || { ++ eval "$_G_user_locale ++ $_G_cmd" ++ _G_status=$? ++ eval "$_G_safe_locale" ++ if test 0 -ne "$_G_status"; then ++ eval "(exit $_G_status); $_G_fail_exp" ++ fi ++ } ++} ++ ++ ++# func_tr_sh ++# ---------- ++# Turn $1 into a string suitable for a shell variable name. ++# Result is stored in $func_tr_sh_result. All characters ++# not in the set a-zA-Z0-9_ are replaced with '_'. Further, ++# if $1 begins with a digit, a '_' is prepended as well. ++func_tr_sh () ++{ ++ $debug_cmd ++ ++ case $1 in ++ [0-9]* | *[!a-zA-Z0-9_]*) ++ func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'` ++ ;; ++ * ) ++ func_tr_sh_result=$1 ++ ;; ++ esac ++} ++ ++ ++# func_verbose ARG... ++# ------------------- ++# Echo program name prefixed message in verbose mode only. ++func_verbose () ++{ ++ $debug_cmd ++ ++ $opt_verbose && func_echo "$*" ++ ++ : ++} ++ ++ ++# func_warn_and_continue ARG... ++# ----------------------------- ++# Echo program name prefixed warning message to standard error. ++func_warn_and_continue () ++{ ++ $debug_cmd ++ ++ $require_term_colors ++ ++ func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2 ++} ++ ++ ++# func_warning CATEGORY ARG... ++# ---------------------------- ++# Echo program name prefixed warning message to standard error. Warning ++# messages can be filtered according to CATEGORY, where this function ++# elides messages where CATEGORY is not listed in the global variable ++# 'opt_warning_types'. ++func_warning () ++{ ++ $debug_cmd ++ ++ # CATEGORY must be in the warning_categories list! ++ case " $warning_categories " in ++ *" $1 "*) ;; ++ *) func_internal_error "invalid warning category '$1'" ;; ++ esac ++ ++ _G_category=$1 ++ shift ++ ++ case " $opt_warning_types " in ++ *" $_G_category "*) $warning_func ${1+"$@"} ;; ++ esac ++} ++ ++ ++# func_sort_ver VER1 VER2 ++# ----------------------- ++# 'sort -V' is not generally available. ++# Note this deviates from the version comparison in automake ++# in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a ++# but this should suffice as we won't be specifying old ++# version formats or redundant trailing .0 in bootstrap.conf. ++# If we did want full compatibility then we should probably ++# use m4_version_compare from autoconf. ++func_sort_ver () ++{ ++ $debug_cmd ++ ++ printf '%s\n%s\n' "$1" "$2" \ ++ | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n ++} ++ ++# func_lt_ver PREV CURR ++# --------------------- ++# Return true if PREV and CURR are in the correct order according to ++# func_sort_ver, otherwise false. Use it like this: ++# ++# func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..." ++func_lt_ver () ++{ ++ $debug_cmd ++ ++ test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q` ++} ++ ++ ++# Local variables: ++# mode: shell-script ++# sh-indentation: 2 ++# eval: (add-hook 'before-save-hook 'time-stamp) ++# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC" ++# time-stamp-time-zone: "UTC" ++# End: ++#! /bin/sh ++ ++# Set a version string for this script. ++scriptversion=2014-01-07.03; # UTC ++ ++# A portable, pluggable option parser for Bourne shell. ++# Written by Gary V. Vaughan, 2010 ++ ++# Copyright (C) 2010-2015 Free Software Foundation, Inc. ++# This is free software; see the source for copying conditions. There is NO ++# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. ++ ++# 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 . ++ ++# Please report bugs or propose patches to gary@gnu.org. ++ ++ ++## ------ ## ++## Usage. ## ++## ------ ## ++ ++# This file is a library for parsing options in your shell scripts along ++# with assorted other useful supporting features that you can make use ++# of too. ++# ++# For the simplest scripts you might need only: ++# ++# #!/bin/sh ++# . relative/path/to/funclib.sh ++# . relative/path/to/options-parser ++# scriptversion=1.0 ++# func_options ${1+"$@"} ++# eval set dummy "$func_options_result"; shift ++# ...rest of your script... ++# ++# In order for the '--version' option to work, you will need to have a ++# suitably formatted comment like the one at the top of this file ++# starting with '# Written by ' and ending with '# warranty; '. ++# ++# For '-h' and '--help' to work, you will also need a one line ++# description of your script's purpose in a comment directly above the ++# '# Written by ' line, like the one at the top of this file. ++# ++# The default options also support '--debug', which will turn on shell ++# execution tracing (see the comment above debug_cmd below for another ++# use), and '--verbose' and the func_verbose function to allow your script ++# to display verbose messages only when your user has specified ++# '--verbose'. ++# ++# After sourcing this file, you can plug processing for additional ++# options by amending the variables from the 'Configuration' section ++# below, and following the instructions in the 'Option parsing' ++# section further down. ++ ++## -------------- ## ++## Configuration. ## ++## -------------- ## ++ ++# You should override these variables in your script after sourcing this ++# file so that they reflect the customisations you have added to the ++# option parser. ++ ++# The usage line for option parsing errors and the start of '-h' and ++# '--help' output messages. You can embed shell variables for delayed ++# expansion at the time the message is displayed, but you will need to ++# quote other shell meta-characters carefully to prevent them being ++# expanded when the contents are evaled. ++usage='$progpath [OPTION]...' ++ ++# Short help message in response to '-h' and '--help'. Add to this or ++# override it after sourcing this library to reflect the full set of ++# options your script accepts. ++usage_message="\ ++ --debug enable verbose shell tracing ++ -W, --warnings=CATEGORY ++ report the warnings falling in CATEGORY [all] ++ -v, --verbose verbosely report processing ++ --version print version information and exit ++ -h, --help print short or long help message and exit ++" ++ ++# Additional text appended to 'usage_message' in response to '--help'. ++long_help_message=" ++Warning categories include: ++ 'all' show all warnings ++ 'none' turn off all the warnings ++ 'error' warnings are treated as fatal errors" ++ ++# Help message printed before fatal option parsing errors. ++fatal_help="Try '\$progname --help' for more information." ++ ++ ++ ++## ------------------------- ## ++## Hook function management. ## ++## ------------------------- ## ++ ++# This section contains functions for adding, removing, and running hooks ++# to the main code. A hook is just a named list of of function, that can ++# be run in order later on. ++ ++# func_hookable FUNC_NAME ++# ----------------------- ++# Declare that FUNC_NAME will run hooks added with ++# 'func_add_hook FUNC_NAME ...'. ++func_hookable () ++{ ++ $debug_cmd ++ ++ func_append hookable_fns " $1" ++} ++ ++ ++# func_add_hook FUNC_NAME HOOK_FUNC ++# --------------------------------- ++# Request that FUNC_NAME call HOOK_FUNC before it returns. FUNC_NAME must ++# first have been declared "hookable" by a call to 'func_hookable'. ++func_add_hook () ++{ ++ $debug_cmd ++ ++ case " $hookable_fns " in ++ *" $1 "*) ;; ++ *) func_fatal_error "'$1' does not accept hook functions." ;; ++ esac ++ ++ eval func_append ${1}_hooks '" $2"' ++} ++ ++ ++# func_remove_hook FUNC_NAME HOOK_FUNC ++# ------------------------------------ ++# Remove HOOK_FUNC from the list of functions called by FUNC_NAME. ++func_remove_hook () ++{ ++ $debug_cmd ++ ++ eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`' ++} ++ ++ ++# func_run_hooks FUNC_NAME [ARG]... ++# --------------------------------- ++# Run all hook functions registered to FUNC_NAME. ++# It is assumed that the list of hook functions contains nothing more ++# than a whitespace-delimited list of legal shell function names, and ++# no effort is wasted trying to catch shell meta-characters or preserve ++# whitespace. ++func_run_hooks () ++{ ++ $debug_cmd ++ ++ case " $hookable_fns " in ++ *" $1 "*) ;; ++ *) func_fatal_error "'$1' does not support hook funcions.n" ;; ++ esac ++ ++ eval _G_hook_fns=\$$1_hooks; shift ++ ++ for _G_hook in $_G_hook_fns; do ++ eval $_G_hook '"$@"' ++ ++ # store returned options list back into positional ++ # parameters for next 'cmd' execution. ++ eval _G_hook_result=\$${_G_hook}_result ++ eval set dummy "$_G_hook_result"; shift ++ done ++ ++ func_quote_for_eval ${1+"$@"} ++ func_run_hooks_result=$func_quote_for_eval_result ++} ++ ++ ++ ++## --------------- ## ++## Option parsing. ## ++## --------------- ## ++ ++# In order to add your own option parsing hooks, you must accept the ++# full positional parameter list in your hook function, remove any ++# options that you action, and then pass back the remaining unprocessed ++# options in '_result', escaped suitably for ++# 'eval'. Like this: ++# ++# my_options_prep () ++# { ++# $debug_cmd ++# ++# # Extend the existing usage message. ++# usage_message=$usage_message' ++# -s, --silent don'\''t print informational messages ++# ' ++# ++# func_quote_for_eval ${1+"$@"} ++# my_options_prep_result=$func_quote_for_eval_result ++# } ++# func_add_hook func_options_prep my_options_prep ++# ++# ++# my_silent_option () ++# { ++# $debug_cmd ++# ++# # Note that for efficiency, we parse as many options as we can ++# # recognise in a loop before passing the remainder back to the ++# # caller on the first unrecognised argument we encounter. ++# while test $# -gt 0; do ++# opt=$1; shift ++# case $opt in ++# --silent|-s) opt_silent=: ;; ++# # Separate non-argument short options: ++# -s*) func_split_short_opt "$_G_opt" ++# set dummy "$func_split_short_opt_name" \ ++# "-$func_split_short_opt_arg" ${1+"$@"} ++# shift ++# ;; ++# *) set dummy "$_G_opt" "$*"; shift; break ;; ++# esac ++# done ++# ++# func_quote_for_eval ${1+"$@"} ++# my_silent_option_result=$func_quote_for_eval_result ++# } ++# func_add_hook func_parse_options my_silent_option ++# ++# ++# my_option_validation () ++# { ++# $debug_cmd ++# ++# $opt_silent && $opt_verbose && func_fatal_help "\ ++# '--silent' and '--verbose' options are mutually exclusive." ++# ++# func_quote_for_eval ${1+"$@"} ++# my_option_validation_result=$func_quote_for_eval_result ++# } ++# func_add_hook func_validate_options my_option_validation ++# ++# You'll alse need to manually amend $usage_message to reflect the extra ++# options you parse. It's preferable to append if you can, so that ++# multiple option parsing hooks can be added safely. ++ ++ ++# func_options [ARG]... ++# --------------------- ++# All the functions called inside func_options are hookable. See the ++# individual implementations for details. ++func_hookable func_options ++func_options () ++{ ++ $debug_cmd ++ ++ func_options_prep ${1+"$@"} ++ eval func_parse_options \ ++ ${func_options_prep_result+"$func_options_prep_result"} ++ eval func_validate_options \ ++ ${func_parse_options_result+"$func_parse_options_result"} ++ ++ eval func_run_hooks func_options \ ++ ${func_validate_options_result+"$func_validate_options_result"} ++ ++ # save modified positional parameters for caller ++ func_options_result=$func_run_hooks_result ++} ++ ++ ++# func_options_prep [ARG]... ++# -------------------------- ++# All initialisations required before starting the option parse loop. ++# Note that when calling hook functions, we pass through the list of ++# positional parameters. If a hook function modifies that list, and ++# needs to propogate that back to rest of this script, then the complete ++# modified list must be put in 'func_run_hooks_result' before ++# returning. ++func_hookable func_options_prep ++func_options_prep () ++{ ++ $debug_cmd ++ ++ # Option defaults: ++ opt_verbose=false ++ opt_warning_types= ++ ++ func_run_hooks func_options_prep ${1+"$@"} ++ ++ # save modified positional parameters for caller ++ func_options_prep_result=$func_run_hooks_result ++} ++ ++ ++# func_parse_options [ARG]... ++# --------------------------- ++# The main option parsing loop. ++func_hookable func_parse_options ++func_parse_options () ++{ ++ $debug_cmd ++ ++ func_parse_options_result= ++ ++ # this just eases exit handling ++ while test $# -gt 0; do ++ # Defer to hook functions for initial option parsing, so they ++ # get priority in the event of reusing an option name. ++ func_run_hooks func_parse_options ${1+"$@"} ++ ++ # Adjust func_parse_options positional parameters to match ++ eval set dummy "$func_run_hooks_result"; shift ++ ++ # Break out of the loop if we already parsed every option. ++ test $# -gt 0 || break ++ ++ _G_opt=$1 ++ shift ++ case $_G_opt in ++ --debug|-x) debug_cmd='set -x' ++ func_echo "enabling shell trace mode" ++ $debug_cmd ++ ;; ++ ++ --no-warnings|--no-warning|--no-warn) ++ set dummy --warnings none ${1+"$@"} ++ shift ++ ;; ++ ++ --warnings|--warning|-W) ++ test $# = 0 && func_missing_arg $_G_opt && break ++ case " $warning_categories $1" in ++ *" $1 "*) ++ # trailing space prevents matching last $1 above ++ func_append_uniq opt_warning_types " $1" ++ ;; ++ *all) ++ opt_warning_types=$warning_categories ++ ;; ++ *none) ++ opt_warning_types=none ++ warning_func=: ++ ;; ++ *error) ++ opt_warning_types=$warning_categories ++ warning_func=func_fatal_error ++ ;; ++ *) ++ func_fatal_error \ ++ "unsupported warning category: '$1'" ++ ;; ++ esac ++ shift ++ ;; ++ ++ --verbose|-v) opt_verbose=: ;; ++ --version) func_version ;; ++ -\?|-h) func_usage ;; ++ --help) func_help ;; ++ ++ # Separate optargs to long options (plugins may need this): ++ --*=*) func_split_equals "$_G_opt" ++ set dummy "$func_split_equals_lhs" \ ++ "$func_split_equals_rhs" ${1+"$@"} ++ shift ++ ;; ++ ++ # Separate optargs to short options: ++ -W*) ++ func_split_short_opt "$_G_opt" ++ set dummy "$func_split_short_opt_name" \ ++ "$func_split_short_opt_arg" ${1+"$@"} ++ shift ++ ;; ++ ++ # Separate non-argument short options: ++ -\?*|-h*|-v*|-x*) ++ func_split_short_opt "$_G_opt" ++ set dummy "$func_split_short_opt_name" \ ++ "-$func_split_short_opt_arg" ${1+"$@"} ++ shift ++ ;; ++ ++ --) break ;; ++ -*) func_fatal_help "unrecognised option: '$_G_opt'" ;; ++ *) set dummy "$_G_opt" ${1+"$@"}; shift; break ;; ++ esac ++ done ++ ++ # save modified positional parameters for caller ++ func_quote_for_eval ${1+"$@"} ++ func_parse_options_result=$func_quote_for_eval_result ++} ++ ++ ++# func_validate_options [ARG]... ++# ------------------------------ ++# Perform any sanity checks on option settings and/or unconsumed ++# arguments. ++func_hookable func_validate_options ++func_validate_options () ++{ ++ $debug_cmd ++ ++ # Display all warnings if -W was not given. ++ test -n "$opt_warning_types" || opt_warning_types=" $warning_categories" ++ ++ func_run_hooks func_validate_options ${1+"$@"} ++ ++ # Bail if the options were screwed! ++ $exit_cmd $EXIT_FAILURE ++ ++ # save modified positional parameters for caller ++ func_validate_options_result=$func_run_hooks_result ++} ++ ++ ++ ++## ----------------- ## ++## Helper functions. ## ++## ----------------- ## ++ ++# This section contains the helper functions used by the rest of the ++# hookable option parser framework in ascii-betical order. ++ ++ ++# func_fatal_help ARG... ++# ---------------------- ++# Echo program name prefixed message to standard error, followed by ++# a help hint, and exit. ++func_fatal_help () ++{ ++ $debug_cmd ++ ++ eval \$ECHO \""Usage: $usage"\" ++ eval \$ECHO \""$fatal_help"\" ++ func_error ${1+"$@"} ++ exit $EXIT_FAILURE ++} ++ ++ ++# func_help ++# --------- ++# Echo long help message to standard output and exit. ++func_help () ++{ ++ $debug_cmd ++ ++ func_usage_message ++ $ECHO "$long_help_message" ++ exit 0 ++} ++ ++ ++# func_missing_arg ARGNAME ++# ------------------------ ++# Echo program name prefixed message to standard error and set global ++# exit_cmd. ++func_missing_arg () ++{ ++ $debug_cmd ++ ++ func_error "Missing argument for '$1'." ++ exit_cmd=exit ++} ++ ++ ++# func_split_equals STRING ++# ------------------------ ++# Set func_split_equals_lhs and func_split_equals_rhs shell variables after ++# splitting STRING at the '=' sign. ++test -z "$_G_HAVE_XSI_OPS" \ ++ && (eval 'x=a/b/c; ++ test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \ ++ && _G_HAVE_XSI_OPS=yes ++ ++if test yes = "$_G_HAVE_XSI_OPS" ++then ++ # This is an XSI compatible shell, allowing a faster implementation... ++ eval 'func_split_equals () ++ { ++ $debug_cmd ++ ++ func_split_equals_lhs=${1%%=*} ++ func_split_equals_rhs=${1#*=} ++ test "x$func_split_equals_lhs" = "x$1" \ ++ && func_split_equals_rhs= ++ }' ++else ++ # ...otherwise fall back to using expr, which is often a shell builtin. ++ func_split_equals () ++ { ++ $debug_cmd ++ ++ func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'` ++ func_split_equals_rhs= ++ test "x$func_split_equals_lhs" = "x$1" \ ++ || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'` ++ } ++fi #func_split_equals ++ ++ ++# func_split_short_opt SHORTOPT ++# ----------------------------- ++# Set func_split_short_opt_name and func_split_short_opt_arg shell ++# variables after splitting SHORTOPT after the 2nd character. ++if test yes = "$_G_HAVE_XSI_OPS" ++then ++ # This is an XSI compatible shell, allowing a faster implementation... ++ eval 'func_split_short_opt () ++ { ++ $debug_cmd ++ ++ func_split_short_opt_arg=${1#??} ++ func_split_short_opt_name=${1%"$func_split_short_opt_arg"} ++ }' ++else ++ # ...otherwise fall back to using expr, which is often a shell builtin. ++ func_split_short_opt () ++ { ++ $debug_cmd ++ ++ func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'` ++ func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'` ++ } ++fi #func_split_short_opt ++ ++ ++# func_usage ++# ---------- ++# Echo short help message to standard output and exit. ++func_usage () ++{ ++ $debug_cmd ++ ++ func_usage_message ++ $ECHO "Run '$progname --help |${PAGER-more}' for full usage" ++ exit 0 ++} ++ ++ ++# func_usage_message ++# ------------------ ++# Echo short help message to standard output. ++func_usage_message () ++{ ++ $debug_cmd ++ ++ eval \$ECHO \""Usage: $usage"\" ++ echo ++ $SED -n 's|^# || ++ /^Written by/{ ++ x;p;x ++ } ++ h ++ /^Written by/q' < "$progpath" ++ echo ++ eval \$ECHO \""$usage_message"\" ++} ++ ++ ++# func_version ++# ------------ ++# Echo version message to standard output and exit. ++func_version () ++{ ++ $debug_cmd ++ ++ printf '%s\n' "$progname $scriptversion" ++ $SED -n ' ++ /(C)/!b go ++ :more ++ /\./!{ ++ N ++ s|\n# | | ++ b more ++ } ++ :go ++ /^# Written by /,/# warranty; / { ++ s|^# || ++ s|^# *$|| ++ s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2| ++ p ++ } ++ /^# Written by / { ++ s|^# || ++ p ++ } ++ /^warranty; /q' < "$progpath" ++ ++ exit $? ++} ++ ++ ++# Local variables: ++# mode: shell-script ++# sh-indentation: 2 ++# eval: (add-hook 'before-save-hook 'time-stamp) ++# time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC" ++# time-stamp-time-zone: "UTC" ++# End: ++ ++# Set a version string. ++scriptversion='(GNU libtool) 2.4.6' ++ ++ ++# func_echo ARG... ++# ---------------- ++# Libtool also displays the current mode in messages, so override ++# funclib.sh func_echo with this custom definition. ++func_echo () ++{ ++ $debug_cmd ++ ++ _G_message=$* ++ ++ func_echo_IFS=$IFS ++ IFS=$nl ++ for _G_line in $_G_message; do ++ IFS=$func_echo_IFS ++ $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line" ++ done ++ IFS=$func_echo_IFS ++} ++ ++ ++# func_warning ARG... ++# ------------------- ++# Libtool warnings are not categorized, so override funclib.sh ++# func_warning with this simpler definition. ++func_warning () ++{ ++ $debug_cmd ++ ++ $warning_func ${1+"$@"} ++} ++ ++ ++## ---------------- ## ++## Options parsing. ## ++## ---------------- ## ++ ++# Hook in the functions to make sure our own options are parsed during ++# the option parsing loop. ++ ++usage='$progpath [OPTION]... [MODE-ARG]...' ++ ++# Short help message in response to '-h'. ++usage_message="Options: ++ --config show all configuration variables ++ --debug enable verbose shell tracing ++ -n, --dry-run display commands without modifying any files ++ --features display basic configuration information and exit ++ --mode=MODE use operation mode MODE ++ --no-warnings equivalent to '-Wnone' ++ --preserve-dup-deps don't remove duplicate dependency libraries ++ --quiet, --silent don't print informational messages ++ --tag=TAG use configuration variables from tag TAG ++ -v, --verbose print more informational messages than default ++ --version print version information ++ -W, --warnings=CATEGORY report the warnings falling in CATEGORY [all] ++ -h, --help, --help-all print short, long, or detailed help message ++" ++ ++# Additional text appended to 'usage_message' in response to '--help'. ++func_help () ++{ ++ $debug_cmd ++ ++ func_usage_message ++ $ECHO "$long_help_message ++ ++MODE must be one of the following: ++ ++ clean remove files from the build directory ++ compile compile a source file into a libtool object ++ execute automatically set library path, then run a program ++ finish complete the installation of libtool libraries ++ install install libraries or executables ++ link create a library or an executable ++ uninstall remove libraries from an installed directory ++ ++MODE-ARGS vary depending on the MODE. When passed as first option, ++'--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that. ++Try '$progname --help --mode=MODE' for a more detailed description of MODE. ++ ++When reporting a bug, please describe a test case to reproduce it and ++include the following information: ++ ++ host-triplet: $host ++ shell: $SHELL ++ compiler: $LTCC ++ compiler flags: $LTCFLAGS ++ linker: $LD (gnu? $with_gnu_ld) ++ version: $progname $scriptversion Debian-2.4.6-2 ++ automake: `($AUTOMAKE --version) 2>/dev/null |$SED 1q` ++ autoconf: `($AUTOCONF --version) 2>/dev/null |$SED 1q` ++ ++Report bugs to . ++GNU libtool home page: . ++General help using GNU software: ." ++ exit 0 ++} ++ ++ ++# func_lo2o OBJECT-NAME ++# --------------------- ++# Transform OBJECT-NAME from a '.lo' suffix to the platform specific ++# object suffix. ++ ++lo2o=s/\\.lo\$/.$objext/ ++o2lo=s/\\.$objext\$/.lo/ ++ ++if test yes = "$_G_HAVE_XSI_OPS"; then ++ eval 'func_lo2o () ++ { ++ case $1 in ++ *.lo) func_lo2o_result=${1%.lo}.$objext ;; ++ * ) func_lo2o_result=$1 ;; ++ esac ++ }' ++ ++ # func_xform LIBOBJ-OR-SOURCE ++ # --------------------------- ++ # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise) ++ # suffix to a '.lo' libtool-object suffix. ++ eval 'func_xform () ++ { ++ func_xform_result=${1%.*}.lo ++ }' ++else ++ # ...otherwise fall back to using sed. ++ func_lo2o () ++ { ++ func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"` ++ } ++ ++ func_xform () ++ { ++ func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'` ++ } ++fi ++ ++ ++# func_fatal_configuration ARG... ++# ------------------------------- ++# Echo program name prefixed message to standard error, followed by ++# a configuration failure hint, and exit. ++func_fatal_configuration () ++{ ++ func__fatal_error ${1+"$@"} \ ++ "See the $PACKAGE documentation for more information." \ ++ "Fatal configuration error." ++} ++ ++ ++# func_config ++# ----------- ++# Display the configuration for all the tags in this script. ++func_config () ++{ ++ re_begincf='^# ### BEGIN LIBTOOL' ++ re_endcf='^# ### END LIBTOOL' ++ ++ # Default configuration. ++ $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath" ++ ++ # Now print the configurations for the tags. ++ for tagname in $taglist; do ++ $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath" ++ done ++ ++ exit $? ++} ++ ++ ++# func_features ++# ------------- ++# Display the features supported by this script. ++func_features () ++{ ++ echo "host: $host" ++ if test yes = "$build_libtool_libs"; then ++ echo "enable shared libraries" ++ else ++ echo "disable shared libraries" ++ fi ++ if test yes = "$build_old_libs"; then ++ echo "enable static libraries" ++ else ++ echo "disable static libraries" ++ fi ++ ++ exit $? ++} ++ ++ ++# func_enable_tag TAGNAME ++# ----------------------- ++# Verify that TAGNAME is valid, and either flag an error and exit, or ++# enable the TAGNAME tag. We also add TAGNAME to the global $taglist ++# variable here. ++func_enable_tag () ++{ ++ # Global variable: ++ tagname=$1 ++ ++ re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$" ++ re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$" ++ sed_extractcf=/$re_begincf/,/$re_endcf/p ++ ++ # Validate tagname. ++ case $tagname in ++ *[!-_A-Za-z0-9,/]*) ++ func_fatal_error "invalid tag name: $tagname" ++ ;; ++ esac ++ ++ # Don't test for the "default" C tag, as we know it's ++ # there but not specially marked. ++ case $tagname in ++ CC) ;; ++ *) ++ if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then ++ taglist="$taglist $tagname" ++ ++ # Evaluate the configuration. Be careful to quote the path ++ # and the sed script, to avoid splitting on whitespace, but ++ # also don't use non-portable quotes within backquotes within ++ # quotes we have to do it in 2 steps: ++ extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"` ++ eval "$extractedcf" ++ else ++ func_error "ignoring unknown tag $tagname" ++ fi ++ ;; ++ esac ++} ++ ++ ++# func_check_version_match ++# ------------------------ ++# Ensure that we are using m4 macros, and libtool script from the same ++# release of libtool. ++func_check_version_match () ++{ ++ if test "$package_revision" != "$macro_revision"; then ++ if test "$VERSION" != "$macro_version"; then ++ if test -z "$macro_version"; then ++ cat >&2 <<_LT_EOF ++$progname: Version mismatch error. This is $PACKAGE $VERSION, but the ++$progname: definition of this LT_INIT comes from an older release. ++$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION ++$progname: and run autoconf again. ++_LT_EOF ++ else ++ cat >&2 <<_LT_EOF ++$progname: Version mismatch error. This is $PACKAGE $VERSION, but the ++$progname: definition of this LT_INIT comes from $PACKAGE $macro_version. ++$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION ++$progname: and run autoconf again. ++_LT_EOF ++ fi ++ else ++ cat >&2 <<_LT_EOF ++$progname: Version mismatch error. This is $PACKAGE $VERSION, revision $package_revision, ++$progname: but the definition of this LT_INIT comes from revision $macro_revision. ++$progname: You should recreate aclocal.m4 with macros from revision $package_revision ++$progname: of $PACKAGE $VERSION and run autoconf again. ++_LT_EOF ++ fi ++ ++ exit $EXIT_MISMATCH ++ fi ++} ++ ++ ++# libtool_options_prep [ARG]... ++# ----------------------------- ++# Preparation for options parsed by libtool. ++libtool_options_prep () ++{ ++ $debug_mode ++ ++ # Option defaults: ++ opt_config=false ++ opt_dlopen= ++ opt_dry_run=false ++ opt_help=false ++ opt_mode= ++ opt_preserve_dup_deps=false ++ opt_quiet=false ++ ++ nonopt= ++ preserve_args= ++ ++ # Shorthand for --mode=foo, only valid as the first argument ++ case $1 in ++ clean|clea|cle|cl) ++ shift; set dummy --mode clean ${1+"$@"}; shift ++ ;; ++ compile|compil|compi|comp|com|co|c) ++ shift; set dummy --mode compile ${1+"$@"}; shift ++ ;; ++ execute|execut|execu|exec|exe|ex|e) ++ shift; set dummy --mode execute ${1+"$@"}; shift ++ ;; ++ finish|finis|fini|fin|fi|f) ++ shift; set dummy --mode finish ${1+"$@"}; shift ++ ;; ++ install|instal|insta|inst|ins|in|i) ++ shift; set dummy --mode install ${1+"$@"}; shift ++ ;; ++ link|lin|li|l) ++ shift; set dummy --mode link ${1+"$@"}; shift ++ ;; ++ uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u) ++ shift; set dummy --mode uninstall ${1+"$@"}; shift ++ ;; ++ esac ++ ++ # Pass back the list of options. ++ func_quote_for_eval ${1+"$@"} ++ libtool_options_prep_result=$func_quote_for_eval_result ++} ++func_add_hook func_options_prep libtool_options_prep ++ ++ ++# libtool_parse_options [ARG]... ++# --------------------------------- ++# Provide handling for libtool specific options. ++libtool_parse_options () ++{ ++ $debug_cmd ++ ++ # Perform our own loop to consume as many options as possible in ++ # each iteration. ++ while test $# -gt 0; do ++ _G_opt=$1 ++ shift ++ case $_G_opt in ++ --dry-run|--dryrun|-n) ++ opt_dry_run=: ++ ;; ++ ++ --config) func_config ;; ++ ++ --dlopen|-dlopen) ++ opt_dlopen="${opt_dlopen+$opt_dlopen ++}$1" ++ shift ++ ;; ++ ++ --preserve-dup-deps) ++ opt_preserve_dup_deps=: ;; ++ ++ --features) func_features ;; ++ ++ --finish) set dummy --mode finish ${1+"$@"}; shift ;; ++ ++ --help) opt_help=: ;; ++ ++ --help-all) opt_help=': help-all' ;; ++ ++ --mode) test $# = 0 && func_missing_arg $_G_opt && break ++ opt_mode=$1 ++ case $1 in ++ # Valid mode arguments: ++ clean|compile|execute|finish|install|link|relink|uninstall) ;; ++ ++ # Catch anything else as an error ++ *) func_error "invalid argument for $_G_opt" ++ exit_cmd=exit ++ break ++ ;; ++ esac ++ shift ++ ;; ++ ++ --no-silent|--no-quiet) ++ opt_quiet=false ++ func_append preserve_args " $_G_opt" ++ ;; ++ ++ --no-warnings|--no-warning|--no-warn) ++ opt_warning=false ++ func_append preserve_args " $_G_opt" ++ ;; ++ ++ --no-verbose) ++ opt_verbose=false ++ func_append preserve_args " $_G_opt" ++ ;; ++ ++ --silent|--quiet) ++ opt_quiet=: ++ opt_verbose=false ++ func_append preserve_args " $_G_opt" ++ ;; ++ ++ --tag) test $# = 0 && func_missing_arg $_G_opt && break ++ opt_tag=$1 ++ func_append preserve_args " $_G_opt $1" ++ func_enable_tag "$1" ++ shift ++ ;; ++ ++ --verbose|-v) opt_quiet=false ++ opt_verbose=: ++ func_append preserve_args " $_G_opt" ++ ;; ++ ++ # An option not handled by this hook function: ++ *) set dummy "$_G_opt" ${1+"$@"}; shift; break ;; ++ esac ++ done ++ ++ ++ # save modified positional parameters for caller ++ func_quote_for_eval ${1+"$@"} ++ libtool_parse_options_result=$func_quote_for_eval_result ++} ++func_add_hook func_parse_options libtool_parse_options ++ ++ ++ ++# libtool_validate_options [ARG]... ++# --------------------------------- ++# Perform any sanity checks on option settings and/or unconsumed ++# arguments. ++libtool_validate_options () ++{ ++ # save first non-option argument ++ if test 0 -lt $#; then ++ nonopt=$1 ++ shift ++ fi ++ ++ # preserve --debug ++ test : = "$debug_cmd" || func_append preserve_args " --debug" ++ ++ case $host in ++ # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452 ++ # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788 ++ *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*) ++ # don't eliminate duplications in $postdeps and $predeps ++ opt_duplicate_compiler_generated_deps=: ++ ;; ++ *) ++ opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps ++ ;; ++ esac ++ ++ $opt_help || { ++ # Sanity checks first: ++ func_check_version_match ++ ++ test yes != "$build_libtool_libs" \ ++ && test yes != "$build_old_libs" \ ++ && func_fatal_configuration "not configured to build any kind of library" ++ ++ # Darwin sucks ++ eval std_shrext=\"$shrext_cmds\" ++ ++ # Only execute mode is allowed to have -dlopen flags. ++ if test -n "$opt_dlopen" && test execute != "$opt_mode"; then ++ func_error "unrecognized option '-dlopen'" ++ $ECHO "$help" 1>&2 ++ exit $EXIT_FAILURE ++ fi ++ ++ # Change the help message to a mode-specific one. ++ generic_help=$help ++ help="Try '$progname --help --mode=$opt_mode' for more information." ++ } ++ ++ # Pass back the unparsed argument list ++ func_quote_for_eval ${1+"$@"} ++ libtool_validate_options_result=$func_quote_for_eval_result ++} ++func_add_hook func_validate_options libtool_validate_options ++ ++ ++# Process options as early as possible so that --help and --version ++# can return quickly. ++func_options ${1+"$@"} ++eval set dummy "$func_options_result"; shift ++ ++ ++ ++## ----------- ## ++## Main. ## ++## ----------- ## ++ ++magic='%%%MAGIC variable%%%' ++magic_exe='%%%MAGIC EXE variable%%%' ++ ++# Global variables. ++extracted_archives= ++extracted_serial=0 ++ ++# If this variable is set in any of the actions, the command in it ++# will be execed at the end. This prevents here-documents from being ++# left over by shells. ++exec_cmd= ++ ++ ++# A function that is used when there is no print builtin or printf. ++func_fallback_echo () ++{ ++ eval 'cat <<_LTECHO_EOF ++$1 ++_LTECHO_EOF' ++} ++ ++# func_generated_by_libtool ++# True iff stdin has been generated by Libtool. This function is only ++# a basic sanity check; it will hardly flush out determined imposters. ++func_generated_by_libtool_p () ++{ ++ $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1 ++} ++ ++# func_lalib_p file ++# True iff FILE is a libtool '.la' library or '.lo' object file. ++# This function is only a basic sanity check; it will hardly flush out ++# determined imposters. ++func_lalib_p () ++{ ++ test -f "$1" && ++ $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p ++} ++ ++# func_lalib_unsafe_p file ++# True iff FILE is a libtool '.la' library or '.lo' object file. ++# This function implements the same check as func_lalib_p without ++# resorting to external programs. To this end, it redirects stdin and ++# closes it afterwards, without saving the original file descriptor. ++# As a safety measure, use it only where a negative result would be ++# fatal anyway. Works if 'file' does not exist. ++func_lalib_unsafe_p () ++{ ++ lalib_p=no ++ if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then ++ for lalib_p_l in 1 2 3 4 ++ do ++ read lalib_p_line ++ case $lalib_p_line in ++ \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;; ++ esac ++ done ++ exec 0<&5 5<&- ++ fi ++ test yes = "$lalib_p" ++} ++ ++# func_ltwrapper_script_p file ++# True iff FILE is a libtool wrapper script ++# This function is only a basic sanity check; it will hardly flush out ++# determined imposters. ++func_ltwrapper_script_p () ++{ ++ test -f "$1" && ++ $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p ++} ++ ++# func_ltwrapper_executable_p file ++# True iff FILE is a libtool wrapper executable ++# This function is only a basic sanity check; it will hardly flush out ++# determined imposters. ++func_ltwrapper_executable_p () ++{ ++ func_ltwrapper_exec_suffix= ++ case $1 in ++ *.exe) ;; ++ *) func_ltwrapper_exec_suffix=.exe ;; ++ esac ++ $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1 ++} ++ ++# func_ltwrapper_scriptname file ++# Assumes file is an ltwrapper_executable ++# uses $file to determine the appropriate filename for a ++# temporary ltwrapper_script. ++func_ltwrapper_scriptname () ++{ ++ func_dirname_and_basename "$1" "" "." ++ func_stripname '' '.exe' "$func_basename_result" ++ func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper ++} ++ ++# func_ltwrapper_p file ++# True iff FILE is a libtool wrapper script or wrapper executable ++# This function is only a basic sanity check; it will hardly flush out ++# determined imposters. ++func_ltwrapper_p () ++{ ++ func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1" ++} ++ ++ ++# func_execute_cmds commands fail_cmd ++# Execute tilde-delimited COMMANDS. ++# If FAIL_CMD is given, eval that upon failure. ++# FAIL_CMD may read-access the current command in variable CMD! ++func_execute_cmds () ++{ ++ $debug_cmd ++ ++ save_ifs=$IFS; IFS='~' ++ for cmd in $1; do ++ IFS=$sp$nl ++ eval cmd=\"$cmd\" ++ IFS=$save_ifs ++ func_show_eval "$cmd" "${2-:}" ++ done ++ IFS=$save_ifs ++} ++ ++ ++# func_source file ++# Source FILE, adding directory component if necessary. ++# Note that it is not necessary on cygwin/mingw to append a dot to ++# FILE even if both FILE and FILE.exe exist: automatic-append-.exe ++# behavior happens only for exec(3), not for open(2)! Also, sourcing ++# 'FILE.' does not work on cygwin managed mounts. ++func_source () ++{ ++ $debug_cmd ++ ++ case $1 in ++ */* | *\\*) . "$1" ;; ++ *) . "./$1" ;; ++ esac ++} ++ ++ ++# func_resolve_sysroot PATH ++# Replace a leading = in PATH with a sysroot. Store the result into ++# func_resolve_sysroot_result ++func_resolve_sysroot () ++{ ++ func_resolve_sysroot_result=$1 ++ case $func_resolve_sysroot_result in ++ =*) ++ func_stripname '=' '' "$func_resolve_sysroot_result" ++ func_resolve_sysroot_result=$lt_sysroot$func_stripname_result ++ ;; ++ esac ++} ++ ++# func_replace_sysroot PATH ++# If PATH begins with the sysroot, replace it with = and ++# store the result into func_replace_sysroot_result. ++func_replace_sysroot () ++{ ++ case $lt_sysroot:$1 in ++ ?*:"$lt_sysroot"*) ++ func_stripname "$lt_sysroot" '' "$1" ++ func_replace_sysroot_result='='$func_stripname_result ++ ;; ++ *) ++ # Including no sysroot. ++ func_replace_sysroot_result=$1 ++ ;; ++ esac ++} ++ ++# func_infer_tag arg ++# Infer tagged configuration to use if any are available and ++# if one wasn't chosen via the "--tag" command line option. ++# Only attempt this if the compiler in the base compile ++# command doesn't match the default compiler. ++# arg is usually of the form 'gcc ...' ++func_infer_tag () ++{ ++ $debug_cmd ++ ++ if test -n "$available_tags" && test -z "$tagname"; then ++ CC_quoted= ++ for arg in $CC; do ++ func_append_quoted CC_quoted "$arg" ++ done ++ CC_expanded=`func_echo_all $CC` ++ CC_quoted_expanded=`func_echo_all $CC_quoted` ++ case $@ in ++ # Blanks in the command may have been stripped by the calling shell, ++ # but not from the CC environment variable when configure was run. ++ " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ ++ " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;; ++ # Blanks at the start of $base_compile will cause this to fail ++ # if we don't check for them as well. ++ *) ++ for z in $available_tags; do ++ if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then ++ # Evaluate the configuration. ++ eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`" ++ CC_quoted= ++ for arg in $CC; do ++ # Double-quote args containing other shell metacharacters. ++ func_append_quoted CC_quoted "$arg" ++ done ++ CC_expanded=`func_echo_all $CC` ++ CC_quoted_expanded=`func_echo_all $CC_quoted` ++ case "$@ " in ++ " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \ ++ " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ++ # The compiler in the base compile command matches ++ # the one in the tagged configuration. ++ # Assume this is the tagged configuration we want. ++ tagname=$z ++ break ++ ;; ++ esac ++ fi ++ done ++ # If $tagname still isn't set, then no tagged configuration ++ # was found and let the user know that the "--tag" command ++ # line option must be used. ++ if test -z "$tagname"; then ++ func_echo "unable to infer tagged configuration" ++ func_fatal_error "specify a tag with '--tag'" ++# else ++# func_verbose "using $tagname tagged configuration" ++ fi ++ ;; ++ esac ++ fi ++} ++ ++ ++ ++# func_write_libtool_object output_name pic_name nonpic_name ++# Create a libtool object file (analogous to a ".la" file), ++# but don't create it if we're doing a dry run. ++func_write_libtool_object () ++{ ++ write_libobj=$1 ++ if test yes = "$build_libtool_libs"; then ++ write_lobj=\'$2\' ++ else ++ write_lobj=none ++ fi ++ ++ if test yes = "$build_old_libs"; then ++ write_oldobj=\'$3\' ++ else ++ write_oldobj=none ++ fi ++ ++ $opt_dry_run || { ++ cat >${write_libobj}T </dev/null` ++ if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then ++ func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" | ++ $SED -e "$sed_naive_backslashify"` ++ else ++ func_convert_core_file_wine_to_w32_result= ++ fi ++ fi ++} ++# end: func_convert_core_file_wine_to_w32 ++ ++ ++# func_convert_core_path_wine_to_w32 ARG ++# Helper function used by path conversion functions when $build is *nix, and ++# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly ++# configured wine environment available, with the winepath program in $build's ++# $PATH. Assumes ARG has no leading or trailing path separator characters. ++# ++# ARG is path to be converted from $build format to win32. ++# Result is available in $func_convert_core_path_wine_to_w32_result. ++# Unconvertible file (directory) names in ARG are skipped; if no directory names ++# are convertible, then the result may be empty. ++func_convert_core_path_wine_to_w32 () ++{ ++ $debug_cmd ++ ++ # unfortunately, winepath doesn't convert paths, only file names ++ func_convert_core_path_wine_to_w32_result= ++ if test -n "$1"; then ++ oldIFS=$IFS ++ IFS=: ++ for func_convert_core_path_wine_to_w32_f in $1; do ++ IFS=$oldIFS ++ func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f" ++ if test -n "$func_convert_core_file_wine_to_w32_result"; then ++ if test -z "$func_convert_core_path_wine_to_w32_result"; then ++ func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result ++ else ++ func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result" ++ fi ++ fi ++ done ++ IFS=$oldIFS ++ fi ++} ++# end: func_convert_core_path_wine_to_w32 ++ ++ ++# func_cygpath ARGS... ++# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when ++# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2) ++# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or ++# (2), returns the Cygwin file name or path in func_cygpath_result (input ++# file name or path is assumed to be in w32 format, as previously converted ++# from $build's *nix or MSYS format). In case (3), returns the w32 file name ++# or path in func_cygpath_result (input file name or path is assumed to be in ++# Cygwin format). Returns an empty string on error. ++# ++# ARGS are passed to cygpath, with the last one being the file name or path to ++# be converted. ++# ++# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH ++# environment variable; do not put it in $PATH. ++func_cygpath () ++{ ++ $debug_cmd ++ ++ if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then ++ func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null` ++ if test "$?" -ne 0; then ++ # on failure, ensure result is empty ++ func_cygpath_result= ++ fi ++ else ++ func_cygpath_result= ++ func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'" ++ fi ++} ++#end: func_cygpath ++ ++ ++# func_convert_core_msys_to_w32 ARG ++# Convert file name or path ARG from MSYS format to w32 format. Return ++# result in func_convert_core_msys_to_w32_result. ++func_convert_core_msys_to_w32 () ++{ ++ $debug_cmd ++ ++ # awkward: cmd appends spaces to result ++ func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null | ++ $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"` ++} ++#end: func_convert_core_msys_to_w32 ++ ++ ++# func_convert_file_check ARG1 ARG2 ++# Verify that ARG1 (a file name in $build format) was converted to $host ++# format in ARG2. Otherwise, emit an error message, but continue (resetting ++# func_to_host_file_result to ARG1). ++func_convert_file_check () ++{ ++ $debug_cmd ++ ++ if test -z "$2" && test -n "$1"; then ++ func_error "Could not determine host file name corresponding to" ++ func_error " '$1'" ++ func_error "Continuing, but uninstalled executables may not work." ++ # Fallback: ++ func_to_host_file_result=$1 ++ fi ++} ++# end func_convert_file_check ++ ++ ++# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH ++# Verify that FROM_PATH (a path in $build format) was converted to $host ++# format in TO_PATH. Otherwise, emit an error message, but continue, resetting ++# func_to_host_file_result to a simplistic fallback value (see below). ++func_convert_path_check () ++{ ++ $debug_cmd ++ ++ if test -z "$4" && test -n "$3"; then ++ func_error "Could not determine the host path corresponding to" ++ func_error " '$3'" ++ func_error "Continuing, but uninstalled executables may not work." ++ # Fallback. This is a deliberately simplistic "conversion" and ++ # should not be "improved". See libtool.info. ++ if test "x$1" != "x$2"; then ++ lt_replace_pathsep_chars="s|$1|$2|g" ++ func_to_host_path_result=`echo "$3" | ++ $SED -e "$lt_replace_pathsep_chars"` ++ else ++ func_to_host_path_result=$3 ++ fi ++ fi ++} ++# end func_convert_path_check ++ ++ ++# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG ++# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT ++# and appending REPL if ORIG matches BACKPAT. ++func_convert_path_front_back_pathsep () ++{ ++ $debug_cmd ++ ++ case $4 in ++ $1 ) func_to_host_path_result=$3$func_to_host_path_result ++ ;; ++ esac ++ case $4 in ++ $2 ) func_append func_to_host_path_result "$3" ++ ;; ++ esac ++} ++# end func_convert_path_front_back_pathsep ++ ++ ++################################################## ++# $build to $host FILE NAME CONVERSION FUNCTIONS # ++################################################## ++# invoked via '$to_host_file_cmd ARG' ++# ++# In each case, ARG is the path to be converted from $build to $host format. ++# Result will be available in $func_to_host_file_result. ++ ++ ++# func_to_host_file ARG ++# Converts the file name ARG from $build format to $host format. Return result ++# in func_to_host_file_result. ++func_to_host_file () ++{ ++ $debug_cmd ++ ++ $to_host_file_cmd "$1" ++} ++# end func_to_host_file ++ ++ ++# func_to_tool_file ARG LAZY ++# converts the file name ARG from $build format to toolchain format. Return ++# result in func_to_tool_file_result. If the conversion in use is listed ++# in (the comma separated) LAZY, no conversion takes place. ++func_to_tool_file () ++{ ++ $debug_cmd ++ ++ case ,$2, in ++ *,"$to_tool_file_cmd",*) ++ func_to_tool_file_result=$1 ++ ;; ++ *) ++ $to_tool_file_cmd "$1" ++ func_to_tool_file_result=$func_to_host_file_result ++ ;; ++ esac ++} ++# end func_to_tool_file ++ ++ ++# func_convert_file_noop ARG ++# Copy ARG to func_to_host_file_result. ++func_convert_file_noop () ++{ ++ func_to_host_file_result=$1 ++} ++# end func_convert_file_noop ++ ++ ++# func_convert_file_msys_to_w32 ARG ++# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic ++# conversion to w32 is not available inside the cwrapper. Returns result in ++# func_to_host_file_result. ++func_convert_file_msys_to_w32 () ++{ ++ $debug_cmd ++ ++ func_to_host_file_result=$1 ++ if test -n "$1"; then ++ func_convert_core_msys_to_w32 "$1" ++ func_to_host_file_result=$func_convert_core_msys_to_w32_result ++ fi ++ func_convert_file_check "$1" "$func_to_host_file_result" ++} ++# end func_convert_file_msys_to_w32 ++ ++ ++# func_convert_file_cygwin_to_w32 ARG ++# Convert file name ARG from Cygwin to w32 format. Returns result in ++# func_to_host_file_result. ++func_convert_file_cygwin_to_w32 () ++{ ++ $debug_cmd ++ ++ func_to_host_file_result=$1 ++ if test -n "$1"; then ++ # because $build is cygwin, we call "the" cygpath in $PATH; no need to use ++ # LT_CYGPATH in this case. ++ func_to_host_file_result=`cygpath -m "$1"` ++ fi ++ func_convert_file_check "$1" "$func_to_host_file_result" ++} ++# end func_convert_file_cygwin_to_w32 ++ ++ ++# func_convert_file_nix_to_w32 ARG ++# Convert file name ARG from *nix to w32 format. Requires a wine environment ++# and a working winepath. Returns result in func_to_host_file_result. ++func_convert_file_nix_to_w32 () ++{ ++ $debug_cmd ++ ++ func_to_host_file_result=$1 ++ if test -n "$1"; then ++ func_convert_core_file_wine_to_w32 "$1" ++ func_to_host_file_result=$func_convert_core_file_wine_to_w32_result ++ fi ++ func_convert_file_check "$1" "$func_to_host_file_result" ++} ++# end func_convert_file_nix_to_w32 ++ ++ ++# func_convert_file_msys_to_cygwin ARG ++# Convert file name ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. ++# Returns result in func_to_host_file_result. ++func_convert_file_msys_to_cygwin () ++{ ++ $debug_cmd ++ ++ func_to_host_file_result=$1 ++ if test -n "$1"; then ++ func_convert_core_msys_to_w32 "$1" ++ func_cygpath -u "$func_convert_core_msys_to_w32_result" ++ func_to_host_file_result=$func_cygpath_result ++ fi ++ func_convert_file_check "$1" "$func_to_host_file_result" ++} ++# end func_convert_file_msys_to_cygwin ++ ++ ++# func_convert_file_nix_to_cygwin ARG ++# Convert file name ARG from *nix to Cygwin format. Requires Cygwin installed ++# in a wine environment, working winepath, and LT_CYGPATH set. Returns result ++# in func_to_host_file_result. ++func_convert_file_nix_to_cygwin () ++{ ++ $debug_cmd ++ ++ func_to_host_file_result=$1 ++ if test -n "$1"; then ++ # convert from *nix to w32, then use cygpath to convert from w32 to cygwin. ++ func_convert_core_file_wine_to_w32 "$1" ++ func_cygpath -u "$func_convert_core_file_wine_to_w32_result" ++ func_to_host_file_result=$func_cygpath_result ++ fi ++ func_convert_file_check "$1" "$func_to_host_file_result" ++} ++# end func_convert_file_nix_to_cygwin ++ ++ ++############################################# ++# $build to $host PATH CONVERSION FUNCTIONS # ++############################################# ++# invoked via '$to_host_path_cmd ARG' ++# ++# In each case, ARG is the path to be converted from $build to $host format. ++# The result will be available in $func_to_host_path_result. ++# ++# Path separators are also converted from $build format to $host format. If ++# ARG begins or ends with a path separator character, it is preserved (but ++# converted to $host format) on output. ++# ++# All path conversion functions are named using the following convention: ++# file name conversion function : func_convert_file_X_to_Y () ++# path conversion function : func_convert_path_X_to_Y () ++# where, for any given $build/$host combination the 'X_to_Y' value is the ++# same. If conversion functions are added for new $build/$host combinations, ++# the two new functions must follow this pattern, or func_init_to_host_path_cmd ++# will break. ++ ++ ++# func_init_to_host_path_cmd ++# Ensures that function "pointer" variable $to_host_path_cmd is set to the ++# appropriate value, based on the value of $to_host_file_cmd. ++to_host_path_cmd= ++func_init_to_host_path_cmd () ++{ ++ $debug_cmd ++ ++ if test -z "$to_host_path_cmd"; then ++ func_stripname 'func_convert_file_' '' "$to_host_file_cmd" ++ to_host_path_cmd=func_convert_path_$func_stripname_result ++ fi ++} ++ ++ ++# func_to_host_path ARG ++# Converts the path ARG from $build format to $host format. Return result ++# in func_to_host_path_result. ++func_to_host_path () ++{ ++ $debug_cmd ++ ++ func_init_to_host_path_cmd ++ $to_host_path_cmd "$1" ++} ++# end func_to_host_path ++ ++ ++# func_convert_path_noop ARG ++# Copy ARG to func_to_host_path_result. ++func_convert_path_noop () ++{ ++ func_to_host_path_result=$1 ++} ++# end func_convert_path_noop ++ ++ ++# func_convert_path_msys_to_w32 ARG ++# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic ++# conversion to w32 is not available inside the cwrapper. Returns result in ++# func_to_host_path_result. ++func_convert_path_msys_to_w32 () ++{ ++ $debug_cmd ++ ++ func_to_host_path_result=$1 ++ if test -n "$1"; then ++ # Remove leading and trailing path separator characters from ARG. MSYS ++ # behavior is inconsistent here; cygpath turns them into '.;' and ';.'; ++ # and winepath ignores them completely. ++ func_stripname : : "$1" ++ func_to_host_path_tmp1=$func_stripname_result ++ func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" ++ func_to_host_path_result=$func_convert_core_msys_to_w32_result ++ func_convert_path_check : ";" \ ++ "$func_to_host_path_tmp1" "$func_to_host_path_result" ++ func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" ++ fi ++} ++# end func_convert_path_msys_to_w32 ++ ++ ++# func_convert_path_cygwin_to_w32 ARG ++# Convert path ARG from Cygwin to w32 format. Returns result in ++# func_to_host_file_result. ++func_convert_path_cygwin_to_w32 () ++{ ++ $debug_cmd ++ ++ func_to_host_path_result=$1 ++ if test -n "$1"; then ++ # See func_convert_path_msys_to_w32: ++ func_stripname : : "$1" ++ func_to_host_path_tmp1=$func_stripname_result ++ func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"` ++ func_convert_path_check : ";" \ ++ "$func_to_host_path_tmp1" "$func_to_host_path_result" ++ func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" ++ fi ++} ++# end func_convert_path_cygwin_to_w32 ++ ++ ++# func_convert_path_nix_to_w32 ARG ++# Convert path ARG from *nix to w32 format. Requires a wine environment and ++# a working winepath. Returns result in func_to_host_file_result. ++func_convert_path_nix_to_w32 () ++{ ++ $debug_cmd ++ ++ func_to_host_path_result=$1 ++ if test -n "$1"; then ++ # See func_convert_path_msys_to_w32: ++ func_stripname : : "$1" ++ func_to_host_path_tmp1=$func_stripname_result ++ func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" ++ func_to_host_path_result=$func_convert_core_path_wine_to_w32_result ++ func_convert_path_check : ";" \ ++ "$func_to_host_path_tmp1" "$func_to_host_path_result" ++ func_convert_path_front_back_pathsep ":*" "*:" ";" "$1" ++ fi ++} ++# end func_convert_path_nix_to_w32 ++ ++ ++# func_convert_path_msys_to_cygwin ARG ++# Convert path ARG from MSYS to Cygwin format. Requires LT_CYGPATH set. ++# Returns result in func_to_host_file_result. ++func_convert_path_msys_to_cygwin () ++{ ++ $debug_cmd ++ ++ func_to_host_path_result=$1 ++ if test -n "$1"; then ++ # See func_convert_path_msys_to_w32: ++ func_stripname : : "$1" ++ func_to_host_path_tmp1=$func_stripname_result ++ func_convert_core_msys_to_w32 "$func_to_host_path_tmp1" ++ func_cygpath -u -p "$func_convert_core_msys_to_w32_result" ++ func_to_host_path_result=$func_cygpath_result ++ func_convert_path_check : : \ ++ "$func_to_host_path_tmp1" "$func_to_host_path_result" ++ func_convert_path_front_back_pathsep ":*" "*:" : "$1" ++ fi ++} ++# end func_convert_path_msys_to_cygwin ++ ++ ++# func_convert_path_nix_to_cygwin ARG ++# Convert path ARG from *nix to Cygwin format. Requires Cygwin installed in a ++# a wine environment, working winepath, and LT_CYGPATH set. Returns result in ++# func_to_host_file_result. ++func_convert_path_nix_to_cygwin () ++{ ++ $debug_cmd ++ ++ func_to_host_path_result=$1 ++ if test -n "$1"; then ++ # Remove leading and trailing path separator characters from ++ # ARG. msys behavior is inconsistent here, cygpath turns them ++ # into '.;' and ';.', and winepath ignores them completely. ++ func_stripname : : "$1" ++ func_to_host_path_tmp1=$func_stripname_result ++ func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1" ++ func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result" ++ func_to_host_path_result=$func_cygpath_result ++ func_convert_path_check : : \ ++ "$func_to_host_path_tmp1" "$func_to_host_path_result" ++ func_convert_path_front_back_pathsep ":*" "*:" : "$1" ++ fi ++} ++# end func_convert_path_nix_to_cygwin ++ ++ ++# func_dll_def_p FILE ++# True iff FILE is a Windows DLL '.def' file. ++# Keep in sync with _LT_DLL_DEF_P in libtool.m4 ++func_dll_def_p () ++{ ++ $debug_cmd ++ ++ func_dll_def_p_tmp=`$SED -n \ ++ -e 's/^[ ]*//' \ ++ -e '/^\(;.*\)*$/d' \ ++ -e 's/^\(EXPORTS\|LIBRARY\)\([ ].*\)*$/DEF/p' \ ++ -e q \ ++ "$1"` ++ test DEF = "$func_dll_def_p_tmp" ++} ++ ++ ++# func_mode_compile arg... ++func_mode_compile () ++{ ++ $debug_cmd ++ ++ # Get the compilation command and the source file. ++ base_compile= ++ srcfile=$nonopt # always keep a non-empty value in "srcfile" ++ suppress_opt=yes ++ suppress_output= ++ arg_mode=normal ++ libobj= ++ later= ++ pie_flag= ++ ++ for arg ++ do ++ case $arg_mode in ++ arg ) ++ # do not "continue". Instead, add this to base_compile ++ lastarg=$arg ++ arg_mode=normal ++ ;; ++ ++ target ) ++ libobj=$arg ++ arg_mode=normal ++ continue ++ ;; ++ ++ normal ) ++ # Accept any command-line options. ++ case $arg in ++ -o) ++ test -n "$libobj" && \ ++ func_fatal_error "you cannot specify '-o' more than once" ++ arg_mode=target ++ continue ++ ;; ++ ++ -pie | -fpie | -fPIE) ++ func_append pie_flag " $arg" ++ continue ++ ;; ++ ++ -shared | -static | -prefer-pic | -prefer-non-pic) ++ func_append later " $arg" ++ continue ++ ;; ++ ++ -no-suppress) ++ suppress_opt=no ++ continue ++ ;; ++ ++ -Xcompiler) ++ arg_mode=arg # the next one goes into the "base_compile" arg list ++ continue # The current "srcfile" will either be retained or ++ ;; # replaced later. I would guess that would be a bug. ++ ++ -Wc,*) ++ func_stripname '-Wc,' '' "$arg" ++ args=$func_stripname_result ++ lastarg= ++ save_ifs=$IFS; IFS=, ++ for arg in $args; do ++ IFS=$save_ifs ++ func_append_quoted lastarg "$arg" ++ done ++ IFS=$save_ifs ++ func_stripname ' ' '' "$lastarg" ++ lastarg=$func_stripname_result ++ ++ # Add the arguments to base_compile. ++ func_append base_compile " $lastarg" ++ continue ++ ;; ++ ++ *) ++ # Accept the current argument as the source file. ++ # The previous "srcfile" becomes the current argument. ++ # ++ lastarg=$srcfile ++ srcfile=$arg ++ ;; ++ esac # case $arg ++ ;; ++ esac # case $arg_mode ++ ++ # Aesthetically quote the previous argument. ++ func_append_quoted base_compile "$lastarg" ++ done # for arg ++ ++ case $arg_mode in ++ arg) ++ func_fatal_error "you must specify an argument for -Xcompile" ++ ;; ++ target) ++ func_fatal_error "you must specify a target with '-o'" ++ ;; ++ *) ++ # Get the name of the library object. ++ test -z "$libobj" && { ++ func_basename "$srcfile" ++ libobj=$func_basename_result ++ } ++ ;; ++ esac ++ ++ # Recognize several different file suffixes. ++ # If the user specifies -o file.o, it is replaced with file.lo ++ case $libobj in ++ *.[cCFSifmso] | \ ++ *.ada | *.adb | *.ads | *.asm | \ ++ *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \ ++ *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup) ++ func_xform "$libobj" ++ libobj=$func_xform_result ++ ;; ++ esac ++ ++ case $libobj in ++ *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;; ++ *) ++ func_fatal_error "cannot determine name of library object from '$libobj'" ++ ;; ++ esac ++ ++ func_infer_tag $base_compile ++ ++ for arg in $later; do ++ case $arg in ++ -shared) ++ test yes = "$build_libtool_libs" \ ++ || func_fatal_configuration "cannot build a shared library" ++ build_old_libs=no ++ continue ++ ;; ++ ++ -static) ++ build_libtool_libs=no ++ build_old_libs=yes ++ continue ++ ;; ++ ++ -prefer-pic) ++ pic_mode=yes ++ continue ++ ;; ++ ++ -prefer-non-pic) ++ pic_mode=no ++ continue ++ ;; ++ esac ++ done ++ ++ func_quote_for_eval "$libobj" ++ test "X$libobj" != "X$func_quote_for_eval_result" \ ++ && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"' &()|`$[]' \ ++ && func_warning "libobj name '$libobj' may not contain shell special characters." ++ func_dirname_and_basename "$obj" "/" "" ++ objname=$func_basename_result ++ xdir=$func_dirname_result ++ lobj=$xdir$objdir/$objname ++ ++ test -z "$base_compile" && \ ++ func_fatal_help "you must specify a compilation command" ++ ++ # Delete any leftover library objects. ++ if test yes = "$build_old_libs"; then ++ removelist="$obj $lobj $libobj ${libobj}T" ++ else ++ removelist="$lobj $libobj ${libobj}T" ++ fi ++ ++ # On Cygwin there's no "real" PIC flag so we must build both object types ++ case $host_os in ++ cygwin* | mingw* | pw32* | os2* | cegcc*) ++ pic_mode=default ++ ;; ++ esac ++ if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then ++ # non-PIC code in shared libraries is not supported ++ pic_mode=default ++ fi ++ ++ # Calculate the filename of the output object if compiler does ++ # not support -o with -c ++ if test no = "$compiler_c_o"; then ++ output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext ++ lockfile=$output_obj.lock ++ else ++ output_obj= ++ need_locks=no ++ lockfile= ++ fi ++ ++ # Lock this critical section if it is needed ++ # We use this script file to make the link, it avoids creating a new file ++ if test yes = "$need_locks"; then ++ until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do ++ func_echo "Waiting for $lockfile to be removed" ++ sleep 2 ++ done ++ elif test warn = "$need_locks"; then ++ if test -f "$lockfile"; then ++ $ECHO "\ ++*** ERROR, $lockfile exists and contains: ++`cat $lockfile 2>/dev/null` ++ ++This indicates that another process is trying to use the same ++temporary object file, and libtool could not work around it because ++your compiler does not support '-c' and '-o' together. If you ++repeat this compilation, it may succeed, by chance, but you had better ++avoid parallel builds (make -j) in this platform, or get a better ++compiler." ++ ++ $opt_dry_run || $RM $removelist ++ exit $EXIT_FAILURE ++ fi ++ func_append removelist " $output_obj" ++ $ECHO "$srcfile" > "$lockfile" ++ fi ++ ++ $opt_dry_run || $RM $removelist ++ func_append removelist " $lockfile" ++ trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15 ++ ++ func_to_tool_file "$srcfile" func_convert_file_msys_to_w32 ++ srcfile=$func_to_tool_file_result ++ func_quote_for_eval "$srcfile" ++ qsrcfile=$func_quote_for_eval_result ++ ++ # Only build a PIC object if we are building libtool libraries. ++ if test yes = "$build_libtool_libs"; then ++ # Without this assignment, base_compile gets emptied. ++ fbsd_hideous_sh_bug=$base_compile ++ ++ if test no != "$pic_mode"; then ++ command="$base_compile $qsrcfile $pic_flag" ++ else ++ # Don't build PIC code ++ command="$base_compile $qsrcfile" ++ fi ++ ++ func_mkdir_p "$xdir$objdir" ++ ++ if test -z "$output_obj"; then ++ # Place PIC objects in $objdir ++ func_append command " -o $lobj" ++ fi ++ ++ func_show_eval_locale "$command" \ ++ 'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE' ++ ++ if test warn = "$need_locks" && ++ test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then ++ $ECHO "\ ++*** ERROR, $lockfile contains: ++`cat $lockfile 2>/dev/null` ++ ++but it should contain: ++$srcfile ++ ++This indicates that another process is trying to use the same ++temporary object file, and libtool could not work around it because ++your compiler does not support '-c' and '-o' together. If you ++repeat this compilation, it may succeed, by chance, but you had better ++avoid parallel builds (make -j) in this platform, or get a better ++compiler." ++ ++ $opt_dry_run || $RM $removelist ++ exit $EXIT_FAILURE ++ fi ++ ++ # Just move the object if needed, then go on to compile the next one ++ if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then ++ func_show_eval '$MV "$output_obj" "$lobj"' \ ++ 'error=$?; $opt_dry_run || $RM $removelist; exit $error' ++ fi ++ ++ # Allow error messages only from the first compilation. ++ if test yes = "$suppress_opt"; then ++ suppress_output=' >/dev/null 2>&1' ++ fi ++ fi ++ ++ # Only build a position-dependent object if we build old libraries. ++ if test yes = "$build_old_libs"; then ++ if test yes != "$pic_mode"; then ++ # Don't build PIC code ++ command="$base_compile $qsrcfile$pie_flag" ++ else ++ command="$base_compile $qsrcfile $pic_flag" ++ fi ++ if test yes = "$compiler_c_o"; then ++ func_append command " -o $obj" ++ fi ++ ++ # Suppress compiler output if we already did a PIC compilation. ++ func_append command "$suppress_output" ++ func_show_eval_locale "$command" \ ++ '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' ++ ++ if test warn = "$need_locks" && ++ test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then ++ $ECHO "\ ++*** ERROR, $lockfile contains: ++`cat $lockfile 2>/dev/null` ++ ++but it should contain: ++$srcfile ++ ++This indicates that another process is trying to use the same ++temporary object file, and libtool could not work around it because ++your compiler does not support '-c' and '-o' together. If you ++repeat this compilation, it may succeed, by chance, but you had better ++avoid parallel builds (make -j) in this platform, or get a better ++compiler." ++ ++ $opt_dry_run || $RM $removelist ++ exit $EXIT_FAILURE ++ fi ++ ++ # Just move the object if needed ++ if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then ++ func_show_eval '$MV "$output_obj" "$obj"' \ ++ 'error=$?; $opt_dry_run || $RM $removelist; exit $error' ++ fi ++ fi ++ ++ $opt_dry_run || { ++ func_write_libtool_object "$libobj" "$objdir/$objname" "$objname" ++ ++ # Unlock the critical section if it was locked ++ if test no != "$need_locks"; then ++ removelist=$lockfile ++ $RM "$lockfile" ++ fi ++ } ++ ++ exit $EXIT_SUCCESS ++} ++ ++$opt_help || { ++ test compile = "$opt_mode" && func_mode_compile ${1+"$@"} ++} ++ ++func_mode_help () ++{ ++ # We need to display help for each of the modes. ++ case $opt_mode in ++ "") ++ # Generic help is extracted from the usage comments ++ # at the start of this file. ++ func_help ++ ;; ++ ++ clean) ++ $ECHO \ ++"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE... ++ ++Remove files from the build directory. ++ ++RM is the name of the program to use to delete files associated with each FILE ++(typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed ++to RM. ++ ++If FILE is a libtool library, object or program, all the files associated ++with it are deleted. Otherwise, only FILE itself is deleted using RM." ++ ;; ++ ++ compile) ++ $ECHO \ ++"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE ++ ++Compile a source file into a libtool library object. ++ ++This mode accepts the following additional options: ++ ++ -o OUTPUT-FILE set the output file name to OUTPUT-FILE ++ -no-suppress do not suppress compiler output for multiple passes ++ -prefer-pic try to build PIC objects only ++ -prefer-non-pic try to build non-PIC objects only ++ -shared do not build a '.o' file suitable for static linking ++ -static only build a '.o' file suitable for static linking ++ -Wc,FLAG pass FLAG directly to the compiler ++ ++COMPILE-COMMAND is a command to be used in creating a 'standard' object file ++from the given SOURCEFILE. ++ ++The output file name is determined by removing the directory component from ++SOURCEFILE, then substituting the C source code suffix '.c' with the ++library object suffix, '.lo'." ++ ;; ++ ++ execute) ++ $ECHO \ ++"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]... ++ ++Automatically set library path, then run a program. ++ ++This mode accepts the following additional options: ++ ++ -dlopen FILE add the directory containing FILE to the library path ++ ++This mode sets the library path environment variable according to '-dlopen' ++flags. ++ ++If any of the ARGS are libtool executable wrappers, then they are translated ++into their corresponding uninstalled binary, and any of their required library ++directories are added to the library path. ++ ++Then, COMMAND is executed, with ARGS as arguments." ++ ;; ++ ++ finish) ++ $ECHO \ ++"Usage: $progname [OPTION]... --mode=finish [LIBDIR]... ++ ++Complete the installation of libtool libraries. ++ ++Each LIBDIR is a directory that contains libtool libraries. ++ ++The commands that this mode executes may require superuser privileges. Use ++the '--dry-run' option if you just want to see what would be executed." ++ ;; ++ ++ install) ++ $ECHO \ ++"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND... ++ ++Install executables or libraries. ++ ++INSTALL-COMMAND is the installation command. The first component should be ++either the 'install' or 'cp' program. ++ ++The following components of INSTALL-COMMAND are treated specially: ++ ++ -inst-prefix-dir PREFIX-DIR Use PREFIX-DIR as a staging area for installation ++ ++The rest of the components are interpreted as arguments to that command (only ++BSD-compatible install options are recognized)." ++ ;; ++ ++ link) ++ $ECHO \ ++"Usage: $progname [OPTION]... --mode=link LINK-COMMAND... ++ ++Link object files or libraries together to form another library, or to ++create an executable program. ++ ++LINK-COMMAND is a command using the C compiler that you would use to create ++a program from several object files. ++ ++The following components of LINK-COMMAND are treated specially: ++ ++ -all-static do not do any dynamic linking at all ++ -avoid-version do not add a version suffix if possible ++ -bindir BINDIR specify path to binaries directory (for systems where ++ libraries must be found in the PATH setting at runtime) ++ -dlopen FILE '-dlpreopen' FILE if it cannot be dlopened at runtime ++ -dlpreopen FILE link in FILE and add its symbols to lt_preloaded_symbols ++ -export-dynamic allow symbols from OUTPUT-FILE to be resolved with dlsym(3) ++ -export-symbols SYMFILE ++ try to export only the symbols listed in SYMFILE ++ -export-symbols-regex REGEX ++ try to export only the symbols matching REGEX ++ -LLIBDIR search LIBDIR for required installed libraries ++ -lNAME OUTPUT-FILE requires the installed library libNAME ++ -module build a library that can dlopened ++ -no-fast-install disable the fast-install mode ++ -no-install link a not-installable executable ++ -no-undefined declare that a library does not refer to external symbols ++ -o OUTPUT-FILE create OUTPUT-FILE from the specified objects ++ -objectlist FILE use a list of object files found in FILE to specify objects ++ -os2dllname NAME force a short DLL name on OS/2 (no effect on other OSes) ++ -precious-files-regex REGEX ++ don't remove output files matching REGEX ++ -release RELEASE specify package release information ++ -rpath LIBDIR the created library will eventually be installed in LIBDIR ++ -R[ ]LIBDIR add LIBDIR to the runtime path of programs and libraries ++ -shared only do dynamic linking of libtool libraries ++ -shrext SUFFIX override the standard shared library file extension ++ -static do not do any dynamic linking of uninstalled libtool libraries ++ -static-libtool-libs ++ do not do any dynamic linking of libtool libraries ++ -version-info CURRENT[:REVISION[:AGE]] ++ specify library version info [each variable defaults to 0] ++ -weak LIBNAME declare that the target provides the LIBNAME interface ++ -Wc,FLAG ++ -Xcompiler FLAG pass linker-specific FLAG directly to the compiler ++ -Wl,FLAG ++ -Xlinker FLAG pass linker-specific FLAG directly to the linker ++ -XCClinker FLAG pass link-specific FLAG to the compiler driver (CC) ++ ++All other options (arguments beginning with '-') are ignored. ++ ++Every other argument is treated as a filename. Files ending in '.la' are ++treated as uninstalled libtool libraries, other files are standard or library ++object files. ++ ++If the OUTPUT-FILE ends in '.la', then a libtool library is created, ++only library objects ('.lo' files) may be specified, and '-rpath' is ++required, except when creating a convenience library. ++ ++If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created ++using 'ar' and 'ranlib', or on Windows using 'lib'. ++ ++If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file ++is created, otherwise an executable program is created." ++ ;; ++ ++ uninstall) ++ $ECHO \ ++"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE... ++ ++Remove libraries from an installation directory. ++ ++RM is the name of the program to use to delete files associated with each FILE ++(typically '/bin/rm'). RM-OPTIONS are options (such as '-f') to be passed ++to RM. ++ ++If FILE is a libtool library, all the files associated with it are deleted. ++Otherwise, only FILE itself is deleted using RM." ++ ;; ++ ++ *) ++ func_fatal_help "invalid operation mode '$opt_mode'" ++ ;; ++ esac ++ ++ echo ++ $ECHO "Try '$progname --help' for more information about other modes." ++} ++ ++# Now that we've collected a possible --mode arg, show help if necessary ++if $opt_help; then ++ if test : = "$opt_help"; then ++ func_mode_help ++ else ++ { ++ func_help noexit ++ for opt_mode in compile link execute install finish uninstall clean; do ++ func_mode_help ++ done ++ } | $SED -n '1p; 2,$s/^Usage:/ or: /p' ++ { ++ func_help noexit ++ for opt_mode in compile link execute install finish uninstall clean; do ++ echo ++ func_mode_help ++ done ++ } | ++ $SED '1d ++ /^When reporting/,/^Report/{ ++ H ++ d ++ } ++ $x ++ /information about other modes/d ++ /more detailed .*MODE/d ++ s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/' ++ fi ++ exit $? ++fi ++ ++ ++# func_mode_execute arg... ++func_mode_execute () ++{ ++ $debug_cmd ++ ++ # The first argument is the command name. ++ cmd=$nonopt ++ test -z "$cmd" && \ ++ func_fatal_help "you must specify a COMMAND" ++ ++ # Handle -dlopen flags immediately. ++ for file in $opt_dlopen; do ++ test -f "$file" \ ++ || func_fatal_help "'$file' is not a file" ++ ++ dir= ++ case $file in ++ *.la) ++ func_resolve_sysroot "$file" ++ file=$func_resolve_sysroot_result ++ ++ # Check to see that this really is a libtool archive. ++ func_lalib_unsafe_p "$file" \ ++ || func_fatal_help "'$lib' is not a valid libtool archive" ++ ++ # Read the libtool library. ++ dlname= ++ library_names= ++ func_source "$file" ++ ++ # Skip this library if it cannot be dlopened. ++ if test -z "$dlname"; then ++ # Warn if it was a shared library. ++ test -n "$library_names" && \ ++ func_warning "'$file' was not linked with '-export-dynamic'" ++ continue ++ fi ++ ++ func_dirname "$file" "" "." ++ dir=$func_dirname_result ++ ++ if test -f "$dir/$objdir/$dlname"; then ++ func_append dir "/$objdir" ++ else ++ if test ! -f "$dir/$dlname"; then ++ func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'" ++ fi ++ fi ++ ;; ++ ++ *.lo) ++ # Just add the directory containing the .lo file. ++ func_dirname "$file" "" "." ++ dir=$func_dirname_result ++ ;; ++ ++ *) ++ func_warning "'-dlopen' is ignored for non-libtool libraries and objects" ++ continue ++ ;; ++ esac ++ ++ # Get the absolute pathname. ++ absdir=`cd "$dir" && pwd` ++ test -n "$absdir" && dir=$absdir ++ ++ # Now add the directory to shlibpath_var. ++ if eval "test -z \"\$$shlibpath_var\""; then ++ eval "$shlibpath_var=\"\$dir\"" ++ else ++ eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\"" ++ fi ++ done ++ ++ # This variable tells wrapper scripts just to set shlibpath_var ++ # rather than running their programs. ++ libtool_execute_magic=$magic ++ ++ # Check if any of the arguments is a wrapper script. ++ args= ++ for file ++ do ++ case $file in ++ -* | *.la | *.lo ) ;; ++ *) ++ # Do a test to see if this is really a libtool program. ++ if func_ltwrapper_script_p "$file"; then ++ func_source "$file" ++ # Transform arg to wrapped name. ++ file=$progdir/$program ++ elif func_ltwrapper_executable_p "$file"; then ++ func_ltwrapper_scriptname "$file" ++ func_source "$func_ltwrapper_scriptname_result" ++ # Transform arg to wrapped name. ++ file=$progdir/$program ++ fi ++ ;; ++ esac ++ # Quote arguments (to preserve shell metacharacters). ++ func_append_quoted args "$file" ++ done ++ ++ if $opt_dry_run; then ++ # Display what would be done. ++ if test -n "$shlibpath_var"; then ++ eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\"" ++ echo "export $shlibpath_var" ++ fi ++ $ECHO "$cmd$args" ++ exit $EXIT_SUCCESS ++ else ++ if test -n "$shlibpath_var"; then ++ # Export the shlibpath_var. ++ eval "export $shlibpath_var" ++ fi ++ ++ # Restore saved environment variables ++ for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES ++ do ++ eval "if test \"\${save_$lt_var+set}\" = set; then ++ $lt_var=\$save_$lt_var; export $lt_var ++ else ++ $lt_unset $lt_var ++ fi" ++ done ++ ++ # Now prepare to actually exec the command. ++ exec_cmd=\$cmd$args ++ fi ++} ++ ++test execute = "$opt_mode" && func_mode_execute ${1+"$@"} ++ ++ ++# func_mode_finish arg... ++func_mode_finish () ++{ ++ $debug_cmd ++ ++ libs= ++ libdirs= ++ admincmds= ++ ++ for opt in "$nonopt" ${1+"$@"} ++ do ++ if test -d "$opt"; then ++ func_append libdirs " $opt" ++ ++ elif test -f "$opt"; then ++ if func_lalib_unsafe_p "$opt"; then ++ func_append libs " $opt" ++ else ++ func_warning "'$opt' is not a valid libtool archive" ++ fi ++ ++ else ++ func_fatal_error "invalid argument '$opt'" ++ fi ++ done ++ ++ if test -n "$libs"; then ++ if test -n "$lt_sysroot"; then ++ sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"` ++ sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;" ++ else ++ sysroot_cmd= ++ fi ++ ++ # Remove sysroot references ++ if $opt_dry_run; then ++ for lib in $libs; do ++ echo "removing references to $lt_sysroot and '=' prefixes from $lib" ++ done ++ else ++ tmpdir=`func_mktempdir` ++ for lib in $libs; do ++ $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \ ++ > $tmpdir/tmp-la ++ mv -f $tmpdir/tmp-la $lib ++ done ++ ${RM}r "$tmpdir" ++ fi ++ fi ++ ++ if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then ++ for libdir in $libdirs; do ++ if test -n "$finish_cmds"; then ++ # Do each command in the finish commands. ++ func_execute_cmds "$finish_cmds" 'admincmds="$admincmds ++'"$cmd"'"' ++ fi ++ if test -n "$finish_eval"; then ++ # Do the single finish_eval. ++ eval cmds=\"$finish_eval\" ++ $opt_dry_run || eval "$cmds" || func_append admincmds " ++ $cmds" ++ fi ++ done ++ fi ++ ++ # Exit here if they wanted silent mode. ++ $opt_quiet && exit $EXIT_SUCCESS ++ ++ if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then ++ echo "----------------------------------------------------------------------" ++ echo "Libraries have been installed in:" ++ for libdir in $libdirs; do ++ $ECHO " $libdir" ++ done ++ echo ++ echo "If you ever happen to want to link against installed libraries" ++ echo "in a given directory, LIBDIR, you must either use libtool, and" ++ echo "specify the full pathname of the library, or use the '-LLIBDIR'" ++ echo "flag during linking and do at least one of the following:" ++ if test -n "$shlibpath_var"; then ++ echo " - add LIBDIR to the '$shlibpath_var' environment variable" ++ echo " during execution" ++ fi ++ if test -n "$runpath_var"; then ++ echo " - add LIBDIR to the '$runpath_var' environment variable" ++ echo " during linking" ++ fi ++ if test -n "$hardcode_libdir_flag_spec"; then ++ libdir=LIBDIR ++ eval flag=\"$hardcode_libdir_flag_spec\" ++ ++ $ECHO " - use the '$flag' linker flag" ++ fi ++ if test -n "$admincmds"; then ++ $ECHO " - have your system administrator run these commands:$admincmds" ++ fi ++ if test -f /etc/ld.so.conf; then ++ echo " - have your system administrator add LIBDIR to '/etc/ld.so.conf'" ++ fi ++ echo ++ ++ echo "See any operating system documentation about shared libraries for" ++ case $host in ++ solaris2.[6789]|solaris2.1[0-9]) ++ echo "more information, such as the ld(1), crle(1) and ld.so(8) manual" ++ echo "pages." ++ ;; ++ *) ++ echo "more information, such as the ld(1) and ld.so(8) manual pages." ++ ;; ++ esac ++ echo "----------------------------------------------------------------------" ++ fi ++ exit $EXIT_SUCCESS ++} ++ ++test finish = "$opt_mode" && func_mode_finish ${1+"$@"} ++ ++ ++# func_mode_install arg... ++func_mode_install () ++{ ++ $debug_cmd ++ ++ # There may be an optional sh(1) argument at the beginning of ++ # install_prog (especially on Windows NT). ++ if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" || ++ # Allow the use of GNU shtool's install command. ++ case $nonopt in *shtool*) :;; *) false;; esac ++ then ++ # Aesthetically quote it. ++ func_quote_for_eval "$nonopt" ++ install_prog="$func_quote_for_eval_result " ++ arg=$1 ++ shift ++ else ++ install_prog= ++ arg=$nonopt ++ fi ++ ++ # The real first argument should be the name of the installation program. ++ # Aesthetically quote it. ++ func_quote_for_eval "$arg" ++ func_append install_prog "$func_quote_for_eval_result" ++ install_shared_prog=$install_prog ++ case " $install_prog " in ++ *[\\\ /]cp\ *) install_cp=: ;; ++ *) install_cp=false ;; ++ esac ++ ++ # We need to accept at least all the BSD install flags. ++ dest= ++ files= ++ opts= ++ prev= ++ install_type= ++ isdir=false ++ stripme= ++ no_mode=: ++ for arg ++ do ++ arg2= ++ if test -n "$dest"; then ++ func_append files " $dest" ++ dest=$arg ++ continue ++ fi ++ ++ case $arg in ++ -d) isdir=: ;; ++ -f) ++ if $install_cp; then :; else ++ prev=$arg ++ fi ++ ;; ++ -g | -m | -o) ++ prev=$arg ++ ;; ++ -s) ++ stripme=" -s" ++ continue ++ ;; ++ -*) ++ ;; ++ *) ++ # If the previous option needed an argument, then skip it. ++ if test -n "$prev"; then ++ if test X-m = "X$prev" && test -n "$install_override_mode"; then ++ arg2=$install_override_mode ++ no_mode=false ++ fi ++ prev= ++ else ++ dest=$arg ++ continue ++ fi ++ ;; ++ esac ++ ++ # Aesthetically quote the argument. ++ func_quote_for_eval "$arg" ++ func_append install_prog " $func_quote_for_eval_result" ++ if test -n "$arg2"; then ++ func_quote_for_eval "$arg2" ++ fi ++ func_append install_shared_prog " $func_quote_for_eval_result" ++ done ++ ++ test -z "$install_prog" && \ ++ func_fatal_help "you must specify an install program" ++ ++ test -n "$prev" && \ ++ func_fatal_help "the '$prev' option requires an argument" ++ ++ if test -n "$install_override_mode" && $no_mode; then ++ if $install_cp; then :; else ++ func_quote_for_eval "$install_override_mode" ++ func_append install_shared_prog " -m $func_quote_for_eval_result" ++ fi ++ fi ++ ++ if test -z "$files"; then ++ if test -z "$dest"; then ++ func_fatal_help "no file or destination specified" ++ else ++ func_fatal_help "you must specify a destination" ++ fi ++ fi ++ ++ # Strip any trailing slash from the destination. ++ func_stripname '' '/' "$dest" ++ dest=$func_stripname_result ++ ++ # Check to see that the destination is a directory. ++ test -d "$dest" && isdir=: ++ if $isdir; then ++ destdir=$dest ++ destname= ++ else ++ func_dirname_and_basename "$dest" "" "." ++ destdir=$func_dirname_result ++ destname=$func_basename_result ++ ++ # Not a directory, so check to see that there is only one file specified. ++ set dummy $files; shift ++ test "$#" -gt 1 && \ ++ func_fatal_help "'$dest' is not a directory" ++ fi ++ case $destdir in ++ [\\/]* | [A-Za-z]:[\\/]*) ;; ++ *) ++ for file in $files; do ++ case $file in ++ *.lo) ;; ++ *) ++ func_fatal_help "'$destdir' must be an absolute directory name" ++ ;; ++ esac ++ done ++ ;; ++ esac ++ ++ # This variable tells wrapper scripts just to set variables rather ++ # than running their programs. ++ libtool_install_magic=$magic ++ ++ staticlibs= ++ future_libdirs= ++ current_libdirs= ++ for file in $files; do ++ ++ # Do each installation. ++ case $file in ++ *.$libext) ++ # Do the static libraries later. ++ func_append staticlibs " $file" ++ ;; ++ ++ *.la) ++ func_resolve_sysroot "$file" ++ file=$func_resolve_sysroot_result ++ ++ # Check to see that this really is a libtool archive. ++ func_lalib_unsafe_p "$file" \ ++ || func_fatal_help "'$file' is not a valid libtool archive" ++ ++ library_names= ++ old_library= ++ relink_command= ++ func_source "$file" ++ ++ # Add the libdir to current_libdirs if it is the destination. ++ if test "X$destdir" = "X$libdir"; then ++ case "$current_libdirs " in ++ *" $libdir "*) ;; ++ *) func_append current_libdirs " $libdir" ;; ++ esac ++ else ++ # Note the libdir as a future libdir. ++ case "$future_libdirs " in ++ *" $libdir "*) ;; ++ *) func_append future_libdirs " $libdir" ;; ++ esac ++ fi ++ ++ func_dirname "$file" "/" "" ++ dir=$func_dirname_result ++ func_append dir "$objdir" ++ ++ if test -n "$relink_command"; then ++ # Determine the prefix the user has applied to our future dir. ++ inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"` ++ ++ # Don't allow the user to place us outside of our expected ++ # location b/c this prevents finding dependent libraries that ++ # are installed to the same prefix. ++ # At present, this check doesn't affect windows .dll's that ++ # are installed into $libdir/../bin (currently, that works fine) ++ # but it's something to keep an eye on. ++ test "$inst_prefix_dir" = "$destdir" && \ ++ func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir" ++ ++ if test -n "$inst_prefix_dir"; then ++ # Stick the inst_prefix_dir data into the link command. ++ relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"` ++ else ++ relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"` ++ fi ++ ++ func_warning "relinking '$file'" ++ func_show_eval "$relink_command" \ ++ 'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"' ++ fi ++ ++ # See the names of the shared library. ++ set dummy $library_names; shift ++ if test -n "$1"; then ++ realname=$1 ++ shift ++ ++ srcname=$realname ++ test -n "$relink_command" && srcname=${realname}T ++ ++ # Install the shared library and build the symlinks. ++ func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \ ++ 'exit $?' ++ tstripme=$stripme ++ case $host_os in ++ cygwin* | mingw* | pw32* | cegcc*) ++ case $realname in ++ *.dll.a) ++ tstripme= ++ ;; ++ esac ++ ;; ++ os2*) ++ case $realname in ++ *_dll.a) ++ tstripme= ++ ;; ++ esac ++ ;; ++ esac ++ if test -n "$tstripme" && test -n "$striplib"; then ++ func_show_eval "$striplib $destdir/$realname" 'exit $?' ++ fi ++ ++ if test "$#" -gt 0; then ++ # Delete the old symlinks, and create new ones. ++ # Try 'ln -sf' first, because the 'ln' binary might depend on ++ # the symlink we replace! Solaris /bin/ln does not understand -f, ++ # so we also need to try rm && ln -s. ++ for linkname ++ do ++ test "$linkname" != "$realname" \ ++ && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })" ++ done ++ fi ++ ++ # Do each command in the postinstall commands. ++ lib=$destdir/$realname ++ func_execute_cmds "$postinstall_cmds" 'exit $?' ++ fi ++ ++ # Install the pseudo-library for information purposes. ++ func_basename "$file" ++ name=$func_basename_result ++ instname=$dir/${name}i ++ func_show_eval "$install_prog $instname $destdir/$name" 'exit $?' ++ ++ # Maybe install the static library, too. ++ test -n "$old_library" && func_append staticlibs " $dir/$old_library" ++ ;; ++ ++ *.lo) ++ # Install (i.e. copy) a libtool object. ++ ++ # Figure out destination file name, if it wasn't already specified. ++ if test -n "$destname"; then ++ destfile=$destdir/$destname ++ else ++ func_basename "$file" ++ destfile=$func_basename_result ++ destfile=$destdir/$destfile ++ fi ++ ++ # Deduce the name of the destination old-style object file. ++ case $destfile in ++ *.lo) ++ func_lo2o "$destfile" ++ staticdest=$func_lo2o_result ++ ;; ++ *.$objext) ++ staticdest=$destfile ++ destfile= ++ ;; ++ *) ++ func_fatal_help "cannot copy a libtool object to '$destfile'" ++ ;; ++ esac ++ ++ # Install the libtool object if requested. ++ test -n "$destfile" && \ ++ func_show_eval "$install_prog $file $destfile" 'exit $?' ++ ++ # Install the old object if enabled. ++ if test yes = "$build_old_libs"; then ++ # Deduce the name of the old-style object file. ++ func_lo2o "$file" ++ staticobj=$func_lo2o_result ++ func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?' ++ fi ++ exit $EXIT_SUCCESS ++ ;; ++ ++ *) ++ # Figure out destination file name, if it wasn't already specified. ++ if test -n "$destname"; then ++ destfile=$destdir/$destname ++ else ++ func_basename "$file" ++ destfile=$func_basename_result ++ destfile=$destdir/$destfile ++ fi ++ ++ # If the file is missing, and there is a .exe on the end, strip it ++ # because it is most likely a libtool script we actually want to ++ # install ++ stripped_ext= ++ case $file in ++ *.exe) ++ if test ! -f "$file"; then ++ func_stripname '' '.exe' "$file" ++ file=$func_stripname_result ++ stripped_ext=.exe ++ fi ++ ;; ++ esac ++ ++ # Do a test to see if this is really a libtool program. ++ case $host in ++ *cygwin* | *mingw*) ++ if func_ltwrapper_executable_p "$file"; then ++ func_ltwrapper_scriptname "$file" ++ wrapper=$func_ltwrapper_scriptname_result ++ else ++ func_stripname '' '.exe' "$file" ++ wrapper=$func_stripname_result ++ fi ++ ;; ++ *) ++ wrapper=$file ++ ;; ++ esac ++ if func_ltwrapper_script_p "$wrapper"; then ++ notinst_deplibs= ++ relink_command= ++ ++ func_source "$wrapper" ++ ++ # Check the variables that should have been set. ++ test -z "$generated_by_libtool_version" && \ ++ func_fatal_error "invalid libtool wrapper script '$wrapper'" ++ ++ finalize=: ++ for lib in $notinst_deplibs; do ++ # Check to see that each library is installed. ++ libdir= ++ if test -f "$lib"; then ++ func_source "$lib" ++ fi ++ libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'` ++ if test -n "$libdir" && test ! -f "$libfile"; then ++ func_warning "'$lib' has not been installed in '$libdir'" ++ finalize=false ++ fi ++ done ++ ++ relink_command= ++ func_source "$wrapper" ++ ++ outputname= ++ if test no = "$fast_install" && test -n "$relink_command"; then ++ $opt_dry_run || { ++ if $finalize; then ++ tmpdir=`func_mktempdir` ++ func_basename "$file$stripped_ext" ++ file=$func_basename_result ++ outputname=$tmpdir/$file ++ # Replace the output file specification. ++ relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'` ++ ++ $opt_quiet || { ++ func_quote_for_expand "$relink_command" ++ eval "func_echo $func_quote_for_expand_result" ++ } ++ if eval "$relink_command"; then : ++ else ++ func_error "error: relink '$file' with the above command before installing it" ++ $opt_dry_run || ${RM}r "$tmpdir" ++ continue ++ fi ++ file=$outputname ++ else ++ func_warning "cannot relink '$file'" ++ fi ++ } ++ else ++ # Install the binary that we compiled earlier. ++ file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"` ++ fi ++ fi ++ ++ # remove .exe since cygwin /usr/bin/install will append another ++ # one anyway ++ case $install_prog,$host in ++ */usr/bin/install*,*cygwin*) ++ case $file:$destfile in ++ *.exe:*.exe) ++ # this is ok ++ ;; ++ *.exe:*) ++ destfile=$destfile.exe ++ ;; ++ *:*.exe) ++ func_stripname '' '.exe' "$destfile" ++ destfile=$func_stripname_result ++ ;; ++ esac ++ ;; ++ esac ++ func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?' ++ $opt_dry_run || if test -n "$outputname"; then ++ ${RM}r "$tmpdir" ++ fi ++ ;; ++ esac ++ done ++ ++ for file in $staticlibs; do ++ func_basename "$file" ++ name=$func_basename_result ++ ++ # Set up the ranlib parameters. ++ oldlib=$destdir/$name ++ func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 ++ tool_oldlib=$func_to_tool_file_result ++ ++ func_show_eval "$install_prog \$file \$oldlib" 'exit $?' ++ ++ if test -n "$stripme" && test -n "$old_striplib"; then ++ func_show_eval "$old_striplib $tool_oldlib" 'exit $?' ++ fi ++ ++ # Do each command in the postinstall commands. ++ func_execute_cmds "$old_postinstall_cmds" 'exit $?' ++ done ++ ++ test -n "$future_libdirs" && \ ++ func_warning "remember to run '$progname --finish$future_libdirs'" ++ ++ if test -n "$current_libdirs"; then ++ # Maybe just do a dry run. ++ $opt_dry_run && current_libdirs=" -n$current_libdirs" ++ exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs' ++ else ++ exit $EXIT_SUCCESS ++ fi ++} ++ ++test install = "$opt_mode" && func_mode_install ${1+"$@"} ++ ++ ++# func_generate_dlsyms outputname originator pic_p ++# Extract symbols from dlprefiles and create ${outputname}S.o with ++# a dlpreopen symbol table. ++func_generate_dlsyms () ++{ ++ $debug_cmd ++ ++ my_outputname=$1 ++ my_originator=$2 ++ my_pic_p=${3-false} ++ my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'` ++ my_dlsyms= ++ ++ if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then ++ if test -n "$NM" && test -n "$global_symbol_pipe"; then ++ my_dlsyms=${my_outputname}S.c ++ else ++ func_error "not configured to extract global symbols from dlpreopened files" ++ fi ++ fi ++ ++ if test -n "$my_dlsyms"; then ++ case $my_dlsyms in ++ "") ;; ++ *.c) ++ # Discover the nlist of each of the dlfiles. ++ nlist=$output_objdir/$my_outputname.nm ++ ++ func_show_eval "$RM $nlist ${nlist}S ${nlist}T" ++ ++ # Parse the name list into a source file. ++ func_verbose "creating $output_objdir/$my_dlsyms" ++ ++ $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\ ++/* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */ ++/* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */ ++ ++#ifdef __cplusplus ++extern \"C\" { ++#endif ++ ++#if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4)) ++#pragma GCC diagnostic ignored \"-Wstrict-prototypes\" ++#endif ++ ++/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests. */ ++#if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE ++/* DATA imports from DLLs on WIN32 can't be const, because runtime ++ relocations are performed -- see ld's documentation on pseudo-relocs. */ ++# define LT_DLSYM_CONST ++#elif defined __osf__ ++/* This system does not cope well with relocations in const data. */ ++# define LT_DLSYM_CONST ++#else ++# define LT_DLSYM_CONST const ++#endif ++ ++#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0) ++ ++/* External symbol declarations for the compiler. */\ ++" ++ ++ if test yes = "$dlself"; then ++ func_verbose "generating symbol list for '$output'" ++ ++ $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist" ++ ++ # Add our own program objects to the symbol list. ++ progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP` ++ for progfile in $progfiles; do ++ func_to_tool_file "$progfile" func_convert_file_msys_to_w32 ++ func_verbose "extracting global C symbols from '$func_to_tool_file_result'" ++ $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'" ++ done ++ ++ if test -n "$exclude_expsyms"; then ++ $opt_dry_run || { ++ eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T' ++ eval '$MV "$nlist"T "$nlist"' ++ } ++ fi ++ ++ if test -n "$export_symbols_regex"; then ++ $opt_dry_run || { ++ eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T' ++ eval '$MV "$nlist"T "$nlist"' ++ } ++ fi ++ ++ # Prepare the list of exported symbols ++ if test -z "$export_symbols"; then ++ export_symbols=$output_objdir/$outputname.exp ++ $opt_dry_run || { ++ $RM $export_symbols ++ eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"' ++ case $host in ++ *cygwin* | *mingw* | *cegcc* ) ++ eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' ++ eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"' ++ ;; ++ esac ++ } ++ else ++ $opt_dry_run || { ++ eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"' ++ eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T' ++ eval '$MV "$nlist"T "$nlist"' ++ case $host in ++ *cygwin* | *mingw* | *cegcc* ) ++ eval "echo EXPORTS "'> "$output_objdir/$outputname.def"' ++ eval 'cat "$nlist" >> "$output_objdir/$outputname.def"' ++ ;; ++ esac ++ } ++ fi ++ fi ++ ++ for dlprefile in $dlprefiles; do ++ func_verbose "extracting global C symbols from '$dlprefile'" ++ func_basename "$dlprefile" ++ name=$func_basename_result ++ case $host in ++ *cygwin* | *mingw* | *cegcc* ) ++ # if an import library, we need to obtain dlname ++ if func_win32_import_lib_p "$dlprefile"; then ++ func_tr_sh "$dlprefile" ++ eval "curr_lafile=\$libfile_$func_tr_sh_result" ++ dlprefile_dlbasename= ++ if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then ++ # Use subshell, to avoid clobbering current variable values ++ dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"` ++ if test -n "$dlprefile_dlname"; then ++ func_basename "$dlprefile_dlname" ++ dlprefile_dlbasename=$func_basename_result ++ else ++ # no lafile. user explicitly requested -dlpreopen . ++ $sharedlib_from_linklib_cmd "$dlprefile" ++ dlprefile_dlbasename=$sharedlib_from_linklib_result ++ fi ++ fi ++ $opt_dry_run || { ++ if test -n "$dlprefile_dlbasename"; then ++ eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"' ++ else ++ func_warning "Could not compute DLL name from $name" ++ eval '$ECHO ": $name " >> "$nlist"' ++ fi ++ func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 ++ eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe | ++ $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'" ++ } ++ else # not an import lib ++ $opt_dry_run || { ++ eval '$ECHO ": $name " >> "$nlist"' ++ func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 ++ eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" ++ } ++ fi ++ ;; ++ *) ++ $opt_dry_run || { ++ eval '$ECHO ": $name " >> "$nlist"' ++ func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32 ++ eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'" ++ } ++ ;; ++ esac ++ done ++ ++ $opt_dry_run || { ++ # Make sure we have at least an empty file. ++ test -f "$nlist" || : > "$nlist" ++ ++ if test -n "$exclude_expsyms"; then ++ $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T ++ $MV "$nlist"T "$nlist" ++ fi ++ ++ # Try sorting and uniquifying the output. ++ if $GREP -v "^: " < "$nlist" | ++ if sort -k 3 /dev/null 2>&1; then ++ sort -k 3 ++ else ++ sort +2 ++ fi | ++ uniq > "$nlist"S; then ++ : ++ else ++ $GREP -v "^: " < "$nlist" > "$nlist"S ++ fi ++ ++ if test -f "$nlist"S; then ++ eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"' ++ else ++ echo '/* NONE */' >> "$output_objdir/$my_dlsyms" ++ fi ++ ++ func_show_eval '$RM "${nlist}I"' ++ if test -n "$global_symbol_to_import"; then ++ eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I' ++ fi ++ ++ echo >> "$output_objdir/$my_dlsyms" "\ ++ ++/* The mapping between symbol names and symbols. */ ++typedef struct { ++ const char *name; ++ void *address; ++} lt_dlsymlist; ++extern LT_DLSYM_CONST lt_dlsymlist ++lt_${my_prefix}_LTX_preloaded_symbols[];\ ++" ++ ++ if test -s "$nlist"I; then ++ echo >> "$output_objdir/$my_dlsyms" "\ ++static void lt_syminit(void) ++{ ++ LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols; ++ for (; symbol->name; ++symbol) ++ {" ++ $SED 's/.*/ if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms" ++ echo >> "$output_objdir/$my_dlsyms" "\ ++ } ++}" ++ fi ++ echo >> "$output_objdir/$my_dlsyms" "\ ++LT_DLSYM_CONST lt_dlsymlist ++lt_${my_prefix}_LTX_preloaded_symbols[] = ++{ {\"$my_originator\", (void *) 0}," ++ ++ if test -s "$nlist"I; then ++ echo >> "$output_objdir/$my_dlsyms" "\ ++ {\"@INIT@\", (void *) <_syminit}," ++ fi ++ ++ case $need_lib_prefix in ++ no) ++ eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms" ++ ;; ++ *) ++ eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms" ++ ;; ++ esac ++ echo >> "$output_objdir/$my_dlsyms" "\ ++ {0, (void *) 0} ++}; ++ ++/* This works around a problem in FreeBSD linker */ ++#ifdef FREEBSD_WORKAROUND ++static const void *lt_preloaded_setup() { ++ return lt_${my_prefix}_LTX_preloaded_symbols; ++} ++#endif ++ ++#ifdef __cplusplus ++} ++#endif\ ++" ++ } # !$opt_dry_run ++ ++ pic_flag_for_symtable= ++ case "$compile_command " in ++ *" -static "*) ;; ++ *) ++ case $host in ++ # compiling the symbol table file with pic_flag works around ++ # a FreeBSD bug that causes programs to crash when -lm is ++ # linked before any other PIC object. But we must not use ++ # pic_flag when linking with -static. The problem exists in ++ # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1. ++ *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*) ++ pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;; ++ *-*-hpux*) ++ pic_flag_for_symtable=" $pic_flag" ;; ++ *) ++ $my_pic_p && pic_flag_for_symtable=" $pic_flag" ++ ;; ++ esac ++ ;; ++ esac ++ symtab_cflags= ++ for arg in $LTCFLAGS; do ++ case $arg in ++ -pie | -fpie | -fPIE) ;; ++ *) func_append symtab_cflags " $arg" ;; ++ esac ++ done ++ ++ # Now compile the dynamic symbol file. ++ func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?' ++ ++ # Clean up the generated files. ++ func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"' ++ ++ # Transform the symbol file into the correct name. ++ symfileobj=$output_objdir/${my_outputname}S.$objext ++ case $host in ++ *cygwin* | *mingw* | *cegcc* ) ++ if test -f "$output_objdir/$my_outputname.def"; then ++ compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` ++ finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"` ++ else ++ compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` ++ finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` ++ fi ++ ;; ++ *) ++ compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"` ++ finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"` ++ ;; ++ esac ++ ;; ++ *) ++ func_fatal_error "unknown suffix for '$my_dlsyms'" ++ ;; ++ esac ++ else ++ # We keep going just in case the user didn't refer to ++ # lt_preloaded_symbols. The linker will fail if global_symbol_pipe ++ # really was required. ++ ++ # Nullify the symbol file. ++ compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"` ++ finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"` ++ fi ++} ++ ++# func_cygming_gnu_implib_p ARG ++# This predicate returns with zero status (TRUE) if ++# ARG is a GNU/binutils-style import library. Returns ++# with nonzero status (FALSE) otherwise. ++func_cygming_gnu_implib_p () ++{ ++ $debug_cmd ++ ++ func_to_tool_file "$1" func_convert_file_msys_to_w32 ++ func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'` ++ test -n "$func_cygming_gnu_implib_tmp" ++} ++ ++# func_cygming_ms_implib_p ARG ++# This predicate returns with zero status (TRUE) if ++# ARG is an MS-style import library. Returns ++# with nonzero status (FALSE) otherwise. ++func_cygming_ms_implib_p () ++{ ++ $debug_cmd ++ ++ func_to_tool_file "$1" func_convert_file_msys_to_w32 ++ func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'` ++ test -n "$func_cygming_ms_implib_tmp" ++} ++ ++# func_win32_libid arg ++# return the library type of file 'arg' ++# ++# Need a lot of goo to handle *both* DLLs and import libs ++# Has to be a shell function in order to 'eat' the argument ++# that is supplied when $file_magic_command is called. ++# Despite the name, also deal with 64 bit binaries. ++func_win32_libid () ++{ ++ $debug_cmd ++ ++ win32_libid_type=unknown ++ win32_fileres=`file -L $1 2>/dev/null` ++ case $win32_fileres in ++ *ar\ archive\ import\ library*) # definitely import ++ win32_libid_type="x86 archive import" ++ ;; ++ *ar\ archive*) # could be an import, or static ++ # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD. ++ if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | ++ $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then ++ case $nm_interface in ++ "MS dumpbin") ++ if func_cygming_ms_implib_p "$1" || ++ func_cygming_gnu_implib_p "$1" ++ then ++ win32_nmres=import ++ else ++ win32_nmres= ++ fi ++ ;; ++ *) ++ func_to_tool_file "$1" func_convert_file_msys_to_w32 ++ win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" | ++ $SED -n -e ' ++ 1,100{ ++ / I /{ ++ s|.*|import| ++ p ++ q ++ } ++ }'` ++ ;; ++ esac ++ case $win32_nmres in ++ import*) win32_libid_type="x86 archive import";; ++ *) win32_libid_type="x86 archive static";; ++ esac ++ fi ++ ;; ++ *DLL*) ++ win32_libid_type="x86 DLL" ++ ;; ++ *executable*) # but shell scripts are "executable" too... ++ case $win32_fileres in ++ *MS\ Windows\ PE\ Intel*) ++ win32_libid_type="x86 DLL" ++ ;; ++ esac ++ ;; ++ esac ++ $ECHO "$win32_libid_type" ++} ++ ++# func_cygming_dll_for_implib ARG ++# ++# Platform-specific function to extract the ++# name of the DLL associated with the specified ++# import library ARG. ++# Invoked by eval'ing the libtool variable ++# $sharedlib_from_linklib_cmd ++# Result is available in the variable ++# $sharedlib_from_linklib_result ++func_cygming_dll_for_implib () ++{ ++ $debug_cmd ++ ++ sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"` ++} ++ ++# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs ++# ++# The is the core of a fallback implementation of a ++# platform-specific function to extract the name of the ++# DLL associated with the specified import library LIBNAME. ++# ++# SECTION_NAME is either .idata$6 or .idata$7, depending ++# on the platform and compiler that created the implib. ++# ++# Echos the name of the DLL associated with the ++# specified import library. ++func_cygming_dll_for_implib_fallback_core () ++{ ++ $debug_cmd ++ ++ match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"` ++ $OBJDUMP -s --section "$1" "$2" 2>/dev/null | ++ $SED '/^Contents of section '"$match_literal"':/{ ++ # Place marker at beginning of archive member dllname section ++ s/.*/====MARK====/ ++ p ++ d ++ } ++ # These lines can sometimes be longer than 43 characters, but ++ # are always uninteresting ++ /:[ ]*file format pe[i]\{,1\}-/d ++ /^In archive [^:]*:/d ++ # Ensure marker is printed ++ /^====MARK====/p ++ # Remove all lines with less than 43 characters ++ /^.\{43\}/!d ++ # From remaining lines, remove first 43 characters ++ s/^.\{43\}//' | ++ $SED -n ' ++ # Join marker and all lines until next marker into a single line ++ /^====MARK====/ b para ++ H ++ $ b para ++ b ++ :para ++ x ++ s/\n//g ++ # Remove the marker ++ s/^====MARK====// ++ # Remove trailing dots and whitespace ++ s/[\. \t]*$// ++ # Print ++ /./p' | ++ # we now have a list, one entry per line, of the stringified ++ # contents of the appropriate section of all members of the ++ # archive that possess that section. Heuristic: eliminate ++ # all those that have a first or second character that is ++ # a '.' (that is, objdump's representation of an unprintable ++ # character.) This should work for all archives with less than ++ # 0x302f exports -- but will fail for DLLs whose name actually ++ # begins with a literal '.' or a single character followed by ++ # a '.'. ++ # ++ # Of those that remain, print the first one. ++ $SED -e '/^\./d;/^.\./d;q' ++} ++ ++# func_cygming_dll_for_implib_fallback ARG ++# Platform-specific function to extract the ++# name of the DLL associated with the specified ++# import library ARG. ++# ++# This fallback implementation is for use when $DLLTOOL ++# does not support the --identify-strict option. ++# Invoked by eval'ing the libtool variable ++# $sharedlib_from_linklib_cmd ++# Result is available in the variable ++# $sharedlib_from_linklib_result ++func_cygming_dll_for_implib_fallback () ++{ ++ $debug_cmd ++ ++ if func_cygming_gnu_implib_p "$1"; then ++ # binutils import library ++ sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"` ++ elif func_cygming_ms_implib_p "$1"; then ++ # ms-generated import library ++ sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"` ++ else ++ # unknown ++ sharedlib_from_linklib_result= ++ fi ++} ++ ++ ++# func_extract_an_archive dir oldlib ++func_extract_an_archive () ++{ ++ $debug_cmd ++ ++ f_ex_an_ar_dir=$1; shift ++ f_ex_an_ar_oldlib=$1 ++ if test yes = "$lock_old_archive_extraction"; then ++ lockfile=$f_ex_an_ar_oldlib.lock ++ until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do ++ func_echo "Waiting for $lockfile to be removed" ++ sleep 2 ++ done ++ fi ++ func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \ ++ 'stat=$?; rm -f "$lockfile"; exit $stat' ++ if test yes = "$lock_old_archive_extraction"; then ++ $opt_dry_run || rm -f "$lockfile" ++ fi ++ if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then ++ : ++ else ++ func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" ++ fi ++} ++ ++ ++# func_extract_archives gentop oldlib ... ++func_extract_archives () ++{ ++ $debug_cmd ++ ++ my_gentop=$1; shift ++ my_oldlibs=${1+"$@"} ++ my_oldobjs= ++ my_xlib= ++ my_xabs= ++ my_xdir= ++ ++ for my_xlib in $my_oldlibs; do ++ # Extract the objects. ++ case $my_xlib in ++ [\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;; ++ *) my_xabs=`pwd`"/$my_xlib" ;; ++ esac ++ func_basename "$my_xlib" ++ my_xlib=$func_basename_result ++ my_xlib_u=$my_xlib ++ while :; do ++ case " $extracted_archives " in ++ *" $my_xlib_u "*) ++ func_arith $extracted_serial + 1 ++ extracted_serial=$func_arith_result ++ my_xlib_u=lt$extracted_serial-$my_xlib ;; ++ *) break ;; ++ esac ++ done ++ extracted_archives="$extracted_archives $my_xlib_u" ++ my_xdir=$my_gentop/$my_xlib_u ++ ++ func_mkdir_p "$my_xdir" ++ ++ case $host in ++ *-darwin*) ++ func_verbose "Extracting $my_xabs" ++ # Do not bother doing anything if just a dry run ++ $opt_dry_run || { ++ darwin_orig_dir=`pwd` ++ cd $my_xdir || exit $? ++ darwin_archive=$my_xabs ++ darwin_curdir=`pwd` ++ func_basename "$darwin_archive" ++ darwin_base_archive=$func_basename_result ++ darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true` ++ if test -n "$darwin_arches"; then ++ darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'` ++ darwin_arch= ++ func_verbose "$darwin_base_archive has multiple architectures $darwin_arches" ++ for darwin_arch in $darwin_arches; do ++ func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch" ++ $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive" ++ cd "unfat-$$/$darwin_base_archive-$darwin_arch" ++ func_extract_an_archive "`pwd`" "$darwin_base_archive" ++ cd "$darwin_curdir" ++ $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" ++ done # $darwin_arches ++ ## Okay now we've a bunch of thin objects, gotta fatten them up :) ++ darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u` ++ darwin_file= ++ darwin_files= ++ for darwin_file in $darwin_filelist; do ++ darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP` ++ $LIPO -create -output "$darwin_file" $darwin_files ++ done # $darwin_filelist ++ $RM -rf unfat-$$ ++ cd "$darwin_orig_dir" ++ else ++ cd $darwin_orig_dir ++ func_extract_an_archive "$my_xdir" "$my_xabs" ++ fi # $darwin_arches ++ } # !$opt_dry_run ++ ;; ++ *) ++ func_extract_an_archive "$my_xdir" "$my_xabs" ++ ;; ++ esac ++ my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP` ++ done ++ ++ func_extract_archives_result=$my_oldobjs ++} ++ ++ ++# func_emit_wrapper [arg=no] ++# ++# Emit a libtool wrapper script on stdout. ++# Don't directly open a file because we may want to ++# incorporate the script contents within a cygwin/mingw ++# wrapper executable. Must ONLY be called from within ++# func_mode_link because it depends on a number of variables ++# set therein. ++# ++# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR ++# variable will take. If 'yes', then the emitted script ++# will assume that the directory where it is stored is ++# the $objdir directory. This is a cygwin/mingw-specific ++# behavior. ++func_emit_wrapper () ++{ ++ func_emit_wrapper_arg1=${1-no} ++ ++ $ECHO "\ ++#! $SHELL ++ ++# $output - temporary wrapper script for $objdir/$outputname ++# Generated by $PROGRAM (GNU $PACKAGE) $VERSION ++# ++# The $output program cannot be directly executed until all the libtool ++# libraries that it depends on are installed. ++# ++# This wrapper script should never be moved out of the build directory. ++# If it is, it will not operate correctly. ++ ++# Sed substitution that helps us do robust quoting. It backslashifies ++# metacharacters that are still active within double-quoted strings. ++sed_quote_subst='$sed_quote_subst' ++ ++# Be Bourne compatible ++if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then ++ emulate sh ++ NULLCMD=: ++ # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which ++ # is contrary to our usage. Disable this feature. ++ alias -g '\${1+\"\$@\"}'='\"\$@\"' ++ setopt NO_GLOB_SUBST ++else ++ case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac ++fi ++BIN_SH=xpg4; export BIN_SH # for Tru64 ++DUALCASE=1; export DUALCASE # for MKS sh ++ ++# The HP-UX ksh and POSIX shell print the target directory to stdout ++# if CDPATH is set. ++(unset CDPATH) >/dev/null 2>&1 && unset CDPATH ++ ++relink_command=\"$relink_command\" ++ ++# This environment variable determines our operation mode. ++if test \"\$libtool_install_magic\" = \"$magic\"; then ++ # install mode needs the following variables: ++ generated_by_libtool_version='$macro_version' ++ notinst_deplibs='$notinst_deplibs' ++else ++ # When we are sourced in execute mode, \$file and \$ECHO are already set. ++ if test \"\$libtool_execute_magic\" != \"$magic\"; then ++ file=\"\$0\"" ++ ++ qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"` ++ $ECHO "\ ++ ++# A function that is used when there is no print builtin or printf. ++func_fallback_echo () ++{ ++ eval 'cat <<_LTECHO_EOF ++\$1 ++_LTECHO_EOF' ++} ++ ECHO=\"$qECHO\" ++ fi ++ ++# Very basic option parsing. These options are (a) specific to ++# the libtool wrapper, (b) are identical between the wrapper ++# /script/ and the wrapper /executable/ that is used only on ++# windows platforms, and (c) all begin with the string "--lt-" ++# (application programs are unlikely to have options that match ++# this pattern). ++# ++# There are only two supported options: --lt-debug and ++# --lt-dump-script. There is, deliberately, no --lt-help. ++# ++# The first argument to this parsing function should be the ++# script's $0 value, followed by "$@". ++lt_option_debug= ++func_parse_lt_options () ++{ ++ lt_script_arg0=\$0 ++ shift ++ for lt_opt ++ do ++ case \"\$lt_opt\" in ++ --lt-debug) lt_option_debug=1 ;; ++ --lt-dump-script) ++ lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\` ++ test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=. ++ lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\` ++ cat \"\$lt_dump_D/\$lt_dump_F\" ++ exit 0 ++ ;; ++ --lt-*) ++ \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2 ++ exit 1 ++ ;; ++ esac ++ done ++ ++ # Print the debug banner immediately: ++ if test -n \"\$lt_option_debug\"; then ++ echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2 ++ fi ++} ++ ++# Used when --lt-debug. Prints its arguments to stdout ++# (redirection is the responsibility of the caller) ++func_lt_dump_args () ++{ ++ lt_dump_args_N=1; ++ for lt_arg ++ do ++ \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\" ++ lt_dump_args_N=\`expr \$lt_dump_args_N + 1\` ++ done ++} ++ ++# Core function for launching the target application ++func_exec_program_core () ++{ ++" ++ case $host in ++ # Backslashes separate directories on plain windows ++ *-*-mingw | *-*-os2* | *-cegcc*) ++ $ECHO "\ ++ if test -n \"\$lt_option_debug\"; then ++ \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2 ++ func_lt_dump_args \${1+\"\$@\"} 1>&2 ++ fi ++ exec \"\$progdir\\\\\$program\" \${1+\"\$@\"} ++" ++ ;; ++ ++ *) ++ $ECHO "\ ++ if test -n \"\$lt_option_debug\"; then ++ \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2 ++ func_lt_dump_args \${1+\"\$@\"} 1>&2 ++ fi ++ exec \"\$progdir/\$program\" \${1+\"\$@\"} ++" ++ ;; ++ esac ++ $ECHO "\ ++ \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2 ++ exit 1 ++} ++ ++# A function to encapsulate launching the target application ++# Strips options in the --lt-* namespace from \$@ and ++# launches target application with the remaining arguments. ++func_exec_program () ++{ ++ case \" \$* \" in ++ *\\ --lt-*) ++ for lt_wr_arg ++ do ++ case \$lt_wr_arg in ++ --lt-*) ;; ++ *) set x \"\$@\" \"\$lt_wr_arg\"; shift;; ++ esac ++ shift ++ done ;; ++ esac ++ func_exec_program_core \${1+\"\$@\"} ++} ++ ++ # Parse options ++ func_parse_lt_options \"\$0\" \${1+\"\$@\"} ++ ++ # Find the directory that this script lives in. ++ thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\` ++ test \"x\$thisdir\" = \"x\$file\" && thisdir=. ++ ++ # Follow symbolic links until we get to the real thisdir. ++ file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\` ++ while test -n \"\$file\"; do ++ destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\` ++ ++ # If there was a directory component, then change thisdir. ++ if test \"x\$destdir\" != \"x\$file\"; then ++ case \"\$destdir\" in ++ [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;; ++ *) thisdir=\"\$thisdir/\$destdir\" ;; ++ esac ++ fi ++ ++ file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\` ++ file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\` ++ done ++ ++ # Usually 'no', except on cygwin/mingw when embedded into ++ # the cwrapper. ++ WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1 ++ if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then ++ # special case for '.' ++ if test \"\$thisdir\" = \".\"; then ++ thisdir=\`pwd\` ++ fi ++ # remove .libs from thisdir ++ case \"\$thisdir\" in ++ *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;; ++ $objdir ) thisdir=. ;; ++ esac ++ fi ++ ++ # Try to get the absolute directory name. ++ absdir=\`cd \"\$thisdir\" && pwd\` ++ test -n \"\$absdir\" && thisdir=\"\$absdir\" ++" ++ ++ if test yes = "$fast_install"; then ++ $ECHO "\ ++ program=lt-'$outputname'$exeext ++ progdir=\"\$thisdir/$objdir\" ++ ++ if test ! -f \"\$progdir/\$program\" || ++ { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\ ++ test \"X\$file\" != \"X\$progdir/\$program\"; }; then ++ ++ file=\"\$\$-\$program\" ++ ++ if test ! -d \"\$progdir\"; then ++ $MKDIR \"\$progdir\" ++ else ++ $RM \"\$progdir/\$file\" ++ fi" ++ ++ $ECHO "\ ++ ++ # relink executable if necessary ++ if test -n \"\$relink_command\"; then ++ if relink_command_output=\`eval \$relink_command 2>&1\`; then : ++ else ++ \$ECHO \"\$relink_command_output\" >&2 ++ $RM \"\$progdir/\$file\" ++ exit 1 ++ fi ++ fi ++ ++ $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null || ++ { $RM \"\$progdir/\$program\"; ++ $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; } ++ $RM \"\$progdir/\$file\" ++ fi" ++ else ++ $ECHO "\ ++ program='$outputname' ++ progdir=\"\$thisdir/$objdir\" ++" ++ fi ++ ++ $ECHO "\ ++ ++ if test -f \"\$progdir/\$program\"; then" ++ ++ # fixup the dll searchpath if we need to. ++ # ++ # Fix the DLL searchpath if we need to. Do this before prepending ++ # to shlibpath, because on Windows, both are PATH and uninstalled ++ # libraries must come first. ++ if test -n "$dllsearchpath"; then ++ $ECHO "\ ++ # Add the dll search path components to the executable PATH ++ PATH=$dllsearchpath:\$PATH ++" ++ fi ++ ++ # Export our shlibpath_var if we have one. ++ if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then ++ $ECHO "\ ++ # Add our own library path to $shlibpath_var ++ $shlibpath_var=\"$temp_rpath\$$shlibpath_var\" ++ ++ # Some systems cannot cope with colon-terminated $shlibpath_var ++ # The second colon is a workaround for a bug in BeOS R4 sed ++ $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\` ++ ++ export $shlibpath_var ++" ++ fi ++ ++ $ECHO "\ ++ if test \"\$libtool_execute_magic\" != \"$magic\"; then ++ # Run the actual program with our arguments. ++ func_exec_program \${1+\"\$@\"} ++ fi ++ else ++ # The program doesn't exist. ++ \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2 ++ \$ECHO \"This script is just a wrapper for \$program.\" 1>&2 ++ \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2 ++ exit 1 ++ fi ++fi\ ++" ++} ++ ++ ++# func_emit_cwrapperexe_src ++# emit the source code for a wrapper executable on stdout ++# Must ONLY be called from within func_mode_link because ++# it depends on a number of variable set therein. ++func_emit_cwrapperexe_src () ++{ ++ cat < ++#include ++#ifdef _MSC_VER ++# include ++# include ++# include ++#else ++# include ++# include ++# ifdef __CYGWIN__ ++# include ++# endif ++#endif ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++#define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0) ++ ++/* declarations of non-ANSI functions */ ++#if defined __MINGW32__ ++# ifdef __STRICT_ANSI__ ++int _putenv (const char *); ++# endif ++#elif defined __CYGWIN__ ++# ifdef __STRICT_ANSI__ ++char *realpath (const char *, char *); ++int putenv (char *); ++int setenv (const char *, const char *, int); ++# endif ++/* #elif defined other_platform || defined ... */ ++#endif ++ ++/* portability defines, excluding path handling macros */ ++#if defined _MSC_VER ++# define setmode _setmode ++# define stat _stat ++# define chmod _chmod ++# define getcwd _getcwd ++# define putenv _putenv ++# define S_IXUSR _S_IEXEC ++#elif defined __MINGW32__ ++# define setmode _setmode ++# define stat _stat ++# define chmod _chmod ++# define getcwd _getcwd ++# define putenv _putenv ++#elif defined __CYGWIN__ ++# define HAVE_SETENV ++# define FOPEN_WB "wb" ++/* #elif defined other platforms ... */ ++#endif ++ ++#if defined PATH_MAX ++# define LT_PATHMAX PATH_MAX ++#elif defined MAXPATHLEN ++# define LT_PATHMAX MAXPATHLEN ++#else ++# define LT_PATHMAX 1024 ++#endif ++ ++#ifndef S_IXOTH ++# define S_IXOTH 0 ++#endif ++#ifndef S_IXGRP ++# define S_IXGRP 0 ++#endif ++ ++/* path handling portability macros */ ++#ifndef DIR_SEPARATOR ++# define DIR_SEPARATOR '/' ++# define PATH_SEPARATOR ':' ++#endif ++ ++#if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \ ++ defined __OS2__ ++# define HAVE_DOS_BASED_FILE_SYSTEM ++# define FOPEN_WB "wb" ++# ifndef DIR_SEPARATOR_2 ++# define DIR_SEPARATOR_2 '\\' ++# endif ++# ifndef PATH_SEPARATOR_2 ++# define PATH_SEPARATOR_2 ';' ++# endif ++#endif ++ ++#ifndef DIR_SEPARATOR_2 ++# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR) ++#else /* DIR_SEPARATOR_2 */ ++# define IS_DIR_SEPARATOR(ch) \ ++ (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2)) ++#endif /* DIR_SEPARATOR_2 */ ++ ++#ifndef PATH_SEPARATOR_2 ++# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR) ++#else /* PATH_SEPARATOR_2 */ ++# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2) ++#endif /* PATH_SEPARATOR_2 */ ++ ++#ifndef FOPEN_WB ++# define FOPEN_WB "w" ++#endif ++#ifndef _O_BINARY ++# define _O_BINARY 0 ++#endif ++ ++#define XMALLOC(type, num) ((type *) xmalloc ((num) * sizeof(type))) ++#define XFREE(stale) do { \ ++ if (stale) { free (stale); stale = 0; } \ ++} while (0) ++ ++#if defined LT_DEBUGWRAPPER ++static int lt_debug = 1; ++#else ++static int lt_debug = 0; ++#endif ++ ++const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */ ++ ++void *xmalloc (size_t num); ++char *xstrdup (const char *string); ++const char *base_name (const char *name); ++char *find_executable (const char *wrapper); ++char *chase_symlinks (const char *pathspec); ++int make_executable (const char *path); ++int check_executable (const char *path); ++char *strendzap (char *str, const char *pat); ++void lt_debugprintf (const char *file, int line, const char *fmt, ...); ++void lt_fatal (const char *file, int line, const char *message, ...); ++static const char *nonnull (const char *s); ++static const char *nonempty (const char *s); ++void lt_setenv (const char *name, const char *value); ++char *lt_extend_str (const char *orig_value, const char *add, int to_end); ++void lt_update_exe_path (const char *name, const char *value); ++void lt_update_lib_path (const char *name, const char *value); ++char **prepare_spawn (char **argv); ++void lt_dump_script (FILE *f); ++EOF ++ ++ cat <= 0) ++ && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))) ++ return 1; ++ else ++ return 0; ++} ++ ++int ++make_executable (const char *path) ++{ ++ int rval = 0; ++ struct stat st; ++ ++ lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n", ++ nonempty (path)); ++ if ((!path) || (!*path)) ++ return 0; ++ ++ if (stat (path, &st) >= 0) ++ { ++ rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR); ++ } ++ return rval; ++} ++ ++/* Searches for the full path of the wrapper. Returns ++ newly allocated full path name if found, NULL otherwise ++ Does not chase symlinks, even on platforms that support them. ++*/ ++char * ++find_executable (const char *wrapper) ++{ ++ int has_slash = 0; ++ const char *p; ++ const char *p_next; ++ /* static buffer for getcwd */ ++ char tmp[LT_PATHMAX + 1]; ++ size_t tmp_len; ++ char *concat_name; ++ ++ lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n", ++ nonempty (wrapper)); ++ ++ if ((wrapper == NULL) || (*wrapper == '\0')) ++ return NULL; ++ ++ /* Absolute path? */ ++#if defined HAVE_DOS_BASED_FILE_SYSTEM ++ if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':') ++ { ++ concat_name = xstrdup (wrapper); ++ if (check_executable (concat_name)) ++ return concat_name; ++ XFREE (concat_name); ++ } ++ else ++ { ++#endif ++ if (IS_DIR_SEPARATOR (wrapper[0])) ++ { ++ concat_name = xstrdup (wrapper); ++ if (check_executable (concat_name)) ++ return concat_name; ++ XFREE (concat_name); ++ } ++#if defined HAVE_DOS_BASED_FILE_SYSTEM ++ } ++#endif ++ ++ for (p = wrapper; *p; p++) ++ if (*p == '/') ++ { ++ has_slash = 1; ++ break; ++ } ++ if (!has_slash) ++ { ++ /* no slashes; search PATH */ ++ const char *path = getenv ("PATH"); ++ if (path != NULL) ++ { ++ for (p = path; *p; p = p_next) ++ { ++ const char *q; ++ size_t p_len; ++ for (q = p; *q; q++) ++ if (IS_PATH_SEPARATOR (*q)) ++ break; ++ p_len = (size_t) (q - p); ++ p_next = (*q == '\0' ? q : q + 1); ++ if (p_len == 0) ++ { ++ /* empty path: current directory */ ++ if (getcwd (tmp, LT_PATHMAX) == NULL) ++ lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", ++ nonnull (strerror (errno))); ++ tmp_len = strlen (tmp); ++ concat_name = ++ XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); ++ memcpy (concat_name, tmp, tmp_len); ++ concat_name[tmp_len] = '/'; ++ strcpy (concat_name + tmp_len + 1, wrapper); ++ } ++ else ++ { ++ concat_name = ++ XMALLOC (char, p_len + 1 + strlen (wrapper) + 1); ++ memcpy (concat_name, p, p_len); ++ concat_name[p_len] = '/'; ++ strcpy (concat_name + p_len + 1, wrapper); ++ } ++ if (check_executable (concat_name)) ++ return concat_name; ++ XFREE (concat_name); ++ } ++ } ++ /* not found in PATH; assume curdir */ ++ } ++ /* Relative path | not found in path: prepend cwd */ ++ if (getcwd (tmp, LT_PATHMAX) == NULL) ++ lt_fatal (__FILE__, __LINE__, "getcwd failed: %s", ++ nonnull (strerror (errno))); ++ tmp_len = strlen (tmp); ++ concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1); ++ memcpy (concat_name, tmp, tmp_len); ++ concat_name[tmp_len] = '/'; ++ strcpy (concat_name + tmp_len + 1, wrapper); ++ ++ if (check_executable (concat_name)) ++ return concat_name; ++ XFREE (concat_name); ++ return NULL; ++} ++ ++char * ++chase_symlinks (const char *pathspec) ++{ ++#ifndef S_ISLNK ++ return xstrdup (pathspec); ++#else ++ char buf[LT_PATHMAX]; ++ struct stat s; ++ char *tmp_pathspec = xstrdup (pathspec); ++ char *p; ++ int has_symlinks = 0; ++ while (strlen (tmp_pathspec) && !has_symlinks) ++ { ++ lt_debugprintf (__FILE__, __LINE__, ++ "checking path component for symlinks: %s\n", ++ tmp_pathspec); ++ if (lstat (tmp_pathspec, &s) == 0) ++ { ++ if (S_ISLNK (s.st_mode) != 0) ++ { ++ has_symlinks = 1; ++ break; ++ } ++ ++ /* search backwards for last DIR_SEPARATOR */ ++ p = tmp_pathspec + strlen (tmp_pathspec) - 1; ++ while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) ++ p--; ++ if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p))) ++ { ++ /* no more DIR_SEPARATORS left */ ++ break; ++ } ++ *p = '\0'; ++ } ++ else ++ { ++ lt_fatal (__FILE__, __LINE__, ++ "error accessing file \"%s\": %s", ++ tmp_pathspec, nonnull (strerror (errno))); ++ } ++ } ++ XFREE (tmp_pathspec); ++ ++ if (!has_symlinks) ++ { ++ return xstrdup (pathspec); ++ } ++ ++ tmp_pathspec = realpath (pathspec, buf); ++ if (tmp_pathspec == 0) ++ { ++ lt_fatal (__FILE__, __LINE__, ++ "could not follow symlinks for %s", pathspec); ++ } ++ return xstrdup (tmp_pathspec); ++#endif ++} ++ ++char * ++strendzap (char *str, const char *pat) ++{ ++ size_t len, patlen; ++ ++ assert (str != NULL); ++ assert (pat != NULL); ++ ++ len = strlen (str); ++ patlen = strlen (pat); ++ ++ if (patlen <= len) ++ { ++ str += len - patlen; ++ if (STREQ (str, pat)) ++ *str = '\0'; ++ } ++ return str; ++} ++ ++void ++lt_debugprintf (const char *file, int line, const char *fmt, ...) ++{ ++ va_list args; ++ if (lt_debug) ++ { ++ (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line); ++ va_start (args, fmt); ++ (void) vfprintf (stderr, fmt, args); ++ va_end (args); ++ } ++} ++ ++static void ++lt_error_core (int exit_status, const char *file, ++ int line, const char *mode, ++ const char *message, va_list ap) ++{ ++ fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode); ++ vfprintf (stderr, message, ap); ++ fprintf (stderr, ".\n"); ++ ++ if (exit_status >= 0) ++ exit (exit_status); ++} ++ ++void ++lt_fatal (const char *file, int line, const char *message, ...) ++{ ++ va_list ap; ++ va_start (ap, message); ++ lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap); ++ va_end (ap); ++} ++ ++static const char * ++nonnull (const char *s) ++{ ++ return s ? s : "(null)"; ++} ++ ++static const char * ++nonempty (const char *s) ++{ ++ return (s && !*s) ? "(empty)" : nonnull (s); ++} ++ ++void ++lt_setenv (const char *name, const char *value) ++{ ++ lt_debugprintf (__FILE__, __LINE__, ++ "(lt_setenv) setting '%s' to '%s'\n", ++ nonnull (name), nonnull (value)); ++ { ++#ifdef HAVE_SETENV ++ /* always make a copy, for consistency with !HAVE_SETENV */ ++ char *str = xstrdup (value); ++ setenv (name, str, 1); ++#else ++ size_t len = strlen (name) + 1 + strlen (value) + 1; ++ char *str = XMALLOC (char, len); ++ sprintf (str, "%s=%s", name, value); ++ if (putenv (str) != EXIT_SUCCESS) ++ { ++ XFREE (str); ++ } ++#endif ++ } ++} ++ ++char * ++lt_extend_str (const char *orig_value, const char *add, int to_end) ++{ ++ char *new_value; ++ if (orig_value && *orig_value) ++ { ++ size_t orig_value_len = strlen (orig_value); ++ size_t add_len = strlen (add); ++ new_value = XMALLOC (char, add_len + orig_value_len + 1); ++ if (to_end) ++ { ++ strcpy (new_value, orig_value); ++ strcpy (new_value + orig_value_len, add); ++ } ++ else ++ { ++ strcpy (new_value, add); ++ strcpy (new_value + add_len, orig_value); ++ } ++ } ++ else ++ { ++ new_value = xstrdup (add); ++ } ++ return new_value; ++} ++ ++void ++lt_update_exe_path (const char *name, const char *value) ++{ ++ lt_debugprintf (__FILE__, __LINE__, ++ "(lt_update_exe_path) modifying '%s' by prepending '%s'\n", ++ nonnull (name), nonnull (value)); ++ ++ if (name && *name && value && *value) ++ { ++ char *new_value = lt_extend_str (getenv (name), value, 0); ++ /* some systems can't cope with a ':'-terminated path #' */ ++ size_t len = strlen (new_value); ++ while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1])) ++ { ++ new_value[--len] = '\0'; ++ } ++ lt_setenv (name, new_value); ++ XFREE (new_value); ++ } ++} ++ ++void ++lt_update_lib_path (const char *name, const char *value) ++{ ++ lt_debugprintf (__FILE__, __LINE__, ++ "(lt_update_lib_path) modifying '%s' by prepending '%s'\n", ++ nonnull (name), nonnull (value)); ++ ++ if (name && *name && value && *value) ++ { ++ char *new_value = lt_extend_str (getenv (name), value, 0); ++ lt_setenv (name, new_value); ++ XFREE (new_value); ++ } ++} ++ ++EOF ++ case $host_os in ++ mingw*) ++ cat <<"EOF" ++ ++/* Prepares an argument vector before calling spawn(). ++ Note that spawn() does not by itself call the command interpreter ++ (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") : ++ ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); ++ GetVersionEx(&v); ++ v.dwPlatformId == VER_PLATFORM_WIN32_NT; ++ }) ? "cmd.exe" : "command.com"). ++ Instead it simply concatenates the arguments, separated by ' ', and calls ++ CreateProcess(). We must quote the arguments since Win32 CreateProcess() ++ interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a ++ special way: ++ - Space and tab are interpreted as delimiters. They are not treated as ++ delimiters if they are surrounded by double quotes: "...". ++ - Unescaped double quotes are removed from the input. Their only effect is ++ that within double quotes, space and tab are treated like normal ++ characters. ++ - Backslashes not followed by double quotes are not special. ++ - But 2*n+1 backslashes followed by a double quote become ++ n backslashes followed by a double quote (n >= 0): ++ \" -> " ++ \\\" -> \" ++ \\\\\" -> \\" ++ */ ++#define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" ++#define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037" ++char ** ++prepare_spawn (char **argv) ++{ ++ size_t argc; ++ char **new_argv; ++ size_t i; ++ ++ /* Count number of arguments. */ ++ for (argc = 0; argv[argc] != NULL; argc++) ++ ; ++ ++ /* Allocate new argument vector. */ ++ new_argv = XMALLOC (char *, argc + 1); ++ ++ /* Put quoted arguments into the new argument vector. */ ++ for (i = 0; i < argc; i++) ++ { ++ const char *string = argv[i]; ++ ++ if (string[0] == '\0') ++ new_argv[i] = xstrdup ("\"\""); ++ else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL) ++ { ++ int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL); ++ size_t length; ++ unsigned int backslashes; ++ const char *s; ++ char *quoted_string; ++ char *p; ++ ++ length = 0; ++ backslashes = 0; ++ if (quote_around) ++ length++; ++ for (s = string; *s != '\0'; s++) ++ { ++ char c = *s; ++ if (c == '"') ++ length += backslashes + 1; ++ length++; ++ if (c == '\\') ++ backslashes++; ++ else ++ backslashes = 0; ++ } ++ if (quote_around) ++ length += backslashes + 1; ++ ++ quoted_string = XMALLOC (char, length + 1); ++ ++ p = quoted_string; ++ backslashes = 0; ++ if (quote_around) ++ *p++ = '"'; ++ for (s = string; *s != '\0'; s++) ++ { ++ char c = *s; ++ if (c == '"') ++ { ++ unsigned int j; ++ for (j = backslashes + 1; j > 0; j--) ++ *p++ = '\\'; ++ } ++ *p++ = c; ++ if (c == '\\') ++ backslashes++; ++ else ++ backslashes = 0; ++ } ++ if (quote_around) ++ { ++ unsigned int j; ++ for (j = backslashes; j > 0; j--) ++ *p++ = '\\'; ++ *p++ = '"'; ++ } ++ *p = '\0'; ++ ++ new_argv[i] = quoted_string; ++ } ++ else ++ new_argv[i] = (char *) string; ++ } ++ new_argv[argc] = NULL; ++ ++ return new_argv; ++} ++EOF ++ ;; ++ esac ++ ++ cat <<"EOF" ++void lt_dump_script (FILE* f) ++{ ++EOF ++ func_emit_wrapper yes | ++ $SED -n -e ' ++s/^\(.\{79\}\)\(..*\)/\1\ ++\2/ ++h ++s/\([\\"]\)/\\\1/g ++s/$/\\n/ ++s/\([^\n]*\).*/ fputs ("\1", f);/p ++g ++D' ++ cat <<"EOF" ++} ++EOF ++} ++# end: func_emit_cwrapperexe_src ++ ++# func_win32_import_lib_p ARG ++# True if ARG is an import lib, as indicated by $file_magic_cmd ++func_win32_import_lib_p () ++{ ++ $debug_cmd ++ ++ case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in ++ *import*) : ;; ++ *) false ;; ++ esac ++} ++ ++# func_suncc_cstd_abi ++# !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!! ++# Several compiler flags select an ABI that is incompatible with the ++# Cstd library. Avoid specifying it if any are in CXXFLAGS. ++func_suncc_cstd_abi () ++{ ++ $debug_cmd ++ ++ case " $compile_command " in ++ *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*) ++ suncc_use_cstd_abi=no ++ ;; ++ *) ++ suncc_use_cstd_abi=yes ++ ;; ++ esac ++} ++ ++# func_mode_link arg... ++func_mode_link () ++{ ++ $debug_cmd ++ ++ case $host in ++ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) ++ # It is impossible to link a dll without this setting, and ++ # we shouldn't force the makefile maintainer to figure out ++ # what system we are compiling for in order to pass an extra ++ # flag for every libtool invocation. ++ # allow_undefined=no ++ ++ # FIXME: Unfortunately, there are problems with the above when trying ++ # to make a dll that has undefined symbols, in which case not ++ # even a static library is built. For now, we need to specify ++ # -no-undefined on the libtool link line when we can be certain ++ # that all symbols are satisfied, otherwise we get a static library. ++ allow_undefined=yes ++ ;; ++ *) ++ allow_undefined=yes ++ ;; ++ esac ++ libtool_args=$nonopt ++ base_compile="$nonopt $@" ++ compile_command=$nonopt ++ finalize_command=$nonopt ++ ++ compile_rpath= ++ finalize_rpath= ++ compile_shlibpath= ++ finalize_shlibpath= ++ convenience= ++ old_convenience= ++ deplibs= ++ old_deplibs= ++ compiler_flags= ++ linker_flags= ++ dllsearchpath= ++ lib_search_path=`pwd` ++ inst_prefix_dir= ++ new_inherited_linker_flags= ++ ++ avoid_version=no ++ bindir= ++ dlfiles= ++ dlprefiles= ++ dlself=no ++ export_dynamic=no ++ export_symbols= ++ export_symbols_regex= ++ generated= ++ libobjs= ++ ltlibs= ++ module=no ++ no_install=no ++ objs= ++ os2dllname= ++ non_pic_objects= ++ precious_files_regex= ++ prefer_static_libs=no ++ preload=false ++ prev= ++ prevarg= ++ release= ++ rpath= ++ xrpath= ++ perm_rpath= ++ temp_rpath= ++ thread_safe=no ++ vinfo= ++ vinfo_number=no ++ weak_libs= ++ single_module=$wl-single_module ++ func_infer_tag $base_compile ++ ++ # We need to know -static, to get the right output filenames. ++ for arg ++ do ++ case $arg in ++ -shared) ++ test yes != "$build_libtool_libs" \ ++ && func_fatal_configuration "cannot build a shared library" ++ build_old_libs=no ++ break ++ ;; ++ -all-static | -static | -static-libtool-libs) ++ case $arg in ++ -all-static) ++ if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then ++ func_warning "complete static linking is impossible in this configuration" ++ fi ++ if test -n "$link_static_flag"; then ++ dlopen_self=$dlopen_self_static ++ fi ++ prefer_static_libs=yes ++ ;; ++ -static) ++ if test -z "$pic_flag" && test -n "$link_static_flag"; then ++ dlopen_self=$dlopen_self_static ++ fi ++ prefer_static_libs=built ++ ;; ++ -static-libtool-libs) ++ if test -z "$pic_flag" && test -n "$link_static_flag"; then ++ dlopen_self=$dlopen_self_static ++ fi ++ prefer_static_libs=yes ++ ;; ++ esac ++ build_libtool_libs=no ++ build_old_libs=yes ++ break ++ ;; ++ esac ++ done ++ ++ # See if our shared archives depend on static archives. ++ test -n "$old_archive_from_new_cmds" && build_old_libs=yes ++ ++ # Go through the arguments, transforming them on the way. ++ while test "$#" -gt 0; do ++ arg=$1 ++ shift ++ func_quote_for_eval "$arg" ++ qarg=$func_quote_for_eval_unquoted_result ++ func_append libtool_args " $func_quote_for_eval_result" ++ ++ # If the previous option needs an argument, assign it. ++ if test -n "$prev"; then ++ case $prev in ++ output) ++ func_append compile_command " @OUTPUT@" ++ func_append finalize_command " @OUTPUT@" ++ ;; ++ esac ++ ++ case $prev in ++ bindir) ++ bindir=$arg ++ prev= ++ continue ++ ;; ++ dlfiles|dlprefiles) ++ $preload || { ++ # Add the symbol object into the linking commands. ++ func_append compile_command " @SYMFILE@" ++ func_append finalize_command " @SYMFILE@" ++ preload=: ++ } ++ case $arg in ++ *.la | *.lo) ;; # We handle these cases below. ++ force) ++ if test no = "$dlself"; then ++ dlself=needless ++ export_dynamic=yes ++ fi ++ prev= ++ continue ++ ;; ++ self) ++ if test dlprefiles = "$prev"; then ++ dlself=yes ++ elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then ++ dlself=yes ++ else ++ dlself=needless ++ export_dynamic=yes ++ fi ++ prev= ++ continue ++ ;; ++ *) ++ if test dlfiles = "$prev"; then ++ func_append dlfiles " $arg" ++ else ++ func_append dlprefiles " $arg" ++ fi ++ prev= ++ continue ++ ;; ++ esac ++ ;; ++ expsyms) ++ export_symbols=$arg ++ test -f "$arg" \ ++ || func_fatal_error "symbol file '$arg' does not exist" ++ prev= ++ continue ++ ;; ++ expsyms_regex) ++ export_symbols_regex=$arg ++ prev= ++ continue ++ ;; ++ framework) ++ case $host in ++ *-*-darwin*) ++ case "$deplibs " in ++ *" $qarg.ltframework "*) ;; ++ *) func_append deplibs " $qarg.ltframework" # this is fixed later ++ ;; ++ esac ++ ;; ++ esac ++ prev= ++ continue ++ ;; ++ inst_prefix) ++ inst_prefix_dir=$arg ++ prev= ++ continue ++ ;; ++ mllvm) ++ # Clang does not use LLVM to link, so we can simply discard any ++ # '-mllvm $arg' options when doing the link step. ++ prev= ++ continue ++ ;; ++ objectlist) ++ if test -f "$arg"; then ++ save_arg=$arg ++ moreargs= ++ for fil in `cat "$save_arg"` ++ do ++# func_append moreargs " $fil" ++ arg=$fil ++ # A libtool-controlled object. ++ ++ # Check to see that this really is a libtool object. ++ if func_lalib_unsafe_p "$arg"; then ++ pic_object= ++ non_pic_object= ++ ++ # Read the .lo file ++ func_source "$arg" ++ ++ if test -z "$pic_object" || ++ test -z "$non_pic_object" || ++ test none = "$pic_object" && ++ test none = "$non_pic_object"; then ++ func_fatal_error "cannot find name of object for '$arg'" ++ fi ++ ++ # Extract subdirectory from the argument. ++ func_dirname "$arg" "/" "" ++ xdir=$func_dirname_result ++ ++ if test none != "$pic_object"; then ++ # Prepend the subdirectory the object is found in. ++ pic_object=$xdir$pic_object ++ ++ if test dlfiles = "$prev"; then ++ if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then ++ func_append dlfiles " $pic_object" ++ prev= ++ continue ++ else ++ # If libtool objects are unsupported, then we need to preload. ++ prev=dlprefiles ++ fi ++ fi ++ ++ # CHECK ME: I think I busted this. -Ossama ++ if test dlprefiles = "$prev"; then ++ # Preload the old-style object. ++ func_append dlprefiles " $pic_object" ++ prev= ++ fi ++ ++ # A PIC object. ++ func_append libobjs " $pic_object" ++ arg=$pic_object ++ fi ++ ++ # Non-PIC object. ++ if test none != "$non_pic_object"; then ++ # Prepend the subdirectory the object is found in. ++ non_pic_object=$xdir$non_pic_object ++ ++ # A standard non-PIC object ++ func_append non_pic_objects " $non_pic_object" ++ if test -z "$pic_object" || test none = "$pic_object"; then ++ arg=$non_pic_object ++ fi ++ else ++ # If the PIC object exists, use it instead. ++ # $xdir was prepended to $pic_object above. ++ non_pic_object=$pic_object ++ func_append non_pic_objects " $non_pic_object" ++ fi ++ else ++ # Only an error if not doing a dry-run. ++ if $opt_dry_run; then ++ # Extract subdirectory from the argument. ++ func_dirname "$arg" "/" "" ++ xdir=$func_dirname_result ++ ++ func_lo2o "$arg" ++ pic_object=$xdir$objdir/$func_lo2o_result ++ non_pic_object=$xdir$func_lo2o_result ++ func_append libobjs " $pic_object" ++ func_append non_pic_objects " $non_pic_object" ++ else ++ func_fatal_error "'$arg' is not a valid libtool object" ++ fi ++ fi ++ done ++ else ++ func_fatal_error "link input file '$arg' does not exist" ++ fi ++ arg=$save_arg ++ prev= ++ continue ++ ;; ++ os2dllname) ++ os2dllname=$arg ++ prev= ++ continue ++ ;; ++ precious_regex) ++ precious_files_regex=$arg ++ prev= ++ continue ++ ;; ++ release) ++ release=-$arg ++ prev= ++ continue ++ ;; ++ rpath | xrpath) ++ # We need an absolute path. ++ case $arg in ++ [\\/]* | [A-Za-z]:[\\/]*) ;; ++ *) ++ func_fatal_error "only absolute run-paths are allowed" ++ ;; ++ esac ++ if test rpath = "$prev"; then ++ case "$rpath " in ++ *" $arg "*) ;; ++ *) func_append rpath " $arg" ;; ++ esac ++ else ++ case "$xrpath " in ++ *" $arg "*) ;; ++ *) func_append xrpath " $arg" ;; ++ esac ++ fi ++ prev= ++ continue ++ ;; ++ shrext) ++ shrext_cmds=$arg ++ prev= ++ continue ++ ;; ++ weak) ++ func_append weak_libs " $arg" ++ prev= ++ continue ++ ;; ++ xcclinker) ++ func_append linker_flags " $qarg" ++ func_append compiler_flags " $qarg" ++ prev= ++ func_append compile_command " $qarg" ++ func_append finalize_command " $qarg" ++ continue ++ ;; ++ xcompiler) ++ func_append compiler_flags " $qarg" ++ prev= ++ func_append compile_command " $qarg" ++ func_append finalize_command " $qarg" ++ continue ++ ;; ++ xlinker) ++ func_append linker_flags " $qarg" ++ func_append compiler_flags " $wl$qarg" ++ prev= ++ func_append compile_command " $wl$qarg" ++ func_append finalize_command " $wl$qarg" ++ continue ++ ;; ++ *) ++ eval "$prev=\"\$arg\"" ++ prev= ++ continue ++ ;; ++ esac ++ fi # test -n "$prev" ++ ++ prevarg=$arg ++ ++ case $arg in ++ -all-static) ++ if test -n "$link_static_flag"; then ++ # See comment for -static flag below, for more details. ++ func_append compile_command " $link_static_flag" ++ func_append finalize_command " $link_static_flag" ++ fi ++ continue ++ ;; ++ ++ -allow-undefined) ++ # FIXME: remove this flag sometime in the future. ++ func_fatal_error "'-allow-undefined' must not be used because it is the default" ++ ;; ++ ++ -avoid-version) ++ avoid_version=yes ++ continue ++ ;; ++ ++ -bindir) ++ prev=bindir ++ continue ++ ;; ++ ++ -dlopen) ++ prev=dlfiles ++ continue ++ ;; ++ ++ -dlpreopen) ++ prev=dlprefiles ++ continue ++ ;; ++ ++ -export-dynamic) ++ export_dynamic=yes ++ continue ++ ;; ++ ++ -export-symbols | -export-symbols-regex) ++ if test -n "$export_symbols" || test -n "$export_symbols_regex"; then ++ func_fatal_error "more than one -exported-symbols argument is not allowed" ++ fi ++ if test X-export-symbols = "X$arg"; then ++ prev=expsyms ++ else ++ prev=expsyms_regex ++ fi ++ continue ++ ;; ++ ++ -framework) ++ prev=framework ++ continue ++ ;; ++ ++ -inst-prefix-dir) ++ prev=inst_prefix ++ continue ++ ;; ++ ++ # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:* ++ # so, if we see these flags be careful not to treat them like -L ++ -L[A-Z][A-Z]*:*) ++ case $with_gcc/$host in ++ no/*-*-irix* | /*-*-irix*) ++ func_append compile_command " $arg" ++ func_append finalize_command " $arg" ++ ;; ++ esac ++ continue ++ ;; ++ ++ -L*) ++ func_stripname "-L" '' "$arg" ++ if test -z "$func_stripname_result"; then ++ if test "$#" -gt 0; then ++ func_fatal_error "require no space between '-L' and '$1'" ++ else ++ func_fatal_error "need path for '-L' option" ++ fi ++ fi ++ func_resolve_sysroot "$func_stripname_result" ++ dir=$func_resolve_sysroot_result ++ # We need an absolute path. ++ case $dir in ++ [\\/]* | [A-Za-z]:[\\/]*) ;; ++ *) ++ absdir=`cd "$dir" && pwd` ++ test -z "$absdir" && \ ++ func_fatal_error "cannot determine absolute directory name of '$dir'" ++ dir=$absdir ++ ;; ++ esac ++ case "$deplibs " in ++ *" -L$dir "* | *" $arg "*) ++ # Will only happen for absolute or sysroot arguments ++ ;; ++ *) ++ # Preserve sysroot, but never include relative directories ++ case $dir in ++ [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;; ++ *) func_append deplibs " -L$dir" ;; ++ esac ++ func_append lib_search_path " $dir" ++ ;; ++ esac ++ case $host in ++ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) ++ testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'` ++ case :$dllsearchpath: in ++ *":$dir:"*) ;; ++ ::) dllsearchpath=$dir;; ++ *) func_append dllsearchpath ":$dir";; ++ esac ++ case :$dllsearchpath: in ++ *":$testbindir:"*) ;; ++ ::) dllsearchpath=$testbindir;; ++ *) func_append dllsearchpath ":$testbindir";; ++ esac ++ ;; ++ esac ++ continue ++ ;; ++ ++ -l*) ++ if test X-lc = "X$arg" || test X-lm = "X$arg"; then ++ case $host in ++ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*) ++ # These systems don't actually have a C or math library (as such) ++ continue ++ ;; ++ *-*-os2*) ++ # These systems don't actually have a C library (as such) ++ test X-lc = "X$arg" && continue ++ ;; ++ *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*) ++ # Do not include libc due to us having libc/libc_r. ++ test X-lc = "X$arg" && continue ++ ;; ++ *-*-rhapsody* | *-*-darwin1.[012]) ++ # Rhapsody C and math libraries are in the System framework ++ func_append deplibs " System.ltframework" ++ continue ++ ;; ++ *-*-sco3.2v5* | *-*-sco5v6*) ++ # Causes problems with __ctype ++ test X-lc = "X$arg" && continue ++ ;; ++ *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) ++ # Compiler inserts libc in the correct place for threads to work ++ test X-lc = "X$arg" && continue ++ ;; ++ esac ++ elif test X-lc_r = "X$arg"; then ++ case $host in ++ *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*) ++ # Do not include libc_r directly, use -pthread flag. ++ continue ++ ;; ++ esac ++ fi ++ func_append deplibs " $arg" ++ continue ++ ;; ++ ++ -mllvm) ++ prev=mllvm ++ continue ++ ;; ++ ++ -module) ++ module=yes ++ continue ++ ;; ++ ++ # Tru64 UNIX uses -model [arg] to determine the layout of C++ ++ # classes, name mangling, and exception handling. ++ # Darwin uses the -arch flag to determine output architecture. ++ -model|-arch|-isysroot|--sysroot) ++ func_append compiler_flags " $arg" ++ func_append compile_command " $arg" ++ func_append finalize_command " $arg" ++ prev=xcompiler ++ continue ++ ;; ++ ++ -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ ++ |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) ++ func_append compiler_flags " $arg" ++ func_append compile_command " $arg" ++ func_append finalize_command " $arg" ++ case "$new_inherited_linker_flags " in ++ *" $arg "*) ;; ++ * ) func_append new_inherited_linker_flags " $arg" ;; ++ esac ++ continue ++ ;; ++ ++ -multi_module) ++ single_module=$wl-multi_module ++ continue ++ ;; ++ ++ -no-fast-install) ++ fast_install=no ++ continue ++ ;; ++ ++ -no-install) ++ case $host in ++ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*) ++ # The PATH hackery in wrapper scripts is required on Windows ++ # and Darwin in order for the loader to find any dlls it needs. ++ func_warning "'-no-install' is ignored for $host" ++ func_warning "assuming '-no-fast-install' instead" ++ fast_install=no ++ ;; ++ *) no_install=yes ;; ++ esac ++ continue ++ ;; ++ ++ -no-undefined) ++ allow_undefined=no ++ continue ++ ;; ++ ++ -objectlist) ++ prev=objectlist ++ continue ++ ;; ++ ++ -os2dllname) ++ prev=os2dllname ++ continue ++ ;; ++ ++ -o) prev=output ;; ++ ++ -precious-files-regex) ++ prev=precious_regex ++ continue ++ ;; ++ ++ -release) ++ prev=release ++ continue ++ ;; ++ ++ -rpath) ++ prev=rpath ++ continue ++ ;; ++ ++ -R) ++ prev=xrpath ++ continue ++ ;; ++ ++ -R*) ++ func_stripname '-R' '' "$arg" ++ dir=$func_stripname_result ++ # We need an absolute path. ++ case $dir in ++ [\\/]* | [A-Za-z]:[\\/]*) ;; ++ =*) ++ func_stripname '=' '' "$dir" ++ dir=$lt_sysroot$func_stripname_result ++ ;; ++ *) ++ func_fatal_error "only absolute run-paths are allowed" ++ ;; ++ esac ++ case "$xrpath " in ++ *" $dir "*) ;; ++ *) func_append xrpath " $dir" ;; ++ esac ++ continue ++ ;; ++ ++ -shared) ++ # The effects of -shared are defined in a previous loop. ++ continue ++ ;; ++ ++ -shrext) ++ prev=shrext ++ continue ++ ;; ++ ++ -static | -static-libtool-libs) ++ # The effects of -static are defined in a previous loop. ++ # We used to do the same as -all-static on platforms that ++ # didn't have a PIC flag, but the assumption that the effects ++ # would be equivalent was wrong. It would break on at least ++ # Digital Unix and AIX. ++ continue ++ ;; ++ ++ -thread-safe) ++ thread_safe=yes ++ continue ++ ;; ++ ++ -version-info) ++ prev=vinfo ++ continue ++ ;; ++ ++ -version-number) ++ prev=vinfo ++ vinfo_number=yes ++ continue ++ ;; ++ ++ -weak) ++ prev=weak ++ continue ++ ;; ++ ++ -Wc,*) ++ func_stripname '-Wc,' '' "$arg" ++ args=$func_stripname_result ++ arg= ++ save_ifs=$IFS; IFS=, ++ for flag in $args; do ++ IFS=$save_ifs ++ func_quote_for_eval "$flag" ++ func_append arg " $func_quote_for_eval_result" ++ func_append compiler_flags " $func_quote_for_eval_result" ++ done ++ IFS=$save_ifs ++ func_stripname ' ' '' "$arg" ++ arg=$func_stripname_result ++ ;; ++ ++ -Wl,*) ++ func_stripname '-Wl,' '' "$arg" ++ args=$func_stripname_result ++ arg= ++ save_ifs=$IFS; IFS=, ++ for flag in $args; do ++ IFS=$save_ifs ++ func_quote_for_eval "$flag" ++ func_append arg " $wl$func_quote_for_eval_result" ++ func_append compiler_flags " $wl$func_quote_for_eval_result" ++ func_append linker_flags " $func_quote_for_eval_result" ++ done ++ IFS=$save_ifs ++ func_stripname ' ' '' "$arg" ++ arg=$func_stripname_result ++ ;; ++ ++ -Xcompiler) ++ prev=xcompiler ++ continue ++ ;; ++ ++ -Xlinker) ++ prev=xlinker ++ continue ++ ;; ++ ++ -XCClinker) ++ prev=xcclinker ++ continue ++ ;; ++ ++ # -msg_* for osf cc ++ -msg_*) ++ func_quote_for_eval "$arg" ++ arg=$func_quote_for_eval_result ++ ;; ++ ++ # Flags to be passed through unchanged, with rationale: ++ # -64, -mips[0-9] enable 64-bit mode for the SGI compiler ++ # -r[0-9][0-9]* specify processor for the SGI compiler ++ # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler ++ # +DA*, +DD* enable 64-bit mode for the HP compiler ++ # -q* compiler args for the IBM compiler ++ # -m*, -t[45]*, -txscale* architecture-specific flags for GCC ++ # -F/path path to uninstalled frameworks, gcc on darwin ++ # -p, -pg, --coverage, -fprofile-* profiling flags for GCC ++ # -fstack-protector* stack protector flags for GCC ++ # @file GCC response files ++ # -tp=* Portland pgcc target processor selection ++ # --sysroot=* for sysroot support ++ # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization ++ # -specs=* GCC specs files ++ # -stdlib=* select c++ std lib with clang ++ # -fsanitize=* Clang/GCC memory and address sanitizer ++ -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \ ++ -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \ ++ -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*| \ ++ -specs=*|-fsanitize=*) ++ func_quote_for_eval "$arg" ++ arg=$func_quote_for_eval_result ++ func_append compile_command " $arg" ++ func_append finalize_command " $arg" ++ func_append compiler_flags " $arg" ++ continue ++ ;; ++ ++ -Z*) ++ if test os2 = "`expr $host : '.*\(os2\)'`"; then ++ # OS/2 uses -Zxxx to specify OS/2-specific options ++ compiler_flags="$compiler_flags $arg" ++ func_append compile_command " $arg" ++ func_append finalize_command " $arg" ++ case $arg in ++ -Zlinker | -Zstack) ++ prev=xcompiler ++ ;; ++ esac ++ continue ++ else ++ # Otherwise treat like 'Some other compiler flag' below ++ func_quote_for_eval "$arg" ++ arg=$func_quote_for_eval_result ++ fi ++ ;; ++ ++ # Some other compiler flag. ++ -* | +*) ++ func_quote_for_eval "$arg" ++ arg=$func_quote_for_eval_result ++ ;; ++ ++ *.$objext) ++ # A standard object. ++ func_append objs " $arg" ++ ;; ++ ++ *.lo) ++ # A libtool-controlled object. ++ ++ # Check to see that this really is a libtool object. ++ if func_lalib_unsafe_p "$arg"; then ++ pic_object= ++ non_pic_object= ++ ++ # Read the .lo file ++ func_source "$arg" ++ ++ if test -z "$pic_object" || ++ test -z "$non_pic_object" || ++ test none = "$pic_object" && ++ test none = "$non_pic_object"; then ++ func_fatal_error "cannot find name of object for '$arg'" ++ fi ++ ++ # Extract subdirectory from the argument. ++ func_dirname "$arg" "/" "" ++ xdir=$func_dirname_result ++ ++ test none = "$pic_object" || { ++ # Prepend the subdirectory the object is found in. ++ pic_object=$xdir$pic_object ++ ++ if test dlfiles = "$prev"; then ++ if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then ++ func_append dlfiles " $pic_object" ++ prev= ++ continue ++ else ++ # If libtool objects are unsupported, then we need to preload. ++ prev=dlprefiles ++ fi ++ fi ++ ++ # CHECK ME: I think I busted this. -Ossama ++ if test dlprefiles = "$prev"; then ++ # Preload the old-style object. ++ func_append dlprefiles " $pic_object" ++ prev= ++ fi ++ ++ # A PIC object. ++ func_append libobjs " $pic_object" ++ arg=$pic_object ++ } ++ ++ # Non-PIC object. ++ if test none != "$non_pic_object"; then ++ # Prepend the subdirectory the object is found in. ++ non_pic_object=$xdir$non_pic_object ++ ++ # A standard non-PIC object ++ func_append non_pic_objects " $non_pic_object" ++ if test -z "$pic_object" || test none = "$pic_object"; then ++ arg=$non_pic_object ++ fi ++ else ++ # If the PIC object exists, use it instead. ++ # $xdir was prepended to $pic_object above. ++ non_pic_object=$pic_object ++ func_append non_pic_objects " $non_pic_object" ++ fi ++ else ++ # Only an error if not doing a dry-run. ++ if $opt_dry_run; then ++ # Extract subdirectory from the argument. ++ func_dirname "$arg" "/" "" ++ xdir=$func_dirname_result ++ ++ func_lo2o "$arg" ++ pic_object=$xdir$objdir/$func_lo2o_result ++ non_pic_object=$xdir$func_lo2o_result ++ func_append libobjs " $pic_object" ++ func_append non_pic_objects " $non_pic_object" ++ else ++ func_fatal_error "'$arg' is not a valid libtool object" ++ fi ++ fi ++ ;; ++ ++ *.$libext) ++ # An archive. ++ func_append deplibs " $arg" ++ func_append old_deplibs " $arg" ++ continue ++ ;; ++ ++ *.la) ++ # A libtool-controlled library. ++ ++ func_resolve_sysroot "$arg" ++ if test dlfiles = "$prev"; then ++ # This library was specified with -dlopen. ++ func_append dlfiles " $func_resolve_sysroot_result" ++ prev= ++ elif test dlprefiles = "$prev"; then ++ # The library was specified with -dlpreopen. ++ func_append dlprefiles " $func_resolve_sysroot_result" ++ prev= ++ else ++ func_append deplibs " $func_resolve_sysroot_result" ++ fi ++ continue ++ ;; ++ ++ # Some other compiler argument. ++ *) ++ # Unknown arguments in both finalize_command and compile_command need ++ # to be aesthetically quoted because they are evaled later. ++ func_quote_for_eval "$arg" ++ arg=$func_quote_for_eval_result ++ ;; ++ esac # arg ++ ++ # Now actually substitute the argument into the commands. ++ if test -n "$arg"; then ++ func_append compile_command " $arg" ++ func_append finalize_command " $arg" ++ fi ++ done # argument parsing loop ++ ++ test -n "$prev" && \ ++ func_fatal_help "the '$prevarg' option requires an argument" ++ ++ if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then ++ eval arg=\"$export_dynamic_flag_spec\" ++ func_append compile_command " $arg" ++ func_append finalize_command " $arg" ++ fi ++ ++ oldlibs= ++ # calculate the name of the file, without its directory ++ func_basename "$output" ++ outputname=$func_basename_result ++ libobjs_save=$libobjs ++ ++ if test -n "$shlibpath_var"; then ++ # get the directories listed in $shlibpath_var ++ eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\` ++ else ++ shlib_search_path= ++ fi ++ eval sys_lib_search_path=\"$sys_lib_search_path_spec\" ++ eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\" ++ ++ # Definition is injected by LT_CONFIG during libtool generation. ++ func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH" ++ ++ func_dirname "$output" "/" "" ++ output_objdir=$func_dirname_result$objdir ++ func_to_tool_file "$output_objdir/" ++ tool_output_objdir=$func_to_tool_file_result ++ # Create the object directory. ++ func_mkdir_p "$output_objdir" ++ ++ # Determine the type of output ++ case $output in ++ "") ++ func_fatal_help "you must specify an output file" ++ ;; ++ *.$libext) linkmode=oldlib ;; ++ *.lo | *.$objext) linkmode=obj ;; ++ *.la) linkmode=lib ;; ++ *) linkmode=prog ;; # Anything else should be a program. ++ esac ++ ++ specialdeplibs= ++ ++ libs= ++ # Find all interdependent deplibs by searching for libraries ++ # that are linked more than once (e.g. -la -lb -la) ++ for deplib in $deplibs; do ++ if $opt_preserve_dup_deps; then ++ case "$libs " in ++ *" $deplib "*) func_append specialdeplibs " $deplib" ;; ++ esac ++ fi ++ func_append libs " $deplib" ++ done ++ ++ if test lib = "$linkmode"; then ++ libs="$predeps $libs $compiler_lib_search_path $postdeps" ++ ++ # Compute libraries that are listed more than once in $predeps ++ # $postdeps and mark them as special (i.e., whose duplicates are ++ # not to be eliminated). ++ pre_post_deps= ++ if $opt_duplicate_compiler_generated_deps; then ++ for pre_post_dep in $predeps $postdeps; do ++ case "$pre_post_deps " in ++ *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;; ++ esac ++ func_append pre_post_deps " $pre_post_dep" ++ done ++ fi ++ pre_post_deps= ++ fi ++ ++ deplibs= ++ newdependency_libs= ++ newlib_search_path= ++ need_relink=no # whether we're linking any uninstalled libtool libraries ++ notinst_deplibs= # not-installed libtool libraries ++ notinst_path= # paths that contain not-installed libtool libraries ++ ++ case $linkmode in ++ lib) ++ passes="conv dlpreopen link" ++ for file in $dlfiles $dlprefiles; do ++ case $file in ++ *.la) ;; ++ *) ++ func_fatal_help "libraries can '-dlopen' only libtool libraries: $file" ++ ;; ++ esac ++ done ++ ;; ++ prog) ++ compile_deplibs= ++ finalize_deplibs= ++ alldeplibs=false ++ newdlfiles= ++ newdlprefiles= ++ passes="conv scan dlopen dlpreopen link" ++ ;; ++ *) passes="conv" ++ ;; ++ esac ++ ++ for pass in $passes; do ++ # The preopen pass in lib mode reverses $deplibs; put it back here ++ # so that -L comes before libs that need it for instance... ++ if test lib,link = "$linkmode,$pass"; then ++ ## FIXME: Find the place where the list is rebuilt in the wrong ++ ## order, and fix it there properly ++ tmp_deplibs= ++ for deplib in $deplibs; do ++ tmp_deplibs="$deplib $tmp_deplibs" ++ done ++ deplibs=$tmp_deplibs ++ fi ++ ++ if test lib,link = "$linkmode,$pass" || ++ test prog,scan = "$linkmode,$pass"; then ++ libs=$deplibs ++ deplibs= ++ fi ++ if test prog = "$linkmode"; then ++ case $pass in ++ dlopen) libs=$dlfiles ;; ++ dlpreopen) libs=$dlprefiles ;; ++ link) ++ libs="$deplibs %DEPLIBS%" ++ test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs" ++ ;; ++ esac ++ fi ++ if test lib,dlpreopen = "$linkmode,$pass"; then ++ # Collect and forward deplibs of preopened libtool libs ++ for lib in $dlprefiles; do ++ # Ignore non-libtool-libs ++ dependency_libs= ++ func_resolve_sysroot "$lib" ++ case $lib in ++ *.la) func_source "$func_resolve_sysroot_result" ;; ++ esac ++ ++ # Collect preopened libtool deplibs, except any this library ++ # has declared as weak libs ++ for deplib in $dependency_libs; do ++ func_basename "$deplib" ++ deplib_base=$func_basename_result ++ case " $weak_libs " in ++ *" $deplib_base "*) ;; ++ *) func_append deplibs " $deplib" ;; ++ esac ++ done ++ done ++ libs=$dlprefiles ++ fi ++ if test dlopen = "$pass"; then ++ # Collect dlpreopened libraries ++ save_deplibs=$deplibs ++ deplibs= ++ fi ++ ++ for deplib in $libs; do ++ lib= ++ found=false ++ case $deplib in ++ -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \ ++ |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*) ++ if test prog,link = "$linkmode,$pass"; then ++ compile_deplibs="$deplib $compile_deplibs" ++ finalize_deplibs="$deplib $finalize_deplibs" ++ else ++ func_append compiler_flags " $deplib" ++ if test lib = "$linkmode"; then ++ case "$new_inherited_linker_flags " in ++ *" $deplib "*) ;; ++ * ) func_append new_inherited_linker_flags " $deplib" ;; ++ esac ++ fi ++ fi ++ continue ++ ;; ++ -l*) ++ if test lib != "$linkmode" && test prog != "$linkmode"; then ++ func_warning "'-l' is ignored for archives/objects" ++ continue ++ fi ++ func_stripname '-l' '' "$deplib" ++ name=$func_stripname_result ++ if test lib = "$linkmode"; then ++ searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path" ++ else ++ searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path" ++ fi ++ for searchdir in $searchdirs; do ++ for search_ext in .la $std_shrext .so .a; do ++ # Search the libtool library ++ lib=$searchdir/lib$name$search_ext ++ if test -f "$lib"; then ++ if test .la = "$search_ext"; then ++ found=: ++ else ++ found=false ++ fi ++ break 2 ++ fi ++ done ++ done ++ if $found; then ++ # deplib is a libtool library ++ # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib, ++ # We need to do some special things here, and not later. ++ if test yes = "$allow_libtool_libs_with_static_runtimes"; then ++ case " $predeps $postdeps " in ++ *" $deplib "*) ++ if func_lalib_p "$lib"; then ++ library_names= ++ old_library= ++ func_source "$lib" ++ for l in $old_library $library_names; do ++ ll=$l ++ done ++ if test "X$ll" = "X$old_library"; then # only static version available ++ found=false ++ func_dirname "$lib" "" "." ++ ladir=$func_dirname_result ++ lib=$ladir/$old_library ++ if test prog,link = "$linkmode,$pass"; then ++ compile_deplibs="$deplib $compile_deplibs" ++ finalize_deplibs="$deplib $finalize_deplibs" ++ else ++ deplibs="$deplib $deplibs" ++ test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs" ++ fi ++ continue ++ fi ++ fi ++ ;; ++ *) ;; ++ esac ++ fi ++ else ++ # deplib doesn't seem to be a libtool library ++ if test prog,link = "$linkmode,$pass"; then ++ compile_deplibs="$deplib $compile_deplibs" ++ finalize_deplibs="$deplib $finalize_deplibs" ++ else ++ deplibs="$deplib $deplibs" ++ test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs" ++ fi ++ continue ++ fi ++ ;; # -l ++ *.ltframework) ++ if test prog,link = "$linkmode,$pass"; then ++ compile_deplibs="$deplib $compile_deplibs" ++ finalize_deplibs="$deplib $finalize_deplibs" ++ else ++ deplibs="$deplib $deplibs" ++ if test lib = "$linkmode"; then ++ case "$new_inherited_linker_flags " in ++ *" $deplib "*) ;; ++ * ) func_append new_inherited_linker_flags " $deplib" ;; ++ esac ++ fi ++ fi ++ continue ++ ;; ++ -L*) ++ case $linkmode in ++ lib) ++ deplibs="$deplib $deplibs" ++ test conv = "$pass" && continue ++ newdependency_libs="$deplib $newdependency_libs" ++ func_stripname '-L' '' "$deplib" ++ func_resolve_sysroot "$func_stripname_result" ++ func_append newlib_search_path " $func_resolve_sysroot_result" ++ ;; ++ prog) ++ if test conv = "$pass"; then ++ deplibs="$deplib $deplibs" ++ continue ++ fi ++ if test scan = "$pass"; then ++ deplibs="$deplib $deplibs" ++ else ++ compile_deplibs="$deplib $compile_deplibs" ++ finalize_deplibs="$deplib $finalize_deplibs" ++ fi ++ func_stripname '-L' '' "$deplib" ++ func_resolve_sysroot "$func_stripname_result" ++ func_append newlib_search_path " $func_resolve_sysroot_result" ++ ;; ++ *) ++ func_warning "'-L' is ignored for archives/objects" ++ ;; ++ esac # linkmode ++ continue ++ ;; # -L ++ -R*) ++ if test link = "$pass"; then ++ func_stripname '-R' '' "$deplib" ++ func_resolve_sysroot "$func_stripname_result" ++ dir=$func_resolve_sysroot_result ++ # Make sure the xrpath contains only unique directories. ++ case "$xrpath " in ++ *" $dir "*) ;; ++ *) func_append xrpath " $dir" ;; ++ esac ++ fi ++ deplibs="$deplib $deplibs" ++ continue ++ ;; ++ *.la) ++ func_resolve_sysroot "$deplib" ++ lib=$func_resolve_sysroot_result ++ ;; ++ *.$libext) ++ if test conv = "$pass"; then ++ deplibs="$deplib $deplibs" ++ continue ++ fi ++ case $linkmode in ++ lib) ++ # Linking convenience modules into shared libraries is allowed, ++ # but linking other static libraries is non-portable. ++ case " $dlpreconveniencelibs " in ++ *" $deplib "*) ;; ++ *) ++ valid_a_lib=false ++ case $deplibs_check_method in ++ match_pattern*) ++ set dummy $deplibs_check_method; shift ++ match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` ++ if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \ ++ | $EGREP "$match_pattern_regex" > /dev/null; then ++ valid_a_lib=: ++ fi ++ ;; ++ pass_all) ++ valid_a_lib=: ++ ;; ++ esac ++ if $valid_a_lib; then ++ echo ++ $ECHO "*** Warning: Linking the shared library $output against the" ++ $ECHO "*** static library $deplib is not portable!" ++ deplibs="$deplib $deplibs" ++ else ++ echo ++ $ECHO "*** Warning: Trying to link with static lib archive $deplib." ++ echo "*** I have the capability to make that library automatically link in when" ++ echo "*** you link to this library. But I can only do this if you have a" ++ echo "*** shared version of the library, which you do not appear to have" ++ echo "*** because the file extensions .$libext of this argument makes me believe" ++ echo "*** that it is just a static archive that I should not use here." ++ fi ++ ;; ++ esac ++ continue ++ ;; ++ prog) ++ if test link != "$pass"; then ++ deplibs="$deplib $deplibs" ++ else ++ compile_deplibs="$deplib $compile_deplibs" ++ finalize_deplibs="$deplib $finalize_deplibs" ++ fi ++ continue ++ ;; ++ esac # linkmode ++ ;; # *.$libext ++ *.lo | *.$objext) ++ if test conv = "$pass"; then ++ deplibs="$deplib $deplibs" ++ elif test prog = "$linkmode"; then ++ if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then ++ # If there is no dlopen support or we're linking statically, ++ # we need to preload. ++ func_append newdlprefiles " $deplib" ++ compile_deplibs="$deplib $compile_deplibs" ++ finalize_deplibs="$deplib $finalize_deplibs" ++ else ++ func_append newdlfiles " $deplib" ++ fi ++ fi ++ continue ++ ;; ++ %DEPLIBS%) ++ alldeplibs=: ++ continue ++ ;; ++ esac # case $deplib ++ ++ $found || test -f "$lib" \ ++ || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'" ++ ++ # Check to see that this really is a libtool archive. ++ func_lalib_unsafe_p "$lib" \ ++ || func_fatal_error "'$lib' is not a valid libtool archive" ++ ++ func_dirname "$lib" "" "." ++ ladir=$func_dirname_result ++ ++ dlname= ++ dlopen= ++ dlpreopen= ++ libdir= ++ library_names= ++ old_library= ++ inherited_linker_flags= ++ # If the library was installed with an old release of libtool, ++ # it will not redefine variables installed, or shouldnotlink ++ installed=yes ++ shouldnotlink=no ++ avoidtemprpath= ++ ++ ++ # Read the .la file ++ func_source "$lib" ++ ++ # Convert "-framework foo" to "foo.ltframework" ++ if test -n "$inherited_linker_flags"; then ++ tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'` ++ for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do ++ case " $new_inherited_linker_flags " in ++ *" $tmp_inherited_linker_flag "*) ;; ++ *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";; ++ esac ++ done ++ fi ++ dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` ++ if test lib,link = "$linkmode,$pass" || ++ test prog,scan = "$linkmode,$pass" || ++ { test prog != "$linkmode" && test lib != "$linkmode"; }; then ++ test -n "$dlopen" && func_append dlfiles " $dlopen" ++ test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen" ++ fi ++ ++ if test conv = "$pass"; then ++ # Only check for convenience libraries ++ deplibs="$lib $deplibs" ++ if test -z "$libdir"; then ++ if test -z "$old_library"; then ++ func_fatal_error "cannot find name of link library for '$lib'" ++ fi ++ # It is a libtool convenience library, so add in its objects. ++ func_append convenience " $ladir/$objdir/$old_library" ++ func_append old_convenience " $ladir/$objdir/$old_library" ++ tmp_libs= ++ for deplib in $dependency_libs; do ++ deplibs="$deplib $deplibs" ++ if $opt_preserve_dup_deps; then ++ case "$tmp_libs " in ++ *" $deplib "*) func_append specialdeplibs " $deplib" ;; ++ esac ++ fi ++ func_append tmp_libs " $deplib" ++ done ++ elif test prog != "$linkmode" && test lib != "$linkmode"; then ++ func_fatal_error "'$lib' is not a convenience library" ++ fi ++ continue ++ fi # $pass = conv ++ ++ ++ # Get the name of the library we link against. ++ linklib= ++ if test -n "$old_library" && ++ { test yes = "$prefer_static_libs" || ++ test built,no = "$prefer_static_libs,$installed"; }; then ++ linklib=$old_library ++ else ++ for l in $old_library $library_names; do ++ linklib=$l ++ done ++ fi ++ if test -z "$linklib"; then ++ func_fatal_error "cannot find name of link library for '$lib'" ++ fi ++ ++ # This library was specified with -dlopen. ++ if test dlopen = "$pass"; then ++ test -z "$libdir" \ ++ && func_fatal_error "cannot -dlopen a convenience library: '$lib'" ++ if test -z "$dlname" || ++ test yes != "$dlopen_support" || ++ test no = "$build_libtool_libs" ++ then ++ # If there is no dlname, no dlopen support or we're linking ++ # statically, we need to preload. We also need to preload any ++ # dependent libraries so libltdl's deplib preloader doesn't ++ # bomb out in the load deplibs phase. ++ func_append dlprefiles " $lib $dependency_libs" ++ else ++ func_append newdlfiles " $lib" ++ fi ++ continue ++ fi # $pass = dlopen ++ ++ # We need an absolute path. ++ case $ladir in ++ [\\/]* | [A-Za-z]:[\\/]*) abs_ladir=$ladir ;; ++ *) ++ abs_ladir=`cd "$ladir" && pwd` ++ if test -z "$abs_ladir"; then ++ func_warning "cannot determine absolute directory name of '$ladir'" ++ func_warning "passing it literally to the linker, although it might fail" ++ abs_ladir=$ladir ++ fi ++ ;; ++ esac ++ func_basename "$lib" ++ laname=$func_basename_result ++ ++ # Find the relevant object directory and library name. ++ if test yes = "$installed"; then ++ if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then ++ func_warning "library '$lib' was moved." ++ dir=$ladir ++ absdir=$abs_ladir ++ libdir=$abs_ladir ++ else ++ dir=$lt_sysroot$libdir ++ absdir=$lt_sysroot$libdir ++ fi ++ test yes = "$hardcode_automatic" && avoidtemprpath=yes ++ else ++ if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then ++ dir=$ladir ++ absdir=$abs_ladir ++ # Remove this search path later ++ func_append notinst_path " $abs_ladir" ++ else ++ dir=$ladir/$objdir ++ absdir=$abs_ladir/$objdir ++ # Remove this search path later ++ func_append notinst_path " $abs_ladir" ++ fi ++ fi # $installed = yes ++ func_stripname 'lib' '.la' "$laname" ++ name=$func_stripname_result ++ ++ # This library was specified with -dlpreopen. ++ if test dlpreopen = "$pass"; then ++ if test -z "$libdir" && test prog = "$linkmode"; then ++ func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'" ++ fi ++ case $host in ++ # special handling for platforms with PE-DLLs. ++ *cygwin* | *mingw* | *cegcc* ) ++ # Linker will automatically link against shared library if both ++ # static and shared are present. Therefore, ensure we extract ++ # symbols from the import library if a shared library is present ++ # (otherwise, the dlopen module name will be incorrect). We do ++ # this by putting the import library name into $newdlprefiles. ++ # We recover the dlopen module name by 'saving' the la file ++ # name in a special purpose variable, and (later) extracting the ++ # dlname from the la file. ++ if test -n "$dlname"; then ++ func_tr_sh "$dir/$linklib" ++ eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname" ++ func_append newdlprefiles " $dir/$linklib" ++ else ++ func_append newdlprefiles " $dir/$old_library" ++ # Keep a list of preopened convenience libraries to check ++ # that they are being used correctly in the link pass. ++ test -z "$libdir" && \ ++ func_append dlpreconveniencelibs " $dir/$old_library" ++ fi ++ ;; ++ * ) ++ # Prefer using a static library (so that no silly _DYNAMIC symbols ++ # are required to link). ++ if test -n "$old_library"; then ++ func_append newdlprefiles " $dir/$old_library" ++ # Keep a list of preopened convenience libraries to check ++ # that they are being used correctly in the link pass. ++ test -z "$libdir" && \ ++ func_append dlpreconveniencelibs " $dir/$old_library" ++ # Otherwise, use the dlname, so that lt_dlopen finds it. ++ elif test -n "$dlname"; then ++ func_append newdlprefiles " $dir/$dlname" ++ else ++ func_append newdlprefiles " $dir/$linklib" ++ fi ++ ;; ++ esac ++ fi # $pass = dlpreopen ++ ++ if test -z "$libdir"; then ++ # Link the convenience library ++ if test lib = "$linkmode"; then ++ deplibs="$dir/$old_library $deplibs" ++ elif test prog,link = "$linkmode,$pass"; then ++ compile_deplibs="$dir/$old_library $compile_deplibs" ++ finalize_deplibs="$dir/$old_library $finalize_deplibs" ++ else ++ deplibs="$lib $deplibs" # used for prog,scan pass ++ fi ++ continue ++ fi ++ ++ ++ if test prog = "$linkmode" && test link != "$pass"; then ++ func_append newlib_search_path " $ladir" ++ deplibs="$lib $deplibs" ++ ++ linkalldeplibs=false ++ if test no != "$link_all_deplibs" || test -z "$library_names" || ++ test no = "$build_libtool_libs"; then ++ linkalldeplibs=: ++ fi ++ ++ tmp_libs= ++ for deplib in $dependency_libs; do ++ case $deplib in ++ -L*) func_stripname '-L' '' "$deplib" ++ func_resolve_sysroot "$func_stripname_result" ++ func_append newlib_search_path " $func_resolve_sysroot_result" ++ ;; ++ esac ++ # Need to link against all dependency_libs? ++ if $linkalldeplibs; then ++ deplibs="$deplib $deplibs" ++ else ++ # Need to hardcode shared library paths ++ # or/and link against static libraries ++ newdependency_libs="$deplib $newdependency_libs" ++ fi ++ if $opt_preserve_dup_deps; then ++ case "$tmp_libs " in ++ *" $deplib "*) func_append specialdeplibs " $deplib" ;; ++ esac ++ fi ++ func_append tmp_libs " $deplib" ++ done # for deplib ++ continue ++ fi # $linkmode = prog... ++ ++ if test prog,link = "$linkmode,$pass"; then ++ if test -n "$library_names" && ++ { { test no = "$prefer_static_libs" || ++ test built,yes = "$prefer_static_libs,$installed"; } || ++ test -z "$old_library"; }; then ++ # We need to hardcode the library path ++ if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then ++ # Make sure the rpath contains only unique directories. ++ case $temp_rpath: in ++ *"$absdir:"*) ;; ++ *) func_append temp_rpath "$absdir:" ;; ++ esac ++ fi ++ ++ # Hardcode the library path. ++ # Skip directories that are in the system default run-time ++ # search path. ++ case " $sys_lib_dlsearch_path " in ++ *" $absdir "*) ;; ++ *) ++ case "$compile_rpath " in ++ *" $absdir "*) ;; ++ *) func_append compile_rpath " $absdir" ;; ++ esac ++ ;; ++ esac ++ case " $sys_lib_dlsearch_path " in ++ *" $libdir "*) ;; ++ *) ++ case "$finalize_rpath " in ++ *" $libdir "*) ;; ++ *) func_append finalize_rpath " $libdir" ;; ++ esac ++ ;; ++ esac ++ fi # $linkmode,$pass = prog,link... ++ ++ if $alldeplibs && ++ { test pass_all = "$deplibs_check_method" || ++ { test yes = "$build_libtool_libs" && ++ test -n "$library_names"; }; }; then ++ # We only need to search for static libraries ++ continue ++ fi ++ fi ++ ++ link_static=no # Whether the deplib will be linked statically ++ use_static_libs=$prefer_static_libs ++ if test built = "$use_static_libs" && test yes = "$installed"; then ++ use_static_libs=no ++ fi ++ if test -n "$library_names" && ++ { test no = "$use_static_libs" || test -z "$old_library"; }; then ++ case $host in ++ *cygwin* | *mingw* | *cegcc* | *os2*) ++ # No point in relinking DLLs because paths are not encoded ++ func_append notinst_deplibs " $lib" ++ need_relink=no ++ ;; ++ *) ++ if test no = "$installed"; then ++ func_append notinst_deplibs " $lib" ++ need_relink=yes ++ fi ++ ;; ++ esac ++ # This is a shared library ++ ++ # Warn about portability, can't link against -module's on some ++ # systems (darwin). Don't bleat about dlopened modules though! ++ dlopenmodule= ++ for dlpremoduletest in $dlprefiles; do ++ if test "X$dlpremoduletest" = "X$lib"; then ++ dlopenmodule=$dlpremoduletest ++ break ++ fi ++ done ++ if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then ++ echo ++ if test prog = "$linkmode"; then ++ $ECHO "*** Warning: Linking the executable $output against the loadable module" ++ else ++ $ECHO "*** Warning: Linking the shared library $output against the loadable module" ++ fi ++ $ECHO "*** $linklib is not portable!" ++ fi ++ if test lib = "$linkmode" && ++ test yes = "$hardcode_into_libs"; then ++ # Hardcode the library path. ++ # Skip directories that are in the system default run-time ++ # search path. ++ case " $sys_lib_dlsearch_path " in ++ *" $absdir "*) ;; ++ *) ++ case "$compile_rpath " in ++ *" $absdir "*) ;; ++ *) func_append compile_rpath " $absdir" ;; ++ esac ++ ;; ++ esac ++ case " $sys_lib_dlsearch_path " in ++ *" $libdir "*) ;; ++ *) ++ case "$finalize_rpath " in ++ *" $libdir "*) ;; ++ *) func_append finalize_rpath " $libdir" ;; ++ esac ++ ;; ++ esac ++ fi ++ ++ if test -n "$old_archive_from_expsyms_cmds"; then ++ # figure out the soname ++ set dummy $library_names ++ shift ++ realname=$1 ++ shift ++ libname=`eval "\\$ECHO \"$libname_spec\""` ++ # use dlname if we got it. it's perfectly good, no? ++ if test -n "$dlname"; then ++ soname=$dlname ++ elif test -n "$soname_spec"; then ++ # bleh windows ++ case $host in ++ *cygwin* | mingw* | *cegcc* | *os2*) ++ func_arith $current - $age ++ major=$func_arith_result ++ versuffix=-$major ++ ;; ++ esac ++ eval soname=\"$soname_spec\" ++ else ++ soname=$realname ++ fi ++ ++ # Make a new name for the extract_expsyms_cmds to use ++ soroot=$soname ++ func_basename "$soroot" ++ soname=$func_basename_result ++ func_stripname 'lib' '.dll' "$soname" ++ newlib=libimp-$func_stripname_result.a ++ ++ # If the library has no export list, then create one now ++ if test -f "$output_objdir/$soname-def"; then : ++ else ++ func_verbose "extracting exported symbol list from '$soname'" ++ func_execute_cmds "$extract_expsyms_cmds" 'exit $?' ++ fi ++ ++ # Create $newlib ++ if test -f "$output_objdir/$newlib"; then :; else ++ func_verbose "generating import library for '$soname'" ++ func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?' ++ fi ++ # make sure the library variables are pointing to the new library ++ dir=$output_objdir ++ linklib=$newlib ++ fi # test -n "$old_archive_from_expsyms_cmds" ++ ++ if test prog = "$linkmode" || test relink != "$opt_mode"; then ++ add_shlibpath= ++ add_dir= ++ add= ++ lib_linked=yes ++ case $hardcode_action in ++ immediate | unsupported) ++ if test no = "$hardcode_direct"; then ++ add=$dir/$linklib ++ case $host in ++ *-*-sco3.2v5.0.[024]*) add_dir=-L$dir ;; ++ *-*-sysv4*uw2*) add_dir=-L$dir ;; ++ *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \ ++ *-*-unixware7*) add_dir=-L$dir ;; ++ *-*-darwin* ) ++ # if the lib is a (non-dlopened) module then we cannot ++ # link against it, someone is ignoring the earlier warnings ++ if /usr/bin/file -L $add 2> /dev/null | ++ $GREP ": [^:]* bundle" >/dev/null; then ++ if test "X$dlopenmodule" != "X$lib"; then ++ $ECHO "*** Warning: lib $linklib is a module, not a shared library" ++ if test -z "$old_library"; then ++ echo ++ echo "*** And there doesn't seem to be a static archive available" ++ echo "*** The link will probably fail, sorry" ++ else ++ add=$dir/$old_library ++ fi ++ elif test -n "$old_library"; then ++ add=$dir/$old_library ++ fi ++ fi ++ esac ++ elif test no = "$hardcode_minus_L"; then ++ case $host in ++ *-*-sunos*) add_shlibpath=$dir ;; ++ esac ++ add_dir=-L$dir ++ add=-l$name ++ elif test no = "$hardcode_shlibpath_var"; then ++ add_shlibpath=$dir ++ add=-l$name ++ else ++ lib_linked=no ++ fi ++ ;; ++ relink) ++ if test yes = "$hardcode_direct" && ++ test no = "$hardcode_direct_absolute"; then ++ add=$dir/$linklib ++ elif test yes = "$hardcode_minus_L"; then ++ add_dir=-L$absdir ++ # Try looking first in the location we're being installed to. ++ if test -n "$inst_prefix_dir"; then ++ case $libdir in ++ [\\/]*) ++ func_append add_dir " -L$inst_prefix_dir$libdir" ++ ;; ++ esac ++ fi ++ add=-l$name ++ elif test yes = "$hardcode_shlibpath_var"; then ++ add_shlibpath=$dir ++ add=-l$name ++ else ++ lib_linked=no ++ fi ++ ;; ++ *) lib_linked=no ;; ++ esac ++ ++ if test yes != "$lib_linked"; then ++ func_fatal_configuration "unsupported hardcode properties" ++ fi ++ ++ if test -n "$add_shlibpath"; then ++ case :$compile_shlibpath: in ++ *":$add_shlibpath:"*) ;; ++ *) func_append compile_shlibpath "$add_shlibpath:" ;; ++ esac ++ fi ++ if test prog = "$linkmode"; then ++ test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs" ++ test -n "$add" && compile_deplibs="$add $compile_deplibs" ++ else ++ test -n "$add_dir" && deplibs="$add_dir $deplibs" ++ test -n "$add" && deplibs="$add $deplibs" ++ if test yes != "$hardcode_direct" && ++ test yes != "$hardcode_minus_L" && ++ test yes = "$hardcode_shlibpath_var"; then ++ case :$finalize_shlibpath: in ++ *":$libdir:"*) ;; ++ *) func_append finalize_shlibpath "$libdir:" ;; ++ esac ++ fi ++ fi ++ fi ++ ++ if test prog = "$linkmode" || test relink = "$opt_mode"; then ++ add_shlibpath= ++ add_dir= ++ add= ++ # Finalize command for both is simple: just hardcode it. ++ if test yes = "$hardcode_direct" && ++ test no = "$hardcode_direct_absolute"; then ++ add=$libdir/$linklib ++ elif test yes = "$hardcode_minus_L"; then ++ add_dir=-L$libdir ++ add=-l$name ++ elif test yes = "$hardcode_shlibpath_var"; then ++ case :$finalize_shlibpath: in ++ *":$libdir:"*) ;; ++ *) func_append finalize_shlibpath "$libdir:" ;; ++ esac ++ add=-l$name ++ elif test yes = "$hardcode_automatic"; then ++ if test -n "$inst_prefix_dir" && ++ test -f "$inst_prefix_dir$libdir/$linklib"; then ++ add=$inst_prefix_dir$libdir/$linklib ++ else ++ add=$libdir/$linklib ++ fi ++ else ++ # We cannot seem to hardcode it, guess we'll fake it. ++ add_dir=-L$libdir ++ # Try looking first in the location we're being installed to. ++ if test -n "$inst_prefix_dir"; then ++ case $libdir in ++ [\\/]*) ++ func_append add_dir " -L$inst_prefix_dir$libdir" ++ ;; ++ esac ++ fi ++ add=-l$name ++ fi ++ ++ if test prog = "$linkmode"; then ++ test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs" ++ test -n "$add" && finalize_deplibs="$add $finalize_deplibs" ++ else ++ test -n "$add_dir" && deplibs="$add_dir $deplibs" ++ test -n "$add" && deplibs="$add $deplibs" ++ fi ++ fi ++ elif test prog = "$linkmode"; then ++ # Here we assume that one of hardcode_direct or hardcode_minus_L ++ # is not unsupported. This is valid on all known static and ++ # shared platforms. ++ if test unsupported != "$hardcode_direct"; then ++ test -n "$old_library" && linklib=$old_library ++ compile_deplibs="$dir/$linklib $compile_deplibs" ++ finalize_deplibs="$dir/$linklib $finalize_deplibs" ++ else ++ compile_deplibs="-l$name -L$dir $compile_deplibs" ++ finalize_deplibs="-l$name -L$dir $finalize_deplibs" ++ fi ++ elif test yes = "$build_libtool_libs"; then ++ # Not a shared library ++ if test pass_all != "$deplibs_check_method"; then ++ # We're trying link a shared library against a static one ++ # but the system doesn't support it. ++ ++ # Just print a warning and add the library to dependency_libs so ++ # that the program can be linked against the static library. ++ echo ++ $ECHO "*** Warning: This system cannot link to static lib archive $lib." ++ echo "*** I have the capability to make that library automatically link in when" ++ echo "*** you link to this library. But I can only do this if you have a" ++ echo "*** shared version of the library, which you do not appear to have." ++ if test yes = "$module"; then ++ echo "*** But as you try to build a module library, libtool will still create " ++ echo "*** a static module, that should work as long as the dlopening application" ++ echo "*** is linked with the -dlopen flag to resolve symbols at runtime." ++ if test -z "$global_symbol_pipe"; then ++ echo ++ echo "*** However, this would only work if libtool was able to extract symbol" ++ echo "*** lists from a program, using 'nm' or equivalent, but libtool could" ++ echo "*** not find such a program. So, this module is probably useless." ++ echo "*** 'nm' from GNU binutils and a full rebuild may help." ++ fi ++ if test no = "$build_old_libs"; then ++ build_libtool_libs=module ++ build_old_libs=yes ++ else ++ build_libtool_libs=no ++ fi ++ fi ++ else ++ deplibs="$dir/$old_library $deplibs" ++ link_static=yes ++ fi ++ fi # link shared/static library? ++ ++ if test lib = "$linkmode"; then ++ if test -n "$dependency_libs" && ++ { test yes != "$hardcode_into_libs" || ++ test yes = "$build_old_libs" || ++ test yes = "$link_static"; }; then ++ # Extract -R from dependency_libs ++ temp_deplibs= ++ for libdir in $dependency_libs; do ++ case $libdir in ++ -R*) func_stripname '-R' '' "$libdir" ++ temp_xrpath=$func_stripname_result ++ case " $xrpath " in ++ *" $temp_xrpath "*) ;; ++ *) func_append xrpath " $temp_xrpath";; ++ esac;; ++ *) func_append temp_deplibs " $libdir";; ++ esac ++ done ++ dependency_libs=$temp_deplibs ++ fi ++ ++ func_append newlib_search_path " $absdir" ++ # Link against this library ++ test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs" ++ # ... and its dependency_libs ++ tmp_libs= ++ for deplib in $dependency_libs; do ++ newdependency_libs="$deplib $newdependency_libs" ++ case $deplib in ++ -L*) func_stripname '-L' '' "$deplib" ++ func_resolve_sysroot "$func_stripname_result";; ++ *) func_resolve_sysroot "$deplib" ;; ++ esac ++ if $opt_preserve_dup_deps; then ++ case "$tmp_libs " in ++ *" $func_resolve_sysroot_result "*) ++ func_append specialdeplibs " $func_resolve_sysroot_result" ;; ++ esac ++ fi ++ func_append tmp_libs " $func_resolve_sysroot_result" ++ done ++ ++ if test no != "$link_all_deplibs"; then ++ # Add the search paths of all dependency libraries ++ for deplib in $dependency_libs; do ++ path= ++ case $deplib in ++ -L*) path=$deplib ;; ++ *.la) ++ func_resolve_sysroot "$deplib" ++ deplib=$func_resolve_sysroot_result ++ func_dirname "$deplib" "" "." ++ dir=$func_dirname_result ++ # We need an absolute path. ++ case $dir in ++ [\\/]* | [A-Za-z]:[\\/]*) absdir=$dir ;; ++ *) ++ absdir=`cd "$dir" && pwd` ++ if test -z "$absdir"; then ++ func_warning "cannot determine absolute directory name of '$dir'" ++ absdir=$dir ++ fi ++ ;; ++ esac ++ if $GREP "^installed=no" $deplib > /dev/null; then ++ case $host in ++ *-*-darwin*) ++ depdepl= ++ eval deplibrary_names=`$SED -n -e 's/^library_names=\(.*\)$/\1/p' $deplib` ++ if test -n "$deplibrary_names"; then ++ for tmp in $deplibrary_names; do ++ depdepl=$tmp ++ done ++ if test -f "$absdir/$objdir/$depdepl"; then ++ depdepl=$absdir/$objdir/$depdepl ++ darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` ++ if test -z "$darwin_install_name"; then ++ darwin_install_name=`$OTOOL64 -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'` ++ fi ++ func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl" ++ func_append linker_flags " -dylib_file $darwin_install_name:$depdepl" ++ path= ++ fi ++ fi ++ ;; ++ *) ++ path=-L$absdir/$objdir ++ ;; ++ esac ++ else ++ eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $deplib` ++ test -z "$libdir" && \ ++ func_fatal_error "'$deplib' is not a valid libtool archive" ++ test "$absdir" != "$libdir" && \ ++ func_warning "'$deplib' seems to be moved" ++ ++ path=-L$absdir ++ fi ++ ;; ++ esac ++ case " $deplibs " in ++ *" $path "*) ;; ++ *) deplibs="$path $deplibs" ;; ++ esac ++ done ++ fi # link_all_deplibs != no ++ fi # linkmode = lib ++ done # for deplib in $libs ++ if test link = "$pass"; then ++ if test prog = "$linkmode"; then ++ compile_deplibs="$new_inherited_linker_flags $compile_deplibs" ++ finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs" ++ else ++ compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` ++ fi ++ fi ++ dependency_libs=$newdependency_libs ++ if test dlpreopen = "$pass"; then ++ # Link the dlpreopened libraries before other libraries ++ for deplib in $save_deplibs; do ++ deplibs="$deplib $deplibs" ++ done ++ fi ++ if test dlopen != "$pass"; then ++ test conv = "$pass" || { ++ # Make sure lib_search_path contains only unique directories. ++ lib_search_path= ++ for dir in $newlib_search_path; do ++ case "$lib_search_path " in ++ *" $dir "*) ;; ++ *) func_append lib_search_path " $dir" ;; ++ esac ++ done ++ newlib_search_path= ++ } ++ ++ if test prog,link = "$linkmode,$pass"; then ++ vars="compile_deplibs finalize_deplibs" ++ else ++ vars=deplibs ++ fi ++ for var in $vars dependency_libs; do ++ # Add libraries to $var in reverse order ++ eval tmp_libs=\"\$$var\" ++ new_libs= ++ for deplib in $tmp_libs; do ++ # FIXME: Pedantically, this is the right thing to do, so ++ # that some nasty dependency loop isn't accidentally ++ # broken: ++ #new_libs="$deplib $new_libs" ++ # Pragmatically, this seems to cause very few problems in ++ # practice: ++ case $deplib in ++ -L*) new_libs="$deplib $new_libs" ;; ++ -R*) ;; ++ *) ++ # And here is the reason: when a library appears more ++ # than once as an explicit dependence of a library, or ++ # is implicitly linked in more than once by the ++ # compiler, it is considered special, and multiple ++ # occurrences thereof are not removed. Compare this ++ # with having the same library being listed as a ++ # dependency of multiple other libraries: in this case, ++ # we know (pedantically, we assume) the library does not ++ # need to be listed more than once, so we keep only the ++ # last copy. This is not always right, but it is rare ++ # enough that we require users that really mean to play ++ # such unportable linking tricks to link the library ++ # using -Wl,-lname, so that libtool does not consider it ++ # for duplicate removal. ++ case " $specialdeplibs " in ++ *" $deplib "*) new_libs="$deplib $new_libs" ;; ++ *) ++ case " $new_libs " in ++ *" $deplib "*) ;; ++ *) new_libs="$deplib $new_libs" ;; ++ esac ++ ;; ++ esac ++ ;; ++ esac ++ done ++ tmp_libs= ++ for deplib in $new_libs; do ++ case $deplib in ++ -L*) ++ case " $tmp_libs " in ++ *" $deplib "*) ;; ++ *) func_append tmp_libs " $deplib" ;; ++ esac ++ ;; ++ *) func_append tmp_libs " $deplib" ;; ++ esac ++ done ++ eval $var=\"$tmp_libs\" ++ done # for var ++ fi ++ ++ # Add Sun CC postdeps if required: ++ test CXX = "$tagname" && { ++ case $host_os in ++ linux*) ++ case `$CC -V 2>&1 | sed 5q` in ++ *Sun\ C*) # Sun C++ 5.9 ++ func_suncc_cstd_abi ++ ++ if test no != "$suncc_use_cstd_abi"; then ++ func_append postdeps ' -library=Cstd -library=Crun' ++ fi ++ ;; ++ esac ++ ;; ++ ++ solaris*) ++ func_cc_basename "$CC" ++ case $func_cc_basename_result in ++ CC* | sunCC*) ++ func_suncc_cstd_abi ++ ++ if test no != "$suncc_use_cstd_abi"; then ++ func_append postdeps ' -library=Cstd -library=Crun' ++ fi ++ ;; ++ esac ++ ;; ++ esac ++ } ++ ++ # Last step: remove runtime libs from dependency_libs ++ # (they stay in deplibs) ++ tmp_libs= ++ for i in $dependency_libs; do ++ case " $predeps $postdeps $compiler_lib_search_path " in ++ *" $i "*) ++ i= ++ ;; ++ esac ++ if test -n "$i"; then ++ func_append tmp_libs " $i" ++ fi ++ done ++ dependency_libs=$tmp_libs ++ done # for pass ++ if test prog = "$linkmode"; then ++ dlfiles=$newdlfiles ++ fi ++ if test prog = "$linkmode" || test lib = "$linkmode"; then ++ dlprefiles=$newdlprefiles ++ fi ++ ++ case $linkmode in ++ oldlib) ++ if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then ++ func_warning "'-dlopen' is ignored for archives" ++ fi ++ ++ case " $deplibs" in ++ *\ -l* | *\ -L*) ++ func_warning "'-l' and '-L' are ignored for archives" ;; ++ esac ++ ++ test -n "$rpath" && \ ++ func_warning "'-rpath' is ignored for archives" ++ ++ test -n "$xrpath" && \ ++ func_warning "'-R' is ignored for archives" ++ ++ test -n "$vinfo" && \ ++ func_warning "'-version-info/-version-number' is ignored for archives" ++ ++ test -n "$release" && \ ++ func_warning "'-release' is ignored for archives" ++ ++ test -n "$export_symbols$export_symbols_regex" && \ ++ func_warning "'-export-symbols' is ignored for archives" ++ ++ # Now set the variables for building old libraries. ++ build_libtool_libs=no ++ oldlibs=$output ++ func_append objs "$old_deplibs" ++ ;; ++ ++ lib) ++ # Make sure we only generate libraries of the form 'libNAME.la'. ++ case $outputname in ++ lib*) ++ func_stripname 'lib' '.la' "$outputname" ++ name=$func_stripname_result ++ eval shared_ext=\"$shrext_cmds\" ++ eval libname=\"$libname_spec\" ++ ;; ++ *) ++ test no = "$module" \ ++ && func_fatal_help "libtool library '$output' must begin with 'lib'" ++ ++ if test no != "$need_lib_prefix"; then ++ # Add the "lib" prefix for modules if required ++ func_stripname '' '.la' "$outputname" ++ name=$func_stripname_result ++ eval shared_ext=\"$shrext_cmds\" ++ eval libname=\"$libname_spec\" ++ else ++ func_stripname '' '.la' "$outputname" ++ libname=$func_stripname_result ++ fi ++ ;; ++ esac ++ ++ if test -n "$objs"; then ++ if test pass_all != "$deplibs_check_method"; then ++ func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs" ++ else ++ echo ++ $ECHO "*** Warning: Linking the shared library $output against the non-libtool" ++ $ECHO "*** objects $objs is not portable!" ++ func_append libobjs " $objs" ++ fi ++ fi ++ ++ test no = "$dlself" \ ++ || func_warning "'-dlopen self' is ignored for libtool libraries" ++ ++ set dummy $rpath ++ shift ++ test 1 -lt "$#" \ ++ && func_warning "ignoring multiple '-rpath's for a libtool library" ++ ++ install_libdir=$1 ++ ++ oldlibs= ++ if test -z "$rpath"; then ++ if test yes = "$build_libtool_libs"; then ++ # Building a libtool convenience library. ++ # Some compilers have problems with a '.al' extension so ++ # convenience libraries should have the same extension an ++ # archive normally would. ++ oldlibs="$output_objdir/$libname.$libext $oldlibs" ++ build_libtool_libs=convenience ++ build_old_libs=yes ++ fi ++ ++ test -n "$vinfo" && \ ++ func_warning "'-version-info/-version-number' is ignored for convenience libraries" ++ ++ test -n "$release" && \ ++ func_warning "'-release' is ignored for convenience libraries" ++ else ++ ++ # Parse the version information argument. ++ save_ifs=$IFS; IFS=: ++ set dummy $vinfo 0 0 0 ++ shift ++ IFS=$save_ifs ++ ++ test -n "$7" && \ ++ func_fatal_help "too many parameters to '-version-info'" ++ ++ # convert absolute version numbers to libtool ages ++ # this retains compatibility with .la files and attempts ++ # to make the code below a bit more comprehensible ++ ++ case $vinfo_number in ++ yes) ++ number_major=$1 ++ number_minor=$2 ++ number_revision=$3 ++ # ++ # There are really only two kinds -- those that ++ # use the current revision as the major version ++ # and those that subtract age and use age as ++ # a minor version. But, then there is irix ++ # that has an extra 1 added just for fun ++ # ++ case $version_type in ++ # correct linux to gnu/linux during the next big refactor ++ darwin|freebsd-elf|linux|osf|windows|none) ++ func_arith $number_major + $number_minor ++ current=$func_arith_result ++ age=$number_minor ++ revision=$number_revision ++ ;; ++ freebsd-aout|qnx|sunos) ++ current=$number_major ++ revision=$number_minor ++ age=0 ++ ;; ++ irix|nonstopux) ++ func_arith $number_major + $number_minor ++ current=$func_arith_result ++ age=$number_minor ++ revision=$number_minor ++ lt_irix_increment=no ++ ;; ++ *) ++ func_fatal_configuration "$modename: unknown library version type '$version_type'" ++ ;; ++ esac ++ ;; ++ no) ++ current=$1 ++ revision=$2 ++ age=$3 ++ ;; ++ esac ++ ++ # Check that each of the things are valid numbers. ++ case $current in ++ 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; ++ *) ++ func_error "CURRENT '$current' must be a nonnegative integer" ++ func_fatal_error "'$vinfo' is not valid version information" ++ ;; ++ esac ++ ++ case $revision in ++ 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; ++ *) ++ func_error "REVISION '$revision' must be a nonnegative integer" ++ func_fatal_error "'$vinfo' is not valid version information" ++ ;; ++ esac ++ ++ case $age in ++ 0|[1-9]|[1-9][0-9]|[1-9][0-9][0-9]|[1-9][0-9][0-9][0-9]|[1-9][0-9][0-9][0-9][0-9]) ;; ++ *) ++ func_error "AGE '$age' must be a nonnegative integer" ++ func_fatal_error "'$vinfo' is not valid version information" ++ ;; ++ esac ++ ++ if test "$age" -gt "$current"; then ++ func_error "AGE '$age' is greater than the current interface number '$current'" ++ func_fatal_error "'$vinfo' is not valid version information" ++ fi ++ ++ # Calculate the version variables. ++ major= ++ versuffix= ++ verstring= ++ case $version_type in ++ none) ;; ++ ++ darwin) ++ # Like Linux, but with the current version available in ++ # verstring for coding it into the library header ++ func_arith $current - $age ++ major=.$func_arith_result ++ versuffix=$major.$age.$revision ++ # Darwin ld doesn't like 0 for these options... ++ func_arith $current + 1 ++ minor_current=$func_arith_result ++ xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision" ++ verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" ++ # On Darwin other compilers ++ case $CC in ++ nagfor*) ++ verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision" ++ ;; ++ *) ++ verstring="-compatibility_version $minor_current -current_version $minor_current.$revision" ++ ;; ++ esac ++ ;; ++ ++ freebsd-aout) ++ major=.$current ++ versuffix=.$current.$revision ++ ;; ++ ++ freebsd-elf) ++ func_arith $current - $age ++ major=.$func_arith_result ++ versuffix=$major.$age.$revision ++ ;; ++ ++ irix | nonstopux) ++ if test no = "$lt_irix_increment"; then ++ func_arith $current - $age ++ else ++ func_arith $current - $age + 1 ++ fi ++ major=$func_arith_result ++ ++ case $version_type in ++ nonstopux) verstring_prefix=nonstopux ;; ++ *) verstring_prefix=sgi ;; ++ esac ++ verstring=$verstring_prefix$major.$revision ++ ++ # Add in all the interfaces that we are compatible with. ++ loop=$revision ++ while test 0 -ne "$loop"; do ++ func_arith $revision - $loop ++ iface=$func_arith_result ++ func_arith $loop - 1 ++ loop=$func_arith_result ++ verstring=$verstring_prefix$major.$iface:$verstring ++ done ++ ++ # Before this point, $major must not contain '.'. ++ major=.$major ++ versuffix=$major.$revision ++ ;; ++ ++ linux) # correct to gnu/linux during the next big refactor ++ func_arith $current - $age ++ major=.$func_arith_result ++ versuffix=$major.$age.$revision ++ ;; ++ ++ osf) ++ func_arith $current - $age ++ major=.$func_arith_result ++ versuffix=.$current.$age.$revision ++ verstring=$current.$age.$revision ++ ++ # Add in all the interfaces that we are compatible with. ++ loop=$age ++ while test 0 -ne "$loop"; do ++ func_arith $current - $loop ++ iface=$func_arith_result ++ func_arith $loop - 1 ++ loop=$func_arith_result ++ verstring=$verstring:$iface.0 ++ done ++ ++ # Make executables depend on our current version. ++ func_append verstring ":$current.0" ++ ;; ++ ++ qnx) ++ major=.$current ++ versuffix=.$current ++ ;; ++ ++ sco) ++ major=.$current ++ versuffix=.$current ++ ;; ++ ++ sunos) ++ major=.$current ++ versuffix=.$current.$revision ++ ;; ++ ++ windows) ++ # Use '-' rather than '.', since we only want one ++ # extension on DOS 8.3 file systems. ++ func_arith $current - $age ++ major=$func_arith_result ++ versuffix=-$major ++ ;; ++ ++ *) ++ func_fatal_configuration "unknown library version type '$version_type'" ++ ;; ++ esac ++ ++ # Clear the version info if we defaulted, and they specified a release. ++ if test -z "$vinfo" && test -n "$release"; then ++ major= ++ case $version_type in ++ darwin) ++ # we can't check for "0.0" in archive_cmds due to quoting ++ # problems, so we reset it completely ++ verstring= ++ ;; ++ *) ++ verstring=0.0 ++ ;; ++ esac ++ if test no = "$need_version"; then ++ versuffix= ++ else ++ versuffix=.0.0 ++ fi ++ fi ++ ++ # Remove version info from name if versioning should be avoided ++ if test yes,no = "$avoid_version,$need_version"; then ++ major= ++ versuffix= ++ verstring= ++ fi ++ ++ # Check to see if the archive will have undefined symbols. ++ if test yes = "$allow_undefined"; then ++ if test unsupported = "$allow_undefined_flag"; then ++ if test yes = "$build_old_libs"; then ++ func_warning "undefined symbols not allowed in $host shared libraries; building static only" ++ build_libtool_libs=no ++ else ++ func_fatal_error "can't build $host shared library unless -no-undefined is specified" ++ fi ++ fi ++ else ++ # Don't allow undefined symbols. ++ allow_undefined_flag=$no_undefined_flag ++ fi ++ ++ fi ++ ++ func_generate_dlsyms "$libname" "$libname" : ++ func_append libobjs " $symfileobj" ++ test " " = "$libobjs" && libobjs= ++ ++ if test relink != "$opt_mode"; then ++ # Remove our outputs, but don't remove object files since they ++ # may have been created when compiling PIC objects. ++ removelist= ++ tempremovelist=`$ECHO "$output_objdir/*"` ++ for p in $tempremovelist; do ++ case $p in ++ *.$objext | *.gcno) ++ ;; ++ $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*) ++ if test -n "$precious_files_regex"; then ++ if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1 ++ then ++ continue ++ fi ++ fi ++ func_append removelist " $p" ++ ;; ++ *) ;; ++ esac ++ done ++ test -n "$removelist" && \ ++ func_show_eval "${RM}r \$removelist" ++ fi ++ ++ # Now set the variables for building old libraries. ++ if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then ++ func_append oldlibs " $output_objdir/$libname.$libext" ++ ++ # Transform .lo files to .o files. ++ oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP` ++ fi ++ ++ # Eliminate all temporary directories. ++ #for path in $notinst_path; do ++ # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"` ++ # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"` ++ # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"` ++ #done ++ ++ if test -n "$xrpath"; then ++ # If the user specified any rpath flags, then add them. ++ temp_xrpath= ++ for libdir in $xrpath; do ++ func_replace_sysroot "$libdir" ++ func_append temp_xrpath " -R$func_replace_sysroot_result" ++ case "$finalize_rpath " in ++ *" $libdir "*) ;; ++ *) func_append finalize_rpath " $libdir" ;; ++ esac ++ done ++ if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then ++ dependency_libs="$temp_xrpath $dependency_libs" ++ fi ++ fi ++ ++ # Make sure dlfiles contains only unique files that won't be dlpreopened ++ old_dlfiles=$dlfiles ++ dlfiles= ++ for lib in $old_dlfiles; do ++ case " $dlprefiles $dlfiles " in ++ *" $lib "*) ;; ++ *) func_append dlfiles " $lib" ;; ++ esac ++ done ++ ++ # Make sure dlprefiles contains only unique files ++ old_dlprefiles=$dlprefiles ++ dlprefiles= ++ for lib in $old_dlprefiles; do ++ case "$dlprefiles " in ++ *" $lib "*) ;; ++ *) func_append dlprefiles " $lib" ;; ++ esac ++ done ++ ++ if test yes = "$build_libtool_libs"; then ++ if test -n "$rpath"; then ++ case $host in ++ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*) ++ # these systems don't actually have a c library (as such)! ++ ;; ++ *-*-rhapsody* | *-*-darwin1.[012]) ++ # Rhapsody C library is in the System framework ++ func_append deplibs " System.ltframework" ++ ;; ++ *-*-netbsd*) ++ # Don't link with libc until the a.out ld.so is fixed. ++ ;; ++ *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*) ++ # Do not include libc due to us having libc/libc_r. ++ ;; ++ *-*-sco3.2v5* | *-*-sco5v6*) ++ # Causes problems with __ctype ++ ;; ++ *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*) ++ # Compiler inserts libc in the correct place for threads to work ++ ;; ++ *) ++ # Add libc to deplibs on all other systems if necessary. ++ if test yes = "$build_libtool_need_lc"; then ++ func_append deplibs " -lc" ++ fi ++ ;; ++ esac ++ fi ++ ++ # Transform deplibs into only deplibs that can be linked in shared. ++ name_save=$name ++ libname_save=$libname ++ release_save=$release ++ versuffix_save=$versuffix ++ major_save=$major ++ # I'm not sure if I'm treating the release correctly. I think ++ # release should show up in the -l (ie -lgmp5) so we don't want to ++ # add it in twice. Is that correct? ++ release= ++ versuffix= ++ major= ++ newdeplibs= ++ droppeddeps=no ++ case $deplibs_check_method in ++ pass_all) ++ # Don't check for shared/static. Everything works. ++ # This might be a little naive. We might want to check ++ # whether the library exists or not. But this is on ++ # osf3 & osf4 and I'm not really sure... Just ++ # implementing what was already the behavior. ++ newdeplibs=$deplibs ++ ;; ++ test_compile) ++ # This code stresses the "libraries are programs" paradigm to its ++ # limits. Maybe even breaks it. We compile a program, linking it ++ # against the deplibs as a proxy for the library. Then we can check ++ # whether they linked in statically or dynamically with ldd. ++ $opt_dry_run || $RM conftest.c ++ cat > conftest.c </dev/null` ++ $nocaseglob ++ else ++ potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null` ++ fi ++ for potent_lib in $potential_libs; do ++ # Follow soft links. ++ if ls -lLd "$potent_lib" 2>/dev/null | ++ $GREP " -> " >/dev/null; then ++ continue ++ fi ++ # The statement above tries to avoid entering an ++ # endless loop below, in case of cyclic links. ++ # We might still enter an endless loop, since a link ++ # loop can be closed while we follow links, ++ # but so what? ++ potlib=$potent_lib ++ while test -h "$potlib" 2>/dev/null; do ++ potliblink=`ls -ld $potlib | $SED 's/.* -> //'` ++ case $potliblink in ++ [\\/]* | [A-Za-z]:[\\/]*) potlib=$potliblink;; ++ *) potlib=`$ECHO "$potlib" | $SED 's|[^/]*$||'`"$potliblink";; ++ esac ++ done ++ if eval $file_magic_cmd \"\$potlib\" 2>/dev/null | ++ $SED -e 10q | ++ $EGREP "$file_magic_regex" > /dev/null; then ++ func_append newdeplibs " $a_deplib" ++ a_deplib= ++ break 2 ++ fi ++ done ++ done ++ fi ++ if test -n "$a_deplib"; then ++ droppeddeps=yes ++ echo ++ $ECHO "*** Warning: linker path does not have real file for library $a_deplib." ++ echo "*** I have the capability to make that library automatically link in when" ++ echo "*** you link to this library. But I can only do this if you have a" ++ echo "*** shared version of the library, which you do not appear to have" ++ echo "*** because I did check the linker path looking for a file starting" ++ if test -z "$potlib"; then ++ $ECHO "*** with $libname but no candidates were found. (...for file magic test)" ++ else ++ $ECHO "*** with $libname and none of the candidates passed a file format test" ++ $ECHO "*** using a file magic. Last file checked: $potlib" ++ fi ++ fi ++ ;; ++ *) ++ # Add a -L argument. ++ func_append newdeplibs " $a_deplib" ++ ;; ++ esac ++ done # Gone through all deplibs. ++ ;; ++ match_pattern*) ++ set dummy $deplibs_check_method; shift ++ match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"` ++ for a_deplib in $deplibs; do ++ case $a_deplib in ++ -l*) ++ func_stripname -l '' "$a_deplib" ++ name=$func_stripname_result ++ if test yes = "$allow_libtool_libs_with_static_runtimes"; then ++ case " $predeps $postdeps " in ++ *" $a_deplib "*) ++ func_append newdeplibs " $a_deplib" ++ a_deplib= ++ ;; ++ esac ++ fi ++ if test -n "$a_deplib"; then ++ libname=`eval "\\$ECHO \"$libname_spec\""` ++ for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do ++ potential_libs=`ls $i/$libname[.-]* 2>/dev/null` ++ for potent_lib in $potential_libs; do ++ potlib=$potent_lib # see symlink-check above in file_magic test ++ if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \ ++ $EGREP "$match_pattern_regex" > /dev/null; then ++ func_append newdeplibs " $a_deplib" ++ a_deplib= ++ break 2 ++ fi ++ done ++ done ++ fi ++ if test -n "$a_deplib"; then ++ droppeddeps=yes ++ echo ++ $ECHO "*** Warning: linker path does not have real file for library $a_deplib." ++ echo "*** I have the capability to make that library automatically link in when" ++ echo "*** you link to this library. But I can only do this if you have a" ++ echo "*** shared version of the library, which you do not appear to have" ++ echo "*** because I did check the linker path looking for a file starting" ++ if test -z "$potlib"; then ++ $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)" ++ else ++ $ECHO "*** with $libname and none of the candidates passed a file format test" ++ $ECHO "*** using a regex pattern. Last file checked: $potlib" ++ fi ++ fi ++ ;; ++ *) ++ # Add a -L argument. ++ func_append newdeplibs " $a_deplib" ++ ;; ++ esac ++ done # Gone through all deplibs. ++ ;; ++ none | unknown | *) ++ newdeplibs= ++ tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'` ++ if test yes = "$allow_libtool_libs_with_static_runtimes"; then ++ for i in $predeps $postdeps; do ++ # can't use Xsed below, because $i might contain '/' ++ tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"` ++ done ++ fi ++ case $tmp_deplibs in ++ *[!\ \ ]*) ++ echo ++ if test none = "$deplibs_check_method"; then ++ echo "*** Warning: inter-library dependencies are not supported in this platform." ++ else ++ echo "*** Warning: inter-library dependencies are not known to be supported." ++ fi ++ echo "*** All declared inter-library dependencies are being dropped." ++ droppeddeps=yes ++ ;; ++ esac ++ ;; ++ esac ++ versuffix=$versuffix_save ++ major=$major_save ++ release=$release_save ++ libname=$libname_save ++ name=$name_save ++ ++ case $host in ++ *-*-rhapsody* | *-*-darwin1.[012]) ++ # On Rhapsody replace the C library with the System framework ++ newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'` ++ ;; ++ esac ++ ++ if test yes = "$droppeddeps"; then ++ if test yes = "$module"; then ++ echo ++ echo "*** Warning: libtool could not satisfy all declared inter-library" ++ $ECHO "*** dependencies of module $libname. Therefore, libtool will create" ++ echo "*** a static module, that should work as long as the dlopening" ++ echo "*** application is linked with the -dlopen flag." ++ if test -z "$global_symbol_pipe"; then ++ echo ++ echo "*** However, this would only work if libtool was able to extract symbol" ++ echo "*** lists from a program, using 'nm' or equivalent, but libtool could" ++ echo "*** not find such a program. So, this module is probably useless." ++ echo "*** 'nm' from GNU binutils and a full rebuild may help." ++ fi ++ if test no = "$build_old_libs"; then ++ oldlibs=$output_objdir/$libname.$libext ++ build_libtool_libs=module ++ build_old_libs=yes ++ else ++ build_libtool_libs=no ++ fi ++ else ++ echo "*** The inter-library dependencies that have been dropped here will be" ++ echo "*** automatically added whenever a program is linked with this library" ++ echo "*** or is declared to -dlopen it." ++ ++ if test no = "$allow_undefined"; then ++ echo ++ echo "*** Since this library must not contain undefined symbols," ++ echo "*** because either the platform does not support them or" ++ echo "*** it was explicitly requested with -no-undefined," ++ echo "*** libtool will only create a static version of it." ++ if test no = "$build_old_libs"; then ++ oldlibs=$output_objdir/$libname.$libext ++ build_libtool_libs=module ++ build_old_libs=yes ++ else ++ build_libtool_libs=no ++ fi ++ fi ++ fi ++ fi ++ # Done checking deplibs! ++ deplibs=$newdeplibs ++ fi ++ # Time to change all our "foo.ltframework" stuff back to "-framework foo" ++ case $host in ++ *-*-darwin*) ++ newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` ++ new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` ++ deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` ++ ;; ++ esac ++ ++ # move library search paths that coincide with paths to not yet ++ # installed libraries to the beginning of the library search list ++ new_libs= ++ for path in $notinst_path; do ++ case " $new_libs " in ++ *" -L$path/$objdir "*) ;; ++ *) ++ case " $deplibs " in ++ *" -L$path/$objdir "*) ++ func_append new_libs " -L$path/$objdir" ;; ++ esac ++ ;; ++ esac ++ done ++ for deplib in $deplibs; do ++ case $deplib in ++ -L*) ++ case " $new_libs " in ++ *" $deplib "*) ;; ++ *) func_append new_libs " $deplib" ;; ++ esac ++ ;; ++ *) func_append new_libs " $deplib" ;; ++ esac ++ done ++ deplibs=$new_libs ++ ++ # All the library-specific variables (install_libdir is set above). ++ library_names= ++ old_library= ++ dlname= ++ ++ # Test again, we may have decided not to build it any more ++ if test yes = "$build_libtool_libs"; then ++ # Remove $wl instances when linking with ld. ++ # FIXME: should test the right _cmds variable. ++ case $archive_cmds in ++ *\$LD\ *) wl= ;; ++ esac ++ if test yes = "$hardcode_into_libs"; then ++ # Hardcode the library paths ++ hardcode_libdirs= ++ dep_rpath= ++ rpath=$finalize_rpath ++ test relink = "$opt_mode" || rpath=$compile_rpath$rpath ++ for libdir in $rpath; do ++ if test -n "$hardcode_libdir_flag_spec"; then ++ if test -n "$hardcode_libdir_separator"; then ++ func_replace_sysroot "$libdir" ++ libdir=$func_replace_sysroot_result ++ if test -z "$hardcode_libdirs"; then ++ hardcode_libdirs=$libdir ++ else ++ # Just accumulate the unique libdirs. ++ case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in ++ *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) ++ ;; ++ *) ++ func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" ++ ;; ++ esac ++ fi ++ else ++ eval flag=\"$hardcode_libdir_flag_spec\" ++ func_append dep_rpath " $flag" ++ fi ++ elif test -n "$runpath_var"; then ++ case "$perm_rpath " in ++ *" $libdir "*) ;; ++ *) func_append perm_rpath " $libdir" ;; ++ esac ++ fi ++ done ++ # Substitute the hardcoded libdirs into the rpath. ++ if test -n "$hardcode_libdir_separator" && ++ test -n "$hardcode_libdirs"; then ++ libdir=$hardcode_libdirs ++ eval "dep_rpath=\"$hardcode_libdir_flag_spec\"" ++ fi ++ if test -n "$runpath_var" && test -n "$perm_rpath"; then ++ # We should set the runpath_var. ++ rpath= ++ for dir in $perm_rpath; do ++ func_append rpath "$dir:" ++ done ++ eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var" ++ fi ++ test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs" ++ fi ++ ++ shlibpath=$finalize_shlibpath ++ test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath ++ if test -n "$shlibpath"; then ++ eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var" ++ fi ++ ++ # Get the real and link names of the library. ++ eval shared_ext=\"$shrext_cmds\" ++ eval library_names=\"$library_names_spec\" ++ set dummy $library_names ++ shift ++ realname=$1 ++ shift ++ ++ if test -n "$soname_spec"; then ++ eval soname=\"$soname_spec\" ++ else ++ soname=$realname ++ fi ++ if test -z "$dlname"; then ++ dlname=$soname ++ fi ++ ++ lib=$output_objdir/$realname ++ linknames= ++ for link ++ do ++ func_append linknames " $link" ++ done ++ ++ # Use standard objects if they are pic ++ test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP` ++ test "X$libobjs" = "X " && libobjs= ++ ++ delfiles= ++ if test -n "$export_symbols" && test -n "$include_expsyms"; then ++ $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp" ++ export_symbols=$output_objdir/$libname.uexp ++ func_append delfiles " $export_symbols" ++ fi ++ ++ orig_export_symbols= ++ case $host_os in ++ cygwin* | mingw* | cegcc*) ++ if test -n "$export_symbols" && test -z "$export_symbols_regex"; then ++ # exporting using user supplied symfile ++ func_dll_def_p "$export_symbols" || { ++ # and it's NOT already a .def file. Must figure out ++ # which of the given symbols are data symbols and tag ++ # them as such. So, trigger use of export_symbols_cmds. ++ # export_symbols gets reassigned inside the "prepare ++ # the list of exported symbols" if statement, so the ++ # include_expsyms logic still works. ++ orig_export_symbols=$export_symbols ++ export_symbols= ++ always_export_symbols=yes ++ } ++ fi ++ ;; ++ esac ++ ++ # Prepare the list of exported symbols ++ if test -z "$export_symbols"; then ++ if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then ++ func_verbose "generating symbol list for '$libname.la'" ++ export_symbols=$output_objdir/$libname.exp ++ $opt_dry_run || $RM $export_symbols ++ cmds=$export_symbols_cmds ++ save_ifs=$IFS; IFS='~' ++ for cmd1 in $cmds; do ++ IFS=$save_ifs ++ # Take the normal branch if the nm_file_list_spec branch ++ # doesn't work or if tool conversion is not needed. ++ case $nm_file_list_spec~$to_tool_file_cmd in ++ *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*) ++ try_normal_branch=yes ++ eval cmd=\"$cmd1\" ++ func_len " $cmd" ++ len=$func_len_result ++ ;; ++ *) ++ try_normal_branch=no ++ ;; ++ esac ++ if test yes = "$try_normal_branch" \ ++ && { test "$len" -lt "$max_cmd_len" \ ++ || test "$max_cmd_len" -le -1; } ++ then ++ func_show_eval "$cmd" 'exit $?' ++ skipped_export=false ++ elif test -n "$nm_file_list_spec"; then ++ func_basename "$output" ++ output_la=$func_basename_result ++ save_libobjs=$libobjs ++ save_output=$output ++ output=$output_objdir/$output_la.nm ++ func_to_tool_file "$output" ++ libobjs=$nm_file_list_spec$func_to_tool_file_result ++ func_append delfiles " $output" ++ func_verbose "creating $NM input file list: $output" ++ for obj in $save_libobjs; do ++ func_to_tool_file "$obj" ++ $ECHO "$func_to_tool_file_result" ++ done > "$output" ++ eval cmd=\"$cmd1\" ++ func_show_eval "$cmd" 'exit $?' ++ output=$save_output ++ libobjs=$save_libobjs ++ skipped_export=false ++ else ++ # The command line is too long to execute in one step. ++ func_verbose "using reloadable object file for export list..." ++ skipped_export=: ++ # Break out early, otherwise skipped_export may be ++ # set to false by a later but shorter cmd. ++ break ++ fi ++ done ++ IFS=$save_ifs ++ if test -n "$export_symbols_regex" && test : != "$skipped_export"; then ++ func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' ++ func_show_eval '$MV "${export_symbols}T" "$export_symbols"' ++ fi ++ fi ++ fi ++ ++ if test -n "$export_symbols" && test -n "$include_expsyms"; then ++ tmp_export_symbols=$export_symbols ++ test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols ++ $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' ++ fi ++ ++ if test : != "$skipped_export" && test -n "$orig_export_symbols"; then ++ # The given exports_symbols file has to be filtered, so filter it. ++ func_verbose "filter symbol list for '$libname.la' to tag DATA exports" ++ # FIXME: $output_objdir/$libname.filter potentially contains lots of ++ # 's' commands, which not all seds can handle. GNU sed should be fine ++ # though. Also, the filter scales superlinearly with the number of ++ # global variables. join(1) would be nice here, but unfortunately ++ # isn't a blessed tool. ++ $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter ++ func_append delfiles " $export_symbols $output_objdir/$libname.filter" ++ export_symbols=$output_objdir/$libname.def ++ $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols ++ fi ++ ++ tmp_deplibs= ++ for test_deplib in $deplibs; do ++ case " $convenience " in ++ *" $test_deplib "*) ;; ++ *) ++ func_append tmp_deplibs " $test_deplib" ++ ;; ++ esac ++ done ++ deplibs=$tmp_deplibs ++ ++ if test -n "$convenience"; then ++ if test -n "$whole_archive_flag_spec" && ++ test yes = "$compiler_needs_object" && ++ test -z "$libobjs"; then ++ # extract the archives, so we have objects to list. ++ # TODO: could optimize this to just extract one archive. ++ whole_archive_flag_spec= ++ fi ++ if test -n "$whole_archive_flag_spec"; then ++ save_libobjs=$libobjs ++ eval libobjs=\"\$libobjs $whole_archive_flag_spec\" ++ test "X$libobjs" = "X " && libobjs= ++ else ++ gentop=$output_objdir/${outputname}x ++ func_append generated " $gentop" ++ ++ func_extract_archives $gentop $convenience ++ func_append libobjs " $func_extract_archives_result" ++ test "X$libobjs" = "X " && libobjs= ++ fi ++ fi ++ ++ if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then ++ eval flag=\"$thread_safe_flag_spec\" ++ func_append linker_flags " $flag" ++ fi ++ ++ # Make a backup of the uninstalled library when relinking ++ if test relink = "$opt_mode"; then ++ $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $? ++ fi ++ ++ # Do each of the archive commands. ++ if test yes = "$module" && test -n "$module_cmds"; then ++ if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then ++ eval test_cmds=\"$module_expsym_cmds\" ++ cmds=$module_expsym_cmds ++ else ++ eval test_cmds=\"$module_cmds\" ++ cmds=$module_cmds ++ fi ++ else ++ if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then ++ eval test_cmds=\"$archive_expsym_cmds\" ++ cmds=$archive_expsym_cmds ++ else ++ eval test_cmds=\"$archive_cmds\" ++ cmds=$archive_cmds ++ fi ++ fi ++ ++ if test : != "$skipped_export" && ++ func_len " $test_cmds" && ++ len=$func_len_result && ++ test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then ++ : ++ else ++ # The command line is too long to link in one step, link piecewise ++ # or, if using GNU ld and skipped_export is not :, use a linker ++ # script. ++ ++ # Save the value of $output and $libobjs because we want to ++ # use them later. If we have whole_archive_flag_spec, we ++ # want to use save_libobjs as it was before ++ # whole_archive_flag_spec was expanded, because we can't ++ # assume the linker understands whole_archive_flag_spec. ++ # This may have to be revisited, in case too many ++ # convenience libraries get linked in and end up exceeding ++ # the spec. ++ if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then ++ save_libobjs=$libobjs ++ fi ++ save_output=$output ++ func_basename "$output" ++ output_la=$func_basename_result ++ ++ # Clear the reloadable object creation command queue and ++ # initialize k to one. ++ test_cmds= ++ concat_cmds= ++ objlist= ++ last_robj= ++ k=1 ++ ++ if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then ++ output=$output_objdir/$output_la.lnkscript ++ func_verbose "creating GNU ld script: $output" ++ echo 'INPUT (' > $output ++ for obj in $save_libobjs ++ do ++ func_to_tool_file "$obj" ++ $ECHO "$func_to_tool_file_result" >> $output ++ done ++ echo ')' >> $output ++ func_append delfiles " $output" ++ func_to_tool_file "$output" ++ output=$func_to_tool_file_result ++ elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then ++ output=$output_objdir/$output_la.lnk ++ func_verbose "creating linker input file list: $output" ++ : > $output ++ set x $save_libobjs ++ shift ++ firstobj= ++ if test yes = "$compiler_needs_object"; then ++ firstobj="$1 " ++ shift ++ fi ++ for obj ++ do ++ func_to_tool_file "$obj" ++ $ECHO "$func_to_tool_file_result" >> $output ++ done ++ func_append delfiles " $output" ++ func_to_tool_file "$output" ++ output=$firstobj\"$file_list_spec$func_to_tool_file_result\" ++ else ++ if test -n "$save_libobjs"; then ++ func_verbose "creating reloadable object files..." ++ output=$output_objdir/$output_la-$k.$objext ++ eval test_cmds=\"$reload_cmds\" ++ func_len " $test_cmds" ++ len0=$func_len_result ++ len=$len0 ++ ++ # Loop over the list of objects to be linked. ++ for obj in $save_libobjs ++ do ++ func_len " $obj" ++ func_arith $len + $func_len_result ++ len=$func_arith_result ++ if test -z "$objlist" || ++ test "$len" -lt "$max_cmd_len"; then ++ func_append objlist " $obj" ++ else ++ # The command $test_cmds is almost too long, add a ++ # command to the queue. ++ if test 1 -eq "$k"; then ++ # The first file doesn't have a previous command to add. ++ reload_objs=$objlist ++ eval concat_cmds=\"$reload_cmds\" ++ else ++ # All subsequent reloadable object files will link in ++ # the last one created. ++ reload_objs="$objlist $last_robj" ++ eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\" ++ fi ++ last_robj=$output_objdir/$output_la-$k.$objext ++ func_arith $k + 1 ++ k=$func_arith_result ++ output=$output_objdir/$output_la-$k.$objext ++ objlist=" $obj" ++ func_len " $last_robj" ++ func_arith $len0 + $func_len_result ++ len=$func_arith_result ++ fi ++ done ++ # Handle the remaining objects by creating one last ++ # reloadable object file. All subsequent reloadable object ++ # files will link in the last one created. ++ test -z "$concat_cmds" || concat_cmds=$concat_cmds~ ++ reload_objs="$objlist $last_robj" ++ eval concat_cmds=\"\$concat_cmds$reload_cmds\" ++ if test -n "$last_robj"; then ++ eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\" ++ fi ++ func_append delfiles " $output" ++ ++ else ++ output= ++ fi ++ ++ ${skipped_export-false} && { ++ func_verbose "generating symbol list for '$libname.la'" ++ export_symbols=$output_objdir/$libname.exp ++ $opt_dry_run || $RM $export_symbols ++ libobjs=$output ++ # Append the command to create the export file. ++ test -z "$concat_cmds" || concat_cmds=$concat_cmds~ ++ eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\" ++ if test -n "$last_robj"; then ++ eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\" ++ fi ++ } ++ ++ test -n "$save_libobjs" && ++ func_verbose "creating a temporary reloadable object file: $output" ++ ++ # Loop through the commands generated above and execute them. ++ save_ifs=$IFS; IFS='~' ++ for cmd in $concat_cmds; do ++ IFS=$save_ifs ++ $opt_quiet || { ++ func_quote_for_expand "$cmd" ++ eval "func_echo $func_quote_for_expand_result" ++ } ++ $opt_dry_run || eval "$cmd" || { ++ lt_exit=$? ++ ++ # Restore the uninstalled library and exit ++ if test relink = "$opt_mode"; then ++ ( cd "$output_objdir" && \ ++ $RM "${realname}T" && \ ++ $MV "${realname}U" "$realname" ) ++ fi ++ ++ exit $lt_exit ++ } ++ done ++ IFS=$save_ifs ++ ++ if test -n "$export_symbols_regex" && ${skipped_export-false}; then ++ func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"' ++ func_show_eval '$MV "${export_symbols}T" "$export_symbols"' ++ fi ++ fi ++ ++ ${skipped_export-false} && { ++ if test -n "$export_symbols" && test -n "$include_expsyms"; then ++ tmp_export_symbols=$export_symbols ++ test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols ++ $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"' ++ fi ++ ++ if test -n "$orig_export_symbols"; then ++ # The given exports_symbols file has to be filtered, so filter it. ++ func_verbose "filter symbol list for '$libname.la' to tag DATA exports" ++ # FIXME: $output_objdir/$libname.filter potentially contains lots of ++ # 's' commands, which not all seds can handle. GNU sed should be fine ++ # though. Also, the filter scales superlinearly with the number of ++ # global variables. join(1) would be nice here, but unfortunately ++ # isn't a blessed tool. ++ $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter ++ func_append delfiles " $export_symbols $output_objdir/$libname.filter" ++ export_symbols=$output_objdir/$libname.def ++ $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols ++ fi ++ } ++ ++ libobjs=$output ++ # Restore the value of output. ++ output=$save_output ++ ++ if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then ++ eval libobjs=\"\$libobjs $whole_archive_flag_spec\" ++ test "X$libobjs" = "X " && libobjs= ++ fi ++ # Expand the library linking commands again to reset the ++ # value of $libobjs for piecewise linking. ++ ++ # Do each of the archive commands. ++ if test yes = "$module" && test -n "$module_cmds"; then ++ if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then ++ cmds=$module_expsym_cmds ++ else ++ cmds=$module_cmds ++ fi ++ else ++ if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then ++ cmds=$archive_expsym_cmds ++ else ++ cmds=$archive_cmds ++ fi ++ fi ++ fi ++ ++ if test -n "$delfiles"; then ++ # Append the command to remove temporary files to $cmds. ++ eval cmds=\"\$cmds~\$RM $delfiles\" ++ fi ++ ++ # Add any objects from preloaded convenience libraries ++ if test -n "$dlprefiles"; then ++ gentop=$output_objdir/${outputname}x ++ func_append generated " $gentop" ++ ++ func_extract_archives $gentop $dlprefiles ++ func_append libobjs " $func_extract_archives_result" ++ test "X$libobjs" = "X " && libobjs= ++ fi ++ ++ save_ifs=$IFS; IFS='~' ++ for cmd in $cmds; do ++ IFS=$sp$nl ++ eval cmd=\"$cmd\" ++ IFS=$save_ifs ++ $opt_quiet || { ++ func_quote_for_expand "$cmd" ++ eval "func_echo $func_quote_for_expand_result" ++ } ++ $opt_dry_run || eval "$cmd" || { ++ lt_exit=$? ++ ++ # Restore the uninstalled library and exit ++ if test relink = "$opt_mode"; then ++ ( cd "$output_objdir" && \ ++ $RM "${realname}T" && \ ++ $MV "${realname}U" "$realname" ) ++ fi ++ ++ exit $lt_exit ++ } ++ done ++ IFS=$save_ifs ++ ++ # Restore the uninstalled library and exit ++ if test relink = "$opt_mode"; then ++ $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $? ++ ++ if test -n "$convenience"; then ++ if test -z "$whole_archive_flag_spec"; then ++ func_show_eval '${RM}r "$gentop"' ++ fi ++ fi ++ ++ exit $EXIT_SUCCESS ++ fi ++ ++ # Create links to the real library. ++ for linkname in $linknames; do ++ if test "$realname" != "$linkname"; then ++ func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?' ++ fi ++ done ++ ++ # If -module or -export-dynamic was specified, set the dlname. ++ if test yes = "$module" || test yes = "$export_dynamic"; then ++ # On all known operating systems, these are identical. ++ dlname=$soname ++ fi ++ fi ++ ;; ++ ++ obj) ++ if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then ++ func_warning "'-dlopen' is ignored for objects" ++ fi ++ ++ case " $deplibs" in ++ *\ -l* | *\ -L*) ++ func_warning "'-l' and '-L' are ignored for objects" ;; ++ esac ++ ++ test -n "$rpath" && \ ++ func_warning "'-rpath' is ignored for objects" ++ ++ test -n "$xrpath" && \ ++ func_warning "'-R' is ignored for objects" ++ ++ test -n "$vinfo" && \ ++ func_warning "'-version-info' is ignored for objects" ++ ++ test -n "$release" && \ ++ func_warning "'-release' is ignored for objects" ++ ++ case $output in ++ *.lo) ++ test -n "$objs$old_deplibs" && \ ++ func_fatal_error "cannot build library object '$output' from non-libtool objects" ++ ++ libobj=$output ++ func_lo2o "$libobj" ++ obj=$func_lo2o_result ++ ;; ++ *) ++ libobj= ++ obj=$output ++ ;; ++ esac ++ ++ # Delete the old objects. ++ $opt_dry_run || $RM $obj $libobj ++ ++ # Objects from convenience libraries. This assumes ++ # single-version convenience libraries. Whenever we create ++ # different ones for PIC/non-PIC, this we'll have to duplicate ++ # the extraction. ++ reload_conv_objs= ++ gentop= ++ # if reload_cmds runs $LD directly, get rid of -Wl from ++ # whole_archive_flag_spec and hope we can get by with turning comma ++ # into space. ++ case $reload_cmds in ++ *\$LD[\ \$]*) wl= ;; ++ esac ++ if test -n "$convenience"; then ++ if test -n "$whole_archive_flag_spec"; then ++ eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\" ++ test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'` ++ reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags ++ else ++ gentop=$output_objdir/${obj}x ++ func_append generated " $gentop" ++ ++ func_extract_archives $gentop $convenience ++ reload_conv_objs="$reload_objs $func_extract_archives_result" ++ fi ++ fi ++ ++ # If we're not building shared, we need to use non_pic_objs ++ test yes = "$build_libtool_libs" || libobjs=$non_pic_objects ++ ++ # Create the old-style object. ++ reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP`' '$reload_conv_objs ++ ++ output=$obj ++ func_execute_cmds "$reload_cmds" 'exit $?' ++ ++ # Exit if we aren't doing a library object file. ++ if test -z "$libobj"; then ++ if test -n "$gentop"; then ++ func_show_eval '${RM}r "$gentop"' ++ fi ++ ++ exit $EXIT_SUCCESS ++ fi ++ ++ test yes = "$build_libtool_libs" || { ++ if test -n "$gentop"; then ++ func_show_eval '${RM}r "$gentop"' ++ fi ++ ++ # Create an invalid libtool object if no PIC, so that we don't ++ # accidentally link it into a program. ++ # $show "echo timestamp > $libobj" ++ # $opt_dry_run || eval "echo timestamp > $libobj" || exit $? ++ exit $EXIT_SUCCESS ++ } ++ ++ if test -n "$pic_flag" || test default != "$pic_mode"; then ++ # Only do commands if we really have different PIC objects. ++ reload_objs="$libobjs $reload_conv_objs" ++ output=$libobj ++ func_execute_cmds "$reload_cmds" 'exit $?' ++ fi ++ ++ if test -n "$gentop"; then ++ func_show_eval '${RM}r "$gentop"' ++ fi ++ ++ exit $EXIT_SUCCESS ++ ;; ++ ++ prog) ++ case $host in ++ *cygwin*) func_stripname '' '.exe' "$output" ++ output=$func_stripname_result.exe;; ++ esac ++ test -n "$vinfo" && \ ++ func_warning "'-version-info' is ignored for programs" ++ ++ test -n "$release" && \ ++ func_warning "'-release' is ignored for programs" ++ ++ $preload \ ++ && test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \ ++ && func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support." ++ ++ case $host in ++ *-*-rhapsody* | *-*-darwin1.[012]) ++ # On Rhapsody replace the C library is the System framework ++ compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'` ++ finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'` ++ ;; ++ esac ++ ++ case $host in ++ *-*-darwin*) ++ # Don't allow lazy linking, it breaks C++ global constructors ++ # But is supposedly fixed on 10.4 or later (yay!). ++ if test CXX = "$tagname"; then ++ case ${MACOSX_DEPLOYMENT_TARGET-10.0} in ++ 10.[0123]) ++ func_append compile_command " $wl-bind_at_load" ++ func_append finalize_command " $wl-bind_at_load" ++ ;; ++ esac ++ fi ++ # Time to change all our "foo.ltframework" stuff back to "-framework foo" ++ compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` ++ finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'` ++ ;; ++ esac ++ ++ ++ # move library search paths that coincide with paths to not yet ++ # installed libraries to the beginning of the library search list ++ new_libs= ++ for path in $notinst_path; do ++ case " $new_libs " in ++ *" -L$path/$objdir "*) ;; ++ *) ++ case " $compile_deplibs " in ++ *" -L$path/$objdir "*) ++ func_append new_libs " -L$path/$objdir" ;; ++ esac ++ ;; ++ esac ++ done ++ for deplib in $compile_deplibs; do ++ case $deplib in ++ -L*) ++ case " $new_libs " in ++ *" $deplib "*) ;; ++ *) func_append new_libs " $deplib" ;; ++ esac ++ ;; ++ *) func_append new_libs " $deplib" ;; ++ esac ++ done ++ compile_deplibs=$new_libs ++ ++ ++ func_append compile_command " $compile_deplibs" ++ func_append finalize_command " $finalize_deplibs" ++ ++ if test -n "$rpath$xrpath"; then ++ # If the user specified any rpath flags, then add them. ++ for libdir in $rpath $xrpath; do ++ # This is the magic to use -rpath. ++ case "$finalize_rpath " in ++ *" $libdir "*) ;; ++ *) func_append finalize_rpath " $libdir" ;; ++ esac ++ done ++ fi ++ ++ # Now hardcode the library paths ++ rpath= ++ hardcode_libdirs= ++ for libdir in $compile_rpath $finalize_rpath; do ++ if test -n "$hardcode_libdir_flag_spec"; then ++ if test -n "$hardcode_libdir_separator"; then ++ if test -z "$hardcode_libdirs"; then ++ hardcode_libdirs=$libdir ++ else ++ # Just accumulate the unique libdirs. ++ case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in ++ *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) ++ ;; ++ *) ++ func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" ++ ;; ++ esac ++ fi ++ else ++ eval flag=\"$hardcode_libdir_flag_spec\" ++ func_append rpath " $flag" ++ fi ++ elif test -n "$runpath_var"; then ++ case "$perm_rpath " in ++ *" $libdir "*) ;; ++ *) func_append perm_rpath " $libdir" ;; ++ esac ++ fi ++ case $host in ++ *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*) ++ testbindir=`$ECHO "$libdir" | $SED -e 's*/lib$*/bin*'` ++ case :$dllsearchpath: in ++ *":$libdir:"*) ;; ++ ::) dllsearchpath=$libdir;; ++ *) func_append dllsearchpath ":$libdir";; ++ esac ++ case :$dllsearchpath: in ++ *":$testbindir:"*) ;; ++ ::) dllsearchpath=$testbindir;; ++ *) func_append dllsearchpath ":$testbindir";; ++ esac ++ ;; ++ esac ++ done ++ # Substitute the hardcoded libdirs into the rpath. ++ if test -n "$hardcode_libdir_separator" && ++ test -n "$hardcode_libdirs"; then ++ libdir=$hardcode_libdirs ++ eval rpath=\" $hardcode_libdir_flag_spec\" ++ fi ++ compile_rpath=$rpath ++ ++ rpath= ++ hardcode_libdirs= ++ for libdir in $finalize_rpath; do ++ if test -n "$hardcode_libdir_flag_spec"; then ++ if test -n "$hardcode_libdir_separator"; then ++ if test -z "$hardcode_libdirs"; then ++ hardcode_libdirs=$libdir ++ else ++ # Just accumulate the unique libdirs. ++ case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in ++ *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*) ++ ;; ++ *) ++ func_append hardcode_libdirs "$hardcode_libdir_separator$libdir" ++ ;; ++ esac ++ fi ++ else ++ eval flag=\"$hardcode_libdir_flag_spec\" ++ func_append rpath " $flag" ++ fi ++ elif test -n "$runpath_var"; then ++ case "$finalize_perm_rpath " in ++ *" $libdir "*) ;; ++ *) func_append finalize_perm_rpath " $libdir" ;; ++ esac ++ fi ++ done ++ # Substitute the hardcoded libdirs into the rpath. ++ if test -n "$hardcode_libdir_separator" && ++ test -n "$hardcode_libdirs"; then ++ libdir=$hardcode_libdirs ++ eval rpath=\" $hardcode_libdir_flag_spec\" ++ fi ++ finalize_rpath=$rpath ++ ++ if test -n "$libobjs" && test yes = "$build_old_libs"; then ++ # Transform all the library objects into standard objects. ++ compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP` ++ finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP` ++ fi ++ ++ func_generate_dlsyms "$outputname" "@PROGRAM@" false ++ ++ # template prelinking step ++ if test -n "$prelink_cmds"; then ++ func_execute_cmds "$prelink_cmds" 'exit $?' ++ fi ++ ++ wrappers_required=: ++ case $host in ++ *cegcc* | *mingw32ce*) ++ # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway. ++ wrappers_required=false ++ ;; ++ *cygwin* | *mingw* ) ++ test yes = "$build_libtool_libs" || wrappers_required=false ++ ;; ++ *) ++ if test no = "$need_relink" || test yes != "$build_libtool_libs"; then ++ wrappers_required=false ++ fi ++ ;; ++ esac ++ $wrappers_required || { ++ # Replace the output file specification. ++ compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'` ++ link_command=$compile_command$compile_rpath ++ ++ # We have no uninstalled library dependencies, so finalize right now. ++ exit_status=0 ++ func_show_eval "$link_command" 'exit_status=$?' ++ ++ if test -n "$postlink_cmds"; then ++ func_to_tool_file "$output" ++ postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` ++ func_execute_cmds "$postlink_cmds" 'exit $?' ++ fi ++ ++ # Delete the generated files. ++ if test -f "$output_objdir/${outputname}S.$objext"; then ++ func_show_eval '$RM "$output_objdir/${outputname}S.$objext"' ++ fi ++ ++ exit $exit_status ++ } ++ ++ if test -n "$compile_shlibpath$finalize_shlibpath"; then ++ compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command" ++ fi ++ if test -n "$finalize_shlibpath"; then ++ finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command" ++ fi ++ ++ compile_var= ++ finalize_var= ++ if test -n "$runpath_var"; then ++ if test -n "$perm_rpath"; then ++ # We should set the runpath_var. ++ rpath= ++ for dir in $perm_rpath; do ++ func_append rpath "$dir:" ++ done ++ compile_var="$runpath_var=\"$rpath\$$runpath_var\" " ++ fi ++ if test -n "$finalize_perm_rpath"; then ++ # We should set the runpath_var. ++ rpath= ++ for dir in $finalize_perm_rpath; do ++ func_append rpath "$dir:" ++ done ++ finalize_var="$runpath_var=\"$rpath\$$runpath_var\" " ++ fi ++ fi ++ ++ if test yes = "$no_install"; then ++ # We don't need to create a wrapper script. ++ link_command=$compile_var$compile_command$compile_rpath ++ # Replace the output file specification. ++ link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'` ++ # Delete the old output file. ++ $opt_dry_run || $RM $output ++ # Link the executable and exit ++ func_show_eval "$link_command" 'exit $?' ++ ++ if test -n "$postlink_cmds"; then ++ func_to_tool_file "$output" ++ postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` ++ func_execute_cmds "$postlink_cmds" 'exit $?' ++ fi ++ ++ exit $EXIT_SUCCESS ++ fi ++ ++ case $hardcode_action,$fast_install in ++ relink,*) ++ # Fast installation is not supported ++ link_command=$compile_var$compile_command$compile_rpath ++ relink_command=$finalize_var$finalize_command$finalize_rpath ++ ++ func_warning "this platform does not like uninstalled shared libraries" ++ func_warning "'$output' will be relinked during installation" ++ ;; ++ *,yes) ++ link_command=$finalize_var$compile_command$finalize_rpath ++ relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'` ++ ;; ++ *,no) ++ link_command=$compile_var$compile_command$compile_rpath ++ relink_command=$finalize_var$finalize_command$finalize_rpath ++ ;; ++ *,needless) ++ link_command=$finalize_var$compile_command$finalize_rpath ++ relink_command= ++ ;; ++ esac ++ ++ # Replace the output file specification. ++ link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'` ++ ++ # Delete the old output files. ++ $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname ++ ++ func_show_eval "$link_command" 'exit $?' ++ ++ if test -n "$postlink_cmds"; then ++ func_to_tool_file "$output_objdir/$outputname" ++ postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'` ++ func_execute_cmds "$postlink_cmds" 'exit $?' ++ fi ++ ++ # Now create the wrapper script. ++ func_verbose "creating $output" ++ ++ # Quote the relink command for shipping. ++ if test -n "$relink_command"; then ++ # Preserve any variables that may affect compiler behavior ++ for var in $variables_saved_for_relink; do ++ if eval test -z \"\${$var+set}\"; then ++ relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" ++ elif eval var_value=\$$var; test -z "$var_value"; then ++ relink_command="$var=; export $var; $relink_command" ++ else ++ func_quote_for_eval "$var_value" ++ relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" ++ fi ++ done ++ relink_command="(cd `pwd`; $relink_command)" ++ relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` ++ fi ++ ++ # Only actually do things if not in dry run mode. ++ $opt_dry_run || { ++ # win32 will think the script is a binary if it has ++ # a .exe suffix, so we strip it off here. ++ case $output in ++ *.exe) func_stripname '' '.exe' "$output" ++ output=$func_stripname_result ;; ++ esac ++ # test for cygwin because mv fails w/o .exe extensions ++ case $host in ++ *cygwin*) ++ exeext=.exe ++ func_stripname '' '.exe' "$outputname" ++ outputname=$func_stripname_result ;; ++ *) exeext= ;; ++ esac ++ case $host in ++ *cygwin* | *mingw* ) ++ func_dirname_and_basename "$output" "" "." ++ output_name=$func_basename_result ++ output_path=$func_dirname_result ++ cwrappersource=$output_path/$objdir/lt-$output_name.c ++ cwrapper=$output_path/$output_name.exe ++ $RM $cwrappersource $cwrapper ++ trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15 ++ ++ func_emit_cwrapperexe_src > $cwrappersource ++ ++ # The wrapper executable is built using the $host compiler, ++ # because it contains $host paths and files. If cross- ++ # compiling, it, like the target executable, must be ++ # executed on the $host or under an emulation environment. ++ $opt_dry_run || { ++ $LTCC $LTCFLAGS -o $cwrapper $cwrappersource ++ $STRIP $cwrapper ++ } ++ ++ # Now, create the wrapper script for func_source use: ++ func_ltwrapper_scriptname $cwrapper ++ $RM $func_ltwrapper_scriptname_result ++ trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15 ++ $opt_dry_run || { ++ # note: this script will not be executed, so do not chmod. ++ if test "x$build" = "x$host"; then ++ $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result ++ else ++ func_emit_wrapper no > $func_ltwrapper_scriptname_result ++ fi ++ } ++ ;; ++ * ) ++ $RM $output ++ trap "$RM $output; exit $EXIT_FAILURE" 1 2 15 ++ ++ func_emit_wrapper no > $output ++ chmod +x $output ++ ;; ++ esac ++ } ++ exit $EXIT_SUCCESS ++ ;; ++ esac ++ ++ # See if we need to build an old-fashioned archive. ++ for oldlib in $oldlibs; do ++ ++ case $build_libtool_libs in ++ convenience) ++ oldobjs="$libobjs_save $symfileobj" ++ addlibs=$convenience ++ build_libtool_libs=no ++ ;; ++ module) ++ oldobjs=$libobjs_save ++ addlibs=$old_convenience ++ build_libtool_libs=no ++ ;; ++ *) ++ oldobjs="$old_deplibs $non_pic_objects" ++ $preload && test -f "$symfileobj" \ ++ && func_append oldobjs " $symfileobj" ++ addlibs=$old_convenience ++ ;; ++ esac ++ ++ if test -n "$addlibs"; then ++ gentop=$output_objdir/${outputname}x ++ func_append generated " $gentop" ++ ++ func_extract_archives $gentop $addlibs ++ func_append oldobjs " $func_extract_archives_result" ++ fi ++ ++ # Do each command in the archive commands. ++ if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then ++ cmds=$old_archive_from_new_cmds ++ else ++ ++ # Add any objects from preloaded convenience libraries ++ if test -n "$dlprefiles"; then ++ gentop=$output_objdir/${outputname}x ++ func_append generated " $gentop" ++ ++ func_extract_archives $gentop $dlprefiles ++ func_append oldobjs " $func_extract_archives_result" ++ fi ++ ++ # POSIX demands no paths to be encoded in archives. We have ++ # to avoid creating archives with duplicate basenames if we ++ # might have to extract them afterwards, e.g., when creating a ++ # static archive out of a convenience library, or when linking ++ # the entirety of a libtool archive into another (currently ++ # not supported by libtool). ++ if (for obj in $oldobjs ++ do ++ func_basename "$obj" ++ $ECHO "$func_basename_result" ++ done | sort | sort -uc >/dev/null 2>&1); then ++ : ++ else ++ echo "copying selected object files to avoid basename conflicts..." ++ gentop=$output_objdir/${outputname}x ++ func_append generated " $gentop" ++ func_mkdir_p "$gentop" ++ save_oldobjs=$oldobjs ++ oldobjs= ++ counter=1 ++ for obj in $save_oldobjs ++ do ++ func_basename "$obj" ++ objbase=$func_basename_result ++ case " $oldobjs " in ++ " ") oldobjs=$obj ;; ++ *[\ /]"$objbase "*) ++ while :; do ++ # Make sure we don't pick an alternate name that also ++ # overlaps. ++ newobj=lt$counter-$objbase ++ func_arith $counter + 1 ++ counter=$func_arith_result ++ case " $oldobjs " in ++ *[\ /]"$newobj "*) ;; ++ *) if test ! -f "$gentop/$newobj"; then break; fi ;; ++ esac ++ done ++ func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj" ++ func_append oldobjs " $gentop/$newobj" ++ ;; ++ *) func_append oldobjs " $obj" ;; ++ esac ++ done ++ fi ++ func_to_tool_file "$oldlib" func_convert_file_msys_to_w32 ++ tool_oldlib=$func_to_tool_file_result ++ eval cmds=\"$old_archive_cmds\" ++ ++ func_len " $cmds" ++ len=$func_len_result ++ if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then ++ cmds=$old_archive_cmds ++ elif test -n "$archiver_list_spec"; then ++ func_verbose "using command file archive linking..." ++ for obj in $oldobjs ++ do ++ func_to_tool_file "$obj" ++ $ECHO "$func_to_tool_file_result" ++ done > $output_objdir/$libname.libcmd ++ func_to_tool_file "$output_objdir/$libname.libcmd" ++ oldobjs=" $archiver_list_spec$func_to_tool_file_result" ++ cmds=$old_archive_cmds ++ else ++ # the command line is too long to link in one step, link in parts ++ func_verbose "using piecewise archive linking..." ++ save_RANLIB=$RANLIB ++ RANLIB=: ++ objlist= ++ concat_cmds= ++ save_oldobjs=$oldobjs ++ oldobjs= ++ # Is there a better way of finding the last object in the list? ++ for obj in $save_oldobjs ++ do ++ last_oldobj=$obj ++ done ++ eval test_cmds=\"$old_archive_cmds\" ++ func_len " $test_cmds" ++ len0=$func_len_result ++ len=$len0 ++ for obj in $save_oldobjs ++ do ++ func_len " $obj" ++ func_arith $len + $func_len_result ++ len=$func_arith_result ++ func_append objlist " $obj" ++ if test "$len" -lt "$max_cmd_len"; then ++ : ++ else ++ # the above command should be used before it gets too long ++ oldobjs=$objlist ++ if test "$obj" = "$last_oldobj"; then ++ RANLIB=$save_RANLIB ++ fi ++ test -z "$concat_cmds" || concat_cmds=$concat_cmds~ ++ eval concat_cmds=\"\$concat_cmds$old_archive_cmds\" ++ objlist= ++ len=$len0 ++ fi ++ done ++ RANLIB=$save_RANLIB ++ oldobjs=$objlist ++ if test -z "$oldobjs"; then ++ eval cmds=\"\$concat_cmds\" ++ else ++ eval cmds=\"\$concat_cmds~\$old_archive_cmds\" ++ fi ++ fi ++ fi ++ func_execute_cmds "$cmds" 'exit $?' ++ done ++ ++ test -n "$generated" && \ ++ func_show_eval "${RM}r$generated" ++ ++ # Now create the libtool archive. ++ case $output in ++ *.la) ++ old_library= ++ test yes = "$build_old_libs" && old_library=$libname.$libext ++ func_verbose "creating $output" ++ ++ # Preserve any variables that may affect compiler behavior ++ for var in $variables_saved_for_relink; do ++ if eval test -z \"\${$var+set}\"; then ++ relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command" ++ elif eval var_value=\$$var; test -z "$var_value"; then ++ relink_command="$var=; export $var; $relink_command" ++ else ++ func_quote_for_eval "$var_value" ++ relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command" ++ fi ++ done ++ # Quote the link command for shipping. ++ relink_command="(cd `pwd`; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)" ++ relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"` ++ if test yes = "$hardcode_automatic"; then ++ relink_command= ++ fi ++ ++ # Only create the output if not a dry run. ++ $opt_dry_run || { ++ for installed in no yes; do ++ if test yes = "$installed"; then ++ if test -z "$install_libdir"; then ++ break ++ fi ++ output=$output_objdir/${outputname}i ++ # Replace all uninstalled libtool libraries with the installed ones ++ newdependency_libs= ++ for deplib in $dependency_libs; do ++ case $deplib in ++ *.la) ++ func_basename "$deplib" ++ name=$func_basename_result ++ func_resolve_sysroot "$deplib" ++ eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result` ++ test -z "$libdir" && \ ++ func_fatal_error "'$deplib' is not a valid libtool archive" ++ func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name" ++ ;; ++ -L*) ++ func_stripname -L '' "$deplib" ++ func_replace_sysroot "$func_stripname_result" ++ func_append newdependency_libs " -L$func_replace_sysroot_result" ++ ;; ++ -R*) ++ func_stripname -R '' "$deplib" ++ func_replace_sysroot "$func_stripname_result" ++ func_append newdependency_libs " -R$func_replace_sysroot_result" ++ ;; ++ *) func_append newdependency_libs " $deplib" ;; ++ esac ++ done ++ dependency_libs=$newdependency_libs ++ newdlfiles= ++ ++ for lib in $dlfiles; do ++ case $lib in ++ *.la) ++ func_basename "$lib" ++ name=$func_basename_result ++ eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib` ++ test -z "$libdir" && \ ++ func_fatal_error "'$lib' is not a valid libtool archive" ++ func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name" ++ ;; ++ *) func_append newdlfiles " $lib" ;; ++ esac ++ done ++ dlfiles=$newdlfiles ++ newdlprefiles= ++ for lib in $dlprefiles; do ++ case $lib in ++ *.la) ++ # Only pass preopened files to the pseudo-archive (for ++ # eventual linking with the app. that links it) if we ++ # didn't already link the preopened objects directly into ++ # the library: ++ func_basename "$lib" ++ name=$func_basename_result ++ eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib` ++ test -z "$libdir" && \ ++ func_fatal_error "'$lib' is not a valid libtool archive" ++ func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name" ++ ;; ++ esac ++ done ++ dlprefiles=$newdlprefiles ++ else ++ newdlfiles= ++ for lib in $dlfiles; do ++ case $lib in ++ [\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;; ++ *) abs=`pwd`"/$lib" ;; ++ esac ++ func_append newdlfiles " $abs" ++ done ++ dlfiles=$newdlfiles ++ newdlprefiles= ++ for lib in $dlprefiles; do ++ case $lib in ++ [\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;; ++ *) abs=`pwd`"/$lib" ;; ++ esac ++ func_append newdlprefiles " $abs" ++ done ++ dlprefiles=$newdlprefiles ++ fi ++ $RM $output ++ # place dlname in correct position for cygwin ++ # In fact, it would be nice if we could use this code for all target ++ # systems that can't hard-code library paths into their executables ++ # and that have no shared library path variable independent of PATH, ++ # but it turns out we can't easily determine that from inspecting ++ # libtool variables, so we have to hard-code the OSs to which it ++ # applies here; at the moment, that means platforms that use the PE ++ # object format with DLL files. See the long comment at the top of ++ # tests/bindir.at for full details. ++ tdlname=$dlname ++ case $host,$output,$installed,$module,$dlname in ++ *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) ++ # If a -bindir argument was supplied, place the dll there. ++ if test -n "$bindir"; then ++ func_relative_path "$install_libdir" "$bindir" ++ tdlname=$func_relative_path_result/$dlname ++ else ++ # Otherwise fall back on heuristic. ++ tdlname=../bin/$dlname ++ fi ++ ;; ++ esac ++ $ECHO > $output "\ ++# $outputname - a libtool library file ++# Generated by $PROGRAM (GNU $PACKAGE) $VERSION ++# ++# Please DO NOT delete this file! ++# It is necessary for linking the library. ++ ++# The name that we can dlopen(3). ++dlname='$tdlname' ++ ++# Names of this library. ++library_names='$library_names' ++ ++# The name of the static archive. ++old_library='$old_library' ++ ++# Linker flags that cannot go in dependency_libs. ++inherited_linker_flags='$new_inherited_linker_flags' ++ ++# Libraries that this one depends upon. ++dependency_libs='$dependency_libs' ++ ++# Names of additional weak libraries provided by this library ++weak_library_names='$weak_libs' ++ ++# Version information for $libname. ++current=$current ++age=$age ++revision=$revision ++ ++# Is this an already installed library? ++installed=$installed ++ ++# Should we warn about portability when linking against -modules? ++shouldnotlink=$module ++ ++# Files to dlopen/dlpreopen ++dlopen='$dlfiles' ++dlpreopen='$dlprefiles' ++ ++# Directory that this library needs to be installed in: ++libdir='$install_libdir'" ++ if test no,yes = "$installed,$need_relink"; then ++ $ECHO >> $output "\ ++relink_command=\"$relink_command\"" ++ fi ++ done ++ } ++ ++ # Do a symbolic link so that the libtool archive can be found in ++ # LD_LIBRARY_PATH before the program is installed. ++ func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?' ++ ;; ++ esac ++ exit $EXIT_SUCCESS ++} ++ ++if test link = "$opt_mode" || test relink = "$opt_mode"; then ++ func_mode_link ${1+"$@"} ++fi ++ ++ ++# func_mode_uninstall arg... ++func_mode_uninstall () ++{ ++ $debug_cmd ++ ++ RM=$nonopt ++ files= ++ rmforce=false ++ exit_status=0 ++ ++ # This variable tells wrapper scripts just to set variables rather ++ # than running their programs. ++ libtool_install_magic=$magic ++ ++ for arg ++ do ++ case $arg in ++ -f) func_append RM " $arg"; rmforce=: ;; ++ -*) func_append RM " $arg" ;; ++ *) func_append files " $arg" ;; ++ esac ++ done ++ ++ test -z "$RM" && \ ++ func_fatal_help "you must specify an RM program" ++ ++ rmdirs= ++ ++ for file in $files; do ++ func_dirname "$file" "" "." ++ dir=$func_dirname_result ++ if test . = "$dir"; then ++ odir=$objdir ++ else ++ odir=$dir/$objdir ++ fi ++ func_basename "$file" ++ name=$func_basename_result ++ test uninstall = "$opt_mode" && odir=$dir ++ ++ # Remember odir for removal later, being careful to avoid duplicates ++ if test clean = "$opt_mode"; then ++ case " $rmdirs " in ++ *" $odir "*) ;; ++ *) func_append rmdirs " $odir" ;; ++ esac ++ fi ++ ++ # Don't error if the file doesn't exist and rm -f was used. ++ if { test -L "$file"; } >/dev/null 2>&1 || ++ { test -h "$file"; } >/dev/null 2>&1 || ++ test -f "$file"; then ++ : ++ elif test -d "$file"; then ++ exit_status=1 ++ continue ++ elif $rmforce; then ++ continue ++ fi ++ ++ rmfiles=$file ++ ++ case $name in ++ *.la) ++ # Possibly a libtool archive, so verify it. ++ if func_lalib_p "$file"; then ++ func_source $dir/$name ++ ++ # Delete the libtool libraries and symlinks. ++ for n in $library_names; do ++ func_append rmfiles " $odir/$n" ++ done ++ test -n "$old_library" && func_append rmfiles " $odir/$old_library" ++ ++ case $opt_mode in ++ clean) ++ case " $library_names " in ++ *" $dlname "*) ;; ++ *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;; ++ esac ++ test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i" ++ ;; ++ uninstall) ++ if test -n "$library_names"; then ++ # Do each command in the postuninstall commands. ++ func_execute_cmds "$postuninstall_cmds" '$rmforce || exit_status=1' ++ fi ++ ++ if test -n "$old_library"; then ++ # Do each command in the old_postuninstall commands. ++ func_execute_cmds "$old_postuninstall_cmds" '$rmforce || exit_status=1' ++ fi ++ # FIXME: should reinstall the best remaining shared library. ++ ;; ++ esac ++ fi ++ ;; ++ ++ *.lo) ++ # Possibly a libtool object, so verify it. ++ if func_lalib_p "$file"; then ++ ++ # Read the .lo file ++ func_source $dir/$name ++ ++ # Add PIC object to the list of files to remove. ++ if test -n "$pic_object" && test none != "$pic_object"; then ++ func_append rmfiles " $dir/$pic_object" ++ fi ++ ++ # Add non-PIC object to the list of files to remove. ++ if test -n "$non_pic_object" && test none != "$non_pic_object"; then ++ func_append rmfiles " $dir/$non_pic_object" ++ fi ++ fi ++ ;; ++ ++ *) ++ if test clean = "$opt_mode"; then ++ noexename=$name ++ case $file in ++ *.exe) ++ func_stripname '' '.exe' "$file" ++ file=$func_stripname_result ++ func_stripname '' '.exe' "$name" ++ noexename=$func_stripname_result ++ # $file with .exe has already been added to rmfiles, ++ # add $file without .exe ++ func_append rmfiles " $file" ++ ;; ++ esac ++ # Do a test to see if this is a libtool program. ++ if func_ltwrapper_p "$file"; then ++ if func_ltwrapper_executable_p "$file"; then ++ func_ltwrapper_scriptname "$file" ++ relink_command= ++ func_source $func_ltwrapper_scriptname_result ++ func_append rmfiles " $func_ltwrapper_scriptname_result" ++ else ++ relink_command= ++ func_source $dir/$noexename ++ fi ++ ++ # note $name still contains .exe if it was in $file originally ++ # as does the version of $file that was added into $rmfiles ++ func_append rmfiles " $odir/$name $odir/${name}S.$objext" ++ if test yes = "$fast_install" && test -n "$relink_command"; then ++ func_append rmfiles " $odir/lt-$name" ++ fi ++ if test "X$noexename" != "X$name"; then ++ func_append rmfiles " $odir/lt-$noexename.c" ++ fi ++ fi ++ fi ++ ;; ++ esac ++ func_show_eval "$RM $rmfiles" 'exit_status=1' ++ done ++ ++ # Try to remove the $objdir's in the directories where we deleted files ++ for dir in $rmdirs; do ++ if test -d "$dir"; then ++ func_show_eval "rmdir $dir >/dev/null 2>&1" ++ fi ++ done ++ ++ exit $exit_status ++} ++ ++if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then ++ func_mode_uninstall ${1+"$@"} ++fi ++ ++test -z "$opt_mode" && { ++ help=$generic_help ++ func_fatal_help "you must specify a MODE" ++} ++ ++test -z "$exec_cmd" && \ ++ func_fatal_help "invalid operation mode '$opt_mode'" ++ ++if test -n "$exec_cmd"; then ++ eval exec "$exec_cmd" ++ exit $EXIT_FAILURE ++fi ++ ++exit $exit_status ++ ++ ++# The TAGs below are defined such that we never get into a situation ++# where we disable both kinds of libraries. Given conflicting ++# choices, we go for a static library, that is the most portable, ++# since we can't tell whether shared libraries were disabled because ++# the user asked for that or because the platform doesn't support ++# them. This is particularly important on AIX, because we don't ++# support having both static and shared libraries enabled at the same ++# time on that platform, so we default to a shared-only configuration. ++# If a disable-shared tag is given, we'll fallback to a static-only ++# configuration. But we'll never go from static-only to shared-only. ++ ++# ### BEGIN LIBTOOL TAG CONFIG: disable-shared ++build_libtool_libs=no ++build_old_libs=yes ++# ### END LIBTOOL TAG CONFIG: disable-shared ++ ++# ### BEGIN LIBTOOL TAG CONFIG: disable-static ++build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac` ++# ### END LIBTOOL TAG CONFIG: disable-static ++ ++# Local Variables: ++# mode:shell-script ++# sh-indentation:2 ++# End: +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/missing +@@ -0,0 +1,215 @@ ++#! /bin/sh ++# Common wrapper for a few potentially missing GNU programs. ++ ++scriptversion=2013-10-28.13; # UTC ++ ++# Copyright (C) 1996-2014 Free Software Foundation, Inc. ++# Originally written by Fran,cois Pinard , 1996. ++ ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2, or (at your option) ++# any later version. ++ ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++ ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++ ++# As a special exception to the GNU General Public License, if you ++# distribute this file as part of a program that contains a ++# configuration script generated by Autoconf, you may include it under ++# the same distribution terms that you use for the rest of that program. ++ ++if test $# -eq 0; then ++ echo 1>&2 "Try '$0 --help' for more information" ++ exit 1 ++fi ++ ++case $1 in ++ ++ --is-lightweight) ++ # Used by our autoconf macros to check whether the available missing ++ # script is modern enough. ++ exit 0 ++ ;; ++ ++ --run) ++ # Back-compat with the calling convention used by older automake. ++ shift ++ ;; ++ ++ -h|--h|--he|--hel|--help) ++ echo "\ ++$0 [OPTION]... PROGRAM [ARGUMENT]... ++ ++Run 'PROGRAM [ARGUMENT]...', returning a proper advice when this fails due ++to PROGRAM being missing or too old. ++ ++Options: ++ -h, --help display this help and exit ++ -v, --version output version information and exit ++ ++Supported PROGRAM values: ++ aclocal autoconf autoheader autom4te automake makeinfo ++ bison yacc flex lex help2man ++ ++Version suffixes to PROGRAM as well as the prefixes 'gnu-', 'gnu', and ++'g' are ignored when checking the name. ++ ++Send bug reports to ." ++ exit $? ++ ;; ++ ++ -v|--v|--ve|--ver|--vers|--versi|--versio|--version) ++ echo "missing $scriptversion (GNU Automake)" ++ exit $? ++ ;; ++ ++ -*) ++ echo 1>&2 "$0: unknown '$1' option" ++ echo 1>&2 "Try '$0 --help' for more information" ++ exit 1 ++ ;; ++ ++esac ++ ++# Run the given program, remember its exit status. ++"$@"; st=$? ++ ++# If it succeeded, we are done. ++test $st -eq 0 && exit 0 ++ ++# Also exit now if we it failed (or wasn't found), and '--version' was ++# passed; such an option is passed most likely to detect whether the ++# program is present and works. ++case $2 in --version|--help) exit $st;; esac ++ ++# Exit code 63 means version mismatch. This often happens when the user ++# tries to use an ancient version of a tool on a file that requires a ++# minimum version. ++if test $st -eq 63; then ++ msg="probably too old" ++elif test $st -eq 127; then ++ # Program was missing. ++ msg="missing on your system" ++else ++ # Program was found and executed, but failed. Give up. ++ exit $st ++fi ++ ++perl_URL=http://www.perl.org/ ++flex_URL=http://flex.sourceforge.net/ ++gnu_software_URL=http://www.gnu.org/software ++ ++program_details () ++{ ++ case $1 in ++ aclocal|automake) ++ echo "The '$1' program is part of the GNU Automake package:" ++ echo "<$gnu_software_URL/automake>" ++ echo "It also requires GNU Autoconf, GNU m4 and Perl in order to run:" ++ echo "<$gnu_software_URL/autoconf>" ++ echo "<$gnu_software_URL/m4/>" ++ echo "<$perl_URL>" ++ ;; ++ autoconf|autom4te|autoheader) ++ echo "The '$1' program is part of the GNU Autoconf package:" ++ echo "<$gnu_software_URL/autoconf/>" ++ echo "It also requires GNU m4 and Perl in order to run:" ++ echo "<$gnu_software_URL/m4/>" ++ echo "<$perl_URL>" ++ ;; ++ esac ++} ++ ++give_advice () ++{ ++ # Normalize program name to check for. ++ normalized_program=`echo "$1" | sed ' ++ s/^gnu-//; t ++ s/^gnu//; t ++ s/^g//; t'` ++ ++ printf '%s\n' "'$1' is $msg." ++ ++ configure_deps="'configure.ac' or m4 files included by 'configure.ac'" ++ case $normalized_program in ++ autoconf*) ++ echo "You should only need it if you modified 'configure.ac'," ++ echo "or m4 files included by it." ++ program_details 'autoconf' ++ ;; ++ autoheader*) ++ echo "You should only need it if you modified 'acconfig.h' or" ++ echo "$configure_deps." ++ program_details 'autoheader' ++ ;; ++ automake*) ++ echo "You should only need it if you modified 'Makefile.am' or" ++ echo "$configure_deps." ++ program_details 'automake' ++ ;; ++ aclocal*) ++ echo "You should only need it if you modified 'acinclude.m4' or" ++ echo "$configure_deps." ++ program_details 'aclocal' ++ ;; ++ autom4te*) ++ echo "You might have modified some maintainer files that require" ++ echo "the 'autom4te' program to be rebuilt." ++ program_details 'autom4te' ++ ;; ++ bison*|yacc*) ++ echo "You should only need it if you modified a '.y' file." ++ echo "You may want to install the GNU Bison package:" ++ echo "<$gnu_software_URL/bison/>" ++ ;; ++ lex*|flex*) ++ echo "You should only need it if you modified a '.l' file." ++ echo "You may want to install the Fast Lexical Analyzer package:" ++ echo "<$flex_URL>" ++ ;; ++ help2man*) ++ echo "You should only need it if you modified a dependency" \ ++ "of a man page." ++ echo "You may want to install the GNU Help2man package:" ++ echo "<$gnu_software_URL/help2man/>" ++ ;; ++ makeinfo*) ++ echo "You should only need it if you modified a '.texi' file, or" ++ echo "any other file indirectly affecting the aspect of the manual." ++ echo "You might want to install the Texinfo package:" ++ echo "<$gnu_software_URL/texinfo/>" ++ echo "The spurious makeinfo call might also be the consequence of" ++ echo "using a buggy 'make' (AIX, DU, IRIX), in which case you might" ++ echo "want to install GNU make:" ++ echo "<$gnu_software_URL/make/>" ++ ;; ++ *) ++ echo "You might have modified some files without having the proper" ++ echo "tools for further handling them. Check the 'README' file, it" ++ echo "often tells you about the needed prerequisites for installing" ++ echo "this package. You may also peek at any GNU archive site, in" ++ echo "case some other package contains this missing '$1' program." ++ ;; ++ esac ++} ++ ++give_advice "$1" | sed -e '1s/^/WARNING: /' \ ++ -e '2,$s/^/ /' >&2 ++ ++# Propagate the correct exit status (expected to be 127 for a program ++# not found, 63 for a program that failed due to version mismatch). ++exit $st ++ ++# Local variables: ++# eval: (add-hook 'write-file-hooks 'time-stamp) ++# time-stamp-start: "scriptversion=" ++# time-stamp-format: "%:y-%02m-%02d.%02H" ++# time-stamp-time-zone: "UTC" ++# time-stamp-end: "; # UTC" ++# End: +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autoconf/test-driver +@@ -0,0 +1,148 @@ ++#! /bin/sh ++# test-driver - basic testsuite driver script. ++ ++scriptversion=2013-07-13.22; # UTC ++ ++# Copyright (C) 2011-2014 Free Software Foundation, Inc. ++# ++# This program is free software; you can redistribute it and/or modify ++# it under the terms of the GNU General Public License as published by ++# the Free Software Foundation; either version 2, or (at your option) ++# any later version. ++# ++# This program is distributed in the hope that it will be useful, ++# but WITHOUT ANY WARRANTY; without even the implied warranty of ++# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the ++# GNU General Public License for more details. ++# ++# You should have received a copy of the GNU General Public License ++# along with this program. If not, see . ++ ++# As a special exception to the GNU General Public License, if you ++# distribute this file as part of a program that contains a ++# configuration script generated by Autoconf, you may include it under ++# the same distribution terms that you use for the rest of that program. ++ ++# This file is maintained in Automake, please report ++# bugs to or send patches to ++# . ++ ++# Make unconditional expansion of undefined variables an error. This ++# helps a lot in preventing typo-related bugs. ++set -u ++ ++usage_error () ++{ ++ echo "$0: $*" >&2 ++ print_usage >&2 ++ exit 2 ++} ++ ++print_usage () ++{ ++ cat <$log_file 2>&1 ++estatus=$? ++ ++if test $enable_hard_errors = no && test $estatus -eq 99; then ++ tweaked_estatus=1 ++else ++ tweaked_estatus=$estatus ++fi ++ ++case $tweaked_estatus:$expect_failure in ++ 0:yes) col=$red res=XPASS recheck=yes gcopy=yes;; ++ 0:*) col=$grn res=PASS recheck=no gcopy=no;; ++ 77:*) col=$blu res=SKIP recheck=no gcopy=yes;; ++ 99:*) col=$mgn res=ERROR recheck=yes gcopy=yes;; ++ *:yes) col=$lgn res=XFAIL recheck=no gcopy=yes;; ++ *:*) col=$red res=FAIL recheck=yes gcopy=yes;; ++esac ++ ++# Report the test outcome and exit status in the logs, so that one can ++# know whether the test passed or failed simply by looking at the '.log' ++# file, without the need of also peaking into the corresponding '.trs' ++# file (automake bug#11814). ++echo "$res $test_name (exit status: $estatus)" >>$log_file ++ ++# Report outcome to console. ++echo "${col}${res}${std}: $test_name" ++ ++# Register the test result, and other relevant metadata. ++echo ":test-result: $res" > $trs_file ++echo ":global-test-result: $res" >> $trs_file ++echo ":recheck: $recheck" >> $trs_file ++echo ":copy-in-global-log: $gcopy" >> $trs_file ++ ++# Local Variables: ++# mode: shell-script ++# sh-indentation: 2 ++# eval: (add-hook 'write-file-hooks 'time-stamp) ++# time-stamp-start: "scriptversion=" ++# time-stamp-format: "%:y-%02m-%02d.%02H" ++# time-stamp-time-zone: "UTC" ++# time-stamp-end: "; # UTC" ++# End: +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/autogen.sh +@@ -0,0 +1,68 @@ ++#!/bin/sh ++ ++PATH=/usr/local/gnu-autotools/bin/:$PATH ++export PATH ++ ++# Start from one level above the build directory ++if [ -f version ]; then ++ cd .. ++fi ++ ++if [ \! -f build/version ]; then ++ echo "Can't find source directory" ++ exit 1 ++fi ++ ++# BSD make's "OBJDIR" support freaks out the automake-generated ++# Makefile. Effectively disable it. ++export MAKEOBJDIRPREFIX=/junk ++ ++# Start from the build directory, where the version file is located ++if [ -f build/version ]; then ++ cd build ++fi ++ ++if [ \! -f version ]; then ++ echo "Can't find version file" ++ exit 1 ++fi ++ ++# Update the build number in the 'version' file. ++# Separate number from additional alpha/beta/etc marker ++MARKER=`cat version | sed 's/[0-9.]//g'` ++# Bump the number ++VN=`cat version | sed 's/[^0-9.]//g'` ++# Build out the string. ++VS="$(($VN/1000000)).$(( ($VN/1000)%1000 )).$(( $VN%1000 ))$MARKER" ++ ++cd .. ++ ++# Clean up the source dir as much as we can. ++/bin/sh build/clean.sh ++ ++# Substitute the versions into Libarchive's archive.h and archive_entry.h ++perl -p -i -e "s/^(#define\tARCHIVE_VERSION_NUMBER).*/\$1 $VN/" libarchive/archive.h ++perl -p -i -e "s/^(#define\tARCHIVE_VERSION_NUMBER).*/\$1 $VN/" libarchive/archive_entry.h ++perl -p -i -e "s/^(#define\tARCHIVE_VERSION_ONLY_STRING).*/\$1 \"$VS\"/" libarchive/archive.h ++# Substitute versions into configure.ac as well ++perl -p -i -e 's/(m4_define\(\[LIBARCHIVE_VERSION_S\]),.*\)/$1,['"$VS"'])/' configure.ac ++perl -p -i -e 's/(m4_define\(\[LIBARCHIVE_VERSION_N\]),.*\)/$1,['"$VN"'])/' configure.ac ++ ++# Remove developer CFLAGS if a release build is being made ++if [ -n "${MAKE_LIBARCHIVE_RELEASE}" ]; then ++ perl -p -i -e "s/^(DEV_CFLAGS.*)/# \$1/" Makefile.am ++ perl -p -i -e 's/CMAKE_BUILD_TYPE "[A-Za-z]*"/CMAKE_BUILD_TYPE "Release"/' CMakeLists.txt ++fi ++ ++set -xe ++aclocal -I build/autoconf ++ ++# Note: --automake flag needed only for libtoolize from ++# libtool 1.5.x; in libtool 2.2.x it is a synonym for --quiet ++case `uname` in ++Darwin) glibtoolize --automake -c;; ++*) libtoolize --automake -c;; ++esac ++autoconf ++autoheader ++automake -a -c +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/bump-version.sh +@@ -0,0 +1,36 @@ ++#!/bin/sh +v ++ ++# Start from the build directory, where the version file is located ++if [ -f build/version ]; then ++ cd build ++fi ++ ++if [ \! -f version ]; then ++ echo "Can't find version file" ++ exit 1 ++fi ++ ++# Update the build number in the 'version' file. ++# Separate number from additional alpha/beta/etc marker ++MARKER=`cat version | sed 's/[0-9.]//g'` ++# Bump the number ++VN=`cat version | sed 's/[^0-9.]//g'` ++# Reassemble and write back out ++VN=$(($VN + 1)) ++rm -f version.old ++mv version version.old ++chmod +w version.old ++echo $VN$MARKER > version ++VS="$(($VN/1000000)).$(( ($VN/1000)%1000 )).$(( $VN%1000 ))$MARKER" ++cd .. ++ ++ANNOUNCE=`date +"%b %d, %Y:"`" libarchive $VS released" ++ ++echo $ANNOUNCE ++ ++# Add a version notice to NEWS ++mv NEWS NEWS.bak ++chmod +w NEWS.bak ++echo $ANNOUNCE >> NEWS ++echo >> NEWS ++cat NEWS.bak >> NEWS +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/clean.sh +@@ -0,0 +1,99 @@ ++#!/bin/sh ++ ++# ++# Attempt to remove as many generated files as we can. ++# Ideally, a well-used development sandbox would look like ++# a pristine checkout after running this script. ++# ++ ++if [ \! -f build/version ]; then ++ echo 'Must run the clean script from the top-level dir of the libarchive distribution' 1>&2 ++ exit 1 ++fi ++ ++# If we're on BSD, blow away the build dir under /usr/obj ++rm -rf /usr/obj`pwd` ++ ++# ++# Try to clean up a bit more... ++# ++ ++find . -name '*.So' | xargs rm -f ++find . -name '*.a' | xargs rm -f ++find . -name '*.la' | xargs rm -f ++find . -name '*.lo' | xargs rm -f ++find . -name '*.o' | xargs rm -f ++find . -name '*.orig' | xargs rm -f ++find . -name '*.po' | xargs rm -f ++find . -name '*.rej' | xargs rm -f ++find . -name '*~' | xargs rm -f ++find . -name '.depend' | xargs rm -f ++find . -name '.deps' | xargs rm -rf ++find . -name '.dirstamp' | xargs rm -f ++find . -name '.libs' | xargs rm -rf ++find . -name 'CMakeFiles' | xargs rm -rf ++find . -name 'cmake_install.cmake' | xargs rm -f ++find . -name 'CTestTestfile.cmake' | xargs rm -f ++ ++rm -rf Testing ++rm -rf autom4te.cache ++rm -rf bin ++rm -rf cmake.tmp ++rm -rf libarchive/Testing ++ ++rm -f CMakeCache.txt ++rm -f DartConfiguration.tcl ++rm -f Makefile ++rm -f Makefile.in ++rm -f aclocal.m4 ++rm -f bsdcpio ++rm -f bsdcpio_test ++rm -f bsdtar ++rm -f bsdtar_test ++rm -f build/autoconf/compile ++rm -f build/autoconf/config.guess ++rm -f build/autoconf/config.sub ++rm -f build/autoconf/depcomp ++rm -f build/autoconf/install-sh ++rm -f build/autoconf/libtool.m4 ++rm -f build/autoconf/ltmain.sh ++rm -f build/autoconf/ltoptions.m4 ++rm -f build/autoconf/ltsugar.m4 ++rm -f build/autoconf/ltversion.m4 ++rm -f build/autoconf/lt~obsolete.m4 ++rm -f build/autoconf/missing ++rm -f build/autoconf/test-driver ++rm -f build/pkgconfig/libarchive.pc ++rm -f build/version.old ++rm -f cat/test/list.h ++rm -f config.h ++rm -f config.h.in ++rm -f config.log ++rm -f config.status ++rm -f configure ++rm -f cpio/*.1.gz ++rm -f cpio/Makefile ++rm -f cpio/bsdcpio ++rm -f cpio/test/Makefile ++rm -f cpio/test/bsdcpio_test ++rm -f cpio/test/list.h ++rm -f doc/html/* ++rm -f doc/man/* ++rm -f doc/pdf/* ++rm -f doc/text/* ++rm -f doc/wiki/* ++rm -f libarchive/*.[35].gz ++rm -f libarchive/Makefile ++rm -f libarchive/libarchive.so* ++rm -f libarchive/test/Makefile ++rm -f libarchive/test/libarchive_test ++rm -f libarchive/test/list.h ++rm -f libarchive_test ++rm -f libtool ++rm -f stamp-h1 ++rm -f tar/*.1.gz ++rm -f tar/Makefile ++rm -f tar/bsdtar ++rm -f tar/test/Makefile ++rm -f tar/test/bsdtar_test ++rm -f tar/test/list.h +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/CheckFileOffsetBits.c +@@ -0,0 +1,14 @@ ++#include ++ ++#define KB ((off_t)1024) ++#define MB ((off_t)1024 * KB) ++#define GB ((off_t)1024 * MB) ++#define TB ((off_t)1024 * GB) ++int t2[(((64 * GB -1) % 671088649) == 268434537) ++ && (((TB - (64 * GB -1) + 255) % 1792151290) == 305159546)? 1: -1]; ++ ++int main() ++{ ++ ; ++ return 0; ++} +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/CheckFileOffsetBits.cmake +@@ -0,0 +1,44 @@ ++# - Check if _FILE_OFFSET_BITS macro needed for large files ++# CHECK_FILE_OFFSET_BITS () ++# ++# The following variables may be set before calling this macro to ++# modify the way the check is run: ++# ++# CMAKE_REQUIRED_FLAGS = string of compile command line flags ++# CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar) ++# CMAKE_REQUIRED_INCLUDES = list of include directories ++# Copyright (c) 2009, Michihiro NAKAJIMA ++# ++# Redistribution and use is allowed according to the terms of the BSD license. ++# For details see the accompanying COPYING-CMAKE-SCRIPTS file. ++ ++#INCLUDE(CheckCXXSourceCompiles) ++ ++GET_FILENAME_COMPONENT(_selfdir_CheckFileOffsetBits ++ "${CMAKE_CURRENT_LIST_FILE}" PATH) ++ ++MACRO (CHECK_FILE_OFFSET_BITS) ++ IF(NOT DEFINED _FILE_OFFSET_BITS) ++ MESSAGE(STATUS "Checking _FILE_OFFSET_BITS for large files") ++ TRY_COMPILE(__WITHOUT_FILE_OFFSET_BITS_64 ++ ${CMAKE_CURRENT_BINARY_DIR} ++ ${_selfdir_CheckFileOffsetBits}/CheckFileOffsetBits.c ++ COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS}) ++ IF(NOT __WITHOUT_FILE_OFFSET_BITS_64) ++ TRY_COMPILE(__WITH_FILE_OFFSET_BITS_64 ++ ${CMAKE_CURRENT_BINARY_DIR} ++ ${_selfdir_CheckFileOffsetBits}/CheckFileOffsetBits.c ++ COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} -D_FILE_OFFSET_BITS=64) ++ ENDIF(NOT __WITHOUT_FILE_OFFSET_BITS_64) ++ ++ IF(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64) ++ SET(_FILE_OFFSET_BITS 64 CACHE INTERNAL "_FILE_OFFSET_BITS macro needed for large files") ++ MESSAGE(STATUS "Checking _FILE_OFFSET_BITS for large files - needed") ++ ELSE(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64) ++ SET(_FILE_OFFSET_BITS "" CACHE INTERNAL "_FILE_OFFSET_BITS macro needed for large files") ++ MESSAGE(STATUS "Checking _FILE_OFFSET_BITS for large files - not needed") ++ ENDIF(NOT __WITHOUT_FILE_OFFSET_BITS_64 AND __WITH_FILE_OFFSET_BITS_64) ++ ENDIF(NOT DEFINED _FILE_OFFSET_BITS) ++ ++ENDMACRO (CHECK_FILE_OFFSET_BITS) ++ +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/CheckFuncs.cmake +@@ -0,0 +1,49 @@ ++# Check if the system has the specified function; treat glibc "stub" ++# functions as nonexistent: ++# CHECK_FUNCTION_EXISTS_GLIBC (FUNCTION FUNCVAR) ++# ++# FUNCTION - the function(s) where the prototype should be declared ++# FUNCVAR - variable to define if the function does exist ++# ++# In particular, this understands the glibc convention of ++# defining macros __stub_XXXX or __stub___XXXX if the function ++# does appear in the library but is merely a stub that does nothing. ++# By detecting this case, we can select alternate behavior on ++# platforms that don't support this functionality. ++# ++# The following variables may be set before calling this macro to ++# modify the way the check is run: ++# ++# CMAKE_REQUIRED_FLAGS = string of compile command line flags ++# CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar) ++# CMAKE_REQUIRED_INCLUDES = list of include directories ++# Copyright (c) 2009, Michihiro NAKAJIMA ++# ++# Redistribution and use is allowed according to the terms of the BSD license. ++# For details see the accompanying COPYING-CMAKE-SCRIPTS file. ++ ++INCLUDE(CheckFunctionExists) ++GET_FILENAME_COMPONENT(_selfdir_CheckFunctionExistsGlibc ++ "${CMAKE_CURRENT_LIST_FILE}" PATH) ++ ++MACRO (CHECK_FUNCTION_EXISTS_GLIBC _FUNC _FUNCVAR) ++ IF(NOT DEFINED ${_FUNCVAR}) ++ SET(CHECK_STUB_FUNC_1 "__stub_${_FUNC}") ++ SET(CHECK_STUB_FUNC_2 "__stub___${_FUNC}") ++ CONFIGURE_FILE( ${_selfdir_CheckFunctionExistsGlibc}/CheckFuncs_stub.c.in ++ ${CMAKE_CURRENT_BINARY_DIR}/cmake.tmp/CheckFuncs_stub.c IMMEDIATE) ++ TRY_COMPILE(__stub ++ ${CMAKE_CURRENT_BINARY_DIR} ++ ${CMAKE_CURRENT_BINARY_DIR}/cmake.tmp/CheckFuncs_stub.c ++ COMPILE_DEFINITIONS ${CMAKE_REQUIRED_DEFINITIONS} ++ CMAKE_FLAGS ++ -DCOMPILE_DEFINITIONS:STRING=${MACRO_CHECK_INCLUDE_FILE_FLAGS} ++ "${CHECK_INCLUDE_FILE_C_INCLUDE_DIRS}") ++ IF (__stub) ++ SET("${_FUNCVAR}" "" CACHE INTERNAL "Have function ${_FUNC}") ++ ELSE (__stub) ++ CHECK_FUNCTION_EXISTS("${_FUNC}" "${_FUNCVAR}") ++ ENDIF (__stub) ++ ENDIF(NOT DEFINED ${_FUNCVAR}) ++ENDMACRO (CHECK_FUNCTION_EXISTS_GLIBC) ++ +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/CheckFuncs_stub.c.in +@@ -0,0 +1,16 @@ ++#ifdef __STDC__ ++#include ++#else ++#include ++#endif ++ ++int ++main() ++{ ++#if defined ${CHECK_STUB_FUNC_1} || defined ${CHECK_STUB_FUNC_2} ++ return 0; ++#else ++this system have stub ++ return 0; ++#endif ++} +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/CheckHeaderDirent.cmake +@@ -0,0 +1,32 @@ ++# - Check if the system has the specified type ++# CHECK_HEADER_DIRENT (HEADER1 HEARDER2 ...) ++# ++# HEADER - the header(s) where the prototype should be declared ++# ++# The following variables may be set before calling this macro to ++# modify the way the check is run: ++# ++# CMAKE_REQUIRED_FLAGS = string of compile command line flags ++# CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar) ++# CMAKE_REQUIRED_INCLUDES = list of include directories ++# Copyright (c) 2009, Michihiro NAKAJIMA ++# ++# Redistribution and use is allowed according to the terms of the BSD license. ++# For details see the accompanying COPYING-CMAKE-SCRIPTS file. ++ ++ ++INCLUDE(CheckTypeExists) ++ ++MACRO (CHECK_HEADER_DIRENT) ++ CHECK_TYPE_EXISTS("DIR *" dirent.h HAVE_DIRENT_H) ++ IF(NOT HAVE_DIRENT_H) ++ CHECK_TYPE_EXISTS("DIR *" sys/ndir.h HAVE_SYS_NDIR_H) ++ IF(NOT HAVE_SYS_NDIR_H) ++ CHECK_TYPE_EXISTS("DIR *" ndir.h HAVE_NDIR_H) ++ IF(NOT HAVE_NDIR_H) ++ CHECK_TYPE_EXISTS("DIR *" sys/dir.h HAVE_SYS_DIR_H) ++ ENDIF(NOT HAVE_NDIR_H) ++ ENDIF(NOT HAVE_SYS_NDIR_H) ++ ENDIF(NOT HAVE_DIRENT_H) ++ENDMACRO (CHECK_HEADER_DIRENT) ++ +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/CheckTypeExists.cmake +@@ -0,0 +1,42 @@ ++# - Check if the system has the specified type ++# CHECK_TYPE_EXISTS (TYPE HEADER VARIABLE) ++# ++# TYPE - the name of the type or struct or class you are interested in ++# HEADER - the header(s) where the prototype should be declared ++# VARIABLE - variable to store the result ++# ++# The following variables may be set before calling this macro to ++# modify the way the check is run: ++# ++# CMAKE_REQUIRED_FLAGS = string of compile command line flags ++# CMAKE_REQUIRED_DEFINITIONS = list of macros to define (-DFOO=bar) ++# CMAKE_REQUIRED_INCLUDES = list of include directories ++# Copyright (c) 2009, Michihiro NAKAJIMA ++# Copyright (c) 2006, Alexander Neundorf, ++# ++# Redistribution and use is allowed according to the terms of the BSD license. ++# For details see the accompanying COPYING-CMAKE-SCRIPTS file. ++ ++ ++INCLUDE(CheckCSourceCompiles) ++ ++MACRO (CHECK_TYPE_EXISTS _TYPE _HEADER _RESULT) ++ SET(_INCLUDE_FILES) ++ FOREACH (it ${_HEADER}) ++ SET(_INCLUDE_FILES "${_INCLUDE_FILES}#include <${it}>\n") ++ ENDFOREACH (it) ++ ++ SET(_CHECK_TYPE_EXISTS_SOURCE_CODE " ++${_INCLUDE_FILES} ++int main() ++{ ++ static ${_TYPE} tmp; ++ if (sizeof(tmp)) ++ return 0; ++ return 0; ++} ++") ++ CHECK_C_SOURCE_COMPILES("${_CHECK_TYPE_EXISTS_SOURCE_CODE}" ${_RESULT}) ++ ++ENDMACRO (CHECK_TYPE_EXISTS) ++ +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/CreatePkgConfigFile.cmake +@@ -0,0 +1,33 @@ ++# - Generate a libarchive.pc like autotools for pkg-config ++# ++ ++# Set the required variables (we use the same input file as autotools) ++SET(prefix ${CMAKE_INSTALL_PREFIX}) ++SET(exec_prefix \${prefix}) ++SET(libdir \${exec_prefix}/lib) ++SET(includedir \${prefix}/include) ++# Now, this is not particularly pretty, nor is it terribly accurate... ++# Loop over all our additional libs ++FOREACH(mylib ${ADDITIONAL_LIBS}) ++ # Extract the filename from the absolute path ++ GET_FILENAME_COMPONENT(mylib_name ${mylib} NAME_WE) ++ # Strip the lib prefix ++ STRING(REGEX REPLACE "^lib" "" mylib_name ${mylib_name}) ++ # Append it to our LIBS string ++ SET(LIBS "${LIBS} -l${mylib_name}") ++ENDFOREACH() ++# libxml2 is easier, since it's already using pkg-config ++FOREACH(mylib ${PC_LIBXML_STATIC_LDFLAGS}) ++ SET(LIBS "${LIBS} ${mylib}") ++ENDFOREACH() ++# FIXME: The order of the libraries doesn't take dependencies into account, ++# thus there's a good chance it'll make some binutils versions unhappy... ++# This only affects Libs.private (looked up for static builds) though. ++CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/build/pkgconfig/libarchive.pc.in ++ ${CMAKE_CURRENT_BINARY_DIR}/build/pkgconfig/libarchive.pc ++ @ONLY) ++# And install it, of course ;). ++IF(ENABLE_INSTALL) ++ INSTALL(FILES ${CMAKE_CURRENT_BINARY_DIR}/build/pkgconfig/libarchive.pc ++ DESTINATION "lib/pkgconfig") ++ENDIF() +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/FindLibGCC.cmake +@@ -0,0 +1,22 @@ ++# - Find libgcc ++# Find the libgcc library. ++# ++# LIBGCC_LIBRARIES - List of libraries when using libgcc ++# LIBGCC_FOUND - True if libgcc found. ++ ++IF (LIBGCC_LIBRARY) ++ # Already in cache, be silent ++ SET(LIBGCC_FIND_QUIETLY TRUE) ++ENDIF (LIBGCC_LIBRARY) ++ ++FIND_LIBRARY(LIBGCC_LIBRARY NAMES gcc libgcc) ++ ++# handle the QUIETLY and REQUIRED arguments and set LIBGCC_FOUND to TRUE if ++# all listed variables are TRUE ++INCLUDE(FindPackageHandleStandardArgs) ++FIND_PACKAGE_HANDLE_STANDARD_ARGS(LIBGCC DEFAULT_MSG LIBGCC_LIBRARY) ++ ++IF(LIBGCC_FOUND) ++ SET(LIBGCC_LIBRARIES ${LIBGCC_LIBRARY}) ++ SET(HAVE_LIBGCC 1) ++ENDIF(LIBGCC_FOUND) +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/FindMbedTLS.cmake +@@ -0,0 +1,13 @@ ++find_path(MBEDTLS_INCLUDE_DIRS mbedtls/ssl.h) ++ ++find_library(MBEDTLS_LIBRARY mbedtls) ++find_library(MBEDX509_LIBRARY mbedx509) ++find_library(MBEDCRYPTO_LIBRARY mbedcrypto) ++ ++set(MBEDTLS_LIBRARIES "${MBEDTLS_LIBRARY}" "${MBEDX509_LIBRARY}" "${MBEDCRYPTO_LIBRARY}") ++ ++include(FindPackageHandleStandardArgs) ++find_package_handle_standard_args(MBEDTLS DEFAULT_MSG ++ MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARY MBEDX509_LIBRARY MBEDCRYPTO_LIBRARY) ++ ++mark_as_advanced(MBEDTLS_INCLUDE_DIRS MBEDTLS_LIBRARY MBEDX509_LIBRARY MBEDCRYPTO_LIBRARY) +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/FindNettle.cmake +@@ -0,0 +1,23 @@ ++# - Find Nettle ++# Find the Nettle include directory and library ++# ++# NETTLE_INCLUDE_DIR - where to find , etc. ++# NETTLE_LIBRARIES - List of libraries when using libnettle. ++# NETTLE_FOUND - True if libnettle found. ++ ++IF (NETTLE_INCLUDE_DIR) ++ # Already in cache, be silent ++ SET(NETTLE_FIND_QUIETLY TRUE) ++ENDIF (NETTLE_INCLUDE_DIR) ++ ++FIND_PATH(NETTLE_INCLUDE_DIR nettle/md5.h nettle/ripemd160.h nettle/sha.h) ++FIND_LIBRARY(NETTLE_LIBRARY NAMES nettle libnettle) ++ ++# handle the QUIETLY and REQUIRED arguments and set NETTLE_FOUND to TRUE if ++# all listed variables are TRUE ++INCLUDE(FindPackageHandleStandardArgs) ++FIND_PACKAGE_HANDLE_STANDARD_ARGS(NETTLE DEFAULT_MSG NETTLE_LIBRARY NETTLE_INCLUDE_DIR) ++ ++IF(NETTLE_FOUND) ++ SET(NETTLE_LIBRARIES ${NETTLE_LIBRARY}) ++ENDIF(NETTLE_FOUND) +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/FindPCREPOSIX.cmake +@@ -0,0 +1,34 @@ ++# - Find pcreposix ++# Find the native PCRE and PCREPOSIX include and libraries ++# ++# PCRE_INCLUDE_DIR - where to find pcreposix.h, etc. ++# PCREPOSIX_LIBRARIES - List of libraries when using libpcreposix. ++# PCRE_LIBRARIES - List of libraries when using libpcre. ++# PCREPOSIX_FOUND - True if libpcreposix found. ++# PCRE_FOUND - True if libpcre found. ++ ++IF (PCRE_INCLUDE_DIR) ++ # Already in cache, be silent ++ SET(PCRE_FIND_QUIETLY TRUE) ++ENDIF (PCRE_INCLUDE_DIR) ++ ++FIND_PATH(PCRE_INCLUDE_DIR pcreposix.h) ++FIND_LIBRARY(PCREPOSIX_LIBRARY NAMES pcreposix libpcreposix) ++FIND_LIBRARY(PCRE_LIBRARY NAMES pcre libpcre) ++ ++# handle the QUIETLY and REQUIRED arguments and set PCREPOSIX_FOUND to TRUE if ++# all listed variables are TRUE ++INCLUDE(FindPackageHandleStandardArgs) ++FIND_PACKAGE_HANDLE_STANDARD_ARGS(PCREPOSIX DEFAULT_MSG PCREPOSIX_LIBRARY PCRE_INCLUDE_DIR) ++FIND_PACKAGE_HANDLE_STANDARD_ARGS(PCRE DEFAULT_MSG PCRE_LIBRARY) ++ ++IF(PCREPOSIX_FOUND) ++ SET(PCREPOSIX_LIBRARIES ${PCREPOSIX_LIBRARY}) ++ SET(HAVE_LIBPCREPOSIX 1) ++ SET(HAVE_PCREPOSIX_H 1) ++ENDIF(PCREPOSIX_FOUND) ++ ++IF(PCRE_FOUND) ++ SET(PCRE_LIBRARIES ${PCRE_LIBRARY}) ++ SET(HAVE_LIBPCRE 1) ++ENDIF(PCRE_FOUND) +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/LibarchiveCodeCoverage.cmake +@@ -0,0 +1,68 @@ ++################################################################# ++# Adds a build target called "coverage" for code coverage. ++# ++# This compiles the code using special GCC flags, run the tests, ++# and then generates a nice HTML output. This new "coverage" make ++# target will only be available if you build using GCC in Debug ++# mode. If any of the required programs (lcov and genhtml) were ++# not found, a FATAL_ERROR message is printed. ++# ++# If not already done, this code will set ENABLE_TEST to ON. ++# ++# To build the code coverage and open it in your browser do this: ++# ++# mkdir debug ++# cd debug ++# cmake -DCMAKE_BUILD_TYPE=Debug -DENABLE_COVERAGE=ON .. ++# make -j4 ++# make coverage ++# xdg-open coverage/index.html ++################################################################# ++ ++# Find programs we need ++FIND_PROGRAM(LCOV_EXECUTABLE lcov DOC "Full path to lcov executable") ++FIND_PROGRAM(GENHTML_EXECUTABLE genhtml DOC "Full path to genhtml executable") ++MARK_AS_ADVANCED(LCOV_EXECUTABLE GENHTML_EXECUTABLE) ++ ++# Check, compiler, build types and programs are available ++IF(NOT CMAKE_COMPILER_IS_GNUCC) ++MESSAGE(FATAL_ERROR "Coverage can only be built on GCC") ++ELSEIF(NOT CMAKE_BUILD_TYPE STREQUAL "Debug") ++MESSAGE(FATAL_ERROR "Coverage can only be built in Debug mode") ++ELSEIF(NOT LCOV_EXECUTABLE) ++MESSAGE(FATAL_ERROR "lcov executable not found") ++ELSEIF(NOT GENHTML_EXECUTABLE) ++MESSAGE(FATAL_ERROR "genhtml executable not found") ++ENDIF(NOT CMAKE_COMPILER_IS_GNUCC) ++ ++# Enable testing if not already done ++SET(ENABLE_TEST ON) ++ ++################################################################# ++# Set special compiler and linker flags for test coverage ++################################################################# ++# 0. Enable debug: -g ++SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -g") ++# 1. Disable optimizations: -O0 ++SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -O0") ++# 2. Enable all kind of warnings: ++SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -Wall -W") ++# 3. Enable special coverage flag (HINT: --coverage is a synonym for -fprofile-arcs -ftest-coverage) ++SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} --coverage") ++SET(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} --coverage") ++SET(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage") ++################################################################# ++ ++ADD_CUSTOM_TARGET(coverage ++COMMAND ${CMAKE_COMMAND} -E echo "Beginning test coverage. Output is written to coverage.log." ++COMMAND ${CMAKE_COMMAND} -E echo "COVERAGE-STEP-1/5: Reset all execution counts to zero" ++COMMAND ${LCOV_EXECUTABLE} --directory . --zerocounters > coverage.log 2>&1 ++COMMAND ${CMAKE_COMMAND} -E echo "COVERAGE-STEP-2/5: Run testrunner" ++COMMAND ${CMAKE_CTEST_COMMAND} >> coverage.log 2>&1 ++COMMAND ${CMAKE_COMMAND} -E echo "COVERAGE-STEP-3/5: Collect coverage data" ++COMMAND ${LCOV_EXECUTABLE} --capture --directory . --output-file "./coverage.info" >> coverage.log 2>&1 ++COMMAND ${CMAKE_COMMAND} -E echo "COVERAGE-STEP-4/5: Generate HTML from coverage data" ++COMMAND ${GENHTML_EXECUTABLE} "coverage.info" --title="libarchive-${LIBARCHIVE_VERSION_STRING}" --show-details --legend --output-directory "./coverage" >> coverage.log 2>&1 ++COMMAND ${CMAKE_COMMAND} -E echo "COVERAGE-STEP-5/5: Open test coverage HTML output in browser: xdg-open ./coverage/index.html" ++COMMENT "Runs testrunner and generates coverage output (formats: .info and .html)") ++ +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/cmake/config.h.in +@@ -0,0 +1,1338 @@ ++/* config.h. Generated from build/cmake/config.h.in by cmake configure */ ++ ++/* ++ * Ensure we have C99-style int64_t, etc, all defined. ++ */ ++ ++/* First, we need to know if the system has already defined them. */ ++#cmakedefine HAVE_INT16_T ++#cmakedefine HAVE_INT32_T ++#cmakedefine HAVE_INT64_T ++#cmakedefine HAVE_INTMAX_T ++ ++#cmakedefine HAVE_UINT8_T ++#cmakedefine HAVE_UINT16_T ++#cmakedefine HAVE_UINT32_T ++#cmakedefine HAVE_UINT64_T ++#cmakedefine HAVE_UINTMAX_T ++ ++/* We might have the types we want under other spellings. */ ++#cmakedefine HAVE___INT64 ++#cmakedefine HAVE_U_INT64_T ++#cmakedefine HAVE_UNSIGNED___INT64 ++ ++/* The sizes of various standard integer types. */ ++@SIZE_OF_SHORT_CODE@ ++@SIZE_OF_INT_CODE@ ++@SIZE_OF_LONG_CODE@ ++@SIZE_OF_LONG_LONG_CODE@ ++@SIZE_OF_UNSIGNED_SHORT_CODE@ ++@SIZE_OF_UNSIGNED_CODE@ ++@SIZE_OF_UNSIGNED_LONG_CODE@ ++@SIZE_OF_UNSIGNED_LONG_LONG_CODE@ ++ ++/* ++ * If we lack int64_t, define it to the first of __int64, int, long, and long long ++ * that exists and is the right size. ++ */ ++#if !defined(HAVE_INT64_T) && defined(HAVE___INT64) ++typedef __int64 int64_t; ++#define HAVE_INT64_T ++#endif ++ ++#if !defined(HAVE_INT64_T) && SIZE_OF_INT == 8 ++typedef int int64_t; ++#define HAVE_INT64_T ++#endif ++ ++#if !defined(HAVE_INT64_T) && SIZE_OF_LONG == 8 ++typedef long int64_t; ++#define HAVE_INT64_T ++#endif ++ ++#if !defined(HAVE_INT64_T) && SIZE_OF_LONG_LONG == 8 ++typedef long long int64_t; ++#define HAVE_INT64_T ++#endif ++ ++#if !defined(HAVE_INT64_T) ++#error No 64-bit integer type was found. ++#endif ++ ++/* ++ * Similarly for int32_t ++ */ ++#if !defined(HAVE_INT32_T) && SIZE_OF_INT == 4 ++typedef int int32_t; ++#define HAVE_INT32_T ++#endif ++ ++#if !defined(HAVE_INT32_T) && SIZE_OF_LONG == 4 ++typedef long int32_t; ++#define HAVE_INT32_T ++#endif ++ ++#if !defined(HAVE_INT32_T) ++#error No 32-bit integer type was found. ++#endif ++ ++/* ++ * Similarly for int16_t ++ */ ++#if !defined(HAVE_INT16_T) && SIZE_OF_INT == 2 ++typedef int int16_t; ++#define HAVE_INT16_T ++#endif ++ ++#if !defined(HAVE_INT16_T) && SIZE_OF_SHORT == 2 ++typedef short int16_t; ++#define HAVE_INT16_T ++#endif ++ ++#if !defined(HAVE_INT16_T) ++#error No 16-bit integer type was found. ++#endif ++ ++/* ++ * Similarly for uint64_t ++ */ ++#if !defined(HAVE_UINT64_T) && defined(HAVE_UNSIGNED___INT64) ++typedef unsigned __int64 uint64_t; ++#define HAVE_UINT64_T ++#endif ++ ++#if !defined(HAVE_UINT64_T) && SIZE_OF_UNSIGNED == 8 ++typedef unsigned uint64_t; ++#define HAVE_UINT64_T ++#endif ++ ++#if !defined(HAVE_UINT64_T) && SIZE_OF_UNSIGNED_LONG == 8 ++typedef unsigned long uint64_t; ++#define HAVE_UINT64_T ++#endif ++ ++#if !defined(HAVE_UINT64_T) && SIZE_OF_UNSIGNED_LONG_LONG == 8 ++typedef unsigned long long uint64_t; ++#define HAVE_UINT64_T ++#endif ++ ++#if !defined(HAVE_UINT64_T) ++#error No 64-bit unsigned integer type was found. ++#endif ++ ++ ++/* ++ * Similarly for uint32_t ++ */ ++#if !defined(HAVE_UINT32_T) && SIZE_OF_UNSIGNED == 4 ++typedef unsigned uint32_t; ++#define HAVE_UINT32_T ++#endif ++ ++#if !defined(HAVE_UINT32_T) && SIZE_OF_UNSIGNED_LONG == 4 ++typedef unsigned long uint32_t; ++#define HAVE_UINT32_T ++#endif ++ ++#if !defined(HAVE_UINT32_T) ++#error No 32-bit unsigned integer type was found. ++#endif ++ ++/* ++ * Similarly for uint16_t ++ */ ++#if !defined(HAVE_UINT16_T) && SIZE_OF_UNSIGNED == 2 ++typedef unsigned uint16_t; ++#define HAVE_UINT16_T ++#endif ++ ++#if !defined(HAVE_UINT16_T) && SIZE_OF_UNSIGNED_SHORT == 2 ++typedef unsigned short uint16_t; ++#define HAVE_UINT16_T ++#endif ++ ++#if !defined(HAVE_UINT16_T) ++#error No 16-bit unsigned integer type was found. ++#endif ++ ++/* ++ * Similarly for uint8_t ++ */ ++#if !defined(HAVE_UINT8_T) ++typedef unsigned char uint8_t; ++#define HAVE_UINT8_T ++#endif ++ ++#if !defined(HAVE_UINT16_T) ++#error No 8-bit unsigned integer type was found. ++#endif ++ ++/* Define intmax_t and uintmax_t if they are not already defined. */ ++#if !defined(HAVE_INTMAX_T) ++typedef int64_t intmax_t; ++#endif ++ ++#if !defined(HAVE_UINTMAX_T) ++typedef uint64_t uintmax_t; ++#endif ++ ++/* Define ZLIB_WINAPI if zlib was built on Visual Studio. */ ++#cmakedefine ZLIB_WINAPI 1 ++ ++/* Darwin ACL support */ ++#cmakedefine ARCHIVE_ACL_DARWIN 1 ++ ++/* FreeBSD ACL support */ ++#cmakedefine ARCHIVE_ACL_FREEBSD 1 ++ ++/* FreeBSD NFSv4 ACL support */ ++#cmakedefine ARCHIVE_ACL_FREEBSD_NFS4 1 ++ ++/* Linux POSIX.1e ACL support via libacl */ ++#cmakedefine ARCHIVE_ACL_LIBACL 1 ++ ++/* Linux NFSv4 ACL support via librichacl */ ++#cmakedefine ARCHIVE_ACL_LIBRICHACL 1 ++ ++/* Solaris ACL support */ ++#cmakedefine ARCHIVE_ACL_SUNOS 1 ++ ++/* Solaris NFSv4 ACL support */ ++#cmakedefine ARCHIVE_ACL_SUNOS_NFS4 1 ++ ++/* MD5 via ARCHIVE_CRYPTO_MD5_LIBC supported. */ ++#cmakedefine ARCHIVE_CRYPTO_MD5_LIBC 1 ++ ++/* MD5 via ARCHIVE_CRYPTO_MD5_LIBSYSTEM supported. */ ++#cmakedefine ARCHIVE_CRYPTO_MD5_LIBSYSTEM 1 ++ ++/* MD5 via ARCHIVE_CRYPTO_MD5_NETTLE supported. */ ++#cmakedefine ARCHIVE_CRYPTO_MD5_NETTLE 1 ++ ++/* MD5 via ARCHIVE_CRYPTO_MD5_OPENSSL supported. */ ++#cmakedefine ARCHIVE_CRYPTO_MD5_OPENSSL 1 ++ ++/* MD5 via ARCHIVE_CRYPTO_MD5_WIN supported. */ ++#cmakedefine ARCHIVE_CRYPTO_MD5_WIN 1 ++ ++/* RMD160 via ARCHIVE_CRYPTO_RMD160_LIBC supported. */ ++#cmakedefine ARCHIVE_CRYPTO_RMD160_LIBC 1 ++ ++/* RMD160 via ARCHIVE_CRYPTO_RMD160_NETTLE supported. */ ++#cmakedefine ARCHIVE_CRYPTO_RMD160_NETTLE 1 ++ ++/* RMD160 via ARCHIVE_CRYPTO_RMD160_OPENSSL supported. */ ++#cmakedefine ARCHIVE_CRYPTO_RMD160_OPENSSL 1 ++ ++/* SHA1 via ARCHIVE_CRYPTO_SHA1_LIBC supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA1_LIBC 1 ++ ++/* SHA1 via ARCHIVE_CRYPTO_SHA1_LIBSYSTEM supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA1_LIBSYSTEM 1 ++ ++/* SHA1 via ARCHIVE_CRYPTO_SHA1_NETTLE supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA1_NETTLE 1 ++ ++/* SHA1 via ARCHIVE_CRYPTO_SHA1_OPENSSL supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA1_OPENSSL 1 ++ ++/* SHA1 via ARCHIVE_CRYPTO_SHA1_WIN supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA1_WIN 1 ++ ++/* SHA256 via ARCHIVE_CRYPTO_SHA256_LIBC supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA256_LIBC 1 ++ ++/* SHA256 via ARCHIVE_CRYPTO_SHA256_LIBC2 supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA256_LIBC2 1 ++ ++/* SHA256 via ARCHIVE_CRYPTO_SHA256_LIBC3 supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA256_LIBC3 1 ++ ++/* SHA256 via ARCHIVE_CRYPTO_SHA256_LIBSYSTEM supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA256_LIBSYSTEM 1 ++ ++/* SHA256 via ARCHIVE_CRYPTO_SHA256_NETTLE supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA256_NETTLE 1 ++ ++/* SHA256 via ARCHIVE_CRYPTO_SHA256_OPENSSL supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA256_OPENSSL 1 ++ ++/* SHA256 via ARCHIVE_CRYPTO_SHA256_WIN supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA256_WIN 1 ++ ++/* SHA384 via ARCHIVE_CRYPTO_SHA384_LIBC supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA384_LIBC 1 ++ ++/* SHA384 via ARCHIVE_CRYPTO_SHA384_LIBC2 supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA384_LIBC2 1 ++ ++/* SHA384 via ARCHIVE_CRYPTO_SHA384_LIBC3 supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA384_LIBC3 1 ++ ++/* SHA384 via ARCHIVE_CRYPTO_SHA384_LIBSYSTEM supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA384_LIBSYSTEM 1 ++ ++/* SHA384 via ARCHIVE_CRYPTO_SHA384_NETTLE supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA384_NETTLE 1 ++ ++/* SHA384 via ARCHIVE_CRYPTO_SHA384_OPENSSL supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA384_OPENSSL 1 ++ ++/* SHA384 via ARCHIVE_CRYPTO_SHA384_WIN supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA384_WIN 1 ++ ++/* SHA512 via ARCHIVE_CRYPTO_SHA512_LIBC supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA512_LIBC 1 ++ ++/* SHA512 via ARCHIVE_CRYPTO_SHA512_LIBC2 supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA512_LIBC2 1 ++ ++/* SHA512 via ARCHIVE_CRYPTO_SHA512_LIBC3 supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA512_LIBC3 1 ++ ++/* SHA512 via ARCHIVE_CRYPTO_SHA512_LIBSYSTEM supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA512_LIBSYSTEM 1 ++ ++/* SHA512 via ARCHIVE_CRYPTO_SHA512_NETTLE supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA512_NETTLE 1 ++ ++/* SHA512 via ARCHIVE_CRYPTO_SHA512_OPENSSL supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA512_OPENSSL 1 ++ ++/* SHA512 via ARCHIVE_CRYPTO_SHA512_WIN supported. */ ++#cmakedefine ARCHIVE_CRYPTO_SHA512_WIN 1 ++ ++/* AIX xattr support */ ++#cmakedefine ARCHIVE_XATTR_AIX 1 ++ ++/* Darwin xattr support */ ++#cmakedefine ARCHIVE_XATTR_DARWIN 1 ++ ++/* FreeBSD xattr support */ ++#cmakedefine ARCHIVE_XATTR_FREEBSD 1 ++ ++/* Linux xattr support */ ++#cmakedefine ARCHIVE_XATTR_LINUX 1 ++ ++/* Version number of bsdcpio */ ++#cmakedefine BSDCPIO_VERSION_STRING "${BSDCPIO_VERSION_STRING}" ++ ++/* Version number of bsdtar */ ++#cmakedefine BSDTAR_VERSION_STRING "${BSDTAR_VERSION_STRING}" ++ ++/* Version number of bsdcat */ ++#cmakedefine BSDCAT_VERSION_STRING "${BSDCAT_VERSION_STRING}" ++ ++/* Define to 1 if you have the `acl_create_entry' function. */ ++#cmakedefine HAVE_ACL_CREATE_ENTRY 1 ++ ++/* Define to 1 if you have the `acl_get_fd_np' function. */ ++#cmakedefine HAVE_ACL_GET_FD_NP 1 ++ ++/* Define to 1 if you have the `acl_get_link' function. */ ++#cmakedefine HAVE_ACL_GET_LINK 1 ++ ++/* Define to 1 if you have the `acl_get_link_np' function. */ ++#cmakedefine HAVE_ACL_GET_LINK_NP 1 ++ ++/* Define to 1 if you have the `acl_get_perm' function. */ ++#cmakedefine HAVE_ACL_GET_PERM 1 ++ ++/* Define to 1 if you have the `acl_get_perm_np' function. */ ++#cmakedefine HAVE_ACL_GET_PERM_NP 1 ++ ++/* Define to 1 if you have the `acl_init' function. */ ++#cmakedefine HAVE_ACL_INIT 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_ACL_LIBACL_H 1 ++ ++/* Define to 1 if the system has the type `acl_permset_t'. */ ++#cmakedefine HAVE_ACL_PERMSET_T 1 ++ ++/* Define to 1 if you have the `acl_set_fd' function. */ ++#cmakedefine HAVE_ACL_SET_FD 1 ++ ++/* Define to 1 if you have the `acl_set_fd_np' function. */ ++#cmakedefine HAVE_ACL_SET_FD_NP 1 ++ ++/* Define to 1 if you have the `acl_set_file' function. */ ++#cmakedefine HAVE_ACL_SET_FILE 1 ++ ++/* Define to 1 if you have the `arc4random_buf' function. */ ++#cmakedefine HAVE_ARC4RANDOM_BUF 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_ATTR_XATTR_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_BCRYPT_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_BSDXML_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_BZLIB_H 1 ++ ++/* Define to 1 if you have the `chflags' function. */ ++#cmakedefine HAVE_CHFLAGS 1 ++ ++/* Define to 1 if you have the `chown' function. */ ++#cmakedefine HAVE_CHOWN 1 ++ ++/* Define to 1 if you have the `chroot' function. */ ++#cmakedefine HAVE_CHROOT 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_COPYFILE_H 1 ++ ++/* Define to 1 if you have the `ctime_r' function. */ ++#cmakedefine HAVE_CTIME_R 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_CTYPE_H 1 ++ ++/* Define to 1 if you have the `cygwin_conv_path' function. */ ++#cmakedefine HAVE_CYGWIN_CONV_PATH 1 ++ ++/* Define to 1 if you have the declaration of `ACE_GETACL', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_ACE_GETACL 1 ++ ++/* Define to 1 if you have the declaration of `ACE_GETACLCNT', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_ACE_GETACLCNT 1 ++ ++/* Define to 1 if you have the declaration of `ACE_SETACL', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_ACE_SETACL 1 ++ ++/* Define to 1 if you have the declaration of `ACL_SYNCHRONIZE', and to 0 if ++ you don't. */ ++#cmakedefine HAVE_DECL_ACL_SYNCHRONIZE 1 ++ ++/* Define to 1 if you have the declaration of `ACL_TYPE_EXTENDED', and to 0 if ++ you don't. */ ++#cmakedefine HAVE_DECL_ACL_TYPE_EXTENDED 1 ++ ++/* Define to 1 if you have the declaration of `ACL_TYPE_NFS4', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_ACL_TYPE_NFS4 1 ++ ++/* Define to 1 if you have the declaration of `ACL_USER', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_ACL_USER 1 ++ ++/* Define to 1 if you have the declaration of `INT32_MAX', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_INT32_MAX 1 ++ ++/* Define to 1 if you have the declaration of `INT32_MIN', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_INT32_MIN 1 ++ ++/* Define to 1 if you have the declaration of `INT64_MAX', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_INT64_MAX 1 ++ ++/* Define to 1 if you have the declaration of `INT64_MIN', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_INT64_MIN 1 ++ ++/* Define to 1 if you have the declaration of `INTMAX_MAX', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_INTMAX_MAX 1 ++ ++/* Define to 1 if you have the declaration of `INTMAX_MIN', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_INTMAX_MIN 1 ++ ++/* Define to 1 if you have the declaration of `SETACL', and to 0 if you don't. ++ */ ++#cmakedefine HAVE_DECL_SETACL 1 ++ ++/* Define to 1 if you have the declaration of `SIZE_MAX', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_SIZE_MAX 1 ++ ++/* Define to 1 if you have the declaration of `SSIZE_MAX', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_SSIZE_MAX 1 ++ ++/* Define to 1 if you have the declaration of `strerror_r', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_STRERROR_R 1 ++ ++/* Define to 1 if you have the declaration of `UINT32_MAX', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_UINT32_MAX 1 ++ ++/* Define to 1 if you have the declaration of `UINT64_MAX', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_UINT64_MAX 1 ++ ++/* Define to 1 if you have the declaration of `UINTMAX_MAX', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_UINTMAX_MAX 1 ++ ++/* Define to 1 if you have the declaration of `XATTR_NOFOLLOW', and to 0 if ++ you don't. */ ++#cmakedefine HAVE_DECL_XATTR_NOFOLLOW 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_DIRECT_H 1 ++ ++/* Define to 1 if you have the header file, and it defines `DIR'. ++ */ ++#cmakedefine HAVE_DIRENT_H 1 ++ ++/* Define to 1 if you have the `dirfd' function. */ ++#cmakedefine HAVE_DIRFD 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_DLFCN_H 1 ++ ++/* Define to 1 if you don't have `vprintf' but do have `_doprnt.' */ ++#cmakedefine HAVE_DOPRNT 1 ++ ++/* Define to 1 if nl_langinfo supports D_MD_ORDER */ ++#cmakedefine HAVE_D_MD_ORDER 1 ++ ++/* A possible errno value for invalid file format errors */ ++#cmakedefine HAVE_EFTYPE 1 ++ ++/* A possible errno value for invalid file format errors */ ++#cmakedefine HAVE_EILSEQ 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_ERRNO_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_EXPAT_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_EXT2FS_EXT2_FS_H 1 ++ ++/* Define to 1 if you have the `extattr_get_file' function. */ ++#cmakedefine HAVE_EXTATTR_GET_FILE 1 ++ ++/* Define to 1 if you have the `extattr_list_file' function. */ ++#cmakedefine HAVE_EXTATTR_LIST_FILE 1 ++ ++/* Define to 1 if you have the `extattr_set_fd' function. */ ++#cmakedefine HAVE_EXTATTR_SET_FD 1 ++ ++/* Define to 1 if you have the `extattr_set_file' function. */ ++#cmakedefine HAVE_EXTATTR_SET_FILE 1 ++ ++/* Define to 1 if EXTATTR_NAMESPACE_USER is defined in sys/extattr.h. */ ++#cmakedefine HAVE_DECL_EXTATTR_NAMESPACE_USER 1 ++ ++/* Define to 1 if you have the declaration of `GETACL', and to 0 if you don't. ++ */ ++#cmakedefine HAVE_DECL_GETACL 1 ++ ++/* Define to 1 if you have the declaration of `GETACLCNT', and to 0 if you ++ don't. */ ++#cmakedefine HAVE_DECL_GETACLCNT 1 ++ ++/* Define to 1 if you have the `fchdir' function. */ ++#cmakedefine HAVE_FCHDIR 1 ++ ++/* Define to 1 if you have the `fchflags' function. */ ++#cmakedefine HAVE_FCHFLAGS 1 ++ ++/* Define to 1 if you have the `fchmod' function. */ ++#cmakedefine HAVE_FCHMOD 1 ++ ++/* Define to 1 if you have the `fchown' function. */ ++#cmakedefine HAVE_FCHOWN 1 ++ ++/* Define to 1 if you have the `fcntl' function. */ ++#cmakedefine HAVE_FCNTL 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_FCNTL_H 1 ++ ++/* Define to 1 if you have the `fdopendir' function. */ ++#cmakedefine HAVE_FDOPENDIR 1 ++ ++/* Define to 1 if you have the `fgetea' function. */ ++#cmakedefine HAVE_FGETEA 1 ++ ++/* Define to 1 if you have the `fgetxattr' function. */ ++#cmakedefine HAVE_FGETXATTR 1 ++ ++/* Define to 1 if you have the `flistea' function. */ ++#cmakedefine HAVE_FLISTEA 1 ++ ++/* Define to 1 if you have the `flistxattr' function. */ ++#cmakedefine HAVE_FLISTXATTR 1 ++ ++/* Define to 1 if you have the `fork' function. */ ++#cmakedefine HAVE_FORK 1 ++ ++/* Define to 1 if fseeko (and presumably ftello) exists and is declared. */ ++#cmakedefine HAVE_FSEEKO 1 ++ ++/* Define to 1 if you have the `fsetea' function. */ ++#cmakedefine HAVE_FSETEA 1 ++ ++/* Define to 1 if you have the `fsetxattr' function. */ ++#cmakedefine HAVE_FSETXATTR 1 ++ ++/* Define to 1 if you have the `fstat' function. */ ++#cmakedefine HAVE_FSTAT 1 ++ ++/* Define to 1 if you have the `fstatat' function. */ ++#cmakedefine HAVE_FSTATAT 1 ++ ++/* Define to 1 if you have the `fstatfs' function. */ ++#cmakedefine HAVE_FSTATFS 1 ++ ++/* Define to 1 if you have the `fstatvfs' function. */ ++#cmakedefine HAVE_FSTATVFS 1 ++ ++/* Define to 1 if you have the `ftruncate' function. */ ++#cmakedefine HAVE_FTRUNCATE 1 ++ ++/* Define to 1 if you have the `futimens' function. */ ++#cmakedefine HAVE_FUTIMENS 1 ++ ++/* Define to 1 if you have the `futimes' function. */ ++#cmakedefine HAVE_FUTIMES 1 ++ ++/* Define to 1 if you have the `futimesat' function. */ ++#cmakedefine HAVE_FUTIMESAT 1 ++ ++/* Define to 1 if you have the `getea' function. */ ++#cmakedefine HAVE_GETEA 1 ++ ++/* Define to 1 if you have the `geteuid' function. */ ++#cmakedefine HAVE_GETEUID 1 ++ ++/* Define to 1 if you have the `getgrgid_r' function. */ ++#cmakedefine HAVE_GETGRGID_R 1 ++ ++/* Define to 1 if you have the `getgrnam_r' function. */ ++#cmakedefine HAVE_GETGRNAM_R 1 ++ ++/* Define to 1 if you have the `getpid' function. */ ++#cmakedefine HAVE_GETPID 1 ++ ++/* Define to 1 if you have the `getpwnam_r' function. */ ++#cmakedefine HAVE_GETPWNAM_R 1 ++ ++/* Define to 1 if you have the `getpwuid_r' function. */ ++#cmakedefine HAVE_GETPWUID_R 1 ++ ++/* Define to 1 if you have the `getvfsbyname' function. */ ++#cmakedefine HAVE_GETVFSBYNAME 1 ++ ++/* Define to 1 if you have the `getxattr' function. */ ++#cmakedefine HAVE_GETXATTR 1 ++ ++/* Define to 1 if you have the `gmtime_r' function. */ ++#cmakedefine HAVE_GMTIME_R 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_GRP_H 1 ++ ++/* Define to 1 if you have the `iconv' function. */ ++#cmakedefine HAVE_ICONV 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_ICONV_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_INTTYPES_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_IO_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LANGINFO_H 1 ++ ++/* Define to 1 if you have the `lchflags' function. */ ++#cmakedefine HAVE_LCHFLAGS 1 ++ ++/* Define to 1 if you have the `lchmod' function. */ ++#cmakedefine HAVE_LCHMOD 1 ++ ++/* Define to 1 if you have the `lchown' function. */ ++#cmakedefine HAVE_LCHOWN 1 ++ ++/* Define to 1 if you have the `lgetea' function. */ ++#cmakedefine HAVE_LGETEA 1 ++ ++/* Define to 1 if you have the `lgetxattr' function. */ ++#cmakedefine HAVE_LGETXATTR 1 ++ ++/* Define to 1 if you have the `acl' library (-lacl). */ ++#cmakedefine HAVE_LIBACL 1 ++ ++/* Define to 1 if you have the `attr' library (-lattr). */ ++#cmakedefine HAVE_LIBATTR 1 ++ ++/* Define to 1 if you have the `bsdxml' library (-lbsdxml). */ ++#cmakedefine HAVE_LIBBSDXML 1 ++ ++/* Define to 1 if you have the `bz2' library (-lbz2). */ ++#cmakedefine HAVE_LIBBZ2 1 ++ ++/* Define to 1 if you have the `b2' library (-lb2). */ ++#cmakedefine HAVE_LIBB2 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_BLAKE2_H 1 ++ ++/* Define to 1 if you have the `charset' library (-lcharset). */ ++#cmakedefine HAVE_LIBCHARSET 1 ++ ++/* Define to 1 if you have the `crypto' library (-lcrypto). */ ++#cmakedefine HAVE_LIBCRYPTO 1 ++ ++/* Define to 1 if you have the `expat' library (-lexpat). */ ++#cmakedefine HAVE_LIBEXPAT 1 ++ ++/* Define to 1 if you have the `gcc' library (-lgcc). */ ++#cmakedefine HAVE_LIBGCC 1 ++ ++/* Define to 1 if you have the `lz4' library (-llz4). */ ++#cmakedefine HAVE_LIBLZ4 1 ++ ++/* Define to 1 if you have the `lzma' library (-llzma). */ ++#cmakedefine HAVE_LIBLZMA 1 ++ ++/* Define to 1 if you have the `lzmadec' library (-llzmadec). */ ++#cmakedefine HAVE_LIBLZMADEC 1 ++ ++/* Define to 1 if you have the `lzo2' library (-llzo2). */ ++#cmakedefine HAVE_LIBLZO2 1 ++ ++/* Define to 1 if you have the `mbedcrypto' library (-lmbedcrypto). */ ++#cmakedefine HAVE_LIBMBEDCRYPTO 1 ++ ++/* Define to 1 if you have the `nettle' library (-lnettle). */ ++#cmakedefine HAVE_LIBNETTLE 1 ++ ++/* Define to 1 if you have the `pcre' library (-lpcre). */ ++#cmakedefine HAVE_LIBPCRE 1 ++ ++/* Define to 1 if you have the `pcreposix' library (-lpcreposix). */ ++#cmakedefine HAVE_LIBPCREPOSIX 1 ++ ++/* Define to 1 if you have the `xml2' library (-lxml2). */ ++#cmakedefine HAVE_LIBXML2 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LIBXML_XMLREADER_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LIBXML_XMLWRITER_H 1 ++ ++/* Define to 1 if you have the `z' library (-lz). */ ++#cmakedefine HAVE_LIBZ 1 ++ ++/* Define to 1 if you have the `zstd' library (-lzstd). */ ++#cmakedefine HAVE_LIBZSTD 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LIMITS_H 1 ++ ++/* Define to 1 if you have the `link' function. */ ++#cmakedefine HAVE_LINK 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LINUX_FIEMAP_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LINUX_FS_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LINUX_MAGIC_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LINUX_TYPES_H 1 ++ ++/* Define to 1 if you have the `listea' function. */ ++#cmakedefine HAVE_LISTEA 1 ++ ++/* Define to 1 if you have the `listxattr' function. */ ++#cmakedefine HAVE_LISTXATTR 1 ++ ++/* Define to 1 if you have the `llistea' function. */ ++#cmakedefine HAVE_LLISTEA 1 ++ ++/* Define to 1 if you have the `llistxattr' function. */ ++#cmakedefine HAVE_LLISTXATTR 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LOCALCHARSET_H 1 ++ ++/* Define to 1 if you have the `locale_charset' function. */ ++#cmakedefine HAVE_LOCALE_CHARSET 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LOCALE_H 1 ++ ++/* Define to 1 if you have the `localtime_r' function. */ ++#cmakedefine HAVE_LOCALTIME_R 1 ++ ++/* Define to 1 if the system has the type `long long int'. */ ++#cmakedefine HAVE_LONG_LONG_INT 1 ++ ++/* Define to 1 if you have the `lsetea' function. */ ++#cmakedefine HAVE_LSETEA 1 ++ ++/* Define to 1 if you have the `lsetxattr' function. */ ++#cmakedefine HAVE_LSETXATTR 1 ++ ++/* Define to 1 if you have the `lstat' function. */ ++#cmakedefine HAVE_LSTAT 1 ++ ++/* Define to 1 if `lstat' has the bug that it succeeds when given the ++ zero-length file name argument. */ ++#cmakedefine HAVE_LSTAT_EMPTY_STRING_BUG 1 ++ ++/* Define to 1 if you have the `lutimes' function. */ ++#cmakedefine HAVE_LUTIMES 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LZ4HC_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LZ4_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LZMADEC_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LZMA_H 1 ++ ++/* Define to 1 if you have a working `lzma_stream_encoder_mt' function. */ ++#cmakedefine HAVE_LZMA_STREAM_ENCODER_MT 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LZO_LZO1X_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_LZO_LZOCONF_H 1 ++ ++/* Define to 1 if you have the `mbrtowc' function. */ ++#cmakedefine HAVE_MBRTOWC 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_MEMBERSHIP_H 1 ++ ++/* Define to 1 if you have the `memmove' function. */ ++#cmakedefine HAVE_MEMMOVE 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_MEMORY_H 1 ++ ++/* Define to 1 if you have the `mkdir' function. */ ++#cmakedefine HAVE_MKDIR 1 ++ ++/* Define to 1 if you have the `mkfifo' function. */ ++#cmakedefine HAVE_MKFIFO 1 ++ ++/* Define to 1 if you have the `mknod' function. */ ++#cmakedefine HAVE_MKNOD 1 ++ ++/* Define to 1 if you have the `mkstemp' function. */ ++#cmakedefine HAVE_MKSTEMP 1 ++ ++/* Define to 1 if you have the header file, and it defines `DIR'. */ ++#cmakedefine HAVE_NDIR_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_NETTLE_AES_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_NETTLE_HMAC_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_NETTLE_MD5_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_NETTLE_PBKDF2_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_NETTLE_RIPEMD160_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_NETTLE_SHA_H 1 ++ ++/* Define to 1 if you have the `nl_langinfo' function. */ ++#cmakedefine HAVE_NL_LANGINFO 1 ++ ++/* Define to 1 if you have the `openat' function. */ ++#cmakedefine HAVE_OPENAT 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_PATHS_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_PCREPOSIX_H 1 ++ ++/* Define to 1 if you have the `pipe' function. */ ++#cmakedefine HAVE_PIPE 1 ++ ++/* Define to 1 if you have the `PKCS5_PBKDF2_HMAC_SHA1' function. */ ++#cmakedefine HAVE_PKCS5_PBKDF2_HMAC_SHA1 1 ++ ++/* Define to 1 if you have the `poll' function. */ ++#cmakedefine HAVE_POLL 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_POLL_H 1 ++ ++/* Define to 1 if you have the `posix_spawnp' function. */ ++#cmakedefine HAVE_POSIX_SPAWNP 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_PROCESS_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_PTHREAD_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_PWD_H 1 ++ ++/* Define to 1 if you have the `readdir_r' function. */ ++#cmakedefine HAVE_READDIR_R 1 ++ ++/* Define to 1 if you have the `readlink' function. */ ++#cmakedefine HAVE_READLINK 1 ++ ++/* Define to 1 if you have the `readlinkat' function. */ ++#cmakedefine HAVE_READLINKAT 1 ++ ++/* Define to 1 if you have the `readpassphrase' function. */ ++#cmakedefine HAVE_READPASSPHRASE 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_READPASSPHRASE_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_REGEX_H 1 ++ ++/* Define to 1 if you have the `select' function. */ ++#cmakedefine HAVE_SELECT 1 ++ ++/* Define to 1 if you have the `setenv' function. */ ++#cmakedefine HAVE_SETENV 1 ++ ++/* Define to 1 if you have the `setlocale' function. */ ++#cmakedefine HAVE_SETLOCALE 1 ++ ++/* Define to 1 if you have the `sigaction' function. */ ++#cmakedefine HAVE_SIGACTION 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SIGNAL_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SPAWN_H 1 ++ ++/* Define to 1 if you have the `statfs' function. */ ++#cmakedefine HAVE_STATFS 1 ++ ++/* Define to 1 if you have the `statvfs' function. */ ++#cmakedefine HAVE_STATVFS 1 ++ ++/* Define to 1 if `stat' has the bug that it succeeds when given the ++ zero-length file name argument. */ ++#cmakedefine HAVE_STAT_EMPTY_STRING_BUG 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_STDARG_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_STDINT_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_STDLIB_H 1 ++ ++/* Define to 1 if you have the `strchr' function. */ ++#cmakedefine HAVE_STRCHR 1 ++ ++/* Define to 1 if you have the `strdup' function. */ ++#cmakedefine HAVE_STRDUP 1 ++ ++/* Define to 1 if you have the `strerror' function. */ ++#cmakedefine HAVE_STRERROR 1 ++ ++/* Define to 1 if you have the `strerror_r' function. */ ++#cmakedefine HAVE_STRERROR_R 1 ++ ++/* Define to 1 if you have the `strftime' function. */ ++#cmakedefine HAVE_STRFTIME 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_STRINGS_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_STRING_H 1 ++ ++/* Define to 1 if you have the `strrchr' function. */ ++#cmakedefine HAVE_STRRCHR 1 ++ ++/* Define to 1 if `f_namemax' is a member of `struct statfs'. */ ++#cmakedefine HAVE_STRUCT_STATFS_F_NAMEMAX 1 ++ ++/* Define to 1 if `f_iosize' is a member of `struct statvfs'. */ ++#cmakedefine HAVE_STRUCT_STATVFS_F_IOSIZE 1 ++ ++/* Define to 1 if `st_birthtime' is a member of `struct stat'. */ ++#cmakedefine HAVE_STRUCT_STAT_ST_BIRTHTIME 1 ++ ++/* Define to 1 if `st_birthtimespec.tv_nsec' is a member of `struct stat'. */ ++#cmakedefine HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC 1 ++ ++/* Define to 1 if `st_blksize' is a member of `struct stat'. */ ++#cmakedefine HAVE_STRUCT_STAT_ST_BLKSIZE 1 ++ ++/* Define to 1 if `st_flags' is a member of `struct stat'. */ ++#cmakedefine HAVE_STRUCT_STAT_ST_FLAGS 1 ++ ++/* Define to 1 if `st_mtimespec.tv_nsec' is a member of `struct stat'. */ ++#cmakedefine HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC 1 ++ ++/* Define to 1 if `st_mtime_n' is a member of `struct stat'. */ ++#cmakedefine HAVE_STRUCT_STAT_ST_MTIME_N 1 ++ ++/* Define to 1 if `st_mtime_usec' is a member of `struct stat'. */ ++#cmakedefine HAVE_STRUCT_STAT_ST_MTIME_USEC 1 ++ ++/* Define to 1 if `st_mtim.tv_nsec' is a member of `struct stat'. */ ++#cmakedefine HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC 1 ++ ++/* Define to 1 if `st_umtime' is a member of `struct stat'. */ ++#cmakedefine HAVE_STRUCT_STAT_ST_UMTIME 1 ++ ++/* Define to 1 if `tm_gmtoff' is a member of `struct tm'. */ ++#cmakedefine HAVE_STRUCT_TM_TM_GMTOFF 1 ++ ++/* Define to 1 if `__tm_gmtoff' is a member of `struct tm'. */ ++#cmakedefine HAVE_STRUCT_TM___TM_GMTOFF 1 ++ ++/* Define to 1 if you have `struct vfsconf'. */ ++#cmakedefine HAVE_STRUCT_VFSCONF 1 ++ ++/* Define to 1 if you have `struct xvfsconf'. */ ++#cmakedefine HAVE_STRUCT_XVFSCONF 1 ++ ++/* Define to 1 if you have the `symlink' function. */ ++#cmakedefine HAVE_SYMLINK 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_ACL_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_CDEFS_H 1 ++ ++/* Define to 1 if you have the header file, and it defines `DIR'. ++ */ ++#cmakedefine HAVE_SYS_DIR_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_EA_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_EXTATTR_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_IOCTL_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_MKDEV_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_MOUNT_H 1 ++ ++/* Define to 1 if you have the header file, and it defines `DIR'. ++ */ ++#cmakedefine HAVE_SYS_NDIR_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_PARAM_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_POLL_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_RICHACL_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_SELECT_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_STATFS_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_STATVFS_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_STAT_H 1 ++ ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_SYSMACROS_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_TIME_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_TYPES_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_UTIME_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_UTSNAME_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_VFS_H 1 ++ ++/* Define to 1 if you have that is POSIX.1 compatible. */ ++#cmakedefine HAVE_SYS_WAIT_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_SYS_XATTR_H 1 ++ ++/* Define to 1 if you have the `timegm' function. */ ++#cmakedefine HAVE_TIMEGM 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_TIME_H 1 ++ ++/* Define to 1 if you have the `tzset' function. */ ++#cmakedefine HAVE_TZSET 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_UNISTD_H 1 ++ ++/* Define to 1 if you have the `unlinkat' function. */ ++#cmakedefine HAVE_UNLINKAT 1 ++ ++/* Define to 1 if you have the `unsetenv' function. */ ++#cmakedefine HAVE_UNSETENV 1 ++ ++/* Define to 1 if the system has the type `unsigned long long'. */ ++#cmakedefine HAVE_UNSIGNED_LONG_LONG 1 ++ ++/* Define to 1 if the system has the type `unsigned long long int'. */ ++#cmakedefine HAVE_UNSIGNED_LONG_LONG_INT 1 ++ ++/* Define to 1 if you have the `utime' function. */ ++#cmakedefine HAVE_UTIME 1 ++ ++/* Define to 1 if you have the `utimensat' function. */ ++#cmakedefine HAVE_UTIMENSAT 1 ++ ++/* Define to 1 if you have the `utimes' function. */ ++#cmakedefine HAVE_UTIMES 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_UTIME_H 1 ++ ++/* Define to 1 if you have the `vfork' function. */ ++#cmakedefine HAVE_VFORK 1 ++ ++/* Define to 1 if you have the `vprintf' function. */ ++#cmakedefine HAVE_VPRINTF 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_WCHAR_H 1 ++ ++/* Define to 1 if the system has the type `wchar_t'. */ ++#cmakedefine HAVE_WCHAR_T 1 ++ ++/* Define to 1 if you have the `wcrtomb' function. */ ++#cmakedefine HAVE_WCRTOMB 1 ++ ++/* Define to 1 if you have the `wcscmp' function. */ ++#cmakedefine HAVE_WCSCMP 1 ++ ++/* Define to 1 if you have the `wcscpy' function. */ ++#cmakedefine HAVE_WCSCPY 1 ++ ++/* Define to 1 if you have the `wcslen' function. */ ++#cmakedefine HAVE_WCSLEN 1 ++ ++/* Define to 1 if you have the `wctomb' function. */ ++#cmakedefine HAVE_WCTOMB 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_WCTYPE_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_WINCRYPT_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_WINDOWS_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_WINIOCTL_H 1 ++ ++/* Define to 1 if you have _CrtSetReportMode in */ ++#cmakedefine HAVE__CrtSetReportMode 1 ++ ++/* Define to 1 if you have the `wmemcmp' function. */ ++#cmakedefine HAVE_WMEMCMP 1 ++ ++/* Define to 1 if you have the `wmemcpy' function. */ ++#cmakedefine HAVE_WMEMCPY 1 ++ ++/* Define to 1 if you have the `wmemmove' function. */ ++#cmakedefine HAVE_WMEMMOVE 1 ++ ++/* Define to 1 if you have a working EXT2_IOC_GETFLAGS */ ++#cmakedefine HAVE_WORKING_EXT2_IOC_GETFLAGS 1 ++ ++/* Define to 1 if you have a working FS_IOC_GETFLAGS */ ++#cmakedefine HAVE_WORKING_FS_IOC_GETFLAGS 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_ZLIB_H 1 ++ ++/* Define to 1 if you have the header file. */ ++#cmakedefine HAVE_ZSTD_H 1 ++ ++/* Define to 1 if you have the `_ctime64_s' function. */ ++#cmakedefine HAVE__CTIME64_S 1 ++ ++/* Define to 1 if you have the `_fseeki64' function. */ ++#cmakedefine HAVE__FSEEKI64 1 ++ ++/* Define to 1 if you have the `_get_timezone' function. */ ++#cmakedefine HAVE__GET_TIMEZONE 1 ++ ++/* Define to 1 if you have the `_gmtime64_s' function. */ ++#cmakedefine HAVE__GMTIME64_S 1 ++ ++/* Define to 1 if you have the `_localtime64_s' function. */ ++#cmakedefine HAVE__LOCALTIME64_S 1 ++ ++/* Define to 1 if you have the `_mkgmtime64' function. */ ++#cmakedefine HAVE__MKGMTIME64 1 ++ ++/* Define as const if the declaration of iconv() needs const. */ ++#define ICONV_CONST ${ICONV_CONST} ++ ++/* Version number of libarchive as a single integer */ ++#cmakedefine LIBARCHIVE_VERSION_NUMBER "${LIBARCHIVE_VERSION_NUMBER}" ++ ++/* Version number of libarchive */ ++#cmakedefine LIBARCHIVE_VERSION_STRING "${LIBARCHIVE_VERSION_STRING}" ++ ++/* Define to 1 if `lstat' dereferences a symlink specified with a trailing ++ slash. */ ++#cmakedefine LSTAT_FOLLOWS_SLASHED_SYMLINK 1 ++ ++/* Define to 1 if `major', `minor', and `makedev' are declared in . ++ */ ++#cmakedefine MAJOR_IN_MKDEV 1 ++ ++/* Define to 1 if `major', `minor', and `makedev' are declared in ++ . */ ++#cmakedefine MAJOR_IN_SYSMACROS 1 ++ ++/* Define to 1 if your C compiler doesn't accept -c and -o together. */ ++#cmakedefine NO_MINUS_C_MINUS_O 1 ++ ++/* The size of `wchar_t', as computed by sizeof. */ ++#cmakedefine SIZEOF_WCHAR_T ${SIZEOF_WCHAR_T} ++ ++/* Define to 1 if strerror_r returns char *. */ ++#cmakedefine STRERROR_R_CHAR_P 1 ++ ++/* Define to 1 if you can safely include both and . */ ++#cmakedefine TIME_WITH_SYS_TIME 1 ++ ++/* ++ * Some platform requires a macro to use extension functions. ++ */ ++#cmakedefine SAFE_TO_DEFINE_EXTENSIONS 1 ++#ifdef SAFE_TO_DEFINE_EXTENSIONS ++/* Enable extensions on AIX 3, Interix. */ ++#ifndef _ALL_SOURCE ++# define _ALL_SOURCE 1 ++#endif ++/* Enable GNU extensions on systems that have them. */ ++#ifndef _GNU_SOURCE ++# define _GNU_SOURCE 1 ++#endif ++/* Enable threading extensions on Solaris. */ ++#ifndef _POSIX_PTHREAD_SEMANTICS ++# define _POSIX_PTHREAD_SEMANTICS 1 ++#endif ++/* Enable extensions on HP NonStop. */ ++#ifndef _TANDEM_SOURCE ++# define _TANDEM_SOURCE 1 ++#endif ++/* Enable general extensions on Solaris. */ ++#ifndef __EXTENSIONS__ ++# define __EXTENSIONS__ 1 ++#endif ++#endif /* SAFE_TO_DEFINE_EXTENSIONS */ ++ ++/* Version number of package */ ++#cmakedefine VERSION "${VERSION}" ++ ++/* Number of bits in a file offset, on hosts where this is settable. */ ++#cmakedefine _FILE_OFFSET_BITS ${_FILE_OFFSET_BITS} ++ ++/* Define to 1 to make fseeko visible on some hosts (e.g. glibc 2.2). */ ++#cmakedefine _LARGEFILE_SOURCE 1 ++ ++/* Define for large files, on AIX-style hosts. */ ++#cmakedefine _LARGE_FILES ${_LARGE_FILES} ++ ++/* Define to control Windows SDK version */ ++#ifndef NTDDI_VERSION ++#cmakedefine NTDDI_VERSION ${NTDDI_VERSION} ++#endif // NTDDI_VERSION ++ ++#ifndef _WIN32_WINNT ++#cmakedefine _WIN32_WINNT ${_WIN32_WINNT} ++#endif // _WIN32_WINNT ++ ++#ifndef WINVER ++#cmakedefine WINVER ${WINVER} ++#endif // WINVER ++ ++/* Define to empty if `const' does not conform to ANSI C. */ ++#cmakedefine const ${const} ++ ++/* Define to `int' if doesn't define. */ ++#cmakedefine gid_t ${gid_t} ++ ++/* Define to `unsigned long' if does not define. */ ++#cmakedefine id_t ${id_t} ++ ++/* Define to `int' if does not define. */ ++#cmakedefine mode_t ${mode_t} ++ ++/* Define to `long long' if does not define. */ ++#cmakedefine off_t ${off_t} ++ ++/* Define to `int' if doesn't define. */ ++#cmakedefine pid_t ${pid_t} ++ ++/* Define to `unsigned int' if does not define. */ ++#cmakedefine size_t ${size_t} ++ ++/* Define to `int' if does not define. */ ++#cmakedefine ssize_t ${ssize_t} ++ ++/* Define to `int' if doesn't define. */ ++#cmakedefine uid_t ${uid_t} ++ ++/* Define to `int' if does not define. */ ++#cmakedefine intptr_t ${intptr_t} ++ ++/* Define to `unsigned int' if does not define. */ ++#cmakedefine uintptr_t ${uintptr_t} +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/pkgconfig/libarchive.pc.in +@@ -0,0 +1,12 @@ ++prefix=@prefix@ ++exec_prefix=@exec_prefix@ ++libdir=@libdir@ ++includedir=@includedir@ ++ ++Name: libarchive ++Description: library that can create and read several streaming archive formats ++Version: @VERSION@ ++Cflags: -I${includedir} ++Cflags.private: -DLIBARCHIVE_STATIC ++Libs: -L${libdir} -larchive ++Libs.private: @LIBS@ +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/libarchive-3.4.3/build/version +@@ -0,0 +1 @@ ++3004003 +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/speexdsp-SpeexDSP-1.2rc3/SpeexDSP.kdevelop +@@ -0,0 +1,201 @@ ++ ++ ++ ++ Jean-Marc Valin ++ jean-marc.valin@usherbrooke.ca ++ $VERSION$ ++ KDevAutoProject ++ C ++ ++ . ++ false ++ ++ ++ kdevsubversion ++ ++ Speex ++ ++ ++ ++ libspeex/libspeex.la ++ float ++ ++ ++ src/Speex ++ executable ++ / ++ ++ false ++ true ++ ++ false ++ false ++ ++ ++ ++ float ++ kdevgccoptions ++ kdevgppoptions ++ kdevpgf77options ++ -O2 -g -Wall ++ ++ --disable-shared ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ --enable-fixed-point --disable-shared ++ fixed ++ kdevgccoptions ++ kdevgppoptions ++ kdevpgf77options ++ -O2 -g -Wall ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ false ++ 4 ++ false ++ ++ true ++ 0 ++ ++ ++ ++ ++ libtool ++ ++ ++ ++ ++ ++ true ++ false ++ false ++ ++ ++ false ++ true ++ 10 ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ true ++ true ++ true ++ false ++ true ++ true ++ true ++ 350 ++ 400 ++ 250 ++ false ++ 0 ++ true ++ true ++ false ++ std=_GLIBCXX_STD;__gnu_cxx=std ++ true ++ true ++ false ++ false ++ true ++ true ++ true ++ true ++ .; ++ false ++ false ++ ++ ++ false ++ 3 ++ /usr/share/qt3 ++ 3 ++ EmbeddedKDevDesigner ++ /usr/share/qt3/bin/qmake ++ /usr/bin/designer-qt3 ++ ++ ++ ++ ++ set ++ m_,_ ++ theValue ++ true ++ true ++ ++ ++ true ++ true ++ Horizontal ++ ++ ++ ++ ++ false ++ false ++ ++ ++ *.o,*.lo,CVS ++ true ++ false ++ ++ ++ ++ ++ html/ ++ html/ ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ .h ++ .cpp ++ ++ ++ ++ ++ ++ ++ ++ ++ ++ +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/.circleci/config.yml +@@ -0,0 +1,169 @@ ++version: 2 ++ ++jobs: ++ # the first half of the jobs are in this test ++ short-tests-0: ++ # TODO: Create a small custom docker image with all the dependencies we need ++ # preinstalled to reduce installation time. ++ docker: ++ - image: fbopensource/zstd-circleci-primary:0.0.1 ++ steps: ++ - checkout ++ - run: ++ name: Test ++ command: | ++ ./tests/test-license.py ++ cc -v; CFLAGS="-O0 -Werror -pedantic" make all && make clean ++ make c99build ; make clean ++ make c11build ; make clean ++ make aarch64build ; make clean ++ make -j regressiontest; make clean ++ make shortest ; make clean ++ make cxxtest ; make clean ++ # the second half of the jobs are in this test ++ short-tests-1: ++ docker: ++ - image: fbopensource/zstd-circleci-primary:0.0.1 ++ steps: ++ - checkout ++ - run: ++ name: Test ++ command: | ++ make gnu90build; make clean ++ make gnu99build; make clean ++ make ppc64build; make clean ++ make ppcbuild ; make clean ++ make armbuild ; make clean ++ make -C tests test-legacy test-longmatch; make clean ++ make -C lib libzstd-nomt; make clean ++ # This step is only run on release tags. ++ # It publishes the source tarball as artifacts and if the GITHUB_TOKEN ++ # environment variable is set it will publish the source tarball to the ++ # tagged release. ++ publish-github-release: ++ docker: ++ - image: fbopensource/zstd-circleci-primary:0.0.1 ++ environment: ++ CIRCLE_ARTIFACTS: /tmp/circleci-artifacts ++ steps: ++ - checkout ++ - run: ++ name: Publish ++ command: | ++ export VERSION=$(echo $CIRCLE_TAG | tail -c +2) ++ export ZSTD_VERSION=zstd-$VERSION ++ git archive $CIRCLE_TAG --prefix $ZSTD_VERSION/ --format tar \ ++ -o $ZSTD_VERSION.tar ++ sha256sum $ZSTD_VERSION.tar > $ZSTD_VERSION.tar.sha256 ++ zstd -19 $ZSTD_VERSION.tar ++ sha256sum $ZSTD_VERSION.tar.zst > $ZSTD_VERSION.tar.zst.sha256 ++ gzip -k -9 $ZSTD_VERSION.tar ++ sha256sum $ZSTD_VERSION.tar.gz > $ZSTD_VERSION.tar.gz.sha256 ++ mkdir -p $CIRCLE_ARTIFACTS ++ cp $ZSTD_VERSION.tar* $CIRCLE_ARTIFACTS ++ - store_artifacts: ++ path: /tmp/circleci-artifacts ++ # This step should only be run in a cron job ++ regression-test: ++ docker: ++ - image: fbopensource/zstd-circleci-primary:0.0.1 ++ environment: ++ CIRCLE_ARTIFACTS: /tmp/circleci-artifacts ++ steps: ++ - checkout ++ # Restore the cached resources. ++ - restore_cache: ++ # We try our best to bust the cache when the data changes by hashing ++ # data.c. If that doesn't work, simply update the version number here ++ # and below. If we fail to bust the cache, the regression testing will ++ # still work, since it has its own stamp, but will need to redownload ++ # everything. ++ keys: ++ - regression-cache-{{ checksum "tests/regression/data.c" }}-v0 ++ - run: ++ name: Regression Test ++ command: | ++ make -C programs zstd ++ make -C tests/regression test ++ mkdir -p $CIRCLE_ARTIFACTS ++ ./tests/regression/test \ ++ --cache tests/regression/cache \ ++ --output $CIRCLE_ARTIFACTS/results.csv \ ++ --zstd programs/zstd ++ echo "NOTE: The new results.csv is uploaded as an artifact to this job" ++ echo " If this fails, go to the Artifacts pane in CircleCI, " ++ echo " download /tmp/circleci-artifacts/results.csv, and if they " ++ echo " are still good, copy it into the repo and commit it." ++ echo "> diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv" ++ diff tests/regression/results.csv $CIRCLE_ARTIFACTS/results.csv ++ # Only save the cache on success (default), since if the failure happened ++ # before we stamp the data cache, we will have a bad cache for this key. ++ - save_cache: ++ key: regression-cache-{{ checksum "tests/regression/data.c" }}-v0 ++ paths: ++ - tests/regression/cache ++ - store_artifacts: ++ path: /tmp/circleci-artifacts ++ ++ ++workflows: ++ version: 2 ++ commit: ++ jobs: ++ # Run the tests in parallel ++ - short-tests-0: ++ filters: ++ tags: ++ only: /.*/ ++ - short-tests-1: ++ filters: ++ tags: ++ only: /.*/ ++ # Create a branch called regression and set it to dev to force a ++ # regression test run ++ - regression-test: ++ filters: ++ branches: ++ only: ++ - regression ++ # Only run on release tags. ++ - publish-github-release: ++ requires: ++ - short-tests-0 ++ - short-tests-1 ++ filters: ++ branches: ++ ignore: /.*/ ++ tags: ++ only: /^v\d+\.\d+\.\d+$/ ++ nightly: ++ triggers: ++ - schedule: ++ cron: "0 0 * * *" ++ filters: ++ branches: ++ only: ++ - master ++ - dev ++ jobs: ++ # Run daily long regression tests ++ - regression-test ++ ++ ++ ++ # Longer tests ++ #- make -C tests test-zstd-nolegacy && make clean ++ #- pyenv global 3.4.4; make -C tests versionsTest && make clean ++ #- make zlibwrapper && make clean ++ #- gcc -v; make -C tests test32 MOREFLAGS="-I/usr/include/x86_64-linux-gnu" && make clean ++ #- make uasan && make clean ++ #- make asan32 && make clean ++ #- make -C tests test32 CC=clang MOREFLAGS="-g -fsanitize=address -I/usr/include/x86_64-linux-gnu" ++ # Valgrind tests ++ #- CFLAGS="-O1 -g" make -C zlibWrapper valgrindTest && make clean ++ #- make -C tests valgrindTest && make clean ++ # ARM, AArch64, PowerPC, PowerPC64 tests ++ #- make ppctest && make clean ++ #- make ppc64test && make clean ++ #- make armtest && make clean ++ #- make aarch64test && make clean +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/.circleci/images/primary/Dockerfile +@@ -0,0 +1,9 @@ ++FROM circleci/buildpack-deps:bionic ++ ++RUN sudo dpkg --add-architecture i386 ++RUN sudo apt-get -y -qq update ++RUN sudo apt-get -y install \ ++ gcc-multilib-powerpc-linux-gnu gcc-arm-linux-gnueabi \ ++ libc6-dev-armel-cross gcc-aarch64-linux-gnu libc6-dev-arm64-cross \ ++ libc6-dev-ppc64-powerpc-cross zstd gzip coreutils \ ++ libcurl4-openssl-dev +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/.cirrus.yml +@@ -0,0 +1,11 @@ ++task: ++ name: FreeBSD (shortest) ++ freebsd_instance: ++ matrix: ++ image_family: freebsd-12-1 ++ # The stable 11.3 image causes "Agent is not responding" so use a snapshot ++ image_family: freebsd-11-3-snap ++ install_script: pkg install -y gmake coreutils ++ script: | ++ MOREFLAGS="-Werror" gmake -j all ++ gmake shortest +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/.github/ISSUE_TEMPLATE/bug_report.md +@@ -0,0 +1,35 @@ ++--- ++name: Bug report ++about: Create a report to help us improve ++title: '' ++labels: '' ++assignees: '' ++ ++--- ++ ++**Describe the bug** ++A clear and concise description of what the bug is. ++ ++**To Reproduce** ++Steps to reproduce the behavior: ++1. Downloads data '...' ++2. Run '...' with flags '...' ++3. Scroll up on the log to '....' ++4. See error ++ ++**Expected behavior** ++A clear and concise description of what you expected to happen. ++ ++**Screenshots and charts** ++If applicable, add screenshots and charts to help explain your problem. ++ ++**Desktop (please complete the following information):** ++ - OS: [e.g. Mac] ++ - Version [e.g. 22] ++ - Compiler [e.g gcc] ++ - Flags [e.g O2] ++ - Other relevant hardware specs [e.g. Dual-core] ++ - Build system [e.g. Makefile] ++ ++**Additional context** ++Add any other context about the problem here. +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/.github/ISSUE_TEMPLATE/feature_request.md +@@ -0,0 +1,20 @@ ++--- ++name: Feature request ++about: Suggest an idea for this project ++title: '' ++labels: '' ++assignees: '' ++ ++--- ++ ++**Is your feature request related to a problem? Please describe.** ++A clear and concise description of what the problem is. Ex. I'm always frustrated when [...] ++ ++**Describe the solution you'd like** ++A clear and concise description of what you want to happen. ++ ++**Describe alternatives you've considered** ++A clear and concise description of any alternative solutions or features you've considered. ++ ++**Additional context** ++Add any other context or screenshots about the feature request here. +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/.github/workflows/main.yml +@@ -0,0 +1,23 @@ ++name: CIFuzz ++on: [pull_request] ++jobs: ++ Fuzzing: ++ runs-on: ubuntu-latest ++ steps: ++ - name: Build Fuzzers ++ uses: google/oss-fuzz/infra/cifuzz/actions/build_fuzzers@master ++ with: ++ oss-fuzz-project-name: 'zstd' ++ dry-run: false ++ - name: Run Fuzzers ++ uses: google/oss-fuzz/infra/cifuzz/actions/run_fuzzers@master ++ with: ++ oss-fuzz-project-name: 'zstd' ++ fuzz-seconds: 600 ++ dry-run: false ++ - name: Upload Crash ++ uses: actions/upload-artifact@v1 ++ if: failure() ++ with: ++ name: artifacts ++ path: ./out/artifacts +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/.travis.yml +@@ -0,0 +1,280 @@ ++# Medium Tests: Run on all commits/PRs to dev branch ++ ++language: c ++ ++git: ++ depth: 1 ++ ++branches: ++ only: ++ - dev ++ - master ++ - travisTest ++ ++addons: ++ apt: ++ update: true ++ ++env: ++ global: ++ - FUZZERTEST=-T2mn ++ ZSTREAM_TESTTIME=-T2mn ++ DECODECORPUS_TESTTIME=-T1mn ++ ++ ++matrix: ++ fast_finish: true ++ include: ++ - name: icc ++ compiler: icc ++ env: ++ - C_COMPILER=icc ++ - CXX_COMPILER=icpc ++ install: ++ - source /opt/intel/inteloneapi/compiler/latest/env/vars.sh ++ addons: ++ apt: ++ sources: ++ - sourceline: 'deb https://apt.repos.intel.com/oneapi all main' ++ key_url: 'https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS-2023.PUB' ++ packages: ++ - intel-oneapi-icc ++ script: make check ++ ++ - name: arm64 # ~2.5 mn ++ os: linux ++ arch: arm64 ++ script: ++ - make check ++ ++ - name: make benchmarking ++ script: ++ - make benchmarking ++ ++ - name: make test (complete) ++ script: ++ # DEVNULLRIGHTS : will request sudo rights to test permissions on /dev/null ++ - DEVNULLRIGHTS=test make test ++ ++ - name: gcc-6 + gcc-7 + libzstdmt compilation # ~ 6mn ++ script: ++ - make gcc6install gcc7install ++ - CC=gcc-6 CFLAGS=-Werror make -j all ++ - make clean ++ - CC=gcc-7 CFLAGS=-Werror make -j all ++ - make clean ++ - LDFLAGS=-Wl,--no-undefined make -C lib libzstd-mt ++ - make -C tests zbufftest-dll ++ # LDFLAGS=-Wl,--no-undefined : will make the linker fail if dll is underlinked ++ # zbufftest-dll : test that a user program can link to multi-threaded libzstd without specifying -pthread ++ ++ - name: gcc-8 + ASan + UBSan + Test Zstd # ~6.5mn ++ script: ++ - make gcc8install ++ - CC=gcc-8 CFLAGS="-Werror" make -j all ++ - make clean ++ - CC=gcc-8 make -j uasan-test-zstd " ++ "DATAGEN_BIN=$" ++ ) ++else() ++ message(STATUS "Disabling playTests.sh test because ZSTD_BUILD_PROGRAMS is not enabled") ++ set_tests_properties(playTests PROPERTIES DISABLED YES) ++endif() ++ ++# Label the "Medium" set of tests (see TESTING.md) ++set_property(TEST fuzzer zstreamtest playTests APPEND PROPERTY LABELS Medium) ++ ++if (UNIX) ++ add_executable(paramgrill ${PROGRAMS_DIR}/benchfn.c ${PROGRAMS_DIR}/benchzstd.c ${PROGRAMS_DIR}/datagen.c ${PROGRAMS_DIR}/util.c ${PROGRAMS_DIR}/timefn.c ${TESTS_DIR}/paramgrill.c) ++ target_link_libraries(paramgrill libzstd_static m) #m is math library ++endif () +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/cmake/zstdConfig.cmake +@@ -0,0 +1 @@ ++include("${CMAKE_CURRENT_LIST_DIR}/zstdTargets.cmake") +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/GetZstdLibraryVersion.py +@@ -0,0 +1,39 @@ ++#!/usr/bin/env python3 ++# ############################################################################# ++# Copyright (c) 2018-present lzutao ++# All rights reserved. ++# ++# This source code is licensed under both the BSD-style license (found in the ++# LICENSE file in the root directory of this source tree) and the GPLv2 (found ++# in the COPYING file in the root directory of this source tree). ++# ############################################################################# ++import re ++ ++ ++def find_version_tuple(filepath): ++ version_file_data = None ++ with open(filepath) as fd: ++ version_file_data = fd.read() ++ ++ patterns = r"""#\s*define\s+ZSTD_VERSION_MAJOR\s+([0-9]+) ++#\s*define\s+ZSTD_VERSION_MINOR\s+([0-9]+) ++#\s*define\s+ZSTD_VERSION_RELEASE\s+([0-9]+) ++""" ++ regex = re.compile(patterns, re.MULTILINE) ++ version_match = regex.search(version_file_data) ++ if version_match: ++ return version_match.groups() ++ raise Exception("Unable to find version string") ++ ++ ++def main(): ++ import argparse ++ parser = argparse.ArgumentParser(description='Print zstd version from lib/zstd.h') ++ parser.add_argument('file', help='path to lib/zstd.h') ++ args = parser.parse_args() ++ version_tuple = find_version_tuple(args.file) ++ print('.'.join(version_tuple)) ++ ++ ++if __name__ == '__main__': ++ main() +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/InstallSymlink.py +@@ -0,0 +1,55 @@ ++#!/usr/bin/env python3 ++# ############################################################################# ++# Copyright (c) 2018-present lzutao ++# All rights reserved. ++# ++# This source code is licensed under both the BSD-style license (found in the ++# LICENSE file in the root directory of this source tree) and the GPLv2 (found ++# in the COPYING file in the root directory of this source tree). ++# ############################################################################# ++# This file should be synced with https://github.com/lzutao/meson-symlink ++ ++import os ++import pathlib # since Python 3.4 ++ ++ ++def install_symlink(src, dst, install_dir, dst_is_dir=False, dir_mode=0o777): ++ if not install_dir.exists(): ++ install_dir.mkdir(mode=dir_mode, parents=True, exist_ok=True) ++ if not install_dir.is_dir(): ++ raise NotADirectoryError(install_dir) ++ ++ new_dst = install_dir.joinpath(dst) ++ if new_dst.is_symlink() and os.readlink(new_dst) == src: ++ print('File exists: {!r} -> {!r}'.format(new_dst, src)) ++ return ++ print('Installing symlink {!r} -> {!r}'.format(new_dst, src)) ++ new_dst.symlink_to(src, target_is_directory=dst_is_dir) ++ ++ ++def main(): ++ import argparse ++ parser = argparse.ArgumentParser(description='Install a symlink', ++ usage='{0} [-h] [-d] [-m MODE] source dest install_dir\n\n' ++ 'example:\n' ++ ' {0} dash sh /bin'.format(pathlib.Path(__file__).name)) ++ parser.add_argument('source', help='target to link') ++ parser.add_argument('dest', help='link name') ++ parser.add_argument('install_dir', help='installation directory') ++ parser.add_argument('-d', '--isdir', ++ action='store_true', ++ help='dest is a directory') ++ parser.add_argument('-m', '--mode', ++ help='directory mode on creating if not exist', ++ default='0o755') ++ args = parser.parse_args() ++ ++ dir_mode = int(args.mode, 8) ++ ++ meson_destdir = os.environ.get('MESON_INSTALL_DESTDIR_PREFIX', default='') ++ install_dir = pathlib.Path(meson_destdir, args.install_dir) ++ install_symlink(args.source, args.dest, install_dir, args.isdir, dir_mode) ++ ++ ++if __name__ == '__main__': ++ main() +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/README.md +@@ -0,0 +1,38 @@ ++Meson build system for zstandard ++================================ ++ ++Meson is a build system designed to optimize programmer productivity. ++It aims to do this by providing simple, out-of-the-box support for ++modern software development tools and practices, such as unit tests, ++coverage reports, Valgrind, CCache and the like. ++ ++This Meson build system is provided with no guarantee and maintained ++by Dima Krasner \. ++ ++It outputs one `libzstd`, either shared or static, depending on ++`default_library` option. ++ ++## How to build ++ ++`cd` to this meson directory (`build/meson`) ++ ++```sh ++meson setup -Dbin_programs=true -Dbin_contrib=true builddir ++cd builddir ++ninja # to build ++ninja install # to install ++``` ++ ++You might want to install it in staging directory: ++ ++```sh ++DESTDIR=./staging ninja install ++``` ++ ++To configure build options, use: ++ ++```sh ++meson configure ++``` ++ ++See [man meson(1)](https://manpages.debian.org/testing/meson/meson.1.en.html). +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/contrib/gen_html/meson.build +@@ -0,0 +1,30 @@ ++# ############################################################################# ++# Copyright (c) 2018-present lzutao ++# All rights reserved. ++# ++# This source code is licensed under both the BSD-style license (found in the ++# LICENSE file in the root directory of this source tree) and the GPLv2 (found ++# in the COPYING file in the root directory of this source tree). ++# ############################################################################# ++ ++zstd_rootdir = '../../../..' ++ ++gen_html_includes = include_directories(join_paths(zstd_rootdir, 'programs'), ++ join_paths(zstd_rootdir, 'lib'), ++ join_paths(zstd_rootdir, 'lib/common'), ++ join_paths(zstd_rootdir, 'contrib/gen_html')) ++ ++gen_html = executable('gen_html', ++ join_paths(zstd_rootdir, 'contrib/gen_html/gen_html.cpp'), ++ include_directories: gen_html_includes, ++ native: true, ++ install: false) ++ ++# Update zstd manual ++zstd_manual_html = custom_target('zstd_manual.html', ++ output : 'zstd_manual.html', ++ command : [gen_html, ++ zstd_version, ++ join_paths(meson.current_source_dir(), zstd_rootdir, 'lib/zstd.h'), ++ '@OUTPUT@'], ++ install : false) +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/contrib/meson.build +@@ -0,0 +1,12 @@ ++# ############################################################################# ++# Copyright (c) 2018-present Dima Krasner ++# lzutao ++# All rights reserved. ++# ++# This source code is licensed under both the BSD-style license (found in the ++# LICENSE file in the root directory of this source tree) and the GPLv2 (found ++# in the COPYING file in the root directory of this source tree). ++# ############################################################################# ++ ++subdir('pzstd') ++subdir('gen_html') +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/contrib/pzstd/meson.build +@@ -0,0 +1,24 @@ ++# ############################################################################# ++# Copyright (c) 2018-present lzutao ++# All rights reserved. ++# ++# This source code is licensed under both the BSD-style license (found in the ++# LICENSE file in the root directory of this source tree) and the GPLv2 (found ++# in the COPYING file in the root directory of this source tree). ++# ############################################################################# ++ ++zstd_rootdir = '../../../..' ++ ++pzstd_includes = include_directories(join_paths(zstd_rootdir, 'programs'), ++ join_paths(zstd_rootdir, 'contrib/pzstd')) ++pzstd_sources = [join_paths(zstd_rootdir, 'programs/util.c'), ++ join_paths(zstd_rootdir, 'contrib/pzstd/main.cpp'), ++ join_paths(zstd_rootdir, 'contrib/pzstd/Options.cpp'), ++ join_paths(zstd_rootdir, 'contrib/pzstd/Pzstd.cpp'), ++ join_paths(zstd_rootdir, 'contrib/pzstd/SkippableFrame.cpp')] ++pzstd = executable('pzstd', ++ pzstd_sources, ++ cpp_args: [ '-DNDEBUG', '-Wno-shadow', '-pedantic' ], ++ include_directories: pzstd_includes, ++ dependencies: [ libzstd_dep, thread_dep ], ++ install: true) +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/lib/meson.build +@@ -0,0 +1,132 @@ ++# ############################################################################# ++# Copyright (c) 2018-present Dima Krasner ++# lzutao ++# All rights reserved. ++# ++# This source code is licensed under both the BSD-style license (found in the ++# LICENSE file in the root directory of this source tree) and the GPLv2 (found ++# in the COPYING file in the root directory of this source tree). ++# ############################################################################# ++ ++zstd_rootdir = '../../..' ++ ++libzstd_includes = [include_directories(join_paths(zstd_rootdir,'lib'), ++ join_paths(zstd_rootdir, 'lib/common'), ++ join_paths(zstd_rootdir, 'lib/compress'), ++ join_paths(zstd_rootdir, 'lib/decompress'), ++ join_paths(zstd_rootdir, 'lib/dictBuilder'), ++ join_paths(zstd_rootdir, 'lib/deprecated'))] ++ ++libzstd_sources = [join_paths(zstd_rootdir, 'lib/common/entropy_common.c'), ++ join_paths(zstd_rootdir, 'lib/common/fse_decompress.c'), ++ join_paths(zstd_rootdir, 'lib/common/threading.c'), ++ join_paths(zstd_rootdir, 'lib/common/pool.c'), ++ join_paths(zstd_rootdir, 'lib/common/zstd_common.c'), ++ join_paths(zstd_rootdir, 'lib/common/error_private.c'), ++ join_paths(zstd_rootdir, 'lib/common/xxhash.c'), ++ join_paths(zstd_rootdir, 'lib/compress/hist.c'), ++ join_paths(zstd_rootdir, 'lib/compress/fse_compress.c'), ++ join_paths(zstd_rootdir, 'lib/compress/huf_compress.c'), ++ join_paths(zstd_rootdir, 'lib/compress/zstd_compress.c'), ++ join_paths(zstd_rootdir, 'lib/compress/zstd_compress_literals.c'), ++ join_paths(zstd_rootdir, 'lib/compress/zstd_compress_sequences.c'), ++ join_paths(zstd_rootdir, 'lib/compress/zstd_compress_superblock.c'), ++ join_paths(zstd_rootdir, 'lib/compress/zstdmt_compress.c'), ++ join_paths(zstd_rootdir, 'lib/compress/zstd_fast.c'), ++ join_paths(zstd_rootdir, 'lib/compress/zstd_double_fast.c'), ++ join_paths(zstd_rootdir, 'lib/compress/zstd_lazy.c'), ++ join_paths(zstd_rootdir, 'lib/compress/zstd_opt.c'), ++ join_paths(zstd_rootdir, 'lib/compress/zstd_ldm.c'), ++ join_paths(zstd_rootdir, 'lib/decompress/huf_decompress.c'), ++ join_paths(zstd_rootdir, 'lib/decompress/zstd_decompress.c'), ++ join_paths(zstd_rootdir, 'lib/decompress/zstd_decompress_block.c'), ++ join_paths(zstd_rootdir, 'lib/decompress/zstd_ddict.c'), ++ join_paths(zstd_rootdir, 'lib/dictBuilder/cover.c'), ++ join_paths(zstd_rootdir, 'lib/dictBuilder/fastcover.c'), ++ join_paths(zstd_rootdir, 'lib/dictBuilder/divsufsort.c'), ++ join_paths(zstd_rootdir, 'lib/dictBuilder/zdict.c'), ++ join_paths(zstd_rootdir, 'lib/deprecated/zbuff_common.c'), ++ join_paths(zstd_rootdir, 'lib/deprecated/zbuff_compress.c'), ++ join_paths(zstd_rootdir, 'lib/deprecated/zbuff_decompress.c')] ++ ++# Explicit define legacy support ++add_project_arguments('-DZSTD_LEGACY_SUPPORT=@0@'.format(legacy_level), ++ language: 'c') ++ ++if legacy_level == 0 ++ message('Legacy support: DISABLED') ++else ++ # See ZSTD_LEGACY_SUPPORT of lib/README.md ++ message('Enable legacy support back to version 0.@0@'.format(legacy_level)) ++ ++ libzstd_includes += [ include_directories(join_paths(zstd_rootdir, 'lib/legacy')) ] ++ foreach i : [1, 2, 3, 4, 5, 6, 7] ++ if legacy_level <= i ++ libzstd_sources += join_paths(zstd_rootdir, 'lib/legacy/zstd_v0@0@.c'.format(i)) ++ endif ++ endforeach ++endif ++ ++libzstd_deps = [] ++if use_multi_thread ++ message('Enable multi-threading support') ++ add_project_arguments('-DZSTD_MULTITHREAD', language: 'c') ++ libzstd_deps = [ thread_dep ] ++endif ++ ++libzstd_c_args = [] ++if cc_id == compiler_msvc ++ if default_library_type != 'static' ++ libzstd_sources += [windows_mod.compile_resources( ++ join_paths(zstd_rootdir, 'build/VS2010/libzstd-dll/libzstd-dll.rc'))] ++ libzstd_c_args += ['-DZSTD_DLL_EXPORT=1', ++ '-DZSTD_HEAPMODE=0', ++ '-D_CONSOLE', ++ '-D_CRT_SECURE_NO_WARNINGS'] ++ else ++ libzstd_c_args += ['-DZSTD_HEAPMODE=0', ++ '-D_CRT_SECURE_NO_WARNINGS'] ++ endif ++endif ++ ++mingw_ansi_stdio_flags = [] ++if host_machine_os == os_windows and cc_id == compiler_gcc ++ mingw_ansi_stdio_flags = [ '-D__USE_MINGW_ANSI_STDIO' ] ++endif ++libzstd_c_args += mingw_ansi_stdio_flags ++ ++libzstd_debug_cflags = [] ++if use_debug ++ libzstd_c_args += '-DDEBUGLEVEL=@0@'.format(debug_level) ++ if cc_id == compiler_gcc or cc_id == compiler_clang ++ libzstd_debug_cflags = ['-Wstrict-aliasing=1', '-Wswitch-enum', ++ '-Wdeclaration-after-statement', '-Wstrict-prototypes', ++ '-Wundef', '-Wpointer-arith', '-Wvla', ++ '-Wformat=2', '-Winit-self', '-Wfloat-equal', '-Wwrite-strings', ++ '-Wredundant-decls', '-Wmissing-prototypes', '-Wc++-compat'] ++ endif ++endif ++libzstd_c_args += cc.get_supported_arguments(libzstd_debug_cflags) ++ ++libzstd = library('zstd', ++ libzstd_sources, ++ include_directories: libzstd_includes, ++ c_args: libzstd_c_args, ++ dependencies: libzstd_deps, ++ install: true, ++ version: zstd_libversion) ++ ++libzstd_dep = declare_dependency(link_with: libzstd, ++ include_directories: libzstd_includes) ++ ++pkgconfig.generate(libzstd, ++ name: 'libzstd', ++ filebase: 'libzstd', ++ description: 'fast lossless compression algorithm library', ++ version: zstd_libversion, ++ url: 'http://www.zstd.net/') ++ ++install_headers(join_paths(zstd_rootdir, 'lib/zstd.h'), ++ join_paths(zstd_rootdir, 'lib/deprecated/zbuff.h'), ++ join_paths(zstd_rootdir, 'lib/dictBuilder/zdict.h'), ++ join_paths(zstd_rootdir, 'lib/common/zstd_errors.h')) +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/meson.build +@@ -0,0 +1,147 @@ ++# ############################################################################# ++# Copyright (c) 2018-present Dima Krasner ++# lzutao ++# All rights reserved. ++# ++# This source code is licensed under both the BSD-style license (found in the ++# LICENSE file in the root directory of this source tree) and the GPLv2 (found ++# in the COPYING file in the root directory of this source tree). ++# ############################################################################# ++ ++project('zstd', ++ ['c', 'cpp'], ++ license: ['BSD', 'GPLv2'], ++ default_options : [ ++ 'c_std=gnu99', ++ 'cpp_std=c++11', ++ 'buildtype=release' ++ ], ++ version: 'DUMMY', ++ meson_version: '>=0.47.0') ++ ++cc = meson.get_compiler('c') ++cxx = meson.get_compiler('cpp') ++pkgconfig = import('pkgconfig') ++python3 = import('python').find_installation() ++windows_mod = import('windows') ++ ++host_machine_os = host_machine.system() ++os_windows = 'windows' ++os_linux = 'linux' ++os_darwin = 'darwin' ++os_freebsd = 'freebsd' ++os_sun = 'sunos' ++ ++cc_id = cc.get_id() ++compiler_gcc = 'gcc' ++compiler_clang = 'clang' ++compiler_msvc = 'msvc' ++ ++zstd_version = meson.project_version() ++ ++zstd_h_file = join_paths(meson.current_source_dir(), '../../lib/zstd.h') ++GetZstdLibraryVersion_py = files('GetZstdLibraryVersion.py') ++r = run_command(python3, GetZstdLibraryVersion_py, zstd_h_file) ++if r.returncode() == 0 ++ zstd_version = r.stdout().strip() ++ message('Project version is now: @0@'.format(zstd_version)) ++else ++ error('Cannot find project version in @0@'.format(zstd_h_file)) ++endif ++ ++zstd_libversion = zstd_version ++ ++# ============================================================================= ++# Installation directories ++# ============================================================================= ++ ++zstd_prefix = get_option('prefix') ++zstd_bindir = get_option('bindir') ++zstd_datadir = get_option('datadir') ++zstd_mandir = get_option('mandir') ++zstd_docdir = join_paths(zstd_datadir, 'doc', meson.project_name()) ++ ++# ============================================================================= ++# Project options ++# ============================================================================= ++ ++# Built-in options ++use_debug = get_option('debug') ++buildtype = get_option('buildtype') ++default_library_type = get_option('default_library') ++ ++# Custom options ++debug_level = get_option('debug_level') ++legacy_level = get_option('legacy_level') ++use_backtrace = get_option('backtrace') ++use_static_runtime = get_option('static_runtime') ++ ++bin_programs = get_option('bin_programs') ++bin_contrib = get_option('bin_contrib') ++bin_tests = get_option('bin_tests') ++ ++feature_multi_thread = get_option('multi_thread') ++feature_zlib = get_option('zlib') ++feature_lzma = get_option('lzma') ++feature_lz4 = get_option('lz4') ++ ++# ============================================================================= ++# Dependencies ++# ============================================================================= ++ ++libm_dep = cc.find_library('m', required: bin_tests) ++thread_dep = dependency('threads', required: feature_multi_thread) ++use_multi_thread = thread_dep.found() ++# Arguments in dependency should be equivalent to those passed to pkg-config ++zlib_dep = dependency('zlib', required: feature_zlib) ++use_zlib = zlib_dep.found() ++lzma_dep = dependency('liblzma', required: feature_lzma) ++use_lzma = lzma_dep.found() ++lz4_dep = dependency('liblz4', required: feature_lz4) ++use_lz4 = lz4_dep.found() ++ ++# ============================================================================= ++# Compiler flags ++# ============================================================================= ++ ++add_project_arguments('-DXXH_NAMESPACE=ZSTD_', language: ['c']) ++ ++if [compiler_gcc, compiler_clang].contains(cc_id) ++ common_warning_flags = [ '-Wextra', '-Wundef', '-Wshadow', '-Wcast-align', '-Wcast-qual' ] ++ if cc_id == compiler_clang ++ # Should use Meson's own --werror build option ++ #common_warning_flags += '-Werror' ++ common_warning_flags += ['-Wconversion', '-Wno-sign-conversion', '-Wdocumentation'] ++ endif ++ cc_compile_flags = cc.get_supported_arguments(common_warning_flags + ['-Wstrict-prototypes']) ++ cxx_compile_flags = cxx.get_supported_arguments(common_warning_flags) ++ add_project_arguments(cc_compile_flags, language : 'c') ++ add_project_arguments(cxx_compile_flags, language : 'cpp') ++elif cc_id == compiler_msvc ++ msvc_compile_flags = [ '/D_UNICODE', '/DUNICODE' ] ++ if use_multi_thread ++ msvc_compile_flags += '/MP' ++ endif ++ if use_static_runtime ++ msvc_compile_flags += '/MT' ++ endif ++ add_project_arguments(msvc_compile_flags, language: ['c', 'cpp']) ++endif ++ ++# ============================================================================= ++# Subdirs ++# ============================================================================= ++ ++subdir('lib') ++ ++if bin_programs ++ subdir('programs') ++endif ++ ++if bin_tests ++ subdir('tests') ++endif ++ ++if bin_contrib ++ subdir('contrib') ++endif +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/meson_options.txt +@@ -0,0 +1,36 @@ ++# ############################################################################# ++# Copyright (c) 2018-present Dima Krasner ++# lzutao ++# All rights reserved. ++# ++# This source code is licensed under both the BSD-style license (found in the ++# LICENSE file in the root directory of this source tree) and the GPLv2 (found ++# in the COPYING file in the root directory of this source tree). ++# ############################################################################# ++ ++# Read guidelines from https://wiki.gnome.org/Initiatives/GnomeGoals/MesonPorting ++ ++option('legacy_level', type: 'integer', min: 0, max: 7, value: '5', ++ description: 'Support any legacy format: 7 to 1 for v0.7+ to v0.1+') ++option('debug_level', type: 'integer', min: 0, max: 9, value: 1, ++ description: 'Enable run-time debug. See lib/common/debug.h') ++option('backtrace', type: 'boolean', value: false, ++ description: 'Display a stack backtrace when execution generates a runtime exception') ++option('static_runtime', type: 'boolean', value: false, ++ description: 'Link to static run-time libraries on MSVC') ++ ++option('bin_programs', type: 'boolean', value: true, ++ description: 'Enable programs build') ++option('bin_tests', type: 'boolean', value: false, ++ description: 'Enable tests build') ++option('bin_contrib', type: 'boolean', value: false, ++ description: 'Enable contrib build') ++ ++option('multi_thread', type: 'feature', value: 'enabled', ++ description: 'Enable multi-threading when pthread is detected') ++option('zlib', type: 'feature', value: 'auto', ++ description: 'Enable zlib support') ++option('lzma', type: 'feature', value: 'auto', ++ description: 'Enable lzma support') ++option('lz4', type: 'feature', value: 'auto', ++ description: 'Enable lz4 support') +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/programs/meson.build +@@ -0,0 +1,104 @@ ++# ############################################################################# ++# Copyright (c) 2018-present Dima Krasner ++# lzutao ++# All rights reserved. ++# ++# This source code is licensed under both the BSD-style license (found in the ++# LICENSE file in the root directory of this source tree) and the GPLv2 (found ++# in the COPYING file in the root directory of this source tree). ++# ############################################################################# ++ ++zstd_rootdir = '../../..' ++ ++zstd_programs_sources = [join_paths(zstd_rootdir, 'programs/zstdcli.c'), ++ join_paths(zstd_rootdir, 'programs/util.c'), ++ join_paths(zstd_rootdir, 'programs/timefn.c'), ++ join_paths(zstd_rootdir, 'programs/fileio.c'), ++ join_paths(zstd_rootdir, 'programs/benchfn.c'), ++ join_paths(zstd_rootdir, 'programs/benchzstd.c'), ++ join_paths(zstd_rootdir, 'programs/datagen.c'), ++ join_paths(zstd_rootdir, 'programs/dibio.c')] ++ ++zstd_c_args = libzstd_debug_cflags ++if use_multi_thread ++ zstd_c_args += [ '-DZSTD_MULTITHREAD' ] ++endif ++ ++zstd_deps = [ libzstd_dep ] ++if use_zlib ++ zstd_deps += [ zlib_dep ] ++ zstd_c_args += [ '-DZSTD_GZCOMPRESS', '-DZSTD_GZDECOMPRESS' ] ++endif ++ ++if use_lzma ++ zstd_deps += [ lzma_dep ] ++ zstd_c_args += [ '-DZSTD_LZMACOMPRESS', '-DZSTD_LZMADECOMPRESS' ] ++endif ++ ++if use_lz4 ++ zstd_deps += [ lz4_dep ] ++ zstd_c_args += [ '-DZSTD_LZ4COMPRESS', '-DZSTD_LZ4DECOMPRESS' ] ++endif ++ ++export_dynamic_on_windows = false ++# explicit backtrace enable/disable for Linux & Darwin ++if not use_backtrace ++ zstd_c_args += '-DBACKTRACE_ENABLE=0' ++elif use_debug and host_machine_os == os_windows # MinGW target ++ zstd_c_args += '-DBACKTRACE_ENABLE=1' ++ export_dynamic_on_windows = true ++endif ++ ++if cc_id == compiler_msvc ++ if default_library_type != 'static' ++ zstd_programs_sources += [windows_mod.compile_resources( ++ join_paths(zstd_rootdir, 'build/VS2010/zstd/zstd.rc'))] ++ endif ++endif ++ ++zstd = executable('zstd', ++ zstd_programs_sources, ++ c_args: zstd_c_args, ++ dependencies: zstd_deps, ++ export_dynamic: export_dynamic_on_windows, # Since Meson 0.45.0 ++ install: true) ++ ++zstd_frugal_sources = [join_paths(zstd_rootdir, 'programs/zstdcli.c'), ++ join_paths(zstd_rootdir, 'programs/timefn.c'), ++ join_paths(zstd_rootdir, 'programs/util.c'), ++ join_paths(zstd_rootdir, 'programs/fileio.c')] ++ ++# Minimal target, with only zstd compression and decompression. ++# No bench. No legacy. ++executable('zstd-frugal', ++ zstd_frugal_sources, ++ dependencies: libzstd_dep, ++ c_args: [ '-DZSTD_NOBENCH', '-DZSTD_NODICT' ], ++ install: true) ++ ++install_data(join_paths(zstd_rootdir, 'programs/zstdgrep'), ++ join_paths(zstd_rootdir, 'programs/zstdless'), ++ install_dir: zstd_bindir) ++ ++# ============================================================================= ++# Programs and manpages installing ++# ============================================================================= ++ ++install_man(join_paths(zstd_rootdir, 'programs/zstd.1'), ++ join_paths(zstd_rootdir, 'programs/zstdgrep.1'), ++ join_paths(zstd_rootdir, 'programs/zstdless.1')) ++ ++InstallSymlink_py = '../InstallSymlink.py' ++zstd_man1_dir = join_paths(zstd_mandir, 'man1') ++bin_EXT = host_machine_os == os_windows ? '.exe' : '' ++man1_EXT = meson.version().version_compare('>=0.49.0') ? '.1' : '.1.gz' ++ ++foreach f : ['zstdcat', 'unzstd'] ++ meson.add_install_script(InstallSymlink_py, 'zstd' + bin_EXT, f + bin_EXT, zstd_bindir) ++ meson.add_install_script(InstallSymlink_py, 'zstd' + man1_EXT, f + man1_EXT, zstd_man1_dir) ++endforeach ++ ++if use_multi_thread ++ meson.add_install_script(InstallSymlink_py, 'zstd' + bin_EXT, 'zstdmt' + bin_EXT, zstd_bindir) ++ meson.add_install_script(InstallSymlink_py, 'zstd' + man1_EXT, 'zstdmt' + man1_EXT, zstd_man1_dir) ++endif +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/tests/meson.build +@@ -0,0 +1,206 @@ ++# ############################################################################# ++# Copyright (c) 2018-present Dima Krasner ++# lzutao ++# All rights reserved. ++# ++# This source code is licensed under both the BSD-style license (found in the ++# LICENSE file in the root directory of this source tree) and the GPLv2 (found ++# in the COPYING file in the root directory of this source tree). ++# ############################################################################# ++ ++zstd_rootdir = '../../..' ++ ++tests_supported_oses = [os_linux, 'gnu/kfreebsd', os_darwin, 'gnu', 'openbsd', ++ os_freebsd, 'netbsd', 'dragonfly', os_sun] ++ ++# ============================================================================= ++# Test flags ++# ============================================================================= ++ ++FUZZER_FLAGS = ['--no-big-tests'] ++FUZZERTEST = '-T200s' ++ZSTREAM_TESTTIME = '-T90s' ++DECODECORPUS_TESTTIME = '-T30' ++ZSTDRTTEST = ['--test-large-data'] ++ ++# ============================================================================= ++# Executables ++# ============================================================================= ++ ++test_includes = [ include_directories(join_paths(zstd_rootdir, 'programs')) ] ++ ++datagen_sources = [join_paths(zstd_rootdir, 'programs/datagen.c'), ++ join_paths(zstd_rootdir, 'tests/datagencli.c')] ++datagen = executable('datagen', ++ datagen_sources, ++ c_args: [ '-DNDEBUG' ], ++ include_directories: test_includes, ++ dependencies: libzstd_dep, ++ install: false) ++ ++fullbench_sources = [join_paths(zstd_rootdir, 'programs/datagen.c'), ++ join_paths(zstd_rootdir, 'programs/util.c'), ++ join_paths(zstd_rootdir, 'programs/timefn.c'), ++ join_paths(zstd_rootdir, 'programs/benchfn.c'), ++ join_paths(zstd_rootdir, 'programs/benchzstd.c'), ++ join_paths(zstd_rootdir, 'tests/fullbench.c')] ++fullbench = executable('fullbench', ++ fullbench_sources, ++ include_directories: test_includes, ++ dependencies: libzstd_dep, ++ install: false) ++ ++fuzzer_sources = [join_paths(zstd_rootdir, 'programs/datagen.c'), ++ join_paths(zstd_rootdir, 'programs/util.c'), ++ join_paths(zstd_rootdir, 'programs/timefn.c'), ++ join_paths(zstd_rootdir, 'tests/fuzzer.c')] ++fuzzer = executable('fuzzer', ++ fuzzer_sources, ++ include_directories: test_includes, ++ dependencies: libzstd_dep, ++ install: false) ++ ++zstreamtest_sources = [join_paths(zstd_rootdir, 'programs/datagen.c'), ++ join_paths(zstd_rootdir, 'programs/util.c'), ++ join_paths(zstd_rootdir, 'programs/timefn.c'), ++ join_paths(zstd_rootdir, 'tests/seqgen.c'), ++ join_paths(zstd_rootdir, 'tests/zstreamtest.c')] ++zstreamtest = executable('zstreamtest', ++ zstreamtest_sources, ++ include_directories: test_includes, ++ dependencies: libzstd_dep, ++ install: false) ++ ++paramgrill_sources = [join_paths(zstd_rootdir, 'programs/benchfn.c'), ++ join_paths(zstd_rootdir, 'programs/timefn.c'), ++ join_paths(zstd_rootdir, 'programs/benchzstd.c'), ++ join_paths(zstd_rootdir, 'programs/datagen.c'), ++ join_paths(zstd_rootdir, 'programs/util.c'), ++ join_paths(zstd_rootdir, 'tests/paramgrill.c')] ++paramgrill = executable('paramgrill', ++ paramgrill_sources, ++ include_directories: test_includes, ++ dependencies: [ libzstd_dep, libm_dep ], ++ install: false) ++ ++roundTripCrash_sources = [join_paths(zstd_rootdir, 'tests/roundTripCrash.c')] ++roundTripCrash = executable('roundTripCrash', ++ roundTripCrash_sources, ++ dependencies: [ libzstd_dep ], ++ install: false) ++ ++longmatch_sources = [join_paths(zstd_rootdir, 'tests/longmatch.c')] ++longmatch = executable('longmatch', ++ longmatch_sources, ++ dependencies: [ libzstd_dep ], ++ install: false) ++ ++invalidDictionaries_sources = [join_paths(zstd_rootdir, 'tests/invalidDictionaries.c')] ++invalidDictionaries = executable('invalidDictionaries', ++ invalidDictionaries_sources, ++ dependencies: [ libzstd_dep ], ++ install: false) ++ ++if 0 < legacy_level and legacy_level <= 4 ++ legacy_sources = [join_paths(zstd_rootdir, 'tests/legacy.c')] ++ legacy = executable('legacy', ++ legacy_sources, ++ # Use -Dlegacy_level build option to control it ++ #c_args: '-DZSTD_LEGACY_SUPPORT=4', ++ dependencies: [ libzstd_dep ], ++ install: false) ++endif ++ ++decodecorpus_sources = [join_paths(zstd_rootdir, 'programs/util.c'), ++ join_paths(zstd_rootdir, 'programs/timefn.c'), ++ join_paths(zstd_rootdir, 'tests/decodecorpus.c')] ++decodecorpus = executable('decodecorpus', ++ decodecorpus_sources, ++ include_directories: test_includes, ++ dependencies: [ libzstd_dep, libm_dep ], ++ install: false) ++ ++poolTests_sources = [join_paths(zstd_rootdir, 'programs/util.c'), ++ join_paths(zstd_rootdir, 'programs/timefn.c'), ++ join_paths(zstd_rootdir, 'tests/poolTests.c'), ++ join_paths(zstd_rootdir, 'lib/common/pool.c'), ++ join_paths(zstd_rootdir, 'lib/common/threading.c'), ++ join_paths(zstd_rootdir, 'lib/common/zstd_common.c'), ++ join_paths(zstd_rootdir, 'lib/common/error_private.c')] ++poolTests = executable('poolTests', ++ poolTests_sources, ++ include_directories: test_includes, ++ dependencies: [ libzstd_dep, thread_dep ], ++ install: false) ++ ++checkTag_sources = [join_paths(zstd_rootdir, 'tests/checkTag.c')] ++checkTag = executable('checkTag', ++ checkTag_sources, ++ dependencies: [ libzstd_dep ], ++ install: false) ++ ++# ============================================================================= ++# Tests (Use "meson test --list" to list all tests) ++# ============================================================================= ++ ++if tests_supported_oses.contains(host_machine_os) ++ valgrind_prog = find_program('valgrind', ['/usr/bin/valgrind'], required: true) ++ valgrindTest_py = files('valgrindTest.py') ++ test('valgrindTest', ++ valgrindTest_py, ++ args: [valgrind_prog.path(), zstd, datagen, fuzzer, fullbench], ++ depends: [zstd, datagen, fuzzer, fullbench], ++ timeout: 600) # Timeout should work on HDD drive ++endif ++ ++if host_machine_os != os_windows ++ playTests_sh = find_program(join_paths(zstd_rootdir, 'tests/playTests.sh'), required: true) ++ test('test-zstd', ++ playTests_sh, ++ args: ZSTDRTTEST, ++ env: ['ZSTD_BIN=' + zstd.full_path(), 'DATAGEN_BIN=./datagen'], ++ depends: [datagen], ++ workdir: meson.current_build_dir(), ++ timeout: 2800) # Timeout should work on HDD drive ++endif ++ ++test('test-fullbench-1', ++ fullbench, ++ args: ['-i1'], ++ depends: [datagen], ++ timeout: 60) ++test('test-fullbench-2', ++ fullbench, ++ args: ['-i1', '-P0'], ++ depends: [datagen], ++ timeout: 60) ++ ++if use_zlib ++ test('test-fuzzer', ++ fuzzer, ++ args: ['-v', FUZZERTEST] + FUZZER_FLAGS, ++ timeout: 480) ++endif ++ ++test('test-zstream-1', ++ zstreamtest, ++ args: ['-v', ZSTREAM_TESTTIME] + FUZZER_FLAGS, ++ timeout: 240) ++test('test-zstream-2', ++ zstreamtest, ++ args: ['-mt', '-t1', ZSTREAM_TESTTIME] + FUZZER_FLAGS, ++ timeout: 120) ++test('test-zstream-3', ++ zstreamtest, ++ args: ['--newapi', '-t1', ZSTREAM_TESTTIME] + FUZZER_FLAGS, ++ timeout: 120) ++test('test-longmatch', longmatch, timeout: 36) ++test('test-invalidDictionaries', invalidDictionaries) # should be fast ++if 0 < legacy_level and legacy_level <= 4 ++ test('test-legacy', legacy) # should be fast ++endif ++test('test-decodecorpus', ++ decodecorpus, ++ args: ['-t', DECODECORPUS_TESTTIME], ++ timeout: 60) ++test('test-poolTests', poolTests) # should be fast +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/build/meson/tests/valgrindTest.py +@@ -0,0 +1,90 @@ ++#!/usr/bin/env python3 ++# ############################################################################# ++# Copyright (c) 2018-present lzutao ++# All rights reserved. ++# ++# This source code is licensed under both the BSD-style license (found in the ++# LICENSE file in the root directory of this source tree) and the GPLv2 (found ++# in the COPYING file in the root directory of this source tree). ++# ############################################################################# ++import os ++import subprocess ++import tempfile ++ ++ ++def valgrindTest(valgrind, datagen, fuzzer, zstd, fullbench): ++ VALGRIND_ARGS = [valgrind, '--leak-check=full', '--show-leak-kinds=all', '--error-exitcode=1'] ++ ++ print('\n ---- valgrind tests : memory analyzer ----') ++ ++ subprocess.check_call([*VALGRIND_ARGS, datagen, '-g50M'], stdout=subprocess.DEVNULL) ++ ++ if subprocess.call([*VALGRIND_ARGS, zstd], ++ stdout=subprocess.DEVNULL) == 0: ++ raise subprocess.CalledProcessError('zstd without argument should have failed') ++ ++ with subprocess.Popen([datagen, '-g80'], stdout=subprocess.PIPE) as p1, \ ++ subprocess.Popen([*VALGRIND_ARGS, zstd, '-', '-c'], ++ stdin=p1.stdout, ++ stdout=subprocess.DEVNULL) as p2: ++ p1.stdout.close() # Allow p1 to receive a SIGPIPE if p2 exits. ++ p2.communicate() ++ if p2.returncode != 0: ++ raise subprocess.CalledProcessError() ++ ++ with subprocess.Popen([datagen, '-g16KB'], stdout=subprocess.PIPE) as p1, \ ++ subprocess.Popen([*VALGRIND_ARGS, zstd, '-vf', '-', '-c'], ++ stdin=p1.stdout, ++ stdout=subprocess.DEVNULL) as p2: ++ p1.stdout.close() ++ p2.communicate() ++ if p2.returncode != 0: ++ raise subprocess.CalledProcessError() ++ ++ with tempfile.NamedTemporaryFile() as tmp_fd: ++ with subprocess.Popen([datagen, '-g2930KB'], stdout=subprocess.PIPE) as p1, \ ++ subprocess.Popen([*VALGRIND_ARGS, zstd, '-5', '-vf', '-', '-o', tmp_fd.name], ++ stdin=p1.stdout) as p2: ++ p1.stdout.close() ++ p2.communicate() ++ if p2.returncode != 0: ++ raise subprocess.CalledProcessError() ++ ++ subprocess.check_call([*VALGRIND_ARGS, zstd, '-vdf', tmp_fd.name, '-c'], ++ stdout=subprocess.DEVNULL) ++ ++ with subprocess.Popen([datagen, '-g64MB'], stdout=subprocess.PIPE) as p1, \ ++ subprocess.Popen([*VALGRIND_ARGS, zstd, '-vf', '-', '-c'], ++ stdin=p1.stdout, ++ stdout=subprocess.DEVNULL) as p2: ++ p1.stdout.close() ++ p2.communicate() ++ if p2.returncode != 0: ++ raise subprocess.CalledProcessError() ++ ++ subprocess.check_call([*VALGRIND_ARGS, fuzzer, '-T1mn', '-t1']) ++ subprocess.check_call([*VALGRIND_ARGS, fullbench, '-i1']) ++ ++ ++def main(): ++ import argparse ++ parser = argparse.ArgumentParser(description='Valgrind tests : memory analyzer') ++ parser.add_argument('valgrind', help='valgrind path') ++ parser.add_argument('zstd', help='zstd path') ++ parser.add_argument('datagen', help='datagen path') ++ parser.add_argument('fuzzer', help='fuzzer path') ++ parser.add_argument('fullbench', help='fullbench path') ++ ++ args = parser.parse_args() ++ ++ valgrind = args.valgrind ++ zstd = args.zstd ++ datagen = args.datagen ++ fuzzer = args.fuzzer ++ fullbench = args.fullbench ++ ++ valgrindTest(valgrind, datagen, fuzzer, zstd, fullbench) ++ ++ ++if __name__ == '__main__': ++ main() +--- /dev/null ++++ cardinal-22.02/src/Rack/dep/zstd-1.4.5/contrib/linux-kernel/lib/zstd/.clang-format +@@ -0,0 +1,11 @@ ++BasedOnStyle: LLVM ++IndentWidth: 8 ++UseTab: Always ++BreakBeforeBraces: Linux ++AllowShortIfStatementsOnASingleLine: false ++IndentCaseLabels: false ++ ++ColumnLimit: 160 ++AlignEscapedNewlinesLeft: true ++ReflowComments: true ++AllowShortCaseLabelsOnASingleLine: true diff --git a/sources/plugins/cardinal/debian/patches/02_workaround-compiler-bug.patch b/sources/plugins/cardinal/debian/patches/02_workaround-compiler-bug.patch new file mode 100644 index 0000000..4566e20 --- /dev/null +++ b/sources/plugins/cardinal/debian/patches/02_workaround-compiler-bug.patch @@ -0,0 +1,18 @@ +--- cardinal-22.03.orig/plugins/Bidoo/src/ZINC.cpp ++++ cardinal-22.03/plugins/Bidoo/src/ZINC.cpp +@@ -123,6 +123,7 @@ struct ZINC : BidooModule { + const float slewMax = 500.0f; + const float shapeScale = 0.1f; + ++ __attribute__((optimize(1))) + ZINC() { + config(NUM_PARAMS, NUM_INPUTS, NUM_OUTPUTS, NUM_LIGHTS); + +@@ -145,6 +146,7 @@ struct ZINC : BidooModule { + } + } + ++ __attribute__((optimize(1))) + void process(const ProcessArgs &args) override { + float inM = inputs[IN_MOD].getVoltage() / 5.0f; + float inC = inputs[IN_CARR].getVoltage() / 5.0f; diff --git a/sources/plugins/cardinal/debian/patches/series b/sources/plugins/cardinal/debian/patches/series new file mode 100644 index 0000000..a2f4a10 --- /dev/null +++ b/sources/plugins/cardinal/debian/patches/series @@ -0,0 +1,2 @@ +01_vendored-libs.patch +02_workaround-compiler-bug.patch diff --git a/sources/plugins/cardinal/debian/rules b/sources/plugins/cardinal/debian/rules new file mode 100755 index 0000000..ebac119 --- /dev/null +++ b/sources/plugins/cardinal/debian/rules @@ -0,0 +1,24 @@ +#!/usr/bin/make -f + +KXSTUDIO_NO_LTO = y +include /usr/share/dpkg/kxstudio-audio-plugin.mk + +ifeq ($(DEB_HOST_ARCH),armhf) +export CFLAGS += -mno-unaligned-access +export CXXFLAGS += -mno-unaligned-access +endif + +%: + dh $@ + +override_dh_auto_clean: + rm -rf src/Rack/dep/zstd-1.4.5/build/VS2008 + rm -rf src/Rack/dep/zstd-1.4.5/build/VS2010 + rm -rf src/Rack/dep/zstd-1.4.5/build/VS_scripts + +override_dh_auto_build: + dh_auto_build -- PREFIX=/usr CIBUILD=true NOOPT=true + +override_dh_auto_install: + dh_auto_install -- PREFIX=/usr CIBUILD=true NOOPT=true DESTDIR=$(CURDIR)/debian/tmp/ +# $(call kxstudio_audio_plugin_test) diff --git a/sources/plugins/cardinal/debian/source/format b/sources/plugins/cardinal/debian/source/format new file mode 100644 index 0000000..163aaf8 --- /dev/null +++ b/sources/plugins/cardinal/debian/source/format @@ -0,0 +1 @@ +3.0 (quilt)