lac : 0f0a2da3f9dd10627626bf9725b332d95f314393

     1: #! /bin/sh
     2: ## DO NOT EDIT - This file generated from ./build-aux/ltmain.in
     3: ##               by inline-source v2014-01-03.01
     4: 
     5: # libtool (GNU libtool) 2.4.6
     6: # Provide generalized library-building support services.
     7: # Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
     8: 
     9: # Copyright (C) 1996-2015 Free Software Foundation, Inc.
    10: # This is free software; see the source for copying conditions.  There is NO
    11: # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    12: 
    13: # GNU Libtool is free software; you can redistribute it and/or modify
    14: # it under the terms of the GNU General Public License as published by
    15: # the Free Software Foundation; either version 2 of the License, or
    16: # (at your option) any later version.
    17: #
    18: # As a special exception to the GNU General Public License,
    19: # if you distribute this file as part of a program or library that
    20: # is built using GNU Libtool, you may include this file under the
    21: # same distribution terms that you use for the rest of that program.
    22: #
    23: # GNU Libtool is distributed in the hope that it will be useful, but
    24: # WITHOUT ANY WARRANTY; without even the implied warranty of
    25: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    26: # General Public License for more details.
    27: #
    28: # You should have received a copy of the GNU General Public License
    29: # along with this program.  If not, see <http://www.gnu.org/licenses/>.
    30: 
    31: 
    32: PROGRAM=libtool
    33: PACKAGE=libtool
    34: VERSION=2.4.6
    35: package_revision=2.4.6
    36: 
    37: 
    38: ## ------ ##
    39: ## Usage. ##
    40: ## ------ ##
    41: 
    42: # Run './libtool --help' for help with using this script from the
    43: # command line.
    44: 
    45: 
    46: ## ------------------------------- ##
    47: ## User overridable command paths. ##
    48: ## ------------------------------- ##
    49: 
    50: # After configure completes, it has a better idea of some of the
    51: # shell tools we need than the defaults used by the functions shared
    52: # with bootstrap, so set those here where they can still be over-
    53: # ridden by the user, but otherwise take precedence.
    54: 
    55: : ${AUTOCONF="autoconf"}
    56: : ${AUTOMAKE="automake"}
    57: 
    58: 
    59: ## -------------------------- ##
    60: ## Source external libraries. ##
    61: ## -------------------------- ##
    62: 
    63: # Much of our low-level functionality needs to be sourced from external
    64: # libraries, which are installed to $pkgauxdir.
    65: 
    66: # Set a version string for this script.
    67: scriptversion=2015-01-20.17; # UTC
    68: 
    69: # General shell script boiler plate, and helper functions.
    70: # Written by Gary V. Vaughan, 2004
    71: 
    72: # Copyright (C) 2004-2015 Free Software Foundation, Inc.
    73: # This is free software; see the source for copying conditions.  There is NO
    74: # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
    75: 
    76: # This program is free software; you can redistribute it and/or modify
    77: # it under the terms of the GNU General Public License as published by
    78: # the Free Software Foundation; either version 3 of the License, or
    79: # (at your option) any later version.
    80: 
    81: # As a special exception to the GNU General Public License, if you distribute
    82: # this file as part of a program or library that is built using GNU Libtool,
    83: # you may include this file under the same distribution terms that you use
    84: # for the rest of that program.
    85: 
    86: # This program is distributed in the hope that it will be useful,
    87: # but WITHOUT ANY WARRANTY; without even the implied warranty of
    88: # MERCHANTABILITY or FITNES FOR A PARTICULAR PURPOSE. See the GNU
    89: # General Public License for more details.
    90: 
    91: # You should have received a copy of the GNU General Public License
    92: # along with this program. If not, see <http://www.gnu.org/licenses/>.
    93: 
    94: # Please report bugs or propose patches to gary@gnu.org.
    95: 
    96: 
    97: ## ------ ##
    98: ## Usage. ##
    99: ## ------ ##
   100: 
   101: # Evaluate this file near the top of your script to gain access to
   102: # the functions and variables defined here:
   103: #
   104: #   . `echo "$0" | ${SED-sed} 's|[^/]*$||'`/build-aux/funclib.sh
   105: #
   106: # If you need to override any of the default environment variable
   107: # settings, do that before evaluating this file.
   108: 
   109: 
   110: ## -------------------- ##
   111: ## Shell normalisation. ##
   112: ## -------------------- ##
   113: 
   114: # Some shells need a little help to be as Bourne compatible as possible.
   115: # Before doing anything else, make sure all that help has been provided!
   116: 
   117: DUALCASE=1; export DUALCASE # for MKS sh
   118: if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then :
   119:   emulate sh
   120:   NULLCMD=:
   121:   # Pre-4.2 versions of Zsh do word splitting on ${1+"$@"}, which
   122:   # is contrary to our usage.  Disable this feature.
   123:   alias -g '${1+"$@"}'='"$@"'
   124:   setopt NO_GLOB_SUBST
   125: else
   126:   case `(set -o) 2>/dev/null` in *posix*) set -o posix ;; esac
   127: fi
   128: 
   129: # NLS nuisances: We save the old values in case they are required later.
   130: _G_user_locale=
   131: _G_safe_locale=
   132: for _G_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
   133: do
   134:   eval "if test set = \"\${$_G_var+set}\"; then
   135:           save_$_G_var=\$$_G_var
   136:           $_G_var=C
   137: 	  export $_G_var
   138: 	  _G_user_locale=\"$_G_var=\\\$save_\$_G_var; \$_G_user_locale\"
   139: 	  _G_safe_locale=\"$_G_var=C; \$_G_safe_locale\"
   140: 	fi"
   141: done
   142: 
   143: # CDPATH.
   144: (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
   145: 
   146: # Make sure IFS has a sensible default
   147: sp=' '
   148: nl='
   149: '
   150: IFS="$sp	$nl"
   151: 
   152: # There are apparently some retarded systems that use ';' as a PATH separator!
   153: if test "${PATH_SEPARATOR+set}" != set; then
   154:   PATH_SEPARATOR=:
   155:   (PATH='/bin;/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 && {
   156:     (PATH='/bin:/bin'; FPATH=$PATH; sh -c :) >/dev/null 2>&1 ||
   157:       PATH_SEPARATOR=';'
   158:   }
   159: fi
   160: 
   161: 
   162: 
   163: ## ------------------------- ##
   164: ## Locate command utilities. ##
   165: ## ------------------------- ##
   166: 
   167: 
   168: # func_executable_p FILE
   169: # ----------------------
   170: # Check that FILE is an executable regular file.
   171: func_executable_p ()
   172: {
   173:     test -f "$1" && test -x "$1"
   174: }
   175: 
   176: 
   177: # func_path_progs PROGS_LIST CHECK_FUNC [PATH]
   178: # --------------------------------------------
   179: # Search for either a program that responds to --version with output
   180: # containing "GNU", or else returned by CHECK_FUNC otherwise, by
   181: # trying all the directories in PATH with each of the elements of
   182: # PROGS_LIST.
   183: #
   184: # CHECK_FUNC should accept the path to a candidate program, and
   185: # set $func_check_prog_result if it truncates its output less than
   186: # $_G_path_prog_max characters.
   187: func_path_progs ()
   188: {
   189:     _G_progs_list=$1
   190:     _G_check_func=$2
   191:     _G_PATH=${3-"$PATH"}
   192: 
   193:     _G_path_prog_max=0
   194:     _G_path_prog_found=false
   195:     _G_save_IFS=$IFS; IFS=${PATH_SEPARATOR-:}
   196:     for _G_dir in $_G_PATH; do
   197:       IFS=$_G_save_IFS
   198:       test -z "$_G_dir" && _G_dir=.
   199:       for _G_prog_name in $_G_progs_list; do
   200:         for _exeext in '' .EXE; do
   201:           _G_path_prog=$_G_dir/$_G_prog_name$_exeext
   202:           func_executable_p "$_G_path_prog" || continue
   203:           case `"$_G_path_prog" --version 2>&1` in
   204:             *GNU*) func_path_progs_result=$_G_path_prog _G_path_prog_found=: ;;
   205:             *)     $_G_check_func $_G_path_prog
   206: 		   func_path_progs_result=$func_check_prog_result
   207: 		   ;;
   208:           esac
   209:           $_G_path_prog_found && break 3
   210:         done
   211:       done
   212:     done
   213:     IFS=$_G_save_IFS
   214:     test -z "$func_path_progs_result" && {
   215:       echo "no acceptable sed could be found in \$PATH" >&2
   216:       exit 1
   217:     }
   218: }
   219: 
   220: 
   221: # We want to be able to use the functions in this file before configure
   222: # has figured out where the best binaries are kept, which means we have
   223: # to search for them ourselves - except when the results are already set
   224: # where we skip the searches.
   225: 
   226: # Unless the user overrides by setting SED, search the path for either GNU
   227: # sed, or the sed that truncates its output the least.
   228: test -z "$SED" && {
   229:   _G_sed_script=s/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa/bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb/
   230:   for _G_i in 1 2 3 4 5 6 7; do
   231:     _G_sed_script=$_G_sed_script$nl$_G_sed_script
   232:   done
   233:   echo "$_G_sed_script" 2>/dev/null | sed 99q >conftest.sed
   234:   _G_sed_script=
   235: 
   236:   func_check_prog_sed ()
   237:   {
   238:     _G_path_prog=$1
   239: 
   240:     _G_count=0
   241:     printf 0123456789 >conftest.in
   242:     while :
   243:     do
   244:       cat conftest.in conftest.in >conftest.tmp
   245:       mv conftest.tmp conftest.in
   246:       cp conftest.in conftest.nl
   247:       echo '' >> conftest.nl
   248:       "$_G_path_prog" -f conftest.sed <conftest.nl >conftest.out 2>/dev/null || break
   249:       diff conftest.out conftest.nl >/dev/null 2>&1 || break
   250:       _G_count=`expr $_G_count + 1`
   251:       if test "$_G_count" -gt "$_G_path_prog_max"; then
   252:         # Best one so far, save it but keep looking for a better one
   253:         func_check_prog_result=$_G_path_prog
   254:         _G_path_prog_max=$_G_count
   255:       fi
   256:       # 10*(2^10) chars as input seems more than enough
   257:       test 10 -lt "$_G_count" && break
   258:     done
   259:     rm -f conftest.in conftest.tmp conftest.nl conftest.out
   260:   }
   261: 
   262:   func_path_progs "sed gsed" func_check_prog_sed $PATH:/usr/xpg4/bin
   263:   rm -f conftest.sed
   264:   SED=$func_path_progs_result
   265: }
   266: 
   267: 
   268: # Unless the user overrides by setting GREP, search the path for either GNU
   269: # grep, or the grep that truncates its output the least.
   270: test -z "$GREP" && {
   271:   func_check_prog_grep ()
   272:   {
   273:     _G_path_prog=$1
   274: 
   275:     _G_count=0
   276:     _G_path_prog_max=0
   277:     printf 0123456789 >conftest.in
   278:     while :
   279:     do
   280:       cat conftest.in conftest.in >conftest.tmp
   281:       mv conftest.tmp conftest.in
   282:       cp conftest.in conftest.nl
   283:       echo 'GREP' >> conftest.nl
   284:       "$_G_path_prog" -e 'GREP$' -e '-(cannot match)-' <conftest.nl >conftest.out 2>/dev/null || break
   285:       diff conftest.out conftest.nl >/dev/null 2>&1 || break
   286:       _G_count=`expr $_G_count + 1`
   287:       if test "$_G_count" -gt "$_G_path_prog_max"; then
   288:         # Best one so far, save it but keep looking for a better one
   289:         func_check_prog_result=$_G_path_prog
   290:         _G_path_prog_max=$_G_count
   291:       fi
   292:       # 10*(2^10) chars as input seems more than enough
   293:       test 10 -lt "$_G_count" && break
   294:     done
   295:     rm -f conftest.in conftest.tmp conftest.nl conftest.out
   296:   }
   297: 
   298:   func_path_progs "grep ggrep" func_check_prog_grep $PATH:/usr/xpg4/bin
   299:   GREP=$func_path_progs_result
   300: }
   301: 
   302: 
   303: ## ------------------------------- ##
   304: ## User overridable command paths. ##
   305: ## ------------------------------- ##
   306: 
   307: # All uppercase variable names are used for environment variables.  These
   308: # variables can be overridden by the user before calling a script that
   309: # uses them if a suitable command of that name is not already available
   310: # in the command search PATH.
   311: 
   312: : ${CP="cp -f"}
   313: : ${ECHO="printf %s\n"}
   314: : ${EGREP="$GREP -E"}
   315: : ${FGREP="$GREP -F"}
   316: : ${LN_S="ln -s"}
   317: : ${MAKE="make"}
   318: : ${MKDIR="mkdir"}
   319: : ${MV="mv -f"}
   320: : ${RM="rm -f"}
   321: : ${SHELL="${CONFIG_SHELL-/bin/sh}"}
   322: 
   323: 
   324: ## -------------------- ##
   325: ## Useful sed snippets. ##
   326: ## -------------------- ##
   327: 
   328: sed_dirname='s|/[^/]*$||'
   329: sed_basename='s|^.*/||'
   330: 
   331: # Sed substitution that helps us do robust quoting.  It backslashifies
   332: # metacharacters that are still active within double-quoted strings.
   333: sed_quote_subst='s|\([`"$\\]\)|\\\1|g'
   334: 
   335: # Same as above, but do not quote variable references.
   336: sed_double_quote_subst='s/\(["`\\]\)/\\\1/g'
   337: 
   338: # Sed substitution that turns a string into a regex matching for the
   339: # string literally.
   340: sed_make_literal_regex='s|[].[^$\\*\/]|\\&|g'
   341: 
   342: # Sed substitution that converts a w32 file name or path
   343: # that contains forward slashes, into one that contains
   344: # (escaped) backslashes.  A very naive implementation.
   345: sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
   346: 
   347: # Re-'\' parameter expansions in output of sed_double_quote_subst that
   348: # were '\'-ed in input to the same.  If an odd number of '\' preceded a
   349: # '$' in input to sed_double_quote_subst, that '$' was protected from
   350: # expansion.  Since each input '\' is now two '\'s, look for any number
   351: # of runs of four '\'s followed by two '\'s and then a '$'.  '\' that '$'.
   352: _G_bs='\\'
   353: _G_bs2='\\\\'
   354: _G_bs4='\\\\\\\\'
   355: _G_dollar='\$'
   356: sed_double_backslash="\
   357:   s/$_G_bs4/&\\
   358: /g
   359:   s/^$_G_bs2$_G_dollar/$_G_bs&/
   360:   s/\\([^$_G_bs]\\)$_G_bs2$_G_dollar/\\1$_G_bs2$_G_bs$_G_dollar/g
   361:   s/\n//g"
   362: 
   363: 
   364: ## ----------------- ##
   365: ## Global variables. ##
   366: ## ----------------- ##
   367: 
   368: # Except for the global variables explicitly listed below, the following
   369: # functions in the '^func_' namespace, and the '^require_' namespace
   370: # variables initialised in the 'Resource management' section, sourcing
   371: # this file will not pollute your global namespace with anything
   372: # else. There's no portable way to scope variables in Bourne shell
   373: # though, so actually running these functions will sometimes place
   374: # results into a variable named after the function, and often use
   375: # temporary variables in the '^_G_' namespace. If you are careful to
   376: # avoid using those namespaces casually in your sourcing script, things
   377: # should continue to work as you expect. And, of course, you can freely
   378: # overwrite any of the functions or variables defined here before
   379: # calling anything to customize them.
   380: 
   381: EXIT_SUCCESS=0
   382: EXIT_FAILURE=1
   383: EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
   384: EXIT_SKIP=77	  # $? = 77 is used to indicate a skipped test to automake.
   385: 
   386: # Allow overriding, eg assuming that you follow the convention of
   387: # putting '$debug_cmd' at the start of all your functions, you can get
   388: # bash to show function call trace with:
   389: #
   390: #    debug_cmd='eval echo "${FUNCNAME[0]} $*" >&2' bash your-script-name
   391: debug_cmd=${debug_cmd-":"}
   392: exit_cmd=:
   393: 
   394: # By convention, finish your script with:
   395: #
   396: #    exit $exit_status
   397: #
   398: # so that you can set exit_status to non-zero if you want to indicate
   399: # something went wrong during execution without actually bailing out at
   400: # the point of failure.
   401: exit_status=$EXIT_SUCCESS
   402: 
   403: # Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
   404: # is ksh but when the shell is invoked as "sh" and the current value of
   405: # the _XPG environment variable is not equal to 1 (one), the special
   406: # positional parameter $0, within a function call, is the name of the
   407: # function.
   408: progpath=$0
   409: 
   410: # The name of this program.
   411: progname=`$ECHO "$progpath" |$SED "$sed_basename"`
   412: 
   413: # Make sure we have an absolute progpath for reexecution:
   414: case $progpath in
   415:   [\\/]*|[A-Za-z]:\\*) ;;
   416:   *[\\/]*)
   417:      progdir=`$ECHO "$progpath" |$SED "$sed_dirname"`
   418:      progdir=`cd "$progdir" && pwd`
   419:      progpath=$progdir/$progname
   420:      ;;
   421:   *)
   422:      _G_IFS=$IFS
   423:      IFS=${PATH_SEPARATOR-:}
   424:      for progdir in $PATH; do
   425:        IFS=$_G_IFS
   426:        test -x "$progdir/$progname" && break
   427:      done
   428:      IFS=$_G_IFS
   429:      test -n "$progdir" || progdir=`pwd`
   430:      progpath=$progdir/$progname
   431:      ;;
   432: esac
   433: 
   434: 
   435: ## ----------------- ##
   436: ## Standard options. ##
   437: ## ----------------- ##
   438: 
   439: # The following options affect the operation of the functions defined
   440: # below, and should be set appropriately depending on run-time para-
   441: # meters passed on the command line.
   442: 
   443: opt_dry_run=false
   444: opt_quiet=false
   445: opt_verbose=false
   446: 
   447: # Categories 'all' and 'none' are always available.  Append any others
   448: # you will pass as the first argument to func_warning from your own
   449: # code.
   450: warning_categories=
   451: 
   452: # By default, display warnings according to 'opt_warning_types'.  Set
   453: # 'warning_func'  to ':' to elide all warnings, or func_fatal_error to
   454: # treat the next displayed warning as a fatal error.
   455: warning_func=func_warn_and_continue
   456: 
   457: # Set to 'all' to display all warnings, 'none' to suppress all
   458: # warnings, or a space delimited list of some subset of
   459: # 'warning_categories' to display only the listed warnings.
   460: opt_warning_types=all
   461: 
   462: 
   463: ## -------------------- ##
   464: ## Resource management. ##
   465: ## -------------------- ##
   466: 
   467: # This section contains definitions for functions that each ensure a
   468: # particular resource (a file, or a non-empty configuration variable for
   469: # example) is available, and if appropriate to extract default values
   470: # from pertinent package files. Call them using their associated
   471: # 'require_*' variable to ensure that they are executed, at most, once.
   472: #
   473: # It's entirely deliberate that calling these functions can set
   474: # variables that don't obey the namespace limitations obeyed by the rest
   475: # of this file, in order that that they be as useful as possible to
   476: # callers.
   477: 
   478: 
   479: # require_term_colors
   480: # -------------------
   481: # Allow display of bold text on terminals that support it.
   482: require_term_colors=func_require_term_colors
   483: func_require_term_colors ()
   484: {
   485:     $debug_cmd
   486: 
   487:     test -t 1 && {
   488:       # COLORTERM and USE_ANSI_COLORS environment variables take
   489:       # precedence, because most terminfo databases neglect to describe
   490:       # whether color sequences are supported.
   491:       test -n "${COLORTERM+set}" && : ${USE_ANSI_COLORS="1"}
   492: 
   493:       if test 1 = "$USE_ANSI_COLORS"; then
   494:         # Standard ANSI escape sequences
   495:         tc_reset=''
   496:         tc_bold='';   tc_standout=''
   497:         tc_red='';   tc_green=''
   498:         tc_blue='';  tc_cyan=''
   499:       else
   500:         # Otherwise trust the terminfo database after all.
   501:         test -n "`tput sgr0 2>/dev/null`" && {
   502:           tc_reset=`tput sgr0`
   503:           test -n "`tput bold 2>/dev/null`" && tc_bold=`tput bold`
   504:           tc_standout=$tc_bold
   505:           test -n "`tput smso 2>/dev/null`" && tc_standout=`tput smso`
   506:           test -n "`tput setaf 1 2>/dev/null`" && tc_red=`tput setaf 1`
   507:           test -n "`tput setaf 2 2>/dev/null`" && tc_green=`tput setaf 2`
   508:           test -n "`tput setaf 4 2>/dev/null`" && tc_blue=`tput setaf 4`
   509:           test -n "`tput setaf 5 2>/dev/null`" && tc_cyan=`tput setaf 5`
   510:         }
   511:       fi
   512:     }
   513: 
   514:     require_term_colors=:
   515: }
   516: 
   517: 
   518: ## ----------------- ##
   519: ## Function library. ##
   520: ## ----------------- ##
   521: 
   522: # This section contains a variety of useful functions to call in your
   523: # scripts. Take note of the portable wrappers for features provided by
   524: # some modern shells, which will fall back to slower equivalents on
   525: # less featureful shells.
   526: 
   527: 
   528: # func_append VAR VALUE
   529: # ---------------------
   530: # Append VALUE onto the existing contents of VAR.
   531: 
   532:   # We should try to minimise forks, especially on Windows where they are
   533:   # unreasonably slow, so skip the feature probes when bash or zsh are
   534:   # being used:
   535:   if test set = "${BASH_VERSION+set}${ZSH_VERSION+set}"; then
   536:     : ${_G_HAVE_ARITH_OP="yes"}
   537:     : ${_G_HAVE_XSI_OPS="yes"}
   538:     # The += operator was introduced in bash 3.1
   539:     case $BASH_VERSION in
   540:       [12].* | 3.0 | 3.0*) ;;
   541:       *)
   542:         : ${_G_HAVE_PLUSEQ_OP="yes"}
   543:         ;;
   544:     esac
   545:   fi
   546: 
   547:   # _G_HAVE_PLUSEQ_OP
   548:   # Can be empty, in which case the shell is probed, "yes" if += is
   549:   # useable or anything else if it does not work.
   550:   test -z "$_G_HAVE_PLUSEQ_OP" \
   551:     && (eval 'x=a; x+=" b"; test "a b" = "$x"') 2>/dev/null \
   552:     && _G_HAVE_PLUSEQ_OP=yes
   553: 
   554: if test yes = "$_G_HAVE_PLUSEQ_OP"
   555: then
   556:   # This is an XSI compatible shell, allowing a faster implementation...
   557:   eval 'func_append ()
   558:   {
   559:     $debug_cmd
   560: 
   561:     eval "$1+=\$2"
   562:   }'
   563: else
   564:   # ...otherwise fall back to using expr, which is often a shell builtin.
   565:   func_append ()
   566:   {
   567:     $debug_cmd
   568: 
   569:     eval "$1=\$$1\$2"
   570:   }
   571: fi
   572: 
   573: 
   574: # func_append_quoted VAR VALUE
   575: # ----------------------------
   576: # Quote VALUE and append to the end of shell variable VAR, separated
   577: # by a space.
   578: if test yes = "$_G_HAVE_PLUSEQ_OP"; then
   579:   eval 'func_append_quoted ()
   580:   {
   581:     $debug_cmd
   582: 
   583:     func_quote_for_eval "$2"
   584:     eval "$1+=\\ \$func_quote_for_eval_result"
   585:   }'
   586: else
   587:   func_append_quoted ()
   588:   {
   589:     $debug_cmd
   590: 
   591:     func_quote_for_eval "$2"
   592:     eval "$1=\$$1\\ \$func_quote_for_eval_result"
   593:   }
   594: fi
   595: 
   596: 
   597: # func_append_uniq VAR VALUE
   598: # --------------------------
   599: # Append unique VALUE onto the existing contents of VAR, assuming
   600: # entries are delimited by the first character of VALUE.  For example:
   601: #
   602: #   func_append_uniq options " --another-option option-argument"
   603: #
   604: # will only append to $options if " --another-option option-argument "
   605: # is not already present somewhere in $options already (note spaces at
   606: # each end implied by leading space in second argument).
   607: func_append_uniq ()
   608: {
   609:     $debug_cmd
   610: 
   611:     eval _G_current_value='`$ECHO $'$1'`'
   612:     _G_delim=`expr "$2" : '\(.\)'`
   613: 
   614:     case $_G_delim$_G_current_value$_G_delim in
   615:       *"$2$_G_delim"*) ;;
   616:       *) func_append "$@" ;;
   617:     esac
   618: }
   619: 
   620: 
   621: # func_arith TERM...
   622: # ------------------
   623: # Set func_arith_result to the result of evaluating TERMs.
   624:   test -z "$_G_HAVE_ARITH_OP" \
   625:     && (eval 'test 2 = $(( 1 + 1 ))') 2>/dev/null \
   626:     && _G_HAVE_ARITH_OP=yes
   627: 
   628: if test yes = "$_G_HAVE_ARITH_OP"; then
   629:   eval 'func_arith ()
   630:   {
   631:     $debug_cmd
   632: 
   633:     func_arith_result=$(( $* ))
   634:   }'
   635: else
   636:   func_arith ()
   637:   {
   638:     $debug_cmd
   639: 
   640:     func_arith_result=`expr "$@"`
   641:   }
   642: fi
   643: 
   644: 
   645: # func_basename FILE
   646: # ------------------
   647: # Set func_basename_result to FILE with everything up to and including
   648: # the last / stripped.
   649: if test yes = "$_G_HAVE_XSI_OPS"; then
   650:   # If this shell supports suffix pattern removal, then use it to avoid
   651:   # forking. Hide the definitions single quotes in case the shell chokes
   652:   # on unsupported syntax...
   653:   _b='func_basename_result=${1##*/}'
   654:   _d='case $1 in
   655:         */*) func_dirname_result=${1%/*}$2 ;;
   656:         *  ) func_dirname_result=$3        ;;
   657:       esac'
   658: 
   659: else
   660:   # ...otherwise fall back to using sed.
   661:   _b='func_basename_result=`$ECHO "$1" |$SED "$sed_basename"`'
   662:   _d='func_dirname_result=`$ECHO "$1"  |$SED "$sed_dirname"`
   663:       if test "X$func_dirname_result" = "X$1"; then
   664:         func_dirname_result=$3
   665:       else
   666:         func_append func_dirname_result "$2"
   667:       fi'
   668: fi
   669: 
   670: eval 'func_basename ()
   671: {
   672:     $debug_cmd
   673: 
   674:     '"$_b"'
   675: }'
   676: 
   677: 
   678: # func_dirname FILE APPEND NONDIR_REPLACEMENT
   679: # -------------------------------------------
   680: # Compute the dirname of FILE.  If nonempty, add APPEND to the result,
   681: # otherwise set result to NONDIR_REPLACEMENT.
   682: eval 'func_dirname ()
   683: {
   684:     $debug_cmd
   685: 
   686:     '"$_d"'
   687: }'
   688: 
   689: 
   690: # func_dirname_and_basename FILE APPEND NONDIR_REPLACEMENT
   691: # --------------------------------------------------------
   692: # Perform func_basename and func_dirname in a single function
   693: # call:
   694: #   dirname:  Compute the dirname of FILE.  If nonempty,
   695: #             add APPEND to the result, otherwise set result
   696: #             to NONDIR_REPLACEMENT.
   697: #             value returned in "$func_dirname_result"
   698: #   basename: Compute filename of FILE.
   699: #             value retuned in "$func_basename_result"
   700: # For efficiency, we do not delegate to the functions above but instead
   701: # duplicate the functionality here.
   702: eval 'func_dirname_and_basename ()
   703: {
   704:     $debug_cmd
   705: 
   706:     '"$_b"'
   707:     '"$_d"'
   708: }'
   709: 
   710: 
   711: # func_echo ARG...
   712: # ----------------
   713: # Echo program name prefixed message.
   714: func_echo ()
   715: {
   716:     $debug_cmd
   717: 
   718:     _G_message=$*
   719: 
   720:     func_echo_IFS=$IFS
   721:     IFS=$nl
   722:     for _G_line in $_G_message; do
   723:       IFS=$func_echo_IFS
   724:       $ECHO "$progname: $_G_line"
   725:     done
   726:     IFS=$func_echo_IFS
   727: }
   728: 
   729: 
   730: # func_echo_all ARG...
   731: # --------------------
   732: # Invoke $ECHO with all args, space-separated.
   733: func_echo_all ()
   734: {
   735:     $ECHO "$*"
   736: }
   737: 
   738: 
   739: # func_echo_infix_1 INFIX ARG...
   740: # ------------------------------
   741: # Echo program name, followed by INFIX on the first line, with any
   742: # additional lines not showing INFIX.
   743: func_echo_infix_1 ()
   744: {
   745:     $debug_cmd
   746: 
   747:     $require_term_colors
   748: 
   749:     _G_infix=$1; shift
   750:     _G_indent=$_G_infix
   751:     _G_prefix="$progname: $_G_infix: "
   752:     _G_message=$*
   753: 
   754:     # Strip color escape sequences before counting printable length
   755:     for _G_tc in "$tc_reset" "$tc_bold" "$tc_standout" "$tc_red" "$tc_green" "$tc_blue" "$tc_cyan"
   756:     do
   757:       test -n "$_G_tc" && {
   758:         _G_esc_tc=`$ECHO "$_G_tc" | $SED "$sed_make_literal_regex"`
   759:         _G_indent=`$ECHO "$_G_indent" | $SED "s|$_G_esc_tc||g"`
   760:       }
   761:     done
   762:     _G_indent="$progname: "`echo "$_G_indent" | $SED 's|.| |g'`"  " ## exclude from sc_prohibit_nested_quotes
   763: 
   764:     func_echo_infix_1_IFS=$IFS
   765:     IFS=$nl
   766:     for _G_line in $_G_message; do
   767:       IFS=$func_echo_infix_1_IFS
   768:       $ECHO "$_G_prefix$tc_bold$_G_line$tc_reset" >&2
   769:       _G_prefix=$_G_indent
   770:     done
   771:     IFS=$func_echo_infix_1_IFS
   772: }
   773: 
   774: 
   775: # func_error ARG...
   776: # -----------------
   777: # Echo program name prefixed message to standard error.
   778: func_error ()
   779: {
   780:     $debug_cmd
   781: 
   782:     $require_term_colors
   783: 
   784:     func_echo_infix_1 "  $tc_standout${tc_red}error$tc_reset" "$*" >&2
   785: }
   786: 
   787: 
   788: # func_fatal_error ARG...
   789: # -----------------------
   790: # Echo program name prefixed message to standard error, and exit.
   791: func_fatal_error ()
   792: {
   793:     $debug_cmd
   794: 
   795:     func_error "$*"
   796:     exit $EXIT_FAILURE
   797: }
   798: 
   799: 
   800: # func_grep EXPRESSION FILENAME
   801: # -----------------------------
   802: # Check whether EXPRESSION matches any line of FILENAME, without output.
   803: func_grep ()
   804: {
   805:     $debug_cmd
   806: 
   807:     $GREP "$1" "$2" >/dev/null 2>&1
   808: }
   809: 
   810: 
   811: # func_len STRING
   812: # ---------------
   813: # Set func_len_result to the length of STRING. STRING may not
   814: # start with a hyphen.
   815:   test -z "$_G_HAVE_XSI_OPS" \
   816:     && (eval 'x=a/b/c;
   817:       test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
   818:     && _G_HAVE_XSI_OPS=yes
   819: 
   820: if test yes = "$_G_HAVE_XSI_OPS"; then
   821:   eval 'func_len ()
   822:   {
   823:     $debug_cmd
   824: 
   825:     func_len_result=${#1}
   826:   }'
   827: else
   828:   func_len ()
   829:   {
   830:     $debug_cmd
   831: 
   832:     func_len_result=`expr "$1" : ".*" 2>/dev/null || echo $max_cmd_len`
   833:   }
   834: fi
   835: 
   836: 
   837: # func_mkdir_p DIRECTORY-PATH
   838: # ---------------------------
   839: # Make sure the entire path to DIRECTORY-PATH is available.
   840: func_mkdir_p ()
   841: {
   842:     $debug_cmd
   843: 
   844:     _G_directory_path=$1
   845:     _G_dir_list=
   846: 
   847:     if test -n "$_G_directory_path" && test : != "$opt_dry_run"; then
   848: 
   849:       # Protect directory names starting with '-'
   850:       case $_G_directory_path in
   851:         -*) _G_directory_path=./$_G_directory_path ;;
   852:       esac
   853: 
   854:       # While some portion of DIR does not yet exist...
   855:       while test ! -d "$_G_directory_path"; do
   856:         # ...make a list in topmost first order.  Use a colon delimited
   857: 	# list incase some portion of path contains whitespace.
   858:         _G_dir_list=$_G_directory_path:$_G_dir_list
   859: 
   860:         # If the last portion added has no slash in it, the list is done
   861:         case $_G_directory_path in */*) ;; *) break ;; esac
   862: 
   863:         # ...otherwise throw away the child directory and loop
   864:         _G_directory_path=`$ECHO "$_G_directory_path" | $SED -e "$sed_dirname"`
   865:       done
   866:       _G_dir_list=`$ECHO "$_G_dir_list" | $SED 's|:*$||'`
   867: 
   868:       func_mkdir_p_IFS=$IFS; IFS=:
   869:       for _G_dir in $_G_dir_list; do
   870: 	IFS=$func_mkdir_p_IFS
   871:         # mkdir can fail with a 'File exist' error if two processes
   872:         # try to create one of the directories concurrently.  Don't
   873:         # stop in that case!
   874:         $MKDIR "$_G_dir" 2>/dev/null || :
   875:       done
   876:       IFS=$func_mkdir_p_IFS
   877: 
   878:       # Bail out if we (or some other process) failed to create a directory.
   879:       test -d "$_G_directory_path" || \
   880:         func_fatal_error "Failed to create '$1'"
   881:     fi
   882: }
   883: 
   884: 
   885: # func_mktempdir [BASENAME]
   886: # -------------------------
   887: # Make a temporary directory that won't clash with other running
   888: # libtool processes, and avoids race conditions if possible.  If
   889: # given, BASENAME is the basename for that directory.
   890: func_mktempdir ()
   891: {
   892:     $debug_cmd
   893: 
   894:     _G_template=${TMPDIR-/tmp}/${1-$progname}
   895: 
   896:     if test : = "$opt_dry_run"; then
   897:       # Return a directory name, but don't create it in dry-run mode
   898:       _G_tmpdir=$_G_template-$$
   899:     else
   900: 
   901:       # If mktemp works, use that first and foremost
   902:       _G_tmpdir=`mktemp -d "$_G_template-XXXXXXXX" 2>/dev/null`
   903: 
   904:       if test ! -d "$_G_tmpdir"; then
   905:         # Failing that, at least try and use $RANDOM to avoid a race
   906:         _G_tmpdir=$_G_template-${RANDOM-0}$$
   907: 
   908:         func_mktempdir_umask=`umask`
   909:         umask 0077
   910:         $MKDIR "$_G_tmpdir"
   911:         umask $func_mktempdir_umask
   912:       fi
   913: 
   914:       # If we're not in dry-run mode, bomb out on failure
   915:       test -d "$_G_tmpdir" || \
   916:         func_fatal_error "cannot create temporary directory '$_G_tmpdir'"
   917:     fi
   918: 
   919:     $ECHO "$_G_tmpdir"
   920: }
   921: 
   922: 
   923: # func_normal_abspath PATH
   924: # ------------------------
   925: # Remove doubled-up and trailing slashes, "." path components,
   926: # and cancel out any ".." path components in PATH after making
   927: # it an absolute path.
   928: func_normal_abspath ()
   929: {
   930:     $debug_cmd
   931: 
   932:     # These SED scripts presuppose an absolute path with a trailing slash.
   933:     _G_pathcar='s|^/\([^/]*\).*$|\1|'
   934:     _G_pathcdr='s|^/[^/]*||'
   935:     _G_removedotparts=':dotsl
   936: 		s|/\./|/|g
   937: 		t dotsl
   938: 		s|/\.$|/|'
   939:     _G_collapseslashes='s|/\{1,\}|/|g'
   940:     _G_finalslash='s|/*$|/|'
   941: 
   942:     # Start from root dir and reassemble the path.
   943:     func_normal_abspath_result=
   944:     func_normal_abspath_tpath=$1
   945:     func_normal_abspath_altnamespace=
   946:     case $func_normal_abspath_tpath in
   947:       "")
   948:         # Empty path, that just means $cwd.
   949:         func_stripname '' '/' "`pwd`"
   950:         func_normal_abspath_result=$func_stripname_result
   951:         return
   952:         ;;
   953:       # The next three entries are used to spot a run of precisely
   954:       # two leading slashes without using negated character classes;
   955:       # we take advantage of case's first-match behaviour.
   956:       ///*)
   957:         # Unusual form of absolute path, do nothing.
   958:         ;;
   959:       //*)
   960:         # Not necessarily an ordinary path; POSIX reserves leading '//'
   961:         # and for example Cygwin uses it to access remote file shares
   962:         # over CIFS/SMB, so we conserve a leading double slash if found.
   963:         func_normal_abspath_altnamespace=/
   964:         ;;
   965:       /*)
   966:         # Absolute path, do nothing.
   967:         ;;
   968:       *)
   969:         # Relative path, prepend $cwd.
   970:         func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
   971:         ;;
   972:     esac
   973: 
   974:     # Cancel out all the simple stuff to save iterations.  We also want
   975:     # the path to end with a slash for ease of parsing, so make sure
   976:     # there is one (and only one) here.
   977:     func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
   978:           -e "$_G_removedotparts" -e "$_G_collapseslashes" -e "$_G_finalslash"`
   979:     while :; do
   980:       # Processed it all yet?
   981:       if test / = "$func_normal_abspath_tpath"; then
   982:         # If we ascended to the root using ".." the result may be empty now.
   983:         if test -z "$func_normal_abspath_result"; then
   984:           func_normal_abspath_result=/
   985:         fi
   986:         break
   987:       fi
   988:       func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
   989:           -e "$_G_pathcar"`
   990:       func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
   991:           -e "$_G_pathcdr"`
   992:       # Figure out what to do with it
   993:       case $func_normal_abspath_tcomponent in
   994:         "")
   995:           # Trailing empty path component, ignore it.
   996:           ;;
   997:         ..)
   998:           # Parent dir; strip last assembled component from result.
   999:           func_dirname "$func_normal_abspath_result"
  1000:           func_normal_abspath_result=$func_dirname_result
  1001:           ;;
  1002:         *)
  1003:           # Actual path component, append it.
  1004:           func_append func_normal_abspath_result "/$func_normal_abspath_tcomponent"
  1005:           ;;
  1006:       esac
  1007:     done
  1008:     # Restore leading double-slash if one was found on entry.
  1009:     func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
  1010: }
  1011: 
  1012: 
  1013: # func_notquiet ARG...
  1014: # --------------------
  1015: # Echo program name prefixed message only when not in quiet mode.
  1016: func_notquiet ()
  1017: {
  1018:     $debug_cmd
  1019: 
  1020:     $opt_quiet || func_echo ${1+"$@"}
  1021: 
  1022:     # A bug in bash halts the script if the last line of a function
  1023:     # fails when set -e is in force, so we need another command to
  1024:     # work around that:
  1025:     :
  1026: }
  1027: 
  1028: 
  1029: # func_relative_path SRCDIR DSTDIR
  1030: # --------------------------------
  1031: # Set func_relative_path_result to the relative path from SRCDIR to DSTDIR.
  1032: func_relative_path ()
  1033: {
  1034:     $debug_cmd
  1035: 
  1036:     func_relative_path_result=
  1037:     func_normal_abspath "$1"
  1038:     func_relative_path_tlibdir=$func_normal_abspath_result
  1039:     func_normal_abspath "$2"
  1040:     func_relative_path_tbindir=$func_normal_abspath_result
  1041: 
  1042:     # Ascend the tree starting from libdir
  1043:     while :; do
  1044:       # check if we have found a prefix of bindir
  1045:       case $func_relative_path_tbindir in
  1046:         $func_relative_path_tlibdir)
  1047:           # found an exact match
  1048:           func_relative_path_tcancelled=
  1049:           break
  1050:           ;;
  1051:         $func_relative_path_tlibdir*)
  1052:           # found a matching prefix
  1053:           func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
  1054:           func_relative_path_tcancelled=$func_stripname_result
  1055:           if test -z "$func_relative_path_result"; then
  1056:             func_relative_path_result=.
  1057:           fi
  1058:           break
  1059:           ;;
  1060:         *)
  1061:           func_dirname $func_relative_path_tlibdir
  1062:           func_relative_path_tlibdir=$func_dirname_result
  1063:           if test -z "$func_relative_path_tlibdir"; then
  1064:             # Have to descend all the way to the root!
  1065:             func_relative_path_result=../$func_relative_path_result
  1066:             func_relative_path_tcancelled=$func_relative_path_tbindir
  1067:             break
  1068:           fi
  1069:           func_relative_path_result=../$func_relative_path_result
  1070:           ;;
  1071:       esac
  1072:     done
  1073: 
  1074:     # Now calculate path; take care to avoid doubling-up slashes.
  1075:     func_stripname '' '/' "$func_relative_path_result"
  1076:     func_relative_path_result=$func_stripname_result
  1077:     func_stripname '/' '/' "$func_relative_path_tcancelled"
  1078:     if test -n "$func_stripname_result"; then
  1079:       func_append func_relative_path_result "/$func_stripname_result"
  1080:     fi
  1081: 
  1082:     # Normalisation. If bindir is libdir, return '.' else relative path.
  1083:     if test -n "$func_relative_path_result"; then
  1084:       func_stripname './' '' "$func_relative_path_result"
  1085:       func_relative_path_result=$func_stripname_result
  1086:     fi
  1087: 
  1088:     test -n "$func_relative_path_result" || func_relative_path_result=.
  1089: 
  1090:     :
  1091: }
  1092: 
  1093: 
  1094: # func_quote_for_eval ARG...
  1095: # --------------------------
  1096: # Aesthetically quote ARGs to be evaled later.
  1097: # This function returns two values:
  1098: #   i) func_quote_for_eval_result
  1099: #      double-quoted, suitable for a subsequent eval
  1100: #  ii) func_quote_for_eval_unquoted_result
  1101: #      has all characters that are still active within double
  1102: #      quotes backslashified.
  1103: func_quote_for_eval ()
  1104: {
  1105:     $debug_cmd
  1106: 
  1107:     func_quote_for_eval_unquoted_result=
  1108:     func_quote_for_eval_result=
  1109:     while test 0 -lt $#; do
  1110:       case $1 in
  1111:         *[\\\`\"\$]*)
  1112: 	  _G_unquoted_arg=`printf '%s\n' "$1" |$SED "$sed_quote_subst"` ;;
  1113:         *)
  1114:           _G_unquoted_arg=$1 ;;
  1115:       esac
  1116:       if test -n "$func_quote_for_eval_unquoted_result"; then
  1117: 	func_append func_quote_for_eval_unquoted_result " $_G_unquoted_arg"
  1118:       else
  1119:         func_append func_quote_for_eval_unquoted_result "$_G_unquoted_arg"
  1120:       fi
  1121: 
  1122:       case $_G_unquoted_arg in
  1123:         # Double-quote args containing shell metacharacters to delay
  1124:         # word splitting, command substitution and variable expansion
  1125:         # for a subsequent eval.
  1126:         # Many Bourne shells cannot handle close brackets correctly
  1127:         # in scan sets, so we specify it separately.
  1128:         *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
  1129:           _G_quoted_arg=\"$_G_unquoted_arg\"
  1130:           ;;
  1131:         *)
  1132:           _G_quoted_arg=$_G_unquoted_arg
  1133: 	  ;;
  1134:       esac
  1135: 
  1136:       if test -n "$func_quote_for_eval_result"; then
  1137: 	func_append func_quote_for_eval_result " $_G_quoted_arg"
  1138:       else
  1139:         func_append func_quote_for_eval_result "$_G_quoted_arg"
  1140:       fi
  1141:       shift
  1142:     done
  1143: }
  1144: 
  1145: 
  1146: # func_quote_for_expand ARG
  1147: # -------------------------
  1148: # Aesthetically quote ARG to be evaled later; same as above,
  1149: # but do not quote variable references.
  1150: func_quote_for_expand ()
  1151: {
  1152:     $debug_cmd
  1153: 
  1154:     case $1 in
  1155:       *[\\\`\"]*)
  1156: 	_G_arg=`$ECHO "$1" | $SED \
  1157: 	    -e "$sed_double_quote_subst" -e "$sed_double_backslash"` ;;
  1158:       *)
  1159:         _G_arg=$1 ;;
  1160:     esac
  1161: 
  1162:     case $_G_arg in
  1163:       # Double-quote args containing shell metacharacters to delay
  1164:       # word splitting and command substitution for a subsequent eval.
  1165:       # Many Bourne shells cannot handle close brackets correctly
  1166:       # in scan sets, so we specify it separately.
  1167:       *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
  1168:         _G_arg=\"$_G_arg\"
  1169:         ;;
  1170:     esac
  1171: 
  1172:     func_quote_for_expand_result=$_G_arg
  1173: }
  1174: 
  1175: 
  1176: # func_stripname PREFIX SUFFIX NAME
  1177: # ---------------------------------
  1178: # strip PREFIX and SUFFIX from NAME, and store in func_stripname_result.
  1179: # PREFIX and SUFFIX must not contain globbing or regex special
  1180: # characters, hashes, percent signs, but SUFFIX may contain a leading
  1181: # dot (in which case that matches only a dot).
  1182: if test yes = "$_G_HAVE_XSI_OPS"; then
  1183:   eval 'func_stripname ()
  1184:   {
  1185:     $debug_cmd
  1186: 
  1187:     # pdksh 5.2.14 does not do ${X%$Y} correctly if both X and Y are
  1188:     # positional parameters, so assign one to ordinary variable first.
  1189:     func_stripname_result=$3
  1190:     func_stripname_result=${func_stripname_result#"$1"}
  1191:     func_stripname_result=${func_stripname_result%"$2"}
  1192:   }'
  1193: else
  1194:   func_stripname ()
  1195:   {
  1196:     $debug_cmd
  1197: 
  1198:     case $2 in
  1199:       .*) func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%\\\\$2\$%%"`;;
  1200:       *)  func_stripname_result=`$ECHO "$3" | $SED -e "s%^$1%%" -e "s%$2\$%%"`;;
  1201:     esac
  1202:   }
  1203: fi
  1204: 
  1205: 
  1206: # func_show_eval CMD [FAIL_EXP]
  1207: # -----------------------------
  1208: # Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
  1209: # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
  1210: # is given, then evaluate it.
  1211: func_show_eval ()
  1212: {
  1213:     $debug_cmd
  1214: 
  1215:     _G_cmd=$1
  1216:     _G_fail_exp=${2-':'}
  1217: 
  1218:     func_quote_for_expand "$_G_cmd"
  1219:     eval "func_notquiet $func_quote_for_expand_result"
  1220: 
  1221:     $opt_dry_run || {
  1222:       eval "$_G_cmd"
  1223:       _G_status=$?
  1224:       if test 0 -ne "$_G_status"; then
  1225: 	eval "(exit $_G_status); $_G_fail_exp"
  1226:       fi
  1227:     }
  1228: }
  1229: 
  1230: 
  1231: # func_show_eval_locale CMD [FAIL_EXP]
  1232: # ------------------------------------
  1233: # Unless opt_quiet is true, then output CMD.  Then, if opt_dryrun is
  1234: # not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
  1235: # is given, then evaluate it.  Use the saved locale for evaluation.
  1236: func_show_eval_locale ()
  1237: {
  1238:     $debug_cmd
  1239: 
  1240:     _G_cmd=$1
  1241:     _G_fail_exp=${2-':'}
  1242: 
  1243:     $opt_quiet || {
  1244:       func_quote_for_expand "$_G_cmd"
  1245:       eval "func_echo $func_quote_for_expand_result"
  1246:     }
  1247: 
  1248:     $opt_dry_run || {
  1249:       eval "$_G_user_locale
  1250: 	    $_G_cmd"
  1251:       _G_status=$?
  1252:       eval "$_G_safe_locale"
  1253:       if test 0 -ne "$_G_status"; then
  1254: 	eval "(exit $_G_status); $_G_fail_exp"
  1255:       fi
  1256:     }
  1257: }
  1258: 
  1259: 
  1260: # func_tr_sh
  1261: # ----------
  1262: # Turn $1 into a string suitable for a shell variable name.
  1263: # Result is stored in $func_tr_sh_result.  All characters
  1264: # not in the set a-zA-Z0-9_ are replaced with '_'. Further,
  1265: # if $1 begins with a digit, a '_' is prepended as well.
  1266: func_tr_sh ()
  1267: {
  1268:     $debug_cmd
  1269: 
  1270:     case $1 in
  1271:     [0-9]* | *[!a-zA-Z0-9_]*)
  1272:       func_tr_sh_result=`$ECHO "$1" | $SED -e 's/^\([0-9]\)/_\1/' -e 's/[^a-zA-Z0-9_]/_/g'`
  1273:       ;;
  1274:     * )
  1275:       func_tr_sh_result=$1
  1276:       ;;
  1277:     esac
  1278: }
  1279: 
  1280: 
  1281: # func_verbose ARG...
  1282: # -------------------
  1283: # Echo program name prefixed message in verbose mode only.
  1284: func_verbose ()
  1285: {
  1286:     $debug_cmd
  1287: 
  1288:     $opt_verbose && func_echo "$*"
  1289: 
  1290:     :
  1291: }
  1292: 
  1293: 
  1294: # func_warn_and_continue ARG...
  1295: # -----------------------------
  1296: # Echo program name prefixed warning message to standard error.
  1297: func_warn_and_continue ()
  1298: {
  1299:     $debug_cmd
  1300: 
  1301:     $require_term_colors
  1302: 
  1303:     func_echo_infix_1 "${tc_red}warning$tc_reset" "$*" >&2
  1304: }
  1305: 
  1306: 
  1307: # func_warning CATEGORY ARG...
  1308: # ----------------------------
  1309: # Echo program name prefixed warning message to standard error. Warning
  1310: # messages can be filtered according to CATEGORY, where this function
  1311: # elides messages where CATEGORY is not listed in the global variable
  1312: # 'opt_warning_types'.
  1313: func_warning ()
  1314: {
  1315:     $debug_cmd
  1316: 
  1317:     # CATEGORY must be in the warning_categories list!
  1318:     case " $warning_categories " in
  1319:       *" $1 "*) ;;
  1320:       *) func_internal_error "invalid warning category '$1'" ;;
  1321:     esac
  1322: 
  1323:     _G_category=$1
  1324:     shift
  1325: 
  1326:     case " $opt_warning_types " in
  1327:       *" $_G_category "*) $warning_func ${1+"$@"} ;;
  1328:     esac
  1329: }
  1330: 
  1331: 
  1332: # func_sort_ver VER1 VER2
  1333: # -----------------------
  1334: # 'sort -V' is not generally available.
  1335: # Note this deviates from the version comparison in automake
  1336: # in that it treats 1.5 < 1.5.0, and treats 1.4.4a < 1.4-p3a
  1337: # but this should suffice as we won't be specifying old
  1338: # version formats or redundant trailing .0 in bootstrap.conf.
  1339: # If we did want full compatibility then we should probably
  1340: # use m4_version_compare from autoconf.
  1341: func_sort_ver ()
  1342: {
  1343:     $debug_cmd
  1344: 
  1345:     printf '%s\n%s\n' "$1" "$2" \
  1346:       | sort -t. -k 1,1n -k 2,2n -k 3,3n -k 4,4n -k 5,5n -k 6,6n -k 7,7n -k 8,8n -k 9,9n
  1347: }
  1348: 
  1349: # func_lt_ver PREV CURR
  1350: # ---------------------
  1351: # Return true if PREV and CURR are in the correct order according to
  1352: # func_sort_ver, otherwise false.  Use it like this:
  1353: #
  1354: #  func_lt_ver "$prev_ver" "$proposed_ver" || func_fatal_error "..."
  1355: func_lt_ver ()
  1356: {
  1357:     $debug_cmd
  1358: 
  1359:     test "x$1" = x`func_sort_ver "$1" "$2" | $SED 1q`
  1360: }
  1361: 
  1362: 
  1363: # Local variables:
  1364: # mode: shell-script
  1365: # sh-indentation: 2
  1366: # eval: (add-hook 'before-save-hook 'time-stamp)
  1367: # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
  1368: # time-stamp-time-zone: "UTC"
  1369: # End:
  1370: #! /bin/sh
  1371: 
  1372: # Set a version string for this script.
  1373: scriptversion=2014-01-07.03; # UTC
  1374: 
  1375: # A portable, pluggable option parser for Bourne shell.
  1376: # Written by Gary V. Vaughan, 2010
  1377: 
  1378: # Copyright (C) 2010-2015 Free Software Foundation, Inc.
  1379: # This is free software; see the source for copying conditions.  There is NO
  1380: # warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  1381: 
  1382: # This program is free software: you can redistribute it and/or modify
  1383: # it under the terms of the GNU General Public License as published by
  1384: # the Free Software Foundation, either version 3 of the License, or
  1385: # (at your option) any later version.
  1386: 
  1387: # This program is distributed in the hope that it will be useful,
  1388: # but WITHOUT ANY WARRANTY; without even the implied warranty of
  1389: # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  1390: # GNU General Public License for more details.
  1391: 
  1392: # You should have received a copy of the GNU General Public License
  1393: # along with this program.  If not, see <http://www.gnu.org/licenses/>.
  1394: 
  1395: # Please report bugs or propose patches to gary@gnu.org.
  1396: 
  1397: 
  1398: ## ------ ##
  1399: ## Usage. ##
  1400: ## ------ ##
  1401: 
  1402: # This file is a library for parsing options in your shell scripts along
  1403: # with assorted other useful supporting features that you can make use
  1404: # of too.
  1405: #
  1406: # For the simplest scripts you might need only:
  1407: #
  1408: #   #!/bin/sh
  1409: #   . relative/path/to/funclib.sh
  1410: #   . relative/path/to/options-parser
  1411: #   scriptversion=1.0
  1412: #   func_options ${1+"$@"}
  1413: #   eval set dummy "$func_options_result"; shift
  1414: #   ...rest of your script...
  1415: #
  1416: # In order for the '--version' option to work, you will need to have a
  1417: # suitably formatted comment like the one at the top of this file
  1418: # starting with '# Written by ' and ending with '# warranty; '.
  1419: #
  1420: # For '-h' and '--help' to work, you will also need a one line
  1421: # description of your script's purpose in a comment directly above the
  1422: # '# Written by ' line, like the one at the top of this file.
  1423: #
  1424: # The default options also support '--debug', which will turn on shell
  1425: # execution tracing (see the comment above debug_cmd below for another
  1426: # use), and '--verbose' and the func_verbose function to allow your script
  1427: # to display verbose messages only when your user has specified
  1428: # '--verbose'.
  1429: #
  1430: # After sourcing this file, you can plug processing for additional
  1431: # options by amending the variables from the 'Configuration' section
  1432: # below, and following the instructions in the 'Option parsing'
  1433: # section further down.
  1434: 
  1435: ## -------------- ##
  1436: ## Configuration. ##
  1437: ## -------------- ##
  1438: 
  1439: # You should override these variables in your script after sourcing this
  1440: # file so that they reflect the customisations you have added to the
  1441: # option parser.
  1442: 
  1443: # The usage line for option parsing errors and the start of '-h' and
  1444: # '--help' output messages. You can embed shell variables for delayed
  1445: # expansion at the time the message is displayed, but you will need to
  1446: # quote other shell meta-characters carefully to prevent them being
  1447: # expanded when the contents are evaled.
  1448: usage='$progpath [OPTION]...'
  1449: 
  1450: # Short help message in response to '-h' and '--help'.  Add to this or
  1451: # override it after sourcing this library to reflect the full set of
  1452: # options your script accepts.
  1453: usage_message="\
  1454:        --debug        enable verbose shell tracing
  1455:    -W, --warnings=CATEGORY
  1456:                       report the warnings falling in CATEGORY [all]
  1457:    -v, --verbose      verbosely report processing
  1458:        --version      print version information and exit
  1459:    -h, --help         print short or long help message and exit
  1460: "
  1461: 
  1462: # Additional text appended to 'usage_message' in response to '--help'.
  1463: long_help_message="
  1464: Warning categories include:
  1465:        'all'          show all warnings
  1466:        'none'         turn off all the warnings
  1467:        'error'        warnings are treated as fatal errors"
  1468: 
  1469: # Help message printed before fatal option parsing errors.
  1470: fatal_help="Try '\$progname --help' for more information."
  1471: 
  1472: 
  1473: 
  1474: ## ------------------------- ##
  1475: ## Hook function management. ##
  1476: ## ------------------------- ##
  1477: 
  1478: # This section contains functions for adding, removing, and running hooks
  1479: # to the main code.  A hook is just a named list of of function, that can
  1480: # be run in order later on.
  1481: 
  1482: # func_hookable FUNC_NAME
  1483: # -----------------------
  1484: # Declare that FUNC_NAME will run hooks added with
  1485: # 'func_add_hook FUNC_NAME ...'.
  1486: func_hookable ()
  1487: {
  1488:     $debug_cmd
  1489: 
  1490:     func_append hookable_fns " $1"
  1491: }
  1492: 
  1493: 
  1494: # func_add_hook FUNC_NAME HOOK_FUNC
  1495: # ---------------------------------
  1496: # Request that FUNC_NAME call HOOK_FUNC before it returns.  FUNC_NAME must
  1497: # first have been declared "hookable" by a call to 'func_hookable'.
  1498: func_add_hook ()
  1499: {
  1500:     $debug_cmd
  1501: 
  1502:     case " $hookable_fns " in
  1503:       *" $1 "*) ;;
  1504:       *) func_fatal_error "'$1' does not accept hook functions." ;;
  1505:     esac
  1506: 
  1507:     eval func_append ${1}_hooks '" $2"'
  1508: }
  1509: 
  1510: 
  1511: # func_remove_hook FUNC_NAME HOOK_FUNC
  1512: # ------------------------------------
  1513: # Remove HOOK_FUNC from the list of functions called by FUNC_NAME.
  1514: func_remove_hook ()
  1515: {
  1516:     $debug_cmd
  1517: 
  1518:     eval ${1}_hooks='`$ECHO "\$'$1'_hooks" |$SED "s| '$2'||"`'
  1519: }
  1520: 
  1521: 
  1522: # func_run_hooks FUNC_NAME [ARG]...
  1523: # ---------------------------------
  1524: # Run all hook functions registered to FUNC_NAME.
  1525: # It is assumed that the list of hook functions contains nothing more
  1526: # than a whitespace-delimited list of legal shell function names, and
  1527: # no effort is wasted trying to catch shell meta-characters or preserve
  1528: # whitespace.
  1529: func_run_hooks ()
  1530: {
  1531:     $debug_cmd
  1532: 
  1533:     case " $hookable_fns " in
  1534:       *" $1 "*) ;;
  1535:       *) func_fatal_error "'$1' does not support hook funcions.n" ;;
  1536:     esac
  1537: 
  1538:     eval _G_hook_fns=\$$1_hooks; shift
  1539: 
  1540:     for _G_hook in $_G_hook_fns; do
  1541:       eval $_G_hook '"$@"'
  1542: 
  1543:       # store returned options list back into positional
  1544:       # parameters for next 'cmd' execution.
  1545:       eval _G_hook_result=\$${_G_hook}_result
  1546:       eval set dummy "$_G_hook_result"; shift
  1547:     done
  1548: 
  1549:     func_quote_for_eval ${1+"$@"}
  1550:     func_run_hooks_result=$func_quote_for_eval_result
  1551: }
  1552: 
  1553: 
  1554: 
  1555: ## --------------- ##
  1556: ## Option parsing. ##
  1557: ## --------------- ##
  1558: 
  1559: # In order to add your own option parsing hooks, you must accept the
  1560: # full positional parameter list in your hook function, remove any
  1561: # options that you action, and then pass back the remaining unprocessed
  1562: # options in '<hooked_function_name>_result', escaped suitably for
  1563: # 'eval'.  Like this:
  1564: #
  1565: #    my_options_prep ()
  1566: #    {
  1567: #        $debug_cmd
  1568: #
  1569: #        # Extend the existing usage message.
  1570: #        usage_message=$usage_message'
  1571: #      -s, --silent       don'\''t print informational messages
  1572: #    '
  1573: #
  1574: #        func_quote_for_eval ${1+"$@"}
  1575: #        my_options_prep_result=$func_quote_for_eval_result
  1576: #    }
  1577: #    func_add_hook func_options_prep my_options_prep
  1578: #
  1579: #
  1580: #    my_silent_option ()
  1581: #    {
  1582: #        $debug_cmd
  1583: #
  1584: #        # Note that for efficiency, we parse as many options as we can
  1585: #        # recognise in a loop before passing the remainder back to the
  1586: #        # caller on the first unrecognised argument we encounter.
  1587: #        while test $# -gt 0; do
  1588: #          opt=$1; shift
  1589: #          case $opt in
  1590: #            --silent|-s) opt_silent=: ;;
  1591: #            # Separate non-argument short options:
  1592: #            -s*)         func_split_short_opt "$_G_opt"
  1593: #                         set dummy "$func_split_short_opt_name" \
  1594: #                             "-$func_split_short_opt_arg" ${1+"$@"}
  1595: #                         shift
  1596: #                         ;;
  1597: #            *)            set dummy "$_G_opt" "$*"; shift; break ;;
  1598: #          esac
  1599: #        done
  1600: #
  1601: #        func_quote_for_eval ${1+"$@"}
  1602: #        my_silent_option_result=$func_quote_for_eval_result
  1603: #    }
  1604: #    func_add_hook func_parse_options my_silent_option
  1605: #
  1606: #
  1607: #    my_option_validation ()
  1608: #    {
  1609: #        $debug_cmd
  1610: #
  1611: #        $opt_silent && $opt_verbose && func_fatal_help "\
  1612: #    '--silent' and '--verbose' options are mutually exclusive."
  1613: #
  1614: #        func_quote_for_eval ${1+"$@"}
  1615: #        my_option_validation_result=$func_quote_for_eval_result
  1616: #    }
  1617: #    func_add_hook func_validate_options my_option_validation
  1618: #
  1619: # You'll alse need to manually amend $usage_message to reflect the extra
  1620: # options you parse.  It's preferable to append if you can, so that
  1621: # multiple option parsing hooks can be added safely.
  1622: 
  1623: 
  1624: # func_options [ARG]...
  1625: # ---------------------
  1626: # All the functions called inside func_options are hookable. See the
  1627: # individual implementations for details.
  1628: func_hookable func_options
  1629: func_options ()
  1630: {
  1631:     $debug_cmd
  1632: 
  1633:     func_options_prep ${1+"$@"}
  1634:     eval func_parse_options \
  1635:         ${func_options_prep_result+"$func_options_prep_result"}
  1636:     eval func_validate_options \
  1637:         ${func_parse_options_result+"$func_parse_options_result"}
  1638: 
  1639:     eval func_run_hooks func_options \
  1640:         ${func_validate_options_result+"$func_validate_options_result"}
  1641: 
  1642:     # save modified positional parameters for caller
  1643:     func_options_result=$func_run_hooks_result
  1644: }
  1645: 
  1646: 
  1647: # func_options_prep [ARG]...
  1648: # --------------------------
  1649: # All initialisations required before starting the option parse loop.
  1650: # Note that when calling hook functions, we pass through the list of
  1651: # positional parameters.  If a hook function modifies that list, and
  1652: # needs to propogate that back to rest of this script, then the complete
  1653: # modified list must be put in 'func_run_hooks_result' before
  1654: # returning.
  1655: func_hookable func_options_prep
  1656: func_options_prep ()
  1657: {
  1658:     $debug_cmd
  1659: 
  1660:     # Option defaults:
  1661:     opt_verbose=false
  1662:     opt_warning_types=
  1663: 
  1664:     func_run_hooks func_options_prep ${1+"$@"}
  1665: 
  1666:     # save modified positional parameters for caller
  1667:     func_options_prep_result=$func_run_hooks_result
  1668: }
  1669: 
  1670: 
  1671: # func_parse_options [ARG]...
  1672: # ---------------------------
  1673: # The main option parsing loop.
  1674: func_hookable func_parse_options
  1675: func_parse_options ()
  1676: {
  1677:     $debug_cmd
  1678: 
  1679:     func_parse_options_result=
  1680: 
  1681:     # this just eases exit handling
  1682:     while test $# -gt 0; do
  1683:       # Defer to hook functions for initial option parsing, so they
  1684:       # get priority in the event of reusing an option name.
  1685:       func_run_hooks func_parse_options ${1+"$@"}
  1686: 
  1687:       # Adjust func_parse_options positional parameters to match
  1688:       eval set dummy "$func_run_hooks_result"; shift
  1689: 
  1690:       # Break out of the loop if we already parsed every option.
  1691:       test $# -gt 0 || break
  1692: 
  1693:       _G_opt=$1
  1694:       shift
  1695:       case $_G_opt in
  1696:         --debug|-x)   debug_cmd='set -x'
  1697:                       func_echo "enabling shell trace mode"
  1698:                       $debug_cmd
  1699:                       ;;
  1700: 
  1701:         --no-warnings|--no-warning|--no-warn)
  1702:                       set dummy --warnings none ${1+"$@"}
  1703:                       shift
  1704: 		      ;;
  1705: 
  1706:         --warnings|--warning|-W)
  1707:                       test $# = 0 && func_missing_arg $_G_opt && break
  1708:                       case " $warning_categories $1" in
  1709:                         *" $1 "*)
  1710:                           # trailing space prevents matching last $1 above
  1711:                           func_append_uniq opt_warning_types " $1"
  1712:                           ;;
  1713:                         *all)
  1714:                           opt_warning_types=$warning_categories
  1715:                           ;;
  1716:                         *none)
  1717:                           opt_warning_types=none
  1718:                           warning_func=:
  1719:                           ;;
  1720:                         *error)
  1721:                           opt_warning_types=$warning_categories
  1722:                           warning_func=func_fatal_error
  1723:                           ;;
  1724:                         *)
  1725:                           func_fatal_error \
  1726:                              "unsupported warning category: '$1'"
  1727:                           ;;
  1728:                       esac
  1729:                       shift
  1730:                       ;;
  1731: 
  1732:         --verbose|-v) opt_verbose=: ;;
  1733:         --version)    func_version ;;
  1734:         -\?|-h)       func_usage ;;
  1735:         --help)       func_help ;;
  1736: 
  1737: 	# Separate optargs to long options (plugins may need this):
  1738: 	--*=*)        func_split_equals "$_G_opt"
  1739: 	              set dummy "$func_split_equals_lhs" \
  1740:                           "$func_split_equals_rhs" ${1+"$@"}
  1741:                       shift
  1742:                       ;;
  1743: 
  1744:        # Separate optargs to short options:
  1745:         -W*)
  1746:                       func_split_short_opt "$_G_opt"
  1747:                       set dummy "$func_split_short_opt_name" \
  1748:                           "$func_split_short_opt_arg" ${1+"$@"}
  1749:                       shift
  1750:                       ;;
  1751: 
  1752:         # Separate non-argument short options:
  1753:         -\?*|-h*|-v*|-x*)
  1754:                       func_split_short_opt "$_G_opt"
  1755:                       set dummy "$func_split_short_opt_name" \
  1756:                           "-$func_split_short_opt_arg" ${1+"$@"}
  1757:                       shift
  1758:                       ;;
  1759: 
  1760:         --)           break ;;
  1761:         -*)           func_fatal_help "unrecognised option: '$_G_opt'" ;;
  1762:         *)            set dummy "$_G_opt" ${1+"$@"}; shift; break ;;
  1763:       esac
  1764:     done
  1765: 
  1766:     # save modified positional parameters for caller
  1767:     func_quote_for_eval ${1+"$@"}
  1768:     func_parse_options_result=$func_quote_for_eval_result
  1769: }
  1770: 
  1771: 
  1772: # func_validate_options [ARG]...
  1773: # ------------------------------
  1774: # Perform any sanity checks on option settings and/or unconsumed
  1775: # arguments.
  1776: func_hookable func_validate_options
  1777: func_validate_options ()
  1778: {
  1779:     $debug_cmd
  1780: 
  1781:     # Display all warnings if -W was not given.
  1782:     test -n "$opt_warning_types" || opt_warning_types=" $warning_categories"
  1783: 
  1784:     func_run_hooks func_validate_options ${1+"$@"}
  1785: 
  1786:     # Bail if the options were screwed!
  1787:     $exit_cmd $EXIT_FAILURE
  1788: 
  1789:     # save modified positional parameters for caller
  1790:     func_validate_options_result=$func_run_hooks_result
  1791: }
  1792: 
  1793: 
  1794: 
  1795: ## ----------------- ##
  1796: ## Helper functions. ##
  1797: ## ----------------- ##
  1798: 
  1799: # This section contains the helper functions used by the rest of the
  1800: # hookable option parser framework in ascii-betical order.
  1801: 
  1802: 
  1803: # func_fatal_help ARG...
  1804: # ----------------------
  1805: # Echo program name prefixed message to standard error, followed by
  1806: # a help hint, and exit.
  1807: func_fatal_help ()
  1808: {
  1809:     $debug_cmd
  1810: 
  1811:     eval \$ECHO \""Usage: $usage"\"
  1812:     eval \$ECHO \""$fatal_help"\"
  1813:     func_error ${1+"$@"}
  1814:     exit $EXIT_FAILURE
  1815: }
  1816: 
  1817: 
  1818: # func_help
  1819: # ---------
  1820: # Echo long help message to standard output and exit.
  1821: func_help ()
  1822: {
  1823:     $debug_cmd
  1824: 
  1825:     func_usage_message
  1826:     $ECHO "$long_help_message"
  1827:     exit 0
  1828: }
  1829: 
  1830: 
  1831: # func_missing_arg ARGNAME
  1832: # ------------------------
  1833: # Echo program name prefixed message to standard error and set global
  1834: # exit_cmd.
  1835: func_missing_arg ()
  1836: {
  1837:     $debug_cmd
  1838: 
  1839:     func_error "Missing argument for '$1'."
  1840:     exit_cmd=exit
  1841: }
  1842: 
  1843: 
  1844: # func_split_equals STRING
  1845: # ------------------------
  1846: # Set func_split_equals_lhs and func_split_equals_rhs shell variables after
  1847: # splitting STRING at the '=' sign.
  1848: test -z "$_G_HAVE_XSI_OPS" \
  1849:     && (eval 'x=a/b/c;
  1850:       test 5aa/bb/cc = "${#x}${x%%/*}${x%/*}${x#*/}${x##*/}"') 2>/dev/null \
  1851:     && _G_HAVE_XSI_OPS=yes
  1852: 
  1853: if test yes = "$_G_HAVE_XSI_OPS"
  1854: then
  1855:   # This is an XSI compatible shell, allowing a faster implementation...
  1856:   eval 'func_split_equals ()
  1857:   {
  1858:       $debug_cmd
  1859: 
  1860:       func_split_equals_lhs=${1%%=*}
  1861:       func_split_equals_rhs=${1#*=}
  1862:       test "x$func_split_equals_lhs" = "x$1" \
  1863:         && func_split_equals_rhs=
  1864:   }'
  1865: else
  1866:   # ...otherwise fall back to using expr, which is often a shell builtin.
  1867:   func_split_equals ()
  1868:   {
  1869:       $debug_cmd
  1870: 
  1871:       func_split_equals_lhs=`expr "x$1" : 'x\([^=]*\)'`
  1872:       func_split_equals_rhs=
  1873:       test "x$func_split_equals_lhs" = "x$1" \
  1874:         || func_split_equals_rhs=`expr "x$1" : 'x[^=]*=\(.*\)$'`
  1875:   }
  1876: fi #func_split_equals
  1877: 
  1878: 
  1879: # func_split_short_opt SHORTOPT
  1880: # -----------------------------
  1881: # Set func_split_short_opt_name and func_split_short_opt_arg shell
  1882: # variables after splitting SHORTOPT after the 2nd character.
  1883: if test yes = "$_G_HAVE_XSI_OPS"
  1884: then
  1885:   # This is an XSI compatible shell, allowing a faster implementation...
  1886:   eval 'func_split_short_opt ()
  1887:   {
  1888:       $debug_cmd
  1889: 
  1890:       func_split_short_opt_arg=${1#??}
  1891:       func_split_short_opt_name=${1%"$func_split_short_opt_arg"}
  1892:   }'
  1893: else
  1894:   # ...otherwise fall back to using expr, which is often a shell builtin.
  1895:   func_split_short_opt ()
  1896:   {
  1897:       $debug_cmd
  1898: 
  1899:       func_split_short_opt_name=`expr "x$1" : 'x-\(.\)'`
  1900:       func_split_short_opt_arg=`expr "x$1" : 'x-.\(.*\)$'`
  1901:   }
  1902: fi #func_split_short_opt
  1903: 
  1904: 
  1905: # func_usage
  1906: # ----------
  1907: # Echo short help message to standard output and exit.
  1908: func_usage ()
  1909: {
  1910:     $debug_cmd
  1911: 
  1912:     func_usage_message
  1913:     $ECHO "Run '$progname --help |${PAGER-more}' for full usage"
  1914:     exit 0
  1915: }
  1916: 
  1917: 
  1918: # func_usage_message
  1919: # ------------------
  1920: # Echo short help message to standard output.
  1921: func_usage_message ()
  1922: {
  1923:     $debug_cmd
  1924: 
  1925:     eval \$ECHO \""Usage: $usage"\"
  1926:     echo
  1927:     $SED -n 's|^# ||
  1928:         /^Written by/{
  1929:           x;p;x
  1930:         }
  1931: 	h
  1932: 	/^Written by/q' < "$progpath"
  1933:     echo
  1934:     eval \$ECHO \""$usage_message"\"
  1935: }
  1936: 
  1937: 
  1938: # func_version
  1939: # ------------
  1940: # Echo version message to standard output and exit.
  1941: func_version ()
  1942: {
  1943:     $debug_cmd
  1944: 
  1945:     printf '%s\n' "$progname $scriptversion"
  1946:     $SED -n '
  1947:         /(C)/!b go
  1948:         :more
  1949:         /\./!{
  1950:           N
  1951:           s|\n# | |
  1952:           b more
  1953:         }
  1954:         :go
  1955:         /^# Written by /,/# warranty; / {
  1956:           s|^# ||
  1957:           s|^# *$||
  1958:           s|\((C)\)[ 0-9,-]*[ ,-]\([1-9][0-9]* \)|\1 \2|
  1959:           p
  1960:         }
  1961:         /^# Written by / {
  1962:           s|^# ||
  1963:           p
  1964:         }
  1965:         /^warranty; /q' < "$progpath"
  1966: 
  1967:     exit $?
  1968: }
  1969: 
  1970: 
  1971: # Local variables:
  1972: # mode: shell-script
  1973: # sh-indentation: 2
  1974: # eval: (add-hook 'before-save-hook 'time-stamp)
  1975: # time-stamp-pattern: "10/scriptversion=%:y-%02m-%02d.%02H; # UTC"
  1976: # time-stamp-time-zone: "UTC"
  1977: # End:
  1978: 
  1979: # Set a version string.
  1980: scriptversion='(GNU libtool) 2.4.6'
  1981: 
  1982: 
  1983: # func_echo ARG...
  1984: # ----------------
  1985: # Libtool also displays the current mode in messages, so override
  1986: # funclib.sh func_echo with this custom definition.
  1987: func_echo ()
  1988: {
  1989:     $debug_cmd
  1990: 
  1991:     _G_message=$*
  1992: 
  1993:     func_echo_IFS=$IFS
  1994:     IFS=$nl
  1995:     for _G_line in $_G_message; do
  1996:       IFS=$func_echo_IFS
  1997:       $ECHO "$progname${opt_mode+: $opt_mode}: $_G_line"
  1998:     done
  1999:     IFS=$func_echo_IFS
  2000: }
  2001: 
  2002: 
  2003: # func_warning ARG...
  2004: # -------------------
  2005: # Libtool warnings are not categorized, so override funclib.sh
  2006: # func_warning with this simpler definition.
  2007: func_warning ()
  2008: {
  2009:     $debug_cmd
  2010: 
  2011:     $warning_func ${1+"$@"}
  2012: }
  2013: 
  2014: 
  2015: ## ---------------- ##
  2016: ## Options parsing. ##
  2017: ## ---------------- ##
  2018: 
  2019: # Hook in the functions to make sure our own options are parsed during
  2020: # the option parsing loop.
  2021: 
  2022: usage='$progpath [OPTION]... [MODE-ARG]...'
  2023: 
  2024: # Short help message in response to '-h'.
  2025: usage_message="Options:
  2026:        --config             show all configuration variables
  2027:        --debug              enable verbose shell tracing
  2028:    -n, --dry-run            display commands without modifying any files
  2029:        --features           display basic configuration information and exit
  2030:        --mode=MODE          use operation mode MODE
  2031:        --no-warnings        equivalent to '-Wnone'
  2032:        --preserve-dup-deps  don't remove duplicate dependency libraries
  2033:        --quiet, --silent    don't print informational messages
  2034:        --tag=TAG            use configuration variables from tag TAG
  2035:    -v, --verbose            print more informational messages than default
  2036:        --version            print version information
  2037:    -W, --warnings=CATEGORY  report the warnings falling in CATEGORY [all]
  2038:    -h, --help, --help-all   print short, long, or detailed help message
  2039: "
  2040: 
  2041: # Additional text appended to 'usage_message' in response to '--help'.
  2042: func_help ()
  2043: {
  2044:     $debug_cmd
  2045: 
  2046:     func_usage_message
  2047:     $ECHO "$long_help_message
  2048: 
  2049: MODE must be one of the following:
  2050: 
  2051:        clean           remove files from the build directory
  2052:        compile         compile a source file into a libtool object
  2053:        execute         automatically set library path, then run a program
  2054:        finish          complete the installation of libtool libraries
  2055:        install         install libraries or executables
  2056:        link            create a library or an executable
  2057:        uninstall       remove libraries from an installed directory
  2058: 
  2059: MODE-ARGS vary depending on the MODE.  When passed as first option,
  2060: '--mode=MODE' may be abbreviated as 'MODE' or a unique abbreviation of that.
  2061: Try '$progname --help --mode=MODE' for a more detailed description of MODE.
  2062: 
  2063: When reporting a bug, please describe a test case to reproduce it and
  2064: include the following information:
  2065: 
  2066:        host-triplet:   $host
  2067:        shell:          $SHELL
  2068:        compiler:       $LTCC
  2069:        compiler flags: $LTCFLAGS
  2070:        linker:         $LD (gnu? $with_gnu_ld)
  2071:        version:        $progname (GNU libtool) 2.4.6
  2072:        automake:       `($AUTOMAKE --version) 2>/dev/null |$SED 1q`
  2073:        autoconf:       `($AUTOCONF --version) 2>/dev/null |$SED 1q`
  2074: 
  2075: Report bugs to <bug-libtool@gnu.org>.
  2076: GNU libtool home page: <http://www.gnu.org/software/libtool/>.
  2077: General help using GNU software: <http://www.gnu.org/gethelp/>."
  2078:     exit 0
  2079: }
  2080: 
  2081: 
  2082: # func_lo2o OBJECT-NAME
  2083: # ---------------------
  2084: # Transform OBJECT-NAME from a '.lo' suffix to the platform specific
  2085: # object suffix.
  2086: 
  2087: lo2o=s/\\.lo\$/.$objext/
  2088: o2lo=s/\\.$objext\$/.lo/
  2089: 
  2090: if test yes = "$_G_HAVE_XSI_OPS"; then
  2091:   eval 'func_lo2o ()
  2092:   {
  2093:     case $1 in
  2094:       *.lo) func_lo2o_result=${1%.lo}.$objext ;;
  2095:       *   ) func_lo2o_result=$1               ;;
  2096:     esac
  2097:   }'
  2098: 
  2099:   # func_xform LIBOBJ-OR-SOURCE
  2100:   # ---------------------------
  2101:   # Transform LIBOBJ-OR-SOURCE from a '.o' or '.c' (or otherwise)
  2102:   # suffix to a '.lo' libtool-object suffix.
  2103:   eval 'func_xform ()
  2104:   {
  2105:     func_xform_result=${1%.*}.lo
  2106:   }'
  2107: else
  2108:   # ...otherwise fall back to using sed.
  2109:   func_lo2o ()
  2110:   {
  2111:     func_lo2o_result=`$ECHO "$1" | $SED "$lo2o"`
  2112:   }
  2113: 
  2114:   func_xform ()
  2115:   {
  2116:     func_xform_result=`$ECHO "$1" | $SED 's|\.[^.]*$|.lo|'`
  2117:   }
  2118: fi
  2119: 
  2120: 
  2121: # func_fatal_configuration ARG...
  2122: # -------------------------------
  2123: # Echo program name prefixed message to standard error, followed by
  2124: # a configuration failure hint, and exit.
  2125: func_fatal_configuration ()
  2126: {
  2127:     func__fatal_error ${1+"$@"} \
  2128:       "See the $PACKAGE documentation for more information." \
  2129:       "Fatal configuration error."
  2130: }
  2131: 
  2132: 
  2133: # func_config
  2134: # -----------
  2135: # Display the configuration for all the tags in this script.
  2136: func_config ()
  2137: {
  2138:     re_begincf='^# ### BEGIN LIBTOOL'
  2139:     re_endcf='^# ### END LIBTOOL'
  2140: 
  2141:     # Default configuration.
  2142:     $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
  2143: 
  2144:     # Now print the configurations for the tags.
  2145:     for tagname in $taglist; do
  2146:       $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
  2147:     done
  2148: 
  2149:     exit $?
  2150: }
  2151: 
  2152: 
  2153: # func_features
  2154: # -------------
  2155: # Display the features supported by this script.
  2156: func_features ()
  2157: {
  2158:     echo "host: $host"
  2159:     if test yes = "$build_libtool_libs"; then
  2160:       echo "enable shared libraries"
  2161:     else
  2162:       echo "disable shared libraries"
  2163:     fi
  2164:     if test yes = "$build_old_libs"; then
  2165:       echo "enable static libraries"
  2166:     else
  2167:       echo "disable static libraries"
  2168:     fi
  2169: 
  2170:     exit $?
  2171: }
  2172: 
  2173: 
  2174: # func_enable_tag TAGNAME
  2175: # -----------------------
  2176: # Verify that TAGNAME is valid, and either flag an error and exit, or
  2177: # enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
  2178: # variable here.
  2179: func_enable_tag ()
  2180: {
  2181:     # Global variable:
  2182:     tagname=$1
  2183: 
  2184:     re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
  2185:     re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
  2186:     sed_extractcf=/$re_begincf/,/$re_endcf/p
  2187: 
  2188:     # Validate tagname.
  2189:     case $tagname in
  2190:       *[!-_A-Za-z0-9,/]*)
  2191:         func_fatal_error "invalid tag name: $tagname"
  2192:         ;;
  2193:     esac
  2194: 
  2195:     # Don't test for the "default" C tag, as we know it's
  2196:     # there but not specially marked.
  2197:     case $tagname in
  2198:         CC) ;;
  2199:     *)
  2200:         if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
  2201: 	  taglist="$taglist $tagname"
  2202: 
  2203: 	  # Evaluate the configuration.  Be careful to quote the path
  2204: 	  # and the sed script, to avoid splitting on whitespace, but
  2205: 	  # also don't use non-portable quotes within backquotes within
  2206: 	  # quotes we have to do it in 2 steps:
  2207: 	  extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
  2208: 	  eval "$extractedcf"
  2209:         else
  2210: 	  func_error "ignoring unknown tag $tagname"
  2211:         fi
  2212:         ;;
  2213:     esac
  2214: }
  2215: 
  2216: 
  2217: # func_check_version_match
  2218: # ------------------------
  2219: # Ensure that we are using m4 macros, and libtool script from the same
  2220: # release of libtool.
  2221: func_check_version_match ()
  2222: {
  2223:     if test "$package_revision" != "$macro_revision"; then
  2224:       if test "$VERSION" != "$macro_version"; then
  2225:         if test -z "$macro_version"; then
  2226:           cat >&2 <<_LT_EOF
  2227: $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
  2228: $progname: definition of this LT_INIT comes from an older release.
  2229: $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
  2230: $progname: and run autoconf again.
  2231: _LT_EOF
  2232:         else
  2233:           cat >&2 <<_LT_EOF
  2234: $progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
  2235: $progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
  2236: $progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
  2237: $progname: and run autoconf again.
  2238: _LT_EOF
  2239:         fi
  2240:       else
  2241:         cat >&2 <<_LT_EOF
  2242: $progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
  2243: $progname: but the definition of this LT_INIT comes from revision $macro_revision.
  2244: $progname: You should recreate aclocal.m4 with macros from revision $package_revision
  2245: $progname: of $PACKAGE $VERSION and run autoconf again.
  2246: _LT_EOF
  2247:       fi
  2248: 
  2249:       exit $EXIT_MISMATCH
  2250:     fi
  2251: }
  2252: 
  2253: 
  2254: # libtool_options_prep [ARG]...
  2255: # -----------------------------
  2256: # Preparation for options parsed by libtool.
  2257: libtool_options_prep ()
  2258: {
  2259:     $debug_mode
  2260: 
  2261:     # Option defaults:
  2262:     opt_config=false
  2263:     opt_dlopen=
  2264:     opt_dry_run=false
  2265:     opt_help=false
  2266:     opt_mode=
  2267:     opt_preserve_dup_deps=false
  2268:     opt_quiet=false
  2269: 
  2270:     nonopt=
  2271:     preserve_args=
  2272: 
  2273:     # Shorthand for --mode=foo, only valid as the first argument
  2274:     case $1 in
  2275:     clean|clea|cle|cl)
  2276:       shift; set dummy --mode clean ${1+"$@"}; shift
  2277:       ;;
  2278:     compile|compil|compi|comp|com|co|c)
  2279:       shift; set dummy --mode compile ${1+"$@"}; shift
  2280:       ;;
  2281:     execute|execut|execu|exec|exe|ex|e)
  2282:       shift; set dummy --mode execute ${1+"$@"}; shift
  2283:       ;;
  2284:     finish|finis|fini|fin|fi|f)
  2285:       shift; set dummy --mode finish ${1+"$@"}; shift
  2286:       ;;
  2287:     install|instal|insta|inst|ins|in|i)
  2288:       shift; set dummy --mode install ${1+"$@"}; shift
  2289:       ;;
  2290:     link|lin|li|l)
  2291:       shift; set dummy --mode link ${1+"$@"}; shift
  2292:       ;;
  2293:     uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
  2294:       shift; set dummy --mode uninstall ${1+"$@"}; shift
  2295:       ;;
  2296:     esac
  2297: 
  2298:     # Pass back the list of options.
  2299:     func_quote_for_eval ${1+"$@"}
  2300:     libtool_options_prep_result=$func_quote_for_eval_result
  2301: }
  2302: func_add_hook func_options_prep libtool_options_prep
  2303: 
  2304: 
  2305: # libtool_parse_options [ARG]...
  2306: # ---------------------------------
  2307: # Provide handling for libtool specific options.
  2308: libtool_parse_options ()
  2309: {
  2310:     $debug_cmd
  2311: 
  2312:     # Perform our own loop to consume as many options as possible in
  2313:     # each iteration.
  2314:     while test $# -gt 0; do
  2315:       _G_opt=$1
  2316:       shift
  2317:       case $_G_opt in
  2318:         --dry-run|--dryrun|-n)
  2319:                         opt_dry_run=:
  2320:                         ;;
  2321: 
  2322:         --config)       func_config ;;
  2323: 
  2324:         --dlopen|-dlopen)
  2325:                         opt_dlopen="${opt_dlopen+$opt_dlopen
  2326: }$1"
  2327:                         shift
  2328:                         ;;
  2329: 
  2330:         --preserve-dup-deps)
  2331:                         opt_preserve_dup_deps=: ;;
  2332: 
  2333:         --features)     func_features ;;
  2334: 
  2335:         --finish)       set dummy --mode finish ${1+"$@"}; shift ;;
  2336: 
  2337:         --help)         opt_help=: ;;
  2338: 
  2339:         --help-all)     opt_help=': help-all' ;;
  2340: 
  2341:         --mode)         test $# = 0 && func_missing_arg $_G_opt && break
  2342:                         opt_mode=$1
  2343:                         case $1 in
  2344:                           # Valid mode arguments:
  2345:                           clean|compile|execute|finish|install|link|relink|uninstall) ;;
  2346: 
  2347:                           # Catch anything else as an error
  2348:                           *) func_error "invalid argument for $_G_opt"
  2349:                              exit_cmd=exit
  2350:                              break
  2351:                              ;;
  2352:                         esac
  2353:                         shift
  2354:                         ;;
  2355: 
  2356:         --no-silent|--no-quiet)
  2357:                         opt_quiet=false
  2358:                         func_append preserve_args " $_G_opt"
  2359:                         ;;
  2360: 
  2361:         --no-warnings|--no-warning|--no-warn)
  2362:                         opt_warning=false
  2363:                         func_append preserve_args " $_G_opt"
  2364:                         ;;
  2365: 
  2366:         --no-verbose)
  2367:                         opt_verbose=false
  2368:                         func_append preserve_args " $_G_opt"
  2369:                         ;;
  2370: 
  2371:         --silent|--quiet)
  2372:                         opt_quiet=:
  2373:                         opt_verbose=false
  2374:                         func_append preserve_args " $_G_opt"
  2375:                         ;;
  2376: 
  2377:         --tag)          test $# = 0 && func_missing_arg $_G_opt && break
  2378:                         opt_tag=$1
  2379:                         func_append preserve_args " $_G_opt $1"
  2380:                         func_enable_tag "$1"
  2381:                         shift
  2382:                         ;;
  2383: 
  2384:         --verbose|-v)   opt_quiet=false
  2385:                         opt_verbose=:
  2386:                         func_append preserve_args " $_G_opt"
  2387:                         ;;
  2388: 
  2389: 	# An option not handled by this hook function:
  2390:         *)		set dummy "$_G_opt" ${1+"$@"};	shift; break  ;;
  2391:       esac
  2392:     done
  2393: 
  2394: 
  2395:     # save modified positional parameters for caller
  2396:     func_quote_for_eval ${1+"$@"}
  2397:     libtool_parse_options_result=$func_quote_for_eval_result
  2398: }
  2399: func_add_hook func_parse_options libtool_parse_options
  2400: 
  2401: 
  2402: 
  2403: # libtool_validate_options [ARG]...
  2404: # ---------------------------------
  2405: # Perform any sanity checks on option settings and/or unconsumed
  2406: # arguments.
  2407: libtool_validate_options ()
  2408: {
  2409:     # save first non-option argument
  2410:     if test 0 -lt $#; then
  2411:       nonopt=$1
  2412:       shift
  2413:     fi
  2414: 
  2415:     # preserve --debug
  2416:     test : = "$debug_cmd" || func_append preserve_args " --debug"
  2417: 
  2418:     case $host in
  2419:       # Solaris2 added to fix http://debbugs.gnu.org/cgi/bugreport.cgi?bug=16452
  2420:       # see also: http://gcc.gnu.org/bugzilla/show_bug.cgi?id=59788
  2421:       *cygwin* | *mingw* | *pw32* | *cegcc* | *solaris2* | *os2*)
  2422:         # don't eliminate duplications in $postdeps and $predeps
  2423:         opt_duplicate_compiler_generated_deps=:
  2424:         ;;
  2425:       *)
  2426:         opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
  2427:         ;;
  2428:     esac
  2429: 
  2430:     $opt_help || {
  2431:       # Sanity checks first:
  2432:       func_check_version_match
  2433: 
  2434:       test yes != "$build_libtool_libs" \
  2435:         && test yes != "$build_old_libs" \
  2436:         && func_fatal_configuration "not configured to build any kind of library"
  2437: 
  2438:       # Darwin sucks
  2439:       eval std_shrext=\"$shrext_cmds\"
  2440: 
  2441:       # Only execute mode is allowed to have -dlopen flags.
  2442:       if test -n "$opt_dlopen" && test execute != "$opt_mode"; then
  2443:         func_error "unrecognized option '-dlopen'"
  2444:         $ECHO "$help" 1>&2
  2445:         exit $EXIT_FAILURE
  2446:       fi
  2447: 
  2448:       # Change the help message to a mode-specific one.
  2449:       generic_help=$help
  2450:       help="Try '$progname --help --mode=$opt_mode' for more information."
  2451:     }
  2452: 
  2453:     # Pass back the unparsed argument list
  2454:     func_quote_for_eval ${1+"$@"}
  2455:     libtool_validate_options_result=$func_quote_for_eval_result
  2456: }
  2457: func_add_hook func_validate_options libtool_validate_options
  2458: 
  2459: 
  2460: # Process options as early as possible so that --help and --version
  2461: # can return quickly.
  2462: func_options ${1+"$@"}
  2463: eval set dummy "$func_options_result"; shift
  2464: 
  2465: 
  2466: 
  2467: ## ----------- ##
  2468: ##    Main.    ##
  2469: ## ----------- ##
  2470: 
  2471: magic='%%%MAGIC variable%%%'
  2472: magic_exe='%%%MAGIC EXE variable%%%'
  2473: 
  2474: # Global variables.
  2475: extracted_archives=
  2476: extracted_serial=0
  2477: 
  2478: # If this variable is set in any of the actions, the command in it
  2479: # will be execed at the end.  This prevents here-documents from being
  2480: # left over by shells.
  2481: exec_cmd=
  2482: 
  2483: 
  2484: # A function that is used when there is no print builtin or printf.
  2485: func_fallback_echo ()
  2486: {
  2487:   eval 'cat <<_LTECHO_EOF
  2488: $1
  2489: _LTECHO_EOF'
  2490: }
  2491: 
  2492: # func_generated_by_libtool
  2493: # True iff stdin has been generated by Libtool. This function is only
  2494: # a basic sanity check; it will hardly flush out determined imposters.
  2495: func_generated_by_libtool_p ()
  2496: {
  2497:   $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
  2498: }
  2499: 
  2500: # func_lalib_p file
  2501: # True iff FILE is a libtool '.la' library or '.lo' object file.
  2502: # This function is only a basic sanity check; it will hardly flush out
  2503: # determined imposters.
  2504: func_lalib_p ()
  2505: {
  2506:     test -f "$1" &&
  2507:       $SED -e 4q "$1" 2>/dev/null | func_generated_by_libtool_p
  2508: }
  2509: 
  2510: # func_lalib_unsafe_p file
  2511: # True iff FILE is a libtool '.la' library or '.lo' object file.
  2512: # This function implements the same check as func_lalib_p without
  2513: # resorting to external programs.  To this end, it redirects stdin and
  2514: # closes it afterwards, without saving the original file descriptor.
  2515: # As a safety measure, use it only where a negative result would be
  2516: # fatal anyway.  Works if 'file' does not exist.
  2517: func_lalib_unsafe_p ()
  2518: {
  2519:     lalib_p=no
  2520:     if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
  2521: 	for lalib_p_l in 1 2 3 4
  2522: 	do
  2523: 	    read lalib_p_line
  2524: 	    case $lalib_p_line in
  2525: 		\#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
  2526: 	    esac
  2527: 	done
  2528: 	exec 0<&5 5<&-
  2529:     fi
  2530:     test yes = "$lalib_p"
  2531: }
  2532: 
  2533: # func_ltwrapper_script_p file
  2534: # True iff FILE is a libtool wrapper script
  2535: # This function is only a basic sanity check; it will hardly flush out
  2536: # determined imposters.
  2537: func_ltwrapper_script_p ()
  2538: {
  2539:     test -f "$1" &&
  2540:       $lt_truncate_bin < "$1" 2>/dev/null | func_generated_by_libtool_p
  2541: }
  2542: 
  2543: # func_ltwrapper_executable_p file
  2544: # True iff FILE is a libtool wrapper executable
  2545: # This function is only a basic sanity check; it will hardly flush out
  2546: # determined imposters.
  2547: func_ltwrapper_executable_p ()
  2548: {
  2549:     func_ltwrapper_exec_suffix=
  2550:     case $1 in
  2551:     *.exe) ;;
  2552:     *) func_ltwrapper_exec_suffix=.exe ;;
  2553:     esac
  2554:     $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
  2555: }
  2556: 
  2557: # func_ltwrapper_scriptname file
  2558: # Assumes file is an ltwrapper_executable
  2559: # uses $file to determine the appropriate filename for a
  2560: # temporary ltwrapper_script.
  2561: func_ltwrapper_scriptname ()
  2562: {
  2563:     func_dirname_and_basename "$1" "" "."
  2564:     func_stripname '' '.exe' "$func_basename_result"
  2565:     func_ltwrapper_scriptname_result=$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper
  2566: }
  2567: 
  2568: # func_ltwrapper_p file
  2569: # True iff FILE is a libtool wrapper script or wrapper executable
  2570: # This function is only a basic sanity check; it will hardly flush out
  2571: # determined imposters.
  2572: func_ltwrapper_p ()
  2573: {
  2574:     func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
  2575: }
  2576: 
  2577: 
  2578: # func_execute_cmds commands fail_cmd
  2579: # Execute tilde-delimited COMMANDS.
  2580: # If FAIL_CMD is given, eval that upon failure.
  2581: # FAIL_CMD may read-access the current command in variable CMD!
  2582: func_execute_cmds ()
  2583: {
  2584:     $debug_cmd
  2585: 
  2586:     save_ifs=$IFS; IFS='~'
  2587:     for cmd in $1; do
  2588:       IFS=$sp$nl
  2589:       eval cmd=\"$cmd\"
  2590:       IFS=$save_ifs
  2591:       func_show_eval "$cmd" "${2-:}"
  2592:     done
  2593:     IFS=$save_ifs
  2594: }
  2595: 
  2596: 
  2597: # func_source file
  2598: # Source FILE, adding directory component if necessary.
  2599: # Note that it is not necessary on cygwin/mingw to append a dot to
  2600: # FILE even if both FILE and FILE.exe exist: automatic-append-.exe
  2601: # behavior happens only for exec(3), not for open(2)!  Also, sourcing
  2602: # 'FILE.' does not work on cygwin managed mounts.
  2603: func_source ()
  2604: {
  2605:     $debug_cmd
  2606: 
  2607:     case $1 in
  2608:     */* | *\\*)	. "$1" ;;
  2609:     *)		. "./$1" ;;
  2610:     esac
  2611: }
  2612: 
  2613: 
  2614: # func_resolve_sysroot PATH
  2615: # Replace a leading = in PATH with a sysroot.  Store the result into
  2616: # func_resolve_sysroot_result
  2617: func_resolve_sysroot ()
  2618: {
  2619:   func_resolve_sysroot_result=$1
  2620:   case $func_resolve_sysroot_result in
  2621:   =*)
  2622:     func_stripname '=' '' "$func_resolve_sysroot_result"
  2623:     func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
  2624:     ;;
  2625:   esac
  2626: }
  2627: 
  2628: # func_replace_sysroot PATH
  2629: # If PATH begins with the sysroot, replace it with = and
  2630: # store the result into func_replace_sysroot_result.
  2631: func_replace_sysroot ()
  2632: {
  2633:   case $lt_sysroot:$1 in
  2634:   ?*:"$lt_sysroot"*)
  2635:     func_stripname "$lt_sysroot" '' "$1"
  2636:     func_replace_sysroot_result='='$func_stripname_result
  2637:     ;;
  2638:   *)
  2639:     # Including no sysroot.
  2640:     func_replace_sysroot_result=$1
  2641:     ;;
  2642:   esac
  2643: }
  2644: 
  2645: # func_infer_tag arg
  2646: # Infer tagged configuration to use if any are available and
  2647: # if one wasn't chosen via the "--tag" command line option.
  2648: # Only attempt this if the compiler in the base compile
  2649: # command doesn't match the default compiler.
  2650: # arg is usually of the form 'gcc ...'
  2651: func_infer_tag ()
  2652: {
  2653:     $debug_cmd
  2654: 
  2655:     if test -n "$available_tags" && test -z "$tagname"; then
  2656:       CC_quoted=
  2657:       for arg in $CC; do
  2658: 	func_append_quoted CC_quoted "$arg"
  2659:       done
  2660:       CC_expanded=`func_echo_all $CC`
  2661:       CC_quoted_expanded=`func_echo_all $CC_quoted`
  2662:       case $@ in
  2663:       # Blanks in the command may have been stripped by the calling shell,
  2664:       # but not from the CC environment variable when configure was run.
  2665:       " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
  2666:       " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
  2667:       # Blanks at the start of $base_compile will cause this to fail
  2668:       # if we don't check for them as well.
  2669:       *)
  2670: 	for z in $available_tags; do
  2671: 	  if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
  2672: 	    # Evaluate the configuration.
  2673: 	    eval "`$SED -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
  2674: 	    CC_quoted=
  2675: 	    for arg in $CC; do
  2676: 	      # Double-quote args containing other shell metacharacters.
  2677: 	      func_append_quoted CC_quoted "$arg"
  2678: 	    done
  2679: 	    CC_expanded=`func_echo_all $CC`
  2680: 	    CC_quoted_expanded=`func_echo_all $CC_quoted`
  2681: 	    case "$@ " in
  2682: 	    " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
  2683: 	    " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
  2684: 	      # The compiler in the base compile command matches
  2685: 	      # the one in the tagged configuration.
  2686: 	      # Assume this is the tagged configuration we want.
  2687: 	      tagname=$z
  2688: 	      break
  2689: 	      ;;
  2690: 	    esac
  2691: 	  fi
  2692: 	done
  2693: 	# If $tagname still isn't set, then no tagged configuration
  2694: 	# was found and let the user know that the "--tag" command
  2695: 	# line option must be used.
  2696: 	if test -z "$tagname"; then
  2697: 	  func_echo "unable to infer tagged configuration"
  2698: 	  func_fatal_error "specify a tag with '--tag'"
  2699: #	else
  2700: #	  func_verbose "using $tagname tagged configuration"
  2701: 	fi
  2702: 	;;
  2703:       esac
  2704:     fi
  2705: }
  2706: 
  2707: 
  2708: 
  2709: # func_write_libtool_object output_name pic_name nonpic_name
  2710: # Create a libtool object file (analogous to a ".la" file),
  2711: # but don't create it if we're doing a dry run.
  2712: func_write_libtool_object ()
  2713: {
  2714:     write_libobj=$1
  2715:     if test yes = "$build_libtool_libs"; then
  2716:       write_lobj=\'$2\'
  2717:     else
  2718:       write_lobj=none
  2719:     fi
  2720: 
  2721:     if test yes = "$build_old_libs"; then
  2722:       write_oldobj=\'$3\'
  2723:     else
  2724:       write_oldobj=none
  2725:     fi
  2726: 
  2727:     $opt_dry_run || {
  2728:       cat >${write_libobj}T <<EOF
  2729: # $write_libobj - a libtool object file
  2730: # Generated by $PROGRAM (GNU $PACKAGE) $VERSION
  2731: #
  2732: # Please DO NOT delete this file!
  2733: # It is necessary for linking the library.
  2734: 
  2735: # Name of the PIC object.
  2736: pic_object=$write_lobj
  2737: 
  2738: # Name of the non-PIC object
  2739: non_pic_object=$write_oldobj
  2740: 
  2741: EOF
  2742:       $MV "${write_libobj}T" "$write_libobj"
  2743:     }
  2744: }
  2745: 
  2746: 
  2747: ##################################################
  2748: # FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
  2749: ##################################################
  2750: 
  2751: # func_convert_core_file_wine_to_w32 ARG
  2752: # Helper function used by file name conversion functions when $build is *nix,
  2753: # and $host is mingw, cygwin, or some other w32 environment. Relies on a
  2754: # correctly configured wine environment available, with the winepath program
  2755: # in $build's $PATH.
  2756: #
  2757: # ARG is the $build file name to be converted to w32 format.
  2758: # Result is available in $func_convert_core_file_wine_to_w32_result, and will
  2759: # be empty on error (or when ARG is empty)
  2760: func_convert_core_file_wine_to_w32 ()
  2761: {
  2762:   $debug_cmd
  2763: 
  2764:   func_convert_core_file_wine_to_w32_result=$1
  2765:   if test -n "$1"; then
  2766:     # Unfortunately, winepath does not exit with a non-zero error code, so we
  2767:     # are forced to check the contents of stdout. On the other hand, if the
  2768:     # command is not found, the shell will set an exit code of 127 and print
  2769:     # *an error message* to stdout. So we must check for both error code of
  2770:     # zero AND non-empty stdout, which explains the odd construction:
  2771:     func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
  2772:     if test "$?" -eq 0 && test -n "$func_convert_core_file_wine_to_w32_tmp"; then
  2773:       func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
  2774:         $SED -e "$sed_naive_backslashify"`
  2775:     else
  2776:       func_convert_core_file_wine_to_w32_result=
  2777:     fi
  2778:   fi
  2779: }
  2780: # end: func_convert_core_file_wine_to_w32
  2781: 
  2782: 
  2783: # func_convert_core_path_wine_to_w32 ARG
  2784: # Helper function used by path conversion functions when $build is *nix, and
  2785: # $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
  2786: # configured wine environment available, with the winepath program in $build's
  2787: # $PATH. Assumes ARG has no leading or trailing path separator characters.
  2788: #
  2789: # ARG is path to be converted from $build format to win32.
  2790: # Result is available in $func_convert_core_path_wine_to_w32_result.
  2791: # Unconvertible file (directory) names in ARG are skipped; if no directory names
  2792: # are convertible, then the result may be empty.
  2793: func_convert_core_path_wine_to_w32 ()
  2794: {
  2795:   $debug_cmd
  2796: 
  2797:   # unfortunately, winepath doesn't convert paths, only file names
  2798:   func_convert_core_path_wine_to_w32_result=
  2799:   if test -n "$1"; then
  2800:     oldIFS=$IFS
  2801:     IFS=:
  2802:     for func_convert_core_path_wine_to_w32_f in $1; do
  2803:       IFS=$oldIFS
  2804:       func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
  2805:       if test -n "$func_convert_core_file_wine_to_w32_result"; then
  2806:         if test -z "$func_convert_core_path_wine_to_w32_result"; then
  2807:           func_convert_core_path_wine_to_w32_result=$func_convert_core_file_wine_to_w32_result
  2808:         else
  2809:           func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
  2810:         fi
  2811:       fi
  2812:     done
  2813:     IFS=$oldIFS
  2814:   fi
  2815: }
  2816: # end: func_convert_core_path_wine_to_w32
  2817: 
  2818: 
  2819: # func_cygpath ARGS...
  2820: # Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
  2821: # when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
  2822: # $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
  2823: # (2), returns the Cygwin file name or path in func_cygpath_result (input
  2824: # file name or path is assumed to be in w32 format, as previously converted
  2825: # from $build's *nix or MSYS format). In case (3), returns the w32 file name
  2826: # or path in func_cygpath_result (input file name or path is assumed to be in
  2827: # Cygwin format). Returns an empty string on error.
  2828: #
  2829: # ARGS are passed to cygpath, with the last one being the file name or path to
  2830: # be converted.
  2831: #
  2832: # Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
  2833: # environment variable; do not put it in $PATH.
  2834: func_cygpath ()
  2835: {
  2836:   $debug_cmd
  2837: 
  2838:   if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
  2839:     func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
  2840:     if test "$?" -ne 0; then
  2841:       # on failure, ensure result is empty
  2842:       func_cygpath_result=
  2843:     fi
  2844:   else
  2845:     func_cygpath_result=
  2846:     func_error "LT_CYGPATH is empty or specifies non-existent file: '$LT_CYGPATH'"
  2847:   fi
  2848: }
  2849: #end: func_cygpath
  2850: 
  2851: 
  2852: # func_convert_core_msys_to_w32 ARG
  2853: # Convert file name or path ARG from MSYS format to w32 format.  Return
  2854: # result in func_convert_core_msys_to_w32_result.
  2855: func_convert_core_msys_to_w32 ()
  2856: {
  2857:   $debug_cmd
  2858: 
  2859:   # awkward: cmd appends spaces to result
  2860:   func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
  2861:     $SED -e 's/[ ]*$//' -e "$sed_naive_backslashify"`
  2862: }
  2863: #end: func_convert_core_msys_to_w32
  2864: 
  2865: 
  2866: # func_convert_file_check ARG1 ARG2
  2867: # Verify that ARG1 (a file name in $build format) was converted to $host
  2868: # format in ARG2. Otherwise, emit an error message, but continue (resetting
  2869: # func_to_host_file_result to ARG1).
  2870: func_convert_file_check ()
  2871: {
  2872:   $debug_cmd
  2873: 
  2874:   if test -z "$2" && test -n "$1"; then
  2875:     func_error "Could not determine host file name corresponding to"
  2876:     func_error "  '$1'"
  2877:     func_error "Continuing, but uninstalled executables may not work."
  2878:     # Fallback:
  2879:     func_to_host_file_result=$1
  2880:   fi
  2881: }
  2882: # end func_convert_file_check
  2883: 
  2884: 
  2885: # func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
  2886: # Verify that FROM_PATH (a path in $build format) was converted to $host
  2887: # format in TO_PATH. Otherwise, emit an error message, but continue, resetting
  2888: # func_to_host_file_result to a simplistic fallback value (see below).
  2889: func_convert_path_check ()
  2890: {
  2891:   $debug_cmd
  2892: 
  2893:   if test -z "$4" && test -n "$3"; then
  2894:     func_error "Could not determine the host path corresponding to"
  2895:     func_error "  '$3'"
  2896:     func_error "Continuing, but uninstalled executables may not work."
  2897:     # Fallback.  This is a deliberately simplistic "conversion" and
  2898:     # should not be "improved".  See libtool.info.
  2899:     if test "x$1" != "x$2"; then
  2900:       lt_replace_pathsep_chars="s|$1|$2|g"
  2901:       func_to_host_path_result=`echo "$3" |
  2902:         $SED -e "$lt_replace_pathsep_chars"`
  2903:     else
  2904:       func_to_host_path_result=$3
  2905:     fi
  2906:   fi
  2907: }
  2908: # end func_convert_path_check
  2909: 
  2910: 
  2911: # func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
  2912: # Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
  2913: # and appending REPL if ORIG matches BACKPAT.
  2914: func_convert_path_front_back_pathsep ()
  2915: {
  2916:   $debug_cmd
  2917: 
  2918:   case $4 in
  2919:   $1 ) func_to_host_path_result=$3$func_to_host_path_result
  2920:     ;;
  2921:   esac
  2922:   case $4 in
  2923:   $2 ) func_append func_to_host_path_result "$3"
  2924:     ;;
  2925:   esac
  2926: }
  2927: # end func_convert_path_front_back_pathsep
  2928: 
  2929: 
  2930: ##################################################
  2931: # $build to $host FILE NAME CONVERSION FUNCTIONS #
  2932: ##################################################
  2933: # invoked via '$to_host_file_cmd ARG'
  2934: #
  2935: # In each case, ARG is the path to be converted from $build to $host format.
  2936: # Result will be available in $func_to_host_file_result.
  2937: 
  2938: 
  2939: # func_to_host_file ARG
  2940: # Converts the file name ARG from $build format to $host format. Return result
  2941: # in func_to_host_file_result.
  2942: func_to_host_file ()
  2943: {
  2944:   $debug_cmd
  2945: 
  2946:   $to_host_file_cmd "$1"
  2947: }
  2948: # end func_to_host_file
  2949: 
  2950: 
  2951: # func_to_tool_file ARG LAZY
  2952: # converts the file name ARG from $build format to toolchain format. Return
  2953: # result in func_to_tool_file_result.  If the conversion in use is listed
  2954: # in (the comma separated) LAZY, no conversion takes place.
  2955: func_to_tool_file ()
  2956: {
  2957:   $debug_cmd
  2958: 
  2959:   case ,$2, in
  2960:     *,"$to_tool_file_cmd",*)
  2961:       func_to_tool_file_result=$1
  2962:       ;;
  2963:     *)
  2964:       $to_tool_file_cmd "$1"
  2965:       func_to_tool_file_result=$func_to_host_file_result
  2966:       ;;
  2967:   esac
  2968: }
  2969: # end func_to_tool_file
  2970: 
  2971: 
  2972: # func_convert_file_noop ARG
  2973: # Copy ARG to func_to_host_file_result.
  2974: func_convert_file_noop ()
  2975: {
  2976:   func_to_host_file_result=$1
  2977: }
  2978: # end func_convert_file_noop
  2979: 
  2980: 
  2981: # func_convert_file_msys_to_w32 ARG
  2982: # Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
  2983: # conversion to w32 is not available inside the cwrapper.  Returns result in
  2984: # func_to_host_file_result.
  2985: func_convert_file_msys_to_w32 ()
  2986: {
  2987:   $debug_cmd
  2988: 
  2989:   func_to_host_file_result=$1
  2990:   if test -n "$1"; then
  2991:     func_convert_core_msys_to_w32 "$1"
  2992:     func_to_host_file_result=$func_convert_core_msys_to_w32_result
  2993:   fi
  2994:   func_convert_file_check "$1" "$func_to_host_file_result"
  2995: }
  2996: # end func_convert_file_msys_to_w32
  2997: 
  2998: 
  2999: # func_convert_file_cygwin_to_w32 ARG
  3000: # Convert file name ARG from Cygwin to w32 format.  Returns result in
  3001: # func_to_host_file_result.
  3002: func_convert_file_cygwin_to_w32 ()
  3003: {
  3004:   $debug_cmd
  3005: 
  3006:   func_to_host_file_result=$1
  3007:   if test -n "$1"; then
  3008:     # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
  3009:     # LT_CYGPATH in this case.
  3010:     func_to_host_file_result=`cygpath -m "$1"`
  3011:   fi
  3012:   func_convert_file_check "$1" "$func_to_host_file_result"
  3013: }
  3014: # end func_convert_file_cygwin_to_w32
  3015: 
  3016: 
  3017: # func_convert_file_nix_to_w32 ARG
  3018: # Convert file name ARG from *nix to w32 format.  Requires a wine environment
  3019: # and a working winepath. Returns result in func_to_host_file_result.
  3020: func_convert_file_nix_to_w32 ()
  3021: {
  3022:   $debug_cmd
  3023: 
  3024:   func_to_host_file_result=$1
  3025:   if test -n "$1"; then
  3026:     func_convert_core_file_wine_to_w32 "$1"
  3027:     func_to_host_file_result=$func_convert_core_file_wine_to_w32_result
  3028:   fi
  3029:   func_convert_file_check "$1" "$func_to_host_file_result"
  3030: }
  3031: # end func_convert_file_nix_to_w32
  3032: 
  3033: 
  3034: # func_convert_file_msys_to_cygwin ARG
  3035: # Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
  3036: # Returns result in func_to_host_file_result.
  3037: func_convert_file_msys_to_cygwin ()
  3038: {
  3039:   $debug_cmd
  3040: 
  3041:   func_to_host_file_result=$1
  3042:   if test -n "$1"; then
  3043:     func_convert_core_msys_to_w32 "$1"
  3044:     func_cygpath -u "$func_convert_core_msys_to_w32_result"
  3045:     func_to_host_file_result=$func_cygpath_result
  3046:   fi
  3047:   func_convert_file_check "$1" "$func_to_host_file_result"
  3048: }
  3049: # end func_convert_file_msys_to_cygwin
  3050: 
  3051: 
  3052: # func_convert_file_nix_to_cygwin ARG
  3053: # Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
  3054: # in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
  3055: # in func_to_host_file_result.
  3056: func_convert_file_nix_to_cygwin ()
  3057: {
  3058:   $debug_cmd
  3059: 
  3060:   func_to_host_file_result=$1
  3061:   if test -n "$1"; then
  3062:     # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
  3063:     func_convert_core_file_wine_to_w32 "$1"
  3064:     func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
  3065:     func_to_host_file_result=$func_cygpath_result
  3066:   fi
  3067:   func_convert_file_check "$1" "$func_to_host_file_result"
  3068: }
  3069: # end func_convert_file_nix_to_cygwin
  3070: 
  3071: 
  3072: #############################################
  3073: # $build to $host PATH CONVERSION FUNCTIONS #
  3074: #############################################
  3075: # invoked via '$to_host_path_cmd ARG'
  3076: #
  3077: # In each case, ARG is the path to be converted from $build to $host format.
  3078: # The result will be available in $func_to_host_path_result.
  3079: #
  3080: # Path separators are also converted from $build format to $host format.  If
  3081: # ARG begins or ends with a path separator character, it is preserved (but
  3082: # converted to $host format) on output.
  3083: #
  3084: # All path conversion functions are named using the following convention:
  3085: #   file name conversion function    : func_convert_file_X_to_Y ()
  3086: #   path conversion function         : func_convert_path_X_to_Y ()
  3087: # where, for any given $build/$host combination the 'X_to_Y' value is the
  3088: # same.  If conversion functions are added for new $build/$host combinations,
  3089: # the two new functions must follow this pattern, or func_init_to_host_path_cmd
  3090: # will break.
  3091: 
  3092: 
  3093: # func_init_to_host_path_cmd
  3094: # Ensures that function "pointer" variable $to_host_path_cmd is set to the
  3095: # appropriate value, based on the value of $to_host_file_cmd.
  3096: to_host_path_cmd=
  3097: func_init_to_host_path_cmd ()
  3098: {
  3099:   $debug_cmd
  3100: 
  3101:   if test -z "$to_host_path_cmd"; then
  3102:     func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
  3103:     to_host_path_cmd=func_convert_path_$func_stripname_result
  3104:   fi
  3105: }
  3106: 
  3107: 
  3108: # func_to_host_path ARG
  3109: # Converts the path ARG from $build format to $host format. Return result
  3110: # in func_to_host_path_result.
  3111: func_to_host_path ()
  3112: {
  3113:   $debug_cmd
  3114: 
  3115:   func_init_to_host_path_cmd
  3116:   $to_host_path_cmd "$1"
  3117: }
  3118: # end func_to_host_path
  3119: 
  3120: 
  3121: # func_convert_path_noop ARG
  3122: # Copy ARG to func_to_host_path_result.
  3123: func_convert_path_noop ()
  3124: {
  3125:   func_to_host_path_result=$1
  3126: }
  3127: # end func_convert_path_noop
  3128: 
  3129: 
  3130: # func_convert_path_msys_to_w32 ARG
  3131: # Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
  3132: # conversion to w32 is not available inside the cwrapper.  Returns result in
  3133: # func_to_host_path_result.
  3134: func_convert_path_msys_to_w32 ()
  3135: {
  3136:   $debug_cmd
  3137: 
  3138:   func_to_host_path_result=$1
  3139:   if test -n "$1"; then
  3140:     # Remove leading and trailing path separator characters from ARG.  MSYS
  3141:     # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
  3142:     # and winepath ignores them completely.
  3143:     func_stripname : : "$1"
  3144:     func_to_host_path_tmp1=$func_stripname_result
  3145:     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
  3146:     func_to_host_path_result=$func_convert_core_msys_to_w32_result
  3147:     func_convert_path_check : ";" \
  3148:       "$func_to_host_path_tmp1" "$func_to_host_path_result"
  3149:     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
  3150:   fi
  3151: }
  3152: # end func_convert_path_msys_to_w32
  3153: 
  3154: 
  3155: # func_convert_path_cygwin_to_w32 ARG
  3156: # Convert path ARG from Cygwin to w32 format.  Returns result in
  3157: # func_to_host_file_result.
  3158: func_convert_path_cygwin_to_w32 ()
  3159: {
  3160:   $debug_cmd
  3161: 
  3162:   func_to_host_path_result=$1
  3163:   if test -n "$1"; then
  3164:     # See func_convert_path_msys_to_w32:
  3165:     func_stripname : : "$1"
  3166:     func_to_host_path_tmp1=$func_stripname_result
  3167:     func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
  3168:     func_convert_path_check : ";" \
  3169:       "$func_to_host_path_tmp1" "$func_to_host_path_result"
  3170:     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
  3171:   fi
  3172: }
  3173: # end func_convert_path_cygwin_to_w32
  3174: 
  3175: 
  3176: # func_convert_path_nix_to_w32 ARG
  3177: # Convert path ARG from *nix to w32 format.  Requires a wine environment and
  3178: # a working winepath.  Returns result in func_to_host_file_result.
  3179: func_convert_path_nix_to_w32 ()
  3180: {
  3181:   $debug_cmd
  3182: 
  3183:   func_to_host_path_result=$1
  3184:   if test -n "$1"; then
  3185:     # See func_convert_path_msys_to_w32:
  3186:     func_stripname : : "$1"
  3187:     func_to_host_path_tmp1=$func_stripname_result
  3188:     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
  3189:     func_to_host_path_result=$func_convert_core_path_wine_to_w32_result
  3190:     func_convert_path_check : ";" \
  3191:       "$func_to_host_path_tmp1" "$func_to_host_path_result"
  3192:     func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
  3193:   fi
  3194: }
  3195: # end func_convert_path_nix_to_w32
  3196: 
  3197: 
  3198: # func_convert_path_msys_to_cygwin ARG
  3199: # Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
  3200: # Returns result in func_to_host_file_result.
  3201: func_convert_path_msys_to_cygwin ()
  3202: {
  3203:   $debug_cmd
  3204: 
  3205:   func_to_host_path_result=$1
  3206:   if test -n "$1"; then
  3207:     # See func_convert_path_msys_to_w32:
  3208:     func_stripname : : "$1"
  3209:     func_to_host_path_tmp1=$func_stripname_result
  3210:     func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
  3211:     func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
  3212:     func_to_host_path_result=$func_cygpath_result
  3213:     func_convert_path_check : : \
  3214:       "$func_to_host_path_tmp1" "$func_to_host_path_result"
  3215:     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
  3216:   fi
  3217: }
  3218: # end func_convert_path_msys_to_cygwin
  3219: 
  3220: 
  3221: # func_convert_path_nix_to_cygwin ARG
  3222: # Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
  3223: # a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
  3224: # func_to_host_file_result.
  3225: func_convert_path_nix_to_cygwin ()
  3226: {
  3227:   $debug_cmd
  3228: 
  3229:   func_to_host_path_result=$1
  3230:   if test -n "$1"; then
  3231:     # Remove leading and trailing path separator characters from
  3232:     # ARG. msys behavior is inconsistent here, cygpath turns them
  3233:     # into '.;' and ';.', and winepath ignores them completely.
  3234:     func_stripname : : "$1"
  3235:     func_to_host_path_tmp1=$func_stripname_result
  3236:     func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
  3237:     func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
  3238:     func_to_host_path_result=$func_cygpath_result
  3239:     func_convert_path_check : : \
  3240:       "$func_to_host_path_tmp1" "$func_to_host_path_result"
  3241:     func_convert_path_front_back_pathsep ":*" "*:" : "$1"
  3242:   fi
  3243: }
  3244: # end func_convert_path_nix_to_cygwin
  3245: 
  3246: 
  3247: # func_dll_def_p FILE
  3248: # True iff FILE is a Windows DLL '.def' file.
  3249: # Keep in sync with _LT_DLL_DEF_P in libtool.m4
  3250: func_dll_def_p ()
  3251: {
  3252:   $debug_cmd
  3253: 
  3254:   func_dll_def_p_tmp=`$SED -n \
  3255:     -e 's/^[	 ]*//' \
  3256:     -e '/^\(;.*\)*$/d' \
  3257:     -e 's/^\(EXPORTS\|LIBRARY\)\([	 ].*\)*$/DEF/p' \
  3258:     -e q \
  3259:     "$1"`
  3260:   test DEF = "$func_dll_def_p_tmp"
  3261: }
  3262: 
  3263: 
  3264: # func_mode_compile arg...
  3265: func_mode_compile ()
  3266: {
  3267:     $debug_cmd
  3268: 
  3269:     # Get the compilation command and the source file.
  3270:     base_compile=
  3271:     srcfile=$nonopt  #  always keep a non-empty value in "srcfile"
  3272:     suppress_opt=yes
  3273:     suppress_output=
  3274:     arg_mode=normal
  3275:     libobj=
  3276:     later=
  3277:     pie_flag=
  3278: 
  3279:     for arg
  3280:     do
  3281:       case $arg_mode in
  3282:       arg  )
  3283: 	# do not "continue".  Instead, add this to base_compile
  3284: 	lastarg=$arg
  3285: 	arg_mode=normal
  3286: 	;;
  3287: 
  3288:       target )
  3289: 	libobj=$arg
  3290: 	arg_mode=normal
  3291: 	continue
  3292: 	;;
  3293: 
  3294:       normal )
  3295: 	# Accept any command-line options.
  3296: 	case $arg in
  3297: 	-o)
  3298: 	  test -n "$libobj" && \
  3299: 	    func_fatal_error "you cannot specify '-o' more than once"
  3300: 	  arg_mode=target
  3301: 	  continue
  3302: 	  ;;
  3303: 
  3304: 	-pie | -fpie | -fPIE)
  3305:           func_append pie_flag " $arg"
  3306: 	  continue
  3307: 	  ;;
  3308: 
  3309: 	-shared | -static | -prefer-pic | -prefer-non-pic)
  3310: 	  func_append later " $arg"
  3311: 	  continue
  3312: 	  ;;
  3313: 
  3314: 	-no-suppress)
  3315: 	  suppress_opt=no
  3316: 	  continue
  3317: 	  ;;
  3318: 
  3319: 	-Xcompiler)
  3320: 	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
  3321: 	  continue      #  The current "srcfile" will either be retained or
  3322: 	  ;;            #  replaced later.  I would guess that would be a bug.
  3323: 
  3324: 	-Wc,*)
  3325: 	  func_stripname '-Wc,' '' "$arg"
  3326: 	  args=$func_stripname_result
  3327: 	  lastarg=
  3328: 	  save_ifs=$IFS; IFS=,
  3329: 	  for arg in $args; do
  3330: 	    IFS=$save_ifs
  3331: 	    func_append_quoted lastarg "$arg"
  3332: 	  done
  3333: 	  IFS=$save_ifs
  3334: 	  func_stripname ' ' '' "$lastarg"
  3335: 	  lastarg=$func_stripname_result
  3336: 
  3337: 	  # Add the arguments to base_compile.
  3338: 	  func_append base_compile " $lastarg"
  3339: 	  continue
  3340: 	  ;;
  3341: 
  3342: 	*)
  3343: 	  # Accept the current argument as the source file.
  3344: 	  # The previous "srcfile" becomes the current argument.
  3345: 	  #
  3346: 	  lastarg=$srcfile
  3347: 	  srcfile=$arg
  3348: 	  ;;
  3349: 	esac  #  case $arg
  3350: 	;;
  3351:       esac    #  case $arg_mode
  3352: 
  3353:       # Aesthetically quote the previous argument.
  3354:       func_append_quoted base_compile "$lastarg"
  3355:     done # for arg
  3356: 
  3357:     case $arg_mode in
  3358:     arg)
  3359:       func_fatal_error "you must specify an argument for -Xcompile"
  3360:       ;;
  3361:     target)
  3362:       func_fatal_error "you must specify a target with '-o'"
  3363:       ;;
  3364:     *)
  3365:       # Get the name of the library object.
  3366:       test -z "$libobj" && {
  3367: 	func_basename "$srcfile"
  3368: 	libobj=$func_basename_result
  3369:       }
  3370:       ;;
  3371:     esac
  3372: 
  3373:     # Recognize several different file suffixes.
  3374:     # If the user specifies -o file.o, it is replaced with file.lo
  3375:     case $libobj in
  3376:     *.[cCFSifmso] | \
  3377:     *.ada | *.adb | *.ads | *.asm | \
  3378:     *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
  3379:     *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
  3380:       func_xform "$libobj"
  3381:       libobj=$func_xform_result
  3382:       ;;
  3383:     esac
  3384: 
  3385:     case $libobj in
  3386:     *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
  3387:     *)
  3388:       func_fatal_error "cannot determine name of library object from '$libobj'"
  3389:       ;;
  3390:     esac
  3391: 
  3392:     func_infer_tag $base_compile
  3393: 
  3394:     for arg in $later; do
  3395:       case $arg in
  3396:       -shared)
  3397: 	test yes = "$build_libtool_libs" \
  3398: 	  || func_fatal_configuration "cannot build a shared library"
  3399: 	build_old_libs=no
  3400: 	continue
  3401: 	;;
  3402: 
  3403:       -static)
  3404: 	build_libtool_libs=no
  3405: 	build_old_libs=yes
  3406: 	continue
  3407: 	;;
  3408: 
  3409:       -prefer-pic)
  3410: 	pic_mode=yes
  3411: 	continue
  3412: 	;;
  3413: 
  3414:       -prefer-non-pic)
  3415: 	pic_mode=no
  3416: 	continue
  3417: 	;;
  3418:       esac
  3419:     done
  3420: 
  3421:     func_quote_for_eval "$libobj"
  3422:     test "X$libobj" != "X$func_quote_for_eval_result" \
  3423:       && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'	 &()|`$[]' \
  3424:       && func_warning "libobj name '$libobj' may not contain shell special characters."
  3425:     func_dirname_and_basename "$obj" "/" ""
  3426:     objname=$func_basename_result
  3427:     xdir=$func_dirname_result
  3428:     lobj=$xdir$objdir/$objname
  3429: 
  3430:     test -z "$base_compile" && \
  3431:       func_fatal_help "you must specify a compilation command"
  3432: 
  3433:     # Delete any leftover library objects.
  3434:     if test yes = "$build_old_libs"; then
  3435:       removelist="$obj $lobj $libobj ${libobj}T"
  3436:     else
  3437:       removelist="$lobj $libobj ${libobj}T"
  3438:     fi
  3439: 
  3440:     # On Cygwin there's no "real" PIC flag so we must build both object types
  3441:     case $host_os in
  3442:     cygwin* | mingw* | pw32* | os2* | cegcc*)
  3443:       pic_mode=default
  3444:       ;;
  3445:     esac
  3446:     if test no = "$pic_mode" && test pass_all != "$deplibs_check_method"; then
  3447:       # non-PIC code in shared libraries is not supported
  3448:       pic_mode=default
  3449:     fi
  3450: 
  3451:     # Calculate the filename of the output object if compiler does
  3452:     # not support -o with -c
  3453:     if test no = "$compiler_c_o"; then
  3454:       output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.$objext
  3455:       lockfile=$output_obj.lock
  3456:     else
  3457:       output_obj=
  3458:       need_locks=no
  3459:       lockfile=
  3460:     fi
  3461: 
  3462:     # Lock this critical section if it is needed
  3463:     # We use this script file to make the link, it avoids creating a new file
  3464:     if test yes = "$need_locks"; then
  3465:       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
  3466: 	func_echo "Waiting for $lockfile to be removed"
  3467: 	sleep 2
  3468:       done
  3469:     elif test warn = "$need_locks"; then
  3470:       if test -f "$lockfile"; then
  3471: 	$ECHO "\
  3472: *** ERROR, $lockfile exists and contains:
  3473: `cat $lockfile 2>/dev/null`
  3474: 
  3475: This indicates that another process is trying to use the same
  3476: temporary object file, and libtool could not work around it because
  3477: your compiler does not support '-c' and '-o' together.  If you
  3478: repeat this compilation, it may succeed, by chance, but you had better
  3479: avoid parallel builds (make -j) in this platform, or get a better
  3480: compiler."
  3481: 
  3482: 	$opt_dry_run || $RM $removelist
  3483: 	exit $EXIT_FAILURE
  3484:       fi
  3485:       func_append removelist " $output_obj"
  3486:       $ECHO "$srcfile" > "$lockfile"
  3487:     fi
  3488: 
  3489:     $opt_dry_run || $RM $removelist
  3490:     func_append removelist " $lockfile"
  3491:     trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
  3492: 
  3493:     func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
  3494:     srcfile=$func_to_tool_file_result
  3495:     func_quote_for_eval "$srcfile"
  3496:     qsrcfile=$func_quote_for_eval_result
  3497: 
  3498:     # Only build a PIC object if we are building libtool libraries.
  3499:     if test yes = "$build_libtool_libs"; then
  3500:       # Without this assignment, base_compile gets emptied.
  3501:       fbsd_hideous_sh_bug=$base_compile
  3502: 
  3503:       if test no != "$pic_mode"; then
  3504: 	command="$base_compile $qsrcfile $pic_flag"
  3505:       else
  3506: 	# Don't build PIC code
  3507: 	command="$base_compile $qsrcfile"
  3508:       fi
  3509: 
  3510:       func_mkdir_p "$xdir$objdir"
  3511: 
  3512:       if test -z "$output_obj"; then
  3513: 	# Place PIC objects in $objdir
  3514: 	func_append command " -o $lobj"
  3515:       fi
  3516: 
  3517:       func_show_eval_locale "$command"	\
  3518:           'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
  3519: 
  3520:       if test warn = "$need_locks" &&
  3521: 	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
  3522: 	$ECHO "\
  3523: *** ERROR, $lockfile contains:
  3524: `cat $lockfile 2>/dev/null`
  3525: 
  3526: but it should contain:
  3527: $srcfile
  3528: 
  3529: This indicates that another process is trying to use the same
  3530: temporary object file, and libtool could not work around it because
  3531: your compiler does not support '-c' and '-o' together.  If you
  3532: repeat this compilation, it may succeed, by chance, but you had better
  3533: avoid parallel builds (make -j) in this platform, or get a better
  3534: compiler."
  3535: 
  3536: 	$opt_dry_run || $RM $removelist
  3537: 	exit $EXIT_FAILURE
  3538:       fi
  3539: 
  3540:       # Just move the object if needed, then go on to compile the next one
  3541:       if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
  3542: 	func_show_eval '$MV "$output_obj" "$lobj"' \
  3543: 	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
  3544:       fi
  3545: 
  3546:       # Allow error messages only from the first compilation.
  3547:       if test yes = "$suppress_opt"; then
  3548: 	suppress_output=' >/dev/null 2>&1'
  3549:       fi
  3550:     fi
  3551: 
  3552:     # Only build a position-dependent object if we build old libraries.
  3553:     if test yes = "$build_old_libs"; then
  3554:       if test yes != "$pic_mode"; then
  3555: 	# Don't build PIC code
  3556: 	command="$base_compile $qsrcfile$pie_flag"
  3557:       else
  3558: 	command="$base_compile $qsrcfile $pic_flag"
  3559:       fi
  3560:       if test yes = "$compiler_c_o"; then
  3561: 	func_append command " -o $obj"
  3562:       fi
  3563: 
  3564:       # Suppress compiler output if we already did a PIC compilation.
  3565:       func_append command "$suppress_output"
  3566:       func_show_eval_locale "$command" \
  3567:         '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
  3568: 
  3569:       if test warn = "$need_locks" &&
  3570: 	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
  3571: 	$ECHO "\
  3572: *** ERROR, $lockfile contains:
  3573: `cat $lockfile 2>/dev/null`
  3574: 
  3575: but it should contain:
  3576: $srcfile
  3577: 
  3578: This indicates that another process is trying to use the same
  3579: temporary object file, and libtool could not work around it because
  3580: your compiler does not support '-c' and '-o' together.  If you
  3581: repeat this compilation, it may succeed, by chance, but you had better
  3582: avoid parallel builds (make -j) in this platform, or get a better
  3583: compiler."
  3584: 
  3585: 	$opt_dry_run || $RM $removelist
  3586: 	exit $EXIT_FAILURE
  3587:       fi
  3588: 
  3589:       # Just move the object if needed
  3590:       if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
  3591: 	func_show_eval '$MV "$output_obj" "$obj"' \
  3592: 	  'error=$?; $opt_dry_run || $RM $removelist; exit $error'
  3593:       fi
  3594:     fi
  3595: 
  3596:     $opt_dry_run || {
  3597:       func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
  3598: 
  3599:       # Unlock the critical section if it was locked
  3600:       if test no != "$need_locks"; then
  3601: 	removelist=$lockfile
  3602:         $RM "$lockfile"
  3603:       fi
  3604:     }
  3605: 
  3606:     exit $EXIT_SUCCESS
  3607: }
  3608: 
  3609: $opt_help || {
  3610:   test compile = "$opt_mode" && func_mode_compile ${1+"$@"}
  3611: }
  3612: 
  3613: func_mode_help ()
  3614: {
  3615:     # We need to display help for each of the modes.
  3616:     case $opt_mode in
  3617:       "")
  3618:         # Generic help is extracted from the usage comments
  3619:         # at the start of this file.
  3620:         func_help
  3621:         ;;
  3622: 
  3623:       clean)
  3624:         $ECHO \
  3625: "Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
  3626: 
  3627: Remove files from the build directory.
  3628: 
  3629: RM is the name of the program to use to delete files associated with each FILE
  3630: (typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
  3631: to RM.
  3632: 
  3633: If FILE is a libtool library, object or program, all the files associated
  3634: with it are deleted. Otherwise, only FILE itself is deleted using RM."
  3635:         ;;
  3636: 
  3637:       compile)
  3638:       $ECHO \
  3639: "Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
  3640: 
  3641: Compile a source file into a libtool library object.
  3642: 
  3643: This mode accepts the following additional options:
  3644: 
  3645:   -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
  3646:   -no-suppress      do not suppress compiler output for multiple passes
  3647:   -prefer-pic       try to build PIC objects only
  3648:   -prefer-non-pic   try to build non-PIC objects only
  3649:   -shared           do not build a '.o' file suitable for static linking
  3650:   -static           only build a '.o' file suitable for static linking
  3651:   -Wc,FLAG          pass FLAG directly to the compiler
  3652: 
  3653: COMPILE-COMMAND is a command to be used in creating a 'standard' object file
  3654: from the given SOURCEFILE.
  3655: 
  3656: The output file name is determined by removing the directory component from
  3657: SOURCEFILE, then substituting the C source code suffix '.c' with the
  3658: library object suffix, '.lo'."
  3659:         ;;
  3660: 
  3661:       execute)
  3662:         $ECHO \
  3663: "Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
  3664: 
  3665: Automatically set library path, then run a program.
  3666: 
  3667: This mode accepts the following additional options:
  3668: 
  3669:   -dlopen FILE      add the directory containing FILE to the library path
  3670: 
  3671: This mode sets the library path environment variable according to '-dlopen'
  3672: flags.
  3673: 
  3674: If any of the ARGS are libtool executable wrappers, then they are translated
  3675: into their corresponding uninstalled binary, and any of their required library
  3676: directories are added to the library path.
  3677: 
  3678: Then, COMMAND is executed, with ARGS as arguments."
  3679:         ;;
  3680: 
  3681:       finish)
  3682:         $ECHO \
  3683: "Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
  3684: 
  3685: Complete the installation of libtool libraries.
  3686: 
  3687: Each LIBDIR is a directory that contains libtool libraries.
  3688: 
  3689: The commands that this mode executes may require superuser privileges.  Use
  3690: the '--dry-run' option if you just want to see what would be executed."
  3691:         ;;
  3692: 
  3693:       install)
  3694:         $ECHO \
  3695: "Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
  3696: 
  3697: Install executables or libraries.
  3698: 
  3699: INSTALL-COMMAND is the installation command.  The first component should be
  3700: either the 'install' or 'cp' program.
  3701: 
  3702: The following components of INSTALL-COMMAND are treated specially:
  3703: 
  3704:   -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
  3705: 
  3706: The rest of the components are interpreted as arguments to that command (only
  3707: BSD-compatible install options are recognized)."
  3708:         ;;
  3709: 
  3710:       link)
  3711:         $ECHO \
  3712: "Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
  3713: 
  3714: Link object files or libraries together to form another library, or to
  3715: create an executable program.
  3716: 
  3717: LINK-COMMAND is a command using the C compiler that you would use to create
  3718: a program from several object files.
  3719: 
  3720: The following components of LINK-COMMAND are treated specially:
  3721: 
  3722:   -all-static       do not do any dynamic linking at all
  3723:   -avoid-version    do not add a version suffix if possible
  3724:   -bindir BINDIR    specify path to binaries directory (for systems where
  3725:                     libraries must be found in the PATH setting at runtime)
  3726:   -dlopen FILE      '-dlpreopen' FILE if it cannot be dlopened at runtime
  3727:   -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
  3728:   -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
  3729:   -export-symbols SYMFILE
  3730:                     try to export only the symbols listed in SYMFILE
  3731:   -export-symbols-regex REGEX
  3732:                     try to export only the symbols matching REGEX
  3733:   -LLIBDIR          search LIBDIR for required installed libraries
  3734:   -lNAME            OUTPUT-FILE requires the installed library libNAME
  3735:   -module           build a library that can dlopened
  3736:   -no-fast-install  disable the fast-install mode
  3737:   -no-install       link a not-installable executable
  3738:   -no-undefined     declare that a library does not refer to external symbols
  3739:   -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
  3740:   -objectlist FILE  use a list of object files found in FILE to specify objects
  3741:   -os2dllname NAME  force a short DLL name on OS/2 (no effect on other OSes)
  3742:   -precious-files-regex REGEX
  3743:                     don't remove output files matching REGEX
  3744:   -release RELEASE  specify package release information
  3745:   -rpath LIBDIR     the created library will eventually be installed in LIBDIR
  3746:   -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
  3747:   -shared           only do dynamic linking of libtool libraries
  3748:   -shrext SUFFIX    override the standard shared library file extension
  3749:   -static           do not do any dynamic linking of uninstalled libtool libraries
  3750:   -static-libtool-libs
  3751:                     do not do any dynamic linking of libtool libraries
  3752:   -version-info CURRENT[:REVISION[:AGE]]
  3753:                     specify library version info [each variable defaults to 0]
  3754:   -weak LIBNAME     declare that the target provides the LIBNAME interface
  3755:   -Wc,FLAG
  3756:   -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
  3757:   -Wl,FLAG
  3758:   -Xlinker FLAG     pass linker-specific FLAG directly to the linker
  3759:   -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
  3760: 
  3761: All other options (arguments beginning with '-') are ignored.
  3762: 
  3763: Every other argument is treated as a filename.  Files ending in '.la' are
  3764: treated as uninstalled libtool libraries, other files are standard or library
  3765: object files.
  3766: 
  3767: If the OUTPUT-FILE ends in '.la', then a libtool library is created,
  3768: only library objects ('.lo' files) may be specified, and '-rpath' is
  3769: required, except when creating a convenience library.
  3770: 
  3771: If OUTPUT-FILE ends in '.a' or '.lib', then a standard library is created
  3772: using 'ar' and 'ranlib', or on Windows using 'lib'.
  3773: 
  3774: If OUTPUT-FILE ends in '.lo' or '.$objext', then a reloadable object file
  3775: is created, otherwise an executable program is created."
  3776:         ;;
  3777: 
  3778:       uninstall)
  3779:         $ECHO \
  3780: "Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
  3781: 
  3782: Remove libraries from an installation directory.
  3783: 
  3784: RM is the name of the program to use to delete files associated with each FILE
  3785: (typically '/bin/rm').  RM-OPTIONS are options (such as '-f') to be passed
  3786: to RM.
  3787: 
  3788: If FILE is a libtool library, all the files associated with it are deleted.
  3789: Otherwise, only FILE itself is deleted using RM."
  3790:         ;;
  3791: 
  3792:       *)
  3793:         func_fatal_help "invalid operation mode '$opt_mode'"
  3794:         ;;
  3795:     esac
  3796: 
  3797:     echo
  3798:     $ECHO "Try '$progname --help' for more information about other modes."
  3799: }
  3800: 
  3801: # Now that we've collected a possible --mode arg, show help if necessary
  3802: if $opt_help; then
  3803:   if test : = "$opt_help"; then
  3804:     func_mode_help
  3805:   else
  3806:     {
  3807:       func_help noexit
  3808:       for opt_mode in compile link execute install finish uninstall clean; do
  3809: 	func_mode_help
  3810:       done
  3811:     } | $SED -n '1p; 2,$s/^Usage:/  or: /p'
  3812:     {
  3813:       func_help noexit
  3814:       for opt_mode in compile link execute install finish uninstall clean; do
  3815: 	echo
  3816: 	func_mode_help
  3817:       done
  3818:     } |
  3819:     $SED '1d
  3820:       /^When reporting/,/^Report/{
  3821: 	H
  3822: 	d
  3823:       }
  3824:       $x
  3825:       /information about other modes/d
  3826:       /more detailed .*MODE/d
  3827:       s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
  3828:   fi
  3829:   exit $?
  3830: fi
  3831: 
  3832: 
  3833: # func_mode_execute arg...
  3834: func_mode_execute ()
  3835: {
  3836:     $debug_cmd
  3837: 
  3838:     # The first argument is the command name.
  3839:     cmd=$nonopt
  3840:     test -z "$cmd" && \
  3841:       func_fatal_help "you must specify a COMMAND"
  3842: 
  3843:     # Handle -dlopen flags immediately.
  3844:     for file in $opt_dlopen; do
  3845:       test -f "$file" \
  3846: 	|| func_fatal_help "'$file' is not a file"
  3847: 
  3848:       dir=
  3849:       case $file in
  3850:       *.la)
  3851: 	func_resolve_sysroot "$file"
  3852: 	file=$func_resolve_sysroot_result
  3853: 
  3854: 	# Check to see that this really is a libtool archive.
  3855: 	func_lalib_unsafe_p "$file" \
  3856: 	  || func_fatal_help "'$lib' is not a valid libtool archive"
  3857: 
  3858: 	# Read the libtool library.
  3859: 	dlname=
  3860: 	library_names=
  3861: 	func_source "$file"
  3862: 
  3863: 	# Skip this library if it cannot be dlopened.
  3864: 	if test -z "$dlname"; then
  3865: 	  # Warn if it was a shared library.
  3866: 	  test -n "$library_names" && \
  3867: 	    func_warning "'$file' was not linked with '-export-dynamic'"
  3868: 	  continue
  3869: 	fi
  3870: 
  3871: 	func_dirname "$file" "" "."
  3872: 	dir=$func_dirname_result
  3873: 
  3874: 	if test -f "$dir/$objdir/$dlname"; then
  3875: 	  func_append dir "/$objdir"
  3876: 	else
  3877: 	  if test ! -f "$dir/$dlname"; then
  3878: 	    func_fatal_error "cannot find '$dlname' in '$dir' or '$dir/$objdir'"
  3879: 	  fi
  3880: 	fi
  3881: 	;;
  3882: 
  3883:       *.lo)
  3884: 	# Just add the directory containing the .lo file.
  3885: 	func_dirname "$file" "" "."
  3886: 	dir=$func_dirname_result
  3887: 	;;
  3888: 
  3889:       *)
  3890: 	func_warning "'-dlopen' is ignored for non-libtool libraries and objects"
  3891: 	continue
  3892: 	;;
  3893:       esac
  3894: 
  3895:       # Get the absolute pathname.
  3896:       absdir=`cd "$dir" && pwd`
  3897:       test -n "$absdir" && dir=$absdir
  3898: 
  3899:       # Now add the directory to shlibpath_var.
  3900:       if eval "test -z \"\$$shlibpath_var\""; then
  3901: 	eval "$shlibpath_var=\"\$dir\""
  3902:       else
  3903: 	eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
  3904:       fi
  3905:     done
  3906: 
  3907:     # This variable tells wrapper scripts just to set shlibpath_var
  3908:     # rather than running their programs.
  3909:     libtool_execute_magic=$magic
  3910: 
  3911:     # Check if any of the arguments is a wrapper script.
  3912:     args=
  3913:     for file
  3914:     do
  3915:       case $file in
  3916:       -* | *.la | *.lo ) ;;
  3917:       *)
  3918: 	# Do a test to see if this is really a libtool program.
  3919: 	if func_ltwrapper_script_p "$file"; then
  3920: 	  func_source "$file"
  3921: 	  # Transform arg to wrapped name.
  3922: 	  file=$progdir/$program
  3923: 	elif func_ltwrapper_executable_p "$file"; then
  3924: 	  func_ltwrapper_scriptname "$file"
  3925: 	  func_source "$func_ltwrapper_scriptname_result"
  3926: 	  # Transform arg to wrapped name.
  3927: 	  file=$progdir/$program
  3928: 	fi
  3929: 	;;
  3930:       esac
  3931:       # Quote arguments (to preserve shell metacharacters).
  3932:       func_append_quoted args "$file"
  3933:     done
  3934: 
  3935:     if $opt_dry_run; then
  3936:       # Display what would be done.
  3937:       if test -n "$shlibpath_var"; then
  3938: 	eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
  3939: 	echo "export $shlibpath_var"
  3940:       fi
  3941:       $ECHO "$cmd$args"
  3942:       exit $EXIT_SUCCESS
  3943:     else
  3944:       if test -n "$shlibpath_var"; then
  3945: 	# Export the shlibpath_var.
  3946: 	eval "export $shlibpath_var"
  3947:       fi
  3948: 
  3949:       # Restore saved environment variables
  3950:       for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
  3951:       do
  3952: 	eval "if test \"\${save_$lt_var+set}\" = set; then
  3953:                 $lt_var=\$save_$lt_var; export $lt_var
  3954: 	      else
  3955: 		$lt_unset $lt_var
  3956: 	      fi"
  3957:       done
  3958: 
  3959:       # Now prepare to actually exec the command.
  3960:       exec_cmd=\$cmd$args
  3961:     fi
  3962: }
  3963: 
  3964: test execute = "$opt_mode" && func_mode_execute ${1+"$@"}
  3965: 
  3966: 
  3967: # func_mode_finish arg...
  3968: func_mode_finish ()
  3969: {
  3970:     $debug_cmd
  3971: 
  3972:     libs=
  3973:     libdirs=
  3974:     admincmds=
  3975: 
  3976:     for opt in "$nonopt" ${1+"$@"}
  3977:     do
  3978:       if test -d "$opt"; then
  3979: 	func_append libdirs " $opt"
  3980: 
  3981:       elif test -f "$opt"; then
  3982: 	if func_lalib_unsafe_p "$opt"; then
  3983: 	  func_append libs " $opt"
  3984: 	else
  3985: 	  func_warning "'$opt' is not a valid libtool archive"
  3986: 	fi
  3987: 
  3988:       else
  3989: 	func_fatal_error "invalid argument '$opt'"
  3990:       fi
  3991:     done
  3992: 
  3993:     if test -n "$libs"; then
  3994:       if test -n "$lt_sysroot"; then
  3995:         sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
  3996:         sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
  3997:       else
  3998:         sysroot_cmd=
  3999:       fi
  4000: 
  4001:       # Remove sysroot references
  4002:       if $opt_dry_run; then
  4003:         for lib in $libs; do
  4004:           echo "removing references to $lt_sysroot and '=' prefixes from $lib"
  4005:         done
  4006:       else
  4007:         tmpdir=`func_mktempdir`
  4008:         for lib in $libs; do
  4009: 	  $SED -e "$sysroot_cmd s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
  4010: 	    > $tmpdir/tmp-la
  4011: 	  mv -f $tmpdir/tmp-la $lib
  4012: 	done
  4013:         ${RM}r "$tmpdir"
  4014:       fi
  4015:     fi
  4016: 
  4017:     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
  4018:       for libdir in $libdirs; do
  4019: 	if test -n "$finish_cmds"; then
  4020: 	  # Do each command in the finish commands.
  4021: 	  func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
  4022: '"$cmd"'"'
  4023: 	fi
  4024: 	if test -n "$finish_eval"; then
  4025: 	  # Do the single finish_eval.
  4026: 	  eval cmds=\"$finish_eval\"
  4027: 	  $opt_dry_run || eval "$cmds" || func_append admincmds "
  4028:        $cmds"
  4029: 	fi
  4030:       done
  4031:     fi
  4032: 
  4033:     # Exit here if they wanted silent mode.
  4034:     $opt_quiet && exit $EXIT_SUCCESS
  4035: 
  4036:     if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
  4037:       echo "----------------------------------------------------------------------"
  4038:       echo "Libraries have been installed in:"
  4039:       for libdir in $libdirs; do
  4040: 	$ECHO "   $libdir"
  4041:       done
  4042:       echo
  4043:       echo "If you ever happen to want to link against installed libraries"
  4044:       echo "in a given directory, LIBDIR, you must either use libtool, and"
  4045:       echo "specify the full pathname of the library, or use the '-LLIBDIR'"
  4046:       echo "flag during linking and do at least one of the following:"
  4047:       if test -n "$shlibpath_var"; then
  4048: 	echo "   - add LIBDIR to the '$shlibpath_var' environment variable"
  4049: 	echo "     during execution"
  4050:       fi
  4051:       if test -n "$runpath_var"; then
  4052: 	echo "   - add LIBDIR to the '$runpath_var' environment variable"
  4053: 	echo "     during linking"
  4054:       fi
  4055:       if test -n "$hardcode_libdir_flag_spec"; then
  4056: 	libdir=LIBDIR
  4057: 	eval flag=\"$hardcode_libdir_flag_spec\"
  4058: 
  4059: 	$ECHO "   - use the '$flag' linker flag"
  4060:       fi
  4061:       if test -n "$admincmds"; then
  4062: 	$ECHO "   - have your system administrator run these commands:$admincmds"
  4063:       fi
  4064:       if test -f /etc/ld.so.conf; then
  4065: 	echo "   - have your system administrator add LIBDIR to '/etc/ld.so.conf'"
  4066:       fi
  4067:       echo
  4068: 
  4069:       echo "See any operating system documentation about shared libraries for"
  4070:       case $host in
  4071: 	solaris2.[6789]|solaris2.1[0-9])
  4072: 	  echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
  4073: 	  echo "pages."
  4074: 	  ;;
  4075: 	*)
  4076: 	  echo "more information, such as the ld(1) and ld.so(8) manual pages."
  4077: 	  ;;
  4078:       esac
  4079:       echo "----------------------------------------------------------------------"
  4080:     fi
  4081:     exit $EXIT_SUCCESS
  4082: }
  4083: 
  4084: test finish = "$opt_mode" && func_mode_finish ${1+"$@"}
  4085: 
  4086: 
  4087: # func_mode_install arg...
  4088: func_mode_install ()
  4089: {
  4090:     $debug_cmd
  4091: 
  4092:     # There may be an optional sh(1) argument at the beginning of
  4093:     # install_prog (especially on Windows NT).
  4094:     if test "$SHELL" = "$nonopt" || test /bin/sh = "$nonopt" ||
  4095:        # Allow the use of GNU shtool's install command.
  4096:        case $nonopt in *shtool*) :;; *) false;; esac
  4097:     then
  4098:       # Aesthetically quote it.
  4099:       func_quote_for_eval "$nonopt"
  4100:       install_prog="$func_quote_for_eval_result "
  4101:       arg=$1
  4102:       shift
  4103:     else
  4104:       install_prog=
  4105:       arg=$nonopt
  4106:     fi
  4107: 
  4108:     # The real first argument should be the name of the installation program.
  4109:     # Aesthetically quote it.
  4110:     func_quote_for_eval "$arg"
  4111:     func_append install_prog "$func_quote_for_eval_result"
  4112:     install_shared_prog=$install_prog
  4113:     case " $install_prog " in
  4114:       *[\\\ /]cp\ *) install_cp=: ;;
  4115:       *) install_cp=false ;;
  4116:     esac
  4117: 
  4118:     # We need to accept at least all the BSD install flags.
  4119:     dest=
  4120:     files=
  4121:     opts=
  4122:     prev=
  4123:     install_type=
  4124:     isdir=false
  4125:     stripme=
  4126:     no_mode=:
  4127:     for arg
  4128:     do
  4129:       arg2=
  4130:       if test -n "$dest"; then
  4131: 	func_append files " $dest"
  4132: 	dest=$arg
  4133: 	continue
  4134:       fi
  4135: 
  4136:       case $arg in
  4137:       -d) isdir=: ;;
  4138:       -f)
  4139: 	if $install_cp; then :; else
  4140: 	  prev=$arg
  4141: 	fi
  4142: 	;;
  4143:       -g | -m | -o)
  4144: 	prev=$arg
  4145: 	;;
  4146:       -s)
  4147: 	stripme=" -s"
  4148: 	continue
  4149: 	;;
  4150:       -*)
  4151: 	;;
  4152:       *)
  4153: 	# If the previous option needed an argument, then skip it.
  4154: 	if test -n "$prev"; then
  4155: 	  if test X-m = "X$prev" && test -n "$install_override_mode"; then
  4156: 	    arg2=$install_override_mode
  4157: 	    no_mode=false
  4158: 	  fi
  4159: 	  prev=
  4160: 	else
  4161: 	  dest=$arg
  4162: 	  continue
  4163: 	fi
  4164: 	;;
  4165:       esac
  4166: 
  4167:       # Aesthetically quote the argument.
  4168:       func_quote_for_eval "$arg"
  4169:       func_append install_prog " $func_quote_for_eval_result"
  4170:       if test -n "$arg2"; then
  4171: 	func_quote_for_eval "$arg2"
  4172:       fi
  4173:       func_append install_shared_prog " $func_quote_for_eval_result"
  4174:     done
  4175: 
  4176:     test -z "$install_prog" && \
  4177:       func_fatal_help "you must specify an install program"
  4178: 
  4179:     test -n "$prev" && \
  4180:       func_fatal_help "the '$prev' option requires an argument"
  4181: 
  4182:     if test -n "$install_override_mode" && $no_mode; then
  4183:       if $install_cp; then :; else
  4184: 	func_quote_for_eval "$install_override_mode"
  4185: 	func_append install_shared_prog " -m $func_quote_for_eval_result"
  4186:       fi
  4187:     fi
  4188: 
  4189:     if test -z "$files"; then
  4190:       if test -z "$dest"; then
  4191: 	func_fatal_help "no file or destination specified"
  4192:       else
  4193: 	func_fatal_help "you must specify a destination"
  4194:       fi
  4195:     fi
  4196: 
  4197:     # Strip any trailing slash from the destination.
  4198:     func_stripname '' '/' "$dest"
  4199:     dest=$func_stripname_result
  4200: 
  4201:     # Check to see that the destination is a directory.
  4202:     test -d "$dest" && isdir=:
  4203:     if $isdir; then
  4204:       destdir=$dest
  4205:       destname=
  4206:     else
  4207:       func_dirname_and_basename "$dest" "" "."
  4208:       destdir=$func_dirname_result
  4209:       destname=$func_basename_result
  4210: 
  4211:       # Not a directory, so check to see that there is only one file specified.
  4212:       set dummy $files; shift
  4213:       test "$#" -gt 1 && \
  4214: 	func_fatal_help "'$dest' is not a directory"
  4215:     fi
  4216:     case $destdir in
  4217:     [\\/]* | [A-Za-z]:[\\/]*) ;;
  4218:     *)
  4219:       for file in $files; do
  4220: 	case $file in
  4221: 	*.lo) ;;
  4222: 	*)
  4223: 	  func_fatal_help "'$destdir' must be an absolute directory name"
  4224: 	  ;;
  4225: 	esac
  4226:       done
  4227:       ;;
  4228:     esac
  4229: 
  4230:     # This variable tells wrapper scripts just to set variables rather
  4231:     # than running their programs.
  4232:     libtool_install_magic=$magic
  4233: 
  4234:     staticlibs=
  4235:     future_libdirs=
  4236:     current_libdirs=
  4237:     for file in $files; do
  4238: 
  4239:       # Do each installation.
  4240:       case $file in
  4241:       *.$libext)
  4242: 	# Do the static libraries later.
  4243: 	func_append staticlibs " $file"
  4244: 	;;
  4245: 
  4246:       *.la)
  4247: 	func_resolve_sysroot "$file"
  4248: 	file=$func_resolve_sysroot_result
  4249: 
  4250: 	# Check to see that this really is a libtool archive.
  4251: 	func_lalib_unsafe_p "$file" \
  4252: 	  || func_fatal_help "'$file' is not a valid libtool archive"
  4253: 
  4254: 	library_names=
  4255: 	old_library=
  4256: 	relink_command=
  4257: 	func_source "$file"
  4258: 
  4259: 	# Add the libdir to current_libdirs if it is the destination.
  4260: 	if test "X$destdir" = "X$libdir"; then
  4261: 	  case "$current_libdirs " in
  4262: 	  *" $libdir "*) ;;
  4263: 	  *) func_append current_libdirs " $libdir" ;;
  4264: 	  esac
  4265: 	else
  4266: 	  # Note the libdir as a future libdir.
  4267: 	  case "$future_libdirs " in
  4268: 	  *" $libdir "*) ;;
  4269: 	  *) func_append future_libdirs " $libdir" ;;
  4270: 	  esac
  4271: 	fi
  4272: 
  4273: 	func_dirname "$file" "/" ""
  4274: 	dir=$func_dirname_result
  4275: 	func_append dir "$objdir"
  4276: 
  4277: 	if test -n "$relink_command"; then
  4278: 	  # Determine the prefix the user has applied to our future dir.
  4279: 	  inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
  4280: 
  4281: 	  # Don't allow the user to place us outside of our expected
  4282: 	  # location b/c this prevents finding dependent libraries that
  4283: 	  # are installed to the same prefix.
  4284: 	  # At present, this check doesn't affect windows .dll's that
  4285: 	  # are installed into $libdir/../bin (currently, that works fine)
  4286: 	  # but it's something to keep an eye on.
  4287: 	  test "$inst_prefix_dir" = "$destdir" && \
  4288: 	    func_fatal_error "error: cannot install '$file' to a directory not ending in $libdir"
  4289: 
  4290: 	  if test -n "$inst_prefix_dir"; then
  4291: 	    # Stick the inst_prefix_dir data into the link command.
  4292: 	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
  4293: 	  else
  4294: 	    relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
  4295: 	  fi
  4296: 
  4297: 	  func_warning "relinking '$file'"
  4298: 	  func_show_eval "$relink_command" \
  4299: 	    'func_fatal_error "error: relink '\''$file'\'' with the above command before installing it"'
  4300: 	fi
  4301: 
  4302: 	# See the names of the shared library.
  4303: 	set dummy $library_names; shift
  4304: 	if test -n "$1"; then
  4305: 	  realname=$1
  4306: 	  shift
  4307: 
  4308: 	  srcname=$realname
  4309: 	  test -n "$relink_command" && srcname=${realname}T
  4310: 
  4311: 	  # Install the shared library and build the symlinks.
  4312: 	  func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
  4313: 	      'exit $?'
  4314: 	  tstripme=$stripme
  4315: 	  case $host_os in
  4316: 	  cygwin* | mingw* | pw32* | cegcc*)
  4317: 	    case $realname in
  4318: 	    *.dll.a)
  4319: 	      tstripme=
  4320: 	      ;;
  4321: 	    esac
  4322: 	    ;;
  4323: 	  os2*)
  4324: 	    case $realname in
  4325: 	    *_dll.a)
  4326: 	      tstripme=
  4327: 	      ;;
  4328: 	    esac
  4329: 	    ;;
  4330: 	  esac
  4331: 	  if test -n "$tstripme" && test -n "$striplib"; then
  4332: 	    func_show_eval "$striplib $destdir/$realname" 'exit $?'
  4333: 	  fi
  4334: 
  4335: 	  if test "$#" -gt 0; then
  4336: 	    # Delete the old symlinks, and create new ones.
  4337: 	    # Try 'ln -sf' first, because the 'ln' binary might depend on
  4338: 	    # the symlink we replace!  Solaris /bin/ln does not understand -f,
  4339: 	    # so we also need to try rm && ln -s.
  4340: 	    for linkname
  4341: 	    do
  4342: 	      test "$linkname" != "$realname" \
  4343: 		&& func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
  4344: 	    done
  4345: 	  fi
  4346: 
  4347: 	  # Do each command in the postinstall commands.
  4348: 	  lib=$destdir/$realname
  4349: 	  func_execute_cmds "$postinstall_cmds" 'exit $?'
  4350: 	fi
  4351: 
  4352: 	# Install the pseudo-library for information purposes.
  4353: 	func_basename "$file"
  4354: 	name=$func_basename_result
  4355: 	instname=$dir/${name}i
  4356: 	func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
  4357: 
  4358: 	# Maybe install the static library, too.
  4359: 	test -n "$old_library" && func_append staticlibs " $dir/$old_library"
  4360: 	;;
  4361: 
  4362:       *.lo)
  4363: 	# Install (i.e. copy) a libtool object.
  4364: 
  4365: 	# Figure out destination file name, if it wasn't already specified.
  4366: 	if test -n "$destname"; then
  4367: 	  destfile=$destdir/$destname
  4368: 	else
  4369: 	  func_basename "$file"
  4370: 	  destfile=$func_basename_result
  4371: 	  destfile=$destdir/$destfile
  4372: 	fi
  4373: 
  4374: 	# Deduce the name of the destination old-style object file.
  4375: 	case $destfile in
  4376: 	*.lo)
  4377: 	  func_lo2o "$destfile"
  4378: 	  staticdest=$func_lo2o_result
  4379: 	  ;;
  4380: 	*.$objext)
  4381: 	  staticdest=$destfile
  4382: 	  destfile=
  4383: 	  ;;
  4384: 	*)
  4385: 	  func_fatal_help "cannot copy a libtool object to '$destfile'"
  4386: 	  ;;
  4387: 	esac
  4388: 
  4389: 	# Install the libtool object if requested.
  4390: 	test -n "$destfile" && \
  4391: 	  func_show_eval "$install_prog $file $destfile" 'exit $?'
  4392: 
  4393: 	# Install the old object if enabled.
  4394: 	if test yes = "$build_old_libs"; then
  4395: 	  # Deduce the name of the old-style object file.
  4396: 	  func_lo2o "$file"
  4397: 	  staticobj=$func_lo2o_result
  4398: 	  func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
  4399: 	fi
  4400: 	exit $EXIT_SUCCESS
  4401: 	;;
  4402: 
  4403:       *)
  4404: 	# Figure out destination file name, if it wasn't already specified.
  4405: 	if test -n "$destname"; then
  4406: 	  destfile=$destdir/$destname
  4407: 	else
  4408: 	  func_basename "$file"
  4409: 	  destfile=$func_basename_result
  4410: 	  destfile=$destdir/$destfile
  4411: 	fi
  4412: 
  4413: 	# If the file is missing, and there is a .exe on the end, strip it
  4414: 	# because it is most likely a libtool script we actually want to
  4415: 	# install
  4416: 	stripped_ext=
  4417: 	case $file in
  4418: 	  *.exe)
  4419: 	    if test ! -f "$file"; then
  4420: 	      func_stripname '' '.exe' "$file"
  4421: 	      file=$func_stripname_result
  4422: 	      stripped_ext=.exe
  4423: 	    fi
  4424: 	    ;;
  4425: 	esac
  4426: 
  4427: 	# Do a test to see if this is really a libtool program.
  4428: 	case $host in
  4429: 	*cygwin* | *mingw*)
  4430: 	    if func_ltwrapper_executable_p "$file"; then
  4431: 	      func_ltwrapper_scriptname "$file"
  4432: 	      wrapper=$func_ltwrapper_scriptname_result
  4433: 	    else
  4434: 	      func_stripname '' '.exe' "$file"
  4435: 	      wrapper=$func_stripname_result
  4436: 	    fi
  4437: 	    ;;
  4438: 	*)
  4439: 	    wrapper=$file
  4440: 	    ;;
  4441: 	esac
  4442: 	if func_ltwrapper_script_p "$wrapper"; then
  4443: 	  notinst_deplibs=
  4444: 	  relink_command=
  4445: 
  4446: 	  func_source "$wrapper"
  4447: 
  4448: 	  # Check the variables that should have been set.
  4449: 	  test -z "$generated_by_libtool_version" && \
  4450: 	    func_fatal_error "invalid libtool wrapper script '$wrapper'"
  4451: 
  4452: 	  finalize=:
  4453: 	  for lib in $notinst_deplibs; do
  4454: 	    # Check to see that each library is installed.
  4455: 	    libdir=
  4456: 	    if test -f "$lib"; then
  4457: 	      func_source "$lib"
  4458: 	    fi
  4459: 	    libfile=$libdir/`$ECHO "$lib" | $SED 's%^.*/%%g'`
  4460: 	    if test -n "$libdir" && test ! -f "$libfile"; then
  4461: 	      func_warning "'$lib' has not been installed in '$libdir'"
  4462: 	      finalize=false
  4463: 	    fi
  4464: 	  done
  4465: 
  4466: 	  relink_command=
  4467: 	  func_source "$wrapper"
  4468: 
  4469: 	  outputname=
  4470: 	  if test no = "$fast_install" && test -n "$relink_command"; then
  4471: 	    $opt_dry_run || {
  4472: 	      if $finalize; then
  4473: 	        tmpdir=`func_mktempdir`
  4474: 		func_basename "$file$stripped_ext"
  4475: 		file=$func_basename_result
  4476: 	        outputname=$tmpdir/$file
  4477: 	        # Replace the output file specification.
  4478: 	        relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
  4479: 
  4480: 	        $opt_quiet || {
  4481: 	          func_quote_for_expand "$relink_command"
  4482: 		  eval "func_echo $func_quote_for_expand_result"
  4483: 	        }
  4484: 	        if eval "$relink_command"; then :
  4485: 	          else
  4486: 		  func_error "error: relink '$file' with the above command before installing it"
  4487: 		  $opt_dry_run || ${RM}r "$tmpdir"
  4488: 		  continue
  4489: 	        fi
  4490: 	        file=$outputname
  4491: 	      else
  4492: 	        func_warning "cannot relink '$file'"
  4493: 	      fi
  4494: 	    }
  4495: 	  else
  4496: 	    # Install the binary that we compiled earlier.
  4497: 	    file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
  4498: 	  fi
  4499: 	fi
  4500: 
  4501: 	# remove .exe since cygwin /usr/bin/install will append another
  4502: 	# one anyway
  4503: 	case $install_prog,$host in
  4504: 	*/usr/bin/install*,*cygwin*)
  4505: 	  case $file:$destfile in
  4506: 	  *.exe:*.exe)
  4507: 	    # this is ok
  4508: 	    ;;
  4509: 	  *.exe:*)
  4510: 	    destfile=$destfile.exe
  4511: 	    ;;
  4512: 	  *:*.exe)
  4513: 	    func_stripname '' '.exe' "$destfile"
  4514: 	    destfile=$func_stripname_result
  4515: 	    ;;
  4516: 	  esac
  4517: 	  ;;
  4518: 	esac
  4519: 	func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
  4520: 	$opt_dry_run || if test -n "$outputname"; then
  4521: 	  ${RM}r "$tmpdir"
  4522: 	fi
  4523: 	;;
  4524:       esac
  4525:     done
  4526: 
  4527:     for file in $staticlibs; do
  4528:       func_basename "$file"
  4529:       name=$func_basename_result
  4530: 
  4531:       # Set up the ranlib parameters.
  4532:       oldlib=$destdir/$name
  4533:       func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
  4534:       tool_oldlib=$func_to_tool_file_result
  4535: 
  4536:       func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
  4537: 
  4538:       if test -n "$stripme" && test -n "$old_striplib"; then
  4539: 	func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
  4540:       fi
  4541: 
  4542:       # Do each command in the postinstall commands.
  4543:       func_execute_cmds "$old_postinstall_cmds" 'exit $?'
  4544:     done
  4545: 
  4546:     test -n "$future_libdirs" && \
  4547:       func_warning "remember to run '$progname --finish$future_libdirs'"
  4548: 
  4549:     if test -n "$current_libdirs"; then
  4550:       # Maybe just do a dry run.
  4551:       $opt_dry_run && current_libdirs=" -n$current_libdirs"
  4552:       exec_cmd='$SHELL "$progpath" $preserve_args --finish$current_libdirs'
  4553:     else
  4554:       exit $EXIT_SUCCESS
  4555:     fi
  4556: }
  4557: 
  4558: test install = "$opt_mode" && func_mode_install ${1+"$@"}
  4559: 
  4560: 
  4561: # func_generate_dlsyms outputname originator pic_p
  4562: # Extract symbols from dlprefiles and create ${outputname}S.o with
  4563: # a dlpreopen symbol table.
  4564: func_generate_dlsyms ()
  4565: {
  4566:     $debug_cmd
  4567: 
  4568:     my_outputname=$1
  4569:     my_originator=$2
  4570:     my_pic_p=${3-false}
  4571:     my_prefix=`$ECHO "$my_originator" | $SED 's%[^a-zA-Z0-9]%_%g'`
  4572:     my_dlsyms=
  4573: 
  4574:     if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
  4575:       if test -n "$NM" && test -n "$global_symbol_pipe"; then
  4576: 	my_dlsyms=${my_outputname}S.c
  4577:       else
  4578: 	func_error "not configured to extract global symbols from dlpreopened files"
  4579:       fi
  4580:     fi
  4581: 
  4582:     if test -n "$my_dlsyms"; then
  4583:       case $my_dlsyms in
  4584:       "") ;;
  4585:       *.c)
  4586: 	# Discover the nlist of each of the dlfiles.
  4587: 	nlist=$output_objdir/$my_outputname.nm
  4588: 
  4589: 	func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
  4590: 
  4591: 	# Parse the name list into a source file.
  4592: 	func_verbose "creating $output_objdir/$my_dlsyms"
  4593: 
  4594: 	$opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
  4595: /* $my_dlsyms - symbol resolution table for '$my_outputname' dlsym emulation. */
  4596: /* Generated by $PROGRAM (GNU $PACKAGE) $VERSION */
  4597: 
  4598: #ifdef __cplusplus
  4599: extern \"C\" {
  4600: #endif
  4601: 
  4602: #if defined __GNUC__ && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
  4603: #pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
  4604: #endif
  4605: 
  4606: /* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
  4607: #if defined _WIN32 || defined __CYGWIN__ || defined _WIN32_WCE
  4608: /* DATA imports from DLLs on WIN32 can't be const, because runtime
  4609:    relocations are performed -- see ld's documentation on pseudo-relocs.  */
  4610: # define LT_DLSYM_CONST
  4611: #elif defined __osf__
  4612: /* This system does not cope well with relocations in const data.  */
  4613: # define LT_DLSYM_CONST
  4614: #else
  4615: # define LT_DLSYM_CONST const
  4616: #endif
  4617: 
  4618: #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
  4619: 
  4620: /* External symbol declarations for the compiler. */\
  4621: "
  4622: 
  4623: 	if test yes = "$dlself"; then
  4624: 	  func_verbose "generating symbol list for '$output'"
  4625: 
  4626: 	  $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
  4627: 
  4628: 	  # Add our own program objects to the symbol list.
  4629: 	  progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
  4630: 	  for progfile in $progfiles; do
  4631: 	    func_to_tool_file "$progfile" func_convert_file_msys_to_w32
  4632: 	    func_verbose "extracting global C symbols from '$func_to_tool_file_result'"
  4633: 	    $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
  4634: 	  done
  4635: 
  4636: 	  if test -n "$exclude_expsyms"; then
  4637: 	    $opt_dry_run || {
  4638: 	      eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
  4639: 	      eval '$MV "$nlist"T "$nlist"'
  4640: 	    }
  4641: 	  fi
  4642: 
  4643: 	  if test -n "$export_symbols_regex"; then
  4644: 	    $opt_dry_run || {
  4645: 	      eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
  4646: 	      eval '$MV "$nlist"T "$nlist"'
  4647: 	    }
  4648: 	  fi
  4649: 
  4650: 	  # Prepare the list of exported symbols
  4651: 	  if test -z "$export_symbols"; then
  4652: 	    export_symbols=$output_objdir/$outputname.exp
  4653: 	    $opt_dry_run || {
  4654: 	      $RM $export_symbols
  4655: 	      eval "$SED -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
  4656: 	      case $host in
  4657: 	      *cygwin* | *mingw* | *cegcc* )
  4658:                 eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
  4659:                 eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
  4660: 	        ;;
  4661: 	      esac
  4662: 	    }
  4663: 	  else
  4664: 	    $opt_dry_run || {
  4665: 	      eval "$SED -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
  4666: 	      eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
  4667: 	      eval '$MV "$nlist"T "$nlist"'
  4668: 	      case $host in
  4669: 	        *cygwin* | *mingw* | *cegcc* )
  4670: 	          eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
  4671: 	          eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
  4672: 	          ;;
  4673: 	      esac
  4674: 	    }
  4675: 	  fi
  4676: 	fi
  4677: 
  4678: 	for dlprefile in $dlprefiles; do
  4679: 	  func_verbose "extracting global C symbols from '$dlprefile'"
  4680: 	  func_basename "$dlprefile"
  4681: 	  name=$func_basename_result
  4682:           case $host in
  4683: 	    *cygwin* | *mingw* | *cegcc* )
  4684: 	      # if an import library, we need to obtain dlname
  4685: 	      if func_win32_import_lib_p "$dlprefile"; then
  4686: 	        func_tr_sh "$dlprefile"
  4687: 	        eval "curr_lafile=\$libfile_$func_tr_sh_result"
  4688: 	        dlprefile_dlbasename=
  4689: 	        if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
  4690: 	          # Use subshell, to avoid clobbering current variable values
  4691: 	          dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
  4692: 	          if test -n "$dlprefile_dlname"; then
  4693: 	            func_basename "$dlprefile_dlname"
  4694: 	            dlprefile_dlbasename=$func_basename_result
  4695: 	          else
  4696: 	            # no lafile. user explicitly requested -dlpreopen <import library>.
  4697: 	            $sharedlib_from_linklib_cmd "$dlprefile"
  4698: 	            dlprefile_dlbasename=$sharedlib_from_linklib_result
  4699: 	          fi
  4700: 	        fi
  4701: 	        $opt_dry_run || {
  4702: 	          if test -n "$dlprefile_dlbasename"; then
  4703: 	            eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
  4704: 	          else
  4705: 	            func_warning "Could not compute DLL name from $name"
  4706: 	            eval '$ECHO ": $name " >> "$nlist"'
  4707: 	          fi
  4708: 	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
  4709: 	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
  4710: 	            $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
  4711: 	        }
  4712: 	      else # not an import lib
  4713: 	        $opt_dry_run || {
  4714: 	          eval '$ECHO ": $name " >> "$nlist"'
  4715: 	          func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
  4716: 	          eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
  4717: 	        }
  4718: 	      fi
  4719: 	    ;;
  4720: 	    *)
  4721: 	      $opt_dry_run || {
  4722: 	        eval '$ECHO ": $name " >> "$nlist"'
  4723: 	        func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
  4724: 	        eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
  4725: 	      }
  4726: 	    ;;
  4727:           esac
  4728: 	done
  4729: 
  4730: 	$opt_dry_run || {
  4731: 	  # Make sure we have at least an empty file.
  4732: 	  test -f "$nlist" || : > "$nlist"
  4733: 
  4734: 	  if test -n "$exclude_expsyms"; then
  4735: 	    $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
  4736: 	    $MV "$nlist"T "$nlist"
  4737: 	  fi
  4738: 
  4739: 	  # Try sorting and uniquifying the output.
  4740: 	  if $GREP -v "^: " < "$nlist" |
  4741: 	      if sort -k 3 </dev/null >/dev/null 2>&1; then
  4742: 		sort -k 3
  4743: 	      else
  4744: 		sort +2
  4745: 	      fi |
  4746: 	      uniq > "$nlist"S; then
  4747: 	    :
  4748: 	  else
  4749: 	    $GREP -v "^: " < "$nlist" > "$nlist"S
  4750: 	  fi
  4751: 
  4752: 	  if test -f "$nlist"S; then
  4753: 	    eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
  4754: 	  else
  4755: 	    echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
  4756: 	  fi
  4757: 
  4758: 	  func_show_eval '$RM "${nlist}I"'
  4759: 	  if test -n "$global_symbol_to_import"; then
  4760: 	    eval "$global_symbol_to_import"' < "$nlist"S > "$nlist"I'
  4761: 	  fi
  4762: 
  4763: 	  echo >> "$output_objdir/$my_dlsyms" "\
  4764: 
  4765: /* The mapping between symbol names and symbols.  */
  4766: typedef struct {
  4767:   const char *name;
  4768:   void *address;
  4769: } lt_dlsymlist;
  4770: extern LT_DLSYM_CONST lt_dlsymlist
  4771: lt_${my_prefix}_LTX_preloaded_symbols[];\
  4772: "
  4773: 
  4774: 	  if test -s "$nlist"I; then
  4775: 	    echo >> "$output_objdir/$my_dlsyms" "\
  4776: static void lt_syminit(void)
  4777: {
  4778:   LT_DLSYM_CONST lt_dlsymlist *symbol = lt_${my_prefix}_LTX_preloaded_symbols;
  4779:   for (; symbol->name; ++symbol)
  4780:     {"
  4781: 	    $SED 's/.*/      if (STREQ (symbol->name, \"&\")) symbol->address = (void *) \&&;/' < "$nlist"I >> "$output_objdir/$my_dlsyms"
  4782: 	    echo >> "$output_objdir/$my_dlsyms" "\
  4783:     }
  4784: }"
  4785: 	  fi
  4786: 	  echo >> "$output_objdir/$my_dlsyms" "\
  4787: LT_DLSYM_CONST lt_dlsymlist
  4788: lt_${my_prefix}_LTX_preloaded_symbols[] =
  4789: { {\"$my_originator\", (void *) 0},"
  4790: 
  4791: 	  if test -s "$nlist"I; then
  4792: 	    echo >> "$output_objdir/$my_dlsyms" "\
  4793:   {\"@INIT@\", (void *) <_syminit},"
  4794: 	  fi
  4795: 
  4796: 	  case $need_lib_prefix in
  4797: 	  no)
  4798: 	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
  4799: 	    ;;
  4800: 	  *)
  4801: 	    eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
  4802: 	    ;;
  4803: 	  esac
  4804: 	  echo >> "$output_objdir/$my_dlsyms" "\
  4805:   {0, (void *) 0}
  4806: };
  4807: 
  4808: /* This works around a problem in FreeBSD linker */
  4809: #ifdef FREEBSD_WORKAROUND
  4810: static const void *lt_preloaded_setup() {
  4811:   return lt_${my_prefix}_LTX_preloaded_symbols;
  4812: }
  4813: #endif
  4814: 
  4815: #ifdef __cplusplus
  4816: }
  4817: #endif\
  4818: "
  4819: 	} # !$opt_dry_run
  4820: 
  4821: 	pic_flag_for_symtable=
  4822: 	case "$compile_command " in
  4823: 	*" -static "*) ;;
  4824: 	*)
  4825: 	  case $host in
  4826: 	  # compiling the symbol table file with pic_flag works around
  4827: 	  # a FreeBSD bug that causes programs to crash when -lm is
  4828: 	  # linked before any other PIC object.  But we must not use
  4829: 	  # pic_flag when linking with -static.  The problem exists in
  4830: 	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
  4831: 	  *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
  4832: 	    pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
  4833: 	  *-*-hpux*)
  4834: 	    pic_flag_for_symtable=" $pic_flag"  ;;
  4835: 	  *)
  4836: 	    $my_pic_p && pic_flag_for_symtable=" $pic_flag"
  4837: 	    ;;
  4838: 	  esac
  4839: 	  ;;
  4840: 	esac
  4841: 	symtab_cflags=
  4842: 	for arg in $LTCFLAGS; do
  4843: 	  case $arg in
  4844: 	  -pie | -fpie | -fPIE) ;;
  4845: 	  *) func_append symtab_cflags " $arg" ;;
  4846: 	  esac
  4847: 	done
  4848: 
  4849: 	# Now compile the dynamic symbol file.
  4850: 	func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
  4851: 
  4852: 	# Clean up the generated files.
  4853: 	func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T" "${nlist}I"'
  4854: 
  4855: 	# Transform the symbol file into the correct name.
  4856: 	symfileobj=$output_objdir/${my_outputname}S.$objext
  4857: 	case $host in
  4858: 	*cygwin* | *mingw* | *cegcc* )
  4859: 	  if test -f "$output_objdir/$my_outputname.def"; then
  4860: 	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
  4861: 	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
  4862: 	  else
  4863: 	    compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
  4864: 	    finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
  4865: 	  fi
  4866: 	  ;;
  4867: 	*)
  4868: 	  compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
  4869: 	  finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
  4870: 	  ;;
  4871: 	esac
  4872: 	;;
  4873:       *)
  4874: 	func_fatal_error "unknown suffix for '$my_dlsyms'"
  4875: 	;;
  4876:       esac
  4877:     else
  4878:       # We keep going just in case the user didn't refer to
  4879:       # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
  4880:       # really was required.
  4881: 
  4882:       # Nullify the symbol file.
  4883:       compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
  4884:       finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
  4885:     fi
  4886: }
  4887: 
  4888: # func_cygming_gnu_implib_p ARG
  4889: # This predicate returns with zero status (TRUE) if
  4890: # ARG is a GNU/binutils-style import library. Returns
  4891: # with nonzero status (FALSE) otherwise.
  4892: func_cygming_gnu_implib_p ()
  4893: {
  4894:   $debug_cmd
  4895: 
  4896:   func_to_tool_file "$1" func_convert_file_msys_to_w32
  4897:   func_cygming_gnu_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $EGREP ' (_head_[A-Za-z0-9_]+_[ad]l*|[A-Za-z0-9_]+_[ad]l*_iname)$'`
  4898:   test -n "$func_cygming_gnu_implib_tmp"
  4899: }
  4900: 
  4901: # func_cygming_ms_implib_p ARG
  4902: # This predicate returns with zero status (TRUE) if
  4903: # ARG is an MS-style import library. Returns
  4904: # with nonzero status (FALSE) otherwise.
  4905: func_cygming_ms_implib_p ()
  4906: {
  4907:   $debug_cmd
  4908: 
  4909:   func_to_tool_file "$1" func_convert_file_msys_to_w32
  4910:   func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
  4911:   test -n "$func_cygming_ms_implib_tmp"
  4912: }
  4913: 
  4914: # func_win32_libid arg
  4915: # return the library type of file 'arg'
  4916: #
  4917: # Need a lot of goo to handle *both* DLLs and import libs
  4918: # Has to be a shell function in order to 'eat' the argument
  4919: # that is supplied when $file_magic_command is called.
  4920: # Despite the name, also deal with 64 bit binaries.
  4921: func_win32_libid ()
  4922: {
  4923:   $debug_cmd
  4924: 
  4925:   win32_libid_type=unknown
  4926:   win32_fileres=`file -L $1 2>/dev/null`
  4927:   case $win32_fileres in
  4928:   *ar\ archive\ import\ library*) # definitely import
  4929:     win32_libid_type="x86 archive import"
  4930:     ;;
  4931:   *ar\ archive*) # could be an import, or static
  4932:     # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
  4933:     if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
  4934:        $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
  4935:       case $nm_interface in
  4936:       "MS dumpbin")
  4937: 	if func_cygming_ms_implib_p "$1" ||
  4938: 	   func_cygming_gnu_implib_p "$1"
  4939: 	then
  4940: 	  win32_nmres=import
  4941: 	else
  4942: 	  win32_nmres=
  4943: 	fi
  4944: 	;;
  4945:       *)
  4946: 	func_to_tool_file "$1" func_convert_file_msys_to_w32
  4947: 	win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
  4948: 	  $SED -n -e '
  4949: 	    1,100{
  4950: 		/ I /{
  4951: 		    s|.*|import|
  4952: 		    p
  4953: 		    q
  4954: 		}
  4955: 	    }'`
  4956: 	;;
  4957:       esac
  4958:       case $win32_nmres in
  4959:       import*)  win32_libid_type="x86 archive import";;
  4960:       *)        win32_libid_type="x86 archive static";;
  4961:       esac
  4962:     fi
  4963:     ;;
  4964:   *DLL*)
  4965:     win32_libid_type="x86 DLL"
  4966:     ;;
  4967:   *executable*) # but shell scripts are "executable" too...
  4968:     case $win32_fileres in
  4969:     *MS\ Windows\ PE\ Intel*)
  4970:       win32_libid_type="x86 DLL"
  4971:       ;;
  4972:     esac
  4973:     ;;
  4974:   esac
  4975:   $ECHO "$win32_libid_type"
  4976: }
  4977: 
  4978: # func_cygming_dll_for_implib ARG
  4979: #
  4980: # Platform-specific function to extract the
  4981: # name of the DLL associated with the specified
  4982: # import library ARG.
  4983: # Invoked by eval'ing the libtool variable
  4984: #    $sharedlib_from_linklib_cmd
  4985: # Result is available in the variable
  4986: #    $sharedlib_from_linklib_result
  4987: func_cygming_dll_for_implib ()
  4988: {
  4989:   $debug_cmd
  4990: 
  4991:   sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
  4992: }
  4993: 
  4994: # func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
  4995: #
  4996: # The is the core of a fallback implementation of a
  4997: # platform-specific function to extract the name of the
  4998: # DLL associated with the specified import library LIBNAME.
  4999: #
  5000: # SECTION_NAME is either .idata$6 or .idata$7, depending
  5001: # on the platform and compiler that created the implib.
  5002: #
  5003: # Echos the name of the DLL associated with the
  5004: # specified import library.
  5005: func_cygming_dll_for_implib_fallback_core ()
  5006: {
  5007:   $debug_cmd
  5008: 
  5009:   match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
  5010:   $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
  5011:     $SED '/^Contents of section '"$match_literal"':/{
  5012:       # Place marker at beginning of archive member dllname section
  5013:       s/.*/====MARK====/
  5014:       p
  5015:       d
  5016:     }
  5017:     # These lines can sometimes be longer than 43 characters, but
  5018:     # are always uninteresting
  5019:     /:[	 ]*file format pe[i]\{,1\}-/d
  5020:     /^In archive [^:]*:/d
  5021:     # Ensure marker is printed
  5022:     /^====MARK====/p
  5023:     # Remove all lines with less than 43 characters
  5024:     /^.\{43\}/!d
  5025:     # From remaining lines, remove first 43 characters
  5026:     s/^.\{43\}//' |
  5027:     $SED -n '
  5028:       # Join marker and all lines until next marker into a single line
  5029:       /^====MARK====/ b para
  5030:       H
  5031:       $ b para
  5032:       b
  5033:       :para
  5034:       x
  5035:       s/\n//g
  5036:       # Remove the marker
  5037:       s/^====MARK====//
  5038:       # Remove trailing dots and whitespace
  5039:       s/[\. \t]*$//
  5040:       # Print
  5041:       /./p' |
  5042:     # we now have a list, one entry per line, of the stringified
  5043:     # contents of the appropriate section of all members of the
  5044:     # archive that possess that section. Heuristic: eliminate
  5045:     # all those that have a first or second character that is
  5046:     # a '.' (that is, objdump's representation of an unprintable
  5047:     # character.) This should work for all archives with less than
  5048:     # 0x302f exports -- but will fail for DLLs whose name actually
  5049:     # begins with a literal '.' or a single character followed by
  5050:     # a '.'.
  5051:     #
  5052:     # Of those that remain, print the first one.
  5053:     $SED -e '/^\./d;/^.\./d;q'
  5054: }
  5055: 
  5056: # func_cygming_dll_for_implib_fallback ARG
  5057: # Platform-specific function to extract the
  5058: # name of the DLL associated with the specified
  5059: # import library ARG.
  5060: #
  5061: # This fallback implementation is for use when $DLLTOOL
  5062: # does not support the --identify-strict option.
  5063: # Invoked by eval'ing the libtool variable
  5064: #    $sharedlib_from_linklib_cmd
  5065: # Result is available in the variable
  5066: #    $sharedlib_from_linklib_result
  5067: func_cygming_dll_for_implib_fallback ()
  5068: {
  5069:   $debug_cmd
  5070: 
  5071:   if func_cygming_gnu_implib_p "$1"; then
  5072:     # binutils import library
  5073:     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
  5074:   elif func_cygming_ms_implib_p "$1"; then
  5075:     # ms-generated import library
  5076:     sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
  5077:   else
  5078:     # unknown
  5079:     sharedlib_from_linklib_result=
  5080:   fi
  5081: }
  5082: 
  5083: 
  5084: # func_extract_an_archive dir oldlib
  5085: func_extract_an_archive ()
  5086: {
  5087:     $debug_cmd
  5088: 
  5089:     f_ex_an_ar_dir=$1; shift
  5090:     f_ex_an_ar_oldlib=$1
  5091:     if test yes = "$lock_old_archive_extraction"; then
  5092:       lockfile=$f_ex_an_ar_oldlib.lock
  5093:       until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
  5094: 	func_echo "Waiting for $lockfile to be removed"
  5095: 	sleep 2
  5096:       done
  5097:     fi
  5098:     func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
  5099: 		   'stat=$?; rm -f "$lockfile"; exit $stat'
  5100:     if test yes = "$lock_old_archive_extraction"; then
  5101:       $opt_dry_run || rm -f "$lockfile"
  5102:     fi
  5103:     if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
  5104:      :
  5105:     else
  5106:       func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
  5107:     fi
  5108: }
  5109: 
  5110: 
  5111: # func_extract_archives gentop oldlib ...
  5112: func_extract_archives ()
  5113: {
  5114:     $debug_cmd
  5115: 
  5116:     my_gentop=$1; shift
  5117:     my_oldlibs=${1+"$@"}
  5118:     my_oldobjs=
  5119:     my_xlib=
  5120:     my_xabs=
  5121:     my_xdir=
  5122: 
  5123:     for my_xlib in $my_oldlibs; do
  5124:       # Extract the objects.
  5125:       case $my_xlib in
  5126: 	[\\/]* | [A-Za-z]:[\\/]*) my_xabs=$my_xlib ;;
  5127: 	*) my_xabs=`pwd`"/$my_xlib" ;;
  5128:       esac
  5129:       func_basename "$my_xlib"
  5130:       my_xlib=$func_basename_result
  5131:       my_xlib_u=$my_xlib
  5132:       while :; do
  5133:         case " $extracted_archives " in
  5134: 	*" $my_xlib_u "*)
  5135: 	  func_arith $extracted_serial + 1
  5136: 	  extracted_serial=$func_arith_result
  5137: 	  my_xlib_u=lt$extracted_serial-$my_xlib ;;
  5138: 	*) break ;;
  5139: 	esac
  5140:       done
  5141:       extracted_archives="$extracted_archives $my_xlib_u"
  5142:       my_xdir=$my_gentop/$my_xlib_u
  5143: 
  5144:       func_mkdir_p "$my_xdir"
  5145: 
  5146:       case $host in
  5147:       *-darwin*)
  5148: 	func_verbose "Extracting $my_xabs"
  5149: 	# Do not bother doing anything if just a dry run
  5150: 	$opt_dry_run || {
  5151: 	  darwin_orig_dir=`pwd`
  5152: 	  cd $my_xdir || exit $?
  5153: 	  darwin_archive=$my_xabs
  5154: 	  darwin_curdir=`pwd`
  5155: 	  func_basename "$darwin_archive"
  5156: 	  darwin_base_archive=$func_basename_result
  5157: 	  darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
  5158: 	  if test -n "$darwin_arches"; then
  5159: 	    darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
  5160: 	    darwin_arch=
  5161: 	    func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
  5162: 	    for darwin_arch in  $darwin_arches; do
  5163: 	      func_mkdir_p "unfat-$$/$darwin_base_archive-$darwin_arch"
  5164: 	      $LIPO -thin $darwin_arch -output "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive" "$darwin_archive"
  5165: 	      cd "unfat-$$/$darwin_base_archive-$darwin_arch"
  5166: 	      func_extract_an_archive "`pwd`" "$darwin_base_archive"
  5167: 	      cd "$darwin_curdir"
  5168: 	      $RM "unfat-$$/$darwin_base_archive-$darwin_arch/$darwin_base_archive"
  5169: 	    done # $darwin_arches
  5170:             ## Okay now we've a bunch of thin objects, gotta fatten them up :)
  5171: 	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$sed_basename" | sort -u`
  5172: 	    darwin_file=
  5173: 	    darwin_files=
  5174: 	    for darwin_file in $darwin_filelist; do
  5175: 	      darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
  5176: 	      $LIPO -create -output "$darwin_file" $darwin_files
  5177: 	    done # $darwin_filelist
  5178: 	    $RM -rf unfat-$$
  5179: 	    cd "$darwin_orig_dir"
  5180: 	  else
  5181: 	    cd $darwin_orig_dir
  5182: 	    func_extract_an_archive "$my_xdir" "$my_xabs"
  5183: 	  fi # $darwin_arches
  5184: 	} # !$opt_dry_run
  5185: 	;;
  5186:       *)
  5187:         func_extract_an_archive "$my_xdir" "$my_xabs"
  5188: 	;;
  5189:       esac
  5190:       my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
  5191:     done
  5192: 
  5193:     func_extract_archives_result=$my_oldobjs
  5194: }
  5195: 
  5196: 
  5197: # func_emit_wrapper [arg=no]
  5198: #
  5199: # Emit a libtool wrapper script on stdout.
  5200: # Don't directly open a file because we may want to
  5201: # incorporate the script contents within a cygwin/mingw
  5202: # wrapper executable.  Must ONLY be called from within
  5203: # func_mode_link because it depends on a number of variables
  5204: # set therein.
  5205: #
  5206: # ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
  5207: # variable will take.  If 'yes', then the emitted script
  5208: # will assume that the directory where it is stored is
  5209: # the $objdir directory.  This is a cygwin/mingw-specific
  5210: # behavior.
  5211: func_emit_wrapper ()
  5212: {
  5213: 	func_emit_wrapper_arg1=${1-no}
  5214: 
  5215: 	$ECHO "\
  5216: #! $SHELL
  5217: 
  5218: # $output - temporary wrapper script for $objdir/$outputname
  5219: # Generated by $PROGRAM (GNU $PACKAGE) $VERSION
  5220: #
  5221: # The $output program cannot be directly executed until all the libtool
  5222: # libraries that it depends on are installed.
  5223: #
  5224: # This wrapper script should never be moved out of the build directory.
  5225: # If it is, it will not operate correctly.
  5226: 
  5227: # Sed substitution that helps us do robust quoting.  It backslashifies
  5228: # metacharacters that are still active within double-quoted strings.
  5229: sed_quote_subst='$sed_quote_subst'
  5230: 
  5231: # Be Bourne compatible
  5232: if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
  5233:   emulate sh
  5234:   NULLCMD=:
  5235:   # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
  5236:   # is contrary to our usage.  Disable this feature.
  5237:   alias -g '\${1+\"\$@\"}'='\"\$@\"'
  5238:   setopt NO_GLOB_SUBST
  5239: else
  5240:   case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
  5241: fi
  5242: BIN_SH=xpg4; export BIN_SH # for Tru64
  5243: DUALCASE=1; export DUALCASE # for MKS sh
  5244: 
  5245: # The HP-UX ksh and POSIX shell print the target directory to stdout
  5246: # if CDPATH is set.
  5247: (unset CDPATH) >/dev/null 2>&1 && unset CDPATH
  5248: 
  5249: relink_command=\"$relink_command\"
  5250: 
  5251: # This environment variable determines our operation mode.
  5252: if test \"\$libtool_install_magic\" = \"$magic\"; then
  5253:   # install mode needs the following variables:
  5254:   generated_by_libtool_version='$macro_version'
  5255:   notinst_deplibs='$notinst_deplibs'
  5256: else
  5257:   # When we are sourced in execute mode, \$file and \$ECHO are already set.
  5258:   if test \"\$libtool_execute_magic\" != \"$magic\"; then
  5259:     file=\"\$0\""
  5260: 
  5261:     qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
  5262:     $ECHO "\
  5263: 
  5264: # A function that is used when there is no print builtin or printf.
  5265: func_fallback_echo ()
  5266: {
  5267:   eval 'cat <<_LTECHO_EOF
  5268: \$1
  5269: _LTECHO_EOF'
  5270: }
  5271:     ECHO=\"$qECHO\"
  5272:   fi
  5273: 
  5274: # Very basic option parsing. These options are (a) specific to
  5275: # the libtool wrapper, (b) are identical between the wrapper
  5276: # /script/ and the wrapper /executable/ that is used only on
  5277: # windows platforms, and (c) all begin with the string "--lt-"
  5278: # (application programs are unlikely to have options that match
  5279: # this pattern).
  5280: #
  5281: # There are only two supported options: --lt-debug and
  5282: # --lt-dump-script. There is, deliberately, no --lt-help.
  5283: #
  5284: # The first argument to this parsing function should be the
  5285: # script's $0 value, followed by "$@".
  5286: lt_option_debug=
  5287: func_parse_lt_options ()
  5288: {
  5289:   lt_script_arg0=\$0
  5290:   shift
  5291:   for lt_opt
  5292:   do
  5293:     case \"\$lt_opt\" in
  5294:     --lt-debug) lt_option_debug=1 ;;
  5295:     --lt-dump-script)
  5296:         lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
  5297:         test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
  5298:         lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
  5299:         cat \"\$lt_dump_D/\$lt_dump_F\"
  5300:         exit 0
  5301:       ;;
  5302:     --lt-*)
  5303:         \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
  5304:         exit 1
  5305:       ;;
  5306:     esac
  5307:   done
  5308: 
  5309:   # Print the debug banner immediately:
  5310:   if test -n \"\$lt_option_debug\"; then
  5311:     echo \"$outputname:$output:\$LINENO: libtool wrapper (GNU $PACKAGE) $VERSION\" 1>&2
  5312:   fi
  5313: }
  5314: 
  5315: # Used when --lt-debug. Prints its arguments to stdout
  5316: # (redirection is the responsibility of the caller)
  5317: func_lt_dump_args ()
  5318: {
  5319:   lt_dump_args_N=1;
  5320:   for lt_arg
  5321:   do
  5322:     \$ECHO \"$outputname:$output:\$LINENO: newargv[\$lt_dump_args_N]: \$lt_arg\"
  5323:     lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
  5324:   done
  5325: }
  5326: 
  5327: # Core function for launching the target application
  5328: func_exec_program_core ()
  5329: {
  5330: "
  5331:   case $host in
  5332:   # Backslashes separate directories on plain windows
  5333:   *-*-mingw | *-*-os2* | *-cegcc*)
  5334:     $ECHO "\
  5335:       if test -n \"\$lt_option_debug\"; then
  5336:         \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir\\\\\$program\" 1>&2
  5337:         func_lt_dump_args \${1+\"\$@\"} 1>&2
  5338:       fi
  5339:       exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
  5340: "
  5341:     ;;
  5342: 
  5343:   *)
  5344:     $ECHO "\
  5345:       if test -n \"\$lt_option_debug\"; then
  5346:         \$ECHO \"$outputname:$output:\$LINENO: newargv[0]: \$progdir/\$program\" 1>&2
  5347:         func_lt_dump_args \${1+\"\$@\"} 1>&2
  5348:       fi
  5349:       exec \"\$progdir/\$program\" \${1+\"\$@\"}
  5350: "
  5351:     ;;
  5352:   esac
  5353:   $ECHO "\
  5354:       \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
  5355:       exit 1
  5356: }
  5357: 
  5358: # A function to encapsulate launching the target application
  5359: # Strips options in the --lt-* namespace from \$@ and
  5360: # launches target application with the remaining arguments.
  5361: func_exec_program ()
  5362: {
  5363:   case \" \$* \" in
  5364:   *\\ --lt-*)
  5365:     for lt_wr_arg
  5366:     do
  5367:       case \$lt_wr_arg in
  5368:       --lt-*) ;;
  5369:       *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
  5370:       esac
  5371:       shift
  5372:     done ;;
  5373:   esac
  5374:   func_exec_program_core \${1+\"\$@\"}
  5375: }
  5376: 
  5377:   # Parse options
  5378:   func_parse_lt_options \"\$0\" \${1+\"\$@\"}
  5379: 
  5380:   # Find the directory that this script lives in.
  5381:   thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
  5382:   test \"x\$thisdir\" = \"x\$file\" && thisdir=.
  5383: 
  5384:   # Follow symbolic links until we get to the real thisdir.
  5385:   file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
  5386:   while test -n \"\$file\"; do
  5387:     destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
  5388: 
  5389:     # If there was a directory component, then change thisdir.
  5390:     if test \"x\$destdir\" != \"x\$file\"; then
  5391:       case \"\$destdir\" in
  5392:       [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
  5393:       *) thisdir=\"\$thisdir/\$destdir\" ;;
  5394:       esac
  5395:     fi
  5396: 
  5397:     file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
  5398:     file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
  5399:   done
  5400: 
  5401:   # Usually 'no', except on cygwin/mingw when embedded into
  5402:   # the cwrapper.
  5403:   WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
  5404:   if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
  5405:     # special case for '.'
  5406:     if test \"\$thisdir\" = \".\"; then
  5407:       thisdir=\`pwd\`
  5408:     fi
  5409:     # remove .libs from thisdir
  5410:     case \"\$thisdir\" in
  5411:     *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
  5412:     $objdir )   thisdir=. ;;
  5413:     esac
  5414:   fi
  5415: 
  5416:   # Try to get the absolute directory name.
  5417:   absdir=\`cd \"\$thisdir\" && pwd\`
  5418:   test -n \"\$absdir\" && thisdir=\"\$absdir\"
  5419: "
  5420: 
  5421: 	if test yes = "$fast_install"; then
  5422: 	  $ECHO "\
  5423:   program=lt-'$outputname'$exeext
  5424:   progdir=\"\$thisdir/$objdir\"
  5425: 
  5426:   if test ! -f \"\$progdir/\$program\" ||
  5427:      { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | $SED 1q\`; \\
  5428:        test \"X\$file\" != \"X\$progdir/\$program\"; }; then
  5429: 
  5430:     file=\"\$\$-\$program\"
  5431: 
  5432:     if test ! -d \"\$progdir\"; then
  5433:       $MKDIR \"\$progdir\"
  5434:     else
  5435:       $RM \"\$progdir/\$file\"
  5436:     fi"
  5437: 
  5438: 	  $ECHO "\
  5439: 
  5440:     # relink executable if necessary
  5441:     if test -n \"\$relink_command\"; then
  5442:       if relink_command_output=\`eval \$relink_command 2>&1\`; then :
  5443:       else
  5444: 	\$ECHO \"\$relink_command_output\" >&2
  5445: 	$RM \"\$progdir/\$file\"
  5446: 	exit 1
  5447:       fi
  5448:     fi
  5449: 
  5450:     $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
  5451:     { $RM \"\$progdir/\$program\";
  5452:       $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
  5453:     $RM \"\$progdir/\$file\"
  5454:   fi"
  5455: 	else
  5456: 	  $ECHO "\
  5457:   program='$outputname'
  5458:   progdir=\"\$thisdir/$objdir\"
  5459: "
  5460: 	fi
  5461: 
  5462: 	$ECHO "\
  5463: 
  5464:   if test -f \"\$progdir/\$program\"; then"
  5465: 
  5466: 	# fixup the dll searchpath if we need to.
  5467: 	#
  5468: 	# Fix the DLL searchpath if we need to.  Do this before prepending
  5469: 	# to shlibpath, because on Windows, both are PATH and uninstalled
  5470: 	# libraries must come first.
  5471: 	if test -n "$dllsearchpath"; then
  5472: 	  $ECHO "\
  5473:     # Add the dll search path components to the executable PATH
  5474:     PATH=$dllsearchpath:\$PATH
  5475: "
  5476: 	fi
  5477: 
  5478: 	# Export our shlibpath_var if we have one.
  5479: 	if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
  5480: 	  $ECHO "\
  5481:     # Add our own library path to $shlibpath_var
  5482:     $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
  5483: 
  5484:     # Some systems cannot cope with colon-terminated $shlibpath_var
  5485:     # The second colon is a workaround for a bug in BeOS R4 sed
  5486:     $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
  5487: 
  5488:     export $shlibpath_var
  5489: "
  5490: 	fi
  5491: 
  5492: 	$ECHO "\
  5493:     if test \"\$libtool_execute_magic\" != \"$magic\"; then
  5494:       # Run the actual program with our arguments.
  5495:       func_exec_program \${1+\"\$@\"}
  5496:     fi
  5497:   else
  5498:     # The program doesn't exist.
  5499:     \$ECHO \"\$0: error: '\$progdir/\$program' does not exist\" 1>&2
  5500:     \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
  5501:     \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
  5502:     exit 1
  5503:   fi
  5504: fi\
  5505: "
  5506: }
  5507: 
  5508: 
  5509: # func_emit_cwrapperexe_src
  5510: # emit the source code for a wrapper executable on stdout
  5511: # Must ONLY be called from within func_mode_link because
  5512: # it depends on a number of variable set therein.
  5513: func_emit_cwrapperexe_src ()
  5514: {
  5515: 	cat <<EOF
  5516: 
  5517: /* $cwrappersource - temporary wrapper executable for $objdir/$outputname
  5518:    Generated by $PROGRAM (GNU $PACKAGE) $VERSION
  5519: 
  5520:    The $output program cannot be directly executed until all the libtool
  5521:    libraries that it depends on are installed.
  5522: 
  5523:    This wrapper executable should never be moved out of the build directory.
  5524:    If it is, it will not operate correctly.
  5525: */
  5526: EOF
  5527: 	    cat <<"EOF"
  5528: #ifdef _MSC_VER
  5529: # define _CRT_SECURE_NO_DEPRECATE 1
  5530: #endif
  5531: #include <stdio.h>
  5532: #include <stdlib.h>
  5533: #ifdef _MSC_VER
  5534: # include <direct.h>
  5535: # include <process.h>
  5536: # include <io.h>
  5537: #else
  5538: # include <unistd.h>
  5539: # include <stdint.h>
  5540: # ifdef __CYGWIN__
  5541: #  include <io.h>
  5542: # endif
  5543: #endif
  5544: #include <malloc.h>
  5545: #include <stdarg.h>
  5546: #include <assert.h>
  5547: #include <string.h>
  5548: #include <ctype.h>
  5549: #include <errno.h>
  5550: #include <fcntl.h>
  5551: #include <sys/stat.h>
  5552: 
  5553: #define STREQ(s1, s2) (strcmp ((s1), (s2)) == 0)
  5554: 
  5555: /* declarations of non-ANSI functions */
  5556: #if defined __MINGW32__
  5557: # ifdef __STRICT_ANSI__
  5558: int _putenv (const char *);
  5559: # endif
  5560: #elif defined __CYGWIN__
  5561: # ifdef __STRICT_ANSI__
  5562: char *realpath (const char *, char *);
  5563: int putenv (char *);
  5564: int setenv (const char *, const char *, int);
  5565: # endif
  5566: /* #elif defined other_platform || defined ... */
  5567: #endif
  5568: 
  5569: /* portability defines, excluding path handling macros */
  5570: #if defined _MSC_VER
  5571: # define setmode _setmode
  5572: # define stat    _stat
  5573: # define chmod   _chmod
  5574: # define getcwd  _getcwd
  5575: # define putenv  _putenv
  5576: # define S_IXUSR _S_IEXEC
  5577: #elif defined __MINGW32__
  5578: # define setmode _setmode
  5579: # define stat    _stat
  5580: # define chmod   _chmod
  5581: # define getcwd  _getcwd
  5582: # define putenv  _putenv
  5583: #elif defined __CYGWIN__
  5584: # define HAVE_SETENV
  5585: # define FOPEN_WB "wb"
  5586: /* #elif defined other platforms ... */
  5587: #endif
  5588: 
  5589: #if defined PATH_MAX
  5590: # define LT_PATHMAX PATH_MAX
  5591: #elif defined MAXPATHLEN
  5592: # define LT_PATHMAX MAXPATHLEN
  5593: #else
  5594: # define LT_PATHMAX 1024
  5595: #endif
  5596: 
  5597: #ifndef S_IXOTH
  5598: # define S_IXOTH 0
  5599: #endif
  5600: #ifndef S_IXGRP
  5601: # define S_IXGRP 0
  5602: #endif
  5603: 
  5604: /* path handling portability macros */
  5605: #ifndef DIR_SEPARATOR
  5606: # define DIR_SEPARATOR '/'
  5607: # define PATH_SEPARATOR ':'
  5608: #endif
  5609: 
  5610: #if defined _WIN32 || defined __MSDOS__ || defined __DJGPP__ || \
  5611:   defined __OS2__
  5612: # define HAVE_DOS_BASED_FILE_SYSTEM
  5613: # define FOPEN_WB "wb"
  5614: # ifndef DIR_SEPARATOR_2
  5615: #  define DIR_SEPARATOR_2 '\\'
  5616: # endif
  5617: # ifndef PATH_SEPARATOR_2
  5618: #  define PATH_SEPARATOR_2 ';'
  5619: # endif
  5620: #endif
  5621: 
  5622: #ifndef DIR_SEPARATOR_2
  5623: # define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
  5624: #else /* DIR_SEPARATOR_2 */
  5625: # define IS_DIR_SEPARATOR(ch) \
  5626: 	(((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
  5627: #endif /* DIR_SEPARATOR_2 */
  5628: 
  5629: #ifndef PATH_SEPARATOR_2
  5630: # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
  5631: #else /* PATH_SEPARATOR_2 */
  5632: # define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
  5633: #endif /* PATH_SEPARATOR_2 */
  5634: 
  5635: #ifndef FOPEN_WB
  5636: # define FOPEN_WB "w"
  5637: #endif
  5638: #ifndef _O_BINARY
  5639: # define _O_BINARY 0
  5640: #endif
  5641: 
  5642: #define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
  5643: #define XFREE(stale) do { \
  5644:   if (stale) { free (stale); stale = 0; } \
  5645: } while (0)
  5646: 
  5647: #if defined LT_DEBUGWRAPPER
  5648: static int lt_debug = 1;
  5649: #else
  5650: static int lt_debug = 0;
  5651: #endif
  5652: 
  5653: const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
  5654: 
  5655: void *xmalloc (size_t num);
  5656: char *xstrdup (const char *string);
  5657: const char *base_name (const char *name);
  5658: char *find_executable (const char *wrapper);
  5659: char *chase_symlinks (const char *pathspec);
  5660: int make_executable (const char *path);
  5661: int check_executable (const char *path);
  5662: char *strendzap (char *str, const char *pat);
  5663: void lt_debugprintf (const char *file, int line, const char *fmt, ...);
  5664: void lt_fatal (const char *file, int line, const char *message, ...);
  5665: static const char *nonnull (const char *s);
  5666: static const char *nonempty (const char *s);
  5667: void lt_setenv (const char *name, const char *value);
  5668: char *lt_extend_str (const char *orig_value, const char *add, int to_end);
  5669: void lt_update_exe_path (const char *name, const char *value);
  5670: void lt_update_lib_path (const char *name, const char *value);
  5671: char **prepare_spawn (char **argv);
  5672: void lt_dump_script (FILE *f);
  5673: EOF
  5674: 
  5675: 	    cat <<EOF
  5676: #if __GNUC__ < 4 || (__GNUC__ == 4 && __GNUC_MINOR__ < 5)
  5677: # define externally_visible volatile
  5678: #else
  5679: # define externally_visible __attribute__((externally_visible)) volatile
  5680: #endif
  5681: externally_visible const char * MAGIC_EXE = "$magic_exe";
  5682: const char * LIB_PATH_VARNAME = "$shlibpath_var";
  5683: EOF
  5684: 
  5685: 	    if test yes = "$shlibpath_overrides_runpath" && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
  5686:               func_to_host_path "$temp_rpath"
  5687: 	      cat <<EOF
  5688: const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
  5689: EOF
  5690: 	    else
  5691: 	      cat <<"EOF"
  5692: const char * LIB_PATH_VALUE   = "";
  5693: EOF
  5694: 	    fi
  5695: 
  5696: 	    if test -n "$dllsearchpath"; then
  5697:               func_to_host_path "$dllsearchpath:"
  5698: 	      cat <<EOF
  5699: const char * EXE_PATH_VARNAME = "PATH";
  5700: const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
  5701: EOF
  5702: 	    else
  5703: 	      cat <<"EOF"
  5704: const char * EXE_PATH_VARNAME = "";
  5705: const char * EXE_PATH_VALUE   = "";
  5706: EOF
  5707: 	    fi
  5708: 
  5709: 	    if test yes = "$fast_install"; then
  5710: 	      cat <<EOF
  5711: const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
  5712: EOF
  5713: 	    else
  5714: 	      cat <<EOF
  5715: const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
  5716: EOF
  5717: 	    fi
  5718: 
  5719: 
  5720: 	    cat <<"EOF"
  5721: 
  5722: #define LTWRAPPER_OPTION_PREFIX         "--lt-"
  5723: 
  5724: static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
  5725: static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
  5726: static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
  5727: 
  5728: int
  5729: main (int argc, char *argv[])
  5730: {
  5731:   char **newargz;
  5732:   int  newargc;
  5733:   char *tmp_pathspec;
  5734:   char *actual_cwrapper_path;
  5735:   char *actual_cwrapper_name;
  5736:   char *target_name;
  5737:   char *lt_argv_zero;
  5738:   int rval = 127;
  5739: 
  5740:   int i;
  5741: 
  5742:   program_name = (char *) xstrdup (base_name (argv[0]));
  5743:   newargz = XMALLOC (char *, (size_t) argc + 1);
  5744: 
  5745:   /* very simple arg parsing; don't want to rely on getopt
  5746:    * also, copy all non cwrapper options to newargz, except
  5747:    * argz[0], which is handled differently
  5748:    */
  5749:   newargc=0;
  5750:   for (i = 1; i < argc; i++)
  5751:     {
  5752:       if (STREQ (argv[i], dumpscript_opt))
  5753: 	{
  5754: EOF
  5755: 	    case $host in
  5756: 	      *mingw* | *cygwin* )
  5757: 		# make stdout use "unix" line endings
  5758: 		echo "          setmode(1,_O_BINARY);"
  5759: 		;;
  5760: 	      esac
  5761: 
  5762: 	    cat <<"EOF"
  5763: 	  lt_dump_script (stdout);
  5764: 	  return 0;
  5765: 	}
  5766:       if (STREQ (argv[i], debug_opt))
  5767: 	{
  5768:           lt_debug = 1;
  5769:           continue;
  5770: 	}
  5771:       if (STREQ (argv[i], ltwrapper_option_prefix))
  5772:         {
  5773:           /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
  5774:              namespace, but it is not one of the ones we know about and
  5775:              have already dealt with, above (inluding dump-script), then
  5776:              report an error. Otherwise, targets might begin to believe
  5777:              they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
  5778:              namespace. The first time any user complains about this, we'll
  5779:              need to make LTWRAPPER_OPTION_PREFIX a configure-time option
  5780:              or a configure.ac-settable value.
  5781:            */
  5782:           lt_fatal (__FILE__, __LINE__,
  5783: 		    "unrecognized %s option: '%s'",
  5784:                     ltwrapper_option_prefix, argv[i]);
  5785:         }
  5786:       /* otherwise ... */
  5787:       newargz[++newargc] = xstrdup (argv[i]);
  5788:     }
  5789:   newargz[++newargc] = NULL;
  5790: 
  5791: EOF
  5792: 	    cat <<EOF
  5793:   /* The GNU banner must be the first non-error debug message */
  5794:   lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE) $VERSION\n");
  5795: EOF
  5796: 	    cat <<"EOF"
  5797:   lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
  5798:   lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
  5799: 
  5800:   tmp_pathspec = find_executable (argv[0]);
  5801:   if (tmp_pathspec == NULL)
  5802:     lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
  5803:   lt_debugprintf (__FILE__, __LINE__,
  5804:                   "(main) found exe (before symlink chase) at: %s\n",
  5805: 		  tmp_pathspec);
  5806: 
  5807:   actual_cwrapper_path = chase_symlinks (tmp_pathspec);
  5808:   lt_debugprintf (__FILE__, __LINE__,
  5809:                   "(main) found exe (after symlink chase) at: %s\n",
  5810: 		  actual_cwrapper_path);
  5811:   XFREE (tmp_pathspec);
  5812: 
  5813:   actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
  5814:   strendzap (actual_cwrapper_path, actual_cwrapper_name);
  5815: 
  5816:   /* wrapper name transforms */
  5817:   strendzap (actual_cwrapper_name, ".exe");
  5818:   tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
  5819:   XFREE (actual_cwrapper_name);
  5820:   actual_cwrapper_name = tmp_pathspec;
  5821:   tmp_pathspec = 0;
  5822: 
  5823:   /* target_name transforms -- use actual target program name; might have lt- prefix */
  5824:   target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
  5825:   strendzap (target_name, ".exe");
  5826:   tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
  5827:   XFREE (target_name);
  5828:   target_name = tmp_pathspec;
  5829:   tmp_pathspec = 0;
  5830: 
  5831:   lt_debugprintf (__FILE__, __LINE__,
  5832: 		  "(main) libtool target name: %s\n",
  5833: 		  target_name);
  5834: EOF
  5835: 
  5836: 	    cat <<EOF
  5837:   newargz[0] =
  5838:     XMALLOC (char, (strlen (actual_cwrapper_path) +
  5839: 		    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
  5840:   strcpy (newargz[0], actual_cwrapper_path);
  5841:   strcat (newargz[0], "$objdir");
  5842:   strcat (newargz[0], "/");
  5843: EOF
  5844: 
  5845: 	    cat <<"EOF"
  5846:   /* stop here, and copy so we don't have to do this twice */
  5847:   tmp_pathspec = xstrdup (newargz[0]);
  5848: 
  5849:   /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
  5850:   strcat (newargz[0], actual_cwrapper_name);
  5851: 
  5852:   /* DO want the lt- prefix here if it exists, so use target_name */
  5853:   lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
  5854:   XFREE (tmp_pathspec);
  5855:   tmp_pathspec = NULL;
  5856: EOF
  5857: 
  5858: 	    case $host_os in
  5859: 	      mingw*)
  5860: 	    cat <<"EOF"
  5861:   {
  5862:     char* p;
  5863:     while ((p = strchr (newargz[0], '\\')) != NULL)
  5864:       {
  5865: 	*p = '/';
  5866:       }
  5867:     while ((p = strchr (lt_argv_zero, '\\')) != NULL)
  5868:       {
  5869: 	*p = '/';
  5870:       }
  5871:   }
  5872: EOF
  5873: 	    ;;
  5874: 	    esac
  5875: 
  5876: 	    cat <<"EOF"
  5877:   XFREE (target_name);
  5878:   XFREE (actual_cwrapper_path);
  5879:   XFREE (actual_cwrapper_name);
  5880: 
  5881:   lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
  5882:   lt_setenv ("DUALCASE", "1");  /* for MSK sh */
  5883:   /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
  5884:      be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
  5885:      because on Windows, both *_VARNAMEs are PATH but uninstalled
  5886:      libraries must come first. */
  5887:   lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
  5888:   lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
  5889: 
  5890:   lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
  5891: 		  nonnull (lt_argv_zero));
  5892:   for (i = 0; i < newargc; i++)
  5893:     {
  5894:       lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
  5895: 		      i, nonnull (newargz[i]));
  5896:     }
  5897: 
  5898: EOF
  5899: 
  5900: 	    case $host_os in
  5901: 	      mingw*)
  5902: 		cat <<"EOF"
  5903:   /* execv doesn't actually work on mingw as expected on unix */
  5904:   newargz = prepare_spawn (newargz);
  5905:   rval = (int) _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
  5906:   if (rval == -1)
  5907:     {
  5908:       /* failed to start process */
  5909:       lt_debugprintf (__FILE__, __LINE__,
  5910: 		      "(main) failed to launch target \"%s\": %s\n",
  5911: 		      lt_argv_zero, nonnull (strerror (errno)));
  5912:       return 127;
  5913:     }
  5914:   return rval;
  5915: EOF
  5916: 		;;
  5917: 	      *)
  5918: 		cat <<"EOF"
  5919:   execv (lt_argv_zero, newargz);
  5920:   return rval; /* =127, but avoids unused variable warning */
  5921: EOF
  5922: 		;;
  5923: 	    esac
  5924: 
  5925: 	    cat <<"EOF"
  5926: }
  5927: 
  5928: void *
  5929: xmalloc (size_t num)
  5930: {
  5931:   void *p = (void *) malloc (num);
  5932:   if (!p)
  5933:     lt_fatal (__FILE__, __LINE__, "memory exhausted");
  5934: 
  5935:   return p;
  5936: }
  5937: 
  5938: char *
  5939: xstrdup (const char *string)
  5940: {
  5941:   return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
  5942: 			  string) : NULL;
  5943: }
  5944: 
  5945: const char *
  5946: base_name (const char *name)
  5947: {
  5948:   const char *base;
  5949: 
  5950: #if defined HAVE_DOS_BASED_FILE_SYSTEM
  5951:   /* Skip over the disk name in MSDOS pathnames. */
  5952:   if (isalpha ((unsigned char) name[0]) && name[1] == ':')
  5953:     name += 2;
  5954: #endif
  5955: 
  5956:   for (base = name; *name; name++)
  5957:     if (IS_DIR_SEPARATOR (*name))
  5958:       base = name + 1;
  5959:   return base;
  5960: }
  5961: 
  5962: int
  5963: check_executable (const char *path)
  5964: {
  5965:   struct stat st;
  5966: 
  5967:   lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
  5968:                   nonempty (path));
  5969:   if ((!path) || (!*path))
  5970:     return 0;
  5971: 
  5972:   if ((stat (path, &st) >= 0)
  5973:       && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
  5974:     return 1;
  5975:   else
  5976:     return 0;
  5977: }
  5978: 
  5979: int
  5980: make_executable (const char *path)
  5981: {
  5982:   int rval = 0;
  5983:   struct stat st;
  5984: 
  5985:   lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
  5986:                   nonempty (path));
  5987:   if ((!path) || (!*path))
  5988:     return 0;
  5989: 
  5990:   if (stat (path, &st) >= 0)
  5991:     {
  5992:       rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
  5993:     }
  5994:   return rval;
  5995: }
  5996: 
  5997: /* Searches for the full path of the wrapper.  Returns
  5998:    newly allocated full path name if found, NULL otherwise
  5999:    Does not chase symlinks, even on platforms that support them.
  6000: */
  6001: char *
  6002: find_executable (const char *wrapper)
  6003: {
  6004:   int has_slash = 0;
  6005:   const char *p;
  6006:   const char *p_next;
  6007:   /* static buffer for getcwd */
  6008:   char tmp[LT_PATHMAX + 1];
  6009:   size_t tmp_len;
  6010:   char *concat_name;
  6011: 
  6012:   lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
  6013:                   nonempty (wrapper));
  6014: 
  6015:   if ((wrapper == NULL) || (*wrapper == '\0'))
  6016:     return NULL;
  6017: 
  6018:   /* Absolute path? */
  6019: #if defined HAVE_DOS_BASED_FILE_SYSTEM
  6020:   if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
  6021:     {
  6022:       concat_name = xstrdup (wrapper);
  6023:       if (check_executable (concat_name))
  6024: 	return concat_name;
  6025:       XFREE (concat_name);
  6026:     }
  6027:   else
  6028:     {
  6029: #endif
  6030:       if (IS_DIR_SEPARATOR (wrapper[0]))
  6031: 	{
  6032: 	  concat_name = xstrdup (wrapper);
  6033: 	  if (check_executable (concat_name))
  6034: 	    return concat_name;
  6035: 	  XFREE (concat_name);
  6036: 	}
  6037: #if defined HAVE_DOS_BASED_FILE_SYSTEM
  6038:     }
  6039: #endif
  6040: 
  6041:   for (p = wrapper; *p; p++)
  6042:     if (*p == '/')
  6043:       {
  6044: 	has_slash = 1;
  6045: 	break;
  6046:       }
  6047:   if (!has_slash)
  6048:     {
  6049:       /* no slashes; search PATH */
  6050:       const char *path = getenv ("PATH");
  6051:       if (path != NULL)
  6052: 	{
  6053: 	  for (p = path; *p; p = p_next)
  6054: 	    {
  6055: 	      const char *q;
  6056: 	      size_t p_len;
  6057: 	      for (q = p; *q; q++)
  6058: 		if (IS_PATH_SEPARATOR (*q))
  6059: 		  break;
  6060: 	      p_len = (size_t) (q - p);
  6061: 	      p_next = (*q == '\0' ? q : q + 1);
  6062: 	      if (p_len == 0)
  6063: 		{
  6064: 		  /* empty path: current directory */
  6065: 		  if (getcwd (tmp, LT_PATHMAX) == NULL)
  6066: 		    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
  6067:                               nonnull (strerror (errno)));
  6068: 		  tmp_len = strlen (tmp);
  6069: 		  concat_name =
  6070: 		    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
  6071: 		  memcpy (concat_name, tmp, tmp_len);
  6072: 		  concat_name[tmp_len] = '/';
  6073: 		  strcpy (concat_name + tmp_len + 1, wrapper);
  6074: 		}
  6075: 	      else
  6076: 		{
  6077: 		  concat_name =
  6078: 		    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
  6079: 		  memcpy (concat_name, p, p_len);
  6080: 		  concat_name[p_len] = '/';
  6081: 		  strcpy (concat_name + p_len + 1, wrapper);
  6082: 		}
  6083: 	      if (check_executable (concat_name))
  6084: 		return concat_name;
  6085: 	      XFREE (concat_name);
  6086: 	    }
  6087: 	}
  6088:       /* not found in PATH; assume curdir */
  6089:     }
  6090:   /* Relative path | not found in path: prepend cwd */
  6091:   if (getcwd (tmp, LT_PATHMAX) == NULL)
  6092:     lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
  6093:               nonnull (strerror (errno)));
  6094:   tmp_len = strlen (tmp);
  6095:   concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
  6096:   memcpy (concat_name, tmp, tmp_len);
  6097:   concat_name[tmp_len] = '/';
  6098:   strcpy (concat_name + tmp_len + 1, wrapper);
  6099: 
  6100:   if (check_executable (concat_name))
  6101:     return concat_name;
  6102:   XFREE (concat_name);
  6103:   return NULL;
  6104: }
  6105: 
  6106: char *
  6107: chase_symlinks (const char *pathspec)
  6108: {
  6109: #ifndef S_ISLNK
  6110:   return xstrdup (pathspec);
  6111: #else
  6112:   char buf[LT_PATHMAX];
  6113:   struct stat s;
  6114:   char *tmp_pathspec = xstrdup (pathspec);
  6115:   char *p;
  6116:   int has_symlinks = 0;
  6117:   while (strlen (tmp_pathspec) && !has_symlinks)
  6118:     {
  6119:       lt_debugprintf (__FILE__, __LINE__,
  6120: 		      "checking path component for symlinks: %s\n",
  6121: 		      tmp_pathspec);
  6122:       if (lstat (tmp_pathspec, &s) == 0)
  6123: 	{
  6124: 	  if (S_ISLNK (s.st_mode) != 0)
  6125: 	    {
  6126: 	      has_symlinks = 1;
  6127: 	      break;
  6128: 	    }
  6129: 
  6130: 	  /* search backwards for last DIR_SEPARATOR */
  6131: 	  p = tmp_pathspec + strlen (tmp_pathspec) - 1;
  6132: 	  while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
  6133: 	    p--;
  6134: 	  if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
  6135: 	    {
  6136: 	      /* no more DIR_SEPARATORS left */
  6137: 	      break;
  6138: 	    }
  6139: 	  *p = '\0';
  6140: 	}
  6141:       else
  6142: 	{
  6143: 	  lt_fatal (__FILE__, __LINE__,
  6144: 		    "error accessing file \"%s\": %s",
  6145: 		    tmp_pathspec, nonnull (strerror (errno)));
  6146: 	}
  6147:     }
  6148:   XFREE (tmp_pathspec);
  6149: 
  6150:   if (!has_symlinks)
  6151:     {
  6152:       return xstrdup (pathspec);
  6153:     }
  6154: 
  6155:   tmp_pathspec = realpath (pathspec, buf);
  6156:   if (tmp_pathspec == 0)
  6157:     {
  6158:       lt_fatal (__FILE__, __LINE__,
  6159: 		"could not follow symlinks for %s", pathspec);
  6160:     }
  6161:   return xstrdup (tmp_pathspec);
  6162: #endif
  6163: }
  6164: 
  6165: char *
  6166: strendzap (char *str, const char *pat)
  6167: {
  6168:   size_t len, patlen;
  6169: 
  6170:   assert (str != NULL);
  6171:   assert (pat != NULL);
  6172: 
  6173:   len = strlen (str);
  6174:   patlen = strlen (pat);
  6175: 
  6176:   if (patlen <= len)
  6177:     {
  6178:       str += len - patlen;
  6179:       if (STREQ (str, pat))
  6180: 	*str = '\0';
  6181:     }
  6182:   return str;
  6183: }
  6184: 
  6185: void
  6186: lt_debugprintf (const char *file, int line, const char *fmt, ...)
  6187: {
  6188:   va_list args;
  6189:   if (lt_debug)
  6190:     {
  6191:       (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
  6192:       va_start (args, fmt);
  6193:       (void) vfprintf (stderr, fmt, args);
  6194:       va_end (args);
  6195:     }
  6196: }
  6197: 
  6198: static void
  6199: lt_error_core (int exit_status, const char *file,
  6200: 	       int line, const char *mode,
  6201: 	       const char *message, va_list ap)
  6202: {
  6203:   fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
  6204:   vfprintf (stderr, message, ap);
  6205:   fprintf (stderr, ".\n");
  6206: 
  6207:   if (exit_status >= 0)
  6208:     exit (exit_status);
  6209: }
  6210: 
  6211: void
  6212: lt_fatal (const char *file, int line, const char *message, ...)
  6213: {
  6214:   va_list ap;
  6215:   va_start (ap, message);
  6216:   lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
  6217:   va_end (ap);
  6218: }
  6219: 
  6220: static const char *
  6221: nonnull (const char *s)
  6222: {
  6223:   return s ? s : "(null)";
  6224: }
  6225: 
  6226: static const char *
  6227: nonempty (const char *s)
  6228: {
  6229:   return (s && !*s) ? "(empty)" : nonnull (s);
  6230: }
  6231: 
  6232: void
  6233: lt_setenv (const char *name, const char *value)
  6234: {
  6235:   lt_debugprintf (__FILE__, __LINE__,
  6236: 		  "(lt_setenv) setting '%s' to '%s'\n",
  6237:                   nonnull (name), nonnull (value));
  6238:   {
  6239: #ifdef HAVE_SETENV
  6240:     /* always make a copy, for consistency with !HAVE_SETENV */
  6241:     char *str = xstrdup (value);
  6242:     setenv (name, str, 1);
  6243: #else
  6244:     size_t len = strlen (name) + 1 + strlen (value) + 1;
  6245:     char *str = XMALLOC (char, len);
  6246:     sprintf (str, "%s=%s", name, value);
  6247:     if (putenv (str) != EXIT_SUCCESS)
  6248:       {
  6249:         XFREE (str);
  6250:       }
  6251: #endif
  6252:   }
  6253: }
  6254: 
  6255: char *
  6256: lt_extend_str (const char *orig_value, const char *add, int to_end)
  6257: {
  6258:   char *new_value;
  6259:   if (orig_value && *orig_value)
  6260:     {
  6261:       size_t orig_value_len = strlen (orig_value);
  6262:       size_t add_len = strlen (add);
  6263:       new_value = XMALLOC (char, add_len + orig_value_len + 1);
  6264:       if (to_end)
  6265:         {
  6266:           strcpy (new_value, orig_value);
  6267:           strcpy (new_value + orig_value_len, add);
  6268:         }
  6269:       else
  6270:         {
  6271:           strcpy (new_value, add);
  6272:           strcpy (new_value + add_len, orig_value);
  6273:         }
  6274:     }
  6275:   else
  6276:     {
  6277:       new_value = xstrdup (add);
  6278:     }
  6279:   return new_value;
  6280: }
  6281: 
  6282: void
  6283: lt_update_exe_path (const char *name, const char *value)
  6284: {
  6285:   lt_debugprintf (__FILE__, __LINE__,
  6286: 		  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
  6287:                   nonnull (name), nonnull (value));
  6288: 
  6289:   if (name && *name && value && *value)
  6290:     {
  6291:       char *new_value = lt_extend_str (getenv (name), value, 0);
  6292:       /* some systems can't cope with a ':'-terminated path #' */
  6293:       size_t len = strlen (new_value);
  6294:       while ((len > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
  6295:         {
  6296:           new_value[--len] = '\0';
  6297:         }
  6298:       lt_setenv (name, new_value);
  6299:       XFREE (new_value);
  6300:     }
  6301: }
  6302: 
  6303: void
  6304: lt_update_lib_path (const char *name, const char *value)
  6305: {
  6306:   lt_debugprintf (__FILE__, __LINE__,
  6307: 		  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
  6308:                   nonnull (name), nonnull (value));
  6309: 
  6310:   if (name && *name && value && *value)
  6311:     {
  6312:       char *new_value = lt_extend_str (getenv (name), value, 0);
  6313:       lt_setenv (name, new_value);
  6314:       XFREE (new_value);
  6315:     }
  6316: }
  6317: 
  6318: EOF
  6319: 	    case $host_os in
  6320: 	      mingw*)
  6321: 		cat <<"EOF"
  6322: 
  6323: /* Prepares an argument vector before calling spawn().
  6324:    Note that spawn() does not by itself call the command interpreter
  6325:      (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
  6326:       ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
  6327:          GetVersionEx(&v);
  6328:          v.dwPlatformId == VER_PLATFORM_WIN32_NT;
  6329:       }) ? "cmd.exe" : "command.com").
  6330:    Instead it simply concatenates the arguments, separated by ' ', and calls
  6331:    CreateProcess().  We must quote the arguments since Win32 CreateProcess()
  6332:    interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
  6333:    special way:
  6334:    - Space and tab are interpreted as delimiters. They are not treated as
  6335:      delimiters if they are surrounded by double quotes: "...".
  6336:    - Unescaped double quotes are removed from the input. Their only effect is
  6337:      that within double quotes, space and tab are treated like normal
  6338:      characters.
  6339:    - Backslashes not followed by double quotes are not special.
  6340:    - But 2*n+1 backslashes followed by a double quote become
  6341:      n backslashes followed by a double quote (n >= 0):
  6342:        \" -> "
  6343:        \\\" -> \"
  6344:        \\\\\" -> \\"
  6345:  */
  6346: #define SHELL_SPECIAL_CHARS "\"\\ \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
  6347: #define SHELL_SPACE_CHARS " \001\002\003\004\005\006\007\010\011\012\013\014\015\016\017\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
  6348: char **
  6349: prepare_spawn (char **argv)
  6350: {
  6351:   size_t argc;
  6352:   char **new_argv;
  6353:   size_t i;
  6354: 
  6355:   /* Count number of arguments.  */
  6356:   for (argc = 0; argv[argc] != NULL; argc++)
  6357:     ;
  6358: 
  6359:   /* Allocate new argument vector.  */
  6360:   new_argv = XMALLOC (char *, argc + 1);
  6361: 
  6362:   /* Put quoted arguments into the new argument vector.  */
  6363:   for (i = 0; i < argc; i++)
  6364:     {
  6365:       const char *string = argv[i];
  6366: 
  6367:       if (string[0] == '\0')
  6368: 	new_argv[i] = xstrdup ("\"\"");
  6369:       else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
  6370: 	{
  6371: 	  int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
  6372: 	  size_t length;
  6373: 	  unsigned int backslashes;
  6374: 	  const char *s;
  6375: 	  char *quoted_string;
  6376: 	  char *p;
  6377: 
  6378: 	  length = 0;
  6379: 	  backslashes = 0;
  6380: 	  if (quote_around)
  6381: 	    length++;
  6382: 	  for (s = string; *s != '\0'; s++)
  6383: 	    {
  6384: 	      char c = *s;
  6385: 	      if (c == '"')
  6386: 		length += backslashes + 1;
  6387: 	      length++;
  6388: 	      if (c == '\\')
  6389: 		backslashes++;
  6390: 	      else
  6391: 		backslashes = 0;
  6392: 	    }
  6393: 	  if (quote_around)
  6394: 	    length += backslashes + 1;
  6395: 
  6396: 	  quoted_string = XMALLOC (char, length + 1);
  6397: 
  6398: 	  p = quoted_string;
  6399: 	  backslashes = 0;
  6400: 	  if (quote_around)
  6401: 	    *p++ = '"';
  6402: 	  for (s = string; *s != '\0'; s++)
  6403: 	    {
  6404: 	      char c = *s;
  6405: 	      if (c == '"')
  6406: 		{
  6407: 		  unsigned int j;
  6408: 		  for (j = backslashes + 1; j > 0; j--)
  6409: 		    *p++ = '\\';
  6410: 		}
  6411: 	      *p++ = c;
  6412: 	      if (c == '\\')
  6413: 		backslashes++;
  6414: 	      else
  6415: 		backslashes = 0;
  6416: 	    }
  6417: 	  if (quote_around)
  6418: 	    {
  6419: 	      unsigned int j;
  6420: 	      for (j = backslashes; j > 0; j--)
  6421: 		*p++ = '\\';
  6422: 	      *p++ = '"';
  6423: 	    }
  6424: 	  *p = '\0';
  6425: 
  6426: 	  new_argv[i] = quoted_string;
  6427: 	}
  6428:       else
  6429: 	new_argv[i] = (char *) string;
  6430:     }
  6431:   new_argv[argc] = NULL;
  6432: 
  6433:   return new_argv;
  6434: }
  6435: EOF
  6436: 		;;
  6437: 	    esac
  6438: 
  6439:             cat <<"EOF"
  6440: void lt_dump_script (FILE* f)
  6441: {
  6442: EOF
  6443: 	    func_emit_wrapper yes |
  6444: 	      $SED -n -e '
  6445: s/^\(.\{79\}\)\(..*\)/\1\
  6446: \2/
  6447: h
  6448: s/\([\\"]\)/\\\1/g
  6449: s/$/\\n/
  6450: s/\([^\n]*\).*/  fputs ("\1", f);/p
  6451: g
  6452: D'
  6453:             cat <<"EOF"
  6454: }
  6455: EOF
  6456: }
  6457: # end: func_emit_cwrapperexe_src
  6458: 
  6459: # func_win32_import_lib_p ARG
  6460: # True if ARG is an import lib, as indicated by $file_magic_cmd
  6461: func_win32_import_lib_p ()
  6462: {
  6463:     $debug_cmd
  6464: 
  6465:     case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
  6466:     *import*) : ;;
  6467:     *) false ;;
  6468:     esac
  6469: }
  6470: 
  6471: # func_suncc_cstd_abi
  6472: # !!ONLY CALL THIS FOR SUN CC AFTER $compile_command IS FULLY EXPANDED!!
  6473: # Several compiler flags select an ABI that is incompatible with the
  6474: # Cstd library. Avoid specifying it if any are in CXXFLAGS.
  6475: func_suncc_cstd_abi ()
  6476: {
  6477:     $debug_cmd
  6478: 
  6479:     case " $compile_command " in
  6480:     *" -compat=g "*|*\ -std=c++[0-9][0-9]\ *|*" -library=stdcxx4 "*|*" -library=stlport4 "*)
  6481:       suncc_use_cstd_abi=no
  6482:       ;;
  6483:     *)
  6484:       suncc_use_cstd_abi=yes
  6485:       ;;
  6486:     esac
  6487: }
  6488: 
  6489: # func_mode_link arg...
  6490: func_mode_link ()
  6491: {
  6492:     $debug_cmd
  6493: 
  6494:     case $host in
  6495:     *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
  6496:       # It is impossible to link a dll without this setting, and
  6497:       # we shouldn't force the makefile maintainer to figure out
  6498:       # what system we are compiling for in order to pass an extra
  6499:       # flag for every libtool invocation.
  6500:       # allow_undefined=no
  6501: 
  6502:       # FIXME: Unfortunately, there are problems with the above when trying
  6503:       # to make a dll that has undefined symbols, in which case not
  6504:       # even a static library is built.  For now, we need to specify
  6505:       # -no-undefined on the libtool link line when we can be certain
  6506:       # that all symbols are satisfied, otherwise we get a static library.
  6507:       allow_undefined=yes
  6508:       ;;
  6509:     *)
  6510:       allow_undefined=yes
  6511:       ;;
  6512:     esac
  6513:     libtool_args=$nonopt
  6514:     base_compile="$nonopt $@"
  6515:     compile_command=$nonopt
  6516:     finalize_command=$nonopt
  6517: 
  6518:     compile_rpath=
  6519:     finalize_rpath=
  6520:     compile_shlibpath=
  6521:     finalize_shlibpath=
  6522:     convenience=
  6523:     old_convenience=
  6524:     deplibs=
  6525:     old_deplibs=
  6526:     compiler_flags=
  6527:     linker_flags=
  6528:     dllsearchpath=
  6529:     lib_search_path=`pwd`
  6530:     inst_prefix_dir=
  6531:     new_inherited_linker_flags=
  6532: 
  6533:     avoid_version=no
  6534:     bindir=
  6535:     dlfiles=
  6536:     dlprefiles=
  6537:     dlself=no
  6538:     export_dynamic=no
  6539:     export_symbols=
  6540:     export_symbols_regex=
  6541:     generated=
  6542:     libobjs=
  6543:     ltlibs=
  6544:     module=no
  6545:     no_install=no
  6546:     objs=
  6547:     os2dllname=
  6548:     non_pic_objects=
  6549:     precious_files_regex=
  6550:     prefer_static_libs=no
  6551:     preload=false
  6552:     prev=
  6553:     prevarg=
  6554:     release=
  6555:     rpath=
  6556:     xrpath=
  6557:     perm_rpath=
  6558:     temp_rpath=
  6559:     thread_safe=no
  6560:     vinfo=
  6561:     vinfo_number=no
  6562:     weak_libs=
  6563:     single_module=$wl-single_module
  6564:     func_infer_tag $base_compile
  6565: 
  6566:     # We need to know -static, to get the right output filenames.
  6567:     for arg
  6568:     do
  6569:       case $arg in
  6570:       -shared)
  6571: 	test yes != "$build_libtool_libs" \
  6572: 	  && func_fatal_configuration "cannot build a shared library"
  6573: 	build_old_libs=no
  6574: 	break
  6575: 	;;
  6576:       -all-static | -static | -static-libtool-libs)
  6577: 	case $arg in
  6578: 	-all-static)
  6579: 	  if test yes = "$build_libtool_libs" && test -z "$link_static_flag"; then
  6580: 	    func_warning "complete static linking is impossible in this configuration"
  6581: 	  fi
  6582: 	  if test -n "$link_static_flag"; then
  6583: 	    dlopen_self=$dlopen_self_static
  6584: 	  fi
  6585: 	  prefer_static_libs=yes
  6586: 	  ;;
  6587: 	-static)
  6588: 	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
  6589: 	    dlopen_self=$dlopen_self_static
  6590: 	  fi
  6591: 	  prefer_static_libs=built
  6592: 	  ;;
  6593: 	-static-libtool-libs)
  6594: 	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
  6595: 	    dlopen_self=$dlopen_self_static
  6596: 	  fi
  6597: 	  prefer_static_libs=yes
  6598: 	  ;;
  6599: 	esac
  6600: 	build_libtool_libs=no
  6601: 	build_old_libs=yes
  6602: 	break
  6603: 	;;
  6604:       esac
  6605:     done
  6606: 
  6607:     # See if our shared archives depend on static archives.
  6608:     test -n "$old_archive_from_new_cmds" && build_old_libs=yes
  6609: 
  6610:     # Go through the arguments, transforming them on the way.
  6611:     while test "$#" -gt 0; do
  6612:       arg=$1
  6613:       shift
  6614:       func_quote_for_eval "$arg"
  6615:       qarg=$func_quote_for_eval_unquoted_result
  6616:       func_append libtool_args " $func_quote_for_eval_result"
  6617: 
  6618:       # If the previous option needs an argument, assign it.
  6619:       if test -n "$prev"; then
  6620: 	case $prev in
  6621: 	output)
  6622: 	  func_append compile_command " @OUTPUT@"
  6623: 	  func_append finalize_command " @OUTPUT@"
  6624: 	  ;;
  6625: 	esac
  6626: 
  6627: 	case $prev in
  6628: 	bindir)
  6629: 	  bindir=$arg
  6630: 	  prev=
  6631: 	  continue
  6632: 	  ;;
  6633: 	dlfiles|dlprefiles)
  6634: 	  $preload || {
  6635: 	    # Add the symbol object into the linking commands.
  6636: 	    func_append compile_command " @SYMFILE@"
  6637: 	    func_append finalize_command " @SYMFILE@"
  6638: 	    preload=:
  6639: 	  }
  6640: 	  case $arg in
  6641: 	  *.la | *.lo) ;;  # We handle these cases below.
  6642: 	  force)
  6643: 	    if test no = "$dlself"; then
  6644: 	      dlself=needless
  6645: 	      export_dynamic=yes
  6646: 	    fi
  6647: 	    prev=
  6648: 	    continue
  6649: 	    ;;
  6650: 	  self)
  6651: 	    if test dlprefiles = "$prev"; then
  6652: 	      dlself=yes
  6653: 	    elif test dlfiles = "$prev" && test yes != "$dlopen_self"; then
  6654: 	      dlself=yes
  6655: 	    else
  6656: 	      dlself=needless
  6657: 	      export_dynamic=yes
  6658: 	    fi
  6659: 	    prev=
  6660: 	    continue
  6661: 	    ;;
  6662: 	  *)
  6663: 	    if test dlfiles = "$prev"; then
  6664: 	      func_append dlfiles " $arg"
  6665: 	    else
  6666: 	      func_append dlprefiles " $arg"
  6667: 	    fi
  6668: 	    prev=
  6669: 	    continue
  6670: 	    ;;
  6671: 	  esac
  6672: 	  ;;
  6673: 	expsyms)
  6674: 	  export_symbols=$arg
  6675: 	  test -f "$arg" \
  6676: 	    || func_fatal_error "symbol file '$arg' does not exist"
  6677: 	  prev=
  6678: 	  continue
  6679: 	  ;;
  6680: 	expsyms_regex)
  6681: 	  export_symbols_regex=$arg
  6682: 	  prev=
  6683: 	  continue
  6684: 	  ;;
  6685: 	framework)
  6686: 	  case $host in
  6687: 	    *-*-darwin*)
  6688: 	      case "$deplibs " in
  6689: 		*" $qarg.ltframework "*) ;;
  6690: 		*) func_append deplibs " $qarg.ltframework" # this is fixed later
  6691: 		   ;;
  6692: 	      esac
  6693: 	      ;;
  6694: 	  esac
  6695: 	  prev=
  6696: 	  continue
  6697: 	  ;;
  6698: 	inst_prefix)
  6699: 	  inst_prefix_dir=$arg
  6700: 	  prev=
  6701: 	  continue
  6702: 	  ;;
  6703: 	mllvm)
  6704: 	  # Clang does not use LLVM to link, so we can simply discard any
  6705: 	  # '-mllvm $arg' options when doing the link step.
  6706: 	  prev=
  6707: 	  continue
  6708: 	  ;;
  6709: 	objectlist)
  6710: 	  if test -f "$arg"; then
  6711: 	    save_arg=$arg
  6712: 	    moreargs=
  6713: 	    for fil in `cat "$save_arg"`
  6714: 	    do
  6715: #	      func_append moreargs " $fil"
  6716: 	      arg=$fil
  6717: 	      # A libtool-controlled object.
  6718: 
  6719: 	      # Check to see that this really is a libtool object.
  6720: 	      if func_lalib_unsafe_p "$arg"; then
  6721: 		pic_object=
  6722: 		non_pic_object=
  6723: 
  6724: 		# Read the .lo file
  6725: 		func_source "$arg"
  6726: 
  6727: 		if test -z "$pic_object" ||
  6728: 		   test -z "$non_pic_object" ||
  6729: 		   test none = "$pic_object" &&
  6730: 		   test none = "$non_pic_object"; then
  6731: 		  func_fatal_error "cannot find name of object for '$arg'"
  6732: 		fi
  6733: 
  6734: 		# Extract subdirectory from the argument.
  6735: 		func_dirname "$arg" "/" ""
  6736: 		xdir=$func_dirname_result
  6737: 
  6738: 		if test none != "$pic_object"; then
  6739: 		  # Prepend the subdirectory the object is found in.
  6740: 		  pic_object=$xdir$pic_object
  6741: 
  6742: 		  if test dlfiles = "$prev"; then
  6743: 		    if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
  6744: 		      func_append dlfiles " $pic_object"
  6745: 		      prev=
  6746: 		      continue
  6747: 		    else
  6748: 		      # If libtool objects are unsupported, then we need to preload.
  6749: 		      prev=dlprefiles
  6750: 		    fi
  6751: 		  fi
  6752: 
  6753: 		  # CHECK ME:  I think I busted this.  -Ossama
  6754: 		  if test dlprefiles = "$prev"; then
  6755: 		    # Preload the old-style object.
  6756: 		    func_append dlprefiles " $pic_object"
  6757: 		    prev=
  6758: 		  fi
  6759: 
  6760: 		  # A PIC object.
  6761: 		  func_append libobjs " $pic_object"
  6762: 		  arg=$pic_object
  6763: 		fi
  6764: 
  6765: 		# Non-PIC object.
  6766: 		if test none != "$non_pic_object"; then
  6767: 		  # Prepend the subdirectory the object is found in.
  6768: 		  non_pic_object=$xdir$non_pic_object
  6769: 
  6770: 		  # A standard non-PIC object
  6771: 		  func_append non_pic_objects " $non_pic_object"
  6772: 		  if test -z "$pic_object" || test none = "$pic_object"; then
  6773: 		    arg=$non_pic_object
  6774: 		  fi
  6775: 		else
  6776: 		  # If the PIC object exists, use it instead.
  6777: 		  # $xdir was prepended to $pic_object above.
  6778: 		  non_pic_object=$pic_object
  6779: 		  func_append non_pic_objects " $non_pic_object"
  6780: 		fi
  6781: 	      else
  6782: 		# Only an error if not doing a dry-run.
  6783: 		if $opt_dry_run; then
  6784: 		  # Extract subdirectory from the argument.
  6785: 		  func_dirname "$arg" "/" ""
  6786: 		  xdir=$func_dirname_result
  6787: 
  6788: 		  func_lo2o "$arg"
  6789: 		  pic_object=$xdir$objdir/$func_lo2o_result
  6790: 		  non_pic_object=$xdir$func_lo2o_result
  6791: 		  func_append libobjs " $pic_object"
  6792: 		  func_append non_pic_objects " $non_pic_object"
  6793: 	        else
  6794: 		  func_fatal_error "'$arg' is not a valid libtool object"
  6795: 		fi
  6796: 	      fi
  6797: 	    done
  6798: 	  else
  6799: 	    func_fatal_error "link input file '$arg' does not exist"
  6800: 	  fi
  6801: 	  arg=$save_arg
  6802: 	  prev=
  6803: 	  continue
  6804: 	  ;;
  6805: 	os2dllname)
  6806: 	  os2dllname=$arg
  6807: 	  prev=
  6808: 	  continue
  6809: 	  ;;
  6810: 	precious_regex)
  6811: 	  precious_files_regex=$arg
  6812: 	  prev=
  6813: 	  continue
  6814: 	  ;;
  6815: 	release)
  6816: 	  release=-$arg
  6817: 	  prev=
  6818: 	  continue
  6819: 	  ;;
  6820: 	rpath | xrpath)
  6821: 	  # We need an absolute path.
  6822: 	  case $arg in
  6823: 	  [\\/]* | [A-Za-z]:[\\/]*) ;;
  6824: 	  *)
  6825: 	    func_fatal_error "only absolute run-paths are allowed"
  6826: 	    ;;
  6827: 	  esac
  6828: 	  if test rpath = "$prev"; then
  6829: 	    case "$rpath " in
  6830: 	    *" $arg "*) ;;
  6831: 	    *) func_append rpath " $arg" ;;
  6832: 	    esac
  6833: 	  else
  6834: 	    case "$xrpath " in
  6835: 	    *" $arg "*) ;;
  6836: 	    *) func_append xrpath " $arg" ;;
  6837: 	    esac
  6838: 	  fi
  6839: 	  prev=
  6840: 	  continue
  6841: 	  ;;
  6842: 	shrext)
  6843: 	  shrext_cmds=$arg
  6844: 	  prev=
  6845: 	  continue
  6846: 	  ;;
  6847: 	weak)
  6848: 	  func_append weak_libs " $arg"
  6849: 	  prev=
  6850: 	  continue
  6851: 	  ;;
  6852: 	xcclinker)
  6853: 	  func_append linker_flags " $qarg"
  6854: 	  func_append compiler_flags " $qarg"
  6855: 	  prev=
  6856: 	  func_append compile_command " $qarg"
  6857: 	  func_append finalize_command " $qarg"
  6858: 	  continue
  6859: 	  ;;
  6860: 	xcompiler)
  6861: 	  func_append compiler_flags " $qarg"
  6862: 	  prev=
  6863: 	  func_append compile_command " $qarg"
  6864: 	  func_append finalize_command " $qarg"
  6865: 	  continue
  6866: 	  ;;
  6867: 	xlinker)
  6868: 	  func_append linker_flags " $qarg"
  6869: 	  func_append compiler_flags " $wl$qarg"
  6870: 	  prev=
  6871: 	  func_append compile_command " $wl$qarg"
  6872: 	  func_append finalize_command " $wl$qarg"
  6873: 	  continue
  6874: 	  ;;
  6875: 	*)
  6876: 	  eval "$prev=\"\$arg\""
  6877: 	  prev=
  6878: 	  continue
  6879: 	  ;;
  6880: 	esac
  6881:       fi # test -n "$prev"
  6882: 
  6883:       prevarg=$arg
  6884: 
  6885:       case $arg in
  6886:       -all-static)
  6887: 	if test -n "$link_static_flag"; then
  6888: 	  # See comment for -static flag below, for more details.
  6889: 	  func_append compile_command " $link_static_flag"
  6890: 	  func_append finalize_command " $link_static_flag"
  6891: 	fi
  6892: 	continue
  6893: 	;;
  6894: 
  6895:       -allow-undefined)
  6896: 	# FIXME: remove this flag sometime in the future.
  6897: 	func_fatal_error "'-allow-undefined' must not be used because it is the default"
  6898: 	;;
  6899: 
  6900:       -avoid-version)
  6901: 	avoid_version=yes
  6902: 	continue
  6903: 	;;
  6904: 
  6905:       -bindir)
  6906: 	prev=bindir
  6907: 	continue
  6908: 	;;
  6909: 
  6910:       -dlopen)
  6911: 	prev=dlfiles
  6912: 	continue
  6913: 	;;
  6914: 
  6915:       -dlpreopen)
  6916: 	prev=dlprefiles
  6917: 	continue
  6918: 	;;
  6919: 
  6920:       -export-dynamic)
  6921: 	export_dynamic=yes
  6922: 	continue
  6923: 	;;
  6924: 
  6925:       -export-symbols | -export-symbols-regex)
  6926: 	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
  6927: 	  func_fatal_error "more than one -exported-symbols argument is not allowed"
  6928: 	fi
  6929: 	if test X-export-symbols = "X$arg"; then
  6930: 	  prev=expsyms
  6931: 	else
  6932: 	  prev=expsyms_regex
  6933: 	fi
  6934: 	continue
  6935: 	;;
  6936: 
  6937:       -framework)
  6938: 	prev=framework
  6939: 	continue
  6940: 	;;
  6941: 
  6942:       -inst-prefix-dir)
  6943: 	prev=inst_prefix
  6944: 	continue
  6945: 	;;
  6946: 
  6947:       # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
  6948:       # so, if we see these flags be careful not to treat them like -L
  6949:       -L[A-Z][A-Z]*:*)
  6950: 	case $with_gcc/$host in
  6951: 	no/*-*-irix* | /*-*-irix*)
  6952: 	  func_append compile_command " $arg"
  6953: 	  func_append finalize_command " $arg"
  6954: 	  ;;
  6955: 	esac
  6956: 	continue
  6957: 	;;
  6958: 
  6959:       -L*)
  6960: 	func_stripname "-L" '' "$arg"
  6961: 	if test -z "$func_stripname_result"; then
  6962: 	  if test "$#" -gt 0; then
  6963: 	    func_fatal_error "require no space between '-L' and '$1'"
  6964: 	  else
  6965: 	    func_fatal_error "need path for '-L' option"
  6966: 	  fi
  6967: 	fi
  6968: 	func_resolve_sysroot "$func_stripname_result"
  6969: 	dir=$func_resolve_sysroot_result
  6970: 	# We need an absolute path.
  6971: 	case $dir in
  6972: 	[\\/]* | [A-Za-z]:[\\/]*) ;;
  6973: 	*)
  6974: 	  absdir=`cd "$dir" && pwd`
  6975: 	  test -z "$absdir" && \
  6976: 	    func_fatal_error "cannot determine absolute directory name of '$dir'"
  6977: 	  dir=$absdir
  6978: 	  ;;
  6979: 	esac
  6980: 	case "$deplibs " in
  6981: 	*" -L$dir "* | *" $arg "*)
  6982: 	  # Will only happen for absolute or sysroot arguments
  6983: 	  ;;
  6984: 	*)
  6985: 	  # Preserve sysroot, but never include relative directories
  6986: 	  case $dir in
  6987: 	    [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
  6988: 	    *) func_append deplibs " -L$dir" ;;
  6989: 	  esac
  6990: 	  func_append lib_search_path " $dir"
  6991: 	  ;;
  6992: 	esac
  6993: 	case $host in
  6994: 	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
  6995: 	  testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
  6996: 	  case :$dllsearchpath: in
  6997: 	  *":$dir:"*) ;;
  6998: 	  ::) dllsearchpath=$dir;;
  6999: 	  *) func_append dllsearchpath ":$dir";;
  7000: 	  esac
  7001: 	  case :$dllsearchpath: in
  7002: 	  *":$testbindir:"*) ;;
  7003: 	  ::) dllsearchpath=$testbindir;;
  7004: 	  *) func_append dllsearchpath ":$testbindir";;
  7005: 	  esac
  7006: 	  ;;
  7007: 	esac
  7008: 	continue
  7009: 	;;
  7010: 
  7011:       -l*)
  7012: 	if test X-lc = "X$arg" || test X-lm = "X$arg"; then
  7013: 	  case $host in
  7014: 	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
  7015: 	    # These systems don't actually have a C or math library (as such)
  7016: 	    continue
  7017: 	    ;;
  7018: 	  *-*-os2*)
  7019: 	    # These systems don't actually have a C library (as such)
  7020: 	    test X-lc = "X$arg" && continue
  7021: 	    ;;
  7022: 	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
  7023: 	    # Do not include libc due to us having libc/libc_r.
  7024: 	    test X-lc = "X$arg" && continue
  7025: 	    ;;
  7026: 	  *-*-rhapsody* | *-*-darwin1.[012])
  7027: 	    # Rhapsody C and math libraries are in the System framework
  7028: 	    func_append deplibs " System.ltframework"
  7029: 	    continue
  7030: 	    ;;
  7031: 	  *-*-sco3.2v5* | *-*-sco5v6*)
  7032: 	    # Causes problems with __ctype
  7033: 	    test X-lc = "X$arg" && continue
  7034: 	    ;;
  7035: 	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
  7036: 	    # Compiler inserts libc in the correct place for threads to work
  7037: 	    test X-lc = "X$arg" && continue
  7038: 	    ;;
  7039: 	  esac
  7040: 	elif test X-lc_r = "X$arg"; then
  7041: 	 case $host in
  7042: 	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly* | *-*-bitrig*)
  7043: 	   # Do not include libc_r directly, use -pthread flag.
  7044: 	   continue
  7045: 	   ;;
  7046: 	 esac
  7047: 	fi
  7048: 	func_append deplibs " $arg"
  7049: 	continue
  7050: 	;;
  7051: 
  7052:       -mllvm)
  7053: 	prev=mllvm
  7054: 	continue
  7055: 	;;
  7056: 
  7057:       -module)
  7058: 	module=yes
  7059: 	continue
  7060: 	;;
  7061: 
  7062:       # Tru64 UNIX uses -model [arg] to determine the layout of C++
  7063:       # classes, name mangling, and exception handling.
  7064:       # Darwin uses the -arch flag to determine output architecture.
  7065:       -model|-arch|-isysroot|--sysroot)
  7066: 	func_append compiler_flags " $arg"
  7067: 	func_append compile_command " $arg"
  7068: 	func_append finalize_command " $arg"
  7069: 	prev=xcompiler
  7070: 	continue
  7071: 	;;
  7072: 
  7073:       -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
  7074:       |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
  7075: 	func_append compiler_flags " $arg"
  7076: 	func_append compile_command " $arg"
  7077: 	func_append finalize_command " $arg"
  7078: 	case "$new_inherited_linker_flags " in
  7079: 	    *" $arg "*) ;;
  7080: 	    * ) func_append new_inherited_linker_flags " $arg" ;;
  7081: 	esac
  7082: 	continue
  7083: 	;;
  7084: 
  7085:       -multi_module)
  7086: 	single_module=$wl-multi_module
  7087: 	continue
  7088: 	;;
  7089: 
  7090:       -no-fast-install)
  7091: 	fast_install=no
  7092: 	continue
  7093: 	;;
  7094: 
  7095:       -no-install)
  7096: 	case $host in
  7097: 	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
  7098: 	  # The PATH hackery in wrapper scripts is required on Windows
  7099: 	  # and Darwin in order for the loader to find any dlls it needs.
  7100: 	  func_warning "'-no-install' is ignored for $host"
  7101: 	  func_warning "assuming '-no-fast-install' instead"
  7102: 	  fast_install=no
  7103: 	  ;;
  7104: 	*) no_install=yes ;;
  7105: 	esac
  7106: 	continue
  7107: 	;;
  7108: 
  7109:       -no-undefined)
  7110: 	allow_undefined=no
  7111: 	continue
  7112: 	;;
  7113: 
  7114:       -objectlist)
  7115: 	prev=objectlist
  7116: 	continue
  7117: 	;;
  7118: 
  7119:       -os2dllname)
  7120: 	prev=os2dllname
  7121: 	continue
  7122: 	;;
  7123: 
  7124:       -o) prev=output ;;
  7125: 
  7126:       -precious-files-regex)
  7127: 	prev=precious_regex
  7128: 	continue
  7129: 	;;
  7130: 
  7131:       -release)
  7132: 	prev=release
  7133: 	continue
  7134: 	;;
  7135: 
  7136:       -rpath)
  7137: 	prev=rpath
  7138: 	continue
  7139: 	;;
  7140: 
  7141:       -R)
  7142: 	prev=xrpath
  7143: 	continue
  7144: 	;;
  7145: 
  7146:       -R*)
  7147: 	func_stripname '-R' '' "$arg"
  7148: 	dir=$func_stripname_result
  7149: 	# We need an absolute path.
  7150: 	case $dir in
  7151: 	[\\/]* | [A-Za-z]:[\\/]*) ;;
  7152: 	=*)
  7153: 	  func_stripname '=' '' "$dir"
  7154: 	  dir=$lt_sysroot$func_stripname_result
  7155: 	  ;;
  7156: 	*)
  7157: 	  func_fatal_error "only absolute run-paths are allowed"
  7158: 	  ;;
  7159: 	esac
  7160: 	case "$xrpath " in
  7161: 	*" $dir "*) ;;
  7162: 	*) func_append xrpath " $dir" ;;
  7163: 	esac
  7164: 	continue
  7165: 	;;
  7166: 
  7167:       -shared)
  7168: 	# The effects of -shared are defined in a previous loop.
  7169: 	continue
  7170: 	;;
  7171: 
  7172:       -shrext)
  7173: 	prev=shrext
  7174: 	continue
  7175: 	;;
  7176: 
  7177:       -static | -static-libtool-libs)
  7178: 	# The effects of -static are defined in a previous loop.
  7179: 	# We used to do the same as -all-static on platforms that
  7180: 	# didn't have a PIC flag, but the assumption that the effects
  7181: 	# would be equivalent was wrong.  It would break on at least
  7182: 	# Digital Unix and AIX.
  7183: 	continue
  7184: 	;;
  7185: 
  7186:       -thread-safe)
  7187: 	thread_safe=yes
  7188: 	continue
  7189: 	;;
  7190: 
  7191:       -version-info)
  7192: 	prev=vinfo
  7193: 	continue
  7194: 	;;
  7195: 
  7196:       -version-number)
  7197: 	prev=vinfo
  7198: 	vinfo_number=yes
  7199: 	continue
  7200: 	;;
  7201: 
  7202:       -weak)
  7203:         prev=weak
  7204: 	continue
  7205: 	;;
  7206: 
  7207:       -Wc,*)
  7208: 	func_stripname '-Wc,' '' "$arg"
  7209: 	args=$func_stripname_result
  7210: 	arg=
  7211: 	save_ifs=$IFS; IFS=,
  7212: 	for flag in $args; do
  7213: 	  IFS=$save_ifs
  7214:           func_quote_for_eval "$flag"
  7215: 	  func_append arg " $func_quote_for_eval_result"
  7216: 	  func_append compiler_flags " $func_quote_for_eval_result"
  7217: 	done
  7218: 	IFS=$save_ifs
  7219: 	func_stripname ' ' '' "$arg"
  7220: 	arg=$func_stripname_result
  7221: 	;;
  7222: 
  7223:       -Wl,*)
  7224: 	func_stripname '-Wl,' '' "$arg"
  7225: 	args=$func_stripname_result
  7226: 	arg=
  7227: 	save_ifs=$IFS; IFS=,
  7228: 	for flag in $args; do
  7229: 	  IFS=$save_ifs
  7230:           func_quote_for_eval "$flag"
  7231: 	  func_append arg " $wl$func_quote_for_eval_result"
  7232: 	  func_append compiler_flags " $wl$func_quote_for_eval_result"
  7233: 	  func_append linker_flags " $func_quote_for_eval_result"
  7234: 	done
  7235: 	IFS=$save_ifs
  7236: 	func_stripname ' ' '' "$arg"
  7237: 	arg=$func_stripname_result
  7238: 	;;
  7239: 
  7240:       -Xcompiler)
  7241: 	prev=xcompiler
  7242: 	continue
  7243: 	;;
  7244: 
  7245:       -Xlinker)
  7246: 	prev=xlinker
  7247: 	continue
  7248: 	;;
  7249: 
  7250:       -XCClinker)
  7251: 	prev=xcclinker
  7252: 	continue
  7253: 	;;
  7254: 
  7255:       # -msg_* for osf cc
  7256:       -msg_*)
  7257: 	func_quote_for_eval "$arg"
  7258: 	arg=$func_quote_for_eval_result
  7259: 	;;
  7260: 
  7261:       # Flags to be passed through unchanged, with rationale:
  7262:       # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
  7263:       # -r[0-9][0-9]*        specify processor for the SGI compiler
  7264:       # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
  7265:       # +DA*, +DD*           enable 64-bit mode for the HP compiler
  7266:       # -q*                  compiler args for the IBM compiler
  7267:       # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
  7268:       # -F/path              path to uninstalled frameworks, gcc on darwin
  7269:       # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
  7270:       # -fstack-protector*   stack protector flags for GCC
  7271:       # @file                GCC response files
  7272:       # -tp=*                Portland pgcc target processor selection
  7273:       # --sysroot=*          for sysroot support
  7274:       # -O*, -g*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
  7275:       # -stdlib=*            select c++ std lib with clang
  7276:       -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
  7277:       -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
  7278:       -O*|-g*|-flto*|-fwhopr*|-fuse-linker-plugin|-fstack-protector*|-stdlib=*)
  7279:         func_quote_for_eval "$arg"
  7280: 	arg=$func_quote_for_eval_result
  7281:         func_append compile_command " $arg"
  7282:         func_append finalize_command " $arg"
  7283:         func_append compiler_flags " $arg"
  7284:         continue
  7285:         ;;
  7286: 
  7287:       -Z*)
  7288:         if test os2 = "`expr $host : '.*\(os2\)'`"; then
  7289:           # OS/2 uses -Zxxx to specify OS/2-specific options
  7290: 	  compiler_flags="$compiler_flags $arg"
  7291: 	  func_append compile_command " $arg"
  7292: 	  func_append finalize_command " $arg"
  7293: 	  case $arg in
  7294: 	  -Zlinker | -Zstack)
  7295: 	    prev=xcompiler
  7296: 	    ;;
  7297: 	  esac
  7298: 	  continue
  7299:         else
  7300: 	  # Otherwise treat like 'Some other compiler flag' below
  7301: 	  func_quote_for_eval "$arg"
  7302: 	  arg=$func_quote_for_eval_result
  7303:         fi
  7304: 	;;
  7305: 
  7306:       # Some other compiler flag.
  7307:       -* | +*)
  7308:         func_quote_for_eval "$arg"
  7309: 	arg=$func_quote_for_eval_result
  7310: 	;;
  7311: 
  7312:       *.$objext)
  7313: 	# A standard object.
  7314: 	func_append objs " $arg"
  7315: 	;;
  7316: 
  7317:       *.lo)
  7318: 	# A libtool-controlled object.
  7319: 
  7320: 	# Check to see that this really is a libtool object.
  7321: 	if func_lalib_unsafe_p "$arg"; then
  7322: 	  pic_object=
  7323: 	  non_pic_object=
  7324: 
  7325: 	  # Read the .lo file
  7326: 	  func_source "$arg"
  7327: 
  7328: 	  if test -z "$pic_object" ||
  7329: 	     test -z "$non_pic_object" ||
  7330: 	     test none = "$pic_object" &&
  7331: 	     test none = "$non_pic_object"; then
  7332: 	    func_fatal_error "cannot find name of object for '$arg'"
  7333: 	  fi
  7334: 
  7335: 	  # Extract subdirectory from the argument.
  7336: 	  func_dirname "$arg" "/" ""
  7337: 	  xdir=$func_dirname_result
  7338: 
  7339: 	  test none = "$pic_object" || {
  7340: 	    # Prepend the subdirectory the object is found in.
  7341: 	    pic_object=$xdir$pic_object
  7342: 
  7343: 	    if test dlfiles = "$prev"; then
  7344: 	      if test yes = "$build_libtool_libs" && test yes = "$dlopen_support"; then
  7345: 		func_append dlfiles " $pic_object"
  7346: 		prev=
  7347: 		continue
  7348: 	      else
  7349: 		# If libtool objects are unsupported, then we need to preload.
  7350: 		prev=dlprefiles
  7351: 	      fi
  7352: 	    fi
  7353: 
  7354: 	    # CHECK ME:  I think I busted this.  -Ossama
  7355: 	    if test dlprefiles = "$prev"; then
  7356: 	      # Preload the old-style object.
  7357: 	      func_append dlprefiles " $pic_object"
  7358: 	      prev=
  7359: 	    fi
  7360: 
  7361: 	    # A PIC object.
  7362: 	    func_append libobjs " $pic_object"
  7363: 	    arg=$pic_object
  7364: 	  }
  7365: 
  7366: 	  # Non-PIC object.
  7367: 	  if test none != "$non_pic_object"; then
  7368: 	    # Prepend the subdirectory the object is found in.
  7369: 	    non_pic_object=$xdir$non_pic_object
  7370: 
  7371: 	    # A standard non-PIC object
  7372: 	    func_append non_pic_objects " $non_pic_object"
  7373: 	    if test -z "$pic_object" || test none = "$pic_object"; then
  7374: 	      arg=$non_pic_object
  7375: 	    fi
  7376: 	  else
  7377: 	    # If the PIC object exists, use it instead.
  7378: 	    # $xdir was prepended to $pic_object above.
  7379: 	    non_pic_object=$pic_object
  7380: 	    func_append non_pic_objects " $non_pic_object"
  7381: 	  fi
  7382: 	else
  7383: 	  # Only an error if not doing a dry-run.
  7384: 	  if $opt_dry_run; then
  7385: 	    # Extract subdirectory from the argument.
  7386: 	    func_dirname "$arg" "/" ""
  7387: 	    xdir=$func_dirname_result
  7388: 
  7389: 	    func_lo2o "$arg"
  7390: 	    pic_object=$xdir$objdir/$func_lo2o_result
  7391: 	    non_pic_object=$xdir$func_lo2o_result
  7392: 	    func_append libobjs " $pic_object"
  7393: 	    func_append non_pic_objects " $non_pic_object"
  7394: 	  else
  7395: 	    func_fatal_error "'$arg' is not a valid libtool object"
  7396: 	  fi
  7397: 	fi
  7398: 	;;
  7399: 
  7400:       *.$libext)
  7401: 	# An archive.
  7402: 	func_append deplibs " $arg"
  7403: 	func_append old_deplibs " $arg"
  7404: 	continue
  7405: 	;;
  7406: 
  7407:       *.la)
  7408: 	# A libtool-controlled library.
  7409: 
  7410: 	func_resolve_sysroot "$arg"
  7411: 	if test dlfiles = "$prev"; then
  7412: 	  # This library was specified with -dlopen.
  7413: 	  func_append dlfiles " $func_resolve_sysroot_result"
  7414: 	  prev=
  7415: 	elif test dlprefiles = "$prev"; then
  7416: 	  # The library was specified with -dlpreopen.
  7417: 	  func_append dlprefiles " $func_resolve_sysroot_result"
  7418: 	  prev=
  7419: 	else
  7420: 	  func_append deplibs " $func_resolve_sysroot_result"
  7421: 	fi
  7422: 	continue
  7423: 	;;
  7424: 
  7425:       # Some other compiler argument.
  7426:       *)
  7427: 	# Unknown arguments in both finalize_command and compile_command need
  7428: 	# to be aesthetically quoted because they are evaled later.
  7429: 	func_quote_for_eval "$arg"
  7430: 	arg=$func_quote_for_eval_result
  7431: 	;;
  7432:       esac # arg
  7433: 
  7434:       # Now actually substitute the argument into the commands.
  7435:       if test -n "$arg"; then
  7436: 	func_append compile_command " $arg"
  7437: 	func_append finalize_command " $arg"
  7438:       fi
  7439:     done # argument parsing loop
  7440: 
  7441:     test -n "$prev" && \
  7442:       func_fatal_help "the '$prevarg' option requires an argument"
  7443: 
  7444:     if test yes = "$export_dynamic" && test -n "$export_dynamic_flag_spec"; then
  7445:       eval arg=\"$export_dynamic_flag_spec\"
  7446:       func_append compile_command " $arg"
  7447:       func_append finalize_command " $arg"
  7448:     fi
  7449: 
  7450:     oldlibs=
  7451:     # calculate the name of the file, without its directory
  7452:     func_basename "$output"
  7453:     outputname=$func_basename_result
  7454:     libobjs_save=$libobjs
  7455: 
  7456:     if test -n "$shlibpath_var"; then
  7457:       # get the directories listed in $shlibpath_var
  7458:       eval shlib_search_path=\`\$ECHO \"\$$shlibpath_var\" \| \$SED \'s/:/ /g\'\`
  7459:     else
  7460:       shlib_search_path=
  7461:     fi
  7462:     eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
  7463:     eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
  7464: 
  7465:     # Definition is injected by LT_CONFIG during libtool generation.
  7466:     func_munge_path_list sys_lib_dlsearch_path "$LT_SYS_LIBRARY_PATH"
  7467: 
  7468:     func_dirname "$output" "/" ""
  7469:     output_objdir=$func_dirname_result$objdir
  7470:     func_to_tool_file "$output_objdir/"
  7471:     tool_output_objdir=$func_to_tool_file_result
  7472:     # Create the object directory.
  7473:     func_mkdir_p "$output_objdir"
  7474: 
  7475:     # Determine the type of output
  7476:     case $output in
  7477:     "")
  7478:       func_fatal_help "you must specify an output file"
  7479:       ;;
  7480:     *.$libext) linkmode=oldlib ;;
  7481:     *.lo | *.$objext) linkmode=obj ;;
  7482:     *.la) linkmode=lib ;;
  7483:     *) linkmode=prog ;; # Anything else should be a program.
  7484:     esac
  7485: 
  7486:     specialdeplibs=
  7487: 
  7488:     libs=
  7489:     # Find all interdependent deplibs by searching for libraries
  7490:     # that are linked more than once (e.g. -la -lb -la)
  7491:     for deplib in $deplibs; do
  7492:       if $opt_preserve_dup_deps; then
  7493: 	case "$libs " in
  7494: 	*" $deplib "*) func_append specialdeplibs " $deplib" ;;
  7495: 	esac
  7496:       fi
  7497:       func_append libs " $deplib"
  7498:     done
  7499: 
  7500:     if test lib = "$linkmode"; then
  7501:       libs="$predeps $libs $compiler_lib_search_path $postdeps"
  7502: 
  7503:       # Compute libraries that are listed more than once in $predeps
  7504:       # $postdeps and mark them as special (i.e., whose duplicates are
  7505:       # not to be eliminated).
  7506:       pre_post_deps=
  7507:       if $opt_duplicate_compiler_generated_deps; then
  7508: 	for pre_post_dep in $predeps $postdeps; do
  7509: 	  case "$pre_post_deps " in
  7510: 	  *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
  7511: 	  esac
  7512: 	  func_append pre_post_deps " $pre_post_dep"
  7513: 	done
  7514:       fi
  7515:       pre_post_deps=
  7516:     fi
  7517: 
  7518:     deplibs=
  7519:     newdependency_libs=
  7520:     newlib_search_path=
  7521:     need_relink=no # whether we're linking any uninstalled libtool libraries
  7522:     notinst_deplibs= # not-installed libtool libraries
  7523:     notinst_path= # paths that contain not-installed libtool libraries
  7524: 
  7525:     case $linkmode in
  7526:     lib)
  7527: 	passes="conv dlpreopen link"
  7528: 	for file in $dlfiles $dlprefiles; do
  7529: 	  case $file in
  7530: 	  *.la) ;;
  7531: 	  *)
  7532: 	    func_fatal_help "libraries can '-dlopen' only libtool libraries: $file"
  7533: 	    ;;
  7534: 	  esac
  7535: 	done
  7536: 	;;
  7537:     prog)
  7538: 	compile_deplibs=
  7539: 	finalize_deplibs=
  7540: 	alldeplibs=false
  7541: 	newdlfiles=
  7542: 	newdlprefiles=
  7543: 	passes="conv scan dlopen dlpreopen link"
  7544: 	;;
  7545:     *)  passes="conv"
  7546: 	;;
  7547:     esac
  7548: 
  7549:     for pass in $passes; do
  7550:       # The preopen pass in lib mode reverses $deplibs; put it back here
  7551:       # so that -L comes before libs that need it for instance...
  7552:       if test lib,link = "$linkmode,$pass"; then
  7553: 	## FIXME: Find the place where the list is rebuilt in the wrong
  7554: 	##        order, and fix it there properly
  7555:         tmp_deplibs=
  7556: 	for deplib in $deplibs; do
  7557: 	  tmp_deplibs="$deplib $tmp_deplibs"
  7558: 	done
  7559: 	deplibs=$tmp_deplibs
  7560:       fi
  7561: 
  7562:       if test lib,link = "$linkmode,$pass" ||
  7563: 	 test prog,scan = "$linkmode,$pass"; then
  7564: 	libs=$deplibs
  7565: 	deplibs=
  7566:       fi
  7567:       if test prog = "$linkmode"; then
  7568: 	case $pass in
  7569: 	dlopen) libs=$dlfiles ;;
  7570: 	dlpreopen) libs=$dlprefiles ;;
  7571: 	link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
  7572: 	esac
  7573:       fi
  7574:       if test lib,dlpreopen = "$linkmode,$pass"; then
  7575: 	# Collect and forward deplibs of preopened libtool libs
  7576: 	for lib in $dlprefiles; do
  7577: 	  # Ignore non-libtool-libs
  7578: 	  dependency_libs=
  7579: 	  func_resolve_sysroot "$lib"
  7580: 	  case $lib in
  7581: 	  *.la)	func_source "$func_resolve_sysroot_result" ;;
  7582: 	  esac
  7583: 
  7584: 	  # Collect preopened libtool deplibs, except any this library
  7585: 	  # has declared as weak libs
  7586: 	  for deplib in $dependency_libs; do
  7587: 	    func_basename "$deplib"
  7588:             deplib_base=$func_basename_result
  7589: 	    case " $weak_libs " in
  7590: 	    *" $deplib_base "*) ;;
  7591: 	    *) func_append deplibs " $deplib" ;;
  7592: 	    esac
  7593: 	  done
  7594: 	done
  7595: 	libs=$dlprefiles
  7596:       fi
  7597:       if test dlopen = "$pass"; then
  7598: 	# Collect dlpreopened libraries
  7599: 	save_deplibs=$deplibs
  7600: 	deplibs=
  7601:       fi
  7602: 
  7603:       for deplib in $libs; do
  7604: 	lib=
  7605: 	found=false
  7606: 	case $deplib in
  7607: 	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
  7608:         |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
  7609: 	  if test prog,link = "$linkmode,$pass"; then
  7610: 	    compile_deplibs="$deplib $compile_deplibs"
  7611: 	    finalize_deplibs="$deplib $finalize_deplibs"
  7612: 	  else
  7613: 	    func_append compiler_flags " $deplib"
  7614: 	    if test lib = "$linkmode"; then
  7615: 		case "$new_inherited_linker_flags " in
  7616: 		    *" $deplib "*) ;;
  7617: 		    * ) func_append new_inherited_linker_flags " $deplib" ;;
  7618: 		esac
  7619: 	    fi
  7620: 	  fi
  7621: 	  continue
  7622: 	  ;;
  7623: 	-l*)
  7624: 	  if test lib != "$linkmode" && test prog != "$linkmode"; then
  7625: 	    func_warning "'-l' is ignored for archives/objects"
  7626: 	    continue
  7627: 	  fi
  7628: 	  func_stripname '-l' '' "$deplib"
  7629: 	  name=$func_stripname_result
  7630: 	  if test lib = "$linkmode"; then
  7631: 	    searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
  7632: 	  else
  7633: 	    searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
  7634: 	  fi
  7635: 	  for searchdir in $searchdirs; do
  7636: 	    for search_ext in .la $std_shrext .so .a; do
  7637: 	      # Search the libtool library
  7638: 	      lib=$searchdir/lib$name$search_ext
  7639: 	      if test -f "$lib"; then
  7640: 		if test .la = "$search_ext"; then
  7641: 		  found=:
  7642: 		else
  7643: 		  found=false
  7644: 		fi
  7645: 		break 2
  7646: 	      fi
  7647: 	    done
  7648: 	  done
  7649: 	  if $found; then
  7650: 	    # deplib is a libtool library
  7651: 	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
  7652: 	    # We need to do some special things here, and not later.
  7653: 	    if test yes = "$allow_libtool_libs_with_static_runtimes"; then
  7654: 	      case " $predeps $postdeps " in
  7655: 	      *" $deplib "*)
  7656: 		if func_lalib_p "$lib"; then
  7657: 		  library_names=
  7658: 		  old_library=
  7659: 		  func_source "$lib"
  7660: 		  for l in $old_library $library_names; do
  7661: 		    ll=$l
  7662: 		  done
  7663: 		  if test "X$ll" = "X$old_library"; then # only static version available
  7664: 		    found=false
  7665: 		    func_dirname "$lib" "" "."
  7666: 		    ladir=$func_dirname_result
  7667: 		    lib=$ladir/$old_library
  7668: 		    if test prog,link = "$linkmode,$pass"; then
  7669: 		      compile_deplibs="$deplib $compile_deplibs"
  7670: 		      finalize_deplibs="$deplib $finalize_deplibs"
  7671: 		    else
  7672: 		      deplibs="$deplib $deplibs"
  7673: 		      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
  7674: 		    fi
  7675: 		    continue
  7676: 		  fi
  7677: 		fi
  7678: 		;;
  7679: 	      *) ;;
  7680: 	      esac
  7681: 	    fi
  7682: 	  else
  7683: 	    # deplib doesn't seem to be a libtool library
  7684: 	    if test prog,link = "$linkmode,$pass"; then
  7685: 	      compile_deplibs="$deplib $compile_deplibs"
  7686: 	      finalize_deplibs="$deplib $finalize_deplibs"
  7687: 	    else
  7688: 	      deplibs="$deplib $deplibs"
  7689: 	      test lib = "$linkmode" && newdependency_libs="$deplib $newdependency_libs"
  7690: 	    fi
  7691: 	    continue
  7692: 	  fi
  7693: 	  ;; # -l
  7694: 	*.ltframework)
  7695: 	  if test prog,link = "$linkmode,$pass"; then
  7696: 	    compile_deplibs="$deplib $compile_deplibs"
  7697: 	    finalize_deplibs="$deplib $finalize_deplibs"
  7698: 	  else
  7699: 	    deplibs="$deplib $deplibs"
  7700: 	    if test lib = "$linkmode"; then
  7701: 		case "$new_inherited_linker_flags " in
  7702: 		    *" $deplib "*) ;;
  7703: 		    * ) func_append new_inherited_linker_flags " $deplib" ;;
  7704: 		esac
  7705: 	    fi
  7706: 	  fi
  7707: 	  continue
  7708: 	  ;;
  7709: 	-L*)
  7710: 	  case $linkmode in
  7711: 	  lib)
  7712: 	    deplibs="$deplib $deplibs"
  7713: 	    test conv = "$pass" && continue
  7714: 	    newdependency_libs="$deplib $newdependency_libs"
  7715: 	    func_stripname '-L' '' "$deplib"
  7716: 	    func_resolve_sysroot "$func_stripname_result"
  7717: 	    func_append newlib_search_path " $func_resolve_sysroot_result"
  7718: 	    ;;
  7719: 	  prog)
  7720: 	    if test conv = "$pass"; then
  7721: 	      deplibs="$deplib $deplibs"
  7722: 	      continue
  7723: 	    fi
  7724: 	    if test scan = "$pass"; then
  7725: 	      deplibs="$deplib $deplibs"
  7726: 	    else
  7727: 	      compile_deplibs="$deplib $compile_deplibs"
  7728: 	      finalize_deplibs="$deplib $finalize_deplibs"
  7729: 	    fi
  7730: 	    func_stripname '-L' '' "$deplib"
  7731: 	    func_resolve_sysroot "$func_stripname_result"
  7732: 	    func_append newlib_search_path " $func_resolve_sysroot_result"
  7733: 	    ;;
  7734: 	  *)
  7735: 	    func_warning "'-L' is ignored for archives/objects"
  7736: 	    ;;
  7737: 	  esac # linkmode
  7738: 	  continue
  7739: 	  ;; # -L
  7740: 	-R*)
  7741: 	  if test link = "$pass"; then
  7742: 	    func_stripname '-R' '' "$deplib"
  7743: 	    func_resolve_sysroot "$func_stripname_result"
  7744: 	    dir=$func_resolve_sysroot_result
  7745: 	    # Make sure the xrpath contains only unique directories.
  7746: 	    case "$xrpath " in
  7747: 	    *" $dir "*) ;;
  7748: 	    *) func_append xrpath " $dir" ;;
  7749: 	    esac
  7750: 	  fi
  7751: 	  deplibs="$deplib $deplibs"
  7752: 	  continue
  7753: 	  ;;
  7754: 	*.la)
  7755: 	  func_resolve_sysroot "$deplib"
  7756: 	  lib=$func_resolve_sysroot_result
  7757: 	  ;;
  7758: 	*.$libext)
  7759: 	  if test conv = "$pass"; then
  7760: 	    deplibs="$deplib $deplibs"
  7761: 	    continue
  7762: 	  fi
  7763: 	  case $linkmode in
  7764: 	  lib)
  7765: 	    # Linking convenience modules into shared libraries is allowed,
  7766: 	    # but linking other static libraries is non-portable.
  7767: 	    case " $dlpreconveniencelibs " in
  7768: 	    *" $deplib "*) ;;
  7769: 	    *)
  7770: 	      valid_a_lib=false
  7771: 	      case $deplibs_check_method in
  7772: 		match_pattern*)
  7773: 		  set dummy $deplibs_check_method; shift
  7774: 		  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
  7775: 		  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
  7776: 		    | $EGREP "$match_pattern_regex" > /dev/null; then
  7777: 		    valid_a_lib=:
  7778: 		  fi
  7779: 		;;
  7780: 		pass_all)
  7781: 		  valid_a_lib=:
  7782: 		;;
  7783: 	      esac
  7784: 	      if $valid_a_lib; then
  7785: 		echo
  7786: 		$ECHO "*** Warning: Linking the shared library $output against the"
  7787: 		$ECHO "*** static library $deplib is not portable!"
  7788: 		deplibs="$deplib $deplibs"
  7789: 	      else
  7790: 		echo
  7791: 		$ECHO "*** Warning: Trying to link with static lib archive $deplib."
  7792: 		echo "*** I have the capability to make that library automatically link in when"
  7793: 		echo "*** you link to this library.  But I can only do this if you have a"
  7794: 		echo "*** shared version of the library, which you do not appear to have"
  7795: 		echo "*** because the file extensions .$libext of this argument makes me believe"
  7796: 		echo "*** that it is just a static archive that I should not use here."
  7797: 	      fi
  7798: 	      ;;
  7799: 	    esac
  7800: 	    continue
  7801: 	    ;;
  7802: 	  prog)
  7803: 	    if test link != "$pass"; then
  7804: 	      deplibs="$deplib $deplibs"
  7805: 	    else
  7806: 	      compile_deplibs="$deplib $compile_deplibs"
  7807: 	      finalize_deplibs="$deplib $finalize_deplibs"
  7808: 	    fi
  7809: 	    continue
  7810: 	    ;;
  7811: 	  esac # linkmode
  7812: 	  ;; # *.$libext
  7813: 	*.lo | *.$objext)
  7814: 	  if test conv = "$pass"; then
  7815: 	    deplibs="$deplib $deplibs"
  7816: 	  elif test prog = "$linkmode"; then
  7817: 	    if test dlpreopen = "$pass" || test yes != "$dlopen_support" || test no = "$build_libtool_libs"; then
  7818: 	      # If there is no dlopen support or we're linking statically,
  7819: 	      # we need to preload.
  7820: 	      func_append newdlprefiles " $deplib"
  7821: 	      compile_deplibs="$deplib $compile_deplibs"
  7822: 	      finalize_deplibs="$deplib $finalize_deplibs"
  7823: 	    else
  7824: 	      func_append newdlfiles " $deplib"
  7825: 	    fi
  7826: 	  fi
  7827: 	  continue
  7828: 	  ;;
  7829: 	%DEPLIBS%)
  7830: 	  alldeplibs=:
  7831: 	  continue
  7832: 	  ;;
  7833: 	esac # case $deplib
  7834: 
  7835: 	$found || test -f "$lib" \
  7836: 	  || func_fatal_error "cannot find the library '$lib' or unhandled argument '$deplib'"
  7837: 
  7838: 	# Check to see that this really is a libtool archive.
  7839: 	func_lalib_unsafe_p "$lib" \
  7840: 	  || func_fatal_error "'$lib' is not a valid libtool archive"
  7841: 
  7842: 	func_dirname "$lib" "" "."
  7843: 	ladir=$func_dirname_result
  7844: 
  7845: 	dlname=
  7846: 	dlopen=
  7847: 	dlpreopen=
  7848: 	libdir=
  7849: 	library_names=
  7850: 	old_library=
  7851: 	inherited_linker_flags=
  7852: 	# If the library was installed with an old release of libtool,
  7853: 	# it will not redefine variables installed, or shouldnotlink
  7854: 	installed=yes
  7855: 	shouldnotlink=no
  7856: 	avoidtemprpath=
  7857: 
  7858: 
  7859: 	# Read the .la file
  7860: 	func_source "$lib"
  7861: 
  7862: 	# Convert "-framework foo" to "foo.ltframework"
  7863: 	if test -n "$inherited_linker_flags"; then
  7864: 	  tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
  7865: 	  for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
  7866: 	    case " $new_inherited_linker_flags " in
  7867: 	      *" $tmp_inherited_linker_flag "*) ;;
  7868: 	      *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
  7869: 	    esac
  7870: 	  done
  7871: 	fi
  7872: 	dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
  7873: 	if test lib,link = "$linkmode,$pass" ||
  7874: 	   test prog,scan = "$linkmode,$pass" ||
  7875: 	   { test prog != "$linkmode" && test lib != "$linkmode"; }; then
  7876: 	  test -n "$dlopen" && func_append dlfiles " $dlopen"
  7877: 	  test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
  7878: 	fi
  7879: 
  7880: 	if test conv = "$pass"; then
  7881: 	  # Only check for convenience libraries
  7882: 	  deplibs="$lib $deplibs"
  7883: 	  if test -z "$libdir"; then
  7884: 	    if test -z "$old_library"; then
  7885: 	      func_fatal_error "cannot find name of link library for '$lib'"
  7886: 	    fi
  7887: 	    # It is a libtool convenience library, so add in its objects.
  7888: 	    func_append convenience " $ladir/$objdir/$old_library"
  7889: 	    func_append old_convenience " $ladir/$objdir/$old_library"
  7890: 	  elif test prog != "$linkmode" && test lib != "$linkmode"; then
  7891: 	    func_fatal_error "'$lib' is not a convenience library"
  7892: 	  fi
  7893: 	  tmp_libs=
  7894: 	  for deplib in $dependency_libs; do
  7895: 	    deplibs="$deplib $deplibs"
  7896: 	    if $opt_preserve_dup_deps; then
  7897: 	      case "$tmp_libs " in
  7898: 	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
  7899: 	      esac
  7900: 	    fi
  7901: 	    func_append tmp_libs " $deplib"
  7902: 	  done
  7903: 	  continue
  7904: 	fi # $pass = conv
  7905: 
  7906: 
  7907: 	# Get the name of the library we link against.
  7908: 	linklib=
  7909: 	if test -n "$old_library" &&
  7910: 	   { test yes = "$prefer_static_libs" ||
  7911: 	     test built,no = "$prefer_static_libs,$installed"; }; then
  7912: 	  linklib=$old_library
  7913: 	else
  7914: 	  for l in $old_library $library_names; do
  7915: 	    linklib=$l
  7916: 	  done
  7917: 	fi
  7918: 	if test -z "$linklib"; then
  7919: 	  func_fatal_error "cannot find name of link library for '$lib'"
  7920: 	fi
  7921: 
  7922: 	# This library was specified with -dlopen.
  7923: 	if test dlopen = "$pass"; then
  7924: 	  test -z "$libdir" \
  7925: 	    && func_fatal_error "cannot -dlopen a convenience library: '$lib'"
  7926: 	  if test -z "$dlname" ||
  7927: 	     test yes != "$dlopen_support" ||
  7928: 	     test no = "$build_libtool_libs"
  7929: 	  then
  7930: 	    # If there is no dlname, no dlopen support or we're linking
  7931: 	    # statically, we need to preload.  We also need to preload any
  7932: 	    # dependent libraries so libltdl's deplib preloader doesn't
  7933: 	    # bomb out in the load deplibs phase.
  7934: 	    func_append dlprefiles " $lib $dependency_libs"
  7935: 	  else
  7936: 	    func_append newdlfiles " $lib"
  7937: 	  fi
  7938: 	  continue
  7939: 	fi # $pass = dlopen
  7940: 
  7941: 	# We need an absolute path.
  7942: 	case $ladir in
  7943: 	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir=$ladir ;;
  7944: 	*)
  7945: 	  abs_ladir=`cd "$ladir" && pwd`
  7946: 	  if test -z "$abs_ladir"; then
  7947: 	    func_warning "cannot determine absolute directory name of '$ladir'"
  7948: 	    func_warning "passing it literally to the linker, although it might fail"
  7949: 	    abs_ladir=$ladir
  7950: 	  fi
  7951: 	  ;;
  7952: 	esac
  7953: 	func_basename "$lib"
  7954: 	laname=$func_basename_result
  7955: 
  7956: 	# Find the relevant object directory and library name.
  7957: 	if test yes = "$installed"; then
  7958: 	  if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
  7959: 	    func_warning "library '$lib' was moved."
  7960: 	    dir=$ladir
  7961: 	    absdir=$abs_ladir
  7962: 	    libdir=$abs_ladir
  7963: 	  else
  7964: 	    dir=$lt_sysroot$libdir
  7965: 	    absdir=$lt_sysroot$libdir
  7966: 	  fi
  7967: 	  test yes = "$hardcode_automatic" && avoidtemprpath=yes
  7968: 	else
  7969: 	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
  7970: 	    dir=$ladir
  7971: 	    absdir=$abs_ladir
  7972: 	    # Remove this search path later
  7973: 	    func_append notinst_path " $abs_ladir"
  7974: 	  else
  7975: 	    dir=$ladir/$objdir
  7976: 	    absdir=$abs_ladir/$objdir
  7977: 	    # Remove this search path later
  7978: 	    func_append notinst_path " $abs_ladir"
  7979: 	  fi
  7980: 	fi # $installed = yes
  7981: 	func_stripname 'lib' '.la' "$laname"
  7982: 	name=$func_stripname_result
  7983: 
  7984: 	# This library was specified with -dlpreopen.
  7985: 	if test dlpreopen = "$pass"; then
  7986: 	  if test -z "$libdir" && test prog = "$linkmode"; then
  7987: 	    func_fatal_error "only libraries may -dlpreopen a convenience library: '$lib'"
  7988: 	  fi
  7989: 	  case $host in
  7990: 	    # special handling for platforms with PE-DLLs.
  7991: 	    *cygwin* | *mingw* | *cegcc* )
  7992: 	      # Linker will automatically link against shared library if both
  7993: 	      # static and shared are present.  Therefore, ensure we extract
  7994: 	      # symbols from the import library if a shared library is present
  7995: 	      # (otherwise, the dlopen module name will be incorrect).  We do
  7996: 	      # this by putting the import library name into $newdlprefiles.
  7997: 	      # We recover the dlopen module name by 'saving' the la file
  7998: 	      # name in a special purpose variable, and (later) extracting the
  7999: 	      # dlname from the la file.
  8000: 	      if test -n "$dlname"; then
  8001: 	        func_tr_sh "$dir/$linklib"
  8002: 	        eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
  8003: 	        func_append newdlprefiles " $dir/$linklib"
  8004: 	      else
  8005: 	        func_append newdlprefiles " $dir/$old_library"
  8006: 	        # Keep a list of preopened convenience libraries to check
  8007: 	        # that they are being used correctly in the link pass.
  8008: 	        test -z "$libdir" && \
  8009: 	          func_append dlpreconveniencelibs " $dir/$old_library"
  8010: 	      fi
  8011: 	    ;;
  8012: 	    * )
  8013: 	      # Prefer using a static library (so that no silly _DYNAMIC symbols
  8014: 	      # are required to link).
  8015: 	      if test -n "$old_library"; then
  8016: 	        func_append newdlprefiles " $dir/$old_library"
  8017: 	        # Keep a list of preopened convenience libraries to check
  8018: 	        # that they are being used correctly in the link pass.
  8019: 	        test -z "$libdir" && \
  8020: 	          func_append dlpreconveniencelibs " $dir/$old_library"
  8021: 	      # Otherwise, use the dlname, so that lt_dlopen finds it.
  8022: 	      elif test -n "$dlname"; then
  8023: 	        func_append newdlprefiles " $dir/$dlname"
  8024: 	      else
  8025: 	        func_append newdlprefiles " $dir/$linklib"
  8026: 	      fi
  8027: 	    ;;
  8028: 	  esac
  8029: 	fi # $pass = dlpreopen
  8030: 
  8031: 	if test -z "$libdir"; then
  8032: 	  # Link the convenience library
  8033: 	  if test lib = "$linkmode"; then
  8034: 	    deplibs="$dir/$old_library $deplibs"
  8035: 	  elif test prog,link = "$linkmode,$pass"; then
  8036: 	    compile_deplibs="$dir/$old_library $compile_deplibs"
  8037: 	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
  8038: 	  else
  8039: 	    deplibs="$lib $deplibs" # used for prog,scan pass
  8040: 	  fi
  8041: 	  continue
  8042: 	fi
  8043: 
  8044: 
  8045: 	if test prog = "$linkmode" && test link != "$pass"; then
  8046: 	  func_append newlib_search_path " $ladir"
  8047: 	  deplibs="$lib $deplibs"
  8048: 
  8049: 	  linkalldeplibs=false
  8050: 	  if test no != "$link_all_deplibs" || test -z "$library_names" ||
  8051: 	     test no = "$build_libtool_libs"; then
  8052: 	    linkalldeplibs=:
  8053: 	  fi
  8054: 
  8055: 	  tmp_libs=
  8056: 	  for deplib in $dependency_libs; do
  8057: 	    case $deplib in
  8058: 	    -L*) func_stripname '-L' '' "$deplib"
  8059: 	         func_resolve_sysroot "$func_stripname_result"
  8060: 	         func_append newlib_search_path " $func_resolve_sysroot_result"
  8061: 		 ;;
  8062: 	    esac
  8063: 	    # Need to link against all dependency_libs?
  8064: 	    if $linkalldeplibs; then
  8065: 	      deplibs="$deplib $deplibs"
  8066: 	    else
  8067: 	      # Need to hardcode shared library paths
  8068: 	      # or/and link against static libraries
  8069: 	      newdependency_libs="$deplib $newdependency_libs"
  8070: 	    fi
  8071: 	    if $opt_preserve_dup_deps; then
  8072: 	      case "$tmp_libs " in
  8073: 	      *" $deplib "*) func_append specialdeplibs " $deplib" ;;
  8074: 	      esac
  8075: 	    fi
  8076: 	    func_append tmp_libs " $deplib"
  8077: 	  done # for deplib
  8078: 	  continue
  8079: 	fi # $linkmode = prog...
  8080: 
  8081: 	if test prog,link = "$linkmode,$pass"; then
  8082: 	  if test -n "$library_names" &&
  8083: 	     { { test no = "$prefer_static_libs" ||
  8084: 	         test built,yes = "$prefer_static_libs,$installed"; } ||
  8085: 	       test -z "$old_library"; }; then
  8086: 	    # We need to hardcode the library path
  8087: 	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath"; then
  8088: 	      # Make sure the rpath contains only unique directories.
  8089: 	      case $temp_rpath: in
  8090: 	      *"$absdir:"*) ;;
  8091: 	      *) func_append temp_rpath "$absdir:" ;;
  8092: 	      esac
  8093: 	    fi
  8094: 
  8095: 	    # Hardcode the library path.
  8096: 	    # Skip directories that are in the system default run-time
  8097: 	    # search path.
  8098: 	    case " $sys_lib_dlsearch_path " in
  8099: 	    *" $absdir "*) ;;
  8100: 	    *)
  8101: 	      case "$compile_rpath " in
  8102: 	      *" $absdir "*) ;;
  8103: 	      *) func_append compile_rpath " $absdir" ;;
  8104: 	      esac
  8105: 	      ;;
  8106: 	    esac
  8107: 	    case " $sys_lib_dlsearch_path " in
  8108: 	    *" $libdir "*) ;;
  8109: 	    *)
  8110: 	      case "$finalize_rpath " in
  8111: 	      *" $libdir "*) ;;
  8112: 	      *) func_append finalize_rpath " $libdir" ;;
  8113: 	      esac
  8114: 	      ;;
  8115: 	    esac
  8116: 	  fi # $linkmode,$pass = prog,link...
  8117: 
  8118: 	  if $alldeplibs &&
  8119: 	     { test pass_all = "$deplibs_check_method" ||
  8120: 	       { test yes = "$build_libtool_libs" &&
  8121: 		 test -n "$library_names"; }; }; then
  8122: 	    # We only need to search for static libraries
  8123: 	    continue
  8124: 	  fi
  8125: 	fi
  8126: 
  8127: 	link_static=no # Whether the deplib will be linked statically
  8128: 	use_static_libs=$prefer_static_libs
  8129: 	if test built = "$use_static_libs" && test yes = "$installed"; then
  8130: 	  use_static_libs=no
  8131: 	fi
  8132: 	if test -n "$library_names" &&
  8133: 	   { test no = "$use_static_libs" || test -z "$old_library"; }; then
  8134: 	  case $host in
  8135: 	  *cygwin* | *mingw* | *cegcc* | *os2*)
  8136: 	      # No point in relinking DLLs because paths are not encoded
  8137: 	      func_append notinst_deplibs " $lib"
  8138: 	      need_relink=no
  8139: 	    ;;
  8140: 	  *)
  8141: 	    if test no = "$installed"; then
  8142: 	      func_append notinst_deplibs " $lib"
  8143: 	      need_relink=yes
  8144: 	    fi
  8145: 	    ;;
  8146: 	  esac
  8147: 	  # This is a shared library
  8148: 
  8149: 	  # Warn about portability, can't link against -module's on some
  8150: 	  # systems (darwin).  Don't bleat about dlopened modules though!
  8151: 	  dlopenmodule=
  8152: 	  for dlpremoduletest in $dlprefiles; do
  8153: 	    if test "X$dlpremoduletest" = "X$lib"; then
  8154: 	      dlopenmodule=$dlpremoduletest
  8155: 	      break
  8156: 	    fi
  8157: 	  done
  8158: 	  if test -z "$dlopenmodule" && test yes = "$shouldnotlink" && test link = "$pass"; then
  8159: 	    echo
  8160: 	    if test prog = "$linkmode"; then
  8161: 	      $ECHO "*** Warning: Linking the executable $output against the loadable module"
  8162: 	    else
  8163: 	      $ECHO "*** Warning: Linking the shared library $output against the loadable module"
  8164: 	    fi
  8165: 	    $ECHO "*** $linklib is not portable!"
  8166: 	  fi
  8167: 	  if test lib = "$linkmode" &&
  8168: 	     test yes = "$hardcode_into_libs"; then
  8169: 	    # Hardcode the library path.
  8170: 	    # Skip directories that are in the system default run-time
  8171: 	    # search path.
  8172: 	    case " $sys_lib_dlsearch_path " in
  8173: 	    *" $absdir "*) ;;
  8174: 	    *)
  8175: 	      case "$compile_rpath " in
  8176: 	      *" $absdir "*) ;;
  8177: 	      *) func_append compile_rpath " $absdir" ;;
  8178: 	      esac
  8179: 	      ;;
  8180: 	    esac
  8181: 	    case " $sys_lib_dlsearch_path " in
  8182: 	    *" $libdir "*) ;;
  8183: 	    *)
  8184: 	      case "$finalize_rpath " in
  8185: 	      *" $libdir "*) ;;
  8186: 	      *) func_append finalize_rpath " $libdir" ;;
  8187: 	      esac
  8188: 	      ;;
  8189: 	    esac
  8190: 	  fi
  8191: 
  8192: 	  if test -n "$old_archive_from_expsyms_cmds"; then
  8193: 	    # figure out the soname
  8194: 	    set dummy $library_names
  8195: 	    shift
  8196: 	    realname=$1
  8197: 	    shift
  8198: 	    libname=`eval "\\$ECHO \"$libname_spec\""`
  8199: 	    # use dlname if we got it. it's perfectly good, no?
  8200: 	    if test -n "$dlname"; then
  8201: 	      soname=$dlname
  8202: 	    elif test -n "$soname_spec"; then
  8203: 	      # bleh windows
  8204: 	      case $host in
  8205: 	      *cygwin* | mingw* | *cegcc* | *os2*)
  8206: 	        func_arith $current - $age
  8207: 		major=$func_arith_result
  8208: 		versuffix=-$major
  8209: 		;;
  8210: 	      esac
  8211: 	      eval soname=\"$soname_spec\"
  8212: 	    else
  8213: 	      soname=$realname
  8214: 	    fi
  8215: 
  8216: 	    # Make a new name for the extract_expsyms_cmds to use
  8217: 	    soroot=$soname
  8218: 	    func_basename "$soroot"
  8219: 	    soname=$func_basename_result
  8220: 	    func_stripname 'lib' '.dll' "$soname"
  8221: 	    newlib=libimp-$func_stripname_result.a
  8222: 
  8223: 	    # If the library has no export list, then create one now
  8224: 	    if test -f "$output_objdir/$soname-def"; then :
  8225: 	    else
  8226: 	      func_verbose "extracting exported symbol list from '$soname'"
  8227: 	      func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
  8228: 	    fi
  8229: 
  8230: 	    # Create $newlib
  8231: 	    if test -f "$output_objdir/$newlib"; then :; else
  8232: 	      func_verbose "generating import library for '$soname'"
  8233: 	      func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
  8234: 	    fi
  8235: 	    # make sure the library variables are pointing to the new library
  8236: 	    dir=$output_objdir
  8237: 	    linklib=$newlib
  8238: 	  fi # test -n "$old_archive_from_expsyms_cmds"
  8239: 
  8240: 	  if test prog = "$linkmode" || test relink != "$opt_mode"; then
  8241: 	    add_shlibpath=
  8242: 	    add_dir=
  8243: 	    add=
  8244: 	    lib_linked=yes
  8245: 	    case $hardcode_action in
  8246: 	    immediate | unsupported)
  8247: 	      if test no = "$hardcode_direct"; then
  8248: 		add=$dir/$linklib
  8249: 		case $host in
  8250: 		  *-*-sco3.2v5.0.[024]*) add_dir=-L$dir ;;
  8251: 		  *-*-sysv4*uw2*) add_dir=-L$dir ;;
  8252: 		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
  8253: 		    *-*-unixware7*) add_dir=-L$dir ;;
  8254: 		  *-*-darwin* )
  8255: 		    # if the lib is a (non-dlopened) module then we cannot
  8256: 		    # link against it, someone is ignoring the earlier warnings
  8257: 		    if /usr/bin/file -L $add 2> /dev/null |
  8258: 			 $GREP ": [^:]* bundle" >/dev/null; then
  8259: 		      if test "X$dlopenmodule" != "X$lib"; then
  8260: 			$ECHO "*** Warning: lib $linklib is a module, not a shared library"
  8261: 			if test -z "$old_library"; then
  8262: 			  echo
  8263: 			  echo "*** And there doesn't seem to be a static archive available"
  8264: 			  echo "*** The link will probably fail, sorry"
  8265: 			else
  8266: 			  add=$dir/$old_library
  8267: 			fi
  8268: 		      elif test -n "$old_library"; then
  8269: 			add=$dir/$old_library
  8270: 		      fi
  8271: 		    fi
  8272: 		esac
  8273: 	      elif test no = "$hardcode_minus_L"; then
  8274: 		case $host in
  8275: 		*-*-sunos*) add_shlibpath=$dir ;;
  8276: 		esac
  8277: 		add_dir=-L$dir
  8278: 		add=-l$name
  8279: 	      elif test no = "$hardcode_shlibpath_var"; then
  8280: 		add_shlibpath=$dir
  8281: 		add=-l$name
  8282: 	      else
  8283: 		lib_linked=no
  8284: 	      fi
  8285: 	      ;;
  8286: 	    relink)
  8287: 	      if test yes = "$hardcode_direct" &&
  8288: 	         test no = "$hardcode_direct_absolute"; then
  8289: 		add=$dir/$linklib
  8290: 	      elif test yes = "$hardcode_minus_L"; then
  8291: 		add_dir=-L$absdir
  8292: 		# Try looking first in the location we're being installed to.
  8293: 		if test -n "$inst_prefix_dir"; then
  8294: 		  case $libdir in
  8295: 		    [\\/]*)
  8296: 		      func_append add_dir " -L$inst_prefix_dir$libdir"
  8297: 		      ;;
  8298: 		  esac
  8299: 		fi
  8300: 		add=-l$name
  8301: 	      elif test yes = "$hardcode_shlibpath_var"; then
  8302: 		add_shlibpath=$dir
  8303: 		add=-l$name
  8304: 	      else
  8305: 		lib_linked=no
  8306: 	      fi
  8307: 	      ;;
  8308: 	    *) lib_linked=no ;;
  8309: 	    esac
  8310: 
  8311: 	    if test yes != "$lib_linked"; then
  8312: 	      func_fatal_configuration "unsupported hardcode properties"
  8313: 	    fi
  8314: 
  8315: 	    if test -n "$add_shlibpath"; then
  8316: 	      case :$compile_shlibpath: in
  8317: 	      *":$add_shlibpath:"*) ;;
  8318: 	      *) func_append compile_shlibpath "$add_shlibpath:" ;;
  8319: 	      esac
  8320: 	    fi
  8321: 	    if test prog = "$linkmode"; then
  8322: 	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
  8323: 	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
  8324: 	    else
  8325: 	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
  8326: 	      test -n "$add" && deplibs="$add $deplibs"
  8327: 	      if test yes != "$hardcode_direct" &&
  8328: 		 test yes != "$hardcode_minus_L" &&
  8329: 		 test yes = "$hardcode_shlibpath_var"; then
  8330: 		case :$finalize_shlibpath: in
  8331: 		*":$libdir:"*) ;;
  8332: 		*) func_append finalize_shlibpath "$libdir:" ;;
  8333: 		esac
  8334: 	      fi
  8335: 	    fi
  8336: 	  fi
  8337: 
  8338: 	  if test prog = "$linkmode" || test relink = "$opt_mode"; then
  8339: 	    add_shlibpath=
  8340: 	    add_dir=
  8341: 	    add=
  8342: 	    # Finalize command for both is simple: just hardcode it.
  8343: 	    if test yes = "$hardcode_direct" &&
  8344: 	       test no = "$hardcode_direct_absolute"; then
  8345: 	      add=$libdir/$linklib
  8346: 	    elif test yes = "$hardcode_minus_L"; then
  8347: 	      add_dir=-L$libdir
  8348: 	      add=-l$name
  8349: 	    elif test yes = "$hardcode_shlibpath_var"; then
  8350: 	      case :$finalize_shlibpath: in
  8351: 	      *":$libdir:"*) ;;
  8352: 	      *) func_append finalize_shlibpath "$libdir:" ;;
  8353: 	      esac
  8354: 	      add=-l$name
  8355: 	    elif test yes = "$hardcode_automatic"; then
  8356: 	      if test -n "$inst_prefix_dir" &&
  8357: 		 test -f "$inst_prefix_dir$libdir/$linklib"; then
  8358: 		add=$inst_prefix_dir$libdir/$linklib
  8359: 	      else
  8360: 		add=$libdir/$linklib
  8361: 	      fi
  8362: 	    else
  8363: 	      # We cannot seem to hardcode it, guess we'll fake it.
  8364: 	      add_dir=-L$libdir
  8365: 	      # Try looking first in the location we're being installed to.
  8366: 	      if test -n "$inst_prefix_dir"; then
  8367: 		case $libdir in
  8368: 		  [\\/]*)
  8369: 		    func_append add_dir " -L$inst_prefix_dir$libdir"
  8370: 		    ;;
  8371: 		esac
  8372: 	      fi
  8373: 	      add=-l$name
  8374: 	    fi
  8375: 
  8376: 	    if test prog = "$linkmode"; then
  8377: 	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
  8378: 	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
  8379: 	    else
  8380: 	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
  8381: 	      test -n "$add" && deplibs="$add $deplibs"
  8382: 	    fi
  8383: 	  fi
  8384: 	elif test prog = "$linkmode"; then
  8385: 	  # Here we assume that one of hardcode_direct or hardcode_minus_L
  8386: 	  # is not unsupported.  This is valid on all known static and
  8387: 	  # shared platforms.
  8388: 	  if test unsupported != "$hardcode_direct"; then
  8389: 	    test -n "$old_library" && linklib=$old_library
  8390: 	    compile_deplibs="$dir/$linklib $compile_deplibs"
  8391: 	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
  8392: 	  else
  8393: 	    compile_deplibs="-l$name -L$dir $compile_deplibs"
  8394: 	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
  8395: 	  fi
  8396: 	elif test yes = "$build_libtool_libs"; then
  8397: 	  # Not a shared library
  8398: 	  if test pass_all != "$deplibs_check_method"; then
  8399: 	    # We're trying link a shared library against a static one
  8400: 	    # but the system doesn't support it.
  8401: 
  8402: 	    # Just print a warning and add the library to dependency_libs so
  8403: 	    # that the program can be linked against the static library.
  8404: 	    echo
  8405: 	    $ECHO "*** Warning: This system cannot link to static lib archive $lib."
  8406: 	    echo "*** I have the capability to make that library automatically link in when"
  8407: 	    echo "*** you link to this library.  But I can only do this if you have a"
  8408: 	    echo "*** shared version of the library, which you do not appear to have."
  8409: 	    if test yes = "$module"; then
  8410: 	      echo "*** But as you try to build a module library, libtool will still create "
  8411: 	      echo "*** a static module, that should work as long as the dlopening application"
  8412: 	      echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
  8413: 	      if test -z "$global_symbol_pipe"; then
  8414: 		echo
  8415: 		echo "*** However, this would only work if libtool was able to extract symbol"
  8416: 		echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
  8417: 		echo "*** not find such a program.  So, this module is probably useless."
  8418: 		echo "*** 'nm' from GNU binutils and a full rebuild may help."
  8419: 	      fi
  8420: 	      if test no = "$build_old_libs"; then
  8421: 		build_libtool_libs=module
  8422: 		build_old_libs=yes
  8423: 	      else
  8424: 		build_libtool_libs=no
  8425: 	      fi
  8426: 	    fi
  8427: 	  else
  8428: 	    deplibs="$dir/$old_library $deplibs"
  8429: 	    link_static=yes
  8430: 	  fi
  8431: 	fi # link shared/static library?
  8432: 
  8433: 	if test lib = "$linkmode"; then
  8434: 	  if test -n "$dependency_libs" &&
  8435: 	     { test yes != "$hardcode_into_libs" ||
  8436: 	       test yes = "$build_old_libs" ||
  8437: 	       test yes = "$link_static"; }; then
  8438: 	    # Extract -R from dependency_libs
  8439: 	    temp_deplibs=
  8440: 	    for libdir in $dependency_libs; do
  8441: 	      case $libdir in
  8442: 	      -R*) func_stripname '-R' '' "$libdir"
  8443: 	           temp_xrpath=$func_stripname_result
  8444: 		   case " $xrpath " in
  8445: 		   *" $temp_xrpath "*) ;;
  8446: 		   *) func_append xrpath " $temp_xrpath";;
  8447: 		   esac;;
  8448: 	      *) func_append temp_deplibs " $libdir";;
  8449: 	      esac
  8450: 	    done
  8451: 	    dependency_libs=$temp_deplibs
  8452: 	  fi
  8453: 
  8454: 	  func_append newlib_search_path " $absdir"
  8455: 	  # Link against this library
  8456: 	  test no = "$link_static" && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
  8457: 	  # ... and its dependency_libs
  8458: 	  tmp_libs=
  8459: 	  for deplib in $dependency_libs; do
  8460: 	    newdependency_libs="$deplib $newdependency_libs"
  8461: 	    case $deplib in
  8462:               -L*) func_stripname '-L' '' "$deplib"
  8463:                    func_resolve_sysroot "$func_stripname_result";;
  8464:               *) func_resolve_sysroot "$deplib" ;;
  8465:             esac
  8466: 	    if $opt_preserve_dup_deps; then
  8467: 	      case "$tmp_libs " in
  8468: 	      *" $func_resolve_sysroot_result "*)
  8469:                 func_append specialdeplibs " $func_resolve_sysroot_result" ;;
  8470: 	      esac
  8471: 	    fi
  8472: 	    func_append tmp_libs " $func_resolve_sysroot_result"
  8473: 	  done
  8474: 
  8475: 	  if test no != "$link_all_deplibs"; then
  8476: 	    # Add the search paths of all dependency libraries
  8477: 	    for deplib in $dependency_libs; do
  8478: 	      path=
  8479: 	      case $deplib in
  8480: 	      -L*) path=$deplib ;;
  8481: 	      *.la)
  8482: 	        func_resolve_sysroot "$deplib"
  8483: 	        deplib=$func_resolve_sysroot_result
  8484: 	        func_dirname "$deplib" "" "."
  8485: 		dir=$func_dirname_result
  8486: 		# We need an absolute path.
  8487: 		case $dir in
  8488: 		[\\/]* | [A-Za-z]:[\\/]*) absdir=$dir ;;
  8489: 		*)
  8490: 		  absdir=`cd "$dir" && pwd`
  8491: 		  if test -z "$absdir"; then
  8492: 		    func_warning "cannot determine absolute directory name of '$dir'"
  8493: 		    absdir=$dir
  8494: 		  fi
  8495: 		  ;;
  8496: 		esac
  8497: 		if $GREP "^installed=no" $deplib > /dev/null; then
  8498: 		case $host in
  8499: 		*-*-darwin*)
  8500: 		  depdepl=
  8501: 		  eval deplibrary_names=`$SED -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
  8502: 		  if test -n "$deplibrary_names"; then
  8503: 		    for tmp in $deplibrary_names; do
  8504: 		      depdepl=$tmp
  8505: 		    done
  8506: 		    if test -f "$absdir/$objdir/$depdepl"; then
  8507: 		      depdepl=$absdir/$objdir/$depdepl
  8508: 		      darwin_install_name=`$OTOOL -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
  8509:                       if test -z "$darwin_install_name"; then
  8510:                           darwin_install_name=`$OTOOL64 -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
  8511:                       fi
  8512: 		      func_append compiler_flags " $wl-dylib_file $wl$darwin_install_name:$depdepl"
  8513: 		      func_append linker_flags " -dylib_file $darwin_install_name:$depdepl"
  8514: 		      path=
  8515: 		    fi
  8516: 		  fi
  8517: 		  ;;
  8518: 		*)
  8519: 		  path=-L$absdir/$objdir
  8520: 		  ;;
  8521: 		esac
  8522: 		else
  8523: 		  eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
  8524: 		  test -z "$libdir" && \
  8525: 		    func_fatal_error "'$deplib' is not a valid libtool archive"
  8526: 		  test "$absdir" != "$libdir" && \
  8527: 		    func_warning "'$deplib' seems to be moved"
  8528: 
  8529: 		  path=-L$absdir
  8530: 		fi
  8531: 		;;
  8532: 	      esac
  8533: 	      case " $deplibs " in
  8534: 	      *" $path "*) ;;
  8535: 	      *) deplibs="$path $deplibs" ;;
  8536: 	      esac
  8537: 	    done
  8538: 	  fi # link_all_deplibs != no
  8539: 	fi # linkmode = lib
  8540:       done # for deplib in $libs
  8541:       if test link = "$pass"; then
  8542: 	if test prog = "$linkmode"; then
  8543: 	  compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
  8544: 	  finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
  8545: 	else
  8546: 	  compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
  8547: 	fi
  8548:       fi
  8549:       dependency_libs=$newdependency_libs
  8550:       if test dlpreopen = "$pass"; then
  8551: 	# Link the dlpreopened libraries before other libraries
  8552: 	for deplib in $save_deplibs; do
  8553: 	  deplibs="$deplib $deplibs"
  8554: 	done
  8555:       fi
  8556:       if test dlopen != "$pass"; then
  8557: 	test conv = "$pass" || {
  8558: 	  # Make sure lib_search_path contains only unique directories.
  8559: 	  lib_search_path=
  8560: 	  for dir in $newlib_search_path; do
  8561: 	    case "$lib_search_path " in
  8562: 	    *" $dir "*) ;;
  8563: 	    *) func_append lib_search_path " $dir" ;;
  8564: 	    esac
  8565: 	  done
  8566: 	  newlib_search_path=
  8567: 	}
  8568: 
  8569: 	if test prog,link = "$linkmode,$pass"; then
  8570: 	  vars="compile_deplibs finalize_deplibs"
  8571: 	else
  8572: 	  vars=deplibs
  8573: 	fi
  8574: 	for var in $vars dependency_libs; do
  8575: 	  # Add libraries to $var in reverse order
  8576: 	  eval tmp_libs=\"\$$var\"
  8577: 	  new_libs=
  8578: 	  for deplib in $tmp_libs; do
  8579: 	    # FIXME: Pedantically, this is the right thing to do, so
  8580: 	    #        that some nasty dependency loop isn't accidentally
  8581: 	    #        broken:
  8582: 	    #new_libs="$deplib $new_libs"
  8583: 	    # Pragmatically, this seems to cause very few problems in
  8584: 	    # practice:
  8585: 	    case $deplib in
  8586: 	    -L*) new_libs="$deplib $new_libs" ;;
  8587: 	    -R*) ;;
  8588: 	    *)
  8589: 	      # And here is the reason: when a library appears more
  8590: 	      # than once as an explicit dependence of a library, or
  8591: 	      # is implicitly linked in more than once by the
  8592: 	      # compiler, it is considered special, and multiple
  8593: 	      # occurrences thereof are not removed.  Compare this
  8594: 	      # with having the same library being listed as a
  8595: 	      # dependency of multiple other libraries: in this case,
  8596: 	      # we know (pedantically, we assume) the library does not
  8597: 	      # need to be listed more than once, so we keep only the
  8598: 	      # last copy.  This is not always right, but it is rare
  8599: 	      # enough that we require users that really mean to play
  8600: 	      # such unportable linking tricks to link the library
  8601: 	      # using -Wl,-lname, so that libtool does not consider it
  8602: 	      # for duplicate removal.
  8603: 	      case " $specialdeplibs " in
  8604: 	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
  8605: 	      *)
  8606: 		case " $new_libs " in
  8607: 		*" $deplib "*) ;;
  8608: 		*) new_libs="$deplib $new_libs" ;;
  8609: 		esac
  8610: 		;;
  8611: 	      esac
  8612: 	      ;;
  8613: 	    esac
  8614: 	  done
  8615: 	  tmp_libs=
  8616: 	  for deplib in $new_libs; do
  8617: 	    case $deplib in
  8618: 	    -L*)
  8619: 	      case " $tmp_libs " in
  8620: 	      *" $deplib "*) ;;
  8621: 	      *) func_append tmp_libs " $deplib" ;;
  8622: 	      esac
  8623: 	      ;;
  8624: 	    *) func_append tmp_libs " $deplib" ;;
  8625: 	    esac
  8626: 	  done
  8627: 	  eval $var=\"$tmp_libs\"
  8628: 	done # for var
  8629:       fi
  8630: 
  8631:       # Add Sun CC postdeps if required:
  8632:       test CXX = "$tagname" && {
  8633:         case $host_os in
  8634:         linux*)
  8635:           case `$CC -V 2>&1 | sed 5q` in
  8636:           *Sun\ C*) # Sun C++ 5.9
  8637:             func_suncc_cstd_abi
  8638: 
  8639:             if test no != "$suncc_use_cstd_abi"; then
  8640:               func_append postdeps ' -library=Cstd -library=Crun'
  8641:             fi
  8642:             ;;
  8643:           esac
  8644:           ;;
  8645: 
  8646:         solaris*)
  8647:           func_cc_basename "$CC"
  8648:           case $func_cc_basename_result in
  8649:           CC* | sunCC*)
  8650:             func_suncc_cstd_abi
  8651: 
  8652:             if test no != "$suncc_use_cstd_abi"; then
  8653:               func_append postdeps ' -library=Cstd -library=Crun'
  8654:             fi
  8655:             ;;
  8656:           esac
  8657:           ;;
  8658:         esac
  8659:       }
  8660: 
  8661:       # Last step: remove runtime libs from dependency_libs
  8662:       # (they stay in deplibs)
  8663:       tmp_libs=
  8664:       for i in $dependency_libs; do
  8665: 	case " $predeps $postdeps $compiler_lib_search_path " in
  8666: 	*" $i "*)
  8667: 	  i=
  8668: 	  ;;
  8669: 	esac
  8670: 	if test -n "$i"; then
  8671: 	  func_append tmp_libs " $i"
  8672: 	fi
  8673:       done
  8674:       dependency_libs=$tmp_libs
  8675:     done # for pass
  8676:     if test prog = "$linkmode"; then
  8677:       dlfiles=$newdlfiles
  8678:     fi
  8679:     if test prog = "$linkmode" || test lib = "$linkmode"; then
  8680:       dlprefiles=$newdlprefiles
  8681:     fi
  8682: 
  8683:     case $linkmode in
  8684:     oldlib)
  8685:       if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
  8686: 	func_warning "'-dlopen' is ignored for archives"
  8687:       fi
  8688: 
  8689:       case " $deplibs" in
  8690:       *\ -l* | *\ -L*)
  8691: 	func_warning "'-l' and '-L' are ignored for archives" ;;
  8692:       esac
  8693: 
  8694:       test -n "$rpath" && \
  8695: 	func_warning "'-rpath' is ignored for archives"
  8696: 
  8697:       test -n "$xrpath" && \
  8698: 	func_warning "'-R' is ignored for archives"
  8699: 
  8700:       test -n "$vinfo" && \
  8701: 	func_warning "'-version-info/-version-number' is ignored for archives"
  8702: 
  8703:       test -n "$release" && \
  8704: 	func_warning "'-release' is ignored for archives"
  8705: 
  8706:       test -n "$export_symbols$export_symbols_regex" && \
  8707: 	func_warning "'-export-symbols' is ignored for archives"
  8708: 
  8709:       # Now set the variables for building old libraries.
  8710:       build_libtool_libs=no
  8711:       oldlibs=$output
  8712:       func_append objs "$old_deplibs"
  8713:       ;;
  8714: 
  8715:     lib)
  8716:       # Make sure we only generate libraries of the form 'libNAME.la'.
  8717:       case $outputname in
  8718:       lib*)
  8719: 	func_stripname 'lib' '.la' "$outputname"
  8720: 	name=$func_stripname_result
  8721: 	eval shared_ext=\"$shrext_cmds\"
  8722: 	eval libname=\"$libname_spec\"
  8723: 	;;
  8724:       *)
  8725: 	test no = "$module" \
  8726: 	  && func_fatal_help "libtool library '$output' must begin with 'lib'"
  8727: 
  8728: 	if test no != "$need_lib_prefix"; then
  8729: 	  # Add the "lib" prefix for modules if required
  8730: 	  func_stripname '' '.la' "$outputname"
  8731: 	  name=$func_stripname_result
  8732: 	  eval shared_ext=\"$shrext_cmds\"
  8733: 	  eval libname=\"$libname_spec\"
  8734: 	else
  8735: 	  func_stripname '' '.la' "$outputname"
  8736: 	  libname=$func_stripname_result
  8737: 	fi
  8738: 	;;
  8739:       esac
  8740: 
  8741:       if test -n "$objs"; then
  8742: 	if test pass_all != "$deplibs_check_method"; then
  8743: 	  func_fatal_error "cannot build libtool library '$output' from non-libtool objects on this host:$objs"
  8744: 	else
  8745: 	  echo
  8746: 	  $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
  8747: 	  $ECHO "*** objects $objs is not portable!"
  8748: 	  func_append libobjs " $objs"
  8749: 	fi
  8750:       fi
  8751: 
  8752:       test no = "$dlself" \
  8753: 	|| func_warning "'-dlopen self' is ignored for libtool libraries"
  8754: 
  8755:       set dummy $rpath
  8756:       shift
  8757:       test 1 -lt "$#" \
  8758: 	&& func_warning "ignoring multiple '-rpath's for a libtool library"
  8759: 
  8760:       install_libdir=$1
  8761: 
  8762:       oldlibs=
  8763:       if test -z "$rpath"; then
  8764: 	if test yes = "$build_libtool_libs"; then
  8765: 	  # Building a libtool convenience library.
  8766: 	  # Some compilers have problems with a '.al' extension so
  8767: 	  # convenience libraries should have the same extension an
  8768: 	  # archive normally would.
  8769: 	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
  8770: 	  build_libtool_libs=convenience
  8771: 	  build_old_libs=yes
  8772: 	fi
  8773: 
  8774: 	test -n "$vinfo" && \
  8775: 	  func_warning "'-version-info/-version-number' is ignored for convenience libraries"
  8776: 
  8777: 	test -n "$release" && \
  8778: 	  func_warning "'-release' is ignored for convenience libraries"
  8779:       else
  8780: 
  8781: 	# Parse the version information argument.
  8782: 	save_ifs=$IFS; IFS=:
  8783: 	set dummy $vinfo 0 0 0
  8784: 	shift
  8785: 	IFS=$save_ifs
  8786: 
  8787: 	test -n "$7" && \
  8788: 	  func_fatal_help "too many parameters to '-version-info'"
  8789: 
  8790: 	# convert absolute version numbers to libtool ages
  8791: 	# this retains compatibility with .la files and attempts
  8792: 	# to make the code below a bit more comprehensible
  8793: 
  8794: 	case $vinfo_number in
  8795: 	yes)
  8796: 	  number_major=$1
  8797: 	  number_minor=$2
  8798: 	  number_revision=$3
  8799: 	  #
  8800: 	  # There are really only two kinds -- those that
  8801: 	  # use the current revision as the major version
  8802: 	  # and those that subtract age and use age as
  8803: 	  # a minor version.  But, then there is irix
  8804: 	  # that has an extra 1 added just for fun
  8805: 	  #
  8806: 	  case $version_type in
  8807: 	  # correct linux to gnu/linux during the next big refactor
  8808: 	  darwin|freebsd-elf|linux|osf|windows|none)
  8809: 	    func_arith $number_major + $number_minor
  8810: 	    current=$func_arith_result
  8811: 	    age=$number_minor
  8812: 	    revision=$number_revision
  8813: 	    ;;
  8814: 	  freebsd-aout|qnx|sunos)
  8815: 	    current=$number_major
  8816: 	    revision=$number_minor
  8817: 	    age=0
  8818: 	    ;;
  8819: 	  irix|nonstopux)
  8820: 	    func_arith $number_major + $number_minor
  8821: 	    current=$func_arith_result
  8822: 	    age=$number_minor
  8823: 	    revision=$number_minor
  8824: 	    lt_irix_increment=no
  8825: 	    ;;
  8826: 	  esac
  8827: 	  ;;
  8828: 	no)
  8829: 	  current=$1
  8830: 	  revision=$2
  8831: 	  age=$3
  8832: 	  ;;
  8833: 	esac
  8834: 
  8835: 	# Check that each of the things are valid numbers.
  8836: 	case $current in
  8837: 	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]) ;;
  8838: 	*)
  8839: 	  func_error "CURRENT '$current' must be a nonnegative integer"
  8840: 	  func_fatal_error "'$vinfo' is not valid version information"
  8841: 	  ;;
  8842: 	esac
  8843: 
  8844: 	case $revision in
  8845: 	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]) ;;
  8846: 	*)
  8847: 	  func_error "REVISION '$revision' must be a nonnegative integer"
  8848: 	  func_fatal_error "'$vinfo' is not valid version information"
  8849: 	  ;;
  8850: 	esac
  8851: 
  8852: 	case $age in
  8853: 	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]) ;;
  8854: 	*)
  8855: 	  func_error "AGE '$age' must be a nonnegative integer"
  8856: 	  func_fatal_error "'$vinfo' is not valid version information"
  8857: 	  ;;
  8858: 	esac
  8859: 
  8860: 	if test "$age" -gt "$current"; then
  8861: 	  func_error "AGE '$age' is greater than the current interface number '$current'"
  8862: 	  func_fatal_error "'$vinfo' is not valid version information"
  8863: 	fi
  8864: 
  8865: 	# Calculate the version variables.
  8866: 	major=
  8867: 	versuffix=
  8868: 	verstring=
  8869: 	case $version_type in
  8870: 	none) ;;
  8871: 
  8872: 	darwin)
  8873: 	  # Like Linux, but with the current version available in
  8874: 	  # verstring for coding it into the library header
  8875: 	  func_arith $current - $age
  8876: 	  major=.$func_arith_result
  8877: 	  versuffix=$major.$age.$revision
  8878: 	  # Darwin ld doesn't like 0 for these options...
  8879: 	  func_arith $current + 1
  8880: 	  minor_current=$func_arith_result
  8881: 	  xlcverstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
  8882: 	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
  8883:           # On Darwin other compilers
  8884:           case $CC in
  8885:               nagfor*)
  8886:                   verstring="$wl-compatibility_version $wl$minor_current $wl-current_version $wl$minor_current.$revision"
  8887:                   ;;
  8888:               *)
  8889:                   verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
  8890:                   ;;
  8891:           esac
  8892: 	  ;;
  8893: 
  8894: 	freebsd-aout)
  8895: 	  major=.$current
  8896: 	  versuffix=.$current.$revision
  8897: 	  ;;
  8898: 
  8899: 	freebsd-elf)
  8900: 	  func_arith $current - $age
  8901: 	  major=.$func_arith_result
  8902: 	  versuffix=$major.$age.$revision
  8903: 	  ;;
  8904: 
  8905: 	irix | nonstopux)
  8906: 	  if test no = "$lt_irix_increment"; then
  8907: 	    func_arith $current - $age
  8908: 	  else
  8909: 	    func_arith $current - $age + 1
  8910: 	  fi
  8911: 	  major=$func_arith_result
  8912: 
  8913: 	  case $version_type in
  8914: 	    nonstopux) verstring_prefix=nonstopux ;;
  8915: 	    *)         verstring_prefix=sgi ;;
  8916: 	  esac
  8917: 	  verstring=$verstring_prefix$major.$revision
  8918: 
  8919: 	  # Add in all the interfaces that we are compatible with.
  8920: 	  loop=$revision
  8921: 	  while test 0 -ne "$loop"; do
  8922: 	    func_arith $revision - $loop
  8923: 	    iface=$func_arith_result
  8924: 	    func_arith $loop - 1
  8925: 	    loop=$func_arith_result
  8926: 	    verstring=$verstring_prefix$major.$iface:$verstring
  8927: 	  done
  8928: 
  8929: 	  # Before this point, $major must not contain '.'.
  8930: 	  major=.$major
  8931: 	  versuffix=$major.$revision
  8932: 	  ;;
  8933: 
  8934: 	linux) # correct to gnu/linux during the next big refactor
  8935: 	  func_arith $current - $age
  8936: 	  major=.$func_arith_result
  8937: 	  versuffix=$major.$age.$revision
  8938: 	  ;;
  8939: 
  8940: 	osf)
  8941: 	  func_arith $current - $age
  8942: 	  major=.$func_arith_result
  8943: 	  versuffix=.$current.$age.$revision
  8944: 	  verstring=$current.$age.$revision
  8945: 
  8946: 	  # Add in all the interfaces that we are compatible with.
  8947: 	  loop=$age
  8948: 	  while test 0 -ne "$loop"; do
  8949: 	    func_arith $current - $loop
  8950: 	    iface=$func_arith_result
  8951: 	    func_arith $loop - 1
  8952: 	    loop=$func_arith_result
  8953: 	    verstring=$verstring:$iface.0
  8954: 	  done
  8955: 
  8956: 	  # Make executables depend on our current version.
  8957: 	  func_append verstring ":$current.0"
  8958: 	  ;;
  8959: 
  8960: 	qnx)
  8961: 	  major=.$current
  8962: 	  versuffix=.$current
  8963: 	  ;;
  8964: 
  8965: 	sco)
  8966: 	  major=.$current
  8967: 	  versuffix=.$current
  8968: 	  ;;
  8969: 
  8970: 	sunos)
  8971: 	  major=.$current
  8972: 	  versuffix=.$current.$revision
  8973: 	  ;;
  8974: 
  8975: 	windows)
  8976: 	  # Use '-' rather than '.', since we only want one
  8977: 	  # extension on DOS 8.3 file systems.
  8978: 	  func_arith $current - $age
  8979: 	  major=$func_arith_result
  8980: 	  versuffix=-$major
  8981: 	  ;;
  8982: 
  8983: 	*)
  8984: 	  func_fatal_configuration "unknown library version type '$version_type'"
  8985: 	  ;;
  8986: 	esac
  8987: 
  8988: 	# Clear the version info if we defaulted, and they specified a release.
  8989: 	if test -z "$vinfo" && test -n "$release"; then
  8990: 	  major=
  8991: 	  case $version_type in
  8992: 	  darwin)
  8993: 	    # we can't check for "0.0" in archive_cmds due to quoting
  8994: 	    # problems, so we reset it completely
  8995: 	    verstring=
  8996: 	    ;;
  8997: 	  *)
  8998: 	    verstring=0.0
  8999: 	    ;;
  9000: 	  esac
  9001: 	  if test no = "$need_version"; then
  9002: 	    versuffix=
  9003: 	  else
  9004: 	    versuffix=.0.0
  9005: 	  fi
  9006: 	fi
  9007: 
  9008: 	# Remove version info from name if versioning should be avoided
  9009: 	if test yes,no = "$avoid_version,$need_version"; then
  9010: 	  major=
  9011: 	  versuffix=
  9012: 	  verstring=
  9013: 	fi
  9014: 
  9015: 	# Check to see if the archive will have undefined symbols.
  9016: 	if test yes = "$allow_undefined"; then
  9017: 	  if test unsupported = "$allow_undefined_flag"; then
  9018: 	    if test yes = "$build_old_libs"; then
  9019: 	      func_warning "undefined symbols not allowed in $host shared libraries; building static only"
  9020: 	      build_libtool_libs=no
  9021: 	    else
  9022: 	      func_fatal_error "can't build $host shared library unless -no-undefined is specified"
  9023: 	    fi
  9024: 	  fi
  9025: 	else
  9026: 	  # Don't allow undefined symbols.
  9027: 	  allow_undefined_flag=$no_undefined_flag
  9028: 	fi
  9029: 
  9030:       fi
  9031: 
  9032:       func_generate_dlsyms "$libname" "$libname" :
  9033:       func_append libobjs " $symfileobj"
  9034:       test " " = "$libobjs" && libobjs=
  9035: 
  9036:       if test relink != "$opt_mode"; then
  9037: 	# Remove our outputs, but don't remove object files since they
  9038: 	# may have been created when compiling PIC objects.
  9039: 	removelist=
  9040: 	tempremovelist=`$ECHO "$output_objdir/*"`
  9041: 	for p in $tempremovelist; do
  9042: 	  case $p in
  9043: 	    *.$objext | *.gcno)
  9044: 	       ;;
  9045: 	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/$libname$release.*)
  9046: 	       if test -n "$precious_files_regex"; then
  9047: 		 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
  9048: 		 then
  9049: 		   continue
  9050: 		 fi
  9051: 	       fi
  9052: 	       func_append removelist " $p"
  9053: 	       ;;
  9054: 	    *) ;;
  9055: 	  esac
  9056: 	done
  9057: 	test -n "$removelist" && \
  9058: 	  func_show_eval "${RM}r \$removelist"
  9059:       fi
  9060: 
  9061:       # Now set the variables for building old libraries.
  9062:       if test yes = "$build_old_libs" && test convenience != "$build_libtool_libs"; then
  9063: 	func_append oldlibs " $output_objdir/$libname.$libext"
  9064: 
  9065: 	# Transform .lo files to .o files.
  9066: 	oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; $lo2o" | $NL2SP`
  9067:       fi
  9068: 
  9069:       # Eliminate all temporary directories.
  9070:       #for path in $notinst_path; do
  9071:       #	lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
  9072:       #	deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
  9073:       #	dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
  9074:       #done
  9075: 
  9076:       if test -n "$xrpath"; then
  9077: 	# If the user specified any rpath flags, then add them.
  9078: 	temp_xrpath=
  9079: 	for libdir in $xrpath; do
  9080: 	  func_replace_sysroot "$libdir"
  9081: 	  func_append temp_xrpath " -R$func_replace_sysroot_result"
  9082: 	  case "$finalize_rpath " in
  9083: 	  *" $libdir "*) ;;
  9084: 	  *) func_append finalize_rpath " $libdir" ;;
  9085: 	  esac
  9086: 	done
  9087: 	if test yes != "$hardcode_into_libs" || test yes = "$build_old_libs"; then
  9088: 	  dependency_libs="$temp_xrpath $dependency_libs"
  9089: 	fi
  9090:       fi
  9091: 
  9092:       # Make sure dlfiles contains only unique files that won't be dlpreopened
  9093:       old_dlfiles=$dlfiles
  9094:       dlfiles=
  9095:       for lib in $old_dlfiles; do
  9096: 	case " $dlprefiles $dlfiles " in
  9097: 	*" $lib "*) ;;
  9098: 	*) func_append dlfiles " $lib" ;;
  9099: 	esac
  9100:       done
  9101: 
  9102:       # Make sure dlprefiles contains only unique files
  9103:       old_dlprefiles=$dlprefiles
  9104:       dlprefiles=
  9105:       for lib in $old_dlprefiles; do
  9106: 	case "$dlprefiles " in
  9107: 	*" $lib "*) ;;
  9108: 	*) func_append dlprefiles " $lib" ;;
  9109: 	esac
  9110:       done
  9111: 
  9112:       if test yes = "$build_libtool_libs"; then
  9113: 	if test -n "$rpath"; then
  9114: 	  case $host in
  9115: 	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
  9116: 	    # these systems don't actually have a c library (as such)!
  9117: 	    ;;
  9118: 	  *-*-rhapsody* | *-*-darwin1.[012])
  9119: 	    # Rhapsody C library is in the System framework
  9120: 	    func_append deplibs " System.ltframework"
  9121: 	    ;;
  9122: 	  *-*-netbsd*)
  9123: 	    # Don't link with libc until the a.out ld.so is fixed.
  9124: 	    ;;
  9125: 	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
  9126: 	    # Do not include libc due to us having libc/libc_r.
  9127: 	    ;;
  9128: 	  *-*-sco3.2v5* | *-*-sco5v6*)
  9129: 	    # Causes problems with __ctype
  9130: 	    ;;
  9131: 	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
  9132: 	    # Compiler inserts libc in the correct place for threads to work
  9133: 	    ;;
  9134: 	  *)
  9135: 	    # Add libc to deplibs on all other systems if necessary.
  9136: 	    if test yes = "$build_libtool_need_lc"; then
  9137: 	      func_append deplibs " -lc"
  9138: 	    fi
  9139: 	    ;;
  9140: 	  esac
  9141: 	fi
  9142: 
  9143: 	# Transform deplibs into only deplibs that can be linked in shared.
  9144: 	name_save=$name
  9145: 	libname_save=$libname
  9146: 	release_save=$release
  9147: 	versuffix_save=$versuffix
  9148: 	major_save=$major
  9149: 	# I'm not sure if I'm treating the release correctly.  I think
  9150: 	# release should show up in the -l (ie -lgmp5) so we don't want to
  9151: 	# add it in twice.  Is that correct?
  9152: 	release=
  9153: 	versuffix=
  9154: 	major=
  9155: 	newdeplibs=
  9156: 	droppeddeps=no
  9157: 	case $deplibs_check_method in
  9158: 	pass_all)
  9159: 	  # Don't check for shared/static.  Everything works.
  9160: 	  # This might be a little naive.  We might want to check
  9161: 	  # whether the library exists or not.  But this is on
  9162: 	  # osf3 & osf4 and I'm not really sure... Just
  9163: 	  # implementing what was already the behavior.
  9164: 	  newdeplibs=$deplibs
  9165: 	  ;;
  9166: 	test_compile)
  9167: 	  # This code stresses the "libraries are programs" paradigm to its
  9168: 	  # limits. Maybe even breaks it.  We compile a program, linking it
  9169: 	  # against the deplibs as a proxy for the library.  Then we can check
  9170: 	  # whether they linked in statically or dynamically with ldd.
  9171: 	  $opt_dry_run || $RM conftest.c
  9172: 	  cat > conftest.c <<EOF
  9173: 	  int main() { return 0; }
  9174: EOF
  9175: 	  $opt_dry_run || $RM conftest
  9176: 	  if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
  9177: 	    ldd_output=`ldd conftest`
  9178: 	    for i in $deplibs; do
  9179: 	      case $i in
  9180: 	      -l*)
  9181: 		func_stripname -l '' "$i"
  9182: 		name=$func_stripname_result
  9183: 		if test yes = "$allow_libtool_libs_with_static_runtimes"; then
  9184: 		  case " $predeps $postdeps " in
  9185: 		  *" $i "*)
  9186: 		    func_append newdeplibs " $i"
  9187: 		    i=
  9188: 		    ;;
  9189: 		  esac
  9190: 		fi
  9191: 		if test -n "$i"; then
  9192: 		  libname=`eval "\\$ECHO \"$libname_spec\""`
  9193: 		  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
  9194: 		  set dummy $deplib_matches; shift
  9195: 		  deplib_match=$1
  9196: 		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
  9197: 		    func_append newdeplibs " $i"
  9198: 		  else
  9199: 		    droppeddeps=yes
  9200: 		    echo
  9201: 		    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
  9202: 		    echo "*** I have the capability to make that library automatically link in when"
  9203: 		    echo "*** you link to this library.  But I can only do this if you have a"
  9204: 		    echo "*** shared version of the library, which I believe you do not have"
  9205: 		    echo "*** because a test_compile did reveal that the linker did not use it for"
  9206: 		    echo "*** its dynamic dependency list that programs get resolved with at runtime."
  9207: 		  fi
  9208: 		fi
  9209: 		;;
  9210: 	      *)
  9211: 		func_append newdeplibs " $i"
  9212: 		;;
  9213: 	      esac
  9214: 	    done
  9215: 	  else
  9216: 	    # Error occurred in the first compile.  Let's try to salvage
  9217: 	    # the situation: Compile a separate program for each library.
  9218: 	    for i in $deplibs; do
  9219: 	      case $i in
  9220: 	      -l*)
  9221: 		func_stripname -l '' "$i"
  9222: 		name=$func_stripname_result
  9223: 		$opt_dry_run || $RM conftest
  9224: 		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
  9225: 		  ldd_output=`ldd conftest`
  9226: 		  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
  9227: 		    case " $predeps $postdeps " in
  9228: 		    *" $i "*)
  9229: 		      func_append newdeplibs " $i"
  9230: 		      i=
  9231: 		      ;;
  9232: 		    esac
  9233: 		  fi
  9234: 		  if test -n "$i"; then
  9235: 		    libname=`eval "\\$ECHO \"$libname_spec\""`
  9236: 		    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
  9237: 		    set dummy $deplib_matches; shift
  9238: 		    deplib_match=$1
  9239: 		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0; then
  9240: 		      func_append newdeplibs " $i"
  9241: 		    else
  9242: 		      droppeddeps=yes
  9243: 		      echo
  9244: 		      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
  9245: 		      echo "*** I have the capability to make that library automatically link in when"
  9246: 		      echo "*** you link to this library.  But I can only do this if you have a"
  9247: 		      echo "*** shared version of the library, which you do not appear to have"
  9248: 		      echo "*** because a test_compile did reveal that the linker did not use this one"
  9249: 		      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
  9250: 		    fi
  9251: 		  fi
  9252: 		else
  9253: 		  droppeddeps=yes
  9254: 		  echo
  9255: 		  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
  9256: 		  echo "*** make it link in!  You will probably need to install it or some"
  9257: 		  echo "*** library that it depends on before this library will be fully"
  9258: 		  echo "*** functional.  Installing it before continuing would be even better."
  9259: 		fi
  9260: 		;;
  9261: 	      *)
  9262: 		func_append newdeplibs " $i"
  9263: 		;;
  9264: 	      esac
  9265: 	    done
  9266: 	  fi
  9267: 	  ;;
  9268: 	file_magic*)
  9269: 	  set dummy $deplibs_check_method; shift
  9270: 	  file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
  9271: 	  for a_deplib in $deplibs; do
  9272: 	    case $a_deplib in
  9273: 	    -l*)
  9274: 	      func_stripname -l '' "$a_deplib"
  9275: 	      name=$func_stripname_result
  9276: 	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
  9277: 		case " $predeps $postdeps " in
  9278: 		*" $a_deplib "*)
  9279: 		  func_append newdeplibs " $a_deplib"
  9280: 		  a_deplib=
  9281: 		  ;;
  9282: 		esac
  9283: 	      fi
  9284: 	      if test -n "$a_deplib"; then
  9285: 		libname=`eval "\\$ECHO \"$libname_spec\""`
  9286: 		if test -n "$file_magic_glob"; then
  9287: 		  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
  9288: 		else
  9289: 		  libnameglob=$libname
  9290: 		fi
  9291: 		test yes = "$want_nocaseglob" && nocaseglob=`shopt -p nocaseglob`
  9292: 		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
  9293: 		  if test yes = "$want_nocaseglob"; then
  9294: 		    shopt -s nocaseglob
  9295: 		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
  9296: 		    $nocaseglob
  9297: 		  else
  9298: 		    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
  9299: 		  fi
  9300: 		  for potent_lib in $potential_libs; do
  9301: 		      # Follow soft links.
  9302: 		      if ls -lLd "$potent_lib" 2>/dev/null |
  9303: 			 $GREP " -> " >/dev/null; then
  9304: 			continue
  9305: 		      fi
  9306: 		      # The statement above tries to avoid entering an
  9307: 		      # endless loop below, in case of cyclic links.
  9308: 		      # We might still enter an endless loop, since a link
  9309: 		      # loop can be closed while we follow links,
  9310: 		      # but so what?
  9311: 		      potlib=$potent_lib
  9312: 		      while test -h "$potlib" 2>/dev/null; do
  9313: 			potliblink=`ls -ld $potlib | $SED 's/.* -> //'`
  9314: 			case $potliblink in
  9315: 			[\\/]* | [A-Za-z]:[\\/]*) potlib=$potliblink;;
  9316: 			*) potlib=`$ECHO "$potlib" | $SED 's|[^/]*$||'`"$potliblink";;
  9317: 			esac
  9318: 		      done
  9319: 		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
  9320: 			 $SED -e 10q |
  9321: 			 $EGREP "$file_magic_regex" > /dev/null; then
  9322: 			func_append newdeplibs " $a_deplib"
  9323: 			a_deplib=
  9324: 			break 2
  9325: 		      fi
  9326: 		  done
  9327: 		done
  9328: 	      fi
  9329: 	      if test -n "$a_deplib"; then
  9330: 		droppeddeps=yes
  9331: 		echo
  9332: 		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
  9333: 		echo "*** I have the capability to make that library automatically link in when"
  9334: 		echo "*** you link to this library.  But I can only do this if you have a"
  9335: 		echo "*** shared version of the library, which you do not appear to have"
  9336: 		echo "*** because I did check the linker path looking for a file starting"
  9337: 		if test -z "$potlib"; then
  9338: 		  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
  9339: 		else
  9340: 		  $ECHO "*** with $libname and none of the candidates passed a file format test"
  9341: 		  $ECHO "*** using a file magic. Last file checked: $potlib"
  9342: 		fi
  9343: 	      fi
  9344: 	      ;;
  9345: 	    *)
  9346: 	      # Add a -L argument.
  9347: 	      func_append newdeplibs " $a_deplib"
  9348: 	      ;;
  9349: 	    esac
  9350: 	  done # Gone through all deplibs.
  9351: 	  ;;
  9352: 	match_pattern*)
  9353: 	  set dummy $deplibs_check_method; shift
  9354: 	  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
  9355: 	  for a_deplib in $deplibs; do
  9356: 	    case $a_deplib in
  9357: 	    -l*)
  9358: 	      func_stripname -l '' "$a_deplib"
  9359: 	      name=$func_stripname_result
  9360: 	      if test yes = "$allow_libtool_libs_with_static_runtimes"; then
  9361: 		case " $predeps $postdeps " in
  9362: 		*" $a_deplib "*)
  9363: 		  func_append newdeplibs " $a_deplib"
  9364: 		  a_deplib=
  9365: 		  ;;
  9366: 		esac
  9367: 	      fi
  9368: 	      if test -n "$a_deplib"; then
  9369: 		libname=`eval "\\$ECHO \"$libname_spec\""`
  9370: 		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
  9371: 		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
  9372: 		  for potent_lib in $potential_libs; do
  9373: 		    potlib=$potent_lib # see symlink-check above in file_magic test
  9374: 		    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
  9375: 		       $EGREP "$match_pattern_regex" > /dev/null; then
  9376: 		      func_append newdeplibs " $a_deplib"
  9377: 		      a_deplib=
  9378: 		      break 2
  9379: 		    fi
  9380: 		  done
  9381: 		done
  9382: 	      fi
  9383: 	      if test -n "$a_deplib"; then
  9384: 		droppeddeps=yes
  9385: 		echo
  9386: 		$ECHO "*** Warning: linker path does not have real file for library $a_deplib."
  9387: 		echo "*** I have the capability to make that library automatically link in when"
  9388: 		echo "*** you link to this library.  But I can only do this if you have a"
  9389: 		echo "*** shared version of the library, which you do not appear to have"
  9390: 		echo "*** because I did check the linker path looking for a file starting"
  9391: 		if test -z "$potlib"; then
  9392: 		  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
  9393: 		else
  9394: 		  $ECHO "*** with $libname and none of the candidates passed a file format test"
  9395: 		  $ECHO "*** using a regex pattern. Last file checked: $potlib"
  9396: 		fi
  9397: 	      fi
  9398: 	      ;;
  9399: 	    *)
  9400: 	      # Add a -L argument.
  9401: 	      func_append newdeplibs " $a_deplib"
  9402: 	      ;;
  9403: 	    esac
  9404: 	  done # Gone through all deplibs.
  9405: 	  ;;
  9406: 	none | unknown | *)
  9407: 	  newdeplibs=
  9408: 	  tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
  9409: 	  if test yes = "$allow_libtool_libs_with_static_runtimes"; then
  9410: 	    for i in $predeps $postdeps; do
  9411: 	      # can't use Xsed below, because $i might contain '/'
  9412: 	      tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s|$i||"`
  9413: 	    done
  9414: 	  fi
  9415: 	  case $tmp_deplibs in
  9416: 	  *[!\	\ ]*)
  9417: 	    echo
  9418: 	    if test none = "$deplibs_check_method"; then
  9419: 	      echo "*** Warning: inter-library dependencies are not supported in this platform."
  9420: 	    else
  9421: 	      echo "*** Warning: inter-library dependencies are not known to be supported."
  9422: 	    fi
  9423: 	    echo "*** All declared inter-library dependencies are being dropped."
  9424: 	    droppeddeps=yes
  9425: 	    ;;
  9426: 	  esac
  9427: 	  ;;
  9428: 	esac
  9429: 	versuffix=$versuffix_save
  9430: 	major=$major_save
  9431: 	release=$release_save
  9432: 	libname=$libname_save
  9433: 	name=$name_save
  9434: 
  9435: 	case $host in
  9436: 	*-*-rhapsody* | *-*-darwin1.[012])
  9437: 	  # On Rhapsody replace the C library with the System framework
  9438: 	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
  9439: 	  ;;
  9440: 	esac
  9441: 
  9442: 	if test yes = "$droppeddeps"; then
  9443: 	  if test yes = "$module"; then
  9444: 	    echo
  9445: 	    echo "*** Warning: libtool could not satisfy all declared inter-library"
  9446: 	    $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
  9447: 	    echo "*** a static module, that should work as long as the dlopening"
  9448: 	    echo "*** application is linked with the -dlopen flag."
  9449: 	    if test -z "$global_symbol_pipe"; then
  9450: 	      echo
  9451: 	      echo "*** However, this would only work if libtool was able to extract symbol"
  9452: 	      echo "*** lists from a program, using 'nm' or equivalent, but libtool could"
  9453: 	      echo "*** not find such a program.  So, this module is probably useless."
  9454: 	      echo "*** 'nm' from GNU binutils and a full rebuild may help."
  9455: 	    fi
  9456: 	    if test no = "$build_old_libs"; then
  9457: 	      oldlibs=$output_objdir/$libname.$libext
  9458: 	      build_libtool_libs=module
  9459: 	      build_old_libs=yes
  9460: 	    else
  9461: 	      build_libtool_libs=no
  9462: 	    fi
  9463: 	  else
  9464: 	    echo "*** The inter-library dependencies that have been dropped here will be"
  9465: 	    echo "*** automatically added whenever a program is linked with this library"
  9466: 	    echo "*** or is declared to -dlopen it."
  9467: 
  9468: 	    if test no = "$allow_undefined"; then
  9469: 	      echo
  9470: 	      echo "*** Since this library must not contain undefined symbols,"
  9471: 	      echo "*** because either the platform does not support them or"
  9472: 	      echo "*** it was explicitly requested with -no-undefined,"
  9473: 	      echo "*** libtool will only create a static version of it."
  9474: 	      if test no = "$build_old_libs"; then
  9475: 		oldlibs=$output_objdir/$libname.$libext
  9476: 		build_libtool_libs=module
  9477: 		build_old_libs=yes
  9478: 	      else
  9479: 		build_libtool_libs=no
  9480: 	      fi
  9481: 	    fi
  9482: 	  fi
  9483: 	fi
  9484: 	# Done checking deplibs!
  9485: 	deplibs=$newdeplibs
  9486:       fi
  9487:       # Time to change all our "foo.ltframework" stuff back to "-framework foo"
  9488:       case $host in
  9489: 	*-*-darwin*)
  9490: 	  newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
  9491: 	  new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
  9492: 	  deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
  9493: 	  ;;
  9494:       esac
  9495: 
  9496:       # move library search paths that coincide with paths to not yet
  9497:       # installed libraries to the beginning of the library search list
  9498:       new_libs=
  9499:       for path in $notinst_path; do
  9500: 	case " $new_libs " in
  9501: 	*" -L$path/$objdir "*) ;;
  9502: 	*)
  9503: 	  case " $deplibs " in
  9504: 	  *" -L$path/$objdir "*)
  9505: 	    func_append new_libs " -L$path/$objdir" ;;
  9506: 	  esac
  9507: 	  ;;
  9508: 	esac
  9509:       done
  9510:       for deplib in $deplibs; do
  9511: 	case $deplib in
  9512: 	-L*)
  9513: 	  case " $new_libs " in
  9514: 	  *" $deplib "*) ;;
  9515: 	  *) func_append new_libs " $deplib" ;;
  9516: 	  esac
  9517: 	  ;;
  9518: 	*) func_append new_libs " $deplib" ;;
  9519: 	esac
  9520:       done
  9521:       deplibs=$new_libs
  9522: 
  9523:       # All the library-specific variables (install_libdir is set above).
  9524:       library_names=
  9525:       old_library=
  9526:       dlname=
  9527: 
  9528:       # Test again, we may have decided not to build it any more
  9529:       if test yes = "$build_libtool_libs"; then
  9530: 	# Remove $wl instances when linking with ld.
  9531: 	# FIXME: should test the right _cmds variable.
  9532: 	case $archive_cmds in
  9533: 	  *\$LD\ *) wl= ;;
  9534:         esac
  9535: 	if test yes = "$hardcode_into_libs"; then
  9536: 	  # Hardcode the library paths
  9537: 	  hardcode_libdirs=
  9538: 	  dep_rpath=
  9539: 	  rpath=$finalize_rpath
  9540: 	  test relink = "$opt_mode" || rpath=$compile_rpath$rpath
  9541: 	  for libdir in $rpath; do
  9542: 	    if test -n "$hardcode_libdir_flag_spec"; then
  9543: 	      if test -n "$hardcode_libdir_separator"; then
  9544: 		func_replace_sysroot "$libdir"
  9545: 		libdir=$func_replace_sysroot_result
  9546: 		if test -z "$hardcode_libdirs"; then
  9547: 		  hardcode_libdirs=$libdir
  9548: 		else
  9549: 		  # Just accumulate the unique libdirs.
  9550: 		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
  9551: 		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
  9552: 		    ;;
  9553: 		  *)
  9554: 		    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
  9555: 		    ;;
  9556: 		  esac
  9557: 		fi
  9558: 	      else
  9559: 		eval flag=\"$hardcode_libdir_flag_spec\"
  9560: 		func_append dep_rpath " $flag"
  9561: 	      fi
  9562: 	    elif test -n "$runpath_var"; then
  9563: 	      case "$perm_rpath " in
  9564: 	      *" $libdir "*) ;;
  9565: 	      *) func_append perm_rpath " $libdir" ;;
  9566: 	      esac
  9567: 	    fi
  9568: 	  done
  9569: 	  # Substitute the hardcoded libdirs into the rpath.
  9570: 	  if test -n "$hardcode_libdir_separator" &&
  9571: 	     test -n "$hardcode_libdirs"; then
  9572: 	    libdir=$hardcode_libdirs
  9573: 	    eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
  9574: 	  fi
  9575: 	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
  9576: 	    # We should set the runpath_var.
  9577: 	    rpath=
  9578: 	    for dir in $perm_rpath; do
  9579: 	      func_append rpath "$dir:"
  9580: 	    done
  9581: 	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
  9582: 	  fi
  9583: 	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
  9584: 	fi
  9585: 
  9586: 	shlibpath=$finalize_shlibpath
  9587: 	test relink = "$opt_mode" || shlibpath=$compile_shlibpath$shlibpath
  9588: 	if test -n "$shlibpath"; then
  9589: 	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
  9590: 	fi
  9591: 
  9592: 	# Get the real and link names of the library.
  9593: 	eval shared_ext=\"$shrext_cmds\"
  9594: 	eval library_names=\"$library_names_spec\"
  9595: 	set dummy $library_names
  9596: 	shift
  9597: 	realname=$1
  9598: 	shift
  9599: 
  9600: 	if test -n "$soname_spec"; then
  9601: 	  eval soname=\"$soname_spec\"
  9602: 	else
  9603: 	  soname=$realname
  9604: 	fi
  9605: 	if test -z "$dlname"; then
  9606: 	  dlname=$soname
  9607: 	fi
  9608: 
  9609: 	lib=$output_objdir/$realname
  9610: 	linknames=
  9611: 	for link
  9612: 	do
  9613: 	  func_append linknames " $link"
  9614: 	done
  9615: 
  9616: 	# Use standard objects if they are pic
  9617: 	test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
  9618: 	test "X$libobjs" = "X " && libobjs=
  9619: 
  9620: 	delfiles=
  9621: 	if test -n "$export_symbols" && test -n "$include_expsyms"; then
  9622: 	  $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
  9623: 	  export_symbols=$output_objdir/$libname.uexp
  9624: 	  func_append delfiles " $export_symbols"
  9625: 	fi
  9626: 
  9627: 	orig_export_symbols=
  9628: 	case $host_os in
  9629: 	cygwin* | mingw* | cegcc*)
  9630: 	  if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
  9631: 	    # exporting using user supplied symfile
  9632: 	    func_dll_def_p "$export_symbols" || {
  9633: 	      # and it's NOT already a .def file. Must figure out
  9634: 	      # which of the given symbols are data symbols and tag
  9635: 	      # them as such. So, trigger use of export_symbols_cmds.
  9636: 	      # export_symbols gets reassigned inside the "prepare
  9637: 	      # the list of exported symbols" if statement, so the
  9638: 	      # include_expsyms logic still works.
  9639: 	      orig_export_symbols=$export_symbols
  9640: 	      export_symbols=
  9641: 	      always_export_symbols=yes
  9642: 	    }
  9643: 	  fi
  9644: 	  ;;
  9645: 	esac
  9646: 
  9647: 	# Prepare the list of exported symbols
  9648: 	if test -z "$export_symbols"; then
  9649: 	  if test yes = "$always_export_symbols" || test -n "$export_symbols_regex"; then
  9650: 	    func_verbose "generating symbol list for '$libname.la'"
  9651: 	    export_symbols=$output_objdir/$libname.exp
  9652: 	    $opt_dry_run || $RM $export_symbols
  9653: 	    cmds=$export_symbols_cmds
  9654: 	    save_ifs=$IFS; IFS='~'
  9655: 	    for cmd1 in $cmds; do
  9656: 	      IFS=$save_ifs
  9657: 	      # Take the normal branch if the nm_file_list_spec branch
  9658: 	      # doesn't work or if tool conversion is not needed.
  9659: 	      case $nm_file_list_spec~$to_tool_file_cmd in
  9660: 		*~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
  9661: 		  try_normal_branch=yes
  9662: 		  eval cmd=\"$cmd1\"
  9663: 		  func_len " $cmd"
  9664: 		  len=$func_len_result
  9665: 		  ;;
  9666: 		*)
  9667: 		  try_normal_branch=no
  9668: 		  ;;
  9669: 	      esac
  9670: 	      if test yes = "$try_normal_branch" \
  9671: 		 && { test "$len" -lt "$max_cmd_len" \
  9672: 		      || test "$max_cmd_len" -le -1; }
  9673: 	      then
  9674: 		func_show_eval "$cmd" 'exit $?'
  9675: 		skipped_export=false
  9676: 	      elif test -n "$nm_file_list_spec"; then
  9677: 		func_basename "$output"
  9678: 		output_la=$func_basename_result
  9679: 		save_libobjs=$libobjs
  9680: 		save_output=$output
  9681: 		output=$output_objdir/$output_la.nm
  9682: 		func_to_tool_file "$output"
  9683: 		libobjs=$nm_file_list_spec$func_to_tool_file_result
  9684: 		func_append delfiles " $output"
  9685: 		func_verbose "creating $NM input file list: $output"
  9686: 		for obj in $save_libobjs; do
  9687: 		  func_to_tool_file "$obj"
  9688: 		  $ECHO "$func_to_tool_file_result"
  9689: 		done > "$output"
  9690: 		eval cmd=\"$cmd1\"
  9691: 		func_show_eval "$cmd" 'exit $?'
  9692: 		output=$save_output
  9693: 		libobjs=$save_libobjs
  9694: 		skipped_export=false
  9695: 	      else
  9696: 		# The command line is too long to execute in one step.
  9697: 		func_verbose "using reloadable object file for export list..."
  9698: 		skipped_export=:
  9699: 		# Break out early, otherwise skipped_export may be
  9700: 		# set to false by a later but shorter cmd.
  9701: 		break
  9702: 	      fi
  9703: 	    done
  9704: 	    IFS=$save_ifs
  9705: 	    if test -n "$export_symbols_regex" && test : != "$skipped_export"; then
  9706: 	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
  9707: 	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
  9708: 	    fi
  9709: 	  fi
  9710: 	fi
  9711: 
  9712: 	if test -n "$export_symbols" && test -n "$include_expsyms"; then
  9713: 	  tmp_export_symbols=$export_symbols
  9714: 	  test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
  9715: 	  $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
  9716: 	fi
  9717: 
  9718: 	if test : != "$skipped_export" && test -n "$orig_export_symbols"; then
  9719: 	  # The given exports_symbols file has to be filtered, so filter it.
  9720: 	  func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
  9721: 	  # FIXME: $output_objdir/$libname.filter potentially contains lots of
  9722: 	  # 's' commands, which not all seds can handle. GNU sed should be fine
  9723: 	  # though. Also, the filter scales superlinearly with the number of
  9724: 	  # global variables. join(1) would be nice here, but unfortunately
  9725: 	  # isn't a blessed tool.
  9726: 	  $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
  9727: 	  func_append delfiles " $export_symbols $output_objdir/$libname.filter"
  9728: 	  export_symbols=$output_objdir/$libname.def
  9729: 	  $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
  9730: 	fi
  9731: 
  9732: 	tmp_deplibs=
  9733: 	for test_deplib in $deplibs; do
  9734: 	  case " $convenience " in
  9735: 	  *" $test_deplib "*) ;;
  9736: 	  *)
  9737: 	    func_append tmp_deplibs " $test_deplib"
  9738: 	    ;;
  9739: 	  esac
  9740: 	done
  9741: 	deplibs=$tmp_deplibs
  9742: 
  9743: 	if test -n "$convenience"; then
  9744: 	  if test -n "$whole_archive_flag_spec" &&
  9745: 	    test yes = "$compiler_needs_object" &&
  9746: 	    test -z "$libobjs"; then
  9747: 	    # extract the archives, so we have objects to list.
  9748: 	    # TODO: could optimize this to just extract one archive.
  9749: 	    whole_archive_flag_spec=
  9750: 	  fi
  9751: 	  if test -n "$whole_archive_flag_spec"; then
  9752: 	    save_libobjs=$libobjs
  9753: 	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
  9754: 	    test "X$libobjs" = "X " && libobjs=
  9755: 	  else
  9756: 	    gentop=$output_objdir/${outputname}x
  9757: 	    func_append generated " $gentop"
  9758: 
  9759: 	    func_extract_archives $gentop $convenience
  9760: 	    func_append libobjs " $func_extract_archives_result"
  9761: 	    test "X$libobjs" = "X " && libobjs=
  9762: 	  fi
  9763: 	fi
  9764: 
  9765: 	if test yes = "$thread_safe" && test -n "$thread_safe_flag_spec"; then
  9766: 	  eval flag=\"$thread_safe_flag_spec\"
  9767: 	  func_append linker_flags " $flag"
  9768: 	fi
  9769: 
  9770: 	# Make a backup of the uninstalled library when relinking
  9771: 	if test relink = "$opt_mode"; then
  9772: 	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
  9773: 	fi
  9774: 
  9775: 	# Do each of the archive commands.
  9776: 	if test yes = "$module" && test -n "$module_cmds"; then
  9777: 	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
  9778: 	    eval test_cmds=\"$module_expsym_cmds\"
  9779: 	    cmds=$module_expsym_cmds
  9780: 	  else
  9781: 	    eval test_cmds=\"$module_cmds\"
  9782: 	    cmds=$module_cmds
  9783: 	  fi
  9784: 	else
  9785: 	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
  9786: 	    eval test_cmds=\"$archive_expsym_cmds\"
  9787: 	    cmds=$archive_expsym_cmds
  9788: 	  else
  9789: 	    eval test_cmds=\"$archive_cmds\"
  9790: 	    cmds=$archive_cmds
  9791: 	  fi
  9792: 	fi
  9793: 
  9794: 	if test : != "$skipped_export" &&
  9795: 	   func_len " $test_cmds" &&
  9796: 	   len=$func_len_result &&
  9797: 	   test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
  9798: 	  :
  9799: 	else
  9800: 	  # The command line is too long to link in one step, link piecewise
  9801: 	  # or, if using GNU ld and skipped_export is not :, use a linker
  9802: 	  # script.
  9803: 
  9804: 	  # Save the value of $output and $libobjs because we want to
  9805: 	  # use them later.  If we have whole_archive_flag_spec, we
  9806: 	  # want to use save_libobjs as it was before
  9807: 	  # whole_archive_flag_spec was expanded, because we can't
  9808: 	  # assume the linker understands whole_archive_flag_spec.
  9809: 	  # This may have to be revisited, in case too many
  9810: 	  # convenience libraries get linked in and end up exceeding
  9811: 	  # the spec.
  9812: 	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
  9813: 	    save_libobjs=$libobjs
  9814: 	  fi
  9815: 	  save_output=$output
  9816: 	  func_basename "$output"
  9817: 	  output_la=$func_basename_result
  9818: 
  9819: 	  # Clear the reloadable object creation command queue and
  9820: 	  # initialize k to one.
  9821: 	  test_cmds=
  9822: 	  concat_cmds=
  9823: 	  objlist=
  9824: 	  last_robj=
  9825: 	  k=1
  9826: 
  9827: 	  if test -n "$save_libobjs" && test : != "$skipped_export" && test yes = "$with_gnu_ld"; then
  9828: 	    output=$output_objdir/$output_la.lnkscript
  9829: 	    func_verbose "creating GNU ld script: $output"
  9830: 	    echo 'INPUT (' > $output
  9831: 	    for obj in $save_libobjs
  9832: 	    do
  9833: 	      func_to_tool_file "$obj"
  9834: 	      $ECHO "$func_to_tool_file_result" >> $output
  9835: 	    done
  9836: 	    echo ')' >> $output
  9837: 	    func_append delfiles " $output"
  9838: 	    func_to_tool_file "$output"
  9839: 	    output=$func_to_tool_file_result
  9840: 	  elif test -n "$save_libobjs" && test : != "$skipped_export" && test -n "$file_list_spec"; then
  9841: 	    output=$output_objdir/$output_la.lnk
  9842: 	    func_verbose "creating linker input file list: $output"
  9843: 	    : > $output
  9844: 	    set x $save_libobjs
  9845: 	    shift
  9846: 	    firstobj=
  9847: 	    if test yes = "$compiler_needs_object"; then
  9848: 	      firstobj="$1 "
  9849: 	      shift
  9850: 	    fi
  9851: 	    for obj
  9852: 	    do
  9853: 	      func_to_tool_file "$obj"
  9854: 	      $ECHO "$func_to_tool_file_result" >> $output
  9855: 	    done
  9856: 	    func_append delfiles " $output"
  9857: 	    func_to_tool_file "$output"
  9858: 	    output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
  9859: 	  else
  9860: 	    if test -n "$save_libobjs"; then
  9861: 	      func_verbose "creating reloadable object files..."
  9862: 	      output=$output_objdir/$output_la-$k.$objext
  9863: 	      eval test_cmds=\"$reload_cmds\"
  9864: 	      func_len " $test_cmds"
  9865: 	      len0=$func_len_result
  9866: 	      len=$len0
  9867: 
  9868: 	      # Loop over the list of objects to be linked.
  9869: 	      for obj in $save_libobjs
  9870: 	      do
  9871: 		func_len " $obj"
  9872: 		func_arith $len + $func_len_result
  9873: 		len=$func_arith_result
  9874: 		if test -z "$objlist" ||
  9875: 		   test "$len" -lt "$max_cmd_len"; then
  9876: 		  func_append objlist " $obj"
  9877: 		else
  9878: 		  # The command $test_cmds is almost too long, add a
  9879: 		  # command to the queue.
  9880: 		  if test 1 -eq "$k"; then
  9881: 		    # The first file doesn't have a previous command to add.
  9882: 		    reload_objs=$objlist
  9883: 		    eval concat_cmds=\"$reload_cmds\"
  9884: 		  else
  9885: 		    # All subsequent reloadable object files will link in
  9886: 		    # the last one created.
  9887: 		    reload_objs="$objlist $last_robj"
  9888: 		    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
  9889: 		  fi
  9890: 		  last_robj=$output_objdir/$output_la-$k.$objext
  9891: 		  func_arith $k + 1
  9892: 		  k=$func_arith_result
  9893: 		  output=$output_objdir/$output_la-$k.$objext
  9894: 		  objlist=" $obj"
  9895: 		  func_len " $last_robj"
  9896: 		  func_arith $len0 + $func_len_result
  9897: 		  len=$func_arith_result
  9898: 		fi
  9899: 	      done
  9900: 	      # Handle the remaining objects by creating one last
  9901: 	      # reloadable object file.  All subsequent reloadable object
  9902: 	      # files will link in the last one created.
  9903: 	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
  9904: 	      reload_objs="$objlist $last_robj"
  9905: 	      eval concat_cmds=\"\$concat_cmds$reload_cmds\"
  9906: 	      if test -n "$last_robj"; then
  9907: 	        eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
  9908: 	      fi
  9909: 	      func_append delfiles " $output"
  9910: 
  9911: 	    else
  9912: 	      output=
  9913: 	    fi
  9914: 
  9915: 	    ${skipped_export-false} && {
  9916: 	      func_verbose "generating symbol list for '$libname.la'"
  9917: 	      export_symbols=$output_objdir/$libname.exp
  9918: 	      $opt_dry_run || $RM $export_symbols
  9919: 	      libobjs=$output
  9920: 	      # Append the command to create the export file.
  9921: 	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
  9922: 	      eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
  9923: 	      if test -n "$last_robj"; then
  9924: 		eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
  9925: 	      fi
  9926: 	    }
  9927: 
  9928: 	    test -n "$save_libobjs" &&
  9929: 	      func_verbose "creating a temporary reloadable object file: $output"
  9930: 
  9931: 	    # Loop through the commands generated above and execute them.
  9932: 	    save_ifs=$IFS; IFS='~'
  9933: 	    for cmd in $concat_cmds; do
  9934: 	      IFS=$save_ifs
  9935: 	      $opt_quiet || {
  9936: 		  func_quote_for_expand "$cmd"
  9937: 		  eval "func_echo $func_quote_for_expand_result"
  9938: 	      }
  9939: 	      $opt_dry_run || eval "$cmd" || {
  9940: 		lt_exit=$?
  9941: 
  9942: 		# Restore the uninstalled library and exit
  9943: 		if test relink = "$opt_mode"; then
  9944: 		  ( cd "$output_objdir" && \
  9945: 		    $RM "${realname}T" && \
  9946: 		    $MV "${realname}U" "$realname" )
  9947: 		fi
  9948: 
  9949: 		exit $lt_exit
  9950: 	      }
  9951: 	    done
  9952: 	    IFS=$save_ifs
  9953: 
  9954: 	    if test -n "$export_symbols_regex" && ${skipped_export-false}; then
  9955: 	      func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
  9956: 	      func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
  9957: 	    fi
  9958: 	  fi
  9959: 
  9960:           ${skipped_export-false} && {
  9961: 	    if test -n "$export_symbols" && test -n "$include_expsyms"; then
  9962: 	      tmp_export_symbols=$export_symbols
  9963: 	      test -n "$orig_export_symbols" && tmp_export_symbols=$orig_export_symbols
  9964: 	      $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
  9965: 	    fi
  9966: 
  9967: 	    if test -n "$orig_export_symbols"; then
  9968: 	      # The given exports_symbols file has to be filtered, so filter it.
  9969: 	      func_verbose "filter symbol list for '$libname.la' to tag DATA exports"
  9970: 	      # FIXME: $output_objdir/$libname.filter potentially contains lots of
  9971: 	      # 's' commands, which not all seds can handle. GNU sed should be fine
  9972: 	      # though. Also, the filter scales superlinearly with the number of
  9973: 	      # global variables. join(1) would be nice here, but unfortunately
  9974: 	      # isn't a blessed tool.
  9975: 	      $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
  9976: 	      func_append delfiles " $export_symbols $output_objdir/$libname.filter"
  9977: 	      export_symbols=$output_objdir/$libname.def
  9978: 	      $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
  9979: 	    fi
  9980: 	  }
  9981: 
  9982: 	  libobjs=$output
  9983: 	  # Restore the value of output.
  9984: 	  output=$save_output
  9985: 
  9986: 	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
  9987: 	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
  9988: 	    test "X$libobjs" = "X " && libobjs=
  9989: 	  fi
  9990: 	  # Expand the library linking commands again to reset the
  9991: 	  # value of $libobjs for piecewise linking.
  9992: 
  9993: 	  # Do each of the archive commands.
  9994: 	  if test yes = "$module" && test -n "$module_cmds"; then
  9995: 	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
  9996: 	      cmds=$module_expsym_cmds
  9997: 	    else
  9998: 	      cmds=$module_cmds
  9999: 	    fi
 10000: 	  else
 10001: 	    if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
 10002: 	      cmds=$archive_expsym_cmds
 10003: 	    else
 10004: 	      cmds=$archive_cmds
 10005: 	    fi
 10006: 	  fi
 10007: 	fi
 10008: 
 10009: 	if test -n "$delfiles"; then
 10010: 	  # Append the command to remove temporary files to $cmds.
 10011: 	  eval cmds=\"\$cmds~\$RM $delfiles\"
 10012: 	fi
 10013: 
 10014: 	# Add any objects from preloaded convenience libraries
 10015: 	if test -n "$dlprefiles"; then
 10016: 	  gentop=$output_objdir/${outputname}x
 10017: 	  func_append generated " $gentop"
 10018: 
 10019: 	  func_extract_archives $gentop $dlprefiles
 10020: 	  func_append libobjs " $func_extract_archives_result"
 10021: 	  test "X$libobjs" = "X " && libobjs=
 10022: 	fi
 10023: 
 10024: 	save_ifs=$IFS; IFS='~'
 10025: 	for cmd in $cmds; do
 10026: 	  IFS=$sp$nl
 10027: 	  eval cmd=\"$cmd\"
 10028: 	  IFS=$save_ifs
 10029: 	  $opt_quiet || {
 10030: 	    func_quote_for_expand "$cmd"
 10031: 	    eval "func_echo $func_quote_for_expand_result"
 10032: 	  }
 10033: 	  $opt_dry_run || eval "$cmd" || {
 10034: 	    lt_exit=$?
 10035: 
 10036: 	    # Restore the uninstalled library and exit
 10037: 	    if test relink = "$opt_mode"; then
 10038: 	      ( cd "$output_objdir" && \
 10039: 	        $RM "${realname}T" && \
 10040: 		$MV "${realname}U" "$realname" )
 10041: 	    fi
 10042: 
 10043: 	    exit $lt_exit
 10044: 	  }
 10045: 	done
 10046: 	IFS=$save_ifs
 10047: 
 10048: 	# Restore the uninstalled library and exit
 10049: 	if test relink = "$opt_mode"; then
 10050: 	  $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
 10051: 
 10052: 	  if test -n "$convenience"; then
 10053: 	    if test -z "$whole_archive_flag_spec"; then
 10054: 	      func_show_eval '${RM}r "$gentop"'
 10055: 	    fi
 10056: 	  fi
 10057: 
 10058: 	  exit $EXIT_SUCCESS
 10059: 	fi
 10060: 
 10061: 	# Create links to the real library.
 10062: 	for linkname in $linknames; do
 10063: 	  if test "$realname" != "$linkname"; then
 10064: 	    func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
 10065: 	  fi
 10066: 	done
 10067: 
 10068: 	# If -module or -export-dynamic was specified, set the dlname.
 10069: 	if test yes = "$module" || test yes = "$export_dynamic"; then
 10070: 	  # On all known operating systems, these are identical.
 10071: 	  dlname=$soname
 10072: 	fi
 10073:       fi
 10074:       ;;
 10075: 
 10076:     obj)
 10077:       if test -n "$dlfiles$dlprefiles" || test no != "$dlself"; then
 10078: 	func_warning "'-dlopen' is ignored for objects"
 10079:       fi
 10080: 
 10081:       case " $deplibs" in
 10082:       *\ -l* | *\ -L*)
 10083: 	func_warning "'-l' and '-L' are ignored for objects" ;;
 10084:       esac
 10085: 
 10086:       test -n "$rpath" && \
 10087: 	func_warning "'-rpath' is ignored for objects"
 10088: 
 10089:       test -n "$xrpath" && \
 10090: 	func_warning "'-R' is ignored for objects"
 10091: 
 10092:       test -n "$vinfo" && \
 10093: 	func_warning "'-version-info' is ignored for objects"
 10094: 
 10095:       test -n "$release" && \
 10096: 	func_warning "'-release' is ignored for objects"
 10097: 
 10098:       case $output in
 10099:       *.lo)
 10100: 	test -n "$objs$old_deplibs" && \
 10101: 	  func_fatal_error "cannot build library object '$output' from non-libtool objects"
 10102: 
 10103: 	libobj=$output
 10104: 	func_lo2o "$libobj"
 10105: 	obj=$func_lo2o_result
 10106: 	;;
 10107:       *)
 10108: 	libobj=
 10109: 	obj=$output
 10110: 	;;
 10111:       esac
 10112: 
 10113:       # Delete the old objects.
 10114:       $opt_dry_run || $RM $obj $libobj
 10115: 
 10116:       # Objects from convenience libraries.  This assumes
 10117:       # single-version convenience libraries.  Whenever we create
 10118:       # different ones for PIC/non-PIC, this we'll have to duplicate
 10119:       # the extraction.
 10120:       reload_conv_objs=
 10121:       gentop=
 10122:       # if reload_cmds runs $LD directly, get rid of -Wl from
 10123:       # whole_archive_flag_spec and hope we can get by with turning comma
 10124:       # into space.
 10125:       case $reload_cmds in
 10126:         *\$LD[\ \$]*) wl= ;;
 10127:       esac
 10128:       if test -n "$convenience"; then
 10129: 	if test -n "$whole_archive_flag_spec"; then
 10130: 	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
 10131: 	  test -n "$wl" || tmp_whole_archive_flags=`$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
 10132: 	  reload_conv_objs=$reload_objs\ $tmp_whole_archive_flags
 10133: 	else
 10134: 	  gentop=$output_objdir/${obj}x
 10135: 	  func_append generated " $gentop"
 10136: 
 10137: 	  func_extract_archives $gentop $convenience
 10138: 	  reload_conv_objs="$reload_objs $func_extract_archives_result"
 10139: 	fi
 10140:       fi
 10141: 
 10142:       # If we're not building shared, we need to use non_pic_objs
 10143:       test yes = "$build_libtool_libs" || libobjs=$non_pic_objects
 10144: 
 10145:       # Create the old-style object.
 10146:       reload_objs=$objs$old_deplibs' '`$ECHO "$libobjs" | $SP2NL | $SED "/\.$libext$/d; /\.lib$/d; $lo2o" | $NL2SP`' '$reload_conv_objs
 10147: 
 10148:       output=$obj
 10149:       func_execute_cmds "$reload_cmds" 'exit $?'
 10150: 
 10151:       # Exit if we aren't doing a library object file.
 10152:       if test -z "$libobj"; then
 10153: 	if test -n "$gentop"; then
 10154: 	  func_show_eval '${RM}r "$gentop"'
 10155: 	fi
 10156: 
 10157: 	exit $EXIT_SUCCESS
 10158:       fi
 10159: 
 10160:       test yes = "$build_libtool_libs" || {
 10161: 	if test -n "$gentop"; then
 10162: 	  func_show_eval '${RM}r "$gentop"'
 10163: 	fi
 10164: 
 10165: 	# Create an invalid libtool object if no PIC, so that we don't
 10166: 	# accidentally link it into a program.
 10167: 	# $show "echo timestamp > $libobj"
 10168: 	# $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
 10169: 	exit $EXIT_SUCCESS
 10170:       }
 10171: 
 10172:       if test -n "$pic_flag" || test default != "$pic_mode"; then
 10173: 	# Only do commands if we really have different PIC objects.
 10174: 	reload_objs="$libobjs $reload_conv_objs"
 10175: 	output=$libobj
 10176: 	func_execute_cmds "$reload_cmds" 'exit $?'
 10177:       fi
 10178: 
 10179:       if test -n "$gentop"; then
 10180: 	func_show_eval '${RM}r "$gentop"'
 10181:       fi
 10182: 
 10183:       exit $EXIT_SUCCESS
 10184:       ;;
 10185: 
 10186:     prog)
 10187:       case $host in
 10188: 	*cygwin*) func_stripname '' '.exe' "$output"
 10189: 	          output=$func_stripname_result.exe;;
 10190:       esac
 10191:       test -n "$vinfo" && \
 10192: 	func_warning "'-version-info' is ignored for programs"
 10193: 
 10194:       test -n "$release" && \
 10195: 	func_warning "'-release' is ignored for programs"
 10196: 
 10197:       $preload \
 10198: 	&& test unknown,unknown,unknown = "$dlopen_support,$dlopen_self,$dlopen_self_static" \
 10199: 	&& func_warning "'LT_INIT([dlopen])' not used. Assuming no dlopen support."
 10200: 
 10201:       case $host in
 10202:       *-*-rhapsody* | *-*-darwin1.[012])
 10203: 	# On Rhapsody replace the C library is the System framework
 10204: 	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
 10205: 	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
 10206: 	;;
 10207:       esac
 10208: 
 10209:       case $host in
 10210:       *-*-darwin*)
 10211: 	# Don't allow lazy linking, it breaks C++ global constructors
 10212: 	# But is supposedly fixed on 10.4 or later (yay!).
 10213: 	if test CXX = "$tagname"; then
 10214: 	  case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
 10215: 	    10.[0123])
 10216: 	      func_append compile_command " $wl-bind_at_load"
 10217: 	      func_append finalize_command " $wl-bind_at_load"
 10218: 	    ;;
 10219: 	  esac
 10220: 	fi
 10221: 	# Time to change all our "foo.ltframework" stuff back to "-framework foo"
 10222: 	compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 10223: 	finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 10224: 	;;
 10225:       esac
 10226: 
 10227: 
 10228:       # move library search paths that coincide with paths to not yet
 10229:       # installed libraries to the beginning of the library search list
 10230:       new_libs=
 10231:       for path in $notinst_path; do
 10232: 	case " $new_libs " in
 10233: 	*" -L$path/$objdir "*) ;;
 10234: 	*)
 10235: 	  case " $compile_deplibs " in
 10236: 	  *" -L$path/$objdir "*)
 10237: 	    func_append new_libs " -L$path/$objdir" ;;
 10238: 	  esac
 10239: 	  ;;
 10240: 	esac
 10241:       done
 10242:       for deplib in $compile_deplibs; do
 10243: 	case $deplib in
 10244: 	-L*)
 10245: 	  case " $new_libs " in
 10246: 	  *" $deplib "*) ;;
 10247: 	  *) func_append new_libs " $deplib" ;;
 10248: 	  esac
 10249: 	  ;;
 10250: 	*) func_append new_libs " $deplib" ;;
 10251: 	esac
 10252:       done
 10253:       compile_deplibs=$new_libs
 10254: 
 10255: 
 10256:       func_append compile_command " $compile_deplibs"
 10257:       func_append finalize_command " $finalize_deplibs"
 10258: 
 10259:       if test -n "$rpath$xrpath"; then
 10260: 	# If the user specified any rpath flags, then add them.
 10261: 	for libdir in $rpath $xrpath; do
 10262: 	  # This is the magic to use -rpath.
 10263: 	  case "$finalize_rpath " in
 10264: 	  *" $libdir "*) ;;
 10265: 	  *) func_append finalize_rpath " $libdir" ;;
 10266: 	  esac
 10267: 	done
 10268:       fi
 10269: 
 10270:       # Now hardcode the library paths
 10271:       rpath=
 10272:       hardcode_libdirs=
 10273:       for libdir in $compile_rpath $finalize_rpath; do
 10274: 	if test -n "$hardcode_libdir_flag_spec"; then
 10275: 	  if test -n "$hardcode_libdir_separator"; then
 10276: 	    if test -z "$hardcode_libdirs"; then
 10277: 	      hardcode_libdirs=$libdir
 10278: 	    else
 10279: 	      # Just accumulate the unique libdirs.
 10280: 	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
 10281: 	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 10282: 		;;
 10283: 	      *)
 10284: 		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
 10285: 		;;
 10286: 	      esac
 10287: 	    fi
 10288: 	  else
 10289: 	    eval flag=\"$hardcode_libdir_flag_spec\"
 10290: 	    func_append rpath " $flag"
 10291: 	  fi
 10292: 	elif test -n "$runpath_var"; then
 10293: 	  case "$perm_rpath " in
 10294: 	  *" $libdir "*) ;;
 10295: 	  *) func_append perm_rpath " $libdir" ;;
 10296: 	  esac
 10297: 	fi
 10298: 	case $host in
 10299: 	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
 10300: 	  testbindir=`$ECHO "$libdir" | $SED -e 's*/lib$*/bin*'`
 10301: 	  case :$dllsearchpath: in
 10302: 	  *":$libdir:"*) ;;
 10303: 	  ::) dllsearchpath=$libdir;;
 10304: 	  *) func_append dllsearchpath ":$libdir";;
 10305: 	  esac
 10306: 	  case :$dllsearchpath: in
 10307: 	  *":$testbindir:"*) ;;
 10308: 	  ::) dllsearchpath=$testbindir;;
 10309: 	  *) func_append dllsearchpath ":$testbindir";;
 10310: 	  esac
 10311: 	  ;;
 10312: 	esac
 10313:       done
 10314:       # Substitute the hardcoded libdirs into the rpath.
 10315:       if test -n "$hardcode_libdir_separator" &&
 10316: 	 test -n "$hardcode_libdirs"; then
 10317: 	libdir=$hardcode_libdirs
 10318: 	eval rpath=\" $hardcode_libdir_flag_spec\"
 10319:       fi
 10320:       compile_rpath=$rpath
 10321: 
 10322:       rpath=
 10323:       hardcode_libdirs=
 10324:       for libdir in $finalize_rpath; do
 10325: 	if test -n "$hardcode_libdir_flag_spec"; then
 10326: 	  if test -n "$hardcode_libdir_separator"; then
 10327: 	    if test -z "$hardcode_libdirs"; then
 10328: 	      hardcode_libdirs=$libdir
 10329: 	    else
 10330: 	      # Just accumulate the unique libdirs.
 10331: 	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
 10332: 	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
 10333: 		;;
 10334: 	      *)
 10335: 		func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
 10336: 		;;
 10337: 	      esac
 10338: 	    fi
 10339: 	  else
 10340: 	    eval flag=\"$hardcode_libdir_flag_spec\"
 10341: 	    func_append rpath " $flag"
 10342: 	  fi
 10343: 	elif test -n "$runpath_var"; then
 10344: 	  case "$finalize_perm_rpath " in
 10345: 	  *" $libdir "*) ;;
 10346: 	  *) func_append finalize_perm_rpath " $libdir" ;;
 10347: 	  esac
 10348: 	fi
 10349:       done
 10350:       # Substitute the hardcoded libdirs into the rpath.
 10351:       if test -n "$hardcode_libdir_separator" &&
 10352: 	 test -n "$hardcode_libdirs"; then
 10353: 	libdir=$hardcode_libdirs
 10354: 	eval rpath=\" $hardcode_libdir_flag_spec\"
 10355:       fi
 10356:       finalize_rpath=$rpath
 10357: 
 10358:       if test -n "$libobjs" && test yes = "$build_old_libs"; then
 10359: 	# Transform all the library objects into standard objects.
 10360: 	compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
 10361: 	finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
 10362:       fi
 10363: 
 10364:       func_generate_dlsyms "$outputname" "@PROGRAM@" false
 10365: 
 10366:       # template prelinking step
 10367:       if test -n "$prelink_cmds"; then
 10368: 	func_execute_cmds "$prelink_cmds" 'exit $?'
 10369:       fi
 10370: 
 10371:       wrappers_required=:
 10372:       case $host in
 10373:       *cegcc* | *mingw32ce*)
 10374:         # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
 10375:         wrappers_required=false
 10376:         ;;
 10377:       *cygwin* | *mingw* )
 10378:         test yes = "$build_libtool_libs" || wrappers_required=false
 10379:         ;;
 10380:       *)
 10381:         if test no = "$need_relink" || test yes != "$build_libtool_libs"; then
 10382:           wrappers_required=false
 10383:         fi
 10384:         ;;
 10385:       esac
 10386:       $wrappers_required || {
 10387: 	# Replace the output file specification.
 10388: 	compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
 10389: 	link_command=$compile_command$compile_rpath
 10390: 
 10391: 	# We have no uninstalled library dependencies, so finalize right now.
 10392: 	exit_status=0
 10393: 	func_show_eval "$link_command" 'exit_status=$?'
 10394: 
 10395: 	if test -n "$postlink_cmds"; then
 10396: 	  func_to_tool_file "$output"
 10397: 	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
 10398: 	  func_execute_cmds "$postlink_cmds" 'exit $?'
 10399: 	fi
 10400: 
 10401: 	# Delete the generated files.
 10402: 	if test -f "$output_objdir/${outputname}S.$objext"; then
 10403: 	  func_show_eval '$RM "$output_objdir/${outputname}S.$objext"'
 10404: 	fi
 10405: 
 10406: 	exit $exit_status
 10407:       }
 10408: 
 10409:       if test -n "$compile_shlibpath$finalize_shlibpath"; then
 10410: 	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
 10411:       fi
 10412:       if test -n "$finalize_shlibpath"; then
 10413: 	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
 10414:       fi
 10415: 
 10416:       compile_var=
 10417:       finalize_var=
 10418:       if test -n "$runpath_var"; then
 10419: 	if test -n "$perm_rpath"; then
 10420: 	  # We should set the runpath_var.
 10421: 	  rpath=
 10422: 	  for dir in $perm_rpath; do
 10423: 	    func_append rpath "$dir:"
 10424: 	  done
 10425: 	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
 10426: 	fi
 10427: 	if test -n "$finalize_perm_rpath"; then
 10428: 	  # We should set the runpath_var.
 10429: 	  rpath=
 10430: 	  for dir in $finalize_perm_rpath; do
 10431: 	    func_append rpath "$dir:"
 10432: 	  done
 10433: 	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
 10434: 	fi
 10435:       fi
 10436: 
 10437:       if test yes = "$no_install"; then
 10438: 	# We don't need to create a wrapper script.
 10439: 	link_command=$compile_var$compile_command$compile_rpath
 10440: 	# Replace the output file specification.
 10441: 	link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
 10442: 	# Delete the old output file.
 10443: 	$opt_dry_run || $RM $output
 10444: 	# Link the executable and exit
 10445: 	func_show_eval "$link_command" 'exit $?'
 10446: 
 10447: 	if test -n "$postlink_cmds"; then
 10448: 	  func_to_tool_file "$output"
 10449: 	  postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
 10450: 	  func_execute_cmds "$postlink_cmds" 'exit $?'
 10451: 	fi
 10452: 
 10453: 	exit $EXIT_SUCCESS
 10454:       fi
 10455: 
 10456:       case $hardcode_action,$fast_install in
 10457:         relink,*)
 10458: 	  # Fast installation is not supported
 10459: 	  link_command=$compile_var$compile_command$compile_rpath
 10460: 	  relink_command=$finalize_var$finalize_command$finalize_rpath
 10461: 
 10462: 	  func_warning "this platform does not like uninstalled shared libraries"
 10463: 	  func_warning "'$output' will be relinked during installation"
 10464: 	  ;;
 10465:         *,yes)
 10466: 	  link_command=$finalize_var$compile_command$finalize_rpath
 10467: 	  relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
 10468:           ;;
 10469: 	*,no)
 10470: 	  link_command=$compile_var$compile_command$compile_rpath
 10471: 	  relink_command=$finalize_var$finalize_command$finalize_rpath
 10472:           ;;
 10473: 	*,needless)
 10474: 	  link_command=$finalize_var$compile_command$finalize_rpath
 10475: 	  relink_command=
 10476:           ;;
 10477:       esac
 10478: 
 10479:       # Replace the output file specification.
 10480:       link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
 10481: 
 10482:       # Delete the old output files.
 10483:       $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
 10484: 
 10485:       func_show_eval "$link_command" 'exit $?'
 10486: 
 10487:       if test -n "$postlink_cmds"; then
 10488: 	func_to_tool_file "$output_objdir/$outputname"
 10489: 	postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
 10490: 	func_execute_cmds "$postlink_cmds" 'exit $?'
 10491:       fi
 10492: 
 10493:       # Now create the wrapper script.
 10494:       func_verbose "creating $output"
 10495: 
 10496:       # Quote the relink command for shipping.
 10497:       if test -n "$relink_command"; then
 10498: 	# Preserve any variables that may affect compiler behavior
 10499: 	for var in $variables_saved_for_relink; do
 10500: 	  if eval test -z \"\${$var+set}\"; then
 10501: 	    relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
 10502: 	  elif eval var_value=\$$var; test -z "$var_value"; then
 10503: 	    relink_command="$var=; export $var; $relink_command"
 10504: 	  else
 10505: 	    func_quote_for_eval "$var_value"
 10506: 	    relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
 10507: 	  fi
 10508: 	done
 10509: 	relink_command="(cd `pwd`; $relink_command)"
 10510: 	relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
 10511:       fi
 10512: 
 10513:       # Only actually do things if not in dry run mode.
 10514:       $opt_dry_run || {
 10515: 	# win32 will think the script is a binary if it has
 10516: 	# a .exe suffix, so we strip it off here.
 10517: 	case $output in
 10518: 	  *.exe) func_stripname '' '.exe' "$output"
 10519: 	         output=$func_stripname_result ;;
 10520: 	esac
 10521: 	# test for cygwin because mv fails w/o .exe extensions
 10522: 	case $host in
 10523: 	  *cygwin*)
 10524: 	    exeext=.exe
 10525: 	    func_stripname '' '.exe' "$outputname"
 10526: 	    outputname=$func_stripname_result ;;
 10527: 	  *) exeext= ;;
 10528: 	esac
 10529: 	case $host in
 10530: 	  *cygwin* | *mingw* )
 10531: 	    func_dirname_and_basename "$output" "" "."
 10532: 	    output_name=$func_basename_result
 10533: 	    output_path=$func_dirname_result
 10534: 	    cwrappersource=$output_path/$objdir/lt-$output_name.c
 10535: 	    cwrapper=$output_path/$output_name.exe
 10536: 	    $RM $cwrappersource $cwrapper
 10537: 	    trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
 10538: 
 10539: 	    func_emit_cwrapperexe_src > $cwrappersource
 10540: 
 10541: 	    # The wrapper executable is built using the $host compiler,
 10542: 	    # because it contains $host paths and files. If cross-
 10543: 	    # compiling, it, like the target executable, must be
 10544: 	    # executed on the $host or under an emulation environment.
 10545: 	    $opt_dry_run || {
 10546: 	      $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
 10547: 	      $STRIP $cwrapper
 10548: 	    }
 10549: 
 10550: 	    # Now, create the wrapper script for func_source use:
 10551: 	    func_ltwrapper_scriptname $cwrapper
 10552: 	    $RM $func_ltwrapper_scriptname_result
 10553: 	    trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
 10554: 	    $opt_dry_run || {
 10555: 	      # note: this script will not be executed, so do not chmod.
 10556: 	      if test "x$build" = "x$host"; then
 10557: 		$cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
 10558: 	      else
 10559: 		func_emit_wrapper no > $func_ltwrapper_scriptname_result
 10560: 	      fi
 10561: 	    }
 10562: 	  ;;
 10563: 	  * )
 10564: 	    $RM $output
 10565: 	    trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
 10566: 
 10567: 	    func_emit_wrapper no > $output
 10568: 	    chmod +x $output
 10569: 	  ;;
 10570: 	esac
 10571:       }
 10572:       exit $EXIT_SUCCESS
 10573:       ;;
 10574:     esac
 10575: 
 10576:     # See if we need to build an old-fashioned archive.
 10577:     for oldlib in $oldlibs; do
 10578: 
 10579:       case $build_libtool_libs in
 10580:         convenience)
 10581: 	  oldobjs="$libobjs_save $symfileobj"
 10582: 	  addlibs=$convenience
 10583: 	  build_libtool_libs=no
 10584: 	  ;;
 10585: 	module)
 10586: 	  oldobjs=$libobjs_save
 10587: 	  addlibs=$old_convenience
 10588: 	  build_libtool_libs=no
 10589:           ;;
 10590: 	*)
 10591: 	  oldobjs="$old_deplibs $non_pic_objects"
 10592: 	  $preload && test -f "$symfileobj" \
 10593: 	    && func_append oldobjs " $symfileobj"
 10594: 	  addlibs=$old_convenience
 10595: 	  ;;
 10596:       esac
 10597: 
 10598:       if test -n "$addlibs"; then
 10599: 	gentop=$output_objdir/${outputname}x
 10600: 	func_append generated " $gentop"
 10601: 
 10602: 	func_extract_archives $gentop $addlibs
 10603: 	func_append oldobjs " $func_extract_archives_result"
 10604:       fi
 10605: 
 10606:       # Do each command in the archive commands.
 10607:       if test -n "$old_archive_from_new_cmds" && test yes = "$build_libtool_libs"; then
 10608: 	cmds=$old_archive_from_new_cmds
 10609:       else
 10610: 
 10611: 	# Add any objects from preloaded convenience libraries
 10612: 	if test -n "$dlprefiles"; then
 10613: 	  gentop=$output_objdir/${outputname}x
 10614: 	  func_append generated " $gentop"
 10615: 
 10616: 	  func_extract_archives $gentop $dlprefiles
 10617: 	  func_append oldobjs " $func_extract_archives_result"
 10618: 	fi
 10619: 
 10620: 	# POSIX demands no paths to be encoded in archives.  We have
 10621: 	# to avoid creating archives with duplicate basenames if we
 10622: 	# might have to extract them afterwards, e.g., when creating a
 10623: 	# static archive out of a convenience library, or when linking
 10624: 	# the entirety of a libtool archive into another (currently
 10625: 	# not supported by libtool).
 10626: 	if (for obj in $oldobjs
 10627: 	    do
 10628: 	      func_basename "$obj"
 10629: 	      $ECHO "$func_basename_result"
 10630: 	    done | sort | sort -uc >/dev/null 2>&1); then
 10631: 	  :
 10632: 	else
 10633: 	  echo "copying selected object files to avoid basename conflicts..."
 10634: 	  gentop=$output_objdir/${outputname}x
 10635: 	  func_append generated " $gentop"
 10636: 	  func_mkdir_p "$gentop"
 10637: 	  save_oldobjs=$oldobjs
 10638: 	  oldobjs=
 10639: 	  counter=1
 10640: 	  for obj in $save_oldobjs
 10641: 	  do
 10642: 	    func_basename "$obj"
 10643: 	    objbase=$func_basename_result
 10644: 	    case " $oldobjs " in
 10645: 	    " ") oldobjs=$obj ;;
 10646: 	    *[\ /]"$objbase "*)
 10647: 	      while :; do
 10648: 		# Make sure we don't pick an alternate name that also
 10649: 		# overlaps.
 10650: 		newobj=lt$counter-$objbase
 10651: 		func_arith $counter + 1
 10652: 		counter=$func_arith_result
 10653: 		case " $oldobjs " in
 10654: 		*[\ /]"$newobj "*) ;;
 10655: 		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
 10656: 		esac
 10657: 	      done
 10658: 	      func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
 10659: 	      func_append oldobjs " $gentop/$newobj"
 10660: 	      ;;
 10661: 	    *) func_append oldobjs " $obj" ;;
 10662: 	    esac
 10663: 	  done
 10664: 	fi
 10665: 	func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
 10666: 	tool_oldlib=$func_to_tool_file_result
 10667: 	eval cmds=\"$old_archive_cmds\"
 10668: 
 10669: 	func_len " $cmds"
 10670: 	len=$func_len_result
 10671: 	if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 10672: 	  cmds=$old_archive_cmds
 10673: 	elif test -n "$archiver_list_spec"; then
 10674: 	  func_verbose "using command file archive linking..."
 10675: 	  for obj in $oldobjs
 10676: 	  do
 10677: 	    func_to_tool_file "$obj"
 10678: 	    $ECHO "$func_to_tool_file_result"
 10679: 	  done > $output_objdir/$libname.libcmd
 10680: 	  func_to_tool_file "$output_objdir/$libname.libcmd"
 10681: 	  oldobjs=" $archiver_list_spec$func_to_tool_file_result"
 10682: 	  cmds=$old_archive_cmds
 10683: 	else
 10684: 	  # the command line is too long to link in one step, link in parts
 10685: 	  func_verbose "using piecewise archive linking..."
 10686: 	  save_RANLIB=$RANLIB
 10687: 	  RANLIB=:
 10688: 	  objlist=
 10689: 	  concat_cmds=
 10690: 	  save_oldobjs=$oldobjs
 10691: 	  oldobjs=
 10692: 	  # Is there a better way of finding the last object in the list?
 10693: 	  for obj in $save_oldobjs
 10694: 	  do
 10695: 	    last_oldobj=$obj
 10696: 	  done
 10697: 	  eval test_cmds=\"$old_archive_cmds\"
 10698: 	  func_len " $test_cmds"
 10699: 	  len0=$func_len_result
 10700: 	  len=$len0
 10701: 	  for obj in $save_oldobjs
 10702: 	  do
 10703: 	    func_len " $obj"
 10704: 	    func_arith $len + $func_len_result
 10705: 	    len=$func_arith_result
 10706: 	    func_append objlist " $obj"
 10707: 	    if test "$len" -lt "$max_cmd_len"; then
 10708: 	      :
 10709: 	    else
 10710: 	      # the above command should be used before it gets too long
 10711: 	      oldobjs=$objlist
 10712: 	      if test "$obj" = "$last_oldobj"; then
 10713: 		RANLIB=$save_RANLIB
 10714: 	      fi
 10715: 	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
 10716: 	      eval concat_cmds=\"\$concat_cmds$old_archive_cmds\"
 10717: 	      objlist=
 10718: 	      len=$len0
 10719: 	    fi
 10720: 	  done
 10721: 	  RANLIB=$save_RANLIB
 10722: 	  oldobjs=$objlist
 10723: 	  if test -z "$oldobjs"; then
 10724: 	    eval cmds=\"\$concat_cmds\"
 10725: 	  else
 10726: 	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
 10727: 	  fi
 10728: 	fi
 10729:       fi
 10730:       func_execute_cmds "$cmds" 'exit $?'
 10731:     done
 10732: 
 10733:     test -n "$generated" && \
 10734:       func_show_eval "${RM}r$generated"
 10735: 
 10736:     # Now create the libtool archive.
 10737:     case $output in
 10738:     *.la)
 10739:       old_library=
 10740:       test yes = "$build_old_libs" && old_library=$libname.$libext
 10741:       func_verbose "creating $output"
 10742: 
 10743:       # Preserve any variables that may affect compiler behavior
 10744:       for var in $variables_saved_for_relink; do
 10745: 	if eval test -z \"\${$var+set}\"; then
 10746: 	  relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
 10747: 	elif eval var_value=\$$var; test -z "$var_value"; then
 10748: 	  relink_command="$var=; export $var; $relink_command"
 10749: 	else
 10750: 	  func_quote_for_eval "$var_value"
 10751: 	  relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
 10752: 	fi
 10753:       done
 10754:       # Quote the link command for shipping.
 10755:       relink_command="(cd `pwd`; $SHELL \"$progpath\" $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
 10756:       relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
 10757:       if test yes = "$hardcode_automatic"; then
 10758: 	relink_command=
 10759:       fi
 10760: 
 10761:       # Only create the output if not a dry run.
 10762:       $opt_dry_run || {
 10763: 	for installed in no yes; do
 10764: 	  if test yes = "$installed"; then
 10765: 	    if test -z "$install_libdir"; then
 10766: 	      break
 10767: 	    fi
 10768: 	    output=$output_objdir/${outputname}i
 10769: 	    # Replace all uninstalled libtool libraries with the installed ones
 10770: 	    newdependency_libs=
 10771: 	    for deplib in $dependency_libs; do
 10772: 	      case $deplib in
 10773: 	      *.la)
 10774: 		func_basename "$deplib"
 10775: 		name=$func_basename_result
 10776: 		func_resolve_sysroot "$deplib"
 10777: 		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
 10778: 		test -z "$libdir" && \
 10779: 		  func_fatal_error "'$deplib' is not a valid libtool archive"
 10780: 		func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
 10781: 		;;
 10782: 	      -L*)
 10783: 		func_stripname -L '' "$deplib"
 10784: 		func_replace_sysroot "$func_stripname_result"
 10785: 		func_append newdependency_libs " -L$func_replace_sysroot_result"
 10786: 		;;
 10787: 	      -R*)
 10788: 		func_stripname -R '' "$deplib"
 10789: 		func_replace_sysroot "$func_stripname_result"
 10790: 		func_append newdependency_libs " -R$func_replace_sysroot_result"
 10791: 		;;
 10792: 	      *) func_append newdependency_libs " $deplib" ;;
 10793: 	      esac
 10794: 	    done
 10795: 	    dependency_libs=$newdependency_libs
 10796: 	    newdlfiles=
 10797: 
 10798: 	    for lib in $dlfiles; do
 10799: 	      case $lib in
 10800: 	      *.la)
 10801: 	        func_basename "$lib"
 10802: 		name=$func_basename_result
 10803: 		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
 10804: 		test -z "$libdir" && \
 10805: 		  func_fatal_error "'$lib' is not a valid libtool archive"
 10806: 		func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
 10807: 		;;
 10808: 	      *) func_append newdlfiles " $lib" ;;
 10809: 	      esac
 10810: 	    done
 10811: 	    dlfiles=$newdlfiles
 10812: 	    newdlprefiles=
 10813: 	    for lib in $dlprefiles; do
 10814: 	      case $lib in
 10815: 	      *.la)
 10816: 		# Only pass preopened files to the pseudo-archive (for
 10817: 		# eventual linking with the app. that links it) if we
 10818: 		# didn't already link the preopened objects directly into
 10819: 		# the library:
 10820: 		func_basename "$lib"
 10821: 		name=$func_basename_result
 10822: 		eval libdir=`$SED -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
 10823: 		test -z "$libdir" && \
 10824: 		  func_fatal_error "'$lib' is not a valid libtool archive"
 10825: 		func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
 10826: 		;;
 10827: 	      esac
 10828: 	    done
 10829: 	    dlprefiles=$newdlprefiles
 10830: 	  else
 10831: 	    newdlfiles=
 10832: 	    for lib in $dlfiles; do
 10833: 	      case $lib in
 10834: 		[\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
 10835: 		*) abs=`pwd`"/$lib" ;;
 10836: 	      esac
 10837: 	      func_append newdlfiles " $abs"
 10838: 	    done
 10839: 	    dlfiles=$newdlfiles
 10840: 	    newdlprefiles=
 10841: 	    for lib in $dlprefiles; do
 10842: 	      case $lib in
 10843: 		[\\/]* | [A-Za-z]:[\\/]*) abs=$lib ;;
 10844: 		*) abs=`pwd`"/$lib" ;;
 10845: 	      esac
 10846: 	      func_append newdlprefiles " $abs"
 10847: 	    done
 10848: 	    dlprefiles=$newdlprefiles
 10849: 	  fi
 10850: 	  $RM $output
 10851: 	  # place dlname in correct position for cygwin
 10852: 	  # In fact, it would be nice if we could use this code for all target
 10853: 	  # systems that can't hard-code library paths into their executables
 10854: 	  # and that have no shared library path variable independent of PATH,
 10855: 	  # but it turns out we can't easily determine that from inspecting
 10856: 	  # libtool variables, so we have to hard-code the OSs to which it
 10857: 	  # applies here; at the moment, that means platforms that use the PE
 10858: 	  # object format with DLL files.  See the long comment at the top of
 10859: 	  # tests/bindir.at for full details.
 10860: 	  tdlname=$dlname
 10861: 	  case $host,$output,$installed,$module,$dlname in
 10862: 	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
 10863: 	      # If a -bindir argument was supplied, place the dll there.
 10864: 	      if test -n "$bindir"; then
 10865: 		func_relative_path "$install_libdir" "$bindir"
 10866: 		tdlname=$func_relative_path_result/$dlname
 10867: 	      else
 10868: 		# Otherwise fall back on heuristic.
 10869: 		tdlname=../bin/$dlname
 10870: 	      fi
 10871: 	      ;;
 10872: 	  esac
 10873: 	  $ECHO > $output "\
 10874: # $outputname - a libtool library file
 10875: # Generated by $PROGRAM (GNU $PACKAGE) $VERSION
 10876: #
 10877: # Please DO NOT delete this file!
 10878: # It is necessary for linking the library.
 10879: 
 10880: # The name that we can dlopen(3).
 10881: dlname='$tdlname'
 10882: 
 10883: # Names of this library.
 10884: library_names='$library_names'
 10885: 
 10886: # The name of the static archive.
 10887: old_library='$old_library'
 10888: 
 10889: # Linker flags that cannot go in dependency_libs.
 10890: inherited_linker_flags='$new_inherited_linker_flags'
 10891: 
 10892: # Libraries that this one depends upon.
 10893: dependency_libs='$dependency_libs'
 10894: 
 10895: # Names of additional weak libraries provided by this library
 10896: weak_library_names='$weak_libs'
 10897: 
 10898: # Version information for $libname.
 10899: current=$current
 10900: age=$age
 10901: revision=$revision
 10902: 
 10903: # Is this an already installed library?
 10904: installed=$installed
 10905: 
 10906: # Should we warn about portability when linking against -modules?
 10907: shouldnotlink=$module
 10908: 
 10909: # Files to dlopen/dlpreopen
 10910: dlopen='$dlfiles'
 10911: dlpreopen='$dlprefiles'
 10912: 
 10913: # Directory that this library needs to be installed in:
 10914: libdir='$install_libdir'"
 10915: 	  if test no,yes = "$installed,$need_relink"; then
 10916: 	    $ECHO >> $output "\
 10917: relink_command=\"$relink_command\""
 10918: 	  fi
 10919: 	done
 10920:       }
 10921: 
 10922:       # Do a symbolic link so that the libtool archive can be found in
 10923:       # LD_LIBRARY_PATH before the program is installed.
 10924:       func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
 10925:       ;;
 10926:     esac
 10927:     exit $EXIT_SUCCESS
 10928: }
 10929: 
 10930: if test link = "$opt_mode" || test relink = "$opt_mode"; then
 10931:   func_mode_link ${1+"$@"}
 10932: fi
 10933: 
 10934: 
 10935: # func_mode_uninstall arg...
 10936: func_mode_uninstall ()
 10937: {
 10938:     $debug_cmd
 10939: 
 10940:     RM=$nonopt
 10941:     files=
 10942:     rmforce=false
 10943:     exit_status=0
 10944: 
 10945:     # This variable tells wrapper scripts just to set variables rather
 10946:     # than running their programs.
 10947:     libtool_install_magic=$magic
 10948: 
 10949:     for arg
 10950:     do
 10951:       case $arg in
 10952:       -f) func_append RM " $arg"; rmforce=: ;;
 10953:       -*) func_append RM " $arg" ;;
 10954:       *) func_append files " $arg" ;;
 10955:       esac
 10956:     done
 10957: 
 10958:     test -z "$RM" && \
 10959:       func_fatal_help "you must specify an RM program"
 10960: 
 10961:     rmdirs=
 10962: 
 10963:     for file in $files; do
 10964:       func_dirname "$file" "" "."
 10965:       dir=$func_dirname_result
 10966:       if test . = "$dir"; then
 10967: 	odir=$objdir
 10968:       else
 10969: 	odir=$dir/$objdir
 10970:       fi
 10971:       func_basename "$file"
 10972:       name=$func_basename_result
 10973:       test uninstall = "$opt_mode" && odir=$dir
 10974: 
 10975:       # Remember odir for removal later, being careful to avoid duplicates
 10976:       if test clean = "$opt_mode"; then
 10977: 	case " $rmdirs " in
 10978: 	  *" $odir "*) ;;
 10979: 	  *) func_append rmdirs " $odir" ;;
 10980: 	esac
 10981:       fi
 10982: 
 10983:       # Don't error if the file doesn't exist and rm -f was used.
 10984:       if { test -L "$file"; } >/dev/null 2>&1 ||
 10985: 	 { test -h "$file"; } >/dev/null 2>&1 ||
 10986: 	 test -f "$file"; then
 10987: 	:
 10988:       elif test -d "$file"; then
 10989: 	exit_status=1
 10990: 	continue
 10991:       elif $rmforce; then
 10992: 	continue
 10993:       fi
 10994: 
 10995:       rmfiles=$file
 10996: 
 10997:       case $name in
 10998:       *.la)
 10999: 	# Possibly a libtool archive, so verify it.
 11000: 	if func_lalib_p "$file"; then
 11001: 	  func_source $dir/$name
 11002: 
 11003: 	  # Delete the libtool libraries and symlinks.
 11004: 	  for n in $library_names; do
 11005: 	    func_append rmfiles " $odir/$n"
 11006: 	  done
 11007: 	  test -n "$old_library" && func_append rmfiles " $odir/$old_library"
 11008: 
 11009: 	  case $opt_mode in
 11010: 	  clean)
 11011: 	    case " $library_names " in
 11012: 	    *" $dlname "*) ;;
 11013: 	    *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
 11014: 	    esac
 11015: 	    test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
 11016: 	    ;;
 11017: 	  uninstall)
 11018: 	    if test -n "$library_names"; then
 11019: 	      # Do each command in the postuninstall commands.
 11020: 	      func_execute_cmds "$postuninstall_cmds" '$rmforce || exit_status=1'
 11021: 	    fi
 11022: 
 11023: 	    if test -n "$old_library"; then
 11024: 	      # Do each command in the old_postuninstall commands.
 11025: 	      func_execute_cmds "$old_postuninstall_cmds" '$rmforce || exit_status=1'
 11026: 	    fi
 11027: 	    # FIXME: should reinstall the best remaining shared library.
 11028: 	    ;;
 11029: 	  esac
 11030: 	fi
 11031: 	;;
 11032: 
 11033:       *.lo)
 11034: 	# Possibly a libtool object, so verify it.
 11035: 	if func_lalib_p "$file"; then
 11036: 
 11037: 	  # Read the .lo file
 11038: 	  func_source $dir/$name
 11039: 
 11040: 	  # Add PIC object to the list of files to remove.
 11041: 	  if test -n "$pic_object" && test none != "$pic_object"; then
 11042: 	    func_append rmfiles " $dir/$pic_object"
 11043: 	  fi
 11044: 
 11045: 	  # Add non-PIC object to the list of files to remove.
 11046: 	  if test -n "$non_pic_object" && test none != "$non_pic_object"; then
 11047: 	    func_append rmfiles " $dir/$non_pic_object"
 11048: 	  fi
 11049: 	fi
 11050: 	;;
 11051: 
 11052:       *)
 11053: 	if test clean = "$opt_mode"; then
 11054: 	  noexename=$name
 11055: 	  case $file in
 11056: 	  *.exe)
 11057: 	    func_stripname '' '.exe' "$file"
 11058: 	    file=$func_stripname_result
 11059: 	    func_stripname '' '.exe' "$name"
 11060: 	    noexename=$func_stripname_result
 11061: 	    # $file with .exe has already been added to rmfiles,
 11062: 	    # add $file without .exe
 11063: 	    func_append rmfiles " $file"
 11064: 	    ;;
 11065: 	  esac
 11066: 	  # Do a test to see if this is a libtool program.
 11067: 	  if func_ltwrapper_p "$file"; then
 11068: 	    if func_ltwrapper_executable_p "$file"; then
 11069: 	      func_ltwrapper_scriptname "$file"
 11070: 	      relink_command=
 11071: 	      func_source $func_ltwrapper_scriptname_result
 11072: 	      func_append rmfiles " $func_ltwrapper_scriptname_result"
 11073: 	    else
 11074: 	      relink_command=
 11075: 	      func_source $dir/$noexename
 11076: 	    fi
 11077: 
 11078: 	    # note $name still contains .exe if it was in $file originally
 11079: 	    # as does the version of $file that was added into $rmfiles
 11080: 	    func_append rmfiles " $odir/$name $odir/${name}S.$objext"
 11081: 	    if test yes = "$fast_install" && test -n "$relink_command"; then
 11082: 	      func_append rmfiles " $odir/lt-$name"
 11083: 	    fi
 11084: 	    if test "X$noexename" != "X$name"; then
 11085: 	      func_append rmfiles " $odir/lt-$noexename.c"
 11086: 	    fi
 11087: 	  fi
 11088: 	fi
 11089: 	;;
 11090:       esac
 11091:       func_show_eval "$RM $rmfiles" 'exit_status=1'
 11092:     done
 11093: 
 11094:     # Try to remove the $objdir's in the directories where we deleted files
 11095:     for dir in $rmdirs; do
 11096:       if test -d "$dir"; then
 11097: 	func_show_eval "rmdir $dir >/dev/null 2>&1"
 11098:       fi
 11099:     done
 11100: 
 11101:     exit $exit_status
 11102: }
 11103: 
 11104: if test uninstall = "$opt_mode" || test clean = "$opt_mode"; then
 11105:   func_mode_uninstall ${1+"$@"}
 11106: fi
 11107: 
 11108: test -z "$opt_mode" && {
 11109:   help=$generic_help
 11110:   func_fatal_help "you must specify a MODE"
 11111: }
 11112: 
 11113: test -z "$exec_cmd" && \
 11114:   func_fatal_help "invalid operation mode '$opt_mode'"
 11115: 
 11116: if test -n "$exec_cmd"; then
 11117:   eval exec "$exec_cmd"
 11118:   exit $EXIT_FAILURE
 11119: fi
 11120: 
 11121: exit $exit_status
 11122: 
 11123: 
 11124: # The TAGs below are defined such that we never get into a situation
 11125: # where we disable both kinds of libraries.  Given conflicting
 11126: # choices, we go for a static library, that is the most portable,
 11127: # since we can't tell whether shared libraries were disabled because
 11128: # the user asked for that or because the platform doesn't support
 11129: # them.  This is particularly important on AIX, because we don't
 11130: # support having both static and shared libraries enabled at the same
 11131: # time on that platform, so we default to a shared-only configuration.
 11132: # If a disable-shared tag is given, we'll fallback to a static-only
 11133: # configuration.  But we'll never go from static-only to shared-only.
 11134: 
 11135: # ### BEGIN LIBTOOL TAG CONFIG: disable-shared
 11136: build_libtool_libs=no
 11137: build_old_libs=yes
 11138: # ### END LIBTOOL TAG CONFIG: disable-shared
 11139: 
 11140: # ### BEGIN LIBTOOL TAG CONFIG: disable-static
 11141: build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
 11142: # ### END LIBTOOL TAG CONFIG: disable-static
 11143: 
 11144: # Local Variables:
 11145: # mode:shell-script
 11146: # sh-indentation:2
 11147: # End:

Generated by git2html.