"Fossies" - the Fresh Open Source Software Archive

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