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