"Fossies" - the Fresh Open Source Software Archive

Member "scalpel-2.0/tre-0.7.5-win32/utils/ltmain.sh" (20 Apr 2011, 196440 Bytes) of archive /linux/misc/scalpel-2.0.tar.gz:


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

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