← Back to branch summary

~ubuntu-branches/ubuntu/trusty/ntp/trusty-proposed

« back to all changes in this revision

Viewing changes to sntp/ltmain.sh

  • Committer: Package Import Robot
  • Author(s): Matthias Klose
  • Date: 2013-04-03 07:21:01 UTC
  • mfrom: (4.1.12 sid)
  • Revision ID: package-import@ubuntu.com-20130403072101-v3vt8xcs18b6uhjf
Tags: 1:4.2.6.p5+dfsg-2ubuntu1
* New upstream version, fixing build failure in raring.
* Merge with Debian; remaining changes:
  + debian/ntp.conf, debian/ntpdate.default: Change default server to
    ntp.ubuntu.com.
  + debian/ntpdate.ifup: Stop ntp before running ntpdate when an interface
    comes up, then start again afterwards.
  + debian/ntp.init, debian/rules: Only stop when entering single user mode.
  + Add enforcing AppArmor profile:
    - debian/control: Add Conflicts/Replaces on apparmor-profiles.
    - debian/control: Add Suggests on apparmor.
    - debian/ntp.dirs: Add apparmor directories.
    - debian/ntp.preinst: Force complain on certain upgrades.
    - debian/ntp.postinst: Reload apparmor profile.
    - debian/ntp.postrm: Remove the force-complain file.
    - add debian/apparmor-profile*.
    - debian/rules: install apparmor-profile and apparmor-profile.tunable.
    - debian/README.Debian: Add note on AppArmor.
  + debian/{control,rules}: Add and enable hardened build for PIE.
  + debian/apparmor-profile: Adjust location of drift files.
  + debian/rules, debian/ntp.dirs, debian/source_ntp.py: Add apport hook.
  + debian/ntpdate-debian: Disregard empty ntp.conf files.
  + debian/ntp.preinst: Remove empty /etc/ntp.conf on fresh intallation.
  + debian/ntpdate.ifup: Fix interaction with openntpd.
  + debian/source_ntp.py: Add filter on AppArmor profile names to prevent
    false positives from denials originating in other packages.
  + debian/apparmor-profile: Add samba4 ntp signing socket to ntpd apparmor
    profile.
  + debian/apparmor-profile: adjust for IPv6.

Show diffs side-by-side

added added

removed removed

Lines of Context:
sntp/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
 
#
4
 
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005
5
 
# Free Software Foundation, Inc.
6
 
# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
7
 
#
8
 
# This program is free software; you can redistribute it and/or modify
 
1
 
 
2
# libtool (GNU libtool) 2.4.2
 
3
# Written by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
 
4
 
 
5
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003, 2004, 2005, 2006,
 
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.20
47
 
TIMESTAMP=" (1.1220.2.287 2005/08/31 18:54:15)"
48
 
 
49
 
# See if we are running on zsh, and set the options which allow our
50
 
# commands through without removal of \ escapes.
51
 
if test -n "${ZSH_VERSION+set}" ; then
52
 
  setopt NO_GLOB_SUBST
53
 
fi
54
 
 
55
 
# Check that we have a working $echo.
56
 
if test "X$1" = X--no-reexec; then
57
 
  # Discard the --no-reexec flag, and continue.
58
 
  shift
59
 
elif test "X$1" = X--fallback-echo; then
60
 
  # Avoid inline document here, it may be left over
61
 
  :
62
 
elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
63
 
  # Yippee, $echo works!
64
 
  :
65
 
else
66
 
  # Restart under the correct shell, and then maybe $echo will work.
67
 
  exec $SHELL "$progpath" --no-reexec ${1+"$@"}
68
 
fi
69
 
 
70
 
if test "X$1" = X--fallback-echo; then
71
 
  # used as fallback echo
72
 
  shift
73
 
  cat <<EOF
74
 
$*
75
 
EOF
76
 
  exit $EXIT_SUCCESS
77
 
fi
78
 
 
79
 
default_mode=
80
 
help="Try \`$progname --help' for more information."
81
 
magic="%%%MAGIC variable%%%"
82
 
mkdir="mkdir"
83
 
mv="mv -f"
84
 
rm="rm -f"
85
 
 
86
 
# Sed substitution that helps us do robust quoting.  It backslashifies
87
 
# metacharacters that are still active within double-quoted strings.
88
 
Xsed="${SED}"' -e 1s/^X//'
89
 
sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
90
 
# test EBCDIC or ASCII
91
 
case `echo X|tr X '\101'` in
92
 
 A) # ASCII based system
93
 
    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
94
 
  SP2NL='tr \040 \012'
95
 
  NL2SP='tr \015\012 \040\040'
96
 
  ;;
97
 
 *) # EBCDIC based system
98
 
  SP2NL='tr \100 \n'
99
 
  NL2SP='tr \r\n \100\100'
100
 
  ;;
101
 
esac
102
 
 
103
 
# NLS nuisances.
104
 
# Only set LANG and LC_ALL to C if already set.
105
 
# These must not be set unconditionally because not all systems understand
106
 
# e.g. LANG=C (notably SCO).
107
 
# We save the old values to restore during execute mode.
108
 
if test "${LC_ALL+set}" = set; then
109
 
  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
110
 
fi
111
 
if test "${LANG+set}" = set; then
112
 
  save_LANG="$LANG"; LANG=C; export LANG
113
 
fi
 
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
114
154
 
115
155
# Make sure IFS has a sensible default
116
156
lt_nl='
117
157
'
118
158
IFS="   $lt_nl"
119
159
 
120
 
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
121
 
  $echo "$modename: not configured to build any kind of library" 1>&2
122
 
  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
123
 
  exit $EXIT_FAILURE
124
 
fi
 
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
 
 
552
 
 
553
# func_mktempdir [string]
 
554
# Make a temporary directory that won't clash with other running
 
555
# libtool processes, and avoids race conditions if possible.  If
 
556
# given, STRING is the basename for that directory.
 
557
func_mktempdir ()
 
558
{
 
559
    my_template="${TMPDIR-/tmp}/${1-$progname}"
 
560
 
 
561
    if test "$opt_dry_run" = ":"; then
 
562
      # Return a directory name, but don't create it in dry-run mode
 
563
      my_tmpdir="${my_template}-$$"
 
564
    else
 
565
 
 
566
      # If mktemp works, use that first and foremost
 
567
      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
 
568
 
 
569
      if test ! -d "$my_tmpdir"; then
 
570
        # Failing that, at least try and use $RANDOM to avoid a race
 
571
        my_tmpdir="${my_template}-${RANDOM-0}$$"
 
572
 
 
573
        save_mktempdir_umask=`umask`
 
574
        umask 0077
 
575
        $MKDIR "$my_tmpdir"
 
576
        umask $save_mktempdir_umask
 
577
      fi
 
578
 
 
579
      # If we're not in dry-run mode, bomb out on failure
 
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%%%"
125
829
 
126
830
# Global variables.
127
 
mode=$default_mode
128
831
nonopt=
129
 
prev=
130
 
prevopt=
131
 
run=
132
 
show="$echo"
133
 
show_help=
134
 
execute_dlfiles=
 
832
preserve_args=
135
833
lo2o="s/\\.lo\$/.${objext}/"
136
834
o2lo="s/\\.${objext}\$/.lo/"
137
 
 
138
 
#####################################
139
 
# Shell function definitions:
140
 
# This seems to be the best place for them
141
 
 
142
 
# func_win32_libid arg
143
 
# return the library type of file 'arg'
144
 
#
145
 
# Need a lot of goo to handle *both* DLLs and import libs
146
 
# Has to be a shell function in order to 'eat' the argument
147
 
# that is supplied when $file_magic_command is called.
148
 
func_win32_libid ()
149
 
{
150
 
  win32_libid_type="unknown"
151
 
  win32_fileres=`file -L $1 2>/dev/null`
152
 
  case $win32_fileres in
153
 
  *ar\ archive\ import\ library*) # definitely import
154
 
    win32_libid_type="x86 archive import"
155
 
    ;;
156
 
  *ar\ archive*) # could be an import, or static
157
 
    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
158
 
      $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
159
 
      win32_nmres=`eval $NM -f posix -A $1 | \
160
 
        sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`
161
 
      if test "X$win32_nmres" = "Ximport" ; then
162
 
        win32_libid_type="x86 archive import"
163
 
      else
164
 
        win32_libid_type="x86 archive static"
165
 
      fi
166
 
    fi
167
 
    ;;
168
 
  *DLL*)
169
 
    win32_libid_type="x86 DLL"
170
 
    ;;
171
 
  *executable*) # but shell scripts are "executable" too...
172
 
    case $win32_fileres in
173
 
    *MS\ Windows\ PE\ Intel*)
174
 
      win32_libid_type="x86 DLL"
175
 
      ;;
176
 
    esac
177
 
    ;;
178
 
  esac
179
 
  $echo $win32_libid_type
180
 
}
181
 
 
 
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
}
182
1368
 
183
1369
# func_infer_tag arg
184
1370
# Infer tagged configuration to use if any are available and
188
1374
# arg is usually of the form 'gcc ...'
189
1375
func_infer_tag ()
190
1376
{
 
1377
    $opt_debug
191
1378
    if test -n "$available_tags" && test -z "$tagname"; then
192
1379
      CC_quoted=
193
1380
      for arg in $CC; do
194
 
        case $arg in
195
 
          *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \ ]*|*]*|"")
196
 
          arg="\"$arg\""
197
 
          ;;
198
 
        esac
199
 
        CC_quoted="$CC_quoted $arg"
 
1381
        func_append_quoted CC_quoted "$arg"
200
1382
      done
 
1383
      CC_expanded=`func_echo_all $CC`
 
1384
      CC_quoted_expanded=`func_echo_all $CC_quoted`
201
1385
      case $@ in
202
1386
      # Blanks in the command may have been stripped by the calling shell,
203
1387
      # but not from the CC environment variable when configure was run.
204
 
      " $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 "*) ;;
205
1390
      # Blanks at the start of $base_compile will cause this to fail
206
1391
      # if we don't check for them as well.
207
1392
      *)
208
1393
        for z in $available_tags; do
209
 
          if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
 
1394
          if $GREP "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
210
1395
            # Evaluate the configuration.
211
1396
            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
212
1397
            CC_quoted=
213
1398
            for arg in $CC; do
214
 
            # Double-quote args containing other shell metacharacters.
215
 
            case $arg in
216
 
              *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
217
 
              arg="\"$arg\""
218
 
              ;;
219
 
            esac
220
 
            CC_quoted="$CC_quoted $arg"
221
 
          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`
222
1404
            case "$@ " in
223
 
              " $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 "*)
224
1407
              # The compiler in the base compile command matches
225
1408
              # the one in the tagged configuration.
226
1409
              # Assume this is the tagged configuration we want.
234
1417
        # was found and let the user know that the "--tag" command
235
1418
        # line option must be used.
236
1419
        if test -z "$tagname"; then
237
 
          $echo "$modename: unable to infer tagged configuration"
238
 
          $echo "$modename: specify a tag with \`--tag'" 1>&2
239
 
          exit $EXIT_FAILURE
240
 
#        else
241
 
#          $echo "$modename: using $tagname tagged configuration"
242
 
        fi
243
 
        ;;
244
 
      esac
245
 
    fi
246
 
}
247
 
 
248
 
 
249
 
# func_extract_an_archive dir oldlib
250
 
func_extract_an_archive ()
251
 
{
252
 
    f_ex_an_ar_dir="$1"; shift
253
 
    f_ex_an_ar_oldlib="$1"
254
 
 
255
 
    $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
256
 
    $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
257
 
    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
258
 
     :
259
 
    else
260
 
      $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
261
 
      exit $EXIT_FAILURE
262
 
    fi
263
 
}
264
 
 
265
 
# func_extract_archives gentop oldlib ...
266
 
func_extract_archives ()
267
 
{
268
 
    my_gentop="$1"; shift
269
 
    my_oldlibs=${1+"$@"}
270
 
    my_oldobjs=""
271
 
    my_xlib=""
272
 
    my_xabs=""
273
 
    my_xdir=""
274
 
    my_status=""
275
 
 
276
 
    $show "${rm}r $my_gentop"
277
 
    $run ${rm}r "$my_gentop"
278
 
    $show "$mkdir $my_gentop"
279
 
    $run $mkdir "$my_gentop"
280
 
    my_status=$?
281
 
    if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
282
 
      exit $my_status
283
 
    fi
284
 
 
285
 
    for my_xlib in $my_oldlibs; do
286
 
      # Extract the objects.
287
 
      case $my_xlib in
288
 
        [\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
289
 
        *) my_xabs=`pwd`"/$my_xlib" ;;
290
 
      esac
291
 
      my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
292
 
      my_xdir="$my_gentop/$my_xlib"
293
 
 
294
 
      $show "${rm}r $my_xdir"
295
 
      $run ${rm}r "$my_xdir"
296
 
      $show "$mkdir $my_xdir"
297
 
      $run $mkdir "$my_xdir"
298
 
      status=$?
299
 
      if test "$status" -ne 0 && test ! -d "$my_xdir"; then
300
 
        exit $status
301
 
      fi
302
 
      case $host in
303
 
      *-darwin*)
304
 
        $show "Extracting $my_xabs"
305
 
        # Do not bother doing anything if just a dry run
306
 
        if test -z "$run"; then
307
 
          darwin_orig_dir=`pwd`
308
 
          cd $my_xdir || exit $?
309
 
          darwin_archive=$my_xabs
310
 
          darwin_curdir=`pwd`
311
 
          darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
312
 
          darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
313
 
          if test -n "$darwin_arches"; then 
314
 
            darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
315
 
            darwin_arch=
316
 
            $show "$darwin_base_archive has multiple architectures $darwin_arches"
317
 
            for darwin_arch in  $darwin_arches ; do
318
 
              mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
319
 
              lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
320
 
              cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
321
 
              func_extract_an_archive "`pwd`" "${darwin_base_archive}"
322
 
              cd "$darwin_curdir"
323
 
              $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
324
 
            done # $darwin_arches
325
 
      ## Okay now we have a bunch of thin objects, gotta fatten them up :)
326
 
            darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
327
 
            darwin_file=
328
 
            darwin_files=
329
 
            for darwin_file in $darwin_filelist; do
330
 
              darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
331
 
              lipo -create -output "$darwin_file" $darwin_files
332
 
            done # $darwin_filelist
333
 
            ${rm}r unfat-$$
334
 
            cd "$darwin_orig_dir"
335
 
          else
336
 
            cd "$darwin_orig_dir"
337
 
            func_extract_an_archive "$my_xdir" "$my_xabs"
338
 
          fi # $darwin_arches
339
 
        fi # $run
340
 
        ;;
341
 
      *)
342
 
        func_extract_an_archive "$my_xdir" "$my_xabs"
343
 
        ;;
344
 
      esac
345
 
      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
346
 
    done
347
 
    func_extract_archives_result="$my_oldobjs"
348
 
}
349
 
# End of Shell function definitions
350
 
#####################################
351
 
 
352
 
# Darwin sucks
353
 
eval std_shrext=\"$shrext_cmds\"
354
 
 
355
 
# Parse our command line options once, thoroughly.
356
 
while test "$#" -gt 0
357
 
do
358
 
  arg="$1"
359
 
  shift
360
 
 
361
 
  case $arg in
362
 
  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
363
 
  *) optarg= ;;
364
 
  esac
365
 
 
366
 
  # If the previous option needs an argument, assign it.
367
 
  if test -n "$prev"; then
368
 
    case $prev in
369
 
    execute_dlfiles)
370
 
      execute_dlfiles="$execute_dlfiles $arg"
371
 
      ;;
372
 
    tag)
373
 
      tagname="$arg"
374
 
      preserve_args="${preserve_args}=$arg"
375
 
 
376
 
      # Check whether tagname contains only valid characters
377
 
      case $tagname in
378
 
      *[!-_A-Za-z0-9,/]*)
379
 
        $echo "$progname: invalid tag name: $tagname" 1>&2
380
 
        exit $EXIT_FAILURE
381
 
        ;;
382
 
      esac
383
 
 
384
 
      case $tagname in
385
 
      CC)
386
 
        # Don't test for the "default" C tag, as we know, it's there, but
387
 
        # not specially marked.
388
 
        ;;
389
 
      *)
390
 
        if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
391
 
          taglist="$taglist $tagname"
392
 
          # Evaluate the configuration.
393
 
          eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
394
 
        else
395
 
          $echo "$progname: ignoring unknown tag $tagname" 1>&2
396
 
        fi
397
 
        ;;
398
 
      esac
399
 
      ;;
400
 
    *)
401
 
      eval "$prev=\$arg"
402
 
      ;;
403
 
    esac
404
 
 
405
 
    prev=
406
 
    prevopt=
407
 
    continue
408
 
  fi
409
 
 
410
 
  # Have we seen a non-optional argument yet?
411
 
  case $arg in
412
 
  --help)
413
 
    show_help=yes
414
 
    ;;
415
 
 
416
 
  --version)
417
 
    $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
418
 
    $echo
419
 
    $echo "Copyright (C) 2005  Free Software Foundation, Inc."
420
 
    $echo "This is free software; see the source for copying conditions.  There is NO"
421
 
    $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
422
 
    exit $?
423
 
    ;;
424
 
 
425
 
  --config)
426
 
    ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
427
 
    # Now print the configurations for the tags.
428
 
    for tagname in $taglist; do
429
 
      ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
430
 
    done
431
 
    exit $?
432
 
    ;;
433
 
 
434
 
  --debug)
435
 
    $echo "$progname: enabling shell trace mode"
436
 
    set -x
437
 
    preserve_args="$preserve_args $arg"
438
 
    ;;
439
 
 
440
 
  --dry-run | -n)
441
 
    run=:
442
 
    ;;
443
 
 
444
 
  --features)
445
 
    $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}
446
1438
    if test "$build_libtool_libs" = yes; then
447
 
      $echo "enable shared libraries"
 
1439
      write_lobj=\'${2}\'
448
1440
    else
449
 
      $echo "disable shared libraries"
 
1441
      write_lobj=none
450
1442
    fi
 
1443
 
451
1444
    if test "$build_old_libs" = yes; then
452
 
      $echo "enable static libraries"
453
 
    else
454
 
      $echo "disable static libraries"
455
 
    fi
456
 
    exit $?
457
 
    ;;
458
 
 
459
 
  --finish) mode="finish" ;;
460
 
 
461
 
  --mode) prevopt="--mode" prev=mode ;;
462
 
  --mode=*) mode="$optarg" ;;
463
 
 
464
 
  --preserve-dup-deps) duplicate_deps="yes" ;;
465
 
 
466
 
  --quiet | --silent)
467
 
    show=:
468
 
    preserve_args="$preserve_args $arg"
469
 
    ;;
470
 
 
471
 
  --tag) prevopt="--tag" prev=tag ;;
472
 
  --tag=*)
473
 
    set tag "$optarg" ${1+"$@"}
474
 
    shift
475
 
    prev=tag
476
 
    preserve_args="$preserve_args --tag"
477
 
    ;;
478
 
 
479
 
  -dlopen)
480
 
    prevopt="-dlopen"
481
 
    prev=execute_dlfiles
482
 
    ;;
483
 
 
484
 
  -*)
485
 
    $echo "$modename: unrecognized option \`$arg'" 1>&2
486
 
    $echo "$help" 1>&2
487
 
    exit $EXIT_FAILURE
488
 
    ;;
489
 
 
490
 
  *)
491
 
    nonopt="$arg"
492
 
    break
493
 
    ;;
494
 
  esac
495
 
done
496
 
 
497
 
if test -n "$prevopt"; then
498
 
  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
499
 
  $echo "$help" 1>&2
500
 
  exit $EXIT_FAILURE
501
 
fi
502
 
 
503
 
# If this variable is set in any of the actions, the command in it
504
 
# will be execed at the end.  This prevents here-documents from being
505
 
# left over by shells.
506
 
exec_cmd=
507
 
 
508
 
if test -z "$show_help"; then
509
 
 
510
 
  # Infer the operation mode.
511
 
  if test -z "$mode"; then
512
 
    $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
513
 
    $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
514
 
    case $nonopt in
515
 
    *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
516
 
      mode=link
517
 
      for arg
518
 
      do
519
 
        case $arg in
520
 
        -c)
521
 
           mode=compile
522
 
           break
523
 
           ;;
524
 
        esac
525
 
      done
526
 
      ;;
527
 
    *db | *dbx | *strace | *truss)
528
 
      mode=execute
529
 
      ;;
530
 
    *install*|cp|mv)
531
 
      mode=install
532
 
      ;;
533
 
    *rm)
534
 
      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
535
1676
      ;;
536
1677
    *)
537
 
      # If we have no mode, but dlfiles were specified, then do execute mode.
538
 
      test -n "$execute_dlfiles" && mode=execute
539
 
 
540
 
      # Just use the default operation mode.
541
 
      if test -z "$mode"; then
542
 
        if test -n "$nonopt"; then
543
 
          $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
544
 
        else
545
 
          $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
546
 
        fi
547
 
      fi
 
1678
      $to_tool_file_cmd "$1"
 
1679
      func_to_tool_file_result=$func_to_host_file_result
548
1680
      ;;
549
 
    esac
550
 
  fi
551
 
 
552
 
  # Only execute mode is allowed to have -dlopen flags.
553
 
  if test -n "$execute_dlfiles" && test "$mode" != execute; then
554
 
    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
555
 
    $echo "$help" 1>&2
556
 
    exit $EXIT_FAILURE
557
 
  fi
558
 
 
559
 
  # Change the help message to a mode-specific one.
560
 
  generic_help="$help"
561
 
  help="Try \`$modename --help --mode=$mode' for more information."
562
 
 
563
 
  # These modes are in order of execution frequency so that they run quickly.
564
 
  case $mode in
565
 
  # libtool compile mode
566
 
  compile)
567
 
    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
568
1953
    # Get the compilation command and the source file.
569
1954
    base_compile=
570
1955
    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
573
1958
    arg_mode=normal
574
1959
    libobj=
575
1960
    later=
 
1961
    pie_flag=
576
1962
 
577
1963
    for arg
578
1964
    do
593
1979
        # Accept any command-line options.
594
1980
        case $arg in
595
1981
        -o)
596
 
          if test -n "$libobj" ; then
597
 
            $echo "$modename: you cannot specify \`-o' more than once" 1>&2
598
 
            exit $EXIT_FAILURE
599
 
          fi
 
1982
          test -n "$libobj" && \
 
1983
            func_fatal_error "you cannot specify \`-o' more than once"
600
1984
          arg_mode=target
601
1985
          continue
602
1986
          ;;
603
1987
 
604
 
        -static | -prefer-pic | -prefer-non-pic)
605
 
          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"
606
1995
          continue
607
1996
          ;;
608
1997
 
617
2006
          ;;            #  replaced later.  I would guess that would be a bug.
618
2007
 
619
2008
        -Wc,*)
620
 
          args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
 
2009
          func_stripname '-Wc,' '' "$arg"
 
2010
          args=$func_stripname_result
621
2011
          lastarg=
622
2012
          save_ifs="$IFS"; IFS=','
623
 
          for arg in $args; do
 
2013
          for arg in $args; do
624
2014
            IFS="$save_ifs"
625
 
 
626
 
            # Double-quote args containing other shell metacharacters.
627
 
            # Many Bourne shells cannot handle close brackets correctly
628
 
            # in scan sets, so we specify it separately.
629
 
            case $arg in
630
 
              *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
631
 
              arg="\"$arg\""
632
 
              ;;
633
 
            esac
634
 
            lastarg="$lastarg $arg"
 
2015
            func_append_quoted lastarg "$arg"
635
2016
          done
636
2017
          IFS="$save_ifs"
637
 
          lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
 
2018
          func_stripname ' ' '' "$lastarg"
 
2019
          lastarg=$func_stripname_result
638
2020
 
639
2021
          # Add the arguments to base_compile.
640
 
          base_compile="$base_compile $lastarg"
 
2022
          func_append base_compile " $lastarg"
641
2023
          continue
642
2024
          ;;
643
2025
 
644
 
        * )
 
2026
        *)
645
2027
          # Accept the current argument as the source file.
646
2028
          # The previous "srcfile" becomes the current argument.
647
2029
          #
653
2035
      esac    #  case $arg_mode
654
2036
 
655
2037
      # Aesthetically quote the previous argument.
656
 
      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
657
 
 
658
 
      case $lastarg in
659
 
      # Double-quote args containing other shell metacharacters.
660
 
      # Many Bourne shells cannot handle close brackets correctly
661
 
      # in scan sets, and some SunOS ksh mistreat backslash-escaping
662
 
      # in scan sets (worked around with variable expansion),
663
 
      # and furthermore cannot handle '|' '&' '(' ')' in scan sets 
664
 
      # at all, so we specify them separately.
665
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
666
 
        lastarg="\"$lastarg\""
667
 
        ;;
668
 
      esac
669
 
 
670
 
      base_compile="$base_compile $lastarg"
 
2038
      func_append_quoted base_compile "$lastarg"
671
2039
    done # for arg
672
2040
 
673
2041
    case $arg_mode in
674
2042
    arg)
675
 
      $echo "$modename: you must specify an argument for -Xcompile"
676
 
      exit $EXIT_FAILURE
 
2043
      func_fatal_error "you must specify an argument for -Xcompile"
677
2044
      ;;
678
2045
    target)
679
 
      $echo "$modename: you must specify a target with \`-o'" 1>&2
680
 
      exit $EXIT_FAILURE
 
2046
      func_fatal_error "you must specify a target with \`-o'"
681
2047
      ;;
682
2048
    *)
683
2049
      # Get the name of the library object.
684
 
      [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
 
2050
      test -z "$libobj" && {
 
2051
        func_basename "$srcfile"
 
2052
        libobj="$func_basename_result"
 
2053
      }
685
2054
      ;;
686
2055
    esac
687
2056
 
688
2057
    # Recognize several different file suffixes.
689
2058
    # If the user specifies -o file.o, it is replaced with file.lo
690
 
    xform='[cCFSifmso]'
691
2059
    case $libobj in
692
 
    *.ada) xform=ada ;;
693
 
    *.adb) xform=adb ;;
694
 
    *.ads) xform=ads ;;
695
 
    *.asm) xform=asm ;;
696
 
    *.c++) xform=c++ ;;
697
 
    *.cc) xform=cc ;;
698
 
    *.ii) xform=ii ;;
699
 
    *.class) xform=class ;;
700
 
    *.cpp) xform=cpp ;;
701
 
    *.cxx) xform=cxx ;;
702
 
    *.f90) xform=f90 ;;
703
 
    *.for) xform=for ;;
704
 
    *.java) xform=java ;;
 
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
      ;;
705
2067
    esac
706
2068
 
707
 
    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
708
 
 
709
2069
    case $libobj in
710
 
    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
 
2070
    *.lo) func_lo2o "$libobj"; obj=$func_lo2o_result ;;
711
2071
    *)
712
 
      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
713
 
      exit $EXIT_FAILURE
 
2072
      func_fatal_error "cannot determine name of library object from \`$libobj'"
714
2073
      ;;
715
2074
    esac
716
2075
 
718
2077
 
719
2078
    for arg in $later; do
720
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
 
721
2087
      -static)
 
2088
        build_libtool_libs=no
722
2089
        build_old_libs=yes
723
2090
        continue
724
2091
        ;;
735
2102
      esac
736
2103
    done
737
2104
 
738
 
    qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
739
 
    case $qlibobj in
740
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
741
 
        qlibobj="\"$qlibobj\"" ;;
742
 
    esac
743
 
    test "X$libobj" != "X$qlibobj" \
744
 
        && $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"'  &()|`$[]' \
745
 
        && $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
746
 
    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
747
 
    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
748
 
    if test "X$xdir" = "X$obj"; then
749
 
      xdir=
750
 
    else
751
 
      xdir=$xdir/
752
 
    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"
753
2112
    lobj=${xdir}$objdir/$objname
754
2113
 
755
 
    if test -z "$base_compile"; then
756
 
      $echo "$modename: you must specify a compilation command" 1>&2
757
 
      $echo "$help" 1>&2
758
 
      exit $EXIT_FAILURE
759
 
    fi
 
2114
    test -z "$base_compile" && \
 
2115
      func_fatal_help "you must specify a compilation command"
760
2116
 
761
2117
    # Delete any leftover library objects.
762
2118
    if test "$build_old_libs" = yes; then
765
2121
      removelist="$lobj $libobj ${libobj}T"
766
2122
    fi
767
2123
 
768
 
    $run $rm $removelist
769
 
    trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
770
 
 
771
2124
    # On Cygwin there's no "real" PIC flag so we must build both object types
772
2125
    case $host_os in
773
 
    cygwin* | mingw* | pw32* | os2*)
 
2126
    cygwin* | mingw* | pw32* | os2* | cegcc*)
774
2127
      pic_mode=default
775
2128
      ;;
776
2129
    esac
782
2135
    # Calculate the filename of the output object if compiler does
783
2136
    # not support -o with -c
784
2137
    if test "$compiler_c_o" = no; then
785
 
      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
 
2138
      output_obj=`$ECHO "$srcfile" | $SED 's%^.*/%%; s%\.[^.]*$%%'`.${objext}
786
2139
      lockfile="$output_obj.lock"
787
 
      removelist="$removelist $output_obj $lockfile"
788
 
      trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
789
2140
    else
790
2141
      output_obj=
791
2142
      need_locks=no
795
2146
    # Lock this critical section if it is needed
796
2147
    # We use this script file to make the link, it avoids creating a new file
797
2148
    if test "$need_locks" = yes; then
798
 
      until $run ln "$progpath" "$lockfile" 2>/dev/null; do
799
 
        $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"
800
2151
        sleep 2
801
2152
      done
802
2153
    elif test "$need_locks" = warn; then
803
2154
      if test -f "$lockfile"; then
804
 
        $echo "\
 
2155
        $ECHO "\
805
2156
*** ERROR, $lockfile exists and contains:
806
2157
`cat $lockfile 2>/dev/null`
807
2158
 
812
2163
avoid parallel builds (make -j) in this platform, or get a better
813
2164
compiler."
814
2165
 
815
 
        $run $rm $removelist
 
2166
        $opt_dry_run || $RM $removelist
816
2167
        exit $EXIT_FAILURE
817
2168
      fi
818
 
      $echo "$srcfile" > "$lockfile"
819
 
    fi
820
 
 
821
 
    if test -n "$fix_srcfile_path"; then
822
 
      eval srcfile=\"$fix_srcfile_path\"
823
 
    fi
824
 
    qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
825
 
    case $qsrcfile in
826
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
827
 
      qsrcfile="\"$qsrcfile\"" ;;
828
 
    esac
829
 
 
830
 
    $run $rm "$libobj" "${libobj}T"
831
 
 
832
 
    # Create a libtool object file (analogous to a ".la" file),
833
 
    # but don't create it if we're doing a dry run.
834
 
    test -z "$run" && cat > ${libobj}T <<EOF
835
 
# $libobj - a libtool object file
836
 
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
837
 
#
838
 
# Please DO NOT delete this file!
839
 
# It is necessary for linking the library.
840
 
 
841
 
# Name of the PIC object.
842
 
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
843
2181
 
844
2182
    # Only build a PIC object if we are building libtool libraries.
845
2183
    if test "$build_libtool_libs" = yes; then
853
2191
        command="$base_compile $qsrcfile"
854
2192
      fi
855
2193
 
856
 
      if test ! -d "${xdir}$objdir"; then
857
 
        $show "$mkdir ${xdir}$objdir"
858
 
        $run $mkdir ${xdir}$objdir
859
 
        status=$?
860
 
        if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
861
 
          exit $status
862
 
        fi
863
 
      fi
 
2194
      func_mkdir_p "$xdir$objdir"
864
2195
 
865
2196
      if test -z "$output_obj"; then
866
2197
        # Place PIC objects in $objdir
867
 
        command="$command -o $lobj"
868
 
      fi
