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