ltmain.sh

   1 # Generated from ltmain.m4sh.\r
   2 \r
   3 # ltmain.sh (GNU libtool) 2.2.6b\r
   4 # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996\r
   5 \r
   6 # Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006, 2007 2008 Free Software Foundation, Inc.\r
   7 # This is free software; see the source for copying conditions.  There is NO\r
   8 # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\r
   9 \r
  10 # GNU Libtool is free software; you can redistribute it and/or modify\r
  11 # it under the terms of the GNU General Public License as published by\r
  12 # the Free Software Foundation; either version 2 of the License, or\r
  13 # (at your option) any later version.\r
  14 #\r
  15 # As a special exception to the GNU General Public License,\r
  16 # if you distribute this file as part of a program or library that\r
  17 # is built using GNU Libtool, you may include this file under the\r
  18 # same distribution terms that you use for the rest of that program.\r
  19 #\r
  20 # GNU Libtool is distributed in the hope that it will be useful, but\r
  21 # WITHOUT ANY WARRANTY; without even the implied warranty of\r
  22 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\r
  23 # General Public License for more details.\r
  24 #\r
  25 # You should have received a copy of the GNU General Public License\r
  26 # along with GNU Libtool; see the file COPYING.  If not, a copy\r
  27 # can be downloaded from http://www.gnu.org/licenses/gpl.html,\r
  28 # or obtained by writing to the Free Software Foundation, Inc.,\r
  29 # 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.\r
  30 \r
  31 # Usage: $progname [OPTION]... [MODE-ARG]...\r
  32 #\r
  33 # Provide generalized library-building support services.\r
  34 #\r
  35 #     --config             show all configuration variables\r
  36 #     --debug              enable verbose shell tracing\r
  37 # -n, --dry-run            display commands without modifying any files\r
  38 #     --features           display basic configuration information and exit\r
  39 #     --mode=MODE          use operation mode MODE\r
  40 #     --preserve-dup-deps  don't remove duplicate dependency libraries\r
  41 #     --quiet, --silent    don't print informational messages\r
  42 #     --tag=TAG            use configuration variables from tag TAG\r
  43 # -v, --verbose            print informational messages (default)\r
  44 #     --version            print version information\r
  45 # -h, --help               print short or long help message\r
  46 #\r
  47 # MODE must be one of the following:\r
  48 #\r
  49 #       clean              remove files from the build directory\r
  50 #       compile            compile a source file into a libtool object\r
  51 #       execute            automatically set library path, then run a program\r
  52 #       finish             complete the installation of libtool libraries\r
  53 #       install            install libraries or executables\r
  54 #       link               create a library or an executable\r
  55 #       uninstall          remove libraries from an installed directory\r
  56 #\r
  57 # MODE-ARGS vary depending on the MODE.\r
  58 # Try `$progname --help --mode=MODE' for a more detailed description of MODE.\r
  59 #\r
  60 # When reporting a bug, please describe a test case to reproduce it and\r
  61 # include the following information:\r
  62 #\r
  63 #       host-triplet:   $host\r
  64 #       shell:          $SHELL\r
  65 #       compiler:               $LTCC\r
  66 #       compiler flags:         $LTCFLAGS\r
  67 #       linker:         $LD (gnu? $with_gnu_ld)\r
  68 #       $progname:              (GNU libtool) 2.2.6b\r
  69 #       automake:               $automake_version\r
  70 #       autoconf:               $autoconf_version\r
  71 #\r
  72 # Report bugs to <bug-libtool@gnu.org>.\r
  73 \r
  74 PROGRAM=ltmain.sh\r
  75 PACKAGE=libtool\r
  76 VERSION=2.2.6b\r
  77 TIMESTAMP=""\r
  78 package_revision=1.3017\r
  79 \r
  80 # Be Bourne compatible\r
  81 if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then\r
  82   emulate sh\r
  83   NULLCMD=:\r
  84   # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which\r
  85   # is contrary to our usage.  Disable this feature.\r
  86   alias -g '${1+"$@"}'='"$@"'\r
  87   setopt NO_GLOB_SUBST\r
  88 else\r
  89   case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac\r
  90 fi\r
  91 BIN_SH=xpg4; export BIN_SH # for Tru64\r
  92 DUALCASE=1; export DUALCASE # for MKS sh\r
  93 \r
  94 # NLS nuisances: We save the old values to restore during execute mode.\r
  95 # Only set LANG and LC_ALL to C if already set.\r
  96 # These must not be set unconditionally because not all systems understand\r
  97 # e.g. LANG=C (notably SCO).\r
  98 lt_user_locale=\r
  99 lt_safe_locale=\r
 100 for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES\r
 101 do\r
 102   eval "if test \"\${$lt_var+set}\" = set; then\r
 103           save_$lt_var=\$$lt_var\r
 104           $lt_var=C\r
 105           export $lt_var\r
 106           lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"\r
 107           lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"\r
 108         fi"\r
 109 done\r
 110 \r
 111 $lt_unset CDPATH\r
 112 \r
 113 \r
 114 \r
 115 \r
 116 \r
 117 : ${CP="cp -f"}\r
 118 : ${ECHO="echo"}\r
 119 : ${EGREP="/bin/grep -E"}\r
 120 : ${FGREP="/bin/grep -F"}\r
 121 : ${GREP="/bin/grep"}\r
 122 : ${LN_S="ln -s"}\r
 123 : ${MAKE="make"}\r
 124 : ${MKDIR="mkdir"}\r
 125 : ${MV="mv -f"}\r
 126 : ${RM="rm -f"}\r
 127 : ${SED="/bin/sed"}\r
 128 : ${SHELL="${CONFIG_SHELL-/bin/sh}"}\r
 129 : ${Xsed="$SED -e 1s/^X//"}\r
 130 \r
 131 # Global variables:\r
 132 EXIT_SUCCESS=0\r
 133 EXIT_FAILURE=1\r
 134 EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.\r
 135 EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.\r
 136 \r
 137 exit_status=$EXIT_SUCCESS\r
 138 \r
 139 # Make sure IFS has a sensible default\r
 140 lt_nl='\r
 141 '\r
 142 IFS="   $lt_nl"\r
 143 \r
 144 dirname="s,/[^/]*$,,"\r
 145 basename="s,^.*/,,"\r
 146 \r
 147 # func_dirname_and_basename file append nondir_replacement\r
 148 # perform func_basename and func_dirname in a single function\r
 149 # call:\r
 150 #   dirname:  Compute the dirname of FILE.  If nonempty,\r
 151 #             add APPEND to the result, otherwise set result\r
 152 #             to NONDIR_REPLACEMENT.\r
 153 #             value returned in "$func_dirname_result"\r
 154 #   basename: Compute filename of FILE.\r
 155 #             value retuned in "$func_basename_result"\r
 156 # Implementation must be kept synchronized with func_dirname\r
 157 # and func_basename. For efficiency, we do not delegate to\r
 158 # those functions but instead duplicate the functionality here.\r
 159 func_dirname_and_basename ()\r
 160 {\r
 161   # Extract subdirectory from the argument.\r
 162   func_dirname_result=`$ECHO "X${1}" | $Xsed -e "$dirname"`\r
 163   if test "X$func_dirname_result" = "X${1}"; then\r
 164     func_dirname_result="${3}"\r
 165   else\r
 166     func_dirname_result="$func_dirname_result${2}"\r
 167   fi\r
 168   func_basename_result=`$ECHO "X${1}" | $Xsed -e "$basename"`\r
 169 }\r
 170 \r
 171 # Generated shell functions inserted here.\r
 172 \r
 173 # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh\r
 174 # is ksh but when the shell is invoked as "sh" and the current value of\r
 175 # the _XPG environment variable is not equal to 1 (one), the special\r
 176 # positional parameter $0, within a function call, is the name of the\r
 177 # function.\r
 178 progpath="$0"\r
 179 \r
 180 # The name of this program:\r
 181 # In the unlikely event $progname began with a '-', it would play havoc with\r
 182 # func_echo (imagine progname=-n), so we prepend ./ in that case:\r
 183 func_dirname_and_basename "$progpath"\r
 184 progname=$func_basename_result\r
 185 case $progname in\r
 186   -*) progname=./$progname ;;\r
 187 esac\r
 188 \r
 189 # Make sure we have an absolute path for reexecution:\r
 190 case $progpath in\r
 191   [\\/]*|[A-Za-z]:\\*) ;;\r
 192   *[\\/]*)\r
 193      progdir=$func_dirname_result\r
 194      progdir=`cd "$progdir" && pwd`\r
 195      progpath="$progdir/$progname"\r
 196      ;;\r
 197   *)\r
 198      save_IFS="$IFS"\r
 199      IFS=:\r
 200      for progdir in $PATH; do\r
 201        IFS="$save_IFS"\r
 202        test -x "$progdir/$progname" && break\r
 203      done\r
 204      IFS="$save_IFS"\r
 205      test -n "$progdir" || progdir=`pwd`\r
 206      progpath="$progdir/$progname"\r
 207      ;;\r
 208 esac\r
 209 \r
 210 # Sed substitution that helps us do robust quoting.  It backslashifies\r
 211 # metacharacters that are still active within double-quoted strings.\r
 212 Xsed="${SED}"' -e 1s/^X//'\r
 213 sed_quote_subst='s/\([`"$\\]\)/\\\1/g'\r
 214 \r
 215 # Same as above, but do not quote variable references.\r
 216 double_quote_subst='s/\(["`\\]\)/\\\1/g'\r
 217 \r
 218 # Re-`\' parameter expansions in output of double_quote_subst that were\r
 219 # `\'-ed in input to the same.  If an odd number of `\' preceded a '$'\r
 220 # in input to double_quote_subst, that '$' was protected from expansion.\r
 221 # Since each input `\' is now two `\'s, look for any number of runs of\r
 222 # four `\'s followed by two `\'s and then a '$'.  `\' that '$'.\r
 223 bs='\\'\r
 224 bs2='\\\\'\r
 225 bs4='\\\\\\\\'\r
 226 dollar='\$'\r
 227 sed_double_backslash="\\r
 228   s/$bs4/&\\\r
 229 /g\r
 230   s/^$bs2$dollar/$bs&/\r
 231   s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g\r
 232   s/\n//g"\r
 233 \r
 234 # Standard options:\r
 235 opt_dry_run=false\r
 236 opt_help=false\r
 237 opt_quiet=false\r
 238 opt_verbose=false\r
 239 opt_warning=:\r
 240 \r
 241 # func_echo arg...\r
 242 # Echo program name prefixed message, along with the current mode\r
 243 # name if it has been set yet.\r
 244 func_echo ()\r
 245 {\r
 246     $ECHO "$progname${mode+: }$mode: $*"\r
 247 }\r
 248 \r
 249 # func_verbose arg...\r
 250 # Echo program name prefixed message in verbose mode only.\r
 251 func_verbose ()\r
 252 {\r
 253     $opt_verbose && func_echo ${1+"$@"}\r
 254 \r
 255     # A bug in bash halts the script if the last line of a function\r
 256     # fails when set -e is in force, so we need another command to\r
 257     # work around that:\r
 258     :\r
 259 }\r
 260 \r
 261 # func_error arg...\r
 262 # Echo program name prefixed message to standard error.\r
 263 func_error ()\r
 264 {\r
 265     $ECHO "$progname${mode+: }$mode: "${1+"$@"} 1>&2\r
 266 }\r
 267 \r
 268 # func_warning arg...\r
 269 # Echo program name prefixed warning message to standard error.\r
 270 func_warning ()\r
 271 {\r
 272     $opt_warning && $ECHO "$progname${mode+: }$mode: warning: "${1+"$@"} 1>&2\r
 273 \r
 274     # bash bug again:\r
 275     :\r
 276 }\r
 277 \r
 278 # func_fatal_error arg...\r
 279 # Echo program name prefixed message to standard error, and exit.\r
 280 func_fatal_error ()\r
 281 {\r
 282     func_error ${1+"$@"}\r
 283     exit $EXIT_FAILURE\r
 284 }\r
 285 \r
 286 # func_fatal_help arg...\r
 287 # Echo program name prefixed message to standard error, followed by\r
 288 # a help hint, and exit.\r
 289 func_fatal_help ()\r
 290 {\r
 291     func_error ${1+"$@"}\r
 292     func_fatal_error "$help"\r
 293 }\r
 294 help="Try \`$progname --help' for more information."  ## default\r
 295 \r
 296 \r
 297 # func_grep expression filename\r
 298 # Check whether EXPRESSION matches any line of FILENAME, without output.\r
 299 func_grep ()\r
 300 {\r
 301     $GREP "$1" "$2" >/dev/null 2>&1\r
 302 }\r
 303 \r
 304 \r
 305 # func_mkdir_p directory-path\r
 306 # Make sure the entire path to DIRECTORY-PATH is available.\r
 307 func_mkdir_p ()\r
 308 {\r
 309     my_directory_path="$1"\r
 310     my_dir_list=\r
 311 \r
 312     if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then\r
 313 \r
 314       # Protect directory names starting with `-'\r
 315       case $my_directory_path in\r
 316         -*) my_directory_path="./$my_directory_path" ;;\r
 317       esac\r
 318 \r
 319       # While some portion of DIR does not yet exist...\r
 320       while test ! -d "$my_directory_path"; do\r
 321         # ...make a list in topmost first order.  Use a colon delimited\r
 322         # list incase some portion of path contains whitespace.\r
 323         my_dir_list="$my_directory_path:$my_dir_list"\r
 324 \r
 325         # If the last portion added has no slash in it, the list is done\r
 326         case $my_directory_path in */*) ;; *) break ;; esac\r
 327 \r
 328         # ...otherwise throw away the child directory and loop\r
 329         my_directory_path=`$ECHO "X$my_directory_path" | $Xsed -e "$dirname"`\r
 330       done\r
 331       my_dir_list=`$ECHO "X$my_dir_list" | $Xsed -e 's,:*$,,'`\r
 332 \r
 333       save_mkdir_p_IFS="$IFS"; IFS=':'\r
 334       for my_dir in $my_dir_list; do\r
 335         IFS="$save_mkdir_p_IFS"\r
 336         # mkdir can fail with a `File exist' error if two processes\r
 337         # try to create one of the directories concurrently.  Don't\r
 338         # stop in that case!\r
 339         $MKDIR "$my_dir" 2>/dev/null || :\r
 340       done\r
 341       IFS="$save_mkdir_p_IFS"\r
 342 \r
 343       # Bail out if we (or some other process) failed to create a directory.\r
 344       test -d "$my_directory_path" || \\r
 345         func_fatal_error "Failed to create \`$1'"\r
 346     fi\r
 347 }\r
 348 \r
 349 \r
 350 # func_mktempdir [string]\r
 351 # Make a temporary directory that won't clash with other running\r
 352 # libtool processes, and avoids race conditions if possible.  If\r
 353 # given, STRING is the basename for that directory.\r
 354 func_mktempdir ()\r
 355 {\r
 356     my_template="${TMPDIR-/tmp}/${1-$progname}"\r
 357 \r
 358     if test "$opt_dry_run" = ":"; then\r
 359       # Return a directory name, but don't create it in dry-run mode\r
 360       my_tmpdir="${my_template}-$$"\r
 361     else\r
 362 \r
 363       # If mktemp works, use that first and foremost\r
 364       my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`\r
 365 \r
 366       if test ! -d "$my_tmpdir"; then\r
 367         # Failing that, at least try and use $RANDOM to avoid a race\r
 368         my_tmpdir="${my_template}-${RANDOM-0}$$"\r
 369 \r
 370         save_mktempdir_umask=`umask`\r
 371         umask 0077\r
 372         $MKDIR "$my_tmpdir"\r
 373         umask $save_mktempdir_umask\r
 374       fi\r
 375 \r
 376       # If we're not in dry-run mode, bomb out on failure\r
 377       test -d "$my_tmpdir" || \\r
 378         func_fatal_error "cannot create temporary directory \`$my_tmpdir'"\r
 379     fi\r
 380 \r
 381     $ECHO "X$my_tmpdir" | $Xsed\r
 382 }\r
 383 \r
 384 \r
 385 # func_quote_for_eval arg\r
 386 # Aesthetically quote ARG to be evaled later.\r
 387 # This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT\r
 388 # is double-quoted, suitable for a subsequent eval, whereas\r
 389 # FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters\r
 390 # which are still active within double quotes backslashified.\r
 391 func_quote_for_eval ()\r
 392 {\r
 393     case $1 in\r
 394       *[\\\`\"\$]*)\r
 395         func_quote_for_eval_unquoted_result=`$ECHO "X$1" | $Xsed -e "$sed_quote_subst"` ;;\r
 396       *)\r
 397         func_quote_for_eval_unquoted_result="$1" ;;\r
 398     esac\r
 399 \r
 400     case $func_quote_for_eval_unquoted_result in\r
 401       # Double-quote args containing shell metacharacters to delay\r
 402       # word splitting, command substitution and and variable\r
 403       # expansion for a subsequent eval.\r
 404       # Many Bourne shells cannot handle close brackets correctly\r
 405       # in scan sets, so we specify it separately.\r
 406       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")\r
 407         func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""\r
 408         ;;\r
 409       *)\r
 410         func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"\r
 411     esac\r
 412 }\r
 413 \r
 414 \r
 415 # func_quote_for_expand arg\r
 416 # Aesthetically quote ARG to be evaled later; same as above,\r
 417 # but do not quote variable references.\r
 418 func_quote_for_expand ()\r
 419 {\r
 420     case $1 in\r
 421       *[\\\`\"]*)\r
 422         my_arg=`$ECHO "X$1" | $Xsed \\r
 423             -e "$double_quote_subst" -e "$sed_double_backslash"` ;;\r
 424       *)\r
 425         my_arg="$1" ;;\r
 426     esac\r
 427 \r
 428     case $my_arg in\r
 429       # Double-quote args containing shell metacharacters to delay\r
 430       # word splitting and command substitution for a subsequent eval.\r
 431       # Many Bourne shells cannot handle close brackets correctly\r
 432       # in scan sets, so we specify it separately.\r
 433       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")\r
 434         my_arg="\"$my_arg\""\r
 435         ;;\r
 436     esac\r
 437 \r
 438     func_quote_for_expand_result="$my_arg"\r
 439 }\r
 440 \r
 441 \r
 442 # func_show_eval cmd [fail_exp]\r
 443 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is\r
 444 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP\r
 445 # is given, then evaluate it.\r
 446 func_show_eval ()\r
 447 {\r
 448     my_cmd="$1"\r
 449     my_fail_exp="${2-:}"\r
 450 \r
 451     ${opt_silent-false} || {\r
 452       func_quote_for_expand "$my_cmd"\r
 453       eval "func_echo $func_quote_for_expand_result"\r
 454     }\r
 455 \r
 456     if ${opt_dry_run-false}; then :; else\r
 457       eval "$my_cmd"\r
 458       my_status=$?\r
 459       if test "$my_status" -eq 0; then :; else\r
 460         eval "(exit $my_status); $my_fail_exp"\r
 461       fi\r
 462     fi\r
 463 }\r
 464 \r
 465 \r
 466 # func_show_eval_locale cmd [fail_exp]\r
 467 # Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is\r
 468 # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP\r
 469 # is given, then evaluate it.  Use the saved locale for evaluation.\r
 470 func_show_eval_locale ()\r
 471 {\r
 472     my_cmd="$1"\r
 473     my_fail_exp="${2-:}"\r
 474 \r
 475     ${opt_silent-false} || {\r
 476       func_quote_for_expand "$my_cmd"\r
 477       eval "func_echo $func_quote_for_expand_result"\r
 478     }\r
 479 \r
 480     if ${opt_dry_run-false}; then :; else\r
 481       eval "$lt_user_locale\r
 482             $my_cmd"\r
 483       my_status=$?\r
 484       eval "$lt_safe_locale"\r
 485       if test "$my_status" -eq 0; then :; else\r
 486         eval "(exit $my_status); $my_fail_exp"\r
 487       fi\r
 488     fi\r
 489 }\r
 490 \r
 491 \r
 492 \r
 493 \r
 494 \r
 495 # func_version\r
 496 # Echo version message to standard output and exit.\r
 497 func_version ()\r
 498 {\r
 499     $SED -n '/^# '$PROGRAM' (GNU /,/# warranty; / {\r
 500         s/^# //\r
 501         s/^# *$//\r
 502         s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/\r
 503         p\r
 504      }' < "$progpath"\r
 505      exit $?\r
 506 }\r
 507 \r
 508 # func_usage\r
 509 # Echo short help message to standard output and exit.\r
 510 func_usage ()\r
 511 {\r
 512     $SED -n '/^# Usage:/,/# -h/ {\r
 513         s/^# //\r
 514         s/^# *$//\r
 515         s/\$progname/'$progname'/\r
 516         p\r
 517     }' < "$progpath"\r
 518     $ECHO\r
 519     $ECHO "run \`$progname --help | more' for full usage"\r
 520     exit $?\r
 521 }\r
 522 \r
 523 # func_help\r
 524 # Echo long help message to standard output and exit.\r
 525 func_help ()\r
 526 {\r
 527     $SED -n '/^# Usage:/,/# Report bugs to/ {\r
 528         s/^# //\r
 529         s/^# *$//\r
 530         s*\$progname*'$progname'*\r
 531         s*\$host*'"$host"'*\r
 532         s*\$SHELL*'"$SHELL"'*\r
 533         s*\$LTCC*'"$LTCC"'*\r
 534         s*\$LTCFLAGS*'"$LTCFLAGS"'*\r
 535         s*\$LD*'"$LD"'*\r
 536         s/\$with_gnu_ld/'"$with_gnu_ld"'/\r
 537         s/\$automake_version/'"`(automake --version) 2>/dev/null |$SED 1q`"'/\r
 538         s/\$autoconf_version/'"`(autoconf --version) 2>/dev/null |$SED 1q`"'/\r
 539         p\r
 540      }' < "$progpath"\r
 541     exit $?\r
 542 }\r
 543 \r
 544 # func_missing_arg argname\r
 545 # Echo program name prefixed message to standard error and set global\r
 546 # exit_cmd.\r
 547 func_missing_arg ()\r
 548 {\r
 549     func_error "missing argument for $1"\r
 550     exit_cmd=exit\r
 551 }\r
 552 \r
 553 exit_cmd=:\r
 554 \r
 555 \r
 556 \r
 557 \r
 558 \r
 559 # Check that we have a working $ECHO.\r
 560 if test "X$1" = X--no-reexec; then\r
 561   # Discard the --no-reexec flag, and continue.\r
 562   shift\r
 563 elif test "X$1" = X--fallback-echo; then\r
 564   # Avoid inline document here, it may be left over\r
 565   :\r
 566 elif test "X`{ $ECHO '\t'; } 2>/dev/null`" = 'X\t'; then\r
 567   # Yippee, $ECHO works!\r
 568   :\r
 569 else\r
 570   # Restart under the correct shell, and then maybe $ECHO will work.\r
 571   exec $SHELL "$progpath" --no-reexec ${1+"$@"}\r
 572 fi\r
 573 \r
 574 if test "X$1" = X--fallback-echo; then\r
 575   # used as fallback echo\r
 576   shift\r
 577   cat <<EOF\r
 578 $*\r
 579 EOF\r
 580   exit $EXIT_SUCCESS\r
 581 fi\r
 582 \r
 583 magic="%%%MAGIC variable%%%"\r
 584 magic_exe="%%%MAGIC EXE variable%%%"\r
 585 \r
 586 # Global variables.\r
 587 # $mode is unset\r
 588 nonopt=\r
 589 execute_dlfiles=\r
 590 preserve_args=\r
 591 lo2o="s/\\.lo\$/.${objext}/"\r
 592 o2lo="s/\\.${objext}\$/.lo/"\r
 593 extracted_archives=\r
 594 extracted_serial=0\r
 595 \r
 596 opt_dry_run=false\r
 597 opt_duplicate_deps=false\r
 598 opt_silent=false\r
 599 opt_debug=:\r
 600 \r
 601 # If this variable is set in any of the actions, the command in it\r
 602 # will be execed at the end.  This prevents here-documents from being\r
 603 # left over by shells.\r
 604 exec_cmd=\r
 605 \r
 606 # func_fatal_configuration arg...\r
 607 # Echo program name prefixed message to standard error, followed by\r
 608 # a configuration failure hint, and exit.\r
 609 func_fatal_configuration ()\r
 610 {\r
 611     func_error ${1+"$@"}\r
 612     func_error "See the $PACKAGE documentation for more information."\r
 613     func_fatal_error "Fatal configuration error."\r
 614 }\r
 615 \r
 616 \r
 617 # func_config\r
 618 # Display the configuration for all the tags in this script.\r
 619 func_config ()\r
 620 {\r
 621     re_begincf='^# ### BEGIN LIBTOOL'\r
 622     re_endcf='^# ### END LIBTOOL'\r
 623 \r
 624     # Default configuration.\r
 625     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"\r
 626 \r
 627     # Now print the configurations for the tags.\r
 628     for tagname in $taglist; do\r
 629       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"\r
 630     done\r
 631 \r
 632     exit $?\r
 633 }\r
 634 \r
 635 # func_features\r
 636 # Display the features supported by this script.\r
 637 func_features ()\r
 638 {\r
 639     $ECHO "host: $host"\r
 640     if test "$build_libtool_libs" = yes; then\r
 641       $ECHO "enable shared libraries"\r
 642     else\r
 643       $ECHO "disable shared libraries"\r
 644     fi\r
 645     if test "$build_old_libs" = yes; then\r
 646       $ECHO "enable static libraries"\r
 647     else\r
 648       $ECHO "disable static libraries"\r
 649     fi\r
 650 \r
 651     exit $?\r
 652 }\r
 653 \r
 654 # func_enable_tag tagname\r
 655 # Verify that TAGNAME is valid, and either flag an error and exit, or\r
 656 # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist\r
 657 # variable here.\r
 658 func_enable_tag ()\r
 659 {\r
 660   # Global variable:\r
 661   tagname="$1"\r
 662 \r
 663   re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"\r
 664   re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"\r
 665   sed_extractcf="/$re_begincf/,/$re_endcf/p"\r
 666 \r
 667   # Validate tagname.\r
 668   case $tagname in\r
 669     *[!-_A-Za-z0-9,/]*)\r
 670       func_fatal_error "invalid tag name: $tagname"\r
 671       ;;\r
 672   esac\r
 673 \r
 674   # Don't test for the "default" C tag, as we know it's\r
 675   # there but not specially marked.\r
 676   case $tagname in\r
 677     CC) ;;\r
 678     *)\r
 679       if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then\r
 680         taglist="$taglist $tagname"\r
 681 \r
 682         # Evaluate the configuration.  Be careful to quote the path\r
 683         # and the sed script, to avoid splitting on whitespace, but\r
 684         # also don't use non-portable quotes within backquotes within\r
 685         # quotes we have to do it in 2 steps:\r
 686         extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`\r
 687         eval "$extractedcf"\r
 688       else\r
 689         func_error "ignoring unknown tag $tagname"\r
 690       fi\r
 691       ;;\r
 692   esac\r
 693 }\r
 694 \r
 695 # Parse options once, thoroughly.  This comes as soon as possible in\r
 696 # the script to make things like `libtool --version' happen quickly.\r
 697 {\r
 698 \r
 699   # Shorthand for --mode=foo, only valid as the first argument\r
 700   case $1 in\r
 701   clean|clea|cle|cl)\r
 702     shift; set dummy --mode clean ${1+"$@"}; shift\r
 703     ;;\r
 704   compile|compil|compi|comp|com|co|c)\r
 705     shift; set dummy --mode compile ${1+"$@"}; shift\r
 706     ;;\r
 707   execute|execut|execu|exec|exe|ex|e)\r
 708     shift; set dummy --mode execute ${1+"$@"}; shift\r
 709     ;;\r
 710   finish|finis|fini|fin|fi|f)\r
 711     shift; set dummy --mode finish ${1+"$@"}; shift\r
 712     ;;\r
 713   install|instal|insta|inst|ins|in|i)\r
 714     shift; set dummy --mode install ${1+"$@"}; shift\r
 715     ;;\r
 716   link|lin|li|l)\r
 717     shift; set dummy --mode link ${1+"$@"}; shift\r
 718     ;;\r
 719   uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)\r
 720     shift; set dummy --mode uninstall ${1+"$@"}; shift\r
 721     ;;\r
 722   esac\r
 723 \r
 724   # Parse non-mode specific arguments:\r
 725   while test "$#" -gt 0; do\r
 726     opt="$1"\r
 727     shift\r
 728 \r
 729     case $opt in\r
 730       --config)         func_config                                     ;;\r
 731 \r
 732       --debug)          preserve_args="$preserve_args $opt"\r
 733                         func_echo "enabling shell trace mode"\r
 734                         opt_debug='set -x'\r
 735                         $opt_debug\r
 736                         ;;\r
 737 \r
 738       -dlopen)          test "$#" -eq 0 && func_missing_arg "$opt" && break\r
 739                         execute_dlfiles="$execute_dlfiles $1"\r
 740                         shift\r
 741                         ;;\r
 742 \r
 743       --dry-run | -n)   opt_dry_run=:                                   ;;\r
 744       --features)       func_features                                   ;;\r
 745       --finish)         mode="finish"                                   ;;\r
 746 \r
 747       --mode)           test "$#" -eq 0 && func_missing_arg "$opt" && break\r
 748                         case $1 in\r
 749                           # Valid mode arguments:\r
 750                           clean)        ;;\r
 751                           compile)      ;;\r
 752                           execute)      ;;\r
 753                           finish)       ;;\r
 754                           install)      ;;\r
 755                           link)         ;;\r
 756                           relink)       ;;\r
 757                           uninstall)    ;;\r
 758 \r
 759                           # Catch anything else as an error\r
 760                           *) func_error "invalid argument for $opt"\r
 761                              exit_cmd=exit\r
 762                              break\r
 763                              ;;\r
 764                         esac\r
 765 \r
 766                         mode="$1"\r
 767                         shift\r
 768                         ;;\r
 769 \r
 770       --preserve-dup-deps)\r
 771                         opt_duplicate_deps=:                            ;;\r
 772 \r
 773       --quiet|--silent) preserve_args="$preserve_args $opt"\r
 774                         opt_silent=:\r
 775                         ;;\r
 776 \r
 777       --verbose| -v)    preserve_args="$preserve_args $opt"\r
 778                         opt_silent=false\r
 779                         ;;\r
 780 \r
 781       --tag)            test "$#" -eq 0 && func_missing_arg "$opt" && break\r
 782                         preserve_args="$preserve_args $opt $1"\r
 783                         func_enable_tag "$1"    # tagname is set here\r
 784                         shift\r
 785                         ;;\r
 786 \r
 787       # Separate optargs to long options:\r
 788       -dlopen=*|--mode=*|--tag=*)\r
 789                         func_opt_split "$opt"\r
 790                         set dummy "$func_opt_split_opt" "$func_opt_split_arg" ${1+"$@"}\r
 791                         shift\r
 792                         ;;\r
 793 \r
 794       -\?|-h)           func_usage                                      ;;\r
 795       --help)           opt_help=:                                      ;;\r
 796       --version)        func_version                                    ;;\r
 797 \r
 798       -*)               func_fatal_help "unrecognized option \`$opt'"   ;;\r
 799 \r
 800       *)                nonopt="$opt"\r
 801                         break\r
 802                         ;;\r
 803     esac\r
 804   done\r
 805 \r
 806 \r
 807   case $host in\r
 808     *cygwin* | *mingw* | *pw32* | *cegcc*)\r
 809       # don't eliminate duplications in $postdeps and $predeps\r
 810       opt_duplicate_compiler_generated_deps=:\r
 811       ;;\r
 812     *)\r
 813       opt_duplicate_compiler_generated_deps=$opt_duplicate_deps\r
 814       ;;\r
 815   esac\r
 816 \r
 817   # Having warned about all mis-specified options, bail out if\r
 818   # anything was wrong.\r
 819   $exit_cmd $EXIT_FAILURE\r
 820 }\r
 821 \r
 822 # func_check_version_match\r
 823 # Ensure that we are using m4 macros, and libtool script from the same\r
 824 # release of libtool.\r
 825 func_check_version_match ()\r
 826 {\r
 827   if test "$package_revision" != "$macro_revision"; then\r
 828     if test "$VERSION" != "$macro_version"; then\r
 829       if test -z "$macro_version"; then\r
 830         cat >&2 <<_LT_EOF\r
 831 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the\r
 832 $progname: definition of this LT_INIT comes from an older release.\r
 833 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION\r
 834 $progname: and run autoconf again.\r
 835 _LT_EOF\r
 836       else\r
 837         cat >&2 <<_LT_EOF\r
 838 $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the\r
 839 $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.\r
 840 $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION\r
 841 $progname: and run autoconf again.\r
 842 _LT_EOF\r
 843       fi\r
 844     else\r
 845       cat >&2 <<_LT_EOF\r
 846 $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,\r
 847 $progname: but the definition of this LT_INIT comes from revision $macro_revision.\r
 848 $progname: You should recreate aclocal.m4 with macros from revision $package_revision\r
 849 $progname: of $PACKAGE $VERSION and run autoconf again.\r
 850 _LT_EOF\r
 851     fi\r
 852 \r
 853     exit $EXIT_MISMATCH\r
 854   fi\r
 855 }\r
 856 \r
 857 \r
 858 ## ----------- ##\r
 859 ##    Main.    ##\r
 860 ## ----------- ##\r
 861 \r
 862 $opt_help || {\r
 863   # Sanity checks first:\r
 864   func_check_version_match\r
 865 \r
 866   if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then\r
 867     func_fatal_configuration "not configured to build any kind of library"\r
 868   fi\r
 869 \r
 870   test -z "$mode" && func_fatal_error "error: you must specify a MODE."\r
 871 \r
 872 \r
 873   # Darwin sucks\r
 874   eval std_shrext=\"$shrext_cmds\"\r
 875 \r
 876 \r
 877   # Only execute mode is allowed to have -dlopen flags.\r
 878   if test -n "$execute_dlfiles" && test "$mode" != execute; then\r
 879     func_error "unrecognized option \`-dlopen'"\r
 880     $ECHO "$help" 1>&2\r
 881     exit $EXIT_FAILURE\r
 882   fi\r
 883 \r
 884   # Change the help message to a mode-specific one.\r
 885   generic_help="$help"\r
 886   help="Try \`$progname --help --mode=$mode' for more information."\r
 887 }\r
 888 \r
 889 \r
 890 # func_lalib_p file\r
 891 # True iff FILE is a libtool `.la' library or `.lo' object file.\r
 892 # This function is only a basic sanity check; it will hardly flush out\r
 893 # determined imposters.\r
 894 func_lalib_p ()\r
 895 {\r
 896     test -f "$1" &&\r
 897       $SED -e 4q "$1" 2>/dev/null \\r
 898         | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1\r
 899 }\r
 900 \r
 901 # func_lalib_unsafe_p file\r
 902 # True iff FILE is a libtool `.la' library or `.lo' object file.\r
 903 # This function implements the same check as func_lalib_p without\r
 904 # resorting to external programs.  To this end, it redirects stdin and\r
 905 # closes it afterwards, without saving the original file descriptor.\r
 906 # As a safety measure, use it only where a negative result would be\r
 907 # fatal anyway.  Works if `file' does not exist.\r
 908 func_lalib_unsafe_p ()\r
 909 {\r
 910     lalib_p=no\r
 911     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then\r
 912         for lalib_p_l in 1 2 3 4\r
 913         do\r
 914             read lalib_p_line\r
 915             case "$lalib_p_line" in\r
 916                 \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;\r
 917             esac\r
 918         done\r
 919         exec 0<&5 5<&-\r
 920     fi\r
 921     test "$lalib_p" = yes\r
 922 }\r
 923 \r
 924 # func_ltwrapper_script_p file\r
 925 # True iff FILE is a libtool wrapper script\r
 926 # This function is only a basic sanity check; it will hardly flush out\r
 927 # determined imposters.\r
 928 func_ltwrapper_script_p ()\r
 929 {\r
 930     func_lalib_p "$1"\r
 931 }\r
 932 \r
 933 # func_ltwrapper_executable_p file\r
 934 # True iff FILE is a libtool wrapper executable\r
 935 # This function is only a basic sanity check; it will hardly flush out\r
 936 # determined imposters.\r
 937 func_ltwrapper_executable_p ()\r
 938 {\r
 939     func_ltwrapper_exec_suffix=\r
 940     case $1 in\r
 941     *.exe) ;;\r
 942     *) func_ltwrapper_exec_suffix=.exe ;;\r
 943     esac\r
 944     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1\r
 945 }\r
 946 \r
 947 # func_ltwrapper_scriptname file\r
 948 # Assumes file is an ltwrapper_executable\r
 949 # uses $file to determine the appropriate filename for a\r
 950 # temporary ltwrapper_script.\r
 951 func_ltwrapper_scriptname ()\r
 952 {\r
 953     func_ltwrapper_scriptname_result=""\r
 954     if func_ltwrapper_executable_p "$1"; then\r
 955         func_dirname_and_basename "$1" "" "."\r
 956         func_stripname '' '.exe' "$func_basename_result"\r
 957         func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"\r
 958     fi\r
 959 }\r
 960 \r
 961 # func_ltwrapper_p file\r
 962 # True iff FILE is a libtool wrapper script or wrapper executable\r
 963 # This function is only a basic sanity check; it will hardly flush out\r
 964 # determined imposters.\r
 965 func_ltwrapper_p ()\r
 966 {\r
 967     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"\r
 968 }\r
 969 \r
 970 \r
 971 # func_execute_cmds commands fail_cmd\r
 972 # Execute tilde-delimited COMMANDS.\r
 973 # If FAIL_CMD is given, eval that upon failure.\r
 974 # FAIL_CMD may read-access the current command in variable CMD!\r
 975 func_execute_cmds ()\r
 976 {\r
 977     $opt_debug\r
 978     save_ifs=$IFS; IFS='~'\r
 979     for cmd in $1; do\r
 980       IFS=$save_ifs\r
 981       eval cmd=\"$cmd\"\r
 982       func_show_eval "$cmd" "${2-:}"\r
 983     done\r
 984     IFS=$save_ifs\r
 985 }\r
 986 \r
 987 \r
 988 # func_source file\r
 989 # Source FILE, adding directory component if necessary.\r
 990 # Note that it is not necessary on cygwin/mingw to append a dot to\r
 991 # FILE even if both FILE and FILE.exe exist: automatic-append-.exe\r
 992 # behavior happens only for exec(3), not for open(2)!  Also, sourcing\r
 993 # `FILE.' does not work on cygwin managed mounts.\r
 994 func_source ()\r
 995 {\r
 996     $opt_debug\r
 997     case $1 in\r
 998     */* | *\\*) . "$1" ;;\r
 999     *)          . "./$1" ;;\r
1000     esac\r
1001 }\r
1002 \r
1003 \r
1004 # func_infer_tag arg\r
1005 # Infer tagged configuration to use if any are available and\r
1006 # if one wasn't chosen via the "--tag" command line option.\r
1007 # Only attempt this if the compiler in the base compile\r
1008 # command doesn't match the default compiler.\r
1009 # arg is usually of the form 'gcc ...'\r
1010 func_infer_tag ()\r
1011 {\r
1012     $opt_debug\r
1013     if test -n "$available_tags" && test -z "$tagname"; then\r
1014       CC_quoted=\r
1015       for arg in $CC; do\r
1016         func_quote_for_eval "$arg"\r
1017         CC_quoted="$CC_quoted $func_quote_for_eval_result"\r
1018       done\r
1019       case $@ in\r
1020       # Blanks in the command may have been stripped by the calling shell,\r
1021       # but not from the CC environment variable when configure was run.\r
1022       " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*) ;;\r
1023       # Blanks at the start of $base_compile will cause this to fail\r
1024       # if we don't check for them as well.\r
1025       *)\r
1026         for z in $available_tags; do\r
1027           if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then\r
1028             # Evaluate the configuration.\r
1029             eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"\r
1030             CC_quoted=\r
1031             for arg in $CC; do\r
1032               # Double-quote args containing other shell metacharacters.\r
1033               func_quote_for_eval "$arg"\r
1034               CC_quoted="$CC_quoted $func_quote_for_eval_result"\r
1035             done\r
1036             case "$@ " in\r
1037               " $CC "* | "$CC "* | " `$ECHO $CC` "* | "`$ECHO $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$ECHO $CC_quoted` "* | "`$ECHO $CC_quoted` "*)\r
1038               # The compiler in the base compile command matches\r
1039               # the one in the tagged configuration.\r
1040               # Assume this is the tagged configuration we want.\r
1041               tagname=$z\r
1042               break\r
1043               ;;\r
1044             esac\r
1045           fi\r
1046         done\r
1047         # If $tagname still isn't set, then no tagged configuration\r
1048         # was found and let the user know that the "--tag" command\r
1049         # line option must be used.\r
1050         if test -z "$tagname"; then\r
1051           func_echo "unable to infer tagged configuration"\r
1052           func_fatal_error "specify a tag with \`--tag'"\r
1053 #       else\r
1054 #         func_verbose "using $tagname tagged configuration"\r
1055         fi\r
1056         ;;\r
1057       esac\r
1058     fi\r
1059 }\r
1060 \r
1061 \r
1062 \r
1063 # func_write_libtool_object output_name pic_name nonpic_name\r
1064 # Create a libtool object file (analogous to a ".la" file),\r
1065 # but don't create it if we're doing a dry run.\r
1066 func_write_libtool_object ()\r
1067 {\r
1068     write_libobj=${1}\r
1069     if test "$build_libtool_libs" = yes; then\r
1070       write_lobj=\'${2}\'\r
1071     else\r
1072       write_lobj=none\r
1073     fi\r
1074 \r
1075     if test "$build_old_libs" = yes; then\r
1076       write_oldobj=\'${3}\'\r
1077     else\r
1078       write_oldobj=none\r
1079     fi\r
1080 \r
1081     $opt_dry_run || {\r
1082       cat >${write_libobj}T <<EOF\r
1083 # $write_libobj - a libtool object file\r
1084 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION\r
1085 #\r
1086 # Please DO NOT delete this file!\r
1087 # It is necessary for linking the library.\r
1088 \r
1089 # Name of the PIC object.\r
1090 pic_object=$write_lobj\r
1091 \r
1092 # Name of the non-PIC object\r
1093 non_pic_object=$write_oldobj\r
1094 \r
1095 EOF\r
1096       $MV "${write_libobj}T" "${write_libobj}"\r
1097     }\r
1098 }\r
1099 \r
1100 # func_mode_compile arg...\r
1101 func_mode_compile ()\r
1102 {\r
1103     $opt_debug\r
1104     # Get the compilation command and the source file.\r
1105     base_compile=\r
1106     srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"\r
1107     suppress_opt=yes\r
1108     suppress_output=\r
1109     arg_mode=normal\r
1110     libobj=\r
1111     later=\r
1112     pie_flag=\r
1113 \r
1114     for arg\r
1115     do\r
1116       case $arg_mode in\r
1117       arg  )\r
1118         # do not "continue".  Instead, add this to base_compile\r
1119         lastarg="$arg"\r
1120         arg_mode=normal\r
1121         ;;\r
1122 \r
1123       target )\r
1124         libobj="$arg"\r
1125         arg_mode=normal\r
1126         continue\r
1127         ;;\r
1128 \r
1129       normal )\r
1130         # Accept any command-line options.\r
1131         case $arg in\r
1132         -o)\r
1133           test -n "$libobj" && \\r
1134             func_fatal_error "you cannot specify \`-o' more than once"\r
1135           arg_mode=target\r
1136           continue\r
1137           ;;\r
1138 \r
1139         -pie | -fpie | -fPIE)\r
1140           pie_flag="$pie_flag $arg"\r
1141           continue\r
1142           ;;\r
1143 \r
1144         -shared | -static | -prefer-pic | -prefer-non-pic)\r
1145           later="$later $arg"\r
1146           continue\r
1147           ;;\r
1148 \r
1149         -no-suppress)\r
1150           suppress_opt=no\r
1151           continue\r
1152           ;;\r
1153 \r
1154         -Xcompiler)\r
1155           arg_mode=arg  #  the next one goes into the "base_compile" arg list\r
1156           continue      #  The current "srcfile" will either be retained or\r
1157           ;;            #  replaced later.  I would guess that would be a bug.\r
1158 \r
1159         -Wc,*)\r
1160           func_stripname '-Wc,' '' "$arg"\r
1161           args=$func_stripname_result\r
1162           lastarg=\r
1163           save_ifs="$IFS"; IFS=','\r
1164           for arg in $args; do\r
1165             IFS="$save_ifs"\r
1166             func_quote_for_eval "$arg"\r
1167             lastarg="$lastarg $func_quote_for_eval_result"\r
1168           done\r
1169           IFS="$save_ifs"\r
1170           func_stripname ' ' '' "$lastarg"\r
1171           lastarg=$func_stripname_result\r
1172 \r
1173           # Add the arguments to base_compile.\r
1174           base_compile="$base_compile $lastarg"\r
1175           continue\r
1176           ;;\r
1177 \r
1178         *)\r
1179           # Accept the current argument as the source file.\r
1180           # The previous "srcfile" becomes the current argument.\r
1181           #\r
1182           lastarg="$srcfile"\r
1183           srcfile="$arg"\r
1184           ;;\r
1185         esac  #  case $arg\r
1186         ;;\r
1187       esac    #  case $arg_mode\r
1188 \r
1189       # Aesthetically quote the previous argument.\r
1190       func_quote_for_eval "$lastarg"\r
1191       base_compile="$base_compile $func_quote_for_eval_result"\r
1192     done # for arg\r
1193 \r
1194     case $arg_mode in\r
1195     arg)\r
1196       func_fatal_error "you must specify an argument for -Xcompile"\r
1197       ;;\r
1198     target)\r
1199       func_fatal_error "you must specify a target with \`-o'"\r
1200       ;;\r
1201     *)\r
1202       # Get the name of the library object.\r
1203       test -z "$libobj" && {\r
1204         func_basename "$srcfile"\r
1205         libobj="$func_basename_result"\r
1206       }\r
1207       ;;\r
1208     esac\r
1209 \r
1210     # Recognize several different file suffixes.\r
1211     # If the user specifies -o file.o, it is replaced with file.lo\r
1212     case $libobj in\r
1213     *.[cCFSifmso] | \\r
1214     *.ada | *.adb | *.ads | *.asm | \\r
1215     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \\r
1216     *.[fF][09]? | *.for | *.java | *.obj | *.sx)\r
1217       func_xform "$libobj"\r
1218       libobj=$func_xform_result\r
1219       ;;\r
1220     esac\r
1221 \r
1222     case $libobj in\r
1223     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;\r
1224     *)\r
1225       func_fatal_error "cannot determine name of library object from \`$libobj'"\r
1226       ;;\r
1227     esac\r
1228 \r
1229     func_infer_tag $base_compile\r
1230 \r
1231     for arg in $later; do\r
1232       case $arg in\r
1233       -shared)\r
1234         test "$build_libtool_libs" != yes && \\r
1235           func_fatal_configuration "can not build a shared library"\r
1236         build_old_libs=no\r
1237         continue\r
1238         ;;\r
1239 \r
1240       -static)\r
1241         build_libtool_libs=no\r
1242         build_old_libs=yes\r
1243         continue\r
1244         ;;\r
1245 \r
1246       -prefer-pic)\r
1247         pic_mode=yes\r
1248         continue\r
1249         ;;\r
1250 \r
1251       -prefer-non-pic)\r
1252         pic_mode=no\r
1253         continue\r
1254         ;;\r
1255       esac\r
1256     done\r
1257 \r
1258     func_quote_for_eval "$libobj"\r
1259     test "X$libobj" != "X$func_quote_for_eval_result" \\r
1260       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \\r
1261       && func_warning "libobj name \`$libobj' may not contain shell special characters."\r
1262     func_dirname_and_basename "$obj" "/" ""\r
1263     objname="$func_basename_result"\r
1264     xdir="$func_dirname_result"\r
1265     lobj=${xdir}$objdir/$objname\r
1266 \r
1267     test -z "$base_compile" && \\r
1268       func_fatal_help "you must specify a compilation command"\r
1269 \r
1270     # Delete any leftover library objects.\r
1271     if test "$build_old_libs" = yes; then\r
1272       removelist="$obj $lobj $libobj ${libobj}T"\r
1273     else\r
1274       removelist="$lobj $libobj ${libobj}T"\r
1275     fi\r
1276 \r
1277     # On Cygwin there's no "real" PIC flag so we must build both object types\r
1278     case $host_os in\r
1279     cygwin* | mingw* | pw32* | os2* | cegcc*)\r
1280       pic_mode=default\r
1281       ;;\r
1282     esac\r
1283     if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then\r
1284       # non-PIC code in shared libraries is not supported\r
1285       pic_mode=default\r
1286     fi\r
1287 \r
1288     # Calculate the filename of the output object if compiler does\r
1289     # not support -o with -c\r
1290     if test "$compiler_c_o" = no; then\r
1291       output_obj=`$ECHO "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}\r
1292       lockfile="$output_obj.lock"\r
1293     else\r
1294       output_obj=\r
1295       need_locks=no\r
1296       lockfile=\r
1297     fi\r
1298 \r
1299     # Lock this critical section if it is needed\r
1300     # We use this script file to make the link, it avoids creating a new file\r
1301     if test "$need_locks" = yes; then\r
1302       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do\r
1303         func_echo "Waiting for $lockfile to be removed"\r
1304         sleep 2\r
1305       done\r
1306     elif test "$need_locks" = warn; then\r
1307       if test -f "$lockfile"; then\r
1308         $ECHO "\\r
1309 *** ERROR, $lockfile exists and contains:\r
1310 `cat $lockfile 2>/dev/null`\r
1311 \r
1312 This indicates that another process is trying to use the same\r
1313 temporary object file, and libtool could not work around it because\r
1314 your compiler does not support \`-c' and \`-o' together.  If you\r
1315 repeat this compilation, it may succeed, by chance, but you had better\r
1316 avoid parallel builds (make -j) in this platform, or get a better\r
1317 compiler."\r
1318 \r
1319         $opt_dry_run || $RM $removelist\r
1320         exit $EXIT_FAILURE\r
1321       fi\r
1322       removelist="$removelist $output_obj"\r
1323       $ECHO "$srcfile" > "$lockfile"\r
1324     fi\r
1325 \r
1326     $opt_dry_run || $RM $removelist\r
1327     removelist="$removelist $lockfile"\r
1328     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15\r
1329 \r
1330     if test -n "$fix_srcfile_path"; then\r
1331       eval srcfile=\"$fix_srcfile_path\"\r
1332     fi\r
1333     func_quote_for_eval "$srcfile"\r
1334     qsrcfile=$func_quote_for_eval_result\r
1335 \r
1336     # Only build a PIC object if we are building libtool libraries.\r
1337     if test "$build_libtool_libs" = yes; then\r
1338       # Without this assignment, base_compile gets emptied.\r
1339       fbsd_hideous_sh_bug=$base_compile\r
1340 \r
1341       if test "$pic_mode" != no; then\r
1342         command="$base_compile $qsrcfile $pic_flag"\r
1343       else\r
1344         # Don't build PIC code\r
1345         command="$base_compile $qsrcfile"\r
1346       fi\r
1347 \r
1348       func_mkdir_p "$xdir$objdir"\r
1349 \r
1350       if test -z "$output_obj"; then\r
1351         # Place PIC objects in $objdir\r
1352         command="$command -o $lobj"\r
1353       fi\r
1354 \r
1355       func_show_eval_locale "$command"  \\r
1356           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'\r
1357 \r
1358       if test "$need_locks" = warn &&\r
1359          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then\r
1360         $ECHO "\\r
1361 *** ERROR, $lockfile contains:\r
1362 `cat $lockfile 2>/dev/null`\r
1363 \r
1364 but it should contain:\r
1365 $srcfile\r
1366 \r
1367 This indicates that another process is trying to use the same\r
1368 temporary object file, and libtool could not work around it because\r
1369 your compiler does not support \`-c' and \`-o' together.  If you\r
1370 repeat this compilation, it may succeed, by chance, but you had better\r
1371 avoid parallel builds (make -j) in this platform, or get a better\r
1372 compiler."\r
1373 \r
1374         $opt_dry_run || $RM $removelist\r
1375         exit $EXIT_FAILURE\r
1376       fi\r
1377 \r
1378       # Just move the object if needed, then go on to compile the next one\r
1379       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then\r
1380         func_show_eval '$MV "$output_obj" "$lobj"' \\r
1381           'error=$?; $opt_dry_run || $RM $removelist; exit $error'\r
1382       fi\r
1383 \r
1384       # Allow error messages only from the first compilation.\r
1385       if test "$suppress_opt" = yes; then\r
1386         suppress_output=' >/dev/null 2>&1'\r
1387       fi\r
1388     fi\r
1389 \r
1390     # Only build a position-dependent object if we build old libraries.\r
1391     if test "$build_old_libs" = yes; then\r
1392       if test "$pic_mode" != yes; then\r
1393         # Don't build PIC code\r
1394         command="$base_compile $qsrcfile$pie_flag"\r
1395       else\r
1396         command="$base_compile $qsrcfile $pic_flag"\r
1397       fi\r
1398       if test "$compiler_c_o" = yes; then\r
1399         command="$command -o $obj"\r
1400       fi\r
1401 \r
1402       # Suppress compiler output if we already did a PIC compilation.\r
1403       command="$command$suppress_output"\r
1404       func_show_eval_locale "$command" \\r
1405         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'\r
1406 \r
1407       if test "$need_locks" = warn &&\r
1408          test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then\r
1409         $ECHO "\\r
1410 *** ERROR, $lockfile contains:\r
1411 `cat $lockfile 2>/dev/null`\r
1412 \r
1413 but it should contain:\r
1414 $srcfile\r
1415 \r
1416 This indicates that another process is trying to use the same\r
1417 temporary object file, and libtool could not work around it because\r
1418 your compiler does not support \`-c' and \`-o' together.  If you\r
1419 repeat this compilation, it may succeed, by chance, but you had better\r
1420 avoid parallel builds (make -j) in this platform, or get a better\r
1421 compiler."\r
1422 \r
1423         $opt_dry_run || $RM $removelist\r
1424         exit $EXIT_FAILURE\r
1425       fi\r
1426 \r
1427       # Just move the object if needed\r
1428       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then\r
1429         func_show_eval '$MV "$output_obj" "$obj"' \\r
1430           'error=$?; $opt_dry_run || $RM $removelist; exit $error'\r
1431       fi\r
1432     fi\r
1433 \r
1434     $opt_dry_run || {\r
1435       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"\r
1436 \r
1437       # Unlock the critical section if it was locked\r
1438       if test "$need_locks" != no; then\r
1439         removelist=$lockfile\r
1440         $RM "$lockfile"\r
1441       fi\r
1442     }\r
1443 \r
1444     exit $EXIT_SUCCESS\r
1445 }\r
1446 \r
1447 $opt_help || {\r
1448 test "$mode" = compile && func_mode_compile ${1+"$@"}\r
1449 }\r
1450 \r
1451 func_mode_help ()\r
1452 {\r
1453     # We need to display help for each of the modes.\r
1454     case $mode in\r
1455       "")\r
1456         # Generic help is extracted from the usage comments\r
1457         # at the start of this file.\r
1458         func_help\r
1459         ;;\r
1460 \r
1461       clean)\r
1462         $ECHO \\r
1463 "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...\r
1464 \r
1465 Remove files from the build directory.\r
1466 \r
1467 RM is the name of the program to use to delete files associated with each FILE\r
1468 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed\r
1469 to RM.\r
1470 \r
1471 If FILE is a libtool library, object or program, all the files associated\r
1472 with it are deleted. Otherwise, only FILE itself is deleted using RM."\r
1473         ;;\r
1474 \r
1475       compile)\r
1476       $ECHO \\r
1477 "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE\r
1478 \r
1479 Compile a source file into a libtool library object.\r
1480 \r
1481 This mode accepts the following additional options:\r
1482 \r
1483   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE\r
1484   -no-suppress      do not suppress compiler output for multiple passes\r
1485   -prefer-pic       try to building PIC objects only\r
1486   -prefer-non-pic   try to building non-PIC objects only\r
1487   -shared           do not build a \`.o' file suitable for static linking\r
1488   -static           only build a \`.o' file suitable for static linking\r
1489 \r
1490 COMPILE-COMMAND is a command to be used in creating a \`standard' object file\r
1491 from the given SOURCEFILE.\r
1492 \r
1493 The output file name is determined by removing the directory component from\r
1494 SOURCEFILE, then substituting the C source code suffix \`.c' with the\r
1495 library object suffix, \`.lo'."\r
1496         ;;\r
1497 \r
1498       execute)\r
1499         $ECHO \\r
1500 "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...\r
1501 \r
1502 Automatically set library path, then run a program.\r
1503 \r
1504 This mode accepts the following additional options:\r
1505 \r
1506   -dlopen FILE      add the directory containing FILE to the library path\r
1507 \r
1508 This mode sets the library path environment variable according to \`-dlopen'\r
1509 flags.\r
1510 \r
1511 If any of the ARGS are libtool executable wrappers, then they are translated\r
1512 into their corresponding uninstalled binary, and any of their required library\r
1513 directories are added to the library path.\r
1514 \r
1515 Then, COMMAND is executed, with ARGS as arguments."\r
1516         ;;\r
1517 \r
1518       finish)\r
1519         $ECHO \\r
1520 "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...\r
1521 \r
1522 Complete the installation of libtool libraries.\r
1523 \r
1524 Each LIBDIR is a directory that contains libtool libraries.\r
1525 \r
1526 The commands that this mode executes may require superuser privileges.  Use\r
1527 the \`--dry-run' option if you just want to see what would be executed."\r
1528         ;;\r
1529 \r
1530       install)\r
1531         $ECHO \\r
1532 "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...\r
1533 \r
1534 Install executables or libraries.\r
1535 \r
1536 INSTALL-COMMAND is the installation command.  The first component should be\r
1537 either the \`install' or \`cp' program.\r
1538 \r
1539 The following components of INSTALL-COMMAND are treated specially:\r
1540 \r
1541   -inst-prefix PREFIX-DIR  Use PREFIX-DIR as a staging area for installation\r
1542 \r
1543 The rest of the components are interpreted as arguments to that command (only\r
1544 BSD-compatible install options are recognized)."\r
1545         ;;\r
1546 \r
1547       link)\r
1548         $ECHO \\r
1549 "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...\r
1550 \r
1551 Link object files or libraries together to form another library, or to\r
1552 create an executable program.\r
1553 \r
1554 LINK-COMMAND is a command using the C compiler that you would use to create\r
1555 a program from several object files.\r
1556 \r
1557 The following components of LINK-COMMAND are treated specially:\r
1558 \r
1559   -all-static       do not do any dynamic linking at all\r
1560   -avoid-version    do not add a version suffix if possible\r
1561   -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime\r
1562   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols\r
1563   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)\r
1564   -export-symbols SYMFILE\r
1565                     try to export only the symbols listed in SYMFILE\r
1566   -export-symbols-regex REGEX\r
1567                     try to export only the symbols matching REGEX\r
1568   -LLIBDIR          search LIBDIR for required installed libraries\r
1569   -lNAME            OUTPUT-FILE requires the installed library libNAME\r
1570   -module           build a library that can dlopened\r
1571   -no-fast-install  disable the fast-install mode\r
1572   -no-install       link a not-installable executable\r
1573   -no-undefined     declare that a library does not refer to external symbols\r
1574   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects\r
1575   -objectlist FILE  Use a list of object files found in FILE to specify objects\r
1576   -precious-files-regex REGEX\r
1577                     don't remove output files matching REGEX\r
1578   -release RELEASE  specify package release information\r
1579   -rpath LIBDIR     the created library will eventually be installed in LIBDIR\r
1580   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries\r
1581   -shared           only do dynamic linking of libtool libraries\r
1582   -shrext SUFFIX    override the standard shared library file extension\r
1583   -static           do not do any dynamic linking of uninstalled libtool libraries\r
1584   -static-libtool-libs\r
1585                     do not do any dynamic linking of libtool libraries\r
1586   -version-info CURRENT[:REVISION[:AGE]]\r
1587                     specify library version info [each variable defaults to 0]\r
1588   -weak LIBNAME     declare that the target provides the LIBNAME interface\r
1589 \r
1590 All other options (arguments beginning with \`-') are ignored.\r
1591 \r
1592 Every other argument is treated as a filename.  Files ending in \`.la' are\r
1593 treated as uninstalled libtool libraries, other files are standard or library\r
1594 object files.\r
1595 \r
1596 If the OUTPUT-FILE ends in \`.la', then a libtool library is created,\r
1597 only library objects (\`.lo' files) may be specified, and \`-rpath' is\r
1598 required, except when creating a convenience library.\r
1599 \r
1600 If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created\r
1601 using \`ar' and \`ranlib', or on Windows using \`lib'.\r
1602 \r
1603 If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file\r
1604 is created, otherwise an executable program is created."\r
1605         ;;\r
1606 \r
1607       uninstall)\r
1608         $ECHO \\r
1609 "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...\r
1610 \r
1611 Remove libraries from an installation directory.\r
1612 \r
1613 RM is the name of the program to use to delete files associated with each FILE\r
1614 (typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed\r
1615 to RM.\r
1616 \r
1617 If FILE is a libtool library, all the files associated with it are deleted.\r
1618 Otherwise, only FILE itself is deleted using RM."\r
1619         ;;\r
1620 \r
1621       *)\r
1622         func_fatal_help "invalid operation mode \`$mode'"\r
1623         ;;\r
1624     esac\r
1625 \r
1626     $ECHO\r
1627     $ECHO "Try \`$progname --help' for more information about other modes."\r
1628 \r
1629     exit $?\r
1630 }\r
1631 \r
1632   # Now that we've collected a possible --mode arg, show help if necessary\r
1633   $opt_help && func_mode_help\r
1634 \r
1635 \r
1636 # func_mode_execute arg...\r
1637 func_mode_execute ()\r
1638 {\r
1639     $opt_debug\r
1640     # The first argument is the command name.\r
1641     cmd="$nonopt"\r
1642     test -z "$cmd" && \\r
1643       func_fatal_help "you must specify a COMMAND"\r
1644 \r
1645     # Handle -dlopen flags immediately.\r
1646     for file in $execute_dlfiles; do\r
1647       test -f "$file" \\r
1648         || func_fatal_help "\`$file' is not a file"\r
1649 \r
1650       dir=\r
1651       case $file in\r
1652       *.la)\r
1653         # Check to see that this really is a libtool archive.\r
1654         func_lalib_unsafe_p "$file" \\r
1655           || func_fatal_help "\`$lib' is not a valid libtool archive"\r
1656 \r
1657         # Read the libtool library.\r
1658         dlname=\r
1659         library_names=\r
1660         func_source "$file"\r
1661 \r
1662         # Skip this library if it cannot be dlopened.\r
1663         if test -z "$dlname"; then\r
1664           # Warn if it was a shared library.\r
1665           test -n "$library_names" && \\r
1666             func_warning "\`$file' was not linked with \`-export-dynamic'"\r
1667           continue\r
1668         fi\r
1669 \r
1670         func_dirname "$file" "" "."\r
1671         dir="$func_dirname_result"\r
1672 \r
1673         if test -f "$dir/$objdir/$dlname"; then\r
1674           dir="$dir/$objdir"\r
1675         else\r
1676           if test ! -f "$dir/$dlname"; then\r
1677             func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"\r
1678           fi\r
1679         fi\r
1680         ;;\r
1681 \r
1682       *.lo)\r
1683         # Just add the directory containing the .lo file.\r
1684         func_dirname "$file" "" "."\r
1685         dir="$func_dirname_result"\r
1686         ;;\r
1687 \r
1688       *)\r
1689         func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"\r
1690         continue\r
1691         ;;\r
1692       esac\r
1693 \r
1694       # Get the absolute pathname.\r
1695       absdir=`cd "$dir" && pwd`\r
1696       test -n "$absdir" && dir="$absdir"\r
1697 \r
1698       # Now add the directory to shlibpath_var.\r
1699       if eval "test -z \"\$$shlibpath_var\""; then\r
1700         eval "$shlibpath_var=\"\$dir\""\r
1701       else\r
1702         eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""\r
1703       fi\r
1704     done\r
1705 \r
1706     # This variable tells wrapper scripts just to set shlibpath_var\r
1707     # rather than running their programs.\r
1708     libtool_execute_magic="$magic"\r
1709 \r
1710     # Check if any of the arguments is a wrapper script.\r
1711     args=\r
1712     for file\r
1713     do\r
1714       case $file in\r
1715       -*) ;;\r
1716       *)\r
1717         # Do a test to see if this is really a libtool program.\r
1718         if func_ltwrapper_script_p "$file"; then\r
1719           func_source "$file"\r
1720           # Transform arg to wrapped name.\r
1721           file="$progdir/$program"\r
1722         elif func_ltwrapper_executable_p "$file"; then\r
1723           func_ltwrapper_scriptname "$file"\r
1724           func_source "$func_ltwrapper_scriptname_result"\r
1725           # Transform arg to wrapped name.\r
1726           file="$progdir/$program"\r
1727         fi\r
1728         ;;\r
1729       esac\r
1730       # Quote arguments (to preserve shell metacharacters).\r
1731       func_quote_for_eval "$file"\r
1732       args="$args $func_quote_for_eval_result"\r
1733     done\r
1734 \r
1735     if test "X$opt_dry_run" = Xfalse; then\r
1736       if test -n "$shlibpath_var"; then\r
1737         # Export the shlibpath_var.\r
1738         eval "export $shlibpath_var"\r
1739       fi\r
1740 \r
1741       # Restore saved environment variables\r
1742       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES\r
1743       do\r
1744         eval "if test \"\${save_$lt_var+set}\" = set; then\r
1745                 $lt_var=\$save_$lt_var; export $lt_var\r
1746               else\r
1747                 $lt_unset $lt_var\r
1748               fi"\r
1749       done\r
1750 \r
1751       # Now prepare to actually exec the command.\r
1752       exec_cmd="\$cmd$args"\r
1753     else\r
1754       # Display what would be done.\r
1755       if test -n "$shlibpath_var"; then\r
1756         eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""\r
1757         $ECHO "export $shlibpath_var"\r
1758       fi\r
1759       $ECHO "$cmd$args"\r
1760       exit $EXIT_SUCCESS\r
1761     fi\r
1762 }\r
1763 \r
1764 test "$mode" = execute && func_mode_execute ${1+"$@"}\r
1765 \r
1766 \r
1767 # func_mode_finish arg...\r
1768 func_mode_finish ()\r
1769 {\r
1770     $opt_debug\r
1771     libdirs="$nonopt"\r
1772     admincmds=\r
1773 \r
1774     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then\r
1775       for dir\r
1776       do\r
1777         libdirs="$libdirs $dir"\r
1778       done\r
1779 \r
1780       for libdir in $libdirs; do\r
1781         if test -n "$finish_cmds"; then\r
1782           # Do each command in the finish commands.\r
1783           func_execute_cmds "$finish_cmds" 'admincmds="$admincmds\r
1784 '"$cmd"'"'\r
1785         fi\r
1786         if test -n "$finish_eval"; then\r
1787           # Do the single finish_eval.\r
1788           eval cmds=\"$finish_eval\"\r
1789           $opt_dry_run || eval "$cmds" || admincmds="$admincmds\r
1790        $cmds"\r
1791         fi\r
1792       done\r
1793     fi\r
1794 \r
1795     # Exit here if they wanted silent mode.\r
1796     $opt_silent && exit $EXIT_SUCCESS\r
1797 \r
1798     $ECHO "X----------------------------------------------------------------------" | $Xsed\r
1799     $ECHO "Libraries have been installed in:"\r
1800     for libdir in $libdirs; do\r
1801       $ECHO "   $libdir"\r
1802     done\r
1803     $ECHO\r
1804     $ECHO "If you ever happen to want to link against installed libraries"\r
1805     $ECHO "in a given directory, LIBDIR, you must either use libtool, and"\r
1806     $ECHO "specify the full pathname of the library, or use the \`-LLIBDIR'"\r
1807     $ECHO "flag during linking and do at least one of the following:"\r
1808     if test -n "$shlibpath_var"; then\r
1809       $ECHO "   - add LIBDIR to the \`$shlibpath_var' environment variable"\r
1810       $ECHO "     during execution"\r
1811     fi\r
1812     if test -n "$runpath_var"; then\r
1813       $ECHO "   - add LIBDIR to the \`$runpath_var' environment variable"\r
1814       $ECHO "     during linking"\r
1815     fi\r
1816     if test -n "$hardcode_libdir_flag_spec"; then\r
1817       libdir=LIBDIR\r
1818       eval flag=\"$hardcode_libdir_flag_spec\"\r
1819 \r
1820       $ECHO "   - use the \`$flag' linker flag"\r
1821     fi\r
1822     if test -n "$admincmds"; then\r
1823       $ECHO "   - have your system administrator run these commands:$admincmds"\r
1824     fi\r
1825     if test -f /etc/ld.so.conf; then\r
1826       $ECHO "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"\r
1827     fi\r
1828     $ECHO\r
1829 \r
1830     $ECHO "See any operating system documentation about shared libraries for"\r
1831     case $host in\r
1832       solaris2.[6789]|solaris2.1[0-9])\r
1833         $ECHO "more information, such as the ld(1), crle(1) and ld.so(8) manual"\r
1834         $ECHO "pages."\r
1835         ;;\r
1836       *)\r
1837         $ECHO "more information, such as the ld(1) and ld.so(8) manual pages."\r
1838         ;;\r
1839     esac\r
1840     $ECHO "X----------------------------------------------------------------------" | $Xsed\r
1841     exit $EXIT_SUCCESS\r
1842 }\r
1843 \r
1844 test "$mode" = finish && func_mode_finish ${1+"$@"}\r
1845 \r
1846 \r
1847 # func_mode_install arg...\r
1848 func_mode_install ()\r
1849 {\r
1850     $opt_debug\r
1851     # There may be an optional sh(1) argument at the beginning of\r
1852     # install_prog (especially on Windows NT).\r
1853     if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||\r
1854        # Allow the use of GNU shtool's install command.\r
1855        $ECHO "X$nonopt" | $GREP shtool >/dev/null; then\r
1856       # Aesthetically quote it.\r
1857       func_quote_for_eval "$nonopt"\r
1858       install_prog="$func_quote_for_eval_result "\r
1859       arg=$1\r
1860       shift\r
1861     else\r
1862       install_prog=\r
1863       arg=$nonopt\r
1864     fi\r
1865 \r
1866     # The real first argument should be the name of the installation program.\r
1867     # Aesthetically quote it.\r
1868     func_quote_for_eval "$arg"\r
1869     install_prog="$install_prog$func_quote_for_eval_result"\r
1870 \r
1871     # We need to accept at least all the BSD install flags.\r
1872     dest=\r
1873     files=\r
1874     opts=\r
1875     prev=\r
1876     install_type=\r
1877     isdir=no\r
1878     stripme=\r
1879     for arg\r
1880     do\r
1881       if test -n "$dest"; then\r
1882         files="$files $dest"\r
1883         dest=$arg\r
1884         continue\r
1885       fi\r
1886 \r
1887       case $arg in\r
1888       -d) isdir=yes ;;\r
1889       -f)\r
1890         case " $install_prog " in\r
1891         *[\\\ /]cp\ *) ;;\r
1892         *) prev=$arg ;;\r
1893         esac\r
1894         ;;\r
1895       -g | -m | -o)\r
1896         prev=$arg\r
1897         ;;\r
1898       -s)\r
1899         stripme=" -s"\r
1900         continue\r
1901         ;;\r
1902       -*)\r
1903         ;;\r
1904       *)\r
1905         # If the previous option needed an argument, then skip it.\r
1906         if test -n "$prev"; then\r
1907           prev=\r
1908         else\r
1909           dest=$arg\r
1910           continue\r
1911         fi\r
1912         ;;\r
1913       esac\r
1914 \r
1915       # Aesthetically quote the argument.\r
1916       func_quote_for_eval "$arg"\r
1917       install_prog="$install_prog $func_quote_for_eval_result"\r
1918     done\r
1919 \r
1920     test -z "$install_prog" && \\r
1921       func_fatal_help "you must specify an install program"\r
1922 \r
1923     test -n "$prev" && \\r
1924       func_fatal_help "the \`$prev' option requires an argument"\r
1925 \r
1926     if test -z "$files"; then\r
1927       if test -z "$dest"; then\r
1928         func_fatal_help "no file or destination specified"\r
1929       else\r
1930         func_fatal_help "you must specify a destination"\r
1931       fi\r
1932     fi\r
1933 \r
1934     # Strip any trailing slash from the destination.\r
1935     func_stripname '' '/' "$dest"\r
1936     dest=$func_stripname_result\r
1937 \r
1938     # Check to see that the destination is a directory.\r
1939     test -d "$dest" && isdir=yes\r
1940     if test "$isdir" = yes; then\r
1941       destdir="$dest"\r
1942       destname=\r
1943     else\r
1944       func_dirname_and_basename "$dest" "" "."\r
1945       destdir="$func_dirname_result"\r
1946       destname="$func_basename_result"\r
1947 \r
1948       # Not a directory, so check to see that there is only one file specified.\r
1949       set dummy $files; shift\r
1950       test "$#" -gt 1 && \\r
1951         func_fatal_help "\`$dest' is not a directory"\r
1952     fi\r
1953     case $destdir in\r
1954     [\\/]* | [A-Za-z]:[\\/]*) ;;\r
1955     *)\r
1956       for file in $files; do\r
1957         case $file in\r
1958         *.lo) ;;\r
1959         *)\r
1960           func_fatal_help "\`$destdir' must be an absolute directory name"\r
1961           ;;\r
1962         esac\r
1963       done\r
1964       ;;\r
1965     esac\r
1966 \r
1967     # This variable tells wrapper scripts just to set variables rather\r
1968     # than running their programs.\r
1969     libtool_install_magic="$magic"\r
1970 \r
1971     staticlibs=\r
1972     future_libdirs=\r
1973     current_libdirs=\r
1974     for file in $files; do\r
1975 \r
1976       # Do each installation.\r
1977       case $file in\r
1978       *.$libext)\r
1979         # Do the static libraries later.\r
1980         staticlibs="$staticlibs $file"\r
1981         ;;\r
1982 \r
1983       *.la)\r
1984         # Check to see that this really is a libtool archive.\r
1985         func_lalib_unsafe_p "$file" \\r
1986           || func_fatal_help "\`$file' is not a valid libtool archive"\r
1987 \r
1988         library_names=\r
1989         old_library=\r
1990         relink_command=\r
1991         func_source "$file"\r
1992 \r
1993         # Add the libdir to current_libdirs if it is the destination.\r
1994         if test "X$destdir" = "X$libdir"; then\r
1995           case "$current_libdirs " in\r
1996           *" $libdir "*) ;;\r
1997           *) current_libdirs="$current_libdirs $libdir" ;;\r
1998           esac\r
1999         else\r
2000           # Note the libdir as a future libdir.\r
2001           case "$future_libdirs " in\r
2002           *" $libdir "*) ;;\r
2003           *) future_libdirs="$future_libdirs $libdir" ;;\r
2004           esac\r
2005         fi\r
2006 \r
2007         func_dirname "$file" "/" ""\r
2008         dir="$func_dirname_result"\r
2009         dir="$dir$objdir"\r
2010 \r
2011         if test -n "$relink_command"; then\r
2012           # Determine the prefix the user has applied to our future dir.\r
2013           inst_prefix_dir=`$ECHO "X$destdir" | $Xsed -e "s%$libdir\$%%"`\r
2014 \r
2015           # Don't allow the user to place us outside of our expected\r
2016           # location b/c this prevents finding dependent libraries that\r
2017           # are installed to the same prefix.\r
2018           # At present, this check doesn't affect windows .dll's that\r
2019           # are installed into $libdir/../bin (currently, that works fine)\r
2020           # but it's something to keep an eye on.\r
2021           test "$inst_prefix_dir" = "$destdir" && \\r
2022             func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"\r
2023 \r
2024           if test -n "$inst_prefix_dir"; then\r
2025             # Stick the inst_prefix_dir data into the link command.\r
2026             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`\r
2027           else\r
2028             relink_command=`$ECHO "X$relink_command" | $Xsed -e "s%@inst_prefix_dir@%%"`\r
2029           fi\r
2030 \r
2031           func_warning "relinking \`$file'"\r
2032           func_show_eval "$relink_command" \\r
2033             'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'\r
2034         fi\r
2035 \r
2036         # See the names of the shared library.\r
2037         set dummy $library_names; shift\r
2038         if test -n "$1"; then\r
2039           realname="$1"\r
2040           shift\r
2041 \r
2042           srcname="$realname"\r
2043           test -n "$relink_command" && srcname="$realname"T\r
2044 \r
2045           # Install the shared library and build the symlinks.\r
2046           func_show_eval "$install_prog $dir/$srcname $destdir/$realname" \\r
2047               'exit $?'\r
2048           tstripme="$stripme"\r
2049           case $host_os in\r
2050           cygwin* | mingw* | pw32* | cegcc*)\r
2051             case $realname in\r
2052             *.dll.a)\r
2053               tstripme=""\r
2054               ;;\r
2055             esac\r
2056             ;;\r
2057           esac\r
2058           if test -n "$tstripme" && test -n "$striplib"; then\r
2059             func_show_eval "$striplib $destdir/$realname" 'exit $?'\r
2060           fi\r
2061 \r
2062           if test "$#" -gt 0; then\r
2063             # Delete the old symlinks, and create new ones.\r
2064             # Try `ln -sf' first, because the `ln' binary might depend on\r
2065             # the symlink we replace!  Solaris /bin/ln does not understand -f,\r
2066             # so we also need to try rm && ln -s.\r
2067             for linkname\r
2068             do\r
2069               test "$linkname" != "$realname" \\r
2070                 && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"\r
2071             done\r
2072           fi\r
2073 \r
2074           # Do each command in the postinstall commands.\r
2075           lib="$destdir/$realname"\r
2076           func_execute_cmds "$postinstall_cmds" 'exit $?'\r
2077         fi\r
2078 \r
2079         # Install the pseudo-library for information purposes.\r
2080         func_basename "$file"\r
2081         name="$func_basename_result"\r
2082         instname="$dir/$name"i\r
2083         func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'\r
2084 \r
2085         # Maybe install the static library, too.\r
2086         test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"\r
2087         ;;\r
2088 \r
2089       *.lo)\r
2090         # Install (i.e. copy) a libtool object.\r
2091 \r
2092         # Figure out destination file name, if it wasn't already specified.\r
2093         if test -n "$destname"; then\r
2094           destfile="$destdir/$destname"\r
2095         else\r
2096           func_basename "$file"\r
2097           destfile="$func_basename_result"\r
2098           destfile="$destdir/$destfile"\r
2099         fi\r
2100 \r
2101         # Deduce the name of the destination old-style object file.\r
2102         case $destfile in\r
2103         *.lo)\r
2104           func_lo2o "$destfile"\r
2105           staticdest=$func_lo2o_result\r
2106           ;;\r
2107         *.$objext)\r
2108           staticdest="$destfile"\r
2109           destfile=\r
2110           ;;\r
2111         *)\r
2112           func_fatal_help "cannot copy a libtool object to \`$destfile'"\r
2113           ;;\r
2114         esac\r
2115 \r
2116         # Install the libtool object if requested.\r
2117         test -n "$destfile" && \\r
2118           func_show_eval "$install_prog $file $destfile" 'exit $?'\r
2119 \r
2120         # Install the old object if enabled.\r
2121         if test "$build_old_libs" = yes; then\r
2122           # Deduce the name of the old-style object file.\r
2123           func_lo2o "$file"\r
2124           staticobj=$func_lo2o_result\r
2125           func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'\r
2126         fi\r
2127         exit $EXIT_SUCCESS\r
2128         ;;\r
2129 \r
2130       *)\r
2131         # Figure out destination file name, if it wasn't already specified.\r
2132         if test -n "$destname"; then\r
2133           destfile="$destdir/$destname"\r
2134         else\r
2135           func_basename "$file"\r
2136           destfile="$func_basename_result"\r
2137           destfile="$destdir/$destfile"\r
2138         fi\r
2139 \r
2140         # If the file is missing, and there is a .exe on the end, strip it\r
2141         # because it is most likely a libtool script we actually want to\r
2142         # install\r
2143         stripped_ext=""\r
2144         case $file in\r
2145           *.exe)\r
2146             if test ! -f "$file"; then\r
2147               func_stripname '' '.exe' "$file"\r
2148               file=$func_stripname_result\r
2149               stripped_ext=".exe"\r
2150             fi\r
2151             ;;\r
2152         esac\r
2153 \r
2154         # Do a test to see if this is really a libtool program.\r
2155         case $host in\r
2156         *cygwin* | *mingw*)\r
2157             if func_ltwrapper_executable_p "$file"; then\r
2158               func_ltwrapper_scriptname "$file"\r
2159               wrapper=$func_ltwrapper_scriptname_result\r
2160             else\r
2161               func_stripname '' '.exe' "$file"\r
2162               wrapper=$func_stripname_result\r
2163             fi\r
2164             ;;\r
2165         *)\r
2166             wrapper=$file\r
2167             ;;\r
2168         esac\r
2169         if func_ltwrapper_script_p "$wrapper"; then\r
2170           notinst_deplibs=\r
2171           relink_command=\r
2172 \r
2173           func_source "$wrapper"\r
2174 \r
2175           # Check the variables that should have been set.\r
2176           test -z "$generated_by_libtool_version" && \\r
2177             func_fatal_error "invalid libtool wrapper script \`$wrapper'"\r
2178 \r
2179           finalize=yes\r
2180           for lib in $notinst_deplibs; do\r
2181             # Check to see that each library is installed.\r
2182             libdir=\r
2183             if test -f "$lib"; then\r
2184               func_source "$lib"\r
2185             fi\r
2186             libfile="$libdir/"`$ECHO "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test\r
2187             if test -n "$libdir" && test ! -f "$libfile"; then\r
2188               func_warning "\`$lib' has not been installed in \`$libdir'"\r
2189               finalize=no\r
2190             fi\r
2191           done\r
2192 \r
2193           relink_command=\r
2194           func_source "$wrapper"\r
2195 \r
2196           outputname=\r
2197           if test "$fast_install" = no && test -n "$relink_command"; then\r
2198             $opt_dry_run || {\r
2199               if test "$finalize" = yes; then\r
2200                 tmpdir=`func_mktempdir`\r
2201                 func_basename "$file$stripped_ext"\r
2202                 file="$func_basename_result"\r
2203                 outputname="$tmpdir/$file"\r
2204                 # Replace the output file specification.\r
2205                 relink_command=`$ECHO "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`\r
2206 \r
2207                 $opt_silent || {\r
2208                   func_quote_for_expand "$relink_command"\r
2209                   eval "func_echo $func_quote_for_expand_result"\r
2210                 }\r
2211                 if eval "$relink_command"; then :\r
2212                   else\r
2213                   func_error "error: relink \`$file' with the above command before installing it"\r
2214                   $opt_dry_run || ${RM}r "$tmpdir"\r
2215                   continue\r
2216                 fi\r
2217                 file="$outputname"\r
2218               else\r
2219                 func_warning "cannot relink \`$file'"\r
2220               fi\r
2221             }\r
2222           else\r
2223             # Install the binary that we compiled earlier.\r
2224             file=`$ECHO "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`\r
2225           fi\r
2226         fi\r
2227 \r
2228         # remove .exe since cygwin /usr/bin/install will append another\r
2229         # one anyway\r
2230         case $install_prog,$host in\r
2231         */usr/bin/install*,*cygwin*)\r
2232           case $file:$destfile in\r
2233           *.exe:*.exe)\r
2234             # this is ok\r
2235             ;;\r
2236           *.exe:*)\r
2237             destfile=$destfile.exe\r
2238             ;;\r
2239           *:*.exe)\r
2240             func_stripname '' '.exe' "$destfile"\r
2241             destfile=$func_stripname_result\r
2242             ;;\r
2243           esac\r
2244           ;;\r
2245         esac\r
2246         func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'\r
2247         $opt_dry_run || if test -n "$outputname"; then\r
2248           ${RM}r "$tmpdir"\r
2249         fi\r
2250         ;;\r
2251       esac\r
2252     done\r
2253 \r
2254     for file in $staticlibs; do\r
2255       func_basename "$file"\r
2256       name="$func_basename_result"\r
2257 \r
2258       # Set up the ranlib parameters.\r
2259       oldlib="$destdir/$name"\r
2260 \r
2261       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'\r
2262 \r
2263       if test -n "$stripme" && test -n "$old_striplib"; then\r
2264         func_show_eval "$old_striplib $oldlib" 'exit $?'\r
2265       fi\r
2266 \r
2267       # Do each command in the postinstall commands.\r
2268       func_execute_cmds "$old_postinstall_cmds" 'exit $?'\r
2269     done\r
2270 \r
2271     test -n "$future_libdirs" && \\r
2272       func_warning "remember to run \`$progname --finish$future_libdirs'"\r
2273 \r
2274     if test -n "$current_libdirs"; then\r
2275       # Maybe just do a dry run.\r
2276       $opt_dry_run && current_libdirs=" -n$current_libdirs"\r
2277       exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'\r
2278     else\r
2279       exit $EXIT_SUCCESS\r
2280     fi\r
2281 }\r
2282 \r
2283 test "$mode" = install && func_mode_install ${1+"$@"}\r
2284 \r
2285 \r
2286 # func_generate_dlsyms outputname originator pic_p\r
2287 # Extract symbols from dlprefiles and create ${outputname}S.o with\r
2288 # a dlpreopen symbol table.\r
2289 func_generate_dlsyms ()\r
2290 {\r
2291     $opt_debug\r
2292     my_outputname="$1"\r
2293     my_originator="$2"\r
2294     my_pic_p="${3-no}"\r
2295     my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`\r
2296     my_dlsyms=\r
2297 \r
2298     if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then\r
2299       if test -n "$NM" && test -n "$global_symbol_pipe"; then\r
2300         my_dlsyms="${my_outputname}S.c"\r
2301       else\r
2302         func_error "not configured to extract global symbols from dlpreopened files"\r
2303       fi\r
2304     fi\r
2305 \r
2306     if test -n "$my_dlsyms"; then\r
2307       case $my_dlsyms in\r
2308       "") ;;\r
2309       *.c)\r
2310         # Discover the nlist of each of the dlfiles.\r
2311         nlist="$output_objdir/${my_outputname}.nm"\r
2312 \r
2313         func_show_eval "$RM $nlist ${nlist}S ${nlist}T"\r
2314 \r
2315         # Parse the name list into a source file.\r
2316         func_verbose "creating $output_objdir/$my_dlsyms"\r
2317 \r
2318         $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\\r
2319 /* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */\r
2320 /* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */\r
2321 \r
2322 #ifdef __cplusplus\r
2323 extern \"C\" {\r
2324 #endif\r
2325 \r
2326 /* External symbol declarations for the compiler. */\\r
2327 "\r
2328 \r
2329         if test "$dlself" = yes; then\r
2330           func_verbose "generating symbol list for \`$output'"\r
2331 \r
2332           $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"\r
2333 \r
2334           # Add our own program objects to the symbol list.\r
2335           progfiles=`$ECHO "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`\r
2336           for progfile in $progfiles; do\r
2337             func_verbose "extracting global C symbols from \`$progfile'"\r
2338             $opt_dry_run || eval "$NM $progfile | $global_symbol_pipe >> '$nlist'"\r
2339           done\r
2340 \r
2341           if test -n "$exclude_expsyms"; then\r
2342             $opt_dry_run || {\r
2343               eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'\r
2344               eval '$MV "$nlist"T "$nlist"'\r
2345             }\r
2346           fi\r
2347 \r
2348           if test -n "$export_symbols_regex"; then\r
2349             $opt_dry_run || {\r
2350               eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'\r
2351               eval '$MV "$nlist"T "$nlist"'\r
2352             }\r
2353           fi\r
2354 \r
2355           # Prepare the list of exported symbols\r
2356           if test -z "$export_symbols"; then\r
2357             export_symbols="$output_objdir/$outputname.exp"\r
2358             $opt_dry_run || {\r
2359               $RM $export_symbols\r
2360               eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'\r
2361               case $host in\r
2362               *cygwin* | *mingw* | *cegcc* )\r
2363                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'\r
2364                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'\r
2365                 ;;\r
2366               esac\r
2367             }\r
2368           else\r
2369             $opt_dry_run || {\r
2370               eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'\r
2371               eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'\r
2372               eval '$MV "$nlist"T "$nlist"'\r
2373               case $host in\r
2374                 *cygwin | *mingw* | *cegcc* )\r
2375                   eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'\r
2376                   eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'\r
2377                   ;;\r
2378               esac\r
2379             }\r
2380           fi\r
2381         fi\r
2382 \r
2383         for dlprefile in $dlprefiles; do\r
2384           func_verbose "extracting global C symbols from \`$dlprefile'"\r
2385           func_basename "$dlprefile"\r
2386           name="$func_basename_result"\r
2387           $opt_dry_run || {\r
2388             eval '$ECHO ": $name " >> "$nlist"'\r
2389             eval "$NM $dlprefile 2>/dev/null | $global_symbol_pipe >> '$nlist'"\r
2390           }\r
2391         done\r
2392 \r
2393         $opt_dry_run || {\r
2394           # Make sure we have at least an empty file.\r
2395           test -f "$nlist" || : > "$nlist"\r
2396 \r
2397           if test -n "$exclude_expsyms"; then\r
2398             $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T\r
2399             $MV "$nlist"T "$nlist"\r
2400           fi\r
2401 \r
2402           # Try sorting and uniquifying the output.\r
2403           if $GREP -v "^: " < "$nlist" |\r
2404               if sort -k 3 </dev/null >/dev/null 2>&1; then\r
2405                 sort -k 3\r
2406               else\r
2407                 sort +2\r
2408               fi |\r
2409               uniq > "$nlist"S; then\r
2410             :\r
2411           else\r
2412             $GREP -v "^: " < "$nlist" > "$nlist"S\r
2413           fi\r
2414 \r
2415           if test -f "$nlist"S; then\r
2416             eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'\r
2417           else\r
2418             $ECHO '/* NONE */' >> "$output_objdir/$my_dlsyms"\r
2419           fi\r
2420 \r
2421           $ECHO >> "$output_objdir/$my_dlsyms" "\\r
2422 \r
2423 /* The mapping between symbol names and symbols.  */\r
2424 typedef struct {\r
2425   const char *name;\r
2426   void *address;\r
2427 } lt_dlsymlist;\r
2428 "\r
2429           case $host in\r
2430           *cygwin* | *mingw* | *cegcc* )\r
2431             $ECHO >> "$output_objdir/$my_dlsyms" "\\r
2432 /* DATA imports from DLLs on WIN32 con't be const, because\r
2433    runtime relocations are performed -- see ld's documentation\r
2434    on pseudo-relocs.  */"\r
2435             lt_dlsym_const= ;;\r
2436           *osf5*)\r
2437             echo >> "$output_objdir/$my_dlsyms" "\\r
2438 /* This system does not cope well with relocations in const data */"\r
2439             lt_dlsym_const= ;;\r
2440           *)\r
2441             lt_dlsym_const=const ;;\r
2442           esac\r
2443 \r
2444           $ECHO >> "$output_objdir/$my_dlsyms" "\\r
2445 extern $lt_dlsym_const lt_dlsymlist\r
2446 lt_${my_prefix}_LTX_preloaded_symbols[];\r
2447 $lt_dlsym_const lt_dlsymlist\r
2448 lt_${my_prefix}_LTX_preloaded_symbols[] =\r
2449 {\\r
2450   { \"$my_originator\", (void *) 0 },"\r
2451 \r
2452           case $need_lib_prefix in\r
2453           no)\r
2454             eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"\r
2455             ;;\r
2456           *)\r
2457             eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"\r
2458             ;;\r
2459           esac\r
2460           $ECHO >> "$output_objdir/$my_dlsyms" "\\r
2461   {0, (void *) 0}\r
2462 };\r
2463 \r
2464 /* This works around a problem in FreeBSD linker */\r
2465 #ifdef FREEBSD_WORKAROUND\r
2466 static const void *lt_preloaded_setup() {\r
2467   return lt_${my_prefix}_LTX_preloaded_symbols;\r
2468 }\r
2469 #endif\r
2470 \r
2471 #ifdef __cplusplus\r
2472 }\r
2473 #endif\\r
2474 "\r
2475         } # !$opt_dry_run\r
2476 \r
2477         pic_flag_for_symtable=\r
2478         case "$compile_command " in\r
2479         *" -static "*) ;;\r
2480         *)\r
2481           case $host in\r
2482           # compiling the symbol table file with pic_flag works around\r
2483           # a FreeBSD bug that causes programs to crash when -lm is\r
2484           # linked before any other PIC object.  But we must not use\r
2485           # pic_flag when linking with -static.  The problem exists in\r
2486           # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.\r
2487           *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)\r
2488             pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;\r
2489           *-*-hpux*)\r
2490             pic_flag_for_symtable=" $pic_flag"  ;;\r
2491           *)\r
2492             if test "X$my_pic_p" != Xno; then\r
2493               pic_flag_for_symtable=" $pic_flag"\r
2494             fi\r
2495             ;;\r
2496           esac\r
2497           ;;\r
2498         esac\r
2499         symtab_cflags=\r
2500         for arg in $LTCFLAGS; do\r
2501           case $arg in\r
2502           -pie | -fpie | -fPIE) ;;\r
2503           *) symtab_cflags="$symtab_cflags $arg" ;;\r
2504           esac\r
2505         done\r
2506 \r
2507         # Now compile the dynamic symbol file.\r
2508         func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'\r
2509 \r
2510         # Clean up the generated files.\r
2511         func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'\r
2512 \r
2513         # Transform the symbol file into the correct name.\r
2514         symfileobj="$output_objdir/${my_outputname}S.$objext"\r
2515         case $host in\r
2516         *cygwin* | *mingw* | *cegcc* )\r
2517           if test -f "$output_objdir/$my_outputname.def"; then\r
2518             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`\r
2519             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`\r
2520           else\r
2521             compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`\r
2522             finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`\r
2523           fi\r
2524           ;;\r
2525         *)\r
2526           compile_command=`$ECHO "X$compile_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`\r
2527           finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$symfileobj%"`\r
2528           ;;\r
2529         esac\r
2530         ;;\r
2531       *)\r
2532         func_fatal_error "unknown suffix for \`$my_dlsyms'"\r
2533         ;;\r
2534       esac\r
2535     else\r
2536       # We keep going just in case the user didn't refer to\r
2537       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe\r
2538       # really was required.\r
2539 \r
2540       # Nullify the symbol file.\r
2541       compile_command=`$ECHO "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`\r
2542       finalize_command=`$ECHO "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`\r
2543     fi\r
2544 }\r
2545 \r
2546 # func_win32_libid arg\r
2547 # return the library type of file 'arg'\r
2548 #\r
2549 # Need a lot of goo to handle *both* DLLs and import libs\r
2550 # Has to be a shell function in order to 'eat' the argument\r
2551 # that is supplied when $file_magic_command is called.\r
2552 func_win32_libid ()\r
2553 {\r
2554   $opt_debug\r
2555   win32_libid_type="unknown"\r
2556   win32_fileres=`file -L $1 2>/dev/null`\r
2557   case $win32_fileres in\r
2558   *ar\ archive\ import\ library*) # definitely import\r
2559     win32_libid_type="x86 archive import"\r
2560     ;;\r
2561   *ar\ archive*) # could be an import, or static\r
2562     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |\r
2563        $EGREP 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then\r
2564       win32_nmres=`eval $NM -f posix -A $1 |\r
2565         $SED -n -e '\r
2566             1,100{\r
2567                 / I /{\r
2568                     s,.*,import,\r
2569                     p\r
2570                     q\r
2571                 }\r
2572             }'`\r
2573       case $win32_nmres in\r
2574       import*)  win32_libid_type="x86 archive import";;\r
2575       *)        win32_libid_type="x86 archive static";;\r
2576       esac\r
2577     fi\r
2578     ;;\r
2579   *DLL*)\r
2580     win32_libid_type="x86 DLL"\r
2581     ;;\r
2582   *executable*) # but shell scripts are "executable" too...\r
2583     case $win32_fileres in\r
2584     *MS\ Windows\ PE\ Intel*)\r
2585       win32_libid_type="x86 DLL"\r
2586       ;;\r
2587     esac\r
2588     ;;\r
2589   esac\r
2590   $ECHO "$win32_libid_type"\r
2591 }\r
2592 \r
2593 \r
2594 \r
2595 # func_extract_an_archive dir oldlib\r
2596 func_extract_an_archive ()\r
2597 {\r
2598     $opt_debug\r
2599     f_ex_an_ar_dir="$1"; shift\r
2600     f_ex_an_ar_oldlib="$1"\r
2601     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" 'exit $?'\r
2602     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then\r
2603      :\r
2604     else\r
2605       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"\r
2606     fi\r
2607 }\r
2608 \r
2609 \r
2610 # func_extract_archives gentop oldlib ...\r
2611 func_extract_archives ()\r
2612 {\r
2613     $opt_debug\r
2614     my_gentop="$1"; shift\r
2615     my_oldlibs=${1+"$@"}\r
2616     my_oldobjs=""\r
2617     my_xlib=""\r
2618     my_xabs=""\r
2619     my_xdir=""\r
2620 \r
2621     for my_xlib in $my_oldlibs; do\r
2622       # Extract the objects.\r
2623       case $my_xlib in\r
2624         [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;\r
2625         *) my_xabs=`pwd`"/$my_xlib" ;;\r
2626       esac\r
2627       func_basename "$my_xlib"\r
2628       my_xlib="$func_basename_result"\r
2629       my_xlib_u=$my_xlib\r
2630       while :; do\r
2631         case " $extracted_archives " in\r
2632         *" $my_xlib_u "*)\r
2633           func_arith $extracted_serial + 1\r
2634           extracted_serial=$func_arith_result\r
2635           my_xlib_u=lt$extracted_serial-$my_xlib ;;\r
2636         *) break ;;\r
2637         esac\r
2638       done\r
2639       extracted_archives="$extracted_archives $my_xlib_u"\r
2640       my_xdir="$my_gentop/$my_xlib_u"\r
2641 \r
2642       func_mkdir_p "$my_xdir"\r
2643 \r
2644       case $host in\r
2645       *-darwin*)\r
2646         func_verbose "Extracting $my_xabs"\r
2647         # Do not bother doing anything if just a dry run\r
2648         $opt_dry_run || {\r
2649           darwin_orig_dir=`pwd`\r
2650           cd $my_xdir || exit $?\r
2651           darwin_archive=$my_xabs\r
2652           darwin_curdir=`pwd`\r
2653           darwin_base_archive=`basename "$darwin_archive"`\r
2654           darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`\r
2655           if test -n "$darwin_arches"; then\r
2656             darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`\r
2657             darwin_arch=\r
2658             func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"\r
2659             for darwin_arch in  $darwin_arches ; do\r
2660               func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"\r
2661               $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"\r
2662               cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"\r
2663               func_extract_an_archive "`pwd`" "${darwin_base_archive}"\r
2664               cd "$darwin_curdir"\r
2665               $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"\r
2666             done # $darwin_arches\r
2667             ## Okay now we've a bunch of thin objects, gotta fatten them up :)\r
2668             darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`\r
2669             darwin_file=\r
2670             darwin_files=\r
2671             for darwin_file in $darwin_filelist; do\r
2672               darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`\r
2673               $LIPO -create -output "$darwin_file" $darwin_files\r
2674             done # $darwin_filelist\r
2675             $RM -rf unfat-$$\r
2676             cd "$darwin_orig_dir"\r
2677           else\r
2678             cd $darwin_orig_dir\r
2679             func_extract_an_archive "$my_xdir" "$my_xabs"\r
2680           fi # $darwin_arches\r
2681         } # !$opt_dry_run\r
2682         ;;\r
2683       *)\r
2684         func_extract_an_archive "$my_xdir" "$my_xabs"\r
2685         ;;\r
2686       esac\r
2687       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`\r
2688     done\r
2689 \r
2690     func_extract_archives_result="$my_oldobjs"\r
2691 }\r
2692 \r
2693 \r
2694 \r
2695 # func_emit_wrapper_part1 [arg=no]\r
2696 #\r
2697 # Emit the first part of a libtool wrapper script on stdout.\r
2698 # For more information, see the description associated with\r
2699 # func_emit_wrapper(), below.\r
2700 func_emit_wrapper_part1 ()\r
2701 {\r
2702         func_emit_wrapper_part1_arg1=no\r
2703         if test -n "$1" ; then\r
2704           func_emit_wrapper_part1_arg1=$1\r
2705         fi\r
2706 \r
2707         $ECHO "\\r
2708 #! $SHELL\r
2709 \r
2710 # $output - temporary wrapper script for $objdir/$outputname\r
2711 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION\r
2712 #\r
2713 # The $output program cannot be directly executed until all the libtool\r
2714 # libraries that it depends on are installed.\r
2715 #\r
2716 # This wrapper script should never be moved out of the build directory.\r
2717 # If it is, it will not operate correctly.\r
2718 \r
2719 # Sed substitution that helps us do robust quoting.  It backslashifies\r
2720 # metacharacters that are still active within double-quoted strings.\r
2721 Xsed='${SED} -e 1s/^X//'\r
2722 sed_quote_subst='$sed_quote_subst'\r
2723 \r
2724 # Be Bourne compatible\r
2725 if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then\r
2726   emulate sh\r
2727   NULLCMD=:\r
2728   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which\r
2729   # is contrary to our usage.  Disable this feature.\r
2730   alias -g '\${1+\"\$@\"}'='\"\$@\"'\r
2731   setopt NO_GLOB_SUBST\r
2732 else\r
2733   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac\r
2734 fi\r
2735 BIN_SH=xpg4; export BIN_SH # for Tru64\r
2736 DUALCASE=1; export DUALCASE # for MKS sh\r
2737 \r
2738 # The HP-UX ksh and POSIX shell print the target directory to stdout\r
2739 # if CDPATH is set.\r
2740 (unset CDPATH) >/dev/null 2>&1 && unset CDPATH\r
2741 \r
2742 relink_command=\"$relink_command\"\r
2743 \r
2744 # This environment variable determines our operation mode.\r
2745 if test \"\$libtool_install_magic\" = \"$magic\"; then\r
2746   # install mode needs the following variables:\r
2747   generated_by_libtool_version='$macro_version'\r
2748   notinst_deplibs='$notinst_deplibs'\r
2749 else\r
2750   # When we are sourced in execute mode, \$file and \$ECHO are already set.\r
2751   if test \"\$libtool_execute_magic\" != \"$magic\"; then\r
2752     ECHO=\"$qecho\"\r
2753     file=\"\$0\"\r
2754     # Make sure echo works.\r
2755     if test \"X\$1\" = X--no-reexec; then\r
2756       # Discard the --no-reexec flag, and continue.\r
2757       shift\r
2758     elif test \"X\`{ \$ECHO '\t'; } 2>/dev/null\`\" = 'X\t'; then\r
2759       # Yippee, \$ECHO works!\r
2760       :\r
2761     else\r
2762       # Restart under the correct shell, and then maybe \$ECHO will work.\r
2763       exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}\r
2764     fi\r
2765   fi\\r
2766 "\r
2767         $ECHO "\\r
2768 \r
2769   # Find the directory that this script lives in.\r
2770   thisdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`\r
2771   test \"x\$thisdir\" = \"x\$file\" && thisdir=.\r
2772 \r
2773   # Follow symbolic links until we get to the real thisdir.\r
2774   file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`\r
2775   while test -n \"\$file\"; do\r
2776     destdir=\`\$ECHO \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`\r
2777 \r
2778     # If there was a directory component, then change thisdir.\r
2779     if test \"x\$destdir\" != \"x\$file\"; then\r
2780       case \"\$destdir\" in\r
2781       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;\r
2782       *) thisdir=\"\$thisdir/\$destdir\" ;;\r
2783       esac\r
2784     fi\r
2785 \r
2786     file=\`\$ECHO \"X\$file\" | \$Xsed -e 's%^.*/%%'\`\r
2787     file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`\r
2788   done\r
2789 "\r
2790 }\r
2791 # end: func_emit_wrapper_part1\r
2792 \r
2793 # func_emit_wrapper_part2 [arg=no]\r
2794 #\r
2795 # Emit the second part of a libtool wrapper script on stdout.\r
2796 # For more information, see the description associated with\r
2797 # func_emit_wrapper(), below.\r
2798 func_emit_wrapper_part2 ()\r
2799 {\r
2800         func_emit_wrapper_part2_arg1=no\r
2801         if test -n "$1" ; then\r
2802           func_emit_wrapper_part2_arg1=$1\r
2803         fi\r
2804 \r
2805         $ECHO "\\r
2806 \r
2807   # Usually 'no', except on cygwin/mingw when embedded into\r
2808   # the cwrapper.\r
2809   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_part2_arg1\r
2810   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then\r
2811     # special case for '.'\r
2812     if test \"\$thisdir\" = \".\"; then\r
2813       thisdir=\`pwd\`\r
2814     fi\r
2815     # remove .libs from thisdir\r
2816     case \"\$thisdir\" in\r
2817     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"X\$thisdir\" | \$Xsed -e 's%[\\\\/][^\\\\/]*$%%'\` ;;\r
2818     $objdir )   thisdir=. ;;\r
2819     esac\r
2820   fi\r
2821 \r
2822   # Try to get the absolute directory name.\r
2823   absdir=\`cd \"\$thisdir\" && pwd\`\r
2824   test -n \"\$absdir\" && thisdir=\"\$absdir\"\r
2825 "\r
2826 \r
2827         if test "$fast_install" = yes; then\r
2828           $ECHO "\\r
2829   program=lt-'$outputname'$exeext\r
2830   progdir=\"\$thisdir/$objdir\"\r
2831 \r
2832   if test ! -f \"\$progdir/\$program\" ||\r
2833      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\\r
2834        test \"X\$file\" != \"X\$progdir/\$program\"; }; then\r
2835 \r
2836     file=\"\$\$-\$program\"\r
2837 \r
2838     if test ! -d \"\$progdir\"; then\r
2839       $MKDIR \"\$progdir\"\r
2840     else\r
2841       $RM \"\$progdir/\$file\"\r
2842     fi"\r
2843 \r
2844           $ECHO "\\r
2845 \r
2846     # relink executable if necessary\r
2847     if test -n \"\$relink_command\"; then\r
2848       if relink_command_output=\`eval \$relink_command 2>&1\`; then :\r
2849       else\r
2850         $ECHO \"\$relink_command_output\" >&2\r
2851         $RM \"\$progdir/\$file\"\r
2852         exit 1\r
2853       fi\r
2854     fi\r
2855 \r
2856     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||\r
2857     { $RM \"\$progdir/\$program\";\r
2858       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }\r
2859     $RM \"\$progdir/\$file\"\r
2860   fi"\r
2861         else\r
2862           $ECHO "\\r
2863   program='$outputname'\r
2864   progdir=\"\$thisdir/$objdir\"\r
2865 "\r
2866         fi\r
2867 \r
2868         $ECHO "\\r
2869 \r
2870   if test -f \"\$progdir/\$program\"; then"\r
2871 \r
2872         # Export our shlibpath_var if we have one.\r
2873         if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then\r
2874           $ECHO "\\r
2875     # Add our own library path to $shlibpath_var\r
2876     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"\r
2877 \r
2878     # Some systems cannot cope with colon-terminated $shlibpath_var\r
2879     # The second colon is a workaround for a bug in BeOS R4 sed\r
2880     $shlibpath_var=\`\$ECHO \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`\r
2881 \r
2882     export $shlibpath_var\r
2883 "\r
2884         fi\r
2885 \r
2886         # fixup the dll searchpath if we need to.\r
2887         if test -n "$dllsearchpath"; then\r
2888           $ECHO "\\r
2889     # Add the dll search path components to the executable PATH\r
2890     PATH=$dllsearchpath:\$PATH\r
2891 "\r
2892         fi\r
2893 \r
2894         $ECHO "\\r
2895     if test \"\$libtool_execute_magic\" != \"$magic\"; then\r
2896       # Run the actual program with our arguments.\r
2897 "\r
2898         case $host in\r
2899         # Backslashes separate directories on plain windows\r
2900         *-*-mingw | *-*-os2* | *-cegcc*)\r
2901           $ECHO "\\r
2902       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}\r
2903 "\r
2904           ;;\r
2905 \r
2906         *)\r
2907           $ECHO "\\r
2908       exec \"\$progdir/\$program\" \${1+\"\$@\"}\r
2909 "\r
2910           ;;\r
2911         esac\r
2912         $ECHO "\\r
2913       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2\r
2914       exit 1\r
2915     fi\r
2916   else\r
2917     # The program doesn't exist.\r
2918     \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2\r
2919     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2\r
2920     $ECHO \"See the $PACKAGE documentation for more information.\" 1>&2\r
2921     exit 1\r
2922   fi\r
2923 fi\\r
2924 "\r
2925 }\r
2926 # end: func_emit_wrapper_part2\r
2927 \r
2928 \r
2929 # func_emit_wrapper [arg=no]\r
2930 #\r
2931 # Emit a libtool wrapper script on stdout.\r
2932 # Don't directly open a file because we may want to\r
2933 # incorporate the script contents within a cygwin/mingw\r
2934 # wrapper executable.  Must ONLY be called from within\r
2935 # func_mode_link because it depends on a number of variables\r
2936 # set therein.\r
2937 #\r
2938 # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\r
2939 # variable will take.  If 'yes', then the emitted script\r
2940 # will assume that the directory in which it is stored is\r
2941 # the $objdir directory.  This is a cygwin/mingw-specific\r
2942 # behavior.\r
2943 func_emit_wrapper ()\r
2944 {\r
2945         func_emit_wrapper_arg1=no\r
2946         if test -n "$1" ; then\r
2947           func_emit_wrapper_arg1=$1\r
2948         fi\r
2949 \r
2950         # split this up so that func_emit_cwrapperexe_src\r
2951         # can call each part independently.\r
2952         func_emit_wrapper_part1 "${func_emit_wrapper_arg1}"\r
2953         func_emit_wrapper_part2 "${func_emit_wrapper_arg1}"\r
2954 }\r
2955 \r
2956 \r
2957 # func_to_host_path arg\r
2958 #\r
2959 # Convert paths to host format when used with build tools.\r
2960 # Intended for use with "native" mingw (where libtool itself\r
2961 # is running under the msys shell), or in the following cross-\r
2962 # build environments:\r
2963 #    $build          $host\r
2964 #    mingw (msys)    mingw  [e.g. native]\r
2965 #    cygwin          mingw\r
2966 #    *nix + wine     mingw\r
2967 # where wine is equipped with the `winepath' executable.\r
2968 # In the native mingw case, the (msys) shell automatically\r
2969 # converts paths for any non-msys applications it launches,\r
2970 # but that facility isn't available from inside the cwrapper.\r
2971 # Similar accommodations are necessary for $host mingw and\r
2972 # $build cygwin.  Calling this function does no harm for other\r
2973 # $host/$build combinations not listed above.\r
2974 #\r
2975 # ARG is the path (on $build) that should be converted to\r
2976 # the proper representation for $host. The result is stored\r
2977 # in $func_to_host_path_result.\r
2978 func_to_host_path ()\r
2979 {\r
2980   func_to_host_path_result="$1"\r
2981   if test -n "$1" ; then\r
2982     case $host in\r
2983       *mingw* )\r
2984         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'\r
2985         case $build in\r
2986           *mingw* ) # actually, msys\r
2987             # awkward: cmd appends spaces to result\r
2988             lt_sed_strip_trailing_spaces="s/[ ]*\$//"\r
2989             func_to_host_path_tmp1=`( cmd //c echo "$1" |\\r
2990               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`\r
2991             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\\r
2992               $SED -e "$lt_sed_naive_backslashify"`\r
2993             ;;\r
2994           *cygwin* )\r
2995             func_to_host_path_tmp1=`cygpath -w "$1"`\r
2996             func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\\r
2997               $SED -e "$lt_sed_naive_backslashify"`\r
2998             ;;\r
2999           * )\r
3000             # Unfortunately, winepath does not exit with a non-zero\r
3001             # error code, so we are forced to check the contents of\r
3002             # stdout. On the other hand, if the command is not\r
3003             # found, the shell will set an exit code of 127 and print\r
3004             # *an error message* to stdout. So we must check for both\r
3005             # error code of zero AND non-empty stdout, which explains\r
3006             # the odd construction:\r
3007             func_to_host_path_tmp1=`winepath -w "$1" 2>/dev/null`\r
3008             if test "$?" -eq 0 && test -n "${func_to_host_path_tmp1}"; then\r
3009               func_to_host_path_result=`echo "$func_to_host_path_tmp1" |\\r
3010                 $SED -e "$lt_sed_naive_backslashify"`\r
3011             else\r
3012               # Allow warning below.\r
3013               func_to_host_path_result=""\r
3014             fi\r
3015             ;;\r
3016         esac\r
3017         if test -z "$func_to_host_path_result" ; then\r
3018           func_error "Could not determine host path corresponding to"\r
3019           func_error "  '$1'"\r
3020           func_error "Continuing, but uninstalled executables may not work."\r
3021           # Fallback:\r
3022           func_to_host_path_result="$1"\r
3023         fi\r
3024         ;;\r
3025     esac\r
3026   fi\r
3027 }\r
3028 # end: func_to_host_path\r
3029 \r
3030 # func_to_host_pathlist arg\r
3031 #\r
3032 # Convert pathlists to host format when used with build tools.\r
3033 # See func_to_host_path(), above. This function supports the\r
3034 # following $build/$host combinations (but does no harm for\r
3035 # combinations not listed here):\r
3036 #    $build          $host\r
3037 #    mingw (msys)    mingw  [e.g. native]\r
3038 #    cygwin          mingw\r
3039 #    *nix + wine     mingw\r
3040 #\r
3041 # Path separators are also converted from $build format to\r
3042 # $host format. If ARG begins or ends with a path separator\r
3043 # character, it is preserved (but converted to $host format)\r
3044 # on output.\r
3045 #\r
3046 # ARG is a pathlist (on $build) that should be converted to\r
3047 # the proper representation on $host. The result is stored\r
3048 # in $func_to_host_pathlist_result.\r
3049 func_to_host_pathlist ()\r
3050 {\r
3051   func_to_host_pathlist_result="$1"\r
3052   if test -n "$1" ; then\r
3053     case $host in\r
3054       *mingw* )\r
3055         lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'\r
3056         # Remove leading and trailing path separator characters from\r
3057         # ARG. msys behavior is inconsistent here, cygpath turns them\r
3058         # into '.;' and ';.', and winepath ignores them completely.\r
3059         func_to_host_pathlist_tmp2="$1"\r
3060         # Once set for this call, this variable should not be\r
3061         # reassigned. It is used in tha fallback case.\r
3062         func_to_host_pathlist_tmp1=`echo "$func_to_host_pathlist_tmp2" |\\r
3063           $SED -e 's|^:*||' -e 's|:*$||'`\r
3064         case $build in\r
3065           *mingw* ) # Actually, msys.\r
3066             # Awkward: cmd appends spaces to result.\r
3067             lt_sed_strip_trailing_spaces="s/[ ]*\$//"\r
3068             func_to_host_pathlist_tmp2=`( cmd //c echo "$func_to_host_pathlist_tmp1" |\\r
3069               $SED -e "$lt_sed_strip_trailing_spaces" ) 2>/dev/null || echo ""`\r
3070             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\\r
3071               $SED -e "$lt_sed_naive_backslashify"`\r
3072             ;;\r
3073           *cygwin* )\r
3074             func_to_host_pathlist_tmp2=`cygpath -w -p "$func_to_host_pathlist_tmp1"`\r
3075             func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp2" |\\r
3076               $SED -e "$lt_sed_naive_backslashify"`\r
3077             ;;\r
3078           * )\r
3079             # unfortunately, winepath doesn't convert pathlists\r
3080             func_to_host_pathlist_result=""\r
3081             func_to_host_pathlist_oldIFS=$IFS\r
3082             IFS=:\r
3083             for func_to_host_pathlist_f in $func_to_host_pathlist_tmp1 ; do\r
3084               IFS=$func_to_host_pathlist_oldIFS\r
3085               if test -n "$func_to_host_pathlist_f" ; then\r
3086                 func_to_host_path "$func_to_host_pathlist_f"\r
3087                 if test -n "$func_to_host_path_result" ; then\r
3088                   if test -z "$func_to_host_pathlist_result" ; then\r
3089                     func_to_host_pathlist_result="$func_to_host_path_result"\r
3090                   else\r
3091                     func_to_host_pathlist_result="$func_to_host_pathlist_result;$func_to_host_path_result"\r
3092                   fi\r
3093                 fi\r
3094               fi\r
3095               IFS=:\r
3096             done\r
3097             IFS=$func_to_host_pathlist_oldIFS\r
3098             ;;\r
3099         esac\r
3100         if test -z "$func_to_host_pathlist_result" ; then\r
3101           func_error "Could not determine the host path(s) corresponding to"\r
3102           func_error "  '$1'"\r
3103           func_error "Continuing, but uninstalled executables may not work."\r
3104           # Fallback. This may break if $1 contains DOS-style drive\r
3105           # specifications. The fix is not to complicate the expression\r
3106           # below, but for the user to provide a working wine installation\r
3107           # with winepath so that path translation in the cross-to-mingw\r
3108           # case works properly.\r
3109           lt_replace_pathsep_nix_to_dos="s|:|;|g"\r
3110           func_to_host_pathlist_result=`echo "$func_to_host_pathlist_tmp1" |\\r
3111             $SED -e "$lt_replace_pathsep_nix_to_dos"`\r
3112         fi\r
3113         # Now, add the leading and trailing path separators back\r
3114         case "$1" in\r
3115           :* ) func_to_host_pathlist_result=";$func_to_host_pathlist_result"\r
3116             ;;\r
3117         esac\r
3118         case "$1" in\r
3119           *: ) func_to_host_pathlist_result="$func_to_host_pathlist_result;"\r
3120             ;;\r
3121         esac\r
3122         ;;\r
3123     esac\r
3124   fi\r
3125 }\r
3126 # end: func_to_host_pathlist\r
3127 \r
3128 # func_emit_cwrapperexe_src\r
3129 # emit the source code for a wrapper executable on stdout\r
3130 # Must ONLY be called from within func_mode_link because\r
3131 # it depends on a number of variable set therein.\r
3132 func_emit_cwrapperexe_src ()\r
3133 {\r
3134         cat <<EOF\r
3135 \r
3136 /* $cwrappersource - temporary wrapper executable for $objdir/$outputname\r
3137    Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION\r
3138 \r
3139    The $output program cannot be directly executed until all the libtool\r
3140    libraries that it depends on are installed.\r
3141 \r
3142    This wrapper executable should never be moved out of the build directory.\r
3143    If it is, it will not operate correctly.\r
3144 \r
3145    Currently, it simply execs the wrapper *script* "$SHELL $output",\r
3146    but could eventually absorb all of the scripts functionality and\r
3147    exec $objdir/$outputname directly.\r
3148 */\r
3149 EOF\r
3150             cat <<"EOF"\r
3151 #include <stdio.h>\r
3152 #include <stdlib.h>\r
3153 #ifdef _MSC_VER\r
3154 # include <direct.h>\r
3155 # include <process.h>\r
3156 # include <io.h>\r
3157 # define setmode _setmode\r
3158 #else\r
3159 # include <unistd.h>\r
3160 # include <stdint.h>\r
3161 # ifdef __CYGWIN__\r
3162 #  include <io.h>\r
3163 #  define HAVE_SETENV\r
3164 #  ifdef __STRICT_ANSI__\r
3165 char *realpath (const char *, char *);\r
3166 int putenv (char *);\r
3167 int setenv (const char *, const char *, int);\r
3168 #  endif\r
3169 # endif\r
3170 #endif\r
3171 #include <malloc.h>\r
3172 #include <stdarg.h>\r
3173 #include <assert.h>\r
3174 #include <string.h>\r
3175 #include <ctype.h>\r
3176 #include <errno.h>\r
3177 #include <fcntl.h>\r
3178 #include <sys/stat.h>\r
3179 \r
3180 #if defined(PATH_MAX)\r
3181 # define LT_PATHMAX PATH_MAX\r
3182 #elif defined(MAXPATHLEN)\r
3183 # define LT_PATHMAX MAXPATHLEN\r
3184 #else\r
3185 # define LT_PATHMAX 1024\r
3186 #endif\r
3187 \r
3188 #ifndef S_IXOTH\r
3189 # define S_IXOTH 0\r
3190 #endif\r
3191 #ifndef S_IXGRP\r
3192 # define S_IXGRP 0\r
3193 #endif\r
3194 \r
3195 #ifdef _MSC_VER\r
3196 # define S_IXUSR _S_IEXEC\r
3197 # define stat _stat\r
3198 # ifndef _INTPTR_T_DEFINED\r
3199 #  define intptr_t int\r
3200 # endif\r
3201 #endif\r
3202 \r
3203 #ifndef DIR_SEPARATOR\r
3204 # define DIR_SEPARATOR '/'\r
3205 # define PATH_SEPARATOR ':'\r
3206 #endif\r
3207 \r
3208 #if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \\r
3209   defined (__OS2__)\r
3210 # define HAVE_DOS_BASED_FILE_SYSTEM\r
3211 # define FOPEN_WB "wb"\r
3212 # ifndef DIR_SEPARATOR_2\r
3213 #  define DIR_SEPARATOR_2 '\\'\r
3214 # endif\r
3215 # ifndef PATH_SEPARATOR_2\r
3216 #  define PATH_SEPARATOR_2 ';'\r
3217 # endif\r
3218 #endif\r
3219 \r
3220 #ifndef DIR_SEPARATOR_2\r
3221 # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)\r
3222 #else /* DIR_SEPARATOR_2 */\r
3223 # define IS_DIR_SEPARATOR(ch) \\r
3224         (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))\r
3225 #endif /* DIR_SEPARATOR_2 */\r
3226 \r
3227 #ifndef PATH_SEPARATOR_2\r
3228 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)\r
3229 #else /* PATH_SEPARATOR_2 */\r
3230 # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)\r
3231 #endif /* PATH_SEPARATOR_2 */\r
3232 \r
3233 #ifdef __CYGWIN__\r
3234 # define FOPEN_WB "wb"\r
3235 #endif\r
3236 \r
3237 #ifndef FOPEN_WB\r
3238 # define FOPEN_WB "w"\r
3239 #endif\r
3240 #ifndef _O_BINARY\r
3241 # define _O_BINARY 0\r
3242 #endif\r
3243 \r
3244 #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))\r
3245 #define XFREE(stale) do { \\r
3246   if (stale) { free ((void *) stale); stale = 0; } \\r
3247 } while (0)\r
3248 \r
3249 #undef LTWRAPPER_DEBUGPRINTF\r
3250 #if defined DEBUGWRAPPER\r
3251 # define LTWRAPPER_DEBUGPRINTF(args) ltwrapper_debugprintf args\r
3252 static void\r
3253 ltwrapper_debugprintf (const char *fmt, ...)\r
3254 {\r
3255     va_list args;\r
3256     va_start (args, fmt);\r
3257     (void) vfprintf (stderr, fmt, args);\r
3258     va_end (args);\r
3259 }\r
3260 #else\r
3261 # define LTWRAPPER_DEBUGPRINTF(args)\r
3262 #endif\r
3263 \r
3264 const char *program_name = NULL;\r
3265 \r
3266 void *xmalloc (size_t num);\r
3267 char *xstrdup (const char *string);\r
3268 const char *base_name (const char *name);\r
3269 char *find_executable (const char *wrapper);\r
3270 char *chase_symlinks (const char *pathspec);\r
3271 int make_executable (const char *path);\r
3272 int check_executable (const char *path);\r
3273 char *strendzap (char *str, const char *pat);\r
3274 void lt_fatal (const char *message, ...);\r
3275 void lt_setenv (const char *name, const char *value);\r
3276 char *lt_extend_str (const char *orig_value, const char *add, int to_end);\r
3277 void lt_opt_process_env_set (const char *arg);\r
3278 void lt_opt_process_env_prepend (const char *arg);\r
3279 void lt_opt_process_env_append (const char *arg);\r
3280 int lt_split_name_value (const char *arg, char** name, char** value);\r
3281 void lt_update_exe_path (const char *name, const char *value);\r
3282 void lt_update_lib_path (const char *name, const char *value);\r
3283 \r
3284 static const char *script_text_part1 =\r
3285 EOF\r
3286 \r
3287             func_emit_wrapper_part1 yes |\r
3288                 $SED -e 's/\([\\"]\)/\\\1/g' \\r
3289                      -e 's/^/  "/' -e 's/$/\\n"/'\r
3290             echo ";"\r
3291             cat <<EOF\r
3292 \r
3293 static const char *script_text_part2 =\r
3294 EOF\r
3295             func_emit_wrapper_part2 yes |\r
3296                 $SED -e 's/\([\\"]\)/\\\1/g' \\r
3297                      -e 's/^/  "/' -e 's/$/\\n"/'\r
3298             echo ";"\r
3299 \r
3300             cat <<EOF\r
3301 const char * MAGIC_EXE = "$magic_exe";\r
3302 const char * LIB_PATH_VARNAME = "$shlibpath_var";\r
3303 EOF\r
3304 \r
3305             if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then\r
3306               func_to_host_pathlist "$temp_rpath"\r
3307               cat <<EOF\r
3308 const char * LIB_PATH_VALUE   = "$func_to_host_pathlist_result";\r
3309 EOF\r
3310             else\r
3311               cat <<"EOF"\r
3312 const char * LIB_PATH_VALUE   = "";\r
3313 EOF\r
3314             fi\r
3315 \r
3316             if test -n "$dllsearchpath"; then\r
3317               func_to_host_pathlist "$dllsearchpath:"\r
3318               cat <<EOF\r
3319 const char * EXE_PATH_VARNAME = "PATH";\r
3320 const char * EXE_PATH_VALUE   = "$func_to_host_pathlist_result";\r
3321 EOF\r
3322             else\r
3323               cat <<"EOF"\r
3324 const char * EXE_PATH_VARNAME = "";\r
3325 const char * EXE_PATH_VALUE   = "";\r
3326 EOF\r
3327             fi\r
3328 \r
3329             if test "$fast_install" = yes; then\r
3330               cat <<EOF\r
3331 const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */\r
3332 EOF\r
3333             else\r
3334               cat <<EOF\r
3335 const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */\r
3336 EOF\r
3337             fi\r
3338 \r
3339 \r
3340             cat <<"EOF"\r
3341 \r
3342 #define LTWRAPPER_OPTION_PREFIX         "--lt-"\r
3343 #define LTWRAPPER_OPTION_PREFIX_LENGTH  5\r
3344 \r
3345 static const size_t opt_prefix_len         = LTWRAPPER_OPTION_PREFIX_LENGTH;\r
3346 static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;\r
3347 \r
3348 static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";\r
3349 \r
3350 static const size_t env_set_opt_len     = LTWRAPPER_OPTION_PREFIX_LENGTH + 7;\r
3351 static const char *env_set_opt          = LTWRAPPER_OPTION_PREFIX "env-set";\r
3352   /* argument is putenv-style "foo=bar", value of foo is set to bar */\r
3353 \r
3354 static const size_t env_prepend_opt_len = LTWRAPPER_OPTION_PREFIX_LENGTH + 11;\r
3355 static const char *env_prepend_opt      = LTWRAPPER_OPTION_PREFIX "env-prepend";\r
3356   /* argument is putenv-style "foo=bar", new value of foo is bar${foo} */\r
3357 \r
3358 static const size_t env_append_opt_len  = LTWRAPPER_OPTION_PREFIX_LENGTH + 10;\r
3359 static const char *env_append_opt       = LTWRAPPER_OPTION_PREFIX "env-append";\r
3360   /* argument is putenv-style "foo=bar", new value of foo is ${foo}bar */\r
3361 \r
3362 int\r
3363 main (int argc, char *argv[])\r
3364 {\r
3365   char **newargz;\r
3366   int  newargc;\r
3367   char *tmp_pathspec;\r
3368   char *actual_cwrapper_path;\r
3369   char *actual_cwrapper_name;\r
3370   char *target_name;\r
3371   char *lt_argv_zero;\r
3372   intptr_t rval = 127;\r
3373 \r
3374   int i;\r
3375 \r
3376   program_name = (char *) xstrdup (base_name (argv[0]));\r
3377   LTWRAPPER_DEBUGPRINTF (("(main) argv[0]      : %s\n", argv[0]));\r
3378   LTWRAPPER_DEBUGPRINTF (("(main) program_name : %s\n", program_name));\r
3379 \r
3380   /* very simple arg parsing; don't want to rely on getopt */\r
3381   for (i = 1; i < argc; i++)\r
3382     {\r
3383       if (strcmp (argv[i], dumpscript_opt) == 0)\r
3384         {\r
3385 EOF\r
3386             case "$host" in\r
3387               *mingw* | *cygwin* )\r
3388                 # make stdout use "unix" line endings\r
3389                 echo "          setmode(1,_O_BINARY);"\r
3390                 ;;\r
3391               esac\r
3392 \r
3393             cat <<"EOF"\r
3394           printf ("%s", script_text_part1);\r
3395           printf ("%s", script_text_part2);\r
3396           return 0;\r
3397         }\r
3398     }\r
3399 \r
3400   newargz = XMALLOC (char *, argc + 1);\r
3401   tmp_pathspec = find_executable (argv[0]);\r
3402   if (tmp_pathspec == NULL)\r
3403     lt_fatal ("Couldn't find %s", argv[0]);\r
3404   LTWRAPPER_DEBUGPRINTF (("(main) found exe (before symlink chase) at : %s\n",\r
3405                           tmp_pathspec));\r
3406 \r
3407   actual_cwrapper_path = chase_symlinks (tmp_pathspec);\r
3408   LTWRAPPER_DEBUGPRINTF (("(main) found exe (after symlink chase) at : %s\n",\r
3409                           actual_cwrapper_path));\r
3410   XFREE (tmp_pathspec);\r
3411 \r
3412   actual_cwrapper_name = xstrdup( base_name (actual_cwrapper_path));\r
3413   strendzap (actual_cwrapper_path, actual_cwrapper_name);\r
3414 \r
3415   /* wrapper name transforms */\r
3416   strendzap (actual_cwrapper_name, ".exe");\r
3417   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);\r
3418   XFREE (actual_cwrapper_name);\r
3419   actual_cwrapper_name = tmp_pathspec;\r
3420   tmp_pathspec = 0;\r
3421 \r
3422   /* target_name transforms -- use actual target program name; might have lt- prefix */\r
3423   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));\r
3424   strendzap (target_name, ".exe");\r
3425   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);\r
3426   XFREE (target_name);\r
3427   target_name = tmp_pathspec;\r
3428   tmp_pathspec = 0;\r
3429 \r
3430   LTWRAPPER_DEBUGPRINTF (("(main) libtool target name: %s\n",\r
3431                           target_name));\r
3432 EOF\r
3433 \r
3434             cat <<EOF\r
3435   newargz[0] =\r
3436     XMALLOC (char, (strlen (actual_cwrapper_path) +\r
3437                     strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));\r
3438   strcpy (newargz[0], actual_cwrapper_path);\r
3439   strcat (newargz[0], "$objdir");\r
3440   strcat (newargz[0], "/");\r
3441 EOF\r
3442 \r
3443             cat <<"EOF"\r
3444   /* stop here, and copy so we don't have to do this twice */\r
3445   tmp_pathspec = xstrdup (newargz[0]);\r
3446 \r
3447   /* do NOT want the lt- prefix here, so use actual_cwrapper_name */\r
3448   strcat (newargz[0], actual_cwrapper_name);\r
3449 \r
3450   /* DO want the lt- prefix here if it exists, so use target_name */\r
3451   lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);\r
3452   XFREE (tmp_pathspec);\r
3453   tmp_pathspec = NULL;\r
3454 EOF\r
3455 \r
3456             case $host_os in\r
3457               mingw*)\r
3458             cat <<"EOF"\r
3459   {\r
3460     char* p;\r
3461     while ((p = strchr (newargz[0], '\\')) != NULL)\r
3462       {\r
3463         *p = '/';\r
3464       }\r
3465     while ((p = strchr (lt_argv_zero, '\\')) != NULL)\r
3466       {\r
3467         *p = '/';\r
3468       }\r
3469   }\r
3470 EOF\r
3471             ;;\r
3472             esac\r
3473 \r
3474             cat <<"EOF"\r
3475   XFREE (target_name);\r
3476   XFREE (actual_cwrapper_path);\r
3477   XFREE (actual_cwrapper_name);\r
3478 \r
3479   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */\r
3480   lt_setenv ("DUALCASE", "1");  /* for MSK sh */\r
3481   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);\r
3482   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);\r
3483 \r
3484   newargc=0;\r
3485   for (i = 1; i < argc; i++)\r
3486     {\r
3487       if (strncmp (argv[i], env_set_opt, env_set_opt_len) == 0)\r
3488         {\r
3489           if (argv[i][env_set_opt_len] == '=')\r
3490             {\r
3491               const char *p = argv[i] + env_set_opt_len + 1;\r
3492               lt_opt_process_env_set (p);\r
3493             }\r
3494           else if (argv[i][env_set_opt_len] == '\0' && i + 1 < argc)\r
3495             {\r
3496               lt_opt_process_env_set (argv[++i]); /* don't copy */\r
3497             }\r
3498           else\r
3499             lt_fatal ("%s missing required argument", env_set_opt);\r
3500           continue;\r
3501         }\r
3502       if (strncmp (argv[i], env_prepend_opt, env_prepend_opt_len) == 0)\r
3503         {\r
3504           if (argv[i][env_prepend_opt_len] == '=')\r
3505             {\r
3506               const char *p = argv[i] + env_prepend_opt_len + 1;\r
3507               lt_opt_process_env_prepend (p);\r
3508             }\r
3509           else if (argv[i][env_prepend_opt_len] == '\0' && i + 1 < argc)\r
3510             {\r
3511               lt_opt_process_env_prepend (argv[++i]); /* don't copy */\r
3512             }\r
3513           else\r
3514             lt_fatal ("%s missing required argument", env_prepend_opt);\r
3515           continue;\r
3516         }\r
3517       if (strncmp (argv[i], env_append_opt, env_append_opt_len) == 0)\r
3518         {\r
3519           if (argv[i][env_append_opt_len] == '=')\r
3520             {\r
3521               const char *p = argv[i] + env_append_opt_len + 1;\r
3522               lt_opt_process_env_append (p);\r
3523             }\r
3524           else if (argv[i][env_append_opt_len] == '\0' && i + 1 < argc)\r
3525             {\r
3526               lt_opt_process_env_append (argv[++i]); /* don't copy */\r
3527             }\r
3528           else\r
3529             lt_fatal ("%s missing required argument", env_append_opt);\r
3530           continue;\r
3531         }\r
3532       if (strncmp (argv[i], ltwrapper_option_prefix, opt_prefix_len) == 0)\r
3533         {\r
3534           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX\r
3535              namespace, but it is not one of the ones we know about and\r
3536              have already dealt with, above (inluding dump-script), then\r
3537              report an error. Otherwise, targets might begin to believe\r
3538              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX\r
3539              namespace. The first time any user complains about this, we'll\r
3540              need to make LTWRAPPER_OPTION_PREFIX a configure-time option\r
3541              or a configure.ac-settable value.\r
3542            */\r
3543           lt_fatal ("Unrecognized option in %s namespace: '%s'",\r
3544                     ltwrapper_option_prefix, argv[i]);\r
3545         }\r
3546       /* otherwise ... */\r
3547       newargz[++newargc] = xstrdup (argv[i]);\r
3548     }\r
3549   newargz[++newargc] = NULL;\r
3550 \r
3551   LTWRAPPER_DEBUGPRINTF     (("(main) lt_argv_zero : %s\n", (lt_argv_zero ? lt_argv_zero : "<NULL>")));\r
3552   for (i = 0; i < newargc; i++)\r
3553     {\r
3554       LTWRAPPER_DEBUGPRINTF (("(main) newargz[%d]   : %s\n", i, (newargz[i] ? newargz[i] : "<NULL>")));\r
3555     }\r
3556 \r
3557 EOF\r
3558 \r
3559             case $host_os in\r
3560               mingw*)\r
3561                 cat <<"EOF"\r
3562   /* execv doesn't actually work on mingw as expected on unix */\r
3563   rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);\r
3564   if (rval == -1)\r
3565     {\r
3566       /* failed to start process */\r
3567       LTWRAPPER_DEBUGPRINTF (("(main) failed to launch target \"%s\": errno = %d\n", lt_argv_zero, errno));\r
3568       return 127;\r
3569     }\r
3570   return rval;\r
3571 EOF\r
3572                 ;;\r
3573               *)\r
3574                 cat <<"EOF"\r
3575   execv (lt_argv_zero, newargz);\r
3576   return rval; /* =127, but avoids unused variable warning */\r
3577 EOF\r
3578                 ;;\r
3579             esac\r
3580 \r
3581             cat <<"EOF"\r
3582 }\r
3583 \r
3584 void *\r
3585 xmalloc (size_t num)\r
3586 {\r
3587   void *p = (void *) malloc (num);\r
3588   if (!p)\r
3589     lt_fatal ("Memory exhausted");\r
3590 \r
3591   return p;\r
3592 }\r
3593 \r
3594 char *\r
3595 xstrdup (const char *string)\r
3596 {\r
3597   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),\r
3598                           string) : NULL;\r
3599 }\r
3600 \r
3601 const char *\r
3602 base_name (const char *name)\r
3603 {\r
3604   const char *base;\r
3605 \r
3606 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)\r
3607   /* Skip over the disk name in MSDOS pathnames. */\r
3608   if (isalpha ((unsigned char) name[0]) && name[1] == ':')\r
3609     name += 2;\r
3610 #endif\r
3611 \r
3612   for (base = name; *name; name++)\r
3613     if (IS_DIR_SEPARATOR (*name))\r
3614       base = name + 1;\r
3615   return base;\r
3616 }\r
3617 \r
3618 int\r
3619 check_executable (const char *path)\r
3620 {\r
3621   struct stat st;\r
3622 \r
3623   LTWRAPPER_DEBUGPRINTF (("(check_executable)  : %s\n",\r
3624                           path ? (*path ? path : "EMPTY!") : "NULL!"));\r
3625   if ((!path) || (!*path))\r
3626     return 0;\r
3627 \r
3628   if ((stat (path, &st) >= 0)\r
3629       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))\r
3630     return 1;\r
3631   else\r
3632     return 0;\r
3633 }\r
3634 \r
3635 int\r
3636 make_executable (const char *path)\r
3637 {\r
3638   int rval = 0;\r
3639   struct stat st;\r
3640 \r
3641   LTWRAPPER_DEBUGPRINTF (("(make_executable)   : %s\n",\r
3642                           path ? (*path ? path : "EMPTY!") : "NULL!"));\r
3643   if ((!path) || (!*path))\r
3644     return 0;\r
3645 \r
3646   if (stat (path, &st) >= 0)\r
3647     {\r
3648       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);\r
3649     }\r
3650   return rval;\r
3651 }\r
3652 \r
3653 /* Searches for the full path of the wrapper.  Returns\r
3654    newly allocated full path name if found, NULL otherwise\r
3655    Does not chase symlinks, even on platforms that support them.\r
3656 */\r
3657 char *\r
3658 find_executable (const char *wrapper)\r
3659 {\r
3660   int has_slash = 0;\r
3661   const char *p;\r
3662   const char *p_next;\r
3663   /* static buffer for getcwd */\r
3664   char tmp[LT_PATHMAX + 1];\r
3665   int tmp_len;\r
3666   char *concat_name;\r
3667 \r
3668   LTWRAPPER_DEBUGPRINTF (("(find_executable)   : %s\n",\r
3669                           wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!"));\r
3670 \r
3671   if ((wrapper == NULL) || (*wrapper == '\0'))\r
3672     return NULL;\r
3673 \r
3674   /* Absolute path? */\r
3675 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)\r
3676   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')\r
3677     {\r
3678       concat_name = xstrdup (wrapper);\r
3679       if (check_executable (concat_name))\r
3680         return concat_name;\r
3681       XFREE (concat_name);\r
3682     }\r
3683   else\r
3684     {\r
3685 #endif\r
3686       if (IS_DIR_SEPARATOR (wrapper[0]))\r
3687         {\r
3688           concat_name = xstrdup (wrapper);\r
3689           if (check_executable (concat_name))\r
3690             return concat_name;\r
3691           XFREE (concat_name);\r
3692         }\r
3693 #if defined (HAVE_DOS_BASED_FILE_SYSTEM)\r
3694     }\r
3695 #endif\r
3696 \r
3697   for (p = wrapper; *p; p++)\r
3698     if (*p == '/')\r
3699       {\r
3700         has_slash = 1;\r
3701         break;\r
3702       }\r
3703   if (!has_slash)\r
3704     {\r
3705       /* no slashes; search PATH */\r
3706       const char *path = getenv ("PATH");\r
3707       if (path != NULL)\r
3708         {\r
3709           for (p = path; *p; p = p_next)\r
3710             {\r
3711               const char *q;\r
3712               size_t p_len;\r
3713               for (q = p; *q; q++)\r
3714                 if (IS_PATH_SEPARATOR (*q))\r
3715                   break;\r
3716               p_len = q - p;\r
3717               p_next = (*q == '\0' ? q : q + 1);\r
3718               if (p_len == 0)\r
3719                 {\r
3720                   /* empty path: current directory */\r
3721                   if (getcwd (tmp, LT_PATHMAX) == NULL)\r
3722                     lt_fatal ("getcwd failed");\r
3723                   tmp_len = strlen (tmp);\r
3724                   concat_name =\r
3725                     XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);\r
3726                   memcpy (concat_name, tmp, tmp_len);\r
3727                   concat_name[tmp_len] = '/';\r
3728                   strcpy (concat_name + tmp_len + 1, wrapper);\r
3729                 }\r
3730               else\r
3731                 {\r
3732                   concat_name =\r
3733                     XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);\r
3734                   memcpy (concat_name, p, p_len);\r
3735                   concat_name[p_len] = '/';\r
3736                   strcpy (concat_name + p_len + 1, wrapper);\r
3737                 }\r
3738               if (check_executable (concat_name))\r
3739                 return concat_name;\r
3740               XFREE (concat_name);\r
3741             }\r
3742         }\r
3743       /* not found in PATH; assume curdir */\r
3744     }\r
3745   /* Relative path | not found in path: prepend cwd */\r
3746   if (getcwd (tmp, LT_PATHMAX) == NULL)\r
3747     lt_fatal ("getcwd failed");\r
3748   tmp_len = strlen (tmp);\r
3749   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);\r
3750   memcpy (concat_name, tmp, tmp_len);\r
3751   concat_name[tmp_len] = '/';\r
3752   strcpy (concat_name + tmp_len + 1, wrapper);\r
3753 \r
3754   if (check_executable (concat_name))\r
3755     return concat_name;\r
3756   XFREE (concat_name);\r
3757   return NULL;\r
3758 }\r
3759 \r
3760 char *\r
3761 chase_symlinks (const char *pathspec)\r
3762 {\r
3763 #ifndef S_ISLNK\r
3764   return xstrdup (pathspec);\r
3765 #else\r
3766   char buf[LT_PATHMAX];\r
3767   struct stat s;\r
3768   char *tmp_pathspec = xstrdup (pathspec);\r
3769   char *p;\r
3770   int has_symlinks = 0;\r
3771   while (strlen (tmp_pathspec) && !has_symlinks)\r
3772     {\r
3773       LTWRAPPER_DEBUGPRINTF (("checking path component for symlinks: %s\n",\r
3774                               tmp_pathspec));\r
3775       if (lstat (tmp_pathspec, &s) == 0)\r
3776         {\r
3777           if (S_ISLNK (s.st_mode) != 0)\r
3778             {\r
3779               has_symlinks = 1;\r
3780               break;\r
3781             }\r
3782 \r
3783           /* search backwards for last DIR_SEPARATOR */\r
3784           p = tmp_pathspec + strlen (tmp_pathspec) - 1;\r
3785           while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))\r
3786             p--;\r
3787           if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))\r
3788             {\r
3789               /* no more DIR_SEPARATORS left */\r
3790               break;\r
3791             }\r
3792           *p = '\0';\r
3793         }\r
3794       else\r
3795         {\r
3796           char *errstr = strerror (errno);\r
3797           lt_fatal ("Error accessing file %s (%s)", tmp_pathspec, errstr);\r
3798         }\r
3799     }\r
3800   XFREE (tmp_pathspec);\r
3801 \r
3802   if (!has_symlinks)\r
3803     {\r
3804       return xstrdup (pathspec);\r
3805     }\r
3806 \r
3807   tmp_pathspec = realpath (pathspec, buf);\r
3808   if (tmp_pathspec == 0)\r
3809     {\r
3810       lt_fatal ("Could not follow symlinks for %s", pathspec);\r
3811     }\r
3812   return xstrdup (tmp_pathspec);\r
3813 #endif\r
3814 }\r
3815 \r
3816 char *\r
3817 strendzap (char *str, const char *pat)\r
3818 {\r
3819   size_t len, patlen;\r
3820 \r
3821   assert (str != NULL);\r
3822   assert (pat != NULL);\r
3823 \r
3824   len = strlen (str);\r
3825   patlen = strlen (pat);\r
3826 \r
3827   if (patlen <= len)\r
3828     {\r
3829       str += len - patlen;\r
3830       if (strcmp (str, pat) == 0)\r
3831         *str = '\0';\r
3832     }\r
3833   return str;\r
3834 }\r
3835 \r
3836 static void\r
3837 lt_error_core (int exit_status, const char *mode,\r
3838                const char *message, va_list ap)\r
3839 {\r
3840   fprintf (stderr, "%s: %s: ", program_name, mode);\r
3841   vfprintf (stderr, message, ap);\r
3842   fprintf (stderr, ".\n");\r
3843 \r
3844   if (exit_status >= 0)\r
3845     exit (exit_status);\r
3846 }\r
3847 \r
3848 void\r
3849 lt_fatal (const char *message, ...)\r
3850 {\r
3851   va_list ap;\r
3852   va_start (ap, message);\r
3853   lt_error_core (EXIT_FAILURE, "FATAL", message, ap);\r
3854   va_end (ap);\r
3855 }\r
3856 \r
3857 void\r
3858 lt_setenv (const char *name, const char *value)\r
3859 {\r
3860   LTWRAPPER_DEBUGPRINTF (("(lt_setenv) setting '%s' to '%s'\n",\r
3861                           (name ? name : "<NULL>"),\r
3862                           (value ? value : "<NULL>")));\r
3863   {\r
3864 #ifdef HAVE_SETENV\r
3865     /* always make a copy, for consistency with !HAVE_SETENV */\r
3866     char *str = xstrdup (value);\r
3867     setenv (name, str, 1);\r
3868 #else\r
3869     int len = strlen (name) + 1 + strlen (value) + 1;\r
3870     char *str = XMALLOC (char, len);\r
3871     sprintf (str, "%s=%s", name, value);\r
3872     if (putenv (str) != EXIT_SUCCESS)\r
3873       {\r
3874         XFREE (str);\r
3875       }\r
3876 #endif\r
3877   }\r
3878 }\r
3879 \r
3880 char *\r
3881 lt_extend_str (const char *orig_value, const char *add, int to_end)\r
3882 {\r
3883   char *new_value;\r
3884   if (orig_value && *orig_value)\r
3885     {\r
3886       int orig_value_len = strlen (orig_value);\r
3887       int add_len = strlen (add);\r
3888       new_value = XMALLOC (char, add_len + orig_value_len + 1);\r
3889       if (to_end)\r
3890         {\r
3891           strcpy (new_value, orig_value);\r
3892           strcpy (new_value + orig_value_len, add);\r
3893         }\r
3894       else\r
3895         {\r
3896           strcpy (new_value, add);\r
3897           strcpy (new_value + add_len, orig_value);\r
3898         }\r
3899     }\r
3900   else\r
3901     {\r
3902       new_value = xstrdup (add);\r
3903     }\r
3904   return new_value;\r
3905 }\r
3906 \r
3907 int\r
3908 lt_split_name_value (const char *arg, char** name, char** value)\r
3909 {\r
3910   const char *p;\r
3911   int len;\r
3912   if (!arg || !*arg)\r
3913     return 1;\r
3914 \r
3915   p = strchr (arg, (int)'=');\r
3916 \r
3917   if (!p)\r
3918     return 1;\r
3919 \r
3920   *value = xstrdup (++p);\r
3921 \r
3922   len = strlen (arg) - strlen (*value);\r
3923   *name = XMALLOC (char, len);\r
3924   strncpy (*name, arg, len-1);\r
3925   (*name)[len - 1] = '\0';\r
3926 \r
3927   return 0;\r
3928 }\r
3929 \r
3930 void\r
3931 lt_opt_process_env_set (const char *arg)\r
3932 {\r
3933   char *name = NULL;\r
3934   char *value = NULL;\r
3935 \r
3936   if (lt_split_name_value (arg, &name, &value) != 0)\r
3937     {\r
3938       XFREE (name);\r
3939       XFREE (value);\r
3940       lt_fatal ("bad argument for %s: '%s'", env_set_opt, arg);\r
3941     }\r
3942 \r
3943   lt_setenv (name, value);\r
3944   XFREE (name);\r
3945   XFREE (value);\r
3946 }\r
3947 \r
3948 void\r
3949 lt_opt_process_env_prepend (const char *arg)\r
3950 {\r
3951   char *name = NULL;\r
3952   char *value = NULL;\r
3953   char *new_value = NULL;\r
3954 \r
3955   if (lt_split_name_value (arg, &name, &value) != 0)\r
3956     {\r
3957       XFREE (name);\r
3958       XFREE (value);\r
3959       lt_fatal ("bad argument for %s: '%s'", env_prepend_opt, arg);\r
3960     }\r
3961 \r
3962   new_value = lt_extend_str (getenv (name), value, 0);\r
3963   lt_setenv (name, new_value);\r
3964   XFREE (new_value);\r
3965   XFREE (name);\r
3966   XFREE (value);\r
3967 }\r
3968 \r
3969 void\r
3970 lt_opt_process_env_append (const char *arg)\r
3971 {\r
3972   char *name = NULL;\r
3973   char *value = NULL;\r
3974   char *new_value = NULL;\r
3975 \r
3976   if (lt_split_name_value (arg, &name, &value) != 0)\r
3977     {\r
3978       XFREE (name);\r
3979       XFREE (value);\r
3980       lt_fatal ("bad argument for %s: '%s'", env_append_opt, arg);\r
3981     }\r
3982 \r
3983   new_value = lt_extend_str (getenv (name), value, 1);\r
3984   lt_setenv (name, new_value);\r
3985   XFREE (new_value);\r
3986   XFREE (name);\r
3987   XFREE (value);\r
3988 }\r
3989 \r
3990 void\r
3991 lt_update_exe_path (const char *name, const char *value)\r
3992 {\r
3993   LTWRAPPER_DEBUGPRINTF (("(lt_update_exe_path) modifying '%s' by prepending '%s'\n",\r
3994                           (name ? name : "<NULL>"),\r
3995                           (value ? value : "<NULL>")));\r
3996 \r
3997   if (name && *name && value && *value)\r
3998     {\r
3999       char *new_value = lt_extend_str (getenv (name), value, 0);\r
4000       /* some systems can't cope with a ':'-terminated path #' */\r
4001       int len = strlen (new_value);\r
4002       while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))\r
4003         {\r
4004           new_value[len-1] = '\0';\r
4005         }\r
4006       lt_setenv (name, new_value);\r
4007       XFREE (new_value);\r
4008     }\r
4009 }\r
4010 \r
4011 void\r
4012 lt_update_lib_path (const char *name, const char *value)\r
4013 {\r
4014   LTWRAPPER_DEBUGPRINTF (("(lt_update_lib_path) modifying '%s' by prepending '%s'\n",\r
4015                           (name ? name : "<NULL>"),\r
4016                           (value ? value : "<NULL>")));\r
4017 \r
4018   if (name && *name && value && *value)\r
4019     {\r
4020       char *new_value = lt_extend_str (getenv (name), value, 0);\r
4021       lt_setenv (name, new_value);\r
4022       XFREE (new_value);\r
4023     }\r
4024 }\r
4025 \r
4026 \r
4027 EOF\r
4028 }\r
4029 # end: func_emit_cwrapperexe_src\r
4030 \r
4031 # func_mode_link arg...\r
4032 func_mode_link ()\r
4033 {\r
4034     $opt_debug\r
4035     case $host in\r
4036     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)\r
4037       # It is impossible to link a dll without this setting, and\r
4038       # we shouldn't force the makefile maintainer to figure out\r
4039       # which system we are compiling for in order to pass an extra\r
4040       # flag for every libtool invocation.\r
4041       # allow_undefined=no\r
4042 \r
4043       # FIXME: Unfortunately, there are problems with the above when trying\r
4044       # to make a dll which has undefined symbols, in which case not\r
4045       # even a static library is built.  For now, we need to specify\r
4046       # -no-undefined on the libtool link line when we can be certain\r
4047       # that all symbols are satisfied, otherwise we get a static library.\r
4048       allow_undefined=yes\r
4049       ;;\r
4050     *)\r
4051       allow_undefined=yes\r
4052       ;;\r
4053     esac\r
4054     libtool_args=$nonopt\r
4055     base_compile="$nonopt $@"\r
4056     compile_command=$nonopt\r
4057     finalize_command=$nonopt\r
4058 \r
4059     compile_rpath=\r
4060     finalize_rpath=\r
4061     compile_shlibpath=\r
4062     finalize_shlibpath=\r
4063     convenience=\r
4064     old_convenience=\r
4065     deplibs=\r
4066     old_deplibs=\r
4067     compiler_flags=\r
4068     linker_flags=\r
4069     dllsearchpath=\r
4070     lib_search_path=`pwd`\r
4071     inst_prefix_dir=\r
4072     new_inherited_linker_flags=\r
4073 \r
4074     avoid_version=no\r
4075     dlfiles=\r
4076     dlprefiles=\r
4077     dlself=no\r
4078     export_dynamic=no\r
4079     export_symbols=\r
4080     export_symbols_regex=\r
4081     generated=\r
4082     libobjs=\r
4083     ltlibs=\r
4084     module=no\r
4085     no_install=no\r
4086     objs=\r
4087     non_pic_objects=\r
4088     precious_files_regex=\r
4089     prefer_static_libs=no\r
4090     preload=no\r
4091     prev=\r
4092     prevarg=\r
4093     release=\r
4094     rpath=\r
4095     xrpath=\r
4096     perm_rpath=\r
4097     temp_rpath=\r
4098     thread_safe=no\r
4099     vinfo=\r
4100     vinfo_number=no\r
4101     weak_libs=\r
4102     single_module="${wl}-single_module"\r
4103     func_infer_tag $base_compile\r
4104 \r
4105     # We need to know -static, to get the right output filenames.\r
4106     for arg\r
4107     do\r
4108       case $arg in\r
4109       -shared)\r
4110         test "$build_libtool_libs" != yes && \\r
4111           func_fatal_configuration "can not build a shared library"\r
4112         build_old_libs=no\r
4113         break\r
4114         ;;\r
4115       -all-static | -static | -static-libtool-libs)\r
4116         case $arg in\r
4117         -all-static)\r
4118           if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then\r
4119             func_warning "complete static linking is impossible in this configuration"\r
4120           fi\r
4121           if test -n "$link_static_flag"; then\r
4122             dlopen_self=$dlopen_self_static\r
4123           fi\r
4124           prefer_static_libs=yes\r
4125           ;;\r
4126         -static)\r
4127           if test -z "$pic_flag" && test -n "$link_static_flag"; then\r
4128             dlopen_self=$dlopen_self_static\r
4129           fi\r
4130           prefer_static_libs=built\r
4131           ;;\r
4132         -static-libtool-libs)\r
4133           if test -z "$pic_flag" && test -n "$link_static_flag"; then\r
4134             dlopen_self=$dlopen_self_static\r
4135           fi\r
4136           prefer_static_libs=yes\r
4137           ;;\r
4138         esac\r
4139         build_libtool_libs=no\r
4140         build_old_libs=yes\r
4141         break\r
4142         ;;\r
4143       esac\r
4144     done\r
4145 \r
4146     # See if our shared archives depend on static archives.\r
4147     test -n "$old_archive_from_new_cmds" && build_old_libs=yes\r
4148 \r
4149     # Go through the arguments, transforming them on the way.\r
4150     while test "$#" -gt 0; do\r
4151       arg="$1"\r
4152       shift\r
4153       func_quote_for_eval "$arg"\r
4154       qarg=$func_quote_for_eval_unquoted_result\r
4155       func_append libtool_args " $func_quote_for_eval_result"\r
4156 \r
4157       # If the previous option needs an argument, assign it.\r
4158       if test -n "$prev"; then\r
4159         case $prev in\r
4160         output)\r
4161           func_append compile_command " @OUTPUT@"\r
4162           func_append finalize_command " @OUTPUT@"\r
4163           ;;\r
4164         esac\r
4165 \r
4166         case $prev in\r
4167         dlfiles|dlprefiles)\r
4168           if test "$preload" = no; then\r
4169             # Add the symbol object into the linking commands.\r
4170             func_append compile_command " @SYMFILE@"\r
4171             func_append finalize_command " @SYMFILE@"\r
4172             preload=yes\r
4173           fi\r
4174           case $arg in\r
4175           *.la | *.lo) ;;  # We handle these cases below.\r
4176           force)\r
4177             if test "$dlself" = no; then\r
4178               dlself=needless\r
4179               export_dynamic=yes\r
4180             fi\r
4181             prev=\r
4182             continue\r
4183             ;;\r
4184           self)\r
4185             if test "$prev" = dlprefiles; then\r
4186               dlself=yes\r
4187             elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then\r
4188               dlself=yes\r
4189             else\r
4190               dlself=needless\r
4191               export_dynamic=yes\r
4192             fi\r
4193             prev=\r
4194             continue\r
4195             ;;\r
4196           *)\r
4197             if test "$prev" = dlfiles; then\r
4198               dlfiles="$dlfiles $arg"\r
4199             else\r
4200               dlprefiles="$dlprefiles $arg"\r
4201             fi\r
4202             prev=\r
4203             continue\r
4204             ;;\r
4205           esac\r
4206           ;;\r
4207         expsyms)\r
4208           export_symbols="$arg"\r
4209           test -f "$arg" \\r
4210             || func_fatal_error "symbol file \`$arg' does not exist"\r
4211           prev=\r
4212           continue\r
4213           ;;\r
4214         expsyms_regex)\r
4215           export_symbols_regex="$arg"\r
4216           prev=\r
4217           continue\r
4218           ;;\r
4219         framework)\r
4220           case $host in\r
4221             *-*-darwin*)\r
4222               case "$deplibs " in\r
4223                 *" $qarg.ltframework "*) ;;\r
4224                 *) deplibs="$deplibs $qarg.ltframework" # this is fixed later\r
4225                    ;;\r
4226               esac\r
4227               ;;\r
4228           esac\r
4229           prev=\r
4230           continue\r
4231           ;;\r
4232         inst_prefix)\r
4233           inst_prefix_dir="$arg"\r
4234           prev=\r
4235           continue\r
4236           ;;\r
4237         objectlist)\r
4238           if test -f "$arg"; then\r
4239             save_arg=$arg\r
4240             moreargs=\r
4241             for fil in `cat "$save_arg"`\r
4242             do\r
4243 #             moreargs="$moreargs $fil"\r
4244               arg=$fil\r
4245               # A libtool-controlled object.\r
4246 \r
4247               # Check to see that this really is a libtool object.\r
4248               if func_lalib_unsafe_p "$arg"; then\r
4249                 pic_object=\r
4250                 non_pic_object=\r
4251 \r
4252                 # Read the .lo file\r
4253                 func_source "$arg"\r
4254 \r
4255                 if test -z "$pic_object" ||\r
4256                    test -z "$non_pic_object" ||\r
4257                    test "$pic_object" = none &&\r
4258                    test "$non_pic_object" = none; then\r
4259                   func_fatal_error "cannot find name of object for \`$arg'"\r
4260                 fi\r
4261 \r
4262                 # Extract subdirectory from the argument.\r
4263                 func_dirname "$arg" "/" ""\r
4264                 xdir="$func_dirname_result"\r
4265 \r
4266                 if test "$pic_object" != none; then\r
4267                   # Prepend the subdirectory the object is found in.\r
4268                   pic_object="$xdir$pic_object"\r
4269 \r
4270                   if test "$prev" = dlfiles; then\r
4271                     if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then\r
4272                       dlfiles="$dlfiles $pic_object"\r
4273                       prev=\r
4274                       continue\r
4275                     else\r
4276                       # If libtool objects are unsupported, then we need to preload.\r
4277                       prev=dlprefiles\r
4278                     fi\r
4279                   fi\r
4280 \r
4281                   # CHECK ME:  I think I busted this.  -Ossama\r
4282                   if test "$prev" = dlprefiles; then\r
4283                     # Preload the old-style object.\r
4284                     dlprefiles="$dlprefiles $pic_object"\r
4285                     prev=\r
4286                   fi\r
4287 \r
4288                   # A PIC object.\r
4289                   func_append libobjs " $pic_object"\r
4290                   arg="$pic_object"\r
4291                 fi\r
4292 \r
4293                 # Non-PIC object.\r
4294                 if test "$non_pic_object" != none; then\r
4295                   # Prepend the subdirectory the object is found in.\r
4296                   non_pic_object="$xdir$non_pic_object"\r
4297 \r
4298                   # A standard non-PIC object\r
4299                   func_append non_pic_objects " $non_pic_object"\r
4300                   if test -z "$pic_object" || test "$pic_object" = none ; then\r
4301                     arg="$non_pic_object"\r
4302                   fi\r
4303                 else\r
4304                   # If the PIC object exists, use it instead.\r
4305                   # $xdir was prepended to $pic_object above.\r
4306                   non_pic_object="$pic_object"\r
4307                   func_append non_pic_objects " $non_pic_object"\r
4308                 fi\r
4309               else\r
4310                 # Only an error if not doing a dry-run.\r
4311                 if $opt_dry_run; then\r
4312                   # Extract subdirectory from the argument.\r
4313                   func_dirname "$arg" "/" ""\r
4314                   xdir="$func_dirname_result"\r
4315 \r
4316                   func_lo2o "$arg"\r
4317                   pic_object=$xdir$objdir/$func_lo2o_result\r
4318                   non_pic_object=$xdir$func_lo2o_result\r
4319                   func_append libobjs " $pic_object"\r
4320                   func_append non_pic_objects " $non_pic_object"\r
4321                 else\r
4322                   func_fatal_error "\`$arg' is not a valid libtool object"\r
4323                 fi\r
4324               fi\r
4325             done\r
4326           else\r
4327             func_fatal_error "link input file \`$arg' does not exist"\r
4328           fi\r
4329           arg=$save_arg\r
4330           prev=\r
4331           continue\r
4332           ;;\r
4333         precious_regex)\r
4334           precious_files_regex="$arg"\r
4335           prev=\r
4336           continue\r
4337           ;;\r
4338         release)\r
4339           release="-$arg"\r
4340           prev=\r
4341           continue\r
4342           ;;\r
4343         rpath | xrpath)\r
4344           # We need an absolute path.\r
4345           case $arg in\r
4346           [\\/]* | [A-Za-z]:[\\/]*) ;;\r
4347           *)\r
4348             func_fatal_error "only absolute run-paths are allowed"\r
4349             ;;\r
4350           esac\r
4351           if test "$prev" = rpath; then\r
4352             case "$rpath " in\r
4353             *" $arg "*) ;;\r
4354             *) rpath="$rpath $arg" ;;\r
4355             esac\r
4356           else\r
4357             case "$xrpath " in\r
4358             *" $arg "*) ;;\r
4359             *) xrpath="$xrpath $arg" ;;\r
4360             esac\r
4361           fi\r
4362           prev=\r
4363           continue\r
4364           ;;\r
4365         shrext)\r
4366           shrext_cmds="$arg"\r
4367           prev=\r
4368           continue\r
4369           ;;\r
4370         weak)\r
4371           weak_libs="$weak_libs $arg"\r
4372           prev=\r
4373           continue\r
4374           ;;\r
4375         xcclinker)\r
4376           linker_flags="$linker_flags $qarg"\r
4377           compiler_flags="$compiler_flags $qarg"\r
4378           prev=\r
4379           func_append compile_command " $qarg"\r
4380           func_append finalize_command " $qarg"\r
4381           continue\r
4382           ;;\r
4383         xcompiler)\r
4384           compiler_flags="$compiler_flags $qarg"\r
4385           prev=\r
4386           func_append compile_command " $qarg"\r
4387           func_append finalize_command " $qarg"\r
4388           continue\r
4389           ;;\r
4390         xlinker)\r
4391           linker_flags="$linker_flags $qarg"\r
4392           compiler_flags="$compiler_flags $wl$qarg"\r
4393           prev=\r
4394           func_append compile_command " $wl$qarg"\r
4395           func_append finalize_command " $wl$qarg"\r
4396           continue\r
4397           ;;\r
4398         *)\r
4399           eval "$prev=\"\$arg\""\r
4400           prev=\r
4401           continue\r
4402           ;;\r
4403         esac\r
4404       fi # test -n "$prev"\r
4405 \r
4406       prevarg="$arg"\r
4407 \r
4408       case $arg in\r
4409       -all-static)\r
4410         if test -n "$link_static_flag"; then\r
4411           # See comment for -static flag below, for more details.\r
4412           func_append compile_command " $link_static_flag"\r
4413           func_append finalize_command " $link_static_flag"\r
4414         fi\r
4415         continue\r
4416         ;;\r
4417 \r
4418       -allow-undefined)\r
4419         # FIXME: remove this flag sometime in the future.\r
4420         func_fatal_error "\`-allow-undefined' must not be used because it is the default"\r
4421         ;;\r
4422 \r
4423       -avoid-version)\r
4424         avoid_version=yes\r
4425         continue\r
4426         ;;\r
4427 \r
4428       -dlopen)\r
4429         prev=dlfiles\r
4430         continue\r
4431         ;;\r
4432 \r
4433       -dlpreopen)\r
4434         prev=dlprefiles\r
4435         continue\r
4436         ;;\r
4437 \r
4438       -export-dynamic)\r
4439         export_dynamic=yes\r
4440         continue\r
4441         ;;\r
4442 \r
4443       -export-symbols | -export-symbols-regex)\r
4444         if test -n "$export_symbols" || test -n "$export_symbols_regex"; then\r
4445           func_fatal_error "more than one -exported-symbols argument is not allowed"\r
4446         fi\r
4447         if test "X$arg" = "X-export-symbols"; then\r
4448           prev=expsyms\r
4449         else\r
4450           prev=expsyms_regex\r
4451         fi\r
4452         continue\r
4453         ;;\r
4454 \r
4455       -framework)\r
4456         prev=framework\r
4457         continue\r
4458         ;;\r
4459 \r
4460       -inst-prefix-dir)\r
4461         prev=inst_prefix\r
4462         continue\r
4463         ;;\r
4464 \r
4465       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*\r
4466       # so, if we see these flags be careful not to treat them like -L\r
4467       -L[A-Z][A-Z]*:*)\r
4468         case $with_gcc/$host in\r
4469         no/*-*-irix* | /*-*-irix*)\r
4470           func_append compile_command " $arg"\r
4471           func_append finalize_command " $arg"\r
4472           ;;\r
4473         esac\r
4474         continue\r
4475         ;;\r
4476 \r
4477       -L*)\r
4478         func_stripname '-L' '' "$arg"\r
4479         dir=$func_stripname_result\r
4480         if test -z "$dir"; then\r
4481           if test "$#" -gt 0; then\r
4482             func_fatal_error "require no space between \`-L' and \`$1'"\r
4483           else\r
4484             func_fatal_error "need path for \`-L' option"\r
4485           fi\r
4486         fi\r
4487         # We need an absolute path.\r
4488         case $dir in\r
4489         [\\/]* | [A-Za-z]:[\\/]*) ;;\r
4490         *)\r
4491           absdir=`cd "$dir" && pwd`\r
4492           test -z "$absdir" && \\r
4493             func_fatal_error "cannot determine absolute directory name of \`$dir'"\r
4494           dir="$absdir"\r
4495           ;;\r
4496         esac\r
4497         case "$deplibs " in\r
4498         *" -L$dir "*) ;;\r
4499         *)\r
4500           deplibs="$deplibs -L$dir"\r
4501           lib_search_path="$lib_search_path $dir"\r
4502           ;;\r
4503         esac\r
4504         case $host in\r
4505         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)\r
4506           testbindir=`$ECHO "X$dir" | $Xsed -e 's*/lib$*/bin*'`\r
4507           case :$dllsearchpath: in\r
4508           *":$dir:"*) ;;\r
4509           ::) dllsearchpath=$dir;;\r
4510           *) dllsearchpath="$dllsearchpath:$dir";;\r
4511           esac\r
4512           case :$dllsearchpath: in\r
4513           *":$testbindir:"*) ;;\r
4514           ::) dllsearchpath=$testbindir;;\r
4515           *) dllsearchpath="$dllsearchpath:$testbindir";;\r
4516           esac\r
4517           ;;\r
4518         esac\r
4519         continue\r
4520         ;;\r
4521 \r
4522       -l*)\r
4523         if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then\r
4524           case $host in\r
4525           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc*)\r
4526             # These systems don't actually have a C or math library (as such)\r
4527             continue\r
4528             ;;\r
4529           *-*-os2*)\r
4530             # These systems don't actually have a C library (as such)\r
4531             test "X$arg" = "X-lc" && continue\r
4532             ;;\r
4533           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)\r
4534             # Do not include libc due to us having libc/libc_r.\r
4535             test "X$arg" = "X-lc" && continue\r
4536             ;;\r
4537           *-*-rhapsody* | *-*-darwin1.[012])\r
4538             # Rhapsody C and math libraries are in the System framework\r
4539             deplibs="$deplibs System.ltframework"\r
4540             continue\r
4541             ;;\r
4542           *-*-sco3.2v5* | *-*-sco5v6*)\r
4543             # Causes problems with __ctype\r
4544             test "X$arg" = "X-lc" && continue\r
4545             ;;\r
4546           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)\r
4547             # Compiler inserts libc in the correct place for threads to work\r
4548             test "X$arg" = "X-lc" && continue\r
4549             ;;\r
4550           esac\r
4551         elif test "X$arg" = "X-lc_r"; then\r
4552          case $host in\r
4553          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)\r
4554            # Do not include libc_r directly, use -pthread flag.\r
4555            continue\r
4556            ;;\r
4557          esac\r
4558         fi\r
4559         deplibs="$deplibs $arg"\r
4560         continue\r
4561         ;;\r
4562 \r
4563       -module)\r
4564         module=yes\r
4565         continue\r
4566         ;;\r
4567 \r
4568       # Tru64 UNIX uses -model [arg] to determine the layout of C++\r
4569       # classes, name mangling, and exception handling.\r
4570       # Darwin uses the -arch flag to determine output architecture.\r
4571       -model|-arch|-isysroot)\r
4572         compiler_flags="$compiler_flags $arg"\r
4573         func_append compile_command " $arg"\r
4574         func_append finalize_command " $arg"\r
4575         prev=xcompiler\r
4576         continue\r
4577         ;;\r
4578 \r
4579       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)\r
4580         compiler_flags="$compiler_flags $arg"\r
4581         func_append compile_command " $arg"\r
4582         func_append finalize_command " $arg"\r
4583         case "$new_inherited_linker_flags " in\r
4584             *" $arg "*) ;;\r
4585             * ) new_inherited_linker_flags="$new_inherited_linker_flags $arg" ;;\r
4586         esac\r
4587         continue\r
4588         ;;\r
4589 \r
4590       -multi_module)\r
4591         single_module="${wl}-multi_module"\r
4592         continue\r
4593         ;;\r
4594 \r
4595       -no-fast-install)\r
4596         fast_install=no\r
4597         continue\r
4598         ;;\r
4599 \r
4600       -no-install)\r
4601         case $host in\r
4602         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)\r
4603           # The PATH hackery in wrapper scripts is required on Windows\r
4604           # and Darwin in order for the loader to find any dlls it needs.\r
4605           func_warning "\`-no-install' is ignored for $host"\r
4606           func_warning "assuming \`-no-fast-install' instead"\r
4607           fast_install=no\r
4608           ;;\r
4609         *) no_install=yes ;;\r
4610         esac\r
4611         continue\r
4612         ;;\r
4613 \r
4614       -no-undefined)\r
4615         allow_undefined=no\r
4616         continue\r
4617         ;;\r
4618 \r
4619       -objectlist)\r
4620         prev=objectlist\r
4621         continue\r
4622         ;;\r
4623 \r
4624       -o) prev=output ;;\r
4625 \r
4626       -precious-files-regex)\r
4627         prev=precious_regex\r
4628         continue\r
4629         ;;\r
4630 \r
4631       -release)\r
4632         prev=release\r
4633         continue\r
4634         ;;\r
4635 \r
4636       -rpath)\r
4637         prev=rpath\r
4638         continue\r
4639         ;;\r
4640 \r
4641       -R)\r
4642         prev=xrpath\r
4643         continue\r
4644         ;;\r
4645 \r
4646       -R*)\r
4647         func_stripname '-R' '' "$arg"\r
4648         dir=$func_stripname_result\r
4649         # We need an absolute path.\r
4650         case $dir in\r
4651         [\\/]* | [A-Za-z]:[\\/]*) ;;\r
4652         *)\r
4653           func_fatal_error "only absolute run-paths are allowed"\r
4654           ;;\r
4655         esac\r
4656         case "$xrpath " in\r
4657         *" $dir "*) ;;\r
4658         *) xrpath="$xrpath $dir" ;;\r
4659         esac\r
4660         continue\r
4661         ;;\r
4662 \r
4663       -shared)\r
4664         # The effects of -shared are defined in a previous loop.\r
4665         continue\r
4666         ;;\r
4667 \r
4668       -shrext)\r
4669         prev=shrext\r
4670         continue\r
4671         ;;\r
4672 \r
4673       -static | -static-libtool-libs)\r
4674         # The effects of -static are defined in a previous loop.\r
4675         # We used to do the same as -all-static on platforms that\r
4676         # didn't have a PIC flag, but the assumption that the effects\r
4677         # would be equivalent was wrong.  It would break on at least\r
4678         # Digital Unix and AIX.\r
4679         continue\r
4680         ;;\r
4681 \r
4682       -thread-safe)\r
4683         thread_safe=yes\r
4684         continue\r
4685         ;;\r
4686 \r
4687       -version-info)\r
4688         prev=vinfo\r
4689         continue\r
4690         ;;\r
4691 \r
4692       -version-number)\r
4693         prev=vinfo\r
4694         vinfo_number=yes\r
4695         continue\r
4696         ;;\r
4697 \r
4698       -weak)\r
4699         prev=weak\r
4700         continue\r
4701         ;;\r
4702 \r
4703       -Wc,*)\r
4704         func_stripname '-Wc,' '' "$arg"\r
4705         args=$func_stripname_result\r
4706         arg=\r
4707         save_ifs="$IFS"; IFS=','\r
4708         for flag in $args; do\r
4709           IFS="$save_ifs"\r
4710           func_quote_for_eval "$flag"\r
4711           arg="$arg $wl$func_quote_for_eval_result"\r
4712           compiler_flags="$compiler_flags $func_quote_for_eval_result"\r
4713         done\r
4714         IFS="$save_ifs"\r
4715         func_stripname ' ' '' "$arg"\r
4716         arg=$func_stripname_result\r
4717         ;;\r
4718 \r
4719       -Wl,*)\r
4720         func_stripname '-Wl,' '' "$arg"\r
4721         args=$func_stripname_result\r
4722         arg=\r
4723         save_ifs="$IFS"; IFS=','\r
4724         for flag in $args; do\r
4725           IFS="$save_ifs"\r
4726           func_quote_for_eval "$flag"\r
4727           arg="$arg $wl$func_quote_for_eval_result"\r
4728           compiler_flags="$compiler_flags $wl$func_quote_for_eval_result"\r
4729           linker_flags="$linker_flags $func_quote_for_eval_result"\r
4730         done\r
4731         IFS="$save_ifs"\r
4732         func_stripname ' ' '' "$arg"\r
4733         arg=$func_stripname_result\r
4734         ;;\r
4735 \r
4736       -Xcompiler)\r
4737         prev=xcompiler\r
4738         continue\r
4739         ;;\r
4740 \r
4741       -Xlinker)\r
4742         prev=xlinker\r
4743         continue\r
4744         ;;\r
4745 \r
4746       -XCClinker)\r
4747         prev=xcclinker\r
4748         continue\r
4749         ;;\r
4750 \r
4751       # -msg_* for osf cc\r
4752       -msg_*)\r
4753         func_quote_for_eval "$arg"\r
4754         arg="$func_quote_for_eval_result"\r
4755         ;;\r
4756 \r
4757       # -64, -mips[0-9] enable 64-bit mode on the SGI compiler\r
4758       # -r[0-9][0-9]* specifies the processor on the SGI compiler\r
4759       # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler\r
4760       # +DA*, +DD* enable 64-bit mode on the HP compiler\r
4761       # -q* pass through compiler args for the IBM compiler\r
4762       # -m*, -t[45]*, -txscale* pass through architecture-specific\r
4763       # compiler args for GCC\r
4764       # -F/path gives path to uninstalled frameworks, gcc on darwin\r
4765       # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC\r
4766       # @file GCC response files\r
4767       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \\r
4768       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)\r
4769         func_quote_for_eval "$arg"\r
4770         arg="$func_quote_for_eval_result"\r
4771         func_append compile_command " $arg"\r
4772         func_append finalize_command " $arg"\r
4773         compiler_flags="$compiler_flags $arg"\r
4774         continue\r
4775         ;;\r
4776 \r
4777       # Some other compiler flag.\r
4778       -* | +*)\r
4779         func_quote_for_eval "$arg"\r
4780         arg="$func_quote_for_eval_result"\r
4781         ;;\r
4782 \r
4783       *.$objext)\r
4784         # A standard object.\r
4785         objs="$objs $arg"\r
4786         ;;\r
4787 \r
4788       *.lo)\r
4789         # A libtool-controlled object.\r
4790 \r
4791         # Check to see that this really is a libtool object.\r
4792         if func_lalib_unsafe_p "$arg"; then\r
4793           pic_object=\r
4794           non_pic_object=\r
4795 \r
4796           # Read the .lo file\r
4797           func_source "$arg"\r
4798 \r
4799           if test -z "$pic_object" ||\r
4800              test -z "$non_pic_object" ||\r
4801              test "$pic_object" = none &&\r
4802              test "$non_pic_object" = none; then\r
4803             func_fatal_error "cannot find name of object for \`$arg'"\r
4804           fi\r
4805 \r
4806           # Extract subdirectory from the argument.\r
4807           func_dirname "$arg" "/" ""\r
4808           xdir="$func_dirname_result"\r
4809 \r
4810           if test "$pic_object" != none; then\r
4811             # Prepend the subdirectory the object is found in.\r
4812             pic_object="$xdir$pic_object"\r
4813 \r
4814             if test "$prev" = dlfiles; then\r
4815               if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then\r
4816                 dlfiles="$dlfiles $pic_object"\r
4817                 prev=\r
4818                 continue\r
4819               else\r
4820                 # If libtool objects are unsupported, then we need to preload.\r
4821                 prev=dlprefiles\r
4822               fi\r
4823             fi\r
4824 \r
4825             # CHECK ME:  I think I busted this.  -Ossama\r
4826             if test "$prev" = dlprefiles; then\r
4827               # Preload the old-style object.\r
4828               dlprefiles="$dlprefiles $pic_object"\r
4829               prev=\r
4830             fi\r
4831 \r
4832             # A PIC object.\r
4833             func_append libobjs " $pic_object"\r
4834             arg="$pic_object"\r
4835           fi\r
4836 \r
4837           # Non-PIC object.\r
4838           if test "$non_pic_object" != none; then\r
4839             # Prepend the subdirectory the object is found in.\r
4840             non_pic_object="$xdir$non_pic_object"\r
4841 \r
4842             # A standard non-PIC object\r
4843             func_append non_pic_objects " $non_pic_object"\r
4844             if test -z "$pic_object" || test "$pic_object" = none ; then\r
4845               arg="$non_pic_object"\r
4846             fi\r
4847           else\r
4848             # If the PIC object exists, use it instead.\r
4849             # $xdir was prepended to $pic_object above.\r
4850             non_pic_object="$pic_object"\r
4851             func_append non_pic_objects " $non_pic_object"\r
4852           fi\r
4853         else\r
4854           # Only an error if not doing a dry-run.\r
4855           if $opt_dry_run; then\r
4856             # Extract subdirectory from the argument.\r
4857             func_dirname "$arg" "/" ""\r
4858             xdir="$func_dirname_result"\r
4859 \r
4860             func_lo2o "$arg"\r
4861             pic_object=$xdir$objdir/$func_lo2o_result\r
4862             non_pic_object=$xdir$func_lo2o_result\r
4863             func_append libobjs " $pic_object"\r
4864             func_append non_pic_objects " $non_pic_object"\r
4865           else\r
4866             func_fatal_error "\`$arg' is not a valid libtool object"\r
4867           fi\r
4868         fi\r
4869         ;;\r
4870 \r
4871       *.$libext)\r
4872         # An archive.\r
4873         deplibs="$deplibs $arg"\r
4874         old_deplibs="$old_deplibs $arg"\r
4875         continue\r
4876         ;;\r
4877 \r
4878       *.la)\r
4879         # A libtool-controlled library.\r
4880 \r
4881         if test "$prev" = dlfiles; then\r
4882           # This library was specified with -dlopen.\r
4883           dlfiles="$dlfiles $arg"\r
4884           prev=\r
4885         elif test "$prev" = dlprefiles; then\r
4886           # The library was specified with -dlpreopen.\r
4887           dlprefiles="$dlprefiles $arg"\r
4888           prev=\r
4889         else\r
4890           deplibs="$deplibs $arg"\r
4891         fi\r
4892         continue\r
4893         ;;\r
4894 \r
4895       # Some other compiler argument.\r
4896       *)\r
4897         # Unknown arguments in both finalize_command and compile_command need\r
4898         # to be aesthetically quoted because they are evaled later.\r
4899         func_quote_for_eval "$arg"\r
4900         arg="$func_quote_for_eval_result"\r
4901         ;;\r
4902       esac # arg\r
4903 \r
4904       # Now actually substitute the argument into the commands.\r
4905       if test -n "$arg"; then\r
4906         func_append compile_command " $arg"\r
4907         func_append finalize_command " $arg"\r
4908       fi\r
4909     done # argument parsing loop\r
4910 \r
4911     test -n "$prev" && \\r
4912       func_fatal_help "the \`$prevarg' option requires an argument"\r
4913 \r
4914     if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then\r
4915       eval arg=\"$export_dynamic_flag_spec\"\r
4916       func_append compile_command " $arg"\r
4917       func_append finalize_command " $arg"\r
4918     fi\r
4919 \r
4920     oldlibs=\r
4921     # calculate the name of the file, without its directory\r
4922     func_basename "$output"\r
4923     outputname="$func_basename_result"\r
4924     libobjs_save="$libobjs"\r
4925 \r
4926     if test -n "$shlibpath_var"; then\r
4927       # get the directories listed in $shlibpath_var\r
4928       eval shlib_search_path=\`\$ECHO \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`\r
4929     else\r
4930       shlib_search_path=\r
4931     fi\r
4932     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"\r
4933     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"\r
4934 \r
4935     func_dirname "$output" "/" ""\r
4936     output_objdir="$func_dirname_result$objdir"\r
4937     # Create the object directory.\r
4938     func_mkdir_p "$output_objdir"\r
4939 \r
4940     # Determine the type of output\r
4941     case $output in\r
4942     "")\r
4943       func_fatal_help "you must specify an output file"\r
4944       ;;\r
4945     *.$libext) linkmode=oldlib ;;\r
4946     *.lo | *.$objext) linkmode=obj ;;\r
4947     *.la) linkmode=lib ;;\r
4948     *) linkmode=prog ;; # Anything else should be a program.\r
4949     esac\r
4950 \r
4951     specialdeplibs=\r
4952 \r
4953     libs=\r
4954     # Find all interdependent deplibs by searching for libraries\r
4955     # that are linked more than once (e.g. -la -lb -la)\r
4956     for deplib in $deplibs; do\r
4957       if $opt_duplicate_deps ; then\r
4958         case "$libs " in\r
4959         *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;\r
4960         esac\r
4961       fi\r
4962       libs="$libs $deplib"\r
4963     done\r
4964 \r
4965     if test "$linkmode" = lib; then\r
4966       libs="$predeps $libs $compiler_lib_search_path $postdeps"\r
4967 \r
4968       # Compute libraries that are listed more than once in $predeps\r
4969       # $postdeps and mark them as special (i.e., whose duplicates are\r
4970       # not to be eliminated).\r
4971       pre_post_deps=\r
4972       if $opt_duplicate_compiler_generated_deps; then\r
4973         for pre_post_dep in $predeps $postdeps; do\r
4974           case "$pre_post_deps " in\r
4975           *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;\r
4976           esac\r
4977           pre_post_deps="$pre_post_deps $pre_post_dep"\r
4978         done\r
4979       fi\r
4980       pre_post_deps=\r
4981     fi\r
4982 \r
4983     deplibs=\r
4984     newdependency_libs=\r
4985     newlib_search_path=\r
4986     need_relink=no # whether we're linking any uninstalled libtool libraries\r
4987     notinst_deplibs= # not-installed libtool libraries\r
4988     notinst_path= # paths that contain not-installed libtool libraries\r
4989 \r
4990     case $linkmode in\r
4991     lib)\r
4992         passes="conv dlpreopen link"\r
4993         for file in $dlfiles $dlprefiles; do\r
4994           case $file in\r
4995           *.la) ;;\r
4996           *)\r
4997             func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"\r
4998             ;;\r
4999           esac\r
5000         done\r
5001         ;;\r
5002     prog)\r
5003         compile_deplibs=\r
5004         finalize_deplibs=\r
5005         alldeplibs=no\r
5006         newdlfiles=\r
5007         newdlprefiles=\r
5008         passes="conv scan dlopen dlpreopen link"\r
5009         ;;\r
5010     *)  passes="conv"\r
5011         ;;\r
5012     esac\r
5013 \r
5014     for pass in $passes; do\r
5015       # The preopen pass in lib mode reverses $deplibs; put it back here\r
5016       # so that -L comes before libs that need it for instance...\r
5017       if test "$linkmode,$pass" = "lib,link"; then\r
5018         ## FIXME: Find the place where the list is rebuilt in the wrong\r
5019         ##        order, and fix it there properly\r
5020         tmp_deplibs=\r
5021         for deplib in $deplibs; do\r
5022           tmp_deplibs="$deplib $tmp_deplibs"\r
5023         done\r
5024         deplibs="$tmp_deplibs"\r
5025       fi\r
5026 \r
5027       if test "$linkmode,$pass" = "lib,link" ||\r
5028          test "$linkmode,$pass" = "prog,scan"; then\r
5029         libs="$deplibs"\r
5030         deplibs=\r
5031       fi\r
5032       if test "$linkmode" = prog; then\r
5033         case $pass in\r
5034         dlopen) libs="$dlfiles" ;;\r
5035         dlpreopen) libs="$dlprefiles" ;;\r
5036         link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;\r
5037         esac\r
5038       fi\r
5039       if test "$linkmode,$pass" = "lib,dlpreopen"; then\r
5040         # Collect and forward deplibs of preopened libtool libs\r
5041         for lib in $dlprefiles; do\r
5042           # Ignore non-libtool-libs\r
5043           dependency_libs=\r
5044           case $lib in\r
5045           *.la) func_source "$lib" ;;\r
5046           esac\r
5047 \r
5048           # Collect preopened libtool deplibs, except any this library\r
5049           # has declared as weak libs\r
5050           for deplib in $dependency_libs; do\r
5051             deplib_base=`$ECHO "X$deplib" | $Xsed -e "$basename"`\r
5052             case " $weak_libs " in\r
5053             *" $deplib_base "*) ;;\r
5054             *) deplibs="$deplibs $deplib" ;;\r
5055             esac\r
5056           done\r
5057         done\r
5058         libs="$dlprefiles"\r
5059       fi\r
5060       if test "$pass" = dlopen; then\r
5061         # Collect dlpreopened libraries\r
5062         save_deplibs="$deplibs"\r
5063         deplibs=\r
5064       fi\r
5065 \r
5066       for deplib in $libs; do\r
5067         lib=\r
5068         found=no\r
5069         case $deplib in\r
5070         -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)\r
5071           if test "$linkmode,$pass" = "prog,link"; then\r
5072             compile_deplibs="$deplib $compile_deplibs"\r
5073             finalize_deplibs="$deplib $finalize_deplibs"\r
5074           else\r
5075             compiler_flags="$compiler_flags $deplib"\r
5076             if test "$linkmode" = lib ; then\r
5077                 case "$new_inherited_linker_flags " in\r
5078                     *" $deplib "*) ;;\r
5079                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;\r
5080                 esac\r
5081             fi\r
5082           fi\r
5083           continue\r
5084           ;;\r
5085         -l*)\r
5086           if test "$linkmode" != lib && test "$linkmode" != prog; then\r
5087             func_warning "\`-l' is ignored for archives/objects"\r
5088             continue\r
5089           fi\r
5090           func_stripname '-l' '' "$deplib"\r
5091           name=$func_stripname_result\r
5092           if test "$linkmode" = lib; then\r
5093             searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"\r
5094           else\r
5095             searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"\r
5096           fi\r
5097           for searchdir in $searchdirs; do\r
5098             for search_ext in .la $std_shrext .so .a; do\r
5099               # Search the libtool library\r
5100               lib="$searchdir/lib${name}${search_ext}"\r
5101               if test -f "$lib"; then\r
5102                 if test "$search_ext" = ".la"; then\r
5103                   found=yes\r
5104                 else\r
5105                   found=no\r
5106                 fi\r
5107                 break 2\r
5108               fi\r
5109             done\r
5110           done\r
5111           if test "$found" != yes; then\r
5112             # deplib doesn't seem to be a libtool library\r
5113             if test "$linkmode,$pass" = "prog,link"; then\r
5114               compile_deplibs="$deplib $compile_deplibs"\r
5115               finalize_deplibs="$deplib $finalize_deplibs"\r
5116             else\r
5117               deplibs="$deplib $deplibs"\r
5118               test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"\r
5119             fi\r
5120             continue\r
5121           else # deplib is a libtool library\r
5122             # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,\r
5123             # We need to do some special things here, and not later.\r
5124             if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then\r
5125               case " $predeps $postdeps " in\r
5126               *" $deplib "*)\r
5127                 if func_lalib_p "$lib"; then\r
5128                   library_names=\r
5129                   old_library=\r
5130                   func_source "$lib"\r
5131                   for l in $old_library $library_names; do\r
5132                     ll="$l"\r
5133                   done\r
5134                   if test "X$ll" = "X$old_library" ; then # only static version available\r
5135                     found=no\r
5136                     func_dirname "$lib" "" "."\r
5137                     ladir="$func_dirname_result"\r
5138                     lib=$ladir/$old_library\r
5139                     if test "$linkmode,$pass" = "prog,link"; then\r
5140                       compile_deplibs="$deplib $compile_deplibs"\r
5141                       finalize_deplibs="$deplib $finalize_deplibs"\r
5142                     else\r
5143                       deplibs="$deplib $deplibs"\r
5144                       test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"\r
5145                     fi\r
5146                     continue\r
5147                   fi\r
5148                 fi\r
5149                 ;;\r
5150               *) ;;\r
5151               esac\r
5152             fi\r
5153           fi\r
5154           ;; # -l\r
5155         *.ltframework)\r
5156           if test "$linkmode,$pass" = "prog,link"; then\r
5157             compile_deplibs="$deplib $compile_deplibs"\r
5158             finalize_deplibs="$deplib $finalize_deplibs"\r
5159           else\r
5160             deplibs="$deplib $deplibs"\r
5161             if test "$linkmode" = lib ; then\r
5162                 case "$new_inherited_linker_flags " in\r
5163                     *" $deplib "*) ;;\r
5164                     * ) new_inherited_linker_flags="$new_inherited_linker_flags $deplib" ;;\r
5165                 esac\r
5166             fi\r
5167           fi\r
5168           continue\r
5169           ;;\r
5170         -L*)\r
5171           case $linkmode in\r
5172           lib)\r
5173             deplibs="$deplib $deplibs"\r
5174             test "$pass" = conv && continue\r
5175             newdependency_libs="$deplib $newdependency_libs"\r
5176             func_stripname '-L' '' "$deplib"\r
5177             newlib_search_path="$newlib_search_path $func_stripname_result"\r
5178             ;;\r
5179           prog)\r
5180             if test "$pass" = conv; then\r
5181               deplibs="$deplib $deplibs"\r
5182               continue\r
5183             fi\r
5184             if test "$pass" = scan; then\r
5185               deplibs="$deplib $deplibs"\r
5186             else\r
5187               compile_deplibs="$deplib $compile_deplibs"\r
5188               finalize_deplibs="$deplib $finalize_deplibs"\r
5189             fi\r
5190             func_stripname '-L' '' "$deplib"\r
5191             newlib_search_path="$newlib_search_path $func_stripname_result"\r
5192             ;;\r
5193           *)\r
5194             func_warning "\`-L' is ignored for archives/objects"\r
5195             ;;\r
5196           esac # linkmode\r
5197           continue\r
5198           ;; # -L\r
5199         -R*)\r
5200           if test "$pass" = link; then\r
5201             func_stripname '-R' '' "$deplib"\r
5202             dir=$func_stripname_result\r
5203             # Make sure the xrpath contains only unique directories.\r
5204             case "$xrpath " in\r
5205             *" $dir "*) ;;\r
5206             *) xrpath="$xrpath $dir" ;;\r
5207             esac\r
5208           fi\r
5209           deplibs="$deplib $deplibs"\r
5210           continue\r
5211           ;;\r
5212         *.la) lib="$deplib" ;;\r
5213         *.$libext)\r
5214           if test "$pass" = conv; then\r
5215             deplibs="$deplib $deplibs"\r
5216             continue\r
5217           fi\r
5218           case $linkmode in\r
5219           lib)\r
5220             # Linking convenience modules into shared libraries is allowed,\r
5221             # but linking other static libraries is non-portable.\r
5222             case " $dlpreconveniencelibs " in\r
5223             *" $deplib "*) ;;\r
5224             *)\r
5225               valid_a_lib=no\r
5226               case $deplibs_check_method in\r
5227                 match_pattern*)\r
5228                   set dummy $deplibs_check_method; shift\r
5229                   match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`\r
5230                   if eval "\$ECHO \"X$deplib\"" 2>/dev/null | $Xsed -e 10q \\r
5231                     | $EGREP "$match_pattern_regex" > /dev/null; then\r
5232                     valid_a_lib=yes\r
5233                   fi\r
5234                 ;;\r
5235                 pass_all)\r
5236                   valid_a_lib=yes\r
5237                 ;;\r
5238               esac\r
5239               if test "$valid_a_lib" != yes; then\r
5240                 $ECHO\r
5241                 $ECHO "*** Warning: Trying to link with static lib archive $deplib."\r
5242                 $ECHO "*** I have the capability to make that library automatically link in when"\r
5243                 $ECHO "*** you link to this library.  But I can only do this if you have a"\r
5244                 $ECHO "*** shared version of the library, which you do not appear to have"\r
5245                 $ECHO "*** because the file extensions .$libext of this argument makes me believe"\r
5246                 $ECHO "*** that it is just a static archive that I should not use here."\r
5247               else\r
5248                 $ECHO\r
5249                 $ECHO "*** Warning: Linking the shared library $output against the"\r
5250                 $ECHO "*** static library $deplib is not portable!"\r
5251                 deplibs="$deplib $deplibs"\r
5252               fi\r
5253               ;;\r
5254             esac\r
5255             continue\r
5256             ;;\r
5257           prog)\r
5258             if test "$pass" != link; then\r
5259               deplibs="$deplib $deplibs"\r
5260             else\r
5261               compile_deplibs="$deplib $compile_deplibs"\r
5262               finalize_deplibs="$deplib $finalize_deplibs"\r
5263             fi\r
5264             continue\r
5265             ;;\r
5266           esac # linkmode\r
5267           ;; # *.$libext\r
5268         *.lo | *.$objext)\r
5269           if test "$pass" = conv; then\r
5270             deplibs="$deplib $deplibs"\r
5271           elif test "$linkmode" = prog; then\r
5272             if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then\r
5273               # If there is no dlopen support or we're linking statically,\r
5274               # we need to preload.\r
5275               newdlprefiles="$newdlprefiles $deplib"\r
5276               compile_deplibs="$deplib $compile_deplibs"\r
5277               finalize_deplibs="$deplib $finalize_deplibs"\r
5278             else\r
5279               newdlfiles="$newdlfiles $deplib"\r
5280             fi\r
5281           fi\r
5282           continue\r
5283           ;;\r
5284         %DEPLIBS%)\r
5285           alldeplibs=yes\r
5286           continue\r
5287           ;;\r
5288         esac # case $deplib\r
5289 \r
5290         if test "$found" = yes || test -f "$lib"; then :\r
5291         else\r
5292           func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"\r
5293         fi\r
5294 \r
5295         # Check to see that this really is a libtool archive.\r
5296         func_lalib_unsafe_p "$lib" \\r
5297           || func_fatal_error "\`$lib' is not a valid libtool archive"\r
5298 \r
5299         func_dirname "$lib" "" "."\r
5300         ladir="$func_dirname_result"\r
5301 \r
5302         dlname=\r
5303         dlopen=\r
5304         dlpreopen=\r
5305         libdir=\r
5306         library_names=\r
5307         old_library=\r
5308         inherited_linker_flags=\r
5309         # If the library was installed with an old release of libtool,\r
5310         # it will not redefine variables installed, or shouldnotlink\r
5311         installed=yes\r
5312         shouldnotlink=no\r
5313         avoidtemprpath=\r
5314 \r
5315 \r
5316         # Read the .la file\r
5317         func_source "$lib"\r
5318 \r
5319         # Convert "-framework foo" to "foo.ltframework"\r
5320         if test -n "$inherited_linker_flags"; then\r
5321           tmp_inherited_linker_flags=`$ECHO "X$inherited_linker_flags" | $Xsed -e 's/-framework \([^ $]*\)/\1.ltframework/g'`\r
5322           for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do\r
5323             case " $new_inherited_linker_flags " in\r
5324               *" $tmp_inherited_linker_flag "*) ;;\r
5325               *) new_inherited_linker_flags="$new_inherited_linker_flags $tmp_inherited_linker_flag";;\r
5326             esac\r
5327           done\r
5328         fi\r
5329         dependency_libs=`$ECHO "X $dependency_libs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`\r
5330         if test "$linkmode,$pass" = "lib,link" ||\r
5331            test "$linkmode,$pass" = "prog,scan" ||\r
5332            { test "$linkmode" != prog && test "$linkmode" != lib; }; then\r
5333           test -n "$dlopen" && dlfiles="$dlfiles $dlopen"\r
5334           test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"\r
5335         fi\r
5336 \r
5337         if test "$pass" = conv; then\r
5338           # Only check for convenience libraries\r
5339           deplibs="$lib $deplibs"\r
5340           if test -z "$libdir"; then\r
5341             if test -z "$old_library"; then\r
5342               func_fatal_error "cannot find name of link library for \`$lib'"\r
5343             fi\r
5344             # It is a libtool convenience library, so add in its objects.\r
5345             convenience="$convenience $ladir/$objdir/$old_library"\r
5346             old_convenience="$old_convenience $ladir/$objdir/$old_library"\r
5347           elif test "$linkmode" != prog && test "$linkmode" != lib; then\r
5348             func_fatal_error "\`$lib' is not a convenience library"\r
5349           fi\r
5350           tmp_libs=\r
5351           for deplib in $dependency_libs; do\r
5352             deplibs="$deplib $deplibs"\r
5353             if $opt_duplicate_deps ; then\r
5354               case "$tmp_libs " in\r
5355               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;\r
5356               esac\r
5357             fi\r
5358             tmp_libs="$tmp_libs $deplib"\r
5359           done\r
5360           continue\r
5361         fi # $pass = conv\r
5362 \r
5363 \r
5364         # Get the name of the library we link against.\r
5365         linklib=\r
5366         for l in $old_library $library_names; do\r
5367           linklib="$l"\r
5368         done\r
5369         if test -z "$linklib"; then\r
5370           func_fatal_error "cannot find name of link library for \`$lib'"\r
5371         fi\r
5372 \r
5373         # This library was specified with -dlopen.\r
5374         if test "$pass" = dlopen; then\r
5375           if test -z "$libdir"; then\r
5376             func_fatal_error "cannot -dlopen a convenience library: \`$lib'"\r
5377           fi\r
5378           if test -z "$dlname" ||\r
5379              test "$dlopen_support" != yes ||\r
5380              test "$build_libtool_libs" = no; then\r
5381             # If there is no dlname, no dlopen support or we're linking\r
5382             # statically, we need to preload.  We also need to preload any\r
5383             # dependent libraries so libltdl's deplib preloader doesn't\r
5384             # bomb out in the load deplibs phase.\r
5385             dlprefiles="$dlprefiles $lib $dependency_libs"\r
5386           else\r
5387             newdlfiles="$newdlfiles $lib"\r
5388           fi\r
5389           continue\r
5390         fi # $pass = dlopen\r
5391 \r
5392         # We need an absolute path.\r
5393         case $ladir in\r
5394         [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;\r
5395         *)\r
5396           abs_ladir=`cd "$ladir" && pwd`\r
5397           if test -z "$abs_ladir"; then\r
5398             func_warning "cannot determine absolute directory name of \`$ladir'"\r
5399             func_warning "passing it literally to the linker, although it might fail"\r
5400             abs_ladir="$ladir"\r
5401           fi\r
5402           ;;\r
5403         esac\r
5404         func_basename "$lib"\r
5405         laname="$func_basename_result"\r
5406 \r
5407         # Find the relevant object directory and library name.\r
5408         if test "X$installed" = Xyes; then\r
5409           if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then\r
5410             func_warning "library \`$lib' was moved."\r
5411             dir="$ladir"\r
5412             absdir="$abs_ladir"\r
5413             libdir="$abs_ladir"\r
5414           else\r
5415             dir="$libdir"\r
5416             absdir="$libdir"\r
5417           fi\r
5418           test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes\r
5419         else\r
5420           if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then\r
5421             dir="$ladir"\r
5422             absdir="$abs_ladir"\r
5423             # Remove this search path later\r
5424             notinst_path="$notinst_path $abs_ladir"\r
5425           else\r
5426             dir="$ladir/$objdir"\r
5427             absdir="$abs_ladir/$objdir"\r
5428             # Remove this search path later\r
5429             notinst_path="$notinst_path $abs_ladir"\r
5430           fi\r
5431         fi # $installed = yes\r
5432         func_stripname 'lib' '.la' "$laname"\r
5433         name=$func_stripname_result\r
5434 \r
5435         # This library was specified with -dlpreopen.\r
5436         if test "$pass" = dlpreopen; then\r
5437           if test -z "$libdir" && test "$linkmode" = prog; then\r
5438             func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"\r
5439           fi\r
5440           # Prefer using a static library (so that no silly _DYNAMIC symbols\r
5441           # are required to link).\r
5442           if test -n "$old_library"; then\r
5443             newdlprefiles="$newdlprefiles $dir/$old_library"\r
5444             # Keep a list of preopened convenience libraries to check\r
5445             # that they are being used correctly in the link pass.\r
5446             test -z "$libdir" && \\r
5447                 dlpreconveniencelibs="$dlpreconveniencelibs $dir/$old_library"\r
5448           # Otherwise, use the dlname, so that lt_dlopen finds it.\r
5449           elif test -n "$dlname"; then\r
5450             newdlprefiles="$newdlprefiles $dir/$dlname"\r
5451           else\r
5452             newdlprefiles="$newdlprefiles $dir/$linklib"\r
5453           fi\r
5454         fi # $pass = dlpreopen\r
5455 \r
5456         if test -z "$libdir"; then\r
5457           # Link the convenience library\r
5458           if test "$linkmode" = lib; then\r
5459             deplibs="$dir/$old_library $deplibs"\r
5460           elif test "$linkmode,$pass" = "prog,link"; then\r
5461             compile_deplibs="$dir/$old_library $compile_deplibs"\r
5462             finalize_deplibs="$dir/$old_library $finalize_deplibs"\r
5463           else\r
5464             deplibs="$lib $deplibs" # used for prog,scan pass\r
5465           fi\r
5466           continue\r
5467         fi\r
5468 \r
5469 \r
5470         if test "$linkmode" = prog && test "$pass" != link; then\r
5471           newlib_search_path="$newlib_search_path $ladir"\r
5472           deplibs="$lib $deplibs"\r
5473 \r
5474           linkalldeplibs=no\r
5475           if test "$link_all_deplibs" != no || test -z "$library_names" ||\r
5476              test "$build_libtool_libs" = no; then\r
5477             linkalldeplibs=yes\r
5478           fi\r
5479 \r
5480           tmp_libs=\r
5481           for deplib in $dependency_libs; do\r
5482             case $deplib in\r
5483             -L*) func_stripname '-L' '' "$deplib"\r
5484                  newlib_search_path="$newlib_search_path $func_stripname_result"\r
5485                  ;;\r
5486             esac\r
5487             # Need to link against all dependency_libs?\r
5488             if test "$linkalldeplibs" = yes; then\r
5489               deplibs="$deplib $deplibs"\r
5490             else\r
5491               # Need to hardcode shared library paths\r
5492               # or/and link against static libraries\r
5493               newdependency_libs="$deplib $newdependency_libs"\r
5494             fi\r
5495             if $opt_duplicate_deps ; then\r
5496               case "$tmp_libs " in\r
5497               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;\r
5498               esac\r
5499             fi\r
5500             tmp_libs="$tmp_libs $deplib"\r
5501           done # for deplib\r
5502           continue\r
5503         fi # $linkmode = prog...\r
5504 \r
5505         if test "$linkmode,$pass" = "prog,link"; then\r
5506           if test -n "$library_names" &&\r
5507              { { test "$prefer_static_libs" = no ||\r
5508                  test "$prefer_static_libs,$installed" = "built,yes"; } ||\r
5509                test -z "$old_library"; }; then\r
5510             # We need to hardcode the library path\r
5511             if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then\r
5512               # Make sure the rpath contains only unique directories.\r
5513               case "$temp_rpath:" in\r
5514               *"$absdir:"*) ;;\r
5515               *) temp_rpath="$temp_rpath$absdir:" ;;\r
5516               esac\r
5517             fi\r
5518 \r
5519             # Hardcode the library path.\r
5520             # Skip directories that are in the system default run-time\r
5521             # search path.\r
5522             case " $sys_lib_dlsearch_path " in\r
5523             *" $absdir "*) ;;\r
5524             *)\r
5525               case "$compile_rpath " in\r
5526               *" $absdir "*) ;;\r
5527               *) compile_rpath="$compile_rpath $absdir"\r
5528               esac\r
5529               ;;\r
5530             esac\r
5531             case " $sys_lib_dlsearch_path " in\r
5532             *" $libdir "*) ;;\r
5533             *)\r
5534               case "$finalize_rpath " in\r
5535               *" $libdir "*) ;;\r
5536               *) finalize_rpath="$finalize_rpath $libdir"\r
5537               esac\r
5538               ;;\r
5539             esac\r
5540           fi # $linkmode,$pass = prog,link...\r
5541 \r
5542           if test "$alldeplibs" = yes &&\r
5543              { test "$deplibs_check_method" = pass_all ||\r
5544                { test "$build_libtool_libs" = yes &&\r
5545                  test -n "$library_names"; }; }; then\r
5546             # We only need to search for static libraries\r
5547             continue\r
5548           fi\r
5549         fi\r
5550 \r
5551         link_static=no # Whether the deplib will be linked statically\r
5552         use_static_libs=$prefer_static_libs\r
5553         if test "$use_static_libs" = built && test "$installed" = yes; then\r
5554           use_static_libs=no\r
5555         fi\r
5556         if test -n "$library_names" &&\r
5557            { test "$use_static_libs" = no || test -z "$old_library"; }; then\r
5558           case $host in\r
5559           *cygwin* | *mingw* | *cegcc*)\r
5560               # No point in relinking DLLs because paths are not encoded\r
5561               notinst_deplibs="$notinst_deplibs $lib"\r
5562               need_relink=no\r
5563             ;;\r
5564           *)\r
5565             if test "$installed" = no; then\r
5566               notinst_deplibs="$notinst_deplibs $lib"\r
5567               need_relink=yes\r
5568             fi\r
5569             ;;\r
5570           esac\r
5571           # This is a shared library\r
5572 \r
5573           # Warn about portability, can't link against -module's on some\r
5574           # systems (darwin).  Don't bleat about dlopened modules though!\r
5575           dlopenmodule=""\r
5576           for dlpremoduletest in $dlprefiles; do\r
5577             if test "X$dlpremoduletest" = "X$lib"; then\r
5578               dlopenmodule="$dlpremoduletest"\r
5579               break\r
5580             fi\r
5581           done\r
5582           if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then\r
5583             $ECHO\r
5584             if test "$linkmode" = prog; then\r
5585               $ECHO "*** Warning: Linking the executable $output against the loadable module"\r
5586             else\r
5587               $ECHO "*** Warning: Linking the shared library $output against the loadable module"\r
5588             fi\r
5589             $ECHO "*** $linklib is not portable!"\r
5590           fi\r
5591           if test "$linkmode" = lib &&\r
5592              test "$hardcode_into_libs" = yes; then\r
5593             # Hardcode the library path.\r
5594             # Skip directories that are in the system default run-time\r
5595             # search path.\r
5596             case " $sys_lib_dlsearch_path " in\r
5597             *" $absdir "*) ;;\r
5598             *)\r
5599               case "$compile_rpath " in\r
5600               *" $absdir "*) ;;\r
5601               *) compile_rpath="$compile_rpath $absdir"\r
5602               esac\r
5603               ;;\r
5604             esac\r
5605             case " $sys_lib_dlsearch_path " in\r
5606             *" $libdir "*) ;;\r
5607             *)\r
5608               case "$finalize_rpath " in\r
5609               *" $libdir "*) ;;\r
5610               *) finalize_rpath="$finalize_rpath $libdir"\r
5611               esac\r
5612               ;;\r
5613             esac\r
5614           fi\r
5615 \r
5616           if test -n "$old_archive_from_expsyms_cmds"; then\r
5617             # figure out the soname\r
5618             set dummy $library_names\r
5619             shift\r
5620             realname="$1"\r
5621             shift\r
5622             libname=`eval "\\$ECHO \"$libname_spec\""`\r
5623             # use dlname if we got it. it's perfectly good, no?\r
5624             if test -n "$dlname"; then\r
5625               soname="$dlname"\r
5626             elif test -n "$soname_spec"; then\r
5627               # bleh windows\r
5628               case $host in\r
5629               *cygwin* | mingw* | *cegcc*)\r
5630                 func_arith $current - $age\r
5631                 major=$func_arith_result\r
5632                 versuffix="-$major"\r
5633                 ;;\r
5634               esac\r
5635               eval soname=\"$soname_spec\"\r
5636             else\r
5637               soname="$realname"\r
5638             fi\r
5639 \r
5640             # Make a new name for the extract_expsyms_cmds to use\r
5641             soroot="$soname"\r
5642             func_basename "$soroot"\r
5643             soname="$func_basename_result"\r
5644             func_stripname 'lib' '.dll' "$soname"\r
5645             newlib=libimp-$func_stripname_result.a\r
5646 \r
5647             # If the library has no export list, then create one now\r
5648             if test -f "$output_objdir/$soname-def"; then :\r
5649             else\r
5650               func_verbose "extracting exported symbol list from \`$soname'"\r
5651               func_execute_cmds "$extract_expsyms_cmds" 'exit $?'\r
5652             fi\r
5653 \r
5654             # Create $newlib\r
5655             if test -f "$output_objdir/$newlib"; then :; else\r
5656               func_verbose "generating import library for \`$soname'"\r
5657               func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'\r
5658             fi\r
5659             # make sure the library variables are pointing to the new library\r
5660             dir=$output_objdir\r
5661             linklib=$newlib\r
5662           fi # test -n "$old_archive_from_expsyms_cmds"\r
5663 \r
5664           if test "$linkmode" = prog || test "$mode" != relink; then\r
5665             add_shlibpath=\r
5666             add_dir=\r
5667             add=\r
5668             lib_linked=yes\r
5669             case $hardcode_action in\r
5670             immediate | unsupported)\r
5671               if test "$hardcode_direct" = no; then\r
5672                 add="$dir/$linklib"\r
5673                 case $host in\r
5674                   *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;\r
5675                   *-*-sysv4*uw2*) add_dir="-L$dir" ;;\r
5676                   *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \\r
5677                     *-*-unixware7*) add_dir="-L$dir" ;;\r
5678                   *-*-darwin* )\r
5679                     # if the lib is a (non-dlopened) module then we can not\r
5680                     # link against it, someone is ignoring the earlier warnings\r
5681                     if /usr/bin/file -L $add 2> /dev/null |\r
5682                          $GREP ": [^:]* bundle" >/dev/null ; then\r
5683                       if test "X$dlopenmodule" != "X$lib"; then\r
5684                         $ECHO "*** Warning: lib $linklib is a module, not a shared library"\r
5685                         if test -z "$old_library" ; then\r
5686                           $ECHO\r
5687                           $ECHO "*** And there doesn't seem to be a static archive available"\r
5688                           $ECHO "*** The link will probably fail, sorry"\r
5689                         else\r
5690                           add="$dir/$old_library"\r
5691                         fi\r
5692                       elif test -n "$old_library"; then\r
5693                         add="$dir/$old_library"\r
5694                       fi\r
5695                     fi\r
5696                 esac\r
5697               elif test "$hardcode_minus_L" = no; then\r
5698                 case $host in\r
5699                 *-*-sunos*) add_shlibpath="$dir" ;;\r
5700                 esac\r
5701                 add_dir="-L$dir"\r
5702                 add="-l$name"\r
5703               elif test "$hardcode_shlibpath_var" = no; then\r
5704                 add_shlibpath="$dir"\r
5705                 add="-l$name"\r
5706               else\r
5707                 lib_linked=no\r
5708               fi\r
5709               ;;\r
5710             relink)\r
5711               if test "$hardcode_direct" = yes &&\r
5712                  test "$hardcode_direct_absolute" = no; then\r
5713                 add="$dir/$linklib"\r
5714               elif test "$hardcode_minus_L" = yes; then\r
5715                 add_dir="-L$dir"\r
5716                 # Try looking first in the location we're being installed to.\r
5717                 if test -n "$inst_prefix_dir"; then\r
5718                   case $libdir in\r
5719                     [\\/]*)\r
5720                       add_dir="$add_dir -L$inst_prefix_dir$libdir"\r
5721                       ;;\r
5722                   esac\r
5723                 fi\r
5724                 add="-l$name"\r
5725               elif test "$hardcode_shlibpath_var" = yes; then\r
5726                 add_shlibpath="$dir"\r
5727                 add="-l$name"\r
5728               else\r
5729                 lib_linked=no\r
5730               fi\r
5731               ;;\r
5732             *) lib_linked=no ;;\r
5733             esac\r
5734 \r
5735             if test "$lib_linked" != yes; then\r
5736               func_fatal_configuration "unsupported hardcode properties"\r
5737             fi\r
5738 \r
5739             if test -n "$add_shlibpath"; then\r
5740               case :$compile_shlibpath: in\r
5741               *":$add_shlibpath:"*) ;;\r
5742               *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;\r
5743               esac\r
5744             fi\r
5745             if test "$linkmode" = prog; then\r
5746               test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"\r
5747               test -n "$add" && compile_deplibs="$add $compile_deplibs"\r
5748             else\r
5749               test -n "$add_dir" && deplibs="$add_dir $deplibs"\r
5750               test -n "$add" && deplibs="$add $deplibs"\r
5751               if test "$hardcode_direct" != yes &&\r
5752                  test "$hardcode_minus_L" != yes &&\r
5753                  test "$hardcode_shlibpath_var" = yes; then\r
5754                 case :$finalize_shlibpath: in\r
5755                 *":$libdir:"*) ;;\r
5756                 *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;\r
5757                 esac\r
5758               fi\r
5759             fi\r
5760           fi\r
5761 \r
5762           if test "$linkmode" = prog || test "$mode" = relink; then\r
5763             add_shlibpath=\r
5764             add_dir=\r
5765             add=\r
5766             # Finalize command for both is simple: just hardcode it.\r
5767             if test "$hardcode_direct" = yes &&\r
5768                test "$hardcode_direct_absolute" = no; then\r
5769               add="$libdir/$linklib"\r
5770             elif test "$hardcode_minus_L" = yes; then\r
5771               add_dir="-L$libdir"\r
5772               add="-l$name"\r
5773             elif test "$hardcode_shlibpath_var" = yes; then\r
5774               case :$finalize_shlibpath: in\r
5775               *":$libdir:"*) ;;\r
5776               *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;\r
5777               esac\r
5778               add="-l$name"\r
5779             elif test "$hardcode_automatic" = yes; then\r
5780               if test -n "$inst_prefix_dir" &&\r
5781                  test -f "$inst_prefix_dir$libdir/$linklib" ; then\r
5782                 add="$inst_prefix_dir$libdir/$linklib"\r
5783               else\r
5784                 add="$libdir/$linklib"\r
5785               fi\r
5786             else\r
5787               # We cannot seem to hardcode it, guess we'll fake it.\r
5788               add_dir="-L$libdir"\r
5789               # Try looking first in the location we're being installed to.\r
5790               if test -n "$inst_prefix_dir"; then\r
5791                 case $libdir in\r
5792                   [\\/]*)\r
5793                     add_dir="$add_dir -L$inst_prefix_dir$libdir"\r
5794                     ;;\r
5795                 esac\r
5796               fi\r
5797               add="-l$name"\r
5798             fi\r
5799 \r
5800             if test "$linkmode" = prog; then\r
5801               test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"\r
5802               test -n "$add" && finalize_deplibs="$add $finalize_deplibs"\r
5803             else\r
5804               test -n "$add_dir" && deplibs="$add_dir $deplibs"\r
5805               test -n "$add" && deplibs="$add $deplibs"\r
5806             fi\r
5807           fi\r
5808         elif test "$linkmode" = prog; then\r
5809           # Here we assume that one of hardcode_direct or hardcode_minus_L\r
5810           # is not unsupported.  This is valid on all known static and\r
5811           # shared platforms.\r
5812           if test "$hardcode_direct" != unsupported; then\r
5813             test -n "$old_library" && linklib="$old_library"\r
5814             compile_deplibs="$dir/$linklib $compile_deplibs"\r
5815             finalize_deplibs="$dir/$linklib $finalize_deplibs"\r
5816           else\r
5817             compile_deplibs="-l$name -L$dir $compile_deplibs"\r
5818             finalize_deplibs="-l$name -L$dir $finalize_deplibs"\r
5819           fi\r
5820         elif test "$build_libtool_libs" = yes; then\r
5821           # Not a shared library\r
5822           if test "$deplibs_check_method" != pass_all; then\r
5823             # We're trying link a shared library against a static one\r
5824             # but the system doesn't support it.\r
5825 \r
5826             # Just print a warning and add the library to dependency_libs so\r
5827             # that the program can be linked against the static library.\r
5828             $ECHO\r
5829             $ECHO "*** Warning: This system can not link to static lib archive $lib."\r
5830             $ECHO "*** I have the capability to make that library automatically link in when"\r
5831             $ECHO "*** you link to this library.  But I can only do this if you have a"\r
5832             $ECHO "*** shared version of the library, which you do not appear to have."\r
5833             if test "$module" = yes; then\r
5834               $ECHO "*** But as you try to build a module library, libtool will still create "\r
5835               $ECHO "*** a static module, that should work as long as the dlopening application"\r
5836               $ECHO "*** is linked with the -dlopen flag to resolve symbols at runtime."\r
5837               if test -z "$global_symbol_pipe"; then\r
5838                 $ECHO\r
5839                 $ECHO "*** However, this would only work if libtool was able to extract symbol"\r
5840                 $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"\r
5841                 $ECHO "*** not find such a program.  So, this module is probably useless."\r
5842                 $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."\r
5843               fi\r
5844               if test "$build_old_libs" = no; then\r
5845                 build_libtool_libs=module\r
5846                 build_old_libs=yes\r
5847               else\r
5848                 build_libtool_libs=no\r
5849               fi\r
5850             fi\r
5851           else\r
5852             deplibs="$dir/$old_library $deplibs"\r
5853             link_static=yes\r
5854           fi\r
5855         fi # link shared/static library?\r
5856 \r
5857         if test "$linkmode" = lib; then\r
5858           if test -n "$dependency_libs" &&\r
5859              { test "$hardcode_into_libs" != yes ||\r
5860                test "$build_old_libs" = yes ||\r
5861                test "$link_static" = yes; }; then\r
5862             # Extract -R from dependency_libs\r
5863             temp_deplibs=\r
5864             for libdir in $dependency_libs; do\r
5865               case $libdir in\r
5866               -R*) func_stripname '-R' '' "$libdir"\r
5867                    temp_xrpath=$func_stripname_result\r
5868                    case " $xrpath " in\r
5869                    *" $temp_xrpath "*) ;;\r
5870                    *) xrpath="$xrpath $temp_xrpath";;\r
5871                    esac;;\r
5872               *) temp_deplibs="$temp_deplibs $libdir";;\r
5873               esac\r
5874             done\r
5875             dependency_libs="$temp_deplibs"\r
5876           fi\r
5877 \r
5878           newlib_search_path="$newlib_search_path $absdir"\r
5879           # Link against this library\r
5880           test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"\r
5881           # ... and its dependency_libs\r
5882           tmp_libs=\r
5883           for deplib in $dependency_libs; do\r
5884             newdependency_libs="$deplib $newdependency_libs"\r
5885             if $opt_duplicate_deps ; then\r
5886               case "$tmp_libs " in\r
5887               *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;\r
5888               esac\r
5889             fi\r
5890             tmp_libs="$tmp_libs $deplib"\r
5891           done\r
5892 \r
5893           if test "$link_all_deplibs" != no; then\r
5894             # Add the search paths of all dependency libraries\r
5895             for deplib in $dependency_libs; do\r
5896               case $deplib in\r
5897               -L*) path="$deplib" ;;\r
5898               *.la)\r
5899                 func_dirname "$deplib" "" "."\r
5900                 dir="$func_dirname_result"\r
5901                 # We need an absolute path.\r
5902                 case $dir in\r
5903                 [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;\r
5904                 *)\r
5905                   absdir=`cd "$dir" && pwd`\r
5906                   if test -z "$absdir"; then\r
5907                     func_warning "cannot determine absolute directory name of \`$dir'"\r
5908                     absdir="$dir"\r
5909                   fi\r
5910                   ;;\r
5911                 esac\r
5912                 if $GREP "^installed=no" $deplib > /dev/null; then\r
5913                 case $host in\r
5914                 *-*-darwin*)\r
5915                   depdepl=\r
5916                   eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`\r
5917                   if test -n "$deplibrary_names" ; then\r
5918                     for tmp in $deplibrary_names ; do\r
5919                       depdepl=$tmp\r
5920                     done\r
5921                     if test -f "$absdir/$objdir/$depdepl" ; then\r
5922                       depdepl="$absdir/$objdir/$depdepl"\r
5923                       darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`\r
5924                       if test -z "$darwin_install_name"; then\r
5925                           darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`\r
5926                       fi\r
5927                       compiler_flags="$compiler_flags ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"\r
5928                       linker_flags="$linker_flags -dylib_file ${darwin_install_name}:${depdepl}"\r
5929                       path=\r
5930                     fi\r
5931                   fi\r
5932                   ;;\r
5933                 *)\r
5934                   path="-L$absdir/$objdir"\r
5935                   ;;\r
5936                 esac\r
5937                 else\r
5938                   eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`\r
5939                   test -z "$libdir" && \\r
5940                     func_fatal_error "\`$deplib' is not a valid libtool archive"\r
5941                   test "$absdir" != "$libdir" && \\r
5942                     func_warning "\`$deplib' seems to be moved"\r
5943 \r
5944                   path="-L$absdir"\r
5945                 fi\r
5946                 ;;\r
5947               esac\r
5948               case " $deplibs " in\r
5949               *" $path "*) ;;\r
5950               *) deplibs="$path $deplibs" ;;\r
5951               esac\r
5952             done\r
5953           fi # link_all_deplibs != no\r
5954         fi # linkmode = lib\r
5955       done # for deplib in $libs\r
5956       if test "$pass" = link; then\r
5957         if test "$linkmode" = "prog"; then\r
5958           compile_deplibs="$new_inherited_linker_flags $compile_deplibs"\r
5959           finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"\r
5960         else\r
5961           compiler_flags="$compiler_flags "`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`\r
5962         fi\r
5963       fi\r
5964       dependency_libs="$newdependency_libs"\r
5965       if test "$pass" = dlpreopen; then\r
5966         # Link the dlpreopened libraries before other libraries\r
5967         for deplib in $save_deplibs; do\r
5968           deplibs="$deplib $deplibs"\r
5969         done\r
5970       fi\r
5971       if test "$pass" != dlopen; then\r
5972         if test "$pass" != conv; then\r
5973           # Make sure lib_search_path contains only unique directories.\r
5974           lib_search_path=\r
5975           for dir in $newlib_search_path; do\r
5976             case "$lib_search_path " in\r
5977             *" $dir "*) ;;\r
5978             *) lib_search_path="$lib_search_path $dir" ;;\r
5979             esac\r
5980           done\r
5981           newlib_search_path=\r
5982         fi\r
5983 \r
5984         if test "$linkmode,$pass" != "prog,link"; then\r
5985           vars="deplibs"\r
5986         else\r
5987           vars="compile_deplibs finalize_deplibs"\r
5988         fi\r
5989         for var in $vars dependency_libs; do\r
5990           # Add libraries to $var in reverse order\r
5991           eval tmp_libs=\"\$$var\"\r
5992           new_libs=\r
5993           for deplib in $tmp_libs; do\r
5994             # FIXME: Pedantically, this is the right thing to do, so\r
5995             #        that some nasty dependency loop isn't accidentally\r
5996             #        broken:\r
5997             #new_libs="$deplib $new_libs"\r
5998             # Pragmatically, this seems to cause very few problems in\r
5999             # practice:\r
6000             case $deplib in\r
6001             -L*) new_libs="$deplib $new_libs" ;;\r
6002             -R*) ;;\r
6003             *)\r
6004               # And here is the reason: when a library appears more\r
6005               # than once as an explicit dependence of a library, or\r
6006               # is implicitly linked in more than once by the\r
6007               # compiler, it is considered special, and multiple\r
6008               # occurrences thereof are not removed.  Compare this\r
6009               # with having the same library being listed as a\r
6010               # dependency of multiple other libraries: in this case,\r
6011               # we know (pedantically, we assume) the library does not\r
6012               # need to be listed more than once, so we keep only the\r
6013               # last copy.  This is not always right, but it is rare\r
6014               # enough that we require users that really mean to play\r
6015               # such unportable linking tricks to link the library\r
6016               # using -Wl,-lname, so that libtool does not consider it\r
6017               # for duplicate removal.\r
6018               case " $specialdeplibs " in\r
6019               *" $deplib "*) new_libs="$deplib $new_libs" ;;\r
6020               *)\r
6021                 case " $new_libs " in\r
6022                 *" $deplib "*) ;;\r
6023                 *) new_libs="$deplib $new_libs" ;;\r
6024                 esac\r
6025                 ;;\r
6026               esac\r
6027               ;;\r
6028             esac\r
6029           done\r
6030           tmp_libs=\r
6031           for deplib in $new_libs; do\r
6032             case $deplib in\r
6033             -L*)\r
6034               case " $tmp_libs " in\r
6035               *" $deplib "*) ;;\r
6036               *) tmp_libs="$tmp_libs $deplib" ;;\r
6037               esac\r
6038               ;;\r
6039             *) tmp_libs="$tmp_libs $deplib" ;;\r
6040             esac\r
6041           done\r
6042           eval $var=\"$tmp_libs\"\r
6043         done # for var\r
6044       fi\r
6045       # Last step: remove runtime libs from dependency_libs\r
6046       # (they stay in deplibs)\r
6047       tmp_libs=\r
6048       for i in $dependency_libs ; do\r
6049         case " $predeps $postdeps $compiler_lib_search_path " in\r
6050         *" $i "*)\r
6051           i=""\r
6052           ;;\r
6053         esac\r
6054         if test -n "$i" ; then\r
6055           tmp_libs="$tmp_libs $i"\r
6056         fi\r
6057       done\r
6058       dependency_libs=$tmp_libs\r
6059     done # for pass\r
6060     if test "$linkmode" = prog; then\r
6061       dlfiles="$newdlfiles"\r
6062     fi\r
6063     if test "$linkmode" = prog || test "$linkmode" = lib; then\r
6064       dlprefiles="$newdlprefiles"\r
6065     fi\r
6066 \r
6067     case $linkmode in\r
6068     oldlib)\r
6069       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then\r
6070         func_warning "\`-dlopen' is ignored for archives"\r
6071       fi\r
6072 \r
6073       case " $deplibs" in\r
6074       *\ -l* | *\ -L*)\r
6075         func_warning "\`-l' and \`-L' are ignored for archives" ;;\r
6076       esac\r
6077 \r
6078       test -n "$rpath" && \\r
6079         func_warning "\`-rpath' is ignored for archives"\r
6080 \r
6081       test -n "$xrpath" && \\r
6082         func_warning "\`-R' is ignored for archives"\r
6083 \r
6084       test -n "$vinfo" && \\r
6085         func_warning "\`-version-info/-version-number' is ignored for archives"\r
6086 \r
6087       test -n "$release" && \\r
6088         func_warning "\`-release' is ignored for archives"\r
6089 \r
6090       test -n "$export_symbols$export_symbols_regex" && \\r
6091         func_warning "\`-export-symbols' is ignored for archives"\r
6092 \r
6093       # Now set the variables for building old libraries.\r
6094       build_libtool_libs=no\r
6095       oldlibs="$output"\r
6096       objs="$objs$old_deplibs"\r
6097       ;;\r
6098 \r
6099     lib)\r
6100       # Make sure we only generate libraries of the form `libNAME.la'.\r
6101       case $outputname in\r
6102       lib*)\r
6103         func_stripname 'lib' '.la' "$outputname"\r
6104         name=$func_stripname_result\r
6105         eval shared_ext=\"$shrext_cmds\"\r
6106         eval libname=\"$libname_spec\"\r
6107         ;;\r
6108       *)\r
6109         test "$module" = no && \\r
6110           func_fatal_help "libtool library \`$output' must begin with \`lib'"\r
6111 \r
6112         if test "$need_lib_prefix" != no; then\r
6113           # Add the "lib" prefix for modules if required\r
6114           func_stripname '' '.la' "$outputname"\r
6115           name=$func_stripname_result\r
6116           eval shared_ext=\"$shrext_cmds\"\r
6117           eval libname=\"$libname_spec\"\r
6118         else\r
6119           func_stripname '' '.la' "$outputname"\r
6120           libname=$func_stripname_result\r
6121         fi\r
6122         ;;\r
6123       esac\r
6124 \r
6125       if test -n "$objs"; then\r
6126         if test "$deplibs_check_method" != pass_all; then\r
6127           func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"\r
6128         else\r
6129           $ECHO\r
6130           $ECHO "*** Warning: Linking the shared library $output against the non-libtool"\r
6131           $ECHO "*** objects $objs is not portable!"\r
6132           libobjs="$libobjs $objs"\r
6133         fi\r
6134       fi\r
6135 \r
6136       test "$dlself" != no && \\r
6137         func_warning "\`-dlopen self' is ignored for libtool libraries"\r
6138 \r
6139       set dummy $rpath\r
6140       shift\r
6141       test "$#" -gt 1 && \\r
6142         func_warning "ignoring multiple \`-rpath's for a libtool library"\r
6143 \r
6144       install_libdir="$1"\r
6145 \r
6146       oldlibs=\r
6147       if test -z "$rpath"; then\r
6148         if test "$build_libtool_libs" = yes; then\r
6149           # Building a libtool convenience library.\r
6150           # Some compilers have problems with a `.al' extension so\r
6151           # convenience libraries should have the same extension an\r
6152           # archive normally would.\r
6153           oldlibs="$output_objdir/$libname.$libext $oldlibs"\r
6154           build_libtool_libs=convenience\r
6155           build_old_libs=yes\r
6156         fi\r
6157 \r
6158         test -n "$vinfo" && \\r
6159           func_warning "\`-version-info/-version-number' is ignored for convenience libraries"\r
6160 \r
6161         test -n "$release" && \\r
6162           func_warning "\`-release' is ignored for convenience libraries"\r
6163       else\r
6164 \r
6165         # Parse the version information argument.\r
6166         save_ifs="$IFS"; IFS=':'\r
6167         set dummy $vinfo 0 0 0\r
6168         shift\r
6169         IFS="$save_ifs"\r
6170 \r
6171         test -n "$7" && \\r
6172           func_fatal_help "too many parameters to \`-version-info'"\r
6173 \r
6174         # convert absolute version numbers to libtool ages\r
6175         # this retains compatibility with .la files and attempts\r
6176         # to make the code below a bit more comprehensible\r
6177 \r
6178         case $vinfo_number in\r
6179         yes)\r
6180           number_major="$1"\r
6181           number_minor="$2"\r
6182           number_revision="$3"\r
6183           #\r
6184           # There are really only two kinds -- those that\r
6185           # use the current revision as the major version\r
6186           # and those that subtract age and use age as\r
6187           # a minor version.  But, then there is irix\r
6188           # which has an extra 1 added just for fun\r
6189           #\r
6190           case $version_type in\r
6191           darwin|linux|osf|windows|none)\r
6192             func_arith $number_major + $number_minor\r
6193             current=$func_arith_result\r
6194             age="$number_minor"\r
6195             revision="$number_revision"\r
6196             ;;\r
6197           freebsd-aout|freebsd-elf|sunos)\r
6198             current="$number_major"\r
6199             revision="$number_minor"\r
6200             age="0"\r
6201             ;;\r
6202           irix|nonstopux)\r
6203             func_arith $number_major + $number_minor\r
6204             current=$func_arith_result\r
6205             age="$number_minor"\r
6206             revision="$number_minor"\r
6207             lt_irix_increment=no\r
6208             ;;\r
6209           esac\r
6210           ;;\r
6211         no)\r
6212           current="$1"\r
6213           revision="$2"\r
6214           age="$3"\r
6215           ;;\r
6216         esac\r
6217 \r
6218         # Check that each of the things are valid numbers.\r
6219         case $current in\r
6220         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]) ;;\r
6221         *)\r
6222           func_error "CURRENT \`$current' must be a nonnegative integer"\r
6223           func_fatal_error "\`$vinfo' is not valid version information"\r
6224           ;;\r
6225         esac\r
6226 \r
6227         case $revision in\r
6228         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]) ;;\r
6229         *)\r
6230           func_error "REVISION \`$revision' must be a nonnegative integer"\r
6231           func_fatal_error "\`$vinfo' is not valid version information"\r
6232           ;;\r
6233         esac\r
6234 \r
6235         case $age in\r
6236         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]) ;;\r
6237         *)\r
6238           func_error "AGE \`$age' must be a nonnegative integer"\r
6239           func_fatal_error "\`$vinfo' is not valid version information"\r
6240           ;;\r
6241         esac\r
6242 \r
6243         if test "$age" -gt "$current"; then\r
6244           func_error "AGE \`$age' is greater than the current interface number \`$current'"\r
6245           func_fatal_error "\`$vinfo' is not valid version information"\r
6246         fi\r
6247 \r
6248         # Calculate the version variables.\r
6249         major=\r
6250         versuffix=\r
6251         verstring=\r
6252         case $version_type in\r
6253         none) ;;\r
6254 \r
6255         darwin)\r
6256           # Like Linux, but with the current version available in\r
6257           # verstring for coding it into the library header\r
6258           func_arith $current - $age\r
6259           major=.$func_arith_result\r
6260           versuffix="$major.$age.$revision"\r
6261           # Darwin ld doesn't like 0 for these options...\r
6262           func_arith $current + 1\r
6263           minor_current=$func_arith_result\r
6264           xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"\r
6265           verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"\r
6266           ;;\r
6267 \r
6268         freebsd-aout)\r
6269           major=".$current"\r
6270           versuffix=".$current.$revision";\r
6271           ;;\r
6272 \r
6273         freebsd-elf)\r
6274           major=".$current"\r
6275           versuffix=".$current"\r
6276           ;;\r
6277 \r
6278         irix | nonstopux)\r
6279           if test "X$lt_irix_increment" = "Xno"; then\r
6280             func_arith $current - $age\r
6281           else\r
6282             func_arith $current - $age + 1\r
6283           fi\r
6284           major=$func_arith_result\r
6285 \r
6286           case $version_type in\r
6287             nonstopux) verstring_prefix=nonstopux ;;\r
6288             *)         verstring_prefix=sgi ;;\r
6289           esac\r
6290           verstring="$verstring_prefix$major.$revision"\r
6291 \r
6292           # Add in all the interfaces that we are compatible with.\r
6293           loop=$revision\r
6294           while test "$loop" -ne 0; do\r
6295             func_arith $revision - $loop\r
6296             iface=$func_arith_result\r
6297             func_arith $loop - 1\r
6298             loop=$func_arith_result\r
6299             verstring="$verstring_prefix$major.$iface:$verstring"\r
6300           done\r
6301 \r
6302           # Before this point, $major must not contain `.'.\r
6303           major=.$major\r
6304           versuffix="$major.$revision"\r
6305           ;;\r
6306 \r
6307         linux)\r
6308           func_arith $current - $age\r
6309           major=.$func_arith_result\r
6310           versuffix="$major.$age.$revision"\r
6311           ;;\r
6312 \r
6313         osf)\r
6314           func_arith $current - $age\r
6315           major=.$func_arith_result\r
6316           versuffix=".$current.$age.$revision"\r
6317           verstring="$current.$age.$revision"\r
6318 \r
6319           # Add in all the interfaces that we are compatible with.\r
6320           loop=$age\r
6321           while test "$loop" -ne 0; do\r
6322             func_arith $current - $loop\r
6323             iface=$func_arith_result\r
6324             func_arith $loop - 1\r
6325             loop=$func_arith_result\r
6326             verstring="$verstring:${iface}.0"\r
6327           done\r
6328 \r
6329           # Make executables depend on our current version.\r
6330           verstring="$verstring:${current}.0"\r
6331           ;;\r
6332 \r
6333         qnx)\r
6334           major=".$current"\r
6335           versuffix=".$current"\r
6336           ;;\r
6337 \r
6338         sunos)\r
6339           major=".$current"\r
6340           versuffix=".$current.$revision"\r
6341           ;;\r
6342 \r
6343         windows)\r
6344           # Use '-' rather than '.', since we only want one\r
6345           # extension on DOS 8.3 filesystems.\r
6346           func_arith $current - $age\r
6347           major=$func_arith_result\r
6348           versuffix="-$major"\r
6349           ;;\r
6350 \r
6351         *)\r
6352           func_fatal_configuration "unknown library version type \`$version_type'"\r
6353           ;;\r
6354         esac\r
6355 \r
6356         # Clear the version info if we defaulted, and they specified a release.\r
6357         if test -z "$vinfo" && test -n "$release"; then\r
6358           major=\r
6359           case $version_type in\r
6360           darwin)\r
6361             # we can't check for "0.0" in archive_cmds due to quoting\r
6362             # problems, so we reset it completely\r
6363             verstring=\r
6364             ;;\r
6365           *)\r
6366             verstring="0.0"\r
6367             ;;\r
6368           esac\r
6369           if test "$need_version" = no; then\r
6370             versuffix=\r
6371           else\r
6372             versuffix=".0.0"\r
6373           fi\r
6374         fi\r
6375 \r
6376         # Remove version info from name if versioning should be avoided\r
6377         if test "$avoid_version" = yes && test "$need_version" = no; then\r
6378           major=\r
6379           versuffix=\r
6380           verstring=""\r
6381         fi\r
6382 \r
6383         # Check to see if the archive will have undefined symbols.\r
6384         if test "$allow_undefined" = yes; then\r
6385           if test "$allow_undefined_flag" = unsupported; then\r
6386             func_warning "undefined symbols not allowed in $host shared libraries"\r
6387             build_libtool_libs=no\r
6388             build_old_libs=yes\r
6389           fi\r
6390         else\r
6391           # Don't allow undefined symbols.\r
6392           allow_undefined_flag="$no_undefined_flag"\r
6393         fi\r
6394 \r
6395       fi\r
6396 \r
6397       func_generate_dlsyms "$libname" "$libname" "yes"\r
6398       libobjs="$libobjs $symfileobj"\r
6399       test "X$libobjs" = "X " && libobjs=\r
6400 \r
6401       if test "$mode" != relink; then\r
6402         # Remove our outputs, but don't remove object files since they\r
6403         # may have been created when compiling PIC objects.\r
6404         removelist=\r
6405         tempremovelist=`$ECHO "$output_objdir/*"`\r
6406         for p in $tempremovelist; do\r
6407           case $p in\r
6408             *.$objext | *.gcno)\r
6409                ;;\r
6410             $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)\r
6411                if test "X$precious_files_regex" != "X"; then\r
6412                  if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1\r
6413                  then\r
6414                    continue\r
6415                  fi\r
6416                fi\r
6417                removelist="$removelist $p"\r
6418                ;;\r
6419             *) ;;\r
6420           esac\r
6421         done\r
6422         test -n "$removelist" && \\r
6423           func_show_eval "${RM}r \$removelist"\r
6424       fi\r
6425 \r
6426       # Now set the variables for building old libraries.\r
6427       if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then\r
6428         oldlibs="$oldlibs $output_objdir/$libname.$libext"\r
6429 \r
6430         # Transform .lo files to .o files.\r
6431         oldobjs="$objs "`$ECHO "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`\r
6432       fi\r
6433 \r
6434       # Eliminate all temporary directories.\r
6435       #for path in $notinst_path; do\r
6436       # lib_search_path=`$ECHO "X$lib_search_path " | $Xsed -e "s% $path % %g"`\r
6437       # deplibs=`$ECHO "X$deplibs " | $Xsed -e "s% -L$path % %g"`\r
6438       # dependency_libs=`$ECHO "X$dependency_libs " | $Xsed -e "s% -L$path % %g"`\r
6439       #done\r
6440 \r
6441       if test -n "$xrpath"; then\r
6442         # If the user specified any rpath flags, then add them.\r
6443         temp_xrpath=\r
6444         for libdir in $xrpath; do\r
6445           temp_xrpath="$temp_xrpath -R$libdir"\r
6446           case "$finalize_rpath " in\r
6447           *" $libdir "*) ;;\r
6448           *) finalize_rpath="$finalize_rpath $libdir" ;;\r
6449           esac\r
6450         done\r
6451         if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then\r
6452           dependency_libs="$temp_xrpath $dependency_libs"\r
6453         fi\r
6454       fi\r
6455 \r
6456       # Make sure dlfiles contains only unique files that won't be dlpreopened\r
6457       old_dlfiles="$dlfiles"\r
6458       dlfiles=\r
6459       for lib in $old_dlfiles; do\r
6460         case " $dlprefiles $dlfiles " in\r
6461         *" $lib "*) ;;\r
6462         *) dlfiles="$dlfiles $lib" ;;\r
6463         esac\r
6464       done\r
6465 \r
6466       # Make sure dlprefiles contains only unique files\r
6467       old_dlprefiles="$dlprefiles"\r
6468       dlprefiles=\r
6469       for lib in $old_dlprefiles; do\r
6470         case "$dlprefiles " in\r
6471         *" $lib "*) ;;\r
6472         *) dlprefiles="$dlprefiles $lib" ;;\r
6473         esac\r
6474       done\r
6475 \r
6476       if test "$build_libtool_libs" = yes; then\r
6477         if test -n "$rpath"; then\r
6478           case $host in\r
6479           *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc*)\r
6480             # these systems don't actually have a c library (as such)!\r
6481             ;;\r
6482           *-*-rhapsody* | *-*-darwin1.[012])\r
6483             # Rhapsody C library is in the System framework\r
6484             deplibs="$deplibs System.ltframework"\r
6485             ;;\r
6486           *-*-netbsd*)\r
6487             # Don't link with libc until the a.out ld.so is fixed.\r
6488             ;;\r
6489           *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)\r
6490             # Do not include libc due to us having libc/libc_r.\r
6491             ;;\r
6492           *-*-sco3.2v5* | *-*-sco5v6*)\r
6493             # Causes problems with __ctype\r
6494             ;;\r
6495           *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)\r
6496             # Compiler inserts libc in the correct place for threads to work\r
6497             ;;\r
6498           *)\r
6499             # Add libc to deplibs on all other systems if necessary.\r
6500             if test "$build_libtool_need_lc" = "yes"; then\r
6501               deplibs="$deplibs -lc"\r
6502             fi\r
6503             ;;\r
6504           esac\r
6505         fi\r
6506 \r
6507         # Transform deplibs into only deplibs that can be linked in shared.\r
6508         name_save=$name\r
6509         libname_save=$libname\r
6510         release_save=$release\r
6511         versuffix_save=$versuffix\r
6512         major_save=$major\r
6513         # I'm not sure if I'm treating the release correctly.  I think\r
6514         # release should show up in the -l (ie -lgmp5) so we don't want to\r
6515         # add it in twice.  Is that correct?\r
6516         release=""\r
6517         versuffix=""\r
6518         major=""\r
6519         newdeplibs=\r
6520         droppeddeps=no\r
6521         case $deplibs_check_method in\r
6522         pass_all)\r
6523           # Don't check for shared/static.  Everything works.\r
6524           # This might be a little naive.  We might want to check\r
6525           # whether the library exists or not.  But this is on\r
6526           # osf3 & osf4 and I'm not really sure... Just\r
6527           # implementing what was already the behavior.\r
6528           newdeplibs=$deplibs\r
6529           ;;\r
6530         test_compile)\r
6531           # This code stresses the "libraries are programs" paradigm to its\r
6532           # limits. Maybe even breaks it.  We compile a program, linking it\r
6533           # against the deplibs as a proxy for the library.  Then we can check\r
6534           # whether they linked in statically or dynamically with ldd.\r
6535           $opt_dry_run || $RM conftest.c\r
6536           cat > conftest.c <<EOF\r
6537           int main() { return 0; }\r
6538 EOF\r
6539           $opt_dry_run || $RM conftest\r
6540           if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then\r
6541             ldd_output=`ldd conftest`\r
6542             for i in $deplibs; do\r
6543               case $i in\r
6544               -l*)\r
6545                 func_stripname -l '' "$i"\r
6546                 name=$func_stripname_result\r
6547                 if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then\r
6548                   case " $predeps $postdeps " in\r
6549                   *" $i "*)\r
6550                     newdeplibs="$newdeplibs $i"\r
6551                     i=""\r
6552                     ;;\r
6553                   esac\r
6554                 fi\r
6555                 if test -n "$i" ; then\r
6556                   libname=`eval "\\$ECHO \"$libname_spec\""`\r
6557                   deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`\r
6558                   set dummy $deplib_matches; shift\r
6559                   deplib_match=$1\r
6560                   if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then\r
6561                     newdeplibs="$newdeplibs $i"\r
6562                   else\r
6563                     droppeddeps=yes\r
6564                     $ECHO\r
6565                     $ECHO "*** Warning: dynamic linker does not accept needed library $i."\r
6566                     $ECHO "*** I have the capability to make that library automatically link in when"\r
6567                     $ECHO "*** you link to this library.  But I can only do this if you have a"\r
6568                     $ECHO "*** shared version of the library, which I believe you do not have"\r
6569                     $ECHO "*** because a test_compile did reveal that the linker did not use it for"\r
6570                     $ECHO "*** its dynamic dependency list that programs get resolved with at runtime."\r
6571                   fi\r
6572                 fi\r
6573                 ;;\r
6574               *)\r
6575                 newdeplibs="$newdeplibs $i"\r
6576                 ;;\r
6577               esac\r
6578             done\r
6579           else\r
6580             # Error occurred in the first compile.  Let's try to salvage\r
6581             # the situation: Compile a separate program for each library.\r
6582             for i in $deplibs; do\r
6583               case $i in\r
6584               -l*)\r
6585                 func_stripname -l '' "$i"\r
6586                 name=$func_stripname_result\r
6587                 $opt_dry_run || $RM conftest\r
6588                 if $LTCC $LTCFLAGS -o conftest conftest.c $i; then\r
6589                   ldd_output=`ldd conftest`\r
6590                   if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then\r
6591                     case " $predeps $postdeps " in\r
6592                     *" $i "*)\r
6593                       newdeplibs="$newdeplibs $i"\r
6594                       i=""\r
6595                       ;;\r
6596                     esac\r
6597                   fi\r
6598                   if test -n "$i" ; then\r
6599                     libname=`eval "\\$ECHO \"$libname_spec\""`\r
6600                     deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`\r
6601                     set dummy $deplib_matches; shift\r
6602                     deplib_match=$1\r
6603                     if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then\r
6604                       newdeplibs="$newdeplibs $i"\r
6605                     else\r
6606                       droppeddeps=yes\r
6607                       $ECHO\r
6608                       $ECHO "*** Warning: dynamic linker does not accept needed library $i."\r
6609                       $ECHO "*** I have the capability to make that library automatically link in when"\r
6610                       $ECHO "*** you link to this library.  But I can only do this if you have a"\r
6611                       $ECHO "*** shared version of the library, which you do not appear to have"\r
6612                       $ECHO "*** because a test_compile did reveal that the linker did not use this one"\r
6613                       $ECHO "*** as a dynamic dependency that programs can get resolved with at runtime."\r
6614                     fi\r
6615                   fi\r
6616                 else\r
6617                   droppeddeps=yes\r
6618                   $ECHO\r
6619                   $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"\r
6620                   $ECHO "*** make it link in!  You will probably need to install it or some"\r
6621                   $ECHO "*** library that it depends on before this library will be fully"\r
6622                   $ECHO "*** functional.  Installing it before continuing would be even better."\r
6623                 fi\r
6624                 ;;\r
6625               *)\r
6626                 newdeplibs="$newdeplibs $i"\r
6627                 ;;\r
6628               esac\r
6629             done\r
6630           fi\r
6631           ;;\r
6632         file_magic*)\r
6633           set dummy $deplibs_check_method; shift\r
6634           file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`\r
6635           for a_deplib in $deplibs; do\r
6636             case $a_deplib in\r
6637             -l*)\r
6638               func_stripname -l '' "$a_deplib"\r
6639               name=$func_stripname_result\r
6640               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then\r
6641                 case " $predeps $postdeps " in\r
6642                 *" $a_deplib "*)\r
6643                   newdeplibs="$newdeplibs $a_deplib"\r
6644                   a_deplib=""\r
6645                   ;;\r
6646                 esac\r
6647               fi\r
6648               if test -n "$a_deplib" ; then\r
6649                 libname=`eval "\\$ECHO \"$libname_spec\""`\r
6650                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do\r
6651                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`\r
6652                   for potent_lib in $potential_libs; do\r
6653                       # Follow soft links.\r
6654                       if ls -lLd "$potent_lib" 2>/dev/null |\r
6655                          $GREP " -> " >/dev/null; then\r
6656                         continue\r
6657                       fi\r
6658                       # The statement above tries to avoid entering an\r
6659                       # endless loop below, in case of cyclic links.\r
6660                       # We might still enter an endless loop, since a link\r
6661                       # loop can be closed while we follow links,\r
6662                       # but so what?\r
6663                       potlib="$potent_lib"\r
6664                       while test -h "$potlib" 2>/dev/null; do\r
6665                         potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`\r
6666                         case $potliblink in\r
6667                         [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;\r
6668                         *) potlib=`$ECHO "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;\r
6669                         esac\r
6670                       done\r
6671                       if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |\r
6672                          $SED -e 10q |\r
6673                          $EGREP "$file_magic_regex" > /dev/null; then\r
6674                         newdeplibs="$newdeplibs $a_deplib"\r
6675                         a_deplib=""\r
6676                         break 2\r
6677                       fi\r
6678                   done\r
6679                 done\r
6680               fi\r
6681               if test -n "$a_deplib" ; then\r
6682                 droppeddeps=yes\r
6683                 $ECHO\r
6684                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."\r
6685                 $ECHO "*** I have the capability to make that library automatically link in when"\r
6686                 $ECHO "*** you link to this library.  But I can only do this if you have a"\r
6687                 $ECHO "*** shared version of the library, which you do not appear to have"\r
6688                 $ECHO "*** because I did check the linker path looking for a file starting"\r
6689                 if test -z "$potlib" ; then\r
6690                   $ECHO "*** with $libname but no candidates were found. (...for file magic test)"\r
6691                 else\r
6692                   $ECHO "*** with $libname and none of the candidates passed a file format test"\r
6693                   $ECHO "*** using a file magic. Last file checked: $potlib"\r
6694                 fi\r
6695               fi\r
6696               ;;\r
6697             *)\r
6698               # Add a -L argument.\r
6699               newdeplibs="$newdeplibs $a_deplib"\r
6700               ;;\r
6701             esac\r
6702           done # Gone through all deplibs.\r
6703           ;;\r
6704         match_pattern*)\r
6705           set dummy $deplibs_check_method; shift\r
6706           match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`\r
6707           for a_deplib in $deplibs; do\r
6708             case $a_deplib in\r
6709             -l*)\r
6710               func_stripname -l '' "$a_deplib"\r
6711               name=$func_stripname_result\r
6712               if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then\r
6713                 case " $predeps $postdeps " in\r
6714                 *" $a_deplib "*)\r
6715                   newdeplibs="$newdeplibs $a_deplib"\r
6716                   a_deplib=""\r
6717                   ;;\r
6718                 esac\r
6719               fi\r
6720               if test -n "$a_deplib" ; then\r
6721                 libname=`eval "\\$ECHO \"$libname_spec\""`\r
6722                 for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do\r
6723                   potential_libs=`ls $i/$libname[.-]* 2>/dev/null`\r
6724                   for potent_lib in $potential_libs; do\r
6725                     potlib="$potent_lib" # see symlink-check above in file_magic test\r
6726                     if eval "\$ECHO \"X$potent_lib\"" 2>/dev/null | $Xsed -e 10q | \\r
6727                        $EGREP "$match_pattern_regex" > /dev/null; then\r
6728                       newdeplibs="$newdeplibs $a_deplib"\r
6729                       a_deplib=""\r
6730                       break 2\r
6731                     fi\r
6732                   done\r
6733                 done\r
6734               fi\r
6735               if test -n "$a_deplib" ; then\r
6736                 droppeddeps=yes\r
6737                 $ECHO\r
6738                 $ECHO "*** Warning: linker path does not have real file for library $a_deplib."\r
6739                 $ECHO "*** I have the capability to make that library automatically link in when"\r
6740                 $ECHO "*** you link to this library.  But I can only do this if you have a"\r
6741                 $ECHO "*** shared version of the library, which you do not appear to have"\r
6742                 $ECHO "*** because I did check the linker path looking for a file starting"\r
6743                 if test -z "$potlib" ; then\r
6744                   $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"\r
6745                 else\r
6746                   $ECHO "*** with $libname and none of the candidates passed a file format test"\r
6747                   $ECHO "*** using a regex pattern. Last file checked: $potlib"\r
6748                 fi\r
6749               fi\r
6750               ;;\r
6751             *)\r
6752               # Add a -L argument.\r
6753               newdeplibs="$newdeplibs $a_deplib"\r
6754               ;;\r
6755             esac\r
6756           done # Gone through all deplibs.\r
6757           ;;\r
6758         none | unknown | *)\r
6759           newdeplibs=""\r
6760           tmp_deplibs=`$ECHO "X $deplibs" | $Xsed \\r
6761               -e 's/ -lc$//' -e 's/ -[LR][^ ]*//g'`\r
6762           if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then\r
6763             for i in $predeps $postdeps ; do\r
6764               # can't use Xsed below, because $i might contain '/'\r
6765               tmp_deplibs=`$ECHO "X $tmp_deplibs" | $Xsed -e "s,$i,,"`\r
6766             done\r
6767           fi\r
6768           if $ECHO "X $tmp_deplibs" | $Xsed -e 's/[      ]//g' |\r
6769              $GREP . >/dev/null; then\r
6770             $ECHO\r
6771             if test "X$deplibs_check_method" = "Xnone"; then\r
6772               $ECHO "*** Warning: inter-library dependencies are not supported in this platform."\r
6773             else\r
6774               $ECHO "*** Warning: inter-library dependencies are not known to be supported."\r
6775             fi\r
6776             $ECHO "*** All declared inter-library dependencies are being dropped."\r
6777             droppeddeps=yes\r
6778           fi\r
6779           ;;\r
6780         esac\r
6781         versuffix=$versuffix_save\r
6782         major=$major_save\r
6783         release=$release_save\r
6784         libname=$libname_save\r
6785         name=$name_save\r
6786 \r
6787         case $host in\r
6788         *-*-rhapsody* | *-*-darwin1.[012])\r
6789           # On Rhapsody replace the C library with the System framework\r
6790           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's/ -lc / System.ltframework /'`\r
6791           ;;\r
6792         esac\r
6793 \r
6794         if test "$droppeddeps" = yes; then\r
6795           if test "$module" = yes; then\r
6796             $ECHO\r
6797             $ECHO "*** Warning: libtool could not satisfy all declared inter-library"\r
6798             $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"\r
6799             $ECHO "*** a static module, that should work as long as the dlopening"\r
6800             $ECHO "*** application is linked with the -dlopen flag."\r
6801             if test -z "$global_symbol_pipe"; then\r
6802               $ECHO\r
6803               $ECHO "*** However, this would only work if libtool was able to extract symbol"\r
6804               $ECHO "*** lists from a program, using \`nm' or equivalent, but libtool could"\r
6805               $ECHO "*** not find such a program.  So, this module is probably useless."\r
6806               $ECHO "*** \`nm' from GNU binutils and a full rebuild may help."\r
6807             fi\r
6808             if test "$build_old_libs" = no; then\r
6809               oldlibs="$output_objdir/$libname.$libext"\r
6810               build_libtool_libs=module\r
6811               build_old_libs=yes\r
6812             else\r
6813               build_libtool_libs=no\r
6814             fi\r
6815           else\r
6816             $ECHO "*** The inter-library dependencies that have been dropped here will be"\r
6817             $ECHO "*** automatically added whenever a program is linked with this library"\r
6818             $ECHO "*** or is declared to -dlopen it."\r
6819 \r
6820             if test "$allow_undefined" = no; then\r
6821               $ECHO\r
6822               $ECHO "*** Since this library must not contain undefined symbols,"\r
6823               $ECHO "*** because either the platform does not support them or"\r
6824               $ECHO "*** it was explicitly requested with -no-undefined,"\r
6825               $ECHO "*** libtool will only create a static version of it."\r
6826               if test "$build_old_libs" = no; then\r
6827                 oldlibs="$output_objdir/$libname.$libext"\r
6828                 build_libtool_libs=module\r
6829                 build_old_libs=yes\r
6830               else\r
6831                 build_libtool_libs=no\r
6832               fi\r
6833             fi\r
6834           fi\r
6835         fi\r
6836         # Done checking deplibs!\r
6837         deplibs=$newdeplibs\r
6838       fi\r
6839       # Time to change all our "foo.ltframework" stuff back to "-framework foo"\r
6840       case $host in\r
6841         *-*-darwin*)\r
6842           newdeplibs=`$ECHO "X $newdeplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`\r
6843           new_inherited_linker_flags=`$ECHO "X $new_inherited_linker_flags" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`\r
6844           deplibs=`$ECHO "X $deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`\r
6845           ;;\r
6846       esac\r
6847 \r
6848       # move library search paths that coincide with paths to not yet\r
6849       # installed libraries to the beginning of the library search list\r
6850       new_libs=\r
6851       for path in $notinst_path; do\r
6852         case " $new_libs " in\r
6853         *" -L$path/$objdir "*) ;;\r
6854         *)\r
6855           case " $deplibs " in\r
6856           *" -L$path/$objdir "*)\r
6857             new_libs="$new_libs -L$path/$objdir" ;;\r
6858           esac\r
6859           ;;\r
6860         esac\r
6861       done\r
6862       for deplib in $deplibs; do\r
6863         case $deplib in\r
6864         -L*)\r
6865           case " $new_libs " in\r
6866           *" $deplib "*) ;;\r
6867           *) new_libs="$new_libs $deplib" ;;\r
6868           esac\r
6869           ;;\r
6870         *) new_libs="$new_libs $deplib" ;;\r
6871         esac\r
6872       done\r
6873       deplibs="$new_libs"\r
6874 \r
6875       # All the library-specific variables (install_libdir is set above).\r
6876       library_names=\r
6877       old_library=\r
6878       dlname=\r
6879 \r
6880       # Test again, we may have decided not to build it any more\r
6881       if test "$build_libtool_libs" = yes; then\r
6882         if test "$hardcode_into_libs" = yes; then\r
6883           # Hardcode the library paths\r
6884           hardcode_libdirs=\r
6885           dep_rpath=\r
6886           rpath="$finalize_rpath"\r
6887           test "$mode" != relink && rpath="$compile_rpath$rpath"\r
6888           for libdir in $rpath; do\r
6889             if test -n "$hardcode_libdir_flag_spec"; then\r
6890               if test -n "$hardcode_libdir_separator"; then\r
6891                 if test -z "$hardcode_libdirs"; then\r
6892                   hardcode_libdirs="$libdir"\r
6893                 else\r
6894                   # Just accumulate the unique libdirs.\r
6895                   case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in\r
6896                   *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)\r
6897                     ;;\r
6898                   *)\r
6899                     hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"\r
6900                     ;;\r
6901                   esac\r
6902                 fi\r
6903               else\r
6904                 eval flag=\"$hardcode_libdir_flag_spec\"\r
6905                 dep_rpath="$dep_rpath $flag"\r
6906               fi\r
6907             elif test -n "$runpath_var"; then\r
6908               case "$perm_rpath " in\r
6909               *" $libdir "*) ;;\r
6910               *) perm_rpath="$perm_rpath $libdir" ;;\r
6911               esac\r
6912             fi\r
6913           done\r
6914           # Substitute the hardcoded libdirs into the rpath.\r
6915           if test -n "$hardcode_libdir_separator" &&\r
6916              test -n "$hardcode_libdirs"; then\r
6917             libdir="$hardcode_libdirs"\r
6918             if test -n "$hardcode_libdir_flag_spec_ld"; then\r
6919               eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"\r
6920             else\r
6921               eval dep_rpath=\"$hardcode_libdir_flag_spec\"\r
6922             fi\r
6923           fi\r
6924           if test -n "$runpath_var" && test -n "$perm_rpath"; then\r
6925             # We should set the runpath_var.\r
6926             rpath=\r
6927             for dir in $perm_rpath; do\r
6928               rpath="$rpath$dir:"\r
6929             done\r
6930             eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"\r
6931           fi\r
6932           test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"\r
6933         fi\r
6934 \r
6935         shlibpath="$finalize_shlibpath"\r
6936         test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"\r
6937         if test -n "$shlibpath"; then\r
6938           eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"\r
6939         fi\r
6940 \r
6941         # Get the real and link names of the library.\r
6942         eval shared_ext=\"$shrext_cmds\"\r
6943         eval library_names=\"$library_names_spec\"\r
6944         set dummy $library_names\r
6945         shift\r
6946         realname="$1"\r
6947         shift\r
6948 \r
6949         if test -n "$soname_spec"; then\r
6950           eval soname=\"$soname_spec\"\r
6951         else\r
6952           soname="$realname"\r
6953         fi\r
6954         if test -z "$dlname"; then\r
6955           dlname=$soname\r
6956         fi\r
6957 \r
6958         lib="$output_objdir/$realname"\r
6959         linknames=\r
6960         for link\r
6961         do\r
6962           linknames="$linknames $link"\r
6963         done\r
6964 \r
6965         # Use standard objects if they are pic\r
6966         test -z "$pic_flag" && libobjs=`$ECHO "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`\r
6967         test "X$libobjs" = "X " && libobjs=\r
6968 \r
6969         delfiles=\r
6970         if test -n "$export_symbols" && test -n "$include_expsyms"; then\r
6971           $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"\r
6972           export_symbols="$output_objdir/$libname.uexp"\r
6973           delfiles="$delfiles $export_symbols"\r
6974         fi\r
6975 \r
6976         orig_export_symbols=\r
6977         case $host_os in\r
6978         cygwin* | mingw* | cegcc*)\r
6979           if test -n "$export_symbols" && test -z "$export_symbols_regex"; then\r
6980             # exporting using user supplied symfile\r
6981             if test "x`$SED 1q $export_symbols`" != xEXPORTS; then\r
6982               # and it's NOT already a .def file. Must figure out\r
6983               # which of the given symbols are data symbols and tag\r
6984               # them as such. So, trigger use of export_symbols_cmds.\r
6985               # export_symbols gets reassigned inside the "prepare\r
6986               # the list of exported symbols" if statement, so the\r
6987               # include_expsyms logic still works.\r
6988               orig_export_symbols="$export_symbols"\r
6989               export_symbols=\r
6990               always_export_symbols=yes\r
6991             fi\r
6992           fi\r
6993           ;;\r
6994         esac\r
6995 \r
6996         # Prepare the list of exported symbols\r
6997         if test -z "$export_symbols"; then\r
6998           if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then\r
6999             func_verbose "generating symbol list for \`$libname.la'"\r
7000             export_symbols="$output_objdir/$libname.exp"\r
7001             $opt_dry_run || $RM $export_symbols\r
7002             cmds=$export_symbols_cmds\r
7003             save_ifs="$IFS"; IFS='~'\r
7004             for cmd in $cmds; do\r
7005               IFS="$save_ifs"\r
7006               eval cmd=\"$cmd\"\r
7007               func_len " $cmd"\r
7008               len=$func_len_result\r
7009               if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then\r
7010                 func_show_eval "$cmd" 'exit $?'\r
7011                 skipped_export=false\r
7012               else\r
7013                 # The command line is too long to execute in one step.\r
7014                 func_verbose "using reloadable object file for export list..."\r
7015                 skipped_export=:\r
7016                 # Break out early, otherwise skipped_export may be\r
7017                 # set to false by a later but shorter cmd.\r
7018                 break\r
7019               fi\r
7020             done\r
7021             IFS="$save_ifs"\r
7022             if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then\r
7023               func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'\r
7024               func_show_eval '$MV "${export_symbols}T" "$export_symbols"'\r
7025             fi\r
7026           fi\r
7027         fi\r
7028 \r
7029         if test -n "$export_symbols" && test -n "$include_expsyms"; then\r
7030           tmp_export_symbols="$export_symbols"\r
7031           test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"\r
7032           $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'\r
7033         fi\r
7034 \r
7035         if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then\r
7036           # The given exports_symbols file has to be filtered, so filter it.\r
7037           func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"\r
7038           # FIXME: $output_objdir/$libname.filter potentially contains lots of\r
7039           # 's' commands which not all seds can handle. GNU sed should be fine\r
7040           # though. Also, the filter scales superlinearly with the number of\r
7041           # global variables. join(1) would be nice here, but unfortunately\r
7042           # isn't a blessed tool.\r
7043           $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter\r
7044           delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"\r
7045           export_symbols=$output_objdir/$libname.def\r
7046           $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols\r
7047         fi\r
7048 \r
7049         tmp_deplibs=\r
7050         for test_deplib in $deplibs; do\r
7051           case " $convenience " in\r
7052           *" $test_deplib "*) ;;\r
7053           *)\r
7054             tmp_deplibs="$tmp_deplibs $test_deplib"\r
7055             ;;\r
7056           esac\r
7057         done\r
7058         deplibs="$tmp_deplibs"\r
7059 \r
7060         if test -n "$convenience"; then\r
7061           if test -n "$whole_archive_flag_spec" &&\r
7062             test "$compiler_needs_object" = yes &&\r
7063             test -z "$libobjs"; then\r
7064             # extract the archives, so we have objects to list.\r
7065             # TODO: could optimize this to just extract one archive.\r
7066             whole_archive_flag_spec=\r
7067           fi\r
7068           if test -n "$whole_archive_flag_spec"; then\r
7069             save_libobjs=$libobjs\r
7070             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"\r
7071             test "X$libobjs" = "X " && libobjs=\r
7072           else\r
7073             gentop="$output_objdir/${outputname}x"\r
7074             generated="$generated $gentop"\r
7075 \r
7076             func_extract_archives $gentop $convenience\r
7077             libobjs="$libobjs $func_extract_archives_result"\r
7078             test "X$libobjs" = "X " && libobjs=\r
7079           fi\r
7080         fi\r
7081 \r
7082         if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then\r
7083           eval flag=\"$thread_safe_flag_spec\"\r
7084           linker_flags="$linker_flags $flag"\r
7085         fi\r
7086 \r
7087         # Make a backup of the uninstalled library when relinking\r
7088         if test "$mode" = relink; then\r
7089           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?\r
7090         fi\r
7091 \r
7092         # Do each of the archive commands.\r
7093         if test "$module" = yes && test -n "$module_cmds" ; then\r
7094           if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then\r
7095             eval test_cmds=\"$module_expsym_cmds\"\r
7096             cmds=$module_expsym_cmds\r
7097           else\r
7098             eval test_cmds=\"$module_cmds\"\r
7099             cmds=$module_cmds\r
7100           fi\r
7101         else\r
7102           if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then\r
7103             eval test_cmds=\"$archive_expsym_cmds\"\r
7104             cmds=$archive_expsym_cmds\r
7105           else\r
7106             eval test_cmds=\"$archive_cmds\"\r
7107             cmds=$archive_cmds\r
7108           fi\r
7109         fi\r
7110 \r
7111         if test "X$skipped_export" != "X:" &&\r
7112            func_len " $test_cmds" &&\r
7113            len=$func_len_result &&\r
7114            test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then\r
7115           :\r
7116         else\r
7117           # The command line is too long to link in one step, link piecewise\r
7118           # or, if using GNU ld and skipped_export is not :, use a linker\r
7119           # script.\r
7120 \r
7121           # Save the value of $output and $libobjs because we want to\r
7122           # use them later.  If we have whole_archive_flag_spec, we\r
7123           # want to use save_libobjs as it was before\r
7124           # whole_archive_flag_spec was expanded, because we can't\r
7125           # assume the linker understands whole_archive_flag_spec.\r
7126           # This may have to be revisited, in case too many\r
7127           # convenience libraries get linked in and end up exceeding\r
7128           # the spec.\r
7129           if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then\r
7130             save_libobjs=$libobjs\r
7131           fi\r
7132           save_output=$output\r
7133           output_la=`$ECHO "X$output" | $Xsed -e "$basename"`\r
7134 \r
7135           # Clear the reloadable object creation command queue and\r
7136           # initialize k to one.\r
7137           test_cmds=\r
7138           concat_cmds=\r
7139           objlist=\r
7140           last_robj=\r
7141           k=1\r
7142 \r
7143           if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then\r
7144             output=${output_objdir}/${output_la}.lnkscript\r
7145             func_verbose "creating GNU ld script: $output"\r
7146             $ECHO 'INPUT (' > $output\r
7147             for obj in $save_libobjs\r
7148             do\r
7149               $ECHO "$obj" >> $output\r
7150             done\r
7151             $ECHO ')' >> $output\r
7152             delfiles="$delfiles $output"\r
7153           elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then\r
7154             output=${output_objdir}/${output_la}.lnk\r
7155             func_verbose "creating linker input file list: $output"\r
7156             : > $output\r
7157             set x $save_libobjs\r
7158             shift\r
7159             firstobj=\r
7160             if test "$compiler_needs_object" = yes; then\r
7161               firstobj="$1 "\r
7162               shift\r
7163             fi\r
7164             for obj\r
7165             do\r
7166               $ECHO "$obj" >> $output\r
7167             done\r
7168             delfiles="$delfiles $output"\r
7169             output=$firstobj\"$file_list_spec$output\"\r
7170           else\r
7171             if test -n "$save_libobjs"; then\r
7172               func_verbose "creating reloadable object files..."\r
7173               output=$output_objdir/$output_la-${k}.$objext\r
7174               eval test_cmds=\"$reload_cmds\"\r
7175               func_len " $test_cmds"\r
7176               len0=$func_len_result\r
7177               len=$len0\r
7178 \r
7179               # Loop over the list of objects to be linked.\r
7180               for obj in $save_libobjs\r
7181               do\r
7182                 func_len " $obj"\r
7183                 func_arith $len + $func_len_result\r
7184                 len=$func_arith_result\r
7185                 if test "X$objlist" = X ||\r
7186                    test "$len" -lt "$max_cmd_len"; then\r
7187                   func_append objlist " $obj"\r
7188                 else\r
7189                   # The command $test_cmds is almost too long, add a\r
7190                   # command to the queue.\r
7191                   if test "$k" -eq 1 ; then\r
7192                     # The first file doesn't have a previous command to add.\r
7193                     eval concat_cmds=\"$reload_cmds $objlist $last_robj\"\r
7194                   else\r
7195                     # All subsequent reloadable object files will link in\r
7196                     # the last one created.\r
7197                     eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj~\$RM $last_robj\"\r
7198                   fi\r
7199                   last_robj=$output_objdir/$output_la-${k}.$objext\r
7200                   func_arith $k + 1\r
7201                   k=$func_arith_result\r
7202                   output=$output_objdir/$output_la-${k}.$objext\r
7203                   objlist=$obj\r
7204                   func_len " $last_robj"\r
7205                   func_arith $len0 + $func_len_result\r
7206                   len=$func_arith_result\r
7207                 fi\r
7208               done\r
7209               # Handle the remaining objects by creating one last\r
7210               # reloadable object file.  All subsequent reloadable object\r
7211               # files will link in the last one created.\r
7212               test -z "$concat_cmds" || concat_cmds=$concat_cmds~\r
7213               eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"\r
7214               if test -n "$last_robj"; then\r
7215                 eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"\r
7216               fi\r
7217               delfiles="$delfiles $output"\r
7218 \r
7219             else\r
7220               output=\r
7221             fi\r
7222 \r
7223             if ${skipped_export-false}; then\r
7224               func_verbose "generating symbol list for \`$libname.la'"\r
7225               export_symbols="$output_objdir/$libname.exp"\r
7226               $opt_dry_run || $RM $export_symbols\r
7227               libobjs=$output\r
7228               # Append the command to create the export file.\r
7229               test -z "$concat_cmds" || concat_cmds=$concat_cmds~\r
7230               eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"\r
7231               if test -n "$last_robj"; then\r
7232                 eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"\r
7233               fi\r
7234             fi\r
7235 \r
7236             test -n "$save_libobjs" &&\r
7237               func_verbose "creating a temporary reloadable object file: $output"\r
7238 \r
7239             # Loop through the commands generated above and execute them.\r
7240             save_ifs="$IFS"; IFS='~'\r
7241             for cmd in $concat_cmds; do\r
7242               IFS="$save_ifs"\r
7243               $opt_silent || {\r
7244                   func_quote_for_expand "$cmd"\r
7245                   eval "func_echo $func_quote_for_expand_result"\r
7246               }\r
7247               $opt_dry_run || eval "$cmd" || {\r
7248                 lt_exit=$?\r
7249 \r
7250                 # Restore the uninstalled library and exit\r
7251                 if test "$mode" = relink; then\r
7252                   ( cd "$output_objdir" && \\r
7253                     $RM "${realname}T" && \\r
7254                     $MV "${realname}U" "$realname" )\r
7255                 fi\r
7256 \r
7257                 exit $lt_exit\r
7258               }\r
7259             done\r
7260             IFS="$save_ifs"\r
7261 \r
7262             if test -n "$export_symbols_regex" && ${skipped_export-false}; then\r
7263               func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'\r
7264               func_show_eval '$MV "${export_symbols}T" "$export_symbols"'\r
7265             fi\r
7266           fi\r
7267 \r
7268           if ${skipped_export-false}; then\r
7269             if test -n "$export_symbols" && test -n "$include_expsyms"; then\r
7270               tmp_export_symbols="$export_symbols"\r
7271               test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"\r
7272               $opt_dry_run || eval '$ECHO "X$include_expsyms" | $Xsed | $SP2NL >> "$tmp_export_symbols"'\r
7273             fi\r
7274 \r
7275             if test -n "$orig_export_symbols"; then\r
7276               # The given exports_symbols file has to be filtered, so filter it.\r
7277               func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"\r
7278               # FIXME: $output_objdir/$libname.filter potentially contains lots of\r
7279               # 's' commands which not all seds can handle. GNU sed should be fine\r
7280               # though. Also, the filter scales superlinearly with the number of\r
7281               # global variables. join(1) would be nice here, but unfortunately\r
7282               # isn't a blessed tool.\r
7283               $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter\r
7284               delfiles="$delfiles $export_symbols $output_objdir/$libname.filter"\r
7285               export_symbols=$output_objdir/$libname.def\r
7286               $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols\r
7287             fi\r
7288           fi\r
7289 \r
7290           libobjs=$output\r
7291           # Restore the value of output.\r
7292           output=$save_output\r
7293 \r
7294           if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then\r
7295             eval libobjs=\"\$libobjs $whole_archive_flag_spec\"\r
7296             test "X$libobjs" = "X " && libobjs=\r
7297           fi\r
7298           # Expand the library linking commands again to reset the\r
7299           # value of $libobjs for piecewise linking.\r
7300 \r
7301           # Do each of the archive commands.\r
7302           if test "$module" = yes && test -n "$module_cmds" ; then\r
7303             if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then\r
7304               cmds=$module_expsym_cmds\r
7305             else\r
7306               cmds=$module_cmds\r
7307             fi\r
7308           else\r
7309             if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then\r
7310               cmds=$archive_expsym_cmds\r
7311             else\r
7312               cmds=$archive_cmds\r
7313             fi\r
7314           fi\r
7315         fi\r
7316 \r
7317         if test -n "$delfiles"; then\r
7318           # Append the command to remove temporary files to $cmds.\r
7319           eval cmds=\"\$cmds~\$RM $delfiles\"\r
7320         fi\r
7321 \r
7322         # Add any objects from preloaded convenience libraries\r
7323         if test -n "$dlprefiles"; then\r
7324           gentop="$output_objdir/${outputname}x"\r
7325           generated="$generated $gentop"\r
7326 \r
7327           func_extract_archives $gentop $dlprefiles\r
7328           libobjs="$libobjs $func_extract_archives_result"\r
7329           test "X$libobjs" = "X " && libobjs=\r
7330         fi\r
7331 \r
7332         save_ifs="$IFS"; IFS='~'\r
7333         for cmd in $cmds; do\r
7334           IFS="$save_ifs"\r
7335           eval cmd=\"$cmd\"\r
7336           $opt_silent || {\r
7337             func_quote_for_expand "$cmd"\r
7338             eval "func_echo $func_quote_for_expand_result"\r
7339           }\r
7340           $opt_dry_run || eval "$cmd" || {\r
7341             lt_exit=$?\r
7342 \r
7343             # Restore the uninstalled library and exit\r
7344             if test "$mode" = relink; then\r
7345               ( cd "$output_objdir" && \\r
7346                 $RM "${realname}T" && \\r
7347                 $MV "${realname}U" "$realname" )\r
7348             fi\r
7349 \r
7350             exit $lt_exit\r
7351           }\r
7352         done\r
7353         IFS="$save_ifs"\r
7354 \r
7355         # Restore the uninstalled library and exit\r
7356         if test "$mode" = relink; then\r
7357           $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?\r
7358 \r
7359           if test -n "$convenience"; then\r
7360             if test -z "$whole_archive_flag_spec"; then\r
7361               func_show_eval '${RM}r "$gentop"'\r
7362             fi\r
7363           fi\r
7364 \r
7365           exit $EXIT_SUCCESS\r
7366         fi\r
7367 \r
7368         # Create links to the real library.\r
7369         for linkname in $linknames; do\r
7370           if test "$realname" != "$linkname"; then\r
7371             func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'\r
7372           fi\r
7373         done\r
7374 \r
7375         # If -module or -export-dynamic was specified, set the dlname.\r
7376         if test "$module" = yes || test "$export_dynamic" = yes; then\r
7377           # On all known operating systems, these are identical.\r
7378           dlname="$soname"\r
7379         fi\r
7380       fi\r
7381       ;;\r
7382 \r
7383     obj)\r
7384       if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then\r
7385         func_warning "\`-dlopen' is ignored for objects"\r
7386       fi\r
7387 \r
7388       case " $deplibs" in\r
7389       *\ -l* | *\ -L*)\r
7390         func_warning "\`-l' and \`-L' are ignored for objects" ;;\r
7391       esac\r
7392 \r
7393       test -n "$rpath" && \\r
7394         func_warning "\`-rpath' is ignored for objects"\r
7395 \r
7396       test -n "$xrpath" && \\r
7397         func_warning "\`-R' is ignored for objects"\r
7398 \r
7399       test -n "$vinfo" && \\r
7400         func_warning "\`-version-info' is ignored for objects"\r
7401 \r
7402       test -n "$release" && \\r
7403         func_warning "\`-release' is ignored for objects"\r
7404 \r
7405       case $output in\r
7406       *.lo)\r
7407         test -n "$objs$old_deplibs" && \\r
7408           func_fatal_error "cannot build library object \`$output' from non-libtool objects"\r
7409 \r
7410         libobj=$output\r
7411         func_lo2o "$libobj"\r
7412         obj=$func_lo2o_result\r
7413         ;;\r
7414       *)\r
7415         libobj=\r
7416         obj="$output"\r
7417         ;;\r
7418       esac\r
7419 \r
7420       # Delete the old objects.\r
7421       $opt_dry_run || $RM $obj $libobj\r
7422 \r
7423       # Objects from convenience libraries.  This assumes\r
7424       # single-version convenience libraries.  Whenever we create\r
7425       # different ones for PIC/non-PIC, this we'll have to duplicate\r
7426       # the extraction.\r
7427       reload_conv_objs=\r
7428       gentop=\r
7429       # reload_cmds runs $LD directly, so let us get rid of\r
7430       # -Wl from whole_archive_flag_spec and hope we can get by with\r
7431       # turning comma into space..\r
7432       wl=\r
7433 \r
7434       if test -n "$convenience"; then\r
7435         if test -n "$whole_archive_flag_spec"; then\r
7436           eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"\r
7437           reload_conv_objs=$reload_objs\ `$ECHO "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`\r
7438         else\r
7439           gentop="$output_objdir/${obj}x"\r
7440           generated="$generated $gentop"\r
7441 \r
7442           func_extract_archives $gentop $convenience\r
7443           reload_conv_objs="$reload_objs $func_extract_archives_result"\r
7444         fi\r
7445       fi\r
7446 \r
7447       # Create the old-style object.\r
7448       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\r
7449 \r
7450       output="$obj"\r
7451       func_execute_cmds "$reload_cmds" 'exit $?'\r
7452 \r
7453       # Exit if we aren't doing a library object file.\r
7454       if test -z "$libobj"; then\r
7455         if test -n "$gentop"; then\r
7456           func_show_eval '${RM}r "$gentop"'\r
7457         fi\r
7458 \r
7459         exit $EXIT_SUCCESS\r
7460       fi\r
7461 \r
7462       if test "$build_libtool_libs" != yes; then\r
7463         if test -n "$gentop"; then\r
7464           func_show_eval '${RM}r "$gentop"'\r
7465         fi\r
7466 \r
7467         # Create an invalid libtool object if no PIC, so that we don't\r
7468         # accidentally link it into a program.\r
7469         # $show "echo timestamp > $libobj"\r
7470         # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?\r
7471         exit $EXIT_SUCCESS\r
7472       fi\r
7473 \r
7474       if test -n "$pic_flag" || test "$pic_mode" != default; then\r
7475         # Only do commands if we really have different PIC objects.\r
7476         reload_objs="$libobjs $reload_conv_objs"\r
7477         output="$libobj"\r
7478         func_execute_cmds "$reload_cmds" 'exit $?'\r
7479       fi\r
7480 \r
7481       if test -n "$gentop"; then\r
7482         func_show_eval '${RM}r "$gentop"'\r
7483       fi\r
7484 \r
7485       exit $EXIT_SUCCESS\r
7486       ;;\r
7487 \r
7488     prog)\r
7489       case $host in\r
7490         *cygwin*) func_stripname '' '.exe' "$output"\r
7491                   output=$func_stripname_result.exe;;\r
7492       esac\r
7493       test -n "$vinfo" && \\r
7494         func_warning "\`-version-info' is ignored for programs"\r
7495 \r
7496       test -n "$release" && \\r
7497         func_warning "\`-release' is ignored for programs"\r
7498 \r
7499       test "$preload" = yes \\r
7500         && test "$dlopen_support" = unknown \\r
7501         && test "$dlopen_self" = unknown \\r
7502         && test "$dlopen_self_static" = unknown && \\r
7503           func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."\r
7504 \r
7505       case $host in\r
7506       *-*-rhapsody* | *-*-darwin1.[012])\r
7507         # On Rhapsody replace the C library is the System framework\r
7508         compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`\r
7509         finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's/ -lc / System.ltframework /'`\r
7510         ;;\r
7511       esac\r
7512 \r
7513       case $host in\r
7514       *-*-darwin*)\r
7515         # Don't allow lazy linking, it breaks C++ global constructors\r
7516         # But is supposedly fixed on 10.4 or later (yay!).\r
7517         if test "$tagname" = CXX ; then\r
7518           case ${MACOSX_DEPLOYMENT_TARGET-10.0} in\r
7519             10.[0123])\r
7520               compile_command="$compile_command ${wl}-bind_at_load"\r
7521               finalize_command="$finalize_command ${wl}-bind_at_load"\r
7522             ;;\r
7523           esac\r
7524         fi\r
7525         # Time to change all our "foo.ltframework" stuff back to "-framework foo"\r
7526         compile_deplibs=`$ECHO "X $compile_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`\r
7527         finalize_deplibs=`$ECHO "X $finalize_deplibs" | $Xsed -e 's% \([^ $]*\).ltframework% -framework \1%g'`\r
7528         ;;\r
7529       esac\r
7530 \r
7531 \r
7532       # move library search paths that coincide with paths to not yet\r
7533       # installed libraries to the beginning of the library search list\r
7534       new_libs=\r
7535       for path in $notinst_path; do\r
7536         case " $new_libs " in\r
7537         *" -L$path/$objdir "*) ;;\r
7538         *)\r
7539           case " $compile_deplibs " in\r
7540           *" -L$path/$objdir "*)\r
7541             new_libs="$new_libs -L$path/$objdir" ;;\r
7542           esac\r
7543           ;;\r
7544         esac\r
7545       done\r
7546       for deplib in $compile_deplibs; do\r
7547         case $deplib in\r
7548         -L*)\r
7549           case " $new_libs " in\r
7550           *" $deplib "*) ;;\r
7551           *) new_libs="$new_libs $deplib" ;;\r
7552           esac\r
7553           ;;\r
7554         *) new_libs="$new_libs $deplib" ;;\r
7555         esac\r
7556       done\r
7557       compile_deplibs="$new_libs"\r
7558 \r
7559 \r
7560       compile_command="$compile_command $compile_deplibs"\r
7561       finalize_command="$finalize_command $finalize_deplibs"\r
7562 \r
7563       if test -n "$rpath$xrpath"; then\r
7564         # If the user specified any rpath flags, then add them.\r
7565         for libdir in $rpath $xrpath; do\r
7566           # This is the magic to use -rpath.\r
7567           case "$finalize_rpath " in\r
7568           *" $libdir "*) ;;\r
7569           *) finalize_rpath="$finalize_rpath $libdir" ;;\r
7570           esac\r
7571         done\r
7572       fi\r
7573 \r
7574       # Now hardcode the library paths\r
7575       rpath=\r
7576       hardcode_libdirs=\r
7577       for libdir in $compile_rpath $finalize_rpath; do\r
7578         if test -n "$hardcode_libdir_flag_spec"; then\r
7579           if test -n "$hardcode_libdir_separator"; then\r
7580             if test -z "$hardcode_libdirs"; then\r
7581               hardcode_libdirs="$libdir"\r
7582             else\r
7583               # Just accumulate the unique libdirs.\r
7584               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in\r
7585               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)\r
7586                 ;;\r
7587               *)\r
7588                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"\r
7589                 ;;\r
7590               esac\r
7591             fi\r
7592           else\r
7593             eval flag=\"$hardcode_libdir_flag_spec\"\r
7594             rpath="$rpath $flag"\r
7595           fi\r
7596         elif test -n "$runpath_var"; then\r
7597           case "$perm_rpath " in\r
7598           *" $libdir "*) ;;\r
7599           *) perm_rpath="$perm_rpath $libdir" ;;\r
7600           esac\r
7601         fi\r
7602         case $host in\r
7603         *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)\r
7604           testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`\r
7605           case :$dllsearchpath: in\r
7606           *":$libdir:"*) ;;\r
7607           ::) dllsearchpath=$libdir;;\r
7608           *) dllsearchpath="$dllsearchpath:$libdir";;\r
7609           esac\r
7610           case :$dllsearchpath: in\r
7611           *":$testbindir:"*) ;;\r
7612           ::) dllsearchpath=$testbindir;;\r
7613           *) dllsearchpath="$dllsearchpath:$testbindir";;\r
7614           esac\r
7615           ;;\r
7616         esac\r
7617       done\r
7618       # Substitute the hardcoded libdirs into the rpath.\r
7619       if test -n "$hardcode_libdir_separator" &&\r
7620          test -n "$hardcode_libdirs"; then\r
7621         libdir="$hardcode_libdirs"\r
7622         eval rpath=\" $hardcode_libdir_flag_spec\"\r
7623       fi\r
7624       compile_rpath="$rpath"\r
7625 \r
7626       rpath=\r
7627       hardcode_libdirs=\r
7628       for libdir in $finalize_rpath; do\r
7629         if test -n "$hardcode_libdir_flag_spec"; then\r
7630           if test -n "$hardcode_libdir_separator"; then\r
7631             if test -z "$hardcode_libdirs"; then\r
7632               hardcode_libdirs="$libdir"\r
7633             else\r
7634               # Just accumulate the unique libdirs.\r
7635               case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in\r
7636               *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)\r
7637                 ;;\r
7638               *)\r
7639                 hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"\r
7640                 ;;\r
7641               esac\r
7642             fi\r
7643           else\r
7644             eval flag=\"$hardcode_libdir_flag_spec\"\r
7645             rpath="$rpath $flag"\r
7646           fi\r
7647         elif test -n "$runpath_var"; then\r
7648           case "$finalize_perm_rpath " in\r
7649           *" $libdir "*) ;;\r
7650           *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;\r
7651           esac\r
7652         fi\r
7653       done\r
7654       # Substitute the hardcoded libdirs into the rpath.\r
7655       if test -n "$hardcode_libdir_separator" &&\r
7656          test -n "$hardcode_libdirs"; then\r
7657         libdir="$hardcode_libdirs"\r
7658         eval rpath=\" $hardcode_libdir_flag_spec\"\r
7659       fi\r
7660       finalize_rpath="$rpath"\r
7661 \r
7662       if test -n "$libobjs" && test "$build_old_libs" = yes; then\r
7663         # Transform all the library objects into standard objects.\r
7664         compile_command=`$ECHO "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`\r
7665         finalize_command=`$ECHO "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`\r
7666       fi\r
7667 \r
7668       func_generate_dlsyms "$outputname" "@PROGRAM@" "no"\r
7669 \r
7670       # template prelinking step\r
7671       if test -n "$prelink_cmds"; then\r
7672         func_execute_cmds "$prelink_cmds" 'exit $?'\r
7673       fi\r
7674 \r
7675       wrappers_required=yes\r
7676       case $host in\r
7677       *cygwin* | *mingw* )\r
7678         if test "$build_libtool_libs" != yes; then\r
7679           wrappers_required=no\r
7680         fi\r
7681         ;;\r
7682       *cegcc)\r
7683         # Disable wrappers for cegcc, we are cross compiling anyway.\r
7684         wrappers_required=no\r
7685         ;;\r
7686       *)\r
7687         if test "$need_relink" = no || test "$build_libtool_libs" != yes; then\r
7688           wrappers_required=no\r
7689         fi\r
7690         ;;\r
7691       esac\r
7692       if test "$wrappers_required" = no; then\r
7693         # Replace the output file specification.\r
7694         compile_command=`$ECHO "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`\r
7695         link_command="$compile_command$compile_rpath"\r
7696 \r
7697         # We have no uninstalled library dependencies, so finalize right now.\r
7698         exit_status=0\r
7699         func_show_eval "$link_command" 'exit_status=$?'\r
7700 \r
7701         # Delete the generated files.\r
7702         if test -f "$output_objdir/${outputname}S.${objext}"; then\r
7703           func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'\r
7704         fi\r
7705 \r
7706         exit $exit_status\r
7707       fi\r
7708 \r
7709       if test -n "$compile_shlibpath$finalize_shlibpath"; then\r
7710         compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"\r
7711       fi\r
7712       if test -n "$finalize_shlibpath"; then\r
7713         finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"\r
7714       fi\r
7715 \r
7716       compile_var=\r
7717       finalize_var=\r
7718       if test -n "$runpath_var"; then\r
7719         if test -n "$perm_rpath"; then\r
7720           # We should set the runpath_var.\r
7721           rpath=\r
7722           for dir in $perm_rpath; do\r
7723             rpath="$rpath$dir:"\r
7724           done\r
7725           compile_var="$runpath_var=\"$rpath\$$runpath_var\" "\r
7726         fi\r
7727         if test -n "$finalize_perm_rpath"; then\r
7728           # We should set the runpath_var.\r
7729           rpath=\r
7730           for dir in $finalize_perm_rpath; do\r
7731             rpath="$rpath$dir:"\r
7732           done\r
7733           finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "\r
7734         fi\r
7735       fi\r
7736 \r
7737       if test "$no_install" = yes; then\r
7738         # We don't need to create a wrapper script.\r
7739         link_command="$compile_var$compile_command$compile_rpath"\r
7740         # Replace the output file specification.\r
7741         link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`\r
7742         # Delete the old output file.\r
7743         $opt_dry_run || $RM $output\r
7744         # Link the executable and exit\r
7745         func_show_eval "$link_command" 'exit $?'\r
7746         exit $EXIT_SUCCESS\r
7747       fi\r
7748 \r
7749       if test "$hardcode_action" = relink; then\r
7750         # Fast installation is not supported\r
7751         link_command="$compile_var$compile_command$compile_rpath"\r
7752         relink_command="$finalize_var$finalize_command$finalize_rpath"\r
7753 \r
7754         func_warning "this platform does not like uninstalled shared libraries"\r
7755         func_warning "\`$output' will be relinked during installation"\r
7756       else\r
7757         if test "$fast_install" != no; then\r
7758           link_command="$finalize_var$compile_command$finalize_rpath"\r
7759           if test "$fast_install" = yes; then\r
7760             relink_command=`$ECHO "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`\r
7761           else\r
7762             # fast_install is set to needless\r
7763             relink_command=\r
7764           fi\r
7765         else\r
7766           link_command="$compile_var$compile_command$compile_rpath"\r
7767           relink_command="$finalize_var$finalize_command$finalize_rpath"\r
7768         fi\r
7769       fi\r
7770 \r
7771       # Replace the output file specification.\r
7772       link_command=`$ECHO "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`\r
7773 \r
7774       # Delete the old output files.\r
7775       $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname\r
7776 \r
7777       func_show_eval "$link_command" 'exit $?'\r
7778 \r
7779       # Now create the wrapper script.\r
7780       func_verbose "creating $output"\r
7781 \r
7782       # Quote the relink command for shipping.\r
7783       if test -n "$relink_command"; then\r
7784         # Preserve any variables that may affect compiler behavior\r
7785         for var in $variables_saved_for_relink; do\r
7786           if eval test -z \"\${$var+set}\"; then\r
7787             relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"\r
7788           elif eval var_value=\$$var; test -z "$var_value"; then\r
7789             relink_command="$var=; export $var; $relink_command"\r
7790           else\r
7791             func_quote_for_eval "$var_value"\r
7792             relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"\r
7793           fi\r
7794         done\r
7795         relink_command="(cd `pwd`; $relink_command)"\r
7796         relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`\r
7797       fi\r
7798 \r
7799       # Quote $ECHO for shipping.\r
7800       if test "X$ECHO" = "X$SHELL $progpath --fallback-echo"; then\r
7801         case $progpath in\r
7802         [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;\r
7803         *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;\r
7804         esac\r
7805         qecho=`$ECHO "X$qecho" | $Xsed -e "$sed_quote_subst"`\r
7806       else\r
7807         qecho=`$ECHO "X$ECHO" | $Xsed -e "$sed_quote_subst"`\r
7808       fi\r
7809 \r
7810       # Only actually do things if not in dry run mode.\r
7811       $opt_dry_run || {\r
7812         # win32 will think the script is a binary if it has\r
7813         # a .exe suffix, so we strip it off here.\r
7814         case $output in\r
7815           *.exe) func_stripname '' '.exe' "$output"\r
7816                  output=$func_stripname_result ;;\r
7817         esac\r
7818         # test for cygwin because mv fails w/o .exe extensions\r
7819         case $host in\r
7820           *cygwin*)\r
7821             exeext=.exe\r
7822             func_stripname '' '.exe' "$outputname"\r
7823             outputname=$func_stripname_result ;;\r
7824           *) exeext= ;;\r
7825         esac\r
7826         case $host in\r
7827           *cygwin* | *mingw* )\r
7828             func_dirname_and_basename "$output" "" "."\r
7829             output_name=$func_basename_result\r
7830             output_path=$func_dirname_result\r
7831             cwrappersource="$output_path/$objdir/lt-$output_name.c"\r
7832             cwrapper="$output_path/$output_name.exe"\r
7833             $RM $cwrappersource $cwrapper\r
7834             trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15\r
7835 \r
7836             func_emit_cwrapperexe_src > $cwrappersource\r
7837 \r
7838             # The wrapper executable is built using the $host compiler,\r
7839             # because it contains $host paths and files. If cross-\r
7840             # compiling, it, like the target executable, must be\r
7841             # executed on the $host or under an emulation environment.\r
7842             $opt_dry_run || {\r
7843               $LTCC $LTCFLAGS -o $cwrapper $cwrappersource\r
7844               $STRIP $cwrapper\r
7845             }\r
7846 \r
7847             # Now, create the wrapper script for func_source use:\r
7848             func_ltwrapper_scriptname $cwrapper\r
7849             $RM $func_ltwrapper_scriptname_result\r
7850             trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15\r
7851             $opt_dry_run || {\r
7852               # note: this script will not be executed, so do not chmod.\r
7853               if test "x$build" = "x$host" ; then\r
7854                 $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result\r
7855               else\r
7856                 func_emit_wrapper no > $func_ltwrapper_scriptname_result\r
7857               fi\r
7858             }\r
7859           ;;\r
7860           * )\r
7861             $RM $output\r
7862             trap "$RM $output; exit $EXIT_FAILURE" 1 2 15\r
7863 \r
7864             func_emit_wrapper no > $output\r
7865             chmod +x $output\r
7866           ;;\r
7867         esac\r
7868       }\r
7869       exit $EXIT_SUCCESS\r
7870       ;;\r
7871     esac\r
7872 \r
7873     # See if we need to build an old-fashioned archive.\r
7874     for oldlib in $oldlibs; do\r
7875 \r
7876       if test "$build_libtool_libs" = convenience; then\r
7877         oldobjs="$libobjs_save $symfileobj"\r
7878         addlibs="$convenience"\r
7879         build_libtool_libs=no\r
7880       else\r
7881         if test "$build_libtool_libs" = module; then\r
7882           oldobjs="$libobjs_save"\r
7883           build_libtool_libs=no\r
7884         else\r
7885           oldobjs="$old_deplibs $non_pic_objects"\r
7886           if test "$preload" = yes && test -f "$symfileobj"; then\r
7887             oldobjs="$oldobjs $symfileobj"\r
7888           fi\r
7889         fi\r
7890         addlibs="$old_convenience"\r
7891       fi\r
7892 \r
7893       if test -n "$addlibs"; then\r
7894         gentop="$output_objdir/${outputname}x"\r
7895         generated="$generated $gentop"\r
7896 \r
7897         func_extract_archives $gentop $addlibs\r
7898         oldobjs="$oldobjs $func_extract_archives_result"\r
7899       fi\r
7900 \r
7901       # Do each command in the archive commands.\r
7902       if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then\r
7903         cmds=$old_archive_from_new_cmds\r
7904       else\r
7905 \r
7906         # Add any objects from preloaded convenience libraries\r
7907         if test -n "$dlprefiles"; then\r
7908           gentop="$output_objdir/${outputname}x"\r
7909           generated="$generated $gentop"\r
7910 \r
7911           func_extract_archives $gentop $dlprefiles\r
7912           oldobjs="$oldobjs $func_extract_archives_result"\r
7913         fi\r
7914 \r
7915         # POSIX demands no paths to be encoded in archives.  We have\r
7916         # to avoid creating archives with duplicate basenames if we\r
7917         # might have to extract them afterwards, e.g., when creating a\r
7918         # static archive out of a convenience library, or when linking\r
7919         # the entirety of a libtool archive into another (currently\r
7920         # not supported by libtool).\r
7921         if (for obj in $oldobjs\r
7922             do\r
7923               func_basename "$obj"\r
7924               $ECHO "$func_basename_result"\r
7925             done | sort | sort -uc >/dev/null 2>&1); then\r
7926           :\r
7927         else\r
7928           $ECHO "copying selected object files to avoid basename conflicts..."\r
7929           gentop="$output_objdir/${outputname}x"\r
7930           generated="$generated $gentop"\r
7931           func_mkdir_p "$gentop"\r
7932           save_oldobjs=$oldobjs\r
7933           oldobjs=\r
7934           counter=1\r
7935           for obj in $save_oldobjs\r
7936           do\r
7937             func_basename "$obj"\r
7938             objbase="$func_basename_result"\r
7939             case " $oldobjs " in\r
7940             " ") oldobjs=$obj ;;\r
7941             *[\ /]"$objbase "*)\r
7942               while :; do\r
7943                 # Make sure we don't pick an alternate name that also\r
7944                 # overlaps.\r
7945                 newobj=lt$counter-$objbase\r
7946                 func_arith $counter + 1\r
7947                 counter=$func_arith_result\r
7948                 case " $oldobjs " in\r
7949                 *[\ /]"$newobj "*) ;;\r
7950                 *) if test ! -f "$gentop/$newobj"; then break; fi ;;\r
7951                 esac\r
7952               done\r
7953               func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"\r
7954               oldobjs="$oldobjs $gentop/$newobj"\r
7955               ;;\r
7956             *) oldobjs="$oldobjs $obj" ;;\r
7957             esac\r
7958           done\r
7959         fi\r
7960         eval cmds=\"$old_archive_cmds\"\r
7961 \r
7962         func_len " $cmds"\r
7963         len=$func_len_result\r
7964         if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then\r
7965           cmds=$old_archive_cmds\r
7966         else\r
7967           # the command line is too long to link in one step, link in parts\r
7968           func_verbose "using piecewise archive linking..."\r
7969           save_RANLIB=$RANLIB\r
7970           RANLIB=:\r
7971           objlist=\r
7972           concat_cmds=\r
7973           save_oldobjs=$oldobjs\r
7974           oldobjs=\r
7975           # Is there a better way of finding the last object in the list?\r
7976           for obj in $save_oldobjs\r
7977           do\r
7978             last_oldobj=$obj\r
7979           done\r
7980           eval test_cmds=\"$old_archive_cmds\"\r
7981           func_len " $test_cmds"\r
7982           len0=$func_len_result\r
7983           len=$len0\r
7984           for obj in $save_oldobjs\r
7985           do\r
7986             func_len " $obj"\r
7987             func_arith $len + $func_len_result\r
7988             len=$func_arith_result\r
7989             func_append objlist " $obj"\r
7990             if test "$len" -lt "$max_cmd_len"; then\r
7991               :\r
7992             else\r
7993               # the above command should be used before it gets too long\r
7994               oldobjs=$objlist\r
7995               if test "$obj" = "$last_oldobj" ; then\r
7996                 RANLIB=$save_RANLIB\r
7997               fi\r
7998               test -z "$concat_cmds" || concat_cmds=$concat_cmds~\r
7999               eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"\r
8000               objlist=\r
8001               len=$len0\r
8002             fi\r
8003           done\r
8004           RANLIB=$save_RANLIB\r
8005           oldobjs=$objlist\r
8006           if test "X$oldobjs" = "X" ; then\r
8007             eval cmds=\"\$concat_cmds\"\r
8008           else\r
8009             eval cmds=\"\$concat_cmds~\$old_archive_cmds\"\r
8010           fi\r
8011         fi\r
8012       fi\r
8013       func_execute_cmds "$cmds" 'exit $?'\r
8014     done\r
8015 \r
8016     test -n "$generated" && \\r
8017       func_show_eval "${RM}r$generated"\r
8018 \r
8019     # Now create the libtool archive.\r
8020     case $output in\r
8021     *.la)\r
8022       old_library=\r
8023       test "$build_old_libs" = yes && old_library="$libname.$libext"\r
8024       func_verbose "creating $output"\r
8025 \r
8026       # Preserve any variables that may affect compiler behavior\r
8027       for var in $variables_saved_for_relink; do\r
8028         if eval test -z \"\${$var+set}\"; then\r
8029           relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"\r
8030         elif eval var_value=\$$var; test -z "$var_value"; then\r
8031           relink_command="$var=; export $var; $relink_command"\r
8032         else\r
8033           func_quote_for_eval "$var_value"\r
8034           relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"\r
8035         fi\r
8036       done\r
8037       # Quote the link command for shipping.\r
8038       relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"\r
8039       relink_command=`$ECHO "X$relink_command" | $Xsed -e "$sed_quote_subst"`\r
8040       if test "$hardcode_automatic" = yes ; then\r
8041         relink_command=\r
8042       fi\r
8043 \r
8044       # Only create the output if not a dry run.\r
8045       $opt_dry_run || {\r
8046         for installed in no yes; do\r
8047           if test "$installed" = yes; then\r
8048             if test -z "$install_libdir"; then\r
8049               break\r
8050             fi\r
8051             output="$output_objdir/$outputname"i\r
8052             # Replace all uninstalled libtool libraries with the installed ones\r
8053             newdependency_libs=\r
8054             for deplib in $dependency_libs; do\r
8055               case $deplib in\r
8056               *.la)\r
8057                 func_basename "$deplib"\r
8058                 name="$func_basename_result"\r
8059                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`\r
8060                 test -z "$libdir" && \\r
8061                   func_fatal_error "\`$deplib' is not a valid libtool archive"\r
8062                 newdependency_libs="$newdependency_libs $libdir/$name"\r
8063                 ;;\r
8064               *) newdependency_libs="$newdependency_libs $deplib" ;;\r
8065               esac\r
8066             done\r
8067             dependency_libs="$newdependency_libs"\r
8068             newdlfiles=\r
8069 \r
8070             for lib in $dlfiles; do\r
8071               case $lib in\r
8072               *.la)\r
8073                 func_basename "$lib"\r
8074                 name="$func_basename_result"\r
8075                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`\r
8076                 test -z "$libdir" && \\r
8077                   func_fatal_error "\`$lib' is not a valid libtool archive"\r
8078                 newdlfiles="$newdlfiles $libdir/$name"\r
8079                 ;;\r
8080               *) newdlfiles="$newdlfiles $lib" ;;\r
8081               esac\r
8082             done\r
8083             dlfiles="$newdlfiles"\r
8084             newdlprefiles=\r
8085             for lib in $dlprefiles; do\r
8086               case $lib in\r
8087               *.la)\r
8088                 # Only pass preopened files to the pseudo-archive (for\r
8089                 # eventual linking with the app. that links it) if we\r
8090                 # didn't already link the preopened objects directly into\r
8091                 # the library:\r
8092                 func_basename "$lib"\r
8093                 name="$func_basename_result"\r
8094                 eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`\r
8095                 test -z "$libdir" && \\r
8096                   func_fatal_error "\`$lib' is not a valid libtool archive"\r
8097                 newdlprefiles="$newdlprefiles $libdir/$name"\r
8098                 ;;\r
8099               esac\r
8100             done\r
8101             dlprefiles="$newdlprefiles"\r
8102           else\r
8103             newdlfiles=\r
8104             for lib in $dlfiles; do\r
8105               case $lib in\r
8106                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;\r
8107                 *) abs=`pwd`"/$lib" ;;\r
8108               esac\r
8109               newdlfiles="$newdlfiles $abs"\r
8110             done\r
8111             dlfiles="$newdlfiles"\r
8112             newdlprefiles=\r
8113             for lib in $dlprefiles; do\r
8114               case $lib in\r
8115                 [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;\r
8116                 *) abs=`pwd`"/$lib" ;;\r
8117               esac\r
8118               newdlprefiles="$newdlprefiles $abs"\r
8119             done\r
8120             dlprefiles="$newdlprefiles"\r
8121           fi\r
8122           $RM $output\r
8123           # place dlname in correct position for cygwin\r
8124           tdlname=$dlname\r
8125           case $host,$output,$installed,$module,$dlname in\r
8126             *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;\r
8127           esac\r
8128           $ECHO > $output "\\r
8129 # $outputname - a libtool library file\r
8130 # Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION\r
8131 #\r
8132 # Please DO NOT delete this file!\r
8133 # It is necessary for linking the library.\r
8134 \r
8135 # The name that we can dlopen(3).\r
8136 dlname='$tdlname'\r
8137 \r
8138 # Names of this library.\r
8139 library_names='$library_names'\r
8140 \r
8141 # The name of the static archive.\r
8142 old_library='$old_library'\r
8143 \r
8144 # Linker flags that can not go in dependency_libs.\r
8145 inherited_linker_flags='$new_inherited_linker_flags'\r
8146 \r
8147 # Libraries that this one depends upon.\r
8148 dependency_libs='$dependency_libs'\r
8149 \r
8150 # Names of additional weak libraries provided by this library\r
8151 weak_library_names='$weak_libs'\r
8152 \r
8153 # Version information for $libname.\r
8154 current=$current\r
8155 age=$age\r
8156 revision=$revision\r
8157 \r
8158 # Is this an already installed library?\r
8159 installed=$installed\r
8160 \r
8161 # Should we warn about portability when linking against -modules?\r
8162 shouldnotlink=$module\r
8163 \r
8164 # Files to dlopen/dlpreopen\r
8165 dlopen='$dlfiles'\r
8166 dlpreopen='$dlprefiles'\r
8167 \r
8168 # Directory that this library needs to be installed in:\r
8169 libdir='$install_libdir'"\r
8170           if test "$installed" = no && test "$need_relink" = yes; then\r
8171             $ECHO >> $output "\\r
8172 relink_command=\"$relink_command\""\r
8173           fi\r
8174         done\r
8175       }\r
8176 \r
8177       # Do a symbolic link so that the libtool archive can be found in\r
8178       # LD_LIBRARY_PATH before the program is installed.\r
8179       func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'\r
8180       ;;\r
8181     esac\r
8182     exit $EXIT_SUCCESS\r
8183 }\r
8184 \r
8185 { test "$mode" = link || test "$mode" = relink; } &&\r
8186     func_mode_link ${1+"$@"}\r
8187 \r
8188 \r
8189 # func_mode_uninstall arg...\r
8190 func_mode_uninstall ()\r
8191 {\r
8192     $opt_debug\r
8193     RM="$nonopt"\r
8194     files=\r
8195     rmforce=\r
8196     exit_status=0\r
8197 \r
8198     # This variable tells wrapper scripts just to set variables rather\r
8199     # than running their programs.\r
8200     libtool_install_magic="$magic"\r
8201 \r
8202     for arg\r
8203     do\r
8204       case $arg in\r
8205       -f) RM="$RM $arg"; rmforce=yes ;;\r
8206       -*) RM="$RM $arg" ;;\r
8207       *) files="$files $arg" ;;\r
8208       esac\r
8209     done\r
8210 \r
8211     test -z "$RM" && \\r
8212       func_fatal_help "you must specify an RM program"\r
8213 \r
8214     rmdirs=\r
8215 \r
8216     origobjdir="$objdir"\r
8217     for file in $files; do\r
8218       func_dirname "$file" "" "."\r
8219       dir="$func_dirname_result"\r
8220       if test "X$dir" = X.; then\r
8221         objdir="$origobjdir"\r
8222       else\r
8223         objdir="$dir/$origobjdir"\r
8224       fi\r
8225       func_basename "$file"\r
8226       name="$func_basename_result"\r
8227       test "$mode" = uninstall && objdir="$dir"\r
8228 \r
8229       # Remember objdir for removal later, being careful to avoid duplicates\r
8230       if test "$mode" = clean; then\r
8231         case " $rmdirs " in\r
8232           *" $objdir "*) ;;\r
8233           *) rmdirs="$rmdirs $objdir" ;;\r
8234         esac\r
8235       fi\r
8236 \r
8237       # Don't error if the file doesn't exist and rm -f was used.\r
8238       if { test -L "$file"; } >/dev/null 2>&1 ||\r
8239          { test -h "$file"; } >/dev/null 2>&1 ||\r
8240          test -f "$file"; then\r
8241         :\r
8242       elif test -d "$file"; then\r
8243         exit_status=1\r
8244         continue\r
8245       elif test "$rmforce" = yes; then\r
8246         continue\r
8247       fi\r
8248 \r
8249       rmfiles="$file"\r
8250 \r
8251       case $name in\r
8252       *.la)\r
8253         # Possibly a libtool archive, so verify it.\r
8254         if func_lalib_p "$file"; then\r
8255           func_source $dir/$name\r
8256 \r
8257           # Delete the libtool libraries and symlinks.\r
8258           for n in $library_names; do\r
8259             rmfiles="$rmfiles $objdir/$n"\r
8260           done\r
8261           test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"\r
8262 \r
8263           case "$mode" in\r
8264           clean)\r
8265             case "  $library_names " in\r
8266             # "  " in the beginning catches empty $dlname\r
8267             *" $dlname "*) ;;\r
8268             *) rmfiles="$rmfiles $objdir/$dlname" ;;\r
8269             esac\r
8270             test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"\r
8271             ;;\r
8272           uninstall)\r
8273             if test -n "$library_names"; then\r
8274               # Do each command in the postuninstall commands.\r
8275               func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'\r
8276             fi\r
8277 \r
8278             if test -n "$old_library"; then\r
8279               # Do each command in the old_postuninstall commands.\r
8280               func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'\r
8281             fi\r
8282             # FIXME: should reinstall the best remaining shared library.\r
8283             ;;\r
8284           esac\r
8285         fi\r
8286         ;;\r
8287 \r
8288       *.lo)\r
8289         # Possibly a libtool object, so verify it.\r
8290         if func_lalib_p "$file"; then\r
8291 \r
8292           # Read the .lo file\r
8293           func_source $dir/$name\r
8294 \r
8295           # Add PIC object to the list of files to remove.\r
8296           if test -n "$pic_object" &&\r
8297              test "$pic_object" != none; then\r
8298             rmfiles="$rmfiles $dir/$pic_object"\r
8299           fi\r
8300 \r
8301           # Add non-PIC object to the list of files to remove.\r
8302           if test -n "$non_pic_object" &&\r
8303              test "$non_pic_object" != none; then\r
8304             rmfiles="$rmfiles $dir/$non_pic_object"\r
8305           fi\r
8306         fi\r
8307         ;;\r
8308 \r
8309       *)\r
8310         if test "$mode" = clean ; then\r
8311           noexename=$name\r
8312           case $file in\r
8313           *.exe)\r
8314             func_stripname '' '.exe' "$file"\r
8315             file=$func_stripname_result\r
8316             func_stripname '' '.exe' "$name"\r
8317             noexename=$func_stripname_result\r
8318             # $file with .exe has already been added to rmfiles,\r
8319             # add $file without .exe\r
8320             rmfiles="$rmfiles $file"\r
8321             ;;\r
8322           esac\r
8323           # Do a test to see if this is a libtool program.\r
8324           if func_ltwrapper_p "$file"; then\r
8325             if func_ltwrapper_executable_p "$file"; then\r
8326               func_ltwrapper_scriptname "$file"\r
8327               relink_command=\r
8328               func_source $func_ltwrapper_scriptname_result\r
8329               rmfiles="$rmfiles $func_ltwrapper_scriptname_result"\r
8330             else\r
8331               relink_command=\r
8332               func_source $dir/$noexename\r
8333             fi\r
8334 \r
8335             # note $name still contains .exe if it was in $file originally\r
8336             # as does the version of $file that was added into $rmfiles\r
8337             rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"\r
8338             if test "$fast_install" = yes && test -n "$relink_command"; then\r
8339               rmfiles="$rmfiles $objdir/lt-$name"\r
8340             fi\r
8341             if test "X$noexename" != "X$name" ; then\r
8342               rmfiles="$rmfiles $objdir/lt-${noexename}.c"\r
8343             fi\r
8344           fi\r
8345         fi\r
8346         ;;\r
8347       esac\r
8348       func_show_eval "$RM $rmfiles" 'exit_status=1'\r
8349     done\r
8350     objdir="$origobjdir"\r
8351 \r
8352     # Try to remove the ${objdir}s in the directories where we deleted files\r
8353     for dir in $rmdirs; do\r
8354       if test -d "$dir"; then\r
8355         func_show_eval "rmdir $dir >/dev/null 2>&1"\r
8356       fi\r
8357     done\r
8358 \r
8359     exit $exit_status\r
8360 }\r
8361 \r
8362 { test "$mode" = uninstall || test "$mode" = clean; } &&\r
8363     func_mode_uninstall ${1+"$@"}\r
8364 \r
8365 test -z "$mode" && {\r
8366   help="$generic_help"\r
8367   func_fatal_help "you must specify a MODE"\r
8368 }\r
8369 \r
8370 test -z "$exec_cmd" && \\r
8371   func_fatal_help "invalid operation mode \`$mode'"\r
8372 \r
8373 if test -n "$exec_cmd"; then\r
8374   eval exec "$exec_cmd"\r
8375   exit $EXIT_FAILURE\r
8376 fi\r
8377 \r
8378 exit $exit_status\r
8379 \r
8380 \r
8381 # The TAGs below are defined such that we never get into a situation\r
8382 # in which we disable both kinds of libraries.  Given conflicting\r
8383 # choices, we go for a static library, that is the most portable,\r
8384 # since we can't tell whether shared libraries were disabled because\r
8385 # the user asked for that or because the platform doesn't support\r
8386 # them.  This is particularly important on AIX, because we don't\r
8387 # support having both static and shared libraries enabled at the same\r
8388 # time on that platform, so we default to a shared-only configuration.\r
8389 # If a disable-shared tag is given, we'll fallback to a static-only\r
8390 # configuration.  But we'll never go from static-only to shared-only.\r
8391 \r
8392 # ### BEGIN LIBTOOL TAG CONFIG: disable-shared\r
8393 build_libtool_libs=no\r
8394 build_old_libs=yes\r
8395 # ### END LIBTOOL TAG CONFIG: disable-shared\r
8396 \r
8397 # ### BEGIN LIBTOOL TAG CONFIG: disable-static\r
8398 build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`\r
8399 # ### END LIBTOOL TAG CONFIG: disable-static\r
8400 \r
8401 # Local Variables:\r
8402 # mode:shell-script\r
8403 # sh-indentation:2\r
8404 # End:\r
8405 # vi:sw=2\r
8406 \r