Statistics
| Revision:

root / ltmain.sh @ 2022

History | View | Annotate | Download (195 KB)

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, 2008  Free Software Foundation, Inc.
6
# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
7
#
8
# This program is free software; you can redistribute it and/or modify
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.26 Debian 1.5.26-1ubuntu1"
47
TIMESTAMP=" (1.1220.2.493 2008/02/01 16:58:18)"
48

    
49
# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
50
if test -n "${ZSH_VERSION+set}" && (emulate sh) >/dev/null 2>&1; then
51
  emulate sh
52
  NULLCMD=:
53
  # Zsh 3.x and 4.x performs word splitting on ${1+"$@"}, which
54
  # is contrary to our usage.  Disable this feature.
55
  alias -g '${1+"$@"}'='"$@"'
56
  setopt NO_GLOB_SUBST
57
else
58
  case `(set -o) 2>/dev/null` in *posix*) set -o posix;; esac
59
fi
60
BIN_SH=xpg4; export BIN_SH # for Tru64
61
DUALCASE=1; export DUALCASE # for MKS sh
62

    
63
# Check that we have a working $echo.
64
if test "X$1" = X--no-reexec; then
65
  # Discard the --no-reexec flag, and continue.
66
  shift
67
elif test "X$1" = X--fallback-echo; then
68
  # Avoid inline document here, it may be left over
69
  :
70
elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
71
  # Yippee, $echo works!
72
  :
73
else
74
  # Restart under the correct shell, and then maybe $echo will work.
75
  exec $SHELL "$progpath" --no-reexec ${1+"$@"}
76
fi
77

    
78
if test "X$1" = X--fallback-echo; then
79
  # used as fallback echo
80
  shift
81
  cat <<EOF
82
$*
83
EOF
84
  exit $EXIT_SUCCESS
85
fi
86

    
87
default_mode=
88
help="Try \`$progname --help' for more information."
89
magic="%%%MAGIC variable%%%"
90
mkdir="mkdir"
91
mv="mv -f"
92
rm="rm -f"
93

    
94
# Sed substitution that helps us do robust quoting.  It backslashifies
95
# metacharacters that are still active within double-quoted strings.
96
Xsed="${SED}"' -e 1s/^X//'
97
sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
98
# test EBCDIC or ASCII
99
case `echo X|tr X '\101'` in
100
 A) # ASCII based system
101
    # \n is not interpreted correctly by Solaris 8 /usr/ucb/tr
102
  SP2NL='tr \040 \012'
103
  NL2SP='tr \015\012 \040\040'
104
  ;;
105
 *) # EBCDIC based system
106
  SP2NL='tr \100 \n'
107
  NL2SP='tr \r\n \100\100'
108
  ;;
109
esac
110

    
111
# NLS nuisances.
112
# Only set LANG and LC_ALL to C if already set.
113
# These must not be set unconditionally because not all systems understand
114
# e.g. LANG=C (notably SCO).
115
# We save the old values to restore during execute mode.
116
lt_env=
117
for lt_var in LANG LANGUAGE LC_ALL LC_CTYPE LC_COLLATE LC_MESSAGES
118
do
119
  eval "if test \"\${$lt_var+set}\" = set; then
120
	  save_$lt_var=\$$lt_var
121
	  lt_env=\"$lt_var=\$$lt_var \$lt_env\"
122
	  $lt_var=C
123
	  export $lt_var
124
	fi"
125
done
126

    
127
if test -n "$lt_env"; then
128
  lt_env="env $lt_env"
129
fi
130

    
131
# Make sure IFS has a sensible default
132
lt_nl='
133
'
134
IFS=" 	$lt_nl"
135

    
136
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
137
  $echo "$modename: not configured to build any kind of library" 1>&2
138
  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
139
  exit $EXIT_FAILURE
140
fi
141

    
142
# Global variables.
143
mode=$default_mode
144
nonopt=
145
prev=
146
prevopt=
147
run=
148
show="$echo"
149
show_help=
150
execute_dlfiles=
151
duplicate_deps=no
152
preserve_args=
153
lo2o="s/\\.lo\$/.${objext}/"
154
o2lo="s/\\.${objext}\$/.lo/"
155
extracted_archives=
156
extracted_serial=0
157

    
158
#####################################
159
# Shell function definitions:
160
# This seems to be the best place for them
161

    
162
# func_mktempdir [string]
163
# Make a temporary directory that won't clash with other running
164
# libtool processes, and avoids race conditions if possible.  If
165
# given, STRING is the basename for that directory.
166
func_mktempdir ()
167
{
168
    my_template="${TMPDIR-/tmp}/${1-$progname}"
169

    
170
    if test "$run" = ":"; then
171
      # Return a directory name, but don't create it in dry-run mode
172
      my_tmpdir="${my_template}-$$"
173
    else
174

    
175
      # If mktemp works, use that first and foremost
176
      my_tmpdir=`mktemp -d "${my_template}-XXXXXXXX" 2>/dev/null`
177

    
178
      if test ! -d "$my_tmpdir"; then
179
	# Failing that, at least try and use $RANDOM to avoid a race
180
	my_tmpdir="${my_template}-${RANDOM-0}$$"
181

    
182
	save_mktempdir_umask=`umask`
183
	umask 0077
184
	$mkdir "$my_tmpdir"
185
	umask $save_mktempdir_umask
186
      fi
187

    
188
      # If we're not in dry-run mode, bomb out on failure
189
      test -d "$my_tmpdir" || {
190
        $echo "cannot create temporary directory \`$my_tmpdir'" 1>&2
191
	exit $EXIT_FAILURE
192
      }
193
    fi
194

    
195
    $echo "X$my_tmpdir" | $Xsed
196
}
197

    
198

    
199
# func_win32_libid arg
200
# return the library type of file 'arg'
201
#
202
# Need a lot of goo to handle *both* DLLs and import libs
203
# Has to be a shell function in order to 'eat' the argument
204
# that is supplied when $file_magic_command is called.
205
func_win32_libid ()
206
{
207
  win32_libid_type="unknown"
208
  win32_fileres=`file -L $1 2>/dev/null`
209
  case $win32_fileres in
210
  *ar\ archive\ import\ library*) # definitely import
211
    win32_libid_type="x86 archive import"
212
    ;;
213
  *ar\ archive*) # could be an import, or static
214
    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
215
      $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
216
      win32_nmres=`eval $NM -f posix -A $1 | \
217
	$SED -n -e '1,100{
218
		/ I /{
219
			s,.*,import,
220
			p
221
			q
222
			}
223
		}'`
224
      case $win32_nmres in
225
      import*)  win32_libid_type="x86 archive import";;
226
      *)        win32_libid_type="x86 archive static";;
227
      esac
228
    fi
229
    ;;
230
  *DLL*)
231
    win32_libid_type="x86 DLL"
232
    ;;
233
  *executable*) # but shell scripts are "executable" too...
234
    case $win32_fileres in
235
    *MS\ Windows\ PE\ Intel*)
236
      win32_libid_type="x86 DLL"
237
      ;;
238
    esac
239
    ;;
240
  esac
241
  $echo $win32_libid_type
242
}
243

    
244

    
245
# func_infer_tag arg
246
# Infer tagged configuration to use if any are available and
247
# if one wasn't chosen via the "--tag" command line option.
248
# Only attempt this if the compiler in the base compile
249
# command doesn't match the default compiler.
250
# arg is usually of the form 'gcc ...'
251
func_infer_tag ()
252
{
253
    if test -n "$available_tags" && test -z "$tagname"; then
254
      CC_quoted=
255
      for arg in $CC; do
256
	case $arg in
257
	  *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
258
	  arg="\"$arg\""
259
	  ;;
260
	esac
261
	CC_quoted="$CC_quoted $arg"
262
      done
263
      case $@ in
264
      # Blanks in the command may have been stripped by the calling shell,
265
      # but not from the CC environment variable when configure was run.
266
      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
267
      # Blanks at the start of $base_compile will cause this to fail
268
      # if we don't check for them as well.
269
      *)
270
	for z in $available_tags; do
271
	  if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
272
	    # Evaluate the configuration.
273
	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
274
	    CC_quoted=
275
	    for arg in $CC; do
276
	    # Double-quote args containing other shell metacharacters.
277
	    case $arg in
278
	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
279
	      arg="\"$arg\""
280
	      ;;
281
	    esac
282
	    CC_quoted="$CC_quoted $arg"
283
	  done
284
	    case "$@ " in
285
	      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
286
	      # The compiler in the base compile command matches
287
	      # the one in the tagged configuration.
288
	      # Assume this is the tagged configuration we want.
289
	      tagname=$z
290
	      break
291
	      ;;
292
	    esac
293
	  fi
294
	done
295
	# If $tagname still isn't set, then no tagged configuration
296
	# was found and let the user know that the "--tag" command
297
	# line option must be used.
298
	if test -z "$tagname"; then
299
	  $echo "$modename: unable to infer tagged configuration"
300
	  $echo "$modename: specify a tag with \`--tag'" 1>&2
301
	  exit $EXIT_FAILURE
302
#        else
303
#          $echo "$modename: using $tagname tagged configuration"
304
	fi
305
	;;
306
      esac
307
    fi
308
}
309

    
310

    
311
# func_extract_an_archive dir oldlib
312
func_extract_an_archive ()
313
{
314
    f_ex_an_ar_dir="$1"; shift
315
    f_ex_an_ar_oldlib="$1"
316

    
317
    $show "(cd $f_ex_an_ar_dir && $AR x $f_ex_an_ar_oldlib)"
318
    $run eval "(cd \$f_ex_an_ar_dir && $AR x \$f_ex_an_ar_oldlib)" || exit $?
319
    if ($AR t "$f_ex_an_ar_oldlib" | sort | sort -uc >/dev/null 2>&1); then
320
     :
321
    else
322
      $echo "$modename: ERROR: object name conflicts: $f_ex_an_ar_dir/$f_ex_an_ar_oldlib" 1>&2
323
      exit $EXIT_FAILURE
324
    fi
325
}
326

    
327
# func_extract_archives gentop oldlib ...
328
func_extract_archives ()
329
{
330
    my_gentop="$1"; shift
331
    my_oldlibs=${1+"$@"}
332
    my_oldobjs=""
333
    my_xlib=""
334
    my_xabs=""
335
    my_xdir=""
336
    my_status=""
337

    
338
    $show "${rm}r $my_gentop"
339
    $run ${rm}r "$my_gentop"
340
    $show "$mkdir $my_gentop"
341
    $run $mkdir "$my_gentop"
342
    my_status=$?
343
    if test "$my_status" -ne 0 && test ! -d "$my_gentop"; then
344
      exit $my_status
345
    fi
346

    
347
    for my_xlib in $my_oldlibs; do
348
      # Extract the objects.
349
      case $my_xlib in
350
	[\\/]* | [A-Za-z]:[\\/]*) my_xabs="$my_xlib" ;;
351
	*) my_xabs=`pwd`"/$my_xlib" ;;
352
      esac
353
      my_xlib=`$echo "X$my_xlib" | $Xsed -e 's%^.*/%%'`
354
      my_xlib_u=$my_xlib
355
      while :; do
356
        case " $extracted_archives " in
357
	*" $my_xlib_u "*)
358
	  extracted_serial=`expr $extracted_serial + 1`
359
	  my_xlib_u=lt$extracted_serial-$my_xlib ;;
360
	*) break ;;
361
	esac
362
      done
363
      extracted_archives="$extracted_archives $my_xlib_u"
364
      my_xdir="$my_gentop/$my_xlib_u"
365

    
366
      $show "${rm}r $my_xdir"
367
      $run ${rm}r "$my_xdir"
368
      $show "$mkdir $my_xdir"
369
      $run $mkdir "$my_xdir"
370
      exit_status=$?
371
      if test "$exit_status" -ne 0 && test ! -d "$my_xdir"; then
372
	exit $exit_status
373
      fi
374
      case $host in
375
      *-darwin*)
376
	$show "Extracting $my_xabs"
377
	# Do not bother doing anything if just a dry run
378
	if test -z "$run"; then
379
	  darwin_orig_dir=`pwd`
380
	  cd $my_xdir || exit $?
381
	  darwin_archive=$my_xabs
382
	  darwin_curdir=`pwd`
383
	  darwin_base_archive=`$echo "X$darwin_archive" | $Xsed -e 's%^.*/%%'`
384
	  darwin_arches=`lipo -info "$darwin_archive" 2>/dev/null | $EGREP Architectures 2>/dev/null`
385
	  if test -n "$darwin_arches"; then 
386
	    darwin_arches=`echo "$darwin_arches" | $SED -e 's/.*are://'`
387
	    darwin_arch=
388
	    $show "$darwin_base_archive has multiple architectures $darwin_arches"
389
	    for darwin_arch in  $darwin_arches ; do
390
	      mkdir -p "unfat-$$/${darwin_base_archive}-${darwin_arch}"
391
	      lipo -thin $darwin_arch -output "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}" "${darwin_archive}"
392
	      cd "unfat-$$/${darwin_base_archive}-${darwin_arch}"
393
	      func_extract_an_archive "`pwd`" "${darwin_base_archive}"
394
	      cd "$darwin_curdir"
395
	      $rm "unfat-$$/${darwin_base_archive}-${darwin_arch}/${darwin_base_archive}"
396
	    done # $darwin_arches
397
      ## Okay now we have a bunch of thin objects, gotta fatten them up :)
398
	    darwin_filelist=`find unfat-$$ -type f -name \*.o -print -o -name \*.lo -print| xargs basename | sort -u | $NL2SP`
399
	    darwin_file=
400
	    darwin_files=
401
	    for darwin_file in $darwin_filelist; do
402
	      darwin_files=`find unfat-$$ -name $darwin_file -print | $NL2SP`
403
	      lipo -create -output "$darwin_file" $darwin_files
404
	    done # $darwin_filelist
405
	    ${rm}r unfat-$$
406
	    cd "$darwin_orig_dir"
407
	  else
408
	    cd "$darwin_orig_dir"
409
 	    func_extract_an_archive "$my_xdir" "$my_xabs"
410
	  fi # $darwin_arches
411
	fi # $run
412
	;;
413
      *)
414
        func_extract_an_archive "$my_xdir" "$my_xabs"
415
        ;;
416
      esac
417
      my_oldobjs="$my_oldobjs "`find $my_xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
418
    done
419
    func_extract_archives_result="$my_oldobjs"
420
}
421
# End of Shell function definitions
422
#####################################
423

    
424
# Darwin sucks
425
eval std_shrext=\"$shrext_cmds\"
426

    
427
disable_libs=no
428

    
429
# Parse our command line options once, thoroughly.
430
while test "$#" -gt 0
431
do
432
  arg="$1"
433
  shift
434

    
435
  case $arg in
436
  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
437
  *) optarg= ;;
438
  esac
439

    
440
  # If the previous option needs an argument, assign it.
441
  if test -n "$prev"; then
442
    case $prev in
443
    execute_dlfiles)
444
      execute_dlfiles="$execute_dlfiles $arg"
445
      ;;
446
    tag)
447
      tagname="$arg"
448
      preserve_args="${preserve_args}=$arg"
449

    
450
      # Check whether tagname contains only valid characters
451
      case $tagname in
452
      *[!-_A-Za-z0-9,/]*)
453
	$echo "$progname: invalid tag name: $tagname" 1>&2
454
	exit $EXIT_FAILURE
455
	;;
456
      esac
457

    
458
      case $tagname in
459
      CC)
460
	# Don't test for the "default" C tag, as we know, it's there, but
461
	# not specially marked.
462
	;;
463
      *)
464
	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
465
	  taglist="$taglist $tagname"
466
	  # Evaluate the configuration.
467
	  eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
468
	else
469
	  $echo "$progname: ignoring unknown tag $tagname" 1>&2
470
	fi
471
	;;
472
      esac
473
      ;;
474
    *)
475
      eval "$prev=\$arg"
476
      ;;
477
    esac
478

    
479
    prev=
480
    prevopt=
481
    continue
482
  fi
483

    
484
  # Have we seen a non-optional argument yet?
485
  case $arg in
486
  --help)
487
    show_help=yes
488
    ;;
489

    
490
  --version)
491
    echo "\
492
$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP
493

    
494
Copyright (C) 2008  Free Software Foundation, Inc.
495
This is free software; see the source for copying conditions.  There is NO
496
warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
497
    exit $?
498
    ;;
499

    
500
  --config)
501
    ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
502
    # Now print the configurations for the tags.
503
    for tagname in $taglist; do
504
      ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
505
    done
506
    exit $?
507
    ;;
508

    
509
  --debug)
510
    $echo "$progname: enabling shell trace mode"
511
    set -x
512
    preserve_args="$preserve_args $arg"
513
    ;;
514

    
515
  --dry-run | -n)
516
    run=:
517
    ;;
518

    
519
  --features)
520
    $echo "host: $host"
521
    if test "$build_libtool_libs" = yes; then
522
      $echo "enable shared libraries"
523
    else
524
      $echo "disable shared libraries"
525
    fi
526
    if test "$build_old_libs" = yes; then
527
      $echo "enable static libraries"
528
    else
529
      $echo "disable static libraries"
530
    fi
531
    exit $?
532
    ;;
533

    
534
  --finish) mode="finish" ;;
535

    
536
  --mode) prevopt="--mode" prev=mode ;;
537
  --mode=*) mode="$optarg" ;;
538

    
539
  --preserve-dup-deps) duplicate_deps="yes" ;;
540

    
541
  --quiet | --silent)
542
    show=:
543
    preserve_args="$preserve_args $arg"
544
    ;;
545

    
546
  --tag)
547
    prevopt="--tag"
548
    prev=tag
549
    preserve_args="$preserve_args --tag"
550
    ;;
551
  --tag=*)
552
    set tag "$optarg" ${1+"$@"}
553
    shift
554
    prev=tag
555
    preserve_args="$preserve_args --tag"
556
    ;;
557

    
558
  -dlopen)
559
    prevopt="-dlopen"
560
    prev=execute_dlfiles
561
    ;;
562

    
563
  -*)
564
    $echo "$modename: unrecognized option \`$arg'" 1>&2
565
    $echo "$help" 1>&2
566
    exit $EXIT_FAILURE
567
    ;;
568

    
569
  *)
570
    nonopt="$arg"
571
    break
572
    ;;
573
  esac
574
done
575

    
576
if test -n "$prevopt"; then
577
  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
578
  $echo "$help" 1>&2
579
  exit $EXIT_FAILURE
580
fi
581

    
582
case $disable_libs in
583
no) 
584
  ;;
585
shared)
586
  build_libtool_libs=no
587
  build_old_libs=yes
588
  ;;
589
static)
590
  build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
591
  ;;
592
esac
593

    
594
# If this variable is set in any of the actions, the command in it
595
# will be execed at the end.  This prevents here-documents from being
596
# left over by shells.
597
exec_cmd=
598

    
599
if test -z "$show_help"; then
600

    
601
  # Infer the operation mode.
602
  if test -z "$mode"; then
603
    $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
604
    $echo "*** Future versions of Libtool will require --mode=MODE be specified." 1>&2
605
    case $nonopt in
606
    *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
607
      mode=link
608
      for arg
609
      do
610
	case $arg in
611
	-c)
612
	   mode=compile
613
	   break
614
	   ;;
615
	esac
616
      done
617
      ;;
618
    *db | *dbx | *strace | *truss)
619
      mode=execute
620
      ;;
621
    *install*|cp|mv)
622
      mode=install
623
      ;;
624
    *rm)
625
      mode=uninstall
626
      ;;
627
    *)
628
      # If we have no mode, but dlfiles were specified, then do execute mode.
629
      test -n "$execute_dlfiles" && mode=execute
630

    
631
      # Just use the default operation mode.
632
      if test -z "$mode"; then
633
	if test -n "$nonopt"; then
634
	  $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
635
	else
636
	  $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
637
	fi
638
      fi
639
      ;;
640
    esac
641
  fi
642

    
643
  # Only execute mode is allowed to have -dlopen flags.
644
  if test -n "$execute_dlfiles" && test "$mode" != execute; then
645
    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
646
    $echo "$help" 1>&2
647
    exit $EXIT_FAILURE
648
  fi
649

    
650
  # Change the help message to a mode-specific one.
651
  generic_help="$help"
652
  help="Try \`$modename --help --mode=$mode' for more information."
653

    
654
  # These modes are in order of execution frequency so that they run quickly.
655
  case $mode in
656
  # libtool compile mode
657
  compile)
658
    modename="$modename: compile"
659
    # Get the compilation command and the source file.
660
    base_compile=
661
    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
662
    suppress_opt=yes
663
    suppress_output=
664
    arg_mode=normal
665
    libobj=
666
    later=
667

    
668
    for arg
669
    do
670
      case $arg_mode in
671
      arg  )
672
	# do not "continue".  Instead, add this to base_compile
673
	lastarg="$arg"
674
	arg_mode=normal
675
	;;
676

    
677
      target )
678
	libobj="$arg"
679
	arg_mode=normal
680
	continue
681
	;;
682

    
683
      normal )
684
	# Accept any command-line options.
685
	case $arg in
686
	-o)
687
	  if test -n "$libobj" ; then
688
	    $echo "$modename: you cannot specify \`-o' more than once" 1>&2
689
	    exit $EXIT_FAILURE
690
	  fi
691
	  arg_mode=target
692
	  continue
693
	  ;;
694

    
695
	-static | -prefer-pic | -prefer-non-pic)
696
	  later="$later $arg"
697
	  continue
698
	  ;;
699

    
700
	-no-suppress)
701
	  suppress_opt=no
702
	  continue
703
	  ;;
704

    
705
	-Xcompiler)
706
	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
707
	  continue      #  The current "srcfile" will either be retained or
708
	  ;;            #  replaced later.  I would guess that would be a bug.
709

    
710
	-Wc,*)
711
	  args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
712
	  lastarg=
713
	  save_ifs="$IFS"; IFS=','
714
 	  for arg in $args; do
715
	    IFS="$save_ifs"
716

    
717
	    # Double-quote args containing other shell metacharacters.
718
	    # Many Bourne shells cannot handle close brackets correctly
719
	    # in scan sets, so we specify it separately.
720
	    case $arg in
721
	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
722
	      arg="\"$arg\""
723
	      ;;
724
	    esac
725
	    lastarg="$lastarg $arg"
726
	  done
727
	  IFS="$save_ifs"
728
	  lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
729

    
730
	  # Add the arguments to base_compile.
731
	  base_compile="$base_compile $lastarg"
732
	  continue
733
	  ;;
734

    
735
	* )
736
	  # Accept the current argument as the source file.
737
	  # The previous "srcfile" becomes the current argument.
738
	  #
739
	  lastarg="$srcfile"
740
	  srcfile="$arg"
741
	  ;;
742
	esac  #  case $arg
743
	;;
744
      esac    #  case $arg_mode
745

    
746
      # Aesthetically quote the previous argument.
747
      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
748

    
749
      case $lastarg in
750
      # Double-quote args containing other shell metacharacters.
751
      # Many Bourne shells cannot handle close brackets correctly
752
      # in scan sets, and some SunOS ksh mistreat backslash-escaping
753
      # in scan sets (worked around with variable expansion),
754
      # and furthermore cannot handle '|' '&' '(' ')' in scan sets 
755
      # at all, so we specify them separately.
756
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
757
	lastarg="\"$lastarg\""
758
	;;
759
      esac
760

    
761
      base_compile="$base_compile $lastarg"
762
    done # for arg
763

    
764
    case $arg_mode in
765
    arg)
766
      $echo "$modename: you must specify an argument for -Xcompile"
767
      exit $EXIT_FAILURE
768
      ;;
769
    target)
770
      $echo "$modename: you must specify a target with \`-o'" 1>&2
771
      exit $EXIT_FAILURE
772
      ;;
773
    *)
774
      # Get the name of the library object.
775
      [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
776
      ;;
777
    esac
778

    
779
    # Recognize several different file suffixes.
780
    # If the user specifies -o file.o, it is replaced with file.lo
781
    xform='[cCFSifmso]'
782
    case $libobj in
783
    *.ada) xform=ada ;;
784
    *.adb) xform=adb ;;
785
    *.ads) xform=ads ;;
786
    *.asm) xform=asm ;;
787
    *.c++) xform=c++ ;;
788
    *.cc) xform=cc ;;
789
    *.ii) xform=ii ;;
790
    *.class) xform=class ;;
791
    *.cpp) xform=cpp ;;
792
    *.cxx) xform=cxx ;;
793
    *.[fF][09]?) xform=[fF][09]. ;;
794
    *.for) xform=for ;;
795
    *.java) xform=java ;;
796
    *.obj) xform=obj ;;
797
    *.sx) xform=sx ;;
798
    esac
799

    
800
    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
801

    
802
    case $libobj in
803
    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
804
    *)
805
      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
806
      exit $EXIT_FAILURE
807
      ;;
808
    esac
809

    
810
    func_infer_tag $base_compile
811

    
812
    for arg in $later; do
813
      case $arg in
814
      -static)
815
	build_old_libs=yes
816
	continue
817
	;;
818

    
819
      -prefer-pic)
820
	pic_mode=yes
821
	continue
822
	;;
823

    
824
      -prefer-non-pic)
825
	pic_mode=no
826
	continue
827
	;;
828
      esac
829
    done
830

    
831
    qlibobj=`$echo "X$libobj" | $Xsed -e "$sed_quote_subst"`
832
    case $qlibobj in
833
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
834
	qlibobj="\"$qlibobj\"" ;;
835
    esac
836
    test "X$libobj" != "X$qlibobj" \
837
	&& $echo "X$libobj" | grep '[]~#^*{};<>?"'"'"' 	&()|`$[]' \
838
	&& $echo "$modename: libobj name \`$libobj' may not contain shell special characters."
