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

Subversion Repositories or1k

[/] [or1k/] [trunk/] [insight/] [ltmain.sh] - Blame information for rev 1768

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

Line No. Rev Author Line
1 578 markom
# ltmain.sh - Provide generalized library-building support services.
2
# NOTE: Changing this file will not affect anything until you rerun ltconfig.
3
#
4
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001
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
# Check that we have a working $echo.
28
if test "X$1" = X--no-reexec; then
29
  # Discard the --no-reexec flag, and continue.
30
  shift
31
elif test "X$1" = X--fallback-echo; then
32
  # Avoid inline document here, it may be left over
33
  :
34
elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
35
  # Yippee, $echo works!
36
  :
37
else
38
  # Restart under the correct shell, and then maybe $echo will work.
39
  exec $SHELL "$0" --no-reexec ${1+"$@"}
40
fi
41
 
42
if test "X$1" = X--fallback-echo; then
43
  # used as fallback echo
44
  shift
45
  cat <<EOF
46
$*
47
EOF
48
  exit 0
49
fi
50
 
51
# The name of this program.
52
progname=`$echo "$0" | sed 's%^.*/%%'`
53
modename="$progname"
54
 
55
# Constants.
56
PROGRAM=ltmain.sh
57
PACKAGE=libtool
58
VERSION=1.4a
59
TIMESTAMP=" (1.641.2.256 2001/05/28 20:09:07)"
60
 
61
default_mode=
62
help="Try \`$progname --help' for more information."
63
magic="%%%MAGIC variable%%%"
64
mkdir="mkdir"
65
mv="mv -f"
66
rm="rm -f"
67
 
68
# Sed substitution that helps us do robust quoting.  It backslashifies
69
# metacharacters that are still active within double-quoted strings.
70
Xsed='sed -e 1s/^X//'
71
sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
72
SP2NL='tr \040 \012'
73
NL2SP='tr \015\012 \040\040'
74
 
75
# NLS nuisances.
76
# Only set LANG and LC_ALL to C if already set.
77
# These must not be set unconditionally because not all systems understand
78
# e.g. LANG=C (notably SCO).
79
# We save the old values to restore during execute mode.
80
if test "${LC_ALL+set}" = set; then
81
  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
82
fi
83
if test "${LANG+set}" = set; then
84
  save_LANG="$LANG"; LANG=C; export LANG
85
fi
86
 
87
if test "$LTCONFIG_VERSION" != "$VERSION"; then
88
  echo "$modename: ltconfig version \`$LTCONFIG_VERSION' does not match $PROGRAM version \`$VERSION'" 1>&2
89
  echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
90
  exit 1
91
fi
92
 
93
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
94
  echo "$modename: not configured to build any kind of library" 1>&2
95
  echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
96
  exit 1
97
fi
98
 
99
# Global variables.
100
mode=$default_mode
101
nonopt=
102
prev=
103
prevopt=
104
run=
105
show="$echo"
106
show_help=
107
execute_dlfiles=
108
lo2o="s/\\.lo\$/.${objext}/"
109
o2lo="s/\\.${objext}\$/.lo/"
110
 
111
# Parse our command line options once, thoroughly.
112
while test $# -gt 0
113
do
114
  arg="$1"
115
  shift
116
 
117
  case $arg in
118
  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
119
  *) optarg= ;;
120
  esac
121
 
122
  # If the previous option needs an argument, assign it.
123
  if test -n "$prev"; then
124
    case $prev in
125
    execute_dlfiles)
126
      execute_dlfiles="$execute_dlfiles $arg"
127
      ;;
128
    tag)
129
      tagname="$arg"
130
 
131
      # Check whether tagname contains only valid characters
132
      case $tagname in
133
      *[!-_A-Za-z0-9,/]*)
134
        echo "$progname: invalid tag name: $tagname" 1>&2
135
        exit 1
136
        ;;
137
      esac
138
 
139
      case $tagname in
140
      CC)
141
        # Don't test for the "default" C tag, as we know, it's there, but
142
        # not specially marked.
143
        ;;
144
      *)
145
        if grep "^### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$0" > /dev/null; then
146
          taglist="$taglist $tagname"
147
          # Evaluate the configuration.
