Subversion Repositories Scribus

Rev

Rev 599 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
3 paul 1
# ltmain.sh - Provide generalized library-building support services.
599 cbradney 2
# NOTE: Changing this file will not affect anything until you rerun configure.
3 paul 3
#
599 cbradney 4
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2003
3 paul 5
# Free Software Foundation, Inc.
6
# Originally by Gordon Matzigkeit <gord@gnu.ai.mit.edu>, 1996
7
#
8
# This program is free software; you can redistribute it and/or modify
9
# it under the terms of the GNU General Public License as published by
10
# the Free Software Foundation; either version 2 of the License, or
11
# (at your option) any later version.
12
#
13
# This program is distributed in the hope that it will be useful, but
14
# WITHOUT ANY WARRANTY; without even the implied warranty of
15
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
16
# General Public License for more details.
17
#
18
# You should have received a copy of the GNU General Public License
19
# along with this program; if not, write to the Free Software
20
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
21
#
22
# As a special exception to the GNU General Public License, if you
23
# distribute this file as part of a program that contains a
24
# configuration script generated by Autoconf, you may include it under
25
# the same distribution terms that you use for the rest of that program.
26
 
27
# Check that we have a working $echo.
28
if test "X$1" = X--no-reexec; then
29
  # Discard the --no-reexec flag, and continue.
30
  shift
31
elif test "X$1" = X--fallback-echo; then
32
  # Avoid inline document here, it may be left over
33
  :
34
elif test "X`($echo '\t') 2>/dev/null`" = 'X\t'; then
35
  # Yippee, $echo works!
36
  :
37
else
38
  # Restart under the correct shell, and then maybe $echo will work.
39
  exec $SHELL "$0" --no-reexec ${1+"$@"}
40
fi
41
 
42
if test "X$1" = X--fallback-echo; then
43
  # used as fallback echo
44
  shift
45
  cat <<EOF
46
$*
47
EOF
48
  exit 0
49
fi
50
 
51
# The name of this program.
599 cbradney 52
progname=`$echo "$0" | ${SED} 's%^.*/%%'`
3 paul 53
modename="$progname"
54
 
55
# Constants.
56
PROGRAM=ltmain.sh
57
PACKAGE=libtool
599 cbradney 58
VERSION=1.5a
59
TIMESTAMP=" (1.1240 2003/06/26 06:55:19)"
3 paul 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.
599 cbradney 70
Xsed="${SED}"' -e 1s/^X//'
3 paul 71
sed_quote_subst='s/\([\\`\\"$\\\\]\)/\\\1/g'
599 cbradney 72
# test EBCDIC or ASCII
73
case `echo A|tr A '\301'` in
74
 A) # EBCDIC based system
75
  SP2NL="tr '\100' '\n'"
76
  NL2SP="tr '\r\n' '\100\100'"
77
  ;;
78
 *) # Assume ASCII based system
79
  SP2NL="tr '\040' '\012'"
80
  NL2SP="tr '\015\012' '\040\040'"
81
  ;;
82
esac
3 paul 83
 
84
# NLS nuisances.
85
# Only set LANG and LC_ALL to C if already set.
86
# These must not be set unconditionally because not all systems understand
87
# e.g. LANG=C (notably SCO).
88
# We save the old values to restore during execute mode.
89
if test "${LC_ALL+set}" = set; then
90
  save_LC_ALL="$LC_ALL"; LC_ALL=C; export LC_ALL
91
fi
92
if test "${LANG+set}" = set; then
93
  save_LANG="$LANG"; LANG=C; export LANG
94
fi
95
 
599 cbradney 96
# Make sure IFS has a sensible default
97
: ${IFS="       "}
3 paul 98
 
99
if test "$build_libtool_libs" != yes && test "$build_old_libs" != yes; then
599 cbradney 100
  $echo "$modename: not configured to build any kind of library" 1>&2
101
  $echo "Fatal configuration error.  See the $PACKAGE docs for more information." 1>&2
3 paul 102
  exit 1
103
fi
104
 
105
# Global variables.
106
mode=$default_mode
107
nonopt=
108
prev=
109
prevopt=
110
run=
111
show="$echo"
112
show_help=
113
execute_dlfiles=
114
lo2o="s/\\.lo\$/.${objext}/"
115
o2lo="s/\\.${objext}\$/.lo/"
116
 
599 cbradney 117
#####################################
118
# Shell function definitions:
119
# This seems to be the best place for them
120
 
121
# Need a lot of goo to handle *both* DLLs and import libs
122
# Has to be a shell function in order to 'eat' the argument
123
# that is supplied when $file_magic_command is called.
124
win32_libid () {
125
  win32_libid_type="unknown"
126
  win32_fileres=`file -L $1 2>/dev/null`
127
  case $win32_fileres in
128
  *ar\ archive\ import\ library*) # definitely import
129
    win32_libid_type="x86 archive import"
130
    ;;
131
  *ar\ archive*) # could be an import, or static
132
    if eval $OBJDUMP -f $1 | $SED -e '10q' 2>/dev/null | \
133
      grep -E 'file format pe-i386(.*architecture: i386)?' >/dev/null ; then
134
      win32_nmres=`eval $NM -f posix -A $1 | \
135
        sed -n -e '1,100{/ I /{x;/import/!{s/^/import/;h;p;};x;};}'`
136
      if test "X$win32_nmres" = "Ximport" ; then
137
        win32_libid_type="x86 archive import"
138
      else
139
        win32_libid_type="x86 archive static"
140
      fi
141
    fi
142
    ;;
143
  *DLL*)
144
    win32_libid_type="x86 DLL"
145
    ;;
146
  *executable*) # but shell scripts are "executable" too...
147
    case $win32_fileres in
148
    *MS\ Windows\ PE\ Intel*)
149
      win32_libid_type="x86 DLL"
150
      ;;
151
    esac
152
    ;;
153
  esac
154
  $echo $win32_libid_type
155
}
156
 
157
# End of Shell function definitions
158
#####################################
159
 
3 paul 160
# Parse our command line options once, thoroughly.
599 cbradney 161
while test "$#" -gt 0
3 paul 162
do
163
  arg="$1"
164
  shift
165
 
166
  case $arg in
167
  -*=*) optarg=`$echo "X$arg" | $Xsed -e 's/[-_a-zA-Z0-9]*=//'` ;;
168
  *) optarg= ;;
169
  esac
170
 
171
  # If the previous option needs an argument, assign it.
172
  if test -n "$prev"; then
173
    case $prev in
174
    execute_dlfiles)
175
      execute_dlfiles="$execute_dlfiles $arg"
176
      ;;
177
    tag)
178
      tagname="$arg"
179
 
180
      # Check whether tagname contains only valid characters
181
      case $tagname in
182
      *[!-_A-Za-z0-9,/]*)
599 cbradney 183
        $echo "$progname: invalid tag name: $tagname" 1>&2
3 paul 184
        exit 1
599 cbradney 185
        ;;
3 paul 186
      esac
187
 
599 cbradney 188
      case $tagname in
189
      CC)
190
        # Don't test for the "default" C tag, as we know, it's there, but
191
        # not specially marked.
192
        ;;
193
      *)
194
        if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$" < "$0" > /dev/null; then
195
          taglist="$taglist $tagname"
196
          # Evaluate the configuration.
197
          eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$tagname'$/,/^# ### END LIBTOOL TAG CONFIG: '$tagname'$/p' < $0`"
198
        else
199
          $echo "$progname: ignoring unknown tag $tagname" 1>&2
200
        fi
201
        ;;
202
      esac
3 paul 203
      ;;
204
    *)
205
      eval "$prev=\$arg"
206
      ;;
207
    esac
208
 
209
    prev=
210
    prevopt=
211
    continue
212
  fi
213
 
214
  # Have we seen a non-optional argument yet?
215
  case $arg in
216
  --help)
217
    show_help=yes
218
    ;;
219
 
220
  --version)
599 cbradney 221
    $echo "$PROGRAM (GNU $PACKAGE) $VERSION$TIMESTAMP"
222
    $echo
223
    $echo "Copyright (C) 2003  Free Software Foundation, Inc."
224
    $echo "This is free software; see the source for copying conditions.  There is NO"
225
    $echo "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE."
3 paul 226
    exit 0
227
    ;;
228
 
229
  --config)
599 cbradney 230
    ${SED} -e '1,/^# ### BEGIN LIBTOOL CONFIG/d' -e '/^# ### END LIBTOOL CONFIG/,$d' $0
3 paul 231
    # Now print the configurations for the tags.
232
    for tagname in $taglist; do
599 cbradney 233
      ${SED} -n -e "/^# ### BEGIN LIBTOOL TAG CONFIG: $tagname$/,/^# ### END LIBTOOL TAG CONFIG: $tagname$/p" < "$0"
3 paul 234
    done
235
    exit 0
236
    ;;
237
 
238
  --debug)
599 cbradney 239
    $echo "$progname: enabling shell trace mode"
3 paul 240
    set -x
241
    ;;
242
 
243
  --dry-run | -n)
244
    run=:
245
    ;;
246
 
247
  --features)
599 cbradney 248
    $echo "host: $host"
3 paul 249
    if test "$build_libtool_libs" = yes; then
599 cbradney 250
      $echo "enable shared libraries"
3 paul 251
    else
599 cbradney 252
      $echo "disable shared libraries"
3 paul 253
    fi
254
    if test "$build_old_libs" = yes; then
599 cbradney 255
      $echo "enable static libraries"
3 paul 256
    else
599 cbradney 257
      $echo "disable static libraries"
3 paul 258
    fi
259
    exit 0
260
    ;;
261
 
262
  --finish) mode="finish" ;;
263
 
264
  --mode) prevopt="--mode" prev=mode ;;
265
  --mode=*) mode="$optarg" ;;
266
 
599 cbradney 267
  --preserve-dup-deps) duplicate_deps="yes" ;;
268
 
3 paul 269
  --quiet | --silent)
270
    show=:
271
    ;;
272
 
273
  --tag) prevopt="--tag" prev=tag ;;
274
  --tag=*)
275
    set tag "$optarg" ${1+"$@"}
276
    shift
277
    prev=tag
278
    ;;
279
 
280
  -dlopen)
281
    prevopt="-dlopen"
282
    prev=execute_dlfiles
283
    ;;
284
 
285
  -*)
286
    $echo "$modename: unrecognized option \`$arg'" 1>&2
287
    $echo "$help" 1>&2
288
    exit 1
289
    ;;
290
 
291
  *)
292
    nonopt="$arg"
293
    break
294
    ;;
295
  esac
296
done
297
 
298
if test -n "$prevopt"; then
299
  $echo "$modename: option \`$prevopt' requires an argument" 1>&2
300
  $echo "$help" 1>&2
301
  exit 1
302
fi
303
 
599 cbradney 304
# If this variable is set in any of the actions, the command in it
305
# will be execed at the end.  This prevents here-documents from being
306
# left over by shells.
307
exec_cmd=
308
 
3 paul 309
if test -z "$show_help"; then
310
 
311
  # Infer the operation mode.
312
  if test -z "$mode"; then
599 cbradney 313
    $echo "*** Warning: inferring the mode of operation is deprecated." 1>&2
314
    $echo "*** Future versions of Libtool will require -mode=MODE be specified." 1>&2
3 paul 315
    case $nonopt in
599 cbradney 316
    *cc | cc* | *++ | gcc* | *-gcc* | g++* | xlc*)
3 paul 317
      mode=link
318
      for arg
319
      do
320
        case $arg in
321
        -c)
322
           mode=compile
323
           break
324
           ;;
325
        esac
326
      done
327
      ;;
328
    *db | *dbx | *strace | *truss)
329
      mode=execute
330
      ;;
331
    *install*|cp|mv)
332
      mode=install
333
      ;;
334
    *rm)
335
      mode=uninstall
336
      ;;
337
    *)
338
      # If we have no mode, but dlfiles were specified, then do execute mode.
339
      test -n "$execute_dlfiles" && mode=execute
340
 
341
      # Just use the default operation mode.
342
      if test -z "$mode"; then
343
        if test -n "$nonopt"; then
344
          $echo "$modename: warning: cannot infer operation mode from \`$nonopt'" 1>&2
345
        else
346
          $echo "$modename: warning: cannot infer operation mode without MODE-ARGS" 1>&2
347
        fi
348
      fi
349
      ;;
350
    esac
351
  fi
352
 
353
  # Only execute mode is allowed to have -dlopen flags.
354
  if test -n "$execute_dlfiles" && test "$mode" != execute; then
355
    $echo "$modename: unrecognized option \`-dlopen'" 1>&2
356
    $echo "$help" 1>&2
357
    exit 1
358
  fi
359
 
360
  # Change the help message to a mode-specific one.
361
  generic_help="$help"
362
  help="Try \`$modename --help --mode=$mode' for more information."
363
 
364
  # These modes are in order of execution frequency so that they run quickly.
365
  case $mode in
366
  # libtool compile mode
367
  compile)
368
    modename="$modename: compile"
369
    # Get the compilation command and the source file.
370
    base_compile=
599 cbradney 371
    srcfile="$nonopt"  #  always keep a non-empty value in "srcfile"
3 paul 372
    suppress_output=
599 cbradney 373
    arg_mode=normal
374
    libobj=
3 paul 375
 
376
    for arg
377
    do
599 cbradney 378
      case "$arg_mode" in
379
      arg  )
380
        # do not "continue".  Instead, add this to base_compile
381
        lastarg="$arg"
382
        arg_mode=normal
383
        ;;
3 paul 384
 
599 cbradney 385
      target )
386
        libobj="$arg"
387
        arg_mode=normal
388
        continue
389
        ;;
390
 
391
      normal )
392
        # Accept any command-line options.
3 paul 393
        case $arg in
599 cbradney 394
        -o)
395
          if test -n "$libobj" ; then
396
            $echo "$modename: you cannot specify \`-o' more than once" 1>&2
397
            exit 1
398
          fi
399
          arg_mode=target
400
          continue
3 paul 401
          ;;
402
 
599 cbradney 403
        -static)
404
          build_old_libs=yes
405
          continue
406
          ;;
3 paul 407
 
599 cbradney 408
        -prefer-pic)
409
          pic_mode=yes
410
          continue
411
          ;;
3 paul 412
 
599 cbradney 413
        -prefer-non-pic)
414
          pic_mode=no
415
          continue
416
          ;;
3 paul 417
 
599 cbradney 418
        -Xcompiler)
419
          arg_mode=arg  #  the next one goes into the "base_compile" arg list
420
          continue      #  The current "srcfile" will either be retained or
421
          ;;            #  replaced later.  I would guess that would be a bug.
3 paul 422
 
599 cbradney 423
        -Wc,*)
424
          args=`$echo "X$arg" | $Xsed -e "s/^-Wc,//"`
425
          lastarg=
426
          save_ifs="$IFS"; IFS=','
427
          for arg in $args; do
428
            IFS="$save_ifs"
3 paul 429
 
599 cbradney 430
            # Double-quote args containing other shell metacharacters.
431
            # Many Bourne shells cannot handle close brackets correctly
432
            # in scan sets, so we specify it separately.
433
            case $arg in
434
              *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
435
              arg="\"$arg\""
436
              ;;
437
            esac
438
            lastarg="$lastarg $arg"
439
          done
3 paul 440
          IFS="$save_ifs"
599 cbradney 441
          lastarg=`$echo "X$lastarg" | $Xsed -e "s/^ //"`
3 paul 442
 
599 cbradney 443
          # Add the arguments to base_compile.
3 paul 444
          base_compile="$base_compile $lastarg"
599 cbradney 445
          continue
446
          ;;
3 paul 447
 
599 cbradney 448
        * )
449
          # Accept the current argument as the source file.
450
          # The previous "srcfile" becomes the current argument.
451
          #
452
          lastarg="$srcfile"
453
          srcfile="$arg"
454
          ;;
455
        esac  #  case $arg
3 paul 456
        ;;
599 cbradney 457
      esac    #  case $arg_mode
3 paul 458
 
459
      # Aesthetically quote the previous argument.
460
      lastarg=`$echo "X$lastarg" | $Xsed -e "$sed_quote_subst"`
461
 
599 cbradney 462
      case $lastarg in
3 paul 463
      # Double-quote args containing other shell metacharacters.
464
      # Many Bourne shells cannot handle close brackets correctly
465
      # in scan sets, so we specify it separately.
466
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
467
        lastarg="\"$lastarg\""
468
        ;;
469
      esac
470
 
599 cbradney 471
      base_compile="$base_compile $lastarg"
472
    done # for arg
3 paul 473
 
599 cbradney 474
    case $arg_mode in
475
    arg)
476
      $echo "$modename: you must specify an argument for -Xcompile"
477
      exit 1
3 paul 478
      ;;
599 cbradney 479
    target)
3 paul 480
      $echo "$modename: you must specify a target with \`-o'" 1>&2
481
      exit 1
482
      ;;
599 cbradney 483
    *)
484
      # Get the name of the library object.
485
      [ -z "$libobj" ] && libobj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%'`