869
 
 
870
 
      $run $rm "$lobj" "$output_obj"
871
 
 
872
 
      $show "$command"
873
 
      if $run eval "$command"; then :
874
 
      else
875
 
        test -n "$output_obj" && $run $rm $removelist
876
 
        exit $EXIT_FAILURE
877
 
      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'
878
2203
 
879
2204
      if test "$need_locks" = warn &&
880
2205
         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
881
 
        $echo "\
 
2206
        $ECHO "\
882
2207
*** ERROR, $lockfile contains:
883
2208
`cat $lockfile 2>/dev/null`
884
2209
 
892
2217
avoid parallel builds (make -j) in this platform, or get a better
893
2218
compiler."
894
2219
 
895
 
        $run $rm $removelist
 
2220
        $opt_dry_run || $RM $removelist
896
2221
        exit $EXIT_FAILURE
897
2222
      fi
898
2223
 
899
2224
      # Just move the object if needed, then go on to compile the next one
900
2225
      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
901
 
        $show "$mv $output_obj $lobj"
902
 
        if $run $mv $output_obj $lobj; then :
903
 
        else
904
 
          error=$?
905
 
          $run $rm $removelist
906
 
          exit $error
907
 
        fi
 
2226
        func_show_eval '$MV "$output_obj" "$lobj"' \
 
2227
          'error=$?; $opt_dry_run || $RM $removelist; exit $error'
908
2228
      fi
909
2229
 
910
 
      # Append the name of the PIC object to the libtool object file.
911
 
      test -z "$run" && cat >> ${libobj}T <<EOF
912
 
pic_object='$objdir/$objname'
913
 
 
914
 
EOF
915
 
 
916
2230
      # Allow error messages only from the first compilation.
917
2231
      if test "$suppress_opt" = yes; then
918
 
        suppress_output=' >/dev/null 2>&1'
 
2232
        suppress_output=' >/dev/null 2>&1'
919
2233
      fi
920
 
    else
921
 
      # No PIC object so indicate it doesn't exist in the libtool
922
 
      # object file.
923
 
      test -z "$run" && cat >> ${libobj}T <<EOF
924
 
pic_object=none
925
 
 
926
 
EOF
927
2234
    fi
928
2235
 
929
2236
    # Only build a position-dependent object if we build old libraries.
930
2237
    if test "$build_old_libs" = yes; then
931
2238
      if test "$pic_mode" != yes; then
932
2239
        # Don't build PIC code
933
 
        command="$base_compile $qsrcfile"
 
2240
        command="$base_compile $qsrcfile$pie_flag"
934
2241
      else
935
2242
        command="$base_compile $qsrcfile $pic_flag"
936
2243
      fi
937
2244
      if test "$compiler_c_o" = yes; then
938
 
        command="$command -o $obj"
 
2245
        func_append command " -o $obj"
939
2246
      fi
940
2247
 
941
2248
      # Suppress compiler output if we already did a PIC compilation.
942
 
      command="$command$suppress_output"
943
 
      $run $rm "$obj" "$output_obj"
944
 
      $show "$command"
945
 
      if $run eval "$command"; then :
946
 
      else
947
 
        $run $rm $removelist
948
 
        exit $EXIT_FAILURE
949
 
      fi
 
2249
      func_append command "$suppress_output"
 
2250
      func_show_eval_locale "$command" \
 
2251
        '$opt_dry_run || $RM $removelist; exit $EXIT_FAILURE'
950
2252
 
951
2253
      if test "$need_locks" = warn &&
952
2254
         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
953
 
        $echo "\
 
2255
        $ECHO "\
954
2256
*** ERROR, $lockfile contains:
955
2257
`cat $lockfile 2>/dev/null`
956
2258
 
964
2266
avoid parallel builds (make -j) in this platform, or get a better
965
2267
compiler."
966
2268
 
967
 
        $run $rm $removelist
 
2269
        $opt_dry_run || $RM $removelist
968
2270
        exit $EXIT_FAILURE
969
2271
      fi
970
2272
 
971
2273
      # Just move the object if needed
972
2274
      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
973
 
        $show "$mv $output_obj $obj"
974
 
        if $run $mv $output_obj $obj; then :
975
 
        else
976
 
          error=$?
977
 
          $run $rm $removelist
978
 
          exit $error
979
 
        fi
980
 
      fi
981
 
 
982
 
      # Append the name of the non-PIC object the libtool object file.
983
 
      # Only append if the libtool object file exists.
984
 
      test -z "$run" && cat >> ${libobj}T <<EOF
985
 
# Name of the non-PIC object.
986
 
non_pic_object='$objname'
987
 
 
988
 
EOF
989
 
    else
990
 
      # Append the name of the non-PIC object the libtool object file.
991
 
      # Only append if the libtool object file exists.
992
 
      test -z "$run" && cat >> ${libobj}T <<EOF
993
 
# Name of the non-PIC object.
994
 
non_pic_object=none
995
 
 
996
 
EOF
997
 
    fi
998
 
 
999
 
    $run $mv "${libobj}T" "${libobj}"
1000
 
 
1001
 
    # Unlock the critical section if it was locked
1002
 
    if test "$need_locks" != no; then
1003
 
      $run $rm "$lockfile"
1004
 
    fi
1005
 
 
1006
 
    exit $EXIT_SUCCESS
1007
 
    ;;
1008
 
 
1009
 
  # libtool link mode
1010
 
  link | relink)
1011
 
    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
1012
5096
    case $host in
1013
 
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 
5097
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
1014
5098
      # It is impossible to link a dll without this setting, and
1015
5099
      # we shouldn't force the makefile maintainer to figure out
1016
5100
      # which system we are compiling for in order to pass an extra
1028
5112
      allow_undefined=yes
1029
5113
      ;;
1030
5114
    esac
1031
 
    libtool_args="$nonopt"
 
5115
    libtool_args=$nonopt
1032
5116
    base_compile="$nonopt $@"
1033
 
    compile_command="$nonopt"
1034
 
    finalize_command="$nonopt"
 
5117
    compile_command=$nonopt
 
5118
    finalize_command=$nonopt
1035
5119
 
1036
5120
    compile_rpath=
1037
5121
    finalize_rpath=
1046
5130
    dllsearchpath=
1047
5131
    lib_search_path=`pwd`
1048
5132
    inst_prefix_dir=
 
5133
    new_inherited_linker_flags=
1049
5134
 
1050
5135
    avoid_version=no
 
5136
    bindir=
1051
5137
    dlfiles=
1052
5138
    dlprefiles=
1053
5139
    dlself=no
1074
5160
    thread_safe=no
1075
5161
    vinfo=
1076
5162
    vinfo_number=no
1077
 
 
 
5163
    weak_libs=
 
5164
    single_module="${wl}-single_module"
1078
5165
    func_infer_tag $base_compile
1079
5166
 
1080
5167
    # We need to know -static, to get the right output filenames.
1081
5168
    for arg
1082
5169
    do
1083
5170
      case $arg in
1084
 
      -all-static | -static)
1085
 
        if test "X$arg" = "X-all-static"; then
 
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
        ;;
 
5177
      -all-static | -static | -static-libtool-libs)
 
5178
        case $arg in
 
5179
        -all-static)
1086
5180
          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
1087
 
            $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
 
5181
            func_warning "complete static linking is impossible in this configuration"
1088
5182
          fi
1089
5183
          if test -n "$link_static_flag"; then
1090
5184
            dlopen_self=$dlopen_self_static
1091
5185
          fi
1092
 
        else
1093
 
          if test -z "$pic_flag" && test -n "$link_static_flag"; then
1094
 
            dlopen_self=$dlopen_self_static
1095
 
          fi
1096
 
        fi
 
5186
          prefer_static_libs=yes
 
5187
          ;;
 
5188
        -static)
 
5189
          if test -z "$pic_flag" && test -n "$link_static_flag"; then
 
5190
            dlopen_self=$dlopen_self_static
 
5191
          fi
 
5192
          prefer_static_libs=built
 
5193
          ;;
 
5194
        -static-libtool-libs)
 
5195
          if test -z "$pic_flag" && test -n "$link_static_flag"; then
 
5196
            dlopen_self=$dlopen_self_static
 
5197
          fi
 
5198
          prefer_static_libs=yes
 
5199
          ;;
 
5200
        esac
1097
5201
        build_libtool_libs=no
1098
5202
        build_old_libs=yes
1099
 
        prefer_static_libs=yes
1100
5203
        break
1101
5204
        ;;
1102
5205
      esac
1109
5212
    while test "$#" -gt 0; do
1110
5213
      arg="$1"
1111
5214
      shift
1112
 
      case $arg in
1113
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
1114
 
        qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
1115
 
        ;;
1116
 
      *) qarg=$arg ;;
1117
 
      esac
1118
 
      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"
1119
5218
 
1120
5219
      # If the previous option needs an argument, assign it.
1121
5220
      if test -n "$prev"; then
1122
5221
        case $prev in
1123
5222
        output)
1124
 
          compile_command="$compile_command @OUTPUT@"
1125
 
          finalize_command="$finalize_command @OUTPUT@"
 
5223
          func_append compile_command " @OUTPUT@"
 
5224
          func_append finalize_command " @OUTPUT@"
1126
5225
          ;;
1127
5226
        esac
1128
5227
 
1129
5228
        case $prev in
 
5229
        bindir)
 
5230
          bindir="$arg"
 
5231
          prev=
 
5232
          continue
 
5233
          ;;
1130
5234
        dlfiles|dlprefiles)
1131
5235
          if test "$preload" = no; then
1132
5236
            # Add the symbol object into the linking commands.
1133
 
            compile_command="$compile_command @SYMFILE@"
1134
 
            finalize_command="$finalize_command @SYMFILE@"
 
5237
            func_append compile_command " @SYMFILE@"
 
5238
            func_append finalize_command " @SYMFILE@"
1135
5239
            preload=yes
1136
5240
          fi
1137
5241
          case $arg in
1158
5262
            ;;
1159
5263
          *)
1160
5264
            if test "$prev" = dlfiles; then
1161
 
              dlfiles="$dlfiles $arg"
 
5265
              func_append dlfiles " $arg"
1162
5266
            else
1163
 
              dlprefiles="$dlprefiles $arg"
 
5267
              func_append dlprefiles " $arg"
1164
5268
            fi
1165
5269
            prev=
1166
5270
            continue
1169
5273
          ;;
1170
5274
        expsyms)
1171
5275
          export_symbols="$arg"
1172
 
          if test ! -f "$arg"; then
1173
 
            $echo "$modename: symbol file \`$arg' does not exist"
1174
 
            exit $EXIT_FAILURE
1175
 
          fi
 
5276
          test -f "$arg" \
 
5277
            || func_fatal_error "symbol file \`$arg' does not exist"
1176
5278
          prev=
1177
5279
          continue
1178
5280
          ;;
1181
5283
          prev=
1182
5284
          continue
1183
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
          ;;
1184
5299
        inst_prefix)
1185
5300
          inst_prefix_dir="$arg"
1186
5301
          prev=
1187
5302
          continue
1188
5303
          ;;
1189
 
        precious_regex)
1190
 
          precious_files_regex="$arg"
1191
 
          prev=
1192
 
          continue
1193
 
          ;;
1194
 
        release)
1195
 
          release="-$arg"
1196
 
          prev=
1197
 
          continue
1198
 
          ;;
1199
5304
        objectlist)
1200
5305
          if test -f "$arg"; then
1201
5306
            save_arg=$arg
1202
5307
            moreargs=
1203
 
            for fil in `cat $save_arg`
 
5308
            for fil in `cat "$save_arg"`
1204
5309
            do
1205
 
#             moreargs="$moreargs $fil"
 
5310
#             func_append moreargs " $fil"
1206
5311
              arg=$fil
1207
5312
              # A libtool-controlled object.
1208
5313
 
1209
5314
              # Check to see that this really is a libtool object.
1210
 
              if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 
5315
              if func_lalib_unsafe_p "$arg"; then
1211
5316
                pic_object=
1212
5317
                non_pic_object=
1213
5318
 
1214
5319
                # Read the .lo file
1215
 
                # If there is no directory component, then add one.
1216
 
                case $arg in
1217
 
                */* | *\\*) . $arg ;;
1218
 
                *) . ./$arg ;;
1219
 
                esac
 
5320
                func_source "$arg"
1220
5321
 
1221
 
                if test -z "$pic_object" || \
 
5322
                if test -z "$pic_object" ||
1222
5323
                   test -z "$non_pic_object" ||
1223
 
                   test "$pic_object" = none && \
 
5324
                   test "$pic_object" = none &&
1224
5325
                   test "$non_pic_object" = none; then
1225
 
                  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1226
 
                  exit $EXIT_FAILURE
 
5326
                  func_fatal_error "cannot find name of object for \`$arg'"
1227
5327
                fi
1228
5328
 
1229
5329
                # Extract subdirectory from the argument.
1230
 
                xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1231
 
                if test "X$xdir" = "X$arg"; then
1232
 
                  xdir=
1233
 
                else
1234
 
                  xdir="$xdir/"
1235
 
                fi
 
5330
                func_dirname "$arg" "/" ""
 
5331
                xdir="$func_dirname_result"
1236
5332
 
1237
5333
                if test "$pic_object" != none; then
1238
5334
                  # Prepend the subdirectory the object is found in.
1240
5336
 
1241
5337
                  if test "$prev" = dlfiles; then
1242
5338
                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1243
 
                      dlfiles="$dlfiles $pic_object"
 
5339
                      func_append dlfiles " $pic_object"
1244
5340
                      prev=
1245
5341
                      continue
1246
5342
                    else
1252
5348
                  # CHECK ME:  I think I busted this.  -Ossama
1253
5349
                  if test "$prev" = dlprefiles; then
1254
5350
                    # Preload the old-style object.
1255
 
                    dlprefiles="$dlprefiles $pic_object"
 
5351
                    func_append dlprefiles " $pic_object"
1256
5352
                    prev=
1257
5353
                  fi
1258
5354
 
1259
5355
                  # A PIC object.
1260
 
                  libobjs="$libobjs $pic_object"
 
5356
                  func_append libobjs " $pic_object"
1261
5357
                  arg="$pic_object"
1262
5358
                fi
1263
5359
 
1267
5363
                  non_pic_object="$xdir$non_pic_object"
1268
5364
 
1269
5365
                  # A standard non-PIC object
1270
 
                  non_pic_objects="$non_pic_objects $non_pic_object"
 
5366
                  func_append non_pic_objects " $non_pic_object"
1271
5367
                  if test -z "$pic_object" || test "$pic_object" = none ; then
1272
5368
                    arg="$non_pic_object"
1273
5369
                  fi
 
5370
                else
 
5371
                  # If the PIC object exists, use it instead.
 
5372
                  # $xdir was prepended to $pic_object above.
 
5373
                  non_pic_object="$pic_object"
 
5374
                  func_append non_pic_objects " $non_pic_object"
1274
5375
                fi
1275
5376
              else
1276
5377
                # Only an error if not doing a dry-run.
1277
 
                if test -z "$run"; then
1278
 
                  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1279
 
                  exit $EXIT_FAILURE
1280
 
                else
1281
 
                  # Dry-run case.
1282
 
 
 
5378
                if $opt_dry_run; then
1283
5379
                  # Extract subdirectory from the argument.
1284
 
                  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1285
 
                  if test "X$xdir" = "X$arg"; then
1286
 
                    xdir=
1287
 
                  else
1288
 
                    xdir="$xdir/"
1289
 
                  fi
 
5380
                  func_dirname "$arg" "/" ""
 
5381
                  xdir="$func_dirname_result"
1290
5382
 
1291
 
                  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1292
 
                  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1293
 
                  libobjs="$libobjs $pic_object"
1294
 
                  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"
1295
5390
                fi
1296
5391
              fi
1297
5392
            done
1298
5393
          else
1299
 
            $echo "$modename: link input file \`$save_arg' does not exist"
1300
 
            exit $EXIT_FAILURE
 
5394
            func_fatal_error "link input file \`$arg' does not exist"
1301
5395
          fi
1302
5396
          arg=$save_arg
1303
5397
          prev=
1304
5398
          continue
1305
5399
          ;;
 
5400
        precious_regex)
 
5401
          precious_files_regex="$arg"
 
5402
          prev=
 
5403
          continue
 
5404
          ;;
 
5405
        release)
 
5406
          release="-$arg"
 
5407
          prev=
 
5408
          continue
 
5409
          ;;
1306
5410
        rpath | xrpath)
1307
5411
          # We need an absolute path.
1308
5412
          case $arg in
1309
5413
          [\\/]* | [A-Za-z]:[\\/]*) ;;
1310
5414
          *)
1311
 
            $echo "$modename: only absolute run-paths are allowed" 1>&2
1312
 
            exit $EXIT_FAILURE
 
5415
            func_fatal_error "only absolute run-paths are allowed"
1313
5416
            ;;
1314
5417
          esac
1315
5418
          if test "$prev" = rpath; then
1316
5419
            case "$rpath " in
1317
5420
            *" $arg "*) ;;
1318
 
            *) rpath="$rpath $arg" ;;
 
5421
            *) func_append rpath " $arg" ;;
1319
5422
            esac
1320
5423
          else
1321
5424
            case "$xrpath " in
1322
5425
            *" $arg "*) ;;
1323
 
            *) xrpath="$xrpath $arg" ;;
 
5426
            *) func_append xrpath " $arg" ;;
1324
5427
            esac
1325
5428
          fi
1326
5429
          prev=
1327
5430
          continue
1328
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
          ;;
1329
5450
        xcompiler)
1330
 
          compiler_flags="$compiler_flags $qarg"
 
5451
          func_append compiler_flags " $qarg"
1331
5452
          prev=
1332
 
          compile_command="$compile_command $qarg"
1333
 
          finalize_command="$finalize_command $qarg"
 
5453
          func_append compile_command " $qarg"
 
5454
          func_append finalize_command " $qarg"
1334
5455
          continue
1335
5456
          ;;
1336
5457
        xlinker)
1337
 
          linker_flags="$linker_flags $qarg"
1338
 
          compiler_flags="$compiler_flags $wl$qarg"
1339
 
          prev=
1340
 
          compile_command="$compile_command $wl$qarg"
1341
 
          finalize_command="$finalize_command $wl$qarg"
1342
 
          continue
1343
 
          ;;
1344
 
        xcclinker)
1345
 
          linker_flags="$linker_flags $qarg"
1346
 
          compiler_flags="$compiler_flags $qarg"
1347
 
          prev=
1348
 
          compile_command="$compile_command $qarg"
1349
 
          finalize_command="$finalize_command $qarg"
1350
 
          continue
1351
 
          ;;
1352
 
        shrext)
1353
 
          shrext_cmds="$arg"
1354
 
          prev=
1355
 
          continue
1356
 
          ;;
1357
 
        darwin_framework)
1358
 
          compiler_flags="$compiler_flags $arg"
1359
 
          compile_command="$compile_command $arg"
1360
 
          finalize_command="$finalize_command $arg"
1361
 
          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"
1362
5463
          continue
1363
5464
          ;;
1364
5465
        *)
1374
5475
      case $arg in
1375
5476
      -all-static)
1376
5477
        if test -n "$link_static_flag"; then
1377
 
          compile_command="$compile_command $link_static_flag"
1378
 
          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"
1379
5481
        fi
1380
5482
        continue
1381
5483
        ;;
1382
5484
 
1383
5485
      -allow-undefined)
1384
5486
        # FIXME: remove this flag sometime in the future.
1385
 
        $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1386
 
        continue
 
5487
        func_fatal_error "\`-allow-undefined' must not be used because it is the default"
1387
5488
        ;;
1388
5489
 
1389
5490
      -avoid-version)
1391
5492
        continue
1392
5493
        ;;
1393
5494
 
 
5495
      -bindir)
 
5496
        prev=bindir
 
5497
        continue
 
5498
        ;;
 
5499
 
1394
5500
      -dlopen)
1395
5501
        prev=dlfiles
1396
5502
        continue
1408
5514
 
1409
5515
      -export-symbols | -export-symbols-regex)
1410
5516
        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1411
 
          $echo "$modename: more than one -exported-symbols argument is not allowed"
1412
 
          exit $EXIT_FAILURE
 
5517
          func_fatal_error "more than one -exported-symbols argument is not allowed"
1413
5518
        fi
1414
5519
        if test "X$arg" = "X-export-symbols"; then
1415
5520
          prev=expsyms
1419
5524
        continue
1420
5525
        ;;
1421
5526
 
1422
 
      -framework|-arch)
1423
 
        prev=darwin_framework
1424
 
        compiler_flags="$compiler_flags $arg"
1425
 
        compile_command="$compile_command $arg"
1426
 
        finalize_command="$finalize_command $arg"
1427
 
        continue
1428
 
        ;;
 
5527
      -framework)
 
5528
        prev=framework
 
5529
        continue
 
5530
        ;;
1429
5531
 
1430
5532
      -inst-prefix-dir)
1431
5533
        prev=inst_prefix
1437
5539
      -L[A-Z][A-Z]*:*)
1438
5540
        case $with_gcc/$host in
1439
5541
        no/*-*-irix* | /*-*-irix*)
1440
 
          compile_command="$compile_command $arg"
1441
 
          finalize_command="$finalize_command $arg"
 
5542
          func_append compile_command " $arg"
 
5543
          func_append finalize_command " $arg"
1442
5544
          ;;
1443
5545
        esac
1444
5546
        continue
1445
5547
        ;;
1446
5548
 
1447
5549
      -L*)
1448
 
        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
1449
5560
        # We need an absolute path.
1450
5561
        case $dir in
1451
5562
        [\\/]* | [A-Za-z]:[\\/]*) ;;
1452
5563
        *)
1453
5564
          absdir=`cd "$dir" && pwd`
1454
 
          if test -z "$absdir"; then
1455
 
            $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1456
 
            exit $EXIT_FAILURE
1457
 
          fi
 
5565
          test -z "$absdir" && \
 
5566
            func_fatal_error "cannot determine absolute directory name of \`$dir'"
1458
5567
          dir="$absdir"
1459
5568
          ;;
1460
5569
        esac
1461
5570
        case "$deplibs " in
1462
 
        *" -L$dir "*) ;;
 
5571
        *" -L$dir "* | *" $arg "*)
 
5572
          # Will only happen for absolute or sysroot arguments
 
5573
          ;;
1463
5574
        *)
1464
 
          deplibs="$deplibs -L$dir"
1465
 
          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"
1466
5581
          ;;
1467
5582
        esac
1468
5583
        case $host in
1469
 
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 
5584
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
 
5585
          testbindir=`$ECHO "$dir" | $SED 's*/lib$*/bin*'`
1470
5586
          case :$dllsearchpath: in
1471
5587
          *":$dir:"*) ;;
1472
 
          *) dllsearchpath="$dllsearchpath:$dir";;
 
5588
          ::) dllsearchpath=$dir;;
 
5589
          *) func_append dllsearchpath ":$dir";;
 
5590
          esac
 
5591
          case :$dllsearchpath: in
 
5592
          *":$testbindir:"*) ;;
 
5593
          ::) dllsearchpath=$testbindir;;
 
5594
          *) func_append dllsearchpath ":$testbindir";;
1473
5595
          esac
1474
5596
          ;;
1475
5597
        esac
1479
5601
      -l*)
1480
5602
        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1481
5603
          case $host in
1482
 
          *-*-cygwin* | *-*-pw32* | *-*-beos*)
 
5604
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos* | *-cegcc* | *-*-haiku*)
1483
5605
            # These systems don't actually have a C or math library (as such)
1484
5606
            continue
1485
5607
            ;;
1486
 
          *-*-mingw* | *-*-os2*)
 
5608
          *-*-os2*)
1487
5609
            # These systems don't actually have a C library (as such)
1488
5610
            test "X$arg" = "X-lc" && continue
1489
5611
            ;;
1493
5615
            ;;
1494
5616
          *-*-rhapsody* | *-*-darwin1.[012])
1495
5617
            # Rhapsody C and math libraries are in the System framework
1496
 
            deplibs="$deplibs -framework System"
 
5618
            func_append deplibs " System.ltframework"
1497
5619
            continue
 
5620
            ;;
 
5621
          *-*-sco3.2v5* | *-*-sco5v6*)
 
5622
            # Causes problems with __ctype
 
5623
            test "X$arg" = "X-lc" && continue
 
5624
            ;;
 
5625
          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
 
5626
            # Compiler inserts libc in the correct place for threads to work
 
5627
            test "X$arg" = "X-lc" && continue
 
5628
            ;;
1498
5629
          esac
1499
5630
        elif test "X$arg" = "X-lc_r"; then
1500
5631
         case $host in
1504
5635
           ;;
1505
5636
         esac
1506
5637
        fi
1507
 
        deplibs="$deplibs $arg"
 
5638
        func_append deplibs " $arg"
 
5639
        continue
 
5640
        ;;
 
5641
 
 
5642
      -module)
 
5643
        module=yes
1508
5644
        continue
1509
5645
        ;;
1510
5646
 
1511
5647
      # Tru64 UNIX uses -model [arg] to determine the layout of C++
1512
5648
      # classes, name mangling, and exception handling.
1513
 
      -model)
1514
 
        compile_command="$compile_command $arg"
1515
 
        compiler_flags="$compiler_flags $arg"
1516
 
        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"
1517
5654
        prev=xcompiler
1518
5655
        continue
1519
5656
        ;;
1520
5657
 
1521
 
     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1522
 
        compiler_flags="$compiler_flags $arg"
1523
 
        compile_command="$compile_command $arg"
1524
 
        finalize_command="$finalize_command $arg"
1525
 
        continue
1526
 
        ;;
1527
 
 
1528
 
      -module)
1529
 
        module=yes
1530
 
        continue
1531
 
        ;;
1532
 
 
1533
 
      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
1534
 
      # -r[0-9][0-9]* specifies the processor on the SGI compiler
1535
 
      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
1536
 
      # +DA*, +DD* enable 64-bit mode on the HP compiler
1537
 
      # -q* pass through compiler args for the IBM compiler
1538
 
      # -m* pass through architecture-specific compiler args for GCC
1539
 
      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*)
1540
 
 
1541
 
        # Unknown arguments in both finalize_command and compile_command need
1542
 
        # to be aesthetically quoted because they are evaled later.
1543
 
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1544
 
        case $arg in
1545
 
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1546
 
          arg="\"$arg\""
1547
 
          ;;
 
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" ;;
1548
5666
        esac
1549
 
        compile_command="$compile_command $arg"
1550
 
        finalize_command="$finalize_command $arg"
1551
 
        if test "$with_gcc" = "yes" ; then
1552
 
          compiler_flags="$compiler_flags $arg"
1553
 
        fi
1554
 
        continue
1555
 
        ;;
 
5667
        continue
 
5668
        ;;
1556
5669
 
1557
 
      -shrext)
1558
 
        prev=shrext
 
5670
      -multi_module)
 
5671
        single_module="${wl}-multi_module"
1559
5672
        continue
1560
5673
        ;;
1561
5674
 
1566
5679
 
1567
5680
      -no-install)
1568
5681
        case $host in
1569
 
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 
5682
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin* | *-cegcc*)
1570
5683
          # The PATH hackery in wrapper scripts is required on Windows
1571
 
          # in order for the loader to find any dlls it needs.
1572
 
          $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1573
 
          $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
 
5684
          # and Darwin in order for the loader to find any dlls it needs.
 
5685
          func_warning "\`-no-install' is ignored for $host"
 
5686
          func_warning "assuming \`-no-fast-install' instead"
1574
5687
          fast_install=no
1575
5688
          ;;
1576
5689
        *) no_install=yes ;;
1611
5724
        ;;
1612
5725
 
1613
5726
      -R*)
1614
 
        dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
 
5727
        func_stripname '-R' '' "$arg"
 
5728
        dir=$func_stripname_result
1615
5729
        # We need an absolute path.
1616
5730
        case $dir in
1617
5731
        [\\/]* | [A-Za-z]:[\\/]*) ;;
 
5732
        =*)
 
5733
          func_stripname '=' '' "$dir"
 
5734
          dir=$lt_sysroot$func_stripname_result
 
5735
          ;;
1618
5736
        *)
1619
 
          $echo "$modename: only absolute run-paths are allowed" 1>&2
1620
 
          exit $EXIT_FAILURE
 
5737
          func_fatal_error "only absolute run-paths are allowed"
1621
5738
          ;;
1622
5739
        esac
1623
5740
        case "$xrpath " in
1624
5741
        *" $dir "*) ;;
1625
 
        *) xrpath="$xrpath $dir" ;;
 
5742
        *) func_append xrpath " $dir" ;;
1626
5743
        esac
1627
5744
        continue
1628
5745
        ;;
1629
5746
 
1630
 
      -static)
 
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
 
 
5757
      -static | -static-libtool-libs)
1631
5758
        # The effects of -static are defined in a previous loop.
1632
5759
        # We used to do the same as -all-static on platforms that
1633
5760
        # didn't have a PIC flag, but the assumption that the effects
1645
5772
        prev=vinfo
1646
5773
        continue
1647
5774
        ;;
 
5775
 
1648
5776
      -version-number)
1649
5777
        prev=vinfo
1650
5778
        vinfo_number=yes
1651
5779
        continue
1652
5780
        ;;
1653
5781
 
 
5782
      -weak)
 
5783
        prev=weak
 
5784
        continue
 
5785
        ;;
 
5786
 
1654
5787
      -Wc,*)
1655
 
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
 
5788
        func_stripname '-Wc,' '' "$arg"
 
5789
        args=$func_stripname_result
1656
5790
        arg=
1657
5791
        save_ifs="$IFS"; IFS=','
1658
5792
        for flag in $args; do
1659
5793
          IFS="$save_ifs"
1660
 
          case $flag in
1661
 
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1662
 
            flag="\"$flag\""
1663
 
            ;;
1664
 
          esac
1665
 
          arg="$arg $wl$flag"
1666
 
          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"
1667
5797
        done
1668
5798
        IFS="$save_ifs"
1669
 
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
 
5799
        func_stripname ' ' '' "$arg"
 
5800
        arg=$func_stripname_result
1670
5801
        ;;
1671
5802
 
1672
5803
      -Wl,*)
1673
 
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
 
5804
        func_stripname '-Wl,' '' "$arg"
 
5805
        args=$func_stripname_result
1674
5806
        arg=
1675
5807
        save_ifs="$IFS"; IFS=','
1676
5808
        for flag in $args; do
1677
5809
          IFS="$save_ifs"
1678
 
          case $flag in
1679
 
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1680
 
            flag="\"$flag\""
1681
 
            ;;
1682
 
          esac
1683
 
          arg="$arg $wl$flag"
1684
 
          compiler_flags="$compiler_flags $wl$flag"
1685
 
          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"
1686
5814
        done
1687
5815
        IFS="$save_ifs"
1688
 
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
 
5816
        func_stripname ' ' '' "$arg"
 
5817
        arg=$func_stripname_result
1689
5818
        ;;
1690
5819
 
1691
5820
      -Xcompiler)
1703
5832
        continue
1704
5833
        ;;
1705
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
 
1706
5865
      # Some other compiler flag.
1707
5866
      -* | +*)
1708
 
        # Unknown arguments in both finalize_command and compile_command need
1709
 
        # to be aesthetically quoted because they are evaled later.
1710
 
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1711
 
        case $arg in
1712
 
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1713
 
          arg="\"$arg\""
1714
 
          ;;
1715
 
        esac
 
5867
        func_quote_for_eval "$arg"
 
5868
        arg="$func_quote_for_eval_result"
1716
5869
        ;;
1717
5870
 
1718
5871
      *.$objext)
1719
5872
        # A standard object.
1720
 
        objs="$objs $arg"
 
5873
        func_append objs " $arg"
1721
5874
        ;;
1722
5875
 
1723
5876
      *.lo)
1724
5877
        # A libtool-controlled object.
1725
5878
 