148
          eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $0`"
149
        else
150
          echo "$progname: ignoring unknown tag $tagname" 1>&2
151
        fi
152
        ;;
153
      esac
154
      ;;
155
    *)
156
      eval "$prev=\$arg"
157
      ;;
158
    esac
159
 
160
    prev=
161
    prevopt=
162
    continue
163
  fi
164
 
165
  # Have we seen a non-optional argument yet?
166
  case $arg in
167
  --help)
168
    show_help=yes
169
    ;;
170
 
171
  --version)
172
    echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
173
    exit 0
174
    ;;
175
 
176
  --config)
177
    sed -n -e '/^### BEGIN LIBTOOL CONFIG/,/^### END LIBTOOL CONFIG/p' < "$0"
178
    # Now print the configurations for the tags.
179
    for tagname in $taglist; do
180
      sed -n -e "/^### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^### END LIBTOOL TAG CONFIG: $tagname$/p" < "$0"
181
    done
182
    exit 0
183
    ;;
184
 
185
  --debug)
186
    echo "$progname: enabling shell trace mode"
187
    set -x
188
    ;;
189
 
190
  --dry-run | -n)
191
    run=:
192
    ;;
193
 
194
  --features)
195
    echo "host: $host"
196
    if test "$build_libtool_libs" = yes; then
197
      echo "enable shared libraries"
198
    else
199
      echo "disable shared libraries"
200
    fi
201
    if test "$build_old_libs" = yes; then
202
      echo "enable static libraries"
203
    else
204
      echo "disable static libraries"
205
    fi
206
    exit 0
207
    ;;
208
 
209
  --finish) mode="finish" ;;
210
 
211
  --mode) prevopt="--mode" prev=mode ;;
212
  --mode=*) mode="$optarg" ;;
213
 
214
  --quiet | --silent)
215
    show=:
216
    ;;
217
 
218
  --tag) prevopt="--tag" prev=tag ;;
219
  --tag=*)
220
    set tag "$optarg" ${1+"$@"}
221
    shift
222
    prev=tag
223
    ;;
224
 
225
  -dlopen)
226
    prevopt="-dlopen"
227
    prev=execute_dlfiles
228
    ;;
229
 
230
  -*)
231
    $echo "$modename: unrecognized option \`$arg'" 1>&2
232
    $echo "$help" 1>&2
233
    exit 1
234
    ;;
235
 
236
  *)
237
    nonopt="$arg"
238
    break
239
    ;;
240
  esac
241
done
242
 
243
if test -n "$prevopt"; then
244
  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
245
  $echo "$help" 1>&2
246
  exit 1
247
fi
248
 
249
# If this variable is set in any of the actions, the command in it
250
# will be execed at the end.  This prevents here-documents from being
251
# left over by shells.
252
exec_cmd=
253
 
254
if test -z "$show_help"; then
255
 
256
  # Infer the operation mode.
257
  if test -z "$mode"; then
258
    case $nonopt in
259
    *cc | *++ | gcc* | *-gcc*)
260
      mode=link
261
      for arg
262
      do
263
        case $arg in
264
        -c)
265
           mode=compile
266
           break
267
           ;;
268
        esac
269
      done
270
      ;;
271
    *db | *dbx | *strace | *truss)
272
      mode=execute
273
      ;;
274
    *install*|cp|mv)
275
      mode=install
276
      ;;
277
    *rm)
278
      mode=uninstall
279
      ;;
280
    *)
281
      # If we have no mode, but dlfiles were specified, then do execute mode.
282
      test -n "$execute_dlfiles" && mode=execute
283
 
284
      # Just use the default operation mode.
285
      if test -z "$mode"; then
286
        if test -n "$nonopt"; then
287
          $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
288
        else
289
          $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
290
        fi
291
      fi
292
      ;;
293
    esac
294
  fi
295
 
296
  # Only execute mode is allowed to have -dlopen flags.
297
  if test -n "$execute_dlfiles" && test "$mode" != execute; then
298
    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
299
    $echo "$help" 1>&2
300
    exit 1
301
  fi
302
 
303
  # Change the help message to a mode-specific one.
304
  generic_help="$help"
305
  help="Try \`$modename --help --mode=$mode' for more information."
306
 
307
  # These modes are in order of execution frequency so that they run quickly.
308
  case $mode in
309
  # libtool compile mode
310
  compile)
311
    modename="$modename: compile"
312
    # Get the compilation command and the source file.
313
    base_compile=
314
    prev=
315
    lastarg=
316
    srcfile="$nonopt"
317
    suppress_output=
318
 
319
    user_target=no
320
    for arg
321
    do
322
      case $prev in
323
      "") ;;
324
      xcompiler)
325
        # Aesthetically quote the previous argument.
326
        prev=
327
        lastarg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
328
 
329
        case $arg in
330
        # Double-quote args containing other shell metacharacters.
331
        # Many Bourne shells cannot handle close brackets correctly
332
        # in scan sets, so we specify it separately.
333
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
334
          arg="\"$arg\""
335
          ;;
336
        esac
337
 
338
        # Add the previous argument to base_compile.
339
        if test -z "$base_compile"; then
340
          base_compile="$lastarg"
341
        else
342
          base_compile="$base_compile $lastarg"
343
        fi
344
        continue
345
        ;;
346
      esac
347
 
348
      # Accept any command-line options.
349
      case $arg in
350
      -o)
351
        if test "$user_target" != "no"; then
352
          $echo "$modename: you cannot specify \`-o' more than once" 1>&2
353
          exit 1
354
        fi
355
        user_target=next
356
        ;;
357
 
358
      -static)
359
        build_old_libs=yes
360
        continue
361
        ;;
362
 
363
      -prefer-pic)
364
        pic_mode=yes
365
        continue
366
        ;;
367
 
368
      -prefer-non-pic)
369
        pic_mode=no
370
        continue
371
        ;;
372
 
373
      -Xcompiler)
374
        prev=xcompiler
375
        continue
376
        ;;
377
 
378
      -Wc,*)
379
        args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
380
        lastarg=
381
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
382
        for arg in $args; do
383
          IFS="$save_ifs"
384
 
385
          # Double-quote args containing other shell metacharacters.
386
          # Many Bourne shells cannot handle close brackets correctly
387
          # in scan sets, so we specify it separately.
388
          case $arg in
389
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
390
            arg="\"$arg\""
391
            ;;
392
          esac
393
          lastarg="$lastarg $arg"
394
        done
395
        IFS="$save_ifs"
396
        lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
397
 
398
        # Add the arguments to base_compile.
399
        if test -z "$base_compile"; then
400
          base_compile="$lastarg"
401
        else
402
          base_compile="$base_compile $lastarg"
403
        fi
404
        continue
405
        ;;
406
      esac
407
 
408
      case $user_target in
409
      next)
410
        # The next one is the -o target name
411
        user_target=yes
412
        continue
413
        ;;
414
      yes)
415
        # We got the output file
416
        user_target=set
417
        libobj="$arg"
418
        continue
419
        ;;
420
      esac
421
 
422
      # Accept the current argument as the source file.
423
      lastarg="$srcfile"
424
      srcfile="$arg"
425
 
426
      # Aesthetically quote the previous argument.
427
 
428
      # Backslashify any backslashes, double quotes, and dollar signs.
429
      # These are the only characters that are still specially
430
      # interpreted inside of double-quoted scrings.
431
      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
432
 
433
      # Double-quote args containing other shell metacharacters.
434
      # Many Bourne shells cannot handle close brackets correctly
435
      # in scan sets, so we specify it separately.
436
      case $lastarg in
437
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
438
        lastarg="\"$lastarg\""
439
        ;;
440
      esac
441
 
442
      # Add the previous argument to base_compile.
443
      if test -z "$base_compile"; then
444
        base_compile="$lastarg"
445
      else
446
        base_compile="$base_compile $lastarg"
447
      fi
448
    done
449
 
450
    case $user_target in
451
    set)
452
      ;;
453
    no)
454
      # Get the name of the library object.
455
      libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
456
      ;;
457
    *)
458
      $echo "$modename: you must specify a target with \`-o'" 1>&2
459
      exit 1
460
      ;;
461
    esac
462
 
463
    # Recognize several different file suffixes.
464
    # If the user specifies -o file.o, it is replaced with file.lo
465
    xform='[cCFSfmso]'
466
    case $libobj in
467
    *.ada) xform=ada ;;
468
    *.adb) xform=adb ;;
469
    *.ads) xform=ads ;;
470
    *.asm) xform=asm ;;
471
    *.c++) xform=c++ ;;
472
    *.cc) xform=cc ;;
473
    *.class) xform=class ;;
474
    *.cpp) xform=cpp ;;
475
    *.cxx) xform=cxx ;;
476
    *.f90) xform=f90 ;;
477
    *.for) xform=for ;;
478
    *.java) xform=java ;;
479
    esac
480
 
481
    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
482
 
483
    case $libobj in
484
    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
485
    *)
486
      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
487
      exit 1
488
      ;;
489
    esac
490
 
491
    # Infer tagged configuration to use if any are available and
492
    # if one wasn't chosen via the "--tag" command line option.
493
    # Only attempt this if the compiler in the base compile
494
    # command doesn't match the default compiler.
495
    if test -n "$available_tags" && test -z "$tagname"; then
496
      case $base_compile in
497
      "$CC "*) ;;
498
      # Blanks in the command may have been stripped by the calling shell,
499
      # but not from the CC environment variable when ltconfig was run.
500
      "`$echo $CC` "*) ;;
501
      *)
502
        for z in $available_tags; do
503
          if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
504
            # Evaluate the configuration.
505
            eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
506
            case $base_compile in
507
            "$CC "*)
508
              # The compiler in the base compile command matches
509
              # the one in the tagged configuration.
510
              # Assume this is the tagged configuration we want.
511
              tagname=$z
512
              break
513
              ;;
514
            "`$echo $CC` "*)
515
              tagname=$z
516
              break
517
              ;;
518
            esac
519
          fi
520
        done
521
        # If $tagname still isn't set, then no tagged configuration
522
        # was found and let the user know that the "--tag" command
523
        # line option must be used.
524
        if test -z "$tagname"; then
525
          echo "$modename: unable to infer tagged configuration"
526
          echo "$modename: specify a tag with \`--tag'" 1>&2
527
          exit 1
528
#        else
529
#          echo "$modename: using $tagname tagged configuration"
530
        fi
531
        ;;
532
      esac
533
    fi
534
 
535
    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
536
    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
537
    if test "X$xdir" = "X$obj"; then
538
      xdir=
539
    else
540
      xdir=$xdir/
541
    fi
542
    lobj=${xdir}$objdir/$objname
543
 
544
    if test -z "$base_compile"; then
545
      $echo "$modename: you must specify a compilation command" 1>&2
546
      $echo "$help" 1>&2
547
      exit 1
548
    fi
549
 
550
    # Delete any leftover library objects.
551
    if test "$build_old_libs" = yes; then
552
      removelist="$obj $lobj $libobj ${libobj}T"
553
    else
554
      removelist="$lobj $libobj ${libobj}T"
555
    fi
556
 
557
    $run $rm $removelist
558
    trap "$run $rm $removelist; exit 1" 1 2 15
559
 
560
    # On Cygwin there's no "real" PIC flag so we must build both object types
561
    case $host_os in
562
    cygwin* | mingw* | pw32* | os2*)
563
      pic_mode=default
564
      ;;
565
    esac
566
    if test $pic_mode = no && test "$deplibs_check_method" != pass_all; then
567
      # non-PIC code in shared libraries is not supported
568
      pic_mode=default
569
    fi
570
 
571
    # Calculate the filename of the output object if compiler does
572
    # not support -o with -c
573
    if test "$compiler_c_o" = no; then
574
      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
575
      lockfile="$output_obj.lock"
576
      removelist="$removelist $output_obj $lockfile"
577
      trap "$run $rm $removelist; exit 1" 1 2 15
578
    else
579
      output_obj=
580
      need_locks=no
581
      lockfile=
582
    fi
583
 
584
    # Lock this critical section if it is needed
585
    # We use this script file to make the link, it avoids creating a new file
586
    if test "$need_locks" = yes; then
587
      until $run ln "$0" "$lockfile" 2>/dev/null; do
588
        $show "Waiting for $lockfile to be removed"
589
        sleep 2
590
      done
591
    elif test "$need_locks" = warn; then
592
      if test -f "$lockfile"; then
593
        echo "\
594
*** ERROR, $lockfile exists and contains:
595
`cat $lockfile 2>/dev/null`
596
 
597
This indicates that another process is trying to use the same
598
temporary object file, and libtool could not work around it because
599
your compiler does not support \`-c' and \`-o' together.  If you
600
repeat this compilation, it may succeed, by chance, but you had better
601
avoid parallel builds (make -j) in this platform, or get a better
602
compiler."
603
 
604
        $run $rm $removelist
605
        exit 1
606
      fi
607
      echo $srcfile > "$lockfile"
608
    fi
609
 
610
    if test -n "$fix_srcfile_path"; then
611
      eval srcfile=\"$fix_srcfile_path\"
612
    fi
613
 
614
    $run $rm "$libobj" "${libobj}T"
615
 
616
    # Create a libtool object file (analogous to a ".la" file),
617
    # but don't create it if we're doing a dry run.
618
    test -z "$run" && cat > ${libobj}T <<EOF
619
# $libobj - a libtool object file
620
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
621
#
622
# Please DO NOT delete this file!
623
# It is necessary for linking the library.
624
 
625
# Name of the PIC object.
626
EOF
627
 
628
    # Only build a PIC object if we are building libtool libraries.
629
    if test "$build_libtool_libs" = yes; then
630
      # Without this assignment, base_compile gets emptied.
631
      fbsd_hideous_sh_bug=$base_compile
632
 
633
      if test "$pic_mode" != no; then
634
        command="$base_compile $srcfile $pic_flag"
635
      else
636
        # Don't build PIC code
637
        command="$base_compile $srcfile"
638
      fi
639
 
640
      if test ! -d ${xdir}$objdir; then
641
        $show "$mkdir ${xdir}$objdir"
642
        $run $mkdir ${xdir}$objdir
643
        status=$?
644
        if test $status -ne 0 && test ! -d ${xdir}$objdir; then
645
          exit $status
646
        fi
647
      fi
648
 
649
      if test -z "$output_obj"; then
650
        # Place PIC objects in $objdir
651
        command="$command -o $lobj"
652
      fi
653
 
654
      $run $rm "$lobj" "$output_obj"
655
 
656
      $show "$command"
657
      if $run eval "$command"; then :
658
      else
659
        test -n "$output_obj" && $run $rm $removelist
660
        exit 1
661
      fi
662
 
663
      if test "$need_locks" = warn &&
664
         test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
665
        echo "\
666
*** ERROR, $lockfile contains:
667
`cat $lockfile 2>/dev/null`
668
 
669
but it should contain:
670
$srcfile
671
 
672
This indicates that another process is trying to use the same
673
temporary object file, and libtool could not work around it because
674
your compiler does not support \`-c' and \`-o' together.  If you
675
repeat this compilation, it may succeed, by chance, but you had better
676
avoid parallel builds (make -j) in this platform, or get a better
677
compiler."
678
 
679
        $run $rm $removelist
680
        exit 1
681
      fi
682
 
683
      # Just move the object if needed, then go on to compile the next one
684
      if test -n "$output_obj" && test "x$output_obj" != "x$lobj"; then
685
        $show "$mv $output_obj $lobj"
686
        if $run $mv $output_obj $lobj; then :
687
        else
688
          error=$?
689
          $run $rm $removelist
690
          exit $error
691
        fi
692
      fi
693
 
694
      # Append the name of the PIC object to the libtool object file.
695
      test -z "$run" && cat >> ${libobj}T <<EOF
696
pic_object='$objdir/$objname'
697
 
698
EOF
699
 
700
      # Allow error messages only from the first compilation.
701
      suppress_output=' >/dev/null 2>&1'
702
    else
703
      # No PIC object so indicate it doesn't exist in the libtool
704
      # object file.
705
      test -z "$run" && cat >> ${libobj}T <<EOF
706
pic_object=none
707
 
708
EOF
709
    fi
710
 
711
    # Only build a position-dependent object if we build old libraries.
712
    if test "$build_old_libs" = yes; then
713
      if test "$pic_mode" != yes; then
714
        # Don't build PIC code
715
        command="$base_compile $srcfile"
716
      else
717
        command="$base_compile $srcfile $pic_flag"
718
      fi
719
      if test "$compiler_c_o" = yes; then
720
        command="$command -o $obj"
721
      fi
722
 
723
      # Suppress compiler output if we already did a PIC compilation.
724
      command="$command$suppress_output"
725
      $run $rm "$obj" "$output_obj"
726
      $show "$command"
727
      if $run eval "$command"; then :
728
      else
729
        $run $rm $removelist
730
        exit 1
731
      fi
732
 
733
      if test "$need_locks" = warn &&
734
         test x"`cat $lockfile 2>/dev/null`" != x"$srcfile"; then
735
        echo "\
736
*** ERROR, $lockfile contains:
737
`cat $lockfile 2>/dev/null`
738
 
739
but it should contain:
740
$srcfile
741
 
742
This indicates that another process is trying to use the same
743
temporary object file, and libtool could not work around it because
744
your compiler does not support \`-c' and \`-o' together.  If you
745
repeat this compilation, it may succeed, by chance, but you had better
746
avoid parallel builds (make -j) in this platform, or get a better
747
compiler."
748
 
749
        $run $rm $removelist
750
        exit 1
751
      fi
752
 
753
      # Just move the object if needed
754
      if test -n "$output_obj" && test "x$output_obj" != "x$obj"; then
755
        $show "$mv $output_obj $obj"
756
        if $run $mv $output_obj $obj; then :
757
        else
758
          error=$?
759
          $run $rm $removelist
760
          exit $error
761
        fi
762
      fi
763
 
764
      # Append the name of the non-PIC object the libtool object file.
765
      # Only append if the libtool object file exists.
766
      test -z "$run" && cat >> ${libobj}T <<EOF
767
# Name of the non-PIC object.
768
non_pic_object='$objname'
769
 
770
EOF
771
    else
772
      # Append the name of the non-PIC object the libtool object file.
773
      # Only append if the libtool object file exists.
774
      test -z "$run" && cat >> ${libobj}T <<EOF
775
# Name of the non-PIC object.
776
non_pic_object=none
777
 
778
EOF
779
    fi
780
 
781
    $run $mv "${libobj}T" "${libobj}"
782
 
783
    # Unlock the critical section if it was locked
784
    if test "$need_locks" != no; then
785
      $run $rm "$lockfile"
786
    fi
787
 
788
    exit 0
789
    ;;
790
 
791
  # libtool link mode
792
  link | relink)
793
    modename="$modename: link"
794
    case $host in
795
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
796
      # It is impossible to link a dll without this setting, and
797
      # we shouldn't force the makefile maintainer to figure out
798
      # which system we are compiling for in order to pass an extra
799
      # flag for every libtool invokation.
800
      # allow_undefined=no
801
 
802
      # FIXME: Unfortunately, there are problems with the above when trying
803
      # to make a dll which has undefined symbols, in which case not
804
      # even a static library is built.  For now, we need to specify
805
      # -no-undefined on the libtool link line when we can be certain
806
      # that all symbols are satisfied, otherwise we get a static library.
807
      allow_undefined=yes
808
      ;;
809
    *)
810
      allow_undefined=yes
811
      ;;
812
    esac
813
    libtool_args="$nonopt"
814
    base_compile="$nonopt"
815
    compile_command="$nonopt"
816
    finalize_command="$nonopt"
817
 
818
    compile_rpath=
819
    finalize_rpath=
820
    compile_shlibpath=
821
    finalize_shlibpath=
822
    convenience=
823
    old_convenience=
824
    deplibs=
825
    old_deplibs=
826
    compiler_flags=
827
    linker_flags=
828
    dllsearchpath=
829
    lib_search_path=`pwd`
830
 
831
    avoid_version=no
832
    dlfiles=
833
    dlprefiles=
834
    dlself=no
835
    export_dynamic=no
836
    export_symbols=
837
    export_symbols_regex=
838
    generated=
839
    libobjs=
840
    ltlibs=
841
    module=no
842
    no_install=no
843
    objs=
844
    non_pic_objects=
845
    prefer_static_libs=no
846
    preload=no
847
    prev=
848
    prevarg=
849
    release=
850
    rpath=
851
    xrpath=
852
    perm_rpath=
853
    temp_rpath=
854
    thread_safe=no
855
    vinfo=
856
 
857
    # We need to know -static, to get the right output filenames.
858
    for arg
859
    do
860
      case $arg in
861
      -all-static | -static)
862
        if test "X$arg" = "X-all-static"; then
863
          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
864
            $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
865
          fi
866
          if test -n "$link_static_flag"; then
867
            dlopen_self=$dlopen_self_static
868
          fi
869
        else
870
          if test -z "$pic_flag" && test -n "$link_static_flag"; then
871
            dlopen_self=$dlopen_self_static
872
          fi
873
        fi
874
        build_libtool_libs=no
875
        build_old_libs=yes
876
        prefer_static_libs=yes
877
        break
878
        ;;
879
      esac
880
    done
881
 
882
    # See if our shared archives depend on static archives.
883
    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
884
 
885
    # Go through the arguments, transforming them on the way.
886
    while test $# -gt 0; do
887
      arg="$1"
888
      base_compile="$base_compile $arg"
889
      shift
890
      case $arg in
891
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
892
        qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
893
        ;;
894
      *) qarg=$arg ;;
895
      esac
896
      libtool_args="$libtool_args $qarg"
897
 
898
      # If the previous option needs an argument, assign it.
899
      if test -n "$prev"; then
900
        case $prev in
901
        output)
902
          compile_command="$compile_command @OUTPUT@"
903
          finalize_command="$finalize_command @OUTPUT@"
904
          ;;
905
        esac
906
 
907
        case $prev in
908
        dlfiles|dlprefiles)
909
          if test "$preload" = no; then
910
            # Add the symbol object into the linking commands.
911
            compile_command="$compile_command @SYMFILE@"
912
            finalize_command="$finalize_command @SYMFILE@"
913
            preload=yes
914
          fi
915
          case $arg in
916
          *.la | *.lo) ;;  # We handle these cases below.
917
          force)
918
            if test "$dlself" = no; then
919
              dlself=needless
920
              export_dynamic=yes
921
            fi
922
            prev=
923
            continue
924
            ;;
925
          self)
926
            if test "$prev" = dlprefiles; then
927
              dlself=yes
928
            elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
929
              dlself=yes
930
            else
931
              dlself=needless
932
              export_dynamic=yes
933
            fi
934
            prev=
935
            continue
936
            ;;
937
          *)
938
            if test "$prev" = dlfiles; then
939
              dlfiles="$dlfiles $arg"
940
            else
941
              dlprefiles="$dlprefiles $arg"
942
            fi
943
            prev=
944
            continue
945
            ;;
946
          esac
947
          ;;
948
        expsyms)
949
          export_symbols="$arg"
950
          if test ! -f "$arg"; then
951
            $echo "$modename: symbol file \`$arg' does not exist"
952
            exit 1
953
          fi
954
          prev=
955
          continue
956
          ;;
957
        expsyms_regex)
958
          export_symbols_regex="$arg"
959
          prev=
960
          continue
961
          ;;
962
        release)
963
          release="-$arg"
964
          prev=
965
          continue
966
          ;;
967
        objectlist)
968
          if test -f "$arg"; then
969
            save_arg=$arg
970
            moreargs=
971
            for fil in `cat $save_arg`
972
            do
973
#             moreargs="$moreargs $fil"
974
              arg=$fil
975
              # A libtool-controlled object.
976
 
977
              # Check to see that this really is a libtool object.
978
              if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
979
                pic_object=
980
                non_pic_object=
981
 
982
                # Read the .lo file
983
                # If there is no directory component, then add one.
984
                case $arg in
985
                */* | *\\*) . $arg ;;
986
                *) . ./$arg ;;
987
                esac
988
 
989
                if test -z "$pic_object" || \
990
                   test -z "$non_pic_object" ||
991
                   test "$pic_object" = none && \
992
                   test "$non_pic_object" = none; then
993
                  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
994
                  exit 1
995
                fi
996
 
997
                # Extract subdirectory from the argument.
998
                xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
999
                if test "X$xdir" = "X$arg"; then
1000
                  xdir=
1001
                else
1002
                  xdir="$xdir/"
1003
                fi
1004
 
1005
                if test "$pic_object" != none; then
1006
                  # Prepend the subdirectory the object is found in.
1007
                  pic_object="$xdir$pic_object"
1008
 
1009
                  if test "$prev" = dlfiles; then
1010
                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1011
                      dlfiles="$dlfiles $pic_object"
1012
                      prev=
1013
                      continue
1014
                    else
1015
                      # If libtool objects are unsupported, then we need to preload.
1016
                      prev=dlprefiles
1017
                    fi
1018
                  fi
1019
 
1020
                  # CHECK ME:  I think I busted this.  -Ossama
1021
                  if test "$prev" = dlprefiles; then
1022
                    # Preload the old-style object.
1023
                    dlprefiles="$dlprefiles $pic_object"
1024
                    prev=
1025
                  fi
1026
 
1027
                  # A PIC object.
1028
                  libobjs="$libobjs $pic_object"
1029
                  arg="$pic_object"
1030
                fi
1031
 
1032
                # Non-PIC object.
1033
                if test "$non_pic_object" != none; then
1034
                  # Prepend the subdirectory the object is found in.
1035
                  non_pic_object="$xdir$non_pic_object"
1036
 
1037
                  # A standard non-PIC object
1038
                  non_pic_objects="$non_pic_objects $non_pic_object"
1039
                  if test -z "$pic_object" || test "$pic_object" = none ; then
1040
                    arg="$non_pic_object"
1041
                  fi
1042
                fi
1043
              else
1044
                # Only an error if not doing a dry-run.
1045
                if test -z "$run"; then
1046
                  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1047
                  exit 1
1048
                else
1049
                  # Dry-run case.
1050
 
1051
                  # Extract subdirectory from the argument.
1052
                  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1053
                  if test "X$xdir" = "X$arg"; then
1054
                    xdir=
1055
                  else
1056
                    xdir="$xdir/"
1057
                  fi
1058
 
1059
                  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1060
                  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1061
                  libobjs="$libobjs $pic_object"
1062
                  non_pic_objects="$non_pic_objects $non_pic_object"
1063
                fi
1064
              fi
1065
            done
1066
          else
1067
            $echo "$modename: link input file \`$save_arg' does not exist"
1068
            exit 1
1069
          fi
1070
          arg=$save_arg
1071
          prev=
1072
          continue
1073
          ;;
1074
        rpath | xrpath)
1075
          # We need an absolute path.
1076
          case $arg in
1077
          [\\/]* | [A-Za-z]:[\\/]*) ;;
1078
          *)
1079
            $echo "$modename: only absolute run-paths are allowed" 1>&2
1080
            exit 1
1081
            ;;
1082
          esac
1083
          if test "$prev" = rpath; then
1084
            case "$rpath " in
1085
            *" $arg "*) ;;
1086
            *) rpath="$rpath $arg" ;;
1087
            esac
1088
          else
1089
            case "$xrpath " in
1090
            *" $arg "*) ;;
1091
            *) xrpath="$xrpath $arg" ;;
1092
            esac
1093
          fi
1094
          prev=
1095
          continue
1096
          ;;
1097
        xcompiler)
1098
          compiler_flags="$compiler_flags $qarg"
1099
          prev=
1100
          compile_command="$compile_command $qarg"
1101
          finalize_command="$finalize_command $qarg"
1102
          continue
1103
          ;;
1104
        xlinker)
1105
          linker_flags="$linker_flags $qarg"
1106
          compiler_flags="$compiler_flags $wl$qarg"
1107
          prev=
1108
          compile_command="$compile_command $wl$qarg"
1109
          finalize_command="$finalize_command $wl$qarg"
1110
          continue
1111
          ;;
1112
        *)
1113
          eval "$prev=\"\$arg\""
1114
          prev=
1115
          continue
1116
          ;;
1117
        esac
1118
      fi # test -n $prev
1119
 
1120
      prevarg="$arg"
1121
 
1122
      case $arg in
1123
      -all-static)
1124
        if test -n "$link_static_flag"; then
1125
          compile_command="$compile_command $link_static_flag"
1126
          finalize_command="$finalize_command $link_static_flag"
1127
        fi
1128
        continue
1129
        ;;
1130
 
1131
      -allow-undefined)
1132
        # FIXME: remove this flag sometime in the future.
1133
        $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1134
        continue
1135
        ;;
1136
 
1137
      -avoid-version)
1138
        avoid_version=yes
1139
        continue
1140
        ;;
1141
 
1142
      -dlopen)
1143
        prev=dlfiles
1144
        continue
1145
        ;;
1146
 
1147
      -dlpreopen)
1148
        prev=dlprefiles
1149
        continue
1150
        ;;
1151
 
1152
      -export-dynamic)
1153
        export_dynamic=yes
1154
        continue
1155
        ;;
1156
 
1157
      -export-symbols | -export-symbols-regex)
1158
        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
1159
          $echo "$modename: more than one -exported-symbols argument is not allowed"
1160
          exit 1
1161
        fi
1162
        if test "X$arg" = "X-export-symbols"; then
1163
          prev=expsyms
1164
        else
1165
          prev=expsyms_regex
1166
        fi
1167
        continue
1168
        ;;
1169
 
1170
      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1171
      # so, if we see these flags be careful not to treat them like -L
1172
      -L[A-Z][A-Z]*:*)
1173
        case $with_gcc/$host in
1174
        no/*-*-irix*)
1175
          compile_command="$compile_command $arg"
1176
          finalize_command="$finalize_command $arg"
1177
          ;;
1178
        esac
1179
        continue
1180
        ;;
1181
 
1182
      -L*)
1183
        dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1184
        # We need an absolute path.
1185
        case $dir in
1186
        [\\/]* | [A-Za-z]:[\\/]*) ;;
1187
        *)
1188
          absdir=`cd "$dir" && pwd`
1189
          if test -z "$absdir"; then
1190
            $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1191
            exit 1
1192
          fi
1193
          dir="$absdir"
1194
          ;;
1195
        esac
1196
        case "$deplibs " in
1197
        *" -L$dir "*) ;;
1198
        *)
1199
          deplibs="$deplibs -L$dir"
1200
          lib_search_path="$lib_search_path $dir"
1201
          ;;
1202
        esac
1203
        case $host in
1204
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1205
          case :$dllsearchpath: in
1206
          *":$dir:"*) ;;
1207
          *) dllsearchpath="$dllsearchpath:$dir";;
1208
          esac
1209
          ;;
1210
        esac
1211
        continue
1212
        ;;
1213
 
1214
      -l*)
1215
        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
1216
          case $host in
1217
          *-*-cygwin* | *-*-pw32* | *-*-beos*)
1218
            # These systems don't actually have a C or math library (as such)
1219
            continue
1220
            ;;
1221
          *-*-mingw* | *-*-os2*)
1222
            # These systems don't actually have a C library (as such)
1223
            test "X$arg" = "X-lc" && continue
1224
            ;;
1225
          esac
1226
        fi
1227
        deplibs="$deplibs $arg"
1228
        continue
1229
        ;;
1230
 
1231
      -module)
1232
        module=yes
1233
        continue
1234
        ;;
1235
 
1236
      -no-fast-install)
1237
        fast_install=no
1238
        continue
1239
        ;;
1240
 
1241
      -no-install)
1242
        case $host in
1243
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1244
          # The PATH hackery in wrapper scripts is required on Windows
1245
          # in order for the loader to find any dlls it needs.
1246
          $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1247
          $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1248
          fast_install=no
1249
          ;;
1250
        *) no_install=yes ;;
1251
        esac
1252
        continue
1253
        ;;
1254
 
1255
      -no-undefined)
1256
        allow_undefined=no
1257
        continue
1258
        ;;
1259
 
1260
      -objectlist)
1261
        prev=objectlist
1262
        continue
1263
        ;;
1264
 
1265
      -o) prev=output ;;
1266
 
1267
      -release)
1268
        prev=release
1269
        continue
1270
        ;;
1271
 
1272
      -rpath)
1273
        prev=rpath
1274
        continue
1275
        ;;
1276
 
1277
      -R)
1278
        prev=xrpath
1279
        continue
1280
        ;;
1281
 
1282
      -R*)
1283
        dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1284
        # We need an absolute path.
1285
        case $dir in
1286
        [\\/]* | [A-Za-z]:[\\/]*) ;;
1287
        *)
1288
          $echo "$modename: only absolute run-paths are allowed" 1>&2
1289
          exit 1
1290
          ;;
1291
        esac
1292
        case "$xrpath " in
1293
        *" $dir "*) ;;
1294
        *) xrpath="$xrpath $dir" ;;
1295
        esac
1296
        continue
1297
        ;;
1298
 
1299
      -static)
1300
        # The effects of -static are defined in a previous loop.
1301
        # We used to do the same as -all-static on platforms that
1302
        # didn't have a PIC flag, but the assumption that the effects
1303
        # would be equivalent was wrong.  It would break on at least
1304
        # Digital Unix and AIX.
1305
        continue
1306
        ;;
1307
 
1308
      -thread-safe)
1309
        thread_safe=yes
1310
        continue
1311
        ;;
1312
 
1313
      -version-info)
1314
        prev=vinfo
1315
        continue
1316
        ;;
1317
 
1318
      -Wc,*)
1319
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1320
        arg=
1321
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1322
        for flag in $args; do
1323
          IFS="$save_ifs"
1324
          case $flag in
1325
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1326
            flag="\"$flag\""
1327
            ;;
1328
          esac
1329
          arg="$arg $wl$flag"
1330
          compiler_flags="$compiler_flags $flag"
1331
        done
1332
        IFS="$save_ifs"
1333
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1334
        ;;
1335
 
1336
      -Wl,*)
1337
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1338
        arg=
1339
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=','
1340
        for flag in $args; do
1341
          IFS="$save_ifs"
1342
          case $flag in
1343
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1344
            flag="\"$flag\""
1345
            ;;
1346
          esac
1347
          arg="$arg $wl$flag"
1348
          compiler_flags="$compiler_flags $wl$flag"
1349
          linker_flags="$linker_flags $flag"
1350
        done
1351
        IFS="$save_ifs"
1352
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1353
        ;;
1354
 
1355
      -Xcompiler)
1356
        prev=xcompiler
1357
        continue
1358
        ;;
1359
 
1360
      -Xlinker)
1361
        prev=xlinker
1362
        continue
1363
        ;;
1364
 
1365
      # Some other compiler flag.
1366
      -* | +*)
1367
        # Unknown arguments in both finalize_command and compile_command need
1368
        # to be aesthetically quoted because they are evaled later.
1369
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1370
        case $arg in
1371
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1372
          arg="\"$arg\""
1373
          ;;
1374
        esac
1375
        ;;
1376
 
1377
      *.$objext)
1378
        # A standard object.
1379
        objs="$objs $arg"
1380
        ;;
1381
 
1382
      *.lo)
1383
        # A libtool-controlled object.
1384
 
1385
        # Check to see that this really is a libtool object.
1386
        if (sed -e '2q' $arg | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1387
          pic_object=
1388
          non_pic_object=
1389
 
1390
          # Read the .lo file
1391
          # If there is no directory component, then add one.
1392
          case $arg in
1393
          */* | *\\*) . $arg ;;
1394
          *) . ./$arg ;;
1395
          esac
1396
 
1397
          if test -z "$pic_object" || \
1398
             test -z "$non_pic_object" ||
1399
             test "$pic_object" = none && \
1400
             test "$non_pic_object" = none; then
1401
            $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1402
            exit 1
1403
          fi
1404
 
1405
          # Extract subdirectory from the argument.
1406
          xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1407
          if test "X$xdir" = "X$arg"; then
1408
            xdir=
1409
          else
1410
            xdir="$xdir/"
1411
          fi
1412
 
1413
          if test "$pic_object" != none; then
1414
            # Prepend the subdirectory the object is found in.
1415
            pic_object="$xdir$pic_object"
1416
 
1417
            if test "$prev" = dlfiles; then
1418
              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1419
                dlfiles="$dlfiles $pic_object"
1420
                prev=
1421
                continue
1422
              else
1423
                # If libtool objects are unsupported, then we need to preload.
1424
                prev=dlprefiles
1425
              fi
1426
            fi
1427
 
1428
            # CHECK ME:  I think I busted this.  -Ossama
1429
            if test "$prev" = dlprefiles; then
1430
              # Preload the old-style object.
1431
              dlprefiles="$dlprefiles $pic_object"
1432
              prev=
1433
            fi
1434
 
1435
            # A PIC object.
1436
            libobjs="$libobjs $pic_object"
1437
            arg="$pic_object"
1438
          fi
1439
 
1440
          # Non-PIC object.
1441
          if test "$non_pic_object" != none; then
1442
            # Prepend the subdirectory the object is found in.
1443
            non_pic_object="$xdir$non_pic_object"
1444
 
1445
            # A standard non-PIC object
1446
            non_pic_objects="$non_pic_objects $non_pic_object"
1447
            if test -z "$pic_object" || test "$pic_object" = none ; then
1448
              arg="$non_pic_object"
1449
            fi
1450
          fi
1451
        else
1452
          # Only an error if not doing a dry-run.
1453
          if test -z "$run"; then
1454
            $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1455
            exit 1
1456
          else
1457
            # Dry-run case.
1458
 
1459
            # Extract subdirectory from the argument.
1460
            xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1461
            if test "X$xdir" = "X$arg"; then
1462
              xdir=
1463
            else
1464
              xdir="$xdir/"
1465
            fi
1466
 
1467
            pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1468
            non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1469
            libobjs="$libobjs $pic_object"
1470
            non_pic_objects="$non_pic_objects $non_pic_object"
1471
          fi
1472
        fi
1473
        ;;
1474
 
1475
      *.$libext)
1476
        # An archive.
1477
        deplibs="$deplibs $arg"
1478
        old_deplibs="$old_deplibs $arg"
1479
        continue
1480
        ;;
1481
 
1482
      *.la)
1483
        # A libtool-controlled library.
1484
 
1485
        if test "$prev" = dlfiles; then
1486
          # This library was specified with -dlopen.
1487
          dlfiles="$dlfiles $arg"
1488
          prev=
1489
        elif test "$prev" = dlprefiles; then
1490
          # The library was specified with -dlpreopen.
1491
          dlprefiles="$dlprefiles $arg"
1492
          prev=
1493
        else
1494
          deplibs="$deplibs $arg"
1495
        fi
1496
        continue
1497
        ;;
1498
 
1499
      # Some other compiler argument.
1500
      *)
1501
        # Unknown arguments in both finalize_command and compile_command need
1502
        # to be aesthetically quoted because they are evaled later.
1503
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1504
        case $arg in
1505
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1506
          arg="\"$arg\""
1507
          ;;
1508
        esac
1509
        ;;
1510
      esac # arg
1511
 
1512
      # Now actually substitute the argument into the commands.
1513
      if test -n "$arg"; then
1514
        compile_command="$compile_command $arg"
1515
        finalize_command="$finalize_command $arg"
1516
      fi
1517
    done # argument parsing loop
1518
 
1519
    if test -n "$prev"; then
1520
      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1521
      $echo "$help" 1>&2
1522
      exit 1
1523
    fi
1524
 
1525
    # Infer tagged configuration to use if any are available and
1526
    # if one wasn't chosen via the "--tag" command line option.
1527
    # Only attempt this if the compiler in the base link
1528
    # command doesn't match the default compiler.
1529
    if test -n "$available_tags" && test -z "$tagname"; then
1530
      case $base_compile in
1531
      "$CC "*) ;;
1532
      # Blanks in the command may have been stripped by the calling shell,
1533
      # but not from the CC environment variable when ltconfig was run.
1534
      "`$echo $CC` "*) ;;
1535
      *)
1536
        for z in $available_tags; do
1537
          if grep "^### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
1538
            # Evaluate the configuration.
1539
            eval "`sed -n -e '/^### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
1540
            case $base_compile in
1541
            "$CC "*)
1542
              # The compiler in $compile_command matches
1543
              # the one in the tagged configuration.
1544
              # Assume this is the tagged configuration we want.
1545
              tagname=$z
1546
              break
1547
              ;;
1548
            "`$echo $CC` "*)
1549
              tagname=$z
1550
              break
1551
              ;;
1552
            esac
1553
          fi
1554
        done
1555
        # If $tagname still isn't set, then no tagged configuration
1556
        # was found and let the user know that the "--tag" command
1557
        # line option must be used.
1558
        if test -z "$tagname"; then
1559
          echo "$modename: unable to infer tagged configuration"
1560
          echo "$modename: specify a tag with \`--tag'" 1>&2
1561
          exit 1
1562
#       else
1563
#         echo "$modename: using $tagname tagged configuration"
1564
        fi
1565
        ;;
1566
      esac
1567
    fi
1568
 
1569
    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1570
      eval arg=\"$export_dynamic_flag_spec\"
1571
      compile_command="$compile_command $arg"
1572
      finalize_command="$finalize_command $arg"
1573
    fi
1574
 
1575
    # calculate the name of the file, without its directory
1576
    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1577
    libobjs_save="$libobjs"
1578
 
1579
    if test -n "$shlibpath_var"; then
1580
      # get the directories listed in $shlibpath_var
1581
      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1582
    else
1583
      shlib_search_path=
1584
    fi
1585
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1586
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1587
 
1588
    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1589
    if test "X$output_objdir" = "X$output"; then
1590
      output_objdir="$objdir"
1591
    else
1592
      output_objdir="$output_objdir/$objdir"
1593
    fi
1594
    # Create the object directory.
1595
    if test ! -d $output_objdir; then
1596
      $show "$mkdir $output_objdir"
1597
      $run $mkdir $output_objdir
1598
      status=$?
1599
      if test $status -ne 0 && test ! -d $output_objdir; then
1600
        exit $status
1601
      fi
1602
    fi
1603
 
1604
    # Determine the type of output
1605
    case $output in
1606
    "")
1607
      $echo "$modename: you must specify an output file" 1>&2
1608
      $echo "$help" 1>&2
1609
      exit 1
1610
      ;;
1611
    *.$libext) linkmode=oldlib ;;
1612
    *.lo | *.$objext) linkmode=obj ;;
1613
    *.la) linkmode=lib ;;
1614
    *) linkmode=prog ;; # Anything else should be a program.
1615
    esac
1616
 
1617
    specialdeplibs=
1618
    libs=
1619
    # Find all interdependent deplibs by searching for libraries
1620
    # that are linked more than once (e.g. -la -lb -la)
1621
    for deplib in $deplibs; do
1622
      case "$libs " in
1623
      *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1624
      esac
1625
      libs="$libs $deplib"
1626
    done
1627
 
1628
    if test $linkmode = lib; then
1629
      libs="$predeps $libs $compiler_lib_search_path $postdeps"
1630
 
1631
      # Compute libraries that are listed more than once in $predeps
1632
      # $postdeps and mark them as special (i.e., whose duplicates are
1633
      # not to be eliminated).
1634
      pre_post_deps=
1635
      for pre_post_dep in $predeps $postdeps; do
1636
        case "$pre_post_deps " in
1637
        *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1638
        esac
1639
        pre_post_deps="$pre_post_deps $pre_post_dep"
1640
      done