486
      ;;
3 paul 487
    esac
488
 
489
    # Recognize several different file suffixes.
490
    # If the user specifies -o file.o, it is replaced with file.lo
599 cbradney 491
    xform='[cCFSifmso]'
3 paul 492
    case $libobj in
493
    *.ada) xform=ada ;;
494
    *.adb) xform=adb ;;
495
    *.ads) xform=ads ;;
496
    *.asm) xform=asm ;;
497
    *.c++) xform=c++ ;;
498
    *.cc) xform=cc ;;
599 cbradney 499
    *.ii) xform=ii ;;
3 paul 500
    *.class) xform=class ;;
501
    *.cpp) xform=cpp ;;
502
    *.cxx) xform=cxx ;;
503
    *.f90) xform=f90 ;;
504
    *.for) xform=for ;;
505
    *.java) xform=java ;;
506
    esac
507
 
508
    libobj=`$echo "X$libobj" | $Xsed -e "s/\.$xform$/.lo/"`
509
 
510
    case $libobj in
511
    *.lo) obj=`$echo "X$libobj" | $Xsed -e "$lo2o"` ;;
512
    *)
513
      $echo "$modename: cannot determine name of library object from \`$libobj'" 1>&2
514
      exit 1
515
      ;;
516
    esac
517
 
518
    # Infer tagged configuration to use if any are available and
519
    # if one wasn't chosen via the "--tag" command line option.
520
    # Only attempt this if the compiler in the base compile
521
    # command doesn't match the default compiler.
522
    if test -n "$available_tags" && test -z "$tagname"; then
523
      case $base_compile in
524
      # Blanks in the command may have been stripped by the calling shell,
599 cbradney 525
      # but not from the CC environment variable when configure was run.
526
      " $CC "* | "$CC "* | " `$echo $CC` "* | "`$echo $CC` "*) ;;
527
      # Blanks at the start of $base_compile will cause this to fail
528
      # if we don't check for them as well.
3 paul 529
      *)
599 cbradney 530
        for z in $available_tags; do
531
          if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
3 paul 532
            # Evaluate the configuration.
599 cbradney 533
            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
534
            case "$base_compile " in
535
            "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)
536
              # The compiler in the base compile command matches
537
              # the one in the tagged configuration.
538
              # Assume this is the tagged configuration we want.
3 paul 539
              tagname=$z
540
              break
541
              ;;
542
            esac
599 cbradney 543
          fi
544
        done
545
        # If $tagname still isn't set, then no tagged configuration
546
        # was found and let the user know that the "--tag" command
547
        # line option must be used.
548
        if test -z "$tagname"; then
549
          $echo "$modename: unable to infer tagged configuration"
550
          $echo "$modename: specify a tag with \`--tag'" 1>&2
3 paul 551
          exit 1
552
#        else
599 cbradney 553
#          $echo "$modename: using $tagname tagged configuration"
554
        fi
3 paul 555
        ;;
556
      esac
557
    fi
558
 
559
    objname=`$echo "X$obj" | $Xsed -e 's%^.*/%%'`
560
    xdir=`$echo "X$obj" | $Xsed -e 's%/[^/]*$%%'`
561
    if test "X$xdir" = "X$obj"; then
562
      xdir=
563
    else
564
      xdir=$xdir/
565
    fi
566
    lobj=${xdir}$objdir/$objname
567
 
568
    if test -z "$base_compile"; then
569
      $echo "$modename: you must specify a compilation command" 1>&2
570
      $echo "$help" 1>&2
571
      exit 1
572
    fi
573
 
574
    # Delete any leftover library objects.
575
    if test "$build_old_libs" = yes; then
576
      removelist="$obj $lobj $libobj ${libobj}T"
577
    else
578
      removelist="$lobj $libobj ${libobj}T"
579
    fi
580
 
581
    $run $rm $removelist
582
    trap "$run $rm $removelist; exit 1" 1 2 15
583
 
584
    # On Cygwin there's no "real" PIC flag so we must build both object types
585
    case $host_os in
586
    cygwin* | mingw* | pw32* | os2*)
587
      pic_mode=default
588
      ;;
589
    esac
599 cbradney 590
    if test "$pic_mode" = no && test "$deplibs_check_method" != pass_all; then
3 paul 591
      # non-PIC code in shared libraries is not supported
592
      pic_mode=default
593
    fi
594
 
595
    # Calculate the filename of the output object if compiler does
596
    # not support -o with -c
597
    if test "$compiler_c_o" = no; then
598
      output_obj=`$echo "X$srcfile" | $Xsed -e 's%^.*/%%' -e 's%\.[^.]*$%%'`.${objext}
599
      lockfile="$output_obj.lock"
600
      removelist="$removelist $output_obj $lockfile"
601
      trap "$run $rm $removelist; exit 1" 1 2 15
602
    else
603
      output_obj=
604
      need_locks=no
605
      lockfile=
606
    fi
607
 
608
    # Lock this critical section if it is needed
609
    # We use this script file to make the link, it avoids creating a new file
610
    if test "$need_locks" = yes; then
611
      until $run ln "$0" "$lockfile" 2>/dev/null; do
612
        $show "Waiting for $lockfile to be removed"
613
        sleep 2
614
      done
615
    elif test "$need_locks" = warn; then
616
      if test -f "$lockfile"; then
599 cbradney 617
        $echo "\
3 paul 618
*** ERROR, $lockfile exists and contains:
619
`cat $lockfile 2>/dev/null`
620
 
