~ubuntu-branches/ubuntu/trusty/librep/trusty

« back to all changes in this revision

Viewing changes to aclocal.m4

  • Committer: Bazaar Package Importer
  • Author(s): Barry deFreese
  • Date: 2007-01-25 11:09:23 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20070125110923-2owlh6jsptg68pn5
Tags: 0.17+svn20070119-2ubuntu1
* Re-sync with Debian.  Following change kept:
  - Still building with --with-stack-direction=-1 for ppc/ia64.

Show diffs side-by-side

added added

removed removed

Lines of Context:
1
 
dnl aclocal.m4 generated automatically by aclocal 1.4-p6
2
 
 
3
 
dnl Copyright (C) 1994, 1995-8, 1999, 2001 Free Software Foundation, Inc.
 
1
# generated automatically by aclocal 1.10 -*- Autoconf -*-
 
2
 
 
3
# Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
 
4
# 2005, 2006  Free Software Foundation, Inc.
 
5
# This file is free software; the Free Software Foundation
 
6
# gives unlimited permission to copy and/or distribute it,
 
7
# with or without modifications, as long as this notice is preserved.
 
8
 
 
9
# This program is distributed in the hope that it will be useful,
 
10
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
 
11
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
 
12
# PARTICULAR PURPOSE.
 
13
 
 
14
# lcmessage.m4 serial 4 (gettext-0.14.2)
 
15
dnl Copyright (C) 1995-2002, 2004-2005 Free Software Foundation, Inc.
4
16
dnl This file is free software; the Free Software Foundation
5
17
dnl gives unlimited permission to copy and/or distribute it,
6
18
dnl with or without modifications, as long as this notice is preserved.
7
 
 
8
 
dnl This program is distributed in the hope that it will be useful,
9
 
dnl but WITHOUT ANY WARRANTY, to the extent permitted by law; without
10
 
dnl even the implied warranty of MERCHANTABILITY or FITNESS FOR A
11
 
dnl PARTICULAR PURPOSE.
12
 
 
13
 
# lib-prefix.m4 serial 3 (gettext-0.12.2)
14
 
dnl Copyright (C) 2001-2003 Free Software Foundation, Inc.
15
 
dnl This file is free software, distributed under the terms of the GNU
16
 
dnl General Public License.  As a special exception to the GNU General
17
 
dnl Public License, this file may be distributed as part of a program
18
 
dnl that contains a configuration script generated by Autoconf, under
19
 
dnl the same distribution terms as the rest of that program.
20
 
 
21
 
dnl From Bruno Haible.
22
 
 
23
 
dnl AC_LIB_ARG_WITH is synonymous to AC_ARG_WITH in autoconf-2.13, and
24
 
dnl similar to AC_ARG_WITH in autoconf 2.52...2.57 except that is doesn't
25
 
dnl require excessive bracketing.
26
 
ifdef([AC_HELP_STRING],
27
 
[AC_DEFUN([AC_LIB_ARG_WITH], [AC_ARG_WITH([$1],[[$2]],[$3],[$4])])],
28
 
[AC_DEFUN([AC_][LIB_ARG_WITH], [AC_ARG_WITH([$1],[$2],[$3],[$4])])])
29
 
 
30
 
dnl AC_LIB_PREFIX adds to the CPPFLAGS and LDFLAGS the flags that are needed
31
 
dnl to access previously installed libraries. The basic assumption is that
32
 
dnl a user will want packages to use other packages he previously installed
33
 
dnl with the same --prefix option.
34
 
dnl This macro is not needed if only AC_LIB_LINKFLAGS is used to locate
35
 
dnl libraries, but is otherwise very convenient.
36
 
AC_DEFUN([AC_LIB_PREFIX],
37
 
[
38
 
  AC_BEFORE([$0], [AC_LIB_LINKFLAGS])
39
 
  AC_REQUIRE([AC_PROG_CC])
40
 
  AC_REQUIRE([AC_CANONICAL_HOST])
41
 
  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
42
 
  dnl By default, look in $includedir and $libdir.
43
 
  use_additional=yes
44
 
  AC_LIB_WITH_FINAL_PREFIX([
45
 
    eval additional_includedir=\"$includedir\"
46
 
    eval additional_libdir=\"$libdir\"
47
 
  ])
48
 
  AC_LIB_ARG_WITH([lib-prefix],
49
 
[  --with-lib-prefix[=DIR] search for libraries in DIR/include and DIR/lib
50
 
  --without-lib-prefix    don't search for libraries in includedir and libdir],
51
 
[
52
 
    if test "X$withval" = "Xno"; then
53
 
      use_additional=no
54
 
    else
55
 
      if test "X$withval" = "X"; then
56
 
        AC_LIB_WITH_FINAL_PREFIX([
57
 
          eval additional_includedir=\"$includedir\"
58
 
          eval additional_libdir=\"$libdir\"
59
 
        ])
60
 
      else
61
 
        additional_includedir="$withval/include"
62
 
        additional_libdir="$withval/lib"
63
 
      fi
64
 
    fi
65
 
])
66
 
  if test $use_additional = yes; then
67
 
    dnl Potentially add $additional_includedir to $CPPFLAGS.
68
 
    dnl But don't add it
69
 
    dnl   1. if it's the standard /usr/include,
70
 
    dnl   2. if it's already present in $CPPFLAGS,
71
 
    dnl   3. if it's /usr/local/include and we are using GCC on Linux,
72
 
    dnl   4. if it doesn't exist as a directory.
73
 
    if test "X$additional_includedir" != "X/usr/include"; then
74
 
      haveit=
75
 
      for x in $CPPFLAGS; do
76
 
        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
77
 
        if test "X$x" = "X-I$additional_includedir"; then
78
 
          haveit=yes
79
 
          break
80
 
        fi
81
 
      done
82
 
      if test -z "$haveit"; then
83
 
        if test "X$additional_includedir" = "X/usr/local/include"; then
84
 
          if test -n "$GCC"; then
85
 
            case $host_os in
86
 
              linux*) haveit=yes;;
87
 
            esac
88
 
          fi
89
 
        fi
90
 
        if test -z "$haveit"; then
91
 
          if test -d "$additional_includedir"; then
92
 
            dnl Really add $additional_includedir to $CPPFLAGS.
93
 
            CPPFLAGS="${CPPFLAGS}${CPPFLAGS:+ }-I$additional_includedir"
94
 
          fi
95
 
        fi
96
 
      fi
97
 
    fi
98
 
    dnl Potentially add $additional_libdir to $LDFLAGS.
99
 
    dnl But don't add it
100
 
    dnl   1. if it's the standard /usr/lib,
101
 
    dnl   2. if it's already present in $LDFLAGS,
102
 
    dnl   3. if it's /usr/local/lib and we are using GCC on Linux,
103
 
    dnl   4. if it doesn't exist as a directory.
104
 
    if test "X$additional_libdir" != "X/usr/lib"; then
105
 
      haveit=
106
 
      for x in $LDFLAGS; do
107
 
        AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
108
 
        if test "X$x" = "X-L$additional_libdir"; then
109
 
          haveit=yes
110
 
          break
111
 
        fi
112
 
      done
113
 
      if test -z "$haveit"; then
114
 
        if test "X$additional_libdir" = "X/usr/local/lib"; then
115
 
          if test -n "$GCC"; then
116
 
            case $host_os in
117
 
              linux*) haveit=yes;;
118
 
            esac
119
 
          fi
120
 
        fi
121
 
        if test -z "$haveit"; then
122
 
          if test -d "$additional_libdir"; then
123
 
            dnl Really add $additional_libdir to $LDFLAGS.
124
 
            LDFLAGS="${LDFLAGS}${LDFLAGS:+ }-L$additional_libdir"
125
 
          fi
126
 
        fi
127
 
      fi
128
 
    fi
129
 
  fi
130
 
])
131
 
 
132
 
dnl AC_LIB_PREPARE_PREFIX creates variables acl_final_prefix,
133
 
dnl acl_final_exec_prefix, containing the values to which $prefix and
134
 
dnl $exec_prefix will expand at the end of the configure script.
135
 
AC_DEFUN([AC_LIB_PREPARE_PREFIX],
136
 
[
137
 
  dnl Unfortunately, prefix and exec_prefix get only finally determined
138
 
  dnl at the end of configure.
139
 
  if test "X$prefix" = "XNONE"; then
140
 
    acl_final_prefix="$ac_default_prefix"
141
 
  else
142
 
    acl_final_prefix="$prefix"
143
 
  fi
144
 
  if test "X$exec_prefix" = "XNONE"; then
145
 
    acl_final_exec_prefix='${prefix}'
146
 
  else
147
 
    acl_final_exec_prefix="$exec_prefix"
148
 
  fi
149
 
  acl_save_prefix="$prefix"
150
 
  prefix="$acl_final_prefix"
151
 
  eval acl_final_exec_prefix=\"$acl_final_exec_prefix\"
152
 
  prefix="$acl_save_prefix"
153
 
])
154
 
 
155
 
dnl AC_LIB_WITH_FINAL_PREFIX([statement]) evaluates statement, with the
156
 
dnl variables prefix and exec_prefix bound to the values they will have
157
 
dnl at the end of the configure script.
158
 
AC_DEFUN([AC_LIB_WITH_FINAL_PREFIX],
159
 
[
160
 
  acl_save_prefix="$prefix"
161
 
  prefix="$acl_final_prefix"
162
 
  acl_save_exec_prefix="$exec_prefix"
163
 
  exec_prefix="$acl_final_exec_prefix"
164
 
  $1
165
 
  exec_prefix="$acl_save_exec_prefix"
166
 
  prefix="$acl_save_prefix"
167
 
])
168
 
 
169
 
# lib-link.m4 serial 4 (gettext-0.12)
170
 
dnl Copyright (C) 2001-2003 Free Software Foundation, Inc.
171
 
dnl This file is free software, distributed under the terms of the GNU
172
 
dnl General Public License.  As a special exception to the GNU General
173
 
dnl Public License, this file may be distributed as part of a program
174
 
dnl that contains a configuration script generated by Autoconf, under
175
 
dnl the same distribution terms as the rest of that program.
176
 
 
177
 
dnl From Bruno Haible.
178
 
 
179
 
dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and
180
 
dnl the libraries corresponding to explicit and implicit dependencies.
181
 
dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and
182
 
dnl augments the CPPFLAGS variable.
183
 
AC_DEFUN([AC_LIB_LINKFLAGS],
184
 
[
185
 
  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
186
 
  AC_REQUIRE([AC_LIB_RPATH])
187
 
  define([Name],[translit([$1],[./-], [___])])
188
 
  define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
189
 
                               [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
190
 
  AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [
191
 
    AC_LIB_LINKFLAGS_BODY([$1], [$2])
192
 
    ac_cv_lib[]Name[]_libs="$LIB[]NAME"
193
 
    ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME"
194
 
    ac_cv_lib[]Name[]_cppflags="$INC[]NAME"
195
 
  ])
196
 
  LIB[]NAME="$ac_cv_lib[]Name[]_libs"
197
 
  LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs"
198
 
  INC[]NAME="$ac_cv_lib[]Name[]_cppflags"
199
 
  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
200
 
  AC_SUBST([LIB]NAME)
201
 
  AC_SUBST([LTLIB]NAME)
202
 
  dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the
203
 
  dnl results of this search when this library appears as a dependency.
204
 
  HAVE_LIB[]NAME=yes
205
 
  undefine([Name])
206
 
  undefine([NAME])
207
 
])
208
 
 
209
 
dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode)
210
 
dnl searches for libname and the libraries corresponding to explicit and
211
 
dnl implicit dependencies, together with the specified include files and
212
 
dnl the ability to compile and link the specified testcode. If found, it
213
 
dnl sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} and
214
 
dnl LTLIB${NAME} variables and augments the CPPFLAGS variable, and
215
 
dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs
216
 
dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty.
217
 
AC_DEFUN([AC_LIB_HAVE_LINKFLAGS],
218
 
[
219
 
  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
220
 
  AC_REQUIRE([AC_LIB_RPATH])
221
 
  define([Name],[translit([$1],[./-], [___])])
222
 
  define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
223
 
                               [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
224
 
 
225
 
  dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME
226
 
  dnl accordingly.
227
 
  AC_LIB_LINKFLAGS_BODY([$1], [$2])
228
 
 
229
 
  dnl Add $INC[]NAME to CPPFLAGS before performing the following checks,
230
 
  dnl because if the user has installed lib[]Name and not disabled its use
231
 
  dnl via --without-lib[]Name-prefix, he wants to use it.
232
 
  ac_save_CPPFLAGS="$CPPFLAGS"
233
 
  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
234
 
 
235
 
  AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [
236
 
    ac_save_LIBS="$LIBS"
237
 
    LIBS="$LIBS $LIB[]NAME"
238
 
    AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name=no])
239
 
    LIBS="$ac_save_LIBS"
240
 
  ])
241
 
  if test "$ac_cv_lib[]Name" = yes; then
242
 
    HAVE_LIB[]NAME=yes
243
 
    AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the $1 library.])
244
 
    AC_MSG_CHECKING([how to link with lib[]$1])
245
 
    AC_MSG_RESULT([$LIB[]NAME])
246
 
  else
247
 
    HAVE_LIB[]NAME=no
248
 
    dnl If $LIB[]NAME didn't lead to a usable library, we don't need
249
 
    dnl $INC[]NAME either.
250
 
    CPPFLAGS="$ac_save_CPPFLAGS"
251
 
    LIB[]NAME=
252
 
    LTLIB[]NAME=
253
 
  fi
254
 
  AC_SUBST([HAVE_LIB]NAME)
255
 
  AC_SUBST([LIB]NAME)
256
 
  AC_SUBST([LTLIB]NAME)
257
 
  undefine([Name])
258
 
  undefine([NAME])
259
 
])
260
 
 
261
 
dnl Determine the platform dependent parameters needed to use rpath:
262
 
dnl libext, shlibext, hardcode_libdir_flag_spec, hardcode_libdir_separator,
263
 
dnl hardcode_direct, hardcode_minus_L.
264
 
AC_DEFUN([AC_LIB_RPATH],
265
 
[
266
 
  AC_REQUIRE([AC_PROG_CC])                dnl we use $CC, $GCC, $LDFLAGS
267
 
  AC_REQUIRE([AC_LIB_PROG_LD])            dnl we use $LD, $with_gnu_ld
268
 
  AC_REQUIRE([AC_CANONICAL_HOST])         dnl we use $host
269
 
  AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir
270
 
  AC_CACHE_CHECK([for shared library run path origin], acl_cv_rpath, [
271
 
    CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \
272
 
    ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh
273
 
    . ./conftest.sh
274
 
    rm -f ./conftest.sh
275
 
    acl_cv_rpath=done
276
 
  ])
277
 
  wl="$acl_cv_wl"
278
 
  libext="$acl_cv_libext"
279
 
  shlibext="$acl_cv_shlibext"
280
 
  hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"
281
 
  hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"
282
 
  hardcode_direct="$acl_cv_hardcode_direct"
283
 
  hardcode_minus_L="$acl_cv_hardcode_minus_L"
284
 
  dnl Determine whether the user wants rpath handling at all.
285
 
  AC_ARG_ENABLE(rpath,
286
 
    [  --disable-rpath         do not hardcode runtime library paths],
287
 
    :, enable_rpath=yes)
288
 
])
289
 
 
290
 
dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and
291
 
dnl the libraries corresponding to explicit and implicit dependencies.
292
 
dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables.
293
 
