~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to config/ac-macros/lib-link.m4

  • Committer: Monty Taylor
  • Date: 2008-07-24 22:51:52 UTC
  • mto: (236.1.42 codestyle)
  • mto: This revision was merged to the branch mainline in revision 261.
  • Revision ID: monty@inaugust.com-20080724225152-1t1vnoj93kr9tb39
Added very initial gettextize stuff.

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
# lib-link.m4 serial 13 (gettext-0.17)
 
2
dnl Copyright (C) 2001-2007 Free Software Foundation, Inc.
 
3
dnl This file is free software; the Free Software Foundation
 
4
dnl gives unlimited permission to copy and/or distribute it,
 
5
dnl with or without modifications, as long as this notice is preserved.
 
6
 
 
7
dnl From Bruno Haible.
 
8
 
 
9
AC_PREREQ(2.54)
 
10
 
 
11
dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and
 
12
dnl the libraries corresponding to explicit and implicit dependencies.
 
13
dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and
 
14
dnl augments the CPPFLAGS variable.
 
15
dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
 
16
dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
 
17
AC_DEFUN([AC_LIB_LINKFLAGS],
 
18
[
 
19
  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
 
20
  AC_REQUIRE([AC_LIB_RPATH])
 
21
  define([Name],[translit([$1],[./-], [___])])
 
22
  define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
 
23
                               [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
 
24
  AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [
 
25
    AC_LIB_LINKFLAGS_BODY([$1], [$2])
 
26
    ac_cv_lib[]Name[]_libs="$LIB[]NAME"
 
27
    ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME"
 
28
    ac_cv_lib[]Name[]_cppflags="$INC[]NAME"
 
29
    ac_cv_lib[]Name[]_prefix="$LIB[]NAME[]_PREFIX"
 
30
  ])
 
31
  LIB[]NAME="$ac_cv_lib[]Name[]_libs"
 
32
  LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs"
 
33
  INC[]NAME="$ac_cv_lib[]Name[]_cppflags"
 
34
  LIB[]NAME[]_PREFIX="$ac_cv_lib[]Name[]_prefix"
 
35
  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
 
36
  AC_SUBST([LIB]NAME)
 
37
  AC_SUBST([LTLIB]NAME)
 
38
  AC_SUBST([LIB]NAME[_PREFIX])
 
39
  dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the
 
40
  dnl results of this search when this library appears as a dependency.
 
41
  HAVE_LIB[]NAME=yes
 
42
  undefine([Name])
 
43
  undefine([NAME])
 
44
])
 
45
 
 
46
dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode)
 
47
dnl searches for libname and the libraries corresponding to explicit and
 
48
dnl implicit dependencies, together with the specified include files and
 
49
dnl the ability to compile and link the specified testcode. If found, it
 
50
dnl sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME} and
 
51
dnl LTLIB${NAME} variables and augments the CPPFLAGS variable, and
 
52
dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs
 
53
dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty.
 
54
dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname
 
55
dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
 
56
AC_DEFUN([AC_LIB_HAVE_LINKFLAGS],
 
57
[
 
58
  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])
 
59
  AC_REQUIRE([AC_LIB_RPATH])
 
60
  define([Name],[translit([$1],[./-], [___])])
 
61
  define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
 
62
                               [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
 
63
 
 
64
  dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME
 
65
  dnl accordingly.
 
66
  AC_LIB_LINKFLAGS_BODY([$1], [$2])
 
67
 
 
68
  dnl Add $INC[]NAME to CPPFLAGS before performing the following checks,
 
69
  dnl because if the user has installed lib[]Name and not disabled its use
 
70
  dnl via --without-lib[]Name-prefix, he wants to use it.
 
71
  ac_save_CPPFLAGS="$CPPFLAGS"
 
72
  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)
 
73
 
 
74
  AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [
 
75
    ac_save_LIBS="$LIBS"
 
76
    LIBS="$LIBS $LIB[]NAME"
 
77
    AC_TRY_LINK([$3], [$4], [ac_cv_lib[]Name=yes], [ac_cv_lib[]Name=no])
 
78
    LIBS="$ac_save_LIBS"
 
79
  ])
 