621
This indicates that another process is trying to use the same
622
temporary object file, and libtool could not work around it because
623
your compiler does not support \`-c' and \`-o' together.  If you
624
repeat this compilation, it may succeed, by chance, but you had better
625
avoid parallel builds (make -j) in this platform, or get a better
626
compiler."
627
 
628
        $run $rm $removelist
629
        exit 1
630
      fi
599 cbradney 631
      $echo $srcfile > "$lockfile"
3 paul 632
    fi
633
 
634
    if test -n "$fix_srcfile_path"; then
635
      eval srcfile=\"$fix_srcfile_path\"
636
    fi
637
 
638
    $run $rm "$libobj" "${libobj}T"
639
 
640
    # Create a libtool object file (analogous to a ".la" file),
641
    # but don't create it if we're doing a dry run.
642
    test -z "$run" && cat > ${libobj}T <<EOF
643
# $libobj - a libtool object file
644
# Generated by $PROGRAM - GNU $PACKAGE $VERSION$TIMESTAMP
645
#
646
# Please DO NOT delete this file!
647
# It is necessary for linking the library.
648
 
649
# Name of the PIC object.
650
EOF
651
 
652
    # Only build a PIC object if we are building libtool libraries.
653
    if test "$build_libtool_libs" = yes; then
654
      # Without this assignment, base_compile gets emptied.
655
      fbsd_hideous_sh_bug=$base_compile
656
 
657
      if test "$pic_mode" != no; then
658
        command="$base_compile $srcfile $pic_flag"
659
      else
660
        # Don't build PIC code
661
        command="$base_compile $srcfile"
662
      fi
663
 
599 cbradney 664
      if test ! -d "${xdir}$objdir"; then
3 paul 665
        $show "$mkdir ${xdir}$objdir"
666
        $run $mkdir ${xdir}$objdir
667
        status=$?
599 cbradney 668
        if test "$status" -ne 0 && test ! -d "${xdir}$objdir"; then
3 paul 669
          exit $status
599 cbradney 670
        fi
671
      fi
3 paul 672
 
673
      if test -z "$output_obj"; then
599 cbradney 674
        # Place PIC objects in $objdir
675
        command="$command -o $lobj"
3 paul 676
      fi
677
 
678
      $run $rm "$lobj" "$output_obj"
679
 
680
      $show "$command"
681
      if $run eval "$command"; then :
682
      else
683
        test -n "$output_obj" && $run $rm $removelist
684
        exit 1
685
      fi
686
 
687
      if test "$need_locks" = warn &&
599 cbradney 688
         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
689
        $echo "\
3 paul 690
*** ERROR, $lockfile contains:
691
`cat $lockfile 2>/dev/null`
692
 
693
but it should contain:
694
$srcfile
695
 
696
This indicates that another process is trying to use the same
697
temporary object file, and libtool could not work around it because
698
your compiler does not support \`-c' and \`-o' together.  If you
699
repeat this compilation, it may succeed, by chance, but you had better
700
avoid parallel builds (make -j) in this platform, or get a better
701
compiler."
702
 
703
        $run $rm $removelist
704
        exit 1
705
      fi
706
 
707
      # Just move the object if needed, then go on to compile the next one
599 cbradney 708
      if test -n "$output_obj" && test "X$output_obj" != "X$lobj"; then
3 paul 709
        $show "$mv $output_obj $lobj"
710
        if $run $mv $output_obj $lobj; then :
711
        else
712
          error=$?
713
          $run $rm $removelist
714
          exit $error
715
        fi
716
      fi
717
 
718
      # Append the name of the PIC object to the libtool object file.
719
      test -z "$run" && cat >> ${libobj}T <<EOF
720
pic_object='$objdir/$objname'
721
 
722
EOF
723
 
724
      # Allow error messages only from the first compilation.
725
      suppress_output=' >/dev/null 2>&1'
726
    else
727
      # No PIC object so indicate it doesn't exist in the libtool
728
      # object file.
729
      test -z "$run" && cat >> ${libobj}T <<EOF
730
pic_object=none
731
 
732
EOF
733
    fi
734
 
735
    # Only build a position-dependent object if we build old libraries.
736
    if test "$build_old_libs" = yes; then
737
      if test "$pic_mode" != yes; then
738
        # Don't build PIC code
739
        command="$base_compile $srcfile"
740
      else
741
        command="$base_compile $srcfile $pic_flag"
742
      fi
743
      if test "$compiler_c_o" = yes; then
744
        command="$command -o $obj"
745
      fi
746
 
747
      # Suppress compiler output if we already did a PIC compilation.
748
      command="$command$suppress_output"
749
      $run $rm "$obj" "$output_obj"
750
      $show "$command"
751
      if $run eval "$command"; then :
752
      else
753
        $run $rm $removelist
754
        exit 1
755
      fi
756
 
757
      if test "$need_locks" = warn &&
599 cbradney 758
         test "X`cat $lockfile 2>/dev/null`" != "X$srcfile"; then
759
        $echo "\
3 paul 760
*** ERROR, $lockfile contains:
761
`cat $lockfile 2>/dev/null`
762
 
763
but it should contain:
764
$srcfile
765
 
766
This indicates that another process is trying to use the same
767
temporary object file, and libtool could not work around it because
768
your compiler does not support \`-c' and \`-o' together.  If you
769
repeat this compilation, it may succeed, by chance, but you had better
770
avoid parallel builds (make -j) in this platform, or get a better
771
compiler."
772
 
773
        $run $rm $removelist
774
        exit 1
775
      fi
776
 
777
      # Just move the object if needed
599 cbradney 778
      if test -n "$output_obj" && test "X$output_obj" != "X$obj"; then
3 paul 779
        $show "$mv $output_obj $obj"
780
        if $run $mv $output_obj $obj; then :
781
        else
782
          error=$?
783
          $run $rm $removelist
784
          exit $error
785
        fi
786
      fi
787
 
788
      # Append the name of the non-PIC object the libtool object file.
789
      # Only append if the libtool object file exists.
790
      test -z "$run" && cat >> ${libobj}T <<EOF
791
# Name of the non-PIC object.
792
non_pic_object='$objname'
793
 
794
EOF
795
    else
796
      # Append the name of the non-PIC object the libtool object file.
797
      # Only append if the libtool object file exists.
798
      test -z "$run" && cat >> ${libobj}T <<EOF
799
# Name of the non-PIC object.
800
non_pic_object=none
801
 
802
EOF
803
    fi
804
 
805
    $run $mv "${libobj}T" "${libobj}"
806
 
807
    # Unlock the critical section if it was locked
808
    if test "$need_locks" != no; then
809
      $run $rm "$lockfile"
810
    fi
811
 
812
    exit 0
813
    ;;
814
 
815
  # libtool link mode
816
  link | relink)
817
    modename="$modename: link"
818
    case $host in
819
    *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
820
      # It is impossible to link a dll without this setting, and
821
      # we shouldn't force the makefile maintainer to figure out
822
      # which system we are compiling for in order to pass an extra
599 cbradney 823
      # flag for every libtool invocation.
3 paul 824
      # allow_undefined=no
825
 
826
      # FIXME: Unfortunately, there are problems with the above when trying
827
      # to make a dll which has undefined symbols, in which case not
828
      # even a static library is built.  For now, we need to specify
829
      # -no-undefined on the libtool link line when we can be certain
830
      # that all symbols are satisfied, otherwise we get a static library.
831
      allow_undefined=yes
832
      ;;
833
    *)
834
      allow_undefined=yes
835
      ;;
836
    esac
837
    libtool_args="$nonopt"
838
    base_compile="$nonopt"
839
    compile_command="$nonopt"
840
    finalize_command="$nonopt"
841
 
842
    compile_rpath=
843
    finalize_rpath=
844
    compile_shlibpath=
845
    finalize_shlibpath=
846
    convenience=
847
    old_convenience=
848
    deplibs=
849
    old_deplibs=
850
    add_flags=
851
    compiler_flags=
852
    linker_flags=
853
    dllsearchpath=
854
    lib_search_path=`pwd`
599 cbradney 855
    inst_prefix_dir=
3 paul 856
 
857
    avoid_version=no
858
    dlfiles=
859
    dlprefiles=
860
    dlself=no
861
    export_dynamic=no
862
    export_symbols=
863
    export_symbols_regex=
864
    generated=
865
    libobjs=
866
    ltlibs=
867
    module=no
868
    no_install=no
869
    objs=
870
    non_pic_objects=
871
    prefer_static_libs=no
872
    preload=no
873
    prev=
874
    prevarg=
875
    release=
876
    rpath=
877
    xrpath=
878
    perm_rpath=
879
    temp_rpath=
880
    thread_safe=no
881
    vinfo=
599 cbradney 882
    vinfo_number=no
3 paul 883
 
884
    # We need to know -static, to get the right output filenames.
885
    for arg
886
    do
887
      case $arg in
888
      -all-static | -static)
889
        if test "X$arg" = "X-all-static"; then
890
          if test "$build_libtool_libs" = yes && test -z "$link_static_flag"; then
891
            $echo "$modename: warning: complete static linking is impossible in this configuration" 1>&2
892
          fi
893
          if test -n "$link_static_flag"; then
894
            dlopen_self=$dlopen_self_static
895
          fi
896
        else
897
          if test -z "$pic_flag" && test -n "$link_static_flag"; then
898
            dlopen_self=$dlopen_self_static
899
          fi
900
        fi
901
        build_libtool_libs=no
902
        build_old_libs=yes
903
        prefer_static_libs=yes
904
        break
905
        ;;
906
      esac
907
    done
908
 
909
    # See if our shared archives depend on static archives.
910
    test -n "$old_archive_from_new_cmds" && build_old_libs=yes
911
 
912
    # Go through the arguments, transforming them on the way.
599 cbradney 913
    while test "$#" -gt 0; do
3 paul 914
      arg="$1"
915
      base_compile="$base_compile $arg"
916
      shift
917
      case $arg in
918
      *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \     ]*|*]*|"")
919
        qarg=\"`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`\" ### testsuite: skip nested quoting test
920
        ;;
921
      *) qarg=$arg ;;
922
      esac
923
      libtool_args="$libtool_args $qarg"
924
 
925
      # If the previous option needs an argument, assign it.
926
      if test -n "$prev"; then
927
        case $prev in
928
        output)
929
          compile_command="$compile_command @OUTPUT@"
930
          finalize_command="$finalize_command @OUTPUT@"
931
          ;;
932
        esac
933
 
934
        case $prev in
935
        dlfiles|dlprefiles)
936
          if test "$preload" = no; then
937
            # Add the symbol object into the linking commands.
938
            compile_command="$compile_command @SYMFILE@"
939
            finalize_command="$finalize_command @SYMFILE@"
940
            preload=yes
941
          fi
942
          case $arg in
943
          *.la | *.lo) ;;  # We handle these cases below.
944
          force)
945
            if test "$dlself" = no; then
946
              dlself=needless
947
              export_dynamic=yes
948
            fi
949
            prev=
950
            continue
951
            ;;
952
          self)
953
            if test "$prev" = dlprefiles; then
954
              dlself=yes
955
            elif test "$prev" = dlfiles && test "$dlopen_self" != yes; then
956
              dlself=yes
957
            else
958
              dlself=needless
959
              export_dynamic=yes
960
            fi
961
            prev=
962
            continue
963
            ;;
964
          *)
965
            if test "$prev" = dlfiles; then
966
              dlfiles="$dlfiles $arg"
967
            else
968
              dlprefiles="$dlprefiles $arg"
969
            fi
970
            prev=
971
            continue
972
            ;;
973
          esac
974
          ;;
975
        expsyms)
976
          export_symbols="$arg"
977
          if test ! -f "$arg"; then
978
            $echo "$modename: symbol file \`$arg' does not exist"
979
            exit 1
980
          fi
981
          prev=
982
          continue
983
          ;;
984
        expsyms_regex)
985
          export_symbols_regex="$arg"
986
          prev=
987
          continue
988
          ;;
599 cbradney 989
        inst_prefix)
990
          inst_prefix_dir="$arg"
991
          prev=
992
          continue
993
          ;;
3 paul 994
        release)
995
          release="-$arg"
996
          prev=
997
          continue
998
          ;;
999
        objectlist)
1000
          if test -f "$arg"; then
599 cbradney 1001
            save_arg=$arg
3 paul 1002
            moreargs=
1003
            for fil in `cat $save_arg`
1004
            do
1005
#             moreargs="$moreargs $fil"
599 cbradney 1006
              arg=$fil
1007
              # A libtool-controlled object.
3 paul 1008
 
1009
              # Check to see that this really is a libtool object.
599 cbradney 1010
              if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1011
                pic_object=
1012
                non_pic_object=
3 paul 1013
 
599 cbradney 1014
                # Read the .lo file
1015
                # If there is no directory component, then add one.
1016
                case $arg in
1017
                */* | *\\*) . $arg ;;
1018
                *) . ./$arg ;;
1019
                esac
3 paul 1020
 
599 cbradney 1021
                if test -z "$pic_object" || \
1022
                   test -z "$non_pic_object" ||
1023
                   test "$pic_object" = none && \
1024
                   test "$non_pic_object" = none; then
1025
                  $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1026
                  exit 1
1027
                fi
3 paul 1028
 
599 cbradney 1029
                # Extract subdirectory from the argument.
1030
                xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1031
                if test "X$xdir" = "X$arg"; then
1032
                  xdir=
1033
                else
1034
                  xdir="$xdir/"
1035
                fi
3 paul 1036
 
599 cbradney 1037
                if test "$pic_object" != none; then
1038
                  # Prepend the subdirectory the object is found in.
1039
                  pic_object="$xdir$pic_object"
3 paul 1040
 
599 cbradney 1041
                  if test "$prev" = dlfiles; then
1042
                    if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
1043
                      dlfiles="$dlfiles $pic_object"
1044
                      prev=
1045
                      continue
1046
                    else
1047
                      # If libtool objects are unsupported, then we need to preload.
1048
                      prev=dlprefiles
1049
                    fi
1050
                  fi
3 paul 1051
 
599 cbradney 1052
                  # CHECK ME:  I think I busted this.  -Ossama
1053
                  if test "$prev" = dlprefiles; then
1054
                    # Preload the old-style object.
1055
                    dlprefiles="$dlprefiles $pic_object"
1056
                    prev=
1057
                  fi
3 paul 1058
 
599 cbradney 1059
                  # A PIC object.
1060
                  libobjs="$libobjs $pic_object"
1061
                  arg="$pic_object"
1062
                fi
3 paul 1063
 
599 cbradney 1064
                # Non-PIC object.
1065
                if test "$non_pic_object" != none; then
1066
                  # Prepend the subdirectory the object is found in.
1067
                  non_pic_object="$xdir$non_pic_object"
3 paul 1068
 
599 cbradney 1069
                  # A standard non-PIC object
1070
                  non_pic_objects="$non_pic_objects $non_pic_object"
1071
                  if test -z "$pic_object" || test "$pic_object" = none ; then
1072
                    arg="$non_pic_object"
1073
                  fi
1074
                fi
1075
              else
1076
                # Only an error if not doing a dry-run.
1077
                if test -z "$run"; then
1078
                  $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1079
                  exit 1
1080
                else
1081
                  # Dry-run case.
3 paul 1082
 
599 cbradney 1083
                  # Extract subdirectory from the argument.
1084
                  xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1085
                  if test "X$xdir" = "X$arg"; then
1086
                    xdir=
1087
                  else
1088
                    xdir="$xdir/"
1089
                  fi
3 paul 1090
 
599 cbradney 1091
                  pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1092
                  non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
1093
                  libobjs="$libobjs $pic_object"
1094
                  non_pic_objects="$non_pic_objects $non_pic_object"
1095
                fi
3 paul 1096
              fi
1097
            done
1098
          else
1099
            $echo "$modename: link input file \`$save_arg' does not exist"
1100
            exit 1
1101
          fi
599 cbradney 1102
          arg=$save_arg
3 paul 1103
          prev=
1104
          continue
1105
          ;;
1106
        rpath | xrpath)
1107
          # We need an absolute path.
1108
          case $arg in
1109
          [\\/]* | [A-Za-z]:[\\/]*) ;;
1110
          *)
1111
            $echo "$modename: only absolute run-paths are allowed" 1>&2
1112
            exit 1
1113
            ;;
1114
          esac
1115
          if test "$prev" = rpath; then
1116
            case "$rpath " in
1117
            *" $arg "*) ;;
1118
            *) rpath="$rpath $arg" ;;
1119
            esac
1120
          else
1121
            case "$xrpath " in
1122
            *" $arg "*) ;;
1123
            *) xrpath="$xrpath $arg" ;;
1124
            esac
1125
          fi
1126
          prev=
1127
          continue
1128
          ;;
1129
        xcompiler)
1130
          compiler_flags="$compiler_flags $qarg"
1131
          prev=
1132
          compile_command="$compile_command $qarg"
1133
          finalize_command="$finalize_command $qarg"
1134
          continue
1135
          ;;
1136
        xlinker)
1137
          linker_flags="$linker_flags $qarg"
1138
          compiler_flags="$compiler_flags $wl$qarg"
1139
          prev=
1140
          compile_command="$compile_command $wl$qarg"
1141
          finalize_command="$finalize_command $wl$qarg"
1142
          continue
1143
          ;;
599 cbradney 1144
        xcclinker)
1145
          linker_flags="$linker_flags $qarg"
1146
          compiler_flags="$compiler_flags $qarg"
1147
          prev=
1148
          compile_command="$compile_command $qarg"
1149
          finalize_command="$finalize_command $qarg"
1150
          continue
1151
          ;;
3 paul 1152
        *)
1153
          eval "$prev=\"\$arg\""
1154
          prev=
1155
          continue
1156
          ;;
1157
        esac
599 cbradney 1158
      fi # test -n "$prev"
3 paul 1159
 
1160
      prevarg="$arg"
1161
 
1162
      case $arg in
1163
      -all-static)
1164
        if test -n "$link_static_flag"; then
1165
          compile_command="$compile_command $link_static_flag"
1166
          finalize_command="$finalize_command $link_static_flag"
1167
        fi
1168
        continue
1169
        ;;
1170
 
1171
      -allow-undefined)
1172
        # FIXME: remove this flag sometime in the future.
1173
        $echo "$modename: \`-allow-undefined' is deprecated because it is the default" 1>&2
1174
        continue
1175
        ;;
1176
 
1177
      -avoid-version)
1178
        avoid_version=yes
1179
        continue
1180
        ;;
1181
 
1182
      -dlopen)
1183
        prev=dlfiles
1184
        continue
1185
        ;;
1186
 
1187
      -dlpreopen)
1188
        prev=dlprefiles
1189
        continue
1190
        ;;
1191
 
1192
      -export-dynamic)
1193
        export_dynamic=yes
1194
        continue
1195
        ;;
1196
 
1197
      -export-symbols | -export-symbols-regex)
1198
        if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
599 cbradney 1199
          $echo "$modename: more than one -exported-symbols argument is not allowed"
3 paul 1200
          exit 1
1201
        fi
1202
        if test "X$arg" = "X-export-symbols"; then
1203
          prev=expsyms
1204
        else
1205
          prev=expsyms_regex
1206
        fi
1207
        continue
1208
        ;;
1209
 
599 cbradney 1210
      -inst-prefix-dir)
1211
        prev=inst_prefix
1212
        continue
1213
        ;;
1214
 
3 paul 1215
      # The native IRIX linker understands -LANG:*, -LIST:* and -LNO:*
1216
      # so, if we see these flags be careful not to treat them like -L
1217
      -L[A-Z][A-Z]*:*)
1218
        case $with_gcc/$host in
599 cbradney 1219
        no/*-*-irix* | /*-*-irix*)
3 paul 1220
          compile_command="$compile_command $arg"
1221
          finalize_command="$finalize_command $arg"
1222
          ;;
1223
        esac
1224
        continue
1225
        ;;
599 cbradney 1226
 
3 paul 1227
      -L*)
1228
        dir=`$echo "X$arg" | $Xsed -e 's/^-L//'`
1229
        # We need an absolute path.
1230
        case $dir in
1231
        [\\/]* | [A-Za-z]:[\\/]*) ;;
1232
        *)
1233
          absdir=`cd "$dir" && pwd`
1234
          if test -z "$absdir"; then
1235
            $echo "$modename: cannot determine absolute directory name of \`$dir'" 1>&2
1236
            exit 1
1237
          fi
1238
          dir="$absdir"
1239
          ;;
1240
        esac
1241
        case "$deplibs " in
1242
        *" -L$dir "*) ;;
1243
        *)
1244
          deplibs="$deplibs -L$dir"
1245
          lib_search_path="$lib_search_path $dir"
1246
          ;;
1247
        esac
1248
        case $host in
1249
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1250
          case :$dllsearchpath: in
1251
          *":$dir:"*) ;;
1252
          *) dllsearchpath="$dllsearchpath:$dir";;
1253
          esac
1254
          ;;
1255
        esac
1256
        continue
1257
        ;;
1258
 
1259
      -l*)
599 cbradney 1260
        if test "X$arg" = "X-lc" || test "X$arg" = "X-lm"; then
3 paul 1261
          case $host in
599 cbradney 1262
          *-*-cygwin* | *-*-pw32* | *-*-beos*)
1263
            # These systems don't actually have a C or math library (as such)
3 paul 1264
            continue
1265
            ;;
599 cbradney 1266
          *-*-freebsd*-gnu*)
1267
            # prevent being parsed by the freebsd regexp below
3 paul 1268
            ;;
599 cbradney 1269
          *-*-mingw* | *-*-os2*)
1270
            # These systems don't actually have a C library (as such)
1271
            test "X$arg" = "X-lc" && continue
3 paul 1272
            ;;
599 cbradney 1273
          *-*-openbsd* | *-*-freebsd*)
1274
            # Do not include libc due to us having libc/libc_r.
1275
            test "X$arg" = "X-lc" && continue
1276
            ;;
3 paul 1277
          *-*-rhapsody* | *-*-darwin1.[012])
599 cbradney 1278
            # Rhapsody C and math libraries are in the System framework
3 paul 1279
            deplibs="$deplibs -framework System"
1280
            continue
1281
          esac
599 cbradney 1282
        elif test "X$arg" = "X-lc_r"; then
1283
         case $host in
1284
         *-*-freebsd*-gnu*)
1285
           # prevent being parsed by the freebsd regexp below
1286
           ;;
1287
         *-*-openbsd*)
1288
           # Do not include libc_r directly, use -pthread flag.
1289
           continue
1290
           ;;
1291
         esac
3 paul 1292
        fi
1293
        deplibs="$deplibs $arg"
1294
        continue
1295
        ;;
1296
 
1297
      -module)
1298
        module=yes
1299
        continue
1300
        ;;
1301
 
599 cbradney 1302
      # gcc -m* arguments should be passed to the linker via $compiler_flags
1303
      # in order to pass architecture information to the linker
1304
      # (e.g. 32 vs 64-bit).  This may also be accomplished via -Wl,-mfoo
1305
      # but this is not reliable with gcc because gcc may use -mfoo to
1306
      # select a different linker, different libraries, etc, while
1307
      # -Wl,-mfoo simply passes -mfoo to the linker.
1308
      -m*)
1309
        # Unknown arguments in both finalize_command and compile_command need
1310
        # to be aesthetically quoted because they are evaled later.
1311
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1312
        case $arg in
1313
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1314
          arg="\"$arg\""
1315
          ;;
1316
        esac
1317
        compile_command="$compile_command $arg"
1318
        finalize_command="$finalize_command $arg"
1319
        if test "$with_gcc" = "yes" ; then
1320
          compiler_flags="$compiler_flags $arg"
1321
        fi
1322
        continue
1323
        ;;
1324
 
1325
      -shrext)
1326
        prev=shrext
1327
        continue
1328
        ;;
1329
 
3 paul 1330
      -no-fast-install)
1331
        fast_install=no
1332
        continue
1333
        ;;
1334
 
1335
      -no-install)
1336
        case $host in
1337
        *-*-cygwin* | *-*-mingw* | *-*-pw32* | *-*-os2*)
1338
          # The PATH hackery in wrapper scripts is required on Windows
1339
          # in order for the loader to find any dlls it needs.
1340
          $echo "$modename: warning: \`-no-install' is ignored for $host" 1>&2
1341
          $echo "$modename: warning: assuming \`-no-fast-install' instead" 1>&2
1342
          fast_install=no
1343
          ;;
599 cbradney 1344
        *) no_install=yes ;;
3 paul 1345
        esac
1346
        continue
1347
        ;;
1348
 
1349
      -no-undefined)
1350
        allow_undefined=no
1351
        continue
1352
        ;;
1353
 
1354
      -objectlist)
1355
        prev=objectlist
1356
        continue
1357
        ;;
1358
 
1359
      -o) prev=output ;;
1360
 
1361
      -release)
1362
        prev=release
1363
        continue
1364
        ;;
1365
 
1366
      -rpath)
1367
        prev=rpath
1368
        continue
1369
        ;;
1370
 
1371
      -R)
1372
        prev=xrpath
1373
        continue
1374
        ;;
1375
 
1376
      -R*)
1377
        dir=`$echo "X$arg" | $Xsed -e 's/^-R//'`
1378
        # We need an absolute path.
1379
        case $dir in
1380
        [\\/]* | [A-Za-z]:[\\/]*) ;;
1381
        *)
1382
          $echo "$modename: only absolute run-paths are allowed" 1>&2
1383
          exit 1
1384
          ;;
1385
        esac
1386
        case "$xrpath " in
1387
        *" $dir "*) ;;
1388
        *) xrpath="$xrpath $dir" ;;
1389
        esac
1390
        continue
1391
        ;;
1392
 
1393
      -static)
599 cbradney 1394
        # The effects of -static are defined in a previous loop.
3 paul 1395
        # We used to do the same as -all-static on platforms that
1396
        # didn't have a PIC flag, but the assumption that the effects
1397
        # would be equivalent was wrong.  It would break on at least
1398
        # Digital Unix and AIX.
1399
        continue
1400
        ;;
1401
 
1402
      -thread-safe)
1403
        thread_safe=yes
1404
        continue
1405
        ;;
1406
 
1407
      -version-info)
1408
        prev=vinfo
1409
        continue
1410
        ;;
599 cbradney 1411
      -version-number)
1412
        prev=vinfo
1413
        vinfo_number=yes
1414
        continue
1415
        ;;
3 paul 1416
 
1417
      -Wc,*)
1418
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wc,//'`
1419
        arg=
