"Fossies" - the Fresh Open Source Software Archive

Member "mapgenerator-1.1.2/ltmain.sh" (20 Aug 2005, 184058 Bytes) of package /linux/www/old/mapgenerator-1.1.2.tar.gz:


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

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