← Back to branch summary

~ubuntu-branches/ubuntu/raring/hplip/raring-proposed

« back to all changes in this revision

Viewing changes to ltmain.sh

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2012-05-26 11:20:39 UTC
  • mfrom: (1.5.6) (31.1.3 precise)
  • Revision ID: package-import@ubuntu.com-20120526112039-bevxczegxnbyr5m7
Tags: 3.12.4-1
http://bugs.debian.org/667828
http://bugs.debian.org/583273
http://bugs.debian.org/666544
* New upstream release
* Switch to source/format 3.0 (quilt) - drop dpatch
* Refreshed debian/patches
* dh_autoreconf debian/autogen.sh & set local-options single-debian-patch
* Update to debian/compat -> 9
* Fix "hardened build flags" patch from Moritz - thanks (Closes: #667828)
* Fix "duplex descriptor uninitialized" patch from Matej (Closes: #583273)
* Fix "please migrate to kde-runtime" patch from Pino (Closes: #666544)

Show diffs side-by-side

added added

removed removed

Lines of Context:
ltmain.sh
1
 
# ltmain.sh - Provide generalized library-building support services.
2
 
# NOTE: Changing this file will not affect anything until you rerun configure.
3
 
#
 
1
 
 
2
# libtool (GNU libtool) 2.4.2
 
3
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
 
4
 
4
5
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
5
 
# 2007, 2008  Free Software Foundation, Inc.
6
 
# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
7
 
#
8
 
# This program is free software; you can redistribute it and/or modify
 
6
# 2007, 2008, 2009, 2010, 2011 Free Software Foundation, Inc.
 
7
# This is free software; see the source for copying conditions.  There is NO
 
8
# warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
 
9
 
 
10
# GNU Libtool is free software; you can redistribute it and/or modify
9
11
# it under the terms of the GNU General Public License as published by
10
12
# the Free Software Foundation; either version 2 of the License, or
11
13
# (at your option) any later version.
12
14
#
13
 
# This program is distributed in the hope that it will be useful, but
 
15
# As a special exception to the GNU General Public License,
 
16
# if you distribute this file as part of a program or library that
 
17
# is built using GNU Libtool, you may include this file under the
 
18
# same distribution terms that you use for the rest of that program.
 
19
#
 
20
# GNU Libtool is distributed in the hope that it will be useful, but
14
21
# WITHOUT ANY WARRANTY; without even the implied warranty of
15
22
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
23
# General Public License for more details.
17
24
#
18
25
# You should have received a copy of the GNU General Public License
19
 
# along with this program; if not, write to the Free Software
20
 
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
21
 
#
22
 
# As a special exception to the GNU General Public License, if you
23
 
# distribute this file as part of a program that contains a
24
 
# configuration script generated by Autoconf, you may include it under
25
 
# the same distribution terms that you use for the rest of that program.
26
 
 
27
 
basename="s,^.*/,,g"
 
26
# along with GNU Libtool; see the file COPYING.  If not, a copy
 
27
# can be downloaded from http://www.gnu.org/licenses/gpl.html,
 
28
# or obtained by writing to the Free Software Foundation, Inc.,
 
29
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
30
 
 
31
# Usage: $progname [OPTION]... [MODE-ARG]...
 
32
#
 
33
# Provide generalized library-building support services.
 
34
#
 
35
#       --config             show all configuration variables
 
36
#       --debug              enable verbose shell tracing
 
37
#   -n, --dry-run            display commands without modifying any files
 
38
#       --features           display basic configuration information and exit
 
39
#       --mode=MODE          use operation mode MODE
 
40
#       --preserve-dup-deps  don't remove duplicate dependency libraries
 
41
#       --quiet, --silent    don't print informational messages
 
42
#       --no-quiet, --no-silent
 
43
#                            print informational messages (default)
 
44
#       --no-warn            don't display warning messages
 
45
#       --tag=TAG            use configuration variables from tag TAG
 
46
#   -v, --verbose            print more informational messages than default
 
47
#       --no-verbose         don't print the extra informational messages
 
48
#       --version            print version information
 
49
#   -h, --help, --help-all   print short, long, or detailed help message
 
50
#
 
51
# MODE must be one of the following:
 
52
#
 
53
#         clean              remove files from the build directory
 
54
#         compile            compile a source file into a libtool object
 
55
#         execute            automatically set library path, then run a program
 
56
#         finish             complete the installation of libtool libraries
 
57
#         install            install libraries or executables
 
58
#         link               create a library or an executable
 
59
#         uninstall          remove libraries from an installed directory
 
60
#
 
61
# MODE-ARGS vary depending on the MODE.  When passed as first option,
 
62
# `--mode=MODE' may be abbreviated as `MODE' or a unique abbreviation of that.
 
63
# Try `$progname --help --mode=MODE' for a more detailed description of MODE.
 
64
#
 
65
# When reporting a bug, please describe a test case to reproduce it and
 
66
# include the following information:
 
67
#
 
68
#         host-triplet: $host
 
69
#         shell:                $SHELL
 
70
#         compiler:             $LTCC
 
71
#         compiler flags:               $LTCFLAGS
 
72
#         linker:               $LD (gnu? $with_gnu_ld)
 
73
#         $progname:    (GNU libtool) 2.4.2 Debian-2.4.2-1
 
74
#         automake:     $automake_version
 
75
#         autoconf:     $autoconf_version
 
76
#
 
77
# Report bugs to <bug-libtool@gnu.org>.
 
78
# GNU libtool home page: <http://www.gnu.org/software/libtool/>.
 
79
# General help using GNU software: <http://www.gnu.org/gethelp/>.
 
80
 
 
81
PROGRAM=libtool
 
82
PACKAGE=libtool
 
83
VERSION="2.4.2 Debian-2.4.2-1"
 
84
TIMESTAMP=""
 
85
package_revision=1.3337
 
86
 
 
87
# Be Bourne compatible
 
88
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
 
89
  emulate sh
 
90
  NULLCMD=:
 
91
  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
 
92
  # is contrary to our usage.  Disable this feature.
 
93
  alias -g '${1+"$@"}'='"$@"'
 
94
  setopt NO_GLOB_SUBST
 
95
else
 
96
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
 
97
fi
 
98
BIN_SH=xpg4; export BIN_SH # for Tru64
 
99
DUALCASE=1; export DUALCASE # for MKS sh
 
100
 
 
101
# A function that is used when there is no print builtin or printf.
 
102
func_fallback_echo ()
 
103
{
 
104
  eval 'cat <<_LTECHO_EOF
 
105
$1
 
106
_LTECHO_EOF'
 
107
}
 
108
 
 
109
# NLS nuisances: We save the old values to restore during execute mode.
 
110
lt_user_locale=
 
111
lt_safe_locale=
 
112
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
 
113
do
 
114
  eval "if test \"\${$lt_var+set}\" = set; then
 
115
          save_$lt_var=\$$lt_var
 
116
          $lt_var=C
 
117
          export $lt_var
 
118
          lt_user_locale=\"$lt_var=\\\$save_\$lt_var; \$lt_user_locale\"
 
119
          lt_safe_locale=\"$lt_var=C; \$lt_safe_locale\"
 
120
        fi"
 
121
done
 
122
LC_ALL=C
 
123
LANGUAGE=C
 
124
export LANGUAGE LC_ALL
 
125
 
 
126
$lt_unset CDPATH
 
127
 
28
128
 
29
129
# Work around backward compatibility issue on IRIX 6.5. On IRIX 6.4+, sh
30
130
# is ksh but when the shell is invoked as "sh" and the current value of
33
133
# function.
34
134
progpath="$0"
35
135
 
36
 
# The name of this program:
37
 
progname=`echo "$progpath" | $SED $basename`
38
 
modename="$progname"
 
136
 
 
137
 
 
138
: ${CP="cp -f"}
 
139
test "${ECHO+set}" = set || ECHO=${as_echo-'printf %s\n'}
 
140
: ${MAKE="make"}
 
141
: ${MKDIR="mkdir"}
 
142
: ${MV="mv -f"}
 
143
: ${RM="rm -f"}
 
144
: ${SHELL="${CONFIG_SHELL-/bin/sh}"}
 
145
: ${Xsed="$SED -e 1s/^X//"}
39
146
 
40
147
# Global variables:
41
148
EXIT_SUCCESS=0
42
149
EXIT_FAILURE=1
43
 
 
44
 
PROGRAM=ltmain.sh
45
 
PACKAGE=libtool
46
 
VERSION=1.5.26
47
 
TIMESTAMP=" (1.1220.2.493 2008/02/01 16:58:18)"
48
 
 
49
 
# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
50
 
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
51
 
  emulate sh
52
 
  NULLCMD=:
53
 
  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
54
 
  # is contrary to our usage.  Disable this feature.
55
 
  alias -g '${1+"$@"}'='"$@"'
56
 
  setopt NO_GLOB_SUBST
57
 
else
58
 
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
59
 
fi
60
 
BIN_SH=xpg4; export BIN_SH # for Tru64
61
 
DUALCASE=1; export DUALCASE # for MKS sh
62
 
 
63
 
# Check that we have a working $echo.
64
 
if test "X$1" = X--no-reexec; then
65
 
  # Discard the --no-reexec flag, and continue.
66
 
  shift
67
 
elif test "X$1" = X--fallback-echo; then
68
 
  # Avoid inline document here, it may be left over
69
 
  :
70
 
elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
71
 
  # Yippee, $echo works!
72
 
  :
73
 
else
74
 
  # Restart under the correct shell, and then maybe $echo will work.
75
 
  exec $SHELL "$progpath" --no-reexec ${1+"$@"}
76
 
fi
77
 
 
78
 
if test "X$1" = X--fallback-echo; then
79
 
  # used as fallback echo
80
 
  shift
81
 
  cat <<EOF
82
 
$*
83
 
EOF
84
 
  exit $EXIT_SUCCESS
85
 
fi
86
 
 
87
 
default_mode=
88
 
help="Try \`$progname --help' for more information."
89
 
magic="%%%MAGIC variable%%%"
90
 
mkdir="mkdir"
91
 
mv="mv -f"
92
 
rm="rm -f"
93
 
 
94
 
# Sed substitution that helps us do robust quoting.  It backslashifies
95
 
# metacharacters that are still active within double-quoted strings.
96
 
Xsed="${SED}"' -e 1s/^X//'
97
 
sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
98
 
# test EBCDIC or ASCII
99
 
case `echo X|tr X '\101'` in
100
 
 A) # ASCII based system
101
 
    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
102
 
  SP2NL='tr \040 \012'
103
 
  NL2SP='tr \015\012 \040\040'
104
 
  ;;
105
 
 *) # EBCDIC based system
106
 
  SP2NL='tr \100 \n'
107
 
  NL2SP='tr \r\n \100\100'
108
 
  ;;
109
 
esac
110
 
 
111
 
# NLS nuisances.
112
 
# Only set LANG and LC_ALL to C if already set.
113
 
# These must not be set unconditionally because not all systems understand
114
 
# e.g. LANG=C (notably SCO).
115
 
# We save the old values to restore during execute mode.
116
 
lt_env=
117
 
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
118
 
do
119
 
  eval "if test \"\${$lt_var+set}\" = set; then
120
 
          save_$lt_var=\$$lt_var
121
 
          lt_env=\"$lt_var=\$$lt_var \$lt_env\"
122
 
          $lt_var=C
123
 
          export $lt_var
124
 
        fi"
125
 
done
126
 
 
127
 
if test -n "$lt_env"; then
128
 
  lt_env="env $lt_env"
129
 
fi
 
150
EXIT_MISMATCH=63  # $? = 63 is used to indicate version mismatch to missing.
 
151
EXIT_SKIP=77      # $? = 77 is used to indicate a skipped test to automake.
 
152
 
 
153
exit_status=$EXIT_SUCCESS
130
154
 
131
155
# Make sure IFS has a sensible default
132
156
lt_nl='
133
157
'
134
158
IFS="   $lt_nl"
135
159
 
136
 
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
137
 
  $echo "$modename: not configured to build any kind of library" 1>&2
138
 
  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
139
 
  exit $EXIT_FAILURE
140
 
fi
141
 
 
142
 
# Global variables.
143
 
mode=$default_mode
144
 
nonopt=
145
 
prev=
146
 
prevopt=
147
 
run=
148
 
show="$echo"
149
 
show_help=
150
 
execute_dlfiles=
151
 
duplicate_deps=no
152
 
preserve_args=
153
 
lo2o="s/\\.lo\$/.${objext}/"
154
 
o2lo="s/\\.${objext}\$/.lo/"
155
 
extracted_archives=
156
 
extracted_serial=0
157
 
 
158
 
#####################################
159
 
# Shell function definitions:
160
 
# This seems to be the best place for them
 
160
dirname="s,/[^/]*$,,"
 
161
basename="s,^.*/,,"
 
162
 
 
163
# func_dirname file append nondir_replacement
 
164
# Compute the dirname of FILE.  If nonempty, add APPEND to the result,
 
165
# otherwise set result to NONDIR_REPLACEMENT.
 
166
func_dirname ()
 
167
{
 
168
    func_dirname_result=`$ECHO "${1}" | $SED "$dirname"`
 
169
    if test "X$func_dirname_result" = "X${1}"; then
 
170
      func_dirname_result="${3}"
 
171
    else
 
172
      func_dirname_result="$func_dirname_result${2}"
 
173
    fi
 
174
} # func_dirname may be replaced by extended shell implementation
 
175
 
 
176
 
 
177
# func_basename file
 
178
func_basename ()
 
179
{
 
180
    func_basename_result=`$ECHO "${1}" | $SED "$basename"`
 
181
} # func_basename may be replaced by extended shell implementation
 
182
 
 
183
 
 
184
# func_dirname_and_basename file append nondir_replacement
 
185
# perform func_basename and func_dirname in a single function
 
186
# call:
 
187
#   dirname:  Compute the dirname of FILE.  If nonempty,
 
188
#             add APPEND to the result, otherwise set result
 
189
#             to NONDIR_REPLACEMENT.
 
190
#             value returned in "$func_dirname_result"
 
191
#   basename: Compute filename of FILE.
 
192
#             value retuned in "$func_basename_result"
 
193
# Implementation must be kept synchronized with func_dirname
 
194
# and func_basename. For efficiency, we do not delegate to
 
195
# those functions but instead duplicate the functionality here.
 
196
func_dirname_and_basename ()
 
197
{
 
198
    # Extract subdirectory from the argument.
 
199
    func_dirname_result=`$ECHO "${1}" | $SED -e "$dirname"`
 
200
    if test "X$func_dirname_result" = "X${1}"; then
 
201
      func_dirname_result="${3}"
 
202
    else
 
203
      func_dirname_result="$func_dirname_result${2}"
 
204
    fi
 
205
    func_basename_result=`$ECHO "${1}" | $SED -e "$basename"`
 
206
} # func_dirname_and_basename may be replaced by extended shell implementation
 
207
 
 
208
 
 
209
# func_stripname prefix suffix name
 
210
# strip PREFIX and SUFFIX off of NAME.
 
211
# PREFIX and SUFFIX must not contain globbing or regex special
 
212
# characters, hashes, percent signs, but SUFFIX may contain a leading
 
213
# dot (in which case that matches only a dot).
 
214
# func_strip_suffix prefix name
 
215
func_stripname ()
 
216
{
 
217
    case ${2} in
 
218
      .*) func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%\\\\${2}\$%%"`;;
 
219
      *)  func_stripname_result=`$ECHO "${3}" | $SED "s%^${1}%%; s%${2}\$%%"`;;
 
220
    esac
 
221
} # func_stripname may be replaced by extended shell implementation
 
222
 
 
223
 
 
224
# These SED scripts presuppose an absolute path with a trailing slash.
 
225
pathcar='s,^/\([^/]*\).*$,\1,'
 
226
pathcdr='s,^/[^/]*,,'
 
227
removedotparts=':dotsl
 
228
                s@/\./@/@g
 
229
                t dotsl
 
230
                s,/\.$,/,'
 
231
collapseslashes='s@/\{1,\}@/@g'
 
232
finalslash='s,/*$,/,'
 
233
 
 
234
# func_normal_abspath PATH
 
235
# Remove doubled-up and trailing slashes, "." path components,
 
236
# and cancel out any ".." path components in PATH after making
 
237
# it an absolute path.
 
238
#             value returned in "$func_normal_abspath_result"
 
239
func_normal_abspath ()
 
240
{
 
241
  # Start from root dir and reassemble the path.
 
242
  func_normal_abspath_result=
 
243
  func_normal_abspath_tpath=$1
 
244
  func_normal_abspath_altnamespace=
 
245
  case $func_normal_abspath_tpath in
 
246
    "")
 
247
      # Empty path, that just means $cwd.
 
248
      func_stripname '' '/' "`pwd`"
 
249
      func_normal_abspath_result=$func_stripname_result
 
250
      return
 
251
    ;;
 
252
    # The next three entries are used to spot a run of precisely
 
253
    # two leading slashes without using negated character classes;
 
254
    # we take advantage of case's first-match behaviour.
 
255
    ///*)
 
256
      # Unusual form of absolute path, do nothing.
 
257
    ;;
 
258
    //*)
 
259
      # Not necessarily an ordinary path; POSIX reserves leading '//'
 
260
      # and for example Cygwin uses it to access remote file shares
 
261
      # over CIFS/SMB, so we conserve a leading double slash if found.
 
262
      func_normal_abspath_altnamespace=/
 
263
    ;;
 
264
    /*)
 
265
      # Absolute path, do nothing.
 
266
    ;;
 
267
    *)
 
268
      # Relative path, prepend $cwd.
 
269
      func_normal_abspath_tpath=`pwd`/$func_normal_abspath_tpath
 
270
    ;;
 
271
  esac
 
272
  # Cancel out all the simple stuff to save iterations.  We also want
 
273
  # the path to end with a slash for ease of parsing, so make sure
 
274
  # there is one (and only one) here.
 
275
  func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
 
276
        -e "$removedotparts" -e "$collapseslashes" -e "$finalslash"`
 
277
  while :; do
 
278
    # Processed it all yet?
 
279
    if test "$func_normal_abspath_tpath" = / ; then
 
280
      # If we ascended to the root using ".." the result may be empty now.
 
281
      if test -z "$func_normal_abspath_result" ; then
 
282
        func_normal_abspath_result=/
 
283
      fi
 
284
      break
 
285
    fi
 
286
    func_normal_abspath_tcomponent=`$ECHO "$func_normal_abspath_tpath" | $SED \
 
287
        -e "$pathcar"`
 
288
    func_normal_abspath_tpath=`$ECHO "$func_normal_abspath_tpath" | $SED \
 
289
        -e "$pathcdr"`
 
290
    # Figure out what to do with it
 
291
    case $func_normal_abspath_tcomponent in
 
292
      "")
 
293
        # Trailing empty path component, ignore it.
 
294
      ;;
 
295
      ..)
 
296
        # Parent dir; strip last assembled component from result.
 
297
        func_dirname "$func_normal_abspath_result"
 
298
        func_normal_abspath_result=$func_dirname_result
 
299
      ;;
 
300
      *)
 
301
        # Actual path component, append it.
 
302
        func_normal_abspath_result=$func_normal_abspath_result/$func_normal_abspath_tcomponent
 
303
      ;;
 
304
    esac
 
305
  done
 
306
  # Restore leading double-slash if one was found on entry.
 
307
  func_normal_abspath_result=$func_normal_abspath_altnamespace$func_normal_abspath_result
 
308
}
 
309
 
 
310
# func_relative_path SRCDIR DSTDIR
 
311
# generates a relative path from SRCDIR to DSTDIR, with a trailing
 
312
# slash if non-empty, suitable for immediately appending a filename
 
313
# without needing to append a separator.
 
314
#             value returned in "$func_relative_path_result"
 
315
func_relative_path ()
 
316
{
 
317
  func_relative_path_result=
 
318
  func_normal_abspath "$1"
 
319
  func_relative_path_tlibdir=$func_normal_abspath_result
 
320
  func_normal_abspath "$2"
 
321
  func_relative_path_tbindir=$func_normal_abspath_result
 
322
 
 
323
  # Ascend the tree starting from libdir
 
324
  while :; do
 
325
    # check if we have found a prefix of bindir
 
326
    case $func_relative_path_tbindir in
 
327
      $func_relative_path_tlibdir)
 
328
        # found an exact match
 
329
        func_relative_path_tcancelled=
 
330
        break
 
331
        ;;
 
332
      $func_relative_path_tlibdir*)
 
333
        # found a matching prefix
 
334
        func_stripname "$func_relative_path_tlibdir" '' "$func_relative_path_tbindir"
 
335
        func_relative_path_tcancelled=$func_stripname_result
 
336
        if test -z "$func_relative_path_result"; then
 
337
          func_relative_path_result=.
 
338
        fi
 
339
        break
 
340
        ;;
 
341
      *)
 
342
        func_dirname $func_relative_path_tlibdir
 
343
        func_relative_path_tlibdir=${func_dirname_result}
 
344
        if test "x$func_relative_path_tlibdir" = x ; then
 
345
          # Have to descend all the way to the root!
 
346
          func_relative_path_result=../$func_relative_path_result
 
347
          func_relative_path_tcancelled=$func_relative_path_tbindir
 
348
          break
 
349
        fi
 
350
        func_relative_path_result=../$func_relative_path_result
 
351
        ;;
 
352
    esac
 
353
  done
 
354
 
 
355
  # Now calculate path; take care to avoid doubling-up slashes.
 
356
  func_stripname '' '/' "$func_relative_path_result"
 
357
  func_relative_path_result=$func_stripname_result
 
358
  func_stripname '/' '/' "$func_relative_path_tcancelled"
 
359
  if test "x$func_stripname_result" != x ; then
 
360
    func_relative_path_result=${func_relative_path_result}/${func_stripname_result}
 
361
  fi
 
362
 
 
363
  # Normalisation. If bindir is libdir, return empty string,
 
364
  # else relative path ending with a slash; either way, target
 
365
  # file name can be directly appended.
 
366
  if test ! -z "$func_relative_path_result"; then
 
367
    func_stripname './' '' "$func_relative_path_result/"
 
368
    func_relative_path_result=$func_stripname_result
 
369
  fi
 
370
}
 
371
 
 
372
# The name of this program:
 
373
func_dirname_and_basename "$progpath"
 
374
progname=$func_basename_result
 
375
 
 
376
# Make sure we have an absolute path for reexecution:
 
377
case $progpath in
 
378
  [\\/]*|[A-Za-z]:\\*) ;;
 
379
  *[\\/]*)
 
380
     progdir=$func_dirname_result
 
381
     progdir=`cd "$progdir" && pwd`
 
382
     progpath="$progdir/$progname"
 
383
     ;;
 
384
  *)
 
385
     save_IFS="$IFS"
 
386
     IFS=${PATH_SEPARATOR-:}
 
387
     for progdir in $PATH; do
 
388
       IFS="$save_IFS"
 
389
       test -x "$progdir/$progname" && break
 
390
     done
 
391
     IFS="$save_IFS"
 
392
     test -n "$progdir" || progdir=`pwd`
 
393
     progpath="$progdir/$progname"
 
394
     ;;
 
395
esac
 
396
 
 
397
# Sed substitution that helps us do robust quoting.  It backslashifies
 
398
# metacharacters that are still active within double-quoted strings.
 
399
Xsed="${SED}"' -e 1s/^X//'
 
400
sed_quote_subst='s/\([`"$\\]\)/\\\1/g'
 
401
 
 
402
# Same as above, but do not quote variable references.
 
403
double_quote_subst='s/\(["`\\]\)/\\\1/g'
 
404
 
 
405
# Sed substitution that turns a string into a regex matching for the
 
406
# string literally.
 
407
sed_make_literal_regex='s,[].[^$\\*\/],\\&,g'
 
408
 
 
409
# Sed substitution that converts a w32 file name or path
 
410
# which contains forward slashes, into one that contains
 
411
# (escaped) backslashes.  A very naive implementation.
 
412
lt_sed_naive_backslashify='s|\\\\*|\\|g;s|/|\\|g;s|\\|\\\\|g'
 
413
 
 
414
# Re-`\' parameter expansions in output of double_quote_subst that were
 
415
# `\'-ed in input to the same.  If an odd number of `\' preceded a '$'
 
416
# in input to double_quote_subst, that '$' was protected from expansion.
 
417
# Since each input `\' is now two `\'s, look for any number of runs of
 
418
# four `\'s followed by two `\'s and then a '$'.  `\' that '$'.
 
419
bs='\\'
 
420
bs2='\\\\'
 
421
bs4='\\\\\\\\'
 
422
dollar='\$'
 
423
sed_double_backslash="\
 
424
  s/$bs4/&\\
 
425
/g
 
426
  s/^$bs2$dollar/$bs&/
 
427
  s/\\([^$bs]\\)$bs2$dollar/\\1$bs2$bs$dollar/g
 
428
  s/\n//g"
 
429
 
 
430
# Standard options:
 
431
opt_dry_run=false
 
432
opt_help=false
 
433
opt_quiet=false
 
434
opt_verbose=false
 
435
opt_warning=:
 
436
 
 
437
# func_echo arg...
 
438
# Echo program name prefixed message, along with the current mode
 
439
# name if it has been set yet.
 
440
func_echo ()
 
441
{
 
442
    $ECHO "$progname: ${opt_mode+$opt_mode: }$*"
 
443
}
 
444
 
 
445
# func_verbose arg...
 
446
# Echo program name prefixed message in verbose mode only.
 
447
func_verbose ()
 
448
{
 
449
    $opt_verbose && func_echo ${1+"$@"}
 
450
 
 
451
    # A bug in bash halts the script if the last line of a function
 
452
    # fails when set -e is in force, so we need another command to
 
453
    # work around that:
 
454
    :
 
455
}
 
456
 
 
457
# func_echo_all arg...
 
458
# Invoke $ECHO with all args, space-separated.
 
459
func_echo_all ()
 
460
{
 
461
    $ECHO "$*"
 
462
}
 
463
 
 
464
# func_error arg...
 
465
# Echo program name prefixed message to standard error.
 
466
func_error ()
 
467
{
 
468
    $ECHO "$progname: ${opt_mode+$opt_mode: }"${1+"$@"} 1>&2
 
469
}
 
470
 
 
471
# func_warning arg...
 
472
# Echo program name prefixed warning message to standard error.
 
473
func_warning ()
 
474
{
 
475
    $opt_warning && $ECHO "$progname: ${opt_mode+$opt_mode: }warning: "${1+"$@"} 1>&2
 
476
 
 
477
    # bash bug again:
 
478
    :
 
479
}
 
480
 
 
481
# func_fatal_error arg...
 
482
# Echo program name prefixed message to standard error, and exit.
 
483
func_fatal_error ()
 
484
{
 
485
    func_error ${1+"$@"}
 
486
    exit $EXIT_FAILURE
 
487
}
 
488
 
 
489
# func_fatal_help arg...
 
490
# Echo program name prefixed message to standard error, followed by
 
491
# a help hint, and exit.
 
492
func_fatal_help ()
 
493
{
 
494
    func_error ${1+"$@"}
 
495
    func_fatal_error "$help"
 
496
}
 
497
help="Try \`$progname --help' for more information."  ## default
 
498
 
 
499
 
 
500
# func_grep expression filename
 
501
# Check whether EXPRESSION matches any line of FILENAME, without output.
 
502
func_grep ()
 
503
{
 
504
    $GREP "$1" "$2" >/dev/null 2>&1
 
505
}
 
506
 
 
507
 
 
508
# func_mkdir_p directory-path
 
509
# Make sure the entire path to DIRECTORY-PATH is available.
 
510
func_mkdir_p ()
 
511
{
 
512
    my_directory_path="$1"
 
513
    my_dir_list=
 
514
 
 
515
    if test -n "$my_directory_path" && test "$opt_dry_run" != ":"; then
 
516
 
 
517
      # Protect directory names starting with `-'
 
518
      case $my_directory_path in
 
519
        -*) my_directory_path="./$my_directory_path" ;;
 
520
      esac
 
521
 
 
522
      # While some portion of DIR does not yet exist...
 
523
      while test ! -d "$my_directory_path"; do
 
524
        # ...make a list in topmost first order.  Use a colon delimited
 
525
        # list incase some portion of path contains whitespace.
 
526
        my_dir_list="$my_directory_path:$my_dir_list"
 
527
 
 
528
        # If the last portion added has no slash in it, the list is done
 
529
        case $my_directory_path in */*) ;; *) break ;; esac
 
530
 
 
531
        # ...otherwise throw away the child directory and loop
 
532
        my_directory_path=`$ECHO "$my_directory_path" | $SED -e "$dirname"`
 
533
      done
 
534
      my_dir_list=`$ECHO "$my_dir_list" | $SED 's,:*$,,'`
 
535
 
 
536
      save_mkdir_p_IFS="$IFS"; IFS=':'
 
537
      for my_dir in $my_dir_list; do
 
538
        IFS="$save_mkdir_p_IFS"
 
539
        # mkdir can fail with a `File exist' error if two processes
 
540
        # try to create one of the directories concurrently.  Don't
 
541
        # stop in that case!
 
542
        $MKDIR "$my_dir" 2>/dev/null || :
 
543
      done
 
544
      IFS="$save_mkdir_p_IFS"
 
545
 
 
546
      # Bail out if we (or some other process) failed to create a directory.
 
547
      test -d "$my_directory_path" || \
 
548
        func_fatal_error "Failed to create \`$1'"
 
549
    fi
 
550
}
 
551
 
161
552
 
162
553
# func_mktempdir [string]
163
554
# Make a temporary directory that won't clash with other running
167
558
{
168
559
    my_template="${TMPDIR-/tmp}/${1-$progname}"
169
560
 
170
 
    if test "$run" = ":"; then
 
561
    if test "$opt_dry_run" = ":"; then
171
562
      # Return a directory name, but don't create it in dry-run mode
172
563
      my_tmpdir="${my_template}-$$"
173
564
    else
176
567
      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
177
568
 
178
569
      if test ! -d "$my_tmpdir"; then
179
 
        # Failing that, at least try and use $RANDOM to avoid a race
180
 
        my_tmpdir="${my_template}-${RANDOM-0}$$"
 
570
        # Failing that, at least try and use $RANDOM to avoid a race
 
571
        my_tmpdir="${my_template}-${RANDOM-0}$$"
181
572
 
182
 
        save_mktempdir_umask=`umask`
183
 
        umask 0077
184
 
        $mkdir "$my_tmpdir"
185
 
        umask $save_mktempdir_umask
 
573
        save_mktempdir_umask=`umask`
 
574
        umask 0077
 
575
        $MKDIR "$my_tmpdir"
 
576
        umask $save_mktempdir_umask
186
577
      fi
187
578
 
188
579
      # If we're not in dry-run mode, bomb out on failure
189
 
      test -d "$my_tmpdir" || {
190
 
        $echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
191
 
        exit $EXIT_FAILURE
192
 
      }
193
 
    fi
194
 
 
195
 
    $echo "X$my_tmpdir" | $Xsed
196
 
}
197
 
 
198
 
 
199
 
# func_win32_libid arg
200
 
# return the library type of file 'arg'
201
 
#
202
 
# Need a lot of goo to handle *both* DLLs and import libs
203
 
# Has to be a shell function in order to 'eat' the argument
204
 
# that is supplied when $file_magic_command is called.
205
 
func_win32_libid ()
206
 
{
207
 
  win32_libid_type="unknown"
208
 
  win32_fileres=`file -L $1 2>/dev/null`
209
 
  case $win32_fileres in
210
 
  *ar\ archive\ import\ library*) # definitely import
211
 
    win32_libid_type="x86 archive import"
212
 
    ;;
213
 
  *ar\ archive*) # could be an import, or static
214
 
    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
215
 
      $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
216
 
      win32_nmres=`eval $NM -f posix -A $1 | \
217
 
        $SED -n -e '1,100{
218
 
                / I /{
219
 
                        s,.*,import,
220
 
                        p
221
 
                        q
222
 
                        }
223
 
                }'`
224
 
      case $win32_nmres in
225
 
      import*)  win32_libid_type="x86 archive import";;
226
 
      *)        win32_libid_type="x86 archive static";;
227
 
      esac
228
 
    fi
229
 
    ;;
230
 
  *DLL*)
231
 
    win32_libid_type="x86 DLL"
232
 
    ;;
233
 
  *executable*) # but shell scripts are "executable" too...
234
 
    case $win32_fileres in
235
 
    *MS\ Windows\ PE\ Intel*)
236
 
      win32_libid_type="x86 DLL"
237
 
      ;;
238
 
    esac
239
 
    ;;
240
 
  esac
241
 
  $echo $win32_libid_type
242
 
}
243
 
 
 
580
      test -d "$my_tmpdir" || \
 
581
        func_fatal_error "cannot create temporary directory \`$my_tmpdir'"
 
582
    fi
 
583
 
 
584
    $ECHO "$my_tmpdir"
 
585
}
 
586
 
 
587
 
 
588
# func_quote_for_eval arg
 
589
# Aesthetically quote ARG to be evaled later.
 
590
# This function returns two values: FUNC_QUOTE_FOR_EVAL_RESULT
 
591
# is double-quoted, suitable for a subsequent eval, whereas
 
592
# FUNC_QUOTE_FOR_EVAL_UNQUOTED_RESULT has merely all characters
 
593
# which are still active within double quotes backslashified.
 
594
func_quote_for_eval ()
 
595
{
 
596
    case $1 in
 
597
      *[\\\`\"\$]*)
 
598
        func_quote_for_eval_unquoted_result=`$ECHO "$1" | $SED "$sed_quote_subst"` ;;
 
599
      *)
 
600
        func_quote_for_eval_unquoted_result="$1" ;;
 
601
    esac
 
602
 
 
603
    case $func_quote_for_eval_unquoted_result in
 
604
      # Double-quote args containing shell metacharacters to delay
 
605
      # word splitting, command substitution and and variable
 
606
      # expansion for a subsequent eval.
 
607
      # Many Bourne shells cannot handle close brackets correctly
 
608
      # in scan sets, so we specify it separately.
 
609
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 
610
        func_quote_for_eval_result="\"$func_quote_for_eval_unquoted_result\""
 
611
        ;;
 
612
      *)
 
613
        func_quote_for_eval_result="$func_quote_for_eval_unquoted_result"
 
614
    esac
 
615
}
 
616
 
 
617
 
 
618
# func_quote_for_expand arg
 
619
# Aesthetically quote ARG to be evaled later; same as above,
 
620
# but do not quote variable references.
 
621
func_quote_for_expand ()
 
622
{
 
623
    case $1 in
 
624
      *[\\\`\"]*)
 
625
        my_arg=`$ECHO "$1" | $SED \
 
626
            -e "$double_quote_subst" -e "$sed_double_backslash"` ;;
 
627
      *)
 
628
        my_arg="$1" ;;
 
629
    esac
 
630
 
 
631
    case $my_arg in
 
632
      # Double-quote args containing shell metacharacters to delay
 
633
      # word splitting and command substitution for a subsequent eval.
 
634
      # Many Bourne shells cannot handle close brackets correctly
 
635
      # in scan sets, so we specify it separately.
 
636
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
 
637
        my_arg="\"$my_arg\""
 
638
        ;;
 
639
    esac
 
640
 
 
641
    func_quote_for_expand_result="$my_arg"
 
642
}
 
643
 
 
644
 
 
645
# func_show_eval cmd [fail_exp]
 
646
# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
 
647
# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
 
648
# is given, then evaluate it.
 
649
func_show_eval ()
 
650
{
 
651
    my_cmd="$1"
 
652
    my_fail_exp="${2-:}"
 
653
 
 
654
    ${opt_silent-false} || {
 
655
      func_quote_for_expand "$my_cmd"
 
656
      eval "func_echo $func_quote_for_expand_result"
 
657
    }
 
658
 
 
659
    if ${opt_dry_run-false}; then :; else
 
660
      eval "$my_cmd"
 
661
      my_status=$?
 
662
      if test "$my_status" -eq 0; then :; else
 
663
        eval "(exit $my_status); $my_fail_exp"
 
664
      fi
 
665
    fi
 
666
}
 
667
 
 
668
 
 
669
# func_show_eval_locale cmd [fail_exp]
 
670
# Unless opt_silent is true, then output CMD.  Then, if opt_dryrun is
 
671
# not true, evaluate CMD.  If the evaluation of CMD fails, and FAIL_EXP
 
672
# is given, then evaluate it.  Use the saved locale for evaluation.
 
673
func_show_eval_locale ()
 
674
{
 
675
    my_cmd="$1"
 
676
    my_fail_exp="${2-:}"
 
677
 
 
678
    ${opt_silent-false} || {
 
679
      func_quote_for_expand "$my_cmd"
 
680
      eval "func_echo $func_quote_for_expand_result"
 
681
    }
 
682
 
 
683
    if ${opt_dry_run-false}; then :; else
 
684
      eval "$lt_user_locale
 
685
            $my_cmd"
 
686
      my_status=$?
 
687
      eval "$lt_safe_locale"
 
688
      if test "$my_status" -eq 0; then :; else
 
689
        eval "(exit $my_status); $my_fail_exp"
 
690
      fi
 
691
    fi
 
692
}
 
693
 
 
694
# func_tr_sh
 
695
# Turn $1 into a string suitable for a shell variable name.
 
696
# Result is stored in $func_tr_sh_result.  All characters
 
697
# not in the set a-zA-Z0-9_ are replaced with '_'. Further,
 
698
# if $1 begins with a digit, a '_' is prepended as well.
 
699
func_tr_sh ()
 
700
{
 
701
  case $1 in
 
702
  [0-9]* | *[!a-zA-Z0-9_]*)
 
703
    func_tr_sh_result=`$ECHO "$1" | $SED 's/^\([0-9]\)/_\1/; s/[^a-zA-Z0-9_]/_/g'`
 
704
    ;;
 
705
  * )
 
706
    func_tr_sh_result=$1
 
707
    ;;
 
708
  esac
 
709
}
 
710
 
 
711
 
 
712
# func_version
 
713
# Echo version message to standard output and exit.
 
714
func_version ()
 
715
{
 
716
    $opt_debug
 
717
 
 
718
    $SED -n '/(C)/!b go
 
719
        :more
 
720
        /\./!{
 
721
          N
 
722
          s/\n# / /
 
723
          b more
 
724
        }
 
725
        :go
 
726
        /^# '$PROGRAM' (GNU /,/# warranty; / {
 
727
        s/^# //
 
728
        s/^# *$//
 
729
        s/\((C)\)[ 0-9,-]*\( [1-9][0-9]*\)/\1\2/
 
730
        p
 
731
     }' < "$progpath"
 
732
     exit $?
 
733
}
 
734
 
 
735
# func_usage
 
736
# Echo short help message to standard output and exit.
 
737
func_usage ()
 
738
{
 
739
    $opt_debug
 
740
 
 
741
    $SED -n '/^# Usage:/,/^#  *.*--help/ {
 
742
        s/^# //
 
743
        s/^# *$//
 
744
        s/\$progname/'$progname'/
 
745
        p
 
746
    }' < "$progpath"
 
747
    echo
 
748
    $ECHO "run \`$progname --help | more' for full usage"
 
749
    exit $?
 
750
}
 
751
 
 
752
# func_help [NOEXIT]
 
753
# Echo long help message to standard output and exit,
 
754
# unless 'noexit' is passed as argument.
 
755
func_help ()
 
756
{
 
757
    $opt_debug
 
758
 
 
759
    $SED -n '/^# Usage:/,/# Report bugs to/ {
 
760
        :print
 
761
        s/^# //
 
762
        s/^# *$//
 
763
        s*\$progname*'$progname'*
 
764
        s*\$host*'"$host"'*
 
765
        s*\$SHELL*'"$SHELL"'*
 
766
        s*\$LTCC*'"$LTCC"'*
 
767
        s*\$LTCFLAGS*'"$LTCFLAGS"'*
 
768
        s*\$LD*'"$LD"'*
 
769
        s/\$with_gnu_ld/'"$with_gnu_ld"'/
 
770
        s/\$automake_version/'"`(${AUTOMAKE-automake} --version) 2>/dev/null |$SED 1q`"'/
 
771
        s/\$autoconf_version/'"`(${AUTOCONF-autoconf} --version) 2>/dev/null |$SED 1q`"'/
 
772
        p
 
773
        d
 
774
     }
 
775
     /^# .* home page:/b print
 
776
     /^# General help using/b print
 
777
     ' < "$progpath"
 
778
    ret=$?
 
779
    if test -z "$1"; then
 
780
      exit $ret
 
781
    fi
 
782
}
 
783
 
 
784
# func_missing_arg argname
 
785
# Echo program name prefixed message to standard error and set global
 
786
# exit_cmd.
 
787
func_missing_arg ()
 
788
{
 
789
    $opt_debug
 
790
 
 
791
    func_error "missing argument for $1."
 
792
    exit_cmd=exit
 
793
}
 
794
 
 
795
 
 
796
# func_split_short_opt shortopt
 
797
# Set func_split_short_opt_name and func_split_short_opt_arg shell
 
798
# variables after splitting SHORTOPT after the 2nd character.
 
799
func_split_short_opt ()
 
800
{
 
801
    my_sed_short_opt='1s/^\(..\).*$/\1/;q'
 
802
    my_sed_short_rest='1s/^..\(.*\)$/\1/;q'
 
803
 
 
804
    func_split_short_opt_name=`$ECHO "$1" | $SED "$my_sed_short_opt"`
 
805
    func_split_short_opt_arg=`$ECHO "$1" | $SED "$my_sed_short_rest"`
 
806
} # func_split_short_opt may be replaced by extended shell implementation
 
807
 
 
808
 
 
809
# func_split_long_opt longopt
 
810
# Set func_split_long_opt_name and func_split_long_opt_arg shell
 
811
# variables after splitting LONGOPT at the `=' sign.
 
812
func_split_long_opt ()
 
813
{
 
814
    my_sed_long_opt='1s/^\(--[^=]*\)=.*/\1/;q'
 
815
    my_sed_long_arg='1s/^--[^=]*=//'
 
816
 
 
817
    func_split_long_opt_name=`$ECHO "$1" | $SED "$my_sed_long_opt"`
 
818
    func_split_long_opt_arg=`$ECHO "$1" | $SED "$my_sed_long_arg"`
 
819
} # func_split_long_opt may be replaced by extended shell implementation
 
820
 
 
821
exit_cmd=:
 
822
 
 
823
 
 
824
 
 
825
 
 
826
 
 
827
magic="%%%MAGIC variable%%%"
 
828
magic_exe="%%%MAGIC EXE variable%%%"
 
829
 
 
830
# Global variables.
 
831
nonopt=
 
832
preserve_args=
 
833
lo2o="s/\\.lo\$/.${objext}/"
 
834
o2lo="s/\\.${objext}\$/.lo/"
 
835
extracted_archives=
 
836
extracted_serial=0
 
837
 
 
838
# If this variable is set in any of the actions, the command in it
 
839
# will be execed at the end.  This prevents here-documents from being
 
840
# left over by shells.
 
841
exec_cmd=
 
842
 
 
843
# func_append var value
 
844
# Append VALUE to the end of shell variable VAR.
 
845
func_append ()
 
846
{
 
847
    eval "${1}=\$${1}\${2}"
 
848
} # func_append may be replaced by extended shell implementation
 
849
 
 
850
# func_append_quoted var value
 
851
# Quote VALUE and append to the end of shell variable VAR, separated
 
852
# by a space.
 
853
func_append_quoted ()
 
854
{
 
855
    func_quote_for_eval "${2}"
 
856
    eval "${1}=\$${1}\\ \$func_quote_for_eval_result"
 
857
} # func_append_quoted may be replaced by extended shell implementation
 
858
 
 
859
 
 
860
# func_arith arithmetic-term...
 
861
func_arith ()
 
862
{
 
863
    func_arith_result=`expr "${@}"`
 
864
} # func_arith may be replaced by extended shell implementation
 
865
 
 
866
 
 
867
# func_len string
 
868
# STRING may not start with a hyphen.
 
869
func_len ()
 
870
{
 
871
    func_len_result=`expr "${1}" : ".*" 2>/dev/null || echo $max_cmd_len`
 
872
} # func_len may be replaced by extended shell implementation
 
873
 
 
874
 
 
875
# func_lo2o object
 
876
func_lo2o ()
 
877
{
 
878
    func_lo2o_result=`$ECHO "${1}" | $SED "$lo2o"`
 
879
} # func_lo2o may be replaced by extended shell implementation
 
880
 
 
881
 
 
882
# func_xform libobj-or-source
 
883
func_xform ()
 
884
{
 
885
    func_xform_result=`$ECHO "${1}" | $SED 's/\.[^.]*$/.lo/'`
 
886
} # func_xform may be replaced by extended shell implementation
 
887
 
 
888
 
 
889
# func_fatal_configuration arg...
 
890
# Echo program name prefixed message to standard error, followed by
 
891
# a configuration failure hint, and exit.
 
892
func_fatal_configuration ()
 
893
{
 
894
    func_error ${1+"$@"}
 
895
    func_error "See the $PACKAGE documentation for more information."
 
896
    func_fatal_error "Fatal configuration error."
 
897
}
 
898
 
 
899
 
 
900
# func_config
 
901
# Display the configuration for all the tags in this script.
 
902
func_config ()
 
903
{
 
904
    re_begincf='^# ### BEGIN LIBTOOL'
 
905
    re_endcf='^# ### END LIBTOOL'
 
906
 
 
907
    # Default configuration.
 
908
    $SED "1,/$re_begincf CONFIG/d;/$re_endcf CONFIG/,\$d" < "$progpath"
 
909
 
 
910
    # Now print the configurations for the tags.
 
911
    for tagname in $taglist; do
 
912
      $SED -n "/$re_begincf TAG CONFIG: $tagname\$/,/$re_endcf TAG CONFIG: $tagname\$/p" < "$progpath"
 
913
    done
 
914
 
 
915
    exit $?
 
916
}
 
917
 
 
918
# func_features
 
919
# Display the features supported by this script.
 
920
func_features ()
 
921
{
 
922
    echo "host: $host"
 
923
    if test "$build_libtool_libs" = yes; then
 
924
      echo "enable shared libraries"
 
925
    else
 
926
      echo "disable shared libraries"
 
927
    fi
 
928
    if test "$build_old_libs" = yes; then
 
929
      echo "enable static libraries"
 
930
    else
 
931
      echo "disable static libraries"
 
932
    fi
 
933
 
 
934
    exit $?
 
935
}
 
936
 
 
937
# func_enable_tag tagname
 
938
# Verify that TAGNAME is valid, and either flag an error and exit, or
 
939
# enable the TAGNAME tag.  We also add TAGNAME to the global $taglist
 
940
# variable here.
 
941
func_enable_tag ()
 
942
{
 
943
  # Global variable:
 
944
  tagname="$1"
 
945
 
 
946
  re_begincf="^# ### BEGIN LIBTOOL TAG CONFIG: $tagname\$"
 
947
  re_endcf="^# ### END LIBTOOL TAG CONFIG: $tagname\$"
 
948
  sed_extractcf="/$re_begincf/,/$re_endcf/p"
 
949
 
 
950
  # Validate tagname.
 
951
  case $tagname in
 
952
    *[!-_A-Za-z0-9,/]*)
 
953
      func_fatal_error "invalid tag name: $tagname"
 
954
      ;;
 
955
  esac
 
956
 
 
957
  # Don't test for the "default" C tag, as we know it's
 
958
  # there but not specially marked.
 
959
  case $tagname in
 
960
    CC) ;;
 
961
    *)
 
962
      if $GREP "$re_begincf" "$progpath" >/dev/null 2>&1; then
 
963
        taglist="$taglist $tagname"
 
964
 
 
965
        # Evaluate the configuration.  Be careful to quote the path
 
966
        # and the sed script, to avoid splitting on whitespace, but
 
967
        # also don't use non-portable quotes within backquotes within
 
968
        # quotes we have to do it in 2 steps:
 
969
        extractedcf=`$SED -n -e "$sed_extractcf" < "$progpath"`
 
970
        eval "$extractedcf"
 
971
      else
 
972
        func_error "ignoring unknown tag $tagname"
 
973
      fi
 
974
      ;;
 
975
  esac
 
976
}
 
977
 
 
978
# func_check_version_match
 
979
# Ensure that we are using m4 macros, and libtool script from the same
 
980
# release of libtool.
 
981
func_check_version_match ()
 
982
{
 
983
  if test "$package_revision" != "$macro_revision"; then
 
984
    if test "$VERSION" != "$macro_version"; then
 
985
      if test -z "$macro_version"; then
 
986
        cat >&2 <<_LT_EOF
 
987
$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
 
988
$progname: definition of this LT_INIT comes from an older release.
 
989
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
 
990
$progname: and run autoconf again.
 
991
_LT_EOF
 
992
      else
 
993
        cat >&2 <<_LT_EOF
 
994
$progname: Version mismatch error.  This is $PACKAGE $VERSION, but the
 
995
$progname: definition of this LT_INIT comes from $PACKAGE $macro_version.
 
996
$progname: You should recreate aclocal.m4 with macros from $PACKAGE $VERSION
 
997
$progname: and run autoconf again.
 
998
_LT_EOF
 
999
      fi
 
1000
    else
 
1001
      cat >&2 <<_LT_EOF
 
1002
$progname: Version mismatch error.  This is $PACKAGE $VERSION, revision $package_revision,
 
1003
$progname: but the definition of this LT_INIT comes from revision $macro_revision.
 
1004
$progname: You should recreate aclocal.m4 with macros from revision $package_revision
 
1005
$progname: of $PACKAGE $VERSION and run autoconf again.
 
1006
_LT_EOF
 
1007
    fi
 
1008
 
 
1009
    exit $EXIT_MISMATCH
 
1010
  fi
 
1011
}
 
1012
 
 
1013
 
 
1014
# Shorthand for --mode=foo, only valid as the first argument
 
1015
case $1 in
 
1016
clean|clea|cle|cl)
 
1017
  shift; set dummy --mode clean ${1+"$@"}; shift
 
1018
  ;;
 
1019
compile|compil|compi|comp|com|co|c)
 
1020
  shift; set dummy --mode compile ${1+"$@"}; shift
 
1021
  ;;
 
1022
execute|execut|execu|exec|exe|ex|e)
 
1023
  shift; set dummy --mode execute ${1+"$@"}; shift
 
1024
  ;;
 
1025
finish|finis|fini|fin|fi|f)
 
1026
  shift; set dummy --mode finish ${1+"$@"}; shift
 
1027
  ;;
 
1028
install|instal|insta|inst|ins|in|i)
 
1029
  shift; set dummy --mode install ${1+"$@"}; shift
 
1030
  ;;
 
1031
link|lin|li|l)
 
1032
  shift; set dummy --mode link ${1+"$@"}; shift
 
1033
  ;;
 
1034
uninstall|uninstal|uninsta|uninst|unins|unin|uni|un|u)
 
1035
  shift; set dummy --mode uninstall ${1+"$@"}; shift
 
1036
  ;;
 
1037
esac
 
1038
 
 
1039
 
 
1040
 
 
1041
# Option defaults:
 
1042
opt_debug=:
 
1043
opt_dry_run=false
 
1044
opt_config=false
 
1045
opt_preserve_dup_deps=false
 
1046
opt_features=false
 
1047
opt_finish=false
 
1048
opt_help=false
 
1049
opt_help_all=false
 
1050
opt_silent=:
 
1051
opt_warning=:
 
1052
opt_verbose=:
 
1053
opt_silent=false
 
1054
opt_verbose=false
 
1055
 
 
1056
 
 
1057
# Parse options once, thoroughly.  This comes as soon as possible in the
 
1058
# script to make things like `--version' happen as quickly as we can.
 
1059
{
 
1060
  # this just eases exit handling
 
1061
  while test $# -gt 0; do
 
1062
    opt="$1"
 
1063
    shift
 
1064
    case $opt in
 
1065
      --debug|-x)       opt_debug='set -x'
 
1066
                        func_echo "enabling shell trace mode"
 
1067
                        $opt_debug
 
1068
                        ;;
 
1069
      --dry-run|--dryrun|-n)
 
1070
                        opt_dry_run=:
 
1071
                        ;;
 
1072
      --config)
 
1073
                        opt_config=:
 
1074
func_config
 
1075
                        ;;
 
1076
      --dlopen|-dlopen)
 
1077
                        optarg="$1"
 
1078
                        opt_dlopen="${opt_dlopen+$opt_dlopen
 
1079
}$optarg"
 
1080
                        shift
 
1081
                        ;;
 
1082
      --preserve-dup-deps)
 
1083
                        opt_preserve_dup_deps=:
 
1084
                        ;;
 
1085
      --features)
 
1086
                        opt_features=:
 
1087
func_features
 
1088
                        ;;
 
1089
      --finish)
 
1090
                        opt_finish=:
 
1091
set dummy --mode finish ${1+"$@"}; shift
 
1092
                        ;;
 
1093
      --help)
 
1094
                        opt_help=:
 
1095
                        ;;
 
1096
      --help-all)
 
1097
                        opt_help_all=:
 
1098
opt_help=': help-all'
 
1099
                        ;;
 
1100
      --mode)
 
1101
                        test $# = 0 && func_missing_arg $opt && break
 
1102
                        optarg="$1"
 
1103
                        opt_mode="$optarg"
 
1104
case $optarg in
 
1105
  # Valid mode arguments:
 
1106
  clean|compile|execute|finish|install|link|relink|uninstall) ;;
 
1107
 
 
1108
  # Catch anything else as an error
 
1109
  *) func_error "invalid argument for $opt"
 
1110
     exit_cmd=exit
 
1111
     break
 
1112
     ;;
 
1113
esac
 
1114
                        shift
 
1115
                        ;;
 
1116
      --no-silent|--no-quiet)
 
1117
                        opt_silent=false
 
1118
func_append preserve_args " $opt"
 
1119
                        ;;
 
1120
      --no-warning|--no-warn)
 
1121
                        opt_warning=false
 
1122
func_append preserve_args " $opt"
 
1123
                        ;;
 
1124
      --no-verbose)
 
1125
                        opt_verbose=false
 
1126
func_append preserve_args " $opt"
 
1127
                        ;;
 
1128
      --silent|--quiet)
 
1129
                        opt_silent=:
 
1130
func_append preserve_args " $opt"
 
1131
        opt_verbose=false
 
1132
                        ;;
 
1133
      --verbose|-v)
 
1134
                        opt_verbose=:
 
1135
func_append preserve_args " $opt"
 
1136
opt_silent=false
 
1137
                        ;;
 
1138
      --tag)
 
1139
                        test $# = 0 && func_missing_arg $opt && break
 
1140
                        optarg="$1"
 
1141
                        opt_tag="$optarg"
 
1142
func_append preserve_args " $opt $optarg"
 
1143
func_enable_tag "$optarg"
 
1144
                        shift
 
1145
                        ;;
 
1146
 
 
1147
      -\?|-h)           func_usage                              ;;
 
1148
      --help)           func_help                               ;;
 
1149
      --version)        func_version                            ;;
 
1150
 
 
1151
      # Separate optargs to long options:
 
1152
      --*=*)
 
1153
                        func_split_long_opt "$opt"
 
1154
                        set dummy "$func_split_long_opt_name" "$func_split_long_opt_arg" ${1+"$@"}
 
1155
                        shift
 
1156
                        ;;
 
1157
 
 
1158
      # Separate non-argument short options:
 
1159
      -\?*|-h*|-n*|-v*)
 
1160
                        func_split_short_opt "$opt"
 
1161
                        set dummy "$func_split_short_opt_name" "-$func_split_short_opt_arg" ${1+"$@"}
 
1162
                        shift
 
1163
                        ;;
 
1164
 
 
1165
      --)               break                                   ;;
 
1166
      -*)               func_fatal_help "unrecognized option \`$opt'" ;;
 
1167
      *)                set dummy "$opt" ${1+"$@"};     shift; break  ;;
 
1168
    esac
 
1169
  done
 
1170
 
 
1171
  # Validate options:
 
1172
 
 
1173
  # save first non-option argument
 
1174
  if test "$#" -gt 0; then
 
1175
    nonopt="$opt"
 
1176
    shift
 
1177
  fi
 
1178
 
 
1179
  # preserve --debug
 
1180
  test "$opt_debug" = : || func_append preserve_args " --debug"
 
1181
 
 
1182
  case $host in
 
1183
    *cygwin* | *mingw* | *pw32* | *cegcc*)
 
1184
      # don't eliminate duplications in $postdeps and $predeps
 
1185
      opt_duplicate_compiler_generated_deps=:
 
1186
      ;;
 
1187
    *)
 
1188
      opt_duplicate_compiler_generated_deps=$opt_preserve_dup_deps
 
1189
      ;;
 
1190
  esac
 
1191
 
 
1192
  $opt_help || {
 
1193
    # Sanity checks first:
 
1194
    func_check_version_match
 
1195
 
 
1196
    if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
 
1197
      func_fatal_configuration "not configured to build any kind of library"
 
1198
    fi
 
1199
 
 
1200
    # Darwin sucks
 
1201
    eval std_shrext=\"$shrext_cmds\"
 
1202
 
 
1203
    # Only execute mode is allowed to have -dlopen flags.
 
1204
    if test -n "$opt_dlopen" && test "$opt_mode" != execute; then
 
1205
      func_error "unrecognized option \`-dlopen'"
 
1206
      $ECHO "$help" 1>&2
 
1207
      exit $EXIT_FAILURE
 
1208
    fi
 
1209
 
 
1210
    # Change the help message to a mode-specific one.
 
1211
    generic_help="$help"
 
1212
    help="Try \`$progname --help --mode=$opt_mode' for more information."
 
1213
  }
 
1214
 
 
1215
 
 
1216
  # Bail if the options were screwed
 
1217
  $exit_cmd $EXIT_FAILURE
 
1218
}
 
1219
 
 
1220
 
 
1221
 
 
1222
 
 
1223
## ----------- ##
 
1224
##    Main.    ##
 
1225
## ----------- ##
 
1226
 
 
1227
# func_lalib_p file
 
1228
# True iff FILE is a libtool `.la' library or `.lo' object file.
 
1229
# This function is only a basic sanity check; it will hardly flush out
 
1230
# determined imposters.
 
1231
func_lalib_p ()
 
1232
{
 
1233
    test -f "$1" &&
 
1234
      $SED -e 4q "$1" 2>/dev/null \
 
1235
        | $GREP "^# Generated by .*$PACKAGE" > /dev/null 2>&1
 
1236
}
 
1237
 
 
1238
# func_lalib_unsafe_p file
 
1239
# True iff FILE is a libtool `.la' library or `.lo' object file.
 
1240
# This function implements the same check as func_lalib_p without
 
1241
# resorting to external programs.  To this end, it redirects stdin and
 
1242
# closes it afterwards, without saving the original file descriptor.
 
1243
# As a safety measure, use it only where a negative result would be
 
1244
# fatal anyway.  Works if `file' does not exist.
 
1245
func_lalib_unsafe_p ()
 
1246
{
 
1247
    lalib_p=no
 
1248
    if test -f "$1" && test -r "$1" && exec 5<&0 <"$1"; then
 
1249
        for lalib_p_l in 1 2 3 4
 
1250
        do
 
1251
            read lalib_p_line
 
1252
            case "$lalib_p_line" in
 
1253
                \#\ Generated\ by\ *$PACKAGE* ) lalib_p=yes; break;;
 
1254
            esac
 
1255
        done
 
1256
        exec 0<&5 5<&-
 
1257
    fi
 
1258
    test "$lalib_p" = yes
 
1259
}
 
1260
 
 
1261
# func_ltwrapper_script_p file
 
1262
# True iff FILE is a libtool wrapper script
 
1263
# This function is only a basic sanity check; it will hardly flush out
 
1264
# determined imposters.
 
1265
func_ltwrapper_script_p ()
 
1266
{
 
1267
    func_lalib_p "$1"
 
1268
}
 
1269
 
 
1270
# func_ltwrapper_executable_p file
 
1271
# True iff FILE is a libtool wrapper executable
 
1272
# This function is only a basic sanity check; it will hardly flush out
 
1273
# determined imposters.
 
1274
func_ltwrapper_executable_p ()
 
1275
{
 
1276
    func_ltwrapper_exec_suffix=
 
1277
    case $1 in
 
1278
    *.exe) ;;
 
1279
    *) func_ltwrapper_exec_suffix=.exe ;;
 
1280
    esac
 
1281
    $GREP "$magic_exe" "$1$func_ltwrapper_exec_suffix" >/dev/null 2>&1
 
1282
}
 
1283
 
 
1284
# func_ltwrapper_scriptname file
 
1285
# Assumes file is an ltwrapper_executable
 
1286
# uses $file to determine the appropriate filename for a
 
1287
# temporary ltwrapper_script.
 
1288
func_ltwrapper_scriptname ()
 
1289
{
 
1290
    func_dirname_and_basename "$1" "" "."
 
1291
    func_stripname '' '.exe' "$func_basename_result"
 
1292
    func_ltwrapper_scriptname_result="$func_dirname_result/$objdir/${func_stripname_result}_ltshwrapper"
 
1293
}
 
1294
 
 
1295
# func_ltwrapper_p file
 
1296
# True iff FILE is a libtool wrapper script or wrapper executable
 
1297
# This function is only a basic sanity check; it will hardly flush out
 
1298
# determined imposters.
 
1299
func_ltwrapper_p ()
 
1300
{
 
1301
    func_ltwrapper_script_p "$1" || func_ltwrapper_executable_p "$1"
 
1302
}
 
1303
 
 
1304
 
 
1305
# func_execute_cmds commands fail_cmd
 
1306
# Execute tilde-delimited COMMANDS.
 
1307
# If FAIL_CMD is given, eval that upon failure.
 
1308
# FAIL_CMD may read-access the current command in variable CMD!
 
1309
func_execute_cmds ()
 
1310
{
 
1311
    $opt_debug
 
1312
    save_ifs=$IFS; IFS='~'
 
1313
    for cmd in $1; do
 
1314
      IFS=$save_ifs
 
1315
      eval cmd=\"$cmd\"
 
1316
      func_show_eval "$cmd" "${2-:}"
 
1317
    done
 
1318
    IFS=$save_ifs
 
1319
}
 
1320
 
 
1321
 
 
1322
# func_source file
 
1323
# Source FILE, adding directory component if necessary.
 
1324
# Note that it is not necessary on cygwin/mingw to append a dot to
 
1325
# FILE even if both FILE and FILE.exe exist: automatic-append-.exe
 
1326
# behavior happens only for exec(3), not for open(2)!  Also, sourcing
 
1327
# `FILE.' does not work on cygwin managed mounts.
 
1328
func_source ()
 
1329
{
 
1330
    $opt_debug
 
1331
    case $1 in
 
1332
    */* | *\\*) . "$1" ;;
 
1333
    *)          . "./$1" ;;
 
1334
    esac
 
1335
}
 
1336
 
 
1337
 
 
1338
# func_resolve_sysroot PATH
 
1339
# Replace a leading = in PATH with a sysroot.  Store the result into
 
1340
# func_resolve_sysroot_result
 
1341
func_resolve_sysroot ()
 
1342
{
 
1343
  func_resolve_sysroot_result=$1
 
1344
  case $func_resolve_sysroot_result in
 
1345
  =*)
 
1346
    func_stripname '=' '' "$func_resolve_sysroot_result"
 
1347
    func_resolve_sysroot_result=$lt_sysroot$func_stripname_result
 
1348
    ;;
 
1349
  esac
 
1350
}
 
1351
 
 
1352
# func_replace_sysroot PATH
 
1353
# If PATH begins with the sysroot, replace it with = and
 
1354
# store the result into func_replace_sysroot_result.
 
1355
func_replace_sysroot ()
 
1356
{
 
1357
  case "$lt_sysroot:$1" in
 
1358
  ?*:"$lt_sysroot"*)
 
1359
    func_stripname "$lt_sysroot" '' "$1"
 
1360
    func_replace_sysroot_result="=$func_stripname_result"
 
1361
    ;;
 
1362
  *)
 
1363
    # Including no sysroot.
 
1364
    func_replace_sysroot_result=$1
 
1365
    ;;
 
1366
  esac
 
1367
}
244
1368
 
245
1369
# func_infer_tag arg
246
1370
# Infer tagged configuration to use if any are available and
250
1374
# arg is usually of the form 'gcc ...'
251
1375
func_infer_tag ()
252
1376
{
 
1377
    $opt_debug
253
1378
    if test -n "$available_tags" && test -z "$tagname"; then
254
1379
      CC_quoted=
255
1380
      for arg in $CC; do
256
 
        case $arg in
257
 
          *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
258
 
          arg="\"$arg\""
259
 
          ;;
260
 
        esac
261
 
        CC_quoted="$CC_quoted $arg"
 
1381
        func_append_quoted CC_quoted "$arg"
262
1382
      done
 
1383
      CC_expanded=`func_echo_all $CC`
 
1384
      CC_quoted_expanded=`func_echo_all $CC_quoted`
263
1385
      case $@ in
264
1386
      # Blanks in the command may have been stripped by the calling shell,
265
1387
      # but not from the CC environment variable when configure was run.
266
 
      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
 
1388
      " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
 
1389
      " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*) ;;
267
1390
      # Blanks at the start of $base_compile will cause this to fail
268
1391
      # if we don't check for them as well.
269
1392
      *)
270
1393
        for z in $available_tags; do
271
 
          if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
 
1394
          if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
272
1395
            # Evaluate the configuration.
273
1396
            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
274
1397
            CC_quoted=
275
1398
            for arg in $CC; do
276
 
            # Double-quote args containing other shell metacharacters.
277
 
            case $arg in
278
 
              *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
279
 
              arg="\"$arg\""
280
 
              ;;
281
 
            esac
282
 
            CC_quoted="$CC_quoted $arg"
283
 
          done
 
1399
              # Double-quote args containing other shell metacharacters.
 
1400
              func_append_quoted CC_quoted "$arg"
 
1401
            done
 
1402
            CC_expanded=`func_echo_all $CC`
 
1403
            CC_quoted_expanded=`func_echo_all $CC_quoted`
284
1404
            case "$@ " in
285
 
              " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
 
1405
            " $CC "* | "$CC "* | " $CC_expanded "* | "$CC_expanded "* | \
 
1406
            " $CC_quoted"* | "$CC_quoted "* | " $CC_quoted_expanded "* | "$CC_quoted_expanded "*)
286
1407
              # The compiler in the base compile command matches
287
1408
              # the one in the tagged configuration.
288
1409
              # Assume this is the tagged configuration we want.
296
1417
        # was found and let the user know that the "--tag" command
297
1418
        # line option must be used.
298
1419
        if test -z "$tagname"; then
299
 
          $echo "$modename: unable to infer tagged configuration"
300
 
          $echo "$modename: specify a tag with \`--tag'" 1>&2
301
 
          exit $EXIT_FAILURE
302
 
#        else
303
 
#          $echo "$modename: using $tagname tagged configuration"
304
 
        fi
305
 
        ;;
306
 
      esac
307
 
    fi
308
 
}
309
 
 
310
 
 
311
 
# func_extract_an_archive dir oldlib
312
 
func_extract_an_archive ()
313
 
{
314
 
    f_ex_an_ar_dir="$1"; shift
315
 
    f_ex_an_ar_oldlib="$1"
316
 
 
317
 
    $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
318
 
    $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
319
 
    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
320
 
     :
321
 
    else
322
 
      $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
323
 
      exit $EXIT_FAILURE
324
 
    fi
325
 
}
326
 
 
327
 
# func_extract_archives gentop oldlib ...
328
 
func_extract_archives ()
329
 
{
330
 
    my_gentop="$1"; shift
331
 
    my_oldlibs=${1+"$@"}
332
 
    my_oldobjs=""
333
 
    my_xlib=""
334
 
    my_xabs=""
335
 
    my_xdir=""
336
 
    my_status=""
337
 
 
338
 
    $show "${rm}r $my_gentop"
339
 
    $run ${rm}r "$my_gentop"
340
 
    $show "$mkdir $my_gentop"
341
 
    $run $mkdir "$my_gentop"
342
 
    my_status=$?
343
 
    if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
344
 
      exit $my_status
345
 
    fi
346
 
 
347
 
    for my_xlib in $my_oldlibs; do
348
 
      # Extract the objects.
349
 
      case $my_xlib in
350
 
        [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
351
 
        *) my_xabs=`pwd`"/$my_xlib" ;;
352
 
      esac
353
 
      my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
354
 
      my_xlib_u=$my_xlib
355
 
      while :; do
356
 
        case " $extracted_archives " in
357
 
        *" $my_xlib_u "*)
358
 
          extracted_serial=`expr $extracted_serial + 1`
359
 
          my_xlib_u=lt$extracted_serial-$my_xlib ;;
360
 
        *) break ;;
361
 
        esac
362
 
      done
363
 
      extracted_archives="$extracted_archives $my_xlib_u"
364
 
      my_xdir="$my_gentop/$my_xlib_u"
365
 
 
366
 
      $show "${rm}r $my_xdir"
367
 
      $run ${rm}r "$my_xdir"
368
 
      $show "$mkdir $my_xdir"
369
 
      $run $mkdir "$my_xdir"
370
 
      exit_status=$?
371
 
      if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
372
 
        exit $exit_status
373
 
      fi
374
 
      case $host in
375
 
      *-darwin*)
376
 
        $show "Extracting $my_xabs"
377
 
        # Do not bother doing anything if just a dry run
378
 
        if test -z "$run"; then
379
 
          darwin_orig_dir=`pwd`
380
 
          cd $my_xdir || exit $?
381
 
          darwin_archive=$my_xabs
382
 
          darwin_curdir=`pwd`
383
 
          darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
384
 
          darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
385
 
          if test -n "$darwin_arches"; then 
386
 
            darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
387
 
            darwin_arch=
388
 
            $show "$darwin_base_archive has multiple architectures $darwin_arches"
389
 
            for darwin_arch in  $darwin_arches ; do
390
 
              mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
391
 
              lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
392
 
              cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
393
 
              func_extract_an_archive "`pwd`" "${darwin_base_archive}"
394
 
              cd "$darwin_curdir"
395
 
              $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
396
 
            done # $darwin_arches
397
 
      ## Okay now we have a bunch of thin objects, gotta fatten them up :)
398
 
            darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
399
 
            darwin_file=
400
 
            darwin_files=
401
 
            for darwin_file in $darwin_filelist; do
402
 
              darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
403
 
              lipo -create -output "$darwin_file" $darwin_files
404
 
            done # $darwin_filelist
405
 
            ${rm}r unfat-$$
406
 
            cd "$darwin_orig_dir"
407
 
          else
408
 
            cd "$darwin_orig_dir"
409
 
            func_extract_an_archive "$my_xdir" "$my_xabs"
410
 
          fi # $darwin_arches
411
 
        fi # $run
412
 
        ;;
413
 
      *)
414
 
        func_extract_an_archive "$my_xdir" "$my_xabs"
415
 
        ;;
416
 
      esac
417
 
      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
418
 
    done
419
 
    func_extract_archives_result="$my_oldobjs"
420
 
}
421
 
# End of Shell function definitions
422
 
#####################################
423
 
 
424
 
# Darwin sucks
425
 
eval std_shrext=\"$shrext_cmds\"
426
 
 
427
 
disable_libs=no
428
 
 
429
 
# Parse our command line options once, thoroughly.
430
 
while test "$#" -gt 0
431
 
do
432
 
  arg="$1"
433
 
  shift
434
 
 
435
 
  case $arg in
436
 
  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
437
 
  *) optarg= ;;
438
 
  esac
439
 
 
440
 
  # If the previous option needs an argument, assign it.
441
 
  if test -n "$prev"; then
442
 
    case $prev in
443
 
    execute_dlfiles)
444
 
      execute_dlfiles="$execute_dlfiles $arg"
445
 
      ;;
446
 
    tag)
447
 
      tagname="$arg"
448
 
      preserve_args="${preserve_args}=$arg"
449
 
 
450
 
      # Check whether tagname contains only valid characters
451
 
      case $tagname in
452
 
      *[!-_A-Za-z0-9,/]*)
453
 
        $echo "$progname: invalid tag name: $tagname" 1>&2
454
 
        exit $EXIT_FAILURE
455
 
        ;;
456
 
      esac
457
 
 
458
 
      case $tagname in
459
 
      CC)
460
 
        # Don't test for the "default" C tag, as we know, it's there, but
461
 
        # not specially marked.
462
 
        ;;
463
 
      *)
464
 
        if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
465
 
          taglist="$taglist $tagname"
466
 
          # Evaluate the configuration.
467
 
          eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
468
 
        else
469
 
          $echo "$progname: ignoring unknown tag $tagname" 1>&2
470
 
        fi
471
 
        ;;
472
 
      esac
473
 
      ;;
474
 
    *)
475
 
      eval "$prev=\$arg"
476
 
      ;;
477
 
    esac
478
 
 
479
 
    prev=
480
 
    prevopt=
481
 
    continue
482
 
  fi
483
 
 
484
 
  # Have we seen a non-optional argument yet?
485
 
  case $arg in
486
 
  --help)
487
 
    show_help=yes
488
 
    ;;
489
 
 
490
 
  --version)
491
 
    echo "\
492
 
$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP
493
 
 
494
 
Copyright (C) 2008  Free Software Foundation, Inc.
495
 
This is free software; see the source for copying conditions.  There is NO
496
 
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
497
 
    exit $?
498
 
    ;;
499
 
 
500
 
  --config)
501
 
    ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
502
 
    # Now print the configurations for the tags.
503
 
    for tagname in $taglist; do
504
 
      ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
505
 
    done
506
 
    exit $?
507
 
    ;;
508
 
 
509
 
  --debug)
510
 
    $echo "$progname: enabling shell trace mode"
511
 
    set -x
512
 
    preserve_args="$preserve_args $arg"
513
 
    ;;
514
 
 
515
 
  --dry-run | -n)
516
 
    run=:
517
 
    ;;
518
 
 
519
 
  --features)
520
 
    $echo "host: $host"
 
1420
          func_echo "unable to infer tagged configuration"
 
1421
          func_fatal_error "specify a tag with \`--tag'"
 
1422
#       else
 
1423
#         func_verbose "using $tagname tagged configuration"
 
1424
        fi
 
1425
        ;;
 
1426
      esac
 
1427
    fi
 
1428
}
 
1429
 
 
1430
 
 
1431
 
 
1432
# func_write_libtool_object output_name pic_name nonpic_name
 
1433
# Create a libtool object file (analogous to a ".la" file),
 
1434
# but don't create it if we're doing a dry run.
 
1435
func_write_libtool_object ()
 
1436
{
 
1437
    write_libobj=${1}
521
1438
    if test "$build_libtool_libs" = yes; then
522
 
      $echo "enable shared libraries"
 
1439
      write_lobj=\'${2}\'
523
1440
    else
524
 
      $echo "disable shared libraries"
 
1441
      write_lobj=none
525
1442
    fi
 
1443
 
526
1444
    if test "$build_old_libs" = yes; then
527
 
      $echo "enable static libraries"
528
 
    else
529
 
      $echo "disable static libraries"
530
 
    fi
531
 
    exit $?
532
 
    ;;
533
 
 
534
 
  --finish) mode="finish" ;;
535
 
 
536
 
  --mode) prevopt="--mode" prev=mode ;;
537
 
  --mode=*) mode="$optarg" ;;
538
 
 
539
 
  --preserve-dup-deps) duplicate_deps="yes" ;;
540
 
 
541
 
  --quiet | --silent)
542
 
    show=:
543
 
    preserve_args="$preserve_args $arg"
544
 
    ;;
545
 
 
546
 
  --tag)
547
 
    prevopt="--tag"
548
 
    prev=tag
549
 
    preserve_args="$preserve_args --tag"
550
 
    ;;
551
 
  --tag=*)
552
 
    set tag "$optarg" ${1+"$@"}
553
 
    shift
554
 
    prev=tag
555
 
    preserve_args="$preserve_args --tag"
556
 
    ;;
557
 
 
558
 
  -dlopen)
559
 
    prevopt="-dlopen"
560
 
    prev=execute_dlfiles
561
 
    ;;
562
 
 
563
 
  -*)
564
 
    $echo "$modename: unrecognized option \`$arg'" 1>&2
565
 
    $echo "$help" 1>&2
566
 
    exit $EXIT_FAILURE
567
 
    ;;
568
 
 
569
 
  *)
570
 
    nonopt="$arg"
571
 
    break
572
 
    ;;
573
 
  esac
574
 
done
575
 
 
576
 
if test -n "$prevopt"; then
577
 
  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
578
 
  $echo "$help" 1>&2
579
 
  exit $EXIT_FAILURE
580
 
fi
581
 
 
582
 
case $disable_libs in
583
 
no) 
584
 
  ;;
585
 
shared)
586
 
  build_libtool_libs=no
587
 
  build_old_libs=yes
588
 
  ;;
589
 
static)
590
 
  build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
591
 
  ;;
592
 
esac
593
 
 
594
 
# If this variable is set in any of the actions, the command in it
595
 
# will be execed at the end.  This prevents here-documents from being
596
 
# left over by shells.
597
 
exec_cmd=
598
 
 
599
 
if test -z "$show_help"; then
600
 
 
601
 
  # Infer the operation mode.
602
 
  if test -z "$mode"; then
603
 
    $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
604
 
    $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
605
 
    case $nonopt in
606
 
    *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
607
 
      mode=link
608
 
      for arg
609
 
      do
610
 
        case $arg in
611
 
        -c)
612
 
           mode=compile
613
 
           break
614
 
           ;;
615
 
        esac
616
 
      done
617
 
      ;;
618
 
    *db | *dbx | *strace | *truss)
619
 
      mode=execute
620
 
      ;;
621
 
    *install*|cp|mv)
622
 
      mode=install
623
 
      ;;
624
 
    *rm)
625
 
      mode=uninstall
 
1445
      write_oldobj=\'${3}\'
 
1446
    else
 
1447
      write_oldobj=none
 
1448
    fi
 
1449
 
 
1450
    $opt_dry_run || {
 
1451
      cat >${write_libobj}T <<EOF
 
1452
# $write_libobj - a libtool object file
 
1453
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
 
1454
#
 
1455
# Please DO NOT delete this file!
 
1456
# It is necessary for linking the library.
 
1457
 
 
1458
# Name of the PIC object.
 
1459
pic_object=$write_lobj
 
1460
 
 
1461
# Name of the non-PIC object
 
1462
non_pic_object=$write_oldobj
 
1463
 
 
1464
EOF
 
1465
      $MV "${write_libobj}T" "${write_libobj}"
 
1466
    }
 
1467
}
 
1468
 
 
1469
 
 
1470
##################################################
 
1471
# FILE NAME AND PATH CONVERSION HELPER FUNCTIONS #
 
1472
##################################################
 
1473
 
 
1474
# func_convert_core_file_wine_to_w32 ARG
 
1475
# Helper function used by file name conversion functions when $build is *nix,
 
1476
# and $host is mingw, cygwin, or some other w32 environment. Relies on a
 
1477
# correctly configured wine environment available, with the winepath program
 
1478
# in $build's $PATH.
 
1479
#
 
1480
# ARG is the $build file name to be converted to w32 format.
 
1481
# Result is available in $func_convert_core_file_wine_to_w32_result, and will
 
1482
# be empty on error (or when ARG is empty)
 
1483
func_convert_core_file_wine_to_w32 ()
 
1484
{
 
1485
  $opt_debug
 
1486
  func_convert_core_file_wine_to_w32_result="$1"
 
1487
  if test -n "$1"; then
 
1488
    # Unfortunately, winepath does not exit with a non-zero error code, so we
 
1489
    # are forced to check the contents of stdout. On the other hand, if the
 
1490
    # command is not found, the shell will set an exit code of 127 and print
 
1491
    # *an error message* to stdout. So we must check for both error code of
 
1492
    # zero AND non-empty stdout, which explains the odd construction:
 
1493
    func_convert_core_file_wine_to_w32_tmp=`winepath -w "$1" 2>/dev/null`
 
1494
    if test "$?" -eq 0 && test -n "${func_convert_core_file_wine_to_w32_tmp}"; then
 
1495
      func_convert_core_file_wine_to_w32_result=`$ECHO "$func_convert_core_file_wine_to_w32_tmp" |
 
1496
        $SED -e "$lt_sed_naive_backslashify"`
 
1497
    else
 
1498
      func_convert_core_file_wine_to_w32_result=
 
1499
    fi
 
1500
  fi
 
1501
}
 
1502
# end: func_convert_core_file_wine_to_w32
 
1503
 
 
1504
 
 
1505
# func_convert_core_path_wine_to_w32 ARG
 
1506
# Helper function used by path conversion functions when $build is *nix, and
 
1507
# $host is mingw, cygwin, or some other w32 environment. Relies on a correctly
 
1508
# configured wine environment available, with the winepath program in $build's
 
1509
# $PATH. Assumes ARG has no leading or trailing path separator characters.
 
1510
#
 
1511
# ARG is path to be converted from $build format to win32.
 
1512
# Result is available in $func_convert_core_path_wine_to_w32_result.
 
1513
# Unconvertible file (directory) names in ARG are skipped; if no directory names
 
1514
# are convertible, then the result may be empty.
 
1515
func_convert_core_path_wine_to_w32 ()
 
1516
{
 
1517
  $opt_debug
 
1518
  # unfortunately, winepath doesn't convert paths, only file names
 
1519
  func_convert_core_path_wine_to_w32_result=""
 
1520
  if test -n "$1"; then
 
1521
    oldIFS=$IFS
 
1522
    IFS=:
 
1523
    for func_convert_core_path_wine_to_w32_f in $1; do
 
1524
      IFS=$oldIFS
 
1525
      func_convert_core_file_wine_to_w32 "$func_convert_core_path_wine_to_w32_f"
 
1526
      if test -n "$func_convert_core_file_wine_to_w32_result" ; then
 
1527
        if test -z "$func_convert_core_path_wine_to_w32_result"; then
 
1528
          func_convert_core_path_wine_to_w32_result="$func_convert_core_file_wine_to_w32_result"
 
1529
        else
 
1530
          func_append func_convert_core_path_wine_to_w32_result ";$func_convert_core_file_wine_to_w32_result"
 
1531
        fi
 
1532
      fi
 
1533
    done
 
1534
    IFS=$oldIFS
 
1535
  fi
 
1536
}
 
1537
# end: func_convert_core_path_wine_to_w32
 
1538
 
 
1539
 
 
1540
# func_cygpath ARGS...
 
1541
# Wrapper around calling the cygpath program via LT_CYGPATH. This is used when
 
1542
# when (1) $build is *nix and Cygwin is hosted via a wine environment; or (2)
 
1543
# $build is MSYS and $host is Cygwin, or (3) $build is Cygwin. In case (1) or
 
1544
# (2), returns the Cygwin file name or path in func_cygpath_result (input
 
1545
# file name or path is assumed to be in w32 format, as previously converted
 
1546
# from $build's *nix or MSYS format). In case (3), returns the w32 file name
 
1547
# or path in func_cygpath_result (input file name or path is assumed to be in
 
1548
# Cygwin format). Returns an empty string on error.
 
1549
#
 
1550
# ARGS are passed to cygpath, with the last one being the file name or path to
 
1551
# be converted.
 
1552
#
 
1553
# Specify the absolute *nix (or w32) name to cygpath in the LT_CYGPATH
 
1554
# environment variable; do not put it in $PATH.
 
1555
func_cygpath ()
 
1556
{
 
1557
  $opt_debug
 
1558
  if test -n "$LT_CYGPATH" && test -f "$LT_CYGPATH"; then
 
1559
    func_cygpath_result=`$LT_CYGPATH "$@" 2>/dev/null`
 
1560
    if test "$?" -ne 0; then
 
1561
      # on failure, ensure result is empty
 
1562
      func_cygpath_result=
 
1563
    fi
 
1564
  else
 
1565
    func_cygpath_result=
 
1566
    func_error "LT_CYGPATH is empty or specifies non-existent file: \`$LT_CYGPATH'"
 
1567
  fi
 
1568
}
 
1569
#end: func_cygpath
 
1570
 
 
1571
 
 
1572
# func_convert_core_msys_to_w32 ARG
 
1573
# Convert file name or path ARG from MSYS format to w32 format.  Return
 
1574
# result in func_convert_core_msys_to_w32_result.
 
1575
func_convert_core_msys_to_w32 ()
 
1576
{
 
1577
  $opt_debug
 
1578
  # awkward: cmd appends spaces to result
 
1579
  func_convert_core_msys_to_w32_result=`( cmd //c echo "$1" ) 2>/dev/null |
 
1580
    $SED -e 's/[ ]*$//' -e "$lt_sed_naive_backslashify"`
 
1581
}
 
1582
#end: func_convert_core_msys_to_w32
 
1583
 
 
1584
 
 
1585
# func_convert_file_check ARG1 ARG2
 
1586
# Verify that ARG1 (a file name in $build format) was converted to $host
 
1587
# format in ARG2. Otherwise, emit an error message, but continue (resetting
 
1588
# func_to_host_file_result to ARG1).
 
1589
func_convert_file_check ()
 
1590
{
 
1591
  $opt_debug
 
1592
  if test -z "$2" && test -n "$1" ; then
 
1593
    func_error "Could not determine host file name corresponding to"
 
1594
    func_error "  \`$1'"
 
1595
    func_error "Continuing, but uninstalled executables may not work."
 
1596
    # Fallback:
 
1597
    func_to_host_file_result="$1"
 
1598
  fi
 
1599
}
 
1600
# end func_convert_file_check
 
1601
 
 
1602
 
 
1603
# func_convert_path_check FROM_PATHSEP TO_PATHSEP FROM_PATH TO_PATH
 
1604
# Verify that FROM_PATH (a path in $build format) was converted to $host
 
1605
# format in TO_PATH. Otherwise, emit an error message, but continue, resetting
 
1606
# func_to_host_file_result to a simplistic fallback value (see below).
 
1607
func_convert_path_check ()
 
1608
{
 
1609
  $opt_debug
 
1610
  if test -z "$4" && test -n "$3"; then
 
1611
    func_error "Could not determine the host path corresponding to"
 
1612
    func_error "  \`$3'"
 
1613
    func_error "Continuing, but uninstalled executables may not work."
 
1614
    # Fallback.  This is a deliberately simplistic "conversion" and
 
1615
    # should not be "improved".  See libtool.info.
 
1616
    if test "x$1" != "x$2"; then
 
1617
      lt_replace_pathsep_chars="s|$1|$2|g"
 
1618
      func_to_host_path_result=`echo "$3" |
 
1619
        $SED -e "$lt_replace_pathsep_chars"`
 
1620
    else
 
1621
      func_to_host_path_result="$3"
 
1622
    fi
 
1623
  fi
 
1624
}
 
1625
# end func_convert_path_check
 
1626
 
 
1627
 
 
1628
# func_convert_path_front_back_pathsep FRONTPAT BACKPAT REPL ORIG
 
1629
# Modifies func_to_host_path_result by prepending REPL if ORIG matches FRONTPAT
 
1630
# and appending REPL if ORIG matches BACKPAT.
 
1631
func_convert_path_front_back_pathsep ()
 
1632
{
 
1633
  $opt_debug
 
1634
  case $4 in
 
1635
  $1 ) func_to_host_path_result="$3$func_to_host_path_result"
 
1636
    ;;
 
1637
  esac
 
1638
  case $4 in
 
1639
  $2 ) func_append func_to_host_path_result "$3"
 
1640
    ;;
 
1641
  esac
 
1642
}
 
1643
# end func_convert_path_front_back_pathsep
 
1644
 
 
1645
 
 
1646
##################################################
 
1647
# $build to $host FILE NAME CONVERSION FUNCTIONS #
 
1648
##################################################
 
1649
# invoked via `$to_host_file_cmd ARG'
 
1650
#
 
1651
# In each case, ARG is the path to be converted from $build to $host format.
 
1652
# Result will be available in $func_to_host_file_result.
 
1653
 
 
1654
 
 
1655
# func_to_host_file ARG
 
1656
# Converts the file name ARG from $build format to $host format. Return result
 
1657
# in func_to_host_file_result.
 
1658
func_to_host_file ()
 
1659
{
 
1660
  $opt_debug
 
1661
  $to_host_file_cmd "$1"
 
1662
}
 
1663
# end func_to_host_file
 
1664
 
 
1665
 
 
1666
# func_to_tool_file ARG LAZY
 
1667
# converts the file name ARG from $build format to toolchain format. Return
 
1668
# result in func_to_tool_file_result.  If the conversion in use is listed
 
1669
# in (the comma separated) LAZY, no conversion takes place.
 
1670
func_to_tool_file ()
 
1671
{
 
1672
  $opt_debug
 
1673
  case ,$2, in
 
1674
    *,"$to_tool_file_cmd",*)
 
1675
      func_to_tool_file_result=$1
626
1676
      ;;
627
1677
    *)
628
 
      # If we have no mode, but dlfiles were specified, then do execute mode.
629
 
      test -n "$execute_dlfiles" && mode=execute
630
 
 
631
 
      # Just use the default operation mode.
632
 
      if test -z "$mode"; then
633
 
        if test -n "$nonopt"; then
634
 
          $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
635
 
        else
636
 
          $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
637
 
        fi
638
 
      fi
 
1678
      $to_tool_file_cmd "$1"
 
1679
      func_to_tool_file_result=$func_to_host_file_result
639
1680
      ;;
640
 
    esac
641
 
  fi
642
 
 
643
 
  # Only execute mode is allowed to have -dlopen flags.
644
 
  if test -n "$execute_dlfiles" && test "$mode" != execute; then
645
 
    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
646
 
    $echo "$help" 1>&2
647
 
    exit $EXIT_FAILURE
648
 
  fi
649
 
 
650
 
  # Change the help message to a mode-specific one.
651
 
  generic_help="$help"
652
 
  help="Try \`$modename --help --mode=$mode' for more information."
653
 
 
654
 
  # These modes are in order of execution frequency so that they run quickly.
655
 
  case $mode in
656
 
  # libtool compile mode
657
 
  compile)
658
 
    modename="$modename: compile"
 
1681
  esac
 
1682
}
 
1683
# end func_to_tool_file
 
1684
 
 
1685
 
 
1686
# func_convert_file_noop ARG
 
1687
# Copy ARG to func_to_host_file_result.
 
1688
func_convert_file_noop ()
 
1689
{
 
1690
  func_to_host_file_result="$1"
 
1691
}
 
1692
# end func_convert_file_noop
 
1693
 
 
1694
 
 
1695
# func_convert_file_msys_to_w32 ARG
 
1696
# Convert file name ARG from (mingw) MSYS to (mingw) w32 format; automatic
 
1697
# conversion to w32 is not available inside the cwrapper.  Returns result in
 
1698
# func_to_host_file_result.
 
1699
func_convert_file_msys_to_w32 ()
 
1700
{
 
1701
  $opt_debug
 
1702
  func_to_host_file_result="$1"
 
1703
  if test -n "$1"; then
 
1704
    func_convert_core_msys_to_w32 "$1"
 
1705
    func_to_host_file_result="$func_convert_core_msys_to_w32_result"
 
1706
  fi
 
1707
  func_convert_file_check "$1" "$func_to_host_file_result"
 
1708
}
 
1709
# end func_convert_file_msys_to_w32
 
1710
 
 
1711
 
 
1712
# func_convert_file_cygwin_to_w32 ARG
 
1713
# Convert file name ARG from Cygwin to w32 format.  Returns result in
 
1714
# func_to_host_file_result.
 
1715
func_convert_file_cygwin_to_w32 ()
 
1716
{
 
1717
  $opt_debug
 
1718
  func_to_host_file_result="$1"
 
1719
  if test -n "$1"; then
 
1720
    # because $build is cygwin, we call "the" cygpath in $PATH; no need to use
 
1721
    # LT_CYGPATH in this case.
 
1722
    func_to_host_file_result=`cygpath -m "$1"`
 
1723
  fi
 
1724
  func_convert_file_check "$1" "$func_to_host_file_result"
 
1725
}
 
1726
# end func_convert_file_cygwin_to_w32
 
1727
 
 
1728
 
 
1729
# func_convert_file_nix_to_w32 ARG
 
1730
# Convert file name ARG from *nix to w32 format.  Requires a wine environment
 
1731
# and a working winepath. Returns result in func_to_host_file_result.
 
1732
func_convert_file_nix_to_w32 ()
 
1733
{
 
1734
  $opt_debug
 
1735
  func_to_host_file_result="$1"
 
1736
  if test -n "$1"; then
 
1737
    func_convert_core_file_wine_to_w32 "$1"
 
1738
    func_to_host_file_result="$func_convert_core_file_wine_to_w32_result"
 
1739
  fi
 
1740
  func_convert_file_check "$1" "$func_to_host_file_result"
 
1741
}
 
1742
# end func_convert_file_nix_to_w32
 
1743
 
 
1744
 
 
1745
# func_convert_file_msys_to_cygwin ARG
 
1746
# Convert file name ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
 
1747
# Returns result in func_to_host_file_result.
 
1748
func_convert_file_msys_to_cygwin ()
 
1749
{
 
1750
  $opt_debug
 
1751
  func_to_host_file_result="$1"
 
1752
  if test -n "$1"; then
 
1753
    func_convert_core_msys_to_w32 "$1"
 
1754
    func_cygpath -u "$func_convert_core_msys_to_w32_result"
 
1755
    func_to_host_file_result="$func_cygpath_result"
 
1756
  fi
 
1757
  func_convert_file_check "$1" "$func_to_host_file_result"
 
1758
}
 
1759
# end func_convert_file_msys_to_cygwin
 
1760
 
 
1761
 
 
1762
# func_convert_file_nix_to_cygwin ARG
 
1763
# Convert file name ARG from *nix to Cygwin format.  Requires Cygwin installed
 
1764
# in a wine environment, working winepath, and LT_CYGPATH set.  Returns result
 
1765
# in func_to_host_file_result.
 
1766
func_convert_file_nix_to_cygwin ()
 
1767
{
 
1768
  $opt_debug
 
1769
  func_to_host_file_result="$1"
 
1770
  if test -n "$1"; then
 
1771
    # convert from *nix to w32, then use cygpath to convert from w32 to cygwin.
 
1772
    func_convert_core_file_wine_to_w32 "$1"
 
1773
    func_cygpath -u "$func_convert_core_file_wine_to_w32_result"
 
1774
    func_to_host_file_result="$func_cygpath_result"
 
1775
  fi
 
1776
  func_convert_file_check "$1" "$func_to_host_file_result"
 
1777
}
 
1778
# end func_convert_file_nix_to_cygwin
 
1779
 
 
1780
 
 
1781
#############################################
 
1782
# $build to $host PATH CONVERSION FUNCTIONS #
 
1783
#############################################
 
1784
# invoked via `$to_host_path_cmd ARG'
 
1785
#
 
1786
# In each case, ARG is the path to be converted from $build to $host format.
 
1787
# The result will be available in $func_to_host_path_result.
 
1788
#
 
1789
# Path separators are also converted from $build format to $host format.  If
 
1790
# ARG begins or ends with a path separator character, it is preserved (but
 
1791
# converted to $host format) on output.
 
1792
#
 
1793
# All path conversion functions are named using the following convention:
 
1794
#   file name conversion function    : func_convert_file_X_to_Y ()
 
1795
#   path conversion function         : func_convert_path_X_to_Y ()
 
1796
# where, for any given $build/$host combination the 'X_to_Y' value is the
 
1797
# same.  If conversion functions are added for new $build/$host combinations,
 
1798
# the two new functions must follow this pattern, or func_init_to_host_path_cmd
 
1799
# will break.
 
1800
 
 
1801
 
 
1802
# func_init_to_host_path_cmd
 
1803
# Ensures that function "pointer" variable $to_host_path_cmd is set to the
 
1804
# appropriate value, based on the value of $to_host_file_cmd.
 
1805
to_host_path_cmd=
 
1806
func_init_to_host_path_cmd ()
 
1807
{
 
1808
  $opt_debug
 
1809
  if test -z "$to_host_path_cmd"; then
 
1810
    func_stripname 'func_convert_file_' '' "$to_host_file_cmd"
 
1811
    to_host_path_cmd="func_convert_path_${func_stripname_result}"
 
1812
  fi
 
1813
}
 
1814
 
 
1815
 
 
1816
# func_to_host_path ARG
 
1817
# Converts the path ARG from $build format to $host format. Return result
 
1818
# in func_to_host_path_result.
 
1819
func_to_host_path ()
 
1820
{
 
1821
  $opt_debug
 
1822
  func_init_to_host_path_cmd
 
1823
  $to_host_path_cmd "$1"
 
1824
}
 
1825
# end func_to_host_path
 
1826
 
 
1827
 
 
1828
# func_convert_path_noop ARG
 
1829
# Copy ARG to func_to_host_path_result.
 
1830
func_convert_path_noop ()
 
1831
{
 
1832
  func_to_host_path_result="$1"
 
1833
}
 
1834
# end func_convert_path_noop
 
1835
 
 
1836
 
 
1837
# func_convert_path_msys_to_w32 ARG
 
1838
# Convert path ARG from (mingw) MSYS to (mingw) w32 format; automatic
 
1839
# conversion to w32 is not available inside the cwrapper.  Returns result in
 
1840
# func_to_host_path_result.
 
1841
func_convert_path_msys_to_w32 ()
 
1842
{
 
1843
  $opt_debug
 
1844
  func_to_host_path_result="$1"
 
1845
  if test -n "$1"; then
 
1846
    # Remove leading and trailing path separator characters from ARG.  MSYS
 
1847
    # behavior is inconsistent here; cygpath turns them into '.;' and ';.';
 
1848
    # and winepath ignores them completely.
 
1849
    func_stripname : : "$1"
 
1850
    func_to_host_path_tmp1=$func_stripname_result
 
1851
    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
 
1852
    func_to_host_path_result="$func_convert_core_msys_to_w32_result"
 
1853
    func_convert_path_check : ";" \
 
1854
      "$func_to_host_path_tmp1" "$func_to_host_path_result"
 
1855
    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
 
1856
  fi
 
1857
}
 
1858
# end func_convert_path_msys_to_w32
 
1859
 
 
1860
 
 
1861
# func_convert_path_cygwin_to_w32 ARG
 
1862
# Convert path ARG from Cygwin to w32 format.  Returns result in
 
1863
# func_to_host_file_result.
 
1864
func_convert_path_cygwin_to_w32 ()
 
1865
{
 
1866
  $opt_debug
 
1867
  func_to_host_path_result="$1"
 
1868
  if test -n "$1"; then
 
1869
    # See func_convert_path_msys_to_w32:
 
1870
    func_stripname : : "$1"
 
1871
    func_to_host_path_tmp1=$func_stripname_result
 
1872
    func_to_host_path_result=`cygpath -m -p "$func_to_host_path_tmp1"`
 
1873
    func_convert_path_check : ";" \
 
1874
      "$func_to_host_path_tmp1" "$func_to_host_path_result"
 
1875
    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
 
1876
  fi
 
1877
}
 
1878
# end func_convert_path_cygwin_to_w32
 
1879
 
 
1880
 
 
1881
# func_convert_path_nix_to_w32 ARG
 
1882
# Convert path ARG from *nix to w32 format.  Requires a wine environment and
 
1883
# a working winepath.  Returns result in func_to_host_file_result.
 
1884
func_convert_path_nix_to_w32 ()
 
1885
{
 
1886
  $opt_debug
 
1887
  func_to_host_path_result="$1"
 
1888
  if test -n "$1"; then
 
1889
    # See func_convert_path_msys_to_w32:
 
1890
    func_stripname : : "$1"
 
1891
    func_to_host_path_tmp1=$func_stripname_result
 
1892
    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
 
1893
    func_to_host_path_result="$func_convert_core_path_wine_to_w32_result"
 
1894
    func_convert_path_check : ";" \
 
1895
      "$func_to_host_path_tmp1" "$func_to_host_path_result"
 
1896
    func_convert_path_front_back_pathsep ":*" "*:" ";" "$1"
 
1897
  fi
 
1898
}
 
1899
# end func_convert_path_nix_to_w32
 
1900
 
 
1901
 
 
1902
# func_convert_path_msys_to_cygwin ARG
 
1903
# Convert path ARG from MSYS to Cygwin format.  Requires LT_CYGPATH set.
 
1904
# Returns result in func_to_host_file_result.
 
1905
func_convert_path_msys_to_cygwin ()
 
1906
{
 
1907
  $opt_debug
 
1908
  func_to_host_path_result="$1"
 
1909
  if test -n "$1"; then
 
1910
    # See func_convert_path_msys_to_w32:
 
1911
    func_stripname : : "$1"
 
1912
    func_to_host_path_tmp1=$func_stripname_result
 
1913
    func_convert_core_msys_to_w32 "$func_to_host_path_tmp1"
 
1914
    func_cygpath -u -p "$func_convert_core_msys_to_w32_result"
 
1915
    func_to_host_path_result="$func_cygpath_result"
 
1916
    func_convert_path_check : : \
 
1917
      "$func_to_host_path_tmp1" "$func_to_host_path_result"
 
1918
    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
 
1919
  fi
 
1920
}
 
1921
# end func_convert_path_msys_to_cygwin
 
1922
 
 
1923
 
 
1924
# func_convert_path_nix_to_cygwin ARG
 
1925
# Convert path ARG from *nix to Cygwin format.  Requires Cygwin installed in a
 
1926
# a wine environment, working winepath, and LT_CYGPATH set.  Returns result in
 
1927
# func_to_host_file_result.
 
1928
func_convert_path_nix_to_cygwin ()
 
1929
{
 
1930
  $opt_debug
 
1931
  func_to_host_path_result="$1"
 
1932
  if test -n "$1"; then
 
1933
    # Remove leading and trailing path separator characters from
 
1934
    # ARG. msys behavior is inconsistent here, cygpath turns them
 
1935
    # into '.;' and ';.', and winepath ignores them completely.
 
1936
    func_stripname : : "$1"
 
1937
    func_to_host_path_tmp1=$func_stripname_result
 
1938
    func_convert_core_path_wine_to_w32 "$func_to_host_path_tmp1"
 
1939
    func_cygpath -u -p "$func_convert_core_path_wine_to_w32_result"
 
1940
    func_to_host_path_result="$func_cygpath_result"
 
1941
    func_convert_path_check : : \
 
1942
      "$func_to_host_path_tmp1" "$func_to_host_path_result"
 
1943
    func_convert_path_front_back_pathsep ":*" "*:" : "$1"
 
1944
  fi
 
1945
}
 
1946
# end func_convert_path_nix_to_cygwin
 
1947
 
 
1948
 
 
1949
# func_mode_compile arg...
 
1950
func_mode_compile ()
 
1951
{
 
1952
    $opt_debug
659
1953
    # Get the compilation command and the source file.
660
1954
    base_compile=
661
1955
    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
664
1958
    arg_mode=normal
665
1959
    libobj=
666
1960
    later=
 
1961
    pie_flag=
667
1962
 
668
1963
    for arg
669
1964
    do
684
1979
        # Accept any command-line options.
685
1980
        case $arg in
686
1981
        -o)
687
 
          if test -n "$libobj" ; then
688
 
            $echo "$modename: you cannot specify \`-o' more than once" 1>&2
689
 
            exit $EXIT_FAILURE
690
 
          fi
 
1982
          test -n "$libobj" && \
 
1983
            func_fatal_error "you cannot specify \`-o' more than once"
691
1984
          arg_mode=target
692
1985
          continue
693
1986
          ;;
694
1987
 
695
 
        -static | -prefer-pic | -prefer-non-pic)
696
 
          later="$later $arg"
 
1988
        -pie | -fpie | -fPIE)
 
1989
          func_append pie_flag " $arg"
 
1990
          continue
 
1991
          ;;
 
1992
 
 
1993
        -shared | -static | -prefer-pic | -prefer-non-pic)
 
1994
          func_append later " $arg"
697
1995
          continue
698
1996
          ;;
699
1997
 
708
2006
          ;;            #  replaced later.  I would guess that would be a bug.
709
2007
 
710
2008
        -Wc,*)
711
 
          args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
 
2009
          func_stripname '-Wc,' '' "$arg"
 
2010
          args=$func_stripname_result
712
2011
          lastarg=
713
2012
          save_ifs="$IFS"; IFS=','
714
 
          for arg in $args; do
 
2013
          for arg in $args; do
715
2014
            IFS="$save_ifs"
716
 
 
717
 
            # Double-quote args containing other shell metacharacters.
718
 
            # Many Bourne shells cannot handle close brackets correctly
719
 
            # in scan sets, so we specify it separately.
720
 
            case $arg in
721
 
              *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
722
 
              arg="\"$arg\""
723
 
              ;;
724
 
            esac
725
 
            lastarg="$lastarg $arg"
 
2015
            func_append_quoted lastarg "$arg"
726
2016
          done
727
2017
          IFS="$save_ifs"
728
 
          lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
 
2018
          func_stripname ' ' '' "$lastarg"
 
2019
          lastarg=$func_stripname_result
729
2020
 
730
2021
          # Add the arguments to base_compile.
731
 
          base_compile="$base_compile $lastarg"
 
2022
          func_append base_compile " $lastarg"
732
2023
          continue
733
2024
          ;;
734
2025
 
735
 
        * )
 
2026
        *)
736
2027
          # Accept the current argument as the source file.
737
2028
          # The previous "srcfile" becomes the current argument.
738
2029
          #
744
2035
      esac    #  case $arg_mode
745
2036
 
746
2037
      # Aesthetically quote the previous argument.
747
 
      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
748
 
 
749
 
      case $lastarg in
750
 
      # Double-quote args containing other shell metacharacters.
751
 
      # Many Bourne shells cannot handle close brackets correctly
752
 
      # in scan sets, and some SunOS ksh mistreat backslash-escaping
753
 
      # in scan sets (worked around with variable expansion),
754
 
      # and furthermore cannot handle '|' '&' '(' ')' in scan sets 
755
 
      # at all, so we specify them separately.
756
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
757
 
        lastarg="\"$lastarg\""
758
 
        ;;
759
 
      esac
760
 
 
761
 
      base_compile="$base_compile $lastarg"
 
2038
      func_append_quoted base_compile "$lastarg"
762
2039
    done # for arg
763
2040
 
764
2041
    case $arg_mode in
765
2042
    arg)
766
 
      $echo "$modename: you must specify an argument for -Xcompile"
767
 
      exit $EXIT_FAILURE
 
2043
      func_fatal_error "you must specify an argument for -Xcompile"
768
2044
      ;;
769
2045
    target)
770
 
      $echo "$modename: you must specify a target with \`-o'" 1>&2
771
 
      exit $EXIT_FAILURE
 
2046
      func_fatal_error "you must specify a target with \`-o'"
772
2047
      ;;
773
2048
    *)
774
2049
      # Get the name of the library object.
775
 
      [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
 
2050
      test -z "$libobj" && {
 
2051
        func_basename "$srcfile"
 
2052
        libobj="$func_basename_result"
 
2053
      }
776
2054
      ;;
777
2055
    esac
778
2056
 
779
2057
    # Recognize several different file suffixes.
780
2058
    # If the user specifies -o file.o, it is replaced with file.lo
781
 
    xform='[cCFSifmso]'
782
2059
    case $libobj in
783
 
    *.ada) xform=ada ;;
784
 
    *.adb) xform=adb ;;
785
 
    *.ads) xform=ads ;;
786
 
    *.asm) xform=asm ;;
787
 
    *.c++) xform=c++ ;;
788
 
    *.cc) xform=cc ;;
789
 
    *.ii) xform=ii ;;
790
 
    *.class) xform=class ;;
791
 
    *.cpp) xform=cpp ;;
792
 
    *.cxx) xform=cxx ;;
793
 
    *.[fF][09]?) xform=[fF][09]. ;;
794
 
    *.for) xform=for ;;
795
 
    *.java) xform=java ;;
796
 
    *.obj) xform=obj ;;
797
 
    *.sx) xform=sx ;;
 
2060
    *.[cCFSifmso] | \
 
2061
    *.ada | *.adb | *.ads | *.asm | \
 
2062
    *.c++ | *.cc | *.ii | *.class | *.cpp | *.cxx | \
 
2063
    *.[fF][09]? | *.for | *.java | *.go | *.obj | *.sx | *.cu | *.cup)
 
2064
      func_xform "$libobj"
 
2065
      libobj=$func_xform_result
 
2066
      ;;
798
2067
    esac
799
2068
 
800
 
    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
801
 
 
802
2069
    case $libobj in
803
 
    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
 
2070
    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
804
2071
    *)
805
 
      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
806
 
      exit $EXIT_FAILURE
 
2072
      func_fatal_error "cannot determine name of library object from \`$libobj'"
807
2073
      ;;
808
2074
    esac
809
2075
 
811
2077
 
812
2078
    for arg in $later; do
813
2079
      case $arg in
 
2080
      -shared)
 
2081
        test "$build_libtool_libs" != yes && \
 
2082
          func_fatal_configuration "can not build a shared library"
 
2083
        build_old_libs=no
 
2084
        continue
 
2085
        ;;
 
2086
 
814
2087
      -static)
 
2088
        build_libtool_libs=no
815
2089
        build_old_libs=yes
816
2090
        continue
817
2091
        ;;
828
2102
      esac
829
2103
    done
830
2104
 
831
 
    qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
832
 
    case $qlibobj in
833
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
834
 
        qlibobj="\"$qlibobj\"" ;;
835
 
    esac
836
 
    test "X$libobj" != "X$qlibobj" \
837
 
        && $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"'  &()|`$[]' \
838
 
        && $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
839
 
    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
840
 
    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
841
 
    if test "X$xdir" = "X$obj"; then
842
 
      xdir=
843
 
    else
844
 
      xdir=$xdir/
845
 
    fi
 
2105
    func_quote_for_eval "$libobj"
 
2106
    test "X$libobj" != "X$func_quote_for_eval_result" \
 
2107
      && $ECHO "X$libobj" | $GREP '[]~#^*{};<>?"'"'"'    &()|`$[]' \
 
2108
      && func_warning "libobj name \`$libobj' may not contain shell special characters."
 
2109
    func_dirname_and_basename "$obj" "/" ""
 
2110
    objname="$func_basename_result"
 
2111
    xdir="$func_dirname_result"
846
2112
    lobj=${xdir}$objdir/$objname
847
2113
 
848
 
    if test -z "$base_compile"; then
849
 
      $echo "$modename: you must specify a compilation command" 1>&2
850
 
      $echo "$help" 1>&2
851
 
      exit $EXIT_FAILURE
852
 
    fi
 
2114
    test -z "$base_compile" && \
 
2115
      func_fatal_help "you must specify a compilation command"
853
2116
 
854
2117
    # Delete any leftover library objects.
855
2118
    if test "$build_old_libs" = yes; then
858
2121
      removelist="$lobj $libobj ${libobj}T"
859
2122
    fi
860
2123
 
861
 
    $run $rm $removelist
862
 
    trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
863
 
 
864
2124
    # On Cygwin there's no "real" PIC flag so we must build both object types
865
2125
    case $host_os in
866
 
    cygwin* | mingw* | pw32* | os2*)
 
2126
    cygwin* | mingw* | pw32* | os2* | cegcc*)
867
2127
      pic_mode=default
868
2128
      ;;
869
2129
    esac
875
2135
    # Calculate the filename of the output object if compiler does
876
2136
    # not support -o with -c
877
2137
    if test "$compiler_c_o" = no; then
878
 
      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
 
2138
      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
879
2139
      lockfile="$output_obj.lock"
880
 
      removelist="$removelist $output_obj $lockfile"
881
 
      trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
882
2140
    else
883
2141
      output_obj=
884
2142
      need_locks=no
888
2146
    # Lock this critical section if it is needed
889
2147
    # We use this script file to make the link, it avoids creating a new file
890
2148
    if test "$need_locks" = yes; then
891
 
      until $run ln "$progpath" "$lockfile" 2>/dev/null; do
892
 
        $show "Waiting for $lockfile to be removed"
 
2149
      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
 
2150
        func_echo "Waiting for $lockfile to be removed"
893
2151
        sleep 2
894
2152
      done
895
2153
    elif test "$need_locks" = warn; then
896
2154
      if test -f "$lockfile"; then
897
 
        $echo "\
 
2155
        $ECHO "\
898
2156
*** ERROR, $lockfile exists and contains:
899
2157
`cat $lockfile 2>/dev/null`
900
2158
 
905
2163
avoid parallel builds (make -j) in this platform, or get a better
906
2164
compiler."
907
2165
 
908
 
        $run $rm $removelist
 
2166
        $opt_dry_run || $RM $removelist
909
2167
        exit $EXIT_FAILURE
910
2168
      fi
911
 
      $echo "$srcfile" > "$lockfile"
912
 
    fi
913
 
 
914
 
    if test -n "$fix_srcfile_path"; then
915
 
      eval srcfile=\"$fix_srcfile_path\"
916
 
    fi
917
 
    qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
918
 
    case $qsrcfile in
919
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
920
 
      qsrcfile="\"$qsrcfile\"" ;;
921
 
    esac
922
 
 
923
 
    $run $rm "$libobj" "${libobj}T"
924
 
 
925
 
    # Create a libtool object file (analogous to a ".la" file),
926
 
    # but don't create it if we're doing a dry run.
927
 
    test -z "$run" && cat > ${libobj}T <<EOF
928
 
# $libobj - a libtool object file
929
 
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
930
 
#
931
 
# Please DO NOT delete this file!
932
 
# It is necessary for linking the library.
933
 
 
934
 
# Name of the PIC object.
935
 
EOF
 
2169
      func_append removelist " $output_obj"
 
2170
      $ECHO "$srcfile" > "$lockfile"
 
2171
    fi
 
2172
 
 
2173
    $opt_dry_run || $RM $removelist
 
2174
    func_append removelist " $lockfile"
 
2175
    trap '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE' 1 2 15
 
2176
 
 
2177
    func_to_tool_file "$srcfile" func_convert_file_msys_to_w32
 
2178
    srcfile=$func_to_tool_file_result
 
2179
    func_quote_for_eval "$srcfile"
 
2180
    qsrcfile=$func_quote_for_eval_result
936
2181
 
937
2182
    # Only build a PIC object if we are building libtool libraries.
938
2183
    if test "$build_libtool_libs" = yes; then
946
2191
        command="$base_compile $qsrcfile"
947
2192
      fi
948
2193
 
949
 
      if test ! -d "${xdir}$objdir"; then
950
 
        $show "$mkdir ${xdir}$objdir"
951
 
        $run $mkdir ${xdir}$objdir
952
 
        exit_status=$?
953
 
        if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
954
 
          exit $exit_status
955
 
        fi
956
 
      fi
 
2194
      func_mkdir_p "$xdir$objdir"
957
2195
 
958
2196
      if test -z "$output_obj"; then
959
2197
        # Place PIC objects in $objdir
960
 
        command="$command -o $lobj"
961
 
      fi
962
 
 
963
 
      $run $rm "$lobj" "$output_obj"
964
 
 
965
 
      $show "$command"
966
 
      if $run eval $lt_env "$command"; then :
967
 
      else
968
 
        test -n "$output_obj" && $run $rm $removelist
969
 
        exit $EXIT_FAILURE
970
 
      fi
 
2198
        func_append command " -o $lobj"
 
2199
      fi
 
2200
 
 
2201
      func_show_eval_locale "$command"  \
 
2202
          'test -n "$output_obj" && $RM $removelist; exit $EXIT_FAILURE'
971
2203
 
972
2204
      if test "$need_locks" = warn &&
973
2205
         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
974
 
        $echo "\
 
2206
        $ECHO "\
975
2207
*** ERROR, $lockfile contains:
976
2208
`cat $lockfile 2>/dev/null`
977
2209
 
985
2217
avoid parallel builds (make -j) in this platform, or get a better
986
2218
compiler."
987
2219
 
988
 
        $run $rm $removelist
 
2220
        $opt_dry_run || $RM $removelist
989
2221
        exit $EXIT_FAILURE
990
2222
      fi
991
2223
 
992
2224
      # Just move the object if needed, then go on to compile the next one
993
2225
      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
994
 
        $show "$mv $output_obj $lobj"
995
 
        if $run $mv $output_obj $lobj; then :
996
 
        else
997
 
          error=$?
998
 
          $run $rm $removelist
999
 
          exit $error
1000
 
        fi
 
2226
        func_show_eval '$MV "$output_obj" "$lobj"' \
 
2227
          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
1001
2228
      fi
1002
2229
 
1003
 
      # Append the name of the PIC object to the libtool object file.
1004
 
      test -z "$run" && cat >> ${libobj}T <<EOF
1005
 
pic_object='$objdir/$objname'
1006
 
 
1007
 
EOF
1008
 
 
1009
2230
      # Allow error messages only from the first compilation.
1010
2231
      if test "$suppress_opt" = yes; then
1011
 
        suppress_output=' >/dev/null 2>&1'
 
2232
        suppress_output=' >/dev/null 2>&1'
1012
2233
      fi
1013
 
    else
1014
 
      # No PIC object so indicate it doesn't exist in the libtool
1015
 
      # object file.
1016
 
      test -z "$run" && cat >> ${libobj}T <<EOF
1017
 
pic_object=none
1018
 
 
1019
 
EOF
1020
2234
    fi
1021
2235
 
1022
2236
    # Only build a position-dependent object if we build old libraries.
1023
2237
    if test "$build_old_libs" = yes; then
1024
2238
      if test "$pic_mode" != yes; then
1025
2239
        # Don't build PIC code
1026
 
        command="$base_compile $qsrcfile"
 
2240
        command="$base_compile $qsrcfile$pie_flag"
1027
2241
      else
1028
2242
        command="$base_compile $qsrcfile $pic_flag"
1029
2243
      fi
1030
2244
      if test "$compiler_c_o" = yes; then
1031
 
        command="$command -o $obj"
 
2245
        func_append command " -o $obj"
1032
2246
      fi
1033
2247
 
1034
2248
      # Suppress compiler output if we already did a PIC compilation.
1035
 
      command="$command$suppress_output"
1036
 
      $run $rm "$obj" "$output_obj"
1037
 
      $show "$command"
1038
 
      if $run eval $lt_env "$command"; then :
1039
 
      else
1040
 
        $run $rm $removelist
1041
 
        exit $EXIT_FAILURE
1042
 
      fi
 
2249
      func_append command "$suppress_output"
 
2250
      func_show_eval_locale "$command" \
 
2251
        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
1043
2252
 
1044
2253
      if test "$need_locks" = warn &&
1045
2254
         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1046
 
        $echo "\
 
2255
        $ECHO "\
1047
2256
*** ERROR, $lockfile contains:
1048
2257
`cat $lockfile 2>/dev/null`
1049
2258
 
1057
2266
avoid parallel builds (make -j) in this platform, or get a better
1058
2267
compiler."
1059
2268
 
1060
 
        $run $rm $removelist
 
2269
        $opt_dry_run || $RM $removelist
1061
2270
        exit $EXIT_FAILURE
1062
2271
      fi
1063
2272
 
1064
2273
      # Just move the object if needed
1065
2274
      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1066
 
        $show "$mv $output_obj $obj"
1067
 
        if $run $mv $output_obj $obj; then :
1068
 
        else
1069
 
          error=$?
1070
 
          $run $rm $removelist
1071
 
          exit $error
1072
 
        fi
1073
 
      fi
1074
 
 
1075
 
      # Append the name of the non-PIC object the libtool object file.
1076
 
      # Only append if the libtool object file exists.
1077
 
      test -z "$run" && cat >> ${libobj}T <<EOF
1078
 
# Name of the non-PIC object.
1079
 
non_pic_object='$objname'
1080
 
 
1081
 
EOF
1082
 
    else
1083
 
      # Append the name of the non-PIC object the libtool object file.
1084
 
      # Only append if the libtool object file exists.
1085
 
      test -z "$run" && cat >> ${libobj}T <<EOF
1086
 
# Name of the non-PIC object.
1087
 
non_pic_object=none
1088
 
 
1089
 
EOF
1090
 
    fi
1091
 
 
1092
 
    $run $mv "${libobj}T" "${libobj}"
1093
 
 
1094
 
    # Unlock the critical section if it was locked
1095
 
    if test "$need_locks" != no; then
1096
 
      $run $rm "$lockfile"
1097
 
    fi
1098
 
 
1099
 
    exit $EXIT_SUCCESS
1100
 
    ;;
1101
 
 
1102
 
  # libtool link mode
1103
 
  link | relink)
1104
 
    modename="$modename: link"
 
2275
        func_show_eval '$MV "$output_obj" "$obj"' \
 
2276
          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
 
2277
      fi
 
2278
    fi
 
2279
 
 
2280
    $opt_dry_run || {
 
2281
      func_write_libtool_object "$libobj" "$objdir/$objname" "$objname"
 
2282
 
 
2283
      # Unlock the critical section if it was locked
 
2284
      if test "$need_locks" != no; then
 
2285
        removelist=$lockfile
 
2286
        $RM "$lockfile"
 
2287
      fi
 
2288
    }
 
2289
 
 
2290
    exit $EXIT_SUCCESS
 
2291
}
 
2292
 
 
2293
$opt_help || {
 
2294
  test "$opt_mode" = compile && func_mode_compile ${1+"$@"}
 
2295
}
 
2296
 
 
2297
func_mode_help ()
 
2298
{
 
2299
    # We need to display help for each of the modes.
 
2300
    case $opt_mode in
 
2301
      "")
 
2302
        # Generic help is extracted from the usage comments
 
2303
        # at the start of this file.
 
2304
        func_help
 
2305
        ;;
 
2306
 
 
2307
      clean)
 
2308
        $ECHO \
 
2309
"Usage: $progname [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
 
2310
 
 
2311
Remove files from the build directory.
 
2312
 
 
2313
RM is the name of the program to use to delete files associated with each FILE
 
2314
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
 
2315
to RM.
 
2316
 
 
2317
If FILE is a libtool library, object or program, all the files associated
 
2318
with it are deleted. Otherwise, only FILE itself is deleted using RM."
 
2319
        ;;
 
2320
 
 
2321
      compile)
 
2322
      $ECHO \
 
2323
"Usage: $progname [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
 
2324
 
 
2325
Compile a source file into a libtool library object.
 
2326
 
 
2327
This mode accepts the following additional options:
 
2328
 
 
2329
  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
 
2330
  -no-suppress      do not suppress compiler output for multiple passes
 
2331
  -prefer-pic       try to build PIC objects only
 
2332
  -prefer-non-pic   try to build non-PIC objects only
 
2333
  -shared           do not build a \`.o' file suitable for static linking
 
2334
  -static           only build a \`.o' file suitable for static linking
 
2335
  -Wc,FLAG          pass FLAG directly to the compiler
 
2336
 
 
2337
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
 
2338
from the given SOURCEFILE.
 
2339
 
 
2340
The output file name is determined by removing the directory component from
 
2341
SOURCEFILE, then substituting the C source code suffix \`.c' with the
 
2342
library object suffix, \`.lo'."
 
2343
        ;;
 
2344
 
 
2345
      execute)
 
2346
        $ECHO \
 
2347
"Usage: $progname [OPTION]... --mode=execute COMMAND [ARGS]...
 
2348
 
 
2349
Automatically set library path, then run a program.
 
2350
 
 
2351
This mode accepts the following additional options:
 
2352
 
 
2353
  -dlopen FILE      add the directory containing FILE to the library path
 
2354
 
 
2355
This mode sets the library path environment variable according to \`-dlopen'
 
2356
flags.
 
2357
 
 
2358
If any of the ARGS are libtool executable wrappers, then they are translated
 
2359
into their corresponding uninstalled binary, and any of their required library
 
2360
directories are added to the library path.
 
2361
 
 
2362
Then, COMMAND is executed, with ARGS as arguments."
 
2363
        ;;
 
2364
 
 
2365
      finish)
 
2366
        $ECHO \
 
2367
"Usage: $progname [OPTION]... --mode=finish [LIBDIR]...
 
2368
 
 
2369
Complete the installation of libtool libraries.
 
2370
 
 
2371
Each LIBDIR is a directory that contains libtool libraries.
 
2372
 
 
2373
The commands that this mode executes may require superuser privileges.  Use
 
2374
the \`--dry-run' option if you just want to see what would be executed."
 
2375
        ;;
 
2376
 
 
2377
      install)
 
2378
        $ECHO \
 
2379
"Usage: $progname [OPTION]... --mode=install INSTALL-COMMAND...
 
2380
 
 
2381
Install executables or libraries.
 
2382
 
 
2383
INSTALL-COMMAND is the installation command.  The first component should be
 
2384
either the \`install' or \`cp' program.
 
2385
 
 
2386
The following components of INSTALL-COMMAND are treated specially:
 
2387
 
 
2388
  -inst-prefix-dir PREFIX-DIR  Use PREFIX-DIR as a staging area for installation
 
2389
 
 
2390
The rest of the components are interpreted as arguments to that command (only
 
2391
BSD-compatible install options are recognized)."
 
2392
        ;;
 
2393
 
 
2394
      link)
 
2395
        $ECHO \
 
2396
"Usage: $progname [OPTION]... --mode=link LINK-COMMAND...
 
2397
 
 
2398
Link object files or libraries together to form another library, or to
 
2399
create an executable program.
 
2400
 
 
2401
LINK-COMMAND is a command using the C compiler that you would use to create
 
2402
a program from several object files.
 
2403
 
 
2404
The following components of LINK-COMMAND are treated specially:
 
2405
 
 
2406
  -all-static       do not do any dynamic linking at all
 
2407
  -avoid-version    do not add a version suffix if possible
 
2408
  -bindir BINDIR    specify path to binaries directory (for systems where
 
2409
                    libraries must be found in the PATH setting at runtime)
 
2410
  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
 
2411
  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
 
2412
  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
 
2413
  -export-symbols SYMFILE
 
2414
                    try to export only the symbols listed in SYMFILE
 
2415
  -export-symbols-regex REGEX
 
2416
                    try to export only the symbols matching REGEX
 
2417
  -LLIBDIR          search LIBDIR for required installed libraries
 
2418
  -lNAME            OUTPUT-FILE requires the installed library libNAME
 
2419
  -module           build a library that can dlopened
 
2420
  -no-fast-install  disable the fast-install mode
 
2421
  -no-install       link a not-installable executable
 
2422
  -no-undefined     declare that a library does not refer to external symbols
 
2423
  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
 
2424
  -objectlist FILE  Use a list of object files found in FILE to specify objects
 
2425
  -precious-files-regex REGEX
 
2426
                    don't remove output files matching REGEX
 
2427
  -release RELEASE  specify package release information
 
2428
  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
 
2429
  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
 
2430
  -shared           only do dynamic linking of libtool libraries
 
2431
  -shrext SUFFIX    override the standard shared library file extension
 
2432
  -static           do not do any dynamic linking of uninstalled libtool libraries
 
2433
  -static-libtool-libs
 
2434
                    do not do any dynamic linking of libtool libraries
 
2435
  -version-info CURRENT[:REVISION[:AGE]]
 
2436
                    specify library version info [each variable defaults to 0]
 
2437
  -weak LIBNAME     declare that the target provides the LIBNAME interface
 
2438
  -Wc,FLAG
 
2439
  -Xcompiler FLAG   pass linker-specific FLAG directly to the compiler
 
2440
  -Wl,FLAG
 
2441
  -Xlinker FLAG     pass linker-specific FLAG directly to the linker
 
2442
  -XCClinker FLAG   pass link-specific FLAG to the compiler driver (CC)
 
2443
 
 
2444
All other options (arguments beginning with \`-') are ignored.
 
2445
 
 
2446
Every other argument is treated as a filename.  Files ending in \`.la' are
 
2447
treated as uninstalled libtool libraries, other files are standard or library
 
2448
object files.
 
2449
 
 
2450
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
 
2451
only library objects (\`.lo' files) may be specified, and \`-rpath' is
 
2452
required, except when creating a convenience library.
 
2453
 
 
2454
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
 
2455
using \`ar' and \`ranlib', or on Windows using \`lib'.
 
2456
 
 
2457
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
 
2458
is created, otherwise an executable program is created."
 
2459
        ;;
 
2460
 
 
2461
      uninstall)
 
2462
        $ECHO \
 
2463
"Usage: $progname [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
 
2464
 
 
2465
Remove libraries from an installation directory.
 
2466
 
 
2467
RM is the name of the program to use to delete files associated with each FILE
 
2468
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
 
2469
to RM.
 
2470
 
 
2471
If FILE is a libtool library, all the files associated with it are deleted.
 
2472
Otherwise, only FILE itself is deleted using RM."
 
2473
        ;;
 
2474
 
 
2475
      *)
 
2476
        func_fatal_help "invalid operation mode \`$opt_mode'"
 
2477
        ;;
 
2478
    esac
 
2479
 
 
2480
    echo
 
2481
    $ECHO "Try \`$progname --help' for more information about other modes."
 
2482
}
 
2483
 
 
2484
# Now that we've collected a possible --mode arg, show help if necessary
 
2485
if $opt_help; then
 
2486
  if test "$opt_help" = :; then
 
2487
    func_mode_help
 
2488
  else
 
2489
    {
 
2490
      func_help noexit
 
2491
      for opt_mode in compile link execute install finish uninstall clean; do
 
2492
        func_mode_help
 
2493
      done
 
2494
    } | sed -n '1p; 2,$s/^Usage:/  or: /p'
 
2495
    {
 
2496
      func_help noexit
 
2497
      for opt_mode in compile link execute install finish uninstall clean; do
 
2498
        echo
 
2499
        func_mode_help
 
2500
      done
 
2501
    } |
 
2502
    sed '1d
 
2503
      /^When reporting/,/^Report/{
 
2504
        H
 
2505
        d
 
2506
      }
 
2507
      $x
 
2508
      /information about other modes/d
 
2509
      /more detailed .*MODE/d
 
2510
      s/^Usage:.*--mode=\([^ ]*\) .*/Description of \1 mode:/'
 
2511
  fi
 
2512
  exit $?
 
2513
fi
 
2514
 
 
2515
 
 
2516
# func_mode_execute arg...
 
2517
func_mode_execute ()
 
2518
{
 
2519
    $opt_debug
 
2520
    # The first argument is the command name.
 
2521
    cmd="$nonopt"
 
2522
    test -z "$cmd" && \
 
2523
      func_fatal_help "you must specify a COMMAND"
 
2524
 
 
2525
    # Handle -dlopen flags immediately.
 
2526
    for file in $opt_dlopen; do
 
2527
      test -f "$file" \
 
2528
        || func_fatal_help "\`$file' is not a file"
 
2529
 
 
2530
      dir=
 
2531
      case $file in
 
2532
      *.la)
 
2533
        func_resolve_sysroot "$file"
 
2534
        file=$func_resolve_sysroot_result
 
2535
 
 
2536
        # Check to see that this really is a libtool archive.
 
2537
        func_lalib_unsafe_p "$file" \
 
2538
          || func_fatal_help "\`$lib' is not a valid libtool archive"
 
2539
 
 
2540
        # Read the libtool library.
 
2541
        dlname=
 
2542
        library_names=
 
2543
        func_source "$file"
 
2544
 
 
2545
        # Skip this library if it cannot be dlopened.
 
2546
        if test -z "$dlname"; then
 
2547
          # Warn if it was a shared library.
 
2548
          test -n "$library_names" && \
 
2549
            func_warning "\`$file' was not linked with \`-export-dynamic'"
 
2550
          continue
 
2551
        fi
 
2552
 
 
2553
        func_dirname "$file" "" "."
 
2554
        dir="$func_dirname_result"
 
2555
 
 
2556
        if test -f "$dir/$objdir/$dlname"; then
 
2557
          func_append dir "/$objdir"
 
2558
        else
 
2559
          if test ! -f "$dir/$dlname"; then
 
2560
            func_fatal_error "cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'"
 
2561
          fi
 
2562
        fi
 
2563
        ;;
 
2564
 
 
2565
      *.lo)
 
2566
        # Just add the directory containing the .lo file.
 
2567
        func_dirname "$file" "" "."
 
2568
        dir="$func_dirname_result"
 
2569
        ;;
 
2570
 
 
2571
      *)
 
2572
        func_warning "\`-dlopen' is ignored for non-libtool libraries and objects"
 
2573
        continue
 
2574
        ;;
 
2575
      esac
 
2576
 
 
2577
      # Get the absolute pathname.
 
2578
      absdir=`cd "$dir" && pwd`
 
2579
      test -n "$absdir" && dir="$absdir"
 
2580
 
 
2581
      # Now add the directory to shlibpath_var.
 
2582
      if eval "test -z \"\$$shlibpath_var\""; then
 
2583
        eval "$shlibpath_var=\"\$dir\""
 
2584
      else
 
2585
        eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
 
2586
      fi
 
2587
    done
 
2588
 
 
2589
    # This variable tells wrapper scripts just to set shlibpath_var
 
2590
    # rather than running their programs.
 
2591
    libtool_execute_magic="$magic"
 
2592
 
 
2593
    # Check if any of the arguments is a wrapper script.
 
2594
    args=
 
2595
    for file
 
2596
    do
 
2597
      case $file in
 
2598
      -* | *.la | *.lo ) ;;
 
2599
      *)
 
2600
        # Do a test to see if this is really a libtool program.
 
2601
        if func_ltwrapper_script_p "$file"; then
 
2602
          func_source "$file"
 
2603
          # Transform arg to wrapped name.
 
2604
          file="$progdir/$program"
 
2605
        elif func_ltwrapper_executable_p "$file"; then
 
2606
          func_ltwrapper_scriptname "$file"
 
2607
          func_source "$func_ltwrapper_scriptname_result"
 
2608
          # Transform arg to wrapped name.
 
2609
          file="$progdir/$program"
 
2610
        fi
 
2611
        ;;
 
2612
      esac
 
2613
      # Quote arguments (to preserve shell metacharacters).
 
2614
      func_append_quoted args "$file"
 
2615
    done
 
2616
 
 
2617
    if test "X$opt_dry_run" = Xfalse; then
 
2618
      if test -n "$shlibpath_var"; then
 
2619
        # Export the shlibpath_var.
 
2620
        eval "export $shlibpath_var"
 
2621
      fi
 
2622
 
 
2623
      # Restore saved environment variables
 
2624
      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
 
2625
      do
 
2626
        eval "if test \"\${save_$lt_var+set}\" = set; then
 
2627
                $lt_var=\$save_$lt_var; export $lt_var
 
2628
              else
 
2629
                $lt_unset $lt_var
 
2630
              fi"
 
2631
      done
 
2632
 
 
2633
      # Now prepare to actually exec the command.
 
2634
      exec_cmd="\$cmd$args"
 
2635
    else
 
2636
      # Display what would be done.
 
2637
      if test -n "$shlibpath_var"; then
 
2638
        eval "\$ECHO \"\$shlibpath_var=\$$shlibpath_var\""
 
2639
        echo "export $shlibpath_var"
 
2640
      fi
 
2641
      $ECHO "$cmd$args"
 
2642
      exit $EXIT_SUCCESS
 
2643
    fi
 
2644
}
 
2645
 
 
2646
test "$opt_mode" = execute && func_mode_execute ${1+"$@"}
 
2647
 
 
2648
 
 
2649
# func_mode_finish arg...
 
2650
func_mode_finish ()
 
2651
{
 
2652
    $opt_debug
 
2653
    libs=
 
2654
    libdirs=
 
2655
    admincmds=
 
2656
 
 
2657
    for opt in "$nonopt" ${1+"$@"}
 
2658
    do
 
2659
      if test -d "$opt"; then
 
2660
        func_append libdirs " $opt"
 
2661
 
 
2662
      elif test -f "$opt"; then
 
2663
        if func_lalib_unsafe_p "$opt"; then
 
2664
          func_append libs " $opt"
 
2665
        else
 
2666
          func_warning "\`$opt' is not a valid libtool archive"
 
2667
        fi
 
2668
 
 
2669
      else
 
2670
        func_fatal_error "invalid argument \`$opt'"
 
2671
      fi
 
2672
    done
 
2673
 
 
2674
    if test -n "$libs"; then
 
2675
      if test -n "$lt_sysroot"; then
 
2676
        sysroot_regex=`$ECHO "$lt_sysroot" | $SED "$sed_make_literal_regex"`
 
2677
        sysroot_cmd="s/\([ ']\)$sysroot_regex/\1/g;"
 
2678
      else
 
2679
        sysroot_cmd=
 
2680
      fi
 
2681
 
 
2682
      # Remove sysroot references
 
2683
      if $opt_dry_run; then
 
2684
        for lib in $libs; do
 
2685
          echo "removing references to $lt_sysroot and \`=' prefixes from $lib"
 
2686
        done
 
2687
      else
 
2688
        tmpdir=`func_mktempdir`
 
2689
        for lib in $libs; do
 
2690
          sed -e "${sysroot_cmd} s/\([ ']-[LR]\)=/\1/g; s/\([ ']\)=/\1/g" $lib \
 
2691
            > $tmpdir/tmp-la
 
2692
          mv -f $tmpdir/tmp-la $lib
 
2693
        done
 
2694
        ${RM}r "$tmpdir"
 
2695
      fi
 
2696
    fi
 
2697
 
 
2698
    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
 
2699
      for libdir in $libdirs; do
 
2700
        if test -n "$finish_cmds"; then
 
2701
          # Do each command in the finish commands.
 
2702
          func_execute_cmds "$finish_cmds" 'admincmds="$admincmds
 
2703
'"$cmd"'"'
 
2704
        fi
 
2705
        if test -n "$finish_eval"; then
 
2706
          # Do the single finish_eval.
 
2707
          eval cmds=\"$finish_eval\"
 
2708
          $opt_dry_run || eval "$cmds" || func_append admincmds "
 
2709
       $cmds"
 
2710
        fi
 
2711
      done
 
2712
    fi
 
2713
 
 
2714
    # Exit here if they wanted silent mode.
 
2715
    $opt_silent && exit $EXIT_SUCCESS
 
2716
 
 
2717
    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
 
2718
      echo "----------------------------------------------------------------------"
 
2719
      echo "Libraries have been installed in:"
 
2720
      for libdir in $libdirs; do
 
2721
        $ECHO "   $libdir"
 
2722
      done
 
2723
      echo
 
2724
      echo "If you ever happen to want to link against installed libraries"
 
2725
      echo "in a given directory, LIBDIR, you must either use libtool, and"
 
2726
      echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
 
2727
      echo "flag during linking and do at least one of the following:"
 
2728
      if test -n "$shlibpath_var"; then
 
2729
        echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
 
2730
        echo "     during execution"
 
2731
      fi
 
2732
      if test -n "$runpath_var"; then
 
2733
        echo "   - add LIBDIR to the \`$runpath_var' environment variable"
 
2734
        echo "     during linking"
 
2735
      fi
 
2736
      if test -n "$hardcode_libdir_flag_spec"; then
 
2737
        libdir=LIBDIR
 
2738
        eval flag=\"$hardcode_libdir_flag_spec\"
 
2739
 
 
2740
        $ECHO "   - use the \`$flag' linker flag"
 
2741
      fi
 
2742
      if test -n "$admincmds"; then
 
2743
        $ECHO "   - have your system administrator run these commands:$admincmds"
 
2744
      fi
 
2745
      if test -f /etc/ld.so.conf; then
 
2746
        echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
 
2747
      fi
 
2748
      echo
 
2749
 
 
2750
      echo "See any operating system documentation about shared libraries for"
 
2751
      case $host in
 
2752
        solaris2.[6789]|solaris2.1[0-9])
 
2753
          echo "more information, such as the ld(1), crle(1) and ld.so(8) manual"
 
2754
          echo "pages."
 
2755
          ;;
 
2756
        *)
 
2757
          echo "more information, such as the ld(1) and ld.so(8) manual pages."
 
2758
          ;;
 
2759
      esac
 
2760
      echo "----------------------------------------------------------------------"
 
2761
    fi
 
2762
    exit $EXIT_SUCCESS
 
2763
}
 
2764
 
 
2765
test "$opt_mode" = finish && func_mode_finish ${1+"$@"}
 
2766
 
 
2767
 
 
2768
# func_mode_install arg...
 
2769
func_mode_install ()
 
2770
{
 
2771
    $opt_debug
 
2772
    # There may be an optional sh(1) argument at the beginning of
 
2773
    # install_prog (especially on Windows NT).
 
2774
    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
 
2775
       # Allow the use of GNU shtool's install command.
 
2776
       case $nonopt in *shtool*) :;; *) false;; esac; then
 
2777
      # Aesthetically quote it.
 
2778
      func_quote_for_eval "$nonopt"
 
2779
      install_prog="$func_quote_for_eval_result "
 
2780
      arg=$1
 
2781
      shift
 
2782
    else
 
2783
      install_prog=
 
2784
      arg=$nonopt
 
2785
    fi
 
2786
 
 
2787
    # The real first argument should be the name of the installation program.
 
2788
    # Aesthetically quote it.
 
2789
    func_quote_for_eval "$arg"
 
2790
    func_append install_prog "$func_quote_for_eval_result"
 
2791
    install_shared_prog=$install_prog
 
2792
    case " $install_prog " in
 
2793
      *[\\\ /]cp\ *) install_cp=: ;;
 
2794
      *) install_cp=false ;;
 
2795
    esac
 
2796
 
 
2797
    # We need to accept at least all the BSD install flags.
 
2798
    dest=
 
2799
    files=
 
2800
    opts=
 
2801
    prev=
 
2802
    install_type=
 
2803
    isdir=no
 
2804
    stripme=
 
2805
    no_mode=:
 
2806
    for arg
 
2807
    do
 
2808
      arg2=
 
2809
      if test -n "$dest"; then
 
2810
        func_append files " $dest"
 
2811
        dest=$arg
 
2812
        continue
 
2813
      fi
 
2814
 
 
2815
      case $arg in
 
2816
      -d) isdir=yes ;;
 
2817
      -f)
 
2818
        if $install_cp; then :; else
 
2819
          prev=$arg
 
2820
        fi
 
2821
        ;;
 
2822
      -g | -m | -o)
 
2823
        prev=$arg
 
2824
        ;;
 
2825
      -s)
 
2826
        stripme=" -s"
 
2827
        continue
 
2828
        ;;
 
2829
      -*)
 
2830
        ;;
 
2831
      *)
 
2832
        # If the previous option needed an argument, then skip it.
 
2833
        if test -n "$prev"; then
 
2834
          if test "x$prev" = x-m && test -n "$install_override_mode"; then
 
2835
            arg2=$install_override_mode
 
2836
            no_mode=false
 
2837
          fi
 
2838
          prev=
 
2839
        else
 
2840
          dest=$arg
 
2841
          continue
 
2842
        fi
 
2843
        ;;
 
2844
      esac
 
2845
 
 
2846
      # Aesthetically quote the argument.
 
2847
      func_quote_for_eval "$arg"
 
2848
      func_append install_prog " $func_quote_for_eval_result"
 
2849
      if test -n "$arg2"; then
 
2850
        func_quote_for_eval "$arg2"
 
2851
      fi
 
2852
      func_append install_shared_prog " $func_quote_for_eval_result"
 
2853
    done
 
2854
 
 
2855
    test -z "$install_prog" && \
 
2856
      func_fatal_help "you must specify an install program"
 
2857
 
 
2858
    test -n "$prev" && \
 
2859
      func_fatal_help "the \`$prev' option requires an argument"
 
2860
 
 
2861
    if test -n "$install_override_mode" && $no_mode; then
 
2862
      if $install_cp; then :; else
 
2863
        func_quote_for_eval "$install_override_mode"
 
2864
        func_append install_shared_prog " -m $func_quote_for_eval_result"
 
2865
      fi
 
2866
    fi
 
2867
 
 
2868
    if test -z "$files"; then
 
2869
      if test -z "$dest"; then
 
2870
        func_fatal_help "no file or destination specified"
 
2871
      else
 
2872
        func_fatal_help "you must specify a destination"
 
2873
      fi
 
2874
    fi
 
2875
 
 
2876
    # Strip any trailing slash from the destination.
 
2877
    func_stripname '' '/' "$dest"
 
2878
    dest=$func_stripname_result
 
2879
 
 
2880
    # Check to see that the destination is a directory.
 
2881
    test -d "$dest" && isdir=yes
 
2882
    if test "$isdir" = yes; then
 
2883
      destdir="$dest"
 
2884
      destname=
 
2885
    else
 
2886
      func_dirname_and_basename "$dest" "" "."
 
2887
      destdir="$func_dirname_result"
 
2888
      destname="$func_basename_result"
 
2889
 
 
2890
      # Not a directory, so check to see that there is only one file specified.
 
2891
      set dummy $files; shift
 
2892
      test "$#" -gt 1 && \
 
2893
        func_fatal_help "\`$dest' is not a directory"
 
2894
    fi
 
2895
    case $destdir in
 
2896
    [\\/]* | [A-Za-z]:[\\/]*) ;;
 
2897
    *)
 
2898
      for file in $files; do
 
2899
        case $file in
 
2900
        *.lo) ;;
 
2901
        *)
 
2902
          func_fatal_help "\`$destdir' must be an absolute directory name"
 
2903
          ;;
 
2904
        esac
 
2905
      done
 
2906
      ;;
 
2907
    esac
 
2908
 
 
2909
    # This variable tells wrapper scripts just to set variables rather
 
2910
    # than running their programs.
 
2911
    libtool_install_magic="$magic"
 
2912
 
 
2913
    staticlibs=
 
2914
    future_libdirs=
 
2915
    current_libdirs=
 
2916
    for file in $files; do
 
2917
 
 
2918
      # Do each installation.
 
2919
      case $file in
 
2920
      *.$libext)
 
2921
        # Do the static libraries later.
 
2922
        func_append staticlibs " $file"
 
2923
        ;;
 
2924
 
 
2925
      *.la)
 
2926
        func_resolve_sysroot "$file"
 
2927
        file=$func_resolve_sysroot_result
 
2928
 
 
2929
        # Check to see that this really is a libtool archive.
 
2930
        func_lalib_unsafe_p "$file" \
 
2931
          || func_fatal_help "\`$file' is not a valid libtool archive"
 
2932
 
 
2933
        library_names=
 
2934
        old_library=
 
2935
        relink_command=
 
2936
        func_source "$file"
 
2937
 
 
2938
        # Add the libdir to current_libdirs if it is the destination.
 
2939
        if test "X$destdir" = "X$libdir"; then
 
2940
          case "$current_libdirs " in
 
2941
          *" $libdir "*) ;;
 
2942
          *) func_append current_libdirs " $libdir" ;;
 
2943
          esac
 
2944
        else
 
2945
          # Note the libdir as a future libdir.
 
2946
          case "$future_libdirs " in
 
2947
          *" $libdir "*) ;;
 
2948
          *) func_append future_libdirs " $libdir" ;;
 
2949
          esac
 
2950
        fi
 
2951
 
 
2952
        func_dirname "$file" "/" ""
 
2953
        dir="$func_dirname_result"
 
2954
        func_append dir "$objdir"
 
2955
 
 
2956
        if test -n "$relink_command"; then
 
2957
          # Determine the prefix the user has applied to our future dir.
 
2958
          inst_prefix_dir=`$ECHO "$destdir" | $SED -e "s%$libdir\$%%"`
 
2959
 
 
2960
          # Don't allow the user to place us outside of our expected
 
2961
          # location b/c this prevents finding dependent libraries that
 
2962
          # are installed to the same prefix.
 
2963
          # At present, this check doesn't affect windows .dll's that
 
2964
          # are installed into $libdir/../bin (currently, that works fine)
 
2965
          # but it's something to keep an eye on.
 
2966
          test "$inst_prefix_dir" = "$destdir" && \
 
2967
            func_fatal_error "error: cannot install \`$file' to a directory not ending in $libdir"
 
2968
 
 
2969
          if test -n "$inst_prefix_dir"; then
 
2970
            # Stick the inst_prefix_dir data into the link command.
 
2971
            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
 
2972
          else
 
2973
            relink_command=`$ECHO "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
 
2974
          fi
 
2975
 
 
2976
          func_warning "relinking \`$file'"
 
2977
          func_show_eval "$relink_command" \
 
2978
            'func_fatal_error "error: relink \`$file'\'' with the above command before installing it"'
 
2979
        fi
 
2980
 
 
2981
        # See the names of the shared library.
 
2982
        set dummy $library_names; shift
 
2983
        if test -n "$1"; then
 
2984
          realname="$1"
 
2985
          shift
 
2986
 
 
2987
          srcname="$realname"
 
2988
          test -n "$relink_command" && srcname="$realname"T
 
2989
 
 
2990
          # Install the shared library and build the symlinks.
 
2991
          func_show_eval "$install_shared_prog $dir/$srcname $destdir/$realname" \
 
2992
              'exit $?'
 
2993
          tstripme="$stripme"
 
2994
          case $host_os in
 
2995
          cygwin* | mingw* | pw32* | cegcc*)
 
2996
            case $realname in
 
2997
            *.dll.a)
 
2998
              tstripme=""
 
2999
              ;;
 
3000
            esac
 
3001
            ;;
 
3002
          esac
 
3003
          if test -n "$tstripme" && test -n "$striplib"; then
 
3004
            func_show_eval "$striplib $destdir/$realname" 'exit $?'
 
3005
          fi
 
3006
 
 
3007
          if test "$#" -gt 0; then
 
3008
            # Delete the old symlinks, and create new ones.
 
3009
            # Try `ln -sf' first, because the `ln' binary might depend on
 
3010
            # the symlink we replace!  Solaris /bin/ln does not understand -f,
 
3011
            # so we also need to try rm && ln -s.
 
3012
            for linkname
 
3013
            do
 
3014
              test "$linkname" != "$realname" \
 
3015
                && func_show_eval "(cd $destdir && { $LN_S -f $realname $linkname || { $RM $linkname && $LN_S $realname $linkname; }; })"
 
3016
            done
 
3017
          fi
 
3018
 
 
3019
          # Do each command in the postinstall commands.
 
3020
          lib="$destdir/$realname"
 
3021
          func_execute_cmds "$postinstall_cmds" 'exit $?'
 
3022
        fi
 
3023
 
 
3024
        # Install the pseudo-library for information purposes.
 
3025
        func_basename "$file"
 
3026
        name="$func_basename_result"
 
3027
        instname="$dir/$name"i
 
3028
        func_show_eval "$install_prog $instname $destdir/$name" 'exit $?'
 
3029
 
 
3030
        # Maybe install the static library, too.
 
3031
        test -n "$old_library" && func_append staticlibs " $dir/$old_library"
 
3032
        ;;
 
3033
 
 
3034
      *.lo)
 
3035
        # Install (i.e. copy) a libtool object.
 
3036
 
 
3037
        # Figure out destination file name, if it wasn't already specified.
 
3038
        if test -n "$destname"; then
 
3039
          destfile="$destdir/$destname"
 
3040
        else
 
3041
          func_basename "$file"
 
3042
          destfile="$func_basename_result"
 
3043
          destfile="$destdir/$destfile"
 
3044
        fi
 
3045
 
 
3046
        # Deduce the name of the destination old-style object file.
 
3047
        case $destfile in
 
3048
        *.lo)
 
3049
          func_lo2o "$destfile"
 
3050
          staticdest=$func_lo2o_result
 
3051
          ;;
 
3052
        *.$objext)
 
3053
          staticdest="$destfile"
 
3054
          destfile=
 
3055
          ;;
 
3056
        *)
 
3057
          func_fatal_help "cannot copy a libtool object to \`$destfile'"
 
3058
          ;;
 
3059
        esac
 
3060
 
 
3061
        # Install the libtool object if requested.
 
3062
        test -n "$destfile" && \
 
3063
          func_show_eval "$install_prog $file $destfile" 'exit $?'
 
3064
 
 
3065
        # Install the old object if enabled.
 
3066
        if test "$build_old_libs" = yes; then
 
3067
          # Deduce the name of the old-style object file.
 
3068
          func_lo2o "$file"
 
3069
          staticobj=$func_lo2o_result
 
3070
          func_show_eval "$install_prog \$staticobj \$staticdest" 'exit $?'
 
3071
        fi
 
3072
        exit $EXIT_SUCCESS
 
3073
        ;;
 
3074
 
 
3075
      *)
 
3076
        # Figure out destination file name, if it wasn't already specified.
 
3077
        if test -n "$destname"; then
 
3078
          destfile="$destdir/$destname"
 
3079
        else
 
3080
          func_basename "$file"
 
3081
          destfile="$func_basename_result"
 
3082
          destfile="$destdir/$destfile"
 
3083
        fi
 
3084
 
 
3085
        # If the file is missing, and there is a .exe on the end, strip it
 
3086
        # because it is most likely a libtool script we actually want to
 
3087
        # install
 
3088
        stripped_ext=""
 
3089
        case $file in
 
3090
          *.exe)
 
3091
            if test ! -f "$file"; then
 
3092
              func_stripname '' '.exe' "$file"
 
3093
              file=$func_stripname_result
 
3094
              stripped_ext=".exe"
 
3095
            fi
 
3096
            ;;
 
3097
        esac
 
3098
 
 
3099
        # Do a test to see if this is really a libtool program.
 
3100
        case $host in
 
3101
        *cygwin* | *mingw*)
 
3102
            if func_ltwrapper_executable_p "$file"; then
 
3103
              func_ltwrapper_scriptname "$file"
 
3104
              wrapper=$func_ltwrapper_scriptname_result
 
3105
            else
 
3106
              func_stripname '' '.exe' "$file"
 
3107
              wrapper=$func_stripname_result
 
3108
            fi
 
3109
            ;;
 
3110
        *)
 
3111
            wrapper=$file
 
3112
            ;;
 
3113
        esac
 
3114
        if func_ltwrapper_script_p "$wrapper"; then
 
3115
          notinst_deplibs=
 
3116
          relink_command=
 
3117
 
 
3118
          func_source "$wrapper"
 
3119
 
 
3120
          # Check the variables that should have been set.
 
3121
          test -z "$generated_by_libtool_version" && \
 
3122
            func_fatal_error "invalid libtool wrapper script \`$wrapper'"
 
3123
 
 
3124
          finalize=yes
 
3125
          for lib in $notinst_deplibs; do
 
3126
            # Check to see that each library is installed.
 
3127
            libdir=
 
3128
            if test -f "$lib"; then
 
3129
              func_source "$lib"
 
3130
            fi
 
3131
            libfile="$libdir/"`$ECHO "$lib" | $SED 's%^.*/%%g'` ### testsuite: skip nested quoting test
 
3132
            if test -n "$libdir" && test ! -f "$libfile"; then
 
3133
              func_warning "\`$lib' has not been installed in \`$libdir'"
 
3134
              finalize=no
 
3135
            fi
 
3136
          done
 
3137
 
 
3138
          relink_command=
 
3139
          func_source "$wrapper"
 
3140
 
 
3141
          outputname=
 
3142
          if test "$fast_install" = no && test -n "$relink_command"; then
 
3143
            $opt_dry_run || {
 
3144
              if test "$finalize" = yes; then
 
3145
                tmpdir=`func_mktempdir`
 
3146
                func_basename "$file$stripped_ext"
 
3147
                file="$func_basename_result"
 
3148
                outputname="$tmpdir/$file"
 
3149
                # Replace the output file specification.
 
3150
                relink_command=`$ECHO "$relink_command" | $SED 's%@OUTPUT@%'"$outputname"'%g'`
 
3151
 
 
3152
                $opt_silent || {
 
3153
                  func_quote_for_expand "$relink_command"
 
3154
                  eval "func_echo $func_quote_for_expand_result"
 
3155
                }
 
3156
                if eval "$relink_command"; then :
 
3157
                  else
 
3158
                  func_error "error: relink \`$file' with the above command before installing it"
 
3159
                  $opt_dry_run || ${RM}r "$tmpdir"
 
3160
                  continue
 
3161
                fi
 
3162
                file="$outputname"
 
3163
              else
 
3164
                func_warning "cannot relink \`$file'"
 
3165
              fi
 
3166
            }
 
3167
          else
 
3168
            # Install the binary that we compiled earlier.
 
3169
            file=`$ECHO "$file$stripped_ext" | $SED "s%\([^/]*\)$%$objdir/\1%"`
 
3170
          fi
 
3171
        fi
 
3172
 
 
3173
        # remove .exe since cygwin /usr/bin/install will append another
 
3174
        # one anyway
 
3175
        case $install_prog,$host in
 
3176
        */usr/bin/install*,*cygwin*)
 
3177
          case $file:$destfile in
 
3178
          *.exe:*.exe)
 
3179
            # this is ok
 
3180
            ;;
 
3181
          *.exe:*)
 
3182
            destfile=$destfile.exe
 
3183
            ;;
 
3184
          *:*.exe)
 
3185
            func_stripname '' '.exe' "$destfile"
 
3186
            destfile=$func_stripname_result
 
3187
            ;;
 
3188
          esac
 
3189
          ;;
 
3190
        esac
 
3191
        func_show_eval "$install_prog\$stripme \$file \$destfile" 'exit $?'
 
3192
        $opt_dry_run || if test -n "$outputname"; then
 
3193
          ${RM}r "$tmpdir"
 
3194
        fi
 
3195
        ;;
 
3196
      esac
 
3197
    done
 
3198
 
 
3199
    for file in $staticlibs; do
 
3200
      func_basename "$file"
 
3201
      name="$func_basename_result"
 
3202
 
 
3203
      # Set up the ranlib parameters.
 
3204
      oldlib="$destdir/$name"
 
3205
      func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
 
3206
      tool_oldlib=$func_to_tool_file_result
 
3207
 
 
3208
      func_show_eval "$install_prog \$file \$oldlib" 'exit $?'
 
3209
 
 
3210
      if test -n "$stripme" && test -n "$old_striplib"; then
 
3211
        func_show_eval "$old_striplib $tool_oldlib" 'exit $?'
 
3212
      fi
 
3213
 
 
3214
      # Do each command in the postinstall commands.
 
3215
      func_execute_cmds "$old_postinstall_cmds" 'exit $?'
 
3216
    done
 
3217
 
 
3218
    test -n "$future_libdirs" && \
 
3219
      func_warning "remember to run \`$progname --finish$future_libdirs'"
 
3220
 
 
3221
    if test -n "$current_libdirs"; then
 
3222
      # Maybe just do a dry run.
 
3223
      $opt_dry_run && current_libdirs=" -n$current_libdirs"
 
3224
      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
 
3225
    else
 
3226
      exit $EXIT_SUCCESS
 
3227
    fi
 
3228
}
 
3229
 
 
3230
test "$opt_mode" = install && func_mode_install ${1+"$@"}
 
3231
 
 
3232
 
 
3233
# func_generate_dlsyms outputname originator pic_p
 
3234
# Extract symbols from dlprefiles and create ${outputname}S.o with
 
3235
# a dlpreopen symbol table.
 
3236
func_generate_dlsyms ()
 
3237
{
 
3238
    $opt_debug
 
3239
    my_outputname="$1"
 
3240
    my_originator="$2"
 
3241
    my_pic_p="${3-no}"
 
3242
    my_prefix=`$ECHO "$my_originator" | sed 's%[^a-zA-Z0-9]%_%g'`
 
3243
    my_dlsyms=
 
3244
 
 
3245
    if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
 
3246
      if test -n "$NM" && test -n "$global_symbol_pipe"; then
 
3247
        my_dlsyms="${my_outputname}S.c"
 
3248
      else
 
3249
        func_error "not configured to extract global symbols from dlpreopened files"
 
3250
      fi
 
3251
    fi
 
3252
 
 
3253
    if test -n "$my_dlsyms"; then
 
3254
      case $my_dlsyms in
 
3255
      "") ;;
 
3256
      *.c)
 
3257
        # Discover the nlist of each of the dlfiles.
 
3258
        nlist="$output_objdir/${my_outputname}.nm"
 
3259
 
 
3260
        func_show_eval "$RM $nlist ${nlist}S ${nlist}T"
 
3261
 
 
3262
        # Parse the name list into a source file.
 
3263
        func_verbose "creating $output_objdir/$my_dlsyms"
 
3264
 
 
3265
        $opt_dry_run || $ECHO > "$output_objdir/$my_dlsyms" "\
 
3266
/* $my_dlsyms - symbol resolution table for \`$my_outputname' dlsym emulation. */
 
3267
/* Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION */
 
3268
 
 
3269
#ifdef __cplusplus
 
3270
extern \"C\" {
 
3271
#endif
 
3272
 
 
3273
#if defined(__GNUC__) && (((__GNUC__ == 4) && (__GNUC_MINOR__ >= 4)) || (__GNUC__ > 4))
 
3274
#pragma GCC diagnostic ignored \"-Wstrict-prototypes\"
 
3275
#endif
 
3276
 
 
3277
/* Keep this code in sync between libtool.m4, ltmain, lt_system.h, and tests.  */
 
3278
#if defined(_WIN32) || defined(__CYGWIN__) || defined(_WIN32_WCE)
 
3279
/* DATA imports from DLLs on WIN32 con't be const, because runtime
 
3280
   relocations are performed -- see ld's documentation on pseudo-relocs.  */
 
3281
# define LT_DLSYM_CONST
 
3282
#elif defined(__osf__)
 
3283
/* This system does not cope well with relocations in const data.  */
 
3284
# define LT_DLSYM_CONST
 
3285
#else
 
3286
# define LT_DLSYM_CONST const
 
3287
#endif
 
3288
 
 
3289
/* External symbol declarations for the compiler. */\
 
3290
"
 
3291
 
 
3292
        if test "$dlself" = yes; then
 
3293
          func_verbose "generating symbol list for \`$output'"
 
3294
 
 
3295
          $opt_dry_run || echo ': @PROGRAM@ ' > "$nlist"
 
3296
 
 
3297
          # Add our own program objects to the symbol list.
 
3298
          progfiles=`$ECHO "$objs$old_deplibs" | $SP2NL | $SED "$lo2o" | $NL2SP`
 
3299
          for progfile in $progfiles; do
 
3300
            func_to_tool_file "$progfile" func_convert_file_msys_to_w32
 
3301
            func_verbose "extracting global C symbols from \`$func_to_tool_file_result'"
 
3302
            $opt_dry_run || eval "$NM $func_to_tool_file_result | $global_symbol_pipe >> '$nlist'"
 
3303
          done
 
3304
 
 
3305
          if test -n "$exclude_expsyms"; then
 
3306
            $opt_dry_run || {
 
3307
              eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
 
3308
              eval '$MV "$nlist"T "$nlist"'
 
3309
            }
 
3310
          fi
 
3311
 
 
3312
          if test -n "$export_symbols_regex"; then
 
3313
            $opt_dry_run || {
 
3314
              eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
 
3315
              eval '$MV "$nlist"T "$nlist"'
 
3316
            }
 
3317
          fi
 
3318
 
 
3319
          # Prepare the list of exported symbols
 
3320
          if test -z "$export_symbols"; then
 
3321
            export_symbols="$output_objdir/$outputname.exp"
 
3322
            $opt_dry_run || {
 
3323
              $RM $export_symbols
 
3324
              eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
 
3325
              case $host in
 
3326
              *cygwin* | *mingw* | *cegcc* )
 
3327
                eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
 
3328
                eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
 
3329
                ;;
 
3330
              esac
 
3331
            }
 
3332
          else
 
3333
            $opt_dry_run || {
 
3334
              eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
 
3335
              eval '$GREP -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
 
3336
              eval '$MV "$nlist"T "$nlist"'
 
3337
              case $host in
 
3338
                *cygwin* | *mingw* | *cegcc* )
 
3339
                  eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
 
3340
                  eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
 
3341
                  ;;
 
3342
              esac
 
3343
            }
 
3344
          fi
 
3345
        fi
 
3346
 
 
3347
        for dlprefile in $dlprefiles; do
 
3348
          func_verbose "extracting global C symbols from \`$dlprefile'"
 
3349
          func_basename "$dlprefile"
 
3350
          name="$func_basename_result"
 
3351
          case $host in
 
3352
            *cygwin* | *mingw* | *cegcc* )
 
3353
              # if an import library, we need to obtain dlname
 
3354
              if func_win32_import_lib_p "$dlprefile"; then
 
3355
                func_tr_sh "$dlprefile"
 
3356
                eval "curr_lafile=\$libfile_$func_tr_sh_result"
 
3357
                dlprefile_dlbasename=""
 
3358
                if test -n "$curr_lafile" && func_lalib_p "$curr_lafile"; then
 
3359
                  # Use subshell, to avoid clobbering current variable values
 
3360
                  dlprefile_dlname=`source "$curr_lafile" && echo "$dlname"`
 
3361
                  if test -n "$dlprefile_dlname" ; then
 
3362
                    func_basename "$dlprefile_dlname"
 
3363
                    dlprefile_dlbasename="$func_basename_result"
 
3364
                  else
 
3365
                    # no lafile. user explicitly requested -dlpreopen <import library>.
 
3366
                    $sharedlib_from_linklib_cmd "$dlprefile"
 
3367
                    dlprefile_dlbasename=$sharedlib_from_linklib_result
 
3368
                  fi
 
3369
                fi
 
3370
                $opt_dry_run || {
 
3371
                  if test -n "$dlprefile_dlbasename" ; then
 
3372
                    eval '$ECHO ": $dlprefile_dlbasename" >> "$nlist"'
 
3373
                  else
 
3374
                    func_warning "Could not compute DLL name from $name"
 
3375
                    eval '$ECHO ": $name " >> "$nlist"'
 
3376
                  fi
 
3377
                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
 
3378
                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe |
 
3379
                    $SED -e '/I __imp/d' -e 's/I __nm_/D /;s/_nm__//' >> '$nlist'"
 
3380
                }
 
3381
              else # not an import lib
 
3382
                $opt_dry_run || {
 
3383
                  eval '$ECHO ": $name " >> "$nlist"'
 
3384
                  func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
 
3385
                  eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
 
3386
                }
 
3387
              fi
 
3388
            ;;
 
3389
            *)
 
3390
              $opt_dry_run || {
 
3391
                eval '$ECHO ": $name " >> "$nlist"'
 
3392
                func_to_tool_file "$dlprefile" func_convert_file_msys_to_w32
 
3393
                eval "$NM \"$func_to_tool_file_result\" 2>/dev/null | $global_symbol_pipe >> '$nlist'"
 
3394
              }
 
3395
            ;;
 
3396
          esac
 
3397
        done
 
3398
 
 
3399
        $opt_dry_run || {
 
3400
          # Make sure we have at least an empty file.
 
3401
          test -f "$nlist" || : > "$nlist"
 
3402
 
 
3403
          if test -n "$exclude_expsyms"; then
 
3404
            $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
 
3405
            $MV "$nlist"T "$nlist"
 
3406
          fi
 
3407
 
 
3408
          # Try sorting and uniquifying the output.
 
3409
          if $GREP -v "^: " < "$nlist" |
 
3410
              if sort -k 3 </dev/null >/dev/null 2>&1; then
 
3411
                sort -k 3
 
3412
              else
 
3413
                sort +2
 
3414
              fi |
 
3415
              uniq > "$nlist"S; then
 
3416
            :
 
3417
          else
 
3418
            $GREP -v "^: " < "$nlist" > "$nlist"S
 
3419
          fi
 
3420
 
 
3421
          if test -f "$nlist"S; then
 
3422
            eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$my_dlsyms"'
 
3423
          else
 
3424
            echo '/* NONE */' >> "$output_objdir/$my_dlsyms"
 
3425
          fi
 
3426
 
 
3427
          echo >> "$output_objdir/$my_dlsyms" "\
 
3428
 
 
3429
/* The mapping between symbol names and symbols.  */
 
3430
typedef struct {
 
3431
  const char *name;
 
3432
  void *address;
 
3433
} lt_dlsymlist;
 
3434
extern LT_DLSYM_CONST lt_dlsymlist
 
3435
lt_${my_prefix}_LTX_preloaded_symbols[];
 
3436
LT_DLSYM_CONST lt_dlsymlist
 
3437
lt_${my_prefix}_LTX_preloaded_symbols[] =
 
3438
{\
 
3439
  { \"$my_originator\", (void *) 0 },"
 
3440
 
 
3441
          case $need_lib_prefix in
 
3442
          no)
 
3443
            eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$my_dlsyms"
 
3444
            ;;
 
3445
          *)
 
3446
            eval "$global_symbol_to_c_name_address_lib_prefix" < "$nlist" >> "$output_objdir/$my_dlsyms"
 
3447
            ;;
 
3448
          esac
 
3449
          echo >> "$output_objdir/$my_dlsyms" "\
 
3450
  {0, (void *) 0}
 
3451
};
 
3452
 
 
3453
/* This works around a problem in FreeBSD linker */
 
3454
#ifdef FREEBSD_WORKAROUND
 
3455
static const void *lt_preloaded_setup() {
 
3456
  return lt_${my_prefix}_LTX_preloaded_symbols;
 
3457
}
 
3458
#endif
 
3459
 
 
3460
#ifdef __cplusplus
 
3461
}
 
3462
#endif\
 
3463
"
 
3464
        } # !$opt_dry_run
 
3465
 
 
3466
        pic_flag_for_symtable=
 
3467
        case "$compile_command " in
 
3468
        *" -static "*) ;;
 
3469
        *)
 
3470
          case $host in
 
3471
          # compiling the symbol table file with pic_flag works around
 
3472
          # a FreeBSD bug that causes programs to crash when -lm is
 
3473
          # linked before any other PIC object.  But we must not use
 
3474
          # pic_flag when linking with -static.  The problem exists in
 
3475
          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
 
3476
          *-*-freebsd2.*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
 
3477
            pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND" ;;
 
3478
          *-*-hpux*)
 
3479
            pic_flag_for_symtable=" $pic_flag"  ;;
 
3480
          *)
 
3481
            if test "X$my_pic_p" != Xno; then
 
3482
              pic_flag_for_symtable=" $pic_flag"
 
3483
            fi
 
3484
            ;;
 
3485
          esac
 
3486
          ;;
 
3487
        esac
 
3488
        symtab_cflags=
 
3489
        for arg in $LTCFLAGS; do
 
3490
          case $arg in
 
3491
          -pie | -fpie | -fPIE) ;;
 
3492
          *) func_append symtab_cflags " $arg" ;;
 
3493
          esac
 
3494
        done
 
3495
 
 
3496
        # Now compile the dynamic symbol file.
 
3497
        func_show_eval '(cd $output_objdir && $LTCC$symtab_cflags -c$no_builtin_flag$pic_flag_for_symtable "$my_dlsyms")' 'exit $?'
 
3498
 
 
3499
        # Clean up the generated files.
 
3500
        func_show_eval '$RM "$output_objdir/$my_dlsyms" "$nlist" "${nlist}S" "${nlist}T"'
 
3501
 
 
3502
        # Transform the symbol file into the correct name.
 
3503
        symfileobj="$output_objdir/${my_outputname}S.$objext"
 
3504
        case $host in
 
3505
        *cygwin* | *mingw* | *cegcc* )
 
3506
          if test -f "$output_objdir/$my_outputname.def"; then
 
3507
            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
 
3508
            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$output_objdir/$my_outputname.def $symfileobj%"`
 
3509
          else
 
3510
            compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
 
3511
            finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
 
3512
          fi
 
3513
          ;;
 
3514
        *)
 
3515
          compile_command=`$ECHO "$compile_command" | $SED "s%@SYMFILE@%$symfileobj%"`
 
3516
          finalize_command=`$ECHO "$finalize_command" | $SED "s%@SYMFILE@%$symfileobj%"`
 
3517
          ;;
 
3518
        esac
 
3519
        ;;
 
3520
      *)
 
3521
        func_fatal_error "unknown suffix for \`$my_dlsyms'"
 
3522
        ;;
 
3523
      esac
 
3524
    else
 
3525
      # We keep going just in case the user didn't refer to
 
3526
      # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
 
3527
      # really was required.
 
3528
 
 
3529
      # Nullify the symbol file.
 
3530
      compile_command=`$ECHO "$compile_command" | $SED "s% @SYMFILE@%%"`
 
3531
      finalize_command=`$ECHO "$finalize_command" | $SED "s% @SYMFILE@%%"`
 
3532
    fi
 
3533
}
 
3534
 
 
3535
# func_win32_libid arg
 
3536
# return the library type of file 'arg'
 
3537
#
 
3538
# Need a lot of goo to handle *both* DLLs and import libs
 
3539
# Has to be a shell function in order to 'eat' the argument
 
3540
# that is supplied when $file_magic_command is called.
 
3541
# Despite the name, also deal with 64 bit binaries.
 
3542
func_win32_libid ()
 
3543
{
 
3544
  $opt_debug
 
3545
  win32_libid_type="unknown"
 
3546
  win32_fileres=`file -L $1 2>/dev/null`
 
3547
  case $win32_fileres in
 
3548
  *ar\ archive\ import\ library*) # definitely import
 
3549
    win32_libid_type="x86 archive import"
 
3550
    ;;
 
3551
  *ar\ archive*) # could be an import, or static
 
3552
    # Keep the egrep pattern in sync with the one in _LT_CHECK_MAGIC_METHOD.
 
3553
    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null |
 
3554
       $EGREP 'file format (pei*-i386(.*architecture: i386)?|pe-arm-wince|pe-x86-64)' >/dev/null; then
 
3555
      func_to_tool_file "$1" func_convert_file_msys_to_w32
 
3556
      win32_nmres=`eval $NM -f posix -A \"$func_to_tool_file_result\" |
 
3557
        $SED -n -e '
 
3558
            1,100{
 
3559
                / I /{
 
3560
                    s,.*,import,
 
3561
                    p
 
3562
                    q
 
3563
                }
 
3564
            }'`
 
3565
      case $win32_nmres in
 
3566
      import*)  win32_libid_type="x86 archive import";;
 
3567
      *)        win32_libid_type="x86 archive static";;
 
3568
      esac
 
3569
    fi
 
3570
    ;;
 
3571
  *DLL*)
 
3572
    win32_libid_type="x86 DLL"
 
3573
    ;;
 
3574
  *executable*) # but shell scripts are "executable" too...
 
3575
    case $win32_fileres in
 
3576
    *MS\ Windows\ PE\ Intel*)
 
3577
      win32_libid_type="x86 DLL"
 
3578
      ;;
 
3579
    esac
 
3580
    ;;
 
3581
  esac
 
3582
  $ECHO "$win32_libid_type"
 
3583
}
 
3584
 
 
3585
# func_cygming_dll_for_implib ARG
 
3586
#
 
3587
# Platform-specific function to extract the
 
3588
# name of the DLL associated with the specified
 
3589
# import library ARG.
 
3590
# Invoked by eval'ing the libtool variable
 
3591
#    $sharedlib_from_linklib_cmd
 
3592
# Result is available in the variable
 
3593
#    $sharedlib_from_linklib_result
 
3594
func_cygming_dll_for_implib ()
 
3595
{
 
3596
  $opt_debug
 
3597
  sharedlib_from_linklib_result=`$DLLTOOL --identify-strict --identify "$1"`
 
3598
}
 
3599
 
 
3600
# func_cygming_dll_for_implib_fallback_core SECTION_NAME LIBNAMEs
 
3601
#
 
3602
# The is the core of a fallback implementation of a
 
3603
# platform-specific function to extract the name of the
 
3604
# DLL associated with the specified import library LIBNAME.
 
3605
#
 
3606
# SECTION_NAME is either .idata$6 or .idata$7, depending
 
3607
# on the platform and compiler that created the implib.
 
3608
#
 
3609
# Echos the name of the DLL associated with the
 
3610
# specified import library.
 
3611
func_cygming_dll_for_implib_fallback_core ()
 
3612
{
 
3613
  $opt_debug
 
3614
  match_literal=`$ECHO "$1" | $SED "$sed_make_literal_regex"`
 
3615
  $OBJDUMP -s --section "$1" "$2" 2>/dev/null |
 
3616
    $SED '/^Contents of section '"$match_literal"':/{
 
3617
      # Place marker at beginning of archive member dllname section
 
3618
      s/.*/====MARK====/
 
3619
      p
 
3620
      d
 
3621
    }
 
3622
    # These lines can sometimes be longer than 43 characters, but
 
3623
    # are always uninteresting
 
3624
    /:[  ]*file format pe[i]\{,1\}-/d
 
3625
    /^In archive [^:]*:/d
 
3626
    # Ensure marker is printed
 
3627
    /^====MARK====/p
 
3628
    # Remove all lines with less than 43 characters
 
3629
    /^.\{43\}/!d
 
3630
    # From remaining lines, remove first 43 characters
 
3631
    s/^.\{43\}//' |
 
3632
    $SED -n '
 
3633
      # Join marker and all lines until next marker into a single line
 
3634
      /^====MARK====/ b para
 
3635
      H
 
3636
      $ b para
 
3637
      b
 
3638
      :para
 
3639
      x
 
3640
      s/\n//g
 
3641
      # Remove the marker
 
3642
      s/^====MARK====//
 
3643
      # Remove trailing dots and whitespace
 
3644
      s/[\. \t]*$//
 
3645
      # Print
 
3646
      /./p' |
 
3647
    # we now have a list, one entry per line, of the stringified
 
3648
    # contents of the appropriate section of all members of the
 
3649
    # archive which possess that section. Heuristic: eliminate
 
3650
    # all those which have a first or second character that is
 
3651
    # a '.' (that is, objdump's representation of an unprintable
 
3652
    # character.) This should work for all archives with less than
 
3653
    # 0x302f exports -- but will fail for DLLs whose name actually
 
3654
    # begins with a literal '.' or a single character followed by
 
3655
    # a '.'.
 
3656
    #
 
3657
    # Of those that remain, print the first one.
 
3658
    $SED -e '/^\./d;/^.\./d;q'
 
3659
}
 
3660
 
 
3661
# func_cygming_gnu_implib_p ARG
 
3662
# This predicate returns with zero status (TRUE) if
 
3663
# ARG is a GNU/binutils-style import library. Returns
 
3664
# with nonzero status (FALSE) otherwise.
 
3665
func_cygming_gnu_implib_p ()
 
3666
{
 
3667
  $opt_debug
 
3668
  func_to_tool_file "$1" func_convert_file_msys_to_w32
 
3669
  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)$'`
 
3670
  test -n "$func_cygming_gnu_implib_tmp"
 
3671
}
 
3672
 
 
3673
# func_cygming_ms_implib_p ARG
 
3674
# This predicate returns with zero status (TRUE) if
 
3675
# ARG is an MS-style import library. Returns
 
3676
# with nonzero status (FALSE) otherwise.
 
3677
func_cygming_ms_implib_p ()
 
3678
{
 
3679
  $opt_debug
 
3680
  func_to_tool_file "$1" func_convert_file_msys_to_w32
 
3681
  func_cygming_ms_implib_tmp=`$NM "$func_to_tool_file_result" | eval "$global_symbol_pipe" | $GREP '_NULL_IMPORT_DESCRIPTOR'`
 
3682
  test -n "$func_cygming_ms_implib_tmp"
 
3683
}
 
3684
 
 
3685
# func_cygming_dll_for_implib_fallback ARG
 
3686
# Platform-specific function to extract the
 
3687
# name of the DLL associated with the specified
 
3688
# import library ARG.
 
3689
#
 
3690
# This fallback implementation is for use when $DLLTOOL
 
3691
# does not support the --identify-strict option.
 
3692
# Invoked by eval'ing the libtool variable
 
3693
#    $sharedlib_from_linklib_cmd
 
3694
# Result is available in the variable
 
3695
#    $sharedlib_from_linklib_result
 
3696
func_cygming_dll_for_implib_fallback ()
 
3697
{
 
3698
  $opt_debug
 
3699
  if func_cygming_gnu_implib_p "$1" ; then
 
3700
    # binutils import library
 
3701
    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$7' "$1"`
 
3702
  elif func_cygming_ms_implib_p "$1" ; then
 
3703
    # ms-generated import library
 
3704
    sharedlib_from_linklib_result=`func_cygming_dll_for_implib_fallback_core '.idata$6' "$1"`
 
3705
  else
 
3706
    # unknown
 
3707
    sharedlib_from_linklib_result=""
 
3708
  fi
 
3709
}
 
3710
 
 
3711
 
 
3712
# func_extract_an_archive dir oldlib
 
3713
func_extract_an_archive ()
 
3714
{
 
3715
    $opt_debug
 
3716
    f_ex_an_ar_dir="$1"; shift
 
3717
    f_ex_an_ar_oldlib="$1"
 
3718
    if test "$lock_old_archive_extraction" = yes; then
 
3719
      lockfile=$f_ex_an_ar_oldlib.lock
 
3720
      until $opt_dry_run || ln "$progpath" "$lockfile" 2>/dev/null; do
 
3721
        func_echo "Waiting for $lockfile to be removed"
 
3722
        sleep 2
 
3723
      done
 
3724
    fi
 
3725
    func_show_eval "(cd \$f_ex_an_ar_dir && $AR x \"\$f_ex_an_ar_oldlib\")" \
 
3726
                   'stat=$?; rm -f "$lockfile"; exit $stat'
 
3727
    if test "$lock_old_archive_extraction" = yes; then
 
3728
      $opt_dry_run || rm -f "$lockfile"
 
3729
    fi
 
3730
    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
 
3731
     :
 
3732
    else
 
3733
      func_fatal_error "object name conflicts in archive: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib"
 
3734
    fi
 
3735
}
 
3736
 
 
3737
 
 
3738
# func_extract_archives gentop oldlib ...
 
3739
func_extract_archives ()
 
3740
{
 
3741
    $opt_debug
 
3742
    my_gentop="$1"; shift
 
3743
    my_oldlibs=${1+"$@"}
 
3744
    my_oldobjs=""
 
3745
    my_xlib=""
 
3746
    my_xabs=""
 
3747
    my_xdir=""
 
3748
 
 
3749
    for my_xlib in $my_oldlibs; do
 
3750
      # Extract the objects.
 
3751
      case $my_xlib in
 
3752
        [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
 
3753
        *) my_xabs=`pwd`"/$my_xlib" ;;
 
3754
      esac
 
3755
      func_basename "$my_xlib"
 
3756
      my_xlib="$func_basename_result"
 
3757
      my_xlib_u=$my_xlib
 
3758
      while :; do
 
3759
        case " $extracted_archives " in
 
3760
        *" $my_xlib_u "*)
 
3761
          func_arith $extracted_serial + 1
 
3762
          extracted_serial=$func_arith_result
 
3763
          my_xlib_u=lt$extracted_serial-$my_xlib ;;
 
3764
        *) break ;;
 
3765
        esac
 
3766
      done
 
3767
      extracted_archives="$extracted_archives $my_xlib_u"
 
3768
      my_xdir="$my_gentop/$my_xlib_u"
 
3769
 
 
3770
      func_mkdir_p "$my_xdir"
 
3771
 
 
3772
      case $host in
 
3773
      *-darwin*)
 
3774
        func_verbose "Extracting $my_xabs"
 
3775
        # Do not bother doing anything if just a dry run
 
3776
        $opt_dry_run || {
 
3777
          darwin_orig_dir=`pwd`
 
3778
          cd $my_xdir || exit $?
 
3779
          darwin_archive=$my_xabs
 
3780
          darwin_curdir=`pwd`
 
3781
          darwin_base_archive=`basename "$darwin_archive"`
 
3782
          darwin_arches=`$LIPO -info "$darwin_archive" 2>/dev/null | $GREP Architectures 2>/dev/null || true`
 
3783
          if test -n "$darwin_arches"; then
 
3784
            darwin_arches=`$ECHO "$darwin_arches" | $SED -e 's/.*are://'`
 
3785
            darwin_arch=
 
3786
            func_verbose "$darwin_base_archive has multiple architectures $darwin_arches"
 
3787
            for darwin_arch in  $darwin_arches ; do
 
3788
              func_mkdir_p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
 
3789
              $LIPO -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
 
3790
              cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
 
3791
              func_extract_an_archive "`pwd`" "${darwin_base_archive}"
 
3792
              cd "$darwin_curdir"
 
3793
              $RM "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
 
3794
            done # $darwin_arches
 
3795
            ## Okay now we've a bunch of thin objects, gotta fatten them up :)
 
3796
            darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print | $SED -e "$basename" | sort -u`
 
3797
            darwin_file=
 
3798
            darwin_files=
 
3799
            for darwin_file in $darwin_filelist; do
 
3800
              darwin_files=`find unfat-$$ -name $darwin_file -print | sort | $NL2SP`
 
3801
              $LIPO -create -output "$darwin_file" $darwin_files
 
3802
            done # $darwin_filelist
 
3803
            $RM -rf unfat-$$
 
3804
            cd "$darwin_orig_dir"
 
3805
          else
 
3806
            cd $darwin_orig_dir
 
3807
            func_extract_an_archive "$my_xdir" "$my_xabs"
 
3808
          fi # $darwin_arches
 
3809
        } # !$opt_dry_run
 
3810
        ;;
 
3811
      *)
 
3812
        func_extract_an_archive "$my_xdir" "$my_xabs"
 
3813
        ;;
 
3814
      esac
 
3815
      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | sort | $NL2SP`
 
3816
    done
 
3817
 
 
3818
    func_extract_archives_result="$my_oldobjs"
 
3819
}
 
3820
 
 
3821
 
 
3822
# func_emit_wrapper [arg=no]
 
3823
#
 
3824
# Emit a libtool wrapper script on stdout.
 
3825
# Don't directly open a file because we may want to
 
3826
# incorporate the script contents within a cygwin/mingw
 
3827
# wrapper executable.  Must ONLY be called from within
 
3828
# func_mode_link because it depends on a number of variables
 
3829
# set therein.
 
3830
#
 
3831
# ARG is the value that the WRAPPER_SCRIPT_BELONGS_IN_OBJDIR
 
3832
# variable will take.  If 'yes', then the emitted script
 
3833
# will assume that the directory in which it is stored is
 
3834
# the $objdir directory.  This is a cygwin/mingw-specific
 
3835
# behavior.
 
3836
func_emit_wrapper ()
 
3837
{
 
3838
        func_emit_wrapper_arg1=${1-no}
 
3839
 
 
3840
        $ECHO "\
 
3841
#! $SHELL
 
3842
 
 
3843
# $output - temporary wrapper script for $objdir/$outputname
 
3844
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
 
3845
#
 
3846
# The $output program cannot be directly executed until all the libtool
 
3847
# libraries that it depends on are installed.
 
3848
#
 
3849
# This wrapper script should never be moved out of the build directory.
 
3850
# If it is, it will not operate correctly.
 
3851
 
 
3852
# Sed substitution that helps us do robust quoting.  It backslashifies
 
3853
# metacharacters that are still active within double-quoted strings.
 
3854
sed_quote_subst='$sed_quote_subst'
 
3855
 
 
3856
# Be Bourne compatible
 
3857
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
 
3858
  emulate sh
 
3859
  NULLCMD=:
 
3860
  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
 
3861
  # is contrary to our usage.  Disable this feature.
 
3862
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
 
3863
  setopt NO_GLOB_SUBST
 
3864
else
 
3865
  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
 
3866
fi
 
3867
BIN_SH=xpg4; export BIN_SH # for Tru64
 
3868
DUALCASE=1; export DUALCASE # for MKS sh
 
3869
 
 
3870
# The HP-UX ksh and POSIX shell print the target directory to stdout
 
3871
# if CDPATH is set.
 
3872
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
 
3873
 
 
3874
relink_command=\"$relink_command\"
 
3875
 
 
3876
# This environment variable determines our operation mode.
 
3877
if test \"\$libtool_install_magic\" = \"$magic\"; then
 
3878
  # install mode needs the following variables:
 
3879
  generated_by_libtool_version='$macro_version'
 
3880
  notinst_deplibs='$notinst_deplibs'
 
3881
else
 
3882
  # When we are sourced in execute mode, \$file and \$ECHO are already set.
 
3883
  if test \"\$libtool_execute_magic\" != \"$magic\"; then
 
3884
    file=\"\$0\""
 
3885
 
 
3886
    qECHO=`$ECHO "$ECHO" | $SED "$sed_quote_subst"`
 
3887
    $ECHO "\
 
3888
 
 
3889
# A function that is used when there is no print builtin or printf.
 
3890
func_fallback_echo ()
 
3891
{
 
3892
  eval 'cat <<_LTECHO_EOF
 
3893
\$1
 
3894
_LTECHO_EOF'
 
3895
}
 
3896
    ECHO=\"$qECHO\"
 
3897
  fi
 
3898
 
 
3899
# Very basic option parsing. These options are (a) specific to
 
3900
# the libtool wrapper, (b) are identical between the wrapper
 
3901
# /script/ and the wrapper /executable/ which is used only on
 
3902
# windows platforms, and (c) all begin with the string "--lt-"
 
3903
# (application programs are unlikely to have options which match
 
3904
# this pattern).
 
3905
#
 
3906
# There are only two supported options: --lt-debug and
 
3907
# --lt-dump-script. There is, deliberately, no --lt-help.
 
3908
#
 
3909
# The first argument to this parsing function should be the
 
3910
# script's $0 value, followed by "$@".
 
3911
lt_option_debug=
 
3912
func_parse_lt_options ()
 
3913
{
 
3914
  lt_script_arg0=\$0
 
3915
  shift
 
3916
  for lt_opt
 
3917
  do
 
3918
    case \"\$lt_opt\" in
 
3919
    --lt-debug) lt_option_debug=1 ;;
 
3920
    --lt-dump-script)
 
3921
        lt_dump_D=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%/[^/]*$%%'\`
 
3922
        test \"X\$lt_dump_D\" = \"X\$lt_script_arg0\" && lt_dump_D=.
 
3923
        lt_dump_F=\`\$ECHO \"X\$lt_script_arg0\" | $SED -e 's/^X//' -e 's%^.*/%%'\`
 
3924
        cat \"\$lt_dump_D/\$lt_dump_F\"
 
3925
        exit 0
 
3926
      ;;
 
3927
    --lt-*)
 
3928
        \$ECHO \"Unrecognized --lt- option: '\$lt_opt'\" 1>&2
 
3929
        exit 1
 
3930
      ;;
 
3931
    esac
 
3932
  done
 
3933
 
 
3934
  # Print the debug banner immediately:
 
3935
  if test -n \"\$lt_option_debug\"; then
 
3936
    echo \"${outputname}:${output}:\${LINENO}: libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\" 1>&2
 
3937
  fi
 
3938
}
 
3939
 
 
3940
# Used when --lt-debug. Prints its arguments to stdout
 
3941
# (redirection is the responsibility of the caller)
 
3942
func_lt_dump_args ()
 
3943
{
 
3944
  lt_dump_args_N=1;
 
3945
  for lt_arg
 
3946
  do
 
3947
    \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[\$lt_dump_args_N]: \$lt_arg\"
 
3948
    lt_dump_args_N=\`expr \$lt_dump_args_N + 1\`
 
3949
  done
 
3950
}
 
3951
 
 
3952
# Core function for launching the target application
 
3953
func_exec_program_core ()
 
3954
{
 
3955
"
 
3956
  case $host in
 
3957
  # Backslashes separate directories on plain windows
 
3958
  *-*-mingw | *-*-os2* | *-cegcc*)
 
3959
    $ECHO "\
 
3960
      if test -n \"\$lt_option_debug\"; then
 
3961
        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir\\\\\$program\" 1>&2
 
3962
        func_lt_dump_args \${1+\"\$@\"} 1>&2
 
3963
      fi
 
3964
      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
 
3965
"
 
3966
    ;;
 
3967
 
 
3968
  *)
 
3969
    $ECHO "\
 
3970
      if test -n \"\$lt_option_debug\"; then
 
3971
        \$ECHO \"${outputname}:${output}:\${LINENO}: newargv[0]: \$progdir/\$program\" 1>&2
 
3972
        func_lt_dump_args \${1+\"\$@\"} 1>&2
 
3973
      fi
 
3974
      exec \"\$progdir/\$program\" \${1+\"\$@\"}
 
3975
"
 
3976
    ;;
 
3977
  esac
 
3978
  $ECHO "\
 
3979
      \$ECHO \"\$0: cannot exec \$program \$*\" 1>&2
 
3980
      exit 1
 
3981
}
 
3982
 
 
3983
# A function to encapsulate launching the target application
 
3984
# Strips options in the --lt-* namespace from \$@ and
 
3985
# launches target application with the remaining arguments.
 
3986
func_exec_program ()
 
3987
{
 
3988
  case \" \$* \" in
 
3989
  *\\ --lt-*)
 
3990
    for lt_wr_arg
 
3991
    do
 
3992
      case \$lt_wr_arg in
 
3993
      --lt-*) ;;
 
3994
      *) set x \"\$@\" \"\$lt_wr_arg\"; shift;;
 
3995
      esac
 
3996
      shift
 
3997
    done ;;
 
3998
  esac
 
3999
  func_exec_program_core \${1+\"\$@\"}
 
4000
}
 
4001
 
 
4002
  # Parse options
 
4003
  func_parse_lt_options \"\$0\" \${1+\"\$@\"}
 
4004
 
 
4005
  # Find the directory that this script lives in.
 
4006
  thisdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*$%%'\`
 
4007
  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
 
4008
 
 
4009
  # Follow symbolic links until we get to the real thisdir.
 
4010
  file=\`ls -ld \"\$file\" | $SED -n 's/.*-> //p'\`
 
4011
  while test -n \"\$file\"; do
 
4012
    destdir=\`\$ECHO \"\$file\" | $SED 's%/[^/]*\$%%'\`
 
4013
 
 
4014
    # If there was a directory component, then change thisdir.
 
4015
    if test \"x\$destdir\" != \"x\$file\"; then
 
4016
      case \"\$destdir\" in
 
4017
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
 
4018
      *) thisdir=\"\$thisdir/\$destdir\" ;;
 
4019
      esac
 
4020
    fi
 
4021
 
 
4022
    file=\`\$ECHO \"\$file\" | $SED 's%^.*/%%'\`
 
4023
    file=\`ls -ld \"\$thisdir/\$file\" | $SED -n 's/.*-> //p'\`
 
4024
  done
 
4025
 
 
4026
  # Usually 'no', except on cygwin/mingw when embedded into
 
4027
  # the cwrapper.
 
4028
  WRAPPER_SCRIPT_BELONGS_IN_OBJDIR=$func_emit_wrapper_arg1
 
4029
  if test \"\$WRAPPER_SCRIPT_BELONGS_IN_OBJDIR\" = \"yes\"; then
 
4030
    # special case for '.'
 
4031
    if test \"\$thisdir\" = \".\"; then
 
4032
      thisdir=\`pwd\`
 
4033
    fi
 
4034
    # remove .libs from thisdir
 
4035
    case \"\$thisdir\" in
 
4036
    *[\\\\/]$objdir ) thisdir=\`\$ECHO \"\$thisdir\" | $SED 's%[\\\\/][^\\\\/]*$%%'\` ;;
 
4037
    $objdir )   thisdir=. ;;
 
4038
    esac
 
4039
  fi
 
4040
 
 
4041
  # Try to get the absolute directory name.
 
4042
  absdir=\`cd \"\$thisdir\" && pwd\`
 
4043
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
 
4044
"
 
4045
 
 
4046
        if test "$fast_install" = yes; then
 
4047
          $ECHO "\
 
4048
  program=lt-'$outputname'$exeext
 
4049
  progdir=\"\$thisdir/$objdir\"
 
4050
 
 
4051
  if test ! -f \"\$progdir/\$program\" ||
 
4052
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
 
4053
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
 
4054
 
 
4055
    file=\"\$\$-\$program\"
 
4056
 
 
4057
    if test ! -d \"\$progdir\"; then
 
4058
      $MKDIR \"\$progdir\"
 
4059
    else
 
4060
      $RM \"\$progdir/\$file\"
 
4061
    fi"
 
4062
 
 
4063
          $ECHO "\
 
4064
 
 
4065
    # relink executable if necessary
 
4066
    if test -n \"\$relink_command\"; then
 
4067
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
 
4068
      else
 
4069
        $ECHO \"\$relink_command_output\" >&2
 
4070
        $RM \"\$progdir/\$file\"
 
4071
        exit 1
 
4072
      fi
 
4073
    fi
 
4074
 
 
4075
    $MV \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
 
4076
    { $RM \"\$progdir/\$program\";
 
4077
      $MV \"\$progdir/\$file\" \"\$progdir/\$program\"; }
 
4078
    $RM \"\$progdir/\$file\"
 
4079
  fi"
 
4080
        else
 
4081
          $ECHO "\
 
4082
  program='$outputname'
 
4083
  progdir=\"\$thisdir/$objdir\"
 
4084
"
 
4085
        fi
 
4086
 
 
4087
        $ECHO "\
 
4088
 
 
4089
  if test -f \"\$progdir/\$program\"; then"
 
4090
 
 
4091
        # fixup the dll searchpath if we need to.
 
4092
        #
 
4093
        # Fix the DLL searchpath if we need to.  Do this before prepending
 
4094
        # to shlibpath, because on Windows, both are PATH and uninstalled
 
4095
        # libraries must come first.
 
4096
        if test -n "$dllsearchpath"; then
 
4097
          $ECHO "\
 
4098
    # Add the dll search path components to the executable PATH
 
4099
    PATH=$dllsearchpath:\$PATH
 
4100
"
 
4101
        fi
 
4102
 
 
4103
        # Export our shlibpath_var if we have one.
 
4104
        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
 
4105
          $ECHO "\
 
4106
    # Add our own library path to $shlibpath_var
 
4107
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
 
4108
 
 
4109
    # Some systems cannot cope with colon-terminated $shlibpath_var
 
4110
    # The second colon is a workaround for a bug in BeOS R4 sed
 
4111
    $shlibpath_var=\`\$ECHO \"\$$shlibpath_var\" | $SED 's/::*\$//'\`
 
4112
 
 
4113
    export $shlibpath_var
 
4114
"
 
4115
        fi
 
4116
 
 
4117
        $ECHO "\
 
4118
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
 
4119
      # Run the actual program with our arguments.
 
4120
      func_exec_program \${1+\"\$@\"}
 
4121
    fi
 
4122
  else
 
4123
    # The program doesn't exist.
 
4124
    \$ECHO \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
 
4125
    \$ECHO \"This script is just a wrapper for \$program.\" 1>&2
 
4126
    \$ECHO \"See the $PACKAGE documentation for more information.\" 1>&2
 
4127
    exit 1
 
4128
  fi
 
4129
fi\
 
4130
"
 
4131
}
 
4132
 
 
4133
 
 
4134
# func_emit_cwrapperexe_src
 
4135
# emit the source code for a wrapper executable on stdout
 
4136
# Must ONLY be called from within func_mode_link because
 
4137
# it depends on a number of variable set therein.
 
4138
func_emit_cwrapperexe_src ()
 
4139
{
 
4140
        cat <<EOF
 
4141
 
 
4142
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
 
4143
   Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
 
4144
 
 
4145
   The $output program cannot be directly executed until all the libtool
 
4146
   libraries that it depends on are installed.
 
4147
 
 
4148
   This wrapper executable should never be moved out of the build directory.
 
4149
   If it is, it will not operate correctly.
 
4150
*/
 
4151
EOF
 
4152
            cat <<"EOF"
 
4153
#ifdef _MSC_VER
 
4154
# define _CRT_SECURE_NO_DEPRECATE 1
 
4155
#endif
 
4156
#include <stdio.h>
 
4157
#include <stdlib.h>
 
4158
#ifdef _MSC_VER
 
4159
# include <direct.h>
 
4160
# include <process.h>
 
4161
# include <io.h>
 
4162
#else
 
4163
# include <unistd.h>
 
4164
# include <stdint.h>
 
4165
# ifdef __CYGWIN__
 
4166
#  include <io.h>
 
4167
# endif
 
4168
#endif
 
4169
#include <malloc.h>
 
4170
#include <stdarg.h>
 
4171
#include <assert.h>
 
4172
#include <string.h>
 
4173
#include <ctype.h>
 
4174
#include <errno.h>
 
4175
#include <fcntl.h>
 
4176
#include <sys/stat.h>
 
4177
 
 
4178
/* declarations of non-ANSI functions */
 
4179
#if defined(__MINGW32__)
 
4180
# ifdef __STRICT_ANSI__
 
4181
int _putenv (const char *);
 
4182
# endif
 
4183
#elif defined(__CYGWIN__)
 
4184
# ifdef __STRICT_ANSI__
 
4185
char *realpath (const char *, char *);
 
4186
int putenv (char *);
 
4187
int setenv (const char *, const char *, int);
 
4188
# endif
 
4189
/* #elif defined (other platforms) ... */
 
4190
#endif
 
4191
 
 
4192
/* portability defines, excluding path handling macros */
 
4193
#if defined(_MSC_VER)
 
4194
# define setmode _setmode
 
4195
# define stat    _stat
 
4196
# define chmod   _chmod
 
4197
# define getcwd  _getcwd
 
4198
# define putenv  _putenv
 
4199
# define S_IXUSR _S_IEXEC
 
4200
# ifndef _INTPTR_T_DEFINED
 
4201
#  define _INTPTR_T_DEFINED
 
4202
#  define intptr_t int
 
4203
# endif
 
4204
#elif defined(__MINGW32__)
 
4205
# define setmode _setmode
 
4206
# define stat    _stat
 
4207
# define chmod   _chmod
 
4208
# define getcwd  _getcwd
 
4209
# define putenv  _putenv
 
4210
#elif defined(__CYGWIN__)
 
4211
# define HAVE_SETENV
 
4212
# define FOPEN_WB "wb"
 
4213
/* #elif defined (other platforms) ... */
 
4214
#endif
 
4215
 
 
4216
#if defined(PATH_MAX)
 
4217
# define LT_PATHMAX PATH_MAX
 
4218
#elif defined(MAXPATHLEN)
 
4219
# define LT_PATHMAX MAXPATHLEN
 
4220
#else
 
4221
# define LT_PATHMAX 1024
 
4222
#endif
 
4223
 
 
4224
#ifndef S_IXOTH
 
4225
# define S_IXOTH 0
 
4226
#endif
 
4227
#ifndef S_IXGRP
 
4228
# define S_IXGRP 0
 
4229
#endif
 
4230
 
 
4231
/* path handling portability macros */
 
4232
#ifndef DIR_SEPARATOR
 
4233
# define DIR_SEPARATOR '/'
 
4234
# define PATH_SEPARATOR ':'
 
4235
#endif
 
4236
 
 
4237
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
 
4238
  defined (__OS2__)
 
4239
# define HAVE_DOS_BASED_FILE_SYSTEM
 
4240
# define FOPEN_WB "wb"
 
4241
# ifndef DIR_SEPARATOR_2
 
4242
#  define DIR_SEPARATOR_2 '\\'
 
4243
# endif
 
4244
# ifndef PATH_SEPARATOR_2
 
4245
#  define PATH_SEPARATOR_2 ';'
 
4246
# endif
 
4247
#endif
 
4248
 
 
4249
#ifndef DIR_SEPARATOR_2
 
4250
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
 
4251
#else /* DIR_SEPARATOR_2 */
 
4252
# define IS_DIR_SEPARATOR(ch) \
 
4253
        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
 
4254
#endif /* DIR_SEPARATOR_2 */
 
4255
 
 
4256
#ifndef PATH_SEPARATOR_2
 
4257
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
 
4258
#else /* PATH_SEPARATOR_2 */
 
4259
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
 
4260
#endif /* PATH_SEPARATOR_2 */
 
4261
 
 
4262
#ifndef FOPEN_WB
 
4263
# define FOPEN_WB "w"
 
4264
#endif
 
4265
#ifndef _O_BINARY
 
4266
# define _O_BINARY 0
 
4267
#endif
 
4268
 
 
4269
#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
 
4270
#define XFREE(stale) do { \
 
4271
  if (stale) { free ((void *) stale); stale = 0; } \
 
4272
} while (0)
 
4273
 
 
4274
#if defined(LT_DEBUGWRAPPER)
 
4275
static int lt_debug = 1;
 
4276
#else
 
4277
static int lt_debug = 0;
 
4278
#endif
 
4279
 
 
4280
const char *program_name = "libtool-wrapper"; /* in case xstrdup fails */
 
4281
 
 
4282
void *xmalloc (size_t num);
 
4283
char *xstrdup (const char *string);
 
4284
const char *base_name (const char *name);
 
4285
char *find_executable (const char *wrapper);
 
4286
char *chase_symlinks (const char *pathspec);
 
4287
int make_executable (const char *path);
 
4288
int check_executable (const char *path);
 
4289
char *strendzap (char *str, const char *pat);
 
4290
void lt_debugprintf (const char *file, int line, const char *fmt, ...);
 
4291
void lt_fatal (const char *file, int line, const char *message, ...);
 
4292
static const char *nonnull (const char *s);
 
4293
static const char *nonempty (const char *s);
 
4294
void lt_setenv (const char *name, const char *value);
 
4295
char *lt_extend_str (const char *orig_value, const char *add, int to_end);
 
4296
void lt_update_exe_path (const char *name, const char *value);
 
4297
void lt_update_lib_path (const char *name, const char *value);
 
4298
char **prepare_spawn (char **argv);
 
4299
void lt_dump_script (FILE *f);
 
4300
EOF
 
4301
 
 
4302
            cat <<EOF
 
4303
volatile const char * MAGIC_EXE = "$magic_exe";
 
4304
const char * LIB_PATH_VARNAME = "$shlibpath_var";
 
4305
EOF
 
4306
 
 
4307
            if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
 
4308
              func_to_host_path "$temp_rpath"
 
4309
              cat <<EOF
 
4310
const char * LIB_PATH_VALUE   = "$func_to_host_path_result";
 
4311
EOF
 
4312
            else
 
4313
              cat <<"EOF"
 
4314
const char * LIB_PATH_VALUE   = "";
 
4315
EOF
 
4316
            fi
 
4317
 
 
4318
            if test -n "$dllsearchpath"; then
 
4319
              func_to_host_path "$dllsearchpath:"
 
4320
              cat <<EOF
 
4321
const char * EXE_PATH_VARNAME = "PATH";
 
4322
const char * EXE_PATH_VALUE   = "$func_to_host_path_result";
 
4323
EOF
 
4324
            else
 
4325
              cat <<"EOF"
 
4326
const char * EXE_PATH_VARNAME = "";
 
4327
const char * EXE_PATH_VALUE   = "";
 
4328
EOF
 
4329
            fi
 
4330
 
 
4331
            if test "$fast_install" = yes; then
 
4332
              cat <<EOF
 
4333
const char * TARGET_PROGRAM_NAME = "lt-$outputname"; /* hopefully, no .exe */
 
4334
EOF
 
4335
            else
 
4336
              cat <<EOF
 
4337
const char * TARGET_PROGRAM_NAME = "$outputname"; /* hopefully, no .exe */
 
4338
EOF
 
4339
            fi
 
4340
 
 
4341
 
 
4342
            cat <<"EOF"
 
4343
 
 
4344
#define LTWRAPPER_OPTION_PREFIX         "--lt-"
 
4345
 
 
4346
static const char *ltwrapper_option_prefix = LTWRAPPER_OPTION_PREFIX;
 
4347
static const char *dumpscript_opt       = LTWRAPPER_OPTION_PREFIX "dump-script";
 
4348
static const char *debug_opt            = LTWRAPPER_OPTION_PREFIX "debug";
 
4349
 
 
4350
int
 
4351
main (int argc, char *argv[])
 
4352
{
 
4353
  char **newargz;
 
4354
  int  newargc;
 
4355
  char *tmp_pathspec;
 
4356
  char *actual_cwrapper_path;
 
4357
  char *actual_cwrapper_name;
 
4358
  char *target_name;
 
4359
  char *lt_argv_zero;
 
4360
  intptr_t rval = 127;
 
4361
 
 
4362
  int i;
 
4363
 
 
4364
  program_name = (char *) xstrdup (base_name (argv[0]));
 
4365
  newargz = XMALLOC (char *, argc + 1);
 
4366
 
 
4367
  /* very simple arg parsing; don't want to rely on getopt
 
4368
   * also, copy all non cwrapper options to newargz, except
 
4369
   * argz[0], which is handled differently
 
4370
   */
 
4371
  newargc=0;
 
4372
  for (i = 1; i < argc; i++)
 
4373
    {
 
4374
      if (strcmp (argv[i], dumpscript_opt) == 0)
 
4375
        {
 
4376
EOF
 
4377
            case "$host" in
 
4378
              *mingw* | *cygwin* )
 
4379
                # make stdout use "unix" line endings
 
4380
                echo "          setmode(1,_O_BINARY);"
 
4381
                ;;
 
4382
              esac
 
4383
 
 
4384
            cat <<"EOF"
 
4385
          lt_dump_script (stdout);
 
4386
          return 0;
 
4387
        }
 
4388
      if (strcmp (argv[i], debug_opt) == 0)
 
4389
        {
 
4390
          lt_debug = 1;
 
4391
          continue;
 
4392
        }
 
4393
      if (strcmp (argv[i], ltwrapper_option_prefix) == 0)
 
4394
        {
 
4395
          /* however, if there is an option in the LTWRAPPER_OPTION_PREFIX
 
4396
             namespace, but it is not one of the ones we know about and
 
4397
             have already dealt with, above (inluding dump-script), then
 
4398
             report an error. Otherwise, targets might begin to believe
 
4399
             they are allowed to use options in the LTWRAPPER_OPTION_PREFIX
 
4400
             namespace. The first time any user complains about this, we'll
 
4401
             need to make LTWRAPPER_OPTION_PREFIX a configure-time option
 
4402
             or a configure.ac-settable value.
 
4403
           */
 
4404
          lt_fatal (__FILE__, __LINE__,
 
4405
                    "unrecognized %s option: '%s'",
 
4406
                    ltwrapper_option_prefix, argv[i]);
 
4407
        }
 
4408
      /* otherwise ... */
 
4409
      newargz[++newargc] = xstrdup (argv[i]);
 
4410
    }
 
4411
  newargz[++newargc] = NULL;
 
4412
 
 
4413
EOF
 
4414
            cat <<EOF
 
4415
  /* The GNU banner must be the first non-error debug message */
 
4416
  lt_debugprintf (__FILE__, __LINE__, "libtool wrapper (GNU $PACKAGE$TIMESTAMP) $VERSION\n");
 
4417
EOF
 
4418
            cat <<"EOF"
 
4419
  lt_debugprintf (__FILE__, __LINE__, "(main) argv[0]: %s\n", argv[0]);
 
4420
  lt_debugprintf (__FILE__, __LINE__, "(main) program_name: %s\n", program_name);
 
4421
 
 
4422
  tmp_pathspec = find_executable (argv[0]);
 
4423
  if (tmp_pathspec == NULL)
 
4424
    lt_fatal (__FILE__, __LINE__, "couldn't find %s", argv[0]);
 
4425
  lt_debugprintf (__FILE__, __LINE__,
 
4426
                  "(main) found exe (before symlink chase) at: %s\n",
 
4427
                  tmp_pathspec);
 
4428
 
 
4429
  actual_cwrapper_path = chase_symlinks (tmp_pathspec);
 
4430
  lt_debugprintf (__FILE__, __LINE__,
 
4431
                  "(main) found exe (after symlink chase) at: %s\n",
 
4432
                  actual_cwrapper_path);
 
4433
  XFREE (tmp_pathspec);
 
4434
 
 
4435
  actual_cwrapper_name = xstrdup (base_name (actual_cwrapper_path));
 
4436
  strendzap (actual_cwrapper_path, actual_cwrapper_name);
 
4437
 
 
4438
  /* wrapper name transforms */
 
4439
  strendzap (actual_cwrapper_name, ".exe");
 
4440
  tmp_pathspec = lt_extend_str (actual_cwrapper_name, ".exe", 1);
 
4441
  XFREE (actual_cwrapper_name);
 
4442
  actual_cwrapper_name = tmp_pathspec;
 
4443
  tmp_pathspec = 0;
 
4444
 
 
4445
  /* target_name transforms -- use actual target program name; might have lt- prefix */
 
4446
  target_name = xstrdup (base_name (TARGET_PROGRAM_NAME));
 
4447
  strendzap (target_name, ".exe");
 
4448
  tmp_pathspec = lt_extend_str (target_name, ".exe", 1);
 
4449
  XFREE (target_name);
 
4450
  target_name = tmp_pathspec;
 
4451
  tmp_pathspec = 0;
 
4452
 
 
4453
  lt_debugprintf (__FILE__, __LINE__,
 
4454
                  "(main) libtool target name: %s\n",
 
4455
                  target_name);
 
4456
EOF
 
4457
 
 
4458
            cat <<EOF
 
4459
  newargz[0] =
 
4460
    XMALLOC (char, (strlen (actual_cwrapper_path) +
 
4461
                    strlen ("$objdir") + 1 + strlen (actual_cwrapper_name) + 1));
 
4462
  strcpy (newargz[0], actual_cwrapper_path);
 
4463
  strcat (newargz[0], "$objdir");
 
4464
  strcat (newargz[0], "/");
 
4465
EOF
 
4466
 
 
4467
            cat <<"EOF"
 
4468
  /* stop here, and copy so we don't have to do this twice */
 
4469
  tmp_pathspec = xstrdup (newargz[0]);
 
4470
 
 
4471
  /* do NOT want the lt- prefix here, so use actual_cwrapper_name */
 
4472
  strcat (newargz[0], actual_cwrapper_name);
 
4473
 
 
4474
  /* DO want the lt- prefix here if it exists, so use target_name */
 
4475
  lt_argv_zero = lt_extend_str (tmp_pathspec, target_name, 1);
 
4476
  XFREE (tmp_pathspec);
 
4477
  tmp_pathspec = NULL;
 
4478
EOF
 
4479
 
 
4480
            case $host_os in
 
4481
              mingw*)
 
4482
            cat <<"EOF"
 
4483
  {
 
4484
    char* p;
 
4485
    while ((p = strchr (newargz[0], '\\')) != NULL)
 
4486
      {
 
4487
        *p = '/';
 
4488
      }
 
4489
    while ((p = strchr (lt_argv_zero, '\\')) != NULL)
 
4490
      {
 
4491
        *p = '/';
 
4492
      }
 
4493
  }
 
4494
EOF
 
4495
            ;;
 
4496
            esac
 
4497
 
 
4498
            cat <<"EOF"
 
4499
  XFREE (target_name);
 
4500
  XFREE (actual_cwrapper_path);
 
4501
  XFREE (actual_cwrapper_name);
 
4502
 
 
4503
  lt_setenv ("BIN_SH", "xpg4"); /* for Tru64 */
 
4504
  lt_setenv ("DUALCASE", "1");  /* for MSK sh */
 
4505
  /* Update the DLL searchpath.  EXE_PATH_VALUE ($dllsearchpath) must
 
4506
     be prepended before (that is, appear after) LIB_PATH_VALUE ($temp_rpath)
 
4507
     because on Windows, both *_VARNAMEs are PATH but uninstalled
 
4508
     libraries must come first. */
 
4509
  lt_update_exe_path (EXE_PATH_VARNAME, EXE_PATH_VALUE);
 
4510
  lt_update_lib_path (LIB_PATH_VARNAME, LIB_PATH_VALUE);
 
4511
 
 
4512
  lt_debugprintf (__FILE__, __LINE__, "(main) lt_argv_zero: %s\n",
 
4513
                  nonnull (lt_argv_zero));
 
4514
  for (i = 0; i < newargc; i++)
 
4515
    {
 
4516
      lt_debugprintf (__FILE__, __LINE__, "(main) newargz[%d]: %s\n",
 
4517
                      i, nonnull (newargz[i]));
 
4518
    }
 
4519
 
 
4520
EOF
 
4521
 
 
4522
            case $host_os in
 
4523
              mingw*)
 
4524
                cat <<"EOF"
 
4525
  /* execv doesn't actually work on mingw as expected on unix */
 
4526
  newargz = prepare_spawn (newargz);
 
4527
  rval = _spawnv (_P_WAIT, lt_argv_zero, (const char * const *) newargz);
 
4528
  if (rval == -1)
 
4529
    {
 
4530
      /* failed to start process */
 
4531
      lt_debugprintf (__FILE__, __LINE__,
 
4532
                      "(main) failed to launch target \"%s\": %s\n",
 
4533
                      lt_argv_zero, nonnull (strerror (errno)));
 
4534
      return 127;
 
4535
    }
 
4536
  return rval;
 
4537
EOF
 
4538
                ;;
 
4539
              *)
 
4540
                cat <<"EOF"
 
4541
  execv (lt_argv_zero, newargz);
 
4542
  return rval; /* =127, but avoids unused variable warning */
 
4543
EOF
 
4544
                ;;
 
4545
            esac
 
4546
 
 
4547
            cat <<"EOF"
 
4548
}
 
4549
 
 
4550
void *
 
4551
xmalloc (size_t num)
 
4552
{
 
4553
  void *p = (void *) malloc (num);
 
4554
  if (!p)
 
4555
    lt_fatal (__FILE__, __LINE__, "memory exhausted");
 
4556
 
 
4557
  return p;
 
4558
}
 
4559
 
 
4560
char *
 
4561
xstrdup (const char *string)
 
4562
{
 
4563
  return string ? strcpy ((char *) xmalloc (strlen (string) + 1),
 
4564
                          string) : NULL;
 
4565
}
 
4566
 
 
4567
const char *
 
4568
base_name (const char *name)
 
4569
{
 
4570
  const char *base;
 
4571
 
 
4572
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 
4573
  /* Skip over the disk name in MSDOS pathnames. */
 
4574
  if (isalpha ((unsigned char) name[0]) && name[1] == ':')
 
4575
    name += 2;
 
4576
#endif
 
4577
 
 
4578
  for (base = name; *name; name++)
 
4579
    if (IS_DIR_SEPARATOR (*name))
 
4580
      base = name + 1;
 
4581
  return base;
 
4582
}
 
4583
 
 
4584
int
 
4585
check_executable (const char *path)
 
4586
{
 
4587
  struct stat st;
 
4588
 
 
4589
  lt_debugprintf (__FILE__, __LINE__, "(check_executable): %s\n",
 
4590
                  nonempty (path));
 
4591
  if ((!path) || (!*path))
 
4592
    return 0;
 
4593
 
 
4594
  if ((stat (path, &st) >= 0)
 
4595
      && (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH)))
 
4596
    return 1;
 
4597
  else
 
4598
    return 0;
 
4599
}
 
4600
 
 
4601
int
 
4602
make_executable (const char *path)
 
4603
{
 
4604
  int rval = 0;
 
4605
  struct stat st;
 
4606
 
 
4607
  lt_debugprintf (__FILE__, __LINE__, "(make_executable): %s\n",
 
4608
                  nonempty (path));
 
4609
  if ((!path) || (!*path))
 
4610
    return 0;
 
4611
 
 
4612
  if (stat (path, &st) >= 0)
 
4613
    {
 
4614
      rval = chmod (path, st.st_mode | S_IXOTH | S_IXGRP | S_IXUSR);
 
4615
    }
 
4616
  return rval;
 
4617
}
 
4618
 
 
4619
/* Searches for the full path of the wrapper.  Returns
 
4620
   newly allocated full path name if found, NULL otherwise
 
4621
   Does not chase symlinks, even on platforms that support them.
 
4622
*/
 
4623
char *
 
4624
find_executable (const char *wrapper)
 
4625
{
 
4626
  int has_slash = 0;
 
4627
  const char *p;
 
4628
  const char *p_next;
 
4629
  /* static buffer for getcwd */
 
4630
  char tmp[LT_PATHMAX + 1];
 
4631
  int tmp_len;
 
4632
  char *concat_name;
 
4633
 
 
4634
  lt_debugprintf (__FILE__, __LINE__, "(find_executable): %s\n",
 
4635
                  nonempty (wrapper));
 
4636
 
 
4637
  if ((wrapper == NULL) || (*wrapper == '\0'))
 
4638
    return NULL;
 
4639
 
 
4640
  /* Absolute path? */
 
4641
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 
4642
  if (isalpha ((unsigned char) wrapper[0]) && wrapper[1] == ':')
 
4643
    {
 
4644
      concat_name = xstrdup (wrapper);
 
4645
      if (check_executable (concat_name))
 
4646
        return concat_name;
 
4647
      XFREE (concat_name);
 
4648
    }
 
4649
  else
 
4650
    {
 
4651
#endif
 
4652
      if (IS_DIR_SEPARATOR (wrapper[0]))
 
4653
        {
 
4654
          concat_name = xstrdup (wrapper);
 
4655
          if (check_executable (concat_name))
 
4656
            return concat_name;
 
4657
          XFREE (concat_name);
 
4658
        }
 
4659
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
 
4660
    }
 
4661
#endif
 
4662
 
 
4663
  for (p = wrapper; *p; p++)
 
4664
    if (*p == '/')
 
4665
      {
 
4666
        has_slash = 1;
 
4667
        break;
 
4668
      }
 
4669
  if (!has_slash)
 
4670
    {
 
4671
      /* no slashes; search PATH */
 
4672
      const char *path = getenv ("PATH");
 
4673
      if (path != NULL)
 
4674
        {
 
4675
          for (p = path; *p; p = p_next)
 
4676
            {
 
4677
              const char *q;
 
4678
              size_t p_len;
 
4679
              for (q = p; *q; q++)
 
4680
                if (IS_PATH_SEPARATOR (*q))
 
4681
                  break;
 
4682
              p_len = q - p;
 
4683
              p_next = (*q == '\0' ? q : q + 1);
 
4684
              if (p_len == 0)
 
4685
                {
 
4686
                  /* empty path: current directory */
 
4687
                  if (getcwd (tmp, LT_PATHMAX) == NULL)
 
4688
                    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
 
4689
                              nonnull (strerror (errno)));
 
4690
                  tmp_len = strlen (tmp);
 
4691
                  concat_name =
 
4692
                    XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
 
4693
                  memcpy (concat_name, tmp, tmp_len);
 
4694
                  concat_name[tmp_len] = '/';
 
4695
                  strcpy (concat_name + tmp_len + 1, wrapper);
 
4696
                }
 
4697
              else
 
4698
                {
 
4699
                  concat_name =
 
4700
                    XMALLOC (char, p_len + 1 + strlen (wrapper) + 1);
 
4701
                  memcpy (concat_name, p, p_len);
 
4702
                  concat_name[p_len] = '/';
 
4703
                  strcpy (concat_name + p_len + 1, wrapper);
 
4704
                }
 
4705
              if (check_executable (concat_name))
 
4706
                return concat_name;
 
4707
              XFREE (concat_name);
 
4708
            }
 
4709
        }
 
4710
      /* not found in PATH; assume curdir */
 
4711
    }
 
4712
  /* Relative path | not found in path: prepend cwd */
 
4713
  if (getcwd (tmp, LT_PATHMAX) == NULL)
 
4714
    lt_fatal (__FILE__, __LINE__, "getcwd failed: %s",
 
4715
              nonnull (strerror (errno)));
 
4716
  tmp_len = strlen (tmp);
 
4717
  concat_name = XMALLOC (char, tmp_len + 1 + strlen (wrapper) + 1);
 
4718
  memcpy (concat_name, tmp, tmp_len);
 
4719
  concat_name[tmp_len] = '/';
 
4720
  strcpy (concat_name + tmp_len + 1, wrapper);
 
4721
 
 
4722
  if (check_executable (concat_name))
 
4723
    return concat_name;
 
4724
  XFREE (concat_name);
 
4725
  return NULL;
 
4726
}
 
4727
 
 
4728
char *
 
4729
chase_symlinks (const char *pathspec)
 
4730
{
 
4731
#ifndef S_ISLNK
 
4732
  return xstrdup (pathspec);
 
4733
#else
 
4734
  char buf[LT_PATHMAX];
 
4735
  struct stat s;
 
4736
  char *tmp_pathspec = xstrdup (pathspec);
 
4737
  char *p;
 
4738
  int has_symlinks = 0;
 
4739
  while (strlen (tmp_pathspec) && !has_symlinks)
 
4740
    {
 
4741
      lt_debugprintf (__FILE__, __LINE__,
 
4742
                      "checking path component for symlinks: %s\n",
 
4743
                      tmp_pathspec);
 
4744
      if (lstat (tmp_pathspec, &s) == 0)
 
4745
        {
 
4746
          if (S_ISLNK (s.st_mode) != 0)
 
4747
            {
 
4748
              has_symlinks = 1;
 
4749
              break;
 
4750
            }
 
4751
 
 
4752
          /* search backwards for last DIR_SEPARATOR */
 
4753
          p = tmp_pathspec + strlen (tmp_pathspec) - 1;
 
4754
          while ((p > tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
 
4755
            p--;
 
4756
          if ((p == tmp_pathspec) && (!IS_DIR_SEPARATOR (*p)))
 
4757
            {
 
4758
              /* no more DIR_SEPARATORS left */
 
4759
              break;
 
4760
            }
 
4761
          *p = '\0';
 
4762
        }
 
4763
      else
 
4764
        {
 
4765
          lt_fatal (__FILE__, __LINE__,
 
4766
                    "error accessing file \"%s\": %s",
 
4767
                    tmp_pathspec, nonnull (strerror (errno)));
 
4768
        }
 
4769
    }
 
4770
  XFREE (tmp_pathspec);
 
4771
 
 
4772
  if (!has_symlinks)
 
4773
    {
 
4774
      return xstrdup (pathspec);
 
4775
    }
 
4776
 
 
4777
  tmp_pathspec = realpath (pathspec, buf);
 
4778
  if (tmp_pathspec == 0)
 
4779
    {
 
4780
      lt_fatal (__FILE__, __LINE__,
 
4781
                "could not follow symlinks for %s", pathspec);
 
4782
    }
 
4783
  return xstrdup (tmp_pathspec);
 
4784
#endif
 
4785
}
 
4786
 
 
4787
char *
 
4788
strendzap (char *str, const char *pat)
 
4789
{
 
4790
  size_t len, patlen;
 
4791
 
 
4792
  assert (str != NULL);
 
4793
  assert (pat != NULL);
 
4794
 
 
4795
  len = strlen (str);
 
4796
  patlen = strlen (pat);
 
4797
 
 
4798
  if (patlen <= len)
 
4799
    {
 
4800
      str += len - patlen;
 
4801
      if (strcmp (str, pat) == 0)
 
4802
        *str = '\0';
 
4803
    }
 
4804
  return str;
 
4805
}
 
4806
 
 
4807
void
 
4808
lt_debugprintf (const char *file, int line, const char *fmt, ...)
 
4809
{
 
4810
  va_list args;
 
4811
  if (lt_debug)
 
4812
    {
 
4813
      (void) fprintf (stderr, "%s:%s:%d: ", program_name, file, line);
 
4814
      va_start (args, fmt);
 
4815
      (void) vfprintf (stderr, fmt, args);
 
4816
      va_end (args);
 
4817
    }
 
4818
}
 
4819
 
 
4820
static void
 
4821
lt_error_core (int exit_status, const char *file,
 
4822
               int line, const char *mode,
 
4823
               const char *message, va_list ap)
 
4824
{
 
4825
  fprintf (stderr, "%s:%s:%d: %s: ", program_name, file, line, mode);
 
4826
  vfprintf (stderr, message, ap);
 
4827
  fprintf (stderr, ".\n");
 
4828
 
 
4829
  if (exit_status >= 0)
 
4830
    exit (exit_status);
 
4831
}
 
4832
 
 
4833
void
 
4834
lt_fatal (const char *file, int line, const char *message, ...)
 
4835
{
 
4836
  va_list ap;
 
4837
  va_start (ap, message);
 
4838
  lt_error_core (EXIT_FAILURE, file, line, "FATAL", message, ap);
 
4839
  va_end (ap);
 
4840
}
 
4841
 
 
4842
static const char *
 
4843
nonnull (const char *s)
 
4844
{
 
4845
  return s ? s : "(null)";
 
4846
}
 
4847
 
 
4848
static const char *
 
4849
nonempty (const char *s)
 
4850
{
 
4851
  return (s && !*s) ? "(empty)" : nonnull (s);
 
4852
}
 
4853
 
 
4854
void
 
4855
lt_setenv (const char *name, const char *value)
 
4856
{
 
4857
  lt_debugprintf (__FILE__, __LINE__,
 
4858
                  "(lt_setenv) setting '%s' to '%s'\n",
 
4859
                  nonnull (name), nonnull (value));
 
4860
  {
 
4861
#ifdef HAVE_SETENV
 
4862
    /* always make a copy, for consistency with !HAVE_SETENV */
 
4863
    char *str = xstrdup (value);
 
4864
    setenv (name, str, 1);
 
4865
#else
 
4866
    int len = strlen (name) + 1 + strlen (value) + 1;
 
4867
    char *str = XMALLOC (char, len);
 
4868
    sprintf (str, "%s=%s", name, value);
 
4869
    if (putenv (str) != EXIT_SUCCESS)
 
4870
      {
 
4871
        XFREE (str);
 
4872
      }
 
4873
#endif
 
4874
  }
 
4875
}
 
4876
 
 
4877
char *
 
4878
lt_extend_str (const char *orig_value, const char *add, int to_end)
 
4879
{
 
4880
  char *new_value;
 
4881
  if (orig_value && *orig_value)
 
4882
    {
 
4883
      int orig_value_len = strlen (orig_value);
 
4884
      int add_len = strlen (add);
 
4885
      new_value = XMALLOC (char, add_len + orig_value_len + 1);
 
4886
      if (to_end)
 
4887
        {
 
4888
          strcpy (new_value, orig_value);
 
4889
          strcpy (new_value + orig_value_len, add);
 
4890
        }
 
4891
      else
 
4892
        {
 
4893
          strcpy (new_value, add);
 
4894
          strcpy (new_value + add_len, orig_value);
 
4895
        }
 
4896
    }
 
4897
  else
 
4898
    {
 
4899
      new_value = xstrdup (add);
 
4900
    }
 
4901
  return new_value;
 
4902
}
 
4903
 
 
4904
void
 
4905
lt_update_exe_path (const char *name, const char *value)
 
4906
{
 
4907
  lt_debugprintf (__FILE__, __LINE__,
 
4908
                  "(lt_update_exe_path) modifying '%s' by prepending '%s'\n",
 
4909
                  nonnull (name), nonnull (value));
 
4910
 
 
4911
  if (name && *name && value && *value)
 
4912
    {
 
4913
      char *new_value = lt_extend_str (getenv (name), value, 0);
 
4914
      /* some systems can't cope with a ':'-terminated path #' */
 
4915
      int len = strlen (new_value);
 
4916
      while (((len = strlen (new_value)) > 0) && IS_PATH_SEPARATOR (new_value[len-1]))
 
4917
        {
 
4918
          new_value[len-1] = '\0';
 
4919
        }
 
4920
      lt_setenv (name, new_value);
 
4921
      XFREE (new_value);
 
4922
    }
 
4923
}
 
4924
 
 
4925
void
 
4926
lt_update_lib_path (const char *name, const char *value)
 
4927
{
 
4928
  lt_debugprintf (__FILE__, __LINE__,
 
4929
                  "(lt_update_lib_path) modifying '%s' by prepending '%s'\n",
 
4930
                  nonnull (name), nonnull (value));
 
4931
 
 
4932
  if (name && *name && value && *value)
 
4933
    {
 
4934
      char *new_value = lt_extend_str (getenv (name), value, 0);
 
4935
      lt_setenv (name, new_value);
 
4936
      XFREE (new_value);
 
4937
    }
 
4938
}
 
4939
 
 
4940
EOF
 
4941
            case $host_os in
 
4942
              mingw*)
 
4943
                cat <<"EOF"
 
4944
 
 
4945
/* Prepares an argument vector before calling spawn().
 
4946
   Note that spawn() does not by itself call the command interpreter
 
4947
     (getenv ("COMSPEC") != NULL ? getenv ("COMSPEC") :
 
4948
      ({ OSVERSIONINFO v; v.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
 
4949
         GetVersionEx(&v);
 
4950
         v.dwPlatformId == VER_PLATFORM_WIN32_NT;
 
4951
      }) ? "cmd.exe" : "command.com").
 
4952
   Instead it simply concatenates the arguments, separated by ' ', and calls
 
4953
   CreateProcess().  We must quote the arguments since Win32 CreateProcess()
 
4954
   interprets characters like ' ', '\t', '\\', '"' (but not '<' and '>') in a
 
4955
   special way:
 
4956
   - Space and tab are interpreted as delimiters. They are not treated as
 
4957
     delimiters if they are surrounded by double quotes: "...".
 
4958
   - Unescaped double quotes are removed from the input. Their only effect is
 
4959
     that within double quotes, space and tab are treated like normal
 
4960
     characters.
 
4961
   - Backslashes not followed by double quotes are not special.
 
4962
   - But 2*n+1 backslashes followed by a double quote become
 
4963
     n backslashes followed by a double quote (n >= 0):
 
4964
       \" -> "
 
4965
       \\\" -> \"
 
4966
       \\\\\" -> \\"
 
4967
 */
 
4968
#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"
 
4969
#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"
 
4970
char **
 
4971
prepare_spawn (char **argv)
 
4972
{
 
4973
  size_t argc;
 
4974
  char **new_argv;
 
4975
  size_t i;
 
4976
 
 
4977
  /* Count number of arguments.  */
 
4978
  for (argc = 0; argv[argc] != NULL; argc++)
 
4979
    ;
 
4980
 
 
4981
  /* Allocate new argument vector.  */
 
4982
  new_argv = XMALLOC (char *, argc + 1);
 
4983
 
 
4984
  /* Put quoted arguments into the new argument vector.  */
 
4985
  for (i = 0; i < argc; i++)
 
4986
    {
 
4987
      const char *string = argv[i];
 
4988
 
 
4989
      if (string[0] == '\0')
 
4990
        new_argv[i] = xstrdup ("\"\"");
 
4991
      else if (strpbrk (string, SHELL_SPECIAL_CHARS) != NULL)
 
4992
        {
 
4993
          int quote_around = (strpbrk (string, SHELL_SPACE_CHARS) != NULL);
 
4994
          size_t length;
 
4995
          unsigned int backslashes;
 
4996
          const char *s;
 
4997
          char *quoted_string;
 
4998
          char *p;
 
4999
 
 
5000
          length = 0;
 
5001
          backslashes = 0;
 
5002
          if (quote_around)
 
5003
            length++;
 
5004
          for (s = string; *s != '\0'; s++)
 
5005
            {
 
5006
              char c = *s;
 
5007
              if (c == '"')
 
5008
                length += backslashes + 1;
 
5009
              length++;
 
5010
              if (c == '\\')
 
5011
                backslashes++;
 
5012
              else
 
5013
                backslashes = 0;
 
5014
            }
 
5015
          if (quote_around)
 
5016
            length += backslashes + 1;
 
5017
 
 
5018
          quoted_string = XMALLOC (char, length + 1);
 
5019
 
 
5020
          p = quoted_string;
 
5021
          backslashes = 0;
 
5022
          if (quote_around)
 
5023
            *p++ = '"';
 
5024
          for (s = string; *s != '\0'; s++)
 
5025
            {
 
5026
              char c = *s;
 
5027
              if (c == '"')
 
5028
                {
 
5029
                  unsigned int j;
 
5030
                  for (j = backslashes + 1; j > 0; j--)
 
5031
                    *p++ = '\\';
 
5032
                }
 
5033
              *p++ = c;
 
5034
              if (c == '\\')
 
5035
                backslashes++;
 
5036
              else
 
5037
                backslashes = 0;
 
5038
            }
 
5039
          if (quote_around)
 
5040
            {
 
5041
              unsigned int j;
 
5042
              for (j = backslashes; j > 0; j--)
 
5043
                *p++ = '\\';
 
5044
              *p++ = '"';
 
5045
            }
 
5046
          *p = '\0';
 
5047
 
 
5048
          new_argv[i] = quoted_string;
 
5049
        }
 
5050
      else
 
5051
        new_argv[i] = (char *) string;
 
5052
    }
 
5053
  new_argv[argc] = NULL;
 
5054
 
 
5055
  return new_argv;
 
5056
}
 
5057
EOF
 
5058
                ;;
 
5059
            esac
 
5060
 
 
5061
            cat <<"EOF"
 
5062
void lt_dump_script (FILE* f)
 
5063
{
 
5064
EOF
 
5065
            func_emit_wrapper yes |
 
5066
              $SED -n -e '
 
5067
s/^\(.\{79\}\)\(..*\)/\1\
 
5068
\2/
 
5069
h
 
5070
s/\([\\"]\)/\\\1/g
 
5071
s/$/\\n/
 
5072
s/\([^\n]*\).*/  fputs ("\1", f);/p
 
5073
g
 
5074
D'
 
5075
            cat <<"EOF"
 
5076
}
 
5077
EOF
 
5078
}
 
5079
# end: func_emit_cwrapperexe_src
 
5080
 
 
5081
# func_win32_import_lib_p ARG
 
5082
# True if ARG is an import lib, as indicated by $file_magic_cmd
 
5083
func_win32_import_lib_p ()
 
5084
{
 
5085
    $opt_debug
 
5086
    case `eval $file_magic_cmd \"\$1\" 2>/dev/null | $SED -e 10q` in
 
5087
    *import*) : ;;
 
5088
    *) false ;;
 
5089
    esac
 
5090
}
 
5091
 
 
5092
# func_mode_link arg...
 
5093
func_mode_link ()
 
5094
{
 
5095
    $opt_debug
1105
5096
    case $host in
1106
 
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 
5097
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
1107
5098
      # It is impossible to link a dll without this setting, and
1108
5099
      # we shouldn't force the makefile maintainer to figure out
1109
5100
      # which system we are compiling for in order to pass an extra
1121
5112
      allow_undefined=yes
1122
5113
      ;;
1123
5114
    esac
1124
 
    libtool_args="$nonopt"
 
5115
    libtool_args=$nonopt
1125
5116
    base_compile="$nonopt $@"
1126
 
    compile_command="$nonopt"
1127
 
    finalize_command="$nonopt"
 
5117
    compile_command=$nonopt
 
5118
    finalize_command=$nonopt
1128
5119
 
1129
5120
    compile_rpath=
1130
5121
    finalize_rpath=
1139
5130
    dllsearchpath=
1140
5131
    lib_search_path=`pwd`
1141
5132
    inst_prefix_dir=
 
5133
    new_inherited_linker_flags=
1142
5134
 
1143
5135
    avoid_version=no
 
5136
    bindir=
1144
5137
    dlfiles=
1145
5138
    dlprefiles=
1146
5139
    dlself=no
1154
5147
    no_install=no
1155
5148
    objs=
1156
5149
    non_pic_objects=
1157
 
    notinst_path= # paths that contain not-installed libtool libraries
1158
5150
    precious_files_regex=
1159
5151
    prefer_static_libs=no
1160
5152
    preload=no
1168
5160
    thread_safe=no
1169
5161
    vinfo=
1170
5162
    vinfo_number=no
 
5163
    weak_libs=
1171
5164
    single_module="${wl}-single_module"
1172
 
 
1173
5165
    func_infer_tag $base_compile
1174
5166
 
1175
5167
    # We need to know -static, to get the right output filenames.
1176
5168
    for arg
1177
5169
    do
1178
5170
      case $arg in
 
5171
      -shared)
 
5172
        test "$build_libtool_libs" != yes && \
 
5173
          func_fatal_configuration "can not build a shared library"
 
5174
        build_old_libs=no
 
5175
        break
 
5176
        ;;
1179
5177
      -all-static | -static | -static-libtool-libs)
1180
5178
        case $arg in
1181
5179
        -all-static)
1182
5180
          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
1183
 
            $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
 
5181
            func_warning "complete static linking is impossible in this configuration"
1184
5182
          fi
1185
5183
          if test -n "$link_static_flag"; then
1186
5184
            dlopen_self=$dlopen_self_static
1214
5212
    while test "$#" -gt 0; do
1215
5213
      arg="$1"
1216
5214
      shift
1217
 
      case $arg in
1218
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
1219
 
        qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
1220
 
        ;;
1221
 
      *) qarg=$arg ;;
1222
 
      esac
1223
 
      libtool_args="$libtool_args $qarg"
 
5215
      func_quote_for_eval "$arg"
 
5216
      qarg=$func_quote_for_eval_unquoted_result
 
5217
      func_append libtool_args " $func_quote_for_eval_result"
1224
5218
 
1225
5219
      # If the previous option needs an argument, assign it.
1226
5220
      if test -n "$prev"; then
1227
5221
        case $prev in
1228
5222
        output)
1229
 
          compile_command="$compile_command @OUTPUT@"
1230
 
          finalize_command="$finalize_command @OUTPUT@"
 
5223
          func_append compile_command " @OUTPUT@"
 
5224
          func_append finalize_command " @OUTPUT@"
1231
5225
          ;;
1232
5226
        esac
1233
5227
 
1234
5228
        case $prev in
 
5229
        bindir)
 
5230
          bindir="$arg"
 
5231
          prev=
 
5232
          continue
 
5233
          ;;
1235
5234
        dlfiles|dlprefiles)
1236
5235
          if test "$preload" = no; then
1237
5236
            # Add the symbol object into the linking commands.
1238
 
            compile_command="$compile_command @SYMFILE@"
1239
 
            finalize_command="$finalize_command @SYMFILE@"
 
5237
            func_append compile_command " @SYMFILE@"
 
5238
            func_append finalize_command " @SYMFILE@"
1240
5239
            preload=yes
1241
5240
          fi
1242
5241
          case $arg in
1263
5262
            ;;
1264
5263
          *)
1265
5264
            if test "$prev" = dlfiles; then
1266
 
              dlfiles="$dlfiles $arg"
 
5265
              func_append dlfiles " $arg"
1267
5266
            else
1268
 
              dlprefiles="$dlprefiles $arg"
 
5267
              func_append dlprefiles " $arg"
1269
5268
            fi
1270
5269
            prev=
1271
5270
            continue
1274
5273
          ;;
1275
5274
        expsyms)
1276
5275
          export_symbols="$arg"
1277
 
          if test ! -f "$arg"; then
1278
 
            $echo "$modename: symbol file \`$arg' does not exist"
1279
 
            exit $EXIT_FAILURE
1280
 
          fi
 
5276
          test -f "$arg" \
 
5277
            || func_fatal_error "symbol file \`$arg' does not exist"
1281
5278
          prev=
1282
5279
          continue
1283
5280
          ;;
1286
5283
          prev=
1287
5284
          continue
1288
5285
          ;;
 
5286
        framework)
 
5287
          case $host in
 
5288
            *-*-darwin*)
 
5289
              case "$deplibs " in
 
5290
                *" $qarg.ltframework "*) ;;
 
5291
                *) func_append deplibs " $qarg.ltframework" # this is fixed later
 
5292
                   ;;
 
5293
              esac
 
5294
              ;;
 
5295
          esac
 
5296
          prev=
 
5297
          continue
 
5298
          ;;
1289
5299
        inst_prefix)
1290
5300
          inst_prefix_dir="$arg"
1291
5301
          prev=
1292
5302
          continue
1293
5303
          ;;
1294
 
        precious_regex)
1295
 
          precious_files_regex="$arg"
1296
 
          prev=
1297
 
          continue
1298
 
          ;;
1299
 
        release)
1300
 
          release="-$arg"
1301
 
          prev=
1302
 
          continue
1303
 
          ;;
1304
5304
        objectlist)
1305
5305
          if test -f "$arg"; then
1306
5306
            save_arg=$arg
1307
5307
            moreargs=
1308
 
            for fil in `cat $save_arg`
 
5308
            for fil in `cat "$save_arg"`
1309
5309
            do
1310
 
#             moreargs="$moreargs $fil"
 
5310
#             func_append moreargs " $fil"
1311
5311
              arg=$fil
1312
5312
              # A libtool-controlled object.
1313
5313
 
1314
5314
              # Check to see that this really is a libtool object.
1315
 
              if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 
5315
              if func_lalib_unsafe_p "$arg"; then
1316
5316
                pic_object=
1317
5317
                non_pic_object=
1318
5318
 
1319
5319
                # Read the .lo file
1320
 
                # If there is no directory component, then add one.
1321
 
                case $arg in
1322
 
                */* | *\\*) . $arg ;;
1323
 
                *) . ./$arg ;;
1324
 
                esac
 
5320
                func_source "$arg"
1325
5321
 
1326
 
                if test -z "$pic_object" || \
 
5322
                if test -z "$pic_object" ||
1327
5323
                   test -z "$non_pic_object" ||
1328
 
                   test "$pic_object" = none && \
 
5324
                   test "$pic_object" = none &&
1329
5325
                   test "$non_pic_object" = none; then
1330
 
                  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1331
 
                  exit $EXIT_FAILURE
 
5326
                  func_fatal_error "cannot find name of object for \`$arg'"
1332
5327
                fi
1333
5328
 
1334
5329
                # Extract subdirectory from the argument.
1335
 
                xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1336
 
                if test "X$xdir" = "X$arg"; then
1337
 
                  xdir=
1338
 
                else
1339
 
                  xdir="$xdir/"
1340
 
                fi
 
5330
                func_dirname "$arg" "/" ""
 
5331
                xdir="$func_dirname_result"
1341
5332
 
1342
5333
                if test "$pic_object" != none; then
1343
5334
                  # Prepend the subdirectory the object is found in.
1345
5336
 
1346
5337
                  if test "$prev" = dlfiles; then
1347
5338
                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1348
 
                      dlfiles="$dlfiles $pic_object"
 
5339
                      func_append dlfiles " $pic_object"
1349
5340
                      prev=
1350
5341
                      continue
1351
5342
                    else
1357
5348
                  # CHECK ME:  I think I busted this.  -Ossama
1358
5349
                  if test "$prev" = dlprefiles; then
1359
5350
                    # Preload the old-style object.
1360
 
                    dlprefiles="$dlprefiles $pic_object"
 
5351
                    func_append dlprefiles " $pic_object"
1361
5352
                    prev=
1362
5353
                  fi
1363
5354
 
1364
5355
                  # A PIC object.
1365
 
                  libobjs="$libobjs $pic_object"
 
5356
                  func_append libobjs " $pic_object"
1366
5357
                  arg="$pic_object"
1367
5358
                fi
1368
5359
 
1372
5363
                  non_pic_object="$xdir$non_pic_object"
1373
5364
 
1374
5365
                  # A standard non-PIC object
1375
 
                  non_pic_objects="$non_pic_objects $non_pic_object"
 
5366
                  func_append non_pic_objects " $non_pic_object"
1376
5367
                  if test -z "$pic_object" || test "$pic_object" = none ; then
1377
5368
                    arg="$non_pic_object"
1378
5369
                  fi
1380
5371
                  # If the PIC object exists, use it instead.
1381
5372
                  # $xdir was prepended to $pic_object above.
1382
5373
                  non_pic_object="$pic_object"
1383
 
                  non_pic_objects="$non_pic_objects $non_pic_object"
 
5374
                  func_append non_pic_objects " $non_pic_object"
1384
5375
                fi
1385
5376
              else
1386
5377
                # Only an error if not doing a dry-run.
1387
 
                if test -z "$run"; then
1388
 
                  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1389
 
                  exit $EXIT_FAILURE
1390
 
                else
1391
 
                  # Dry-run case.
1392
 
 
 
5378
                if $opt_dry_run; then
1393
5379
                  # Extract subdirectory from the argument.
1394
 
                  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1395
 
                  if test "X$xdir" = "X$arg"; then
1396
 
                    xdir=
1397
 
                  else
1398
 
                    xdir="$xdir/"
1399
 
                  fi
 
5380
                  func_dirname "$arg" "/" ""
 
5381
                  xdir="$func_dirname_result"
1400
5382
 
1401
 
                  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1402
 
                  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1403
 
                  libobjs="$libobjs $pic_object"
1404
 
                  non_pic_objects="$non_pic_objects $non_pic_object"
 
5383
                  func_lo2o "$arg"
 
5384
                  pic_object=$xdir$objdir/$func_lo2o_result
 
5385
                  non_pic_object=$xdir$func_lo2o_result
 
5386
                  func_append libobjs " $pic_object"
 
5387
                  func_append non_pic_objects " $non_pic_object"
 
5388
                else
 
5389
                  func_fatal_error "\`$arg' is not a valid libtool object"
1405
5390
                fi
1406
5391
              fi
1407
5392
            done
1408
5393
          else
1409
 
            $echo "$modename: link input file \`$save_arg' does not exist"
1410
 
            exit $EXIT_FAILURE
 
5394
            func_fatal_error "link input file \`$arg' does not exist"
1411
5395
          fi
1412
5396
          arg=$save_arg
1413
5397
          prev=
1414
5398
          continue
1415
5399
          ;;
 
5400
        precious_regex)
 
5401
          precious_files_regex="$arg"
 
5402
          prev=
 
5403
          continue
 
5404
          ;;
 
5405
        release)
 
5406
          release="-$arg"
 
5407
          prev=
 
5408
          continue
 
5409
          ;;
1416
5410
        rpath | xrpath)
1417
5411
          # We need an absolute path.
1418
5412
          case $arg in
1419
5413
          [\\/]* | [A-Za-z]:[\\/]*) ;;
1420
5414
          *)
1421
 
            $echo "$modename: only absolute run-paths are allowed" 1>&2
1422
 
            exit $EXIT_FAILURE
 
5415
            func_fatal_error "only absolute run-paths are allowed"
1423
5416
            ;;
1424
5417
          esac
1425
5418
          if test "$prev" = rpath; then
1426
5419
            case "$rpath " in
1427
5420
            *" $arg "*) ;;
1428
 
            *) rpath="$rpath $arg" ;;
 
5421
            *) func_append rpath " $arg" ;;
1429
5422
            esac
1430
5423
          else
1431
5424
            case "$xrpath " in
1432
5425
            *" $arg "*) ;;
1433
 
            *) xrpath="$xrpath $arg" ;;
 
5426
            *) func_append xrpath " $arg" ;;
1434
5427
            esac
1435
5428
          fi
1436
5429
          prev=
1437
5430
          continue
1438
5431
          ;;
 
5432
        shrext)
 
5433
          shrext_cmds="$arg"
 
5434
          prev=
 
5435
          continue
 
5436
          ;;
 
5437
        weak)
 
5438
          func_append weak_libs " $arg"
 
5439
          prev=
 
5440
          continue
 
5441
          ;;
 
5442
        xcclinker)
 
5443
          func_append linker_flags " $qarg"
 
5444
          func_append compiler_flags " $qarg"
 
5445
          prev=
 
5446
          func_append compile_command " $qarg"
 
5447
          func_append finalize_command " $qarg"
 
5448
          continue
 
5449
          ;;
1439
5450
        xcompiler)
1440
 
          compiler_flags="$compiler_flags $qarg"
 
5451
          func_append compiler_flags " $qarg"
1441
5452
          prev=
1442
 
          compile_command="$compile_command $qarg"
1443
 
          finalize_command="$finalize_command $qarg"
 
5453
          func_append compile_command " $qarg"
 
5454
          func_append finalize_command " $qarg"
1444
5455
          continue
1445
5456
          ;;
1446
5457
        xlinker)
1447
 
          linker_flags="$linker_flags $qarg"
1448
 
          compiler_flags="$compiler_flags $wl$qarg"
1449
 
          prev=
1450
 
          compile_command="$compile_command $wl$qarg"
1451
 
          finalize_command="$finalize_command $wl$qarg"
1452
 
          continue
1453
 
          ;;
1454
 
        xcclinker)
1455
 
          linker_flags="$linker_flags $qarg"
1456
 
          compiler_flags="$compiler_flags $qarg"
1457
 
          prev=
1458
 
          compile_command="$compile_command $qarg"
1459
 
          finalize_command="$finalize_command $qarg"
1460
 
          continue
1461
 
          ;;
1462
 
        shrext)
1463
 
          shrext_cmds="$arg"
1464
 
          prev=
1465
 
          continue
1466
 
          ;;
1467
 
        darwin_framework|darwin_framework_skip)
1468
 
          test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
1469
 
          compile_command="$compile_command $arg"
1470
 
          finalize_command="$finalize_command $arg"
1471
 
          prev=
 
5458
          func_append linker_flags " $qarg"
 
5459
          func_append compiler_flags " $wl$qarg"
 
5460
          prev=
 
5461
          func_append compile_command " $wl$qarg"
 
5462
          func_append finalize_command " $wl$qarg"
1472
5463
          continue
1473
5464
          ;;
1474
5465
        *)
1484
5475
      case $arg in
1485
5476
      -all-static)
1486
5477
        if test -n "$link_static_flag"; then
1487
 
          compile_command="$compile_command $link_static_flag"
1488
 
          finalize_command="$finalize_command $link_static_flag"
 
5478
          # See comment for -static flag below, for more details.
 
5479
          func_append compile_command " $link_static_flag"
 
5480
          func_append finalize_command " $link_static_flag"
1489
5481
        fi
1490
5482
        continue
1491
5483
        ;;
1492
5484
 
1493
5485
      -allow-undefined)
1494
5486
        # FIXME: remove this flag sometime in the future.
1495
 
        $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1496
 
        continue
 
5487
        func_fatal_error "\`-allow-undefined' must not be used because it is the default"
1497
5488
        ;;
1498
5489
 
1499
5490
      -avoid-version)
1501
5492
        continue
1502
5493
        ;;
1503
5494
 
 
5495
      -bindir)
 
5496
        prev=bindir
 
5497
        continue
 
5498
        ;;
 
5499
 
1504
5500
      -dlopen)
1505
5501
        prev=dlfiles
1506
5502
        continue
1518
5514
 
1519
5515
      -export-symbols | -export-symbols-regex)
1520
5516
        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1521
 
          $echo "$modename: more than one -exported-symbols argument is not allowed"
1522
 
          exit $EXIT_FAILURE
 
5517
          func_fatal_error "more than one -exported-symbols argument is not allowed"
1523
5518
        fi
1524
5519
        if test "X$arg" = "X-export-symbols"; then
1525
5520
          prev=expsyms
1529
5524
        continue
1530
5525
        ;;
1531
5526
 
1532
 
      -framework|-arch|-isysroot)
1533
 
        case " $CC " in
1534
 
          *" ${arg} ${1} "* | *" ${arg} ${1} "*) 
1535
 
                prev=darwin_framework_skip ;;
1536
 
          *) compiler_flags="$compiler_flags $arg"
1537
 
             prev=darwin_framework ;;
1538
 
        esac
1539
 
        compile_command="$compile_command $arg"
1540
 
        finalize_command="$finalize_command $arg"
 
5527
      -framework)
 
5528
        prev=framework
1541
5529
        continue
1542
5530
        ;;
1543
5531
 
1551
5539
      -L[A-Z][A-Z]*:*)
1552
5540
        case $with_gcc/$host in
1553
5541
        no/*-*-irix* | /*-*-irix*)
1554
 
          compile_command="$compile_command $arg"
1555
 
          finalize_command="$finalize_command $arg"
 
5542
          func_append compile_command " $arg"
 
5543
          func_append finalize_command " $arg"
1556
5544
          ;;
1557
5545
        esac
1558
5546
        continue
1559
5547
        ;;
1560
5548
 
1561
5549
      -L*)
1562
 
        dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
 
5550
        func_stripname "-L" '' "$arg"
 
5551
        if test -z "$func_stripname_result"; then
 
5552
          if test "$#" -gt 0; then
 
5553
            func_fatal_error "require no space between \`-L' and \`$1'"
 
5554
          else
 
5555
            func_fatal_error "need path for \`-L' option"
 
5556
          fi
 
5557
        fi
 
5558
        func_resolve_sysroot "$func_stripname_result"
 
5559
        dir=$func_resolve_sysroot_result
1563
5560
        # We need an absolute path.
1564
5561
        case $dir in
1565
5562
        [\\/]* | [A-Za-z]:[\\/]*) ;;
1566
5563
        *)
1567
5564
          absdir=`cd "$dir" && pwd`
1568
 
          if test -z "$absdir"; then
1569
 
            $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1570
 
            absdir="$dir"
1571
 
            notinst_path="$notinst_path $dir"
1572
 
          fi
 
5565
          test -z "$absdir" && \
 
5566
            func_fatal_error "cannot determine absolute directory name of \`$dir'"
1573
5567
          dir="$absdir"
1574
5568
          ;;
1575
5569
        esac
1576
5570
        case "$deplibs " in
1577
 
        *" -L$dir "*) ;;
 
5571
        *" -L$dir "* | *" $arg "*)
 
5572
          # Will only happen for absolute or sysroot arguments
 
5573
          ;;
1578
5574
        *)
1579
 
          deplibs="$deplibs -L$dir"
1580
 
          lib_search_path="$lib_search_path $dir"
 
5575
          # Preserve sysroot, but never include relative directories
 
5576
          case $dir in
 
5577
            [\\/]* | [A-Za-z]:[\\/]* | =*) func_append deplibs " $arg" ;;
 
5578
            *) func_append deplibs " -L$dir" ;;
 
5579
          esac
 
5580
          func_append lib_search_path " $dir"
1581
5581
          ;;
1582
5582
        esac
1583
5583
        case $host in
1584
 
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1585
 
          testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`
 
5584
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
 
5585
          testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
1586
5586
          case :$dllsearchpath: in
1587
5587
          *":$dir:"*) ;;
1588
 
          *) dllsearchpath="$dllsearchpath:$dir";;
 
5588
          ::) dllsearchpath=$dir;;
 
5589
          *) func_append dllsearchpath ":$dir";;
1589
5590
          esac
1590
5591
          case :$dllsearchpath: in
1591
5592
          *":$testbindir:"*) ;;
1592
 
          *) dllsearchpath="$dllsearchpath:$testbindir";;
 
5593
          ::) dllsearchpath=$testbindir;;
 
5594
          *) func_append dllsearchpath ":$testbindir";;
1593
5595
          esac
1594
5596
          ;;
1595
5597
        esac
1599
5601
      -l*)
1600
5602
        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1601
5603
          case $host in
1602
 
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
 
5604
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
1603
5605
            # These systems don't actually have a C or math library (as such)
1604
5606
            continue
1605
5607
            ;;
1613
5615
            ;;
1614
5616
          *-*-rhapsody* | *-*-darwin1.[012])
1615
5617
            # Rhapsody C and math libraries are in the System framework
1616
 
            deplibs="$deplibs -framework System"
 
5618
            func_append deplibs " System.ltframework"
1617
5619
            continue
1618
5620
            ;;
1619
5621
          *-*-sco3.2v5* | *-*-sco5v6*)
1633
5635
           ;;
1634
5636
         esac
1635
5637
        fi
1636
 
        deplibs="$deplibs $arg"
 
5638
        func_append deplibs " $arg"
 
5639
        continue
 
5640
        ;;
 
5641
 
 
5642
      -module)
 
5643
        module=yes
1637
5644
        continue
1638
5645
        ;;
1639
5646
 
1640
5647
      # Tru64 UNIX uses -model [arg] to determine the layout of C++
1641
5648
      # classes, name mangling, and exception handling.
1642
 
      -model)
1643
 
        compile_command="$compile_command $arg"
1644
 
        compiler_flags="$compiler_flags $arg"
1645
 
        finalize_command="$finalize_command $arg"
 
5649
      # Darwin uses the -arch flag to determine output architecture.
 
5650
      -model|-arch|-isysroot|--sysroot)
 
5651
        func_append compiler_flags " $arg"
 
5652
        func_append compile_command " $arg"
 
5653
        func_append finalize_command " $arg"
1646
5654
        prev=xcompiler
1647
5655
        continue
1648
5656
        ;;
1649
5657
 
1650
 
     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
1651
 
        compiler_flags="$compiler_flags $arg"
1652
 
        compile_command="$compile_command $arg"
1653
 
        finalize_command="$finalize_command $arg"
 
5658
      -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
 
5659
      |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
 
5660
        func_append compiler_flags " $arg"
 
5661
        func_append compile_command " $arg"
 
5662
        func_append finalize_command " $arg"
 
5663
        case "$new_inherited_linker_flags " in
 
5664
            *" $arg "*) ;;
 
5665
            * ) func_append new_inherited_linker_flags " $arg" ;;
 
5666
        esac
1654
5667
        continue
1655
5668
        ;;
1656
5669
 
1659
5672
        continue
1660
5673
        ;;
1661
5674
 
1662
 
      -module)
1663
 
        module=yes
1664
 
        continue
1665
 
        ;;
1666
 
 
1667
 
      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
1668
 
      # -r[0-9][0-9]* specifies the processor on the SGI compiler
1669
 
      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
1670
 
      # +DA*, +DD* enable 64-bit mode on the HP compiler
1671
 
      # -q* pass through compiler args for the IBM compiler
1672
 
      # -m* pass through architecture-specific compiler args for GCC
1673
 
      # -m*, -t[45]*, -txscale* pass through architecture-specific
1674
 
      # compiler args for GCC
1675
 
      # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
1676
 
      # -F/path gives path to uninstalled frameworks, gcc on darwin
1677
 
      # @file GCC response files
1678
 
      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
1679
 
      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
1680
 
 
1681
 
        # Unknown arguments in both finalize_command and compile_command need
1682
 
        # to be aesthetically quoted because they are evaled later.
1683
 
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1684
 
        case $arg in
1685
 
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1686
 
          arg="\"$arg\""
1687
 
          ;;
1688
 
        esac
1689
 
        compile_command="$compile_command $arg"
1690
 
        finalize_command="$finalize_command $arg"
1691
 
        compiler_flags="$compiler_flags $arg"
1692
 
        continue
1693
 
        ;;
1694
 
 
1695
 
      -shrext)
1696
 
        prev=shrext
1697
 
        continue
1698
 
        ;;
1699
 
 
1700
5675
      -no-fast-install)
1701
5676
        fast_install=no
1702
5677
        continue
1704
5679
 
1705
5680
      -no-install)
1706
5681
        case $host in
1707
 
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin*)
 
5682
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
1708
5683
          # The PATH hackery in wrapper scripts is required on Windows
1709
5684
          # and Darwin in order for the loader to find any dlls it needs.
1710
 
          $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1711
 
          $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
 
5685
          func_warning "\`-no-install' is ignored for $host"
 
5686
          func_warning "assuming \`-no-fast-install' instead"
1712
5687
          fast_install=no
1713
5688
          ;;
1714
5689
        *) no_install=yes ;;
1749
5724
        ;;
1750
5725
 
1751
5726
      -R*)
1752
 
        dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
 
5727
        func_stripname '-R' '' "$arg"
 
5728
        dir=$func_stripname_result
1753
5729
        # We need an absolute path.
1754
5730
        case $dir in
1755
5731
        [\\/]* | [A-Za-z]:[\\/]*) ;;
 
5732
        =*)
 
5733
          func_stripname '=' '' "$dir"
 
5734
          dir=$lt_sysroot$func_stripname_result
 
5735
          ;;
1756
5736
        *)
1757
 
          $echo "$modename: only absolute run-paths are allowed" 1>&2
1758
 
          exit $EXIT_FAILURE
 
5737
          func_fatal_error "only absolute run-paths are allowed"
1759
5738
          ;;
1760
5739
        esac
1761
5740
        case "$xrpath " in
1762
5741
        *" $dir "*) ;;
1763
 
        *) xrpath="$xrpath $dir" ;;
 
5742
        *) func_append xrpath " $dir" ;;
1764
5743
        esac
1765
5744
        continue
1766
5745
        ;;
1767
5746
 
 
5747
      -shared)
 
5748
        # The effects of -shared are defined in a previous loop.
 
5749
        continue
 
5750
        ;;
 
5751
 
 
5752
      -shrext)
 
5753
        prev=shrext
 
5754
        continue
 
5755
        ;;
 
5756
 
1768
5757
      -static | -static-libtool-libs)
1769
5758
        # The effects of -static are defined in a previous loop.
1770
5759
        # We used to do the same as -all-static on platforms that
1783
5772
        prev=vinfo
1784
5773
        continue
1785
5774
        ;;
 
5775
 
1786
5776
      -version-number)
1787
5777
        prev=vinfo
1788
5778
        vinfo_number=yes
1789
5779
        continue
1790
5780
        ;;
1791
5781
 
 
5782
      -weak)
 
5783
        prev=weak
 
5784
        continue
 
5785
        ;;
 
5786
 
1792
5787
      -Wc,*)
1793
 
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
 
5788
        func_stripname '-Wc,' '' "$arg"
 
5789
        args=$func_stripname_result
1794
5790
        arg=
1795
5791
        save_ifs="$IFS"; IFS=','
1796
5792
        for flag in $args; do
1797
5793
          IFS="$save_ifs"
1798
 
          case $flag in
1799
 
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1800
 
            flag="\"$flag\""
1801
 
            ;;
1802
 
          esac
1803
 
          arg="$arg $wl$flag"
1804
 
          compiler_flags="$compiler_flags $flag"
 
5794
          func_quote_for_eval "$flag"
 
5795
          func_append arg " $func_quote_for_eval_result"
 
5796
          func_append compiler_flags " $func_quote_for_eval_result"
1805
5797
        done
1806
5798
        IFS="$save_ifs"
1807
 
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
 
5799
        func_stripname ' ' '' "$arg"
 
5800
        arg=$func_stripname_result
1808
5801
        ;;
1809
5802
 
1810
5803
      -Wl,*)
1811
 
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
 
5804
        func_stripname '-Wl,' '' "$arg"
 
5805
        args=$func_stripname_result
1812
5806
        arg=
1813
5807
        save_ifs="$IFS"; IFS=','
1814
5808
        for flag in $args; do
1815
5809
          IFS="$save_ifs"
1816
 
          case $flag in
1817
 
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1818
 
            flag="\"$flag\""
1819
 
            ;;
1820
 
          esac
1821
 
          arg="$arg $wl$flag"
1822
 
          compiler_flags="$compiler_flags $wl$flag"
1823
 
          linker_flags="$linker_flags $flag"
 
5810
          func_quote_for_eval "$flag"
 
5811
          func_append arg " $wl$func_quote_for_eval_result"
 
5812
          func_append compiler_flags " $wl$func_quote_for_eval_result"
 
5813
          func_append linker_flags " $func_quote_for_eval_result"
1824
5814
        done
1825
5815
        IFS="$save_ifs"
1826
 
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
 
5816
        func_stripname ' ' '' "$arg"
 
5817
        arg=$func_stripname_result
1827
5818
        ;;
1828
5819
 
1829
5820
      -Xcompiler)
1841
5832
        continue
1842
5833
        ;;
1843
5834
 
 
5835
      # -msg_* for osf cc
 
5836
      -msg_*)
 
5837
        func_quote_for_eval "$arg"
 
5838
        arg="$func_quote_for_eval_result"
 
5839
        ;;
 
5840
 
 
5841
      # Flags to be passed through unchanged, with rationale:
 
5842
      # -64, -mips[0-9]      enable 64-bit mode for the SGI compiler
 
5843
      # -r[0-9][0-9]*        specify processor for the SGI compiler
 
5844
      # -xarch=*, -xtarget=* enable 64-bit mode for the Sun compiler
 
5845
      # +DA*, +DD*           enable 64-bit mode for the HP compiler
 
5846
      # -q*                  compiler args for the IBM compiler
 
5847
      # -m*, -t[45]*, -txscale* architecture-specific flags for GCC
 
5848
      # -F/path              path to uninstalled frameworks, gcc on darwin
 
5849
      # -p, -pg, --coverage, -fprofile-*  profiling flags for GCC
 
5850
      # @file                GCC response files
 
5851
      # -tp=*                Portland pgcc target processor selection
 
5852
      # --sysroot=*          for sysroot support
 
5853
      # -O*, -flto*, -fwhopr*, -fuse-linker-plugin GCC link-time optimization
 
5854
      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
 
5855
      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*|-tp=*|--sysroot=*| \
 
5856
      -O*|-flto*|-fwhopr*|-fuse-linker-plugin)
 
5857
        func_quote_for_eval "$arg"
 
5858
        arg="$func_quote_for_eval_result"
 
5859
        func_append compile_command " $arg"
 
5860
        func_append finalize_command " $arg"
 
5861
        func_append compiler_flags " $arg"
 
5862
        continue
 
5863
        ;;
 
5864
 
1844
5865
      # Some other compiler flag.
1845
5866
      -* | +*)
1846
 
        # Unknown arguments in both finalize_command and compile_command need
1847
 
        # to be aesthetically quoted because they are evaled later.
1848
 
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1849
 
        case $arg in
1850
 
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1851
 
          arg="\"$arg\""
1852
 
          ;;
1853
 
        esac
 
5867
        func_quote_for_eval "$arg"
 
5868
        arg="$func_quote_for_eval_result"
1854
5869
        ;;
1855
5870
 
1856
5871
      *.$objext)
1857
5872
        # A standard object.
1858
 
        objs="$objs $arg"
 
5873
        func_append objs " $arg"
1859
5874
        ;;
1860
5875
 
1861
5876
      *.lo)
1862
5877
        # A libtool-controlled object.
1863
5878
 
1864
5879
        # Check to see that this really is a libtool object.
1865
 
        if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 
5880
        if func_lalib_unsafe_p "$arg"; then
1866
5881
          pic_object=
1867
5882
          non_pic_object=
1868
5883
 
1869
5884
          # Read the .lo file
1870
 
          # If there is no directory component, then add one.
1871
 
          case $arg in
1872
 
          */* | *\\*) . $arg ;;
1873
 
          *) . ./$arg ;;
1874
 
          esac
 
5885
          func_source "$arg"
1875
5886
 
1876
 
          if test -z "$pic_object" || \
 
5887
          if test -z "$pic_object" ||
1877
5888
             test -z "$non_pic_object" ||
1878
 
             test "$pic_object" = none && \
 
5889
             test "$pic_object" = none &&
1879
5890
             test "$non_pic_object" = none; then
1880
 
            $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1881
 
            exit $EXIT_FAILURE
 
5891
            func_fatal_error "cannot find name of object for \`$arg'"
1882
5892
          fi
1883
5893
 
1884
5894
          # Extract subdirectory from the argument.
1885
 
          xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1886
 
          if test "X$xdir" = "X$arg"; then
1887
 
            xdir=
1888
 
          else
1889
 
            xdir="$xdir/"
1890
 
          fi
 
5895
          func_dirname "$arg" "/" ""
 
5896
          xdir="$func_dirname_result"
1891
5897
 
1892
5898
          if test "$pic_object" != none; then
1893
5899
            # Prepend the subdirectory the object is found in.
1895
5901
 
1896
5902
            if test "$prev" = dlfiles; then
1897
5903
              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1898
 
                dlfiles="$dlfiles $pic_object"
 
5904
                func_append dlfiles " $pic_object"
1899
5905
                prev=
1900
5906
                continue
1901
5907
              else
1907
5913
            # CHECK ME:  I think I busted this.  -Ossama
1908
5914
            if test "$prev" = dlprefiles; then
1909
5915
              # Preload the old-style object.
1910
 
              dlprefiles="$dlprefiles $pic_object"
 
5916
              func_append dlprefiles " $pic_object"
1911
5917
              prev=
1912
5918
            fi
1913
5919
 
1914
5920
            # A PIC object.
1915
 
            libobjs="$libobjs $pic_object"
 
5921
            func_append libobjs " $pic_object"
1916
5922
            arg="$pic_object"
1917
5923
          fi
1918
5924
 
1922
5928
            non_pic_object="$xdir$non_pic_object"
1923
5929
 
1924
5930
            # A standard non-PIC object
1925
 
            non_pic_objects="$non_pic_objects $non_pic_object"
 
5931
            func_append non_pic_objects " $non_pic_object"
1926
5932
            if test -z "$pic_object" || test "$pic_object" = none ; then
1927
5933
              arg="$non_pic_object"
1928
5934
            fi
1930
5936
            # If the PIC object exists, use it instead.
1931
5937
            # $xdir was prepended to $pic_object above.
1932
5938
            non_pic_object="$pic_object"
1933
 
            non_pic_objects="$non_pic_objects $non_pic_object"
 
5939
            func_append non_pic_objects " $non_pic_object"
1934
5940
          fi
1935
5941
        else
1936
5942
          # Only an error if not doing a dry-run.
1937
 
          if test -z "$run"; then
1938
 
            $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1939
 
            exit $EXIT_FAILURE
1940
 
          else
1941
 
            # Dry-run case.
1942
 
 
 
5943
          if $opt_dry_run; then
1943
5944
            # Extract subdirectory from the argument.
1944
 
            xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1945
 
            if test "X$xdir" = "X$arg"; then
1946
 
              xdir=
1947
 
            else
1948
 
              xdir="$xdir/"
1949
 
            fi
 
5945
            func_dirname "$arg" "/" ""
 
5946
            xdir="$func_dirname_result"
1950
5947
 
1951
 
            pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1952
 
            non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1953
 
            libobjs="$libobjs $pic_object"
1954
 
            non_pic_objects="$non_pic_objects $non_pic_object"
 
5948
            func_lo2o "$arg"
 
5949
            pic_object=$xdir$objdir/$func_lo2o_result
 
5950
            non_pic_object=$xdir$func_lo2o_result
 
5951
            func_append libobjs " $pic_object"
 
5952
            func_append non_pic_objects " $non_pic_object"
 
5953
          else
 
5954
            func_fatal_error "\`$arg' is not a valid libtool object"
1955
5955
          fi
1956
5956
        fi
1957
5957
        ;;
1958
5958
 
1959
5959
      *.$libext)
1960
5960
        # An archive.
1961
 
        deplibs="$deplibs $arg"
1962
 
        old_deplibs="$old_deplibs $arg"
 
5961
        func_append deplibs " $arg"
 
5962
        func_append old_deplibs " $arg"
1963
5963
        continue
1964
5964
        ;;
1965
5965
 
1966
5966
      *.la)
1967
5967
        # A libtool-controlled library.
1968
5968
 
 
5969
        func_resolve_sysroot "$arg"
1969
5970
        if test "$prev" = dlfiles; then
1970
5971
          # This library was specified with -dlopen.
1971
 
          dlfiles="$dlfiles $arg"
 
5972
          func_append dlfiles " $func_resolve_sysroot_result"
1972
5973
          prev=
1973
5974
        elif test "$prev" = dlprefiles; then
1974
5975
          # The library was specified with -dlpreopen.
1975
 
          dlprefiles="$dlprefiles $arg"
 
5976
          func_append dlprefiles " $func_resolve_sysroot_result"
1976
5977
          prev=
1977
5978
        else
1978
 
          deplibs="$deplibs $arg"
 
5979
          func_append deplibs " $func_resolve_sysroot_result"
1979
5980
        fi
1980
5981
        continue
1981
5982
        ;;
1984
5985
      *)
1985
5986
        # Unknown arguments in both finalize_command and compile_command need
1986
5987
        # to be aesthetically quoted because they are evaled later.
1987
 
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1988
 
        case $arg in
1989
 
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1990
 
          arg="\"$arg\""
1991
 
          ;;
1992
 
        esac
 
5988
        func_quote_for_eval "$arg"
 
5989
        arg="$func_quote_for_eval_result"
1993
5990
        ;;
1994
5991
      esac # arg
1995
5992
 
1996
5993
      # Now actually substitute the argument into the commands.
1997
5994
      if test -n "$arg"; then
1998
 
        compile_command="$compile_command $arg"
1999
 
        finalize_command="$finalize_command $arg"
 
5995
        func_append compile_command " $arg"
 
5996
        func_append finalize_command " $arg"
2000
5997
      fi
2001
5998
    done # argument parsing loop
2002
5999
 
2003
 
    if test -n "$prev"; then
2004
 
      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
2005
 
      $echo "$help" 1>&2
2006
 
      exit $EXIT_FAILURE
2007
 
    fi
 
6000
    test -n "$prev" && \
 
6001
      func_fatal_help "the \`$prevarg' option requires an argument"
2008
6002
 
2009
6003
    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
2010
6004
      eval arg=\"$export_dynamic_flag_spec\"
2011
 
      compile_command="$compile_command $arg"
2012
 
      finalize_command="$finalize_command $arg"
 
6005
      func_append compile_command " $arg"
 
6006
      func_append finalize_command " $arg"
2013
6007
    fi
2014
6008
 
2015
6009
    oldlibs=
2016
6010
    # calculate the name of the file, without its directory
2017
 
    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
 
6011
    func_basename "$output"
 
6012
    outputname="$func_basename_result"
2018
6013
    libobjs_save="$libobjs"
2019
6014
 
2020
6015
    if test -n "$shlibpath_var"; then
2021
6016
      # get the directories listed in $shlibpath_var
2022
 
      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
 
6017
      eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
2023
6018
    else
2024
6019
      shlib_search_path=
2025
6020
    fi
2026
6021
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
2027
6022
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
2028
6023
 
2029
 
    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
2030
 
    if test "X$output_objdir" = "X$output"; then
2031
 
      output_objdir="$objdir"
2032
 
    else
2033
 
      output_objdir="$output_objdir/$objdir"
2034
 
    fi
 
6024
    func_dirname "$output" "/" ""
 
6025
    output_objdir="$func_dirname_result$objdir"
 
6026
    func_to_tool_file "$output_objdir/"
 
6027
    tool_output_objdir=$func_to_tool_file_result
2035
6028
    # Create the object directory.
2036
 
    if test ! -d "$output_objdir"; then
2037
 
      $show "$mkdir $output_objdir"
2038
 
      $run $mkdir $output_objdir
2039
 
      exit_status=$?
2040
 
      if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
2041
 
        exit $exit_status
2042
 
      fi
2043
 
    fi
 
6029
    func_mkdir_p "$output_objdir"
2044
6030
 
2045
6031
    # Determine the type of output
2046
6032
    case $output in
2047
6033
    "")
2048
 
      $echo "$modename: you must specify an output file" 1>&2
2049
 
      $echo "$help" 1>&2
2050
 
      exit $EXIT_FAILURE
 
6034
      func_fatal_help "you must specify an output file"
2051
6035
      ;;
2052
6036
    *.$libext) linkmode=oldlib ;;
2053
6037
    *.lo | *.$objext) linkmode=obj ;;
2055
6039
    *) linkmode=prog ;; # Anything else should be a program.
2056
6040
    esac
2057
6041
 
2058
 
    case $host in
2059
 
    *cygwin* | *mingw* | *pw32*)
2060
 
      # don't eliminate duplications in $postdeps and $predeps
2061
 
      duplicate_compiler_generated_deps=yes
2062
 
      ;;
2063
 
    *)
2064
 
      duplicate_compiler_generated_deps=$duplicate_deps
2065
 
      ;;
2066
 
    esac
2067
6042
    specialdeplibs=
2068
6043
 
2069
6044
    libs=
2070
6045
    # Find all interdependent deplibs by searching for libraries
2071
6046
    # that are linked more than once (e.g. -la -lb -la)
2072
6047
    for deplib in $deplibs; do
2073
 
      if test "X$duplicate_deps" = "Xyes" ; then
 
6048
      if $opt_preserve_dup_deps ; then
2074
6049
        case "$libs " in
2075
 
        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
6050
        *" $deplib "*) func_append specialdeplibs " $deplib" ;;
2076
6051
        esac
2077
6052
      fi
2078
 
      libs="$libs $deplib"
 
6053
      func_append libs " $deplib"
2079
6054
    done
2080
6055
 
2081
6056
    if test "$linkmode" = lib; then
2085
6060
      # $postdeps and mark them as special (i.e., whose duplicates are
2086
6061
      # not to be eliminated).
2087
6062
      pre_post_deps=
2088
 
      if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
 
6063
      if $opt_duplicate_compiler_generated_deps; then
2089
6064
        for pre_post_dep in $predeps $postdeps; do
2090
6065
          case "$pre_post_deps " in
2091
 
          *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
 
6066
          *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
2092
6067
          esac
2093
 
          pre_post_deps="$pre_post_deps $pre_post_dep"
 
6068
          func_append pre_post_deps " $pre_post_dep"
2094
6069
        done
2095
6070
      fi
2096
6071
      pre_post_deps=
2101
6076
    newlib_search_path=
2102
6077
    need_relink=no # whether we're linking any uninstalled libtool libraries
2103
6078
    notinst_deplibs= # not-installed libtool libraries
 
6079
    notinst_path= # paths that contain not-installed libtool libraries
 
6080
 
2104
6081
    case $linkmode in
2105
6082
    lib)
2106
 
        passes="conv link"
 
6083
        passes="conv dlpreopen link"
2107
6084
        for file in $dlfiles $dlprefiles; do
2108
6085
          case $file in
2109
6086
          *.la) ;;
2110
6087
          *)
2111
 
            $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
2112
 
            exit $EXIT_FAILURE
 
6088
            func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
2113
6089
            ;;
2114
6090
          esac
2115
6091
        done
2125
6101
    *)  passes="conv"
2126
6102
        ;;
2127
6103
    esac
 
6104
 
2128
6105
    for pass in $passes; do
 
6106
      # The preopen pass in lib mode reverses $deplibs; put it back here
 
6107
      # so that -L comes before libs that need it for instance...
 
6108
      if test "$linkmode,$pass" = "lib,link"; then
 
6109
        ## FIXME: Find the place where the list is rebuilt in the wrong
 
6110
        ##        order, and fix it there properly
 
6111
        tmp_deplibs=
 
6112
        for deplib in $deplibs; do
 
6113
          tmp_deplibs="$deplib $tmp_deplibs"
 
6114
        done
 
6115
        deplibs="$tmp_deplibs"
 
6116
      fi
 
6117
 
2129
6118
      if test "$linkmode,$pass" = "lib,link" ||
2130
6119
         test "$linkmode,$pass" = "prog,scan"; then
2131
6120
        libs="$deplibs"
2135
6124
        case $pass in
2136
6125
        dlopen) libs="$dlfiles" ;;
2137
6126
        dlpreopen) libs="$dlprefiles" ;;
2138
 
        link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
 
6127
        link)
 
6128
          libs="$deplibs %DEPLIBS%"
 
6129
          test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
 
6130
          ;;
2139
6131
        esac
2140
6132
      fi
 
6133
      if test "$linkmode,$pass" = "lib,dlpreopen"; then
 
6134
        # Collect and forward deplibs of preopened libtool libs
 
6135
        for lib in $dlprefiles; do
 
6136
          # Ignore non-libtool-libs
 
6137
          dependency_libs=
 
6138
          func_resolve_sysroot "$lib"
 
6139
          case $lib in
 
6140
          *.la) func_source "$func_resolve_sysroot_result" ;;
 
6141
          esac
 
6142
 
 
6143
          # Collect preopened libtool deplibs, except any this library
 
6144
          # has declared as weak libs
 
6145
          for deplib in $dependency_libs; do
 
6146
            func_basename "$deplib"
 
6147
            deplib_base=$func_basename_result
 
6148
            case " $weak_libs " in
 
6149
            *" $deplib_base "*) ;;
 
6150
            *) func_append deplibs " $deplib" ;;
 
6151
            esac
 
6152
          done
 
6153
        done
 
6154
        libs="$dlprefiles"
 
6155
      fi
2141
6156
      if test "$pass" = dlopen; then
2142
6157
        # Collect dlpreopened libraries
2143
6158
        save_deplibs="$deplibs"
2144
6159
        deplibs=
2145
6160
      fi
 
6161
 
2146
6162
      for deplib in $libs; do
2147
6163
        lib=
2148
6164
        found=no
2149
6165
        case $deplib in
2150
 
        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
 
6166
        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
 
6167
        |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
2151
6168
          if test "$linkmode,$pass" = "prog,link"; then
2152
6169
            compile_deplibs="$deplib $compile_deplibs"
2153
6170
            finalize_deplibs="$deplib $finalize_deplibs"
2154
6171
          else
2155
 
            compiler_flags="$compiler_flags $deplib"
 
6172
            func_append compiler_flags " $deplib"
 
6173
            if test "$linkmode" = lib ; then
 
6174
                case "$new_inherited_linker_flags " in
 
6175
                    *" $deplib "*) ;;
 
6176
                    * ) func_append new_inherited_linker_flags " $deplib" ;;
 
6177
                esac
 
6178
            fi
2156
6179
          fi
2157
6180
          continue
2158
6181
          ;;
2159
6182
        -l*)
2160
6183
          if test "$linkmode" != lib && test "$linkmode" != prog; then
2161
 
            $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
 
6184
            func_warning "\`-l' is ignored for archives/objects"
2162
6185
            continue
2163
6186
          fi
2164
 
          name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
 
6187
          func_stripname '-l' '' "$deplib"
 
6188
          name=$func_stripname_result
2165
6189
          if test "$linkmode" = lib; then
2166
6190
            searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
2167
6191
          else
2197
6221
            if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
2198
6222
              case " $predeps $postdeps " in
2199
6223
              *" $deplib "*)
2200
 
                if (${SED} -e '2q' $lib |
2201
 
                    grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 
6224
                if func_lalib_p "$lib"; then
2202
6225
                  library_names=
2203
6226
                  old_library=
2204
 
                  case $lib in
2205
 
                  */* | *\\*) . $lib ;;
2206
 
                  *) . ./$lib ;;
2207
 
                  esac
 
6227
                  func_source "$lib"
2208
6228
                  for l in $old_library $library_names; do
2209
6229
                    ll="$l"
2210
6230
                  done
2211
6231
                  if test "X$ll" = "X$old_library" ; then # only static version available
2212
6232
                    found=no
2213
 
                    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2214
 
                    test "X$ladir" = "X$lib" && ladir="."
 
6233
                    func_dirname "$lib" "" "."
 
6234
                    ladir="$func_dirname_result"
2215
6235
                    lib=$ladir/$old_library
2216
6236
                    if test "$linkmode,$pass" = "prog,link"; then
2217
6237
                      compile_deplibs="$deplib $compile_deplibs"
2223
6243
                    continue
2224
6244
                  fi
2225
6245
                fi
2226
 
                ;;
 
6246
                ;;
2227
6247
              *) ;;
2228
6248
              esac
2229
6249
            fi
2230
6250
          fi
2231
6251
          ;; # -l
 
6252
        *.ltframework)
 
6253
          if test "$linkmode,$pass" = "prog,link"; then
 
6254
            compile_deplibs="$deplib $compile_deplibs"
 
6255
            finalize_deplibs="$deplib $finalize_deplibs"
 
6256
          else
 
6257
            deplibs="$deplib $deplibs"
 
6258
            if test "$linkmode" = lib ; then
 
6259
                case "$new_inherited_linker_flags " in
 
6260
                    *" $deplib "*) ;;
 
6261
                    * ) func_append new_inherited_linker_flags " $deplib" ;;
 
6262
                esac
 
6263
            fi
 
6264
          fi
 
6265
          continue
 
6266
          ;;
2232
6267
        -L*)
2233
6268
          case $linkmode in
2234
6269
          lib)
2235
6270
            deplibs="$deplib $deplibs"
2236
6271
            test "$pass" = conv && continue
2237
6272
            newdependency_libs="$deplib $newdependency_libs"
2238
 
            newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
 
6273
            func_stripname '-L' '' "$deplib"
 
6274
            func_resolve_sysroot "$func_stripname_result"
 
6275
            func_append newlib_search_path " $func_resolve_sysroot_result"
2239
6276
            ;;
2240
6277
          prog)
2241
6278
            if test "$pass" = conv; then
2248
6285
              compile_deplibs="$deplib $compile_deplibs"
2249
6286
              finalize_deplibs="$deplib $finalize_deplibs"
2250
6287
            fi
2251
 
            newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
 
6288
            func_stripname '-L' '' "$deplib"
 
6289
            func_resolve_sysroot "$func_stripname_result"
 
6290
            func_append newlib_search_path " $func_resolve_sysroot_result"
2252
6291
            ;;
2253
6292
          *)
2254
 
            $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
 
6293
            func_warning "\`-L' is ignored for archives/objects"
2255
6294
            ;;
2256
6295
          esac # linkmode
2257
6296
          continue
2258
6297
          ;; # -L
2259
6298
        -R*)
2260
6299
          if test "$pass" = link; then
2261
 
            dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
 
6300
            func_stripname '-R' '' "$deplib"
 
6301
            func_resolve_sysroot "$func_stripname_result"
 
6302
            dir=$func_resolve_sysroot_result
2262
6303
            # Make sure the xrpath contains only unique directories.
2263
6304
            case "$xrpath " in
2264
6305
            *" $dir "*) ;;
2265
 
            *) xrpath="$xrpath $dir" ;;
 
6306
            *) func_append xrpath " $dir" ;;
2266
6307
            esac
2267
6308
          fi
2268
6309
          deplibs="$deplib $deplibs"
2269
6310
          continue
2270
6311
          ;;
2271
 
        *.la) lib="$deplib" ;;
 
6312
        *.la)
 
6313
          func_resolve_sysroot "$deplib"
 
6314
          lib=$func_resolve_sysroot_result
 
6315
          ;;
2272
6316
        *.$libext)
2273
6317
          if test "$pass" = conv; then
2274
6318
            deplibs="$deplib $deplibs"
2276
6320
          fi
2277
6321
          case $linkmode in
2278
6322
          lib)
2279
 
            valid_a_lib=no
2280
 
            case $deplibs_check_method in
2281
 
              match_pattern*)
2282
 
                set dummy $deplibs_check_method
2283
 
                match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2284
 
                if eval $echo \"$deplib\" 2>/dev/null \
2285
 
                    | $SED 10q \
 
6323
            # Linking convenience modules into shared libraries is allowed,
 
6324
            # but linking other static libraries is non-portable.
 
6325
            case " $dlpreconveniencelibs " in
 
6326
            *" $deplib "*) ;;
 
6327
            *)
 
6328
              valid_a_lib=no
 
6329
              case $deplibs_check_method in
 
6330
                match_pattern*)
 
6331
                  set dummy $deplibs_check_method; shift
 
6332
                  match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
 
6333
                  if eval "\$ECHO \"$deplib\"" 2>/dev/null | $SED 10q \
2286
6334
                    | $EGREP "$match_pattern_regex" > /dev/null; then
 
6335
                    valid_a_lib=yes
 
6336
                  fi
 
6337
                ;;
 
6338
                pass_all)
2287
6339
                  valid_a_lib=yes
2288
 
                fi
2289
 
                ;;
2290
 
              pass_all)
2291
 
                valid_a_lib=yes
2292
 
                ;;
2293
 
            esac
2294
 
            if test "$valid_a_lib" != yes; then
2295
 
              $echo
2296
 
              $echo "*** Warning: Trying to link with static lib archive $deplib."
2297
 
              $echo "*** I have the capability to make that library automatically link in when"
2298
 
              $echo "*** you link to this library.  But I can only do this if you have a"
2299
 
              $echo "*** shared version of the library, which you do not appear to have"
2300
 
              $echo "*** because the file extensions .$libext of this argument makes me believe"
2301
 
              $echo "*** that it is just a static archive that I should not used here."
2302
 
            else
2303
 
              $echo
2304
 
              $echo "*** Warning: Linking the shared library $output against the"
2305
 
              $echo "*** static library $deplib is not portable!"
2306
 
              deplibs="$deplib $deplibs"
2307
 
            fi
 
6340
                ;;
 
6341
              esac
 
6342
              if test "$valid_a_lib" != yes; then
 
6343
                echo
 
6344
                $ECHO "*** Warning: Trying to link with static lib archive $deplib."
 
6345
                echo "*** I have the capability to make that library automatically link in when"
 
6346
                echo "*** you link to this library.  But I can only do this if you have a"
 
6347
                echo "*** shared version of the library, which you do not appear to have"
 
6348
                echo "*** because the file extensions .$libext of this argument makes me believe"
 
6349
                echo "*** that it is just a static archive that I should not use here."
 
6350
              else
 
6351
                echo
 
6352
                $ECHO "*** Warning: Linking the shared library $output against the"
 
6353
                $ECHO "*** static library $deplib is not portable!"
 
6354
                deplibs="$deplib $deplibs"
 
6355
              fi
 
6356
              ;;
 
6357
            esac
2308
6358
            continue
2309
6359
            ;;
2310
6360
          prog)
2325
6375
            if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2326
6376
              # If there is no dlopen support or we're linking statically,
2327
6377
              # we need to preload.
2328
 
              newdlprefiles="$newdlprefiles $deplib"
 
6378
              func_append newdlprefiles " $deplib"
2329
6379
              compile_deplibs="$deplib $compile_deplibs"
2330
6380
              finalize_deplibs="$deplib $finalize_deplibs"
2331
6381
            else
2332
 
              newdlfiles="$newdlfiles $deplib"
 
6382
              func_append newdlfiles " $deplib"
2333
6383
            fi
2334
6384
          fi
2335
6385
          continue
2339
6389
          continue
2340
6390
          ;;
2341
6391
        esac # case $deplib
 
6392
 
2342
6393
        if test "$found" = yes || test -f "$lib"; then :
2343
6394
        else
2344
 
          $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
2345
 
          exit $EXIT_FAILURE
 
6395
          func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
2346
6396
        fi
2347
6397
 
2348
6398
        # Check to see that this really is a libtool archive.
2349
 
        if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2350
 
        else
2351
 
          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2352
 
          exit $EXIT_FAILURE
2353
 
        fi
 
6399
        func_lalib_unsafe_p "$lib" \
 
6400
          || func_fatal_error "\`$lib' is not a valid libtool archive"
2354
6401
 
2355
 
        ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2356
 
        test "X$ladir" = "X$lib" && ladir="."
 
6402
        func_dirname "$lib" "" "."
 
6403
        ladir="$func_dirname_result"
2357
6404
 
2358
6405
        dlname=
2359
6406
        dlopen=
2361
6408
        libdir=
2362
6409
        library_names=
2363
6410
        old_library=
 
6411
        inherited_linker_flags=
2364
6412
        # If the library was installed with an old release of libtool,
2365
6413
        # it will not redefine variables installed, or shouldnotlink
2366
6414
        installed=yes
2369
6417
 
2370
6418
 
2371
6419
        # Read the .la file
2372
 
        case $lib in
2373
 
        */* | *\\*) . $lib ;;
2374
 
        *) . ./$lib ;;
2375
 
        esac
 
6420
        func_source "$lib"
2376
6421
 
 
6422
        # Convert "-framework foo" to "foo.ltframework"
 
6423
        if test -n "$inherited_linker_flags"; then
 
6424
          tmp_inherited_linker_flags=`$ECHO "$inherited_linker_flags" | $SED 's/-framework \([^ $]*\)/\1.ltframework/g'`
 
6425
          for tmp_inherited_linker_flag in $tmp_inherited_linker_flags; do
 
6426
            case " $new_inherited_linker_flags " in
 
6427
              *" $tmp_inherited_linker_flag "*) ;;
 
6428
              *) func_append new_inherited_linker_flags " $tmp_inherited_linker_flag";;
 
6429
            esac
 
6430
          done
 
6431
        fi
 
6432
        dependency_libs=`$ECHO " $dependency_libs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
2377
6433
        if test "$linkmode,$pass" = "lib,link" ||
2378
6434
           test "$linkmode,$pass" = "prog,scan" ||
2379
6435
           { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2380
 
          test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2381
 
          test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
 
6436
          test -n "$dlopen" && func_append dlfiles " $dlopen"
 
6437
          test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
2382
6438
        fi
2383
6439
 
2384
6440
        if test "$pass" = conv; then
2386
6442
          deplibs="$lib $deplibs"
2387
6443
          if test -z "$libdir"; then
2388
6444
            if test -z "$old_library"; then
2389
 
              $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2390
 
              exit $EXIT_FAILURE
 
6445
              func_fatal_error "cannot find name of link library for \`$lib'"
2391
6446
            fi
2392
6447
            # It is a libtool convenience library, so add in its objects.
2393
 
            convenience="$convenience $ladir/$objdir/$old_library"
2394
 
            old_convenience="$old_convenience $ladir/$objdir/$old_library"
 
6448
            func_append convenience " $ladir/$objdir/$old_library"
 
6449
            func_append old_convenience " $ladir/$objdir/$old_library"
2395
6450
            tmp_libs=
2396
6451
            for deplib in $dependency_libs; do
2397
6452
              deplibs="$deplib $deplibs"
2398
 
              if test "X$duplicate_deps" = "Xyes" ; then
2399
 
                case "$tmp_libs " in
2400
 
                *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2401
 
                esac
2402
 
              fi
2403
 
              tmp_libs="$tmp_libs $deplib"
 
6453
              if $opt_preserve_dup_deps ; then
 
6454
                case "$tmp_libs " in
 
6455
                *" $deplib "*) func_append specialdeplibs " $deplib" ;;
 
6456
                esac
 
6457
              fi
 
6458
              func_append tmp_libs " $deplib"
2404
6459
            done
2405
6460
          elif test "$linkmode" != prog && test "$linkmode" != lib; then
2406
 
            $echo "$modename: \`$lib' is not a convenience library" 1>&2
2407
 
            exit $EXIT_FAILURE
 
6461
            func_fatal_error "\`$lib' is not a convenience library"
2408
6462
          fi
2409
6463
          continue
2410
6464
        fi # $pass = conv
2412
6466
 
2413
6467
        # Get the name of the library we link against.
2414
6468
        linklib=
2415
 
        for l in $old_library $library_names; do
2416
 
          linklib="$l"
2417
 
        done
 
6469
        if test -n "$old_library" &&
 
6470
           { test "$prefer_static_libs" = yes ||
 
6471
             test "$prefer_static_libs,$installed" = "built,no"; }; then
 
6472
          linklib=$old_library
 
6473
        else
 
6474
          for l in $old_library $library_names; do
 
6475
            linklib="$l"
 
6476
          done
 
6477
        fi
2418
6478
        if test -z "$linklib"; then
2419
 
          $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2420
 
          exit $EXIT_FAILURE
 
6479
          func_fatal_error "cannot find name of link library for \`$lib'"
2421
6480
        fi
2422
6481
 
2423
6482
        # This library was specified with -dlopen.
2424
6483
        if test "$pass" = dlopen; then
2425
6484
          if test -z "$libdir"; then
2426
 
            $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2427
 
            exit $EXIT_FAILURE
 
6485
            func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
2428
6486
          fi
2429
6487
          if test -z "$dlname" ||
2430
6488
             test "$dlopen_support" != yes ||
2433
6491
            # statically, we need to preload.  We also need to preload any
2434
6492
            # dependent libraries so libltdl's deplib preloader doesn't
2435
6493
            # bomb out in the load deplibs phase.
2436
 
            dlprefiles="$dlprefiles $lib $dependency_libs"
 
6494
            func_append dlprefiles " $lib $dependency_libs"
2437
6495
          else
2438
 
            newdlfiles="$newdlfiles $lib"
 
6496
            func_append newdlfiles " $lib"
2439
6497
          fi
2440
6498
          continue
2441
6499
        fi # $pass = dlopen
2446
6504
        *)
2447
6505
          abs_ladir=`cd "$ladir" && pwd`
2448
6506
          if test -z "$abs_ladir"; then
2449
 
            $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2450
 
            $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
 
6507
            func_warning "cannot determine absolute directory name of \`$ladir'"
 
6508
            func_warning "passing it literally to the linker, although it might fail"
2451
6509
            abs_ladir="$ladir"
2452
6510
          fi
2453
6511
          ;;
2454
6512
        esac
2455
 
        laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
 
6513
        func_basename "$lib"
 
6514
        laname="$func_basename_result"
2456
6515
 
2457
6516
        # Find the relevant object directory and library name.
2458
6517
        if test "X$installed" = Xyes; then
2459
 
          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2460
 
            $echo "$modename: warning: library \`$lib' was moved." 1>&2
 
6518
          if test ! -f "$lt_sysroot$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
 
6519
            func_warning "library \`$lib' was moved."
2461
6520
            dir="$ladir"
2462
6521
            absdir="$abs_ladir"
2463
6522
            libdir="$abs_ladir"
2464
6523
          else
2465
 
            dir="$libdir"
2466
 
            absdir="$libdir"
 
6524
            dir="$lt_sysroot$libdir"
 
6525
            absdir="$lt_sysroot$libdir"
2467
6526
          fi
2468
6527
          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
2469
6528
        else
2471
6530
            dir="$ladir"
2472
6531
            absdir="$abs_ladir"
2473
6532
            # Remove this search path later
2474
 
            notinst_path="$notinst_path $abs_ladir"
 
6533
            func_append notinst_path " $abs_ladir"
2475
6534
          else
2476
6535
            dir="$ladir/$objdir"
2477
6536
            absdir="$abs_ladir/$objdir"
2478
6537
            # Remove this search path later
2479
 
            notinst_path="$notinst_path $abs_ladir"
 
6538
            func_append notinst_path " $abs_ladir"
2480
6539
          fi
2481
6540
        fi # $installed = yes
2482
 
        name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 
6541
        func_stripname 'lib' '.la' "$laname"
 
6542
        name=$func_stripname_result
2483
6543
 
2484
6544
        # This library was specified with -dlpreopen.
2485
6545
        if test "$pass" = dlpreopen; then
2486
 
          if test -z "$libdir"; then
2487
 
            $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2488
 
            exit $EXIT_FAILURE
2489
 
          fi
2490
 
          # Prefer using a static library (so that no silly _DYNAMIC symbols
2491
 
          # are required to link).
2492
 
          if test -n "$old_library"; then
2493
 
            newdlprefiles="$newdlprefiles $dir/$old_library"
2494
 
          # Otherwise, use the dlname, so that lt_dlopen finds it.
2495
 
          elif test -n "$dlname"; then
2496
 
            newdlprefiles="$newdlprefiles $dir/$dlname"
2497
 
          else
2498
 
            newdlprefiles="$newdlprefiles $dir/$linklib"
2499
 
          fi
 
6546
          if test -z "$libdir" && test "$linkmode" = prog; then
 
6547
            func_fatal_error "only libraries may -dlpreopen a convenience library: \`$lib'"
 
6548
          fi
 
6549
          case "$host" in
 
6550
            # special handling for platforms with PE-DLLs.
 
6551
            *cygwin* | *mingw* | *cegcc* )
 
6552
              # Linker will automatically link against shared library if both
 
6553
              # static and shared are present.  Therefore, ensure we extract
 
6554
              # symbols from the import library if a shared library is present
 
6555
              # (otherwise, the dlopen module name will be incorrect).  We do
 
6556
              # this by putting the import library name into $newdlprefiles.
 
6557
              # We recover the dlopen module name by 'saving' the la file
 
6558
              # name in a special purpose variable, and (later) extracting the
 
6559
              # dlname from the la file.
 
6560
              if test -n "$dlname"; then
 
6561
                func_tr_sh "$dir/$linklib"
 
6562
                eval "libfile_$func_tr_sh_result=\$abs_ladir/\$laname"
 
6563
                func_append newdlprefiles " $dir/$linklib"
 
6564
              else
 
6565
                func_append newdlprefiles " $dir/$old_library"
 
6566
                # Keep a list of preopened convenience libraries to check
 
6567
                # that they are being used correctly in the link pass.
 
6568
                test -z "$libdir" && \
 
6569
                  func_append dlpreconveniencelibs " $dir/$old_library"
 
6570
              fi
 
6571
            ;;
 
6572
            * )
 
6573
              # Prefer using a static library (so that no silly _DYNAMIC symbols
 
6574
              # are required to link).
 
6575
              if test -n "$old_library"; then
 
6576
                func_append newdlprefiles " $dir/$old_library"
 
6577
                # Keep a list of preopened convenience libraries to check
 
6578
                # that they are being used correctly in the link pass.
 
6579
                test -z "$libdir" && \
 
6580
                  func_append dlpreconveniencelibs " $dir/$old_library"
 
6581
              # Otherwise, use the dlname, so that lt_dlopen finds it.
 
6582
              elif test -n "$dlname"; then
 
6583
                func_append newdlprefiles " $dir/$dlname"
 
6584
              else
 
6585
                func_append newdlprefiles " $dir/$linklib"
 
6586
              fi
 
6587
            ;;
 
6588
          esac
2500
6589
        fi # $pass = dlpreopen
2501
6590
 
2502
6591
        if test -z "$libdir"; then
2514
6603
 
2515
6604
 
2516
6605
        if test "$linkmode" = prog && test "$pass" != link; then
2517
 
          newlib_search_path="$newlib_search_path $ladir"
 
6606
          func_append newlib_search_path " $ladir"
2518
6607
          deplibs="$lib $deplibs"
2519
6608
 
2520
6609
          linkalldeplibs=no
2526
6615
          tmp_libs=
2527
6616
          for deplib in $dependency_libs; do
2528
6617
            case $deplib in
2529
 
            -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
 
6618
            -L*) func_stripname '-L' '' "$deplib"
 
6619
                 func_resolve_sysroot "$func_stripname_result"
 
6620
                 func_append newlib_search_path " $func_resolve_sysroot_result"
 
6621
                 ;;
2530
6622
            esac
2531
6623
            # Need to link against all dependency_libs?
2532
6624
            if test "$linkalldeplibs" = yes; then
2536
6628
              # or/and link against static libraries
2537
6629
              newdependency_libs="$deplib $newdependency_libs"
2538
6630
            fi
2539
 
            if test "X$duplicate_deps" = "Xyes" ; then
 
6631
            if $opt_preserve_dup_deps ; then
2540
6632
              case "$tmp_libs " in
2541
 
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
6633
              *" $deplib "*) func_append specialdeplibs " $deplib" ;;
2542
6634
              esac
2543
6635
            fi
2544
 
            tmp_libs="$tmp_libs $deplib"
 
6636
            func_append tmp_libs " $deplib"
2545
6637
          done # for deplib
2546
6638
          continue
2547
6639
        fi # $linkmode = prog...
2549
6641
        if test "$linkmode,$pass" = "prog,link"; then
2550
6642
          if test -n "$library_names" &&
2551
6643
             { { test "$prefer_static_libs" = no ||
2552
 
                 test "$prefer_static_libs,$installed" = "built,yes"; } ||
 
6644
                 test "$prefer_static_libs,$installed" = "built,yes"; } ||
2553
6645
               test -z "$old_library"; }; then
2554
6646
            # We need to hardcode the library path
2555
6647
            if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
2556
6648
              # Make sure the rpath contains only unique directories.
2557
 
              case "$temp_rpath " in
2558
 
              *" $dir "*) ;;
2559
 
              *" $absdir "*) ;;
2560
 
              *) temp_rpath="$temp_rpath $absdir" ;;
 
6649
              case "$temp_rpath:" in
 
6650
              *"$absdir:"*) ;;
 
6651
              *) func_append temp_rpath "$absdir:" ;;
2561
6652
              esac
2562
6653
            fi
2563
6654
 
2569
6660
            *)
2570
6661
              case "$compile_rpath " in
2571
6662
              *" $absdir "*) ;;
2572
 
              *) compile_rpath="$compile_rpath $absdir"
 
6663
              *) func_append compile_rpath " $absdir" ;;
2573
6664
              esac
2574
6665
              ;;
2575
6666
            esac
2578
6669
            *)
2579
6670
              case "$finalize_rpath " in
2580
6671
              *" $libdir "*) ;;
2581
 
              *) finalize_rpath="$finalize_rpath $libdir"
 
6672
              *) func_append finalize_rpath " $libdir" ;;
2582
6673
              esac
2583
6674
              ;;
2584
6675
            esac
2595
6686
 
2596
6687
        link_static=no # Whether the deplib will be linked statically
2597
6688
        use_static_libs=$prefer_static_libs
2598
 
        if test "$use_static_libs" = built && test "$installed" = yes ; then
 
6689
        if test "$use_static_libs" = built && test "$installed" = yes; then
2599
6690
          use_static_libs=no
2600
6691
        fi
2601
6692
        if test -n "$library_names" &&
2602
6693
           { test "$use_static_libs" = no || test -z "$old_library"; }; then
2603
 
          if test "$installed" = no; then
2604
 
            notinst_deplibs="$notinst_deplibs $lib"
2605
 
            need_relink=yes
2606
 
          fi
 
6694
          case $host in
 
6695
          *cygwin* | *mingw* | *cegcc*)
 
6696
              # No point in relinking DLLs because paths are not encoded
 
6697
              func_append notinst_deplibs " $lib"
 
6698
              need_relink=no
 
6699
            ;;
 
6700
          *)
 
6701
            if test "$installed" = no; then
 
6702
              func_append notinst_deplibs " $lib"
 
6703
              need_relink=yes
 
6704
            fi
 
6705
            ;;
 
6706
          esac
2607
6707
          # This is a shared library
2608
6708
 
2609
 
          # Warn about portability, can't link against -module's on
2610
 
          # some systems (darwin)
2611
 
          if test "$shouldnotlink" = yes && test "$pass" = link ; then
2612
 
            $echo
 
6709
          # Warn about portability, can't link against -module's on some
 
6710
          # systems (darwin).  Don't bleat about dlopened modules though!
 
6711
          dlopenmodule=""
 
6712
          for dlpremoduletest in $dlprefiles; do
 
6713
            if test "X$dlpremoduletest" = "X$lib"; then
 
6714
              dlopenmodule="$dlpremoduletest"
 
6715
              break
 
6716
            fi
 
6717
          done
 
6718
          if test -z "$dlopenmodule" && test "$shouldnotlink" = yes && test "$pass" = link; then
 
6719
            echo
2613
6720
            if test "$linkmode" = prog; then
2614
 
              $echo "*** Warning: Linking the executable $output against the loadable module"
 
6721
              $ECHO "*** Warning: Linking the executable $output against the loadable module"
2615
6722
            else
2616
 
              $echo "*** Warning: Linking the shared library $output against the loadable module"
 
6723
              $ECHO "*** Warning: Linking the shared library $output against the loadable module"
2617
6724
            fi
2618
 
            $echo "*** $linklib is not portable!"
 
6725
            $ECHO "*** $linklib is not portable!"
2619
6726
          fi
2620
6727
          if test "$linkmode" = lib &&
2621
6728
             test "$hardcode_into_libs" = yes; then
2627
6734
            *)
2628
6735
              case "$compile_rpath " in
2629
6736
              *" $absdir "*) ;;
2630
 
              *) compile_rpath="$compile_rpath $absdir"
 
6737
              *) func_append compile_rpath " $absdir" ;;
2631
6738
              esac
2632
6739
              ;;
2633
6740
            esac
2636
6743
            *)
2637
6744
              case "$finalize_rpath " in
2638
6745
              *" $libdir "*) ;;
2639
 
              *) finalize_rpath="$finalize_rpath $libdir"
 
6746
              *) func_append finalize_rpath " $libdir" ;;
2640
6747
              esac
2641
6748
              ;;
2642
6749
            esac
2645
6752
          if test -n "$old_archive_from_expsyms_cmds"; then
2646
6753
            # figure out the soname
2647
6754
            set dummy $library_names
2648
 
            realname="$2"
2649
 
            shift; shift
2650
 
            libname=`eval \\$echo \"$libname_spec\"`
 
6755
            shift
 
6756
            realname="$1"
 
6757
            shift
 
6758
            libname=`eval "\\$ECHO \"$libname_spec\""`
2651
6759
            # use dlname if we got it. it's perfectly good, no?
2652
6760
            if test -n "$dlname"; then
2653
6761
              soname="$dlname"
2654
6762
            elif test -n "$soname_spec"; then
2655
6763
              # bleh windows
2656
6764
              case $host in
2657
 
              *cygwin* | mingw*)
2658
 
                major=`expr $current - $age`
 
6765
              *cygwin* | mingw* | *cegcc*)
 
6766
                func_arith $current - $age
 
6767
                major=$func_arith_result
2659
6768
                versuffix="-$major"
2660
6769
                ;;
2661
6770
              esac
2666
6775
 
2667
6776
            # Make a new name for the extract_expsyms_cmds to use
2668
6777
            soroot="$soname"
2669
 
            soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2670
 
            newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
 
6778
            func_basename "$soroot"
 
6779
            soname="$func_basename_result"
 
6780
            func_stripname 'lib' '.dll' "$soname"
 
6781
            newlib=libimp-$func_stripname_result.a
2671
6782
 
2672
6783
            # If the library has no export list, then create one now
2673
6784
            if test -f "$output_objdir/$soname-def"; then :
2674
6785
            else
2675
 
              $show "extracting exported symbol list from \`$soname'"
2676
 
              save_ifs="$IFS"; IFS='~'
2677
 
              cmds=$extract_expsyms_cmds
2678
 
              for cmd in $cmds; do
2679
 
                IFS="$save_ifs"
2680
 
                eval cmd=\"$cmd\"
2681
 
                $show "$cmd"
2682
 
                $run eval "$cmd" || exit $?
2683
 
              done
2684
 
              IFS="$save_ifs"
 
6786
              func_verbose "extracting exported symbol list from \`$soname'"
 
6787
              func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
2685
6788
            fi
2686
6789
 
2687
6790
            # Create $newlib
2688
6791
            if test -f "$output_objdir/$newlib"; then :; else
2689
 
              $show "generating import library for \`$soname'"
2690
 
              save_ifs="$IFS"; IFS='~'
2691
 
              cmds=$old_archive_from_expsyms_cmds
2692
 
              for cmd in $cmds; do
2693
 
                IFS="$save_ifs"
2694
 
                eval cmd=\"$cmd\"
2695
 
                $show "$cmd"
2696
 
                $run eval "$cmd" || exit $?
2697
 
              done
2698
 
              IFS="$save_ifs"
 
6792
              func_verbose "generating import library for \`$soname'"
 
6793
              func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
2699
6794
            fi
2700
6795
            # make sure the library variables are pointing to the new library
2701
6796
            dir=$output_objdir
2702
6797
            linklib=$newlib
2703
6798
          fi # test -n "$old_archive_from_expsyms_cmds"
2704
6799
 
2705
 
          if test "$linkmode" = prog || test "$mode" != relink; then
 
6800
          if test "$linkmode" = prog || test "$opt_mode" != relink; then
2706
6801
            add_shlibpath=
2707
6802
            add_dir=
2708
6803
            add=
2717
6812
                  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
2718
6813
                    *-*-unixware7*) add_dir="-L$dir" ;;
2719
6814
                  *-*-darwin* )
2720
 
                    # if the lib is a module then we can not link against
2721
 
                    # it, someone is ignoring the new warnings I added
 
6815
                    # if the lib is a (non-dlopened) module then we can not
 
6816
                    # link against it, someone is ignoring the earlier warnings
2722
6817
                    if /usr/bin/file -L $add 2> /dev/null |
2723
 
                      $EGREP ": [^:]* bundle" >/dev/null ; then
2724
 
                      $echo "** Warning, lib $linklib is a module, not a shared library"
2725
 
                      if test -z "$old_library" ; then
2726
 
                        $echo
2727
 
                        $echo "** And there doesn't seem to be a static archive available"
2728
 
                        $echo "** The link will probably fail, sorry"
2729
 
                      else
2730
 
                        add="$dir/$old_library"
 
6818
                         $GREP ": [^:]* bundle" >/dev/null ; then
 
6819
                      if test "X$dlopenmodule" != "X$lib"; then
 
6820
                        $ECHO "*** Warning: lib $linklib is a module, not a shared library"
 
6821
                        if test -z "$old_library" ; then
 
6822
                          echo
 
6823
                          echo "*** And there doesn't seem to be a static archive available"
 
6824
                          echo "*** The link will probably fail, sorry"
 
6825
                        else
 
6826
                          add="$dir/$old_library"
 
6827
                        fi
 
6828
                      elif test -n "$old_library"; then
 
6829
                        add="$dir/$old_library"
2731
6830
                      fi
2732
6831
                    fi
2733
6832
                esac
2745
6844
              fi
2746
6845
              ;;
2747
6846
            relink)
2748
 
              if test "$hardcode_direct" = yes; then
 
6847
              if test "$hardcode_direct" = yes &&
 
6848
                 test "$hardcode_direct_absolute" = no; then
2749
6849
                add="$dir/$linklib"
2750
6850
              elif test "$hardcode_minus_L" = yes; then
2751
 
                add_dir="-L$dir"
 
6851
                add_dir="-L$absdir"
2752
6852
                # Try looking first in the location we're being installed to.
2753
6853
                if test -n "$inst_prefix_dir"; then
2754
6854
                  case $libdir in
2755
6855
                    [\\/]*)
2756
 
                      add_dir="$add_dir -L$inst_prefix_dir$libdir"
 
6856
                      func_append add_dir " -L$inst_prefix_dir$libdir"
2757
6857
                      ;;
2758
6858
                  esac
2759
6859
                fi
2769
6869
            esac
2770
6870
 
2771
6871
            if test "$lib_linked" != yes; then
2772
 
              $echo "$modename: configuration error: unsupported hardcode properties"
2773
 
              exit $EXIT_FAILURE
 
6872
              func_fatal_configuration "unsupported hardcode properties"
2774
6873
            fi
2775
6874
 
2776
6875
            if test -n "$add_shlibpath"; then
2777
6876
              case :$compile_shlibpath: in
2778
6877
              *":$add_shlibpath:"*) ;;
2779
 
              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
 
6878
              *) func_append compile_shlibpath "$add_shlibpath:" ;;
2780
6879
              esac
2781
6880
            fi
2782
6881
            if test "$linkmode" = prog; then
2785
6884
            else
2786
6885
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
2787
6886
              test -n "$add" && deplibs="$add $deplibs"
2788
 
              if test "$hardcode_direct" != yes && \
2789
 
                 test "$hardcode_minus_L" != yes && \
 
6887
              if test "$hardcode_direct" != yes &&
 
6888
                 test "$hardcode_minus_L" != yes &&
2790
6889
                 test "$hardcode_shlibpath_var" = yes; then
2791
6890
                case :$finalize_shlibpath: in
2792
6891
                *":$libdir:"*) ;;
2793
 
                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
 
6892
                *) func_append finalize_shlibpath "$libdir:" ;;
2794
6893
                esac
2795
6894
              fi
2796
6895
            fi
2797
6896
          fi
2798
6897
 
2799
 
          if test "$linkmode" = prog || test "$mode" = relink; then
 
6898
          if test "$linkmode" = prog || test "$opt_mode" = relink; then
2800
6899
            add_shlibpath=
2801
6900
            add_dir=
2802
6901
            add=
2803
6902
            # Finalize command for both is simple: just hardcode it.
2804
 
            if test "$hardcode_direct" = yes; then
 
6903
            if test "$hardcode_direct" = yes &&
 
6904
               test "$hardcode_direct_absolute" = no; then
2805
6905
              add="$libdir/$linklib"
2806
6906
            elif test "$hardcode_minus_L" = yes; then
2807
6907
              add_dir="-L$libdir"
2809
6909
            elif test "$hardcode_shlibpath_var" = yes; then
2810
6910
              case :$finalize_shlibpath: in
2811
6911
              *":$libdir:"*) ;;
2812
 
              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
 
6912
              *) func_append finalize_shlibpath "$libdir:" ;;
2813
6913
              esac
2814
6914
              add="-l$name"
2815
6915
            elif test "$hardcode_automatic" = yes; then
2816
6916
              if test -n "$inst_prefix_dir" &&
2817
6917
                 test -f "$inst_prefix_dir$libdir/$linklib" ; then
2818
 
                add="$inst_prefix_dir$libdir/$linklib"
 
6918
                add="$inst_prefix_dir$libdir/$linklib"
2819
6919
              else
2820
 
                add="$libdir/$linklib"
 
6920
                add="$libdir/$linklib"
2821
6921
              fi
2822
6922
            else
2823
6923
              # We cannot seem to hardcode it, guess we'll fake it.
2826
6926
              if test -n "$inst_prefix_dir"; then
2827
6927
                case $libdir in
2828
6928
                  [\\/]*)
2829
 
                    add_dir="$add_dir -L$inst_prefix_dir$libdir"
 
6929
                    func_append add_dir " -L$inst_prefix_dir$libdir"
2830
6930
                    ;;
2831
6931
                esac
2832
6932
              fi
2861
6961
 
2862
6962
            # Just print a warning and add the library to dependency_libs so
2863
6963
            # that the program can be linked against the static library.
2864
 
            $echo
2865
 
            $echo "*** Warning: This system can not link to static lib archive $lib."
2866
 
            $echo "*** I have the capability to make that library automatically link in when"
2867
 
            $echo "*** you link to this library.  But I can only do this if you have a"
2868
 
            $echo "*** shared version of the library, which you do not appear to have."
 
6964
            echo
 
6965
            $ECHO "*** Warning: This system can not link to static lib archive $lib."
 
6966
            echo "*** I have the capability to make that library automatically link in when"
 
6967
            echo "*** you link to this library.  But I can only do this if you have a"
 
6968
            echo "*** shared version of the library, which you do not appear to have."
2869
6969
            if test "$module" = yes; then
2870
 
              $echo "*** But as you try to build a module library, libtool will still create "
2871
 
              $echo "*** a static module, that should work as long as the dlopening application"
2872
 
              $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
 
6970
              echo "*** But as you try to build a module library, libtool will still create "
 
6971
              echo "*** a static module, that should work as long as the dlopening application"
 
6972
              echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2873
6973
              if test -z "$global_symbol_pipe"; then
2874
 
                $echo
2875
 
                $echo "*** However, this would only work if libtool was able to extract symbol"
2876
 
                $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2877
 
                $echo "*** not find such a program.  So, this module is probably useless."
2878
 
                $echo "*** \`nm' from GNU binutils and a full rebuild may help."
 
6974
                echo
 
6975
                echo "*** However, this would only work if libtool was able to extract symbol"
 
6976
                echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
 
6977
                echo "*** not find such a program.  So, this module is probably useless."
 
6978
                echo "*** \`nm' from GNU binutils and a full rebuild may help."
2879
6979
              fi
2880
6980
              if test "$build_old_libs" = no; then
2881
6981
                build_libtool_libs=module
2899
6999
            temp_deplibs=
2900
7000
            for libdir in $dependency_libs; do
2901
7001
              case $libdir in
2902
 
              -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
 
7002
              -R*) func_stripname '-R' '' "$libdir"
 
7003
                   temp_xrpath=$func_stripname_result
2903
7004
                   case " $xrpath " in
2904
7005
                   *" $temp_xrpath "*) ;;
2905
 
                   *) xrpath="$xrpath $temp_xrpath";;
 
7006
                   *) func_append xrpath " $temp_xrpath";;
2906
7007
                   esac;;
2907
 
              *) temp_deplibs="$temp_deplibs $libdir";;
 
7008
              *) func_append temp_deplibs " $libdir";;
2908
7009
              esac
2909
7010
            done
2910
7011
            dependency_libs="$temp_deplibs"
2911
7012
          fi
2912
7013
 
2913
 
          newlib_search_path="$newlib_search_path $absdir"
 
7014
          func_append newlib_search_path " $absdir"
2914
7015
          # Link against this library
2915
7016
          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2916
7017
          # ... and its dependency_libs
2917
7018
          tmp_libs=
2918
7019
          for deplib in $dependency_libs; do
2919
7020
            newdependency_libs="$deplib $newdependency_libs"
2920
 
            if test "X$duplicate_deps" = "Xyes" ; then
 
7021
            case $deplib in
 
7022
              -L*) func_stripname '-L' '' "$deplib"
 
7023
                   func_resolve_sysroot "$func_stripname_result";;
 
7024
              *) func_resolve_sysroot "$deplib" ;;
 
7025
            esac
 
7026
            if $opt_preserve_dup_deps ; then
2921
7027
              case "$tmp_libs " in
2922
 
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
7028
              *" $func_resolve_sysroot_result "*)
 
7029
                func_append specialdeplibs " $func_resolve_sysroot_result" ;;
2923
7030
              esac
2924
7031
            fi
2925
 
            tmp_libs="$tmp_libs $deplib"
 
7032
            func_append tmp_libs " $func_resolve_sysroot_result"
2926
7033
          done
2927
7034
 
2928
7035
          if test "$link_all_deplibs" != no; then
2929
7036
            # Add the search paths of all dependency libraries
2930
7037
            for deplib in $dependency_libs; do
 
7038
              path=
2931
7039
              case $deplib in
2932
7040
              -L*) path="$deplib" ;;
2933
7041
              *.la)
2934
 
                dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2935
 
                test "X$dir" = "X$deplib" && dir="."
 
7042
                func_resolve_sysroot "$deplib"
 
7043
                deplib=$func_resolve_sysroot_result
 
7044
                func_dirname "$deplib" "" "."
 
7045
                dir=$func_dirname_result
2936
7046
                # We need an absolute path.
2937
7047
                case $dir in
2938
7048
                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2939
7049
                *)
2940
7050
                  absdir=`cd "$dir" && pwd`
2941
7051
                  if test -z "$absdir"; then
2942
 
                    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
 
7052
                    func_warning "cannot determine absolute directory name of \`$dir'"
2943
7053
                    absdir="$dir"
2944
7054
                  fi
2945
7055
                  ;;
2946
7056
                esac
2947
 
                if grep "^installed=no" $deplib > /dev/null; then
2948
 
                  path="$absdir/$objdir"
2949
 
                else
2950
 
                  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2951
 
                  if test -z "$libdir"; then
2952
 
                    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2953
 
                    exit $EXIT_FAILURE
2954
 
                  fi
2955
 
                  if test "$absdir" != "$libdir"; then
2956
 
                    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2957
 
                  fi
2958
 
                  path="$absdir"
2959
 
                fi
2960
 
                depdepl=
 
7057
                if $GREP "^installed=no" $deplib > /dev/null; then
2961
7058
                case $host in
2962
7059
                *-*-darwin*)
2963
 
                  # we do not want to link against static libs,
2964
 
                  # but need to link against shared
 
7060
                  depdepl=
2965
7061
                  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2966
 
                  eval deplibdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2967
7062
                  if test -n "$deplibrary_names" ; then
2968
7063
                    for tmp in $deplibrary_names ; do
2969
7064
                      depdepl=$tmp
2970
7065
                    done
2971
 
                    if test -f "$deplibdir/$depdepl" ; then
2972
 
                      depdepl="$deplibdir/$depdepl"
2973
 
                    elif test -f "$path/$depdepl" ; then
2974
 
                      depdepl="$path/$depdepl"
2975
 
                    else
2976
 
                      # Can't find it, oh well...
2977
 
                      depdepl=
 
7066
                    if test -f "$absdir/$objdir/$depdepl" ; then
 
7067
                      depdepl="$absdir/$objdir/$depdepl"
 
7068
                      darwin_install_name=`${OTOOL} -L $depdepl | awk '{if (NR == 2) {print $1;exit}}'`
 
7069
                      if test -z "$darwin_install_name"; then
 
7070
                          darwin_install_name=`${OTOOL64} -L $depdepl  | awk '{if (NR == 2) {print $1;exit}}'`
 
7071
                      fi
 
7072
                      func_append compiler_flags " ${wl}-dylib_file ${wl}${darwin_install_name}:${depdepl}"
 
7073
                      func_append linker_flags " -dylib_file ${darwin_install_name}:${depdepl}"
 
7074
                      path=
2978
7075
                    fi
2979
 
                    # do not add paths which are already there
2980
 
                    case " $newlib_search_path " in
2981
 
                    *" $path "*) ;;
2982
 
                    *) newlib_search_path="$newlib_search_path $path";;
2983
 
                    esac
2984
7076
                  fi
2985
 
                  path=""
2986
7077
                  ;;
2987
7078
                *)
2988
 
                  path="-L$path"
2989
 
                  ;;
2990
 
                esac
2991
 
                ;;
2992
 
              -l*)
2993
 
                case $host in
2994
 
                *-*-darwin*)
2995
 
                  # Again, we only want to link against shared libraries
2996
 
                  eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2997
 
                  for tmp in $newlib_search_path ; do
2998
 
                    if test -f "$tmp/lib$tmp_libs.dylib" ; then
2999
 
                      eval depdepl="$tmp/lib$tmp_libs.dylib"
3000
 
                      break
3001
 
                    fi
3002
 
                  done
3003
 
                  path=""
3004
 
                  ;;
3005
 
                *) continue ;;
3006
 
                esac
3007
 
                ;;
3008
 
              *) continue ;;
 
7079
                  path="-L$absdir/$objdir"
 
7080
                  ;;
 
7081
                esac
 
7082
                else
 
7083
                  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
 
7084
                  test -z "$libdir" && \
 
7085
                    func_fatal_error "\`$deplib' is not a valid libtool archive"
 
7086
                  test "$absdir" != "$libdir" && \
 
7087
                    func_warning "\`$deplib' seems to be moved"
 
7088
 
 
7089
                  path="-L$absdir"
 
7090
                fi
 
7091
                ;;
3009
7092
              esac
3010
7093
              case " $deplibs " in
3011
7094
              *" $path "*) ;;
3012
7095
              *) deplibs="$path $deplibs" ;;
3013
7096
              esac
3014
 
              case " $deplibs " in
3015
 
              *" $depdepl "*) ;;
3016
 
              *) deplibs="$depdepl $deplibs" ;;
3017
 
              esac
3018
7097
            done
3019
7098
          fi # link_all_deplibs != no
3020
7099
        fi # linkmode = lib
3021
7100
      done # for deplib in $libs
 
7101
      if test "$pass" = link; then
 
7102
        if test "$linkmode" = "prog"; then
 
7103
          compile_deplibs="$new_inherited_linker_flags $compile_deplibs"
 
7104
          finalize_deplibs="$new_inherited_linker_flags $finalize_deplibs"
 
7105
        else
 
7106
          compiler_flags="$compiler_flags "`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 
7107
        fi
 
7108
      fi
3022
7109
      dependency_libs="$newdependency_libs"
3023
7110
      if test "$pass" = dlpreopen; then
3024
7111
        # Link the dlpreopened libraries before other libraries
3033
7120
          for dir in $newlib_search_path; do
3034
7121
            case "$lib_search_path " in
3035
7122
            *" $dir "*) ;;
3036
 
            *) lib_search_path="$lib_search_path $dir" ;;
 
7123
            *) func_append lib_search_path " $dir" ;;
3037
7124
            esac
3038
7125
          done
3039
7126
          newlib_search_path=
3091
7178
            -L*)
3092
7179
              case " $tmp_libs " in
3093
7180
              *" $deplib "*) ;;
3094
 
              *) tmp_libs="$tmp_libs $deplib" ;;
 
7181
              *) func_append tmp_libs " $deplib" ;;
3095
7182
              esac
3096
7183
              ;;
3097
 
            *) tmp_libs="$tmp_libs $deplib" ;;
 
7184
            *) func_append tmp_libs " $deplib" ;;
3098
7185
            esac
3099
7186
          done
3100
7187
          eval $var=\"$tmp_libs\"
3110
7197
          ;;
3111
7198
        esac
3112
7199
        if test -n "$i" ; then
3113
 
          tmp_libs="$tmp_libs $i"
 
7200
          func_append tmp_libs " $i"
3114
7201
        fi
3115
7202
      done
3116
7203
      dependency_libs=$tmp_libs
3117
7204
    done # for pass
3118
7205
    if test "$linkmode" = prog; then
3119
7206
      dlfiles="$newdlfiles"
 
7207
    fi
 
7208
    if test "$linkmode" = prog || test "$linkmode" = lib; then
3120
7209
      dlprefiles="$newdlprefiles"
3121
7210
    fi
3122
7211
 
3123
7212
    case $linkmode in
3124
7213
    oldlib)
 
7214
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
 
7215
        func_warning "\`-dlopen' is ignored for archives"
 
7216
      fi
 
7217
 
3125
7218
      case " $deplibs" in
3126
7219
      *\ -l* | *\ -L*)
3127
 
        $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2 ;;
 
7220
        func_warning "\`-l' and \`-L' are ignored for archives" ;;
3128
7221
      esac
3129
7222
 
3130
 
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3131
 
        $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
3132
 
      fi
3133
 
 
3134
 
      if test -n "$rpath"; then
3135
 
        $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
3136
 
      fi
3137
 
 
3138
 
      if test -n "$xrpath"; then
3139
 
        $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
3140
 
      fi
3141
 
 
3142
 
      if test -n "$vinfo"; then
3143
 
        $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
3144
 
      fi
3145
 
 
3146
 
      if test -n "$release"; then
3147
 
        $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
3148
 
      fi
3149
 
 
3150
 
      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
3151
 
        $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
3152
 
      fi
 
7223
      test -n "$rpath" && \
 
7224
        func_warning "\`-rpath' is ignored for archives"
 
7225
 
 
7226
      test -n "$xrpath" && \
 
7227
        func_warning "\`-R' is ignored for archives"
 
7228
 
 
7229
      test -n "$vinfo" && \
 
7230
        func_warning "\`-version-info/-version-number' is ignored for archives"
 
7231
 
 
7232
      test -n "$release" && \
 
7233
        func_warning "\`-release' is ignored for archives"
 
7234
 
 
7235
      test -n "$export_symbols$export_symbols_regex" && \
 
7236
        func_warning "\`-export-symbols' is ignored for archives"
3153
7237
 
3154
7238
      # Now set the variables for building old libraries.
3155
7239
      build_libtool_libs=no
3156
7240
      oldlibs="$output"
3157
 
      objs="$objs$old_deplibs"
 
7241
      func_append objs "$old_deplibs"
3158
7242
      ;;
3159
7243
 
3160
7244
    lib)
3161
7245
      # Make sure we only generate libraries of the form `libNAME.la'.
3162
7246
      case $outputname in
3163
7247
      lib*)
3164
 
        name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 
7248
        func_stripname 'lib' '.la' "$outputname"
 
7249
        name=$func_stripname_result
3165
7250
        eval shared_ext=\"$shrext_cmds\"
3166
7251
        eval libname=\"$libname_spec\"
3167
7252
        ;;
3168
7253
      *)
3169
 
        if test "$module" = no; then
3170
 
          $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
3171
 
          $echo "$help" 1>&2
3172
 
          exit $EXIT_FAILURE
3173
 
        fi
 
7254
        test "$module" = no && \
 
7255
          func_fatal_help "libtool library \`$output' must begin with \`lib'"
 
7256
 
3174
7257
        if test "$need_lib_prefix" != no; then
3175
7258
          # Add the "lib" prefix for modules if required
3176
 
          name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
 
7259
          func_stripname '' '.la' "$outputname"
 
7260
          name=$func_stripname_result
3177
7261
          eval shared_ext=\"$shrext_cmds\"
3178
7262
          eval libname=\"$libname_spec\"
3179
7263
        else
3180
 
          libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
 
7264
          func_stripname '' '.la' "$outputname"
 
7265
          libname=$func_stripname_result
3181
7266
        fi
3182
7267
        ;;
3183
7268
      esac
3184
7269
 
3185
7270
      if test -n "$objs"; then
3186
7271
        if test "$deplibs_check_method" != pass_all; then
3187
 
          $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
3188
 
          exit $EXIT_FAILURE
 
7272
          func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
3189
7273
        else
3190
 
          $echo
3191
 
          $echo "*** Warning: Linking the shared library $output against the non-libtool"
3192
 
          $echo "*** objects $objs is not portable!"
3193
 
          libobjs="$libobjs $objs"
 
7274
          echo
 
7275
          $ECHO "*** Warning: Linking the shared library $output against the non-libtool"
 
7276
          $ECHO "*** objects $objs is not portable!"
 
7277
          func_append libobjs " $objs"
3194
7278
        fi
3195
7279
      fi
3196
7280
 
3197
 
      if test "$dlself" != no; then
3198
 
        $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
3199
 
      fi
 
7281
      test "$dlself" != no && \
 
7282
        func_warning "\`-dlopen self' is ignored for libtool libraries"
3200
7283
 
3201
7284
      set dummy $rpath
3202
 
      if test "$#" -gt 2; then
3203
 
        $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
3204
 
      fi
3205
 
      install_libdir="$2"
 
7285
      shift
 
7286
      test "$#" -gt 1 && \
 
7287
        func_warning "ignoring multiple \`-rpath's for a libtool library"
 
7288
 
 
7289
      install_libdir="$1"
3206
7290
 
3207
7291
      oldlibs=
3208
7292
      if test -z "$rpath"; then
3216
7300
          build_old_libs=yes
3217
7301
        fi
3218
7302
 
3219
 
        if test -n "$vinfo"; then
3220
 
          $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3221
 
        fi
 
7303
        test -n "$vinfo" && \
 
7304
          func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
3222
7305
 
3223
 
        if test -n "$release"; then
3224
 
          $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
3225
 
        fi
 
7306
        test -n "$release" && \
 
7307
          func_warning "\`-release' is ignored for convenience libraries"
3226
7308
      else
3227
7309
 
3228
7310
        # Parse the version information argument.
3229
7311
        save_ifs="$IFS"; IFS=':'
3230
7312
        set dummy $vinfo 0 0 0
 
7313
        shift
3231
7314
        IFS="$save_ifs"
3232
7315
 
3233
 
        if test -n "$8"; then
3234
 
          $echo "$modename: too many parameters to \`-version-info'" 1>&2
3235
 
          $echo "$help" 1>&2
3236
 
          exit $EXIT_FAILURE
3237
 
        fi
 
7316
        test -n "$7" && \
 
7317
          func_fatal_help "too many parameters to \`-version-info'"
3238
7318
 
3239
7319
        # convert absolute version numbers to libtool ages
3240
7320
        # this retains compatibility with .la files and attempts
3242
7322
 
3243
7323
        case $vinfo_number in
3244
7324
        yes)
3245
 
          number_major="$2"
3246
 
          number_minor="$3"
3247
 
          number_revision="$4"
 
7325
          number_major="$1"
 
7326
          number_minor="$2"
 
7327
          number_revision="$3"
3248
7328
          #
3249
7329
          # There are really only two kinds -- those that
3250
7330
          # use the current revision as the major version
3253
7333
          # which has an extra 1 added just for fun
3254
7334
          #
3255
7335
          case $version_type in
 
7336
          # correct linux to gnu/linux during the next big refactor
3256
7337
          darwin|linux|osf|windows|none)
3257
 
            current=`expr $number_major + $number_minor`
 
7338
            func_arith $number_major + $number_minor
 
7339
            current=$func_arith_result
3258
7340
            age="$number_minor"
3259
7341
            revision="$number_revision"
3260
7342
            ;;
3261
 
          freebsd-aout|freebsd-elf|sunos)
 
7343
          freebsd-aout|freebsd-elf|qnx|sunos)
3262
7344
            current="$number_major"
3263
7345
            revision="$number_minor"
3264
7346
            age="0"
3265
7347
            ;;
3266
7348
          irix|nonstopux)
3267
 
            current=`expr $number_major + $number_minor`
 
7349
            func_arith $number_major + $number_minor
 
7350
            current=$func_arith_result
3268
7351
            age="$number_minor"
3269
7352
            revision="$number_minor"
3270
7353
            lt_irix_increment=no
3271
7354
            ;;
 
7355
          *)
 
7356
            func_fatal_configuration "$modename: unknown library version type \`$version_type'"
 
7357
            ;;
3272
7358
          esac
3273
7359
          ;;
3274
7360
        no)
3275
 
          current="$2"
3276
 
          revision="$3"
3277
 
          age="$4"
 
7361
          current="$1"
 
7362
          revision="$2"
 
7363
          age="$3"
3278
7364
          ;;
3279
7365
        esac
3280
7366
 
3282
7368
        case $current in
3283
7369
        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]) ;;
3284
7370
        *)
3285
 
          $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
3286
 
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3287
 
          exit $EXIT_FAILURE
 
7371
          func_error "CURRENT \`$current' must be a nonnegative integer"
 
7372
          func_fatal_error "\`$vinfo' is not valid version information"
3288
7373
          ;;
3289
7374
        esac
3290
7375
 
3291
7376
        case $revision in
3292
7377
        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]) ;;
3293
7378
        *)
3294
 
          $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
3295
 
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3296
 
          exit $EXIT_FAILURE
 
7379
          func_error "REVISION \`$revision' must be a nonnegative integer"
 
7380
          func_fatal_error "\`$vinfo' is not valid version information"
3297
7381
          ;;
3298
7382
        esac
3299
7383
 
3300
7384
        case $age in
3301
7385
        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]) ;;
3302
7386
        *)
3303
 
          $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
3304
 
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3305
 
          exit $EXIT_FAILURE
 
7387
          func_error "AGE \`$age' must be a nonnegative integer"
 
7388
          func_fatal_error "\`$vinfo' is not valid version information"
3306
7389
          ;;
3307
7390
        esac
3308
7391
 
3309
7392
        if test "$age" -gt "$current"; then
3310
 
          $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
3311
 
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3312
 
          exit $EXIT_FAILURE
 
7393
          func_error "AGE \`$age' is greater than the current interface number \`$current'"
 
7394
          func_fatal_error "\`$vinfo' is not valid version information"
3313
7395
        fi
3314
7396
 
3315
7397
        # Calculate the version variables.
3322
7404
        darwin)
3323
7405
          # Like Linux, but with the current version available in
3324
7406
          # verstring for coding it into the library header
3325
 
          major=.`expr $current - $age`
 
7407
          func_arith $current - $age
 
7408
          major=.$func_arith_result
3326
7409
          versuffix="$major.$age.$revision"
3327
7410
          # Darwin ld doesn't like 0 for these options...
3328
 
          minor_current=`expr $current + 1`
 
7411
          func_arith $current + 1
 
7412
          minor_current=$func_arith_result
3329
7413
          xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
3330
7414
          verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
3331
7415
          ;;
3337
7421
 
3338
7422
        freebsd-elf)
3339
7423
          major=".$current"
3340
 
          versuffix=".$current";
 
7424
          versuffix=".$current"
3341
7425
          ;;
3342
7426
 
3343
7427
        irix | nonstopux)
3344
7428
          if test "X$lt_irix_increment" = "Xno"; then
3345
 
            major=`expr $current - $age`
 
7429
            func_arith $current - $age
3346
7430
          else
3347
 
            major=`expr $current - $age + 1`
 
7431
            func_arith $current - $age + 1
3348
7432
          fi
 
7433
          major=$func_arith_result
 
7434
 
3349
7435
          case $version_type in
3350
7436
            nonstopux) verstring_prefix=nonstopux ;;
3351
7437
            *)         verstring_prefix=sgi ;;
3355
7441
          # Add in all the interfaces that we are compatible with.
3356
7442
          loop=$revision
3357
7443
          while test "$loop" -ne 0; do
3358
 
            iface=`expr $revision - $loop`
3359
 
            loop=`expr $loop - 1`
 
7444
            func_arith $revision - $loop
 
7445
            iface=$func_arith_result
 
7446
            func_arith $loop - 1
 
7447
            loop=$func_arith_result
3360
7448
            verstring="$verstring_prefix$major.$iface:$verstring"
3361
7449
          done
3362
7450
 
3365
7453
          versuffix="$major.$revision"
3366
7454
          ;;
3367
7455
 
3368
 
        linux)
3369
 
          major=.`expr $current - $age`
 
7456
        linux) # correct to gnu/linux during the next big refactor
 
7457
          func_arith $current - $age
 
7458
          major=.$func_arith_result
3370
7459
          versuffix="$major.$age.$revision"
3371
7460
          ;;
3372
7461
 
3373
7462
        osf)
3374
 
          major=.`expr $current - $age`
 
7463
          func_arith $current - $age
 
7464
          major=.$func_arith_result
3375
7465
          versuffix=".$current.$age.$revision"
3376
7466
          verstring="$current.$age.$revision"
3377
7467
 
3378
7468
          # Add in all the interfaces that we are compatible with.
3379
7469
          loop=$age
3380
7470
          while test "$loop" -ne 0; do
3381
 
            iface=`expr $current - $loop`
3382
 
            loop=`expr $loop - 1`
 
7471
            func_arith $current - $loop
 
7472
            iface=$func_arith_result
 
7473
            func_arith $loop - 1
 
7474
            loop=$func_arith_result
3383
7475
            verstring="$verstring:${iface}.0"
3384
7476
          done
3385
7477
 
3386
7478
          # Make executables depend on our current version.
3387
 
          verstring="$verstring:${current}.0"
 
7479
          func_append verstring ":${current}.0"
 
7480
          ;;
 
7481
 
 
7482
        qnx)
 
7483
          major=".$current"
 
7484
          versuffix=".$current"
3388
7485
          ;;
3389
7486
 
3390
7487
        sunos)
3395
7492
        windows)
3396
7493
          # Use '-' rather than '.', since we only want one
3397
7494
          # extension on DOS 8.3 filesystems.
3398
 
          major=`expr $current - $age`
 
7495
          func_arith $current - $age
 
7496
          major=$func_arith_result
3399
7497
          versuffix="-$major"
3400
7498
          ;;
3401
7499
 
3402
7500
        *)
3403
 
          $echo "$modename: unknown library version type \`$version_type'" 1>&2
3404
 
          $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3405
 
          exit $EXIT_FAILURE
 
7501
          func_fatal_configuration "unknown library version type \`$version_type'"
3406
7502
          ;;
3407
7503
        esac
3408
7504
 
3436
7532
        # Check to see if the archive will have undefined symbols.
3437
7533
        if test "$allow_undefined" = yes; then
3438
7534
          if test "$allow_undefined_flag" = unsupported; then
3439
 
            $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
 
7535
            func_warning "undefined symbols not allowed in $host shared libraries"
3440
7536
            build_libtool_libs=no
3441
7537
            build_old_libs=yes
3442
7538
          fi
3444
7540
          # Don't allow undefined symbols.
3445
7541
          allow_undefined_flag="$no_undefined_flag"
3446
7542
        fi
 
7543
 
3447
7544
      fi
3448
7545
 
3449
 
      if test "$mode" != relink; then
 
7546
      func_generate_dlsyms "$libname" "$libname" "yes"
 
7547
      func_append libobjs " $symfileobj"
 
7548
      test "X$libobjs" = "X " && libobjs=
 
7549
 
 
7550
      if test "$opt_mode" != relink; then
3450
7551
        # Remove our outputs, but don't remove object files since they
3451
7552
        # may have been created when compiling PIC objects.
3452
7553
        removelist=
3453
 
        tempremovelist=`$echo "$output_objdir/*"`
 
7554
        tempremovelist=`$ECHO "$output_objdir/*"`
3454
7555
        for p in $tempremovelist; do
3455
7556
          case $p in
3456
 
            *.$objext)
 
7557
            *.$objext | *.gcno)
3457
7558
               ;;
3458
7559
            $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3459
7560
               if test "X$precious_files_regex" != "X"; then
3460
 
                 if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3461
 
                 then
 
7561
                 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
 
7562
                 then
3462
7563
                   continue
3463
7564
                 fi
3464
7565
               fi
3465
 
               removelist="$removelist $p"
 
7566
               func_append removelist " $p"
3466
7567
               ;;
3467
7568
            *) ;;
3468
7569
          esac
3469
7570
        done
3470
 
        if test -n "$removelist"; then
3471
 
          $show "${rm}r $removelist"
3472
 
          $run ${rm}r $removelist
3473
 
        fi
 
7571
        test -n "$removelist" && \
 
7572
          func_show_eval "${RM}r \$removelist"
3474
7573
      fi
3475
7574
 
3476
7575
      # Now set the variables for building old libraries.
3477
7576
      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3478
 
        oldlibs="$oldlibs $output_objdir/$libname.$libext"
 
7577
        func_append oldlibs " $output_objdir/$libname.$libext"
3479
7578
 
3480
7579
        # Transform .lo files to .o files.
3481
 
        oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
 
7580
        oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
3482
7581
      fi
3483
7582
 
3484
7583
      # Eliminate all temporary directories.
3485
7584
      #for path in $notinst_path; do
3486
 
      # lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
3487
 
      # deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
3488
 
      # dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
 
7585
      # lib_search_path=`$ECHO "$lib_search_path " | $SED "s% $path % %g"`
 
7586
      # deplibs=`$ECHO "$deplibs " | $SED "s% -L$path % %g"`
 
7587
      # dependency_libs=`$ECHO "$dependency_libs " | $SED "s% -L$path % %g"`
3489
7588
      #done
3490
7589
 
3491
7590
      if test -n "$xrpath"; then
3492
7591
        # If the user specified any rpath flags, then add them.
3493
7592
        temp_xrpath=
3494
7593
        for libdir in $xrpath; do
3495
 
          temp_xrpath="$temp_xrpath -R$libdir"
 
7594
          func_replace_sysroot "$libdir"
 
7595
          func_append temp_xrpath " -R$func_replace_sysroot_result"
3496
7596
          case "$finalize_rpath " in
3497
7597
          *" $libdir "*) ;;
3498
 
          *) finalize_rpath="$finalize_rpath $libdir" ;;
 
7598
          *) func_append finalize_rpath " $libdir" ;;
3499
7599
          esac
3500
7600
        done
3501
7601
        if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3509
7609
      for lib in $old_dlfiles; do
3510
7610
        case " $dlprefiles $dlfiles " in
3511
7611
        *" $lib "*) ;;
3512
 
        *) dlfiles="$dlfiles $lib" ;;
 
7612
        *) func_append dlfiles " $lib" ;;
3513
7613
        esac
3514
7614
      done
3515
7615
 
3519
7619
      for lib in $old_dlprefiles; do
3520
7620
        case "$dlprefiles " in
3521
7621
        *" $lib "*) ;;
3522
 
        *) dlprefiles="$dlprefiles $lib" ;;
 
7622
        *) func_append dlprefiles " $lib" ;;
3523
7623
        esac
3524
7624
      done
3525
7625
 
3526
7626
      if test "$build_libtool_libs" = yes; then
3527
7627
        if test -n "$rpath"; then
3528
7628
          case $host in
3529
 
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
 
7629
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
3530
7630
            # these systems don't actually have a c library (as such)!
3531
7631
            ;;
3532
7632
          *-*-rhapsody* | *-*-darwin1.[012])
3533
7633
            # Rhapsody C library is in the System framework
3534
 
            deplibs="$deplibs -framework System"
 
7634
            func_append deplibs " System.ltframework"
3535
7635
            ;;
3536
7636
          *-*-netbsd*)
3537
7637
            # Don't link with libc until the a.out ld.so is fixed.
3545
7645
          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
3546
7646
            # Compiler inserts libc in the correct place for threads to work
3547
7647
            ;;
3548
 
          *)
 
7648
          *)
3549
7649
            # Add libc to deplibs on all other systems if necessary.
3550
7650
            if test "$build_libtool_need_lc" = "yes"; then
3551
 
              deplibs="$deplibs -lc"
 
7651
              func_append deplibs " -lc"
3552
7652
            fi
3553
7653
            ;;
3554
7654
          esac
3582
7682
          # limits. Maybe even breaks it.  We compile a program, linking it
3583
7683
          # against the deplibs as a proxy for the library.  Then we can check
3584
7684
          # whether they linked in statically or dynamically with ldd.
3585
 
          $rm conftest.c
 
7685
          $opt_dry_run || $RM conftest.c
3586
7686
          cat > conftest.c <<EOF
3587
7687
          int main() { return 0; }
3588
7688
EOF
3589
 
          $rm conftest
 
7689
          $opt_dry_run || $RM conftest
3590
7690
          if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
3591
7691
            ldd_output=`ldd conftest`
3592
7692
            for i in $deplibs; do
3593
 
              name=`expr $i : '-l\(.*\)'`
3594
 
              # If $name is empty we are operating on a -L argument.
3595
 
              if test "$name" != "" && test "$name" != "0"; then
 
7693
              case $i in
 
7694
              -l*)
 
7695
                func_stripname -l '' "$i"
 
7696
                name=$func_stripname_result
3596
7697
                if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3597
7698
                  case " $predeps $postdeps " in
3598
7699
                  *" $i "*)
3599
 
                    newdeplibs="$newdeplibs $i"
 
7700
                    func_append newdeplibs " $i"
3600
7701
                    i=""
3601
7702
                    ;;
3602
7703
                  esac
3603
 
                fi
 
7704
                fi
3604
7705
                if test -n "$i" ; then
3605
 
                  libname=`eval \\$echo \"$libname_spec\"`
3606
 
                  deplib_matches=`eval \\$echo \"$library_names_spec\"`
3607
 
                  set dummy $deplib_matches
3608
 
                  deplib_match=$2
 
7706
                  libname=`eval "\\$ECHO \"$libname_spec\""`
 
7707
                  deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
 
7708
                  set dummy $deplib_matches; shift
 
7709
                  deplib_match=$1
3609
7710
                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3610
 
                    newdeplibs="$newdeplibs $i"
 
7711
                    func_append newdeplibs " $i"
3611
7712
                  else
3612
7713
                    droppeddeps=yes
3613
 
                    $echo
3614
 
                    $echo "*** Warning: dynamic linker does not accept needed library $i."
3615
 
                    $echo "*** I have the capability to make that library automatically link in when"
3616
 
                    $echo "*** you link to this library.  But I can only do this if you have a"
3617
 
                    $echo "*** shared version of the library, which I believe you do not have"
3618
 
                    $echo "*** because a test_compile did reveal that the linker did not use it for"
3619
 
                    $echo "*** its dynamic dependency list that programs get resolved with at runtime."
 
7714
                    echo
 
7715
                    $ECHO "*** Warning: dynamic linker does not accept needed library $i."
 
7716
                    echo "*** I have the capability to make that library automatically link in when"
 
7717
                    echo "*** you link to this library.  But I can only do this if you have a"
 
7718
                    echo "*** shared version of the library, which I believe you do not have"
 
7719
                    echo "*** because a test_compile did reveal that the linker did not use it for"
 
7720
                    echo "*** its dynamic dependency list that programs get resolved with at runtime."
3620
7721
                  fi
3621
7722
                fi
3622
 
              else
3623
 
                newdeplibs="$newdeplibs $i"
3624
 
              fi
 
7723
                ;;
 
7724
              *)
 
7725
                func_append newdeplibs " $i"
 
7726
                ;;
 
7727
              esac
3625
7728
            done
3626
7729
          else
3627
7730
            # Error occurred in the first compile.  Let's try to salvage
3628
7731
            # the situation: Compile a separate program for each library.
3629
7732
            for i in $deplibs; do
3630
 
              name=`expr $i : '-l\(.*\)'`
3631
 
              # If $name is empty we are operating on a -L argument.
3632
 
              if test "$name" != "" && test "$name" != "0"; then
3633
 
                $rm conftest
 
7733
              case $i in
 
7734
              -l*)
 
7735
                func_stripname -l '' "$i"
 
7736
                name=$func_stripname_result
 
7737
                $opt_dry_run || $RM conftest
3634
7738
                if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
3635
7739
                  ldd_output=`ldd conftest`
3636
7740
                  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3637
7741
                    case " $predeps $postdeps " in
3638
7742
                    *" $i "*)
3639
 
                      newdeplibs="$newdeplibs $i"
 
7743
                      func_append newdeplibs " $i"
3640
7744
                      i=""
3641
7745
                      ;;
3642
7746
                    esac
3643
7747
                  fi
3644
7748
                  if test -n "$i" ; then
3645
 
                    libname=`eval \\$echo \"$libname_spec\"`
3646
 
                    deplib_matches=`eval \\$echo \"$library_names_spec\"`
3647
 
                    set dummy $deplib_matches
3648
 
                    deplib_match=$2
 
7749
                    libname=`eval "\\$ECHO \"$libname_spec\""`
 
7750
                    deplib_matches=`eval "\\$ECHO \"$library_names_spec\""`
 
7751
                    set dummy $deplib_matches; shift
 
7752
                    deplib_match=$1
3649
7753
                    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3650
 
                      newdeplibs="$newdeplibs $i"
 
7754
                      func_append newdeplibs " $i"
3651
7755
                    else
3652
7756
                      droppeddeps=yes
3653
 
                      $echo
3654
 
                      $echo "*** Warning: dynamic linker does not accept needed library $i."
3655
 
                      $echo "*** I have the capability to make that library automatically link in when"
3656
 
                      $echo "*** you link to this library.  But I can only do this if you have a"
3657
 
                      $echo "*** shared version of the library, which you do not appear to have"
3658
 
                      $echo "*** because a test_compile did reveal that the linker did not use this one"
3659
 
                      $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
 
7757
                      echo
 
7758
                      $ECHO "*** Warning: dynamic linker does not accept needed library $i."
 
7759
                      echo "*** I have the capability to make that library automatically link in when"
 
7760
                      echo "*** you link to this library.  But I can only do this if you have a"
 
7761
                      echo "*** shared version of the library, which you do not appear to have"
 
7762
                      echo "*** because a test_compile did reveal that the linker did not use this one"
 
7763
                      echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3660
7764
                    fi
3661
7765
                  fi
3662
7766
                else
3663
7767
                  droppeddeps=yes
3664
 
                  $echo
3665
 
                  $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3666
 
                  $echo "*** make it link in!  You will probably need to install it or some"
3667
 
                  $echo "*** library that it depends on before this library will be fully"
3668
 
                  $echo "*** functional.  Installing it before continuing would be even better."
 
7768
                  echo
 
7769
                  $ECHO "*** Warning!  Library $i is needed by this library but I was not able to"
 
7770
                  echo "*** make it link in!  You will probably need to install it or some"
 
7771
                  echo "*** library that it depends on before this library will be fully"
 
7772
                  echo "*** functional.  Installing it before continuing would be even better."
3669
7773
                fi
3670
 
              else
3671
 
                newdeplibs="$newdeplibs $i"
3672
 
              fi
 
7774
                ;;
 
7775
              *)
 
7776
                func_append newdeplibs " $i"
 
7777
                ;;
 
7778
              esac
3673
7779
            done
3674
7780
          fi
3675
7781
          ;;
3676
7782
        file_magic*)
3677
 
          set dummy $deplibs_check_method
3678
 
          file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
 
7783
          set dummy $deplibs_check_method; shift
 
7784
          file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
3679
7785
          for a_deplib in $deplibs; do
3680
 
            name=`expr $a_deplib : '-l\(.*\)'`
3681
 
            # If $name is empty we are operating on a -L argument.
3682
 
            if test "$name" != "" && test  "$name" != "0"; then
 
7786
            case $a_deplib in
 
7787
            -l*)
 
7788
              func_stripname -l '' "$a_deplib"
 
7789
              name=$func_stripname_result
3683
7790
              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3684
7791
                case " $predeps $postdeps " in
3685
7792
                *" $a_deplib "*)
3686
 
                  newdeplibs="$newdeplibs $a_deplib"
 
7793
                  func_append newdeplibs " $a_deplib"
3687
7794
                  a_deplib=""
3688
7795
                  ;;
3689
7796
                esac
3690
7797
              fi
3691
7798
              if test -n "$a_deplib" ; then
3692
 
                libname=`eval \\$echo \"$libname_spec\"`
 
7799
                libname=`eval "\\$ECHO \"$libname_spec\""`
 
7800
                if test -n "$file_magic_glob"; then
 
7801
                  libnameglob=`func_echo_all "$libname" | $SED -e $file_magic_glob`
 
7802
                else
 
7803
                  libnameglob=$libname
 
7804
                fi
 
7805
                test "$want_nocaseglob" = yes && nocaseglob=`shopt -p nocaseglob`
3693
7806
                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3694
 
                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
 
7807
                  if test "$want_nocaseglob" = yes; then
 
7808
                    shopt -s nocaseglob
 
7809
                    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
 
7810
                    $nocaseglob
 
7811
                  else
 
7812
                    potential_libs=`ls $i/$libnameglob[.-]* 2>/dev/null`
 
7813
                  fi
3695
7814
                  for potent_lib in $potential_libs; do
3696
7815
                      # Follow soft links.
3697
 
                      if ls -lLd "$potent_lib" 2>/dev/null \
3698
 
                         | grep " -> " >/dev/null; then
 
7816
                      if ls -lLd "$potent_lib" 2>/dev/null |
 
7817
                         $GREP " -> " >/dev/null; then
3699
7818
                        continue
3700
7819
                      fi
3701
7820
                      # The statement above tries to avoid entering an
3708
7827
                        potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3709
7828
                        case $potliblink in
3710
7829
                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3711
 
                        *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
 
7830
                        *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
3712
7831
                        esac
3713
7832
                      done
3714
 
                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3715
 
                         | ${SED} 10q \
3716
 
                         | $EGREP "$file_magic_regex" > /dev/null; then
3717
 
                        newdeplibs="$newdeplibs $a_deplib"
 
7833
                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null |
 
7834
                         $SED -e 10q |
 
7835
                         $EGREP "$file_magic_regex" > /dev/null; then
 
7836
                        func_append newdeplibs " $a_deplib"
3718
7837
                        a_deplib=""
3719
7838
                        break 2
3720
7839
                      fi
3723
7842
              fi
3724
7843
              if test -n "$a_deplib" ; then
3725
7844
                droppeddeps=yes
3726
 
                $echo
3727
 
                $echo "*** Warning: linker path does not have real file for library $a_deplib."
3728
 
                $echo "*** I have the capability to make that library automatically link in when"
3729
 
                $echo "*** you link to this library.  But I can only do this if you have a"
3730
 
                $echo "*** shared version of the library, which you do not appear to have"
3731
 
                $echo "*** because I did check the linker path looking for a file starting"
 
7845
                echo
 
7846
                $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
 
7847
                echo "*** I have the capability to make that library automatically link in when"
 
7848
                echo "*** you link to this library.  But I can only do this if you have a"
 
7849
                echo "*** shared version of the library, which you do not appear to have"
 
7850
                echo "*** because I did check the linker path looking for a file starting"
3732
7851
                if test -z "$potlib" ; then
3733
 
                  $echo "*** with $libname but no candidates were found. (...for file magic test)"
 
7852
                  $ECHO "*** with $libname but no candidates were found. (...for file magic test)"
3734
7853
                else
3735
 
                  $echo "*** with $libname and none of the candidates passed a file format test"
3736
 
                  $echo "*** using a file magic. Last file checked: $potlib"
 
7854
                  $ECHO "*** with $libname and none of the candidates passed a file format test"
 
7855
                  $ECHO "*** using a file magic. Last file checked: $potlib"
3737
7856
                fi
3738
7857
              fi
3739
 
            else
 
7858
              ;;
 
7859
            *)
3740
7860
              # Add a -L argument.
3741
 
              newdeplibs="$newdeplibs $a_deplib"
3742
 
            fi
 
7861
              func_append newdeplibs " $a_deplib"
 
7862
              ;;
 
7863
            esac
3743
7864
          done # Gone through all deplibs.
3744
7865
          ;;
3745
7866
        match_pattern*)
3746
 
          set dummy $deplibs_check_method
3747
 
          match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
 
7867
          set dummy $deplibs_check_method; shift
 
7868
          match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
3748
7869
          for a_deplib in $deplibs; do
3749
 
            name=`expr $a_deplib : '-l\(.*\)'`
3750
 
            # If $name is empty we are operating on a -L argument.
3751
 
            if test -n "$name" && test "$name" != "0"; then
 
7870
            case $a_deplib in
 
7871
            -l*)
 
7872
              func_stripname -l '' "$a_deplib"
 
7873
              name=$func_stripname_result
3752
7874
              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3753
7875
                case " $predeps $postdeps " in
3754
7876
                *" $a_deplib "*)
3755
 
                  newdeplibs="$newdeplibs $a_deplib"
 
7877
                  func_append newdeplibs " $a_deplib"
3756
7878
                  a_deplib=""
3757
7879
                  ;;
3758
7880
                esac
3759
7881
              fi
3760
7882
              if test -n "$a_deplib" ; then
3761
 
                libname=`eval \\$echo \"$libname_spec\"`
 
7883
                libname=`eval "\\$ECHO \"$libname_spec\""`
3762
7884
                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3763
7885
                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3764
7886
                  for potent_lib in $potential_libs; do
3765
7887
                    potlib="$potent_lib" # see symlink-check above in file_magic test
3766
 
                    if eval $echo \"$potent_lib\" 2>/dev/null \
3767
 
                        | ${SED} 10q \
3768
 
                        | $EGREP "$match_pattern_regex" > /dev/null; then
3769
 
                      newdeplibs="$newdeplibs $a_deplib"
 
7888
                    if eval "\$ECHO \"$potent_lib\"" 2>/dev/null | $SED 10q | \
 
7889
                       $EGREP "$match_pattern_regex" > /dev/null; then
 
7890
                      func_append newdeplibs " $a_deplib"
3770
7891
                      a_deplib=""
3771
7892
                      break 2
3772
7893
                    fi
3775
7896
              fi
3776
7897
              if test -n "$a_deplib" ; then
3777
7898
                droppeddeps=yes
3778
 
                $echo
3779
 
                $echo "*** Warning: linker path does not have real file for library $a_deplib."
3780
 
                $echo "*** I have the capability to make that library automatically link in when"
3781
 
                $echo "*** you link to this library.  But I can only do this if you have a"
3782
 
                $echo "*** shared version of the library, which you do not appear to have"
3783
 
                $echo "*** because I did check the linker path looking for a file starting"
 
7899
                echo
 
7900
                $ECHO "*** Warning: linker path does not have real file for library $a_deplib."
 
7901
                echo "*** I have the capability to make that library automatically link in when"
 
7902
                echo "*** you link to this library.  But I can only do this if you have a"
 
7903
                echo "*** shared version of the library, which you do not appear to have"
 
7904
                echo "*** because I did check the linker path looking for a file starting"
3784
7905
                if test -z "$potlib" ; then
3785
 
                  $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
 
7906
                  $ECHO "*** with $libname but no candidates were found. (...for regex pattern test)"
3786
7907
                else
3787
 
                  $echo "*** with $libname and none of the candidates passed a file format test"
3788
 
                  $echo "*** using a regex pattern. Last file checked: $potlib"
 
7908
                  $ECHO "*** with $libname and none of the candidates passed a file format test"
 
7909
                  $ECHO "*** using a regex pattern. Last file checked: $potlib"
3789
7910
                fi
3790
7911
              fi
3791
 
            else
 
7912
              ;;
 
7913
            *)
3792
7914
              # Add a -L argument.
3793
 
              newdeplibs="$newdeplibs $a_deplib"
3794
 
            fi
 
7915
              func_append newdeplibs " $a_deplib"
 
7916
              ;;
 
7917
            esac
3795
7918
          done # Gone through all deplibs.
3796
7919
          ;;
3797
7920
        none | unknown | *)
3798
7921
          newdeplibs=""
3799
 
          tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3800
 
            -e 's/ -[LR][^ ]*//g'`
 
7922
          tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
3801
7923
          if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3802
7924
            for i in $predeps $postdeps ; do
3803
7925
              # can't use Xsed below, because $i might contain '/'
3804
 
              tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
 
7926
              tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
3805
7927
            done
3806
7928
          fi
3807
 
          if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
3808
 
            | grep . >/dev/null; then
3809
 
            $echo
 
7929
          case $tmp_deplibs in
 
7930
          *[!\  \ ]*)
 
7931
            echo
3810
7932
            if test "X$deplibs_check_method" = "Xnone"; then
3811
 
              $echo "*** Warning: inter-library dependencies are not supported in this platform."
 
7933
              echo "*** Warning: inter-library dependencies are not supported in this platform."
3812
7934
            else
3813
 
              $echo "*** Warning: inter-library dependencies are not known to be supported."
 
7935
              echo "*** Warning: inter-library dependencies are not known to be supported."
3814
7936
            fi
3815
 
            $echo "*** All declared inter-library dependencies are being dropped."
 
7937
            echo "*** All declared inter-library dependencies are being dropped."
3816
7938
            droppeddeps=yes
3817
 
          fi
 
7939
            ;;
 
7940
          esac
3818
7941
          ;;
3819
7942
        esac
3820
7943
        versuffix=$versuffix_save
3825
7948
 
3826
7949
        case $host in
3827
7950
        *-*-rhapsody* | *-*-darwin1.[012])
3828
 
          # On Rhapsody replace the C library is the System framework
3829
 
          newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
 
7951
          # On Rhapsody replace the C library with the System framework
 
7952
          newdeplibs=`$ECHO " $newdeplibs" | $SED 's/ -lc / System.ltframework /'`
3830
7953
          ;;
3831
7954
        esac
3832
7955
 
3833
7956
        if test "$droppeddeps" = yes; then
3834
7957
          if test "$module" = yes; then
3835
 
            $echo
3836
 
            $echo "*** Warning: libtool could not satisfy all declared inter-library"
3837
 
            $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3838
 
            $echo "*** a static module, that should work as long as the dlopening"
3839
 
            $echo "*** application is linked with the -dlopen flag."
 
7958
            echo
 
7959
            echo "*** Warning: libtool could not satisfy all declared inter-library"
 
7960
            $ECHO "*** dependencies of module $libname.  Therefore, libtool will create"
 
7961
            echo "*** a static module, that should work as long as the dlopening"
 
7962
            echo "*** application is linked with the -dlopen flag."
3840
7963
            if test -z "$global_symbol_pipe"; then
3841
 
              $echo
3842
 
              $echo "*** However, this would only work if libtool was able to extract symbol"
3843
 
              $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3844
 
              $echo "*** not find such a program.  So, this module is probably useless."
3845
 
              $echo "*** \`nm' from GNU binutils and a full rebuild may help."
 
7964
              echo
 
7965
              echo "*** However, this would only work if libtool was able to extract symbol"
 
7966
              echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
 
7967
              echo "*** not find such a program.  So, this module is probably useless."
 
7968
              echo "*** \`nm' from GNU binutils and a full rebuild may help."
3846
7969
            fi
3847
7970
            if test "$build_old_libs" = no; then
3848
7971
              oldlibs="$output_objdir/$libname.$libext"
3852
7975
              build_libtool_libs=no
3853
7976
            fi
3854
7977
          else
3855
 
            $echo "*** The inter-library dependencies that have been dropped here will be"
3856
 
            $echo "*** automatically added whenever a program is linked with this library"
3857
 
            $echo "*** or is declared to -dlopen it."
 
7978
            echo "*** The inter-library dependencies that have been dropped here will be"
 
7979
            echo "*** automatically added whenever a program is linked with this library"
 
7980
            echo "*** or is declared to -dlopen it."
3858
7981
 
3859
7982
            if test "$allow_undefined" = no; then
3860
 
              $echo
3861
 
              $echo "*** Since this library must not contain undefined symbols,"
3862
 
              $echo "*** because either the platform does not support them or"
3863
 
              $echo "*** it was explicitly requested with -no-undefined,"
3864
 
              $echo "*** libtool will only create a static version of it."
 
7983
              echo
 
7984
              echo "*** Since this library must not contain undefined symbols,"
 
7985
              echo "*** because either the platform does not support them or"
 
7986
              echo "*** it was explicitly requested with -no-undefined,"
 
7987
              echo "*** libtool will only create a static version of it."
3865
7988
              if test "$build_old_libs" = no; then
3866
7989
                oldlibs="$output_objdir/$libname.$libext"
3867
7990
                build_libtool_libs=module
3875
7998
        # Done checking deplibs!
3876
7999
        deplibs=$newdeplibs
3877
8000
      fi
3878
 
 
 
8001
      # Time to change all our "foo.ltframework" stuff back to "-framework foo"
 
8002
      case $host in
 
8003
        *-*-darwin*)
 
8004
          newdeplibs=`$ECHO " $newdeplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 
8005
          new_inherited_linker_flags=`$ECHO " $new_inherited_linker_flags" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 
8006
          deplibs=`$ECHO " $deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 
8007
          ;;
 
8008
      esac
3879
8009
 
3880
8010
      # move library search paths that coincide with paths to not yet
3881
8011
      # installed libraries to the beginning of the library search list
3886
8016
        *)
3887
8017
          case " $deplibs " in
3888
8018
          *" -L$path/$objdir "*)
3889
 
            new_libs="$new_libs -L$path/$objdir" ;;
 
8019
            func_append new_libs " -L$path/$objdir" ;;
3890
8020
          esac
3891
8021
          ;;
3892
8022
        esac
3896
8026
        -L*)
3897
8027
          case " $new_libs " in
3898
8028
          *" $deplib "*) ;;
3899
 
          *) new_libs="$new_libs $deplib" ;;
 
8029
          *) func_append new_libs " $deplib" ;;
3900
8030
          esac
3901
8031
          ;;
3902
 
        *) new_libs="$new_libs $deplib" ;;
 
8032
        *) func_append new_libs " $deplib" ;;
3903
8033
        esac
3904
8034
      done
3905
8035
      deplibs="$new_libs"
3906
8036
 
3907
 
 
3908
8037
      # All the library-specific variables (install_libdir is set above).
3909
8038
      library_names=
3910
8039
      old_library=
3912
8041
 
3913
8042
      # Test again, we may have decided not to build it any more
3914
8043
      if test "$build_libtool_libs" = yes; then
 
8044
        # Remove ${wl} instances when linking with ld.
 
8045
        # FIXME: should test the right _cmds variable.
 
8046
        case $archive_cmds in
 
8047
          *\$LD\ *) wl= ;;
 
8048
        esac
3915
8049
        if test "$hardcode_into_libs" = yes; then
3916
8050
          # Hardcode the library paths
3917
8051
          hardcode_libdirs=
3918
8052
          dep_rpath=
3919
8053
          rpath="$finalize_rpath"
3920
 
          test "$mode" != relink && rpath="$compile_rpath$rpath"
 
8054
          test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
3921
8055
          for libdir in $rpath; do
3922
8056
            if test -n "$hardcode_libdir_flag_spec"; then
3923
8057
              if test -n "$hardcode_libdir_separator"; then
 
8058
                func_replace_sysroot "$libdir"
 
8059
                libdir=$func_replace_sysroot_result
3924
8060
                if test -z "$hardcode_libdirs"; then
3925
8061
                  hardcode_libdirs="$libdir"
3926
8062
                else
3929
8065
                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3930
8066
                    ;;
3931
8067
                  *)
3932
 
                    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 
8068
                    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
3933
8069
                    ;;
3934
8070
                  esac
3935
8071
                fi
3936
8072
              else
3937
8073
                eval flag=\"$hardcode_libdir_flag_spec\"
3938
 
                dep_rpath="$dep_rpath $flag"
 
8074
                func_append dep_rpath " $flag"
3939
8075
              fi
3940
8076
            elif test -n "$runpath_var"; then
3941
8077
              case "$perm_rpath " in
3942
8078
              *" $libdir "*) ;;
3943
 
              *) perm_rpath="$perm_rpath $libdir" ;;
 
8079
              *) func_append perm_rpath " $libdir" ;;
3944
8080
              esac
3945
8081
            fi
3946
8082
          done
3948
8084
          if test -n "$hardcode_libdir_separator" &&
3949
8085
             test -n "$hardcode_libdirs"; then
3950
8086
            libdir="$hardcode_libdirs"
3951
 
            if test -n "$hardcode_libdir_flag_spec_ld"; then
3952
 
              case $archive_cmds in
3953
 
              *\$LD*) eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" ;;
3954
 
              *)      eval dep_rpath=\"$hardcode_libdir_flag_spec\" ;;
3955
 
              esac
3956
 
            else
3957
 
              eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3958
 
            fi
 
8087
            eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
3959
8088
          fi
3960
8089
          if test -n "$runpath_var" && test -n "$perm_rpath"; then
3961
8090
            # We should set the runpath_var.
3962
8091
            rpath=
3963
8092
            for dir in $perm_rpath; do
3964
 
              rpath="$rpath$dir:"
 
8093
              func_append rpath "$dir:"
3965
8094
            done
3966
8095
            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3967
8096
          fi
3969
8098
        fi
3970
8099
 
3971
8100
        shlibpath="$finalize_shlibpath"
3972
 
        test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
 
8101
        test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3973
8102
        if test -n "$shlibpath"; then
3974
8103
          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3975
8104
        fi
3978
8107
        eval shared_ext=\"$shrext_cmds\"
3979
8108
        eval library_names=\"$library_names_spec\"
3980
8109
        set dummy $library_names
3981
 
        realname="$2"
3982
 
        shift; shift
 
8110
        shift
 
8111
        realname="$1"
 
8112
        shift
3983
8113
 
3984
8114
        if test -n "$soname_spec"; then
3985
8115
          eval soname=\"$soname_spec\"
3994
8124
        linknames=
3995
8125
        for link
3996
8126
        do
3997
 
          linknames="$linknames $link"
 
8127
          func_append linknames " $link"
3998
8128
        done
3999
8129
 
4000
8130
        # Use standard objects if they are pic
4001
 
        test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
 
8131
        test -z "$pic_flag" && libobjs=`$ECHO "$libobjs" | $SP2NL | $SED "$lo2o" | $NL2SP`
 
8132
        test "X$libobjs" = "X " && libobjs=
 
8133
 
 
8134
        delfiles=
 
8135
        if test -n "$export_symbols" && test -n "$include_expsyms"; then
 
8136
          $opt_dry_run || cp "$export_symbols" "$output_objdir/$libname.uexp"
 
8137
          export_symbols="$output_objdir/$libname.uexp"
 
8138
          func_append delfiles " $export_symbols"
 
8139
        fi
 
8140
 
 
8141
        orig_export_symbols=
 
8142
        case $host_os in
 
8143
        cygwin* | mingw* | cegcc*)
 
8144
          if test -n "$export_symbols" && test -z "$export_symbols_regex"; then
 
8145
            # exporting using user supplied symfile
 
8146
            if test "x`$SED 1q $export_symbols`" != xEXPORTS; then
 
8147
              # and it's NOT already a .def file. Must figure out
 
8148
              # which of the given symbols are data symbols and tag
 
8149
              # them as such. So, trigger use of export_symbols_cmds.
 
8150
              # export_symbols gets reassigned inside the "prepare
 
8151
              # the list of exported symbols" if statement, so the
 
8152
              # include_expsyms logic still works.
 
8153
              orig_export_symbols="$export_symbols"
 
8154
              export_symbols=
 
8155
              always_export_symbols=yes
 
8156
            fi
 
8157
          fi
 
8158
          ;;
 
8159
        esac
4002
8160
 
4003
8161
        # Prepare the list of exported symbols
4004
8162
        if test -z "$export_symbols"; then
4005
8163
          if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
4006
 
            $show "generating symbol list for \`$libname.la'"
 
8164
            func_verbose "generating symbol list for \`$libname.la'"
4007
8165
            export_symbols="$output_objdir/$libname.exp"
4008
 
            $run $rm $export_symbols
 
8166
            $opt_dry_run || $RM $export_symbols
4009
8167
            cmds=$export_symbols_cmds
4010
8168
            save_ifs="$IFS"; IFS='~'
4011
 
            for cmd in $cmds; do
 
8169
            for cmd1 in $cmds; do
4012
8170
              IFS="$save_ifs"
4013
 
              eval cmd=\"$cmd\"
4014
 
              if len=`expr "X$cmd" : ".*"` &&
4015
 
               test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
4016
 
                $show "$cmd"
4017
 
                $run eval "$cmd" || exit $?
4018
 
                skipped_export=false
 
8171
              # Take the normal branch if the nm_file_list_spec branch
 
8172
              # doesn't work or if tool conversion is not needed.
 
8173
              case $nm_file_list_spec~$to_tool_file_cmd in
 
8174
                *~func_convert_file_noop | *~func_convert_file_msys_to_w32 | ~*)
 
8175
                  try_normal_branch=yes
 
8176
                  eval cmd=\"$cmd1\"
 
8177
                  func_len " $cmd"
 
8178
                  len=$func_len_result
 
8179
                  ;;
 
8180
                *)
 
8181
                  try_normal_branch=no
 
8182
                  ;;
 
8183
              esac
 
8184
              if test "$try_normal_branch" = yes \
 
8185
                 && { test "$len" -lt "$max_cmd_len" \
 
8186
                      || test "$max_cmd_len" -le -1; }
 
8187
              then
 
8188
                func_show_eval "$cmd" 'exit $?'
 
8189
                skipped_export=false
 
8190
              elif test -n "$nm_file_list_spec"; then
 
8191
                func_basename "$output"
 
8192
                output_la=$func_basename_result
 
8193
                save_libobjs=$libobjs
 
8194
                save_output=$output
 
8195
                output=${output_objdir}/${output_la}.nm
 
8196
                func_to_tool_file "$output"
 
8197
                libobjs=$nm_file_list_spec$func_to_tool_file_result
 
8198
                func_append delfiles " $output"
 
8199
                func_verbose "creating $NM input file list: $output"
 
8200
                for obj in $save_libobjs; do
 
8201
                  func_to_tool_file "$obj"
 
8202
                  $ECHO "$func_to_tool_file_result"
 
8203
                done > "$output"
 
8204
                eval cmd=\"$cmd1\"
 
8205
                func_show_eval "$cmd" 'exit $?'
 
8206
                output=$save_output
 
8207
                libobjs=$save_libobjs
 
8208
                skipped_export=false
4019
8209
              else
4020
 
                # The command line is too long to execute in one step.
4021
 
                $show "using reloadable object file for export list..."
4022
 
                skipped_export=:
 
8210
                # The command line is too long to execute in one step.
 
8211
                func_verbose "using reloadable object file for export list..."
 
8212
                skipped_export=:
4023
8213
                # Break out early, otherwise skipped_export may be
4024
8214
                # set to false by a later but shorter cmd.
4025
8215
                break
4026
8216
              fi
4027
8217
            done
4028
8218
            IFS="$save_ifs"
4029
 
            if test -n "$export_symbols_regex"; then
4030
 
              $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
4031
 
              $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
4032
 
              $show "$mv \"${export_symbols}T\" \"$export_symbols\""
4033
 
              $run eval '$mv "${export_symbols}T" "$export_symbols"'
 
8219
            if test -n "$export_symbols_regex" && test "X$skipped_export" != "X:"; then
 
8220
              func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
 
8221
              func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
4034
8222
            fi
4035
8223
          fi
4036
8224
        fi
4037
8225
 
4038
8226
        if test -n "$export_symbols" && test -n "$include_expsyms"; then
4039
 
          $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
 
8227
          tmp_export_symbols="$export_symbols"
 
8228
          test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
 
8229
          $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
 
8230
        fi
 
8231
 
 
8232
        if test "X$skipped_export" != "X:" && test -n "$orig_export_symbols"; then
 
8233
          # The given exports_symbols file has to be filtered, so filter it.
 
8234
          func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
 
8235
          # FIXME: $output_objdir/$libname.filter potentially contains lots of
 
8236
          # 's' commands which not all seds can handle. GNU sed should be fine
 
8237
          # though. Also, the filter scales superlinearly with the number of
 
8238
          # global variables. join(1) would be nice here, but unfortunately
 
8239
          # isn't a blessed tool.
 
8240
          $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
 
8241
          func_append delfiles " $export_symbols $output_objdir/$libname.filter"
 
8242
          export_symbols=$output_objdir/$libname.def
 
8243
          $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
4040
8244
        fi
4041
8245
 
4042
8246
        tmp_deplibs=
4043
8247
        for test_deplib in $deplibs; do
4044
 
                case " $convenience " in
4045
 
                *" $test_deplib "*) ;;
4046
 
                *)
4047
 
                        tmp_deplibs="$tmp_deplibs $test_deplib"
4048
 
                        ;;
4049
 
                esac
 
8248
          case " $convenience " in
 
8249
          *" $test_deplib "*) ;;
 
8250
          *)
 
8251
            func_append tmp_deplibs " $test_deplib"
 
8252
            ;;
 
8253
          esac
4050
8254
        done
4051
8255
        deplibs="$tmp_deplibs"
4052
8256
 
4053
8257
        if test -n "$convenience"; then
 
8258
          if test -n "$whole_archive_flag_spec" &&
 
8259
            test "$compiler_needs_object" = yes &&
 
8260
            test -z "$libobjs"; then
 
8261
            # extract the archives, so we have objects to list.
 
8262
            # TODO: could optimize this to just extract one archive.
 
8263
            whole_archive_flag_spec=
 
8264
          fi
4054
8265
          if test -n "$whole_archive_flag_spec"; then
4055
8266
            save_libobjs=$libobjs
4056
8267
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 
8268
            test "X$libobjs" = "X " && libobjs=
4057
8269
          else
4058
8270
            gentop="$output_objdir/${outputname}x"
4059
 
            generated="$generated $gentop"
 
8271
            func_append generated " $gentop"
4060
8272
 
4061
8273
            func_extract_archives $gentop $convenience
4062
 
            libobjs="$libobjs $func_extract_archives_result"
 
8274
            func_append libobjs " $func_extract_archives_result"
 
8275
            test "X$libobjs" = "X " && libobjs=
4063
8276
          fi
4064
8277
        fi
4065
 
        
 
8278
 
4066
8279
        if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
4067
8280
          eval flag=\"$thread_safe_flag_spec\"
4068
 
          linker_flags="$linker_flags $flag"
 
8281
          func_append linker_flags " $flag"
4069
8282
        fi
4070
8283
 
4071
8284
        # Make a backup of the uninstalled library when relinking
4072
 
        if test "$mode" = relink; then
4073
 
          $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
 
8285
        if test "$opt_mode" = relink; then
 
8286
          $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}U && $MV $realname ${realname}U)' || exit $?
4074
8287
        fi
4075
8288
 
4076
8289
        # Do each of the archive commands.
4083
8296
            cmds=$module_cmds
4084
8297
          fi
4085
8298
        else
4086
 
        if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4087
 
          eval test_cmds=\"$archive_expsym_cmds\"
4088
 
          cmds=$archive_expsym_cmds
4089
 
        else
4090
 
          eval test_cmds=\"$archive_cmds\"
4091
 
          cmds=$archive_cmds
 
8299
          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
 
8300
            eval test_cmds=\"$archive_expsym_cmds\"
 
8301
            cmds=$archive_expsym_cmds
 
8302
          else
 
8303
            eval test_cmds=\"$archive_cmds\"
 
8304
            cmds=$archive_cmds
4092
8305
          fi
4093
8306
        fi
4094
8307
 
4095
8308
        if test "X$skipped_export" != "X:" &&
4096
 
           len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4097
 
           test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 
8309
           func_len " $test_cmds" &&
 
8310
           len=$func_len_result &&
 
8311
           test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
4098
8312
          :
4099
8313
        else
4100
 
          # The command line is too long to link in one step, link piecewise.
4101
 
          $echo "creating reloadable object files..."
 
8314
          # The command line is too long to link in one step, link piecewise
 
8315
          # or, if using GNU ld and skipped_export is not :, use a linker
 
8316
          # script.
4102
8317
 
4103
8318
          # Save the value of $output and $libobjs because we want to
4104
8319
          # use them later.  If we have whole_archive_flag_spec, we
4112
8327
            save_libobjs=$libobjs
4113
8328
          fi
4114
8329
          save_output=$output
4115
 
          output_la=`$echo "X$output" | $Xsed -e "$basename"`
 
8330
          func_basename "$output"
 
8331
          output_la=$func_basename_result
4116
8332
 
4117
8333
          # Clear the reloadable object creation command queue and
4118
8334
          # initialize k to one.
4119
8335
          test_cmds=
4120
8336
          concat_cmds=
4121
8337
          objlist=
4122
 
          delfiles=
4123
8338
          last_robj=
4124
8339
          k=1
4125
 
          output=$output_objdir/$output_la-${k}.$objext
4126
 
          # Loop over the list of objects to be linked.
4127
 
          for obj in $save_libobjs
4128
 
          do
4129
 
            eval test_cmds=\"$reload_cmds $objlist $last_robj\"
4130
 
            if test "X$objlist" = X ||
4131
 
               { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4132
 
                 test "$len" -le "$max_cmd_len"; }; then
4133
 
              objlist="$objlist $obj"
4134
 
            else
4135
 
              # The command $test_cmds is almost too long, add a
4136
 
              # command to the queue.
4137
 
              if test "$k" -eq 1 ; then
4138
 
                # The first file doesn't have a previous command to add.
4139
 
                eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
4140
 
              else
4141
 
                # All subsequent reloadable object files will link in
4142
 
                # the last one created.
4143
 
                eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
4144
 
              fi
4145
 
              last_robj=$output_objdir/$output_la-${k}.$objext
4146
 
              k=`expr $k + 1`
 
8340
 
 
8341
          if test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "$with_gnu_ld" = yes; then
 
8342
            output=${output_objdir}/${output_la}.lnkscript
 
8343
            func_verbose "creating GNU ld script: $output"
 
8344
            echo 'INPUT (' > $output
 
8345
            for obj in $save_libobjs
 
8346
            do
 
8347
              func_to_tool_file "$obj"
 
8348
              $ECHO "$func_to_tool_file_result" >> $output
 
8349
            done
 
8350
            echo ')' >> $output
 
8351
            func_append delfiles " $output"
 
8352
            func_to_tool_file "$output"
 
8353
            output=$func_to_tool_file_result
 
8354
          elif test -n "$save_libobjs" && test "X$skipped_export" != "X:" && test "X$file_list_spec" != X; then
 
8355
            output=${output_objdir}/${output_la}.lnk
 
8356
            func_verbose "creating linker input file list: $output"
 
8357
            : > $output
 
8358
            set x $save_libobjs
 
8359
            shift
 
8360
            firstobj=
 
8361
            if test "$compiler_needs_object" = yes; then
 
8362
              firstobj="$1 "
 
8363
              shift
 
8364
            fi
 
8365
            for obj
 
8366
            do
 
8367
              func_to_tool_file "$obj"
 
8368
              $ECHO "$func_to_tool_file_result" >> $output
 
8369
            done
 
8370
            func_append delfiles " $output"
 
8371
            func_to_tool_file "$output"
 
8372
            output=$firstobj\"$file_list_spec$func_to_tool_file_result\"
 
8373
          else
 
8374
            if test -n "$save_libobjs"; then
 
8375
              func_verbose "creating reloadable object files..."
4147
8376
              output=$output_objdir/$output_la-${k}.$objext
4148
 
              objlist=$obj
4149
 
              len=1
4150
 
            fi
4151
 
          done
4152
 
          # Handle the remaining objects by creating one last
4153
 
          # reloadable object file.  All subsequent reloadable object
4154
 
          # files will link in the last one created.
4155
 
          test -z "$concat_cmds" || concat_cmds=$concat_cmds~
4156
 
          eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
4157
 
 
4158
 
          if ${skipped_export-false}; then
4159
 
            $show "generating symbol list for \`$libname.la'"
4160
 
            export_symbols="$output_objdir/$libname.exp"
4161
 
            $run $rm $export_symbols
4162
 
            libobjs=$output
4163
 
            # Append the command to create the export file.
4164
 
            eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
4165
 
          fi
4166
 
 
4167
 
          # Set up a command to remove the reloadable object files
4168
 
          # after they are used.
4169
 
          i=0
4170
 
          while test "$i" -lt "$k"
4171
 
          do
4172
 
            i=`expr $i + 1`
4173
 
            delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
4174
 
          done
4175
 
 
4176
 
          $echo "creating a temporary reloadable object file: $output"
4177
 
 
4178
 
          # Loop through the commands generated above and execute them.
4179
 
          save_ifs="$IFS"; IFS='~'
4180
 
          for cmd in $concat_cmds; do
 
8377
              eval test_cmds=\"$reload_cmds\"
 
8378
              func_len " $test_cmds"
 
8379
              len0=$func_len_result
 
8380
              len=$len0
 
8381
 
 
8382
              # Loop over the list of objects to be linked.
 
8383
              for obj in $save_libobjs
 
8384
              do
 
8385
                func_len " $obj"
 
8386
                func_arith $len + $func_len_result
 
8387
                len=$func_arith_result
 
8388
                if test "X$objlist" = X ||
 
8389
                   test "$len" -lt "$max_cmd_len"; then
 
8390
                  func_append objlist " $obj"
 
8391
                else
 
8392
                  # The command $test_cmds is almost too long, add a
 
8393
                  # command to the queue.
 
8394
                  if test "$k" -eq 1 ; then
 
8395
                    # The first file doesn't have a previous command to add.
 
8396
                    reload_objs=$objlist
 
8397
                    eval concat_cmds=\"$reload_cmds\"
 
8398
                  else
 
8399
                    # All subsequent reloadable object files will link in
 
8400
                    # the last one created.
 
8401
                    reload_objs="$objlist $last_robj"
 
8402
                    eval concat_cmds=\"\$concat_cmds~$reload_cmds~\$RM $last_robj\"
 
8403
                  fi
 
8404
                  last_robj=$output_objdir/$output_la-${k}.$objext
 
8405
                  func_arith $k + 1
 
8406
                  k=$func_arith_result
 
8407
                  output=$output_objdir/$output_la-${k}.$objext
 
8408
                  objlist=" $obj"
 
8409
                  func_len " $last_robj"
 
8410
                  func_arith $len0 + $func_len_result
 
8411
                  len=$func_arith_result
 
8412
                fi
 
8413
              done
 
8414
              # Handle the remaining objects by creating one last
 
8415
              # reloadable object file.  All subsequent reloadable object
 
8416
              # files will link in the last one created.
 
8417
              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
 
8418
              reload_objs="$objlist $last_robj"
 
8419
              eval concat_cmds=\"\${concat_cmds}$reload_cmds\"
 
8420
              if test -n "$last_robj"; then
 
8421
                eval concat_cmds=\"\${concat_cmds}~\$RM $last_robj\"
 
8422
              fi
 
8423
              func_append delfiles " $output"
 
8424
 
 
8425
            else
 
8426
              output=
 
8427
            fi
 
8428
 
 
8429
            if ${skipped_export-false}; then
 
8430
              func_verbose "generating symbol list for \`$libname.la'"
 
8431
              export_symbols="$output_objdir/$libname.exp"
 
8432
              $opt_dry_run || $RM $export_symbols
 
8433
              libobjs=$output
 
8434
              # Append the command to create the export file.
 
8435
              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
 
8436
              eval concat_cmds=\"\$concat_cmds$export_symbols_cmds\"
 
8437
              if test -n "$last_robj"; then
 
8438
                eval concat_cmds=\"\$concat_cmds~\$RM $last_robj\"
 
8439
              fi
 
8440
            fi
 
8441
 
 
8442
            test -n "$save_libobjs" &&
 
8443
              func_verbose "creating a temporary reloadable object file: $output"
 
8444
 
 
8445
            # Loop through the commands generated above and execute them.
 
8446
            save_ifs="$IFS"; IFS='~'
 
8447
            for cmd in $concat_cmds; do
 
8448
              IFS="$save_ifs"
 
8449
              $opt_silent || {
 
8450
                  func_quote_for_expand "$cmd"
 
8451
                  eval "func_echo $func_quote_for_expand_result"
 
8452
              }
 
8453
              $opt_dry_run || eval "$cmd" || {
 
8454
                lt_exit=$?
 
8455
 
 
8456
                # Restore the uninstalled library and exit
 
8457
                if test "$opt_mode" = relink; then
 
8458
                  ( cd "$output_objdir" && \
 
8459
                    $RM "${realname}T" && \
 
8460
                    $MV "${realname}U" "$realname" )
 
8461
                fi
 
8462
 
 
8463
                exit $lt_exit
 
8464
              }
 
8465
            done
4181
8466
            IFS="$save_ifs"
4182
 
            $show "$cmd"
4183
 
            $run eval "$cmd" || exit $?
4184
 
          done
4185
 
          IFS="$save_ifs"
 
8467
 
 
8468
            if test -n "$export_symbols_regex" && ${skipped_export-false}; then
 
8469
              func_show_eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
 
8470
              func_show_eval '$MV "${export_symbols}T" "$export_symbols"'
 
8471
            fi
 
8472
          fi
 
8473
 
 
8474
          if ${skipped_export-false}; then
 
8475
            if test -n "$export_symbols" && test -n "$include_expsyms"; then
 
8476
              tmp_export_symbols="$export_symbols"
 
8477
              test -n "$orig_export_symbols" && tmp_export_symbols="$orig_export_symbols"
 
8478
              $opt_dry_run || eval '$ECHO "$include_expsyms" | $SP2NL >> "$tmp_export_symbols"'
 
8479
            fi
 
8480
 
 
8481
            if test -n "$orig_export_symbols"; then
 
8482
              # The given exports_symbols file has to be filtered, so filter it.
 
8483
              func_verbose "filter symbol list for \`$libname.la' to tag DATA exports"
 
8484
              # FIXME: $output_objdir/$libname.filter potentially contains lots of
 
8485
              # 's' commands which not all seds can handle. GNU sed should be fine
 
8486
              # though. Also, the filter scales superlinearly with the number of
 
8487
              # global variables. join(1) would be nice here, but unfortunately
 
8488
              # isn't a blessed tool.
 
8489
              $opt_dry_run || $SED -e '/[ ,]DATA/!d;s,\(.*\)\([ \,].*\),s|^\1$|\1\2|,' < $export_symbols > $output_objdir/$libname.filter
 
8490
              func_append delfiles " $export_symbols $output_objdir/$libname.filter"
 
8491
              export_symbols=$output_objdir/$libname.def
 
8492
              $opt_dry_run || $SED -f $output_objdir/$libname.filter < $orig_export_symbols > $export_symbols
 
8493
            fi
 
8494
          fi
4186
8495
 
4187
8496
          libobjs=$output
4188
8497
          # Restore the value of output.
4190
8499
 
4191
8500
          if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
4192
8501
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 
8502
            test "X$libobjs" = "X " && libobjs=
4193
8503
          fi
4194
8504
          # Expand the library linking commands again to reset the
4195
8505
          # value of $libobjs for piecewise linking.
4202
8512
              cmds=$module_cmds
4203
8513
            fi
4204
8514
          else
4205
 
          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4206
 
            cmds=$archive_expsym_cmds
4207
 
          else
4208
 
            cmds=$archive_cmds
 
8515
            if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
 
8516
              cmds=$archive_expsym_cmds
 
8517
            else
 
8518
              cmds=$archive_cmds
4209
8519
            fi
4210
8520
          fi
4211
 
 
4212
 
          # Append the command to remove the reloadable object files
4213
 
          # to the just-reset $cmds.
4214
 
          eval cmds=\"\$cmds~\$rm $delfiles\"
4215
 
        fi
 
8521
        fi
 
8522
 
 
8523
        if test -n "$delfiles"; then
 
8524
          # Append the command to remove temporary files to $cmds.
 
8525
          eval cmds=\"\$cmds~\$RM $delfiles\"
 
8526
        fi
 
8527
 
 
8528
        # Add any objects from preloaded convenience libraries
 
8529
        if test -n "$dlprefiles"; then
 
8530
          gentop="$output_objdir/${outputname}x"
 
8531
          func_append generated " $gentop"
 
8532
 
 
8533
          func_extract_archives $gentop $dlprefiles
 
8534
          func_append libobjs " $func_extract_archives_result"
 
8535
          test "X$libobjs" = "X " && libobjs=
 
8536
        fi
 
8537
 
4216
8538
        save_ifs="$IFS"; IFS='~'
4217
8539
        for cmd in $cmds; do
4218
8540
          IFS="$save_ifs"
4219
8541
          eval cmd=\"$cmd\"
4220
 
          $show "$cmd"
4221
 
          $run eval "$cmd" || {
 
8542
          $opt_silent || {
 
8543
            func_quote_for_expand "$cmd"
 
8544
            eval "func_echo $func_quote_for_expand_result"
 
8545
          }
 
8546
          $opt_dry_run || eval "$cmd" || {
4222
8547
            lt_exit=$?
4223
8548
 
4224
8549
            # Restore the uninstalled library and exit
4225
 
            if test "$mode" = relink; then
4226
 
              $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
 
8550
            if test "$opt_mode" = relink; then
 
8551
              ( cd "$output_objdir" && \
 
8552
                $RM "${realname}T" && \
 
8553
                $MV "${realname}U" "$realname" )
4227
8554
            fi
4228
8555
 
4229
8556
            exit $lt_exit
4232
8559
        IFS="$save_ifs"
4233
8560
 
4234
8561
        # Restore the uninstalled library and exit
4235
 
        if test "$mode" = relink; then
4236
 
          $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
 
8562
        if test "$opt_mode" = relink; then
 
8563
          $opt_dry_run || eval '(cd $output_objdir && $RM ${realname}T && $MV $realname ${realname}T && $MV ${realname}U $realname)' || exit $?
4237
8564
 
4238
8565
          if test -n "$convenience"; then
4239
8566
            if test -z "$whole_archive_flag_spec"; then
4240
 
              $show "${rm}r $gentop"
4241
 
              $run ${rm}r "$gentop"
 
8567
              func_show_eval '${RM}r "$gentop"'
4242
8568
            fi
4243
8569
          fi
4244
8570
 
4248
8574
        # Create links to the real library.
4249
8575
        for linkname in $linknames; do
4250
8576
          if test "$realname" != "$linkname"; then
4251
 
            $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
4252
 
            $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
 
8577
            func_show_eval '(cd "$output_objdir" && $RM "$linkname" && $LN_S "$realname" "$linkname")' 'exit $?'
4253
8578
          fi
4254
8579
        done
4255
8580
 
4262
8587
      ;;
4263
8588
 
4264
8589
    obj)
 
8590
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
 
8591
        func_warning "\`-dlopen' is ignored for objects"
 
8592
      fi
 
8593
 
4265
8594
      case " $deplibs" in
4266
8595
      *\ -l* | *\ -L*)
4267
 
        $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2 ;;
 
8596
        func_warning "\`-l' and \`-L' are ignored for objects" ;;
4268
8597
      esac
4269
8598
 
4270
 
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4271
 
        $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
4272
 
      fi
4273
 
 
4274
 
      if test -n "$rpath"; then
4275
 
        $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
4276
 
      fi
4277
 
 
4278
 
      if test -n "$xrpath"; then
4279
 
        $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
4280
 
      fi
4281
 
 
4282
 
      if test -n "$vinfo"; then
4283
 
        $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
4284
 
      fi
4285
 
 
4286
 
      if test -n "$release"; then
4287
 
        $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
4288
 
      fi
 
8599
      test -n "$rpath" && \
 
8600
        func_warning "\`-rpath' is ignored for objects"
 
8601
 
 
8602
      test -n "$xrpath" && \
 
8603
        func_warning "\`-R' is ignored for objects"
 
8604
 
 
8605
      test -n "$vinfo" && \
 
8606
        func_warning "\`-version-info' is ignored for objects"
 
8607
 
 
8608
      test -n "$release" && \
 
8609
        func_warning "\`-release' is ignored for objects"
4289
8610
 
4290
8611
      case $output in
4291
8612
      *.lo)
4292
 
        if test -n "$objs$old_deplibs"; then
4293
 
          $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
4294
 
          exit $EXIT_FAILURE
4295
 
        fi
4296
 
        libobj="$output"
4297
 
        obj=`$echo "X$output" | $Xsed -e "$lo2o"`
 
8613
        test -n "$objs$old_deplibs" && \
 
8614
          func_fatal_error "cannot build library object \`$output' from non-libtool objects"
 
8615
 
 
8616
        libobj=$output
 
8617
        func_lo2o "$libobj"
 
8618
        obj=$func_lo2o_result
4298
8619
        ;;
4299
8620
      *)
4300
8621
        libobj=
4303
8624
      esac
4304
8625
 
4305
8626
      # Delete the old objects.
4306
 
      $run $rm $obj $libobj
 
8627
      $opt_dry_run || $RM $obj $libobj
4307
8628
 
4308
8629
      # Objects from convenience libraries.  This assumes
4309
8630
      # single-version convenience libraries.  Whenever we create
4319
8640
      if test -n "$convenience"; then
4320
8641
        if test -n "$whole_archive_flag_spec"; then
4321
8642
          eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
4322
 
          reload_conv_objs=$reload_objs\ `$echo "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
 
8643
          reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
4323
8644
        else
4324
8645
          gentop="$output_objdir/${obj}x"
4325
 
          generated="$generated $gentop"
 
8646
          func_append generated " $gentop"
4326
8647
 
4327
8648
          func_extract_archives $gentop $convenience
4328
8649
          reload_conv_objs="$reload_objs $func_extract_archives_result"
4329
8650
        fi
4330
8651
      fi
4331
8652
 
 
8653
      # If we're not building shared, we need to use non_pic_objs
 
8654
      test "$build_libtool_libs" != yes && libobjs="$non_pic_objects"
 
8655
 
4332
8656
      # Create the old-style object.
4333
 
      reload_objs="$objs$old_deplibs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}$'/d' -e '/\.lib$/d' -e "$lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
 
8657
      reload_objs="$objs$old_deplibs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; /\.lib$/d; $lo2o" | $NL2SP`" $reload_conv_objs" ### testsuite: skip nested quoting test
4334
8658
 
4335
8659
      output="$obj"
4336
 
      cmds=$reload_cmds
4337
 
      save_ifs="$IFS"; IFS='~'
4338
 
      for cmd in $cmds; do
4339
 
        IFS="$save_ifs"
4340
 
        eval cmd=\"$cmd\"
4341
 
        $show "$cmd"
4342
 
        $run eval "$cmd" || exit $?
4343
 
      done
4344
 
      IFS="$save_ifs"
 
8660
      func_execute_cmds "$reload_cmds" 'exit $?'
4345
8661
 
4346
8662
      # Exit if we aren't doing a library object file.
4347
8663
      if test -z "$libobj"; then
4348
8664
        if test -n "$gentop"; then
4349
 
          $show "${rm}r $gentop"
4350
 
          $run ${rm}r $gentop
 
8665
          func_show_eval '${RM}r "$gentop"'
4351
8666
        fi
4352
8667
 
4353
8668
        exit $EXIT_SUCCESS
4355
8670
 
4356
8671
      if test "$build_libtool_libs" != yes; then
4357
8672
        if test -n "$gentop"; then
4358
 
          $show "${rm}r $gentop"
4359
 
          $run ${rm}r $gentop
 
8673
          func_show_eval '${RM}r "$gentop"'
4360
8674
        fi
4361
8675
 
4362
8676
        # Create an invalid libtool object if no PIC, so that we don't
4363
8677
        # accidentally link it into a program.
4364
8678
        # $show "echo timestamp > $libobj"
4365
 
        # $run eval "echo timestamp > $libobj" || exit $?
 
8679
        # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
4366
8680
        exit $EXIT_SUCCESS
4367
8681
      fi
4368
8682
 
4370
8684
        # Only do commands if we really have different PIC objects.
4371
8685
        reload_objs="$libobjs $reload_conv_objs"
4372
8686
        output="$libobj"
4373
 
        cmds=$reload_cmds
4374
 
        save_ifs="$IFS"; IFS='~'
4375
 
        for cmd in $cmds; do
4376
 
          IFS="$save_ifs"
4377
 
          eval cmd=\"$cmd\"
4378
 
          $show "$cmd"
4379
 
          $run eval "$cmd" || exit $?
4380
 
        done
4381
 
        IFS="$save_ifs"
 
8687
        func_execute_cmds "$reload_cmds" 'exit $?'
4382
8688
      fi
4383
8689
 
4384
8690
      if test -n "$gentop"; then
4385
 
        $show "${rm}r $gentop"
4386
 
        $run ${rm}r $gentop
 
8691
        func_show_eval '${RM}r "$gentop"'
4387
8692
      fi
4388
8693
 
4389
8694
      exit $EXIT_SUCCESS
4391
8696
 
4392
8697
    prog)
4393
8698
      case $host in
4394
 
        *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
 
8699
        *cygwin*) func_stripname '' '.exe' "$output"
 
8700
                  output=$func_stripname_result.exe;;
4395
8701
      esac
4396
 
      if test -n "$vinfo"; then
4397
 
        $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4398
 
      fi
4399
 
 
4400
 
      if test -n "$release"; then
4401
 
        $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4402
 
      fi
4403
 
 
4404
 
      if test "$preload" = yes; then
4405
 
        if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4406
 
           test "$dlopen_self_static" = unknown; then
4407
 
          $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4408
 
        fi
4409
 
      fi
 
8702
      test -n "$vinfo" && \
 
8703
        func_warning "\`-version-info' is ignored for programs"
 
8704
 
 
8705
      test -n "$release" && \
 
8706
        func_warning "\`-release' is ignored for programs"
 
8707
 
 
8708
      test "$preload" = yes \
 
8709
        && test "$dlopen_support" = unknown \
 
8710
        && test "$dlopen_self" = unknown \
 
8711
        && test "$dlopen_self_static" = unknown && \
 
8712
          func_warning "\`LT_INIT([dlopen])' not used. Assuming no dlopen support."
4410
8713
 
4411
8714
      case $host in
4412
8715
      *-*-rhapsody* | *-*-darwin1.[012])
4413
8716
        # On Rhapsody replace the C library is the System framework
4414
 
        compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4415
 
        finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
 
8717
        compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's/ -lc / System.ltframework /'`
 
8718
        finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's/ -lc / System.ltframework /'`
4416
8719
        ;;
4417
8720
      esac
4418
8721
 
4419
8722
      case $host in
4420
 
      *darwin*)
4421
 
        # Don't allow lazy linking, it breaks C++ global constructors
4422
 
        if test "$tagname" = CXX ; then
4423
 
        compile_command="$compile_command ${wl}-bind_at_load"
4424
 
        finalize_command="$finalize_command ${wl}-bind_at_load"
4425
 
        fi
4426
 
        ;;
 
8723
      *-*-darwin*)
 
8724
        # Don't allow lazy linking, it breaks C++ global constructors
 
8725
        # But is supposedly fixed on 10.4 or later (yay!).
 
8726
        if test "$tagname" = CXX ; then
 
8727
          case ${MACOSX_DEPLOYMENT_TARGET-10.0} in
 
8728
            10.[0123])
 
8729
              func_append compile_command " ${wl}-bind_at_load"
 
8730
              func_append finalize_command " ${wl}-bind_at_load"
 
8731
            ;;
 
8732
          esac
 
8733
        fi
 
8734
        # Time to change all our "foo.ltframework" stuff back to "-framework foo"
 
8735
        compile_deplibs=`$ECHO " $compile_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 
8736
        finalize_deplibs=`$ECHO " $finalize_deplibs" | $SED 's% \([^ $]*\).ltframework% -framework \1%g'`
 
8737
        ;;
4427
8738
      esac
4428
8739
 
4429
8740
 
4436
8747
        *)
4437
8748
          case " $compile_deplibs " in
4438
8749
          *" -L$path/$objdir "*)
4439
 
            new_libs="$new_libs -L$path/$objdir" ;;
 
8750
            func_append new_libs " -L$path/$objdir" ;;
4440
8751
          esac
4441
8752
          ;;
4442
8753
        esac
4446
8757
        -L*)
4447
8758
          case " $new_libs " in
4448
8759
          *" $deplib "*) ;;
4449
 
          *) new_libs="$new_libs $deplib" ;;
 
8760
          *) func_append new_libs " $deplib" ;;
4450
8761
          esac
4451
8762
          ;;
4452
 
        *) new_libs="$new_libs $deplib" ;;
 
8763
        *) func_append new_libs " $deplib" ;;
4453
8764
        esac
4454
8765
      done
4455
8766
      compile_deplibs="$new_libs"
4456
8767
 
4457
8768
 
4458
 
      compile_command="$compile_command $compile_deplibs"
4459
 
      finalize_command="$finalize_command $finalize_deplibs"
 
8769
      func_append compile_command " $compile_deplibs"
 
8770
      func_append finalize_command " $finalize_deplibs"
4460
8771
 
4461
8772
      if test -n "$rpath$xrpath"; then
4462
8773
        # If the user specified any rpath flags, then add them.
4464
8775
          # This is the magic to use -rpath.
4465
8776
          case "$finalize_rpath " in
4466
8777
          *" $libdir "*) ;;
4467
 
          *) finalize_rpath="$finalize_rpath $libdir" ;;
 
8778
          *) func_append finalize_rpath " $libdir" ;;
4468
8779
          esac
4469
8780
        done
4470
8781
      fi
4483
8794
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4484
8795
                ;;
4485
8796
              *)
4486
 
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 
8797
                func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
4487
8798
                ;;
4488
8799
              esac
4489
8800
            fi
4490
8801
          else
4491
8802
            eval flag=\"$hardcode_libdir_flag_spec\"
4492
 
            rpath="$rpath $flag"
 
8803
            func_append rpath " $flag"
4493
8804
          fi
4494
8805
        elif test -n "$runpath_var"; then
4495
8806
          case "$perm_rpath " in
4496
8807
          *" $libdir "*) ;;
4497
 
          *) perm_rpath="$perm_rpath $libdir" ;;
 
8808
          *) func_append perm_rpath " $libdir" ;;
4498
8809
          esac
4499
8810
        fi
4500
8811
        case $host in
4501
 
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4502
 
          testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
 
8812
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
 
8813
          testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
4503
8814
          case :$dllsearchpath: in
4504
8815
          *":$libdir:"*) ;;
4505
 
          *) dllsearchpath="$dllsearchpath:$libdir";;
 
8816
          ::) dllsearchpath=$libdir;;
 
8817
          *) func_append dllsearchpath ":$libdir";;
4506
8818
          esac
4507
8819
          case :$dllsearchpath: in
4508
8820
          *":$testbindir:"*) ;;
4509
 
          *) dllsearchpath="$dllsearchpath:$testbindir";;
 
8821
          ::) dllsearchpath=$testbindir;;
 
8822
          *) func_append dllsearchpath ":$testbindir";;
4510
8823
          esac
4511
8824
          ;;
4512
8825
        esac
4532
8845
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4533
8846
                ;;
4534
8847
              *)
4535
 
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 
8848
                func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
4536
8849
                ;;
4537
8850
              esac
4538
8851
            fi
4539
8852
          else
4540
8853
            eval flag=\"$hardcode_libdir_flag_spec\"
4541
 
            rpath="$rpath $flag"
 
8854
            func_append rpath " $flag"
4542
8855
          fi
4543
8856
        elif test -n "$runpath_var"; then
4544
8857
          case "$finalize_perm_rpath " in
4545
8858
          *" $libdir "*) ;;
4546
 
          *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
 
8859
          *) func_append finalize_perm_rpath " $libdir" ;;
4547
8860
          esac
4548
8861
        fi
4549
8862
      done
4557
8870
 
4558
8871
      if test -n "$libobjs" && test "$build_old_libs" = yes; then
4559
8872
        # Transform all the library objects into standard objects.
4560
 
        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4561
 
        finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4562
 
      fi
4563
 
 
4564
 
      dlsyms=
4565
 
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4566
 
        if test -n "$NM" && test -n "$global_symbol_pipe"; then
4567
 
          dlsyms="${outputname}S.c"
4568
 
        else
4569
 
          $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4570
 
        fi
4571
 
      fi
4572
 
 
4573
 
      if test -n "$dlsyms"; then
4574
 
        case $dlsyms in
4575
 
        "") ;;
4576
 
        *.c)
4577
 
          # Discover the nlist of each of the dlfiles.
4578
 
          nlist="$output_objdir/${outputname}.nm"
4579
 
 
4580
 
          $show "$rm $nlist ${nlist}S ${nlist}T"
4581
 
          $run $rm "$nlist" "${nlist}S" "${nlist}T"
4582
 
 
4583
 
          # Parse the name list into a source file.
4584
 
          $show "creating $output_objdir/$dlsyms"
4585
 
 
4586
 
          test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4587
 
/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4588
 
/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4589
 
 
4590
 
#ifdef __cplusplus
4591
 
extern \"C\" {
4592
 
#endif
4593
 
 
4594
 
/* Prevent the only kind of declaration conflicts we can make. */
4595
 
#define lt_preloaded_symbols some_other_symbol
4596
 
 
4597
 
/* External symbol declarations for the compiler. */\
4598
 
"
4599
 
 
4600
 
          if test "$dlself" = yes; then
4601
 
            $show "generating symbol list for \`$output'"
4602
 
 
4603
 
            test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4604
 
 
4605
 
            # Add our own program objects to the symbol list.
4606
 
            progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4607
 
            for arg in $progfiles; do
4608
 
              $show "extracting global C symbols from \`$arg'"
4609
 
              $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4610
 
            done
4611
 
 
4612
 
            if test -n "$exclude_expsyms"; then
4613
 
              $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4614
 
              $run eval '$mv "$nlist"T "$nlist"'
4615
 
            fi
4616
 
 
4617
 
            if test -n "$export_symbols_regex"; then
4618
 
              $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4619
 
              $run eval '$mv "$nlist"T "$nlist"'
4620
 
            fi
4621
 
 
4622
 
            # Prepare the list of exported symbols
4623
 
            if test -z "$export_symbols"; then
4624
 
              export_symbols="$output_objdir/$outputname.exp"
4625
 
              $run $rm $export_symbols
4626
 
              $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4627
 
              case $host in
4628
 
              *cygwin* | *mingw* )
4629
 
                $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4630
 
                $run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
4631
 
                ;;
4632
 
              esac
4633
 
            else
4634
 
              $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
4635
 
              $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
4636
 
              $run eval 'mv "$nlist"T "$nlist"'
4637
 
              case $host in
4638
 
              *cygwin* | *mingw* )
4639
 
                $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4640
 
                $run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
4641
 
                ;;
4642
 
              esac
4643
 
            fi
4644
 
          fi
4645
 
 
4646
 
          for arg in $dlprefiles; do
4647
 
            $show "extracting global C symbols from \`$arg'"
4648
 
            name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4649
 
            $run eval '$echo ": $name " >> "$nlist"'
4650
 
            $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4651
 
          done
4652
 
 
4653
 
          if test -z "$run"; then
4654
 
            # Make sure we have at least an empty file.
4655
 
            test -f "$nlist" || : > "$nlist"
4656
 
 
4657
 
            if test -n "$exclude_expsyms"; then
4658
 
              $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4659
 
              $mv "$nlist"T "$nlist"
4660
 
            fi
4661
 
 
4662
 
            # Try sorting and uniquifying the output.
4663
 
            if grep -v "^: " < "$nlist" |
4664
 
                if sort -k 3 </dev/null >/dev/null 2>&1; then
4665
 
                  sort -k 3
4666
 
                else
4667
 
                  sort +2
4668
 
                fi |
4669
 
                uniq > "$nlist"S; then
4670
 
              :
4671
 
            else
4672
 
              grep -v "^: " < "$nlist" > "$nlist"S
4673
 
            fi
4674
 
 
4675
 
            if test -f "$nlist"S; then
4676
 
              eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4677
 
            else
4678
 
              $echo '/* NONE */' >> "$output_objdir/$dlsyms"
4679
 
            fi
4680
 
 
4681
 
            $echo >> "$output_objdir/$dlsyms" "\
4682
 
 
4683
 
#undef lt_preloaded_symbols
4684
 
 
4685
 
#if defined (__STDC__) && __STDC__
4686
 
# define lt_ptr void *
4687
 
#else
4688
 
# define lt_ptr char *
4689
 
# define const
4690
 
#endif
4691
 
 
4692
 
/* The mapping between symbol names and symbols. */
4693
 
"
4694
 
 
4695
 
            case $host in
4696
 
            *cygwin* | *mingw* )
4697
 
          $echo >> "$output_objdir/$dlsyms" "\
4698
 
/* DATA imports from DLLs on WIN32 can't be const, because
4699
 
   runtime relocations are performed -- see ld's documentation
4700
 
   on pseudo-relocs */
4701
 
struct {
4702
 
"
4703
 
              ;;
4704
 
            * )
4705
 
          $echo >> "$output_objdir/$dlsyms" "\
4706
 
const struct {
4707
 
"
4708
 
              ;;
4709
 
            esac
4710
 
 
4711
 
 
4712
 
          $echo >> "$output_objdir/$dlsyms" "\
4713
 
  const char *name;
4714
 
  lt_ptr address;
4715
 
}
4716
 
lt_preloaded_symbols[] =
4717
 
{\
4718
 
"
4719
 
 
4720
 
            eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4721
 
 
4722
 
            $echo >> "$output_objdir/$dlsyms" "\
4723
 
  {0, (lt_ptr) 0}
4724
 
};
4725
 
 
4726
 
/* This works around a problem in FreeBSD linker */
4727
 
#ifdef FREEBSD_WORKAROUND
4728
 
static const void *lt_preloaded_setup() {
4729
 
  return lt_preloaded_symbols;
4730
 
}
4731
 
#endif
4732
 
 
4733
 
#ifdef __cplusplus
4734
 
}
4735
 
#endif\
4736
 
"
4737
 
          fi
4738
 
 
4739
 
          pic_flag_for_symtable=
4740
 
          case $host in
4741
 
          # compiling the symbol table file with pic_flag works around
4742
 
          # a FreeBSD bug that causes programs to crash when -lm is
4743
 
          # linked before any other PIC object.  But we must not use
4744
 
          # pic_flag when linking with -static.  The problem exists in
4745
 
          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4746
 
          *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4747
 
            case "$compile_command " in
4748
 
            *" -static "*) ;;
4749
 
            *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4750
 
            esac;;
4751
 
          *-*-hpux*)
4752
 
            case "$compile_command " in
4753
 
            *" -static "*) ;;
4754
 
            *) pic_flag_for_symtable=" $pic_flag";;
4755
 
            esac
4756
 
          esac
4757
 
 
4758
 
          # Now compile the dynamic symbol file.
4759
 
          $show "(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4760
 
          $run eval '(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4761
 
 
4762
 
          # Clean up the generated files.
4763
 
          $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4764
 
          $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4765
 
 
4766
 
          # Transform the symbol file into the correct name.
4767
 
          case $host in
4768
 
          *cygwin* | *mingw* )
4769
 
            if test -f "$output_objdir/${outputname}.def" ; then
4770
 
              compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
4771
 
              finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
4772
 
            else
4773
 
              compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4774
 
              finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4775
 
             fi
4776
 
            ;;
4777
 
          * )
4778
 
            compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4779
 
            finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4780
 
            ;;
4781
 
          esac
4782
 
          ;;
4783
 
        *)
4784
 
          $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4785
 
          exit $EXIT_FAILURE
4786
 
          ;;
4787
 
        esac
4788
 
      else
4789
 
        # We keep going just in case the user didn't refer to
4790
 
        # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
4791
 
        # really was required.
4792
 
 
4793
 
        # Nullify the symbol file.
4794
 
        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
4795
 
        finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
4796
 
      fi
4797
 
 
4798
 
      if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
 
8873
        compile_command=`$ECHO "$compile_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
 
8874
        finalize_command=`$ECHO "$finalize_command" | $SP2NL | $SED "$lo2o" | $NL2SP`
 
8875
      fi
 
8876
 
 
8877
      func_generate_dlsyms "$outputname" "@PROGRAM@" "no"
 
8878
 
 
8879
      # template prelinking step
 
8880
      if test -n "$prelink_cmds"; then
 
8881
        func_execute_cmds "$prelink_cmds" 'exit $?'
 
8882
      fi
 
8883
 
 
8884
      wrappers_required=yes
 
8885
      case $host in
 
8886
      *cegcc* | *mingw32ce*)
 
8887
        # Disable wrappers for cegcc and mingw32ce hosts, we are cross compiling anyway.
 
8888
        wrappers_required=no
 
8889
        ;;
 
8890
      *cygwin* | *mingw* )
 
8891
        if test "$build_libtool_libs" != yes; then
 
8892
          wrappers_required=no
 
8893
        fi
 
8894
        ;;
 
8895
      *)
 
8896
        if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
 
8897
          wrappers_required=no
 
8898
        fi
 
8899
        ;;
 
8900
      esac
 
8901
      if test "$wrappers_required" = no; then
4799
8902
        # Replace the output file specification.
4800
 
        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$output"'%g' | $NL2SP`
 
8903
        compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
4801
8904
        link_command="$compile_command$compile_rpath"
4802
8905
 
4803
8906
        # We have no uninstalled library dependencies, so finalize right now.
4804
 
        $show "$link_command"
4805
 
        $run eval "$link_command"
4806
 
        exit_status=$?
 
8907
        exit_status=0
 
8908
        func_show_eval "$link_command" 'exit_status=$?'
 
8909
 
 
8910
        if test -n "$postlink_cmds"; then
 
8911
          func_to_tool_file "$output"
 
8912
          postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
 
8913
          func_execute_cmds "$postlink_cmds" 'exit $?'
 
8914
        fi
4807
8915
 
4808
8916
        # Delete the generated files.
4809
 
        if test -n "$dlsyms"; then
4810
 
          $show "$rm $output_objdir/${outputname}S.${objext}"
4811
 
          $run $rm "$output_objdir/${outputname}S.${objext}"
 
8917
        if test -f "$output_objdir/${outputname}S.${objext}"; then
 
8918
          func_show_eval '$RM "$output_objdir/${outputname}S.${objext}"'
4812
8919
        fi
4813
8920
 
4814
8921
        exit $exit_status
4815
8922
      fi
4816
8923
 
4817
 
      if test -n "$shlibpath_var"; then
4818
 
        # We should set the shlibpath_var
4819
 
        rpath=
4820
 
        for dir in $temp_rpath; do
4821
 
          case $dir in
4822
 
          [\\/]* | [A-Za-z]:[\\/]*)
4823
 
            # Absolute path.
4824
 
            rpath="$rpath$dir:"
4825
 
            ;;
4826
 
          *)
4827
 
            # Relative path: add a thisdir entry.
4828
 
            rpath="$rpath\$thisdir/$dir:"
4829
 
            ;;
4830
 
          esac
4831
 
        done
4832
 
        temp_rpath="$rpath"
4833
 
      fi
4834
 
 
4835
8924
      if test -n "$compile_shlibpath$finalize_shlibpath"; then
4836
8925
        compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
4837
8926
      fi
4846
8935
          # We should set the runpath_var.
4847
8936
          rpath=
4848
8937
          for dir in $perm_rpath; do
4849
 
            rpath="$rpath$dir:"
 
8938
            func_append rpath "$dir:"
4850
8939
          done
4851
8940
          compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
4852
8941
        fi
4854
8943
          # We should set the runpath_var.
4855
8944
          rpath=
4856
8945
          for dir in $finalize_perm_rpath; do
4857
 
            rpath="$rpath$dir:"
 
8946
            func_append rpath "$dir:"
4858
8947
          done
4859
8948
          finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
4860
8949
        fi
4864
8953
        # We don't need to create a wrapper script.
4865
8954
        link_command="$compile_var$compile_command$compile_rpath"
4866
8955
        # Replace the output file specification.
4867
 
        link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
 
8956
        link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
4868
8957
        # Delete the old output file.
4869
 
        $run $rm $output
 
8958
        $opt_dry_run || $RM $output
4870
8959
        # Link the executable and exit
4871
 
        $show "$link_command"
4872
 
        $run eval "$link_command" || exit $?
 
8960
        func_show_eval "$link_command" 'exit $?'
 
8961
 
 
8962
        if test -n "$postlink_cmds"; then
 
8963
          func_to_tool_file "$output"
 
8964
          postlink_cmds=`func_echo_all "$postlink_cmds" | $SED -e 's%@OUTPUT@%'"$output"'%g' -e 's%@TOOL_OUTPUT@%'"$func_to_tool_file_result"'%g'`
 
8965
          func_execute_cmds "$postlink_cmds" 'exit $?'
 
8966
        fi
 
8967
 
4873
8968
        exit $EXIT_SUCCESS
4874
8969
      fi
4875
8970
 
4878
8973
        link_command="$compile_var$compile_command$compile_rpath"
4879
8974
        relink_command="$finalize_var$finalize_command$finalize_rpath"
4880
8975
 
4881
 
        $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
4882
 
        $echo "$modename: \`$output' will be relinked during installation" 1>&2
 
8976
        func_warning "this platform does not like uninstalled shared libraries"
 
8977
        func_warning "\`$output' will be relinked during installation"
4883
8978
      else
4884
8979
        if test "$fast_install" != no; then
4885
8980
          link_command="$finalize_var$compile_command$finalize_rpath"
4886
8981
          if test "$fast_install" = yes; then
4887
 
            relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $SP2NL | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g' | $NL2SP`
 
8982
            relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
4888
8983
          else
4889
8984
            # fast_install is set to needless
4890
8985
            relink_command=
4896
8991
      fi
4897
8992
 
4898
8993
      # Replace the output file specification.
4899
 
      link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
 
8994
      link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4900
8995
 
4901
8996
      # Delete the old output files.
4902
 
      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
4903
 
 
4904
 
      $show "$link_command"
4905
 
      $run eval "$link_command" || exit $?
 
8997
      $opt_dry_run || $RM $output $output_objdir/$outputname $output_objdir/lt-$outputname
 
8998
 
 
8999
      func_show_eval "$link_command" 'exit $?'
 
9000
 
 
9001
      if test -n "$postlink_cmds"; then
 
9002
        func_to_tool_file "$output_objdir/$outputname"
 
9003
        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'`
 
9004
        func_execute_cmds "$postlink_cmds" 'exit $?'
 
9005
      fi
4906
9006
 
4907
9007
      # Now create the wrapper script.
4908
 
      $show "creating $output"
 
9008
      func_verbose "creating $output"
4909
9009
 
4910
9010
      # Quote the relink command for shipping.
4911
9011
      if test -n "$relink_command"; then
4912
9012
        # Preserve any variables that may affect compiler behavior
4913
9013
        for var in $variables_saved_for_relink; do
4914
9014
          if eval test -z \"\${$var+set}\"; then
4915
 
            relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
 
9015
            relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
4916
9016
          elif eval var_value=\$$var; test -z "$var_value"; then
4917
9017
            relink_command="$var=; export $var; $relink_command"
4918
9018
          else
4919
 
            var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4920
 
            relink_command="$var=\"$var_value\"; export $var; $relink_command"
 
9019
            func_quote_for_eval "$var_value"
 
9020
            relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
4921
9021
          fi
4922
9022
        done
4923
9023
        relink_command="(cd `pwd`; $relink_command)"
4924
 
        relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
4925
 
      fi
4926
 
 
4927
 
      # Quote $echo for shipping.
4928
 
      if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
4929
 
        case $progpath in
4930
 
        [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4931
 
        *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4932
 
        esac
4933
 
        qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4934
 
      else
4935
 
        qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4936
 
      fi
4937
 
 
4938
 
      # Only actually do things if our run command is non-null.
4939
 
      if test -z "$run"; then
 
9024
        relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
 
9025
      fi
 
9026
 
 
9027
      # Only actually do things if not in dry run mode.
 
9028
      $opt_dry_run || {
4940
9029
        # win32 will think the script is a binary if it has
4941
9030
        # a .exe suffix, so we strip it off here.
4942
9031
        case $output in
4943
 
          *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
 
9032
          *.exe) func_stripname '' '.exe' "$output"
 
9033
                 output=$func_stripname_result ;;
4944
9034
        esac
4945
9035
        # test for cygwin because mv fails w/o .exe extensions
4946
9036
        case $host in
4947
9037
          *cygwin*)
4948
9038
            exeext=.exe
4949
 
            outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
 
9039
            func_stripname '' '.exe' "$outputname"
 
9040
            outputname=$func_stripname_result ;;
4950
9041
          *) exeext= ;;
4951
9042
        esac
4952
9043
        case $host in
4953
9044
          *cygwin* | *mingw* )
4954
 
            output_name=`basename $output`
4955
 
            output_path=`dirname $output`
4956
 
            cwrappersource="$output_path/$objdir/lt-$output_name.c"
4957
 
            cwrapper="$output_path/$output_name.exe"
4958
 
            $rm $cwrappersource $cwrapper
4959
 
            trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4960
 
 
4961
 
            cat > $cwrappersource <<EOF
4962
 
 
4963
 
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4964
 
   Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4965
 
 
4966
 
   The $output program cannot be directly executed until all the libtool
4967
 
   libraries that it depends on are installed.
4968
 
 
4969
 
   This wrapper executable should never be moved out of the build directory.
4970
 
   If it is, it will not operate correctly.
4971
 
 
4972
 
   Currently, it simply execs the wrapper *script* "/bin/sh $output",
4973
 
   but could eventually absorb all of the scripts functionality and
4974
 
   exec $objdir/$outputname directly.
4975
 
*/
4976
 
EOF
4977
 
            cat >> $cwrappersource<<"EOF"
4978
 
#include <stdio.h>
4979
 
#include <stdlib.h>
4980
 
#include <unistd.h>
4981
 
#include <malloc.h>
4982
 
#include <stdarg.h>
4983
 
#include <assert.h>
4984
 
#include <string.h>
4985
 
#include <ctype.h>
4986
 
#include <sys/stat.h>
4987
 
 
4988
 
#if defined(PATH_MAX)
4989
 
# define LT_PATHMAX PATH_MAX
4990
 
#elif defined(MAXPATHLEN)
4991
 
# define LT_PATHMAX MAXPATHLEN
4992
 
#else
4993
 
# define LT_PATHMAX 1024
4994
 
#endif
4995
 
 
4996
 
#ifndef DIR_SEPARATOR
4997
 
# define DIR_SEPARATOR '/'
4998
 
# define PATH_SEPARATOR ':'
4999
 
#endif
5000
 
 
5001
 
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
5002
 
  defined (__OS2__)
5003
 
# define HAVE_DOS_BASED_FILE_SYSTEM
5004
 
# ifndef DIR_SEPARATOR_2
5005
 
#  define DIR_SEPARATOR_2 '\\'
5006
 
# endif
5007
 
# ifndef PATH_SEPARATOR_2
5008
 
#  define PATH_SEPARATOR_2 ';'
5009
 
# endif
5010
 
#endif
5011
 
 
5012
 
#ifndef DIR_SEPARATOR_2
5013
 
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
5014
 
#else /* DIR_SEPARATOR_2 */
5015
 
# define IS_DIR_SEPARATOR(ch) \
5016
 
        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
5017
 
#endif /* DIR_SEPARATOR_2 */
5018
 
 
5019
 
#ifndef PATH_SEPARATOR_2
5020
 
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
5021
 
#else /* PATH_SEPARATOR_2 */
5022
 
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
5023
 
#endif /* PATH_SEPARATOR_2 */
5024
 
 
5025
 
#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
5026
 
#define XFREE(stale) do { \
5027
 
  if (stale) { free ((void *) stale); stale = 0; } \
5028
 
} while (0)
5029
 
 
5030
 
/* -DDEBUG is fairly common in CFLAGS.  */
5031
 
#undef DEBUG
5032
 
#if defined DEBUGWRAPPER
5033
 
# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
5034
 
#else
5035
 
# define DEBUG(format, ...)
5036
 
#endif
5037
 
 
5038
 
const char *program_name = NULL;
5039
 
 
5040
 
void * xmalloc (size_t num);
5041
 
char * xstrdup (const char *string);
5042
 
const char * base_name (const char *name);
5043
 
char * find_executable(const char *wrapper);
5044
 
int    check_executable(const char *path);
5045
 
char * strendzap(char *str, const char *pat);
5046
 
void lt_fatal (const char *message, ...);
5047
 
 
5048
 
int
5049
 
main (int argc, char *argv[])
5050
 
{
5051
 
  char **newargz;
5052
 
  int i;
5053
 
 
5054
 
  program_name = (char *) xstrdup (base_name (argv[0]));
5055
 
  DEBUG("(main) argv[0]      : %s\n",argv[0]);
5056
 
  DEBUG("(main) program_name : %s\n",program_name);
5057
 
  newargz = XMALLOC(char *, argc+2);
5058
 
EOF
5059
 
 
5060
 
            cat >> $cwrappersource <<EOF
5061
 
  newargz[0] = (char *) xstrdup("$SHELL");
5062
 
EOF
5063
 
 
5064
 
            cat >> $cwrappersource <<"EOF"
5065
 
  newargz[1] = find_executable(argv[0]);
5066
 
  if (newargz[1] == NULL)
5067
 
    lt_fatal("Couldn't find %s", argv[0]);
5068
 
  DEBUG("(main) found exe at : %s\n",newargz[1]);
5069
 
  /* we know the script has the same name, without the .exe */
5070
 
  /* so make sure newargz[1] doesn't end in .exe */
5071
 
  strendzap(newargz[1],".exe");
5072
 
  for (i = 1; i < argc; i++)
5073
 
    newargz[i+1] = xstrdup(argv[i]);
5074
 
  newargz[argc+1] = NULL;
5075
 
 
5076
 
  for (i=0; i<argc+1; i++)
5077
 
  {
5078
 
    DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
5079
 
    ;
5080
 
  }
5081
 
 
5082
 
EOF
5083
 
 
5084
 
            case $host_os in
5085
 
              mingw*)
5086
 
                cat >> $cwrappersource <<EOF
5087
 
  execv("$SHELL",(char const **)newargz);
5088
 
EOF
5089
 
              ;;
5090
 
              *)
5091
 
                cat >> $cwrappersource <<EOF
5092
 
  execv("$SHELL",newargz);
5093
 
EOF
5094
 
              ;;
5095
 
            esac
5096
 
 
5097
 
            cat >> $cwrappersource <<"EOF"
5098
 
  return 127;
5099
 
}
5100
 
 
5101
 
void *
5102
 
xmalloc (size_t num)
5103
 
{
5104
 
  void * p = (void *) malloc (num);
5105
 
  if (!p)
5106
 
    lt_fatal ("Memory exhausted");
5107
 
 
5108
 
  return p;
5109
 
}
5110
 
 
5111
 
char *
5112
 
xstrdup (const char *string)
5113
 
{
5114
 
  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
5115
 
;
5116
 
}
5117
 
 
5118
 
const char *
5119
 
base_name (const char *name)
5120
 
{
5121
 
  const char *base;
5122
 
 
5123
 
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5124
 
  /* Skip over the disk name in MSDOS pathnames. */
5125
 
  if (isalpha ((unsigned char)name[0]) && name[1] == ':')
5126
 
    name += 2;
5127
 
#endif
5128
 
 
5129
 
  for (base = name; *name; name++)
5130
 
    if (IS_DIR_SEPARATOR (*name))
5131
 
      base = name + 1;
5132
 
  return base;
5133
 
}
5134
 
 
5135
 
int
5136
 
check_executable(const char * path)
5137
 
{
5138
 
  struct stat st;
5139
 
 
5140
 
  DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
5141
 
  if ((!path) || (!*path))
5142
 
    return 0;
5143
 
 
5144
 
  if ((stat (path, &st) >= 0) &&
5145
 
      (
5146
 
        /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
5147
 
#if defined (S_IXOTH)
5148
 
       ((st.st_mode & S_IXOTH) == S_IXOTH) ||
5149
 
#endif
5150
 
#if defined (S_IXGRP)
5151
 
       ((st.st_mode & S_IXGRP) == S_IXGRP) ||
5152
 
#endif
5153
 
       ((st.st_mode & S_IXUSR) == S_IXUSR))
5154
 
      )
5155
 
    return 1;
5156
 
  else
5157
 
    return 0;
5158
 
}
5159
 
 
5160
 
/* Searches for the full path of the wrapper.  Returns
5161
 
   newly allocated full path name if found, NULL otherwise */
5162
 
char *
5163
 
find_executable (const char* wrapper)
5164
 
{
5165
 
  int has_slash = 0;
5166
 
  const char* p;
5167
 
  const char* p_next;
5168
 
  /* static buffer for getcwd */
5169
 
  char tmp[LT_PATHMAX + 1];
5170
 
  int tmp_len;
5171
 
  char* concat_name;
5172
 
 
5173
 
  DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
5174
 
 
5175
 
  if ((wrapper == NULL) || (*wrapper == '\0'))
5176
 
    return NULL;
5177
 
 
5178
 
  /* Absolute path? */
5179
 
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5180
 
  if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
5181
 
  {
5182
 
    concat_name = xstrdup (wrapper);
5183
 
    if (check_executable(concat_name))
5184
 
      return concat_name;
5185
 
    XFREE(concat_name);
5186
 
  }
5187
 
  else
5188
 
  {
5189
 
#endif
5190
 
    if (IS_DIR_SEPARATOR (wrapper[0]))
5191
 
    {
5192
 
      concat_name = xstrdup (wrapper);
5193
 
      if (check_executable(concat_name))
5194
 
        return concat_name;
5195
 
      XFREE(concat_name);
5196
 
    }
5197
 
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5198
 
  }
5199
 
#endif
5200
 
 
5201
 
  for (p = wrapper; *p; p++)
5202
 
    if (*p == '/')
5203
 
    {
5204
 
      has_slash = 1;
5205
 
      break;
5206
 
    }
5207
 
  if (!has_slash)
5208
 
  {
5209
 
    /* no slashes; search PATH */
5210
 
    const char* path = getenv ("PATH");
5211
 
    if (path != NULL)
5212
 
    {
5213
 
      for (p = path; *p; p = p_next)
5214
 
      {
5215
 
        const char* q;
5216
 
        size_t p_len;
5217
 
        for (q = p; *q; q++)
5218
 
          if (IS_PATH_SEPARATOR(*q))
5219
 
            break;
5220
 
        p_len = q - p;
5221
 
        p_next = (*q == '\0' ? q : q + 1);
5222
 
        if (p_len == 0)
5223
 
        {
5224
 
          /* empty path: current directory */
5225
 
          if (getcwd (tmp, LT_PATHMAX) == NULL)
5226
 
            lt_fatal ("getcwd failed");
5227
 
          tmp_len = strlen(tmp);
5228
 
          concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5229
 
          memcpy (concat_name, tmp, tmp_len);
5230
 
          concat_name[tmp_len] = '/';
5231
 
          strcpy (concat_name + tmp_len + 1, wrapper);
5232
 
        }
5233
 
        else
5234
 
        {
5235
 
          concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
5236
 
          memcpy (concat_name, p, p_len);
5237
 
          concat_name[p_len] = '/';
5238
 
          strcpy (concat_name + p_len + 1, wrapper);
5239
 
        }
5240
 
        if (check_executable(concat_name))
5241
 
          return concat_name;
5242
 
        XFREE(concat_name);
 
9045
            func_dirname_and_basename "$output" "" "."
 
9046
            output_name=$func_basename_result
 
9047
            output_path=$func_dirname_result
 
9048
            cwrappersource="$output_path/$objdir/lt-$output_name.c"
 
9049
            cwrapper="$output_path/$output_name.exe"
 
9050
            $RM $cwrappersource $cwrapper
 
9051
            trap "$RM $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
 
9052
 
 
9053
            func_emit_cwrapperexe_src > $cwrappersource
 
9054
 
 
9055
            # The wrapper executable is built using the $host compiler,
 
9056
            # because it contains $host paths and files. If cross-
 
9057
            # compiling, it, like the target executable, must be
 
9058
            # executed on the $host or under an emulation environment.
 
9059
            $opt_dry_run || {
 
9060
              $LTCC $LTCFLAGS -o $cwrapper $cwrappersource
 
9061
              $STRIP $cwrapper
 
9062
            }
 
9063
 
 
9064
            # Now, create the wrapper script for func_source use:
 
9065
            func_ltwrapper_scriptname $cwrapper
 
9066
            $RM $func_ltwrapper_scriptname_result
 
9067
            trap "$RM $func_ltwrapper_scriptname_result; exit $EXIT_FAILURE" 1 2 15
 
9068
            $opt_dry_run || {
 
9069
              # note: this script will not be executed, so do not chmod.
 
9070
              if test "x$build" = "x$host" ; then
 
9071
                $cwrapper --lt-dump-script > $func_ltwrapper_scriptname_result
 
9072
              else
 
9073
                func_emit_wrapper no > $func_ltwrapper_scriptname_result
 
9074
              fi
 
9075
            }
 
9076
          ;;
 
9077
          * )
 
9078
            $RM $output
 
9079
            trap "$RM $output; exit $EXIT_FAILURE" 1 2 15
 
9080
 
 
9081
            func_emit_wrapper no > $output
 
9082
            chmod +x $output
 
9083
          ;;
 
9084
        esac
5243
9085
      }
5244
 
    }
5245
 
    /* not found in PATH; assume curdir */
5246
 
  }
5247
 
  /* Relative path | not found in path: prepend cwd */
5248
 
  if (getcwd (tmp, LT_PATHMAX) == NULL)
5249
 
    lt_fatal ("getcwd failed");
5250
 
  tmp_len = strlen(tmp);
5251
 
  concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5252
 
  memcpy (concat_name, tmp, tmp_len);
5253
 
  concat_name[tmp_len] = '/';
5254
 
  strcpy (concat_name + tmp_len + 1, wrapper);
5255
 
 
5256
 
  if (check_executable(concat_name))
5257
 
    return concat_name;
5258
 
  XFREE(concat_name);
5259
 
  return NULL;
5260
 
}
5261
 
 
5262
 
char *
5263
 
strendzap(char *str, const char *pat)
5264
 
{
5265
 
  size_t len, patlen;
5266
 
 
5267
 
  assert(str != NULL);
5268
 
  assert(pat != NULL);
5269
 
 
5270
 
  len = strlen(str);
5271
 
  patlen = strlen(pat);
5272
 
 
5273
 
  if (patlen <= len)
5274
 
  {
5275
 
    str += len - patlen;
5276
 
    if (strcmp(str, pat) == 0)
5277
 
      *str = '\0';
5278
 
  }
5279
 
  return str;
5280
 
}
5281
 
 
5282
 
static void
5283
 
lt_error_core (int exit_status, const char * mode,
5284
 
          const char * message, va_list ap)
5285
 
{
5286
 
  fprintf (stderr, "%s: %s: ", program_name, mode);
5287
 
  vfprintf (stderr, message, ap);
5288
 
  fprintf (stderr, ".\n");
5289
 
 
5290
 
  if (exit_status >= 0)
5291
 
    exit (exit_status);
5292
 
}
5293
 
 
5294
 
void
5295
 
lt_fatal (const char *message, ...)
5296
 
{
5297
 
  va_list ap;
5298
 
  va_start (ap, message);
5299
 
  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
5300
 
  va_end (ap);
5301
 
}
5302
 
EOF
5303
 
          # we should really use a build-platform specific compiler
5304
 
          # here, but OTOH, the wrappers (shell script and this C one)
5305
 
          # are only useful if you want to execute the "real" binary.
5306
 
          # Since the "real" binary is built for $host, then this
5307
 
          # wrapper might as well be built for $host, too.
5308
 
          $run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
5309
 
          ;;
5310
 
        esac
5311
 
        $rm $output
5312
 
        trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
5313
 
 
5314
 
        $echo > $output "\
5315
 
#! $SHELL
5316
 
 
5317
 
# $output - temporary wrapper script for $objdir/$outputname
5318
 
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5319
 
#
5320
 
# The $output program cannot be directly executed until all the libtool
5321
 
# libraries that it depends on are installed.
5322
 
#
5323
 
# This wrapper script should never be moved out of the build directory.
5324
 
# If it is, it will not operate correctly.
5325
 
 
5326
 
# Sed substitution that helps us do robust quoting.  It backslashifies
5327
 
# metacharacters that are still active within double-quoted strings.
5328
 
Xsed='${SED} -e 1s/^X//'
5329
 
sed_quote_subst='$sed_quote_subst'
5330
 
 
5331
 
# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
5332
 
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
5333
 
  emulate sh
5334
 
  NULLCMD=:
5335
 
  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
5336
 
  # is contrary to our usage.  Disable this feature.
5337
 
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
5338
 
  setopt NO_GLOB_SUBST
5339
 
else
5340
 
  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
5341
 
fi
5342
 
BIN_SH=xpg4; export BIN_SH # for Tru64
5343
 
DUALCASE=1; export DUALCASE # for MKS sh
5344
 
 
5345
 
# The HP-UX ksh and POSIX shell print the target directory to stdout
5346
 
# if CDPATH is set.
5347
 
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5348
 
 
5349
 
relink_command=\"$relink_command\"
5350
 
 
5351
 
# This environment variable determines our operation mode.
5352
 
if test \"\$libtool_install_magic\" = \"$magic\"; then
5353
 
  # install mode needs the following variable:
5354
 
  notinst_deplibs='$notinst_deplibs'
5355
 
else
5356
 
  # When we are sourced in execute mode, \$file and \$echo are already set.
5357
 
  if test \"\$libtool_execute_magic\" != \"$magic\"; then
5358
 
    echo=\"$qecho\"
5359
 
    file=\"\$0\"
5360
 
    # Make sure echo works.
5361
 
    if test \"X\$1\" = X--no-reexec; then
5362
 
      # Discard the --no-reexec flag, and continue.
5363
 
      shift
5364
 
    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
5365
 
      # Yippee, \$echo works!
5366
 
      :
5367
 
    else
5368
 
      # Restart under the correct shell, and then maybe \$echo will work.
5369
 
      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
5370
 
    fi
5371
 
  fi\
5372
 
"
5373
 
        $echo >> $output "\
5374
 
 
5375
 
  # Find the directory that this script lives in.
5376
 
  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
5377
 
  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5378
 
 
5379
 
  # Follow symbolic links until we get to the real thisdir.
5380
 
  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
5381
 
  while test -n \"\$file\"; do
5382
 
    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
5383
 
 
5384
 
    # If there was a directory component, then change thisdir.
5385
 
    if test \"x\$destdir\" != \"x\$file\"; then
5386
 
      case \"\$destdir\" in
5387
 
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5388
 
      *) thisdir=\"\$thisdir/\$destdir\" ;;
5389
 
      esac
5390
 
    fi
5391
 
 
5392
 
    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
5393
 
    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
5394
 
  done
5395
 
 
5396
 
  # Try to get the absolute directory name.
5397
 
  absdir=\`cd \"\$thisdir\" && pwd\`
5398
 
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
5399
 
"
5400
 
 
5401
 
        if test "$fast_install" = yes; then
5402
 
          $echo >> $output "\
5403
 
  program=lt-'$outputname'$exeext
5404
 
  progdir=\"\$thisdir/$objdir\"
5405
 
 
5406
 
  if test ! -f \"\$progdir/\$program\" || \\
5407
 
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
5408
 
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5409
 
 
5410
 
    file=\"\$\$-\$program\"
5411
 
 
5412
 
    if test ! -d \"\$progdir\"; then
5413
 
      $mkdir \"\$progdir\"
5414
 
    else
5415
 
      $rm \"\$progdir/\$file\"
5416
 
    fi"
5417
 
 
5418
 
          $echo >> $output "\
5419
 
 
5420
 
    # relink executable if necessary
5421
 
    if test -n \"\$relink_command\"; then
5422
 
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5423
 
      else
5424
 
        $echo \"\$relink_command_output\" >&2
5425
 
        $rm \"\$progdir/\$file\"
5426
 
        exit $EXIT_FAILURE
5427
 
      fi
5428
 
    fi
5429
 
 
5430
 
    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5431
 
    { $rm \"\$progdir/\$program\";
5432
 
      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5433
 
    $rm \"\$progdir/\$file\"
5434
 
  fi"
5435
 
        else
5436
 
          $echo >> $output "\
5437
 
  program='$outputname'
5438
 
  progdir=\"\$thisdir/$objdir\"
5439
 
"
5440
 
        fi
5441
 
 
5442
 
        $echo >> $output "\
5443
 
 
5444
 
  if test -f \"\$progdir/\$program\"; then"
5445
 
 
5446
 
        # Export our shlibpath_var if we have one.
5447
 
        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5448
 
          $echo >> $output "\
5449
 
    # Add our own library path to $shlibpath_var
5450
 
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5451
 
 
5452
 
    # Some systems cannot cope with colon-terminated $shlibpath_var
5453
 
    # The second colon is a workaround for a bug in BeOS R4 sed
5454
 
    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
5455
 
 
5456
 
    export $shlibpath_var
5457
 
"
5458
 
        fi
5459
 
 
5460
 
        # fixup the dll searchpath if we need to.
5461
 
        if test -n "$dllsearchpath"; then
5462
 
          $echo >> $output "\
5463
 
    # Add the dll search path components to the executable PATH
5464
 
    PATH=$dllsearchpath:\$PATH
5465
 
"
5466
 
        fi
5467
 
 
5468
 
        $echo >> $output "\
5469
 
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
5470
 
      # Run the actual program with our arguments.
5471
 
"
5472
 
        case $host in
5473
 
        # Backslashes separate directories on plain windows
5474
 
        *-*-mingw | *-*-os2*)
5475
 
          $echo >> $output "\
5476
 
      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5477
 
"
5478
 
          ;;
5479
 
 
5480
 
        *)
5481
 
          $echo >> $output "\
5482
 
      exec \"\$progdir/\$program\" \${1+\"\$@\"}
5483
 
"
5484
 
          ;;
5485
 
        esac
5486
 
        $echo >> $output "\
5487
 
      \$echo \"\$0: cannot exec \$program \$*\"
5488
 
      exit $EXIT_FAILURE
5489
 
    fi
5490
 
  else
5491
 
    # The program doesn't exist.
5492
 
    \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
5493
 
    \$echo \"This script is just a wrapper for \$program.\" 1>&2
5494
 
    $echo \"See the $PACKAGE documentation for more information.\" 1>&2
5495
 
    exit $EXIT_FAILURE
5496
 
  fi
5497
 
fi\
5498
 
"
5499
 
        chmod +x $output
5500
 
      fi
5501
9086
      exit $EXIT_SUCCESS
5502
9087
      ;;
5503
9088
    esac
5506
9091
    for oldlib in $oldlibs; do
5507
9092
 
5508
9093
      if test "$build_libtool_libs" = convenience; then
5509
 
        oldobjs="$libobjs_save"
 
9094
        oldobjs="$libobjs_save $symfileobj"
5510
9095
        addlibs="$convenience"
5511
9096
        build_libtool_libs=no
5512
9097
      else
5515
9100
          build_libtool_libs=no
5516
9101
        else
5517
9102
          oldobjs="$old_deplibs $non_pic_objects"
 
9103
          if test "$preload" = yes && test -f "$symfileobj"; then
 
9104
            func_append oldobjs " $symfileobj"
 
9105
          fi
5518
9106
        fi
5519
9107
        addlibs="$old_convenience"
5520
9108
      fi
5521
9109
 
5522
9110
      if test -n "$addlibs"; then
5523
9111
        gentop="$output_objdir/${outputname}x"
5524
 
        generated="$generated $gentop"
 
9112
        func_append generated " $gentop"
5525
9113
 
5526
9114
        func_extract_archives $gentop $addlibs
5527
 
        oldobjs="$oldobjs $func_extract_archives_result"
 
9115
        func_append oldobjs " $func_extract_archives_result"
5528
9116
      fi
5529
9117
 
5530
9118
      # Do each command in the archive commands.
5531
9119
      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
5532
 
       cmds=$old_archive_from_new_cmds
 
9120
        cmds=$old_archive_from_new_cmds
5533
9121
      else
 
9122
 
 
9123
        # Add any objects from preloaded convenience libraries
 
9124
        if test -n "$dlprefiles"; then
 
9125
          gentop="$output_objdir/${outputname}x"
 
9126
          func_append generated " $gentop"
 
9127
 
 
9128
          func_extract_archives $gentop $dlprefiles
 
9129
          func_append oldobjs " $func_extract_archives_result"
 
9130
        fi
 
9131
 
5534
9132
        # POSIX demands no paths to be encoded in archives.  We have
5535
9133
        # to avoid creating archives with duplicate basenames if we
5536
9134
        # might have to extract them afterwards, e.g., when creating a
5539
9137
        # not supported by libtool).
5540
9138
        if (for obj in $oldobjs
5541
9139
            do
5542
 
              $echo "X$obj" | $Xsed -e 's%^.*/%%'
 
9140
              func_basename "$obj"
 
9141
              $ECHO "$func_basename_result"
5543
9142
            done | sort | sort -uc >/dev/null 2>&1); then
5544
9143
          :
5545
9144
        else
5546
 
          $echo "copying selected object files to avoid basename conflicts..."
5547
 
 
5548
 
          if test -z "$gentop"; then
5549
 
            gentop="$output_objdir/${outputname}x"
5550
 
            generated="$generated $gentop"
5551
 
 
5552
 
            $show "${rm}r $gentop"
5553
 
            $run ${rm}r "$gentop"
5554
 
            $show "$mkdir $gentop"
5555
 
            $run $mkdir "$gentop"
5556
 
            exit_status=$?
5557
 
            if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
5558
 
              exit $exit_status
5559
 
            fi
5560
 
          fi
5561
 
 
 
9145
          echo "copying selected object files to avoid basename conflicts..."
 
9146
          gentop="$output_objdir/${outputname}x"
 
9147
          func_append generated " $gentop"
 
9148
          func_mkdir_p "$gentop"
5562
9149
          save_oldobjs=$oldobjs
5563
9150
          oldobjs=
5564
9151
          counter=1
5565
9152
          for obj in $save_oldobjs
5566
9153
          do
5567
 
            objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
 
9154
            func_basename "$obj"
 
9155
            objbase="$func_basename_result"
5568
9156
            case " $oldobjs " in
5569
9157
            " ") oldobjs=$obj ;;
5570
9158
            *[\ /]"$objbase "*)
5572
9160
                # Make sure we don't pick an alternate name that also
5573
9161
                # overlaps.
5574
9162
                newobj=lt$counter-$objbase
5575
 
                counter=`expr $counter + 1`
 
9163
                func_arith $counter + 1
 
9164
                counter=$func_arith_result
5576
9165
                case " $oldobjs " in
5577
9166
                *[\ /]"$newobj "*) ;;
5578
9167
                *) if test ! -f "$gentop/$newobj"; then break; fi ;;
5579
9168
                esac
5580
9169
              done
5581
 
              $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
5582
 
              $run ln "$obj" "$gentop/$newobj" ||
5583
 
              $run cp "$obj" "$gentop/$newobj"
5584
 
              oldobjs="$oldobjs $gentop/$newobj"
 
9170
              func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
 
9171
              func_append oldobjs " $gentop/$newobj"
5585
9172
              ;;
5586
 
            *) oldobjs="$oldobjs $obj" ;;
 
9173
            *) func_append oldobjs " $obj" ;;
5587
9174
            esac
5588
9175
          done
5589
9176
        fi
5590
 
 
 
9177
        func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
 
9178
        tool_oldlib=$func_to_tool_file_result
5591
9179
        eval cmds=\"$old_archive_cmds\"
5592
9180
 
5593
 
        if len=`expr "X$cmds" : ".*"` &&
5594
 
             test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 
9181
        func_len " $cmds"
 
9182
        len=$func_len_result
 
9183
        if test "$len" -lt "$max_cmd_len" || test "$max_cmd_len" -le -1; then
 
9184
          cmds=$old_archive_cmds
 
9185
        elif test -n "$archiver_list_spec"; then
 
9186
          func_verbose "using command file archive linking..."
 
9187
          for obj in $oldobjs
 
9188
          do
 
9189
            func_to_tool_file "$obj"
 
9190
            $ECHO "$func_to_tool_file_result"
 
9191
          done > $output_objdir/$libname.libcmd
 
9192
          func_to_tool_file "$output_objdir/$libname.libcmd"
 
9193
          oldobjs=" $archiver_list_spec$func_to_tool_file_result"
5595
9194
          cmds=$old_archive_cmds
5596
9195
        else
5597
9196
          # the command line is too long to link in one step, link in parts
5598
 
          $echo "using piecewise archive linking..."
 
9197
          func_verbose "using piecewise archive linking..."
5599
9198
          save_RANLIB=$RANLIB
5600
9199
          RANLIB=:
5601
9200
          objlist=
5602
9201
          concat_cmds=
5603
9202
          save_oldobjs=$oldobjs
5604
 
 
 
9203
          oldobjs=
5605
9204
          # Is there a better way of finding the last object in the list?
5606
9205
          for obj in $save_oldobjs
5607
9206
          do
5608
9207
            last_oldobj=$obj
5609
9208
          done
 
9209
          eval test_cmds=\"$old_archive_cmds\"
 
9210
          func_len " $test_cmds"
 
9211
          len0=$func_len_result
 
9212
          len=$len0
5610
9213
          for obj in $save_oldobjs
5611
9214
          do
5612
 
            oldobjs="$objlist $obj"
5613
 
            objlist="$objlist $obj"
5614
 
            eval test_cmds=\"$old_archive_cmds\"
5615
 
            if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
5616
 
               test "$len" -le "$max_cmd_len"; then
 
9215
            func_len " $obj"
 
9216
            func_arith $len + $func_len_result
 
9217
            len=$func_arith_result
 
9218
            func_append objlist " $obj"
 
9219
            if test "$len" -lt "$max_cmd_len"; then
5617
9220
              :
5618
9221
            else
5619
9222
              # the above command should be used before it gets too long
5620
9223
              oldobjs=$objlist
5621
9224
              if test "$obj" = "$last_oldobj" ; then
5622
 
                RANLIB=$save_RANLIB
 
9225
                RANLIB=$save_RANLIB
5623
9226
              fi
5624
9227
              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
5625
9228
              eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
5626
9229
              objlist=
 
9230
              len=$len0
5627
9231
            fi
5628
9232
          done
5629
9233
          RANLIB=$save_RANLIB
5635
9239
          fi
5636
9240
        fi
5637
9241
      fi
5638
 
      save_ifs="$IFS"; IFS='~'
5639
 
      for cmd in $cmds; do
5640
 
        eval cmd=\"$cmd\"
5641
 
        IFS="$save_ifs"
5642
 
        $show "$cmd"
5643
 
        $run eval "$cmd" || exit $?
5644
 
      done
5645
 
      IFS="$save_ifs"
 
9242
      func_execute_cmds "$cmds" 'exit $?'
5646
9243
    done
5647
9244
 
5648
 
    if test -n "$generated"; then
5649
 
      $show "${rm}r$generated"
5650
 
      $run ${rm}r$generated
5651
 
    fi
 
9245
    test -n "$generated" && \
 
9246
      func_show_eval "${RM}r$generated"
5652
9247
 
5653
9248
    # Now create the libtool archive.
5654
9249
    case $output in
5655
9250
    *.la)
5656
9251
      old_library=
5657
9252
      test "$build_old_libs" = yes && old_library="$libname.$libext"
5658
 
      $show "creating $output"
 
9253
      func_verbose "creating $output"
5659
9254
 
5660
9255
      # Preserve any variables that may affect compiler behavior
5661
9256
      for var in $variables_saved_for_relink; do
5662
9257
        if eval test -z \"\${$var+set}\"; then
5663
 
          relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
 
9258
          relink_command="{ test -z \"\${$var+set}\" || $lt_unset $var || { $var=; export $var; }; }; $relink_command"
5664
9259
        elif eval var_value=\$$var; test -z "$var_value"; then
5665
9260
          relink_command="$var=; export $var; $relink_command"
5666
9261
        else
5667
 
          var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
5668
 
          relink_command="$var=\"$var_value\"; export $var; $relink_command"
 
9262
          func_quote_for_eval "$var_value"
 
9263
          relink_command="$var=$func_quote_for_eval_result; export $var; $relink_command"
5669
9264
        fi
5670
9265
      done
5671
9266
      # Quote the link command for shipping.
5672
9267
      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
5673
 
      relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
 
9268
      relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
5674
9269
      if test "$hardcode_automatic" = yes ; then
5675
9270
        relink_command=
5676
9271
      fi
5677
9272
 
5678
 
 
5679
9273
      # Only create the output if not a dry run.
5680
 
      if test -z "$run"; then
 
9274
      $opt_dry_run || {
5681
9275
        for installed in no yes; do
5682
9276
          if test "$installed" = yes; then
5683
9277
            if test -z "$install_libdir"; then
5689
9283
            for deplib in $dependency_libs; do
5690
9284
              case $deplib in
5691
9285
              *.la)
5692
 
                name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5693
 
                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5694
 
                if test -z "$libdir"; then
5695
 
                  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5696
 
                  exit $EXIT_FAILURE
5697
 
                fi
5698
 
                newdependency_libs="$newdependency_libs $libdir/$name"
5699
 
                ;;
5700
 
              *) newdependency_libs="$newdependency_libs $deplib" ;;
 
9286
                func_basename "$deplib"
 
9287
                name="$func_basename_result"
 
9288
                func_resolve_sysroot "$deplib"
 
9289
                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $func_resolve_sysroot_result`
 
9290
                test -z "$libdir" && \
 
9291
                  func_fatal_error "\`$deplib' is not a valid libtool archive"
 
9292
                func_append newdependency_libs " ${lt_sysroot:+=}$libdir/$name"
 
9293
                ;;
 
9294
              -L*)
 
9295
                func_stripname -L '' "$deplib"
 
9296
                func_replace_sysroot "$func_stripname_result"
 
9297
                func_append newdependency_libs " -L$func_replace_sysroot_result"
 
9298
                ;;
 
9299
              -R*)
 
9300
                func_stripname -R '' "$deplib"
 
9301
                func_replace_sysroot "$func_stripname_result"
 
9302
                func_append newdependency_libs " -R$func_replace_sysroot_result"
 
9303
                ;;
 
9304
              *) func_append newdependency_libs " $deplib" ;;
5701
9305
              esac
5702
9306
            done
5703
9307
            dependency_libs="$newdependency_libs"
5704
9308
            newdlfiles=
 
9309
 
5705
9310
            for lib in $dlfiles; do
5706
 
              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5707
 
              eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5708
 
              if test -z "$libdir"; then
5709
 
                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5710
 
                exit $EXIT_FAILURE
5711
 
              fi
5712
 
              newdlfiles="$newdlfiles $libdir/$name"
 
9311
              case $lib in
 
9312
              *.la)
 
9313
                func_basename "$lib"
 
9314
                name="$func_basename_result"
 
9315
                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
 
9316
                test -z "$libdir" && \
 
9317
                  func_fatal_error "\`$lib' is not a valid libtool archive"
 
9318
                func_append newdlfiles " ${lt_sysroot:+=}$libdir/$name"
 
9319
                ;;
 
9320
              *) func_append newdlfiles " $lib" ;;
 
9321
              esac
5713
9322
            done
5714
9323
            dlfiles="$newdlfiles"
5715
9324
            newdlprefiles=
5716
9325
            for lib in $dlprefiles; do
5717
 
              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5718
 
              eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5719
 
              if test -z "$libdir"; then
5720
 
                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5721
 
                exit $EXIT_FAILURE
5722
 
              fi
5723
 
              newdlprefiles="$newdlprefiles $libdir/$name"
 
9326
              case $lib in
 
9327
              *.la)
 
9328
                # Only pass preopened files to the pseudo-archive (for
 
9329
                # eventual linking with the app. that links it) if we
 
9330
                # didn't already link the preopened objects directly into
 
9331
                # the library:
 
9332
                func_basename "$lib"
 
9333
                name="$func_basename_result"
 
9334
                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
 
9335
                test -z "$libdir" && \
 
9336
                  func_fatal_error "\`$lib' is not a valid libtool archive"
 
9337
                func_append newdlprefiles " ${lt_sysroot:+=}$libdir/$name"
 
9338
                ;;
 
9339
              esac
5724
9340
            done
5725
9341
            dlprefiles="$newdlprefiles"
5726
9342
          else
5730
9346
                [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5731
9347
                *) abs=`pwd`"/$lib" ;;
5732
9348
              esac
5733
 
              newdlfiles="$newdlfiles $abs"
 
9349
              func_append newdlfiles " $abs"
5734
9350
            done
5735
9351
            dlfiles="$newdlfiles"
5736
9352
            newdlprefiles=
5739
9355
                [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5740
9356
                *) abs=`pwd`"/$lib" ;;
5741
9357
              esac
5742
 
              newdlprefiles="$newdlprefiles $abs"
 
9358
              func_append newdlprefiles " $abs"
5743
9359
            done
5744
9360
            dlprefiles="$newdlprefiles"
5745
9361
          fi
5746
 
          $rm $output
 
9362
          $RM $output
5747
9363
          # place dlname in correct position for cygwin
 
9364
          # In fact, it would be nice if we could use this code for all target
 
9365
          # systems that can't hard-code library paths into their executables
 
9366
          # and that have no shared library path variable independent of PATH,
 
9367
          # but it turns out we can't easily determine that from inspecting
 
9368
          # libtool variables, so we have to hard-code the OSs to which it
 
9369
          # applies here; at the moment, that means platforms that use the PE
 
9370
          # object format with DLL files.  See the long comment at the top of
 
9371
          # tests/bindir.at for full details.
5748
9372
          tdlname=$dlname
5749
9373
          case $host,$output,$installed,$module,$dlname in
5750
 
            *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
 
9374
            *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll | *cegcc*,*lai,yes,no,*.dll)
 
9375
              # If a -bindir argument was supplied, place the dll there.
 
9376
              if test "x$bindir" != x ;
 
9377
              then
 
9378
                func_relative_path "$install_libdir" "$bindir"
 
9379
                tdlname=$func_relative_path_result$dlname
 
9380
              else
 
9381
                # Otherwise fall back on heuristic.
 
9382
                tdlname=../bin/$dlname
 
9383
              fi
 
9384
              ;;
5751
9385
          esac
5752
 
          $echo > $output "\
 
9386
          $ECHO > $output "\
5753
9387
# $outputname - a libtool library file
5754
 
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 
9388
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
5755
9389
#
5756
9390
# Please DO NOT delete this file!
5757
9391
# It is necessary for linking the library.
5765
9399
# The name of the static archive.
5766
9400
old_library='$old_library'
5767
9401
 
 
9402
# Linker flags that can not go in dependency_libs.
 
9403
inherited_linker_flags='$new_inherited_linker_flags'
 
9404
 
5768
9405
# Libraries that this one depends upon.
5769
9406
dependency_libs='$dependency_libs'
5770
9407
 
 
9408
# Names of additional weak libraries provided by this library
 
9409
weak_library_names='$weak_libs'
 
9410
 
5771
9411
# Version information for $libname.
5772
9412
current=$current
5773
9413
age=$age
5786
9426
# Directory that this library needs to be installed in:
5787
9427
libdir='$install_libdir'"
5788
9428
          if test "$installed" = no && test "$need_relink" = yes; then
5789
 
            $echo >> $output "\
 
9429
            $ECHO >> $output "\
5790
9430
relink_command=\"$relink_command\""
5791
9431
          fi
5792
9432
        done
5793
 
      fi
 
9433
      }
5794
9434
 
5795
9435
      # Do a symbolic link so that the libtool archive can be found in
5796
9436
      # LD_LIBRARY_PATH before the program is installed.
5797
 
      $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5798
 
      $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5799
 
      ;;
5800
 
    esac
5801
 
    exit $EXIT_SUCCESS
5802
 
    ;;
5803
 
 
5804
 
  # libtool install mode
5805
 
  install)
5806
 
    modename="$modename: install"
5807
 
 
5808
 
    # There may be an optional sh(1) argument at the beginning of
5809
 
    # install_prog (especially on Windows NT).
5810
 
    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5811
 
       # Allow the use of GNU shtool's install command.
5812
 
       $echo "X$nonopt" | grep shtool > /dev/null; then
5813
 
      # Aesthetically quote it.
5814
 
      arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5815
 
      case $arg in
5816
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
5817
 
        arg="\"$arg\""
5818
 
        ;;
5819
 
      esac
5820
 
      install_prog="$arg "
5821
 
      arg="$1"
5822
 
      shift
5823
 
    else
5824
 
      install_prog=
5825
 
      arg=$nonopt
5826
 
    fi
5827
 
 
5828
 
    # The real first argument should be the name of the installation program.
5829
 
    # Aesthetically quote it.
5830
 
    arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5831
 
    case $arg in
5832
 
    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
5833
 
      arg="\"$arg\""
5834
 
      ;;
5835
 
    esac
5836
 
    install_prog="$install_prog$arg"
5837
 
 
5838
 
    # We need to accept at least all the BSD install flags.
5839
 
    dest=
5840
 
    files=
5841
 
    opts=
5842
 
    prev=
5843
 
    install_type=
5844
 
    isdir=no
5845
 
    stripme=
5846
 
    for arg
5847
 
    do
5848
 
      if test -n "$dest"; then
5849
 
        files="$files $dest"
5850
 
        dest=$arg
5851
 
        continue
5852
 
      fi
5853
 
 
5854
 
      case $arg in
5855
 
      -d) isdir=yes ;;
5856
 
      -f) 
5857
 
        case " $install_prog " in
5858
 
        *[\\\ /]cp\ *) ;;
5859
 
        *) prev=$arg ;;
5860
 
        esac
5861
 
        ;;
5862
 
      -g | -m | -o) prev=$arg ;;
5863
 
      -s)
5864
 
        stripme=" -s"
5865
 
        continue
5866
 
        ;;
5867
 
      -*)
5868
 
        ;;
5869
 
      *)
5870
 
        # If the previous option needed an argument, then skip it.
5871
 
        if test -n "$prev"; then
5872
 
          prev=
5873
 
        else
5874
 
          dest=$arg
5875
 
          continue
5876
 
        fi
5877
 
        ;;
5878
 
      esac
5879
 
 
5880
 
      # Aesthetically quote the argument.
5881
 
      arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5882
 
      case $arg in
5883
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
5884
 
        arg="\"$arg\""
5885
 
        ;;
5886
 
      esac
5887
 
      install_prog="$install_prog $arg"
5888
 
    done
5889
 
 
5890
 
    if test -z "$install_prog"; then
5891
 
      $echo "$modename: you must specify an install program" 1>&2
5892
 
      $echo "$help" 1>&2
5893
 
      exit $EXIT_FAILURE
5894
 
    fi
5895
 
 
5896
 
    if test -n "$prev"; then
5897
 
      $echo "$modename: the \`$prev' option requires an argument" 1>&2
5898
 
      $echo "$help" 1>&2
5899
 
      exit $EXIT_FAILURE
5900
 
    fi
5901
 
 
5902
 
    if test -z "$files"; then
5903
 
      if test -z "$dest"; then
5904
 
        $echo "$modename: no file or destination specified" 1>&2
5905
 
      else
5906
 
        $echo "$modename: you must specify a destination" 1>&2
5907
 
      fi
5908
 
      $echo "$help" 1>&2
5909
 
      exit $EXIT_FAILURE
5910
 
    fi
5911
 
 
5912
 
    # Strip any trailing slash from the destination.
5913
 
    dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5914
 
 
5915
 
    # Check to see that the destination is a directory.
5916
 
    test -d "$dest" && isdir=yes
5917
 
    if test "$isdir" = yes; then
5918
 
      destdir="$dest"
5919
 
      destname=
5920
 
    else
5921
 
      destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5922
 
      test "X$destdir" = "X$dest" && destdir=.
5923
 
      destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5924
 
 
5925
 
      # Not a directory, so check to see that there is only one file specified.
5926
 
      set dummy $files
5927
 
      if test "$#" -gt 2; then
5928
 
        $echo "$modename: \`$dest' is not a directory" 1>&2
5929
 
        $echo "$help" 1>&2
5930
 
        exit $EXIT_FAILURE
5931
 
      fi
5932
 
    fi
5933
 
    case $destdir in
5934
 
    [\\/]* | [A-Za-z]:[\\/]*) ;;
5935
 
    *)
5936
 
      for file in $files; do
5937
 
        case $file in
5938
 
        *.lo) ;;
5939
 
        *)
5940
 
          $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5941
 
          $echo "$help" 1>&2
5942
 
          exit $EXIT_FAILURE
5943
 
          ;;
5944
 
        esac
5945
 
      done
5946
 
      ;;
5947
 
    esac
5948
 
 
5949
 
    # This variable tells wrapper scripts just to set variables rather
5950
 
    # than running their programs.
5951
 
    libtool_install_magic="$magic"
5952
 
 
5953
 
    staticlibs=
5954
 
    future_libdirs=
5955
 
    current_libdirs=
5956
 
    for file in $files; do
5957
 
 
5958
 
      # Do each installation.
5959
 
      case $file in
5960
 
      *.$libext)
5961
 
        # Do the static libraries later.
5962
 
        staticlibs="$staticlibs $file"
5963
 
        ;;
5964
 
 
5965
 
      *.la)
5966
 
        # Check to see that this really is a libtool archive.
5967
 
        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5968
 
        else
5969
 
          $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5970
 
          $echo "$help" 1>&2
5971
 
          exit $EXIT_FAILURE
5972
 
        fi
5973
 
 
5974
 
        library_names=
5975
 
        old_library=
5976
 
        relink_command=
5977
 
        # If there is no directory component, then add one.
5978
 
        case $file in
5979
 
        */* | *\\*) . $file ;;
5980
 
        *) . ./$file ;;
5981
 
        esac
5982
 
 
5983
 
        # Add the libdir to current_libdirs if it is the destination.
5984
 
        if test "X$destdir" = "X$libdir"; then
5985
 
          case "$current_libdirs " in
5986
 
          *" $libdir "*) ;;
5987
 
          *) current_libdirs="$current_libdirs $libdir" ;;
5988
 
          esac
5989
 
        else
5990
 
          # Note the libdir as a future libdir.
5991
 
          case "$future_libdirs " in
5992
 
          *" $libdir "*) ;;
5993
 
          *) future_libdirs="$future_libdirs $libdir" ;;
5994
 
          esac
5995
 
        fi
5996
 
 
5997
 
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5998
 
        test "X$dir" = "X$file/" && dir=
5999
 
        dir="$dir$objdir"
6000
 
 
6001
 
        if test -n "$relink_command"; then
6002
 
          # Determine the prefix the user has applied to our future dir.
6003
 
          inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
6004
 
 
6005
 
          # Don't allow the user to place us outside of our expected
6006
 
          # location b/c this prevents finding dependent libraries that
6007
 
          # are installed to the same prefix.
6008
 
          # At present, this check doesn't affect windows .dll's that
6009
 
          # are installed into $libdir/../bin (currently, that works fine)
6010
 
          # but it's something to keep an eye on.
6011
 
          if test "$inst_prefix_dir" = "$destdir"; then
6012
 
            $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
6013
 
            exit $EXIT_FAILURE
6014
 
          fi
6015
 
 
6016
 
          if test -n "$inst_prefix_dir"; then
6017
 
            # Stick the inst_prefix_dir data into the link command.
6018
 
            relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%" | $NL2SP`
6019
 
          else
6020
 
            relink_command=`$echo "$relink_command" | $SP2NL | $SED "s%@inst_prefix_dir@%%" | $NL2SP`
6021
 
          fi
6022
 
 
6023
 
          $echo "$modename: warning: relinking \`$file'" 1>&2
6024
 
          $show "$relink_command"
6025
 
          if $run eval "$relink_command"; then :
6026
 
          else
6027
 
            $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6028
 
            exit $EXIT_FAILURE
6029
 
          fi
6030
 
        fi
6031
 
 
6032
 
        # See the names of the shared library.
6033
 
        set dummy $library_names
6034
 
        if test -n "$2"; then
6035
 
          realname="$2"
6036
 
          shift
6037
 
          shift
6038
 
 
6039
 
          srcname="$realname"
6040
 
          test -n "$relink_command" && srcname="$realname"T
6041
 
 
6042
 
          # Install the shared library and build the symlinks.
6043
 
          $show "$install_prog $dir/$srcname $destdir/$realname"
6044
 
          $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
6045
 
          if test -n "$stripme" && test -n "$striplib"; then
6046
 
            $show "$striplib $destdir/$realname"
6047
 
            $run eval "$striplib $destdir/$realname" || exit $?
6048
 
          fi
6049
 
 
6050
 
          if test "$#" -gt 0; then
6051
 
            # Delete the old symlinks, and create new ones.
6052
 
            # Try `ln -sf' first, because the `ln' binary might depend on
6053
 
            # the symlink we replace!  Solaris /bin/ln does not understand -f,
6054
 
            # so we also need to try rm && ln -s.
6055
 
            for linkname
6056
 
            do
6057
 
              if test "$linkname" != "$realname"; then
6058
 
                $show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
6059
 
                $run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
6060
 
              fi
6061
 
            done
6062
 
          fi
6063
 
 
6064
 
          # Do each command in the postinstall commands.
6065
 
          lib="$destdir/$realname"
6066
 
          cmds=$postinstall_cmds
6067
 
          save_ifs="$IFS"; IFS='~'
6068
 
          for cmd in $cmds; do
6069
 
            IFS="$save_ifs"
6070
 
            eval cmd=\"$cmd\"
6071
 
            $show "$cmd"
6072
 
            $run eval "$cmd" || {
6073
 
              lt_exit=$?
6074
 
 
6075
 
              # Restore the uninstalled library and exit
6076
 
              if test "$mode" = relink; then
6077
 
                $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
6078
 
              fi
6079
 
 
6080
 
              exit $lt_exit
6081
 
            }
6082
 
          done
6083
 
          IFS="$save_ifs"
6084
 
        fi
6085
 
 
6086
 
        # Install the pseudo-library for information purposes.
6087
 
        name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6088
 
        instname="$dir/$name"i
6089
 
        $show "$install_prog $instname $destdir/$name"
6090
 
        $run eval "$install_prog $instname $destdir/$name" || exit $?
6091
 
 
6092
 
        # Maybe install the static library, too.
6093
 
        test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
6094
 
        ;;
6095
 
 
6096
 
      *.lo)
6097
 
        # Install (i.e. copy) a libtool object.
6098
 
 
6099
 
        # Figure out destination file name, if it wasn't already specified.
6100
 
        if test -n "$destname"; then
6101
 
          destfile="$destdir/$destname"
6102
 
        else
6103
 
          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6104
 
          destfile="$destdir/$destfile"
6105
 
        fi
6106
 
 
6107
 
        # Deduce the name of the destination old-style object file.
6108
 
        case $destfile in
6109
 
        *.lo)
6110
 
          staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
6111
 
          ;;
6112
 
        *.$objext)
6113
 
          staticdest="$destfile"
6114
 
          destfile=
6115
 
          ;;
6116
 
        *)
6117
 
          $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
6118
 
          $echo "$help" 1>&2
6119
 
          exit $EXIT_FAILURE
6120
 
          ;;
6121
 
        esac
6122
 
 
6123
 
        # Install the libtool object if requested.
6124
 
        if test -n "$destfile"; then
6125
 
          $show "$install_prog $file $destfile"
6126
 
          $run eval "$install_prog $file $destfile" || exit $?
6127
 
        fi
6128
 
 
6129
 
        # Install the old object if enabled.
6130
 
        if test "$build_old_libs" = yes; then
6131
 
          # Deduce the name of the old-style object file.
6132
 
          staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
6133
 
 
6134
 
          $show "$install_prog $staticobj $staticdest"
6135
 
          $run eval "$install_prog \$staticobj \$staticdest" || exit $?
6136
 
        fi
6137
 
        exit $EXIT_SUCCESS
6138
 
        ;;
6139
 
 
6140
 
      *)
6141
 
        # Figure out destination file name, if it wasn't already specified.
6142
 
        if test -n "$destname"; then
6143
 
          destfile="$destdir/$destname"
6144
 
        else
6145
 
          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6146
 
          destfile="$destdir/$destfile"
6147
 
        fi
6148
 
 
6149
 
        # If the file is missing, and there is a .exe on the end, strip it
6150
 
        # because it is most likely a libtool script we actually want to
6151
 
        # install
6152
 
        stripped_ext=""
6153
 
        case $file in
6154
 
          *.exe)
6155
 
            if test ! -f "$file"; then
6156
 
              file=`$echo $file|${SED} 's,.exe$,,'`
6157
 
              stripped_ext=".exe"
6158
 
            fi
6159
 
            ;;
6160
 
        esac
6161
 
 
6162
 
        # Do a test to see if this is really a libtool program.
6163
 
        case $host in
6164
 
        *cygwin*|*mingw*)
6165
 
            wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
6166
 
            ;;
6167
 
        *)
6168
 
            wrapper=$file
6169
 
            ;;
6170
 
        esac
6171
 
        if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
6172
 
          notinst_deplibs=
6173
 
          relink_command=
6174
 
 
6175
 
          # Note that it is not necessary on cygwin/mingw to append a dot to
6176
 
          # foo even if both foo and FILE.exe exist: automatic-append-.exe
6177
 
          # behavior happens only for exec(3), not for open(2)!  Also, sourcing
6178
 
          # `FILE.' does not work on cygwin managed mounts.
6179
 
          #
6180
 
          # If there is no directory component, then add one.
6181
 
          case $wrapper in
6182
 
          */* | *\\*) . ${wrapper} ;;
6183
 
          *) . ./${wrapper} ;;
6184
 
          esac
6185
 
 
6186
 
          # Check the variables that should have been set.
6187
 
          if test -z "$notinst_deplibs"; then
6188
 
            $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
6189
 
            exit $EXIT_FAILURE
6190
 
          fi
6191
 
 
6192
 
          finalize=yes
6193
 
          for lib in $notinst_deplibs; do
6194
 
            # Check to see that each library is installed.
6195
 
            libdir=
6196
 
            if test -f "$lib"; then
6197
 
              # If there is no directory component, then add one.
6198
 
              case $lib in
6199
 
              */* | *\\*) . $lib ;;
6200
 
              *) . ./$lib ;;
6201
 
              esac
6202
 
            fi
6203
 
            libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
6204
 
            if test -n "$libdir" && test ! -f "$libfile"; then
6205
 
              $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
6206
 
              finalize=no
6207
 
            fi
6208
 
          done
6209
 
 
6210
 
          relink_command=
6211
 
          # Note that it is not necessary on cygwin/mingw to append a dot to
6212
 
          # foo even if both foo and FILE.exe exist: automatic-append-.exe
6213
 
          # behavior happens only for exec(3), not for open(2)!  Also, sourcing
6214
 
          # `FILE.' does not work on cygwin managed mounts.
6215
 
          #
6216
 
          # If there is no directory component, then add one.
6217
 
          case $wrapper in
6218
 
          */* | *\\*) . ${wrapper} ;;
6219
 
          *) . ./${wrapper} ;;
6220
 
          esac
6221
 
 
6222
 
          outputname=
6223
 
          if test "$fast_install" = no && test -n "$relink_command"; then
6224
 
            if test "$finalize" = yes && test -z "$run"; then
6225
 
              tmpdir=`func_mktempdir`
6226
 
              file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
6227
 
              outputname="$tmpdir/$file"
6228
 
              # Replace the output file specification.
6229
 
              relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g' | $NL2SP`
6230
 
 
6231
 
              $show "$relink_command"
6232
 
              if $run eval "$relink_command"; then :
6233
 
              else
6234
 
                $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
6235
 
                ${rm}r "$tmpdir"
6236
 
                continue
6237
 
              fi
6238
 
              file="$outputname"
6239
 
            else
6240
 
              $echo "$modename: warning: cannot relink \`$file'" 1>&2
6241
 
            fi
6242
 
          else
6243
 
            # Install the binary that we compiled earlier.
6244
 
            file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
6245
 
          fi
6246
 
        fi
6247
 
 
6248
 
        # remove .exe since cygwin /usr/bin/install will append another
6249
 
        # one anyway 
6250
 
        case $install_prog,$host in
6251
 
        */usr/bin/install*,*cygwin*)
6252
 
          case $file:$destfile in
6253
 
          *.exe:*.exe)
6254
 
            # this is ok
6255
 
            ;;
6256
 
          *.exe:*)
6257
 
            destfile=$destfile.exe
6258
 
            ;;
6259
 
          *:*.exe)
6260
 
            destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
6261
 
            ;;
6262
 
          esac
6263
 
          ;;
6264
 
        esac
6265
 
        $show "$install_prog$stripme $file $destfile"
6266
 
        $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
6267
 
        test -n "$outputname" && ${rm}r "$tmpdir"
6268
 
        ;;
6269
 
      esac
6270
 
    done
6271
 
 
6272
 
    for file in $staticlibs; do
6273
 
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6274
 
 
6275
 
      # Set up the ranlib parameters.
6276
 
      oldlib="$destdir/$name"
6277
 
 
6278
 
      $show "$install_prog $file $oldlib"
6279
 
      $run eval "$install_prog \$file \$oldlib" || exit $?
6280
 
 
6281
 
      if test -n "$stripme" && test -n "$old_striplib"; then
6282
 
        $show "$old_striplib $oldlib"
6283
 
        $run eval "$old_striplib $oldlib" || exit $?
6284
 
      fi
6285
 
 
6286
 
      # Do each command in the postinstall commands.
6287
 
      cmds=$old_postinstall_cmds
6288
 
      save_ifs="$IFS"; IFS='~'
6289
 
      for cmd in $cmds; do
6290
 
        IFS="$save_ifs"
6291
 
        eval cmd=\"$cmd\"
6292
 
        $show "$cmd"
6293
 
        $run eval "$cmd" || exit $?
6294
 
      done
6295
 
      IFS="$save_ifs"
6296
 
    done
6297
 
 
6298
 
    if test -n "$future_libdirs"; then
6299
 
      $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
6300
 
    fi
6301
 
 
6302
 
    if test -n "$current_libdirs"; then
6303
 
      # Maybe just do a dry run.
6304
 
      test -n "$run" && current_libdirs=" -n$current_libdirs"
6305
 
      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
6306
 
    else
6307
 
      exit $EXIT_SUCCESS
6308
 
    fi
6309
 
    ;;
6310
 
 
6311
 
  # libtool finish mode
6312
 
  finish)
6313
 
    modename="$modename: finish"
6314
 
    libdirs="$nonopt"
6315
 
    admincmds=
6316
 
 
6317
 
    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
6318
 
      for dir
6319
 
      do
6320
 
        libdirs="$libdirs $dir"
6321
 
      done
6322
 
 
6323
 
      for libdir in $libdirs; do
6324
 
        if test -n "$finish_cmds"; then
6325
 
          # Do each command in the finish commands.
6326
 
          cmds=$finish_cmds
6327
 
          save_ifs="$IFS"; IFS='~'
6328
 
          for cmd in $cmds; do
6329
 
            IFS="$save_ifs"
6330
 
            eval cmd=\"$cmd\"
6331
 
            $show "$cmd"
6332
 
            $run eval "$cmd" || admincmds="$admincmds
6333
 
       $cmd"
6334
 
          done
6335
 
          IFS="$save_ifs"
6336
 
        fi
6337
 
        if test -n "$finish_eval"; then
6338
 
          # Do the single finish_eval.
6339
 
          eval cmds=\"$finish_eval\"
6340
 
          $run eval "$cmds" || admincmds="$admincmds
6341
 
       $cmds"
6342
 
        fi
6343
 
      done
6344
 
    fi
6345
 
 
6346
 
    # Exit here if they wanted silent mode.
6347
 
    test "$show" = : && exit $EXIT_SUCCESS
6348
 
 
6349
 
    $echo "X----------------------------------------------------------------------" | $Xsed
6350
 
    $echo "Libraries have been installed in:"
6351
 
    for libdir in $libdirs; do
6352
 
      $echo "   $libdir"
6353
 
    done
6354
 
    $echo
6355
 
    $echo "If you ever happen to want to link against installed libraries"
6356
 
    $echo "in a given directory, LIBDIR, you must either use libtool, and"
6357
 
    $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
6358
 
    $echo "flag during linking and do at least one of the following:"
6359
 
    if test -n "$shlibpath_var"; then
6360
 
      $echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
6361
 
      $echo "     during execution"
6362
 
    fi
6363
 
    if test -n "$runpath_var"; then
6364
 
      $echo "   - add LIBDIR to the \`$runpath_var' environment variable"
6365
 
      $echo "     during linking"
6366
 
    fi
6367
 
    if test -n "$hardcode_libdir_flag_spec"; then
6368
 
      libdir=LIBDIR
6369
 
      eval flag=\"$hardcode_libdir_flag_spec\"
6370
 
 
6371
 
      $echo "   - use the \`$flag' linker flag"
6372
 
    fi
6373
 
    if test -n "$admincmds"; then
6374
 
      $echo "   - have your system administrator run these commands:$admincmds"
6375
 
    fi
6376
 
    if test -f /etc/ld.so.conf; then
6377
 
      $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
6378
 
    fi
6379
 
    $echo
6380
 
    $echo "See any operating system documentation about shared libraries for"
6381
 
    $echo "more information, such as the ld(1) and ld.so(8) manual pages."
6382
 
    $echo "X----------------------------------------------------------------------" | $Xsed
6383
 
    exit $EXIT_SUCCESS
6384
 
    ;;
6385
 
 
6386
 
  # libtool execute mode
6387
 
  execute)
6388
 
    modename="$modename: execute"
6389
 
 
6390
 
    # The first argument is the command name.
6391
 
    cmd="$nonopt"
6392
 
    if test -z "$cmd"; then
6393
 
      $echo "$modename: you must specify a COMMAND" 1>&2
6394
 
      $echo "$help"
6395
 
      exit $EXIT_FAILURE
6396
 
    fi
6397
 
 
6398
 
    # Handle -dlopen flags immediately.
6399
 
    for file in $execute_dlfiles; do
6400
 
      if test ! -f "$file"; then
6401
 
        $echo "$modename: \`$file' is not a file" 1>&2
6402
 
        $echo "$help" 1>&2
6403
 
        exit $EXIT_FAILURE
6404
 
      fi
6405
 
 
6406
 
      dir=
6407
 
      case $file in
6408
 
      *.la)
6409
 
        # Check to see that this really is a libtool archive.
6410
 
        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
6411
 
        else
6412
 
          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
6413
 
          $echo "$help" 1>&2
6414
 
          exit $EXIT_FAILURE
6415
 
        fi
6416
 
 
6417
 
        # Read the libtool library.
6418
 
        dlname=
6419
 
        library_names=
6420
 
 
6421
 
        # If there is no directory component, then add one.
6422
 
        case $file in
6423
 
        */* | *\\*) . $file ;;
6424
 
        *) . ./$file ;;
6425
 
        esac
6426
 
 
6427
 
        # Skip this library if it cannot be dlopened.
6428
 
        if test -z "$dlname"; then
6429
 
          # Warn if it was a shared library.
6430
 
          test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
6431
 
          continue
6432
 
        fi
6433
 
 
6434
 
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6435
 
        test "X$dir" = "X$file" && dir=.
6436
 
 
6437
 
        if test -f "$dir/$objdir/$dlname"; then
6438
 
          dir="$dir/$objdir"
6439
 
        else
6440
 
          if test ! -f "$dir/$dlname"; then
6441
 
            $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
6442
 
            exit $EXIT_FAILURE
6443
 
          fi
6444
 
        fi
6445
 
        ;;
6446
 
 
6447
 
      *.lo)
6448
 
        # Just add the directory containing the .lo file.
6449
 
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6450
 
        test "X$dir" = "X$file" && dir=.
6451
 
        ;;
6452
 
 
6453
 
      *)
6454
 
        $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
6455
 
        continue
6456
 
        ;;
6457
 
      esac
6458
 
 
6459
 
      # Get the absolute pathname.
6460
 
      absdir=`cd "$dir" && pwd`
6461
 
      test -n "$absdir" && dir="$absdir"
6462
 
 
6463
 
      # Now add the directory to shlibpath_var.
6464
 
      if eval "test -z \"\$$shlibpath_var\""; then
6465
 
        eval "$shlibpath_var=\"\$dir\""
6466
 
      else
6467
 
        eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
6468
 
      fi
6469
 
    done
6470
 
 
6471
 
    # This variable tells wrapper scripts just to set shlibpath_var
6472
 
    # rather than running their programs.
6473
 
    libtool_execute_magic="$magic"
6474
 
 
6475
 
    # Check if any of the arguments is a wrapper script.
6476
 
    args=
6477
 
    for file
6478
 
    do
6479
 
      case $file in
6480
 
      -*) ;;
6481
 
      *)
6482
 
        # Do a test to see if this is really a libtool program.
6483
 
        if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6484
 
          # If there is no directory component, then add one.
6485
 
          case $file in
6486
 
          */* | *\\*) . $file ;;
6487
 
          *) . ./$file ;;
6488
 
          esac
6489
 
 
6490
 
          # Transform arg to wrapped name.
6491
 
          file="$progdir/$program"
6492
 
        fi
6493
 
        ;;
6494
 
      esac
6495
 
      # Quote arguments (to preserve shell metacharacters).
6496
 
      file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
6497
 
      args="$args \"$file\""
6498
 
    done
6499
 
 
6500
 
    if test -z "$run"; then
6501
 
      if test -n "$shlibpath_var"; then
6502
 
        # Export the shlibpath_var.
6503
 
        eval "export $shlibpath_var"
6504
 
      fi
6505
 
 
6506
 
      # Restore saved environment variables
6507
 
      for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
6508
 
      do
6509
 
        eval "if test \"\${save_$lt_var+set}\" = set; then
6510
 
                $lt_var=\$save_$lt_var; export $lt_var
6511
 
              fi"
6512
 
      done
6513
 
 
6514
 
      # Now prepare to actually exec the command.
6515
 
      exec_cmd="\$cmd$args"
6516
 
    else
6517
 
      # Display what would be done.
6518
 
      if test -n "$shlibpath_var"; then
6519
 
        eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
6520
 
        $echo "export $shlibpath_var"
6521
 
      fi
6522
 
      $echo "$cmd$args"
6523
 
      exit $EXIT_SUCCESS
6524
 
    fi
6525
 
    ;;
6526
 
 
6527
 
  # libtool clean and uninstall mode
6528
 
  clean | uninstall)
6529
 
    modename="$modename: $mode"
6530
 
    rm="$nonopt"
 
9437
      func_show_eval '( cd "$output_objdir" && $RM "$outputname" && $LN_S "../$outputname" "$outputname" )' 'exit $?'
 
9438
      ;;
 
9439
    esac
 
9440
    exit $EXIT_SUCCESS
 
9441
}
 
9442
 
 
9443
{ test "$opt_mode" = link || test "$opt_mode" = relink; } &&
 
9444
    func_mode_link ${1+"$@"}
 
9445
 
 
9446
 
 
9447
# func_mode_uninstall arg...
 
9448
func_mode_uninstall ()
 
9449
{
 
9450
    $opt_debug
 
9451
    RM="$nonopt"
6531
9452
    files=
6532
9453
    rmforce=
6533
9454
    exit_status=0
6539
9460
    for arg
6540
9461
    do
6541
9462
      case $arg in
6542
 
      -f) rm="$rm $arg"; rmforce=yes ;;
6543
 
      -*) rm="$rm $arg" ;;
6544
 
      *) files="$files $arg" ;;
 
9463
      -f) func_append RM " $arg"; rmforce=yes ;;
 
9464
      -*) func_append RM " $arg" ;;
 
9465
      *) func_append files " $arg" ;;
6545
9466
      esac
6546
9467
    done
6547
9468
 
6548
 
    if test -z "$rm"; then
6549
 
      $echo "$modename: you must specify an RM program" 1>&2
6550
 
      $echo "$help" 1>&2
6551
 
      exit $EXIT_FAILURE
6552
 
    fi
 
9469
    test -z "$RM" && \
 
9470
      func_fatal_help "you must specify an RM program"
6553
9471
 
6554
9472
    rmdirs=
6555
9473
 
6556
 
    origobjdir="$objdir"
6557
9474
    for file in $files; do
6558
 
      dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6559
 
      if test "X$dir" = "X$file"; then
6560
 
        dir=.
6561
 
        objdir="$origobjdir"
 
9475
      func_dirname "$file" "" "."
 
9476
      dir="$func_dirname_result"
 
9477
      if test "X$dir" = X.; then
 
9478
        odir="$objdir"
6562
9479
      else
6563
 
        objdir="$dir/$origobjdir"
 
9480
        odir="$dir/$objdir"
6564
9481
      fi
6565
 
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6566
 
      test "$mode" = uninstall && objdir="$dir"
 
9482
      func_basename "$file"
 
9483
      name="$func_basename_result"
 
9484
      test "$opt_mode" = uninstall && odir="$dir"
6567
9485
 
6568
 
      # Remember objdir for removal later, being careful to avoid duplicates
6569
 
      if test "$mode" = clean; then
 
9486
      # Remember odir for removal later, being careful to avoid duplicates
 
9487
      if test "$opt_mode" = clean; then
6570
9488
        case " $rmdirs " in
6571
 
          *" $objdir "*) ;;
6572
 
          *) rmdirs="$rmdirs $objdir" ;;
 
9489
          *" $odir "*) ;;
 
9490
          *) func_append rmdirs " $odir" ;;
6573
9491
        esac
6574
9492
      fi
6575
9493
 
6576
9494
      # Don't error if the file doesn't exist and rm -f was used.
6577
 
      if (test -L "$file") >/dev/null 2>&1 \
6578
 
        || (test -h "$file") >/dev/null 2>&1 \
6579
 
        || test -f "$file"; then
 
9495
      if { test -L "$file"; } >/dev/null 2>&1 ||
 
9496
         { test -h "$file"; } >/dev/null 2>&1 ||
 
9497
         test -f "$file"; then
6580
9498
        :
6581
9499
      elif test -d "$file"; then
6582
9500
        exit_status=1
6590
9508
      case $name in
6591
9509
      *.la)
6592
9510
        # Possibly a libtool archive, so verify it.
6593
 
        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6594
 
          . $dir/$name
 
9511
        if func_lalib_p "$file"; then
 
9512
          func_source $dir/$name
6595
9513
 
6596
9514
          # Delete the libtool libraries and symlinks.
6597
9515
          for n in $library_names; do
6598
 
            rmfiles="$rmfiles $objdir/$n"
 
9516
            func_append rmfiles " $odir/$n"
6599
9517
          done
6600
 
          test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
 
9518
          test -n "$old_library" && func_append rmfiles " $odir/$old_library"
6601
9519
 
6602
 
          case "$mode" in
 
9520
          case "$opt_mode" in
6603
9521
          clean)
6604
 
            case "  $library_names " in
6605
 
            # "  " in the beginning catches empty $dlname
 
9522
            case " $library_names " in
6606
9523
            *" $dlname "*) ;;
6607
 
            *) rmfiles="$rmfiles $objdir/$dlname" ;;
 
9524
            *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
6608
9525
            esac
6609
 
             test -n "$libdir" && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
 
9526
            test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
6610
9527
            ;;
6611
9528
          uninstall)
6612
9529
            if test -n "$library_names"; then
6613
9530
              # Do each command in the postuninstall commands.
6614
 
              cmds=$postuninstall_cmds
6615
 
              save_ifs="$IFS"; IFS='~'
6616
 
              for cmd in $cmds; do
6617
 
                IFS="$save_ifs"
6618
 
                eval cmd=\"$cmd\"
6619
 
                $show "$cmd"
6620
 
                $run eval "$cmd"
6621
 
                if test "$?" -ne 0 && test "$rmforce" != yes; then
6622
 
                  exit_status=1
6623
 
                fi
6624
 
              done
6625
 
              IFS="$save_ifs"
 
9531
              func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
6626
9532
            fi
6627
9533
 
6628
9534
            if test -n "$old_library"; then
6629
9535
              # Do each command in the old_postuninstall commands.
6630
 
              cmds=$old_postuninstall_cmds
6631
 
              save_ifs="$IFS"; IFS='~'
6632
 
              for cmd in $cmds; do
6633
 
                IFS="$save_ifs"
6634
 
                eval cmd=\"$cmd\"
6635
 
                $show "$cmd"
6636
 
                $run eval "$cmd"
6637
 
                if test "$?" -ne 0 && test "$rmforce" != yes; then
6638
 
                  exit_status=1
6639
 
                fi
6640
 
              done
6641
 
              IFS="$save_ifs"
 
9536
              func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
6642
9537
            fi
6643
9538
            # FIXME: should reinstall the best remaining shared library.
6644
9539
            ;;
6648
9543
 
6649
9544
      *.lo)
6650
9545
        # Possibly a libtool object, so verify it.
6651
 
        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 
9546
        if func_lalib_p "$file"; then
6652
9547
 
6653
9548
          # Read the .lo file
6654
 
          . $dir/$name
 
9549
          func_source $dir/$name
6655
9550
 
6656
9551
          # Add PIC object to the list of files to remove.
6657
 
          if test -n "$pic_object" \
6658
 
             && test "$pic_object" != none; then
6659
 
            rmfiles="$rmfiles $dir/$pic_object"
 
9552
          if test -n "$pic_object" &&
 
9553
             test "$pic_object" != none; then
 
9554
            func_append rmfiles " $dir/$pic_object"
6660
9555
          fi
6661
9556
 
6662
9557
          # Add non-PIC object to the list of files to remove.
6663
 
          if test -n "$non_pic_object" \
6664
 
             && test "$non_pic_object" != none; then
6665
 
            rmfiles="$rmfiles $dir/$non_pic_object"
 
9558
          if test -n "$non_pic_object" &&
 
9559
             test "$non_pic_object" != none; then
 
9560
            func_append rmfiles " $dir/$non_pic_object"
6666
9561
          fi
6667
9562
        fi
6668
9563
        ;;
6669
9564
 
6670
9565
      *)
6671
 
        if test "$mode" = clean ; then
 
9566
        if test "$opt_mode" = clean ; then
6672
9567
          noexename=$name
6673
9568
          case $file in
6674
9569
          *.exe)
6675
 
            file=`$echo $file|${SED} 's,.exe$,,'`
6676
 
            noexename=`$echo $name|${SED} 's,.exe$,,'`
 
9570
            func_stripname '' '.exe' "$file"
 
9571
            file=$func_stripname_result
 
9572
            func_stripname '' '.exe' "$name"
 
9573
            noexename=$func_stripname_result
6677
9574
            # $file with .exe has already been added to rmfiles,
6678
9575
            # add $file without .exe
6679
 
            rmfiles="$rmfiles $file"
 
9576
            func_append rmfiles " $file"
6680
9577
            ;;
6681
9578
          esac
6682
9579
          # Do a test to see if this is a libtool program.
6683
 
          if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6684
 
            relink_command=
6685
 
            . $dir/$noexename
 
9580
          if func_ltwrapper_p "$file"; then
 
9581
            if func_ltwrapper_executable_p "$file"; then
 
9582
              func_ltwrapper_scriptname "$file"
 
9583
              relink_command=
 
9584
              func_source $func_ltwrapper_scriptname_result
 
9585
              func_append rmfiles " $func_ltwrapper_scriptname_result"
 
9586
            else
 
9587
              relink_command=
 
9588
              func_source $dir/$noexename
 
9589
            fi
6686
9590
 
6687
9591
            # note $name still contains .exe if it was in $file originally
6688
9592
            # as does the version of $file that was added into $rmfiles
6689
 
            rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
 
9593
            func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
6690
9594
            if test "$fast_install" = yes && test -n "$relink_command"; then
6691
 
              rmfiles="$rmfiles $objdir/lt-$name"
 
9595
              func_append rmfiles " $odir/lt-$name"
6692
9596
            fi
6693
9597
            if test "X$noexename" != "X$name" ; then
6694
 
              rmfiles="$rmfiles $objdir/lt-${noexename}.c"
 
9598
              func_append rmfiles " $odir/lt-${noexename}.c"
6695
9599
            fi
6696
9600
          fi
6697
9601
        fi
6698
9602
        ;;
6699
9603
      esac
6700
 
      $show "$rm $rmfiles"
6701
 
      $run $rm $rmfiles || exit_status=1
 
9604
      func_show_eval "$RM $rmfiles" 'exit_status=1'
6702
9605
    done
6703
 
    objdir="$origobjdir"
6704
9606
 
6705
9607
    # Try to remove the ${objdir}s in the directories where we deleted files
6706
9608
    for dir in $rmdirs; do
6707
9609
      if test -d "$dir"; then
6708
 
        $show "rmdir $dir"
6709
 
        $run rmdir $dir >/dev/null 2>&1
 
9610
        func_show_eval "rmdir $dir >/dev/null 2>&1"
6710
9611
      fi
6711
9612
    done
6712
9613
 
6713
9614
    exit $exit_status
6714
 
    ;;
6715
 
 
6716
 
  "")
6717
 
    $echo "$modename: you must specify a MODE" 1>&2
6718
 
    $echo "$generic_help" 1>&2
6719
 
    exit $EXIT_FAILURE
6720
 
    ;;
6721
 
  esac
6722
 
 
6723
 
  if test -z "$exec_cmd"; then
6724
 
    $echo "$modename: invalid operation mode \`$mode'" 1>&2
6725
 
    $echo "$generic_help" 1>&2
6726
 
    exit $EXIT_FAILURE
6727
 
  fi
6728
 
fi # test -z "$show_help"
 
9615
}
 
9616
 
 
9617
{ test "$opt_mode" = uninstall || test "$opt_mode" = clean; } &&
 
9618
    func_mode_uninstall ${1+"$@"}
 
9619
 
 
9620
test -z "$opt_mode" && {
 
9621
  help="$generic_help"
 
9622
  func_fatal_help "you must specify a MODE"
 
9623
}
 
9624
 
 
9625
test -z "$exec_cmd" && \
 
9626
  func_fatal_help "invalid operation mode \`$opt_mode'"
6729
9627
 
6730
9628
if test -n "$exec_cmd"; then
6731
 
  eval exec $exec_cmd
 
9629
  eval exec "$exec_cmd"
6732
9630
  exit $EXIT_FAILURE
6733
9631
fi
6734
9632
 
6735
 
# We need to display help for each of the modes.
6736
 
case $mode in
6737
 
"") $echo \
6738
 
"Usage: $modename [OPTION]... [MODE-ARG]...
6739
 
 
6740
 
Provide generalized library-building support services.
6741
 
 
6742
 
    --config          show all configuration variables
6743
 
    --debug           enable verbose shell tracing
6744
 
-n, --dry-run         display commands without modifying any files
6745
 
    --features        display basic configuration information and exit
6746
 
    --finish          same as \`--mode=finish'
6747
 
    --help            display this help message and exit
6748
 
    --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
6749
 
    --quiet           same as \`--silent'
6750
 
    --silent          don't print informational messages
6751
 
    --tag=TAG         use configuration variables from tag TAG
6752
 
    --version         print version information
6753
 
 
6754
 
MODE must be one of the following:
6755
 
 
6756
 
      clean           remove files from the build directory
6757
 
      compile         compile a source file into a libtool object
6758
 
      execute         automatically set library path, then run a program
6759
 
      finish          complete the installation of libtool libraries
6760
 
      install         install libraries or executables
6761
 
      link            create a library or an executable
6762
 
      uninstall       remove libraries from an installed directory
6763
 
 
6764
 
MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
6765
 
a more detailed description of MODE.
6766
 
 
6767
 
Report bugs to <bug-libtool@gnu.org>."
6768
 
  exit $EXIT_SUCCESS
6769
 
  ;;
6770
 
 
6771
 
clean)
6772
 
  $echo \
6773
 
"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
6774
 
 
6775
 
Remove files from the build directory.
6776
 
 
6777
 
RM is the name of the program to use to delete files associated with each FILE
6778
 
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6779
 
to RM.
6780
 
 
6781
 
If FILE is a libtool library, object or program, all the files associated
6782
 
with it are deleted. Otherwise, only FILE itself is deleted using RM."
6783
 
  ;;
6784
 
 
6785
 
compile)
6786
 
  $echo \
6787
 
"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
6788
 
 
6789
 
Compile a source file into a libtool library object.
6790
 
 
6791
 
This mode accepts the following additional options:
6792
 
 
6793
 
  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
6794
 
  -prefer-pic       try to building PIC objects only
6795
 
  -prefer-non-pic   try to building non-PIC objects only
6796
 
  -static           always build a \`.o' file suitable for static linking
6797
 
 
6798
 
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
6799
 
from the given SOURCEFILE.
6800
 
 
6801
 
The output file name is determined by removing the directory component from
6802
 
SOURCEFILE, then substituting the C source code suffix \`.c' with the
6803
 
library object suffix, \`.lo'."
6804
 
  ;;
6805
 
 
6806
 
execute)
6807
 
  $echo \
6808
 
"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
6809
 
 
6810
 
Automatically set library path, then run a program.
6811
 
 
6812
 
This mode accepts the following additional options:
6813
 
 
6814
 
  -dlopen FILE      add the directory containing FILE to the library path
6815
 
 
6816
 
This mode sets the library path environment variable according to \`-dlopen'
6817
 
flags.
6818
 
 
6819
 
If any of the ARGS are libtool executable wrappers, then they are translated
6820
 
into their corresponding uninstalled binary, and any of their required library
6821
 
directories are added to the library path.
6822
 
 
6823
 
Then, COMMAND is executed, with ARGS as arguments."
6824
 
  ;;
6825
 
 
6826
 
finish)
6827
 
  $echo \
6828
 
"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
6829
 
 
6830
 
Complete the installation of libtool libraries.
6831
 
 
6832
 
Each LIBDIR is a directory that contains libtool libraries.
6833
 
 
6834
 
The commands that this mode executes may require superuser privileges.  Use
6835
 
the \`--dry-run' option if you just want to see what would be executed."
6836
 
  ;;
6837
 
 
6838
 
install)
6839
 
  $echo \
6840
 
"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
6841
 
 
6842
 
Install executables or libraries.
6843
 
 
6844
 
INSTALL-COMMAND is the installation command.  The first component should be
6845
 
either the \`install' or \`cp' program.
6846
 
 
6847
 
The rest of the components are interpreted as arguments to that command (only
6848
 
BSD-compatible install options are recognized)."
6849
 
  ;;
6850
 
 
6851
 
link)
6852
 
  $echo \
6853
 
"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
6854
 
 
6855
 
Link object files or libraries together to form another library, or to
6856
 
create an executable program.
6857
 
 
6858
 
LINK-COMMAND is a command using the C compiler that you would use to create
6859
 
a program from several object files.
6860
 
 
6861
 
The following components of LINK-COMMAND are treated specially:
6862
 
 
6863
 
  -all-static       do not do any dynamic linking at all
6864
 
  -avoid-version    do not add a version suffix if possible
6865
 
  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
6866
 
  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
6867
 
  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
6868
 
  -export-symbols SYMFILE
6869
 
                    try to export only the symbols listed in SYMFILE
6870
 
  -export-symbols-regex REGEX
6871
 
                    try to export only the symbols matching REGEX
6872
 
  -LLIBDIR          search LIBDIR for required installed libraries
6873
 
  -lNAME            OUTPUT-FILE requires the installed library libNAME
6874
 
  -module           build a library that can dlopened
6875
 
  -no-fast-install  disable the fast-install mode
6876
 
  -no-install       link a not-installable executable
6877
 
  -no-undefined     declare that a library does not refer to external symbols
6878
 
  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
6879
 
  -objectlist FILE  Use a list of object files found in FILE to specify objects
6880
 
  -precious-files-regex REGEX
6881
 
                    don't remove output files matching REGEX
6882
 
  -release RELEASE  specify package release information
6883
 
  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
6884
 
  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
6885
 
  -static           do not do any dynamic linking of uninstalled libtool libraries
6886
 
  -static-libtool-libs
6887
 
                    do not do any dynamic linking of libtool libraries
6888
 
  -version-info CURRENT[:REVISION[:AGE]]
6889
 
                    specify library version info [each variable defaults to 0]
6890
 
 
6891
 
All other options (arguments beginning with \`-') are ignored.
6892
 
 
6893
 
Every other argument is treated as a filename.  Files ending in \`.la' are
6894
 
treated as uninstalled libtool libraries, other files are standard or library
6895
 
object files.
6896
 
 
6897
 
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
6898
 
only library objects (\`.lo' files) may be specified, and \`-rpath' is
6899
 
required, except when creating a convenience library.
6900
 
 
6901
 
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
6902
 
using \`ar' and \`ranlib', or on Windows using \`lib'.
6903
 
 
6904
 
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
6905
 
is created, otherwise an executable program is created."
6906
 
  ;;
6907
 
 
6908
 
uninstall)
6909
 
  $echo \
6910
 
"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
6911
 
 
6912
 
Remove libraries from an installation directory.
6913
 
 
6914
 
RM is the name of the program to use to delete files associated with each FILE
6915
 
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6916
 
to RM.
6917
 
 
6918
 
If FILE is a libtool library, all the files associated with it are deleted.
6919
 
Otherwise, only FILE itself is deleted using RM."
6920
 
  ;;
6921
 
 
6922
 
*)
6923
 
  $echo "$modename: invalid operation mode \`$mode'" 1>&2
6924
 
  $echo "$help" 1>&2
6925
 
  exit $EXIT_FAILURE
6926
 
  ;;
6927
 
esac
6928
 
 
6929
 
$echo
6930
 
$echo "Try \`$modename --help' for more information about other modes."
6931
 
 
6932
 
exit $?
 
9633
exit $exit_status
 
9634
 
6933
9635
 
6934
9636
# The TAGs below are defined such that we never get into a situation
6935
9637
# in which we disable both kinds of libraries.  Given conflicting
6943
9645
# configuration.  But we'll never go from static-only to shared-only.
6944
9646
 
6945
9647
# ### BEGIN LIBTOOL TAG CONFIG: disable-shared
6946
 
disable_libs=shared
 
9648
build_libtool_libs=no
 
9649
build_old_libs=yes
6947
9650
# ### END LIBTOOL TAG CONFIG: disable-shared
6948
9651
 
6949
9652
# ### BEGIN LIBTOOL TAG CONFIG: disable-static
6950
 
disable_libs=static
 
9653
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
6951
9654
# ### END LIBTOOL TAG CONFIG: disable-static
6952
9655
 
6953
9656
# Local Variables:
6954
9657
# mode:shell-script
6955
9658
# sh-indentation:2
6956
9659
# End:
 
9660
# vi:sw=2
 
9661