1641
      pre_post_deps=
1642
    fi
1643
 
1644
    deplibs=
1645
    newdependency_libs=
1646
    newlib_search_path=
1647
    need_relink=no # whether we're linking any uninstalled libtool libraries
1648
    notinst_deplibs= # not-installed libtool libraries
1649
    notinst_path= # paths that contain not-installed libtool libraries
1650
    case $linkmode in
1651
    lib)
1652
        passes="conv link"
1653
        for file in $dlfiles $dlprefiles; do
1654
          case $file in
1655
          *.la) ;;
1656
          *)
1657
            $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1658
            exit 1
1659
            ;;
1660
          esac
1661
        done
1662
        ;;
1663
    prog)
1664
        compile_deplibs=
1665
        finalize_deplibs=
1666
        alldeplibs=no
1667
        newdlfiles=
1668
        newdlprefiles=
1669
        passes="conv scan dlopen dlpreopen link"
1670
        ;;
1671
    *)  passes="conv"
1672
        ;;
1673
    esac
1674
    for pass in $passes; do
1675
      if test $linkmode = prog; then
1676
        # Determine which files to process
1677
        case $pass in
1678
        dlopen)
1679
          libs="$dlfiles"
1680
          save_deplibs="$deplibs" # Collect dlpreopened libraries
1681
          deplibs=
1682
          ;;
1683
        dlpreopen) libs="$dlprefiles" ;;
1684
        link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1685
        esac
1686
      fi
1687
      for deplib in $libs; do
1688
        lib=
1689
        found=no
1690
        case $deplib in
1691
        -l*)
1692
          if test $linkmode = oldlib && test $linkmode = obj; then
1693
            $echo "$modename: warning: \`-l' is ignored for archives/objects: $deplib" 1>&2
1694
            continue
1695
          fi
1696
          if test $pass = conv; then
1697
            deplibs="$deplib $deplibs"
1698
            continue
1699
          fi
1700
          name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1701
          for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
1702
            # Search the libtool library
1703
            lib="$searchdir/lib${name}.la"
1704
            if test -f "$lib"; then
1705
              found=yes
1706
              break
1707
            fi
1708
          done
1709
          if test "$found" != yes; then
1710
            # deplib doesn't seem to be a libtool library
1711
            if test "$linkmode,$pass" = "prog,link"; then
1712
              compile_deplibs="$deplib $compile_deplibs"
1713
              finalize_deplibs="$deplib $finalize_deplibs"
1714
            else
1715
              deplibs="$deplib $deplibs"
1716
              test $linkmode = lib && newdependency_libs="$deplib $newdependency_libs"
1717
            fi
1718
            continue
1719
          fi
1720
          ;; # -l
1721
        -L*)
1722
          case $linkmode in
1723
          lib)
1724
            deplibs="$deplib $deplibs"
1725
            test $pass = conv && continue
1726
            newdependency_libs="$deplib $newdependency_libs"
1727
            newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1728
            ;;
1729
          prog)
1730
            if test $pass = conv; then
1731
              deplibs="$deplib $deplibs"
1732
              continue
1733
            fi
1734
            if test $pass = scan; then
1735
              deplibs="$deplib $deplibs"
1736
              newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1737
            else
1738
              compile_deplibs="$deplib $compile_deplibs"
1739
              finalize_deplibs="$deplib $finalize_deplibs"
1740
            fi
1741
            ;;
1742
          *)
1743
            $echo "$modename: warning: \`-L' is ignored for archives/objects: $deplib" 1>&2
1744
            ;;
1745
          esac # linkmode
1746
          continue
1747
          ;; # -L
1748
        -R*)
1749
          if test $pass = link; then
1750
            dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1751
            # Make sure the xrpath contains only unique directories.
1752
            case "$xrpath " in
1753
            *" $dir "*) ;;
1754
            *) xrpath="$xrpath $dir" ;;
1755
            esac
1756
          fi
1757
          deplibs="$deplib $deplibs"
1758
          continue
1759
          ;;
1760
        *.la) lib="$deplib" ;;
1761
        *.$libext)
1762
          if test $pass = conv; then
1763
            deplibs="$deplib $deplibs"
1764
            continue
1765
          fi
1766
          case $linkmode in
1767
          lib)
1768
            if test "$deplibs_check_method" != pass_all; then
1769
              echo
1770
              echo "*** Warning: This library needs some functionality provided by $deplib."
1771
              echo "*** I have the capability to make that library automatically link in when"
1772
              echo "*** you link to this library.  But I can only do this if you have a"
1773
              echo "*** shared version of the library, which you do not appear to have."
1774
            else
1775
              echo
1776
              echo "*** Warning: Linking the shared library $output against the"
1777
              echo "*** static library $deplib is not portable!"
1778
              deplibs="$deplib $deplibs"
1779
            fi
1780
            continue
1781
            ;;
1782
          prog)
1783
            if test $pass != link; then
1784
              deplibs="$deplib $deplibs"
1785
            else
1786
              compile_deplibs="$deplib $compile_deplibs"
1787
              finalize_deplibs="$deplib $finalize_deplibs"
1788
            fi
1789
            continue
1790
            ;;
1791
          esac # linkmode
1792
          ;; # *.$libext
1793
        *.lo | *.$objext)
1794
          if test $pass = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1795
            # If there is no dlopen support or we're linking statically,
1796
            # we need to preload.
1797
            newdlprefiles="$newdlprefiles $deplib"
1798
            compile_deplibs="$deplib $compile_deplibs"
1799
            finalize_deplibs="$deplib $finalize_deplibs"
1800
          else
1801
            newdlfiles="$newdlfiles $deplib"
1802
          fi
1803
          continue
1804
          ;;
1805
        %DEPLIBS%)
1806
          alldeplibs=yes
1807
          continue
1808
          ;;
1809
        esac # case $deplib
1810
        if test $found = yes || test -f "$lib"; then :
1811
        else
1812
          $echo "$modename: cannot find the library \`$lib'" 1>&2
1813
          exit 1
1814
        fi
1815
 
1816
        # Check to see that this really is a libtool archive.
