OpenCores
URL https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk

Subversion Repositories openrisc_2011-10-31

[/] [openrisc/] [trunk/] [gnu-src/] [gcc-4.2.2/] [ltmain.sh] - Blame information for rev 310

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

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

powered by: WebSVN 2.1.0

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