"Fossies" - the Fresh Open Source Software Archive

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