599 cbradney 1420
        save_ifs="$IFS"; IFS=','
3 paul 1421
        for flag in $args; do
1422
          IFS="$save_ifs"
1423
          case $flag in
1424
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1425
            flag="\"$flag\""
1426
            ;;
1427
          esac
1428
          arg="$arg $wl$flag"
1429
          compiler_flags="$compiler_flags $flag"
1430
        done
1431
        IFS="$save_ifs"
1432
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1433
        ;;
1434
 
1435
      -Wl,*)
1436
        args=`$echo "X$arg" | $Xsed -e "$sed_quote_subst" -e 's/^-Wl,//'`
1437
        arg=
599 cbradney 1438
        save_ifs="$IFS"; IFS=','
3 paul 1439
        for flag in $args; do
1440
          IFS="$save_ifs"
1441
          case $flag in
1442
            *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \       ]*|*]*|"")
1443
            flag="\"$flag\""
1444
            ;;
1445
          esac
1446
          arg="$arg $wl$flag"
1447
          compiler_flags="$compiler_flags $wl$flag"
1448
          linker_flags="$linker_flags $flag"
1449
        done
1450
        IFS="$save_ifs"
1451
        arg=`$echo "X$arg" | $Xsed -e "s/^ //"`
1452
        ;;
1453
 
1454
      -Xcompiler)
1455
        prev=xcompiler
1456
        continue
1457
        ;;
1458
 
1459
      -Xlinker)
1460
        prev=xlinker
1461
        continue
1462
        ;;
1463
 
599 cbradney 1464
      -XCClinker)
1465
        prev=xcclinker
1466
        continue
1467
        ;;
1468
 
3 paul 1469
      # Some other compiler flag.
1470
      -* | +*)
1471
        # Unknown arguments in both finalize_command and compile_command need
1472
        # to be aesthetically quoted because they are evaled later.
1473
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1474
        case $arg in
1475
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1476
          arg="\"$arg\""
1477
          ;;
1478
        esac
1479
        add_flags="$add_flags $arg"
1480
        ;;
1481
 
1482
      *.$objext)
1483
        # A standard object.
1484
        objs="$objs $arg"
1485
        ;;
1486
 
1487
      *.lo)
1488
        # A libtool-controlled object.
1489
 
1490
        # Check to see that this really is a libtool object.