1726
5879
        # Check to see that this really is a libtool object.
1727
 
        if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 
5880
        if func_lalib_unsafe_p "$arg"; then
1728
5881
          pic_object=
1729
5882
          non_pic_object=
1730
5883
 
1731
5884
          # Read the .lo file
1732
 
          # If there is no directory component, then add one.
1733
 
          case $arg in
1734
 
          */* | *\\*) . $arg ;;
1735
 
          *) . ./$arg ;;
1736
 
          esac
 
5885
          func_source "$arg"
1737
5886
 
1738
 
          if test -z "$pic_object" || \
 
5887
          if test -z "$pic_object" ||
1739
5888
             test -z "$non_pic_object" ||
1740
 
             test "$pic_object" = none && \
 
5889
             test "$pic_object" = none &&
1741
5890
             test "$non_pic_object" = none; then
1742
 
            $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1743
 
            exit $EXIT_FAILURE
 
5891
            func_fatal_error "cannot find name of object for \`$arg'"
1744
5892
          fi
1745
5893
 
1746
5894
          # Extract subdirectory from the argument.
1747
 
          xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1748
 
          if test "X$xdir" = "X$arg"; then
1749
 
            xdir=
1750
 
          else
1751
 
            xdir="$xdir/"
1752
 
          fi
 
5895
          func_dirname "$arg" "/" ""
 
5896
          xdir="$func_dirname_result"
1753
5897
 
1754
5898
          if test "$pic_object" != none; then
1755
5899
            # Prepend the subdirectory the object is found in.
1757
5901
 
1758
5902
            if test "$prev" = dlfiles; then
1759
5903
              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1760
 
                dlfiles="$dlfiles $pic_object"
 
5904
                func_append dlfiles " $pic_object"
1761
5905
                prev=
1762
5906
                continue
1763
5907
              else
1769
5913
            # CHECK ME:  I think I busted this.  -Ossama
1770
5914
            if test "$prev" = dlprefiles; then
1771
5915
              # Preload the old-style object.
1772
 
              dlprefiles="$dlprefiles $pic_object"
 
5916
              func_append dlprefiles " $pic_object"
1773
5917
              prev=
1774
5918
            fi
1775
5919
 
1776
5920
            # A PIC object.
1777
 
            libobjs="$libobjs $pic_object"
 
5921
            func_append libobjs " $pic_object"
1778
5922
            arg="$pic_object"
1779
5923
          fi
1780
5924
 
1784
5928
            non_pic_object="$xdir$non_pic_object"
1785
5929
 
1786
5930
            # A standard non-PIC object
1787
 
            non_pic_objects="$non_pic_objects $non_pic_object"
 
5931
            func_append non_pic_objects " $non_pic_object"
1788
5932
            if test -z "$pic_object" || test "$pic_object" = none ; then
1789
5933
              arg="$non_pic_object"
1790
5934
            fi
 
5935
          else
 
5936
            # If the PIC object exists, use it instead.
 
5937
            # $xdir was prepended to $pic_object above.
 
5938
            non_pic_object="$pic_object"
 
5939
            func_append non_pic_objects " $non_pic_object"
1791
5940
          fi
1792
5941
        else
1793
5942
          # Only an error if not doing a dry-run.
1794
 
          if test -z "$run"; then
1795
 
            $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1796
 
            exit $EXIT_FAILURE
1797
 
          else
1798
 
            # Dry-run case.
1799
 
 
 
5943
          if $opt_dry_run; then
1800
5944
            # Extract subdirectory from the argument.
1801
 
            xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1802
 
            if test "X$xdir" = "X$arg"; then
1803
 
              xdir=
1804
 
            else
1805
 
              xdir="$xdir/"
1806
 
            fi
 
5945
            func_dirname "$arg" "/" ""
 
5946
            xdir="$func_dirname_result"
1807
5947
 
1808
 
            pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1809
 
            non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1810
 
            libobjs="$libobjs $pic_object"
1811
 
            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"
1812
5955
          fi
1813
5956
        fi
1814
5957
        ;;
1815
5958
 
1816
5959
      *.$libext)
1817
5960
        # An archive.
1818
 
        deplibs="$deplibs $arg"
1819
 
        old_deplibs="$old_deplibs $arg"
 
5961
        func_append deplibs " $arg"
 
5962
        func_append old_deplibs " $arg"
1820
5963
        continue
1821
5964
        ;;
1822
5965
 
1823
5966
      *.la)
1824
5967
        # A libtool-controlled library.
1825
5968
 
 
5969
        func_resolve_sysroot "$arg"
1826
5970
        if test "$prev" = dlfiles; then
1827
5971
          # This library was specified with -dlopen.
1828
 
          dlfiles="$dlfiles $arg"
 
5972
          func_append dlfiles " $func_resolve_sysroot_result"
1829
5973
          prev=
1830
5974
        elif test "$prev" = dlprefiles; then
1831
5975
          # The library was specified with -dlpreopen.
1832
 
          dlprefiles="$dlprefiles $arg"
 
5976
          func_append dlprefiles " $func_resolve_sysroot_result"
1833
5977
          prev=
1834
5978
        else
1835
 
          deplibs="$deplibs $arg"
 
5979
          func_append deplibs " $func_resolve_sysroot_result"
1836
5980
        fi
1837
5981
        continue
1838
5982
        ;;
1841
5985
      *)
1842
5986
        # Unknown arguments in both finalize_command and compile_command need
1843
5987
        # to be aesthetically quoted because they are evaled later.
1844
 
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1845
 
        case $arg in
1846
 
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1847
 
          arg="\"$arg\""
1848
 
          ;;
1849
 
        esac
 
5988
        func_quote_for_eval "$arg"
 
5989
        arg="$func_quote_for_eval_result"
1850
5990
        ;;
1851
5991
      esac # arg
1852
5992
 
1853
5993
      # Now actually substitute the argument into the commands.
1854
5994
      if test -n "$arg"; then
1855
 
        compile_command="$compile_command $arg"
1856
 
        finalize_command="$finalize_command $arg"
 
5995
        func_append compile_command " $arg"
 
5996
        func_append finalize_command " $arg"
1857
5997
      fi
1858
5998
    done # argument parsing loop
1859
5999
 
1860
 
    if test -n "$prev"; then
1861
 
      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1862
 
      $echo "$help" 1>&2
1863
 
      exit $EXIT_FAILURE
1864
 
    fi
 
6000
    test -n "$prev" && \
 
6001
      func_fatal_help "the \`$prevarg' option requires an argument"
1865
6002
 
1866
6003
    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1867
6004
      eval arg=\"$export_dynamic_flag_spec\"
1868
 
      compile_command="$compile_command $arg"
1869
 
      finalize_command="$finalize_command $arg"
 
6005
      func_append compile_command " $arg"
 
6006
      func_append finalize_command " $arg"
1870
6007
    fi
1871
6008
 
1872
6009
    oldlibs=
1873
6010
    # calculate the name of the file, without its directory
1874
 
    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
 
6011
    func_basename "$output"
 
6012
    outputname="$func_basename_result"
1875
6013
    libobjs_save="$libobjs"
1876
6014
 
1877
6015
    if test -n "$shlibpath_var"; then
1878
6016
      # get the directories listed in $shlibpath_var
1879
 
      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
 
6017
      eval shlib_search_path=\`\$ECHO \"\${$shlibpath_var}\" \| \$SED \'s/:/ /g\'\`
1880
6018
    else
1881
6019
      shlib_search_path=
1882
6020
    fi
1883
6021
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1884
6022
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1885
6023
 
1886
 
    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1887
 
    if test "X$output_objdir" = "X$output"; then
1888
 
      output_objdir="$objdir"
1889
 
    else
1890
 
      output_objdir="$output_objdir/$objdir"
1891
 
    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
1892
6028
    # Create the object directory.
1893
 
    if test ! -d "$output_objdir"; then
1894
 
      $show "$mkdir $output_objdir"
1895
 
      $run $mkdir $output_objdir
1896
 
      status=$?
1897
 
      if test "$status" -ne 0 && test ! -d "$output_objdir"; then
1898
 
        exit $status
1899
 
      fi
1900
 
    fi
 
6029
    func_mkdir_p "$output_objdir"
1901
6030
 
1902
6031
    # Determine the type of output
1903
6032
    case $output in
1904
6033
    "")
1905
 
      $echo "$modename: you must specify an output file" 1>&2
1906
 
      $echo "$help" 1>&2
1907
 
      exit $EXIT_FAILURE
 
6034
      func_fatal_help "you must specify an output file"
1908
6035
      ;;
1909
6036
    *.$libext) linkmode=oldlib ;;
1910
6037
    *.lo | *.$objext) linkmode=obj ;;
1912
6039
    *) linkmode=prog ;; # Anything else should be a program.
1913
6040
    esac
1914
6041
 
1915
 
    case $host in
1916
 
    *cygwin* | *mingw* | *pw32*)
1917
 
      # don't eliminate duplications in $postdeps and $predeps
1918
 
      duplicate_compiler_generated_deps=yes
1919
 
      ;;
1920
 
    *)
1921
 
      duplicate_compiler_generated_deps=$duplicate_deps
1922
 
      ;;
1923
 
    esac
1924
6042
    specialdeplibs=
1925
6043
 
1926
6044
    libs=
1927
6045
    # Find all interdependent deplibs by searching for libraries
1928
6046
    # that are linked more than once (e.g. -la -lb -la)
1929
6047
    for deplib in $deplibs; do
1930
 
      if test "X$duplicate_deps" = "Xyes" ; then
 
6048
      if $opt_preserve_dup_deps ; then
1931
6049
        case "$libs " in
1932
 
        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
6050
        *" $deplib "*) func_append specialdeplibs " $deplib" ;;
1933
6051
        esac
1934
6052
      fi
1935
 
      libs="$libs $deplib"
 
6053
      func_append libs " $deplib"
1936
6054
    done
1937
6055
 
1938
6056
    if test "$linkmode" = lib; then
1942
6060
      # $postdeps and mark them as special (i.e., whose duplicates are
1943
6061
      # not to be eliminated).
1944
6062
      pre_post_deps=
1945
 
      if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
 
6063
      if $opt_duplicate_compiler_generated_deps; then
1946
6064
        for pre_post_dep in $predeps $postdeps; do
1947
6065
          case "$pre_post_deps " in
1948
 
          *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
 
6066
          *" $pre_post_dep "*) func_append specialdeplibs " $pre_post_deps" ;;
1949
6067
          esac
1950
 
          pre_post_deps="$pre_post_deps $pre_post_dep"
 
6068
          func_append pre_post_deps " $pre_post_dep"
1951
6069
        done
1952
6070
      fi
1953
6071
      pre_post_deps=
1959
6077
    need_relink=no # whether we're linking any uninstalled libtool libraries
1960
6078
    notinst_deplibs= # not-installed libtool libraries
1961
6079
    notinst_path= # paths that contain not-installed libtool libraries
 
6080
 
1962
6081
    case $linkmode in
1963
6082
    lib)
1964
 
        passes="conv link"
 
6083
        passes="conv dlpreopen link"
1965
6084
        for file in $dlfiles $dlprefiles; do
1966
6085
          case $file in
1967
6086
          *.la) ;;
1968
6087
          *)
1969
 
            $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1970
 
            exit $EXIT_FAILURE
 
6088
            func_fatal_help "libraries can \`-dlopen' only libtool libraries: $file"
1971
6089
            ;;
1972
6090
          esac
1973
6091
        done
1983
6101
    *)  passes="conv"
1984
6102
        ;;
1985
6103
    esac
 
6104
 
1986
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
 
1987
6118
      if test "$linkmode,$pass" = "lib,link" ||
1988
6119
         test "$linkmode,$pass" = "prog,scan"; then
1989
6120
        libs="$deplibs"
1993
6124
        case $pass in
1994
6125
        dlopen) libs="$dlfiles" ;;
1995
6126
        dlpreopen) libs="$dlprefiles" ;;
1996
 
        link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
 
6127
        link)
 
6128
          libs="$deplibs %DEPLIBS%"
 
6129
          test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
 
6130
          ;;
1997
6131
        esac
1998
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
1999
6156
      if test "$pass" = dlopen; then
2000
6157
        # Collect dlpreopened libraries
2001
6158
        save_deplibs="$deplibs"
2002
6159
        deplibs=
2003
6160
      fi
 
6161
 
2004
6162
      for deplib in $libs; do
2005
6163
        lib=
2006
6164
        found=no
2007
6165
        case $deplib in
2008
 
        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
 
6166
        -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe \
 
6167
        |-threads|-fopenmp|-openmp|-mp|-xopenmp|-omp|-qsmp=*)
2009
6168
          if test "$linkmode,$pass" = "prog,link"; then
2010
6169
            compile_deplibs="$deplib $compile_deplibs"
2011
6170
            finalize_deplibs="$deplib $finalize_deplibs"
2012
6171
          else
2013
 
            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
2014
6179
          fi
2015
6180
          continue
2016
6181
          ;;
2017
6182
        -l*)
2018
6183
          if test "$linkmode" != lib && test "$linkmode" != prog; then
2019
 
            $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
 
6184
            func_warning "\`-l' is ignored for archives/objects"
2020
6185
            continue
2021
6186
          fi
2022
 
          name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
2023
 
          for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
 
6187
          func_stripname '-l' '' "$deplib"
 
6188
          name=$func_stripname_result
 
6189
          if test "$linkmode" = lib; then
 
6190
            searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
 
6191
          else
 
6192
            searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
 
6193
          fi
 
6194
          for searchdir in $searchdirs; do
2024
6195
            for search_ext in .la $std_shrext .so .a; do
2025
6196
              # Search the libtool library
2026
6197
              lib="$searchdir/lib${name}${search_ext}"
2050
6221
            if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
2051
6222
              case " $predeps $postdeps " in
2052
6223
              *" $deplib "*)
2053
 
                if (${SED} -e '2q' $lib |
2054
 
                    grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 
6224
                if func_lalib_p "$lib"; then
2055
6225
                  library_names=
2056
6226
                  old_library=
2057
 
                  case $lib in
2058
 
                  */* | *\\*) . $lib ;;
2059
 
                  *) . ./$lib ;;
2060
 
                  esac
 
6227
                  func_source "$lib"
2061
6228
                  for l in $old_library $library_names; do
2062
6229
                    ll="$l"
2063
6230
                  done
2064
6231
                  if test "X$ll" = "X$old_library" ; then # only static version available
2065
6232
                    found=no
2066
 
                    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2067
 
                    test "X$ladir" = "X$lib" && ladir="."
 
6233
                    func_dirname "$lib" "" "."
 
6234
                    ladir="$func_dirname_result"
2068
6235
                    lib=$ladir/$old_library
2069
6236
                    if test "$linkmode,$pass" = "prog,link"; then
2070
6237
                      compile_deplibs="$deplib $compile_deplibs"
2076
6243
                    continue
2077
6244
                  fi
2078
6245
                fi
2079
 
                ;;
 
6246
                ;;
2080
6247
              *) ;;
2081
6248
              esac
2082
6249
            fi
2083
6250
          fi
2084
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
          ;;
2085
6267
        -L*)
2086
6268
          case $linkmode in
2087
6269
          lib)
2088
6270
            deplibs="$deplib $deplibs"
2089
6271
            test "$pass" = conv && continue
2090
6272
            newdependency_libs="$deplib $newdependency_libs"
2091
 
            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"
2092
6276
            ;;
2093
6277
          prog)
2094
6278
            if test "$pass" = conv; then
2101
6285
              compile_deplibs="$deplib $compile_deplibs"
2102
6286
              finalize_deplibs="$deplib $finalize_deplibs"
2103
6287
            fi
2104
 
            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"
2105
6291
            ;;
2106
6292
          *)
2107
 
            $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
 
6293
            func_warning "\`-L' is ignored for archives/objects"
2108
6294
            ;;
2109
6295
          esac # linkmode
2110
6296
          continue
2111
6297
          ;; # -L
2112
6298
        -R*)
2113
6299
          if test "$pass" = link; then
2114
 
            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
2115
6303
            # Make sure the xrpath contains only unique directories.
2116
6304
            case "$xrpath " in
2117
6305
            *" $dir "*) ;;
2118
 
            *) xrpath="$xrpath $dir" ;;
 
6306
            *) func_append xrpath " $dir" ;;
2119
6307
            esac
2120
6308
          fi
2121
6309
          deplibs="$deplib $deplibs"
2122
6310
          continue
2123
6311
          ;;
2124
 
        *.la) lib="$deplib" ;;
 
6312
        *.la)
 
6313
          func_resolve_sysroot "$deplib"
 
6314
          lib=$func_resolve_sysroot_result
 
6315
          ;;
2125
6316
        *.$libext)
2126
6317
          if test "$pass" = conv; then
2127
6318
            deplibs="$deplib $deplibs"
2129
6320
          fi
2130
6321
          case $linkmode in
2131
6322
          lib)
2132
 
            valid_a_lib=no
2133
 
            case $deplibs_check_method in
2134
 
              match_pattern*)
2135
 
                set dummy $deplibs_check_method
2136
 
                match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2137
 
                if eval $echo \"$deplib\" 2>/dev/null \
2138
 
                    | $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 \
2139
6334
                    | $EGREP "$match_pattern_regex" > /dev/null; then
 
6335
                    valid_a_lib=yes
 
6336
                  fi
 
6337
                ;;
 
6338
                pass_all)
2140
6339
                  valid_a_lib=yes
2141
 
                fi
2142
 
                ;;
2143
 
              pass_all)
2144
 
                valid_a_lib=yes
2145
 
                ;;
2146
 
            esac
2147
 
            if test "$valid_a_lib" != yes; then
2148
 
              $echo
2149
 
              $echo "*** Warning: Trying to link with static lib archive $deplib."
2150
 
              $echo "*** I have the capability to make that library automatically link in when"
2151
 
              $echo "*** you link to this library.  But I can only do this if you have a"
2152
 
              $echo "*** shared version of the library, which you do not appear to have"
2153
 
              $echo "*** because the file extensions .$libext of this argument makes me believe"
2154
 
              $echo "*** that it is just a static archive that I should not used here."
2155
 
            else
2156
 
              $echo
2157
 
              $echo "*** Warning: Linking the shared library $output against the"
2158
 
              $echo "*** static library $deplib is not portable!"
2159
 
              deplibs="$deplib $deplibs"
2160
 
            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
2161
6358
            continue
2162
6359
            ;;
2163
6360
          prog)
2178
6375
            if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2179
6376
              # If there is no dlopen support or we're linking statically,
2180
6377
              # we need to preload.
2181
 
              newdlprefiles="$newdlprefiles $deplib"
 
6378
              func_append newdlprefiles " $deplib"
2182
6379
              compile_deplibs="$deplib $compile_deplibs"
2183
6380
              finalize_deplibs="$deplib $finalize_deplibs"
2184
6381
            else
2185
 
              newdlfiles="$newdlfiles $deplib"
 
6382
              func_append newdlfiles " $deplib"
2186
6383
            fi
2187
6384
          fi
2188
6385
          continue
2192
6389
          continue
2193
6390
          ;;
2194
6391
        esac # case $deplib
 
6392
 
2195
6393
        if test "$found" = yes || test -f "$lib"; then :
2196
6394
        else
2197
 
          $echo "$modename: cannot find the library \`$lib'" 1>&2
2198
 
          exit $EXIT_FAILURE
 
6395
          func_fatal_error "cannot find the library \`$lib' or unhandled argument \`$deplib'"
2199
6396
        fi
2200
6397
 
2201
6398
        # Check to see that this really is a libtool archive.
2202
 
        if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2203
 
        else
2204
 
          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2205
 
          exit $EXIT_FAILURE
2206
 
        fi
 
6399
        func_lalib_unsafe_p "$lib" \
 
6400
          || func_fatal_error "\`$lib' is not a valid libtool archive"
2207
6401
 
2208
 
        ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2209
 
        test "X$ladir" = "X$lib" && ladir="."
 
6402
        func_dirname "$lib" "" "."
 
6403
        ladir="$func_dirname_result"
2210
6404
 
2211
6405
        dlname=
2212
6406
        dlopen=
2214
6408
        libdir=
2215
6409
        library_names=
2216
6410
        old_library=
 
6411
        inherited_linker_flags=
2217
6412
        # If the library was installed with an old release of libtool,
2218
6413
        # it will not redefine variables installed, or shouldnotlink
2219
6414
        installed=yes
2222
6417
 
2223
6418
 
2224
6419
        # Read the .la file
2225
 
        case $lib in
