"Fossies" - the Fresh Open Source Software Archive

Member "tre-0.8.0/utils/ltmain.sh" (8 Feb 2008, 199991 Bytes) of package /linux/misc/tre-0.8.0.tar.gz:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) Bash source code syntax highlighting (style: standard) with prefixed line numbers. Alternatively you can here view or download the uninterpreted source code file.

    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, 2006,
    5 # 2007, 2008  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.26 Debian 1.5.26-1ubuntu1"
   47 TIMESTAMP=" (1.1220.2.493 2008/02/01 16:58:18)"
   48 
   49 # Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
   50 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
   51   emulate sh
   52   NULLCMD=:
   53   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
   54   # is contrary to our usage.  Disable this feature.
   55   alias -g '${1+"$@"}'='"$@"'
   56   setopt NO_GLOB_SUBST
   57 else
   58   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
   59 fi
   60 BIN_SH=xpg4; export BIN_SH # for Tru64
   61 DUALCASE=1; export DUALCASE # for MKS sh
   62 
   63 # Check that we have a working $echo.
   64 if test "X$1" = X--no-reexec; then
   65   # Discard the --no-reexec flag, and continue.
   66   shift
   67 elif test "X$1" = X--fallback-echo; then
   68   # Avoid inline document here, it may be left over
   69   :
   70 elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
   71   # Yippee, $echo works!
   72   :
   73 else
   74   # Restart under the correct shell, and then maybe $echo will work.
   75   exec $SHELL "$progpath" --no-reexec ${1+"$@"}
   76 fi
   77 
   78 if test "X$1" = X--fallback-echo; then
   79   # used as fallback echo
   80   shift
   81   cat <<EOF
   82 $*
   83 EOF
   84   exit $EXIT_SUCCESS
   85 fi
   86 
   87 default_mode=
   88 help="Try \`$progname --help' for more information."
   89 magic="%%%MAGIC variable%%%"
   90 mkdir="mkdir"
   91 mv="mv -f"
   92 rm="rm -f"
   93 
   94 # Sed substitution that helps us do robust quoting.  It backslashifies
   95 # metacharacters that are still active within double-quoted strings.
   96 Xsed="${SED}"' -e 1s/^X//'
   97 sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
   98 # test EBCDIC or ASCII
   99 case `echo X|tr X '\101'` in
  100  A) # ASCII based system
  101     # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
  102   SP2NL='tr \040 \012'
  103   NL2SP='tr \015\012 \040\040'
  104   ;;
  105  *) # EBCDIC based system
  106   SP2NL='tr \100 \n'
  107   NL2SP='tr \r\n \100\100'
  108   ;;
  109 esac
  110 
  111 # NLS nuisances.
  112 # Only set LANG and LC_ALL to C if already set.
  113 # These must not be set unconditionally because not all systems understand
  114 # e.g. LANG=C (notably SCO).
  115 # We save the old values to restore during execute mode.
  116 lt_env=
  117 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
  118 do
  119   eval "if test \"\${$lt_var+set}\" = set; then
  120       save_$lt_var=\$$lt_var
  121       lt_env=\"$lt_var=\$$lt_var \$lt_env\"
  122       $lt_var=C
  123       export $lt_var
  124     fi"
  125 done
  126 
  127 if test -n "$lt_env"; then
  128   lt_env="env $lt_env"
  129 fi
  130 
  131 # Make sure IFS has a sensible default
  132 lt_nl='
  133 '
  134 IFS="   $lt_nl"
  135 
  136 if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
  137   $echo "$modename: not configured to build any kind of library" 1>&2
  138   $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
  139   exit $EXIT_FAILURE
  140 fi
  141 
  142 # Global variables.
  143 mode=$default_mode
  144 nonopt=
  145 prev=
  146 prevopt=
  147 run=
  148 show="$echo"
  149 show_help=
  150 execute_dlfiles=
  151 duplicate_deps=no
  152 preserve_args=
  153 lo2o="s/\\.lo\$/.${objext}/"
  154 o2lo="s/\\.${objext}\$/.lo/"
  155 extracted_archives=
  156 extracted_serial=0
  157 
  158 #####################################
  159 # Shell function definitions:
  160 # This seems to be the best place for them
  161 
  162 # func_mktempdir [string]
  163 # Make a temporary directory that won't clash with other running
  164 # libtool processes, and avoids race conditions if possible.  If
  165 # given, STRING is the basename for that directory.
  166 func_mktempdir ()
  167 {
  168     my_template="${TMPDIR-/tmp}/${1-$progname}"
  169 
  170     if test "$run" = ":"; then
  171       # Return a directory name, but don't create it in dry-run mode
  172       my_tmpdir="${my_template}-$$"
  173     else
  174 
  175       # If mktemp works, use that first and foremost
  176       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
  177 
  178       if test ! -d "$my_tmpdir"; then
  179     # Failing that, at least try and use $RANDOM to avoid a race
  180     my_tmpdir="${my_template}-${RANDOM-0}$$"
  181 
  182     save_mktempdir_umask=`umask`
  183     umask 0077
  184     $mkdir "$my_tmpdir"
  185     umask $save_mktempdir_umask
  186       fi
  187 
  188       # If we're not in dry-run mode, bomb out on failure
  189       test -d "$my_tmpdir" || {
  190         $echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
  191     exit $EXIT_FAILURE
  192       }
  193     fi
  194 
  195     $echo "X$my_tmpdir" | $Xsed
  196 }
  197 
  198 
  199 # func_win32_libid arg
  200 # return the library type of file 'arg'
  201 #
  202 # Need a lot of goo to handle *both* DLLs and import libs
  203 # Has to be a shell function in order to 'eat' the argument
  204 # that is supplied when $file_magic_command is called.
  205 func_win32_libid ()
  206 {
  207   win32_libid_type="unknown"
  208   win32_fileres=`file -L $1 2>/dev/null`
  209   case $win32_fileres in
  210   *ar\ archive\ import\ library*) # definitely import
  211     win32_libid_type="x86 archive import"
  212     ;;
  213   *ar\ archive*) # could be an import, or static
  214     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
  215       $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
  216       win32_nmres=`eval $NM -f posix -A $1 | \
  217     $SED -n -e '1,100{
  218         / I /{
  219             s,.*,import,
  220             p
  221             q
  222             }
  223         }'`
  224       case $win32_nmres in
  225       import*)  win32_libid_type="x86 archive import";;
  226       *)        win32_libid_type="x86 archive static";;
  227       esac
  228     fi
  229     ;;
  230   *DLL*)
  231     win32_libid_type="x86 DLL"
  232     ;;
  233   *executable*) # but shell scripts are "executable" too...
  234     case $win32_fileres in
  235     *MS\ Windows\ PE\ Intel*)
  236       win32_libid_type="x86 DLL"
  237       ;;
  238     esac
  239     ;;
  240   esac
  241   $echo $win32_libid_type
  242 }
  243 
  244 
  245 # func_infer_tag arg
  246 # Infer tagged configuration to use if any are available and
  247 # if one wasn't chosen via the "--tag" command line option.
  248 # Only attempt this if the compiler in the base compile
  249 # command doesn't match the default compiler.
  250 # arg is usually of the form 'gcc ...'
  251 func_infer_tag ()
  252 {
  253     if test -n "$available_tags" && test -z "$tagname"; then
  254       CC_quoted=
  255       for arg in $CC; do
  256     case $arg in
  257       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
  258       arg="\"$arg\""
  259       ;;
  260     esac
  261     CC_quoted="$CC_quoted $arg"
  262       done
  263       case $@ in
  264       # Blanks in the command may have been stripped by the calling shell,
  265       # but not from the CC environment variable when configure was run.
  266       " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
  267       # Blanks at the start of $base_compile will cause this to fail
  268       # if we don't check for them as well.
  269       *)
  270     for z in $available_tags; do
  271       if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
  272         # Evaluate the configuration.
  273         eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
  274         CC_quoted=
  275         for arg in $CC; do
  276         # Double-quote args containing other shell metacharacters.
  277         case $arg in
  278           *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
  279           arg="\"$arg\""
  280           ;;
  281         esac
  282         CC_quoted="$CC_quoted $arg"
  283       done
  284         case "$@ " in
  285           " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
  286           # The compiler in the base compile command matches
  287           # the one in the tagged configuration.
  288           # Assume this is the tagged configuration we want.
  289           tagname=$z
  290           break
  291           ;;
  292         esac
  293       fi
  294     done
  295     # If $tagname still isn't set, then no tagged configuration
  296     # was found and let the user know that the "--tag" command
  297     # line option must be used.
  298     if test -z "$tagname"; then
  299       $echo "$modename: unable to infer tagged configuration"
  300       $echo "$modename: specify a tag with \`--tag'" 1>&2
  301       exit $EXIT_FAILURE
  302 #        else
  303 #          $echo "$modename: using $tagname tagged configuration"
  304     fi
  305     ;;
  306       esac
  307     fi
  308 }
  309 
  310 
  311 # func_extract_an_archive dir oldlib
  312 func_extract_an_archive ()
  313 {
  314     f_ex_an_ar_dir="$1"; shift
  315     f_ex_an_ar_oldlib="$1"
  316 
  317     $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
  318     $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
  319     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
  320      :
  321     else
  322       $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
  323       exit $EXIT_FAILURE
  324     fi
  325 }
  326 
  327 # func_extract_archives gentop oldlib ...
  328 func_extract_archives ()
  329 {
  330     my_gentop="$1"; shift
  331     my_oldlibs=${1+"$@"}
  332     my_oldobjs=""
  333     my_xlib=""
  334     my_xabs=""
  335     my_xdir=""
  336     my_status=""
  337 
  338     $show "${rm}r $my_gentop"
  339     $run ${rm}r "$my_gentop"
  340     $show "$mkdir $my_gentop"
  341     $run $mkdir "$my_gentop"
  342     my_status=$?
  343     if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
  344       exit $my_status
  345     fi
  346 
  347     for my_xlib in $my_oldlibs; do
  348       # Extract the objects.
  349       case $my_xlib in
  350     [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
  351     *) my_xabs=`pwd`"/$my_xlib" ;;
  352       esac
  353       my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
  354       my_xlib_u=$my_xlib
  355       while :; do
  356         case " $extracted_archives " in
  357     *" $my_xlib_u "*)
  358       extracted_serial=`expr $extracted_serial + 1`
  359       my_xlib_u=lt$extracted_serial-$my_xlib ;;
  360     *) break ;;
  361     esac
  362       done
  363       extracted_archives="$extracted_archives $my_xlib_u"
  364       my_xdir="$my_gentop/$my_xlib_u"
  365 
  366       $show "${rm}r $my_xdir"
  367       $run ${rm}r "$my_xdir"
  368       $show "$mkdir $my_xdir"
  369       $run $mkdir "$my_xdir"
  370       exit_status=$?
  371       if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
  372     exit $exit_status
  373       fi
  374       case $host in
  375       *-darwin*)
  376     $show "Extracting $my_xabs"
  377     # Do not bother doing anything if just a dry run
  378     if test -z "$run"; then
  379       darwin_orig_dir=`pwd`
  380       cd $my_xdir || exit $?
  381       darwin_archive=$my_xabs
  382       darwin_curdir=`pwd`
  383       darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
  384       darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
  385       if test -n "$darwin_arches"; then 
  386         darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
  387         darwin_arch=
  388         $show "$darwin_base_archive has multiple architectures $darwin_arches"
  389         for darwin_arch in  $darwin_arches ; do
  390           mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
  391           lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
  392           cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
  393           func_extract_an_archive "`pwd`" "${darwin_base_archive}"
  394           cd "$darwin_curdir"
  395           $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
  396         done # $darwin_arches
  397       ## Okay now we have a bunch of thin objects, gotta fatten them up :)
  398         darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
  399         darwin_file=
  400         darwin_files=
  401         for darwin_file in $darwin_filelist; do
  402           darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
  403           lipo -create -output "$darwin_file" $darwin_files
  404         done # $darwin_filelist
  405         ${rm}r unfat-$$
  406         cd "$darwin_orig_dir"
  407       else
  408         cd "$darwin_orig_dir"
  409         func_extract_an_archive "$my_xdir" "$my_xabs"
  410       fi # $darwin_arches
  411     fi # $run
  412     ;;
  413       *)
  414         func_extract_an_archive "$my_xdir" "$my_xabs"
  415         ;;
  416       esac
  417       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
  418     done
  419     func_extract_archives_result="$my_oldobjs"
  420 }
  421 # End of Shell function definitions
  422 #####################################
  423 
  424 # Darwin sucks
  425 eval std_shrext=\"$shrext_cmds\"
  426 
  427 disable_libs=no
  428 
  429 # Parse our command line options once, thoroughly.
  430 while test "$#" -gt 0
  431 do
  432   arg="$1"
  433   shift
  434 
  435   case $arg in
  436   -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
  437   *) optarg= ;;
  438   esac
  439 
  440   # If the previous option needs an argument, assign it.
  441   if test -n "$prev"; then
  442     case $prev in
  443     execute_dlfiles)
  444       execute_dlfiles="$execute_dlfiles $arg"
  445       ;;
  446     tag)
  447       tagname="$arg"
  448       preserve_args="${preserve_args}=$arg"
  449 
  450       # Check whether tagname contains only valid characters
  451       case $tagname in
  452       *[!-_A-Za-z0-9,/]*)
  453     $echo "$progname: invalid tag name: $tagname" 1>&2
  454     exit $EXIT_FAILURE
  455     ;;
  456       esac
  457 
  458       case $tagname in
  459       CC)
  460     # Don't test for the "default" C tag, as we know, it's there, but
  461     # not specially marked.
  462     ;;
  463       *)
  464     if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
  465       taglist="$taglist $tagname"
  466       # Evaluate the configuration.
  467       eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
  468     else
  469       $echo "$progname: ignoring unknown tag $tagname" 1>&2
  470     fi
  471     ;;
  472       esac
  473       ;;
  474     *)
  475       eval "$prev=\$arg"
  476       ;;
  477     esac
  478 
  479     prev=
  480     prevopt=
  481     continue
  482   fi
  483 
  484   # Have we seen a non-optional argument yet?
  485   case $arg in
  486   --help)
  487     show_help=yes
  488     ;;
  489 
  490   --version)
  491     echo "\
  492 $PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP
  493 
  494 Copyright (C) 2008  Free Software Foundation, Inc.
  495 This is free software; see the source for copying conditions.  There is NO
  496 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
  497     exit $?
  498     ;;
  499 
  500   --config)
  501     ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
  502     # Now print the configurations for the tags.
  503     for tagname in $taglist; do
  504       ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
  505     done
  506     exit $?
  507     ;;
  508 
  509   --debug)
  510     $echo "$progname: enabling shell trace mode"
  511     set -x
  512     preserve_args="$preserve_args $arg"
  513     ;;
  514 
  515   --dry-run | -n)
  516     run=:
  517     ;;
  518 
  519   --features)
  520     $echo "host: $host"
  521     if test "$build_libtool_libs" = yes; then
  522       $echo "enable shared libraries"
  523     else
  524       $echo "disable shared libraries"
  525     fi
  526     if test "$build_old_libs" = yes; then
  527       $echo "enable static libraries"
  528     else
  529       $echo "disable static libraries"
  530     fi
  531     exit $?
  532     ;;
  533 
  534   --finish) mode="finish" ;;
  535 
  536   --mode) prevopt="--mode" prev=mode ;;
  537   --mode=*) mode="$optarg" ;;
  538 
  539   --preserve-dup-deps) duplicate_deps="yes" ;;
  540 
  541   --quiet | --silent)
  542     show=:
  543     preserve_args="$preserve_args $arg"
  544     ;;
  545 
  546   --tag)
  547     prevopt="--tag"
  548     prev=tag
  549     preserve_args="$preserve_args --tag"
  550     ;;
  551   --tag=*)
  552     set tag "$optarg" ${1+"$@"}
  553     shift
  554     prev=tag
  555     preserve_args="$preserve_args --tag"
  556     ;;
  557 
  558   -dlopen)
  559     prevopt="-dlopen"
  560     prev=execute_dlfiles
  561     ;;
  562 
  563   -*)
  564     $echo "$modename: unrecognized option \`$arg'" 1>&2
  565     $echo "$help" 1>&2
  566     exit $EXIT_FAILURE
  567     ;;
  568 
  569   *)
  570     nonopt="$arg"
  571     break
  572     ;;
  573   esac
  574 done
  575 
  576 if test -n "$prevopt"; then
  577   $echo "$modename: option \`$prevopt' requires an argument" 1>&2
  578   $echo "$help" 1>&2
  579   exit $EXIT_FAILURE
  580 fi
  581 
  582 case $disable_libs in
  583 no) 
  584   ;;
  585 shared)
  586   build_libtool_libs=no
  587   build_old_libs=yes
  588   ;;
  589 static)
  590   build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
  591   ;;
  592 esac
  593 
  594 # If this variable is set in any of the actions, the command in it
  595 # will be execed at the end.  This prevents here-documents from being
  596 # left over by shells.
  597 exec_cmd=
  598 
  599 if test -z "$show_help"; then
  600 
  601   # Infer the operation mode.
  602   if test -z "$mode"; then
  603     $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
  604     $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
  605     case $nonopt in
  606     *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
  607       mode=link
  608       for arg
  609       do
  610     case $arg in
  611     -c)
  612        mode=compile
  613        break
  614        ;;
  615     esac
  616       done
  617       ;;
  618     *db | *dbx | *strace | *truss)
  619       mode=execute
  620       ;;
  621     *install*|cp|mv)
  622       mode=install
  623       ;;
  624     *rm)
  625       mode=uninstall
  626       ;;
  627     *)
  628       # If we have no mode, but dlfiles were specified, then do execute mode.
  629       test -n "$execute_dlfiles" && mode=execute
  630 
  631       # Just use the default operation mode.
  632       if test -z "$mode"; then
  633     if test -n "$nonopt"; then
  634       $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
  635     else
  636       $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
  637     fi
  638       fi
  639       ;;
  640     esac
  641   fi
  642 
  643   # Only execute mode is allowed to have -dlopen flags.
  644   if test -n "$execute_dlfiles" && test "$mode" != execute; then
  645     $echo "$modename: unrecognized option \`-dlopen'" 1>&2
  646     $echo "$help" 1>&2
  647     exit $EXIT_FAILURE
  648   fi
  649 
  650   # Change the help message to a mode-specific one.
  651   generic_help="$help"
  652   help="Try \`$modename --help --mode=$mode' for more information."
  653 
  654   # These modes are in order of execution frequency so that they run quickly.
  655   case $mode in
  656   # libtool compile mode
  657   compile)
  658     modename="$modename: compile"
  659     # Get the compilation command and the source file.
  660     base_compile=
  661     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
  662     suppress_opt=yes
  663     suppress_output=
  664     arg_mode=normal
  665     libobj=
  666     later=
  667 
  668     for arg
  669     do
  670       case $arg_mode in
  671       arg  )
  672     # do not "continue".  Instead, add this to base_compile
  673     lastarg="$arg"
  674     arg_mode=normal
  675     ;;
  676 
  677       target )
  678     libobj="$arg"
  679     arg_mode=normal
  680     continue
  681     ;;
  682 
  683       normal )
  684     # Accept any command-line options.
  685     case $arg in
  686     -o)
  687       if test -n "$libobj" ; then
  688         $echo "$modename: you cannot specify \`-o' more than once" 1>&2
  689         exit $EXIT_FAILURE
  690       fi
  691       arg_mode=target
  692       continue
  693       ;;
  694 
  695     -static | -prefer-pic | -prefer-non-pic)
  696       later="$later $arg"
  697       continue
  698       ;;
  699 
  700     -no-suppress)
  701       suppress_opt=no
  702       continue
  703       ;;
  704 
  705     -Xcompiler)
  706       arg_mode=arg  #  the next one goes into the "base_compile" arg list
  707       continue      #  The current "srcfile" will either be retained or
  708       ;;            #  replaced later.  I would guess that would be a bug.
  709 
  710     -Wc,*)
  711       args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
  712       lastarg=
  713       save_ifs="$IFS"; IFS=','
  714       for arg in $args; do
  715         IFS="$save_ifs"
  716 
  717         # Double-quote args containing other shell metacharacters.
  718         # Many Bourne shells cannot handle close brackets correctly
  719         # in scan sets, so we specify it separately.
  720         case $arg in
  721           *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
  722           arg="\"$arg\""
  723           ;;
  724         esac
  725         lastarg="$lastarg $arg"
  726       done
  727       IFS="$save_ifs"
  728       lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
  729 
  730       # Add the arguments to base_compile.
  731       base_compile="$base_compile $lastarg"
  732       continue
  733       ;;
  734 
  735     * )
  736       # Accept the current argument as the source file.
  737       # The previous "srcfile" becomes the current argument.
  738       #
  739       lastarg="$srcfile"
  740       srcfile="$arg"
  741       ;;
  742     esac  #  case $arg
  743     ;;
  744       esac    #  case $arg_mode
  745 
  746       # Aesthetically quote the previous argument.
  747       lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
  748 
  749       case $lastarg in
  750       # Double-quote args containing other shell metacharacters.
  751       # Many Bourne shells cannot handle close brackets correctly
  752       # in scan sets, and some SunOS ksh mistreat backslash-escaping
  753       # in scan sets (worked around with variable expansion),
  754       # and furthermore cannot handle '|' '&' '(' ')' in scan sets 
  755       # at all, so we specify them separately.
  756       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
  757     lastarg="\"$lastarg\""
  758     ;;
  759       esac
  760 
  761       base_compile="$base_compile $lastarg"
  762     done # for arg
  763 
  764     case $arg_mode in
  765     arg)
  766       $echo "$modename: you must specify an argument for -Xcompile"
  767       exit $EXIT_FAILURE
  768       ;;
  769     target)
  770       $echo "$modename: you must specify a target with \`-o'" 1>&2
  771       exit $EXIT_FAILURE
  772       ;;
  773     *)
  774       # Get the name of the library object.
  775       [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
  776       ;;
  777     esac
  778 
  779     # Recognize several different file suffixes.
  780     # If the user specifies -o file.o, it is replaced with file.lo
  781     xform='[cCFSifmso]'
  782     case $libobj in
  783     *.ada) xform=ada ;;
  784     *.adb) xform=adb ;;
  785     *.ads) xform=ads ;;
  786     *.asm) xform=asm ;;
  787     *.c++) xform=c++ ;;
  788     *.cc) xform=cc ;;
  789     *.ii) xform=ii ;;
  790     *.class) xform=class ;;
  791     *.cpp) xform=cpp ;;
  792     *.cxx) xform=cxx ;;
  793     *.[fF][09]?) xform=[fF][09]. ;;
  794     *.for) xform=for ;;
  795     *.java) xform=java ;;
  796     *.obj) xform=obj ;;
  797     *.sx) xform=sx ;;
  798     esac
  799 
  800     libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
  801 
  802     case $libobj in
  803     *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
  804     *)
  805       $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
  806       exit $EXIT_FAILURE
  807       ;;
  808     esac
  809 
  810     func_infer_tag $base_compile
  811 
  812     for arg in $later; do
  813       case $arg in
  814       -static)
  815     build_old_libs=yes
  816     continue
  817     ;;
  818 
  819       -prefer-pic)
  820     pic_mode=yes
  821     continue
  822     ;;
  823 
  824       -prefer-non-pic)
  825     pic_mode=no
  826     continue
  827     ;;
  828       esac
  829     done
  830 
  831     qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
  832     case $qlibobj in
  833       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
  834     qlibobj="\"$qlibobj\"" ;;
  835     esac
  836     test "X$libobj" != "X$qlibobj" \
  837     && $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"'  &()|`$[]' \
  838     && $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
  839     objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
  840     xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
  841     if test "X$xdir" = "X$obj"; then
  842       xdir=
  843     else
  844       xdir=$xdir/
  845     fi
  846     lobj=${xdir}$objdir/$objname
  847 
  848     if test -z "$base_compile"; then
  849       $echo "$modename: you must specify a compilation command" 1>&2
  850       $echo "$help" 1>&2
  851       exit $EXIT_FAILURE
  852     fi
  853 
  854     # Delete any leftover library objects.
  855     if test "$build_old_libs" = yes; then
  856       removelist="$obj $lobj $libobj ${libobj}T"
  857     else
  858       removelist="$lobj $libobj ${libobj}T"
  859     fi
  860 
  861     $run $rm $removelist
  862     trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
  863 
  864     # On Cygwin there's no "real" PIC flag so we must build both object types
  865     case $host_os in
  866     cygwin* | mingw* | pw32* | os2*)
  867       pic_mode=default
  868       ;;
  869     esac
  870     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
  871       # non-PIC code in shared libraries is not supported
  872       pic_mode=default
  873     fi
  874 
  875     # Calculate the filename of the output object if compiler does
  876     # not support -o with -c
  877     if test "$compiler_c_o" = no; then
  878       output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
  879       lockfile="$output_obj.lock"
  880       removelist="$removelist $output_obj $lockfile"
  881       trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
  882     else
  883       output_obj=
  884       need_locks=no
  885       lockfile=
  886     fi
  887 
  888     # Lock this critical section if it is needed
  889     # We use this script file to make the link, it avoids creating a new file
  890     if test "$need_locks" = yes; then
  891       until $run ln "$progpath" "$lockfile" 2>/dev/null; do
  892     $show "Waiting for $lockfile to be removed"
  893     sleep 2
  894       done
  895     elif test "$need_locks" = warn; then
  896       if test -f "$lockfile"; then
  897     $echo "\
  898 *** ERROR, $lockfile exists and contains:
  899 `cat $lockfile 2>/dev/null`
  900 
  901 This indicates that another process is trying to use the same
  902 temporary object file, and libtool could not work around it because
  903 your compiler does not support \`-c' and \`-o' together.  If you
  904 repeat this compilation, it may succeed, by chance, but you had better
  905 avoid parallel builds (make -j) in this platform, or get a better
  906 compiler."
  907 
  908     $run $rm $removelist
  909     exit $EXIT_FAILURE
  910       fi
  911       $echo "$srcfile" > "$lockfile"
  912     fi
  913 
  914     if test -n "$fix_srcfile_path"; then
  915       eval srcfile=\"$fix_srcfile_path\"
  916     fi
  917     qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
  918     case $qsrcfile in
  919       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
  920       qsrcfile="\"$qsrcfile\"" ;;
  921     esac
  922 
  923     $run $rm "$libobj" "${libobj}T"
  924 
  925     # Create a libtool object file (analogous to a ".la" file),
  926     # but don't create it if we're doing a dry run.
  927     test -z "$run" && cat > ${libobj}T <<EOF
  928 # $libobj - a libtool object file
  929 # Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
  930 #
  931 # Please DO NOT delete this file!
  932 # It is necessary for linking the library.
  933 
  934 # Name of the PIC object.
  935 EOF
  936 
  937     # Only build a PIC object if we are building libtool libraries.
  938     if test "$build_libtool_libs" = yes; then
  939       # Without this assignment, base_compile gets emptied.
  940       fbsd_hideous_sh_bug=$base_compile
  941 
  942       if test "$pic_mode" != no; then
  943     command="$base_compile $qsrcfile $pic_flag"
  944       else
  945     # Don't build PIC code
  946     command="$base_compile $qsrcfile"
  947       fi
  948 
  949       if test ! -d "${xdir}$objdir"; then
  950     $show "$mkdir ${xdir}$objdir"
  951     $run $mkdir ${xdir}$objdir
  952     exit_status=$?
  953     if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
  954       exit $exit_status
  955     fi
  956       fi
  957 
  958       if test -z "$output_obj"; then
  959     # Place PIC objects in $objdir
  960     command="$command -o $lobj"
  961       fi
  962 
  963       $run $rm "$lobj" "$output_obj"
  964 
  965       $show "$command"
  966       if $run eval $lt_env "$command"; then :
  967       else
  968     test -n "$output_obj" && $run $rm $removelist
  969     exit $EXIT_FAILURE
  970       fi
  971 
  972       if test "$need_locks" = warn &&
  973      test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
  974     $echo "\
  975 *** ERROR, $lockfile contains:
  976 `cat $lockfile 2>/dev/null`
  977 
  978 but it should contain:
  979 $srcfile
  980 
  981 This indicates that another process is trying to use the same
  982 temporary object file, and libtool could not work around it because
  983 your compiler does not support \`-c' and \`-o' together.  If you
  984 repeat this compilation, it may succeed, by chance, but you had better
  985 avoid parallel builds (make -j) in this platform, or get a better
  986 compiler."
  987 
  988     $run $rm $removelist
  989     exit $EXIT_FAILURE
  990       fi
  991 
  992       # Just move the object if needed, then go on to compile the next one
  993       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
  994     $show "$mv $output_obj $lobj"
  995     if $run $mv $output_obj $lobj; then :
  996     else
  997       error=$?
  998       $run $rm $removelist
  999       exit $error
 1000     fi
 1001       fi
 1002 
 1003       # Append the name of the PIC object to the libtool object file.
 1004       test -z "$run" && cat >> ${libobj}T <<EOF
 1005 pic_object='$objdir/$objname'
 1006 
 1007 EOF
 1008 
 1009       # Allow error messages only from the first compilation.
 1010       if test "$suppress_opt" = yes; then
 1011         suppress_output=' >/dev/null 2>&1'
 1012       fi
 1013     else
 1014       # No PIC object so indicate it doesn't exist in the libtool
 1015       # object file.
 1016       test -z "$run" && cat >> ${libobj}T <<EOF
 1017 pic_object=none
 1018 
 1019 EOF
 1020     fi
 1021 
 1022     # Only build a position-dependent object if we build old libraries.
 1023     if test "$build_old_libs" = yes; then
 1024       if test "$pic_mode" != yes; then
 1025     # Don't build PIC code
 1026     command="$base_compile $qsrcfile"
 1027       else
 1028     command="$base_compile $qsrcfile $pic_flag"
 1029       fi
 1030       if test "$compiler_c_o" = yes; then
 1031     command="$command -o $obj"
 1032       fi
 1033 
 1034       # Suppress compiler output if we already did a PIC compilation.
 1035       command="$command$suppress_output"
 1036       $run $rm "$obj" "$output_obj"
 1037       $show "$command"
 1038       if $run eval $lt_env "$command"; then :
 1039       else
 1040     $run $rm $removelist
 1041     exit $EXIT_FAILURE
 1042       fi
 1043 
 1044       if test "$need_locks" = warn &&
 1045      test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
 1046     $echo "\
 1047 *** ERROR, $lockfile contains:
 1048 `cat $lockfile 2>/dev/null`
 1049 
 1050 but it should contain:
 1051 $srcfile
 1052 
 1053 This indicates that another process is trying to use the same
 1054 temporary object file, and libtool could not work around it because
 1055 your compiler does not support \`-c' and \`-o' together.  If you
 1056 repeat this compilation, it may succeed, by chance, but you had better
 1057 avoid parallel builds (make -j) in this platform, or get a better
 1058 compiler."
 1059 
 1060     $run $rm $removelist
 1061     exit $EXIT_FAILURE
 1062       fi
 1063 
 1064       # Just move the object if needed
 1065       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
 1066     $show "$mv $output_obj $obj"
 1067     if $run $mv $output_obj $obj; then :
 1068     else
 1069       error=$?
 1070       $run $rm $removelist
 1071       exit $error
 1072     fi
 1073       fi
 1074 
 1075       # Append the name of the non-PIC object the libtool object file.
 1076       # Only append if the libtool object file exists.
 1077       test -z "$run" && cat >> ${libobj}T <<EOF
 1078 # Name of the non-PIC object.
 1079 non_pic_object='$objname'
 1080 
 1081 EOF
 1082     else
 1083       # Append the name of the non-PIC object the libtool object file.
 1084       # Only append if the libtool object file exists.
 1085       test -z "$run" && cat >> ${libobj}T <<EOF
 1086 # Name of the non-PIC object.
 1087 non_pic_object=none
 1088 
 1089 EOF
 1090     fi
 1091 
 1092     $run $mv "${libobj}T" "${libobj}"
 1093 
 1094     # Unlock the critical section if it was locked
 1095     if test "$need_locks" != no; then
 1096       $run $rm "$lockfile"
 1097     fi
 1098 
 1099     exit $EXIT_SUCCESS
 1100     ;;
 1101 
 1102   # libtool link mode
 1103   link | relink)
 1104     modename="$modename: link"
 1105     case $host in
 1106     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 1107       # It is impossible to link a dll without this setting, and
 1108       # we shouldn't force the makefile maintainer to figure out
 1109       # which system we are compiling for in order to pass an extra
 1110       # flag for every libtool invocation.
 1111       # allow_undefined=no
 1112 
 1113       # FIXME: Unfortunately, there are problems with the above when trying
 1114       # to make a dll which has undefined symbols, in which case not
 1115       # even a static library is built.  For now, we need to specify
 1116       # -no-undefined on the libtool link line when we can be certain
 1117       # that all symbols are satisfied, otherwise we get a static library.
 1118       allow_undefined=yes
 1119       ;;
 1120     *)
 1121       allow_undefined=yes
 1122       ;;
 1123     esac
 1124     libtool_args="$nonopt"
 1125     base_compile="$nonopt $@"
 1126     compile_command="$nonopt"
 1127     finalize_command="$nonopt"
 1128 
 1129     compile_rpath=
 1130     finalize_rpath=
 1131     compile_shlibpath=
 1132     finalize_shlibpath=
 1133     convenience=
 1134     old_convenience=
 1135     deplibs=
 1136     old_deplibs=
 1137     compiler_flags=
 1138     linker_flags=
 1139     dllsearchpath=
 1140     lib_search_path=`pwd`
 1141     inst_prefix_dir=
 1142 
 1143     avoid_version=no
 1144     dlfiles=
 1145     dlprefiles=
 1146     dlself=no
 1147     export_dynamic=no
 1148     export_symbols=
 1149     export_symbols_regex=
 1150     generated=
 1151     libobjs=
 1152     ltlibs=
 1153     module=no
 1154     no_install=no
 1155     objs=
 1156     non_pic_objects=
 1157     notinst_path= # paths that contain not-installed libtool libraries
 1158     precious_files_regex=
 1159     prefer_static_libs=no
 1160     preload=no
 1161     prev=
 1162     prevarg=
 1163     release=
 1164     rpath=
 1165     xrpath=
 1166     perm_rpath=
 1167     temp_rpath=
 1168     thread_safe=no
 1169     vinfo=
 1170     vinfo_number=no
 1171     single_module="${wl}-single_module"
 1172 
 1173     func_infer_tag $base_compile
 1174 
 1175     # We need to know -static, to get the right output filenames.
 1176     for arg
 1177     do
 1178       case $arg in
 1179       -all-static | -static | -static-libtool-libs)
 1180     case $arg in
 1181     -all-static)
 1182       if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
 1183         $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
 1184       fi
 1185       if test -n "$link_static_flag"; then
 1186         dlopen_self=$dlopen_self_static
 1187       fi
 1188       prefer_static_libs=yes
 1189       ;;
 1190     -static)
 1191       if test -z "$pic_flag" && test -n "$link_static_flag"; then
 1192         dlopen_self=$dlopen_self_static
 1193       fi
 1194       prefer_static_libs=built
 1195       ;;
 1196     -static-libtool-libs)
 1197       if test -z "$pic_flag" && test -n "$link_static_flag"; then
 1198         dlopen_self=$dlopen_self_static
 1199       fi
 1200       prefer_static_libs=yes
 1201       ;;
 1202     esac
 1203     build_libtool_libs=no
 1204     build_old_libs=yes
 1205     break
 1206     ;;
 1207       esac
 1208     done
 1209 
 1210     # See if our shared archives depend on static archives.
 1211     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
 1212 
 1213     # Go through the arguments, transforming them on the way.
 1214     while test "$#" -gt 0; do
 1215       arg="$1"
 1216       shift
 1217       case $arg in
 1218       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
 1219     qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
 1220     ;;
 1221       *) qarg=$arg ;;
 1222       esac
 1223       libtool_args="$libtool_args $qarg"
 1224 
 1225       # If the previous option needs an argument, assign it.
 1226       if test -n "$prev"; then
 1227     case $prev in
 1228     output)
 1229       compile_command="$compile_command @OUTPUT@"
 1230       finalize_command="$finalize_command @OUTPUT@"
 1231       ;;
 1232     esac
 1233 
 1234     case $prev in
 1235     dlfiles|dlprefiles)
 1236       if test "$preload" = no; then
 1237         # Add the symbol object into the linking commands.
 1238         compile_command="$compile_command @SYMFILE@"
 1239         finalize_command="$finalize_command @SYMFILE@"
 1240         preload=yes
 1241       fi
 1242       case $arg in
 1243       *.la | *.lo) ;;  # We handle these cases below.
 1244       force)
 1245         if test "$dlself" = no; then
 1246           dlself=needless
 1247           export_dynamic=yes
 1248         fi
 1249         prev=
 1250         continue
 1251         ;;
 1252       self)
 1253         if test "$prev" = dlprefiles; then
 1254           dlself=yes
 1255         elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
 1256           dlself=yes
 1257         else
 1258           dlself=needless
 1259           export_dynamic=yes
 1260         fi
 1261         prev=
 1262         continue
 1263         ;;
 1264       *)
 1265         if test "$prev" = dlfiles; then
 1266           dlfiles="$dlfiles $arg"
 1267         else
 1268           dlprefiles="$dlprefiles $arg"
 1269         fi
 1270         prev=
 1271         continue
 1272         ;;
 1273       esac
 1274       ;;
 1275     expsyms)
 1276       export_symbols="$arg"
 1277       if test ! -f "$arg"; then
 1278         $echo "$modename: symbol file \`$arg' does not exist"
 1279         exit $EXIT_FAILURE
 1280       fi
 1281       prev=
 1282       continue
 1283       ;;
 1284     expsyms_regex)
 1285       export_symbols_regex="$arg"
 1286       prev=
 1287       continue
 1288       ;;
 1289     inst_prefix)
 1290       inst_prefix_dir="$arg"
 1291       prev=
 1292       continue
 1293       ;;
 1294     precious_regex)
 1295       precious_files_regex="$arg"
 1296       prev=
 1297       continue
 1298       ;;
 1299     release)
 1300       release="-$arg"
 1301       prev=
 1302       continue
 1303       ;;
 1304     objectlist)
 1305       if test -f "$arg"; then
 1306         save_arg=$arg
 1307         moreargs=
 1308         for fil in `cat $save_arg`
 1309         do
 1310 #         moreargs="$moreargs $fil"
 1311           arg=$fil
 1312           # A libtool-controlled object.
 1313 
 1314           # Check to see that this really is a libtool object.
 1315           if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 1316         pic_object=
 1317         non_pic_object=
 1318 
 1319         # Read the .lo file
 1320         # If there is no directory component, then add one.
 1321         case $arg in
 1322         */* | *\\*) . $arg ;;
 1323         *) . ./$arg ;;
 1324         esac
 1325 
 1326         if test -z "$pic_object" || \
 1327            test -z "$non_pic_object" ||
 1328            test "$pic_object" = none && \
 1329            test "$non_pic_object" = none; then
 1330           $echo "$modename: cannot find name of object for \`$arg'" 1>&2
 1331           exit $EXIT_FAILURE
 1332         fi
 1333 
 1334         # Extract subdirectory from the argument.
 1335         xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
 1336         if test "X$xdir" = "X$arg"; then
 1337           xdir=
 1338         else
 1339           xdir="$xdir/"
 1340         fi
 1341 
 1342         if test "$pic_object" != none; then
 1343           # Prepend the subdirectory the object is found in.
 1344           pic_object="$xdir$pic_object"
 1345 
 1346           if test "$prev" = dlfiles; then
 1347             if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
 1348               dlfiles="$dlfiles $pic_object"
 1349               prev=
 1350               continue
 1351             else
 1352               # If libtool objects are unsupported, then we need to preload.
 1353               prev=dlprefiles
 1354             fi
 1355           fi
 1356 
 1357           # CHECK ME:  I think I busted this.  -Ossama
 1358           if test "$prev" = dlprefiles; then
 1359             # Preload the old-style object.
 1360             dlprefiles="$dlprefiles $pic_object"
 1361             prev=
 1362           fi
 1363 
 1364           # A PIC object.
 1365           libobjs="$libobjs $pic_object"
 1366           arg="$pic_object"
 1367         fi
 1368 
 1369         # Non-PIC object.
 1370         if test "$non_pic_object" != none; then
 1371           # Prepend the subdirectory the object is found in.
 1372           non_pic_object="$xdir$non_pic_object"
 1373 
 1374           # A standard non-PIC object
 1375           non_pic_objects="$non_pic_objects $non_pic_object"
 1376           if test -z "$pic_object" || test "$pic_object" = none ; then
 1377             arg="$non_pic_object"
 1378           fi
 1379         else
 1380           # If the PIC object exists, use it instead.
 1381           # $xdir was prepended to $pic_object above.
 1382           non_pic_object="$pic_object"
 1383           non_pic_objects="$non_pic_objects $non_pic_object"
 1384         fi
 1385           else
 1386         # Only an error if not doing a dry-run.
 1387         if test -z "$run"; then
 1388           $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
 1389           exit $EXIT_FAILURE
 1390         else
 1391           # Dry-run case.
 1392 
 1393           # Extract subdirectory from the argument.
 1394           xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
 1395           if test "X$xdir" = "X$arg"; then
 1396             xdir=
 1397           else
 1398             xdir="$xdir/"
 1399           fi
 1400 
 1401           pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
 1402           non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
 1403           libobjs="$libobjs $pic_object"
 1404           non_pic_objects="$non_pic_objects $non_pic_object"
 1405         fi
 1406           fi
 1407         done
 1408       else
 1409         $echo "$modename: link input file \`$save_arg' does not exist"
 1410         exit $EXIT_FAILURE
 1411       fi
 1412       arg=$save_arg
 1413       prev=
 1414       continue
 1415       ;;
 1416     rpath | xrpath)
 1417       # We need an absolute path.
 1418       case $arg in
 1419       [\\/]* | [A-Za-z]:[\\/]*) ;;
 1420       *)
 1421         $echo "$modename: only absolute run-paths are allowed" 1>&2
 1422         exit $EXIT_FAILURE
 1423         ;;
 1424       esac
 1425       if test "$prev" = rpath; then
 1426         case "$rpath " in
 1427         *" $arg "*) ;;
 1428         *) rpath="$rpath $arg" ;;
 1429         esac
 1430       else
 1431         case "$xrpath " in
 1432         *" $arg "*) ;;
 1433         *) xrpath="$xrpath $arg" ;;
 1434         esac
 1435       fi
 1436       prev=
 1437       continue
 1438       ;;
 1439     xcompiler)
 1440       compiler_flags="$compiler_flags $qarg"
 1441       prev=
 1442       compile_command="$compile_command $qarg"
 1443       finalize_command="$finalize_command $qarg"
 1444       continue
 1445       ;;
 1446     xlinker)
 1447       linker_flags="$linker_flags $qarg"
 1448       compiler_flags="$compiler_flags $wl$qarg"
 1449       prev=
 1450       compile_command="$compile_command $wl$qarg"
 1451       finalize_command="$finalize_command $wl$qarg"
 1452       continue
 1453       ;;
 1454     xcclinker)
 1455       linker_flags="$linker_flags $qarg"
 1456       compiler_flags="$compiler_flags $qarg"
 1457       prev=
 1458       compile_command="$compile_command $qarg"
 1459       finalize_command="$finalize_command $qarg"
 1460       continue
 1461       ;;
 1462     shrext)
 1463       shrext_cmds="$arg"
 1464       prev=
 1465       continue
 1466       ;;
 1467     darwin_framework|darwin_framework_skip)
 1468       test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
 1469       compile_command="$compile_command $arg"
 1470       finalize_command="$finalize_command $arg"
 1471       prev=
 1472       continue
 1473       ;;
 1474     *)
 1475       eval "$prev=\"\$arg\""
 1476       prev=
 1477       continue
 1478       ;;
 1479     esac
 1480       fi # test -n "$prev"
 1481 
 1482       prevarg="$arg"
 1483 
 1484       case $arg in
 1485       -all-static)
 1486     if test -n "$link_static_flag"; then
 1487       compile_command="$compile_command $link_static_flag"
 1488       finalize_command="$finalize_command $link_static_flag"
 1489     fi
 1490     continue
 1491     ;;
 1492 
 1493       -allow-undefined)
 1494     # FIXME: remove this flag sometime in the future.
 1495     $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
 1496     continue
 1497     ;;
 1498 
 1499       -avoid-version)
 1500     avoid_version=yes
 1501     continue
 1502     ;;
 1503 
 1504       -dlopen)
 1505     prev=dlfiles
 1506     continue
 1507     ;;
 1508 
 1509       -dlpreopen)
 1510     prev=dlprefiles
 1511     continue
 1512     ;;
 1513 
 1514       -export-dynamic)
 1515     export_dynamic=yes
 1516     continue
 1517     ;;
 1518 
 1519       -export-symbols | -export-symbols-regex)
 1520     if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
 1521       $echo "$modename: more than one -exported-symbols argument is not allowed"
 1522       exit $EXIT_FAILURE
 1523     fi
 1524     if test "X$arg" = "X-export-symbols"; then
 1525       prev=expsyms
 1526     else
 1527       prev=expsyms_regex
 1528     fi
 1529     continue
 1530     ;;
 1531 
 1532       -framework|-arch|-isysroot)
 1533     case " $CC " in
 1534       *" ${arg} ${1} "* | *" ${arg} ${1} "*) 
 1535         prev=darwin_framework_skip ;;
 1536       *) compiler_flags="$compiler_flags $arg"
 1537          prev=darwin_framework ;;
 1538     esac
 1539     compile_command="$compile_command $arg"
 1540     finalize_command="$finalize_command $arg"
 1541     continue
 1542     ;;
 1543 
 1544       -inst-prefix-dir)
 1545     prev=inst_prefix
 1546     continue
 1547     ;;
 1548 
 1549       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
 1550       # so, if we see these flags be careful not to treat them like -L
 1551       -L[A-Z][A-Z]*:*)
 1552     case $with_gcc/$host in
 1553     no/*-*-irix* | /*-*-irix*)
 1554       compile_command="$compile_command $arg"
 1555       finalize_command="$finalize_command $arg"
 1556       ;;
 1557     esac
 1558     continue
 1559     ;;
 1560 
 1561       -L*)
 1562     dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
 1563     # We need an absolute path.
 1564     case $dir in
 1565     [\\/]* | [A-Za-z]:[\\/]*) ;;
 1566     *)
 1567       absdir=`cd "$dir" && pwd`
 1568       if test -z "$absdir"; then
 1569         $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
 1570         absdir="$dir"
 1571         notinst_path="$notinst_path $dir"
 1572       fi
 1573       dir="$absdir"
 1574       ;;
 1575     esac
 1576     case "$deplibs " in
 1577     *" -L$dir "*) ;;
 1578     *)
 1579       deplibs="$deplibs -L$dir"
 1580       lib_search_path="$lib_search_path $dir"
 1581       ;;
 1582     esac
 1583     case $host in
 1584     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 1585       testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`
 1586       case :$dllsearchpath: in
 1587       *":$dir:"*) ;;
 1588       *) dllsearchpath="$dllsearchpath:$dir";;
 1589       esac
 1590       case :$dllsearchpath: in
 1591       *":$testbindir:"*) ;;
 1592       *) dllsearchpath="$dllsearchpath:$testbindir";;
 1593       esac
 1594       ;;
 1595     esac
 1596     continue
 1597     ;;
 1598 
 1599       -l*)
 1600     if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
 1601       case $host in
 1602       *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
 1603         # These systems don't actually have a C or math library (as such)
 1604         continue
 1605         ;;
 1606       *-*-os2*)
 1607         # These systems don't actually have a C library (as such)
 1608         test "X$arg" = "X-lc" && continue
 1609         ;;
 1610       *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
 1611         # Do not include libc due to us having libc/libc_r.
 1612         test "X$arg" = "X-lc" && continue
 1613         ;;
 1614       *-*-rhapsody* | *-*-darwin1.[012])
 1615         # Rhapsody C and math libraries are in the System framework
 1616         deplibs="$deplibs -framework System"
 1617         continue
 1618         ;;
 1619       *-*-sco3.2v5* | *-*-sco5v6*)
 1620         # Causes problems with __ctype
 1621         test "X$arg" = "X-lc" && continue
 1622         ;;
 1623       *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
 1624         # Compiler inserts libc in the correct place for threads to work
 1625         test "X$arg" = "X-lc" && continue
 1626         ;;
 1627       esac
 1628     elif test "X$arg" = "X-lc_r"; then
 1629      case $host in
 1630      *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
 1631        # Do not include libc_r directly, use -pthread flag.
 1632        continue
 1633        ;;
 1634      esac
 1635     fi
 1636     deplibs="$deplibs $arg"
 1637     continue
 1638     ;;
 1639 
 1640       # Tru64 UNIX uses -model [arg] to determine the layout of C++
 1641       # classes, name mangling, and exception handling.
 1642       -model)
 1643     compile_command="$compile_command $arg"
 1644     compiler_flags="$compiler_flags $arg"
 1645     finalize_command="$finalize_command $arg"
 1646     prev=xcompiler
 1647     continue
 1648     ;;
 1649 
 1650      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
 1651     compiler_flags="$compiler_flags $arg"
 1652     compile_command="$compile_command $arg"
 1653     finalize_command="$finalize_command $arg"
 1654     continue
 1655     ;;
 1656 
 1657       -multi_module)
 1658     single_module="${wl}-multi_module"
 1659     continue
 1660     ;;
 1661 
 1662       -module)
 1663     module=yes
 1664     continue
 1665     ;;
 1666 
 1667       # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
 1668       # -r[0-9][0-9]* specifies the processor on the SGI compiler
 1669       # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
 1670       # +DA*, +DD* enable 64-bit mode on the HP compiler
 1671       # -q* pass through compiler args for the IBM compiler
 1672       # -m* pass through architecture-specific compiler args for GCC
 1673       # -m*, -t[45]*, -txscale* pass through architecture-specific
 1674       # compiler args for GCC
 1675       # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
 1676       # -F/path gives path to uninstalled frameworks, gcc on darwin
 1677       # @file GCC response files
 1678       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
 1679       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
 1680 
 1681     # Unknown arguments in both finalize_command and compile_command need
 1682     # to be aesthetically quoted because they are evaled later.
 1683     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
 1684     case $arg in
 1685     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
 1686       arg="\"$arg\""
 1687       ;;
 1688     esac
 1689         compile_command="$compile_command $arg"
 1690         finalize_command="$finalize_command $arg"
 1691         compiler_flags="$compiler_flags $arg"
 1692         continue
 1693         ;;
 1694 
 1695       -shrext)
 1696     prev=shrext
 1697     continue
 1698     ;;
 1699 
 1700       -no-fast-install)
 1701     fast_install=no
 1702     continue
 1703     ;;
 1704 
 1705       -no-install)
 1706     case $host in
 1707     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin*)
 1708       # The PATH hackery in wrapper scripts is required on Windows
 1709       # and Darwin in order for the loader to find any dlls it needs.
 1710       $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
 1711       $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
 1712       fast_install=no
 1713       ;;
 1714     *) no_install=yes ;;
 1715     esac
 1716     continue
 1717     ;;
 1718 
 1719       -no-undefined)
 1720     allow_undefined=no
 1721     continue
 1722     ;;
 1723 
 1724       -objectlist)
 1725     prev=objectlist
 1726     continue
 1727     ;;
 1728 
 1729       -o) prev=output ;;
 1730 
 1731       -precious-files-regex)
 1732     prev=precious_regex
 1733     continue
 1734     ;;
 1735 
 1736       -release)
 1737     prev=release
 1738     continue
 1739     ;;
 1740 
 1741       -rpath)
 1742     prev=rpath
 1743     continue
 1744     ;;
 1745 
 1746       -R)
 1747     prev=xrpath
 1748     continue
 1749     ;;
 1750 
 1751       -R*)
 1752     dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
 1753     # We need an absolute path.
 1754     case $dir in
 1755     [\\/]* | [A-Za-z]:[\\/]*) ;;
 1756     *)
 1757       $echo "$modename: only absolute run-paths are allowed" 1>&2
 1758       exit $EXIT_FAILURE
 1759       ;;
 1760     esac
 1761     case "$xrpath " in
 1762     *" $dir "*) ;;
 1763     *) xrpath="$xrpath $dir" ;;
 1764     esac
 1765     continue
 1766     ;;
 1767 
 1768       -static | -static-libtool-libs)
 1769     # The effects of -static are defined in a previous loop.
 1770     # We used to do the same as -all-static on platforms that
 1771     # didn't have a PIC flag, but the assumption that the effects
 1772     # would be equivalent was wrong.  It would break on at least
 1773     # Digital Unix and AIX.
 1774     continue
 1775     ;;
 1776 
 1777       -thread-safe)
 1778     thread_safe=yes
 1779     continue
 1780     ;;
 1781 
 1782       -version-info)
 1783     prev=vinfo
 1784     continue
 1785     ;;
 1786       -version-number)
 1787     prev=vinfo
 1788     vinfo_number=yes
 1789     continue
 1790     ;;
 1791 
 1792       -Wc,*)
 1793     args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
 1794     arg=
 1795     save_ifs="$IFS"; IFS=','
 1796     for flag in $args; do
 1797       IFS="$save_ifs"
 1798       case $flag in
 1799         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
 1800         flag="\"$flag\""
 1801         ;;
 1802       esac
 1803       arg="$arg $wl$flag"
 1804       compiler_flags="$compiler_flags $flag"
 1805     done
 1806     IFS="$save_ifs"
 1807     arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
 1808     ;;
 1809 
 1810       -Wl,*)
 1811     args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
 1812     arg=
 1813     save_ifs="$IFS"; IFS=','
 1814     for flag in $args; do
 1815       IFS="$save_ifs"
 1816       case $flag in
 1817         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
 1818         flag="\"$flag\""
 1819         ;;
 1820       esac
 1821       arg="$arg $wl$flag"
 1822       compiler_flags="$compiler_flags $wl$flag"
 1823       linker_flags="$linker_flags $flag"
 1824     done
 1825     IFS="$save_ifs"
 1826     arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
 1827     ;;
 1828 
 1829       -Xcompiler)
 1830     prev=xcompiler
 1831     continue
 1832     ;;
 1833 
 1834       -Xlinker)
 1835     prev=xlinker
 1836     continue
 1837     ;;
 1838 
 1839       -XCClinker)
 1840     prev=xcclinker
 1841     continue
 1842     ;;
 1843 
 1844       # Some other compiler flag.
 1845       -* | +*)
 1846     # Unknown arguments in both finalize_command and compile_command need
 1847     # to be aesthetically quoted because they are evaled later.
 1848     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
 1849     case $arg in
 1850     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
 1851       arg="\"$arg\""
 1852       ;;
 1853     esac
 1854     ;;
 1855 
 1856       *.$objext)
 1857     # A standard object.
 1858     objs="$objs $arg"
 1859     ;;
 1860 
 1861       *.lo)
 1862     # A libtool-controlled object.
 1863 
 1864     # Check to see that this really is a libtool object.
 1865     if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 1866       pic_object=
 1867       non_pic_object=
 1868 
 1869       # Read the .lo file
 1870       # If there is no directory component, then add one.
 1871       case $arg in
 1872       */* | *\\*) . $arg ;;
 1873       *) . ./$arg ;;
 1874       esac
 1875 
 1876       if test -z "$pic_object" || \
 1877          test -z "$non_pic_object" ||
 1878          test "$pic_object" = none && \
 1879          test "$non_pic_object" = none; then
 1880         $echo "$modename: cannot find name of object for \`$arg'" 1>&2
 1881         exit $EXIT_FAILURE
 1882       fi
 1883 
 1884       # Extract subdirectory from the argument.
 1885       xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
 1886       if test "X$xdir" = "X$arg"; then
 1887         xdir=
 1888       else
 1889         xdir="$xdir/"
 1890       fi
 1891 
 1892       if test "$pic_object" != none; then
 1893         # Prepend the subdirectory the object is found in.
 1894         pic_object="$xdir$pic_object"
 1895 
 1896         if test "$prev" = dlfiles; then
 1897           if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
 1898         dlfiles="$dlfiles $pic_object"
 1899         prev=
 1900         continue
 1901           else
 1902         # If libtool objects are unsupported, then we need to preload.
 1903         prev=dlprefiles
 1904           fi
 1905         fi
 1906 
 1907         # CHECK ME:  I think I busted this.  -Ossama
 1908         if test "$prev" = dlprefiles; then
 1909           # Preload the old-style object.
 1910           dlprefiles="$dlprefiles $pic_object"
 1911           prev=
 1912         fi
 1913 
 1914         # A PIC object.
 1915         libobjs="$libobjs $pic_object"
 1916         arg="$pic_object"
 1917       fi
 1918 
 1919       # Non-PIC object.
 1920       if test "$non_pic_object" != none; then
 1921         # Prepend the subdirectory the object is found in.
 1922         non_pic_object="$xdir$non_pic_object"
 1923 
 1924         # A standard non-PIC object
 1925         non_pic_objects="$non_pic_objects $non_pic_object"
 1926         if test -z "$pic_object" || test "$pic_object" = none ; then
 1927           arg="$non_pic_object"
 1928         fi
 1929       else
 1930         # If the PIC object exists, use it instead.
 1931         # $xdir was prepended to $pic_object above.
 1932         non_pic_object="$pic_object"
 1933         non_pic_objects="$non_pic_objects $non_pic_object"
 1934       fi
 1935     else
 1936       # Only an error if not doing a dry-run.
 1937       if test -z "$run"; then
 1938         $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
 1939         exit $EXIT_FAILURE
 1940       else
 1941         # Dry-run case.
 1942 
 1943         # Extract subdirectory from the argument.
 1944         xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
 1945         if test "X$xdir" = "X$arg"; then
 1946           xdir=
 1947         else
 1948           xdir="$xdir/"
 1949         fi
 1950 
 1951         pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
 1952         non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
 1953         libobjs="$libobjs $pic_object"
 1954         non_pic_objects="$non_pic_objects $non_pic_object"
 1955       fi
 1956     fi
 1957     ;;
 1958 
 1959       *.$libext)
 1960     # An archive.
 1961     deplibs="$deplibs $arg"
 1962     old_deplibs="$old_deplibs $arg"
 1963     continue
 1964     ;;
 1965 
 1966       *.la)
 1967     # A libtool-controlled library.
 1968 
 1969     if test "$prev" = dlfiles; then
 1970       # This library was specified with -dlopen.
 1971       dlfiles="$dlfiles $arg"
 1972       prev=
 1973     elif test "$prev" = dlprefiles; then
 1974       # The library was specified with -dlpreopen.
 1975       dlprefiles="$dlprefiles $arg"
 1976       prev=
 1977     else
 1978       deplibs="$deplibs $arg"
 1979     fi
 1980     continue
 1981     ;;
 1982 
 1983       # Some other compiler argument.
 1984       *)
 1985     # Unknown arguments in both finalize_command and compile_command need
 1986     # to be aesthetically quoted because they are evaled later.
 1987     arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
 1988     case $arg in
 1989     *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
 1990       arg="\"$arg\""
 1991       ;;
 1992     esac
 1993     ;;
 1994       esac # arg
 1995 
 1996       # Now actually substitute the argument into the commands.
 1997       if test -n "$arg"; then
 1998     compile_command="$compile_command $arg"
 1999     finalize_command="$finalize_command $arg"
 2000       fi
 2001     done # argument parsing loop
 2002 
 2003     if test -n "$prev"; then
 2004       $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
 2005       $echo "$help" 1>&2
 2006       exit $EXIT_FAILURE
 2007     fi
 2008 
 2009     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
 2010       eval arg=\"$export_dynamic_flag_spec\"
 2011       compile_command="$compile_command $arg"
 2012       finalize_command="$finalize_command $arg"
 2013     fi
 2014 
 2015     oldlibs=
 2016     # calculate the name of the file, without its directory
 2017     outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
 2018     libobjs_save="$libobjs"
 2019 
 2020     if test -n "$shlibpath_var"; then
 2021       # get the directories listed in $shlibpath_var
 2022       eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
 2023     else
 2024       shlib_search_path=
 2025     fi
 2026     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
 2027     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
 2028 
 2029     output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
 2030     if test "X$output_objdir" = "X$output"; then
 2031       output_objdir="$objdir"
 2032     else
 2033       output_objdir="$output_objdir/$objdir"
 2034     fi
 2035     # Create the object directory.
 2036     if test ! -d "$output_objdir"; then
 2037       $show "$mkdir $output_objdir"
 2038       $run $mkdir $output_objdir
 2039       exit_status=$?
 2040       if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
 2041     exit $exit_status
 2042       fi
 2043     fi
 2044 
 2045     # Determine the type of output
 2046     case $output in
 2047     "")
 2048       $echo "$modename: you must specify an output file" 1>&2
 2049       $echo "$help" 1>&2
 2050       exit $EXIT_FAILURE
 2051       ;;
 2052     *.$libext) linkmode=oldlib ;;
 2053     *.lo | *.$objext) linkmode=obj ;;
 2054     *.la) linkmode=lib ;;
 2055     *) linkmode=prog ;; # Anything else should be a program.
 2056     esac
 2057 
 2058     case $host in
 2059     *cygwin* | *mingw* | *pw32*)
 2060       # don't eliminate duplications in $postdeps and $predeps
 2061       duplicate_compiler_generated_deps=yes
 2062       ;;
 2063     *)
 2064       duplicate_compiler_generated_deps=$duplicate_deps
 2065       ;;
 2066     esac
 2067     specialdeplibs=
 2068 
 2069     libs=
 2070     # Find all interdependent deplibs by searching for libraries
 2071     # that are linked more than once (e.g. -la -lb -la)
 2072     for deplib in $deplibs; do
 2073       if test "X$duplicate_deps" = "Xyes" ; then
 2074     case "$libs " in
 2075     *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 2076     esac
 2077       fi
 2078       libs="$libs $deplib"
 2079     done
 2080 
 2081     if test "$linkmode" = lib; then
 2082       libs="$predeps $libs $compiler_lib_search_path $postdeps"
 2083 
 2084       # Compute libraries that are listed more than once in $predeps
 2085       # $postdeps and mark them as special (i.e., whose duplicates are
 2086       # not to be eliminated).
 2087       pre_post_deps=
 2088       if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
 2089     for pre_post_dep in $predeps $postdeps; do
 2090       case "$pre_post_deps " in
 2091       *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
 2092       esac
 2093       pre_post_deps="$pre_post_deps $pre_post_dep"
 2094     done
 2095       fi
 2096       pre_post_deps=
 2097     fi
 2098 
 2099     deplibs=
 2100     newdependency_libs=
 2101     newlib_search_path=
 2102     need_relink=no # whether we're linking any uninstalled libtool libraries
 2103     notinst_deplibs= # not-installed libtool libraries
 2104     case $linkmode in
 2105     lib)
 2106     passes="conv link"
 2107     for file in $dlfiles $dlprefiles; do
 2108       case $file in
 2109       *.la) ;;
 2110       *)
 2111         $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
 2112         exit $EXIT_FAILURE
 2113         ;;
 2114       esac
 2115     done
 2116     ;;
 2117     prog)
 2118     compile_deplibs=
 2119     finalize_deplibs=
 2120     alldeplibs=no
 2121     newdlfiles=
 2122     newdlprefiles=
 2123     passes="conv scan dlopen dlpreopen link"
 2124     ;;
 2125     *)  passes="conv"
 2126     ;;
 2127     esac
 2128     for pass in $passes; do
 2129       if test "$linkmode,$pass" = "lib,link" ||
 2130      test "$linkmode,$pass" = "prog,scan"; then
 2131     libs="$deplibs"
 2132     deplibs=
 2133       fi
 2134       if test "$linkmode" = prog; then
 2135     case $pass in
 2136     dlopen) libs="$dlfiles" ;;
 2137     dlpreopen) libs="$dlprefiles" ;;
 2138     link)
 2139       libs="$deplibs %DEPLIBS%"
 2140       test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
 2141       ;;
 2142     esac
 2143       fi
 2144       if test "$pass" = dlopen; then
 2145     # Collect dlpreopened libraries
 2146     save_deplibs="$deplibs"
 2147     deplibs=
 2148       fi
 2149       for deplib in $libs; do
 2150     lib=
 2151     found=no
 2152     case $deplib in
 2153     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
 2154       if test "$linkmode,$pass" = "prog,link"; then
 2155         compile_deplibs="$deplib $compile_deplibs"
 2156         finalize_deplibs="$deplib $finalize_deplibs"
 2157       else
 2158         compiler_flags="$compiler_flags $deplib"
 2159       fi
 2160       continue
 2161       ;;
 2162     -l*)
 2163       if test "$linkmode" != lib && test "$linkmode" != prog; then
 2164         $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
 2165         continue
 2166       fi
 2167       name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
 2168       if test "$linkmode" = lib; then
 2169         searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
 2170       else
 2171         searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
 2172       fi
 2173       for searchdir in $searchdirs; do
 2174         for search_ext in .la $std_shrext .so .a; do
 2175           # Search the libtool library
 2176           lib="$searchdir/lib${name}${search_ext}"
 2177           if test -f "$lib"; then
 2178         if test "$search_ext" = ".la"; then
 2179           found=yes
 2180         else
 2181           found=no
 2182         fi
 2183         break 2
 2184           fi
 2185         done
 2186       done
 2187       if test "$found" != yes; then
 2188         # deplib doesn't seem to be a libtool library
 2189         if test "$linkmode,$pass" = "prog,link"; then
 2190           compile_deplibs="$deplib $compile_deplibs"
 2191           finalize_deplibs="$deplib $finalize_deplibs"
 2192         else
 2193           deplibs="$deplib $deplibs"
 2194           test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
 2195         fi
 2196         continue
 2197       else # deplib is a libtool library
 2198         # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
 2199         # We need to do some special things here, and not later.
 2200         if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 2201           case " $predeps $postdeps " in
 2202           *" $deplib "*)
 2203         if (${SED} -e '2q' $lib |
 2204                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 2205           library_names=
 2206           old_library=
 2207           case $lib in
 2208           */* | *\\*) . $lib ;;
 2209           *) . ./$lib ;;
 2210           esac
 2211           for l in $old_library $library_names; do
 2212             ll="$l"
 2213           done
 2214           if test "X$ll" = "X$old_library" ; then # only static version available
 2215             found=no
 2216             ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
 2217             test "X$ladir" = "X$lib" && ladir="."
 2218             lib=$ladir/$old_library
 2219             if test "$linkmode,$pass" = "prog,link"; then
 2220               compile_deplibs="$deplib $compile_deplibs"
 2221               finalize_deplibs="$deplib $finalize_deplibs"
 2222             else
 2223               deplibs="$deplib $deplibs"
 2224               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
 2225             fi
 2226             continue
 2227           fi
 2228         fi
 2229             ;;
 2230           *) ;;
 2231           esac
 2232         fi
 2233       fi
 2234       ;; # -l
 2235     -L*)
 2236       case $linkmode in
 2237       lib)
 2238         deplibs="$deplib $deplibs"
 2239         test "$pass" = conv && continue
 2240         newdependency_libs="$deplib $newdependency_libs"
 2241         newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
 2242         ;;
 2243       prog)
 2244         if test "$pass" = conv; then
 2245           deplibs="$deplib $deplibs"
 2246           continue
 2247         fi
 2248         if test "$pass" = scan; then
 2249           deplibs="$deplib $deplibs"
 2250         else
 2251           compile_deplibs="$deplib $compile_deplibs"
 2252           finalize_deplibs="$deplib $finalize_deplibs"
 2253         fi
 2254         newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
 2255         ;;
 2256       *)
 2257         $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
 2258         ;;
 2259       esac # linkmode
 2260       continue
 2261       ;; # -L
 2262     -R*)
 2263       if test "$pass" = link; then
 2264         dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
 2265         # Make sure the xrpath contains only unique directories.
 2266         case "$xrpath " in
 2267         *" $dir "*) ;;
 2268         *) xrpath="$xrpath $dir" ;;
 2269         esac
 2270       fi
 2271       deplibs="$deplib $deplibs"
 2272       continue
 2273       ;;
 2274     *.la) lib="$deplib" ;;
 2275     *.$libext)
 2276       if test "$pass" = conv; then
 2277         deplibs="$deplib $deplibs"
 2278         continue
 2279       fi
 2280       case $linkmode in
 2281       lib)
 2282         valid_a_lib=no
 2283         case $deplibs_check_method in
 2284           match_pattern*)
 2285         set dummy $deplibs_check_method
 2286             match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
 2287         if eval $echo \"$deplib\" 2>/dev/null \
 2288             | $SED 10q \
 2289             | $EGREP "$match_pattern_regex" > /dev/null; then
 2290           valid_a_lib=yes
 2291         fi
 2292         ;;
 2293           pass_all)
 2294         valid_a_lib=yes
 2295         ;;
 2296             esac
 2297         if test "$valid_a_lib" != yes; then
 2298           $echo
 2299           $echo "*** Warning: Trying to link with static lib archive $deplib."
 2300           $echo "*** I have the capability to make that library automatically link in when"
 2301           $echo "*** you link to this library.  But I can only do this if you have a"
 2302           $echo "*** shared version of the library, which you do not appear to have"
 2303           $echo "*** because the file extensions .$libext of this argument makes me believe"
 2304           $echo "*** that it is just a static archive that I should not used here."
 2305         else
 2306           $echo
 2307           $echo "*** Warning: Linking the shared library $output against the"
 2308           $echo "*** static library $deplib is not portable!"
 2309           deplibs="$deplib $deplibs"
 2310         fi
 2311         continue
 2312         ;;
 2313       prog)
 2314         if test "$pass" != link; then
 2315           deplibs="$deplib $deplibs"
 2316         else
 2317           compile_deplibs="$deplib $compile_deplibs"
 2318           finalize_deplibs="$deplib $finalize_deplibs"
 2319         fi
 2320         continue
 2321         ;;
 2322       esac # linkmode
 2323       ;; # *.$libext
 2324     *.lo | *.$objext)
 2325       if test "$pass" = conv; then
 2326         deplibs="$deplib $deplibs"
 2327       elif test "$linkmode" = prog; then
 2328         if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
 2329           # If there is no dlopen support or we're linking statically,
 2330           # we need to preload.
 2331           newdlprefiles="$newdlprefiles $deplib"
 2332           compile_deplibs="$deplib $compile_deplibs"
 2333           finalize_deplibs="$deplib $finalize_deplibs"
 2334         else
 2335           newdlfiles="$newdlfiles $deplib"
 2336         fi
 2337       fi
 2338       continue
 2339       ;;
 2340     %DEPLIBS%)
 2341       alldeplibs=yes
 2342       continue
 2343       ;;
 2344     esac # case $deplib
 2345     if test "$found" = yes || test -f "$lib"; then :
 2346     else
 2347       $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
 2348       exit $EXIT_FAILURE
 2349     fi
 2350 
 2351     # Check to see that this really is a libtool archive.
 2352     if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
 2353     else
 2354       $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
 2355       exit $EXIT_FAILURE
 2356     fi
 2357 
 2358     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
 2359     test "X$ladir" = "X$lib" && ladir="."
 2360 
 2361     dlname=
 2362     dlopen=
 2363     dlpreopen=
 2364     libdir=
 2365     library_names=
 2366     old_library=
 2367     # If the library was installed with an old release of libtool,
 2368     # it will not redefine variables installed, or shouldnotlink
 2369     installed=yes
 2370     shouldnotlink=no
 2371     avoidtemprpath=
 2372 
 2373 
 2374     # Read the .la file
 2375     case $lib in
 2376     */* | *\\*) . $lib ;;
 2377     *) . ./$lib ;;
 2378     esac
 2379 
 2380     if test "$linkmode,$pass" = "lib,link" ||
 2381        test "$linkmode,$pass" = "prog,scan" ||
 2382        { test "$linkmode" != prog && test "$linkmode" != lib; }; then
 2383       test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
 2384       test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
 2385     fi
 2386 
 2387     if test "$pass" = conv; then
 2388       # Only check for convenience libraries
 2389       deplibs="$lib $deplibs"
 2390       if test -z "$libdir"; then
 2391         if test -z "$old_library"; then
 2392           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
 2393           exit $EXIT_FAILURE
 2394         fi
 2395         # It is a libtool convenience library, so add in its objects.
 2396         convenience="$convenience $ladir/$objdir/$old_library"
 2397         old_convenience="$old_convenience $ladir/$objdir/$old_library"
 2398         tmp_libs=
 2399         for deplib in $dependency_libs; do
 2400           deplibs="$deplib $deplibs"
 2401               if test "X$duplicate_deps" = "Xyes" ; then
 2402             case "$tmp_libs " in
 2403             *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 2404             esac
 2405               fi
 2406           tmp_libs="$tmp_libs $deplib"
 2407         done
 2408       elif test "$linkmode" != prog && test "$linkmode" != lib; then
 2409         $echo "$modename: \`$lib' is not a convenience library" 1>&2
 2410         exit $EXIT_FAILURE
 2411       fi
 2412       continue
 2413     fi # $pass = conv
 2414 
 2415 
 2416     # Get the name of the library we link against.
 2417     linklib=
 2418     for l in $old_library $library_names; do
 2419       linklib="$l"
 2420     done
 2421     if test -z "$linklib"; then
 2422       $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
 2423       exit $EXIT_FAILURE
 2424     fi
 2425 
 2426     # This library was specified with -dlopen.
 2427     if test "$pass" = dlopen; then
 2428       if test -z "$libdir"; then
 2429         $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
 2430         exit $EXIT_FAILURE
 2431       fi
 2432       if test -z "$dlname" ||
 2433          test "$dlopen_support" != yes ||
 2434          test "$build_libtool_libs" = no; then
 2435         # If there is no dlname, no dlopen support or we're linking
 2436         # statically, we need to preload.  We also need to preload any
 2437         # dependent libraries so libltdl's deplib preloader doesn't
 2438         # bomb out in the load deplibs phase.
 2439         dlprefiles="$dlprefiles $lib $dependency_libs"
 2440       else
 2441         newdlfiles="$newdlfiles $lib"
 2442       fi
 2443       continue
 2444     fi # $pass = dlopen
 2445 
 2446     # We need an absolute path.
 2447     case $ladir in
 2448     [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
 2449     *)
 2450       abs_ladir=`cd "$ladir" && pwd`
 2451       if test -z "$abs_ladir"; then
 2452         $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
 2453         $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
 2454         abs_ladir="$ladir"
 2455       fi
 2456       ;;
 2457     esac
 2458     laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
 2459 
 2460     # Find the relevant object directory and library name.
 2461     if test "X$installed" = Xyes; then
 2462       if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
 2463         $echo "$modename: warning: library \`$lib' was moved." 1>&2
 2464         dir="$ladir"
 2465         absdir="$abs_ladir"
 2466         libdir="$abs_ladir"
 2467       else
 2468         dir="$libdir"
 2469         absdir="$libdir"
 2470       fi
 2471       test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
 2472     else
 2473       if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
 2474         dir="$ladir"
 2475         absdir="$abs_ladir"
 2476         # Remove this search path later
 2477         notinst_path="$notinst_path $abs_ladir"
 2478       else
 2479         dir="$ladir/$objdir"
 2480         absdir="$abs_ladir/$objdir"
 2481         # Remove this search path later
 2482         notinst_path="$notinst_path $abs_ladir"
 2483       fi
 2484     fi # $installed = yes
 2485     name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 2486 
 2487     # This library was specified with -dlpreopen.
 2488     if test "$pass" = dlpreopen; then
 2489       if test -z "$libdir"; then
 2490         $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
 2491         exit $EXIT_FAILURE
 2492       fi
 2493       # Prefer using a static library (so that no silly _DYNAMIC symbols
 2494       # are required to link).
 2495       if test -n "$old_library"; then
 2496         newdlprefiles="$newdlprefiles $dir/$old_library"
 2497       # Otherwise, use the dlname, so that lt_dlopen finds it.
 2498       elif test -n "$dlname"; then
 2499         newdlprefiles="$newdlprefiles $dir/$dlname"
 2500       else
 2501         newdlprefiles="$newdlprefiles $dir/$linklib"
 2502       fi
 2503     fi # $pass = dlpreopen
 2504 
 2505     if test -z "$libdir"; then
 2506       # Link the convenience library
 2507       if test "$linkmode" = lib; then
 2508         deplibs="$dir/$old_library $deplibs"
 2509       elif test "$linkmode,$pass" = "prog,link"; then
 2510         compile_deplibs="$dir/$old_library $compile_deplibs"
 2511         finalize_deplibs="$dir/$old_library $finalize_deplibs"
 2512       else
 2513         deplibs="$lib $deplibs" # used for prog,scan pass
 2514       fi
 2515       continue
 2516     fi
 2517 
 2518 
 2519     if test "$linkmode" = prog && test "$pass" != link; then
 2520       newlib_search_path="$newlib_search_path $ladir"
 2521       deplibs="$lib $deplibs"
 2522 
 2523       linkalldeplibs=no
 2524       if test "$link_all_deplibs" != no || test -z "$library_names" ||
 2525          test "$build_libtool_libs" = no; then
 2526         linkalldeplibs=yes
 2527       fi
 2528 
 2529       tmp_libs=
 2530       for deplib in $dependency_libs; do
 2531         case $deplib in
 2532         -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
 2533         esac
 2534         # Need to link against all dependency_libs?
 2535         if test "$linkalldeplibs" = yes; then
 2536           deplibs="$deplib $deplibs"
 2537         else
 2538           # Need to hardcode shared library paths
 2539           # or/and link against static libraries
 2540           newdependency_libs="$deplib $newdependency_libs"
 2541         fi
 2542         if test "X$duplicate_deps" = "Xyes" ; then
 2543           case "$tmp_libs " in
 2544           *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 2545           esac
 2546         fi
 2547         tmp_libs="$tmp_libs $deplib"
 2548       done # for deplib
 2549       continue
 2550     fi # $linkmode = prog...
 2551 
 2552     if test "$linkmode,$pass" = "prog,link"; then
 2553       if test -n "$library_names" &&
 2554          { { test "$prefer_static_libs" = no ||
 2555          test "$prefer_static_libs,$installed" = "built,yes"; } ||
 2556            test -z "$old_library"; }; then
 2557         # We need to hardcode the library path
 2558         if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
 2559           # Make sure the rpath contains only unique directories.
 2560           case "$temp_rpath " in
 2561           *" $dir "*) ;;
 2562           *" $absdir "*) ;;
 2563           *) temp_rpath="$temp_rpath $absdir" ;;
 2564           esac
 2565         fi
 2566 
 2567         # Hardcode the library path.
 2568         # Skip directories that are in the system default run-time
 2569         # search path.
 2570         case " $sys_lib_dlsearch_path " in
 2571         *" $absdir "*) ;;
 2572         *)
 2573           case "$compile_rpath " in
 2574           *" $absdir "*) ;;
 2575           *) compile_rpath="$compile_rpath $absdir"
 2576           esac
 2577           ;;
 2578         esac
 2579         case " $sys_lib_dlsearch_path " in
 2580         *" $libdir "*) ;;
 2581         *)
 2582           case "$finalize_rpath " in
 2583           *" $libdir "*) ;;
 2584           *) finalize_rpath="$finalize_rpath $libdir"
 2585           esac
 2586           ;;
 2587         esac
 2588       fi # $linkmode,$pass = prog,link...
 2589 
 2590       if test "$alldeplibs" = yes &&
 2591          { test "$deplibs_check_method" = pass_all ||
 2592            { test "$build_libtool_libs" = yes &&
 2593          test -n "$library_names"; }; }; then
 2594         # We only need to search for static libraries
 2595         continue
 2596       fi
 2597     fi
 2598 
 2599     link_static=no # Whether the deplib will be linked statically
 2600     use_static_libs=$prefer_static_libs
 2601     if test "$use_static_libs" = built && test "$installed" = yes ; then
 2602       use_static_libs=no
 2603     fi
 2604     if test -n "$library_names" &&
 2605        { test "$use_static_libs" = no || test -z "$old_library"; }; then
 2606       if test "$installed" = no; then
 2607         notinst_deplibs="$notinst_deplibs $lib"
 2608         need_relink=yes
 2609       fi
 2610       # This is a shared library
 2611 
 2612       # Warn about portability, can't link against -module's on
 2613       # some systems (darwin)
 2614       if test "$shouldnotlink" = yes && test "$pass" = link ; then
 2615         $echo
 2616         if test "$linkmode" = prog; then
 2617           $echo "*** Warning: Linking the executable $output against the loadable module"
 2618         else
 2619           $echo "*** Warning: Linking the shared library $output against the loadable module"
 2620         fi
 2621         $echo "*** $linklib is not portable!"
 2622       fi
 2623       if test "$linkmode" = lib &&
 2624          test "$hardcode_into_libs" = yes; then
 2625         # Hardcode the library path.
 2626         # Skip directories that are in the system default run-time
 2627         # search path.
 2628         case " $sys_lib_dlsearch_path " in
 2629         *" $absdir "*) ;;
 2630         *)
 2631           case "$compile_rpath " in
 2632           *" $absdir "*) ;;
 2633           *) compile_rpath="$compile_rpath $absdir"
 2634           esac
 2635           ;;
 2636         esac
 2637         case " $sys_lib_dlsearch_path " in
 2638         *" $libdir "*) ;;
 2639         *)
 2640           case "$finalize_rpath " in
 2641           *" $libdir "*) ;;
 2642           *) finalize_rpath="$finalize_rpath $libdir"
 2643           esac
 2644           ;;
 2645         esac
 2646       fi
 2647 
 2648       if test -n "$old_archive_from_expsyms_cmds"; then
 2649         # figure out the soname
 2650         set dummy $library_names
 2651         realname="$2"
 2652         shift; shift
 2653         libname=`eval \\$echo \"$libname_spec\"`
 2654         # use dlname if we got it. it's perfectly good, no?
 2655         if test -n "$dlname"; then
 2656           soname="$dlname"
 2657         elif test -n "$soname_spec"; then
 2658           # bleh windows
 2659           case $host in
 2660           *cygwin* | mingw*)
 2661         major=`expr $current - $age`
 2662         versuffix="-$major"
 2663         ;;
 2664           esac
 2665           eval soname=\"$soname_spec\"
 2666         else
 2667           soname="$realname"
 2668         fi
 2669 
 2670         # Make a new name for the extract_expsyms_cmds to use
 2671         soroot="$soname"
 2672         soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
 2673         newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
 2674 
 2675         # If the library has no export list, then create one now
 2676         if test -f "$output_objdir/$soname-def"; then :
 2677         else
 2678           $show "extracting exported symbol list from \`$soname'"
 2679           save_ifs="$IFS"; IFS='~'
 2680           cmds=$extract_expsyms_cmds
 2681           for cmd in $cmds; do
 2682         IFS="$save_ifs"
 2683         eval cmd=\"$cmd\"
 2684         $show "$cmd"
 2685         $run eval "$cmd" || exit $?
 2686           done
 2687           IFS="$save_ifs"
 2688         fi
 2689 
 2690         # Create $newlib
 2691         if test -f "$output_objdir/$newlib"; then :; else
 2692           $show "generating import library for \`$soname'"
 2693           save_ifs="$IFS"; IFS='~'
 2694           cmds=$old_archive_from_expsyms_cmds
 2695           for cmd in $cmds; do
 2696         IFS="$save_ifs"
 2697         eval cmd=\"$cmd\"
 2698         $show "$cmd"
 2699         $run eval "$cmd" || exit $?
 2700           done
 2701           IFS="$save_ifs"
 2702         fi
 2703         # make sure the library variables are pointing to the new library
 2704         dir=$output_objdir
 2705         linklib=$newlib
 2706       fi # test -n "$old_archive_from_expsyms_cmds"
 2707 
 2708       if test "$linkmode" = prog || test "$mode" != relink; then
 2709         add_shlibpath=
 2710         add_dir=
 2711         add=
 2712         lib_linked=yes
 2713         case $hardcode_action in
 2714         immediate | unsupported)
 2715           if test "$hardcode_direct" = no; then
 2716         add="$dir/$linklib"
 2717         case $host in
 2718           *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
 2719           *-*-sysv4*uw2*) add_dir="-L$dir" ;;
 2720           *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
 2721             *-*-unixware7*) add_dir="-L$dir" ;;
 2722           *-*-darwin* )
 2723             # if the lib is a module then we can not link against
 2724             # it, someone is ignoring the new warnings I added
 2725             if /usr/bin/file -L $add 2> /dev/null |
 2726                       $EGREP ": [^:]* bundle" >/dev/null ; then
 2727               $echo "** Warning, lib $linklib is a module, not a shared library"
 2728               if test -z "$old_library" ; then
 2729                 $echo
 2730                 $echo "** And there doesn't seem to be a static archive available"
 2731                 $echo "** The link will probably fail, sorry"
 2732               else
 2733                 add="$dir/$old_library"
 2734               fi
 2735             fi
 2736         esac
 2737           elif test "$hardcode_minus_L" = no; then
 2738         case $host in
 2739         *-*-sunos*) add_shlibpath="$dir" ;;
 2740         esac
 2741         add_dir="-L$dir"
 2742         add="-l$name"
 2743           elif test "$hardcode_shlibpath_var" = no; then
 2744         add_shlibpath="$dir"
 2745         add="-l$name"
 2746           else
 2747         lib_linked=no
 2748           fi
 2749           ;;
 2750         relink)
 2751           if test "$hardcode_direct" = yes; then
 2752         add="$dir/$linklib"
 2753           elif test "$hardcode_minus_L" = yes; then
 2754         add_dir="-L$dir"
 2755         # Try looking first in the location we're being installed to.
 2756         if test -n "$inst_prefix_dir"; then
 2757           case $libdir in
 2758             [\\/]*)
 2759               add_dir="$add_dir -L$inst_prefix_dir$libdir"
 2760               ;;
 2761           esac
 2762         fi
 2763         add="-l$name"
 2764           elif test "$hardcode_shlibpath_var" = yes; then
 2765         add_shlibpath="$dir"
 2766         add="-l$name"
 2767           else
 2768         lib_linked=no
 2769           fi
 2770           ;;
 2771         *) lib_linked=no ;;
 2772         esac
 2773 
 2774         if test "$lib_linked" != yes; then
 2775           $echo "$modename: configuration error: unsupported hardcode properties"
 2776           exit $EXIT_FAILURE
 2777         fi
 2778 
 2779         if test -n "$add_shlibpath"; then
 2780           case :$compile_shlibpath: in
 2781           *":$add_shlibpath:"*) ;;
 2782           *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
 2783           esac
 2784         fi
 2785         if test "$linkmode" = prog; then
 2786           test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
 2787           test -n "$add" && compile_deplibs="$add $compile_deplibs"
 2788         else
 2789           test -n "$add_dir" && deplibs="$add_dir $deplibs"
 2790           test -n "$add" && deplibs="$add $deplibs"
 2791           if test "$hardcode_direct" != yes && \
 2792          test "$hardcode_minus_L" != yes && \
 2793          test "$hardcode_shlibpath_var" = yes; then
 2794         case :$finalize_shlibpath: in
 2795         *":$libdir:"*) ;;
 2796         *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
 2797         esac
 2798           fi
 2799         fi
 2800       fi
 2801 
 2802       if test "$linkmode" = prog || test "$mode" = relink; then
 2803         add_shlibpath=
 2804         add_dir=
 2805         add=
 2806         # Finalize command for both is simple: just hardcode it.
 2807         if test "$hardcode_direct" = yes; then
 2808           add="$libdir/$linklib"
 2809         elif test "$hardcode_minus_L" = yes; then
 2810           add_dir="-L$libdir"
 2811           add="-l$name"
 2812         elif test "$hardcode_shlibpath_var" = yes; then
 2813           case :$finalize_shlibpath: in
 2814           *":$libdir:"*) ;;
 2815           *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
 2816           esac
 2817           add="-l$name"
 2818         elif test "$hardcode_automatic" = yes; then
 2819           if test -n "$inst_prefix_dir" &&
 2820          test -f "$inst_prefix_dir$libdir/$linklib" ; then
 2821             add="$inst_prefix_dir$libdir/$linklib"
 2822           else
 2823             add="$libdir/$linklib"
 2824           fi
 2825         else
 2826           # We cannot seem to hardcode it, guess we'll fake it.
 2827           add_dir="-L$libdir"
 2828           # Try looking first in the location we're being installed to.
 2829           if test -n "$inst_prefix_dir"; then
 2830         case $libdir in
 2831           [\\/]*)
 2832             add_dir="$add_dir -L$inst_prefix_dir$libdir"
 2833             ;;
 2834         esac
 2835           fi
 2836           add="-l$name"
 2837         fi
 2838 
 2839         if test "$linkmode" = prog; then
 2840           test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
 2841           test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
 2842         else
 2843           test -n "$add_dir" && deplibs="$add_dir $deplibs"
 2844           test -n "$add" && deplibs="$add $deplibs"
 2845         fi
 2846       fi
 2847     elif test "$linkmode" = prog; then
 2848       # Here we assume that one of hardcode_direct or hardcode_minus_L
 2849       # is not unsupported.  This is valid on all known static and
 2850       # shared platforms.
 2851       if test "$hardcode_direct" != unsupported; then
 2852         test -n "$old_library" && linklib="$old_library"
 2853         compile_deplibs="$dir/$linklib $compile_deplibs"
 2854         finalize_deplibs="$dir/$linklib $finalize_deplibs"
 2855       else
 2856         compile_deplibs="-l$name -L$dir $compile_deplibs"
 2857         finalize_deplibs="-l$name -L$dir $finalize_deplibs"
 2858       fi
 2859     elif test "$build_libtool_libs" = yes; then
 2860       # Not a shared library
 2861       if test "$deplibs_check_method" != pass_all; then
 2862         # We're trying link a shared library against a static one
 2863         # but the system doesn't support it.
 2864 
 2865         # Just print a warning and add the library to dependency_libs so
 2866         # that the program can be linked against the static library.
 2867         $echo
 2868         $echo "*** Warning: This system can not link to static lib archive $lib."
 2869         $echo "*** I have the capability to make that library automatically link in when"
 2870         $echo "*** you link to this library.  But I can only do this if you have a"
 2871         $echo "*** shared version of the library, which you do not appear to have."
 2872         if test "$module" = yes; then
 2873           $echo "*** But as you try to build a module library, libtool will still create "
 2874           $echo "*** a static module, that should work as long as the dlopening application"
 2875           $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
 2876           if test -z "$global_symbol_pipe"; then
 2877         $echo
 2878         $echo "*** However, this would only work if libtool was able to extract symbol"
 2879         $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
 2880         $echo "*** not find such a program.  So, this module is probably useless."
 2881         $echo "*** \`nm' from GNU binutils and a full rebuild may help."
 2882           fi
 2883           if test "$build_old_libs" = no; then
 2884         build_libtool_libs=module
 2885         build_old_libs=yes
 2886           else
 2887         build_libtool_libs=no
 2888           fi
 2889         fi
 2890       else
 2891         deplibs="$dir/$old_library $deplibs"
 2892         link_static=yes
 2893       fi
 2894     fi # link shared/static library?
 2895 
 2896     if test "$linkmode" = lib; then
 2897       if test -n "$dependency_libs" &&
 2898          { test "$hardcode_into_libs" != yes ||
 2899            test "$build_old_libs" = yes ||
 2900            test "$link_static" = yes; }; then
 2901         # Extract -R from dependency_libs
 2902         temp_deplibs=
 2903         for libdir in $dependency_libs; do
 2904           case $libdir in
 2905           -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
 2906            case " $xrpath " in
 2907            *" $temp_xrpath "*) ;;
 2908            *) xrpath="$xrpath $temp_xrpath";;
 2909            esac;;
 2910           *) temp_deplibs="$temp_deplibs $libdir";;
 2911           esac
 2912         done
 2913         dependency_libs="$temp_deplibs"
 2914       fi
 2915 
 2916       newlib_search_path="$newlib_search_path $absdir"
 2917       # Link against this library
 2918       test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
 2919       # ... and its dependency_libs
 2920       tmp_libs=
 2921       for deplib in $dependency_libs; do
 2922         newdependency_libs="$deplib $newdependency_libs"
 2923         if test "X$duplicate_deps" = "Xyes" ; then
 2924           case "$tmp_libs " in
 2925           *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 2926           esac
 2927         fi
 2928         tmp_libs="$tmp_libs $deplib"
 2929       done
 2930 
 2931       if test "$link_all_deplibs" != no; then
 2932         # Add the search paths of all dependency libraries
 2933         for deplib in $dependency_libs; do
 2934           case $deplib in
 2935           -L*) path="$deplib" ;;
 2936           *.la)
 2937         dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
 2938         test "X$dir" = "X$deplib" && dir="."
 2939         # We need an absolute path.
 2940         case $dir in
 2941         [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
 2942         *)
 2943           absdir=`cd "$dir" && pwd`
 2944           if test -z "$absdir"; then
 2945             $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
 2946             absdir="$dir"
 2947           fi
 2948           ;;
 2949         esac
 2950         if grep "^installed=no" $deplib > /dev/null; then
 2951           path="$absdir/$objdir"
 2952         else
 2953           eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
 2954           if test -z "$libdir"; then
 2955             $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
 2956             exit $EXIT_FAILURE
 2957           fi
 2958           if test "$absdir" != "$libdir"; then
 2959             $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
 2960           fi
 2961           path="$absdir"
 2962         fi
 2963         depdepl=
 2964         case $host in
 2965         *-*-darwin*)
 2966           # we do not want to link against static libs,
 2967           # but need to link against shared
 2968           eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
 2969           eval deplibdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
 2970           if test -n "$deplibrary_names" ; then
 2971             for tmp in $deplibrary_names ; do
 2972               depdepl=$tmp
 2973             done
 2974             if test -f "$deplibdir/$depdepl" ; then
 2975               depdepl="$deplibdir/$depdepl"
 2976                 elif test -f "$path/$depdepl" ; then
 2977               depdepl="$path/$depdepl"
 2978             else
 2979               # Can't find it, oh well...
 2980               depdepl=
 2981             fi
 2982             # do not add paths which are already there
 2983             case " $newlib_search_path " in
 2984             *" $path "*) ;;
 2985             *) newlib_search_path="$newlib_search_path $path";;
 2986             esac
 2987           fi
 2988           path=""
 2989           ;;
 2990         *)
 2991           path="-L$path"
 2992           ;;
 2993         esac
 2994         ;;
 2995           -l*)
 2996         case $host in
 2997         *-*-darwin*)
 2998           # Again, we only want to link against shared libraries
 2999           eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
 3000           for tmp in $newlib_search_path ; do
 3001             if test -f "$tmp/lib$tmp_libs.dylib" ; then
 3002               eval depdepl="$tmp/lib$tmp_libs.dylib"
 3003               break
 3004             fi
 3005           done
 3006           path=""
 3007           ;;
 3008         *) continue ;;
 3009         esac
 3010         ;;
 3011           *) continue ;;
 3012           esac
 3013           case " $deplibs " in
 3014           *" $path "*) ;;
 3015           *) deplibs="$path $deplibs" ;;
 3016           esac
 3017           case " $deplibs " in
 3018           *" $depdepl "*) ;;
 3019           *) deplibs="$depdepl $deplibs" ;;
 3020           esac
 3021         done
 3022       fi # link_all_deplibs != no
 3023     fi # linkmode = lib
 3024       done # for deplib in $libs
 3025       dependency_libs="$newdependency_libs"
 3026       if test "$pass" = dlpreopen; then
 3027     # Link the dlpreopened libraries before other libraries
 3028     for deplib in $save_deplibs; do
 3029       deplibs="$deplib $deplibs"
 3030     done
 3031       fi
 3032       if test "$pass" != dlopen; then
 3033     if test "$pass" != conv; then
 3034       # Make sure lib_search_path contains only unique directories.
 3035       lib_search_path=
 3036       for dir in $newlib_search_path; do
 3037         case "$lib_search_path " in
 3038         *" $dir "*) ;;
 3039         *) lib_search_path="$lib_search_path $dir" ;;
 3040         esac
 3041       done
 3042       newlib_search_path=
 3043     fi
 3044 
 3045     if test "$linkmode,$pass" != "prog,link"; then
 3046       vars="deplibs"
 3047     else
 3048       vars="compile_deplibs finalize_deplibs"
 3049     fi
 3050     for var in $vars dependency_libs; do
 3051       # Add libraries to $var in reverse order
 3052       eval tmp_libs=\"\$$var\"
 3053       new_libs=
 3054       for deplib in $tmp_libs; do
 3055         # FIXME: Pedantically, this is the right thing to do, so
 3056         #        that some nasty dependency loop isn't accidentally
 3057         #        broken:
 3058         #new_libs="$deplib $new_libs"
 3059         # Pragmatically, this seems to cause very few problems in
 3060         # practice:
 3061         case $deplib in
 3062         -L*) new_libs="$deplib $new_libs" ;;
 3063         -R*) ;;
 3064         *)
 3065           # And here is the reason: when a library appears more
 3066           # than once as an explicit dependence of a library, or
 3067           # is implicitly linked in more than once by the
 3068           # compiler, it is considered special, and multiple
 3069           # occurrences thereof are not removed.  Compare this
 3070           # with having the same library being listed as a
 3071           # dependency of multiple other libraries: in this case,
 3072           # we know (pedantically, we assume) the library does not
 3073           # need to be listed more than once, so we keep only the
 3074           # last copy.  This is not always right, but it is rare
 3075           # enough that we require users that really mean to play
 3076           # such unportable linking tricks to link the library
 3077           # using -Wl,-lname, so that libtool does not consider it
 3078           # for duplicate removal.
 3079           case " $specialdeplibs " in
 3080           *" $deplib "*) new_libs="$deplib $new_libs" ;;
 3081           *)
 3082         case " $new_libs " in
 3083         *" $deplib "*) ;;
 3084         *) new_libs="$deplib $new_libs" ;;
 3085         esac
 3086         ;;
 3087           esac
 3088           ;;
 3089         esac
 3090       done
 3091       tmp_libs=
 3092       for deplib in $new_libs; do
 3093         case $deplib in
 3094         -L*)
 3095           case " $tmp_libs " in
 3096           *" $deplib "*) ;;
 3097           *) tmp_libs="$tmp_libs $deplib" ;;
 3098           esac
 3099           ;;
 3100         *) tmp_libs="$tmp_libs $deplib" ;;
 3101         esac
 3102       done
 3103       eval $var=\"$tmp_libs\"
 3104     done # for var
 3105       fi
 3106       # Last step: remove runtime libs from dependency_libs
 3107       # (they stay in deplibs)
 3108       tmp_libs=
 3109       for i in $dependency_libs ; do
 3110     case " $predeps $postdeps $compiler_lib_search_path " in
 3111     *" $i "*)
 3112       i=""
 3113       ;;
 3114     esac
 3115     if test -n "$i" ; then
 3116       tmp_libs="$tmp_libs $i"
 3117     fi
 3118       done
 3119       dependency_libs=$tmp_libs
 3120     done # for pass
 3121     if test "$linkmode" = prog; then
 3122       dlfiles="$newdlfiles"
 3123       dlprefiles="$newdlprefiles"
 3124     fi
 3125 
 3126     case $linkmode in
 3127     oldlib)
 3128       case " $deplibs" in
 3129       *\ -l* | *\ -L*)
 3130     $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2 ;;
 3131       esac
 3132 
 3133       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
 3134     $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
 3135       fi
 3136 
 3137       if test -n "$rpath"; then
 3138     $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
 3139       fi
 3140 
 3141       if test -n "$xrpath"; then
 3142     $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
 3143       fi
 3144 
 3145       if test -n "$vinfo"; then
 3146     $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
 3147       fi
 3148 
 3149       if test -n "$release"; then
 3150     $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
 3151       fi
 3152 
 3153       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
 3154     $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
 3155       fi
 3156 
 3157       # Now set the variables for building old libraries.
 3158       build_libtool_libs=no
 3159       oldlibs="$output"
 3160       objs="$objs$old_deplibs"
 3161       ;;
 3162 
 3163     lib)
 3164       # Make sure we only generate libraries of the form `libNAME.la'.
 3165       case $outputname in
 3166       lib*)
 3167     name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 3168     eval shared_ext=\"$shrext_cmds\"
 3169     eval libname=\"$libname_spec\"
 3170     ;;
 3171       *)
 3172     if test "$module" = no; then
 3173       $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
 3174       $echo "$help" 1>&2
 3175       exit $EXIT_FAILURE
 3176     fi
 3177     if test "$need_lib_prefix" != no; then
 3178       # Add the "lib" prefix for modules if required
 3179       name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
 3180       eval shared_ext=\"$shrext_cmds\"
 3181       eval libname=\"$libname_spec\"
 3182     else
 3183       libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
 3184     fi
 3185     ;;
 3186       esac
 3187 
 3188       if test -n "$objs"; then
 3189     if test "$deplibs_check_method" != pass_all; then
 3190       $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
 3191       exit $EXIT_FAILURE
 3192     else
 3193       $echo
 3194       $echo "*** Warning: Linking the shared library $output against the non-libtool"
 3195       $echo "*** objects $objs is not portable!"
 3196       libobjs="$libobjs $objs"
 3197     fi
 3198       fi
 3199 
 3200       if test "$dlself" != no; then
 3201     $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
 3202       fi
 3203 
 3204       set dummy $rpath
 3205       if test "$#" -gt 2; then
 3206     $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
 3207       fi
 3208       install_libdir="$2"
 3209 
 3210       oldlibs=
 3211       if test -z "$rpath"; then
 3212     if test "$build_libtool_libs" = yes; then
 3213       # Building a libtool convenience library.
 3214       # Some compilers have problems with a `.al' extension so
 3215       # convenience libraries should have the same extension an
 3216       # archive normally would.
 3217       oldlibs="$output_objdir/$libname.$libext $oldlibs"
 3218       build_libtool_libs=convenience
 3219       build_old_libs=yes
 3220     fi
 3221 
 3222     if test -n "$vinfo"; then
 3223       $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
 3224     fi
 3225 
 3226     if test -n "$release"; then
 3227       $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
 3228     fi
 3229       else
 3230 
 3231     # Parse the version information argument.
 3232     save_ifs="$IFS"; IFS=':'
 3233     set dummy $vinfo 0 0 0
 3234     IFS="$save_ifs"
 3235 
 3236     if test -n "$8"; then
 3237       $echo "$modename: too many parameters to \`-version-info'" 1>&2
 3238       $echo "$help" 1>&2
 3239       exit $EXIT_FAILURE
 3240     fi
 3241 
 3242     # convert absolute version numbers to libtool ages
 3243     # this retains compatibility with .la files and attempts
 3244     # to make the code below a bit more comprehensible
 3245 
 3246     case $vinfo_number in
 3247     yes)
 3248       number_major="$2"
 3249       number_minor="$3"
 3250       number_revision="$4"
 3251       #
 3252       # There are really only two kinds -- those that
 3253       # use the current revision as the major version
 3254       # and those that subtract age and use age as
 3255       # a minor version.  But, then there is irix
 3256       # which has an extra 1 added just for fun
 3257       #
 3258       case $version_type in
 3259       darwin|linux|osf|windows|none)
 3260         current=`expr $number_major + $number_minor`
 3261         age="$number_minor"
 3262         revision="$number_revision"
 3263         ;;
 3264       freebsd-aout|freebsd-elf|sunos)
 3265         current="$number_major"
 3266         revision="$number_minor"
 3267         age="0"
 3268         ;;
 3269       irix|nonstopux)
 3270         current=`expr $number_major + $number_minor`
 3271         age="$number_minor"
 3272         revision="$number_minor"
 3273         lt_irix_increment=no
 3274         ;;
 3275       *)
 3276         $echo "$modename: unknown library version type \`$version_type'" 1>&2
 3277         $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
 3278         exit $EXIT_FAILURE
 3279         ;;
 3280       esac
 3281       ;;
 3282     no)
 3283       current="$2"
 3284       revision="$3"
 3285       age="$4"
 3286       ;;
 3287     esac
 3288 
 3289     # Check that each of the things are valid numbers.
 3290     case $current in
 3291     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]) ;;
 3292     *)
 3293       $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
 3294       $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 3295       exit $EXIT_FAILURE
 3296       ;;
 3297     esac
 3298 
 3299     case $revision in
 3300     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]) ;;
 3301     *)
 3302       $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
 3303       $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 3304       exit $EXIT_FAILURE
 3305       ;;
 3306     esac
 3307 
 3308     case $age in
 3309     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]) ;;
 3310     *)
 3311       $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
 3312       $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 3313       exit $EXIT_FAILURE
 3314       ;;
 3315     esac
 3316 
 3317     if test "$age" -gt "$current"; then
 3318       $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
 3319       $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 3320       exit $EXIT_FAILURE
 3321     fi
 3322 
 3323     # Calculate the version variables.
 3324     major=
 3325     versuffix=
 3326     verstring=
 3327     case $version_type in
 3328     none) ;;
 3329 
 3330     darwin)
 3331       # Like Linux, but with the current version available in
 3332       # verstring for coding it into the library header
 3333       major=.`expr $current - $age`
 3334       versuffix="$major.$age.$revision"
 3335       # Darwin ld doesn't like 0 for these options...
 3336       minor_current=`expr $current + 1`
 3337       xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
 3338       verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
 3339       ;;
 3340 
 3341     freebsd-aout)
 3342       major=".$current"
 3343       versuffix=".$current.$revision";
 3344       ;;
 3345 
 3346     freebsd-elf)
 3347       major=".$current"
 3348       versuffix=".$current";
 3349       ;;
 3350 
 3351     irix | nonstopux)
 3352       if test "X$lt_irix_increment" = "Xno"; then
 3353         major=`expr $current - $age`
 3354       else
 3355         major=`expr $current - $age + 1`
 3356       fi
 3357       case $version_type in
 3358         nonstopux) verstring_prefix=nonstopux ;;
 3359         *)         verstring_prefix=sgi ;;
 3360       esac
 3361       verstring="$verstring_prefix$major.$revision"
 3362 
 3363       # Add in all the interfaces that we are compatible with.
 3364       loop=$revision
 3365       while test "$loop" -ne 0; do
 3366         iface=`expr $revision - $loop`
 3367         loop=`expr $loop - 1`
 3368         verstring="$verstring_prefix$major.$iface:$verstring"
 3369       done
 3370 
 3371       # Before this point, $major must not contain `.'.
 3372       major=.$major
 3373       versuffix="$major.$revision"
 3374       ;;
 3375 
 3376     linux)
 3377       major=.`expr $current - $age`
 3378       versuffix="$major.$age.$revision"
 3379       ;;
 3380 
 3381     osf)
 3382       major=.`expr $current - $age`
 3383       versuffix=".$current.$age.$revision"
 3384       verstring="$current.$age.$revision"
 3385 
 3386       # Add in all the interfaces that we are compatible with.
 3387       loop=$age
 3388       while test "$loop" -ne 0; do
 3389         iface=`expr $current - $loop`
 3390         loop=`expr $loop - 1`
 3391         verstring="$verstring:${iface}.0"
 3392       done
 3393 
 3394       # Make executables depend on our current version.
 3395       verstring="$verstring:${current}.0"
 3396       ;;
 3397 
 3398     sunos)
 3399       major=".$current"
 3400       versuffix=".$current.$revision"
 3401       ;;
 3402 
 3403     windows)
 3404       # Use '-' rather than '.', since we only want one
 3405       # extension on DOS 8.3 filesystems.
 3406       major=`expr $current - $age`
 3407       versuffix="-$major"
 3408       ;;
 3409 
 3410     *)
 3411       $echo "$modename: unknown library version type \`$version_type'" 1>&2
 3412       $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
 3413       exit $EXIT_FAILURE
 3414       ;;
 3415     esac
 3416 
 3417     # Clear the version info if we defaulted, and they specified a release.
 3418     if test -z "$vinfo" && test -n "$release"; then
 3419       major=
 3420       case $version_type in
 3421       darwin)
 3422         # we can't check for "0.0" in archive_cmds due to quoting
 3423         # problems, so we reset it completely
 3424         verstring=
 3425         ;;
 3426       *)
 3427         verstring="0.0"
 3428         ;;
 3429       esac
 3430       if test "$need_version" = no; then
 3431         versuffix=
 3432       else
 3433         versuffix=".0.0"
 3434       fi
 3435     fi
 3436 
 3437     # Remove version info from name if versioning should be avoided
 3438     if test "$avoid_version" = yes && test "$need_version" = no; then
 3439       major=
 3440       versuffix=
 3441       verstring=""
 3442     fi
 3443 
 3444     # Check to see if the archive will have undefined symbols.
 3445     if test "$allow_undefined" = yes; then
 3446       if test "$allow_undefined_flag" = unsupported; then
 3447         $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
 3448         build_libtool_libs=no
 3449         build_old_libs=yes
 3450       fi
 3451     else
 3452       # Don't allow undefined symbols.
 3453       allow_undefined_flag="$no_undefined_flag"
 3454     fi
 3455       fi
 3456 
 3457       if test "$mode" != relink; then
 3458     # Remove our outputs, but don't remove object files since they
 3459     # may have been created when compiling PIC objects.
 3460     removelist=
 3461     tempremovelist=`$echo "$output_objdir/*"`
 3462     for p in $tempremovelist; do
 3463       case $p in
 3464         *.$objext)
 3465            ;;
 3466         $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
 3467            if test "X$precious_files_regex" != "X"; then
 3468              if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
 3469              then
 3470            continue
 3471          fi
 3472            fi
 3473            removelist="$removelist $p"
 3474            ;;
 3475         *) ;;
 3476       esac
 3477     done
 3478     if test -n "$removelist"; then
 3479       $show "${rm}r $removelist"
 3480       $run ${rm}r $removelist
 3481     fi
 3482       fi
 3483 
 3484       # Now set the variables for building old libraries.
 3485       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
 3486     oldlibs="$oldlibs $output_objdir/$libname.$libext"
 3487 
 3488     # Transform .lo files to .o files.
 3489     oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
 3490       fi
 3491 
 3492       # Eliminate all temporary directories.
 3493       #for path in $notinst_path; do
 3494       # lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
 3495       # deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
 3496       # dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
 3497       #done
 3498 
 3499       if test -n "$xrpath"; then
 3500     # If the user specified any rpath flags, then add them.
 3501     temp_xrpath=
 3502     for libdir in $xrpath; do
 3503       temp_xrpath="$temp_xrpath -R$libdir"
 3504       case "$finalize_rpath " in
 3505       *" $libdir "*) ;;
 3506       *) finalize_rpath="$finalize_rpath $libdir" ;;
 3507       esac
 3508     done
 3509     if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
 3510       dependency_libs="$temp_xrpath $dependency_libs"
 3511     fi
 3512       fi
 3513 
 3514       # Make sure dlfiles contains only unique files that won't be dlpreopened
 3515       old_dlfiles="$dlfiles"
 3516       dlfiles=
 3517       for lib in $old_dlfiles; do
 3518     case " $dlprefiles $dlfiles " in
 3519     *" $lib "*) ;;
 3520     *) dlfiles="$dlfiles $lib" ;;
 3521     esac
 3522       done
 3523 
 3524       # Make sure dlprefiles contains only unique files
 3525       old_dlprefiles="$dlprefiles"
 3526       dlprefiles=
 3527       for lib in $old_dlprefiles; do
 3528     case "$dlprefiles " in
 3529     *" $lib "*) ;;
 3530     *) dlprefiles="$dlprefiles $lib" ;;
 3531     esac
 3532       done
 3533 
 3534       if test "$build_libtool_libs" = yes; then
 3535     if test -n "$rpath"; then
 3536       case $host in
 3537       *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
 3538         # these systems don't actually have a c library (as such)!
 3539         ;;
 3540       *-*-rhapsody* | *-*-darwin1.[012])
 3541         # Rhapsody C library is in the System framework
 3542         deplibs="$deplibs -framework System"
 3543         ;;
 3544       *-*-netbsd*)
 3545         # Don't link with libc until the a.out ld.so is fixed.
 3546         ;;
 3547       *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
 3548         # Do not include libc due to us having libc/libc_r.
 3549         ;;
 3550       *-*-sco3.2v5* | *-*-sco5v6*)
 3551         # Causes problems with __ctype
 3552         ;;
 3553       *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
 3554         # Compiler inserts libc in the correct place for threads to work
 3555         ;;
 3556       *)
 3557         # Add libc to deplibs on all other systems if necessary.
 3558         if test "$build_libtool_need_lc" = "yes"; then
 3559           deplibs="$deplibs -lc"
 3560         fi
 3561         ;;
 3562       esac
 3563     fi
 3564 
 3565     # Transform deplibs into only deplibs that can be linked in shared.
 3566     name_save=$name
 3567     libname_save=$libname
 3568     release_save=$release
 3569     versuffix_save=$versuffix
 3570     major_save=$major
 3571     # I'm not sure if I'm treating the release correctly.  I think
 3572     # release should show up in the -l (ie -lgmp5) so we don't want to
 3573     # add it in twice.  Is that correct?
 3574     release=""
 3575     versuffix=""
 3576     major=""
 3577     newdeplibs=
 3578     droppeddeps=no
 3579     case $deplibs_check_method in
 3580     pass_all)
 3581       # Don't check for shared/static.  Everything works.
 3582       # This might be a little naive.  We might want to check
 3583       # whether the library exists or not.  But this is on
 3584       # osf3 & osf4 and I'm not really sure... Just
 3585       # implementing what was already the behavior.
 3586       newdeplibs=$deplibs
 3587       ;;
 3588     test_compile)
 3589       # This code stresses the "libraries are programs" paradigm to its
 3590       # limits. Maybe even breaks it.  We compile a program, linking it
 3591       # against the deplibs as a proxy for the library.  Then we can check
 3592       # whether they linked in statically or dynamically with ldd.
 3593       $rm conftest.c
 3594       cat > conftest.c <<EOF
 3595       int main() { return 0; }
 3596 EOF
 3597       $rm conftest
 3598       if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
 3599         ldd_output=`ldd conftest`
 3600         for i in $deplibs; do
 3601           name=`expr $i : '-l\(.*\)'`
 3602           # If $name is empty we are operating on a -L argument.
 3603               if test "$name" != "" && test "$name" != "0"; then
 3604         if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 3605           case " $predeps $postdeps " in
 3606           *" $i "*)
 3607             newdeplibs="$newdeplibs $i"
 3608             i=""
 3609             ;;
 3610           esac
 3611             fi
 3612         if test -n "$i" ; then
 3613           libname=`eval \\$echo \"$libname_spec\"`
 3614           deplib_matches=`eval \\$echo \"$library_names_spec\"`
 3615           set dummy $deplib_matches
 3616           deplib_match=$2
 3617           if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
 3618             newdeplibs="$newdeplibs $i"
 3619           else
 3620             droppeddeps=yes
 3621             $echo
 3622             $echo "*** Warning: dynamic linker does not accept needed library $i."
 3623             $echo "*** I have the capability to make that library automatically link in when"
 3624             $echo "*** you link to this library.  But I can only do this if you have a"
 3625             $echo "*** shared version of the library, which I believe you do not have"
 3626             $echo "*** because a test_compile did reveal that the linker did not use it for"
 3627             $echo "*** its dynamic dependency list that programs get resolved with at runtime."
 3628           fi
 3629         fi
 3630           else
 3631         newdeplibs="$newdeplibs $i"
 3632           fi
 3633         done
 3634       else
 3635         # Error occurred in the first compile.  Let's try to salvage
 3636         # the situation: Compile a separate program for each library.
 3637         for i in $deplibs; do
 3638           name=`expr $i : '-l\(.*\)'`
 3639           # If $name is empty we are operating on a -L argument.
 3640               if test "$name" != "" && test "$name" != "0"; then
 3641         $rm conftest
 3642         if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
 3643           ldd_output=`ldd conftest`
 3644           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 3645             case " $predeps $postdeps " in
 3646             *" $i "*)
 3647               newdeplibs="$newdeplibs $i"
 3648               i=""
 3649               ;;
 3650             esac
 3651           fi
 3652           if test -n "$i" ; then
 3653             libname=`eval \\$echo \"$libname_spec\"`
 3654             deplib_matches=`eval \\$echo \"$library_names_spec\"`
 3655             set dummy $deplib_matches
 3656             deplib_match=$2
 3657             if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
 3658               newdeplibs="$newdeplibs $i"
 3659             else
 3660               droppeddeps=yes
 3661               $echo
 3662               $echo "*** Warning: dynamic linker does not accept needed library $i."
 3663               $echo "*** I have the capability to make that library automatically link in when"
 3664               $echo "*** you link to this library.  But I can only do this if you have a"
 3665               $echo "*** shared version of the library, which you do not appear to have"
 3666               $echo "*** because a test_compile did reveal that the linker did not use this one"
 3667               $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
 3668             fi
 3669           fi
 3670         else
 3671           droppeddeps=yes
 3672           $echo
 3673           $echo "*** Warning!  Library $i is needed by this library but I was not able to"
 3674           $echo "*** make it link in!  You will probably need to install it or some"
 3675           $echo "*** library that it depends on before this library will be fully"
 3676           $echo "*** functional.  Installing it before continuing would be even better."
 3677         fi
 3678           else
 3679         newdeplibs="$newdeplibs $i"
 3680           fi
 3681         done
 3682       fi
 3683       ;;
 3684     file_magic*)
 3685       set dummy $deplibs_check_method
 3686       file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
 3687       for a_deplib in $deplibs; do
 3688         name=`expr $a_deplib : '-l\(.*\)'`
 3689         # If $name is empty we are operating on a -L argument.
 3690             if test "$name" != "" && test  "$name" != "0"; then
 3691           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 3692         case " $predeps $postdeps " in
 3693         *" $a_deplib "*)
 3694           newdeplibs="$newdeplibs $a_deplib"
 3695           a_deplib=""
 3696           ;;
 3697         esac
 3698           fi
 3699           if test -n "$a_deplib" ; then
 3700         libname=`eval \\$echo \"$libname_spec\"`
 3701         for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
 3702           potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
 3703           for potent_lib in $potential_libs; do
 3704               # Follow soft links.
 3705               if ls -lLd "$potent_lib" 2>/dev/null \
 3706              | grep " -> " >/dev/null; then
 3707             continue
 3708               fi
 3709               # The statement above tries to avoid entering an
 3710               # endless loop below, in case of cyclic links.
 3711               # We might still enter an endless loop, since a link
 3712               # loop can be closed while we follow links,
 3713               # but so what?
 3714               potlib="$potent_lib"
 3715               while test -h "$potlib" 2>/dev/null; do
 3716             potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
 3717             case $potliblink in
 3718             [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
 3719             *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
 3720             esac
 3721               done
 3722               if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
 3723              | ${SED} 10q \
 3724              | $EGREP "$file_magic_regex" > /dev/null; then
 3725             newdeplibs="$newdeplibs $a_deplib"
 3726             a_deplib=""
 3727             break 2
 3728               fi
 3729           done
 3730         done
 3731           fi
 3732           if test -n "$a_deplib" ; then
 3733         droppeddeps=yes
 3734         $echo
 3735         $echo "*** Warning: linker path does not have real file for library $a_deplib."
 3736         $echo "*** I have the capability to make that library automatically link in when"
 3737         $echo "*** you link to this library.  But I can only do this if you have a"
 3738         $echo "*** shared version of the library, which you do not appear to have"
 3739         $echo "*** because I did check the linker path looking for a file starting"
 3740         if test -z "$potlib" ; then
 3741           $echo "*** with $libname but no candidates were found. (...for file magic test)"
 3742         else
 3743           $echo "*** with $libname and none of the candidates passed a file format test"
 3744           $echo "*** using a file magic. Last file checked: $potlib"
 3745         fi
 3746           fi
 3747         else
 3748           # Add a -L argument.
 3749           newdeplibs="$newdeplibs $a_deplib"
 3750         fi
 3751       done # Gone through all deplibs.
 3752       ;;
 3753     match_pattern*)
 3754       set dummy $deplibs_check_method
 3755       match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
 3756       for a_deplib in $deplibs; do
 3757         name=`expr $a_deplib : '-l\(.*\)'`
 3758         # If $name is empty we are operating on a -L argument.
 3759         if test -n "$name" && test "$name" != "0"; then
 3760           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 3761         case " $predeps $postdeps " in
 3762         *" $a_deplib "*)
 3763           newdeplibs="$newdeplibs $a_deplib"
 3764           a_deplib=""
 3765           ;;
 3766         esac
 3767           fi
 3768           if test -n "$a_deplib" ; then
 3769         libname=`eval \\$echo \"$libname_spec\"`
 3770         for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
 3771           potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
 3772           for potent_lib in $potential_libs; do
 3773             potlib="$potent_lib" # see symlink-check above in file_magic test
 3774             if eval $echo \"$potent_lib\" 2>/dev/null \
 3775                 | ${SED} 10q \
 3776                 | $EGREP "$match_pattern_regex" > /dev/null; then
 3777               newdeplibs="$newdeplibs $a_deplib"
 3778               a_deplib=""
 3779               break 2
 3780             fi
 3781           done
 3782         done
 3783           fi
 3784           if test -n "$a_deplib" ; then
 3785         droppeddeps=yes
 3786         $echo
 3787         $echo "*** Warning: linker path does not have real file for library $a_deplib."
 3788         $echo "*** I have the capability to make that library automatically link in when"
 3789         $echo "*** you link to this library.  But I can only do this if you have a"
 3790         $echo "*** shared version of the library, which you do not appear to have"
 3791         $echo "*** because I did check the linker path looking for a file starting"
 3792         if test -z "$potlib" ; then
 3793           $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
 3794         else
 3795           $echo "*** with $libname and none of the candidates passed a file format test"
 3796           $echo "*** using a regex pattern. Last file checked: $potlib"
 3797         fi
 3798           fi
 3799         else
 3800           # Add a -L argument.
 3801           newdeplibs="$newdeplibs $a_deplib"
 3802         fi
 3803       done # Gone through all deplibs.
 3804       ;;
 3805     none | unknown | *)
 3806       newdeplibs=""
 3807       tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
 3808         -e 's/ -[LR][^ ]*//g'`
 3809       if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 3810         for i in $predeps $postdeps ; do
 3811           # can't use Xsed below, because $i might contain '/'
 3812           tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
 3813         done
 3814       fi
 3815       if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
 3816         | grep . >/dev/null; then
 3817         $echo
 3818         if test "X$deplibs_check_method" = "Xnone"; then
 3819           $echo "*** Warning: inter-library dependencies are not supported in this platform."
 3820         else
 3821           $echo "*** Warning: inter-library dependencies are not known to be supported."
 3822         fi
 3823         $echo "*** All declared inter-library dependencies are being dropped."
 3824         droppeddeps=yes
 3825       fi
 3826       ;;
 3827     esac
 3828     versuffix=$versuffix_save
 3829     major=$major_save
 3830     release=$release_save
 3831     libname=$libname_save
 3832     name=$name_save
 3833 
 3834     case $host in
 3835     *-*-rhapsody* | *-*-darwin1.[012])
 3836       # On Rhapsody replace the C library is the System framework
 3837       newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
 3838       ;;
 3839     esac
 3840 
 3841     if test "$droppeddeps" = yes; then
 3842       if test "$module" = yes; then
 3843         $echo
 3844         $echo "*** Warning: libtool could not satisfy all declared inter-library"
 3845         $echo "*** dependencies of module $libname.  Therefore, libtool will create"
 3846         $echo "*** a static module, that should work as long as the dlopening"
 3847         $echo "*** application is linked with the -dlopen flag."
 3848         if test -z "$global_symbol_pipe"; then
 3849           $echo
 3850           $echo "*** However, this would only work if libtool was able to extract symbol"
 3851           $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
 3852           $echo "*** not find such a program.  So, this module is probably useless."
 3853           $echo "*** \`nm' from GNU binutils and a full rebuild may help."
 3854         fi
 3855         if test "$build_old_libs" = no; then
 3856           oldlibs="$output_objdir/$libname.$libext"
 3857           build_libtool_libs=module
 3858           build_old_libs=yes
 3859         else
 3860           build_libtool_libs=no
 3861         fi
 3862       else
 3863         $echo "*** The inter-library dependencies that have been dropped here will be"
 3864         $echo "*** automatically added whenever a program is linked with this library"
 3865         $echo "*** or is declared to -dlopen it."
 3866 
 3867         if test "$allow_undefined" = no; then
 3868           $echo
 3869           $echo "*** Since this library must not contain undefined symbols,"
 3870           $echo "*** because either the platform does not support them or"
 3871           $echo "*** it was explicitly requested with -no-undefined,"
 3872           $echo "*** libtool will only create a static version of it."
 3873           if test "$build_old_libs" = no; then
 3874         oldlibs="$output_objdir/$libname.$libext"
 3875         build_libtool_libs=module
 3876         build_old_libs=yes
 3877           else
 3878         build_libtool_libs=no
 3879           fi
 3880         fi
 3881       fi
 3882     fi
 3883     # Done checking deplibs!
 3884     deplibs=$newdeplibs
 3885       fi
 3886 
 3887 
 3888       # move library search paths that coincide with paths to not yet
 3889       # installed libraries to the beginning of the library search list
 3890       new_libs=
 3891       for path in $notinst_path; do
 3892     case " $new_libs " in
 3893     *" -L$path/$objdir "*) ;;
 3894     *)
 3895       case " $deplibs " in
 3896       *" -L$path/$objdir "*)
 3897         new_libs="$new_libs -L$path/$objdir" ;;
 3898       esac
 3899       ;;
 3900     esac
 3901       done
 3902       for deplib in $deplibs; do
 3903     case $deplib in
 3904     -L*)
 3905       case " $new_libs " in
 3906       *" $deplib "*) ;;
 3907       *) new_libs="$new_libs $deplib" ;;
 3908       esac
 3909       ;;
 3910     *) new_libs="$new_libs $deplib" ;;
 3911     esac
 3912       done
 3913       deplibs="$new_libs"
 3914 
 3915 
 3916       # All the library-specific variables (install_libdir is set above).
 3917       library_names=
 3918       old_library=
 3919       dlname=
 3920 
 3921       # Test again, we may have decided not to build it any more
 3922       if test "$build_libtool_libs" = yes; then
 3923     if test "$hardcode_into_libs" = yes; then
 3924       # Hardcode the library paths
 3925       hardcode_libdirs=
 3926       dep_rpath=
 3927       rpath="$finalize_rpath"
 3928       test "$mode" != relink && rpath="$compile_rpath$rpath"
 3929       for libdir in $rpath; do
 3930         if test -n "$hardcode_libdir_flag_spec"; then
 3931           if test -n "$hardcode_libdir_separator"; then
 3932         if test -z "$hardcode_libdirs"; then
 3933           hardcode_libdirs="$libdir"
 3934         else
 3935           # Just accumulate the unique libdirs.
 3936           case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
 3937           *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 3938             ;;
 3939           *)
 3940             hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 3941             ;;
 3942           esac
 3943         fi
 3944           else
 3945         eval flag=\"$hardcode_libdir_flag_spec\"
 3946         dep_rpath="$dep_rpath $flag"
 3947           fi
 3948         elif test -n "$runpath_var"; then
 3949           case "$perm_rpath " in
 3950           *" $libdir "*) ;;
 3951           *) perm_rpath="$perm_rpath $libdir" ;;
 3952           esac
 3953         fi
 3954       done
 3955       # Substitute the hardcoded libdirs into the rpath.
 3956       if test -n "$hardcode_libdir_separator" &&
 3957          test -n "$hardcode_libdirs"; then
 3958         libdir="$hardcode_libdirs"
 3959         if test -n "$hardcode_libdir_flag_spec_ld"; then
 3960           case $archive_cmds in
 3961           *\$LD*) eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" ;;
 3962           *)      eval dep_rpath=\"$hardcode_libdir_flag_spec\" ;;
 3963           esac
 3964         else
 3965           eval dep_rpath=\"$hardcode_libdir_flag_spec\"
 3966         fi
 3967       fi
 3968       if test -n "$runpath_var" && test -n "$perm_rpath"; then
 3969         # We should set the runpath_var.
 3970         rpath=
 3971         for dir in $perm_rpath; do
 3972           rpath="$rpath$dir:"
 3973         done
 3974         eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
 3975       fi
 3976       test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
 3977     fi
 3978 
 3979     shlibpath="$finalize_shlibpath"
 3980     test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
 3981     if test -n "$shlibpath"; then
 3982       eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
 3983     fi
 3984 
 3985     # Get the real and link names of the library.
 3986     eval shared_ext=\"$shrext_cmds\"
 3987     eval library_names=\"$library_names_spec\"
 3988     set dummy $library_names
 3989     realname="$2"
 3990     shift; shift
 3991 
 3992     if test -n "$soname_spec"; then
 3993       eval soname=\"$soname_spec\"
 3994     else
 3995       soname="$realname"
 3996     fi
 3997     if test -z "$dlname"; then
 3998       dlname=$soname
 3999     fi
 4000 
 4001     lib="$output_objdir/$realname"
 4002     linknames=
 4003     for link
 4004     do
 4005       linknames="$linknames $link"
 4006     done
 4007 
 4008     # Use standard objects if they are pic
 4009     test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 4010 
 4011     # Prepare the list of exported symbols
 4012     if test -z "$export_symbols"; then
 4013       if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
 4014         $show "generating symbol list for \`$libname.la'"
 4015         export_symbols="$output_objdir/$libname.exp"
 4016         $run $rm $export_symbols
 4017         cmds=$export_symbols_cmds
 4018         save_ifs="$IFS"; IFS='~'
 4019         for cmd in $cmds; do
 4020           IFS="$save_ifs"
 4021           eval cmd=\"$cmd\"
 4022           if len=`expr "X$cmd" : ".*"` &&
 4023            test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 4024             $show "$cmd"
 4025             $run eval "$cmd" || exit $?
 4026             skipped_export=false
 4027           else
 4028             # The command line is too long to execute in one step.
 4029             $show "using reloadable object file for export list..."
 4030             skipped_export=:
 4031         # Break out early, otherwise skipped_export may be
 4032         # set to false by a later but shorter cmd.
 4033         break
 4034           fi
 4035         done
 4036         IFS="$save_ifs"
 4037         if test -n "$export_symbols_regex"; then
 4038           $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
 4039           $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
 4040           $show "$mv \"${export_symbols}T\" \"$export_symbols\""
 4041           $run eval '$mv "${export_symbols}T" "$export_symbols"'
 4042         fi
 4043       fi
 4044     fi
 4045 
 4046     if test -n "$export_symbols" && test -n "$include_expsyms"; then
 4047       $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
 4048     fi
 4049 
 4050     tmp_deplibs=
 4051     for test_deplib in $deplibs; do
 4052         case " $convenience " in
 4053         *" $test_deplib "*) ;;
 4054         *)
 4055             tmp_deplibs="$tmp_deplibs $test_deplib"
 4056             ;;
 4057         esac
 4058     done
 4059     deplibs="$tmp_deplibs"
 4060 
 4061     if test -n "$convenience"; then
 4062       if test -n "$whole_archive_flag_spec"; then
 4063         save_libobjs=$libobjs
 4064         eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 4065       else
 4066         gentop="$output_objdir/${outputname}x"
 4067         generated="$generated $gentop"
 4068 
 4069         func_extract_archives $gentop $convenience
 4070         libobjs="$libobjs $func_extract_archives_result"
 4071       fi
 4072     fi
 4073     
 4074     if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
 4075       eval flag=\"$thread_safe_flag_spec\"
 4076       linker_flags="$linker_flags $flag"
 4077     fi
 4078 
 4079     # Make a backup of the uninstalled library when relinking
 4080     if test "$mode" = relink; then
 4081       $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
 4082     fi
 4083 
 4084     # Do each of the archive commands.
 4085     if test "$module" = yes && test -n "$module_cmds" ; then
 4086       if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
 4087         eval test_cmds=\"$module_expsym_cmds\"
 4088         cmds=$module_expsym_cmds
 4089       else
 4090         eval test_cmds=\"$module_cmds\"
 4091         cmds=$module_cmds
 4092       fi
 4093     else
 4094     if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
 4095       eval test_cmds=\"$archive_expsym_cmds\"
 4096       cmds=$archive_expsym_cmds
 4097     else
 4098       eval test_cmds=\"$archive_cmds\"
 4099       cmds=$archive_cmds
 4100       fi
 4101     fi
 4102 
 4103     if test "X$skipped_export" != "X:" &&
 4104        len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
 4105        test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 4106       :
 4107     else
 4108       # The command line is too long to link in one step, link piecewise.
 4109       $echo "creating reloadable object files..."
 4110 
 4111       # Save the value of $output and $libobjs because we want to
 4112       # use them later.  If we have whole_archive_flag_spec, we
 4113       # want to use save_libobjs as it was before
 4114       # whole_archive_flag_spec was expanded, because we can't
 4115       # assume the linker understands whole_archive_flag_spec.
 4116       # This may have to be revisited, in case too many
 4117       # convenience libraries get linked in and end up exceeding
 4118       # the spec.
 4119       if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
 4120         save_libobjs=$libobjs
 4121       fi
 4122       save_output=$output
 4123       output_la=`$echo "X$output" | $Xsed -e "$basename"`
 4124 
 4125       # Clear the reloadable object creation command queue and
 4126       # initialize k to one.
 4127       test_cmds=
 4128       concat_cmds=
 4129       objlist=
 4130       delfiles=
 4131       last_robj=
 4132       k=1
 4133       output=$output_objdir/$output_la-${k}.$objext
 4134       # Loop over the list of objects to be linked.
 4135       for obj in $save_libobjs
 4136       do
 4137         eval test_cmds=\"$reload_cmds $objlist $last_robj\"
 4138         if test "X$objlist" = X ||
 4139            { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
 4140          test "$len" -le "$max_cmd_len"; }; then
 4141           objlist="$objlist $obj"
 4142         else
 4143           # The command $test_cmds is almost too long, add a
 4144           # command to the queue.
 4145           if test "$k" -eq 1 ; then
 4146         # The first file doesn't have a previous command to add.
 4147         eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
 4148           else
 4149         # All subsequent reloadable object files will link in
 4150         # the last one created.
 4151         eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
 4152           fi
 4153           last_robj=$output_objdir/$output_la-${k}.$objext
 4154           k=`expr $k + 1`
 4155           output=$output_objdir/$output_la-${k}.$objext
 4156           objlist=$obj
 4157           len=1
 4158         fi
 4159       done
 4160       # Handle the remaining objects by creating one last
 4161       # reloadable object file.  All subsequent reloadable object
 4162       # files will link in the last one created.
 4163       test -z "$concat_cmds" || concat_cmds=$concat_cmds~
 4164       eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
 4165 
 4166       if ${skipped_export-false}; then
 4167         $show "generating symbol list for \`$libname.la'"
 4168         export_symbols="$output_objdir/$libname.exp"
 4169         $run $rm $export_symbols
 4170         libobjs=$output
 4171         # Append the command to create the export file.
 4172         eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
 4173           fi
 4174 
 4175       # Set up a command to remove the reloadable object files
 4176       # after they are used.
 4177       i=0
 4178       while test "$i" -lt "$k"
 4179       do
 4180         i=`expr $i + 1`
 4181         delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
 4182       done
 4183 
 4184       $echo "creating a temporary reloadable object file: $output"
 4185 
 4186       # Loop through the commands generated above and execute them.
 4187       save_ifs="$IFS"; IFS='~'
 4188       for cmd in $concat_cmds; do
 4189         IFS="$save_ifs"
 4190         $show "$cmd"
 4191         $run eval "$cmd" || exit $?
 4192       done
 4193       IFS="$save_ifs"
 4194 
 4195       libobjs=$output
 4196       # Restore the value of output.
 4197       output=$save_output
 4198 
 4199       if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
 4200         eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 4201       fi
 4202       # Expand the library linking commands again to reset the
 4203       # value of $libobjs for piecewise linking.
 4204 
 4205       # Do each of the archive commands.
 4206       if test "$module" = yes && test -n "$module_cmds" ; then
 4207         if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
 4208           cmds=$module_expsym_cmds
 4209         else
 4210           cmds=$module_cmds
 4211         fi
 4212       else
 4213       if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
 4214         cmds=$archive_expsym_cmds
 4215       else
 4216         cmds=$archive_cmds
 4217         fi
 4218       fi
 4219 
 4220       # Append the command to remove the reloadable object files
 4221       # to the just-reset $cmds.
 4222       eval cmds=\"\$cmds~\$rm $delfiles\"
 4223     fi
 4224     save_ifs="$IFS"; IFS='~'
 4225     for cmd in $cmds; do
 4226       IFS="$save_ifs"
 4227       eval cmd=\"$cmd\"
 4228       $show "$cmd"
 4229       $run eval "$cmd" || {
 4230         lt_exit=$?
 4231 
 4232         # Restore the uninstalled library and exit
 4233         if test "$mode" = relink; then
 4234           $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
 4235         fi
 4236 
 4237         exit $lt_exit
 4238       }
 4239     done
 4240     IFS="$save_ifs"
 4241 
 4242     # Restore the uninstalled library and exit
 4243     if test "$mode" = relink; then
 4244       $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
 4245 
 4246       if test -n "$convenience"; then
 4247         if test -z "$whole_archive_flag_spec"; then
 4248           $show "${rm}r $gentop"
 4249           $run ${rm}r "$gentop"
 4250         fi
 4251       fi
 4252 
 4253       exit $EXIT_SUCCESS
 4254     fi
 4255 
 4256     # Create links to the real library.
 4257     for linkname in $linknames; do
 4258       if test "$realname" != "$linkname"; then
 4259         $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
 4260         $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
 4261       fi
 4262     done
 4263 
 4264     # If -module or -export-dynamic was specified, set the dlname.
 4265     if test "$module" = yes || test "$export_dynamic" = yes; then
 4266       # On all known operating systems, these are identical.
 4267       dlname="$soname"
 4268     fi
 4269       fi
 4270       ;;
 4271 
 4272     obj)
 4273       case " $deplibs" in
 4274       *\ -l* | *\ -L*)
 4275     $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2 ;;
 4276       esac
 4277 
 4278       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
 4279     $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
 4280       fi
 4281 
 4282       if test -n "$rpath"; then
 4283     $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
 4284       fi
 4285 
 4286       if test -n "$xrpath"; then
 4287     $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
 4288       fi
 4289 
 4290       if test -n "$vinfo"; then
 4291     $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
 4292       fi
 4293 
 4294       if test -n "$release"; then
 4295     $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
 4296       fi
 4297 
 4298       case $output in
 4299       *.lo)
 4300     if test -n "$objs$old_deplibs"; then
 4301       $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
 4302       exit $EXIT_FAILURE
 4303     fi
 4304     libobj="$output"
 4305     obj=`$echo "X$output" | $Xsed -e "$lo2o"`
 4306     ;;
 4307       *)
 4308     libobj=
 4309     obj="$output"
 4310     ;;
 4311       esac
 4312 
 4313       # Delete the old objects.
 4314       $run $rm $obj $libobj
 4315 
 4316       # Objects from convenience libraries.  This assumes
 4317       # single-version convenience libraries.  Whenever we create
 4318       # different ones for PIC/non-PIC, this we'll have to duplicate
 4319       # the extraction.
 4320       reload_conv_objs=
 4321       gentop=
 4322       # reload_cmds runs $LD directly, so let us get rid of
 4323       # -Wl from whole_archive_flag_spec and hope we can get by with
 4324       # turning comma into space..
 4325       wl=
 4326 
 4327       if test -n "$convenience"; then
 4328     if test -n "$whole_archive_flag_spec"; then
 4329       eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
 4330       reload_conv_objs=$reload_objs\ `$echo "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
 4331     else
 4332       gentop="$output_objdir/${obj}x"
 4333       generated="$generated $gentop"
 4334 
 4335       func_extract_archives $gentop $convenience
 4336       reload_conv_objs="$reload_objs $func_extract_archives_result"
 4337     fi
 4338       fi
 4339 
 4340       # Create the old-style object.
 4341       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
 4342 
 4343       output="$obj"
 4344       cmds=$reload_cmds
 4345       save_ifs="$IFS"; IFS='~'
 4346       for cmd in $cmds; do
 4347     IFS="$save_ifs"
 4348     eval cmd=\"$cmd\"
 4349     $show "$cmd"
 4350     $run eval "$cmd" || exit $?
 4351       done
 4352       IFS="$save_ifs"
 4353 
 4354       # Exit if we aren't doing a library object file.
 4355       if test -z "$libobj"; then
 4356     if test -n "$gentop"; then
 4357       $show "${rm}r $gentop"
 4358       $run ${rm}r $gentop
 4359     fi
 4360 
 4361     exit $EXIT_SUCCESS
 4362       fi
 4363 
 4364       if test "$build_libtool_libs" != yes; then
 4365     if test -n "$gentop"; then
 4366       $show "${rm}r $gentop"
 4367       $run ${rm}r $gentop
 4368     fi
 4369 
 4370     # Create an invalid libtool object if no PIC, so that we don't
 4371     # accidentally link it into a program.
 4372     # $show "echo timestamp > $libobj"
 4373     # $run eval "echo timestamp > $libobj" || exit $?
 4374     exit $EXIT_SUCCESS
 4375       fi
 4376 
 4377       if test -n "$pic_flag" || test "$pic_mode" != default; then
 4378     # Only do commands if we really have different PIC objects.
 4379     reload_objs="$libobjs $reload_conv_objs"
 4380     output="$libobj"
 4381     cmds=$reload_cmds
 4382     save_ifs="$IFS"; IFS='~'
 4383     for cmd in $cmds; do
 4384       IFS="$save_ifs"
 4385       eval cmd=\"$cmd\"
 4386       $show "$cmd"
 4387       $run eval "$cmd" || exit $?
 4388     done
 4389     IFS="$save_ifs"
 4390       fi
 4391 
 4392       if test -n "$gentop"; then
 4393     $show "${rm}r $gentop"
 4394     $run ${rm}r $gentop
 4395       fi
 4396 
 4397       exit $EXIT_SUCCESS
 4398       ;;
 4399 
 4400     prog)
 4401       case $host in
 4402     *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
 4403       esac
 4404       if test -n "$vinfo"; then
 4405     $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
 4406       fi
 4407 
 4408       if test -n "$release"; then
 4409     $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
 4410       fi
 4411 
 4412       if test "$preload" = yes; then
 4413     if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
 4414        test "$dlopen_self_static" = unknown; then
 4415       $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
 4416     fi
 4417       fi
 4418 
 4419       case $host in
 4420       *-*-rhapsody* | *-*-darwin1.[012])
 4421     # On Rhapsody replace the C library is the System framework
 4422     compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
 4423     finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
 4424     ;;
 4425       esac
 4426 
 4427       case $host in
 4428       *darwin*)
 4429         # Don't allow lazy linking, it breaks C++ global constructors
 4430         if test "$tagname" = CXX ; then
 4431         compile_command="$compile_command ${wl}-bind_at_load"
 4432         finalize_command="$finalize_command ${wl}-bind_at_load"
 4433         fi
 4434         ;;
 4435       esac
 4436 
 4437 
 4438       # move library search paths that coincide with paths to not yet
 4439       # installed libraries to the beginning of the library search list
 4440       new_libs=
 4441       for path in $notinst_path; do
 4442     case " $new_libs " in
 4443     *" -L$path/$objdir "*) ;;
 4444     *)
 4445       case " $compile_deplibs " in
 4446       *" -L$path/$objdir "*)
 4447         new_libs="$new_libs -L$path/$objdir" ;;
 4448       esac
 4449       ;;
 4450     esac
 4451       done
 4452       for deplib in $compile_deplibs; do
 4453     case $deplib in
 4454     -L*)
 4455       case " $new_libs " in
 4456       *" $deplib "*) ;;
 4457       *) new_libs="$new_libs $deplib" ;;
 4458       esac
 4459       ;;
 4460     *) new_libs="$new_libs $deplib" ;;
 4461     esac
 4462       done
 4463       compile_deplibs="$new_libs"
 4464 
 4465 
 4466       compile_command="$compile_command $compile_deplibs"
 4467       finalize_command="$finalize_command $finalize_deplibs"
 4468 
 4469       if test -n "$rpath$xrpath"; then
 4470     # If the user specified any rpath flags, then add them.
 4471     for libdir in $rpath $xrpath; do
 4472       # This is the magic to use -rpath.
 4473       case "$finalize_rpath " in
 4474       *" $libdir "*) ;;
 4475       *) finalize_rpath="$finalize_rpath $libdir" ;;
 4476       esac
 4477     done
 4478       fi
 4479 
 4480       # Now hardcode the library paths
 4481       rpath=
 4482       hardcode_libdirs=
 4483       for libdir in $compile_rpath $finalize_rpath; do
 4484     if test -n "$hardcode_libdir_flag_spec"; then
 4485       if test -n "$hardcode_libdir_separator"; then
 4486         if test -z "$hardcode_libdirs"; then
 4487           hardcode_libdirs="$libdir"
 4488         else
 4489           # Just accumulate the unique libdirs.
 4490           case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
 4491           *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 4492         ;;
 4493           *)
 4494         hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 4495         ;;
 4496           esac
 4497         fi
 4498       else
 4499         eval flag=\"$hardcode_libdir_flag_spec\"
 4500         rpath="$rpath $flag"
 4501       fi
 4502     elif test -n "$runpath_var"; then
 4503       case "$perm_rpath " in
 4504       *" $libdir "*) ;;
 4505       *) perm_rpath="$perm_rpath $libdir" ;;
 4506       esac
 4507     fi
 4508     case $host in
 4509     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 4510       testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
 4511       case :$dllsearchpath: in
 4512       *":$libdir:"*) ;;
 4513       *) dllsearchpath="$dllsearchpath:$libdir";;
 4514       esac
 4515       case :$dllsearchpath: in
 4516       *":$testbindir:"*) ;;
 4517       *) dllsearchpath="$dllsearchpath:$testbindir";;
 4518       esac
 4519       ;;
 4520     esac
 4521       done
 4522       # Substitute the hardcoded libdirs into the rpath.
 4523       if test -n "$hardcode_libdir_separator" &&
 4524      test -n "$hardcode_libdirs"; then
 4525     libdir="$hardcode_libdirs"
 4526     eval rpath=\" $hardcode_libdir_flag_spec\"
 4527       fi
 4528       compile_rpath="$rpath"
 4529 
 4530       rpath=
 4531       hardcode_libdirs=
 4532       for libdir in $finalize_rpath; do
 4533     if test -n "$hardcode_libdir_flag_spec"; then
 4534       if test -n "$hardcode_libdir_separator"; then
 4535         if test -z "$hardcode_libdirs"; then
 4536           hardcode_libdirs="$libdir"
 4537         else
 4538           # Just accumulate the unique libdirs.
 4539           case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
 4540           *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 4541         ;;
 4542           *)
 4543         hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 4544         ;;
 4545           esac
 4546         fi
 4547       else
 4548         eval flag=\"$hardcode_libdir_flag_spec\"
 4549         rpath="$rpath $flag"
 4550       fi
 4551     elif test -n "$runpath_var"; then
 4552       case "$finalize_perm_rpath " in
 4553       *" $libdir "*) ;;
 4554       *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
 4555       esac
 4556     fi
 4557       done
 4558       # Substitute the hardcoded libdirs into the rpath.
 4559       if test -n "$hardcode_libdir_separator" &&
 4560      test -n "$hardcode_libdirs"; then
 4561     libdir="$hardcode_libdirs"
 4562     eval rpath=\" $hardcode_libdir_flag_spec\"
 4563       fi
 4564       finalize_rpath="$rpath"
 4565 
 4566       if test -n "$libobjs" && test "$build_old_libs" = yes; then
 4567     # Transform all the library objects into standard objects.
 4568     compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 4569     finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 4570       fi
 4571 
 4572       dlsyms=
 4573       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
 4574     if test -n "$NM" && test -n "$global_symbol_pipe"; then
 4575       dlsyms="${outputname}S.c"
 4576     else
 4577       $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
 4578     fi
 4579       fi
 4580 
 4581       if test -n "$dlsyms"; then
 4582     case $dlsyms in
 4583     "") ;;
 4584     *.c)
 4585       # Discover the nlist of each of the dlfiles.
 4586       nlist="$output_objdir/${outputname}.nm"
 4587 
 4588       $show "$rm $nlist ${nlist}S ${nlist}T"
 4589       $run $rm "$nlist" "${nlist}S" "${nlist}T"
 4590 
 4591       # Parse the name list into a source file.
 4592       $show "creating $output_objdir/$dlsyms"
 4593 
 4594       test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
 4595 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
 4596 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
 4597 
 4598 #ifdef __cplusplus
 4599 extern \"C\" {
 4600 #endif
 4601 
 4602 /* Prevent the only kind of declaration conflicts we can make. */
 4603 #define lt_preloaded_symbols some_other_symbol
 4604 
 4605 /* External symbol declarations for the compiler. */\
 4606 "
 4607 
 4608       if test "$dlself" = yes; then
 4609         $show "generating symbol list for \`$output'"
 4610 
 4611         test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
 4612 
 4613         # Add our own program objects to the symbol list.
 4614         progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 4615         for arg in $progfiles; do
 4616           $show "extracting global C symbols from \`$arg'"
 4617           $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
 4618         done
 4619 
 4620         if test -n "$exclude_expsyms"; then
 4621           $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
 4622           $run eval '$mv "$nlist"T "$nlist"'
 4623         fi
 4624 
 4625         if test -n "$export_symbols_regex"; then
 4626           $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
 4627           $run eval '$mv "$nlist"T "$nlist"'
 4628         fi
 4629 
 4630         # Prepare the list of exported symbols
 4631         if test -z "$export_symbols"; then
 4632           export_symbols="$output_objdir/$outputname.exp"
 4633           $run $rm $export_symbols
 4634           $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
 4635               case $host in
 4636               *cygwin* | *mingw* )
 4637             $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
 4638         $run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
 4639                 ;;
 4640               esac
 4641         else
 4642           $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
 4643           $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
 4644           $run eval 'mv "$nlist"T "$nlist"'
 4645               case $host in
 4646               *cygwin* | *mingw* )
 4647             $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
 4648         $run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
 4649                 ;;
 4650               esac
 4651         fi
 4652       fi
 4653 
 4654       for arg in $dlprefiles; do
 4655         $show "extracting global C symbols from \`$arg'"
 4656         name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
 4657         $run eval '$echo ": $name " >> "$nlist"'
 4658         $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
 4659       done
 4660 
 4661       if test -z "$run"; then
 4662         # Make sure we have at least an empty file.
 4663         test -f "$nlist" || : > "$nlist"
 4664 
 4665         if test -n "$exclude_expsyms"; then
 4666           $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
 4667           $mv "$nlist"T "$nlist"
 4668         fi
 4669 
 4670         # Try sorting and uniquifying the output.
 4671         if grep -v "^: " < "$nlist" |
 4672         if sort -k 3 </dev/null >/dev/null 2>&1; then
 4673           sort -k 3
 4674         else
 4675           sort +2
 4676         fi |
 4677         uniq > "$nlist"S; then
 4678           :
 4679         else
 4680           grep -v "^: " < "$nlist" > "$nlist"S
 4681         fi
 4682 
 4683         if test -f "$nlist"S; then
 4684           eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
 4685         else
 4686           $echo '/* NONE */' >> "$output_objdir/$dlsyms"
 4687         fi
 4688 
 4689         $echo >> "$output_objdir/$dlsyms" "\
 4690 
 4691 #undef lt_preloaded_symbols
 4692 
 4693 #if defined (__STDC__) && __STDC__
 4694 # define lt_ptr void *
 4695 #else
 4696 # define lt_ptr char *
 4697 # define const
 4698 #endif
 4699 
 4700 /* The mapping between symbol names and symbols. */
 4701 "
 4702 
 4703         case $host in
 4704         *cygwin* | *mingw* )
 4705       $echo >> "$output_objdir/$dlsyms" "\
 4706 /* DATA imports from DLLs on WIN32 can't be const, because
 4707    runtime relocations are performed -- see ld's documentation
 4708    on pseudo-relocs */
 4709 struct {
 4710 "
 4711           ;;
 4712         * )
 4713       $echo >> "$output_objdir/$dlsyms" "\
 4714 const struct {
 4715 "
 4716           ;;
 4717         esac
 4718 
 4719 
 4720       $echo >> "$output_objdir/$dlsyms" "\
 4721   const char *name;
 4722   lt_ptr address;
 4723 }
 4724 lt_preloaded_symbols[] =
 4725 {\
 4726 "
 4727 
 4728         eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
 4729 
 4730         $echo >> "$output_objdir/$dlsyms" "\
 4731   {0, (lt_ptr) 0}
 4732 };
 4733 
 4734 /* This works around a problem in FreeBSD linker */
 4735 #ifdef FREEBSD_WORKAROUND
 4736 static const void *lt_preloaded_setup() {
 4737   return lt_preloaded_symbols;
 4738 }
 4739 #endif
 4740 
 4741 #ifdef __cplusplus
 4742 }
 4743 #endif\
 4744 "
 4745       fi
 4746 
 4747       pic_flag_for_symtable=
 4748       case $host in
 4749       # compiling the symbol table file with pic_flag works around
 4750       # a FreeBSD bug that causes programs to crash when -lm is
 4751       # linked before any other PIC object.  But we must not use
 4752       # pic_flag when linking with -static.  The problem exists in
 4753       # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
 4754       *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
 4755         case "$compile_command " in
 4756         *" -static "*) ;;
 4757         *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
 4758         esac;;
 4759       *-*-hpux*)
 4760         case "$compile_command " in
 4761         *" -static "*) ;;
 4762         *) pic_flag_for_symtable=" $pic_flag";;
 4763         esac
 4764       esac
 4765 
 4766       # Now compile the dynamic symbol file.
 4767       $show "(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
 4768       $run eval '(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
 4769 
 4770       # Clean up the generated files.
 4771       $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
 4772       $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
 4773 
 4774       # Transform the symbol file into the correct name.
 4775           case $host in
 4776           *cygwin* | *mingw* )
 4777             if test -f "$output_objdir/${outputname}.def" ; then
 4778               compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4779               finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4780             else
 4781               compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4782               finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4783              fi
 4784             ;;
 4785           * )
 4786             compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4787             finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4788             ;;
 4789           esac
 4790       ;;
 4791     *)
 4792       $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
 4793       exit $EXIT_FAILURE
 4794       ;;
 4795     esac
 4796       else
 4797     # We keep going just in case the user didn't refer to
 4798     # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
 4799     # really was required.
 4800 
 4801     # Nullify the symbol file.
 4802     compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
 4803     finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
 4804       fi
 4805 
 4806       if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
 4807     # Replace the output file specification.
 4808     compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$output"'%g' | $NL2SP`
 4809     link_command="$compile_command$compile_rpath"
 4810 
 4811     # We have no uninstalled library dependencies, so finalize right now.
 4812     $show "$link_command"
 4813     $run eval "$link_command"
 4814     exit_status=$?
 4815 
 4816     # Delete the generated files.
 4817     if test -n "$dlsyms"; then
 4818       $show "$rm $output_objdir/${outputname}S.${objext}"
 4819       $run $rm "$output_objdir/${outputname}S.${objext}"
 4820     fi
 4821 
 4822     exit $exit_status
 4823       fi
 4824 
 4825       if test -n "$shlibpath_var"; then
 4826     # We should set the shlibpath_var
 4827     rpath=
 4828     for dir in $temp_rpath; do
 4829       case $dir in
 4830       [\\/]* | [A-Za-z]:[\\/]*)
 4831         # Absolute path.
 4832         rpath="$rpath$dir:"
 4833         ;;
 4834       *)
 4835         # Relative path: add a thisdir entry.
 4836         rpath="$rpath\$thisdir/$dir:"
 4837         ;;
 4838       esac
 4839     done
 4840     temp_rpath="$rpath"
 4841       fi
 4842 
 4843       if test -n "$compile_shlibpath$finalize_shlibpath"; then
 4844     compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
 4845       fi
 4846       if test -n "$finalize_shlibpath"; then
 4847     finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
 4848       fi
 4849 
 4850       compile_var=
 4851       finalize_var=
 4852       if test -n "$runpath_var"; then
 4853     if test -n "$perm_rpath"; then
 4854       # We should set the runpath_var.
 4855       rpath=
 4856       for dir in $perm_rpath; do
 4857         rpath="$rpath$dir:"
 4858       done
 4859       compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
 4860     fi
 4861     if test -n "$finalize_perm_rpath"; then
 4862       # We should set the runpath_var.
 4863       rpath=
 4864       for dir in $finalize_perm_rpath; do
 4865         rpath="$rpath$dir:"
 4866       done
 4867       finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
 4868     fi
 4869       fi
 4870 
 4871       if test "$no_install" = yes; then
 4872     # We don't need to create a wrapper script.
 4873     link_command="$compile_var$compile_command$compile_rpath"
 4874     # Replace the output file specification.
 4875     link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
 4876     # Delete the old output file.
 4877     $run $rm $output
 4878     # Link the executable and exit
 4879     $show "$link_command"
 4880     $run eval "$link_command" || exit $?
 4881     exit $EXIT_SUCCESS
 4882       fi
 4883 
 4884       if test "$hardcode_action" = relink; then
 4885     # Fast installation is not supported
 4886     link_command="$compile_var$compile_command$compile_rpath"
 4887     relink_command="$finalize_var$finalize_command$finalize_rpath"
 4888 
 4889     $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
 4890     $echo "$modename: \`$output' will be relinked during installation" 1>&2
 4891       else
 4892     if test "$fast_install" != no; then
 4893       link_command="$finalize_var$compile_command$finalize_rpath"
 4894       if test "$fast_install" = yes; then
 4895         relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $SP2NL | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g' | $NL2SP`
 4896       else
 4897         # fast_install is set to needless
 4898         relink_command=
 4899       fi
 4900     else
 4901       link_command="$compile_var$compile_command$compile_rpath"
 4902       relink_command="$finalize_var$finalize_command$finalize_rpath"
 4903     fi
 4904       fi
 4905 
 4906       # Replace the output file specification.
 4907       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
 4908 
 4909       # Delete the old output files.
 4910       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
 4911 
 4912       $show "$link_command"
 4913       $run eval "$link_command" || exit $?
 4914 
 4915       # Now create the wrapper script.
 4916       $show "creating $output"
 4917 
 4918       # Quote the relink command for shipping.
 4919       if test -n "$relink_command"; then
 4920     # Preserve any variables that may affect compiler behavior
 4921     for var in $variables_saved_for_relink; do
 4922       if eval test -z \"\${$var+set}\"; then
 4923         relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
 4924       elif eval var_value=\$$var; test -z "$var_value"; then
 4925         relink_command="$var=; export $var; $relink_command"
 4926       else
 4927         var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
 4928         relink_command="$var=\"$var_value\"; export $var; $relink_command"
 4929       fi
 4930     done
 4931     relink_command="(cd `pwd`; $relink_command)"
 4932     relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
 4933       fi
 4934 
 4935       # Quote $echo for shipping.
 4936       if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
 4937     case $progpath in
 4938     [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
 4939     *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
 4940     esac
 4941     qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
 4942       else
 4943     qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
 4944       fi
 4945 
 4946       # Only actually do things if our run command is non-null.
 4947       if test -z "$run"; then
 4948     # win32 will think the script is a binary if it has
 4949     # a .exe suffix, so we strip it off here.
 4950     case $output in
 4951       *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
 4952     esac
 4953     # test for cygwin because mv fails w/o .exe extensions
 4954     case $host in
 4955       *cygwin*)
 4956         exeext=.exe
 4957         outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
 4958       *) exeext= ;;
 4959     esac
 4960     case $host in
 4961       *cygwin* | *mingw* )
 4962             output_name=`basename $output`
 4963             output_path=`dirname $output`
 4964             cwrappersource="$output_path/$objdir/lt-$output_name.c"
 4965             cwrapper="$output_path/$output_name.exe"
 4966             $rm $cwrappersource $cwrapper
 4967             trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
 4968 
 4969         cat > $cwrappersource <<EOF
 4970 
 4971 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
 4972    Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 4973 
 4974    The $output program cannot be directly executed until all the libtool
 4975    libraries that it depends on are installed.
 4976 
 4977    This wrapper executable should never be moved out of the build directory.
 4978    If it is, it will not operate correctly.
 4979 
 4980    Currently, it simply execs the wrapper *script* "/bin/sh $output",
 4981    but could eventually absorb all of the scripts functionality and
 4982    exec $objdir/$outputname directly.
 4983 */
 4984 EOF
 4985         cat >> $cwrappersource<<"EOF"
 4986 #include <stdio.h>
 4987 #include <stdlib.h>
 4988 #include <unistd.h>
 4989 #include <malloc.h>
 4990 #include <stdarg.h>
 4991 #include <assert.h>
 4992 #include <string.h>
 4993 #include <ctype.h>
 4994 #include <sys/stat.h>
 4995 
 4996 #if defined(PATH_MAX)
 4997 # define LT_PATHMAX PATH_MAX
 4998 #elif defined(MAXPATHLEN)
 4999 # define LT_PATHMAX MAXPATHLEN
 5000 #else
 5001 # define LT_PATHMAX 1024
 5002 #endif
 5003 
 5004 #ifndef DIR_SEPARATOR
 5005 # define DIR_SEPARATOR '/'
 5006 # define PATH_SEPARATOR ':'
 5007 #endif
 5008 
 5009 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
 5010   defined (__OS2__)
 5011 # define HAVE_DOS_BASED_FILE_SYSTEM
 5012 # ifndef DIR_SEPARATOR_2
 5013 #  define DIR_SEPARATOR_2 '\\'
 5014 # endif
 5015 # ifndef PATH_SEPARATOR_2
 5016 #  define PATH_SEPARATOR_2 ';'
 5017 # endif
 5018 #endif
 5019 
 5020 #ifndef DIR_SEPARATOR_2
 5021 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
 5022 #else /* DIR_SEPARATOR_2 */
 5023 # define IS_DIR_SEPARATOR(ch) \
 5024         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
 5025 #endif /* DIR_SEPARATOR_2 */
 5026 
 5027 #ifndef PATH_SEPARATOR_2
 5028 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
 5029 #else /* PATH_SEPARATOR_2 */
 5030 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
 5031 #endif /* PATH_SEPARATOR_2 */
 5032 
 5033 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
 5034 #define XFREE(stale) do { \
 5035   if (stale) { free ((void *) stale); stale = 0; } \
 5036 } while (0)
 5037 
 5038 /* -DDEBUG is fairly common in CFLAGS.  */
 5039 #undef DEBUG
 5040 #if defined DEBUGWRAPPER
 5041 # define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
 5042 #else
 5043 # define DEBUG(format, ...)
 5044 #endif
 5045 
 5046 const char *program_name = NULL;
 5047 
 5048 void * xmalloc (size_t num);
 5049 char * xstrdup (const char *string);
 5050 const char * base_name (const char *name);
 5051 char * find_executable(const char *wrapper);
 5052 int    check_executable(const char *path);
 5053 char * strendzap(char *str, const char *pat);
 5054 void lt_fatal (const char *message, ...);
 5055 
 5056 int
 5057 main (int argc, char *argv[])
 5058 {
 5059   char **newargz;
 5060   int i;
 5061 
 5062   program_name = (char *) xstrdup (base_name (argv[0]));
 5063   DEBUG("(main) argv[0]      : %s\n",argv[0]);
 5064   DEBUG("(main) program_name : %s\n",program_name);
 5065   newargz = XMALLOC(char *, argc+2);
 5066 EOF
 5067 
 5068             cat >> $cwrappersource <<EOF
 5069   newargz[0] = (char *) xstrdup("$SHELL");
 5070 EOF
 5071 
 5072             cat >> $cwrappersource <<"EOF"
 5073   newargz[1] = find_executable(argv[0]);
 5074   if (newargz[1] == NULL)
 5075     lt_fatal("Couldn't find %s", argv[0]);
 5076   DEBUG("(main) found exe at : %s\n",newargz[1]);
 5077   /* we know the script has the same name, without the .exe */
 5078   /* so make sure newargz[1] doesn't end in .exe */
 5079   strendzap(newargz[1],".exe");
 5080   for (i = 1; i < argc; i++)
 5081     newargz[i+1] = xstrdup(argv[i]);
 5082   newargz[argc+1] = NULL;
 5083 
 5084   for (i=0; i<argc+1; i++)
 5085   {
 5086     DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
 5087     ;
 5088   }
 5089 
 5090 EOF
 5091 
 5092             case $host_os in
 5093               mingw*)
 5094                 cat >> $cwrappersource <<EOF
 5095   execv("$SHELL",(char const **)newargz);
 5096 EOF
 5097               ;;
 5098               *)
 5099                 cat >> $cwrappersource <<EOF
 5100   execv("$SHELL",newargz);
 5101 EOF
 5102               ;;
 5103             esac
 5104 
 5105             cat >> $cwrappersource <<"EOF"
 5106   return 127;
 5107 }
 5108 
 5109 void *
 5110 xmalloc (size_t num)
 5111 {
 5112   void * p = (void *) malloc (num);
 5113   if (!p)
 5114     lt_fatal ("Memory exhausted");
 5115 
 5116   return p;
 5117 }
 5118 
 5119 char *
 5120 xstrdup (const char *string)
 5121 {
 5122   return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
 5123 ;
 5124 }
 5125 
 5126 const char *
 5127 base_name (const char *name)
 5128 {
 5129   const char *base;
 5130 
 5131 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 5132   /* Skip over the disk name in MSDOS pathnames. */
 5133   if (isalpha ((unsigned char)name[0]) && name[1] == ':')
 5134     name += 2;
 5135 #endif
 5136 
 5137   for (base = name; *name; name++)
 5138     if (IS_DIR_SEPARATOR (*name))
 5139       base = name + 1;
 5140   return base;
 5141 }
 5142 
 5143 int
 5144 check_executable(const char * path)
 5145 {
 5146   struct stat st;
 5147 
 5148   DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
 5149   if ((!path) || (!*path))
 5150     return 0;
 5151 
 5152   if ((stat (path, &st) >= 0) &&
 5153       (
 5154         /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
 5155 #if defined (S_IXOTH)
 5156        ((st.st_mode & S_IXOTH) == S_IXOTH) ||
 5157 #endif
 5158 #if defined (S_IXGRP)
 5159        ((st.st_mode & S_IXGRP) == S_IXGRP) ||
 5160 #endif
 5161        ((st.st_mode & S_IXUSR) == S_IXUSR))
 5162       )
 5163     return 1;
 5164   else
 5165     return 0;
 5166 }
 5167 
 5168 /* Searches for the full path of the wrapper.  Returns
 5169    newly allocated full path name if found, NULL otherwise */
 5170 char *
 5171 find_executable (const char* wrapper)
 5172 {
 5173   int has_slash = 0;
 5174   const char* p;
 5175   const char* p_next;
 5176   /* static buffer for getcwd */
 5177   char tmp[LT_PATHMAX + 1];
 5178   int tmp_len;
 5179   char* concat_name;
 5180 
 5181   DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
 5182 
 5183   if ((wrapper == NULL) || (*wrapper == '\0'))
 5184     return NULL;
 5185 
 5186   /* Absolute path? */
 5187 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 5188   if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
 5189   {
 5190     concat_name = xstrdup (wrapper);
 5191     if (check_executable(concat_name))
 5192       return concat_name;
 5193     XFREE(concat_name);
 5194   }
 5195   else
 5196   {
 5197 #endif
 5198     if (IS_DIR_SEPARATOR (wrapper[0]))
 5199     {
 5200       concat_name = xstrdup (wrapper);
 5201       if (check_executable(concat_name))
 5202         return concat_name;
 5203       XFREE(concat_name);
 5204     }
 5205 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 5206   }
 5207 #endif
 5208 
 5209   for (p = wrapper; *p; p++)
 5210     if (*p == '/')
 5211     {
 5212       has_slash = 1;
 5213       break;
 5214     }
 5215   if (!has_slash)
 5216   {
 5217     /* no slashes; search PATH */
 5218     const char* path = getenv ("PATH");
 5219     if (path != NULL)
 5220     {
 5221       for (p = path; *p; p = p_next)
 5222       {
 5223         const char* q;
 5224         size_t p_len;
 5225         for (q = p; *q; q++)
 5226           if (IS_PATH_SEPARATOR(*q))
 5227             break;
 5228         p_len = q - p;
 5229         p_next = (*q == '\0' ? q : q + 1);
 5230         if (p_len == 0)
 5231         {
 5232           /* empty path: current directory */
 5233           if (getcwd (tmp, LT_PATHMAX) == NULL)
 5234             lt_fatal ("getcwd failed");
 5235           tmp_len = strlen(tmp);
 5236           concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
 5237           memcpy (concat_name, tmp, tmp_len);
 5238           concat_name[tmp_len] = '/';
 5239           strcpy (concat_name + tmp_len + 1, wrapper);
 5240         }
 5241         else
 5242         {
 5243           concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
 5244           memcpy (concat_name, p, p_len);
 5245           concat_name[p_len] = '/';
 5246           strcpy (concat_name + p_len + 1, wrapper);
 5247