839
    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
840
    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
841
    if test "X$xdir" = "X$obj"; then
842
      xdir=
843
    else
844
      xdir=$xdir/
845
    fi
846
    lobj=${xdir}$objdir/$objname
847

    
848
    if test -z "$base_compile"; then
849
      $echo "$modename: you must specify a compilation command" 1>&2
850
      $echo "$help" 1>&2
851
      exit $EXIT_FAILURE
852
    fi
853

    
854
    # Delete any leftover library objects.
855
    if test "$build_old_libs" = yes; then
856
      removelist="$obj $lobj $libobj ${libobj}T"
857
    else
858
      removelist="$lobj $libobj ${libobj}T"
859
    fi
860

    
861
    $run $rm $removelist
862
    trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
863

    
864
    # On Cygwin there's no "real" PIC flag so we must build both object types
865
    case $host_os in
866
    cygwin* | mingw* | pw32* | os2*)
867
      pic_mode=default
868
      ;;
869
    esac
870
    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
871
      # non-PIC code in shared libraries is not supported
872
      pic_mode=default
873
    fi
874

    
875
    # Calculate the filename of the output object if compiler does
876
    # not support -o with -c
877
    if test "$compiler_c_o" = no; then
878
      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
879
      lockfile="$output_obj.lock"
880
      removelist="$removelist $output_obj $lockfile"
881
      trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
882
    else
883
      output_obj=
884
      need_locks=no
885
      lockfile=
886
    fi
887

    
888
    # Lock this critical section if it is needed
889
    # We use this script file to make the link, it avoids creating a new file
890
    if test "$need_locks" = yes; then
891
      until $run ln "$progpath" "$lockfile" 2>/dev/null; do
892
	$show "Waiting for $lockfile to be removed"
893
	sleep 2
894
      done
895
    elif test "$need_locks" = warn; then
896
      if test -f "$lockfile"; then