2226
 
        */* | *\\*) . $lib ;;
2227
 
        *) . ./$lib ;;
2228
 
        esac
 
6420
        func_source "$lib"
2229
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'`
2230
6433
        if test "$linkmode,$pass" = "lib,link" ||
2231
6434
           test "$linkmode,$pass" = "prog,scan" ||
2232
6435
           { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2233
 
          test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2234
 
          test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
 
6436
          test -n "$dlopen" && func_append dlfiles " $dlopen"
 
6437
          test -n "$dlpreopen" && func_append dlprefiles " $dlpreopen"
2235
6438
        fi
2236
6439
 
2237
6440
        if test "$pass" = conv; then
2239
6442
          deplibs="$lib $deplibs"
2240
6443
          if test -z "$libdir"; then
2241
6444
            if test -z "$old_library"; then
2242
 
              $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2243
 
              exit $EXIT_FAILURE
 
6445
              func_fatal_error "cannot find name of link library for \`$lib'"
2244
6446
            fi
2245
6447
            # It is a libtool convenience library, so add in its objects.
2246
 
            convenience="$convenience $ladir/$objdir/$old_library"
2247
 
            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"
2248
6450
            tmp_libs=
2249
6451
            for deplib in $dependency_libs; do
2250
6452
              deplibs="$deplib $deplibs"
2251
 
              if test "X$duplicate_deps" = "Xyes" ; then
2252
 
                case "$tmp_libs " in
2253
 
                *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2254
 
                esac
2255
 
              fi
2256
 
              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"
2257
6459
            done
2258
6460
          elif test "$linkmode" != prog && test "$linkmode" != lib; then
2259
 
            $echo "$modename: \`$lib' is not a convenience library" 1>&2
2260
 
            exit $EXIT_FAILURE
 
6461
            func_fatal_error "\`$lib' is not a convenience library"
2261
6462
          fi
2262
6463
          continue
2263
6464
        fi # $pass = conv
2265
6466
 
2266
6467
        # Get the name of the library we link against.
2267
6468
        linklib=
2268
 
        for l in $old_library $library_names; do
2269
 
          linklib="$l"
2270
 
        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
2271
6478
        if test -z "$linklib"; then
2272
 
          $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2273
 
          exit $EXIT_FAILURE
 
6479
          func_fatal_error "cannot find name of link library for \`$lib'"
2274
6480
        fi
2275
6481
 
2276
6482
        # This library was specified with -dlopen.
2277
6483
        if test "$pass" = dlopen; then
2278
6484
          if test -z "$libdir"; then
2279
 
            $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2280
 
            exit $EXIT_FAILURE
 
6485
            func_fatal_error "cannot -dlopen a convenience library: \`$lib'"
2281
6486
          fi
2282
6487
          if test -z "$dlname" ||
2283
6488
             test "$dlopen_support" != yes ||
2286
6491
            # statically, we need to preload.  We also need to preload any
2287
6492
            # dependent libraries so libltdl's deplib preloader doesn't
2288
6493
            # bomb out in the load deplibs phase.
2289
 
            dlprefiles="$dlprefiles $lib $dependency_libs"
 
6494
            func_append dlprefiles " $lib $dependency_libs"
2290
6495
          else
2291
 
            newdlfiles="$newdlfiles $lib"
 
6496
            func_append newdlfiles " $lib"
2292
6497
          fi
2293
6498
          continue
2294
6499
        fi # $pass = dlopen
2299
6504
        *)
2300
6505
          abs_ladir=`cd "$ladir" && pwd`
2301
6506
          if test -z "$abs_ladir"; then
2302
 
            $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2303
 
            $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"
2304
6509
            abs_ladir="$ladir"
2305
6510
          fi
2306
6511
          ;;
2307
6512
        esac
2308
 
        laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
 
6513
        func_basename "$lib"
 
6514
        laname="$func_basename_result"
2309
6515
 
2310
6516
        # Find the relevant object directory and library name.
2311
6517
        if test "X$installed" = Xyes; then
2312
 
          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2313
 
            $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."
2314
6520
            dir="$ladir"
2315
6521
            absdir="$abs_ladir"
2316
6522
            libdir="$abs_ladir"
2317
6523
          else
2318
 
            dir="$libdir"
2319
 
            absdir="$libdir"
 
6524
            dir="$lt_sysroot$libdir"
 
6525
            absdir="$lt_sysroot$libdir"
2320
6526
          fi
2321
6527
          test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
2322
6528
        else
2324
6530
            dir="$ladir"
2325
6531
            absdir="$abs_ladir"
2326
6532
            # Remove this search path later
2327
 
            notinst_path="$notinst_path $abs_ladir"
 
6533
            func_append notinst_path " $abs_ladir"
2328
6534
          else
2329
6535
            dir="$ladir/$objdir"
2330
6536
            absdir="$abs_ladir/$objdir"
2331
6537
            # Remove this search path later
2332
 
            notinst_path="$notinst_path $abs_ladir"
 
6538
            func_append notinst_path " $abs_ladir"
2333
6539
          fi
2334
6540
        fi # $installed = yes
2335
 
        name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 
6541
        func_stripname 'lib' '.la' "$laname"
 
6542
        name=$func_stripname_result
2336
6543
 
2337
6544
        # This library was specified with -dlpreopen.
2338
6545
        if test "$pass" = dlpreopen; then
2339
 
          if test -z "$libdir"; then
2340
 
            $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2341
 
            exit $EXIT_FAILURE
2342
 
          fi
2343
 
          # Prefer using a static library (so that no silly _DYNAMIC symbols
2344
 
          # are required to link).
2345
 
          if test -n "$old_library"; then
2346
 
            newdlprefiles="$newdlprefiles $dir/$old_library"
2347
 
          # Otherwise, use the dlname, so that lt_dlopen finds it.
2348
 
          elif test -n "$dlname"; then
2349
 
            newdlprefiles="$newdlprefiles $dir/$dlname"
2350
 
          else
2351
 
            newdlprefiles="$newdlprefiles $dir/$linklib"
2352
 
          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
2353
6589
        fi # $pass = dlpreopen
2354
6590
 
2355
6591
        if test -z "$libdir"; then
2367
6603
 
2368
6604
 
2369
6605
        if test "$linkmode" = prog && test "$pass" != link; then
2370
 
          newlib_search_path="$newlib_search_path $ladir"
 
6606
          func_append newlib_search_path " $ladir"
2371
6607
          deplibs="$lib $deplibs"
2372
6608
 
2373
6609
          linkalldeplibs=no
2379
6615
          tmp_libs=
2380
6616
          for deplib in $dependency_libs; do
2381
6617
            case $deplib in
2382
 
            -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
                 ;;
2383
6622
            esac
2384
6623
            # Need to link against all dependency_libs?
2385
6624
            if test "$linkalldeplibs" = yes; then
2389
6628
              # or/and link against static libraries
2390
6629
              newdependency_libs="$deplib $newdependency_libs"
2391
6630
            fi
2392
 
            if test "X$duplicate_deps" = "Xyes" ; then
 
6631
            if $opt_preserve_dup_deps ; then
2393
6632
              case "$tmp_libs " in
2394
 
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
6633
              *" $deplib "*) func_append specialdeplibs " $deplib" ;;
2395
6634
              esac
2396
6635
            fi
2397
 
            tmp_libs="$tmp_libs $deplib"
 
6636
            func_append tmp_libs " $deplib"
2398
6637
          done # for deplib
2399
6638
          continue
2400
6639
        fi # $linkmode = prog...
2401
6640
 
2402
6641
        if test "$linkmode,$pass" = "prog,link"; then
2403
6642
          if test -n "$library_names" &&
2404
 
             { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
 
6643
             { { test "$prefer_static_libs" = no ||
 
6644
                 test "$prefer_static_libs,$installed" = "built,yes"; } ||
 
6645
               test -z "$old_library"; }; then
2405
6646
            # We need to hardcode the library path
2406
6647
            if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
2407
6648
              # Make sure the rpath contains only unique directories.
2408
 
              case "$temp_rpath " in
2409
 
              *" $dir "*) ;;
2410
 
              *" $absdir "*) ;;
2411
 
              *) temp_rpath="$temp_rpath $absdir" ;;
 
6649
              case "$temp_rpath:" in
 
6650
              *"$absdir:"*) ;;
 
6651
              *) func_append temp_rpath "$absdir:" ;;
2412
6652
              esac
2413
6653
            fi
2414
6654
 
2420
6660
            *)
2421
6661
              case "$compile_rpath " in
2422
6662
              *" $absdir "*) ;;
2423
 
              *) compile_rpath="$compile_rpath $absdir"
 
6663
              *) func_append compile_rpath " $absdir" ;;
2424
6664
              esac
2425
6665
              ;;
2426
6666
            esac
2429
6669
            *)
2430
6670
              case "$finalize_rpath " in
2431
6671
              *" $libdir "*) ;;
2432
 
              *) finalize_rpath="$finalize_rpath $libdir"
 
6672
              *) func_append finalize_rpath " $libdir" ;;
2433
6673
              esac
2434
6674
              ;;
2435
6675
            esac
2445
6685
        fi
2446
6686
 
2447
6687
        link_static=no # Whether the deplib will be linked statically
 
6688
        use_static_libs=$prefer_static_libs
 
6689
        if test "$use_static_libs" = built && test "$installed" = yes; then
 
6690
          use_static_libs=no
 
6691
        fi
2448
6692
        if test -n "$library_names" &&
2449
 
           { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2450
 
          if test "$installed" = no; then
2451
 
            notinst_deplibs="$notinst_deplibs $lib"
2452
 
            need_relink=yes
2453
 
          fi
 
6693
           { test "$use_static_libs" = no || test -z "$old_library"; }; then
 
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
2454
6707
          # This is a shared library
2455
6708
 
2456
 
          # Warn about portability, can't link against -module's on
2457
 
          # some systems (darwin)
2458
 
          if test "$shouldnotlink" = yes && test "$pass" = link ; then
2459
 
            $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
2460
6720
            if test "$linkmode" = prog; then
2461
 
              $echo "*** Warning: Linking the executable $output against the loadable module"
 
6721
              $ECHO "*** Warning: Linking the executable $output against the loadable module"
2462
6722
            else
2463
 
              $echo "*** Warning: Linking the shared library $output against the loadable module"
 
6723
              $ECHO "*** Warning: Linking the shared library $output against the loadable module"
2464
6724
            fi
2465
 
            $echo "*** $linklib is not portable!"
 
6725
            $ECHO "*** $linklib is not portable!"
2466
6726
          fi
2467
6727
          if test "$linkmode" = lib &&
2468
6728
             test "$hardcode_into_libs" = yes; then
2474
6734
            *)
2475
6735
              case "$compile_rpath " in
2476
6736
              *" $absdir "*) ;;
2477
 
              *) compile_rpath="$compile_rpath $absdir"
 
6737
              *) func_append compile_rpath " $absdir" ;;
2478
6738
              esac
2479
6739
              ;;
2480
6740
            esac
2483
6743
            *)
2484
6744
              case "$finalize_rpath " in
2485
6745
              *" $libdir "*) ;;
2486
 
              *) finalize_rpath="$finalize_rpath $libdir"
 
6746
              *) func_append finalize_rpath " $libdir" ;;
2487
6747
              esac
2488
6748
              ;;
2489
6749
            esac
2492
6752
          if test -n "$old_archive_from_expsyms_cmds"; then
2493
6753
            # figure out the soname
2494
6754
            set dummy $library_names
2495
 
            realname="$2"
2496
 
            shift; shift
2497
 
            libname=`eval \\$echo \"$libname_spec\"`
 
6755
            shift
 
6756
            realname="$1"
 
6757
            shift
 
6758
            libname=`eval "\\$ECHO \"$libname_spec\""`
2498
6759
            # use dlname if we got it. it's perfectly good, no?
2499
6760
            if test -n "$dlname"; then
2500
6761
              soname="$dlname"
2501
6762
            elif test -n "$soname_spec"; then
2502
6763
              # bleh windows
2503
6764
              case $host in
2504
 
              *cygwin* | mingw*)
2505
 
                major=`expr $current - $age`
 
6765
              *cygwin* | mingw* | *cegcc*)
 
6766
                func_arith $current - $age
 
6767
                major=$func_arith_result
2506
6768
                versuffix="-$major"
2507
6769
                ;;
2508
6770
              esac
2513
6775
 
2514
6776
            # Make a new name for the extract_expsyms_cmds to use
2515
6777
            soroot="$soname"
2516
 
            soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2517
 
            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
2518
6782
 
2519
6783
            # If the library has no export list, then create one now
2520
6784
            if test -f "$output_objdir/$soname-def"; then :
2521
6785
            else
2522
 
              $show "extracting exported symbol list from \`$soname'"
2523
 
              save_ifs="$IFS"; IFS='~'
2524
 
              cmds=$extract_expsyms_cmds
2525
 
              for cmd in $cmds; do
2526
 
                IFS="$save_ifs"
2527
 
                eval cmd=\"$cmd\"
2528
 
                $show "$cmd"
2529
 
                $run eval "$cmd" || exit $?
2530
 
              done
2531
 
              IFS="$save_ifs"
 
6786
              func_verbose "extracting exported symbol list from \`$soname'"
 
6787
              func_execute_cmds "$extract_expsyms_cmds" 'exit $?'
2532
6788
            fi
2533
6789
 
2534
6790
            # Create $newlib
2535
6791
            if test -f "$output_objdir/$newlib"; then :; else
2536
 
              $show "generating import library for \`$soname'"
2537
 
              save_ifs="$IFS"; IFS='~'
2538
 
              cmds=$old_archive_from_expsyms_cmds
2539
 
              for cmd in $cmds; do
2540
 
                IFS="$save_ifs"
2541
 
                eval cmd=\"$cmd\"
2542
 
                $show "$cmd"
2543
 
                $run eval "$cmd" || exit $?
2544
 
              done
2545
 
              IFS="$save_ifs"
 
6792
              func_verbose "generating import library for \`$soname'"
 
6793
              func_execute_cmds "$old_archive_from_expsyms_cmds" 'exit $?'
2546
6794
            fi
2547
6795
            # make sure the library variables are pointing to the new library
2548
6796
            dir=$output_objdir
2549
6797
            linklib=$newlib
2550
6798
          fi # test -n "$old_archive_from_expsyms_cmds"
2551
6799
 
2552
 
          if test "$linkmode" = prog || test "$mode" != relink; then
 
6800
          if test "$linkmode" = prog || test "$opt_mode" != relink; then
2553
6801
            add_shlibpath=
2554
6802
            add_dir=
2555
6803
            add=
2559
6807
              if test "$hardcode_direct" = no; then
2560
6808
                add="$dir/$linklib"
2561
6809
                case $host in
2562
 
                  *-*-sco3.2v5* ) add_dir="-L$dir" ;;
 
6810
                  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
 
6811
                  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
 
6812
                  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
 
6813
                    *-*-unixware7*) add_dir="-L$dir" ;;
2563
6814
                  *-*-darwin* )
2564
 
                    # if the lib is a module then we can not link against
2565
 
                    # it, someone is ignoring the new warnings I added
2566
 
                    if /usr/bin/file -L $add 2> /dev/null | $EGREP "bundle" >/dev/null ; then
2567
 
                      $echo "** Warning, lib $linklib is a module, not a shared library"
2568
 
                      if test -z "$old_library" ; then
2569
 
                        $echo
2570
 
                        $echo "** And there doesn't seem to be a static archive available"
2571
 
                        $echo "** The link will probably fail, sorry"
2572
 
                      else
2573
 
                        add="$dir/$old_library"
 
6815
                    # if the lib is a (non-dlopened) module then we can not
 
6816
                    # link against it, someone is ignoring the earlier warnings
 
6817
                    if /usr/bin/file -L $add 2> /dev/null |
 
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"
2574
6830
                      fi
2575
6831
                    fi
2576
6832
                esac
2588
6844
              fi
2589
6845
              ;;
2590
6846
            relink)
2591
 
              if test "$hardcode_direct" = yes; then
 
6847
              if test "$hardcode_direct" = yes &&
 
6848
                 test "$hardcode_direct_absolute" = no; then
2592
6849
                add="$dir/$linklib"
2593
6850
              elif test "$hardcode_minus_L" = yes; then
2594
 
                add_dir="-L$dir"
 
6851
                add_dir="-L$absdir"
2595
6852
                # Try looking first in the location we're being installed to.
2596
6853
                if test -n "$inst_prefix_dir"; then
2597
6854
                  case $libdir in
2598
6855
                    [\\/]*)
2599
 
                      add_dir="$add_dir -L$inst_prefix_dir$libdir"
 
6856
                      func_append add_dir " -L$inst_prefix_dir$libdir"
2600
6857
                      ;;
2601
6858
                  esac
2602
6859
                fi
2612
6869
            esac
2613
6870
 
2614
6871
            if test "$lib_linked" != yes; then
2615
 
              $echo "$modename: configuration error: unsupported hardcode properties"
2616
 
              exit $EXIT_FAILURE
 
6872
              func_fatal_configuration "unsupported hardcode properties"
2617
6873
            fi
2618
6874
 
2619
6875
            if test -n "$add_shlibpath"; then
2620
6876
              case :$compile_shlibpath: in
2621
6877
              *":$add_shlibpath:"*) ;;
2622
 
              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
 
6878
              *) func_append compile_shlibpath "$add_shlibpath:" ;;
2623
6879
              esac
2624
6880
            fi
2625
6881
            if test "$linkmode" = prog; then
2628
6884
            else
2629
6885
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
2630
6886
              test -n "$add" && deplibs="$add $deplibs"
2631
 
              if test "$hardcode_direct" != yes && \
2632
 
                 test "$hardcode_minus_L" != yes && \
 
6887
              if test "$hardcode_direct" != yes &&
 
6888
                 test "$hardcode_minus_L" != yes &&
2633
6889
                 test "$hardcode_shlibpath_var" = yes; then
2634
6890
                case :$finalize_shlibpath: in
2635
6891
                *":$libdir:"*) ;;
2636
 
                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
 
6892
                *) func_append finalize_shlibpath "$libdir:" ;;
2637
6893
                esac
2638
6894
              fi
2639
6895
            fi
2640
6896
          fi
2641
6897
 
2642
 
          if test "$linkmode" = prog || test "$mode" = relink; then
 
6898
          if test "$linkmode" = prog || test "$opt_mode" = relink; then
2643
6899
            add_shlibpath=
2644
6900
            add_dir=
2645
6901
            add=
2646
6902
            # Finalize command for both is simple: just hardcode it.
2647
 
            if test "$hardcode_direct" = yes; then
 
6903
            if test "$hardcode_direct" = yes &&
 
6904
               test "$hardcode_direct_absolute" = no; then
2648
6905
              add="$libdir/$linklib"
2649
6906
            elif test "$hardcode_minus_L" = yes; then
2650
6907
              add_dir="-L$libdir"
2652
6909
            elif test "$hardcode_shlibpath_var" = yes; then
2653
6910
              case :$finalize_shlibpath: in
2654
6911
              *":$libdir:"*) ;;
2655
 
              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
 
6912
              *) func_append finalize_shlibpath "$libdir:" ;;
2656
6913
              esac
2657
6914
              add="-l$name"
2658
6915
            elif test "$hardcode_automatic" = yes; then
2659
6916
              if test -n "$inst_prefix_dir" &&
2660
6917
                 test -f "$inst_prefix_dir$libdir/$linklib" ; then
2661
 
                add="$inst_prefix_dir$libdir/$linklib"
 
6918
                add="$inst_prefix_dir$libdir/$linklib"
2662
6919
              else
2663
 
                add="$libdir/$linklib"
 
6920
                add="$libdir/$linklib"
2664
6921
              fi
2665
6922
            else
2666
6923
              # We cannot seem to hardcode it, guess we'll fake it.
2669
6926
              if test -n "$inst_prefix_dir"; then
2670
6927
                case $libdir in
2671
6928
                  [\\/]*)
2672
 
                    add_dir="$add_dir -L$inst_prefix_dir$libdir"
 
6929
                    func_append add_dir " -L$inst_prefix_dir$libdir"
2673
6930
                    ;;
2674
6931
                esac
2675
6932
              fi
2704
6961
 
2705
6962
            # Just print a warning and add the library to dependency_libs so
2706
6963
            # that the program can be linked against the static library.
2707
 
            $echo
2708
 
            $echo "*** Warning: This system can not link to static lib archive $lib."
2709
 
            $echo "*** I have the capability to make that library automatically link in when"
2710
 
            $echo "*** you link to this library.  But I can only do this if you have a"
2711
 
            $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."
2712
6969
            if test "$module" = yes; then
2713
 
              $echo "*** But as you try to build a module library, libtool will still create "
2714
 
              $echo "*** a static module, that should work as long as the dlopening application"
2715
 
              $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."
2716
6973
              if test -z "$global_symbol_pipe"; then
2717
 
                $echo
2718
 
                $echo "*** However, this would only work if libtool was able to extract symbol"
2719
 
                $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2720
 
                $echo "*** not find such a program.  So, this module is probably useless."
2721
 
                $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."
2722
6979
              fi
2723
6980
              if test "$build_old_libs" = no; then
2724
6981
                build_libtool_libs=module
2742
6999
            temp_deplibs=
2743
7000
            for libdir in $dependency_libs; do
2744
7001
              case $libdir in
2745
 
              -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
 
7002
              -R*) func_stripname '-R' '' "$libdir"
 
7003
                   temp_xrpath=$func_stripname_result
2746
7004
                   case " $xrpath " in
2747
7005
                   *" $temp_xrpath "*) ;;
2748
 
                   *) xrpath="$xrpath $temp_xrpath";;
 
7006
                   *) func_append xrpath " $temp_xrpath";;
2749
7007
                   esac;;
2750
 
              *) temp_deplibs="$temp_deplibs $libdir";;
 
7008
              *) func_append temp_deplibs " $libdir";;
2751
7009
              esac
2752
7010
            done
2753
7011
            dependency_libs="$temp_deplibs"
2754
7012
          fi
2755
7013
 
2756
 
          newlib_search_path="$newlib_search_path $absdir"
 
7014
          func_append newlib_search_path " $absdir"
2757
7015
          # Link against this library
2758
7016
          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2759
7017
          # ... and its dependency_libs
2760
7018
          tmp_libs=
2761
7019
          for deplib in $dependency_libs; do
2762
7020
            newdependency_libs="$deplib $newdependency_libs"
2763
 
            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
2764
7027
              case "$tmp_libs " in
2765
 
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
 
7028
              *" $func_resolve_sysroot_result "*)
 
7029
                func_append specialdeplibs " $func_resolve_sysroot_result" ;;
2766
7030
              esac
2767
7031
            fi
2768
 
            tmp_libs="$tmp_libs $deplib"
 
7032
            func_append tmp_libs " $func_resolve_sysroot_result"
2769
7033
          done
2770
7034
 
2771
7035
          if test "$link_all_deplibs" != no; then
2772
7036
            # Add the search paths of all dependency libraries
2773
7037
            for deplib in $dependency_libs; do
 
7038
              path=
2774
7039
              case $deplib in
2775
7040
              -L*) path="$deplib" ;;
2776
7041
              *.la)
2777
 
                dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2778
 
                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
2779
7046
                # We need an absolute path.
2780
7047
                case $dir in
2781
7048
                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2782
7049
                *)
2783
7050
                  absdir=`cd "$dir" && pwd`
2784
7051
                  if test -z "$absdir"; then
2785
 
                    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
 
7052
                    func_warning "cannot determine absolute directory name of \`$dir'"
2786
7053
                    absdir="$dir"
2787
7054
                  fi
2788
7055
                  ;;
2789
7056
                esac
2790
 
                if grep "^installed=no" $deplib > /dev/null; then
2791
 
                  path="$absdir/$objdir"
2792
 
                else
2793
 
                  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2794
 
                  if test -z "$libdir"; then
2795
 
                    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2796
 
                    exit $EXIT_FAILURE
2797
 
                  fi
2798
 
                  if test "$absdir" != "$libdir"; then
2799
 
                    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2800
 
                  fi
2801
 
                  path="$absdir"
2802
 
                fi
2803
 
                depdepl=
 
7057
                if $GREP "^installed=no" $deplib > /dev/null; then
2804
7058
                case $host in
2805
7059
                *-*-darwin*)
2806
 
                  # we do not want to link against static libs,
2807
 
                  # but need to link against shared
 
7060
                  depdepl=
2808
7061
                  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2809
7062
                  if test -n "$deplibrary_names" ; then
2810
7063
                    for tmp in $deplibrary_names ; do
2811
7064
                      depdepl=$tmp
2812
7065
                    done
2813
 
                    if test -f "$path/$depdepl" ; then
2814
 
                      depdepl="$path/$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=
2815
7075
                    fi
2816
 
                    # do not add paths which are already there
2817
 
                    case " $newlib_search_path " in
2818
 
                    *" $path "*) ;;
2819
 
                    *) newlib_search_path="$newlib_search_path $path";;
2820
 
                    esac
2821
7076
                  fi
2822
 
                  path=""
2823
7077
                  ;;
2824
7078
                *)
2825
 
                  path="-L$path"
2826
 
                  ;;
2827
 
                esac
2828
 
                ;;
2829
 
              -l*)
2830
 
                case $host in
2831
 
                *-*-darwin*)
2832
 
                  # Again, we only want to link against shared libraries
2833
 
                  eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2834
 
                  for tmp in $newlib_search_path ; do
2835
 
                    if test -f "$tmp/lib$tmp_libs.dylib" ; then
2836
 
                      eval depdepl="$tmp/lib$tmp_libs.dylib"
2837
 
                      break
2838
 
                    fi
2839
 
                  done
2840
 
                  path=""
2841
 
                  ;;
2842
 
                *) continue ;;
2843
 
                esac
2844
 
                ;;
2845
 
              *) 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
                ;;
2846
7092
              esac
2847
7093
              case " $deplibs " in
2848
7094
              *" $path "*) ;;
2849
7095
              *) deplibs="$path $deplibs" ;;
2850
7096
              esac
2851
 
              case " $deplibs " in
2852
 
              *" $depdepl "*) ;;
2853
 
              *) deplibs="$depdepl $deplibs" ;;
2854
 
              esac
2855
7097
            done
2856
7098
          fi # link_all_deplibs != no
2857
7099
        fi # linkmode = lib
2858
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
2859
7109
      dependency_libs="$newdependency_libs"
2860
7110
      if test "$pass" = dlpreopen; then
2861
7111
        # Link the dlpreopened libraries before other libraries
2870
7120
          for dir in $newlib_search_path; do
2871
7121
            case "$lib_search_path " in
2872
7122
            *" $dir "*) ;;
2873
 
            *) lib_search_path="$lib_search_path $dir" ;;
 
7123
            *) func_append lib_search_path " $dir" ;;
2874
7124
            esac
2875
7125
          done
2876
7126
          newlib_search_path=
2928
7178
            -L*)
2929
7179
              case " $tmp_libs " in
2930
7180
              *" $deplib "*) ;;
2931
 
              *) tmp_libs="$tmp_libs $deplib" ;;
 
7181
              *) func_append tmp_libs " $deplib" ;;
2932
7182
              esac
2933
7183
              ;;
2934
 
            *) tmp_libs="$tmp_libs $deplib" ;;
 
7184
            *) func_append tmp_libs " $deplib" ;;
2935
7185
            esac
2936
7186
          done
2937
7187
          eval $var=\"$tmp_libs\"
2947
7197
          ;;
2948
7198
        esac
2949
7199
        if test -n "$i" ; then
2950
 
          tmp_libs="$tmp_libs $i"
 
7200
          func_append tmp_libs " $i"
2951
7201
        fi
2952
7202
      done
2953
7203
      dependency_libs=$tmp_libs
2954
7204
    done # for pass
2955
7205
    if test "$linkmode" = prog; then
2956
7206
      dlfiles="$newdlfiles"
 
7207
    fi
 
7208
    if test "$linkmode" = prog || test "$linkmode" = lib; then
2957
7209
      dlprefiles="$newdlprefiles"
2958
7210
    fi
2959
7211
 
2960
7212
    case $linkmode in
2961
7213
    oldlib)
2962
 
      if test -n "$deplibs"; then
2963
 
        $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
2964
 
      fi
2965
 
 
2966
7214
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2967
 
        $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2968
 
      fi
2969
 
 
2970
 
      if test -n "$rpath"; then
2971
 
        $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2972
 
      fi
2973
 
 
2974
 
      if test -n "$xrpath"; then
2975
 
        $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2976
 
      fi
2977
 
 
2978
 
      if test -n "$vinfo"; then
2979
 
        $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
2980
 
      fi
2981
 
 
2982
 
      if test -n "$release"; then
2983
 
        $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2984
 
      fi
2985
 
 
2986
 
      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2987
 
        $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2988
 
      fi
 
7215
        func_warning "\`-dlopen' is ignored for archives"
 
7216
      fi
 
7217
 
 
7218
      case " $deplibs" in
 
7219
      *\ -l* | *\ -L*)
 
7220
        func_warning "\`-l' and \`-L' are ignored for archives" ;;
 
7221
      esac
 
7222
 
 
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"
2989
7237
 
2990
7238
      # Now set the variables for building old libraries.
2991
7239
      build_libtool_libs=no
2992
7240
      oldlibs="$output"
2993
 
      objs="$objs$old_deplibs"
 
7241
      func_append objs "$old_deplibs"
2994
7242
      ;;
2995
7243
 
2996
7244
    lib)
2997
7245
      # Make sure we only generate libraries of the form `libNAME.la'.
2998
7246
      case $outputname in
2999
7247
      lib*)
3000
 
        name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
 
7248
        func_stripname 'lib' '.la' "$outputname"
 
7249
        name=$func_stripname_result
3001
7250
        eval shared_ext=\"$shrext_cmds\"
3002
7251
        eval libname=\"$libname_spec\"
3003
7252
        ;;
3004
7253
      *)
3005
 
        if test "$module" = no; then
3006
 
          $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
3007
 
          $echo "$help" 1>&2
3008
 
          exit $EXIT_FAILURE
3009
 
        fi
 
7254
        test "$module" = no && \
 
7255
          func_fatal_help "libtool library \`$output' must begin with \`lib'"
 
7256
 
3010
7257
        if test "$need_lib_prefix" != no; then
3011
7258
          # Add the "lib" prefix for modules if required
3012
 
          name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
 
7259
          func_stripname '' '.la' "$outputname"
 
7260
          name=$func_stripname_result
3013
7261
          eval shared_ext=\"$shrext_cmds\"
3014
7262
          eval libname=\"$libname_spec\"
3015
7263
        else
3016
 
          libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
 
7264
          func_stripname '' '.la' "$outputname"
 
7265
          libname=$func_stripname_result
3017
7266
        fi
3018
7267
        ;;
3019
7268
      esac
3020
7269
 
3021
7270
      if test -n "$objs"; then
3022
7271
        if test "$deplibs_check_method" != pass_all; then
3023
 
          $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
3024
 
          exit $EXIT_FAILURE
 
7272
          func_fatal_error "cannot build libtool library \`$output' from non-libtool objects on this host:$objs"
3025
7273
        else
3026
 
          $echo
3027
 
          $echo "*** Warning: Linking the shared library $output against the non-libtool"
3028
 
          $echo "*** objects $objs is not portable!"
3029
 
          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"
3030
7278
        fi
3031
7279
      fi
3032
7280
 
3033
 
      if test "$dlself" != no; then
3034
 
        $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
3035
 
      fi
 
7281
      test "$dlself" != no && \
 
7282
        func_warning "\`-dlopen self' is ignored for libtool libraries"
3036
7283
 
3037
7284
      set dummy $rpath
3038
 
      if test "$#" -gt 2; then
3039
 
        $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
3040
 
      fi
3041
 
      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"
3042
7290
 
3043
7291
      oldlibs=
3044
7292
      if test -z "$rpath"; then
3052
7300
          build_old_libs=yes
3053
7301
        fi
3054
7302
 
3055
 
        if test -n "$vinfo"; then
3056
 
          $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3057
 
        fi
 
7303
        test -n "$vinfo" && \
 
7304
          func_warning "\`-version-info/-version-number' is ignored for convenience libraries"
3058
7305
 
3059
 
        if test -n "$release"; then
3060
 
          $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
3061
 
        fi
 
7306
        test -n "$release" && \
 
7307
          func_warning "\`-release' is ignored for convenience libraries"
3062
7308
      else
3063
7309
 
3064
7310
        # Parse the version information argument.
3065
7311
        save_ifs="$IFS"; IFS=':'
3066
7312
        set dummy $vinfo 0 0 0
 
7313
        shift
3067
7314
        IFS="$save_ifs"
3068
7315
 
3069
 
        if test -n "$8"; then
3070
 
          $echo "$modename: too many parameters to \`-version-info'" 1>&2
3071
 
          $echo "$help" 1>&2
3072
 
          exit $EXIT_FAILURE
3073
 
        fi
 
7316
        test -n "$7" && \
 
7317
          func_fatal_help "too many parameters to \`-version-info'"
3074
7318
 
3075
7319
        # convert absolute version numbers to libtool ages
3076
7320
        # this retains compatibility with .la files and attempts
3078
7322
 
3079
7323
        case $vinfo_number in
3080
7324
        yes)
3081
 
          number_major="$2"
3082
 
          number_minor="$3"
3083
 
          number_revision="$4"
 
7325
          number_major="$1"
 
7326
          number_minor="$2"
 
7327
          number_revision="$3"
3084
7328
          #
3085
7329
          # There are really only two kinds -- those that
3086
7330
          # use the current revision as the major version
3089
7333
          # which has an extra 1 added just for fun
3090
7334
          #
3091
7335
          case $version_type in
3092
 
          darwin|linux|osf|windows)
3093
 
            current=`expr $number_major + $number_minor`
 
7336
          # correct linux to gnu/linux during the next big refactor
 
7337
          darwin|linux|osf|windows|none)
 
7338
            func_arith $number_major + $number_minor
 
7339
            current=$func_arith_result
3094
7340
            age="$number_minor"
3095
7341
            revision="$number_revision"
3096
7342
            ;;
3097
 
          freebsd-aout|freebsd-elf|sunos)
 
7343
          freebsd-aout|freebsd-elf|qnx|sunos)
3098
7344
            current="$number_major"
3099
7345
            revision="$number_minor"
3100
7346
            age="0"
3101
7347
            ;;
3102
7348
          irix|nonstopux)
3103
 
            current=`expr $number_major + $number_minor - 1`
 
7349
            func_arith $number_major + $number_minor
 
7350
            current=$func_arith_result
3104
7351
            age="$number_minor"
3105
7352
            revision="$number_minor"
 
7353
            lt_irix_increment=no
 
7354
            ;;
 
7355
          *)
 
7356
            func_fatal_configuration "$modename: unknown library version type \`$version_type'"
3106
7357
            ;;
3107
7358
          esac
3108
7359
          ;;
3109
7360
        no)
3110
 
          current="$2"
3111
 
          revision="$3"
3112
 
          age="$4"
 
7361
          current="$1"
 
7362
          revision="$2"
 
7363
          age="$3"
3113
7364
          ;;
3114
7365
        esac
3115
7366
 
3117
7368
        case $current in
3118
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]) ;;
3119
7370
        *)
3120
 
          $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
3121
 
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3122
 
          exit $EXIT_FAILURE
 
7371
          func_error "CURRENT \`$current' must be a nonnegative integer"
 
7372
          func_fatal_error "\`$vinfo' is not valid version information"
3123
7373
          ;;
3124
7374
        esac
3125
7375
 
3126
7376
        case $revision in
3127
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]) ;;
3128
7378
        *)
3129
 
          $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
3130
 
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3131
 
          exit $EXIT_FAILURE
 
7379
          func_error "REVISION \`$revision' must be a nonnegative integer"
 
7380
          func_fatal_error "\`$vinfo' is not valid version information"
3132
7381
          ;;
3133
7382
        esac
3134
7383
 
3135
7384
        case $age in
3136
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]) ;;
3137
7386
        *)
3138
 
          $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
3139
 
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3140
 
          exit $EXIT_FAILURE
 
7387
          func_error "AGE \`$age' must be a nonnegative integer"
 
7388
          func_fatal_error "\`$vinfo' is not valid version information"
3141
7389
          ;;
3142
7390
        esac
3143
7391
 
3144
7392
        if test "$age" -gt "$current"; then
3145
 
          $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
3146
 
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3147
 
          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"
3148
7395
        fi
3149
7396
 
3150
7397
        # Calculate the version variables.
3157
7404
        darwin)
3158
7405
          # Like Linux, but with the current version available in
3159
7406
          # verstring for coding it into the library header
3160
 
          major=.`expr $current - $age`
 
7407
          func_arith $current - $age
 
7408
          major=.$func_arith_result
3161
7409
          versuffix="$major.$age.$revision"
3162
7410
          # Darwin ld doesn't like 0 for these options...
3163
 
          minor_current=`expr $current + 1`
3164
 
          verstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
 
7411
          func_arith $current + 1
 
7412
          minor_current=$func_arith_result
 
7413
          xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
 
7414
          verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
3165
7415
          ;;
3166
7416
 
3167
7417
        freebsd-aout)
3171
7421
 
3172
7422
        freebsd-elf)
3173
7423
          major=".$current"
3174
 
          versuffix=".$current";
 
7424
          versuffix=".$current"
3175
7425
          ;;
3176
7426
 
3177
7427
        irix | nonstopux)
3178
 
          major=`expr $current - $age + 1`
 
7428
          if test "X$lt_irix_increment" = "Xno"; then
 
7429
            func_arith $current - $age
 
7430
          else
 
7431
            func_arith $current - $age + 1
 
7432
          fi
 
7433
          major=$func_arith_result
3179
7434
 
3180
7435
          case $version_type in
3181
7436
            nonstopux) verstring_prefix=nonstopux ;;
3186
7441
          # Add in all the interfaces that we are compatible with.
3187
7442
          loop=$revision
3188
7443
          while test "$loop" -ne 0; do
3189
 
            iface=`expr $revision - $loop`
3190
 
            loop=`expr $loop - 1`
 
7444
            func_arith $revision - $loop
 
7445
            iface=$func_arith_result
 
7446
            func_arith $loop - 1
 
7447
            loop=$func_arith_result
3191
7448
            verstring="$verstring_prefix$major.$iface:$verstring"
3192
7449
          done
3193
7450
 
3196
7453
          versuffix="$major.$revision"
3197
7454
          ;;
3198
7455
 
3199
 
        linux)
3200
 
          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
3201
7459
          versuffix="$major.$age.$revision"
3202
7460
          ;;
3203
7461
 
3204
7462
        osf)
3205
 
          major=.`expr $current - $age`
 
7463
          func_arith $current - $age
 
7464
          major=.$func_arith_result
3206
7465
          versuffix=".$current.$age.$revision"
3207
7466
          verstring="$current.$age.$revision"
3208
7467
 
3209
7468
          # Add in all the interfaces that we are compatible with.
3210
7469
          loop=$age
3211
7470
          while test "$loop" -ne 0; do
3212
 
            iface=`expr $current - $loop`
3213
 
            loop=`expr $loop - 1`
 
7471
            func_arith $current - $loop
 
7472
            iface=$func_arith_result
 
7473
            func_arith $loop - 1
 
7474
            loop=$func_arith_result
3214
7475
            verstring="$verstring:${iface}.0"
3215
7476
          done
3216
7477
 
3217
7478
          # Make executables depend on our current version.
3218
 
          verstring="$verstring:${current}.0"
 
7479
          func_append verstring ":${current}.0"
 
7480
          ;;
 
7481
 
 
7482
        qnx)
 
7483
          major=".$current"
 
7484
          versuffix=".$current"
3219
7485
          ;;
3220
7486
 
3221
7487
        sunos)
3226
7492
        windows)
3227
7493
          # Use '-' rather than '.', since we only want one
3228
7494
          # extension on DOS 8.3 filesystems.
3229
 
          major=`expr $current - $age`
 
7495
          func_arith $current - $age
 
7496
          major=$func_arith_result
3230
7497
          versuffix="-$major"
3231
7498
          ;;
3232
7499
 
3233
7500
        *)
3234
 
          $echo "$modename: unknown library version type \`$version_type'" 1>&2
3235
 
          $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3236
 
          exit $EXIT_FAILURE
 
7501
          func_fatal_configuration "unknown library version type \`$version_type'"
3237
7502
          ;;
3238
7503
        esac
3239
7504
 
3267
7532
        # Check to see if the archive will have undefined symbols.
3268
7533
        if test "$allow_undefined" = yes; then
3269
7534
          if test "$allow_undefined_flag" = unsupported; then
3270
 
            $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
 
7535
            func_warning "undefined symbols not allowed in $host shared libraries"
3271
7536
            build_libtool_libs=no
3272
7537
            build_old_libs=yes
3273
7538
          fi
3275
7540
          # Don't allow undefined symbols.
3276
7541
          allow_undefined_flag="$no_undefined_flag"
3277
7542
        fi
 
7543
 
3278
7544
      fi
3279
7545
 
3280
 
      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
3281
7551
        # Remove our outputs, but don't remove object files since they
3282
7552
        # may have been created when compiling PIC objects.
3283
7553
        removelist=
3284
 
        tempremovelist=`$echo "$output_objdir/*"`
 
7554
        tempremovelist=`$ECHO "$output_objdir/*"`
3285
7555
        for p in $tempremovelist; do
3286
7556
          case $p in
3287
 
            *.$objext)
 
7557
            *.$objext | *.gcno)
3288
7558
               ;;
3289
7559
            $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3290
7560
               if test "X$precious_files_regex" != "X"; then
3291
 
                 if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3292
 
                 then
 
7561
                 if $ECHO "$p" | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
 
7562
                 then
3293
7563
                   continue
3294
7564
                 fi
3295
7565
               fi
3296
 
               removelist="$removelist $p"
 
7566
               func_append removelist " $p"
3297
7567
               ;;
3298
7568
            *) ;;
3299
7569
          esac
3300
7570
        done
3301
 
        if test -n "$removelist"; then
3302
 
          $show "${rm}r $removelist"
3303
 
          $run ${rm}r $removelist
3304
 
        fi
 
7571
        test -n "$removelist" && \
 
7572
          func_show_eval "${RM}r \$removelist"
3305
7573
      fi
3306
7574
 
3307
7575
      # Now set the variables for building old libraries.
3308
7576
      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3309
 
        oldlibs="$oldlibs $output_objdir/$libname.$libext"
 
7577
        func_append oldlibs " $output_objdir/$libname.$libext"
3310
7578
 
3311
7579
        # Transform .lo files to .o files.
3312
 
        oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
 
7580
        oldobjs="$objs "`$ECHO "$libobjs" | $SP2NL | $SED "/\.${libext}$/d; $lo2o" | $NL2SP`
3313
7581
      fi
3314
7582
 
3315
7583
      # Eliminate all temporary directories.
3316
 
      for path in $notinst_path; do
3317
 
        lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
3318
 
        deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
3319
 
        dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
3320
 
      done
 
7584
      #for path in $notinst_path; do
 
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"`
 
7588
      #done
3321
7589
 
3322
7590
      if test -n "$xrpath"; then
3323
7591
        # If the user specified any rpath flags, then add them.
3324
7592
        temp_xrpath=
3325
7593
        for libdir in $xrpath; do
3326
 
          temp_xrpath="$temp_xrpath -R$libdir"
 
7594
          func_replace_sysroot "$libdir"
 
7595
          func_append temp_xrpath " -R$func_replace_sysroot_result"
3327
7596
          case "$finalize_rpath " in
3328
7597
          *" $libdir "*) ;;
3329
 
          *) finalize_rpath="$finalize_rpath $libdir" ;;
 
7598
          *) func_append finalize_rpath " $libdir" ;;
3330
7599
          esac
3331
7600
        done
3332
7601
        if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3340
7609
      for lib in $old_dlfiles; do
3341
7610
        case " $dlprefiles $dlfiles " in
3342
7611
        *" $lib "*) ;;
3343
 
        *) dlfiles="$dlfiles $lib" ;;
 
7612
        *) func_append dlfiles " $lib" ;;
3344
7613
        esac
3345
7614
      done
3346
7615
 
3350
7619
      for lib in $old_dlprefiles; do
3351
7620
        case "$dlprefiles " in
3352
7621
        *" $lib "*) ;;
3353
 
        *) dlprefiles="$dlprefiles $lib" ;;
 
7622
        *) func_append dlprefiles " $lib" ;;
3354
7623
        esac
3355
7624
      done
3356
7625
 
3357
7626
      if test "$build_libtool_libs" = yes; then
3358
7627
        if test -n "$rpath"; then
3359
7628
          case $host in
3360
 
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
 
7629
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos* | *-cegcc* | *-*-haiku*)
3361
7630
            # these systems don't actually have a c library (as such)!
3362
7631
            ;;
3363
7632
          *-*-rhapsody* | *-*-darwin1.[012])
3364
7633
            # Rhapsody C library is in the System framework
3365
 
            deplibs="$deplibs -framework System"
 
7634
            func_append deplibs " System.ltframework"
3366
7635
            ;;
3367
7636
          *-*-netbsd*)
3368
7637
            # Don't link with libc until the a.out ld.so is fixed.
3369
7638
            ;;
3370
7639
          *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
3371
7640
            # Do not include libc due to us having libc/libc_r.
3372
 
            test "X$arg" = "X-lc" && continue
3373
 
            ;;
3374
 
          *)
 
7641
            ;;
 
7642
          *-*-sco3.2v5* | *-*-sco5v6*)
 
7643
            # Causes problems with __ctype
 
7644
            ;;
 
7645
          *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
 
7646
            # Compiler inserts libc in the correct place for threads to work
 
7647
            ;;
 
7648
          *)
3375
7649
            # Add libc to deplibs on all other systems if necessary.
3376
7650
            if test "$build_libtool_need_lc" = "yes"; then
3377
 
              deplibs="$deplibs -lc"
 
7651
              func_append deplibs " -lc"
3378
7652
            fi
3379
7653
            ;;
3380
7654
          esac
3408
7682
          # limits. Maybe even breaks it.  We compile a program, linking it
3409
7683
          # against the deplibs as a proxy for the library.  Then we can check
3410
7684
          # whether they linked in statically or dynamically with ldd.
3411
 
          $rm conftest.c
 
7685
          $opt_dry_run || $RM conftest.c
3412
7686
          cat > conftest.c <<EOF
3413
7687
          int main() { return 0; }
3414
7688
EOF
3415
 
          $rm conftest
3416
 
          $LTCC -o conftest conftest.c $deplibs
3417
 
          if test "$?" -eq 0 ; then
 
7689
          $opt_dry_run || $RM conftest
 
7690
          if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
3418
7691
            ldd_output=`ldd conftest`
3419
7692
            for i in $deplibs; do
3420
 
              name=`expr $i : '-l\(.*\)'`
3421
 
              # If $name is empty we are operating on a -L argument.
3422
 
              if test "$name" != "" && test "$name" -ne "0"; then
 
7693
              case $i in
 
7694
              -l*)
 
7695
                func_stripname -l '' "$i"
 
7696
                name=$func_stripname_result
3423
7697
                if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3424
7698
                  case " $predeps $postdeps " in
3425
7699
                  *" $i "*)
3426
 
                    newdeplibs="$newdeplibs $i"
 
7700
                    func_append newdeplibs " $i"
3427
7701
                    i=""
3428
7702
                    ;;
3429
7703
                  esac
3430
 
                fi
 
7704
                fi
3431
7705
                if test -n "$i" ; then
3432
 
                  libname=`eval \\$echo \"$libname_spec\"`
3433
 
                  deplib_matches=`eval \\$echo \"$library_names_spec\"`
3434
 
                  set dummy $deplib_matches
3435
 
                  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
3436
7710
                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3437
 
                    newdeplibs="$newdeplibs $i"
 
7711
                    func_append newdeplibs " $i"
3438
7712
                  else
3439
7713
                    droppeddeps=yes
3440
 
                    $echo
3441
 
                    $echo "*** Warning: dynamic linker does not accept needed library $i."
3442
 
                    $echo "*** I have the capability to make that library automatically link in when"
3443
 
                    $echo "*** you link to this library.  But I can only do this if you have a"
3444
 
                    $echo "*** shared version of the library, which I believe you do not have"
3445
 
                    $echo "*** because a test_compile did reveal that the linker did not use it for"
3446
 
                    $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."
3447
7721
                  fi
3448
7722
                fi
3449
 
              else
3450
 
                newdeplibs="$newdeplibs $i"
3451
 
              fi
 
7723
                ;;
 
7724
              *)
 
7725
                func_append newdeplibs " $i"
 
7726
                ;;
 
7727
              esac
3452
7728
            done
3453
7729
          else
3454
7730
            # Error occurred in the first compile.  Let's try to salvage
3455
7731
            # the situation: Compile a separate program for each library.
3456
7732
            for i in $deplibs; do
3457
 
              name=`expr $i : '-l\(.*\)'`
3458
 
              # If $name is empty we are operating on a -L argument.
3459
 
              if test "$name" != "" && test "$name" != "0"; then
3460
 
                $rm conftest
3461
 
                $LTCC -o conftest conftest.c $i
3462
 
                # Did it work?
3463
 
                if test "$?" -eq 0 ; then
 
7733
              case $i in
 
7734
              -l*)
 
7735
                func_stripname -l '' "$i"
 
7736
                name=$func_stripname_result
 
7737
                $opt_dry_run || $RM conftest
 
7738
                if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
3464
7739
                  ldd_output=`ldd conftest`
3465
7740
                  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3466
7741
                    case " $predeps $postdeps " in
3467
7742
                    *" $i "*)
3468
 
                      newdeplibs="$newdeplibs $i"
 
7743
                      func_append newdeplibs " $i"
3469
7744
                      i=""
3470
7745
                      ;;
3471
7746
                    esac
3472
7747
                  fi
3473
7748
                  if test -n "$i" ; then
3474
 
                    libname=`eval \\$echo \"$libname_spec\"`
3475
 
                    deplib_matches=`eval \\$echo \"$library_names_spec\"`
3476
 
                    set dummy $deplib_matches
3477
 
                    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
3478
7753
                    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3479
 
                      newdeplibs="$newdeplibs $i"
 
7754
                      func_append newdeplibs " $i"
3480
7755
                    else
3481
7756
                      droppeddeps=yes
3482
 
                      $echo
3483
 
                      $echo "*** Warning: dynamic linker does not accept needed library $i."
3484
 
                      $echo "*** I have the capability to make that library automatically link in when"
3485
 
                      $echo "*** you link to this library.  But I can only do this if you have a"
3486
 
                      $echo "*** shared version of the library, which you do not appear to have"
3487
 
                      $echo "*** because a test_compile did reveal that the linker did not use this one"
3488
 
                      $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."
3489
7764
                    fi
3490
7765
                  fi
3491
7766
                else
3492
7767
                  droppeddeps=yes
3493
 
                  $echo
3494
 
                  $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3495
 
                  $echo "***  make it link in!  You will probably need to install it or some"
3496
 
                  $echo "*** library that it depends on before this library will be fully"
3497
 
                  $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."
3498
7773
                fi
3499
 
              else
3500
 
                newdeplibs="$newdeplibs $i"
3501
 
              fi
 
7774
                ;;
 
7775
              *)
 
7776
                func_append newdeplibs " $i"
 
7777
                ;;
 
7778
              esac
3502
7779
            done
3503
7780
          fi
3504
7781
          ;;
3505
7782
        file_magic*)
3506
 
          set dummy $deplibs_check_method
3507
 
          file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
 
7783
          set dummy $deplibs_check_method; shift
 
7784
          file_magic_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
3508
7785
          for a_deplib in $deplibs; do
3509
 
            name=`expr $a_deplib : '-l\(.*\)'`
3510
 
            # If $name is empty we are operating on a -L argument.
3511
 
            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
3512
7790
              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3513
7791
                case " $predeps $postdeps " in
3514
7792
                *" $a_deplib "*)
3515
 
                  newdeplibs="$newdeplibs $a_deplib"
 
7793
                  func_append newdeplibs " $a_deplib"
3516
7794
                  a_deplib=""
3517
7795
                  ;;
3518
7796
                esac
3519
7797
              fi
3520
7798
              if test -n "$a_deplib" ; then
3521
 
                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`
3522
7806
                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3523
 
                  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
3524
7814
                  for potent_lib in $potential_libs; do
3525
7815
                      # Follow soft links.
3526
 
                      if ls -lLd "$potent_lib" 2>/dev/null \
3527
 
                         | grep " -> " >/dev/null; then
 
7816
                      if ls -lLd "$potent_lib" 2>/dev/null |
 
7817
                         $GREP " -> " >/dev/null; then
3528
7818
                        continue
3529
7819
                      fi
3530
7820
                      # The statement above tries to avoid entering an
3537
7827
                        potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3538
7828
                        case $potliblink in
3539
7829
                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3540
 
                        *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
 
7830
                        *) potlib=`$ECHO "$potlib" | $SED 's,[^/]*$,,'`"$potliblink";;
3541
7831
                        esac
3542
7832
                      done
3543
 
                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3544
 
                         | ${SED} 10q \
3545
 
                         | $EGREP "$file_magic_regex" > /dev/null; then
3546
 
                        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"
3547
7837
                        a_deplib=""
3548
7838
                        break 2
3549
7839
                      fi
3552
7842
              fi
3553
7843
              if test -n "$a_deplib" ; then
3554
7844
                droppeddeps=yes
3555
 
                $echo
3556
 
                $echo "*** Warning: linker path does not have real file for library $a_deplib."
3557
 
                $echo "*** I have the capability to make that library automatically link in when"
3558
 
                $echo "*** you link to this library.  But I can only do this if you have a"
3559
 
                $echo "*** shared version of the library, which you do not appear to have"
3560
 
                $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"
3561
7851
                if test -z "$potlib" ; then
3562
 
                  $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)"
3563
7853
                else
3564
 
                  $echo "*** with $libname and none of the candidates passed a file format test"
3565
 
                  $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"
3566
7856
                fi
3567
7857
              fi
3568
 
            else
 
7858
              ;;
 
7859
            *)
3569
7860
              # Add a -L argument.
3570
 
              newdeplibs="$newdeplibs $a_deplib"
3571
 
            fi
 
7861
              func_append newdeplibs " $a_deplib"
 
7862
              ;;
 
7863
            esac
3572
7864
          done # Gone through all deplibs.
3573
7865
          ;;
3574
7866
        match_pattern*)
3575
 
          set dummy $deplibs_check_method
3576
 
          match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
 
7867
          set dummy $deplibs_check_method; shift
 
7868
          match_pattern_regex=`expr "$deplibs_check_method" : "$1 \(.*\)"`
3577
7869
          for a_deplib in $deplibs; do
3578
 
            name=`expr $a_deplib : '-l\(.*\)'`
3579
 
            # If $name is empty we are operating on a -L argument.
3580
 
            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
3581
7874
              if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3582
7875
                case " $predeps $postdeps " in
3583
7876
                *" $a_deplib "*)
3584
 
                  newdeplibs="$newdeplibs $a_deplib"
 
7877
                  func_append newdeplibs " $a_deplib"
3585
7878
                  a_deplib=""
3586
7879
                  ;;
3587
7880
                esac
3588
7881
              fi
3589
7882
              if test -n "$a_deplib" ; then
3590
 
                libname=`eval \\$echo \"$libname_spec\"`
 
7883
                libname=`eval "\\$ECHO \"$libname_spec\""`
3591
7884
                for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3592
7885
                  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3593
7886
                  for potent_lib in $potential_libs; do
3594
7887
                    potlib="$potent_lib" # see symlink-check above in file_magic test
3595
 
                    if eval $echo \"$potent_lib\" 2>/dev/null \
3596
 
                        | ${SED} 10q \
3597
 
                        | $EGREP "$match_pattern_regex" > /dev/null; then
3598
 
                      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"
3599
7891
                      a_deplib=""
3600
7892
                      break 2
3601
7893
                    fi
3604
7896
              fi
3605
7897
              if test -n "$a_deplib" ; then
3606
7898
                droppeddeps=yes
3607
 
                $echo
3608
 
                $echo "*** Warning: linker path does not have real file for library $a_deplib."
3609
 
                $echo "*** I have the capability to make that library automatically link in when"
3610
 
                $echo "*** you link to this library.  But I can only do this if you have a"
3611
 
                $echo "*** shared version of the library, which you do not appear to have"
3612
 
                $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"
3613
7905
                if test -z "$potlib" ; then
3614
 
                  $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)"
3615
7907
                else
3616
 
                  $echo "*** with $libname and none of the candidates passed a file format test"
3617
 
                  $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"
3618
7910
                fi
3619
7911
              fi
3620
 
            else
 
7912
              ;;
 
7913
            *)
3621
7914
              # Add a -L argument.
3622
 
              newdeplibs="$newdeplibs $a_deplib"
3623
 
            fi
 
7915
              func_append newdeplibs " $a_deplib"
 
7916
              ;;
 
7917
            esac
3624
7918
          done # Gone through all deplibs.
3625
7919
          ;;
3626
7920
        none | unknown | *)
3627
7921
          newdeplibs=""
3628
 
          tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3629
 
            -e 's/ -[LR][^ ]*//g'`
 