1817
        if (sed -e '2q' $lib | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
1818
        else
1819
          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
1820
          exit 1
1821
        fi
1822
 
1823
        ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1824
        test "X$ladir" = "X$lib" && ladir="."
1825
 
1826
        dlname=
1827
        dlopen=
1828
        dlpreopen=
1829
        libdir=
1830
        library_names=
1831
        old_library=
1832
        # If the library was installed with an old release of libtool,
1833
        # it will not redefine variable installed.
1834
        installed=yes
1835
 
1836
        # Read the .la file
1837
        case $lib in
1838
        */* | *\\*) . $lib ;;
1839
        *) . ./$lib ;;
1840
        esac
1841
 
1842
        if test "$linkmode,$pass" = "lib,link" ||
1843
           test "$linkmode,$pass" = "prog,scan" ||
1844
           { test $linkmode = oldlib && test $linkmode = obj; }; then
1845
           # Add dl[pre]opened files of deplib
1846
          test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
1847
          test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
1848
        fi
1849
 
1850
        if test $pass = conv; then
1851
          # Only check for convenience libraries
1852
          deplibs="$lib $deplibs"
1853
          if test -z "$libdir"; then
1854
            if test -z "$old_library"; then
1855
              $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1856
              exit 1
1857
            fi
1858
            # It is a libtool convenience library, so add in its objects.
1859
            convenience="$convenience $ladir/$objdir/$old_library"
1860
            old_convenience="$old_convenience $ladir/$objdir/$old_library"
1861
            tmp_libs=
1862
            for deplib in $dependency_libs; do
1863
              deplibs="$deplib $deplibs"
1864
              case "$tmp_libs " in
1865
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1866
              esac
1867
              tmp_libs="$tmp_libs $deplib"
1868
            done
1869
          elif test $linkmode != prog && test $linkmode != lib; then
1870
            $echo "$modename: \`$lib' is not a convenience library" 1>&2
1871
            exit 1
1872
          fi
1873
          continue
1874
        fi # $pass = conv
1875
 
1876
        # Get the name of the library we link against.
1877
        linklib=
1878
        for l in $old_library $library_names; do
1879
          linklib="$l"
1880
        done
1881
        if test -z "$linklib"; then
1882
          $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
1883
          exit 1
1884
        fi
1885
 
1886
        # This library was specified with -dlopen.
1887
        if test $pass = dlopen; then
1888
          if test -z "$libdir"; then
1889
            $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
1890
            exit 1
1891
          fi
1892
          if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
1893
            # If there is no dlname, no dlopen support or we're linking
1894
            # statically, we need to preload.
1895
            dlprefiles="$dlprefiles $lib"
1896
          else
1897
            newdlfiles="$newdlfiles $lib"
1898
          fi
1899
          continue
1900
        fi # $pass = dlopen
1901
 
1902
        # We need an absolute path.
1903
        case $ladir in
1904
        [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
1905
        *)
1906
          abs_ladir=`cd "$ladir" && pwd`
1907
          if test -z "$abs_ladir"; then
1908
            $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
1909
            $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
1910
            abs_ladir="$ladir"
1911
          fi
1912
          ;;
1913
        esac
1914
        laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
1915
 
1916
        # Find the relevant object directory and library name.
1917
        if test "X$installed" = Xyes; then
1918
          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
1919
            $echo "$modename: warning: library \`$lib' was moved." 1>&2
1920
            dir="$ladir"
1921
            absdir="$abs_ladir"
1922
            libdir="$abs_ladir"
1923
          else
1924
            dir="$libdir"
1925
            absdir="$libdir"
1926
          fi
1927
        else
1928
          dir="$ladir/$objdir"
1929
          absdir="$abs_ladir/$objdir"
1930
          # Remove this search path later
1931
          notinst_path="$notinst_path $abs_ladir"
1932
        fi # $installed = yes
1933
        name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
1934
 
1935
        # This library was specified with -dlpreopen.
1936
        if test $pass = dlpreopen; then
1937
          if test -z "$libdir"; then
1938
            $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
1939
            exit 1
1940
          fi
1941
          # Prefer using a static library (so that no silly _DYNAMIC symbols
1942
          # are required to link).
1943
          if test -n "$old_library"; then
1944
            newdlprefiles="$newdlprefiles $dir/$old_library"
1945
          # Otherwise, use the dlname, so that lt_dlopen finds it.
1946
          elif test -n "$dlname"; then
1947
            newdlprefiles="$newdlprefiles $dir/$dlname"
1948
          else
1949
            newdlprefiles="$newdlprefiles $dir/$linklib"
1950
          fi
1951
        fi # $pass = dlpreopen
1952
 
1953
        if test -z "$libdir"; then
1954
          # Link the convenience library
1955
          if test $linkmode = lib; then
1956
            deplibs="$dir/$old_library $deplibs"
1957
          elif test "$linkmode,$pass" = "prog,link"; then
1958
            compile_deplibs="$dir/$old_library $compile_deplibs"
1959
            finalize_deplibs="$dir/$old_library $finalize_deplibs"
1960
          else
1961
            deplibs="$lib $deplibs"
1962
          fi
1963
          continue
1964
        fi
1965
 
1966
        if test $linkmode = prog && test $pass != link; then
1967
          newlib_search_path="$newlib_search_path $ladir"
1968
          deplibs="$lib $deplibs"
1969
 
1970
          linkalldeplibs=no
1971
          if test "$link_all_deplibs" != no || test -z "$library_names" ||
1972
             test "$build_libtool_libs" = no; then
1973
            linkalldeplibs=yes
1974
          fi
1975
 
1976
          tmp_libs=
1977
          for deplib in $dependency_libs; do
1978
            case $deplib in
1979
            -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
1980
            esac
1981
            # Need to link against all dependency_libs?
1982
            if test $linkalldeplibs = yes; then
1983
              deplibs="$deplib $deplibs"
1984
            else
1985
              # Need to hardcode shared library paths
1986
              # or/and link against static libraries
1987
              newdependency_libs="$deplib $newdependency_libs"
1988
            fi
1989
            case "$tmp_libs " in
1990
            *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1991
            esac
1992
            tmp_libs="$tmp_libs $deplib"
1993
          done # for deplib
1994
          continue
1995
        fi # $linkmode = prog...
1996
 
1997
        link_static=no # Whether the deplib will be linked statically
1998
        if test -n "$library_names" &&
1999
           { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2000
          # Link against this shared library
2001
 
2002
          if test "$linkmode,$pass" = "prog,link" ||
2003
           { test $linkmode = lib && test $hardcode_into_libs = yes; }; then
2004
            # Hardcode the library path.
2005
            # Skip directories that are in the system default run-time
2006
            # search path.
2007
            case " $sys_lib_dlsearch_path " in
2008
            *" $absdir "*) ;;
2009
            *)
2010
              case "$compile_rpath " in
2011
              *" $absdir "*) ;;
2012
              *) compile_rpath="$compile_rpath $absdir"
2013
              esac
2014
              ;;
2015
            esac
2016
            case " $sys_lib_dlsearch_path " in
2017
            *" $libdir "*) ;;
2018
            *)
2019
              case "$finalize_rpath " in
2020
              *" $libdir "*) ;;
2021
              *) finalize_rpath="$finalize_rpath $libdir"
2022
              esac
2023
              ;;
2024
            esac
2025
            if test $linkmode = prog; then
2026
              # We need to hardcode the library path
2027
              if test -n "$shlibpath_var"; then
2028
                # Make sure the rpath contains only unique directories.
2029
                case "$temp_rpath " in
2030
                *" $dir "*) ;;
2031
                *" $absdir "*) ;;
2032
                *) temp_rpath="$temp_rpath $dir" ;;
2033
                esac
2034
              fi
2035
            fi
2036
          fi # $linkmode,$pass = prog,link...
2037
 
2038
          if test "$alldeplibs" = yes &&
2039
             { test "$deplibs_check_method" = pass_all ||
2040
               { test "$build_libtool_libs" = yes &&
2041
                 test -n "$library_names"; }; }; then
2042
            # We only need to search for static libraries
2043
            continue
2044
          fi
2045
 
2046
          if test "$installed" = no; then
2047
            notinst_deplibs="$notinst_deplibs $lib"
2048
            need_relink=yes
2049
          fi
2050
 
2051
          if test -n "$old_archive_from_expsyms_cmds"; then
2052
            # figure out the soname
2053
            set dummy $library_names
2054
            realname="$2"
2055
            shift; shift
2056
            libname=`eval \\$echo \"$libname_spec\"`
2057
            # use dlname if we got it. it's perfectly good, no?
2058
            if test -n "$dlname"; then
2059
              soname="$dlname"
2060
            elif test -n "$soname_spec"; then
2061
              # bleh windows
2062
              case $host in
2063
              *cygwin*)
2064
                major=`expr $current - $age`
2065
                versuffix="-$major"
2066
                ;;
2067
              esac
2068
              eval soname=\"$soname_spec\"
2069
            else
2070
              soname="$realname"
2071
            fi
2072
 
2073
            # Make a new name for the extract_expsyms_cmds to use
2074
            soroot="$soname"
2075
            soname=`echo $soroot | sed -e 's/^.*\///'`
2076
            newlib="libimp-`echo $soname | sed 's/^lib//;s/\.dll$//'`.a"
2077
 
2078
            # If the library has no export list, then create one now
2079
            if test -f "$output_objdir/$soname-def"; then :
2080
            else
2081
              $show "extracting exported symbol list from \`$soname'"
2082
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2083
              eval cmds=\"$extract_expsyms_cmds\"
2084
              for cmd in $cmds; do
2085
                IFS="$save_ifs"
2086
                $show "$cmd"
2087
                $run eval "$cmd" || exit $?
2088
              done
2089
              IFS="$save_ifs"
2090
            fi
2091
 
2092
            # Create $newlib
2093
            if test -f "$output_objdir/$newlib"; then :; else
2094
              $show "generating import library for \`$soname'"
2095
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
2096
              eval cmds=\"$old_archive_from_expsyms_cmds\"
2097
              for cmd in $cmds; do
2098
                IFS="$save_ifs"
2099
                $show "$cmd"
2100
                $run eval "$cmd" || exit $?
2101
              done
2102
              IFS="$save_ifs"
2103
            fi
2104
            # make sure the library variables are pointing to the new library
2105
            dir=$output_objdir
2106
            linklib=$newlib
2107
          fi # test -n $old_archive_from_expsyms_cmds
2108
 
2109
          if test $linkmode = prog || test "$mode" != relink; then
2110
            add_shlibpath=
2111
            add_dir=
2112
            add=
2113
            lib_linked=yes
2114
            case $hardcode_action in
2115
            immediate | unsupported)
2116
              if test "$hardcode_direct" = no; then
2117
                add="$dir/$linklib"
2118
              elif test "$hardcode_minus_L" = no; then
2119
                case $host in
2120
                *-*-sunos*) add_shlibpath="$dir" ;;
2121
                esac
2122
                add_dir="-L$dir"
2123
                add="-l$name"
2124
              elif test "$hardcode_shlibpath_var" = no; then
2125
                add_shlibpath="$dir"
2126
                add="-l$name"
2127
              else
2128
                lib_linked=no
2129
              fi
2130
              ;;
2131
            relink)
2132
              if test "$hardcode_direct" = yes; then
2133
                add="$dir/$linklib"
2134
              elif test "$hardcode_minus_L" = yes; then
2135
                add_dir="-L$dir"
2136
                add="-l$name"
2137
              elif test "$hardcode_shlibpath_var" = yes; then
2138
                add_shlibpath="$dir"
2139
                add="-l$name"
2140
              else
2141
                lib_linked=no
2142
              fi
2143
              ;;
2144
            *) lib_linked=no ;;
2145
            esac
2146
 
2147
            if test "$lib_linked" != yes; then
2148
              $echo "$modename: configuration error: unsupported hardcode properties"
2149
              exit 1
2150
            fi
2151
 
2152
            if test -n "$add_shlibpath"; then
2153
              case :$compile_shlibpath: in
2154
              *":$add_shlibpath:"*) ;;
2155
              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2156
              esac
2157
            fi
2158
            if test $linkmode = prog; then
2159
              test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2160
              test -n "$add" && compile_deplibs="$add $compile_deplibs"
2161
            else
2162
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
2163
              test -n "$add" && deplibs="$add $deplibs"
2164
              if test "$hardcode_direct" != yes && \
2165
                 test "$hardcode_minus_L" != yes && \
2166
                 test "$hardcode_shlibpath_var" = yes; then
2167
                case :$finalize_shlibpath: in
2168
                *":$libdir:"*) ;;
2169
                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2170
                esac
2171
              fi
2172
            fi
2173
          fi
2174
 
2175
          if test $linkmode = prog || test "$mode" = relink; then
2176
            add_shlibpath=
2177
            add_dir=
2178
            add=
2179
            # Finalize command for both is simple: just hardcode it.
2180
            if test "$hardcode_direct" = yes; then
2181
              add="$libdir/$linklib"
2182
            elif test "$hardcode_minus_L" = yes; then
2183
              add_dir="-L$libdir"
2184
              add="-l$name"
2185
            elif test "$hardcode_shlibpath_var" = yes; then
2186
              case :$finalize_shlibpath: in
2187
              *":$libdir:"*) ;;
2188
              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2189
              esac
2190
              add="-l$name"
2191
            else
2192
              # We cannot seem to hardcode it, guess we'll fake it.
2193
              add_dir="-L$libdir"
2194
              add="-l$name"
2195
            fi
2196
 
2197
            if test $linkmode = prog; then
2198
              test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2199
              test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2200
            else
2201
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
2202
              test -n "$add" && deplibs="$add $deplibs"
2203
            fi
2204
          fi
2205
        elif test $linkmode = prog; then
2206
          if test "$alldeplibs" = yes &&
2207
             { test "$deplibs_check_method" = pass_all ||
2208
               { test "$build_libtool_libs" = yes &&
2209
                 test -n "$library_names"; }; }; then
2210
            # We only need to search for static libraries
2211
            continue
2212
          fi
2213
 
2214
          # Try to link the static library
2215
          # Here we assume that one of hardcode_direct or hardcode_minus_L
2216
          # is not unsupported.  This is valid on all known static and
2217
          # shared platforms.
2218
          if test "$hardcode_direct" != unsupported; then
2219
            test -n "$old_library" && linklib="$old_library"
2220
            compile_deplibs="$dir/$linklib $compile_deplibs"
2221
            finalize_deplibs="$dir/$linklib $finalize_deplibs"
2222
          else
2223
            compile_deplibs="-l$name -L$dir $compile_deplibs"
2224
            finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2225
          fi
2226
        elif test "$build_libtool_libs" = yes; then
2227
          # Not a shared library
2228
          if test "$deplibs_check_method" != pass_all; then
2229
            # We're trying link a shared library against a static one
2230
            # but the system doesn't support it.
2231
 
2232
            # Just print a warning and add the library to dependency_libs so
2233
            # that the program can be linked against the static library.
2234
            echo
2235
            echo "*** Warning: This library needs some functionality provided by $lib."
2236
            echo "*** I have the capability to make that library automatically link in when"
2237
            echo "*** you link to this library.  But I can only do this if you have a"
2238
            echo "*** shared version of the library, which you do not appear to have."
2239
            if test "$module" = yes; then
2240
              echo "*** Therefore, libtool will create a static module, that should work "
2241
              echo "*** as long as the dlopening application is linked with the -dlopen flag."
2242
              if test -z "$global_symbol_pipe"; then
2243
                echo
2244
                echo "*** However, this would only work if libtool was able to extract symbol"
2245
                echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2246
                echo "*** not find such a program.  So, this module is probably useless."
2247
                echo "*** \`nm' from GNU binutils and a full rebuild may help."
2248
              fi
2249
              if test "$build_old_libs" = no; then
2250
                build_libtool_libs=module
2251
                build_old_libs=yes
2252
              else
2253
                build_libtool_libs=no
2254
              fi
2255
            fi
2256
          else
2257
            convenience="$convenience $dir/$old_library"
2258
            old_convenience="$old_convenience $dir/$old_library"
2259
            deplibs="$dir/$old_library $deplibs"
2260
            link_static=yes
2261
          fi
2262
        fi # link shared/static library?
2263
 
2264
        if test $linkmode = lib; then
2265
          if test -n "$dependency_libs" &&
2266
             { test $hardcode_into_libs != yes || test $build_old_libs = yes ||
2267
               test $link_static = yes; }; then
2268
            # Extract -R from dependency_libs
2269
            temp_deplibs=
2270
            for libdir in $dependency_libs; do
2271
              case $libdir in
2272
              -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2273
                   case " $xrpath " in
2274
                   *" $temp_xrpath "*) ;;
2275
                   *) xrpath="$xrpath $temp_xrpath";;
2276
                   esac;;
2277
              *) temp_deplibs="$temp_deplibs $libdir";;
2278
              esac
2279
            done
2280
            dependency_libs="$temp_deplibs"
2281
          fi
2282
 
2283
          newlib_search_path="$newlib_search_path $absdir"
2284
          # Link against this library
2285
          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2286
          # ... and its dependency_libs
2287
          tmp_libs=
2288
          for deplib in $dependency_libs; do
2289
            newdependency_libs="$deplib $newdependency_libs"
2290
            case "$tmp_libs " in
2291
            *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2292
            esac
2293
            tmp_libs="$tmp_libs $deplib"
2294
          done
2295
 
2296
          if test $link_all_deplibs != no; then
2297
            # Add the search paths of all dependency libraries
2298
            for deplib in $dependency_libs; do
2299
              case $deplib in
2300
              -L*) path="$deplib" ;;
2301
              *.la)
2302
                dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2303
                test "X$dir" = "X$deplib" && dir="."
2304
                # We need an absolute path.
2305
                case $dir in
2306
                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2307
                *)
2308
                  absdir=`cd "$dir" && pwd`
2309
                  if test -z "$absdir"; then
2310
                    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2311
                    absdir="$dir"
2312
                  fi
2313
                  ;;
2314
                esac
2315
                if grep "^installed=no" $deplib > /dev/null; then
2316
                  path="-L$absdir/$objdir"
2317
                else
2318
                  eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
2319
                  if test -z "$libdir"; then
2320
                    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2321
                    exit 1
2322
                  fi
2323
                  if test "$absdir" != "$libdir"; then
2324
                    $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
2325
                  fi
2326
                  path="-L$absdir"
2327
                fi
2328
                ;;
2329
              *) continue ;;
2330
              esac
2331
              case " $deplibs " in
2332
              *" $path "*) ;;
2333
              *) deplibs="$path $deplibs" ;;
2334
              esac
2335
            done
2336
          fi # link_all_deplibs != no
2337
        fi # linkmode = lib
2338
      done # for deplib in $libs
2339
      if test $pass = dlpreopen; then
2340
        # Link the dlpreopened libraries before other libraries
2341
        for deplib in $save_deplibs; do
2342
          deplibs="$deplib $deplibs"
2343
        done
2344
      fi
2345
      if test $pass != dlopen; then
2346
        test $pass != scan && dependency_libs="$newdependency_libs"
2347
        if test $pass != conv; then
2348
          # Make sure lib_search_path contains only unique directories.
2349
          lib_search_path=
2350
          for dir in $newlib_search_path; do
2351
            case "$lib_search_path " in
2352
            *" $dir "*) ;;
2353
            *) lib_search_path="$lib_search_path $dir" ;;
2354
            esac
2355
          done
2356
          newlib_search_path=
2357
        fi
2358
 
2359
        if test "$linkmode,$pass" != "prog,link"; then
2360
          vars="deplibs"
2361
        else
2362
          vars="compile_deplibs finalize_deplibs"
2363
        fi
2364
        for var in $vars dependency_libs; do
2365
          # Add libraries to $var in reverse order
2366
          eval tmp_libs=\"\$$var\"
2367
          new_libs=
2368
          for deplib in $tmp_libs; do
2369
            case $deplib in
2370
            -L*) new_libs="$deplib $new_libs" ;;
2371
            *)
2372
              case " $specialdeplibs " in
2373
              *" $deplib "*) new_libs="$deplib $new_libs" ;;
2374
              *)
2375
                case " $new_libs " in
2376
                *" $deplib "*) ;;
2377
                *) new_libs="$deplib $new_libs" ;;
2378
                esac
2379
                ;;
2380
              esac
2381
              ;;
2382
            esac
2383
          done
2384
          tmp_libs=
2385
          for deplib in $new_libs; do
2386
            case $deplib in
2387
            -L*)
2388
              case " $tmp_libs " in
2389
              *" $deplib "*) ;;
2390
              *) tmp_libs="$tmp_libs $deplib" ;;
2391
              esac
2392
              ;;
2393
            *) tmp_libs="$tmp_libs $deplib" ;;
2394
            esac
2395
          done
2396
          eval $var=\"$tmp_libs\"
2397
        done # for var
2398
      fi
2399
      if test "$pass" = "conv" &&
2400
       { test "$linkmode" = "lib" || test "$linkmode" = "prog"; }; then
2401
        libs="$deplibs" # reset libs
2402
        deplibs=
2403
      fi
2404
    done # for pass
2405
    if test $linkmode = prog; then
2406
      dlfiles="$newdlfiles"
2407
      dlprefiles="$newdlprefiles"
2408
    fi
2409
 
2410
    case $linkmode in
2411
    oldlib)
2412
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2413
        $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2414
      fi
2415
 
2416
      if test -n "$rpath"; then
2417
        $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2418
      fi
2419
 
2420
      if test -n "$xrpath"; then
2421
        $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2422
      fi
2423
 
2424
      if test -n "$vinfo"; then
2425
        $echo "$modename: warning: \`-version-info' is ignored for archives" 1>&2
2426
      fi
2427
 
2428
      if test -n "$release"; then
2429
        $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2430
      fi
2431
 
2432
      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2433
        $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2434
      fi
2435
 
2436
      # Now set the variables for building old libraries.
2437
      build_libtool_libs=no
2438
      oldlibs="$output"
2439
      objs="$objs$old_deplibs"
2440
      ;;
2441
 
2442
    lib)
2443
      # Make sure we only generate libraries of the form `libNAME.la'.
2444
      case $outputname in
2445
      lib*)
2446
        name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2447
        eval libname=\"$libname_spec\"
2448
        ;;
2449
      *)
2450
        if test "$module" = no; then
2451
          $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2452
          $echo "$help" 1>&2
2453
          exit 1
2454
        fi
2455
        if test "$need_lib_prefix" != no; then
2456
          # Add the "lib" prefix for modules if required
2457
          name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2458
          eval libname=\"$libname_spec\"
2459
        else
2460
          libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2461
        fi
2462
        ;;
2463
      esac
2464
 
2465
      if test -n "$objs"; then
2466
        if test "$deplibs_check_method" != pass_all; then
2467
          $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2468
          exit 1
2469
        else
2470
          echo
2471
          echo "*** Warning: Linking the shared library $output against the non-libtool"
2472
          echo "*** objects $objs is not portable!"
2473
          libobjs="$libobjs $objs"
2474
        fi
2475
      fi
2476
 
2477
      if test "$dlself" != no; then
2478
        $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2479
      fi
2480
 
2481
      set dummy $rpath
2482
      if test $# -gt 2; then
2483
        $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2484
      fi
2485
      install_libdir="$2"
2486
 
2487
      oldlibs=
2488
      if test -z "$rpath"; then
2489
        if test "$build_libtool_libs" = yes; then
2490
          # Building a libtool convenience library.
2491
          # Some compilers have problems with a `.al' extension so
2492
          # convenience libraries should have the same extension an
2493
          # archive normally would.
2494
          oldlibs="$output_objdir/$libname.$libext $oldlibs"
2495
          build_libtool_libs=convenience
2496
          build_old_libs=yes
2497
        fi
2498
 
2499
        if test -n "$vinfo"; then
2500
          $echo "$modename: warning: \`-version-info' is ignored for convenience libraries" 1>&2
2501
        fi
2502
 
2503
        if test -n "$release"; then
2504
          $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2505
        fi
2506
      else
2507
 
2508
        # Parse the version information argument.
2509
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS=':'
2510
        set dummy $vinfo 0 0 0
2511
        IFS="$save_ifs"
2512
 
2513
        if test -n "$8"; then
2514
          $echo "$modename: too many parameters to \`-version-info'" 1>&2
2515
          $echo "$help" 1>&2
2516
          exit 1
2517
        fi
2518
 
2519
        current="$2"
2520
        revision="$3"
2521
        age="$4"
2522
 
2523
        # Check that each of the things are valid numbers.
2524
        case $current in
2525
 
2526
        *)
2527
          $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2528
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2529
          exit 1
2530
          ;;
2531
        esac
2532
 
2533
        case $revision in
2534
 
2535
        *)
2536
          $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2537
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2538
          exit 1
2539
          ;;
2540
        esac
2541
 
2542
        case $age in
2543
 
2544
        *)
2545
          $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2546
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2547
          exit 1
2548
          ;;
2549
        esac
2550
 
2551
        if test $age -gt $current; then
2552
          $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2553
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2554
          exit 1
2555
        fi
2556
 
2557
        # Calculate the version variables.
2558
        major=
2559
        versuffix=
2560
        verstring=
2561
        case $version_type in
2562
        none) ;;
2563
 
2564
        darwin)
2565
          # Like Linux, but with the current version available in
2566
          # verstring for coding it into the library header
2567
          major=.`expr $current - $age`
2568
          versuffix="$major.$age.$revision"
2569
          # Darwin ld doesn't like 0 for these options...
2570
          minor_current=`expr $current + 1`
2571
          verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2572
          ;;
2573
 
2574
        freebsd-aout)
2575
          major=".$current"
2576
          versuffix=".$current.$revision";
2577
          ;;
2578
 
2579
        freebsd-elf)
2580
          major=".$current"
2581
          versuffix=".$current";
2582
          ;;
2583
 
2584
        irix)
2585
          major=`expr $current - $age + 1`
2586
          verstring="sgi$major.$revision"
2587
 
2588
          # Add in all the interfaces that we are compatible with.
2589
          loop=$revision
2590
          while test $loop != 0; do
2591
            iface=`expr $revision - $loop`
2592
            loop=`expr $loop - 1`
2593
            verstring="sgi$major.$iface:$verstring"
2594
          done
2595
 
2596
          # Before this point, $major must not contain `.'.
2597
          major=.$major
2598
          versuffix="$major.$revision"
2599
          ;;
2600
 
2601
        linux)
2602
          major=.`expr $current - $age`
2603
          versuffix="$major.$age.$revision"
2604
          ;;
2605
 
2606
        osf)
2607
          major=`expr $current - $age`
2608
          versuffix=".$current.$age.$revision"
2609
          verstring="$current.$age.$revision"
2610
 
2611
          # Add in all the interfaces that we are compatible with.
2612
          loop=$age
2613
          while test $loop != 0; do
2614
            iface=`expr $current - $loop`
2615
            loop=`expr $loop - 1`
2616
            verstring="$verstring:${iface}.0"
2617
          done
2618
 
2619
          # Make executables depend on our current version.
2620
          verstring="$verstring:${current}.0"
2621
          ;;
2622
 
2623
        sunos)
2624
          major=".$current"
2625
          versuffix=".$current.$revision"
2626
          ;;
2627
 
2628
        windows)
2629
          # Use '-' rather than '.', since we only want one
2630
          # extension on DOS 8.3 filesystems.
2631
          major=`expr $current - $age`
2632
          versuffix="-$major"
2633
          ;;
2634
 
2635
        *)
2636
          $echo "$modename: unknown library version type \`$version_type'" 1>&2
2637
          echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
2638
          exit 1
2639
          ;;
2640
        esac
2641
 
2642
        # Clear the version info if we defaulted, and they specified a release.
2643
        if test -z "$vinfo" && test -n "$release"; then
2644
          major=
2645
          verstring="0.0"
2646
          if test "$need_version" = no; then
2647
            versuffix=
2648
          else
2649
            versuffix=".0.0"
2650
          fi
2651
        fi
2652
 
2653
        # Remove version info from name if versioning should be avoided
2654
        if test "$avoid_version" = yes && test "$need_version" = no; then
2655
          major=
2656
          versuffix=
2657
          verstring=""
2658
        fi
2659
 
2660
        # Check to see if the archive will have undefined symbols.
2661
        if test "$allow_undefined" = yes; then
2662
          if test "$allow_undefined_flag" = unsupported; then
2663
            $echo "$modename: warning: undefined symbols not allowed in $host shared libraries" 1>&2
2664
            build_libtool_libs=no
2665
            build_old_libs=yes
2666
          fi
2667
        else
2668
          # Don't allow undefined symbols.
2669
          allow_undefined_flag="$no_undefined_flag"
2670
        fi
2671
      fi
2672
 
2673
      if test "$mode" != relink; then
2674
        # Remove our outputs, but don't remove object files since they
2675
        # may have been created when compiling PIC objects.
2676
        removelist=
2677
        tempremovelist=`echo "$output_objdir/*"`
2678
        for p in $tempremovelist; do
2679
          case $p in
2680
            *.$objext)
2681
               ;;
2682
            $output_objdir/$outputname | $output_objdir/$libname.* | $output_objdir/${libname}${release}.*)
2683
               removelist="$removelist $p"
2684
               ;;
2685
            *) ;;
2686
          esac
2687
        done
2688
        if test -n "$removelist"; then
2689
          $show "${rm}r $removelist"
2690
          $run ${rm}r $removelist
2691
        fi
2692
      fi
2693
 
2694
      # Now set the variables for building old libraries.
2695
      if test "$build_old_libs" = yes && test "$build_libtool_libs" != convenience ; then
2696
        oldlibs="$oldlibs $output_objdir/$libname.$libext"
2697
 
2698
        # Transform .lo files to .o files.
2699
        oldobjs="$objs "`$echo "X$libobjs" | $SP2NL | $Xsed -e '/\.'${libext}'$/d' -e "$lo2o" | $NL2SP`
2700
      fi
2701
 
2702
      # Eliminate all temporary directories.
2703
      for path in $notinst_path; do
2704
        lib_search_path=`echo "$lib_search_path " | sed -e 's% $path % %g'`
2705
        deplibs=`echo "$deplibs " | sed -e 's% -L$path % %g'`
2706
        dependency_libs=`echo "$dependency_libs " | sed -e 's% -L$path % %g'`
2707
      done
2708
 
2709
      if test -n "$xrpath"; then
2710
        # If the user specified any rpath flags, then add them.
2711
        temp_xrpath=
2712
        for libdir in $xrpath; do
2713
          temp_xrpath="$temp_xrpath -R$libdir"
2714
          case "$finalize_rpath " in
2715
          *" $libdir "*) ;;
2716
          *) finalize_rpath="$finalize_rpath $libdir" ;;
2717
          esac
2718
        done
2719
        if test $hardcode_into_libs != yes || test $build_old_libs = yes; then
2720
          dependency_libs="$temp_xrpath $dependency_libs"
2721
        fi
2722
      fi
2723
 
2724
      # Make sure dlfiles contains only unique files that won't be dlpreopened
2725
      old_dlfiles="$dlfiles"
2726
      dlfiles=
2727
      for lib in $old_dlfiles; do
2728
        case " $dlprefiles $dlfiles " in
2729
        *" $lib "*) ;;
2730
        *) dlfiles="$dlfiles $lib" ;;
2731
        esac
2732
      done
2733
 
2734
      # Make sure dlprefiles contains only unique files
2735
      old_dlprefiles="$dlprefiles"
2736
      dlprefiles=
2737
      for lib in $old_dlprefiles; do
2738
        case "$dlprefiles " in
2739
        *" $lib "*) ;;
2740
        *) dlprefiles="$dlprefiles $lib" ;;
2741
        esac
2742
      done
2743
 
2744
      if test "$build_libtool_libs" = yes; then
2745
        if test -n "$rpath"; then
2746
          case $host in
2747
          *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2* | *-*-beos*)
2748
            # these systems don't actually have a c library (as such)!
2749
            ;;
2750
          *-*-rhapsody* | *-*-darwin1.[012])
2751
            # Rhapsody C library is in the System framework
2752
            deplibs="$deplibs -framework System"
2753
            ;;
2754
          *-*-netbsd*)
2755
            # Don't link with libc until the a.out ld.so is fixed.
2756
            ;;
2757
          *)
2758
            # Add libc to deplibs on all other systems if necessary.
2759
            if test $build_libtool_need_lc = "yes"; then
2760
              deplibs="$deplibs -lc"
2761
            fi
2762
            ;;
2763
          esac
2764
        fi
2765
 
2766
        # Transform deplibs into only deplibs that can be linked in shared.
2767
        name_save=$name
2768
        libname_save=$libname
2769
        release_save=$release
2770
        versuffix_save=$versuffix
2771
        major_save=$major
2772
        # I'm not sure if I'm treating the release correctly.  I think
2773
        # release should show up in the -l (ie -lgmp5) so we don't want to
2774
        # add it in twice.  Is that correct?
2775
        release=""
2776
        versuffix=""
2777
        major=""
2778
        newdeplibs=
2779
        droppeddeps=no
2780
        case $deplibs_check_method in
2781
        pass_all)
2782
          # Don't check for shared/static.  Everything works.
2783
          # This might be a little naive.  We might want to check
2784
          # whether the library exists or not.  But this is on
2785
          # osf3 & osf4 and I'm not really sure... Just
2786
          # implementing what was already the behaviour.
2787
          newdeplibs=$deplibs
2788
          ;;
2789
        test_compile)
2790
          # This code stresses the "libraries are programs" paradigm to its
2791
          # limits. Maybe even breaks it.  We compile a program, linking it
2792
          # against the deplibs as a proxy for the library.  Then we can check
2793
          # whether they linked in statically or dynamically with ldd.
2794
          $rm conftest.c
2795
          cat > conftest.c <<EOF
2796
          int main() { return 0; }
2797
EOF
2798
          $rm conftest
2799
          $LTCC -o conftest conftest.c $deplibs
2800
          if test $? -eq 0 ; then
2801
            ldd_output=`ldd conftest`
2802
            for i in $deplibs; do
2803
              name="`expr $i : '-l\(.*\)'`"
2804
              # If $name is empty we are operating on a -L argument.
2805
              if test -n "$name" && test "$name" != "0"; then
2806
                libname=`eval \\$echo \"$libname_spec\"`
2807
                deplib_matches=`eval \\$echo \"$library_names_spec\"`
2808
                set dummy $deplib_matches
2809
                deplib_match=$2
2810
                if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2811
                  newdeplibs="$newdeplibs $i"
2812
                else
2813
                  droppeddeps=yes
2814
                  echo
2815
                  echo "*** Warning: This library needs some functionality provided by $i."
2816
                  echo "*** I have the capability to make that library automatically link in when"
2817
                  echo "*** you link to this library.  But I can only do this if you have a"
2818
                  echo "*** shared version of the library, which you do not appear to have."
2819
                fi
2820
              else
2821
                newdeplibs="$newdeplibs $i"
2822
              fi
2823
            done
2824
          else
2825
            # Error occured in the first compile.  Let's try to salvage the situation:
2826
            # Compile a seperate program for each library.
2827
            for i in $deplibs; do
2828
              name="`expr $i : '-l\(.*\)'`"
2829
             # If $name is empty we are operating on a -L argument.
2830
              if test -n "$name" && test "$name" != "0"; then
2831
                $rm conftest
2832
                $LTCC -o conftest conftest.c $i
2833
                # Did it work?
2834
                if test $? -eq 0 ; then
2835
                  ldd_output=`ldd conftest`
2836
                  libname=`eval \\$echo \"$libname_spec\"`
2837
                  deplib_matches=`eval \\$echo \"$library_names_spec\"`
2838
                  set dummy $deplib_matches
2839
                  deplib_match=$2
2840
                  if test `expr "$ldd_output" : ".*$deplib_match"` -ne 0 ; then
2841
                    newdeplibs="$newdeplibs $i"
2842
                  else
2843
                    droppeddeps=yes
2844
                    echo
2845
                    echo "*** Warning: This library needs some functionality provided by $i."
2846
                    echo "*** I have the capability to make that library automatically link in when"
2847
                    echo "*** you link to this library.  But I can only do this if you have a"
2848
                    echo "*** shared version of the library, which you do not appear to have."
2849
                  fi
2850
                else
2851
                  droppeddeps=yes
2852
                  echo
2853
                  echo "*** Warning!  Library $i is needed by this library but I was not able to"
2854
                  echo "***  make it link in!  You will probably need to install it or some"
2855
                  echo "*** library that it depends on before this library will be fully"
2856
                  echo "*** functional.  Installing it before continuing would be even better."
2857
                fi
2858
              else
2859
                newdeplibs="$newdeplibs $i"
2860
              fi
2861
            done
2862
          fi
2863
          ;;
2864
        file_magic*)
2865
          set dummy $deplibs_check_method
2866
          file_magic_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2867
          for a_deplib in $deplibs; do
2868
            name="`expr $a_deplib : '-l\(.*\)'`"
2869
            # If $name is empty we are operating on a -L argument.
2870
            if test -n "$name" && test "$name" != "0"; then
2871
              libname=`eval \\$echo \"$libname_spec\"`
2872
              for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2873
                    potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2874
                    for potent_lib in $potential_libs; do
2875
                      # Follow soft links.
2876
                      if ls -lLd "$potent_lib" 2>/dev/null \
2877
                         | grep " -> " >/dev/null; then
2878
                        continue
2879
                      fi
2880
                      # The statement above tries to avoid entering an
2881
                      # endless loop below, in case of cyclic links.
2882
                      # We might still enter an endless loop, since a link
2883
                      # loop can be closed while we follow links,
2884
                      # but so what?
2885
                      potlib="$potent_lib"
2886
                      while test -h "$potlib" 2>/dev/null; do
2887
                        potliblink=`ls -ld $potlib | sed 's/.* -> //'`
2888
                        case $potliblink in
2889
                        [\\/]* | [A-Za-z]:[\\/]*) potlib="$potliblink";;
2890
                        *) potlib=`$echo "X$potlib" | $Xsed -e 's,[^/]*$,,'`"$potliblink";;
2891
                        esac
2892
                      done
2893
                      if eval $file_magic_cmd \"\$potlib\" 2>/dev/null \
2894
                         | sed 10q \
2895
                         | egrep "$file_magic_regex" > /dev/null; then
2896
                        newdeplibs="$newdeplibs $a_deplib"
2897
                        a_deplib=""
2898
                        break 2
2899
                      fi
2900
                    done
2901
              done
2902
              if test -n "$a_deplib" ; then
2903
                droppeddeps=yes
2904
                echo
2905
                echo "*** Warning: This library needs some functionality provided by $a_deplib."
2906
                echo "*** I have the capability to make that library automatically link in when"
2907
                echo "*** you link to this library.  But I can only do this if you have a"
2908
                echo "*** shared version of the library, which you do not appear to have."
2909
              fi
2910
            else
2911
              # Add a -L argument.
2912
              newdeplibs="$newdeplibs $a_deplib"
2913
            fi
2914
          done # Gone through all deplibs.
2915
          ;;
2916
        match_pattern*)
2917
          set dummy $deplibs_check_method
2918
          match_pattern_regex=`expr "$deplibs_check_method" : "$2 \(.*\)"`
2919
          for a_deplib in $deplibs; do
2920
            name="`expr $a_deplib : '-l\(.*\)'`"
2921
            # If $name is empty we are operating on a -L argument.
2922
            if test -n "$name" && test "$name" != "0"; then
2923
              libname=`eval \\$echo \"$libname_spec\"`
2924
              for i in $lib_search_path $sys_lib_search_path $shlib_search_path; do
2925
                potential_libs=`ls $i/$libname[.-]* 2>/dev/null`
2926
                for potent_lib in $potential_libs; do
2927
                  if eval echo \"$potent_lib\" 2>/dev/null \
2928
                      | sed 10q \
2929
                      | egrep "$match_pattern_regex" > /dev/null; then
2930
                    newdeplibs="$newdeplibs $a_deplib"
2931
                    a_deplib=""
2932
                    break 2
2933
                  fi
2934
                done
2935
              done
2936
              if test -n "$a_deplib" ; then
2937
                droppeddeps=yes
2938
                echo
2939
                echo "*** Warning: This library needs some functionality provided by $a_deplib."
2940
                echo "*** I have the capability to make that library automatically link in when"
2941
                echo "*** you link to this library.  But I can only do this if you have a"
2942
                echo "*** shared version of the library, which you do not appear to have."
2943
              fi
2944
            else
2945
              # Add a -L argument.
2946
              newdeplibs="$newdeplibs $a_deplib"
2947
            fi
2948
          done # Gone through all deplibs.
2949
          ;;
2950
        none | unknown | *)
2951
          newdeplibs=""
2952
          if $echo "X $deplibs" | $Xsed -e 's/ -lc$//' \
2953
               -e 's/ -[LR][^ ]*//g' -e 's/[    ]//g' |
2954
             grep . >/dev/null; then
2955
            echo
2956
            if test "X$deplibs_check_method" = "Xnone"; then
2957
              echo "*** Warning: inter-library dependencies are not supported in this platform."
2958
            else
2959
              echo "*** Warning: inter-library dependencies are not known to be supported."
2960
            fi
2961
            echo "*** All declared inter-library dependencies are being dropped."
2962
            droppeddeps=yes
2963
          fi
2964
          ;;
2965
        esac
2966
        versuffix=$versuffix_save
2967
        major=$major_save
2968
        release=$release_save
2969
        libname=$libname_save
2970
        name=$name_save
2971
 
2972
        case $host in
2973
        *-*-rhapsody* | *-*-darwin1.[012])