80
  if test "$ac_cv_lib[]Name" = yes; then
 
81
    HAVE_LIB[]NAME=yes
 
82
    AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the $1 library.])
 
83
    AC_MSG_CHECKING([how to link with lib[]$1])
 
84
    AC_MSG_RESULT([$LIB[]NAME])
 
85
  else
 
86
    HAVE_LIB[]NAME=no
 
87
    dnl If $LIB[]NAME didn't lead to a usable library, we don't need
 
88
    dnl $INC[]NAME either.
 
89
    CPPFLAGS="$ac_save_CPPFLAGS"
 
90
    LIB[]NAME=
 
91
    LTLIB[]NAME=
 
92
    LIB[]NAME[]_PREFIX=
 
93
  fi
 
94
  AC_SUBST([HAVE_LIB]NAME)
 
95
  AC_SUBST([LIB]NAME)
 
96
  AC_SUBST([LTLIB]NAME)
 
97
  AC_SUBST([LIB]NAME[_PREFIX])
 
98
  undefine([Name])
 
99
  undefine([NAME])
 
100
])
 
101
 
 
102
dnl Determine the platform dependent parameters needed to use rpath:
 
103
dnl   acl_libext,
 
104
dnl   acl_shlibext,
 
105
dnl   acl_hardcode_libdir_flag_spec,
 
106
dnl   acl_hardcode_libdir_separator,
 
107
dnl   acl_hardcode_direct,
 
108
dnl   acl_hardcode_minus_L.
 
109
AC_DEFUN([AC_LIB_RPATH],
 
110
[
 
111
  dnl Tell automake >= 1.10 to complain if config.rpath is missing.
 
112
  m4_ifdef([AC_REQUIRE_AUX_FILE], [AC_REQUIRE_AUX_FILE([config.rpath])])
 
113
  AC_REQUIRE([AC_PROG_CC])                dnl we use $CC, $GCC, $LDFLAGS
 
114
  AC_REQUIRE([AC_LIB_PROG_LD])            dnl we use $LD, $with_gnu_ld
 
115
  AC_REQUIRE([AC_CANONICAL_HOST])         dnl we use $host
 
116
  AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir
 
117
  AC_CACHE_CHECK([for shared library run path origin], acl_cv_rpath, [
 
118
    CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \
 
119
    ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh
 
120
    . ./conftest.sh
 
121
    rm -f ./conftest.sh
 
122
    acl_cv_rpath=done
 
123
  ])
 
124
  wl="$acl_cv_wl"
 
125
  acl_libext="$acl_cv_libext"
 
126
  acl_shlibext="$acl_cv_shlibext"
 
127
  acl_libname_spec="$acl_cv_libname_spec"
 
128
  acl_library_names_spec="$acl_cv_library_names_spec"
 
129
  acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"
 
130
  acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"
 
131
  acl_hardcode_direct="$acl_cv_hardcode_direct"
 
132
  acl_hardcode_minus_L="$acl_cv_hardcode_minus_L"
 
133
  dnl Determine whether the user wants rpath handling at all.
 
134
  AC_ARG_ENABLE(rpath,
 
135
    [  --disable-rpath         do not hardcode runtime library paths],
 
136
    :, enable_rpath=yes)
 
137
])
 
138
 
 
139
dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and
 
140
dnl the libraries corresponding to explicit and implicit dependencies.
 
141
dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables.
 
142
dnl Also, sets the LIB${NAME}_PREFIX variable to nonempty if libname was found
 
143
dnl in ${LIB${NAME}_PREFIX}/$acl_libdirstem.
 
144
AC_DEFUN([AC_LIB_LINKFLAGS_BODY],
 
145
[
 
146
  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
 
147
  define([NAME],[translit([$1],[abcdefghijklmnopqrstuvwxyz./-],
 
148
                               [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])])
 
149
  dnl Autoconf >= 2.61 supports dots in --with options.
 
150
  define([N_A_M_E],[m4_if(m4_version_compare(m4_defn([m4_PACKAGE_VERSION]),[2.61]),[-1],[translit([$1],[.],[_])],[$1])])
 
151
  dnl By default, look in $includedir and $libdir.
 
152
  use_additional=yes
 
153
  AC_LIB_WITH_FINAL_PREFIX([
 
154
    eval additional_includedir=\"$includedir\"
 
155
    eval additional_libdir=\"$libdir\"
 
156
  ])
 
157
  AC_LIB_ARG_WITH([lib]N_A_M_E[-prefix],
 
158
[  --with-lib]N_A_M_E[-prefix[=DIR]  search for lib$1 in DIR/include and DIR/lib
 
159
  --without-lib]N_A_M_E[-prefix     don't search for lib$1 in includedir and libdir],
 
160
[
 
161
    if test "X$withval" = "Xno"; then
 
162
      use_additional=no
 
163
    else
 
164
      if test "X$withval" = "X"; then
 
165
        AC_LIB_WITH_FINAL_PREFIX([
 
166
          eval additional_includedir=\"$includedir\"
 
167
          eval additional_libdir=\"$libdir\"
 
168
        ])
 
169
      else
 
170
        additional_includedir="$withval/include"
 
171
        additional_libdir="$withval/$acl_libdirstem"
 
172
      fi
 
173
    fi
 
174
])
 
175
  dnl Search the library and its dependencies in $additional_libdir and
 
176
  dnl $LDFLAGS. Using breadth-first-seach.
 
177
  LIB[]NAME=
 
178
  LTLIB[]NAME=
 
179
  INC[]NAME=
 
180
  LIB[]NAME[]_PREFIX=
 
181
  rpathdirs=
 
182
  ltrpathdirs=
 
183
  names_already_handled=
 
184
  names_next_round='$1 $2'
 
185
  while test -n "$names_next_round"; do
 
186
    names_this_round="$names_next_round"
 
187
    names_next_round=
 
188
    for name in $names_this_round; do
 
189
      already_handled=
 
190
      for n in $names_already_handled; do
 
191
        if test "$n" = "$name"; then
 
192
          already_handled=yes
 
193
          break
 
194
        fi
 
195
      done
 
196
      if test -z "$already_handled"; then
 
197
        names_already_handled="$names_already_handled $name"
 
198
        dnl See if it was already located by an earlier AC_LIB_LINKFLAGS
 
199
        dnl or AC_LIB_HAVE_LINKFLAGS call.
 
200
        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./-|ABCDEFGHIJKLMNOPQRSTUVWXYZ___|'`
 
201
        eval value=\"\$HAVE_LIB$uppername\"
 
202
        if test -n "$value"; then
 
203
          if test "$value" = yes; then
 
204
            eval value=\"\$LIB$uppername\"
 
205
            test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value"
 
206
            eval value=\"\$LTLIB$uppername\"
 
207
            test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value"
 
208
          else
 
209
            dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined
 
210
            dnl that this library doesn't exist. So just drop it.
 
211
            :
 
212
          fi
 
213
        else
 
214
          dnl Search the library lib$name in $additional_libdir and $LDFLAGS
 
215
          dnl and the already constructed $LIBNAME/$LTLIBNAME.
 
216
          found_dir=
 
217
          found_la=
 
218
          found_so=
 
219
          found_a=
 
220
          eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name
 
221
          if test -n "$acl_shlibext"; then
 
222
            shrext=".$acl_shlibext"             # typically: shrext=.so
 
223
          else
 
224
            shrext=
 
225
          fi
 
226
          if test $use_additional = yes; then
 
227
            dir="$additional_libdir"
 
228
            dnl The same code as in the loop below:
 
229
            dnl First look for a shared library.
 
230
            if test -n "$acl_shlibext"; then
 
231
              if test -f "$dir/$libname$shrext"; then
 
232
                found_dir="$dir"
 
233
                found_so="$dir/$libname$shrext"
 
234
              else
 
235
                if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
 
236
                  ver=`(cd "$dir" && \
 
237
                        for f in "$libname$shrext".*; do echo "$f"; done \
 
238
                        | sed -e "s,^$libname$shrext\\\\.,," \
 
239
                        | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
 
240
                        | sed 1q ) 2>/dev/null`
 
241
                  if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
 
242
                    found_dir="$dir"
 
243
                    found_so="$dir/$libname$shrext.$ver"
 
244
                  fi
 
245
                else
 
246
                  eval library_names=\"$acl_library_names_spec\"
 
247
                  for f in $library_names; do
 
248
                    if test -f "$dir/$f"; then
 
249
                      found_dir="$dir"
 
250
                      found_so="$dir/$f"
 
251
                      break
 
252
                    fi
 
253
                  done
 
254
                fi
 
255
              fi
 
256
            fi
 
257
            dnl Then look for a static library.
 
258
            if test "X$found_dir" = "X"; then
 
259
              if test -f "$dir/$libname.$acl_libext"; then
 
260
                found_dir="$dir"
 
261
                found_a="$dir/$libname.$acl_libext"
 
262
              fi
 
263
            fi
 
264
            if test "X$found_dir" != "X"; then
 
265
              if test -f "$dir/$libname.la"; then
 
266
                found_la="$dir/$libname.la"
 
267
              fi
 
268
            fi
 
269
          fi
 
270
          if test "X$found_dir" = "X"; then
 
271
            for x in $LDFLAGS $LTLIB[]NAME; do
 
272
              AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
 
273
              case "$x" in
 
274
                -L*)
 
275
                  dir=`echo "X$x" | sed -e 's/^X-L//'`
 
276
                  dnl First look for a shared library.
 
277
                  if test -n "$acl_shlibext"; then
 
278
                    if test -f "$dir/$libname$shrext"; then
 
279
                      found_dir="$dir"
 
280
                      found_so="$dir/$libname$shrext"
 
281
                    else
 
282
                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then
 
283
                        ver=`(cd "$dir" && \
 
284
                              for f in "$libname$shrext".*; do echo "$f"; done \
 
285
                              | sed -e "s,^$libname$shrext\\\\.,," \
 
286
                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \
 
287
                              | sed 1q ) 2>/dev/null`
 
288
                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver"; then
 
289
                          found_dir="$dir"
 
290
                          found_so="$dir/$libname$shrext.$ver"
 
291
                        fi
 
292
                      else
 
293
                        eval library_names=\"$acl_library_names_spec\"
 
294
                        for f in $library_names; do
 
295
                          if test -f "$dir/$f"; then
 
296
                            found_dir="$dir"
 
297
                            found_so="$dir/$f"
 
298
                            break
 
299
                          fi
 
300
                        done
 
301
                      fi
 
302
                    fi
 
303
                  fi
 
304
                  dnl Then look for a static library.
 
305
                  if test "X$found_dir" = "X"; then
 
306
                    if test -f "$dir/$libname.$acl_libext"; then
 
307
                      found_dir="$dir"
 
308
                      found_a="$dir/$libname.$acl_libext"
 
309
                    fi
 
310
                  fi
 
311
                  if test "X$found_dir" != "X"; then
 
312
                    if test -f "$dir/$libname.la"; then
 
313
                      found_la="$dir/$libname.la"
 
314
                    fi
 
315
                  fi
 
316
                  ;;
 
317
              esac
 
318
              if test "X$found_dir" != "X"; then
 
319
                break
 
320
              fi
 
321
            done
 
322
          fi
 
323
          if test "X$found_dir" != "X"; then
 
324
            dnl Found the library.
 
325
            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name"
 
326
            if test "X$found_so" != "X"; then
 
327
              dnl Linking with a shared library. We attempt to hardcode its
 
328
              dnl directory into the executable's runpath, unless it's the
 
329
              dnl standard /usr/lib.
 
330
              if test "$enable_rpath" = no || test "X$found_dir" = "X/usr/$acl_libdirstem"; then
 
331
                dnl No hardcoding is needed.
 
332
                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
 
333
              else
 
334
                dnl Use an explicit option to hardcode DIR into the resulting
 
335
                dnl binary.
 
336
                dnl Potentially add DIR to ltrpathdirs.
 
337
                dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
 
338
                haveit=
 
339
                for x in $ltrpathdirs; do
 
340
                  if test "X$x" = "X$found_dir"; then
 
341
                    haveit=yes
 
342
                    break
 
343
                  fi
 
344
                done
 
345
                if test -z "$haveit"; then
 
346
                  ltrpathdirs="$ltrpathdirs $found_dir"
 
347
                fi
 
348
                dnl The hardcoding into $LIBNAME is system dependent.
 
349
                if test "$acl_hardcode_direct" = yes; then
 
350
                  dnl Using DIR/libNAME.so during linking hardcodes DIR into the
 
351
                  dnl resulting binary.
 
352
                  LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
 
353
                else
 
354
                  if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
 
355
                    dnl Use an explicit option to hardcode DIR into the resulting
 
356
                    dnl binary.
 
357
                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
 
358
                    dnl Potentially add DIR to rpathdirs.
 
359
                    dnl The rpathdirs will be appended to $LIBNAME at the end.
 
360
                    haveit=
 
361
                    for x in $rpathdirs; do
 
362
                      if test "X$x" = "X$found_dir"; then
 
363
                        haveit=yes
 
364
                        break
 
365
                      fi
 
366
                    done
 
367
                    if test -z "$haveit"; then
 
368
                      rpathdirs="$rpathdirs $found_dir"
 
369
                    fi
 
370
                  else
 
371
                    dnl Rely on "-L$found_dir".
 
372
                    dnl But don't add it if it's already contained in the LDFLAGS
 
373
                    dnl or the already constructed $LIBNAME
 
374
                    haveit=
 
375
                    for x in $LDFLAGS $LIB[]NAME; do
 
376
                      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
 
377
                      if test "X$x" = "X-L$found_dir"; then
 
378
                        haveit=yes
 
379
                        break
 
380
                      fi
 
381
                    done
 
382
                    if test -z "$haveit"; then
 
383
                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir"
 
384
                    fi
 
385
                    if test "$acl_hardcode_minus_L" != no; then
 
386
                      dnl FIXME: Not sure whether we should use
 
387
                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
 
388
                      dnl here.
 
389
                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"
 
390
                    else
 
391
                      dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH
 
392
                      dnl here, because this doesn't fit in flags passed to the
 
393
                      dnl compiler. So give up. No hardcoding. This affects only
 
394
                      dnl very old systems.
 
395
                      dnl FIXME: Not sure whether we should use
 
396
                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"
 
397
                      dnl here.
 
398
                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
 
399
                    fi
 
400
                  fi
 
401
                fi
 
402
              fi
 
403
            else
 
404
              if test "X$found_a" != "X"; then
 
405
                dnl Linking with a static library.
 
406
                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a"
 
407
              else
 
408
                dnl We shouldn't come here, but anyway it's good to have a
 
409
                dnl fallback.
 
410
                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name"
 
411
              fi
 
412
            fi
 
413
            dnl Assume the include files are nearby.
 
414
            additional_includedir=
 
415
            case "$found_dir" in
 
416
              */$acl_libdirstem | */$acl_libdirstem/)
 
417
                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`
 
418
                LIB[]NAME[]_PREFIX="$basedir"
 
419
                additional_includedir="$basedir/include"
 
420
                ;;
 
421
            esac
 
422
            if test "X$additional_includedir" != "X"; then
 
423
              dnl Potentially add $additional_includedir to $INCNAME.
 
424
              dnl But don't add it
 
425
              dnl   1. if it's the standard /usr/include,
 
426
              dnl   2. if it's /usr/local/include and we are using GCC on Linux,
 
427
              dnl   3. if it's already present in $CPPFLAGS or the already
 
428
              dnl      constructed $INCNAME,
 
429
              dnl   4. if it doesn't exist as a directory.
 
430
              if test "X$additional_includedir" != "X/usr/include"; then
 
431
                haveit=
 
432
                if test "X$additional_includedir" = "X/usr/local/include"; then
 
433
                  if test -n "$GCC"; then
 
434
                    case $host_os in
 
435
                      linux* | gnu* | k*bsd*-gnu) haveit=yes;;
 
436
                    esac
 
437
                  fi
 
438
                fi
 
439
                if test -z "$haveit"; then
 
440
                  for x in $CPPFLAGS $INC[]NAME; do
 
441
                    AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
 
442
                    if test "X$x" = "X-I$additional_includedir"; then
 
443
                      haveit=yes
 
444
                      break
 
445
                    fi
 
446
                  done
 
447
                  if test -z "$haveit"; then
 
448
                    if test -d "$additional_includedir"; then
 
449
                      dnl Really add $additional_includedir to $INCNAME.
 
450
                      INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir"
 
451
                    fi
 
452
                  fi
 
453
                fi
 
454
              fi
 
455
            fi
 
456
            dnl Look for dependencies.
 
457
            if test -n "$found_la"; then
 
458
              dnl Read the .la file. It defines the variables
 
459
              dnl dlname, library_names, old_library, dependency_libs, current,
 
460
              dnl age, revision, installed, dlopen, dlpreopen, libdir.
 
461
              save_libdir="$libdir"
 
462
              case "$found_la" in
 
463
                */* | *\\*) . "$found_la" ;;
 
464
                *) . "./$found_la" ;;
 
465
              esac
 
466
              libdir="$save_libdir"
 
467
              dnl We use only dependency_libs.
 
468
              for dep in $dependency_libs; do
 
469
                case "$dep" in
 
470
                  -L*)
 
471
                    additional_libdir=`echo "X$dep" | sed -e 's/^X-L//'`
 
472
                    dnl Potentially add $additional_libdir to $LIBNAME and $LTLIBNAME.
 
473
                    dnl But don't add it
 
474
                    dnl   1. if it's the standard /usr/lib,
 
475
                    dnl   2. if it's /usr/local/lib and we are using GCC on Linux,
 
476
                    dnl   3. if it's already present in $LDFLAGS or the already
 
477
                    dnl      constructed $LIBNAME,
 
478
                    dnl   4. if it doesn't exist as a directory.
 
479
                    if test "X$additional_libdir" != "X/usr/$acl_libdirstem"; then
 
480
                      haveit=
 
481
                      if test "X$additional_libdir" = "X/usr/local/$acl_libdirstem"; then
 
482
                        if test -n "$GCC"; then
 
483
                          case $host_os in
 
484
                            linux* | gnu* | k*bsd*-gnu) haveit=yes;;
 
485
                          esac
 
486
                        fi
 
487
                      fi
 
488
                      if test -z "$haveit"; then
 
489
                        haveit=
 
490
                        for x in $LDFLAGS $LIB[]NAME; do
 
491
                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
 
492
                          if test "X$x" = "X-L$additional_libdir"; then
 
493
                            haveit=yes
 
494
                            break
 
495
                          fi
 
496
                        done
 
497
                        if test -z "$haveit"; then
 
498
                          if test -d "$additional_libdir"; then
 
499
                            dnl Really add $additional_libdir to $LIBNAME.
 
500
                            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$additional_libdir"
 
501
                          fi
 
502
                        fi
 
503
                        haveit=
 
504
                        for x in $LDFLAGS $LTLIB[]NAME; do
 
505
                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
 
506
                          if test "X$x" = "X-L$additional_libdir"; then
 
507
                            haveit=yes
 
508
                            break
 
509
                          fi
 
510
                        done
 
511
                        if test -z "$haveit"; then
 
512
                          if test -d "$additional_libdir"; then
 
513
                            dnl Really add $additional_libdir to $LTLIBNAME.
 
514
                            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$additional_libdir"
 
515
                          fi
 
516
                        fi
 
517
                      fi
 
518
                    fi
 
519
                    ;;
 
520
                  -R*)
 
521
                    dir=`echo "X$dep" | sed -e 's/^X-R//'`
 
522
                    if test "$enable_rpath" != no; then
 
523
                      dnl Potentially add DIR to rpathdirs.
 
524
                      dnl The rpathdirs will be appended to $LIBNAME at the end.
 
525
                      haveit=
 
526
                      for x in $rpathdirs; do
 
527
                        if test "X$x" = "X$dir"; then
 
528
                          haveit=yes
 
529
                          break
 
530
                        fi
 
531
                      done
 
532
                      if test -z "$haveit"; then
 
533
                        rpathdirs="$rpathdirs $dir"
 
534
                      fi
 
535
                      dnl Potentially add DIR to ltrpathdirs.
 
536
                      dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.
 
537
                      haveit=
 
538
                      for x in $ltrpathdirs; do
 
539
                        if test "X$x" = "X$dir"; then
 
540
                          haveit=yes
 
541
                          break
 
542
                        fi
 
543
                      done
 
544
                      if test -z "$haveit"; then
 
545
                        ltrpathdirs="$ltrpathdirs $dir"
 
546
                      fi
 
547
                    fi
 
548
                    ;;
 
549
                  -l*)
 
550
                    dnl Handle this in the next round.
 
551
                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`
 
552
                    ;;
 
553
                  *.la)
 
554
                    dnl Handle this in the next round. Throw away the .la's
 
555
                    dnl directory; it is already contained in a preceding -L
 
556
                    dnl option.
 
557
                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`
 
558
                    ;;
 
559
                  *)
 
560
                    dnl Most likely an immediate library name.
 
561
                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep"
 
562
                    LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep"
 
563
                    ;;
 
564
                esac
 
565
              done
 
566
            fi
 
567
          else
 
568
            dnl Didn't find the library; assume it is in the system directories
 
569
            dnl known to the linker and runtime loader. (All the system
 
570
            dnl directories known to the linker should also be known to the
 
571
            dnl runtime loader, otherwise the system is severely misconfigured.)
 
572
            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"
 
573
            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name"
 
574
          fi
 
575
        fi
 
576
      fi
 
577
    done
 
578
  done
 
579
  if test "X$rpathdirs" != "X"; then
 
580
    if test -n "$acl_hardcode_libdir_separator"; then
 
581
      dnl Weird platform: only the last -rpath option counts, the user must
 
582
      dnl pass all path elements in one option. We can arrange that for a
 
583
      dnl single library, but not when more than one $LIBNAMEs are used.
 
584
      alldirs=
 
585
      for found_dir in $rpathdirs; do
 
586
        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"
 
587
      done
 
588
      dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl.
 
589
      acl_save_libdir="$libdir"
 
590
      libdir="$alldirs"
 
591
      eval flag=\"$acl_hardcode_libdir_flag_spec\"
 
592
      libdir="$acl_save_libdir"
 
593
      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
 
594
    else
 
595
      dnl The -rpath options are cumulative.
 
596
      for found_dir in $rpathdirs; do
 
597
        acl_save_libdir="$libdir"
 
598
        libdir="$found_dir"
 
599
        eval flag=\"$acl_hardcode_libdir_flag_spec\"
 
600
        libdir="$acl_save_libdir"
 
601
        LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"
 
602
      done
 
603
    fi
 
604
  fi
 
605
  if test "X$ltrpathdirs" != "X"; then
 
606
    dnl When using libtool, the option that works for both libraries and
 
607
    dnl executables is -R. The -R options are cumulative.
 
608
    for found_dir in $ltrpathdirs; do
 
609
      LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir"
 
610
    done
 
611
  fi
 
612
])
 
613
 
 
614
dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR,
 
615
dnl unless already present in VAR.
 
616
dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes
 
617
dnl contains two or three consecutive elements that belong together.
 
618
AC_DEFUN([AC_LIB_APPENDTOVAR],
 
619
[
 
620
  for element in [$2]; do
 
621
    haveit=
 
622
    for x in $[$1]; do
 
623
      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])
 
624
      if test "X$x" = "X$element"; then
 
625
        haveit=yes
 
626
        break
 
627
      fi
 
628
    done
 
629
    if test -z "$haveit"; then
 
630
      [$1]="${[$1]}${[$1]:+ }$element"
 
631
    fi
 
632
  done
 
633
])
 
634
 
 
635
dnl For those cases where a variable contains several -L and -l options
 
636
dnl referring to unknown libraries and directories, this macro determines the
 
637
dnl necessary additional linker options for the runtime path.
 
638
dnl AC_LIB_LINKFLAGS_FROM_LIBS([LDADDVAR], [LIBSVALUE], [USE-LIBTOOL])
 
639
dnl sets LDADDVAR to linker options needed together with LIBSVALUE.
 
640
dnl If USE-LIBTOOL evaluates to non-empty, linking with libtool is assumed,
 
641
dnl otherwise linking without libtool is assumed.
 
642
AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS],
 
643
[
 
644
  AC_REQUIRE([AC_LIB_RPATH])
 
645
  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])
 
646
  $1=
 
647
  if test "$enable_rpath" != no; then
 
648
    if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then
 
649
      dnl Use an explicit option to hardcode directories into the resulting
 
650
      dnl binary.
 
651
      rpathdirs=
 
652
      next=
 
653
      for opt in $2; do
 
654
        if test -n "$next"; then
 
655
          dir="$next"
 
656
          dnl No need to hardcode the standard /usr/lib.
 
657
          if test "X$dir" != "X/usr/$acl_libdirstem"; then
 
658
            rpathdirs="$rpathdirs $dir"
 
659
          fi
 
660
          next=
 
661
        else
 
662
          case $opt in
 
663
            -L) next=yes ;;
 
664
            -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'`
 
665
                 dnl No need to hardcode the standard /usr/lib.
 
666
                 if test "X$dir" != "X/usr/$acl_libdirstem"; then
 
667
                   rpathdirs="$rpathdirs $dir"
 
668
                 fi
 
669
                 next= ;;
 
670
            *) next= ;;
 
671
          esac
 
672
        fi
 
673
      done
 
674
      if test "X$rpathdirs" != "X"; then
 
675
        if test -n ""$3""; then
 
676
          dnl libtool is used for linking. Use -R options.
 
677
          for dir in $rpathdirs; do
 
678
            $1="${$1}${$1:+ }-R$dir"
 
679
          done
 
680
        else
 
681
          dnl The linker is used for linking directly.
 
682
          if test -n "$acl_hardcode_libdir_separator"; then
 
683
            dnl Weird platform: only the last -rpath option counts, the user
 
684
            dnl must pass all path elements in one option.
 
685
            alldirs=
 
686
            for dir in $rpathdirs; do
 
687
              alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir"
 
688
            done
 
689
            acl_save_libdir="$libdir"
 
690
            libdir="$alldirs"
 
691
            eval flag=\"$acl_hardcode_libdir_flag_spec\"
 
692
            libdir="$acl_save_libdir"
 
693
            $1="$flag"
 
694
          else
 
695
            dnl The -rpath options are cumulative.
 
696
            for dir in $rpathdirs; do
 
697
              acl_save_libdir="$libdir"
 
698
              libdir="$dir"
 
699
              eval flag=\"$acl_hardcode_libdir_flag_spec\"
 
700
              libdir="$acl_save_libdir"
 
701
              $1="${$1}${$1:+ }$flag"
 
702
            done
 
703
          fi
 
704
        fi
 
705
      fi
 
706
    fi
 
707
  fi
 
708
  AC_SUBST([$1])
 
709
])