7922
          tmp_deplibs=`$ECHO " $deplibs" | $SED 's/ -lc$//; s/ -[LR][^ ]*//g'`
3630
7923
          if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3631
7924
            for i in $predeps $postdeps ; do
3632
7925
              # can't use Xsed below, because $i might contain '/'
3633
 
              tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
 
7926
              tmp_deplibs=`$ECHO " $tmp_deplibs" | $SED "s,$i,,"`
3634
7927
            done
3635
7928
          fi
3636
 
          if $echo "X $tmp_deplibs" | $Xsed -e 's/[     ]//g' \
3637
 
            | grep . >/dev/null; then
3638
 
            $echo
 
7929
          case $tmp_deplibs in
 
7930
          *[!\  \ ]*)
 
7931
            echo
3639
7932
            if test "X$deplibs_check_method" = "Xnone"; then
3640
 
              $echo "*** Warning: inter-library dependencies are not supported in this platform."
 
7933
              echo "*** Warning: inter-library dependencies are not supported in this platform."
3641
7934
            else
3642
 
              $echo "*** Warning: inter-library dependencies are not known to be supported."
 
7935
              echo "*** Warning: inter-library dependencies are not known to be supported."
3643
7936
            fi
3644
 
            $echo "*** All declared inter-library dependencies are being dropped."
 
7937
            echo "*** All declared inter-library dependencies are being dropped."
3645
7938
            droppeddeps=yes
3646
 
          fi
 
7939
            ;;
 
7940
          esac
3647
7941
          ;;
3648
7942
        esac
3649
7943
        versuffix=$versuffix_save
3654
7948
 
3655
7949
        case $host in
3656
7950
        *-*-rhapsody* | *-*-darwin1.[012])
3657
 
          # On Rhapsody replace the C library is the System framework
3658
 
          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 /'`
3659
7953
          ;;
3660
7954
        esac
3661
7955
 
3662
7956
        if test "$droppeddeps" = yes; then
3663
7957
          if test "$module" = yes; then
3664
 
            $echo
3665
 
            $echo "*** Warning: libtool could not satisfy all declared inter-library"
3666
 
            $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3667
 
            $echo "*** a static module, that should work as long as the dlopening"
3668
 
            $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."
3669
7963
            if test -z "$global_symbol_pipe"; then
3670
 
              $echo
3671
 
              $echo "*** However, this would only work if libtool was able to extract symbol"
3672
 
              $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3673
 
              $echo "*** not find such a program.  So, this module is probably useless."
3674
 
              $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."
3675
7969
            fi
3676
7970
            if test "$build_old_libs" = no; then
3677
7971
              oldlibs="$output_objdir/$libname.$libext"
3681
7975
              build_libtool_libs=no
3682
7976
            fi
3683
7977
          else
3684
 
            $echo "*** The inter-library dependencies that have been dropped here will be"
3685
 
            $echo "*** automatically added whenever a program is linked with this library"
3686
 
            $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."
3687
7981
 
3688
7982
            if test "$allow_undefined" = no; then
3689
 
              $echo
3690
 
              $echo "*** Since this library must not contain undefined symbols,"
3691
 
              $echo "*** because either the platform does not support them or"
3692
 
              $echo "*** it was explicitly requested with -no-undefined,"
3693
 
              $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."
3694
7988
              if test "$build_old_libs" = no; then
3695
7989
                oldlibs="$output_objdir/$libname.$libext"
3696
7990
                build_libtool_libs=module
3704
7998
        # Done checking deplibs!
3705
7999
        deplibs=$newdeplibs
3706
8000
      fi
 
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
 
8009
 
 
8010
      # move library search paths that coincide with paths to not yet
 
8011
      # installed libraries to the beginning of the library search list
 
8012
      new_libs=
 
8013
      for path in $notinst_path; do
 
8014
        case " $new_libs " in
 
8015
        *" -L$path/$objdir "*) ;;
 
8016
        *)
 
8017
          case " $deplibs " in
 
8018
          *" -L$path/$objdir "*)
 
8019
            func_append new_libs " -L$path/$objdir" ;;
 
8020
          esac
 
8021
          ;;
 
8022
        esac
 
8023
      done
 
8024
      for deplib in $deplibs; do
 
8025
        case $deplib in
 
8026
        -L*)
 
8027
          case " $new_libs " in
 
8028
          *" $deplib "*) ;;
 
8029
          *) func_append new_libs " $deplib" ;;
 
8030
          esac
 
8031
          ;;
 
8032
        *) func_append new_libs " $deplib" ;;
 
8033
        esac
 
8034
      done
 
8035
      deplibs="$new_libs"
3707
8036
 
3708
8037
      # All the library-specific variables (install_libdir is set above).
3709
8038
      library_names=
3712
8041
 
3713
8042
      # Test again, we may have decided not to build it any more
3714
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
3715
8049
        if test "$hardcode_into_libs" = yes; then
3716
8050
          # Hardcode the library paths
3717
8051
          hardcode_libdirs=
3718
8052
          dep_rpath=
3719
8053
          rpath="$finalize_rpath"
3720
 
          test "$mode" != relink && rpath="$compile_rpath$rpath"
 
8054
          test "$opt_mode" != relink && rpath="$compile_rpath$rpath"
3721
8055
          for libdir in $rpath; do
3722
8056
            if test -n "$hardcode_libdir_flag_spec"; then
3723
8057
              if test -n "$hardcode_libdir_separator"; then
 
8058
                func_replace_sysroot "$libdir"
 
8059
                libdir=$func_replace_sysroot_result
3724
8060
                if test -z "$hardcode_libdirs"; then
3725
8061
                  hardcode_libdirs="$libdir"
3726
8062
                else
3729
8065
                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3730
8066
                    ;;
3731
8067
                  *)
3732
 
                    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 
8068
                    func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
3733
8069
                    ;;
3734
8070
                  esac
3735
8071
                fi
3736
8072
              else
3737
8073
                eval flag=\"$hardcode_libdir_flag_spec\"
3738
 
                dep_rpath="$dep_rpath $flag"
 
8074
                func_append dep_rpath " $flag"
3739
8075
              fi
3740
8076
            elif test -n "$runpath_var"; then
3741
8077
              case "$perm_rpath " in
3742
8078
              *" $libdir "*) ;;
3743
 
              *) perm_rpath="$perm_rpath $libdir" ;;
 
8079
              *) func_append perm_rpath " $libdir" ;;
3744
8080
              esac
3745
8081
            fi
3746
8082
          done
3748
8084
          if test -n "$hardcode_libdir_separator" &&
3749
8085
             test -n "$hardcode_libdirs"; then
3750
8086
            libdir="$hardcode_libdirs"
3751
 
            if test -n "$hardcode_libdir_flag_spec_ld"; then
3752
 
              eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3753
 
            else
3754
 
              eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3755
 
            fi
 
8087
            eval "dep_rpath=\"$hardcode_libdir_flag_spec\""
3756
8088
          fi
3757
8089
          if test -n "$runpath_var" && test -n "$perm_rpath"; then
3758
8090
            # We should set the runpath_var.
3759
8091
            rpath=
3760
8092
            for dir in $perm_rpath; do
3761
 
              rpath="$rpath$dir:"
 
8093
              func_append rpath "$dir:"
3762
8094
            done
3763
8095
            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3764
8096
          fi
3766
8098
        fi
3767
8099
 
3768
8100
        shlibpath="$finalize_shlibpath"
3769
 
        test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
 
8101
        test "$opt_mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3770
8102
        if test -n "$shlibpath"; then
3771
8103
          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3772
8104
        fi
3775
8107
        eval shared_ext=\"$shrext_cmds\"
3776
8108
        eval library_names=\"$library_names_spec\"
3777
8109
        set dummy $library_names
3778
 
        realname="$2"
3779
 
        shift; shift
 
8110
        shift
 
8111
        realname="$1"
 
8112
        shift
3780
8113
 
3781
8114
        if test -n "$soname_spec"; then
3782
8115
          eval soname=\"$soname_spec\"
3788
8121
        fi
3789
8122
 
3790
8123
        lib="$output_objdir/$realname"
 
8124
        linknames=
3791
8125
        for link
3792
8126
        do
3793
 
          linknames="$linknames $link"
 
8127
          func_append linknames " $link"
3794
8128
        done
3795
8129
 
3796
8130
        # Use standard objects if they are pic
3797
 
        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
3798
8160
 
3799
8161
        # Prepare the list of exported symbols
3800
8162
        if test -z "$export_symbols"; then
3801
8163
          if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3802
 
            $show "generating symbol list for \`$libname.la'"
 
8164
            func_verbose "generating symbol list for \`$libname.la'"
3803
8165
            export_symbols="$output_objdir/$libname.exp"
3804
 
            $run $rm $export_symbols
 
8166
            $opt_dry_run || $RM $export_symbols
3805
8167
            cmds=$export_symbols_cmds
3806
8168
            save_ifs="$IFS"; IFS='~'
3807
 
            for cmd in $cmds; do
 
8169
            for cmd1 in $cmds; do
3808
8170
              IFS="$save_ifs"
3809
 
              eval cmd=\"$cmd\"
3810
 
              if len=`expr "X$cmd" : ".*"` &&
3811
 
               test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3812
 
                $show "$cmd"
3813
 
                $run eval "$cmd" || exit $?
3814
 
                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
3815
8209
              else
3816
 
                # The command line is too long to execute in one step.
3817
 
                $show "using reloadable object file for export list..."
3818
 
                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=:
3819
8213
                # Break out early, otherwise skipped_export may be
3820
8214
                # set to false by a later but shorter cmd.
3821
8215
                break
3822
8216
              fi
3823
8217
            done
3824
8218
            IFS="$save_ifs"
3825
 
            if test -n "$export_symbols_regex"; then
3826
 
              $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3827
 
              $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3828
 
              $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3829
 
              $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"'
3830
8222
            fi
3831
8223
          fi
3832
8224
        fi
3833
8225
 
3834
8226
        if test -n "$export_symbols" && test -n "$include_expsyms"; then
3835
 
          $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
3836
8244
        fi
3837
8245
 
3838
8246
        tmp_deplibs=
3839
8247
        for test_deplib in $deplibs; do
3840
 
                case " $convenience " in
3841
 
                *" $test_deplib "*) ;;
3842
 
                *)
3843
 
                        tmp_deplibs="$tmp_deplibs $test_deplib"
3844
 
                        ;;
3845
 
                esac
 
8248
          case " $convenience " in
 
8249
          *" $test_deplib "*) ;;
 
8250
          *)
 
8251
            func_append tmp_deplibs " $test_deplib"
 
8252
            ;;
 
8253
          esac
3846
8254
        done
3847
8255
        deplibs="$tmp_deplibs"
3848
8256
 
3849
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
3850
8265
          if test -n "$whole_archive_flag_spec"; then
3851
8266
            save_libobjs=$libobjs
3852
8267
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 
8268
            test "X$libobjs" = "X " && libobjs=
3853
8269
          else
3854
8270
            gentop="$output_objdir/${outputname}x"
3855
 
            generated="$generated $gentop"
 
8271
            func_append generated " $gentop"
3856
8272
 
3857
8273
            func_extract_archives $gentop $convenience
3858
 
            libobjs="$libobjs $func_extract_archives_result"
 
8274
            func_append libobjs " $func_extract_archives_result"
 
8275
            test "X$libobjs" = "X " && libobjs=
3859
8276
          fi
3860
8277
        fi
3861
 
        
 
8278
 
3862
8279
        if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3863
8280
          eval flag=\"$thread_safe_flag_spec\"
3864
 
          linker_flags="$linker_flags $flag"
 
8281
          func_append linker_flags " $flag"
3865
8282
        fi
3866
8283
 
3867
8284
        # Make a backup of the uninstalled library when relinking
3868
 
        if test "$mode" = relink; then
3869
 
          $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 $?
3870
8287
        fi
3871
8288
 
3872
8289
        # Do each of the archive commands.
3879
8296
            cmds=$module_cmds
3880
8297
          fi
3881
8298
        else
3882
 
        if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3883
 
          eval test_cmds=\"$archive_expsym_cmds\"
3884
 
          cmds=$archive_expsym_cmds
3885
 
        else
3886
 
          eval test_cmds=\"$archive_cmds\"
3887
 
          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
3888
8305
          fi
3889
8306
        fi
3890
8307
 
3891
8308
        if test "X$skipped_export" != "X:" &&
3892
 
           len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
3893
 
           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
3894
8312
          :
3895
8313
        else
3896
 
          # The command line is too long to link in one step, link piecewise.
3897
 
          $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.
3898
8317
 
3899
8318
          # Save the value of $output and $libobjs because we want to
3900
8319
          # use them later.  If we have whole_archive_flag_spec, we
3908
8327
            save_libobjs=$libobjs
3909
8328
          fi
3910
8329
          save_output=$output
3911
 
          output_la=`$echo "X$output" | $Xsed -e "$basename"`
 
8330
          func_basename "$output"
 
8331
          output_la=$func_basename_result
3912
8332
 
3913
8333
          # Clear the reloadable object creation command queue and
3914
8334
          # initialize k to one.
3915
8335
          test_cmds=
3916
8336
          concat_cmds=
3917
8337
          objlist=
3918
 
          delfiles=
3919
8338
          last_robj=
3920
8339
          k=1
3921
 
          output=$output_objdir/$output_la-${k}.$objext
3922
 
          # Loop over the list of objects to be linked.
3923
 
          for obj in $save_libobjs
3924
 
          do
3925
 
            eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3926
 
            if test "X$objlist" = X ||
3927
 
               { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
3928
 
                 test "$len" -le "$max_cmd_len"; }; then
3929
 
              objlist="$objlist $obj"
3930
 
            else
3931
 
              # The command $test_cmds is almost too long, add a
3932
 
              # command to the queue.
3933
 
              if test "$k" -eq 1 ; then
3934
 
                # The first file doesn't have a previous command to add.
3935
 
                eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3936
 
              else
3937
 
                # All subsequent reloadable object files will link in
3938
 
                # the last one created.
3939
 
                eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3940
 
              fi
3941
 
              last_robj=$output_objdir/$output_la-${k}.$objext
3942
 
              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..."
3943
8376
              output=$output_objdir/$output_la-${k}.$objext
3944
 
              objlist=$obj
3945
 
              len=1
3946
 
            fi
3947
 
          done
3948
 
          # Handle the remaining objects by creating one last
3949
 
          # reloadable object file.  All subsequent reloadable object
3950
 
          # files will link in the last one created.
3951
 
          test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3952
 
          eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3953
 
 
3954
 
          if ${skipped_export-false}; then
3955
 
            $show "generating symbol list for \`$libname.la'"
3956
 
            export_symbols="$output_objdir/$libname.exp"
3957
 
            $run $rm $export_symbols
3958
 
            libobjs=$output
3959
 
            # Append the command to create the export file.
3960
 
            eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
3961
 
          fi
3962
 
 
3963
 
          # Set up a command to remove the reloadable object files
3964
 
          # after they are used.
3965
 
          i=0
3966
 
          while test "$i" -lt "$k"
3967
 
          do
3968
 
            i=`expr $i + 1`
3969
 
            delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
3970
 
          done
3971
 
 
3972
 
          $echo "creating a temporary reloadable object file: $output"
3973
 
 
3974
 
          # Loop through the commands generated above and execute them.
3975
 
          save_ifs="$IFS"; IFS='~'
3976
 
          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
3977
8466
            IFS="$save_ifs"
3978
 
            $show "$cmd"
3979
 
            $run eval "$cmd" || exit $?
3980
 
          done
3981
 
          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
3982
8495
 
3983
8496
          libobjs=$output
3984
8497
          # Restore the value of output.
3986
8499
 
3987
8500
          if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3988
8501
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
 
8502
            test "X$libobjs" = "X " && libobjs=
3989
8503
          fi
3990
8504
          # Expand the library linking commands again to reset the
3991
8505
          # value of $libobjs for piecewise linking.
3998
8512
              cmds=$module_cmds
3999
8513
            fi
4000
8514
          else
4001
 
          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4002
 
            cmds=$archive_expsym_cmds
4003
 
          else
4004
 
            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
4005
8519
            fi
4006
8520
          fi
4007
 
 
4008
 
          # Append the command to remove the reloadable object files
4009
 
          # to the just-reset $cmds.
4010
 
          eval cmds=\"\$cmds~\$rm $delfiles\"
4011
 
        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
 
4012
8538
        save_ifs="$IFS"; IFS='~'
4013
8539
        for cmd in $cmds; do
4014
8540
          IFS="$save_ifs"
4015
8541
          eval cmd=\"$cmd\"
4016
 
          $show "$cmd"
4017
 
          $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" || {
4018
8547
            lt_exit=$?
4019
8548
 
4020
8549
            # Restore the uninstalled library and exit
4021
 
            if test "$mode" = relink; then
4022
 
              $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" )
4023
8554
            fi
4024
8555
 
4025
8556
            exit $lt_exit
4028
8559
        IFS="$save_ifs"
4029
8560
 
4030
8561
        # Restore the uninstalled library and exit
4031
 
        if test "$mode" = relink; then
4032
 
          $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 $?
4033
8564
 
4034
8565
          if test -n "$convenience"; then
4035
8566
            if test -z "$whole_archive_flag_spec"; then
4036
 
              $show "${rm}r $gentop"
4037
 
              $run ${rm}r "$gentop"
 
8567
              func_show_eval '${RM}r "$gentop"'
4038
8568
            fi
4039
8569
          fi
4040
8570
 
4044
8574
        # Create links to the real library.
4045
8575
        for linkname in $linknames; do
4046
8576
          if test "$realname" != "$linkname"; then
4047
 
            $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
4048
 
            $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 $?'
4049
8578
          fi
4050
8579
        done
4051
8580
 
4058
8587
      ;;
4059
8588
 
4060
8589
    obj)
4061
 
      if test -n "$deplibs"; then
4062
 
        $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
4063
 
      fi
4064
 
 
4065
8590
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4066
 
        $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
4067
 
      fi
