Subversion Repositories svnkaklik

Rev

Go to most recent revision | Details | Last modification | View Log

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