AC_DEFUN([AC_LIB_LINKFLAGS_BODY],
294
 
[
295
 
  define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
296
 
                               [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
297
 
  dnl By default, look in $includedir and $libdir.
298
 
  use_additional=yes
299
 
  AC_LIB_WITH_FINAL_PREFIX([
300
 
    eval additional_includedir=\"$includedir\"
301
 
    eval additional_libdir=\"$libdir\"
302
 
  ])
303
 
  AC_LIB_ARG_WITH([lib$1-prefix],
304
 
[  --with-lib$1-prefix[=DIR]  search for lib$1 in DIR/include and DIR/lib
305
 
  --without-lib$1-prefix     don't search for lib$1 in includedir and libdir],
306
 
[
307
 
    if test "X$withval" = "Xno"; then
308
 
      use_additional=no
309
 
    else
310
 
      if test "X$withval" = "X"; then
311
 
        AC_LIB_WITH_FINAL_PREFIX([
312
 
          eval additional_includedir=\"$includedir\"
313
 
          eval additional_libdir=\"$libdir\"
314
 
        ])
315
 
      else
316
 
        additional_includedir="$withval/include"
317
 
        additional_libdir="$withval/lib"
318
 
      fi
319
 
    fi
320
 
])
321
 
  dnl Search the library and its dependencies in $additional_libdir and
322
 
  dnl $LDFLAGS. Using breadth-first-seach.
323
 
  LIB[]NAME=
324
 
  LTLIB[]NAME=
325
 
  INC[]NAME=
326
 
  rpathdirs=
327
 
  ltrpathdirs=
328
 
  names_already_handled=
329
 
  names_next_round='$1 $2'
330
 
  while test -n "$names_next_round"; do
331
 
    names_this_round="$names_next_round"
332
 
    names_next_round=
333
 
    for name in $names_this_round; do
334
 
      already_handled=
335
 
      for n in $names_already_handled; do
336
 
        if test "$n" = "$name"; then
337
 
          already_handled=yes
338
 
          break
339
 
        fi
340
 
      done
341
 
      if test -z "$already_handled"; then
342
 
        names_already_handled="$names_already_handled $name"
343
 
        dnl See if it was already located by an earlier AC_LIB_LINKFLAGS
344
 
        dnl or AC_LIB_HAVE_LINKFLAGS call.
345
 
        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
346
 
        eval value=\"\$HAVE_LIB$uppername\"
347
 
        if test -n "$value"; then
348
 
          if test "$value" = yes; then
349
 
            eval value=\"\$LIB$uppername\"
350
 
            test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value"
351
 
            eval value=\"\$LTLIB$uppername\"
352
 
            test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value"
353
 
          else
354
 
            dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined
355
 
            dnl that this library doesn't exist. So just drop it.
356
 
            :
357
 
          fi
358
 
        else
359
 
          dnl Search the library lib$name in $additional_libdir and $LDFLAGS
360
 
          dnl and the already constructed $LIBNAME/$LTLIBNAME.
361
 
          found_dir=
362
 
          found_la=
363
 
          found_so=
364
 
          found_a=
365
 
          if test $use_additional = yes; then
366
 
            if test -n "$shlibext" && test -f "$additional_libdir/lib$name.$shlibext"; then
367
 
              found_dir="$additional_libdir"
368
 
              found_so="$additional_libdir/lib$name.$shlibext"
369
 
              if test -f "$additional_libdir/lib$name.la"; then
370
 
                found_la="$additional_libdir/lib$name.la"
371
 
              fi
372
 
            else
373
 
              if test -f "$additional_libdir/lib$name.$libext"; then
374
 
                found_dir="$additional_libdir"
375
 
                found_a="$additional_libdir/lib$name.$libext"
376
 
                if test -f "$additional_libdir/lib$name.la"; then
377
 
                  found_la="$additional_libdir/lib$name.la"
378
 
                fi
379
 
              fi
380
 
            fi
381
 
          fi
382
 
          if test "X$found_dir" = "X"; then
383
 
            for x in $LDFLAGS $LTLIB[]NAME; do
384
 
              AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
385
 
              case "$x" in
386
 
                -L*)
387
 
                  dir=`echo "X$x" | sed -e 's/^X-L//'`
388
 
                  if test -n "$shlibext" && test -f "$dir/lib$name.$shlibext"; then
389
 
                    found_dir="$dir"
390
 
                    found_so="$dir/lib$name.$shlibext"
391
 
                    if test -f "$dir/lib$name.la"; then
392
 
                      found_la="$dir/lib$name.la"
393
 
                    fi
394
 
                  else
395
 
                    if test -f "$dir/lib$name.$libext"; then
396
 
                      found_dir="$dir"
397
 
                      found_a="$dir/lib$name.$libext"
398
 
                      if test -f "$dir/lib$name.la"; then
399
 
                        found_la="$dir/lib$name.la"
400
 
                      fi
401
 
                    fi
402
 
                  fi
403
 
                  ;;
404
 
              esac
405
 
              if test "X$found_dir" != "X"; then
406
 
                break
407
 
              fi
408
 
            done
409
 
          fi
410
 
          if test "X$found_dir" != "X"; then
411
 
            dnl Found the library.
412
 
            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name"
413
 
            if test "X$found_so" != "X"; then
414
 
              dnl Linking with a shared library. We attempt to hardcode its
415
 
              dnl directory into the executable's runpath, unless it's the
416
 
              dnl standard /usr/lib.
417
 
              if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/lib"; then
418
 
                dnl No hardcoding is needed.
419
 
                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
420
 
              else
421
 
                dnl Use an explicit option to hardcode DIR into the resulting
422
 
                dnl binary.
423
 
                dnl Potentially add DIR to ltrpathdirs.
424
 
                dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
425
 
                haveit=
426
 
                for x in $ltrpathdirs; do
427
 
                  if test "X$x" = "X$found_dir"; then
428
 
                    haveit=yes
429
 
                    break
430
 
                  fi
431
 
                done
432
 
                if test -z "$haveit"; then
433
 
                  ltrpathdirs="$ltrpathdirs $found_dir"
434
 
                fi
435
 
                dnl The hardcoding into $LIBNAME is system dependent.
436
 
                if test "$hardcode_direct" = yes; then
437
 
                  dnl Using DIR/libNAME.so during linking hardcodes DIR into the
438
 
                  dnl resulting binary.
439
 
                  LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
440
 
                else
441
 
                  if test -n "$hardcode_libdir_flag_spec" && test "$hardcode_minus_L" = no; then
442
 
                    dnl Use an explicit option to hardcode DIR into the resulting
443
 
                    dnl binary.
444
 
                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
445
 
                    dnl Potentially add DIR to rpathdirs.
446
 
                    dnl The rpathdirs will be appended to $LIBNAME at the end.
447
 
                    haveit=
448
 
                    for x in $rpathdirs; do
449
 
                      if test "X$x" = "X$found_dir"; then
450
 
                        haveit=yes
451
 
                        break
452
 
                      fi
453
 
                    done
454
 
                    if test -z "$haveit"; then
455
 
                      rpathdirs="$rpathdirs $found_dir"
456
 
                    fi
457
 
                  else
458
 
                    dnl Rely on "-L$found_dir".
459
 
                    dnl But don't add it if it's already contained in the LDFLAGS
460
 
                    dnl or the already constructed $LIBNAME
461
 
                    haveit=
462
 
                    for x in $LDFLAGS $LIB[]NAME; do
463
 
                      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
464
 
                      if test "X$x" = "X-L$found_dir"; then
465
 
                        haveit=yes
466
 
                        break
467
 
                      fi
468
 
                    done
469
 
                    if test -z "$haveit"; then
470
 
                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir"
471
 
                    fi
472
 
                    if test "$hardcode_minus_L" != no; then
473
 
                      dnl FIXME: Not sure whether we should use
474
 
                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
475
 
                      dnl here.
476
 
                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
477
 
                    else
478
 
                      dnl We cannot use $hardcode_runpath_var and LD_RUN_PATH
479
 
                      dnl here, because this doesn't fit in flags passed to the
480
 
                      dnl compiler. So give up. No hardcoding. This affects only
481
 
                      dnl very old systems.
482
 
                      dnl FIXME: Not sure whether we should use
483
 
                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
484
 
                      dnl here.
485
 
                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
486
 
                    fi
487
 
                  fi
488
 
                fi
489
 
              fi
490
 
            else
491
 
              if test "X$found_a" != "X"; then
492
 
                dnl Linking with a static library.
493
 
                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a"
494
 
              else
495
 
                dnl We shouldn't come here, but anyway it's good to have a
496
 
                dnl fallback.
497
 
                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name"
498
 
              fi
499
 
            fi
500
 
            dnl Assume the include files are nearby.
501
 
            additional_includedir=
502
 
            case "$found_dir" in
503
 
              */lib | */lib/)
504
 
                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e 's,/lib/*$,,'`
505
 
                additional_includedir="$basedir/include"
506
 
                ;;
507
 
            esac
508
 
            if test "X$additional_includedir" != "X"; then
509
 
              dnl Potentially add $additional_includedir to $INCNAME.
510
 
              dnl But don't add it
511
 
              dnl   1. if it's the standard /usr/include,
512
 
              dnl   2. if it's /usr/local/include and we are using GCC on Linux,
513
 
              dnl   3. if it's already present in $CPPFLAGS or the already
514
 
              dnl      constructed $INCNAME,
515
 
              dnl   4. if it doesn't exist as a directory.
516
 
              if test "X$additional_includedir" != "X/usr/include"; then
517
 
                haveit=
518
 
                if test "X$additional_includedir" = "X/usr/local/include"; then
519
 
                  if test -n "$GCC"; then
520
 
                    case $host_os in
521
 
                      linux*) haveit=yes;;
522
 
                    esac
523
 
                  fi
524
 
                fi
525
 
                if test -z "$haveit"; then
526
 
                  for x in $CPPFLAGS $INC[]NAME; do
527
 
                    AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
528
 
                    if test "X$x" = "X-I$additional_includedir"; then
529
 
                      haveit=yes
530
 
                      break
531
 
                    fi
532
 
                  done
533
 
                  if test -z "$haveit"; then
534
 
                    if test -d "$additional_includedir"; then
535
 
                      dnl Really add $additional_includedir to $INCNAME.
536
 
                      INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir"
537
 
                    fi
538
 
                  fi
539
 
                fi
540
 
              fi
541
 
            fi
542
 
            dnl Look for dependencies.
543
 
            if test -n "$found_la"; then
544
 
              dnl Read the .la file. It defines the variables
545
 
              dnl dlname, library_names, old_library, dependency_libs, current,
546
 
              dnl age, revision, installed, dlopen, dlpreopen, libdir.
547
 
              save_libdir="$libdir"
548
 
              case "$found_la" in
549
 
                */* | *\\*) . "$found_la" ;;
550
 
                *) . "./$found_la" ;;
551
 
              esac
552
 
              libdir="$save_libdir"
553
 
              dnl We use only dependency_libs.
554
 
              for dep in $dependency_libs; do
555
 
                case "$dep" in
556
 
                  -L*)
557
 
                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
558
 
                    dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME.
559
 
                    dnl But don't add it
560
 
                    dnl   1. if it's the standard /usr/lib,
561
 
                    dnl   2. if it's /usr/local/lib and we are using GCC on Linux,
562
 
                    dnl   3. if it's already present in $LDFLAGS or the already
563
 
                    dnl      constructed $LIBNAME,
564
 
                    dnl   4. if it doesn't exist as a directory.
565
 
                    if test "X$additional_libdir" != "X/usr/lib"; then
566
 
                      haveit=
567
 
                      if test "X$additional_libdir" = "X/usr/local/lib"; then
568
 
                        if test -n "$GCC"; then
569
 
                          case $host_os in
570
 
                            linux*) haveit=yes;;
571
 
                          esac
572
 
                        fi
573
 
                      fi
574
 
                      if test -z "$haveit"; then
575
 
                        haveit=
576
 
                        for x in $LDFLAGS $LIB[]NAME; do
577
 
                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
578
 
                          if test "X$x" = "X-L$additional_libdir"; then
579
 
                            haveit=yes
580
 
                            break
581
 
                          fi
582
 
                        done
583
 
                        if test -z "$haveit"; then
584
 
                          if test -d "$additional_libdir"; then
585
 
                            dnl Really add $additional_libdir to $LIBNAME.
586
 
                            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir"
587
 
                          fi
588
 
                        fi
589
 
                        haveit=
590
 
                        for x in $LDFLAGS $LTLIB[]NAME; do
591
 
                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
592
 
                          if test "X$x" = "X-L$additional_libdir"; then
593
 
                            haveit=yes
594
 
                            break
595
 
                          fi
596
 
                        done
597
 
                        if test -z "$haveit"; then
598
 
                          if test -d "$additional_libdir"; then
599
 
                            dnl Really add $additional_libdir to $LTLIBNAME.
600
 
                            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir"
601
 
                          fi
602
 
                        fi
603
 
                      fi
604
 
                    fi
605
 
                    ;;
606
 
                  -R*)
607
 
                    dir=`echo "X$dep" | sed -e 's/^X-R//'`
608
 
                    if test "$enable_rpath" != no; then
609
 
                      dnl Potentially add DIR to rpathdirs.
610
 
                      dnl The rpathdirs will be appended to $LIBNAME at the end.
611
 
                      haveit=
612
 
                      for x in $rpathdirs; do
613
 
                        if test "X$x" = "X$dir"; then
614
 
                          haveit=yes
615
 
                          break
616
 
                        fi
617
 
                      done
618
 
                      if test -z "$haveit"; then
619
 
                        rpathdirs="$rpathdirs $dir"
620
 
                      fi
621
 
                      dnl Potentially add DIR to ltrpathdirs.
622
 
                      dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
623
 
                      haveit=
624
 
                      for x in $ltrpathdirs; do
625
 
                        if test "X$x" = "X$dir"; then
626
 
                          haveit=yes
627
 
                          break
628
 
                        fi
629
 
                      done
630
 
                      if test -z "$haveit"; then
631
 
                        ltrpathdirs="$ltrpathdirs $dir"
632
 
                      fi
633
 
                    fi
634
 
                    ;;
635
 
                  -l*)
636
 
                    dnl Handle this in the next round.
637
 
                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
638
 
                    ;;
639
 
                  *.la)
640
 
                    dnl Handle this in the next round. Throw away the .la's
641
 
                    dnl directory; it is already contained in a preceding -L
642
 
                    dnl option.
643
 
                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
644
 
                    ;;
645
 
                  *)
646
 
                    dnl Most likely an immediate library name.
647
 
                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep"
648
 
                    LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep"
649
 
                    ;;
650
 
                esac
651
 
              done
652
 
            fi
653
 
          else
654
 
            dnl Didn't find the library; assume it is in the system directories
655
 
            dnl known to the linker and runtime loader. (All the system
656
 
            dnl directories known to the linker should also be known to the
657
 
            dnl runtime loader, otherwise the system is severely misconfigured.)
658
 
            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
659
 
            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name"
660
 
          fi
661
 
        fi
662
 
      fi
663
 
    done
664
 
  done
665
 
  if test "X$rpathdirs" != "X"; then
666
 
    if test -n "$hardcode_libdir_separator"; then
667
 
      dnl Weird platform: only the last -rpath option counts, the user must
668
 
      dnl pass all path elements in one option. We can arrange that for a
669
 
      dnl single library, but not when more than one $LIBNAMEs are used.
670
 
      alldirs=
671
 
      for found_dir in $rpathdirs; do
672
 
        alldirs="${alldirs}${alldirs:+$hardcode_libdir_separator}$found_dir"
673
 
      done
674
 
      dnl Note: hardcode_libdir_flag_spec uses $libdir and $wl.
675
 
      acl_save_libdir="$libdir"
676
 
      libdir="$alldirs"
677
 
      eval flag=\"$hardcode_libdir_flag_spec\"
678
 
      libdir="$acl_save_libdir"
679
 
      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
680
 
    else
681
 
      dnl The -rpath options are cumulative.
682
 
      for found_dir in $rpathdirs; do
683
 
        acl_save_libdir="$libdir"
684
 
        libdir="$found_dir"
685
 
        eval flag=\"$hardcode_libdir_flag_spec\"
686
 
        libdir="$acl_save_libdir"
687
 
        LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
688
 
      done
689
 
    fi
690
 
  fi
691
 
  if test "X$ltrpathdirs" != "X"; then
692
 
    dnl When using libtool, the option that works for both libraries and
693
 
    dnl executables is -R. The -R options are cumulative.
694
 
    for found_dir in $ltrpathdirs; do
695
 
      LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir"
696
 
    done
697
 
  fi
698
 
])
699
 
 
700
 
dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR,
701
 
dnl unless already present in VAR.
702
 
dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes
703
 
dnl contains two or three consecutive elements that belong together.
704
 
AC_DEFUN([AC_LIB_APPENDTOVAR],
705
 
[
706
 
  for element in [$2]; do
707
 
    haveit=
708
 
    for x in $[$1]; do
709
 
      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
710
 
      if test "X$x" = "X$element"; then
711
 
        haveit=yes
712
 
        break
713
 
      fi
714
 
    done
715
 
    if test -z "$haveit"; then
716
 
      [$1]="${[$1]}${[$1]:+ }$element"
717
 
    fi
718
 
  done
719
 
])
720
 
 
721
 
# lib-ld.m4 serial 2 (gettext-0.12)
722
 
dnl Copyright (C) 1996-2003 Free Software Foundation, Inc.
723
 
dnl This file is free software, distributed under the terms of the GNU
724
 
dnl General Public License.  As a special exception to the GNU General
725
 
dnl Public License, this file may be distributed as part of a program
726
 
dnl that contains a configuration script generated by Autoconf, under
727
 
dnl the same distribution terms as the rest of that program.
728
 
 
729
 
dnl Subroutines of libtool.m4,
730
 
dnl with replacements s/AC_/AC_LIB/ and s/lt_cv/acl_cv/ to avoid collision
731
 
dnl with libtool.m4.
732
 
 
733
 
dnl From libtool-1.4. Sets the variable with_gnu_ld to yes or no.
734
 
AC_DEFUN([AC_LIB_PROG_LD_GNU],
735
 
[AC_CACHE_CHECK([if the linker ($LD) is GNU ld], acl_cv_prog_gnu_ld,
736
 
[# I'd rather use --version here, but apparently some GNU ld's only accept -v.
737
 
if $LD -v 2>&1 </dev/null | egrep '(GNU|with BFD)' 1>&5; then
738
 
  acl_cv_prog_gnu_ld=yes
739
 
else
740
 
  acl_cv_prog_gnu_ld=no
741
 
fi])
742
 
with_gnu_ld=$acl_cv_prog_gnu_ld
743
 
])
744
 
 
745
 
dnl From libtool-1.4. Sets the variable LD.
746
 
AC_DEFUN([AC_LIB_PROG_LD],
747
 
[AC_ARG_WITH(gnu-ld,
748
 
[  --with-gnu-ld           assume the C compiler uses GNU ld [default=no]],
749
 
test "$withval" = no || with_gnu_ld=yes, with_gnu_ld=no)
750
 
AC_REQUIRE([AC_PROG_CC])dnl
751
 
AC_REQUIRE([AC_CANONICAL_HOST])dnl
752
 
# Prepare PATH_SEPARATOR.
753
 
# The user is always right.
754
 
if test "${PATH_SEPARATOR+set}" != set; then
755
 
  echo "#! /bin/sh" >conf$$.sh
756
 
  echo  "exit 0"   >>conf$$.sh
757
 
  chmod +x conf$$.sh
758
 
  if (PATH="/nonexistent;."; conf$$.sh) >/dev/null 2>&1; then
759
 
    PATH_SEPARATOR=';'
760
 
  else
761
 
    PATH_SEPARATOR=:
762
 
  fi
763
 
  rm -f conf$$.sh
764
 
fi
765
 
ac_prog=ld
766
 
if test "$GCC" = yes; then
767
 
  # Check if gcc -print-prog-name=ld gives a path.
768
 
  AC_MSG_CHECKING([for ld used by GCC])
769
 
  case $host in
770
 
  *-*-mingw*)
771
 
    # gcc leaves a trailing carriage return which upsets mingw
772
 
    ac_prog=`($CC -print-prog-name=ld) 2>&5 | tr -d '\015'` ;;
773
 
  *)
774
 
    ac_prog=`($CC -print-prog-name=ld) 2>&5` ;;
775
 
  esac
776
 
  case $ac_prog in
777
 
    # Accept absolute paths.
778
 
    [[\\/]* | [A-Za-z]:[\\/]*)]
779
 
      [re_direlt='/[^/][^/]*/\.\./']
780
 
      # Canonicalize the path of ld
781
 
      ac_prog=`echo $ac_prog| sed 's%\\\\%/%g'`
782
 
      while echo $ac_prog | grep "$re_direlt" > /dev/null 2>&1; do
783
 
        ac_prog=`echo $ac_prog| sed "s%$re_direlt%/%"`
784
 
      done
785
 
      test -z "$LD" && LD="$ac_prog"
786
 
      ;;
787
 
  "")
788
 
    # If it fails, then pretend we aren't using GCC.
789
 
    ac_prog=ld
790
 
    ;;
791
 
  *)
792
 
    # If it is relative, then search for the first ld in PATH.
793
 
    with_gnu_ld=unknown
794
 
    ;;
795
 
  esac
796
 
elif test "$with_gnu_ld" = yes; then
797
 
  AC_MSG_CHECKING([for GNU ld])
798
 
else
799
 
  AC_MSG_CHECKING([for non-GNU ld])
800
 
fi
801
 
AC_CACHE_VAL(acl_cv_path_LD,
802
 
[if test -z "$LD"; then
803
 
  IFS="${IFS=   }"; ac_save_ifs="$IFS"; IFS="${IFS}${PATH_SEPARATOR-:}"
804
 
  for ac_dir in $PATH; do
805
 
    test -z "$ac_dir" && ac_dir=.
806
 
    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
807
 
      acl_cv_path_LD="$ac_dir/$ac_prog"
808
 
      # Check to see if the program is GNU ld.  I'd rather use --version,
809
 
      # but apparently some GNU ld's only accept -v.
810
 
      # Break only if it was the GNU/non-GNU ld that we prefer.
811
 
      if "$acl_cv_path_LD" -v 2>&1 < /dev/null | egrep '(GNU|with BFD)' > /dev/null; then
812
 
        test "$with_gnu_ld" != no && break
813
 
      else
814
 
        test "$with_gnu_ld" != yes && break
815
 
      fi
816
 
    fi
817
 
  done
818
 
  IFS="$ac_save_ifs"
819
 
else
820
 
  acl_cv_path_LD="$LD" # Let the user override the test with a path.
821
 
fi])
822
 
LD="$acl_cv_path_LD"
823
 
if test -n "$LD"; then
824
 
  AC_MSG_RESULT($LD)
825
 
else
826
 
  AC_MSG_RESULT(no)
827
 
fi
828
 
test -z "$LD" && AC_MSG_ERROR([no acceptable ld found in \$PATH])
829
 
AC_LIB_PROG_LD_GNU
830
 
])
831
 
 
832
 
# isc-posix.m4 serial 2 (gettext-0.11.2)
833
 
dnl Copyright (C) 1995-2002 Free Software Foundation, Inc.
834
 
dnl This file is free software, distributed under the terms of the GNU
835
 
dnl General Public License.  As a special exception to the GNU General
836
 
dnl Public License, this file may be distributed as part of a program
837
 
dnl that contains a configuration script generated by Autoconf, under
838
 
dnl the same distribution terms as the rest of that program.
839
 
 
840
 
# This file is not needed with autoconf-2.53 and newer.  Remove it in 2005.
841
 
 
842
 
# This test replaces the one in autoconf.
843
 
# Currently this macro should have the same name as the autoconf macro
844
 
# because gettext's gettext.m4 (distributed in the automake package)
845
 
# still uses it.  Otherwise, the use in gettext.m4 makes autoheader
846
 
# give these diagnostics:
847
 
#   configure.in:556: AC_TRY_COMPILE was called before AC_ISC_POSIX
848
 
#   configure.in:556: AC_TRY_RUN was called before AC_ISC_POSIX
849
 
 
850
 
undefine([AC_ISC_POSIX])
851
 
 
852
 
AC_DEFUN([AC_ISC_POSIX],
853
 
  [
854
 
    dnl This test replaces the obsolescent AC_ISC_POSIX kludge.
855
 
    AC_CHECK_LIB(cposix, strerror, [LIBS="$LIBS -lcposix"])
856
 
  ]
857
 
)
 
19
dnl
 
20
dnl This file can can be used in projects which are not available under
 
21
dnl the GNU General Public License or the GNU Library General Public
 
22
dnl License but which still want to provide support for the GNU gettext
 
23
dnl functionality.
 
24
dnl Please note that the actual code of the GNU gettext library is covered
 
25
dnl by the GNU Library General Public License, and the rest of the GNU
 
26
dnl gettext package package is covered by the GNU General Public License.
 
27
dnl They are *not* in the public domain.
 
28
 
 
29
dnl Authors:
 
30
dnl   Ulrich Drepper <drepper@cygnus.com>, 1995.
 
31
 
 
32
# Check whether LC_MESSAGES is available in <locale.h>.
 
33
 
 
34
AC_DEFUN([gt_LC_MESSAGES],
 
35
[
 
36
  AC_CACHE_CHECK([for LC_MESSAGES], gt_cv_val_LC_MESSAGES,
 
37
    [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
 
38
       gt_cv_val_LC_MESSAGES=yes, gt_cv_val_LC_MESSAGES=no)])
 
39
  if test $gt_cv_val_LC_MESSAGES = yes; then
 
40
    AC_DEFINE(HAVE_LC_MESSAGES, 1,
 
41
      [Define if your <locale.h> file defines LC_MESSAGES.])
 
42
  fi
 
43
])
858
44
 
859
45
# libtool.m4 - Configure libtool for the host system. -*-Autoconf-*-
860
46
 
861
 
# serial 47 AC_PROG_LIBTOOL
862
 
# Debian $Rev: 47 $
 
47
# serial 48 Debian 1.5.22-4 AC_PROG_LIBTOOL
863
48
 
864
49
 
865
50
# AC_PROVIDE_IFELSE(MACRO-NAME, IF-PROVIDED, IF-NOT-PROVIDED)
969
154
 
970
155
# Sed substitution that helps us do robust quoting.  It backslashifies
971
156
# metacharacters that are still active within double-quoted strings.
972
 
Xsed='sed -e s/^X//'
 
157
Xsed='sed -e 1s/^X//'
973
158
[sed_quote_subst='s/\([\\"\\`$\\\\]\)/\\\1/g']
974
159
 
975
160
# Same as above, but do not quote variable references.
989
174
default_ofile=libtool
990
175
can_build_shared=yes
991
176
 
992
 
# All known linkers require a `.a' archive for static linking (except M$VC,
 
177
# All known linkers require a `.a' archive for static linking (except MSVC,
993
178
# which needs '.lib').
994
179
libext=a
995
180
ltmain="$ac_aux_dir/ltmain.sh"
1009
194
test -z "$AS" && AS=as
1010
195
test -z "$CC" && CC=cc
1011
196
test -z "$LTCC" && LTCC=$CC
 
197
test -z "$LTCFLAGS" && LTCFLAGS=$CFLAGS
1012
198
test -z "$DLLTOOL" && DLLTOOL=dlltool
1013
199
test -z "$LD" && LD=ld
1014
200
test -z "$LN_S" && LN_S="ln -s"
1028
214
if test -n "$RANLIB"; then
1029
215
  case $host_os in
1030
216
  openbsd*)
1031
 
    old_postinstall_cmds="\$RANLIB -t \$oldlib~$old_postinstall_cmds"
 
217
    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB -t \$oldlib"
1032
218
    ;;
1033
219
  *)
1034
 
    old_postinstall_cmds="\$RANLIB \$oldlib~$old_postinstall_cmds"
 
220
    old_postinstall_cmds="$old_postinstall_cmds~\$RANLIB \$oldlib"
1035
221
    ;;
1036
222
  esac
1037
223
  old_archive_cmds="$old_archive_cmds~\$RANLIB \$oldlib"
1038
224
fi
1039
225
 
 
226
_LT_CC_BASENAME([$compiler])
 
227
 
1040
228
# Only perform the check for file, if the check method requires it
1041
229
case $deplibs_check_method in
1042
230
file_magic*)
1077
265
# If no C compiler was specified, use CC.
1078
266
LTCC=${LTCC-"$CC"}
1079
267
 
 
268
# If no C compiler flags were specified, use CFLAGS.
 
269
LTCFLAGS=${LTCFLAGS-"$CFLAGS"}
 
270
 
1080
271
# Allow CC to be a program name with arguments.
1081
272
compiler=$CC
1082
273
])# _LT_AC_SYS_COMPILER
1083
274
 
1084
275
 
 
276
# _LT_CC_BASENAME(CC)
 
277
# -------------------
 
278
# Calculate cc_basename.  Skip known compiler wrappers and cross-prefix.
 
279
AC_DEFUN([_LT_CC_BASENAME],
 
280
[for cc_temp in $1""; do
 
281
  case $cc_temp in
 
282
    compile | *[[\\/]]compile | ccache | *[[\\/]]ccache ) ;;
 
283
    distcc | *[[\\/]]distcc | purify | *[[\\/]]purify ) ;;
 
284
    \-*) ;;
 
285
    *) break;;
 
286
  esac
 
287
done
 
288
cc_basename=`$echo "X$cc_temp" | $Xsed -e 's%.*/%%' -e "s%^$host_alias-%%"`
 
289
])
 
290
 
 
291
 
 
292
# _LT_COMPILER_BOILERPLATE
 
293
# ------------------------
 
294
# Check for compiler boilerplate output or warnings with
 
295
# the simple compiler test code.
 
296
AC_DEFUN([_LT_COMPILER_BOILERPLATE],
 
297
[ac_outfile=conftest.$ac_objext
 
298
printf "$lt_simple_compile_test_code" >conftest.$ac_ext
 
299
eval "$ac_compile" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
 
300
_lt_compiler_boilerplate=`cat conftest.err`
 
301
$rm conftest*
 
302
])# _LT_COMPILER_BOILERPLATE
 
303
 
 
304
 
 
305
# _LT_LINKER_BOILERPLATE
 
306
# ----------------------
 
307
# Check for linker boilerplate output or warnings with
 
308
# the simple link test code.
 
309
AC_DEFUN([_LT_LINKER_BOILERPLATE],
 
310
[ac_outfile=conftest.$ac_objext
 
311
printf "$lt_simple_link_test_code" >conftest.$ac_ext
 
312
eval "$ac_link" 2>&1 >/dev/null | $SED '/^$/d; /^ *+/d' >conftest.err
 
313
_lt_linker_boilerplate=`cat conftest.err`
 
314
$rm conftest*
 
315
])# _LT_LINKER_BOILERPLATE
 
316
 
 
317
 
1085
318
# _LT_AC_SYS_LIBPATH_AIX
1086
319
# ----------------------
1087
320
# Links a minimal program and checks the executable
1154
387
 
1155
388
# The HP-UX ksh and POSIX shell print the target directory to stdout
1156
389
# if CDPATH is set.
1157
 
if test "X${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi
 
390
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
1158
391
 
1159
392
if test -z "$ECHO"; then
1160
393
if test "X${echo_test_string+set}" != Xset; then
1161
394
# find a string as large as possible, as long as the shell can cope with it
1162
395
  for cmd in 'sed 50q "[$]0"' 'sed 20q "[$]0"' 'sed 10q "[$]0"' 'sed 2q "[$]0"' 'echo test'; do
1163
396
    # expected sizes: less than 2Kb, 1Kb, 512 bytes, 16 bytes, ...
1164
 
    if (echo_test_string="`eval $cmd`") 2>/dev/null &&
1165
 
       echo_test_string="`eval $cmd`" &&
 
397
    if (echo_test_string=`eval $cmd`) 2>/dev/null &&
 
398
       echo_test_string=`eval $cmd` &&
1166
399
       (test "X$echo_test_string" = "X$echo_test_string") 2>/dev/null
1167
400
    then
1168
401
      break
1331
564
  # Find out which ABI we are using.
1332
565
  echo 'int i;' > conftest.$ac_ext
1333
566
  if AC_TRY_EVAL(ac_compile); then
1334
 
    case "`/usr/bin/file conftest.o`" in
 
567
    case `/usr/bin/file conftest.o` in
1335
568
    *32-bit*)
1336
569
      case $host in
1337
570
        x86_64-*linux*)
1382
615
    CFLAGS="$SAVE_CFLAGS"
1383
616
  fi
1384
617
  ;;
 
618
sparc*-*solaris*)
 
619
  # Find out which ABI we are using.
 
620
  echo 'int i;' > conftest.$ac_ext
 
621
  if AC_TRY_EVAL(ac_compile); then
 
622
    case `/usr/bin/file conftest.o` in
 
623
    *64-bit*)
 
624
      case $lt_cv_prog_gnu_ld in
 
625
      yes*) LD="${LD-ld} -m elf64_sparc" ;;
 
626
      *)    LD="${LD-ld} -64" ;;
 
627
      esac
 
628
      ;;
 
629
    esac
 
630
  fi
 
631
  rm -rf conftest*
 
632
  ;;
 
633
 
1385
634
AC_PROVIDE_IFELSE([AC_LIBTOOL_WIN32_DLL],
1386
635
[*-*-cygwin* | *-*-mingw* | *-*-pw32*)
1387
636
  AC_CHECK_TOOL(DLLTOOL, dlltool, false)
1413
662
   # with a dollar sign (not a hyphen), so the echo should work correctly.
1414
663
   # The option is referenced via a variable to avoid confusing sed.
1415
664
   lt_compile=`echo "$ac_compile" | $SED \
1416
 
   -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
 
665
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
1417
666
   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
1418
667
   -e 's:$: $lt_compiler_flag:'`
1419
668
   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
1423
672
   echo "$as_me:__oline__: \$? = $ac_status" >&AS_MESSAGE_LOG_FD
1424
673
   if (exit $ac_status) && test -s "$ac_outfile"; then
1425
674
     # The compiler can only warn and ignore the option if not recognized
1426
 
     # So say no if there are warnings
1427
 
     if test ! -s conftest.err; then
 
675
     # So say no if there are warnings other than the usual output.
 
676
     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' >conftest.exp
 
677
     $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
 
678
     if test ! -s conftest.er2 || diff conftest.exp conftest.er2 >/dev/null; then
1428
679
       $2=yes
1429
680
     fi
1430
681
   fi
1450
701
   LDFLAGS="$LDFLAGS $3"
1451
702
   printf "$lt_simple_link_test_code" > conftest.$ac_ext
1452
703
   if (eval $ac_link 2>conftest.err) && test -s conftest$ac_exeext; then
1453
 
     # The compiler can only warn and ignore the option if not recognized
 
704
     # The linker can only warn and ignore the option if not recognized
1454
705
     # So say no if there are warnings
1455
706
     if test -s conftest.err; then
1456
707
       # Append any errors to the config.log.
1457
708
       cat conftest.err 1>&AS_MESSAGE_LOG_FD
 
709
       $echo "X$_lt_linker_boilerplate" | $Xsed -e '/^$/d' > conftest.exp
 
710
       $SED '/^$/d; /^ *+/d' conftest.err >conftest.er2
 
711
       if diff conftest.exp conftest.er2 >/dev/null; then
 
712
         $2=yes
 
713
       fi
1458
714
     else
1459
715
       $2=yes
1460
716
     fi
1478
734
AC_MSG_CHECKING([the maximum length of command line arguments])
1479
735
AC_CACHE_VAL([lt_cv_sys_max_cmd_len], [dnl
1480
736
  i=0
1481
 
  testring="ABCD"
 
737
  teststring="ABCD"
1482
738
 
1483
739
  case $build_os in
1484
740
  msdosdjgpp*)
1513
769
    lt_cv_sys_max_cmd_len=8192;
1514
770
    ;;
1515
771
 
1516
 
 *)
 
772
  netbsd* | freebsd* | openbsd* | darwin* | dragonfly*)
 