599 cbradney 1491
        if (${SED} -e '2q' $arg | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1492
          pic_object=
1493
          non_pic_object=
3 paul 1494
 
599 cbradney 1495
          # Read the .lo file
1496
          # If there is no directory component, then add one.
1497
          case $arg in
1498
          */* | *\\*) . $arg ;;
1499
          *) . ./$arg ;;
1500
          esac
3 paul 1501
 
599 cbradney 1502
          if test -z "$pic_object" || \
1503
             test -z "$non_pic_object" ||
1504
             test "$pic_object" = none && \
1505
             test "$non_pic_object" = none; then
1506
            $echo "$modename: cannot find name of object for \`$arg'" 1>&2
1507
            exit 1
1508
          fi
3 paul 1509
 
1510
          # Extract subdirectory from the argument.
1511
          xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1512
          if test "X$xdir" = "X$arg"; then
1513
            xdir=
599 cbradney 1514
          else
3 paul 1515
            xdir="$xdir/"
1516
          fi
1517
 
599 cbradney 1518
          if test "$pic_object" != none; then
1519
            # Prepend the subdirectory the object is found in.
3 paul 1520
            pic_object="$xdir$pic_object"
1521
 
1522
            if test "$prev" = dlfiles; then
1523
              if test "$build_libtool_libs" = yes && test "$dlopen_support" = yes; then
599 cbradney 1524
                dlfiles="$dlfiles $pic_object"
1525
                prev=
1526
                continue
3 paul 1527
              else
599 cbradney 1528
                # If libtool objects are unsupported, then we need to preload.
1529
                prev=dlprefiles
3 paul 1530
              fi
1531
            fi
1532
 
1533
            # CHECK ME:  I think I busted this.  -Ossama
599 cbradney 1534
            if test "$prev" = dlprefiles; then
3 paul 1535
              # Preload the old-style object.
1536
              dlprefiles="$dlprefiles $pic_object"
1537
              prev=
599 cbradney 1538
            fi
3 paul 1539
 
599 cbradney 1540
            # A PIC object.
3 paul 1541
            libobjs="$libobjs $pic_object"
1542
            arg="$pic_object"
599 cbradney 1543
          fi
3 paul 1544
 
599 cbradney 1545
          # Non-PIC object.
1546
          if test "$non_pic_object" != none; then
1547
            # Prepend the subdirectory the object is found in.
3 paul 1548
            non_pic_object="$xdir$non_pic_object"
1549
 
599 cbradney 1550
            # A standard non-PIC object
1551
            non_pic_objects="$non_pic_objects $non_pic_object"
1552
            if test -z "$pic_object" || test "$pic_object" = none ; then
1553
              arg="$non_pic_object"
1554
            fi
1555
          fi
1556
        else
1557
          # Only an error if not doing a dry-run.
1558
          if test -z "$run"; then
1559
            $echo "$modename: \`$arg' is not a valid libtool object" 1>&2
1560
            exit 1
1561
          else
1562
            # Dry-run case.
3 paul 1563
 
1564
            # Extract subdirectory from the argument.
1565
            xdir=`$echo "X$arg" | $Xsed -e 's%/[^/]*$%%'`
1566
            if test "X$xdir" = "X$arg"; then
1567
              xdir=
1568
            else
1569
              xdir="$xdir/"
1570
            fi
1571
 
599 cbradney 1572
            pic_object=`$echo "X${xdir}${objdir}/${arg}" | $Xsed -e "$lo2o"`
1573
            non_pic_object=`$echo "X${xdir}${arg}" | $Xsed -e "$lo2o"`
3 paul 1574
            libobjs="$libobjs $pic_object"
599 cbradney 1575
            non_pic_objects="$non_pic_objects $non_pic_object"
1576
          fi
3 paul 1577
        fi
1578
        ;;
1579
 
1580
      *.$libext)
1581
        # An archive.
1582
        deplibs="$deplibs $arg"
1583
        old_deplibs="$old_deplibs $arg"
1584
        continue
1585
        ;;
1586
 
1587
      *.la)
1588
        # A libtool-controlled library.
1589
 
1590
        if test "$prev" = dlfiles; then
1591
          # This library was specified with -dlopen.
1592
          dlfiles="$dlfiles $arg"
1593
          prev=
1594
        elif test "$prev" = dlprefiles; then
1595
          # The library was specified with -dlpreopen.
1596
          dlprefiles="$dlprefiles $arg"
1597
          prev=
1598
        else
1599
          deplibs="$deplibs $arg"
1600
        fi
1601
        continue
1602
        ;;
1603
 
1604
      # Some other compiler argument.
1605
      *)
1606
        # Unknown arguments in both finalize_command and compile_command need
1607
        # to be aesthetically quoted because they are evaled later.
1608
        arg=`$echo "X$arg" | $Xsed -e "$sed_quote_subst"`
1609
        case $arg in
1610
        *[\[\~\#\^\&\*\(\)\{\}\|\;\<\>\?\'\ \   ]*|*]*|"")
1611
          arg="\"$arg\""
1612
          ;;
1613
        esac
1614
        add_flags="$add_flags $arg"
1615
        ;;
599 cbradney 1616
      esac # arg
3 paul 1617
 
1618
      # Now actually substitute the argument into the commands.
1619
      if test -n "$arg"; then
1620
        compile_command="$compile_command $arg"
1621
        finalize_command="$finalize_command $arg"
1622
      fi
599 cbradney 1623
    done # argument parsing loop
3 paul 1624
 
1625
    if test -n "$prev"; then
1626
      $echo "$modename: the \`$prevarg' option requires an argument" 1>&2
1627
      $echo "$help" 1>&2
1628
      exit 1
1629
    fi
1630
 
1631
    # Infer tagged configuration to use if any are available and
1632
    # if one wasn't chosen via the "--tag" command line option.
1633
    # Only attempt this if the compiler in the base link
1634
    # command doesn't match the default compiler.
1635
    if test -n "$available_tags" && test -z "$tagname"; then
1636
      case $base_compile in
1637
      # Blanks in the command may have been stripped by the calling shell,
599 cbradney 1638
      # but not from the CC environment variable when configure was run.
1639
      "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*) ;;
1640
      # Blanks at the start of $base_compile will cause this to fail
1641
      # if we don't check for them as well.
3 paul 1642
      *)
599 cbradney 1643
        for z in $available_tags; do
1644
          if grep "^# ### BEGIN LIBTOOL TAG CONFIG: $z$" < "$0" > /dev/null; then
3 paul 1645
            # Evaluate the configuration.
599 cbradney 1646
            eval "`${SED} -n -e '/^# ### BEGIN LIBTOOL TAG CONFIG: '$z'$/,/^# ### END LIBTOOL TAG CONFIG: '$z'$/p' < $0`"
1647
            case $base_compile in
1648
            "$CC "* | " $CC "* | "`$echo $CC` "* | " `$echo $CC` "*)
1649
              # The compiler in $compile_command matches
1650
              # the one in the tagged configuration.
1651
              # Assume this is the tagged configuration we want.
3 paul 1652
              tagname=$z
1653
              break
1654
              ;;
1655
            esac
599 cbradney 1656
          fi
1657
        done
1658
        # If $tagname still isn't set, then no tagged configuration
1659
        # was found and let the user know that the "--tag" command
1660
        # line option must be used.
1661
        if test -z "$tagname"; then
1662
          $echo "$modename: unable to infer tagged configuration"
1663
          $echo "$modename: specify a tag with \`--tag'" 1>&2
3 paul 1664
          exit 1
1665
#       else
599 cbradney 1666
#         $echo "$modename: using $tagname tagged configuration"
1667
        fi
3 paul 1668
        ;;
1669
      esac
1670
    fi
1671
 
1672
    if test "$export_dynamic" = yes && test -n "$export_dynamic_flag_spec"; then
1673
      eval arg=\"$export_dynamic_flag_spec\"
1674
      compile_command="$compile_command $arg"
1675
      finalize_command="$finalize_command $arg"
1676
    fi
1677
 
1678
    oldlibs=
1679
    # calculate the name of the file, without its directory
1680
    outputname=`$echo "X$output" | $Xsed -e 's%^.*/%%'`
1681
    libobjs_save="$libobjs"
1682
 
1683
    if test -n "$shlibpath_var"; then
1684
      # get the directories listed in $shlibpath_var
1685
      eval shlib_search_path=\`\$echo \"X\${$shlibpath_var}\" \| \$Xsed -e \'s/:/ /g\'\`
1686
    else
1687
      shlib_search_path=
1688
    fi
1689
    eval sys_lib_search_path=\"$sys_lib_search_path_spec\"
1690
    eval sys_lib_dlsearch_path=\"$sys_lib_dlsearch_path_spec\"
1691
 
1692
    output_objdir=`$echo "X$output" | $Xsed -e 's%/[^/]*$%%'`
1693
    if test "X$output_objdir" = "X$output"; then
1694
      output_objdir="$objdir"
1695
    else
1696
      output_objdir="$output_objdir/$objdir"
1697
    fi
1698
    # Create the object directory.
599 cbradney 1699
    if test ! -d "$output_objdir"; then
3 paul 1700
      $show "$mkdir $output_objdir"
1701
      $run $mkdir $output_objdir
1702
      status=$?
599 cbradney 1703
      if test "$status" -ne 0 && test ! -d "$output_objdir"; then
3 paul 1704
        exit $status
1705
      fi
1706
    fi
1707
 
1708
    # Determine the type of output
1709
    case $output in
1710
    "")
1711
      $echo "$modename: you must specify an output file" 1>&2
1712
      $echo "$help" 1>&2
1713
      exit 1
1714
      ;;
1715
    *.$libext) linkmode=oldlib ;;
1716
    *.lo | *.$objext) linkmode=obj ;;
1717
    *.la) linkmode=lib ;;
1718
    *) linkmode=prog ;; # Anything else should be a program.
1719
    esac
1720
 
599 cbradney 1721
    case $host in
1722
    *cygwin* | *mingw* | *pw32*)
1723
      # don't eliminate duplcations in $postdeps and $predeps
1724
      duplicate_compiler_generated_deps=yes
1725
      ;;
1726
    *)
1727
      duplicate_compiler_generated_deps=$duplicate_deps
1728
      ;;
1729
    esac
3 paul 1730
    specialdeplibs=
599 cbradney 1731
 
3 paul 1732
    libs=
1733
    # Find all interdependent deplibs by searching for libraries
1734
    # that are linked more than once (e.g. -la -lb -la)
1735
    for deplib in $deplibs; do
599 cbradney 1736
      if test "X$duplicate_deps" = "Xyes" ; then
1737
        case "$libs " in
1738
        *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
1739
        esac
1740
      fi
3 paul 1741
      libs="$libs $deplib"
1742
    done
1743
 
599 cbradney 1744
    if test "$linkmode" = lib; then
3 paul 1745
      libs="$predeps $libs $compiler_lib_search_path $postdeps"
599 cbradney 1746
 
1747
      # Compute libraries that are listed more than once in $predeps
1748
      # $postdeps and mark them as special (i.e., whose duplicates are
1749
      # not to be eliminated).
1750
      pre_post_deps=
1751
      if test "X$duplicate_compiler_generated_deps" = "Xyes" ; then
1752
        for pre_post_dep in $predeps $postdeps; do
1753
          case "$pre_post_deps " in
1754
          *" $pre_post_dep "*) specialdeplibs="$specialdeplibs $pre_post_deps" ;;
1755
          esac
1756
          pre_post_deps="$pre_post_deps $pre_post_dep"
1757
        done
1758
      fi
1759
      pre_post_deps=
3 paul 1760
    fi
1761
 
1762
    deplibs=
1763
    newdependency_libs=
1764
    newlib_search_path=
1765
    need_relink=no # whether we're linking any uninstalled libtool libraries
599 cbradney 1766
    notinst_deplibs= # not-installed libtool libraries
1767
    notinst_path= # paths that contain not-installed libtool libraries
3 paul 1768
    case $linkmode in
1769
    lib)
1770
        passes="conv link"
1771
        for file in $dlfiles $dlprefiles; do
1772
          case $file in
1773
          *.la) ;;
1774
          *)
1775
            $echo "$modename: libraries can \`-dlopen' only libtool libraries: $file" 1>&2
1776
            exit 1
1777
            ;;
1778
          esac
1779
        done
1780
        ;;
1781
    prog)
1782
        compile_deplibs=
1783
        finalize_deplibs=
1784
        alldeplibs=no
1785
        newdlfiles=
1786
        newdlprefiles=
1787
        passes="conv scan dlopen dlpreopen link"
1788
        ;;
599 cbradney 1789
    *)  passes="conv"
3 paul 1790
        ;;
1791
    esac
1792
    for pass in $passes; do
1793
      if test "$linkmode,$pass" = "lib,link" ||
1794
         test "$linkmode,$pass" = "prog,scan"; then
1795
        libs="$deplibs"
1796
        deplibs=
1797
      fi
599 cbradney 1798
      if test "$linkmode" = prog; then
3 paul 1799
        case $pass in
1800
        dlopen) libs="$dlfiles" ;;
1801
        dlpreopen) libs="$dlprefiles" ;;
1802
        link) libs="$deplibs %DEPLIBS% $dependency_libs" ;;
1803
        esac
1804
      fi
599 cbradney 1805
      if test "$pass" = dlopen; then
3 paul 1806
        # Collect dlpreopened libraries
1807
        save_deplibs="$deplibs"
1808
        deplibs=
1809
      fi
1810
      for deplib in $libs; do
1811
        lib=
1812
        found=no
1813
        case $deplib in
1814
        -l*)
599 cbradney 1815
          if test "$linkmode" != lib && test "$linkmode" != prog; then
3 paul 1816
            $echo "$modename: warning: \`-l' is ignored for archives/objects" 1>&2
1817
            continue
1818
          fi
599 cbradney 1819
          if test "$pass" = conv && test "$allow_undefined" = yes; then
3 paul 1820
            deplibs="$deplib $deplibs"
1821
            continue
1822
          fi
1823
          name=`$echo "X$deplib" | $Xsed -e 's/^-l//'`
1824
          for searchdir in $newlib_search_path $lib_search_path $sys_lib_search_path $shlib_search_path; do
599 cbradney 1825
            for search_ext in .la $shrext .so .a; do
1826
              # Search the libtool library
1827
              lib="$searchdir/lib${name}${search_ext}"
1828
              if test -f "$lib"; then
1829
                if test "$search_ext" = ".la"; then
1830
                  found=yes
1831
                else
1832
                  found=no
1833
                fi
1834
                break 2
1835
              fi
1836
            done
3 paul 1837
          done
1838
          if test "$found" != yes; then
599 cbradney 1839
            # deplib doesn't seem to be a libtool library
3 paul 1840
            if test "$linkmode,$pass" = "prog,link"; then
1841
              compile_deplibs="$deplib $compile_deplibs"
1842
              finalize_deplibs="$deplib $finalize_deplibs"
1843
            else
1844
              deplibs="$deplib $deplibs"
599 cbradney 1845
              test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
3 paul 1846
            fi
1847
            continue
599 cbradney 1848
          else # deplib is a libtool library
1849
            # If $allow_libtool_libs_with_static_runtimes && $deplib is a stdlib,
1850
            # We need to do some special things here, and not later.
1851
            if test "X$allow_libtool_libs_with_static_runtimes" = "Xyes" ; then
1852
              case " $predeps $postdeps " in
1853
              *" $deplib "*)
1854
                if (${SED} -e '2q' $lib |
1855
                    grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then
1856
                  library_names=
1857
                  old_library=
1858
                  case $lib in
1859
                  */* | *\\*) . $lib ;;
1860
                  *) . ./$lib ;;
1861
                  esac
1862
                  for l in $old_library $library_names; do
1863
                    ll="$l"
1864
                  done
1865
                  if test "X$ll" = "X$old_library" ; then # only static version available
1866
                    found=no
1867
                    ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1868
                    test "X$ladir" = "X$lib" && ladir="."
1869
                    lib=$ladir/$old_library
1870
                    if test "$linkmode,$pass" = "prog,link"; then
1871
                      compile_deplibs="$deplib $compile_deplibs"
1872
                      finalize_deplibs="$deplib $finalize_deplibs"
1873
                    else
1874
                      deplibs="$deplib $deplibs"
1875
                      test "$linkmode" = lib && newdependency_libs="$deplib $newdependency_libs"
1876
                    fi
1877
                    continue
1878
                  fi
1879
                fi
1880
                ;;
1881
              *) ;;
1882
              esac
1883
            fi
3 paul 1884
          fi
599 cbradney 1885
          ;; # -l
3 paul 1886
        -L*)
1887
          case $linkmode in
1888
          lib)
1889
            deplibs="$deplib $deplibs"
599 cbradney 1890
            test "$pass" = conv && continue
3 paul 1891
            newdependency_libs="$deplib $newdependency_libs"
1892
            newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1893
            ;;
1894
          prog)
599 cbradney 1895
            if test "$pass" = conv; then
3 paul 1896
              deplibs="$deplib $deplibs"
1897
              continue
1898
            fi
599 cbradney 1899
            if test "$pass" = scan; then
3 paul 1900
              deplibs="$deplib $deplibs"
1901
              newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`
1902
            else
1903
              compile_deplibs="$deplib $compile_deplibs"
1904
              finalize_deplibs="$deplib $finalize_deplibs"
1905
            fi
1906
            ;;
1907
          *)
1908
            $echo "$modename: warning: \`-L' is ignored for archives/objects" 1>&2
1909
            ;;
599 cbradney 1910
          esac # linkmode
3 paul 1911
          continue
599 cbradney 1912
          ;; # -L
3 paul 1913
        -R*)
599 cbradney 1914
          if test "$pass" = link; then
3 paul 1915
            dir=`$echo "X$deplib" | $Xsed -e 's/^-R//'`
1916
            # Make sure the xrpath contains only unique directories.
1917
            case "$xrpath " in
1918
            *" $dir "*) ;;
1919
            *) xrpath="$xrpath $dir" ;;
1920
            esac
1921
          fi
1922
          deplibs="$deplib $deplibs"
1923
          continue
1924
          ;;
1925
        *.la) lib="$deplib" ;;
1926
        *.$libext)
599 cbradney 1927
          if test "$pass" = conv; then
3 paul 1928
            deplibs="$deplib $deplibs"
1929
            continue
1930
          fi
1931
          case $linkmode in
1932
          lib)
1933
            if test "$deplibs_check_method" != pass_all; then
599 cbradney 1934
              $echo
1935
              $echo "*** Warning: Trying to link with static lib archive $deplib."
1936
              $echo "*** I have the capability to make that library automatically link in when"
1937
              $echo "*** you link to this library.  But I can only do this if you have a"
1938
              $echo "*** shared version of the library, which you do not appear to have"
1939
              $echo "*** because the file extensions .$libext of this argument makes me believe"
1940
              $echo "*** that it is just a static archive that I should not used here."
3 paul 1941
            else
599 cbradney 1942
              $echo
1943
              $echo "*** Warning: Linking the shared library $output against the"
1944
              $echo "*** static library $deplib is not portable!"
3 paul 1945
              deplibs="$deplib $deplibs"
1946
            fi
1947
            continue
1948
            ;;
1949
          prog)
599 cbradney 1950
            if test "$pass" != link; then
3 paul 1951
              deplibs="$deplib $deplibs"
1952
            else
1953
              compile_deplibs="$deplib $compile_deplibs"
1954
              finalize_deplibs="$deplib $finalize_deplibs"
1955
            fi
1956
            continue
1957
            ;;
599 cbradney 1958
          esac # linkmode
1959
          ;; # *.$libext
3 paul 1960
        *.lo | *.$objext)
599 cbradney 1961
          if test "$pass" = conv; then
3 paul 1962
            deplibs="$deplib $deplibs"
599 cbradney 1963
          elif test "$linkmode" = prog; then
1964
            if test "$pass" = dlpreopen || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
3 paul 1965
              # If there is no dlopen support or we're linking statically,
1966
              # we need to preload.