897
	$echo "\
898
*** ERROR, $lockfile exists and contains:
899
`cat $lockfile 2>/dev/null`
900

    
901
This indicates that another process is trying to use the same
902
temporary object file, and libtool could not work around it because
903
your compiler does not support \`-c' and \`-o' together.  If you
904
repeat this compilation, it may succeed, by chance, but you had better
905
avoid parallel builds (make -j) in this platform, or get a better
906
compiler."
907

    
908
	$run $rm $removelist
909
	exit $EXIT_FAILURE
910
      fi
911
      $echo "$srcfile" > "$lockfile"
912
    fi
913

    
914
    if test -n "$fix_srcfile_path"; then
915
      eval srcfile=\"$fix_srcfile_path\"
916
    fi
917
    qsrcfile=`$echo "X$srcfile" | $Xsed -e "$sed_quote_subst"`
918
    case $qsrcfile in
919
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
920
      qsrcfile="\"$qsrcfile\"" ;;
921
    esac
922

    
923
    $run $rm "$libobj" "${libobj}T"
924

    
925
    # Create a libtool object file (analogous to a ".la" file),
926
    # but don't create it if we're doing a dry run.
927
    test -z "$run" && cat > ${libobj}T <<EOF
928
# $libobj - a libtool object file
929
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
930
#
931
# Please DO NOT delete this file!
932
# It is necessary for linking the library.
933

    
934
# Name of the PIC object.
935
EOF
936

    
937
    # Only build a PIC object if we are building libtool libraries.
938
    if test "$build_libtool_libs" = yes; then
939
      # Without this assignment, base_compile gets emptied.
940
      fbsd_hideous_sh_bug=$base_compile
941

    
942
      if test "$pic_mode" != no; then
943
	command="$base_compile $qsrcfile $pic_flag"
944
      else
945
	# Don't build PIC code
946
	command="$base_compile $qsrcfile"
947
      fi
948

    
949
      if test ! -d "${xdir}$objdir"; then
950
	$show "$mkdir ${xdir}$objdir"
951
	$run $mkdir ${xdir}$objdir
952
	exit_status=$?
953
	if test "$exit_status" -ne 0 && test ! -d "${xdir}$objdir"; then
954
	  exit $exit_status
955
	fi
956
      fi
957

    
958
      if test -z "$output_obj"; then
959
	# Place PIC objects in $objdir
960
	command="$command -o $lobj"
961
      fi
962

    
963
      $run $rm "$lobj" "$output_obj"
964

    
965
      $show "$command"
966
      if $run eval $lt_env "$command"; then :
967
      else
968
	test -n "$output_obj" && $run $rm $removelist
969
	exit $EXIT_FAILURE
970
      fi
971

    
972
      if test "$need_locks" = warn &&
973
	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
974
	$echo "\
975
*** ERROR, $lockfile contains:
976
`cat $lockfile 2>/dev/null`
977

    
978
but it should contain:
979
$srcfile
980

    
981
This indicates that another process is trying to use the same
982
temporary object file, and libtool could not work around it because
983
your compiler does not support \`-c' and \`-o' together.  If you
984
repeat this compilation, it may succeed, by chance, but you had better
985
avoid parallel builds (make -j) in this platform, or get a better
986
compiler."
987

    
988
	$run $rm $removelist
989
	exit $EXIT_FAILURE
990
      fi
991

    
992
      # Just move the object if needed, then go on to compile the next one
993
      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
994
	$show "$mv $output_obj $lobj"
995
	if $run $mv $output_obj $lobj; then :
996
	else
997
	  error=$?
998
	  $run $rm $removelist
999
	  exit $error
1000
	fi
1001
      fi
1002

    
1003
      # Append the name of the PIC object to the libtool object file.
1004
      test -z "$run" && cat >> ${libobj}T <<EOF
1005
pic_object='$objdir/$objname'
1006

    
1007
EOF
1008

    
1009
      # Allow error messages only from the first compilation.
1010
      if test "$suppress_opt" = yes; then
1011
        suppress_output=' >/dev/null 2>&1'
1012
      fi
1013
    else
1014
      # No PIC object so indicate it doesn't exist in the libtool
1015
      # object file.
1016
      test -z "$run" && cat >> ${libobj}T <<EOF
1017
pic_object=none
1018

    
1019
EOF
1020
    fi
1021

    
1022
    # Only build a position-dependent object if we build old libraries.
1023
    if test "$build_old_libs" = yes; then
1024
      if test "$pic_mode" != yes; then
1025
	# Don't build PIC code
1026
	command="$base_compile $qsrcfile"
1027
      else
1028
	command="$base_compile $qsrcfile $pic_flag"
1029
      fi
1030
      if test "$compiler_c_o" = yes; then
1031
	command="$command -o $obj"
1032
      fi
1033

    
1034
      # Suppress compiler output if we already did a PIC compilation.
1035
      command="$command$suppress_output"
1036
      $run $rm "$obj" "$output_obj"
1037
      $show "$command"
1038
      if $run eval $lt_env "$command"; then :
1039
      else
1040
	$run $rm $removelist
1041
	exit $EXIT_FAILURE
1042
      fi
1043

    
1044
      if test "$need_locks" = warn &&
1045
	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
1046
	$echo "\
1047
*** ERROR, $lockfile contains:
1048
`cat $lockfile 2>/dev/null`
1049

    
1050
but it should contain:
1051
$srcfile
1052

    
1053
This indicates that another process is trying to use the same
1054
temporary object file, and libtool could not work around it because
1055
your compiler does not support \`-c' and \`-o' together.  If you
1056
repeat this compilation, it may succeed, by chance, but you had better
1057
avoid parallel builds (make -j) in this platform, or get a better
1058
compiler."
1059

    
1060
	$run $rm $removelist
1061
	exit $EXIT_FAILURE
1062
      fi
1063

    
1064
      # Just move the object if needed
1065
      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
1066
	$show "$mv $output_obj $obj"
1067
	if $run $mv $output_obj $obj; then :
1068
	else
1069
	  error=$?
1070
	  $run $rm $removelist
1071
	  exit $error
1072
	fi
1073
      fi
1074

    
1075
      # Append the name of the non-PIC object the libtool object file.
1076
      # Only append if the libtool object file exists.
1077
      test -z "$run" && cat >> ${libobj}T <<EOF
1078
# Name of the non-PIC object.
1079
non_pic_object='$objname'
1080

    
1081
EOF
1082
    else
1083
      # Append the name of the non-PIC object the libtool object file.
1084
      # Only append if the libtool object file exists.
1085
      test -z "$run" && cat >> ${libobj}T <<EOF
1086
# Name of the non-PIC object.
1087
non_pic_object=none
1088

    
1089
EOF
1090
    fi
1091

    
1092
    $run $mv "${libobj}T" "${libobj}"
1093

    
1094
    # Unlock the critical section if it was locked
1095
    if test "$need_locks" != no; then
1096
      $run $rm "$lockfile"
1097
    fi
1098

    
1099
    exit $EXIT_SUCCESS
1100
    ;;
1101

    
1102
  # libtool link mode
1103
  link | relink)
1104
    modename="$modename: link"
1105
    case $host in
1106
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1107
      # It is impossible to link a dll without this setting, and
1108
      # we shouldn't force the makefile maintainer to figure out
1109
      # which system we are compiling for in order to pass an extra
1110
      # flag for every libtool invocation.
1111
      # allow_undefined=no
1112

    
1113
      # FIXME: Unfortunately, there are problems with the above when trying
1114
      # to make a dll which has undefined symbols, in which case not
1115
      # even a static library is built.  For now, we need to specify
1116
      # -no-undefined on the libtool link line when we can be certain
1117
      # that all symbols are satisfied, otherwise we get a static library.
1118
      allow_undefined=yes
1119
      ;;
1120
    *)
1121
      allow_undefined=yes
1122
      ;;
1123
    esac
1124
    libtool_args="$nonopt"
1125
    base_compile="$nonopt $@"
1126
    compile_command="$nonopt"
1127
    finalize_command="$nonopt"
1128

    
1129
    compile_rpath=
1130
    finalize_rpath=
1131
    compile_shlibpath=
1132
    finalize_shlibpath=
1133
    convenience=
1134
    old_convenience=
1135
    deplibs=
1136
    old_deplibs=
1137
    compiler_flags=
1138
    linker_flags=
1139
    dllsearchpath=
1140
    lib_search_path=`pwd`
1141
    inst_prefix_dir=
1142

    
1143
    avoid_version=no
1144
    dlfiles=
1145
    dlprefiles=
1146
    dlself=no
1147
    export_dynamic=no
1148
    export_symbols=
1149
    export_symbols_regex=
1150
    generated=
1151
    libobjs=
1152
    ltlibs=
1153
    module=no
1154
    no_install=no
1155
    objs=
1156
    non_pic_objects=
1157
    notinst_path= # paths that contain not-installed libtool libraries
1158
    precious_files_regex=
1159
    prefer_static_libs=no
1160
    preload=no
1161
    prev=
1162
    prevarg=
1163
    release=
1164
    rpath=
1165
    xrpath=
1166
    perm_rpath=
1167
    temp_rpath=
1168
    thread_safe=no
1169
    vinfo=
1170
    vinfo_number=no
1171
    single_module="${wl}-single_module"
1172

    
1173
    func_infer_tag $base_compile
1174

    
1175
    # We need to know -static, to get the right output filenames.
1176
    for arg
1177
    do
1178
      case $arg in
1179
      -all-static | -static | -static-libtool-libs)
1180
	case $arg in
1181
	-all-static)
1182
	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
1183
	    $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
1184
	  fi
1185
	  if test -n "$link_static_flag"; then
1186
	    dlopen_self=$dlopen_self_static
1187
	  fi
1188
	  prefer_static_libs=yes
1189
	  ;;
1190
	-static)
1191
	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
1192
	    dlopen_self=$dlopen_self_static
1193
	  fi
1194
	  prefer_static_libs=built
1195
	  ;;
1196
	-static-libtool-libs)
1197
	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
1198
	    dlopen_self=$dlopen_self_static
1199
	  fi
1200
	  prefer_static_libs=yes
1201
	  ;;
1202
	esac
1203
	build_libtool_libs=no
1204
	build_old_libs=yes
1205
	break
1206
	;;
1207
      esac
1208
    done
1209

    
1210
    # See if our shared archives depend on static archives.
1211
    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
1212

    
1213
    # Go through the arguments, transforming them on the way.
1214
    while test "$#" -gt 0; do
1215
      arg="$1"
1216
      shift
1217
      case $arg in
1218
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
1219
	qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
1220
	;;
1221
      *) qarg=$arg ;;
1222
      esac
1223
      libtool_args="$libtool_args $qarg"
1224

    
1225
      # If the previous option needs an argument, assign it.
1226
      if test -n "$prev"; then
1227
	case $prev in
1228
	output)
1229
	  compile_command="$compile_command @OUTPUT@"
1230
	  finalize_command="$finalize_command @OUTPUT@"
1231
	  ;;
1232
	esac
1233

    
1234
	case $prev in
1235
	dlfiles|dlprefiles)
1236
	  if test "$preload" = no; then
1237
	    # Add the symbol object into the linking commands.
1238
	    compile_command="$compile_command @SYMFILE@"
1239
	    finalize_command="$finalize_command @SYMFILE@"
1240
	    preload=yes
1241
	  fi
1242
	  case $arg in
1243
	  *.la | *.lo) ;;  # We handle these cases below.
1244
	  force)
1245
	    if test "$dlself" = no; then
1246
	      dlself=needless
1247
	      export_dynamic=yes
1248
	    fi
1249
	    prev=
1250
	    continue
1251
	    ;;
1252
	  self)
1253
	    if test "$prev" = dlprefiles; then
1254
	      dlself=yes
1255
	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
1256
	      dlself=yes
1257
	    else
1258
	      dlself=needless
1259
	      export_dynamic=yes
1260
	    fi
1261
	    prev=
1262
	    continue
1263
	    ;;
1264
	  *)
1265
	    if test "$prev" = dlfiles; then
1266
	      dlfiles="$dlfiles $arg"
1267
	    else
1268
	      dlprefiles="$dlprefiles $arg"
1269
	    fi
1270
	    prev=
1271
	    continue
1272
	    ;;
1273
	  esac
1274
	  ;;
1275
	expsyms)
1276
	  export_symbols="$arg"
1277
	  if test ! -f "$arg"; then
1278
	    $echo "$modename: symbol file \`$arg' does not exist"
1279
	    exit $EXIT_FAILURE
1280
	  fi
1281
	  prev=
1282
	  continue
1283
	  ;;
1284
	expsyms_regex)
1285
	  export_symbols_regex="$arg"
1286
	  prev=
1287
	  continue
1288
	  ;;
1289
	inst_prefix)
1290
	  inst_prefix_dir="$arg"
1291
	  prev=
1292
	  continue
1293
	  ;;
1294
	precious_regex)
1295
	  precious_files_regex="$arg"
1296
	  prev=
1297
	  continue
1298
	  ;;
1299
	release)
1300
	  release="-$arg"
1301
	  prev=
1302
	  continue
1303
	  ;;
1304
	objectlist)
1305
	  if test -f "$arg"; then
1306
	    save_arg=$arg
1307
	    moreargs=
1308
	    for fil in `cat $save_arg`
1309
	    do
1310
#	      moreargs="$moreargs $fil"
1311
	      arg=$fil
1312
	      # A libtool-controlled object.
1313

    
1314
	      # Check to see that this really is a libtool object.
1315
	      if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1316
		pic_object=
1317
		non_pic_object=
1318

    
1319
		# Read the .lo file
1320
		# If there is no directory component, then add one.
1321
		case $arg in
1322
		*/* | *\\*) . $arg ;;
1323
		*) . ./$arg ;;
1324
		esac
1325

    
1326
		if test -z "$pic_object" || \
1327
		   test -z "$non_pic_object" ||
1328
		   test "$pic_object" = none && \
1329
		   test "$non_pic_object" = none; then
1330
		  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1331
		  exit $EXIT_FAILURE
1332
		fi
1333

    
1334
		# Extract subdirectory from the argument.
1335
		xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1336
		if test "X$xdir" = "X$arg"; then
1337
		  xdir=
1338
		else
1339
		  xdir="$xdir/"
1340
		fi
1341

    
1342
		if test "$pic_object" != none; then
1343
		  # Prepend the subdirectory the object is found in.
1344
		  pic_object="$xdir$pic_object"
1345

    
1346
		  if test "$prev" = dlfiles; then
1347
		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1348
		      dlfiles="$dlfiles $pic_object"
1349
		      prev=
1350
		      continue
1351
		    else
1352
		      # If libtool objects are unsupported, then we need to preload.
1353
		      prev=dlprefiles
1354
		    fi
1355
		  fi
1356

    
1357
		  # CHECK ME:  I think I busted this.  -Ossama
1358
		  if test "$prev" = dlprefiles; then
1359
		    # Preload the old-style object.
1360
		    dlprefiles="$dlprefiles $pic_object"
1361
		    prev=
1362
		  fi
1363

    
1364
		  # A PIC object.
1365
		  libobjs="$libobjs $pic_object"
1366
		  arg="$pic_object"
1367
		fi
1368

    
1369
		# Non-PIC object.
1370
		if test "$non_pic_object" != none; then
1371
		  # Prepend the subdirectory the object is found in.
1372
		  non_pic_object="$xdir$non_pic_object"
1373

    
1374
		  # A standard non-PIC object
1375
		  non_pic_objects="$non_pic_objects $non_pic_object"
1376
		  if test -z "$pic_object" || test "$pic_object" = none ; then
1377
		    arg="$non_pic_object"
1378
		  fi
1379
		else
1380
		  # If the PIC object exists, use it instead.
1381
		  # $xdir was prepended to $pic_object above.
1382
		  non_pic_object="$pic_object"
1383
		  non_pic_objects="$non_pic_objects $non_pic_object"
1384
		fi
1385
	      else
1386
		# Only an error if not doing a dry-run.
1387
		if test -z "$run"; then
1388
		  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1389
		  exit $EXIT_FAILURE
1390
		else
1391
		  # Dry-run case.
1392

    
1393
		  # Extract subdirectory from the argument.
1394
		  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1395
		  if test "X$xdir" = "X$arg"; then
1396
		    xdir=
1397
		  else
1398
		    xdir="$xdir/"
1399
		  fi
1400

    
1401
		  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1402
		  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1403
		  libobjs="$libobjs $pic_object"
1404
		  non_pic_objects="$non_pic_objects $non_pic_object"
1405
		fi
1406
	      fi
1407
	    done
1408
	  else
1409
	    $echo "$modename: link input file \`$save_arg' does not exist"
1410
	    exit $EXIT_FAILURE
1411
	  fi
1412
	  arg=$save_arg
1413
	  prev=
1414
	  continue
1415
	  ;;
1416
	rpath | xrpath)
1417
	  # We need an absolute path.
1418
	  case $arg in
1419
	  [\\/]* | [A-Za-z]:[\\/]*) ;;
1420
	  *)
1421
	    $echo "$modename: only absolute run-paths are allowed" 1>&2
1422
	    exit $EXIT_FAILURE
1423
	    ;;
1424
	  esac
1425
	  if test "$prev" = rpath; then
1426
	    case "$rpath " in
1427
	    *" $arg "*) ;;
1428
	    *) rpath="$rpath $arg" ;;
1429
	    esac
1430
	  else
1431
	    case "$xrpath " in
1432
	    *" $arg "*) ;;
1433
	    *) xrpath="$xrpath $arg" ;;
1434
	    esac
1435
	  fi
1436
	  prev=
1437
	  continue
1438
	  ;;
1439
	xcompiler)
1440
	  compiler_flags="$compiler_flags $qarg"
1441
	  prev=
1442
	  compile_command="$compile_command $qarg"
1443
	  finalize_command="$finalize_command $qarg"
1444
	  continue
1445
	  ;;
1446
	xlinker)
1447
	  linker_flags="$linker_flags $qarg"
1448
	  compiler_flags="$compiler_flags $wl$qarg"
1449
	  prev=
1450
	  compile_command="$compile_command $wl$qarg"
1451
	  finalize_command="$finalize_command $wl$qarg"
1452
	  continue
1453
	  ;;
1454
	xcclinker)
1455
	  linker_flags="$linker_flags $qarg"
1456
	  compiler_flags="$compiler_flags $qarg"
1457
	  prev=
1458
	  compile_command="$compile_command $qarg"
1459
	  finalize_command="$finalize_command $qarg"
1460
	  continue
1461
	  ;;
1462
	shrext)
1463
  	  shrext_cmds="$arg"
1464
	  prev=
1465
	  continue
1466
	  ;;
1467
	darwin_framework|darwin_framework_skip)
1468
	  test "$prev" = "darwin_framework" && compiler_flags="$compiler_flags $arg"
1469
	  compile_command="$compile_command $arg"
1470
	  finalize_command="$finalize_command $arg"
1471
	  prev=
1472
	  continue
1473
	  ;;
1474
	*)
1475
	  eval "$prev=\"\$arg\""
1476
	  prev=
1477
	  continue
1478
	  ;;
1479
	esac
1480
      fi # test -n "$prev"
1481

    
1482
      prevarg="$arg"
1483

    
1484
      case $arg in
1485
      -all-static)
1486
	if test -n "$link_static_flag"; then
1487
	  compile_command="$compile_command $link_static_flag"
1488
	  finalize_command="$finalize_command $link_static_flag"
1489
	fi
1490
	continue
1491
	;;
1492

    
1493
      -allow-undefined)
1494
	# FIXME: remove this flag sometime in the future.
1495
	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1496
	continue
1497
	;;
1498

    
1499
      -avoid-version)
1500
	avoid_version=yes
1501
	continue
1502
	;;
1503

    
1504
      -dlopen)
1505
	prev=dlfiles
1506
	continue
1507
	;;
1508

    
1509
      -dlpreopen)
1510
	prev=dlprefiles
1511
	continue
1512
	;;
1513

    
1514
      -export-dynamic)
1515
	export_dynamic=yes
1516
	continue
1517
	;;
1518

    
1519
      -export-symbols | -export-symbols-regex)
1520
	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1521
	  $echo "$modename: more than one -exported-symbols argument is not allowed"
1522
	  exit $EXIT_FAILURE
1523
	fi
1524
	if test "X$arg" = "X-export-symbols"; then
1525
	  prev=expsyms
1526
	else
1527
	  prev=expsyms_regex
1528
	fi
1529
	continue
1530
	;;
1531

    
1532
      -framework|-arch|-isysroot)
1533
	case " $CC " in
1534
	  *" ${arg} ${1} "* | *" ${arg}	${1} "*) 
1535
		prev=darwin_framework_skip ;;
1536
	  *) compiler_flags="$compiler_flags $arg"
1537
	     prev=darwin_framework ;;
1538
	esac
1539
	compile_command="$compile_command $arg"
1540
	finalize_command="$finalize_command $arg"
1541
	continue
1542
	;;
1543

    
1544
      -inst-prefix-dir)
1545
	prev=inst_prefix
1546
	continue
1547
	;;
1548

    
1549
      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1550
      # so, if we see these flags be careful not to treat them like -L
1551
      -L[A-Z][A-Z]*:*)
1552
	case $with_gcc/$host in
1553
	no/*-*-irix* | /*-*-irix*)
1554
	  compile_command="$compile_command $arg"
1555
	  finalize_command="$finalize_command $arg"
1556
	  ;;
1557
	esac
1558
	continue
1559
	;;
1560

    
1561
      -L*)
1562
	dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1563
	# We need an absolute path.
1564
	case $dir in
1565
	[\\/]* | [A-Za-z]:[\\/]*) ;;
1566
	*)
1567
	  absdir=`cd "$dir" && pwd`
1568
	  if test -z "$absdir"; then
1569
	    $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1570
	    absdir="$dir"
1571
	    notinst_path="$notinst_path $dir"
1572
	  fi
1573
	  dir="$absdir"
1574
	  ;;
1575
	esac
1576
	case "$deplibs " in
1577
	*" -L$dir "*) ;;
1578
	*)
1579
	  deplibs="$deplibs -L$dir"
1580
	  lib_search_path="$lib_search_path $dir"
1581
	  ;;
1582
	esac
1583
	case $host in
1584
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1585
	  testbindir=`$echo "X$dir" | $Xsed -e 's*/lib$*/bin*'`
1586
	  case :$dllsearchpath: in
1587
	  *":$dir:"*) ;;
1588
	  *) dllsearchpath="$dllsearchpath:$dir";;
1589
	  esac
1590
	  case :$dllsearchpath: in
1591
	  *":$testbindir:"*) ;;
1592
	  *) dllsearchpath="$dllsearchpath:$testbindir";;
1593
	  esac
1594
	  ;;
1595
	esac
1596
	continue
1597
	;;
1598

    
1599
      -l*)
1600
	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1601
	  case $host in
1602
	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-beos*)
1603
	    # These systems don't actually have a C or math library (as such)
1604
	    continue
1605
	    ;;
1606
	  *-*-os2*)
1607
	    # These systems don't actually have a C library (as such)
1608
	    test "X$arg" = "X-lc" && continue
1609
	    ;;
1610
	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
1611
	    # Do not include libc due to us having libc/libc_r.
1612
	    test "X$arg" = "X-lc" && continue
1613
	    ;;
1614
	  *-*-rhapsody* | *-*-darwin1.[012])
1615
	    # Rhapsody C and math libraries are in the System framework
1616
	    deplibs="$deplibs -framework System"
1617
	    continue
1618
	    ;;
1619
	  *-*-sco3.2v5* | *-*-sco5v6*)
1620
	    # Causes problems with __ctype
1621
	    test "X$arg" = "X-lc" && continue
1622
	    ;;
1623
	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
1624
	    # Compiler inserts libc in the correct place for threads to work
1625
	    test "X$arg" = "X-lc" && continue
1626
	    ;;
1627
	  esac
1628
	elif test "X$arg" = "X-lc_r"; then
1629
	 case $host in
1630
	 *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
1631
	   # Do not include libc_r directly, use -pthread flag.
1632
	   continue
1633
	   ;;
1634
	 esac
1635
	fi
1636
	deplibs="$deplibs $arg"
1637
	continue
1638
	;;
1639

    
1640
      # Tru64 UNIX uses -model [arg] to determine the layout of C++
1641
      # classes, name mangling, and exception handling.
1642
      -model)
1643
	compile_command="$compile_command $arg"
1644
	compiler_flags="$compiler_flags $arg"
1645
	finalize_command="$finalize_command $arg"
1646
	prev=xcompiler
1647
	continue
1648
	;;
1649

    
1650
     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
1651
	compiler_flags="$compiler_flags $arg"
1652
	compile_command="$compile_command $arg"
1653
	finalize_command="$finalize_command $arg"
1654
	continue
1655
	;;
1656

    
1657
      -multi_module)
1658
	single_module="${wl}-multi_module"
1659
	continue
1660
	;;
1661

    
1662
      -module)
1663
	module=yes
1664
	continue
1665
	;;
1666

    
1667
      # -64, -mips[0-9] enable 64-bit mode on the SGI compiler
1668
      # -r[0-9][0-9]* specifies the processor on the SGI compiler
1669
      # -xarch=*, -xtarget=* enable 64-bit mode on the Sun compiler
1670
      # +DA*, +DD* enable 64-bit mode on the HP compiler
1671
      # -q* pass through compiler args for the IBM compiler
1672
      # -m* pass through architecture-specific compiler args for GCC
1673
      # -m*, -t[45]*, -txscale* pass through architecture-specific
1674
      # compiler args for GCC
1675
      # -p, -pg, --coverage, -fprofile-* pass through profiling flag for GCC
1676
      # -F/path gives path to uninstalled frameworks, gcc on darwin
1677
      # @file GCC response files
1678
      -64|-mips[0-9]|-r[0-9][0-9]*|-xarch=*|-xtarget=*|+DA*|+DD*|-q*|-m*| \
1679
      -t[45]*|-txscale*|-p|-pg|--coverage|-fprofile-*|-F*|@*)
1680

    
1681
	# Unknown arguments in both finalize_command and compile_command need
1682
	# to be aesthetically quoted because they are evaled later.
1683
	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1684
	case $arg in
1685
	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
1686
	  arg="\"$arg\""
1687
	  ;;
1688
	esac
1689
        compile_command="$compile_command $arg"
1690
        finalize_command="$finalize_command $arg"
1691
        compiler_flags="$compiler_flags $arg"
1692
        continue
1693
        ;;
1694

    
1695
      -shrext)
1696
	prev=shrext
1697
	continue
1698
	;;
1699

    
1700
      -no-fast-install)
1701
	fast_install=no
1702
	continue
1703
	;;
1704

    
1705
      -no-install)
1706
	case $host in
1707
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-darwin*)
1708
	  # The PATH hackery in wrapper scripts is required on Windows
1709
	  # and Darwin in order for the loader to find any dlls it needs.
1710
	  $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1711
	  $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1712
	  fast_install=no
1713
	  ;;
1714
	*) no_install=yes ;;
1715
	esac
1716
	continue
1717
	;;
1718

    
1719
      -no-undefined)
1720
	allow_undefined=no
1721
	continue
1722
	;;
1723

    
1724
      -objectlist)
1725
	prev=objectlist
1726
	continue
1727
	;;
1728

    
1729
      -o) prev=output ;;
1730

    
1731
      -precious-files-regex)
1732
	prev=precious_regex
1733
	continue
1734
	;;
1735

    
1736
      -release)
1737
	prev=release
1738
	continue
1739
	;;
1740

    
1741
      -rpath)
1742
	prev=rpath
1743
	continue
1744
	;;
1745

    
1746
      -R)
1747
	prev=xrpath
1748
	continue
1749
	;;
1750

    
1751
      -R*)
1752
	dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1753
	# We need an absolute path.
1754
	case $dir in
1755
	[\\/]* | [A-Za-z]:[\\/]*) ;;
1756
	*)
1757
	  $echo "$modename: only absolute run-paths are allowed" 1>&2
1758
	  exit $EXIT_FAILURE
1759
	  ;;
1760
	esac
1761
	case "$xrpath " in
1762
	*" $dir "*) ;;
1763
	*) xrpath="$xrpath $dir" ;;
1764
	esac
1765
	continue
1766
	;;
1767

    
1768
      -static | -static-libtool-libs)
1769
	# The effects of -static are defined in a previous loop.
1770
	# We used to do the same as -all-static on platforms that
1771
	# didn't have a PIC flag, but the assumption that the effects
1772
	# would be equivalent was wrong.  It would break on at least
1773
	# Digital Unix and AIX.
1774
	continue
1775
	;;
1776

    
1777
      -thread-safe)
1778
	thread_safe=yes
1779
	continue
1780
	;;
1781

    
1782
      -version-info)
1783
	prev=vinfo
1784
	continue
1785
	;;
1786
      -version-number)
1787
	prev=vinfo
1788
	vinfo_number=yes
1789
	continue
1790
	;;
1791

    
1792
      -Wc,*)
1793
	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1794
	arg=
1795
	save_ifs="$IFS"; IFS=','
1796
	for flag in $args; do
1797
	  IFS="$save_ifs"
1798
	  case $flag in
1799
	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
1800
	    flag="\"$flag\""
1801
	    ;;
1802
	  esac
1803
	  arg="$arg $wl$flag"
1804
	  compiler_flags="$compiler_flags $flag"
1805
	done
1806
	IFS="$save_ifs"
1807
	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1808
	;;
1809

    
1810
      -Wl,*)
1811
	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1812
	arg=
1813
	save_ifs="$IFS"; IFS=','
1814
	for flag in $args; do
1815
	  IFS="$save_ifs"
1816
	  case $flag in
1817
	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
1818
	    flag="\"$flag\""
1819
	    ;;
1820
	  esac
1821
	  arg="$arg $wl$flag"
1822
	  compiler_flags="$compiler_flags $wl$flag"
1823
	  linker_flags="$linker_flags $flag"
1824
	done
1825
	IFS="$save_ifs"
1826
	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1827
	;;
1828

    
1829
      -Xcompiler)
1830
	prev=xcompiler
1831
	continue
1832
	;;
1833

    
1834
      -Xlinker)
1835
	prev=xlinker
1836
	continue
1837
	;;
1838

    
1839
      -XCClinker)
1840
	prev=xcclinker
1841
	continue
1842
	;;
1843

    
1844
      # Some other compiler flag.
1845
      -* | +*)
1846
	# Unknown arguments in both finalize_command and compile_command need
1847
	# to be aesthetically quoted because they are evaled later.
1848
	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1849
	case $arg in
1850
	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
1851
	  arg="\"$arg\""
1852
	  ;;
1853
	esac
1854
	;;
1855

    
1856
      *.$objext)
1857
	# A standard object.
1858
	objs="$objs $arg"
1859
	;;
1860

    
1861
      *.lo)
1862
	# A libtool-controlled object.
1863

    
1864
	# Check to see that this really is a libtool object.
1865
	if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1866
	  pic_object=
1867
	  non_pic_object=
1868

    
1869
	  # Read the .lo file
1870
	  # If there is no directory component, then add one.
1871
	  case $arg in
1872
	  */* | *\\*) . $arg ;;
1873
	  *) . ./$arg ;;
1874
	  esac
1875

    
1876
	  if test -z "$pic_object" || \
1877
	     test -z "$non_pic_object" ||
1878
	     test "$pic_object" = none && \
1879
	     test "$non_pic_object" = none; then
1880
	    $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1881
	    exit $EXIT_FAILURE
1882
	  fi
1883

    
1884
	  # Extract subdirectory from the argument.
1885
	  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1886
	  if test "X$xdir" = "X$arg"; then
1887
	    xdir=
1888
 	  else
1889
	    xdir="$xdir/"
1890
	  fi
1891

    
1892
	  if test "$pic_object" != none; then
1893
	    # Prepend the subdirectory the object is found in.
1894
	    pic_object="$xdir$pic_object"
1895

    
1896
	    if test "$prev" = dlfiles; then
1897
	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1898
		dlfiles="$dlfiles $pic_object"
1899
		prev=
1900
		continue
1901
	      else
1902
		# If libtool objects are unsupported, then we need to preload.
1903
		prev=dlprefiles
1904
	      fi
1905
	    fi
1906

    
1907
	    # CHECK ME:  I think I busted this.  -Ossama
1908
	    if test "$prev" = dlprefiles; then
1909
	      # Preload the old-style object.
1910
	      dlprefiles="$dlprefiles $pic_object"
1911
	      prev=
1912
	    fi
1913

    
1914
	    # A PIC object.
1915
	    libobjs="$libobjs $pic_object"
1916
	    arg="$pic_object"
1917
	  fi
1918

    
1919
	  # Non-PIC object.
1920
	  if test "$non_pic_object" != none; then
1921
	    # Prepend the subdirectory the object is found in.
1922
	    non_pic_object="$xdir$non_pic_object"
1923

    
1924
	    # A standard non-PIC object
1925
	    non_pic_objects="$non_pic_objects $non_pic_object"
1926
	    if test -z "$pic_object" || test "$pic_object" = none ; then
1927
	      arg="$non_pic_object"
1928
	    fi
1929
	  else
1930
	    # If the PIC object exists, use it instead.
1931
	    # $xdir was prepended to $pic_object above.
1932
	    non_pic_object="$pic_object"
1933
	    non_pic_objects="$non_pic_objects $non_pic_object"
1934
	  fi
1935
	else
1936
	  # Only an error if not doing a dry-run.
1937
	  if test -z "$run"; then
1938
	    $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1939
	    exit $EXIT_FAILURE
1940
	  else
1941
	    # Dry-run case.
1942

    
1943
	    # Extract subdirectory from the argument.
1944
	    xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1945
	    if test "X$xdir" = "X$arg"; then
1946
	      xdir=
1947
	    else
1948
	      xdir="$xdir/"
1949
	    fi
1950

    
1951
	    pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1952
	    non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1953
	    libobjs="$libobjs $pic_object"
1954
	    non_pic_objects="$non_pic_objects $non_pic_object"
1955
	  fi
1956
	fi
1957
	;;
1958

    
1959
      *.$libext)
1960
	# An archive.
1961
	deplibs="$deplibs $arg"
1962
	old_deplibs="$old_deplibs $arg"
1963
	continue
1964
	;;
1965

    
1966
      *.la)
1967
	# A libtool-controlled library.
1968

    
1969
	if test "$prev" = dlfiles; then
1970
	  # This library was specified with -dlopen.
1971
	  dlfiles="$dlfiles $arg"
1972
	  prev=
1973
	elif test "$prev" = dlprefiles; then
1974
	  # The library was specified with -dlpreopen.
1975
	  dlprefiles="$dlprefiles $arg"
1976
	  prev=
1977
	else
1978
	  deplibs="$deplibs $arg"
1979
	fi
1980
	continue
1981
	;;
1982

    
1983
      # Some other compiler argument.
1984
      *)
1985
	# Unknown arguments in both finalize_command and compile_command need
1986
	# to be aesthetically quoted because they are evaled later.
1987
	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1988
	case $arg in
1989
	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
1990
	  arg="\"$arg\""
1991
	  ;;
1992
	esac
1993
	;;
1994
      esac # arg
1995

    
1996
      # Now actually substitute the argument into the commands.
1997
      if test -n "$arg"; then
1998
	compile_command="$compile_command $arg"
1999
	finalize_command="$finalize_command $arg"
2000
      fi
2001
    done # argument parsing loop
2002

    
2003
    if test -n "$prev"; then
2004
      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
2005
      $echo "$help" 1>&2
2006
      exit $EXIT_FAILURE
2007
    fi
2008

    
2009
    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
2010
      eval arg=\"$export_dynamic_flag_spec\"
2011
      compile_command="$compile_command $arg"
2012
      finalize_command="$finalize_command $arg"
2013
    fi
2014

    
2015
    oldlibs=
2016
    # calculate the name of the file, without its directory
2017
    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
2018
    libobjs_save="$libobjs"
2019

    
2020
    if test -n "$shlibpath_var"; then
2021
      # get the directories listed in $shlibpath_var
2022
      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
2023
    else
2024
      shlib_search_path=
2025
    fi
2026
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
2027
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
2028

    
2029
    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
2030
    if test "X$output_objdir" = "X$output"; then
2031
      output_objdir="$objdir"
2032
    else
2033
      output_objdir="$output_objdir/$objdir"
2034
    fi
2035
    # Create the object directory.
2036
    if test ! -d "$output_objdir"; then
2037
      $show "$mkdir $output_objdir"
2038
      $run $mkdir $output_objdir
2039
      exit_status=$?
2040
      if test "$exit_status" -ne 0 && test ! -d "$output_objdir"; then
2041
	exit $exit_status
2042
      fi
2043
    fi
2044

    
2045
    # Determine the type of output
2046
    case $output in
2047
    "")
2048
      $echo "$modename: you must specify an output file" 1>&2
2049
      $echo "$help" 1>&2
2050
      exit $EXIT_FAILURE
2051
      ;;
2052
    *.$libext) linkmode=oldlib ;;
2053
    *.lo | *.$objext) linkmode=obj ;;
2054
    *.la) linkmode=lib ;;
2055
    *) linkmode=prog ;; # Anything else should be a program.
2056
    esac
2057

    
2058
    case $host in
2059
    *cygwin* | *mingw* | *pw32*)
2060
      # don't eliminate duplications in $postdeps and $predeps
2061
      duplicate_compiler_generated_deps=yes
2062
      ;;
2063
    *)
2064
      duplicate_compiler_generated_deps=$duplicate_deps
2065
      ;;
2066
    esac
2067
    specialdeplibs=
2068

    
2069
    libs=
2070
    # Find all interdependent deplibs by searching for libraries
2071
    # that are linked more than once (e.g. -la -lb -la)
2072
    for deplib in $deplibs; do
2073
      if test "X$duplicate_deps" = "Xyes" ; then
2074
	case "$libs " in
2075
	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2076
	esac
2077
      fi
2078
      libs="$libs $deplib"
2079
    done
2080

    
2081
    if test "$linkmode" = lib; then
2082
      libs="$predeps $libs $compiler_lib_search_path $postdeps"
2083

    
2084
      # Compute libraries that are listed more than once in $predeps
2085
      # $postdeps and mark them as special (i.e., whose duplicates are
2086
      # not to be eliminated).
2087
      pre_post_deps=
2088
      if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
2089
	for pre_post_dep in $predeps $postdeps; do
2090
	  case "$pre_post_deps " in
2091
	  *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
2092
	  esac
2093
	  pre_post_deps="$pre_post_deps $pre_post_dep"
2094
	done
2095
      fi
2096
      pre_post_deps=
2097
    fi
2098

    
2099
    deplibs=
2100
    newdependency_libs=
2101
    newlib_search_path=
2102
    need_relink=no # whether we're linking any uninstalled libtool libraries
2103
    notinst_deplibs= # not-installed libtool libraries
2104
    case $linkmode in
2105
    lib)
2106
	passes="conv link"
2107
	for file in $dlfiles $dlprefiles; do
2108
	  case $file in
2109
	  *.la) ;;
2110
	  *)
2111
	    $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
2112
	    exit $EXIT_FAILURE
2113
	    ;;
2114
	  esac
2115
	done
2116
	;;
2117
    prog)
2118
	compile_deplibs=
2119
	finalize_deplibs=
2120
	alldeplibs=no
2121
	newdlfiles=
2122
	newdlprefiles=
2123
	passes="conv scan dlopen dlpreopen link"
2124
	;;
2125
    *)  passes="conv"
2126
	;;
2127
    esac
2128
    for pass in $passes; do
2129
      if test "$linkmode,$pass" = "lib,link" ||
2130
	 test "$linkmode,$pass" = "prog,scan"; then
2131
	libs="$deplibs"
2132
	deplibs=
2133
      fi
2134
      if test "$linkmode" = prog; then
2135
	case $pass in
2136
	dlopen) libs="$dlfiles" ;;
2137
	dlpreopen) libs="$dlprefiles" ;;
2138
	link)
2139
	  libs="$deplibs %DEPLIBS%"
2140
	  test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
2141
	  ;;
2142
	esac
2143
      fi
2144
      if test "$pass" = dlopen; then
2145
	# Collect dlpreopened libraries
2146
	save_deplibs="$deplibs"
2147
	deplibs=
2148
      fi
2149
      for deplib in $libs; do
2150
	lib=
2151
	found=no
2152
	case $deplib in
2153
	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe|-threads)
2154
	  if test "$linkmode,$pass" = "prog,link"; then
2155
	    compile_deplibs="$deplib $compile_deplibs"
2156
	    finalize_deplibs="$deplib $finalize_deplibs"
2157
	  else
2158
	    compiler_flags="$compiler_flags $deplib"
2159
	  fi
2160
	  continue
2161
	  ;;
2162
	-l*)
2163
	  if test "$linkmode" != lib && test "$linkmode" != prog; then
2164
	    $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
2165
	    continue
2166
	  fi
2167
	  name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
2168
	  if test "$linkmode" = lib; then
2169
	    searchdirs="$newlib_search_path $lib_search_path $compiler_lib_search_dirs $sys_lib_search_path $shlib_search_path"
2170
	  else
2171
	    searchdirs="$newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path"
2172
	  fi
2173
	  for searchdir in $searchdirs; do
2174
	    for search_ext in .la $std_shrext .so .a; do
2175
	      # Search the libtool library
2176
	      lib="$searchdir/lib${name}${search_ext}"
2177
	      if test -f "$lib"; then
2178
		if test "$search_ext" = ".la"; then
2179
		  found=yes
2180
		else
2181
		  found=no
2182
		fi
2183
		break 2
2184
	      fi
2185
	    done
2186
	  done
2187
	  if test "$found" != yes; then
2188
	    # deplib doesn't seem to be a libtool library
2189
	    if test "$linkmode,$pass" = "prog,link"; then
2190
	      compile_deplibs="$deplib $compile_deplibs"
2191
	      finalize_deplibs="$deplib $finalize_deplibs"
2192
	    else
2193
	      deplibs="$deplib $deplibs"
2194
	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2195
	    fi
2196
	    continue
2197
	  else # deplib is a libtool library
2198
	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
2199
	    # We need to do some special things here, and not later.
2200
	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
2201
	      case " $predeps $postdeps " in
2202
	      *" $deplib "*)
2203
		if (${SED} -e '2q' $lib |
2204
                    grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
2205
		  library_names=
2206
		  old_library=
2207
		  case $lib in
2208
		  */* | *\\*) . $lib ;;
2209
		  *) . ./$lib ;;
2210
		  esac
2211
		  for l in $old_library $library_names; do
2212
		    ll="$l"
2213
		  done
2214
		  if test "X$ll" = "X$old_library" ; then # only static version available
2215
		    found=no
2216
		    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2217
		    test "X$ladir" = "X$lib" && ladir="."
2218
		    lib=$ladir/$old_library
2219
		    if test "$linkmode,$pass" = "prog,link"; then
2220
		      compile_deplibs="$deplib $compile_deplibs"
2221
		      finalize_deplibs="$deplib $finalize_deplibs"
2222
		    else
2223
		      deplibs="$deplib $deplibs"
2224
		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
2225
		    fi
2226
		    continue
2227
		  fi
2228
		fi
2229
	        ;;
2230
	      *) ;;
2231
	      esac
2232
	    fi
2233
	  fi
2234
	  ;; # -l
2235
	-L*)
2236
	  case $linkmode in
2237
	  lib)
2238
	    deplibs="$deplib $deplibs"
2239
	    test "$pass" = conv && continue
2240
	    newdependency_libs="$deplib $newdependency_libs"
2241
	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2242
	    ;;
2243
	  prog)
2244
	    if test "$pass" = conv; then
2245
	      deplibs="$deplib $deplibs"
2246
	      continue
2247
	    fi
2248
	    if test "$pass" = scan; then
2249
	      deplibs="$deplib $deplibs"
2250
	    else
2251
	      compile_deplibs="$deplib $compile_deplibs"
2252
	      finalize_deplibs="$deplib $finalize_deplibs"
2253
	    fi
2254
	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
2255
	    ;;
2256
	  *)
2257
	    $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
2258
	    ;;
2259
	  esac # linkmode
2260
	  continue
2261
	  ;; # -L
2262
	-R*)
2263
	  if test "$pass" = link; then
2264
	    dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
2265
	    # Make sure the xrpath contains only unique directories.
2266
	    case "$xrpath " in
2267
	    *" $dir "*) ;;
2268
	    *) xrpath="$xrpath $dir" ;;
2269
	    esac
2270
	  fi
2271
	  deplibs="$deplib $deplibs"
2272
	  continue
2273
	  ;;
2274
	*.la) lib="$deplib" ;;
2275
	*.$libext)
2276
	  if test "$pass" = conv; then
2277
	    deplibs="$deplib $deplibs"
2278
	    continue
2279
	  fi
2280
	  case $linkmode in
2281
	  lib)
2282
	    valid_a_lib=no
2283
	    case $deplibs_check_method in
2284
	      match_pattern*)
2285
		set dummy $deplibs_check_method
2286
	        match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2287
		if eval $echo \"$deplib\" 2>/dev/null \
2288
		    | $SED 10q \
2289
		    | $EGREP "$match_pattern_regex" > /dev/null; then
2290
		  valid_a_lib=yes
2291
		fi
2292
		;;
2293
	      pass_all)
2294
		valid_a_lib=yes
2295
		;;
2296
            esac
2297
	    if test "$valid_a_lib" != yes; then
2298
	      $echo
2299
	      $echo "*** Warning: Trying to link with static lib archive $deplib."
2300
	      $echo "*** I have the capability to make that library automatically link in when"
2301
	      $echo "*** you link to this library.  But I can only do this if you have a"
2302
	      $echo "*** shared version of the library, which you do not appear to have"
2303
	      $echo "*** because the file extensions .$libext of this argument makes me believe"
2304
	      $echo "*** that it is just a static archive that I should not used here."
2305
	    else
2306
	      $echo
2307
	      $echo "*** Warning: Linking the shared library $output against the"
2308
	      $echo "*** static library $deplib is not portable!"
2309
	      deplibs="$deplib $deplibs"
2310
	    fi
2311
	    continue
2312
	    ;;
2313
	  prog)
2314
	    if test "$pass" != link; then
2315
	      deplibs="$deplib $deplibs"
2316
	    else
2317
	      compile_deplibs="$deplib $compile_deplibs"
2318
	      finalize_deplibs="$deplib $finalize_deplibs"
2319
	    fi
2320
	    continue
2321
	    ;;
2322
	  esac # linkmode
2323
	  ;; # *.$libext
2324
	*.lo | *.$objext)
2325
	  if test "$pass" = conv; then
2326
	    deplibs="$deplib $deplibs"
2327
	  elif test "$linkmode" = prog; then
2328
	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2329
	      # If there is no dlopen support or we're linking statically,
2330
	      # we need to preload.
2331
	      newdlprefiles="$newdlprefiles $deplib"
2332
	      compile_deplibs="$deplib $compile_deplibs"
2333
	      finalize_deplibs="$deplib $finalize_deplibs"
2334
	    else
2335
	      newdlfiles="$newdlfiles $deplib"
2336
	    fi
2337
	  fi
2338
	  continue
2339
	  ;;
2340
	%DEPLIBS%)
2341
	  alldeplibs=yes
2342
	  continue
2343
	  ;;
2344
	esac # case $deplib
2345
	if test "$found" = yes || test -f "$lib"; then :
2346
	else
2347
	  $echo "$modename: cannot find the library \`$lib' or unhandled argument \`$deplib'" 1>&2
2348
	  exit $EXIT_FAILURE
2349
	fi
2350

    
2351
	# Check to see that this really is a libtool archive.
2352
	if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2353
	else
2354
	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2355
	  exit $EXIT_FAILURE
2356
	fi
2357

    
2358
	ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2359
	test "X$ladir" = "X$lib" && ladir="."
2360

    
2361
	dlname=
2362
	dlopen=
2363
	dlpreopen=
2364
	libdir=
2365
	library_names=
2366
	old_library=
2367
	# If the library was installed with an old release of libtool,
2368
	# it will not redefine variables installed, or shouldnotlink
2369
	installed=yes
2370
	shouldnotlink=no
2371
	avoidtemprpath=
2372

    
2373

    
2374
	# Read the .la file
2375
	case $lib in
2376
	*/* | *\\*) . $lib ;;
2377
	*) . ./$lib ;;
2378
	esac
2379

    
2380
	if test "$linkmode,$pass" = "lib,link" ||
2381
	   test "$linkmode,$pass" = "prog,scan" ||
2382
	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2383
	  test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2384
	  test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2385
	fi
2386

    
2387
	if test "$pass" = conv; then
2388
	  # Only check for convenience libraries
2389
	  deplibs="$lib $deplibs"
2390
	  if test -z "$libdir"; then
2391
	    if test -z "$old_library"; then
2392
	      $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2393
	      exit $EXIT_FAILURE
2394
	    fi
2395
	    # It is a libtool convenience library, so add in its objects.
2396
	    convenience="$convenience $ladir/$objdir/$old_library"
2397
	    old_convenience="$old_convenience $ladir/$objdir/$old_library"
2398
	    tmp_libs=
2399
	    for deplib in $dependency_libs; do
2400
	      deplibs="$deplib $deplibs"
2401
              if test "X$duplicate_deps" = "Xyes" ; then
2402
	        case "$tmp_libs " in
2403
	        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2404
	        esac
2405
              fi
2406
	      tmp_libs="$tmp_libs $deplib"
2407
	    done
2408
	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
2409
	    $echo "$modename: \`$lib' is not a convenience library" 1>&2
2410
	    exit $EXIT_FAILURE
2411
	  fi
2412
	  continue
2413
	fi # $pass = conv
2414

    
2415

    
2416
	# Get the name of the library we link against.
2417
	linklib=
2418
	for l in $old_library $library_names; do
2419
	  linklib="$l"
2420
	done
2421
	if test -z "$linklib"; then
2422
	  $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2423
	  exit $EXIT_FAILURE
2424
	fi
2425

    
2426
	# This library was specified with -dlopen.
2427
	if test "$pass" = dlopen; then
2428
	  if test -z "$libdir"; then
2429
	    $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2430
	    exit $EXIT_FAILURE
2431
	  fi
2432
	  if test -z "$dlname" ||
2433
	     test "$dlopen_support" != yes ||
2434
	     test "$build_libtool_libs" = no; then
2435
	    # If there is no dlname, no dlopen support or we're linking
2436
	    # statically, we need to preload.  We also need to preload any
2437
	    # dependent libraries so libltdl's deplib preloader doesn't
2438
	    # bomb out in the load deplibs phase.
2439
	    dlprefiles="$dlprefiles $lib $dependency_libs"
2440
	  else
2441
	    newdlfiles="$newdlfiles $lib"
2442
	  fi
2443
	  continue
2444
	fi # $pass = dlopen
2445

    
2446
	# We need an absolute path.
2447
	case $ladir in
2448
	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2449
	*)
2450
	  abs_ladir=`cd "$ladir" && pwd`
2451
	  if test -z "$abs_ladir"; then
2452
	    $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2453
	    $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2454
	    abs_ladir="$ladir"
2455
	  fi
2456
	  ;;
2457
	esac
2458
	laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2459

    
2460
	# Find the relevant object directory and library name.
2461
	if test "X$installed" = Xyes; then
2462
	  if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2463
	    $echo "$modename: warning: library \`$lib' was moved." 1>&2
2464
	    dir="$ladir"
2465
	    absdir="$abs_ladir"
2466
	    libdir="$abs_ladir"
2467
	  else
2468
	    dir="$libdir"
2469
	    absdir="$libdir"
2470
	  fi
2471
	  test "X$hardcode_automatic" = Xyes && avoidtemprpath=yes
2472
	else
2473
	  if test ! -f "$ladir/$objdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2474
	    dir="$ladir"
2475
	    absdir="$abs_ladir"
2476
	    # Remove this search path later
2477
	    notinst_path="$notinst_path $abs_ladir"
2478
	  else
2479
	    dir="$ladir/$objdir"
2480
	    absdir="$abs_ladir/$objdir"
2481
	    # Remove this search path later
2482
	    notinst_path="$notinst_path $abs_ladir"
2483
	  fi
2484
	fi # $installed = yes
2485
	name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2486

    
2487
	# This library was specified with -dlpreopen.
2488
	if test "$pass" = dlpreopen; then
2489
	  if test -z "$libdir"; then
2490
	    $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2491
	    exit $EXIT_FAILURE
2492
	  fi
2493
	  # Prefer using a static library (so that no silly _DYNAMIC symbols
2494
	  # are required to link).
2495
	  if test -n "$old_library"; then
2496
	    newdlprefiles="$newdlprefiles $dir/$old_library"
2497
	  # Otherwise, use the dlname, so that lt_dlopen finds it.
2498
	  elif test -n "$dlname"; then
2499
	    newdlprefiles="$newdlprefiles $dir/$dlname"
2500
	  else
2501
	    newdlprefiles="$newdlprefiles $dir/$linklib"
2502
	  fi
2503
	fi # $pass = dlpreopen
2504

    
2505
	if test -z "$libdir"; then
2506
	  # Link the convenience library
2507
	  if test "$linkmode" = lib; then
2508
	    deplibs="$dir/$old_library $deplibs"
2509
	  elif test "$linkmode,$pass" = "prog,link"; then
2510
	    compile_deplibs="$dir/$old_library $compile_deplibs"
2511
	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
2512
	  else
2513
	    deplibs="$lib $deplibs" # used for prog,scan pass
2514
	  fi
2515
	  continue
2516
	fi
2517

    
2518

    
2519
	if test "$linkmode" = prog && test "$pass" != link; then
2520
	  newlib_search_path="$newlib_search_path $ladir"
2521
	  deplibs="$lib $deplibs"
2522

    
2523
	  linkalldeplibs=no
2524
	  if test "$link_all_deplibs" != no || test -z "$library_names" ||
2525
	     test "$build_libtool_libs" = no; then
2526
	    linkalldeplibs=yes
2527
	  fi
2528

    
2529
	  tmp_libs=
2530
	  for deplib in $dependency_libs; do
2531
	    case $deplib in
2532
	    -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2533
	    esac
2534
	    # Need to link against all dependency_libs?
2535
	    if test "$linkalldeplibs" = yes; then
2536
	      deplibs="$deplib $deplibs"
2537
	    else
2538
	      # Need to hardcode shared library paths
2539
	      # or/and link against static libraries
2540
	      newdependency_libs="$deplib $newdependency_libs"
2541
	    fi
2542
	    if test "X$duplicate_deps" = "Xyes" ; then
2543
	      case "$tmp_libs " in
2544
	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2545
	      esac
2546
	    fi
2547
	    tmp_libs="$tmp_libs $deplib"
2548
	  done # for deplib
2549
	  continue
2550
	fi # $linkmode = prog...
2551

    
2552
	if test "$linkmode,$pass" = "prog,link"; then
2553
	  if test -n "$library_names" &&
2554
	     { { test "$prefer_static_libs" = no ||
2555
		 test "$prefer_static_libs,$installed" = "built,yes"; } ||
2556
	       test -z "$old_library"; }; then
2557
	    # We need to hardcode the library path
2558
	    if test -n "$shlibpath_var" && test -z "$avoidtemprpath" ; then
2559
	      # Make sure the rpath contains only unique directories.
2560
	      case "$temp_rpath " in
2561
	      *" $dir "*) ;;
2562
	      *" $absdir "*) ;;
2563
	      *) temp_rpath="$temp_rpath $absdir" ;;
2564
	      esac
2565
	    fi
2566

    
2567
	    # Hardcode the library path.
2568
	    # Skip directories that are in the system default run-time
2569
	    # search path.
2570
	    case " $sys_lib_dlsearch_path " in
2571
	    *" $absdir "*) ;;
2572
	    *)
2573
	      case "$compile_rpath " in
2574
	      *" $absdir "*) ;;
2575
	      *) compile_rpath="$compile_rpath $absdir"
2576
	      esac
2577
	      ;;
2578
	    esac
2579
	    case " $sys_lib_dlsearch_path " in
2580
	    *" $libdir "*) ;;
2581
	    *)
2582
	      case "$finalize_rpath " in
2583
	      *" $libdir "*) ;;
2584
	      *) finalize_rpath="$finalize_rpath $libdir"
2585
	      esac
2586
	      ;;
2587
	    esac
2588
	  fi # $linkmode,$pass = prog,link...
2589

    
2590
	  if test "$alldeplibs" = yes &&
2591
	     { test "$deplibs_check_method" = pass_all ||
2592
	       { test "$build_libtool_libs" = yes &&
2593
		 test -n "$library_names"; }; }; then
2594
	    # We only need to search for static libraries
2595
	    continue
2596
	  fi
2597
	fi
2598

    
2599
	link_static=no # Whether the deplib will be linked statically
2600
	use_static_libs=$prefer_static_libs
2601
	if test "$use_static_libs" = built && test "$installed" = yes ; then
2602
	  use_static_libs=no
2603
	fi
2604
	if test -n "$library_names" &&
2605
	   { test "$use_static_libs" = no || test -z "$old_library"; }; then
2606
	  if test "$installed" = no; then
2607
	    notinst_deplibs="$notinst_deplibs $lib"
2608
	    need_relink=yes
2609
	  fi
2610
	  # This is a shared library
2611

    
2612
	  # Warn about portability, can't link against -module's on
2613
	  # some systems (darwin)
2614
	  if test "$shouldnotlink" = yes && test "$pass" = link ; then
2615
	    $echo
2616
	    if test "$linkmode" = prog; then
2617
	      $echo "*** Warning: Linking the executable $output against the loadable module"
2618
	    else
2619
	      $echo "*** Warning: Linking the shared library $output against the loadable module"
2620
	    fi
2621
	    $echo "*** $linklib is not portable!"
2622
	  fi
2623
	  if test "$linkmode" = lib &&
2624
	     test "$hardcode_into_libs" = yes; then
2625
	    # Hardcode the library path.
2626
	    # Skip directories that are in the system default run-time
2627
	    # search path.
2628
	    case " $sys_lib_dlsearch_path " in
2629
	    *" $absdir "*) ;;
2630
	    *)
2631
	      case "$compile_rpath " in
2632
	      *" $absdir "*) ;;
2633
	      *) compile_rpath="$compile_rpath $absdir"
2634
	      esac
2635
	      ;;
2636
	    esac
2637
	    case " $sys_lib_dlsearch_path " in
2638
	    *" $libdir "*) ;;
2639
	    *)
2640
	      case "$finalize_rpath " in
2641
	      *" $libdir "*) ;;
2642
	      *) finalize_rpath="$finalize_rpath $libdir"
2643
	      esac
2644
	      ;;
2645
	    esac
2646
	  fi
2647

    
2648
	  if test -n "$old_archive_from_expsyms_cmds"; then
2649
	    # figure out the soname
2650
	    set dummy $library_names
2651
	    realname="$2"
2652
	    shift; shift
2653
	    libname=`eval \\$echo \"$libname_spec\"`