773
    # This has been around since 386BSD, at least.  Likely further.
 
774
    if test -x /sbin/sysctl; then
 
775
      lt_cv_sys_max_cmd_len=`/sbin/sysctl -n kern.argmax`
 
776
    elif test -x /usr/sbin/sysctl; then
 
777
      lt_cv_sys_max_cmd_len=`/usr/sbin/sysctl -n kern.argmax`
 
778
    else
 
779
      lt_cv_sys_max_cmd_len=65536       # usable default for all BSDs
 
780
    fi
 
781
    # And add a safety zone
 
782
    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \/ 4`
 
783
    lt_cv_sys_max_cmd_len=`expr $lt_cv_sys_max_cmd_len \* 3`
 
784
    ;;
 
785
 
 
786
  interix*)
 
787
    # We know the value 262144 and hardcode it with a safety zone (like BSD)
 
788
    lt_cv_sys_max_cmd_len=196608
 
789
    ;;
 
790
 
 
791
  osf*)
 
792
    # Dr. Hans Ekkehard Plesser reports seeing a kernel panic running configure
 
793
    # due to this test when exec_disable_arg_limit is 1 on Tru64. It is not
 
794
    # nice to cause kernel panics so lets avoid the loop below.
 
795
    # First set a reasonable default.
 
796
    lt_cv_sys_max_cmd_len=16384
 
797
    #
 
798
    if test -x /sbin/sysconfig; then
 
799
      case `/sbin/sysconfig -q proc exec_disable_arg_limit` in
 
800
        *1*) lt_cv_sys_max_cmd_len=-1 ;;
 
801
      esac
 
802
    fi
 
803
    ;;
 
804
  sco3.2v5*)
 
805
    lt_cv_sys_max_cmd_len=102400
 
806
    ;;
 
807
  sysv5* | sco5v6* | sysv4.2uw2*)
 
808
    kargmax=`grep ARG_MAX /etc/conf/cf.d/stune 2>/dev/null`
 
809
    if test -n "$kargmax"; then
 
810
      lt_cv_sys_max_cmd_len=`echo $kargmax | sed 's/.*[[        ]]//'`
 
811
    else
 
812
      lt_cv_sys_max_cmd_len=32768
 
813
    fi
 
814
    ;;
 
815
  *)
1517
816
    # If test is not a shell built-in, we'll probably end up computing a
1518
817
    # maximum length that is only half of the actual maximum length, but
1519
818
    # we can't tell.
1520
 
    while (test "X"`$CONFIG_SHELL [$]0 --fallback-echo "X$testring" 2>/dev/null` \
1521
 
               = "XX$testring") >/dev/null 2>&1 &&
1522
 
            new_result=`expr "X$testring" : ".*" 2>&1` &&
 
819
    SHELL=${SHELL-${CONFIG_SHELL-/bin/sh}}
 
820
    while (test "X"`$SHELL [$]0 --fallback-echo "X$teststring" 2>/dev/null` \
 
821
               = "XX$teststring") >/dev/null 2>&1 &&
 
822
            new_result=`expr "X$teststring" : ".*" 2>&1` &&
1523
823
            lt_cv_sys_max_cmd_len=$new_result &&
1524
824
            test $i != 17 # 1/2 MB should be enough
1525
825
    do
1526
826
      i=`expr $i + 1`
1527
 
      testring=$testring$testring
 
827
      teststring=$teststring$teststring
1528
828
    done
1529
 
    testring=
 
829
    teststring=
1530
830
    # Add a significant safety factor because C++ compilers can tack on massive
1531
831
    # amounts of additional arguments before passing them to the linker.
1532
832
    # It appears as though 1/2 is a usable value.
1543
843
 
1544
844
 
1545
845
# _LT_AC_CHECK_DLFCN
1546
 
# --------------------
 
846
# ------------------
1547
847
AC_DEFUN([_LT_AC_CHECK_DLFCN],
1548
848
[AC_CHECK_HEADERS(dlfcn.h)dnl
1549
849
])# _LT_AC_CHECK_DLFCN
1551
851
 
1552
852
# _LT_AC_TRY_DLOPEN_SELF (ACTION-IF-TRUE, ACTION-IF-TRUE-W-USCORE,
1553
853
#                           ACTION-IF-FALSE, ACTION-IF-CROSS-COMPILING)
1554
 
# ------------------------------------------------------------------
 
854
# ---------------------------------------------------------------------
1555
855
AC_DEFUN([_LT_AC_TRY_DLOPEN_SELF],
1556
856
[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
1557
857
if test "$cross_compiling" = yes; then :
1617
917
      else if (dlsym( self,"_fnord")) status = $lt_dlneed_uscore;
1618
918
      /* dlclose (self); */
1619
919
    }
 
920
  else
 
921
    puts (dlerror ());
1620
922
 
1621
923
    exit (status);
1622
924
}]
1623
925
EOF
1624
926
  if AC_TRY_EVAL(ac_link) && test -s conftest${ac_exeext} 2>/dev/null; then
1625
 
    (./conftest; exit; ) 2>/dev/null
 
927
    (./conftest; exit; ) >&AS_MESSAGE_LOG_FD 2>/dev/null
1626
928
    lt_status=$?
1627
929
    case x$lt_status in
1628
930
      x$lt_dlno_uscore) $1 ;;
1629
931
      x$lt_dlneed_uscore) $2 ;;
1630
 
      x$lt_unknown|x*) $3 ;;
 
932
      x$lt_dlunknown|x*) $3 ;;
1631
933
    esac
1632
934
  else :
1633
935
    # compilation failed
1639
941
 
1640
942
 
1641
943
# AC_LIBTOOL_DLOPEN_SELF
1642
 
# -------------------
 
944
# ----------------------
1643
945
AC_DEFUN([AC_LIBTOOL_DLOPEN_SELF],
1644
946
[AC_REQUIRE([_LT_AC_CHECK_DLFCN])dnl
1645
947
if test "x$enable_dlopen" != xyes; then
1676
978
    lt_cv_dlopen_self=yes
1677
979
    ])
1678
980
   ;;
1679
 
    
 
981
 
1680
982
  *)
1681
983
    AC_CHECK_FUNC([shl_load],
1682
984
          [lt_cv_dlopen="shl_load"],
1710
1012
    test "x$ac_cv_header_dlfcn_h" = xyes && CPPFLAGS="$CPPFLAGS -DHAVE_DLFCN_H"
1711
1013
 
1712
1014
    save_LDFLAGS="$LDFLAGS"
1713
 
    eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
 
1015
    wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $export_dynamic_flag_spec\"
1714
1016
 
1715
1017
    save_LIBS="$LIBS"
1716
1018
    LIBS="$lt_cv_dlopen_libs $LIBS"
1723
1025
    ])
1724
1026
 
1725
1027
    if test "x$lt_cv_dlopen_self" = xyes; then
1726
 
      LDFLAGS="$LDFLAGS $link_static_flag"
 
1028
      wl=$lt_prog_compiler_wl eval LDFLAGS=\"\$LDFLAGS $lt_prog_compiler_static\"
1727
1029
      AC_CACHE_CHECK([whether a statically linked program can dlopen itself],
1728
1030
          lt_cv_dlopen_self_static, [dnl
1729
1031
          _LT_AC_TRY_DLOPEN_SELF(
1765
1067
   mkdir out
1766
1068
   printf "$lt_simple_compile_test_code" > conftest.$ac_ext
1767
1069
 
1768
 
   # According to Tom Tromey, Ian Lance Taylor reported there are C compilers
1769
 
   # that will create temporary files in the current directory regardless of
1770
 
   # the output directory.  Thus, making CWD read-only will cause this test
1771
 
   # to fail, enabling locking or at least warning the user not to do parallel
1772
 
   # builds.
1773
 
   chmod -w .
1774
 
 
1775
1070
   lt_compiler_flag="-o out/conftest2.$ac_objext"
1776
1071
   # Insert the option either (1) after the last *FLAGS variable, or
1777
1072
   # (2) before a word containing "conftest.", or (3) at the end.
1778
1073
   # Note that $ac_compile itself does not contain backslashes and begins
1779
1074
   # with a dollar sign (not a hyphen), so the echo should work correctly.
1780
1075
   lt_compile=`echo "$ac_compile" | $SED \
1781
 
   -e 's:.*FLAGS}? :&$lt_compiler_flag :; t' \
 
1076
   -e 's:.*FLAGS}\{0,1\} :&$lt_compiler_flag :; t' \
1782
1077
   -e 's: [[^ ]]*conftest\.: $lt_compiler_flag&:; t' \
1783
1078
   -e 's:$: $lt_compiler_flag:'`
1784
1079
   (eval echo "\"\$as_me:__oline__: $lt_compile\"" >&AS_MESSAGE_LOG_FD)
1790
1085
   then
1791
1086
     # The compiler can only warn and ignore the option if not recognized
1792
1087
     # So say no if there are warnings
1793
 
     if test ! -s out/conftest.err; then
 
1088
     $echo "X$_lt_compiler_boilerplate" | $Xsed -e '/^$/d' > out/conftest.exp
 
1089
     $SED '/^$/d; /^ *+/d' out/conftest.err >out/conftest.er2
 
1090
     if test ! -s out/conftest.er2 || diff out/conftest.exp out/conftest.er2 >/dev/null; then
1794
1091
       _LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
1795
1092
     fi
1796
1093
   fi
1797
 
   chmod u+w .
 
1094
   chmod u+w . 2>&AS_MESSAGE_LOG_FD
1798
1095
   $rm conftest*
1799
1096
   # SGI C++ compiler will create directory out/ii_files/ for
1800
1097
   # template instantiation
1858
1155
[AC_MSG_CHECKING([how to hardcode library paths into programs])
1859
1156
_LT_AC_TAGVAR(hardcode_action, $1)=
1860
1157
if test -n "$_LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)" || \
1861
 
   test -n "$_LT_AC_TAGVAR(runpath_var $1)" || \
1862
 
   test "X$_LT_AC_TAGVAR(hardcode_automatic, $1)"="Xyes" ; then
 
1158
   test -n "$_LT_AC_TAGVAR(runpath_var, $1)" || \
 
1159
   test "X$_LT_AC_TAGVAR(hardcode_automatic, $1)" = "Xyes" ; then
1863
1160
 
1864
1161
  # We can hardcode non-existant directories.
1865
1162
  if test "$_LT_AC_TAGVAR(hardcode_direct, $1)" != no &&
1916
1213
   *)
1917
1214
  AC_MSG_RESULT([no])
1918
1215
    ;;
1919
 
  esac  
 
1216
  esac
1920
1217
fi
1921
1218
])# AC_LIBTOOL_SYS_LIB_STRIP
1922
1219
 
1929
1226
library_names_spec=
1930
1227
libname_spec='lib$name'
1931
1228
soname_spec=
1932
 
shrext=".so"
 
1229
shrext_cmds=".so"
1933
1230
postinstall_cmds=
1934
1231
postuninstall_cmds=
1935
1232
finish_cmds=
2026
1323
  shlibpath_var=LIBRARY_PATH
2027
1324
  ;;
2028
1325
 
2029
 
bsdi4*)
 
1326
bsdi[[45]]*)
2030
1327
  version_type=linux
2031
1328
  need_version=no
2032
1329
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2042
1339
 
2043
1340
cygwin* | mingw* | pw32*)
2044
1341
  version_type=windows
2045
 
  shrext=".dll"
 
1342
  shrext_cmds=".dll"
2046
1343
  need_version=no
2047
1344
  need_lib_prefix=no
2048
1345
 
2054
1351
      dlpath=`$SHELL 2>&1 -c '\''. $dir/'\''\${base_file}'\''i;echo \$dlname'\''`~
2055
1352
      dldir=$destdir/`dirname \$dlpath`~
2056
1353
      test -d \$dldir || mkdir -p \$dldir~
2057
 
      $install_prog $dir/$dlname \$dldir/$dlname'
 
1354
      $install_prog $dir/$dlname \$dldir/$dlname~
 
1355
      chmod a+x \$dldir/$dlname'
2058
1356
    postuninstall_cmds='dldll=`$SHELL 2>&1 -c '\''. $file; echo \$dlname'\''`~
2059
1357
      dlpath=$dir/\$dldll~
2060
1358
       $rm \$dlpath'
2084
1382
      ;;
2085
1383
    pw32*)
2086
1384
      # pw32 DLLs use 'pw' prefix rather than 'lib'
2087
 
      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[.]/-/g'`${versuffix}${shared_ext}'
 
1385
      library_names_spec='`echo ${libname} | sed -e 's/^lib/pw/'``echo ${release} | $SED -e 's/[[.]]/-/g'`${versuffix}${shared_ext}'
2088
1386
      ;;
2089
1387
    esac
2090
1388
    ;;
2107
1405
  soname_spec='${libname}${release}${major}$shared_ext'
2108
1406
  shlibpath_overrides_runpath=yes
2109
1407
  shlibpath_var=DYLD_LIBRARY_PATH
2110
 
  shrext='$(test .$module = .yes && echo .so || echo .dylib)'
 
1408
  shrext_cmds='`test .$module = .yes && echo .so || echo .dylib`'
2111
1409
  # Apple's gcc prints 'gcc -print-search-dirs' doesn't operate the same.
2112
1410
  if test "$GCC" = yes; then
2113
1411
    sys_lib_search_path_spec=`$CC -print-search-dirs | tr "\n" "$PATH_SEPARATOR" | sed -e 's/libraries:/@libraries:/' | tr "@" "\n" | grep "^libraries:" | sed -e "s/^libraries://" -e "s,=/,/,g" -e "s,$PATH_SEPARATOR, ,g" -e "s,.*,& /lib /usr/lib /usr/local/lib,g"`
2130
1428
  dynamic_linker=no
2131
1429
  ;;
2132
1430
 
2133
 
kfreebsd*-gnu)
2134
 
  version_type=linux
2135
 
  need_lib_prefix=no
2136
 
  need_version=no
2137
 
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
2138
 
  soname_spec='${libname}${release}${shared_ext}$major'
2139
 
  shlibpath_var=LD_LIBRARY_PATH
2140
 
  shlibpath_overrides_runpath=no
2141
 
  hardcode_into_libs=yes
2142
 
  dynamic_linker='GNU ld.so'
2143
 
  ;;
2144
 
 
2145
 
freebsd*)
2146
 
  objformat=`test -x /usr/bin/objformat && /usr/bin/objformat || echo aout`
 
1431
freebsd* | dragonfly*)
 
1432
  # DragonFly does not have aout.  When/if they implement a new
 
1433
  # versioning mechanism, adjust this.
 
1434
  if test -x /usr/bin/objformat; then
 
1435
    objformat=`/usr/bin/objformat`
 
1436
  else
 
1437
    case $host_os in
 
1438
    freebsd[[123]]*) objformat=aout ;;
 
1439
    *) objformat=elf ;;
 
1440
    esac
 
1441
  fi
2147
1442
  version_type=freebsd-$objformat
2148
1443
  case $version_type in
2149
1444
    freebsd-elf*)
2161
1456
  freebsd2*)
2162
1457
    shlibpath_overrides_runpath=yes
2163
1458
    ;;
2164
 
  freebsd3.[01]* | freebsdelf3.[01]*)
 
1459
  freebsd3.[[01]]* | freebsdelf3.[[01]]*)
2165
1460
    shlibpath_overrides_runpath=yes
2166
1461
    hardcode_into_libs=yes
2167
1462
    ;;
2168
 
  *) # from 3.2 on
 
1463
  freebsd3.[[2-9]]* | freebsdelf3.[[2-9]]* | \
 
1464
  freebsd4.[[0-5]] | freebsdelf4.[[0-5]] | freebsd4.1.1 | freebsdelf4.1.1)
2169
1465
    shlibpath_overrides_runpath=no
2170
1466
    hardcode_into_libs=yes
2171
1467
    ;;
 
1468
  freebsd*) # from 4.6 on
 
1469
    shlibpath_overrides_runpath=yes
 
1470
    hardcode_into_libs=yes
 
1471
    ;;
2172
1472
  esac
2173
1473
  ;;
2174
1474
 
2188
1488
  version_type=sunos
2189
1489
  need_lib_prefix=no
2190
1490
  need_version=no
2191
 
  case "$host_cpu" in
 
1491
  case $host_cpu in
2192
1492
  ia64*)
2193
 
    shrext='.so'
 
1493
    shrext_cmds='.so'
2194
1494
    hardcode_into_libs=yes
2195
1495
    dynamic_linker="$host_os dld.so"
2196
1496
    shlibpath_var=LD_LIBRARY_PATH
2205
1505
    sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
2206
1506
    ;;
2207
1507
   hppa*64*)
2208
 
     shrext='.sl'
 
1508
     shrext_cmds='.sl'
2209
1509
     hardcode_into_libs=yes
2210
1510
     dynamic_linker="$host_os dld.sl"
2211
1511
     shlibpath_var=LD_LIBRARY_PATH # How should we handle SHLIB_PATH
2216
1516
     sys_lib_dlsearch_path_spec=$sys_lib_search_path_spec
2217
1517
     ;;
2218
1518
   *)
2219
 
    shrext='.sl'
 
1519
    shrext_cmds='.sl'
2220
1520
    dynamic_linker="$host_os dld.sl"
2221
1521
    shlibpath_var=SHLIB_PATH
2222
1522
    shlibpath_overrides_runpath=no # +s is required to enable SHLIB_PATH
2228
1528
  postinstall_cmds='chmod 555 $lib'
2229
1529
  ;;
2230
1530
 
 
1531
interix3*)
 
1532
  version_type=linux
 
1533
  need_lib_prefix=no
 
1534
  need_version=no
 
1535
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
 
1536
  soname_spec='${libname}${release}${shared_ext}$major'
 
1537
  dynamic_linker='Interix 3.x ld.so.1 (PE, like ELF)'
 
1538
  shlibpath_var=LD_LIBRARY_PATH
 
1539
  shlibpath_overrides_runpath=no
 
1540
  hardcode_into_libs=yes
 
1541
  ;;
 
1542
 
2231
1543
irix5* | irix6* | nonstopux*)
2232
1544
  case $host_os in
2233
1545
    nonstopux*) version_type=nonstopux ;;
2271
1583
  ;;
2272
1584
 
2273
1585
# This must be Linux ELF.
2274
 
linux*)
 
1586
linux* | k*bsd*-gnu)
2275
1587
  version_type=linux
2276
1588
  need_lib_prefix=no
2277
1589
  need_version=no
2285
1597
  # before this can be enabled.
2286
1598
  hardcode_into_libs=yes
2287
1599
 
 
1600
  # Append ld.so.conf contents to the search path
 
1601
  if test -f /etc/ld.so.conf; then
 
1602
    lt_ld_extra=`awk '/^include / { system(sprintf("cd /etc; cat %s", \[$]2)); skip = 1; } { if (!skip) print \[$]0; skip = 0; }' < /etc/ld.so.conf | $SED -e 's/#.*//;s/[:,    ]/ /g;s/=[^=]*$//;s/=[^= ]* / /g;/^$/d' | tr '\n' ' '`
 
1603
    sys_lib_dlsearch_path_spec="/lib /usr/lib $lt_ld_extra"
 
1604
  fi
 
1605
 
2288
1606
  # We used to test for /lib/ld.so.1 and disable shared libraries on
2289
1607
  # powerpc, because MkLinux only supported shared libraries with the
2290
1608
  # GNU dynamic linker.  Since this was broken with cross compilers,
2294
1612
  dynamic_linker='GNU/Linux ld.so'
2295
1613
  ;;
2296
1614
 
 
1615
netbsdelf*-gnu)
 
1616
  version_type=linux
 
1617
  need_lib_prefix=no
 
1618
  need_version=no
 
1619
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
 
1620
  soname_spec='${libname}${release}${shared_ext}$major'
 
1621
  shlibpath_var=LD_LIBRARY_PATH
 
1622
  shlibpath_overrides_runpath=no
 
1623
  hardcode_into_libs=yes
 
1624
  dynamic_linker='NetBSD ld.elf_so'
 
1625
  ;;
 
1626
 
2297
1627
netbsd*)
2298
1628
  version_type=sunos
2299
1629
  need_lib_prefix=no
2303
1633
    finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
2304
1634
    dynamic_linker='NetBSD (a.out) ld.so'
2305
1635
  else
2306
 
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${release}${shared_ext} ${libname}${shared_ext}'
 
1636
    library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major ${libname}${shared_ext}'
2307
1637
    soname_spec='${libname}${release}${shared_ext}$major'
2308
1638
    dynamic_linker='NetBSD ld.elf_so'
2309
1639
  fi
2331
1661
 
2332
1662
openbsd*)
2333
1663
  version_type=sunos
 
1664
  sys_lib_dlsearch_path_spec="/usr/lib"
2334
1665
  need_lib_prefix=no
2335
 
  need_version=no
 
1666
  # Some older versions of OpenBSD (3.3 at least) *do* need versioned libs.
 
1667
  case $host_os in
 
1668
    openbsd3.3 | openbsd3.3.*) need_version=yes ;;
 
1669
    *)                         need_version=no  ;;
 
1670
  esac
2336
1671
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${shared_ext}$versuffix'
2337
1672
  finish_cmds='PATH="\$PATH:/sbin" ldconfig -m $libdir'
2338
1673
  shlibpath_var=LD_LIBRARY_PATH
2352
1687
 
2353
1688
os2*)
2354
1689
  libname_spec='$name'
2355
 
  shrext=".dll"
 
1690
  shrext_cmds=".dll"
2356
1691
  need_lib_prefix=no
2357
1692
  library_names_spec='$libname${shared_ext} $libname.a'
2358
1693
  dynamic_linker='OS/2 ld.exe'
2370
1705
  sys_lib_dlsearch_path_spec="$sys_lib_search_path_spec"
2371
1706
  ;;
2372
1707
 
2373
 
sco3.2v5*)
2374
 
  version_type=osf
2375
 
  soname_spec='${libname}${release}${shared_ext}$major'
2376
 
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2377
 
  shlibpath_var=LD_LIBRARY_PATH
2378
 
  ;;
2379
 
 
2380
1708
solaris*)
2381
1709
  version_type=linux
2382
1710
  need_lib_prefix=no
2402
1730
  need_version=yes
2403
1731
  ;;
2404
1732
 
2405
 
sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
 
1733
sysv4 | sysv4.3*)
2406
1734
  version_type=linux
2407
1735
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2408
1736
  soname_spec='${libname}${release}${shared_ext}$major'
2435
1763
  fi
2436
1764
  ;;
2437
1765
 
 
1766
sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
 
1767
  version_type=freebsd-elf
 
1768
  need_lib_prefix=no
 
1769
  need_version=no
 
1770
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext} $libname${shared_ext}'
 
1771
  soname_spec='${libname}${release}${shared_ext}$major'
 
1772
  shlibpath_var=LD_LIBRARY_PATH
 
1773
  hardcode_into_libs=yes
 
1774
  if test "$with_gnu_ld" = yes; then
 
1775
    sys_lib_search_path_spec='/usr/local/lib /usr/gnu/lib /usr/ccs/lib /usr/lib /lib'
 
1776
    shlibpath_overrides_runpath=no
 
1777
  else
 
1778
    sys_lib_search_path_spec='/usr/ccs/lib /usr/lib'
 
1779
    shlibpath_overrides_runpath=yes
 
1780
    case $host_os in
 
1781
      sco3.2v5*)
 
1782
        sys_lib_search_path_spec="$sys_lib_search_path_spec /lib"
 
1783
        ;;
 
1784
    esac
 
1785
  fi
 
1786
  sys_lib_dlsearch_path_spec='/usr/lib'
 
1787
  ;;
 
1788
 
2438
1789
uts4*)
2439
1790
  version_type=linux
2440
1791
  library_names_spec='${libname}${release}${shared_ext}$versuffix ${libname}${release}${shared_ext}$major $libname${shared_ext}'
2448
1799
esac
2449
1800
AC_MSG_RESULT([$dynamic_linker])
2450
1801
test "$dynamic_linker" = no && can_build_shared=no
 