1967
              newdlprefiles="$newdlprefiles $deplib"
1968
              compile_deplibs="$deplib $compile_deplibs"
1969
              finalize_deplibs="$deplib $finalize_deplibs"
1970
            else
1971
              newdlfiles="$newdlfiles $deplib"
1972
            fi
1973
          fi
1974
          continue
1975
          ;;
1976
        %DEPLIBS%)
1977
          alldeplibs=yes
1978
          continue
1979
          ;;
599 cbradney 1980
        esac # case $deplib
1981
        if test "$found" = yes || test -f "$lib"; then :
3 paul 1982
        else
1983
          $echo "$modename: cannot find the library \`$lib'" 1>&2
1984
          exit 1
1985
        fi
1986
 
1987
        # Check to see that this really is a libtool archive.
599 cbradney 1988
        if (${SED} -e '2q' $lib | grep "^# Generated by .*$PACKAGE") >/dev/null 2>&1; then :
3 paul 1989
        else
1990
          $echo "$modename: \`$lib' is not a valid libtool archive" 1>&2
1991
          exit 1
1992
        fi
1993
 
1994
        ladir=`$echo "X$lib" | $Xsed -e 's%/[^/]*$%%'`
1995
        test "X$ladir" = "X$lib" && ladir="."
1996
 
1997
        dlname=
1998
        dlopen=
1999
        dlpreopen=
2000
        libdir=
2001
        library_names=
2002
        old_library=
2003
        # If the library was installed with an old release of libtool,
599 cbradney 2004
        # it will not redefine variables installed, or shouldnotlink
3 paul 2005
        installed=yes
599 cbradney 2006
        shouldnotlink=no
3 paul 2007
 
2008
        # Read the .la file
2009
        case $lib in
2010
        */* | *\\*) . $lib ;;
2011
        *) . ./$lib ;;
2012
        esac
2013
 
2014
        if test "$linkmode,$pass" = "lib,link" ||
2015
           test "$linkmode,$pass" = "prog,scan" ||
599 cbradney 2016
           { test "$linkmode" != prog && test "$linkmode" != lib; }; then
3 paul 2017
          test -n "$dlopen" && dlfiles="$dlfiles $dlopen"
2018
          test -n "$dlpreopen" && dlprefiles="$dlprefiles $dlpreopen"
2019
        fi
2020
 
599 cbradney 2021
        if test "$pass" = conv; then
2022
          # Only check for convenience libraries
3 paul 2023
          deplibs="$lib $deplibs"
599 cbradney 2024
          tmp_libs=
2025
          for deplib in $dependency_libs; do
2026
            #echo "Adding $deplib to \$deplibs"
2027
            deplibs="$deplib $deplibs"
2028
            if test "X$duplicate_deps" = "Xyes" ; then
2029
              case "$tmp_libs " in
2030
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2031
              esac
2032
            fi
2033
            tmp_libs="$tmp_libs $deplib"
2034
          done
3 paul 2035
          if test -z "$libdir"; then
2036
            if test -z "$old_library"; then
2037
              $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2038
              exit 1
2039
            fi
2040
            # It is a libtool convenience library, so add in its objects.
2041
            convenience="$convenience $ladir/$objdir/$old_library"
2042
            old_convenience="$old_convenience $ladir/$objdir/$old_library"
599 cbradney 2043
          elif test "$linkmode" != prog && test "$linkmode" != lib; then
3 paul 2044
            $echo "$modename: \`$lib' is not a convenience library" 1>&2
2045
            exit 1
2046
          fi
2047
          continue
599 cbradney 2048
        fi # $pass = conv
3 paul 2049
 
599 cbradney 2050
 
3 paul 2051
        # Get the name of the library we link against.
2052
        linklib=
2053
        for l in $old_library $library_names; do
2054
          linklib="$l"
2055
        done
2056
        if test -z "$linklib"; then
2057
          $echo "$modename: cannot find name of link library for \`$lib'" 1>&2
2058
          exit 1
2059
        fi
2060
 
2061
        # This library was specified with -dlopen.
599 cbradney 2062
        if test "$pass" = dlopen; then
3 paul 2063
          if test -z "$libdir"; then
2064
            $echo "$modename: cannot -dlopen a convenience library: \`$lib'" 1>&2
2065
            exit 1
2066
          fi
2067
          if test -z "$dlname" || test "$dlopen_support" != yes || test "$build_libtool_libs" = no; then
2068
            # If there is no dlname, no dlopen support or we're linking
2069
            # statically, we need to preload.  We also need to preload any
2070
            # dependent libraries so libltdl's deplib preloader doesn't
2071
            # bomb out in the load deplibs phase.
2072
            dlprefiles="$dlprefiles $lib $dependency_libs"
2073
          else
2074
            newdlfiles="$newdlfiles $lib"
2075
          fi
2076
          continue
599 cbradney 2077
        fi # $pass = dlopen
3 paul 2078
 
2079
        # We need an absolute path.
2080
        case $ladir in
2081
        [\\/]* | [A-Za-z]:[\\/]*) abs_ladir="$ladir" ;;
2082
        *)
2083
          abs_ladir=`cd "$ladir" && pwd`
2084
          if test -z "$abs_ladir"; then
2085
            $echo "$modename: warning: cannot determine absolute directory name of \`$ladir'" 1>&2
2086
            $echo "$modename: passing it literally to the linker, although it might fail" 1>&2
2087
            abs_ladir="$ladir"
2088
          fi
2089
          ;;
2090
        esac
2091
        laname=`$echo "X$lib" | $Xsed -e 's%^.*/%%'`
2092
 
2093
        # Find the relevant object directory and library name.
2094
        if test "X$installed" = Xyes; then
2095
          if test ! -f "$libdir/$linklib" && test -f "$abs_ladir/$linklib"; then
2096
            $echo "$modename: warning: library \`$lib' was moved." 1>&2
2097
            dir="$ladir"
2098
            absdir="$abs_ladir"
2099
            libdir="$abs_ladir"
2100
          else
2101
            dir="$libdir"
2102
            absdir="$libdir"
2103
          fi
2104
        else
2105
          dir="$ladir/$objdir"
2106
          absdir="$abs_ladir/$objdir"
2107
          # Remove this search path later
599 cbradney 2108
          notinst_path="$notinst_path $abs_ladir"
2109
        fi # $installed = yes
3 paul 2110
        name=`$echo "X$laname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
2111
 
2112
        # This library was specified with -dlpreopen.
599 cbradney 2113
        if test "$pass" = dlpreopen; then
3 paul 2114
          if test -z "$libdir"; then
2115
            $echo "$modename: cannot -dlpreopen a convenience library: \`$lib'" 1>&2
2116
            exit 1
2117
          fi
2118
          # Prefer using a static library (so that no silly _DYNAMIC symbols
2119
          # are required to link).
2120
          if test -n "$old_library"; then
2121
            newdlprefiles="$newdlprefiles $dir/$old_library"
2122
          # Otherwise, use the dlname, so that lt_dlopen finds it.
2123
          elif test -n "$dlname"; then
2124
            newdlprefiles="$newdlprefiles $dir/$dlname"
2125
          else
2126
            newdlprefiles="$newdlprefiles $dir/$linklib"
2127
          fi
599 cbradney 2128
        fi # $pass = dlpreopen
3 paul 2129
 
2130
        if test -z "$libdir"; then
599 cbradney 2131
          # Link the convenience library
2132
          if test "$linkmode" = lib; then
3 paul 2133
            deplibs="$dir/$old_library $deplibs"
2134
          elif test "$linkmode,$pass" = "prog,link"; then
2135
            compile_deplibs="$dir/$old_library $compile_deplibs"
2136
            finalize_deplibs="$dir/$old_library $finalize_deplibs"
2137
          else
2138
            deplibs="$lib $deplibs" # used for prog,scan pass
2139
          fi
2140
          continue
2141
        fi
2142
 
599 cbradney 2143
 
2144
        if test "$linkmode" = prog && test "$pass" != link; then
3 paul 2145
          newlib_search_path="$newlib_search_path $ladir"
2146
          deplibs="$lib $deplibs"
2147
 
2148
          linkalldeplibs=no
2149
          if test "$link_all_deplibs" != no || test -z "$library_names" ||
2150
             test "$build_libtool_libs" = no; then
2151
            linkalldeplibs=yes
2152
          fi
2153
 
2154
          tmp_libs=
2155
          for deplib in $dependency_libs; do
2156
            case $deplib in
2157
            -L*) newlib_search_path="$newlib_search_path "`$echo "X$deplib" | $Xsed -e 's/^-L//'`;; ### testsuite: skip nested quoting test
2158
            esac
2159
            # Need to link against all dependency_libs?
599 cbradney 2160
            if test "$linkalldeplibs" = yes; then
3 paul 2161
              deplibs="$deplib $deplibs"
2162
            else
2163
              # Need to hardcode shared library paths
2164
              # or/and link against static libraries
2165
              newdependency_libs="$deplib $newdependency_libs"
2166
            fi
599 cbradney 2167
            if test "X$duplicate_deps" = "Xyes" ; then
2168
              case "$tmp_libs " in
2169
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2170
              esac
2171
            fi
3 paul 2172
            tmp_libs="$tmp_libs $deplib"
599 cbradney 2173
          done # for deplib
3 paul 2174
          continue
599 cbradney 2175
        fi # $linkmode = prog...
3 paul 2176
 
2177
        if test "$linkmode,$pass" = "prog,link"; then
2178
          if test -n "$library_names" &&
2179
             { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2180
            # We need to hardcode the library path
2181
            if test -n "$shlibpath_var"; then
2182
              # Make sure the rpath contains only unique directories.
2183
              case "$temp_rpath " in
2184
              *" $dir "*) ;;
2185
              *" $absdir "*) ;;
2186
              *) temp_rpath="$temp_rpath $dir" ;;
2187
              esac
2188
            fi
2189
 
2190
            # Hardcode the library path.
2191
            # Skip directories that are in the system default run-time
2192
            # search path.
2193
            case " $sys_lib_dlsearch_path " in
2194
            *" $absdir "*) ;;
2195
            *)
2196
              case "$compile_rpath " in
2197
              *" $absdir "*) ;;
2198
              *) compile_rpath="$compile_rpath $absdir"
2199
              esac
2200
              ;;
2201
            esac
2202
            case " $sys_lib_dlsearch_path " in
2203
            *" $libdir "*) ;;
2204
            *)
2205
              case "$finalize_rpath " in
2206
              *" $libdir "*) ;;
2207
              *) finalize_rpath="$finalize_rpath $libdir"
2208
              esac
2209
              ;;
2210
            esac
599 cbradney 2211
          fi # $linkmode,$pass = prog,link...
3 paul 2212
 
2213
          if test "$alldeplibs" = yes &&
2214
             { test "$deplibs_check_method" = pass_all ||
2215
               { test "$build_libtool_libs" = yes &&
2216
                 test -n "$library_names"; }; }; then
2217
            # We only need to search for static libraries
2218
            continue
2219
          fi
2220
        fi
2221
 
2222
        link_static=no # Whether the deplib will be linked statically
2223
        if test -n "$library_names" &&
2224
           { test "$prefer_static_libs" = no || test -z "$old_library"; }; then
2225
          if test "$installed" = no; then
599 cbradney 2226
            notinst_deplibs="$notinst_deplibs $lib"
3 paul 2227
            need_relink=yes
2228
          fi
2229
          # This is a shared library
599 cbradney 2230
 
2231
      # Warn about portability, can't link against -module's on some systems (darwin)
2232
      if test "$shouldnotlink" = yes && test "$pass" = link ; then
2233
            $echo
2234
            if test "$linkmode" = prog; then
2235
              $echo "*** Warning: Linking the executable $output against the loadable module"
2236
            else
2237
              $echo "*** Warning: Linking the shared library $output against the loadable module"
2238
            fi
2239
            $echo "*** $linklib is not portable!"    
2240
      fi         
2241
          if test "$linkmode" = lib &&
2242
             test "$hardcode_into_libs" = yes; then
3 paul 2243
            # Hardcode the library path.
2244
            # Skip directories that are in the system default run-time
2245
            # search path.
2246
            case " $sys_lib_dlsearch_path " in
2247
            *" $absdir "*) ;;
2248
            *)
2249
              case "$compile_rpath " in
2250
              *" $absdir "*) ;;
2251
              *) compile_rpath="$compile_rpath $absdir"
2252
              esac
2253
              ;;
2254
            esac
2255
            case " $sys_lib_dlsearch_path " in
2256
            *" $libdir "*) ;;
2257
            *)
2258
              case "$finalize_rpath " in
2259
              *" $libdir "*) ;;
2260
              *) finalize_rpath="$finalize_rpath $libdir"
2261
              esac
2262
              ;;
2263
            esac
2264
          fi
2265
 
2266
          if test -n "$old_archive_from_expsyms_cmds"; then
2267
            # figure out the soname
2268
            set dummy $library_names
2269
            realname="$2"
2270
            shift; shift
2271
            libname=`eval \\$echo \"$libname_spec\"`
2272
            # use dlname if we got it. it's perfectly good, no?
2273
            if test -n "$dlname"; then
2274
              soname="$dlname"
2275
            elif test -n "$soname_spec"; then
2276
              # bleh windows
2277
              case $host in
599 cbradney 2278
              *cygwin* | mingw*)
3 paul 2279
                major=`expr $current - $age`
2280
                versuffix="-$major"
2281
                ;;
2282
              esac
2283
              eval soname=\"$soname_spec\"
2284
            else
2285
              soname="$realname"
2286
            fi
2287
 
2288
            # Make a new name for the extract_expsyms_cmds to use
2289
            soroot="$soname"
599 cbradney 2290
            soname=`$echo $soroot | ${SED} -e 's/^.*\///'`
2291
            newlib="libimp-`$echo $soname | ${SED} 's/^lib//;s/\.dll$//'`.a"
3 paul 2292
 
2293
            # If the library has no export list, then create one now
2294
            if test -f "$output_objdir/$soname-def"; then :
2295
            else
2296
              $show "extracting exported symbol list from \`$soname'"
599 cbradney 2297
              save_ifs="$IFS"; IFS='~'
3 paul 2298
              eval cmds=\"$extract_expsyms_cmds\"
2299
              for cmd in $cmds; do
2300
                IFS="$save_ifs"
