librfid/libtool

   1 #! /bin/sh
   2
   3 # libtool - Provide generalized library-building support services.
   4 # Generated automatically by config.status (librfid) 0.2.0
   5 # Libtool was configured on host kaos:
   6 # NOTE: Changes made to this file will be lost: look at ltmain.sh.
   7 #
   8 #   Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005,
   9 #                 2006, 2007, 2008 Free Software Foundation, Inc.
  10 #   Written by Gordon Matzigkeit, 1996
  11 #
  12 #   This file is part of GNU Libtool.
  13 #
  14 # GNU Libtool is free software; you can redistribute it and/or
  15 # modify it under the terms of the GNU General Public License as
  16 # published by the Free Software Foundation; either version 2 of
  17 # the License, or (at your option) any later version.
  18 #
  19 # As a special exception to the GNU General Public License,
  20 # if you distribute this file as part of a program or library that
  21 # is built using GNU Libtool, you may include this file under the
  22 # same distribution terms that you use for the rest of that program.
  23 #
  24 # GNU Libtool is distributed in the hope that it will be useful,
  25 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  26 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  27 # GNU General Public License for more details.
  28 #
  29 # You should have received a copy of the GNU General Public License
  30 # along with GNU Libtool; see the file COPYING.  If not, a copy
  31 # can be downloaded from http://www.gnu.org/licenses/gpl.html, or
  32 # obtained by writing to the Free Software Foundation, Inc.,
  33 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  34
  35
  36 # The names of the tagged configurations supported by this script.
  37 available_tags=""
  38
  39 # ### BEGIN LIBTOOL CONFIG
  40
  41 # Assembler program.
  42 AS=as
  43
  44 # DLL creation program.
  45 DLLTOOL=dlltool
  46
  47 # Object dumper program.
  48 OBJDUMP=objdump
  49
  50 # Which release of libtool.m4 was used?
  51 macro_version=2.2.6
  52 macro_revision=1.3012
  53
  54 # Whether or not to build shared libraries.
  55 build_libtool_libs=yes
  56
  57 # Whether or not to build static libraries.
  58 build_old_libs=yes
  59
  60 # What type of objects to build.
  61 pic_mode=default
  62
  63 # Whether or not to optimize for fast installation.
  64 fast_install=yes
  65
  66 # The host system.
  67 host_alias=
  68 host=x86_64-unknown-linux-gnu
  69 host_os=linux-gnu
  70
  71 # The build system.
  72 build_alias=
  73 build=x86_64-unknown-linux-gnu
  74 build_os=linux-gnu
  75
  76 # A sed program that does not truncate output.
  77 SED="/bin/sed"
  78
  79 # Sed that helps us avoid accidentally triggering echo(1) options like -n.
  80 Xsed="$SED -e 1s/^X//"
  81
  82 # A grep program that handles long lines.
  83 GREP="/bin/grep"
  84
  85 # An ERE matcher.
  86 EGREP="/bin/grep -E"
  87
  88 # A literal string matcher.
  89 FGREP="/bin/grep -F"
  90
  91 # A BSD- or MS-compatible name lister.
  92 NM="/usr/bin/nm -B"
  93
  94 # Whether we need soft or hard links.
  95 LN_S="ln -s"
  96
  97 # What is the maximum length of a command?
  98 max_cmd_len=1572864
  99
 100 # Object file suffix (normally "o").
 101 objext=o
 102
 103 # Executable file suffix (normally "").
 104 exeext=
 105
 106 # whether the shell understands "unset".
 107 lt_unset=unset
 108
 109 # turn spaces into newlines.
 110 SP2NL="tr \\040 \\012"
 111
 112 # turn newlines into spaces.
 113 NL2SP="tr \\015\\012 \\040\\040"
 114
 115 # How to create reloadable object files.
 116 reload_flag=" -r"
 117 reload_cmds="\$LD\$reload_flag -o \$output\$reload_objs"
 118
 119 # Method to check whether dependent libraries are shared objects.
 120 deplibs_check_method="pass_all"
 121
 122 # Command to use when deplibs_check_method == "file_magic".
 123 file_magic_cmd="\$MAGIC_CMD"
 124
 125 # The archiver.
 126 AR="ar"
 127 AR_FLAGS="cru"
 128
 129 # A symbol stripping program.
 130 STRIP="strip"
 131
 132 # Commands used to install an old-style archive.
 133 RANLIB="ranlib"
 134 old_postinstall_cmds="chmod 644 \$oldlib~\$RANLIB \$oldlib"
 135 old_postuninstall_cmds=""
 136
 137 # A C compiler.
 138 LTCC="gcc"
 139
 140 # LTCC compiler flags.
 141 LTCFLAGS="-g -O2"
 142
 143 # Take the output of nm and produce a listing of raw symbols and C names.
 144 global_symbol_pipe="sed -n -e 's/^.*[    ]\\([ABCDGIRSTW][ABCDGIRSTW]*\\)[       ][      ]*\\([_A-Za-z][_A-Za-z0-9]*\\)\$/\\1 \\2 \\2/p'"
 145
 146 # Transform the output of nm in a proper C declaration.
 147 global_symbol_to_cdecl="sed -n -e 's/^T .* \\(.*\\)\$/extern int \\1();/p' -e 's/^[ABCDGIRSTW]* .* \\(.*\\)\$/extern char \\1;/p'"
 148
 149 # Transform the output of nm in a C name address pair.
 150 global_symbol_to_c_name_address="sed -n -e 's/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/  {\"\\2\", (void *) \\&\\2},/p'"
 151
 152 # Transform the output of nm in a C name address pair when lib prefix is needed.
 153 global_symbol_to_c_name_address_lib_prefix="sed -n -e 's/^: \\([^ ]*\\) \$/  {\\\"\\1\\\", (void *) 0},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\(lib[^ ]*\\)\$/  {\"\\2\", (void *) \\&\\2},/p' -e 's/^[ABCDGIRSTW]* \\([^ ]*\\) \\([^ ]*\\)\$/  {\"lib\\2\", (void *) \\&\\2},/p'"
 154
 155 # The name of the directory that contains temporary libtool files.
 156 objdir=.libs
 157
 158 # Shell to use when invoking shell scripts.
 159 SHELL="/bin/sh"
 160
 161 # An echo program that does not interpret backslashes.
 162 ECHO="echo"
 163
 164 # Used to examine libraries when file_magic_cmd begins with "file".
 165 MAGIC_CMD=file
 166
 167 # Must we lock files when doing compilation?
 168 need_locks="no"
 169
 170 # Tool to manipulate archived DWARF debug symbol files on Mac OS X.
 171 DSYMUTIL=""
 172
 173 # Tool to change global to local symbols on Mac OS X.
 174 NMEDIT=""
 175
 176 # Tool to manipulate fat objects and archives on Mac OS X.
 177 LIPO=""
 178
 179 # ldd/readelf like tool for Mach-O binaries on Mac OS X.
 180 OTOOL=""
 181
 182 # ldd/readelf like tool for 64 bit Mach-O binaries on Mac OS X 10.4.
 183 OTOOL64=""
 184
 185 # Old archive suffix (normally "a").
 186 libext=a
 187
 188 # Shared library suffix (normally ".so").
 189 shrext_cmds=".so"
 190
 191 # The commands to extract the exported symbol list from a shared archive.
 192 extract_expsyms_cmds=""
 193
 194 # Variables whose values should be saved in libtool wrapper scripts and
 195 # restored at link time.
 196 variables_saved_for_relink="PATH LD_LIBRARY_PATH LD_RUN_PATH GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
 197
 198 # Do we need the "lib" prefix for modules?
 199 need_lib_prefix=no
 200
 201 # Do we need a version for libraries?
 202 need_version=no
 203
 204 # Library versioning type.
 205 version_type=linux
 206
 207 # Shared library runtime path variable.
 208 runpath_var=LD_RUN_PATH
 209
 210 # Shared library path variable.
 211 shlibpath_var=LD_LIBRARY_PATH
 212
 213 # Is shlibpath searched before the hard-coded library search path?
 214 shlibpath_overrides_runpath=no
 215
 216 # Format of library name prefix.
 217 libname_spec="lib\$name"
 218
 219 # List of archive names.  First name is the real one, the rest are links.
 220 # The last name is the one that the linker finds with -lNAME
 221 library_names_spec="\${libname}\${release}\${shared_ext}\$versuffix \${libname}\${release}\${shared_ext}\$major \$libname\${shared_ext}"
 222
 223 # The coded name of the library, if different from the real name.
 224 soname_spec="\${libname}\${release}\${shared_ext}\$major"
 225
 226 # Command to use after installation of a shared archive.
 227 postinstall_cmds=""
 228
 229 # Command to use after uninstallation of a shared archive.
 230 postuninstall_cmds=""
 231
 232 # Commands used to finish a libtool library installation in a directory.
 233 finish_cmds="PATH=\\\"\\\$PATH:/sbin\\\" ldconfig -n \$libdir"
 234
 235 # As "finish_cmds", except a single script fragment to be evaled but
 236 # not shown.
 237 finish_eval=""
 238
 239 # Whether we should hardcode library paths into libraries.
 240 hardcode_into_libs=yes
 241
 242 # Compile-time system search path for libraries.
 243 sys_lib_search_path_spec="/usr/lib/gcc/x86_64-unknown-linux-gnu/4.3.2 /usr/lib /lib"
 244
 245 # Run-time system search path for libraries.
 246 sys_lib_dlsearch_path_spec="/lib /usr/lib /usr/lib/libfakeroot /opt/lib32/lib /opt/lib32/usr/lib "
 247
 248 # Whether dlopen is supported.
 249 dlopen_support=unknown
 250
 251 # Whether dlopen of programs is supported.
 252 dlopen_self=unknown
 253
 254 # Whether dlopen of statically linked programs is supported.
 255 dlopen_self_static=unknown
 256
 257 # Commands to strip libraries.
 258 old_striplib="strip --strip-debug"
 259 striplib="strip --strip-unneeded"
 260
 261
 262 # The linker used to build libraries.
 263 LD="/usr/bin/ld -m elf_x86_64"
 264
 265 # Commands used to build an old-style archive.
 266 old_archive_cmds="\$AR \$AR_FLAGS \$oldlib\$oldobjs~\$RANLIB \$oldlib"
 267
 268 # A language specific compiler.
 269 CC="gcc"
 270
 271 # Is the compiler the GNU compiler?
 272 with_gcc=yes
 273
 274 # Compiler flag to turn off builtin functions.
 275 no_builtin_flag=" -fno-builtin"
 276
 277 # How to pass a linker flag through the compiler.
 278 wl="-Wl,"
 279
 280 # Additional compiler flags for building library objects.
 281 pic_flag=" -fPIC -DPIC"
 282
 283 # Compiler flag to prevent dynamic linking.
 284 link_static_flag="-static"
 285
 286 # Does compiler simultaneously support -c and -o options?
 287 compiler_c_o="yes"
 288
 289 # Whether or not to add -lc for building shared libraries.
 290 build_libtool_need_lc=no
 291
 292 # Whether or not to disallow shared libs when runtime libs are static.
 293 allow_libtool_libs_with_static_runtimes=no
 294
 295 # Compiler flag to allow reflexive dlopens.
 296 export_dynamic_flag_spec="\${wl}--export-dynamic"
 297
 298 # Compiler flag to generate shared objects directly from archives.
 299 whole_archive_flag_spec="\${wl}--whole-archive\$convenience \${wl}--no-whole-archive"
 300
 301 # Whether the compiler copes with passing no objects directly.
 302 compiler_needs_object="no"
 303
 304 # Create an old-style archive from a shared archive.
 305 old_archive_from_new_cmds=""
 306
 307 # Create a temporary old-style archive to link instead of a shared archive.
 308 old_archive_from_expsyms_cmds=""
 309
 310 # Commands used to build a shared archive.
 311 archive_cmds="\$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname -o \$lib"
 312 archive_expsym_cmds="echo \\\"{ global:\\\" > \$output_objdir/\$libname.ver~
 313             cat \$export_symbols | sed -e \\\"s/\\\\(.*\\\\)/\\\\1;/\\\" >> \$output_objdir/\$libname.ver~
 314             echo \\\"local: *; };\\\" >> \$output_objdir/\$libname.ver~
 315             \$CC -shared \$libobjs \$deplibs \$compiler_flags \${wl}-soname \$wl\$soname \${wl}-version-script \${wl}\$output_objdir/\$libname.ver -o \$lib"
 316
 317 # Commands used to build a loadable module if different from building
 318 # a shared archive.
 319 module_cmds=""
 320 module_expsym_cmds=""
 321
 322 # Whether we are building with GNU ld or not.
 323 with_gnu_ld="yes"
 324
 325 # Flag that allows shared libraries with undefined symbols to be built.
 326 allow_undefined_flag=""
 327
 328 # Flag that enforces no undefined symbols.
 329 no_undefined_flag=""
 330
 331 # Flag to hardcode $libdir into a binary during linking.
 332 # This must work even if $libdir does not exist
 333 hardcode_libdir_flag_spec="\${wl}-rpath \${wl}\$libdir"
 334
 335 # If ld is used when linking, flag to hardcode $libdir into a binary
 336 # during linking.  This must work even if $libdir does not exist.
 337 hardcode_libdir_flag_spec_ld=""
 338
 339 # Whether we need a single "-rpath" flag with a separated argument.
 340 hardcode_libdir_separator=""
 341
 342 # Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
 343 # DIR into the resulting binary.
 344 hardcode_direct=no
 345
 346 # Set to "yes" if using DIR/libNAME${shared_ext} during linking hardcodes
 347 # DIR into the resulting binary and the resulting library dependency is
 348 # "absolute",i.e impossible to change by setting ${shlibpath_var} if the
 349 # library is relocated.
 350 hardcode_direct_absolute=no
 351
 352 # Set to "yes" if using the -LDIR flag during linking hardcodes DIR
 353 # into the resulting binary.
 354 hardcode_minus_L=no
 355
 356 # Set to "yes" if using SHLIBPATH_VAR=DIR during linking hardcodes DIR
 357 # into the resulting binary.
 358 hardcode_shlibpath_var=unsupported
 359
 360 # Set to "yes" if building a shared library automatically hardcodes DIR
 361 # into the library and all subsequent libraries and executables linked
 362 # against it.
 363 hardcode_automatic=no
 364
 365 # Set to yes if linker adds runtime paths of dependent libraries
 366 # to runtime path list.
 367 inherit_rpath=no
 368
 369 # Whether libtool must link a program against all its dependency libraries.
 370 link_all_deplibs=unknown
 371
 372 # Fix the shell variable $srcfile for the compiler.
 373 fix_srcfile_path=""
 374
 375 # Set to "yes" if exported symbols are required.
 376 always_export_symbols=no
 377
 378 # The commands to list exported symbols.
 379 export_symbols_cmds="\$NM \$libobjs \$convenience | \$global_symbol_pipe | \$SED 's/.* //' | sort | uniq > \$export_symbols"
 380
 381 # Symbols that should not be listed in the preloaded symbols.
 382 exclude_expsyms="_GLOBAL_OFFSET_TABLE_|_GLOBAL__F[ID]_.*"
 383
 384 # Symbols that must always be exported.
 385 include_expsyms=""
 386
 387 # Commands necessary for linking programs (against libraries) with templates.
 388 prelink_cmds=""
 389
 390 # Specify filename containing input files.
 391 file_list_spec=""
 392
 393 # How to hardcode a shared library path into an executable.
 394 hardcode_action=immediate
 395
 396 # ### END LIBTOOL CONFIG
 397
 398 # Generated from ltmain.m4sh.
 399
 400 # ltmain.sh (GNU libtool) 2.2.6
 401 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
 402
 403 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.
 404 # This is free software; see the source for copying conditions.  There is NO
 405 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 406
 407 # GNU Libtool is free software; you can redistribute it and/or modify
 408 # it under the terms of the GNU General Public License as published by
 409 # the Free Software Foundation; either version 2 of the License, or
 410 # (at your option) any later version.
 411 #
 412 # As a special exception to the GNU General Public License,
 413 # if you distribute this file as part of a program or library that
 414 # is built using GNU Libtool, you may include this file under the
 415 # same distribution terms that you use for the rest of that program.
 416 #
 417 # GNU Libtool is distributed in the hope that it will be useful, but
 418 # WITHOUT ANY WARRANTY; without even the implied warranty of
 419 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 420 # General Public License for more details.
 421 #
 422 # You should have received a copy of the GNU General Public License
 423 # along with GNU Libtool; see the file COPYING.  If not, a copy
 424 # can be downloaded from http://www.gnu.org/licenses/gpl.html,
 425 # or obtained by writing to the Free Software Foundation, Inc.,
 426 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 427
 428 # Usage: $progname [OPTION]... [MODE-ARG]...
 429 #
 430 # Provide generalized library-building support services.
 431 #
 432 #     --config             show all configuration variables
 433 #     --debug              enable verbose shell tracing
 434 # -n, --dry-run            display commands without modifying any files
 435 #     --features           display basic configuration information and exit
 436 #     --mode=MODE          use operation mode MODE
 437 #     --preserve-dup-deps  don't remove duplicate dependency libraries
 438 #     --quiet, --silent    don't print informational messages
 439 #     --tag=TAG            use configuration variables from tag TAG
 440 # -v, --verbose            print informational messages (default)
 441 #     --version            print version information
 442 # -h, --help               print short or long help message
 443 #
 444 # MODE must be one of the following:
 445 #
 446 #       clean              remove files from the build directory
 447 #       compile            compile a source file into a libtool object
 448 #       execute            automatically set library path, then run a program
 449 #       finish             complete the installation of libtool libraries
 450 #       install            install libraries or executables
 451 #       link               create a library or an executable
 452 #       uninstall          remove libraries from an installed directory
 453 #
 454 # MODE-ARGS vary depending on the MODE.
 455 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.
 456 #
 457 # When reporting a bug, please describe a test case to reproduce it and
 458 # include the following information:
 459 #
 460 #       host-triplet:   $host
 461 #       shell:          $SHELL
 462 #       compiler:               $LTCC
 463 #       compiler flags:         $LTCFLAGS
 464 #       linker:         $LD (gnu? $with_gnu_ld)
 465 #       $progname:              (GNU libtool) 2.2.6
 466 #       automake:               $automake_version
 467 #       autoconf:               $autoconf_version
 468 #
 469 # Report bugs to <bug-libtool@gnu.org>.
 470
 471 PROGRAM=ltmain.sh
 472 PACKAGE=libtool
 473 VERSION=2.2.6
 474 TIMESTAMP=""
 475 package_revision=1.3012
 476
 477 # Be Bourne compatible
 478 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
 479   emulate sh
 480   NULLCMD=:
 481   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
 482   # is contrary to our usage.  Disable this feature.
 483   alias -g '${1+"$@"}'='"$@"'
 484   setopt NO_GLOB_SUBST
 485 else
 486   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 487 fi
 488 BIN_SH=xpg4; export BIN_SH # for Tru64
 489 DUALCASE=1; export DUALCASE # for MKS sh
 490
 491 # NLS nuisances: We save the old values to restore during execute mode.
 492 # Only set LANG and LC_ALL to C if already set.
 493 # These must not be set unconditionally because not all systems understand
 494 # e.g. LANG=C (notably SCO).
 495 lt_user_locale=
 496 lt_safe_locale=
 497 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
 498 do
 499   eval "if test \"\${$lt_var+set}\" = set; then
 500           save_$lt_var=\$$lt_var
 501           $lt_var=C
 502           export $lt_var
 503           lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
 504           lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
 505         fi"
 506 done
 507
 508 $lt_unset CDPATH
 509
 510
 511
 512
 513
 514 : ${CP="cp -f"}
 515 : ${ECHO="echo"}
 516 : ${EGREP="/usr/bin/grep -E"}
 517 : ${FGREP="/usr/bin/grep -F"}
 518 : ${GREP="/usr/bin/grep"}
 519 : ${LN_S="ln -s"}
 520 : ${MAKE="make"}
 521 : ${MKDIR="mkdir"}
 522 : ${MV="mv -f"}
 523 : ${RM="rm -f"}
 524 : ${SED="/opt/local/bin/gsed"}
 525 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
 526 : ${Xsed="$SED -e 1s/^X//"}
 527
 528 # Global variables:
 529 EXIT_SUCCESS=0
 530 EXIT_FAILURE=1
 531 EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
 532 EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
 533
 534 exit_status=$EXIT_SUCCESS
 535
 536 # Make sure IFS has a sensible default
 537 lt_nl='
 538 '
 539 IFS="   $lt_nl"
 540
 541 dirname="s,/[^/]*$,,"
 542 basename="s,^.*/,,"
 543
 544 # func_dirname_and_basename file append nondir_replacement
 545 # perform func_basename and func_dirname in a single function
 546 # call:
 547 #   dirname:  Compute the dirname of FILE.  If nonempty,
 548 #             add APPEND to the result, otherwise set result
 549 #             to NONDIR_REPLACEMENT.
 550 #             value returned in "$func_dirname_result"
 551 #   basename: Compute filename of FILE.
 552 #             value retuned in "$func_basename_result"
 553 # Implementation must be kept synchronized with func_dirname
 554 # and func_basename. For efficiency, we do not delegate to
 555 # those functions but instead duplicate the functionality here.
 556 func_dirname_and_basename ()
 557 {
 558   # Extract subdirectory from the argument.
 559   func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`
 560   if test "X$func_dirname_result" = "X${1}"; then
 561     func_dirname_result="${3}"
 562   else
 563     func_dirname_result="$func_dirname_result${2}"
 564   fi
 565   func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`
 566 }
 567
 568 # Generated shell functions inserted here.
 569
 570 # func_dirname file append nondir_replacement
 571 # Compute the dirname of FILE.  If nonempty, add APPEND to the result,
 572 # otherwise set result to NONDIR_REPLACEMENT.
 573 func_dirname ()
 574 {
 575   case ${1} in
 576     */*) func_dirname_result="${1%/*}${2}" ;;
 577     *  ) func_dirname_result="${3}" ;;
 578   esac
 579 }
 580
 581 # func_basename file
 582 func_basename ()
 583 {
 584   func_basename_result="${1##*/}"
 585 }
 586
 587 # func_dirname_and_basename file append nondir_replacement
 588 # perform func_basename and func_dirname in a single function
 589 # call:
 590 #   dirname:  Compute the dirname of FILE.  If nonempty,
 591 #             add APPEND to the result, otherwise set result
 592 #             to NONDIR_REPLACEMENT.
 593 #             value returned in "$func_dirname_result"
 594 #   basename: Compute filename of FILE.
 595 #             value retuned in "$func_basename_result"
 596 # Implementation must be kept synchronized with func_dirname
 597 # and func_basename. For efficiency, we do not delegate to
 598 # those functions but instead duplicate the functionality here.
 599 func_dirname_and_basename ()
 600 {
 601   case ${1} in
 602     */*) func_dirname_result="${1%/*}${2}" ;;
 603     *  ) func_dirname_result="${3}" ;;
 604   esac
 605   func_basename_result="${1##*/}"
 606 }
 607
 608 # func_stripname prefix suffix name
 609 # strip PREFIX and SUFFIX off of NAME.
 610 # PREFIX and SUFFIX must not contain globbing or regex special
 611 # characters, hashes, percent signs, but SUFFIX may contain a leading
 612 # dot (in which case that matches only a dot).
 613 func_stripname ()
 614 {
 615   # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
 616   # positional parameters, so assign one to ordinary parameter first.
 617   func_stripname_result=${3}
 618   func_stripname_result=${func_stripname_result#"${1}"}
 619   func_stripname_result=${func_stripname_result%"${2}"}
 620 }
 621
 622 # func_opt_split
 623 func_opt_split ()
 624 {
 625   func_opt_split_opt=${1%%=*}
 626   func_opt_split_arg=${1#*=}
 627 }
 628
 629 # func_lo2o object
 630 func_lo2o ()
 631 {
 632   case ${1} in
 633     *.lo) func_lo2o_result=${1%.lo}.${objext} ;;
 634     *)    func_lo2o_result=${1} ;;
 635   esac
 636 }
 637
 638 # func_xform libobj-or-source
 639 func_xform ()
 640 {
 641   func_xform_result=${1%.*}.lo
 642 }
 643
 644 # func_arith arithmetic-term...
 645 func_arith ()
 646 {
 647   func_arith_result=$(( $* ))
 648 }
 649
 650 # func_len string
 651 # STRING may not start with a hyphen.
 652 func_len ()
 653 {
 654   func_len_result=${#1}
 655 }
 656
 657
 658 # func_append var value
 659 # Append VALUE to the end of shell variable VAR.
 660 func_append ()
 661 {
 662   eval "$1+=\$2"
 663 }
 664 # Generated shell functions inserted here.
 665
 666 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
 667 # is ksh but when the shell is invoked as "sh" and the current value of
 668 # the _XPG environment variable is not equal to 1 (one), the special
 669 # positional parameter $0, within a function call, is the name of the
 670 # function.
 671 progpath="$0"
 672
 673 # The name of this program:
 674 # In the unlikely event $progname began with a '-', it would play havoc with
 675 # func_echo (imagine progname=-n), so we prepend ./ in that case:
 676 func_dirname_and_basename "$progpath"
 677 progname=$func_basename_result
 678 case $progname in
 679   -*) progname=./$progname ;;
 680 esac
 681
 682 # Make sure we have an absolute path for reexecution:
 683 case $progpath in
 684   [\\/]*|[A-Za-z]:\\*) ;;
 685   *[\\/]*)
 686      progdir=$func_dirname_result
 687      progdir=`cd "$progdir" && pwd`
 688      progpath="$progdir/$progname"
 689      ;;
 690   *)
 691      save_IFS="$IFS"
 692      IFS=:
 693      for progdir in $PATH; do
 694        IFS="$save_IFS"
 695        test -x "$progdir/$progname" && break
 696      done
 697      IFS="$save_IFS"
 698      test -n "$progdir" || progdir=`pwd`
 699      progpath="$progdir/$progname"
 700      ;;
 701 esac
 702
 703 # Sed substitution that helps us do robust quoting.  It backslashifies
 704 # metacharacters that are still active within double-quoted strings.
 705 Xsed="${SED}"' -e 1s/^X//'
 706 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
 707
 708 # Same as above, but do not quote variable references.
 709 double_quote_subst='s/\(["`\\]\)/\\\1/g'
 710
 711 # Re-`\' parameter expansions in output of double_quote_subst that were
 712 # `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
 713 # in input to double_quote_subst, that '$' was protected from expansion.
 714 # Since each input `\' is now two `\'s, look for any number of runs of
 715 # four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
 716 bs='\\'
 717 bs2='\\\\'
 718 bs4='\\\\\\\\'
 719 dollar='\$'
 720 sed_double_backslash="\
 721   s/$bs4/&\\
 722 /g
 723   s/^$bs2$dollar/$bs&/
 724   s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
 725   s/\n//g"
 726
 727 # Standard options:
 728 opt_dry_run=false
 729 opt_help=false
 730 opt_quiet=false
 731 opt_verbose=false
 732 opt_warning=:
 733
 734 # func_echo arg...
 735 # Echo program name prefixed message, along with the current mode
 736 # name if it has been set yet.
 737 func_echo ()
 738 {
 739     $ECHO "$progname${mode+: }$mode: $*"
 740 }
 741
 742 # func_verbose arg...
 743 # Echo program name prefixed message in verbose mode only.
 744 func_verbose ()
 745 {
 746     $opt_verbose && func_echo ${1+"$@"}
 747
 748     # A bug in bash halts the script if the last line of a function
 749     # fails when set -e is in force, so we need another command to
 750     # work around that:
 751     :
 752 }
 753
 754 # func_error arg...
 755 # Echo program name prefixed message to standard error.
 756 func_error ()
 757 {
 758     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2
 759 }
 760
 761 # func_warning arg...
 762 # Echo program name prefixed warning message to standard error.
 763 func_warning ()
 764 {
 765     $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2
 766
 767     # bash bug again:
 768     :
 769 }
 770
 771 # func_fatal_error arg...
 772 # Echo program name prefixed message to standard error, and exit.
 773 func_fatal_error ()
 774 {
 775     func_error ${1+"$@"}
 776     exit $EXIT_FAILURE
 777 }
 778
 779 # func_fatal_help arg...
 780 # Echo program name prefixed message to standard error, followed by
 781 # a help hint, and exit.
 782 func_fatal_help ()
 783 {
 784     func_error ${1+"$@"}
 785     func_fatal_error "$help"
 786 }
 787 help="Try \`$progname --help' for more information."  ## default
 788
 789
 790 # func_grep expression filename
 791 # Check whether EXPRESSION matches any line of FILENAME, without output.
 792 func_grep ()
 793 {
 794     $GREP "$1" "$2" >/dev/null 2>&1
 795 }
 796
 797
 798 # func_mkdir_p directory-path
 799 # Make sure the entire path to DIRECTORY-PATH is available.
 800 func_mkdir_p ()
 801 {
 802     my_directory_path="$1"
 803     my_dir_list=
 804
 805     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
 806
 807       # Protect directory names starting with `-'
 808       case $my_directory_path in
 809         -*) my_directory_path="./$my_directory_path" ;;
 810       esac
 811
 812       # While some portion of DIR does not yet exist...
 813       while test ! -d "$my_directory_path"; do
 814         # ...make a list in topmost first order.  Use a colon delimited
 815         # list incase some portion of path contains whitespace.
 816         my_dir_list="$my_directory_path:$my_dir_list"
 817
 818         # If the last portion added has no slash in it, the list is done
 819         case $my_directory_path in */*) ;; *) break ;; esac
 820
 821         # ...otherwise throw away the child directory and loop
 822         my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`
 823       done
 824       my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`
 825
 826       save_mkdir_p_IFS="$IFS"; IFS=':'
 827       for my_dir in $my_dir_list; do
 828         IFS="$save_mkdir_p_IFS"
 829         # mkdir can fail with a `File exist' error if two processes
 830         # try to create one of the directories concurrently.  Don't
 831         # stop in that case!
 832         $MKDIR "$my_dir" 2>/dev/null || :
 833       done
 834       IFS="$save_mkdir_p_IFS"
 835
 836       # Bail out if we (or some other process) failed to create a directory.
 837       test -d "$my_directory_path" || \
 838         func_fatal_error "Failed to create \`$1'"
 839     fi
 840 }
 841
 842
 843 # func_mktempdir [string]
 844 # Make a temporary directory that won't clash with other running
 845 # libtool processes, and avoids race conditions if possible.  If
 846 # given, STRING is the basename for that directory.
 847 func_mktempdir ()
 848 {
 849     my_template="${TMPDIR-/tmp}/${1-$progname}"
 850
 851     if test "$opt_dry_run" = ":"; then
 852       # Return a directory name, but don't create it in dry-run mode
 853       my_tmpdir="${my_template}-$$"
 854     else
 855
 856       # If mktemp works, use that first and foremost
 857       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
 858
 859       if test ! -d "$my_tmpdir"; then
 860         # Failing that, at least try and use $RANDOM to avoid a race
 861         my_tmpdir="${my_template}-${RANDOM-0}$$"
 862
 863         save_mktempdir_umask=`umask`
 864         umask 0077
 865         $MKDIR "$my_tmpdir"
 866         umask $save_mktempdir_umask
 867       fi
 868
 869       # If we're not in dry-run mode, bomb out on failure
 870       test -d "$my_tmpdir" || \
 871         func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
 872     fi
 873
 874     $ECHO "X$my_tmpdir" | $Xsed
 875 }
 876
 877
 878 # func_quote_for_eval arg
 879 # Aesthetically quote ARG to be evaled later.
 880 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
 881 # is double-quoted, suitable for a subsequent eval, whereas
 882 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
 883 # which are still active within double quotes backslashified.
 884 func_quote_for_eval ()
 885 {
 886     case $1 in
 887       *[\\\`\"\$]*)
 888         func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;
 889       *)
 890         func_quote_for_eval_unquoted_result="$1" ;;
 891     esac
 892
 893     case $func_quote_for_eval_unquoted_result in
 894       # Double-quote args containing shell metacharacters to delay
 895       # word splitting, command substitution and and variable
 896       # expansion for a subsequent eval.
 897       # Many Bourne shells cannot handle close brackets correctly
 898       # in scan sets, so we specify it separately.
 899       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 900         func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
 901         ;;
 902       *)
 903         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
 904     esac
 905 }
 906
 907
 908 # func_quote_for_expand arg
 909 # Aesthetically quote ARG to be evaled later; same as above,
 910 # but do not quote variable references.
 911 func_quote_for_expand ()
 912 {
 913     case $1 in
 914       *[\\\`\"]*)
 915         my_arg=`$ECHO "X$1" | $Xsed \
 916             -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
 917       *)
 918         my_arg="$1" ;;
 919     esac
 920
 921     case $my_arg in
 922       # Double-quote args containing shell metacharacters to delay
 923       # word splitting and command substitution for a subsequent eval.
 924       # Many Bourne shells cannot handle close brackets correctly
 925       # in scan sets, so we specify it separately.
 926       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 927         my_arg="\"$my_arg\""
 928         ;;
 929     esac
 930
 931     func_quote_for_expand_result="$my_arg"
 932 }
 933
 934
 935 # func_show_eval cmd [fail_exp]
 936 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
 937 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
 938 # is given, then evaluate it.
 939 func_show_eval ()
 940 {
 941     my_cmd="$1"
 942     my_fail_exp="${2-:}"
 943
 944     ${opt_silent-false} || {
 945       func_quote_for_expand "$my_cmd"
 946       eval "func_echo $func_quote_for_expand_result"
 947     }
 948
 949     if ${opt_dry_run-false}; then :; else
 950       eval "$my_cmd"
 951       my_status=$?
 952       if test "$my_status" -eq 0; then :; else
 953         eval "(exit $my_status); $my_fail_exp"
 954       fi
 955     fi
 956 }
 957
 958
 959 # func_show_eval_locale cmd [fail_exp]
 960 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
 961 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
 962 # is given, then evaluate it.  Use the saved locale for evaluation.
 963 func_show_eval_locale ()
 964 {
 965     my_cmd="$1"
 966     my_fail_exp="${2-:}"
 967
 968     ${opt_silent-false} || {
 969       func_quote_for_expand "$my_cmd"
 970       eval "func_echo $func_quote_for_expand_result"
 971     }
 972
 973     if ${opt_dry_run-false}; then :; else
 974       eval "$lt_user_locale
 975             $my_cmd"
 976       my_status=$?
 977       eval "$lt_safe_locale"
 978       if test "$my_status" -eq 0; then :; else
 979         eval "(exit $my_status); $my_fail_exp"
 980       fi
 981     fi
 982 }
 983
 984
 985
 986
 987
 988 # func_version
 989 # Echo version message to standard output and exit.
 990 func_version ()
 991 {
 992     $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {
 993         s/^# //
 994         s/^# *$//
 995         s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
 996         p
 997      }' < "$progpath"
 998      exit $?
 999 }
1000
1001 # func_usage
1002 # Echo short help message to standard output and exit.
1003 func_usage ()
1004 {
1005     $SED -n '/^# Usage:/,/# -h/ {
1006         s/^# //
1007         s/^# *$//
1008         s/\$progname/'$progname'/
1009         p
1010     }' < "$progpath"
1011     $ECHO
1012     $ECHO "run \`$progname --help | more' for full usage"
1013     exit $?
1014 }
1015
1016 # func_help
1017 # Echo long help message to standard output and exit.
1018 func_help ()
1019 {
1020     $SED -n '/^# Usage:/,/# Report bugs to/ {
1021         s/^# //
1022         s/^# *$//
1023         s*\$progname*'$progname'*
1024         s*\$host*'"$host"'*
1025         s*\$SHELL*'"$SHELL"'*
1026         s*\$LTCC*'"$LTCC"'*
1027         s*\$LTCFLAGS*'"$LTCFLAGS"'*
1028         s*\$LD*'"$LD"'*
1029         s/\$with_gnu_ld/'"$with_gnu_ld"'/
1030         s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/
1031         s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/
1032         p
1033      }' < "$progpath"
1034     exit $?
1035 }
1036
1037 # func_missing_arg argname
1038 # Echo program name prefixed message to standard error and set global
1039 # exit_cmd.
1040 func_missing_arg ()
1041 {
1042     func_error "missing argument for $1"
1043     exit_cmd=exit
1044 }
1045
1046 exit_cmd=:
1047
1048
1049
1050
1051
1052 # Check that we have a working $ECHO.
1053 if test "X$1" = X--no-reexec; then
1054   # Discard the --no-reexec flag, and continue.
1055   shift
1056 elif test "X$1" = X--fallback-echo; then
1057   # Avoid inline document here, it may be left over
1058   :
1059 elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then
1060   # Yippee, $ECHO works!
1061   :
1062 else
1063   # Restart under the correct shell, and then maybe $ECHO will work.
1064   exec $SHELL "$progpath" --no-reexec ${1+"$@"}
1065 fi
1066
1067 if test "X$1" = X--fallback-echo; then
1068   # used as fallback echo
1069   shift
1070   cat <<EOF
1071 $*
1072 EOF
1073   exit $EXIT_SUCCESS
1074 fi
1075
1076 magic="%%%MAGIC variable%%%"
1077 magic_exe="%%%MAGIC EXE variable%%%"
1078
1079 # Global variables.
1080 # $mode is unset
1081 nonopt=
1082 execute_dlfiles=
1083 preserve_args=
1084 lo2o="s/\\.lo\$/.${objext}/"
1085 o2lo="s/\\.${objext}\$/.lo/"
1086 extracted_archives=
1087 extracted_serial=0
1088
1089 opt_dry_run=false
1090 opt_duplicate_deps=false
1091 opt_silent=false
1092 opt_debug=:
1093
1094 # If this variable is set in any of the actions, the command in it
1095 # will be execed at the end.  This prevents here-documents from being
1096 # left over by shells.
1097 exec_cmd=
1098
1099 # func_fatal_configuration arg...
1100 # Echo program name prefixed message to standard error, followed by
1101 # a configuration failure hint, and exit.
1102 func_fatal_configuration ()
1103 {
1104     func_error ${1+"$@"}
1105     func_error "See the $PACKAGE documentation for more information."
1106     func_fatal_error "Fatal configuration error."
1107 }
1108
1109
1110 # func_config
1111 # Display the configuration for all the tags in this script.
1112 func_config ()
1113 {
1114     re_begincf='^# ### BEGIN LIBTOOL'
1115     re_endcf='^# ### END LIBTOOL'
1116
1117     # Default configuration.
1118     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
1119
1120     # Now print the configurations for the tags.
1121     for tagname in $taglist; do
1122       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
1123     done
1124
1125     exit $?
1126 }
1127
1128 # func_features
1129 # Display the features supported by this script.
1130 func_features ()
1131 {
1132     $ECHO "host: $host"
1133     if test "$build_libtool_libs" = yes; then
1134       $ECHO "enable shared libraries"
1135     else
1136       $ECHO "disable shared libraries"
1137     fi
1138     if test "$build_old_libs" = yes; then
1139       $ECHO "enable static libraries"
1140     else
1141       $ECHO "disable static libraries"
1142     fi
1143
1144     exit $?
1145 }
1146
1147 # func_enable_tag tagname
1148 # Verify that TAGNAME is valid, and either flag an error and exit, or
1149 # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
1150 # variable here.
1151 func_enable_tag ()
1152 {
1153   # Global variable:
1154   tagname="$1"
1155
1156   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
1157   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
1158   sed_extractcf="/$re_begincf/,/$re_endcf/p"
1159
1160   # Validate tagname.
1161   case $tagname in
1162     *[!-_A-Za-z0-9,/]*)
1163       func_fatal_error "invalid tag name: $tagname"
1164       ;;
1165   esac
1166
1167   # Don't test for the "default" C tag, as we know it's
1168   # there but not specially marked.
1169   case $tagname in
1170     CC) ;;
1171     *)
1172       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
1173         taglist="$taglist $tagname"
1174
1175         # Evaluate the configuration.  Be careful to quote the path
1176         # and the sed script, to avoid splitting on whitespace, but
1177         # also don't use non-portable quotes within backquotes within
1178         # quotes we have to do it in 2 steps:
1179         extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
1180         eval "$extractedcf"
1181       else
1182         func_error "ignoring unknown tag $tagname"
1183       fi
1184       ;;
1185   esac
1186 }
1187
1188 # Parse options once, thoroughly.  This comes as soon as possible in
1189 # the script to make things like `libtool --version' happen quickly.
1190 {
1191
1192   # Shorthand for --mode=foo, only valid as the first argument
1193   case $1 in
1194   clean|clea|cle|cl)
1195     shift; set dummy --mode clean ${1+"$@"}; shift
1196     ;;
1197   compile|compil|compi|comp|com|co|c)
1198     shift; set dummy --mode compile ${1+"$@"}; shift
1199     ;;
1200   execute|execut|execu|exec|exe|ex|e)
1201     shift; set dummy --mode execute ${1+"$@"}; shift
1202     ;;
1203   finish|finis|fini|fin|fi|f)
1204     shift; set dummy --mode finish ${1+"$@"}; shift
1205     ;;
1206   install|instal|insta|inst|ins|in|i)
1207     shift; set dummy --mode install ${1+"$@"}; shift
1208     ;;
1209   link|lin|li|l)
1210     shift; set dummy --mode link ${1+"$@"}; shift
1211     ;;
1212   uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
1213     shift; set dummy --mode uninstall ${1+"$@"}; shift
1214     ;;
1215   esac
1216
1217   # Parse non-mode specific arguments:
1218   while test "$#" -gt 0; do
1219     opt="$1"
1220     shift
1221
1222     case $opt in
1223       --config)         func_config                                     ;;
1224
1225       --debug)          preserve_args="$preserve_args $opt"
1226                         func_echo "enabling shell trace mode"
1227                         opt_debug='set -x'
1228                         $opt_debug
1229                         ;;
1230
1231       -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break
1232                         execute_dlfiles="$execute_dlfiles $1"
1233                         shift
1234                         ;;
1235
1236       --dry-run | -n)   opt_dry_run=:                                   ;;
1237       --features)       func_features                                   ;;
1238       --finish)         mode="finish"                                   ;;
1239
1240       --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break
1241                         case $1 in
1242                           # Valid mode arguments:
1243                           clean)        ;;
1244                           compile)      ;;
1245                           execute)      ;;
1246                           finish)       ;;
1247                           install)      ;;
1248                           link)         ;;
1249                           relink)       ;;
1250                           uninstall)    ;;
1251
1252                           # Catch anything else as an error
1253                           *) func_error "invalid argument for $opt"
1254                              exit_cmd=exit
1255                              break
1256                              ;;
1257                         esac
1258
1259                         mode="$1"
1260                         shift
1261                         ;;
1262
1263       --preserve-dup-deps)
1264                         opt_duplicate_deps=:                            ;;
1265
1266       --quiet|--silent) preserve_args="$preserve_args $opt"
1267                         opt_silent=:
1268                         ;;
1269
1270       --verbose| -v)    preserve_args="$preserve_args $opt"
1271                         opt_silent=false
1272                         ;;
1273
1274       --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break
1275                         preserve_args="$preserve_args $opt $1"
1276                         func_enable_tag "$1"    # tagname is set here
1277                         shift
1278                         ;;
1279
1280       # Separate optargs to long options:
1281       -dlopen=*|--mode=*|--tag=*)
1282                         func_opt_split "$opt"
1283                         set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}
1284                         shift
1285                         ;;
1286
1287       -\?|-h)           func_usage                                      ;;
1288       --help)           opt_help=:                                      ;;
1289       --version)        func_version                                    ;;
1290
1291       -*)               func_fatal_help "unrecognized option \`$opt'"   ;;
1292
1293       *)                nonopt="$opt"
1294                         break
1295                         ;;
1296     esac
1297   done
1298
1299
1300   case $host in
1301     *cygwin* | *mingw* | *pw32* | *cegcc*)
1302       # don't eliminate duplications in $postdeps and $predeps
1303       opt_duplicate_compiler_generated_deps=:
1304       ;;
1305     *)
1306       opt_duplicate_compiler_generated_deps=$opt_duplicate_deps
1307       ;;
1308   esac
1309
1310   # Having warned about all mis-specified options, bail out if
1311   # anything was wrong.
1312   $exit_cmd $EXIT_FAILURE
1313 }
1314
1315 # func_check_version_match
1316 # Ensure that we are using m4 macros, and libtool script from the same
1317 # release of libtool.
1318 func_check_version_match ()
1319 {
1320   if test "$package_revision" != "$macro_revision"; then
1321     if test "$VERSION" != "$macro_version"; then
1322       if test -z "$macro_version"; then
1323         cat >&2 <<_LT_EOF
1324 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
1325 $progname: definition of this LT_INIT comes from an older release.
1326 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1327 $progname: and run autoconf again.
1328 _LT_EOF
1329       else
1330         cat >&2 <<_LT_EOF
1331 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
1332 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
1333 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
1334 $progname: and run autoconf again.
1335 _LT_EOF
1336       fi
1337     else
1338       cat >&2 <<_LT_EOF
1339 $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
1340 $progname: but the definition of this LT_INIT comes from revision $macro_revision.
1341 $progname: You should recreate aclocal.m4 with macros from revision $package_revision
1342 $progname: of $PACKAGE $VERSION and run autoconf again.
1343 _LT_EOF
1344     fi
1345
1346     exit $EXIT_MISMATCH
1347   fi
1348 }
1349
1350
1351 ## ----------- ##
1352 ##    Main.    ##
1353 ## ----------- ##
1354
1355 $opt_help || {
1356   # Sanity checks first:
1357   func_check_version_match
1358
1359   if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
1360     func_fatal_configuration "not configured to build any kind of library"
1361   fi
1362
1363   test -z "$mode" && func_fatal_error "error: you must specify a MODE."
1364
1365
1366   # Darwin sucks
1367   eval std_shrext=\"$shrext_cmds\"
1368
1369
1370   # Only execute mode is allowed to have -dlopen flags.
1371   if test -n "$execute_dlfiles" && test "$mode" != execute; then
1372     func_error "unrecognized option \`-dlopen'"
1373     $ECHO "$help" 1>&2
1374     exit $EXIT_FAILURE
1375   fi
1376
1377   # Change the help message to a mode-specific one.
1378   generic_help="$help"
1379   help="Try \`$progname --help --mode=$mode' for more information."
1380 }
1381
1382
1383 # func_lalib_p file
1384 # True iff FILE is a libtool `.la' library or `.lo' object file.
1385 # This function is only a basic sanity check; it will hardly flush out
1386 # determined imposters.
1387 func_lalib_p ()
1388 {
1389     test -f "$1" &&
1390       $SED -e 4q "$1" 2>/dev/null \
1391         | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
1392 }
1393
1394 # func_lalib_unsafe_p file
1395 # True iff FILE is a libtool `.la' library or `.lo' object file.
1396 # This function implements the same check as func_lalib_p without
1397 # resorting to external programs.  To this end, it redirects stdin and
1398 # closes it afterwards, without saving the original file descriptor.
1399 # As a safety measure, use it only where a negative result would be
1400 # fatal anyway.  Works if `file' does not exist.
1401 func_lalib_unsafe_p ()
1402 {
1403     lalib_p=no
1404     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
1405         for lalib_p_l in 1 2 3 4
1406         do
1407             read lalib_p_line
1408             case "$lalib_p_line" in
1409                 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
1410             esac
1411         done
1412         exec 0<&5 5<&-
1413     fi
1414     test "$lalib_p" = yes
1415 }
1416
1417 # func_ltwrapper_script_p file
1418 # True iff FILE is a libtool wrapper script
1419 # This function is only a basic sanity check; it will hardly flush out
1420 # determined imposters.
1421 func_ltwrapper_script_p ()
1422 {
1423     func_lalib_p "$1"
1424 }
1425
1426 # func_ltwrapper_executable_p file
1427 # True iff FILE is a libtool wrapper executable
1428 # This function is only a basic sanity check; it will hardly flush out
1429 # determined imposters.
1430 func_ltwrapper_executable_p ()
1431 {
1432     func_ltwrapper_exec_suffix=
1433     case $1 in
1434     *.exe) ;;
1435     *) func_ltwrapper_exec_suffix=.exe ;;
1436     esac
1437     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
1438 }
1439
1440 # func_ltwrapper_scriptname file
1441 # Assumes file is an ltwrapper_executable
1442 # uses $file to determine the appropriate filename for a
1443 # temporary ltwrapper_script.
1444 func_ltwrapper_scriptname ()
1445 {
1446     func_ltwrapper_scriptname_result=""
1447     if func_ltwrapper_executable_p "$1"; then
1448         func_dirname_and_basename "$1" "" "."
1449         func_stripname '' '.exe' "$func_basename_result"
1450         func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
1451     fi
1452 }
1453
1454 # func_ltwrapper_p file
1455 # True iff FILE is a libtool wrapper script or wrapper executable
1456 # This function is only a basic sanity check; it will hardly flush out
1457 # determined imposters.
1458 func_ltwrapper_p ()
1459 {
1460     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
1461 }
1462
1463
1464 # func_execute_cmds commands fail_cmd
1465 # Execute tilde-delimited COMMANDS.
1466 # If FAIL_CMD is given, eval that upon failure.
1467 # FAIL_CMD may read-access the current command in variable CMD!
1468 func_execute_cmds ()
1469 {
1470     $opt_debug
1471     save_ifs=$IFS; IFS='~'
1472     for cmd in $1; do
1473       IFS=$save_ifs
1474       eval cmd=\"$cmd\"
1475       func_show_eval "$cmd" "${2-:}"
1476     done
1477     IFS=$save_ifs
1478 }
1479
1480
1481 # func_source file
1482 # Source FILE, adding directory component if necessary.
1483 # Note that it is not necessary on cygwin/mingw to append a dot to
1484 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
1485 # behavior happens only for exec(3), not for open(2)!  Also, sourcing
1486 # `FILE.' does not work on cygwin managed mounts.
1487 func_source ()
1488 {
1489     $opt_debug
1490     case $1 in
1491     */* | *\\*) . "$1" ;;
1492     *)          . "./$1" ;;
1493     esac
1494 }
1495
1496
1497 # func_infer_tag arg
1498 # Infer tagged configuration to use if any are available and
1499 # if one wasn't chosen via the "--tag" command line option.
1500 # Only attempt this if the compiler in the base compile
1501 # command doesn't match the default compiler.
1502 # arg is usually of the form 'gcc ...'
1503 func_infer_tag ()
1504 {
1505     $opt_debug
1506     if test -n "$available_tags" && test -z "$tagname"; then
1507       CC_quoted=
1508       for arg in $CC; do
1509         func_quote_for_eval "$arg"
1510         CC_quoted="$CC_quoted $func_quote_for_eval_result"
1511       done
1512       case $@ in
1513       # Blanks in the command may have been stripped by the calling shell,
1514       # but not from the CC environment variable when configure was run.
1515       " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;
1516       # Blanks at the start of $base_compile will cause this to fail
1517       # if we don't check for them as well.
1518       *)
1519         for z in $available_tags; do
1520           if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
1521             # Evaluate the configuration.
1522             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
1523             CC_quoted=
1524             for arg in $CC; do
1525               # Double-quote args containing other shell metacharacters.
1526               func_quote_for_eval "$arg"
1527               CC_quoted="$CC_quoted $func_quote_for_eval_result"
1528             done
1529             case "$@ " in
1530               " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)
1531               # The compiler in the base compile command matches
1532               # the one in the tagged configuration.
1533               # Assume this is the tagged configuration we want.
1534               tagname=$z
1535               break
1536               ;;
1537             esac
1538           fi
1539         done
1540         # If $tagname still isn't set, then no tagged configuration
1541         # was found and let the user know that the "--tag" command
1542         # line option must be used.
1543         if test -z "$tagname"; then
1544           func_echo "unable to infer tagged configuration"
1545           func_fatal_error "specify a tag with \`--tag'"
1546 #       else
1547 #         func_verbose "using $tagname tagged configuration"
1548         fi
1549         ;;
1550       esac
1551     fi
1552 }
1553
1554
1555
1556 # func_write_libtool_object output_name pic_name nonpic_name
1557 # Create a libtool object file (analogous to a ".la" file),
1558 # but don't create it if we're doing a dry run.
1559 func_write_libtool_object ()
1560 {
1561     write_libobj=${1}
1562     if test "$build_libtool_libs" = yes; then
1563       write_lobj=\'${2}\'
1564     else
1565       write_lobj=none
1566     fi
1567
1568     if test "$build_old_libs" = yes; then
1569       write_oldobj=\'${3}\'
1570     else
1571       write_oldobj=none
1572     fi
1573
1574     $opt_dry_run || {
1575       cat >${write_libobj}T <<EOF
1576 # $write_libobj - a libtool object file
1577 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
1578 #
1579 # Please DO NOT delete this file!
1580 # It is necessary for linking the library.
1581
1582 # Name of the PIC object.
1583 pic_object=$write_lobj
1584
1585 # Name of the non-PIC object
1586 non_pic_object=$write_oldobj
1587
1588 EOF
1589       $MV "${write_libobj}T" "${write_libobj}"
1590     }
1591 }
1592
1593 # func_mode_compile arg...
1594 func_mode_compile ()
1595 {
1596     $opt_debug
1597     # Get the compilation command and the source file.
1598     base_compile=
1599     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
1600     suppress_opt=yes
1601     suppress_output=
1602     arg_mode=normal
1603     libobj=
1604     later=
1605     pie_flag=
1606
1607     for arg
1608     do
1609       case $arg_mode in
1610       arg  )
1611         # do not "continue".  Instead, add this to base_compile
1612         lastarg="$arg"
1613         arg_mode=normal
1614         ;;
1615
1616       target )
1617         libobj="$arg"
1618         arg_mode=normal
1619         continue
1620         ;;
1621
1622       normal )
1623         # Accept any command-line options.
1624         case $arg in
1625         -o)
1626           test -n "$libobj" && \
1627             func_fatal_error "you cannot specify \`-o' more than once"
1628           arg_mode=target
1629           continue
1630           ;;
1631
1632         -pie | -fpie | -fPIE)
1633           pie_flag="$pie_flag $arg"
1634           continue
1635           ;;
1636
1637         -shared | -static | -prefer-pic | -prefer-non-pic)
1638           later="$later $arg"
1639           continue
1640           ;;
1641
1642         -no-suppress)
1643           suppress_opt=no
1644           continue
1645           ;;
1646
1647         -Xcompiler)
1648           arg_mode=arg  #  the next one goes into the "base_compile" arg list
1649           continue      #  The current "srcfile" will either be retained or
1650           ;;            #  replaced later.  I would guess that would be a bug.
1651
1652         -Wc,*)
1653           func_stripname '-Wc,' '' "$arg"
1654           args=$func_stripname_result
1655           lastarg=
1656           save_ifs="$IFS"; IFS=','
1657           for arg in $args; do
1658             IFS="$save_ifs"
1659             func_quote_for_eval "$arg"
1660             lastarg="$lastarg $func_quote_for_eval_result"
1661           done
1662           IFS="$save_ifs"
1663           func_stripname ' ' '' "$lastarg"
1664           lastarg=$func_stripname_result
1665
1666           # Add the arguments to base_compile.
1667           base_compile="$base_compile $lastarg"
1668           continue
1669           ;;
1670
1671         *)
1672           # Accept the current argument as the source file.
1673           # The previous "srcfile" becomes the current argument.
1674           #
1675           lastarg="$srcfile"
1676           srcfile="$arg"
1677           ;;
1678         esac  #  case $arg
1679         ;;
1680       esac    #  case $arg_mode
1681
1682       # Aesthetically quote the previous argument.
1683       func_quote_for_eval "$lastarg"
1684       base_compile="$base_compile $func_quote_for_eval_result"
1685     done # for arg
1686
1687     case $arg_mode in
1688     arg)
1689       func_fatal_error "you must specify an argument for -Xcompile"
1690       ;;
1691     target)
1692       func_fatal_error "you must specify a target with \`-o'"
1693       ;;
1694     *)
1695       # Get the name of the library object.
1696       test -z "$libobj" && {
1697         func_basename "$srcfile"
1698         libobj="$func_basename_result"
1699       }
1700       ;;
1701     esac
1702
1703     # Recognize several different file suffixes.
1704     # If the user specifies -o file.o, it is replaced with file.lo
1705     case $libobj in
1706     *.[cCFSifmso] | \
1707     *.ada | *.adb | *.ads | *.asm | \
1708     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
1709     *.[fF][09]? | *.for | *.java | *.obj | *.sx)
1710       func_xform "$libobj"
1711       libobj=$func_xform_result
1712       ;;
1713     esac
1714
1715     case $libobj in
1716     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
1717     *)
1718       func_fatal_error "cannot determine name of library object from \`$libobj'"
1719       ;;
1720     esac
1721
1722     func_infer_tag $base_compile
1723
1724     for arg in $later; do
1725       case $arg in
1726       -shared)
1727         test "$build_libtool_libs" != yes && \
1728           func_fatal_configuration "can not build a shared library"
1729         build_old_libs=no
1730         continue
1731         ;;
1732
1733       -static)
1734         build_libtool_libs=no
1735         build_old_libs=yes
1736         continue
1737         ;;
1738
1739       -prefer-pic)
1740         pic_mode=yes
1741         continue
1742         ;;
1743
1744       -prefer-non-pic)
1745         pic_mode=no
1746         continue
1747         ;;
1748       esac
1749     done
1750
1751     func_quote_for_eval "$libobj"
1752     test "X$libobj" != "X$func_quote_for_eval_result" \
1753       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
1754       && func_warning "libobj name \`$libobj' may not contain shell special characters."
1755     func_dirname_and_basename "$obj" "/" ""
1756     objname="$func_basename_result"
1757     xdir="$func_dirname_result"
1758     lobj=${xdir}$objdir/$objname
1759
1760     test -z "$base_compile" && \
1761       func_fatal_help "you must specify a compilation command"
1762
1763     # Delete any leftover library objects.
1764     if test "$build_old_libs" = yes; then
1765       removelist="$obj $lobj $libobj ${libobj}T"
1766     else
1767       removelist="$lobj $libobj ${libobj}T"
1768     fi
1769
1770     # On Cygwin there's no "real" PIC flag so we must build both object types
1771     case $host_os in
1772     cygwin* | mingw* | pw32* | os2* | cegcc*)
1773       pic_mode=default
1774       ;;
1775     esac
1776     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
1777       # non-PIC code in shared libraries is not supported
1778       pic_mode=default
1779     fi
1780
1781     # Calculate the filename of the output object if compiler does
1782     # not support -o with -c
1783     if test "$compiler_c_o" = no; then
1784       output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
1785       lockfile="$output_obj.lock"
1786     else
1787       output_obj=
1788       need_locks=no
1789       lockfile=
1790     fi
1791
1792     # Lock this critical section if it is needed
1793     # We use this script file to make the link, it avoids creating a new file
1794     if test "$need_locks" = yes; then
1795       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
1796         func_echo "Waiting for $lockfile to be removed"
1797         sleep 2
1798       done
1799     elif test "$need_locks" = warn; then
1800       if test -f "$lockfile"; then
1801         $ECHO "\
1802 *** ERROR, $lockfile exists and contains:
1803 `cat $lockfile 2>/dev/null`
1804
1805 This indicates that another process is trying to use the same
1806 temporary object file, and libtool could not work around it because
1807 your compiler does not support \`-c' and \`-o' together.  If you
1808 repeat this compilation, it may succeed, by chance, but you had better
1809 avoid parallel builds (make -j) in this platform, or get a better
1810 compiler."
1811
1812         $opt_dry_run || $RM $removelist
1813         exit $EXIT_FAILURE
1814       fi
1815       removelist="$removelist $output_obj"
1816       $ECHO "$srcfile" > "$lockfile"
1817     fi
1818
1819     $opt_dry_run || $RM $removelist
1820     removelist="$removelist $lockfile"
1821     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
1822
1823     if test -n "$fix_srcfile_path"; then
1824       eval srcfile=\"$fix_srcfile_path\"
1825     fi
1826     func_quote_for_eval "$srcfile"
1827     qsrcfile=$func_quote_for_eval_result
1828
1829     # Only build a PIC object if we are building libtool libraries.
1830     if test "$build_libtool_libs" = yes; then
1831       # Without this assignment, base_compile gets emptied.
1832       fbsd_hideous_sh_bug=$base_compile
1833
1834       if test "$pic_mode" != no; then
1835         command="$base_compile $qsrcfile $pic_flag"
1836       else
1837         # Don't build PIC code
1838         command="$base_compile $qsrcfile"
1839       fi
1840
1841       func_mkdir_p "$xdir$objdir"
1842
1843       if test -z "$output_obj"; then
1844         # Place PIC objects in $objdir
1845         command="$command -o $lobj"
1846       fi
1847
1848       func_show_eval_locale "$command"  \
1849           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
1850
1851       if test "$need_locks" = warn &&
1852          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1853         $ECHO "\
1854 *** ERROR, $lockfile contains:
1855 `cat $lockfile 2>/dev/null`
1856
1857 but it should contain:
1858 $srcfile
1859
1860 This indicates that another process is trying to use the same
1861 temporary object file, and libtool could not work around it because
1862 your compiler does not support \`-c' and \`-o' together.  If you
1863 repeat this compilation, it may succeed, by chance, but you had better
1864 avoid parallel builds (make -j) in this platform, or get a better
1865 compiler."
1866
1867         $opt_dry_run || $RM $removelist
1868         exit $EXIT_FAILURE
1869       fi
1870
1871       # Just move the object if needed, then go on to compile the next one
1872       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
1873         func_show_eval '$MV "$output_obj" "$lobj"' \
1874           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1875       fi
1876
1877       # Allow error messages only from the first compilation.
1878       if test "$suppress_opt" = yes; then
1879         suppress_output=' >/dev/null 2>&1'
1880       fi
1881     fi
1882
1883     # Only build a position-dependent object if we build old libraries.
1884     if test "$build_old_libs" = yes; then
1885       if test "$pic_mode" != yes; then
1886         # Don't build PIC code
1887         command="$base_compile $qsrcfile$pie_flag"
1888       else
1889         command="$base_compile $qsrcfile $pic_flag"
1890       fi
1891       if test "$compiler_c_o" = yes; then
1892         command="$command -o $obj"
1893       fi
1894
1895       # Suppress compiler output if we already did a PIC compilation.
1896       command="$command$suppress_output"
1897       func_show_eval_locale "$command" \
1898         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1899
1900       if test "$need_locks" = warn &&
1901          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1902         $ECHO "\
1903 *** ERROR, $lockfile contains:
1904 `cat $lockfile 2>/dev/null`
1905
1906 but it should contain:
1907 $srcfile
1908
1909 This indicates that another process is trying to use the same
1910 temporary object file, and libtool could not work around it because
1911 your compiler does not support \`-c' and \`-o' together.  If you
1912 repeat this compilation, it may succeed, by chance, but you had better
1913 avoid parallel builds (make -j) in this platform, or get a better
1914 compiler."
1915
1916         $opt_dry_run || $RM $removelist
1917         exit $EXIT_FAILURE
1918       fi
1919
1920       # Just move the object if needed
1921       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1922         func_show_eval '$MV "$output_obj" "$obj"' \
1923           'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1924       fi
1925     fi
1926
1927     $opt_dry_run || {
1928       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
1929
1930       # Unlock the critical section if it was locked
1931       if test "$need_locks" != no; then
1932         removelist=$lockfile
1933         $RM "$lockfile"
1934       fi
1935     }
1936
1937     exit $EXIT_SUCCESS
1938 }
1939
1940 $opt_help || {
1941 test "$mode" = compile && func_mode_compile ${1+"$@"}
1942 }
1943
1944 func_mode_help ()
1945 {
1946     # We need to display help for each of the modes.
1947     case $mode in
1948       "")
1949         # Generic help is extracted from the usage comments
1950         # at the start of this file.
1951         func_help
1952         ;;
1953
1954       clean)
1955         $ECHO \
1956 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
1957
1958 Remove files from the build directory.
1959
1960 RM is the name of the program to use to delete files associated with each FILE
1961 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
1962 to RM.
1963
1964 If FILE is a libtool library, object or program, all the files associated
1965 with it are deleted. Otherwise, only FILE itself is deleted using RM."
1966         ;;
1967
1968       compile)
1969       $ECHO \
1970 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
1971
1972 Compile a source file into a libtool library object.
1973
1974 This mode accepts the following additional options:
1975
1976   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
1977   -no-suppress      do not suppress compiler output for multiple passes
1978   -prefer-pic       try to building PIC objects only
1979   -prefer-non-pic   try to building non-PIC objects only
1980   -shared           do not build a \`.o' file suitable for static linking
1981   -static           only build a \`.o' file suitable for static linking
1982
1983 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
1984 from the given SOURCEFILE.
1985
1986 The output file name is determined by removing the directory component from
1987 SOURCEFILE, then substituting the C source code suffix \`.c' with the
1988 library object suffix, \`.lo'."
1989         ;;
1990
1991       execute)
1992         $ECHO \
1993 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
1994
1995 Automatically set library path, then run a program.
1996
1997 This mode accepts the following additional options:
1998
1999   -dlopen FILE      add the directory containing FILE to the library path
2000
2001 This mode sets the library path environment variable according to \`-dlopen'
2002 flags.
2003
2004 If any of the ARGS are libtool executable wrappers, then they are translated
2005 into their corresponding uninstalled binary, and any of their required library
2006 directories are added to the library path.
2007
2008 Then, COMMAND is executed, with ARGS as arguments."
2009         ;;
2010
2011       finish)
2012         $ECHO \
2013 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
2014
2015 Complete the installation of libtool libraries.
2016
2017 Each LIBDIR is a directory that contains libtool libraries.
2018
2019 The commands that this mode executes may require superuser privileges.  Use
2020 the \`--dry-run' option if you just want to see what would be executed."
2021         ;;
2022
2023       install)
2024         $ECHO \
2025 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
2026
2027 Install executables or libraries.
2028
2029 INSTALL-COMMAND is the installation command.  The first component should be
2030 either the \`install' or \`cp' program.
2031
2032 The following components of INSTALL-COMMAND are treated specially:
2033
2034   -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
2035
2036 The rest of the components are interpreted as arguments to that command (only
2037 BSD-compatible install options are recognized)."
2038         ;;
2039
2040       link)
2041         $ECHO \
2042 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
2043
2044 Link object files or libraries together to form another library, or to
2045 create an executable program.
2046
2047 LINK-COMMAND is a command using the C compiler that you would use to create
2048 a program from several object files.
2049
2050 The following components of LINK-COMMAND are treated specially:
2051
2052   -all-static       do not do any dynamic linking at all
2053   -avoid-version    do not add a version suffix if possible
2054   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
2055   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
2056   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
2057   -export-symbols SYMFILE
2058                     try to export only the symbols listed in SYMFILE
2059   -export-symbols-regex REGEX
2060                     try to export only the symbols matching REGEX
2061   -LLIBDIR          search LIBDIR for required installed libraries
2062   -lNAME            OUTPUT-FILE requires the installed library libNAME
2063   -module           build a library that can dlopened
2064   -no-fast-install  disable the fast-install mode
2065   -no-install       link a not-installable executable
2066   -no-undefined     declare that a library does not refer to external symbols
2067   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
2068   -objectlist FILE  Use a list of object files found in FILE to specify objects
2069   -precious-files-regex REGEX
2070                     don't remove output files matching REGEX
2071   -release RELEASE  specify package release information
2072   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
2073   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
2074   -shared           only do dynamic linking of libtool libraries
2075   -shrext SUFFIX    override the standard shared library file extension
2076   -static           do not do any dynamic linking of uninstalled libtool libraries
2077   -static-libtool-libs
2078                     do not do any dynamic linking of libtool libraries
2079   -version-info CURRENT[:REVISION[:AGE]]
2080                     specify library version info [each variable defaults to 0]
2081   -weak LIBNAME     declare that the target provides the LIBNAME interface
2082
2083 All other options (arguments beginning with \`-') are ignored.
2084
2085 Every other argument is treated as a filename.  Files ending in \`.la' are
2086 treated as uninstalled libtool libraries, other files are standard or library
2087 object files.
2088
2089 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
2090 only library objects (\`.lo' files) may be specified, and \`-rpath' is
2091 required, except when creating a convenience library.
2092
2093 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
2094 using \`ar' and \`ranlib', or on Windows using \`lib'.
2095
2096 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
2097 is created, otherwise an executable program is created."
2098         ;;
2099
2100       uninstall)
2101         $ECHO \
2102 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
2103
2104 Remove libraries from an installation directory.
2105
2106 RM is the name of the program to use to delete files associated with each FILE
2107 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
2108 to RM.
2109
2110 If FILE is a libtool library, all the files associated with it are deleted.
2111 Otherwise, only FILE itself is deleted using RM."
2112         ;;
2113
2114       *)
2115         func_fatal_help "invalid operation mode \`$mode'"
2116         ;;
2117     esac
2118
2119     $ECHO
2120     $ECHO "Try \`$progname --help' for more information about other modes."
2121
2122     exit $?
2123 }
2124
2125   # Now that we've collected a possible --mode arg, show help if necessary
2126   $opt_help && func_mode_help
2127
2128
2129 # func_mode_execute arg...
2130 func_mode_execute ()
2131 {
2132     $opt_debug
2133     # The first argument is the command name.
2134     cmd="$nonopt"
2135     test -z "$cmd" && \
2136       func_fatal_help "you must specify a COMMAND"
2137
2138     # Handle -dlopen flags immediately.
2139     for file in $execute_dlfiles; do
2140       test -f "$file" \
2141         || func_fatal_help "\`$file' is not a file"
2142
2143       dir=
2144       case $file in
2145       *.la)
2146         # Check to see that this really is a libtool archive.
2147         func_lalib_unsafe_p "$file" \
2148           || func_fatal_help "\`$lib' is not a valid libtool archive"
2149
2150         # Read the libtool library.
2151         dlname=
2152         library_names=
2153         func_source "$file"
2154
2155         # Skip this library if it cannot be dlopened.
2156         if test -z "$dlname"; then
2157           # Warn if it was a shared library.
2158           test -n "$library_names" && \
2159             func_warning "\`$file' was not linked with \`-export-dynamic'"
2160           continue
2161         fi
2162
2163         func_dirname "$file" "" "."
2164         dir="$func_dirname_result"
2165
2166         if test -f "$dir/$objdir/$dlname"; then
2167           dir="$dir/$objdir"
2168         else
2169           if test ! -f "$dir/$dlname"; then
2170             func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
2171           fi
2172         fi
2173         ;;
2174
2175       *.lo)
2176         # Just add the directory containing the .lo file.
2177         func_dirname "$file" "" "."
2178         dir="$func_dirname_result"
2179         ;;
2180
2181       *)
2182         func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
2183         continue
2184         ;;
2185       esac
2186
2187       # Get the absolute pathname.
2188       absdir=`cd "$dir" && pwd`
2189       test -n "$absdir" && dir="$absdir"
2190
2191       # Now add the directory to shlibpath_var.
2192       if eval "test -z \"\$$shlibpath_var\""; then
2193         eval "$shlibpath_var=\"\$dir\""
2194       else
2195         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
2196       fi
2197     done
2198
2199     # This variable tells wrapper scripts just to set shlibpath_var
2200     # rather than running their programs.
2201     libtool_execute_magic="$magic"
2202
2203     # Check if any of the arguments is a wrapper script.
2204     args=
2205     for file
2206     do
2207       case $file in
2208       -*) ;;
2209       *)
2210         # Do a test to see if this is really a libtool program.
2211         if func_ltwrapper_script_p "$file"; then
2212           func_source "$file"
2213           # Transform arg to wrapped name.
2214           file="$progdir/$program"
2215         elif func_ltwrapper_executable_p "$file"; then
2216           func_ltwrapper_scriptname "$file"
2217           func_source "$func_ltwrapper_scriptname_result"
2218           # Transform arg to wrapped name.
2219           file="$progdir/$program"
2220         fi
2221         ;;
2222       esac
2223       # Quote arguments (to preserve shell metacharacters).
2224       func_quote_for_eval "$file"
2225       args="$args $func_quote_for_eval_result"
2226     done
2227
2228     if test "X$opt_dry_run" = Xfalse; then
2229       if test -n "$shlibpath_var"; then
2230         # Export the shlibpath_var.
2231         eval "export $shlibpath_var"
2232       fi
2233
2234       # Restore saved environment variables
2235       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
2236       do
2237         eval "if test \"\${save_$lt_var+set}\" = set; then
2238                 $lt_var=\$save_$lt_var; export $lt_var
2239               else
2240                 $lt_unset $lt_var
2241               fi"
2242       done
2243
2244       # Now prepare to actually exec the command.
2245       exec_cmd="\$cmd$args"
2246     else
2247       # Display what would be done.
2248       if test -n "$shlibpath_var"; then
2249         eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
2250         $ECHO "export $shlibpath_var"
2251       fi
2252       $ECHO "$cmd$args"
2253       exit $EXIT_SUCCESS
2254     fi
2255 }
2256
2257 test "$mode" = execute && func_mode_execute ${1+"$@"}
2258
2259
2260 # func_mode_finish arg...
2261 func_mode_finish ()
2262 {
2263     $opt_debug
2264     libdirs="$nonopt"
2265     admincmds=
2266
2267     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
2268       for dir
2269       do
2270         libdirs="$libdirs $dir"
2271       done
2272
2273       for libdir in $libdirs; do
2274         if test -n "$finish_cmds"; then
2275           # Do each command in the finish commands.
2276           func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
2277 '"$cmd"'"'
2278         fi
2279         if test -n "$finish_eval"; then
2280           # Do the single finish_eval.
2281           eval cmds=\"$finish_eval\"
2282           $opt_dry_run || eval "$cmds" || admincmds="$admincmds
2283        $cmds"
2284         fi
2285       done
2286     fi
2287
2288     # Exit here if they wanted silent mode.
2289     $opt_silent && exit $EXIT_SUCCESS
2290
2291     $ECHO "X----------------------------------------------------------------------" | $Xsed
2292     $ECHO "Libraries have been installed in:"
2293     for libdir in $libdirs; do
2294       $ECHO "   $libdir"
2295     done
2296     $ECHO
2297     $ECHO "If you ever happen to want to link against installed libraries"
2298     $ECHO "in a given directory, LIBDIR, you must either use libtool, and"
2299     $ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"
2300     $ECHO "flag during linking and do at least one of the following:"
2301     if test -n "$shlibpath_var"; then
2302       $ECHO "   - add LIBDIR to the \`$shlibpath_var' environment variable"
2303       $ECHO "     during execution"
2304     fi
2305     if test -n "$runpath_var"; then
2306       $ECHO "   - add LIBDIR to the \`$runpath_var' environment variable"
2307       $ECHO "     during linking"
2308     fi
2309     if test -n "$hardcode_libdir_flag_spec"; then
2310       libdir=LIBDIR
2311       eval flag=\"$hardcode_libdir_flag_spec\"
2312
2313       $ECHO "   - use the \`$flag' linker flag"
2314     fi
2315     if test -n "$admincmds"; then
2316       $ECHO "   - have your system administrator run these commands:$admincmds"
2317     fi
2318     if test -f /etc/ld.so.conf; then
2319       $ECHO "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
2320     fi
2321     $ECHO
2322
2323     $ECHO "See any operating system documentation about shared libraries for"
2324     case $host in
2325       solaris2.[6789]|solaris2.1[0-9])
2326         $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"
2327         $ECHO "pages."
2328         ;;
2329       *)
2330         $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."
2331         ;;
2332     esac
2333     $ECHO "X----------------------------------------------------------------------" | $Xsed
2334     exit $EXIT_SUCCESS
2335 }
2336
2337 test "$mode" = finish && func_mode_finish ${1+"$@"}
2338
2339
2340 # func_mode_install arg...
2341 func_mode_install ()
2342 {
2343     $opt_debug
2344     # There may be an optional sh(1) argument at the beginning of
2345     # install_prog (especially on Windows NT).
2346     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
2347        # Allow the use of GNU shtool's install command.
2348        $ECHO "X$nonopt" | $GREP shtool >/dev/null; then
2349       # Aesthetically quote it.
2350       func_quote_for_eval "$nonopt"
2351       install_prog="$func_quote_for_eval_result "
2352       arg=$1
2353       shift
2354     else
2355       install_prog=
2356       arg=$nonopt
2357     fi
2358
2359     # The real first argument should be the name of the installation program.
2360     # Aesthetically quote it.
2361     func_quote_for_eval "$arg"
2362     install_prog="$install_prog$func_quote_for_eval_result"
2363
2364     # We need to accept at least all the BSD install flags.
2365     dest=
2366     files=
2367     opts=
2368     prev=
2369     install_type=
2370     isdir=no
2371     stripme=
2372     for arg
2373     do
2374       if test -n "$dest"; then
2375         files="$files $dest"
2376         dest=$arg
2377         continue
2378       fi
2379
2380       case $arg in
2381       -d) isdir=yes ;;
2382       -f)
2383         case " $install_prog " in
2384         *[\\\ /]cp\ *) ;;
2385         *) prev=$arg ;;
2386         esac
2387         ;;
2388       -g | -m | -o)
2389         prev=$arg
2390         ;;
2391       -s)
2392         stripme=" -s"
2393         continue
2394         ;;
2395       -*)
2396         ;;
2397       *)
2398         # If the previous option needed an argument, then skip it.
2399         if test -n "$prev"; then
2400           prev=
2401         else
2402           dest=$arg
2403           continue
2404         fi
2405         ;;
2406       esac
2407
2408       # Aesthetically quote the argument.
2409       func_quote_for_eval "$arg"
2410       install_prog="$install_prog $func_quote_for_eval_result"
2411     done
2412
2413     test -z "$install_prog" && \
2414       func_fatal_help "you must specify an install program"
2415
2416     test -n "$prev" && \
2417       func_fatal_help "the \`$prev' option requires an argument"
2418
2419     if test -z "$files"; then
2420       if test -z "$dest"; then
2421         func_fatal_help "no file or destination specified"
2422       else
2423         func_fatal_help "you must specify a destination"
2424       fi
2425     fi
2426
2427     # Strip any trailing slash from the destination.
2428     func_stripname '' '/' "$dest"
2429     dest=$func_stripname_result
2430
2431     # Check to see that the destination is a directory.
2432     test -d "$dest" && isdir=yes
2433     if test "$isdir" = yes; then
2434       destdir="$dest"
2435       destname=
2436     else
2437       func_dirname_and_basename "$dest" "" "."
2438       destdir="$func_dirname_result"
2439       destname="$func_basename_result"
2440
2441       # Not a directory, so check to see that there is only one file specified.
2442       set dummy $files; shift
2443       test "$#" -gt 1 && \
2444         func_fatal_help "\`$dest' is not a directory"
2445     fi
2446     case $destdir in
2447     [\\/]* | [A-Za-z]:[\\/]*) ;;
2448     *)
2449       for file in $files; do
2450         case $file in
2451         *.lo) ;;
2452         *)
2453           func_fatal_help "\`$destdir' must be an absolute directory name"
2454           ;;
2455         esac
2456       done
2457       ;;
2458     esac
2459
2460     # This variable tells wrapper scripts just to set variables rather
2461     # than running their programs.
2462     libtool_install_magic="$magic"
2463
2464     staticlibs=
2465     future_libdirs=
2466     current_libdirs=
2467     for file in $files; do
2468
2469       # Do each installation.
2470       case $file in
2471       *.$libext)
2472         # Do the static libraries later.
2473         staticlibs="$staticlibs $file"
2474         ;;
2475
2476       *.la)
2477         # Check to see that this really is a libtool archive.
2478         func_lalib_unsafe_p "$file" \
2479           || func_fatal_help "\`$file' is not a valid libtool archive"
2480
2481         library_names=
2482         old_library=
2483         relink_command=
2484         func_source "$file"
2485
2486         # Add the libdir to current_libdirs if it is the destination.
2487         if test "X$destdir" = "X$libdir"; then
2488           case "$current_libdirs " in
2489           *" $libdir "*) ;;
2490           *) current_libdirs="$current_libdirs $libdir" ;;
2491           esac
2492         else
2493           # Note the libdir as a future libdir.
2494           case "$future_libdirs " in
2495           *" $libdir "*) ;;
2496           *) future_libdirs="$future_libdirs $libdir" ;;
2497           esac
2498         fi
2499
2500         func_dirname "$file" "/" ""
2501         dir="$func_dirname_result"
2502         dir="$dir$objdir"
2503
2504         if test -n "$relink_command"; then
2505           # Determine the prefix the user has applied to our future dir.
2506           inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`
2507
2508           # Don't allow the user to place us outside of our expected
2509           # location b/c this prevents finding dependent libraries that
2510           # are installed to the same prefix.
2511           # At present, this check doesn't affect windows .dll's that
2512           # are installed into $libdir/../bin (currently, that works fine)
2513           # but it's something to keep an eye on.
2514           test "$inst_prefix_dir" = "$destdir" && \
2515             func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
2516
2517           if test -n "$inst_prefix_dir"; then
2518             # Stick the inst_prefix_dir data into the link command.
2519             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
2520           else
2521             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`
2522           fi
2523
2524           func_warning "relinking \`$file'"
2525           func_show_eval "$relink_command" \
2526             'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
2527         fi
2528
2529         # See the names of the shared library.
2530         set dummy $library_names; shift
2531         if test -n "$1"; then
2532           realname="$1"
2533           shift
2534
2535           srcname="$realname"
2536           test -n "$relink_command" && srcname="$realname"T
2537
2538           # Install the shared library and build the symlinks.
2539           func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \
2540               'exit $?'
2541           tstripme="$stripme"
2542           case $host_os in
2543           cygwin* | mingw* | pw32* | cegcc*)
2544             case $realname in
2545             *.dll.a)
2546               tstripme=""
2547               ;;
2548             esac
2549             ;;
2550           esac
2551           if test -n "$tstripme" && test -n "$striplib"; then
2552             func_show_eval "$striplib $destdir/$realname" 'exit $?'
2553           fi
2554
2555           if test "$#" -gt 0; then
2556             # Delete the old symlinks, and create new ones.
2557             # Try `ln -sf' first, because the `ln' binary might depend on
2558             # the symlink we replace!  Solaris /bin/ln does not understand -f,
2559             # so we also need to try rm && ln -s.
2560             for linkname
2561             do
2562               test "$linkname" != "$realname" \
2563                 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
2564             done
2565           fi
2566
2567           # Do each command in the postinstall commands.
2568           lib="$destdir/$realname"
2569           func_execute_cmds "$postinstall_cmds" 'exit $?'
2570         fi
2571
2572         # Install the pseudo-library for information purposes.
2573         func_basename "$file"
2574         name="$func_basename_result"
2575         instname="$dir/$name"i
2576         func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
2577
2578         # Maybe install the static library, too.
2579         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
2580         ;;
2581
2582       *.lo)
2583         # Install (i.e. copy) a libtool object.
2584
2585         # Figure out destination file name, if it wasn't already specified.
2586         if test -n "$destname"; then
2587           destfile="$destdir/$destname"
2588         else
2589           func_basename "$file"
2590           destfile="$func_basename_result"
2591           destfile="$destdir/$destfile"
2592         fi
2593
2594         # Deduce the name of the destination old-style object file.
2595         case $destfile in
2596         *.lo)
2597           func_lo2o "$destfile"
2598           staticdest=$func_lo2o_result
2599           ;;
2600         *.$objext)
2601           staticdest="$destfile"
2602           destfile=
2603           ;;
2604         *)
2605           func_fatal_help "cannot copy a libtool object to \`$destfile'"
2606           ;;
2607         esac
2608
2609         # Install the libtool object if requested.
2610         test -n "$destfile" && \
2611           func_show_eval "$install_prog $file $destfile" 'exit $?'
2612
2613         # Install the old object if enabled.
2614         if test "$build_old_libs" = yes; then
2615           # Deduce the name of the old-style object file.
2616           func_lo2o "$file"
2617           staticobj=$func_lo2o_result
2618           func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
2619         fi
2620         exit $EXIT_SUCCESS
2621         ;;
2622
2623       *)
2624         # Figure out destination file name, if it wasn't already specified.
2625         if test -n "$destname"; then
2626           destfile="$destdir/$destname"
2627         else
2628           func_basename "$file"
2629           destfile="$func_basename_result"
2630           destfile="$destdir/$destfile"
2631         fi
2632
2633         # If the file is missing, and there is a .exe on the end, strip it
2634         # because it is most likely a libtool script we actually want to
2635         # install
2636         stripped_ext=""
2637         case $file in
2638           *.exe)
2639             if test ! -f "$file"; then
2640               func_stripname '' '.exe' "$file"
2641               file=$func_stripname_result
2642               stripped_ext=".exe"
2643             fi
2644             ;;
2645         esac
2646
2647         # Do a test to see if this is really a libtool program.
2648         case $host in
2649         *cygwin* | *mingw*)
2650             if func_ltwrapper_executable_p "$file"; then
2651               func_ltwrapper_scriptname "$file"
2652               wrapper=$func_ltwrapper_scriptname_result
2653             else
2654               func_stripname '' '.exe' "$file"
2655               wrapper=$func_stripname_result
2656             fi
2657             ;;
2658         *)
2659             wrapper=$file
2660             ;;
2661         esac
2662         if func_ltwrapper_script_p "$wrapper"; then
2663           notinst_deplibs=
2664           relink_command=
2665
2666           func_source "$wrapper"
2667
2668           # Check the variables that should have been set.
2669           test -z "$generated_by_libtool_version" && \
2670             func_fatal_error "invalid libtool wrapper script \`$wrapper'"
2671
2672           finalize=yes
2673           for lib in $notinst_deplibs; do
2674             # Check to see that each library is installed.
2675             libdir=
2676             if test -f "$lib"; then
2677               func_source "$lib"
2678             fi
2679             libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
2680             if test -n "$libdir" && test ! -f "$libfile"; then
2681               func_warning "\`$lib' has not been installed in \`$libdir'"
2682               finalize=no
2683             fi
2684           done
2685
2686           relink_command=
2687           func_source "$wrapper"
2688
2689           outputname=
2690           if test "$fast_install" = no && test -n "$relink_command"; then
2691             $opt_dry_run || {
2692               if test "$finalize" = yes; then
2693                 tmpdir=`func_mktempdir`
2694                 func_basename "$file$stripped_ext"
2695                 file="$func_basename_result"
2696                 outputname="$tmpdir/$file"
2697                 # Replace the output file specification.
2698                 relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
2699
2700                 $opt_silent || {
2701                   func_quote_for_expand "$relink_command"
2702                   eval "func_echo $func_quote_for_expand_result"
2703                 }
2704                 if eval "$relink_command"; then :
2705                   else
2706                   func_error "error: relink \`$file' with the above command before installing it"
2707                   $opt_dry_run || ${RM}r "$tmpdir"
2708                   continue
2709                 fi
2710                 file="$outputname"
2711               else
2712                 func_warning "cannot relink \`$file'"
2713               fi
2714             }
2715           else
2716             # Install the binary that we compiled earlier.
2717             file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
2718           fi
2719         fi
2720
2721         # remove .exe since cygwin /usr/bin/install will append another
2722         # one anyway
2723         case $install_prog,$host in
2724         */usr/bin/install*,*cygwin*)
2725           case $file:$destfile in
2726           *.exe:*.exe)
2727             # this is ok
2728             ;;
2729           *.exe:*)
2730             destfile=$destfile.exe
2731             ;;
2732           *:*.exe)
2733             func_stripname '' '.exe' "$destfile"
2734             destfile=$func_stripname_result
2735             ;;
2736           esac
2737           ;;
2738         esac
2739         func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
2740         $opt_dry_run || if test -n "$outputname"; then
2741           ${RM}r "$tmpdir"
2742         fi
2743         ;;
2744       esac
2745     done
2746
2747     for file in $staticlibs; do
2748       func_basename "$file"
2749       name="$func_basename_result"
2750
2751       # Set up the ranlib parameters.
2752       oldlib="$destdir/$name"
2753
2754       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
2755
2756       if test -n "$stripme" && test -n "$old_striplib"; then
2757         func_show_eval "$old_striplib $oldlib" 'exit $?'
2758       fi
2759
2760       # Do each command in the postinstall commands.
2761       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
2762     done
2763
2764     test -n "$future_libdirs" && \
2765       func_warning "remember to run \`$progname --finish$future_libdirs'"
2766
2767     if test -n "$current_libdirs"; then
2768       # Maybe just do a dry run.
2769       $opt_dry_run && current_libdirs=" -n$current_libdirs"
2770       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
2771     else
2772       exit $EXIT_SUCCESS
2773     fi
2774 }
2775
2776 test "$mode" = install && func_mode_install ${1+"$@"}
2777
2778
2779 # func_generate_dlsyms outputname originator pic_p
2780 # Extract symbols from dlprefiles and create ${outputname}S.o with
2781 # a dlpreopen symbol table.
2782 func_generate_dlsyms ()
2783 {
2784     $opt_debug
2785     my_outputname="$1"
2786     my_originator="$2"
2787     my_pic_p="${3-no}"
2788     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
2789     my_dlsyms=
2790
2791     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2792       if test -n "$NM" && test -n "$global_symbol_pipe"; then
2793         my_dlsyms="${my_outputname}S.c"
2794       else
2795         func_error "not configured to extract global symbols from dlpreopened files"
2796       fi
2797     fi
2798
2799     if test -n "$my_dlsyms"; then
2800       case $my_dlsyms in
2801       "") ;;
2802       *.c)
2803         # Discover the nlist of each of the dlfiles.
2804         nlist="$output_objdir/${my_outputname}.nm"
2805
2806         func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
2807
2808         # Parse the name list into a source file.
2809         func_verbose "creating $output_objdir/$my_dlsyms"
2810
2811         $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
2812 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
2813 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
2814
2815 #ifdef __cplusplus
2816 extern \"C\" {
2817 #endif
2818
2819 /* External symbol declarations for the compiler. */\
2820 "
2821
2822         if test "$dlself" = yes; then
2823           func_verbose "generating symbol list for \`$output'"
2824
2825           $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
2826
2827           # Add our own program objects to the symbol list.
2828           progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
2829           for progfile in $progfiles; do
2830             func_verbose "extracting global C symbols from \`$progfile'"
2831             $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"
2832           done
2833
2834           if test -n "$exclude_expsyms"; then
2835             $opt_dry_run || {
2836               eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
2837               eval '$MV "$nlist"T "$nlist"'
2838             }
2839           fi
2840
2841           if test -n "$export_symbols_regex"; then
2842             $opt_dry_run || {
2843               eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
2844               eval '$MV "$nlist"T "$nlist"'
2845             }
2846           fi
2847
2848           # Prepare the list of exported symbols
2849           if test -z "$export_symbols"; then
2850             export_symbols="$output_objdir/$outputname.exp"
2851             $opt_dry_run || {
2852               $RM $export_symbols
2853               eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
2854               case $host in
2855               *cygwin* | *mingw* | *cegcc* )
2856                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2857                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
2858                 ;;
2859               esac
2860             }
2861           else
2862             $opt_dry_run || {
2863               eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
2864               eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
2865               eval '$MV "$nlist"T "$nlist"'
2866               case $host in
2867                 *cygwin | *mingw* | *cegcc* )
2868                   eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
2869                   eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
2870                   ;;
2871               esac
2872             }
2873           fi
2874         fi
2875
2876         for dlprefile in $dlprefiles; do
2877           func_verbose "extracting global C symbols from \`$dlprefile'"
2878           func_basename "$dlprefile"
2879           name="$func_basename_result"
2880           $opt_dry_run || {
2881             eval '$ECHO ": $name " >> "$nlist"'
2882             eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"
2883           }
2884         done
2885
2886         $opt_dry_run || {
2887           # Make sure we have at least an empty file.
2888           test -f "$nlist" || : > "$nlist"
2889
2890           if test -n "$exclude_expsyms"; then
2891             $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
2892             $MV "$nlist"T "$nlist"
2893           fi
2894
2895           # Try sorting and uniquifying the output.
2896           if $GREP -v "^: " < "$nlist" |
2897               if sort -k 3 </dev/null >/dev/null 2>&1; then
2898                 sort -k 3
2899               else
2900                 sort +2
2901               fi |
2902               uniq > "$nlist"S; then
2903             :
2904           else
2905             $GREP -v "^: " < "$nlist" > "$nlist"S
2906           fi
2907
2908           if test -f "$nlist"S; then
2909             eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
2910           else
2911             $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"
2912           fi
2913
2914           $ECHO >> "$output_objdir/$my_dlsyms" "\
2915
2916 /* The mapping between symbol names and symbols.  */
2917 typedef struct {
2918   const char *name;
2919   void *address;
2920 } lt_dlsymlist;
2921 "
2922           case $host in
2923           *cygwin* | *mingw* | *cegcc* )
2924             $ECHO >> "$output_objdir/$my_dlsyms" "\
2925 /* DATA imports from DLLs on WIN32 con't be const, because
2926    runtime relocations are performed -- see ld's documentation
2927    on pseudo-relocs.  */"
2928             lt_dlsym_const= ;;
2929           *osf5*)
2930             echo >> "$output_objdir/$my_dlsyms" "\
2931 /* This system does not cope well with relocations in const data */"
2932             lt_dlsym_const= ;;
2933           *)
2934             lt_dlsym_const=const ;;
2935           esac
2936
2937           $ECHO >> "$output_objdir/$my_dlsyms" "\
2938 extern $lt_dlsym_const lt_dlsymlist
2939 lt_${my_prefix}_LTX_preloaded_symbols[];
2940 $lt_dlsym_const lt_dlsymlist
2941 lt_${my_prefix}_LTX_preloaded_symbols[] =
2942 {\
2943   { \"$my_originator\", (void *) 0 },"
2944
2945           case $need_lib_prefix in
2946           no)
2947             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
2948             ;;
2949           *)
2950             eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
2951             ;;
2952           esac
2953           $ECHO >> "$output_objdir/$my_dlsyms" "\
2954   {0, (void *) 0}
2955 };
2956
2957 /* This works around a problem in FreeBSD linker */
2958 #ifdef FREEBSD_WORKAROUND
2959 static const void *lt_preloaded_setup() {
2960   return lt_${my_prefix}_LTX_preloaded_symbols;
2961 }
2962 #endif
2963
2964 #ifdef __cplusplus
2965 }
2966 #endif\
2967 "
2968         } # !$opt_dry_run
2969
2970         pic_flag_for_symtable=
2971         case "$compile_command " in
2972         *" -static "*) ;;
2973         *)
2974           case $host in
2975           # compiling the symbol table file with pic_flag works around
2976           # a FreeBSD bug that causes programs to crash when -lm is
2977           # linked before any other PIC object.  But we must not use
2978           # pic_flag when linking with -static.  The problem exists in
2979           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
2980           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
2981             pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
2982           *-*-hpux*)
2983             pic_flag_for_symtable=" $pic_flag"  ;;
2984           *)
2985             if test "X$my_pic_p" != Xno; then
2986               pic_flag_for_symtable=" $pic_flag"
2987             fi
2988             ;;
2989           esac
2990           ;;
2991         esac
2992         symtab_cflags=
2993         for arg in $LTCFLAGS; do
2994           case $arg in
2995           -pie | -fpie | -fPIE) ;;
2996           *) symtab_cflags="$symtab_cflags $arg" ;;
2997           esac
2998         done
2999
3000         # Now compile the dynamic symbol file.
3001         func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
3002
3003         # Clean up the generated files.
3004         func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
3005
3006         # Transform the symbol file into the correct name.
3007         symfileobj="$output_objdir/${my_outputname}S.$objext"
3008         case $host in
3009         *cygwin* | *mingw* | *cegcc* )
3010           if test -f "$output_objdir/$my_outputname.def"; then
3011             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3012             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
3013           else
3014             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3015             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3016           fi
3017           ;;
3018         *)
3019           compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3020           finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`
3021           ;;
3022         esac
3023         ;;
3024       *)
3025         func_fatal_error "unknown suffix for \`$my_dlsyms'"
3026         ;;
3027       esac
3028     else
3029       # We keep going just in case the user didn't refer to
3030       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3031       # really was required.
3032
3033       # Nullify the symbol file.
3034       compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
3035       finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
3036     fi
3037 }
3038
3039 # func_win32_libid arg
3040 # return the library type of file 'arg'
3041 #
3042 # Need a lot of goo to handle *both* DLLs and import libs
3043 # Has to be a shell function in order to 'eat' the argument
3044 # that is supplied when $file_magic_command is called.
3045 func_win32_libid ()
3046 {
3047   $opt_debug
3048   win32_libid_type="unknown"
3049   win32_fileres=`file -L $1 2>/dev/null`
3050   case $win32_fileres in
3051   *ar\ archive\ import\ library*) # definitely import
3052     win32_libid_type="x86 archive import"
3053     ;;
3054   *ar\ archive*) # could be an import, or static
3055     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
3056        $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
3057       win32_nmres=`eval $NM -f posix -A $1 |
3058         $SED -n -e '
3059             1,100{
3060                 / I /{
3061                     s,.*,import,
3062                     p
3063                     q
3064                 }
3065             }'`
3066       case $win32_nmres in
3067       import*)  win32_libid_type="x86 archive import";;
3068       *)        win32_libid_type="x86 archive static";;
3069       esac
3070     fi
3071     ;;
3072   *DLL*)
3073     win32_libid_type="x86 DLL"
3074     ;;
3075   *executable*) # but shell scripts are "executable" too...
3076     case $win32_fileres in
3077     *MS\ Windows\ PE\ Intel*)
3078       win32_libid_type="x86 DLL"
3079       ;;
3080     esac
3081     ;;
3082   esac
3083   $ECHO "$win32_libid_type"
3084 }
3085
3086
3087
3088 # func_extract_an_archive dir oldlib
3089 func_extract_an_archive ()
3090 {
3091     $opt_debug
3092     f_ex_an_ar_dir="$1"; shift
3093     f_ex_an_ar_oldlib="$1"
3094     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'
3095     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
3096      :
3097     else
3098       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
3099     fi
3100 }
3101
3102
3103 # func_extract_archives gentop oldlib ...
3104 func_extract_archives ()
3105 {
3106     $opt_debug
3107     my_gentop="$1"; shift
3108     my_oldlibs=${1+"$@"}
3109     my_oldobjs=""
3110     my_xlib=""
3111     my_xabs=""
3112     my_xdir=""
3113
3114     for my_xlib in $my_oldlibs; do
3115       # Extract the objects.
3116       case $my_xlib in
3117         [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
3118         *) my_xabs=`pwd`"/$my_xlib" ;;
3119       esac
3120       func_basename "$my_xlib"
3121       my_xlib="$func_basename_result"
3122       my_xlib_u=$my_xlib
3123       while :; do
3124         case " $extracted_archives " in
3125         *" $my_xlib_u "*)
3126           func_arith $extracted_serial + 1
3127           extracted_serial=$func_arith_result
3128           my_xlib_u=lt$extracted_serial-$my_xlib ;;
3129         *) break ;;
3130         esac
3131       done
3132       extracted_archives="$extracted_archives $my_xlib_u"
3133       my_xdir="$my_gentop/$my_xlib_u"
3134
3135       func_mkdir_p "$my_xdir"
3136
3137       case $host in
3138       *-darwin*)
3139         func_verbose "Extracting $my_xabs"
3140         # Do not bother doing anything if just a dry run
3141         $opt_dry_run || {
3142           darwin_orig_dir=`pwd`
3143           cd $my_xdir || exit $?
3144           darwin_archive=$my_xabs
3145           darwin_curdir=`pwd`
3146           darwin_base_archive=`basename "$darwin_archive"`
3147           darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
3148           if test -n "$darwin_arches"; then
3149             darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
3150             darwin_arch=
3151             func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
3152             for darwin_arch in  $darwin_arches ; do
3153               func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3154               $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
3155               cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
3156               func_extract_an_archive "`pwd`" "${darwin_base_archive}"
3157               cd "$darwin_curdir"
3158               $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
3159             done # $darwin_arches
3160             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
3161             darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
3162             darwin_file=
3163             darwin_files=
3164             for darwin_file in $darwin_filelist; do
3165               darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
3166               $LIPO -create -output "$darwin_file" $darwin_files
3167             done # $darwin_filelist
3168             $RM -rf unfat-$$
3169             cd "$darwin_orig_dir"
3170           else
3171             cd $darwin_orig_dir
3172             func_extract_an_archive "$my_xdir" "$my_xabs"
3173           fi # $darwin_arches
3174         } # !$opt_dry_run
3175         ;;
3176       *)
3177         func_extract_an_archive "$my_xdir" "$my_xabs"
3178         ;;
3179       esac
3180       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3181     done
3182
3183     func_extract_archives_result="$my_oldobjs"
3184 }
3185
3186
3187
3188 # func_emit_wrapper_part1 [arg=no]
3189 #
3190 # Emit the first part of a libtool wrapper script on stdout.
3191 # For more information, see the description associated with
3192 # func_emit_wrapper(), below.
3193 func_emit_wrapper_part1 ()
3194 {
3195         func_emit_wrapper_part1_arg1=no
3196         if test -n "$1" ; then
3197           func_emit_wrapper_part1_arg1=$1
3198         fi
3199
3200         $ECHO "\
3201 #! $SHELL
3202
3203 # $output - temporary wrapper script for $objdir/$outputname
3204 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3205 #
3206 # The $output program cannot be directly executed until all the libtool
3207 # libraries that it depends on are installed.
3208 #
3209 # This wrapper script should never be moved out of the build directory.
3210 # If it is, it will not operate correctly.
3211
3212 # Sed substitution that helps us do robust quoting.  It backslashifies
3213 # metacharacters that are still active within double-quoted strings.
3214 Xsed='${SED} -e 1s/^X//'
3215 sed_quote_subst='$sed_quote_subst'
3216
3217 # Be Bourne compatible
3218 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
3219   emulate sh
3220   NULLCMD=:
3221   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
3222   # is contrary to our usage.  Disable this feature.
3223   alias -g '\${1+\"\$@\"}'='\"\$@\"'
3224   setopt NO_GLOB_SUBST
3225 else
3226   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
3227 fi
3228 BIN_SH=xpg4; export BIN_SH # for Tru64
3229 DUALCASE=1; export DUALCASE # for MKS sh
3230
3231 # The HP-UX ksh and POSIX shell print the target directory to stdout
3232 # if CDPATH is set.
3233 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
3234
3235 relink_command=\"$relink_command\"
3236
3237 # This environment variable determines our operation mode.
3238 if test \"\$libtool_install_magic\" = \"$magic\"; then
3239   # install mode needs the following variables:
3240   generated_by_libtool_version='$macro_version'
3241   notinst_deplibs='$notinst_deplibs'
3242 else
3243   # When we are sourced in execute mode, \$file and \$ECHO are already set.
3244   if test \"\$libtool_execute_magic\" != \"$magic\"; then
3245     ECHO=\"$qecho\"
3246     file=\"\$0\"
3247     # Make sure echo works.
3248     if test \"X\$1\" = X--no-reexec; then
3249       # Discard the --no-reexec flag, and continue.
3250       shift
3251     elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then
3252       # Yippee, \$ECHO works!
3253       :
3254     else
3255       # Restart under the correct shell, and then maybe \$ECHO will work.
3256       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
3257     fi
3258   fi\
3259 "
3260         $ECHO "\
3261
3262   # Find the directory that this script lives in.
3263   thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
3264   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
3265
3266   # Follow symbolic links until we get to the real thisdir.
3267   file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
3268   while test -n \"\$file\"; do
3269     destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
3270
3271     # If there was a directory component, then change thisdir.
3272     if test \"x\$destdir\" != \"x\$file\"; then
3273       case \"\$destdir\" in
3274       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
3275       *) thisdir=\"\$thisdir/\$destdir\" ;;
3276       esac
3277     fi
3278
3279     file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
3280     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
3281   done
3282 "
3283 }
3284 # end: func_emit_wrapper_part1
3285
3286 # func_emit_wrapper_part2 [arg=no]
3287 #
3288 # Emit the second part of a libtool wrapper script on stdout.
3289 # For more information, see the description associated with
3290 # func_emit_wrapper(), below.
3291 func_emit_wrapper_part2 ()
3292 {
3293         func_emit_wrapper_part2_arg1=no
3294         if test -n "$1" ; then
3295           func_emit_wrapper_part2_arg1=$1
3296         fi
3297
3298         $ECHO "\
3299
3300   # Usually 'no', except on cygwin/mingw when embedded into
3301   # the cwrapper.
3302   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1
3303   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
3304     # special case for '.'
3305     if test \"\$thisdir\" = \".\"; then
3306       thisdir=\`pwd\`
3307     fi
3308     # remove .libs from thisdir
3309     case \"\$thisdir\" in
3310     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;
3311     $objdir )   thisdir=. ;;
3312     esac
3313   fi
3314
3315   # Try to get the absolute directory name.
3316   absdir=\`cd \"\$thisdir\" && pwd\`
3317   test -n \"\$absdir\" && thisdir=\"\$absdir\"
3318 "
3319
3320         if test "$fast_install" = yes; then
3321           $ECHO "\
3322   program=lt-'$outputname'$exeext
3323   progdir=\"\$thisdir/$objdir\"
3324
3325   if test ! -f \"\$progdir/\$program\" ||
3326      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
3327        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
3328
3329     file=\"\$\$-\$program\"
3330
3331     if test ! -d \"\$progdir\"; then
3332       $MKDIR \"\$progdir\"
3333     else
3334       $RM \"\$progdir/\$file\"
3335     fi"
3336
3337           $ECHO "\
3338
3339     # relink executable if necessary
3340     if test -n \"\$relink_command\"; then
3341       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
3342       else
3343         $ECHO \"\$relink_command_output\" >&2
3344         $RM \"\$progdir/\$file\"
3345         exit 1
3346       fi
3347     fi
3348
3349     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
3350     { $RM \"\$progdir/\$program\";
3351       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
3352     $RM \"\$progdir/\$file\"
3353   fi"
3354         else
3355           $ECHO "\
3356   program='$outputname'
3357   progdir=\"\$thisdir/$objdir\"
3358 "
3359         fi
3360
3361         $ECHO "\
3362
3363   if test -f \"\$progdir/\$program\"; then"
3364
3365         # Export our shlibpath_var if we have one.
3366         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3367           $ECHO "\
3368     # Add our own library path to $shlibpath_var
3369     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
3370
3371     # Some systems cannot cope with colon-terminated $shlibpath_var
3372     # The second colon is a workaround for a bug in BeOS R4 sed
3373     $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
3374
3375     export $shlibpath_var
3376 "
3377         fi
3378
3379         # fixup the dll searchpath if we need to.
3380         if test -n "$dllsearchpath"; then
3381           $ECHO "\
3382     # Add the dll search path components to the executable PATH
3383     PATH=$dllsearchpath:\$PATH
3384 "
3385         fi
3386
3387         $ECHO "\
3388     if test \"\$libtool_execute_magic\" != \"$magic\"; then
3389       # Run the actual program with our arguments.
3390 "
3391         case $host in
3392         # Backslashes separate directories on plain windows
3393         *-*-mingw | *-*-os2* | *-cegcc*)
3394           $ECHO "\
3395       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
3396 "
3397           ;;
3398
3399         *)
3400           $ECHO "\
3401       exec \"\$progdir/\$program\" \${1+\"\$@\"}
3402 "
3403           ;;
3404         esac
3405         $ECHO "\
3406       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
3407       exit 1
3408     fi
3409   else
3410     # The program doesn't exist.
3411     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
3412     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
3413     $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
3414     exit 1
3415   fi
3416 fi\
3417 "
3418 }
3419 # end: func_emit_wrapper_part2
3420
3421
3422 # func_emit_wrapper [arg=no]
3423 #
3424 # Emit a libtool wrapper script on stdout.
3425 # Don't directly open a file because we may want to
3426 # incorporate the script contents within a cygwin/mingw
3427 # wrapper executable.  Must ONLY be called from within
3428 # func_mode_link because it depends on a number of variables
3429 # set therein.
3430 #
3431 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
3432 # variable will take.  If 'yes', then the emitted script
3433 # will assume that the directory in which it is stored is
3434 # the $objdir directory.  This is a cygwin/mingw-specific
3435 # behavior.
3436 func_emit_wrapper ()
3437 {
3438         func_emit_wrapper_arg1=no
3439         if test -n "$1" ; then
3440           func_emit_wrapper_arg1=$1
3441         fi
3442
3443         # split this up so that func_emit_cwrapperexe_src
3444         # can call each part independently.
3445         func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"
3446         func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"
3447 }
3448
3449
3450 # func_to_host_path arg
3451 #
3452 # Convert paths to host format when used with build tools.
3453 # Intended for use with "native" mingw (where libtool itself
3454 # is running under the msys shell), or in the following cross-
3455 # build environments:
3456 #    $build          $host
3457 #    mingw (msys)    mingw  [e.g. native]
3458 #    cygwin          mingw
3459 #    *nix + wine     mingw
3460 # where wine is equipped with the `winepath' executable.
3461 # In the native mingw case, the (msys) shell automatically
3462 # converts paths for any non-msys applications it launches,
3463 # but that facility isn't available from inside the cwrapper.
3464 # Similar accommodations are necessary for $host mingw and
3465 # $build cygwin.  Calling this function does no harm for other
3466 # $host/$build combinations not listed above.
3467 #
3468 # ARG is the path (on $build) that should be converted to
3469 # the proper representation for $host. The result is stored
3470 # in $func_to_host_path_result.
3471 func_to_host_path ()
3472 {
3473   func_to_host_path_result="$1"
3474   if test -n "$1" ; then
3475     case $host in
3476       *mingw* )
3477         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3478         case $build in
3479           *mingw* ) # actually, msys
3480             # awkward: cmd appends spaces to result
3481             lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3482             func_to_host_path_tmp1=`( cmd //c echo "$1" |\
3483               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3484             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3485               $SED -e "$lt_sed_naive_backslashify"`
3486             ;;
3487           *cygwin* )
3488             func_to_host_path_tmp1=`cygpath -w "$1"`
3489             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3490               $SED -e "$lt_sed_naive_backslashify"`
3491             ;;
3492           * )
3493             # Unfortunately, winepath does not exit with a non-zero
3494             # error code, so we are forced to check the contents of
3495             # stdout. On the other hand, if the command is not
3496             # found, the shell will set an exit code of 127 and print
3497             # *an error message* to stdout. So we must check for both
3498             # error code of zero AND non-empty stdout, which explains
3499             # the odd construction:
3500             func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`
3501             if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then
3502               func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\
3503                 $SED -e "$lt_sed_naive_backslashify"`
3504             else
3505               # Allow warning below.
3506               func_to_host_path_result=""
3507             fi
3508             ;;
3509         esac
3510         if test -z "$func_to_host_path_result" ; then
3511           func_error "Could not determine host path corresponding to"
3512           func_error "  '$1'"
3513           func_error "Continuing, but uninstalled executables may not work."
3514           # Fallback:
3515           func_to_host_path_result="$1"
3516         fi
3517         ;;
3518     esac
3519   fi
3520 }
3521 # end: func_to_host_path
3522
3523 # func_to_host_pathlist arg
3524 #
3525 # Convert pathlists to host format when used with build tools.
3526 # See func_to_host_path(), above. This function supports the
3527 # following $build/$host combinations (but does no harm for
3528 # combinations not listed here):
3529 #    $build          $host
3530 #    mingw (msys)    mingw  [e.g. native]
3531 #    cygwin          mingw
3532 #    *nix + wine     mingw
3533 #
3534 # Path separators are also converted from $build format to
3535 # $host format. If ARG begins or ends with a path separator
3536 # character, it is preserved (but converted to $host format)
3537 # on output.
3538 #
3539 # ARG is a pathlist (on $build) that should be converted to
3540 # the proper representation on $host. The result is stored
3541 # in $func_to_host_pathlist_result.
3542 func_to_host_pathlist ()
3543 {
3544   func_to_host_pathlist_result="$1"
3545   if test -n "$1" ; then
3546     case $host in
3547       *mingw* )
3548         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
3549         # Remove leading and trailing path separator characters from
3550         # ARG. msys behavior is inconsistent here, cygpath turns them
3551         # into '.;' and ';.', and winepath ignores them completely.
3552         func_to_host_pathlist_tmp2="$1"
3553         # Once set for this call, this variable should not be
3554         # reassigned. It is used in tha fallback case.
3555         func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\
3556           $SED -e 's|^:*||' -e 's|:*$||'`
3557         case $build in
3558           *mingw* ) # Actually, msys.
3559             # Awkward: cmd appends spaces to result.
3560             lt_sed_strip_trailing_spaces="s/[ ]*\$//"
3561             func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\
3562               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`
3563             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3564               $SED -e "$lt_sed_naive_backslashify"`
3565             ;;
3566           *cygwin* )
3567             func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`
3568             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\
3569               $SED -e "$lt_sed_naive_backslashify"`
3570             ;;
3571           * )
3572             # unfortunately, winepath doesn't convert pathlists
3573             func_to_host_pathlist_result=""
3574             func_to_host_pathlist_oldIFS=$IFS
3575             IFS=:
3576             for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do
3577               IFS=$func_to_host_pathlist_oldIFS
3578               if test -n "$func_to_host_pathlist_f" ; then
3579                 func_to_host_path "$func_to_host_pathlist_f"
3580                 if test -n "$func_to_host_path_result" ; then
3581                   if test -z "$func_to_host_pathlist_result" ; then
3582                     func_to_host_pathlist_result="$func_to_host_path_result"
3583                   else
3584                     func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"
3585                   fi
3586                 fi
3587               fi
3588               IFS=:
3589             done
3590             IFS=$func_to_host_pathlist_oldIFS
3591             ;;
3592         esac
3593         if test -z "$func_to_host_pathlist_result" ; then
3594           func_error "Could not determine the host path(s) corresponding to"
3595           func_error "  '$1'"
3596           func_error "Continuing, but uninstalled executables may not work."
3597           # Fallback. This may break if $1 contains DOS-style drive
3598           # specifications. The fix is not to complicate the expression
3599           # below, but for the user to provide a working wine installation
3600           # with winepath so that path translation in the cross-to-mingw
3601           # case works properly.
3602           lt_replace_pathsep_nix_to_dos="s|:|;|g"
3603           func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\
3604             $SED -e "$lt_replace_pathsep_nix_to_dos"`
3605         fi
3606         # Now, add the leading and trailing path separators back
3607         case "$1" in
3608           :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"
3609             ;;
3610         esac
3611         case "$1" in
3612           *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"
3613             ;;
3614         esac
3615         ;;
3616     esac
3617   fi
3618 }
3619 # end: func_to_host_pathlist
3620
3621 # func_emit_cwrapperexe_src
3622 # emit the source code for a wrapper executable on stdout
3623 # Must ONLY be called from within func_mode_link because
3624 # it depends on a number of variable set therein.
3625 func_emit_cwrapperexe_src ()
3626 {
3627         cat <<EOF
3628
3629 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
3630    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
3631
3632    The $output program cannot be directly executed until all the libtool
3633    libraries that it depends on are installed.
3634
3635    This wrapper executable should never be moved out of the build directory.
3636    If it is, it will not operate correctly.
3637
3638    Currently, it simply execs the wrapper *script* "$SHELL $output",
3639    but could eventually absorb all of the scripts functionality and
3640    exec $objdir/$outputname directly.
3641 */
3642 EOF
3643             cat <<"EOF"
3644 #include <stdio.h>
3645 #include <stdlib.h>
3646 #ifdef _MSC_VER
3647 # include <direct.h>
3648 # include <process.h>
3649 # include <io.h>
3650 # define setmode _setmode
3651 #else
3652 # include <unistd.h>
3653 # include <stdint.h>
3654 # ifdef __CYGWIN__
3655 #  include <io.h>
3656 #  define HAVE_SETENV
3657 #  ifdef __STRICT_ANSI__
3658 char *realpath (const char *, char *);
3659 int putenv (char *);
3660 int setenv (const char *, const char *, int);
3661 #  endif
3662 # endif
3663 #endif
3664 #include <malloc.h>
3665 #include <stdarg.h>
3666 #include <assert.h>
3667 #include <string.h>
3668 #include <ctype.h>
3669 #include <errno.h>
3670 #include <fcntl.h>
3671 #include <sys/stat.h>
3672
3673 #if defined(PATH_MAX)
3674 # define LT_PATHMAX PATH_MAX
3675 #elif defined(MAXPATHLEN)
3676 # define LT_PATHMAX MAXPATHLEN
3677 #else
3678 # define LT_PATHMAX 1024
3679 #endif
3680
3681 #ifndef S_IXOTH
3682 # define S_IXOTH 0
3683 #endif
3684 #ifndef S_IXGRP
3685 # define S_IXGRP 0
3686 #endif
3687
3688 #ifdef _MSC_VER
3689 # define S_IXUSR _S_IEXEC
3690 # define stat _stat
3691 # ifndef _INTPTR_T_DEFINED
3692 #  define intptr_t int
3693 # endif
3694 #endif
3695
3696 #ifndef DIR_SEPARATOR
3697 # define DIR_SEPARATOR '/'
3698 # define PATH_SEPARATOR ':'
3699 #endif
3700
3701 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
3702   defined (__OS2__)
3703 # define HAVE_DOS_BASED_FILE_SYSTEM
3704 # define FOPEN_WB "wb"
3705 # ifndef DIR_SEPARATOR_2
3706 #  define DIR_SEPARATOR_2 '\\'
3707 # endif
3708 # ifndef PATH_SEPARATOR_2
3709 #  define PATH_SEPARATOR_2 ';'
3710 # endif
3711 #endif
3712
3713 #ifndef DIR_SEPARATOR_2
3714 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
3715 #else /* DIR_SEPARATOR_2 */
3716 # define IS_DIR_SEPARATOR(ch) \
3717         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
3718 #endif /* DIR_SEPARATOR_2 */
3719
3720 #ifndef PATH_SEPARATOR_2
3721 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
3722 #else /* PATH_SEPARATOR_2 */
3723 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
3724 #endif /* PATH_SEPARATOR_2 */
3725
3726 #ifdef __CYGWIN__
3727 # define FOPEN_WB "wb"
3728 #endif
3729
3730 #ifndef FOPEN_WB
3731 # define FOPEN_WB "w"
3732 #endif
3733 #ifndef _O_BINARY
3734 # define _O_BINARY 0
3735 #endif
3736
3737 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
3738 #define XFREE(stale) do { \
3739   if (stale) { free ((void *) stale); stale = 0; } \
3740 } while (0)
3741
3742 #undef LTWRAPPER_DEBUGPRINTF
3743 #if defined DEBUGWRAPPER
3744 # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args
3745 static void
3746 ltwrapper_debugprintf (const char *fmt, ...)
3747 {
3748     va_list args;
3749     va_start (args, fmt);
3750     (void) vfprintf (stderr, fmt, args);
3751     va_end (args);
3752 }
3753 #else
3754 # define LTWRAPPER_DEBUGPRINTF(args)
3755 #endif
3756
3757 const char *program_name = NULL;
3758
3759 void *xmalloc (size_t num);
3760 char *xstrdup (const char *string);
3761 const char *base_name (const char *name);
3762 char *find_executable (const char *wrapper);
3763 char *chase_symlinks (const char *pathspec);
3764 int make_executable (const char *path);
3765 int check_executable (const char *path);
3766 char *strendzap (char *str, const char *pat);
3767 void lt_fatal (const char *message, ...);
3768 void lt_setenv (const char *name, const char *value);
3769 char *lt_extend_str (const char *orig_value, const char *add, int to_end);
3770 void lt_opt_process_env_set (const char *arg);
3771 void lt_opt_process_env_prepend (const char *arg);
3772 void lt_opt_process_env_append (const char *arg);
3773 int lt_split_name_value (const char *arg, char** name, char** value);
3774 void lt_update_exe_path (const char *name, const char *value);
3775 void lt_update_lib_path (const char *name, const char *value);
3776
3777 static const char *script_text_part1 =
3778 EOF
3779
3780             func_emit_wrapper_part1 yes |
3781                 $SED -e 's/\([\\"]\)/\\\1/g' \
3782                      -e 's/^/  "/' -e 's/$/\\n"/'
3783             echo ";"
3784             cat <<EOF
3785
3786 static const char *script_text_part2 =
3787 EOF
3788             func_emit_wrapper_part2 yes |
3789                 $SED -e 's/\([\\"]\)/\\\1/g' \
3790                      -e 's/^/  "/' -e 's/$/\\n"/'
3791             echo ";"
3792
3793             cat <<EOF
3794 const char * MAGIC_EXE = "$magic_exe";
3795 const char * LIB_PATH_VARNAME = "$shlibpath_var";
3796 EOF
3797
3798             if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
3799               func_to_host_pathlist "$temp_rpath"
3800               cat <<EOF
3801 const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";
3802 EOF
3803             else
3804               cat <<"EOF"
3805 const char * LIB_PATH_VALUE   = "";
3806 EOF
3807             fi
3808
3809             if test -n "$dllsearchpath"; then
3810               func_to_host_pathlist "$dllsearchpath:"
3811               cat <<EOF
3812 const char * EXE_PATH_VARNAME = "PATH";
3813 const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";
3814 EOF
3815             else
3816               cat <<"EOF"
3817 const char * EXE_PATH_VARNAME = "";
3818 const char * EXE_PATH_VALUE   = "";
3819 EOF
3820             fi
3821
3822             if test "$fast_install" = yes; then
3823               cat <<EOF
3824 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
3825 EOF
3826             else
3827               cat <<EOF
3828 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
3829 EOF
3830             fi
3831
3832
3833             cat <<"EOF"
3834
3835 #define LTWRAPPER_OPTION_PREFIX         "--lt-"
3836 #define LTWRAPPER_OPTION_PREFIX_LENGTH  5
3837
3838 static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;
3839 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
3840
3841 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
3842
3843 static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;
3844 static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";
3845   /* argument is putenv-style "foo=bar", value of foo is set to bar */
3846
3847 static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;
3848 static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";
3849   /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */
3850
3851 static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;
3852 static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";
3853   /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */
3854
3855 int
3856 main (int argc, char *argv[])
3857 {
3858   char **newargz;
3859   int  newargc;
3860   char *tmp_pathspec;
3861   char *actual_cwrapper_path;
3862   char *actual_cwrapper_name;
3863   char *target_name;
3864   char *lt_argv_zero;
3865   intptr_t rval = 127;
3866
3867   int i;
3868
3869   program_name = (char *) xstrdup (base_name (argv[0]));
3870   LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));
3871   LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));
3872
3873   /* very simple arg parsing; don't want to rely on getopt */
3874   for (i = 1; i < argc; i++)
3875     {
3876       if (strcmp (argv[i], dumpscript_opt) == 0)
3877         {
3878 EOF
3879             case "$host" in
3880               *mingw* | *cygwin* )
3881                 # make stdout use "unix" line endings
3882                 echo "          setmode(1,_O_BINARY);"
3883                 ;;
3884               esac
3885
3886             cat <<"EOF"
3887           printf ("%s", script_text_part1);
3888           printf ("%s", script_text_part2);
3889           return 0;
3890         }
3891     }
3892
3893   newargz = XMALLOC (char *, argc + 1);
3894   tmp_pathspec = find_executable (argv[0]);
3895   if (tmp_pathspec == NULL)
3896     lt_fatal ("Couldn't find %s", argv[0]);
3897   LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",
3898                           tmp_pathspec));
3899
3900   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
3901   LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",
3902                           actual_cwrapper_path));
3903   XFREE (tmp_pathspec);
3904
3905   actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));
3906   strendzap (actual_cwrapper_path, actual_cwrapper_name);
3907
3908   /* wrapper name transforms */
3909   strendzap (actual_cwrapper_name, ".exe");
3910   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
3911   XFREE (actual_cwrapper_name);
3912   actual_cwrapper_name = tmp_pathspec;
3913   tmp_pathspec = 0;
3914
3915   /* target_name transforms -- use actual target program name; might have lt- prefix */
3916   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
3917   strendzap (target_name, ".exe");
3918   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
3919   XFREE (target_name);
3920   target_name = tmp_pathspec;
3921   tmp_pathspec = 0;
3922
3923   LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",
3924                           target_name));
3925 EOF
3926
3927             cat <<EOF
3928   newargz[0] =
3929     XMALLOC (char, (strlen (actual_cwrapper_path) +
3930                     strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
3931   strcpy (newargz[0], actual_cwrapper_path);
3932   strcat (newargz[0], "$objdir");
3933   strcat (newargz[0], "/");
3934 EOF
3935
3936             cat <<"EOF"
3937   /* stop here, and copy so we don't have to do this twice */
3938   tmp_pathspec = xstrdup (newargz[0]);
3939
3940   /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
3941   strcat (newargz[0], actual_cwrapper_name);
3942
3943   /* DO want the lt- prefix here if it exists, so use target_name */
3944   lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
3945   XFREE (tmp_pathspec);
3946   tmp_pathspec = NULL;
3947 EOF
3948
3949             case $host_os in
3950               mingw*)
3951             cat <<"EOF"
3952   {
3953     char* p;
3954     while ((p = strchr (newargz[0], '\\')) != NULL)
3955       {
3956         *p = '/';
3957       }
3958     while ((p = strchr (lt_argv_zero, '\\')) != NULL)
3959       {
3960         *p = '/';
3961       }
3962   }
3963 EOF
3964             ;;
3965             esac
3966
3967             cat <<"EOF"
3968   XFREE (target_name);
3969   XFREE (actual_cwrapper_path);
3970   XFREE (actual_cwrapper_name);
3971
3972   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
3973   lt_setenv ("DUALCASE", "1");  /* for MSK sh */
3974   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
3975   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
3976
3977   newargc=0;
3978   for (i = 1; i < argc; i++)
3979     {
3980       if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)
3981         {
3982           if (argv[i][env_set_opt_len] == '=')
3983             {
3984               const char *p = argv[i] + env_set_opt_len + 1;
3985               lt_opt_process_env_set (p);
3986             }
3987           else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)
3988             {
3989               lt_opt_process_env_set (argv[++i]); /* don't copy */
3990             }
3991           else
3992             lt_fatal ("%s missing required argument", env_set_opt);
3993           continue;
3994         }
3995       if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)
3996         {
3997           if (argv[i][env_prepend_opt_len] == '=')
3998             {
3999               const char *p = argv[i] + env_prepend_opt_len + 1;
4000               lt_opt_process_env_prepend (p);
4001             }
4002           else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)
4003             {
4004               lt_opt_process_env_prepend (argv[++i]); /* don't copy */
4005             }
4006           else
4007             lt_fatal ("%s missing required argument", env_prepend_opt);
4008           continue;
4009         }
4010       if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)
4011         {
4012           if (argv[i][env_append_opt_len] == '=')
4013             {
4014               const char *p = argv[i] + env_append_opt_len + 1;
4015               lt_opt_process_env_append (p);
4016             }
4017           else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)
4018             {
4019               lt_opt_process_env_append (argv[++i]); /* don't copy */
4020             }
4021           else
4022             lt_fatal ("%s missing required argument", env_append_opt);
4023           continue;
4024         }
4025       if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)
4026         {
4027           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
4028              namespace, but it is not one of the ones we know about and
4029              have already dealt with, above (inluding dump-script), then
4030              report an error. Otherwise, targets might begin to believe
4031              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
4032              namespace. The first time any user complains about this, we'll
4033              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
4034              or a configure.ac-settable value.
4035            */
4036           lt_fatal ("Unrecognized option in %s namespace: '%s'",
4037                     ltwrapper_option_prefix, argv[i]);
4038         }
4039       /* otherwise ... */
4040       newargz[++newargc] = xstrdup (argv[i]);
4041     }
4042   newargz[++newargc] = NULL;
4043
4044   LTWRAPPER_DEBUGPRINTF     (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));
4045   for (i = 0; i < newargc; i++)
4046     {
4047       LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));
4048     }
4049
4050 EOF
4051
4052             case $host_os in
4053               mingw*)
4054                 cat <<"EOF"
4055   /* execv doesn't actually work on mingw as expected on unix */
4056   rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
4057   if (rval == -1)
4058     {
4059       /* failed to start process */
4060       LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));
4061       return 127;
4062     }
4063   return rval;
4064 EOF
4065                 ;;
4066               *)
4067                 cat <<"EOF"
4068   execv (lt_argv_zero, newargz);
4069   return rval; /* =127, but avoids unused variable warning */
4070 EOF
4071                 ;;
4072             esac
4073
4074             cat <<"EOF"
4075 }
4076
4077 void *
4078 xmalloc (size_t num)
4079 {
4080   void *p = (void *) malloc (num);
4081   if (!p)
4082     lt_fatal ("Memory exhausted");
4083
4084   return p;
4085 }
4086
4087 char *
4088 xstrdup (const char *string)
4089 {
4090   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
4091                           string) : NULL;
4092 }
4093
4094 const char *
4095 base_name (const char *name)
4096 {
4097   const char *base;
4098
4099 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4100   /* Skip over the disk name in MSDOS pathnames. */
4101   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
4102     name += 2;
4103 #endif
4104
4105   for (base = name; *name; name++)
4106     if (IS_DIR_SEPARATOR (*name))
4107       base = name + 1;
4108   return base;
4109 }
4110
4111 int
4112 check_executable (const char *path)
4113 {
4114   struct stat st;
4115
4116   LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",
4117                           path ? (*path ? path : "EMPTY!") : "NULL!"));
4118   if ((!path) || (!*path))
4119     return 0;
4120
4121   if ((stat (path, &st) >= 0)
4122       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
4123     return 1;
4124   else
4125     return 0;
4126 }
4127
4128 int
4129 make_executable (const char *path)
4130 {
4131   int rval = 0;
4132   struct stat st;
4133
4134   LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",
4135                           path ? (*path ? path : "EMPTY!") : "NULL!"));
4136   if ((!path) || (!*path))
4137     return 0;
4138
4139   if (stat (path, &st) >= 0)
4140     {
4141       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
4142     }
4143   return rval;
4144 }
4145
4146 /* Searches for the full path of the wrapper.  Returns
4147    newly allocated full path name if found, NULL otherwise
4148    Does not chase symlinks, even on platforms that support them.
4149 */
4150 char *
4151 find_executable (const char *wrapper)
4152 {
4153   int has_slash = 0;
4154   const char *p;
4155   const char *p_next;
4156   /* static buffer for getcwd */
4157   char tmp[LT_PATHMAX + 1];
4158   int tmp_len;
4159   char *concat_name;
4160
4161   LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",
4162                           wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));
4163
4164   if ((wrapper == NULL) || (*wrapper == '\0'))
4165     return NULL;
4166
4167   /* Absolute path? */
4168 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4169   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
4170     {
4171       concat_name = xstrdup (wrapper);
4172       if (check_executable (concat_name))
4173         return concat_name;
4174       XFREE (concat_name);
4175     }
4176   else
4177     {
4178 #endif
4179       if (IS_DIR_SEPARATOR (wrapper[0]))
4180         {
4181           concat_name = xstrdup (wrapper);
4182           if (check_executable (concat_name))
4183             return concat_name;
4184           XFREE (concat_name);
4185         }
4186 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4187     }
4188 #endif
4189
4190   for (p = wrapper; *p; p++)
4191     if (*p == '/')
4192       {
4193         has_slash = 1;
4194         break;
4195       }
4196   if (!has_slash)
4197     {
4198       /* no slashes; search PATH */
4199       const char *path = getenv ("PATH");
4200       if (path != NULL)
4201         {
4202           for (p = path; *p; p = p_next)
4203             {
4204               const char *q;
4205               size_t p_len;
4206               for (q = p; *q; q++)
4207                 if (IS_PATH_SEPARATOR (*q))
4208                   break;
4209               p_len = q - p;
4210               p_next = (*q == '\0' ? q : q + 1);
4211               if (p_len == 0)
4212                 {
4213                   /* empty path: current directory */
4214                   if (getcwd (tmp, LT_PATHMAX) == NULL)
4215                     lt_fatal ("getcwd failed");
4216                   tmp_len = strlen (tmp);
4217                   concat_name =
4218                     XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4219                   memcpy (concat_name, tmp, tmp_len);
4220                   concat_name[tmp_len] = '/';
4221                   strcpy (concat_name + tmp_len + 1, wrapper);
4222                 }
4223               else
4224                 {
4225                   concat_name =
4226                     XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
4227                   memcpy (concat_name, p, p_len);
4228                   concat_name[p_len] = '/';
4229                   strcpy (concat_name + p_len + 1, wrapper);
4230                 }
4231               if (check_executable (concat_name))
4232                 return concat_name;
4233               XFREE (concat_name);
4234             }
4235         }
4236       /* not found in PATH; assume curdir */
4237     }
4238   /* Relative path | not found in path: prepend cwd */
4239   if (getcwd (tmp, LT_PATHMAX) == NULL)
4240     lt_fatal ("getcwd failed");
4241   tmp_len = strlen (tmp);
4242   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
4243   memcpy (concat_name, tmp, tmp_len);
4244   concat_name[tmp_len] = '/';
4245   strcpy (concat_name + tmp_len + 1, wrapper);
4246
4247   if (check_executable (concat_name))
4248     return concat_name;
4249   XFREE (concat_name);
4250   return NULL;
4251 }
4252
4253 char *
4254 chase_symlinks (const char *pathspec)
4255 {
4256 #ifndef S_ISLNK
4257   return xstrdup (pathspec);
4258 #else
4259   char buf[LT_PATHMAX];
4260   struct stat s;
4261   char *tmp_pathspec = xstrdup (pathspec);
4262   char *p;
4263   int has_symlinks = 0;
4264   while (strlen (tmp_pathspec) && !has_symlinks)
4265     {
4266       LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",
4267                               tmp_pathspec));
4268       if (lstat (tmp_pathspec, &s) == 0)
4269         {
4270           if (S_ISLNK (s.st_mode) != 0)
4271             {
4272               has_symlinks = 1;
4273               break;
4274             }
4275
4276           /* search backwards for last DIR_SEPARATOR */
4277           p = tmp_pathspec + strlen (tmp_pathspec) - 1;
4278           while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4279             p--;
4280           if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
4281             {
4282               /* no more DIR_SEPARATORS left */
4283               break;
4284             }
4285           *p = '\0';
4286         }
4287       else
4288         {
4289           char *errstr = strerror (errno);
4290           lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);
4291         }
4292     }
4293   XFREE (tmp_pathspec);
4294
4295   if (!has_symlinks)
4296     {
4297       return xstrdup (pathspec);
4298     }
4299
4300   tmp_pathspec = realpath (pathspec, buf);
4301   if (tmp_pathspec == 0)
4302     {
4303       lt_fatal ("Could not follow symlinks for %s", pathspec);
4304     }
4305   return xstrdup (tmp_pathspec);
4306 #endif
4307 }
4308
4309 char *
4310 strendzap (char *str, const char *pat)
4311 {
4312   size_t len, patlen;
4313
4314   assert (str != NULL);
4315   assert (pat != NULL);
4316
4317   len = strlen (str);
4318   patlen = strlen (pat);
4319
4320   if (patlen <= len)
4321     {
4322       str += len - patlen;
4323       if (strcmp (str, pat) == 0)
4324         *str = '\0';
4325     }
4326   return str;
4327 }
4328
4329 static void
4330 lt_error_core (int exit_status, const char *mode,
4331                const char *message, va_list ap)
4332 {
4333   fprintf (stderr, "%s: %s: ", program_name, mode);
4334   vfprintf (stderr, message, ap);
4335   fprintf (stderr, ".\n");
4336
4337   if (exit_status >= 0)
4338     exit (exit_status);
4339 }
4340
4341 void
4342 lt_fatal (const char *message, ...)
4343 {
4344   va_list ap;
4345   va_start (ap, message);
4346   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4347   va_end (ap);
4348 }
4349
4350 void
4351 lt_setenv (const char *name, const char *value)
4352 {
4353   LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",
4354                           (name ? name : "<NULL>"),
4355                           (value ? value : "<NULL>")));
4356   {
4357 #ifdef HAVE_SETENV
4358     /* always make a copy, for consistency with !HAVE_SETENV */
4359     char *str = xstrdup (value);
4360     setenv (name, str, 1);
4361 #else
4362     int len = strlen (name) + 1 + strlen (value) + 1;
4363     char *str = XMALLOC (char, len);
4364     sprintf (str, "%s=%s", name, value);
4365     if (putenv (str) != EXIT_SUCCESS)
4366       {
4367         XFREE (str);
4368       }
4369 #endif
4370   }
4371 }
4372
4373 char *
4374 lt_extend_str (const char *orig_value, const char *add, int to_end)
4375 {
4376   char *new_value;
4377   if (orig_value && *orig_value)
4378     {
4379       int orig_value_len = strlen (orig_value);
4380       int add_len = strlen (add);
4381       new_value = XMALLOC (char, add_len + orig_value_len + 1);
4382       if (to_end)
4383         {
4384           strcpy (new_value, orig_value);
4385           strcpy (new_value + orig_value_len, add);
4386         }
4387       else
4388         {
4389           strcpy (new_value, add);
4390           strcpy (new_value + add_len, orig_value);
4391         }
4392     }
4393   else
4394     {
4395       new_value = xstrdup (add);
4396     }
4397   return new_value;
4398 }
4399
4400 int
4401 lt_split_name_value (const char *arg, char** name, char** value)
4402 {
4403   const char *p;
4404   int len;
4405   if (!arg || !*arg)
4406     return 1;
4407
4408   p = strchr (arg, (int)'=');
4409
4410   if (!p)
4411     return 1;
4412
4413   *value = xstrdup (++p);
4414
4415   len = strlen (arg) - strlen (*value);
4416   *name = XMALLOC (char, len);
4417   strncpy (*name, arg, len-1);
4418   (*name)[len - 1] = '\0';
4419
4420   return 0;
4421 }
4422
4423 void
4424 lt_opt_process_env_set (const char *arg)
4425 {
4426   char *name = NULL;
4427   char *value = NULL;
4428
4429   if (lt_split_name_value (arg, &name, &value) != 0)
4430     {
4431       XFREE (name);
4432       XFREE (value);
4433       lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);
4434     }
4435
4436   lt_setenv (name, value);
4437   XFREE (name);
4438   XFREE (value);
4439 }
4440
4441 void
4442 lt_opt_process_env_prepend (const char *arg)
4443 {
4444   char *name = NULL;
4445   char *value = NULL;
4446   char *new_value = NULL;
4447
4448   if (lt_split_name_value (arg, &name, &value) != 0)
4449     {
4450       XFREE (name);
4451       XFREE (value);
4452       lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);
4453     }
4454
4455   new_value = lt_extend_str (getenv (name), value, 0);
4456   lt_setenv (name, new_value);
4457   XFREE (new_value);
4458   XFREE (name);
4459   XFREE (value);
4460 }
4461
4462 void
4463 lt_opt_process_env_append (const char *arg)
4464 {
4465   char *name = NULL;
4466   char *value = NULL;
4467   char *new_value = NULL;
4468
4469   if (lt_split_name_value (arg, &name, &value) != 0)
4470     {
4471       XFREE (name);
4472       XFREE (value);
4473       lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);
4474     }
4475
4476   new_value = lt_extend_str (getenv (name), value, 1);
4477   lt_setenv (name, new_value);
4478   XFREE (new_value);
4479   XFREE (name);
4480   XFREE (value);
4481 }
4482
4483 void
4484 lt_update_exe_path (const char *name, const char *value)
4485 {
4486   LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
4487                           (name ? name : "<NULL>"),
4488                           (value ? value : "<NULL>")));
4489
4490   if (name && *name && value && *value)
4491     {
4492       char *new_value = lt_extend_str (getenv (name), value, 0);
4493       /* some systems can't cope with a ':'-terminated path #' */
4494       int len = strlen (new_value);
4495       while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
4496         {
4497           new_value[len-1] = '\0';
4498         }
4499       lt_setenv (name, new_value);
4500       XFREE (new_value);
4501     }
4502 }
4503
4504 void
4505 lt_update_lib_path (const char *name, const char *value)
4506 {
4507   LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
4508                           (name ? name : "<NULL>"),
4509                           (value ? value : "<NULL>")));
4510
4511   if (name && *name && value && *value)
4512     {
4513       char *new_value = lt_extend_str (getenv (name), value, 0);
4514       lt_setenv (name, new_value);
4515       XFREE (new_value);
4516     }
4517 }
4518
4519
4520 EOF
4521 }
4522 # end: func_emit_cwrapperexe_src
4523
4524 # func_mode_link arg...
4525 func_mode_link ()
4526 {
4527     $opt_debug
4528     case $host in
4529     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4530       # It is impossible to link a dll without this setting, and
4531       # we shouldn't force the makefile maintainer to figure out
4532       # which system we are compiling for in order to pass an extra
4533       # flag for every libtool invocation.
4534       # allow_undefined=no
4535
4536       # FIXME: Unfortunately, there are problems with the above when trying
4537       # to make a dll which has undefined symbols, in which case not
4538       # even a static library is built.  For now, we need to specify
4539       # -no-undefined on the libtool link line when we can be certain
4540       # that all symbols are satisfied, otherwise we get a static library.
4541       allow_undefined=yes
4542       ;;
4543     *)
4544       allow_undefined=yes
4545       ;;
4546     esac
4547     libtool_args=$nonopt
4548     base_compile="$nonopt $@"
4549     compile_command=$nonopt
4550     finalize_command=$nonopt
4551
4552     compile_rpath=
4553     finalize_rpath=
4554     compile_shlibpath=
4555     finalize_shlibpath=
4556     convenience=
4557     old_convenience=
4558     deplibs=
4559     old_deplibs=
4560     compiler_flags=
4561     linker_flags=
4562     dllsearchpath=
4563     lib_search_path=`pwd`
4564     inst_prefix_dir=
4565     new_inherited_linker_flags=
4566
4567     avoid_version=no
4568     dlfiles=
4569     dlprefiles=
4570     dlself=no
4571     export_dynamic=no
4572     export_symbols=
4573     export_symbols_regex=
4574     generated=
4575     libobjs=
4576     ltlibs=
4577     module=no
4578     no_install=no
4579     objs=
4580     non_pic_objects=
4581     precious_files_regex=
4582     prefer_static_libs=no
4583     preload=no
4584     prev=
4585     prevarg=
4586     release=
4587     rpath=
4588     xrpath=
4589     perm_rpath=
4590     temp_rpath=
4591     thread_safe=no
4592     vinfo=
4593     vinfo_number=no
4594     weak_libs=
4595     single_module="${wl}-single_module"
4596     func_infer_tag $base_compile
4597
4598     # We need to know -static, to get the right output filenames.
4599     for arg
4600     do
4601       case $arg in
4602       -shared)
4603         test "$build_libtool_libs" != yes && \
4604           func_fatal_configuration "can not build a shared library"
4605         build_old_libs=no
4606         break
4607         ;;
4608       -all-static | -static | -static-libtool-libs)
4609         case $arg in
4610         -all-static)
4611           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
4612             func_warning "complete static linking is impossible in this configuration"
4613           fi
4614           if test -n "$link_static_flag"; then
4615             dlopen_self=$dlopen_self_static
4616           fi
4617           prefer_static_libs=yes
4618           ;;
4619         -static)
4620           if test -z "$pic_flag" && test -n "$link_static_flag"; then
4621             dlopen_self=$dlopen_self_static
4622           fi
4623           prefer_static_libs=built
4624           ;;
4625         -static-libtool-libs)
4626           if test -z "$pic_flag" && test -n "$link_static_flag"; then
4627             dlopen_self=$dlopen_self_static
4628           fi
4629           prefer_static_libs=yes
4630           ;;
4631         esac
4632         build_libtool_libs=no
4633         build_old_libs=yes
4634         break
4635         ;;
4636       esac
4637     done
4638
4639     # See if our shared archives depend on static archives.
4640     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
4641
4642     # Go through the arguments, transforming them on the way.
4643     while test "$#" -gt 0; do
4644       arg="$1"
4645       shift
4646       func_quote_for_eval "$arg"
4647       qarg=$func_quote_for_eval_unquoted_result
4648       func_append libtool_args " $func_quote_for_eval_result"
4649
4650       # If the previous option needs an argument, assign it.
4651       if test -n "$prev"; then
4652         case $prev in
4653         output)
4654           func_append compile_command " @OUTPUT@"
4655           func_append finalize_command " @OUTPUT@"
4656           ;;
4657         esac
4658
4659         case $prev in
4660         dlfiles|dlprefiles)
4661           if test "$preload" = no; then
4662             # Add the symbol object into the linking commands.
4663             func_append compile_command " @SYMFILE@"
4664             func_append finalize_command " @SYMFILE@"
4665             preload=yes
4666           fi
4667           case $arg in
4668           *.la | *.lo) ;;  # We handle these cases below.
4669           force)
4670             if test "$dlself" = no; then
4671               dlself=needless
4672               export_dynamic=yes
4673             fi
4674             prev=
4675             continue
4676             ;;
4677           self)
4678             if test "$prev" = dlprefiles; then
4679               dlself=yes
4680             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
4681               dlself=yes
4682             else
4683               dlself=needless
4684               export_dynamic=yes
4685             fi
4686             prev=
4687             continue
4688             ;;
4689           *)
4690             if test "$prev" = dlfiles; then
4691               dlfiles="$dlfiles $arg"
4692             else
4693               dlprefiles="$dlprefiles $arg"
4694             fi
4695             prev=
4696             continue
4697             ;;
4698           esac
4699           ;;
4700         expsyms)
4701           export_symbols="$arg"
4702           test -f "$arg" \
4703             || func_fatal_error "symbol file \`$arg' does not exist"
4704           prev=
4705           continue
4706           ;;
4707         expsyms_regex)
4708           export_symbols_regex="$arg"
4709           prev=
4710           continue
4711           ;;
4712         framework)
4713           case $host in
4714             *-*-darwin*)
4715               case "$deplibs " in
4716                 *" $qarg.ltframework "*) ;;
4717                 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later
4718                    ;;
4719               esac
4720               ;;
4721           esac
4722           prev=
4723           continue
4724           ;;
4725         inst_prefix)
4726           inst_prefix_dir="$arg"
4727           prev=
4728           continue
4729           ;;
4730         objectlist)
4731           if test -f "$arg"; then
4732             save_arg=$arg
4733             moreargs=
4734             for fil in `cat "$save_arg"`
4735             do
4736 #             moreargs="$moreargs $fil"
4737               arg=$fil
4738               # A libtool-controlled object.
4739
4740               # Check to see that this really is a libtool object.
4741               if func_lalib_unsafe_p "$arg"; then
4742                 pic_object=
4743                 non_pic_object=
4744
4745                 # Read the .lo file
4746                 func_source "$arg"
4747
4748                 if test -z "$pic_object" ||
4749                    test -z "$non_pic_object" ||
4750                    test "$pic_object" = none &&
4751                    test "$non_pic_object" = none; then
4752                   func_fatal_error "cannot find name of object for \`$arg'"
4753                 fi
4754
4755                 # Extract subdirectory from the argument.
4756                 func_dirname "$arg" "/" ""
4757                 xdir="$func_dirname_result"
4758
4759                 if test "$pic_object" != none; then
4760                   # Prepend the subdirectory the object is found in.
4761                   pic_object="$xdir$pic_object"
4762
4763                   if test "$prev" = dlfiles; then
4764                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
4765                       dlfiles="$dlfiles $pic_object"
4766                       prev=
4767                       continue
4768                     else
4769                       # If libtool objects are unsupported, then we need to preload.
4770                       prev=dlprefiles
4771                     fi
4772                   fi
4773
4774                   # CHECK ME:  I think I busted this.  -Ossama
4775                   if test "$prev" = dlprefiles; then
4776                     # Preload the old-style object.
4777                     dlprefiles="$dlprefiles $pic_object"
4778                     prev=
4779                   fi
4780
4781                   # A PIC object.
4782                   func_append libobjs " $pic_object"
4783                   arg="$pic_object"
4784                 fi
4785
4786                 # Non-PIC object.
4787                 if test "$non_pic_object" != none; then
4788                   # Prepend the subdirectory the object is found in.
4789                   non_pic_object="$xdir$non_pic_object"
4790
4791                   # A standard non-PIC object
4792                   func_append non_pic_objects " $non_pic_object"
4793                   if test -z "$pic_object" || test "$pic_object" = none ; then
4794                     arg="$non_pic_object"
4795                   fi
4796                 else
4797                   # If the PIC object exists, use it instead.
4798                   # $xdir was prepended to $pic_object above.
4799                   non_pic_object="$pic_object"
4800                   func_append non_pic_objects " $non_pic_object"
4801                 fi
4802               else
4803                 # Only an error if not doing a dry-run.
4804                 if $opt_dry_run; then
4805                   # Extract subdirectory from the argument.
4806                   func_dirname "$arg" "/" ""
4807                   xdir="$func_dirname_result"
4808
4809                   func_lo2o "$arg"
4810                   pic_object=$xdir$objdir/$func_lo2o_result
4811                   non_pic_object=$xdir$func_lo2o_result
4812                   func_append libobjs " $pic_object"
4813                   func_append non_pic_objects " $non_pic_object"
4814                 else
4815                   func_fatal_error "\`$arg' is not a valid libtool object"
4816                 fi
4817               fi
4818             done
4819           else
4820             func_fatal_error "link input file \`$arg' does not exist"
4821           fi
4822           arg=$save_arg
4823           prev=
4824           continue
4825           ;;
4826         precious_regex)
4827           precious_files_regex="$arg"
4828           prev=
4829           continue
4830           ;;
4831         release)
4832           release="-$arg"
4833           prev=
4834           continue
4835           ;;
4836         rpath | xrpath)
4837           # We need an absolute path.
4838           case $arg in
4839           [\\/]* | [A-Za-z]:[\\/]*) ;;
4840           *)
4841             func_fatal_error "only absolute run-paths are allowed"
4842             ;;
4843           esac
4844           if test "$prev" = rpath; then
4845             case "$rpath " in
4846             *" $arg "*) ;;
4847             *) rpath="$rpath $arg" ;;
4848             esac
4849           else
4850             case "$xrpath " in
4851             *" $arg "*) ;;
4852             *) xrpath="$xrpath $arg" ;;
4853             esac
4854           fi
4855           prev=
4856           continue
4857           ;;
4858         shrext)
4859           shrext_cmds="$arg"
4860           prev=
4861           continue
4862           ;;
4863         weak)
4864           weak_libs="$weak_libs $arg"
4865           prev=
4866           continue
4867           ;;
4868         xcclinker)
4869           linker_flags="$linker_flags $qarg"
4870           compiler_flags="$compiler_flags $qarg"
4871           prev=
4872           func_append compile_command " $qarg"
4873           func_append finalize_command " $qarg"
4874           continue
4875           ;;
4876         xcompiler)
4877           compiler_flags="$compiler_flags $qarg"
4878           prev=
4879           func_append compile_command " $qarg"
4880           func_append finalize_command " $qarg"
4881           continue
4882           ;;
4883         xlinker)
4884           linker_flags="$linker_flags $qarg"
4885           compiler_flags="$compiler_flags $wl$qarg"
4886           prev=
4887           func_append compile_command " $wl$qarg"
4888           func_append finalize_command " $wl$qarg"
4889           continue
4890           ;;
4891         *)
4892           eval "$prev=\"\$arg\""
4893           prev=
4894           continue
4895           ;;
4896         esac
4897       fi # test -n "$prev"
4898
4899       prevarg="$arg"
4900
4901       case $arg in
4902       -all-static)
4903         if test -n "$link_static_flag"; then
4904           # See comment for -static flag below, for more details.
4905           func_append compile_command " $link_static_flag"
4906           func_append finalize_command " $link_static_flag"
4907         fi
4908         continue
4909         ;;
4910
4911       -allow-undefined)
4912         # FIXME: remove this flag sometime in the future.
4913         func_fatal_error "\`-allow-undefined' must not be used because it is the default"
4914         ;;
4915
4916       -avoid-version)
4917         avoid_version=yes
4918         continue
4919         ;;
4920
4921       -dlopen)
4922         prev=dlfiles
4923         continue
4924         ;;
4925
4926       -dlpreopen)
4927         prev=dlprefiles
4928         continue
4929         ;;
4930
4931       -export-dynamic)
4932         export_dynamic=yes
4933         continue
4934         ;;
4935
4936       -export-symbols | -export-symbols-regex)
4937         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
4938           func_fatal_error "more than one -exported-symbols argument is not allowed"
4939         fi
4940         if test "X$arg" = "X-export-symbols"; then
4941           prev=expsyms
4942         else
4943           prev=expsyms_regex
4944         fi
4945         continue
4946         ;;
4947
4948       -framework)
4949         prev=framework
4950         continue
4951         ;;
4952
4953       -inst-prefix-dir)
4954         prev=inst_prefix
4955         continue
4956         ;;
4957
4958       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
4959       # so, if we see these flags be careful not to treat them like -L
4960       -L[A-Z][A-Z]*:*)
4961         case $with_gcc/$host in
4962         no/*-*-irix* | /*-*-irix*)
4963           func_append compile_command " $arg"
4964           func_append finalize_command " $arg"
4965           ;;
4966         esac
4967         continue
4968         ;;
4969
4970       -L*)
4971         func_stripname '-L' '' "$arg"
4972         dir=$func_stripname_result
4973         if test -z "$dir"; then
4974           if test "$#" -gt 0; then
4975             func_fatal_error "require no space between \`-L' and \`$1'"
4976           else
4977             func_fatal_error "need path for \`-L' option"
4978           fi
4979         fi
4980         # We need an absolute path.
4981         case $dir in
4982         [\\/]* | [A-Za-z]:[\\/]*) ;;
4983         *)
4984           absdir=`cd "$dir" && pwd`
4985           test -z "$absdir" && \
4986             func_fatal_error "cannot determine absolute directory name of \`$dir'"
4987           dir="$absdir"
4988           ;;
4989         esac
4990         case "$deplibs " in
4991         *" -L$dir "*) ;;
4992         *)
4993           deplibs="$deplibs -L$dir"
4994           lib_search_path="$lib_search_path $dir"
4995           ;;
4996         esac
4997         case $host in
4998         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
4999           testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`
5000           case :$dllsearchpath: in
5001           *":$dir:"*) ;;
5002           ::) dllsearchpath=$dir;;
5003           *) dllsearchpath="$dllsearchpath:$dir";;
5004           esac
5005           case :$dllsearchpath: in
5006           *":$testbindir:"*) ;;
5007           ::) dllsearchpath=$testbindir;;
5008           *) dllsearchpath="$dllsearchpath:$testbindir";;
5009           esac
5010           ;;
5011         esac
5012         continue
5013         ;;
5014
5015       -l*)
5016         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
5017           case $host in
5018           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)
5019             # These systems don't actually have a C or math library (as such)
5020             continue
5021             ;;
5022           *-*-os2*)
5023             # These systems don't actually have a C library (as such)
5024             test "X$arg" = "X-lc" && continue
5025             ;;
5026           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5027             # Do not include libc due to us having libc/libc_r.
5028             test "X$arg" = "X-lc" && continue
5029             ;;
5030           *-*-rhapsody* | *-*-darwin1.[012])
5031             # Rhapsody C and math libraries are in the System framework
5032             deplibs="$deplibs System.ltframework"
5033             continue
5034             ;;
5035           *-*-sco3.2v5* | *-*-sco5v6*)
5036             # Causes problems with __ctype
5037             test "X$arg" = "X-lc" && continue
5038             ;;
5039           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
5040             # Compiler inserts libc in the correct place for threads to work
5041             test "X$arg" = "X-lc" && continue
5042             ;;
5043           esac
5044         elif test "X$arg" = "X-lc_r"; then
5045          case $host in
5046          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
5047            # Do not include libc_r directly, use -pthread flag.
5048            continue
5049            ;;
5050          esac
5051         fi
5052         deplibs="$deplibs $arg"
5053         continue
5054         ;;
5055
5056       -module)
5057         module=yes
5058         continue
5059         ;;
5060
5061       # Tru64 UNIX uses -model [arg] to determine the layout of C++
5062       # classes, name mangling, and exception handling.
5063       # Darwin uses the -arch flag to determine output architecture.
5064       -model|-arch|-isysroot)
5065         compiler_flags="$compiler_flags $arg"
5066         func_append compile_command " $arg"
5067         func_append finalize_command " $arg"
5068         prev=xcompiler
5069         continue
5070         ;;
5071
5072       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5073         compiler_flags="$compiler_flags $arg"
5074         func_append compile_command " $arg"
5075         func_append finalize_command " $arg"
5076         case "$new_inherited_linker_flags " in
5077             *" $arg "*) ;;
5078             * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;
5079         esac
5080         continue
5081         ;;
5082
5083       -multi_module)
5084         single_module="${wl}-multi_module"
5085         continue
5086         ;;
5087
5088       -no-fast-install)
5089         fast_install=no
5090         continue
5091         ;;
5092
5093       -no-install)
5094         case $host in
5095         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
5096           # The PATH hackery in wrapper scripts is required on Windows
5097           # and Darwin in order for the loader to find any dlls it needs.
5098           func_warning "\`-no-install' is ignored for $host"
5099           func_warning "assuming \`-no-fast-install' instead"
5100           fast_install=no
5101           ;;
5102         *) no_install=yes ;;
5103         esac
5104         continue
5105         ;;
5106
5107       -no-undefined)
5108         allow_undefined=no
5109         continue
5110         ;;
5111
5112       -objectlist)
5113         prev=objectlist
5114         continue
5115         ;;
5116
5117       -o) prev=output ;;
5118
5119       -precious-files-regex)
5120         prev=precious_regex
5121         continue
5122         ;;
5123
5124       -release)
5125         prev=release
5126         continue
5127         ;;
5128
5129       -rpath)
5130         prev=rpath
5131         continue
5132         ;;
5133
5134       -R)
5135         prev=xrpath
5136         continue
5137         ;;
5138
5139       -R*)
5140         func_stripname '-R' '' "$arg"
5141         dir=$func_stripname_result
5142         # We need an absolute path.
5143         case $dir in
5144         [\\/]* | [A-Za-z]:[\\/]*) ;;
5145         *)
5146           func_fatal_error "only absolute run-paths are allowed"
5147           ;;
5148         esac
5149         case "$xrpath " in
5150         *" $dir "*) ;;
5151         *) xrpath="$xrpath $dir" ;;
5152         esac
5153         continue
5154         ;;
5155
5156       -shared)
5157         # The effects of -shared are defined in a previous loop.
5158         continue
5159         ;;
5160
5161       -shrext)
5162         prev=shrext
5163         continue
5164         ;;
5165
5166       -static | -static-libtool-libs)
5167         # The effects of -static are defined in a previous loop.
5168         # We used to do the same as -all-static on platforms that
5169         # didn't have a PIC flag, but the assumption that the effects
5170         # would be equivalent was wrong.  It would break on at least
5171         # Digital Unix and AIX.
5172         continue
5173         ;;
5174
5175       -thread-safe)
5176         thread_safe=yes
5177         continue
5178         ;;
5179
5180       -version-info)
5181         prev=vinfo
5182         continue
5183         ;;
5184
5185       -version-number)
5186         prev=vinfo
5187         vinfo_number=yes
5188         continue
5189         ;;
5190
5191       -weak)
5192         prev=weak
5193         continue
5194         ;;
5195
5196       -Wc,*)
5197         func_stripname '-Wc,' '' "$arg"
5198         args=$func_stripname_result
5199         arg=
5200         save_ifs="$IFS"; IFS=','
5201         for flag in $args; do
5202           IFS="$save_ifs"
5203           func_quote_for_eval "$flag"
5204           arg="$arg $wl$func_quote_for_eval_result"
5205           compiler_flags="$compiler_flags $func_quote_for_eval_result"
5206         done
5207         IFS="$save_ifs"
5208         func_stripname ' ' '' "$arg"
5209         arg=$func_stripname_result
5210         ;;
5211
5212       -Wl,*)
5213         func_stripname '-Wl,' '' "$arg"
5214         args=$func_stripname_result
5215         arg=
5216         save_ifs="$IFS"; IFS=','
5217         for flag in $args; do
5218           IFS="$save_ifs"
5219           func_quote_for_eval "$flag"
5220           arg="$arg $wl$func_quote_for_eval_result"
5221           compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"
5222           linker_flags="$linker_flags $func_quote_for_eval_result"
5223         done
5224         IFS="$save_ifs"
5225         func_stripname ' ' '' "$arg"
5226         arg=$func_stripname_result
5227         ;;
5228
5229       -Xcompiler)
5230         prev=xcompiler
5231         continue
5232         ;;
5233
5234       -Xlinker)
5235         prev=xlinker
5236         continue
5237         ;;
5238
5239       -XCClinker)
5240         prev=xcclinker
5241         continue
5242         ;;
5243
5244       # -msg_* for osf cc
5245       -msg_*)
5246         func_quote_for_eval "$arg"
5247         arg="$func_quote_for_eval_result"
5248         ;;
5249
5250       # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
5251       # -r[0-9][0-9]* specifies the processor on the SGI compiler
5252       # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
5253       # +DA*, +DD* enable 64-bit mode on the HP compiler
5254       # -q* pass through compiler args for the IBM compiler
5255       # -m*, -t[45]*, -txscale* pass through architecture-specific
5256       # compiler args for GCC
5257       # -F/path gives path to uninstalled frameworks, gcc on darwin
5258       # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
5259       # @file GCC response files
5260       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
5261       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
5262         func_quote_for_eval "$arg"
5263         arg="$func_quote_for_eval_result"
5264         func_append compile_command " $arg"
5265         func_append finalize_command " $arg"
5266         compiler_flags="$compiler_flags $arg"
5267         continue
5268         ;;
5269
5270       # Some other compiler flag.
5271       -* | +*)
5272         func_quote_for_eval "$arg"
5273         arg="$func_quote_for_eval_result"
5274         ;;
5275
5276       *.$objext)
5277         # A standard object.
5278         objs="$objs $arg"
5279         ;;
5280
5281       *.lo)
5282         # A libtool-controlled object.
5283
5284         # Check to see that this really is a libtool object.
5285         if func_lalib_unsafe_p "$arg"; then
5286           pic_object=
5287           non_pic_object=
5288
5289           # Read the .lo file
5290           func_source "$arg"
5291
5292           if test -z "$pic_object" ||
5293              test -z "$non_pic_object" ||
5294              test "$pic_object" = none &&
5295              test "$non_pic_object" = none; then
5296             func_fatal_error "cannot find name of object for \`$arg'"
5297           fi
5298
5299           # Extract subdirectory from the argument.
5300           func_dirname "$arg" "/" ""
5301           xdir="$func_dirname_result"
5302
5303           if test "$pic_object" != none; then
5304             # Prepend the subdirectory the object is found in.
5305             pic_object="$xdir$pic_object"
5306
5307             if test "$prev" = dlfiles; then
5308               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
5309                 dlfiles="$dlfiles $pic_object"
5310                 prev=
5311                 continue
5312               else
5313                 # If libtool objects are unsupported, then we need to preload.
5314                 prev=dlprefiles
5315               fi
5316             fi
5317
5318             # CHECK ME:  I think I busted this.  -Ossama
5319             if test "$prev" = dlprefiles; then
5320               # Preload the old-style object.
5321               dlprefiles="$dlprefiles $pic_object"
5322               prev=
5323             fi
5324
5325             # A PIC object.
5326             func_append libobjs " $pic_object"
5327             arg="$pic_object"
5328           fi
5329
5330           # Non-PIC object.
5331           if test "$non_pic_object" != none; then
5332             # Prepend the subdirectory the object is found in.
5333             non_pic_object="$xdir$non_pic_object"
5334
5335             # A standard non-PIC object
5336             func_append non_pic_objects " $non_pic_object"
5337             if test -z "$pic_object" || test "$pic_object" = none ; then
5338               arg="$non_pic_object"
5339             fi
5340           else
5341             # If the PIC object exists, use it instead.
5342             # $xdir was prepended to $pic_object above.
5343             non_pic_object="$pic_object"
5344             func_append non_pic_objects " $non_pic_object"
5345           fi
5346         else
5347           # Only an error if not doing a dry-run.
5348           if $opt_dry_run; then
5349             # Extract subdirectory from the argument.
5350             func_dirname "$arg" "/" ""
5351             xdir="$func_dirname_result"
5352
5353             func_lo2o "$arg"
5354             pic_object=$xdir$objdir/$func_lo2o_result
5355             non_pic_object=$xdir$func_lo2o_result
5356             func_append libobjs " $pic_object"
5357             func_append non_pic_objects " $non_pic_object"
5358           else
5359             func_fatal_error "\`$arg' is not a valid libtool object"
5360           fi
5361         fi
5362         ;;
5363
5364       *.$libext)
5365         # An archive.
5366         deplibs="$deplibs $arg"
5367         old_deplibs="$old_deplibs $arg"
5368         continue
5369         ;;
5370
5371       *.la)
5372         # A libtool-controlled library.
5373
5374         if test "$prev" = dlfiles; then
5375           # This library was specified with -dlopen.
5376           dlfiles="$dlfiles $arg"
5377           prev=
5378         elif test "$prev" = dlprefiles; then
5379           # The library was specified with -dlpreopen.
5380           dlprefiles="$dlprefiles $arg"
5381           prev=
5382         else
5383           deplibs="$deplibs $arg"
5384         fi
5385         continue
5386         ;;
5387
5388       # Some other compiler argument.
5389       *)
5390         # Unknown arguments in both finalize_command and compile_command need
5391         # to be aesthetically quoted because they are evaled later.
5392         func_quote_for_eval "$arg"
5393         arg="$func_quote_for_eval_result"
5394         ;;
5395       esac # arg
5396
5397       # Now actually substitute the argument into the commands.
5398       if test -n "$arg"; then
5399         func_append compile_command " $arg"
5400         func_append finalize_command " $arg"
5401       fi
5402     done # argument parsing loop
5403
5404     test -n "$prev" && \
5405       func_fatal_help "the \`$prevarg' option requires an argument"
5406
5407     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
5408       eval arg=\"$export_dynamic_flag_spec\"
5409       func_append compile_command " $arg"
5410       func_append finalize_command " $arg"
5411     fi
5412
5413     oldlibs=
5414     # calculate the name of the file, without its directory
5415     func_basename "$output"
5416     outputname="$func_basename_result"
5417     libobjs_save="$libobjs"
5418
5419     if test -n "$shlibpath_var"; then
5420       # get the directories listed in $shlibpath_var
5421       eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
5422     else
5423       shlib_search_path=
5424     fi
5425     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
5426     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
5427
5428     func_dirname "$output" "/" ""
5429     output_objdir="$func_dirname_result$objdir"
5430     # Create the object directory.
5431     func_mkdir_p "$output_objdir"
5432
5433     # Determine the type of output
5434     case $output in
5435     "")
5436       func_fatal_help "you must specify an output file"
5437       ;;
5438     *.$libext) linkmode=oldlib ;;
5439     *.lo | *.$objext) linkmode=obj ;;
5440     *.la) linkmode=lib ;;
5441     *) linkmode=prog ;; # Anything else should be a program.
5442     esac
5443
5444     specialdeplibs=
5445
5446     libs=
5447     # Find all interdependent deplibs by searching for libraries
5448     # that are linked more than once (e.g. -la -lb -la)
5449     for deplib in $deplibs; do
5450       if $opt_duplicate_deps ; then
5451         case "$libs " in
5452         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5453         esac
5454       fi
5455       libs="$libs $deplib"
5456     done
5457
5458     if test "$linkmode" = lib; then
5459       libs="$predeps $libs $compiler_lib_search_path $postdeps"
5460
5461       # Compute libraries that are listed more than once in $predeps
5462       # $postdeps and mark them as special (i.e., whose duplicates are
5463       # not to be eliminated).
5464       pre_post_deps=
5465       if $opt_duplicate_compiler_generated_deps; then
5466         for pre_post_dep in $predeps $postdeps; do
5467           case "$pre_post_deps " in
5468           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
5469           esac
5470           pre_post_deps="$pre_post_deps $pre_post_dep"
5471         done
5472       fi
5473       pre_post_deps=
5474     fi
5475
5476     deplibs=
5477     newdependency_libs=
5478     newlib_search_path=
5479     need_relink=no # whether we're linking any uninstalled libtool libraries
5480     notinst_deplibs= # not-installed libtool libraries
5481     notinst_path= # paths that contain not-installed libtool libraries
5482
5483     case $linkmode in
5484     lib)
5485         passes="conv dlpreopen link"
5486         for file in $dlfiles $dlprefiles; do
5487           case $file in
5488           *.la) ;;
5489           *)
5490             func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
5491             ;;
5492           esac
5493         done
5494         ;;
5495     prog)
5496         compile_deplibs=
5497         finalize_deplibs=
5498         alldeplibs=no
5499         newdlfiles=
5500         newdlprefiles=
5501         passes="conv scan dlopen dlpreopen link"
5502         ;;
5503     *)  passes="conv"
5504         ;;
5505     esac
5506
5507     for pass in $passes; do
5508       # The preopen pass in lib mode reverses $deplibs; put it back here
5509       # so that -L comes before libs that need it for instance...
5510       if test "$linkmode,$pass" = "lib,link"; then
5511         ## FIXME: Find the place where the list is rebuilt in the wrong
5512         ##        order, and fix it there properly
5513         tmp_deplibs=
5514         for deplib in $deplibs; do
5515           tmp_deplibs="$deplib $tmp_deplibs"
5516         done
5517         deplibs="$tmp_deplibs"
5518       fi
5519
5520       if test "$linkmode,$pass" = "lib,link" ||
5521          test "$linkmode,$pass" = "prog,scan"; then
5522         libs="$deplibs"
5523         deplibs=
5524       fi
5525       if test "$linkmode" = prog; then
5526         case $pass in
5527         dlopen) libs="$dlfiles" ;;
5528         dlpreopen) libs="$dlprefiles" ;;
5529         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
5530         esac
5531       fi
5532       if test "$linkmode,$pass" = "lib,dlpreopen"; then
5533         # Collect and forward deplibs of preopened libtool libs
5534         for lib in $dlprefiles; do
5535           # Ignore non-libtool-libs
5536           dependency_libs=
5537           case $lib in
5538           *.la) func_source "$lib" ;;
5539           esac
5540
5541           # Collect preopened libtool deplibs, except any this library
5542           # has declared as weak libs
5543           for deplib in $dependency_libs; do
5544             deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`
5545             case " $weak_libs " in
5546             *" $deplib_base "*) ;;
5547             *) deplibs="$deplibs $deplib" ;;
5548             esac
5549           done
5550         done
5551         libs="$dlprefiles"
5552       fi
5553       if test "$pass" = dlopen; then
5554         # Collect dlpreopened libraries
5555         save_deplibs="$deplibs"
5556         deplibs=
5557       fi
5558
5559       for deplib in $libs; do
5560         lib=
5561         found=no
5562         case $deplib in
5563         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
5564           if test "$linkmode,$pass" = "prog,link"; then
5565             compile_deplibs="$deplib $compile_deplibs"
5566             finalize_deplibs="$deplib $finalize_deplibs"
5567           else
5568             compiler_flags="$compiler_flags $deplib"
5569             if test "$linkmode" = lib ; then
5570                 case "$new_inherited_linker_flags " in
5571                     *" $deplib "*) ;;
5572                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5573                 esac
5574             fi
5575           fi
5576           continue
5577           ;;
5578         -l*)
5579           if test "$linkmode" != lib && test "$linkmode" != prog; then
5580             func_warning "\`-l' is ignored for archives/objects"
5581             continue
5582           fi
5583           func_stripname '-l' '' "$deplib"
5584           name=$func_stripname_result
5585           if test "$linkmode" = lib; then
5586             searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
5587           else
5588             searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
5589           fi
5590           for searchdir in $searchdirs; do
5591             for search_ext in .la $std_shrext .so .a; do
5592               # Search the libtool library
5593               lib="$searchdir/lib${name}${search_ext}"
5594               if test -f "$lib"; then
5595                 if test "$search_ext" = ".la"; then
5596                   found=yes
5597                 else
5598                   found=no
5599                 fi
5600                 break 2
5601               fi
5602             done
5603           done
5604           if test "$found" != yes; then
5605             # deplib doesn't seem to be a libtool library
5606             if test "$linkmode,$pass" = "prog,link"; then
5607               compile_deplibs="$deplib $compile_deplibs"
5608               finalize_deplibs="$deplib $finalize_deplibs"
5609             else
5610               deplibs="$deplib $deplibs"
5611               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5612             fi
5613             continue
5614           else # deplib is a libtool library
5615             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
5616             # We need to do some special things here, and not later.
5617             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
5618               case " $predeps $postdeps " in
5619               *" $deplib "*)
5620                 if func_lalib_p "$lib"; then
5621                   library_names=
5622                   old_library=
5623                   func_source "$lib"
5624                   for l in $old_library $library_names; do
5625                     ll="$l"
5626                   done
5627                   if test "X$ll" = "X$old_library" ; then # only static version available
5628                     found=no
5629                     func_dirname "$lib" "" "."
5630                     ladir="$func_dirname_result"
5631                     lib=$ladir/$old_library
5632                     if test "$linkmode,$pass" = "prog,link"; then
5633                       compile_deplibs="$deplib $compile_deplibs"
5634                       finalize_deplibs="$deplib $finalize_deplibs"
5635                     else
5636                       deplibs="$deplib $deplibs"
5637                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
5638                     fi
5639                     continue
5640                   fi
5641                 fi
5642                 ;;
5643               *) ;;
5644               esac
5645             fi
5646           fi
5647           ;; # -l
5648         *.ltframework)
5649           if test "$linkmode,$pass" = "prog,link"; then
5650             compile_deplibs="$deplib $compile_deplibs"
5651             finalize_deplibs="$deplib $finalize_deplibs"
5652           else
5653             deplibs="$deplib $deplibs"
5654             if test "$linkmode" = lib ; then
5655                 case "$new_inherited_linker_flags " in
5656                     *" $deplib "*) ;;
5657                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;
5658                 esac
5659             fi
5660           fi
5661           continue
5662           ;;
5663         -L*)
5664           case $linkmode in
5665           lib)
5666             deplibs="$deplib $deplibs"
5667             test "$pass" = conv && continue
5668             newdependency_libs="$deplib $newdependency_libs"
5669             func_stripname '-L' '' "$deplib"
5670             newlib_search_path="$newlib_search_path $func_stripname_result"
5671             ;;
5672           prog)
5673             if test "$pass" = conv; then
5674               deplibs="$deplib $deplibs"
5675               continue
5676             fi
5677             if test "$pass" = scan; then
5678               deplibs="$deplib $deplibs"
5679             else
5680               compile_deplibs="$deplib $compile_deplibs"
5681               finalize_deplibs="$deplib $finalize_deplibs"
5682             fi
5683             func_stripname '-L' '' "$deplib"
5684             newlib_search_path="$newlib_search_path $func_stripname_result"
5685             ;;
5686           *)
5687             func_warning "\`-L' is ignored for archives/objects"
5688             ;;
5689           esac # linkmode
5690           continue
5691           ;; # -L
5692         -R*)
5693           if test "$pass" = link; then
5694             func_stripname '-R' '' "$deplib"
5695             dir=$func_stripname_result
5696             # Make sure the xrpath contains only unique directories.
5697             case "$xrpath " in
5698             *" $dir "*) ;;
5699             *) xrpath="$xrpath $dir" ;;
5700             esac
5701           fi
5702           deplibs="$deplib $deplibs"
5703           continue
5704           ;;
5705         *.la) lib="$deplib" ;;
5706         *.$libext)
5707           if test "$pass" = conv; then
5708             deplibs="$deplib $deplibs"
5709             continue
5710           fi
5711           case $linkmode in
5712           lib)
5713             # Linking convenience modules into shared libraries is allowed,
5714             # but linking other static libraries is non-portable.
5715             case " $dlpreconveniencelibs " in
5716             *" $deplib "*) ;;
5717             *)
5718               valid_a_lib=no
5719               case $deplibs_check_method in
5720                 match_pattern*)
5721                   set dummy $deplibs_check_method; shift
5722                   match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
5723                   if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \
5724                     | $EGREP "$match_pattern_regex" > /dev/null; then
5725                     valid_a_lib=yes
5726                   fi
5727                 ;;
5728                 pass_all)
5729                   valid_a_lib=yes
5730                 ;;
5731               esac
5732               if test "$valid_a_lib" != yes; then
5733                 $ECHO
5734                 $ECHO "*** Warning: Trying to link with static lib archive $deplib."
5735                 $ECHO "*** I have the capability to make that library automatically link in when"
5736                 $ECHO "*** you link to this library.  But I can only do this if you have a"
5737                 $ECHO "*** shared version of the library, which you do not appear to have"
5738                 $ECHO "*** because the file extensions .$libext of this argument makes me believe"
5739                 $ECHO "*** that it is just a static archive that I should not use here."
5740               else
5741                 $ECHO
5742                 $ECHO "*** Warning: Linking the shared library $output against the"
5743                 $ECHO "*** static library $deplib is not portable!"
5744                 deplibs="$deplib $deplibs"
5745               fi
5746               ;;
5747             esac
5748             continue
5749             ;;
5750           prog)
5751             if test "$pass" != link; then
5752               deplibs="$deplib $deplibs"
5753             else
5754               compile_deplibs="$deplib $compile_deplibs"
5755               finalize_deplibs="$deplib $finalize_deplibs"
5756             fi
5757             continue
5758             ;;
5759           esac # linkmode
5760           ;; # *.$libext
5761         *.lo | *.$objext)
5762           if test "$pass" = conv; then
5763             deplibs="$deplib $deplibs"
5764           elif test "$linkmode" = prog; then
5765             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
5766               # If there is no dlopen support or we're linking statically,
5767               # we need to preload.
5768               newdlprefiles="$newdlprefiles $deplib"
5769               compile_deplibs="$deplib $compile_deplibs"
5770               finalize_deplibs="$deplib $finalize_deplibs"
5771             else
5772               newdlfiles="$newdlfiles $deplib"
5773             fi
5774           fi
5775           continue
5776           ;;
5777         %DEPLIBS%)
5778           alldeplibs=yes
5779           continue
5780           ;;
5781         esac # case $deplib
5782
5783         if test "$found" = yes || test -f "$lib"; then :
5784         else
5785           func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
5786         fi
5787
5788         # Check to see that this really is a libtool archive.
5789         func_lalib_unsafe_p "$lib" \
5790           || func_fatal_error "\`$lib' is not a valid libtool archive"
5791
5792         func_dirname "$lib" "" "."
5793         ladir="$func_dirname_result"
5794
5795         dlname=
5796         dlopen=
5797         dlpreopen=
5798         libdir=
5799         library_names=
5800         old_library=
5801         inherited_linker_flags=
5802         # If the library was installed with an old release of libtool,
5803         # it will not redefine variables installed, or shouldnotlink
5804         installed=yes
5805         shouldnotlink=no
5806         avoidtemprpath=
5807
5808
5809         # Read the .la file
5810         func_source "$lib"
5811
5812         # Convert "-framework foo" to "foo.ltframework"
5813         if test -n "$inherited_linker_flags"; then
5814           tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`
5815           for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
5816             case " $new_inherited_linker_flags " in
5817               *" $tmp_inherited_linker_flag "*) ;;
5818               *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;
5819             esac
5820           done
5821         fi
5822         dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
5823         if test "$linkmode,$pass" = "lib,link" ||
5824            test "$linkmode,$pass" = "prog,scan" ||
5825            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
5826           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
5827           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
5828         fi
5829
5830         if test "$pass" = conv; then
5831           # Only check for convenience libraries
5832           deplibs="$lib $deplibs"
5833           if test -z "$libdir"; then
5834             if test -z "$old_library"; then
5835               func_fatal_error "cannot find name of link library for \`$lib'"
5836             fi
5837             # It is a libtool convenience library, so add in its objects.
5838             convenience="$convenience $ladir/$objdir/$old_library"
5839             old_convenience="$old_convenience $ladir/$objdir/$old_library"
5840           elif test "$linkmode" != prog && test "$linkmode" != lib; then
5841             func_fatal_error "\`$lib' is not a convenience library"
5842           fi
5843           tmp_libs=
5844           for deplib in $dependency_libs; do
5845             deplibs="$deplib $deplibs"
5846             if $opt_duplicate_deps ; then
5847               case "$tmp_libs " in
5848               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5849               esac
5850             fi
5851             tmp_libs="$tmp_libs $deplib"
5852           done
5853           continue
5854         fi # $pass = conv
5855
5856
5857         # Get the name of the library we link against.
5858         linklib=
5859         for l in $old_library $library_names; do
5860           linklib="$l"
5861         done
5862         if test -z "$linklib"; then
5863           func_fatal_error "cannot find name of link library for \`$lib'"
5864         fi
5865
5866         # This library was specified with -dlopen.
5867         if test "$pass" = dlopen; then
5868           if test -z "$libdir"; then
5869             func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
5870           fi
5871           if test -z "$dlname" ||
5872              test "$dlopen_support" != yes ||
5873              test "$build_libtool_libs" = no; then
5874             # If there is no dlname, no dlopen support or we're linking
5875             # statically, we need to preload.  We also need to preload any
5876             # dependent libraries so libltdl's deplib preloader doesn't
5877             # bomb out in the load deplibs phase.
5878             dlprefiles="$dlprefiles $lib $dependency_libs"
5879           else
5880             newdlfiles="$newdlfiles $lib"
5881           fi
5882           continue
5883         fi # $pass = dlopen
5884
5885         # We need an absolute path.
5886         case $ladir in
5887         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
5888         *)
5889           abs_ladir=`cd "$ladir" && pwd`
5890           if test -z "$abs_ladir"; then
5891             func_warning "cannot determine absolute directory name of \`$ladir'"
5892             func_warning "passing it literally to the linker, although it might fail"
5893             abs_ladir="$ladir"
5894           fi
5895           ;;
5896         esac
5897         func_basename "$lib"
5898         laname="$func_basename_result"
5899
5900         # Find the relevant object directory and library name.
5901         if test "X$installed" = Xyes; then
5902           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5903             func_warning "library \`$lib' was moved."
5904             dir="$ladir"
5905             absdir="$abs_ladir"
5906             libdir="$abs_ladir"
5907           else
5908             dir="$libdir"
5909             absdir="$libdir"
5910           fi
5911           test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
5912         else
5913           if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
5914             dir="$ladir"
5915             absdir="$abs_ladir"
5916             # Remove this search path later
5917             notinst_path="$notinst_path $abs_ladir"
5918           else
5919             dir="$ladir/$objdir"
5920             absdir="$abs_ladir/$objdir"
5921             # Remove this search path later
5922             notinst_path="$notinst_path $abs_ladir"
5923           fi
5924         fi # $installed = yes
5925         func_stripname 'lib' '.la' "$laname"
5926         name=$func_stripname_result
5927
5928         # This library was specified with -dlpreopen.
5929         if test "$pass" = dlpreopen; then
5930           if test -z "$libdir" && test "$linkmode" = prog; then
5931             func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
5932           fi
5933           # Prefer using a static library (so that no silly _DYNAMIC symbols
5934           # are required to link).
5935           if test -n "$old_library"; then
5936             newdlprefiles="$newdlprefiles $dir/$old_library"
5937             # Keep a list of preopened convenience libraries to check
5938             # that they are being used correctly in the link pass.
5939             test -z "$libdir" && \
5940                 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"
5941           # Otherwise, use the dlname, so that lt_dlopen finds it.
5942           elif test -n "$dlname"; then
5943             newdlprefiles="$newdlprefiles $dir/$dlname"
5944           else
5945             newdlprefiles="$newdlprefiles $dir/$linklib"
5946           fi
5947         fi # $pass = dlpreopen
5948
5949         if test -z "$libdir"; then
5950           # Link the convenience library
5951           if test "$linkmode" = lib; then
5952             deplibs="$dir/$old_library $deplibs"
5953           elif test "$linkmode,$pass" = "prog,link"; then
5954             compile_deplibs="$dir/$old_library $compile_deplibs"
5955             finalize_deplibs="$dir/$old_library $finalize_deplibs"
5956           else
5957             deplibs="$lib $deplibs" # used for prog,scan pass
5958           fi
5959           continue
5960         fi
5961
5962
5963         if test "$linkmode" = prog && test "$pass" != link; then
5964           newlib_search_path="$newlib_search_path $ladir"
5965           deplibs="$lib $deplibs"
5966
5967           linkalldeplibs=no
5968           if test "$link_all_deplibs" != no || test -z "$library_names" ||
5969              test "$build_libtool_libs" = no; then
5970             linkalldeplibs=yes
5971           fi
5972
5973           tmp_libs=
5974           for deplib in $dependency_libs; do
5975             case $deplib in
5976             -L*) func_stripname '-L' '' "$deplib"
5977                  newlib_search_path="$newlib_search_path $func_stripname_result"
5978                  ;;
5979             esac
5980             # Need to link against all dependency_libs?
5981             if test "$linkalldeplibs" = yes; then
5982               deplibs="$deplib $deplibs"
5983             else
5984               # Need to hardcode shared library paths
5985               # or/and link against static libraries
5986               newdependency_libs="$deplib $newdependency_libs"
5987             fi
5988             if $opt_duplicate_deps ; then
5989               case "$tmp_libs " in
5990               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
5991               esac
5992             fi
5993             tmp_libs="$tmp_libs $deplib"
5994           done # for deplib
5995           continue
5996         fi # $linkmode = prog...
5997
5998         if test "$linkmode,$pass" = "prog,link"; then
5999           if test -n "$library_names" &&
6000              { { test "$prefer_static_libs" = no ||
6001                  test "$prefer_static_libs,$installed" = "built,yes"; } ||
6002                test -z "$old_library"; }; then
6003             # We need to hardcode the library path
6004             if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
6005               # Make sure the rpath contains only unique directories.
6006               case "$temp_rpath:" in
6007               *"$absdir:"*) ;;
6008               *) temp_rpath="$temp_rpath$absdir:" ;;
6009               esac
6010             fi
6011
6012             # Hardcode the library path.
6013             # Skip directories that are in the system default run-time
6014             # search path.
6015             case " $sys_lib_dlsearch_path " in
6016             *" $absdir "*) ;;
6017             *)
6018               case "$compile_rpath " in
6019               *" $absdir "*) ;;
6020               *) compile_rpath="$compile_rpath $absdir"
6021               esac
6022               ;;
6023             esac
6024             case " $sys_lib_dlsearch_path " in
6025             *" $libdir "*) ;;
6026             *)
6027               case "$finalize_rpath " in
6028               *" $libdir "*) ;;
6029               *) finalize_rpath="$finalize_rpath $libdir"
6030               esac
6031               ;;
6032             esac
6033           fi # $linkmode,$pass = prog,link...
6034
6035           if test "$alldeplibs" = yes &&
6036              { test "$deplibs_check_method" = pass_all ||
6037                { test "$build_libtool_libs" = yes &&
6038                  test -n "$library_names"; }; }; then
6039             # We only need to search for static libraries
6040             continue
6041           fi
6042         fi
6043
6044         link_static=no # Whether the deplib will be linked statically
6045         use_static_libs=$prefer_static_libs
6046         if test "$use_static_libs" = built && test "$installed" = yes; then
6047           use_static_libs=no
6048         fi
6049         if test -n "$library_names" &&
6050            { test "$use_static_libs" = no || test -z "$old_library"; }; then
6051           case $host in
6052           *cygwin* | *mingw* | *cegcc*)
6053               # No point in relinking DLLs because paths are not encoded
6054               notinst_deplibs="$notinst_deplibs $lib"
6055               need_relink=no
6056             ;;
6057           *)
6058             if test "$installed" = no; then
6059               notinst_deplibs="$notinst_deplibs $lib"
6060               need_relink=yes
6061             fi
6062             ;;
6063           esac
6064           # This is a shared library
6065
6066           # Warn about portability, can't link against -module's on some
6067           # systems (darwin).  Don't bleat about dlopened modules though!
6068           dlopenmodule=""
6069           for dlpremoduletest in $dlprefiles; do
6070             if test "X$dlpremoduletest" = "X$lib"; then
6071               dlopenmodule="$dlpremoduletest"
6072               break
6073             fi
6074           done
6075           if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
6076             $ECHO
6077             if test "$linkmode" = prog; then
6078               $ECHO "*** Warning: Linking the executable $output against the loadable module"
6079             else
6080               $ECHO "*** Warning: Linking the shared library $output against the loadable module"
6081             fi
6082             $ECHO "*** $linklib is not portable!"
6083           fi
6084           if test "$linkmode" = lib &&
6085              test "$hardcode_into_libs" = yes; then
6086             # Hardcode the library path.
6087             # Skip directories that are in the system default run-time
6088             # search path.
6089             case " $sys_lib_dlsearch_path " in
6090             *" $absdir "*) ;;
6091             *)
6092               case "$compile_rpath " in
6093               *" $absdir "*) ;;
6094               *) compile_rpath="$compile_rpath $absdir"
6095               esac
6096               ;;
6097             esac
6098             case " $sys_lib_dlsearch_path " in
6099             *" $libdir "*) ;;
6100             *)
6101               case "$finalize_rpath " in
6102               *" $libdir "*) ;;
6103               *) finalize_rpath="$finalize_rpath $libdir"
6104               esac
6105               ;;
6106             esac
6107           fi
6108
6109           if test -n "$old_archive_from_expsyms_cmds"; then
6110             # figure out the soname
6111             set dummy $library_names
6112             shift
6113             realname="$1"
6114             shift
6115             libname=`eval "\\$ECHO \"$libname_spec\""`
6116             # use dlname if we got it. it's perfectly good, no?
6117             if test -n "$dlname"; then
6118               soname="$dlname"
6119             elif test -n "$soname_spec"; then
6120               # bleh windows
6121               case $host in
6122               *cygwin* | mingw* | *cegcc*)
6123                 func_arith $current - $age
6124                 major=$func_arith_result
6125                 versuffix="-$major"
6126                 ;;
6127               esac
6128               eval soname=\"$soname_spec\"
6129             else
6130               soname="$realname"
6131             fi
6132
6133             # Make a new name for the extract_expsyms_cmds to use
6134             soroot="$soname"
6135             func_basename "$soroot"
6136             soname="$func_basename_result"
6137             func_stripname 'lib' '.dll' "$soname"
6138             newlib=libimp-$func_stripname_result.a
6139
6140             # If the library has no export list, then create one now
6141             if test -f "$output_objdir/$soname-def"; then :
6142             else
6143               func_verbose "extracting exported symbol list from \`$soname'"
6144               func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
6145             fi
6146
6147             # Create $newlib
6148             if test -f "$output_objdir/$newlib"; then :; else
6149               func_verbose "generating import library for \`$soname'"
6150               func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
6151             fi
6152             # make sure the library variables are pointing to the new library
6153             dir=$output_objdir
6154             linklib=$newlib
6155           fi # test -n "$old_archive_from_expsyms_cmds"
6156
6157           if test "$linkmode" = prog || test "$mode" != relink; then
6158             add_shlibpath=
6159             add_dir=
6160             add=
6161             lib_linked=yes
6162             case $hardcode_action in
6163             immediate | unsupported)
6164               if test "$hardcode_direct" = no; then
6165                 add="$dir/$linklib"
6166                 case $host in
6167                   *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
6168                   *-*-sysv4*uw2*) add_dir="-L$dir" ;;
6169                   *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
6170                     *-*-unixware7*) add_dir="-L$dir" ;;
6171                   *-*-darwin* )
6172                     # if the lib is a (non-dlopened) module then we can not
6173                     # link against it, someone is ignoring the earlier warnings
6174                     if /usr/bin/file -L $add 2> /dev/null |
6175                          $GREP ": [^:]* bundle" >/dev/null ; then
6176                       if test "X$dlopenmodule" != "X$lib"; then
6177                         $ECHO "*** Warning: lib $linklib is a module, not a shared library"
6178                         if test -z "$old_library" ; then
6179                           $ECHO
6180                           $ECHO "*** And there doesn't seem to be a static archive available"
6181                           $ECHO "*** The link will probably fail, sorry"
6182                         else
6183                           add="$dir/$old_library"
6184                         fi
6185                       elif test -n "$old_library"; then
6186                         add="$dir/$old_library"
6187                       fi
6188                     fi
6189                 esac
6190               elif test "$hardcode_minus_L" = no; then
6191                 case $host in
6192                 *-*-sunos*) add_shlibpath="$dir" ;;
6193                 esac
6194                 add_dir="-L$dir"
6195                 add="-l$name"
6196               elif test "$hardcode_shlibpath_var" = no; then
6197                 add_shlibpath="$dir"
6198                 add="-l$name"
6199               else
6200                 lib_linked=no
6201               fi
6202               ;;
6203             relink)
6204               if test "$hardcode_direct" = yes &&
6205                  test "$hardcode_direct_absolute" = no; then
6206                 add="$dir/$linklib"
6207               elif test "$hardcode_minus_L" = yes; then
6208                 add_dir="-L$dir"
6209                 # Try looking first in the location we're being installed to.
6210                 if test -n "$inst_prefix_dir"; then
6211                   case $libdir in
6212                     [\\/]*)
6213                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
6214                       ;;
6215                   esac
6216                 fi
6217                 add="-l$name"
6218               elif test "$hardcode_shlibpath_var" = yes; then
6219                 add_shlibpath="$dir"
6220                 add="-l$name"
6221               else
6222                 lib_linked=no
6223               fi
6224               ;;
6225             *) lib_linked=no ;;
6226             esac
6227
6228             if test "$lib_linked" != yes; then
6229               func_fatal_configuration "unsupported hardcode properties"
6230             fi
6231
6232             if test -n "$add_shlibpath"; then
6233               case :$compile_shlibpath: in
6234               *":$add_shlibpath:"*) ;;
6235               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
6236               esac
6237             fi
6238             if test "$linkmode" = prog; then
6239               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
6240               test -n "$add" && compile_deplibs="$add $compile_deplibs"
6241             else
6242               test -n "$add_dir" && deplibs="$add_dir $deplibs"
6243               test -n "$add" && deplibs="$add $deplibs"
6244               if test "$hardcode_direct" != yes &&
6245                  test "$hardcode_minus_L" != yes &&
6246                  test "$hardcode_shlibpath_var" = yes; then
6247                 case :$finalize_shlibpath: in
6248                 *":$libdir:"*) ;;
6249                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6250                 esac
6251               fi
6252             fi
6253           fi
6254
6255           if test "$linkmode" = prog || test "$mode" = relink; then
6256             add_shlibpath=
6257             add_dir=
6258             add=
6259             # Finalize command for both is simple: just hardcode it.
6260             if test "$hardcode_direct" = yes &&
6261                test "$hardcode_direct_absolute" = no; then
6262               add="$libdir/$linklib"
6263             elif test "$hardcode_minus_L" = yes; then
6264               add_dir="-L$libdir"
6265               add="-l$name"
6266             elif test "$hardcode_shlibpath_var" = yes; then
6267               case :$finalize_shlibpath: in
6268               *":$libdir:"*) ;;
6269               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
6270               esac
6271               add="-l$name"
6272             elif test "$hardcode_automatic" = yes; then
6273               if test -n "$inst_prefix_dir" &&
6274                  test -f "$inst_prefix_dir$libdir/$linklib" ; then
6275                 add="$inst_prefix_dir$libdir/$linklib"
6276               else
6277                 add="$libdir/$linklib"
6278               fi
6279             else
6280               # We cannot seem to hardcode it, guess we'll fake it.
6281               add_dir="-L$libdir"
6282               # Try looking first in the location we're being installed to.
6283               if test -n "$inst_prefix_dir"; then
6284                 case $libdir in
6285                   [\\/]*)
6286                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
6287                     ;;
6288                 esac
6289               fi
6290               add="-l$name"
6291             fi
6292
6293             if test "$linkmode" = prog; then
6294               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
6295               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
6296             else
6297               test -n "$add_dir" && deplibs="$add_dir $deplibs"
6298               test -n "$add" && deplibs="$add $deplibs"
6299             fi
6300           fi
6301         elif test "$linkmode" = prog; then
6302           # Here we assume that one of hardcode_direct or hardcode_minus_L
6303           # is not unsupported.  This is valid on all known static and
6304           # shared platforms.
6305           if test "$hardcode_direct" != unsupported; then
6306             test -n "$old_library" && linklib="$old_library"
6307             compile_deplibs="$dir/$linklib $compile_deplibs"
6308             finalize_deplibs="$dir/$linklib $finalize_deplibs"
6309           else
6310             compile_deplibs="-l$name -L$dir $compile_deplibs"
6311             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
6312           fi
6313         elif test "$build_libtool_libs" = yes; then
6314           # Not a shared library
6315           if test "$deplibs_check_method" != pass_all; then
6316             # We're trying link a shared library against a static one
6317             # but the system doesn't support it.
6318
6319             # Just print a warning and add the library to dependency_libs so
6320             # that the program can be linked against the static library.
6321             $ECHO
6322             $ECHO "*** Warning: This system can not link to static lib archive $lib."
6323             $ECHO "*** I have the capability to make that library automatically link in when"
6324             $ECHO "*** you link to this library.  But I can only do this if you have a"
6325             $ECHO "*** shared version of the library, which you do not appear to have."
6326             if test "$module" = yes; then
6327               $ECHO "*** But as you try to build a module library, libtool will still create "
6328               $ECHO "*** a static module, that should work as long as the dlopening application"
6329               $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."
6330               if test -z "$global_symbol_pipe"; then
6331                 $ECHO
6332                 $ECHO "*** However, this would only work if libtool was able to extract symbol"
6333                 $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
6334                 $ECHO "*** not find such a program.  So, this module is probably useless."
6335                 $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
6336               fi
6337               if test "$build_old_libs" = no; then
6338                 build_libtool_libs=module
6339                 build_old_libs=yes
6340               else
6341                 build_libtool_libs=no
6342               fi
6343             fi
6344           else
6345             deplibs="$dir/$old_library $deplibs"
6346             link_static=yes
6347           fi
6348         fi # link shared/static library?
6349
6350         if test "$linkmode" = lib; then
6351           if test -n "$dependency_libs" &&
6352              { test "$hardcode_into_libs" != yes ||
6353                test "$build_old_libs" = yes ||
6354                test "$link_static" = yes; }; then
6355             # Extract -R from dependency_libs
6356             temp_deplibs=
6357             for libdir in $dependency_libs; do
6358               case $libdir in
6359               -R*) func_stripname '-R' '' "$libdir"
6360                    temp_xrpath=$func_stripname_result
6361                    case " $xrpath " in
6362                    *" $temp_xrpath "*) ;;
6363                    *) xrpath="$xrpath $temp_xrpath";;
6364                    esac;;
6365               *) temp_deplibs="$temp_deplibs $libdir";;
6366               esac
6367             done
6368             dependency_libs="$temp_deplibs"
6369           fi
6370
6371           newlib_search_path="$newlib_search_path $absdir"
6372           # Link against this library
6373           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
6374           # ... and its dependency_libs
6375           tmp_libs=
6376           for deplib in $dependency_libs; do
6377             newdependency_libs="$deplib $newdependency_libs"
6378             if $opt_duplicate_deps ; then
6379               case "$tmp_libs " in
6380               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
6381               esac
6382             fi
6383             tmp_libs="$tmp_libs $deplib"
6384           done
6385
6386           if test "$link_all_deplibs" != no; then
6387             # Add the search paths of all dependency libraries
6388             for deplib in $dependency_libs; do
6389               case $deplib in
6390               -L*) path="$deplib" ;;
6391               *.la)
6392                 func_dirname "$deplib" "" "."
6393                 dir="$func_dirname_result"
6394                 # We need an absolute path.
6395                 case $dir in
6396                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
6397                 *)
6398                   absdir=`cd "$dir" && pwd`
6399                   if test -z "$absdir"; then
6400                     func_warning "cannot determine absolute directory name of \`$dir'"
6401                     absdir="$dir"
6402                   fi
6403                   ;;
6404                 esac
6405                 if $GREP "^installed=no" $deplib > /dev/null; then
6406                 case $host in
6407                 *-*-darwin*)
6408                   depdepl=
6409                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
6410                   if test -n "$deplibrary_names" ; then
6411                     for tmp in $deplibrary_names ; do
6412                       depdepl=$tmp
6413                     done
6414                     if test -f "$absdir/$objdir/$depdepl" ; then
6415                       depdepl="$absdir/$objdir/$depdepl"
6416                       darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
6417                       if test -z "$darwin_install_name"; then
6418                           darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
6419                       fi
6420                       compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
6421                       linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"
6422                       path=
6423                     fi
6424                   fi
6425                   ;;
6426                 *)
6427                   path="-L$absdir/$objdir"
6428                   ;;
6429                 esac
6430                 else
6431                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
6432                   test -z "$libdir" && \
6433                     func_fatal_error "\`$deplib' is not a valid libtool archive"
6434                   test "$absdir" != "$libdir" && \
6435                     func_warning "\`$deplib' seems to be moved"
6436
6437                   path="-L$absdir"
6438                 fi
6439                 ;;
6440               esac
6441               case " $deplibs " in
6442               *" $path "*) ;;
6443               *) deplibs="$path $deplibs" ;;
6444               esac
6445             done
6446           fi # link_all_deplibs != no
6447         fi # linkmode = lib
6448       done # for deplib in $libs
6449       if test "$pass" = link; then
6450         if test "$linkmode" = "prog"; then
6451           compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
6452           finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
6453         else
6454           compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
6455         fi
6456       fi
6457       dependency_libs="$newdependency_libs"
6458       if test "$pass" = dlpreopen; then
6459         # Link the dlpreopened libraries before other libraries
6460         for deplib in $save_deplibs; do
6461           deplibs="$deplib $deplibs"
6462         done
6463       fi
6464       if test "$pass" != dlopen; then
6465         if test "$pass" != conv; then
6466           # Make sure lib_search_path contains only unique directories.
6467           lib_search_path=
6468           for dir in $newlib_search_path; do
6469             case "$lib_search_path " in
6470             *" $dir "*) ;;
6471             *) lib_search_path="$lib_search_path $dir" ;;
6472             esac
6473           done
6474           newlib_search_path=
6475         fi
6476
6477         if test "$linkmode,$pass" != "prog,link"; then
6478           vars="deplibs"
6479         else
6480           vars="compile_deplibs finalize_deplibs"
6481         fi
6482         for var in $vars dependency_libs; do
6483           # Add libraries to $var in reverse order
6484           eval tmp_libs=\"\$$var\"
6485           new_libs=
6486           for deplib in $tmp_libs; do
6487             # FIXME: Pedantically, this is the right thing to do, so
6488             #        that some nasty dependency loop isn't accidentally
6489             #        broken:
6490             #new_libs="$deplib $new_libs"
6491             # Pragmatically, this seems to cause very few problems in
6492             # practice:
6493             case $deplib in
6494             -L*) new_libs="$deplib $new_libs" ;;
6495             -R*) ;;
6496             *)
6497               # And here is the reason: when a library appears more
6498               # than once as an explicit dependence of a library, or
6499               # is implicitly linked in more than once by the
6500               # compiler, it is considered special, and multiple
6501               # occurrences thereof are not removed.  Compare this
6502               # with having the same library being listed as a
6503               # dependency of multiple other libraries: in this case,
6504               # we know (pedantically, we assume) the library does not
6505               # need to be listed more than once, so we keep only the
6506               # last copy.  This is not always right, but it is rare
6507               # enough that we require users that really mean to play
6508               # such unportable linking tricks to link the library
6509               # using -Wl,-lname, so that libtool does not consider it
6510               # for duplicate removal.
6511               case " $specialdeplibs " in
6512               *" $deplib "*) new_libs="$deplib $new_libs" ;;
6513               *)
6514                 case " $new_libs " in
6515                 *" $deplib "*) ;;
6516                 *) new_libs="$deplib $new_libs" ;;
6517                 esac
6518                 ;;
6519               esac
6520               ;;
6521             esac
6522           done
6523           tmp_libs=
6524           for deplib in $new_libs; do
6525             case $deplib in
6526             -L*)
6527               case " $tmp_libs " in
6528               *" $deplib "*) ;;
6529               *) tmp_libs="$tmp_libs $deplib" ;;
6530               esac
6531               ;;
6532             *) tmp_libs="$tmp_libs $deplib" ;;
6533             esac
6534           done
6535           eval $var=\"$tmp_libs\"
6536         done # for var
6537       fi
6538       # Last step: remove runtime libs from dependency_libs
6539       # (they stay in deplibs)
6540       tmp_libs=
6541       for i in $dependency_libs ; do
6542         case " $predeps $postdeps $compiler_lib_search_path " in
6543         *" $i "*)
6544           i=""
6545           ;;
6546         esac
6547         if test -n "$i" ; then
6548           tmp_libs="$tmp_libs $i"
6549         fi
6550       done
6551       dependency_libs=$tmp_libs
6552     done # for pass
6553     if test "$linkmode" = prog; then
6554       dlfiles="$newdlfiles"
6555     fi
6556     if test "$linkmode" = prog || test "$linkmode" = lib; then
6557       dlprefiles="$newdlprefiles"
6558     fi
6559
6560     case $linkmode in
6561     oldlib)
6562       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
6563         func_warning "\`-dlopen' is ignored for archives"
6564       fi
6565
6566       case " $deplibs" in
6567       *\ -l* | *\ -L*)
6568         func_warning "\`-l' and \`-L' are ignored for archives" ;;
6569       esac
6570
6571       test -n "$rpath" && \
6572         func_warning "\`-rpath' is ignored for archives"
6573
6574       test -n "$xrpath" && \
6575         func_warning "\`-R' is ignored for archives"
6576
6577       test -n "$vinfo" && \
6578         func_warning "\`-version-info/-version-number' is ignored for archives"
6579
6580       test -n "$release" && \
6581         func_warning "\`-release' is ignored for archives"
6582
6583       test -n "$export_symbols$export_symbols_regex" && \
6584         func_warning "\`-export-symbols' is ignored for archives"
6585
6586       # Now set the variables for building old libraries.
6587       build_libtool_libs=no
6588       oldlibs="$output"
6589       objs="$objs$old_deplibs"
6590       ;;
6591
6592     lib)
6593       # Make sure we only generate libraries of the form `libNAME.la'.
6594       case $outputname in
6595       lib*)
6596         func_stripname 'lib' '.la' "$outputname"
6597         name=$func_stripname_result
6598         eval shared_ext=\"$shrext_cmds\"
6599         eval libname=\"$libname_spec\"
6600         ;;
6601       *)
6602         test "$module" = no && \
6603           func_fatal_help "libtool library \`$output' must begin with \`lib'"
6604
6605         if test "$need_lib_prefix" != no; then
6606           # Add the "lib" prefix for modules if required
6607           func_stripname '' '.la' "$outputname"
6608           name=$func_stripname_result
6609           eval shared_ext=\"$shrext_cmds\"
6610           eval libname=\"$libname_spec\"
6611         else
6612           func_stripname '' '.la' "$outputname"
6613           libname=$func_stripname_result
6614         fi
6615         ;;
6616       esac
6617
6618       if test -n "$objs"; then
6619         if test "$deplibs_check_method" != pass_all; then
6620           func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
6621         else
6622           $ECHO
6623           $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
6624           $ECHO "*** objects $objs is not portable!"
6625           libobjs="$libobjs $objs"
6626         fi
6627       fi
6628
6629       test "$dlself" != no && \
6630         func_warning "\`-dlopen self' is ignored for libtool libraries"
6631
6632       set dummy $rpath
6633       shift
6634       test "$#" -gt 1 && \
6635         func_warning "ignoring multiple \`-rpath's for a libtool library"
6636
6637       install_libdir="$1"
6638
6639       oldlibs=
6640       if test -z "$rpath"; then
6641         if test "$build_libtool_libs" = yes; then
6642           # Building a libtool convenience library.
6643           # Some compilers have problems with a `.al' extension so
6644           # convenience libraries should have the same extension an
6645           # archive normally would.
6646           oldlibs="$output_objdir/$libname.$libext $oldlibs"
6647           build_libtool_libs=convenience
6648           build_old_libs=yes
6649         fi
6650
6651         test -n "$vinfo" && \
6652           func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
6653
6654         test -n "$release" && \
6655           func_warning "\`-release' is ignored for convenience libraries"
6656       else
6657
6658         # Parse the version information argument.
6659         save_ifs="$IFS"; IFS=':'
6660         set dummy $vinfo 0 0 0
6661         shift
6662         IFS="$save_ifs"
6663
6664         test -n "$7" && \
6665           func_fatal_help "too many parameters to \`-version-info'"
6666
6667         # convert absolute version numbers to libtool ages
6668         # this retains compatibility with .la files and attempts
6669         # to make the code below a bit more comprehensible
6670
6671         case $vinfo_number in
6672         yes)
6673           number_major="$1"
6674           number_minor="$2"
6675           number_revision="$3"
6676           #
6677           # There are really only two kinds -- those that
6678           # use the current revision as the major version
6679           # and those that subtract age and use age as
6680           # a minor version.  But, then there is irix
6681           # which has an extra 1 added just for fun
6682           #
6683           case $version_type in
6684           darwin|linux|osf|windows|none)
6685             func_arith $number_major + $number_minor
6686             current=$func_arith_result
6687             age="$number_minor"
6688             revision="$number_revision"
6689             ;;
6690           freebsd-aout|freebsd-elf|sunos)
6691             current="$number_major"
6692             revision="$number_minor"
6693             age="0"
6694             ;;
6695           irix|nonstopux)
6696             func_arith $number_major + $number_minor
6697             current=$func_arith_result
6698             age="$number_minor"
6699             revision="$number_minor"
6700             lt_irix_increment=no
6701             ;;
6702           esac
6703           ;;
6704         no)
6705           current="$1"
6706           revision="$2"
6707           age="$3"
6708           ;;
6709         esac
6710
6711         # Check that each of the things are valid numbers.
6712         case $current in
6713         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]) ;;
6714         *)
6715           func_error "CURRENT \`$current' must be a nonnegative integer"
6716           func_fatal_error "\`$vinfo' is not valid version information"
6717           ;;
6718         esac
6719
6720         case $revision in
6721         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]) ;;
6722         *)
6723           func_error "REVISION \`$revision' must be a nonnegative integer"
6724           func_fatal_error "\`$vinfo' is not valid version information"
6725           ;;
6726         esac
6727
6728         case $age in
6729         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]) ;;
6730         *)
6731           func_error "AGE \`$age' must be a nonnegative integer"
6732           func_fatal_error "\`$vinfo' is not valid version information"
6733           ;;
6734         esac
6735
6736         if test "$age" -gt "$current"; then
6737           func_error "AGE \`$age' is greater than the current interface number \`$current'"
6738           func_fatal_error "\`$vinfo' is not valid version information"
6739         fi
6740
6741         # Calculate the version variables.
6742         major=
6743         versuffix=
6744         verstring=
6745         case $version_type in
6746         none) ;;
6747
6748         darwin)
6749           # Like Linux, but with the current version available in
6750           # verstring for coding it into the library header
6751           func_arith $current - $age
6752           major=.$func_arith_result
6753           versuffix="$major.$age.$revision"
6754           # Darwin ld doesn't like 0 for these options...
6755           func_arith $current + 1
6756           minor_current=$func_arith_result
6757           xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
6758           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
6759           ;;
6760
6761         freebsd-aout)
6762           major=".$current"
6763           versuffix=".$current.$revision";
6764           ;;
6765
6766         freebsd-elf)
6767           major=".$current"
6768           versuffix=".$current"
6769           ;;
6770
6771         irix | nonstopux)
6772           if test "X$lt_irix_increment" = "Xno"; then
6773             func_arith $current - $age
6774           else
6775             func_arith $current - $age + 1
6776           fi
6777           major=$func_arith_result
6778
6779           case $version_type in
6780             nonstopux) verstring_prefix=nonstopux ;;
6781             *)         verstring_prefix=sgi ;;
6782           esac
6783           verstring="$verstring_prefix$major.$revision"
6784
6785           # Add in all the interfaces that we are compatible with.
6786           loop=$revision
6787           while test "$loop" -ne 0; do
6788             func_arith $revision - $loop
6789             iface=$func_arith_result
6790             func_arith $loop - 1
6791             loop=$func_arith_result
6792             verstring="$verstring_prefix$major.$iface:$verstring"
6793           done
6794
6795           # Before this point, $major must not contain `.'.
6796           major=.$major
6797           versuffix="$major.$revision"
6798           ;;
6799
6800         linux)
6801           func_arith $current - $age
6802           major=.$func_arith_result
6803           versuffix="$major.$age.$revision"
6804           ;;
6805
6806         osf)
6807           func_arith $current - $age
6808           major=.$func_arith_result
6809           versuffix=".$current.$age.$revision"
6810           verstring="$current.$age.$revision"
6811
6812           # Add in all the interfaces that we are compatible with.
6813           loop=$age
6814           while test "$loop" -ne 0; do
6815             func_arith $current - $loop
6816             iface=$func_arith_result
6817             func_arith $loop - 1
6818             loop=$func_arith_result
6819             verstring="$verstring:${iface}.0"
6820           done
6821
6822           # Make executables depend on our current version.
6823           verstring="$verstring:${current}.0"
6824           ;;
6825
6826         qnx)
6827           major=".$current"
6828           versuffix=".$current"
6829           ;;
6830
6831         sunos)
6832           major=".$current"
6833           versuffix=".$current.$revision"
6834           ;;
6835
6836         windows)
6837           # Use '-' rather than '.', since we only want one
6838           # extension on DOS 8.3 filesystems.
6839           func_arith $current - $age
6840           major=$func_arith_result
6841           versuffix="-$major"
6842           ;;
6843
6844         *)
6845           func_fatal_configuration "unknown library version type \`$version_type'"
6846           ;;
6847         esac
6848
6849         # Clear the version info if we defaulted, and they specified a release.
6850         if test -z "$vinfo" && test -n "$release"; then
6851           major=
6852           case $version_type in
6853           darwin)
6854             # we can't check for "0.0" in archive_cmds due to quoting
6855             # problems, so we reset it completely
6856             verstring=
6857             ;;
6858           *)
6859             verstring="0.0"
6860             ;;
6861           esac
6862           if test "$need_version" = no; then
6863             versuffix=
6864           else
6865             versuffix=".0.0"
6866           fi
6867         fi
6868
6869         # Remove version info from name if versioning should be avoided
6870         if test "$avoid_version" = yes && test "$need_version" = no; then
6871           major=
6872           versuffix=
6873           verstring=""
6874         fi
6875
6876         # Check to see if the archive will have undefined symbols.
6877         if test "$allow_undefined" = yes; then
6878           if test "$allow_undefined_flag" = unsupported; then
6879             func_warning "undefined symbols not allowed in $host shared libraries"
6880             build_libtool_libs=no
6881             build_old_libs=yes
6882           fi
6883         else
6884           # Don't allow undefined symbols.
6885           allow_undefined_flag="$no_undefined_flag"
6886         fi
6887
6888       fi
6889
6890       func_generate_dlsyms "$libname" "$libname" "yes"
6891       libobjs="$libobjs $symfileobj"
6892       test "X$libobjs" = "X " && libobjs=
6893
6894       if test "$mode" != relink; then
6895         # Remove our outputs, but don't remove object files since they
6896         # may have been created when compiling PIC objects.
6897         removelist=
6898         tempremovelist=`$ECHO "$output_objdir/*"`
6899         for p in $tempremovelist; do
6900           case $p in
6901             *.$objext | *.gcno)
6902                ;;
6903             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
6904                if test "X$precious_files_regex" != "X"; then
6905                  if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
6906                  then
6907                    continue
6908                  fi
6909                fi
6910                removelist="$removelist $p"
6911                ;;
6912             *) ;;
6913           esac
6914         done
6915         test -n "$removelist" && \
6916           func_show_eval "${RM}r \$removelist"
6917       fi
6918
6919       # Now set the variables for building old libraries.
6920       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
6921         oldlibs="$oldlibs $output_objdir/$libname.$libext"
6922
6923         # Transform .lo files to .o files.
6924         oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
6925       fi
6926
6927       # Eliminate all temporary directories.
6928       #for path in $notinst_path; do
6929       # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`
6930       # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`
6931       # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`
6932       #done
6933
6934       if test -n "$xrpath"; then
6935         # If the user specified any rpath flags, then add them.
6936         temp_xrpath=
6937         for libdir in $xrpath; do
6938           temp_xrpath="$temp_xrpath -R$libdir"
6939           case "$finalize_rpath " in
6940           *" $libdir "*) ;;
6941           *) finalize_rpath="$finalize_rpath $libdir" ;;
6942           esac
6943         done
6944         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
6945           dependency_libs="$temp_xrpath $dependency_libs"
6946         fi
6947       fi
6948
6949       # Make sure dlfiles contains only unique files that won't be dlpreopened
6950       old_dlfiles="$dlfiles"
6951       dlfiles=
6952       for lib in $old_dlfiles; do
6953         case " $dlprefiles $dlfiles " in
6954         *" $lib "*) ;;
6955         *) dlfiles="$dlfiles $lib" ;;
6956         esac
6957       done
6958
6959       # Make sure dlprefiles contains only unique files
6960       old_dlprefiles="$dlprefiles"
6961       dlprefiles=
6962       for lib in $old_dlprefiles; do
6963         case "$dlprefiles " in
6964         *" $lib "*) ;;
6965         *) dlprefiles="$dlprefiles $lib" ;;
6966         esac
6967       done
6968
6969       if test "$build_libtool_libs" = yes; then
6970         if test -n "$rpath"; then
6971           case $host in
6972           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)
6973             # these systems don't actually have a c library (as such)!
6974             ;;
6975           *-*-rhapsody* | *-*-darwin1.[012])
6976             # Rhapsody C library is in the System framework
6977             deplibs="$deplibs System.ltframework"
6978             ;;
6979           *-*-netbsd*)
6980             # Don't link with libc until the a.out ld.so is fixed.
6981             ;;
6982           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
6983             # Do not include libc due to us having libc/libc_r.
6984             ;;
6985           *-*-sco3.2v5* | *-*-sco5v6*)
6986             # Causes problems with __ctype
6987             ;;
6988           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
6989             # Compiler inserts libc in the correct place for threads to work
6990             ;;
6991           *)
6992             # Add libc to deplibs on all other systems if necessary.
6993             if test "$build_libtool_need_lc" = "yes"; then
6994               deplibs="$deplibs -lc"
6995             fi
6996             ;;
6997           esac
6998         fi
6999
7000         # Transform deplibs into only deplibs that can be linked in shared.
7001         name_save=$name
7002         libname_save=$libname
7003         release_save=$release
7004         versuffix_save=$versuffix
7005         major_save=$major
7006         # I'm not sure if I'm treating the release correctly.  I think
7007         # release should show up in the -l (ie -lgmp5) so we don't want to
7008         # add it in twice.  Is that correct?
7009         release=""
7010         versuffix=""
7011         major=""
7012         newdeplibs=
7013         droppeddeps=no
7014         case $deplibs_check_method in
7015         pass_all)
7016           # Don't check for shared/static.  Everything works.
7017           # This might be a little naive.  We might want to check
7018           # whether the library exists or not.  But this is on
7019           # osf3 & osf4 and I'm not really sure... Just
7020           # implementing what was already the behavior.
7021           newdeplibs=$deplibs
7022           ;;
7023         test_compile)
7024           # This code stresses the "libraries are programs" paradigm to its
7025           # limits. Maybe even breaks it.  We compile a program, linking it
7026           # against the deplibs as a proxy for the library.  Then we can check
7027           # whether they linked in statically or dynamically with ldd.
7028           $opt_dry_run || $RM conftest.c
7029           cat > conftest.c <<EOF
7030           int main() { return 0; }
7031 EOF
7032           $opt_dry_run || $RM conftest
7033           if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
7034             ldd_output=`ldd conftest`
7035             for i in $deplibs; do
7036               case $i in
7037               -l*)
7038                 func_stripname -l '' "$i"
7039                 name=$func_stripname_result
7040                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7041                   case " $predeps $postdeps " in
7042                   *" $i "*)
7043                     newdeplibs="$newdeplibs $i"
7044                     i=""
7045                     ;;
7046                   esac
7047                 fi
7048                 if test -n "$i" ; then
7049                   libname=`eval "\\$ECHO \"$libname_spec\""`
7050                   deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7051                   set dummy $deplib_matches; shift
7052                   deplib_match=$1
7053                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7054                     newdeplibs="$newdeplibs $i"
7055                   else
7056                     droppeddeps=yes
7057                     $ECHO
7058                     $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7059                     $ECHO "*** I have the capability to make that library automatically link in when"
7060                     $ECHO "*** you link to this library.  But I can only do this if you have a"
7061                     $ECHO "*** shared version of the library, which I believe you do not have"
7062                     $ECHO "*** because a test_compile did reveal that the linker did not use it for"
7063                     $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."
7064                   fi
7065                 fi
7066                 ;;
7067               *)
7068                 newdeplibs="$newdeplibs $i"
7069                 ;;
7070               esac
7071             done
7072           else
7073             # Error occurred in the first compile.  Let's try to salvage
7074             # the situation: Compile a separate program for each library.
7075             for i in $deplibs; do
7076               case $i in
7077               -l*)
7078                 func_stripname -l '' "$i"
7079                 name=$func_stripname_result
7080                 $opt_dry_run || $RM conftest
7081                 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
7082                   ldd_output=`ldd conftest`
7083                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7084                     case " $predeps $postdeps " in
7085                     *" $i "*)
7086                       newdeplibs="$newdeplibs $i"
7087                       i=""
7088                       ;;
7089                     esac
7090                   fi
7091                   if test -n "$i" ; then
7092                     libname=`eval "\\$ECHO \"$libname_spec\""`
7093                     deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
7094                     set dummy $deplib_matches; shift
7095                     deplib_match=$1
7096                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
7097                       newdeplibs="$newdeplibs $i"
7098                     else
7099                       droppeddeps=yes
7100                       $ECHO
7101                       $ECHO "*** Warning: dynamic linker does not accept needed library $i."
7102                       $ECHO "*** I have the capability to make that library automatically link in when"
7103                       $ECHO "*** you link to this library.  But I can only do this if you have a"
7104                       $ECHO "*** shared version of the library, which you do not appear to have"
7105                       $ECHO "*** because a test_compile did reveal that the linker did not use this one"
7106                       $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."
7107                     fi
7108                   fi
7109                 else
7110                   droppeddeps=yes
7111                   $ECHO
7112                   $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
7113                   $ECHO "*** make it link in!  You will probably need to install it or some"
7114                   $ECHO "*** library that it depends on before this library will be fully"
7115                   $ECHO "*** functional.  Installing it before continuing would be even better."
7116                 fi
7117                 ;;
7118               *)
7119                 newdeplibs="$newdeplibs $i"
7120                 ;;
7121               esac
7122             done
7123           fi
7124           ;;
7125         file_magic*)
7126           set dummy $deplibs_check_method; shift
7127           file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7128           for a_deplib in $deplibs; do
7129             case $a_deplib in
7130             -l*)
7131               func_stripname -l '' "$a_deplib"
7132               name=$func_stripname_result
7133               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7134                 case " $predeps $postdeps " in
7135                 *" $a_deplib "*)
7136                   newdeplibs="$newdeplibs $a_deplib"
7137                   a_deplib=""
7138                   ;;
7139                 esac
7140               fi
7141               if test -n "$a_deplib" ; then
7142                 libname=`eval "\\$ECHO \"$libname_spec\""`
7143                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7144                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7145                   for potent_lib in $potential_libs; do
7146                       # Follow soft links.
7147                       if ls -lLd "$potent_lib" 2>/dev/null |
7148                          $GREP " -> " >/dev/null; then
7149                         continue
7150                       fi
7151                       # The statement above tries to avoid entering an
7152                       # endless loop below, in case of cyclic links.
7153                       # We might still enter an endless loop, since a link
7154                       # loop can be closed while we follow links,
7155                       # but so what?
7156                       potlib="$potent_lib"
7157                       while test -h "$potlib" 2>/dev/null; do
7158                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
7159                         case $potliblink in
7160                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
7161                         *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
7162                         esac
7163                       done
7164                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
7165                          $SED -e 10q |
7166                          $EGREP "$file_magic_regex" > /dev/null; then
7167                         newdeplibs="$newdeplibs $a_deplib"
7168                         a_deplib=""
7169                         break 2
7170                       fi
7171                   done
7172                 done
7173               fi
7174               if test -n "$a_deplib" ; then
7175                 droppeddeps=yes
7176                 $ECHO
7177                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7178                 $ECHO "*** I have the capability to make that library automatically link in when"
7179                 $ECHO "*** you link to this library.  But I can only do this if you have a"
7180                 $ECHO "*** shared version of the library, which you do not appear to have"
7181                 $ECHO "*** because I did check the linker path looking for a file starting"
7182                 if test -z "$potlib" ; then
7183                   $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
7184                 else
7185                   $ECHO "*** with $libname and none of the candidates passed a file format test"
7186                   $ECHO "*** using a file magic. Last file checked: $potlib"
7187                 fi
7188               fi
7189               ;;
7190             *)
7191               # Add a -L argument.
7192               newdeplibs="$newdeplibs $a_deplib"
7193               ;;
7194             esac
7195           done # Gone through all deplibs.
7196           ;;
7197         match_pattern*)
7198           set dummy $deplibs_check_method; shift
7199           match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
7200           for a_deplib in $deplibs; do
7201             case $a_deplib in
7202             -l*)
7203               func_stripname -l '' "$a_deplib"
7204               name=$func_stripname_result
7205               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7206                 case " $predeps $postdeps " in
7207                 *" $a_deplib "*)
7208                   newdeplibs="$newdeplibs $a_deplib"
7209                   a_deplib=""
7210                   ;;
7211                 esac
7212               fi
7213               if test -n "$a_deplib" ; then
7214                 libname=`eval "\\$ECHO \"$libname_spec\""`
7215                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
7216                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
7217                   for potent_lib in $potential_libs; do
7218                     potlib="$potent_lib" # see symlink-check above in file_magic test
7219                     if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \
7220                        $EGREP "$match_pattern_regex" > /dev/null; then
7221                       newdeplibs="$newdeplibs $a_deplib"
7222                       a_deplib=""
7223                       break 2
7224                     fi
7225                   done
7226                 done
7227               fi
7228               if test -n "$a_deplib" ; then
7229                 droppeddeps=yes
7230                 $ECHO
7231                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
7232                 $ECHO "*** I have the capability to make that library automatically link in when"
7233                 $ECHO "*** you link to this library.  But I can only do this if you have a"
7234                 $ECHO "*** shared version of the library, which you do not appear to have"
7235                 $ECHO "*** because I did check the linker path looking for a file starting"
7236                 if test -z "$potlib" ; then
7237                   $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
7238                 else
7239                   $ECHO "*** with $libname and none of the candidates passed a file format test"
7240                   $ECHO "*** using a regex pattern. Last file checked: $potlib"
7241                 fi
7242               fi
7243               ;;
7244             *)
7245               # Add a -L argument.
7246               newdeplibs="$newdeplibs $a_deplib"
7247               ;;
7248             esac
7249           done # Gone through all deplibs.
7250           ;;
7251         none | unknown | *)
7252           newdeplibs=""
7253           tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \
7254               -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`
7255           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
7256             for i in $predeps $postdeps ; do
7257               # can't use Xsed below, because $i might contain '/'
7258               tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`
7259             done
7260           fi
7261           if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[      ]//g' |
7262              $GREP . >/dev/null; then
7263             $ECHO
7264             if test "X$deplibs_check_method" = "Xnone"; then
7265               $ECHO "*** Warning: inter-library dependencies are not supported in this platform."
7266             else
7267               $ECHO "*** Warning: inter-library dependencies are not known to be supported."
7268             fi
7269             $ECHO "*** All declared inter-library dependencies are being dropped."
7270             droppeddeps=yes
7271           fi
7272           ;;
7273         esac
7274         versuffix=$versuffix_save
7275         major=$major_save
7276         release=$release_save
7277         libname=$libname_save
7278         name=$name_save
7279
7280         case $host in
7281         *-*-rhapsody* | *-*-darwin1.[012])
7282           # On Rhapsody replace the C library with the System framework
7283           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
7284           ;;
7285         esac
7286
7287         if test "$droppeddeps" = yes; then
7288           if test "$module" = yes; then
7289             $ECHO
7290             $ECHO "*** Warning: libtool could not satisfy all declared inter-library"
7291             $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
7292             $ECHO "*** a static module, that should work as long as the dlopening"
7293             $ECHO "*** application is linked with the -dlopen flag."
7294             if test -z "$global_symbol_pipe"; then
7295               $ECHO
7296               $ECHO "*** However, this would only work if libtool was able to extract symbol"
7297               $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"
7298               $ECHO "*** not find such a program.  So, this module is probably useless."
7299               $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."
7300             fi
7301             if test "$build_old_libs" = no; then
7302               oldlibs="$output_objdir/$libname.$libext"
7303               build_libtool_libs=module
7304               build_old_libs=yes
7305             else
7306               build_libtool_libs=no
7307             fi
7308           else
7309             $ECHO "*** The inter-library dependencies that have been dropped here will be"
7310             $ECHO "*** automatically added whenever a program is linked with this library"
7311             $ECHO "*** or is declared to -dlopen it."
7312
7313             if test "$allow_undefined" = no; then
7314               $ECHO
7315               $ECHO "*** Since this library must not contain undefined symbols,"
7316               $ECHO "*** because either the platform does not support them or"
7317               $ECHO "*** it was explicitly requested with -no-undefined,"
7318               $ECHO "*** libtool will only create a static version of it."
7319               if test "$build_old_libs" = no; then
7320                 oldlibs="$output_objdir/$libname.$libext"
7321                 build_libtool_libs=module
7322                 build_old_libs=yes
7323               else
7324                 build_libtool_libs=no
7325               fi
7326             fi
7327           fi
7328         fi
7329         # Done checking deplibs!
7330         deplibs=$newdeplibs
7331       fi
7332       # Time to change all our "foo.ltframework" stuff back to "-framework foo"
7333       case $host in
7334         *-*-darwin*)
7335           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7336           new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7337           deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
7338           ;;
7339       esac
7340
7341       # move library search paths that coincide with paths to not yet
7342       # installed libraries to the beginning of the library search list
7343       new_libs=
7344       for path in $notinst_path; do
7345         case " $new_libs " in
7346         *" -L$path/$objdir "*) ;;
7347         *)
7348           case " $deplibs " in
7349           *" -L$path/$objdir "*)
7350             new_libs="$new_libs -L$path/$objdir" ;;
7351           esac
7352           ;;
7353         esac
7354       done
7355       for deplib in $deplibs; do
7356         case $deplib in
7357         -L*)
7358           case " $new_libs " in
7359           *" $deplib "*) ;;
7360           *) new_libs="$new_libs $deplib" ;;
7361           esac
7362           ;;
7363         *) new_libs="$new_libs $deplib" ;;
7364         esac
7365       done
7366       deplibs="$new_libs"
7367
7368       # All the library-specific variables (install_libdir is set above).
7369       library_names=
7370       old_library=
7371       dlname=
7372
7373       # Test again, we may have decided not to build it any more
7374       if test "$build_libtool_libs" = yes; then
7375         if test "$hardcode_into_libs" = yes; then
7376           # Hardcode the library paths
7377           hardcode_libdirs=
7378           dep_rpath=
7379           rpath="$finalize_rpath"
7380           test "$mode" != relink && rpath="$compile_rpath$rpath"
7381           for libdir in $rpath; do
7382             if test -n "$hardcode_libdir_flag_spec"; then
7383               if test -n "$hardcode_libdir_separator"; then
7384                 if test -z "$hardcode_libdirs"; then
7385                   hardcode_libdirs="$libdir"
7386                 else
7387                   # Just accumulate the unique libdirs.
7388                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
7389                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
7390                     ;;
7391                   *)
7392                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
7393                     ;;
7394                   esac
7395                 fi
7396               else
7397                 eval flag=\"$hardcode_libdir_flag_spec\"
7398                 dep_rpath="$dep_rpath $flag"
7399               fi
7400             elif test -n "$runpath_var"; then
7401               case "$perm_rpath " in
7402               *" $libdir "*) ;;
7403               *) perm_rpath="$perm_rpath $libdir" ;;
7404               esac
7405             fi
7406           done
7407           # Substitute the hardcoded libdirs into the rpath.
7408           if test -n "$hardcode_libdir_separator" &&
7409              test -n "$hardcode_libdirs"; then
7410             libdir="$hardcode_libdirs"
7411             if test -n "$hardcode_libdir_flag_spec_ld"; then
7412               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
7413             else
7414               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
7415             fi
7416           fi
7417           if test -n "$runpath_var" && test -n "$perm_rpath"; then
7418             # We should set the runpath_var.
7419             rpath=
7420             for dir in $perm_rpath; do
7421               rpath="$rpath$dir:"
7422             done
7423             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
7424           fi
7425           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
7426         fi
7427
7428         shlibpath="$finalize_shlibpath"
7429         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
7430         if test -n "$shlibpath"; then
7431           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
7432         fi
7433
7434         # Get the real and link names of the library.
7435         eval shared_ext=\"$shrext_cmds\"
7436         eval library_names=\"$library_names_spec\"
7437         set dummy $library_names
7438         shift
7439         realname="$1"
7440         shift
7441
7442         if test -n "$soname_spec"; then
7443           eval soname=\"$soname_spec\"
7444         else
7445           soname="$realname"
7446         fi
7447         if test -z "$dlname"; then
7448           dlname=$soname
7449         fi
7450
7451         lib="$output_objdir/$realname"
7452         linknames=
7453         for link
7454         do
7455           linknames="$linknames $link"
7456         done
7457
7458         # Use standard objects if they are pic
7459         test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
7460         test "X$libobjs" = "X " && libobjs=
7461
7462         delfiles=
7463         if test -n "$export_symbols" && test -n "$include_expsyms"; then
7464           $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
7465           export_symbols="$output_objdir/$libname.uexp"
7466           delfiles="$delfiles $export_symbols"
7467         fi
7468
7469         orig_export_symbols=
7470         case $host_os in
7471         cygwin* | mingw* | cegcc*)
7472           if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
7473             # exporting using user supplied symfile
7474             if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
7475               # and it's NOT already a .def file. Must figure out
7476               # which of the given symbols are data symbols and tag
7477               # them as such. So, trigger use of export_symbols_cmds.
7478               # export_symbols gets reassigned inside the "prepare
7479               # the list of exported symbols" if statement, so the
7480               # include_expsyms logic still works.
7481               orig_export_symbols="$export_symbols"
7482               export_symbols=
7483               always_export_symbols=yes
7484             fi
7485           fi
7486           ;;
7487         esac
7488
7489         # Prepare the list of exported symbols
7490         if test -z "$export_symbols"; then
7491           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
7492             func_verbose "generating symbol list for \`$libname.la'"
7493             export_symbols="$output_objdir/$libname.exp"
7494             $opt_dry_run || $RM $export_symbols
7495             cmds=$export_symbols_cmds
7496             save_ifs="$IFS"; IFS='~'
7497             for cmd in $cmds; do
7498               IFS="$save_ifs"
7499               eval cmd=\"$cmd\"
7500               func_len " $cmd"
7501               len=$func_len_result
7502               if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7503                 func_show_eval "$cmd" 'exit $?'
7504                 skipped_export=false
7505               else
7506                 # The command line is too long to execute in one step.
7507                 func_verbose "using reloadable object file for export list..."
7508                 skipped_export=:
7509                 # Break out early, otherwise skipped_export may be
7510                 # set to false by a later but shorter cmd.
7511                 break
7512               fi
7513             done
7514             IFS="$save_ifs"
7515             if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
7516               func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7517               func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7518             fi
7519           fi
7520         fi
7521
7522         if test -n "$export_symbols" && test -n "$include_expsyms"; then
7523           tmp_export_symbols="$export_symbols"
7524           test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7525           $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7526         fi
7527
7528         if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
7529           # The given exports_symbols file has to be filtered, so filter it.
7530           func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7531           # FIXME: $output_objdir/$libname.filter potentially contains lots of
7532           # 's' commands which not all seds can handle. GNU sed should be fine
7533           # though. Also, the filter scales superlinearly with the number of
7534           # global variables. join(1) would be nice here, but unfortunately
7535           # isn't a blessed tool.
7536           $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7537           delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7538           export_symbols=$output_objdir/$libname.def
7539           $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7540         fi
7541
7542         tmp_deplibs=
7543         for test_deplib in $deplibs; do
7544           case " $convenience " in
7545           *" $test_deplib "*) ;;
7546           *)
7547             tmp_deplibs="$tmp_deplibs $test_deplib"
7548             ;;
7549           esac
7550         done
7551         deplibs="$tmp_deplibs"
7552
7553         if test -n "$convenience"; then
7554           if test -n "$whole_archive_flag_spec" &&
7555             test "$compiler_needs_object" = yes &&
7556             test -z "$libobjs"; then
7557             # extract the archives, so we have objects to list.
7558             # TODO: could optimize this to just extract one archive.
7559             whole_archive_flag_spec=
7560           fi
7561           if test -n "$whole_archive_flag_spec"; then
7562             save_libobjs=$libobjs
7563             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7564             test "X$libobjs" = "X " && libobjs=
7565           else
7566             gentop="$output_objdir/${outputname}x"
7567             generated="$generated $gentop"
7568
7569             func_extract_archives $gentop $convenience
7570             libobjs="$libobjs $func_extract_archives_result"
7571             test "X$libobjs" = "X " && libobjs=
7572           fi
7573         fi
7574
7575         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
7576           eval flag=\"$thread_safe_flag_spec\"
7577           linker_flags="$linker_flags $flag"
7578         fi
7579
7580         # Make a backup of the uninstalled library when relinking
7581         if test "$mode" = relink; then
7582           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
7583         fi
7584
7585         # Do each of the archive commands.
7586         if test "$module" = yes && test -n "$module_cmds" ; then
7587           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7588             eval test_cmds=\"$module_expsym_cmds\"
7589             cmds=$module_expsym_cmds
7590           else
7591             eval test_cmds=\"$module_cmds\"
7592             cmds=$module_cmds
7593           fi
7594         else
7595           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7596             eval test_cmds=\"$archive_expsym_cmds\"
7597             cmds=$archive_expsym_cmds
7598           else
7599             eval test_cmds=\"$archive_cmds\"
7600             cmds=$archive_cmds
7601           fi
7602         fi
7603
7604         if test "X$skipped_export" != "X:" &&
7605            func_len " $test_cmds" &&
7606            len=$func_len_result &&
7607            test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
7608           :
7609         else
7610           # The command line is too long to link in one step, link piecewise
7611           # or, if using GNU ld and skipped_export is not :, use a linker
7612           # script.
7613
7614           # Save the value of $output and $libobjs because we want to
7615           # use them later.  If we have whole_archive_flag_spec, we
7616           # want to use save_libobjs as it was before
7617           # whole_archive_flag_spec was expanded, because we can't
7618           # assume the linker understands whole_archive_flag_spec.
7619           # This may have to be revisited, in case too many
7620           # convenience libraries get linked in and end up exceeding
7621           # the spec.
7622           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
7623             save_libobjs=$libobjs
7624           fi
7625           save_output=$output
7626           output_la=`$ECHO "X$output" | $Xsed -e "$basename"`
7627
7628           # Clear the reloadable object creation command queue and
7629           # initialize k to one.
7630           test_cmds=
7631           concat_cmds=
7632           objlist=
7633           last_robj=
7634           k=1
7635
7636           if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
7637             output=${output_objdir}/${output_la}.lnkscript
7638             func_verbose "creating GNU ld script: $output"
7639             $ECHO 'INPUT (' > $output
7640             for obj in $save_libobjs
7641             do
7642               $ECHO "$obj" >> $output
7643             done
7644             $ECHO ')' >> $output
7645             delfiles="$delfiles $output"
7646           elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
7647             output=${output_objdir}/${output_la}.lnk
7648             func_verbose "creating linker input file list: $output"
7649             : > $output
7650             set x $save_libobjs
7651             shift
7652             firstobj=
7653             if test "$compiler_needs_object" = yes; then
7654               firstobj="$1 "
7655               shift
7656             fi
7657             for obj
7658             do
7659               $ECHO "$obj" >> $output
7660             done
7661             delfiles="$delfiles $output"
7662             output=$firstobj\"$file_list_spec$output\"
7663           else
7664             if test -n "$save_libobjs"; then
7665               func_verbose "creating reloadable object files..."
7666               output=$output_objdir/$output_la-${k}.$objext
7667               eval test_cmds=\"$reload_cmds\"
7668               func_len " $test_cmds"
7669               len0=$func_len_result
7670               len=$len0
7671
7672               # Loop over the list of objects to be linked.
7673               for obj in $save_libobjs
7674               do
7675                 func_len " $obj"
7676                 func_arith $len + $func_len_result
7677                 len=$func_arith_result
7678                 if test "X$objlist" = X ||
7679                    test "$len" -lt "$max_cmd_len"; then
7680                   func_append objlist " $obj"
7681                 else
7682                   # The command $test_cmds is almost too long, add a
7683                   # command to the queue.
7684                   if test "$k" -eq 1 ; then
7685                     # The first file doesn't have a previous command to add.
7686                     eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
7687                   else
7688                     # All subsequent reloadable object files will link in
7689                     # the last one created.
7690                     eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"
7691                   fi
7692                   last_robj=$output_objdir/$output_la-${k}.$objext
7693                   func_arith $k + 1
7694                   k=$func_arith_result
7695                   output=$output_objdir/$output_la-${k}.$objext
7696                   objlist=$obj
7697                   func_len " $last_robj"
7698                   func_arith $len0 + $func_len_result
7699                   len=$func_arith_result
7700                 fi
7701               done
7702               # Handle the remaining objects by creating one last
7703               # reloadable object file.  All subsequent reloadable object
7704               # files will link in the last one created.
7705               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7706               eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
7707               if test -n "$last_robj"; then
7708                 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
7709               fi
7710               delfiles="$delfiles $output"
7711
7712             else
7713               output=
7714             fi
7715
7716             if ${skipped_export-false}; then
7717               func_verbose "generating symbol list for \`$libname.la'"
7718               export_symbols="$output_objdir/$libname.exp"
7719               $opt_dry_run || $RM $export_symbols
7720               libobjs=$output
7721               # Append the command to create the export file.
7722               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
7723               eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
7724               if test -n "$last_robj"; then
7725                 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
7726               fi
7727             fi
7728
7729             test -n "$save_libobjs" &&
7730               func_verbose "creating a temporary reloadable object file: $output"
7731
7732             # Loop through the commands generated above and execute them.
7733             save_ifs="$IFS"; IFS='~'
7734             for cmd in $concat_cmds; do
7735               IFS="$save_ifs"
7736               $opt_silent || {
7737                   func_quote_for_expand "$cmd"
7738                   eval "func_echo $func_quote_for_expand_result"
7739               }
7740               $opt_dry_run || eval "$cmd" || {
7741                 lt_exit=$?
7742
7743                 # Restore the uninstalled library and exit
7744                 if test "$mode" = relink; then
7745                   ( cd "$output_objdir" && \
7746                     $RM "${realname}T" && \
7747                     $MV "${realname}U" "$realname" )
7748                 fi
7749
7750                 exit $lt_exit
7751               }
7752             done
7753             IFS="$save_ifs"
7754
7755             if test -n "$export_symbols_regex" && ${skipped_export-false}; then
7756               func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
7757               func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
7758             fi
7759           fi
7760
7761           if ${skipped_export-false}; then
7762             if test -n "$export_symbols" && test -n "$include_expsyms"; then
7763               tmp_export_symbols="$export_symbols"
7764               test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
7765               $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'
7766             fi
7767
7768             if test -n "$orig_export_symbols"; then
7769               # The given exports_symbols file has to be filtered, so filter it.
7770               func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
7771               # FIXME: $output_objdir/$libname.filter potentially contains lots of
7772               # 's' commands which not all seds can handle. GNU sed should be fine
7773               # though. Also, the filter scales superlinearly with the number of
7774               # global variables. join(1) would be nice here, but unfortunately
7775               # isn't a blessed tool.
7776               $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
7777               delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"
7778               export_symbols=$output_objdir/$libname.def
7779               $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
7780             fi
7781           fi
7782
7783           libobjs=$output
7784           # Restore the value of output.
7785           output=$save_output
7786
7787           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
7788             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
7789             test "X$libobjs" = "X " && libobjs=
7790           fi
7791           # Expand the library linking commands again to reset the
7792           # value of $libobjs for piecewise linking.
7793
7794           # Do each of the archive commands.
7795           if test "$module" = yes && test -n "$module_cmds" ; then
7796             if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
7797               cmds=$module_expsym_cmds
7798             else
7799               cmds=$module_cmds
7800             fi
7801           else
7802             if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
7803               cmds=$archive_expsym_cmds
7804             else
7805               cmds=$archive_cmds
7806             fi
7807           fi
7808         fi
7809
7810         if test -n "$delfiles"; then
7811           # Append the command to remove temporary files to $cmds.
7812           eval cmds=\"\$cmds~\$RM $delfiles\"
7813         fi
7814
7815         # Add any objects from preloaded convenience libraries
7816         if test -n "$dlprefiles"; then
7817           gentop="$output_objdir/${outputname}x"
7818           generated="$generated $gentop"
7819
7820           func_extract_archives $gentop $dlprefiles
7821           libobjs="$libobjs $func_extract_archives_result"
7822           test "X$libobjs" = "X " && libobjs=
7823         fi
7824
7825         save_ifs="$IFS"; IFS='~'
7826         for cmd in $cmds; do
7827           IFS="$save_ifs"
7828           eval cmd=\"$cmd\"
7829           $opt_silent || {
7830             func_quote_for_expand "$cmd"
7831             eval "func_echo $func_quote_for_expand_result"
7832           }
7833           $opt_dry_run || eval "$cmd" || {
7834             lt_exit=$?
7835
7836             # Restore the uninstalled library and exit
7837             if test "$mode" = relink; then
7838               ( cd "$output_objdir" && \
7839                 $RM "${realname}T" && \
7840                 $MV "${realname}U" "$realname" )
7841             fi
7842
7843             exit $lt_exit
7844           }
7845         done
7846         IFS="$save_ifs"
7847
7848         # Restore the uninstalled library and exit
7849         if test "$mode" = relink; then
7850           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
7851
7852           if test -n "$convenience"; then
7853             if test -z "$whole_archive_flag_spec"; then
7854               func_show_eval '${RM}r "$gentop"'
7855             fi
7856           fi
7857
7858           exit $EXIT_SUCCESS
7859         fi
7860
7861         # Create links to the real library.
7862         for linkname in $linknames; do
7863           if test "$realname" != "$linkname"; then
7864             func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
7865           fi
7866         done
7867
7868         # If -module or -export-dynamic was specified, set the dlname.
7869         if test "$module" = yes || test "$export_dynamic" = yes; then
7870           # On all known operating systems, these are identical.
7871           dlname="$soname"
7872         fi
7873       fi
7874       ;;
7875
7876     obj)
7877       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
7878         func_warning "\`-dlopen' is ignored for objects"
7879       fi
7880
7881       case " $deplibs" in
7882       *\ -l* | *\ -L*)
7883         func_warning "\`-l' and \`-L' are ignored for objects" ;;
7884       esac
7885
7886       test -n "$rpath" && \
7887         func_warning "\`-rpath' is ignored for objects"
7888
7889       test -n "$xrpath" && \
7890         func_warning "\`-R' is ignored for objects"
7891
7892       test -n "$vinfo" && \
7893         func_warning "\`-version-info' is ignored for objects"
7894
7895       test -n "$release" && \
7896         func_warning "\`-release' is ignored for objects"
7897
7898       case $output in
7899       *.lo)
7900         test -n "$objs$old_deplibs" && \
7901           func_fatal_error "cannot build library object \`$output' from non-libtool objects"
7902
7903         libobj=$output
7904         func_lo2o "$libobj"
7905         obj=$func_lo2o_result
7906         ;;
7907       *)
7908         libobj=
7909         obj="$output"
7910         ;;
7911       esac
7912
7913       # Delete the old objects.
7914       $opt_dry_run || $RM $obj $libobj
7915
7916       # Objects from convenience libraries.  This assumes
7917       # single-version convenience libraries.  Whenever we create
7918       # different ones for PIC/non-PIC, this we'll have to duplicate
7919       # the extraction.
7920       reload_conv_objs=
7921       gentop=
7922       # reload_cmds runs $LD directly, so let us get rid of
7923       # -Wl from whole_archive_flag_spec and hope we can get by with
7924       # turning comma into space..
7925       wl=
7926
7927       if test -n "$convenience"; then
7928         if test -n "$whole_archive_flag_spec"; then
7929           eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
7930           reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
7931         else
7932           gentop="$output_objdir/${obj}x"
7933           generated="$generated $gentop"
7934
7935           func_extract_archives $gentop $convenience
7936           reload_conv_objs="$reload_objs $func_extract_archives_result"
7937         fi
7938       fi
7939
7940       # Create the old-style object.
7941       reload_objs="$objs$old_deplibs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
7942
7943       output="$obj"
7944       func_execute_cmds "$reload_cmds" 'exit $?'
7945
7946       # Exit if we aren't doing a library object file.
7947       if test -z "$libobj"; then
7948         if test -n "$gentop"; then
7949           func_show_eval '${RM}r "$gentop"'
7950         fi
7951
7952         exit $EXIT_SUCCESS
7953       fi
7954
7955       if test "$build_libtool_libs" != yes; then
7956         if test -n "$gentop"; then
7957           func_show_eval '${RM}r "$gentop"'
7958         fi
7959
7960         # Create an invalid libtool object if no PIC, so that we don't
7961         # accidentally link it into a program.
7962         # $show "echo timestamp > $libobj"
7963         # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
7964         exit $EXIT_SUCCESS
7965       fi
7966
7967       if test -n "$pic_flag" || test "$pic_mode" != default; then
7968         # Only do commands if we really have different PIC objects.
7969         reload_objs="$libobjs $reload_conv_objs"
7970         output="$libobj"
7971         func_execute_cmds "$reload_cmds" 'exit $?'
7972       fi
7973
7974       if test -n "$gentop"; then
7975         func_show_eval '${RM}r "$gentop"'
7976       fi
7977
7978       exit $EXIT_SUCCESS
7979       ;;
7980
7981     prog)
7982       case $host in
7983         *cygwin*) func_stripname '' '.exe' "$output"
7984                   output=$func_stripname_result.exe;;
7985       esac
7986       test -n "$vinfo" && \
7987         func_warning "\`-version-info' is ignored for programs"
7988
7989       test -n "$release" && \
7990         func_warning "\`-release' is ignored for programs"
7991
7992       test "$preload" = yes \
7993         && test "$dlopen_support" = unknown \
7994         && test "$dlopen_self" = unknown \
7995         && test "$dlopen_self_static" = unknown && \
7996           func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
7997
7998       case $host in
7999       *-*-rhapsody* | *-*-darwin1.[012])
8000         # On Rhapsody replace the C library is the System framework
8001         compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
8002         finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`
8003         ;;
8004       esac
8005
8006       case $host in
8007       *-*-darwin*)
8008         # Don't allow lazy linking, it breaks C++ global constructors
8009         # But is supposedly fixed on 10.4 or later (yay!).
8010         if test "$tagname" = CXX ; then
8011           case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
8012             10.[0123])
8013               compile_command="$compile_command ${wl}-bind_at_load"
8014               finalize_command="$finalize_command ${wl}-bind_at_load"
8015             ;;
8016           esac
8017         fi
8018         # Time to change all our "foo.ltframework" stuff back to "-framework foo"
8019         compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
8020         finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`
8021         ;;
8022       esac
8023
8024
8025       # move library search paths that coincide with paths to not yet
8026       # installed libraries to the beginning of the library search list
8027       new_libs=
8028       for path in $notinst_path; do
8029         case " $new_libs " in
8030         *" -L$path/$objdir "*) ;;
8031         *)
8032           case " $compile_deplibs " in
8033           *" -L$path/$objdir "*)
8034             new_libs="$new_libs -L$path/$objdir" ;;
8035           esac
8036           ;;
8037         esac
8038       done
8039       for deplib in $compile_deplibs; do
8040         case $deplib in
8041         -L*)
8042           case " $new_libs " in
8043           *" $deplib "*) ;;
8044           *) new_libs="$new_libs $deplib" ;;
8045           esac
8046           ;;
8047         *) new_libs="$new_libs $deplib" ;;
8048         esac
8049       done
8050       compile_deplibs="$new_libs"
8051
8052
8053       compile_command="$compile_command $compile_deplibs"
8054       finalize_command="$finalize_command $finalize_deplibs"
8055
8056       if test -n "$rpath$xrpath"; then
8057         # If the user specified any rpath flags, then add them.
8058         for libdir in $rpath $xrpath; do
8059           # This is the magic to use -rpath.
8060           case "$finalize_rpath " in
8061           *" $libdir "*) ;;
8062           *) finalize_rpath="$finalize_rpath $libdir" ;;
8063           esac
8064         done
8065       fi
8066
8067       # Now hardcode the library paths
8068       rpath=
8069       hardcode_libdirs=
8070       for libdir in $compile_rpath $finalize_rpath; do
8071         if test -n "$hardcode_libdir_flag_spec"; then
8072           if test -n "$hardcode_libdir_separator"; then
8073             if test -z "$hardcode_libdirs"; then
8074               hardcode_libdirs="$libdir"
8075             else
8076               # Just accumulate the unique libdirs.
8077               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8078               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8079                 ;;
8080               *)
8081                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8082                 ;;
8083               esac
8084             fi
8085           else
8086             eval flag=\"$hardcode_libdir_flag_spec\"
8087             rpath="$rpath $flag"
8088           fi
8089         elif test -n "$runpath_var"; then
8090           case "$perm_rpath " in
8091           *" $libdir "*) ;;
8092           *) perm_rpath="$perm_rpath $libdir" ;;
8093           esac
8094         fi
8095         case $host in
8096         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
8097           testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
8098           case :$dllsearchpath: in
8099           *":$libdir:"*) ;;
8100           ::) dllsearchpath=$libdir;;
8101           *) dllsearchpath="$dllsearchpath:$libdir";;
8102           esac
8103           case :$dllsearchpath: in
8104           *":$testbindir:"*) ;;
8105           ::) dllsearchpath=$testbindir;;
8106           *) dllsearchpath="$dllsearchpath:$testbindir";;
8107           esac
8108           ;;
8109         esac
8110       done
8111       # Substitute the hardcoded libdirs into the rpath.
8112       if test -n "$hardcode_libdir_separator" &&
8113          test -n "$hardcode_libdirs"; then
8114         libdir="$hardcode_libdirs"
8115         eval rpath=\" $hardcode_libdir_flag_spec\"
8116       fi
8117       compile_rpath="$rpath"
8118
8119       rpath=
8120       hardcode_libdirs=
8121       for libdir in $finalize_rpath; do
8122         if test -n "$hardcode_libdir_flag_spec"; then
8123           if test -n "$hardcode_libdir_separator"; then
8124             if test -z "$hardcode_libdirs"; then
8125               hardcode_libdirs="$libdir"
8126             else
8127               # Just accumulate the unique libdirs.
8128               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
8129               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
8130                 ;;
8131               *)
8132                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
8133                 ;;
8134               esac
8135             fi
8136           else
8137             eval flag=\"$hardcode_libdir_flag_spec\"
8138             rpath="$rpath $flag"
8139           fi
8140         elif test -n "$runpath_var"; then
8141           case "$finalize_perm_rpath " in
8142           *" $libdir "*) ;;
8143           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
8144           esac
8145         fi
8146       done
8147       # Substitute the hardcoded libdirs into the rpath.
8148       if test -n "$hardcode_libdir_separator" &&
8149          test -n "$hardcode_libdirs"; then
8150         libdir="$hardcode_libdirs"
8151         eval rpath=\" $hardcode_libdir_flag_spec\"
8152       fi
8153       finalize_rpath="$rpath"
8154
8155       if test -n "$libobjs" && test "$build_old_libs" = yes; then
8156         # Transform all the library objects into standard objects.
8157         compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8158         finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
8159       fi
8160
8161       func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
8162
8163       # template prelinking step
8164       if test -n "$prelink_cmds"; then
8165         func_execute_cmds "$prelink_cmds" 'exit $?'
8166       fi
8167
8168       wrappers_required=yes
8169       case $host in
8170       *cygwin* | *mingw* )
8171         if test "$build_libtool_libs" != yes; then
8172           wrappers_required=no
8173         fi
8174         ;;
8175       *cegcc)
8176         # Disable wrappers for cegcc, we are cross compiling anyway.
8177         wrappers_required=no
8178         ;;
8179       *)
8180         if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
8181           wrappers_required=no
8182         fi
8183         ;;
8184       esac
8185       if test "$wrappers_required" = no; then
8186         # Replace the output file specification.
8187         compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8188         link_command="$compile_command$compile_rpath"
8189
8190         # We have no uninstalled library dependencies, so finalize right now.
8191         exit_status=0
8192         func_show_eval "$link_command" 'exit_status=$?'
8193
8194         # Delete the generated files.
8195         if test -f "$output_objdir/${outputname}S.${objext}"; then
8196           func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
8197         fi
8198
8199         exit $exit_status
8200       fi
8201
8202       if test -n "$compile_shlibpath$finalize_shlibpath"; then
8203         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
8204       fi
8205       if test -n "$finalize_shlibpath"; then
8206         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
8207       fi
8208
8209       compile_var=
8210       finalize_var=
8211       if test -n "$runpath_var"; then
8212         if test -n "$perm_rpath"; then
8213           # We should set the runpath_var.
8214           rpath=
8215           for dir in $perm_rpath; do
8216             rpath="$rpath$dir:"
8217           done
8218           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
8219         fi
8220         if test -n "$finalize_perm_rpath"; then
8221           # We should set the runpath_var.
8222           rpath=
8223           for dir in $finalize_perm_rpath; do
8224             rpath="$rpath$dir:"
8225           done
8226           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
8227         fi
8228       fi
8229
8230       if test "$no_install" = yes; then
8231         # We don't need to create a wrapper script.
8232         link_command="$compile_var$compile_command$compile_rpath"
8233         # Replace the output file specification.
8234         link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
8235         # Delete the old output file.
8236         $opt_dry_run || $RM $output
8237         # Link the executable and exit
8238         func_show_eval "$link_command" 'exit $?'
8239         exit $EXIT_SUCCESS
8240       fi
8241
8242       if test "$hardcode_action" = relink; then
8243         # Fast installation is not supported
8244         link_command="$compile_var$compile_command$compile_rpath"
8245         relink_command="$finalize_var$finalize_command$finalize_rpath"
8246
8247         func_warning "this platform does not like uninstalled shared libraries"
8248         func_warning "\`$output' will be relinked during installation"
8249       else
8250         if test "$fast_install" != no; then
8251           link_command="$finalize_var$compile_command$finalize_rpath"
8252           if test "$fast_install" = yes; then
8253             relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
8254           else
8255             # fast_install is set to needless
8256             relink_command=
8257           fi
8258         else
8259           link_command="$compile_var$compile_command$compile_rpath"
8260           relink_command="$finalize_var$finalize_command$finalize_rpath"
8261         fi
8262       fi
8263
8264       # Replace the output file specification.
8265       link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
8266
8267       # Delete the old output files.
8268       $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
8269
8270       func_show_eval "$link_command" 'exit $?'
8271
8272       # Now create the wrapper script.
8273       func_verbose "creating $output"
8274
8275       # Quote the relink command for shipping.
8276       if test -n "$relink_command"; then
8277         # Preserve any variables that may affect compiler behavior
8278         for var in $variables_saved_for_relink; do
8279           if eval test -z \"\${$var+set}\"; then
8280             relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8281           elif eval var_value=\$$var; test -z "$var_value"; then
8282             relink_command="$var=; export $var; $relink_command"
8283           else
8284             func_quote_for_eval "$var_value"
8285             relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8286           fi
8287         done
8288         relink_command="(cd `pwd`; $relink_command)"
8289         relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8290       fi
8291
8292       # Quote $ECHO for shipping.
8293       if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then
8294         case $progpath in
8295         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
8296         *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
8297         esac
8298         qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`
8299       else
8300         qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`
8301       fi
8302
8303       # Only actually do things if not in dry run mode.
8304       $opt_dry_run || {
8305         # win32 will think the script is a binary if it has
8306         # a .exe suffix, so we strip it off here.
8307         case $output in
8308           *.exe) func_stripname '' '.exe' "$output"
8309                  output=$func_stripname_result ;;
8310         esac
8311         # test for cygwin because mv fails w/o .exe extensions
8312         case $host in
8313           *cygwin*)
8314             exeext=.exe
8315             func_stripname '' '.exe' "$outputname"
8316             outputname=$func_stripname_result ;;
8317           *) exeext= ;;
8318         esac
8319         case $host in
8320           *cygwin* | *mingw* )
8321             func_dirname_and_basename "$output" "" "."
8322             output_name=$func_basename_result
8323             output_path=$func_dirname_result
8324             cwrappersource="$output_path/$objdir/lt-$output_name.c"
8325             cwrapper="$output_path/$output_name.exe"
8326             $RM $cwrappersource $cwrapper
8327             trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
8328
8329             func_emit_cwrapperexe_src > $cwrappersource
8330
8331             # The wrapper executable is built using the $host compiler,
8332             # because it contains $host paths and files. If cross-
8333             # compiling, it, like the target executable, must be
8334             # executed on the $host or under an emulation environment.
8335             $opt_dry_run || {
8336               $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
8337               $STRIP $cwrapper
8338             }
8339
8340             # Now, create the wrapper script for func_source use:
8341             func_ltwrapper_scriptname $cwrapper
8342             $RM $func_ltwrapper_scriptname_result
8343             trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
8344             $opt_dry_run || {
8345               # note: this script will not be executed, so do not chmod.
8346               if test "x$build" = "x$host" ; then
8347                 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
8348               else
8349                 func_emit_wrapper no > $func_ltwrapper_scriptname_result
8350               fi
8351             }
8352           ;;
8353           * )
8354             $RM $output
8355             trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
8356
8357             func_emit_wrapper no > $output
8358             chmod +x $output
8359           ;;
8360         esac
8361       }
8362       exit $EXIT_SUCCESS
8363       ;;
8364     esac
8365
8366     # See if we need to build an old-fashioned archive.
8367     for oldlib in $oldlibs; do
8368
8369       if test "$build_libtool_libs" = convenience; then
8370         oldobjs="$libobjs_save $symfileobj"
8371         addlibs="$convenience"
8372         build_libtool_libs=no
8373       else
8374         if test "$build_libtool_libs" = module; then
8375           oldobjs="$libobjs_save"
8376           build_libtool_libs=no
8377         else
8378           oldobjs="$old_deplibs $non_pic_objects"
8379           if test "$preload" = yes && test -f "$symfileobj"; then
8380             oldobjs="$oldobjs $symfileobj"
8381           fi
8382         fi
8383         addlibs="$old_convenience"
8384       fi
8385
8386       if test -n "$addlibs"; then
8387         gentop="$output_objdir/${outputname}x"
8388         generated="$generated $gentop"
8389
8390         func_extract_archives $gentop $addlibs
8391         oldobjs="$oldobjs $func_extract_archives_result"
8392       fi
8393
8394       # Do each command in the archive commands.
8395       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
8396         cmds=$old_archive_from_new_cmds
8397       else
8398
8399         # Add any objects from preloaded convenience libraries
8400         if test -n "$dlprefiles"; then
8401           gentop="$output_objdir/${outputname}x"
8402           generated="$generated $gentop"
8403
8404           func_extract_archives $gentop $dlprefiles
8405           oldobjs="$oldobjs $func_extract_archives_result"
8406         fi
8407
8408         # POSIX demands no paths to be encoded in archives.  We have
8409         # to avoid creating archives with duplicate basenames if we
8410         # might have to extract them afterwards, e.g., when creating a
8411         # static archive out of a convenience library, or when linking
8412         # the entirety of a libtool archive into another (currently
8413         # not supported by libtool).
8414         if (for obj in $oldobjs
8415             do
8416               func_basename "$obj"
8417               $ECHO "$func_basename_result"
8418             done | sort | sort -uc >/dev/null 2>&1); then
8419           :
8420         else
8421           $ECHO "copying selected object files to avoid basename conflicts..."
8422           gentop="$output_objdir/${outputname}x"
8423           generated="$generated $gentop"
8424           func_mkdir_p "$gentop"
8425           save_oldobjs=$oldobjs
8426           oldobjs=
8427           counter=1
8428           for obj in $save_oldobjs
8429           do
8430             func_basename "$obj"
8431             objbase="$func_basename_result"
8432             case " $oldobjs " in
8433             " ") oldobjs=$obj ;;
8434             *[\ /]"$objbase "*)
8435               while :; do
8436                 # Make sure we don't pick an alternate name that also
8437                 # overlaps.
8438                 newobj=lt$counter-$objbase
8439                 func_arith $counter + 1
8440                 counter=$func_arith_result
8441                 case " $oldobjs " in
8442                 *[\ /]"$newobj "*) ;;
8443                 *) if test ! -f "$gentop/$newobj"; then break; fi ;;
8444                 esac
8445               done
8446               func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
8447               oldobjs="$oldobjs $gentop/$newobj"
8448               ;;
8449             *) oldobjs="$oldobjs $obj" ;;
8450             esac
8451           done
8452         fi
8453         eval cmds=\"$old_archive_cmds\"
8454
8455         func_len " $cmds"
8456         len=$func_len_result
8457         if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
8458           cmds=$old_archive_cmds
8459         else
8460           # the command line is too long to link in one step, link in parts
8461           func_verbose "using piecewise archive linking..."
8462           save_RANLIB=$RANLIB
8463           RANLIB=:
8464           objlist=
8465           concat_cmds=
8466           save_oldobjs=$oldobjs
8467           oldobjs=
8468           # Is there a better way of finding the last object in the list?
8469           for obj in $save_oldobjs
8470           do
8471             last_oldobj=$obj
8472           done
8473           eval test_cmds=\"$old_archive_cmds\"
8474           func_len " $test_cmds"
8475           len0=$func_len_result
8476           len=$len0
8477           for obj in $save_oldobjs
8478           do
8479             func_len " $obj"
8480             func_arith $len + $func_len_result
8481             len=$func_arith_result
8482             func_append objlist " $obj"
8483             if test "$len" -lt "$max_cmd_len"; then
8484               :
8485             else
8486               # the above command should be used before it gets too long
8487               oldobjs=$objlist
8488               if test "$obj" = "$last_oldobj" ; then
8489                 RANLIB=$save_RANLIB
8490               fi
8491               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
8492               eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
8493               objlist=
8494               len=$len0
8495             fi
8496           done
8497           RANLIB=$save_RANLIB
8498           oldobjs=$objlist
8499           if test "X$oldobjs" = "X" ; then
8500             eval cmds=\"\$concat_cmds\"
8501           else
8502             eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
8503           fi
8504         fi
8505       fi
8506       func_execute_cmds "$cmds" 'exit $?'
8507     done
8508
8509     test -n "$generated" && \
8510       func_show_eval "${RM}r$generated"
8511
8512     # Now create the libtool archive.
8513     case $output in
8514     *.la)
8515       old_library=
8516       test "$build_old_libs" = yes && old_library="$libname.$libext"
8517       func_verbose "creating $output"
8518
8519       # Preserve any variables that may affect compiler behavior
8520       for var in $variables_saved_for_relink; do
8521         if eval test -z \"\${$var+set}\"; then
8522           relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
8523         elif eval var_value=\$$var; test -z "$var_value"; then
8524           relink_command="$var=; export $var; $relink_command"
8525         else
8526           func_quote_for_eval "$var_value"
8527           relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
8528         fi
8529       done
8530       # Quote the link command for shipping.
8531       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
8532       relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`
8533       if test "$hardcode_automatic" = yes ; then
8534         relink_command=
8535       fi
8536
8537       # Only create the output if not a dry run.
8538       $opt_dry_run || {
8539         for installed in no yes; do
8540           if test "$installed" = yes; then
8541             if test -z "$install_libdir"; then
8542               break
8543             fi
8544             output="$output_objdir/$outputname"i
8545             # Replace all uninstalled libtool libraries with the installed ones
8546             newdependency_libs=
8547             for deplib in $dependency_libs; do
8548               case $deplib in
8549               *.la)
8550                 func_basename "$deplib"
8551                 name="$func_basename_result"
8552                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
8553                 test -z "$libdir" && \
8554                   func_fatal_error "\`$deplib' is not a valid libtool archive"
8555                 newdependency_libs="$newdependency_libs $libdir/$name"
8556                 ;;
8557               *) newdependency_libs="$newdependency_libs $deplib" ;;
8558               esac
8559             done
8560             dependency_libs="$newdependency_libs"
8561             newdlfiles=
8562
8563             for lib in $dlfiles; do
8564               case $lib in
8565               *.la)
8566                 func_basename "$lib"
8567                 name="$func_basename_result"
8568                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8569                 test -z "$libdir" && \
8570                   func_fatal_error "\`$lib' is not a valid libtool archive"
8571                 newdlfiles="$newdlfiles $libdir/$name"
8572                 ;;
8573               *) newdlfiles="$newdlfiles $lib" ;;
8574               esac
8575             done
8576             dlfiles="$newdlfiles"
8577             newdlprefiles=
8578             for lib in $dlprefiles; do
8579               case $lib in
8580               *.la)
8581                 # Only pass preopened files to the pseudo-archive (for
8582                 # eventual linking with the app. that links it) if we
8583                 # didn't already link the preopened objects directly into
8584                 # the library:
8585                 func_basename "$lib"
8586                 name="$func_basename_result"
8587                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
8588                 test -z "$libdir" && \
8589                   func_fatal_error "\`$lib' is not a valid libtool archive"
8590                 newdlprefiles="$newdlprefiles $libdir/$name"
8591                 ;;
8592               esac
8593             done
8594             dlprefiles="$newdlprefiles"
8595           else
8596             newdlfiles=
8597             for lib in $dlfiles; do
8598               case $lib in
8599                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8600                 *) abs=`pwd`"/$lib" ;;
8601               esac
8602               newdlfiles="$newdlfiles $abs"
8603             done
8604             dlfiles="$newdlfiles"
8605             newdlprefiles=
8606             for lib in $dlprefiles; do
8607               case $lib in
8608                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
8609                 *) abs=`pwd`"/$lib" ;;
8610               esac
8611               newdlprefiles="$newdlprefiles $abs"
8612             done
8613             dlprefiles="$newdlprefiles"
8614           fi
8615           $RM $output
8616           # place dlname in correct position for cygwin
8617           tdlname=$dlname
8618           case $host,$output,$installed,$module,$dlname in
8619             *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
8620           esac
8621           $ECHO > $output "\
8622 # $outputname - a libtool library file
8623 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
8624 #
8625 # Please DO NOT delete this file!
8626 # It is necessary for linking the library.
8627
8628 # The name that we can dlopen(3).
8629 dlname='$tdlname'
8630
8631 # Names of this library.
8632 library_names='$library_names'
8633
8634 # The name of the static archive.
8635 old_library='$old_library'
8636
8637 # Linker flags that can not go in dependency_libs.
8638 inherited_linker_flags='$new_inherited_linker_flags'
8639
8640 # Libraries that this one depends upon.
8641 dependency_libs='$dependency_libs'
8642
8643 # Names of additional weak libraries provided by this library
8644 weak_library_names='$weak_libs'
8645
8646 # Version information for $libname.
8647 current=$current
8648 age=$age
8649 revision=$revision
8650
8651 # Is this an already installed library?
8652 installed=$installed
8653
8654 # Should we warn about portability when linking against -modules?
8655 shouldnotlink=$module
8656
8657 # Files to dlopen/dlpreopen
8658 dlopen='$dlfiles'
8659 dlpreopen='$dlprefiles'
8660
8661 # Directory that this library needs to be installed in:
8662 libdir='$install_libdir'"
8663           if test "$installed" = no && test "$need_relink" = yes; then
8664             $ECHO >> $output "\
8665 relink_command=\"$relink_command\""
8666           fi
8667         done
8668       }
8669
8670       # Do a symbolic link so that the libtool archive can be found in
8671       # LD_LIBRARY_PATH before the program is installed.
8672       func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
8673       ;;
8674     esac
8675     exit $EXIT_SUCCESS
8676 }
8677
8678 { test "$mode" = link || test "$mode" = relink; } &&
8679     func_mode_link ${1+"$@"}
8680
8681
8682 # func_mode_uninstall arg...
8683 func_mode_uninstall ()
8684 {
8685     $opt_debug
8686     RM="$nonopt"
8687     files=
8688     rmforce=
8689     exit_status=0
8690
8691     # This variable tells wrapper scripts just to set variables rather
8692     # than running their programs.
8693     libtool_install_magic="$magic"
8694
8695     for arg
8696     do
8697       case $arg in
8698       -f) RM="$RM $arg"; rmforce=yes ;;
8699       -*) RM="$RM $arg" ;;
8700       *) files="$files $arg" ;;
8701       esac
8702     done
8703
8704     test -z "$RM" && \
8705       func_fatal_help "you must specify an RM program"
8706
8707     rmdirs=
8708
8709     origobjdir="$objdir"
8710     for file in $files; do
8711       func_dirname "$file" "" "."
8712       dir="$func_dirname_result"
8713       if test "X$dir" = X.; then
8714         objdir="$origobjdir"
8715       else
8716         objdir="$dir/$origobjdir"
8717       fi
8718       func_basename "$file"
8719       name="$func_basename_result"
8720       test "$mode" = uninstall && objdir="$dir"
8721
8722       # Remember objdir for removal later, being careful to avoid duplicates
8723       if test "$mode" = clean; then
8724         case " $rmdirs " in
8725           *" $objdir "*) ;;
8726           *) rmdirs="$rmdirs $objdir" ;;
8727         esac
8728       fi
8729
8730       # Don't error if the file doesn't exist and rm -f was used.
8731       if { test -L "$file"; } >/dev/null 2>&1 ||
8732          { test -h "$file"; } >/dev/null 2>&1 ||
8733          test -f "$file"; then
8734         :
8735       elif test -d "$file"; then
8736         exit_status=1
8737         continue
8738       elif test "$rmforce" = yes; then
8739         continue
8740       fi
8741
8742       rmfiles="$file"
8743
8744       case $name in
8745       *.la)
8746         # Possibly a libtool archive, so verify it.
8747         if func_lalib_p "$file"; then
8748           func_source $dir/$name
8749
8750           # Delete the libtool libraries and symlinks.
8751           for n in $library_names; do
8752             rmfiles="$rmfiles $objdir/$n"
8753           done
8754           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
8755
8756           case "$mode" in
8757           clean)
8758             case "  $library_names " in
8759             # "  " in the beginning catches empty $dlname
8760             *" $dlname "*) ;;
8761             *) rmfiles="$rmfiles $objdir/$dlname" ;;
8762             esac
8763             test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
8764             ;;
8765           uninstall)
8766             if test -n "$library_names"; then
8767               # Do each command in the postuninstall commands.
8768               func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8769             fi
8770
8771             if test -n "$old_library"; then
8772               # Do each command in the old_postuninstall commands.
8773               func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
8774             fi
8775             # FIXME: should reinstall the best remaining shared library.
8776             ;;
8777           esac
8778         fi
8779         ;;
8780
8781       *.lo)
8782         # Possibly a libtool object, so verify it.
8783         if func_lalib_p "$file"; then
8784
8785           # Read the .lo file
8786           func_source $dir/$name
8787
8788           # Add PIC object to the list of files to remove.
8789           if test -n "$pic_object" &&
8790              test "$pic_object" != none; then
8791             rmfiles="$rmfiles $dir/$pic_object"
8792           fi
8793
8794           # Add non-PIC object to the list of files to remove.
8795           if test -n "$non_pic_object" &&
8796              test "$non_pic_object" != none; then
8797             rmfiles="$rmfiles $dir/$non_pic_object"
8798           fi
8799         fi
8800         ;;
8801
8802       *)
8803         if test "$mode" = clean ; then
8804           noexename=$name
8805           case $file in
8806           *.exe)
8807             func_stripname '' '.exe' "$file"
8808             file=$func_stripname_result
8809             func_stripname '' '.exe' "$name"
8810             noexename=$func_stripname_result
8811             # $file with .exe has already been added to rmfiles,
8812             # add $file without .exe
8813             rmfiles="$rmfiles $file"
8814             ;;
8815           esac
8816           # Do a test to see if this is a libtool program.
8817           if func_ltwrapper_p "$file"; then
8818             if func_ltwrapper_executable_p "$file"; then
8819               func_ltwrapper_scriptname "$file"
8820               relink_command=
8821               func_source $func_ltwrapper_scriptname_result
8822               rmfiles="$rmfiles $func_ltwrapper_scriptname_result"
8823             else
8824               relink_command=
8825               func_source $dir/$noexename
8826             fi
8827
8828             # note $name still contains .exe if it was in $file originally
8829             # as does the version of $file that was added into $rmfiles
8830             rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
8831             if test "$fast_install" = yes && test -n "$relink_command"; then
8832               rmfiles="$rmfiles $objdir/lt-$name"
8833             fi
8834             if test "X$noexename" != "X$name" ; then
8835               rmfiles="$rmfiles $objdir/lt-${noexename}.c"
8836             fi
8837           fi
8838         fi
8839         ;;
8840       esac
8841       func_show_eval "$RM $rmfiles" 'exit_status=1'
8842     done
8843     objdir="$origobjdir"
8844
8845     # Try to remove the ${objdir}s in the directories where we deleted files
8846     for dir in $rmdirs; do
8847       if test -d "$dir"; then
8848         func_show_eval "rmdir $dir >/dev/null 2>&1"
8849       fi
8850     done
8851
8852     exit $exit_status
8853 }
8854
8855 { test "$mode" = uninstall || test "$mode" = clean; } &&
8856     func_mode_uninstall ${1+"$@"}
8857
8858 test -z "$mode" && {
8859   help="$generic_help"
8860   func_fatal_help "you must specify a MODE"
8861 }
8862
8863 test -z "$exec_cmd" && \
8864   func_fatal_help "invalid operation mode \`$mode'"
8865
8866 if test -n "$exec_cmd"; then
8867   eval exec "$exec_cmd"
8868   exit $EXIT_FAILURE
8869 fi
8870
8871 exit $exit_status
8872
8873
8874 # The TAGs below are defined such that we never get into a situation
8875 # in which we disable both kinds of libraries.  Given conflicting
8876 # choices, we go for a static library, that is the most portable,
8877 # since we can't tell whether shared libraries were disabled because
8878 # the user asked for that or because the platform doesn't support
8879 # them.  This is particularly important on AIX, because we don't
8880 # support having both static and shared libraries enabled at the same
8881 # time on that platform, so we default to a shared-only configuration.
8882 # If a disable-shared tag is given, we'll fallback to a static-only
8883 # configuration.  But we'll never go from static-only to shared-only.
8884
8885 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
8886 build_libtool_libs=no
8887 build_old_libs=yes
8888 # ### END LIBTOOL TAG CONFIG: disable-shared
8889
8890 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
8891 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
8892 # ### END LIBTOOL TAG CONFIG: disable-static
8893
8894 # Local Variables:
8895 # mode:shell-script
8896 # sh-indentation:2
8897 # End:
8898 # vi:sw=2
8899