1802
 
 
1803
variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
 
1804
if test "$GCC" = yes; then
 
1805
  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
 
1806
fi
2451
1807
])# AC_LIBTOOL_SYS_DYNAMIC_LINKER
2452
1808
 
2453
1809
 
2472
1828
      AC_MSG_WARN([using `LTCC=$LTCC', extracted from `$ofile'])
2473
1829
    fi
2474
1830
  fi
 
1831
  if test -z "$LTCFLAGS"; then
 
1832
    eval "`$SHELL ${ofile} --config | grep '^LTCFLAGS='`"
 
1833
  fi
2475
1834
 
2476
1835
  # Extract list of available tagged configurations in $ofile.
2477
1836
  # Note that this assumes the entire list is on one line.
2498
1857
 
2499
1858
      case $tagname in
2500
1859
      CXX)
2501
 
        if test -n "$CXX" && test "X$CXX" != "Xno"; then
 
1860
        if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
 
1861
            ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
 
1862
            (test "X$CXX" != "Xg++"))) ; then
2502
1863
          AC_LIBTOOL_LANG_CXX_CONFIG
2503
1864
        else
2504
1865
          tagname=""
2560
1921
 
2561
1922
# AC_LIBTOOL_WIN32_DLL
2562
1923
# --------------------
2563
 
# declare package support for building win32 dll's
 
1924
# declare package support for building win32 DLLs
2564
1925
AC_DEFUN([AC_LIBTOOL_WIN32_DLL],
2565
1926
[AC_BEFORE([$0], [AC_LIBTOOL_SETUP])
2566
1927
])# AC_LIBTOOL_WIN32_DLL
2598
1959
 
2599
1960
# AC_DISABLE_SHARED
2600
1961
# -----------------
2601
 
#- set the default shared flag to --disable-shared
 
1962
# set the default shared flag to --disable-shared
2602
1963
AC_DEFUN([AC_DISABLE_SHARED],
2603
1964
[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
2604
1965
AC_ENABLE_SHARED(no)
2734
2095
      if test -n "$file_magic_test_file"; then
2735
2096
        case $deplibs_check_method in
2736
2097
        "file_magic "*)
2737
 
          file_magic_regex="`expr \"$deplibs_check_method\" : \"file_magic \(.*\)\"`"
 
2098
          file_magic_regex=`expr "$deplibs_check_method" : "file_magic \(.*\)"`
2738
2099
          MAGIC_CMD="$lt_cv_path_MAGIC_CMD"
2739
2100
          if eval $file_magic_cmd \$file_magic_test_file 2> /dev/null |
2740
2101
            $EGREP "$file_magic_regex" > /dev/null; then
2844
2205
    if test -f "$ac_dir/$ac_prog" || test -f "$ac_dir/$ac_prog$ac_exeext"; then
2845
2206
      lt_cv_path_LD="$ac_dir/$ac_prog"
2846
2207
      # Check to see if the program is GNU ld.  I'd rather use --version,
2847
 
      # but apparently some GNU ld's only accept -v.
 
2208
      # but apparently some variants of GNU ld only accept -v.
2848
2209
      # Break only if it was the GNU/non-GNU ld that we prefer.
2849
2210
      case `"$lt_cv_path_LD" -v 2>&1 </dev/null` in
2850
2211
      *GNU* | *'with BFD'*)
2876
2237
AC_DEFUN([AC_PROG_LD_GNU],
2877
2238
[AC_REQUIRE([AC_PROG_EGREP])dnl
2878
2239
AC_CACHE_CHECK([if the linker ($LD) is GNU ld], lt_cv_prog_gnu_ld,
2879
 
[# I'd rather use --version here, but apparently some GNU ld's only accept -v.
 
2240
[# I'd rather use --version here, but apparently some GNU lds only accept -v.
2880
2241
case `$LD -v 2>&1 </dev/null` in
2881
2242
*GNU* | *'with BFD'*)
2882
2243
  lt_cv_prog_gnu_ld=yes
2903
2264
*) reload_flag=" $reload_flag" ;;
2904
2265
esac
2905
2266
reload_cmds='$LD$reload_flag -o $output$reload_objs'
 
2267
case $host_os in
 
2268
  darwin*)
 
2269
    if test "$GCC" = yes; then
 
2270
      reload_cmds='$LTCC $LTCFLAGS -nostdlib ${wl}-r -o $output$reload_objs'
 
2271
    else
 
2272
      reload_cmds='$LD$reload_flag -o $output$reload_objs'
 
2273
    fi
 
2274
    ;;
 
2275
esac
2906
2276
])# AC_PROG_LD_RELOAD_FLAG
2907
2277
 
2908
2278
 
2936
2306
  lt_cv_deplibs_check_method=pass_all
2937
2307
  ;;
2938
2308
 
2939
 
bsdi4*)
 
2309
bsdi[[45]]*)
2940
2310
  lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib)'
2941
2311
  lt_cv_file_magic_cmd='/usr/bin/file -L'
2942
2312
  lt_cv_file_magic_test_file=/shlib/libc.so
2943
2313
  ;;
2944
2314
 
2945
 
cygwin* | mingw* | pw32*)
2946
 
  # win32_libid is a shell function defined in ltmain.sh
 
2315
cygwin*)
 
2316
  # func_win32_libid is a shell function defined in ltmain.sh
2947
2317
  lt_cv_deplibs_check_method='file_magic ^x86 archive import|^x86 DLL'
2948
 
  lt_cv_file_magic_cmd='win32_libid'
 
2318
  lt_cv_file_magic_cmd='func_win32_libid'
 
2319
  ;;
 
2320
 
 
2321
mingw* | pw32*)
 
2322
  # Base MSYS/MinGW do not provide the 'file' command needed by
 
2323
  # func_win32_libid shell function, so use a weaker test based on 'objdump'.
 
2324
  lt_cv_deplibs_check_method='file_magic file format pei*-i386(.*architecture: i386)?'
 
2325
  lt_cv_file_magic_cmd='$OBJDUMP -f'
2949
2326
  ;;
2950
2327
 
2951
2328
darwin* | rhapsody*)
2952
 
  # this will be overwritten by pass_all, but leave it in just in case
2953
 
  lt_cv_deplibs_check_method='file_magic Mach-O dynamically linked shared library'
2954
 
  lt_cv_file_magic_cmd='/usr/bin/file -L'
2955
 
  case "$host_os" in
2956
 
  rhapsody* | darwin1.[[012]])
2957
 
    lt_cv_file_magic_test_file=`/System/Library/Frameworks/System.framework/System`
2958
 
    ;;
2959
 
  *) # Darwin 1.3 on
2960
 
    lt_cv_file_magic_test_file='/usr/lib/libSystem.dylib'
2961
 
    ;;
2962
 
  esac
2963
2329
  lt_cv_deplibs_check_method=pass_all
2964
2330
  ;;
2965
2331
 
2966
 
freebsd* | kfreebsd*-gnu)
 
2332
freebsd* | dragonfly*)
2967
2333
  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
2968
2334
    case $host_cpu in
2969
2335
    i*86 )
2970
2336
      # Not sure whether the presence of OpenBSD here was a mistake.
2971
2337
      # Let's accept both of them until this is cleared up.
2972
 
      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD)/i[[3-9]]86 (compact )?demand paged shared library'
 
2338
      lt_cv_deplibs_check_method='file_magic (FreeBSD|OpenBSD|DragonFly)/i[[3-9]]86 (compact )?demand paged shared library'
2973
2339
      lt_cv_file_magic_cmd=/usr/bin/file
2974
2340
      lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
2975
2341
      ;;
2985
2351
 
2986
2352
hpux10.20* | hpux11*)
2987
2353
  lt_cv_file_magic_cmd=/usr/bin/file
2988
 
  case "$host_cpu" in
 
2354
  case $host_cpu in
2989
2355
  ia64*)
2990
2356
    lt_cv_deplibs_check_method='file_magic (s[[0-9]][[0-9]][[0-9]]|ELF-[[0-9]][[0-9]]) shared object file - IA64'
2991
2357
    lt_cv_file_magic_test_file=/usr/lib/hpux32/libc.so
3001
2367
  esac
3002
2368
  ;;
3003
2369
 
 
2370
interix3*)
 
2371
  # PIC code is broken on Interix 3.x, that's why |\.a not |_pic\.a here
 
2372
  lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so|\.a)$'
 
2373
  ;;
 
2374
 
3004
2375
irix5* | irix6* | nonstopux*)
3005
 
  case $host_os in
3006
 
  irix5* | nonstopux*)
3007
 
    # this will be overridden with pass_all, but let us keep it just in case
3008
 
    lt_cv_deplibs_check_method="file_magic ELF 32-bit MSB dynamic lib MIPS - version 1"
3009
 
    ;;
3010
 
  *)
3011
 
    case $LD in
3012
 
    *-32|*"-32 ") libmagic=32-bit;;
3013
 
    *-n32|*"-n32 ") libmagic=N32;;
3014
 
    *-64|*"-64 ") libmagic=64-bit;;
3015
 
    *) libmagic=never-match;;
3016
 
    esac
3017
 
    # this will be overridden with pass_all, but let us keep it just in case
3018
 
    lt_cv_deplibs_check_method="file_magic ELF ${libmagic} MSB mips-[[1234]] dynamic lib MIPS - version 1"
3019
 
    ;;
 
2376
  case $LD in
 
2377
  *-32|*"-32 ") libmagic=32-bit;;
 
2378
  *-n32|*"-n32 ") libmagic=N32;;
 
2379
  *-64|*"-64 ") libmagic=64-bit;;
 
2380
  *) libmagic=never-match;;
3020
2381
  esac
3021
 
  lt_cv_file_magic_test_file=`echo /lib${libsuff}/libc.so*`
3022
2382
  lt_cv_deplibs_check_method=pass_all
3023
2383
  ;;
3024
2384
 
3025
2385
# This must be Linux ELF.
3026
 
linux*)
3027
 
  case $host_cpu in
3028
 
  alpha* | hppa* | i*86 | ia64* | m68* | mips* | powerpc* | sparc* | s390* | sh*)
3029
 
    lt_cv_deplibs_check_method=pass_all ;;
3030
 
  *)
3031
 
    # glibc up to 2.1.1 does not perform some relocations on ARM
3032
 
    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB (shared object|dynamic lib )' ;;
3033
 
  esac
3034
 
  lt_cv_file_magic_test_file=`echo /lib/libc.so* /lib/libc-*.so`
 
2386
linux* | k*bsd*-gnu)
 
2387
  lt_cv_deplibs_check_method=pass_all
3035
2388
  ;;
3036
2389
 
3037
 
netbsd*)
 
2390
netbsd* | netbsdelf*-gnu)
3038
2391
  if echo __ELF__ | $CC -E - | grep __ELF__ > /dev/null; then
3039
2392
    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
3040
2393
  else
3053
2406
  ;;
3054
2407
 
3055
2408
openbsd*)
3056
 
  lt_cv_file_magic_cmd=/usr/bin/file
3057
 
  lt_cv_file_magic_test_file=`echo /usr/lib/libc.so.*`
3058
2409
  if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
3059
 
    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[LM]]SB shared object'
 
2410
    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|\.so|_pic\.a)$'
3060
2411
  else
3061
 
    lt_cv_deplibs_check_method='file_magic OpenBSD.* shared library'
 
2412
    lt_cv_deplibs_check_method='match_pattern /lib[[^/]]+(\.so\.[[0-9]]+\.[[0-9]]+|_pic\.a)$'
3062
2413
  fi
3063
2414
  ;;
3064
2415
 
3065
2416
osf3* | osf4* | osf5*)
3066
 
  # this will be overridden with pass_all, but let us keep it just in case
3067
 
  lt_cv_deplibs_check_method='file_magic COFF format alpha shared library'
3068
 
  lt_cv_file_magic_test_file=/shlib/libc.so
3069
 
  lt_cv_deplibs_check_method=pass_all
3070
 
  ;;
3071
 
 
3072
 
sco3.2v5*)
3073
2417
  lt_cv_deplibs_check_method=pass_all
3074
2418
  ;;
3075
2419
 
3076
2420
solaris*)
3077
2421
  lt_cv_deplibs_check_method=pass_all
3078
 
  lt_cv_file_magic_test_file=/lib/libc.so
3079
2422
  ;;
3080
2423
 
3081
 
sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
 
2424
sysv4 | sysv4.3*)
3082
2425
  case $host_vendor in
3083
2426
  motorola)
3084
2427
    lt_cv_deplibs_check_method='file_magic ELF [[0-9]][[0-9]]*-bit [[ML]]SB (shared object|dynamic lib) M[[0-9]][[0-9]]* Version [[0-9]]'
3099
2442
  siemens)
3100
2443
    lt_cv_deplibs_check_method=pass_all
3101
2444
    ;;
 
2445
  pc)
 
2446
    lt_cv_deplibs_check_method=pass_all
 
2447
    ;;
3102
2448
  esac
3103
2449
  ;;
3104
2450
 
3105
 
sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7* | sysv4*uw2*)
 
2451
sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX* | sysv4*uw2*)
3106
2452
  lt_cv_deplibs_check_method=pass_all
3107
2453
  ;;
3108
2454
esac
3122
2468
  # Let the user override the test.
3123
2469
  lt_cv_path_NM="$NM"
3124
2470
else
3125
 
  lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
3126
 
  for ac_dir in $PATH /usr/ccs/bin /usr/ucb /bin; do
3127
 
    IFS="$lt_save_ifs"
3128
 
    test -z "$ac_dir" && ac_dir=.
3129
 
    tmp_nm="$ac_dir/${ac_tool_prefix}nm"
3130
 
    if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
3131
 
      # Check to see if the nm accepts a BSD-compat flag.
3132
 
      # Adding the `sed 1q' prevents false positives on HP-UX, which says:
3133
 
      #   nm: unknown option "B" ignored
3134
 
      # Tru64's nm complains that /dev/null is an invalid object file
3135
 
      case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
3136
 
      */dev/null* | *'Invalid file or object type'*)
3137
 
        lt_cv_path_NM="$tmp_nm -B"
3138
 
        break
3139
 
        ;;
3140
 
      *)
3141
 
        case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
3142
 
        */dev/null*)
3143
 
          lt_cv_path_NM="$tmp_nm -p"
 
2471
  lt_nm_to_check="${ac_tool_prefix}nm"
 
2472
  if test -n "$ac_tool_prefix" && test "$build" = "$host"; then 
 
2473
    lt_nm_to_check="$lt_nm_to_check nm"
 
2474
  fi
 
2475
  for lt_tmp_nm in $lt_nm_to_check; do
 
2476
    lt_save_ifs="$IFS"; IFS=$PATH_SEPARATOR
 
2477
    for ac_dir in $PATH /usr/ccs/bin/elf /usr/ccs/bin /usr/ucb /bin; do
 
2478
      IFS="$lt_save_ifs"
 
2479
      test -z "$ac_dir" && ac_dir=.
 
2480
      tmp_nm="$ac_dir/$lt_tmp_nm"
 
2481
      if test -f "$tmp_nm" || test -f "$tmp_nm$ac_exeext" ; then
 
2482
        # Check to see if the nm accepts a BSD-compat flag.
 
2483
        # Adding the `sed 1q' prevents false positives on HP-UX, which says:
 
2484
        #   nm: unknown option "B" ignored
 
2485
        # Tru64's nm complains that /dev/null is an invalid object file
 
2486
        case `"$tmp_nm" -B /dev/null 2>&1 | sed '1q'` in
 
2487
        */dev/null* | *'Invalid file or object type'*)
 
2488
          lt_cv_path_NM="$tmp_nm -B"
3144
2489
          break
3145
2490
          ;;
3146
2491
        *)
3147
 
          lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
3148
 
          continue # so that we can try to find one that supports BSD flags
 
2492
          case `"$tmp_nm" -p /dev/null 2>&1 | sed '1q'` in
 
2493
          */dev/null*)
 
2494
            lt_cv_path_NM="$tmp_nm -p"
 
2495
            break
 
2496
            ;;
 
2497
          *)
 
2498
            lt_cv_path_NM=${lt_cv_path_NM="$tmp_nm"} # keep the first match, but
 
2499
            continue # so that we can try to find one that supports BSD flags
 
2500
            ;;
 
2501
          esac
3149
2502
          ;;
3150
2503
        esac
3151
 
      esac
3152
 
    fi
 
2504
      fi
 
2505
    done
 
2506
    IFS="$lt_save_ifs"
3153
2507
  done
3154
 
  IFS="$lt_save_ifs"
3155
2508
  test -z "$lt_cv_path_NM" && lt_cv_path_NM=nm
3156
2509
fi])
3157
2510
NM="$lt_cv_path_NM"
3183
2536
# -----------------------------------
3184
2537
# sets LIBLTDL to the link flags for the libltdl convenience library and
3185
2538
# LTDLINCL to the include flags for the libltdl header and adds
3186
 
# --enable-ltdl-convenience to the configure arguments.  Note that LIBLTDL
3187
 
# and LTDLINCL are not AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called.  If
3188
 
# DIRECTORY is not provided, it is assumed to be `libltdl'.  LIBLTDL will
3189
 
# be prefixed with '${top_builddir}/' and LTDLINCL will be prefixed with
3190
 
# '${top_srcdir}/' (note the single quotes!).  If your package is not
3191
 
# flat and you're not using automake, define top_builddir and
3192
 
# top_srcdir appropriately in the Makefiles.
 
2539
# --enable-ltdl-convenience to the configure arguments.  Note that
 
2540
# AC_CONFIG_SUBDIRS is not called here.  If DIRECTORY is not provided,
 
2541
# it is assumed to be `libltdl'.  LIBLTDL will be prefixed with
 
2542
# '${top_builddir}/' and LTDLINCL will be prefixed with '${top_srcdir}/'
 
2543
# (note the single quotes!).  If your package is not flat and you're not
 
2544
# using automake, define top_builddir and top_srcdir appropriately in
 