2301
                $show "$cmd"
2302
                $run eval "$cmd" || exit $?
2303
              done
2304
              IFS="$save_ifs"
2305
            fi
2306
 
2307
            # Create $newlib
2308
            if test -f "$output_objdir/$newlib"; then :; else
2309
              $show "generating import library for \`$soname'"
599 cbradney 2310
              save_ifs="$IFS"; IFS='~'
3 paul 2311
              eval cmds=\"$old_archive_from_expsyms_cmds\"
2312
              for cmd in $cmds; do
2313
                IFS="$save_ifs"
2314
                $show "$cmd"
2315
                $run eval "$cmd" || exit $?
2316
              done
2317
              IFS="$save_ifs"
2318
            fi
2319
            # make sure the library variables are pointing to the new library
2320
            dir=$output_objdir
2321
            linklib=$newlib
599 cbradney 2322
          fi # test -n "$old_archive_from_expsyms_cmds"
3 paul 2323
 
599 cbradney 2324
          if test "$linkmode" = prog || test "$mode" != relink; then
3 paul 2325
            add_shlibpath=
2326
            add_dir=
2327
            add=
2328
            lib_linked=yes
2329
            case $hardcode_action in
2330
            immediate | unsupported)
2331
              if test "$hardcode_direct" = no; then
2332
                add="$dir/$linklib"
599 cbradney 2333
                case $host in
2334
                  *-*-sco3.2v5* ) add_dir="-L$dir" ;;
2335
                  *-*-darwin* )
2336
                    # if the lib is a module then we can not link against it, someone
2337
                    # is ignoring the new warnings I added
2338
                    if /usr/bin/file -L $add 2> /dev/null | grep "bundle" >/dev/null ; then
2339
                      $echo "** Warning, lib $linklib is a module, not a shared library"
2340
                      if test -z "$old_library" ; then
2341
                        $echo
2342
                        $echo "** And there doesn't seem to be a static archive available"
2343
                        $echo "** The link will probably fail, sorry"
2344
                      else
2345
                        add="$dir/$old_library"
2346
                      fi
2347
                    fi
2348
                esac
3 paul 2349
              elif test "$hardcode_minus_L" = no; then
2350
                case $host in
2351
                *-*-sunos*) add_shlibpath="$dir" ;;
2352
                esac
2353
                add_dir="-L$dir"
2354
                add="-l$name"
2355
              elif test "$hardcode_shlibpath_var" = no; then
2356
                add_shlibpath="$dir"
2357
                add="-l$name"
2358
              else
2359
                lib_linked=no
2360
              fi
2361
              ;;
2362
            relink)
2363
              if test "$hardcode_direct" = yes; then
2364
                add="$dir/$linklib"
2365
              elif test "$hardcode_minus_L" = yes; then
2366
                add_dir="-L$dir"
599 cbradney 2367
                # Try looking first in the location we're being installed to.
2368
                if test -n "$inst_prefix_dir"; then
2369
                  case "$libdir" in
2370
                    [\\/]*)
2371
                      add_dir="-L$inst_prefix_dir$libdir $add_dir"
2372
                      ;;
2373
                  esac
2374
                fi
3 paul 2375
                add="-l$name"
2376
              elif test "$hardcode_shlibpath_var" = yes; then
2377
                add_shlibpath="$dir"
2378
                add="-l$name"
2379
              else
2380
                lib_linked=no
2381
              fi
2382
              ;;
2383
            *) lib_linked=no ;;
2384
            esac
2385
 
2386
            if test "$lib_linked" != yes; then
2387
              $echo "$modename: configuration error: unsupported hardcode properties"
2388
              exit 1
2389
            fi
2390
 
2391
            if test -n "$add_shlibpath"; then
2392
              case :$compile_shlibpath: in
2393
              *":$add_shlibpath:"*) ;;
2394
              *) compile_shlibpath="$compile_shlibpath$add_shlibpath:" ;;
2395
              esac
2396
            fi
599 cbradney 2397
            if test "$linkmode" = prog; then
3 paul 2398
              test -n "$add_dir" && compile_deplibs="$add_dir $compile_deplibs"
2399
              test -n "$add" && compile_deplibs="$add $compile_deplibs"
2400
            else
2401
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
2402
              test -n "$add" && deplibs="$add $deplibs"
2403
              if test "$hardcode_direct" != yes && \
2404
                 test "$hardcode_minus_L" != yes && \
2405
                 test "$hardcode_shlibpath_var" = yes; then
2406
                case :$finalize_shlibpath: in
2407
                *":$libdir:"*) ;;
2408
                *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2409
                esac
2410
              fi
2411
            fi
2412
          fi
2413
 
599 cbradney 2414
          if test "$linkmode" = prog || test "$mode" = relink; then
3 paul 2415
            add_shlibpath=
2416
            add_dir=
2417
            add=
2418
            # Finalize command for both is simple: just hardcode it.
2419
            if test "$hardcode_direct" = yes; then
2420
              add="$libdir/$linklib"
2421
            elif test "$hardcode_minus_L" = yes; then
2422
              add_dir="-L$libdir"
2423
              add="-l$name"
2424
            elif test "$hardcode_shlibpath_var" = yes; then
2425
              case :$finalize_shlibpath: in
2426
              *":$libdir:"*) ;;
2427
              *) finalize_shlibpath="$finalize_shlibpath$libdir:" ;;
2428
              esac
2429
              add="-l$name"
599 cbradney 2430
            elif test "$hardcode_automatic" = yes; then
2431
              if test -n "$inst_prefix_dir" && test -f "$inst_prefix_dir$libdir/$linklib" ; then
2432
                add="$inst_prefix_dir$libdir/$linklib"
2433
              else
2434
                add="$libdir/$linklib"
2435
              fi
3 paul 2436
            else
2437
              # We cannot seem to hardcode it, guess we'll fake it.
2438
              add_dir="-L$libdir"
599 cbradney 2439
              # Try looking first in the location we're being installed to.
2440
              if test -n "$inst_prefix_dir"; then
2441
                case "$libdir" in
2442
                  [\\/]*)
2443
                    add_dir="-L$inst_prefix_dir$libdir $add_dir"
2444
                    ;;
2445
                esac
2446
              fi
3 paul 2447
              add="-l$name"
2448
            fi
2449
 
599 cbradney 2450
            if test "$linkmode" = prog; then
3 paul 2451
              test -n "$add_dir" && finalize_deplibs="$add_dir $finalize_deplibs"
2452
              test -n "$add" && finalize_deplibs="$add $finalize_deplibs"
2453
            else
2454
              test -n "$add_dir" && deplibs="$add_dir $deplibs"
2455
              test -n "$add" && deplibs="$add $deplibs"
2456
            fi
2457
          fi
599 cbradney 2458
        elif test "$linkmode" = prog; then
3 paul 2459
          # Here we assume that one of hardcode_direct or hardcode_minus_L
2460
          # is not unsupported.  This is valid on all known static and
2461
          # shared platforms.
2462
          if test "$hardcode_direct" != unsupported; then
2463
            test -n "$old_library" && linklib="$old_library"
2464
            compile_deplibs="$dir/$linklib $compile_deplibs"
2465
            finalize_deplibs="$dir/$linklib $finalize_deplibs"
2466
          else
2467
            compile_deplibs="-l$name -L$dir $compile_deplibs"
2468
            finalize_deplibs="-l$name -L$dir $finalize_deplibs"
2469
          fi
2470
        elif test "$build_libtool_libs" = yes; then
2471
          # Not a shared library
2472
          if test "$deplibs_check_method" != pass_all; then
2473
            # We're trying link a shared library against a static one
2474
            # but the system doesn't support it.
599 cbradney 2475
 
3 paul 2476
            # Just print a warning and add the library to dependency_libs so
2477
            # that the program can be linked against the static library.
599 cbradney 2478
            $echo
2479
            $echo "*** Warning: This system can not link to static lib archive $lib."
2480
            $echo "*** I have the capability to make that library automatically link in when"
2481
            $echo "*** you link to this library.  But I can only do this if you have a"
2482
            $echo "*** shared version of the library, which you do not appear to have."
2483
            if test "$module" = yes; then
2484
              $echo "*** But as you try to build a module library, libtool will still create "
2485
              $echo "*** a static module, that should work as long as the dlopening application"
2486
              $echo "*** is linked with the -dlopen flag to resolve symbols at runtime."
2487
              if test -z "$global_symbol_pipe"; then
2488
                $echo
2489
                $echo "*** However, this would only work if libtool was able to extract symbol"
2490
                $echo "*** lists from a program, using \`nm' or equivalent, but libtool could"
2491
                $echo "*** not find such a program.  So, this module is probably useless."
2492
                $echo "*** \`nm' from GNU binutils and a full rebuild may help."
2493
              fi
2494
              if test "$build_old_libs" = no; then
2495
                build_libtool_libs=module
2496
                build_old_libs=yes
2497
              else
2498
                build_libtool_libs=no
2499
              fi
2500
            fi
3 paul 2501
          else
2502
            convenience="$convenience $dir/$old_library"
2503
            old_convenience="$old_convenience $dir/$old_library"
2504
            deplibs="$dir/$old_library $deplibs"
2505
            link_static=yes
2506
          fi
599 cbradney 2507
        fi # link shared/static library?
3 paul 2508
 
599 cbradney 2509
        if test "$linkmode" = lib; then
2510
          #if test -n "$dependency_libs" &&
2511
          #   { test "$hardcode_into_libs" != yes || test "$build_old_libs" = yes ||
2512
          #     test "$link_static" = yes; }; then
3 paul 2513
            # Extract -R from dependency_libs
2514
            temp_deplibs=
2515
            for libdir in $dependency_libs; do
2516
              case $libdir in
2517
              -R*) temp_xrpath=`$echo "X$libdir" | $Xsed -e 's/^-R//'`
2518
                   case " $xrpath " in
2519
                   *" $temp_xrpath "*) ;;
2520
                   *) xrpath="$xrpath $temp_xrpath";;
2521
                   esac;;
2522
              *) temp_deplibs="$temp_deplibs $libdir";;
2523
              esac
2524
            done
2525
            dependency_libs="$temp_deplibs"
599 cbradney 2526
          #fi
3 paul 2527
 
2528
          newlib_search_path="$newlib_search_path $absdir"
2529
          # Link against this library
2530
          test "$link_static" = no && newdependency_libs="$abs_ladir/$laname $newdependency_libs"
2531
          # ... and its dependency_libs
2532
          tmp_libs=
2533
          for deplib in $dependency_libs; do
2534
            newdependency_libs="$deplib $newdependency_libs"
599 cbradney 2535
            if test "X$duplicate_deps" = "Xyes" ; then
2536
              case "$tmp_libs " in
2537
              *" $deplib "*) specialdeplibs="$specialdeplibs $deplib" ;;
2538
              esac
2539
            fi
3 paul 2540
            tmp_libs="$tmp_libs $deplib"
2541
          done
2542
 
599 cbradney 2543
          if test "$link_all_deplibs" != no; then
3 paul 2544
            # Add the search paths of all dependency libraries
2545
            for deplib in $dependency_libs; do
2546
              case $deplib in
2547
              -L*) path="$deplib" ;;
2548
              *.la)
2549
                dir=`$echo "X$deplib" | $Xsed -e 's%/[^/]*$%%'`
2550
                test "X$dir" = "X$deplib" && dir="."
2551
                # We need an absolute path.
2552
                case $dir in
2553
                [\\/]* | [A-Za-z]:[\\/]*) absdir="$dir" ;;
2554
                *)
2555
                  absdir=`cd "$dir" && pwd`
2556
                  if test -z "$absdir"; then
2557
                    $echo "$modename: warning: cannot determine absolute directory name of \`$dir'" 1>&2
2558
                    absdir="$dir"
2559
                  fi
2560
                  ;;
2561
                esac
2562
                if grep "^installed=no" $deplib > /dev/null; then
599 cbradney 2563
                  path="$absdir/$objdir"
3 paul 2564
                else
599 cbradney 2565
                  eval libdir=`${SED} -n -e 's/^libdir=\(.*\)$/\1/p' $deplib`
3 paul 2566
                  if test -z "$libdir"; then
2567
                    $echo "$modename: \`$deplib' is not a valid libtool archive" 1>&2
2568
                    exit 1
2569
                  fi
2570
                  if test "$absdir" != "$libdir"; then
599 cbradney 2571
                    # Sure, some shells/systems don't implement the -ef.
2572
                    # Those will have to live with the warning.
2573
                    test "$absdir" -ef "$libdir" > /dev/null 2>&1 ||
2574
                      $echo "$modename: warning: \`$deplib' seems to be moved" 1>&2
3 paul 2575
                  fi
599 cbradney 2576
                  path="$absdir"
3 paul 2577
                fi
599 cbradney 2578
                depdepl=
2579
                case $host in
2580
                *-*-darwin*)
2581
                  # we do not want to link against static libs, but need to link against shared
2582
                  eval deplibrary_names=`${SED} -n -e 's/^library_names=\(.*\)$/\1/p' $deplib`
2583
                  if test -n "$deplibrary_names" ; then
2584
                    for tmp in $deplibrary_names ; do
2585
                      depdepl=$tmp
2586
                    done
2587
                    if test -f "$path/$depdepl" ; then
2588
                      depdepl="$path/$depdepl"
2589
                   fi
2590
                    # do not add paths which are already there
2591
                    case " $newlib_search_path " in
2592
                    *" $path "*) ;;
2593
                    *) newlib_search_path="$newlib_search_path $path";;
2594
                    esac
2595
                    path=""
2596
                  fi
2597
                  ;;
2598
                *)
2599
                path="-L$path"
3 paul 2600
                ;;
599 cbradney 2601
                esac
2602
 
2603
                ;;
2604
                  -l*)
2605
                case $host in
2606
                *-*-darwin*)
2607
                 # Again, we only want to link against shared libraries
2608
                 eval tmp_libs=`$echo "X$deplib" | $Xsed -e "s,^\-l,,"`
2609
                 for tmp in $newlib_search_path ; do
2610
                     if test -f "$tmp/lib$tmp_libs.dylib" ; then
2611
                       eval depdepl="$tmp/lib$tmp_libs.dylib"
2612
                       break
2613
                     fi  
2614
         done
2615
         path=""
2616
                  ;;