2974
          # On Rhapsody replace the C library is the System framework
2975
          newdeplibs=`$echo "X $newdeplibs" | $Xsed -e 's/ -lc / -framework System /'`
2976
          ;;
2977
        esac
2978
 
2979
        if test "$droppeddeps" = yes; then
2980
          if test "$module" = yes; then
2981
            echo
2982
            echo "*** Warning: libtool could not satisfy all declared inter-library"
2983
            echo "*** dependencies of module $libname.  Therefore, libtool will create"
2984
            echo "*** a static module, that should work as long as the dlopening"
2985
            echo "*** application is linked with the -dlopen flag."
2986
            if test -z "$global_symbol_pipe"; then
2987
              echo
2988
              echo "*** However, this would only work if libtool was able to extract symbol"
2989
              echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2990
              echo "*** not find such a program.  So, this module is probably useless."
2991
              echo "*** \`nm' from GNU binutils and a full rebuild may help."
2992
            fi
2993
            if test "$build_old_libs" = no; then
2994
              oldlibs="$output_objdir/$libname.$libext"
2995
              build_libtool_libs=module
2996
              build_old_libs=yes
2997
            else
2998
              build_libtool_libs=no
2999
            fi
3000
          else
3001
            echo "*** The inter-library dependencies that have been dropped here will be"
3002
            echo "*** automatically added whenever a program is linked with this library"
3003
            echo "*** or is declared to -dlopen it."
3004
 
3005
            if test $allow_undefined = no; then
3006
              echo
3007
              echo "*** Since this library must not contain undefined symbols,"
3008
              echo "*** because either the platform does not support them or"
3009
              echo "*** it was explicitly requested with -no-undefined,"
3010
              echo "*** libtool will only create a static version of it."
3011
              if test "$build_old_libs" = no; then
3012
                oldlibs="$output_objdir/$libname.$libext"
3013
                build_libtool_libs=module
3014
                build_old_libs=yes
3015
              else
3016
                build_libtool_libs=no
3017
              fi
3018
            fi
3019
          fi
3020
        fi
3021
        # Done checking deplibs!
3022
        deplibs=$newdeplibs
3023
      fi
3024
 
3025
      # All the library-specific variables (install_libdir is set above).
3026
      library_names=
3027
      old_library=
3028
      dlname=
3029
 
3030
      # Test again, we may have decided not to build it any more
3031
      if test "$build_libtool_libs" = yes; then
3032
        if test $hardcode_into_libs = yes; then
3033
          # Hardcode the library paths
3034
          hardcode_libdirs=
3035
          dep_rpath=
3036
          rpath="$finalize_rpath"
3037
          test "$mode" != relink && rpath="$compile_rpath$rpath"
3038
          for libdir in $rpath; do
3039
            if test -n "$hardcode_libdir_flag_spec"; then
3040
              if test -n "$hardcode_libdir_separator"; then
3041
                if test -z "$hardcode_libdirs"; then
3042
                  hardcode_libdirs="$libdir"
3043
                else
3044
                  # Just accumulate the unique libdirs.
3045
                  case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3046
                  *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3047
                    ;;
3048
                  *)
3049
                    hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3050
                    ;;
3051
                  esac
3052
                fi
3053
              else
3054
                eval flag=\"$hardcode_libdir_flag_spec\"
3055
                dep_rpath="$dep_rpath $flag"
3056
              fi
3057
            elif test -n "$runpath_var"; then
3058
              case "$perm_rpath " in
3059
              *" $libdir "*) ;;
3060
              *) perm_rpath="$perm_rpath $libdir" ;;
3061
              esac
3062
            fi
3063
          done
3064
          # Substitute the hardcoded libdirs into the rpath.
3065
          if test -n "$hardcode_libdir_separator" &&
3066
             test -n "$hardcode_libdirs"; then
3067
            libdir="$hardcode_libdirs"
3068
            eval dep_rpath=\"$hardcode_libdir_flag_spec\"
3069
          fi
3070
          if test -n "$runpath_var" && test -n "$perm_rpath"; then
3071
            # We should set the runpath_var.
3072
            rpath=
3073
            for dir in $perm_rpath; do
3074
              rpath="$rpath$dir:"
3075
            done
3076
            eval "$runpath_var='$rpath\$$runpath_var'; export $runpath_var"
3077
          fi
3078
          test -n "$dep_rpath" && deplibs="$dep_rpath $deplibs"
3079
        fi
3080
 
3081
        shlibpath="$finalize_shlibpath"
3082
        test "$mode" != relink && shlibpath="$compile_shlibpath$shlibpath"
3083
        if test -n "$shlibpath"; then
3084
          eval "$shlibpath_var='$shlibpath\$$shlibpath_var'; export $shlibpath_var"
3085
        fi
3086
 
3087
        # Get the real and link names of the library.
3088
        eval library_names=\"$library_names_spec\"
3089
        set dummy $library_names
3090
        realname="$2"
3091
        shift; shift
3092
 
3093
        if test -n "$soname_spec"; then
3094
          eval soname=\"$soname_spec\"
3095
        else
3096
          soname="$realname"
3097
        fi
3098
        test -z "$dlname" && dlname=$soname
3099
 
3100
        lib="$output_objdir/$realname"
3101
        for link
3102
        do
3103
          linknames="$linknames $link"
3104
        done
3105
 
3106
#       # Ensure that we have .o objects for linkers which dislike .lo
3107
#       # (e.g. aix) in case we are running --disable-static
3108
#       for obj in $libobjs; do
3109
#         xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
3110
#         if test "X$xdir" = "X$obj"; then
3111
#           xdir="."
3112
#         else
3113
#           xdir="$xdir"
3114
#         fi
3115
#         baseobj=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
3116
#         oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
3117
#         if test ! -f $xdir/$oldobj && test "$baseobj" != "$oldobj"; then
3118
#           $show "(cd $xdir && ${LN_S} $baseobj $oldobj)"
3119
#           $run eval '(cd $xdir && ${LN_S} $baseobj $oldobj)' || exit $?
3120
#         fi
3121
#       done
3122
 
3123
        # Use standard objects if they are pic
3124
        test -z "$pic_flag" && libobjs=`$echo "X$libobjs" | $SP2NL | $Xsed -e "$lo2o" | $NL2SP`
3125
 
3126
        # Prepare the list of exported symbols
3127
        if test -z "$export_symbols"; then
3128
          if test "$always_export_symbols" = yes || test -n "$export_symbols_regex"; then
3129
            $show "generating symbol list for \`$libname.la'"
3130
            export_symbols="$output_objdir/$libname.exp"
3131
            $run $rm $export_symbols
3132
            eval cmds=\"$export_symbols_cmds\"
3133
            IFS="${IFS=         }"; save_ifs="$IFS"; IFS='~'
3134
            for cmd in $cmds; do
3135
              IFS="$save_ifs"
3136
              $show "$cmd"
3137
              $run eval "$cmd" || exit $?
3138
            done
3139
            IFS="$save_ifs"
3140
            if test -n "$export_symbols_regex"; then
3141
              $show "egrep -e \"$export_symbols_regex\" \"$export_symbols\" > \"${export_symbols}T\""
3142
              $run eval 'egrep -e "$export_symbols_regex" "$export_symbols" > "${export_symbols}T"'
3143
              $show "$mv \"${export_symbols}T\" \"$export_symbols\""
3144
              $run eval '$mv "${export_symbols}T" "$export_symbols"'
3145
            fi
3146
          fi
3147
        fi
3148
 
3149
        if test -n "$export_symbols" && test -n "$include_expsyms"; then
3150
          $run eval '$echo "X$include_expsyms" | $SP2NL >> "$export_symbols"'
3151
        fi
3152
 
3153
        if test -n "$convenience"; then
3154
          if test -n "$whole_archive_flag_spec"; then
3155
            save_libobjs=$libobjs
3156
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3157
          else
3158
            gentop="$output_objdir/${outputname}x"
3159
            $show "${rm}r $gentop"
3160
            $run ${rm}r "$gentop"
3161
            $show "$mkdir $gentop"
3162
            $run $mkdir "$gentop"
3163
            status=$?
3164
            if test $status -ne 0 && test ! -d "$gentop"; then
3165
              exit $status
3166
            fi
3167
            generated="$generated $gentop"
3168
 
3169
            for xlib in $convenience; do
3170
              # Extract the objects.
3171
              case $xlib in
3172
              [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3173
              *) xabs=`pwd`"/$xlib" ;;
3174
              esac
3175
              xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3176
              xdir="$gentop/$xlib"
3177
 
3178
              $show "${rm}r $xdir"
3179
              $run ${rm}r "$xdir"
3180
              $show "$mkdir $xdir"
3181
              $run $mkdir "$xdir"
3182
              status=$?
3183
              if test $status -ne 0 && test ! -d "$xdir"; then
3184
                exit $status
3185
              fi
3186
              $show "(cd $xdir && $AR x $xabs)"
3187
              $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3188
 
3189
              libobjs="$libobjs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3190
            done
3191
          fi
3192
        fi
3193
 
3194
        if test "$thread_safe" = yes && test -n "$thread_safe_flag_spec"; then
3195
          eval flag=\"$thread_safe_flag_spec\"
3196
          linker_flags="$linker_flags $flag"
3197
        fi
3198
 
3199
        # Make a backup of the uninstalled library when relinking
3200
        if test "$mode" = relink; then
3201
          $run eval '(cd $output_objdir && $rm ${realname}U && $mv $realname ${realname}U)' || exit $?
3202
        fi
3203
 
3204
        # Do each of the archive commands.
3205
        if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3206
          eval cmds=\"$archive_expsym_cmds\"
3207
        else
3208
          eval cmds=\"$archive_cmds\"
3209
        fi
3210
        if len=`expr "X$cmds" : ".*"` &&
3211
           test $len -le $max_cmd_len; then
3212
          :
3213
        else
3214
          # The command line is too long to link in one step, link piecewise.
3215
          $echo "creating reloadable object files..."
3216
 
3217
          # Save the value of $output and $libobjs because we want to
3218
          # use them later.  If we have whole_archive_flag_spec, we
3219
          # want to use save_libobjs as it was before
3220
          # whole_archive_flag_spec was expanded, because we can't
3221
          # assume the linker understands whole_archive_flag_spec.
3222
          # This may have to be revisited, in case too many
3223
          # convenience libraries get linked in and end up exceeding
3224
          # the spec.
3225
          if test -z "$convenience" || test -z "$whole_archive_flag_spec"; then
3226
            save_libobjs=$libobjs
3227
          fi
3228
          save_output=$output
3229
 
3230
          # Clear the reloadable object creation command queue and
3231
          # initialize k to one.
3232
          test_cmds=
3233
          concat_cmds=
3234
          objlist=
3235
          delfiles=
3236
          last_robj=
3237
          k=1
3238
          output=$output_objdir/$save_output-${k}.$objext
3239
          # Loop over the list of objects to be linked.
3240
          for obj in $save_libobjs
3241
          do
3242
            eval test_cmds=\"$reload_cmds $objlist $last_robj\"
3243
            if test "X$objlist" = X ||
3244
               { len=`expr "X$test_cmds" : ".*"` &&
3245
                 test $len -le $max_cmd_len; }; then
3246
              objlist="$objlist $obj"
3247
            else
3248
              # The command $test_cmds is almost too long, add a
3249
              # command to the queue.
3250
              if test $k -eq 1 ; then
3251
                # The first file doesn't have a previous command to add.
3252
                eval concat_cmds=\"$reload_cmds $objlist $last_robj\"
3253
              else
3254
                # All subsequent reloadable object files will link in
3255
                # the last one created.
3256
                eval concat_cmds=\"\$concat_cmds~$reload_cmds $objlist $last_robj\"
3257
              fi
3258
              last_robj=$output_objdir/$save_output-${k}.$objext
3259
              k=`expr $k + 1`
3260
              output=$output_objdir/$save_output-${k}.$objext
3261
              objlist=$obj
3262
              len=1
3263
            fi
3264
          done
3265
          # Handle the remaining objects by creating one last
3266
          # reloadable object file.  All subsequent reloadable object
3267
          # files will link in the last one created.
3268
          test -z "$concat_cmds" || concat_cmds=$concat_cmds~
3269
          eval concat_cmds=\"\${concat_cmds}$reload_cmds $objlist $last_robj\"
3270
 
3271
          # Set up a command to remove the reloadale object files
3272
          # after they are used.
3273
          i=0
3274
          while test $i -lt $k
3275
          do
3276
            i=`expr $i + 1`
3277
            delfiles="$delfiles $output_objdir/$save_output-${i}.$objext"
3278
          done
3279
 
3280
          $echo "creating a temporary reloadable object file: $output"
3281
 
3282
          # Loop through the commands generated above and execute them.
3283
          IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
3284
          for cmd in $concat_cmds; do
3285
            IFS="$save_ifs"
3286
            $show "$cmd"
3287
            $run eval "$cmd" || exit $?
3288
          done
3289
          IFS="$save_ifs"
3290
 
3291
          libobjs=$output
3292
          # Restore the value of output.
3293
          output=$save_output
3294
 
3295
          if test -n "$convenience" && test -n "$whole_archive_flag_spec"; then
3296
            eval libobjs=\"\$libobjs $whole_archive_flag_spec\"
3297
          fi
3298
          # Expand the library linking commands again to reset the
3299
          # value of $libobjs for piecewise linking.
3300
 
3301
          # Do each of the archive commands.
3302
          if test -n "$export_symbols" && test -n "$archive_expsym_cmds"; then
3303
            eval cmds=\"$archive_expsym_cmds\"
3304
          else
3305
            eval cmds=\"$archive_cmds\"
3306
          fi
3307
 
3308
          # Append the command to remove the reloadable object files
3309
          # to the just-reset $cmds.
3310
          eval cmds=\"\$cmds~$rm $delfiles\"
3311
        fi
3312
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
3313
        for cmd in $cmds; do
3314
          IFS="$save_ifs"
3315
          $show "$cmd"
3316
          $run eval "$cmd" || exit $?
3317
        done
3318
        IFS="$save_ifs"
3319
 
3320
        # Restore the uninstalled library and exit
3321
        if test "$mode" = relink; then
3322
          $run eval '(cd $output_objdir && $rm ${realname}T && $mv $realname ${realname}T && $mv "$realname"U $realname)' || exit $?
3323
          exit 0
3324
        fi
3325
 
3326
        # Create links to the real library.
3327
        for linkname in $linknames; do
3328
          if test "$realname" != "$linkname"; then
3329
            $show "(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)"
3330
            $run eval '(cd $output_objdir && $rm $linkname && $LN_S $realname $linkname)' || exit $?
3331
          fi
3332
        done
3333
 
3334
        # If -module or -export-dynamic was specified, set the dlname.
3335
        if test "$module" = yes || test "$export_dynamic" = yes; then
3336
          # On all known operating systems, these are identical.
3337
          dlname="$soname"
3338
        fi
3339
      fi
3340
      ;;
3341
 
3342
    obj)
3343
      if test -n "$deplibs"; then
3344
        $echo "$modename: warning: \`-l' and \`-L' are ignored for objects" 1>&2
3345
      fi
3346
 
3347
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3348
        $echo "$modename: warning: \`-dlopen' is ignored for objects" 1>&2
3349
      fi
3350
 
3351
      if test -n "$rpath"; then
3352
        $echo "$modename: warning: \`-rpath' is ignored for objects" 1>&2
3353
      fi
3354
 
3355
      if test -n "$xrpath"; then
3356
        $echo "$modename: warning: \`-R' is ignored for objects" 1>&2
3357
      fi
3358
 
3359
      if test -n "$vinfo"; then
3360
        $echo "$modename: warning: \`-version-info' is ignored for objects" 1>&2
3361
      fi
3362
 
3363
      if test -n "$release"; then
3364
        $echo "$modename: warning: \`-release' is ignored for objects" 1>&2
3365
      fi
3366
 
3367
      case $output in
3368
      *.lo)
3369
        if test -n "$objs$old_deplibs"; then
3370
          $echo "$modename: cannot build library object \`$output' from non-libtool objects" 1>&2
3371
          exit 1
3372
        fi
3373
        libobj="$output"
3374
        obj=`$echo "X$output" | $Xsed -e "$lo2o"`
3375
        ;;
3376
      *)
3377
        libobj=
3378
        obj="$output"
3379
        ;;
3380
      esac
3381
 
3382
      # Delete the old objects.
3383
      $run $rm $obj $libobj
3384
 
3385
      # Objects from convenience libraries.  This assumes
3386
      # single-version convenience libraries.  Whenever we create
3387
      # different ones for PIC/non-PIC, this we'll have to duplicate
3388
      # the extraction.
3389
      reload_conv_objs=
3390
      gentop=
3391
      # reload_cmds runs $LD directly, so let us get rid of
3392
      # -Wl from whole_archive_flag_spec
3393
      wl=
3394
 
3395
      if test -n "$convenience"; then
3396
        if test -n "$whole_archive_flag_spec"; then
3397
          eval reload_conv_objs=\"\$reload_objs $whole_archive_flag_spec\"
3398
        else
3399
          gentop="$output_objdir/${obj}x"
3400
          $show "${rm}r $gentop"
3401
          $run ${rm}r "$gentop"
3402
          $show "$mkdir $gentop"
3403
          $run $mkdir "$gentop"
3404
          status=$?
3405
          if test $status -ne 0 && test ! -d "$gentop"; then
3406
            exit $status
3407
          fi
3408
          generated="$generated $gentop"
3409
 
3410
          for xlib in $convenience; do
3411
            # Extract the objects.
3412
            case $xlib in
3413
            [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
3414
            *) xabs=`pwd`"/$xlib" ;;
3415
            esac
3416
            xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
3417
            xdir="$gentop/$xlib"
3418
 
3419
            $show "${rm}r $xdir"
3420
            $run ${rm}r "$xdir"
3421
            $show "$mkdir $xdir"
3422
            $run $mkdir "$xdir"
3423
            status=$?
3424
            if test $status -ne 0 && test ! -d "$xdir"; then
3425
              exit $status
3426
            fi
3427
            $show "(cd $xdir && $AR x $xabs)"
3428
            $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
3429
 
3430
            reload_conv_objs="$reload_objs "`find $xdir -name \*.$objext -print -o -name \*.lo -print | $NL2SP`
3431
          done
3432
        fi
3433
      fi
3434
 
3435
      # Create the old-style object.
3436
      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
3437
 
3438
      output="$obj"
3439
      eval cmds=\"$reload_cmds\"
3440
      IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
3441
      for cmd in $cmds; do
3442
        IFS="$save_ifs"
3443
        $show "$cmd"
3444
        $run eval "$cmd" || exit $?
3445
      done
3446
      IFS="$save_ifs"
3447
 
3448
      # Exit if we aren't doing a library object file.
3449
      if test -z "$libobj"; then
3450
        if test -n "$gentop"; then
3451
          $show "${rm}r $gentop"
3452
          $run ${rm}r $gentop
3453
        fi
3454
 
3455
        exit 0
3456
      fi
3457
 
3458
      if test "$build_libtool_libs" != yes; then
3459
        if test -n "$gentop"; then
3460
          $show "${rm}r $gentop"
3461
          $run ${rm}r $gentop
3462
        fi
3463
 
3464
        # Create an invalid libtool object if no PIC, so that we don't
3465
        # accidentally link it into a program.
3466
        # $show "echo timestamp > $libobj"
3467
        # $run eval "echo timestamp > $libobj" || exit $?
3468
        exit 0
3469
      fi
3470
 
3471
      if test -n "$pic_flag" || test "$pic_mode" != default; then
3472
        # Only do commands if we really have different PIC objects.
3473
        reload_objs="$libobjs $reload_conv_objs"
3474
        output="$libobj"
3475
        eval cmds=\"$reload_cmds\"
3476
        IFS="${IFS=     }"; save_ifs="$IFS"; IFS='~'
3477
        for cmd in $cmds; do
3478
          IFS="$save_ifs"
3479
          $show "$cmd"
3480
          $run eval "$cmd" || exit $?
3481
        done
3482
        IFS="$save_ifs"
3483
#     else
3484
#       # Just create a symlink.
3485
#       $show $rm $libobj
3486
#       $run $rm $libobj
3487
#       xdir=`$echo "X$libobj" | $Xsed -e 's%/[^/]*$%%'`
3488
#       if test "X$xdir" = "X$libobj"; then
3489
#         xdir="."
3490
#       else
3491
#         xdir="$xdir"
3492
#       fi
3493
#       baseobj=`$echo "X$libobj" | $Xsed -e 's%^.*/%%'`
3494
#       oldobj=`$echo "X$baseobj" | $Xsed -e "$lo2o"`
3495
#       $show "(cd $xdir && $LN_S $oldobj $baseobj)"
3496
#       $run eval '(cd $xdir && $LN_S $oldobj $baseobj)' || exit $?
3497
      fi
3498
 
3499
      if test -n "$gentop"; then
3500
        $show "${rm}r $gentop"
3501
        $run ${rm}r $gentop
3502
      fi
3503
 
3504
      exit 0
3505
      ;;
3506
 
3507
    prog)
3508
      case $host in
3509
        *cygwin*) output=`echo $output | sed -e 's,.exe$,,;s,$,.exe,'` ;;
3510
      esac
3511
      if test -n "$vinfo"; then
3512
        $echo "$modename: warning: \`-version-info' is ignored for programs" 1>&2
3513
      fi
3514
 
3515
      if test -n "$release"; then
3516
        $echo "$modename: warning: \`-release' is ignored for programs" 1>&2
3517
      fi
3518
 
3519
      if test "$preload" = yes; then
3520
        if test "$dlopen_support" = unknown && test "$dlopen_self" = unknown &&
3521
           test "$dlopen_self_static" = unknown; then
3522
          $echo "$modename: warning: \`AC_LIBTOOL_DLOPEN' not used. Assuming no dlopen support."
3523
        fi
3524
      fi
3525
 
3526
      case $host in
3527
      *-*-rhapsody* | *-*-darwin1.[012])
3528
        # On Rhapsody replace the C library is the System framework