2545
# the Makefiles.
3193
2546
AC_DEFUN([AC_LIBLTDL_CONVENIENCE],
3194
2547
[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
3195
2548
  case $enable_ltdl_convenience in
3208
2561
# -----------------------------------
3209
2562
# sets LIBLTDL to the link flags for the libltdl installable library and
3210
2563
# LTDLINCL to the include flags for the libltdl header and adds
3211
 
# --enable-ltdl-install to the configure arguments.  Note that LIBLTDL
3212
 
# and LTDLINCL are not AC_SUBSTed, nor is AC_CONFIG_SUBDIRS called.  If
3213
 
# DIRECTORY is not provided and an installed libltdl is not found, it is
3214
 
# assumed to be `libltdl'.  LIBLTDL will be prefixed with '${top_builddir}/'
3215
 
# and LTDLINCL will be prefixed with '${top_srcdir}/' (note the single
3216
 
# quotes!).  If your package is not flat and you're not using automake,
3217
 
# define top_builddir and top_srcdir appropriately in the Makefiles.
 
2564
# --enable-ltdl-install to the configure arguments.  Note that
 
2565
# AC_CONFIG_SUBDIRS is not called here.  If DIRECTORY is not provided,
 
2566
# and an installed libltdl is not found, it is assumed to be `libltdl'.
 
2567
# LIBLTDL will be prefixed with '${top_builddir}/'# and LTDLINCL with
 
2568
# '${top_srcdir}/' (note the single quotes!).  If your package is not
 
2569
# flat and you're not using automake, define top_builddir and top_srcdir
 
2570
# appropriately in the Makefiles.
3218
2571
# In the future, this macro may have to be called after AC_PROG_LIBTOOL.
3219
2572
AC_DEFUN([AC_LIBLTDL_INSTALLABLE],
3220
2573
[AC_BEFORE([$0],[AC_LIBTOOL_SETUP])dnl
3252
2605
# ---------------
3253
2606
AC_DEFUN([_LT_AC_LANG_CXX],
3254
2607
[AC_REQUIRE([AC_PROG_CXX])
3255
 
AC_REQUIRE([AC_PROG_CXXCPP])
 
2608
AC_REQUIRE([_LT_AC_PROG_CXXCPP])
3256
2609
_LT_AC_SHELL_INIT([tagnames=${tagnames+${tagnames},}CXX])
3257
2610
])# _LT_AC_LANG_CXX
3258
2611
 
 
2612
# _LT_AC_PROG_CXXCPP
 
2613
# ------------------
 
2614
AC_DEFUN([_LT_AC_PROG_CXXCPP],
 
2615
[
 
2616
AC_REQUIRE([AC_PROG_CXX])
 
2617
if test -n "$CXX" && ( test "X$CXX" != "Xno" &&
 
2618
    ( (test "X$CXX" = "Xg++" && `g++ -v >/dev/null 2>&1` ) ||
 
2619
    (test "X$CXX" != "Xg++"))) ; then
 
2620
  AC_PROG_CXXCPP
 
2621
fi
 
2622
])# _LT_AC_PROG_CXXCPP
3259
2623
 
3260
2624
# AC_LIBTOOL_F77
3261
2625
# --------------
3295
2659
 
3296
2660
 
3297
2661
# AC_LIBTOOL_RC
3298
 
# --------------
 
2662
# -------------
3299
2663
# enable support for Windows resource files
3300
2664
AC_DEFUN([AC_LIBTOOL_RC],
3301
2665
[AC_REQUIRE([LT_AC_PROG_RC])
3328
2692
 
3329
2693
_LT_AC_SYS_COMPILER
3330
2694
 
3331
 
#
3332
 
# Check for any special shared library compilation flags.
3333
 
#
3334
 
_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)=
3335
 
if test "$GCC" = no; then
3336
 
  case $host_os in
3337
 
  sco3.2v5*)
3338
 
    _LT_AC_TAGVAR(lt_prog_cc_shlib, $1)='-belf'
3339
 
    ;;
3340
 
  esac
3341
 
fi
3342
 
if test -n "$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)"; then
3343
 
  AC_MSG_WARN([`$CC' requires `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to build shared libraries])
3344
 
  if echo "$old_CC $old_CFLAGS " | grep "[[     ]]$]_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)[[[      ]]" >/dev/null; then :
3345
 
  else
3346
 
    AC_MSG_WARN([add `$_LT_AC_TAGVAR(lt_prog_cc_shlib, $1)' to the CC or CFLAGS env variable and reconfigure])
3347
 
    _LT_AC_TAGVAR(lt_cv_prog_cc_can_build_shared, $1)=no
3348
 
  fi
3349
 
fi
3350
 
 
3351
 
 
3352
 
#
3353
 
# Check to make sure the static flag actually works.
3354
 
#
3355
 
AC_LIBTOOL_LINKER_OPTION([if $compiler static flag $_LT_AC_TAGVAR(lt_prog_compiler_static, $1) works],
3356
 
  _LT_AC_TAGVAR(lt_prog_compiler_static_works, $1),
3357
 
  $_LT_AC_TAGVAR(lt_prog_compiler_static, $1),
3358
 
  [],
3359
 
  [_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=])
3360
 
 
 
2695
# save warnings/boilerplate of simple test code
 
2696
_LT_COMPILER_BOILERPLATE
 
2697
_LT_LINKER_BOILERPLATE
3361
2698
 
3362
2699
AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)
3363
2700
AC_LIBTOOL_PROG_COMPILER_PIC($1)
3367
2704
AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
3368
2705
AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
3369
2706
AC_LIBTOOL_SYS_LIB_STRIP
3370
 
AC_LIBTOOL_DLOPEN_SELF($1)
 
2707
AC_LIBTOOL_DLOPEN_SELF
3371
2708
 
3372
 
# Report which librarie types wil actually be built
 
2709
# Report which library types will actually be built
3373
2710
AC_MSG_CHECKING([if libtool supports shared libraries])
3374
2711
AC_MSG_RESULT([$can_build_shared])
3375
2712
 
3378
2715
 
3379
2716
# On AIX, shared libraries and static libraries use the same namespace, and
3380
2717
# are all built from PIC.
3381
 
case "$host_os" in
 
2718
case $host_os in
3382
2719
aix3*)
3383
2720
  test "$enable_shared" = yes && enable_static=no
3384
2721
  if test -n "$RANLIB"; then
3387
2724
  fi
3388
2725
  ;;
3389
2726
 
3390
 
aix4*)
 
2727
aix4* | aix5*)
3391
2728
  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
3392
2729
    test "$enable_shared" = yes && enable_static=no
3393
2730
  fi
3394
 
  ;;
3395
 
  darwin* | rhapsody*)
3396
 
  if test "$GCC" = yes; then
3397
 
    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
3398
 
    case "$host_os" in
3399
 
    rhapsody* | darwin1.[[012]])
3400
 
      _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined suppress'
3401
 
      ;;
3402
 
    *) # Darwin 1.3 on
3403
 
      if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
3404
 
        _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress'
3405
 
      else
3406
 
        case ${MACOSX_DEPLOYMENT_TARGET} in
3407
 
          10.[[012]])
3408
 
            _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress'
3409
 
            ;;
3410
 
          10.*)
3411
 
            _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined dynamic_lookup'
3412
 
            ;;            
3413
 
        esac
3414
 
      fi
3415
 
      ;;
3416
 
    esac
3417
 
    output_verbose_link_cmd='echo'
3418
 
    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs$compiler_flags -install_name $rpath/$soname $verstring'
3419
 
    _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
3420
 
    # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's
3421
 
    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag  -o $lib $libobjs $deplibs$compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
3422
 
    _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
3423
 
    _LT_AC_TAGVAR(hardcode_direct, $1)=no
3424
 
    _LT_AC_TAGVAR(hardcode_automatic, $1)=yes
3425
 
    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
3426
 
    _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-all_load $convenience'
3427
 
    _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
3428
 
  else
3429
 
    _LT_AC_TAGVAR(ld_shlibs, $1)=no
3430
 
  fi  
3431
 
    ;;  
 
2731
    ;;
3432
2732
esac
3433
2733
AC_MSG_RESULT([$enable_shared])
3434
2734
 
3453
2753
AC_DEFUN([_LT_AC_LANG_CXX_CONFIG],
3454
2754
[AC_LANG_PUSH(C++)
3455
2755
AC_REQUIRE([AC_PROG_CXX])
3456
 
AC_REQUIRE([AC_PROG_CXXCPP])
 
2756
AC_REQUIRE([_LT_AC_PROG_CXXCPP])
3457
2757
 
3458
2758
_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
3459
2759
_LT_AC_TAGVAR(allow_undefined_flag, $1)=
3465
2765
_LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)=
3466
2766
_LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
3467
2767
_LT_AC_TAGVAR(hardcode_minus_L, $1)=no
 
2768
_LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
3468
2769
_LT_AC_TAGVAR(hardcode_automatic, $1)=no
3469
2770
_LT_AC_TAGVAR(module_cmds, $1)=
3470
2771
_LT_AC_TAGVAR(module_expsym_cmds, $1)=
3482
2783
_LT_AC_TAGVAR(compiler_lib_search_path, $1)=
3483
2784
 
3484
2785
# Source file extension for C++ test sources.
3485
 
ac_ext=cc
 
2786
ac_ext=cpp
3486
2787
 
3487
2788
# Object file extension for compiled C++ test sources.
3488
2789
objext=o
3492
2793
lt_simple_compile_test_code="int some_variable = 0;\n"
3493
2794
 
3494
2795
# Code to be used in simple link tests
3495
 
lt_simple_link_test_code='int main(int, char *[]) { return(0); }\n'
 
2796
lt_simple_link_test_code='int main(int, char *[[]]) { return(0); }\n'
3496
2797
 
3497
2798
# ltmain only uses $CC for tagged configurations so make sure $CC is set.
3498
2799
_LT_AC_SYS_COMPILER
3499
2800
 
 
2801
# save warnings/boilerplate of simple test code
 
2802
_LT_COMPILER_BOILERPLATE
 
2803
_LT_LINKER_BOILERPLATE
 
2804
 
3500
2805
# Allow CC to be a program name with arguments.
3501
2806
lt_save_CC=$CC
3502
2807
lt_save_LD=$LD
3507
2812
if test -n "${lt_cv_prog_gnu_ldcxx+set}"; then
3508
2813
  lt_cv_prog_gnu_ld=$lt_cv_prog_gnu_ldcxx
3509
2814
else
3510
 
  unset lt_cv_prog_gnu_ld
 
2815
  $as_unset lt_cv_prog_gnu_ld
3511
2816
fi
3512
2817
if test -n "${lt_cv_path_LDCXX+set}"; then
3513
2818
  lt_cv_path_LD=$lt_cv_path_LDCXX
3514
2819
else
3515
 
  unset lt_cv_path_LD
 
2820
  $as_unset lt_cv_path_LD
3516
2821
fi
3517
2822
test -z "${LDCXX+set}" || LD=$LDCXX
3518
2823
CC=${CXX-"c++"}
3519
2824
compiler=$CC
3520
2825
_LT_AC_TAGVAR(compiler, $1)=$CC
3521
 
cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'`
 
2826
_LT_CC_BASENAME([$compiler])
3522
2827
 
3523
2828
# We don't want -fno-exception wen compiling C++ code, so set the
3524
2829
# no_builtin_flag separately
3607
2912
            ;;
3608
2913
          esac
3609
2914
        done
 
2915
        ;;
3610
2916
      esac
3611
2917
 
3612
2918
      exp_sym_flag='-bexport'
3625
2931
    _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
3626
2932
 
3627
2933
    if test "$GXX" = yes; then
3628
 
      case $host_os in aix4.[012]|aix4.[012].*)
 
2934
      case $host_os in aix4.[[012]]|aix4.[[012]].*)
3629
2935
      # We only want to do this on AIX 4.2 and lower, the check
3630
2936
      # below for broken collect2 doesn't work under 4.3+
3631
2937
        collect2name=`${CC} -print-prog-name=collect2`
3644
2950
          _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
3645
2951
          _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
3646
2952
        fi
 
2953
        ;;
3647
2954
      esac
3648
2955
      shared_flag='-shared'
 
2956
      if test "$aix_use_runtimelinking" = yes; then
 
2957
        shared_flag="$shared_flag "'${wl}-G'
 
2958
      fi
3649
2959
    else
3650
2960
      # not using gcc
3651
2961
      if test "$host_cpu" = ia64; then
3672
2982
      _LT_AC_SYS_LIBPATH_AIX
3673
2983
      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
3674
2984
 
3675
 
      _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag"
 
2985
      _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
3676
2986
     else
3677
2987
      if test "$host_cpu" = ia64; then
3678
2988
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
3679
2989
        _LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
3680
 
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
 
2990
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
3681
2991
      else
3682
2992
        # Determine the default libpath from the value encoded in an empty executable.
3683
2993
        _LT_AC_SYS_LIBPATH_AIX
3686
2996
        # -berok will link without error, but may produce a broken library.
3687
2997
        _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
3688
2998
        _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
3689
 
        # -bexpall does not export symbols beginning with underscore (_)
3690
 
        _LT_AC_TAGVAR(always_export_symbols, $1)=yes
3691
2999
        # Exported symbols can be pulled into shared objects from archives
3692
 
        _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=' '
 
3000
        _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
3693
3001
        _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
3694
 
        # This is similar to how AIX traditionally builds it's shared libraries.
3695
 
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
 
3002
        # This is similar to how AIX traditionally builds its shared libraries.
 
3003
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
3696
3004
      fi
3697
3005
    fi
3698
3006
    ;;
 
3007
 
 
3008
  beos*)
 
3009
    if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
 
3010
      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
 
3011
      # Joseph Beckenbach <jrb3@best.com> says some releases of gcc
 
3012
      # support --undefined.  This deserves some investigation.  FIXME
 
3013
      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -nostart $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
 
3014
    else
 
3015
      _LT_AC_TAGVAR(ld_shlibs, $1)=no
 
3016
    fi
 
3017
    ;;
 
3018
 
3699
3019
  chorus*)
3700
3020
    case $cc_basename in
3701
3021
      *)
3714
3034
    _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
3715
3035
 
3716
3036
    if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
3717
 
      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'
 
3037
      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
3718
3038
      # If the export-symbols file already is a .def file (1st line
3719
3039
      # is EXPORTS), use it as is; otherwise, prepend...
3720
3040
      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
3723
3043
        echo EXPORTS > $output_objdir/$soname.def;
3724
3044
        cat $export_symbols >> $output_objdir/$soname.def;
3725
3045
      fi~
3726
 
      $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'
 
3046
      $CC -shared -nostdlib $output_objdir/$soname.def $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
3727
3047
    else
3728
3048
      _LT_AC_TAGVAR(ld_shlibs, $1)=no
3729
3049
    fi
3730
3050
  ;;
3731
 
 
3732
 
  darwin* | rhapsody*)
3733
 
  if test "$GXX" = yes; then
3734
 
    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
3735
 
    case "$host_os" in
3736
 
    rhapsody* | darwin1.[[012]])
3737
 
      _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined suppress'
3738
 
      ;;
3739
 
    *) # Darwin 1.3 on
3740
 
      if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
3741
 
        _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress'
3742
 
      else
3743
 
        case ${MACOSX_DEPLOYMENT_TARGET} in
3744
 
          10.[[012]])
3745
 
            _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress'
3746
 
            ;;
3747
 
          10.*)
3748
 
            _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined dynamic_lookup'
3749
 
            ;;            
 
3051
      darwin* | rhapsody*)
 
3052
        case $host_os in
 
3053
        rhapsody* | darwin1.[[012]])
 
3054
         _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}suppress'
 
3055
         ;;
 
3056
       *) # Darwin 1.3 on
 
3057
         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
 
3058
           _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
 
3059
         else
 
3060
           case ${MACOSX_DEPLOYMENT_TARGET} in
 
3061
             10.[[012]])
 
3062
               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
 
3063
               ;;
 
3064
             10.*)
 
3065
               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}dynamic_lookup'
 
3066
               ;;
 
3067
           esac
 
3068
         fi
 
3069
         ;;
3750
3070
        esac
3751
 
      fi
3752
 
      ;;
3753
 
    esac
3754
 
    lt_int_apple_cc_single_mod=no
3755
 
    output_verbose_link_cmd='echo'
3756
 
    if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then
3757
 
      lt_int_apple_cc_single_mod=yes
3758
 
    fi
3759
 
    if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
3760
 
      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
3761
 
    else
3762
 
      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
3763
 
    fi
3764
 
    _LT_AC_TAGVAR(module_cmds, $1)='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
 
3071
      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
 
3072
      _LT_AC_TAGVAR(hardcode_direct, $1)=no
 
3073
      _LT_AC_TAGVAR(hardcode_automatic, $1)=yes
 
3074
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
 
3075
      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=''
 
3076
      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
3765
3077
 
3766
 
    # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's
3767
 
    if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
3768
 
      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
3769
 
    else
3770
 
      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
3771
 
    fi
3772
 
    _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
3773
 
    _LT_AC_TAGVAR(hardcode_direct, $1)=no
3774
 
    _LT_AC_TAGVAR(hardcode_automatic, $1)=yes
3775
 
    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
3776
 
    _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-all_load $convenience'
3777
 
    _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
3778
 
  else
3779
 
    _LT_AC_TAGVAR(ld_shlibs, $1)=no
3780
 
  fi
3781
 
    ;;
 
3078
    if test "$GXX" = yes ; then
 
3079
      lt_int_apple_cc_single_mod=no
 
3080
      output_verbose_link_cmd='echo'
 
3081
      if $CC -dumpspecs 2>&1 | $EGREP 'single_module' >/dev/null ; then
 
3082
       lt_int_apple_cc_single_mod=yes
 
3083
      fi
 
3084
      if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
 
3085
       _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
 
3086
      else
 
3087
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
 
3088
        fi
 
3089
        _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
 
3090
        # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
 
3091
          if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
 
3092
            _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
3093
          else
 
3094
            _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
3095
          fi
 
3096
            _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
3097
      else
 
3098
      case $cc_basename in
 
3099
        xlc*)
 
3100
         output_verbose_link_cmd='echo'
 
3101
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
 
3102
          _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
 
3103
          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
 
3104
          _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj ${wl}-single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
3105
          _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
3106
          ;;
 
3107
       *)
 
3108
         _LT_AC_TAGVAR(ld_shlibs, $1)=no
 
3109
          ;;
 
3110
      esac
 
3111
      fi
 
3112
        ;;
3782
3113
 
3783
3114
  dgux*)
3784
3115
    case $cc_basename in
3785
 
      ec++)
 
3116
      ec++*)
3786
3117
        # FIXME: insert proper C++ library support
3787
3118
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
3788
3119
        ;;
3789
 
      ghcx)
 
3120
      ghcx*)
3790
3121
        # Green Hills C++ Compiler
3791
3122
        # FIXME: insert proper C++ library support
3792
3123
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
3797
3128
        ;;
3798
3129
    esac
3799
3130
    ;;
3800
 
  freebsd[12]*)
 
3131
  freebsd[[12]]*)
3801
3132
    # C++ shared libraries reported to be fairly broken before switch to ELF
3802
3133
    _LT_AC_TAGVAR(ld_shlibs, $1)=no
3803
3134
    ;;
3804
3135
  freebsd-elf*)
3805
3136
    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
3806
3137
    ;;
3807
 
  freebsd* | kfreebsd*-gnu)
 
3138
  freebsd* | dragonfly*)
3808
3139
    # FreeBSD 3 and later use GNU C++ and GNU ld with standard ELF
3809
3140
    # conventions
3810
3141
    _LT_AC_TAGVAR(ld_shlibs, $1)=yes
3821
3152
                                # location of the library.
3822
3153
 
3823
3154
    case $cc_basename in
3824
 
    CC)
 
3155
    CC*)
3825
3156
      # FIXME: insert proper C++ library support
3826
3157
      _LT_AC_TAGVAR(ld_shlibs, $1)=no
3827
3158
      ;;
3828
 
    aCC)
 
3159
    aCC*)
3829
3160
      _LT_AC_TAGVAR(archive_cmds, $1)='$rm $output_objdir/$soname~$CC -b ${wl}+b ${wl}$install_libdir -o $output_objdir/$soname $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~test $output_objdir/$soname = $lib || mv $output_objdir/$soname $lib'
3830
3161
      # Commands to make compiler produce verbose output that lists
3831
3162
      # what "hidden" libraries, object files and flags are used when
3835
3166
      # explicitly linking system object files so we need to strip them
3836
3167
      # from the output so that they don't get included in the library
3837
3168
      # dependencies.
3838
 
      output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | egrep "\-L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
 
3169
      output_verbose_link_cmd='templist=`($CC -b $CFLAGS -v conftest.$objext 2>&1) | grep "[[-]]L"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
3839
3170
      ;;
3840
3171
    *)
3841
3172
      if test "$GXX" = yes; then
3849
3180
    ;;
3850
3181
  hpux10*|hpux11*)
3851
3182
    if test $with_gnu_ld = no; then
3852
 
      case "$host_cpu" in
3853
 
      hppa*64*)
3854
 
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
 
3183
      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
 
3184
      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
 
3185
 
 
3186
      case $host_cpu in
 
3187
      hppa*64*|ia64*)
3855
3188
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'
3856
 
        _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
3857
 
        ;;
3858
 
      ia64*)
3859
 
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
3860
3189
        ;;
3861
3190
      *)
3862
 
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
3863
 
        _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
3864
3191
        _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
3865
3192
        ;;
3866
3193
      esac
3867
3194
    fi
3868
 
    case "$host_cpu" in
3869
 
    hppa*64*)
3870
 
      _LT_AC_TAGVAR(hardcode_direct, $1)=no
3871
 
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
3872
 
      ;;
3873
 
    ia64*)
3874
 
      _LT_AC_TAGVAR(hardcode_direct, $1)=no
3875
 
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
3876
 
      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes # Not in the search PATH,
3877
 
                                              # but as the default
3878
 
                                              # location of the library.
 
3195
    case $host_cpu in
 
3196
    hppa*64*|ia64*)
 
3197
      _LT_AC_TAGVAR(hardcode_direct, $1)=no
 
3198
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
3879
3199
      ;;
3880
3200
    *)
3881
3201
      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
3886
3206
    esac
3887
3207
 
3888
3208
    case $cc_basename in
3889
 
      CC)
 
3209
      CC*)
3890
3210
        # FIXME: insert proper C++ library support
3891
3211
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
3892
3212
        ;;
3893
 
      aCC)
3894
 
        case "$host_cpu" in
3895
 
        hppa*64*|ia64*)
3896
 
          _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs'
 
3213
      aCC*)
 
3214
        case $host_cpu in
 
3215
        hppa*64*)
 
3216
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 
3217
          ;;
 
3218
        ia64*)
 
3219
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
3897
3220
          ;;
3898
3221
        *)
3899
3222
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
3912
3235
      *)
3913
3236
        if test "$GXX" = yes; then
3914
3237
          if test $with_gnu_ld = no; then
3915
 
            case "$host_cpu" in
3916
 
            ia64*|hppa*64*)
3917
 
              _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $linker_flags $libobjs $deplibs'
 
3238
            case $host_cpu in
 
3239
            hppa*64*)
 
3240
              _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 
3241
              ;;
 
3242
            ia64*)
 
3243
              _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
3918
3244
              ;;
3919
3245
            *)
3920
3246
              _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
3928
3254
        ;;
3929
3255
    esac
3930
3256
    ;;
 
3257
  interix3*)
 
3258
    _LT_AC_TAGVAR(hardcode_direct, $1)=no
 
3259
    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
 
3260
    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
 
3261
    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
 
3262
    # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
 
3263
    # Instead, shared libraries are loaded at an image base (0x10000000 by
 
3264
    # default) and relocated if they conflict, which is a slow very memory
 
3265
    # consuming and fragmenting process.  To avoid this, we pick a random,
 
3266
    # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
 
3267
    # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
 
3268
    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
 
3269
    _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
 
3270
    ;;
3931
3271
  irix5* | irix6*)
3932
3272
    case $cc_basename in
3933
 
      CC)
 
3273
      CC*)
3934
3274
        # SGI C++
3935
 
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
 
3275
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -all -multigot $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
3936
3276
 
3937
3277
        # Archives containing C++ object files must be created using
3938
3278
        # "CC -ar", where "CC" is the IRIX C++ compiler.  This is
3943
3283
      *)
3944
3284
        if test "$GXX" = yes; then
3945
3285
          if test "$with_gnu_ld" = no; then
3946
 
            _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
 
3286
            _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
3947
3287
          else
3948
3288
            _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` -o $lib'
3949
3289
          fi
3954
3294
    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
3955
3295
    _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
3956
3296
    ;;
3957
 
  linux*)
 
3297
  linux* | k*bsd*-gnu)
3958
3298
    case $cc_basename in
3959
 
      KCC)
 
3299
      KCC*)
3960
3300
        # Kuck and Associates, Inc. (KAI) C++ Compiler
3961
3301
 
3962
3302
        # KCC will only create a shared library if the output file
3981
3321
        # "CC -Bstatic", where "CC" is the KAI C++ compiler.
3982
3322
        _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
3983
3323
        ;;
3984
 
      icpc)
 
3324
      icpc*)
3985
3325
        # Intel C++
3986
3326
        with_gnu_ld=yes
 
3327
        # version 8.0 and above of icpc choke on multiply defined symbols
 
3328
        # if we add $predep_objects and $postdep_objects, however 7.1 and
 
3329
        # earlier do not add the objects themselves.
 
3330
        case `$CC -V 2>&1` in
 
3331
        *"Version 7."*)
 
3332
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
 
3333
          _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
 
3334
          ;;
 
3335
        *)  # Version 8.0 or newer
 
3336
          tmp_idyn=
 
3337
          case $host_cpu in
 
3338
            ia64*) tmp_idyn=' -i_dynamic';;
 
3339
          esac
 
3340
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
 
3341
          _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared'"$tmp_idyn"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
 
3342
          ;;
 
3343
        esac
3987
3344
        _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
3988
 
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
3989
 
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname ${wl}-retain-symbols-file $wl$export_symbols -o $lib'
3990
3345
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
3991
3346
        _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
3992
3347
        _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive$convenience ${wl}--no-whole-archive'
3993
3348
        ;;
3994
 
      cxx)
 
3349
      pgCC*)
 
3350
        # Portland Group C++ compiler
 
3351
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname -o $lib'
 
3352
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname ${wl}-retain-symbols-file ${wl}$export_symbols -o $lib'
 
3353
 
 
3354
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
 
3355
        _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
 
3356
        _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
 
3357
        ;;
 
3358
      cxx*)
3995
3359
        # Compaq C++
3996
3360
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname -o $lib'
3997
3361
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $wl$soname  -o $lib ${wl}-retain-symbols-file $wl$export_symbols'
4022
3386
    ;;
4023
3387
  mvs*)
4024
3388
    case $cc_basename in
4025
 
      cxx)
 
3389
      cxx*)
4026
3390
        # FIXME: insert proper C++ library support
4027
3391
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
4028
3392
        ;;
4032
3396
        ;;
4033
3397
    esac
4034
3398
    ;;
4035
 
  netbsd*)
 
3399
  netbsd* | netbsdelf*-gnu)
4036
3400
    if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
4037
3401
      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable  -o $lib $predep_objects $libobjs $deplibs $postdep_objects $linker_flags'
4038
3402
      wlarc=
4043
3407
    # Workaround some broken pre-1.5 toolchains
4044
3408
    output_verbose_link_cmd='$CC -shared $CFLAGS -v conftest.$objext 2>&1 | grep conftest.$objext | $SED -e "s:-lgcc -lc -lgcc::"'
4045
3409
    ;;
 
3410
  openbsd2*)
 
3411
    # C++ shared libraries are fairly broken
 
3412
    _LT_AC_TAGVAR(ld_shlibs, $1)=no
 
3413
    ;;
 
3414
  openbsd*)
 
3415
    _LT_AC_TAGVAR(hardcode_direct, $1)=yes
 
3416
    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
 
3417
    _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -o $lib'
 
3418
    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
 
3419
    if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
 
3420
      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-retain-symbols-file,$export_symbols -o $lib'
 
3421
      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
 
3422
      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
 
3423
    fi
 
3424
    output_verbose_link_cmd='echo'
 
3425
    ;;
4046
3426
  osf3*)
4047
3427
    case $cc_basename in
4048
 
      KCC)
 
3428
      KCC*)
4049
3429
        # Kuck and Associates, Inc. (KAI) C++ Compiler
4050
3430
 
4051
3431
        # KCC will only create a shared library if the output file
4061
3441
        _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -Bstatic -o $oldlib $oldobjs'
4062
3442
 
4063
3443
        ;;
4064
 
      RCC)
 
3444
      RCC*)
4065
3445
        # Rational C++ 2.4.1
4066
3446
        # FIXME: insert proper C++ library support
4067
3447
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
4068
3448
        ;;
4069
 
      cxx)
 
3449
      cxx*)
4070
3450
        _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
4071
 
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
 
3451
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname $soname `test -n "$verstring" && echo ${wl}-set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
4072
3452
 
4073
3453
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
4074
3454
        _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
4086
3466
      *)
4087
3467
        if test "$GXX" = yes && test "$with_gnu_ld" = no; then
4088
3468
          _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
4089
 
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
 
3469
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
4090
3470
 
4091
3471
          _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
4092
3472
          _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
4105
3485
    ;;
4106
3486
  osf4* | osf5*)
4107
3487
    case $cc_basename in
4108
 
      KCC)
 
3488
      KCC*)
4109
3489
        # Kuck and Associates, Inc. (KAI) C++ Compiler
4110
3490
 
4111
3491
        # KCC will only create a shared library if the output file
4120
3500
        # the KAI C++ compiler.
4121
3501
        _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -o $oldlib $oldobjs'
4122
3502
        ;;
4123
 
      RCC)
 
3503
      RCC*)
4124
3504
        # Rational C++ 2.4.1
4125
3505
        # FIXME: insert proper C++ library support
4126
3506
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
4127
3507
        ;;
4128
 
      cxx)
 
3508
      cxx*)
4129
3509
        _LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
4130
 
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib'
 
3510
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
4131
3511
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done~
4132
3512
          echo "-hidden">> $lib.exp~
4133
 
          $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp  `test -n "$verstring" && echo -set_version $verstring` -update_registry $objdir/so_locations -o $lib~
 