2654
	    # use dlname if we got it. it's perfectly good, no?
2655
	    if test -n "$dlname"; then
2656
	      soname="$dlname"
2657
	    elif test -n "$soname_spec"; then
2658
	      # bleh windows
2659
	      case $host in
2660
	      *cygwin* | mingw*)
2661
		major=`expr $current - $age`
2662
		versuffix="-$major"
2663
		;;
2664
	      esac
2665
	      eval soname=\"$soname_spec\"
2666
	    else
2667
	      soname="$realname"
2668
	    fi
2669

    
2670
	    # Make a new name for the extract_expsyms_cmds to use
2671
	    soroot="$soname"
2672
	    soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2673
	    newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2674

    
2675
	    # If the library has no export list, then create one now
2676
	    if test -f "$output_objdir/$soname-def"; then :
2677
	    else
2678
	      $show "extracting exported symbol list from \`$soname'"
2679
	      save_ifs="$IFS"; IFS='~'
2680
	      cmds=$extract_expsyms_cmds
2681
	      for cmd in $cmds; do
2682
		IFS="$save_ifs"
2683
		eval cmd=\"$cmd\"
2684
		$show "$cmd"
2685
		$run eval "$cmd" || exit $?
2686
	      done
2687
	      IFS="$save_ifs"
2688
	    fi
2689

    
2690
	    # Create $newlib
2691
	    if test -f "$output_objdir/$newlib"; then :; else
2692
	      $show "generating import library for \`$soname'"
2693
	      save_ifs="$IFS"; IFS='~'
2694
	      cmds=$old_archive_from_expsyms_cmds
2695
	      for cmd in $cmds; do
2696
		IFS="$save_ifs"
2697
		eval cmd=\"$cmd\"
2698
		$show "$cmd"
2699
		$run eval "$cmd" || exit $?
2700
	      done
2701
	      IFS="$save_ifs"
2702
	    fi
2703
	    # make sure the library variables are pointing to the new library
2704
	    dir=$output_objdir
2705
	    linklib=$newlib
2706
	  fi # test -n "$old_archive_from_expsyms_cmds"
2707

    
2708
	  if test "$linkmode" = prog || test "$mode" != relink; then
2709
	    add_shlibpath=
2710
	    add_dir=
2711
	    add=
2712
	    lib_linked=yes
2713
	    case $hardcode_action in
2714
	    immediate | unsupported)
2715
	      if test "$hardcode_direct" = no; then
2716
		add="$dir/$linklib"
2717
		case $host in
2718
		  *-*-sco3.2v5.0.[024]*) add_dir="-L$dir" ;;
2719
		  *-*-sysv4*uw2*) add_dir="-L$dir" ;;
2720
		  *-*-sysv5OpenUNIX* | *-*-sysv5UnixWare7.[01].[10]* | \
2721
		    *-*-unixware7*) add_dir="-L$dir" ;;
2722
		  *-*-darwin* )
2723
		    # if the lib is a module then we can not link against
2724
		    # it, someone is ignoring the new warnings I added
2725
		    if /usr/bin/file -L $add 2> /dev/null |
2726
                      $EGREP ": [^:]* bundle" >/dev/null ; then
2727
		      $echo "** Warning, lib $linklib is a module, not a shared library"
2728
		      if test -z "$old_library" ; then
2729
		        $echo
2730
		        $echo "** And there doesn't seem to be a static archive available"
2731
		        $echo "** The link will probably fail, sorry"
2732
		      else
2733
		        add="$dir/$old_library"
2734
		      fi
2735
		    fi
2736
		esac
2737
	      elif test "$hardcode_minus_L" = no; then
2738
		case $host in
2739
		*-*-sunos*) add_shlibpath="$dir" ;;
2740
		esac
2741
		add_dir="-L$dir"
2742
		add="-l$name"
2743
	      elif test "$hardcode_shlibpath_var" = no; then
2744
		add_shlibpath="$dir"
2745
		add="-l$name"
2746
	      else
2747
		lib_linked=no
2748
	      fi
2749
	      ;;
2750
	    relink)
2751
	      if test "$hardcode_direct" = yes; then
2752
		add="$dir/$linklib"
2753
	      elif test "$hardcode_minus_L" = yes; then
2754
		add_dir="-L$dir"
2755
		# Try looking first in the location we're being installed to.
2756
		if test -n "$inst_prefix_dir"; then
2757
		  case $libdir in
2758
		    [\\/]*)
2759
		      add_dir="$add_dir -L$inst_prefix_dir$libdir"
2760
		      ;;
2761
		  esac
2762
		fi
2763
		add="-l$name"
2764
	      elif test "$hardcode_shlibpath_var" = yes; then
2765
		add_shlibpath="$dir"
2766
		add="-l$name"
2767
	      else
2768
		lib_linked=no
2769
	      fi
2770
	      ;;
2771
	    *) lib_linked=no ;;
2772
	    esac
2773

    
2774
	    if test "$lib_linked" != yes; then
2775
	      $echo "$modename: configuration error: unsupported hardcode properties"
2776
	      exit $EXIT_FAILURE
2777
	    fi
2778

    
2779
	    if test -n "$add_shlibpath"; then
2780
	      case :$compile_shlibpath: in
2781
	      *":$add_shlibpath:"*) ;;
2782
	      *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2783
	      esac
2784
	    fi
2785
	    if test "$linkmode" = prog; then
2786
	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2787
	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
2788
	    else
2789
	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
2790
	      test -n "$add" && deplibs="$add $deplibs"
2791
	      if test "$hardcode_direct" != yes && \
2792
		 test "$hardcode_minus_L" != yes && \
2793
		 test "$hardcode_shlibpath_var" = yes; then
2794
		case :$finalize_shlibpath: in
2795
		*":$libdir:"*) ;;
2796
		*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2797
		esac
2798
	      fi
2799
	    fi
2800
	  fi
2801

    
2802
	  if test "$linkmode" = prog || test "$mode" = relink; then
2803
	    add_shlibpath=
2804
	    add_dir=
2805
	    add=
2806
	    # Finalize command for both is simple: just hardcode it.
2807
	    if test "$hardcode_direct" = yes; then
2808
	      add="$libdir/$linklib"
2809
	    elif test "$hardcode_minus_L" = yes; then
2810
	      add_dir="-L$libdir"
2811
	      add="-l$name"
2812
	    elif test "$hardcode_shlibpath_var" = yes; then
2813
	      case :$finalize_shlibpath: in
2814
	      *":$libdir:"*) ;;
2815
	      *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2816
	      esac
2817
	      add="-l$name"
2818
	    elif test "$hardcode_automatic" = yes; then
2819
	      if test -n "$inst_prefix_dir" &&
2820
		 test -f "$inst_prefix_dir$libdir/$linklib" ; then
2821
	        add="$inst_prefix_dir$libdir/$linklib"
2822
	      else
2823
	        add="$libdir/$linklib"
2824
	      fi
2825
	    else
2826
	      # We cannot seem to hardcode it, guess we'll fake it.
2827
	      add_dir="-L$libdir"
2828
	      # Try looking first in the location we're being installed to.
2829
	      if test -n "$inst_prefix_dir"; then
2830
		case $libdir in
2831
		  [\\/]*)
2832
		    add_dir="$add_dir -L$inst_prefix_dir$libdir"
2833
		    ;;
2834
		esac
2835
	      fi
2836
	      add="-l$name"
2837
	    fi
2838

    
2839
	    if test "$linkmode" = prog; then
2840
	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2841
	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2842
	    else
2843
	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
2844
	      test -n "$add" && deplibs="$add $deplibs"
2845
	    fi
2846
	  fi
2847
	elif test "$linkmode" = prog; then
2848
	  # Here we assume that one of hardcode_direct or hardcode_minus_L
2849
	  # is not unsupported.  This is valid on all known static and
2850
	  # shared platforms.
2851
	  if test "$hardcode_direct" != unsupported; then
2852
	    test -n "$old_library" && linklib="$old_library"
2853
	    compile_deplibs="$dir/$linklib $compile_deplibs"
2854
	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
2855
	  else
2856
	    compile_deplibs="-l$name -L$dir $compile_deplibs"
2857
	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2858
	  fi
2859
	elif test "$build_libtool_libs" = yes; then
2860
	  # Not a shared library
2861
	  if test "$deplibs_check_method" != pass_all; then
2862
	    # We're trying link a shared library against a static one
2863
	    # but the system doesn't support it.
2864

    
2865
	    # Just print a warning and add the library to dependency_libs so
2866
	    # that the program can be linked against the static library.
2867
	    $echo
2868
	    $echo "*** Warning: This system can not link to static lib archive $lib."
2869
	    $echo "*** I have the capability to make that library automatically link in when"
2870
	    $echo "*** you link to this library.  But I can only do this if you have a"
2871
	    $echo "*** shared version of the library, which you do not appear to have."
2872
	    if test "$module" = yes; then
2873
	      $echo "*** But as you try to build a module library, libtool will still create "
2874
	      $echo "*** a static module, that should work as long as the dlopening application"
2875
	      $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2876
	      if test -z "$global_symbol_pipe"; then
2877
		$echo
2878
		$echo "*** However, this would only work if libtool was able to extract symbol"
2879
		$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2880
		$echo "*** not find such a program.  So, this module is probably useless."
2881
		$echo "*** \`nm' from GNU binutils and a full rebuild may help."
2882
	      fi
2883
	      if test "$build_old_libs" = no; then
2884
		build_libtool_libs=module
2885
		build_old_libs=yes
2886
	      else
2887
		build_libtool_libs=no
2888
	      fi
2889
	    fi
2890
	  else
2891
	    deplibs="$dir/$old_library $deplibs"
2892
	    link_static=yes
2893
	  fi
2894
	fi # link shared/static library?
2895

    
2896
	if test "$linkmode" = lib; then
2897
	  if test -n "$dependency_libs" &&
2898
	     { test "$hardcode_into_libs" != yes ||
2899
	       test "$build_old_libs" = yes ||
2900
	       test "$link_static" = yes; }; then
2901
	    # Extract -R from dependency_libs
2902
	    temp_deplibs=
2903
	    for libdir in $dependency_libs; do
2904
	      case $libdir in
2905
	      -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2906
		   case " $xrpath " in
2907
		   *" $temp_xrpath "*) ;;
2908
		   *) xrpath="$xrpath $temp_xrpath";;
2909
		   esac;;
2910
	      *) temp_deplibs="$temp_deplibs $libdir";;
2911
	      esac
2912
	    done
2913
	    dependency_libs="$temp_deplibs"
2914
	  fi
2915

    
2916
	  newlib_search_path="$newlib_search_path $absdir"
2917
	  # Link against this library
2918
	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2919
	  # ... and its dependency_libs
2920
	  tmp_libs=
2921
	  for deplib in $dependency_libs; do
2922
	    newdependency_libs="$deplib $newdependency_libs"
2923
	    if test "X$duplicate_deps" = "Xyes" ; then
2924
	      case "$tmp_libs " in
2925
	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2926
	      esac
2927
	    fi
2928
	    tmp_libs="$tmp_libs $deplib"
2929
	  done
2930

    
2931
	  if test "$link_all_deplibs" != no; then
2932
	    # Add the search paths of all dependency libraries
2933
	    for deplib in $dependency_libs; do
2934
	      case $deplib in
2935
	      -L*) path="$deplib" ;;
2936
	      *.la)
2937
		dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2938
		test "X$dir" = "X$deplib" && dir="."
2939
		# We need an absolute path.
2940
		case $dir in
2941
		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2942
		*)
2943
		  absdir=`cd "$dir" && pwd`
2944
		  if test -z "$absdir"; then
2945
		    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2946
		    absdir="$dir"
2947
		  fi
2948
		  ;;
2949
		esac
2950
		if grep "^installed=no" $deplib > /dev/null; then
2951
		  path="$absdir/$objdir"
2952
		else
2953
		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2954
		  if test -z "$libdir"; then
2955
		    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2956
		    exit $EXIT_FAILURE
2957
		  fi
2958
		  if test "$absdir" != "$libdir"; then
2959
		    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2960
		  fi
2961
		  path="$absdir"
2962
		fi
2963
		depdepl=
2964
		case $host in
2965
		*-*-darwin*)
2966
		  # we do not want to link against static libs,
2967
		  # but need to link against shared
2968
		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2969
		  eval deplibdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2970
		  if test -n "$deplibrary_names" ; then
2971
		    for tmp in $deplibrary_names ; do
2972
		      depdepl=$tmp
2973
		    done
2974
		    if test -f "$deplibdir/$depdepl" ; then
2975
		      depdepl="$deplibdir/$depdepl"
2976
	      	    elif test -f "$path/$depdepl" ; then
2977
		      depdepl="$path/$depdepl"
2978
		    else
2979
		      # Can't find it, oh well...
2980
		      depdepl=
2981
		    fi
2982
		    # do not add paths which are already there
2983
		    case " $newlib_search_path " in
2984
		    *" $path "*) ;;
2985
		    *) newlib_search_path="$newlib_search_path $path";;
2986
		    esac
2987
		  fi
2988
		  path=""
2989
		  ;;
2990
		*)
2991
		  path="-L$path"
2992
		  ;;
2993
		esac
2994
		;;
2995
	      -l*)
2996
		case $host in
2997
		*-*-darwin*)
2998
		  # Again, we only want to link against shared libraries
2999
		  eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
3000
		  for tmp in $newlib_search_path ; do
3001
		    if test -f "$tmp/lib$tmp_libs.dylib" ; then
3002
		      eval depdepl="$tmp/lib$tmp_libs.dylib"
3003
		      break
3004
		    fi
3005
		  done
3006
		  path=""
3007
		  ;;
3008
		*) continue ;;
3009
		esac
3010
		;;
3011
	      *) continue ;;
3012
	      esac
3013
	      case " $deplibs " in
3014
	      *" $path "*) ;;
3015
	      *) deplibs="$path $deplibs" ;;
3016
	      esac
3017
	      case " $deplibs " in
3018
	      *" $depdepl "*) ;;
3019
	      *) deplibs="$depdepl $deplibs" ;;
3020
	      esac
3021
	    done
3022
	  fi # link_all_deplibs != no
3023
	fi # linkmode = lib
3024
      done # for deplib in $libs
3025
      dependency_libs="$newdependency_libs"
3026
      if test "$pass" = dlpreopen; then
3027
	# Link the dlpreopened libraries before other libraries
3028
	for deplib in $save_deplibs; do
3029
	  deplibs="$deplib $deplibs"
3030
	done
3031
      fi
3032
      if test "$pass" != dlopen; then
3033
	if test "$pass" != conv; then
3034
	  # Make sure lib_search_path contains only unique directories.
3035
	  lib_search_path=
3036
	  for dir in $newlib_search_path; do
3037
	    case "$lib_search_path " in
3038
	    *" $dir "*) ;;
3039
	    *) lib_search_path="$lib_search_path $dir" ;;
3040
	    esac
3041
	  done
3042
	  newlib_search_path=
3043
	fi
3044

    
3045
	if test "$linkmode,$pass" != "prog,link"; then
3046
	  vars="deplibs"
3047
	else
3048
	  vars="compile_deplibs finalize_deplibs"
3049
	fi
3050
	for var in $vars dependency_libs; do
3051
	  # Add libraries to $var in reverse order
3052
	  eval tmp_libs=\"\$$var\"
3053
	  new_libs=
3054
	  for deplib in $tmp_libs; do
3055
	    # FIXME: Pedantically, this is the right thing to do, so
3056
	    #        that some nasty dependency loop isn't accidentally
3057
	    #        broken:
3058
	    #new_libs="$deplib $new_libs"
3059
	    # Pragmatically, this seems to cause very few problems in
3060
	    # practice:
3061
	    case $deplib in
3062
	    -L*) new_libs="$deplib $new_libs" ;;
3063
	    -R*) ;;
3064
	    *)
3065
	      # And here is the reason: when a library appears more
3066
	      # than once as an explicit dependence of a library, or
3067
	      # is implicitly linked in more than once by the
3068
	      # compiler, it is considered special, and multiple
3069
	      # occurrences thereof are not removed.  Compare this
3070
	      # with having the same library being listed as a
3071
	      # dependency of multiple other libraries: in this case,
3072
	      # we know (pedantically, we assume) the library does not
3073
	      # need to be listed more than once, so we keep only the
3074
	      # last copy.  This is not always right, but it is rare
3075
	      # enough that we require users that really mean to play
3076
	      # such unportable linking tricks to link the library
3077
	      # using -Wl,-lname, so that libtool does not consider it
3078
	      # for duplicate removal.
3079
	      case " $specialdeplibs " in
3080
	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
3081
	      *)
3082
		case " $new_libs " in
3083
		*" $deplib "*) ;;
3084
		*) new_libs="$deplib $new_libs" ;;
3085
		esac
3086
		;;
3087
	      esac
3088
	      ;;
3089
	    esac
3090
	  done
3091
	  tmp_libs=
3092
	  for deplib in $new_libs; do
3093
	    case $deplib in
3094
	    -L*)
3095
	      case " $tmp_libs " in
3096
	      *" $deplib "*) ;;
3097
	      *) tmp_libs="$tmp_libs $deplib" ;;
3098
	      esac
3099
	      ;;
3100
	    *) tmp_libs="$tmp_libs $deplib" ;;
3101
	    esac
3102
	  done
3103
	  eval $var=\"$tmp_libs\"
3104
	done # for var
3105
      fi
3106
      # Last step: remove runtime libs from dependency_libs
3107
      # (they stay in deplibs)
3108
      tmp_libs=
3109
      for i in $dependency_libs ; do
3110
	case " $predeps $postdeps $compiler_lib_search_path " in
3111
	*" $i "*)
3112
	  i=""
3113
	  ;;
3114
	esac
3115
	if test -n "$i" ; then
3116
	  tmp_libs="$tmp_libs $i"
3117
	fi
3118
      done
3119
      dependency_libs=$tmp_libs
3120
    done # for pass
3121
    if test "$linkmode" = prog; then
3122
      dlfiles="$newdlfiles"
3123
      dlprefiles="$newdlprefiles"
3124
    fi
3125

    
3126
    case $linkmode in
3127
    oldlib)
3128
      case " $deplibs" in
3129
      *\ -l* | *\ -L*)
3130
	$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2 ;;
3131
      esac
3132

    
3133
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3134
	$echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
3135
      fi
3136

    
3137
      if test -n "$rpath"; then
3138
	$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
3139
      fi
3140

    
3141
      if test -n "$xrpath"; then
3142
	$echo "$modename: warning: \`-R' is ignored for archives" 1>&2
3143
      fi
3144

    
3145
      if test -n "$vinfo"; then
3146
	$echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
3147
      fi
3148

    
3149
      if test -n "$release"; then
3150
	$echo "$modename: warning: \`-release' is ignored for archives" 1>&2
3151
      fi
3152

    
3153
      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
3154
	$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
3155
      fi
3156

    
3157
      # Now set the variables for building old libraries.
3158
      build_libtool_libs=no
3159
      oldlibs="$output"
3160
      objs="$objs$old_deplibs"
3161
      ;;
3162

    
3163
    lib)
3164
      # Make sure we only generate libraries of the form `libNAME.la'.
3165
      case $outputname in
3166
      lib*)
3167
	name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
3168
	eval shared_ext=\"$shrext_cmds\"
3169
	eval libname=\"$libname_spec\"
3170
	;;
3171
      *)
3172
	if test "$module" = no; then
3173
	  $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
3174
	  $echo "$help" 1>&2
3175
	  exit $EXIT_FAILURE
3176
	fi
3177
	if test "$need_lib_prefix" != no; then
3178
	  # Add the "lib" prefix for modules if required
3179
	  name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3180
	  eval shared_ext=\"$shrext_cmds\"
3181
	  eval libname=\"$libname_spec\"
3182
	else
3183
	  libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
3184
	fi
3185
	;;
3186
      esac
3187

    
3188
      if test -n "$objs"; then
3189
	if test "$deplibs_check_method" != pass_all; then
3190
	  $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
3191
	  exit $EXIT_FAILURE
3192
	else
3193
	  $echo
3194
	  $echo "*** Warning: Linking the shared library $output against the non-libtool"
3195
	  $echo "*** objects $objs is not portable!"
3196
	  libobjs="$libobjs $objs"
3197
	fi
3198
      fi
3199

    
3200
      if test "$dlself" != no; then
3201
	$echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
3202
      fi
3203

    
3204
      set dummy $rpath
3205
      if test "$#" -gt 2; then
3206
	$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
3207
      fi
3208
      install_libdir="$2"
3209

    
3210
      oldlibs=
3211
      if test -z "$rpath"; then
3212
	if test "$build_libtool_libs" = yes; then
3213
	  # Building a libtool convenience library.
3214
	  # Some compilers have problems with a `.al' extension so
3215
	  # convenience libraries should have the same extension an
3216
	  # archive normally would.
3217
	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
3218
	  build_libtool_libs=convenience
3219
	  build_old_libs=yes
3220
	fi
3221

    
3222
	if test -n "$vinfo"; then
3223
	  $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3224
	fi
3225

    
3226
	if test -n "$release"; then
3227
	  $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
3228
	fi
3229
      else
3230

    
3231
	# Parse the version information argument.
3232
	save_ifs="$IFS"; IFS=':'
3233
	set dummy $vinfo 0 0 0
3234
	IFS="$save_ifs"
3235

    
3236
	if test -n "$8"; then
3237
	  $echo "$modename: too many parameters to \`-version-info'" 1>&2
3238
	  $echo "$help" 1>&2
3239
	  exit $EXIT_FAILURE
3240
	fi
3241

    
3242
	# convert absolute version numbers to libtool ages
3243
	# this retains compatibility with .la files and attempts
3244
	# to make the code below a bit more comprehensible
3245

    
3246
	case $vinfo_number in
3247
	yes)
3248
	  number_major="$2"
3249
	  number_minor="$3"
3250
	  number_revision="$4"
3251
	  #
3252
	  # There are really only two kinds -- those that
3253
	  # use the current revision as the major version
3254
	  # and those that subtract age and use age as
3255
	  # a minor version.  But, then there is irix
3256
	  # which has an extra 1 added just for fun
3257
	  #
3258
	  case $version_type in
3259
	  darwin|linux|osf|windows|none)
3260
	    current=`expr $number_major + $number_minor`
3261
	    age="$number_minor"
3262
	    revision="$number_revision"
3263
	    ;;
3264
	  freebsd-aout|freebsd-elf|sunos)
3265
	    current="$number_major"
3266
	    revision="$number_minor"
3267
	    age="0"
3268
	    ;;
3269
	  irix|nonstopux)
3270
	    current=`expr $number_major + $number_minor`
3271
	    age="$number_minor"
3272
	    revision="$number_minor"
3273
	    lt_irix_increment=no
3274
	    ;;
3275
	  *)
3276
	    $echo "$modename: unknown library version type \`$version_type'" 1>&2
3277
	    $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3278
	    exit $EXIT_FAILURE
3279
	    ;;
3280
	  esac
3281
	  ;;
3282
	no)
3283
	  current="$2"
3284
	  revision="$3"
3285
	  age="$4"
3286
	  ;;
3287
	esac
3288

    
3289
	# Check that each of the things are valid numbers.
3290
	case $current in
3291
	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]) ;;
3292
	*)
3293
	  $echo "$modename: CURRENT \`$current' must be a nonnegative integer" 1>&2
3294
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3295
	  exit $EXIT_FAILURE
3296
	  ;;
3297
	esac
3298

    
3299
	case $revision in
3300
	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]) ;;
3301
	*)
3302
	  $echo "$modename: REVISION \`$revision' must be a nonnegative integer" 1>&2
3303
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3304
	  exit $EXIT_FAILURE
3305
	  ;;
3306
	esac
3307

    
3308
	case $age in
3309
	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]) ;;
3310
	*)
3311
	  $echo "$modename: AGE \`$age' must be a nonnegative integer" 1>&2
3312
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3313
	  exit $EXIT_FAILURE
3314
	  ;;
3315
	esac
3316

    
3317
	if test "$age" -gt "$current"; then
3318
	  $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
3319
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
3320
	  exit $EXIT_FAILURE
3321
	fi
3322

    
3323
	# Calculate the version variables.
3324
	major=
3325
	versuffix=
3326
	verstring=
3327
	case $version_type in
3328
	none) ;;
3329

    
3330
	darwin)
3331
	  # Like Linux, but with the current version available in
3332
	  # verstring for coding it into the library header
3333
	  major=.`expr $current - $age`
3334
	  versuffix="$major.$age.$revision"
3335
	  # Darwin ld doesn't like 0 for these options...
3336
	  minor_current=`expr $current + 1`
3337
	  xlcverstring="${wl}-compatibility_version ${wl}$minor_current ${wl}-current_version ${wl}$minor_current.$revision"
3338
	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
3339
	  ;;
3340

    
3341
	freebsd-aout)
3342
	  major=".$current"
3343
	  versuffix=".$current.$revision";
3344
	  ;;
3345

    
3346
	freebsd-elf)
3347
	  major=".$current"
3348
	  versuffix=".$current";
3349
	  ;;
3350

    
3351
	irix | nonstopux)
3352
	  if test "X$lt_irix_increment" = "Xno"; then
3353
	    major=`expr $current - $age`
3354
	  else
3355
	    major=`expr $current - $age + 1`
3356
	  fi
3357
	  case $version_type in
3358
	    nonstopux) verstring_prefix=nonstopux ;;
3359
	    *)         verstring_prefix=sgi ;;
3360
	  esac
3361
	  verstring="$verstring_prefix$major.$revision"
3362

    
3363
	  # Add in all the interfaces that we are compatible with.
3364
	  loop=$revision
3365
	  while test "$loop" -ne 0; do
3366
	    iface=`expr $revision - $loop`
3367
	    loop=`expr $loop - 1`
3368
	    verstring="$verstring_prefix$major.$iface:$verstring"
3369
	  done
3370

    
3371
	  # Before this point, $major must not contain `.'.
3372
	  major=.$major
3373
	  versuffix="$major.$revision"
3374
	  ;;
3375

    
3376
	linux)
3377
	  major=.`expr $current - $age`
3378
	  versuffix="$major.$age.$revision"
3379
	  ;;
3380

    
3381
	osf)
3382
	  major=.`expr $current - $age`
3383
	  versuffix=".$current.$age.$revision"
3384
	  verstring="$current.$age.$revision"
3385

    
3386
	  # Add in all the interfaces that we are compatible with.
3387
	  loop=$age
3388
	  while test "$loop" -ne 0; do
3389
	    iface=`expr $current - $loop`
3390
	    loop=`expr $loop - 1`
3391
	    verstring="$verstring:${iface}.0"
3392
	  done
3393

    
3394
	  # Make executables depend on our current version.
3395
	  verstring="$verstring:${current}.0"
3396
	  ;;
3397

    
3398
	sunos)
3399
	  major=".$current"
3400
	  versuffix=".$current.$revision"
3401
	  ;;
3402

    
3403
	windows)
3404
	  # Use '-' rather than '.', since we only want one
3405
	  # extension on DOS 8.3 filesystems.
3406
	  major=`expr $current - $age`
3407
	  versuffix="-$major"
3408
	  ;;
3409

    
3410
	*)
3411
	  $echo "$modename: unknown library version type \`$version_type'" 1>&2
3412
	  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3413
	  exit $EXIT_FAILURE
3414
	  ;;
3415
	esac
3416

    
3417
	# Clear the version info if we defaulted, and they specified a release.
3418
	if test -z "$vinfo" && test -n "$release"; then
3419
	  major=
3420
	  case $version_type in
3421
	  darwin)
3422
	    # we can't check for "0.0" in archive_cmds due to quoting
3423
	    # problems, so we reset it completely
3424
	    verstring=
3425
	    ;;
3426
	  *)
3427
	    verstring="0.0"
3428
	    ;;
3429
	  esac
3430
	  if test "$need_version" = no; then
3431
	    versuffix=
3432
	  else
3433
	    versuffix=".0.0"
3434
	  fi
3435
	fi
3436

    
3437
	# Remove version info from name if versioning should be avoided
3438
	if test "$avoid_version" = yes && test "$need_version" = no; then
3439
	  major=
3440
	  versuffix=
3441
	  verstring=""
3442
	fi
3443

    
3444
	# Check to see if the archive will have undefined symbols.
3445
	if test "$allow_undefined" = yes; then
3446
	  if test "$allow_undefined_flag" = unsupported; then
3447
	    $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3448
	    build_libtool_libs=no
3449
	    build_old_libs=yes
3450
	  fi
3451
	else
3452
	  # Don't allow undefined symbols.
3453
	  allow_undefined_flag="$no_undefined_flag"
3454
	fi
3455
      fi
3456

    
3457
      if test "$mode" != relink; then
3458
	# Remove our outputs, but don't remove object files since they
3459
	# may have been created when compiling PIC objects.
3460
	removelist=
3461
	tempremovelist=`$echo "$output_objdir/*"`
3462
	for p in $tempremovelist; do
3463
	  case $p in
3464
	    *.$objext)
3465
	       ;;
3466
	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3467
	       if test "X$precious_files_regex" != "X"; then
3468
	         if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3469
	         then
3470
		   continue
3471
		 fi
3472
	       fi
3473
	       removelist="$removelist $p"
3474
	       ;;
3475
	    *) ;;
3476
	  esac
3477
	done
3478
	if test -n "$removelist"; then
3479
	  $show "${rm}r $removelist"
3480
	  $run ${rm}r $removelist
3481
	fi
3482
      fi
3483

    
3484
      # Now set the variables for building old libraries.
3485
      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3486
	oldlibs="$oldlibs $output_objdir/$libname.$libext"
3487

    
3488
	# Transform .lo files to .o files.
3489
	oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3490
      fi
3491

    
3492
      # Eliminate all temporary directories.
3493
      #for path in $notinst_path; do
3494
      #	lib_search_path=`$echo "$lib_search_path " | ${SED} -e "s% $path % %g"`
3495
      #	deplibs=`$echo "$deplibs " | ${SED} -e "s% -L$path % %g"`
3496
      #	dependency_libs=`$echo "$dependency_libs " | ${SED} -e "s% -L$path % %g"`
3497
      #done
3498

    
3499
      if test -n "$xrpath"; then
3500
	# If the user specified any rpath flags, then add them.
3501
	temp_xrpath=
3502
	for libdir in $xrpath; do
3503
	  temp_xrpath="$temp_xrpath -R$libdir"
3504
	  case "$finalize_rpath " in
3505
	  *" $libdir "*) ;;
3506
	  *) finalize_rpath="$finalize_rpath $libdir" ;;
3507
	  esac
3508
	done
3509
	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3510
	  dependency_libs="$temp_xrpath $dependency_libs"
3511
	fi
3512
      fi
3513

    
3514
      # Make sure dlfiles contains only unique files that won't be dlpreopened
3515
      old_dlfiles="$dlfiles"
3516
      dlfiles=
3517
      for lib in $old_dlfiles; do
3518
	case " $dlprefiles $dlfiles " in
3519
	*" $lib "*) ;;
3520
	*) dlfiles="$dlfiles $lib" ;;
3521
	esac
3522
      done
3523

    
3524
      # Make sure dlprefiles contains only unique files
3525
      old_dlprefiles="$dlprefiles"
3526
      dlprefiles=
3527
      for lib in $old_dlprefiles; do
3528
	case "$dlprefiles " in
3529
	*" $lib "*) ;;
3530
	*) dlprefiles="$dlprefiles $lib" ;;
3531
	esac
3532
      done
3533

    
3534
      if test "$build_libtool_libs" = yes; then
3535
	if test -n "$rpath"; then
3536
	  case $host in
3537
	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3538
	    # these systems don't actually have a c library (as such)!
3539
	    ;;
3540
	  *-*-rhapsody* | *-*-darwin1.[012])
3541
	    # Rhapsody C library is in the System framework
3542
	    deplibs="$deplibs -framework System"
3543
	    ;;
3544
	  *-*-netbsd*)
3545
	    # Don't link with libc until the a.out ld.so is fixed.
3546
	    ;;
3547
	  *-*-openbsd* | *-*-freebsd* | *-*-dragonfly*)
3548
	    # Do not include libc due to us having libc/libc_r.
3549
	    ;;
3550
	  *-*-sco3.2v5* | *-*-sco5v6*)
3551
	    # Causes problems with __ctype
3552
	    ;;
3553
	  *-*-sysv4.2uw2* | *-*-sysv5* | *-*-unixware* | *-*-OpenUNIX*)
3554
	    # Compiler inserts libc in the correct place for threads to work
3555
	    ;;
3556
 	  *)
3557
	    # Add libc to deplibs on all other systems if necessary.
3558
	    if test "$build_libtool_need_lc" = "yes"; then
3559
	      deplibs="$deplibs -lc"
3560
	    fi
3561
	    ;;
3562
	  esac
3563
	fi
3564

    
3565
	# Transform deplibs into only deplibs that can be linked in shared.
3566
	name_save=$name
3567
	libname_save=$libname
3568
	release_save=$release
3569
	versuffix_save=$versuffix
3570
	major_save=$major
3571
	# I'm not sure if I'm treating the release correctly.  I think
3572
	# release should show up in the -l (ie -lgmp5) so we don't want to
3573
	# add it in twice.  Is that correct?
3574
	release=""
3575
	versuffix=""
3576
	major=""
3577
	newdeplibs=
3578
	droppeddeps=no
3579
	case $deplibs_check_method in
3580
	pass_all)
3581
	  # Don't check for shared/static.  Everything works.
3582
	  # This might be a little naive.  We might want to check
3583
	  # whether the library exists or not.  But this is on
3584
	  # osf3 & osf4 and I'm not really sure... Just
3585
	  # implementing what was already the behavior.
3586
	  newdeplibs=$deplibs
3587
	  ;;
3588
	test_compile)
3589
	  # This code stresses the "libraries are programs" paradigm to its
3590
	  # limits. Maybe even breaks it.  We compile a program, linking it
3591
	  # against the deplibs as a proxy for the library.  Then we can check
3592
	  # whether they linked in statically or dynamically with ldd.
3593
	  $rm conftest.c
3594
	  cat > conftest.c <<EOF
3595
	  int main() { return 0; }
3596
EOF
3597
	  $rm conftest
3598
	  if $LTCC $LTCFLAGS -o conftest conftest.c $deplibs; then
3599
	    ldd_output=`ldd conftest`
3600
	    for i in $deplibs; do
3601
	      name=`expr $i : '-l\(.*\)'`
3602
	      # If $name is empty we are operating on a -L argument.
3603
              if test "$name" != "" && test "$name" != "0"; then
3604
		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3605
		  case " $predeps $postdeps " in
3606
		  *" $i "*)
3607
		    newdeplibs="$newdeplibs $i"
3608
		    i=""
3609
		    ;;
3610
		  esac
3611
	        fi
3612
		if test -n "$i" ; then
3613
		  libname=`eval \\$echo \"$libname_spec\"`
3614
		  deplib_matches=`eval \\$echo \"$library_names_spec\"`
3615
		  set dummy $deplib_matches
3616
		  deplib_match=$2
3617
		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3618
		    newdeplibs="$newdeplibs $i"
3619
		  else
3620
		    droppeddeps=yes
3621
		    $echo
3622
		    $echo "*** Warning: dynamic linker does not accept needed library $i."
3623
		    $echo "*** I have the capability to make that library automatically link in when"
3624
		    $echo "*** you link to this library.  But I can only do this if you have a"
3625
		    $echo "*** shared version of the library, which I believe you do not have"
3626
		    $echo "*** because a test_compile did reveal that the linker did not use it for"
3627
		    $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3628
		  fi
3629
		fi
3630
	      else
3631
		newdeplibs="$newdeplibs $i"
3632
	      fi
3633
	    done
3634
	  else
3635
	    # Error occurred in the first compile.  Let's try to salvage
3636
	    # the situation: Compile a separate program for each library.
3637
	    for i in $deplibs; do
3638
	      name=`expr $i : '-l\(.*\)'`
3639
	      # If $name is empty we are operating on a -L argument.
3640
              if test "$name" != "" && test "$name" != "0"; then
3641
		$rm conftest
3642
		if $LTCC $LTCFLAGS -o conftest conftest.c $i; then
3643
		  ldd_output=`ldd conftest`
3644
		  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3645
		    case " $predeps $postdeps " in
3646
		    *" $i "*)
3647
		      newdeplibs="$newdeplibs $i"
3648
		      i=""
3649
		      ;;
3650
		    esac
3651
		  fi
3652
		  if test -n "$i" ; then
3653
		    libname=`eval \\$echo \"$libname_spec\"`
3654
		    deplib_matches=`eval \\$echo \"$library_names_spec\"`
3655
		    set dummy $deplib_matches
3656
		    deplib_match=$2
3657
		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3658
		      newdeplibs="$newdeplibs $i"
3659
		    else
3660
		      droppeddeps=yes
3661
		      $echo
3662
		      $echo "*** Warning: dynamic linker does not accept needed library $i."
3663
		      $echo "*** I have the capability to make that library automatically link in when"
3664
		      $echo "*** you link to this library.  But I can only do this if you have a"
3665
		      $echo "*** shared version of the library, which you do not appear to have"
3666
		      $echo "*** because a test_compile did reveal that the linker did not use this one"
3667
		      $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3668
		    fi
3669
		  fi
3670
		else
3671
		  droppeddeps=yes
3672
		  $echo
3673
		  $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3674
		  $echo "*** make it link in!  You will probably need to install it or some"
3675
		  $echo "*** library that it depends on before this library will be fully"
3676
		  $echo "*** functional.  Installing it before continuing would be even better."
3677
		fi
3678
	      else
3679
		newdeplibs="$newdeplibs $i"
3680
	      fi
3681
	    done
3682
	  fi
3683
	  ;;
3684
	file_magic*)
3685
	  set dummy $deplibs_check_method
3686
	  file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3687
	  for a_deplib in $deplibs; do
3688
	    name=`expr $a_deplib : '-l\(.*\)'`
3689
	    # If $name is empty we are operating on a -L argument.
3690
            if test "$name" != "" && test  "$name" != "0"; then
3691
	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3692
		case " $predeps $postdeps " in
3693
		*" $a_deplib "*)
3694
		  newdeplibs="$newdeplibs $a_deplib"
3695
		  a_deplib=""
3696
		  ;;
3697
		esac
3698
	      fi
3699
	      if test -n "$a_deplib" ; then
3700
		libname=`eval \\$echo \"$libname_spec\"`
3701
		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3702
		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3703
		  for potent_lib in $potential_libs; do
3704
		      # Follow soft links.
3705
		      if ls -lLd "$potent_lib" 2>/dev/null \
3706
			 | grep " -> " >/dev/null; then
3707
			continue
3708
		      fi
3709
		      # The statement above tries to avoid entering an
3710
		      # endless loop below, in case of cyclic links.
3711
		      # We might still enter an endless loop, since a link
3712
		      # loop can be closed while we follow links,
3713
		      # but so what?
3714
		      potlib="$potent_lib"
3715
		      while test -h "$potlib" 2>/dev/null; do
3716
			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3717
			case $potliblink in
3718
			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3719
			*) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3720
			esac
3721
		      done
3722
		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3723
			 | ${SED} 10q \
3724
			 | $EGREP "$file_magic_regex" > /dev/null; then
3725
			newdeplibs="$newdeplibs $a_deplib"
3726
			a_deplib=""
3727
			break 2
3728
		      fi
3729
		  done
3730
		done
3731
	      fi
3732
	      if test -n "$a_deplib" ; then
3733
		droppeddeps=yes
3734
		$echo
3735
		$echo "*** Warning: linker path does not have real file for library $a_deplib."
3736
		$echo "*** I have the capability to make that library automatically link in when"
3737
		$echo "*** you link to this library.  But I can only do this if you have a"
3738
		$echo "*** shared version of the library, which you do not appear to have"
3739
		$echo "*** because I did check the linker path looking for a file starting"
3740
		if test -z "$potlib" ; then
3741
		  $echo "*** with $libname but no candidates were found. (...for file magic test)"
3742
		else
3743
		  $echo "*** with $libname and none of the candidates passed a file format test"
3744
		  $echo "*** using a file magic. Last file checked: $potlib"
3745
		fi
3746
	      fi
3747
	    else
3748
	      # Add a -L argument.
3749
	      newdeplibs="$newdeplibs $a_deplib"
3750
	    fi
3751
	  done # Gone through all deplibs.
3752
	  ;;
3753
	match_pattern*)
3754
	  set dummy $deplibs_check_method
3755
	  match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3756
	  for a_deplib in $deplibs; do
3757
	    name=`expr $a_deplib : '-l\(.*\)'`
3758
	    # If $name is empty we are operating on a -L argument.
3759
	    if test -n "$name" && test "$name" != "0"; then
3760
	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3761
		case " $predeps $postdeps " in
3762
		*" $a_deplib "*)
3763
		  newdeplibs="$newdeplibs $a_deplib"
3764
		  a_deplib=""
3765
		  ;;
3766
		esac
3767
	      fi
3768
	      if test -n "$a_deplib" ; then
3769
		libname=`eval \\$echo \"$libname_spec\"`
3770
		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3771
		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3772
		  for potent_lib in $potential_libs; do
3773
		    potlib="$potent_lib" # see symlink-check above in file_magic test
3774
		    if eval $echo \"$potent_lib\" 2>/dev/null \
3775
		        | ${SED} 10q \
3776
		        | $EGREP "$match_pattern_regex" > /dev/null; then
3777
		      newdeplibs="$newdeplibs $a_deplib"
3778
		      a_deplib=""
3779
		      break 2
3780
		    fi
3781
		  done
3782
		done
3783
	      fi
3784
	      if test -n "$a_deplib" ; then
3785
		droppeddeps=yes
3786
		$echo
3787
		$echo "*** Warning: linker path does not have real file for library $a_deplib."
3788
		$echo "*** I have the capability to make that library automatically link in when"
3789
		$echo "*** you link to this library.  But I can only do this if you have a"
3790
		$echo "*** shared version of the library, which you do not appear to have"
3791
		$echo "*** because I did check the linker path looking for a file starting"
3792
		if test -z "$potlib" ; then
3793
		  $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3794
		else
3795
		  $echo "*** with $libname and none of the candidates passed a file format test"
3796
		  $echo "*** using a regex pattern. Last file checked: $potlib"
3797
		fi
3798
	      fi
3799
	    else
3800
	      # Add a -L argument.
3801
	      newdeplibs="$newdeplibs $a_deplib"
3802
	    fi
3803
	  done # Gone through all deplibs.
3804
	  ;;
3805
	none | unknown | *)
3806
	  newdeplibs=""
3807
	  tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3808
	    -e 's/ -[LR][^ ]*//g'`
3809
	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3810
	    for i in $predeps $postdeps ; do
3811
	      # can't use Xsed below, because $i might contain '/'
3812
	      tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3813
	    done
3814
	  fi
3815
	  if $echo "X $tmp_deplibs" | $Xsed -e 's/[ 	]//g' \
3816
	    | grep . >/dev/null; then
3817
	    $echo
3818
	    if test "X$deplibs_check_method" = "Xnone"; then
3819
	      $echo "*** Warning: inter-library dependencies are not supported in this platform."
3820
	    else
3821
	      $echo "*** Warning: inter-library dependencies are not known to be supported."
3822
	    fi
3823
	    $echo "*** All declared inter-library dependencies are being dropped."
3824
	    droppeddeps=yes
3825
	  fi
3826
	  ;;
3827
	esac
3828
	versuffix=$versuffix_save
3829
	major=$major_save
3830
	release=$release_save
3831
	libname=$libname_save
3832
	name=$name_save
3833

    
3834
	case $host in
3835
	*-*-rhapsody* | *-*-darwin1.[012])
3836
	  # On Rhapsody replace the C library is the System framework
3837
	  newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3838
	  ;;
3839
	esac
3840

    
3841
	if test "$droppeddeps" = yes; then
3842
	  if test "$module" = yes; then
3843
	    $echo
3844
	    $echo "*** Warning: libtool could not satisfy all declared inter-library"
3845
	    $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3846
	    $echo "*** a static module, that should work as long as the dlopening"
3847
	    $echo "*** application is linked with the -dlopen flag."
3848
	    if test -z "$global_symbol_pipe"; then
3849
	      $echo
3850
	      $echo "*** However, this would only work if libtool was able to extract symbol"
3851
	      $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3852
	      $echo "*** not find such a program.  So, this module is probably useless."
3853
	      $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3854
	    fi
3855
	    if test "$build_old_libs" = no; then
3856
	      oldlibs="$output_objdir/$libname.$libext"
3857
	      build_libtool_libs=module
3858
	      build_old_libs=yes
3859
	    else
3860
	      build_libtool_libs=no
3861
	    fi
3862
	  else
3863
	    $echo "*** The inter-library dependencies that have been dropped here will be"
3864
	    $echo "*** automatically added whenever a program is linked with this library"
3865
	    $echo "*** or is declared to -dlopen it."
3866

    
3867
	    if test "$allow_undefined" = no; then
3868
	      $echo
3869
	      $echo "*** Since this library must not contain undefined symbols,"
3870
	      $echo "*** because either the platform does not support them or"
3871
	      $echo "*** it was explicitly requested with -no-undefined,"
3872
	      $echo "*** libtool will only create a static version of it."
3873
	      if test "$build_old_libs" = no; then
3874
		oldlibs="$output_objdir/$libname.$libext"
3875
		build_libtool_libs=module
3876
		build_old_libs=yes
3877
	      else
3878
		build_libtool_libs=no
3879
	      fi
3880
	    fi
3881
	  fi
3882
	fi
3883
	# Done checking deplibs!
3884
	deplibs=$newdeplibs
3885
      fi
3886

    
3887

    
3888
      # move library search paths that coincide with paths to not yet
3889
      # installed libraries to the beginning of the library search list
3890
      new_libs=
3891
      for path in $notinst_path; do
3892
	case " $new_libs " in
3893
	*" -L$path/$objdir "*) ;;
3894
	*)
3895
	  case " $deplibs " in
3896
	  *" -L$path/$objdir "*)
3897
	    new_libs="$new_libs -L$path/$objdir" ;;
3898
	  esac
3899
	  ;;
3900
	esac
3901
      done
3902
      for deplib in $deplibs; do
3903
	case $deplib in
3904
	-L*)
3905
	  case " $new_libs " in
3906
	  *" $deplib "*) ;;
3907
	  *) new_libs="$new_libs $deplib" ;;
3908
	  esac
3909
	  ;;
3910
	*) new_libs="$new_libs $deplib" ;;
3911
	esac
3912
      done
3913
      deplibs="$new_libs"
3914

    
3915

    
3916
      # All the library-specific variables (install_libdir is set above).
3917
      library_names=
3918
      old_library=
3919
      dlname=
3920

    
3921
      # Test again, we may have decided not to build it any more
3922
      if test "$build_libtool_libs" = yes; then
3923
	if test "$hardcode_into_libs" = yes; then
3924
	  # Hardcode the library paths
3925
	  hardcode_libdirs=
3926
	  dep_rpath=
3927
	  rpath="$finalize_rpath"
3928
	  test "$mode" != relink && rpath="$compile_rpath$rpath"
3929
	  for libdir in $rpath; do
3930
	    if test -n "$hardcode_libdir_flag_spec"; then
3931
	      if test -n "$hardcode_libdir_separator"; then
3932
		if test -z "$hardcode_libdirs"; then
3933
		  hardcode_libdirs="$libdir"
3934
		else
3935
		  # Just accumulate the unique libdirs.
3936
		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3937
		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3938
		    ;;
3939
		  *)
3940
		    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3941
		    ;;
3942
		  esac
3943
		fi
3944
	      else
3945
		eval flag=\"$hardcode_libdir_flag_spec\"
3946
		dep_rpath="$dep_rpath $flag"
3947
	      fi
3948
	    elif test -n "$runpath_var"; then
3949
	      case "$perm_rpath " in
3950
	      *" $libdir "*) ;;
3951
	      *) perm_rpath="$perm_rpath $libdir" ;;
3952
	      esac
3953
	    fi
3954
	  done
3955
	  # Substitute the hardcoded libdirs into the rpath.
3956
	  if test -n "$hardcode_libdir_separator" &&
3957
	     test -n "$hardcode_libdirs"; then
3958
	    libdir="$hardcode_libdirs"
3959
	    if test -n "$hardcode_libdir_flag_spec_ld"; then
3960
	      case $archive_cmds in
3961
	      *\$LD*) eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\" ;;
3962
	      *)      eval dep_rpath=\"$hardcode_libdir_flag_spec\" ;;
3963
	      esac
3964
	    else
3965
	      eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3966
	    fi
3967
	  fi
3968
	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
3969
	    # We should set the runpath_var.
3970
	    rpath=
3971
	    for dir in $perm_rpath; do
3972
	      rpath="$rpath$dir:"
3973
	    done
3974
	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3975
	  fi
3976
	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3977
	fi
3978

    
3979
	shlibpath="$finalize_shlibpath"
3980
	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3981
	if test -n "$shlibpath"; then
3982
	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3983
	fi
3984

    
3985
	# Get the real and link names of the library.
3986
	eval shared_ext=\"$shrext_cmds\"
3987
	eval library_names=\"$library_names_spec\"
3988
	set dummy $library_names
3989
	realname="$2"
3990
	shift; shift
3991

    
3992
	if test -n "$soname_spec"; then
3993
	  eval soname=\"$soname_spec\"
3994
	else
3995
	  soname="$realname"
3996
	fi
3997
	if test -z "$dlname"; then
3998
	  dlname=$soname
3999
	fi
4000

    
4001
	lib="$output_objdir/$realname"
4002
	linknames=
4003
	for link
4004
	do
4005
	  linknames="$linknames $link"
4006
	done
4007

    
4008
	# Use standard objects if they are pic
4009
	test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4010

    
4011
	# Prepare the list of exported symbols
4012
	if test -z "$export_symbols"; then
4013
	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
4014
	    $show "generating symbol list for \`$libname.la'"
4015
	    export_symbols="$output_objdir/$libname.exp"
4016
	    $run $rm $export_symbols
4017
	    cmds=$export_symbols_cmds
4018
	    save_ifs="$IFS"; IFS='~'
4019
	    for cmd in $cmds; do
4020
	      IFS="$save_ifs"
4021
	      eval cmd=\"$cmd\"
4022
	      if len=`expr "X$cmd" : ".*"` &&
4023
	       test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
4024
	        $show "$cmd"
4025
	        $run eval "$cmd" || exit $?
4026
	        skipped_export=false
4027
	      else
4028
	        # The command line is too long to execute in one step.
4029
	        $show "using reloadable object file for export list..."
4030
	        skipped_export=:
4031
		# Break out early, otherwise skipped_export may be
4032
		# set to false by a later but shorter cmd.
4033
		break
4034
	      fi
4035
	    done
4036
	    IFS="$save_ifs"
4037
	    if test -n "$export_symbols_regex"; then
4038
	      $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
4039
	      $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
4040
	      $show "$mv \"${export_symbols}T\" \"$export_symbols\""
4041
	      $run eval '$mv "${export_symbols}T" "$export_symbols"'
4042
	    fi
4043
	  fi
4044
	fi
4045

    
4046
	if test -n "$export_symbols" && test -n "$include_expsyms"; then
4047
	  $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
4048
	fi
4049

    
4050
	tmp_deplibs=
4051
	for test_deplib in $deplibs; do
4052
		case " $convenience " in
4053
		*" $test_deplib "*) ;;
4054
		*)
4055
			tmp_deplibs="$tmp_deplibs $test_deplib"
4056
			;;
4057
		esac
4058
	done
4059
	deplibs="$tmp_deplibs"
4060

    
4061
	if test -n "$convenience"; then
4062
	  if test -n "$whole_archive_flag_spec"; then
4063
	    save_libobjs=$libobjs
4064
	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
4065
	  else
4066
	    gentop="$output_objdir/${outputname}x"
4067
	    generated="$generated $gentop"
4068

    
4069
	    func_extract_archives $gentop $convenience
4070
	    libobjs="$libobjs $func_extract_archives_result"
4071
	  fi
4072
	fi
4073
	
4074
	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
4075
	  eval flag=\"$thread_safe_flag_spec\"
4076
	  linker_flags="$linker_flags $flag"
4077
	fi
4078

    
4079
	# Make a backup of the uninstalled library when relinking
4080
	if test "$mode" = relink; then
4081
	  $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
4082
	fi
4083

    
4084
	# Do each of the archive commands.
4085
	if test "$module" = yes && test -n "$module_cmds" ; then
4086
	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
4087
	    eval test_cmds=\"$module_expsym_cmds\"
4088
	    cmds=$module_expsym_cmds
4089
	  else
4090
	    eval test_cmds=\"$module_cmds\"
4091
	    cmds=$module_cmds
4092
	  fi
4093
	else
4094
	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4095
	  eval test_cmds=\"$archive_expsym_cmds\"
4096
	  cmds=$archive_expsym_cmds
4097
	else
4098
	  eval test_cmds=\"$archive_cmds\"
4099
	  cmds=$archive_cmds
4100
	  fi
4101
	fi
4102

    
4103
	if test "X$skipped_export" != "X:" &&
4104
	   len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4105
	   test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
4106
	  :
4107
	else
4108
	  # The command line is too long to link in one step, link piecewise.
4109
	  $echo "creating reloadable object files..."
4110

    
4111
	  # Save the value of $output and $libobjs because we want to
4112
	  # use them later.  If we have whole_archive_flag_spec, we
4113
	  # want to use save_libobjs as it was before
4114
	  # whole_archive_flag_spec was expanded, because we can't
4115
	  # assume the linker understands whole_archive_flag_spec.
4116
	  # This may have to be revisited, in case too many
4117
	  # convenience libraries get linked in and end up exceeding
4118
	  # the spec.
4119
	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
4120
	    save_libobjs=$libobjs
4121
	  fi
4122
	  save_output=$output
4123
	  output_la=`$echo "X$output" | $Xsed -e "$basename"`
4124

    
4125
	  # Clear the reloadable object creation command queue and
4126
	  # initialize k to one.
4127
	  test_cmds=
4128
	  concat_cmds=
4129
	  objlist=
4130
	  delfiles=
4131
	  last_robj=
4132
	  k=1
4133
	  output=$output_objdir/$output_la-${k}.$objext
4134
	  # Loop over the list of objects to be linked.
4135
	  for obj in $save_libobjs
4136
	  do
4137
	    eval test_cmds=\"$reload_cmds $objlist $last_robj\"
4138
	    if test "X$objlist" = X ||
4139
	       { len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
4140
		 test "$len" -le "$max_cmd_len"; }; then
4141
	      objlist="$objlist $obj"
4142
	    else
4143
	      # The command $test_cmds is almost too long, add a
4144
	      # command to the queue.
4145
	      if test "$k" -eq 1 ; then
4146
		# The first file doesn't have a previous command to add.
4147
		eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
4148
	      else
4149
		# All subsequent reloadable object files will link in
4150
		# the last one created.
4151
		eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
4152
	      fi
4153
	      last_robj=$output_objdir/$output_la-${k}.$objext
4154
	      k=`expr $k + 1`
4155
	      output=$output_objdir/$output_la-${k}.$objext
4156
	      objlist=$obj
4157
	      len=1
4158
	    fi
4159
	  done
4160
	  # Handle the remaining objects by creating one last
4161
	  # reloadable object file.  All subsequent reloadable object
4162
	  # files will link in the last one created.
4163
	  test -z "$concat_cmds" || concat_cmds=$concat_cmds~
4164
	  eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
4165

    
4166
	  if ${skipped_export-false}; then
4167
	    $show "generating symbol list for \`$libname.la'"
4168
	    export_symbols="$output_objdir/$libname.exp"
4169
	    $run $rm $export_symbols
4170
	    libobjs=$output
4171
	    # Append the command to create the export file.
4172
	    eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
4173
          fi
4174

    
4175
	  # Set up a command to remove the reloadable object files
4176
	  # after they are used.
4177
	  i=0
4178
	  while test "$i" -lt "$k"
4179
	  do
4180
	    i=`expr $i + 1`
4181
	    delfiles="$delfiles $output_objdir/$output_la-${i}.$objext"
4182
	  done
4183

    
4184
	  $echo "creating a temporary reloadable object file: $output"
4185

    
4186
	  # Loop through the commands generated above and execute them.
4187
	  save_ifs="$IFS"; IFS='~'
4188
	  for cmd in $concat_cmds; do
4189
	    IFS="$save_ifs"
4190
	    $show "$cmd"
4191
	    $run eval "$cmd" || exit $?
4192
	  done
4193
	  IFS="$save_ifs"
4194

    
4195
	  libobjs=$output
4196
	  # Restore the value of output.
4197
	  output=$save_output
4198

    
4199
	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
4200
	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
4201
	  fi
4202
	  # Expand the library linking commands again to reset the
4203
	  # value of $libobjs for piecewise linking.
4204

    
4205
	  # Do each of the archive commands.
4206
	  if test "$module" = yes && test -n "$module_cmds" ; then
4207
	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
4208
	      cmds=$module_expsym_cmds
4209
	    else
4210
	      cmds=$module_cmds
4211
	    fi
4212
	  else
4213
	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
4214
	    cmds=$archive_expsym_cmds
4215
	  else
4216
	    cmds=$archive_cmds
4217
	    fi
4218
	  fi
4219

    
4220
	  # Append the command to remove the reloadable object files
4221
	  # to the just-reset $cmds.
4222
	  eval cmds=\"\$cmds~\$rm $delfiles\"
4223
	fi
4224
	save_ifs="$IFS"; IFS='~'
4225
	for cmd in $cmds; do
4226
	  IFS="$save_ifs"
4227
	  eval cmd=\"$cmd\"
4228
	  $show "$cmd"
4229
	  $run eval "$cmd" || {
4230
	    lt_exit=$?
4231

    
4232
	    # Restore the uninstalled library and exit
4233
	    if test "$mode" = relink; then
4234
	      $run eval '(cd $output_objdir && $rm ${realname}T && $mv ${realname}U $realname)'
4235
	    fi
4236

    
4237
	    exit $lt_exit
4238
	  }
4239
	done
4240
	IFS="$save_ifs"
4241

    
4242
	# Restore the uninstalled library and exit
4243
	if test "$mode" = relink; then
4244
	  $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
4245

    
4246
	  if test -n "$convenience"; then
4247
	    if test -z "$whole_archive_flag_spec"; then
4248
	      $show "${rm}r $gentop"
4249
	      $run ${rm}r "$gentop"
4250
	    fi
4251
	  fi
4252

    
4253
	  exit $EXIT_SUCCESS
4254
	fi
4255

    
4256
	# Create links to the real library.
4257
	for linkname in $linknames; do
4258
	  if test "$realname" != "$linkname"; then
4259
	    $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
4260
	    $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
4261
	  fi
4262
	done
4263

    
4264
	# If -module or -export-dynamic was specified, set the dlname.
4265
	if test "$module" = yes || test "$export_dynamic" = yes; then
4266
	  # On all known operating systems, these are identical.
4267
	  dlname="$soname"
4268
	fi
4269
      fi
4270
      ;;
4271

    
4272
    obj)
4273
      case " $deplibs" in
4274
      *\ -l* | *\ -L*)
4275
	$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2 ;;
4276
      esac
4277

    
4278
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4279
	$echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
4280
      fi
4281

    
4282
      if test -n "$rpath"; then
4283
	$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
4284
      fi
4285

    
4286
      if test -n "$xrpath"; then
4287
	$echo "$modename: warning: \`-R' is ignored for objects" 1>&2
4288
      fi
4289

    
4290
      if test -n "$vinfo"; then
4291
	$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
4292
      fi
4293

    
4294
      if test -n "$release"; then
4295
	$echo "$modename: warning: \`-release' is ignored for objects" 1>&2
4296
      fi
4297

    
4298
      case $output in
4299
      *.lo)
4300
	if test -n "$objs$old_deplibs"; then
4301
	  $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
4302
	  exit $EXIT_FAILURE
4303
	fi
4304
	libobj="$output"
4305
	obj=`$echo "X$output" | $Xsed -e "$lo2o"`
4306
	;;
4307
      *)
4308
	libobj=
4309
	obj="$output"
4310
	;;
4311
      esac
4312

    
4313
      # Delete the old objects.
4314
      $run $rm $obj $libobj
4315

    
4316
      # Objects from convenience libraries.  This assumes
4317
      # single-version convenience libraries.  Whenever we create
4318
      # different ones for PIC/non-PIC, this we'll have to duplicate
4319
      # the extraction.
4320
      reload_conv_objs=
4321
      gentop=
4322
      # reload_cmds runs $LD directly, so let us get rid of
4323
      # -Wl from whole_archive_flag_spec and hope we can get by with
4324
      # turning comma into space..
4325
      wl=
4326

    
4327
      if test -n "$convenience"; then
4328
	if test -n "$whole_archive_flag_spec"; then
4329
	  eval tmp_whole_archive_flags=\"$whole_archive_flag_spec\"
4330
	  reload_conv_objs=$reload_objs\ `$echo "X$tmp_whole_archive_flags" | $Xsed -e 's|,| |g'`
4331
	else
4332
	  gentop="$output_objdir/${obj}x"
4333
	  generated="$generated $gentop"
4334

    
4335
	  func_extract_archives $gentop $convenience
4336
	  reload_conv_objs="$reload_objs $func_extract_archives_result"
4337
	fi
4338
      fi
4339

    
4340
      # Create the old-style object.
4341
      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
4342

    
4343
      output="$obj"
4344
      cmds=$reload_cmds
4345
      save_ifs="$IFS"; IFS='~'
4346
      for cmd in $cmds; do
4347
	IFS="$save_ifs"
4348
	eval cmd=\"$cmd\"
4349
	$show "$cmd"
4350
	$run eval "$cmd" || exit $?
4351
      done
4352
      IFS="$save_ifs"
4353

    
4354
      # Exit if we aren't doing a library object file.
4355
      if test -z "$libobj"; then
4356
	if test -n "$gentop"; then
4357
	  $show "${rm}r $gentop"
4358
	  $run ${rm}r $gentop
4359
	fi
4360

    
4361
	exit $EXIT_SUCCESS
4362
      fi
4363

    
4364
      if test "$build_libtool_libs" != yes; then
4365
	if test -n "$gentop"; then
4366
	  $show "${rm}r $gentop"
4367
	  $run ${rm}r $gentop
4368
	fi
4369

    
4370
	# Create an invalid libtool object if no PIC, so that we don't
4371
	# accidentally link it into a program.
4372
	# $show "echo timestamp > $libobj"
4373
	# $run eval "echo timestamp > $libobj" || exit $?
4374
	exit $EXIT_SUCCESS
4375
      fi
4376

    
4377
      if test -n "$pic_flag" || test "$pic_mode" != default; then
4378
	# Only do commands if we really have different PIC objects.
4379
	reload_objs="$libobjs $reload_conv_objs"
4380
	output="$libobj"
4381
	cmds=$reload_cmds
4382
	save_ifs="$IFS"; IFS='~'
4383
	for cmd in $cmds; do
4384
	  IFS="$save_ifs"
4385
	  eval cmd=\"$cmd\"
4386
	  $show "$cmd"
4387
	  $run eval "$cmd" || exit $?
4388
	done
4389
	IFS="$save_ifs"
4390
      fi
4391

    
4392
      if test -n "$gentop"; then
4393
	$show "${rm}r $gentop"
4394
	$run ${rm}r $gentop
4395
      fi
4396

    
4397
      exit $EXIT_SUCCESS
4398
      ;;
4399

    
4400
    prog)
4401
      case $host in
4402
	*cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
4403
      esac
4404
      if test -n "$vinfo"; then
4405
	$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4406
      fi
4407

    
4408
      if test -n "$release"; then
4409
	$echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4410
      fi
4411

    
4412
      if test "$preload" = yes; then
4413
	if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4414
	   test "$dlopen_self_static" = unknown; then
4415
	  $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4416
	fi
4417
      fi
4418

    
4419
      case $host in
4420
      *-*-rhapsody* | *-*-darwin1.[012])
4421
	# On Rhapsody replace the C library is the System framework
4422
	compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4423
	finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4424
	;;
4425
      esac
4426

    
4427
      case $host in
4428
      *darwin*)
4429
        # Don't allow lazy linking, it breaks C++ global constructors
4430
        if test "$tagname" = CXX ; then
4431
        compile_command="$compile_command ${wl}-bind_at_load"
4432
        finalize_command="$finalize_command ${wl}-bind_at_load"
4433
        fi
4434
        ;;
4435
      esac
4436

    
4437

    
4438
      # move library search paths that coincide with paths to not yet
4439
      # installed libraries to the beginning of the library search list
4440
      new_libs=
4441
      for path in $notinst_path; do
4442
	case " $new_libs " in
4443
	*" -L$path/$objdir "*) ;;
4444
	*)
4445
	  case " $compile_deplibs " in
4446
	  *" -L$path/$objdir "*)
4447
	    new_libs="$new_libs -L$path/$objdir" ;;
4448
	  esac
4449
	  ;;
4450
	esac
4451
      done
4452
      for deplib in $compile_deplibs; do
4453
	case $deplib in
4454
	-L*)
4455
	  case " $new_libs " in
4456
	  *" $deplib "*) ;;
4457
	  *) new_libs="$new_libs $deplib" ;;
4458
	  esac
4459
	  ;;
4460
	*) new_libs="$new_libs $deplib" ;;
4461
	esac
4462
      done
4463
      compile_deplibs="$new_libs"
4464

    
4465

    
4466
      compile_command="$compile_command $compile_deplibs"
4467
      finalize_command="$finalize_command $finalize_deplibs"
4468

    
4469
      if test -n "$rpath$xrpath"; then
4470
	# If the user specified any rpath flags, then add them.
4471
	for libdir in $rpath $xrpath; do
4472
	  # This is the magic to use -rpath.
4473
	  case "$finalize_rpath " in
4474
	  *" $libdir "*) ;;
4475
	  *) finalize_rpath="$finalize_rpath $libdir" ;;
4476
	  esac
4477
	done
4478
      fi
4479

    
4480
      # Now hardcode the library paths
4481
      rpath=
4482
      hardcode_libdirs=
4483
      for libdir in $compile_rpath $finalize_rpath; do
4484
	if test -n "$hardcode_libdir_flag_spec"; then
4485
	  if test -n "$hardcode_libdir_separator"; then
4486
	    if test -z "$hardcode_libdirs"; then
4487
	      hardcode_libdirs="$libdir"
4488
	    else
4489
	      # Just accumulate the unique libdirs.
4490
	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4491
	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4492
		;;
4493
	      *)
4494
		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4495
		;;
4496
	      esac
4497
	    fi
4498
	  else
4499
	    eval flag=\"$hardcode_libdir_flag_spec\"
4500
	    rpath="$rpath $flag"
4501
	  fi
4502
	elif test -n "$runpath_var"; then
4503
	  case "$perm_rpath " in
4504
	  *" $libdir "*) ;;
4505
	  *) perm_rpath="$perm_rpath $libdir" ;;
4506
	  esac
4507
	fi
4508
	case $host in
4509
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4510
	  testbindir=`$echo "X$libdir" | $Xsed -e 's*/lib$*/bin*'`
4511
	  case :$dllsearchpath: in
4512
	  *":$libdir:"*) ;;
4513
	  *) dllsearchpath="$dllsearchpath:$libdir";;
4514
	  esac
4515
	  case :$dllsearchpath: in
4516
	  *":$testbindir:"*) ;;
4517
	  *) dllsearchpath="$dllsearchpath:$testbindir";;
4518
	  esac
4519
	  ;;
4520
	esac
4521
      done
4522
      # Substitute the hardcoded libdirs into the rpath.
4523
      if test -n "$hardcode_libdir_separator" &&
4524
	 test -n "$hardcode_libdirs"; then
4525
	libdir="$hardcode_libdirs"
4526
	eval rpath=\" $hardcode_libdir_flag_spec\"
4527
      fi
4528
      compile_rpath="$rpath"
4529

    
4530
      rpath=
4531
      hardcode_libdirs=
4532
      for libdir in $finalize_rpath; do
4533
	if test -n "$hardcode_libdir_flag_spec"; then
4534
	  if test -n "$hardcode_libdir_separator"; then
4535
	    if test -z "$hardcode_libdirs"; then
4536
	      hardcode_libdirs="$libdir"
4537
	    else
4538
	      # Just accumulate the unique libdirs.
4539
	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4540
	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4541
		;;
4542
	      *)
4543
		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4544
		;;
4545
	      esac
4546
	    fi
4547
	  else
4548
	    eval flag=\"$hardcode_libdir_flag_spec\"
4549
	    rpath="$rpath $flag"
4550
	  fi
4551
	elif test -n "$runpath_var"; then
4552
	  case "$finalize_perm_rpath " in
4553
	  *" $libdir "*) ;;
4554
	  *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
4555
	  esac
4556
	fi
4557
      done
4558
      # Substitute the hardcoded libdirs into the rpath.
4559
      if test -n "$hardcode_libdir_separator" &&
4560
	 test -n "$hardcode_libdirs"; then
4561
	libdir="$hardcode_libdirs"
4562
	eval rpath=\" $hardcode_libdir_flag_spec\"
4563
      fi
4564
      finalize_rpath="$rpath"
4565

    
4566
      if test -n "$libobjs" && test "$build_old_libs" = yes; then
4567
	# Transform all the library objects into standard objects.
4568
	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4569
	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4570
      fi
4571

    
4572
      dlsyms=
4573
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4574
	if test -n "$NM" && test -n "$global_symbol_pipe"; then
4575
	  dlsyms="${outputname}S.c"
4576
	else
4577
	  $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4578
	fi
4579
      fi
4580

    
4581
      if test -n "$dlsyms"; then
4582
	case $dlsyms in
4583
	"") ;;
4584
	*.c)
4585
	  # Discover the nlist of each of the dlfiles.
4586
	  nlist="$output_objdir/${outputname}.nm"
4587

    
4588
	  $show "$rm $nlist ${nlist}S ${nlist}T"
4589
	  $run $rm "$nlist" "${nlist}S" "${nlist}T"
4590

    
4591
	  # Parse the name list into a source file.
4592
	  $show "creating $output_objdir/$dlsyms"
4593

    
4594
	  test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4595
/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4596
/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4597

    
4598
#ifdef __cplusplus
4599
extern \"C\" {
4600
#endif
4601

    
4602
/* Prevent the only kind of declaration conflicts we can make. */
4603
#define lt_preloaded_symbols some_other_symbol
4604

    
4605
/* External symbol declarations for the compiler. */\
4606
"
4607

    
4608
	  if test "$dlself" = yes; then
4609
	    $show "generating symbol list for \`$output'"
4610

    
4611
	    test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4612

    
4613
	    # Add our own program objects to the symbol list.
4614
	    progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4615
	    for arg in $progfiles; do
4616
	      $show "extracting global C symbols from \`$arg'"
4617
	      $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4618
	    done
4619

    
4620
	    if test -n "$exclude_expsyms"; then
4621
	      $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4622
	      $run eval '$mv "$nlist"T "$nlist"'
4623
	    fi
4624

    
4625
	    if test -n "$export_symbols_regex"; then
4626
	      $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4627
	      $run eval '$mv "$nlist"T "$nlist"'
4628
	    fi
4629

    
4630
	    # Prepare the list of exported symbols
4631
	    if test -z "$export_symbols"; then
4632
	      export_symbols="$output_objdir/$outputname.exp"
4633
	      $run $rm $export_symbols
4634
	      $run eval "${SED} -n -e '/^: @PROGRAM@ $/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4635
              case $host in
4636
              *cygwin* | *mingw* )
4637
	        $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4638
		$run eval 'cat "$export_symbols" >> "$output_objdir/$outputname.def"'
4639
                ;;
4640
              esac
4641
	    else
4642
	      $run eval "${SED} -e 's/\([].[*^$]\)/\\\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$outputname.exp"'
4643
	      $run eval 'grep -f "$output_objdir/$outputname.exp" < "$nlist" > "$nlist"T'
4644
	      $run eval 'mv "$nlist"T "$nlist"'
4645
              case $host in
4646
              *cygwin* | *mingw* )
4647
	        $run eval "echo EXPORTS "'> "$output_objdir/$outputname.def"'
4648
		$run eval 'cat "$nlist" >> "$output_objdir/$outputname.def"'
4649
                ;;
4650
              esac
4651
	    fi
4652
	  fi
4653

    
4654
	  for arg in $dlprefiles; do
4655
	    $show "extracting global C symbols from \`$arg'"
4656
	    name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4657
	    $run eval '$echo ": $name " >> "$nlist"'
4658
	    $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4659
	  done
4660

    
4661
	  if test -z "$run"; then
4662
	    # Make sure we have at least an empty file.
4663
	    test -f "$nlist" || : > "$nlist"
4664

    
4665
	    if test -n "$exclude_expsyms"; then
4666
	      $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4667
	      $mv "$nlist"T "$nlist"
4668
	    fi
4669

    
4670
	    # Try sorting and uniquifying the output.
4671
	    if grep -v "^: " < "$nlist" |
4672
		if sort -k 3 </dev/null >/dev/null 2>&1; then
4673
		  sort -k 3
4674
		else
4675
		  sort +2
4676
		fi |
4677
		uniq > "$nlist"S; then
4678
	      :
4679
	    else
4680
	      grep -v "^: " < "$nlist" > "$nlist"S
4681
	    fi
4682

    
4683
	    if test -f "$nlist"S; then
4684
	      eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4685
	    else
4686
	      $echo '/* NONE */' >> "$output_objdir/$dlsyms"
4687
	    fi
4688

    
4689
	    $echo >> "$output_objdir/$dlsyms" "\
4690

    
4691
#undef lt_preloaded_symbols
4692

    
4693
#if defined (__STDC__) && __STDC__
4694
# define lt_ptr void *
4695
#else
4696
# define lt_ptr char *
4697
# define const
4698
#endif
4699

    
4700
/* The mapping between symbol names and symbols. */
4701
"
4702

    
4703
	    case $host in
4704
	    *cygwin* | *mingw* )
4705
	  $echo >> "$output_objdir/$dlsyms" "\
4706
/* DATA imports from DLLs on WIN32 can't be const, because
4707
   runtime relocations are performed -- see ld's documentation
4708
   on pseudo-relocs */
4709
struct {
4710
"
4711
	      ;;
4712
	    * )
4713
	  $echo >> "$output_objdir/$dlsyms" "\
4714
const struct {
4715
"
4716
	      ;;
4717
	    esac
4718

    
4719

    
4720
	  $echo >> "$output_objdir/$dlsyms" "\
4721
  const char *name;
4722
  lt_ptr address;
4723
}
4724
lt_preloaded_symbols[] =
4725
{\
4726
"
4727

    
4728
	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4729

    
4730
	    $echo >> "$output_objdir/$dlsyms" "\
4731
  {0, (lt_ptr) 0}
4732
};
4733

    
4734
/* This works around a problem in FreeBSD linker */
4735
#ifdef FREEBSD_WORKAROUND
4736
static const void *lt_preloaded_setup() {
4737
  return lt_preloaded_symbols;
4738
}
4739
#endif
4740

    
4741
#ifdef __cplusplus
4742
}
4743
#endif\
4744
"
4745
	  fi
4746

    
4747
	  pic_flag_for_symtable=
4748
	  case $host in
4749
	  # compiling the symbol table file with pic_flag works around
4750
	  # a FreeBSD bug that causes programs to crash when -lm is
4751
	  # linked before any other PIC object.  But we must not use
4752
	  # pic_flag when linking with -static.  The problem exists in
4753
	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4754
	  *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4755
	    case "$compile_command " in
4756
	    *" -static "*) ;;
4757
	    *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4758
	    esac;;
4759
	  *-*-hpux*)
4760
	    case "$compile_command " in
4761
	    *" -static "*) ;;
4762
	    *) pic_flag_for_symtable=" $pic_flag";;
4763
	    esac
4764
	  esac
4765

    
4766
	  # Now compile the dynamic symbol file.
4767
	  $show "(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4768
	  $run eval '(cd $output_objdir && $LTCC  $LTCFLAGS -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4769

    
4770
	  # Clean up the generated files.
4771
	  $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4772
	  $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4773

    
4774
	  # Transform the symbol file into the correct name.
4775
          case $host in
4776
          *cygwin* | *mingw* )
4777
            if test -f "$output_objdir/${outputname}.def" ; then
4778
              compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
4779
              finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}.def $output_objdir/${outputname}S.${objext}%" | $NL2SP`
4780
            else
4781
              compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4782
              finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4783
             fi
4784
            ;;
4785
          * )
4786
            compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4787
            finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%" | $NL2SP`
4788
            ;;
4789
          esac
4790
	  ;;
4791
	*)
4792
	  $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4793
	  exit $EXIT_FAILURE
4794
	  ;;
4795
	esac
4796
      else
4797
	# We keep going just in case the user didn't refer to
4798
	# lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
4799
	# really was required.
4800

    
4801
	# Nullify the symbol file.
4802
	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
4803
	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "s% @SYMFILE@%%" | $NL2SP`
4804
      fi
4805

    
4806
      if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
4807
	# Replace the output file specification.
4808
	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e 's%@OUTPUT@%'"$output"'%g' | $NL2SP`
4809
	link_command="$compile_command$compile_rpath"
4810

    
4811
	# We have no uninstalled library dependencies, so finalize right now.
4812
	$show "$link_command"
4813
	$run eval "$link_command"
4814
	exit_status=$?
4815

    
4816
	# Delete the generated files.
4817
	if test -n "$dlsyms"; then
4818
	  $show "$rm $output_objdir/${outputname}S.${objext}"
4819
	  $run $rm "$output_objdir/${outputname}S.${objext}"
4820
	fi
4821

    
4822
	exit $exit_status
4823
      fi
4824

    
4825
      if test -n "$shlibpath_var"; then
4826
	# We should set the shlibpath_var
4827
	rpath=
4828
	for dir in $temp_rpath; do
4829
	  case $dir in
4830
	  [\\/]* | [A-Za-z]:[\\/]*)
4831
	    # Absolute path.
4832
	    rpath="$rpath$dir:"
4833
	    ;;
4834
	  *)
4835
	    # Relative path: add a thisdir entry.
4836
	    rpath="$rpath\$thisdir/$dir:"
4837
	    ;;
4838
	  esac
4839
	done
4840
	temp_rpath="$rpath"
4841
      fi
4842

    
4843
      if test -n "$compile_shlibpath$finalize_shlibpath"; then
4844
	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
4845
      fi
4846
      if test -n "$finalize_shlibpath"; then
4847
	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
4848
      fi
4849

    
4850
      compile_var=
4851
      finalize_var=
4852
      if test -n "$runpath_var"; then
4853
	if test -n "$perm_rpath"; then
4854
	  # We should set the runpath_var.
4855
	  rpath=
4856
	  for dir in $perm_rpath; do
4857
	    rpath="$rpath$dir:"
4858
	  done
4859
	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
4860
	fi
4861
	if test -n "$finalize_perm_rpath"; then
4862
	  # We should set the runpath_var.
4863
	  rpath=
4864
	  for dir in $finalize_perm_rpath; do
4865
	    rpath="$rpath$dir:"
4866
	  done
4867
	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
4868
	fi
4869
      fi
4870

    
4871
      if test "$no_install" = yes; then
4872
	# We don't need to create a wrapper script.
4873
	link_command="$compile_var$compile_command$compile_rpath"
4874
	# Replace the output file specification.
4875
	link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4876
	# Delete the old output file.
4877
	$run $rm $output
4878
	# Link the executable and exit
4879
	$show "$link_command"
4880
	$run eval "$link_command" || exit $?
4881
	exit $EXIT_SUCCESS
4882
      fi
4883

    
4884
      if test "$hardcode_action" = relink; then
4885
	# Fast installation is not supported
4886
	link_command="$compile_var$compile_command$compile_rpath"
4887
	relink_command="$finalize_var$finalize_command$finalize_rpath"
4888

    
4889
	$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
4890
	$echo "$modename: \`$output' will be relinked during installation" 1>&2
4891
      else
4892
	if test "$fast_install" != no; then
4893
	  link_command="$finalize_var$compile_command$finalize_rpath"
4894
	  if test "$fast_install" = yes; then
4895
	    relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $SP2NL | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g' | $NL2SP`
4896
	  else
4897
	    # fast_install is set to needless
4898
	    relink_command=
4899
	  fi
4900
	else
4901
	  link_command="$compile_var$compile_command$compile_rpath"
4902
	  relink_command="$finalize_var$finalize_command$finalize_rpath"
4903
	fi
4904
      fi
4905

    
4906
      # Replace the output file specification.
4907
      link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
4908

    
4909
      # Delete the old output files.
4910
      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
4911

    
4912
      $show "$link_command"
4913
      $run eval "$link_command" || exit $?
4914

    
4915
      # Now create the wrapper script.
4916
      $show "creating $output"
4917

    
4918
      # Quote the relink command for shipping.
4919
      if test -n "$relink_command"; then
4920
	# Preserve any variables that may affect compiler behavior
4921
	for var in $variables_saved_for_relink; do
4922
	  if eval test -z \"\${$var+set}\"; then
4923
	    relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
4924
	  elif eval var_value=\$$var; test -z "$var_value"; then
4925
	    relink_command="$var=; export $var; $relink_command"
4926
	  else
4927
	    var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4928
	    relink_command="$var=\"$var_value\"; export $var; $relink_command"
4929
	  fi
4930
	done
4931
	relink_command="(cd `pwd`; $relink_command)"
4932
	relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
4933
      fi
4934

    
4935
      # Quote $echo for shipping.
4936
      if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
4937
	case $progpath in
4938
	[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4939
	*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4940
	esac
4941
	qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4942
      else
4943
	qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4944
      fi
4945

    
4946
      # Only actually do things if our run command is non-null.
4947
      if test -z "$run"; then
4948
	# win32 will think the script is a binary if it has
4949
	# a .exe suffix, so we strip it off here.
4950
	case $output in
4951
	  *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
4952
	esac
4953
	# test for cygwin because mv fails w/o .exe extensions
4954
	case $host in
4955
	  *cygwin*)
4956
	    exeext=.exe
4957
	    outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
4958
	  *) exeext= ;;
4959
	esac
4960
	case $host in
4961
	  *cygwin* | *mingw* )
4962
            output_name=`basename $output`
4963
            output_path=`dirname $output`
4964
            cwrappersource="$output_path/$objdir/lt-$output_name.c"
4965
            cwrapper="$output_path/$output_name.exe"
4966
            $rm $cwrappersource $cwrapper
4967
            trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4968

    
4969
	    cat > $cwrappersource <<EOF
4970

    
4971
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4972
   Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4973

    
4974
   The $output program cannot be directly executed until all the libtool
4975
   libraries that it depends on are installed.
4976

    
4977
   This wrapper executable should never be moved out of the build directory.
4978
   If it is, it will not operate correctly.
4979

    
4980
   Currently, it simply execs the wrapper *script* "/bin/sh $output",
4981
   but could eventually absorb all of the scripts functionality and
4982
   exec $objdir/$outputname directly.
4983
*/
4984
EOF
4985
	    cat >> $cwrappersource<<"EOF"
4986
#include <stdio.h>
4987
#include <stdlib.h>
4988
#include <unistd.h>
4989
#include <malloc.h>
4990
#include <stdarg.h>
4991
#include <assert.h>
4992
#include <string.h>
4993
#include <ctype.h>
4994
#include <sys/stat.h>
4995

    
4996
#if defined(PATH_MAX)
4997
# define LT_PATHMAX PATH_MAX
4998
#elif defined(MAXPATHLEN)
4999
# define LT_PATHMAX MAXPATHLEN
5000
#else
5001
# define LT_PATHMAX 1024
5002
#endif
5003

    
5004
#ifndef DIR_SEPARATOR
5005
# define DIR_SEPARATOR '/'
5006
# define PATH_SEPARATOR ':'
5007
#endif
5008

    
5009
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
5010
  defined (__OS2__)
5011
# define HAVE_DOS_BASED_FILE_SYSTEM
5012
# ifndef DIR_SEPARATOR_2
5013
#  define DIR_SEPARATOR_2 '\\'
5014
# endif
5015
# ifndef PATH_SEPARATOR_2
5016
#  define PATH_SEPARATOR_2 ';'
5017
# endif
5018
#endif
5019

    
5020
#ifndef DIR_SEPARATOR_2
5021
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
5022
#else /* DIR_SEPARATOR_2 */
5023
# define IS_DIR_SEPARATOR(ch) \
5024
        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
5025
#endif /* DIR_SEPARATOR_2 */
5026

    
5027
#ifndef PATH_SEPARATOR_2
5028
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR)
5029
#else /* PATH_SEPARATOR_2 */
5030
# define IS_PATH_SEPARATOR(ch) ((ch) == PATH_SEPARATOR_2)
5031
#endif /* PATH_SEPARATOR_2 */
5032

    
5033
#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
5034
#define XFREE(stale) do { \
5035
  if (stale) { free ((void *) stale); stale = 0; } \