3529
        compile_deplibs=`$echo "X $compile_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
3530
        finalize_deplibs=`$echo "X $finalize_deplibs" | $Xsed -e 's/ -lc / -framework System /'`
3531
        ;;
3532
      esac
3533
 
3534
      compile_command="$compile_command $compile_deplibs"
3535
      finalize_command="$finalize_command $finalize_deplibs"
3536
 
3537
      if test -n "$rpath$xrpath"; then
3538
        # If the user specified any rpath flags, then add them.
3539
        for libdir in $rpath $xrpath; do
3540
          # This is the magic to use -rpath.
3541
          case "$finalize_rpath " in
3542
          *" $libdir "*) ;;
3543
          *) finalize_rpath="$finalize_rpath $libdir" ;;
3544
          esac
3545
        done
3546
      fi
3547
 
3548
      # Now hardcode the library paths
3549
      rpath=
3550
      hardcode_libdirs=
3551
      for libdir in $compile_rpath $finalize_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
            rpath="$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
        case $host in
3577
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
3578
          case :$dllsearchpath: in
3579
          *":$libdir:"*) ;;
3580
          *) dllsearchpath="$dllsearchpath:$libdir";;
3581
          esac
3582
          ;;
3583
        esac
3584
      done
3585
      # Substitute the hardcoded libdirs into the rpath.
3586
      if test -n "$hardcode_libdir_separator" &&
3587
         test -n "$hardcode_libdirs"; then
3588
        libdir="$hardcode_libdirs"
3589
        eval rpath=\" $hardcode_libdir_flag_spec\"
3590
      fi
3591
      compile_rpath="$rpath"
3592
 
3593
      rpath=
3594
      hardcode_libdirs=
3595
      for libdir in $finalize_rpath; do
3596
        if test -n "$hardcode_libdir_flag_spec"; then
3597
          if test -n "$hardcode_libdir_separator"; then
3598
            if test -z "$hardcode_libdirs"; then
3599
              hardcode_libdirs="$libdir"
3600
            else
3601
              # Just accumulate the unique libdirs.
3602
              case $hardcode_libdir_separator$hardcode_libdirs$hardcode_libdir_separator in
3603
              *"$hardcode_libdir_separator$libdir$hardcode_libdir_separator"*)
3604
                ;;
3605
              *)
3606
                hardcode_libdirs="$hardcode_libdirs$hardcode_libdir_separator$libdir"
3607
                ;;
3608
              esac
3609
            fi
3610
          else
3611
            eval flag=\"$hardcode_libdir_flag_spec\"
3612
            rpath="$rpath $flag"
3613
          fi
3614
        elif test -n "$runpath_var"; then
3615
          case "$finalize_perm_rpath " in
3616
          *" $libdir "*) ;;
3617
          *) finalize_perm_rpath="$finalize_perm_rpath $libdir" ;;
3618
          esac
3619
        fi
3620
      done
3621
      # Substitute the hardcoded libdirs into the rpath.
3622
      if test -n "$hardcode_libdir_separator" &&
3623
         test -n "$hardcode_libdirs"; then
3624
        libdir="$hardcode_libdirs"
3625
        eval rpath=\" $hardcode_libdir_flag_spec\"
3626
      fi
3627
      finalize_rpath="$rpath"
3628
 
3629
      dlsyms=
3630
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
3631
        if test -n "$NM" && test -n "$global_symbol_pipe"; then
3632
          dlsyms="${outputname}S.c"
3633
        else
3634
          $echo "$modename: not configured to extract global symbols from dlpreopened files" 1>&2
3635
        fi
3636
      fi
3637
 
3638
      if test -n "$dlsyms"; then
3639
        case $dlsyms in
3640
        "") ;;
3641
        *.c)
3642
          # Discover the nlist of each of the dlfiles.
3643
          nlist="$output_objdir/${outputname}.nm"
3644
 
3645
          $show "$rm $nlist ${nlist}S ${nlist}T"
3646
          $run $rm "$nlist" "${nlist}S" "${nlist}T"
3647
 
3648
          # Parse the name list into a source file.
3649
          $show "creating $output_objdir/$dlsyms"
3650
 
3651
          test -z "$run" && $echo > "$output_objdir/$dlsyms" "\
3652
/* $dlsyms - symbol resolution table for \`$outputname' dlsym emulation. */
3653
/* Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP */
3654
 
3655
#ifdef __cplusplus
3656
extern \"C\" {
3657
#endif
3658
 
3659
/* Prevent the only kind of declaration conflicts we can make. */
3660
#define lt_preloaded_symbols some_other_symbol
3661
 
3662
/* External symbol declarations for the compiler. */\
3663
"
3664
 
3665
          if test "$dlself" = yes; then
3666
            $show "generating symbol list for \`$output'"
3667
 
3668
            test -z "$run" && $echo ': @PROGRAM@ ' > "$nlist"
3669
 
3670
            # Add our own program objects to the symbol list.
3671
            progfiles="$objs$old_deplibs"
3672
            for arg in $progfiles; do
3673
              $show "extracting global C symbols from \`$arg'"
3674
              $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
3675
            done
3676
 
3677
            if test -n "$exclude_expsyms"; then
3678
              $run eval 'egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T'
3679
              $run eval '$mv "$nlist"T "$nlist"'
3680
            fi
3681
 
3682
            if test -n "$export_symbols_regex"; then
3683
              $run eval 'egrep -e "$export_symbols_regex" "$nlist" > "$nlist"T'
3684
              $run eval '$mv "$nlist"T "$nlist"'
3685
            fi
3686
 
3687
            # Prepare the list of exported symbols
3688
            if test -z "$export_symbols"; then
3689
              export_symbols="$output_objdir/$output.exp"
3690
              $run $rm $export_symbols
3691
              $run eval "sed -n -e '/^: @PROGRAM@$/d' -e 's/^.* \(.*\)$/\1/p' "'< "$nlist" > "$export_symbols"'
3692
            else
3693
              $run eval "sed -e 's/\([][.*^$]\)/\\\1/g' -e 's/^/ /' -e 's/$/$/'"' < "$export_symbols" > "$output_objdir/$output.exp"'
3694
              $run eval 'grep -f "$output_objdir/$output.exp" < "$nlist" > "$nlist"T'
3695
              $run eval 'mv "$nlist"T "$nlist"'
3696
            fi
3697
          fi
3698
 
3699
          for arg in $dlprefiles; do
3700
            $show "extracting global C symbols from \`$arg'"
3701
            name=`echo "$arg" | sed -e 's%^.*/%%'`
3702
            $run eval 'echo ": $name " >> "$nlist"'
3703
            $run eval "$NM $arg | $global_symbol_pipe >> '$nlist'"
3704
          done
3705
 
3706
          if test -z "$run"; then
3707
            # Make sure we have at least an empty file.
3708
            test -f "$nlist" || : > "$nlist"
3709
 
3710
            if test -n "$exclude_expsyms"; then
3711
              egrep -v " ($exclude_expsyms)$" "$nlist" > "$nlist"T
3712
              $mv "$nlist"T "$nlist"
3713
            fi
3714
 
3715
            # Try sorting and uniquifying the output.
3716
            if grep -v "^: " < "$nlist" | sort +2 | uniq > "$nlist"S; then
3717
              :
3718
            else
3719
              grep -v "^: " < "$nlist" > "$nlist"S
3720
            fi
3721
 
3722
            if test -f "$nlist"S; then
3723
              eval "$global_symbol_to_cdecl"' < "$nlist"S >> "$output_objdir/$dlsyms"'
3724
            else
3725
              echo '/* NONE */' >> "$output_objdir/$dlsyms"
3726
            fi
3727
 
3728
            $echo >> "$output_objdir/$dlsyms" "\
3729
 
3730
#undef lt_preloaded_symbols
3731
 
3732
#if defined (__STDC__) && __STDC__
3733
# define lt_ptr_t void *
3734
#else
3735
# define lt_ptr_t char *
3736
# define const
3737
#endif
3738
 
3739
/* The mapping between symbol names and symbols. */
3740
const struct {
3741
  const char *name;
3742
  lt_ptr_t address;
3743
}
3744
lt_preloaded_symbols[] =
3745
{\
3746
"
3747
 
3748
            sed -n -e 's/^: \([^ ]*\) $/  {\"\1\", (lt_ptr_t) 0},/p' \
3749
                -e 's/^. \([^ ]*\) \([^ ]*\)$/  {"\2", (lt_ptr_t) \&\2},/p' \
3750
                  < "$nlist" >> "$output_objdir/$dlsyms"
3751
 
3752
            $echo >> "$output_objdir/$dlsyms" "\
3753
  {0, (lt_ptr_t) 0}
3754
};
3755
 
3756
/* This works around a problem in FreeBSD linker */
3757
#ifdef FREEBSD_WORKAROUND
3758
static const void *lt_preloaded_setup() {
3759
  return lt_preloaded_symbols;
3760
}
3761
#endif
3762
 
3763
#ifdef __cplusplus
3764
}
3765
#endif\
3766
"
3767
          fi
3768
 
3769
          pic_flag_for_symtable=
3770
          case $host in
3771
          # compiling the symbol table file with pic_flag works around
3772
          # a FreeBSD bug that causes programs to crash when -lm is
3773
          # linked before any other PIC object.  But we must not use
3774
          # pic_flag when linking with -static.  The problem exists in
3775
          # FreeBSD 2.2.6 and is fixed in FreeBSD 3.1.
3776
          *-*-freebsd2*|*-*-freebsd3.0*|*-*-freebsdelf3.0*)
3777
            case "$compile_command " in
3778
            *" -static "*) ;;
3779
            *) pic_flag_for_symtable=" $pic_flag -DFREEBSD_WORKAROUND";;
3780
            esac;;
3781
          *-*-hpux*)
3782
            case "$compile_command " in
3783
            *" -static "*) ;;
3784
            *) pic_flag_for_symtable=" $pic_flag";;
3785
            esac
3786
          esac
3787
 
3788
          # Now compile the dynamic symbol file.
3789
          $show "(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable \"$dlsyms\")"
3790
          $run eval '(cd $output_objdir && $LTCC -c$no_builtin_flag$pic_flag_for_symtable "$dlsyms")' || exit $?
3791
 
3792
          # Clean up the generated files.
3793
          $show "$rm $output_objdir/$dlsyms $nlist ${nlist}S ${nlist}T"
3794
          $run $rm "$output_objdir/$dlsyms" "$nlist" "${nlist}S" "${nlist}T"
3795
 
3796
          # Transform the symbol file into the correct name.
3797
          compile_command=`$echo "X$compile_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
3798
          finalize_command=`$echo "X$finalize_command" | $Xsed -e "s%@SYMFILE@%$output_objdir/${outputname}S.${objext}%"`
3799
          ;;
3800
        *)
3801
          $echo "$modename: unknown suffix for \`$dlsyms'" 1>&2
3802
          exit 1
3803
          ;;
3804
        esac
3805
      else
3806
        # We keep going just in case the user didn't refer to
3807
        # lt_preloaded_symbols.  The linker will fail if global_symbol_pipe
3808
        # really was required.
3809
 
3810
        # Nullify the symbol file.
3811
        compile_command=`$echo "X$compile_command" | $Xsed -e "s% @SYMFILE@%%"`
3812
        finalize_command=`$echo "X$finalize_command" | $Xsed -e "s% @SYMFILE@%%"`
3813
      fi
3814
 
3815
      if test $need_relink = no || test "$build_libtool_libs" != yes; then
3816
        # Replace the output file specification.
3817
        compile_command=`$echo "X$compile_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
3818
        link_command="$compile_command$compile_rpath"
3819
 
3820
        # We have no uninstalled library dependencies, so finalize right now.
3821
        $show "$link_command"
3822
        $run eval "$link_command"
3823
        status=$?
3824
 
3825
        # Delete the generated files.
3826
        if test -n "$dlsyms"; then
3827
          $show "$rm $output_objdir/${outputname}S.${objext}"
3828
          $run $rm "$output_objdir/${outputname}S.${objext}"
3829
        fi
3830
 
3831
        exit $status
3832
      fi
3833
 
3834
      if test -n "$shlibpath_var"; then
3835
        # We should set the shlibpath_var
3836
        rpath=
3837
        for dir in $temp_rpath; do
3838
          case $dir in
3839
          [\\/]* | [A-Za-z]:[\\/]*)
3840
            # Absolute path.
3841
            rpath="$rpath$dir:"
3842
            ;;
3843
          *)
3844
            # Relative path: add a thisdir entry.
3845
            rpath="$rpath\$thisdir/$dir:"
3846
            ;;
3847
          esac
3848
        done
3849
        temp_rpath="$rpath"
3850
      fi
3851
 
3852
      if test -n "$compile_shlibpath$finalize_shlibpath"; then
3853
        compile_command="$shlibpath_var=\"$compile_shlibpath$finalize_shlibpath\$$shlibpath_var\" $compile_command"
3854
      fi
3855
      if test -n "$finalize_shlibpath"; then
3856
        finalize_command="$shlibpath_var=\"$finalize_shlibpath\$$shlibpath_var\" $finalize_command"
3857
      fi
3858
 
3859
      compile_var=
3860
      finalize_var=
3861
      if test -n "$runpath_var"; then
3862
        if test -n "$perm_rpath"; then
3863
          # We should set the runpath_var.
3864
          rpath=
3865
          for dir in $perm_rpath; do
3866
            rpath="$rpath$dir:"
3867
          done
3868
          compile_var="$runpath_var=\"$rpath\$$runpath_var\" "
3869
        fi
3870
        if test -n "$finalize_perm_rpath"; then
3871
          # We should set the runpath_var.
3872
          rpath=
3873
          for dir in $finalize_perm_rpath; do
3874
            rpath="$rpath$dir:"
3875
          done
3876
          finalize_var="$runpath_var=\"$rpath\$$runpath_var\" "
3877
        fi
3878
      fi
3879
 
3880
      if test "$no_install" = yes; then
3881
        # We don't need to create a wrapper script.
3882
        link_command="$compile_var$compile_command$compile_rpath"
3883
        # Replace the output file specification.
3884
        link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output"'%g'`
3885
        # Delete the old output file.
3886
        $run $rm $output
3887
        # Link the executable and exit
3888
        $show "$link_command"
3889
        $run eval "$link_command" || exit $?
3890
        exit 0
3891
      fi
3892
 
3893
      if test "$hardcode_action" = relink; then
3894
        # Fast installation is not supported
3895
        link_command="$compile_var$compile_command$compile_rpath"
3896
        relink_command="$finalize_var$finalize_command$finalize_rpath"
3897
 
3898
        $echo "$modename: warning: this platform does not like uninstalled shared libraries" 1>&2
3899
        $echo "$modename: \`$output' will be relinked during installation" 1>&2
3900
      else
3901
        if test "$fast_install" != no; then
3902
          link_command="$finalize_var$compile_command$finalize_rpath"
3903
          if test "$fast_install" = yes; then
3904
            relink_command=`$echo "X$compile_var$compile_command$compile_rpath" | $Xsed -e 's%@OUTPUT@%\$progdir/\$file%g'`
3905
          else
3906
            # fast_install is set to needless
3907
            relink_command=
3908
          fi
3909
        else
3910
          link_command="$compile_var$compile_command$compile_rpath"
3911
          relink_command="$finalize_var$finalize_command$finalize_rpath"
3912
        fi
3913
      fi
3914
 
3915
      # Replace the output file specification.
3916
      link_command=`$echo "X$link_command" | $Xsed -e 's%@OUTPUT@%'"$output_objdir/$outputname"'%g'`
3917
 
3918
      # Delete the old output files.
3919
      $run $rm $output $output_objdir/$outputname $output_objdir/lt-$outputname
3920
 
3921
      $show "$link_command"
3922
      $run eval "$link_command" || exit $?
3923
 
3924
      # Now create the wrapper script.
3925
      $show "creating $output"
3926
 
3927
      # Quote the relink command for shipping.
3928
      if test -n "$relink_command"; then
3929
        # Preserve any variables that may affect compiler behavior
3930
        for var in $variables_saved_for_relink; do
3931
          if eval test -z \"\${$var+set}\"; then
3932
            relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
3933
          elif eval var_value=\$$var; test -z "$var_value"; then
3934
            relink_command="$var=; export $var; $relink_command"
3935
          else
3936
            var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
3937
            relink_command="$var=\"$var_value\"; export $var; $relink_command"
3938
          fi
3939
        done
3940
        relink_command="cd `pwd`; $relink_command"
3941
        relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
3942
      fi
3943
 
3944
      # Quote $echo for shipping.
3945
      if test "X$echo" = "X$SHELL $0 --fallback-echo"; then
3946
        case $0 in
3947
        [\\/]* | [A-Za-z]:[\\/]*) qecho="$SHELL $0 --fallback-echo";;
3948
        *) qecho="$SHELL `pwd`/$0 --fallback-echo";;
3949
        esac
3950
        qecho=`$echo "X$qecho" | $Xsed -e "$sed_quote_subst"`
3951
      else
3952
        qecho=`$echo "X$echo" | $Xsed -e "$sed_quote_subst"`
3953
      fi
3954
 
3955
      # Only actually do things if our run command is non-null.
3956
      if test -z "$run"; then
3957
        # win32 will think the script is a binary if it has
3958
        # a .exe suffix, so we strip it off here.
3959
        case $output in
3960
          *.exe) output=`echo $output|sed 's,.exe$,,'` ;;
3961
        esac
3962
        # test for cygwin because mv fails w/o .exe extensions
3963
        case $host in
3964
          *cygwin*) exeext=.exe ;;
3965
          *) exeext= ;;
3966
        esac
3967
        $rm $output
3968
        trap "$rm $output; exit 1" 1 2 15
3969
 
3970
        $echo > $output "\
3971
#! $SHELL
3972
 
3973
# $output - temporary wrapper script for $objdir/$outputname
3974
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
3975
#
3976
# The $output program cannot be directly executed until all the libtool
3977
# libraries that it depends on are installed.
3978
#
3979
# This wrapper script should never be moved out of the build directory.
3980
# If it is, it will not operate correctly.
3981
 
3982
# Sed substitution that helps us do robust quoting.  It backslashifies
3983
# metacharacters that are still active within double-quoted strings.
3984
Xsed='sed -e 1s/^X//'
3985
sed_quote_subst='$sed_quote_subst'
3986
 
3987
# The HP-UX ksh and POSIX shell print the target directory to stdout
3988
# if CDPATH is set.
3989
if test \"\${CDPATH+set}\" = set; then CDPATH=:; export CDPATH; fi
3990
 
3991
relink_command=\"$relink_command\"
3992
 
3993
# This environment variable determines our operation mode.
3994
if test \"\$libtool_install_magic\" = \"$magic\"; then
3995
  # install mode needs the following variable:
3996
  notinst_deplibs='$notinst_deplibs'
3997
else
3998
  # When we are sourced in execute mode, \$file and \$echo are already set.
3999
  if test \"\$libtool_execute_magic\" != \"$magic\"; then
4000
    echo=\"$qecho\"
4001
    file=\"\$0\"
4002
    # Make sure echo works.
4003
    if test \"X\$1\" = X--no-reexec; then
4004
      # Discard the --no-reexec flag, and continue.
4005
      shift
4006
    elif test \"X\`(\$echo '\t') 2>/dev/null\`\" = 'X\t'; then
4007
      # Yippee, \$echo works!
4008
      :
4009
    else
4010
      # Restart under the correct shell, and then maybe \$echo will work.
4011
      exec $SHELL \"\$0\" --no-reexec \${1+\"\$@\"}
4012
    fi
4013
  fi\
4014
"
4015
        $echo >> $output "\
4016
 
4017
  # Find the directory that this script lives in.
4018
  thisdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*$%%'\`
4019
  test \"x\$thisdir\" = \"x\$file\" && thisdir=.
4020
 
4021
  # Follow symbolic links until we get to the real thisdir.