3513
          $CC -shared$allow_undefined_flag $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags -msym -soname $soname -Wl,-input -Wl,$lib.exp  `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib~
4134
3514
          $rm $lib.exp'
4135
3515
 
4136
3516
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
4149
3529
      *)
4150
3530
        if test "$GXX" = yes && test "$with_gnu_ld" = no; then
4151
3531
          _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-expect_unresolved ${wl}\*'
4152
 
         _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${objdir}/so_locations -o $lib'
 
3532
         _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -nostdlib ${allow_undefined_flag} $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-msym ${wl}-soname ${wl}$soname `test -n "$verstring" && echo ${wl}-set_version ${wl}$verstring` ${wl}-update_registry ${wl}${output_objdir}/so_locations -o $lib'
4153
3533
 
4154
3534
          _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath ${wl}$libdir'
4155
3535
          _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
4170
3550
    # FIXME: insert proper C++ library support
4171
3551
    _LT_AC_TAGVAR(ld_shlibs, $1)=no
4172
3552
    ;;
4173
 
  sco*)
4174
 
    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
4175
 
    case $cc_basename in
4176
 
      CC)
4177
 
        # FIXME: insert proper C++ library support
4178
 
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
4179
 
        ;;
4180
 
      *)
4181
 
        # FIXME: insert proper C++ library support
4182
 
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
4183
 
        ;;
4184
 
    esac
4185
 
    ;;
4186
3553
  sunos4*)
4187
3554
    case $cc_basename in
4188
 
      CC)
 
3555
      CC*)
4189
3556
        # Sun C++ 4.x
4190
3557
        # FIXME: insert proper C++ library support
4191
3558
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
4192
3559
        ;;
4193
 
      lcc)
 
3560
      lcc*)
4194
3561
        # Lucid
4195
3562
        # FIXME: insert proper C++ library support
4196
3563
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
4203
3570
    ;;
4204
3571
  solaris*)
4205
3572
    case $cc_basename in
4206
 
      CC)
 
3573
      CC*)
4207
3574
        # Sun C++ 4.2, 5.x and Centerline C++
 
3575
        _LT_AC_TAGVAR(archive_cmds_need_lc,$1)=yes
4208
3576
        _LT_AC_TAGVAR(no_undefined_flag, $1)=' -zdefs'
4209
 
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag} -nolib -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
 
3577
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G${allow_undefined_flag}  -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags'
4210
3578
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
4211
 
        $CC -G${allow_undefined_flag} -nolib ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
 
3579
        $CC -G${allow_undefined_flag}  ${wl}-M ${wl}$lib.exp -h$soname -o $lib $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags~$rm $lib.exp'
4212
3580
 
4213
3581
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
4214
3582
        _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
4215
3583
        case $host_os in
4216
 
          solaris2.[0-5] | solaris2.[0-5].*) ;;
 
3584
          solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
4217
3585
          *)
4218
3586
            # The C++ compiler is used as linker so we must use $wl
4219
3587
            # flag to pass the commands to the underlying system
4220
 
            # linker.
 
3588
            # linker. We must also pass each convience library through
 
3589
            # to the system linker between allextract/defaultextract.
 
3590
            # The C++ compiler will combine linker options so we
 
3591
            # cannot just pass the convience library names through
 
3592
            # without $wl.
4221
3593
            # Supported since Solaris 2.6 (maybe 2.5.1?)
4222
 
            _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract$convenience ${wl}-z ${wl}defaultextract'
 
3594
            _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract'
4223
3595
            ;;
4224
3596
        esac
4225
3597
        _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
4226
3598
 
4227
 
        # Commands to make compiler produce verbose output that lists
4228
 
        # what "hidden" libraries, object files and flags are used when
4229
 
        # linking a shared library.
4230
 
        #
4231
 
        # There doesn't appear to be a way to prevent this compiler from
4232
 
        # explicitly linking system object files so we need to strip them
4233
 
        # from the output so that they don't get included in the library
4234
 
        # dependencies.
4235
 
        output_verbose_link_cmd='templist=`$CC -G $CFLAGS -v conftest.$objext 2>&1 | grep "\-[[LR]]"`; list=""; for z in $templist; do case $z in conftest.$objext) list="$list $z";; *.$objext);; *) list="$list $z";;esac; done; echo $list'
 
3599
        output_verbose_link_cmd='echo'
4236
3600
 
4237
3601
        # Archives containing C++ object files must be created using
4238
3602
        # "CC -xar", where "CC" is the Sun C++ compiler.  This is
4240
3604
        # in the archive.
4241
3605
        _LT_AC_TAGVAR(old_archive_cmds, $1)='$CC -xar -o $oldlib $oldobjs'
4242
3606
        ;;
4243
 
      gcx)
 
3607
      gcx*)
4244
3608
        # Green Hills C++ Compiler
4245
3609
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $predep_objects $libobjs $deplibs $postdep_objects $compiler_flags ${wl}-h $wl$soname -o $lib'
4246
3610
 
4278
3642
        ;;
4279
3643
    esac
4280
3644
    ;;
4281
 
  sysv5OpenUNIX8* | sysv5UnixWare7* | sysv5uw[[78]]* | unixware7*)
4282
 
    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
 
3645
  sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7* | sco3.2v5.0.[[024]]*)
 
3646
    _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
 
3647
    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
 
3648
    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
 
3649
    runpath_var='LD_RUN_PATH'
 
3650
 
 
3651
    case $cc_basename in
 
3652
      CC*)
 
3653
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
3654
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
3655
        ;;
 
3656
      *)
 
3657
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
3658
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
3659
        ;;
 
3660
    esac
 
3661
    ;;
 
3662
  sysv5* | sco3.2v5* | sco5v6*)
 
3663
    # Note: We can NOT use -z defs as we might desire, because we do not
 
3664
    # link with -lc, and that would cause any symbols used from libc to
 
3665
    # always be unresolved, which means just about no library would
 
3666
    # ever link correctly.  If we're not using GNU ld we use -z text
 
3667
    # though, which does catch some bad symbols but isn't as heavy-handed
 
3668
    # as -z defs.
 
3669
    # For security reasons, it is highly recommended that you always
 
3670
    # use absolute paths for naming shared libraries, and exclude the
 
3671
    # DT_RUNPATH tag from executables and libraries.  But doing so
 
3672
    # requires that you compile everything twice, which is a pain.
 
3673
    # So that behaviour is only enabled if SCOABSPATH is set to a
 
3674
    # non-empty value in the environment.  Most likely only useful for
 
3675
    # creating official distributions of packages.
 
3676
    # This is a hack until libtool officially supports absolute path
 
3677
    # names for shared libraries.
 
3678
    _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
 
3679
    _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
 
3680
    _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
 
3681
    _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
 
3682
    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
 
3683
    _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'
 
3684
    _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
 
3685
    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
 
3686
    runpath_var='LD_RUN_PATH'
 
3687
 
 
3688
    case $cc_basename in
 
3689
      CC*)
 
3690
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
3691
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
3692
        ;;
 
3693
      *)
 
3694
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
3695
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
3696
        ;;
 
3697
    esac
4283
3698
    ;;
4284
3699
  tandem*)
4285
3700
    case $cc_basename in
4286
 
      NCC)
 
3701
      NCC*)
4287
3702
        # NonStop-UX NCC 3.20
4288
3703
        # FIXME: insert proper C++ library support
4289
3704
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
4316
3731
AC_LIBTOOL_PROG_LD_SHLIBS($1)
4317
3732
AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
4318
3733
AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
4319
 
AC_LIBTOOL_SYS_LIB_STRIP
4320
 
AC_LIBTOOL_DLOPEN_SELF($1)
4321
3734
 
4322
3735
AC_LIBTOOL_CONFIG($1)
4323
3736
 
4335
3748
])# AC_LIBTOOL_LANG_CXX_CONFIG
4336
3749
 
4337
3750
# AC_LIBTOOL_POSTDEP_PREDEP([TAGNAME])
4338
 
# ------------------------
 
3751
# ------------------------------------
4339
3752
# Figure out "hidden" library dependencies from verbose
4340
3753
# compiler output when linking a shared library.
4341
3754
# Parse the compiler output and extract the necessary
4389
3802
  # The `*' in the case matches for architectures that use `case' in
4390
3803
  # $output_verbose_cmd can trigger glob expansion during the loop
4391
3804
  # eval without this substitution.
4392
 
  output_verbose_link_cmd="`$echo \"X$output_verbose_link_cmd\" | $Xsed -e \"$no_glob_subst\"`"
 
3805
  output_verbose_link_cmd=`$echo "X$output_verbose_link_cmd" | $Xsed -e "$no_glob_subst"`
4393
3806
 
4394
3807
  for p in `eval $output_verbose_link_cmd`; do
4395
3808
    case $p in
4465
3878
 
4466
3879
$rm -f confest.$objext
4467
3880
 
 
3881
# PORTME: override above test on systems where it is broken
 
3882
ifelse([$1],[CXX],
 
3883
[case $host_os in
 
3884
interix3*)
 
3885
  # Interix 3.5 installs completely hosed .la files for C++, so rather than
 
3886
  # hack all around it, let's just trust "g++" to DTRT.
 
3887
  _LT_AC_TAGVAR(predep_objects,$1)=
 
3888
  _LT_AC_TAGVAR(postdep_objects,$1)=
 
3889
  _LT_AC_TAGVAR(postdeps,$1)=
 
3890
  ;;
 
3891
 
 
3892
solaris*)
 
3893
  case $cc_basename in
 
3894
  CC*)
 
3895
    # Adding this requires a known-good setup of shared libraries for
 
3896
    # Sun compiler versions before 5.6, else PIC objects from an old
 
3897
    # archive will be linked into the output, leading to subtle bugs.
 
3898
    _LT_AC_TAGVAR(postdeps,$1)='-lCstd -lCrun'
 
3899
    ;;
 
3900
  esac
 
3901
  ;;
 
3902
esac
 
3903
])
 
3904
 
4468
3905
case " $_LT_AC_TAGVAR(postdeps, $1) " in
4469
3906
*" -lc "*) _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no ;;
4470
3907
esac
4471
3908
])# AC_LIBTOOL_POSTDEP_PREDEP
4472
3909
 
4473
3910
# AC_LIBTOOL_LANG_F77_CONFIG
4474
 
# ------------------------
 
3911
# --------------------------
4475
3912
# Ensure that the configuration vars for the C compiler are
4476
3913
# suitably defined.  Those variables are subsequently used by
4477
3914
# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.
4515
3952
# ltmain only uses $CC for tagged configurations so make sure $CC is set.
4516
3953
_LT_AC_SYS_COMPILER
4517
3954
 
 
3955
# save warnings/boilerplate of simple test code
 
3956
_LT_COMPILER_BOILERPLATE
 
3957
_LT_LINKER_BOILERPLATE
 
3958
 
4518
3959
# Allow CC to be a program name with arguments.
4519
3960
lt_save_CC="$CC"
4520
3961
CC=${F77-"f77"}
4521
3962
compiler=$CC
4522
3963
_LT_AC_TAGVAR(compiler, $1)=$CC
4523
 
cc_basename=`$echo X"$compiler" | $Xsed -e 's%^.*/%%'`
 
3964
_LT_CC_BASENAME([$compiler])
4524
3965
 
4525
3966
AC_MSG_CHECKING([if libtool supports shared libraries])
4526
3967
AC_MSG_RESULT([$can_build_shared])
4530
3971
 
4531
3972
# On AIX, shared libraries and static libraries use the same namespace, and
4532
3973
# are all built from PIC.
4533
 
case "$host_os" in
 
3974
case $host_os in
4534
3975
aix3*)
4535
3976
  test "$enable_shared" = yes && enable_static=no
4536
3977
  if test -n "$RANLIB"; then
4538
3979
    postinstall_cmds='$RANLIB $lib'
4539
3980
  fi
4540
3981
  ;;
4541
 
aix4*)
4542
 
  test "$enable_shared" = yes && enable_static=no
 
3982
aix4* | aix5*)
 
3983
  if test "$host_cpu" != ia64 && test "$aix_use_runtimelinking" = no ; then
 
3984
    test "$enable_shared" = yes && enable_static=no
 
3985
  fi
4543
3986
  ;;
4544
3987
esac
4545
3988
AC_MSG_RESULT([$enable_shared])
4549
3992
test "$enable_shared" = yes || enable_static=yes
4550
3993
AC_MSG_RESULT([$enable_static])
4551
3994
 
4552
 
test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
4553
 
 
4554
3995
_LT_AC_TAGVAR(GCC, $1)="$G77"
4555
3996
_LT_AC_TAGVAR(LD, $1)="$LD"
4556
3997
 
4560
4001
AC_LIBTOOL_PROG_LD_SHLIBS($1)
4561
4002
AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
4562
4003
AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
4563
 
AC_LIBTOOL_SYS_LIB_STRIP
4564
 
 
4565
4004
 
4566
4005
AC_LIBTOOL_CONFIG($1)
4567
4006
 
4590
4029
lt_simple_compile_test_code="class foo {}\n"
4591
4030
 
4592
4031
# Code to be used in simple link tests
4593
 
lt_simple_link_test_code='public class conftest { public static void main(String[] argv) {}; }\n'
 
4032
lt_simple_link_test_code='public class conftest { public static void main(String[[]] argv) {}; }\n'
4594
4033
 
4595
4034
# ltmain only uses $CC for tagged configurations so make sure $CC is set.
4596
4035
_LT_AC_SYS_COMPILER
4597
4036
 
 
4037
# save warnings/boilerplate of simple test code
 
4038
_LT_COMPILER_BOILERPLATE
 
4039
_LT_LINKER_BOILERPLATE
 
4040
 
4598
4041
# Allow CC to be a program name with arguments.
4599
4042
lt_save_CC="$CC"
4600
4043
CC=${GCJ-"gcj"}
4601
4044
compiler=$CC
4602
4045
_LT_AC_TAGVAR(compiler, $1)=$CC
 
4046
_LT_CC_BASENAME([$compiler])
4603
4047
 
4604
4048
# GCJ did not exist at the time GCC didn't implicitly link libc in.
4605
4049
_LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
4606
4050
 
 
4051
_LT_AC_TAGVAR(old_archive_cmds, $1)=$old_archive_cmds
 
4052
 
4607
4053
AC_LIBTOOL_PROG_COMPILER_NO_RTTI($1)
4608
4054
AC_LIBTOOL_PROG_COMPILER_PIC($1)
4609
4055
AC_LIBTOOL_PROG_CC_C_O($1)
4611
4057
AC_LIBTOOL_PROG_LD_SHLIBS($1)
4612
4058
AC_LIBTOOL_SYS_DYNAMIC_LINKER($1)
4613
4059
AC_LIBTOOL_PROG_LD_HARDCODE_LIBPATH($1)
4614
 
AC_LIBTOOL_SYS_LIB_STRIP
4615
 
AC_LIBTOOL_DLOPEN_SELF($1)
4616
4060
 
4617
4061
AC_LIBTOOL_CONFIG($1)
4618
4062
 
4622
4066
 
4623
4067
 
4624
4068
# AC_LIBTOOL_LANG_RC_CONFIG
4625
 
# --------------------------
 
4069
# -------------------------
4626
4070
# Ensure that the configuration vars for the Windows resource compiler are
4627
4071
# suitably defined.  Those variables are subsequently used by
4628
4072
# AC_LIBTOOL_CONFIG to write the compiler configuration to `libtool'.
4646
4090
# ltmain only uses $CC for tagged configurations so make sure $CC is set.
4647
4091
_LT_AC_SYS_COMPILER
4648
4092
 
 
4093
# save warnings/boilerplate of simple test code
 
4094
_LT_COMPILER_BOILERPLATE
 
4095
_LT_LINKER_BOILERPLATE
 
4096
 
4649
4097
# Allow CC to be a program name with arguments.
4650
4098
lt_save_CC="$CC"
4651
4099
CC=${RC-"windres"}
4652
4100
compiler=$CC
4653
4101
_LT_AC_TAGVAR(compiler, $1)=$CC
 
4102
_LT_CC_BASENAME([$compiler])
4654
4103
_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)=yes
4655
4104
 
4656
4105
AC_LIBTOOL_CONFIG($1)
4676
4125
  # without removal of \ escapes.
4677
4126
  if test -n "${ZSH_VERSION+set}" ; then
4678
4127
    setopt NO_GLOB_SUBST
4679
 
  fi  
 
4128
  fi
4680
4129
  # Now quote all the things that may contain metacharacters while being
4681
4130
  # careful not to overquote the AC_SUBSTed values.  We take copies of the
4682
4131
  # variables and quote the copies for generation of the libtool script.
4683
 
  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC NM SED SHELL \
 
4132
  for var in echo old_CC old_CFLAGS AR AR_FLAGS EGREP RANLIB LN_S LTCC LTCFLAGS NM \
 
4133
    SED SHELL STRIP \
4684
4134
    libname_spec library_names_spec soname_spec extract_expsyms_cmds \
4685
4135
    old_striplib striplib file_magic_cmd finish_cmds finish_eval \
4686
4136
    deplibs_check_method reload_flag reload_cmds need_locks \
4730
4180
    _LT_AC_TAGVAR(archive_cmds, $1) | \
4731
4181
    _LT_AC_TAGVAR(archive_expsym_cmds, $1) | \
4732
4182
    _LT_AC_TAGVAR(module_cmds, $1) | \
4733
 
    _LT_AC_TAGVAR(module_expsym_cmds, $1) | \   
 
4183
    _LT_AC_TAGVAR(module_expsym_cmds, $1) | \
4734
4184
    _LT_AC_TAGVAR(old_archive_from_expsyms_cmds, $1) | \
4735
4185
    _LT_AC_TAGVAR(export_symbols_cmds, $1) | \
4736
4186
    extract_expsyms_cmds | reload_cmds | finish_cmds | \
4785
4235
#
4786
4236
# You should have received a copy of the GNU General Public License
4787
4237
# along with this program; if not, write to the Free Software
4788
 
# Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 
4238
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
4789
4239
#
4790
4240
# As a special exception to the GNU General Public License, if you
4791
4241
# distribute this file as part of a program that contains a
4796
4246
SED=$lt_SED
4797
4247
 
4798
4248
# Sed that helps us avoid accidentally triggering echo(1) options like -n.
4799
 
Xsed="$SED -e s/^X//"
 
4249
Xsed="$SED -e 1s/^X//"
4800
4250
 
4801
4251
# The HP-UX ksh and POSIX shell print the target directory to stdout
4802
4252
# if CDPATH is set.
4803
 
if test "X\${CDPATH+set}" = Xset; then CDPATH=:; export CDPATH; fi
 
4253
(unset CDPATH) >/dev/null 2>&1 && unset CDPATH
4804
4254
 
4805
4255
# The names of the tagged configurations supported by this script.
4806
4256
available_tags=
4831
4281
# The host system.
4832
4282
host_alias=$host_alias
4833
4283
host=$host
 
4284
host_os=$host_os
 
4285
 
 
4286
# The build system.
 
4287
build_alias=$build_alias
 
4288
build=$build
 
4289
build_os=$build_os
4834
4290
 
4835
4291
# An echo program that does not interpret backslashes.
4836
4292
echo=$lt_echo
4842
4298
# A C compiler.
4843
4299
LTCC=$lt_LTCC
4844
4300
 
 
4301
# LTCC compiler flags.
 
4302
LTCFLAGS=$lt_LTCFLAGS
 
4303
 
4845
4304
# A language-specific compiler.
4846
4305
CC=$lt_[]_LT_AC_TAGVAR(compiler, $1)
4847
4306
 
4861
4320
NM=$lt_NM
4862
4321
 
4863
4322
# A symbol stripping program
4864
 
STRIP="$STRIP"
 
4323
STRIP=$lt_STRIP
4865
4324
 
4866
4325
# Used to examine libraries when file_magic_cmd begins "file"
4867
4326
MAGIC_CMD=$MAGIC_CMD
4892
4351
libext="$libext"
4893
4352
 
4894
4353
# Shared library suffix (normally ".so").
4895
 
shrext='$shrext'
 
4354
shrext_cmds='$shrext_cmds'
4896
4355
 
4897
4356
# Executable file suffix (normally "").
4898
4357
exeext="$exeext"
4907
4366
# Does compiler simultaneously support -c and -o options?
4908
4367
compiler_c_o=$lt_[]_LT_AC_TAGVAR(lt_cv_prog_compiler_c_o, $1)
4909
4368
 
4910
 
# Must we lock files when doing compilation ?
 
4369
# Must we lock files when doing compilation?
4911
4370
need_locks=$lt_need_locks
4912
4371
 
4913
4372
# Do we need the lib prefix for modules?
5136
4595
  # If there is no Makefile yet, we rely on a make rule to execute
5137
4596
  # `config.status --recheck' to rerun these tests and create the
5138
4597
  # libtool script then.
5139
 
  test -f Makefile && make "$ltmain"
 
4598
  ltmain_in=`echo $ltmain | sed -e 's/\.sh$/.in/'`
 
4599
  if test -f "$ltmain_in"; then
 
4600
    test -f Makefile && make "$ltmain"
 
4601
  fi
5140
4602
fi
5141
4603
])# AC_LIBTOOL_CONFIG
5142
4604
 
5178
4640
# Regexp to match symbols that can be accessed directly from C.
5179
4641
sympat='\([[_A-Za-z]][[_A-Za-z0-9]]*\)'
5180
4642
 
5181
 
# Transform the above into a raw symbol and a C symbol.
5182
 
symxfrm='\1 \2\3 \3'
5183
 
 
5184
4643
# Transform an extracted symbol line into a proper C declaration
5185
4644
lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^. .* \(.*\)$/extern int \1;/p'"
5186
4645
 
5202
4661
  lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
5203
4662
  lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
5204
4663
  ;;
 
4664
linux* | k*bsd*-gnu)
 
4665
  if test "$host_cpu" = ia64; then
 
4666
    symcode='[[ABCDGIRSTW]]'
 
4667
    lt_cv_sys_global_symbol_to_cdecl="sed -n -e 's/^T .* \(.*\)$/extern int \1();/p' -e 's/^$symcode* .* \(.*\)$/extern char \1;/p'"
 
4668
    lt_cv_sys_global_symbol_to_c_name_address="sed -n -e 's/^: \([[^ ]]*\) $/  {\\\"\1\\\", (lt_ptr) 0},/p' -e 's/^$symcode* \([[^ ]]*\) \([[^ ]]*\)$/  {\"\2\", (lt_ptr) \&\2},/p'"
 
4669
  fi
 
4670
  ;;
5205
4671
irix* | nonstopux*)
5206
4672
  symcode='[[BCDEGRST]]'
5207
4673
  ;;
5208
4674
osf*)
5209
4675
  symcode='[[BCDEGQRST]]'
5210
4676
  ;;
5211
 
solaris* | sysv5*)
 
4677
solaris*)
5212
4678
  symcode='[[BDRT]]'
5213
4679
  ;;
 
4680
sco3.2v5*)
 
4681
  symcode='[[DT]]'
 
4682
  ;;
 
4683
sysv4.2uw2*)
 
4684
  symcode='[[DT]]'
 
4685
  ;;
 
4686
sysv5* | sco5v6* | unixware* | OpenUNIX*)
 
4687
  symcode='[[ABDT]]'
 
4688
  ;;
5214
4689
sysv4)
5215
4690
  symcode='[[DFNSTU]]'
5216
4691
  ;;
5233
4708
# Try without a prefix undercore, then with it.
5234
4709
for ac_symprfx in "" "_"; do
5235
4710
 
 
4711
  # Transform symcode, sympat, and symprfx into a raw symbol and a C symbol.
 
4712
  symxfrm="\\1 $ac_symprfx\\2 \\2"
 
4713
 
5236
4714
  # Write the raw and C identifiers.
5237
 
  lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[      ]]\($symcode$symcode*\)[[       ]][[    ]]*\($ac_symprfx\)$sympat$opt_cr$/$symxfrm/p'"
 
4715
  lt_cv_sys_global_symbol_pipe="sed -n -e 's/^.*[[      ]]\($symcode$symcode*\)[[       ]][[    ]]*$ac_symprfx$sympat$opt_cr$/$symxfrm/p'"
5238
4716
 
5239
4717
  # Check to see that the pipe works correctly.
5240
4718
  pipe_works=no
5390
4868
      # DJGPP does not support shared libraries at all
5391
4869
      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
5392
4870
      ;;
 
4871
    interix3*)
 
4872
      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
 
4873
      # Instead, we relocate shared libraries at runtime.
 
4874
      ;;
5393
4875
    sysv4*MP*)
5394
4876
      if test -d /usr/nec; then
5395
4877
        _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=-Kconform_pic
5398
4880
    hpux*)
5399
4881
      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
5400
4882
      # not for PA HP-UX.
5401
 
      case "$host_cpu" in
 
4883
      case $host_cpu in
5402
4884
      hppa*64*|ia64*)
5403
4885
        ;;
5404
4886
      *)
5423
4905
        ;;
5424
4906
      chorus*)
5425
4907
        case $cc_basename in
5426
 
        cxch68)
 
4908
        cxch68*)
5427
4909
          # Green Hills C++ Compiler
5428
4910
          # _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="--no_auto_instantiation -u __main -u __premain -u _abort -r $COOL_DIR/lib/libOrb.a $MVME_DIR/lib/CC/libC.a $MVME_DIR/lib/classix/libcx.s.a"
5429
4911
          ;;
5430
4912
        esac
5431
4913
        ;;
 
4914
       darwin*)
 
4915
         # PIC is the default on this platform
 
4916
         # Common symbols not allowed in MH_DYLIB files
 
4917
         case $cc_basename in
 
4918
           xlc*)
 
4919
           _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-qnocommon'
 
4920
           _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
 
4921
           ;;
 
4922
         esac
 
4923
       ;;
5432
4924
      dgux*)
5433
4925
        case $cc_basename in
5434
 
          ec++)
 
4926
          ec++*)
5435
4927
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
5436
4928
            ;;
5437
 
          ghcx)
 
4929
          ghcx*)
5438
4930
            # Green Hills C++ Compiler
5439
4931
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
5440
4932
            ;;
5442
4934
            ;;
5443
4935
        esac
5444
4936
        ;;
5445
 
      freebsd* | kfreebsd*-gnu)
 
4937
      freebsd* | dragonfly*)
5446
4938
        # FreeBSD uses GNU C++
5447
4939
        ;;
5448
4940
      hpux9* | hpux10* | hpux11*)
5449
4941
        case $cc_basename in
5450
 
          CC)
 
4942
          CC*)
5451
4943
            _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
5452
 
            _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive"
 
4944
            _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
5453
4945
            if test "$host_cpu" != ia64; then
5454
4946
              _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='+Z'
5455
4947
            fi
5456
4948
            ;;
5457
 
          aCC)
 
4949
          aCC*)
5458
4950
            _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
5459
 
            _LT_AC_TAGVAR(lt_prog_compiler_static, $1)="${ac_cv_prog_cc_wl}-a ${ac_cv_prog_cc_wl}archive"
5460
 
            case "$host_cpu" in
 
4951
            _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='${wl}-a ${wl}archive'
 
