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

Subversion Repositories openrisc_me

[/] [openrisc/] [trunk/] [gnu-src/] [gdb-6.8/] [ltmain.sh] - Blame information for rev 174

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

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

powered by: WebSVN 2.1.0

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