4068
 
 
4069
 
      if test -n "$rpath"; then
4070
 
        $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
4071
 
      fi
4072
 
 
4073
 
      if test -n "$xrpath"; then
4074
 
        $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
4075
 
      fi
4076
 
 
4077
 
      if test -n "$vinfo"; then
4078
 
        $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
4079
 
      fi
4080
 
 
4081
 
      if test -n "$release"; then
4082
 
        $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
4083
 
      fi
 
8591
        func_warning "\`-dlopen' is ignored for objects"
 
8592
      fi
 
8593
 
 
8594
      case " $deplibs" in
 
8595
      *\ -l* | *\ -L*)
 
8596
        func_warning "\`-l' and \`-L' are ignored for objects" ;;
 
8597
      esac
 
8598
 
 
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"
4084
8610
 
4085
8611
      case $output in
4086
8612
      *.lo)
4087
 
        if test -n "$objs$old_deplibs"; then
4088
 
          $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
4089
 
          exit $EXIT_FAILURE
4090
 
        fi
4091
 
        libobj="$output"
4092
 
        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
4093
8619
        ;;
4094
8620
      *)
4095
8621
        libobj=
4098
8624
      esac
4099
8625
 
4100
8626
      # Delete the old objects.
4101
 
      $run $rm $obj $libobj
 
8627
      $opt_dry_run || $RM $obj $libobj
4102
8628
 
4103
8629
      # Objects from convenience libraries.  This assumes
4104
8630
      # single-version convenience libraries.  Whenever we create
4107
8633
      reload_conv_objs=
4108
8634
      gentop=
4109
8635
      # reload_cmds runs $LD directly, so let us get rid of
4110
 
      # -Wl from whole_archive_flag_spec
 
8636
      # -Wl from whole_archive_flag_spec and hope we can get by with
 
8637
      # turning comma into space..
4111
8638
      wl=
4112
8639
 
4113
8640
      if test -n "$convenience"; then
4114
8641
        if test -n "$whole_archive_flag_spec"; then
4115
 
          eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
 
8642
          eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
 
8643
          reload_conv_objs=$reload_objs\ `$ECHO "$tmp_whole_archive_flags" | $SED 's|,| |g'`
4116
8644
        else
4117
8645
          gentop="$output_objdir/${obj}x"
4118
 
          generated="$generated $gentop"
 
8646
          func_append generated " $gentop"
4119
8647
 
4120
8648
          func_extract_archives $gentop $convenience
4121
8649
          reload_conv_objs="$reload_objs $func_extract_archives_result"
4122
8650
        fi
4123
8651
      fi
4124
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
 
4125
8656
      # Create the old-style object.
4126
 
      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
4127
8658
 
4128
8659
      output="$obj"
4129
 
      cmds=$reload_cmds
4130
 
      save_ifs="$IFS"; IFS='~'
4131
 
      for cmd in $cmds; do
4132
 
        IFS="$save_ifs"
4133
 
        eval cmd=\"$cmd\"
4134
 
        $show "$cmd"
4135
 
        $run eval "$cmd" || exit $?
4136
 
      done
4137
 
      IFS="$save_ifs"
 
8660
      func_execute_cmds "$reload_cmds" 'exit $?'
4138
8661
 
4139
8662
      # Exit if we aren't doing a library object file.
4140
8663
      if test -z "$libobj"; then
4141
8664
        if test -n "$gentop"; then
4142
 
          $show "${rm}r $gentop"
4143
 
          $run ${rm}r $gentop
 
8665
          func_show_eval '${RM}r "$gentop"'
4144
8666
        fi
4145
8667
 
4146
8668
        exit $EXIT_SUCCESS
4148
8670
 
4149
8671
      if test "$build_libtool_libs" != yes; then
4150
8672
        if test -n "$gentop"; then
4151
 
          $show "${rm}r $gentop"
4152
 
          $run ${rm}r $gentop
 
8673
          func_show_eval '${RM}r "$gentop"'
4153
8674
        fi
4154
8675
 
4155
8676
        # Create an invalid libtool object if no PIC, so that we don't
4156
8677
        # accidentally link it into a program.
4157
8678
        # $show "echo timestamp > $libobj"
4158
 
        # $run eval "echo timestamp > $libobj" || exit $?
 
8679
        # $opt_dry_run || eval "echo timestamp > $libobj" || exit $?
4159
8680
        exit $EXIT_SUCCESS
4160
8681
      fi
4161
8682
 
4163
8684
        # Only do commands if we really have different PIC objects.
4164
8685
        reload_objs="$libobjs $reload_conv_objs"
4165
8686
        output="$libobj"
4166
 
        cmds=$reload_cmds
4167
 
        save_ifs="$IFS"; IFS='~'
4168
 
        for cmd in $cmds; do
4169
 
          IFS="$save_ifs"
4170
 
          eval cmd=\"$cmd\"
4171
 
          $show "$cmd"
4172
 
          $run eval "$cmd" || exit $?
4173
 
        done
4174
 
        IFS="$save_ifs"
 
8687
        func_execute_cmds "$reload_cmds" 'exit $?'
4175
8688
      fi
4176
8689
 
4177
8690
      if test -n "$gentop"; then
4178
 
        $show "${rm}r $gentop"
4179
 
        $run ${rm}r $gentop
 
8691
        func_show_eval '${RM}r "$gentop"'
4180
8692
      fi
4181
8693
 
4182
8694
      exit $EXIT_SUCCESS
4184
8696
 
4185
8697
    prog)
4186
8698
      case $host in
4187
 
        *cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
 
8699
        *cygwin*) func_stripname '' '.exe' "$output"
 
8700
                  output=$func_stripname_result.exe;;
4188
8701
      esac
4189
 
      if test -n "$vinfo"; then
4190
 
        $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4191
 
      fi
4192
 
 
4193
 
      if test -n "$release"; then
4194
 
        $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4195
 
      fi
4196
 
 
4197
 
      if test "$preload" = yes; then
4198
 
        if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4199
 
           test "$dlopen_self_static" = unknown; then
4200
 
          $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4201
 
        fi
4202
 
      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."
4203
8713
 
4204
8714
      case $host in
4205
8715
      *-*-rhapsody* | *-*-darwin1.[012])
4206
8716
        # On Rhapsody replace the C library is the System framework
4207
 
        compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4208
 
        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 /'`
4209
8719
        ;;
4210
8720
      esac
4211
8721
 
4212
8722
      case $host in
4213
 
      *darwin*)
4214
 
        # Don't allow lazy linking, it breaks C++ global constructors
4215
 
        if test "$tagname" = CXX ; then
4216
 
        compile_command="$compile_command ${wl}-bind_at_load"
4217
 
        finalize_command="$finalize_command ${wl}-bind_at_load"
4218
 
        fi
4219
 
        ;;
 
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
        ;;
4220
8738
      esac
4221
8739
 
4222
 
      compile_command="$compile_command $compile_deplibs"
4223
 
      finalize_command="$finalize_command $finalize_deplibs"
 
8740
 
 
8741
      # move library search paths that coincide with paths to not yet
 
8742
      # installed libraries to the beginning of the library search list
 
8743
      new_libs=
 
8744
      for path in $notinst_path; do
 
8745
        case " $new_libs " in
 
8746
        *" -L$path/$objdir "*) ;;
 
8747
        *)
 
8748
          case " $compile_deplibs " in
 
8749
          *" -L$path/$objdir "*)
 
8750
            func_append new_libs " -L$path/$objdir" ;;
 
8751
          esac
 
8752
          ;;
 
8753
        esac
 
8754
      done
 
8755
      for deplib in $compile_deplibs; do
 
8756
        case $deplib in
 
8757
        -L*)
 
8758
          case " $new_libs " in
 
8759
          *" $deplib "*) ;;
 
8760
          *) func_append new_libs " $deplib" ;;
 
8761
          esac
 
8762
          ;;
 
8763
        *) func_append new_libs " $deplib" ;;
 
8764
        esac
 
8765
      done
 
8766
      compile_deplibs="$new_libs"
 
8767
 
 
8768
 
 
8769
      func_append compile_command " $compile_deplibs"
 
8770
      func_append finalize_command " $finalize_deplibs"
4224
8771
 
4225
8772
      if test -n "$rpath$xrpath"; then
4226
8773
        # If the user specified any rpath flags, then add them.
4228
8775
          # This is the magic to use -rpath.
4229
8776
          case "$finalize_rpath " in
4230
8777
          *" $libdir "*) ;;
4231
 
          *) finalize_rpath="$finalize_rpath $libdir" ;;
 
8778
          *) func_append finalize_rpath " $libdir" ;;
4232
8779
          esac
4233
8780
        done
4234
8781
      fi
4247
8794
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4248
8795
                ;;
4249
8796
              *)
4250
 
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 
8797
                func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
4251
8798
                ;;
4252
8799
              esac
4253
8800
            fi
4254
8801
          else
4255
8802
            eval flag=\"$hardcode_libdir_flag_spec\"
4256
 
            rpath="$rpath $flag"
 
8803
            func_append rpath " $flag"
4257
8804
          fi
4258
8805
        elif test -n "$runpath_var"; then
4259
8806
          case "$perm_rpath " in
4260
8807
          *" $libdir "*) ;;
4261
 
          *) perm_rpath="$perm_rpath $libdir" ;;
 
8808
          *) func_append perm_rpath " $libdir" ;;
4262
8809
          esac
4263
8810
        fi
4264
8811
        case $host in
4265
 
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
 
8812
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-cegcc*)
 
8813
          testbindir=`${ECHO} "$libdir" | ${SED} -e 's*/lib$*/bin*'`
4266
8814
          case :$dllsearchpath: in
4267
8815
          *":$libdir:"*) ;;
4268
 
          *) dllsearchpath="$dllsearchpath:$libdir";;
 
8816
          ::) dllsearchpath=$libdir;;
 
8817
          *) func_append dllsearchpath ":$libdir";;
 
8818
          esac
 
8819
          case :$dllsearchpath: in
 
8820
          *":$testbindir:"*) ;;
 
8821
          ::) dllsearchpath=$testbindir;;
 
8822
          *) func_append dllsearchpath ":$testbindir";;
4269
8823
          esac
4270
8824
          ;;
4271
8825
        esac
4291
8845
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4292
8846
                ;;
4293
8847
              *)
4294
 
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
 
8848
                func_append hardcode_libdirs "$hardcode_libdir_separator$libdir"
4295
8849
                ;;
4296
8850
              esac
4297
8851
            fi
4298
8852
          else
4299
8853
            eval flag=\"$hardcode_libdir_flag_spec\"
4300
 
            rpath="$rpath $flag"
 
8854
            func_append rpath " $flag"
4301
8855
          fi
4302
8856
        elif test -n "$runpath_var"; then
4303
8857
          case "$finalize_perm_rpath " in
4304
8858
          *" $libdir "*) ;;
4305
 
          *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
 
8859
          *) func_append finalize_perm_rpath " $libdir" ;;
4306
8860
          esac
4307
8861
        fi
4308
8862
      done
4316
8870
 
4317
8871
      if test -n "$libobjs" && test "$build_old_libs" = yes; then
4318
8872
        # Transform all the library objects into standard objects.
4319
 
        compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4320
 
        finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4321
 
      fi
4322
 
 
4323
 
      dlsyms=
4324
 
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4325
 
        if test -n "$NM" && test -n "$global_symbol_pipe"; then
4326
 
          dlsyms="${outputname}S.c"
4327
 
        else
4328
 
          $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4329
 
        fi
4330
 
      fi
4331
 
 
4332
 
      if test -n "$dlsyms"; then
4333
 
        case $dlsyms in
4334
 
        "") ;;
4335
 
        *.c)
4336
 
          # Discover the nlist of each of the dlfiles.
4337
 
          nlist="$output_objdir/${outputname}.nm"
4338
 
 
4339
 
          $show "$rm $nlist ${nlist}S ${nlist}T"
4340
 
          $run $rm "$nlist" "${nlist}S" "${nlist}T"
4341
 
 
4342
 
          # Parse the name list into a source file.
4343
 
          $show "creating $output_objdir/$dlsyms"
4344
 
 
4345
 
          test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4346
 
/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4347
 
/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4348
 
 
4349
 
#ifdef __cplusplus
4350
 
extern \"C\" {
4351
 
#endif
4352
 
 
4353
 
/* Prevent the only kind of declaration conflicts we can make. */
4354
 
#define lt_preloaded_symbols some_other_symbol
4355
 
 
4356
 
/* External symbol declarations for the compiler. */\
4357
 
"
4358
 
 
4359
 
          if test "$dlself" = yes; then
4360
 
            $show "generating symbol list for \`$output'"
4361
 
 
4362
 
            test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4363
 
 
4364
 
            # Add our own program objects to the symbol list.
4365
 
            progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4366
 
            for arg in $progfiles; do
4367
 
              $show "extracting global C symbols from \`$arg'"
4368
 
              $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4369
 
            done
4370
 
 
4371
 
            if test -n "$exclude_expsyms"; then
4372
 
              $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4373
 
              $run eval '$mv "$nlist"T "$nlist"'
4374
 
            fi
4375
 
 
4376
 
            if test -n "$export_symbols_regex"; then
4377
 
              $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4378
 
              $run eval '$mv "$nlist"T "$nlist"'
4379
 
            fi
4380
 
 
4381
 
            # Prepare the list of exported symbols
4382
 
            if test -z "$export_symbols"; then
4383
 
              export_symbols="$output_objdir/$outputname.exp"
4384
 
              $run $rm $export_symbols
4385
 
              $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4386
 
            else
4387
 
              $run eval "${SED} -e 's/\([ ][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
4388
 
              $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
4389
 
              $run eval 'mv "$nlist"T "$nlist"'
4390
 
            fi
4391
 
          fi
4392
 
 
4393
 
          for arg in $dlprefiles; do
4394
 
            $show "extracting global C symbols from \`$arg'"
4395
 
            name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4396
 
            $run eval '$echo ": $name " >> "$nlist"'
4397
 
            $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4398
 
          done
4399
 
 
4400
 
          if test -z "$run"; then
4401
 
            # Make sure we have at least an empty file.
4402
 
            test -f "$nlist" || : > "$nlist"
4403
 
 
4404
 
            if test -n "$exclude_expsyms"; then
4405
 
              $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4406
 
              $mv "$nlist"T "$nlist"
4407
 
            fi
4408
 
 
4409
 
            # Try sorting and uniquifying the output.
4410
 
            if grep -v "^: " < "$nlist" |
4411
 
                if sort -k 3 </dev/null >/dev/null 2>&1; then
4412
 
                  sort -k 3
4413
 
                else
4414
 
                  sort +2
4415
 
                fi |
4416
 
                uniq > "$nlist"S; then
4417
 
              :
4418
 
            else
4419
 
              grep -v "^: " < "$nlist" > "$nlist"S
4420
 
            fi
4421
 
 
4422
 
            if test -f "$nlist"S; then
4423
 
              eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4424
 
            else
4425
 
              $echo '/* NONE */' >> "$output_objdir/$dlsyms"
4426
 
            fi
4427
 
 
4428
 
            $echo >> "$output_objdir/$dlsyms" "\
4429
 
 
4430
 
#undef lt_preloaded_symbols
4431
 
 
4432
 
#if defined (__STDC__) && __STDC__
4433
 
# define lt_ptr void *
4434
 
#else
4435
 
# define lt_ptr char *
4436
 
# define const
4437
 
#endif
4438
 
 
4439
 
/* The mapping between symbol names and symbols. */
4440
 
"
4441
 
 
4442
 
            case $host in
4443
 
            *cygwin* | *mingw* )
4444
 
          $echo >> "$output_objdir/$dlsyms" "\
4445
 
/* DATA imports from DLLs on WIN32 can't be const, because
4446
 
   runtime relocations are performed -- see ld's documentation
4447
 
   on pseudo-relocs */
4448
 
struct {
4449
 
"
4450
 
              ;;
4451
 
            * )
4452
 
          $echo >> "$output_objdir/$dlsyms" "\
4453
 
const struct {
4454
 
"
4455
 
              ;;
4456
 
            esac
4457
 
 
4458
 
 
4459
 
          $echo >> "$output_objdir/$dlsyms" "\
4460
 
  const char *name;
4461
 
  lt_ptr address;
4462
 
}
4463
 
lt_preloaded_symbols[] =
4464
 
{\
4465
 
"
4466
 
 
4467
 
            eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4468
 
 
4469
 
            $echo >> "$output_objdir/$dlsyms" "\
4470
 
  {0, (lt_ptr) 0}
4471
 
};
4472
 
 
4473
 
/* This works around a problem in FreeBSD linker */
4474
 
#ifdef FREEBSD_WORKAROUND
4475
 
static const void *lt_preloaded_setup() {
4476
 
  return lt_preloaded_symbols;
4477
 
}
4478
 
#endif
4479
 
 
4480
 
#ifdef __cplusplus
4481
 
}
4482
 
#endif\
4483
 
"
4484
 
          fi
4485
 
 
4486
 
          pic_flag_for_symtable=
4487
 
          case $host in
4488
 
          # compiling the symbol table file with pic_flag works around
4489
 
          # a FreeBSD bug that causes programs to crash when -lm is
4490
 
          # linked before any other PIC object.  But we must not use
4491
 
          # pic_flag when linking with -static.  The problem exists in
4492
 
          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4493
 
          *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4494
 
            case "$compile_command " in
4495
 
            *" -static "*) ;;
4496
 
            *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4497
 
            esac;;
4498
 
          *-*-hpux*)
4499
 
            case "$compile_command " in
4500
 
            *" -static "*) ;;
4501
 
            *) pic_flag_for_symtable=" $pic_flag";;
4502
 
            esac
4503
 
          esac
4504
 
 
4505
 
          # Now compile the dynamic symbol file.
4506
 
          $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4507
 
          $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4508
 
 
4509
 
          # Clean up the generated files.
4510
 
          $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4511
 
          $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4512
 
 
4513
 
          # Transform the symbol file into the correct name.
4514
 
          compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4515
 
          finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4516
 
          ;;
4517
 
        *)
4518
 
          $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4519
 
          exit $EXIT_FAILURE
4520
 
          ;;
4521
 
        esac
4522
 
      else
4523
 
        # We keep going just in case the user didn't refer to
4524
 
        # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
4525
 
        # really was required.
4526
 
 
4527
 
        # Nullify the symbol file.
4528
 
        compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
4529
 
        finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
4530
 
      fi
4531
 
 
4532
 
      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
4533
8902
        # Replace the output file specification.
4534
 
        compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
 
8903
        compile_command=`$ECHO "$compile_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
4535
8904
        link_command="$compile_command$compile_rpath"
4536
8905
 
4537
8906
        # We have no uninstalled library dependencies, so finalize right now.
4538
 
        $show "$link_command"
4539
 
        $run eval "$link_command"
4540
 
        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
4541
8915
 
4542
8916
        # Delete the generated files.
4543
 
        if test -n "$dlsyms"; then
4544
 
          $show "$rm $output_objdir/${outputname}S.${objext}"
4545
 
          $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}"'
4546
8919
        fi
4547
8920
 
4548
 
        exit $status
4549
 
      fi
4550
 
 
4551
 
      if test -n "$shlibpath_var"; then
4552
 
        # We should set the shlibpath_var
4553
 
        rpath=
4554
 
        for dir in $temp_rpath; do
4555
 
          case $dir in
4556
 
          [\\/]* | [A-Za-z]:[\\/]*)
4557
 
            # Absolute path.
4558
 
            rpath="$rpath$dir:"
4559
 
            ;;
4560
 
          *)
4561
 
            # Relative path: add a thisdir entry.
4562
 
            rpath="$rpath\$thisdir/$dir:"
4563
 
            ;;
4564
 
          esac
4565
 
        done
4566
 
        temp_rpath="$rpath"
 
8921
        exit $exit_status
4567
8922
      fi
4568
8923
 
4569
8924
      if test -n "$compile_shlibpath$finalize_shlibpath"; then
4580
8935
          # We should set the runpath_var.
4581
8936
          rpath=
4582
8937
          for dir in $perm_rpath; do
4583
 
            rpath="$rpath$dir:"
 
8938
            func_append rpath "$dir:"
4584
8939
          done
4585
8940
          compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
4586
8941
        fi
4588
8943
          # We should set the runpath_var.
4589
8944
          rpath=
4590
8945
          for dir in $finalize_perm_rpath; do
4591
 
            rpath="$rpath$dir:"
 
8946
            func_append rpath "$dir:"
4592
8947
          done
4593
8948
          finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
4594
8949
        fi
4598
8953
        # We don't need to create a wrapper script.
4599
8954
        link_command="$compile_var$compile_command$compile_rpath"
4600
8955
        # Replace the output file specification.
4601
 
        link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
 
8956
        link_command=`$ECHO "$link_command" | $SED 's%@OUTPUT@%'"$output"'%g'`
4602
8957
        # Delete the old output file.
4603
 
        $run $rm $output
 
8958
        $opt_dry_run || $RM $output
4604
8959
        # Link the executable and exit
4605
 
        $show "$link_command"
4606
 
        $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
 
4607
8968
        exit $EXIT_SUCCESS
4608
8969
      fi
4609
8970
 
4612
8973
        link_command="$compile_var$compile_command$compile_rpath"
4613
8974
        relink_command="$finalize_var$finalize_command$finalize_rpath"
4614
8975
 
4615
 
        $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
4616
 
        $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"
4617
8978
      else
4618
8979
        if test "$fast_install" != no; then
4619
8980
          link_command="$finalize_var$compile_command$finalize_rpath"
4620
8981
          if test "$fast_install" = yes; then
4621
 
            relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
 
8982
            relink_command=`$ECHO "$compile_var$compile_command$compile_rpath" | $SED 's%@OUTPUT@%\$progdir/\$file%g'`
4622
8983
          else
4623
8984
            # fast_install is set to needless
4624
8985
            relink_command=
4630
8991
      fi
4631
8992
 
4632
8993
      # Replace the output file specification.
4633
 
      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'`
4634
8995
 
4635
8996
      # Delete the old output files.
4636
 
      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
4637
 
 
4638
 
      $show "$link_command"
4639
 
      $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
4640
9006
 
4641
9007
      # Now create the wrapper script.
4642
 
      $show "creating $output"
 
9008
      func_verbose "creating $output"
4643
9009
 
4644
9010
      # Quote the relink command for shipping.
4645
9011
      if test -n "$relink_command"; then
4646
9012
        # Preserve any variables that may affect compiler behavior
4647
9013
        for var in $variables_saved_for_relink; do
4648
9014
          if eval test -z \"\${$var+set}\"; then
4649
 
            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"
4650
9016
          elif eval var_value=\$$var; test -z "$var_value"; then
4651
9017
            relink_command="$var=; export $var; $relink_command"
4652
9018
          else
4653
 
            var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4654
 
            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"
4655
9021
          fi
4656
9022
        done
4657
9023
        relink_command="(cd `pwd`; $relink_command)"
4658
 
        relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4659
 
      fi
4660
 
 
4661
 
      # Quote $echo for shipping.
4662
 
      if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
4663
 
        case $progpath in
4664
 
        [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4665
 
        *) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4666
 
        esac
4667
 
        qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4668
 
      else
4669
 
        qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4670
 
      fi
4671
 
 
4672
 
      # Only actually do things if our run command is non-null.
4673
 
      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 || {
4674
9029
        # win32 will think the script is a binary if it has
4675
9030
        # a .exe suffix, so we strip it off here.
4676
9031
        case $output in
4677
 
          *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
 
9032
          *.exe) func_stripname '' '.exe' "$output"
 
9033
                 output=$func_stripname_result ;;
4678
9034
        esac
4679
9035
        # test for cygwin because mv fails w/o .exe extensions
4680
9036
        case $host in
4681
9037
          *cygwin*)
4682
9038
            exeext=.exe
4683
 
            outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
 
9039
            func_stripname '' '.exe' "$outputname"
 
9040
            outputname=$func_stripname_result ;;
4684
9041
          *) exeext= ;;
4685
9042
        esac
4686
9043
        case $host in
4687
9044
          *cygwin* | *mingw* )
4688
 
            cwrappersource=`$echo ${objdir}/lt-${outputname}.c`
4689
 
            cwrapper=`$echo ${output}.exe`
4690
 
            $rm $cwrappersource $cwrapper
4691
 
            trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4692
 
 
4693
 
            cat > $cwrappersource <<EOF
4694
 
 
4695
 
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4696
 
   Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4697
 
 
4698
 
   The $output program cannot be directly executed until all the libtool
4699
 
   libraries that it depends on are installed.
4700
 
 
4701
 
   This wrapper executable should never be moved out of the build directory.
4702
 
   If it is, it will not operate correctly.
4703
 
 
4704
 
   Currently, it simply execs the wrapper *script* "/bin/sh $output",
4705
 
   but could eventually absorb all of the scripts functionality and
4706
 
   exec $objdir/$outputname directly.
4707
 
*/
4708
 
EOF
4709
 
            cat >> $cwrappersource<<"EOF"
4710
 
#include <stdio.h>
4711
 
#include <stdlib.h>
4712
 
#include <unistd.h>
4713
 
#include <malloc.h>
4714
 
#include <stdarg.h>
4715
 
#include <assert.h>
4716
 
 
4717
 
#if defined(PATH_MAX)
4718
 
# define LT_PATHMAX PATH_MAX
4719
 
#elif defined(MAXPATHLEN)
4720
 
# define LT_PATHMAX MAXPATHLEN
4721
 
#else
4722
 
# define LT_PATHMAX 1024
4723
 
#endif
4724
 
 
4725
 
#ifndef DIR_SEPARATOR
4726
 
#define DIR_SEPARATOR '/'
4727
 
#endif
4728
 
 
4729
 
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4730
 
  defined (__OS2__)
4731
 
#define HAVE_DOS_BASED_FILE_SYSTEM
4732
 
#ifndef DIR_SEPARATOR_2
4733
 
#define DIR_SEPARATOR_2 '\\'
4734
 
#endif
4735
 
#endif
4736
 
 
4737
 
#ifndef DIR_SEPARATOR_2
4738
 
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4739
 
#else /* DIR_SEPARATOR_2 */
4740
 
# define IS_DIR_SEPARATOR(ch) \
4741
 
        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4742
 
#endif /* DIR_SEPARATOR_2 */
4743
 
 
4744
 
#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
4745
 
#define XFREE(stale) do { \
4746
 
  if (stale) { free ((void *) stale); stale = 0; } \
4747
 
} while (0)
4748
 
 
4749
 
const char *program_name = NULL;
4750
 
 
4751
 
void * xmalloc (size_t num);
4752
 
char * xstrdup (const char *string);
4753
 
char * basename (const char *name);
4754
 
char * fnqualify(const char *path);
4755
 
char * strendzap(char *str, const char *pat);
4756
 
void lt_fatal (const char *message, ...);
4757
 
 
4758
 
int
4759
 
main (int argc, char *argv[])
4760
 
{
4761
 
  char **newargz;
4762
 
  int i;
4763
 
 
4764
 
  program_name = (char *) xstrdup ((char *) basename (argv[0]));
4765
 
  newargz = XMALLOC(char *, argc+2);
4766
 
EOF
4767
 
 
4768
 
            cat >> $cwrappersource <<EOF
4769
 
  newargz[0] = "$SHELL";
4770
 
EOF
4771
 
 
4772
 
            cat >> $cwrappersource <<"EOF"
4773
 
  newargz[1] = fnqualify(argv[0]);
4774
 
  /* we know the script has the same name, without the .exe */
4775
 
  /* so make sure newargz[1] doesn't end in .exe */
4776
 
  strendzap(newargz[1],".exe");
4777
 
  for (i = 1; i < argc; i++)
4778
 
    newargz[i+1] = xstrdup(argv[i]);
4779
 
  newargz[argc+1] = NULL;
4780
 
EOF
4781
 
 
4782
 
            cat >> $cwrappersource <<EOF
4783
 
  execv("$SHELL",newargz);
4784
 
EOF
4785
 
 
4786
 
            cat >> $cwrappersource <<"EOF"
4787
 
  return 127;
4788
 
}
4789
 
 
4790
 
void *
4791
 
xmalloc (size_t num)
4792
 
{
4793
 
  void * p = (void *) malloc (num);
4794
 
  if (!p)
4795
 
    lt_fatal ("Memory exhausted");
4796
 
 
4797
 
  return p;
4798
 
}
4799
 
 
4800
 
char *
4801
 
xstrdup (const char *string)
4802
 
{
4803
 
  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
4804
 
;
4805
 
}
4806
 
 
4807
 
char *
4808
 
basename (const char *name)
4809
 
{
4810
 
  const char *base;
4811
 
 
4812
 
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4813
 
  /* Skip over the disk name in MSDOS pathnames. */
4814
 
  if (isalpha (name[0]) && name[1] == ':')
4815
 
    name += 2;
4816
 
#endif
4817
 
 
4818
 
  for (base = name; *name; name++)
4819
 
    if (IS_DIR_SEPARATOR (*name))
4820
 
      base = name + 1;
4821
 
  return (char *) base;
4822
 
}
4823
 
 
4824
 
char *
4825
 
fnqualify(const char *path)
4826
 
{
4827
 
  size_t size;
4828
 
  char *p;
4829
 
  char tmp[LT_PATHMAX + 1];
4830
 
 
4831
 
  assert(path != NULL);
4832
 
 
4833
 
  /* Is it qualified already? */
4834
 
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4835
 
  if (isalpha (path[0]) && path[1] == ':')
4836
 
    return xstrdup (path);
4837
 
#endif
4838
 
  if (IS_DIR_SEPARATOR (path[0]))
4839
 
    return xstrdup (path);
4840
 
 
4841
 
  /* prepend the current directory */
4842
 
  /* doesn't handle '~' */
4843
 
  if (getcwd (tmp, LT_PATHMAX) == NULL)
4844
 
    lt_fatal ("getcwd failed");
4845
 
  size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */
4846
 
  p = XMALLOC(char, size);
4847
 
  sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path);
4848
 
  return p;
4849
 
}
4850
 
 
4851
 
char *
4852
 
strendzap(char *str, const char *pat)
4853
 
{
4854
 
  size_t len, patlen;
4855
 
 
4856
 
  assert(str != NULL);
4857
 
  assert(pat != NULL);
4858
 
 
4859
 
  len = strlen(str);
4860
 
  patlen = strlen(pat);
4861
 
 
4862
 
  if (patlen <= len)
4863
 
  {
4864
 
    str += len - patlen;
4865
 
    if (strcmp(str, pat) == 0)
4866
 
      *str = '\0';
4867
 
  }
4868
 
  return str;
4869
 
}
4870
 
 
4871
 
static void
4872
 
lt_error_core (int exit_status, const char * mode,
4873
 
          const char * message, va_list ap)
4874
 
{
4875
 
  fprintf (stderr, "%s: %s: ", program_name, mode);
4876
 
  vfprintf (stderr, message, ap);
4877
 
  fprintf (stderr, ".\n");
4878
 
 
4879
 
  if (exit_status >= 0)
4880
 
    exit (exit_status);
4881
 
}
4882
 
 
4883
 
void
4884
 
lt_fatal (const char *message, ...)
4885
 
{
4886
 
  va_list ap;
4887
 
  va_start (ap, message);
4888
 
  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4889
 
  va_end (ap);
4890
 
}
4891
 
EOF
4892
 
          # we should really use a build-platform specific compiler
4893
 
          # here, but OTOH, the wrappers (shell script and this C one)
4894
 
          # are only useful if you want to execute the "real" binary.
4895
 
          # Since the "real" binary is built for $host, then this
4896
 
          # wrapper might as well be built for $host, too.
4897
 
          $run $LTCC -s -o $cwrapper $cwrappersource
4898
 
          ;;
4899
 
        esac
4900
 
        $rm $output
4901
 
        trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
4902
 
 
4903
 
        $echo > $output "\
4904
 
#! $SHELL
4905
 
 
4906
 