4022
  file=\`ls -ld \"\$file\" | sed -n 's/.*-> //p'\`
4023
  while test -n \"\$file\"; do
4024
    destdir=\`\$echo \"X\$file\" | \$Xsed -e 's%/[^/]*\$%%'\`
4025
 
4026
    # If there was a directory component, then change thisdir.
4027
    if test \"x\$destdir\" != \"x\$file\"; then
4028
      case \"\$destdir\" in
4029
      [\\\\/]* | [A-Za-z]:[\\\\/]*) thisdir=\"\$destdir\" ;;
4030
      *) thisdir=\"\$thisdir/\$destdir\" ;;
4031
      esac
4032
    fi
4033
 
4034
    file=\`\$echo \"X\$file\" | \$Xsed -e 's%^.*/%%'\`
4035
    file=\`ls -ld \"\$thisdir/\$file\" | sed -n 's/.*-> //p'\`
4036
  done
4037
 
4038
  # Try to get the absolute directory name.
4039
  absdir=\`cd \"\$thisdir\" && pwd\`
4040
  test -n \"\$absdir\" && thisdir=\"\$absdir\"
4041
"
4042
 
4043
        if test "$fast_install" = yes; then
4044
          echo >> $output "\
4045
  program=lt-'$outputname'$exeext
4046
  progdir=\"\$thisdir/$objdir\"
4047
 
4048
  if test ! -f \"\$progdir/\$program\" || \\
4049
     { file=\`ls -1dt \"\$progdir/\$program\" \"\$progdir/../\$program\" 2>/dev/null | sed 1q\`; \\
4050
       test \"X\$file\" != \"X\$progdir/\$program\"; }; then
4051
 
4052
    file=\"\$\$-\$program\"
4053
 
4054
    if test ! -d \"\$progdir\"; then
4055
      $mkdir \"\$progdir\"
4056
    else
4057
      $rm \"\$progdir/\$file\"
4058
    fi"
4059
 
4060
          echo >> $output "\
4061
 
4062
    # relink executable if necessary
4063
    if test -n \"\$relink_command\"; then
4064
      if relink_command_output=\`eval \$relink_command 2>&1\`; then :
4065
      else
4066
        $echo \"\$relink_command_output\" >&2
4067
        $rm \"\$progdir/\$file\"
4068
        exit 1
4069
      fi
4070
    fi
4071
 
4072
    $mv \"\$progdir/\$file\" \"\$progdir/\$program\" 2>/dev/null ||
4073
    { $rm \"\$progdir/\$program\";
4074
      $mv \"\$progdir/\$file\" \"\$progdir/\$program\"; }
4075
    $rm \"\$progdir/\$file\"
4076
  fi"
4077
        else
4078
          echo >> $output "\
4079
  program='$outputname'
4080
  progdir=\"\$thisdir/$objdir\"
4081
"
4082
        fi
4083
 
4084
        echo >> $output "\
4085
 
4086
  if test -f \"\$progdir/\$program\"; then"
4087
 
4088
        # Export our shlibpath_var if we have one.
4089
        if test "$shlibpath_overrides_runpath" = yes && test -n "$shlibpath_var" && test -n "$temp_rpath"; then
4090
          $echo >> $output "\
4091
    # Add our own library path to $shlibpath_var
4092
    $shlibpath_var=\"$temp_rpath\$$shlibpath_var\"
4093
 
4094
    # Some systems cannot cope with colon-terminated $shlibpath_var
4095
    # The second colon is a workaround for a bug in BeOS R4 sed
4096
    $shlibpath_var=\`\$echo \"X\$$shlibpath_var\" | \$Xsed -e 's/::*\$//'\`
4097
 
4098
    export $shlibpath_var
4099
"
4100
        fi
4101
 
4102
        # fixup the dll searchpath if we need to.
4103
        if test -n "$dllsearchpath"; then
4104
          $echo >> $output "\
4105
    # Add the dll search path components to the executable PATH
4106
    PATH=$dllsearchpath:\$PATH
4107
"
4108
        fi
4109
 
4110
        $echo >> $output "\
4111
    if test \"\$libtool_execute_magic\" != \"$magic\"; then
4112
      # Run the actual program with our arguments.
4113
"
4114
        case $host in
4115
        # win32 systems need to use the prog path for dll
4116
        # lookup to work
4117
        *-*-cygwin* | *-*-pw32*)
4118
          $echo >> $output "\
4119
      exec \$progdir/\$program \${1+\"\$@\"}
4120
"
4121
          ;;
4122
 
4123
        # Backslashes separate directories on plain windows
4124
        *-*-mingw | *-*-os2*)
4125
          $echo >> $output "\
4126
      exec \$progdir\\\\\$program \${1+\"\$@\"}
4127
"
4128
          ;;
4129
 
4130
        *)
4131
          $echo >> $output "\
4132
      # Export the path to the program.
4133
      PATH=\"\$progdir:\$PATH\"
4134
      export PATH
4135
 
4136
      exec \$program \${1+\"\$@\"}
4137
"
4138
          ;;
4139
        esac
4140
        $echo >> $output "\
4141
      \$echo \"\$0: cannot exec \$program \${1+\"\$@\"}\"
4142
      exit 1
4143
    fi
4144
  else
4145
    # The program doesn't exist.
4146
    \$echo \"\$0: error: \$progdir/\$program does not exist\" 1>&2
4147
    \$echo \"This script is just a wrapper for \$program.\" 1>&2
4148
    echo \"See the $PACKAGE documentation for more information.\" 1>&2
4149
    exit 1
4150
  fi
4151
fi\
4152
"
4153
        chmod +x $output
4154
      fi
4155
      exit 0
4156
      ;;
4157
    esac
4158
 
4159
    # See if we need to build an old-fashioned archive.
4160
    for oldlib in $oldlibs; do
4161
 
4162
      if test "$build_libtool_libs" = convenience; then
4163
        oldobjs="$libobjs_save"
4164
        addlibs="$convenience"
4165
        build_libtool_libs=no
4166
      else
4167
        if test "$build_libtool_libs" = module; then
4168
          oldobjs="$libobjs_save"
4169
          build_libtool_libs=no
4170
        else
4171
          oldobjs="$objs$old_deplibs $non_pic_objects"
4172
        fi
4173
        addlibs="$old_convenience"
4174
      fi
4175
 
4176
      if test -n "$addlibs"; then
4177
        gentop="$output_objdir/${outputname}x"
4178
        $show "${rm}r $gentop"
4179
        $run ${rm}r "$gentop"
4180
        $show "$mkdir $gentop"
4181
        $run $mkdir "$gentop"
4182
        status=$?
4183
        if test $status -ne 0 && test ! -d "$gentop"; then
4184
          exit $status
4185
        fi
4186
        generated="$generated $gentop"
4187
 
4188
        # Add in members from convenience archives.
4189
        for xlib in $addlibs; do
4190
          # Extract the objects.
4191
          case $xlib in
4192
          [\\/]* | [A-Za-z]:[\\/]*) xabs="$xlib" ;;
4193
          *) xabs=`pwd`"/$xlib" ;;
4194
          esac
4195
          xlib=`$echo "X$xlib" | $Xsed -e 's%^.*/%%'`
4196
          xdir="$gentop/$xlib"
4197
 
4198
          $show "${rm}r $xdir"
4199
          $run ${rm}r "$xdir"
4200
          $show "$mkdir $xdir"
4201
          $run $mkdir "$xdir"
4202
          status=$?
4203
          if test $status -ne 0 && test ! -d "$xdir"; then
4204
            exit $status
4205
          fi
4206
          $show "(cd $xdir && $AR x $xabs)"
4207
          $run eval "(cd \$xdir && $AR x \$xabs)" || exit $?
4208
 
4209
          oldobjs="$oldobjs "`find $xdir -name \*.${objext} -print | $NL2SP`
4210
        done
4211
      fi
4212
 
4213
      # Do each command in the archive commands.
4214
      if test -n "$old_archive_from_new_cmds" && test "$build_libtool_libs" = yes; then
4215
        eval cmds=\"$old_archive_from_new_cmds\"
4216
      else
4217
#       # Ensure that we have .o objects in place in case we decided
4218
#       # not to build a shared library, and have fallen back to building
4219
#       # static libs even though --disable-static was passed!
4220
#       for oldobj in $oldobjs; do
4221
#         if test ! -f $oldobj; then
4222
#           xdir=`$echo "X$oldobj" | $Xsed -e 's%/[^/]*$%%'`
4223
#           if test "X$xdir" = "X$oldobj"; then
4224
#             xdir="."
4225
#           else
4226
#             xdir="$xdir"
4227
#           fi
4228
#           baseobj=`$echo "X$oldobj" | $Xsed -e 's%^.*/%%'`
4229
#           obj=`$echo "X$baseobj" | $Xsed -e "$o2lo"`
4230
#           $show "(cd $xdir && ${LN_S} $obj $baseobj)"
4231
#           $run eval '(cd $xdir && ${LN_S} $obj $baseobj)' || exit $?
4232
#         fi
4233
#       done
4234
 
4235
        eval cmds=\"$old_archive_cmds\"
4236
 
4237
        if len=`expr "X$cmds" : ".*"` &&
4238
             test $len -le $max_cmd_len; then
4239
          :
4240
        else
4241
          # the command line is too long to link in one step, link in parts
4242
          $echo "using piecewise archive linking..."
4243
          save_RANLIB=$RANLIB
4244
          RANLIB=:
4245
          objlist=
4246
          concat_cmds=
4247
          save_oldobjs=$oldobjs
4248
          for obj in $save_oldobjs
4249
          do
4250
            oldobjs="$objlist $obj"
4251
            objlist="$objlist $obj"
4252
            eval test_cmds=\"$old_archive_cmds\"
4253
            if len=`expr "X$test_cmds" : ".*"` &&
4254
               test $len -le $max_cmd_len; then
4255
              :
4256
            else
4257
              # the above command should be used before it gets too long
4258
              oldobjs=$objlist
4259
              test -z "$concat_cmds" || concat_cmds=$concat_cmds~
4260
              eval concat_cmds=\"\${concat_cmds}$old_archive_cmds\"
4261
              objlist=
4262
            fi
4263
          done
4264
          RANLIB=$save_RANLIB
4265
          oldobjs=$objlist
4266
          eval cmds=\"\$concat_cmds~$old_archive_cmds\"
4267
        fi
4268
      fi
4269
      IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
4270
      for cmd in $cmds; do
4271
        IFS="$save_ifs"
4272
        $show "$cmd"
4273
        $run eval "$cmd" || exit $?
4274
      done
4275
      IFS="$save_ifs"
4276
    done
4277
 
4278
    if test -n "$generated"; then
4279
      $show "${rm}r$generated"
4280
      $run ${rm}r$generated
4281
    fi
4282
 
4283
    # Now create the libtool archive.
4284
    case $output in
4285
    *.la)
4286
      old_library=
4287
      test "$build_old_libs" = yes && old_library="$libname.$libext"
4288
      $show "creating $output"
4289
 
4290
      # Preserve any variables that may affect compiler behavior
4291
      for var in $variables_saved_for_relink; do
4292
        if eval test -z \"\${$var+set}\"; then
4293
          relink_command="{ test -z \"\${$var+set}\" || unset $var || { $var=; export $var; }; }; $relink_command"
4294
        elif eval var_value=\$$var; test -z "$var_value"; then
4295
          relink_command="$var=; export $var; $relink_command"
4296
        else
4297
          var_value=`$echo "X$var_value" | $Xsed -e "$sed_quote_subst"`
4298
          relink_command="$var=\"$var_value\"; export $var; $relink_command"
4299
        fi
4300
      done
4301
      # Quote the link command for shipping.
4302
      relink_command="cd `pwd`; $SHELL $0 --mode=relink $libtool_args"
4303
      relink_command=`$echo "X$relink_command" | $Xsed -e "$sed_quote_subst"`
4304
 
4305
      # Only create the output if not a dry run.
4306
      if test -z "$run"; then
4307
        for installed in no yes; do
4308
          if test "$installed" = yes; then
4309
            if test -z "$install_libdir"; then
4310
              break
4311
            fi
4312
            output="$output_objdir/$outputname"i
4313
            # Replace all uninstalled libtool libraries with the installed ones
4314
            newdependency_libs=
4315
            for deplib in $dependency_libs; do
4316
              case $deplib in
4317
              *.la)
4318
                name=`$echo "X$deplib" | $Xsed -e 's%^.*/%%'`
4319
                eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
4320
                if test -z "$libdir"; then
4321
                  $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
4322
                  exit 1
4323
                fi
4324
                newdependency_libs="$newdependency_libs $libdir/$name"
4325
                ;;
4326
              *) newdependency_libs="$newdependency_libs $deplib" ;;
4327
              esac
4328
            done
4329
            dependency_libs="$newdependency_libs"
4330
            newdlfiles=
4331
            for lib in $dlfiles; do
4332
              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
4333
              eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
4334
              if test -z "$libdir"; then
4335
                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
4336
                exit 1
4337
              fi
4338
              newdlfiles="$newdlfiles $libdir/$name"
4339
            done
4340
            dlfiles="$newdlfiles"
4341
            newdlprefiles=
4342
            for lib in $dlprefiles; do
4343
              name=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
4344
              eval libdir=`sed -n -e 's/^libdir=\(.*\)$/\1/p' $lib`
4345
              if test -z "$libdir"; then
4346
                $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
4347
                exit 1
4348
              fi
4349
              newdlprefiles="$newdlprefiles $libdir/$name"
4350
            done
4351
            dlprefiles="$newdlprefiles"
4352
          fi
4353
          $rm $output
4354
          # place dlname in correct position for cygwin
4355
          tdlname=$dlname
4356
          case $host,$output,$installed,$module,$dlname in
4357
            *cygwin*,*lai,yes,no,*.dll) tdlname=../bin/$dlname ;;
4358
          esac
4359
          $echo > $output "\
4360
# $outputname - a libtool library file
4361
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
4362
#
4363
# Please DO NOT delete this file!
4364
# It is necessary for linking the library.
4365
 
4366
# The name that we can dlopen(3).
4367
dlname='$tdlname'
4368
 
4369
# Names of this library.
4370
library_names='$library_names'
4371
 
4372
# The name of the static archive.
4373
old_library='$old_library'
4374
 
4375
# Libraries that this one depends upon.
4376
dependency_libs='$dependency_libs'
4377
 
4378
# Version information for $libname.
4379
current=$current
4380
age=$age
4381
revision=$revision
4382
 
4383
# Is this an already installed library?
4384
installed=$installed
4385
 
4386
# Files to dlopen/dlpreopen
4387
dlopen='$dlfiles'
4388
dlpreopen='$dlprefiles'
4389
 
4390
# Directory that this library needs to be installed in:
4391
libdir='$install_libdir'"
4392
          if test "$installed" = no && test $need_relink = yes; then
4393
            $echo >> $output "\
4394
relink_command=\"$relink_command\""
4395
          fi
4396
        done
4397
      fi
4398
 
4399
      # Do a symbolic link so that the libtool archive can be found in
4400
      # LD_LIBRARY_PATH before the program is installed.
4401
      $show "(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)"
4402
      $run eval '(cd $output_objdir && $rm $outputname && $LN_S ../$outputname $outputname)' || exit $?
4403
      ;;
4404
    esac
4405
    exit 0
4406
    ;;
4407
 
4408
  # libtool install mode
4409
  install)
4410
    modename="$modename: install"
4411
 
4412
    # There may be an optional sh(1) argument at the beginning of
4413
    # install_prog (especially on Windows NT).
4414
    if test "$nonopt" = "$SHELL" || test "$nonopt" = /bin/sh ||
4415
       # Allow the use of GNU shtool's install command.
4416
       $echo "X$nonopt" | $Xsed | grep shtool > /dev/null; then
4417
      # Aesthetically quote it.
4418
      arg=`$echo "X$nonopt" | $Xsed -e "$sed_quote_subst"`
4419
      case $arg in
4420
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
4421
        arg="\"$arg\""
4422
        ;;
4423
      esac
4424
      install_prog="$arg "
4425
      arg="$1"
4426
      shift
4427
    else
4428
      install_prog=
4429
      arg="$nonopt"
4430
    fi
4431
 
4432
    # The real first argument should be the name of the installation program.
4433
    # Aesthetically quote it.
4434
    arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
4435
    case $arg in
4436
    *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*)
4437
      arg="\"$arg\""
4438
      ;;
4439
    esac
4440
    install_prog="$install_prog$arg"
4441
 
4442
    # We need to accept at least all the BSD install flags.
4443
    dest=
4444
    files=
4445
    opts=
4446
    prev=
4447
    install_type=
4448
    isdir=no
4449
    stripme=
4450
    for arg
4451
    do
4452
      if test -n "$dest"; then
4453
        files="$files $dest"
4454
        dest="$arg"
4455
        continue
4456
      fi
4457
 
4458
      case $arg in
4459
      -d) isdir=yes ;;
4460
      -f) prev="-f" ;;
4461
      -g) prev="-g" ;;
4462
      -m) prev="-m" ;;
4463
      -o) prev="-o" ;;
4464
      -s)
4465
        stripme=" -s"
4466
        continue
4467
        ;;
4468
      -*) ;;
4469
 
4470
      *)
4471
        # If the previous option needed an argument, then skip it.
4472
        if test -n "$prev"; then
4473
          prev=
4474
        else
4475
          dest="$arg"
4476
          continue
4477
        fi
4478
        ;;
4479
      esac
4480
 
4481
      # Aesthetically quote the argument.
4482
      arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
4483
      case $arg in
4484
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*)
4485
        arg="\"$arg\""
4486
        ;;
4487
      esac
4488
      install_prog="$install_prog $arg"
4489
    done
4490
 
4491
    if test -z "$install_prog"; then
4492
      $echo "$modename: you must specify an install program" 1>&2
4493
      $echo "$help" 1>&2
4494
      exit 1
4495
    fi
4496
 
4497
    if test -n "$prev"; then
4498
      $echo "$modename: the \`$prev' option requires an argument" 1>&2
4499
      $echo "$help" 1>&2
4500
      exit 1
4501
    fi
4502
 
4503
    if test -z "$files"; then
4504
      if test -z "$dest"; then
4505
        $echo "$modename: no file or destination specified" 1>&2
4506
      else
4507
        $echo "$modename: you must specify a destination" 1>&2
4508
      fi
4509
      $echo "$help" 1>&2
4510
      exit 1
4511
    fi
4512
 
4513
    # Strip any trailing slash from the destination.
4514
    dest=`$echo "X$dest" | $Xsed -e 's%/$%%'`
4515
 
4516
    # Check to see that the destination is a directory.
4517
    test -d "$dest" && isdir=yes
4518
    if test "$isdir" = yes; then
4519
      destdir="$dest"
4520
      destname=
4521
    else
4522
      destdir=`$echo "X$dest" | $Xsed -e 's%/[^/]*$%%'`
4523
      test "X$destdir" = "X$dest" && destdir=.
4524
      destname=`$echo "X$dest" | $Xsed -e 's%^.*/%%'`
4525
 
4526
      # Not a directory, so check to see that there is only one file specified.
4527
      set dummy $files
4528
      if test $# -gt 2; then
4529
        $echo "$modename: \`$dest' is not a directory" 1>&2
4530
        $echo "$help" 1>&2
4531
        exit 1
4532
      fi
4533
    fi
4534
    case $destdir in
4535
    [\\/]* | [A-Za-z]:[\\/]*) ;;
4536
    *)
4537
      for file in $files; do
4538
        case $file in
4539
        *.lo) ;;
4540
        *)
4541
          $echo "$modename: \`$destdir' must be an absolute directory name" 1>&2
4542
          $echo "$help" 1>&2
4543
          exit 1
4544
          ;;
4545
        esac
4546
      done
4547
      ;;
4548
    esac
4549
 
4550
    # This variable tells wrapper scripts just to set variables rather
4551
    # than running their programs.
4552
    libtool_install_magic="$magic"
4553
 
4554
    staticlibs=
4555
    future_libdirs=
4556
    current_libdirs=
4557
    for file in $files; do
4558
 
4559
      # Do each installation.
4560
      case $file in
4561
      *.$libext)
4562
        # Do the static libraries later.
4563
        staticlibs="$staticlibs $file"
4564
        ;;
4565
 
4566
      *.la)
4567
        # Check to see that this really is a libtool archive.
4568
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
4569
        else
4570
          $echo "$modename: \`$file' is not a valid libtool archive" 1>&2
4571
          $echo "$help" 1>&2
4572
          exit 1
4573
        fi
4574
 
4575
        library_names=
4576
        old_library=
4577
        relink_command=
4578
        # If there is no directory component, then add one.
4579
        case $file in
4580
        */* | *\\*) . $file ;;
4581
        *) . ./$file ;;
4582
        esac
4583
 
4584
        # Add the libdir to current_libdirs if it is the destination.
4585
        if test "X$destdir" = "X$libdir"; then
4586
          case "$current_libdirs " in
4587
          *" $libdir "*) ;;
4588
          *) current_libdirs="$current_libdirs $libdir" ;;
4589
          esac
4590
        else
4591
          # Note the libdir as a future libdir.
4592
          case "$future_libdirs " in
4593
          *" $libdir "*) ;;
4594
          *) future_libdirs="$future_libdirs $libdir" ;;
4595
          esac
4596
        fi
4597
 
4598
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`/
4599
        test "X$dir" = "X$file/" && dir=
4600
        dir="$dir$objdir"
4601
 
4602
        if test -n "$relink_command"; then
4603
          $echo "$modename: warning: relinking \`$file'" 1>&2
4604
          $show "$relink_command"
4605
          if $run eval "$relink_command"; then :
4606
          else
4607
            $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
4608
            continue
4609
          fi
4610
        fi
4611
 
4612
        # See the names of the shared library.
4613
        set dummy $library_names
4614
        if test -n "$2"; then
4615
          realname="$2"
4616
          shift
4617
          shift
4618
 
4619
          srcname="$realname"
4620
          test -n "$relink_command" && srcname="$realname"T
4621
 
4622
          # Install the shared library and build the symlinks.
4623
          $show "$install_prog $dir/$srcname $destdir/$realname"
4624
          $run eval "$install_prog $dir/$srcname $destdir/$realname" || exit $?
4625
          if test -n "$stripme" && test -n "$striplib"; then
4626
            $show "$striplib $destdir/$realname"
4627
            $run eval "$striplib $destdir/$realname" || exit $?
4628
          fi
4629
 
4630
          if test $# -gt 0; then
4631
            # Delete the old symlinks, and create new ones.
4632
            for linkname
4633
            do
4634
              if test "$linkname" != "$realname"; then
4635
                $show "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
4636
                $run eval "(cd $destdir && $rm $linkname && $LN_S $realname $linkname)"
4637
              fi
4638
            done
4639
          fi
4640
 
4641
          # Do each command in the postinstall commands.
4642
          lib="$destdir/$realname"
4643
          eval cmds=\"$postinstall_cmds\"
4644
          IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
4645
          for cmd in $cmds; do
4646
            IFS="$save_ifs"
4647
            $show "$cmd"
4648
            $run eval "$cmd" || exit $?
4649
          done
4650
          IFS="$save_ifs"
4651
        fi
4652
 
4653
        # Install the pseudo-library for information purposes.
4654
        name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4655
        instname="$dir/$name"i
4656
        $show "$install_prog $instname $destdir/$name"
4657
        $run eval "$install_prog $instname $destdir/$name" || exit $?
4658
 
4659
        # Maybe install the static library, too.
4660
        test -n "$old_library" && staticlibs="$staticlibs $dir/$old_library"
4661
        ;;
4662
 
4663
      *.lo)
4664
        # Install (i.e. copy) a libtool object.
4665
 
4666
        # Figure out destination file name, if it wasn't already specified.
4667
        if test -n "$destname"; then
4668
          destfile="$destdir/$destname"
4669
        else
4670
          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4671
          destfile="$destdir/$destfile"
4672
        fi
4673
 
4674
        # Deduce the name of the destination old-style object file.
4675
        case $destfile in
4676
        *.lo)
4677
          staticdest=`$echo "X$destfile" | $Xsed -e "$lo2o"`
4678
          ;;
4679
        *.$objext)
4680
          staticdest="$destfile"
4681
          destfile=
4682
          ;;
4683
        *)
4684
          $echo "$modename: cannot copy a libtool object to \`$destfile'" 1>&2
4685
          $echo "$help" 1>&2
4686
          exit 1
4687
          ;;
4688
        esac
4689
 
4690
        # Install the libtool object if requested.
4691
        if test -n "$destfile"; then
4692
          $show "$install_prog $file $destfile"
4693
          $run eval "$install_prog $file $destfile" || exit $?
4694
        fi
4695
 
4696
        # Install the old object if enabled.
4697
        if test "$build_old_libs" = yes; then
4698
          # Deduce the name of the old-style object file.
4699
          staticobj=`$echo "X$file" | $Xsed -e "$lo2o"`
4700
 
4701
          $show "$install_prog $staticobj $staticdest"
4702
          $run eval "$install_prog \$staticobj \$staticdest" || exit $?
4703
        fi
4704
        exit 0
4705
        ;;
4706
 
4707
      *)
4708
        # Figure out destination file name, if it wasn't already specified.
4709
        if test -n "$destname"; then
4710
          destfile="$destdir/$destname"
4711
        else
4712
          destfile=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4713
          destfile="$destdir/$destfile"
4714
        fi
4715
 
4716
        # Do a test to see if this is really a libtool program.
4717
        if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
4718
          notinst_deplibs=
4719
          relink_command=
4720
 
4721
          # If there is no directory component, then add one.
4722
          case $file in
4723
          */* | *\\*) . $file ;;
4724
          *) . ./$file ;;
4725
          esac
4726
 
4727
          # Check the variables that should have been set.
4728
          if test -z "$notinst_deplibs"; then
4729
            $echo "$modename: invalid libtool wrapper script \`$file'" 1>&2
4730
            exit 1
4731
          fi
4732
 
4733
          finalize=yes
4734
          for lib in $notinst_deplibs; do
4735
            # Check to see that each library is installed.
4736
            libdir=
4737
            if test -f "$lib"; then
4738
              # If there is no directory component, then add one.
4739
              case $lib in
4740
              */* | *\\*) . $lib ;;
4741
              *) . ./$lib ;;
4742
              esac
4743
            fi
4744
            libfile="$libdir/"`$echo "X$lib" | $Xsed -e 's%^.*/%%g'` ### testsuite: skip nested quoting test
4745
            if test -n "$libdir" && test ! -f "$libfile"; then
4746
              $echo "$modename: warning: \`$lib' has not been installed in \`$libdir'" 1>&2
4747
              finalize=no
4748
            fi
4749
          done
4750
 
4751
          relink_command=
4752
          # If there is no directory component, then add one.
4753
          case $file in
4754
          */* | *\\*) . $file ;;
4755
          *) . ./$file ;;
4756
          esac
4757
 
4758
          outputname=
4759
          if test "$fast_install" = no && test -n "$relink_command"; then
4760
            if test "$finalize" = yes && test -z "$run"; then
4761
              tmpdir="/tmp"
4762
              test -n "$TMPDIR" && tmpdir="$TMPDIR"
4763
              tmpdir="$tmpdir/libtool-$$"
4764
              if $mkdir -p "$tmpdir" && chmod 700 "$tmpdir"; then :
4765
              else
4766
                $echo "$modename: error: cannot create temporary directory \`$tmpdir'" 1>&2
4767
                continue
4768
              fi
4769
              file=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4770
              outputname="$tmpdir/$file"
4771
              # Replace the output file specification.
4772
              relink_command=`$echo "X$relink_command" | $Xsed -e 's%@OUTPUT@%'"$outputname"'%g'`
4773
 
4774
              $show "$relink_command"
4775
              if $run eval "$relink_command"; then :
4776
              else
4777
                $echo "$modename: error: relink \`$file' with the above command before installing it" 1>&2
4778
                ${rm}r "$tmpdir"
4779
                continue
4780
              fi
4781
              file="$outputname"
4782
            else
4783
              $echo "$modename: warning: cannot relink \`$file'" 1>&2
4784
            fi
4785
          else
4786
            # Install the binary that we compiled earlier.
4787
            file=`$echo "X$file" | $Xsed -e "s%\([^/]*\)$%$objdir/\1%"`
4788
          fi
4789
        fi
4790
 
4791
 
4792
        # remove .exe since cygwin /usr/bin/install will append another
4793
        # one anyways
4794
        case $install_prog,$host in
4795
        */usr/bin/install*,*cygwin*)
4796
          case $file:$destfile in
4797
          *.exe:*.exe)
4798
            # this is ok
4799
            ;;
4800
          *.exe:*)
4801
            destfile=$destfile.exe
4802
            ;;
4803
          *:*.exe)
4804
            destfile=`echo $destfile | sed -e 's,.exe$,,'`
4805
            ;;
4806
          esac
4807
          ;;
4808
        esac
4809
 
4810
        $show "$install_prog$stripme $file $destfile"
4811
        $run eval "$install_prog\$stripme \$file \$destfile" || exit $?
4812
        test -n "$outputname" && ${rm}r "$tmpdir"
4813
        ;;
4814
      esac
4815
    done
4816
 
4817
    for file in $staticlibs; do
4818
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
4819
 
4820
      # Set up the ranlib parameters.
4821
      oldlib="$destdir/$name"
4822
 
4823
      $show "$install_prog $file $oldlib"
4824
      $run eval "$install_prog \$file \$oldlib" || exit $?
4825
 