5036
} while (0)
5037

    
5038
/* -DDEBUG is fairly common in CFLAGS.  */
5039
#undef DEBUG
5040
#if defined DEBUGWRAPPER
5041
# define DEBUG(format, ...) fprintf(stderr, format, __VA_ARGS__)
5042
#else
5043
# define DEBUG(format, ...)
5044
#endif
5045

    
5046
const char *program_name = NULL;
5047

    
5048
void * xmalloc (size_t num);
5049
char * xstrdup (const char *string);
5050
const char * base_name (const char *name);
5051
char * find_executable(const char *wrapper);
5052
int    check_executable(const char *path);
5053
char * strendzap(char *str, const char *pat);
5054
void lt_fatal (const char *message, ...);
5055

    
5056
int
5057
main (int argc, char *argv[])
5058
{
5059
  char **newargz;
5060
  int i;
5061

    
5062
  program_name = (char *) xstrdup (base_name (argv[0]));
5063
  DEBUG("(main) argv[0]      : %s\n",argv[0]);
5064
  DEBUG("(main) program_name : %s\n",program_name);
5065
  newargz = XMALLOC(char *, argc+2);
5066
EOF
5067

    
5068
            cat >> $cwrappersource <<EOF
5069
  newargz[0] = (char *) xstrdup("$SHELL");
5070
EOF
5071

    
5072
            cat >> $cwrappersource <<"EOF"
5073
  newargz[1] = find_executable(argv[0]);
5074
  if (newargz[1] == NULL)
5075
    lt_fatal("Couldn't find %s", argv[0]);
5076
  DEBUG("(main) found exe at : %s\n",newargz[1]);
5077
  /* we know the script has the same name, without the .exe */
5078
  /* so make sure newargz[1] doesn't end in .exe */
5079
  strendzap(newargz[1],".exe");
5080
  for (i = 1; i < argc; i++)
5081
    newargz[i+1] = xstrdup(argv[i]);
5082
  newargz[argc+1] = NULL;
5083

    
5084
  for (i=0; i<argc+1; i++)
5085
  {
5086
    DEBUG("(main) newargz[%d]   : %s\n",i,newargz[i]);
5087
    ;
5088
  }
5089

    
5090
EOF
5091

    
5092
            case $host_os in
5093
              mingw*)
5094
                cat >> $cwrappersource <<EOF
5095
  execv("$SHELL",(char const **)newargz);
5096
EOF
5097
              ;;
5098
              *)
5099
                cat >> $cwrappersource <<EOF
5100
  execv("$SHELL",newargz);
5101
EOF
5102
              ;;
5103
            esac
5104

    
5105
            cat >> $cwrappersource <<"EOF"
5106
  return 127;
5107
}
5108

    
5109
void *
5110
xmalloc (size_t num)
5111
{
5112
  void * p = (void *) malloc (num);
5113
  if (!p)
5114
    lt_fatal ("Memory exhausted");
5115

    
5116
  return p;
5117
}
5118

    
5119
char *
5120
xstrdup (const char *string)
5121
{
5122
  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
5123
;
5124
}
5125

    
5126
const char *
5127
base_name (const char *name)
5128
{
5129
  const char *base;
5130

    
5131
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5132
  /* Skip over the disk name in MSDOS pathnames. */
5133
  if (isalpha ((unsigned char)name[0]) && name[1] == ':')
5134
    name += 2;
5135
#endif
5136

    
5137
  for (base = name; *name; name++)
5138
    if (IS_DIR_SEPARATOR (*name))
5139
      base = name + 1;
5140
  return base;
5141
}
5142

    
5143
int
5144
check_executable(const char * path)
5145
{
5146
  struct stat st;
5147

    
5148
  DEBUG("(check_executable)  : %s\n", path ? (*path ? path : "EMPTY!") : "NULL!");
5149
  if ((!path) || (!*path))
5150
    return 0;
5151

    
5152
  if ((stat (path, &st) >= 0) &&
5153
      (
5154
        /* MinGW & native WIN32 do not support S_IXOTH or S_IXGRP */
5155
#if defined (S_IXOTH)
5156
       ((st.st_mode & S_IXOTH) == S_IXOTH) ||
5157
#endif
5158
#if defined (S_IXGRP)
5159
       ((st.st_mode & S_IXGRP) == S_IXGRP) ||
5160
#endif
5161
       ((st.st_mode & S_IXUSR) == S_IXUSR))
5162
      )
5163
    return 1;
5164
  else
5165
    return 0;
5166
}
5167

    
5168
/* Searches for the full path of the wrapper.  Returns
5169
   newly allocated full path name if found, NULL otherwise */
5170
char *
5171
find_executable (const char* wrapper)
5172
{
5173
  int has_slash = 0;
5174
  const char* p;
5175
  const char* p_next;
5176
  /* static buffer for getcwd */
5177
  char tmp[LT_PATHMAX + 1];
5178
  int tmp_len;
5179
  char* concat_name;
5180

    
5181
  DEBUG("(find_executable)  : %s\n", wrapper ? (*wrapper ? wrapper : "EMPTY!") : "NULL!");
5182

    
5183
  if ((wrapper == NULL) || (*wrapper == '\0'))
5184
    return NULL;
5185

    
5186
  /* Absolute path? */
5187
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5188
  if (isalpha ((unsigned char)wrapper[0]) && wrapper[1] == ':')
5189
  {
5190
    concat_name = xstrdup (wrapper);
5191
    if (check_executable(concat_name))
5192
      return concat_name;
5193
    XFREE(concat_name);
5194
  }
5195
  else
5196
  {
5197
#endif
5198
    if (IS_DIR_SEPARATOR (wrapper[0]))
5199
    {
5200
      concat_name = xstrdup (wrapper);
5201
      if (check_executable(concat_name))
5202
        return concat_name;
5203
      XFREE(concat_name);
5204
    }
5205
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
5206
  }
5207
#endif
5208

    
5209
  for (p = wrapper; *p; p++)
5210
    if (*p == '/')
5211
    {
5212
      has_slash = 1;
5213
      break;
5214
    }
5215
  if (!has_slash)
5216
  {
5217
    /* no slashes; search PATH */
5218
    const char* path = getenv ("PATH");
5219
    if (path != NULL)
5220
    {
5221
      for (p = path; *p; p = p_next)
5222
      {
5223
        const char* q;
5224
        size_t p_len;
5225
        for (q = p; *q; q++)
5226
          if (IS_PATH_SEPARATOR(*q))
5227
            break;
5228
        p_len = q - p;
5229
        p_next = (*q == '\0' ? q : q + 1);
5230
        if (p_len == 0)
5231
        {
5232
          /* empty path: current directory */
5233
          if (getcwd (tmp, LT_PATHMAX) == NULL)
5234
            lt_fatal ("getcwd failed");
5235
          tmp_len = strlen(tmp);
5236
          concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5237
          memcpy (concat_name, tmp, tmp_len);
5238
          concat_name[tmp_len] = '/';
5239
          strcpy (concat_name + tmp_len + 1, wrapper);
5240
        }
5241
        else
5242
        {
5243
          concat_name = XMALLOC(char, p_len + 1 + strlen(wrapper) + 1);
5244
          memcpy (concat_name, p, p_len);
5245
          concat_name[p_len] = '/';
5246
          strcpy (concat_name + p_len + 1, wrapper);
5247
        }
5248
        if (check_executable(concat_name))
5249
          return concat_name;
5250
        XFREE(concat_name);
5251
      }
5252
    }
5253
    /* not found in PATH; assume curdir */
5254
  }
5255
  /* Relative path | not found in path: prepend cwd */
5256
  if (getcwd (tmp, LT_PATHMAX) == NULL)
5257
    lt_fatal ("getcwd failed");
5258
  tmp_len = strlen(tmp);
5259
  concat_name = XMALLOC(char, tmp_len + 1 + strlen(wrapper) + 1);
5260
  memcpy (concat_name, tmp, tmp_len);
5261
  concat_name[tmp_len] = '/';
5262
  strcpy (concat_name + tmp_len + 1, wrapper);
5263

    
5264
  if (check_executable(concat_name))
5265
    return concat_name;
5266
  XFREE(concat_name);
5267
  return NULL;
5268
}
5269

    
5270
char *
5271
strendzap(char *str, const char *pat)
5272
{
5273
  size_t len, patlen;
5274

    
5275
  assert(str != NULL);
5276
  assert(pat != NULL);
5277

    
5278
  len = strlen(str);
5279
  patlen = strlen(pat);
5280

    
5281
  if (patlen <= len)
5282
  {
5283
    str += len - patlen;
5284
    if (strcmp(str, pat) == 0)
5285
      *str = '\0';
5286
  }
5287
  return str;
5288
}
5289

    
5290
static void
5291
lt_error_core (int exit_status, const char * mode,
5292
          const char * message, va_list ap)
5293
{
5294
  fprintf (stderr, "%s: %s: ", program_name, mode);
5295
  vfprintf (stderr, message, ap);
5296
  fprintf (stderr, ".\n");
5297

    
5298
  if (exit_status >= 0)
5299
    exit (exit_status);
5300
}
5301

    
5302
void
5303
lt_fatal (const char *message, ...)
5304
{
5305
  va_list ap;
5306
  va_start (ap, message);
5307
  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
5308
  va_end (ap);
5309
}
5310
EOF
5311
          # we should really use a build-platform specific compiler
5312
          # here, but OTOH, the wrappers (shell script and this C one)
5313
          # are only useful if you want to execute the "real" binary.
5314
          # Since the "real" binary is built for $host, then this
5315
          # wrapper might as well be built for $host, too.
5316
          $run $LTCC $LTCFLAGS -s -o $cwrapper $cwrappersource
5317
          ;;
5318
        esac
5319
        $rm $output
5320
        trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
5321

    
5322
	$echo > $output "\
5323
#! $SHELL
5324

    
5325
# $output - temporary wrapper script for $objdir/$outputname
5326
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5327
#
5328
# The $output program cannot be directly executed until all the libtool
5329
# libraries that it depends on are installed.
5330
#
5331
# This wrapper script should never be moved out of the build directory.
5332
# If it is, it will not operate correctly.
5333

    
5334
# Sed substitution that helps us do robust quoting.  It backslashifies
5335
# metacharacters that are still active within double-quoted strings.
5336
Xsed='${SED} -e 1s/^X//'
5337
sed_quote_subst='$sed_quote_subst'
5338

    
5339
# Be Bourne compatible (taken from Autoconf:_AS_BOURNE_COMPATIBLE).
5340
if test -n \"\${ZSH_VERSION+set}\" && (emulate sh) >/dev/null 2>&1; then
5341
  emulate sh
5342
  NULLCMD=:
5343
  # Zsh 3.x and 4.x performs word splitting on \${1+\"\$@\"}, which
5344
  # is contrary to our usage.  Disable this feature.
5345
  alias -g '\${1+\"\$@\"}'='\"\$@\"'
5346
  setopt NO_GLOB_SUBST
5347
else
5348
  case \`(set -o) 2>/dev/null\` in *posix*) set -o posix;; esac
5349
fi
5350
BIN_SH=xpg4; export BIN_SH # for Tru64
5351
DUALCASE=1; export DUALCASE # for MKS sh
5352

    
5353
# The HP-UX ksh and POSIX shell print the target directory to stdout
5354
# if CDPATH is set.
5355
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
5356

    
5357
relink_command=\"$relink_command\"
5358

    
5359
# This environment variable determines our operation mode.
5360
if test \"\$libtool_install_magic\" = \"$magic\"; then
5361
  # install mode needs the following variable:
5362
  notinst_deplibs='$notinst_deplibs'
5363
else
5364
  # When we are sourced in execute mode, \$file and \$echo are already set.
5365
  if test \"\$libtool_execute_magic\" != \"$magic\"; then
5366
    echo=\"$qecho\"
5367
    file=\"\$0\"
5368
    # Make sure echo works.
5369
    if test \"X\$1\" = X--no-reexec; then
5370
      # Discard the --no-reexec flag, and continue.
5371
      shift
5372
    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
5373
      # Yippee, \$echo works!
5374
      :
5375
    else
5376
      # Restart under the correct shell, and then maybe \$echo will work.
5377
      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
5378
    fi
5379
  fi\
5380
"
5381
	$echo >> $output "\
5382

    
5383
  # Find the directory that this script lives in.
5384
  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
5385
  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
5386

    
5387
  # Follow symbolic links until we get to the real thisdir.
5388
  file=\`ls -ld \"\$file\" | ${SED} -n 's/.*-> //p'\`
5389
  while test -n \"\$file\"; do
5390
    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
5391

    
5392
    # If there was a directory component, then change thisdir.
5393
    if test \"x\$destdir\" != \"x\$file\"; then
5394
      case \"\$destdir\" in
5395
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
5396
      *) thisdir=\"\$thisdir/\$destdir\" ;;
5397
      esac
5398
    fi
5399

    
5400
    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
5401
    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
5402
  done
5403

    
5404
  # Try to get the absolute directory name.
5405
  absdir=\`cd \"\$thisdir\" && pwd\`
5406
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
5407
"
5408

    
5409
	if test "$fast_install" = yes; then
5410
	  $echo >> $output "\
5411
  program=lt-'$outputname'$exeext
5412
  progdir=\"\$thisdir/$objdir\"
5413

    
5414
  if test ! -f \"\$progdir/\$program\" || \\
5415
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
5416
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
5417

    
5418
    file=\"\$\$-\$program\"
5419

    
5420
    if test ! -d \"\$progdir\"; then
5421
      $mkdir \"\$progdir\"
5422
    else
5423
      $rm \"\$progdir/\$file\"
5424
    fi"
5425

    
5426
	  $echo >> $output "\
5427

    
5428
    # relink executable if necessary
5429
    if test -n \"\$relink_command\"; then
5430
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
5431
      else
5432
	$echo \"\$relink_command_output\" >&2
5433
	$rm \"\$progdir/\$file\"
5434
	exit $EXIT_FAILURE
5435
      fi
5436
    fi
5437

    
5438
    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
5439
    { $rm \"\$progdir/\$program\";
5440
      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
5441
    $rm \"\$progdir/\$file\"
5442
  fi"
5443
	else
5444
	  $echo >> $output "\
5445
  program='$outputname'
5446
  progdir=\"\$thisdir/$objdir\"
5447
"
5448
	fi
5449

    
5450
	$echo >> $output "\
5451

    
5452
  if test -f \"\$progdir/\$program\"; then"
5453

    
5454
	# Export our shlibpath_var if we have one.
5455
	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
5456
	  $echo >> $output "\
5457
    # Add our own library path to $shlibpath_var
5458
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
5459

    
5460
    # Some systems cannot cope with colon-terminated $shlibpath_var
5461
    # The second colon is a workaround for a bug in BeOS R4 sed
5462
    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
5463

    
5464
    export $shlibpath_var
5465
"
5466
	fi
5467

    
5468
	# fixup the dll searchpath if we need to.
5469
	if test -n "$dllsearchpath"; then
5470
	  $echo >> $output "\
5471
    # Add the dll search path components to the executable PATH
5472
    PATH=$dllsearchpath:\$PATH
5473
"
5474
	fi
5475

    
5476
	$echo >> $output "\
5477
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
5478
      # Run the actual program with our arguments.
5479
"
5480
	case $host in
5481
	# Backslashes separate directories on plain windows
5482
	*-*-mingw | *-*-os2*)
5483
	  $echo >> $output "\
5484
      exec \"\$progdir\\\\\$program\" \${1+\"\$@\"}
5485
"
5486
	  ;;
5487

    
5488
	*)
5489
	  $echo >> $output "\
5490
      exec \"\$progdir/\$program\" \${1+\"\$@\"}
5491
"
5492
	  ;;
5493
	esac
5494
	$echo >> $output "\
5495
      \$echo \"\$0: cannot exec \$program \$*\"
5496
      exit $EXIT_FAILURE
5497
    fi
5498
  else
5499
    # The program doesn't exist.
5500
    \$echo \"\$0: error: \\\`\$progdir/\$program' does not exist\" 1>&2
5501
    \$echo \"This script is just a wrapper for \$program.\" 1>&2
5502
    $echo \"See the $PACKAGE documentation for more information.\" 1>&2
5503
    exit $EXIT_FAILURE
5504
  fi
5505
fi\
5506
"
5507
	chmod +x $output
5508
      fi
5509
      exit $EXIT_SUCCESS
5510
      ;;
5511
    esac
5512

    
5513
    # See if we need to build an old-fashioned archive.
5514
    for oldlib in $oldlibs; do
5515

    
5516
      if test "$build_libtool_libs" = convenience; then
5517
	oldobjs="$libobjs_save"
5518
	addlibs="$convenience"
5519
	build_libtool_libs=no
5520
      else
5521
	if test "$build_libtool_libs" = module; then
5522
	  oldobjs="$libobjs_save"
5523
	  build_libtool_libs=no
5524
	else
5525
	  oldobjs="$old_deplibs $non_pic_objects"
5526
	fi
5527
	addlibs="$old_convenience"
5528
      fi
5529

    
5530
      if test -n "$addlibs"; then
5531
	gentop="$output_objdir/${outputname}x"
5532
	generated="$generated $gentop"
5533

    
5534
	func_extract_archives $gentop $addlibs
5535
	oldobjs="$oldobjs $func_extract_archives_result"
5536
      fi
5537

    
5538
      # Do each command in the archive commands.
5539
      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
5540
       cmds=$old_archive_from_new_cmds
5541
      else
5542
	# POSIX demands no paths to be encoded in archives.  We have
5543
	# to avoid creating archives with duplicate basenames if we
5544
	# might have to extract them afterwards, e.g., when creating a
5545
	# static archive out of a convenience library, or when linking
5546
	# the entirety of a libtool archive into another (currently
5547
	# not supported by libtool).
5548
	if (for obj in $oldobjs
5549
	    do
5550
	      $echo "X$obj" | $Xsed -e 's%^.*/%%'
5551
	    done | sort | sort -uc >/dev/null 2>&1); then
5552
	  :
5553
	else
5554
	  $echo "copying selected object files to avoid basename conflicts..."
5555

    
5556
	  if test -z "$gentop"; then
5557
	    gentop="$output_objdir/${outputname}x"
5558
	    generated="$generated $gentop"
5559

    
5560
	    $show "${rm}r $gentop"
5561
	    $run ${rm}r "$gentop"
5562
	    $show "$mkdir $gentop"
5563
	    $run $mkdir "$gentop"
5564
	    exit_status=$?
5565
	    if test "$exit_status" -ne 0 && test ! -d "$gentop"; then
5566
	      exit $exit_status
5567
	    fi
5568
	  fi
5569

    
5570
	  save_oldobjs=$oldobjs
5571
	  oldobjs=
5572
	  counter=1
5573
	  for obj in $save_oldobjs
5574
	  do
5575
	    objbase=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
5576
	    case " $oldobjs " in
5577
	    " ") oldobjs=$obj ;;
5578
	    *[\ /]"$objbase "*)
5579
	      while :; do
5580
		# Make sure we don't pick an alternate name that also
5581
		# overlaps.
5582
		newobj=lt$counter-$objbase
5583
		counter=`expr $counter + 1`
5584
		case " $oldobjs " in
5585
		*[\ /]"$newobj "*) ;;
5586
		*) if test ! -f "$gentop/$newobj"; then break; fi ;;
5587
		esac
5588
	      done
5589
	      $show "ln $obj $gentop/$newobj || cp $obj $gentop/$newobj"
5590
	      $run ln "$obj" "$gentop/$newobj" ||
5591
	      $run cp "$obj" "$gentop/$newobj"
5592
	      oldobjs="$oldobjs $gentop/$newobj"
5593
	      ;;
5594
	    *) oldobjs="$oldobjs $obj" ;;
5595
	    esac
5596
	  done
5597
	fi
5598

    
5599
	eval cmds=\"$old_archive_cmds\"
5600

    
5601
	if len=`expr "X$cmds" : ".*"` &&
5602
	     test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
5603
	  cmds=$old_archive_cmds
5604
	else
5605
	  # the command line is too long to link in one step, link in parts
5606
	  $echo "using piecewise archive linking..."
5607
	  save_RANLIB=$RANLIB
5608
	  RANLIB=:
5609
	  objlist=
5610
	  concat_cmds=
5611
	  save_oldobjs=$oldobjs
5612

    
5613
	  # Is there a better way of finding the last object in the list?
5614
	  for obj in $save_oldobjs
5615
	  do
5616
	    last_oldobj=$obj
5617
	  done
5618
	  for obj in $save_oldobjs
5619
	  do
5620
	    oldobjs="$objlist $obj"
5621
	    objlist="$objlist $obj"
5622
	    eval test_cmds=\"$old_archive_cmds\"
5623
	    if len=`expr "X$test_cmds" : ".*" 2>/dev/null` &&
5624
	       test "$len" -le "$max_cmd_len"; then
5625
	      :
5626
	    else
5627
	      # the above command should be used before it gets too long
5628
	      oldobjs=$objlist
5629
	      if test "$obj" = "$last_oldobj" ; then
5630
	        RANLIB=$save_RANLIB
5631
	      fi
5632
	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
5633
	      eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
5634
	      objlist=
5635
	    fi
5636
	  done
5637
	  RANLIB=$save_RANLIB
5638
	  oldobjs=$objlist
5639
	  if test "X$oldobjs" = "X" ; then
5640
	    eval cmds=\"\$concat_cmds\"
5641
	  else
5642
	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
5643
	  fi
5644
	fi
5645
      fi
5646
      save_ifs="$IFS"; IFS='~'
5647
      for cmd in $cmds; do
5648
        eval cmd=\"$cmd\"
5649
	IFS="$save_ifs"
5650
	$show "$cmd"
5651
	$run eval "$cmd" || exit $?
5652
      done
5653
      IFS="$save_ifs"
5654
    done
5655

    
5656
    if test -n "$generated"; then
5657
      $show "${rm}r$generated"
5658
      $run ${rm}r$generated
5659
    fi
5660

    
5661
    # Now create the libtool archive.
5662
    case $output in
5663
    *.la)
5664
      old_library=
5665
      test "$build_old_libs" = yes && old_library="$libname.$libext"
5666
      $show "creating $output"
5667

    
5668
      # Preserve any variables that may affect compiler behavior
5669
      for var in $variables_saved_for_relink; do
5670
	if eval test -z \"\${$var+set}\"; then
5671
	  relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
5672
	elif eval var_value=\$$var; test -z "$var_value"; then
5673
	  relink_command="$var=; export $var; $relink_command"
5674
	else
5675
	  var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
5676
	  relink_command="$var=\"$var_value\"; export $var; $relink_command"
5677
	fi
5678
      done
5679
      # Quote the link command for shipping.
5680
      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
5681
      relink_command=`$echo "X$relink_command" | $SP2NL | $Xsed -e "$sed_quote_subst" | $NL2SP`
5682
      if test "$hardcode_automatic" = yes ; then
5683
	relink_command=
5684
      fi
5685

    
5686

    
5687
      # Only create the output if not a dry run.
5688
      if test -z "$run"; then
5689
	for installed in no yes; do
5690
	  if test "$installed" = yes; then
5691
	    if test -z "$install_libdir"; then
5692
	      break
5693
	    fi
5694
	    output="$output_objdir/$outputname"i
5695
	    # Replace all uninstalled libtool libraries with the installed ones
5696
	    newdependency_libs=
5697
	    for deplib in $dependency_libs; do
5698
	      case $deplib in
5699
	      *.la)
5700
		name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5701
		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5702
		if test -z "$libdir"; then
5703
		  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5704
		  exit $EXIT_FAILURE
5705
		fi
5706
		newdependency_libs="$newdependency_libs $libdir/$name"
5707
		;;
5708
	      *) newdependency_libs="$newdependency_libs $deplib" ;;
5709
	      esac
5710
	    done
5711
	    dependency_libs="$newdependency_libs"
5712
	    newdlfiles=
5713
	    for lib in $dlfiles; do
5714
	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5715
	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5716
	      if test -z "$libdir"; then
5717
		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5718
		exit $EXIT_FAILURE
5719
	      fi
5720
	      newdlfiles="$newdlfiles $libdir/$name"
5721
	    done
5722
	    dlfiles="$newdlfiles"
5723
	    newdlprefiles=
5724
	    for lib in $dlprefiles; do
5725
	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5726
	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5727
	      if test -z "$libdir"; then
5728
		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5729
		exit $EXIT_FAILURE
5730
	      fi
5731
	      newdlprefiles="$newdlprefiles $libdir/$name"
5732
	    done
5733
	    dlprefiles="$newdlprefiles"
5734
	  else
5735
	    newdlfiles=
5736
	    for lib in $dlfiles; do
5737
	      case $lib in
5738
		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5739
		*) abs=`pwd`"/$lib" ;