ltmain.sh

   1 # ltmain.sh - Provide generalized library-building support services.
   2 # NOTE: Changing this file will not affect anything until you rerun configure.
   3 #
   4 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004
   5 # Free Software Foundation, Inc.
   6 # Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
   7 #
   8 # This program is free software; you can redistribute it and/or modify
   9 # it under the terms of the GNU General Public License as published by
  10 # the Free Software Foundation; either version 2 of the License, or
  11 # (at your option) any later version.
  12 #
  13 # This program is distributed in the hope that it will be useful, but
  14 # WITHOUT ANY WARRANTY; without even the implied warranty of
  15 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16 # General Public License for more details.
  17 #
  18 # You should have received a copy of the GNU General Public License
  19 # along with this program; if not, write to the Free Software
  20 # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  21 #
  22 # As a special exception to the GNU General Public License, if you
  23 # distribute this file as part of a program that contains a
  24 # configuration script generated by Autoconf, you may include it under
  25 # the same distribution terms that you use for the rest of that program.
  26
  27 basename="s,^.*/,,g"
  28
  29 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
  30 # is ksh but when the shell is invoked as "sh" and the current value of
  31 # the _XPG environment variable is not equal to 1 (one), the special
  32 # positional parameter $0, within a function call, is the name of the
  33 # function.
  34 progpath="$0"
  35
  36 # RH: define SED for historic ltconfig's generated by Libtool 1.3
  37 [ -z "$SED" ] && SED=sed
  38
  39 # The name of this program:
  40 progname=`echo "$progpath" | $SED $basename`
  41 modename="$progname"
  42
  43 # Global variables:
  44 EXIT_SUCCESS=0
  45 EXIT_FAILURE=1
  46
  47 PROGRAM=ltmain.sh
  48 PACKAGE=libtool
  49 VERSION=1.5.6
  50 TIMESTAMP=" (1.1220.2.95 2004/04/11 05:50:42)"
  51 EGREP="grep -E"
  52
  53
  54 # Check that we have a working $echo.
  55 if test "X$1" = X--no-reexec; then
  56   # Discard the --no-reexec flag, and continue.
  57   shift
  58 elif test "X$1" = X--fallback-echo; then
  59   # Avoid inline document here, it may be left over
  60   :
  61 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
  62   # Yippee, $echo works!
  63   :
  64 else
  65   # Restart under the correct shell, and then maybe $echo will work.
  66   exec $SHELL "$progpath" --no-reexec ${1+"$@"}
  67 fi
  68
  69 if test "X$1" = X--fallback-echo; then
  70   # used as fallback echo
  71   shift
  72   cat <<EOF
  73 $*
  74 EOF
  75   exit $EXIT_SUCCESS
  76 fi
  77
  78 default_mode=
  79 help="Try \`$progname --help' for more information."
  80 magic="%%%MAGIC variable%%%"
  81 mkdir="mkdir"
  82 mv="mv -f"
  83 rm="rm -f"
  84
  85 # Sed substitution that helps us do robust quoting.  It backslashifies
  86 # metacharacters that are still active within double-quoted strings.
  87 Xsed="${SED}"' -e 1s/^X//'
  88 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
  89 # test EBCDIC or ASCII
  90 case `echo A|tr A '\301'` in
  91  A) # EBCDIC based system
  92   SP2NL="tr '\100' '\n'"
  93   NL2SP="tr '\r\n' '\100\100'"
  94   ;;
  95  *) # Assume ASCII based system
  96   SP2NL="tr '\040' '\012'"
  97   NL2SP="tr '\015\012' '\040\040'"
  98   ;;
  99 esac
 100
 101 # NLS nuisances.
 102 # Only set LANG and LC_ALL to C if already set.
 103 # These must not be set unconditionally because not all systems understand
 104 # e.g. LANG=C (notably SCO).
 105 # We save the old values to restore during execute mode.
 106 if test "${LC_ALL+set}" = set; then
 107   save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
 108 fi
 109 if test "${LANG+set}" = set; then
 110   save_LANG="$LANG"; LANG=C; export LANG
 111 fi
 112
 113 # Make sure IFS has a sensible default
 114 : ${IFS="
 115 "}
 116
 117 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
 118   $echo "$modename: not configured to build any kind of library" 1>&2
 119   $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
 120   exit $EXIT_FAILURE
 121 fi
 122
 123 # Global variables.
 124 mode=$default_mode
 125 nonopt=
 126 prev=
 127 prevopt=
 128 run=
 129 show="$echo"
 130 show_help=
 131 execute_dlfiles=
 132 lo2o="s/\\.lo\$/.${objext}/"
 133 o2lo="s/\\.${objext}\$/.lo/"
 134
 135 #####################################
 136 # Shell function definitions:
 137 # This seems to be the best place for them
 138
 139 # func_win32_libid arg
 140 # return the library type of file 'arg'
 141 #
 142 # Need a lot of goo to handle *both* DLLs and import libs
 143 # Has to be a shell function in order to 'eat' the argument
 144 # that is supplied when $file_magic_command is called.
 145 func_win32_libid () {
 146   win32_libid_type="unknown"
 147   win32_fileres=`file -L $1 2>/dev/null`
 148   case $win32_fileres in
 149   *ar\ archive\ import\ library*) # definitely import
 150     win32_libid_type="x86 archive import"
 151     ;;
 152   *ar\ archive*) # could be an import, or static
 153     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
 154       $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
 155       win32_nmres=`eval $NM -f posix -A $1 | \
 156         sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`
 157       if test "X$win32_nmres" = "Ximport" ; then
 158         win32_libid_type="x86 archive import"
 159       else
 160         win32_libid_type="x86 archive static"
 161       fi
 162     fi
 163     ;;
 164   *DLL*)
 165     win32_libid_type="x86 DLL"
 166     ;;
 167   *executable*) # but shell scripts are "executable" too...
 168     case $win32_fileres in
 169     *MS\ Windows\ PE\ Intel*)
 170       win32_libid_type="x86 DLL"
 171       ;;
 172     esac
 173     ;;
 174   esac
 175   $echo $win32_libid_type
 176 }
 177
 178
 179 # func_infer_tag arg
 180 # Infer tagged configuration to use if any are available and
 181 # if one wasn't chosen via the "--tag" command line option.
 182 # Only attempt this if the compiler in the base compile
 183 # command doesn't match the default compiler.
 184 # arg is usually of the form 'gcc ...'
 185 func_infer_tag () {
 186     if test -n "$available_tags" && test -z "$tagname"; then
 187       CC_quoted=
 188       for arg in $CC; do
 189         case $arg in
 190           *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
 191           arg="\"$arg\""
 192           ;;
 193         esac
 194         CC_quoted="$CC_quoted $arg"
 195       done
 196       case $@ in
 197       # Blanks in the command may have been stripped by the calling shell,
 198       # but not from the CC environment variable when configure was run.
 199       " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
 200       # Blanks at the start of $base_compile will cause this to fail
 201       # if we don't check for them as well.
 202       *)
 203         for z in $available_tags; do
 204           if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
 205             # Evaluate the configuration.
 206             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
 207             CC_quoted=
 208             for arg in $CC; do
 209             # Double-quote args containing other shell metacharacters.
 210             case $arg in
 211               *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 212               arg="\"$arg\""
 213               ;;
 214             esac
 215             CC_quoted="$CC_quoted $arg"
 216           done
 217             case "$@ " in
 218               " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
 219               # The compiler in the base compile command matches
 220               # the one in the tagged configuration.
 221               # Assume this is the tagged configuration we want.
 222               tagname=$z
 223               break
 224               ;;
 225             esac
 226           fi
 227         done
 228         # If $tagname still isn't set, then no tagged configuration
 229         # was found and let the user know that the "--tag" command
 230         # line option must be used.
 231         if test -z "$tagname"; then
 232           $echo "$modename: unable to infer tagged configuration"
 233           $echo "$modename: specify a tag with \`--tag'" 1>&2
 234           exit $EXIT_FAILURE
 235 #        else
 236 #          $echo "$modename: using $tagname tagged configuration"
 237         fi
 238         ;;
 239       esac
 240     fi
 241 }
 242 # End of Shell function definitions
 243 #####################################
 244
 245 # Darwin sucks
 246 eval std_shrext=\"$shrext_cmds\"
 247
 248 # Parse our command line options once, thoroughly.
 249 while test "$#" -gt 0
 250 do
 251   arg="$1"
 252   shift
 253
 254   case $arg in
 255   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
 256   *) optarg= ;;
 257   esac
 258
 259   # If the previous option needs an argument, assign it.
 260   if test -n "$prev"; then
 261     case $prev in
 262     execute_dlfiles)
 263       execute_dlfiles="$execute_dlfiles $arg"
 264       ;;
 265     tag)
 266       tagname="$arg"
 267       preserve_args="${preserve_args}=$arg"
 268
 269       # Check whether tagname contains only valid characters
 270       case $tagname in
 271       *[!-_A-Za-z0-9,/]*)
 272         $echo "$progname: invalid tag name: $tagname" 1>&2
 273         exit $EXIT_FAILURE
 274         ;;
 275       esac
 276
 277       case $tagname in
 278       CC)
 279         # Don't test for the "default" C tag, as we know, it's there, but
 280         # not specially marked.
 281         ;;
 282       *)
 283         if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
 284           taglist="$taglist $tagname"
 285           # Evaluate the configuration.
 286           eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
 287         else
 288           $echo "$progname: ignoring unknown tag $tagname" 1>&2
 289         fi
 290         ;;
 291       esac
 292       ;;
 293     *)
 294       eval "$prev=\$arg"
 295       ;;
 296     esac
 297
 298     prev=
 299     prevopt=
 300     continue
 301   fi
 302
 303   # Have we seen a non-optional argument yet?
 304   case $arg in
 305   --help)
 306     show_help=yes
 307     ;;
 308
 309   --version)
 310     $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
 311     $echo
 312     $echo "Copyright (C) 2003  Free Software Foundation, Inc."
 313     $echo "This is free software; see the source for copying conditions.  There is NO"
 314     $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
 315     exit $EXIT_SUCCESS
 316     ;;
 317
 318   --config)
 319     ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
 320     # Now print the configurations for the tags.
 321     for tagname in $taglist; do
 322       ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
 323     done
 324     exit $EXIT_SUCCESS
 325     ;;
 326
 327   --debug)
 328     $echo "$progname: enabling shell trace mode"
 329     set -x
 330     preserve_args="$preserve_args $arg"
 331     ;;
 332
 333   --dry-run | -n)
 334     run=:
 335     ;;
 336
 337   --features)
 338     $echo "host: $host"
 339     if test "$build_libtool_libs" = yes; then
 340       $echo "enable shared libraries"
 341     else
 342       $echo "disable shared libraries"
 343     fi
 344     if test "$build_old_libs" = yes; then
 345       $echo "enable static libraries"
 346     else
 347       $echo "disable static libraries"
 348     fi
 349     exit $EXIT_SUCCESS
 350     ;;
 351
 352   --finish) mode="finish" ;;
 353
 354   --mode) prevopt="--mode" prev=mode ;;
 355   --mode=*) mode="$optarg" ;;
 356
 357   --preserve-dup-deps) duplicate_deps="yes" ;;
 358
 359   --quiet | --silent)
 360     show=:
 361     preserve_args="$preserve_args $arg"
 362     ;;
 363
 364   --tag) prevopt="--tag" prev=tag ;;
 365   --tag=*)
 366     set tag "$optarg" ${1+"$@"}
 367     shift
 368     prev=tag
 369     preserve_args="$preserve_args --tag"
 370     ;;
 371
 372   -dlopen)
 373     prevopt="-dlopen"
 374     prev=execute_dlfiles
 375     ;;
 376
 377   -*)
 378     $echo "$modename: unrecognized option \`$arg'" 1>&2
 379     $echo "$help" 1>&2
 380     exit $EXIT_FAILURE
 381     ;;
 382
 383   *)
 384     nonopt="$arg"
 385     break
 386     ;;
 387   esac
 388 done
 389
 390 if test -n "$prevopt"; then
 391   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
 392   $echo "$help" 1>&2
 393   exit $EXIT_FAILURE
 394 fi
 395
 396 # If this variable is set in any of the actions, the command in it
 397 # will be execed at the end.  This prevents here-documents from being
 398 # left over by shells.
 399 exec_cmd=
 400
 401 if test -z "$show_help"; then
 402
 403   # Infer the operation mode.
 404   if test -z "$mode"; then
 405     $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
 406     $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2
 407     case $nonopt in
 408     *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
 409       mode=link
 410       for arg
 411       do
 412         case $arg in
 413         -c)
 414            mode=compile
 415            break
 416            ;;
 417         esac
 418       done
 419       ;;
 420     *db | *dbx | *strace | *truss)
 421       mode=execute
 422       ;;
 423     *install*|cp|mv)
 424       mode=install
 425       ;;
 426     *rm)
 427       mode=uninstall
 428       ;;
 429     *)
 430       # If we have no mode, but dlfiles were specified, then do execute mode.
 431       test -n "$execute_dlfiles" && mode=execute
 432
 433       # Just use the default operation mode.
 434       if test -z "$mode"; then
 435         if test -n "$nonopt"; then
 436           $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
 437         else
 438           $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
 439         fi
 440       fi
 441       ;;
 442     esac
 443   fi
 444
 445   # Only execute mode is allowed to have -dlopen flags.
 446   if test -n "$execute_dlfiles" && test "$mode" != execute; then
 447     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
 448     $echo "$help" 1>&2
 449     exit $EXIT_FAILURE
 450   fi
 451
 452   # Change the help message to a mode-specific one.
 453   generic_help="$help"
 454   help="Try \`$modename --help --mode=$mode' for more information."
 455
 456   # These modes are in order of execution frequency so that they run quickly.
 457   case $mode in
 458   # libtool compile mode
 459   compile)
 460     modename="$modename: compile"
 461     # Get the compilation command and the source file.
 462     base_compile=
 463     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
 464     suppress_opt=yes
 465     suppress_output=
 466     arg_mode=normal
 467     libobj=
 468     later=
 469
 470     for arg
 471     do
 472       case "$arg_mode" in
 473       arg  )
 474         # do not "continue".  Instead, add this to base_compile
 475         lastarg="$arg"
 476         arg_mode=normal
 477         ;;
 478
 479       target )
 480         libobj="$arg"
 481         arg_mode=normal
 482         continue
 483         ;;
 484
 485       normal )
 486         # Accept any command-line options.
 487         case $arg in
 488         -o)
 489           if test -n "$libobj" ; then
 490             $echo "$modename: you cannot specify \`-o' more than once" 1>&2
 491             exit $EXIT_FAILURE
 492           fi
 493           arg_mode=target
 494           continue
 495           ;;
 496
 497         -static | -prefer-pic | -prefer-non-pic)
 498           later="$later $arg"
 499           continue
 500           ;;
 501
 502         -no-suppress)
 503           suppress_opt=no
 504           continue
 505           ;;
 506
 507         -Xcompiler)
 508           arg_mode=arg  #  the next one goes into the "base_compile" arg list
 509           continue      #  The current "srcfile" will either be retained or
 510           ;;            #  replaced later.  I would guess that would be a bug.
 511
 512         -Wc,*)
 513           args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
 514           lastarg=
 515           save_ifs="$IFS"; IFS=','
 516           for arg in $args; do
 517             IFS="$save_ifs"
 518
 519             # Double-quote args containing other shell metacharacters.
 520             # Many Bourne shells cannot handle close brackets correctly
 521             # in scan sets, so we specify it separately.
 522             case $arg in
 523               *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 524               arg="\"$arg\""
 525               ;;
 526             esac
 527             lastarg="$lastarg $arg"
 528           done
 529           IFS="$save_ifs"
 530           lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
 531
 532           # Add the arguments to base_compile.
 533           base_compile="$base_compile $lastarg"
 534           continue
 535           ;;
 536
 537         * )
 538           # Accept the current argument as the source file.
 539           # The previous "srcfile" becomes the current argument.
 540           #
 541           lastarg="$srcfile"
 542           srcfile="$arg"
 543           ;;
 544         esac  #  case $arg
 545         ;;
 546       esac    #  case $arg_mode
 547
 548       # Aesthetically quote the previous argument.
 549       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
 550
 551       case $lastarg in
 552       # Double-quote args containing other shell metacharacters.
 553       # Many Bourne shells cannot handle close brackets correctly
 554       # in scan sets, so we specify it separately.
 555       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 556         lastarg="\"$lastarg\""
 557         ;;
 558       esac
 559
 560       base_compile="$base_compile $lastarg"
 561     done # for arg
 562
 563     case $arg_mode in
 564     arg)
 565       $echo "$modename: you must specify an argument for -Xcompile"
 566       exit $EXIT_FAILURE
 567       ;;
 568     target)
 569       $echo "$modename: you must specify a target with \`-o'" 1>&2
 570       exit $EXIT_FAILURE
 571       ;;
 572     *)
 573       # Get the name of the library object.
 574       [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
 575       ;;
 576     esac
 577
 578     # Recognize several different file suffixes.
 579     # If the user specifies -o file.o, it is replaced with file.lo
 580     xform='[cCFSifmso]'
 581     case $libobj in
 582     *.ada) xform=ada ;;
 583     *.adb) xform=adb ;;
 584     *.ads) xform=ads ;;
 585     *.asm) xform=asm ;;
 586     *.c++) xform=c++ ;;
 587     *.cc) xform=cc ;;
 588     *.ii) xform=ii ;;
 589     *.class) xform=class ;;
 590     *.cpp) xform=cpp ;;
 591     *.cxx) xform=cxx ;;
 592     *.f90) xform=f90 ;;
 593     *.for) xform=for ;;
 594     *.java) xform=java ;;
 595     esac
 596
 597     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
 598
 599     case $libobj in
 600     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
 601     *)
 602       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
 603       exit $EXIT_FAILURE
 604       ;;
 605     esac
 606
 607     func_infer_tag $base_compile
 608
 609     for arg in $later; do
 610       case $arg in
 611       -static)
 612         build_old_libs=yes
 613         continue
 614         ;;
 615
 616       -prefer-pic)
 617         pic_mode=yes
 618         continue
 619         ;;
 620
 621       -prefer-non-pic)
 622         pic_mode=no
 623         continue
 624         ;;
 625       esac
 626     done
 627
 628     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
 629     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
 630     if test "X$xdir" = "X$obj"; then
 631       xdir=
 632     else
 633       xdir=$xdir/
 634     fi
 635     lobj=${xdir}$objdir/$objname
 636
 637     if test -z "$base_compile"; then
 638       $echo "$modename: you must specify a compilation command" 1>&2
 639       $echo "$help" 1>&2
 640       exit $EXIT_FAILURE
 641     fi
 642
 643     # Delete any leftover library objects.
 644     if test "$build_old_libs" = yes; then
 645       removelist="$obj $lobj $libobj ${libobj}T"
 646     else
 647       removelist="$lobj $libobj ${libobj}T"
 648     fi
 649
 650     $run $rm $removelist
 651     trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
 652
 653     # On Cygwin there's no "real" PIC flag so we must build both object types
 654     case $host_os in
 655     cygwin* | mingw* | pw32* | os2*)
 656       pic_mode=default
 657       ;;
 658     esac
 659     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
 660       # non-PIC code in shared libraries is not supported
 661       pic_mode=default
 662     fi
 663
 664     # Calculate the filename of the output object if compiler does
 665     # not support -o with -c
 666     if test "$compiler_c_o" = no; then
 667       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
 668       lockfile="$output_obj.lock"
 669       removelist="$removelist $output_obj $lockfile"
 670       trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
 671     else
 672       output_obj=
 673       need_locks=no
 674       lockfile=
 675     fi
 676
 677     # Lock this critical section if it is needed
 678     # We use this script file to make the link, it avoids creating a new file
 679     if test "$need_locks" = yes; then
 680       until $run ln "$progpath" "$lockfile" 2>/dev/null; do
 681         $show "Waiting for $lockfile to be removed"
 682         sleep 2
 683       done
 684     elif test "$need_locks" = warn; then
 685       if test -f "$lockfile"; then
 686         $echo "\
 687 *** ERROR, $lockfile exists and contains:
 688 `cat $lockfile 2>/dev/null`
 689
 690 This indicates that another process is trying to use the same
 691 temporary object file, and libtool could not work around it because
 692 your compiler does not support \`-c' and \`-o' together.  If you
 693 repeat this compilation, it may succeed, by chance, but you had better
 694 avoid parallel builds (make -j) in this platform, or get a better
 695 compiler."
 696
 697         $run $rm $removelist
 698         exit $EXIT_FAILURE
 699       fi
 700       $echo $srcfile > "$lockfile"
 701     fi
 702
 703     if test -n "$fix_srcfile_path"; then
 704       eval srcfile=\"$fix_srcfile_path\"
 705     fi
 706
 707     $run $rm "$libobj" "${libobj}T"
 708
 709     # Create a libtool object file (analogous to a ".la" file),
 710     # but don't create it if we're doing a dry run.
 711     test -z "$run" && cat > ${libobj}T <<EOF
 712 # $libobj - a libtool object file
 713 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 714 #
 715 # Please DO NOT delete this file!
 716 # It is necessary for linking the library.
 717
 718 # Name of the PIC object.
 719 EOF
 720
 721     # Only build a PIC object if we are building libtool libraries.
 722     if test "$build_libtool_libs" = yes; then
 723       # Without this assignment, base_compile gets emptied.
 724       fbsd_hideous_sh_bug=$base_compile
 725
 726       if test "$pic_mode" != no; then
 727         command="$base_compile $srcfile $pic_flag"
 728       else
 729         # Don't build PIC code
 730         command="$base_compile $srcfile"
 731       fi
 732
 733       if test ! -d "${xdir}$objdir"; then
 734         $show "$mkdir ${xdir}$objdir"
 735         $run $mkdir ${xdir}$objdir
 736         status=$?
 737         if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
 738           exit $status
 739         fi
 740       fi
 741
 742       if test -z "$output_obj"; then
 743         # Place PIC objects in $objdir
 744         command="$command -o $lobj"
 745       fi
 746
 747       $run $rm "$lobj" "$output_obj"
 748
 749       $show "$command"
 750       if $run eval "$command"; then :
 751       else
 752         test -n "$output_obj" && $run $rm $removelist
 753         exit $EXIT_FAILURE
 754       fi
 755
 756       if test "$need_locks" = warn &&
 757          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 758         $echo "\
 759 *** ERROR, $lockfile contains:
 760 `cat $lockfile 2>/dev/null`
 761
 762 but it should contain:
 763 $srcfile
 764
 765 This indicates that another process is trying to use the same
 766 temporary object file, and libtool could not work around it because
 767 your compiler does not support \`-c' and \`-o' together.  If you
 768 repeat this compilation, it may succeed, by chance, but you had better
 769 avoid parallel builds (make -j) in this platform, or get a better
 770 compiler."
 771
 772         $run $rm $removelist
 773         exit $EXIT_FAILURE
 774       fi
 775
 776       # Just move the object if needed, then go on to compile the next one
 777       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
 778         $show "$mv $output_obj $lobj"
 779         if $run $mv $output_obj $lobj; then :
 780         else
 781           error=$?
 782           $run $rm $removelist
 783           exit $error
 784         fi
 785       fi
 786
 787       # Append the name of the PIC object to the libtool object file.
 788       test -z "$run" && cat >> ${libobj}T <<EOF
 789 pic_object='$objdir/$objname'
 790
 791 EOF
 792
 793       # Allow error messages only from the first compilation.
 794       if test "$suppress_opt" = yes; then
 795         suppress_output=' >/dev/null 2>&1'
 796       fi
 797     else
 798       # No PIC object so indicate it doesn't exist in the libtool
 799       # object file.
 800       test -z "$run" && cat >> ${libobj}T <<EOF
 801 pic_object=none
 802
 803 EOF
 804     fi
 805
 806     # Only build a position-dependent object if we build old libraries.
 807     if test "$build_old_libs" = yes; then
 808       if test "$pic_mode" != yes; then
 809         # Don't build PIC code
 810         command="$base_compile $srcfile"
 811       else
 812         command="$base_compile $srcfile $pic_flag"
 813       fi
 814       if test "$compiler_c_o" = yes; then
 815         command="$command -o $obj"
 816       fi
 817
 818       # Suppress compiler output if we already did a PIC compilation.
 819       command="$command$suppress_output"
 820       $run $rm "$obj" "$output_obj"
 821       $show "$command"
 822       if $run eval "$command"; then :
 823       else
 824         $run $rm $removelist
 825         exit $EXIT_FAILURE
 826       fi
 827
 828       if test "$need_locks" = warn &&
 829          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 830         $echo "\
 831 *** ERROR, $lockfile contains:
 832 `cat $lockfile 2>/dev/null`
 833
 834 but it should contain:
 835 $srcfile
 836
 837 This indicates that another process is trying to use the same
 838 temporary object file, and libtool could not work around it because
 839 your compiler does not support \`-c' and \`-o' together.  If you
 840 repeat this compilation, it may succeed, by chance, but you had better
 841 avoid parallel builds (make -j) in this platform, or get a better
 842 compiler."
 843
 844         $run $rm $removelist
 845         exit $EXIT_FAILURE
 846       fi
 847
 848       # Just move the object if needed
 849       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
 850         $show "$mv $output_obj $obj"
 851         if $run $mv $output_obj $obj; then :
 852         else
 853           error=$?
 854           $run $rm $removelist
 855           exit $error
 856         fi
 857       fi
 858
 859       # Append the name of the non-PIC object the libtool object file.
 860       # Only append if the libtool object file exists.
 861       test -z "$run" && cat >> ${libobj}T <<EOF
 862 # Name of the non-PIC object.
 863 non_pic_object='$objname'
 864
 865 EOF
 866     else
 867       # Append the name of the non-PIC object the libtool object file.
 868       # Only append if the libtool object file exists.
 869       test -z "$run" && cat >> ${libobj}T <<EOF
 870 # Name of the non-PIC object.
 871 non_pic_object=none
 872
 873 EOF
 874     fi
 875
 876     $run $mv "${libobj}T" "${libobj}"
 877
 878     # Unlock the critical section if it was locked
 879     if test "$need_locks" != no; then
 880       $run $rm "$lockfile"
 881     fi
 882
 883     exit $EXIT_SUCCESS
 884     ;;
 885
 886   # libtool link mode
 887   link | relink)
 888     modename="$modename: link"
 889     case $host in
 890     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 891       # It is impossible to link a dll without this setting, and
 892       # we shouldn't force the makefile maintainer to figure out
 893       # which system we are compiling for in order to pass an extra
 894       # flag for every libtool invocation.
 895       # allow_undefined=no
 896
 897       # FIXME: Unfortunately, there are problems with the above when trying
 898       # to make a dll which has undefined symbols, in which case not
 899       # even a static library is built.  For now, we need to specify
 900       # -no-undefined on the libtool link line when we can be certain
 901       # that all symbols are satisfied, otherwise we get a static library.
 902       allow_undefined=yes
 903       ;;
 904     *)
 905       allow_undefined=yes
 906       ;;
 907     esac
 908     libtool_args="$nonopt"
 909     base_compile="$nonopt $@"
 910     compile_command="$nonopt"
 911     finalize_command="$nonopt"
 912
 913     compile_rpath=
 914     finalize_rpath=
 915     compile_shlibpath=
 916     finalize_shlibpath=
 917     convenience=
 918     old_convenience=
 919     deplibs=
 920     old_deplibs=
 921     compiler_flags=
 922     linker_flags=
 923     dllsearchpath=
 924     lib_search_path=`pwd`
 925     inst_prefix_dir=
 926
 927     avoid_version=no
 928     dlfiles=
 929     dlprefiles=
 930     dlself=no
 931     export_dynamic=no
 932     export_symbols=
 933     export_symbols_regex=
 934     generated=
 935     libobjs=
 936     ltlibs=
 937     module=no
 938     no_install=no
 939     objs=
 940     non_pic_objects=
 941     precious_files_regex=
 942     prefer_static_libs=no
 943     preload=no
 944     prev=
 945     prevarg=
 946     release=
 947     rpath=
 948     xrpath=
 949     perm_rpath=
 950     temp_rpath=
 951     thread_safe=no
 952     vinfo=
 953     vinfo_number=no
 954
 955     func_infer_tag $base_compile
 956
 957     # We need to know -static, to get the right output filenames.
 958     for arg
 959     do
 960       case $arg in
 961       -all-static | -static)
 962         if test "X$arg" = "X-all-static"; then
 963           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
 964             $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
 965           fi
 966           if test -n "$link_static_flag"; then
 967             dlopen_self=$dlopen_self_static
 968           fi
 969         else
 970           if test -z "$pic_flag" && test -n "$link_static_flag"; then
 971             dlopen_self=$dlopen_self_static
 972           fi
 973         fi
 974         build_libtool_libs=no
 975         build_old_libs=yes
 976         prefer_static_libs=yes
 977         break
 978         ;;
 979       esac
 980     done
 981
 982     # See if our shared archives depend on static archives.
 983     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
 984
 985     # Go through the arguments, transforming them on the way.
 986     while test "$#" -gt 0; do
 987       arg="$1"
 988       shift
 989       case $arg in
 990       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 991         qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
 992         ;;
 993       *) qarg=$arg ;;
 994       esac
 995       libtool_args="$libtool_args $qarg"
 996
 997       # If the previous option needs an argument, assign it.
 998       if test -n "$prev"; then
 999         case $prev in
1000         output)
1001           compile_command="$compile_command @OUTPUT@"
1002           finalize_command="$finalize_command @OUTPUT@"
1003           ;;
1004         esac
1005
1006         case $prev in
1007         dlfiles|dlprefiles)
1008           if test "$preload" = no; then
1009             # Add the symbol object into the linking commands.
1010             compile_command="$compile_command @SYMFILE@"
1011             finalize_command="$finalize_command @SYMFILE@"
1012             preload=yes
1013           fi
1014           case $arg in
1015           *.la | *.lo) ;;  # We handle these cases below.
1016           force)
1017             if test "$dlself" = no; then
1018               dlself=needless
1019               export_dynamic=yes
1020             fi
1021             prev=
1022             continue
1023             ;;
1024           self)
1025             if test "$prev" = dlprefiles; then
1026               dlself=yes
1027             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
1028               dlself=yes
1029             else
1030               dlself=needless
1031               export_dynamic=yes
1032             fi
1033             prev=
1034             continue
1035             ;;
1036           *)
1037             if test "$prev" = dlfiles; then
1038               dlfiles="$dlfiles $arg"
1039             else
1040               dlprefiles="$dlprefiles $arg"
1041             fi
1042             prev=
1043             continue
1044             ;;
1045           esac
1046           ;;
1047         expsyms)
1048           export_symbols="$arg"
1049           if test ! -f "$arg"; then
1050             $echo "$modename: symbol file \`$arg' does not exist"
1051             exit $EXIT_FAILURE
1052           fi
1053           prev=
1054           continue
1055           ;;
1056         expsyms_regex)
1057           export_symbols_regex="$arg"
1058           prev=
1059           continue
1060           ;;
1061         inst_prefix)
1062           inst_prefix_dir="$arg"
1063           prev=
1064           continue
1065           ;;
1066         precious_regex)
1067           precious_files_regex="$arg"
1068           prev=
1069           continue
1070           ;;
1071         release)
1072           release="-$arg"
1073           prev=
1074           continue
1075           ;;
1076         objectlist)
1077           if test -f "$arg"; then
1078             save_arg=$arg
1079             moreargs=
1080             for fil in `cat $save_arg`
1081             do
1082 #             moreargs="$moreargs $fil"
1083               arg=$fil
1084               # A libtool-controlled object.
1085
1086               # Check to see that this really is a libtool object.
1087               if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1088                 pic_object=
1089                 non_pic_object=
1090
1091                 # Read the .lo file
1092                 # If there is no directory component, then add one.
1093                 case $arg in
1094                 */* | *\\*) . $arg ;;
1095                 *) . ./$arg ;;
1096                 esac
1097
1098                 if test -z "$pic_object" || \
1099                    test -z "$non_pic_object" ||
1100                    test "$pic_object" = none && \
1101                    test "$non_pic_object" = none; then
1102                   $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1103                   exit $EXIT_FAILURE
1104                 fi
1105
1106                 # Extract subdirectory from the argument.
1107                 xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1108                 if test "X$xdir" = "X$arg"; then
1109                   xdir=
1110                 else
1111                   xdir="$xdir/"
1112                 fi
1113
1114                 if test "$pic_object" != none; then
1115                   # Prepend the subdirectory the object is found in.
1116                   pic_object="$xdir$pic_object"
1117
1118                   if test "$prev" = dlfiles; then
1119                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1120                       dlfiles="$dlfiles $pic_object"
1121                       prev=
1122                       continue
1123                     else
1124                       # If libtool objects are unsupported, then we need to preload.
1125                       prev=dlprefiles
1126                     fi
1127                   fi
1128
1129                   # CHECK ME:  I think I busted this.  -Ossama
1130                   if test "$prev" = dlprefiles; then
1131                     # Preload the old-style object.
1132                     dlprefiles="$dlprefiles $pic_object"
1133                     prev=
1134                   fi
1135
1136                   # A PIC object.
1137                   libobjs="$libobjs $pic_object"
1138                   arg="$pic_object"
1139                 fi
1140
1141                 # Non-PIC object.
1142                 if test "$non_pic_object" != none; then
1143                   # Prepend the subdirectory the object is found in.
1144                   non_pic_object="$xdir$non_pic_object"
1145
1146                   # A standard non-PIC object
1147                   non_pic_objects="$non_pic_objects $non_pic_object"
1148                   if test -z "$pic_object" || test "$pic_object" = none ; then
1149                     arg="$non_pic_object"
1150                   fi
1151                 fi
1152               else
1153                 # Only an error if not doing a dry-run.
1154                 if test -z "$run"; then
1155                   $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1156                   exit $EXIT_FAILURE
1157                 else
1158                   # Dry-run case.
1159
1160                   # Extract subdirectory from the argument.
1161                   xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1162                   if test "X$xdir" = "X$arg"; then
1163                     xdir=
1164                   else
1165                     xdir="$xdir/"
1166                   fi
1167
1168                   pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1169                   non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1170                   libobjs="$libobjs $pic_object"
1171                   non_pic_objects="$non_pic_objects $non_pic_object"
1172                 fi
1173               fi
1174             done
1175           else
1176             $echo "$modename: link input file \`$save_arg' does not exist"
1177             exit $EXIT_FAILURE
1178           fi
1179           arg=$save_arg
1180           prev=
1181           continue
1182           ;;
1183         rpath | xrpath)
1184           # We need an absolute path.
1185           case $arg in
1186           [\\/]* | [A-Za-z]:[\\/]*) ;;
1187           *)
1188             $echo "$modename: only absolute run-paths are allowed" 1>&2
1189             exit $EXIT_FAILURE
1190             ;;
1191           esac
1192           if test "$prev" = rpath; then
1193             case "$rpath " in
1194             *" $arg "*) ;;
1195             *) rpath="$rpath $arg" ;;
1196             esac
1197           else
1198             case "$xrpath " in
1199             *" $arg "*) ;;
1200             *) xrpath="$xrpath $arg" ;;
1201             esac
1202           fi
1203           prev=
1204           continue
1205           ;;
1206         xcompiler)
1207           compiler_flags="$compiler_flags $qarg"
1208           prev=
1209           compile_command="$compile_command $qarg"
1210           finalize_command="$finalize_command $qarg"
1211           continue
1212           ;;
1213         xlinker)
1214           linker_flags="$linker_flags $qarg"
1215           compiler_flags="$compiler_flags $wl$qarg"
1216           prev=
1217           compile_command="$compile_command $wl$qarg"
1218           finalize_command="$finalize_command $wl$qarg"
1219           continue
1220           ;;
1221         xcclinker)
1222           linker_flags="$linker_flags $qarg"
1223           compiler_flags="$compiler_flags $qarg"
1224           prev=
1225           compile_command="$compile_command $qarg"
1226           finalize_command="$finalize_command $qarg"
1227           continue
1228           ;;
1229         shrext)
1230           shrext_cmds="$arg"
1231           prev=
1232           continue
1233           ;;
1234         *)
1235           eval "$prev=\"\$arg\""
1236           prev=
1237           continue
1238           ;;
1239         esac
1240       fi # test -n "$prev"
1241
1242       prevarg="$arg"
1243
1244       case $arg in
1245       -all-static)
1246         if test -n "$link_static_flag"; then
1247           compile_command="$compile_command $link_static_flag"
1248           finalize_command="$finalize_command $link_static_flag"
1249         fi
1250         continue
1251         ;;
1252
1253       -allow-undefined)
1254         # FIXME: remove this flag sometime in the future.
1255         $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1256         continue
1257         ;;
1258
1259       -avoid-version)
1260         avoid_version=yes
1261         continue
1262         ;;
1263
1264       -dlopen)
1265         prev=dlfiles
1266         continue
1267         ;;
1268
1269       -dlpreopen)
1270         prev=dlprefiles
1271         continue
1272         ;;
1273
1274       -export-dynamic)
1275         export_dynamic=yes
1276         continue
1277         ;;
1278
1279       -export-symbols | -export-symbols-regex)
1280         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1281           $echo "$modename: more than one -exported-symbols argument is not allowed"
1282           exit $EXIT_FAILURE
1283         fi
1284         if test "X$arg" = "X-export-symbols"; then
1285           prev=expsyms
1286         else
1287           prev=expsyms_regex
1288         fi
1289         continue
1290         ;;
1291
1292       -inst-prefix-dir)
1293         prev=inst_prefix
1294         continue
1295         ;;
1296
1297       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1298       # so, if we see these flags be careful not to treat them like -L
1299       -L[A-Z][A-Z]*:*)
1300         case $with_gcc/$host in
1301         no/*-*-irix* | /*-*-irix*)
1302           compile_command="$compile_command $arg"
1303           finalize_command="$finalize_command $arg"
1304           ;;
1305         esac
1306         continue
1307         ;;
1308
1309       -L*)
1310         dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1311         # We need an absolute path.
1312         case $dir in
1313         [\\/]* | [A-Za-z]:[\\/]*) ;;
1314         *)
1315           absdir=`cd "$dir" && pwd`
1316           if test -z "$absdir"; then
1317             $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1318             exit $EXIT_FAILURE
1319           fi
1320           dir="$absdir"
1321           ;;
1322         esac
1323         case "$deplibs " in
1324         *" -L$dir "*) ;;
1325         *)
1326           deplibs="$deplibs -L$dir"
1327           lib_search_path="$lib_search_path $dir"
1328           ;;
1329         esac
1330         case $host in
1331         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1332           case :$dllsearchpath: in
1333           *":$dir:"*) ;;
1334           *) dllsearchpath="$dllsearchpath:$dir";;
1335           esac
1336           ;;
1337         esac
1338         continue
1339         ;;
1340
1341       -l*)
1342         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1343           case $host in
1344           *-*-cygwin* | *-*-pw32* | *-*-beos*)
1345             # These systems don't actually have a C or math library (as such)
1346             continue
1347             ;;
1348           *-*-mingw* | *-*-os2*)
1349             # These systems don't actually have a C library (as such)
1350             test "X$arg" = "X-lc" && continue
1351             ;;
1352           *-*-openbsd* | *-*-freebsd*)
1353             # Do not include libc due to us having libc/libc_r.
1354             test "X$arg" = "X-lc" && continue
1355             ;;
1356           *-*-rhapsody* | *-*-darwin1.[012])
1357             # Rhapsody C and math libraries are in the System framework
1358             deplibs="$deplibs -framework System"
1359             continue
1360           esac
1361         elif test "X$arg" = "X-lc_r"; then
1362          case $host in
1363          *-*-openbsd* | *-*-freebsd*)
1364            # Do not include libc_r directly, use -pthread flag.
1365            continue
1366            ;;
1367          esac
1368         fi
1369         deplibs="$deplibs $arg"
1370         continue
1371         ;;
1372
1373      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1374         deplibs="$deplibs $arg"
1375         continue
1376         ;;
1377
1378       -module)
1379         module=yes
1380         continue
1381         ;;
1382
1383       # gcc -m* arguments should be passed to the linker via $compiler_flags
1384       # in order to pass architecture information to the linker
1385       # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
1386       # but this is not reliable with gcc because gcc may use -mfoo to
1387       # select a different linker, different libraries, etc, while
1388       # -Wl,-mfoo simply passes -mfoo to the linker.
1389       -m*)
1390         # Unknown arguments in both finalize_command and compile_command need
1391         # to be aesthetically quoted because they are evaled later.
1392         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1393         case $arg in
1394         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1395           arg="\"$arg\""
1396           ;;
1397         esac
1398         compile_command="$compile_command $arg"
1399         finalize_command="$finalize_command $arg"
1400         if test "$with_gcc" = "yes" ; then
1401           compiler_flags="$compiler_flags $arg"
1402         fi
1403         continue
1404         ;;
1405
1406       -shrext)
1407         prev=shrext
1408         continue
1409         ;;
1410
1411       -no-fast-install)
1412         fast_install=no
1413         continue
1414         ;;
1415
1416       -no-install)
1417         case $host in
1418         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1419           # The PATH hackery in wrapper scripts is required on Windows
1420           # in order for the loader to find any dlls it needs.
1421           $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1422           $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1423           fast_install=no
1424           ;;
1425         *) no_install=yes ;;
1426         esac
1427         continue
1428         ;;
1429
1430       -no-undefined)
1431         allow_undefined=no
1432         continue
1433         ;;
1434
1435       -objectlist)
1436         prev=objectlist
1437         continue
1438         ;;
1439
1440       -o) prev=output ;;
1441
1442       -precious-files-regex)
1443         prev=precious_regex
1444         continue
1445         ;;
1446
1447       -release)
1448         prev=release
1449         continue
1450         ;;
1451
1452       -rpath)
1453         prev=rpath
1454         continue
1455         ;;
1456
1457       -R)
1458         prev=xrpath
1459         continue
1460         ;;
1461
1462       -R*)
1463         dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1464         # We need an absolute path.
1465         case $dir in
1466         [\\/]* | [A-Za-z]:[\\/]*) ;;
1467         *)
1468           $echo "$modename: only absolute run-paths are allowed" 1>&2
1469           exit $EXIT_FAILURE
1470           ;;
1471         esac
1472         case "$xrpath " in
1473         *" $dir "*) ;;
1474         *) xrpath="$xrpath $dir" ;;
1475         esac
1476         continue
1477         ;;
1478
1479       -static)
1480         # The effects of -static are defined in a previous loop.
1481         # We used to do the same as -all-static on platforms that
1482         # didn't have a PIC flag, but the assumption that the effects
1483         # would be equivalent was wrong.  It would break on at least
1484         # Digital Unix and AIX.
1485         continue
1486         ;;
1487
1488       -thread-safe)
1489         thread_safe=yes
1490         continue
1491         ;;
1492
1493       -version-info)
1494         prev=vinfo
1495         continue
1496         ;;
1497       -version-number)
1498         prev=vinfo
1499         vinfo_number=yes
1500         continue
1501         ;;
1502
1503       -Wc,*)
1504         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1505         arg=
1506         save_ifs="$IFS"; IFS=','
1507         for flag in $args; do
1508           IFS="$save_ifs"
1509           case $flag in
1510             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1511             flag="\"$flag\""
1512             ;;
1513           esac
1514           arg="$arg $wl$flag"
1515           compiler_flags="$compiler_flags $flag"
1516         done
1517         IFS="$save_ifs"
1518         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1519         ;;
1520
1521       -Wl,*)
1522         args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1523         arg=
1524         save_ifs="$IFS"; IFS=','
1525         for flag in $args; do
1526           IFS="$save_ifs"
1527           case $flag in
1528             *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1529             flag="\"$flag\""
1530             ;;
1531           esac
1532           arg="$arg $wl$flag"
1533           compiler_flags="$compiler_flags $wl$flag"
1534           linker_flags="$linker_flags $flag"
1535         done
1536         IFS="$save_ifs"
1537         arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1538         ;;
1539
1540       -Xcompiler)
1541         prev=xcompiler
1542         continue
1543         ;;
1544
1545       -Xlinker)
1546         prev=xlinker
1547         continue
1548         ;;
1549
1550       -XCClinker)
1551         prev=xcclinker
1552         continue
1553         ;;
1554
1555       # Some other compiler flag.
1556       -* | +*)
1557         # Unknown arguments in both finalize_command and compile_command need
1558         # to be aesthetically quoted because they are evaled later.
1559         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1560         case $arg in
1561         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1562           arg="\"$arg\""
1563           ;;
1564         esac
1565         ;;
1566
1567       *.$objext)
1568         # A standard object.
1569         objs="$objs $arg"
1570         ;;
1571
1572       *.lo)
1573         # A libtool-controlled object.
1574
1575         # Check to see that this really is a libtool object.
1576         if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1577           pic_object=
1578           non_pic_object=
1579
1580           # Read the .lo file
1581           # If there is no directory component, then add one.
1582           case $arg in
1583           */* | *\\*) . $arg ;;
1584           *) . ./$arg ;;
1585           esac
1586
1587           if test -z "$pic_object" || \
1588              test -z "$non_pic_object" ||
1589              test "$pic_object" = none && \
1590              test "$non_pic_object" = none; then
1591             $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1592             exit $EXIT_FAILURE
1593           fi
1594
1595           # Extract subdirectory from the argument.
1596           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1597           if test "X$xdir" = "X$arg"; then
1598             xdir=
1599           else
1600             xdir="$xdir/"
1601           fi
1602
1603           if test "$pic_object" != none; then
1604             # Prepend the subdirectory the object is found in.
1605             pic_object="$xdir$pic_object"
1606
1607             if test "$prev" = dlfiles; then
1608               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1609                 dlfiles="$dlfiles $pic_object"
1610                 prev=
1611                 continue
1612               else
1613                 # If libtool objects are unsupported, then we need to preload.
1614                 prev=dlprefiles
1615               fi
1616             fi
1617
1618             # CHECK ME:  I think I busted this.  -Ossama
1619             if test "$prev" = dlprefiles; then
1620               # Preload the old-style object.
1621               dlprefiles="$dlprefiles $pic_object"
1622               prev=
1623             fi
1624
1625             # A PIC object.
1626             libobjs="$libobjs $pic_object"
1627             arg="$pic_object"
1628           fi
1629
1630           # Non-PIC object.
1631           if test "$non_pic_object" != none; then
1632             # Prepend the subdirectory the object is found in.
1633             non_pic_object="$xdir$non_pic_object"
1634
1635             # A standard non-PIC object
1636             non_pic_objects="$non_pic_objects $non_pic_object"
1637             if test -z "$pic_object" || test "$pic_object" = none ; then
1638               arg="$non_pic_object"
1639             fi
1640           fi
1641         else
1642           # Only an error if not doing a dry-run.
1643           if test -z "$run"; then
1644             $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1645             exit $EXIT_FAILURE
1646           else
1647             # Dry-run case.
1648
1649             # Extract subdirectory from the argument.
1650             xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1651             if test "X$xdir" = "X$arg"; then
1652               xdir=
1653             else
1654               xdir="$xdir/"
1655             fi
1656
1657             pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1658             non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1659             libobjs="$libobjs $pic_object"
1660             non_pic_objects="$non_pic_objects $non_pic_object"
1661           fi
1662         fi
1663         ;;
1664
1665       *.$libext)
1666         # An archive.
1667         deplibs="$deplibs $arg"
1668         old_deplibs="$old_deplibs $arg"
1669         continue
1670         ;;
1671
1672       *.la)
1673         # A libtool-controlled library.
1674
1675         if test "$prev" = dlfiles; then
1676           # This library was specified with -dlopen.
1677           dlfiles="$dlfiles $arg"
1678           prev=
1679         elif test "$prev" = dlprefiles; then
1680           # The library was specified with -dlpreopen.
1681           dlprefiles="$dlprefiles $arg"
1682           prev=
1683         else
1684           deplibs="$deplibs $arg"
1685         fi
1686         continue
1687         ;;
1688
1689       # Some other compiler argument.
1690       *)
1691         # Unknown arguments in both finalize_command and compile_command need
1692         # to be aesthetically quoted because they are evaled later.
1693         arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1694         case $arg in
1695         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1696           arg="\"$arg\""
1697           ;;
1698         esac
1699         ;;
1700       esac # arg
1701
1702       # Now actually substitute the argument into the commands.
1703       if test -n "$arg"; then
1704         compile_command="$compile_command $arg"
1705         finalize_command="$finalize_command $arg"
1706       fi
1707     done # argument parsing loop
1708
1709     if test -n "$prev"; then
1710       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1711       $echo "$help" 1>&2
1712       exit $EXIT_FAILURE
1713     fi
1714
1715     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1716       eval arg=\"$export_dynamic_flag_spec\"
1717       compile_command="$compile_command $arg"
1718       finalize_command="$finalize_command $arg"
1719     fi
1720
1721     oldlibs=
1722     # calculate the name of the file, without its directory
1723     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1724     libobjs_save="$libobjs"
1725
1726     if test -n "$shlibpath_var"; then
1727       # get the directories listed in $shlibpath_var
1728       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1729     else
1730       shlib_search_path=
1731     fi
1732     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1733     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1734
1735     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1736     if test "X$output_objdir" = "X$output"; then
1737       output_objdir="$objdir"
1738     else
1739       output_objdir="$output_objdir/$objdir"
1740     fi
1741     # Create the object directory.
1742     if test ! -d "$output_objdir"; then
1743       $show "$mkdir $output_objdir"
1744       $run $mkdir $output_objdir
1745       status=$?
1746       if test "$status" -ne 0 && test ! -d "$output_objdir"; then
1747         exit $status
1748       fi
1749     fi
1750
1751     # Determine the type of output
1752     case $output in
1753     "")
1754       $echo "$modename: you must specify an output file" 1>&2
1755       $echo "$help" 1>&2
1756       exit $EXIT_FAILURE
1757       ;;
1758     *.$libext) linkmode=oldlib ;;
1759     *.lo | *.$objext) linkmode=obj ;;
1760     *.la) linkmode=lib ;;
1761     *) linkmode=prog ;; # Anything else should be a program.
1762     esac
1763
1764     case $host in
1765     *cygwin* | *mingw* | *pw32*)
1766       # don't eliminate duplications in $postdeps and $predeps
1767       duplicate_compiler_generated_deps=yes
1768       ;;
1769     *)
1770       duplicate_compiler_generated_deps=$duplicate_deps
1771       ;;
1772     esac
1773     specialdeplibs=
1774
1775     libs=
1776     # Find all interdependent deplibs by searching for libraries
1777     # that are linked more than once (e.g. -la -lb -la)
1778     for deplib in $deplibs; do
1779       if test "X$duplicate_deps" = "Xyes" ; then
1780         case "$libs " in
1781         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1782         esac
1783       fi
1784       libs="$libs $deplib"
1785     done
1786
1787     if test "$linkmode" = lib; then
1788       libs="$predeps $libs $compiler_lib_search_path $postdeps"
1789
1790       # Compute libraries that are listed more than once in $predeps
1791       # $postdeps and mark them as special (i.e., whose duplicates are
1792       # not to be eliminated).
1793       pre_post_deps=
1794       if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
1795         for pre_post_dep in $predeps $postdeps; do
1796           case "$pre_post_deps " in
1797           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1798           esac
1799           pre_post_deps="$pre_post_deps $pre_post_dep"
1800         done
1801       fi
1802       pre_post_deps=
1803     fi
1804
1805     deplibs=
1806     newdependency_libs=
1807     newlib_search_path=
1808     need_relink=no # whether we're linking any uninstalled libtool libraries
1809     notinst_deplibs= # not-installed libtool libraries
1810     notinst_path= # paths that contain not-installed libtool libraries
1811     case $linkmode in
1812     lib)
1813         passes="conv link"
1814         for file in $dlfiles $dlprefiles; do
1815           case $file in
1816           *.la) ;;
1817           *)
1818             $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1819             exit $EXIT_FAILURE
1820             ;;
1821           esac
1822         done
1823         ;;
1824     prog)
1825         compile_deplibs=
1826         finalize_deplibs=
1827         alldeplibs=no
1828         newdlfiles=
1829         newdlprefiles=
1830         passes="conv scan dlopen dlpreopen link"
1831         ;;
1832     *)  passes="conv"
1833         ;;
1834     esac
1835     for pass in $passes; do
1836       if test "$linkmode,$pass" = "lib,link" ||
1837          test "$linkmode,$pass" = "prog,scan"; then
1838         libs="$deplibs"
1839         deplibs=
1840       fi
1841       if test "$linkmode" = prog; then
1842         case $pass in
1843         dlopen) libs="$dlfiles" ;;
1844         dlpreopen) libs="$dlprefiles" ;;
1845         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1846         esac
1847       fi
1848       if test "$pass" = dlopen; then
1849         # Collect dlpreopened libraries
1850         save_deplibs="$deplibs"
1851         deplibs=
1852       fi
1853       for deplib in $libs; do
1854         lib=
1855         found=no
1856         case $deplib in
1857         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1858           if test "$linkmode,$pass" = "prog,link"; then
1859             compile_deplibs="$deplib $compile_deplibs"
1860             finalize_deplibs="$deplib $finalize_deplibs"
1861           else
1862             deplibs="$deplib $deplibs"
1863           fi
1864           continue
1865           ;;
1866         -l*)
1867           if test "$linkmode" != lib && test "$linkmode" != prog; then
1868             $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
1869             continue
1870           fi
1871           if test "$pass" = conv; then
1872             deplibs="$deplib $deplibs"
1873             continue
1874           fi
1875           name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1876           for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1877             for search_ext in .la $std_shrext .so .a; do
1878               # Search the libtool library
1879               lib="$searchdir/lib${name}${search_ext}"
1880               if test -f "$lib"; then
1881                 if test "$search_ext" = ".la"; then
1882                   found=yes
1883                 else
1884                   found=no
1885                 fi
1886                 break 2
1887               fi
1888             done
1889           done
1890           if test "$found" != yes; then
1891             # deplib doesn't seem to be a libtool library
1892             if test "$linkmode,$pass" = "prog,link"; then
1893               compile_deplibs="$deplib $compile_deplibs"
1894               finalize_deplibs="$deplib $finalize_deplibs"
1895             else
1896               deplibs="$deplib $deplibs"
1897               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1898             fi
1899             continue
1900           else # deplib is a libtool library
1901             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
1902             # We need to do some special things here, and not later.
1903             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
1904               case " $predeps $postdeps " in
1905               *" $deplib "*)
1906                 if (${SED} -e '2q' $lib |
1907                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1908                   library_names=
1909                   old_library=
1910                   case $lib in
1911                   */* | *\\*) . $lib ;;
1912                   *) . ./$lib ;;
1913                   esac
1914                   for l in $old_library $library_names; do
1915                     ll="$l"
1916                   done
1917                   if test "X$ll" = "X$old_library" ; then # only static version available
1918                     found=no
1919                     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1920                     test "X$ladir" = "X$lib" && ladir="."
1921                     lib=$ladir/$old_library
1922                     if test "$linkmode,$pass" = "prog,link"; then
1923                       compile_deplibs="$deplib $compile_deplibs"
1924                       finalize_deplibs="$deplib $finalize_deplibs"
1925                     else
1926                       deplibs="$deplib $deplibs"
1927                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1928                     fi
1929                     continue
1930                   fi
1931                 fi
1932                 ;;
1933               *) ;;
1934               esac
1935             fi
1936           fi
1937           ;; # -l
1938         -L*)
1939           case $linkmode in
1940           lib)
1941             deplibs="$deplib $deplibs"
1942             test "$pass" = conv && continue
1943             newdependency_libs="$deplib $newdependency_libs"
1944             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1945             ;;
1946           prog)
1947             if test "$pass" = conv; then
1948               deplibs="$deplib $deplibs"
1949               continue
1950             fi
1951             if test "$pass" = scan; then
1952               deplibs="$deplib $deplibs"
1953             else
1954               compile_deplibs="$deplib $compile_deplibs"
1955               finalize_deplibs="$deplib $finalize_deplibs"
1956             fi
1957             newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1958             ;;
1959           *)
1960             $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
1961             ;;
1962           esac # linkmode
1963           continue
1964           ;; # -L
1965         -R*)
1966           if test "$pass" = link; then
1967             dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1968             # Make sure the xrpath contains only unique directories.
1969             case "$xrpath " in
1970             *" $dir "*) ;;
1971             *) xrpath="$xrpath $dir" ;;
1972             esac
1973           fi
1974           deplibs="$deplib $deplibs"
1975           continue
1976           ;;
1977         *.la) lib="$deplib" ;;
1978         *.$libext)
1979           if test "$pass" = conv; then
1980             deplibs="$deplib $deplibs"
1981             continue
1982           fi
1983           case $linkmode in
1984           lib)
1985             if test "$deplibs_check_method" != pass_all; then
1986               $echo
1987               $echo "*** Warning: Trying to link with static lib archive $deplib."
1988               $echo "*** I have the capability to make that library automatically link in when"
1989               $echo "*** you link to this library.  But I can only do this if you have a"
1990               $echo "*** shared version of the library, which you do not appear to have"
1991               $echo "*** because the file extensions .$libext of this argument makes me believe"
1992               $echo "*** that it is just a static archive that I should not used here."
1993             else
1994               $echo
1995               $echo "*** Warning: Linking the shared library $output against the"
1996               $echo "*** static library $deplib is not portable!"
1997               deplibs="$deplib $deplibs"
1998             fi
1999             continue
2000             ;;
2001           prog)
2002             if test "$pass" != link; then
2003               deplibs="$deplib $deplibs"
2004             else
2005               compile_deplibs="$deplib $compile_deplibs"
2006               finalize_deplibs="$deplib $finalize_deplibs"
2007             fi
2008             continue
2009             ;;
2010           esac # linkmode
2011           ;; # *.$libext
2012         *.lo | *.$objext)
2013           if test "$pass" = conv; then
2014             deplibs="$deplib $deplibs"
2015           elif test "$linkmode" = prog; then
2016             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2017               # If there is no dlopen support or we're linking statically,
2018               # we need to preload.
2019               newdlprefiles="$newdlprefiles $deplib"
2020               compile_deplibs="$deplib $compile_deplibs"
2021               finalize_deplibs="$deplib $finalize_deplibs"
2022             else
2023               newdlfiles="$newdlfiles $deplib"
2024             fi
2025           fi
2026           continue
2027           ;;
2028         %DEPLIBS%)
2029           alldeplibs=yes
2030           continue
2031           ;;
2032         esac # case $deplib
2033         if test "$found" = yes || test -f "$lib"; then :
2034         else
2035           $echo "$modename: cannot find the library \`$lib'" 1>&2
2036           exit $EXIT_FAILURE
2037         fi
2038
2039         # Check to see that this really is a libtool archive.
2040         if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2041         else
2042           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2043           exit $EXIT_FAILURE
2044         fi
2045
2046         ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2047         test "X$ladir" = "X$lib" && ladir="."
2048
2049         dlname=
2050         dlopen=
2051         dlpreopen=
2052         libdir=
2053         library_names=
2054         old_library=
2055         # If the library was installed with an old release of libtool,
2056         # it will not redefine variables installed, or shouldnotlink
2057         installed=yes
2058         shouldnotlink=no
2059
2060         # Read the .la file
2061         case $lib in
2062         */* | *\\*) . $lib ;;
2063         *) . ./$lib ;;
2064         esac
2065
2066         if test "$linkmode,$pass" = "lib,link" ||
2067            test "$linkmode,$pass" = "prog,scan" ||
2068            { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2069           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2070           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2071         fi
2072
2073         if test "$pass" = conv; then
2074           # Only check for convenience libraries
2075           deplibs="$lib $deplibs"
2076           if test -z "$libdir"; then
2077             if test -z "$old_library"; then
2078               $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2079               exit $EXIT_FAILURE
2080             fi
2081             # It is a libtool convenience library, so add in its objects.
2082             convenience="$convenience $ladir/$objdir/$old_library"
2083             old_convenience="$old_convenience $ladir/$objdir/$old_library"
2084             tmp_libs=
2085             for deplib in $dependency_libs; do
2086               deplibs="$deplib $deplibs"
2087               if test "X$duplicate_deps" = "Xyes" ; then
2088                 case "$tmp_libs " in
2089                 *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2090                 esac
2091               fi
2092               tmp_libs="$tmp_libs $deplib"
2093             done
2094           elif test "$linkmode" != prog && test "$linkmode" != lib; then
2095             $echo "$modename: \`$lib' is not a convenience library" 1>&2
2096             exit $EXIT_FAILURE
2097           fi
2098           continue
2099         fi # $pass = conv
2100
2101
2102         # Get the name of the library we link against.
2103         linklib=
2104         for l in $old_library $library_names; do
2105           linklib="$l"
2106         done
2107         if test -z "$linklib"; then
2108           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2109           exit $EXIT_FAILURE
2110         fi
2111
2112         # This library was specified with -dlopen.
2113         if test "$pass" = dlopen; then
2114           if test -z "$libdir"; then
2115             $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2116             exit $EXIT_FAILURE
2117           fi
2118           if test -z "$dlname" ||
2119              test "$dlopen_support" != yes ||
2120              test "$build_libtool_libs" = no; then
2121             # If there is no dlname, no dlopen support or we're linking
2122             # statically, we need to preload.  We also need to preload any
2123             # dependent libraries so libltdl's deplib preloader doesn't
2124             # bomb out in the load deplibs phase.
2125             dlprefiles="$dlprefiles $lib $dependency_libs"
2126           else
2127             newdlfiles="$newdlfiles $lib"
2128           fi
2129           continue
2130         fi # $pass = dlopen
2131
2132         # We need an absolute path.
2133         case $ladir in
2134         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2135         *)
2136           abs_ladir=`cd "$ladir" && pwd`
2137           if test -z "$abs_ladir"; then
2138             $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2139             $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2140             abs_ladir="$ladir"
2141           fi
2142           ;;
2143         esac
2144         laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2145
2146         # Find the relevant object directory and library name.
2147         if test "X$installed" = Xyes; then
2148           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2149             $echo "$modename: warning: library \`$lib' was moved." 1>&2
2150             dir="$ladir"
2151             absdir="$abs_ladir"
2152             libdir="$abs_ladir"
2153           else
2154             dir="$libdir"
2155             absdir="$libdir"
2156           fi
2157         else
2158           dir="$ladir/$objdir"
2159           absdir="$abs_ladir/$objdir"
2160           # Remove this search path later
2161           notinst_path="$notinst_path $abs_ladir"
2162         fi # $installed = yes
2163         name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2164
2165         # This library was specified with -dlpreopen.
2166         if test "$pass" = dlpreopen; then
2167           if test -z "$libdir"; then
2168             $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2169             exit $EXIT_FAILURE
2170           fi
2171           # Prefer using a static library (so that no silly _DYNAMIC symbols
2172           # are required to link).
2173           if test -n "$old_library"; then
2174             newdlprefiles="$newdlprefiles $dir/$old_library"
2175           # Otherwise, use the dlname, so that lt_dlopen finds it.
2176           elif test -n "$dlname"; then
2177             newdlprefiles="$newdlprefiles $dir/$dlname"
2178           else
2179             newdlprefiles="$newdlprefiles $dir/$linklib"
2180           fi
2181         fi # $pass = dlpreopen
2182
2183         if test -z "$libdir"; then
2184           # Link the convenience library
2185           if test "$linkmode" = lib; then
2186             deplibs="$dir/$old_library $deplibs"
2187           elif test "$linkmode,$pass" = "prog,link"; then
2188             compile_deplibs="$dir/$old_library $compile_deplibs"
2189             finalize_deplibs="$dir/$old_library $finalize_deplibs"
2190           else
2191             deplibs="$lib $deplibs" # used for prog,scan pass
2192           fi
2193           continue
2194         fi
2195
2196
2197         if test "$linkmode" = prog && test "$pass" != link; then
2198           newlib_search_path="$newlib_search_path $ladir"
2199           deplibs="$lib $deplibs"
2200
2201           linkalldeplibs=no
2202           if test "$link_all_deplibs" != no || test -z "$library_names" ||
2203              test "$build_libtool_libs" = no; then
2204             linkalldeplibs=yes
2205           fi
2206
2207           tmp_libs=
2208           for deplib in $dependency_libs; do
2209             case $deplib in
2210             -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2211             esac
2212             # Need to link against all dependency_libs?
2213             if test "$linkalldeplibs" = yes; then
2214               deplibs="$deplib $deplibs"
2215             else
2216               # Need to hardcode shared library paths
2217               # or/and link against static libraries
2218               newdependency_libs="$deplib $newdependency_libs"
2219             fi
2220             if test "X$duplicate_deps" = "Xyes" ; then
2221               case "$tmp_libs " in
2222               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2223               esac
2224             fi
2225             tmp_libs="$tmp_libs $deplib"
2226           done # for deplib
2227           continue
2228         fi # $linkmode = prog...
2229
2230         if test "$linkmode,$pass" = "prog,link"; then
2231           if test -n "$library_names" &&
2232              { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2233             # We need to hardcode the library path
2234             if test -n "$shlibpath_var"; then
2235               # Make sure the rpath contains only unique directories.
2236               case "$temp_rpath " in
2237               *" $dir "*) ;;
2238               *" $absdir "*) ;;
2239               *) temp_rpath="$temp_rpath $dir" ;;
2240               esac
2241             fi
2242
2243             # Hardcode the library path.
2244             # Skip directories that are in the system default run-time
2245             # search path.
2246             case " $sys_lib_dlsearch_path " in
2247             *" $absdir "*) ;;
2248             *)
2249               case "$compile_rpath " in
2250               *" $absdir "*) ;;
2251               *) compile_rpath="$compile_rpath $absdir"
2252               esac
2253               ;;
2254             esac
2255             case " $sys_lib_dlsearch_path " in
2256             *" $libdir "*) ;;
2257             *)
2258               case "$finalize_rpath " in
2259               *" $libdir "*) ;;
2260               *) finalize_rpath="$finalize_rpath $libdir"
2261               esac
2262               ;;
2263             esac
2264           fi # $linkmode,$pass = prog,link...
2265
2266           if test "$alldeplibs" = yes &&
2267              { test "$deplibs_check_method" = pass_all ||
2268                { test "$build_libtool_libs" = yes &&
2269                  test -n "$library_names"; }; }; then
2270             # We only need to search for static libraries
2271             continue
2272           fi
2273         fi
2274
2275         link_static=no # Whether the deplib will be linked statically
2276         if test -n "$library_names" &&
2277            { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2278           if test "$installed" = no; then
2279             notinst_deplibs="$notinst_deplibs $lib"
2280             need_relink=yes
2281           fi
2282           # This is a shared library
2283
2284           # Warn about portability, can't link against -module's on
2285           # some systems (darwin)
2286           if test "$shouldnotlink" = yes && test "$pass" = link ; then
2287             $echo
2288             if test "$linkmode" = prog; then
2289               $echo "*** Warning: Linking the executable $output against the loadable module"
2290             else
2291               $echo "*** Warning: Linking the shared library $output against the loadable module"
2292             fi
2293             $echo "*** $linklib is not portable!"
2294           fi
2295           if test "$linkmode" = lib &&
2296              test "$hardcode_into_libs" = yes; then
2297             # Hardcode the library path.
2298             # Skip directories that are in the system default run-time
2299             # search path.
2300             case " $sys_lib_dlsearch_path " in
2301             *" $absdir "*) ;;
2302             *)
2303               case "$compile_rpath " in
2304               *" $absdir "*) ;;
2305               *) compile_rpath="$compile_rpath $absdir"
2306               esac
2307               ;;
2308             esac
2309             case " $sys_lib_dlsearch_path " in
2310             *" $libdir "*) ;;
2311             *)
2312               case "$finalize_rpath " in
2313               *" $libdir "*) ;;
2314               *) finalize_rpath="$finalize_rpath $libdir"
2315               esac
2316               ;;
2317             esac
2318           fi
2319
2320           if test -n "$old_archive_from_expsyms_cmds"; then
2321             # figure out the soname
2322             set dummy $library_names
2323             realname="$2"
2324             shift; shift
2325             libname=`eval \\$echo \"$libname_spec\"`
2326             # use dlname if we got it. it's perfectly good, no?
2327             if test -n "$dlname"; then
2328               soname="$dlname"
2329             elif test -n "$soname_spec"; then
2330               # bleh windows
2331               case $host in
2332               *cygwin* | mingw*)
2333                 major=`expr $current - $age`
2334                 versuffix="-$major"
2335                 ;;
2336               esac
2337               eval soname=\"$soname_spec\"
2338             else
2339               soname="$realname"
2340             fi
2341
2342             # Make a new name for the extract_expsyms_cmds to use
2343             soroot="$soname"
2344             soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2345             newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2346
2347             # If the library has no export list, then create one now
2348             if test -f "$output_objdir/$soname-def"; then :
2349             else
2350               $show "extracting exported symbol list from \`$soname'"
2351               save_ifs="$IFS"; IFS='~'
2352               cmds=$extract_expsyms_cmds
2353               for cmd in $cmds; do
2354                 IFS="$save_ifs"
2355                 eval cmd=\"$cmd\"
2356                 $show "$cmd"
2357                 $run eval "$cmd" || exit $?
2358               done
2359               IFS="$save_ifs"
2360             fi
2361
2362             # Create $newlib
2363             if test -f "$output_objdir/$newlib"; then :; else
2364               $show "generating import library for \`$soname'"
2365               save_ifs="$IFS"; IFS='~'
2366               cmds=$old_archive_from_expsyms_cmds
2367               for cmd in $cmds; do
2368                 IFS="$save_ifs"
2369                 eval cmd=\"$cmd\"
2370                 $show "$cmd"
2371                 $run eval "$cmd" || exit $?
2372               done
2373               IFS="$save_ifs"
2374             fi
2375             # make sure the library variables are pointing to the new library
2376             dir=$output_objdir
2377             linklib=$newlib
2378           fi # test -n "$old_archive_from_expsyms_cmds"
2379
2380           if test "$linkmode" = prog || test "$mode" != relink; then
2381             add_shlibpath=
2382             add_dir=
2383             add=
2384             lib_linked=yes
2385             case $hardcode_action in
2386             immediate | unsupported)
2387               if test "$hardcode_direct" = no; then
2388                 add="$dir/$linklib"
2389                 case $host in
2390                   *-*-sco3.2v5* ) add_dir="-L$dir" ;;
2391                   *-*-darwin* )
2392                     # if the lib is a module then we can not link against
2393                     # it, someone is ignoring the new warnings I added
2394                     if /usr/bin/file -L $add 2> /dev/null | $EGREP "bundle" >/dev/null ; then
2395                       $echo "** Warning, lib $linklib is a module, not a shared library"
2396                       if test -z "$old_library" ; then
2397                         $echo
2398                         $echo "** And there doesn't seem to be a static archive available"
2399                         $echo "** The link will probably fail, sorry"
2400                       else
2401                         add="$dir/$old_library"
2402                       fi
2403                     fi
2404                 esac
2405               elif test "$hardcode_minus_L" = no; then
2406                 case $host in
2407                 *-*-sunos*) add_shlibpath="$dir" ;;
2408                 esac
2409                 add_dir="-L$dir"
2410                 add="-l$name"
2411               elif test "$hardcode_shlibpath_var" = no; then
2412                 add_shlibpath="$dir"
2413                 add="-l$name"
2414               else
2415                 lib_linked=no
2416               fi
2417               ;;
2418             relink)
2419               if test "$hardcode_direct" = yes; then
2420                 add="$dir/$linklib"
2421               elif test "$hardcode_minus_L" = yes; then
2422                 add_dir="-L$dir"
2423                 # Try looking first in the location we're being installed to.
2424                 if test -n "$inst_prefix_dir"; then
2425                   case "$libdir" in
2426                     [\\/]*)
2427                       add_dir="$add_dir -L$inst_prefix_dir$libdir"
2428                       ;;
2429                   esac
2430                 fi
2431                 add="-l$name"
2432               elif test "$hardcode_shlibpath_var" = yes; then
2433                 add_shlibpath="$dir"
2434                 add="-l$name"
2435               else
2436                 lib_linked=no
2437               fi
2438               ;;
2439             *) lib_linked=no ;;
2440             esac
2441
2442             if test "$lib_linked" != yes; then
2443               $echo "$modename: configuration error: unsupported hardcode properties"
2444               exit $EXIT_FAILURE
2445             fi
2446
2447             if test -n "$add_shlibpath"; then
2448               case :$compile_shlibpath: in
2449               *":$add_shlibpath:"*) ;;
2450               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2451               esac
2452             fi
2453             if test "$linkmode" = prog; then
2454               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2455               test -n "$add" && compile_deplibs="$add $compile_deplibs"
2456             else
2457               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2458               test -n "$add" && deplibs="$add $deplibs"
2459               if test "$hardcode_direct" != yes && \
2460                  test "$hardcode_minus_L" != yes && \
2461                  test "$hardcode_shlibpath_var" = yes; then
2462                 case :$finalize_shlibpath: in
2463                 *":$libdir:"*) ;;
2464                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2465                 esac
2466               fi
2467             fi
2468           fi
2469
2470           if test "$linkmode" = prog || test "$mode" = relink; then
2471             add_shlibpath=
2472             add_dir=
2473             add=
2474             # Finalize command for both is simple: just hardcode it.
2475             if test "$hardcode_direct" = yes; then
2476               add="$libdir/$linklib"
2477             elif test "$hardcode_minus_L" = yes; then
2478               add_dir="-L$libdir"
2479               add="-l$name"
2480             elif test "$hardcode_shlibpath_var" = yes; then
2481               case :$finalize_shlibpath: in
2482               *":$libdir:"*) ;;
2483               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2484               esac
2485               add="-l$name"
2486             elif test "$hardcode_automatic" = yes; then
2487               if test -n "$inst_prefix_dir" &&
2488                  test -f "$inst_prefix_dir$libdir/$linklib" ; then
2489                 add="$inst_prefix_dir$libdir/$linklib"
2490               else
2491                 add="$libdir/$linklib"
2492               fi
2493             else
2494               # We cannot seem to hardcode it, guess we'll fake it.
2495               add_dir="-L$libdir"
2496               # Try looking first in the location we're being installed to.
2497               if test -n "$inst_prefix_dir"; then
2498                 case "$libdir" in
2499                   [\\/]*)
2500                     add_dir="$add_dir -L$inst_prefix_dir$libdir"
2501                     ;;
2502                 esac
2503               fi
2504               add="-l$name"
2505             fi
2506
2507             if test "$linkmode" = prog; then
2508               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2509               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2510             else
2511               test -n "$add_dir" && deplibs="$add_dir $deplibs"
2512               test -n "$add" && deplibs="$add $deplibs"
2513             fi
2514           fi
2515         elif test "$linkmode" = prog; then
2516           # Here we assume that one of hardcode_direct or hardcode_minus_L
2517           # is not unsupported.  This is valid on all known static and
2518           # shared platforms.
2519           if test "$hardcode_direct" != unsupported; then
2520             test -n "$old_library" && linklib="$old_library"
2521             compile_deplibs="$dir/$linklib $compile_deplibs"
2522             finalize_deplibs="$dir/$linklib $finalize_deplibs"
2523           else
2524             compile_deplibs="-l$name -L$dir $compile_deplibs"
2525             finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2526           fi
2527         elif test "$build_libtool_libs" = yes; then
2528           # Not a shared library
2529           if test "$deplibs_check_method" != pass_all; then
2530             # We're trying link a shared library against a static one
2531             # but the system doesn't support it.
2532
2533             # Just print a warning and add the library to dependency_libs so
2534             # that the program can be linked against the static library.
2535             $echo
2536             $echo "*** Warning: This system can not link to static lib archive $lib."
2537             $echo "*** I have the capability to make that library automatically link in when"
2538             $echo "*** you link to this library.  But I can only do this if you have a"
2539             $echo "*** shared version of the library, which you do not appear to have."
2540             if test "$module" = yes; then
2541               $echo "*** But as you try to build a module library, libtool will still create "
2542               $echo "*** a static module, that should work as long as the dlopening application"
2543               $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2544               if test -z "$global_symbol_pipe"; then
2545                 $echo
2546                 $echo "*** However, this would only work if libtool was able to extract symbol"
2547                 $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2548                 $echo "*** not find such a program.  So, this module is probably useless."
2549                 $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2550               fi
2551               if test "$build_old_libs" = no; then
2552                 build_libtool_libs=module
2553                 build_old_libs=yes
2554               else
2555                 build_libtool_libs=no
2556               fi
2557             fi
2558           else
2559             convenience="$convenience $dir/$old_library"
2560             old_convenience="$old_convenience $dir/$old_library"
2561             deplibs="$dir/$old_library $deplibs"
2562             link_static=yes
2563           fi
2564         fi # link shared/static library?
2565
2566         if test "$linkmode" = lib; then
2567           if test -n "$dependency_libs" &&
2568              { test "$hardcode_into_libs" != yes ||
2569                test "$build_old_libs" = yes ||
2570                test "$link_static" = yes; }; then
2571             # Extract -R from dependency_libs
2572             temp_deplibs=
2573             for libdir in $dependency_libs; do
2574               case $libdir in
2575               -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2576                    case " $xrpath " in
2577                    *" $temp_xrpath "*) ;;
2578                    *) xrpath="$xrpath $temp_xrpath";;
2579                    esac;;
2580               *) temp_deplibs="$temp_deplibs $libdir";;
2581               esac
2582             done
2583             dependency_libs="$temp_deplibs"
2584           fi
2585
2586           newlib_search_path="$newlib_search_path $absdir"
2587           # Link against this library
2588           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2589           # ... and its dependency_libs
2590           tmp_libs=
2591           for deplib in $dependency_libs; do
2592             newdependency_libs="$deplib $newdependency_libs"
2593             if test "X$duplicate_deps" = "Xyes" ; then
2594               case "$tmp_libs " in
2595               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2596               esac
2597             fi
2598             tmp_libs="$tmp_libs $deplib"
2599           done
2600
2601           if test "$link_all_deplibs" != no; then
2602             # Add the search paths of all dependency libraries
2603             for deplib in $dependency_libs; do
2604               case $deplib in
2605               -L*) path="$deplib" ;;
2606               *.la)
2607                 dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2608                 test "X$dir" = "X$deplib" && dir="."
2609                 # We need an absolute path.
2610                 case $dir in
2611                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2612                 *)
2613                   absdir=`cd "$dir" && pwd`
2614                   if test -z "$absdir"; then
2615                     $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2616                     absdir="$dir"
2617                   fi
2618                   ;;
2619                 esac
2620                 if grep "^installed=no" $deplib > /dev/null; then
2621                   path="$absdir/$objdir"
2622                 else
2623                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2624                   if test -z "$libdir"; then
2625                     $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2626                     exit $EXIT_FAILURE
2627                   fi
2628                   if test "$absdir" != "$libdir"; then
2629                     $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2630                   fi
2631                   path="$absdir"
2632                 fi
2633                 depdepl=
2634                 case $host in
2635                 *-*-darwin*)
2636                   # we do not want to link against static libs,
2637                   # but need to link against shared
2638                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2639                   if test -n "$deplibrary_names" ; then
2640                     for tmp in $deplibrary_names ; do
2641                       depdepl=$tmp
2642                     done
2643                     if test -f "$path/$depdepl" ; then
2644                       depdepl="$path/$depdepl"
2645                     fi
2646                     # do not add paths which are already there
2647                     case " $newlib_search_path " in
2648                     *" $path "*) ;;
2649                     *) newlib_search_path="$newlib_search_path $path";;
2650                     esac
2651                   fi
2652                   path=""
2653                   ;;
2654                 *)
2655                   path="-L$path"
2656                   ;;
2657                 esac
2658                 ;;
2659               -l*)
2660                 case $host in
2661                 *-*-darwin*)
2662                   # Again, we only want to link against shared libraries
2663                   eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2664                   for tmp in $newlib_search_path ; do
2665                     if test -f "$tmp/lib$tmp_libs.dylib" ; then
2666                       eval depdepl="$tmp/lib$tmp_libs.dylib"
2667                       break
2668                     fi
2669                   done
2670                   path=""
2671                   ;;
2672                 *) continue ;;
2673                 esac
2674                 ;;
2675               *) continue ;;
2676               esac
2677               case " $deplibs " in
2678               *" $depdepl "*) ;;
2679               *) deplibs="$depdepl $deplibs" ;;
2680               esac
2681               case " $deplibs " in
2682               *" $path "*) ;;
2683               *) deplibs="$deplibs $path" ;;
2684               esac
2685             done
2686           fi # link_all_deplibs != no
2687         fi # linkmode = lib
2688       done # for deplib in $libs
2689       dependency_libs="$newdependency_libs"
2690       if test "$pass" = dlpreopen; then
2691         # Link the dlpreopened libraries before other libraries
2692         for deplib in $save_deplibs; do
2693           deplibs="$deplib $deplibs"
2694         done
2695       fi
2696       if test "$pass" != dlopen; then
2697         if test "$pass" != conv; then
2698           # Make sure lib_search_path contains only unique directories.
2699           lib_search_path=
2700           for dir in $newlib_search_path; do
2701             case "$lib_search_path " in
2702             *" $dir "*) ;;
2703             *) lib_search_path="$lib_search_path $dir" ;;
2704             esac
2705           done
2706           newlib_search_path=
2707         fi
2708
2709         if test "$linkmode,$pass" != "prog,link"; then
2710           vars="deplibs"
2711         else
2712           vars="compile_deplibs finalize_deplibs"
2713         fi
2714         for var in $vars dependency_libs; do
2715           # Add libraries to $var in reverse order
2716           eval tmp_libs=\"\$$var\"
2717           new_libs=
2718           for deplib in $tmp_libs; do
2719             # FIXME: Pedantically, this is the right thing to do, so
2720             #        that some nasty dependency loop isn't accidentally
2721             #        broken:
2722             #new_libs="$deplib $new_libs"
2723             # Pragmatically, this seems to cause very few problems in
2724             # practice:
2725             case $deplib in
2726             -L*) new_libs="$deplib $new_libs" ;;
2727             -R*) ;;
2728             *)
2729               # And here is the reason: when a library appears more
2730               # than once as an explicit dependence of a library, or
2731               # is implicitly linked in more than once by the
2732               # compiler, it is considered special, and multiple
2733               # occurrences thereof are not removed.  Compare this
2734               # with having the same library being listed as a
2735               # dependency of multiple other libraries: in this case,
2736               # we know (pedantically, we assume) the library does not
2737               # need to be listed more than once, so we keep only the
2738               # last copy.  This is not always right, but it is rare
2739               # enough that we require users that really mean to play
2740               # such unportable linking tricks to link the library
2741               # using -Wl,-lname, so that libtool does not consider it
2742               # for duplicate removal.
2743               case " $specialdeplibs " in
2744               *" $deplib "*) new_libs="$deplib $new_libs" ;;
2745               *)
2746                 case " $new_libs " in
2747                 *" $deplib "*) ;;
2748                 *) new_libs="$deplib $new_libs" ;;
2749                 esac
2750                 ;;
2751               esac
2752               ;;
2753             esac
2754           done
2755           tmp_libs=
2756           for deplib in $new_libs; do
2757             case $deplib in
2758             -L*)
2759               case " $tmp_libs " in
2760               *" $deplib "*) ;;
2761               *) tmp_libs="$tmp_libs $deplib" ;;
2762               esac
2763               ;;
2764             *) tmp_libs="$tmp_libs $deplib" ;;
2765             esac
2766           done
2767           eval $var=\"$tmp_libs\"
2768         done # for var
2769       fi
2770       # Last step: remove runtime libs from dependency_libs
2771       # (they stay in deplibs)
2772       tmp_libs=
2773       for i in $dependency_libs ; do
2774         case " $predeps $postdeps $compiler_lib_search_path " in
2775         *" $i "*)
2776           i=""
2777           ;;
2778         esac
2779         if test -n "$i" ; then
2780           tmp_libs="$tmp_libs $i"
2781         fi
2782       done
2783       dependency_libs=$tmp_libs
2784     done # for pass
2785     if test "$linkmode" = prog; then
2786       dlfiles="$newdlfiles"
2787       dlprefiles="$newdlprefiles"
2788     fi
2789
2790     case $linkmode in
2791     oldlib)
2792       if test -n "$deplibs"; then
2793         $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
2794       fi
2795
2796       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2797         $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2798       fi
2799
2800       if test -n "$rpath"; then
2801         $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2802       fi
2803
2804       if test -n "$xrpath"; then
2805         $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2806       fi
2807
2808       if test -n "$vinfo"; then
2809         $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
2810       fi
2811
2812       if test -n "$release"; then
2813         $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2814       fi
2815
2816       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2817         $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2818       fi
2819
2820       # Now set the variables for building old libraries.
2821       build_libtool_libs=no
2822       oldlibs="$output"
2823       objs="$objs$old_deplibs"
2824       ;;
2825
2826     lib)
2827       # Make sure we only generate libraries of the form `libNAME.la'.
2828       case $outputname in
2829       lib*)
2830         name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2831         eval shared_ext=\"$shrext_cmds\"
2832         eval libname=\"$libname_spec\"
2833         ;;
2834       *)
2835         if test "$module" = no; then
2836           $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2837           $echo "$help" 1>&2
2838           exit $EXIT_FAILURE
2839         fi
2840         if test "$need_lib_prefix" != no; then
2841           # Add the "lib" prefix for modules if required
2842           name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2843           eval shared_ext=\"$shrext_cmds\"
2844           eval libname=\"$libname_spec\"
2845         else
2846           libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2847         fi
2848         ;;
2849       esac
2850
2851       if test -n "$objs"; then
2852         if test "$deplibs_check_method" != pass_all; then
2853           $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2854           exit $EXIT_FAILURE
2855         else
2856           $echo
2857           $echo "*** Warning: Linking the shared library $output against the non-libtool"
2858           $echo "*** objects $objs is not portable!"
2859           libobjs="$libobjs $objs"
2860         fi
2861       fi
2862
2863       if test "$dlself" != no; then
2864         $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2865       fi
2866
2867       set dummy $rpath
2868       if test "$#" -gt 2; then
2869         $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2870       fi
2871       install_libdir="$2"
2872
2873       oldlibs=
2874       if test -z "$rpath"; then
2875         if test "$build_libtool_libs" = yes; then
2876           # Building a libtool convenience library.
2877           # Some compilers have problems with a `.al' extension so
2878           # convenience libraries should have the same extension an
2879           # archive normally would.
2880           oldlibs="$output_objdir/$libname.$libext $oldlibs"
2881           build_libtool_libs=convenience
2882           build_old_libs=yes
2883         fi
2884
2885         if test -n "$vinfo"; then
2886           $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
2887         fi
2888
2889         if test -n "$release"; then
2890           $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2891         fi
2892       else
2893
2894         # Parse the version information argument.
2895         save_ifs="$IFS"; IFS=':'
2896         set dummy $vinfo 0 0 0
2897         IFS="$save_ifs"
2898
2899         if test -n "$8"; then
2900           $echo "$modename: too many parameters to \`-version-info'" 1>&2
2901           $echo "$help" 1>&2
2902           exit $EXIT_FAILURE
2903         fi
2904
2905         # convert absolute version numbers to libtool ages
2906         # this retains compatibility with .la files and attempts
2907         # to make the code below a bit more comprehensible
2908
2909         case $vinfo_number in
2910         yes)
2911           number_major="$2"
2912           number_minor="$3"
2913           number_revision="$4"
2914           #
2915           # There are really only two kinds -- those that
2916           # use the current revision as the major version
2917           # and those that subtract age and use age as
2918           # a minor version.  But, then there is irix
2919           # which has an extra 1 added just for fun
2920           #
2921           case $version_type in
2922           darwin|linux|osf|windows)
2923             current=`expr $number_major + $number_minor`
2924             age="$number_minor"
2925             revision="$number_revision"
2926             ;;
2927           freebsd-aout|freebsd-elf|sunos)
2928             current="$number_major"
2929             revision="$number_minor"
2930             age="0"
2931             ;;
2932           irix|nonstopux)
2933             current=`expr $number_major + $number_minor - 1`
2934             age="$number_minor"
2935             revision="$number_minor"
2936             ;;
2937           esac
2938           ;;
2939         no)
2940           current="$2"
2941           revision="$3"
2942           age="$4"
2943           ;;
2944         esac
2945
2946         # Check that each of the things are valid numbers.
2947         case $current in
2948         [0-9]*) ;;
2949         *)
2950           $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2951           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2952           exit $EXIT_FAILURE
2953           ;;
2954         esac
2955
2956         case $revision in
2957         [0-9]*) ;;
2958         *)
2959           $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2960           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2961           exit $EXIT_FAILURE
2962           ;;
2963         esac
2964
2965         case $age in
2966         [0-9]*) ;;
2967         *)
2968           $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2969           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2970           exit $EXIT_FAILURE
2971           ;;
2972         esac
2973
2974         if test "$age" -gt "$current"; then
2975           $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2976           $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2977           exit $EXIT_FAILURE
2978         fi
2979
2980         # Calculate the version variables.
2981         major=
2982         versuffix=
2983         verstring=
2984         case $version_type in
2985         none) ;;
2986
2987         darwin)
2988           # Like Linux, but with the current version available in
2989           # verstring for coding it into the library header
2990           major=.`expr $current - $age`
2991           versuffix="$major.$age.$revision"
2992           # Darwin ld doesn't like 0 for these options...
2993           minor_current=`expr $current + 1`
2994           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2995           ;;
2996
2997         freebsd-aout)
2998           major=".$current"
2999           versuffix=".$current.$revision";
3000           ;;
3001
3002         freebsd-elf)
3003           major=".$current"
3004           versuffix=".$current";
3005           ;;
3006
3007         irix | nonstopux)
3008           major=`expr $current - $age + 1`
3009
3010           case $version_type in
3011             nonstopux) verstring_prefix=nonstopux ;;
3012             *)         verstring_prefix=sgi ;;
3013           esac
3014           verstring="$verstring_prefix$major.$revision"
3015
3016           # Add in all the interfaces that we are compatible with.
3017           loop=$revision
3018           while test "$loop" -ne 0; do
3019             iface=`expr $revision - $loop`
3020             loop=`expr $loop - 1`
3021             verstring="$verstring_prefix$major.$iface:$verstring"
3022           done
3023
3024           # Before this point, $major must not contain `.'.
3025           major=.$major
3026           versuffix="$major.$revision"
3027           ;;
3028
3029         linux)
3030           major=.`expr $current - $age`
3031           versuffix="$major.$age.$revision"
3032           ;;
3033
3034         osf)
3035           major=.`expr $current - $age`
3036           versuffix=".$current.$age.$revision"
3037           verstring="$current.$age.$revision"
3038
3039           # Add in all the interfaces that we are compatible with.
3040           loop=$age
3041           while test "$loop" -ne 0; do
3042             iface=`expr $current - $loop`
3043             loop=`expr $loop - 1`
3044             verstring="$verstring:${iface}.0"
3045           done
3046
3047           # Make executables depend on our current version.
3048           verstring="$verstring:${current}.0"
3049           ;;
3050
3051         sunos)
3052           major=".$current"
3053           versuffix=".$current.$revision"
3054           ;;
3055
3056         windows)
3057           # Use '-' rather than '.', since we only want one
3058           # extension on DOS 8.3 filesystems.
3059           major=`expr $current - $age`
3060           versuffix="-$major"
3061           ;;
3062
3063         *)
3064           $echo "$modename: unknown library version type \`$version_type'" 1>&2
3065           $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3066           exit $EXIT_FAILURE
3067           ;;
3068         esac
3069
3070         # Clear the version info if we defaulted, and they specified a release.
3071         if test -z "$vinfo" && test -n "$release"; then
3072           major=
3073           case $version_type in
3074           darwin)
3075             # we can't check for "0.0" in archive_cmds due to quoting
3076             # problems, so we reset it completely
3077             verstring=
3078             ;;
3079           *)
3080             verstring="0.0"
3081             ;;
3082           esac
3083           if test "$need_version" = no; then
3084             versuffix=
3085           else
3086             versuffix=".0.0"
3087           fi
3088         fi
3089
3090         # Remove version info from name if versioning should be avoided
3091         if test "$avoid_version" = yes && test "$need_version" = no; then
3092           major=
3093           versuffix=
3094           verstring=""
3095         fi
3096
3097         # Check to see if the archive will have undefined symbols.
3098         if test "$allow_undefined" = yes; then
3099           if test "$allow_undefined_flag" = unsupported; then
3100             $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3101             build_libtool_libs=no
3102             build_old_libs=yes
3103           fi
3104         else
3105           # Don't allow undefined symbols.
3106           allow_undefined_flag="$no_undefined_flag"
3107         fi
3108       fi
3109
3110       if test "$mode" != relink; then
3111         # Remove our outputs, but don't remove object files since they
3112         # may have been created when compiling PIC objects.
3113         removelist=
3114         tempremovelist=`$echo "$output_objdir/*"`
3115         for p in $tempremovelist; do
3116           case $p in
3117             *.$objext)
3118                ;;
3119             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3120                if test "X$precious_files_regex" != "X"; then
3121                  if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3122                  then
3123                    continue
3124                  fi
3125                fi
3126                removelist="$removelist $p"
3127                ;;
3128             *) ;;
3129           esac
3130         done
3131         if test -n "$removelist"; then
3132           $show "${rm}r $removelist"
3133           $run ${rm}r $removelist
3134         fi
3135       fi
3136
3137       # Now set the variables for building old libraries.
3138       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3139         oldlibs="$oldlibs $output_objdir/$libname.$libext"
3140
3141         # Transform .lo files to .o files.
3142         oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3143       fi
3144
3145       # Eliminate all temporary directories.
3146       for path in $notinst_path; do
3147         lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
3148         deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
3149         dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
3150       done
3151
3152       if test -n "$xrpath"; then
3153         # If the user specified any rpath flags, then add them.
3154         temp_xrpath=
3155         for libdir in $xrpath; do
3156           temp_xrpath="$temp_xrpath -R$libdir"
3157           case "$finalize_rpath " in
3158           *" $libdir "*) ;;
3159           *) finalize_rpath="$finalize_rpath $libdir" ;;
3160           esac
3161         done
3162         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3163           dependency_libs="$temp_xrpath $dependency_libs"
3164         fi
3165       fi
3166
3167       # Make sure dlfiles contains only unique files that won't be dlpreopened
3168       old_dlfiles="$dlfiles"
3169       dlfiles=
3170       for lib in $old_dlfiles; do
3171         case " $dlprefiles $dlfiles " in
3172         *" $lib "*) ;;
3173         *) dlfiles="$dlfiles $lib" ;;
3174         esac
3175       done
3176
3177       # Make sure dlprefiles contains only unique files
3178       old_dlprefiles="$dlprefiles"
3179       dlprefiles=
3180       for lib in $old_dlprefiles; do
3181         case "$dlprefiles " in
3182         *" $lib "*) ;;
3183         *) dlprefiles="$dlprefiles $lib" ;;
3184         esac
3185       done
3186
3187       if test "$build_libtool_libs" = yes; then
3188         if test -n "$rpath"; then
3189           case $host in
3190           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3191             # these systems don't actually have a c library (as such)!
3192             ;;
3193           *-*-rhapsody* | *-*-darwin1.[012])
3194             # Rhapsody C library is in the System framework
3195             deplibs="$deplibs -framework System"
3196             ;;
3197           *-*-netbsd*)
3198             # Don't link with libc until the a.out ld.so is fixed.
3199             ;;
3200           *-*-openbsd* | *-*-freebsd*)
3201             # Do not include libc due to us having libc/libc_r.
3202             test "X$arg" = "X-lc" && continue
3203             ;;
3204           *)
3205             # Add libc to deplibs on all other systems if necessary.
3206             if test "$build_libtool_need_lc" = "yes"; then
3207               deplibs="$deplibs -lc"
3208             fi
3209             ;;
3210           esac
3211         fi
3212
3213         # Transform deplibs into only deplibs that can be linked in shared.
3214         name_save=$name
3215         libname_save=$libname
3216         release_save=$release
3217         versuffix_save=$versuffix
3218         major_save=$major
3219         # I'm not sure if I'm treating the release correctly.  I think
3220         # release should show up in the -l (ie -lgmp5) so we don't want to
3221         # add it in twice.  Is that correct?
3222         release=""
3223         versuffix=""
3224         major=""
3225         newdeplibs=
3226         droppeddeps=no
3227         case $deplibs_check_method in
3228         pass_all)
3229           # Don't check for shared/static.  Everything works.
3230           # This might be a little naive.  We might want to check
3231           # whether the library exists or not.  But this is on
3232           # osf3 & osf4 and I'm not really sure... Just
3233           # implementing what was already the behavior.
3234           newdeplibs=$deplibs
3235           ;;
3236         test_compile)
3237           # This code stresses the "libraries are programs" paradigm to its
3238           # limits. Maybe even breaks it.  We compile a program, linking it
3239           # against the deplibs as a proxy for the library.  Then we can check
3240           # whether they linked in statically or dynamically with ldd.
3241           $rm conftest.c
3242           cat > conftest.c <<EOF
3243           int main() { return 0; }
3244 EOF
3245           $rm conftest
3246           $LTCC -o conftest conftest.c $deplibs
3247           if test "$?" -eq 0 ; then
3248             ldd_output=`ldd conftest`
3249             for i in $deplibs; do
3250               name="`expr $i : '-l\(.*\)'`"
3251               # If $name is empty we are operating on a -L argument.
3252               if test "$name" != "" && test "$name" -ne "0"; then
3253                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3254                   case " $predeps $postdeps " in
3255                   *" $i "*)
3256                     newdeplibs="$newdeplibs $i"
3257                     i=""
3258                     ;;
3259                   esac
3260                 fi
3261                 if test -n "$i" ; then
3262                   libname=`eval \\$echo \"$libname_spec\"`
3263                   deplib_matches=`eval \\$echo \"$library_names_spec\"`
3264                   set dummy $deplib_matches
3265                   deplib_match=$2
3266                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3267                     newdeplibs="$newdeplibs $i"
3268                   else
3269                     droppeddeps=yes
3270                     $echo
3271                     $echo "*** Warning: dynamic linker does not accept needed library $i."
3272                     $echo "*** I have the capability to make that library automatically link in when"
3273                     $echo "*** you link to this library.  But I can only do this if you have a"
3274                     $echo "*** shared version of the library, which I believe you do not have"
3275                     $echo "*** because a test_compile did reveal that the linker did not use it for"
3276                     $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3277                   fi
3278                 fi
3279               else
3280                 newdeplibs="$newdeplibs $i"
3281               fi
3282             done
3283           else
3284             # Error occurred in the first compile.  Let's try to salvage
3285             # the situation: Compile a separate program for each library.
3286             for i in $deplibs; do
3287               name="`expr $i : '-l\(.*\)'`"
3288               # If $name is empty we are operating on a -L argument.
3289               if test "$name" != "" && test "$name" != "0"; then
3290                 $rm conftest
3291                 $LTCC -o conftest conftest.c $i
3292                 # Did it work?
3293                 if test "$?" -eq 0 ; then
3294                   ldd_output=`ldd conftest`
3295                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3296                     case " $predeps $postdeps " in
3297                     *" $i "*)
3298                       newdeplibs="$newdeplibs $i"
3299                       i=""
3300                       ;;
3301                     esac
3302                   fi
3303                   if test -n "$i" ; then
3304                     libname=`eval \\$echo \"$libname_spec\"`
3305                     deplib_matches=`eval \\$echo \"$library_names_spec\"`
3306                     set dummy $deplib_matches
3307                     deplib_match=$2
3308                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3309                       newdeplibs="$newdeplibs $i"
3310                     else
3311                       droppeddeps=yes
3312                       $echo
3313                       $echo "*** Warning: dynamic linker does not accept needed library $i."
3314                       $echo "*** I have the capability to make that library automatically link in when"
3315                       $echo "*** you link to this library.  But I can only do this if you have a"
3316                       $echo "*** shared version of the library, which you do not appear to have"
3317                       $echo "*** because a test_compile did reveal that the linker did not use this one"
3318                       $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3319                     fi
3320                   fi
3321                 else
3322                   droppeddeps=yes
3323                   $echo
3324                   $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3325                   $echo "***  make it link in!  You will probably need to install it or some"
3326                   $echo "*** library that it depends on before this library will be fully"
3327                   $echo "*** functional.  Installing it before continuing would be even better."
3328                 fi
3329               else
3330                 newdeplibs="$newdeplibs $i"
3331               fi
3332             done
3333           fi
3334           ;;
3335         file_magic*)
3336           set dummy $deplibs_check_method
3337           file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3338           for a_deplib in $deplibs; do
3339             name="`expr $a_deplib : '-l\(.*\)'`"
3340             # If $name is empty we are operating on a -L argument.
3341             if test "$name" != "" && test  "$name" != "0"; then
3342               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3343                 case " $predeps $postdeps " in
3344                 *" $a_deplib "*)
3345                   newdeplibs="$newdeplibs $a_deplib"
3346                   a_deplib=""
3347                   ;;
3348                 esac
3349               fi
3350               if test -n "$a_deplib" ; then
3351                 libname=`eval \\$echo \"$libname_spec\"`
3352                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3353                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3354                   for potent_lib in $potential_libs; do
3355                       # Follow soft links.
3356                       if ls -lLd "$potent_lib" 2>/dev/null \
3357                          | grep " -> " >/dev/null; then
3358                         continue
3359                       fi
3360                       # The statement above tries to avoid entering an
3361                       # endless loop below, in case of cyclic links.
3362                       # We might still enter an endless loop, since a link
3363                       # loop can be closed while we follow links,
3364                       # but so what?
3365                       potlib="$potent_lib"
3366                       while test -h "$potlib" 2>/dev/null; do
3367                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3368                         case $potliblink in
3369                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3370                         *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3371                         esac
3372                       done
3373                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3374                          | ${SED} 10q \
3375                          | $EGREP "$file_magic_regex" > /dev/null; then
3376                         newdeplibs="$newdeplibs $a_deplib"
3377                         a_deplib=""
3378                         break 2
3379                       fi
3380                   done
3381                 done
3382               fi
3383               if test -n "$a_deplib" ; then
3384                 droppeddeps=yes
3385                 $echo
3386                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3387                 $echo "*** I have the capability to make that library automatically link in when"
3388                 $echo "*** you link to this library.  But I can only do this if you have a"
3389                 $echo "*** shared version of the library, which you do not appear to have"
3390                 $echo "*** because I did check the linker path looking for a file starting"
3391                 if test -z "$potlib" ; then
3392                   $echo "*** with $libname but no candidates were found. (...for file magic test)"
3393                 else
3394                   $echo "*** with $libname and none of the candidates passed a file format test"
3395                   $echo "*** using a file magic. Last file checked: $potlib"
3396                 fi
3397               fi
3398             else
3399               # Add a -L argument.
3400               newdeplibs="$newdeplibs $a_deplib"
3401             fi
3402           done # Gone through all deplibs.
3403           ;;
3404         match_pattern*)
3405           set dummy $deplibs_check_method
3406           match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3407           for a_deplib in $deplibs; do
3408             name="`expr $a_deplib : '-l\(.*\)'`"
3409             # If $name is empty we are operating on a -L argument.
3410             if test -n "$name" && test "$name" != "0"; then
3411               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3412                 case " $predeps $postdeps " in
3413                 *" $a_deplib "*)
3414                   newdeplibs="$newdeplibs $a_deplib"
3415                   a_deplib=""
3416                   ;;
3417                 esac
3418               fi
3419               if test -n "$a_deplib" ; then
3420                 libname=`eval \\$echo \"$libname_spec\"`
3421                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3422                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3423                   for potent_lib in $potential_libs; do
3424                     potlib="$potent_lib" # see symlink-check above in file_magic test
3425                     if eval $echo \"$potent_lib\" 2>/dev/null \
3426                         | ${SED} 10q \
3427                         | $EGREP "$match_pattern_regex" > /dev/null; then
3428                       newdeplibs="$newdeplibs $a_deplib"
3429                       a_deplib=""
3430                       break 2
3431                     fi
3432                   done
3433                 done
3434               fi
3435               if test -n "$a_deplib" ; then
3436                 droppeddeps=yes
3437                 $echo
3438                 $echo "*** Warning: linker path does not have real file for library $a_deplib."
3439                 $echo "*** I have the capability to make that library automatically link in when"
3440                 $echo "*** you link to this library.  But I can only do this if you have a"
3441                 $echo "*** shared version of the library, which you do not appear to have"
3442                 $echo "*** because I did check the linker path looking for a file starting"
3443                 if test -z "$potlib" ; then
3444                   $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3445                 else
3446                   $echo "*** with $libname and none of the candidates passed a file format test"
3447                   $echo "*** using a regex pattern. Last file checked: $potlib"
3448                 fi
3449               fi
3450             else
3451               # Add a -L argument.
3452               newdeplibs="$newdeplibs $a_deplib"
3453             fi
3454           done # Gone through all deplibs.
3455           ;;
3456         none | unknown | *)
3457           newdeplibs=""
3458           tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3459             -e 's/ -[LR][^ ]*//g'`
3460           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3461             for i in $predeps $postdeps ; do
3462               # can't use Xsed below, because $i might contain '/'
3463               tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3464             done
3465           fi
3466           if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
3467             | grep . >/dev/null; then
3468             $echo
3469             if test "X$deplibs_check_method" = "Xnone"; then
3470               $echo "*** Warning: inter-library dependencies are not supported in this platform."
3471             else
3472               $echo "*** Warning: inter-library dependencies are not known to be supported."
3473             fi
3474             $echo "*** All declared inter-library dependencies are being dropped."
3475             droppeddeps=yes
3476           fi
3477           ;;
3478         esac
3479         versuffix=$versuffix_save
3480         major=$major_save
3481         release=$release_save
3482         libname=$libname_save
3483         name=$name_save
3484
3485         case $host in
3486         *-*-rhapsody* | *-*-darwin1.[012])
3487           # On Rhapsody replace the C library is the System framework
3488           newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3489           ;;
3490         esac
3491
3492         if test "$droppeddeps" = yes; then
3493           if test "$module" = yes; then
3494             $echo
3495             $echo "*** Warning: libtool could not satisfy all declared inter-library"
3496             $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3497             $echo "*** a static module, that should work as long as the dlopening"
3498             $echo "*** application is linked with the -dlopen flag."
3499             if test -z "$global_symbol_pipe"; then
3500               $echo
3501               $echo "*** However, this would only work if libtool was able to extract symbol"
3502               $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3503               $echo "*** not find such a program.  So, this module is probably useless."
3504               $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3505             fi
3506             if test "$build_old_libs" = no; then
3507               oldlibs="$output_objdir/$libname.$libext"
3508               build_libtool_libs=module
3509               build_old_libs=yes
3510             else
3511               build_libtool_libs=no
3512             fi
3513           else
3514             $echo "*** The inter-library dependencies that have been dropped here will be"
3515             $echo "*** automatically added whenever a program is linked with this library"
3516             $echo "*** or is declared to -dlopen it."
3517
3518             if test "$allow_undefined" = no; then
3519               $echo
3520               $echo "*** Since this library must not contain undefined symbols,"
3521               $echo "*** because either the platform does not support them or"
3522               $echo "*** it was explicitly requested with -no-undefined,"
3523               $echo "*** libtool will only create a static version of it."
3524               if test "$build_old_libs" = no; then
3525                 oldlibs="$output_objdir/$libname.$libext"
3526                 build_libtool_libs=module
3527                 build_old_libs=yes
3528               else
3529                 build_libtool_libs=no
3530               fi
3531             fi
3532           fi
3533         fi
3534         # Done checking deplibs!
3535         deplibs=$newdeplibs
3536       fi
3537
3538       # All the library-specific variables (install_libdir is set above).
3539       library_names=
3540       old_library=
3541       dlname=
3542
3543       # Test again, we may have decided not to build it any more
3544       if test "$build_libtool_libs" = yes; then
3545         if test "$hardcode_into_libs" = yes; then
3546           # Hardcode the library paths
3547           hardcode_libdirs=
3548           dep_rpath=
3549           rpath="$finalize_rpath"
3550           test "$mode" != relink && rpath="$compile_rpath$rpath"
3551           for libdir in $rpath; do
3552             if test -n "$hardcode_libdir_flag_spec"; then
3553               if test -n "$hardcode_libdir_separator"; then
3554                 if test -z "$hardcode_libdirs"; then
3555                   hardcode_libdirs="$libdir"
3556                 else
3557                   # Just accumulate the unique libdirs.
3558                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3559                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3560                     ;;
3561                   *)
3562                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3563                     ;;
3564                   esac
3565                 fi
3566               else
3567                 eval flag=\"$hardcode_libdir_flag_spec\"
3568                 dep_rpath="$dep_rpath $flag"
3569               fi
3570             elif test -n "$runpath_var"; then
3571               case "$perm_rpath " in
3572               *" $libdir "*) ;;
3573               *) perm_rpath="$perm_rpath $libdir" ;;
3574               esac
3575             fi
3576           done
3577           # Substitute the hardcoded libdirs into the rpath.
3578           if test -n "$hardcode_libdir_separator" &&
3579              test -n "$hardcode_libdirs"; then
3580             libdir="$hardcode_libdirs"
3581             if test -n "$hardcode_libdir_flag_spec_ld"; then
3582               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3583             else
3584               eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3585             fi
3586           fi
3587           if test -n "$runpath_var" && test -n "$perm_rpath"; then
3588             # We should set the runpath_var.
3589             rpath=
3590             for dir in $perm_rpath; do
3591               rpath="$rpath$dir:"
3592             done
3593             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3594           fi
3595           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3596         fi
3597
3598         shlibpath="$finalize_shlibpath"
3599         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3600         if test -n "$shlibpath"; then
3601           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3602         fi
3603
3604         # Get the real and link names of the library.
3605         eval shared_ext=\"$shrext_cmds\"
3606         eval library_names=\"$library_names_spec\"
3607         set dummy $library_names
3608         realname="$2"
3609         shift; shift
3610
3611         if test -n "$soname_spec"; then
3612           eval soname=\"$soname_spec\"
3613         else
3614           soname="$realname"
3615         fi
3616         if test -z "$dlname"; then
3617           dlname=$soname
3618         fi
3619
3620         lib="$output_objdir/$realname"
3621         for link
3622         do
3623           linknames="$linknames $link"
3624         done
3625
3626         # Use standard objects if they are pic
3627         test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3628
3629         # Prepare the list of exported symbols
3630         if test -z "$export_symbols"; then
3631           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3632             $show "generating symbol list for \`$libname.la'"
3633             export_symbols="$output_objdir/$libname.exp"
3634             $run $rm $export_symbols
3635             cmds=$export_symbols_cmds
3636             save_ifs="$IFS"; IFS='~'
3637             for cmd in $cmds; do
3638               IFS="$save_ifs"
3639               eval cmd=\"$cmd\"
3640               if len=`expr "X$cmd" : ".*"` &&
3641                test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3642                 $show "$cmd"
3643                 $run eval "$cmd" || exit $?
3644                 skipped_export=false
3645               else
3646                 # The command line is too long to execute in one step.
3647                 $show "using reloadable object file for export list..."
3648                 skipped_export=:
3649               fi
3650             done
3651             IFS="$save_ifs"
3652             if test -n "$export_symbols_regex"; then
3653               $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3654               $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3655               $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3656               $run eval '$mv "${export_symbols}T" "$export_symbols"'
3657             fi
3658           fi
3659         fi
3660
3661         if test -n "$export_symbols" && test -n "$include_expsyms"; then
3662           $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3663         fi
3664
3665         tmp_deplibs=
3666         for test_deplib in $deplibs; do
3667                 case " $convenience " in
3668                 *" $test_deplib "*) ;;
3669                 *)
3670                         tmp_deplibs="$tmp_deplibs $test_deplib"
3671                         ;;
3672                 esac
3673         done
3674         deplibs="$tmp_deplibs"
3675
3676         if test -n "$convenience"; then
3677           if test -n "$whole_archive_flag_spec"; then
3678             save_libobjs=$libobjs
3679             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3680           else
3681             gentop="$output_objdir/${outputname}x"
3682             $show "${rm}r $gentop"
3683             $run ${rm}r "$gentop"
3684             $show "$mkdir $gentop"
3685             $run $mkdir "$gentop"
3686             status=$?
3687             if test "$status" -ne 0 && test ! -d "$gentop"; then
3688               exit $status
3689             fi
3690             generated="$generated $gentop"
3691
3692             for xlib in $convenience; do
3693               # Extract the objects.
3694               case $xlib in
3695               [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3696               *) xabs=`pwd`"/$xlib" ;;
3697               esac
3698               xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3699               xdir="$gentop/$xlib"
3700
3701               $show "${rm}r $xdir"
3702               $run ${rm}r "$xdir"
3703               $show "$mkdir $xdir"
3704               $run $mkdir "$xdir"
3705               status=$?
3706               if test "$status" -ne 0 && test ! -d "$xdir"; then
3707                 exit $status
3708               fi
3709               # We will extract separately just the conflicting names and we will no
3710               # longer touch any unique names. It is faster to leave these extract
3711               # automatically by $AR in one run.
3712               $show "(cd $xdir && $AR x $xabs)"
3713               $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3714               if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
3715                 :
3716               else
3717                 $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
3718                 $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
3719                 $AR t "$xabs" | sort | uniq -cd | while read -r count name
3720                 do
3721                   i=1
3722                   while test "$i" -le "$count"
3723                   do
3724                    # Put our $i before any first dot (extension)
3725                    # Never overwrite any file
3726                    name_to="$name"
3727                    while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
3728                    do
3729                      name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
3730                    done
3731                    $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
3732                    $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
3733                    i=`expr $i + 1`
3734                   done
3735                 done
3736               fi
3737
3738               libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3739             done
3740           fi
3741         fi
3742
3743         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3744           eval flag=\"$thread_safe_flag_spec\"
3745           linker_flags="$linker_flags $flag"
3746         fi
3747
3748         # Make a backup of the uninstalled library when relinking
3749         if test "$mode" = relink; then
3750           $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3751         fi
3752
3753         # Do each of the archive commands.
3754         if test "$module" = yes && test -n "$module_cmds" ; then
3755           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
3756             eval test_cmds=\"$module_expsym_cmds\"
3757             cmds=$module_expsym_cmds
3758           else
3759             eval test_cmds=\"$module_cmds\"
3760             cmds=$module_cmds
3761           fi
3762         else
3763         if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3764           eval test_cmds=\"$archive_expsym_cmds\"
3765           cmds=$archive_expsym_cmds
3766         else
3767           eval test_cmds=\"$archive_cmds\"
3768           cmds=$archive_cmds
3769           fi
3770         fi
3771
3772         if test "X$skipped_export" != "X:" && len=`expr "X$test_cmds" : ".*"` &&
3773            test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3774           :
3775         else
3776           # The command line is too long to link in one step, link piecewise.
3777           $echo "creating reloadable object files..."
3778
3779           # Save the value of $output and $libobjs because we want to
3780           # use them later.  If we have whole_archive_flag_spec, we
3781           # want to use save_libobjs as it was before
3782           # whole_archive_flag_spec was expanded, because we can't
3783           # assume the linker understands whole_archive_flag_spec.
3784           # This may have to be revisited, in case too many
3785           # convenience libraries get linked in and end up exceeding
3786           # the spec.
3787           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3788             save_libobjs=$libobjs
3789           fi
3790           save_output=$output
3791
3792           # Clear the reloadable object creation command queue and
3793           # initialize k to one.
3794           test_cmds=
3795           concat_cmds=
3796           objlist=
3797           delfiles=
3798           last_robj=
3799           k=1
3800           output=$output_objdir/$save_output-${k}.$objext
3801           # Loop over the list of objects to be linked.
3802           for obj in $save_libobjs
3803           do
3804             eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3805             if test "X$objlist" = X ||
3806                { len=`expr "X$test_cmds" : ".*"` &&
3807                  test "$len" -le "$max_cmd_len"; }; then
3808               objlist="$objlist $obj"
3809             else
3810               # The command $test_cmds is almost too long, add a
3811               # command to the queue.
3812               if test "$k" -eq 1 ; then
3813                 # The first file doesn't have a previous command to add.
3814                 eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3815               else
3816                 # All subsequent reloadable object files will link in
3817                 # the last one created.
3818                 eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3819               fi
3820               last_robj=$output_objdir/$save_output-${k}.$objext
3821               k=`expr $k + 1`
3822               output=$output_objdir/$save_output-${k}.$objext
3823               objlist=$obj
3824               len=1
3825             fi
3826           done
3827           # Handle the remaining objects by creating one last
3828           # reloadable object file.  All subsequent reloadable object
3829           # files will link in the last one created.
3830           test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3831           eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3832
3833           if ${skipped_export-false}; then
3834             $show "generating symbol list for \`$libname.la'"
3835             export_symbols="$output_objdir/$libname.exp"
3836             $run $rm $export_symbols
3837             libobjs=$output
3838             # Append the command to create the export file.
3839             eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
3840           fi
3841
3842           # Set up a command to remove the reloadale object files
3843           # after they are used.
3844           i=0
3845           while test "$i" -lt "$k"
3846           do
3847             i=`expr $i + 1`
3848             delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3849           done
3850
3851           $echo "creating a temporary reloadable object file: $output"
3852
3853           # Loop through the commands generated above and execute them.
3854           save_ifs="$IFS"; IFS='~'
3855           for cmd in $concat_cmds; do
3856             IFS="$save_ifs"
3857             $show "$cmd"
3858             $run eval "$cmd" || exit $?
3859           done
3860           IFS="$save_ifs"
3861
3862           libobjs=$output
3863           # Restore the value of output.
3864           output=$save_output
3865
3866           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3867             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3868           fi
3869           # Expand the library linking commands again to reset the
3870           # value of $libobjs for piecewise linking.
3871
3872           # Do each of the archive commands.
3873           if test "$module" = yes && test -n "$module_cmds" ; then
3874             if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
3875               cmds=$module_expsym_cmds
3876             else
3877               cmds=$module_cmds
3878             fi
3879           else
3880           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3881             cmds=$archive_expsym_cmds
3882           else
3883             cmds=$archive_cmds
3884             fi
3885           fi
3886
3887           # Append the command to remove the reloadable object files
3888           # to the just-reset $cmds.
3889           eval cmds=\"\$cmds~\$rm $delfiles\"
3890         fi
3891         save_ifs="$IFS"; IFS='~'
3892         for cmd in $cmds; do
3893           IFS="$save_ifs"
3894           eval cmd=\"$cmd\"
3895           $show "$cmd"
3896           $run eval "$cmd" || exit $?
3897         done
3898         IFS="$save_ifs"
3899
3900         # Restore the uninstalled library and exit
3901         if test "$mode" = relink; then
3902           $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
3903           exit $EXIT_SUCCESS
3904         fi
3905
3906         # Create links to the real library.
3907         for linkname in $linknames; do
3908           if test "$realname" != "$linkname"; then
3909             $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3910             $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
3911           fi
3912         done
3913
3914         # If -module or -export-dynamic was specified, set the dlname.
3915         if test "$module" = yes || test "$export_dynamic" = yes; then
3916           # On all known operating systems, these are identical.
3917           dlname="$soname"
3918         fi
3919       fi
3920       ;;
3921
3922     obj)
3923       if test -n "$deplibs"; then
3924         $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
3925       fi
3926
3927       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3928         $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
3929       fi
3930
3931       if test -n "$rpath"; then
3932         $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
3933       fi
3934
3935       if test -n "$xrpath"; then
3936         $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
3937       fi
3938
3939       if test -n "$vinfo"; then
3940         $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
3941       fi
3942
3943       if test -n "$release"; then
3944         $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
3945       fi
3946
3947       case $output in
3948       *.lo)
3949         if test -n "$objs$old_deplibs"; then
3950           $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
3951           exit $EXIT_FAILURE
3952         fi
3953         libobj="$output"
3954         obj=`$echo "X$output" | $Xsed -e "$lo2o"`
3955         ;;
3956       *)
3957         libobj=
3958         obj="$output"
3959         ;;
3960       esac
3961
3962       # Delete the old objects.
3963       $run $rm $obj $libobj
3964
3965       # Objects from convenience libraries.  This assumes
3966       # single-version convenience libraries.  Whenever we create
3967       # different ones for PIC/non-PIC, this we'll have to duplicate
3968       # the extraction.
3969       reload_conv_objs=
3970       gentop=
3971       # reload_cmds runs $LD directly, so let us get rid of
3972       # -Wl from whole_archive_flag_spec
3973       wl=
3974
3975       if test -n "$convenience"; then
3976         if test -n "$whole_archive_flag_spec"; then
3977           eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
3978         else
3979           gentop="$output_objdir/${obj}x"
3980           $show "${rm}r $gentop"
3981           $run ${rm}r "$gentop"
3982           $show "$mkdir $gentop"
3983           $run $mkdir "$gentop"
3984           status=$?
3985           if test "$status" -ne 0 && test ! -d "$gentop"; then
3986             exit $status
3987           fi
3988           generated="$generated $gentop"
3989
3990           for xlib in $convenience; do
3991             # Extract the objects.
3992             case $xlib in
3993             [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3994             *) xabs=`pwd`"/$xlib" ;;
3995             esac
3996             xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3997             xdir="$gentop/$xlib"
3998
3999             $show "${rm}r $xdir"
4000             $run ${rm}r "$xdir"
4001             $show "$mkdir $xdir"
4002             $run $mkdir "$xdir"
4003             status=$?
4004             if test "$status" -ne 0 && test ! -d "$xdir"; then
4005               exit $status
4006             fi
4007             # We will extract separately just the conflicting names and we will no
4008             # longer touch any unique names. It is faster to leave these extract
4009             # automatically by $AR in one run.
4010             $show "(cd $xdir && $AR x $xabs)"
4011             $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
4012             if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
4013               :
4014             else
4015               $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
4016               $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
4017               $AR t "$xabs" | sort | uniq -cd | while read -r count name
4018               do
4019                 i=1
4020                 while test "$i" -le "$count"
4021                 do
4022                  # Put our $i before any first dot (extension)
4023                  # Never overwrite any file
4024                  name_to="$name"
4025                  while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
4026                  do
4027                    name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
4028                  done
4029                  $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
4030                  $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
4031                  i=`expr $i + 1`
4032                 done
4033               done
4034             fi
4035
4036             reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
4037           done
4038         fi
4039       fi
4040
4041       # Create the old-style object.
4042       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
4043
4044       output="$obj"
4045       cmds=$reload_cmds
4046       save_ifs="$IFS"; IFS='~'
4047       for cmd in $cmds; do
4048         IFS="$save_ifs"
4049         eval cmd=\"$cmd\"
4050         $show "$cmd"
4051         $run eval "$cmd" || exit $?
4052       done
4053       IFS="$save_ifs"
4054
4055       # Exit if we aren't doing a library object file.
4056       if test -z "$libobj"; then
4057         if test -n "$gentop"; then
4058           $show "${rm}r $gentop"
4059           $run ${rm}r $gentop
4060         fi
4061
4062         exit $EXIT_SUCCESS
4063       fi
4064
4065       if test "$build_libtool_libs" != yes; then
4066         if test -n "$gentop"; then
4067           $show "${rm}r $gentop"
4068           $run ${rm}r $gentop
4069         fi
4070
4071         # Create an invalid libtool object if no PIC, so that we don't
4072         # accidentally link it into a program.
4073         # $show "echo timestamp > $libobj"
4074         # $run eval "echo timestamp > $libobj" || exit $?
4075         exit $EXIT_SUCCESS
4076       fi
4077
4078       if test -n "$pic_flag" || test "$pic_mode" != default; then
4079         # Only do commands if we really have different PIC objects.
4080         reload_objs="$libobjs $reload_conv_objs"
4081         output="$libobj"
4082         cmds=$reload_cmds
4083         save_ifs="$IFS"; IFS='~'
4084         for cmd in $cmds; do
4085           IFS="$save_ifs"
4086           eval cmd=\"$cmd\"
4087           $show "$cmd"
4088           $run eval "$cmd" || exit $?
4089         done
4090         IFS="$save_ifs"
4091       fi
4092
4093       if test -n "$gentop"; then
4094         $show "${rm}r $gentop"
4095         $run ${rm}r $gentop
4096       fi
4097
4098       exit $EXIT_SUCCESS
4099       ;;
4100
4101     prog)
4102       case $host in
4103         *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
4104       esac
4105       if test -n "$vinfo"; then
4106         $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4107       fi
4108
4109       if test -n "$release"; then
4110         $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4111       fi
4112
4113       if test "$preload" = yes; then
4114         if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4115            test "$dlopen_self_static" = unknown; then
4116           $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4117         fi
4118       fi
4119
4120       case $host in
4121       *-*-rhapsody* | *-*-darwin1.[012])
4122         # On Rhapsody replace the C library is the System framework
4123         compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4124         finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4125         ;;
4126       esac
4127
4128       case $host in
4129       *darwin*)
4130         # Don't allow lazy linking, it breaks C++ global constructors
4131         if test "$tagname" = CXX ; then
4132         compile_command="$compile_command ${wl}-bind_at_load"
4133         finalize_command="$finalize_command ${wl}-bind_at_load"
4134         fi
4135         ;;
4136       esac
4137
4138       compile_command="$compile_command $compile_deplibs"
4139       finalize_command="$finalize_command $finalize_deplibs"
4140
4141       if test -n "$rpath$xrpath"; then
4142         # If the user specified any rpath flags, then add them.
4143         for libdir in $rpath $xrpath; do
4144           # This is the magic to use -rpath.
4145           case "$finalize_rpath " in
4146           *" $libdir "*) ;;
4147           *) finalize_rpath="$finalize_rpath $libdir" ;;
4148           esac
4149         done
4150       fi
4151
4152       # Now hardcode the library paths
4153       rpath=
4154       hardcode_libdirs=
4155       for libdir in $compile_rpath $finalize_rpath; do
4156         if test -n "$hardcode_libdir_flag_spec"; then
4157           if test -n "$hardcode_libdir_separator"; then
4158             if test -z "$hardcode_libdirs"; then
4159               hardcode_libdirs="$libdir"
4160             else
4161               # Just accumulate the unique libdirs.
4162               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4163               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4164                 ;;
4165               *)
4166                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4167                 ;;
4168               esac
4169             fi
4170           else
4171             eval flag=\"$hardcode_libdir_flag_spec\"
4172             rpath="$rpath $flag"
4173           fi
4174         elif test -n "$runpath_var"; then
4175           case "$perm_rpath " in
4176           *" $libdir "*) ;;
4177           *) perm_rpath="$perm_rpath $libdir" ;;
4178           esac
4179         fi
4180         case $host in
4181         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4182           case :$dllsearchpath: in
4183           *":$libdir:"*) ;;
4184           *) dllsearchpath="$dllsearchpath:$libdir";;
4185           esac
4186           ;;
4187         esac
4188       done
4189       # Substitute the hardcoded libdirs into the rpath.
4190       if test -n "$hardcode_libdir_separator" &&
4191          test -n "$hardcode_libdirs"; then
4192         libdir="$hardcode_libdirs"
4193         eval rpath=\" $hardcode_libdir_flag_spec\"
4194       fi
4195       compile_rpath="$rpath"
4196
4197       rpath=
4198       hardcode_libdirs=
4199       for libdir in $finalize_rpath; do
4200         if test -n "$hardcode_libdir_flag_spec"; then
4201           if test -n "$hardcode_libdir_separator"; then
4202             if test -z "$hardcode_libdirs"; then
4203               hardcode_libdirs="$libdir"
4204             else
4205               # Just accumulate the unique libdirs.
4206               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4207               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4208                 ;;
4209               *)
4210                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4211                 ;;
4212               esac
4213             fi
4214           else
4215             eval flag=\"$hardcode_libdir_flag_spec\"
4216             rpath="$rpath $flag"
4217           fi
4218         elif test -n "$runpath_var"; then
4219           case "$finalize_perm_rpath " in
4220           *" $libdir "*) ;;
4221           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
4222           esac
4223         fi
4224       done
4225       # Substitute the hardcoded libdirs into the rpath.
4226       if test -n "$hardcode_libdir_separator" &&
4227          test -n "$hardcode_libdirs"; then
4228         libdir="$hardcode_libdirs"
4229         eval rpath=\" $hardcode_libdir_flag_spec\"
4230       fi
4231       finalize_rpath="$rpath"
4232
4233       if test -n "$libobjs" && test "$build_old_libs" = yes; then
4234         # Transform all the library objects into standard objects.
4235         compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4236         finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4237       fi
4238
4239       dlsyms=
4240       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4241         if test -n "$NM" && test -n "$global_symbol_pipe"; then
4242           dlsyms="${outputname}S.c"
4243         else
4244           $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4245         fi
4246       fi
4247
4248       if test -n "$dlsyms"; then
4249         case $dlsyms in
4250         "") ;;
4251         *.c)
4252           # Discover the nlist of each of the dlfiles.
4253           nlist="$output_objdir/${outputname}.nm"
4254
4255           $show "$rm $nlist ${nlist}S ${nlist}T"
4256           $run $rm "$nlist" "${nlist}S" "${nlist}T"
4257
4258           # Parse the name list into a source file.
4259           $show "creating $output_objdir/$dlsyms"
4260
4261           test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4262 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4263 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4264
4265 #ifdef __cplusplus
4266 extern \"C\" {
4267 #endif
4268
4269 /* Prevent the only kind of declaration conflicts we can make. */
4270 #define lt_preloaded_symbols some_other_symbol
4271
4272 /* External symbol declarations for the compiler. */\
4273 "
4274
4275           if test "$dlself" = yes; then
4276             $show "generating symbol list for \`$output'"
4277
4278             test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4279
4280             # Add our own program objects to the symbol list.
4281             progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4282             for arg in $progfiles; do
4283               $show "extracting global C symbols from \`$arg'"
4284               $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4285             done
4286
4287             if test -n "$exclude_expsyms"; then
4288               $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4289               $run eval '$mv "$nlist"T "$nlist"'
4290             fi
4291
4292             if test -n "$export_symbols_regex"; then
4293               $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4294               $run eval '$mv "$nlist"T "$nlist"'
4295             fi
4296
4297             # Prepare the list of exported symbols
4298             if test -z "$export_symbols"; then
4299               export_symbols="$output_objdir/$output.exp"
4300               $run $rm $export_symbols
4301               $run eval "${SED} -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4302             else
4303               $run eval "${SED} -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
4304               $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
4305               $run eval 'mv "$nlist"T "$nlist"'
4306             fi
4307           fi
4308
4309           for arg in $dlprefiles; do
4310             $show "extracting global C symbols from \`$arg'"
4311             name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4312             $run eval '$echo ": $name " >> "$nlist"'
4313             $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4314           done
4315
4316           if test -z "$run"; then
4317             # Make sure we have at least an empty file.
4318             test -f "$nlist" || : > "$nlist"
4319
4320             if test -n "$exclude_expsyms"; then
4321               $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4322               $mv "$nlist"T "$nlist"
4323             fi
4324
4325             # Try sorting and uniquifying the output.
4326             if grep -v "^: " < "$nlist" |
4327                 if sort -k 3 </dev/null >/dev/null 2>&1; then
4328                   sort -k 3
4329                 else
4330                   sort +2
4331                 fi |
4332                 uniq > "$nlist"S; then
4333               :
4334             else
4335               grep -v "^: " < "$nlist" > "$nlist"S
4336             fi
4337
4338             if test -f "$nlist"S; then
4339               eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4340             else
4341               $echo '/* NONE */' >> "$output_objdir/$dlsyms"
4342             fi
4343
4344             $echo >> "$output_objdir/$dlsyms" "\
4345
4346 #undef lt_preloaded_symbols
4347
4348 #if defined (__STDC__) && __STDC__
4349 # define lt_ptr void *
4350 #else
4351 # define lt_ptr char *
4352 # define const
4353 #endif
4354
4355 /* The mapping between symbol names and symbols. */
4356 const struct {
4357   const char *name;
4358   lt_ptr address;
4359 }
4360 lt_preloaded_symbols[] =
4361 {\
4362 "
4363
4364             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4365
4366             $echo >> "$output_objdir/$dlsyms" "\
4367   {0, (lt_ptr) 0}
4368 };
4369
4370 /* This works around a problem in FreeBSD linker */
4371 #ifdef FREEBSD_WORKAROUND
4372 static const void *lt_preloaded_setup() {
4373   return lt_preloaded_symbols;
4374 }
4375 #endif
4376
4377 #ifdef __cplusplus
4378 }
4379 #endif\
4380 "
4381           fi
4382
4383           pic_flag_for_symtable=
4384           case $host in
4385           # compiling the symbol table file with pic_flag works around
4386           # a FreeBSD bug that causes programs to crash when -lm is
4387           # linked before any other PIC object.  But we must not use
4388           # pic_flag when linking with -static.  The problem exists in
4389           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4390           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4391             case "$compile_command " in
4392             *" -static "*) ;;
4393             *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4394             esac;;
4395           *-*-hpux*)
4396             case "$compile_command " in
4397             *" -static "*) ;;
4398             *) pic_flag_for_symtable=" $pic_flag";;
4399             esac
4400           esac
4401
4402           # Now compile the dynamic symbol file.
4403           $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4404           $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4405
4406           # Clean up the generated files.
4407           $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4408           $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4409
4410           # Transform the symbol file into the correct name.
4411           compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4412           finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4413           ;;
4414         *)
4415           $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4416           exit $EXIT_FAILURE
4417           ;;
4418         esac
4419       else
4420         # We keep going just in case the user didn't refer to
4421         # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
4422         # really was required.
4423
4424         # Nullify the symbol file.
4425         compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
4426         finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
4427       fi
4428
4429       if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
4430         # Replace the output file specification.
4431         compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4432         link_command="$compile_command$compile_rpath"
4433
4434         # We have no uninstalled library dependencies, so finalize right now.
4435         $show "$link_command"
4436         $run eval "$link_command"
4437         status=$?
4438
4439         # Delete the generated files.
4440         if test -n "$dlsyms"; then
4441           $show "$rm $output_objdir/${outputname}S.${objext}"
4442           $run $rm "$output_objdir/${outputname}S.${objext}"
4443         fi
4444
4445         exit $status
4446       fi
4447
4448       if test -n "$shlibpath_var"; then
4449         # We should set the shlibpath_var
4450         rpath=
4451         for dir in $temp_rpath; do
4452           case $dir in
4453           [\\/]* | [A-Za-z]:[\\/]*)
4454             # Absolute path.
4455             rpath="$rpath$dir:"
4456             ;;
4457           *)
4458             # Relative path: add a thisdir entry.
4459             rpath="$rpath\$thisdir/$dir:"
4460             ;;
4461           esac
4462         done
4463         temp_rpath="$rpath"
4464       fi
4465
4466       if test -n "$compile_shlibpath$finalize_shlibpath"; then
4467         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
4468       fi
4469       if test -n "$finalize_shlibpath"; then
4470         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
4471       fi
4472
4473       compile_var=
4474       finalize_var=
4475       if test -n "$runpath_var"; then
4476         if test -n "$perm_rpath"; then
4477           # We should set the runpath_var.
4478           rpath=
4479           for dir in $perm_rpath; do
4480             rpath="$rpath$dir:"
4481           done
4482           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
4483         fi
4484         if test -n "$finalize_perm_rpath"; then
4485           # We should set the runpath_var.
4486           rpath=
4487           for dir in $finalize_perm_rpath; do
4488             rpath="$rpath$dir:"
4489           done
4490           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
4491         fi
4492       fi
4493
4494       if test "$no_install" = yes; then
4495         # We don't need to create a wrapper script.
4496         link_command="$compile_var$compile_command$compile_rpath"
4497         # Replace the output file specification.
4498         link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4499         # Delete the old output file.
4500         $run $rm $output
4501         # Link the executable and exit
4502         $show "$link_command"
4503         $run eval "$link_command" || exit $?
4504         exit $EXIT_SUCCESS
4505       fi
4506
4507       if test "$hardcode_action" = relink; then
4508         # Fast installation is not supported
4509         link_command="$compile_var$compile_command$compile_rpath"
4510         relink_command="$finalize_var$finalize_command$finalize_rpath"
4511
4512         $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
4513         $echo "$modename: \`$output' will be relinked during installation" 1>&2
4514       else
4515         if test "$fast_install" != no; then
4516           link_command="$finalize_var$compile_command$finalize_rpath"
4517           if test "$fast_install" = yes; then
4518             relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
4519           else
4520             # fast_install is set to needless
4521             relink_command=
4522           fi
4523         else
4524           link_command="$compile_var$compile_command$compile_rpath"
4525           relink_command="$finalize_var$finalize_command$finalize_rpath"
4526         fi
4527       fi
4528
4529       # Replace the output file specification.
4530       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4531
4532       # Delete the old output files.
4533       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
4534
4535       $show "$link_command"
4536       $run eval "$link_command" || exit $?
4537
4538       # Now create the wrapper script.
4539       $show "creating $output"
4540
4541       # Quote the relink command for shipping.
4542       if test -n "$relink_command"; then
4543         # Preserve any variables that may affect compiler behavior
4544         for var in $variables_saved_for_relink; do
4545           if eval test -z \"\${$var+set}\"; then
4546             relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
4547           elif eval var_value=\$$var; test -z "$var_value"; then
4548             relink_command="$var=; export $var; $relink_command"
4549           else
4550             var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4551             relink_command="$var=\"$var_value\"; export $var; $relink_command"
4552           fi
4553         done
4554         relink_command="(cd `pwd`; $relink_command)"
4555         relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4556       fi
4557
4558       # Quote $echo for shipping.
4559       if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
4560         case $progpath in
4561         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4562         *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4563         esac
4564         qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4565       else
4566         qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4567       fi
4568
4569       # Only actually do things if our run command is non-null.
4570       if test -z "$run"; then
4571         # win32 will think the script is a binary if it has
4572         # a .exe suffix, so we strip it off here.
4573         case $output in
4574           *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
4575         esac
4576         # test for cygwin because mv fails w/o .exe extensions
4577         case $host in
4578           *cygwin*)
4579             exeext=.exe
4580             outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
4581           *) exeext= ;;
4582         esac
4583         case $host in
4584           *cygwin* | *mingw* )
4585             cwrappersource=`$echo ${objdir}/lt-${output}.c`
4586             cwrapper=`$echo ${output}.exe`
4587             $rm $cwrappersource $cwrapper
4588             trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4589
4590             cat > $cwrappersource <<EOF
4591
4592 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4593    Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4594
4595    The $output program cannot be directly executed until all the libtool
4596    libraries that it depends on are installed.
4597
4598    This wrapper executable should never be moved out of the build directory.
4599    If it is, it will not operate correctly.
4600
4601    Currently, it simply execs the wrapper *script* "/bin/sh $output",
4602    but could eventually absorb all of the scripts functionality and
4603    exec $objdir/$outputname directly.
4604 */
4605 EOF
4606             cat >> $cwrappersource<<"EOF"
4607 #include <stdio.h>
4608 #include <stdlib.h>
4609 #include <unistd.h>
4610 #include <malloc.h>
4611 #include <stdarg.h>
4612 #include <assert.h>
4613
4614 #if defined(PATH_MAX)
4615 # define LT_PATHMAX PATH_MAX
4616 #elif defined(MAXPATHLEN)
4617 # define LT_PATHMAX MAXPATHLEN
4618 #else
4619 # define LT_PATHMAX 1024
4620 #endif
4621
4622 #ifndef DIR_SEPARATOR
4623 #define DIR_SEPARATOR '/'
4624 #endif
4625
4626 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4627   defined (__OS2__)
4628 #define HAVE_DOS_BASED_FILE_SYSTEM
4629 #ifndef DIR_SEPARATOR_2
4630 #define DIR_SEPARATOR_2 '\\'
4631 #endif
4632 #endif
4633
4634 #ifndef DIR_SEPARATOR_2
4635 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4636 #else /* DIR_SEPARATOR_2 */
4637 # define IS_DIR_SEPARATOR(ch) \
4638         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4639 #endif /* DIR_SEPARATOR_2 */
4640
4641 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
4642 #define XFREE(stale) do { \
4643   if (stale) { free ((void *) stale); stale = 0; } \
4644 } while (0)
4645
4646 const char *program_name = NULL;
4647
4648 void * xmalloc (size_t num);
4649 char * xstrdup (const char *string);
4650 char * basename (const char *name);
4651 char * fnqualify(const char *path);
4652 char * strendzap(char *str, const char *pat);
4653 void lt_fatal (const char *message, ...);
4654
4655 int
4656 main (int argc, char *argv[])
4657 {
4658   char **newargz;
4659   int i;
4660
4661   program_name = (char *) xstrdup ((char *) basename (argv[0]));
4662   newargz = XMALLOC(char *, argc+2);
4663 EOF
4664
4665             cat >> $cwrappersource <<EOF
4666   newargz[0] = "$SHELL";
4667 EOF
4668
4669             cat >> $cwrappersource <<"EOF"
4670   newargz[1] = fnqualify(argv[0]);
4671   /* we know the script has the same name, without the .exe */
4672   /* so make sure newargz[1] doesn't end in .exe */
4673   strendzap(newargz[1],".exe");
4674   for (i = 1; i < argc; i++)
4675     newargz[i+1] = xstrdup(argv[i]);
4676   newargz[argc+1] = NULL;
4677 EOF
4678
4679             cat >> $cwrappersource <<EOF
4680   execv("$SHELL",newargz);
4681 EOF
4682
4683             cat >> $cwrappersource <<"EOF"
4684 }
4685
4686 void *
4687 xmalloc (size_t num)
4688 {
4689   void * p = (void *) malloc (num);
4690   if (!p)
4691     lt_fatal ("Memory exhausted");
4692
4693   return p;
4694 }
4695
4696 char *
4697 xstrdup (const char *string)
4698 {
4699   return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
4700 ;
4701 }
4702
4703 char *
4704 basename (const char *name)
4705 {
4706   const char *base;
4707
4708 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4709   /* Skip over the disk name in MSDOS pathnames. */
4710   if (isalpha (name[0]) && name[1] == ':')
4711     name += 2;
4712 #endif
4713
4714   for (base = name; *name; name++)
4715     if (IS_DIR_SEPARATOR (*name))
4716       base = name + 1;
4717   return (char *) base;
4718 }
4719
4720 char *
4721 fnqualify(const char *path)
4722 {
4723   size_t size;
4724   char *p;
4725   char tmp[LT_PATHMAX + 1];
4726
4727   assert(path != NULL);
4728
4729   /* Is it qualified already? */
4730 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4731   if (isalpha (path[0]) && path[1] == ':')
4732     return xstrdup (path);
4733 #endif
4734   if (IS_DIR_SEPARATOR (path[0]))
4735     return xstrdup (path);
4736
4737   /* prepend the current directory */
4738   /* doesn't handle '~' */
4739   if (getcwd (tmp, LT_PATHMAX) == NULL)
4740     lt_fatal ("getcwd failed");
4741   size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */
4742   p = XMALLOC(char, size);
4743   sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path);
4744   return p;
4745 }
4746
4747 char *
4748 strendzap(char *str, const char *pat)
4749 {
4750   size_t len, patlen;
4751
4752   assert(str != NULL);
4753   assert(pat != NULL);
4754
4755   len = strlen(str);
4756   patlen = strlen(pat);
4757
4758   if (patlen <= len)
4759   {
4760     str += len - patlen;
4761     if (strcmp(str, pat) == 0)
4762       *str = '\0';
4763   }
4764   return str;
4765 }
4766
4767 static void
4768 lt_error_core (int exit_status, const char * mode,
4769           const char * message, va_list ap)
4770 {
4771   fprintf (stderr, "%s: %s: ", program_name, mode);
4772   vfprintf (stderr, message, ap);
4773   fprintf (stderr, ".\n");
4774
4775   if (exit_status >= 0)
4776     exit (exit_status);
4777 }
4778
4779 void
4780 lt_fatal (const char *message, ...)
4781 {
4782   va_list ap;
4783   va_start (ap, message);
4784   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4785   va_end (ap);
4786 }
4787 EOF
4788           # we should really use a build-platform specific compiler
4789           # here, but OTOH, the wrappers (shell script and this C one)
4790           # are only useful if you want to execute the "real" binary.
4791           # Since the "real" binary is built for $host, then this
4792           # wrapper might as well be built for $host, too.
4793           $run $LTCC -s -o $cwrapper $cwrappersource
4794           ;;
4795         esac
4796         $rm $output
4797         trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
4798
4799         $echo > $output "\
4800 #! $SHELL
4801
4802 # $output - temporary wrapper script for $objdir/$outputname
4803 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4804 #
4805 # The $output program cannot be directly executed until all the libtool
4806 # libraries that it depends on are installed.
4807 #
4808 # This wrapper script should never be moved out of the build directory.
4809 # If it is, it will not operate correctly.
4810
4811 # Sed substitution that helps us do robust quoting.  It backslashifies
4812 # metacharacters that are still active within double-quoted strings.
4813 Xsed='${SED} -e 1s/^X//'
4814 sed_quote_subst='$sed_quote_subst'
4815
4816 # The HP-UX ksh and POSIX shell print the target directory to stdout
4817 # if CDPATH is set.
4818 if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
4819
4820 relink_command=\"$relink_command\"
4821
4822 # This environment variable determines our operation mode.
4823 if test \"\$libtool_install_magic\" = \"$magic\"; then
4824   # install mode needs the following variable:
4825   notinst_deplibs='$notinst_deplibs'
4826 else
4827   # When we are sourced in execute mode, \$file and \$echo are already set.
4828   if test \"\$libtool_execute_magic\" != \"$magic\"; then
4829     echo=\"$qecho\"
4830     file=\"\$0\"
4831     # Make sure echo works.
4832     if test \"X\$1\" = X--no-reexec; then
4833       # Discard the --no-reexec flag, and continue.
4834       shift
4835     elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
4836       # Yippee, \$echo works!
4837       :
4838     else
4839       # Restart under the correct shell, and then maybe \$echo will work.
4840       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
4841     fi
4842   fi\
4843 "
4844         $echo >> $output "\
4845
4846   # Find the directory that this script lives in.
4847   thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
4848   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4849
4850   # Follow symbolic links until we get to the real thisdir.
4851   file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
4852   while test -n \"\$file\"; do
4853     destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
4854
4855     # If there was a directory component, then change thisdir.
4856     if test \"x\$destdir\" != \"x\$file\"; then
4857       case \"\$destdir\" in
4858       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4859       *) thisdir=\"\$thisdir/\$destdir\" ;;
4860       esac
4861     fi
4862
4863     file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
4864     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
4865   done
4866
4867   # Try to get the absolute directory name.
4868   absdir=\`cd \"\$thisdir\" && pwd\`
4869   test -n \"\$absdir\" && thisdir=\"\$absdir\"
4870 "
4871
4872         if test "$fast_install" = yes; then
4873           $echo >> $output "\
4874   program=lt-'$outputname'$exeext
4875   progdir=\"\$thisdir/$objdir\"
4876
4877   if test ! -f \"\$progdir/\$program\" || \\
4878      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4879        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4880
4881     file=\"\$\$-\$program\"
4882
4883     if test ! -d \"\$progdir\"; then
4884       $mkdir \"\$progdir\"
4885     else
4886       $rm \"\$progdir/\$file\"
4887     fi"
4888
4889           $echo >> $output "\
4890
4891     # relink executable if necessary
4892     if test -n \"\$relink_command\"; then
4893       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4894       else
4895         $echo \"\$relink_command_output\" >&2
4896         $rm \"\$progdir/\$file\"
4897         exit $EXIT_FAILURE
4898       fi
4899     fi
4900
4901     $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4902     { $rm \"\$progdir/\$program\";
4903       $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4904     $rm \"\$progdir/\$file\"
4905   fi"
4906         else
4907           $echo >> $output "\
4908   program='$outputname'
4909   progdir=\"\$thisdir/$objdir\"
4910 "
4911         fi
4912
4913         $echo >> $output "\
4914
4915   if test -f \"\$progdir/\$program\"; then"
4916
4917         # Export our shlibpath_var if we have one.
4918         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4919           $echo >> $output "\
4920     # Add our own library path to $shlibpath_var
4921     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4922
4923     # Some systems cannot cope with colon-terminated $shlibpath_var
4924     # The second colon is a workaround for a bug in BeOS R4 sed
4925     $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
4926
4927     export $shlibpath_var
4928 "
4929         fi
4930
4931         # fixup the dll searchpath if we need to.
4932         if test -n "$dllsearchpath"; then
4933           $echo >> $output "\
4934     # Add the dll search path components to the executable PATH
4935     PATH=$dllsearchpath:\$PATH
4936 "
4937         fi
4938
4939         $echo >> $output "\
4940     if test \"\$libtool_execute_magic\" != \"$magic\"; then
4941       # Run the actual program with our arguments.
4942 "
4943         case $host in
4944         # Backslashes separate directories on plain windows
4945         *-*-mingw | *-*-os2*)
4946           $echo >> $output "\
4947       exec \$progdir\\\\\$program \${1+\"\$@\"}
4948 "
4949           ;;
4950
4951         *)
4952           $echo >> $output "\
4953       exec \$progdir/\$program \${1+\"\$@\"}
4954 "
4955           ;;
4956         esac
4957         $echo >> $output "\
4958       \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
4959       exit $EXIT_FAILURE
4960     fi
4961   else
4962     # The program doesn't exist.
4963     \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
4964     \$echo \"This script is just a wrapper for \$program.\" 1>&2
4965     $echo \"See the $PACKAGE documentation for more information.\" 1>&2
4966     exit $EXIT_FAILURE
4967   fi
4968 fi\
4969 "
4970         chmod +x $output
4971       fi
4972       exit $EXIT_SUCCESS
4973       ;;
4974     esac
4975
4976     # See if we need to build an old-fashioned archive.
4977     for oldlib in $oldlibs; do
4978
4979       if test "$build_libtool_libs" = convenience; then
4980         oldobjs="$libobjs_save"
4981         addlibs="$convenience"
4982         build_libtool_libs=no
4983       else
4984         if test "$build_libtool_libs" = module; then
4985           oldobjs="$libobjs_save"
4986           build_libtool_libs=no
4987         else
4988           oldobjs="$old_deplibs $non_pic_objects"
4989         fi
4990         addlibs="$old_convenience"
4991       fi
4992
4993       if test -n "$addlibs"; then
4994         gentop="$output_objdir/${outputname}x"
4995         $show "${rm}r $gentop"
4996         $run ${rm}r "$gentop"
4997         $show "$mkdir $gentop"
4998         $run $mkdir "$gentop"
4999         status=$?
5000         if test "$status" -ne 0 && test ! -d "$gentop"; then
5001           exit $status
5002         fi
5003         generated="$generated $gentop"
5004
5005         # Add in members from convenience archives.
5006         for xlib in $addlibs; do
5007           # Extract the objects.
5008           case $xlib in
5009           [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
5010           *) xabs=`pwd`"/$xlib" ;;
5011           esac
5012           xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
5013           xdir="$gentop/$xlib"
5014
5015           $show "${rm}r $xdir"
5016           $run ${rm}r "$xdir"
5017           $show "$mkdir $xdir"
5018           $run $mkdir "$xdir"
5019           status=$?
5020           if test "$status" -ne 0 && test ! -d "$xdir"; then
5021             exit $status
5022           fi
5023           # We will extract separately just the conflicting names and we will no
5024           # longer touch any unique names. It is faster to leave these extract
5025           # automatically by $AR in one run.
5026           $show "(cd $xdir && $AR x $xabs)"
5027           $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
5028           if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
5029             :
5030           else
5031             $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
5032             $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
5033             $AR t "$xabs" | sort | uniq -cd | while read -r count name
5034             do
5035               i=1
5036               while test "$i" -le "$count"
5037               do
5038                # Put our $i before any first dot (extension)
5039                # Never overwrite any file
5040                name_to="$name"
5041                while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
5042                do
5043                  name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
5044                done
5045                $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
5046                $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
5047                i=`expr $i + 1`
5048               done
5049             done
5050           fi
5051
5052           oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP`
5053         done
5054       fi
5055
5056       # Do each command in the archive commands.
5057       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
5058        cmds=$old_archive_from_new_cmds
5059       else
5060         eval cmds=\"$old_archive_cmds\"
5061
5062         if len=`expr "X$cmds" : ".*"` &&
5063              test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
5064           cmds=$old_archive_cmds
5065         else
5066           # the command line is too long to link in one step, link in parts
5067           $echo "using piecewise archive linking..."
5068           save_RANLIB=$RANLIB
5069           RANLIB=:
5070           objlist=
5071           concat_cmds=
5072           save_oldobjs=$oldobjs
5073           # GNU ar 2.10+ was changed to match POSIX; thus no paths are
5074           # encoded into archives.  This makes 'ar r' malfunction in
5075           # this piecewise linking case whenever conflicting object
5076           # names appear in distinct ar calls; check, warn and compensate.
5077             if (for obj in $save_oldobjs
5078             do
5079               $echo "X$obj" | $Xsed -e 's%^.*/%%'
5080             done | sort | sort -uc >/dev/null 2>&1); then
5081             :
5082           else
5083             $echo "$modename: warning: object name conflicts; overriding AR_FLAGS to 'cq'" 1>&2
5084             $echo "$modename: warning: to ensure that POSIX-compatible ar will work" 1>&2
5085             AR_FLAGS=cq
5086           fi
5087           # Is there a better way of finding the last object in the list?
5088           for obj in $save_oldobjs
5089           do
5090             last_oldobj=$obj
5091           done
5092           for obj in $save_oldobjs
5093           do
5094             oldobjs="$objlist $obj"
5095             objlist="$objlist $obj"
5096             eval test_cmds=\"$old_archive_cmds\"
5097             if len=`expr "X$test_cmds" : ".*"` &&
5098                test "$len" -le "$max_cmd_len"; then
5099               :
5100             else
5101               # the above command should be used before it gets too long
5102               oldobjs=$objlist
5103               if test "$obj" = "$last_oldobj" ; then
5104                 RANLIB=$save_RANLIB
5105               fi
5106               test -z "$concat_cmds" || concat_cmds=$concat_cmds~
5107               eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
5108               objlist=
5109             fi
5110           done
5111           RANLIB=$save_RANLIB
5112           oldobjs=$objlist
5113           if test "X$oldobjs" = "X" ; then
5114             eval cmds=\"\$concat_cmds\"
5115           else
5116             eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
5117           fi
5118         fi
5119       fi
5120       save_ifs="$IFS"; IFS='~'
5121       for cmd in $cmds; do
5122         eval cmd=\"$cmd\"
5123         IFS="$save_ifs"
5124         $show "$cmd"
5125         $run eval "$cmd" || exit $?
5126       done
5127       IFS="$save_ifs"
5128     done
5129
5130     if test -n "$generated"; then
5131       $show "${rm}r$generated"
5132       $run ${rm}r$generated
5133     fi
5134
5135     # Now create the libtool archive.
5136     case $output in
5137     *.la)
5138       old_library=
5139       test "$build_old_libs" = yes && old_library="$libname.$libext"
5140       $show "creating $output"
5141
5142       # Preserve any variables that may affect compiler behavior
5143       for var in $variables_saved_for_relink; do
5144         if eval test -z \"\${$var+set}\"; then
5145           relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
5146         elif eval var_value=\$$var; test -z "$var_value"; then
5147           relink_command="$var=; export $var; $relink_command"
5148         else
5149           var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
5150           relink_command="$var=\"$var_value\"; export $var; $relink_command"
5151         fi
5152       done
5153       # Quote the link command for shipping.
5154       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
5155       relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
5156       if test "$hardcode_automatic" = yes ; then
5157         relink_command=
5158       fi
5159
5160
5161       # Only create the output if not a dry run.
5162       if test -z "$run"; then
5163         for installed in no yes; do
5164           if test "$installed" = yes; then
5165             if test -z "$install_libdir"; then
5166               break
5167             fi
5168             output="$output_objdir/$outputname"i
5169             # Replace all uninstalled libtool libraries with the installed ones
5170             newdependency_libs=
5171             for deplib in $dependency_libs; do
5172               case $deplib in
5173               *.la)
5174                 name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5175                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5176                 if test -z "$libdir"; then
5177                   $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5178                   exit $EXIT_FAILURE
5179                 fi
5180                 newdependency_libs="$newdependency_libs $libdir/$name"
5181                 ;;
5182               *) newdependency_libs="$newdependency_libs $deplib" ;;
5183               esac
5184             done
5185             dependency_libs="$newdependency_libs"
5186             newdlfiles=
5187             for lib in $dlfiles; do
5188               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5189               eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5190               if test -z "$libdir"; then
5191                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5192                 exit $EXIT_FAILURE
5193               fi
5194               newdlfiles="$newdlfiles $libdir/$name"
5195             done
5196             dlfiles="$newdlfiles"
5197             newdlprefiles=
5198             for lib in $dlprefiles; do
5199               name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5200               eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5201               if test -z "$libdir"; then
5202                 $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5203                 exit $EXIT_FAILURE
5204               fi
5205               newdlprefiles="$newdlprefiles $libdir/$name"
5206             done
5207             dlprefiles="$newdlprefiles"
5208           else
5209             newdlfiles=
5210             for lib in $dlfiles; do
5211               case $lib in
5212                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5213                 *) abs=`pwd`"/$lib" ;;
5214               esac
5215               newdlfiles="$newdlfiles $abs"
5216             done
5217             dlfiles="$newdlfiles"
5218             newdlprefiles=
5219             for lib in $dlprefiles; do
5220               case $lib in
5221                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5222                 *) abs=`pwd`"/$lib" ;;
5223               esac
5224               newdlprefiles="$newdlprefiles $abs"
5225             done
5226             dlprefiles="$newdlprefiles"
5227           fi
5228           $rm $output
5229           # place dlname in correct position for cygwin
5230           tdlname=$dlname
5231           case $host,$output,$installed,$module,$dlname in
5232             *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
5233           esac
5234           $echo > $output "\
5235 # $outputname - a libtool library file
5236 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5237 #
5238 # Please DO NOT delete this file!
5239 # It is necessary for linking the library.
5240
5241 # The name that we can dlopen(3).
5242 dlname='$tdlname'
5243
5244 # Names of this library.
5245 library_names='$library_names'
5246
5247 # The name of the static archive.
5248 old_library='$old_library'
5249
5250 # Libraries that this one depends upon.
5251 dependency_libs='$dependency_libs'
5252
5253 # Version information for $libname.
5254 current=$current
5255 age=$age
5256 revision=$revision
5257
5258 # Is this an already installed library?
5259 installed=$installed
5260
5261 # Should we warn about portability when linking against -modules?
5262 shouldnotlink=$module
5263
5264 # Files to dlopen/dlpreopen
5265 dlopen='$dlfiles'
5266 dlpreopen='$dlprefiles'
5267
5268 # Directory that this library needs to be installed in:
5269 libdir='$install_libdir'"
5270           if test "$installed" = no && test "$need_relink" = yes; then
5271             $echo >> $output "\
5272 relink_command=\"$relink_command\""
5273           fi
5274         done
5275       fi
5276
5277       # Do a symbolic link so that the libtool archive can be found in
5278       # LD_LIBRARY_PATH before the program is installed.
5279       $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5280       $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5281       ;;
5282     esac
5283     exit $EXIT_SUCCESS
5284     ;;
5285
5286   # libtool install mode
5287   install)
5288     modename="$modename: install"
5289
5290     # There may be an optional sh(1) argument at the beginning of
5291     # install_prog (especially on Windows NT).
5292     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5293        # Allow the use of GNU shtool's install command.
5294        $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
5295       # Aesthetically quote it.
5296       arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5297       case $arg in
5298       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
5299         arg="\"$arg\""
5300         ;;
5301       esac
5302       install_prog="$arg "
5303       arg="$1"
5304       shift
5305     else
5306       install_prog=
5307       arg="$nonopt"
5308     fi
5309
5310     # The real first argument should be the name of the installation program.
5311     # Aesthetically quote it.
5312     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5313     case $arg in
5314     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
5315       arg="\"$arg\""
5316       ;;
5317     esac
5318     install_prog="$install_prog$arg"
5319
5320     # We need to accept at least all the BSD install flags.
5321     dest=
5322     files=
5323     opts=
5324     prev=
5325     install_type=
5326     isdir=no
5327     stripme=
5328     for arg
5329     do
5330       if test -n "$dest"; then
5331         files="$files $dest"
5332         dest="$arg"
5333         continue
5334       fi
5335
5336       case $arg in
5337       -d) isdir=yes ;;
5338       -f) prev="-f" ;;
5339       -g) prev="-g" ;;
5340       -m) prev="-m" ;;
5341       -o) prev="-o" ;;
5342       -s)
5343         stripme=" -s"
5344         continue
5345         ;;
5346       -*) ;;
5347
5348       *)
5349         # If the previous option needed an argument, then skip it.
5350         if test -n "$prev"; then
5351           prev=
5352         else
5353           dest="$arg"
5354           continue
5355         fi
5356         ;;
5357       esac
5358
5359       # Aesthetically quote the argument.
5360       arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5361       case $arg in
5362       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
5363         arg="\"$arg\""
5364         ;;
5365       esac
5366       install_prog="$install_prog $arg"
5367     done
5368
5369     if test -z "$install_prog"; then
5370       $echo "$modename: you must specify an install program" 1>&2
5371       $echo "$help" 1>&2
5372       exit $EXIT_FAILURE
5373     fi
5374
5375     if test -n "$prev"; then
5376       $echo "$modename: the \`$prev' option requires an argument" 1>&2
5377       $echo "$help" 1>&2
5378       exit $EXIT_FAILURE
5379     fi
5380
5381     if test -z "$files"; then
5382       if test -z "$dest"; then
5383         $echo "$modename: no file or destination specified" 1>&2
5384       else
5385         $echo "$modename: you must specify a destination" 1>&2
5386       fi
5387       $echo "$help" 1>&2
5388       exit $EXIT_FAILURE
5389     fi
5390
5391     # Strip any trailing slash from the destination.
5392     dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5393
5394     # Check to see that the destination is a directory.
5395     test -d "$dest" && isdir=yes
5396     if test "$isdir" = yes; then
5397       destdir="$dest"
5398       destname=
5399     else
5400       destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5401       test "X$destdir" = "X$dest" && destdir=.
5402       destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5403
5404       # Not a directory, so check to see that there is only one file specified.
5405       set dummy $files
5406       if test "$#" -gt 2; then
5407         $echo "$modename: \`$dest' is not a directory" 1>&2
5408         $echo "$help" 1>&2
5409         exit $EXIT_FAILURE
5410       fi
5411     fi
5412     case $destdir in
5413     [\\/]* | [A-Za-z]:[\\/]*) ;;
5414     *)
5415       for file in $files; do
5416         case $file in
5417         *.lo) ;;
5418         *)
5419           $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5420           $echo "$help" 1>&2
5421           exit $EXIT_FAILURE
5422           ;;
5423         esac
5424       done
5425       ;;
5426     esac
5427
5428     # This variable tells wrapper scripts just to set variables rather
5429     # than running their programs.
5430     libtool_install_magic="$magic"
5431
5432     staticlibs=
5433     future_libdirs=
5434     current_libdirs=
5435     for file in $files; do
5436
5437       # Do each installation.
5438       case $file in
5439       *.$libext)
5440         # Do the static libraries later.
5441         staticlibs="$staticlibs $file"
5442         ;;
5443
5444       *.la)
5445         # Check to see that this really is a libtool archive.
5446         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5447         else
5448           $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5449           $echo "$help" 1>&2
5450           exit $EXIT_FAILURE
5451         fi
5452
5453         library_names=
5454         old_library=
5455         relink_command=
5456         # If there is no directory component, then add one.
5457         case $file in
5458         */* | *\\*) . $file ;;
5459         *) . ./$file ;;
5460         esac
5461
5462         # Add the libdir to current_libdirs if it is the destination.
5463         if test "X$destdir" = "X$libdir"; then
5464           case "$current_libdirs " in
5465           *" $libdir "*) ;;
5466           *) current_libdirs="$current_libdirs $libdir" ;;
5467           esac
5468         else
5469           # Note the libdir as a future libdir.
5470           case "$future_libdirs " in
5471           *" $libdir "*) ;;
5472           *) future_libdirs="$future_libdirs $libdir" ;;
5473           esac
5474         fi
5475
5476         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5477         test "X$dir" = "X$file/" && dir=
5478         dir="$dir$objdir"
5479
5480         if test -n "$relink_command"; then
5481           # Determine the prefix the user has applied to our future dir.
5482           inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5483
5484           # Don't allow the user to place us outside of our expected
5485           # location b/c this prevents finding dependent libraries that
5486           # are installed to the same prefix.
5487           # At present, this check doesn't affect windows .dll's that
5488           # are installed into $libdir/../bin (currently, that works fine)
5489           # but it's something to keep an eye on.
5490           if test "$inst_prefix_dir" = "$destdir"; then
5491             $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5492             exit $EXIT_FAILURE
5493           fi
5494
5495           if test -n "$inst_prefix_dir"; then
5496             # Stick the inst_prefix_dir data into the link command.
5497             relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
5498           else
5499             relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
5500           fi
5501
5502           $echo "$modename: warning: relinking \`$file'" 1>&2
5503           $show "$relink_command"
5504           if $run eval "$relink_command"; then :
5505           else
5506             $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5507             exit $EXIT_FAILURE
5508           fi
5509         fi
5510
5511         # See the names of the shared library.
5512         set dummy $library_names
5513         if test -n "$2"; then
5514           realname="$2"
5515           shift
5516           shift
5517
5518           srcname="$realname"
5519           test -n "$relink_command" && srcname="$realname"T
5520
5521           # Install the shared library and build the symlinks.
5522           $show "$install_prog $dir/$srcname $destdir/$realname"
5523           $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
5524           if test -n "$stripme" && test -n "$striplib"; then
5525             $show "$striplib $destdir/$realname"
5526             $run eval "$striplib $destdir/$realname" || exit $?
5527           fi
5528
5529           if test "$#" -gt 0; then
5530             # Delete the old symlinks, and create new ones.
5531             for linkname
5532             do
5533               if test "$linkname" != "$realname"; then
5534                 $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5535                 $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5536               fi
5537             done
5538           fi
5539
5540           # Do each command in the postinstall commands.
5541           lib="$destdir/$realname"
5542           cmds=$postinstall_cmds
5543           save_ifs="$IFS"; IFS='~'
5544           for cmd in $cmds; do
5545             IFS="$save_ifs"
5546             eval cmd=\"$cmd\"
5547             $show "$cmd"
5548             $run eval "$cmd" || exit $?
5549           done
5550           IFS="$save_ifs"
5551         fi
5552
5553         # Install the pseudo-library for information purposes.
5554         name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5555         instname="$dir/$name"i
5556         $show "$install_prog $instname $destdir/$name"
5557         $run eval "$install_prog $instname $destdir/$name" || exit $?
5558
5559         # Maybe install the static library, too.
5560         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
5561         ;;
5562
5563       *.lo)
5564         # Install (i.e. copy) a libtool object.
5565
5566         # Figure out destination file name, if it wasn't already specified.
5567         if test -n "$destname"; then
5568           destfile="$destdir/$destname"
5569         else
5570           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5571           destfile="$destdir/$destfile"
5572         fi
5573
5574         # Deduce the name of the destination old-style object file.
5575         case $destfile in
5576         *.lo)
5577           staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
5578           ;;
5579         *.$objext)
5580           staticdest="$destfile"
5581           destfile=
5582           ;;
5583         *)
5584           $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
5585           $echo "$help" 1>&2
5586           exit $EXIT_FAILURE
5587           ;;
5588         esac
5589
5590         # Install the libtool object if requested.
5591         if test -n "$destfile"; then
5592           $show "$install_prog $file $destfile"
5593           $run eval "$install_prog $file $destfile" || exit $?
5594         fi
5595
5596         # Install the old object if enabled.
5597         if test "$build_old_libs" = yes; then
5598           # Deduce the name of the old-style object file.
5599           staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
5600
5601           $show "$install_prog $staticobj $staticdest"
5602           $run eval "$install_prog \$staticobj \$staticdest" || exit $?
5603         fi
5604         exit $EXIT_SUCCESS
5605         ;;
5606
5607       *)
5608         # Figure out destination file name, if it wasn't already specified.
5609         if test -n "$destname"; then
5610           destfile="$destdir/$destname"
5611         else
5612           destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5613           destfile="$destdir/$destfile"
5614         fi
5615
5616         # If the file is missing, and there is a .exe on the end, strip it
5617         # because it is most likely a libtool script we actually want to
5618         # install
5619         stripped_ext=""
5620         case $file in
5621           *.exe)
5622             if test ! -f "$file"; then
5623               file=`$echo $file|${SED} 's,.exe$,,'`
5624               stripped_ext=".exe"
5625             fi
5626             ;;
5627         esac
5628
5629         # Do a test to see if this is really a libtool program.
5630         case $host in
5631         *cygwin*|*mingw*)
5632             wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
5633             ;;
5634         *)
5635             wrapper=$file
5636             ;;
5637         esac
5638         if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
5639           notinst_deplibs=
5640           relink_command=
5641
5642           # To insure that "foo" is sourced, and not "foo.exe",
5643           # finese the cygwin/MSYS system by explicitly sourcing "foo."
5644           # which disallows the automatic-append-.exe behavior.
5645           case $build in
5646           *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5647           *) wrapperdot=${wrapper} ;;
5648           esac
5649           # If there is no directory component, then add one.
5650           case $file in
5651           */* | *\\*) . ${wrapperdot} ;;
5652           *) . ./${wrapperdot} ;;
5653           esac
5654
5655           # Check the variables that should have been set.
5656           if test -z "$notinst_deplibs"; then
5657             $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
5658             exit $EXIT_FAILURE
5659           fi
5660
5661           finalize=yes
5662           for lib in $notinst_deplibs; do
5663             # Check to see that each library is installed.
5664             libdir=
5665             if test -f "$lib"; then
5666               # If there is no directory component, then add one.
5667               case $lib in
5668               */* | *\\*) . $lib ;;
5669               *) . ./$lib ;;
5670               esac
5671             fi
5672             libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
5673             if test -n "$libdir" && test ! -f "$libfile"; then
5674               $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
5675               finalize=no
5676             fi
5677           done
5678
5679           relink_command=
5680           # To insure that "foo" is sourced, and not "foo.exe",
5681           # finese the cygwin/MSYS system by explicitly sourcing "foo."
5682           # which disallows the automatic-append-.exe behavior.
5683           case $build in
5684           *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5685           *) wrapperdot=${wrapper} ;;
5686           esac
5687           # If there is no directory component, then add one.
5688           case $file in
5689           */* | *\\*) . ${wrapperdot} ;;
5690           *) . ./${wrapperdot} ;;
5691           esac
5692
5693           outputname=
5694           if test "$fast_install" = no && test -n "$relink_command"; then
5695             if test "$finalize" = yes && test -z "$run"; then
5696               tmpdir="/tmp"
5697               test -n "$TMPDIR" && tmpdir="$TMPDIR"
5698               tmpdir="$tmpdir/libtool-$$"
5699               save_umask=`umask`
5700               umask 0077
5701               if $mkdir "$tmpdir"; then
5702                 umask $save_umask
5703               else
5704                 umask $save_umask
5705                 $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
5706                 continue
5707               fi
5708               file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
5709               outputname="$tmpdir/$file"
5710               # Replace the output file specification.
5711               relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
5712
5713               $show "$relink_command"
5714               if $run eval "$relink_command"; then :
5715               else
5716                 $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5717                 ${rm}r "$tmpdir"
5718                 continue
5719               fi
5720               file="$outputname"
5721             else
5722               $echo "$modename: warning: cannot relink \`$file'" 1>&2
5723             fi
5724           else
5725             # Install the binary that we compiled earlier.
5726             file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
5727           fi
5728         fi
5729
5730         # remove .exe since cygwin /usr/bin/install will append another
5731         # one anyways
5732         case $install_prog,$host in
5733         */usr/bin/install*,*cygwin*)
5734           case $file:$destfile in
5735           *.exe:*.exe)
5736             # this is ok
5737             ;;
5738           *.exe:*)
5739             destfile=$destfile.exe
5740             ;;
5741           *:*.exe)
5742             destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
5743             ;;
5744           esac
5745           ;;
5746         esac
5747         $show "$install_prog$stripme $file $destfile"
5748         $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
5749         test -n "$outputname" && ${rm}r "$tmpdir"
5750         ;;
5751       esac
5752     done
5753
5754     for file in $staticlibs; do
5755       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5756
5757       # Set up the ranlib parameters.
5758       oldlib="$destdir/$name"
5759
5760       $show "$install_prog $file $oldlib"
5761       $run eval "$install_prog \$file \$oldlib" || exit $?
5762
5763       if test -n "$stripme" && test -n "$old_striplib"; then
5764         $show "$old_striplib $oldlib"
5765         $run eval "$old_striplib $oldlib" || exit $?
5766       fi
5767
5768       # Do each command in the postinstall commands.
5769       cmds=$old_postinstall_cmds
5770       save_ifs="$IFS"; IFS='~'
5771       for cmd in $cmds; do
5772         IFS="$save_ifs"
5773         eval cmd=\"$cmd\"
5774         $show "$cmd"
5775         $run eval "$cmd" || exit $?
5776       done
5777       IFS="$save_ifs"
5778     done
5779
5780     if test -n "$future_libdirs"; then
5781       $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
5782     fi
5783
5784     if test -n "$current_libdirs"; then
5785       # Maybe just do a dry run.
5786       test -n "$run" && current_libdirs=" -n$current_libdirs"
5787       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
5788     else
5789       exit $EXIT_SUCCESS
5790     fi
5791     ;;
5792
5793   # libtool finish mode
5794   finish)
5795     modename="$modename: finish"
5796     libdirs="$nonopt"
5797     admincmds=
5798
5799     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
5800       for dir
5801       do
5802         libdirs="$libdirs $dir"
5803       done
5804
5805       for libdir in $libdirs; do
5806         if test -n "$finish_cmds"; then
5807           # Do each command in the finish commands.
5808           cmds=$finish_cmds
5809           save_ifs="$IFS"; IFS='~'
5810           for cmd in $cmds; do
5811             IFS="$save_ifs"
5812             eval cmd=\"$cmd\"
5813             $show "$cmd"
5814             $run eval "$cmd" || admincmds="$admincmds
5815        $cmd"
5816           done
5817           IFS="$save_ifs"
5818         fi
5819         if test -n "$finish_eval"; then
5820           # Do the single finish_eval.
5821           eval cmds=\"$finish_eval\"
5822           $run eval "$cmds" || admincmds="$admincmds
5823        $cmds"
5824         fi
5825       done
5826     fi
5827
5828     # Exit here if they wanted silent mode.
5829     test "$show" = : && exit $EXIT_SUCCESS
5830
5831     $echo "----------------------------------------------------------------------"
5832     $echo "Libraries have been installed in:"
5833     for libdir in $libdirs; do
5834       $echo "   $libdir"
5835     done
5836     $echo
5837     $echo "If you ever happen to want to link against installed libraries"
5838     $echo "in a given directory, LIBDIR, you must either use libtool, and"
5839     $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
5840     $echo "flag during linking and do at least one of the following:"
5841     if test -n "$shlibpath_var"; then
5842       $echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
5843       $echo "     during execution"
5844     fi
5845     if test -n "$runpath_var"; then
5846       $echo "   - add LIBDIR to the \`$runpath_var' environment variable"
5847       $echo "     during linking"
5848     fi
5849     if test -n "$hardcode_libdir_flag_spec"; then
5850       libdir=LIBDIR
5851       eval flag=\"$hardcode_libdir_flag_spec\"
5852
5853       $echo "   - use the \`$flag' linker flag"
5854     fi
5855     if test -n "$admincmds"; then
5856       $echo "   - have your system administrator run these commands:$admincmds"
5857     fi
5858     if test -f /etc/ld.so.conf; then
5859       $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
5860     fi
5861     $echo
5862     $echo "See any operating system documentation about shared libraries for"
5863     $echo "more information, such as the ld(1) and ld.so(8) manual pages."
5864     $echo "----------------------------------------------------------------------"
5865     exit $EXIT_SUCCESS
5866     ;;
5867
5868   # libtool execute mode
5869   execute)
5870     modename="$modename: execute"
5871
5872     # The first argument is the command name.
5873     cmd="$nonopt"
5874     if test -z "$cmd"; then
5875       $echo "$modename: you must specify a COMMAND" 1>&2
5876       $echo "$help"
5877       exit $EXIT_FAILURE
5878     fi
5879
5880     # Handle -dlopen flags immediately.
5881     for file in $execute_dlfiles; do
5882       if test ! -f "$file"; then
5883         $echo "$modename: \`$file' is not a file" 1>&2
5884         $echo "$help" 1>&2
5885         exit $EXIT_FAILURE
5886       fi
5887
5888       dir=
5889       case $file in
5890       *.la)
5891         # Check to see that this really is a libtool archive.
5892         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5893         else
5894           $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5895           $echo "$help" 1>&2
5896           exit $EXIT_FAILURE
5897         fi
5898
5899         # Read the libtool library.
5900         dlname=
5901         library_names=
5902
5903         # If there is no directory component, then add one.
5904         case $file in
5905         */* | *\\*) . $file ;;
5906         *) . ./$file ;;
5907         esac
5908
5909         # Skip this library if it cannot be dlopened.
5910         if test -z "$dlname"; then
5911           # Warn if it was a shared library.
5912           test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
5913           continue
5914         fi
5915
5916         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5917         test "X$dir" = "X$file" && dir=.
5918
5919         if test -f "$dir/$objdir/$dlname"; then
5920           dir="$dir/$objdir"
5921         else
5922           $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
5923           exit $EXIT_FAILURE
5924         fi
5925         ;;
5926
5927       *.lo)
5928         # Just add the directory containing the .lo file.
5929         dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5930         test "X$dir" = "X$file" && dir=.
5931         ;;
5932
5933       *)
5934         $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
5935         continue
5936         ;;
5937       esac
5938
5939       # Get the absolute pathname.
5940       absdir=`cd "$dir" && pwd`
5941       test -n "$absdir" && dir="$absdir"
5942
5943       # Now add the directory to shlibpath_var.
5944       if eval "test -z \"\$$shlibpath_var\""; then
5945         eval "$shlibpath_var=\"\$dir\""
5946       else
5947         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
5948       fi
5949     done
5950
5951     # This variable tells wrapper scripts just to set shlibpath_var
5952     # rather than running their programs.
5953     libtool_execute_magic="$magic"
5954
5955     # Check if any of the arguments is a wrapper script.
5956     args=
5957     for file
5958     do
5959       case $file in
5960       -*) ;;
5961       *)
5962         # Do a test to see if this is really a libtool program.
5963         if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5964           # If there is no directory component, then add one.
5965           case $file in
5966           */* | *\\*) . $file ;;
5967           *) . ./$file ;;
5968           esac
5969
5970           # Transform arg to wrapped name.
5971           file="$progdir/$program"
5972         fi
5973         ;;
5974       esac
5975       # Quote arguments (to preserve shell metacharacters).
5976       file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
5977       args="$args \"$file\""
5978     done
5979
5980     if test -z "$run"; then
5981       if test -n "$shlibpath_var"; then
5982         # Export the shlibpath_var.
5983         eval "export $shlibpath_var"
5984       fi
5985
5986       # Restore saved environment variables
5987       if test "${save_LC_ALL+set}" = set; then
5988         LC_ALL="$save_LC_ALL"; export LC_ALL
5989       fi
5990       if test "${save_LANG+set}" = set; then
5991         LANG="$save_LANG"; export LANG
5992       fi
5993
5994       # Now prepare to actually exec the command.
5995       exec_cmd="\$cmd$args"
5996     else
5997       # Display what would be done.
5998       if test -n "$shlibpath_var"; then
5999         eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
6000         $echo "export $shlibpath_var"
6001       fi
6002       $echo "$cmd$args"
6003       exit $EXIT_SUCCESS
6004     fi
6005     ;;
6006
6007   # libtool clean and uninstall mode
6008   clean | uninstall)
6009     modename="$modename: $mode"
6010     rm="$nonopt"
6011     files=
6012     rmforce=
6013     exit_status=0
6014
6015     # This variable tells wrapper scripts just to set variables rather
6016     # than running their programs.
6017     libtool_install_magic="$magic"
6018
6019     for arg
6020     do
6021       case $arg in
6022       -f) rm="$rm $arg"; rmforce=yes ;;
6023       -*) rm="$rm $arg" ;;
6024       *) files="$files $arg" ;;
6025       esac
6026     done
6027
6028     if test -z "$rm"; then
6029       $echo "$modename: you must specify an RM program" 1>&2
6030       $echo "$help" 1>&2
6031       exit $EXIT_FAILURE
6032     fi
6033
6034     rmdirs=
6035
6036     origobjdir="$objdir"
6037     for file in $files; do
6038       dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6039       if test "X$dir" = "X$file"; then
6040         dir=.
6041         objdir="$origobjdir"
6042       else
6043         objdir="$dir/$origobjdir"
6044       fi
6045       name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6046       test "$mode" = uninstall && objdir="$dir"
6047
6048       # Remember objdir for removal later, being careful to avoid duplicates
6049       if test "$mode" = clean; then
6050         case " $rmdirs " in
6051           *" $objdir "*) ;;
6052           *) rmdirs="$rmdirs $objdir" ;;
6053         esac
6054       fi
6055
6056       # Don't error if the file doesn't exist and rm -f was used.
6057       if (test -L "$file") >/dev/null 2>&1 \
6058         || (test -h "$file") >/dev/null 2>&1 \
6059         || test -f "$file"; then
6060         :
6061       elif test -d "$file"; then
6062         exit_status=1
6063         continue
6064       elif test "$rmforce" = yes; then
6065         continue
6066       fi
6067
6068       rmfiles="$file"
6069
6070       case $name in
6071       *.la)
6072         # Possibly a libtool archive, so verify it.
6073         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6074           . $dir/$name
6075
6076           # Delete the libtool libraries and symlinks.
6077           for n in $library_names; do
6078             rmfiles="$rmfiles $objdir/$n"
6079           done
6080           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
6081           test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
6082
6083           if test "$mode" = uninstall; then
6084             if test -n "$library_names"; then
6085               # Do each command in the postuninstall commands.
6086               cmds=$postuninstall_cmds
6087               save_ifs="$IFS"; IFS='~'
6088               for cmd in $cmds; do
6089                 IFS="$save_ifs"
6090                 eval cmd=\"$cmd\"
6091                 $show "$cmd"
6092                 $run eval "$cmd"
6093                 if test "$?" -ne 0 && test "$rmforce" != yes; then
6094                   exit_status=1
6095                 fi
6096               done
6097               IFS="$save_ifs"
6098             fi
6099
6100             if test -n "$old_library"; then
6101               # Do each command in the old_postuninstall commands.
6102               cmds=$old_postuninstall_cmds
6103               save_ifs="$IFS"; IFS='~'
6104               for cmd in $cmds; do
6105                 IFS="$save_ifs"
6106                 eval cmd=\"$cmd\"
6107                 $show "$cmd"
6108                 $run eval "$cmd"
6109                 if test "$?" -ne 0 && test "$rmforce" != yes; then
6110                   exit_status=1
6111                 fi
6112               done
6113               IFS="$save_ifs"
6114             fi
6115             # FIXME: should reinstall the best remaining shared library.
6116           fi
6117         fi
6118         ;;
6119
6120       *.lo)
6121         # Possibly a libtool object, so verify it.
6122         if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6123
6124           # Read the .lo file
6125           . $dir/$name
6126
6127           # Add PIC object to the list of files to remove.
6128           if test -n "$pic_object" \
6129              && test "$pic_object" != none; then
6130             rmfiles="$rmfiles $dir/$pic_object"
6131           fi
6132
6133           # Add non-PIC object to the list of files to remove.
6134           if test -n "$non_pic_object" \
6135              && test "$non_pic_object" != none; then
6136             rmfiles="$rmfiles $dir/$non_pic_object"
6137           fi
6138         fi
6139         ;;
6140
6141       *)
6142         if test "$mode" = clean ; then
6143           noexename=$name
6144           case $file in
6145           *.exe)
6146             file=`$echo $file|${SED} 's,.exe$,,'`
6147             noexename=`$echo $name|${SED} 's,.exe$,,'`
6148             # $file with .exe has already been added to rmfiles,
6149             # add $file without .exe
6150             rmfiles="$rmfiles $file"
6151             ;;
6152           esac
6153           # Do a test to see if this is a libtool program.
6154           if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6155             relink_command=
6156             . $dir/$noexename
6157
6158             # note $name still contains .exe if it was in $file originally
6159             # as does the version of $file that was added into $rmfiles
6160             rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
6161             if test "$fast_install" = yes && test -n "$relink_command"; then
6162               rmfiles="$rmfiles $objdir/lt-$name"
6163             fi
6164             if test "X$noexename" != "X$name" ; then
6165               rmfiles="$rmfiles $objdir/lt-${noexename}.c"
6166             fi
6167           fi
6168         fi
6169         ;;
6170       esac
6171       $show "$rm $rmfiles"
6172       $run $rm $rmfiles || exit_status=1
6173     done
6174     objdir="$origobjdir"
6175
6176     # Try to remove the ${objdir}s in the directories where we deleted files
6177     for dir in $rmdirs; do
6178       if test -d "$dir"; then
6179         $show "rmdir $dir"
6180         $run rmdir $dir >/dev/null 2>&1
6181       fi
6182     done
6183
6184     exit $exit_status
6185     ;;
6186
6187   "")
6188     $echo "$modename: you must specify a MODE" 1>&2
6189     $echo "$generic_help" 1>&2
6190     exit $EXIT_FAILURE
6191     ;;
6192   esac
6193
6194   if test -z "$exec_cmd"; then
6195     $echo "$modename: invalid operation mode \`$mode'" 1>&2
6196     $echo "$generic_help" 1>&2
6197     exit $EXIT_FAILURE
6198   fi
6199 fi # test -z "$show_help"
6200
6201 if test -n "$exec_cmd"; then
6202   eval exec $exec_cmd
6203   exit $EXIT_FAILURE
6204 fi
6205
6206 # We need to display help for each of the modes.
6207 case $mode in
6208 "") $echo \
6209 "Usage: $modename [OPTION]... [MODE-ARG]...
6210
6211 Provide generalized library-building support services.
6212
6213     --config          show all configuration variables
6214     --debug           enable verbose shell tracing
6215 -n, --dry-run         display commands without modifying any files
6216     --features        display basic configuration information and exit
6217     --finish          same as \`--mode=finish'
6218     --help            display this help message and exit
6219     --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
6220     --quiet           same as \`--silent'
6221     --silent          don't print informational messages
6222     --tag=TAG         use configuration variables from tag TAG
6223     --version         print version information
6224
6225 MODE must be one of the following:
6226
6227       clean           remove files from the build directory
6228       compile         compile a source file into a libtool object
6229       execute         automatically set library path, then run a program
6230       finish          complete the installation of libtool libraries
6231       install         install libraries or executables
6232       link            create a library or an executable
6233       uninstall       remove libraries from an installed directory
6234
6235 MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
6236 a more detailed description of MODE.
6237
6238 Report bugs to <bug-libtool@gnu.org>."
6239   exit $EXIT_SUCCESS
6240   ;;
6241
6242 clean)
6243   $echo \
6244 "Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
6245
6246 Remove files from the build directory.
6247
6248 RM is the name of the program to use to delete files associated with each FILE
6249 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6250 to RM.
6251
6252 If FILE is a libtool library, object or program, all the files associated
6253 with it are deleted. Otherwise, only FILE itself is deleted using RM."
6254   ;;
6255
6256 compile)
6257   $echo \
6258 "Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
6259
6260 Compile a source file into a libtool library object.
6261
6262 This mode accepts the following additional options:
6263
6264   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
6265   -prefer-pic       try to building PIC objects only
6266   -prefer-non-pic   try to building non-PIC objects only
6267   -static           always build a \`.o' file suitable for static linking
6268
6269 COMPILE-COMMAND is a command to be used in creating a \`standard' object file
6270 from the given SOURCEFILE.
6271
6272 The output file name is determined by removing the directory component from
6273 SOURCEFILE, then substituting the C source code suffix \`.c' with the
6274 library object suffix, \`.lo'."
6275   ;;
6276
6277 execute)
6278   $echo \
6279 "Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
6280
6281 Automatically set library path, then run a program.
6282
6283 This mode accepts the following additional options:
6284
6285   -dlopen FILE      add the directory containing FILE to the library path
6286
6287 This mode sets the library path environment variable according to \`-dlopen'
6288 flags.
6289
6290 If any of the ARGS are libtool executable wrappers, then they are translated
6291 into their corresponding uninstalled binary, and any of their required library
6292 directories are added to the library path.
6293
6294 Then, COMMAND is executed, with ARGS as arguments."
6295   ;;
6296
6297 finish)
6298   $echo \
6299 "Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
6300
6301 Complete the installation of libtool libraries.
6302
6303 Each LIBDIR is a directory that contains libtool libraries.
6304
6305 The commands that this mode executes may require superuser privileges.  Use
6306 the \`--dry-run' option if you just want to see what would be executed."
6307   ;;
6308
6309 install)
6310   $echo \
6311 "Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
6312
6313 Install executables or libraries.
6314
6315 INSTALL-COMMAND is the installation command.  The first component should be
6316 either the \`install' or \`cp' program.
6317
6318 The rest of the components are interpreted as arguments to that command (only
6319 BSD-compatible install options are recognized)."
6320   ;;
6321
6322 link)
6323   $echo \
6324 "Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
6325
6326 Link object files or libraries together to form another library, or to
6327 create an executable program.
6328
6329 LINK-COMMAND is a command using the C compiler that you would use to create
6330 a program from several object files.
6331
6332 The following components of LINK-COMMAND are treated specially:
6333
6334   -all-static       do not do any dynamic linking at all
6335   -avoid-version    do not add a version suffix if possible
6336   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
6337   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
6338   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
6339   -export-symbols SYMFILE
6340                     try to export only the symbols listed in SYMFILE
6341   -export-symbols-regex REGEX
6342                     try to export only the symbols matching REGEX
6343   -LLIBDIR          search LIBDIR for required installed libraries
6344   -lNAME            OUTPUT-FILE requires the installed library libNAME
6345   -module           build a library that can dlopened
6346   -no-fast-install  disable the fast-install mode
6347   -no-install       link a not-installable executable
6348   -no-undefined     declare that a library does not refer to external symbols
6349   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
6350   -objectlist FILE  Use a list of object files found in FILE to specify objects
6351   -precious-files-regex REGEX
6352                     don't remove output files matching REGEX
6353   -release RELEASE  specify package release information
6354   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
6355   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
6356   -static           do not do any dynamic linking of libtool libraries
6357   -version-info CURRENT[:REVISION[:AGE]]
6358                     specify library version info [each variable defaults to 0]
6359
6360 All other options (arguments beginning with \`-') are ignored.
6361
6362 Every other argument is treated as a filename.  Files ending in \`.la' are
6363 treated as uninstalled libtool libraries, other files are standard or library
6364 object files.
6365
6366 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
6367 only library objects (\`.lo' files) may be specified, and \`-rpath' is
6368 required, except when creating a convenience library.
6369
6370 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
6371 using \`ar' and \`ranlib', or on Windows using \`lib'.
6372
6373 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
6374 is created, otherwise an executable program is created."
6375   ;;
6376
6377 uninstall)
6378   $echo \
6379 "Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
6380
6381 Remove libraries from an installation directory.
6382
6383 RM is the name of the program to use to delete files associated with each FILE
6384 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6385 to RM.
6386
6387 If FILE is a libtool library, all the files associated with it are deleted.
6388 Otherwise, only FILE itself is deleted using RM."
6389   ;;
6390
6391 *)
6392   $echo "$modename: invalid operation mode \`$mode'" 1>&2
6393   $echo "$help" 1>&2
6394   exit $EXIT_FAILURE
6395   ;;
6396 esac
6397
6398 $echo
6399 $echo "Try \`$modename --help' for more information about other modes."
6400
6401 exit $EXIT_SUCCESS
6402
6403 # The TAGs below are defined such that we never get into a situation
6404 # in which we disable both kinds of libraries.  Given conflicting
6405 # choices, we go for a static library, that is the most portable,
6406 # since we can't tell whether shared libraries were disabled because
6407 # the user asked for that or because the platform doesn't support
6408 # them.  This is particularly important on AIX, because we don't
6409 # support having both static and shared libraries enabled at the same
6410 # time on that platform, so we default to a shared-only configuration.
6411 # If a disable-shared tag is given, we'll fallback to a static-only
6412 # configuration.  But we'll never go from static-only to shared-only.
6413
6414 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
6415 build_libtool_libs=no
6416 build_old_libs=yes
6417 # ### END LIBTOOL TAG CONFIG: disable-shared
6418
6419 # ### BEGIN LIBTOOL TAG CONFIG: disable-static
6420 build_old_libs=`case $build_libtool_libs in yes) $echo no;; *) $echo yes;; esac`
6421 # ### END LIBTOOL TAG CONFIG: disable-static
6422
6423 # Local Variables:
6424 # mode:shell-script
6425 # sh-indentation:2
6426 # End: