Statistics
| Revision:

root / ltmain.sh @ 1

History | View | Annotate | Download (180 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
5
# Free Software Foundation, Inc.
6
# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
7
#
8
# This program is free software; you can redistribute it and/or modify
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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, 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.6
47
TIMESTAMP=" (1.1220.2.95 2004/04/11 05:50:42) Debian$Rev: 220 $"
48

    
49

    
50
# Check that we have a working $echo.
51
if test "X$1" = X--no-reexec; then
52
  # Discard the --no-reexec flag, and continue.
53
  shift
54
elif test "X$1" = X--fallback-echo; then
55
  # Avoid inline document here, it may be left over
56
  :
57
elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
58
  # Yippee, $echo works!
59
  :
60
else
61
  # Restart under the correct shell, and then maybe $echo will work.
62
  exec $SHELL "$progpath" --no-reexec ${1+"$@"}
63
fi
64

    
65
if test "X$1" = X--fallback-echo; then
66
  # used as fallback echo
67
  shift
68
  cat <<EOF
69
$*
70
EOF
71
  exit $EXIT_SUCCESS
72
fi
73

    
74
default_mode=
75
help="Try \`$progname --help' for more information."
76
magic="%%%MAGIC variable%%%"
77
mkdir="mkdir"
78
mv="mv -f"
79
rm="rm -f"
80

    
81
# Sed substitution that helps us do robust quoting.  It backslashifies
82
# metacharacters that are still active within double-quoted strings.
83
Xsed="${SED}"' -e 1s/^X//'
84
sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
85
# test EBCDIC or ASCII
86
case `echo A|tr A '\301'` in
87
 A) # EBCDIC based system
88
  SP2NL="tr '\100' '\n'"
89
  NL2SP="tr '\r\n' '\100\100'"
90
  ;;
91
 *) # Assume ASCII based system
92
  SP2NL="tr '\040' '\012'"
93
  NL2SP="tr '\015\012' '\040\040'"
94
  ;;
95
esac
96

    
97
# NLS nuisances.
98
# Only set LANG and LC_ALL to C if already set.
99
# These must not be set unconditionally because not all systems understand
100
# e.g. LANG=C (notably SCO).
101
# We save the old values to restore during execute mode.
102
if test "${LC_ALL+set}" = set; then
103
  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
104
fi
105
if test "${LANG+set}" = set; then
106
  save_LANG="$LANG"; LANG=C; export LANG
107
fi
108

    
109
# Make sure IFS has a sensible default
110
: ${IFS=" 	
111
"}
112

    
113
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
114
  $echo "$modename: not configured to build any kind of library" 1>&2
115
  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
116
  exit $EXIT_FAILURE
117
fi
118

    
119
# Global variables.
120
mode=$default_mode
121
nonopt=
122
prev=
123
prevopt=
124
run=
125
show="$echo"
126
show_help=
127
execute_dlfiles=
128
lo2o="s/\\.lo\$/.${objext}/"
129
o2lo="s/\\.${objext}\$/.lo/"
130

    
131
#####################################
132
# Shell function definitions:
133
# This seems to be the best place for them
134

    
135
# func_win32_libid arg
136
# return the library type of file 'arg'
137
#
138
# Need a lot of goo to handle *both* DLLs and import libs
139
# Has to be a shell function in order to 'eat' the argument
140
# that is supplied when $file_magic_command is called.
141
func_win32_libid () {
142
  win32_libid_type="unknown"
143
  win32_fileres=`file -L $1 2>/dev/null`
144
  case $win32_fileres in
145
  *ar\ archive\ import\ library*) # definitely import
146
    win32_libid_type="x86 archive import"
147
    ;;
148
  *ar\ archive*) # could be an import, or static
149
    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
150
      $EGREP -e 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
151
      win32_nmres=`eval $NM -f posix -A $1 | \
152
	sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`
153
      if test "X$win32_nmres" = "Ximport" ; then
154
        win32_libid_type="x86 archive import"
155
      else
156
        win32_libid_type="x86 archive static"
157
      fi
158
    fi
159
    ;;
160
  *DLL*)
161
    win32_libid_type="x86 DLL"
162
    ;;
163
  *executable*) # but shell scripts are "executable" too...
164
    case $win32_fileres in
165
    *MS\ Windows\ PE\ Intel*)
166
      win32_libid_type="x86 DLL"
167
      ;;
168
    esac
169
    ;;
170
  esac
171
  $echo $win32_libid_type
172
}
173

    
174

    
175
# func_infer_tag arg
176
# Infer tagged configuration to use if any are available and
177
# if one wasn't chosen via the "--tag" command line option.
178
# Only attempt this if the compiler in the base compile
179
# command doesn't match the default compiler.
180
# arg is usually of the form 'gcc ...'
181
func_infer_tag () {
182
    if test -n "$available_tags" && test -z "$tagname"; then
183
      CC_quoted=
184
      for arg in $CC; do
185
	case $arg in
186
	  *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
187
	  arg="\"$arg\""
188
	  ;;
189
	esac
190
	CC_quoted="$CC_quoted $arg"
191
      done
192
      case $@ in
193
      # Blanks in the command may have been stripped by the calling shell,
194
      # but not from the CC environment variable when configure was run.
195
      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*) ;;
196
      # Blanks at the start of $base_compile will cause this to fail
197
      # if we don't check for them as well.
198
      *)
199
	for z in $available_tags; do
200
	  if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$progpath" > /dev/null; then
201
	    # Evaluate the configuration.
202
	    eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $progpath`"
203
	    CC_quoted=
204
	    for arg in $CC; do
205
	    # Double-quote args containing other shell metacharacters.
206
	    case $arg in
207
	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
208
	      arg="\"$arg\""
209
	      ;;
210
	    esac
211
	    CC_quoted="$CC_quoted $arg"
212
	  done
213
	    case "$@ " in
214
	      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "* | " $CC_quoted"* | "$CC_quoted "* | " `$echo $CC_quoted` "* | "`$echo $CC_quoted` "*)
215
	      # The compiler in the base compile command matches
216
	      # the one in the tagged configuration.
217
	      # Assume this is the tagged configuration we want.
218
	      tagname=$z
219
	      break
220
	      ;;
221
	    esac
222
	  fi
223
	done
224
	# If $tagname still isn't set, then no tagged configuration
225
	# was found and let the user know that the "--tag" command
226
	# line option must be used.
227
	if test -z "$tagname"; then
228
	  $echo "$modename: unable to infer tagged configuration"
229
	  $echo "$modename: specify a tag with \`--tag'" 1>&2
230
	  exit $EXIT_FAILURE
231
#        else
232
#          $echo "$modename: using $tagname tagged configuration"
233
	fi
234
	;;
235
      esac
236
    fi
237
}
238
# End of Shell function definitions
239
#####################################
240

    
241
# Darwin sucks
242
eval std_shrext=\"$shrext_cmds\"
243

    
244
# Parse our command line options once, thoroughly.
245
while test "$#" -gt 0
246
do
247
  arg="$1"
248
  shift
249

    
250
  case $arg in
251
  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
252
  *) optarg= ;;
253
  esac
254

    
255
  # If the previous option needs an argument, assign it.
256
  if test -n "$prev"; then
257
    case $prev in
258
    execute_dlfiles)
259
      execute_dlfiles="$execute_dlfiles $arg"
260
      ;;
261
    tag)
262
      tagname="$arg"
263
      preserve_args="${preserve_args}=$arg"
264

    
265
      # Check whether tagname contains only valid characters
266
      case $tagname in
267
      *[!-_A-Za-z0-9,/]*)
268
	$echo "$progname: invalid tag name: $tagname" 1>&2
269
	exit $EXIT_FAILURE
270
	;;
271
      esac
272

    
273
      case $tagname in
274
      CC)
275
	# Don't test for the "default" C tag, as we know, it's there, but
276
	# not specially marked.
277
	;;
278
      *)
279
	if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$progpath" > /dev/null; then
280
	  taglist="$taglist $tagname"
281
	  # Evaluate the configuration.
282
	  eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $progpath`"
283
	else
284
	  $echo "$progname: ignoring unknown tag $tagname" 1>&2
285
	fi
286
	;;
287
      esac
288
      ;;
289
    *)
290
      eval "$prev=\$arg"
291
      ;;
292
    esac
293

    
294
    prev=
295
    prevopt=
296
    continue
297
  fi
298

    
299
  # Have we seen a non-optional argument yet?
300
  case $arg in
301
  --help)
302
    show_help=yes
303
    ;;
304

    
305
  --version)
306
    $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
307
    $echo
308
    $echo "Copyright (C) 2003  Free Software Foundation, Inc."
309
    $echo "This is free software; see the source for copying conditions.  There is NO"
310
    $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
311
    exit $EXIT_SUCCESS
312
    ;;
313

    
314
  --config)
315
    ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $progpath
316
    # Now print the configurations for the tags.
317
    for tagname in $taglist; do
318
      ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$progpath"
319
    done
320
    exit $EXIT_SUCCESS
321
    ;;
322

    
323
  --debug)
324
    $echo "$progname: enabling shell trace mode"
325
    set -x
326
    preserve_args="$preserve_args $arg"
327
    ;;
328

    
329
  --dry-run | -n)
330
    run=:
331
    ;;
332

    
333
  --features)
334
    $echo "host: $host"
335
    if test "$build_libtool_libs" = yes; then
336
      $echo "enable shared libraries"
337
    else
338
      $echo "disable shared libraries"
339
    fi
340
    if test "$build_old_libs" = yes; then
341
      $echo "enable static libraries"
342
    else
343
      $echo "disable static libraries"
344
    fi
345
    exit $EXIT_SUCCESS
346
    ;;
347

    
348
  --finish) mode="finish" ;;
349

    
350
  --mode) prevopt="--mode" prev=mode ;;
351
  --mode=*) mode="$optarg" ;;
352

    
353
  --preserve-dup-deps) duplicate_deps="yes" ;;
354

    
355
  --quiet | --silent)
356
    show=:
357
    preserve_args="$preserve_args $arg"
358
    ;;
359

    
360
  --tag) prevopt="--tag" prev=tag ;;
361
  --tag=*)
362
    set tag "$optarg" ${1+"$@"}
363
    shift
364
    prev=tag
365
    preserve_args="$preserve_args --tag"
366
    ;;
367

    
368
  -dlopen)
369
    prevopt="-dlopen"
370
    prev=execute_dlfiles
371
    ;;
372

    
373
  -*)
374
    $echo "$modename: unrecognized option \`$arg'" 1>&2
375
    $echo "$help" 1>&2
376
    exit $EXIT_FAILURE
377
    ;;
378

    
379
  *)
380
    nonopt="$arg"
381
    break
382
    ;;
383
  esac
384
done
385

    
386
if test -n "$prevopt"; then
387
  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
388
  $echo "$help" 1>&2
389
  exit $EXIT_FAILURE
390
fi
391

    
392
# If this variable is set in any of the actions, the command in it
393
# will be execed at the end.  This prevents here-documents from being
394
# left over by shells.
395
exec_cmd=
396

    
397
if test -z "$show_help"; then
398

    
399
  # Infer the operation mode.
400
  if test -z "$mode"; then
401
    $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
402
    $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2
403
    case $nonopt in
404
    *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
405
      mode=link
406
      for arg
407
      do
408
	case $arg in
409
	-c)
410
	   mode=compile
411
	   break
412
	   ;;
413
	esac
414
      done
415
      ;;
416
    *db | *dbx | *strace | *truss)
417
      mode=execute
418
      ;;
419
    *install*|cp|mv)
420
      mode=install
421
      ;;
422
    *rm)
423
      mode=uninstall
424
      ;;
425
    *)
426
      # If we have no mode, but dlfiles were specified, then do execute mode.
427
      test -n "$execute_dlfiles" && mode=execute
428

    
429
      # Just use the default operation mode.
430
      if test -z "$mode"; then
431
	if test -n "$nonopt"; then
432
	  $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
433
	else
434
	  $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
435
	fi
436
      fi
437
      ;;
438
    esac
439
  fi
440

    
441
  # Only execute mode is allowed to have -dlopen flags.
442
  if test -n "$execute_dlfiles" && test "$mode" != execute; then
443
    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
444
    $echo "$help" 1>&2
445
    exit $EXIT_FAILURE
446
  fi
447

    
448
  # Change the help message to a mode-specific one.
449
  generic_help="$help"
450
  help="Try \`$modename --help --mode=$mode' for more information."
451

    
452
  # These modes are in order of execution frequency so that they run quickly.
453
  case $mode in
454
  # libtool compile mode
455
  compile)
456
    modename="$modename: compile"
457
    # Get the compilation command and the source file.
458
    base_compile=
459
    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
460
    suppress_opt=yes
461
    suppress_output=
462
    arg_mode=normal
463
    libobj=
464
    later=
465

    
466
    for arg
467
    do
468
      case "$arg_mode" in
469
      arg  )
470
	# do not "continue".  Instead, add this to base_compile
471
	lastarg="$arg"
472
	arg_mode=normal
473
	;;
474

    
475
      target )
476
	libobj="$arg"
477
	arg_mode=normal
478
	continue
479
	;;
480

    
481
      normal )
482
	# Accept any command-line options.
483
	case $arg in
484
	-o)
485
	  if test -n "$libobj" ; then
486
	    $echo "$modename: you cannot specify \`-o' more than once" 1>&2
487
	    exit $EXIT_FAILURE
488
	  fi
489
	  arg_mode=target
490
	  continue
491
	  ;;
492

    
493
	-static | -prefer-pic | -prefer-non-pic)
494
	  later="$later $arg"
495
	  continue
496
	  ;;
497

    
498
	-no-suppress)
499
	  suppress_opt=no
500
	  continue
501
	  ;;
502

    
503
	-Xcompiler)
504
	  arg_mode=arg  #  the next one goes into the "base_compile" arg list
505
	  continue      #  The current "srcfile" will either be retained or
506
	  ;;            #  replaced later.  I would guess that would be a bug.
507

    
508
	-Wc,*)
509
	  args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
510
	  lastarg=
511
	  save_ifs="$IFS"; IFS=','
512
 	  for arg in $args; do
513
	    IFS="$save_ifs"
514

    
515
	    # Double-quote args containing other shell metacharacters.
516
	    # Many Bourne shells cannot handle close brackets correctly
517
	    # in scan sets, so we specify it separately.
518
	    case $arg in
519
	      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
520
	      arg="\"$arg\""
521
	      ;;
522
	    esac
523
	    lastarg="$lastarg $arg"
524
	  done
525
	  IFS="$save_ifs"
526
	  lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
527

    
528
	  # Add the arguments to base_compile.
529
	  base_compile="$base_compile $lastarg"
530
	  continue
531
	  ;;
532

    
533
	* )
534
	  # Accept the current argument as the source file.
535
	  # The previous "srcfile" becomes the current argument.
536
	  #
537
	  lastarg="$srcfile"
538
	  srcfile="$arg"
539
	  ;;
540
	esac  #  case $arg
541
	;;
542
      esac    #  case $arg_mode
543

    
544
      # Aesthetically quote the previous argument.
545
      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
546

    
547
      case $lastarg in
548
      # Double-quote args containing other shell metacharacters.
549
      # Many Bourne shells cannot handle close brackets correctly
550
      # in scan sets, so we specify it separately.
551
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
552
	lastarg="\"$lastarg\""
553
	;;
554
      esac
555

    
556
      base_compile="$base_compile $lastarg"
557
    done # for arg
558

    
559
    case $arg_mode in
560
    arg)
561
      $echo "$modename: you must specify an argument for -Xcompile"
562
      exit $EXIT_FAILURE
563
      ;;
564
    target)
565
      $echo "$modename: you must specify a target with \`-o'" 1>&2
566
      exit $EXIT_FAILURE
567
      ;;
568
    *)
569
      # Get the name of the library object.
570
      [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
571
      ;;
572
    esac
573

    
574
    # Recognize several different file suffixes.
575
    # If the user specifies -o file.o, it is replaced with file.lo
576
    xform='[cCFSifmso]'
577
    case $libobj in
578
    *.ada) xform=ada ;;
579
    *.adb) xform=adb ;;
580
    *.ads) xform=ads ;;
581
    *.asm) xform=asm ;;
582
    *.c++) xform=c++ ;;
583
    *.cc) xform=cc ;;
584
    *.ii) xform=ii ;;
585
    *.class) xform=class ;;
586
    *.cpp) xform=cpp ;;
587
    *.cxx) xform=cxx ;;
588
    *.f90) xform=f90 ;;
589
    *.for) xform=for ;;
590
    *.java) xform=java ;;
591
    esac
592

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

    
595
    case $libobj in
596
    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
597
    *)
598
      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
599
      exit $EXIT_FAILURE
600
      ;;
601
    esac
602

    
603
    func_infer_tag $base_compile
604

    
605
    for arg in $later; do
606
      case $arg in
607
      -static)
608
	build_old_libs=yes
609
	continue
610
	;;
611

    
612
      -prefer-pic)
613
	pic_mode=yes
614
	continue
615
	;;
616

    
617
      -prefer-non-pic)
618
	pic_mode=no
619
	continue
620
	;;
621
      esac
622
    done
623

    
624
    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
625
    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
626
    if test "X$xdir" = "X$obj"; then
627
      xdir=
628
    else
629
      xdir=$xdir/
630
    fi
631
    lobj=${xdir}$objdir/$objname
632

    
633
    if test -z "$base_compile"; then
634
      $echo "$modename: you must specify a compilation command" 1>&2
635
      $echo "$help" 1>&2
636
      exit $EXIT_FAILURE
637
    fi
638

    
639
    # Delete any leftover library objects.
640
    if test "$build_old_libs" = yes; then
641
      removelist="$obj $lobj $libobj ${libobj}T"
642
    else
643
      removelist="$lobj $libobj ${libobj}T"
644
    fi
645

    
646
    $run $rm $removelist
647
    trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
648

    
649
    # On Cygwin there's no "real" PIC flag so we must build both object types
650
    case $host_os in
651
    cygwin* | mingw* | pw32* | os2*)
652
      pic_mode=default
653
      ;;
654
    esac
655
    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
656
      # non-PIC code in shared libraries is not supported
657
      pic_mode=default
658
    fi
659

    
660
    # Calculate the filename of the output object if compiler does
661
    # not support -o with -c
662
    if test "$compiler_c_o" = no; then
663
      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
664
      lockfile="$output_obj.lock"
665
      removelist="$removelist $output_obj $lockfile"
666
      trap "$run $rm $removelist; exit $EXIT_FAILURE" 1 2 15
667
    else
668
      output_obj=
669
      need_locks=no
670
      lockfile=
671
    fi
672

    
673
    # Lock this critical section if it is needed
674
    # We use this script file to make the link, it avoids creating a new file
675
    if test "$need_locks" = yes; then
676
      until $run ln "$progpath" "$lockfile" 2>/dev/null; do
677
	$show "Waiting for $lockfile to be removed"
678
	sleep 2
679
      done
680
    elif test "$need_locks" = warn; then
681
      if test -f "$lockfile"; then
682
	$echo "\
683
*** ERROR, $lockfile exists and contains:
684
`cat $lockfile 2>/dev/null`
685

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

    
693
	$run $rm $removelist
694
	exit $EXIT_FAILURE
695
      fi
696
      $echo $srcfile > "$lockfile"
697
    fi
698

    
699
    if test -n "$fix_srcfile_path"; then
700
      eval srcfile=\"$fix_srcfile_path\"
701
    fi
702

    
703
    $run $rm "$libobj" "${libobj}T"
704

    
705
    # Create a libtool object file (analogous to a ".la" file),
706
    # but don't create it if we're doing a dry run.
707
    test -z "$run" && cat > ${libobj}T <<EOF
708
# $libobj - a libtool object file
709
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
710
#
711
# Please DO NOT delete this file!
712
# It is necessary for linking the library.
713

    
714
# Name of the PIC object.
715
EOF
716

    
717
    # Only build a PIC object if we are building libtool libraries.
718
    if test "$build_libtool_libs" = yes; then
719
      # Without this assignment, base_compile gets emptied.
720
      fbsd_hideous_sh_bug=$base_compile
721

    
722
      if test "$pic_mode" != no; then
723
	command="$base_compile $srcfile $pic_flag"
724
      else
725
	# Don't build PIC code
726
	command="$base_compile $srcfile"
727
      fi
728

    
729
      if test ! -d "${xdir}$objdir"; then
730
	$show "$mkdir ${xdir}$objdir"
731
	$run $mkdir ${xdir}$objdir
732
	status=$?
733
	if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
734
	  exit $status
735
	fi
736
      fi
737

    
738
      if test -z "$output_obj"; then
739
	# Place PIC objects in $objdir
740
	command="$command -o $lobj"
741
      fi
742

    
743
      $run $rm "$lobj" "$output_obj"
744

    
745
      $show "$command"
746
      if $run eval "$command"; then :
747
      else
748
	test -n "$output_obj" && $run $rm $removelist
749
	exit $EXIT_FAILURE
750
      fi
751

    
752
      if test "$need_locks" = warn &&
753
	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
754
	$echo "\
755
*** ERROR, $lockfile contains:
756
`cat $lockfile 2>/dev/null`
757

    
758
but it should contain:
759
$srcfile
760

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

    
768
	$run $rm $removelist
769
	exit $EXIT_FAILURE
770
      fi
771

    
772
      # Just move the object if needed, then go on to compile the next one
773
      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
774
	$show "$mv $output_obj $lobj"
775
	if $run $mv $output_obj $lobj; then :
776
	else
777
	  error=$?
778
	  $run $rm $removelist
779
	  exit $error
780
	fi
781
      fi
782

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

    
787
EOF
788

    
789
      # Allow error messages only from the first compilation.
790
      if test "$suppress_opt" = yes; then
791
        suppress_output=' >/dev/null 2>&1'
792
      fi
793
    else
794
      # No PIC object so indicate it doesn't exist in the libtool
795
      # object file.
796
      test -z "$run" && cat >> ${libobj}T <<EOF
797
pic_object=none
798

    
799
EOF
800
    fi
801

    
802
    # Only build a position-dependent object if we build old libraries.
803
    if test "$build_old_libs" = yes; then
804
      if test "$pic_mode" != yes; then
805
	# Don't build PIC code
806
	command="$base_compile $srcfile"
807
      else
808
	command="$base_compile $srcfile $pic_flag"
809
      fi
810
      if test "$compiler_c_o" = yes; then
811
	command="$command -o $obj"
812
      fi
813

    
814
      # Suppress compiler output if we already did a PIC compilation.
815
      command="$command$suppress_output"
816
      $run $rm "$obj" "$output_obj"
817
      $show "$command"
818
      if $run eval "$command"; then :
819
      else
820
	$run $rm $removelist
821
	exit $EXIT_FAILURE
822
      fi
823

    
824
      if test "$need_locks" = warn &&
825
	 test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
826
	$echo "\
827
*** ERROR, $lockfile contains:
828
`cat $lockfile 2>/dev/null`
829

    
830
but it should contain:
831
$srcfile
832

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

    
840
	$run $rm $removelist
841
	exit $EXIT_FAILURE
842
      fi
843

    
844
      # Just move the object if needed
845
      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
846
	$show "$mv $output_obj $obj"
847
	if $run $mv $output_obj $obj; then :
848
	else
849
	  error=$?
850
	  $run $rm $removelist
851
	  exit $error
852
	fi
853
      fi
854

    
855
      # Append the name of the non-PIC object the libtool object file.
856
      # Only append if the libtool object file exists.
857
      test -z "$run" && cat >> ${libobj}T <<EOF
858
# Name of the non-PIC object.
859
non_pic_object='$objname'
860

    
861
EOF
862
    else
863
      # Append the name of the non-PIC object the libtool object file.
864
      # Only append if the libtool object file exists.
865
      test -z "$run" && cat >> ${libobj}T <<EOF
866
# Name of the non-PIC object.
867
non_pic_object=none
868

    
869
EOF
870
    fi
871

    
872
    $run $mv "${libobj}T" "${libobj}"
873

    
874
    # Unlock the critical section if it was locked
875
    if test "$need_locks" != no; then
876
      $run $rm "$lockfile"
877
    fi
878

    
879
    exit $EXIT_SUCCESS
880
    ;;
881

    
882
  # libtool link mode
883
  link | relink)
884
    modename="$modename: link"
885
    case $host in
886
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
887
      # It is impossible to link a dll without this setting, and
888
      # we shouldn't force the makefile maintainer to figure out
889
      # which system we are compiling for in order to pass an extra
890
      # flag for every libtool invocation.
891
      # allow_undefined=no
892

    
893
      # FIXME: Unfortunately, there are problems with the above when trying
894
      # to make a dll which has undefined symbols, in which case not
895
      # even a static library is built.  For now, we need to specify
896
      # -no-undefined on the libtool link line when we can be certain
897
      # that all symbols are satisfied, otherwise we get a static library.
898
      allow_undefined=yes
899
      ;;
900
    *)
901
      allow_undefined=yes
902
      ;;
903
    esac
904
    libtool_args="$nonopt"
905
    base_compile="$nonopt $@"
906
    compile_command="$nonopt"
907
    finalize_command="$nonopt"
908

    
909
    compile_rpath=
910
    finalize_rpath=
911
    compile_shlibpath=
912
    finalize_shlibpath=
913
    convenience=
914
    old_convenience=
915
    deplibs=
916
    old_deplibs=
917
    compiler_flags=
918
    linker_flags=
919
    dllsearchpath=
920
    lib_search_path=`pwd`
921
    inst_prefix_dir=
922

    
923
    avoid_version=no
924
    dlfiles=
925
    dlprefiles=
926
    dlself=no
927
    export_dynamic=no
928
    export_symbols=
929
    export_symbols_regex=
930
    generated=
931
    libobjs=
932
    ltlibs=
933
    module=no
934
    no_install=no
935
    objs=
936
    non_pic_objects=
937
    precious_files_regex=
938
    prefer_static_libs=no
939
    preload=no
940
    prev=
941
    prevarg=
942
    release=
943
    rpath=
944
    xrpath=
945
    perm_rpath=
946
    temp_rpath=
947
    thread_safe=no
948
    vinfo=
949
    vinfo_number=no
950

    
951
    func_infer_tag $base_compile
952

    
953
    # We need to know -static, to get the right output filenames.
954
    for arg
955
    do
956
      case $arg in
957
      -all-static | -static)
958
	if test "X$arg" = "X-all-static"; then
959
	  if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
960
	    $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
961
	  fi
962
	  if test -n "$link_static_flag"; then
963
	    dlopen_self=$dlopen_self_static
964
	  fi
965
	else
966
	  if test -z "$pic_flag" && test -n "$link_static_flag"; then
967
	    dlopen_self=$dlopen_self_static
968
	  fi
969
	fi
970
	build_libtool_libs=no
971
	build_old_libs=yes
972
	prefer_static_libs=yes
973
	break
974
	;;
975
      esac
976
    done
977

    
978
    # See if our shared archives depend on static archives.
979
    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
980

    
981
    # Go through the arguments, transforming them on the way.
982
    while test "$#" -gt 0; do
983
      arg="$1"
984
      shift
985
      case $arg in
986
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
987
	qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
988
	;;
989
      *) qarg=$arg ;;
990
      esac
991
      libtool_args="$libtool_args $qarg"
992

    
993
      # If the previous option needs an argument, assign it.
994
      if test -n "$prev"; then
995
	case $prev in
996
	output)
997
	  compile_command="$compile_command @OUTPUT@"
998
	  finalize_command="$finalize_command @OUTPUT@"
999
	  ;;
1000
	esac
1001

    
1002
	case $prev in
1003
	dlfiles|dlprefiles)
1004
	  if test "$preload" = no; then
1005
	    # Add the symbol object into the linking commands.
1006
	    compile_command="$compile_command @SYMFILE@"
1007
	    finalize_command="$finalize_command @SYMFILE@"
1008
	    preload=yes
1009
	  fi
1010
	  case $arg in
1011
	  *.la | *.lo) ;;  # We handle these cases below.
1012
	  force)
1013
	    if test "$dlself" = no; then
1014
	      dlself=needless
1015
	      export_dynamic=yes
1016
	    fi
1017
	    prev=
1018
	    continue
1019
	    ;;
1020
	  self)
1021
	    if test "$prev" = dlprefiles; then
1022
	      dlself=yes
1023
	    elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
1024
	      dlself=yes
1025
	    else
1026
	      dlself=needless
1027
	      export_dynamic=yes
1028
	    fi
1029
	    prev=
1030
	    continue
1031
	    ;;
1032
	  *)
1033
	    if test "$prev" = dlfiles; then
1034
	      dlfiles="$dlfiles $arg"
1035
	    else
1036
	      dlprefiles="$dlprefiles $arg"
1037
	    fi
1038
	    prev=
1039
	    continue
1040
	    ;;
1041
	  esac
1042
	  ;;
1043
	expsyms)
1044
	  export_symbols="$arg"
1045
	  if test ! -f "$arg"; then
1046
	    $echo "$modename: symbol file \`$arg' does not exist"
1047
	    exit $EXIT_FAILURE
1048
	  fi
1049
	  prev=
1050
	  continue
1051
	  ;;
1052
	expsyms_regex)
1053
	  export_symbols_regex="$arg"
1054
	  prev=
1055
	  continue
1056
	  ;;
1057
	inst_prefix)
1058
	  inst_prefix_dir="$arg"
1059
	  prev=
1060
	  continue
1061
	  ;;
1062
	precious_regex)
1063
	  precious_files_regex="$arg"
1064
	  prev=
1065
	  continue
1066
	  ;;
1067
	release)
1068
	  release="-$arg"
1069
	  prev=
1070
	  continue
1071
	  ;;
1072
	objectlist)
1073
	  if test -f "$arg"; then
1074
	    save_arg=$arg
1075
	    moreargs=
1076
	    for fil in `cat $save_arg`
1077
	    do
1078
#	      moreargs="$moreargs $fil"
1079
	      arg=$fil
1080
	      # A libtool-controlled object.
1081

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

    
1087
		# Read the .lo file
1088
		# If there is no directory component, then add one.
1089
		case $arg in
1090
		*/* | *\\*) . $arg ;;
1091
		*) . ./$arg ;;
1092
		esac
1093

    
1094
		if test -z "$pic_object" || \
1095
		   test -z "$non_pic_object" ||
1096
		   test "$pic_object" = none && \
1097
		   test "$non_pic_object" = none; then
1098
		  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1099
		  exit $EXIT_FAILURE
1100
		fi
1101

    
1102
		# Extract subdirectory from the argument.
1103
		xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1104
		if test "X$xdir" = "X$arg"; then
1105
		  xdir=
1106
		else
1107
		  xdir="$xdir/"
1108
		fi
1109

    
1110
		if test "$pic_object" != none; then
1111
		  # Prepend the subdirectory the object is found in.
1112
		  pic_object="$xdir$pic_object"
1113

    
1114
		  if test "$prev" = dlfiles; then
1115
		    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1116
		      dlfiles="$dlfiles $pic_object"
1117
		      prev=
1118
		      continue
1119
		    else
1120
		      # If libtool objects are unsupported, then we need to preload.
1121
		      prev=dlprefiles
1122
		    fi
1123
		  fi
1124

    
1125
		  # CHECK ME:  I think I busted this.  -Ossama
1126
		  if test "$prev" = dlprefiles; then
1127
		    # Preload the old-style object.
1128
		    dlprefiles="$dlprefiles $pic_object"
1129
		    prev=
1130
		  fi
1131

    
1132
		  # A PIC object.
1133
		  libobjs="$libobjs $pic_object"
1134
		  arg="$pic_object"
1135
		fi
1136

    
1137
		# Non-PIC object.
1138
		if test "$non_pic_object" != none; then
1139
		  # Prepend the subdirectory the object is found in.
1140
		  non_pic_object="$xdir$non_pic_object"
1141

    
1142
		  # A standard non-PIC object
1143
		  non_pic_objects="$non_pic_objects $non_pic_object"
1144
		  if test -z "$pic_object" || test "$pic_object" = none ; then
1145
		    arg="$non_pic_object"
1146
		  fi
1147
		fi
1148
	      else
1149
		# Only an error if not doing a dry-run.
1150
		if test -z "$run"; then
1151
		  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1152
		  exit $EXIT_FAILURE
1153
		else
1154
		  # Dry-run case.
1155

    
1156
		  # Extract subdirectory from the argument.
1157
		  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1158
		  if test "X$xdir" = "X$arg"; then
1159
		    xdir=
1160
		  else
1161
		    xdir="$xdir/"
1162
		  fi
1163

    
1164
		  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1165
		  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1166
		  libobjs="$libobjs $pic_object"
1167
		  non_pic_objects="$non_pic_objects $non_pic_object"
1168
		fi
1169
	      fi
1170
	    done
1171
	  else
1172
	    $echo "$modename: link input file \`$save_arg' does not exist"
1173
	    exit $EXIT_FAILURE
1174
	  fi
1175
	  arg=$save_arg
1176
	  prev=
1177
	  continue
1178
	  ;;
1179
	rpath | xrpath)
1180
	  # We need an absolute path.
1181
	  case $arg in
1182
	  [\\/]* | [A-Za-z]:[\\/]*) ;;
1183
	  *)
1184
	    $echo "$modename: only absolute run-paths are allowed" 1>&2
1185
	    exit $EXIT_FAILURE
1186
	    ;;
1187
	  esac
1188
	  if test "$prev" = rpath; then
1189
	    case "$rpath " in
1190
	    *" $arg "*) ;;
1191
	    *) rpath="$rpath $arg" ;;
1192
	    esac
1193
	  else
1194
	    case "$xrpath " in
1195
	    *" $arg "*) ;;
1196
	    *) xrpath="$xrpath $arg" ;;
1197
	    esac
1198
	  fi
1199
	  prev=
1200
	  continue
1201
	  ;;
1202
	xcompiler)
1203
	  compiler_flags="$compiler_flags $qarg"
1204
	  prev=
1205
	  compile_command="$compile_command $qarg"
1206
	  finalize_command="$finalize_command $qarg"
1207
	  continue
1208
	  ;;
1209
	xlinker)
1210
	  linker_flags="$linker_flags $qarg"
1211
	  compiler_flags="$compiler_flags $wl$qarg"
1212
	  prev=
1213
	  compile_command="$compile_command $wl$qarg"
1214
	  finalize_command="$finalize_command $wl$qarg"
1215
	  continue
1216
	  ;;
1217
	xcclinker)
1218
	  linker_flags="$linker_flags $qarg"
1219
	  compiler_flags="$compiler_flags $qarg"
1220
	  prev=
1221
	  compile_command="$compile_command $qarg"
1222
	  finalize_command="$finalize_command $qarg"
1223
	  continue
1224
	  ;;
1225
	shrext)
1226
  	  shrext_cmds="$arg"
1227
	  prev=
1228
	  continue
1229
	  ;;
1230
	*)
1231
	  eval "$prev=\"\$arg\""
1232
	  prev=
1233
	  continue
1234
	  ;;
1235
	esac
1236
      fi # test -n "$prev"
1237

    
1238
      prevarg="$arg"
1239

    
1240
      case $arg in
1241
      -all-static)
1242
	if test -n "$link_static_flag"; then
1243
	  compile_command="$compile_command $link_static_flag"
1244
	  finalize_command="$finalize_command $link_static_flag"
1245
	fi
1246
	continue
1247
	;;
1248

    
1249
      -allow-undefined)
1250
	# FIXME: remove this flag sometime in the future.
1251
	$echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1252
	continue
1253
	;;
1254

    
1255
      -avoid-version)
1256
	avoid_version=yes
1257
	continue
1258
	;;
1259

    
1260
      -dlopen)
1261
	prev=dlfiles
1262
	continue
1263
	;;
1264

    
1265
      -dlpreopen)
1266
	prev=dlprefiles
1267
	continue
1268
	;;
1269

    
1270
      -export-dynamic)
1271
	export_dynamic=yes
1272
	continue
1273
	;;
1274

    
1275
      -export-symbols | -export-symbols-regex)
1276
	if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1277
	  $echo "$modename: more than one -exported-symbols argument is not allowed"
1278
	  exit $EXIT_FAILURE
1279
	fi
1280
	if test "X$arg" = "X-export-symbols"; then
1281
	  prev=expsyms
1282
	else
1283
	  prev=expsyms_regex
1284
	fi
1285
	continue
1286
	;;
1287

    
1288
      -inst-prefix-dir)
1289
	prev=inst_prefix
1290
	continue
1291
	;;
1292

    
1293
      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1294
      # so, if we see these flags be careful not to treat them like -L
1295
      -L[A-Z][A-Z]*:*)
1296
	case $with_gcc/$host in
1297
	no/*-*-irix* | /*-*-irix*)
1298
	  compile_command="$compile_command $arg"
1299
	  finalize_command="$finalize_command $arg"
1300
	  ;;
1301
	esac
1302
	continue
1303
	;;
1304

    
1305
      -L*)
1306
	dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1307
	# We need an absolute path.
1308
	case $dir in
1309
	[\\/]* | [A-Za-z]:[\\/]*) ;;
1310
	*)
1311
	  absdir=`cd "$dir" && pwd`
1312
	  if test -z "$absdir"; then
1313
	    $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1314
	    exit $EXIT_FAILURE
1315
	  fi
1316
	  dir="$absdir"
1317
	  ;;
1318
	esac
1319
	case "$deplibs " in
1320
	*" -L$dir "*) ;;
1321
	*)
1322
	  deplibs="$deplibs -L$dir"
1323
	  lib_search_path="$lib_search_path $dir"
1324
	  ;;
1325
	esac
1326
	case $host in
1327
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1328
	  case :$dllsearchpath: in
1329
	  *":$dir:"*) ;;
1330
	  *) dllsearchpath="$dllsearchpath:$dir";;
1331
	  esac
1332
	  ;;
1333
	esac
1334
	continue
1335
	;;
1336

    
1337
      -l*)
1338
	if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1339
	  case $host in
1340
	  *-*-cygwin* | *-*-pw32* | *-*-beos*)
1341
	    # These systems don't actually have a C or math library (as such)
1342
	    continue
1343
	    ;;
1344
	  *-*-mingw* | *-*-os2*)
1345
	    # These systems don't actually have a C library (as such)
1346
	    test "X$arg" = "X-lc" && continue
1347
	    ;;
1348
	  *-*-openbsd* | *-*-freebsd*)
1349
	    # Do not include libc due to us having libc/libc_r.
1350
	    test "X$arg" = "X-lc" && continue
1351
	    ;;
1352
	  *-*-rhapsody* | *-*-darwin1.[012])
1353
	    # Rhapsody C and math libraries are in the System framework
1354
	    deplibs="$deplibs -framework System"
1355
	    continue
1356
	  esac
1357
	elif test "X$arg" = "X-lc_r"; then
1358
	 case $host in
1359
	 *-*-openbsd* | *-*-freebsd*)
1360
	   # Do not include libc_r directly, use -pthread flag.
1361
	   continue
1362
	   ;;
1363
	 esac
1364
	fi
1365
	deplibs="$deplibs $arg"
1366
	continue
1367
	;;
1368

    
1369
     -mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1370
	deplibs="$deplibs $arg"
1371
	continue
1372
	;;
1373

    
1374
      -module)
1375
	module=yes
1376
	continue
1377
	;;
1378

    
1379
      # gcc -m* arguments should be passed to the linker via $compiler_flags
1380
      # in order to pass architecture information to the linker
1381
      # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
1382
      # but this is not reliable with gcc because gcc may use -mfoo to
1383
      # select a different linker, different libraries, etc, while
1384
      # -Wl,-mfoo simply passes -mfoo to the linker.
1385
      -m*)
1386
	# Unknown arguments in both finalize_command and compile_command need
1387
	# to be aesthetically quoted because they are evaled later.
1388
	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1389
	case $arg in
1390
	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
1391
	  arg="\"$arg\""
1392
	  ;;
1393
	esac
1394
        compile_command="$compile_command $arg"
1395
        finalize_command="$finalize_command $arg"
1396
        if test "$with_gcc" = "yes" ; then
1397
          compiler_flags="$compiler_flags $arg"
1398
        fi
1399
        continue
1400
        ;;
1401

    
1402
      -shrext)
1403
	prev=shrext
1404
	continue
1405
	;;
1406

    
1407
      -no-fast-install)
1408
	fast_install=no
1409
	continue
1410
	;;
1411

    
1412
      -no-install)
1413
	case $host in
1414
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1415
	  # The PATH hackery in wrapper scripts is required on Windows
1416
	  # in order for the loader to find any dlls it needs.
1417
	  $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1418
	  $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1419
	  fast_install=no
1420
	  ;;
1421
	*) no_install=yes ;;
1422
	esac
1423
	continue
1424
	;;
1425

    
1426
      -no-undefined)
1427
	allow_undefined=no
1428
	continue
1429
	;;
1430

    
1431
      -objectlist)
1432
	prev=objectlist
1433
	continue
1434
	;;
1435

    
1436
      -o) prev=output ;;
1437

    
1438
      -precious-files-regex)
1439
	prev=precious_regex
1440
	continue
1441
	;;
1442

    
1443
      -release)
1444
	prev=release
1445
	continue
1446
	;;
1447

    
1448
      -rpath)
1449
	prev=rpath
1450
	continue
1451
	;;
1452

    
1453
      -R)
1454
	prev=xrpath
1455
	continue
1456
	;;
1457

    
1458
      -R*)
1459
	dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1460
	# We need an absolute path.
1461
	case $dir in
1462
	[\\/]* | [A-Za-z]:[\\/]*) ;;
1463
	*)
1464
	  $echo "$modename: only absolute run-paths are allowed" 1>&2
1465
	  exit $EXIT_FAILURE
1466
	  ;;
1467
	esac
1468
	case "$xrpath " in
1469
	*" $dir "*) ;;
1470
	*) xrpath="$xrpath $dir" ;;
1471
	esac
1472
	continue
1473
	;;
1474

    
1475
      -static)
1476
	# The effects of -static are defined in a previous loop.
1477
	# We used to do the same as -all-static on platforms that
1478
	# didn't have a PIC flag, but the assumption that the effects
1479
	# would be equivalent was wrong.  It would break on at least
1480
	# Digital Unix and AIX.
1481
	continue
1482
	;;
1483

    
1484
      -thread-safe)
1485
	thread_safe=yes
1486
	continue
1487
	;;
1488

    
1489
      -version-info)
1490
	prev=vinfo
1491
	continue
1492
	;;
1493
      -version-number)
1494
	prev=vinfo
1495
	vinfo_number=yes
1496
	continue
1497
	;;
1498

    
1499
      -Wc,*)
1500
	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1501
	arg=
1502
	save_ifs="$IFS"; IFS=','
1503
	for flag in $args; do
1504
	  IFS="$save_ifs"
1505
	  case $flag in
1506
	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
1507
	    flag="\"$flag\""
1508
	    ;;
1509
	  esac
1510
	  arg="$arg $wl$flag"
1511
	  compiler_flags="$compiler_flags $flag"
1512
	done
1513
	IFS="$save_ifs"
1514
	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1515
	;;
1516

    
1517
      -Wl,*)
1518
	args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1519
	arg=
1520
	save_ifs="$IFS"; IFS=','
1521
	for flag in $args; do
1522
	  IFS="$save_ifs"
1523
	  case $flag in
1524
	    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
1525
	    flag="\"$flag\""
1526
	    ;;
1527
	  esac
1528
	  arg="$arg $wl$flag"
1529
	  compiler_flags="$compiler_flags $wl$flag"
1530
	  linker_flags="$linker_flags $flag"
1531
	done
1532
	IFS="$save_ifs"
1533
	arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1534
	;;
1535

    
1536
      -Xcompiler)
1537
	prev=xcompiler
1538
	continue
1539
	;;
1540

    
1541
      -Xlinker)
1542
	prev=xlinker
1543
	continue
1544
	;;
1545

    
1546
      -XCClinker)
1547
	prev=xcclinker
1548
	continue
1549
	;;
1550

    
1551
      # Some other compiler flag.
1552
      -* | +*)
1553
	# Unknown arguments in both finalize_command and compile_command need
1554
	# to be aesthetically quoted because they are evaled later.
1555
	arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1556
	case $arg in
1557
	*[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*|"")
1558
	  arg="\"$arg\""
1559
	  ;;
1560
	esac
1561
	;;
1562

    
1563
      *.$objext)
1564
	# A standard object.
1565
	objs="$objs $arg"
1566
	;;
1567

    
1568
      *.lo)
1569
	# A libtool-controlled object.
1570

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

    
1576
	  # Read the .lo file
1577
	  # If there is no directory component, then add one.
1578
	  case $arg in
1579
	  */* | *\\*) . $arg ;;
1580
	  *) . ./$arg ;;
1581
	  esac
1582

    
1583
	  if test -z "$pic_object" || \
1584
	     test -z "$non_pic_object" ||
1585
	     test "$pic_object" = none && \
1586
	     test "$non_pic_object" = none; then
1587
	    $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1588
	    exit $EXIT_FAILURE
1589
	  fi
1590

    
1591
	  # Extract subdirectory from the argument.
1592
	  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1593
	  if test "X$xdir" = "X$arg"; then
1594
	    xdir=
1595
 	  else
1596
	    xdir="$xdir/"
1597
	  fi
1598

    
1599
	  if test "$pic_object" != none; then
1600
	    # Prepend the subdirectory the object is found in.
1601
	    pic_object="$xdir$pic_object"
1602

    
1603
	    if test "$prev" = dlfiles; then
1604
	      if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1605
		dlfiles="$dlfiles $pic_object"
1606
		prev=
1607
		continue
1608
	      else
1609
		# If libtool objects are unsupported, then we need to preload.
1610
		prev=dlprefiles
1611
	      fi
1612
	    fi
1613

    
1614
	    # CHECK ME:  I think I busted this.  -Ossama
1615
	    if test "$prev" = dlprefiles; then
1616
	      # Preload the old-style object.
1617
	      dlprefiles="$dlprefiles $pic_object"
1618
	      prev=
1619
	    fi
1620

    
1621
	    # A PIC object.
1622
	    libobjs="$libobjs $pic_object"
1623
	    arg="$pic_object"
1624
	  fi
1625

    
1626
	  # Non-PIC object.
1627
	  if test "$non_pic_object" != none; then
1628
	    # Prepend the subdirectory the object is found in.
1629
	    non_pic_object="$xdir$non_pic_object"
1630

    
1631
	    # A standard non-PIC object
1632
	    non_pic_objects="$non_pic_objects $non_pic_object"
1633
	    if test -z "$pic_object" || test "$pic_object" = none ; then
1634
	      arg="$non_pic_object"
1635
	    fi
1636
	  fi
1637
	else
1638
	  # Only an error if not doing a dry-run.
1639
	  if test -z "$run"; then
1640
	    $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1641
	    exit $EXIT_FAILURE
1642
	  else
1643
	    # Dry-run case.
1644

    
1645
	    # Extract subdirectory from the argument.
1646
	    xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1647
	    if test "X$xdir" = "X$arg"; then
1648
	      xdir=
1649
	    else
1650
	      xdir="$xdir/"
1651
	    fi
1652

    
1653
	    pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1654
	    non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1655
	    libobjs="$libobjs $pic_object"
1656
	    non_pic_objects="$non_pic_objects $non_pic_object"
1657
	  fi
1658
	fi
1659
	;;
1660

    
1661
      *.$libext)
1662
	# An archive.
1663
	deplibs="$deplibs $arg"
1664
	old_deplibs="$old_deplibs $arg"
1665
	continue
1666
	;;
1667

    
1668
      *.la)
1669
	# A libtool-controlled library.
1670

    
1671
	if test "$prev" = dlfiles; then
1672
	  # This library was specified with -dlopen.
1673
	  dlfiles="$dlfiles $arg"
1674
	  prev=
1675
	elif test "$prev" = dlprefiles; then
1676
	  # The library was specified with -dlpreopen.
1677
	  dlprefiles="$dlprefiles $arg"
1678
	  prev=
1679
	else
1680
	  deplibs="$deplibs $arg"
1681
	fi
1682
	continue
1683
	;;
1684

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

    
1698
      # Now actually substitute the argument into the commands.
1699
      if test -n "$arg"; then
1700
	compile_command="$compile_command $arg"
1701
	finalize_command="$finalize_command $arg"
1702
      fi
1703
    done # argument parsing loop
1704

    
1705
    if test -n "$prev"; then
1706
      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1707
      $echo "$help" 1>&2
1708
      exit $EXIT_FAILURE
1709
    fi
1710

    
1711
    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1712
      eval arg=\"$export_dynamic_flag_spec\"
1713
      compile_command="$compile_command $arg"
1714
      finalize_command="$finalize_command $arg"
1715
    fi
1716

    
1717
    oldlibs=
1718
    # calculate the name of the file, without its directory
1719
    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1720
    libobjs_save="$libobjs"
1721

    
1722
    if test -n "$shlibpath_var"; then
1723
      # get the directories listed in $shlibpath_var
1724
      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1725
    else
1726
      shlib_search_path=
1727
    fi
1728
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1729
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1730

    
1731
    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1732
    if test "X$output_objdir" = "X$output"; then
1733
      output_objdir="$objdir"
1734
    else
1735
      output_objdir="$output_objdir/$objdir"
1736
    fi
1737
    # Create the object directory.
1738
    if test ! -d "$output_objdir"; then
1739
      $show "$mkdir $output_objdir"
1740
      $run $mkdir $output_objdir
1741
      status=$?
1742
      if test "$status" -ne 0 && test ! -d "$output_objdir"; then
1743
	exit $status
1744
      fi
1745
    fi
1746

    
1747
    # Determine the type of output
1748
    case $output in
1749
    "")
1750
      $echo "$modename: you must specify an output file" 1>&2
1751
      $echo "$help" 1>&2
1752
      exit $EXIT_FAILURE
1753
      ;;
1754
    *.$libext) linkmode=oldlib ;;
1755
    *.lo | *.$objext) linkmode=obj ;;
1756
    *.la) linkmode=lib ;;
1757
    *) linkmode=prog ;; # Anything else should be a program.
1758
    esac
1759

    
1760
    case $host in
1761
    *cygwin* | *mingw* | *pw32*)
1762
      # don't eliminate duplications in $postdeps and $predeps
1763
      duplicate_compiler_generated_deps=yes
1764
      ;;
1765
    *)
1766
      duplicate_compiler_generated_deps=$duplicate_deps
1767
      ;;
1768
    esac
1769
    specialdeplibs=
1770

    
1771
    libs=
1772
    # Find all interdependent deplibs by searching for libraries
1773
    # that are linked more than once (e.g. -la -lb -la)
1774
    for deplib in $deplibs; do
1775
      if test "X$duplicate_deps" = "Xyes" ; then
1776
	case "$libs " in
1777
	*" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1778
	esac
1779
      fi
1780
      libs="$libs $deplib"
1781
    done
1782

    
1783
    if test "$linkmode" = lib; then
1784
      libs="$predeps $libs $compiler_lib_search_path $postdeps"
1785

    
1786
      # Compute libraries that are listed more than once in $predeps
1787
      # $postdeps and mark them as special (i.e., whose duplicates are
1788
      # not to be eliminated).
1789
      pre_post_deps=
1790
      if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
1791
	for pre_post_dep in $predeps $postdeps; do
1792
	  case "$pre_post_deps " in
1793
	  *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1794
	  esac
1795
	  pre_post_deps="$pre_post_deps $pre_post_dep"
1796
	done
1797
      fi
1798
      pre_post_deps=
1799
    fi
1800

    
1801
    deplibs=
1802
    newdependency_libs=
1803
    newlib_search_path=
1804
    need_relink=no # whether we're linking any uninstalled libtool libraries
1805
    notinst_deplibs= # not-installed libtool libraries
1806
    notinst_path= # paths that contain not-installed libtool libraries
1807
    case $linkmode in
1808
    lib)
1809
	passes="conv link"
1810
	for file in $dlfiles $dlprefiles; do
1811
	  case $file in
1812
	  *.la) ;;
1813
	  *)
1814
	    $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1815
	    exit $EXIT_FAILURE
1816
	    ;;
1817
	  esac
1818
	done
1819
	;;
1820
    prog)
1821
	compile_deplibs=
1822
	finalize_deplibs=
1823
	alldeplibs=no
1824
	newdlfiles=
1825
	newdlprefiles=
1826
	passes="conv scan dlopen dlpreopen link"
1827
	;;
1828
    *)  passes="conv"
1829
	;;
1830
    esac
1831
    for pass in $passes; do
1832
      if test "$linkmode,$pass" = "lib,link" ||
1833
	 test "$linkmode,$pass" = "prog,scan"; then
1834
	libs="$deplibs"
1835
	deplibs=
1836
      fi
1837
      if test "$linkmode" = prog; then
1838
	case $pass in
1839
	dlopen) libs="$dlfiles" ;;
1840
	dlpreopen) libs="$dlprefiles" ;;
1841
	link)
1842
	  libs="$deplibs %DEPLIBS%"
1843
	  test "X$link_all_deplibs" != Xno && libs="$libs $dependency_libs"
1844
	  ;;
1845
	esac
1846
      fi
1847
      if test "$pass" = dlopen; then
1848
	# Collect dlpreopened libraries
1849
	save_deplibs="$deplibs"
1850
	deplibs=
1851
      fi
1852
      for deplib in $libs; do
1853
	lib=
1854
	found=no
1855
	case $deplib in
1856
	-mt|-mthreads|-kthread|-Kthread|-pthread|-pthreads|--thread-safe)
1857
	  if test "$linkmode,$pass" = "prog,link"; then
1858
	    compile_deplibs="$deplib $compile_deplibs"
1859
	    finalize_deplibs="$deplib $finalize_deplibs"
1860
	  else
1861
	    deplibs="$deplib $deplibs"
1862
	  fi
1863
	  continue
1864
	  ;;
1865
	-l*)
1866
	  if test "$linkmode" != lib && test "$linkmode" != prog; then
1867
	    $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
1868
	    continue
1869
	  fi
1870
	  name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1871
	  for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1872
	    for search_ext in .la $std_shrext .so .a; do
1873
	      # Search the libtool library
1874
	      lib="$searchdir/lib${name}${search_ext}"
1875
	      if test -f "$lib"; then
1876
		if test "$search_ext" = ".la"; then
1877
		  found=yes
1878
		else
1879
		  found=no
1880
		fi
1881
		break 2
1882
	      fi
1883
	    done
1884
	  done
1885
	  if test "$found" != yes; then
1886
	    # deplib doesn't seem to be a libtool library
1887
	    if test "$linkmode,$pass" = "prog,link"; then
1888
	      compile_deplibs="$deplib $compile_deplibs"
1889
	      finalize_deplibs="$deplib $finalize_deplibs"
1890
	    else
1891
	      deplibs="$deplib $deplibs"
1892
	      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1893
	    fi
1894
	    continue
1895
	  else # deplib is a libtool library
1896
	    # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
1897
	    # We need to do some special things here, and not later.
1898
	    if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
1899
	      case " $predeps $postdeps " in
1900
	      *" $deplib "*)
1901
		if (${SED} -e '2q' $lib |
1902
                    grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1903
		  library_names=
1904
		  old_library=
1905
		  case $lib in
1906
		  */* | *\\*) . $lib ;;
1907
		  *) . ./$lib ;;
1908
		  esac
1909
		  for l in $old_library $library_names; do
1910
		    ll="$l"
1911
		  done
1912
		  if test "X$ll" = "X$old_library" ; then # only static version available
1913
		    found=no
1914
		    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1915
		    test "X$ladir" = "X$lib" && ladir="."
1916
		    lib=$ladir/$old_library
1917
		    if test "$linkmode,$pass" = "prog,link"; then
1918
		      compile_deplibs="$deplib $compile_deplibs"
1919
		      finalize_deplibs="$deplib $finalize_deplibs"
1920
		    else
1921
		      deplibs="$deplib $deplibs"
1922
		      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1923
		    fi
1924
		    continue
1925
		  fi
1926
		fi
1927
	        ;;
1928
	      *) ;;
1929
	      esac
1930
	    fi
1931
	  fi
1932
	  ;; # -l
1933
	-L*)
1934
	  case $linkmode in
1935
	  lib)
1936
	    deplibs="$deplib $deplibs"
1937
	    test "$pass" = conv && continue
1938
	    newdependency_libs="$deplib $newdependency_libs"
1939
	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1940
	    ;;
1941
	  prog)
1942
	    if test "$pass" = conv; then
1943
	      deplibs="$deplib $deplibs"
1944
	      continue
1945
	    fi
1946
	    if test "$pass" = scan; then
1947
	      deplibs="$deplib $deplibs"
1948
	    else
1949
	      compile_deplibs="$deplib $compile_deplibs"
1950
	      finalize_deplibs="$deplib $finalize_deplibs"
1951
	    fi
1952
	    newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1953
	    ;;
1954
	  *)
1955
	    $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
1956
	    ;;
1957
	  esac # linkmode
1958
	  continue
1959
	  ;; # -L
1960
	-R*)
1961
	  if test "$pass" = link; then
1962
	    dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1963
	    # Make sure the xrpath contains only unique directories.
1964
	    case "$xrpath " in
1965
	    *" $dir "*) ;;
1966
	    *) xrpath="$xrpath $dir" ;;
1967
	    esac
1968
	  fi
1969
	  deplibs="$deplib $deplibs"
1970
	  continue
1971
	  ;;
1972
	*.la) lib="$deplib" ;;
1973
	*.$libext)
1974
	  if test "$pass" = conv; then
1975
	    deplibs="$deplib $deplibs"
1976
	    continue
1977
	  fi
1978
	  case $linkmode in
1979
	  lib)
1980
	    if test "$deplibs_check_method" != pass_all; then
1981
	      $echo
1982
	      $echo "*** Warning: Trying to link with static lib archive $deplib."
1983
	      $echo "*** I have the capability to make that library automatically link in when"
1984
	      $echo "*** you link to this library.  But I can only do this if you have a"
1985
	      $echo "*** shared version of the library, which you do not appear to have"
1986
	      $echo "*** because the file extensions .$libext of this argument makes me believe"
1987
	      $echo "*** that it is just a static archive that I should not used here."
1988
	    else
1989
	      $echo
1990
	      $echo "*** Warning: Linking the shared library $output against the"
1991
	      $echo "*** static library $deplib is not portable!"
1992
	      deplibs="$deplib $deplibs"
1993
	    fi
1994
	    continue
1995
	    ;;
1996
	  prog)
1997
	    if test "$pass" != link; then
1998
	      deplibs="$deplib $deplibs"
1999
	    else
2000
	      compile_deplibs="$deplib $compile_deplibs"
2001
	      finalize_deplibs="$deplib $finalize_deplibs"
2002
	    fi
2003
	    continue
2004
	    ;;
2005
	  esac # linkmode
2006
	  ;; # *.$libext
2007
	*.lo | *.$objext)
2008
	  if test "$pass" = conv; then
2009
	    deplibs="$deplib $deplibs"
2010
	  elif test "$linkmode" = prog; then
2011
	    if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2012
	      # If there is no dlopen support or we're linking statically,
2013
	      # we need to preload.
2014
	      newdlprefiles="$newdlprefiles $deplib"
2015
	      compile_deplibs="$deplib $compile_deplibs"
2016
	      finalize_deplibs="$deplib $finalize_deplibs"
2017
	    else
2018
	      newdlfiles="$newdlfiles $deplib"
2019
	    fi
2020
	  fi
2021
	  continue
2022
	  ;;
2023
	%DEPLIBS%)
2024
	  alldeplibs=yes
2025
	  continue
2026
	  ;;
2027
	esac # case $deplib
2028
	if test "$found" = yes || test -f "$lib"; then :
2029
	else
2030
	  $echo "$modename: cannot find the library \`$lib'" 1>&2
2031
	  exit $EXIT_FAILURE
2032
	fi
2033

    
2034
	# Check to see that this really is a libtool archive.
2035
	if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
2036
	else
2037
	  $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
2038
	  exit $EXIT_FAILURE
2039
	fi
2040

    
2041
	ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
2042
	test "X$ladir" = "X$lib" && ladir="."
2043

    
2044
	dlname=
2045
	dlopen=
2046
	dlpreopen=
2047
	libdir=
2048
	library_names=
2049
	old_library=
2050
	# If the library was installed with an old release of libtool,
2051
	# it will not redefine variables installed, or shouldnotlink
2052
	installed=yes
2053
	shouldnotlink=no
2054

    
2055
	# Read the .la file
2056
	case $lib in
2057
	*/* | *\\*) . $lib ;;
2058
	*) . ./$lib ;;
2059
	esac
2060

    
2061
	if test "$linkmode,$pass" = "lib,link" ||
2062
	   test "$linkmode,$pass" = "prog,scan" ||
2063
	   { test "$linkmode" != prog && test "$linkmode" != lib; }; then
2064
	  test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2065
	  test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2066
	fi
2067

    
2068
	if test "$pass" = conv; then
2069
	  # Only check for convenience libraries
2070
	  deplibs="$lib $deplibs"
2071
	  if test -z "$libdir"; then
2072
	    if test -z "$old_library"; then
2073
	      $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2074
	      exit $EXIT_FAILURE
2075
	    fi
2076
	    # It is a libtool convenience library, so add in its objects.
2077
	    convenience="$convenience $ladir/$objdir/$old_library"
2078
	    old_convenience="$old_convenience $ladir/$objdir/$old_library"
2079
	    tmp_libs=
2080
	    for deplib in $dependency_libs; do
2081
	      deplibs="$deplib $deplibs"
2082
              if test "X$duplicate_deps" = "Xyes" ; then
2083
	        case "$tmp_libs " in
2084
	        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2085
	        esac
2086
              fi
2087
	      tmp_libs="$tmp_libs $deplib"
2088
	    done
2089
	  elif test "$linkmode" != prog && test "$linkmode" != lib; then
2090
	    $echo "$modename: \`$lib' is not a convenience library" 1>&2
2091
	    exit $EXIT_FAILURE
2092
	  fi
2093
	  continue
2094
	fi # $pass = conv
2095

    
2096

    
2097
	# Get the name of the library we link against.
2098
	linklib=
2099
	for l in $old_library $library_names; do
2100
	  linklib="$l"
2101
	done
2102
	if test -z "$linklib"; then
2103
	  $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2104
	  exit $EXIT_FAILURE
2105
	fi
2106

    
2107
	# This library was specified with -dlopen.
2108
	if test "$pass" = dlopen; then
2109
	  if test -z "$libdir"; then
2110
	    $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2111
	    exit $EXIT_FAILURE
2112
	  fi
2113
	  if test -z "$dlname" ||
2114
	     test "$dlopen_support" != yes ||
2115
	     test "$build_libtool_libs" = no; then
2116
	    # If there is no dlname, no dlopen support or we're linking
2117
	    # statically, we need to preload.  We also need to preload any
2118
	    # dependent libraries so libltdl's deplib preloader doesn't
2119
	    # bomb out in the load deplibs phase.
2120
	    dlprefiles="$dlprefiles $lib $dependency_libs"
2121
	  else
2122
	    newdlfiles="$newdlfiles $lib"
2123
	  fi
2124
	  continue
2125
	fi # $pass = dlopen
2126

    
2127
	# We need an absolute path.
2128
	case $ladir in
2129
	[\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2130
	*)
2131
	  abs_ladir=`cd "$ladir" && pwd`
2132
	  if test -z "$abs_ladir"; then
2133
	    $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2134
	    $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2135
	    abs_ladir="$ladir"
2136
	  fi
2137
	  ;;
2138
	esac
2139
	laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2140

    
2141
	# Find the relevant object directory and library name.
2142
	if test "X$installed" = Xyes; then
2143
	  if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2144
	    $echo "$modename: warning: library \`$lib' was moved." 1>&2
2145
	    dir="$ladir"
2146
	    absdir="$abs_ladir"
2147
	    libdir="$abs_ladir"
2148
	  else
2149
	    dir="$libdir"
2150
	    absdir="$libdir"
2151
	  fi
2152
	else
2153
	  dir="$ladir/$objdir"
2154
	  absdir="$abs_ladir/$objdir"
2155
	  # Remove this search path later
2156
	  notinst_path="$notinst_path $abs_ladir"
2157
	fi # $installed = yes
2158
	name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2159

    
2160
	# This library was specified with -dlpreopen.
2161
	if test "$pass" = dlpreopen; then
2162
	  if test -z "$libdir"; then
2163
	    $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2164
	    exit $EXIT_FAILURE
2165
	  fi
2166
	  # Prefer using a static library (so that no silly _DYNAMIC symbols
2167
	  # are required to link).
2168
	  if test -n "$old_library"; then
2169
	    newdlprefiles="$newdlprefiles $dir/$old_library"
2170
	  # Otherwise, use the dlname, so that lt_dlopen finds it.
2171
	  elif test -n "$dlname"; then
2172
	    newdlprefiles="$newdlprefiles $dir/$dlname"
2173
	  else
2174
	    newdlprefiles="$newdlprefiles $dir/$linklib"
2175
	  fi
2176
	fi # $pass = dlpreopen
2177

    
2178
	if test -z "$libdir"; then
2179
	  # Link the convenience library
2180
	  if test "$linkmode" = lib; then
2181
	    deplibs="$dir/$old_library $deplibs"
2182
	  elif test "$linkmode,$pass" = "prog,link"; then
2183
	    compile_deplibs="$dir/$old_library $compile_deplibs"
2184
	    finalize_deplibs="$dir/$old_library $finalize_deplibs"
2185
	  else
2186
	    deplibs="$lib $deplibs" # used for prog,scan pass
2187
	  fi
2188
	  continue
2189
	fi
2190

    
2191

    
2192
	if test "$linkmode" = prog && test "$pass" != link; then
2193
	  newlib_search_path="$newlib_search_path $ladir"
2194
	  deplibs="$lib $deplibs"
2195

    
2196
	  linkalldeplibs=no
2197
	  if test "$link_all_deplibs" != no || test -z "$library_names" ||
2198
	     test "$build_libtool_libs" = no; then
2199
	    linkalldeplibs=yes
2200
	  fi
2201

    
2202
	  tmp_libs=
2203
	  for deplib in $dependency_libs; do
2204
	    case $deplib in
2205
	    -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2206
	    esac
2207
	    # Need to link against all dependency_libs?
2208
	    if test "$linkalldeplibs" = yes; then
2209
	      deplibs="$deplib $deplibs"
2210
	    else
2211
	      # Need to hardcode shared library paths
2212
	      # or/and link against static libraries
2213
	      newdependency_libs="$deplib $newdependency_libs"
2214
	    fi
2215
	    if test "X$duplicate_deps" = "Xyes" ; then
2216
	      case "$tmp_libs " in
2217
	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2218
	      esac
2219
	    fi
2220
	    tmp_libs="$tmp_libs $deplib"
2221
	  done # for deplib
2222
	  continue
2223
	fi # $linkmode = prog...
2224

    
2225
	if test "$linkmode,$pass" = "prog,link"; then
2226
	  if test -n "$library_names" &&
2227
	     { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2228
	    # We need to hardcode the library path
2229
	    if test -n "$shlibpath_var"; then
2230
	      # Make sure the rpath contains only unique directories.
2231
	      case "$temp_rpath " in
2232
	      *" $dir "*) ;;
2233
	      *" $absdir "*) ;;
2234
	      *) temp_rpath="$temp_rpath $dir" ;;
2235
	      esac
2236
	    fi
2237

    
2238
	    # Hardcode the library path.
2239
	    # Skip directories that are in the system default run-time
2240
	    # search path.
2241
	    case " $sys_lib_dlsearch_path " in
2242
	    *" $absdir "*) ;;
2243
	    *)
2244
	      case "$compile_rpath " in
2245
	      *" $absdir "*) ;;
2246
	      *) compile_rpath="$compile_rpath $absdir"
2247
	      esac
2248
	      ;;
2249
	    esac
2250
	    case " $sys_lib_dlsearch_path " in
2251
	    *" $libdir "*) ;;
2252
	    *)
2253
	      case "$finalize_rpath " in
2254
	      *" $libdir "*) ;;
2255
	      *) finalize_rpath="$finalize_rpath $libdir"
2256
	      esac
2257
	      ;;
2258
	    esac
2259
	  fi # $linkmode,$pass = prog,link...
2260

    
2261
	  if test "$alldeplibs" = yes &&
2262
	     { test "$deplibs_check_method" = pass_all ||
2263
	       { test "$build_libtool_libs" = yes &&
2264
		 test -n "$library_names"; }; }; then
2265
	    # We only need to search for static libraries
2266
	    continue
2267
	  fi
2268
	fi
2269

    
2270
	link_static=no # Whether the deplib will be linked statically
2271
	if test -n "$library_names" &&
2272
	   { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2273
	  if test "$installed" = no; then
2274
	    notinst_deplibs="$notinst_deplibs $lib"
2275
	    need_relink=yes
2276
	  fi
2277
	  # This is a shared library
2278

    
2279
	  # Warn about portability, can't link against -module's on
2280
	  # some systems (darwin)
2281
	  if test "$shouldnotlink" = yes && test "$pass" = link ; then
2282
	    $echo
2283
	    if test "$linkmode" = prog; then
2284
	      $echo "*** Warning: Linking the executable $output against the loadable module"
2285
	    else
2286
	      $echo "*** Warning: Linking the shared library $output against the loadable module"
2287
	    fi
2288
	    $echo "*** $linklib is not portable!"
2289
	  fi
2290
	  if test "$linkmode" = lib &&
2291
	     test "$hardcode_into_libs" = yes; then
2292
	    # Hardcode the library path.
2293
	    # Skip directories that are in the system default run-time
2294
	    # search path.
2295
	    case " $sys_lib_dlsearch_path " in
2296
	    *" $absdir "*) ;;
2297
	    *)
2298
	      case "$compile_rpath " in
2299
	      *" $absdir "*) ;;
2300
	      *) compile_rpath="$compile_rpath $absdir"
2301
	      esac
2302
	      ;;
2303
	    esac
2304
	    case " $sys_lib_dlsearch_path " in
2305
	    *" $libdir "*) ;;
2306
	    *)
2307
	      case "$finalize_rpath " in
2308
	      *" $libdir "*) ;;
2309
	      *) finalize_rpath="$finalize_rpath $libdir"
2310
	      esac
2311
	      ;;
2312
	    esac
2313
	  fi
2314

    
2315
	  if test -n "$old_archive_from_expsyms_cmds"; then
2316
	    # figure out the soname
2317
	    set dummy $library_names
2318
	    realname="$2"
2319
	    shift; shift
2320
	    libname=`eval \\$echo \"$libname_spec\"`
2321
	    # use dlname if we got it. it's perfectly good, no?
2322
	    if test -n "$dlname"; then
2323
	      soname="$dlname"
2324
	    elif test -n "$soname_spec"; then
2325
	      # bleh windows
2326
	      case $host in
2327
	      *cygwin* | mingw*)
2328
		major=`expr $current - $age`
2329
		versuffix="-$major"
2330
		;;
2331
	      esac
2332
	      eval soname=\"$soname_spec\"
2333
	    else
2334
	      soname="$realname"
2335
	    fi
2336

    
2337
	    # Make a new name for the extract_expsyms_cmds to use
2338
	    soroot="$soname"
2339
	    soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2340
	    newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
2341

    
2342
	    # If the library has no export list, then create one now
2343
	    if test -f "$output_objdir/$soname-def"; then :
2344
	    else
2345
	      $show "extracting exported symbol list from \`$soname'"
2346
	      save_ifs="$IFS"; IFS='~'
2347
	      cmds=$extract_expsyms_cmds
2348
	      for cmd in $cmds; do
2349
		IFS="$save_ifs"
2350
		eval cmd=\"$cmd\"
2351
		$show "$cmd"
2352
		$run eval "$cmd" || exit $?
2353
	      done
2354
	      IFS="$save_ifs"
2355
	    fi
2356

    
2357
	    # Create $newlib
2358
	    if test -f "$output_objdir/$newlib"; then :; else
2359
	      $show "generating import library for \`$soname'"
2360
	      save_ifs="$IFS"; IFS='~'
2361
	      cmds=$old_archive_from_expsyms_cmds
2362
	      for cmd in $cmds; do
2363
		IFS="$save_ifs"
2364
		eval cmd=\"$cmd\"
2365
		$show "$cmd"
2366
		$run eval "$cmd" || exit $?
2367
	      done
2368
	      IFS="$save_ifs"
2369
	    fi
2370
	    # make sure the library variables are pointing to the new library
2371
	    dir=$output_objdir
2372
	    linklib=$newlib
2373
	  fi # test -n "$old_archive_from_expsyms_cmds"
2374

    
2375
	  if test "$linkmode" = prog || test "$mode" != relink; then
2376
	    add_shlibpath=
2377
	    add_dir=
2378
	    add=
2379
	    lib_linked=yes
2380
	    case $hardcode_action in
2381
	    immediate | unsupported)
2382
	      if test "$hardcode_direct" = no; then
2383
		add="$dir/$linklib"
2384
		case $host in
2385
		  *-*-sco3.2v5* ) add_dir="-L$dir" ;;
2386
		  *-*-darwin* )
2387
		    # if the lib is a module then we can not link against
2388
		    # it, someone is ignoring the new warnings I added
2389
		    if /usr/bin/file -L $add 2> /dev/null | $EGREP "bundle" >/dev/null ; then
2390
		      $echo "** Warning, lib $linklib is a module, not a shared library"
2391
		      if test -z "$old_library" ; then
2392
		        $echo
2393
		        $echo "** And there doesn't seem to be a static archive available"
2394
		        $echo "** The link will probably fail, sorry"
2395
		      else
2396
		        add="$dir/$old_library"
2397
		      fi
2398
		    fi
2399
		esac
2400
	      elif test "$hardcode_minus_L" = no; then
2401
		case $host in
2402
		*-*-sunos*) add_shlibpath="$dir" ;;
2403
		esac
2404
		add_dir="-L$dir"
2405
		add="-l$name"
2406
	      elif test "$hardcode_shlibpath_var" = no; then
2407
		add_shlibpath="$dir"
2408
		add="-l$name"
2409
	      else
2410
		lib_linked=no
2411
	      fi
2412
	      ;;
2413
	    relink)
2414
	      if test "$hardcode_direct" = yes; then
2415
		add="$dir/$linklib"
2416
	      elif test "$hardcode_minus_L" = yes; then
2417
		add_dir="-L$dir"
2418
		# Try looking first in the location we're being installed to.
2419
		if test -n "$inst_prefix_dir"; then
2420
		  case "$libdir" in
2421
		    [\\/]*)
2422
		      add_dir="$add_dir -L$inst_prefix_dir$libdir"
2423
		      ;;
2424
		  esac
2425
		fi
2426
		add="-l$name"
2427
	      elif test "$hardcode_shlibpath_var" = yes; then
2428
		add_shlibpath="$dir"
2429
		add="-l$name"
2430
	      else
2431
		lib_linked=no
2432
	      fi
2433
	      ;;
2434
	    *) lib_linked=no ;;
2435
	    esac
2436

    
2437
	    if test "$lib_linked" != yes; then
2438
	      $echo "$modename: configuration error: unsupported hardcode properties"
2439
	      exit $EXIT_FAILURE
2440
	    fi
2441

    
2442
	    if test -n "$add_shlibpath"; then
2443
	      case :$compile_shlibpath: in
2444
	      *":$add_shlibpath:"*) ;;
2445
	      *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2446
	      esac
2447
	    fi
2448
	    if test "$linkmode" = prog; then
2449
	      test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2450
	      test -n "$add" && compile_deplibs="$add $compile_deplibs"
2451
	    else
2452
	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
2453
	      test -n "$add" && deplibs="$add $deplibs"
2454
	      if test "$hardcode_direct" != yes && \
2455
		 test "$hardcode_minus_L" != yes && \
2456
		 test "$hardcode_shlibpath_var" = yes; then
2457
		case :$finalize_shlibpath: in
2458
		*":$libdir:"*) ;;
2459
		*) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2460
		esac
2461
	      fi
2462
	    fi
2463
	  fi
2464

    
2465
	  if test "$linkmode" = prog || test "$mode" = relink; then
2466
	    add_shlibpath=
2467
	    add_dir=
2468
	    add=
2469
	    # Finalize command for both is simple: just hardcode it.
2470
	    if test "$hardcode_direct" = yes; then
2471
	      add="$libdir/$linklib"
2472
	    elif test "$hardcode_minus_L" = yes; then
2473
	      add_dir="-L$libdir"
2474
	      add="-l$name"
2475
	    elif test "$hardcode_shlibpath_var" = yes; then
2476
	      case :$finalize_shlibpath: in
2477
	      *":$libdir:"*) ;;
2478
	      *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2479
	      esac
2480
	      add="-l$name"
2481
	    elif test "$hardcode_automatic" = yes; then
2482
	      if test -n "$inst_prefix_dir" &&
2483
		 test -f "$inst_prefix_dir$libdir/$linklib" ; then
2484
	        add="$inst_prefix_dir$libdir/$linklib"
2485
	      else
2486
	        add="$libdir/$linklib"
2487
	      fi
2488
	    else
2489
	      # We cannot seem to hardcode it, guess we'll fake it.
2490
	      add_dir="-L$libdir"
2491
	      # Try looking first in the location we're being installed to.
2492
	      if test -n "$inst_prefix_dir"; then
2493
		case "$libdir" in
2494
		  [\\/]*)
2495
		    add_dir="$add_dir -L$inst_prefix_dir$libdir"
2496
		    ;;
2497
		esac
2498
	      fi
2499
	      add="-l$name"
2500
	    fi
2501

    
2502
	    if test "$linkmode" = prog; then
2503
	      test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2504
	      test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2505
	    else
2506
	      test -n "$add_dir" && deplibs="$add_dir $deplibs"
2507
	      test -n "$add" && deplibs="$add $deplibs"
2508
	    fi
2509
	  fi
2510
	elif test "$linkmode" = prog; then
2511
	  # Here we assume that one of hardcode_direct or hardcode_minus_L
2512
	  # is not unsupported.  This is valid on all known static and
2513
	  # shared platforms.
2514
	  if test "$hardcode_direct" != unsupported; then
2515
	    test -n "$old_library" && linklib="$old_library"
2516
	    compile_deplibs="$dir/$linklib $compile_deplibs"
2517
	    finalize_deplibs="$dir/$linklib $finalize_deplibs"
2518
	  else
2519
	    compile_deplibs="-l$name -L$dir $compile_deplibs"
2520
	    finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2521
	  fi
2522
	elif test "$build_libtool_libs" = yes; then
2523
	  # Not a shared library
2524
	  if test "$deplibs_check_method" != pass_all; then
2525
	    # We're trying link a shared library against a static one
2526
	    # but the system doesn't support it.
2527

    
2528
	    # Just print a warning and add the library to dependency_libs so
2529
	    # that the program can be linked against the static library.
2530
	    $echo
2531
	    $echo "*** Warning: This system can not link to static lib archive $lib."
2532
	    $echo "*** I have the capability to make that library automatically link in when"
2533
	    $echo "*** you link to this library.  But I can only do this if you have a"
2534
	    $echo "*** shared version of the library, which you do not appear to have."
2535
	    if test "$module" = yes; then
2536
	      $echo "*** But as you try to build a module library, libtool will still create "
2537
	      $echo "*** a static module, that should work as long as the dlopening application"
2538
	      $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2539
	      if test -z "$global_symbol_pipe"; then
2540
		$echo
2541
		$echo "*** However, this would only work if libtool was able to extract symbol"
2542
		$echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2543
		$echo "*** not find such a program.  So, this module is probably useless."
2544
		$echo "*** \`nm' from GNU binutils and a full rebuild may help."
2545
	      fi
2546
	      if test "$build_old_libs" = no; then
2547
		build_libtool_libs=module
2548
		build_old_libs=yes
2549
	      else
2550
		build_libtool_libs=no
2551
	      fi
2552
	    fi
2553
	  else
2554
	    convenience="$convenience $dir/$old_library"
2555
	    old_convenience="$old_convenience $dir/$old_library"
2556
	    deplibs="$dir/$old_library $deplibs"
2557
	    link_static=yes
2558
	  fi
2559
	fi # link shared/static library?
2560

    
2561
	if test "$linkmode" = lib; then
2562
	  if test -n "$dependency_libs" &&
2563
	     { test "$hardcode_into_libs" != yes ||
2564
	       test "$build_old_libs" = yes ||
2565
	       test "$link_static" = yes; }; then
2566
	    # Extract -R from dependency_libs
2567
	    temp_deplibs=
2568
	    for libdir in $dependency_libs; do
2569
	      case $libdir in
2570
	      -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2571
		   case " $xrpath " in
2572
		   *" $temp_xrpath "*) ;;
2573
		   *) xrpath="$xrpath $temp_xrpath";;
2574
		   esac;;
2575
	      *) temp_deplibs="$temp_deplibs $libdir";;
2576
	      esac
2577
	    done
2578
	    dependency_libs="$temp_deplibs"
2579
	  fi
2580

    
2581
	  newlib_search_path="$newlib_search_path $absdir"
2582
	  # Link against this library
2583
	  test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2584
	  # ... and its dependency_libs
2585
	  tmp_libs=
2586
	  for deplib in $dependency_libs; do
2587
	    newdependency_libs="$deplib $newdependency_libs"
2588
	    if test "X$duplicate_deps" = "Xyes" ; then
2589
	      case "$tmp_libs " in
2590
	      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2591
	      esac
2592
	    fi
2593
	    tmp_libs="$tmp_libs $deplib"
2594
	  done
2595

    
2596
	  if test "$link_all_deplibs" != no; then
2597
	    # Add the search paths of all dependency libraries
2598
	    for deplib in $dependency_libs; do
2599
	      case $deplib in
2600
	      -L*) path="$deplib" ;;
2601
	      *.la)
2602
		dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2603
		test "X$dir" = "X$deplib" && dir="."
2604
		# We need an absolute path.
2605
		case $dir in
2606
		[\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2607
		*)
2608
		  absdir=`cd "$dir" && pwd`
2609
		  if test -z "$absdir"; then
2610
		    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2611
		    absdir="$dir"
2612
		  fi
2613
		  ;;
2614
		esac
2615
		if grep "^installed=no" $deplib > /dev/null; then
2616
		  path="$absdir/$objdir"
2617
		else
2618
		  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2619
		  if test -z "$libdir"; then
2620
		    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2621
		    exit $EXIT_FAILURE
2622
		  fi
2623
		  if test "$absdir" != "$libdir"; then
2624
		    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2625
		  fi
2626
		  path="$absdir"
2627
		fi
2628
		depdepl=
2629
		case $host in
2630
		*-*-darwin*)
2631
		  # we do not want to link against static libs,
2632
		  # but need to link against shared
2633
		  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2634
		  if test -n "$deplibrary_names" ; then
2635
		    for tmp in $deplibrary_names ; do
2636
		      depdepl=$tmp
2637
		    done
2638
		    if test -f "$path/$depdepl" ; then
2639
		      depdepl="$path/$depdepl"
2640
		    fi
2641
		    # do not add paths which are already there
2642
		    case " $newlib_search_path " in
2643
		    *" $path "*) ;;
2644
		    *) newlib_search_path="$newlib_search_path $path";;
2645
		    esac
2646
		  fi
2647
		  path=""
2648
		  ;;
2649
		*)
2650
		  path="-L$path"
2651
		  ;;
2652
		esac
2653
		;;
2654
	      -l*)
2655
		case $host in
2656
		*-*-darwin*)
2657
		  # Again, we only want to link against shared libraries
2658
		  eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2659
		  for tmp in $newlib_search_path ; do
2660
		    if test -f "$tmp/lib$tmp_libs.dylib" ; then
2661
		      eval depdepl="$tmp/lib$tmp_libs.dylib"
2662
		      break
2663
		    fi
2664
		  done
2665
		  path=""
2666
		  ;;
2667
		*) continue ;;
2668
		esac
2669
		;;
2670
	      *) continue ;;
2671
	      esac
2672
	      case " $deplibs " in
2673
	      *" $depdepl "*) ;;
2674
	      *) deplibs="$depdepl $deplibs" ;;
2675
	      esac
2676
	      case " $deplibs " in
2677
	      *" $path "*) ;;
2678
	      *) deplibs="$deplibs $path" ;;
2679
	      esac
2680
	    done
2681
	  fi # link_all_deplibs != no
2682
	fi # linkmode = lib
2683
      done # for deplib in $libs
2684
      dependency_libs="$newdependency_libs"
2685
      if test "$pass" = dlpreopen; then
2686
	# Link the dlpreopened libraries before other libraries
2687
	for deplib in $save_deplibs; do
2688
	  deplibs="$deplib $deplibs"
2689
	done
2690
      fi
2691
      if test "$pass" != dlopen; then
2692
	if test "$pass" != conv; then
2693
	  # Make sure lib_search_path contains only unique directories.
2694
	  lib_search_path=
2695
	  for dir in $newlib_search_path; do
2696
	    case "$lib_search_path " in
2697
	    *" $dir "*) ;;
2698
	    *) lib_search_path="$lib_search_path $dir" ;;
2699
	    esac
2700
	  done
2701
	  newlib_search_path=
2702
	fi
2703

    
2704
	if test "$linkmode,$pass" != "prog,link"; then
2705
	  vars="deplibs"
2706
	else
2707
	  vars="compile_deplibs finalize_deplibs"
2708
	fi
2709
	for var in $vars dependency_libs; do
2710
	  # Add libraries to $var in reverse order
2711
	  eval tmp_libs=\"\$$var\"
2712
	  new_libs=
2713
	  for deplib in $tmp_libs; do
2714
	    # FIXME: Pedantically, this is the right thing to do, so
2715
	    #        that some nasty dependency loop isn't accidentally
2716
	    #        broken:
2717
	    #new_libs="$deplib $new_libs"
2718
	    # Pragmatically, this seems to cause very few problems in
2719
	    # practice:
2720
	    case $deplib in
2721
	    -L*) new_libs="$deplib $new_libs" ;;
2722
	    -R*) ;;
2723
	    *)
2724
	      # And here is the reason: when a library appears more
2725
	      # than once as an explicit dependence of a library, or
2726
	      # is implicitly linked in more than once by the
2727
	      # compiler, it is considered special, and multiple
2728
	      # occurrences thereof are not removed.  Compare this
2729
	      # with having the same library being listed as a
2730
	      # dependency of multiple other libraries: in this case,
2731
	      # we know (pedantically, we assume) the library does not
2732
	      # need to be listed more than once, so we keep only the
2733
	      # last copy.  This is not always right, but it is rare
2734
	      # enough that we require users that really mean to play
2735
	      # such unportable linking tricks to link the library
2736
	      # using -Wl,-lname, so that libtool does not consider it
2737
	      # for duplicate removal.
2738
	      case " $specialdeplibs " in
2739
	      *" $deplib "*) new_libs="$deplib $new_libs" ;;
2740
	      *)
2741
		case " $new_libs " in
2742
		*" $deplib "*) ;;
2743
		*) new_libs="$deplib $new_libs" ;;
2744
		esac
2745
		;;
2746
	      esac
2747
	      ;;
2748
	    esac
2749
	  done
2750
	  tmp_libs=
2751
	  for deplib in $new_libs; do
2752
	    case $deplib in
2753
	    -L*)
2754
	      case " $tmp_libs " in
2755
	      *" $deplib "*) ;;
2756
	      *) tmp_libs="$tmp_libs $deplib" ;;
2757
	      esac
2758
	      ;;
2759
	    *) tmp_libs="$tmp_libs $deplib" ;;
2760
	    esac
2761
	  done
2762
	  eval $var=\"$tmp_libs\"
2763
	done # for var
2764
      fi
2765
      # Last step: remove runtime libs from dependency_libs
2766
      # (they stay in deplibs)
2767
      tmp_libs=
2768
      for i in $dependency_libs ; do
2769
	case " $predeps $postdeps $compiler_lib_search_path " in
2770
	*" $i "*)
2771
	  i=""
2772
	  ;;
2773
	esac
2774
	if test -n "$i" ; then
2775
	  tmp_libs="$tmp_libs $i"
2776
	fi
2777
      done
2778
      dependency_libs=$tmp_libs
2779
    done # for pass
2780
    if test "$linkmode" = prog; then
2781
      dlfiles="$newdlfiles"
2782
      dlprefiles="$newdlprefiles"
2783
    fi
2784

    
2785
    case $linkmode in
2786
    oldlib)
2787
      if test -n "$deplibs"; then
2788
	$echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
2789
      fi
2790

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

    
2795
      if test -n "$rpath"; then
2796
	$echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2797
      fi
2798

    
2799
      if test -n "$xrpath"; then
2800
	$echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2801
      fi
2802

    
2803
      if test -n "$vinfo"; then
2804
	$echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
2805
      fi
2806

    
2807
      if test -n "$release"; then
2808
	$echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2809
      fi
2810

    
2811
      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2812
	$echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2813
      fi
2814

    
2815
      # Now set the variables for building old libraries.
2816
      build_libtool_libs=no
2817
      oldlibs="$output"
2818
      objs="$objs$old_deplibs"
2819
      ;;
2820

    
2821
    lib)
2822
      # Make sure we only generate libraries of the form `libNAME.la'.
2823
      case $outputname in
2824
      lib*)
2825
	name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2826
	eval shared_ext=\"$shrext_cmds\"
2827
	eval libname=\"$libname_spec\"
2828
	;;
2829
      *)
2830
	if test "$module" = no; then
2831
	  $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2832
	  $echo "$help" 1>&2
2833
	  exit $EXIT_FAILURE
2834
	fi
2835
	if test "$need_lib_prefix" != no; then
2836
	  # Add the "lib" prefix for modules if required
2837
	  name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2838
	  eval shared_ext=\"$shrext_cmds\"
2839
	  eval libname=\"$libname_spec\"
2840
	else
2841
	  libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2842
	fi
2843
	;;
2844
      esac
2845

    
2846
      if test -n "$objs"; then
2847
	if test "$deplibs_check_method" != pass_all; then
2848
	  $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2849
	  exit $EXIT_FAILURE
2850
	else
2851
	  $echo
2852
	  $echo "*** Warning: Linking the shared library $output against the non-libtool"
2853
	  $echo "*** objects $objs is not portable!"
2854
	  libobjs="$libobjs $objs"
2855
	fi
2856
      fi
2857

    
2858
      if test "$dlself" != no; then
2859
	$echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2860
      fi
2861

    
2862
      set dummy $rpath
2863
      if test "$#" -gt 2; then
2864
	$echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2865
      fi
2866
      install_libdir="$2"
2867

    
2868
      oldlibs=
2869
      if test -z "$rpath"; then
2870
	if test "$build_libtool_libs" = yes; then
2871
	  # Building a libtool convenience library.
2872
	  # Some compilers have problems with a `.al' extension so
2873
	  # convenience libraries should have the same extension an
2874
	  # archive normally would.
2875
	  oldlibs="$output_objdir/$libname.$libext $oldlibs"
2876
	  build_libtool_libs=convenience
2877
	  build_old_libs=yes
2878
	fi
2879

    
2880
	if test -n "$vinfo"; then
2881
	  $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
2882
	fi
2883

    
2884
	if test -n "$release"; then
2885
	  $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2886
	fi
2887
      else
2888

    
2889
	# Parse the version information argument.
2890
	save_ifs="$IFS"; IFS=':'
2891
	set dummy $vinfo 0 0 0
2892
	IFS="$save_ifs"
2893

    
2894
	if test -n "$8"; then
2895
	  $echo "$modename: too many parameters to \`-version-info'" 1>&2
2896
	  $echo "$help" 1>&2
2897
	  exit $EXIT_FAILURE
2898
	fi
2899

    
2900
	# convert absolute version numbers to libtool ages
2901
	# this retains compatibility with .la files and attempts
2902
	# to make the code below a bit more comprehensible
2903

    
2904
	case $vinfo_number in
2905
	yes)
2906
	  number_major="$2"
2907
	  number_minor="$3"
2908
	  number_revision="$4"
2909
	  #
2910
	  # There are really only two kinds -- those that
2911
	  # use the current revision as the major version
2912
	  # and those that subtract age and use age as
2913
	  # a minor version.  But, then there is irix
2914
	  # which has an extra 1 added just for fun
2915
	  #
2916
	  case $version_type in
2917
	  darwin|linux|osf|windows)
2918
	    current=`expr $number_major + $number_minor`
2919
	    age="$number_minor"
2920
	    revision="$number_revision"
2921
	    ;;
2922
	  freebsd-aout|freebsd-elf|sunos)
2923
	    current="$number_major"
2924
	    revision="$number_minor"
2925
	    age="0"
2926
	    ;;
2927
	  irix|nonstopux)
2928
	    current=`expr $number_major + $number_minor - 1`
2929
	    age="$number_minor"
2930
	    revision="$number_minor"
2931
	    ;;
2932
	  *)
2933
	    $echo "$modename: unknown library version type \`$version_type'" 1>&2
2934
	    $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
2935
	    exit $EXIT_FAILURE
2936
	    ;;
2937
	  esac
2938
	  ;;
2939
	no)
2940
	  current="$2"
2941
	  revision="$3"
2942
	  age="$4"
2943
	  ;;
2944
	esac
2945

    
2946
	# Check that each of the things are valid numbers.
2947
	case $current in
2948
	0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2949
	*)
2950
	  $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2951
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2952
	  exit $EXIT_FAILURE
2953
	  ;;
2954
	esac
2955

    
2956
	case $revision in
2957
	0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2958
	*)
2959
	  $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2960
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2961
	  exit $EXIT_FAILURE
2962
	  ;;
2963
	esac
2964

    
2965
	case $age in
2966
	0 | [1-9] | [1-9][0-9] | [1-9][0-9][0-9]) ;;
2967
	*)
2968
	  $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2969
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2970
	  exit $EXIT_FAILURE
2971
	  ;;
2972
	esac
2973

    
2974
	if test "$age" -gt "$current"; then
2975
	  $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2976
	  $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2977
	  exit $EXIT_FAILURE
2978
	fi
2979

    
2980
	# Calculate the version variables.
2981
	major=
2982
	versuffix=
2983
	verstring=
2984
	case $version_type in
2985
	none) ;;
2986

    
2987
	darwin)
2988
	  # Like Linux, but with the current version available in
2989
	  # verstring for coding it into the library header
2990
	  major=.`expr $current - $age`
2991
	  versuffix="$major.$age.$revision"
2992
	  # Darwin ld doesn't like 0 for these options...
2993
	  minor_current=`expr $current + 1`
2994
	  verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2995
	  ;;
2996

    
2997
	freebsd-aout)
2998
	  major=".$current"
2999
	  versuffix=".$current.$revision";
3000
	  ;;
3001

    
3002
	freebsd-elf)
3003
	  major=".$current"
3004
	  versuffix=".$current";
3005
	  ;;
3006

    
3007
	irix | nonstopux)
3008
	  major=`expr $current - $age + 1`
3009

    
3010
	  case $version_type in
3011
	    nonstopux) verstring_prefix=nonstopux ;;
3012
	    *)         verstring_prefix=sgi ;;
3013
	  esac
3014
	  verstring="$verstring_prefix$major.$revision"
3015

    
3016
	  # Add in all the interfaces that we are compatible with.
3017
	  loop=$revision
3018
	  while test "$loop" -ne 0; do
3019
	    iface=`expr $revision - $loop`
3020
	    loop=`expr $loop - 1`
3021
	    verstring="$verstring_prefix$major.$iface:$verstring"
3022
	  done
3023

    
3024
	  # Before this point, $major must not contain `.'.
3025
	  major=.$major
3026
	  versuffix="$major.$revision"
3027
	  ;;
3028

    
3029
	linux)
3030
	  major=.`expr $current - $age`
3031
	  versuffix="$major.$age.$revision"
3032
	  ;;
3033

    
3034
	osf)
3035
	  major=.`expr $current - $age`
3036
	  versuffix=".$current.$age.$revision"
3037
	  verstring="$current.$age.$revision"
3038

    
3039
	  # Add in all the interfaces that we are compatible with.
3040
	  loop=$age
3041
	  while test "$loop" -ne 0; do
3042
	    iface=`expr $current - $loop`
3043
	    loop=`expr $loop - 1`
3044
	    verstring="$verstring:${iface}.0"
3045
	  done
3046

    
3047
	  # Make executables depend on our current version.
3048
	  verstring="$verstring:${current}.0"
3049
	  ;;
3050

    
3051
	sunos)
3052
	  major=".$current"
3053
	  versuffix=".$current.$revision"
3054
	  ;;
3055

    
3056
	windows)
3057
	  # Use '-' rather than '.', since we only want one
3058
	  # extension on DOS 8.3 filesystems.
3059
	  major=`expr $current - $age`
3060
	  versuffix="-$major"
3061
	  ;;
3062

    
3063
	*)
3064
	  $echo "$modename: unknown library version type \`$version_type'" 1>&2
3065
	  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3066
	  exit $EXIT_FAILURE
3067
	  ;;
3068
	esac
3069

    
3070
	# Clear the version info if we defaulted, and they specified a release.
3071
	if test -z "$vinfo" && test -n "$release"; then
3072
	  major=
3073
	  case $version_type in
3074
	  darwin)
3075
	    # we can't check for "0.0" in archive_cmds due to quoting
3076
	    # problems, so we reset it completely
3077
	    verstring=
3078
	    ;;
3079
	  *)
3080
	    verstring="0.0"
3081
	    ;;
3082
	  esac
3083
	  if test "$need_version" = no; then
3084
	    versuffix=
3085
	  else
3086
	    versuffix=".0.0"
3087
	  fi
3088
	fi
3089

    
3090
	# Remove version info from name if versioning should be avoided
3091
	if test "$avoid_version" = yes && test "$need_version" = no; then
3092
	  major=
3093
	  versuffix=
3094
	  verstring=""
3095
	fi
3096

    
3097
	# Check to see if the archive will have undefined symbols.
3098
	if test "$allow_undefined" = yes; then
3099
	  if test "$allow_undefined_flag" = unsupported; then
3100
	    $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
3101
	    build_libtool_libs=no
3102
	    build_old_libs=yes
3103
	  fi
3104
	else
3105
	  # Don't allow undefined symbols.
3106
	  allow_undefined_flag="$no_undefined_flag"
3107
	fi
3108
      fi
3109

    
3110
      if test "$mode" != relink; then
3111
	# Remove our outputs, but don't remove object files since they
3112
	# may have been created when compiling PIC objects.
3113
	removelist=
3114
	tempremovelist=`$echo "$output_objdir/*"`
3115
	for p in $tempremovelist; do
3116
	  case $p in
3117
	    *.$objext)
3118
	       ;;
3119
	    $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
3120
	       if test "X$precious_files_regex" != "X"; then
3121
	         if echo $p | $EGREP -e "$precious_files_regex" >/dev/null 2>&1
3122
	         then
3123
		   continue
3124
		 fi
3125
	       fi
3126
	       removelist="$removelist $p"
3127
	       ;;
3128
	    *) ;;
3129
	  esac
3130
	done
3131
	if test -n "$removelist"; then
3132
	  $show "${rm}r $removelist"
3133
	  $run ${rm}r $removelist
3134
	fi
3135
      fi
3136

    
3137
      # Now set the variables for building old libraries.
3138
      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
3139
	oldlibs="$oldlibs $output_objdir/$libname.$libext"
3140

    
3141
	# Transform .lo files to .o files.
3142
	oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
3143
      fi
3144

    
3145
      # Eliminate all temporary directories.
3146
      for path in $notinst_path; do
3147
	lib_search_path=`$echo "$lib_search_path " | ${SED} -e 's% $path % %g'`
3148
	deplibs=`$echo "$deplibs " | ${SED} -e 's% -L$path % %g'`
3149
	dependency_libs=`$echo "$dependency_libs " | ${SED} -e 's% -L$path % %g'`
3150
      done
3151

    
3152
      if test -n "$xrpath"; then
3153
	# If the user specified any rpath flags, then add them.
3154
	temp_xrpath=
3155
	for libdir in $xrpath; do
3156
	  temp_xrpath="$temp_xrpath -R$libdir"
3157
	  case "$finalize_rpath " in
3158
	  *" $libdir "*) ;;
3159
	  *) finalize_rpath="$finalize_rpath $libdir" ;;
3160
	  esac
3161
	done
3162
	if test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes; then
3163
	  dependency_libs="$temp_xrpath $dependency_libs"
3164
	fi
3165
      fi
3166

    
3167
      # Make sure dlfiles contains only unique files that won't be dlpreopened
3168
      old_dlfiles="$dlfiles"
3169
      dlfiles=
3170
      for lib in $old_dlfiles; do
3171
	case " $dlprefiles $dlfiles " in
3172
	*" $lib "*) ;;
3173
	*) dlfiles="$dlfiles $lib" ;;
3174
	esac
3175
      done
3176

    
3177
      # Make sure dlprefiles contains only unique files
3178
      old_dlprefiles="$dlprefiles"
3179
      dlprefiles=
3180
      for lib in $old_dlprefiles; do
3181
	case "$dlprefiles " in
3182
	*" $lib "*) ;;
3183
	*) dlprefiles="$dlprefiles $lib" ;;
3184
	esac
3185
      done
3186

    
3187
      if test "$build_libtool_libs" = yes; then
3188
	if test -n "$rpath"; then
3189
	  case $host in
3190
	  *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
3191
	    # these systems don't actually have a c library (as such)!
3192
	    ;;
3193
	  *-*-rhapsody* | *-*-darwin1.[012])
3194
	    # Rhapsody C library is in the System framework
3195
	    deplibs="$deplibs -framework System"
3196
	    ;;
3197
	  *-*-netbsd*)
3198
	    # Don't link with libc until the a.out ld.so is fixed.
3199
	    ;;
3200
	  *-*-openbsd* | *-*-freebsd*)
3201
	    # Do not include libc due to us having libc/libc_r.
3202
	    test "X$arg" = "X-lc" && continue
3203
	    ;;
3204
 	  *)
3205
	    # Add libc to deplibs on all other systems if necessary.
3206
	    if test "$build_libtool_need_lc" = "yes"; then
3207
	      deplibs="$deplibs -lc"
3208
	    fi
3209
	    ;;
3210
	  esac
3211
	fi
3212

    
3213
	# Transform deplibs into only deplibs that can be linked in shared.
3214
	name_save=$name
3215
	libname_save=$libname
3216
	release_save=$release
3217
	versuffix_save=$versuffix
3218
	major_save=$major
3219
	# I'm not sure if I'm treating the release correctly.  I think
3220
	# release should show up in the -l (ie -lgmp5) so we don't want to
3221
	# add it in twice.  Is that correct?
3222
	release=""
3223
	versuffix=""
3224
	major=""
3225
	newdeplibs=
3226
	droppeddeps=no
3227
	case $deplibs_check_method in
3228
	pass_all)
3229
	  # Don't check for shared/static.  Everything works.
3230
	  # This might be a little naive.  We might want to check
3231
	  # whether the library exists or not.  But this is on
3232
	  # osf3 & osf4 and I'm not really sure... Just
3233
	  # implementing what was already the behavior.
3234
	  newdeplibs=$deplibs
3235
	  ;;
3236
	test_compile)
3237
	  # This code stresses the "libraries are programs" paradigm to its
3238
	  # limits. Maybe even breaks it.  We compile a program, linking it
3239
	  # against the deplibs as a proxy for the library.  Then we can check
3240
	  # whether they linked in statically or dynamically with ldd.
3241
	  $rm conftest.c
3242
	  cat > conftest.c <<EOF
3243
	  int main() { return 0; }
3244
EOF
3245
	  $rm conftest
3246
	  $LTCC -o conftest conftest.c $deplibs
3247
	  if test "$?" -eq 0 ; then
3248
	    ldd_output=`ldd conftest`
3249
	    for i in $deplibs; do
3250
	      name="`expr $i : '-l\(.*\)'`"
3251
	      # If $name is empty we are operating on a -L argument.
3252
              if test "$name" != "" && test "$name" -ne "0"; then
3253
		if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3254
		  case " $predeps $postdeps " in
3255
		  *" $i "*)
3256
		    newdeplibs="$newdeplibs $i"
3257
		    i=""
3258
		    ;;
3259
		  esac
3260
	        fi
3261
		if test -n "$i" ; then
3262
		  libname=`eval \\$echo \"$libname_spec\"`
3263
		  deplib_matches=`eval \\$echo \"$library_names_spec\"`
3264
		  set dummy $deplib_matches
3265
		  deplib_match=$2
3266
		  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3267
		    newdeplibs="$newdeplibs $i"
3268
		  else
3269
		    droppeddeps=yes
3270
		    $echo
3271
		    $echo "*** Warning: dynamic linker does not accept needed library $i."
3272
		    $echo "*** I have the capability to make that library automatically link in when"
3273
		    $echo "*** you link to this library.  But I can only do this if you have a"
3274
		    $echo "*** shared version of the library, which I believe you do not have"
3275
		    $echo "*** because a test_compile did reveal that the linker did not use it for"
3276
		    $echo "*** its dynamic dependency list that programs get resolved with at runtime."
3277
		  fi
3278
		fi
3279
	      else
3280
		newdeplibs="$newdeplibs $i"
3281
	      fi
3282
	    done
3283
	  else
3284
	    # Error occurred in the first compile.  Let's try to salvage
3285
	    # the situation: Compile a separate program for each library.
3286
	    for i in $deplibs; do
3287
	      name="`expr $i : '-l\(.*\)'`"
3288
	      # If $name is empty we are operating on a -L argument.
3289
              if test "$name" != "" && test "$name" != "0"; then
3290
		$rm conftest
3291
		$LTCC -o conftest conftest.c $i
3292
		# Did it work?
3293
		if test "$?" -eq 0 ; then
3294
		  ldd_output=`ldd conftest`
3295
		  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3296
		    case " $predeps $postdeps " in
3297
		    *" $i "*)
3298
		      newdeplibs="$newdeplibs $i"
3299
		      i=""
3300
		      ;;
3301
		    esac
3302
		  fi
3303
		  if test -n "$i" ; then
3304
		    libname=`eval \\$echo \"$libname_spec\"`
3305
		    deplib_matches=`eval \\$echo \"$library_names_spec\"`
3306
		    set dummy $deplib_matches
3307
		    deplib_match=$2
3308
		    if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
3309
		      newdeplibs="$newdeplibs $i"
3310
		    else
3311
		      droppeddeps=yes
3312
		      $echo
3313
		      $echo "*** Warning: dynamic linker does not accept needed library $i."
3314
		      $echo "*** I have the capability to make that library automatically link in when"
3315
		      $echo "*** you link to this library.  But I can only do this if you have a"
3316
		      $echo "*** shared version of the library, which you do not appear to have"
3317
		      $echo "*** because a test_compile did reveal that the linker did not use this one"
3318
		      $echo "*** as a dynamic dependency that programs can get resolved with at runtime."
3319
		    fi
3320
		  fi
3321
		else
3322
		  droppeddeps=yes
3323
		  $echo
3324
		  $echo "*** Warning!  Library $i is needed by this library but I was not able to"
3325
		  $echo "***  make it link in!  You will probably need to install it or some"
3326
		  $echo "*** library that it depends on before this library will be fully"
3327
		  $echo "*** functional.  Installing it before continuing would be even better."
3328
		fi
3329
	      else
3330
		newdeplibs="$newdeplibs $i"
3331
	      fi
3332
	    done
3333
	  fi
3334
	  ;;
3335
	file_magic*)
3336
	  set dummy $deplibs_check_method
3337
	  file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3338
	  for a_deplib in $deplibs; do
3339
	    name="`expr $a_deplib : '-l\(.*\)'`"
3340
	    # If $name is empty we are operating on a -L argument.
3341
            if test "$name" != "" && test  "$name" != "0"; then
3342
	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3343
		case " $predeps $postdeps " in
3344
		*" $a_deplib "*)
3345
		  newdeplibs="$newdeplibs $a_deplib"
3346
		  a_deplib=""
3347
		  ;;
3348
		esac
3349
	      fi
3350
	      if test -n "$a_deplib" ; then
3351
		libname=`eval \\$echo \"$libname_spec\"`
3352
		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3353
		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3354
		  for potent_lib in $potential_libs; do
3355
		      # Follow soft links.
3356
		      if ls -lLd "$potent_lib" 2>/dev/null \
3357
			 | grep " -> " >/dev/null; then
3358
			continue
3359
		      fi
3360
		      # The statement above tries to avoid entering an
3361
		      # endless loop below, in case of cyclic links.
3362
		      # We might still enter an endless loop, since a link
3363
		      # loop can be closed while we follow links,
3364
		      # but so what?
3365
		      potlib="$potent_lib"
3366
		      while test -h "$potlib" 2>/dev/null; do
3367
			potliblink=`ls -ld $potlib | ${SED} 's/.* -> //'`
3368
			case $potliblink in
3369
			[\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
3370
			*) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
3371
			esac
3372
		      done
3373
		      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
3374
			 | ${SED} 10q \
3375
			 | $EGREP "$file_magic_regex" > /dev/null; then
3376
			newdeplibs="$newdeplibs $a_deplib"
3377
			a_deplib=""
3378
			break 2
3379
		      fi
3380
		  done
3381
		done
3382
	      fi
3383
	      if test -n "$a_deplib" ; then
3384
		droppeddeps=yes
3385
		$echo
3386
		$echo "*** Warning: linker path does not have real file for library $a_deplib."
3387
		$echo "*** I have the capability to make that library automatically link in when"
3388
		$echo "*** you link to this library.  But I can only do this if you have a"
3389
		$echo "*** shared version of the library, which you do not appear to have"
3390
		$echo "*** because I did check the linker path looking for a file starting"
3391
		if test -z "$potlib" ; then
3392
		  $echo "*** with $libname but no candidates were found. (...for file magic test)"
3393
		else
3394
		  $echo "*** with $libname and none of the candidates passed a file format test"
3395
		  $echo "*** using a file magic. Last file checked: $potlib"
3396
		fi
3397
	      fi
3398
	    else
3399
	      # Add a -L argument.
3400
	      newdeplibs="$newdeplibs $a_deplib"
3401
	    fi
3402
	  done # Gone through all deplibs.
3403
	  ;;
3404
	match_pattern*)
3405
	  set dummy $deplibs_check_method
3406
	  match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
3407
	  for a_deplib in $deplibs; do
3408
	    name="`expr $a_deplib : '-l\(.*\)'`"
3409
	    # If $name is empty we are operating on a -L argument.
3410
	    if test -n "$name" && test "$name" != "0"; then
3411
	      if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3412
		case " $predeps $postdeps " in
3413
		*" $a_deplib "*)
3414
		  newdeplibs="$newdeplibs $a_deplib"
3415
		  a_deplib=""
3416
		  ;;
3417
		esac
3418
	      fi
3419
	      if test -n "$a_deplib" ; then
3420
		libname=`eval \\$echo \"$libname_spec\"`
3421
		for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
3422
		  potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
3423
		  for potent_lib in $potential_libs; do
3424
		    potlib="$potent_lib" # see symlink-check above in file_magic test
3425
		    if eval $echo \"$potent_lib\" 2>/dev/null \
3426
		        | ${SED} 10q \
3427
		        | $EGREP "$match_pattern_regex" > /dev/null; then
3428
		      newdeplibs="$newdeplibs $a_deplib"
3429
		      a_deplib=""
3430
		      break 2
3431
		    fi
3432
		  done
3433
		done
3434
	      fi
3435
	      if test -n "$a_deplib" ; then
3436
		droppeddeps=yes
3437
		$echo
3438
		$echo "*** Warning: linker path does not have real file for library $a_deplib."
3439
		$echo "*** I have the capability to make that library automatically link in when"
3440
		$echo "*** you link to this library.  But I can only do this if you have a"
3441
		$echo "*** shared version of the library, which you do not appear to have"
3442
		$echo "*** because I did check the linker path looking for a file starting"
3443
		if test -z "$potlib" ; then
3444
		  $echo "*** with $libname but no candidates were found. (...for regex pattern test)"
3445
		else
3446
		  $echo "*** with $libname and none of the candidates passed a file format test"
3447
		  $echo "*** using a regex pattern. Last file checked: $potlib"
3448
		fi
3449
	      fi
3450
	    else
3451
	      # Add a -L argument.
3452
	      newdeplibs="$newdeplibs $a_deplib"
3453
	    fi
3454
	  done # Gone through all deplibs.
3455
	  ;;
3456
	none | unknown | *)
3457
	  newdeplibs=""
3458
	  tmp_deplibs=`$echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
3459
	    -e 's/ -[LR][^ ]*//g'`
3460
	  if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
3461
	    for i in $predeps $postdeps ; do
3462
	      # can't use Xsed below, because $i might contain '/'
3463
	      tmp_deplibs=`$echo "X $tmp_deplibs" | ${SED} -e "1s,^X,," -e "s,$i,,"`
3464
	    done
3465
	  fi
3466
	  if $echo "X $tmp_deplibs" | $Xsed -e 's/[ 	]//g' \
3467
	    | grep . >/dev/null; then
3468
	    $echo
3469
	    if test "X$deplibs_check_method" = "Xnone"; then
3470
	      $echo "*** Warning: inter-library dependencies are not supported in this platform."
3471
	    else
3472
	      $echo "*** Warning: inter-library dependencies are not known to be supported."
3473
	    fi
3474
	    $echo "*** All declared inter-library dependencies are being dropped."
3475
	    droppeddeps=yes
3476
	  fi
3477
	  ;;
3478
	esac
3479
	versuffix=$versuffix_save
3480
	major=$major_save
3481
	release=$release_save
3482
	libname=$libname_save
3483
	name=$name_save
3484

    
3485
	case $host in
3486
	*-*-rhapsody* | *-*-darwin1.[012])
3487
	  # On Rhapsody replace the C library is the System framework
3488
	  newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
3489
	  ;;
3490
	esac
3491

    
3492
	if test "$droppeddeps" = yes; then
3493
	  if test "$module" = yes; then
3494
	    $echo
3495
	    $echo "*** Warning: libtool could not satisfy all declared inter-library"
3496
	    $echo "*** dependencies of module $libname.  Therefore, libtool will create"
3497
	    $echo "*** a static module, that should work as long as the dlopening"
3498
	    $echo "*** application is linked with the -dlopen flag."
3499
	    if test -z "$global_symbol_pipe"; then
3500
	      $echo
3501
	      $echo "*** However, this would only work if libtool was able to extract symbol"
3502
	      $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
3503
	      $echo "*** not find such a program.  So, this module is probably useless."
3504
	      $echo "*** \`nm' from GNU binutils and a full rebuild may help."
3505
	    fi
3506
	    if test "$build_old_libs" = no; then
3507
	      oldlibs="$output_objdir/$libname.$libext"
3508
	      build_libtool_libs=module
3509
	      build_old_libs=yes
3510
	    else
3511
	      build_libtool_libs=no
3512
	    fi
3513
	  else
3514
	    $echo "*** The inter-library dependencies that have been dropped here will be"
3515
	    $echo "*** automatically added whenever a program is linked with this library"
3516
	    $echo "*** or is declared to -dlopen it."
3517

    
3518
	    if test "$allow_undefined" = no; then
3519
	      $echo
3520
	      $echo "*** Since this library must not contain undefined symbols,"
3521
	      $echo "*** because either the platform does not support them or"
3522
	      $echo "*** it was explicitly requested with -no-undefined,"
3523
	      $echo "*** libtool will only create a static version of it."
3524
	      if test "$build_old_libs" = no; then
3525
		oldlibs="$output_objdir/$libname.$libext"
3526
		build_libtool_libs=module
3527
		build_old_libs=yes
3528
	      else
3529
		build_libtool_libs=no
3530
	      fi
3531
	    fi
3532
	  fi
3533
	fi
3534
	# Done checking deplibs!
3535
	deplibs=$newdeplibs
3536
      fi
3537

    
3538
      # All the library-specific variables (install_libdir is set above).
3539
      library_names=
3540
      old_library=
3541
      dlname=
3542

    
3543
      # Test again, we may have decided not to build it any more
3544
      if test "$build_libtool_libs" = yes; then
3545
	if test "$hardcode_into_libs" = yes; then
3546
	  # Hardcode the library paths
3547
	  hardcode_libdirs=
3548
	  dep_rpath=
3549
	  rpath="$finalize_rpath"
3550
	  test "$mode" != relink && rpath="$compile_rpath$rpath"
3551
	  for libdir in $rpath; do
3552
	    if test -n "$hardcode_libdir_flag_spec"; then
3553
	      if test -n "$hardcode_libdir_separator"; then
3554
		if test -z "$hardcode_libdirs"; then
3555
		  hardcode_libdirs="$libdir"
3556
		else
3557
		  # Just accumulate the unique libdirs.
3558
		  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3559
		  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3560
		    ;;
3561
		  *)
3562
		    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3563
		    ;;
3564
		  esac
3565
		fi
3566
	      else
3567
		eval flag=\"$hardcode_libdir_flag_spec\"
3568
		dep_rpath="$dep_rpath $flag"
3569
	      fi
3570
	    elif test -n "$runpath_var"; then
3571
	      case "$perm_rpath " in
3572
	      *" $libdir "*) ;;
3573
	      *) perm_rpath="$perm_rpath $libdir" ;;
3574
	      esac
3575
	    fi
3576
	  done
3577
	  # Substitute the hardcoded libdirs into the rpath.
3578
	  if test -n "$hardcode_libdir_separator" &&
3579
	     test -n "$hardcode_libdirs"; then
3580
	    libdir="$hardcode_libdirs"
3581
	    if test -n "$hardcode_libdir_flag_spec_ld"; then
3582
	      eval dep_rpath=\"$hardcode_libdir_flag_spec_ld\"
3583
	    else
3584
	      eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3585
	    fi
3586
	  fi
3587
	  if test -n "$runpath_var" && test -n "$perm_rpath"; then
3588
	    # We should set the runpath_var.
3589
	    rpath=
3590
	    for dir in $perm_rpath; do
3591
	      rpath="$rpath$dir:"
3592
	    done
3593
	    eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3594
	  fi
3595
	  test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3596
	fi
3597

    
3598
	shlibpath="$finalize_shlibpath"
3599
	test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3600
	if test -n "$shlibpath"; then
3601
	  eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3602
	fi
3603

    
3604
	# Get the real and link names of the library.
3605
	eval shared_ext=\"$shrext_cmds\"
3606
	eval library_names=\"$library_names_spec\"
3607
	set dummy $library_names
3608
	realname="$2"
3609
	shift; shift
3610

    
3611
	if test -n "$soname_spec"; then
3612
	  eval soname=\"$soname_spec\"
3613
	else
3614
	  soname="$realname"
3615
	fi
3616
	if test -z "$dlname"; then
3617
	  dlname=$soname
3618
	fi
3619

    
3620
	lib="$output_objdir/$realname"
3621
	for link
3622
	do
3623
	  linknames="$linknames $link"
3624
	done
3625

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

    
3629
	# Prepare the list of exported symbols
3630
	if test -z "$export_symbols"; then
3631
	  if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3632
	    $show "generating symbol list for \`$libname.la'"
3633
	    export_symbols="$output_objdir/$libname.exp"
3634
	    $run $rm $export_symbols
3635
	    cmds=$export_symbols_cmds
3636
	    save_ifs="$IFS"; IFS='~'
3637
	    for cmd in $cmds; do
3638
	      IFS="$save_ifs"
3639
	      eval cmd=\"$cmd\"
3640
	      if len=`expr "X$cmd" : ".*"` &&
3641
	       test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3642
	        $show "$cmd"
3643
	        $run eval "$cmd" || exit $?
3644
	        skipped_export=false
3645
	      else
3646
	        # The command line is too long to execute in one step.
3647
	        $show "using reloadable object file for export list..."
3648
	        skipped_export=:
3649
	      fi
3650
	    done
3651
	    IFS="$save_ifs"
3652
	    if test -n "$export_symbols_regex"; then
3653
	      $show "$EGREP -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3654
	      $run eval '$EGREP -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3655
	      $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3656
	      $run eval '$mv "${export_symbols}T" "$export_symbols"'
3657
	    fi
3658
	  fi
3659
	fi
3660

    
3661
	if test -n "$export_symbols" && test -n "$include_expsyms"; then
3662
	  $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3663
	fi
3664

    
3665
	tmp_deplibs=
3666
	for test_deplib in $deplibs; do
3667
		case " $convenience " in
3668
		*" $test_deplib "*) ;;
3669
		*)
3670
			tmp_deplibs="$tmp_deplibs $test_deplib"
3671
			;;
3672
		esac
3673
	done
3674
	deplibs="$tmp_deplibs"
3675

    
3676
	if test -n "$convenience"; then
3677
	  if test -n "$whole_archive_flag_spec"; then
3678
	    save_libobjs=$libobjs
3679
	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3680
	  else
3681
	    gentop="$output_objdir/${outputname}x"
3682
	    $show "${rm}r $gentop"
3683
	    $run ${rm}r "$gentop"
3684
	    $show "$mkdir $gentop"
3685
	    $run $mkdir "$gentop"
3686
	    status=$?
3687
	    if test "$status" -ne 0 && test ! -d "$gentop"; then
3688
	      exit $status
3689
	    fi
3690
	    generated="$generated $gentop"
3691

    
3692
	    for xlib in $convenience; do
3693
	      # Extract the objects.
3694
	      case $xlib in
3695
	      [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3696
	      *) xabs=`pwd`"/$xlib" ;;
3697
	      esac
3698
	      xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3699
	      xdir="$gentop/$xlib"
3700

    
3701
	      $show "${rm}r $xdir"
3702
	      $run ${rm}r "$xdir"
3703
	      $show "$mkdir $xdir"
3704
	      $run $mkdir "$xdir"
3705
	      status=$?
3706
	      if test "$status" -ne 0 && test ! -d "$xdir"; then
3707
		exit $status
3708
	      fi
3709
	      # We will extract separately just the conflicting names and we will no
3710
	      # longer touch any unique names. It is faster to leave these extract
3711
	      # automatically by $AR in one run.
3712
	      $show "(cd $xdir && $AR x $xabs)"
3713
	      $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3714
	      if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
3715
		:
3716
	      else
3717
		$echo "$modename: warning: object name conflicts; renaming object files" 1>&2
3718
		$echo "$modename: warning: to ensure that they will not overwrite" 1>&2
3719
		$AR t "$xabs" | sort | uniq -cd | while read -r count name
3720
		do
3721
		  i=1
3722
		  while test "$i" -le "$count"
3723
		  do
3724
		   # Put our $i before any first dot (extension)
3725
		   # Never overwrite any file
3726
		   name_to="$name"
3727
		   while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
3728
		   do
3729
		     name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
3730
		   done
3731
		   $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
3732
		   $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
3733
		   i=`expr $i + 1`
3734
		  done
3735
		done
3736
	      fi
3737

    
3738
	      libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3739
	    done
3740
	  fi
3741
	fi
3742

    
3743
	if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3744
	  eval flag=\"$thread_safe_flag_spec\"
3745
	  linker_flags="$linker_flags $flag"
3746
	fi
3747

    
3748
	# Make a backup of the uninstalled library when relinking
3749
	if test "$mode" = relink; then
3750
	  $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3751
	fi
3752

    
3753
	# Do each of the archive commands.
3754
	if test "$module" = yes && test -n "$module_cmds" ; then
3755
	  if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
3756
	    eval test_cmds=\"$module_expsym_cmds\"
3757
	    cmds=$module_expsym_cmds
3758
	  else
3759
	    eval test_cmds=\"$module_cmds\"
3760
	    cmds=$module_cmds
3761
	  fi
3762
	else
3763
	if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3764
	  eval test_cmds=\"$archive_expsym_cmds\"
3765
	  cmds=$archive_expsym_cmds
3766
	else
3767
	  eval test_cmds=\"$archive_cmds\"
3768
	  cmds=$archive_cmds
3769
	  fi
3770
	fi
3771

    
3772
	if test "X$skipped_export" != "X:" && len=`expr "X$test_cmds" : ".*"` &&
3773
	   test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
3774
	  :
3775
	else
3776
	  # The command line is too long to link in one step, link piecewise.
3777
	  $echo "creating reloadable object files..."
3778

    
3779
	  # Save the value of $output and $libobjs because we want to
3780
	  # use them later.  If we have whole_archive_flag_spec, we
3781
	  # want to use save_libobjs as it was before
3782
	  # whole_archive_flag_spec was expanded, because we can't
3783
	  # assume the linker understands whole_archive_flag_spec.
3784
	  # This may have to be revisited, in case too many
3785
	  # convenience libraries get linked in and end up exceeding
3786
	  # the spec.
3787
	  if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3788
	    save_libobjs=$libobjs
3789
	  fi
3790
	  save_output=$output
3791

    
3792
	  # Clear the reloadable object creation command queue and
3793
	  # initialize k to one.
3794
	  test_cmds=
3795
	  concat_cmds=
3796
	  objlist=
3797
	  delfiles=
3798
	  last_robj=
3799
	  k=1
3800
	  output=$output_objdir/$save_output-${k}.$objext
3801
	  # Loop over the list of objects to be linked.
3802
	  for obj in $save_libobjs
3803
	  do
3804
	    eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3805
	    if test "X$objlist" = X ||
3806
	       { len=`expr "X$test_cmds" : ".*"` &&
3807
		 test "$len" -le "$max_cmd_len"; }; then
3808
	      objlist="$objlist $obj"
3809
	    else
3810
	      # The command $test_cmds is almost too long, add a
3811
	      # command to the queue.
3812
	      if test "$k" -eq 1 ; then
3813
		# The first file doesn't have a previous command to add.
3814
		eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3815
	      else
3816
		# All subsequent reloadable object files will link in
3817
		# the last one created.
3818
		eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3819
	      fi
3820
	      last_robj=$output_objdir/$save_output-${k}.$objext
3821
	      k=`expr $k + 1`
3822
	      output=$output_objdir/$save_output-${k}.$objext
3823
	      objlist=$obj
3824
	      len=1
3825
	    fi
3826
	  done
3827
	  # Handle the remaining objects by creating one last
3828
	  # reloadable object file.  All subsequent reloadable object
3829
	  # files will link in the last one created.
3830
	  test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3831
	  eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3832

    
3833
	  if ${skipped_export-false}; then
3834
	    $show "generating symbol list for \`$libname.la'"
3835
	    export_symbols="$output_objdir/$libname.exp"
3836
	    $run $rm $export_symbols
3837
	    libobjs=$output
3838
	    # Append the command to create the export file.
3839
	    eval concat_cmds=\"\$concat_cmds~$export_symbols_cmds\"
3840
          fi
3841

    
3842
	  # Set up a command to remove the reloadale object files
3843
	  # after they are used.
3844
	  i=0
3845
	  while test "$i" -lt "$k"
3846
	  do
3847
	    i=`expr $i + 1`
3848
	    delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3849
	  done
3850

    
3851
	  $echo "creating a temporary reloadable object file: $output"
3852

    
3853
	  # Loop through the commands generated above and execute them.
3854
	  save_ifs="$IFS"; IFS='~'
3855
	  for cmd in $concat_cmds; do
3856
	    IFS="$save_ifs"
3857
	    $show "$cmd"
3858
	    $run eval "$cmd" || exit $?
3859
	  done
3860
	  IFS="$save_ifs"
3861

    
3862
	  libobjs=$output
3863
	  # Restore the value of output.
3864
	  output=$save_output
3865

    
3866
	  if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3867
	    eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3868
	  fi
3869
	  # Expand the library linking commands again to reset the
3870
	  # value of $libobjs for piecewise linking.
3871

    
3872
	  # Do each of the archive commands.
3873
	  if test "$module" = yes && test -n "$module_cmds" ; then
3874
	    if test -n "$export_symbols" && test -n "$module_expsym_cmds"; then
3875
	      cmds=$module_expsym_cmds
3876
	    else
3877
	      cmds=$module_cmds
3878
	    fi
3879
	  else
3880
	  if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3881
	    cmds=$archive_expsym_cmds
3882
	  else
3883
	    cmds=$archive_cmds
3884
	    fi
3885
	  fi
3886

    
3887
	  # Append the command to remove the reloadable object files
3888
	  # to the just-reset $cmds.
3889
	  eval cmds=\"\$cmds~\$rm $delfiles\"
3890
	fi
3891
	save_ifs="$IFS"; IFS='~'
3892
	for cmd in $cmds; do
3893
	  IFS="$save_ifs"
3894
	  eval cmd=\"$cmd\"
3895
	  $show "$cmd"
3896
	  $run eval "$cmd" || exit $?
3897
	done
3898
	IFS="$save_ifs"
3899

    
3900
	# Restore the uninstalled library and exit
3901
	if test "$mode" = relink; then
3902
	  $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
3903
	  exit $EXIT_SUCCESS
3904
	fi
3905

    
3906
	# Create links to the real library.
3907
	for linkname in $linknames; do
3908
	  if test "$realname" != "$linkname"; then
3909
	    $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3910
	    $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
3911
	  fi
3912
	done
3913

    
3914
	# If -module or -export-dynamic was specified, set the dlname.
3915
	if test "$module" = yes || test "$export_dynamic" = yes; then
3916
	  # On all known operating systems, these are identical.
3917
	  dlname="$soname"
3918
	fi
3919
      fi
3920
      ;;
3921

    
3922
    obj)
3923
      if test -n "$deplibs"; then
3924
	$echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
3925
      fi
3926

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

    
3931
      if test -n "$rpath"; then
3932
	$echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
3933
      fi
3934

    
3935
      if test -n "$xrpath"; then
3936
	$echo "$modename: warning: \`-R' is ignored for objects" 1>&2
3937
      fi
3938

    
3939
      if test -n "$vinfo"; then
3940
	$echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
3941
      fi
3942

    
3943
      if test -n "$release"; then
3944
	$echo "$modename: warning: \`-release' is ignored for objects" 1>&2
3945
      fi
3946

    
3947
      case $output in
3948
      *.lo)
3949
	if test -n "$objs$old_deplibs"; then
3950
	  $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
3951
	  exit $EXIT_FAILURE
3952
	fi
3953
	libobj="$output"
3954
	obj=`$echo "X$output" | $Xsed -e "$lo2o"`
3955
	;;
3956
      *)
3957
	libobj=
3958
	obj="$output"
3959
	;;
3960
      esac
3961

    
3962
      # Delete the old objects.
3963
      $run $rm $obj $libobj
3964

    
3965
      # Objects from convenience libraries.  This assumes
3966
      # single-version convenience libraries.  Whenever we create
3967
      # different ones for PIC/non-PIC, this we'll have to duplicate
3968
      # the extraction.
3969
      reload_conv_objs=
3970
      gentop=
3971
      # reload_cmds runs $LD directly, so let us get rid of
3972
      # -Wl from whole_archive_flag_spec
3973
      wl=
3974

    
3975
      if test -n "$convenience"; then
3976
	if test -n "$whole_archive_flag_spec"; then
3977
	  eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
3978
	else
3979
	  gentop="$output_objdir/${obj}x"
3980
	  $show "${rm}r $gentop"
3981
	  $run ${rm}r "$gentop"
3982
	  $show "$mkdir $gentop"
3983
	  $run $mkdir "$gentop"
3984
	  status=$?
3985
	  if test "$status" -ne 0 && test ! -d "$gentop"; then
3986
	    exit $status
3987
	  fi
3988
	  generated="$generated $gentop"
3989

    
3990
	  for xlib in $convenience; do
3991
	    # Extract the objects.
3992
	    case $xlib in
3993
	    [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3994
	    *) xabs=`pwd`"/$xlib" ;;
3995
	    esac
3996
	    xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3997
	    xdir="$gentop/$xlib"
3998

    
3999
	    $show "${rm}r $xdir"
4000
	    $run ${rm}r "$xdir"
4001
	    $show "$mkdir $xdir"
4002
	    $run $mkdir "$xdir"
4003
	    status=$?
4004
	    if test "$status" -ne 0 && test ! -d "$xdir"; then
4005
	      exit $status
4006
	    fi
4007
	    # We will extract separately just the conflicting names and we will no
4008
	    # longer touch any unique names. It is faster to leave these extract
4009
	    # automatically by $AR in one run.
4010
	    $show "(cd $xdir && $AR x $xabs)"
4011
	    $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
4012
	    if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
4013
	      :
4014
	    else
4015
	      $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
4016
	      $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
4017
	      $AR t "$xabs" | sort | uniq -cd | while read -r count name
4018
	      do
4019
		i=1
4020
		while test "$i" -le "$count"
4021
		do
4022
		 # Put our $i before any first dot (extension)
4023
		 # Never overwrite any file
4024
		 name_to="$name"
4025
		 while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
4026
		 do
4027
		   name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
4028
		 done
4029
		 $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
4030
		 $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
4031
		 i=`expr $i + 1`
4032
		done
4033
	      done
4034
	    fi
4035

    
4036
	    reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
4037
	  done
4038
	fi
4039
      fi
4040

    
4041
      # Create the old-style object.
4042
      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
4043

    
4044
      output="$obj"
4045
      cmds=$reload_cmds
4046
      save_ifs="$IFS"; IFS='~'
4047
      for cmd in $cmds; do
4048
	IFS="$save_ifs"
4049
	eval cmd=\"$cmd\"
4050
	$show "$cmd"
4051
	$run eval "$cmd" || exit $?
4052
      done
4053
      IFS="$save_ifs"
4054

    
4055
      # Exit if we aren't doing a library object file.
4056
      if test -z "$libobj"; then
4057
	if test -n "$gentop"; then
4058
	  $show "${rm}r $gentop"
4059
	  $run ${rm}r $gentop
4060
	fi
4061

    
4062
	exit $EXIT_SUCCESS
4063
      fi
4064

    
4065
      if test "$build_libtool_libs" != yes; then
4066
	if test -n "$gentop"; then
4067
	  $show "${rm}r $gentop"
4068
	  $run ${rm}r $gentop
4069
	fi
4070

    
4071
	# Create an invalid libtool object if no PIC, so that we don't
4072
	# accidentally link it into a program.
4073
	# $show "echo timestamp > $libobj"
4074
	# $run eval "echo timestamp > $libobj" || exit $?
4075
	exit $EXIT_SUCCESS
4076
      fi
4077

    
4078
      if test -n "$pic_flag" || test "$pic_mode" != default; then
4079
	# Only do commands if we really have different PIC objects.
4080
	reload_objs="$libobjs $reload_conv_objs"
4081
	output="$libobj"
4082
	cmds=$reload_cmds
4083
	save_ifs="$IFS"; IFS='~'
4084
	for cmd in $cmds; do
4085
	  IFS="$save_ifs"
4086
	  eval cmd=\"$cmd\"
4087
	  $show "$cmd"
4088
	  $run eval "$cmd" || exit $?
4089
	done
4090
	IFS="$save_ifs"
4091
      fi
4092

    
4093
      if test -n "$gentop"; then
4094
	$show "${rm}r $gentop"
4095
	$run ${rm}r $gentop
4096
      fi
4097

    
4098
      exit $EXIT_SUCCESS
4099
      ;;
4100

    
4101
    prog)
4102
      case $host in
4103
	*cygwin*) output=`$echo $output | ${SED} -e 's,.exe$,,;s,$,.exe,'` ;;
4104
      esac
4105
      if test -n "$vinfo"; then
4106
	$echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
4107
      fi
4108

    
4109
      if test -n "$release"; then
4110
	$echo "$modename: warning: \`-release' is ignored for programs" 1>&2
4111
      fi
4112

    
4113
      if test "$preload" = yes; then
4114
	if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
4115
	   test "$dlopen_self_static" = unknown; then
4116
	  $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
4117
	fi
4118
      fi
4119

    
4120
      case $host in
4121
      *-*-rhapsody* | *-*-darwin1.[012])
4122
	# On Rhapsody replace the C library is the System framework
4123
	compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4124
	finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
4125
	;;
4126
      esac
4127

    
4128
      case $host in
4129
      *darwin*)
4130
        # Don't allow lazy linking, it breaks C++ global constructors
4131
        if test "$tagname" = CXX ; then
4132
        compile_command="$compile_command ${wl}-bind_at_load"
4133
        finalize_command="$finalize_command ${wl}-bind_at_load"
4134
        fi
4135
        ;;
4136
      esac
4137

    
4138
      compile_command="$compile_command $compile_deplibs"
4139
      finalize_command="$finalize_command $finalize_deplibs"
4140

    
4141
      if test -n "$rpath$xrpath"; then
4142
	# If the user specified any rpath flags, then add them.
4143
	for libdir in $rpath $xrpath; do
4144
	  # This is the magic to use -rpath.
4145
	  case "$finalize_rpath " in
4146
	  *" $libdir "*) ;;
4147
	  *) finalize_rpath="$finalize_rpath $libdir" ;;
4148
	  esac
4149
	done
4150
      fi
4151

    
4152
      # Now hardcode the library paths
4153
      rpath=
4154
      hardcode_libdirs=
4155
      for libdir in $compile_rpath $finalize_rpath; do
4156
	if test -n "$hardcode_libdir_flag_spec"; then
4157
	  if test -n "$hardcode_libdir_separator"; then
4158
	    if test -z "$hardcode_libdirs"; then
4159
	      hardcode_libdirs="$libdir"
4160
	    else
4161
	      # Just accumulate the unique libdirs.
4162
	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4163
	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4164
		;;
4165
	      *)
4166
		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4167
		;;
4168
	      esac
4169
	    fi
4170
	  else
4171
	    eval flag=\"$hardcode_libdir_flag_spec\"
4172
	    rpath="$rpath $flag"
4173
	  fi
4174
	elif test -n "$runpath_var"; then
4175
	  case "$perm_rpath " in
4176
	  *" $libdir "*) ;;
4177
	  *) perm_rpath="$perm_rpath $libdir" ;;
4178
	  esac
4179
	fi
4180
	case $host in
4181
	*-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
4182
	  case :$dllsearchpath: in
4183
	  *":$libdir:"*) ;;
4184
	  *) dllsearchpath="$dllsearchpath:$libdir";;
4185
	  esac
4186
	  ;;
4187
	esac
4188
      done
4189
      # Substitute the hardcoded libdirs into the rpath.
4190
      if test -n "$hardcode_libdir_separator" &&
4191
	 test -n "$hardcode_libdirs"; then
4192
	libdir="$hardcode_libdirs"
4193
	eval rpath=\" $hardcode_libdir_flag_spec\"
4194
      fi
4195
      compile_rpath="$rpath"
4196

    
4197
      rpath=
4198
      hardcode_libdirs=
4199
      for libdir in $finalize_rpath; do
4200
	if test -n "$hardcode_libdir_flag_spec"; then
4201
	  if test -n "$hardcode_libdir_separator"; then
4202
	    if test -z "$hardcode_libdirs"; then
4203
	      hardcode_libdirs="$libdir"
4204
	    else
4205
	      # Just accumulate the unique libdirs.
4206
	      case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
4207
	      *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
4208
		;;
4209
	      *)
4210
		hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
4211
		;;
4212
	      esac
4213
	    fi
4214
	  else
4215
	    eval flag=\"$hardcode_libdir_flag_spec\"
4216
	    rpath="$rpath $flag"
4217
	  fi
4218
	elif test -n "$runpath_var"; then
4219
	  case "$finalize_perm_rpath " in
4220
	  *" $libdir "*) ;;
4221
	  *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
4222
	  esac
4223
	fi
4224
      done
4225
      # Substitute the hardcoded libdirs into the rpath.
4226
      if test -n "$hardcode_libdir_separator" &&
4227
	 test -n "$hardcode_libdirs"; then
4228
	libdir="$hardcode_libdirs"
4229
	eval rpath=\" $hardcode_libdir_flag_spec\"
4230
      fi
4231
      finalize_rpath="$rpath"
4232

    
4233
      if test -n "$libobjs" && test "$build_old_libs" = yes; then
4234
	# Transform all the library objects into standard objects.
4235
	compile_command=`$echo "X$compile_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4236
	finalize_command=`$echo "X$finalize_command" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4237
      fi
4238

    
4239
      dlsyms=
4240
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
4241
	if test -n "$NM" && test -n "$global_symbol_pipe"; then
4242
	  dlsyms="${outputname}S.c"
4243
	else
4244
	  $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
4245
	fi
4246
      fi
4247

    
4248
      if test -n "$dlsyms"; then
4249
	case $dlsyms in
4250
	"") ;;
4251
	*.c)
4252
	  # Discover the nlist of each of the dlfiles.
4253
	  nlist="$output_objdir/${outputname}.nm"
4254

    
4255
	  $show "$rm $nlist ${nlist}S ${nlist}T"
4256
	  $run $rm "$nlist" "${nlist}S" "${nlist}T"
4257

    
4258
	  # Parse the name list into a source file.
4259
	  $show "creating $output_objdir/$dlsyms"
4260

    
4261
	  test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
4262
/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
4263
/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
4264

    
4265
#ifdef __cplusplus
4266
extern \"C\" {
4267
#endif
4268

    
4269
/* Prevent the only kind of declaration conflicts we can make. */
4270
#define lt_preloaded_symbols some_other_symbol
4271

    
4272
/* External symbol declarations for the compiler. */\
4273
"
4274

    
4275
	  if test "$dlself" = yes; then
4276
	    $show "generating symbol list for \`$output'"
4277

    
4278
	    test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
4279

    
4280
	    # Add our own program objects to the symbol list.
4281
	    progfiles=`$echo "X$objs$old_deplibs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
4282
	    for arg in $progfiles; do
4283
	      $show "extracting global C symbols from \`$arg'"
4284
	      $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4285
	    done
4286

    
4287
	    if test -n "$exclude_expsyms"; then
4288
	      $run eval '$EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
4289
	      $run eval '$mv "$nlist"T "$nlist"'
4290
	    fi
4291

    
4292
	    if test -n "$export_symbols_regex"; then
4293
	      $run eval '$EGREP -e "$export_symbols_regex" "$nlist" > "$nlist"T'
4294
	      $run eval '$mv "$nlist"T "$nlist"'
4295
	    fi
4296

    
4297
	    # Prepare the list of exported symbols
4298
	    if test -z "$export_symbols"; then
4299
	      export_symbols="$output_objdir/$output.exp"
4300
	      $run $rm $export_symbols
4301
	      $run eval "${SED} -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
4302
	    else
4303
	      $run eval "${SED} -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
4304
	      $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
4305
	      $run eval 'mv "$nlist"T "$nlist"'
4306
	    fi
4307
	  fi
4308

    
4309
	  for arg in $dlprefiles; do
4310
	    $show "extracting global C symbols from \`$arg'"
4311
	    name=`$echo "$arg" | ${SED} -e 's%^.*/%%'`
4312
	    $run eval '$echo ": $name " >> "$nlist"'
4313
	    $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
4314
	  done
4315

    
4316
	  if test -z "$run"; then
4317
	    # Make sure we have at least an empty file.
4318
	    test -f "$nlist" || : > "$nlist"
4319

    
4320
	    if test -n "$exclude_expsyms"; then
4321
	      $EGREP -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
4322
	      $mv "$nlist"T "$nlist"
4323
	    fi
4324

    
4325
	    # Try sorting and uniquifying the output.
4326
	    if grep -v "^: " < "$nlist" |
4327
		if sort -k 3 </dev/null >/dev/null 2>&1; then
4328
		  sort -k 3
4329
		else
4330
		  sort +2
4331
		fi |
4332
		uniq > "$nlist"S; then
4333
	      :
4334
	    else
4335
	      grep -v "^: " < "$nlist" > "$nlist"S
4336
	    fi
4337

    
4338
	    if test -f "$nlist"S; then
4339
	      eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
4340
	    else
4341
	      $echo '/* NONE */' >> "$output_objdir/$dlsyms"
4342
	    fi
4343

    
4344
	    $echo >> "$output_objdir/$dlsyms" "\
4345

    
4346
#undef lt_preloaded_symbols
4347

    
4348
#if defined (__STDC__) && __STDC__
4349
# define lt_ptr void *
4350
#else
4351
# define lt_ptr char *
4352
# define const
4353
#endif
4354

    
4355
/* The mapping between symbol names and symbols. */
4356
const struct {
4357
  const char *name;
4358
  lt_ptr address;
4359
}
4360
lt_preloaded_symbols[] =
4361
{\
4362
"
4363

    
4364
	    eval "$global_symbol_to_c_name_address" < "$nlist" >> "$output_objdir/$dlsyms"
4365

    
4366
	    $echo >> "$output_objdir/$dlsyms" "\
4367
  {0, (lt_ptr) 0}
4368
};
4369

    
4370
/* This works around a problem in FreeBSD linker */
4371
#ifdef FREEBSD_WORKAROUND
4372
static const void *lt_preloaded_setup() {
4373
  return lt_preloaded_symbols;
4374
}
4375
#endif
4376

    
4377
#ifdef __cplusplus
4378
}
4379
#endif\
4380
"
4381
	  fi
4382

    
4383
	  pic_flag_for_symtable=
4384
	  case $host in
4385
	  # compiling the symbol table file with pic_flag works around
4386
	  # a FreeBSD bug that causes programs to crash when -lm is
4387
	  # linked before any other PIC object.  But we must not use
4388
	  # pic_flag when linking with -static.  The problem exists in
4389
	  # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
4390
	  *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
4391
	    case "$compile_command " in
4392
	    *" -static "*) ;;
4393
	    *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
4394
	    esac;;
4395
	  *-*-hpux*)
4396
	    case "$compile_command " in
4397
	    *" -static "*) ;;
4398
	    *) pic_flag_for_symtable=" $pic_flag";;
4399
	    esac
4400
	  esac
4401

    
4402
	  # Now compile the dynamic symbol file.
4403
	  $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
4404
	  $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
4405

    
4406
	  # Clean up the generated files.
4407
	  $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
4408
	  $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
4409

    
4410
	  # Transform the symbol file into the correct name.
4411
	  compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4412
	  finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
4413
	  ;;
4414
	*)
4415
	  $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
4416
	  exit $EXIT_FAILURE
4417
	  ;;
4418
	esac
4419
      else
4420
	# We keep going just in case the user didn't refer to
4421
	# lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
4422
	# really was required.
4423

    
4424
	# Nullify the symbol file.
4425
	compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
4426
	finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
4427
      fi
4428

    
4429
      if test "$need_relink" = no || test "$build_libtool_libs" != yes; then
4430
	# Replace the output file specification.
4431
	compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4432
	link_command="$compile_command$compile_rpath"
4433

    
4434
	# We have no uninstalled library dependencies, so finalize right now.
4435
	$show "$link_command"
4436
	$run eval "$link_command"
4437
	status=$?
4438

    
4439
	# Delete the generated files.
4440
	if test -n "$dlsyms"; then
4441
	  $show "$rm $output_objdir/${outputname}S.${objext}"
4442
	  $run $rm "$output_objdir/${outputname}S.${objext}"
4443
	fi
4444

    
4445
	exit $status
4446
      fi
4447

    
4448
      if test -n "$shlibpath_var"; then
4449
	# We should set the shlibpath_var
4450
	rpath=
4451
	for dir in $temp_rpath; do
4452
	  case $dir in
4453
	  [\\/]* | [A-Za-z]:[\\/]*)
4454
	    # Absolute path.
4455
	    rpath="$rpath$dir:"
4456
	    ;;
4457
	  *)
4458
	    # Relative path: add a thisdir entry.
4459
	    rpath="$rpath\$thisdir/$dir:"
4460
	    ;;
4461
	  esac
4462
	done
4463
	temp_rpath="$rpath"
4464
      fi
4465

    
4466
      if test -n "$compile_shlibpath$finalize_shlibpath"; then
4467
	compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
4468
      fi
4469
      if test -n "$finalize_shlibpath"; then
4470
	finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
4471
      fi
4472

    
4473
      compile_var=
4474
      finalize_var=
4475
      if test -n "$runpath_var"; then
4476
	if test -n "$perm_rpath"; then
4477
	  # We should set the runpath_var.
4478
	  rpath=
4479
	  for dir in $perm_rpath; do
4480
	    rpath="$rpath$dir:"
4481
	  done
4482
	  compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
4483
	fi
4484
	if test -n "$finalize_perm_rpath"; then
4485
	  # We should set the runpath_var.
4486
	  rpath=
4487
	  for dir in $finalize_perm_rpath; do
4488
	    rpath="$rpath$dir:"
4489
	  done
4490
	  finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
4491
	fi
4492
      fi
4493

    
4494
      if test "$no_install" = yes; then
4495
	# We don't need to create a wrapper script.
4496
	link_command="$compile_var$compile_command$compile_rpath"
4497
	# Replace the output file specification.
4498
	link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
4499
	# Delete the old output file.
4500
	$run $rm $output
4501
	# Link the executable and exit
4502
	$show "$link_command"
4503
	$run eval "$link_command" || exit $?
4504
	exit $EXIT_SUCCESS
4505
      fi
4506

    
4507
      if test "$hardcode_action" = relink; then
4508
	# Fast installation is not supported
4509
	link_command="$compile_var$compile_command$compile_rpath"
4510
	relink_command="$finalize_var$finalize_command$finalize_rpath"
4511

    
4512
	$echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
4513
	$echo "$modename: \`$output' will be relinked during installation" 1>&2
4514
      else
4515
	if test "$fast_install" != no; then
4516
	  link_command="$finalize_var$compile_command$finalize_rpath"
4517
	  if test "$fast_install" = yes; then
4518
	    relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
4519
	  else
4520
	    # fast_install is set to needless
4521
	    relink_command=
4522
	  fi
4523
	else
4524
	  link_command="$compile_var$compile_command$compile_rpath"
4525
	  relink_command="$finalize_var$finalize_command$finalize_rpath"
4526
	fi
4527
      fi
4528

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

    
4532
      # Delete the old output files.
4533
      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
4534

    
4535
      $show "$link_command"
4536
      $run eval "$link_command" || exit $?
4537

    
4538
      # Now create the wrapper script.
4539
      $show "creating $output"
4540

    
4541
      # Quote the relink command for shipping.
4542
      if test -n "$relink_command"; then
4543
	# Preserve any variables that may affect compiler behavior
4544
	for var in $variables_saved_for_relink; do
4545
	  if eval test -z \"\${$var+set}\"; then
4546
	    relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
4547
	  elif eval var_value=\$$var; test -z "$var_value"; then
4548
	    relink_command="$var=; export $var; $relink_command"
4549
	  else
4550
	    var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4551
	    relink_command="$var=\"$var_value\"; export $var; $relink_command"
4552
	  fi
4553
	done
4554
	relink_command="(cd `pwd`; $relink_command)"
4555
	relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4556
      fi
4557

    
4558
      # Quote $echo for shipping.
4559
      if test "X$echo" = "X$SHELL $progpath --fallback-echo"; then
4560
	case $progpath in
4561
	[\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $progpath --fallback-echo";;
4562
	*) qecho="$SHELL `pwd`/$progpath --fallback-echo";;
4563
	esac
4564
	qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
4565
      else
4566
	qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
4567
      fi
4568

    
4569
      # Only actually do things if our run command is non-null.
4570
      if test -z "$run"; then
4571
	# win32 will think the script is a binary if it has
4572
	# a .exe suffix, so we strip it off here.
4573
	case $output in
4574
	  *.exe) output=`$echo $output|${SED} 's,.exe$,,'` ;;
4575
	esac
4576
	# test for cygwin because mv fails w/o .exe extensions
4577
	case $host in
4578
	  *cygwin*)
4579
	    exeext=.exe
4580
	    outputname=`$echo $outputname|${SED} 's,.exe$,,'` ;;
4581
	  *) exeext= ;;
4582
	esac
4583
	case $host in
4584
	  *cygwin* | *mingw* )
4585
	    cwrappersource=`$echo ${objdir}/lt-${output}.c`
4586
	    cwrapper=`$echo ${output}.exe`
4587
	    $rm $cwrappersource $cwrapper
4588
	    trap "$rm $cwrappersource $cwrapper; exit $EXIT_FAILURE" 1 2 15
4589

    
4590
	    cat > $cwrappersource <<EOF
4591

    
4592
/* $cwrappersource - temporary wrapper executable for $objdir/$outputname
4593
   Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4594

    
4595
   The $output program cannot be directly executed until all the libtool
4596
   libraries that it depends on are installed.
4597

    
4598
   This wrapper executable should never be moved out of the build directory.
4599
   If it is, it will not operate correctly.
4600

    
4601
   Currently, it simply execs the wrapper *script* "/bin/sh $output",
4602
   but could eventually absorb all of the scripts functionality and
4603
   exec $objdir/$outputname directly.
4604
*/
4605
EOF
4606
	    cat >> $cwrappersource<<"EOF"
4607
#include <stdio.h>
4608
#include <stdlib.h>
4609
#include <unistd.h>
4610
#include <malloc.h>
4611
#include <stdarg.h>
4612
#include <assert.h>
4613

    
4614
#if defined(PATH_MAX)
4615
# define LT_PATHMAX PATH_MAX
4616
#elif defined(MAXPATHLEN)
4617
# define LT_PATHMAX MAXPATHLEN
4618
#else
4619
# define LT_PATHMAX 1024
4620
#endif
4621

    
4622
#ifndef DIR_SEPARATOR
4623
#define DIR_SEPARATOR '/'
4624
#endif
4625

    
4626
#if defined (_WIN32) || defined (__MSDOS__) || defined (__DJGPP__) || \
4627
  defined (__OS2__)
4628
#define HAVE_DOS_BASED_FILE_SYSTEM
4629
#ifndef DIR_SEPARATOR_2
4630
#define DIR_SEPARATOR_2 '\\'
4631
#endif
4632
#endif
4633

    
4634
#ifndef DIR_SEPARATOR_2
4635
# define IS_DIR_SEPARATOR(ch) ((ch) == DIR_SEPARATOR)
4636
#else /* DIR_SEPARATOR_2 */
4637
# define IS_DIR_SEPARATOR(ch) \
4638
        (((ch) == DIR_SEPARATOR) || ((ch) == DIR_SEPARATOR_2))
4639
#endif /* DIR_SEPARATOR_2 */
4640

    
4641
#define XMALLOC(type, num)      ((type *) xmalloc ((num) * sizeof(type)))
4642
#define XFREE(stale) do { \
4643
  if (stale) { free ((void *) stale); stale = 0; } \
4644
} while (0)
4645

    
4646
const char *program_name = NULL;
4647

    
4648
void * xmalloc (size_t num);
4649
char * xstrdup (const char *string);
4650
char * basename (const char *name);
4651
char * fnqualify(const char *path);
4652
char * strendzap(char *str, const char *pat);
4653
void lt_fatal (const char *message, ...);
4654

    
4655
int
4656
main (int argc, char *argv[])
4657
{
4658
  char **newargz;
4659
  int i;
4660

    
4661
  program_name = (char *) xstrdup ((char *) basename (argv[0]));
4662
  newargz = XMALLOC(char *, argc+2);
4663
EOF
4664

    
4665
	    cat >> $cwrappersource <<EOF
4666
  newargz[0] = "$SHELL";
4667
EOF
4668

    
4669
	    cat >> $cwrappersource <<"EOF"
4670
  newargz[1] = fnqualify(argv[0]);
4671
  /* we know the script has the same name, without the .exe */
4672
  /* so make sure newargz[1] doesn't end in .exe */
4673
  strendzap(newargz[1],".exe");
4674
  for (i = 1; i < argc; i++)
4675
    newargz[i+1] = xstrdup(argv[i]);
4676
  newargz[argc+1] = NULL;
4677
EOF
4678

    
4679
	    cat >> $cwrappersource <<EOF
4680
  execv("$SHELL",newargz);
4681
EOF
4682

    
4683
	    cat >> $cwrappersource <<"EOF"
4684
}
4685

    
4686
void *
4687
xmalloc (size_t num)
4688
{
4689
  void * p = (void *) malloc (num);
4690
  if (!p)
4691
    lt_fatal ("Memory exhausted");
4692

    
4693
  return p;
4694
}
4695

    
4696
char *
4697
xstrdup (const char *string)
4698
{
4699
  return string ? strcpy ((char *) xmalloc (strlen (string) + 1), string) : NULL
4700
;
4701
}
4702

    
4703
char *
4704
basename (const char *name)
4705
{
4706
  const char *base;
4707

    
4708
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4709
  /* Skip over the disk name in MSDOS pathnames. */
4710
  if (isalpha (name[0]) && name[1] == ':')
4711
    name += 2;
4712
#endif
4713

    
4714
  for (base = name; *name; name++)
4715
    if (IS_DIR_SEPARATOR (*name))
4716
      base = name + 1;
4717
  return (char *) base;
4718
}
4719

    
4720
char *
4721
fnqualify(const char *path)
4722
{
4723
  size_t size;
4724
  char *p;
4725
  char tmp[LT_PATHMAX + 1];
4726

    
4727
  assert(path != NULL);
4728

    
4729
  /* Is it qualified already? */
4730
#if defined (HAVE_DOS_BASED_FILE_SYSTEM)
4731
  if (isalpha (path[0]) && path[1] == ':')
4732
    return xstrdup (path);
4733
#endif
4734
  if (IS_DIR_SEPARATOR (path[0]))
4735
    return xstrdup (path);
4736

    
4737
  /* prepend the current directory */
4738
  /* doesn't handle '~' */
4739
  if (getcwd (tmp, LT_PATHMAX) == NULL)
4740
    lt_fatal ("getcwd failed");
4741
  size = strlen(tmp) + 1 + strlen(path) + 1; /* +2 for '/' and '\0' */
4742
  p = XMALLOC(char, size);
4743
  sprintf(p, "%s%c%s", tmp, DIR_SEPARATOR, path);
4744
  return p;
4745
}
4746

    
4747
char *
4748
strendzap(char *str, const char *pat)
4749
{
4750
  size_t len, patlen;
4751

    
4752
  assert(str != NULL);
4753
  assert(pat != NULL);
4754

    
4755
  len = strlen(str);
4756
  patlen = strlen(pat);
4757

    
4758
  if (patlen <= len)
4759
  {
4760
    str += len - patlen;
4761
    if (strcmp(str, pat) == 0)
4762
      *str = '\0';
4763
  }
4764
  return str;
4765
}
4766

    
4767
static void
4768
lt_error_core (int exit_status, const char * mode,
4769
          const char * message, va_list ap)
4770
{
4771
  fprintf (stderr, "%s: %s: ", program_name, mode);
4772
  vfprintf (stderr, message, ap);
4773
  fprintf (stderr, ".\n");
4774

    
4775
  if (exit_status >= 0)
4776
    exit (exit_status);
4777
}
4778

    
4779
void
4780
lt_fatal (const char *message, ...)
4781
{
4782
  va_list ap;
4783
  va_start (ap, message);
4784
  lt_error_core (EXIT_FAILURE, "FATAL", message, ap);
4785
  va_end (ap);
4786
}
4787
EOF
4788
	  # we should really use a build-platform specific compiler
4789
	  # here, but OTOH, the wrappers (shell script and this C one)
4790
	  # are only useful if you want to execute the "real" binary.
4791
	  # Since the "real" binary is built for $host, then this
4792
	  # wrapper might as well be built for $host, too.
4793
	  $run $LTCC -s -o $cwrapper $cwrappersource
4794
	  ;;
4795
	esac
4796
	$rm $output
4797
	trap "$rm $output; exit $EXIT_FAILURE" 1 2 15
4798

    
4799
	$echo > $output "\
4800
#! $SHELL
4801

    
4802
# $output - temporary wrapper script for $objdir/$outputname
4803
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4804
#
4805
# The $output program cannot be directly executed until all the libtool
4806
# libraries that it depends on are installed.
4807
#
4808
# This wrapper script should never be moved out of the build directory.
4809
# If it is, it will not operate correctly.
4810

    
4811
# Sed substitution that helps us do robust quoting.  It backslashifies
4812
# metacharacters that are still active within double-quoted strings.
4813
Xsed='${SED} -e 1s/^X//'
4814
sed_quote_subst='$sed_quote_subst'
4815

    
4816
# The HP-UX ksh and POSIX shell print the target directory to stdout
4817
# if CDPATH is set.
4818
if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
4819

    
4820
relink_command=\"$relink_command\"
4821

    
4822
# This environment variable determines our operation mode.
4823
if test \"\$libtool_install_magic\" = \"$magic\"; then
4824
  # install mode needs the following variable:
4825
  notinst_deplibs='$notinst_deplibs'
4826
else
4827
  # When we are sourced in execute mode, \$file and \$echo are already set.
4828
  if test \"\$libtool_execute_magic\" != \"$magic\"; then
4829
    echo=\"$qecho\"
4830
    file=\"\$0\"
4831
    # Make sure echo works.
4832
    if test \"X\$1\" = X--no-reexec; then
4833
      # Discard the --no-reexec flag, and continue.
4834
      shift
4835
    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
4836
      # Yippee, \$echo works!
4837
      :
4838
    else
4839
      # Restart under the correct shell, and then maybe \$echo will work.
4840
      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
4841
    fi
4842
  fi\
4843
"
4844
	$echo >> $output "\
4845

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

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

    
4855
    # If there was a directory component, then change thisdir.
4856
    if test \"x\$destdir\" != \"x\$file\"; then
4857
      case \"\$destdir\" in
4858
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4859
      *) thisdir=\"\$thisdir/\$destdir\" ;;
4860
      esac
4861
    fi
4862

    
4863
    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
4864
    file=\`ls -ld \"\$thisdir/\$file\" | ${SED} -n 's/.*-> //p'\`
4865
  done
4866

    
4867
  # Try to get the absolute directory name.
4868
  absdir=\`cd \"\$thisdir\" && pwd\`
4869
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
4870
"
4871

    
4872
	if test "$fast_install" = yes; then
4873
	  $echo >> $output "\
4874
  program=lt-'$outputname'$exeext
4875
  progdir=\"\$thisdir/$objdir\"
4876

    
4877
  if test ! -f \"\$progdir/\$program\" || \\
4878
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | ${SED} 1q\`; \\
4879
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4880

    
4881
    file=\"\$\$-\$program\"
4882

    
4883
    if test ! -d \"\$progdir\"; then
4884
      $mkdir \"\$progdir\"
4885
    else
4886
      $rm \"\$progdir/\$file\"
4887
    fi"
4888

    
4889
	  $echo >> $output "\
4890

    
4891
    # relink executable if necessary
4892
    if test -n \"\$relink_command\"; then
4893
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4894
      else
4895
	$echo \"\$relink_command_output\" >&2
4896
	$rm \"\$progdir/\$file\"
4897
	exit $EXIT_FAILURE
4898
      fi
4899
    fi
4900

    
4901
    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4902
    { $rm \"\$progdir/\$program\";
4903
      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4904
    $rm \"\$progdir/\$file\"
4905
  fi"
4906
	else
4907
	  $echo >> $output "\
4908
  program='$outputname'
4909
  progdir=\"\$thisdir/$objdir\"
4910
"
4911
	fi
4912

    
4913
	$echo >> $output "\
4914

    
4915
  if test -f \"\$progdir/\$program\"; then"
4916

    
4917
	# Export our shlibpath_var if we have one.
4918
	if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4919
	  $echo >> $output "\
4920
    # Add our own library path to $shlibpath_var
4921
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4922

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

    
4927
    export $shlibpath_var
4928
"
4929
	fi
4930

    
4931
	# fixup the dll searchpath if we need to.
4932
	if test -n "$dllsearchpath"; then
4933
	  $echo >> $output "\
4934
    # Add the dll search path components to the executable PATH
4935
    PATH=$dllsearchpath:\$PATH
4936
"
4937
	fi
4938

    
4939
	$echo >> $output "\
4940
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
4941
      # Run the actual program with our arguments.
4942
"
4943
	case $host in
4944
	# Backslashes separate directories on plain windows
4945
	*-*-mingw | *-*-os2*)
4946
	  $echo >> $output "\
4947
      exec \$progdir\\\\\$program \${1+\"\$@\"}
4948
"
4949
	  ;;
4950

    
4951
	*)
4952
	  $echo >> $output "\
4953
      exec \$progdir/\$program \${1+\"\$@\"}
4954
"
4955
	  ;;
4956
	esac
4957
	$echo >> $output "\
4958
      \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
4959
      exit $EXIT_FAILURE
4960
    fi
4961
  else
4962
    # The program doesn't exist.
4963
    \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
4964
    \$echo \"This script is just a wrapper for \$program.\" 1>&2
4965
    $echo \"See the $PACKAGE documentation for more information.\" 1>&2
4966
    exit $EXIT_FAILURE
4967
  fi
4968
fi\
4969
"
4970
	chmod +x $output
4971
      fi
4972
      exit $EXIT_SUCCESS
4973
      ;;
4974
    esac
4975

    
4976
    # See if we need to build an old-fashioned archive.
4977
    for oldlib in $oldlibs; do
4978

    
4979
      if test "$build_libtool_libs" = convenience; then
4980
	oldobjs="$libobjs_save"
4981
	addlibs="$convenience"
4982
	build_libtool_libs=no
4983
      else
4984
	if test "$build_libtool_libs" = module; then
4985
	  oldobjs="$libobjs_save"
4986
	  build_libtool_libs=no
4987
	else
4988
	  oldobjs="$old_deplibs $non_pic_objects"
4989
	fi
4990
	addlibs="$old_convenience"
4991
      fi
4992

    
4993
      if test -n "$addlibs"; then
4994
	gentop="$output_objdir/${outputname}x"
4995
	$show "${rm}r $gentop"
4996
	$run ${rm}r "$gentop"
4997
	$show "$mkdir $gentop"
4998
	$run $mkdir "$gentop"
4999
	status=$?
5000
	if test "$status" -ne 0 && test ! -d "$gentop"; then
5001
	  exit $status
5002
	fi
5003
	generated="$generated $gentop"
5004

    
5005
	# Add in members from convenience archives.
5006
	for xlib in $addlibs; do
5007
	  # Extract the objects.
5008
	  case $xlib in
5009
	  [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
5010
	  *) xabs=`pwd`"/$xlib" ;;
5011
	  esac
5012
	  xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
5013
	  xdir="$gentop/$xlib"
5014

    
5015
	  $show "${rm}r $xdir"
5016
	  $run ${rm}r "$xdir"
5017
	  $show "$mkdir $xdir"
5018
	  $run $mkdir "$xdir"
5019
	  status=$?
5020
	  if test "$status" -ne 0 && test ! -d "$xdir"; then
5021
	    exit $status
5022
	  fi
5023
	  # We will extract separately just the conflicting names and we will no
5024
	  # longer touch any unique names. It is faster to leave these extract
5025
	  # automatically by $AR in one run.
5026
	  $show "(cd $xdir && $AR x $xabs)"
5027
	  $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
5028
	  if ($AR t "$xabs" | sort | sort -uc >/dev/null 2>&1); then
5029
	    :
5030
	  else
5031
	    $echo "$modename: warning: object name conflicts; renaming object files" 1>&2
5032
	    $echo "$modename: warning: to ensure that they will not overwrite" 1>&2
5033
	    $AR t "$xabs" | sort | uniq -cd | while read -r count name
5034
	    do
5035
	      i=1
5036
	      while test "$i" -le "$count"
5037
	      do
5038
	       # Put our $i before any first dot (extension)
5039
	       # Never overwrite any file
5040
	       name_to="$name"
5041
	       while test "X$name_to" = "X$name" || test -f "$xdir/$name_to"
5042
	       do
5043
		 name_to=`$echo "X$name_to" | $Xsed -e "s/\([^.]*\)/\1-$i/"`
5044
	       done
5045
	       $show "(cd $xdir && $AR xN $i $xabs '$name' && $mv '$name' '$name_to')"
5046
	       $run eval "(cd \$xdir && $AR xN $i \$xabs '$name' && $mv '$name' '$name_to')" || exit $?
5047
	       i=`expr $i + 1`
5048
	      done
5049
	    done
5050
	  fi
5051

    
5052
	  oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print -o -name \*.lo -print | $NL2SP`
5053
	done
5054
      fi
5055

    
5056
      # Do each command in the archive commands.
5057
      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
5058
       cmds=$old_archive_from_new_cmds
5059
      else
5060
	eval cmds=\"$old_archive_cmds\"
5061

    
5062
	if len=`expr "X$cmds" : ".*"` &&
5063
	     test "$len" -le "$max_cmd_len" || test "$max_cmd_len" -le -1; then
5064
	  cmds=$old_archive_cmds
5065
	else
5066
	  # the command line is too long to link in one step, link in parts
5067
	  $echo "using piecewise archive linking..."
5068
	  save_RANLIB=$RANLIB
5069
	  RANLIB=:
5070
	  objlist=
5071
	  concat_cmds=
5072
	  save_oldobjs=$oldobjs
5073
	  # GNU ar 2.10+ was changed to match POSIX; thus no paths are
5074
	  # encoded into archives.  This makes 'ar r' malfunction in
5075
	  # this piecewise linking case whenever conflicting object
5076
	  # names appear in distinct ar calls; check, warn and compensate.
5077
	    if (for obj in $save_oldobjs
5078
	    do
5079
	      $echo "X$obj" | $Xsed -e 's%^.*/%%'
5080
	    done | sort | sort -uc >/dev/null 2>&1); then
5081
	    :
5082
	  else
5083
	    $echo "$modename: warning: object name conflicts; overriding AR_FLAGS to 'cq'" 1>&2
5084
	    $echo "$modename: warning: to ensure that POSIX-compatible ar will work" 1>&2
5085
	    AR_FLAGS=cq
5086
	  fi
5087
	  # Is there a better way of finding the last object in the list?
5088
	  for obj in $save_oldobjs
5089
	  do
5090
	    last_oldobj=$obj
5091
	  done
5092
	  for obj in $save_oldobjs
5093
	  do
5094
	    oldobjs="$objlist $obj"
5095
	    objlist="$objlist $obj"
5096
	    eval test_cmds=\"$old_archive_cmds\"
5097
	    if len=`expr "X$test_cmds" : ".*"` &&
5098
	       test "$len" -le "$max_cmd_len"; then
5099
	      :
5100
	    else
5101
	      # the above command should be used before it gets too long
5102
	      oldobjs=$objlist
5103
	      if test "$obj" = "$last_oldobj" ; then
5104
	        RANLIB=$save_RANLIB
5105
	      fi
5106
	      test -z "$concat_cmds" || concat_cmds=$concat_cmds~
5107
	      eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
5108
	      objlist=
5109
	    fi
5110
	  done
5111
	  RANLIB=$save_RANLIB
5112
	  oldobjs=$objlist
5113
	  if test "X$oldobjs" = "X" ; then
5114
	    eval cmds=\"\$concat_cmds\"
5115
	  else
5116
	    eval cmds=\"\$concat_cmds~\$old_archive_cmds\"
5117
	  fi
5118
	fi
5119
      fi
5120
      save_ifs="$IFS"; IFS='~'
5121
      for cmd in $cmds; do
5122
        eval cmd=\"$cmd\"
5123
	IFS="$save_ifs"
5124
	$show "$cmd"
5125
	$run eval "$cmd" || exit $?
5126
      done
5127
      IFS="$save_ifs"
5128
    done
5129

    
5130
    if test -n "$generated"; then
5131
      $show "${rm}r$generated"
5132
      $run ${rm}r$generated
5133
    fi
5134

    
5135
    # Now create the libtool archive.
5136
    case $output in
5137
    *.la)
5138
      old_library=
5139
      test "$build_old_libs" = yes && old_library="$libname.$libext"
5140
      $show "creating $output"
5141

    
5142
      # Preserve any variables that may affect compiler behavior
5143
      for var in $variables_saved_for_relink; do
5144
	if eval test -z \"\${$var+set}\"; then
5145
	  relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
5146
	elif eval var_value=\$$var; test -z "$var_value"; then
5147
	  relink_command="$var=; export $var; $relink_command"
5148
	else
5149
	  var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
5150
	  relink_command="$var=\"$var_value\"; export $var; $relink_command"
5151
	fi
5152
      done
5153
      # Quote the link command for shipping.
5154
      relink_command="(cd `pwd`; $SHELL $progpath $preserve_args --mode=relink $libtool_args @inst_prefix_dir@)"
5155
      relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
5156
      if test "$hardcode_automatic" = yes ; then
5157
	relink_command=
5158
      fi
5159

    
5160

    
5161
      # Only create the output if not a dry run.
5162
      if test -z "$run"; then
5163
	for installed in no yes; do
5164
	  if test "$installed" = yes; then
5165
	    if test -z "$install_libdir"; then
5166
	      break
5167
	    fi
5168
	    output="$output_objdir/$outputname"i
5169
	    # Replace all uninstalled libtool libraries with the installed ones
5170
	    newdependency_libs=
5171
	    for deplib in $dependency_libs; do
5172
	      case $deplib in
5173
	      *.la)
5174
		name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
5175
		eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
5176
		if test -z "$libdir"; then
5177
		  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
5178
		  exit $EXIT_FAILURE
5179
		fi
5180
		newdependency_libs="$newdependency_libs $libdir/$name"
5181
		;;
5182
	      *) newdependency_libs="$newdependency_libs $deplib" ;;
5183
	      esac
5184
	    done
5185
	    dependency_libs="$newdependency_libs"
5186
	    newdlfiles=
5187
	    for lib in $dlfiles; do
5188
	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5189
	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5190
	      if test -z "$libdir"; then
5191
		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5192
		exit $EXIT_FAILURE
5193
	      fi
5194
	      newdlfiles="$newdlfiles $libdir/$name"
5195
	    done
5196
	    dlfiles="$newdlfiles"
5197
	    newdlprefiles=
5198
	    for lib in $dlprefiles; do
5199
	      name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
5200
	      eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
5201
	      if test -z "$libdir"; then
5202
		$echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
5203
		exit $EXIT_FAILURE
5204
	      fi
5205
	      newdlprefiles="$newdlprefiles $libdir/$name"
5206
	    done
5207
	    dlprefiles="$newdlprefiles"
5208
	  else
5209
	    newdlfiles=
5210
	    for lib in $dlfiles; do
5211
	      case $lib in
5212
		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5213
		*) abs=`pwd`"/$lib" ;;
5214
	      esac
5215
	      newdlfiles="$newdlfiles $abs"
5216
	    done
5217
	    dlfiles="$newdlfiles"
5218
	    newdlprefiles=
5219
	    for lib in $dlprefiles; do
5220
	      case $lib in
5221
		[\\/]* | [A-Za-z]:[\\/]*) abs="$lib" ;;
5222
		*) abs=`pwd`"/$lib" ;;
5223
	      esac
5224
	      newdlprefiles="$newdlprefiles $abs"
5225
	    done
5226
	    dlprefiles="$newdlprefiles"
5227
	  fi
5228
	  $rm $output
5229
	  # place dlname in correct position for cygwin
5230
	  tdlname=$dlname
5231
	  case $host,$output,$installed,$module,$dlname in
5232
	    *cygwin*,*lai,yes,no,*.dll | *mingw*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
5233
	  esac
5234
	  $echo > $output "\
5235
# $outputname - a libtool library file
5236
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
5237
#
5238
# Please DO NOT delete this file!
5239
# It is necessary for linking the library.
5240

    
5241
# The name that we can dlopen(3).
5242
dlname='$tdlname'
5243

    
5244
# Names of this library.
5245
library_names='$library_names'
5246

    
5247
# The name of the static archive.
5248
old_library='$old_library'
5249

    
5250
# Libraries that this one depends upon.
5251
dependency_libs='$dependency_libs'
5252

    
5253
# Version information for $libname.
5254
current=$current
5255
age=$age
5256
revision=$revision
5257

    
5258
# Is this an already installed library?
5259
installed=$installed
5260

    
5261
# Should we warn about portability when linking against -modules?
5262
shouldnotlink=$module
5263

    
5264
# Files to dlopen/dlpreopen
5265
dlopen='$dlfiles'
5266
dlpreopen='$dlprefiles'
5267

    
5268
# Directory that this library needs to be installed in:
5269
libdir='$install_libdir'"
5270
	  if test "$installed" = no && test "$need_relink" = yes; then
5271
	    $echo >> $output "\
5272
relink_command=\"$relink_command\""
5273
	  fi
5274
	done
5275
      fi
5276

    
5277
      # Do a symbolic link so that the libtool archive can be found in
5278
      # LD_LIBRARY_PATH before the program is installed.
5279
      $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
5280
      $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
5281
      ;;
5282
    esac
5283
    exit $EXIT_SUCCESS
5284
    ;;
5285

    
5286
  # libtool install mode
5287
  install)
5288
    modename="$modename: install"
5289

    
5290
    # There may be an optional sh(1) argument at the beginning of
5291
    # install_prog (especially on Windows NT).
5292
    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
5293
       # Allow the use of GNU shtool's install command.
5294
       $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
5295
      # Aesthetically quote it.
5296
      arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
5297
      case $arg in
5298
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
5299
	arg="\"$arg\""
5300
	;;
5301
      esac
5302
      install_prog="$arg "
5303
      arg="$1"
5304
      shift
5305
    else
5306
      install_prog=
5307
      arg="$nonopt"
5308
    fi
5309

    
5310
    # The real first argument should be the name of the installation program.
5311
    # Aesthetically quote it.
5312
    arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5313
    case $arg in
5314
    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
5315
      arg="\"$arg\""
5316
      ;;
5317
    esac
5318
    install_prog="$install_prog$arg"
5319

    
5320
    # We need to accept at least all the BSD install flags.
5321
    dest=
5322
    files=
5323
    opts=
5324
    prev=
5325
    install_type=
5326
    isdir=no
5327
    stripme=
5328
    for arg
5329
    do
5330
      if test -n "$dest"; then
5331
	files="$files $dest"
5332
	dest="$arg"
5333
	continue
5334
      fi
5335

    
5336
      case $arg in
5337
      -d) isdir=yes ;;
5338
      -f) prev="-f" ;;
5339
      -g) prev="-g" ;;
5340
      -m) prev="-m" ;;
5341
      -o) prev="-o" ;;
5342
      -s)
5343
	stripme=" -s"
5344
	continue
5345
	;;
5346
      -*) ;;
5347

    
5348
      *)
5349
	# If the previous option needed an argument, then skip it.
5350
	if test -n "$prev"; then
5351
	  prev=
5352
	else
5353
	  dest="$arg"
5354
	  continue
5355
	fi
5356
	;;
5357
      esac
5358

    
5359
      # Aesthetically quote the argument.
5360
      arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
5361
      case $arg in
5362
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \	]*|*]*)
5363
	arg="\"$arg\""
5364
	;;
5365
      esac
5366
      install_prog="$install_prog $arg"
5367
    done
5368

    
5369
    if test -z "$install_prog"; then
5370
      $echo "$modename: you must specify an install program" 1>&2
5371
      $echo "$help" 1>&2
5372
      exit $EXIT_FAILURE
5373
    fi
5374

    
5375
    if test -n "$prev"; then
5376
      $echo "$modename: the \`$prev' option requires an argument" 1>&2
5377
      $echo "$help" 1>&2
5378
      exit $EXIT_FAILURE
5379
    fi
5380

    
5381
    if test -z "$files"; then
5382
      if test -z "$dest"; then
5383
	$echo "$modename: no file or destination specified" 1>&2
5384
      else
5385
	$echo "$modename: you must specify a destination" 1>&2
5386
      fi
5387
      $echo "$help" 1>&2
5388
      exit $EXIT_FAILURE
5389
    fi
5390

    
5391
    # Strip any trailing slash from the destination.
5392
    dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
5393

    
5394
    # Check to see that the destination is a directory.
5395
    test -d "$dest" && isdir=yes
5396
    if test "$isdir" = yes; then
5397
      destdir="$dest"
5398
      destname=
5399
    else
5400
      destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
5401
      test "X$destdir" = "X$dest" && destdir=.
5402
      destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
5403

    
5404
      # Not a directory, so check to see that there is only one file specified.
5405
      set dummy $files
5406
      if test "$#" -gt 2; then
5407
	$echo "$modename: \`$dest' is not a directory" 1>&2
5408
	$echo "$help" 1>&2
5409
	exit $EXIT_FAILURE
5410
      fi
5411
    fi
5412
    case $destdir in
5413
    [\\/]* | [A-Za-z]:[\\/]*) ;;
5414
    *)
5415
      for file in $files; do
5416
	case $file in
5417
	*.lo) ;;
5418
	*)
5419
	  $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
5420
	  $echo "$help" 1>&2
5421
	  exit $EXIT_FAILURE
5422
	  ;;
5423
	esac
5424
      done
5425
      ;;
5426
    esac
5427

    
5428
    # This variable tells wrapper scripts just to set variables rather
5429
    # than running their programs.
5430
    libtool_install_magic="$magic"
5431

    
5432
    staticlibs=
5433
    future_libdirs=
5434
    current_libdirs=
5435
    for file in $files; do
5436

    
5437
      # Do each installation.
5438
      case $file in
5439
      *.$libext)
5440
	# Do the static libraries later.
5441
	staticlibs="$staticlibs $file"
5442
	;;
5443

    
5444
      *.la)
5445
	# Check to see that this really is a libtool archive.
5446
	if (${SED} -e '2q' $file | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
5447
	else
5448
	  $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
5449
	  $echo "$help" 1>&2
5450
	  exit $EXIT_FAILURE
5451
	fi
5452

    
5453
	library_names=
5454
	old_library=
5455
	relink_command=
5456
	# If there is no directory component, then add one.
5457
	case $file in
5458
	*/* | *\\*) . $file ;;
5459
	*) . ./$file ;;
5460
	esac
5461

    
5462
	# Add the libdir to current_libdirs if it is the destination.
5463
	if test "X$destdir" = "X$libdir"; then
5464
	  case "$current_libdirs " in
5465
	  *" $libdir "*) ;;
5466
	  *) current_libdirs="$current_libdirs $libdir" ;;
5467
	  esac
5468
	else
5469
	  # Note the libdir as a future libdir.
5470
	  case "$future_libdirs " in
5471
	  *" $libdir "*) ;;
5472
	  *) future_libdirs="$future_libdirs $libdir" ;;
5473
	  esac
5474
	fi
5475

    
5476
	dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
5477
	test "X$dir" = "X$file/" && dir=
5478
	dir="$dir$objdir"
5479

    
5480
	if test -n "$relink_command"; then
5481
	  # Determine the prefix the user has applied to our future dir.
5482
	  inst_prefix_dir=`$echo "$destdir" | $SED "s%$libdir\$%%"`
5483

    
5484
	  # Don't allow the user to place us outside of our expected
5485
	  # location b/c this prevents finding dependent libraries that
5486
	  # are installed to the same prefix.
5487
	  # At present, this check doesn't affect windows .dll's that
5488
	  # are installed into $libdir/../bin (currently, that works fine)
5489
	  # but it's something to keep an eye on.
5490
	  if test "$inst_prefix_dir" = "$destdir"; then
5491
	    $echo "$modename: error: cannot install \`$file' to a directory not ending in $libdir" 1>&2
5492
	    exit $EXIT_FAILURE
5493
	  fi
5494

    
5495
	  if test -n "$inst_prefix_dir"; then
5496
	    # Stick the inst_prefix_dir data into the link command.
5497
	    relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%-inst-prefix-dir $inst_prefix_dir%"`
5498
	  else
5499
	    relink_command=`$echo "$relink_command" | $SED "s%@inst_prefix_dir@%%"`
5500
	  fi
5501

    
5502
	  $echo "$modename: warning: relinking \`$file'" 1>&2
5503
	  $show "$relink_command"
5504
	  if $run eval "$relink_command"; then :
5505
	  else
5506
	    $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5507
	    exit $EXIT_FAILURE
5508
	  fi
5509
	fi
5510

    
5511
	# See the names of the shared library.
5512
	set dummy $library_names
5513
	if test -n "$2"; then
5514
	  realname="$2"
5515
	  shift
5516
	  shift
5517

    
5518
	  srcname="$realname"
5519
	  test -n "$relink_command" && srcname="$realname"T
5520

    
5521
	  # Install the shared library and build the symlinks.
5522
	  $show "$install_prog $dir/$srcname $destdir/$realname"
5523
	  $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
5524
	  if test -n "$stripme" && test -n "$striplib"; then
5525
	    $show "$striplib $destdir/$realname"
5526
	    $run eval "$striplib $destdir/$realname" || exit $?
5527
	  fi
5528

    
5529
	  if test "$#" -gt 0; then
5530
	    # Delete the old symlinks, and create new ones.
5531
	    for linkname
5532
	    do
5533
	      if test "$linkname" != "$realname"; then
5534
		$show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5535
		$run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
5536
	      fi
5537
	    done
5538
	  fi
5539

    
5540
	  # Do each command in the postinstall commands.
5541
	  lib="$destdir/$realname"
5542
	  cmds=$postinstall_cmds
5543
	  save_ifs="$IFS"; IFS='~'
5544
	  for cmd in $cmds; do
5545
	    IFS="$save_ifs"
5546
	    eval cmd=\"$cmd\"
5547
	    $show "$cmd"
5548
	    $run eval "$cmd" || exit $?
5549
	  done
5550
	  IFS="$save_ifs"
5551
	fi
5552

    
5553
	# Install the pseudo-library for information purposes.
5554
	name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5555
	instname="$dir/$name"i
5556
	$show "$install_prog $instname $destdir/$name"
5557
	$run eval "$install_prog $instname $destdir/$name" || exit $?
5558

    
5559
	# Maybe install the static library, too.
5560
	test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
5561
	;;
5562

    
5563
      *.lo)
5564
	# Install (i.e. copy) a libtool object.
5565

    
5566
	# Figure out destination file name, if it wasn't already specified.
5567
	if test -n "$destname"; then
5568
	  destfile="$destdir/$destname"
5569
	else
5570
	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5571
	  destfile="$destdir/$destfile"
5572
	fi
5573

    
5574
	# Deduce the name of the destination old-style object file.
5575
	case $destfile in
5576
	*.lo)
5577
	  staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
5578
	  ;;
5579
	*.$objext)
5580
	  staticdest="$destfile"
5581
	  destfile=
5582
	  ;;
5583
	*)
5584
	  $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
5585
	  $echo "$help" 1>&2
5586
	  exit $EXIT_FAILURE
5587
	  ;;
5588
	esac
5589

    
5590
	# Install the libtool object if requested.
5591
	if test -n "$destfile"; then
5592
	  $show "$install_prog $file $destfile"
5593
	  $run eval "$install_prog $file $destfile" || exit $?
5594
	fi
5595

    
5596
	# Install the old object if enabled.
5597
	if test "$build_old_libs" = yes; then
5598
	  # Deduce the name of the old-style object file.
5599
	  staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
5600

    
5601
	  $show "$install_prog $staticobj $staticdest"
5602
	  $run eval "$install_prog \$staticobj \$staticdest" || exit $?
5603
	fi
5604
	exit $EXIT_SUCCESS
5605
	;;
5606

    
5607
      *)
5608
	# Figure out destination file name, if it wasn't already specified.
5609
	if test -n "$destname"; then
5610
	  destfile="$destdir/$destname"
5611
	else
5612
	  destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5613
	  destfile="$destdir/$destfile"
5614
	fi
5615

    
5616
	# If the file is missing, and there is a .exe on the end, strip it
5617
	# because it is most likely a libtool script we actually want to
5618
	# install
5619
	stripped_ext=""
5620
	case $file in
5621
	  *.exe)
5622
	    if test ! -f "$file"; then
5623
	      file=`$echo $file|${SED} 's,.exe$,,'`
5624
	      stripped_ext=".exe"
5625
	    fi
5626
	    ;;
5627
	esac
5628

    
5629
	# Do a test to see if this is really a libtool program.
5630
	case $host in
5631
	*cygwin*|*mingw*)
5632
	    wrapper=`$echo $file | ${SED} -e 's,.exe$,,'`
5633
	    ;;
5634
	*)
5635
	    wrapper=$file
5636
	    ;;
5637
	esac
5638
	if (${SED} -e '4q' $wrapper | grep "^# Generated by .*$PACKAGE")>/dev/null 2>&1; then
5639
	  notinst_deplibs=
5640
	  relink_command=
5641

    
5642
	  # To insure that "foo" is sourced, and not "foo.exe",
5643
	  # finese the cygwin/MSYS system by explicitly sourcing "foo."
5644
	  # which disallows the automatic-append-.exe behavior.
5645
	  case $build in
5646
	  *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5647
	  *) wrapperdot=${wrapper} ;;
5648
	  esac
5649
	  # If there is no directory component, then add one.
5650
	  case $file in
5651
	  */* | *\\*) . ${wrapperdot} ;;
5652
	  *) . ./${wrapperdot} ;;
5653
	  esac
5654

    
5655
	  # Check the variables that should have been set.
5656
	  if test -z "$notinst_deplibs"; then
5657
	    $echo "$modename: invalid libtool wrapper script \`$wrapper'" 1>&2
5658
	    exit $EXIT_FAILURE
5659
	  fi
5660

    
5661
	  finalize=yes
5662
	  for lib in $notinst_deplibs; do
5663
	    # Check to see that each library is installed.
5664
	    libdir=
5665
	    if test -f "$lib"; then
5666
	      # If there is no directory component, then add one.
5667
	      case $lib in
5668
	      */* | *\\*) . $lib ;;
5669
	      *) . ./$lib ;;
5670
	      esac
5671
	    fi
5672
	    libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
5673
	    if test -n "$libdir" && test ! -f "$libfile"; then
5674
	      $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
5675
	      finalize=no
5676
	    fi
5677
	  done
5678

    
5679
	  relink_command=
5680
	  # To insure that "foo" is sourced, and not "foo.exe",
5681
	  # finese the cygwin/MSYS system by explicitly sourcing "foo."
5682
	  # which disallows the automatic-append-.exe behavior.
5683
	  case $build in
5684
	  *cygwin* | *mingw*) wrapperdot=${wrapper}. ;;
5685
	  *) wrapperdot=${wrapper} ;;
5686
	  esac
5687
	  # If there is no directory component, then add one.
5688
	  case $file in
5689
	  */* | *\\*) . ${wrapperdot} ;;
5690
	  *) . ./${wrapperdot} ;;
5691
	  esac
5692

    
5693
	  outputname=
5694
	  if test "$fast_install" = no && test -n "$relink_command"; then
5695
	    if test "$finalize" = yes && test -z "$run"; then
5696
	      tmpdir="/tmp"
5697
	      test -n "$TMPDIR" && tmpdir="$TMPDIR"
5698
	      tmpdir="$tmpdir/libtool-$$"
5699
	      save_umask=`umask`
5700
	      umask 0077
5701
	      if $mkdir "$tmpdir"; then
5702
	        umask $save_umask
5703
	      else
5704
	        umask $save_umask
5705
		$echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
5706
		continue
5707
	      fi
5708
	      file=`$echo "X$file$stripped_ext" | $Xsed -e 's%^.*/%%'`
5709
	      outputname="$tmpdir/$file"
5710
	      # Replace the output file specification.
5711
	      relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
5712

    
5713
	      $show "$relink_command"
5714
	      if $run eval "$relink_command"; then :
5715
	      else
5716
		$echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
5717
		${rm}r "$tmpdir"
5718
		continue
5719
	      fi
5720
	      file="$outputname"
5721
	    else
5722
	      $echo "$modename: warning: cannot relink \`$file'" 1>&2
5723
	    fi
5724
	  else
5725
	    # Install the binary that we compiled earlier.
5726
	    file=`$echo "X$file$stripped_ext" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
5727
	  fi
5728
	fi
5729

    
5730
	# remove .exe since cygwin /usr/bin/install will append another
5731
	# one anyways
5732
	case $install_prog,$host in
5733
	*/usr/bin/install*,*cygwin*)
5734
	  case $file:$destfile in
5735
	  *.exe:*.exe)
5736
	    # this is ok
5737
	    ;;
5738
	  *.exe:*)