4952
            case $host_cpu in
5461
4953
            hppa*64*|ia64*)
5462
4954
              # +Z the default
5463
4955
              ;;
5470
4962
            ;;
5471
4963
        esac
5472
4964
        ;;
 
4965
      interix*)
 
4966
        # This is c89, which is MS Visual C++ (no shared libs)
 
4967
        # Anyone wants to do a port?
 
4968
        ;;
5473
4969
      irix5* | irix6* | nonstopux*)
5474
4970
        case $cc_basename in
5475
 
          CC)
 
4971
          CC*)
5476
4972
            _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
5477
4973
            _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
5478
4974
            # CC pic flag -KPIC is the default.
5481
4977
            ;;
5482
4978
        esac
5483
4979
        ;;
5484
 
      linux*)
 
4980
      linux* | k*bsd*-gnu)
5485
4981
        case $cc_basename in
5486
 
          KCC)
 
4982
          KCC*)
5487
4983
            # KAI C++ Compiler
5488
4984
            _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
5489
4985
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
5490
4986
            ;;
5491
 
          icpc)
 
4987
          icpc* | ecpc*)
5492
4988
            # Intel C++
5493
4989
            _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
5494
4990
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
5495
4991
            _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
5496
 
            ;; 
5497
 
          cxx)
 
4992
            ;;
 
4993
          pgCC*)
 
4994
            # Portland Group C++ compiler.
 
4995
            _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
 
4996
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
 
4997
            _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
 
4998
            ;;
 
4999
          cxx*)
5498
5000
            # Compaq C++
5499
5001
            # Make sure the PIC flag is empty.  It appears that all Alpha
5500
5002
            # Linux and Compaq Tru64 Unix objects are PIC.
5511
5013
        ;;
5512
5014
      mvs*)
5513
5015
        case $cc_basename in
5514
 
          cxx)
 
5016
          cxx*)
5515
5017
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-W c,exportall'
5516
5018
            ;;
5517
5019
          *)
5518
5020
            ;;
5519
5021
        esac
5520
5022
        ;;
5521
 
      netbsd*)
 
5023
      netbsd* | netbsdelf*-gnu)
5522
5024
        ;;
5523
5025
      osf3* | osf4* | osf5*)
5524
5026
        case $cc_basename in
5525
 
          KCC)
 
5027
          KCC*)
5526
5028
            _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='--backend -Wl,'
5527
5029
            ;;
5528
 
          RCC)
 
5030
          RCC*)
5529
5031
            # Rational C++ 2.4.1
5530
5032
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
5531
5033
            ;;
5532
 
          cxx)
 
5034
          cxx*)
5533
5035
            # Digital/Compaq C++
5534
5036
            _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
5535
5037
            # Make sure the PIC flag is empty.  It appears that all Alpha
5543
5045
        ;;
5544
5046
      psos*)
5545
5047
        ;;
5546
 
      sco*)
5547
 
        case $cc_basename in
5548
 
          CC)
5549
 
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fPIC'
5550
 
            ;;
5551
 
          *)
5552
 
            ;;
5553
 
        esac
5554
 
        ;;
5555
5048
      solaris*)
5556
5049
        case $cc_basename in
5557
 
          CC)
 
5050
          CC*)
5558
5051
            # Sun C++ 4.2, 5.x and Centerline C++
5559
5052
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
5560
5053
            _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
5561
5054
            _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld '
5562
5055
            ;;
5563
 
          gcx)
 
5056
          gcx*)
5564
5057
            # Green Hills C++ Compiler
5565
5058
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-PIC'
5566
5059
            ;;
5570
5063
        ;;
5571
5064
      sunos4*)
5572
5065
        case $cc_basename in
5573
 
          CC)
 
5066
          CC*)
5574
5067
            # Sun C++ 4.x
5575
5068
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
5576
5069
            _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
5577
5070
            ;;
5578
 
          lcc)
 
5071
          lcc*)
5579
5072
            # Lucid
5580
5073
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
5581
5074
            ;;
5585
5078
        ;;
5586
5079
      tandem*)
5587
5080
        case $cc_basename in
5588
 
          NCC)
 
5081
          NCC*)
5589
5082
            # NonStop-UX NCC 3.20
5590
5083
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
5591
5084
            ;;
5593
5086
            ;;
5594
5087
        esac
5595
5088
        ;;
5596
 
      unixware*)
 
5089
      sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
 
5090
        case $cc_basename in
 
5091
          CC*)
 
5092
            _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
 
5093
            _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
 
5094
            _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
 
5095
            ;;
 
5096
        esac
5597
5097
        ;;
5598
5098
      vxworks*)
5599
5099
        ;;
5640
5140
      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fno-common'
5641
5141
      ;;
5642
5142
 
 
5143
    interix3*)
 
5144
      # Interix 3.x gcc -fpic/-fPIC options generate broken code.
 
5145
      # Instead, we relocate shared libraries at runtime.
 
5146
      ;;
 
5147
 
5643
5148
    msdosdjgpp*)
5644
5149
      # Just because we use GCC doesn't mean we suddenly get shared libraries
5645
5150
      # on systems that don't support them.
5656
5161
    hpux*)
5657
5162
      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
5658
5163
      # not for PA HP-UX.
5659
 
      case "$host_cpu" in
 
5164
      case $host_cpu in
5660
5165
      hppa*64*|ia64*)
5661
5166
        # +Z the default
5662
5167
        ;;
5682
5187
        _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-bnso -bI:/lib/syscalls.exp'
5683
5188
      fi
5684
5189
      ;;
 
5190
      darwin*)
 
5191
        # PIC is the default on this platform
 
5192
        # Common symbols not allowed in MH_DYLIB files
 
5193
       case $cc_basename in
 
5194
         xlc*)
 
5195
         _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-qnocommon'
 
5196
         _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
 
5197
         ;;
 
5198
       esac
 
5199
       ;;
5685
5200
 
5686
5201
    mingw* | pw32* | os2*)
5687
5202
      # This hack is so that the source file can tell whether it is being
5693
5208
      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
5694
5209
      # PIC is the default for IA64 HP-UX and 64-bit HP-UX, but
5695
5210
      # not for PA HP-UX.
5696
 
      case "$host_cpu" in
 
5211
      case $host_cpu in
5697
5212
      hppa*64*|ia64*)
5698
5213
        # +Z the default
5699
5214
        ;;
5716
5231
      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
5717
5232
      ;;
5718
5233
 
5719
 
    linux*)
5720
 
      case $CC in
 
5234
    linux* | k*bsd*-gnu)
 
5235
      case $cc_basename in
5721
5236
      icc* | ecc*)
5722
5237
        _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
5723
5238
        _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
5724
5239
        _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-static'
5725
5240
        ;;
 
5241
      pgcc* | pgf77* | pgf90* | pgf95*)
 
5242
        # Portland Group compilers (*not* the Pentium gcc compiler,
 
5243
        # which looks to be a dead project)
 
5244
        _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
 
5245
        _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-fpic'
 
5246
        _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
 
5247
        ;;
5726
5248
      ccc*)
5727
5249
        _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
5728
5250
        # All Alpha code is PIC.
5737
5259
      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-non_shared'
5738
5260
      ;;
5739
5261
 
5740
 
    sco3.2v5*)
5741
 
      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-Kpic'
5742
 
      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-dn'
5743
 
      ;;
5744
 
 
5745
5262
    solaris*)
5746
 
      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
5747
5263
      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
5748
5264
      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
 
5265
      case $cc_basename in
 
5266
      f77* | f90* | f95*)
 
5267
        _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Qoption ld ';;
 
5268
      *)
 
5269
        _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,';;
 
5270
      esac
5749
5271
      ;;
5750
5272
 
5751
5273
    sunos4*)
5754
5276
      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
5755
5277
      ;;
5756
5278
 
5757
 
    sysv4 | sysv4.2uw2* | sysv4.3* | sysv5*)
 
5279
    sysv4 | sysv4.2uw2* | sysv4.3*)
5758
5280
      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
5759
5281
      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
5760
5282
      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
5767
5289
      fi
5768
5290
      ;;
5769
5291
 
 
5292
    sysv5* | unixware* | sco3.2v5* | sco5v6* | OpenUNIX*)
 
5293
      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
 
5294
      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-KPIC'
 
5295
      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
 
5296
      ;;
 
5297
 
 
5298
    unicos*)
 
5299
      _LT_AC_TAGVAR(lt_prog_compiler_wl, $1)='-Wl,'
 
5300
      _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no
 
5301
      ;;
 
5302
 
5770
5303
    uts4*)
5771
5304
      _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)='-pic'
5772
5305
      _LT_AC_TAGVAR(lt_prog_compiler_static, $1)='-Bstatic'
5794
5327
    [_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
5795
5328
     _LT_AC_TAGVAR(lt_prog_compiler_can_build_shared, $1)=no])
5796
5329
fi
5797
 
case "$host_os" in
 
5330
case $host_os in
5798
5331
  # For platforms which do not support PIC, -DPIC is meaningless:
5799
5332
  *djgpp*)
5800
5333
    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)=
5803
5336
    _LT_AC_TAGVAR(lt_prog_compiler_pic, $1)="$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)ifelse([$1],[],[ -DPIC],[ifelse([$1],[CXX],[ -DPIC],[])])"
5804
5337
    ;;
5805
5338
esac
 
5339
 
 
5340
#
 
5341
# Check to make sure the static flag actually works.
 
5342
#
 
5343
wl=$_LT_AC_TAGVAR(lt_prog_compiler_wl, $1) eval lt_tmp_static_flag=\"$_LT_AC_TAGVAR(lt_prog_compiler_static, $1)\"
 
5344
AC_LIBTOOL_LINKER_OPTION([if $compiler static flag $lt_tmp_static_flag works],
 
5345
  _LT_AC_TAGVAR(lt_prog_compiler_static_works, $1),
 
5346
  $lt_tmp_static_flag,
 
5347
  [],
 
5348
  [_LT_AC_TAGVAR(lt_prog_compiler_static, $1)=])
5806
5349
])
5807
5350
 
5808
5351
 
5827
5370
    _LT_AC_TAGVAR(export_symbols_cmds, $1)="$ltdll_cmds"
5828
5371
  ;;
5829
5372
  cygwin* | mingw*)
5830
 
    _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGS]] /s/.* \([[^ ]]*\)/\1 DATA/'\'' | $SED -e '\''/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'
 
5373
    _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]] /s/.* \([[^ ]]*\)/\1 DATA/;/^.* __nm__/s/^.* __nm__\([[^ ]]*\) [[^ ]]*/\1 DATA/;/^I /d;/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'
 
5374
  ;;
 
5375
  linux* | k*bsd*-gnu)
 
5376
    _LT_AC_TAGVAR(link_all_deplibs, $1)=no
5831
5377
  ;;
5832
5378
  *)
5833
5379
    _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
5853
5399
  _LT_AC_TAGVAR(link_all_deplibs, $1)=unknown
5854
5400
  _LT_AC_TAGVAR(hardcode_automatic, $1)=no
5855
5401
  _LT_AC_TAGVAR(module_cmds, $1)=
5856
 
  _LT_AC_TAGVAR(module_expsym_cmds, $1)=  
 
5402
  _LT_AC_TAGVAR(module_expsym_cmds, $1)=
5857
5403
  _LT_AC_TAGVAR(always_export_symbols, $1)=no
5858
5404
  _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED '\''s/.* //'\'' | sort | uniq > $export_symbols'
5859
5405
  # include_expsyms should be a list of space-separated symbols to be *always*
5870
5416
  # rely on this symbol name, it's probably fine to never include it in
5871
5417
  # preloaded symbol tables.
5872
5418
  extract_expsyms_cmds=
5873
 
 
 
5419
  # Just being paranoid about ensuring that cc_basename is set.
 
5420
  _LT_CC_BASENAME([$compiler])
5874
5421
  case $host_os in
5875
5422
  cygwin* | mingw* | pw32*)
5876
5423
    # FIXME: the MSVC++ port hasn't been tested in a loooong time
5880
5427
      with_gnu_ld=no
5881
5428
    fi
5882
5429
    ;;
 
5430
  interix*)
 
5431
    # we just hope/assume this is gcc and not c89 (= MSVC++)
 
5432
    with_gnu_ld=yes
 
5433
    ;;
5883
5434
  openbsd*)
5884
5435
    with_gnu_ld=no
5885
5436
    ;;
5890
5441
    # If archive_cmds runs LD, not CC, wlarc should be empty
5891
5442
    wlarc='${wl}'
5892
5443
 
 
5444
    # Set some defaults for GNU ld with shared library support. These
 
5445
    # are reset later if shared libraries are not supported. Putting them
 
5446
    # here allows them to be overridden if necessary.
 
5447
    runpath_var=LD_RUN_PATH
 
5448
    _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
 
5449
    _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
 
5450
    # ancient GNU ld didn't support --whole-archive et. al.
 
5451
    if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then
 
5452
        _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
 
5453
      else
 
5454
        _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
 
5455
    fi
 
5456
    supports_anon_versioning=no
 
5457
    case `$LD -v 2>/dev/null` in
 
5458
      *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
 
5459
      *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
 
5460
      *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
 
5461
      *\ 2.11.*) ;; # other 2.11 versions
 
5462
      *) supports_anon_versioning=yes ;;
 
5463
    esac
 
5464
 
5893
5465
    # See if GNU ld supports shared libraries.
5894
5466
    case $host_os in
5895
5467
    aix3* | aix4* | aix5*)
5940
5512
      _LT_AC_TAGVAR(allow_undefined_flag, $1)=unsupported
5941
5513
      _LT_AC_TAGVAR(always_export_symbols, $1)=no
5942
5514
      _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
5943
 
      _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGS]] /s/.* \([[^ ]]*\)/\1 DATA/'\'' | $SED -e '\''/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'
 
5515
      _LT_AC_TAGVAR(export_symbols_cmds, $1)='$NM $libobjs $convenience | $global_symbol_pipe | $SED -e '\''/^[[BCDGRS]] /s/.* \([[^ ]]*\)/\1 DATA/'\'' | $SED -e '\''/^[[AITW]] /s/.* //'\'' | sort | uniq > $export_symbols'
5944
5516
 
5945
5517
      if $LD --help 2>&1 | grep 'auto-import' > /dev/null; then
5946
 
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000 ${wl}--out-implib,$lib'
 
5518
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
5947
5519
        # If the export-symbols file already is a .def file (1st line
5948
5520
        # is EXPORTS), use it as is; otherwise, prepend...
5949
5521
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='if test "x`$SED 1q $export_symbols`" = xEXPORTS; then
5952
5524
          echo EXPORTS > $output_objdir/$soname.def;
5953
5525
          cat $export_symbols >> $output_objdir/$soname.def;
5954
5526
        fi~
5955
 
        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--image-base=0x10000000  ${wl}--out-implib,$lib'
5956
 
      else
5957
 
        ld_shlibs=no
5958
 
      fi
5959
 
      ;;
5960
 
 
5961
 
    netbsd*)
 
5527
        $CC -shared $output_objdir/$soname.def $libobjs $deplibs $compiler_flags -o $output_objdir/$soname ${wl}--enable-auto-image-base -Xlinker --out-implib -Xlinker $lib'
 
5528
      else
 
5529
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
 
5530
      fi
 
5531
      ;;
 
5532
 
 
5533
    interix3*)
 
5534
      _LT_AC_TAGVAR(hardcode_direct, $1)=no
 
5535
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
 
5536
      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
 
5537
      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
 
5538
      # Hack: On Interix 3.x, we cannot compile PIC because of a broken gcc.
 
5539
      # Instead, shared libraries are loaded at an image base (0x10000000 by
 
5540
      # default) and relocated if they conflict, which is a slow very memory
 
5541
      # consuming and fragmenting process.  To avoid this, we pick a random,
 
5542
      # 256 KiB-aligned image base between 0x50000000 and 0x6FFC0000 at link
 
5543
      # time.  Moving up from 0x10000000 also allows more sbrk(2) space.
 
5544
      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
 
5545
      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed "s,^,_," $export_symbols >$output_objdir/$soname.expsym~$CC -shared $pic_flag $libobjs $deplibs $compiler_flags ${wl}-h,$soname ${wl}--retain-symbols-file,$output_objdir/$soname.expsym ${wl}--image-base,`expr ${RANDOM-$$} % 4096 / 2 \* 262144 + 1342177280` -o $lib'
 
5546
      ;;
 
5547
 
 
5548
    linux* | k*bsd*-gnu)
 
5549
      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
 
5550
        tmp_addflag=
 
5551
        case $cc_basename,$host_cpu in
 
5552
        pgcc*)                          # Portland Group C compiler
 
5553
          _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
 
5554
          tmp_addflag=' $pic_flag'
 
5555
          ;;
 
5556
        pgf77* | pgf90* | pgf95*)       # Portland Group f77 and f90 compilers
 
5557
          _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}--whole-archive`for conv in $convenience\"\"; do test  -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}--no-whole-archive'
 
5558
          tmp_addflag=' $pic_flag -Mnomain' ;;
 
5559
        ecc*,ia64* | icc*,ia64*)                # Intel C compiler on ia64
 
5560
          tmp_addflag=' -i_dynamic' ;;
 
5561
        efc*,ia64* | ifort*,ia64*)      # Intel Fortran compiler on ia64
 
5562
          tmp_addflag=' -i_dynamic -nofor_main' ;;
 
5563
        ifc* | ifort*)                  # Intel Fortran compiler
 
5564
          tmp_addflag=' -nofor_main' ;;
 
5565
        esac
 
5566
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
 
5567
 
 
5568
        if test $supports_anon_versioning = yes; then
 
5569
          _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $output_objdir/$libname.ver~
 
5570
  cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
 
5571
  $echo "local: *; };" >> $output_objdir/$libname.ver~
 
5572
          $CC -shared'"$tmp_addflag"' $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
 
5573
        fi
 
5574
        _LT_AC_TAGVAR(link_all_deplibs, $1)=no
 
5575
      else
 
5576
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
 
5577
      fi
 
5578
      ;;
 
5579
 
 
5580
    netbsd* | netbsdelf*-gnu)
5962
5581
      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
5963
5582
        _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable $libobjs $deplibs $linker_flags -o $lib'
5964
5583
        wlarc=
5968
5587
      fi
5969
5588
      ;;
5970
5589
 
5971
 
    solaris* | sysv5*)
 
5590
    solaris*)
5972
5591
      if $LD -v 2>&1 | grep 'BFD 2\.8' > /dev/null; then
5973
5592
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
5974
5593
        cat <<EOF 1>&2
5989
5608
      fi
5990
5609
      ;;
5991
5610
 
 
5611
    sysv5* | sco3.2v5* | sco5v6* | unixware* | OpenUNIX*)
 
5612
      case `$LD -v 2>&1` in
 
5613
        *\ [[01]].* | *\ 2.[[0-9]].* | *\ 2.1[[0-5]].*) 
 
5614
        _LT_AC_TAGVAR(ld_shlibs, $1)=no
 
5615
        cat <<_LT_EOF 1>&2
 
5616
 
 
5617
*** Warning: Releases of the GNU linker prior to 2.16.91.0.3 can not
 
5618
*** reliably create shared libraries on SCO systems.  Therefore, libtool
 
5619
*** is disabling shared libraries support.  We urge you to upgrade GNU
 
5620
*** binutils to release 2.16.91.0.3 or newer.  Another option is to modify
 
5621
*** your PATH or compiler configuration so that the native linker is
 
5622
*** used, and then restart.
 
5623
 
 
5624
_LT_EOF
 
5625
        ;;
 
5626
        *)
 
5627
          if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
 
5628
            _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='`test -z "$SCOABSPATH" && echo ${wl}-rpath,$libdir`'
 
5629
            _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib'
 
5630
            _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname,\${SCOABSPATH:+${install_libdir}/}$soname,-retain-symbols-file,$export_symbols -o $lib'
 
5631
          else
 
5632
            _LT_AC_TAGVAR(ld_shlibs, $1)=no
 
5633
          fi
 
5634
        ;;
 
5635
      esac
 
5636
      ;;
 
5637
 
5992
5638
    sunos4*)
5993
5639
      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -assert pure-text -Bshareable -o $lib $libobjs $deplibs $linker_flags'
5994
5640
      wlarc=
5996
5642
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
5997
5643
      ;;
5998
5644
 
5999
 
  linux*)
6000
 
    if $LD --help 2>&1 | egrep ': supported targets:.* elf' > /dev/null; then
6001
 
        tmp_archive_cmds='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
6002
 
        _LT_AC_TAGVAR(archive_cmds, $1)="$tmp_archive_cmds"
6003
 
      supports_anon_versioning=no
6004
 
      case `$LD -v 2>/dev/null` in
6005
 
        *\ [01].* | *\ 2.[[0-9]].* | *\ 2.10.*) ;; # catch versions < 2.11
6006
 
        *\ 2.11.93.0.2\ *) supports_anon_versioning=yes ;; # RH7.3 ...
6007
 
        *\ 2.11.92.0.12\ *) supports_anon_versioning=yes ;; # Mandrake 8.2 ...
6008
 
        *\ 2.11.*) ;; # other 2.11 versions
6009
 
        *) supports_anon_versioning=yes ;;
6010
 
      esac
6011
 
      if test $supports_anon_versioning = yes; then
6012
 
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $output_objdir/$libname.ver~
6013
 
cat $export_symbols | sed -e "s/\(.*\)/\1;/" >> $output_objdir/$libname.ver~
6014
 
$echo "local: *; };" >> $output_objdir/$libname.ver~
6015
 
        $CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname ${wl}-version-script ${wl}$output_objdir/$libname.ver -o $lib'
6016
 
      else
6017
 
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)="$tmp_archive_cmds"
6018
 
      fi
6019
 
    else
6020
 
      _LT_AC_TAGVAR(ld_shlibs, $1)=no
6021
 
    fi
6022
 
    ;;
6023
 
 
6024
5645
    *)
6025
5646
      if $LD --help 2>&1 | grep ': supported targets:.* elf' > /dev/null; then
6026
5647
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $libobjs $deplibs $compiler_flags ${wl}-soname $wl$soname -o $lib'
6031
5652
      ;;
6032
5653
    esac
6033
5654
 
6034
 
    if test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = yes; then
6035
 
      runpath_var=LD_RUN_PATH
6036
 
      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}--rpath ${wl}$libdir'
6037
 
      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}--export-dynamic'
6038
 
      # ancient GNU ld didn't support --whole-archive et. al.
6039
 
      if $LD --help 2>&1 | grep 'no-whole-archive' > /dev/null; then
6040
 
        _LT_AC_TAGVAR(whole_archive_flag_spec, $1)="$wlarc"'--whole-archive$convenience '"$wlarc"'--no-whole-archive'
6041
 
      else
6042
 
        _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
6043
 
      fi
 
5655
    if test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no; then
 
5656
      runpath_var=
 
5657
      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
 
5658
      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=
 
5659
      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=
6044
5660
    fi
6045
5661
  else
6046
5662
    # PORTME fill in a description of your system's linker (not GNU ld)
6052
5668
      # Note: this linker hardcodes the directories in LIBPATH if there
6053
5669
      # are no directories specified by -L.
6054
5670
      _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
6055
 
      if test "$GCC" = yes && test -z "$link_static_flag"; then
 
5671
      if test "$GCC" = yes && test -z "$lt_prog_compiler_static"; then
6056
5672
        # Neither direct hardcoding nor static linking is supported with a
6057
5673
        # broken collect2.
6058
5674
        _LT_AC_TAGVAR(hardcode_direct, $1)=unsupported
6086
5702
            break
6087
5703
          fi
6088
5704
          done
 
5705
          ;;
6089
5706
        esac
6090
5707
 
6091
5708
        exp_sym_flag='-bexport'
6104
5721
      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
6105
5722
 
6106
5723
      if test "$GCC" = yes; then
6107
 
        case $host_os in aix4.[012]|aix4.[012].*)
 
5724
        case $host_os in aix4.[[012]]|aix4.[[012]].*)
6108
5725
        # We only want to do this on AIX 4.2 and lower, the check
6109
5726
        # below for broken collect2 doesn't work under 4.3+
6110
5727
          collect2name=`${CC} -print-prog-name=collect2`
6123
5740
          _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
6124
5741
          _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=
6125
5742
          fi
 
5743
          ;;
6126
5744
        esac
6127
5745
        shared_flag='-shared'
 
5746
        if test "$aix_use_runtimelinking" = yes; then
 
5747
          shared_flag="$shared_flag "'${wl}-G'
 
5748
        fi
6128
5749
      else
6129
5750
        # not using gcc
6130
5751
        if test "$host_cpu" = ia64; then
6132
5753
        # chokes on -Wl,-G. The following line is correct:
6133
5754
          shared_flag='-G'
6134
5755
        else
6135
 
        if test "$aix_use_runtimelinking" = yes; then
 
5756
          if test "$aix_use_runtimelinking" = yes; then
6136
5757
            shared_flag='${wl}-G'
6137
5758
          else
6138
5759
            shared_flag='${wl}-bM:SRE'
6139
 
        fi
 
5760
          fi
6140
5761
        fi
6141
5762
      fi
6142
5763
 
6150
5771
       # Determine the default libpath from the value encoded in an empty executable.
6151
5772
       _LT_AC_SYS_LIBPATH_AIX
6152
5773
       _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-blibpath:$libdir:'"$aix_libpath"
6153
 
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols $shared_flag"
 
5774
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags `if test "x${allow_undefined_flag}" != "x"; then echo "${wl}${allow_undefined_flag}"; else :; fi` '"\${wl}$exp_sym_flag:\$export_symbols $shared_flag"
6154
5775
       else
6155
5776
        if test "$host_cpu" = ia64; then
6156
5777
          _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-R $libdir:/usr/lib:/lib'
6157
5778
          _LT_AC_TAGVAR(allow_undefined_flag, $1)="-z nodefs"
6158
 
          _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$no_entry_flag \${wl}$exp_sym_flag:\$export_symbols"
 
5779
          _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs '"\${wl}$no_entry_flag"' $compiler_flags ${wl}${allow_undefined_flag} '"\${wl}$exp_sym_flag:\$export_symbols"
6159
5780
        else
6160
5781
         # Determine the default libpath from the value encoded in an empty executable.
6161
5782
         _LT_AC_SYS_LIBPATH_AIX
6164
5785
          # -berok will link without error, but may produce a broken library.
6165
5786
          _LT_AC_TAGVAR(no_undefined_flag, $1)=' ${wl}-bernotok'
6166
5787
          _LT_AC_TAGVAR(allow_undefined_flag, $1)=' ${wl}-berok'
6167
 
          # -bexpall does not export symbols beginning with underscore (_)
6168
 
          _LT_AC_TAGVAR(always_export_symbols, $1)=yes
6169
5788
          # Exported symbols can be pulled into shared objects from archives
6170
 
          _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=' '
 
5789
          _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='$convenience'
6171
5790
          _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=yes
6172
 
          # This is similar to how AIX traditionally builds it's shared libraries.
6173
 
          _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs $compiler_flags ${wl}-bE:$export_symbols ${wl}-bnoentry${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
 
5791
          # This is similar to how AIX traditionally builds its shared libraries.
 
5792
          _LT_AC_TAGVAR(archive_expsym_cmds, $1)="\$CC $shared_flag"' -o $output_objdir/$soname $libobjs $deplibs ${wl}-bnoentry $compiler_flags ${wl}-bE:$export_symbols${allow_undefined_flag}~$AR $AR_FLAGS $output_objdir/$libname$release.a $output_objdir/$soname'
6174
5793
        fi
6175
5794
      fi
6176
5795
      ;;
6183
5802
      _LT_AC_TAGVAR(ld_shlibs, $1)=no
6184
5803
      ;;
6185
5804
 
6186
 
    bsdi4*)
 
5805
    bsdi[[45]]*)
6187
5806
      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)=-rdynamic
6188
5807
      ;;
6189
5808
 
6197
5816
      # Tell ltmain to make .lib files, not .a files.
6198
5817
      libext=lib
6199
5818
      # Tell ltmain to make .dll files, not .so files.
6200
 
      shrext=".dll"
 
5819
      shrext_cmds=".dll"
6201
5820
      # FIXME: Setting linknames here is a bad hack.
6202
5821
      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -o $lib $libobjs $compiler_flags `echo "$deplibs" | $SED -e '\''s/ -lc$//'\''` -link -dll~linknames='