# $output - temporary wrapper script for $objdir/$outputname
4907
 
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4908
 
#
4909
 
# The $output program cannot be directly executed until all the libtool
4910
 
# libraries that it depends on are installed.
4911
 
#
4912
 
# This wrapper script should never be moved out of the build directory.
4913
 
# If it is, it will not operate correctly.
4914
 
 
4915
 
# Sed substitution that helps us do robust quoting.  It backslashifies
4916
 
# metacharacters that are still active within double-quoted strings.
4917
 
Xsed='${SED} -e 1s/^X//'
4918
 
sed_quote_subst='$sed_quote_subst'
4919
 
 
4920
 
# The HP-UX ksh and POSIX shell print the target directory to stdout
4921
 
# if CDPATH is set.
4922
 
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
4923
 
 
4924
 
relink_command=\"$relink_command\"
4925
 
 
4926
 
# This environment variable determines our operation mode.
4927
 
if test \"\$libtool_install_magic\" = \"$magic\"; then
4928
 
  # install mode needs the following variable:
4929
 
  notinst_deplibs='$notinst_deplibs'
4930
 
else
4931
 
  # When we are sourced in execute mode, \$file and \$echo are already set.
4932
 
  if test \"\$libtool_execute_magic\" != \"$magic\"; then
4933
 
    echo=\"$qecho\"
4934
 
    file=\"\$0\"
4935
 
    # Make sure echo works.
4936
 
    if test \"X\$1\" = X--no-reexec; then
4937
 
      # Discard the --no-reexec flag, and continue.
4938
 
      shift
4939
 
    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
4940
 
      # Yippee, \$echo works!
4941
 
      :
4942
 
    else
4943
 
      # Restart under the correct shell, and then maybe \$echo will work.
4944
 
      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
4945
 
    fi
4946
 
  fi\
4947
 
"
4948
 
        $echo >> $output "\
4949
 
 
4950
 
  # Find the directory that this script lives in.
4951
 
  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
4952
 
  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4953
 
 
4954
 
  # Follow symbolic links until we get to the real thisdir.
4955
 
  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
4956
 
  while test -n \"\$file\"; do
4957
 
    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
4958
 
 
4959
 
    # If there was a directory component, then change thisdir.
4960
 
    if test \"x\$destdir\" != \"x\$file\"; then
4961
 
      case \"\$destdir\" in
4962
 
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4963
 
      *) thisdir=\"\$thisdir/\$destdir\" ;;
4964
 
      esac
4965
 
    fi
4966
 
 
4967
 
    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
4968
 
    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
4969
 
  done
4970
 
 
4971
 
  # Try to get the absolute directory name.
4972
 
  absdir=\`cd \"\$thisdir\" && pwd\`
4973
 
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
4974
 
"
4975
 
 
4976
 
        if test "$fast_install" = yes; then
4977
 
          $echo >> $output "\
4978
 
  program=lt-'$outputname'$exeext
4979
 
  progdir=\"\$thisdir/$objdir\"
4980
 
 
4981
 
  if test ! -f \"\$progdir/\$program\" || \\
4982
 
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4983
 
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4984
 
 
4985
 
    file=\"\$\$-\$program\"
4986
 
 
4987
 
    if test ! -d \"\$progdir\"; then
4988
 
      $mkdir \"\$progdir\"
4989
 
    else
4990
 
      $rm \"\$progdir/\$file\"
4991
 
    fi"
4992
 
 
4993
 
          $echo >> $output "\
4994
 
 
4995
 
    # relink executable if necessary
4996
 
    if test -n \"\$relink_command\"; then
4997
 
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4998
 
      else
4999
 
        $echo \"\$relink_command_output\" >&2
5000
 
        $rm \"\$progdir/\$file\"
5001
 
        exit $EXIT_FAILURE
5002
 
      fi
5003
 
    fi
5004
 
 
5005
 
    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5006
 
    { $rm \"\$progdir/\$program\";
5007
 
      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5008
 
    $rm \"\$progdir/\$file\"
5009
 
  fi"
5010
 
        else
5011
 
          $echo >> $output "\
5012
 
  program='$outputname'
5013
 
  progdir=\"\$thisdir/$objdir\"
5014
 
"
5015
 
        fi
5016
 
 
5017
 
        $echo >> $output "\
5018
 
 
5019
 
  if test -f \"\$progdir/\$program\"; then"
5020
 
 
5021
 
        # Export our shlibpath_var if we have one.
5022
 
        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5023
 
          $echo >> $output "\
5024
 
    # Add our own library path to $shlibpath_var
5025
 
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5026
 
 
5027
 
    # Some systems cannot cope with colon-terminated $shlibpath_var
5028
 
    # The second colon is a workaround for a bug in BeOS R4 sed
5029
 
    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
5030
 
 
5031
 
    export $shlibpath_var
5032
 
"
5033
 
        fi
5034
 
 
5035
 
        # fixup the dll searchpath if we need to.
5036
 
        if test -n "$dllsearchpath"; then
5037
 
          $echo >> $output "\
5038
 
    # Add the dll search path components to the executable PATH
5039
 
    PATH=$dllsearchpath:\$PATH
5040
 
"
5041
 
        fi
5042
 
 
5043
 
        $echo >> $output "\
5044
 
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
5045
 
      # Run the actual program with our arguments.
5046
 
"
5047
 
        case $host in
5048
 
        # Backslashes separate directories on plain windows
5049
 
        *-*-mingw | *-*-os2*)
5050
 
          $echo >> $output "\
5051
 
      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5052
 
"
5053
 
          ;;
5054
 
 
5055
 
        *)
5056
 
          $echo >> $output "\
5057
 
      exec \"\$progdir/\$program\" \${1+\"\$@\"}
5058
 
"
5059
 
          ;;
5060
 
        esac
5061
 
        $echo >> $output "\
5062
 
      \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
5063
 
      exit $EXIT_FAILURE
5064
 
    fi
5065
 
  else
5066
 
    # The program doesn't exist.
5067
 
    \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
5068
 
    \$echo \"This script is just a wrapper for \$program.\" 1>&2
5069
 
    $echo \"See the $PACKAGE documentation for more information.\" 1>&2
5070
 
    exit $EXIT_FAILURE
5071
 
  fi
5072
 
fi\
5073
 
"
5074
 
        chmod +x $output
5075
 
      fi
 
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
 
9085
      }
5076
9086
      exit $EXIT_SUCCESS
5077
9087
      ;;
5078
9088
    esac
5081
9091
    for oldlib in $oldlibs; do
5082
9092
 
5083
9093
      if test "$build_libtool_libs" = convenience; then
5084
 
        oldobjs="$libobjs_save"
 
9094
        oldobjs="$libobjs_save $symfileobj"
5085
9095
        addlibs="$convenience"
5086
9096
        build_libtool_libs=no
5087
9097
      else
5090
9100
          build_libtool_libs=no
5091
9101
        else
5092
9102
          oldobjs="$old_deplibs $non_pic_objects"
 
9103
          if test "$preload" = yes && test -f "$symfileobj"; then
 
9104
            func_append oldobjs " $symfileobj"
 
9105
          fi
5093
9106
        fi
5094
9107
        addlibs="$old_convenience"
5095
9108
      fi
5096
9109
 
5097
9110
      if test -n "$addlibs"; then
5098
9111
        gentop="$output_objdir/${outputname}x"
5099
 
        generated="$generated $gentop"
 
9112
        func_append generated " $gentop"
5100
9113
 
5101
9114
        func_extract_archives $gentop $addlibs
5102
 
        oldobjs="$oldobjs $func_extract_archives_result"
 
9115
        func_append oldobjs " $func_extract_archives_result"
5103
9116
      fi
5104
9117
 
5105
9118
      # Do each command in the archive commands.
5106
9119
      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
5107
 
       cmds=$old_archive_from_new_cmds
 
9120
        cmds=$old_archive_from_new_cmds
5108
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
 
5109
9132
        # POSIX demands no paths to be encoded in archives.  We have
5110
9133
        # to avoid creating archives with duplicate basenames if we
5111
9134
        # might have to extract them afterwards, e.g., when creating a
5114
9137
        # not supported by libtool).
5115
9138
        if (for obj in $oldobjs
5116
9139
            do
5117
 
              $echo "X$obj" | $Xsed -e 's%^.*/%%'
 
9140
              func_basename "$obj"
 
9141
              $ECHO "$func_basename_result"
5118
9142
            done | sort | sort -uc >/dev/null 2>&1); then
5119
9143
          :
5120
9144
        else
5121
 
          $echo "copying selected object files to avoid basename conflicts..."
5122
 
 
5123
 
          if test -z "$gentop"; then
5124
 
            gentop="$output_objdir/${outputname}x"
5125
 
            generated="$generated $gentop"
5126
 
 
5127
 
            $show "${rm}r $gentop"
5128
 
            $run ${rm}r "$gentop"
5129
 
            $show "$mkdir $gentop"
5130
 
            $run $mkdir "$gentop"
5131
 
            status=$?
5132
 
            if test "$status" -ne 0 && test ! -d "$gentop"; then
5133
 
              exit $status
5134
 
            fi
5135
 
          fi
5136
 
 
 
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"
5137
9149
          save_oldobjs=$oldobjs
5138
9150
          oldobjs=
5139
9151
          counter=1
5140
9152
          for obj in $save_oldobjs
5141
9153
          do
5142
 
            objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
 
9154
            func_basename "$obj"
 
9155
            objbase="$func_basename_result"
5143
9156
            case " $oldobjs " in
5144
9157
            " ") oldobjs=$obj ;;
5145
9158
            *[\ /]"$objbase "*)
5147
9160
                # Make sure we don't pick an alternate name that also
5148
9161
                # overlaps.
5149
9162
                newobj=lt$counter-$objbase
5150
 
                counter=`expr $counter + 1`
 
9163
                func_arith $counter + 1
 
9164
                counter=$func_arith_result
5151
9165
                case " $oldobjs " in
5152
9166
                *[\ /]"$newobj "*) ;;
5153
9167
                *) if test ! -f "$gentop/$newobj"; then break; fi ;;
5154
9168
                esac
5155
9169
              done
5156
 
              $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
5157
 
              $run ln "$obj" "$gentop/$newobj" ||
5158
 
              $run cp "$obj" "$gentop/$newobj"
5159
 
              oldobjs="$oldobjs $gentop/$newobj"
 
9170
              func_show_eval "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
 
9171
              func_append oldobjs " $gentop/$newobj"
5160
9172
              ;;
5161
 
            *) oldobjs="$oldobjs $obj" ;;
 
9173
            *) func_append oldobjs " $obj" ;;
5162
9174
            esac
5163
9175
          done
5164
9176
        fi
5165
 
 
 
9177
        func_to_tool_file "$oldlib" func_convert_file_msys_to_w32
 
9178
        tool_oldlib=$func_to_tool_file_result
5166
9179
        eval cmds=\"$old_archive_cmds\"
5167
9180
 
5168
 
        if len=`expr "X$cmds" : ".*"` &&
5169
 
             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"
5170
9194
          cmds=$old_archive_cmds
5171
9195
        else
5172
9196
          # the command line is too long to link in one step, link in parts
5173
 
          $echo "using piecewise archive linking..."
 
9197
          func_verbose "using piecewise archive linking..."
5174
9198
          save_RANLIB=$RANLIB
5175
9199
          RANLIB=:
5176
9200
          objlist=
5177
9201
          concat_cmds=
5178
9202
          save_oldobjs=$oldobjs
5179
 
 
 
9203
          oldobjs=
5180
9204
          # Is there a better way of finding the last object in the list?
5181
9205
          for obj in $save_oldobjs
5182
9206
          do
5183
9207
            last_oldobj=$obj
5184
9208
          done
 
9209
          eval test_cmds=\"$old_archive_cmds\"
 
9210
          func_len " $test_cmds"
 
9211
          len0=$func_len_result
 
9212
          len=$len0
5185
9213
          for obj in $save_oldobjs
5186
9214
          do
5187
 
            oldobjs="$objlist $obj"
5188
 
            objlist="$objlist $obj"
5189
 
            eval test_cmds=\"$old_archive_cmds\"
5190
 
            if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
5191
 
               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
5192
9220
              :
5193
9221
            else
5194
9222
              # the above command should be used before it gets too long
5195
9223
              oldobjs=$objlist
5196
9224
              if test "$obj" = "$last_oldobj" ; then
5197
 
                RANLIB=$save_RANLIB
 
9225
                RANLIB=$save_RANLIB
5198
9226
              fi
5199
9227
              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
5200
9228
              eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
5201
9229
              objlist=
 
9230
              len=$len0
5202
9231
            fi
5203
9232
          done
5204
9233
          RANLIB=$save_RANLIB
5210
9239
          fi
5211
9240
        fi
5212
9241
      fi
5213
 
      save_ifs="$IFS"; IFS='~'
5214
 
      for cmd in $cmds; do
5215
 
        eval cmd=\"$cmd\"
5216
 
        IFS="$save_ifs"
5217
 
        $show "$cmd"
5218
 
        $run eval "$cmd" || exit $?
5219
 
      done
5220
 
      IFS="$save_ifs"
 
9242
      func_execute_cmds "$cmds" 'exit $?'
5221
9243
    done
5222
9244
 
5223
 
    if test -n "$generated"; then
5224
 
      $show "${rm}r$generated"
5225
 
      $run ${rm}r$generated
5226
 
    fi
 
9245
    test -n "$generated" && \
 
9246
      func_show_eval "${RM}r$generated"
5227
9247
 
5228
9248
    # Now create the libtool archive.
5229
9249
    case $output in
5230
9250
    *.la)
5231
9251
      old_library=
5232
9252
      test "$build_old_libs" = yes && old_library="$libname.$libext"
5233
 
      $show "creating $output"
 
9253
      func_verbose "creating $output"
5234
9254
 
5235
9255
      # Preserve any variables that may affect compiler behavior
5236
9256
      for var in $variables_saved_for_relink; do
5237
9257
        if eval test -z \"\${$var+set}\"; then
5238
 
          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"
5239
9259
        elif eval var_value=\$$var; test -z "$var_value"; then
5240
9260
          relink_command="$var=; export $var; $relink_command"
5241
9261
        else
5242
 
          var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
5243
 
          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"
5244
9264
        fi
5245
9265
      done
5246
9266
      # Quote the link command for shipping.
5247
9267
      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
5248
 
      relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
 
9268
      relink_command=`$ECHO "$relink_command" | $SED "$sed_quote_subst"`
5249
9269
      if test "$hardcode_automatic" = yes ; then
5250
9270
        relink_command=
5251
9271
      fi
5252
9272
 
5253
 
 
5254
9273
      # Only create the output if not a dry run.
5255
 
      if test -z "$run"; then
 
9274
      $opt_dry_run || {
5256
9275
        for installed in no yes; do
5257
9276
          if test "$installed" = yes; then
5258
9277
            if test -z "$install_libdir"; then
5264
9283
            for deplib in $dependency_libs; do
5265
9284
              case $deplib in
5266
9285
              *.la)
5267
 
                name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5268
 
                eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5269
 
                if test -z "$libdir"; then
5270
 
                  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5271
 
                  exit $EXIT_FAILURE
5272
 
                fi
5273
 
                newdependency_libs="$newdependency_libs $libdir/$name"
5274
 
                ;;
5275
 
              *) 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" ;;
5276
9305
              esac
5277
9306
            done
5278
9307
            dependency_libs="$newdependency_libs"
5279
9308
            newdlfiles=
 
9309
 
5280
9310
            for lib in $dlfiles; do
5281
 
              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5282
 
              eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5283
 
              if test -z "$libdir"; then
5284
 
                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5285
 
                exit $EXIT_FAILURE
5286
 
              fi
5287
 
              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
5288
9322
            done
5289
9323
            dlfiles="$newdlfiles"
5290
9324
            newdlprefiles=
5291
9325
            for lib in $dlprefiles; do
5292
 
              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5293
 
              eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5294
 
              if test -z "$libdir"; then
5295
 
                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5296
 
                exit $EXIT_FAILURE
5297
 
              fi
5298
 
              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
5299
9340
            done
5300
9341
            dlprefiles="$newdlprefiles"
5301
9342
          else
5305
9346
                [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5306
9347
                *) abs=`pwd`"/$lib" ;;
5307
9348
              esac
5308
 
              newdlfiles="$newdlfiles $abs"
 
9349
              func_append newdlfiles " $abs"
5309
9350
            done
5310
9351
            dlfiles="$newdlfiles"
5311
9352
            newdlprefiles=
5314
9355
                [\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5315
9356
                *) abs=`pwd`"/$lib" ;;
5316
9357
              esac
5317
 
              newdlprefiles="$newdlprefiles $abs"
 
9358
              func_append newdlprefiles " $abs"
5318
9359
            done
5319
9360
            dlprefiles="$newdlprefiles"
5320
9361
          fi
5321
 
          $rm $output
 
9362
          $RM $output
5322
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.
5323
9372
          tdlname=$dlname
5324
9373
          case $host,$output,$installed,$module,$dlname in
5325
 
            *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
              ;;
5326
9385
          esac
5327
 
          $echo > $output "\
 
9386
          $ECHO > $output "\
5328
9387
# $outputname - a libtool library file
5329
 
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
 
9388
# Generated by $PROGRAM (GNU $PACKAGE$TIMESTAMP) $VERSION
5330
9389
#
5331
9390
# Please DO NOT delete this file!
5332
9391
# It is necessary for linking the library.
5340
9399
# The name of the static archive.
5341
9400
old_library='$old_library'
5342
9401
 
 
9402
# Linker flags that can not go in dependency_libs.
 
9403
inherited_linker_flags='$new_inherited_linker_flags'
 
9404
 
5343
9405
# Libraries that this one depends upon.
5344
9406
dependency_libs='$dependency_libs'
5345
9407
 
 
9408
# Names of additional weak libraries provided by this library
 
9409
weak_library_names='$weak_libs'
 
9410
 
5346
9411
# Version information for $libname.
5347
9412
current=$current
5348
9413
age=$age
5361
9426
# Directory that this library needs to be installed in:
5362
9427
libdir='$install_libdir'"
5363
9428
          if test "$installed" = no && test "$need_relink" = yes; then
5364
 
            $echo >> $output "\
 
9429
            $ECHO >> $output "\
5365
9430
relink_command=\"$relink_command\""
5366
9431
          fi
5367
9432
        done
5368
 
      fi
 
9433
      }
5369
9434
 
5370
9435
      # Do a symbolic link so that the libtool archive can be found in
5371
9436
      # LD_LIBRARY_PATH before the program is installed.
5372
 
      $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5373
 
      $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5374
 
      ;;
5375
 
    esac
5376
 
    exit $EXIT_SUCCESS
5377
 
    ;;
5378
 
 
5379
 
  # libtool install mode
5380
 
  install)
5381
 
    modename="$modename: install"
5382
 
 
5383
 
    # There may be an optional sh(1) argument at the beginning of
5384
 
    # install_prog (especially on Windows NT).
5385
 
    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5386
 
       # Allow the use of GNU shtool's install command.
5387
 
       $echo "X$nonopt" | grep shtool > /dev/null; then
5388
 
      # Aesthetically quote it.
5389
 
      arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5390
 
      case $arg in
5391
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
5392
 
        arg="\"$arg\""
5393
 
        ;;
5394
 
      esac
5395
 
      install_prog="$arg "
5396
 
      arg="$1"
5397
 
      shift
5398
 
    else
5399
 
      install_prog=
5400
 
      arg=$nonopt
5401
 
    fi
5402
 
 
5403
 
    # The real first argument should be the name of the installation program.
5404
 
    # Aesthetically quote it.
5405
 
    arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5406
 
    case $arg in
5407
 
    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
5408
 
      arg="\"$arg\""
5409
 
      ;;
5410
 
    esac
5411
 
    install_prog="$install_prog$arg"
5412
 
 
5413
 
    # We need to accept at least all the BSD install flags.
5414
 
    dest=
5415
 
    files=
5416
 
    opts=
5417
 
    prev=
5418
 
    install_type=
5419
 
    isdir=no
5420
 
    stripme=
5421
 
    for arg
5422
 
    do
5423
 
      if test -n "$dest"; then
5424
 
        files="$files $dest"
5425
 
        dest=$arg
5426
 
        continue
5427
 
      fi
5428
 
 
5429
 
      case $arg in
5430
 
      -d) isdir=yes ;;
5431
 
      -f) 
5432
 
        case " $install_prog " in
5433
 
        *[\\\ /]cp\ *) ;;
5434
 
        *) prev=$arg ;;
5435
 
        esac
5436
 
        ;;
5437
 
      -g | -m | -o) prev=$arg ;;
5438
 
      -s)
5439
 
        stripme=" -s"
5440
 
        continue
5441
 
        ;;
5442
 
      -*)
5443
 
        ;;
5444
 
      *)
5445
 
        # If the previous option needed an argument, then skip it.
5446
 
        if test -n "$prev"; then
5447
 
          prev=
5448
 
        else
5449
 
          dest=$arg
5450
 
          continue
5451
 
        fi
5452
 
        ;;
5453
 
      esac
5454
 
 
5455
 
      # Aesthetically quote the argument.
5456
 
      arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5457
 
      case $arg in
5458
 
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
5459
 
        arg="\"$arg\""
5460
 
        ;;
5461
 
      esac
5462
 
      install_prog="$install_prog $arg"
5463
 
    done
5464
 
 
5465
 
    if test -z "$install_prog"; then
5466
 
      $echo "$modename: you must specify an install program" 1>&2
5467
 
      $echo "$help" 1>&2
5468
 
      exit $EXIT_FAILURE
5469
 
    fi
5470
 
 
5471
 
    if test -n "$prev"; then
5472
 
      $echo "$modename: the \`$prev' option requires an argument" 1>&2
5473
 
      $echo "$help" 1>&2
5474
 
      exit $EXIT_FAILURE
5475
 
    fi
5476
 
 
5477
 
    if test -z "$files"; then
5478
 
      if test -z "$dest"; then
5479
 
        $echo "$modename: no file or destination specified" 1>&2
5480
 
      else
5481
 
        $echo "$modename: you must specify a destination" 1>&2
5482
 
      fi
5483
 
      $echo "$help" 1>&2
5484
 
      exit $EXIT_FAILURE
5485
 
    fi
5486
 
 
5487
 
    # Strip any trailing slash from the destination.
5488
 
    dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5489
 
 
5490
 
    # Check to see that the destination is a directory.
5491
 
    test -d "$dest" && isdir=yes
5492
 
    if test "$isdir" = yes; then
5493
 
      destdir="$dest"
5494
 
      destname=
5495
 
    else
5496
 
      destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5497
 
      test "X$destdir" = "X$dest" && destdir=.
5498
 
      destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5499
 
 
5500
 
      # Not a directory, so check to see that there is only one file specified.
5501
 
      set dummy $files
5502
 
      if test "$#" -gt 2; then
5503
 
        $echo "$modename: \`$dest' is not a directory" 1>&2
5504
 
        $echo "$help" 1>&2
5505
 
        exit $EXIT_FAILURE
5506
 
      fi
5507
 
    fi
5508
 
    case $destdir in
5509
 
    [\\/]* | [A-Za-z]:[\\/]*) ;;
5510
 
    *)
5511
 
      for file in $files; do
5512
 
        case $file in
5513
 
        *.lo) ;;
5514
 
        *)
5515
 
          $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5516
 
          $echo "$help" 1>&2
5517
 
          exit $EXIT_FAILURE
5518
 
          ;;
5519
 
        esac
5520
 
      done
5521
 
      ;;
5522
 
    esac
5523
 
 
5524
 
    # This variable tells wrapper scripts just to set variables rather
5525
 
    # than running their programs.
5526
 
    libtool_install_magic="$magic"
5527
 
 
5528
 
    staticlibs=
5529
 
    future_libdirs=
5530
 
    current_libdirs=
5531
 
    for file in $files; do
5532
 
 
5533
 
      # Do each installation.
5534
 
      case $file in
5535
 
      *.$libext)
5536
 
        # Do the static libraries later.
5537
 
        staticlibs="$staticlibs $file"
5538
 
        ;;
5539
 
 
5540
 
      *.la)
5541
 
        # Check to see that this really is a libtool archive.
5542
 
        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5543
 
        else
5544
 
          $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5545
 
          $echo "$help" 1>&2
5546
 
          exit $EXIT_FAILURE
5547
 
        fi
5548
 
 
5549
 
        library_names=
5550
 
        old_library=
5551
 
        relink_command=
5552
 
        # If there is no directory component, then add one.
5553
 
        case $file in
5554
 
        */* | *\\*) . $file ;;
5555
 
        *) . ./$file ;;
5556
 
        esac
5557
 
 
5558
 
        # Add the libdir to current_libdirs if it is the destination.
5559
 
        if test "X$destdir" = "X$libdir"; then
5560
 
          case "$current_libdirs " in
5561
 
          *" $libdir "*) ;;
5562
 
          *) current_libdirs="$current_libdirs $libdir" ;;
5563
 
          esac
5564
 
        else
5565
 
          # Note the libdir as a future libdir.
5566
 
          case "$future_libdirs " in
5567
 
          *" $libdir "*) ;;
5568
 
          *) future_libdirs="$future_libdirs $libdir" ;;
5569
 
          esac
5570
 
        fi
5571
 
 
5572
 
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5573
 
        test "X$dir" = "X$file/" && dir=
5574
 
        dir="$dir$objdir"
5575
 
 
5576
 
        if test -n "$relink_command"; then
5577
 
          # Determine the prefix the user has applied to our future dir.
5578
 
          inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5579
 
 
5580
 
          # Don't allow the user to place us outside of our expected
5581
 
          # location b/c this prevents finding dependent libraries that
5582
 
          # are installed to the same prefix.
5583
 
          # At present, this check doesn't affect windows .dll's that
5584
 
          # are installed into $libdir/../bin (currently, that works fine)
5585
 
          # but it's something to keep an eye on.
5586
 
          if test "$inst_prefix_dir" = "$destdir"; then
5587
 
            $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5588
 
            exit $EXIT_FAILURE
5589
 
          fi
5590
 
 
5591
 
          if test -n "$inst_prefix_dir"; then
5592
 
            # Stick the inst_prefix_dir data into the link command.
5593
 
            relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
5594
 
          else
5595
 
            relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
5596
 
          fi
5597
 
 
5598
 
          $echo "$modename: warning: relinking \`$file'" 1>&2
5599
 
          $show "$relink_command"
5600
 
          if $run eval "$relink_command"; then :
5601
 
          else
5602
 
            $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5603
 
            exit $EXIT_FAILURE
5604
 
          fi
5605
 
        fi
5606
 
 
5607
 
        # See the names of the shared library.
5608
 
        set dummy $library_names
5609
 
        if test -n "$2"; then
5610
 
          realname="$2"
5611
 
          shift
5612
 
          shift
5613
 
 
5614
 
          srcname="$realname"
5615
 
          test -n "$relink_command" && srcname="$realname"T
5616
 
 
5617
 
          # Install the shared library and build the symlinks.
5618
 
          $show "$install_prog $dir/$srcname $destdir/$realname"
5619
 
          $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
5620
 
          if test -n "$stripme" && test -n "$striplib"; then
5621
 
            $show "$striplib $destdir/$realname"
5622
 
            $run eval "$striplib $destdir/$realname" || exit $?
5623
 
          fi
5624
 
 
5625
 
          if test "$#" -gt 0; then
5626
 
            # Delete the old symlinks, and create new ones.
5627
 
            # Try `ln -sf' first, because the `ln' binary might depend on
5628
 
            # the symlink we replace!  Solaris /bin/ln does not understand -f,
5629
 
            # so we also need to try rm && ln -s.
5630
 
            for linkname
5631
 
            do
5632
 
              if test "$linkname" != "$realname"; then
5633
 
                $show "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
5634
 
                $run eval "(cd $destdir && { $LN_S -f $realname $linkname || { $rm $linkname && $LN_S $realname $linkname; }; })"
5635
 
              fi
5636
 
            done
5637
 
          fi
5638
 
 
5639
 
          # Do each command in the postinstall commands.
5640
 
          lib="$destdir/$realname"
5641
 
          cmds=$postinstall_cmds
5642
 
          save_ifs="$IFS"; IFS='~'
5643
 
          for cmd in $cmds; do
5644
 
            IFS="$save_ifs"
5645
 
            eval cmd=\"$cmd\"
5646
 
            $show "$cmd"
5647
 
            $run eval "$cmd" || {
5648
 
              lt_exit=$?
5649
 
 
5650
 
              # Restore the uninstalled library and exit
5651
 
              if test "$mode" = relink; then
5652
 
                $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
5653
 
              fi
5654
 
 
5655
 
              exit $lt_exit
5656
 
            }
5657
 
          done
5658
 
          IFS="$save_ifs"
5659
 
        fi
5660
 
 
5661
 
        # Install the pseudo-library for information purposes.
5662
 
        name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5663
 
        instname="$dir/$name"i
5664
 
        $show "$install_prog $instname $destdir/$name"
5665
 
        $run eval "$install_prog $instname $destdir/$name" || exit $?
5666
 
 
5667
 
        # Maybe install the static library, too.
5668
 
        test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
5669
 
        ;;
5670
 
 
5671
 
      *.lo)
5672
 
        # Install (i.e. copy) a libtool object.
5673
 
 
5674
 
        # Figure out destination file name, if it wasn't already specified.
5675
 
        if test -n "$destname"; then
5676
 
          destfile="$destdir/$destname"
5677
 
        else
5678
 
          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5679
 
          destfile="$destdir/$destfile"
5680
 
        fi
5681
 
 
5682
 
        # Deduce the name of the destination old-style object file.
5683
 
        case $destfile in
5684
 
        *.lo)
5685
 
          staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
5686
 
          ;;
5687
 
        *.$objext)
5688
 
          staticdest="$destfile"
5689
 
          destfile=
5690
 
          ;;
5691
 
        *)
5692
 
          $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
5693
 
          $echo "$help" 1>&2
5694
 
          exit $EXIT_FAILURE
5695
 
          ;;
5696
 
        esac
5697
 
 
5698
 
        # Install the libtool object if requested.
5699
 
        if test -n "$destfile"; then
5700
 
          $show "$install_prog $file $destfile"
5701
 
          $run eval "$install_prog $file $destfile" || exit $?
5702
 
        fi
5703
 
 
5704
 
        # Install the old object if enabled.
5705
 
        if test "$build_old_libs" = yes; then
5706
 
          # Deduce the name of the old-style object file.
5707
 
          staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
5708
 
 
5709
 
          $show "$install_prog $staticobj $staticdest"
5710
 
          $run eval "$install_prog \$staticobj \$staticdest" || exit $?
5711
 
        fi
5712
 
        exit $EXIT_SUCCESS
5713
 
        ;;
5714
 
 
5715
 
      *)
5716
 
        # Figure out destination file name, if it wasn't already specified.
5717
 
        if test -n "$destname"; then
5718
 
          destfile="$destdir/$destname"
5719
 
        else
5720
 
          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5721
 
          destfile="$destdir/$destfile"
5722
 
        fi
5723
 
 
5724
 
        # If the file is missing, and there is a .exe on the end, strip it
5725
 
        # because it is most likely a libtool script we actually want to
5726
 
        # install
5727
 
        stripped_ext=""
5728
 
        case $file in
5729
 
          *.exe)
5730
 
            if test ! -f "$file"; then
5731
 
              file=`$echo $file|${SED} 's,.exe$,,'`
5732
 
              stripped_ext=".exe"
5733
 
            fi
5734
 
            ;;
5735
 
        esac
5736
 
 
5737
 
        # Do a test to see if this is really a libtool program.
5738
 
        case $host in
5739
 
        *cygwin*|*mingw*)
5740
 
            wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
5741
 
            ;;
5742
 
        *)
5743
 
            wrapper=$file
5744
 
            ;;
5745
 
        esac