4826
      if test -n "$stripme" && test -n "$striplib"; then
4827
        $show "$old_striplib $oldlib"
4828
        $run eval "$old_striplib $oldlib" || exit $?
4829
      fi
4830
 
4831
      # Do each command in the postinstall commands.
4832
      eval cmds=\"$old_postinstall_cmds\"
4833
      IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
4834
      for cmd in $cmds; do
4835
        IFS="$save_ifs"
4836
        $show "$cmd"
4837
        $run eval "$cmd" || exit $?
4838
      done
4839
      IFS="$save_ifs"
4840
    done
4841
 
4842
    if test -n "$future_libdirs"; then
4843
      $echo "$modename: warning: remember to run \`$progname --finish$future_libdirs'" 1>&2
4844
    fi
4845
 
4846
    if test -n "$current_libdirs"; then
4847
      # Maybe just do a dry run.
4848
      test -n "$run" && current_libdirs=" -n$current_libdirs"
4849
      exec_cmd='$SHELL $0 --finish$current_libdirs'
4850
    else
4851
      exit 0
4852
    fi
4853
    ;;
4854
 
4855
  # libtool finish mode
4856
  finish)
4857
    modename="$modename: finish"
4858
    libdirs="$nonopt"
4859
    admincmds=
4860
 
4861
    if test -n "$finish_cmds$finish_eval" && test -n "$libdirs"; then
4862
      for dir
4863
      do
4864
        libdirs="$libdirs $dir"
4865
      done
4866
 
4867
      for libdir in $libdirs; do
4868
        if test -n "$finish_cmds"; then
4869
          # Do each command in the finish commands.
4870
          eval cmds=\"$finish_cmds\"
4871
          IFS="${IFS=   }"; save_ifs="$IFS"; IFS='~'
4872
          for cmd in $cmds; do
4873
            IFS="$save_ifs"
4874
            $show "$cmd"
4875
            $run eval "$cmd" || admincmds="$admincmds
4876
       $cmd"
4877
          done
4878
          IFS="$save_ifs"
4879
        fi
4880
        if test -n "$finish_eval"; then
4881
          # Do the single finish_eval.
4882
          eval cmds=\"$finish_eval\"
4883
          $run eval "$cmds" || admincmds="$admincmds
4884
       $cmds"
4885
        fi
4886
      done
4887
    fi
4888
 
4889
    # Exit here if they wanted silent mode.
4890
    test "$show" = ":" && exit 0
4891
 
4892
    echo "----------------------------------------------------------------------"
4893
    echo "Libraries have been installed in:"
4894
    for libdir in $libdirs; do
4895
      echo "   $libdir"
4896
    done
4897
    echo
4898
    echo "If you ever happen to want to link against installed libraries"
4899
    echo "in a given directory, LIBDIR, you must either use libtool, and"
4900
    echo "specify the full pathname of the library, or use the \`-LLIBDIR'"
4901
    echo "flag during linking and do at least one of the following:"
4902
    if test -n "$shlibpath_var"; then
4903
      echo "   - add LIBDIR to the \`$shlibpath_var' environment variable"
4904
      echo "     during execution"
4905
    fi
4906
    if test -n "$runpath_var"; then
4907
      echo "   - add LIBDIR to the \`$runpath_var' environment variable"
4908
      echo "     during linking"
4909
    fi
4910
    if test -n "$hardcode_libdir_flag_spec"; then
4911
      libdir=LIBDIR
4912
      eval flag=\"$hardcode_libdir_flag_spec\"
4913
 
4914
      echo "   - use the \`$flag' linker flag"
4915
    fi
4916
    if test -n "$admincmds"; then
4917
      echo "   - have your system administrator run these commands:$admincmds"
4918
    fi
4919
    if test -f /etc/ld.so.conf; then
4920
      echo "   - have your system administrator add LIBDIR to \`/etc/ld.so.conf'"
4921
    fi
4922
    echo
4923
    echo "See any operating system documentation about shared libraries for"
4924
    echo "more information, such as the ld(1) and ld.so(8) manual pages."
4925
    echo "----------------------------------------------------------------------"
4926
    exit 0
4927
    ;;
4928
 
4929
  # libtool execute mode
4930
  execute)
4931
    modename="$modename: execute"
4932
 
4933
    # The first argument is the command name.
4934
    cmd="$nonopt"
4935
    if test -z "$cmd"; then
4936
      $echo "$modename: you must specify a COMMAND" 1>&2
4937
      $echo "$help"
4938
      exit 1
4939
    fi
4940
 
4941
    # Handle -dlopen flags immediately.
4942
    for file in $execute_dlfiles; do
4943
      if test ! -f "$file"; then
4944
        $echo "$modename: \`$file' is not a file" 1>&2
4945
        $echo "$help" 1>&2
4946
        exit 1
4947
      fi
4948
 
4949
      dir=
4950
      case $file in
4951
      *.la)
4952
        # Check to see that this really is a libtool archive.
4953
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
4954
        else
4955
          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
4956
          $echo "$help" 1>&2
4957
          exit 1
4958
        fi
4959
 
4960
        # Read the libtool library.
4961
        dlname=
4962
        library_names=
4963
 
4964
        # If there is no directory component, then add one.
4965
        case $file in
4966
        */* | *\\*) . $file ;;
4967
        *) . ./$file ;;
4968
        esac
4969
 
4970
        # Skip this library if it cannot be dlopened.
4971
        if test -z "$dlname"; then
4972
          # Warn if it was a shared library.
4973
          test -n "$library_names" && $echo "$modename: warning: \`$file' was not linked with \`-export-dynamic'"
4974
          continue
4975
        fi
4976
 
4977
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
4978
        test "X$dir" = "X$file" && dir=.
4979
 
4980
        if test -f "$dir/$objdir/$dlname"; then
4981
          dir="$dir/$objdir"
4982
        else
4983
          $echo "$modename: cannot find \`$dlname' in \`$dir' or \`$dir/$objdir'" 1>&2
4984
          exit 1
4985
        fi
4986
        ;;
4987
 
4988
      *.lo)
4989
        # Just add the directory containing the .lo file.
4990
        dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
4991
        test "X$dir" = "X$file" && dir=.
4992
        ;;
4993
 
4994
      *)
4995
        $echo "$modename: warning \`-dlopen' is ignored for non-libtool libraries and objects" 1>&2
4996
        continue
4997
        ;;
4998
      esac
4999
 
5000
      # Get the absolute pathname.
5001
      absdir=`cd "$dir" && pwd`
5002
      test -n "$absdir" && dir="$absdir"
5003
 
5004
      # Now add the directory to shlibpath_var.
5005
      if eval "test -z \"\$$shlibpath_var\""; then
5006
        eval "$shlibpath_var=\"\$dir\""
5007
      else
5008
        eval "$shlibpath_var=\"\$dir:\$$shlibpath_var\""
5009
      fi
5010
    done
5011
 
5012
    # This variable tells wrapper scripts just to set shlibpath_var
5013
    # rather than running their programs.
5014
    libtool_execute_magic="$magic"
5015
 
5016
    # Check if any of the arguments is a wrapper script.
5017
    args=
5018
    for file
5019
    do
5020
      case $file in
5021
      -*) ;;
5022
      *)
5023
        # Do a test to see if this is really a libtool program.
5024
        if (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5025
          # If there is no directory component, then add one.
5026
          case $file in
5027
          */* | *\\*) . $file ;;
5028
          *) . ./$file ;;
5029
          esac
5030
 
5031
          # Transform arg to wrapped name.
5032
          file="$progdir/$program"
5033
        fi
5034
        ;;
5035
      esac
5036
      # Quote arguments (to preserve shell metacharacters).
5037
      file=`$echo "X$file" | $Xsed -e "$sed_quote_subst"`
5038
      args="$args \"$file\""
5039
    done
5040
 
5041
    if test -z "$run"; then
5042
      if test -n "$shlibpath_var"; then
5043
        # Export the shlibpath_var.
5044
        eval "export $shlibpath_var"
5045
      fi
5046
 
5047
      # Restore saved enviroment variables
5048
      if test "${save_LC_ALL+set}" = set; then
5049
        LC_ALL="$save_LC_ALL"; export LC_ALL
5050
      fi
5051
      if test "${save_LANG+set}" = set; then
5052
        LANG="$save_LANG"; export LANG
5053
      fi
5054
 
5055
      # Now prepare to actually exec the command.
5056
      exec_cmd='"$cmd"$args'
5057
    else
5058
      # Display what would be done.
5059
      if test -n "$shlibpath_var"; then
5060
        eval "\$echo \"\$shlibpath_var=\$$shlibpath_var\""
5061
        $echo "export $shlibpath_var"
5062
      fi
5063
      $echo "$cmd$args"
5064
      exit 0
5065
    fi
5066
    ;;
5067
 
5068
  # libtool clean and uninstall mode
5069
  clean | uninstall)
5070
    modename="$modename: $mode"
5071
    rm="$nonopt"
5072
    files=
5073
    rmforce=
5074
    exit_status=0
5075
 
5076
    # This variable tells wrapper scripts just to set variables rather
5077
    # than running their programs.
5078
    libtool_install_magic="$magic"
5079
 
5080
    for arg
5081
    do
5082
      case $arg in
5083
      -f) rm="$rm $arg"; rmforce=yes ;;
5084
      -*) rm="$rm $arg" ;;
5085
      *) files="$files $arg" ;;
5086
      esac
5087
    done
5088
 
5089
    if test -z "$rm"; then
5090
      $echo "$modename: you must specify an RM program" 1>&2
5091
      $echo "$help" 1>&2
5092
      exit 1
5093
    fi
5094
 
5095
    rmdirs=
5096
 
5097
    for file in $files; do
5098
      dir=`$echo "X$file" | $Xsed -e 's%/[^/]*$%%'`
5099
      if test "X$dir" = "X$file"; then
5100
        dir=.
5101
        objdir="$objdir"
5102
      else
5103
        objdir="$dir/$objdir"
5104
      fi
5105
      name=`$echo "X$file" | $Xsed -e 's%^.*/%%'`
5106
      test $mode = uninstall && objdir="$dir"
5107
 
5108
      # Remember objdir for removal later, being careful to avoid duplicates
5109
      if test $mode = clean; then
5110
        case " $rmdirs " in
5111
          *" $objdir "*) ;;
5112
          *) rmdirs="$rmdirs $objdir" ;;
5113
        esac
5114
      fi
5115
 
5116
      # Don't error if the file doesn't exist and rm -f was used.
5117
      if (test -L "$file") >/dev/null 2>&1 \
5118
        || (test -h "$file") >/dev/null 2>&1 \
5119
        || test -f "$file"; then
5120
        :
5121
      elif test -d "$file"; then
5122
        exit_status=1
5123
        continue
5124
      elif test "$rmforce" = yes; then
5125
        continue
5126
      fi
5127
 
5128
      rmfiles="$file"
5129
 
5130
      case $name in
5131
      *.la)
5132
        # Possibly a libtool archive, so verify it.
5133
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5134
          . $dir/$name
5135
 
5136
          # Delete the libtool libraries and symlinks.
5137
          for n in $library_names; do
5138
            rmfiles="$rmfiles $objdir/$n"
5139
          done
5140
          test -n "$old_library" && rmfiles="$rmfiles $objdir/$old_library"
5141
          test $mode = clean && rmfiles="$rmfiles $objdir/$name $objdir/${name}i"
5142
 
5143
          if test $mode = uninstall; then
5144
            if test -n "$library_names"; then
5145
              # Do each command in the postuninstall commands.
5146
              eval cmds=\"$postuninstall_cmds\"
5147
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
5148
              for cmd in $cmds; do
5149
                IFS="$save_ifs"
5150
                $show "$cmd"
5151
                $run eval "$cmd"
5152
                if test $? != 0 && test "$rmforce" != yes; then
5153
                  exit_status=1
5154
                fi
5155
              done
5156
              IFS="$save_ifs"
5157
            fi
5158
 
5159
            if test -n "$old_library"; then
5160
              # Do each command in the old_postuninstall commands.
5161
              eval cmds=\"$old_postuninstall_cmds\"
5162
              IFS="${IFS=       }"; save_ifs="$IFS"; IFS='~'
5163
              for cmd in $cmds; do
5164
                IFS="$save_ifs"
5165
                $show "$cmd"
5166
                $run eval "$cmd"
5167
                if test $? != 0 && test "$rmforce" != yes; then
5168
                  exit_status=1
5169
                fi
5170
              done
5171
              IFS="$save_ifs"
5172
            fi
5173
            # FIXME: should reinstall the best remaining shared library.
5174
          fi
5175
        fi
5176
        ;;
5177
 
5178
      *.lo)
5179
        # Possibly a libtool object, so verify it.
5180
        if (sed -e '2q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5181
 
5182
          # Read the .lo file
5183
          . $dir/$name
5184
 
5185
          # Add PIC object to the list of files to remove.
5186
          if test -n "$pic_object" \
5187
             && test "$pic_object" != none; then
5188
            rmfiles="$rmfiles $dir/$pic_object"
5189
          fi
5190
 
5191
          # Add non-PIC object to the list of files to remove.
5192
          if test -n "$non_pic_object" \
5193
             && test "$non_pic_object" != none; then
5194
            rmfiles="$rmfiles $dir/$non_pic_object"
5195
          fi
5196
        fi
5197
        ;;
5198
 
5199
      *)
5200
        # Do a test to see if this is a libtool program.
5201
        if test $mode = clean &&
5202
           (sed -e '4q' $file | egrep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
5203
          relink_command=
5204
          . $dir/$file
5205
 
5206
          rmfiles="$rmfiles $objdir/$name $objdir/${name}S.${objext}"
5207
          if test "$fast_install" = yes && test -n "$relink_command"; then
5208
            rmfiles="$rmfiles $objdir/lt-$name"
5209
          fi
5210
        fi
5211
        ;;
5212
      esac
5213
      $show "$rm $rmfiles"
5214
      $run $rm $rmfiles || exit_status=1
5215
    done
5216
 
5217
    # Try to remove the ${objdir}s in the directories where we deleted files
5218
    for dir in $rmdirs; do
5219
      if test -d "$dir"; then
5220
        $show "rmdir $dir"
5221
        $run rmdir $dir >/dev/null 2>&1
5222
      fi
5223
    done
5224
 
5225
    exit $exit_status
5226
    ;;
5227
 
5228
  "")
5229
    $echo "$modename: you must specify a MODE" 1>&2
5230
    $echo "$generic_help" 1>&2
5231
    exit 1
5232
    ;;
5233
  esac
5234
 
5235
  if test -z "$exec_cmd"; then
5236
    $echo "$modename: invalid operation mode \`$mode'" 1>&2
5237
    $echo "$generic_help" 1>&2
5238
    exit 1
5239
  fi
5240
fi # test -z "$show_help"
5241
 
5242
if test -n "$exec_cmd"; then
5243
  eval exec $exec_cmd
5244
  exit 1
5245
fi
5246
 
5247
# We need to display help for each of the modes.
5248
case $mode in
5249
"") $echo \
5250
"Usage: $modename [OPTION]... [MODE-ARG]...
5251
 
5252
Provide generalized library-building support services.
5253
 
5254
    --config          show all configuration variables
5255
    --debug           enable verbose shell tracing
5256
-n, --dry-run         display commands without modifying any files
5257
    --features        display basic configuration information and exit
5258
    --finish          same as \`--mode=finish'
5259
    --help            display this help message and exit
5260
    --mode=MODE       use operation mode MODE [default=inferred from MODE-ARGS]
5261
    --quiet           same as \`--silent'
5262
    --silent          don't print informational messages
5263
    --tag=TAG         use configuration variables from tag TAG
5264
    --version         print version information
5265
 
5266
MODE must be one of the following:
5267
 
5268
      clean           remove files from the build directory
5269
      compile         compile a source file into a libtool object
5270
      execute         automatically set library path, then run a program
5271
      finish          complete the installation of libtool libraries
5272
      install         install libraries or executables
5273
      link            create a library or an executable
5274
      uninstall       remove libraries from an installed directory
5275
 
5276
MODE-ARGS vary depending on the MODE.  Try \`$modename --help --mode=MODE' for
5277
a more detailed description of MODE."
5278
  exit 0
5279
  ;;
5280
 
5281
clean)
5282
  $echo \
5283
"Usage: $modename [OPTION]... --mode=clean RM [RM-OPTION]... FILE...
5284
 
5285
Remove files from the build directory.
5286
 
5287
RM is the name of the program to use to delete files associated with each FILE
5288
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
5289
to RM.
5290
 
5291
If FILE is a libtool library, object or program, all the files associated
5292
with it are deleted. Otherwise, only FILE itself is deleted using RM."
5293
  ;;
5294
 
5295
compile)
5296
  $echo \
5297
"Usage: $modename [OPTION]... --mode=compile COMPILE-COMMAND... SOURCEFILE
5298
 
5299
Compile a source file into a libtool library object.
5300
 
5301
This mode accepts the following additional options:
5302
 
5303
  -o OUTPUT-FILE    set the output file name to OUTPUT-FILE
5304
  -prefer-pic       try to building PIC objects only
5305
  -prefer-non-pic   try to building non-PIC objects only
5306
  -static           always build a \`.o' file suitable for static linking
5307
 
5308
COMPILE-COMMAND is a command to be used in creating a \`standard' object file
5309
from the given SOURCEFILE.
5310
 
5311
The output file name is determined by removing the directory component from
5312
SOURCEFILE, then substituting the C source code suffix \`.c' with the
5313
library object suffix, \`.lo'."
5314
  ;;
5315
 
5316
execute)
5317
  $echo \
5318
"Usage: $modename [OPTION]... --mode=execute COMMAND [ARGS]...
5319
 
5320
Automatically set library path, then run a program.
5321
 
5322
This mode accepts the following additional options:
5323
 
5324
  -dlopen FILE      add the directory containing FILE to the library path
5325
 
5326
This mode sets the library path environment variable according to \`-dlopen'
5327
flags.
5328
 
5329
If any of the ARGS are libtool executable wrappers, then they are translated
5330
into their corresponding uninstalled binary, and any of their required library
5331
directories are added to the library path.
5332
 
5333
Then, COMMAND is executed, with ARGS as arguments."
5334
  ;;
5335
 
5336
finish)
5337
  $echo \
5338
"Usage: $modename [OPTION]... --mode=finish [LIBDIR]...
5339
 
5340
Complete the installation of libtool libraries.
5341
 
5342
Each LIBDIR is a directory that contains libtool libraries.
5343
 
5344
The commands that this mode executes may require superuser privileges.  Use
5345
the \`--dry-run' option if you just want to see what would be executed."
5346
  ;;
5347
 
5348
install)
5349
  $echo \
5350
"Usage: $modename [OPTION]... --mode=install INSTALL-COMMAND...
5351
 
5352
Install executables or libraries.
5353
 
5354
INSTALL-COMMAND is the installation command.  The first component should be
5355
either the \`install' or \`cp' program.
5356
 
5357
The rest of the components are interpreted as arguments to that command (only
5358
BSD-compatible install options are recognized)."
5359
  ;;
5360
 
5361
link)
5362
  $echo \
5363
"Usage: $modename [OPTION]... --mode=link LINK-COMMAND...
5364
 
5365
Link object files or libraries together to form another library, or to
5366
create an executable program.
5367
 
5368
LINK-COMMAND is a command using the C compiler that you would use to create
5369
a program from several object files.
5370
 
5371
The following components of LINK-COMMAND are treated specially:
5372
 
5373
  -all-static       do not do any dynamic linking at all
5374
  -avoid-version    do not add a version suffix if possible
5375
  -dlopen FILE      \`-dlpreopen' FILE if it cannot be dlopened at runtime
5376
  -dlpreopen FILE   link in FILE and add its symbols to lt_preloaded_symbols
5377
  -export-dynamic   allow symbols from OUTPUT-FILE to be resolved with dlsym(3)
5378
  -export-symbols SYMFILE
5379
                    try to export only the symbols listed in SYMFILE
5380
  -export-symbols-regex REGEX
5381
                    try to export only the symbols matching REGEX
5382
  -LLIBDIR          search LIBDIR for required installed libraries
5383
  -lNAME            OUTPUT-FILE requires the installed library libNAME
5384
  -module           build a library that can dlopened
5385
  -no-fast-install  disable the fast-install mode
5386
  -no-install       link a not-installable executable
5387
  -no-undefined     declare that a library does not refer to external symbols
5388
  -o OUTPUT-FILE    create OUTPUT-FILE from the specified objects
5389
  -objectlist FILE  Use a list of object files found in FILE to specify objects
5390
  -release RELEASE  specify package release information
5391
  -rpath LIBDIR     the created library will eventually be installed in LIBDIR
5392
  -R[ ]LIBDIR       add LIBDIR to the runtime path of programs and libraries
5393
  -static           do not do any dynamic linking of libtool libraries
5394
  -version-info CURRENT[:REVISION[:AGE]]
5395
                    specify library version info [each variable defaults to 0]
5396
 
5397
All other options (arguments beginning with \`-') are ignored.
5398
 
5399
Every other argument is treated as a filename.  Files ending in \`.la' are
5400
treated as uninstalled libtool libraries, other files are standard or library
5401
object files.
5402
 
5403
If the OUTPUT-FILE ends in \`.la', then a libtool library is created,
5404
only library objects (\`.lo' files) may be specified, and \`-rpath' is
5405
required, except when creating a convenience library.
5406
 
5407
If OUTPUT-FILE ends in \`.a' or \`.lib', then a standard library is created
5408
using \`ar' and \`ranlib', or on Windows using \`lib'.
5409
 
5410
If OUTPUT-FILE ends in \`.lo' or \`.${objext}', then a reloadable object file
5411
is created, otherwise an executable program is created."
5412
  ;;
5413
 
5414
uninstall)
5415
  $echo \
5416
"Usage: $modename [OPTION]... --mode=uninstall RM [RM-OPTION]... FILE...
5417
 
5418
Remove libraries from an installation directory.
5419
 
5420
RM is the name of the program to use to delete files associated with each FILE
5421
(typically \`/bin/rm').  RM-OPTIONS are options (such as \`-f') to be passed
5422
to RM.
5423
 
5424
If FILE is a libtool library, all the files associated with it are deleted.
5425
Otherwise, only FILE itself is deleted using RM."
5426
  ;;
5427
 
5428
*)
5429
  $echo "$modename: invalid operation mode \`$mode'" 1>&2
5430
  $echo "$help" 1>&2
5431
  exit 1
5432
  ;;
5433
esac
5434
 
5435
echo
5436
$echo "Try \`$modename --help' for more information about other modes."
5437
 
5438
exit 0
5439
 
5440
# The TAGs below are defined such that we never get into a situation
5441
# in which we disable both kinds of libraries.  Given conflicting
5442
# choices, we go for a static library, that is the most portable,
5443
# since we can't tell whether shared libraries were disabled because
5444
# the user asked for that or because the platform doesn't support
5445
# them.  This is particularly important on AIX, because we don't
5446
# support having both static and shared libraries enabled at the same
5447
# time on that platform, so we default to a shared-only configuration.
5448
# If a disable-shared tag is given, we'll fallback to a static-only
5449
# configuration.  But we'll never go from static-only to shared-only.
5450
 
5451
### BEGIN LIBTOOL TAG CONFIG: disable-shared
5452
build_libtool_libs=no
5453
build_old_libs=yes
5454
### END LIBTOOL TAG CONFIG: disable-shared
5455
 
5456
### BEGIN LIBTOOL TAG CONFIG: disable-static
5457
build_old_libs=`case $build_libtool_libs in yes) echo no;; *) echo yes;; esac`
5458
### END LIBTOOL TAG CONFIG: disable-static
5459
 
5460
# Local Variables:
5461
# mode:shell-script
5462
# sh-indentation:2
5463
# End:

powered by: WebSVN 2.1.0

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