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