2617
                *) continue ;;
2618
                esac             
2619
                ;;
3 paul 2620
              *) continue ;;
2621
              esac
2622
              case " $deplibs " in
599 cbradney 2623
              *" $depdepl "*) ;;
2624
              *) deplibs="$deplibs $depdepl" ;;
2625
              esac           
2626
              case " $deplibs " in
3 paul 2627
              *" $path "*) ;;
599 cbradney 2628
              *) deplibs="$deplibs $path" ;;
3 paul 2629
              esac
2630
            done
599 cbradney 2631
          fi # link_all_deplibs != no
2632
        fi # linkmode = lib
2633
      done # for deplib in $libs
3 paul 2634
      dependency_libs="$newdependency_libs"
599 cbradney 2635
      if test "$pass" = dlpreopen; then
3 paul 2636
        # Link the dlpreopened libraries before other libraries
2637
        for deplib in $save_deplibs; do
2638
          deplibs="$deplib $deplibs"
2639
        done
2640
      fi
599 cbradney 2641
      if test "$pass" != dlopen; then
2642
        if test "$pass" != conv; then
3 paul 2643
          # Make sure lib_search_path contains only unique directories.
2644
          lib_search_path=
2645
          for dir in $newlib_search_path; do
2646
            case "$lib_search_path " in
2647
            *" $dir "*) ;;
2648
            *) lib_search_path="$lib_search_path $dir" ;;
2649
            esac
2650
          done
2651
          newlib_search_path=
2652
        fi
2653
 
2654
        if test "$linkmode,$pass" != "prog,link"; then
2655
          vars="deplibs"
2656
        else
2657
          vars="compile_deplibs finalize_deplibs"
2658
        fi
2659
        for var in $vars dependency_libs; do
599 cbradney 2660
          # Add libraries to $var in reverse order
3 paul 2661
          eval tmp_libs=\"\$$var\"
2662
          new_libs=
2663
          for deplib in $tmp_libs; do
599 cbradney 2664
            # FIXME: Pedantically, this is the right thing to do, so
2665
            #        that some nasty dependency loop isn't accidentally
2666
            #        broken:
2667
            #new_libs="$deplib $new_libs"
2668
            # Pragmatically, this seems to cause very few problems in
2669
            # practice:
2670
            case $deplib in
3 paul 2671
            -L*) new_libs="$deplib $new_libs" ;;
599 cbradney 2672
            -R*) ;;
3 paul 2673
            *)
599 cbradney 2674
              # And here is the reason: when a library appears more
2675
              # than once as an explicit dependence of a library, or
2676
              # is implicitly linked in more than once by the
2677
              # compiler, it is considered special, and multiple
2678
              # occurrences thereof are not removed.  Compare this
2679
              # with having the same library being listed as a
2680
              # dependency of multiple other libraries: in this case,
2681
              # we know (pedantically, we assume) the library does not
2682
              # need to be listed more than once, so we keep only the
2683
              # last copy.  This is not always right, but it is rare
2684
              # enough that we require users that really mean to play
2685
              # such unportable linking tricks to link the library
2686
              # using -Wl,-lname, so that libtool does not consider it
2687
              # for duplicate removal.
3 paul 2688
              case " $specialdeplibs " in
2689
              *" $deplib "*) new_libs="$deplib $new_libs" ;;
2690
              *)
2691
                case " $new_libs " in
2692
                *" $deplib "*) ;;
2693
                *) new_libs="$deplib $new_libs" ;;
2694
                esac
2695
                ;;
2696
              esac
2697
              ;;
2698
            esac
2699
          done
2700
          tmp_libs=
2701
          for deplib in $new_libs; do
2702
            case $deplib in
2703
            -L*)
2704
              case " $tmp_libs " in
2705
              *" $deplib "*) ;;
2706
              *) tmp_libs="$tmp_libs $deplib" ;;
2707
              esac
2708
              ;;
2709
            *) tmp_libs="$tmp_libs $deplib" ;;
2710
            esac
2711
          done
2712
          eval $var=\"$tmp_libs\"
599 cbradney 2713
        done # for var
3 paul 2714
      fi
599 cbradney 2715
      # Last step: remove runtime libs from dependency_libs (they stay in deplibs)
2716
      tmp_libs=
2717
      for i in $dependency_libs ; do
2718
        case " $predeps $postdeps $compiler_lib_search_path " in
2719
        *" $i "*)
2720
          i=""
2721
          ;;
2722
        esac
2723
        if test -n "$i" ; then
2724
          tmp_libs="$tmp_libs $i"
2725
        fi
2726
      done
2727
      dependency_libs=$tmp_libs
2728
    done # for pass
2729
    if test "$linkmode" = prog; then
3 paul 2730
      dlfiles="$newdlfiles"
2731
      dlprefiles="$newdlprefiles"
2732
    fi
2733
 
2734
    case $linkmode in
2735
    oldlib)
2736
      if test -n "$deplibs"; then
2737
        $echo "$modename: warning: \`-l' and \`-L' are ignored for archives" 1>&2
2738
      fi
2739
 
2740
      if test -n "$dlfiles$dlprefiles" || test "$dlself" != no; then
2741
        $echo "$modename: warning: \`-dlopen' is ignored for archives" 1>&2
2742
      fi
2743
 
2744
      if test -n "$rpath"; then
2745
        $echo "$modename: warning: \`-rpath' is ignored for archives" 1>&2
2746
      fi
2747
 
2748
      if test -n "$xrpath"; then
2749
        $echo "$modename: warning: \`-R' is ignored for archives" 1>&2
2750
      fi
2751
 
2752
      if test -n "$vinfo"; then
599 cbradney 2753
        $echo "$modename: warning: \`-version-info/-version-number' is ignored for archives" 1>&2
3 paul 2754
      fi
2755
 
2756
      if test -n "$release"; then
2757
        $echo "$modename: warning: \`-release' is ignored for archives" 1>&2
2758
      fi
2759
 
2760
      if test -n "$export_symbols" || test -n "$export_symbols_regex"; then
2761
        $echo "$modename: warning: \`-export-symbols' is ignored for archives" 1>&2
2762
      fi
2763
 
2764
      # Now set the variables for building old libraries.
2765
      build_libtool_libs=no
2766
      oldlibs="$output"
2767
      objs="$objs$old_deplibs"
2768
      ;;
2769
 
2770
    lib)
2771
      # Make sure we only generate libraries of the form `libNAME.la'.
2772
      case $outputname in
2773
      lib*)
2774
        name=`$echo "X$outputname" | $Xsed -e 's/\.la$//' -e 's/^lib//'`
599 cbradney 2775
        eval shared_ext=\"$shrext\"
3 paul 2776
        eval libname=\"$libname_spec\"
2777
        ;;
2778
      *)
2779
        if test "$module" = no; then
2780
          $echo "$modename: libtool library \`$output' must begin with \`lib'" 1>&2
2781
          $echo "$help" 1>&2
2782
          exit 1
2783
        fi
2784
        if test "$need_lib_prefix" != no; then
2785
          # Add the "lib" prefix for modules if required
2786
          name=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
599 cbradney 2787
          eval shared_ext=\"$shrext\"
3 paul 2788
          eval libname=\"$libname_spec\"
2789
        else
2790
          libname=`$echo "X$outputname" | $Xsed -e 's/\.la$//'`
2791
        fi
2792
        ;;
2793
      esac
2794
 
2795
      if test -n "$objs"; then
2796
        if test "$deplibs_check_method" != pass_all; then
2797
          $echo "$modename: cannot build libtool library \`$output' from non-libtool objects on this host:$objs" 2>&1
2798
          exit 1
2799
        else
599 cbradney 2800
          $echo
2801
          $echo "*** Warning: Linking the shared library $output against the non-libtool"
2802
          $echo "*** objects $objs is not portable!"
3 paul 2803
          libobjs="$libobjs $objs"
2804
        fi
2805
      fi
2806
 
2807
      if test "$dlself" != no; then
2808
        $echo "$modename: warning: \`-dlopen self' is ignored for libtool libraries" 1>&2
2809
      fi
2810
 
2811
      set dummy $rpath
599 cbradney 2812
      if test "$#" -gt 2; then
3 paul 2813
        $echo "$modename: warning: ignoring multiple \`-rpath's for a libtool library" 1>&2
2814
      fi
2815
      install_libdir="$2"
2816
 
2817
      oldlibs=
2818
      if test -z "$rpath"; then
2819
        if test "$build_libtool_libs" = yes; then
2820
          # Building a libtool convenience library.
2821
          # Some compilers have problems with a `.al' extension so
599 cbradney 2822
          # convenience libraries should have the same extension an
2823
          # archive normally would.
3 paul 2824
          oldlibs="$output_objdir/$libname.$libext $oldlibs"
2825
          build_libtool_libs=convenience
2826
          build_old_libs=yes
2827
        fi
2828
 
2829
        if test -n "$vinfo"; then
599 cbradney 2830
          $echo "$modename: warning: \`-version-info/-version-number' is ignored for convenience libraries" 1>&2
3 paul 2831
        fi
2832
 
2833
        if test -n "$release"; then
2834
          $echo "$modename: warning: \`-release' is ignored for convenience libraries" 1>&2
2835
        fi
2836
      else
2837
 
2838
        # Parse the version information argument.
599 cbradney 2839
        save_ifs="$IFS"; IFS=':'
3 paul 2840
        set dummy $vinfo 0 0 0
2841
        IFS="$save_ifs"
2842
 
2843
        if test -n "$8"; then
2844
          $echo "$modename: too many parameters to \`-version-info'" 1>&2
2845
          $echo "$help" 1>&2
2846
          exit 1
2847
        fi
2848
 
599 cbradney 2849
        # convert absolute version numbers to libtool ages
2850
        # this retains compatibility with .la files and attempts
2851
        # to make the code below a bit more comprehensible
2852
 
2853
        case $vinfo_number in
2854
        yes)
2855
          number_major="$2"
2856
          number_minor="$3"
2857
          number_revision="$4"
2858
          #
2859
          # There are really only two kinds -- those that
2860
          # use the current revision as the major version
2861
          # and those that subtract age and use age as
2862
          # a minor version.  But, then there is irix
2863
          # which has an extra 1 added just for fun
2864
          #
2865
          case $version_type in
2866
          darwin|linux|osf|windows)
2867
            current=`expr $number_major + $number_minor`
2868
            age="$number_minor"
2869
            revision="$number_revision"
2870
            ;;
2871
          freebsd-aout|freebsd-elf|sunos)
2872
            current="$number_major"
2873
            revision="$number_minor"
2874
            age="0"
2875
            ;;
2876
          irix|nonstopux)
2877
            current=`expr $number_major + $number_minor - 1`
2878
            age="$number_minor"
2879
            revision="$number_minor"
2880
            ;;
2881
          esac
2882
          ;;
2883
        no)
2884
          current="$2"
2885
          revision="$3"
2886
          age="$4"
2887
          ;;
2888
        esac
3 paul 2889
 
2890
        # Check that each of the things are valid numbers.
2891
        case $current in
599 cbradney 2892
 
3 paul 2893
        *)
2894
          $echo "$modename: CURRENT \`$current' is not a nonnegative integer" 1>&2
2895
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2896
          exit 1
2897
          ;;
2898
        esac
2899
 
2900
        case $revision in
599 cbradney 2901
 
3 paul 2902
        *)
2903
          $echo "$modename: REVISION \`$revision' is not a nonnegative integer" 1>&2
2904
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2905
          exit 1
2906
          ;;
2907
        esac
2908
 
2909
        case $age in
599 cbradney 2910
 
3 paul 2911
        *)
2912
          $echo "$modename: AGE \`$age' is not a nonnegative integer" 1>&2
2913
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2914
          exit 1
2915
          ;;
2916
        esac
2917
 
599 cbradney 2918
        if test "$age" -gt "$current"; then
3 paul 2919
          $echo "$modename: AGE \`$age' is greater than the current interface number \`$current'" 1>&2
2920
          $echo "$modename: \`$vinfo' is not valid version information" 1>&2
2921
          exit 1
2922
        fi
2923
 
2924
        # Calculate the version variables.
2925
        major=
2926
        versuffix=
2927
        verstring=
2928
        case $version_type in
2929
        none) ;;
2930
 
2931
        darwin)
2932
          # Like Linux, but with the current version available in
2933
          # verstring for coding it into the library header
2934
          major=.`expr $current - $age`
2935
          versuffix="$major.$age.$revision"
2936
          # Darwin ld doesn't like 0 for these options...
2937
          minor_current=`expr $current + 1`
2938
          verstring="-compatibility_version $minor_current -current_version $minor_current.$revision"
2939
          ;;
2940
 
2941
        freebsd-aout)
2942
          major=".$current"
2943
          versuffix=".$current.$revision";
2944
          ;;
2945
 
2946
        freebsd-elf)
2947
          major=".$current"
2948
          versuffix=".$current";
2949
          ;;
2950
 
599 cbradney 2951
        irix | nonstopux)
3 paul 2952
          major=`expr $current - $age + 1`
2953
 
599 cbradney 2954
          case $version_type in
2955
            nonstopux) verstring_prefix=nonstopux ;;
2956
            *)         verstring_prefix=sgi ;;
2957
          esac
2958
          verstring="$verstring_prefix$major.$revision"
2959
 
3 paul 2960
          # Add in all the interfaces that we are compatible with.
2961
          loop=$revision
599 cbradney 2962
          while test "$loop" -ne 0; do
3 paul 2963
            iface=`expr $revision - $loop`
2964
            loop=`expr $loop - 1`
599 cbradney 2965
            verstring="$verstring_prefix$major.$iface:$verstring"
3 paul 2966
          done
2967
 
2968
          # Before this point, $major must not contain `.'.
2969
          major=.$major
2970
          versuffix="$major.$revision"
2971
          ;;
2972
 
2973
        linux)
2974
          major=.`expr $current - $age`
2975
          versuffix="$major.$age.$revision"
2976
          ;;
2977
 
2978
        osf)
599 cbradney 2979
          major=.`expr $current - $age`
3 paul 2980
          versuffix=".$current.$age.$revision"
2981
          verstring="$current.$age.$revision"
2982
 
2983
          # Add in all the interfaces that we are compatible with.
2984
          loop=$age
599 cbradney 2985
          while test "$loop" -ne 0; do
3</