5746
 
        if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
5747
 
          notinst_deplibs=
5748
 
          relink_command=
5749
 
 
5750
 
          # Note that it is not necessary on cygwin/mingw to append a dot to
5751
 
          # foo even if both foo and FILE.exe exist: automatic-append-.exe
5752
 
          # behavior happens only for exec(3), not for open(2)!  Also, sourcing
5753
 
          # `FILE.' does not work on cygwin managed mounts.
5754
 
          #
5755
 
          # If there is no directory component, then add one.
5756
 
          case $wrapper in
5757
 
          */* | *\\*) . ${wrapper} ;;
5758
 
          *) . ./${wrapper} ;;
5759
 
          esac
5760
 
 
5761
 
          # Check the variables that should have been set.
5762
 
          if test -z "$notinst_deplibs"; then
5763
 
            $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
5764
 
            exit $EXIT_FAILURE
5765
 
          fi
5766
 
 
5767
 
          finalize=yes
5768
 
          for lib in $notinst_deplibs; do
5769
 
            # Check to see that each library is installed.
5770
 
            libdir=
5771
 
            if test -f "$lib"; then
5772
 
              # If there is no directory component, then add one.
5773
 
              case $lib in
5774
 
              */* | *\\*) . $lib ;;
5775
 
              *) . ./$lib ;;
5776
 
              esac
5777
 
            fi
5778
 
            libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
5779
 
            if test -n "$libdir" && test ! -f "$libfile"; then
5780
 
              $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
5781
 
              finalize=no
5782
 
            fi
5783
 
          done
5784
 
 
5785
 
          relink_command=
5786
 
          # Note that it is not necessary on cygwin/mingw to append a dot to
5787
 
          # foo even if both foo and FILE.exe exist: automatic-append-.exe
5788
 
          # behavior happens only for exec(3), not for open(2)!  Also, sourcing
5789
 
          # `FILE.' does not work on cygwin managed mounts.
5790
 
          #
5791
 
          # If there is no directory component, then add one.
5792
 
          case $wrapper in
5793
 
          */* | *\\*) . ${wrapper} ;;
5794
 
          *) . ./${wrapper} ;;
5795
 
          esac
5796
 
 
5797
 
          outputname=
5798
 
          if test "$fast_install" = no && test -n "$relink_command"; then
5799
 
            if test "$finalize" = yes && test -z "$run"; then
5800
 
              tmpdir="/tmp"
5801
 
              test -n "$TMPDIR" && tmpdir="$TMPDIR"
5802
 
              tmpdir="$tmpdir/libtool-$$"
5803
 
              save_umask=`umask`
5804
 
              umask 0077
5805
 
              if $mkdir "$tmpdir"; then
5806
 
                umask $save_umask
5807
 
              else
5808
 
                umask $save_umask
5809
 
                $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
5810
 
                continue
5811
 
              fi
5812
 
              file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
5813
 
              outputname="$tmpdir/$file"
5814
 
              # Replace the output file specification.
5815
 
              relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
5816
 
 
5817
 
              $show "$relink_command"
5818
 
              if $run eval "$relink_command"; then :
5819
 
              else
5820
 
                $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5821
 
                ${rm}r "$tmpdir"
5822
 
                continue
5823
 
              fi
5824
 
              file="$outputname"
5825
 
            else
5826
 
              $echo "$modename: warning: cannot relink \`$file'" 1>&2
5827
 
            fi
5828
 
          else
5829
 
            # Install the binary that we compiled earlier.
5830
 
            file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
5831
 
          fi
5832
 
        fi
5833
 
 
5834
 
        # remove .exe since cygwin /usr/bin/install will append another
5835
 
        # one anyway 
5836
 
        case $install_prog,$host in
5837
 
        */usr/bin/install*,*cygwin*)
5838
 
          case $file:$destfile in
5839
 
          *.exe:*.exe)
5840
 
            # this is ok
5841
 
            ;;
5842
 
          *.exe:*)
5843
 
            destfile=$destfile.exe
5844
 
            ;;
5845
 
          *:*.exe)
5846
 
            destfile=`$echo $destfile | ${SED} -e 's,.exe$,,'`
5847
 
            ;;
5848
 
          esac
5849
 
          ;;
5850
 
        esac
5851
 
        $show "$install_prog$stripme $file $destfile"
5852
 
        $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
5853
 
        test -n "$outputname" && ${rm}r "$tmpdir"
5854
 
        ;;
5855
 
      esac
5856
 
    done
5857
 
 
5858
 
    for file in $staticlibs; do
5859
 
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5860
 
 
5861
 
      # Set up the ranlib parameters.
5862
 
      oldlib="$destdir/$name"
5863
 
 
5864
 
      $show "$install_prog $file $oldlib"
5865
 
      $run eval "$install_prog \$file \$oldlib" || exit $?
5866
 
 
5867
 
      if test -n "$stripme" && test -n "$old_striplib"; then
5868
 
        $show "$old_striplib $oldlib"
5869
 
        $run eval "$old_striplib $oldlib" || exit $?
5870
 
      fi
5871
 
 
5872
 
      # Do each command in the postinstall commands.
5873
 
      cmds=$old_postinstall_cmds
5874
 
      save_ifs="$IFS"; IFS='~'
5875
 
      for cmd in $cmds; do
5876
 
        IFS="$save_ifs"
5877
 
        eval cmd=\"$cmd\"
5878
 
        $show "$cmd"
5879
 
        $run eval "$cmd" || exit $?
5880
 
      done
5881
 
      IFS="$save_ifs"
5882
 
    done
5883
 
 
5884
 
    if test -n "$future_libdirs"; then
5885
 
      $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
5886
 
    fi
5887
 
 
5888
 
    if test -n "$current_libdirs"; then
5889
 
      # Maybe just do a dry run.
5890
 
      test -n "$run" && current_libdirs=" -n$current_libdirs"
5891
 
      exec_cmd='$SHELL $progpath $preserve_args --finish$current_libdirs'
5892
 
    else
5893
 
      exit $EXIT_SUCCESS
5894
 
    fi
5895
 
    ;;
5896
 
 
5897
 
  # libtool finish mode
5898
 
  finish)
5899
 
    modename="$modename: finish"
5900
 
    libdirs="$nonopt"
5901
 
    admincmds=
5902
 
 
5903
 
    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
5904
 
      for dir
5905
 
      do
5906
 
        libdirs="$libdirs $dir"
5907
 
      done
5908
 
 
5909
 
      for libdir in $libdirs; do
5910
 
        if test -n "$finish_cmds"; then
5911
 
          # Do each command in the finish commands.
5912
 
          cmds=$finish_cmds
5913
 
          save_ifs="$IFS"; IFS='~'
5914
 
          for cmd in $cmds; do
5915
 
            IFS="$save_ifs"
5916
 
            eval cmd=\"$cmd\"
5917
 
            $show "$cmd"
5918
 
            $run eval "$cmd" || admincmds="$admincmds
5919
 
       $cmd"
5920
 
          done
5921
 
          IFS="$save_ifs"
5922
 
        fi
5923
 
        if test -n "$finish_eval"; then
5924
 
          # Do the single finish_eval.
5925
 
          eval cmds=\"$finish_eval\"
5926
 
          $run eval "$cmds" || admincmds="$admincmds
5927
 
       $cmds"
5928
 
        fi
5929
 
      done
5930
 
    fi
5931
 
 
5932
 
    # Exit here if they wanted silent mode.
5933
 
    test "$show" = : && exit $EXIT_SUCCESS
5934
 
 
5935
 
    $echo "----------------------------------------------------------------------"
5936
 
    $echo "Libraries have been installed in:"
5937
 
    for libdir in $libdirs; do
5938
 
      $echo "   $libdir"
5939
 
    done
5940
 
    $echo
5941
 
    $echo "If you ever happen to want to link against installed libraries"
5942
 
    $echo "in a given directory, LIBDIR, you must either use libtool, and"
5943
 
    $echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
5944
 
    $echo "flag during linking and do at least one of the following:"
5945
 
    if test -n "$shlibpath_var"; then
5946
 
      $echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
5947
 
      $echo "     during execution"
5948
 
    fi
5949
 
    if test -n "$runpath_var"; then
5950
 
      $echo "   - add LIBDIR to the \`$runpath_var' environment variable"
5951
 
      $echo "     during linking"
5952
 
    fi
5953
 
    if test -n "$hardcode_libdir_flag_spec"; then
5954
 
      libdir=LIBDIR
5955
 
      eval flag=\"$hardcode_libdir_flag_spec\"
5956
 
 
5957
 
      $echo "   - use the \`$flag' linker flag"
5958
 
    fi
5959
 
    if test -n "$admincmds"; then
5960
 
      $echo "   - have your system administrator run these commands:$admincmds"
5961
 
    fi
5962
 
    if test -f /etc/ld.so.conf; then
5963
 
      $echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
5964
 
    fi
5965
 
    $echo
5966
 
    $echo "See any operating system documentation about shared libraries for"
5967
 
    $echo "more information, such as the ld(1) and ld.so(8) manual pages."
5968
 
    $echo "----------------------------------------------------------------------"
5969
 
    exit $EXIT_SUCCESS
5970
 
    ;;
5971
 
 
5972
 
  # libtool execute mode
5973
 
  execute)
5974
 
    modename="$modename: execute"
5975
 
 
5976
 
    # The first argument is the command name.
5977
 
    cmd="$nonopt"
5978
 
    if test -z "$cmd"; then
5979
 
      $echo "$modename: you must specify a COMMAND" 1>&2
5980
 
      $echo "$help"
5981
 
      exit $EXIT_FAILURE
5982
 
    fi
5983
 
 
5984
 
    # Handle -dlopen flags immediately.
5985
 
    for file in $execute_dlfiles; do
5986
 
      if test ! -f "$file"; then
5987
 
        $echo "$modename: \`$file' is not a file" 1>&2
5988
 
        $echo "$help" 1>&2
5989
 
        exit $EXIT_FAILURE
5990
 
      fi
5991
 
 
5992
 
      dir=
5993
 
      case $file in
5994
 
      *.la)
5995
 
        # Check to see that this really is a libtool archive.
5996
 
        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5997
 
        else
5998
 
          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5999
 
          $echo "$help" 1>&2
6000
 
          exit $EXIT_FAILURE
6001
 
        fi
6002
 
 
6003
 
        # Read the libtool library.
6004
 
        dlname=
6005
 
        library_names=
6006
 
 
6007
 
        # If there is no directory component, then add one.
6008
 
        case $file in
6009
 
        */* | *\\*) . $file ;;
6010
 
        *) . ./$file ;;
6011
 
        esac
6012
 
 
6013
 
        # Skip this library if it cannot be dlopened.
6014
 
        if test -z "$dlname"; then
6015
 
          # Warn if it was a shared library.
6016
 
          test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
6017
 
          continue
6018
 
        fi
6019
 
 
6020
 
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6021
 
        test "X$dir" = "X$file" && dir=.
6022
 
 
6023
 
        if test -f "$dir/$objdir/$dlname"; then
6024
 
          dir="$dir/$objdir"
6025
 
        else
6026
 
          $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
6027
 
          exit $EXIT_FAILURE
6028
 
        fi
6029
 
        ;;
6030
 
 
6031
 
      *.lo)
6032
 
        # Just add the directory containing the .lo file.
6033
 
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6034
 
        test "X$dir" = "X$file" && dir=.
6035
 
        ;;
6036
 
 
6037
 
      *)
6038
 
        $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
6039
 
        continue
6040
 
        ;;
6041
 
      esac
6042
 
 
6043
 
      # Get the absolute pathname.
6044
 
      absdir=`cd "$dir" && pwd`
6045
 
      test -n "$absdir" && dir="$absdir"
6046
 
 
6047
 
      # Now add the directory to shlibpath_var.
6048
 
      if eval "test -z \"\$$shlibpath_var\""; then
6049
 
        eval "$shlibpath_var=\"\$dir\""
6050
 
      else
6051
 
        eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
6052
 
      fi
6053
 
    done
6054
 
 
6055
 
    # This variable tells wrapper scripts just to set shlibpath_var
6056
 
    # rather than running their programs.
6057
 
    libtool_execute_magic="$magic"
6058
 
 
6059
 
    # Check if any of the arguments is a wrapper script.
6060
 
    args=
6061
 
    for file
6062
 
    do
6063
 
      case $file in
6064
 
      -*) ;;
6065
 
      *)
6066
 
        # Do a test to see if this is really a libtool program.
6067
 
        if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6068
 
          # If there is no directory component, then add one.
6069
 
          case $file in
6070
 
          */* | *\\*) . $file ;;
6071
 
          *) . ./$file ;;
6072
 
          esac
6073
 
 
6074
 
          # Transform arg to wrapped name.
6075
 
          file="$progdir/$program"
6076
 
        fi
6077
 
        ;;
6078
 
      esac
6079
 
      # Quote arguments (to preserve shell metacharacters).
6080
 
      file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
6081
 
      args="$args \"$file\""
6082
 
    done
6083
 
 
6084
 
    if test -z "$run"; then
6085
 
      if test -n "$shlibpath_var"; then
6086
 
        # Export the shlibpath_var.
6087
 
        eval "export $shlibpath_var"
6088
 
      fi
6089
 
 
6090
 
      # Restore saved environment variables
6091
 
      if test "${save_LC_ALL+set}" = set; then
6092
 
        LC_ALL="$save_LC_ALL"; export LC_ALL
6093
 
      fi
6094
 
      if test "${save_LANG+set}" = set; then
6095
 
        LANG="$save_LANG"; export LANG
6096
 
      fi
6097
 
 
6098
 
      # Now prepare to actually exec the command.
6099
 
      exec_cmd="\$cmd$args"
6100
 
    else
6101
 
      # Display what would be done.
6102
 
      if test -n "$shlibpath_var"; then
6103
 
        eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
6104
 
        $echo "export $shlibpath_var"
6105
 
      fi
6106
 
      $echo "$cmd$args"
6107
 
      exit $EXIT_SUCCESS
6108
 
    fi
6109
 
    ;;
6110
 
 
6111
 
  # libtool clean and uninstall mode
6112
 
  clean | uninstall)
6113
 
    modename="$modename: $mode"
6114
 
    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"
6115
9452
    files=
6116
9453
    rmforce=
6117
9454
    exit_status=0
6123
9460
    for arg
6124
9461
    do
6125
9462
      case $arg in
6126
 
      -f) rm="$rm $arg"; rmforce=yes ;;
6127
 
      -*) rm="$rm $arg" ;;
6128
 
      *) files="$files $arg" ;;
 
9463
      -f) func_append RM " $arg"; rmforce=yes ;;
 
9464
      -*) func_append RM " $arg" ;;
 
9465
      *) func_append files " $arg" ;;
6129
9466
      esac
6130
9467
    done
6131
9468
 
6132
 
    if test -z "$rm"; then
6133
 
      $echo "$modename: you must specify an RM program" 1>&2
6134
 
      $echo "$help" 1>&2
6135
 
      exit $EXIT_FAILURE
6136
 
    fi
 
9469
    test -z "$RM" && \
 
9470
      func_fatal_help "you must specify an RM program"
6137
9471
 
6138
9472
    rmdirs=
6139
9473
 
6140
 
    origobjdir="$objdir"
6141
9474
    for file in $files; do
6142
 
      dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
6143
 
      if test "X$dir" = "X$file"; then
6144
 
        dir=.
6145
 
        objdir="$origobjdir"
 
9475
      func_dirname "$file" "" "."
 
9476
      dir="$func_dirname_result"
 
9477
      if test "X$dir" = X.; then
 
9478
        odir="$objdir"
6146
9479
      else
6147
 
        objdir="$dir/$origobjdir"
 
9480
        odir="$dir/$objdir"
6148
9481
      fi
6149
 
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
6150
 
      test "$mode" = uninstall && objdir="$dir"
 
9482
      func_basename "$file"
 
9483
      name="$func_basename_result"
 
9484
      test "$opt_mode" = uninstall && odir="$dir"
6151
9485
 
6152
 
      # Remember objdir for removal later, being careful to avoid duplicates
6153
 
      if test "$mode" = clean; then
 
9486
      # Remember odir for removal later, being careful to avoid duplicates
 
9487
      if test "$opt_mode" = clean; then
6154
9488
        case " $rmdirs " in
6155
 
          *" $objdir "*) ;;
6156
 
          *) rmdirs="$rmdirs $objdir" ;;
 
9489
          *" $odir "*) ;;
 
9490
          *) func_append rmdirs " $odir" ;;
6157
9491
        esac
6158
9492
      fi
6159
9493
 
6160
9494
      # Don't error if the file doesn't exist and rm -f was used.
6161
 
      if (test -L "$file") >/dev/null 2>&1 \
6162
 
        || (test -h "$file") >/dev/null 2>&1 \
6163
 
        || 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
6164
9498
        :
6165
9499
      elif test -d "$file"; then
6166
9500
        exit_status=1
6174
9508
      case $name in
6175
9509
      *.la)
6176
9510
        # Possibly a libtool archive, so verify it.
6177
 
        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6178
 
          . $dir/$name
 
9511
        if func_lalib_p "$file"; then
 
9512
          func_source $dir/$name
6179
9513
 
6180
9514
          # Delete the libtool libraries and symlinks.
6181
9515
          for n in $library_names; do
6182
 
            rmfiles="$rmfiles $objdir/$n"
 
9516
            func_append rmfiles " $odir/$n"
6183
9517
          done
6184
 
          test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
6185
 
          test "$mode" = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
 
9518
          test -n "$old_library" && func_append rmfiles " $odir/$old_library"
6186
9519
 
6187
 
          if test "$mode" = uninstall; then
 
9520
          case "$opt_mode" in
 
9521
          clean)
 
9522
            case " $library_names " in
 
9523
            *" $dlname "*) ;;
 
9524
            *) test -n "$dlname" && func_append rmfiles " $odir/$dlname" ;;
 
9525
            esac
 
9526
            test -n "$libdir" && func_append rmfiles " $odir/$name $odir/${name}i"
 
9527
            ;;
 
9528
          uninstall)
6188
9529
            if test -n "$library_names"; then
6189
9530
              # Do each command in the postuninstall commands.
6190
 
              cmds=$postuninstall_cmds
6191
 
              save_ifs="$IFS"; IFS='~'
6192
 
              for cmd in $cmds; do
6193
 
                IFS="$save_ifs"
6194
 
                eval cmd=\"$cmd\"
6195
 
                $show "$cmd"
6196
 
                $run eval "$cmd"
6197
 
                if test "$?" -ne 0 && test "$rmforce" != yes; then
6198
 
                  exit_status=1
6199
 
                fi
6200
 
              done
6201
 
              IFS="$save_ifs"
 
9531
              func_execute_cmds "$postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
6202
9532
            fi
6203
9533
 
6204
9534
            if test -n "$old_library"; then
6205
9535
              # Do each command in the old_postuninstall commands.
6206
 
              cmds=$old_postuninstall_cmds
6207
 
              save_ifs="$IFS"; IFS='~'
6208
 
              for cmd in $cmds; do
6209
 
                IFS="$save_ifs"
6210
 
                eval cmd=\"$cmd\"
6211
 
                $show "$cmd"
6212
 
                $run eval "$cmd"
6213
 
                if test "$?" -ne 0 && test "$rmforce" != yes; then
6214
 
                  exit_status=1
6215
 
                fi
6216
 
              done
6217
 
              IFS="$save_ifs"
 
9536
              func_execute_cmds "$old_postuninstall_cmds" 'test "$rmforce" = yes || exit_status=1'
6218
9537
            fi
6219
9538
            # FIXME: should reinstall the best remaining shared library.
6220
 
          fi
 
9539
            ;;
 
9540
          esac
6221
9541
        fi
6222
9542
        ;;
6223
9543
 
6224
9544
      *.lo)
6225
9545
        # Possibly a libtool object, so verify it.
6226
 
        if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
 
9546
        if func_lalib_p "$file"; then
6227
9547
 
6228
9548
          # Read the .lo file
6229
 
          . $dir/$name
 
9549
          func_source $dir/$name
6230
9550
 
6231
9551
          # Add PIC object to the list of files to remove.
6232
 
          if test -n "$pic_object" \
6233
 
             && test "$pic_object" != none; then
6234
 
            rmfiles="$rmfiles $dir/$pic_object"
 
9552
          if test -n "$pic_object" &&
 
9553
             test "$pic_object" != none; then
 
9554
            func_append rmfiles " $dir/$pic_object"
6235
9555
          fi
6236
9556
 
6237
9557
          # Add non-PIC object to the list of files to remove.
6238
 
          if test -n "$non_pic_object" \
6239
 
             && test "$non_pic_object" != none; then
6240
 
            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"
6241
9561
          fi
6242
9562
        fi
6243
9563
        ;;
6244
9564
 
6245
9565
      *)
6246
 
        if test "$mode" = clean ; then
 
9566
        if test "$opt_mode" = clean ; then
6247
9567
          noexename=$name
6248
9568
          case $file in
6249
9569
          *.exe)
6250
 
            file=`$echo $file|${SED} 's,.exe$,,'`
6251
 
            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
6252
9574
            # $file with .exe has already been added to rmfiles,
6253
9575
            # add $file without .exe
6254
 
            rmfiles="$rmfiles $file"
 
9576
            func_append rmfiles " $file"
6255
9577
            ;;
6256
9578
          esac
6257
9579
          # Do a test to see if this is a libtool program.
6258
 
          if (${SED} -e '4q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
6259
 
            relink_command=
6260
 
            . $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
6261
9590
 
6262
9591
            # note $name still contains .exe if it was in $file originally
6263
9592
            # as does the version of $file that was added into $rmfiles
6264
 
            rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
 
9593
            func_append rmfiles " $odir/$name $odir/${name}S.${objext}"
6265
9594
            if test "$fast_install" = yes && test -n "$relink_command"; then
6266
 
              rmfiles="$rmfiles $objdir/lt-$name"
 
9595
              func_append rmfiles " $odir/lt-$name"
6267
9596
            fi
6268
9597
            if test "X$noexename" != "X$name" ; then
6269
 
              rmfiles="$rmfiles $objdir/lt-${noexename}.c"
 
9598
              func_append rmfiles " $odir/lt-${noexename}.c"
6270
9599
            fi
6271
9600
          fi
6272
9601
        fi
6273
9602
        ;;
6274
9603
      esac
6275
 
      $show "$rm $rmfiles"
6276
 
      $run $rm $rmfiles || exit_status=1
 
9604
      func_show_eval "$RM $rmfiles" 'exit_status=1'
6277
9605
    done
6278
 
    objdir="$origobjdir"
6279
9606
 
6280
9607
    # Try to remove the ${objdir}s in the directories where we deleted files
6281
9608
    for dir in $rmdirs; do
6282
9609
      if test -d "$dir"; then
6283
 
        $show "rmdir $dir"
6284
 
        $run rmdir $dir >/dev/null 2>&1
 
9610
        func_show_eval "rmdir $dir >/dev/null 2>&1"
6285
9611
      fi
6286
9612
    done
6287
9613
 
6288
9614
    exit $exit_status
6289
 
    ;;
6290
 
 
6291
 
  "")
6292
 
    $echo "$modename: you must specify a MODE" 1>&2
6293
 
    $echo "$generic_help" 1>&2
6294
 
    exit $EXIT_FAILURE
6295
 
    ;;
6296
 
  esac
6297
 
 
6298
 
  if test -z "$exec_cmd"; then
6299
 
    $echo "$modename: invalid operation mode \`$mode'" 1>&2
6300
 
    $echo "$generic_help" 1>&2
6301
 
    exit $EXIT_FAILURE
6302
 
  fi
6303
 
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'"
6304
9627
 
6305
9628
if test -n "$exec_cmd"; then
6306
 
  eval exec $exec_cmd
 
9629
  eval exec "$exec_cmd"
6307
9630
  exit $EXIT_FAILURE
6308
9631
fi
6309
9632
 
6310
 
# We need to display help for each of the modes.
6311
 
case $mode in
6312
 
"") $echo \
6313
 
"Usage: $modename [OPTION]... [MODE-ARG]...
6314
 
 
6315
 
Provide generalized library-building support services.
6316
 
 
6317
 
    --config          show all configuration variables
6318
 
    --debug           enable verbose shell tracing
6319
 
-n, --dry-run         display commands without modifying any files
6320
 
    --features        display basic configuration information and exit
6321
 
    --finish          same as \`--mode=finish'
6322
 
    --help            display this help message and exit
6323
 
    --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
6324
 
    --quiet           same as \`--silent'
6325
 
    --silent          don't print informational messages
6326
 
    --tag=TAG         use configuration variables from tag TAG
6327
 
    --version         print version information
6328
 
 
6329
 
MODE must be one of the following:
6330
 
 
6331
 
      clean           remove files from the build directory
6332
 
      compile         compile a source file into a libtool object
6333
 
      execute         automatically set library path, then run a program
6334
 
      finish          complete the installation of libtool libraries
6335
 
      install         install libraries or executables
6336
 
      link            create a library or an executable
6337
 
      uninstall       remove libraries from an installed directory
6338
 
 
6339
 
MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
6340
 
a more detailed description of MODE.
6341
 
 
6342
 
Report bugs to <bug-libtool@gnu.org>."
6343
 
  exit $EXIT_SUCCESS
6344
 
  ;;
6345
 
 
6346
 
clean)
6347
 
  $echo \
6348
 
"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
6349
 
 
6350
 
Remove files from the build directory.
6351
 
 
6352
 
RM is the name of the program to use to delete files associated with each FILE
6353
 
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6354
 
to RM.
6355
 
 
6356
 
If FILE is a libtool library, object or program, all the files associated
6357
 
with it are deleted. Otherwise, only FILE itself is deleted using RM."
6358
 
  ;;
6359
 
 
6360
 
compile)
6361
 
  $echo \
6362
 
"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
6363
 
 
6364
 
Compile a source file into a libtool library object.
6365
 
 
6366
 
This mode accepts the following additional options:
6367
 
 
6368
 
  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
6369
 
  -prefer-pic       try to building PIC objects only
6370
 
  -prefer-non-pic   try to building non-PIC objects only
6371
 
  -static           always build a \`.o' file suitable for static linking
6372
 
 
6373
 
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
6374
 
from the given SOURCEFILE.
6375
 
 
6376
 
The output file name is determined by removing the directory component from
6377
 
SOURCEFILE, then substituting the C source code suffix \`.c' with the
6378
 
library object suffix, \`.lo'."
6379
 
  ;;
6380
 
 
6381
 
execute)
6382
 
  $echo \
6383
 
"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
6384
 
 
6385
 
Automatically set library path, then run a program.
6386
 
 
6387
 
This mode accepts the following additional options:
6388
 
 
6389
 
  -dlopen FILE      add the directory containing FILE to the library path
6390
 
 
6391
 
This mode sets the library path environment variable according to \`-dlopen'
6392
 
flags.
6393
 
 
6394
 
If any of the ARGS are libtool executable wrappers, then they are translated
6395
 
into their corresponding uninstalled binary, and any of their required library
6396
 
directories are added to the library path.
6397
 
 
6398
 
Then, COMMAND is executed, with ARGS as arguments."
6399
 
  ;;
6400
 
 
6401
 
finish)
6402
 
  $echo \
6403
 
"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
6404
 
 
6405
 
Complete the installation of libtool libraries.
6406
 
 
6407
 
Each LIBDIR is a directory that contains libtool libraries.
6408
 
 
6409
 
The commands that this mode executes may require superuser privileges.  Use
6410
 
the \`--dry-run' option if you just want to see what would be executed."
6411
 
  ;;
6412
 
 
6413
 
install)
6414
 
  $echo \
6415
 
"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
6416
 
 
6417
 
Install executables or libraries.
6418
 
 
6419
 
INSTALL-COMMAND is the installation command.  The first component should be
6420
 
either the \`install' or \`cp' program.
6421
 
 
6422
 
The rest of the components are interpreted as arguments to that command (only
6423
 
BSD-compatible install options are recognized)."
6424
 
  ;;
6425
 
 
6426
 
link)
6427
 
  $echo \
6428
 
"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
6429
 
 
6430
 
Link object files or libraries together to form another library, or to
6431
 
create an executable program.
6432
 
 
6433
 
LINK-COMMAND is a command using the C compiler that you would use to create
6434
 
a program from several object files.
6435
 
 
6436
 
The following components of LINK-COMMAND are treated specially:
6437
 
 
6438
 
  -all-static       do not do any dynamic linking at all
6439
 
  -avoid-version    do not add a version suffix if possible
6440
 
  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
6441
 
  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
6442
 
  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
6443
 
  -export-symbols SYMFILE
6444
 
                    try to export only the symbols listed in SYMFILE
6445
 
  -export-symbols-regex REGEX
6446
 
                    try to export only the symbols matching REGEX
6447
 
  -LLIBDIR          search LIBDIR for required installed libraries
6448
 
  -lNAME            OUTPUT-FILE requires the installed library libNAME
6449
 
  -module           build a library that can dlopened
6450
 
  -no-fast-install  disable the fast-install mode
6451
 
  -no-install       link a not-installable executable
6452
 
  -no-undefined     declare that a library does not refer to external symbols
6453
 
  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
6454
 
  -objectlist FILE  Use a list of object files found in FILE to specify objects
6455
 
  -precious-files-regex REGEX
6456
 
                    don't remove output files matching REGEX
6457
 
  -release RELEASE  specify package release information
6458
 
  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
6459
 
  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
6460
 
  -static           do not do any dynamic linking of libtool libraries
6461
 
  -version-info CURRENT[:REVISION[:AGE]]
6462
 
                    specify library version info [each variable defaults to 0]
6463
 
 
6464
 
All other options (arguments beginning with \`-') are ignored.
6465
 
 
6466
 
Every other argument is treated as a filename.  Files ending in \`.la' are
6467
 
treated as uninstalled libtool libraries, other files are standard or library
6468
 
object files.
6469
 
 
6470
 
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
6471
 
only library objects (\`.lo' files) may be specified, and \`-rpath' is
6472
 
required, except when creating a convenience library.
6473
 
 
6474
 
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
6475
 
using \`ar' and \`ranlib', or on Windows using \`lib'.
6476
 
 
6477
 
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
6478
 
is created, otherwise an executable program is created."
6479
 
  ;;
6480
 
 
6481
 
uninstall)
6482
 
  $echo \
6483
 
"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
6484
 
 
6485
 
Remove libraries from an installation directory.
6486
 
 
6487
 
RM is the name of the program to use to delete files associated with each FILE
6488
 
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
6489
 
to RM.
6490
 
 
6491
 
If FILE is a libtool library, all the files associated with it are deleted.
6492
 
Otherwise, only FILE itself is deleted using RM."
6493
 
  ;;
6494
 
 
6495
 
*)
6496
 
  $echo "$modename: invalid operation mode \`$mode'" 1>&2
6497
 
  $echo "$help" 1>&2
6498
 
  exit $EXIT_FAILURE
6499
 
  ;;
6500
 
esac
6501
 
 
6502
 
$echo
6503
 
$echo "Try \`$modename --help' for more information about other modes."
6504
 
 
6505
 
exit $?
 
9633
exit $exit_status
 
9634
 
6506
9635
 
6507
9636
# The TAGs below are defined such that we never get into a situation
6508
9637
# in which we disable both kinds of libraries.  Given conflicting
6521
9650
# ### END LIBTOOL TAG CONFIG: disable-shared
6522
9651
 
6523
9652
# ### BEGIN LIBTOOL TAG CONFIG: disable-static
6524
 
build_old_libs=`case $build_libtool_libs in yes) $echo no;; *) $echo yes;; esac`
 
9653
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
6525
9654
# ### END LIBTOOL TAG CONFIG: disable-static
6526
9655
 
6527
9656
# Local Variables:
6528
9657
# mode:shell-script
6529
9658
# sh-indentation:2
6530
9659
# End:
 
9660
# vi:sw=2
 
9661