OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-old/] [gdb-7.1/] [ltmain.sh] - Blame information for rev 820

Go to most recent revision | Details | Compare with Previous | View Log

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

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.