6203
5822
      # The linker will automatically build a .lib file if we build a DLL.
6204
5823
      _LT_AC_TAGVAR(old_archive_From_new_cmds, $1)='true'
6205
5824
      # FIXME: Should let the user specify the lib program.
6206
5825
      _LT_AC_TAGVAR(old_archive_cmds, $1)='lib /OUT:$oldlib$oldobjs$old_deplibs'
6207
 
      fix_srcfile_path='`cygpath -w "$srcfile"`'
 
5826
      _LT_AC_TAGVAR(fix_srcfile_path, $1)='`cygpath -w "$srcfile"`'
6208
5827
      _LT_AC_TAGVAR(enable_shared_with_static_runtimes, $1)=yes
6209
5828
      ;;
6210
5829
 
6211
5830
    darwin* | rhapsody*)
6212
 
    if test "$GXX" = yes ; then
 
5831
      case $host_os in
 
5832
        rhapsody* | darwin1.[[012]])
 
5833
         _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}suppress'
 
5834
         ;;
 
5835
       *) # Darwin 1.3 on
 
5836
         if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
 
5837
           _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
 
5838
         else
 
5839
           case ${MACOSX_DEPLOYMENT_TARGET} in
 
5840
             10.[[012]])
 
5841
               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-flat_namespace ${wl}-undefined ${wl}suppress'
 
5842
               ;;
 
5843
             10.*)
 
5844
               _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-undefined ${wl}dynamic_lookup'
 
5845
               ;;
 
5846
           esac
 
5847
         fi
 
5848
         ;;
 
5849
      esac
6213
5850
      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
6214
 
      case "$host_os" in
6215
 
      rhapsody* | darwin1.[[012]])
6216
 
        _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined suppress'
6217
 
        ;;
6218
 
      *) # Darwin 1.3 on
6219
 
      if test -z ${MACOSX_DEPLOYMENT_TARGET} ; then
6220
 
        _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress'
6221
 
      else
6222
 
        case ${MACOSX_DEPLOYMENT_TARGET} in
6223
 
          10.[[012]])
6224
 
            _LT_AC_TAGVAR(allow_undefined_flag, $1)='-flat_namespace -undefined suppress'
6225
 
            ;;
6226
 
          10.*)
6227
 
            _LT_AC_TAGVAR(allow_undefined_flag, $1)='-undefined dynamic_lookup'
6228
 
            ;;            
6229
 
        esac
6230
 
      fi
6231
 
        ;;
6232
 
      esac
6233
 
        lt_int_apple_cc_single_mod=no
 
5851
      _LT_AC_TAGVAR(hardcode_direct, $1)=no
 
5852
      _LT_AC_TAGVAR(hardcode_automatic, $1)=yes
 
5853
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
 
5854
      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)=''
 
5855
      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
 
5856
    if test "$GCC" = yes ; then
6234
5857
        output_verbose_link_cmd='echo'
6235
 
        if $CC -dumpspecs 2>&1 | grep 'single_module' >/dev/null ; then
6236
 
          lt_int_apple_cc_single_mod=yes
6237
 
        fi
6238
 
        if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
6239
 
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
6240
 
        else
6241
 
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
6242
 
      fi
6243
 
      _LT_AC_TAGVAR(module_cmds, $1)='$CC ${wl}-bind_at_load $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
6244
 
      # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin ld's
6245
 
        if test "X$lt_int_apple_cc_single_mod" = Xyes ; then
6246
 
          _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib -single_module $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
6247
 
        else
6248
 
          _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -r ${wl}-bind_at_load -keep_private_externs -nostdlib -o ${lib}-master.o $libobjs~$CC -dynamiclib $allow_undefined_flag -o $lib ${lib}-master.o $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
6249
 
        fi
 
5858
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring'
 
5859
      _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
 
5860
      # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
 
5861
      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -dynamiclib $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags -install_name $rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
5862
      _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
 
5863
    else
 
5864
      case $cc_basename in
 
5865
        xlc*)
 
5866
         output_verbose_link_cmd='echo'
 
5867
         _LT_AC_TAGVAR(archive_cmds, $1)='$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}`echo $rpath/$soname` $verstring'
 
5868
         _LT_AC_TAGVAR(module_cmds, $1)='$CC $allow_undefined_flag -o $lib -bundle $libobjs $deplibs$compiler_flags'
 
5869
          # Don't fix this by using the ld -exported_symbols_list flag, it doesn't exist in older darwin lds
 
5870
         _LT_AC_TAGVAR(archive_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC -qmkshrobj $allow_undefined_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-install_name ${wl}$rpath/$soname $verstring~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
6250
5871
          _LT_AC_TAGVAR(module_expsym_cmds, $1)='sed -e "s,#.*,," -e "s,^[    ]*,," -e "s,^\(..*\),_&," < $export_symbols > $output_objdir/${libname}-symbols.expsym~$CC $allow_undefined_flag  -o $lib -bundle $libobjs $deplibs$compiler_flags~nmedit -s $output_objdir/${libname}-symbols.expsym ${lib}'
6251
 
      _LT_AC_TAGVAR(hardcode_direct, $1)=no
6252
 
      _LT_AC_TAGVAR(hardcode_automatic, $1)=yes
6253
 
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=unsupported
6254
 
      _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-all_load $convenience'
6255
 
      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
6256
 
    else  
6257
 
      _LT_AC_TAGVAR(ld_shlibs, $1)=no
6258
 
    fi  
 
5872
          ;;
 
5873
       *)
 
5874
         _LT_AC_TAGVAR(ld_shlibs, $1)=no
 
5875
          ;;
 
5876
      esac
 
5877
    fi
6259
5878
      ;;
6260
5879
 
6261
5880
    dgux*)
6288
5907
      ;;
6289
5908
 
6290
5909
    # FreeBSD 3 and greater uses gcc -shared to do shared libraries.
6291
 
    freebsd* | kfreebsd*-gnu)
 
5910
    freebsd* | dragonfly*)
6292
5911
      _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -o $lib $libobjs $deplibs $compiler_flags'
6293
5912
      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-R$libdir'
6294
5913
      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
6311
5930
      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
6312
5931
      ;;
6313
5932
 
6314
 
    hpux10* | hpux11*)
6315
 
      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
6316
 
        case "$host_cpu" in
6317
 
        hppa*64*|ia64*)
 
5933
    hpux10*)
 
5934
      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
 
5935
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
 
5936
      else
 
5937
        _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
 
5938
      fi
 
5939
      if test "$with_gnu_ld" = no; then
 
5940
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
 
5941
        _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
 
5942
 
 
5943
        _LT_AC_TAGVAR(hardcode_direct, $1)=yes
 
5944
        _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
 
5945
 
 
5946
        # hardcode_minus_L: Not really in the search PATH,
 
5947
        # but as the default location of the library.
 
5948
        _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
 
5949
      fi
 
5950
      ;;
 
5951
 
 
5952
    hpux11*)
 
5953
      if test "$GCC" = yes -a "$with_gnu_ld" = no; then
 
5954
        case $host_cpu in
 
5955
        hppa*64*)
6318
5956
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
6319
5957
          ;;
 
5958
        ia64*)
 
5959
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
 
5960
          ;;
6320
5961
        *)
6321
5962
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared -fPIC ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
6322
5963
          ;;
6323
5964
        esac
6324
5965
      else
6325
 
        case "$host_cpu" in
6326
 
        hppa*64*|ia64*)
6327
 
          _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname -o $lib $libobjs $deplibs $linker_flags'
 
5966
        case $host_cpu in
 
5967
        hppa*64*)
 
5968
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
5969
          ;;
 
5970
        ia64*)
 
5971
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+nodefaultrpath -o $lib $libobjs $deplibs $compiler_flags'
6328
5972
          ;;
6329
5973
        *)
6330
 
          _LT_AC_TAGVAR(archive_cmds, $1)='$LD -b +h $soname +b $install_libdir -o $lib $libobjs $deplibs $linker_flags'
 
5974
          _LT_AC_TAGVAR(archive_cmds, $1)='$CC -b ${wl}+h ${wl}$soname ${wl}+b ${wl}$install_libdir -o $lib $libobjs $deplibs $compiler_flags'
6331
5975
          ;;
6332
5976
        esac
6333
5977
      fi
6334
5978
      if test "$with_gnu_ld" = no; then
6335
 
        case "$host_cpu" in
6336
 
        hppa*64*)
6337
 
          _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
 
5979
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
 
5980
        _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
 
5981
 
 
5982
        case $host_cpu in
 
5983
        hppa*64*|ia64*)
6338
5984
          _LT_AC_TAGVAR(hardcode_libdir_flag_spec_ld, $1)='+b $libdir'
6339
 
          _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
6340
 
          _LT_AC_TAGVAR(hardcode_direct, $1)=no
6341
 
          _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
6342
 
          ;;
6343
 
        ia64*)
6344
 
          _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-L$libdir'
6345
 
          _LT_AC_TAGVAR(hardcode_direct, $1)=no
6346
 
          _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
6347
 
 
6348
 
          # hardcode_minus_L: Not really in the search PATH,
6349
 
          # but as the default location of the library.
6350
 
          _LT_AC_TAGVAR(hardcode_minus_L, $1)=yes
 
5985
          _LT_AC_TAGVAR(hardcode_direct, $1)=no
 
5986
          _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
6351
5987
          ;;
6352
5988
        *)
6353
 
          _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}+b ${wl}$libdir'
6354
 
          _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
6355
5989
          _LT_AC_TAGVAR(hardcode_direct, $1)=yes
6356
5990
          _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
6357
5991
 
6375
6009
      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
6376
6010
      ;;
6377
6011
 
6378
 
    netbsd*)
 
6012
    netbsd* | netbsdelf*-gnu)
6379
6013
      if echo __ELF__ | $CC -E - | grep __ELF__ >/dev/null; then
6380
6014
        _LT_AC_TAGVAR(archive_cmds, $1)='$LD -Bshareable -o $lib $libobjs $deplibs $linker_flags'  # a.out
6381
6015
      else
6399
6033
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
6400
6034
      if test -z "`echo __ELF__ | $CC -E - | grep __ELF__`" || test "$host_os-$host_cpu" = "openbsd2.8-powerpc"; then
6401
6035
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags'
 
6036
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared $pic_flag -o $lib $libobjs $deplibs $compiler_flags ${wl}-retain-symbols-file,$export_symbols'
6402
6037
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='${wl}-rpath,$libdir'
6403
6038
        _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-E'
6404
6039
      else
6444
6079
        _LT_AC_TAGVAR(allow_undefined_flag, $1)=' -expect_unresolved \*'
6445
6080
        _LT_AC_TAGVAR(archive_cmds, $1)='$LD -shared${allow_undefined_flag} $libobjs $deplibs $linker_flags -msym -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib'
6446
6081
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='for i in `cat $export_symbols`; do printf "%s %s\\n" -exported_symbol "\$i" >> $lib.exp; done; echo "-hidden">> $lib.exp~
6447
 
        $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${objdir}/so_locations -o $lib~$rm $lib.exp'
 
6082
        $LD -shared${allow_undefined_flag} -input $lib.exp $linker_flags $libobjs $deplibs -soname $soname `test -n "$verstring" && echo -set_version $verstring` -update_registry ${output_objdir}/so_locations -o $lib~$rm $lib.exp'
6448
6083
 
6449
6084
        # Both c and cxx compiler support -rpath directly
6450
6085
        _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='-rpath $libdir'
6452
6087
      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=:
6453
6088
      ;;
6454
6089
 
6455
 
    sco3.2v5*)
6456
 
      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -h $soname -o $lib $libobjs $deplibs $linker_flags'
6457
 
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
6458
 
      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
6459
 
      runpath_var=LD_RUN_PATH
6460
 
      hardcode_runpath_var=yes
6461
 
      ;;
6462
 
 
6463
6090
    solaris*)
6464
6091
      _LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text'
6465
6092
      if test "$GCC" = yes; then
 
6093
        wlarc='${wl}'
6466
6094
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
6467
6095
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
6468
6096
          $CC -shared ${wl}-M ${wl}$lib.exp ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags~$rm $lib.exp'
6469
6097
      else
 
6098
        wlarc=''
6470
6099
        _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
6471
6100
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
6472
6101
        $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'
6475
6104
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
6476
6105
      case $host_os in
6477
6106
      solaris2.[[0-5]] | solaris2.[[0-5]].*) ;;
6478
 
      *) # Supported since Solaris 2.6 (maybe 2.5.1?)
6479
 
        _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;;
 
6107
      *)
 
6108
        # The compiler driver will combine linker options so we
 
6109
        # cannot just pass the convience library names through
 
6110
        # without $wl, iff we do not link with $LD.
 
6111
        # Luckily, gcc supports the same syntax we need for Sun Studio.
 
6112
        # Supported since Solaris 2.6 (maybe 2.5.1?)
 
6113
        case $wlarc in
 
6114
        '')
 
6115
          _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='-z allextract$convenience -z defaultextract' ;;
 
6116
        *)
 
6117
          _LT_AC_TAGVAR(whole_archive_flag_spec, $1)='${wl}-z ${wl}allextract`for conv in $convenience\"\"; do test -n \"$conv\" && new_convenience=\"$new_convenience,$conv\"; done; $echo \"$new_convenience\"` ${wl}-z ${wl}defaultextract' ;;
 
6118
        esac ;;
6480
6119
      esac
6481
6120
      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
6482
6121
      ;;
6533
6172
      fi
6534
6173
      ;;
6535
6174
 
6536
 
    sysv4.2uw2*)
6537
 
      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G -o $lib $libobjs $deplibs $linker_flags'
6538
 
      _LT_AC_TAGVAR(hardcode_direct, $1)=yes
6539
 
      _LT_AC_TAGVAR(hardcode_minus_L, $1)=no
6540
 
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
6541
 
      hardcode_runpath_var=yes
6542
 
      runpath_var=LD_RUN_PATH
6543
 
      ;;
6544
 
 
6545
 
   sysv5OpenUNIX8* | sysv5UnixWare7* |  sysv5uw[[78]]* | unixware7*)
6546
 
      _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z ${wl}text'
6547
 
      if test "$GCC" = yes; then
6548
 
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
6549
 
      else
6550
 
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h ${wl}$soname -o $lib $libobjs $deplibs $compiler_flags'
6551
 
      fi
6552
 
      runpath_var='LD_RUN_PATH'
6553
 
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
6554
 
      ;;
6555
 
 
6556
 
    sysv5*)
6557
 
      _LT_AC_TAGVAR(no_undefined_flag, $1)=' -z text'
6558
 
      # $CC -shared without GNU ld will not create a library from C++
6559
 
      # object files and a static libstdc++, better avoid it by now
6560
 
      _LT_AC_TAGVAR(archive_cmds, $1)='$LD -G${allow_undefined_flag} -h $soname -o $lib $libobjs $deplibs $linker_flags'
6561
 
      _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$echo "{ global:" > $lib.exp~cat $export_symbols | $SED -e "s/\(.*\)/\1;/" >> $lib.exp~$echo "local: *; };" >> $lib.exp~
6562
 
                $LD -G${allow_undefined_flag} -M $lib.exp -h $soname -o $lib $libobjs $deplibs $linker_flags~$rm $lib.exp'
6563
 
      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)=
6564
 
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
6565
 
      runpath_var='LD_RUN_PATH'
 
6175
    sysv4*uw2* | sysv5OpenUNIX* | sysv5UnixWare7.[[01]].[[10]]* | unixware7*)
 
6176
      _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
 
6177
      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
 
6178
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
 
6179
      runpath_var='LD_RUN_PATH'
 
6180
 
 
6181
      if test "$GCC" = yes; then
 
6182
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
6183
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
6184
      else
 
6185
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
6186
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,$soname -o $lib $libobjs $deplibs $compiler_flags'
 
6187
      fi
 
6188
      ;;
 
6189
 
 
6190
    sysv5* | sco3.2v5* | sco5v6*)
 
6191
      # Note: We can NOT use -z defs as we might desire, because we do not
 
6192
      # link with -lc, and that would cause any symbols used from libc to
 
6193
      # always be unresolved, which means just about no library would
 
6194
      # ever link correctly.  If we're not using GNU ld we use -z text
 
6195
      # though, which does catch some bad symbols but isn't as heavy-handed
 
6196
      # as -z defs.
 
6197
      _LT_AC_TAGVAR(no_undefined_flag, $1)='${wl}-z,text'
 
6198
      _LT_AC_TAGVAR(allow_undefined_flag, $1)='${wl}-z,nodefs'
 
6199
      _LT_AC_TAGVAR(archive_cmds_need_lc, $1)=no
 
6200
      _LT_AC_TAGVAR(hardcode_shlibpath_var, $1)=no
 
6201
      _LT_AC_TAGVAR(hardcode_libdir_flag_spec, $1)='`test -z "$SCOABSPATH" && echo ${wl}-R,$libdir`'
 
6202
      _LT_AC_TAGVAR(hardcode_libdir_separator, $1)=':'
 
6203
      _LT_AC_TAGVAR(link_all_deplibs, $1)=yes
 
6204
      _LT_AC_TAGVAR(export_dynamic_flag_spec, $1)='${wl}-Bexport'
 
6205
      runpath_var='LD_RUN_PATH'
 
6206
 
 
6207
      if test "$GCC" = yes; then
 
6208
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -shared ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
6209
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -shared ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
6210
      else
 
6211
        _LT_AC_TAGVAR(archive_cmds, $1)='$CC -G ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
6212
        _LT_AC_TAGVAR(archive_expsym_cmds, $1)='$CC -G ${wl}-Bexport:$export_symbols ${wl}-h,\${SCOABSPATH:+${install_libdir}/}$soname -o $lib $libobjs $deplibs $compiler_flags'
 
6213
      fi
6566
6214
      ;;
6567
6215
 
6568
6216
    uts4*)
6580
6228
AC_MSG_RESULT([$_LT_AC_TAGVAR(ld_shlibs, $1)])
6581
6229
test "$_LT_AC_TAGVAR(ld_shlibs, $1)" = no && can_build_shared=no
6582
6230
 
6583
 
variables_saved_for_relink="PATH $shlibpath_var $runpath_var"
6584
 
if test "$GCC" = yes; then
6585
 
  variables_saved_for_relink="$variables_saved_for_relink GCC_EXEC_PREFIX COMPILER_PATH LIBRARY_PATH"
6586
 
fi
6587
 
 
6588
6231
#
6589
6232
# Do we need to explicitly link libc?
6590
6233
#
6605
6248
      AC_MSG_CHECKING([whether -lc should be explicitly linked in])
6606
6249
      $rm conftest*
6607
6250
      printf "$lt_simple_compile_test_code" > conftest.$ac_ext
6608
 
  
 
6251
 
6609
6252
      if AC_TRY_EVAL(ac_compile) 2>conftest.err; then
6610
6253
        soname=conftest
6611
6254
        lib=conftest
6612
6255
        libobjs=conftest.$ac_objext
6613
6256
        deplibs=
6614
6257
        wl=$_LT_AC_TAGVAR(lt_prog_compiler_wl, $1)
 
6258
        pic_flag=$_LT_AC_TAGVAR(lt_prog_compiler_pic, $1)
6615
6259
        compiler_flags=-v
6616
6260
        linker_flags=-v
6617
6261
        verstring=
6737
6381
# Add /usr/xpg4/bin/sed as it is typically found on Solaris
6738
6382
# along with /bin/sed that truncates output.
6739
6383
for lt_ac_sed in $lt_ac_sed_list /usr/xpg4/bin/sed; do
6740
 
  test ! -f $lt_ac_sed && break
 
6384
  test ! -f $lt_ac_sed && continue
6741
6385
  cat /dev/null > conftest.in
6742
6386
  lt_ac_count=0
6743
6387
  echo $ECHO_N "0123456789$ECHO_C" >conftest.in
6762
6406
    fi
6763
6407
  done
6764
6408
done
 
6409
])
6765
6410
SED=$lt_cv_path_SED
6766
 
])
6767
6411
AC_MSG_RESULT([$SED])
6768
6412
])
6769
6413
 
6770
 
# lcmessage.m4 serial 3 (gettext-0.11.3)
6771
 
dnl Copyright (C) 1995-2002 Free Software Foundation, Inc.
6772
 
dnl This file is free software, distributed under the terms of the GNU
6773
 
dnl General Public License.  As a special exception to the GNU General
6774
 
dnl Public License, this file may be distributed as part of a program
6775
 
dnl that contains a configuration script generated by Autoconf, under
6776
 
dnl the same distribution terms as the rest of that program.
6777
 
dnl
6778
 
dnl This file can can be used in projects which are not available under
6779
 
dnl the GNU General Public License or the GNU Library General Public
6780
 
dnl License but which still want to provide support for the GNU gettext
6781
 
dnl functionality.
6782
 
dnl Please note that the actual code of the GNU gettext library is covered
6783
 
dnl by the GNU Library General Public License, and the rest of the GNU
6784
 
dnl gettext package package is covered by the GNU General Public License.
6785
 
dnl They are *not* in the public domain.
6786
 
 
6787
 
dnl Authors:
6788
 
dnl   Ulrich Drepper <drepper@cygnus.com>, 1995.
6789
 
 
6790
 
# Check whether LC_MESSAGES is available in <locale.h>.
6791
 
 
6792
 
AC_DEFUN([AM_LC_MESSAGES],
6793
 
[
6794
 
  AC_CACHE_CHECK([for LC_MESSAGES], am_cv_val_LC_MESSAGES,
6795
 
    [AC_TRY_LINK([#include <locale.h>], [return LC_MESSAGES],
6796
 
       am_cv_val_LC_MESSAGES=yes, am_cv_val_LC_MESSAGES=no)])
6797
 
  if test $am_cv_val_LC_MESSAGES = yes; then
6798
 
    AC_DEFINE(HAVE_LC_MESSAGES, 1,
6799
 
      [Define if your <locale.h> file defines LC_MESSAGES.])
6800
 
  fi
6801
 
])
6802