"Fossies" - the Fresh Open Source Software Archive

Member "devtodo-0.1.20/ltmain.sh" (26 Jun 2007, 198965 Bytes) of package /linux/privat/old/devtodo-0.1.20.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
   47 TIMESTAMP=" (1.1220.2.455 2007/06/24 02:13:29)"
   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) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
 2126     esac
 2127       fi
 2128       if test "$pass" = dlopen; then
 2129     # Collect dlpreopened libraries
 2130     save_deplibs="$deplibs"
 2131     deplibs=
 2132       fi
 2133       for deplib in $libs; do
 2134     lib=
 2135     found=no
 2136     case $deplib in
 2137     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
 2138       if test "$linkmode,$pass" = "prog,link"; then
 2139         compile_deplibs="$deplib $compile_deplibs"
 2140         finalize_deplibs="$deplib $finalize_deplibs"
 2141       else
 2142         compiler_flags="$compiler_flags $deplib"
 2143       fi
 2144       continue
 2145       ;;
 2146     -l*)
 2147       if test "$linkmode" != lib && test "$linkmode" != prog; then
 2148         $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
 2149         continue
 2150       fi
 2151       name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
 2152       for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
 2153         for search_ext in .la $std_shrext .so .a; do
 2154           # Search the libtool library
 2155           lib="$searchdir/lib${name}${search_ext}"
 2156           if test -f "$lib"; then
 2157         if test "$search_ext" = ".la"; then
 2158           found=yes
 2159         else
 2160           found=no
 2161         fi
 2162         break 2
 2163           fi
 2164         done
 2165       done
 2166       if test "$found" != yes; then
 2167         # deplib doesn't seem to be a libtool library
 2168         if test "$linkmode,$pass" = "prog,link"; then
 2169           compile_deplibs="$deplib $compile_deplibs"
 2170           finalize_deplibs="$deplib $finalize_deplibs"
 2171         else
 2172           deplibs="$deplib $deplibs"
 2173           test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
 2174         fi
 2175         continue
 2176       else # deplib is a libtool library
 2177         # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
 2178         # We need to do some special things here, and not later.
 2179         if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 2180           case " $predeps $postdeps " in
 2181           *" $deplib "*)
 2182         if (${SED} -e '2q' $lib |
 2183                     grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 2184           library_names=
 2185           old_library=
 2186           case $lib in
 2187           */* | *\\*) . $lib ;;
 2188           *) . ./$lib ;;
 2189           esac
 2190           for l in $old_library $library_names; do
 2191             ll="$l"
 2192           done
 2193           if test "X$ll" = "X$old_library" ; then # only static version available
 2194             found=no
 2195             ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
 2196             test "X$ladir" = "X$lib" && ladir="."
 2197             lib=$ladir/$old_library
 2198             if test "$linkmode,$pass" = "prog,link"; then
 2199               compile_deplibs="$deplib $compile_deplibs"
 2200               finalize_deplibs="$deplib $finalize_deplibs"
 2201             else
 2202               deplibs="$deplib $deplibs"
 2203               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
 2204             fi
 2205             continue
 2206           fi
 2207         fi
 2208             ;;
 2209           *) ;;
 2210           esac
 2211         fi
 2212       fi
 2213       ;; # -l
 2214     -L*)
 2215       case $linkmode in
 2216       lib)
 2217         deplibs="$deplib $deplibs"
 2218         test "$pass" = conv && continue
 2219         newdependency_libs="$deplib $newdependency_libs"
 2220         newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
 2221         ;;
 2222       prog)
 2223         if test "$pass" = conv; then
 2224           deplibs="$deplib $deplibs"
 2225           continue
 2226         fi
 2227         if test "$pass" = scan; then
 2228           deplibs="$deplib $deplibs"
 2229         else
 2230           compile_deplibs="$deplib $compile_deplibs"
 2231           finalize_deplibs="$deplib $finalize_deplibs"
 2232         fi
 2233         newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
 2234         ;;
 2235       *)
 2236         $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
 2237         ;;
 2238       esac # linkmode
 2239       continue
 2240       ;; # -L
 2241     -R*)
 2242       if test "$pass" = link; then
 2243         dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
 2244         # Make sure the xrpath contains only unique directories.
 2245         case "$xrpath " in
 2246         *" $dir "*) ;;
 2247         *) xrpath="$xrpath $dir" ;;
 2248         esac
 2249       fi
 2250       deplibs="$deplib $deplibs"
 2251       continue
 2252       ;;
 2253     *.la) lib="$deplib" ;;
 2254     *.$libext)
 2255       if test "$pass" = conv; then
 2256         deplibs="$deplib $deplibs"
 2257         continue
 2258       fi
 2259       case $linkmode in
 2260       lib)
 2261         valid_a_lib=no
 2262         case $deplibs_check_method in
 2263           match_pattern*)
 2264         set dummy $deplibs_check_method
 2265             match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
 2266         if eval $echo \"$deplib\" 2>/dev/null \
 2267             | $SED 10q \
 2268             | $EGREP "$match_pattern_regex" > /dev/null; then
 2269           valid_a_lib=yes
 2270         fi
 2271         ;;
 2272           pass_all)
 2273         valid_a_lib=yes
 2274         ;;
 2275             esac
 2276         if test "$valid_a_lib" != yes; then
 2277           $echo
 2278           $echo "*** Warning: Trying to link with static lib archive $deplib."
 2279           $echo "*** I have the capability to make that library automatically link in when"
 2280           $echo "*** you link to this library.  But I can only do this if you have a"
 2281           $echo "*** shared version of the library, which you do not appear to have"
 2282           $echo "*** because the file extensions .$libext of this argument makes me believe"
 2283           $echo "*** that it is just a static archive that I should not used here."
 2284         else
 2285           $echo
 2286           $echo "*** Warning: Linking the shared library $output against the"
 2287           $echo "*** static library $deplib is not portable!"
 2288           deplibs="$deplib $deplibs"
 2289         fi
 2290         continue
 2291         ;;
 2292       prog)
 2293         if test "$pass" != link; then
 2294           deplibs="$deplib $deplibs"
 2295         else
 2296           compile_deplibs="$deplib $compile_deplibs"
 2297           finalize_deplibs="$deplib $finalize_deplibs"
 2298         fi
 2299         continue
 2300         ;;
 2301       esac # linkmode
 2302       ;; # *.$libext
 2303     *.lo | *.$objext)
 2304       if test "$pass" = conv; then
 2305         deplibs="$deplib $deplibs"
 2306       elif test "$linkmode" = prog; then
 2307         if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
 2308           # If there is no dlopen support or we're linking statically,
 2309           # we need to preload.
 2310           newdlprefiles="$newdlprefiles $deplib"
 2311           compile_deplibs="$deplib $compile_deplibs"
 2312           finalize_deplibs="$deplib $finalize_deplibs"
 2313         else
 2314           newdlfiles="$newdlfiles $deplib"
 2315         fi
 2316       fi
 2317       continue
 2318       ;;
 2319     %DEPLIBS%)
 2320       alldeplibs=yes
 2321       continue
 2322       ;;
 2323     esac # case $deplib
 2324     if test "$found" = yes || test -f "$lib"; then :
 2325     else
 2326       $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
 2327       exit $EXIT_FAILURE
 2328     fi
 2329 
 2330     # Check to see that this really is a libtool archive.
 2331     if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
 2332     else
 2333       $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
 2334       exit $EXIT_FAILURE
 2335     fi
 2336 
 2337     ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
 2338     test "X$ladir" = "X$lib" && ladir="."
 2339 
 2340     dlname=
 2341     dlopen=
 2342     dlpreopen=
 2343     libdir=
 2344     library_names=
 2345     old_library=
 2346     # If the library was installed with an old release of libtool,
 2347     # it will not redefine variables installed, or shouldnotlink
 2348     installed=yes
 2349     shouldnotlink=no
 2350     avoidtemprpath=
 2351 
 2352 
 2353     # Read the .la file
 2354     case $lib in
 2355     */* | *\\*) . $lib ;;
 2356     *) . ./$lib ;;
 2357     esac
 2358 
 2359     if test "$linkmode,$pass" = "lib,link" ||
 2360        test "$linkmode,$pass" = "prog,scan" ||
 2361        { test "$linkmode" != prog && test "$linkmode" != lib; }; then
 2362       test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
 2363       test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
 2364     fi
 2365 
 2366     if test "$pass" = conv; then
 2367       # Only check for convenience libraries
 2368       deplibs="$lib $deplibs"
 2369       if test -z "$libdir"; then
 2370         if test -z "$old_library"; then
 2371           $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
 2372           exit $EXIT_FAILURE
 2373         fi
 2374         # It is a libtool convenience library, so add in its objects.
 2375         convenience="$convenience $ladir/$objdir/$old_library"
 2376         old_convenience="$old_convenience $ladir/$objdir/$old_library"
 2377         tmp_libs=
 2378         for deplib in $dependency_libs; do
 2379           deplibs="$deplib $deplibs"
 2380               if test "X$duplicate_deps" = "Xyes" ; then
 2381             case "$tmp_libs " in
 2382             *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 2383             esac
 2384               fi
 2385           tmp_libs="$tmp_libs $deplib"
 2386         done
 2387       elif test "$linkmode" != prog && test "$linkmode" != lib; then
 2388         $echo "$modename: \`$lib' is not a convenience library" 1>&2
 2389         exit $EXIT_FAILURE
 2390       fi
 2391       continue
 2392     fi # $pass = conv
 2393 
 2394 
 2395     # Get the name of the library we link against.
 2396     linklib=
 2397     for l in $old_library $library_names; do
 2398       linklib="$l"
 2399     done
 2400     if test -z "$linklib"; then
 2401       $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
 2402       exit $EXIT_FAILURE
 2403     fi
 2404 
 2405     # This library was specified with -dlopen.
 2406     if test "$pass" = dlopen; then
 2407       if test -z "$libdir"; then
 2408         $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
 2409         exit $EXIT_FAILURE
 2410       fi
 2411       if test -z "$dlname" ||
 2412          test "$dlopen_support" != yes ||
 2413          test "$build_libtool_libs" = no; then
 2414         # If there is no dlname, no dlopen support or we're linking
 2415         # statically, we need to preload.  We also need to preload any
 2416         # dependent libraries so libltdl's deplib preloader doesn't
 2417         # bomb out in the load deplibs phase.
 2418         dlprefiles="$dlprefiles $lib $dependency_libs"
 2419       else
 2420         newdlfiles="$newdlfiles $lib"
 2421       fi
 2422       continue
 2423     fi # $pass = dlopen
 2424 
 2425     # We need an absolute path.
 2426     case $ladir in
 2427     [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
 2428     *)
 2429       abs_ladir=`cd "$ladir" && pwd`
 2430       if test -z "$abs_ladir"; then
 2431         $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
 2432         $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
 2433         abs_ladir="$ladir"
 2434       fi
 2435       ;;
 2436     esac
 2437     laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
 2438 
 2439     # Find the relevant object directory and library name.
 2440     if test "X$installed" = Xyes; then
 2441       if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
 2442         $echo "$modename: warning: library \`$lib' was moved." 1>&2
 2443         dir="$ladir"
 2444         absdir="$abs_ladir"
 2445         libdir="$abs_ladir"
 2446       else
 2447         dir="$libdir"
 2448         absdir="$libdir"
 2449       fi
 2450       test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
 2451     else
 2452       if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
 2453         dir="$ladir"
 2454         absdir="$abs_ladir"
 2455         # Remove this search path later
 2456         notinst_path="$notinst_path $abs_ladir"
 2457       else
 2458         dir="$ladir/$objdir"
 2459         absdir="$abs_ladir/$objdir"
 2460         # Remove this search path later
 2461         notinst_path="$notinst_path $abs_ladir"
 2462       fi
 2463     fi # $installed = yes
 2464     name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 2465 
 2466     # This library was specified with -dlpreopen.
 2467     if test "$pass" = dlpreopen; then
 2468       if test -z "$libdir"; then
 2469         $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
 2470         exit $EXIT_FAILURE
 2471       fi
 2472       # Prefer using a static library (so that no silly _DYNAMIC symbols
 2473       # are required to link).
 2474       if test -n "$old_library"; then
 2475         newdlprefiles="$newdlprefiles $dir/$old_library"
 2476       # Otherwise, use the dlname, so that lt_dlopen finds it.
 2477       elif test -n "$dlname"; then
 2478         newdlprefiles="$newdlprefiles $dir/$dlname"
 2479       else
 2480         newdlprefiles="$newdlprefiles $dir/$linklib"
 2481       fi
 2482     fi # $pass = dlpreopen
 2483 
 2484     if test -z "$libdir"; then
 2485       # Link the convenience library
 2486       if test "$linkmode" = lib; then
 2487         deplibs="$dir/$old_library $deplibs"
 2488       elif test "$linkmode,$pass" = "prog,link"; then
 2489         compile_deplibs="$dir/$old_library $compile_deplibs"
 2490         finalize_deplibs="$dir/$old_library $finalize_deplibs"
 2491       else
 2492         deplibs="$lib $deplibs" # used for prog,scan pass
 2493       fi
 2494       continue
 2495     fi
 2496 
 2497 
 2498     if test "$linkmode" = prog && test "$pass" != link; then
 2499       newlib_search_path="$newlib_search_path $ladir"
 2500       deplibs="$lib $deplibs"
 2501 
 2502       linkalldeplibs=no
 2503       if test "$link_all_deplibs" != no || test -z "$library_names" ||
 2504          test "$build_libtool_libs" = no; then
 2505         linkalldeplibs=yes
 2506       fi
 2507 
 2508       tmp_libs=
 2509       for deplib in $dependency_libs; do
 2510         case $deplib in
 2511         -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
 2512         esac
 2513         # Need to link against all dependency_libs?
 2514         if test "$linkalldeplibs" = yes; then
 2515           deplibs="$deplib $deplibs"
 2516         else
 2517           # Need to hardcode shared library paths
 2518           # or/and link against static libraries
 2519           newdependency_libs="$deplib $newdependency_libs"
 2520         fi
 2521         if test "X$duplicate_deps" = "Xyes" ; then
 2522           case "$tmp_libs " in
 2523           *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 2524           esac
 2525         fi
 2526         tmp_libs="$tmp_libs $deplib"
 2527       done # for deplib
 2528       continue
 2529     fi # $linkmode = prog...
 2530 
 2531     if test "$linkmode,$pass" = "prog,link"; then
 2532       if test -n "$library_names" &&
 2533          { { test "$prefer_static_libs" = no ||
 2534          test "$prefer_static_libs,$installed" = "built,yes"; } ||
 2535            test -z "$old_library"; }; then
 2536         # We need to hardcode the library path
 2537         if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
 2538           # Make sure the rpath contains only unique directories.
 2539           case "$temp_rpath " in
 2540           *" $dir "*) ;;
 2541           *" $absdir "*) ;;
 2542           *) temp_rpath="$temp_rpath $absdir" ;;
 2543           esac
 2544         fi
 2545 
 2546         # Hardcode the library path.
 2547         # Skip directories that are in the system default run-time
 2548         # search path.
 2549         case " $sys_lib_dlsearch_path " in
 2550         *" $absdir "*) ;;
 2551         *)
 2552           case "$compile_rpath " in
 2553           *" $absdir "*) ;;
 2554           *) compile_rpath="$compile_rpath $absdir"
 2555           esac
 2556           ;;
 2557         esac
 2558         case " $sys_lib_dlsearch_path " in
 2559         *" $libdir "*) ;;
 2560         *)
 2561           case "$finalize_rpath " in
 2562           *" $libdir "*) ;;
 2563           *) finalize_rpath="$finalize_rpath $libdir"
 2564           esac
 2565           ;;
 2566         esac
 2567       fi # $linkmode,$pass = prog,link...
 2568 
 2569       if test "$alldeplibs" = yes &&
 2570          { test "$deplibs_check_method" = pass_all ||
 2571            { test "$build_libtool_libs" = yes &&
 2572          test -n "$library_names"; }; }; then
 2573         # We only need to search for static libraries
 2574         continue
 2575       fi
 2576     fi
 2577 
 2578     link_static=no # Whether the deplib will be linked statically
 2579     use_static_libs=$prefer_static_libs
 2580     if test "$use_static_libs" = built && test "$installed" = yes ; then
 2581       use_static_libs=no
 2582     fi
 2583     if test -n "$library_names" &&
 2584        { test "$use_static_libs" = no || test -z "$old_library"; }; then
 2585       if test "$installed" = no; then
 2586         notinst_deplibs="$notinst_deplibs $lib"
 2587         need_relink=yes
 2588       fi
 2589       # This is a shared library
 2590 
 2591       # Warn about portability, can't link against -module's on
 2592       # some systems (darwin)
 2593       if test "$shouldnotlink" = yes && test "$pass" = link ; then
 2594         $echo
 2595         if test "$linkmode" = prog; then
 2596           $echo "*** Warning: Linking the executable $output against the loadable module"
 2597         else
 2598           $echo "*** Warning: Linking the shared library $output against the loadable module"
 2599         fi
 2600         $echo "*** $linklib is not portable!"
 2601       fi
 2602       if test "$linkmode" = lib &&
 2603          test "$hardcode_into_libs" = yes; then
 2604         # Hardcode the library path.
 2605         # Skip directories that are in the system default run-time
 2606         # search path.
 2607         case " $sys_lib_dlsearch_path " in
 2608         *" $absdir "*) ;;
 2609         *)
 2610           case "$compile_rpath " in
 2611           *" $absdir "*) ;;
 2612           *) compile_rpath="$compile_rpath $absdir"
 2613           esac
 2614           ;;
 2615         esac
 2616         case " $sys_lib_dlsearch_path " in
 2617         *" $libdir "*) ;;
 2618         *)
 2619           case "$finalize_rpath " in
 2620           *" $libdir "*) ;;
 2621           *) finalize_rpath="$finalize_rpath $libdir"
 2622           esac
 2623           ;;
 2624         esac
 2625       fi
 2626 
 2627       if test -n "$old_archive_from_expsyms_cmds"; then
 2628         # figure out the soname
 2629         set dummy $library_names
 2630         realname="$2"
 2631         shift; shift
 2632         libname=`eval \\$echo \"$libname_spec\"`
 2633         # use dlname if we got it. it's perfectly good, no?
 2634         if test -n "$dlname"; then
 2635           soname="$dlname"
 2636         elif test -n "$soname_spec"; then
 2637           # bleh windows
 2638           case $host in
 2639           *cygwin* | mingw*)
 2640         major=`expr $current - $age`
 2641         versuffix="-$major"
 2642         ;;
 2643           esac
 2644           eval soname=\"$soname_spec\"
 2645         else
 2646           soname="$realname"
 2647         fi
 2648 
 2649         # Make a new name for the extract_expsyms_cmds to use
 2650         soroot="$soname"
 2651         soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
 2652         newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
 2653 
 2654         # If the library has no export list, then create one now
 2655         if test -f "$output_objdir/$soname-def"; then :
 2656         else
 2657           $show "extracting exported symbol list from \`$soname'"
 2658           save_ifs="$IFS"; IFS='~'
 2659           cmds=$extract_expsyms_cmds
 2660           for cmd in $cmds; do
 2661         IFS="$save_ifs"
 2662         eval cmd=\"$cmd\"
 2663         $show "$cmd"
 2664         $run eval "$cmd" || exit $?
 2665           done
 2666           IFS="$save_ifs"
 2667         fi
 2668 
 2669         # Create $newlib
 2670         if test -f "$output_objdir/$newlib"; then :; else
 2671           $show "generating import library for \`$soname'"
 2672           save_ifs="$IFS"; IFS='~'
 2673           cmds=$old_archive_from_expsyms_cmds
 2674           for cmd in $cmds; do
 2675         IFS="$save_ifs"
 2676         eval cmd=\"$cmd\"
 2677         $show "$cmd"
 2678         $run eval "$cmd" || exit $?
 2679           done
 2680           IFS="$save_ifs"
 2681         fi
 2682         # make sure the library variables are pointing to the new library
 2683         dir=$output_objdir
 2684         linklib=$newlib
 2685       fi # test -n "$old_archive_from_expsyms_cmds"
 2686 
 2687       if test "$linkmode" = prog || test "$mode" != relink; then
 2688         add_shlibpath=
 2689         add_dir=
 2690         add=
 2691         lib_linked=yes
 2692         case $hardcode_action in
 2693         immediate | unsupported)
 2694           if test "$hardcode_direct" = no; then
 2695         add="$dir/$linklib"
 2696         case $host in
 2697           *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
 2698           *-*-sysv4*uw2*) add_dir="-L$dir" ;;
 2699           *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
 2700             *-*-unixware7*) add_dir="-L$dir" ;;
 2701           *-*-darwin* )
 2702             # if the lib is a module then we can not link against
 2703             # it, someone is ignoring the new warnings I added
 2704             if /usr/bin/file -L $add 2> /dev/null |
 2705                       $EGREP ": [^:]* bundle" >/dev/null ; then
 2706               $echo "** Warning, lib $linklib is a module, not a shared library"
 2707               if test -z "$old_library" ; then
 2708                 $echo
 2709                 $echo "** And there doesn't seem to be a static archive available"
 2710                 $echo "** The link will probably fail, sorry"
 2711               else
 2712                 add="$dir/$old_library"
 2713               fi
 2714             fi
 2715         esac
 2716           elif test "$hardcode_minus_L" = no; then
 2717         case $host in
 2718         *-*-sunos*) add_shlibpath="$dir" ;;
 2719         esac
 2720         add_dir="-L$dir"
 2721         add="-l$name"
 2722           elif test "$hardcode_shlibpath_var" = no; then
 2723         add_shlibpath="$dir"
 2724         add="-l$name"
 2725           else
 2726         lib_linked=no
 2727           fi
 2728           ;;
 2729         relink)
 2730           if test "$hardcode_direct" = yes; then
 2731         add="$dir/$linklib"
 2732           elif test "$hardcode_minus_L" = yes; then
 2733         add_dir="-L$dir"
 2734         # Try looking first in the location we're being installed to.
 2735         if test -n "$inst_prefix_dir"; then
 2736           case $libdir in
 2737             [\\/]*)
 2738               add_dir="$add_dir -L$inst_prefix_dir$libdir"
 2739               ;;
 2740           esac
 2741         fi
 2742         add="-l$name"
 2743           elif test "$hardcode_shlibpath_var" = yes; then
 2744         add_shlibpath="$dir"
 2745         add="-l$name"
 2746           else
 2747         lib_linked=no
 2748           fi
 2749           ;;
 2750         *) lib_linked=no ;;
 2751         esac
 2752 
 2753         if test "$lib_linked" != yes; then
 2754           $echo "$modename: configuration error: unsupported hardcode properties"
 2755           exit $EXIT_FAILURE
 2756         fi
 2757 
 2758         if test -n "$add_shlibpath"; then
 2759           case :$compile_shlibpath: in
 2760           *":$add_shlibpath:"*) ;;
 2761           *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
 2762           esac
 2763         fi
 2764         if test "$linkmode" = prog; then
 2765           test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
 2766           test -n "$add" && compile_deplibs="$add $compile_deplibs"
 2767         else
 2768           test -n "$add_dir" && deplibs="$add_dir $deplibs"
 2769           test -n "$add" && deplibs="$add $deplibs"
 2770           if test "$hardcode_direct" != yes && \
 2771          test "$hardcode_minus_L" != yes && \
 2772          test "$hardcode_shlibpath_var" = yes; then
 2773         case :$finalize_shlibpath: in
 2774         *":$libdir:"*) ;;
 2775         *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
 2776         esac
 2777           fi
 2778         fi
 2779       fi
 2780 
 2781       if test "$linkmode" = prog || test "$mode" = relink; then
 2782         add_shlibpath=
 2783         add_dir=
 2784         add=
 2785         # Finalize command for both is simple: just hardcode it.
 2786         if test "$hardcode_direct" = yes; then
 2787           add="$libdir/$linklib"
 2788         elif test "$hardcode_minus_L" = yes; then
 2789           add_dir="-L$libdir"
 2790           add="-l$name"
 2791         elif test "$hardcode_shlibpath_var" = yes; then
 2792           case :$finalize_shlibpath: in
 2793           *":$libdir:"*) ;;
 2794           *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
 2795           esac
 2796           add="-l$name"
 2797         elif test "$hardcode_automatic" = yes; then
 2798           if test -n "$inst_prefix_dir" &&
 2799          test -f "$inst_prefix_dir$libdir/$linklib" ; then
 2800             add="$inst_prefix_dir$libdir/$linklib"
 2801           else
 2802             add="$libdir/$linklib"
 2803           fi
 2804         else
 2805           # We cannot seem to hardcode it, guess we'll fake it.
 2806           add_dir="-L$libdir"
 2807           # Try looking first in the location we're being installed to.
 2808           if test -n "$inst_prefix_dir"; then
 2809         case $libdir in
 2810           [\\/]*)
 2811             add_dir="$add_dir -L$inst_prefix_dir$libdir"
 2812             ;;
 2813         esac
 2814           fi
 2815           add="-l$name"
 2816         fi
 2817 
 2818         if test "$linkmode" = prog; then
 2819           test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
 2820           test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
 2821         else
 2822           test -n "$add_dir" && deplibs="$add_dir $deplibs"
 2823           test -n "$add" && deplibs="$add $deplibs"
 2824         fi
 2825       fi
 2826     elif test "$linkmode" = prog; then
 2827       # Here we assume that one of hardcode_direct or hardcode_minus_L
 2828       # is not unsupported.  This is valid on all known static and
 2829       # shared platforms.
 2830       if test "$hardcode_direct" != unsupported; then
 2831         test -n "$old_library" && linklib="$old_library"
 2832         compile_deplibs="$dir/$linklib $compile_deplibs"
 2833         finalize_deplibs="$dir/$linklib $finalize_deplibs"
 2834       else
 2835         compile_deplibs="-l$name -L$dir $compile_deplibs"
 2836         finalize_deplibs="-l$name -L$dir $finalize_deplibs"
 2837       fi
 2838     elif test "$build_libtool_libs" = yes; then
 2839       # Not a shared library
 2840       if test "$deplibs_check_method" != pass_all; then
 2841         # We're trying link a shared library against a static one
 2842         # but the system doesn't support it.
 2843 
 2844         # Just print a warning and add the library to dependency_libs so
 2845         # that the program can be linked against the static library.
 2846         $echo
 2847         $echo "*** Warning: This system can not link to static lib archive $lib."
 2848         $echo "*** I have the capability to make that library automatically link in when"
 2849         $echo "*** you link to this library.  But I can only do this if you have a"
 2850         $echo "*** shared version of the library, which you do not appear to have."
 2851         if test "$module" = yes; then
 2852           $echo "*** But as you try to build a module library, libtool will still create "
 2853           $echo "*** a static module, that should work as long as the dlopening application"
 2854           $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
 2855           if test -z "$global_symbol_pipe"; then
 2856         $echo
 2857         $echo "*** However, this would only work if libtool was able to extract symbol"
 2858         $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
 2859         $echo "*** not find such a program.  So, this module is probably useless."
 2860         $echo "*** \`nm' from GNU binutils and a full rebuild may help."
 2861           fi
 2862           if test "$build_old_libs" = no; then
 2863         build_libtool_libs=module
 2864         build_old_libs=yes
 2865           else
 2866         build_libtool_libs=no
 2867           fi
 2868         fi
 2869       else
 2870         deplibs="$dir/$old_library $deplibs"
 2871         link_static=yes
 2872       fi
 2873     fi # link shared/static library?
 2874 
 2875     if test "$linkmode" = lib; then
 2876       if test -n "$dependency_libs" &&
 2877          { test "$hardcode_into_libs" != yes ||
 2878            test "$build_old_libs" = yes ||
 2879            test "$link_static" = yes; }; then
 2880         # Extract -R from dependency_libs
 2881         temp_deplibs=
 2882         for libdir in $dependency_libs; do
 2883           case $libdir in
 2884           -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
 2885            case " $xrpath " in
 2886            *" $temp_xrpath "*) ;;
 2887            *) xrpath="$xrpath $temp_xrpath";;
 2888            esac;;
 2889           *) temp_deplibs="$temp_deplibs $libdir";;
 2890           esac
 2891         done
 2892         dependency_libs="$temp_deplibs"
 2893       fi
 2894 
 2895       newlib_search_path="$newlib_search_path $absdir"
 2896       # Link against this library
 2897       test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
 2898       # ... and its dependency_libs
 2899       tmp_libs=
 2900       for deplib in $dependency_libs; do
 2901         newdependency_libs="$deplib $newdependency_libs"
 2902         if test "X$duplicate_deps" = "Xyes" ; then
 2903           case "$tmp_libs " in
 2904           *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 2905           esac
 2906         fi
 2907         tmp_libs="$tmp_libs $deplib"
 2908       done
 2909 
 2910       if test "$link_all_deplibs" != no; then
 2911         # Add the search paths of all dependency libraries
 2912         for deplib in $dependency_libs; do
 2913           case $deplib in
 2914           -L*) path="$deplib" ;;
 2915           *.la)
 2916         dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
 2917         test "X$dir" = "X$deplib" && dir="."
 2918         # We need an absolute path.
 2919         case $dir in
 2920         [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
 2921         *)
 2922           absdir=`cd "$dir" && pwd`
 2923           if test -z "$absdir"; then
 2924             $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
 2925             absdir="$dir"
 2926           fi
 2927           ;;
 2928         esac
 2929         if grep "^installed=no" $deplib > /dev/null; then
 2930           path="$absdir/$objdir"
 2931         else
 2932           eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
 2933           if test -z "$libdir"; then
 2934             $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
 2935             exit $EXIT_FAILURE
 2936           fi
 2937           if test "$absdir" != "$libdir"; then
 2938             $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
 2939           fi
 2940           path="$absdir"
 2941         fi
 2942         depdepl=
 2943         case $host in
 2944         *-*-darwin*)
 2945           # we do not want to link against static libs,
 2946           # but need to link against shared
 2947           eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
 2948           if test -n "$deplibrary_names" ; then
 2949             for tmp in $deplibrary_names ; do
 2950               depdepl=$tmp
 2951             done
 2952             if test -f "$path/$depdepl" ; then
 2953               depdepl="$path/$depdepl"
 2954             fi
 2955             # do not add paths which are already there
 2956             case " $newlib_search_path " in
 2957             *" $path "*) ;;
 2958             *) newlib_search_path="$newlib_search_path $path";;
 2959             esac
 2960           fi
 2961           path=""
 2962           ;;
 2963         *)
 2964           path="-L$path"
 2965           ;;
 2966         esac
 2967         ;;
 2968           -l*)
 2969         case $host in
 2970         *-*-darwin*)
 2971           # Again, we only want to link against shared libraries
 2972           eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
 2973           for tmp in $newlib_search_path ; do
 2974             if test -f "$tmp/lib$tmp_libs.dylib" ; then
 2975               eval depdepl="$tmp/lib$tmp_libs.dylib"
 2976               break
 2977             fi
 2978           done
 2979           path=""
 2980           ;;
 2981         *) continue ;;
 2982         esac
 2983         ;;
 2984           *) continue ;;
 2985           esac
 2986           case " $deplibs " in
 2987           *" $path "*) ;;
 2988           *) deplibs="$path $deplibs" ;;
 2989           esac
 2990           case " $deplibs " in
 2991           *" $depdepl "*) ;;
 2992           *) deplibs="$depdepl $deplibs" ;;
 2993           esac
 2994         done
 2995       fi # link_all_deplibs != no
 2996     fi # linkmode = lib
 2997       done # for deplib in $libs
 2998       dependency_libs="$newdependency_libs"
 2999       if test "$pass" = dlpreopen; then
 3000     # Link the dlpreopened libraries before other libraries
 3001     for deplib in $save_deplibs; do
 3002       deplibs="$deplib $deplibs"
 3003     done
 3004       fi
 3005       if test "$pass" != dlopen; then
 3006     if test "$pass" != conv; then
 3007       # Make sure lib_search_path contains only unique directories.
 3008       lib_search_path=
 3009       for dir in $newlib_search_path; do
 3010         case "$lib_search_path " in
 3011         *" $dir "*) ;;
 3012         *) lib_search_path="$lib_search_path $dir" ;;
 3013         esac
 3014       done
 3015       newlib_search_path=
 3016     fi
 3017 
 3018     if test "$linkmode,$pass" != "prog,link"; then
 3019       vars="deplibs"
 3020     else
 3021       vars="compile_deplibs finalize_deplibs"
 3022     fi
 3023     for var in $vars dependency_libs; do
 3024       # Add libraries to $var in reverse order
 3025       eval tmp_libs=\"\$$var\"
 3026       new_libs=
 3027       for deplib in $tmp_libs; do
 3028         # FIXME: Pedantically, this is the right thing to do, so
 3029         #        that some nasty dependency loop isn't accidentally
 3030         #        broken:
 3031         #new_libs="$deplib $new_libs"
 3032         # Pragmatically, this seems to cause very few problems in
 3033         # practice:
 3034         case $deplib in
 3035         -L*) new_libs="$deplib $new_libs" ;;
 3036         -R*) ;;
 3037         *)
 3038           # And here is the reason: when a library appears more
 3039           # than once as an explicit dependence of a library, or
 3040           # is implicitly linked in more than once by the
 3041           # compiler, it is considered special, and multiple
 3042           # occurrences thereof are not removed.  Compare this
 3043           # with having the same library being listed as a
 3044           # dependency of multiple other libraries: in this case,
 3045           # we know (pedantically, we assume) the library does not
 3046           # need to be listed more than once, so we keep only the
 3047           # last copy.  This is not always right, but it is rare
 3048           # enough that we require users that really mean to play
 3049           # such unportable linking tricks to link the library
 3050           # using -Wl,-lname, so that libtool does not consider it
 3051           # for duplicate removal.
 3052           case " $specialdeplibs " in
 3053           *" $deplib "*) new_libs="$deplib $new_libs" ;;
 3054           *)
 3055         case " $new_libs " in
 3056         *" $deplib "*) ;;
 3057         *) new_libs="$deplib $new_libs" ;;
 3058         esac
 3059         ;;
 3060           esac
 3061           ;;
 3062         esac
 3063       done
 3064       tmp_libs=
 3065       for deplib in $new_libs; do
 3066         case $deplib in
 3067         -L*)
 3068           case " $tmp_libs " in
 3069           *" $deplib "*) ;;
 3070           *) tmp_libs="$tmp_libs $deplib" ;;
 3071           esac
 3072           ;;
 3073         *) tmp_libs="$tmp_libs $deplib" ;;
 3074         esac
 3075       done
 3076       eval $var=\"$tmp_libs\"
 3077     done # for var
 3078       fi
 3079       # Last step: remove runtime libs from dependency_libs
 3080       # (they stay in deplibs)
 3081       tmp_libs=
 3082       for i in $dependency_libs ; do
 3083     case " $predeps $postdeps $compiler_lib_search_path " in
 3084     *" $i "*)
 3085       i=""
 3086       ;;
 3087     esac
 3088     if test -n "$i" ; then
 3089       tmp_libs="$tmp_libs $i"
 3090     fi
 3091       done
 3092       dependency_libs=$tmp_libs
 3093     done # for pass
 3094     if test "$linkmode" = prog; then
 3095       dlfiles="$newdlfiles"
 3096       dlprefiles="$newdlprefiles"
 3097     fi
 3098 
 3099     case $linkmode in
 3100     oldlib)
 3101       if test -n "$deplibs"; then
 3102     $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
 3103       fi
 3104 
 3105       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
 3106     $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
 3107       fi
 3108 
 3109       if test -n "$rpath"; then
 3110     $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
 3111       fi
 3112 
 3113       if test -n "$xrpath"; then
 3114     $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
 3115       fi
 3116 
 3117       if test -n "$vinfo"; then
 3118     $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
 3119       fi
 3120 
 3121       if test -n "$release"; then
 3122     $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
 3123       fi
 3124 
 3125       if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
 3126     $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
 3127       fi
 3128 
 3129       # Now set the variables for building old libraries.
 3130       build_libtool_libs=no
 3131       oldlibs="$output"
 3132       objs="$objs$old_deplibs"
 3133       ;;
 3134 
 3135     lib)
 3136       # Make sure we only generate libraries of the form `libNAME.la'.
 3137       case $outputname in
 3138       lib*)
 3139     name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 3140     eval shared_ext=\"$shrext_cmds\"
 3141     eval libname=\"$libname_spec\"
 3142     ;;
 3143       *)
 3144     if test "$module" = no; then
 3145       $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
 3146       $echo "$help" 1>&2
 3147       exit $EXIT_FAILURE
 3148     fi
 3149     if test "$need_lib_prefix" != no; then
 3150       # Add the "lib" prefix for modules if required
 3151       name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
 3152       eval shared_ext=\"$shrext_cmds\"
 3153       eval libname=\"$libname_spec\"
 3154     else
 3155       libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
 3156     fi
 3157     ;;
 3158       esac
 3159 
 3160       if test -n "$objs"; then
 3161     if test "$deplibs_check_method" != pass_all; then
 3162       $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
 3163       exit $EXIT_FAILURE
 3164     else
 3165       $echo
 3166       $echo "*** Warning: Linking the shared library $output against the non-libtool"
 3167       $echo "*** objects $objs is not portable!"
 3168       libobjs="$libobjs $objs"
 3169     fi
 3170       fi
 3171 
 3172       if test "$dlself" != no; then
 3173     $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
 3174       fi
 3175 
 3176       set dummy $rpath
 3177       if test "$#" -gt 2; then
 3178     $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
 3179       fi
 3180       install_libdir="$2"
 3181 
 3182       oldlibs=
 3183       if test -z "$rpath"; then
 3184     if test "$build_libtool_libs" = yes; then
 3185       # Building a libtool convenience library.
 3186       # Some compilers have problems with a `.al' extension so
 3187       # convenience libraries should have the same extension an
 3188       # archive normally would.
 3189       oldlibs="$output_objdir/$libname.$libext $oldlibs"
 3190       build_libtool_libs=convenience
 3191       build_old_libs=yes
 3192     fi
 3193 
 3194     if test -n "$vinfo"; then
 3195       $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
 3196     fi
 3197 
 3198     if test -n "$release"; then
 3199       $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
 3200     fi
 3201       else
 3202 
 3203     # Parse the version information argument.
 3204     save_ifs="$IFS"; IFS=':'
 3205     set dummy $vinfo 0 0 0
 3206     IFS="$save_ifs"
 3207 
 3208     if test -n "$8"; then
 3209       $echo "$modename: too many parameters to \`-version-info'" 1>&2
 3210       $echo "$help" 1>&2
 3211       exit $EXIT_FAILURE
 3212     fi
 3213 
 3214     # convert absolute version numbers to libtool ages
 3215     # this retains compatibility with .la files and attempts
 3216     # to make the code below a bit more comprehensible
 3217 
 3218     case $vinfo_number in
 3219     yes)
 3220       number_major="$2"
 3221       number_minor="$3"
 3222       number_revision="$4"
 3223       #
 3224       # There are really only two kinds -- those that
 3225       # use the current revision as the major version
 3226       # and those that subtract age and use age as
 3227       # a minor version.  But, then there is irix
 3228       # which has an extra 1 added just for fun
 3229       #
 3230       case $version_type in
 3231       darwin|linux|osf|windows|none)
 3232         current=`expr $number_major + $number_minor`
 3233         age="$number_minor"
 3234         revision="$number_revision"
 3235         ;;
 3236       freebsd-aout|freebsd-elf|sunos)
 3237         current="$number_major"
 3238         revision="$number_minor"
 3239         age="0"
 3240         ;;
 3241       irix|nonstopux)
 3242         current=`expr $number_major + $number_minor`
 3243         age="$number_minor"
 3244         revision="$number_minor"
 3245         lt_irix_increment=no
 3246         ;;
 3247       esac
 3248       ;;
 3249     no)
 3250       current="$2"
 3251       revision="$3"
 3252       age="$4"
 3253       ;;
 3254     esac
 3255 
 3256     # Check that each of the things are valid numbers.
 3257     case $current in
 3258     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]) ;;
 3259     *)
 3260       $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
 3261       $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 3262       exit $EXIT_FAILURE
 3263       ;;
 3264     esac
 3265 
 3266     case $revision in
 3267     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]) ;;
 3268     *)
 3269       $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
 3270       $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 3271       exit $EXIT_FAILURE
 3272       ;;
 3273     esac
 3274 
 3275     case $age in
 3276     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]) ;;
 3277     *)
 3278       $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
 3279       $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 3280       exit $EXIT_FAILURE
 3281       ;;
 3282     esac
 3283 
 3284     if test "$age" -gt "$current"; then
 3285       $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
 3286       $echo "$modename: \`$vinfo' is not valid version information" 1>&2
 3287       exit $EXIT_FAILURE
 3288     fi
 3289 
 3290     # Calculate the version variables.
 3291     major=
 3292     versuffix=
 3293     verstring=
 3294     case $version_type in
 3295     none) ;;
 3296 
 3297     darwin)
 3298       # Like Linux, but with the current version available in
 3299       # verstring for coding it into the library header
 3300       major=.`expr $current - $age`
 3301       versuffix="$major.$age.$revision"
 3302       # Darwin ld doesn't like 0 for these options...
 3303       minor_current=`expr $current + 1`
 3304       xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
 3305       verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
 3306       ;;
 3307 
 3308     freebsd-aout)
 3309       major=".$current"
 3310       versuffix=".$current.$revision";
 3311       ;;
 3312 
 3313     freebsd-elf)
 3314       major=".$current"
 3315       versuffix=".$current";
 3316       ;;
 3317 
 3318     irix | nonstopux)
 3319       if test "X$lt_irix_increment" = "Xno"; then
 3320         major=`expr $current - $age`
 3321       else
 3322         major=`expr $current - $age + 1`
 3323       fi
 3324       case $version_type in
 3325         nonstopux) verstring_prefix=nonstopux ;;
 3326         *)         verstring_prefix=sgi ;;
 3327       esac
 3328       verstring="$verstring_prefix$major.$revision"
 3329 
 3330       # Add in all the interfaces that we are compatible with.
 3331       loop=$revision
 3332       while test "$loop" -ne 0; do
 3333         iface=`expr $revision - $loop`
 3334         loop=`expr $loop - 1`
 3335         verstring="$verstring_prefix$major.$iface:$verstring"
 3336       done
 3337 
 3338       # Before this point, $major must not contain `.'.
 3339       major=.$major
 3340       versuffix="$major.$revision"
 3341       ;;
 3342 
 3343     linux)
 3344       major=.`expr $current - $age`
 3345       versuffix="$major.$age.$revision"
 3346       ;;
 3347 
 3348     osf)
 3349       major=.`expr $current - $age`
 3350       versuffix=".$current.$age.$revision"
 3351       verstring="$current.$age.$revision"
 3352 
 3353       # Add in all the interfaces that we are compatible with.
 3354       loop=$age
 3355       while test "$loop" -ne 0; do
 3356         iface=`expr $current - $loop`
 3357         loop=`expr $loop - 1`
 3358         verstring="$verstring:${iface}.0"
 3359       done
 3360 
 3361       # Make executables depend on our current version.
 3362       verstring="$verstring:${current}.0"
 3363       ;;
 3364 
 3365     sunos)
 3366       major=".$current"
 3367       versuffix=".$current.$revision"
 3368       ;;
 3369 
 3370     windows)
 3371       # Use '-' rather than '.', since we only want one
 3372       # extension on DOS 8.3 filesystems.
 3373       major=`expr $current - $age`
 3374       versuffix="-$major"
 3375       ;;
 3376 
 3377     *)
 3378       $echo "$modename: unknown library version type \`$version_type'" 1>&2
 3379       $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
 3380       exit $EXIT_FAILURE
 3381       ;;
 3382     esac
 3383 
 3384     # Clear the version info if we defaulted, and they specified a release.
 3385     if test -z "$vinfo" && test -n "$release"; then
 3386       major=
 3387       case $version_type in
 3388       darwin)
 3389         # we can't check for "0.0" in archive_cmds due to quoting
 3390         # problems, so we reset it completely
 3391         verstring=
 3392         ;;
 3393       *)
 3394         verstring="0.0"
 3395         ;;
 3396       esac
 3397       if test "$need_version" = no; then
 3398         versuffix=
 3399       else
 3400         versuffix=".0.0"
 3401       fi
 3402     fi
 3403 
 3404     # Remove version info from name if versioning should be avoided
 3405     if test "$avoid_version" = yes && test "$need_version" = no; then
 3406       major=
 3407       versuffix=
 3408       verstring=""
 3409     fi
 3410 
 3411     # Check to see if the archive will have undefined symbols.
 3412     if test "$allow_undefined" = yes; then
 3413       if test "$allow_undefined_flag" = unsupported; then
 3414         $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
 3415         build_libtool_libs=no
 3416         build_old_libs=yes
 3417       fi
 3418     else
 3419       # Don't allow undefined symbols.
 3420       allow_undefined_flag="$no_undefined_flag"
 3421     fi
 3422       fi
 3423 
 3424       if test "$mode" != relink; then
 3425     # Remove our outputs, but don't remove object files since they
 3426     # may have been created when compiling PIC objects.
 3427     removelist=
 3428     tempremovelist=`$echo "$output_objdir/*"`
 3429     for p in $tempremovelist; do
 3430       case $p in
 3431         *.$objext)
 3432            ;;
 3433         $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
 3434            if test "X$precious_files_regex" != "X"; then
 3435              if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
 3436              then
 3437            continue
 3438          fi
 3439            fi
 3440            removelist="$removelist $p"
 3441            ;;
 3442         *) ;;
 3443       esac
 3444     done
 3445     if test -n "$removelist"; then
 3446       $show "${rm}r $removelist"
 3447       $run ${rm}r $removelist
 3448     fi
 3449       fi
 3450 
 3451       # Now set the variables for building old libraries.
 3452       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
 3453     oldlibs="$oldlibs $output_objdir/$libname.$libext"
 3454 
 3455     # Transform .lo files to .o files.
 3456     oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
 3457       fi
 3458 
 3459       # Eliminate all temporary directories.
 3460       #for path in $notinst_path; do
 3461       # lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
 3462       # deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
 3463       # dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
 3464       #done
 3465 
 3466       if test -n "$xrpath"; then
 3467     # If the user specified any rpath flags, then add them.
 3468     temp_xrpath=
 3469     for libdir in $xrpath; do
 3470       temp_xrpath="$temp_xrpath -R$libdir"
 3471       case "$finalize_rpath " in
 3472       *" $libdir "*) ;;
 3473       *) finalize_rpath="$finalize_rpath $libdir" ;;
 3474       esac
 3475     done
 3476     if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
 3477       dependency_libs="$temp_xrpath $dependency_libs"
 3478     fi
 3479       fi
 3480 
 3481       # Make sure dlfiles contains only unique files that won't be dlpreopened
 3482       old_dlfiles="$dlfiles"
 3483       dlfiles=
 3484       for lib in $old_dlfiles; do
 3485     case " $dlprefiles $dlfiles " in
 3486     *" $lib "*) ;;
 3487     *) dlfiles="$dlfiles $lib" ;;
 3488     esac
 3489       done
 3490 
 3491       # Make sure dlprefiles contains only unique files
 3492       old_dlprefiles="$dlprefiles"
 3493       dlprefiles=
 3494       for lib in $old_dlprefiles; do
 3495     case "$dlprefiles " in
 3496     *" $lib "*) ;;
 3497     *) dlprefiles="$dlprefiles $lib" ;;
 3498     esac
 3499       done
 3500 
 3501       if test "$build_libtool_libs" = yes; then
 3502     if test -n "$rpath"; then
 3503       case $host in
 3504       *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
 3505         # these systems don't actually have a c library (as such)!
 3506         ;;
 3507       *-*-rhapsody* | *-*-darwin1.[012])
 3508         # Rhapsody C library is in the System framework
 3509         deplibs="$deplibs -framework System"
 3510         ;;
 3511       *-*-netbsd*)
 3512         # Don't link with libc until the a.out ld.so is fixed.
 3513         ;;
 3514       *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
 3515         # Do not include libc due to us having libc/libc_r.
 3516         ;;
 3517       *-*-sco3.2v5* | *-*-sco5v6*)
 3518         # Causes problems with __ctype
 3519         ;;
 3520       *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
 3521         # Compiler inserts libc in the correct place for threads to work
 3522         ;;
 3523       *)
 3524         # Add libc to deplibs on all other systems if necessary.
 3525         if test "$build_libtool_need_lc" = "yes"; then
 3526           deplibs="$deplibs -lc"
 3527         fi
 3528         ;;
 3529       esac
 3530     fi
 3531 
 3532     # Transform deplibs into only deplibs that can be linked in shared.
 3533     name_save=$name
 3534     libname_save=$libname
 3535     release_save=$release
 3536     versuffix_save=$versuffix
 3537     major_save=$major
 3538     # I'm not sure if I'm treating the release correctly.  I think
 3539     # release should show up in the -l (ie -lgmp5) so we don't want to
 3540     # add it in twice.  Is that correct?
 3541     release=""
 3542     versuffix=""
 3543     major=""
 3544     newdeplibs=
 3545     droppeddeps=no
 3546     case $deplibs_check_method in
 3547     pass_all)
 3548       # Don't check for shared/static.  Everything works.
 3549       # This might be a little naive.  We might want to check
 3550       # whether the library exists or not.  But this is on
 3551       # osf3 & osf4 and I'm not really sure... Just
 3552       # implementing what was already the behavior.
 3553       newdeplibs=$deplibs
 3554       ;;
 3555     test_compile)
 3556       # This code stresses the "libraries are programs" paradigm to its
 3557       # limits. Maybe even breaks it.  We compile a program, linking it
 3558       # against the deplibs as a proxy for the library.  Then we can check
 3559       # whether they linked in statically or dynamically with ldd.
 3560       $rm conftest.c
 3561       cat > conftest.c <<EOF
 3562       int main() { return 0; }
 3563 EOF
 3564       $rm conftest
 3565       if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
 3566         ldd_output=`ldd conftest`
 3567         for i in $deplibs; do
 3568           name=`expr $i : '-l\(.*\)'`
 3569           # If $name is empty we are operating on a -L argument.
 3570               if test "$name" != "" && test "$name" != "0"; then
 3571         if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 3572           case " $predeps $postdeps " in
 3573           *" $i "*)
 3574             newdeplibs="$newdeplibs $i"
 3575             i=""
 3576             ;;
 3577           esac
 3578             fi
 3579         if test -n "$i" ; then
 3580           libname=`eval \\$echo \"$libname_spec\"`
 3581           deplib_matches=`eval \\$echo \"$library_names_spec\"`
 3582           set dummy $deplib_matches
 3583           deplib_match=$2
 3584           if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
 3585             newdeplibs="$newdeplibs $i"
 3586           else
 3587             droppeddeps=yes
 3588             $echo
 3589             $echo "*** Warning: dynamic linker does not accept needed library $i."
 3590             $echo "*** I have the capability to make that library automatically link in when"
 3591             $echo "*** you link to this library.  But I can only do this if you have a"
 3592             $echo "*** shared version of the library, which I believe you do not have"
 3593             $echo "*** because a test_compile did reveal that the linker did not use it for"
 3594             $echo "*** its dynamic dependency list that programs get resolved with at runtime."
 3595           fi
 3596         fi
 3597           else
 3598         newdeplibs="$newdeplibs $i"
 3599           fi
 3600         done
 3601       else
 3602         # Error occurred in the first compile.  Let's try to salvage
 3603         # the situation: Compile a separate program for each library.
 3604         for i in $deplibs; do
 3605           name=`expr $i : '-l\(.*\)'`
 3606           # If $name is empty we are operating on a -L argument.
 3607               if test "$name" != "" && test "$name" != "0"; then
 3608         $rm conftest
 3609         if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
 3610           ldd_output=`ldd conftest`
 3611           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 3612             case " $predeps $postdeps " in
 3613             *" $i "*)
 3614               newdeplibs="$newdeplibs $i"
 3615               i=""
 3616               ;;
 3617             esac
 3618           fi
 3619           if test -n "$i" ; then
 3620             libname=`eval \\$echo \"$libname_spec\"`
 3621             deplib_matches=`eval \\$echo \"$library_names_spec\"`
 3622             set dummy $deplib_matches
 3623             deplib_match=$2
 3624             if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
 3625               newdeplibs="$newdeplibs $i"
 3626             else
 3627               droppeddeps=yes
 3628               $echo
 3629               $echo "*** Warning: dynamic linker does not accept needed library $i."
 3630               $echo "*** I have the capability to make that library automatically link in when"
 3631               $echo "*** you link to this library.  But I can only do this if you have a"
 3632               $echo "*** shared version of the library, which you do not appear to have"
 3633               $echo "*** because a test_compile did reveal that the linker did not use this one"
 3634               $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
 3635             fi
 3636           fi
 3637         else
 3638           droppeddeps=yes
 3639           $echo
 3640           $echo "*** Warning!  Library $i is needed by this library but I was not able to"
 3641           $echo "*** make it link in!  You will probably need to install it or some"
 3642           $echo "*** library that it depends on before this library will be fully"
 3643           $echo "*** functional.  Installing it before continuing would be even better."
 3644         fi
 3645           else
 3646         newdeplibs="$newdeplibs $i"
 3647           fi
 3648         done
 3649       fi
 3650       ;;
 3651     file_magic*)
 3652       set dummy $deplibs_check_method
 3653       file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
 3654       for a_deplib in $deplibs; do
 3655         name=`expr $a_deplib : '-l\(.*\)'`
 3656         # If $name is empty we are operating on a -L argument.
 3657             if test "$name" != "" && test  "$name" != "0"; then
 3658           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 3659         case " $predeps $postdeps " in
 3660         *" $a_deplib "*)
 3661           newdeplibs="$newdeplibs $a_deplib"
 3662           a_deplib=""
 3663           ;;
 3664         esac
 3665           fi
 3666           if test -n "$a_deplib" ; then
 3667         libname=`eval \\$echo \"$libname_spec\"`
 3668         for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
 3669           potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
 3670           for potent_lib in $potential_libs; do
 3671               # Follow soft links.
 3672               if ls -lLd "$potent_lib" 2>/dev/null \
 3673              | grep " -> " >/dev/null; then
 3674             continue
 3675               fi
 3676               # The statement above tries to avoid entering an
 3677               # endless loop below, in case of cyclic links.
 3678               # We might still enter an endless loop, since a link
 3679               # loop can be closed while we follow links,
 3680               # but so what?
 3681               potlib="$potent_lib"
 3682               while test -h "$potlib" 2>/dev/null; do
 3683             potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
 3684             case $potliblink in
 3685             [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
 3686             *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
 3687             esac
 3688               done
 3689               if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
 3690              | ${SED} 10q \
 3691              | $EGREP "$file_magic_regex" > /dev/null; then
 3692             newdeplibs="$newdeplibs $a_deplib"
 3693             a_deplib=""
 3694             break 2
 3695               fi
 3696           done
 3697         done
 3698           fi
 3699           if test -n "$a_deplib" ; then
 3700         droppeddeps=yes
 3701         $echo
 3702         $echo "*** Warning: linker path does not have real file for library $a_deplib."
 3703         $echo "*** I have the capability to make that library automatically link in when"
 3704         $echo "*** you link to this library.  But I can only do this if you have a"
 3705         $echo "*** shared version of the library, which you do not appear to have"
 3706         $echo "*** because I did check the linker path looking for a file starting"
 3707         if test -z "$potlib" ; then
 3708           $echo "*** with $libname but no candidates were found. (...for file magic test)"
 3709         else
 3710           $echo "*** with $libname and none of the candidates passed a file format test"
 3711           $echo "*** using a file magic. Last file checked: $potlib"
 3712         fi
 3713           fi
 3714         else
 3715           # Add a -L argument.
 3716           newdeplibs="$newdeplibs $a_deplib"
 3717         fi
 3718       done # Gone through all deplibs.
 3719       ;;
 3720     match_pattern*)
 3721       set dummy $deplibs_check_method
 3722       match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
 3723       for a_deplib in $deplibs; do
 3724         name=`expr $a_deplib : '-l\(.*\)'`
 3725         # If $name is empty we are operating on a -L argument.
 3726         if test -n "$name" && test "$name" != "0"; then
 3727           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 3728         case " $predeps $postdeps " in
 3729         *" $a_deplib "*)
 3730           newdeplibs="$newdeplibs $a_deplib"
 3731           a_deplib=""
 3732           ;;
 3733         esac
 3734           fi
 3735           if test -n "$a_deplib" ; then
 3736         libname=`eval \\$echo \"$libname_spec\"`
 3737         for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
 3738           potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
 3739           for potent_lib in $potential_libs; do
 3740             potlib="$potent_lib" # see symlink-check above in file_magic test
 3741             if eval $echo \"$potent_lib\" 2>/dev/null \
 3742                 | ${SED} 10q \
 3743                 | $EGREP "$match_pattern_regex" > /dev/null; then
 3744               newdeplibs="$newdeplibs $a_deplib"
 3745               a_deplib=""
 3746               break 2
 3747             fi
 3748           done
 3749         done
 3750           fi
 3751           if test -n "$a_deplib" ; then
 3752         droppeddeps=yes
 3753         $echo
 3754         $echo "*** Warning: linker path does not have real file for library $a_deplib."
 3755         $echo "*** I have the capability to make that library automatically link in when"
 3756         $echo "*** you link to this library.  But I can only do this if you have a"
 3757         $echo "*** shared version of the library, which you do not appear to have"
 3758         $echo "*** because I did check the linker path looking for a file starting"
 3759         if test -z "$potlib" ; then
 3760           $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
 3761         else
 3762           $echo "*** with $libname and none of the candidates passed a file format test"
 3763           $echo "*** using a regex pattern. Last file checked: $potlib"
 3764         fi
 3765           fi
 3766         else
 3767           # Add a -L argument.
 3768           newdeplibs="$newdeplibs $a_deplib"
 3769         fi
 3770       done # Gone through all deplibs.
 3771       ;;
 3772     none | unknown | *)
 3773       newdeplibs=""
 3774       tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
 3775         -e 's/ -[LR][^ ]*//g'`
 3776       if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
 3777         for i in $predeps $postdeps ; do
 3778           # can't use Xsed below, because $i might contain '/'
 3779           tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
 3780         done
 3781       fi
 3782       if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
 3783         | grep . >/dev/null; then
 3784         $echo
 3785         if test "X$deplibs_check_method" = "Xnone"; then
 3786           $echo "*** Warning: inter-library dependencies are not supported in this platform."
 3787         else
 3788           $echo "*** Warning: inter-library dependencies are not known to be supported."
 3789         fi
 3790         $echo "*** All declared inter-library dependencies are being dropped."
 3791         droppeddeps=yes
 3792       fi
 3793       ;;
 3794     esac
 3795     versuffix=$versuffix_save
 3796     major=$major_save
 3797     release=$release_save
 3798     libname=$libname_save
 3799     name=$name_save
 3800 
 3801     case $host in
 3802     *-*-rhapsody* | *-*-darwin1.[012])
 3803       # On Rhapsody replace the C library is the System framework
 3804       newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
 3805       ;;
 3806     esac
 3807 
 3808     if test "$droppeddeps" = yes; then
 3809       if test "$module" = yes; then
 3810         $echo
 3811         $echo "*** Warning: libtool could not satisfy all declared inter-library"
 3812         $echo "*** dependencies of module $libname.  Therefore, libtool will create"
 3813         $echo "*** a static module, that should work as long as the dlopening"
 3814         $echo "*** application is linked with the -dlopen flag."
 3815         if test -z "$global_symbol_pipe"; then
 3816           $echo
 3817           $echo "*** However, this would only work if libtool was able to extract symbol"
 3818           $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
 3819           $echo "*** not find such a program.  So, this module is probably useless."
 3820           $echo "*** \`nm' from GNU binutils and a full rebuild may help."
 3821         fi
 3822         if test "$build_old_libs" = no; then
 3823           oldlibs="$output_objdir/$libname.$libext"
 3824           build_libtool_libs=module
 3825           build_old_libs=yes
 3826         else
 3827           build_libtool_libs=no
 3828         fi
 3829       else
 3830         $echo "*** The inter-library dependencies that have been dropped here will be"
 3831         $echo "*** automatically added whenever a program is linked with this library"
 3832         $echo "*** or is declared to -dlopen it."
 3833 
 3834         if test "$allow_undefined" = no; then
 3835           $echo
 3836           $echo "*** Since this library must not contain undefined symbols,"
 3837           $echo "*** because either the platform does not support them or"
 3838           $echo "*** it was explicitly requested with -no-undefined,"
 3839           $echo "*** libtool will only create a static version of it."
 3840           if test "$build_old_libs" = no; then
 3841         oldlibs="$output_objdir/$libname.$libext"
 3842         build_libtool_libs=module
 3843         build_old_libs=yes
 3844           else
 3845         build_libtool_libs=no
 3846           fi
 3847         fi
 3848       fi
 3849     fi
 3850     # Done checking deplibs!
 3851     deplibs=$newdeplibs
 3852       fi
 3853 
 3854 
 3855       # move library search paths that coincide with paths to not yet
 3856       # installed libraries to the beginning of the library search list
 3857       new_libs=
 3858       for path in $notinst_path; do
 3859     case " $new_libs " in
 3860     *" -L$path/$objdir "*) ;;
 3861     *)
 3862       case " $deplibs " in
 3863       *" -L$path/$objdir "*)
 3864         new_libs="$new_libs -L$path/$objdir" ;;
 3865       esac
 3866       ;;
 3867     esac
 3868       done
 3869       for deplib in $deplibs; do
 3870     case $deplib in
 3871     -L*)
 3872       case " $new_libs " in
 3873       *" $deplib "*) ;;
 3874       *) new_libs="$new_libs $deplib" ;;
 3875       esac
 3876       ;;
 3877     *) new_libs="$new_libs $deplib" ;;
 3878     esac
 3879       done
 3880       deplibs="$new_libs"
 3881 
 3882 
 3883       # All the library-specific variables (install_libdir is set above).
 3884       library_names=
 3885       old_library=
 3886       dlname=
 3887 
 3888       # Test again, we may have decided not to build it any more
 3889       if test "$build_libtool_libs" = yes; then
 3890     if test "$hardcode_into_libs" = yes; then
 3891       # Hardcode the library paths
 3892       hardcode_libdirs=
 3893       dep_rpath=
 3894       rpath="$finalize_rpath"
 3895       test "$mode" != relink && rpath="$compile_rpath$rpath"
 3896       for libdir in $rpath; do
 3897         if test -n "$hardcode_libdir_flag_spec"; then
 3898           if test -n "$hardcode_libdir_separator"; then
 3899         if test -z "$hardcode_libdirs"; then
 3900           hardcode_libdirs="$libdir"
 3901         else
 3902           # Just accumulate the unique libdirs.
 3903           case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
 3904           *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 3905             ;;
 3906           *)
 3907             hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 3908             ;;
 3909           esac
 3910         fi
 3911           else
 3912         eval flag=\"$hardcode_libdir_flag_spec\"
 3913         dep_rpath="$dep_rpath $flag"
 3914           fi
 3915         elif test -n "$runpath_var"; then
 3916           case "$perm_rpath " in
 3917           *" $libdir "*) ;;
 3918           *) perm_rpath="$perm_rpath $libdir" ;;
 3919           esac
 3920         fi
 3921       done
 3922       # Substitute the hardcoded libdirs into the rpath.
 3923       if test -n "$hardcode_libdir_separator" &&
 3924          test -n "$hardcode_libdirs"; then
 3925         libdir="$hardcode_libdirs"
 3926         if test -n "$hardcode_libdir_flag_spec_ld"; then
 3927           case $archive_cmds in
 3928           *\$LD*) eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" ;;
 3929           *)      eval dep_rpath=\"$hardcode_libdir_flag_spec\" ;;
 3930           esac
 3931         else
 3932           eval dep_rpath=\"$hardcode_libdir_flag_spec\"
 3933         fi
 3934       fi
 3935       if test -n "$runpath_var" && test -n "$perm_rpath"; then
 3936         # We should set the runpath_var.
 3937         rpath=
 3938         for dir in $perm_rpath; do
 3939           rpath="$rpath$dir:"
 3940         done
 3941         eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
 3942       fi
 3943       test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
 3944     fi
 3945 
 3946     shlibpath="$finalize_shlibpath"
 3947     test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
 3948     if test -n "$shlibpath"; then
 3949       eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
 3950     fi
 3951 
 3952     # Get the real and link names of the library.
 3953     eval shared_ext=\"$shrext_cmds\"
 3954     eval library_names=\"$library_names_spec\"
 3955     set dummy $library_names
 3956     realname="$2"
 3957     shift; shift
 3958 
 3959     if test -n "$soname_spec"; then
 3960       eval soname=\"$soname_spec\"
 3961     else
 3962       soname="$realname"
 3963     fi
 3964     if test -z "$dlname"; then
 3965       dlname=$soname
 3966     fi
 3967 
 3968     lib="$output_objdir/$realname"
 3969     linknames=
 3970     for link
 3971     do
 3972       linknames="$linknames $link"
 3973     done
 3974 
 3975     # Use standard objects if they are pic
 3976     test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 3977 
 3978     # Prepare the list of exported symbols
 3979     if test -z "$export_symbols"; then
 3980       if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
 3981         $show "generating symbol list for \`$libname.la'"
 3982         export_symbols="$output_objdir/$libname.exp"
 3983         $run $rm $export_symbols
 3984         cmds=$export_symbols_cmds
 3985         save_ifs="$IFS"; IFS='~'
 3986         for cmd in $cmds; do
 3987           IFS="$save_ifs"
 3988           eval cmd=\"$cmd\"
 3989           if len=`expr "X$cmd" : ".*"` &&
 3990            test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 3991             $show "$cmd"
 3992             $run eval "$cmd" || exit $?
 3993             skipped_export=false
 3994           else
 3995             # The command line is too long to execute in one step.
 3996             $show "using reloadable object file for export list..."
 3997             skipped_export=:
 3998         # Break out early, otherwise skipped_export may be
 3999         # set to false by a later but shorter cmd.
 4000         break
 4001           fi
 4002         done
 4003         IFS="$save_ifs"
 4004         if test -n "$export_symbols_regex"; then
 4005           $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
 4006           $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
 4007           $show "$mv \"${export_symbols}T\" \"$export_symbols\""
 4008           $run eval '$mv "${export_symbols}T" "$export_symbols"'
 4009         fi
 4010       fi
 4011     fi
 4012 
 4013     if test -n "$export_symbols" && test -n "$include_expsyms"; then
 4014       $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
 4015     fi
 4016 
 4017     tmp_deplibs=
 4018     for test_deplib in $deplibs; do
 4019         case " $convenience " in
 4020         *" $test_deplib "*) ;;
 4021         *)
 4022             tmp_deplibs="$tmp_deplibs $test_deplib"
 4023             ;;
 4024         esac
 4025     done
 4026     deplibs="$tmp_deplibs"
 4027 
 4028     if test -n "$convenience"; then
 4029       if test -n "$whole_archive_flag_spec"; then
 4030         save_libobjs=$libobjs
 4031         eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 4032       else
 4033         gentop="$output_objdir/${outputname}x"
 4034         generated="$generated $gentop"
 4035 
 4036         func_extract_archives $gentop $convenience
 4037         libobjs="$libobjs $func_extract_archives_result"
 4038       fi
 4039     fi
 4040     
 4041     if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
 4042       eval flag=\"$thread_safe_flag_spec\"
 4043       linker_flags="$linker_flags $flag"
 4044     fi
 4045 
 4046     # Make a backup of the uninstalled library when relinking
 4047     if test "$mode" = relink; then
 4048       $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
 4049     fi
 4050 
 4051     # Do each of the archive commands.
 4052     if test "$module" = yes && test -n "$module_cmds" ; then
 4053       if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
 4054         eval test_cmds=\"$module_expsym_cmds\"
 4055         cmds=$module_expsym_cmds
 4056       else
 4057         eval test_cmds=\"$module_cmds\"
 4058         cmds=$module_cmds
 4059       fi
 4060     else
 4061     if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
 4062       eval test_cmds=\"$archive_expsym_cmds\"
 4063       cmds=$archive_expsym_cmds
 4064     else
 4065       eval test_cmds=\"$archive_cmds\"
 4066       cmds=$archive_cmds
 4067       fi
 4068     fi
 4069 
 4070     if test "X$skipped_export" != "X:" &&
 4071        len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
 4072        test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 4073       :
 4074     else
 4075       # The command line is too long to link in one step, link piecewise.
 4076       $echo "creating reloadable object files..."
 4077 
 4078       # Save the value of $output and $libobjs because we want to
 4079       # use them later.  If we have whole_archive_flag_spec, we
 4080       # want to use save_libobjs as it was before
 4081       # whole_archive_flag_spec was expanded, because we can't
 4082       # assume the linker understands whole_archive_flag_spec.
 4083       # This may have to be revisited, in case too many
 4084       # convenience libraries get linked in and end up exceeding
 4085       # the spec.
 4086       if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
 4087         save_libobjs=$libobjs
 4088       fi
 4089       save_output=$output
 4090       output_la=`$echo "X$output" | $Xsed -e "$basename"`
 4091 
 4092       # Clear the reloadable object creation command queue and
 4093       # initialize k to one.
 4094       test_cmds=
 4095       concat_cmds=
 4096       objlist=
 4097       delfiles=
 4098       last_robj=
 4099       k=1
 4100       output=$output_objdir/$output_la-${k}.$objext
 4101       # Loop over the list of objects to be linked.
 4102       for obj in $save_libobjs
 4103       do
 4104         eval test_cmds=\"$reload_cmds $objlist $last_robj\"
 4105         if test "X$objlist" = X ||
 4106            { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
 4107          test "$len" -le "$max_cmd_len"; }; then
 4108           objlist="$objlist $obj"
 4109         else
 4110           # The command $test_cmds is almost too long, add a
 4111           # command to the queue.
 4112           if test "$k" -eq 1 ; then
 4113         # The first file doesn't have a previous command to add.
 4114         eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
 4115           else
 4116         # All subsequent reloadable object files will link in
 4117         # the last one created.
 4118         eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
 4119           fi
 4120           last_robj=$output_objdir/$output_la-${k}.$objext
 4121           k=`expr $k + 1`
 4122           output=$output_objdir/$output_la-${k}.$objext
 4123           objlist=$obj
 4124           len=1
 4125         fi
 4126       done
 4127       # Handle the remaining objects by creating one last
 4128       # reloadable object file.  All subsequent reloadable object
 4129       # files will link in the last one created.
 4130       test -z "$concat_cmds" || concat_cmds=$concat_cmds~
 4131       eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
 4132 
 4133       if ${skipped_export-false}; then
 4134         $show "generating symbol list for \`$libname.la'"
 4135         export_symbols="$output_objdir/$libname.exp"
 4136         $run $rm $export_symbols
 4137         libobjs=$output
 4138         # Append the command to create the export file.
 4139         eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
 4140           fi
 4141 
 4142       # Set up a command to remove the reloadable object files
 4143       # after they are used.
 4144       i=0
 4145       while test "$i" -lt "$k"
 4146       do
 4147         i=`expr $i + 1`
 4148         delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
 4149       done
 4150 
 4151       $echo "creating a temporary reloadable object file: $output"
 4152 
 4153       # Loop through the commands generated above and execute them.
 4154       save_ifs="$IFS"; IFS='~'
 4155       for cmd in $concat_cmds; do
 4156         IFS="$save_ifs"
 4157         $show "$cmd"
 4158         $run eval "$cmd" || exit $?
 4159       done
 4160       IFS="$save_ifs"
 4161 
 4162       libobjs=$output
 4163       # Restore the value of output.
 4164       output=$save_output
 4165 
 4166       if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
 4167         eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 4168       fi
 4169       # Expand the library linking commands again to reset the
 4170       # value of $libobjs for piecewise linking.
 4171 
 4172       # Do each of the archive commands.
 4173       if test "$module" = yes && test -n "$module_cmds" ; then
 4174         if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
 4175           cmds=$module_expsym_cmds
 4176         else
 4177           cmds=$module_cmds
 4178         fi
 4179       else
 4180       if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
 4181         cmds=$archive_expsym_cmds
 4182       else
 4183         cmds=$archive_cmds
 4184         fi
 4185       fi
 4186 
 4187       # Append the command to remove the reloadable object files
 4188       # to the just-reset $cmds.
 4189       eval cmds=\"\$cmds~\$rm $delfiles\"
 4190     fi
 4191     save_ifs="$IFS"; IFS='~'
 4192     for cmd in $cmds; do
 4193       IFS="$save_ifs"
 4194       eval cmd=\"$cmd\"
 4195       $show "$cmd"
 4196       $run eval "$cmd" || {
 4197         lt_exit=$?
 4198 
 4199         # Restore the uninstalled library and exit
 4200         if test "$mode" = relink; then
 4201           $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
 4202         fi
 4203 
 4204         exit $lt_exit
 4205       }
 4206     done
 4207     IFS="$save_ifs"
 4208 
 4209     # Restore the uninstalled library and exit
 4210     if test "$mode" = relink; then
 4211       $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
 4212 
 4213       if test -n "$convenience"; then
 4214         if test -z "$whole_archive_flag_spec"; then
 4215           $show "${rm}r $gentop"
 4216           $run ${rm}r "$gentop"
 4217         fi
 4218       fi
 4219 
 4220       exit $EXIT_SUCCESS
 4221     fi
 4222 
 4223     # Create links to the real library.
 4224     for linkname in $linknames; do
 4225       if test "$realname" != "$linkname"; then
 4226         $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
 4227         $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
 4228       fi
 4229     done
 4230 
 4231     # If -module or -export-dynamic was specified, set the dlname.
 4232     if test "$module" = yes || test "$export_dynamic" = yes; then
 4233       # On all known operating systems, these are identical.
 4234       dlname="$soname"
 4235     fi
 4236       fi
 4237       ;;
 4238 
 4239     obj)
 4240       if test -n "$deplibs"; then
 4241     $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
 4242       fi
 4243 
 4244       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
 4245     $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
 4246       fi
 4247 
 4248       if test -n "$rpath"; then
 4249     $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
 4250       fi
 4251 
 4252       if test -n "$xrpath"; then
 4253     $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
 4254       fi
 4255 
 4256       if test -n "$vinfo"; then
 4257     $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
 4258       fi
 4259 
 4260       if test -n "$release"; then
 4261     $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
 4262       fi
 4263 
 4264       case $output in
 4265       *.lo)
 4266     if test -n "$objs$old_deplibs"; then
 4267       $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
 4268       exit $EXIT_FAILURE
 4269     fi
 4270     libobj="$output"
 4271     obj=`$echo "X$output" | $Xsed -e "$lo2o"`
 4272     ;;
 4273       *)
 4274     libobj=
 4275     obj="$output"
 4276     ;;
 4277       esac
 4278 
 4279       # Delete the old objects.
 4280       $run $rm $obj $libobj
 4281 
 4282       # Objects from convenience libraries.  This assumes
 4283       # single-version convenience libraries.  Whenever we create
 4284       # different ones for PIC/non-PIC, this we'll have to duplicate
 4285       # the extraction.
 4286       reload_conv_objs=
 4287       gentop=
 4288       # reload_cmds runs $LD directly, so let us get rid of
 4289       # -Wl from whole_archive_flag_spec and hope we can get by with
 4290       # turning comma into space..
 4291       wl=
 4292 
 4293       if test -n "$convenience"; then
 4294     if test -n "$whole_archive_flag_spec"; then
 4295       eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
 4296       reload_conv_objs=$reload_objs\ `$echo "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
 4297     else
 4298       gentop="$output_objdir/${obj}x"
 4299       generated="$generated $gentop"
 4300 
 4301       func_extract_archives $gentop $convenience
 4302       reload_conv_objs="$reload_objs $func_extract_archives_result"
 4303     fi
 4304       fi
 4305 
 4306       # Create the old-style object.
 4307       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
 4308 
 4309       output="$obj"
 4310       cmds=$reload_cmds
 4311       save_ifs="$IFS"; IFS='~'
 4312       for cmd in $cmds; do
 4313     IFS="$save_ifs"
 4314     eval cmd=\"$cmd\"
 4315     $show "$cmd"
 4316     $run eval "$cmd" || exit $?
 4317       done
 4318       IFS="$save_ifs"
 4319 
 4320       # Exit if we aren't doing a library object file.
 4321       if test -z "$libobj"; then
 4322     if test -n "$gentop"; then
 4323       $show "${rm}r $gentop"
 4324       $run ${rm}r $gentop
 4325     fi
 4326 
 4327     exit $EXIT_SUCCESS
 4328       fi
 4329 
 4330       if test "$build_libtool_libs" != yes; then
 4331     if test -n "$gentop"; then
 4332       $show "${rm}r $gentop"
 4333       $run ${rm}r $gentop
 4334     fi
 4335 
 4336     # Create an invalid libtool object if no PIC, so that we don't
 4337     # accidentally link it into a program.
 4338     # $show "echo timestamp > $libobj"
 4339     # $run eval "echo timestamp > $libobj" || exit $?
 4340     exit $EXIT_SUCCESS
 4341       fi
 4342 
 4343       if test -n "$pic_flag" || test "$pic_mode" != default; then
 4344     # Only do commands if we really have different PIC objects.
 4345     reload_objs="$libobjs $reload_conv_objs"
 4346     output="$libobj"
 4347     cmds=$reload_cmds
 4348     save_ifs="$IFS"; IFS='~'
 4349     for cmd in $cmds; do
 4350       IFS="$save_ifs"
 4351       eval cmd=\"$cmd\"
 4352       $show "$cmd"
 4353       $run eval "$cmd" || exit $?
 4354     done
 4355     IFS="$save_ifs"
 4356       fi
 4357 
 4358       if test -n "$gentop"; then
 4359     $show "${rm}r $gentop"
 4360     $run ${rm}r $gentop
 4361       fi
 4362 
 4363       exit $EXIT_SUCCESS
 4364       ;;
 4365 
 4366     prog)
 4367       case $host in
 4368     *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
 4369       esac
 4370       if test -n "$vinfo"; then
 4371     $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
 4372       fi
 4373 
 4374       if test -n "$release"; then
 4375     $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
 4376       fi
 4377 
 4378       if test "$preload" = yes; then
 4379     if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
 4380        test "$dlopen_self_static" = unknown; then
 4381       $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
 4382     fi
 4383       fi
 4384 
 4385       case $host in
 4386       *-*-rhapsody* | *-*-darwin1.[012])
 4387     # On Rhapsody replace the C library is the System framework
 4388     compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
 4389     finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
 4390     ;;
 4391       esac
 4392 
 4393       case $host in
 4394       *darwin*)
 4395         # Don't allow lazy linking, it breaks C++ global constructors
 4396         if test "$tagname" = CXX ; then
 4397         compile_command="$compile_command ${wl}-bind_at_load"
 4398         finalize_command="$finalize_command ${wl}-bind_at_load"
 4399         fi
 4400         ;;
 4401       esac
 4402 
 4403 
 4404       # move library search paths that coincide with paths to not yet
 4405       # installed libraries to the beginning of the library search list
 4406       new_libs=
 4407       for path in $notinst_path; do
 4408     case " $new_libs " in
 4409     *" -L$path/$objdir "*) ;;
 4410     *)
 4411       case " $compile_deplibs " in
 4412       *" -L$path/$objdir "*)
 4413         new_libs="$new_libs -L$path/$objdir" ;;
 4414       esac
 4415       ;;
 4416     esac
 4417       done
 4418       for deplib in $compile_deplibs; do
 4419     case $deplib in
 4420     -L*)
 4421       case " $new_libs " in
 4422       *" $deplib "*) ;;
 4423       *) new_libs="$new_libs $deplib" ;;
 4424       esac
 4425       ;;
 4426     *) new_libs="$new_libs $deplib" ;;
 4427     esac
 4428       done
 4429       compile_deplibs="$new_libs"
 4430 
 4431 
 4432       compile_command="$compile_command $compile_deplibs"
 4433       finalize_command="$finalize_command $finalize_deplibs"
 4434 
 4435       if test -n "$rpath$xrpath"; then
 4436     # If the user specified any rpath flags, then add them.
 4437     for libdir in $rpath $xrpath; do
 4438       # This is the magic to use -rpath.
 4439       case "$finalize_rpath " in
 4440       *" $libdir "*) ;;
 4441       *) finalize_rpath="$finalize_rpath $libdir" ;;
 4442       esac
 4443     done
 4444       fi
 4445 
 4446       # Now hardcode the library paths
 4447       rpath=
 4448       hardcode_libdirs=
 4449       for libdir in $compile_rpath $finalize_rpath; do
 4450     if test -n "$hardcode_libdir_flag_spec"; then
 4451       if test -n "$hardcode_libdir_separator"; then
 4452         if test -z "$hardcode_libdirs"; then
 4453           hardcode_libdirs="$libdir"
 4454         else
 4455           # Just accumulate the unique libdirs.
 4456           case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
 4457           *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 4458         ;;
 4459           *)
 4460         hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 4461         ;;
 4462           esac
 4463         fi
 4464       else
 4465         eval flag=\"$hardcode_libdir_flag_spec\"
 4466         rpath="$rpath $flag"
 4467       fi
 4468     elif test -n "$runpath_var"; then
 4469       case "$perm_rpath " in
 4470       *" $libdir "*) ;;
 4471       *) perm_rpath="$perm_rpath $libdir" ;;
 4472       esac
 4473     fi
 4474     case $host in
 4475     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 4476       testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
 4477       case :$dllsearchpath: in
 4478       *":$libdir:"*) ;;
 4479       *) dllsearchpath="$dllsearchpath:$libdir";;
 4480       esac
 4481       case :$dllsearchpath: in
 4482       *":$testbindir:"*) ;;
 4483       *) dllsearchpath="$dllsearchpath:$testbindir";;
 4484       esac
 4485       ;;
 4486     esac
 4487       done
 4488       # Substitute the hardcoded libdirs into the rpath.
 4489       if test -n "$hardcode_libdir_separator" &&
 4490      test -n "$hardcode_libdirs"; then
 4491     libdir="$hardcode_libdirs"
 4492     eval rpath=\" $hardcode_libdir_flag_spec\"
 4493       fi
 4494       compile_rpath="$rpath"
 4495 
 4496       rpath=
 4497       hardcode_libdirs=
 4498       for libdir in $finalize_rpath; do
 4499     if test -n "$hardcode_libdir_flag_spec"; then
 4500       if test -n "$hardcode_libdir_separator"; then
 4501         if test -z "$hardcode_libdirs"; then
 4502           hardcode_libdirs="$libdir"
 4503         else
 4504           # Just accumulate the unique libdirs.
 4505           case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
 4506           *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 4507         ;;
 4508           *)
 4509         hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 4510         ;;
 4511           esac
 4512         fi
 4513       else
 4514         eval flag=\"$hardcode_libdir_flag_spec\"
 4515         rpath="$rpath $flag"
 4516       fi
 4517     elif test -n "$runpath_var"; then
 4518       case "$finalize_perm_rpath " in
 4519       *" $libdir "*) ;;
 4520       *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
 4521       esac
 4522     fi
 4523       done
 4524       # Substitute the hardcoded libdirs into the rpath.
 4525       if test -n "$hardcode_libdir_separator" &&
 4526      test -n "$hardcode_libdirs"; then
 4527     libdir="$hardcode_libdirs"
 4528     eval rpath=\" $hardcode_libdir_flag_spec\"
 4529       fi
 4530       finalize_rpath="$rpath"
 4531 
 4532       if test -n "$libobjs" && test "$build_old_libs" = yes; then
 4533     # Transform all the library objects into standard objects.
 4534     compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 4535     finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 4536       fi
 4537 
 4538       dlsyms=
 4539       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
 4540     if test -n "$NM" && test -n "$global_symbol_pipe"; then
 4541       dlsyms="${outputname}S.c"
 4542     else
 4543       $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
 4544     fi
 4545       fi
 4546 
 4547       if test -n "$dlsyms"; then
 4548     case $dlsyms in
 4549     "") ;;
 4550     *.c)
 4551       # Discover the nlist of each of the dlfiles.
 4552       nlist="$output_objdir/${outputname}.nm"
 4553 
 4554       $show "$rm $nlist ${nlist}S ${nlist}T"
 4555       $run $rm "$nlist" "${nlist}S" "${nlist}T"
 4556 
 4557       # Parse the name list into a source file.
 4558       $show "creating $output_objdir/$dlsyms"
 4559 
 4560       test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
 4561 /* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
 4562 /* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
 4563 
 4564 #ifdef __cplusplus
 4565 extern \"C\" {
 4566 #endif
 4567 
 4568 /* Prevent the only kind of declaration conflicts we can make. */
 4569 #define lt_preloaded_symbols some_other_symbol
 4570 
 4571 /* External symbol declarations for the compiler. */\
 4572 "
 4573 
 4574       if test "$dlself" = yes; then
 4575         $show "generating symbol list for \`$output'"
 4576 
 4577         test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
 4578 
 4579         # Add our own program objects to the symbol list.
 4580         progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 4581         for arg in $progfiles; do
 4582           $show "extracting global C symbols from \`$arg'"
 4583           $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
 4584         done
 4585 
 4586         if test -n "$exclude_expsyms"; then
 4587           $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
 4588           $run eval '$mv "$nlist"T "$nlist"'
 4589         fi
 4590 
 4591         if test -n "$export_symbols_regex"; then
 4592           $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
 4593           $run eval '$mv "$nlist"T "$nlist"'
 4594         fi
 4595 
 4596         # Prepare the list of exported symbols
 4597         if test -z "$export_symbols"; then
 4598           export_symbols="$output_objdir/$outputname.exp"
 4599           $run $rm $export_symbols
 4600           $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
 4601               case $host in
 4602               *cygwin* | *mingw* )
 4603             $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
 4604         $run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
 4605                 ;;
 4606               esac
 4607         else
 4608           $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
 4609           $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
 4610           $run eval 'mv "$nlist"T "$nlist"'
 4611               case $host in
 4612               *cygwin* | *mingw* )
 4613             $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
 4614         $run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
 4615                 ;;
 4616               esac
 4617         fi
 4618       fi
 4619 
 4620       for arg in $dlprefiles; do
 4621         $show "extracting global C symbols from \`$arg'"
 4622         name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
 4623         $run eval '$echo ": $name " >> "$nlist"'
 4624         $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
 4625       done
 4626 
 4627       if test -z "$run"; then
 4628         # Make sure we have at least an empty file.
 4629         test -f "$nlist" || : > "$nlist"
 4630 
 4631         if test -n "$exclude_expsyms"; then
 4632           $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
 4633           $mv "$nlist"T "$nlist"
 4634         fi
 4635 
 4636         # Try sorting and uniquifying the output.
 4637         if grep -v "^: " < "$nlist" |
 4638         if sort -k 3 </dev/null >/dev/null 2>&1; then
 4639           sort -k 3
 4640         else
 4641           sort +2
 4642         fi |
 4643         uniq > "$nlist"S; then
 4644           :
 4645         else
 4646           grep -v "^: " < "$nlist" > "$nlist"S
 4647         fi
 4648 
 4649         if test -f "$nlist"S; then
 4650           eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
 4651         else
 4652           $echo '/* NONE */' >> "$output_objdir/$dlsyms"
 4653         fi
 4654 
 4655         $echo >> "$output_objdir/$dlsyms" "\
 4656 
 4657 #undef lt_preloaded_symbols
 4658 
 4659 #if defined (__STDC__) && __STDC__
 4660 # define lt_ptr void *
 4661 #else
 4662 # define lt_ptr char *
 4663 # define const
 4664 #endif
 4665 
 4666 /* The mapping between symbol names and symbols. */
 4667 "
 4668 
 4669         case $host in
 4670         *cygwin* | *mingw* )
 4671       $echo >> "$output_objdir/$dlsyms" "\
 4672 /* DATA imports from DLLs on WIN32 can't be const, because
 4673    runtime relocations are performed -- see ld's documentation
 4674    on pseudo-relocs */
 4675 struct {
 4676 "
 4677           ;;
 4678         * )
 4679       $echo >> "$output_objdir/$dlsyms" "\
 4680 const struct {
 4681 "
 4682           ;;
 4683         esac
 4684 
 4685 
 4686       $echo >> "$output_objdir/$dlsyms" "\
 4687   const char *name;
 4688   lt_ptr address;
 4689 }
 4690 lt_preloaded_symbols[] =
 4691 {\
 4692 "
 4693 
 4694         eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
 4695 
 4696         $echo >> "$output_objdir/$dlsyms" "\
 4697   {0, (lt_ptr) 0}
 4698 };
 4699 
 4700 /* This works around a problem in FreeBSD linker */
 4701 #ifdef FREEBSD_WORKAROUND
 4702 static const void *lt_preloaded_setup() {
 4703   return lt_preloaded_symbols;
 4704 }
 4705 #endif
 4706 
 4707 #ifdef __cplusplus
 4708 }
 4709 #endif\
 4710 "
 4711       fi
 4712 
 4713       pic_flag_for_symtable=
 4714       case $host in
 4715       # compiling the symbol table file with pic_flag works around
 4716       # a FreeBSD bug that causes programs to crash when -lm is
 4717       # linked before any other PIC object.  But we must not use
 4718       # pic_flag when linking with -static.  The problem exists in
 4719       # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
 4720       *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
 4721         case "$compile_command " in
 4722         *" -static "*) ;;
 4723         *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
 4724         esac;;
 4725       *-*-hpux*)
 4726         case "$compile_command " in
 4727         *" -static "*) ;;
 4728         *) pic_flag_for_symtable=" $pic_flag";;
 4729         esac
 4730       esac
 4731 
 4732       # Now compile the dynamic symbol file.
 4733       $show "(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
 4734       $run eval '(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
 4735 
 4736       # Clean up the generated files.
 4737       $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
 4738       $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
 4739 
 4740       # Transform the symbol file into the correct name.
 4741           case $host in
 4742           *cygwin* | *mingw* )
 4743             if test -f "$output_objdir/${outputname}.def" ; then
 4744               compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4745               finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4746             else
 4747               compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4748               finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4749              fi
 4750             ;;
 4751           * )
 4752             compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4753             finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
 4754             ;;
 4755           esac
 4756       ;;
 4757     *)
 4758       $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
 4759       exit $EXIT_FAILURE
 4760       ;;
 4761     esac
 4762       else
 4763     # We keep going just in case the user didn't refer to
 4764     # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
 4765     # really was required.
 4766 
 4767     # Nullify the symbol file.
 4768     compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
 4769     finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
 4770       fi
 4771 
 4772       if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
 4773     # Replace the output file specification.
 4774     compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$output"'%g' | $NL2SP`
 4775     link_command="$compile_command$compile_rpath"
 4776 
 4777     # We have no uninstalled library dependencies, so finalize right now.
 4778     $show "$link_command"
 4779     $run eval "$link_command"
 4780     exit_status=$?
 4781 
 4782     # Delete the generated files.
 4783     if test -n "$dlsyms"; then
 4784       $show "$rm $output_objdir/${outputname}S.${objext}"
 4785       $run $rm "$output_objdir/${outputname}S.${objext}"
 4786     fi
 4787 
 4788     exit $exit_status
 4789       fi
 4790 
 4791       if test -n "$shlibpath_var"; then
 4792     # We should set the shlibpath_var
 4793     rpath=
 4794     for dir in $temp_rpath; do
 4795       case $dir in
 4796       [\\/]* | [A-Za-z]:[\\/]*)
 4797         # Absolute path.
 4798         rpath="$rpath$dir:"
 4799         ;;
 4800       *)
 4801         # Relative path: add a thisdir entry.
 4802         rpath="$rpath\$thisdir/$dir:"
 4803         ;;
 4804       esac
 4805     done
 4806     temp_rpath="$rpath"
 4807       fi
 4808 
 4809       if test -n "$compile_shlibpath$finalize_shlibpath"; then
 4810     compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
 4811       fi
 4812       if test -n "$finalize_shlibpath"; then
 4813     finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
 4814       fi
 4815 
 4816       compile_var=
 4817       finalize_var=
 4818       if test -n "$runpath_var"; then
 4819     if test -n "$perm_rpath"; then
 4820       # We should set the runpath_var.
 4821       rpath=
 4822       for dir in $perm_rpath; do
 4823         rpath="$rpath$dir:"
 4824       done
 4825       compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
 4826     fi
 4827     if test -n "$finalize_perm_rpath"; then
 4828       # We should set the runpath_var.
 4829       rpath=
 4830       for dir in $finalize_perm_rpath; do
 4831         rpath="$rpath$dir:"
 4832       done
 4833       finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
 4834     fi
 4835       fi
 4836 
 4837       if test "$no_install" = yes; then
 4838     # We don't need to create a wrapper script.
 4839     link_command="$compile_var$compile_command$compile_rpath"
 4840     # Replace the output file specification.
 4841     link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
 4842     # Delete the old output file.
 4843     $run $rm $output
 4844     # Link the executable and exit
 4845     $show "$link_command"
 4846     $run eval "$link_command" || exit $?
 4847     exit $EXIT_SUCCESS
 4848       fi
 4849 
 4850       if test "$hardcode_action" = relink; then
 4851     # Fast installation is not supported
 4852     link_command="$compile_var$compile_command$compile_rpath"
 4853     relink_command="$finalize_var$finalize_command$finalize_rpath"
 4854 
 4855     $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
 4856     $echo "$modename: \`$output' will be relinked during installation" 1>&2
 4857       else
 4858     if test "$fast_install" != no; then
 4859       link_command="$finalize_var$compile_command$finalize_rpath"
 4860       if test "$fast_install" = yes; then
 4861         relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $SP2NL | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g' | $NL2SP`
 4862       else
 4863         # fast_install is set to needless
 4864         relink_command=
 4865       fi
 4866     else
 4867       link_command="$compile_var$compile_command$compile_rpath"
 4868       relink_command="$finalize_var$finalize_command$finalize_rpath"
 4869     fi
 4870       fi
 4871 
 4872       # Replace the output file specification.
 4873       link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
 4874 
 4875       # Delete the old output files.
 4876       $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
 4877 
 4878       $show "$link_command"
 4879       $run eval "$link_command" || exit $?
 4880 
 4881       # Now create the wrapper script.
 4882       $show "creating $output"
 4883 
 4884       # Quote the relink command for shipping.
 4885       if test -n "$relink_command"; then
 4886     # Preserve any variables that may affect compiler behavior
 4887     for var in $variables_saved_for_relink; do
 4888       if eval test -z \"\${$var+set}\"; then
 4889         relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
 4890       elif eval var_value=\$$var; test -z "$var_value"; then
 4891         relink_command="$var=; export $var; $relink_command"
 4892       else
 4893         var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
 4894         relink_command="$var=\"$var_value\"; export $var; $relink_command"
 4895       fi
 4896     done
 4897     relink_command="(cd `pwd`; $relink_command)"
 4898     relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
 4899       fi
 4900 
 4901       # Quote $echo for shipping.
 4902       if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
 4903     case $progpath in
 4904     [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
 4905     *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
 4906     esac
 4907     qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
 4908       else
 4909     qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
 4910       fi
 4911 
 4912       # Only actually do things if our run command is non-null.
 4913       if test -z "$run"; then
 4914     # win32 will think the script is a binary if it has
 4915     # a .exe suffix, so we strip it off here.
 4916     case $output in
 4917       *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
 4918     esac
 4919     # test for cygwin because mv fails w/o .exe extensions
 4920     case $host in
 4921       *cygwin*)
 4922         exeext=.exe
 4923         outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
 4924       *) exeext= ;;
 4925     esac
 4926     case $host in
 4927       *cygwin* | *mingw* )
 4928             output_name=`basename $output`
 4929             output_path=`dirname $output`
 4930             cwrappersource="$output_path/$objdir/lt-$output_name.c"
 4931             cwrapper="$output_path/$output_name.exe"
 4932             $rm $cwrappersource $cwrapper
 4933             trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
 4934 
 4935         cat > $cwrappersource <<EOF
 4936 
 4937 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
 4938    Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 4939 
 4940    The $output program cannot be directly executed until all the libtool
 4941    libraries that it depends on are installed.
 4942 
 4943    This wrapper executable should never be moved out of the build directory.
 4944    If it is, it will not operate correctly.
 4945 
 4946    Currently, it simply execs the wrapper *script* "/bin/sh $output",
 4947    but could eventually absorb all of the scripts functionality and
 4948    exec $objdir/$outputname directly.
 4949 */
 4950 EOF
 4951         cat >> $cwrappersource<<"EOF"
 4952 #include <stdio.h>
 4953 #include <stdlib.h>
 4954 #include <unistd.h>
 4955 #include <malloc.h>
 4956 #include <stdarg.h>
 4957 #include <assert.h>
 4958 #include <string.h>
 4959 #include <ctype.h>
 4960 #include <sys/stat.h>
 4961 
 4962 #if defined(PATH_MAX)
 4963 # define LT_PATHMAX PATH_MAX
 4964 #elif defined(MAXPATHLEN)
 4965 # define LT_PATHMAX MAXPATHLEN
 4966 #else
 4967 # define LT_PATHMAX 1024
 4968 #endif
 4969 
 4970 #ifndef DIR_SEPARATOR
 4971 # define DIR_SEPARATOR '/'
 4972 # define PATH_SEPARATOR ':'
 4973 #endif
 4974 
 4975 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
 4976   defined (__OS2__)
 4977 # define HAVE_DOS_BASED_FILE_SYSTEM
 4978 # ifndef DIR_SEPARATOR_2
 4979 #  define DIR_SEPARATOR_2 '\\'
 4980 # endif
 4981 # ifndef PATH_SEPARATOR_2
 4982 #  define PATH_SEPARATOR_2 ';'
 4983 # endif
 4984 #endif
 4985 
 4986 #ifndef DIR_SEPARATOR_2
 4987 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
 4988 #else /* DIR_SEPARATOR_2 */
 4989 # define IS_DIR_SEPARATOR(ch) \
 4990         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
 4991 #endif /* DIR_SEPARATOR_2 */
 4992 
 4993 #ifndef PATH_SEPARATOR_2
 4994 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
 4995 #else /* PATH_SEPARATOR_2 */
 4996 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
 4997 #endif /* PATH_SEPARATOR_2 */
 4998 
 4999 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
 5000 #define XFREE(stale) do { \
 5001   if (stale) { free ((void *) stale); stale = 0; } \
 5002 } while (0)
 5003 
 5004 /* -DDEBUG is fairly common in CFLAGS.  */
 5005 #undef DEBUG
 5006 #if defined DEBUGWRAPPER
 5007 # define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
 5008 #else
 5009 # define DEBUG(format, ...)
 5010 #endif
 5011 
 5012 const char *program_name = NULL;
 5013 
 5014 void * xmalloc (size_t num);
 5015 char * xstrdup (const char *string);
 5016 const char * base_name (const char *name);
 5017 char * find_executable(const char *wrapper);
 5018 int    check_executable(const char *path);
 5019 char * strendzap(char *str, const char *pat);
 5020 void lt_fatal (const char *message, ...);
 5021 
 5022 int
 5023 main (int argc, char *argv[])
 5024 {
 5025   char **newargz;
 5026   int i;
 5027 
 5028   program_name = (char *) xstrdup (base_name (argv[0]));
 5029   DEBUG("(main) argv[0]      : %s\n",argv[0]);
 5030   DEBUG("(main) program_name : %s\n",program_name);
 5031   newargz = XMALLOC(char *, argc+2);
 5032 EOF
 5033 
 5034             cat >> $cwrappersource <<EOF
 5035   newargz[0] = (char *) xstrdup("$SHELL");
 5036 EOF
 5037 
 5038             cat >> $cwrappersource <<"EOF"
 5039   newargz[1] = find_executable(argv[0]);
 5040   if (newargz[1] == NULL)
 5041     lt_fatal("Couldn't find %s", argv[0]);
 5042   DEBUG("(main) found exe at : %s\n",newargz[1]);
 5043   /* we know the script has the same name, without the .exe */
 5044   /* so make sure newargz[1] doesn't end in .exe */
 5045   strendzap(newargz[1],".exe");
 5046   for (i = 1; i < argc; i++)
 5047     newargz[i+1] = xstrdup(argv[i]);
 5048   newargz[argc+1] = NULL;
 5049 
 5050   for (i=0; i<argc+1; i++)
 5051   {
 5052     DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
 5053     ;
 5054   }
 5055 
 5056 EOF
 5057 
 5058             case $host_os in
 5059               mingw*)
 5060                 cat >> $cwrappersource <<EOF
 5061   execv("$SHELL",(char const **)newargz);
 5062 EOF
 5063               ;;
 5064               *)
 5065                 cat >> $cwrappersource <<EOF
 5066   execv("$SHELL",newargz);
 5067 EOF
 5068               ;;
 5069             esac
 5070 
 5071             cat >> $cwrappersource <<"EOF"
 5072   return 127;
 5073 }
 5074 
 5075 void *
 5076 xmalloc (size_t num)
 5077 {
 5078   void * p = (void *) malloc (num);
 5079   if (!p)
 5080     lt_fatal ("Memory exhausted");
 5081 
 5082   return p;
 5083 }
 5084 
 5085 char *
 5086 xstrdup (const char *string)
 5087 {
 5088   return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
 5089 ;
 5090 }
 5091 
 5092 const char *
 5093 base_name (const char *name)
 5094 {
 5095   const char *base;
 5096 
 5097 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 5098   /* Skip over the disk name in MSDOS pathnames. */
 5099   if (isalpha ((unsigned char)name[0]) && name[1] == ':')
 5100     name += 2;
 5101 #endif
 5102 
 5103   for (base = name; *name; name++)
 5104     if (IS_DIR_SEPARATOR (*name))
 5105       base = name + 1;
 5106   return base;
 5107 }
 5108 
 5109 int
 5110 check_executable(const char * path)
 5111 {
 5112   struct stat st;
 5113 
 5114   DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
 5115   if ((!path) || (!*path))
 5116     return 0;
 5117 
 5118   if ((stat (path, &st) >= 0) &&
 5119       (
 5120         /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
 5121 #if defined (S_IXOTH)
 5122        ((st.st_mode & S_IXOTH) == S_IXOTH) ||
 5123 #endif
 5124 #if defined (S_IXGRP)
 5125        ((st.st_mode & S_IXGRP) == S_IXGRP) ||
 5126 #endif
 5127        ((st.st_mode & S_IXUSR) == S_IXUSR))
 5128       )
 5129     return 1;
 5130   else
 5131     return 0;
 5132 }
 5133 
 5134 /* Searches for the full path of the wrapper.  Returns
 5135    newly allocated full path name if found, NULL otherwise */
 5136 char *
 5137 find_executable (const char* wrapper)
 5138 {
 5139   int has_slash = 0;
 5140   const char* p;
 5141   const char* p_next;
 5142   /* static buffer for getcwd */
 5143   char tmp[LT_PATHMAX + 1];
 5144   int tmp_len;
 5145   char* concat_name;
 5146 
 5147   DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
 5148 
 5149   if ((wrapper == NULL) || (*wrapper == '\0'))
 5150     return NULL;
 5151 
 5152   /* Absolute path? */
 5153 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 5154   if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
 5155   {
 5156     concat_name = xstrdup (wrapper);
 5157     if (check_executable(concat_name))
 5158       return concat_name;
 5159     XFREE(concat_name);
 5160   }
 5161   else
 5162   {
 5163 #endif
 5164     if (IS_DIR_SEPARATOR (wrapper[0]))
 5165     {
 5166       concat_name = xstrdup (wrapper);
 5167       if (check_executable(concat_name))
 5168         return concat_name;
 5169       XFREE(concat_name);
 5170     }
 5171 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 5172   }
 5173 #endif
 5174 
 5175   for (p = wrapper; *p; p++)
 5176     if (*p == '/')
 5177     {
 5178       has_slash = 1;
 5179       break;
 5180     }
 5181   if (!has_slash)
 5182   {
 5183     /* no slashes; search PATH */
 5184     const char* path = getenv ("PATH");
 5185     if (path != NULL)
 5186     {
 5187       for (p = path; *p; p = p_next)
 5188       {
 5189         const char* q;
 5190         size_t p_len;
 5191         for (q = p; *q; q++)
 5192           if (IS_PATH_SEPARATOR(*q))
 5193             break;
 5194         p_len = q - p;
 5195         p_next = (*q == '\0' ? q : q + 1);
 5196         if (p_len == 0)
 5197         {
 5198           /* empty path: current directory */
 5199           if (getcwd (tmp, LT_PATHMAX) == NULL)
 5200             lt_fatal ("getcwd failed");
 5201           tmp_len = strlen(tmp);
 5202           concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
 5203           memcpy (concat_name, tmp, tmp_len);
 5204           concat_name[tmp_len] = '/';
 5205           strcpy (concat_name + tmp_len + 1, wrapper);
 5206         }
 5207         else
 5208         {
 5209           concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
 5210           memcpy (concat_name, p, p_len);
 5211           concat_name[p_len] = '/';
 5212           strcpy (concat_name + p_len + 1, wrapper);
 5213         }
 5214         if (check_executable(concat_name))
 5215           return concat_name;
 5216         XFREE(concat_name);
 5217       }
 5218     }
 5219     /* not found in PATH; assume curdir */
 5220   }
 5221   /* Relative path | not found in path: prepend cwd */
 5222   if (getcwd (tmp, LT_PATHMAX) == NULL)
 5223     lt_fatal ("getcwd failed");
 5224   tmp_len = strlen(tmp);
 5225   concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
 5226   memcpy (concat_name, tmp, tmp_len);
 5227   concat_name[tmp_len] = '/';
 5228   strcpy (concat_name + tmp_len + 1, wrapper);
 5229 
 5230   if (check_executable(concat_name))
 5231     return concat_name;
 5232   XFREE(concat_name);
 5233   return NULL;
 5234 }
 5235 
 5236 char *
 5237 strendzap(char *str, const char *pat)
 5238 {
 5239   size_t len, patlen;
 5240 
 5241   assert(str != NULL);
 5242   assert(pat != NULL);
 5243 
 5244   len = strlen(str);
 5245   patlen = strlen(pat);
 5246 
 5247   if (patlen <= len)
 5248   {
 5249     str += len - patlen;
 5250     if (strcmp(str, pat) == 0)
 5251       *str = '\0';
 5252   }
 5253   return str;
 5254 }
 5255 
 5256 static void
 5257 lt_error_core (int exit_status, const char * mode,
 5258           const char * message, va_list ap)
 5259 {
 5260   fprintf (stderr, "%s: %s: ", program_name, mode);
 5261   vfprintf (stderr, message, ap);
 5262   fprintf (stderr, ".\n");
 5263 
 5264   if (exit_status >= 0)
 5265     exit (exit_status);
 5266 }
 5267 
 5268 void
 5269 lt_fatal (const cha