# lib-link.m4 serial 31

dnl Copyright (C) 2001-2020 Free Software Foundation, Inc.

dnl This file is free software; the Free Software Foundation

dnl gives unlimited permission to copy and/or distribute it,

dnl with or without modifications, as long as this notice is preserved.

dnl From Bruno Haible.

AC_PREREQ([2.61])

dnl AC_LIB_LINKFLAGS(name [, dependencies]) searches for libname and

dnl the libraries corresponding to explicit and implicit dependencies.

dnl Sets and AC_SUBSTs the LIB${NAME} and LTLIB${NAME} variables and

dnl augments the CPPFLAGS variable.

dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname

dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.

AC_DEFUN([AC_LIB_LINKFLAGS],

[

  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])

  AC_REQUIRE([AC_LIB_RPATH])

  pushdef([Name],[m4_translit([$1],[./+-], [____])])

  pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-],

                                   [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])

  AC_CACHE_CHECK([how to link with lib[]$1], [ac_cv_lib[]Name[]_libs], [

    AC_LIB_LINKFLAGS_BODY([$1], [$2])

    ac_cv_lib[]Name[]_libs="$LIB[]NAME"

    ac_cv_lib[]Name[]_ltlibs="$LTLIB[]NAME"

    ac_cv_lib[]Name[]_cppflags="$INC[]NAME"

    ac_cv_lib[]Name[]_prefix="$LIB[]NAME[]_PREFIX"

  ])

  LIB[]NAME="$ac_cv_lib[]Name[]_libs"

  LTLIB[]NAME="$ac_cv_lib[]Name[]_ltlibs"

  INC[]NAME="$ac_cv_lib[]Name[]_cppflags"

  LIB[]NAME[]_PREFIX="$ac_cv_lib[]Name[]_prefix"

  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)

  AC_SUBST([LIB]NAME)

  AC_SUBST([LTLIB]NAME)

  AC_SUBST([LIB]NAME[_PREFIX])

  dnl Also set HAVE_LIB[]NAME so that AC_LIB_HAVE_LINKFLAGS can reuse the

  dnl results of this search when this library appears as a dependency.

  HAVE_LIB[]NAME=yes

  popdef([NAME])

  popdef([Name])

])

dnl AC_LIB_HAVE_LINKFLAGS(name, dependencies, includes, testcode, [missing-message])

dnl searches for libname and the libraries corresponding to explicit and

dnl implicit dependencies, together with the specified include files and

dnl the ability to compile and link the specified testcode. The missing-message

dnl defaults to 'no' and may contain additional hints for the user.

dnl If found, it sets and AC_SUBSTs HAVE_LIB${NAME}=yes and the LIB${NAME}

dnl and LTLIB${NAME} variables and augments the CPPFLAGS variable, and

dnl #defines HAVE_LIB${NAME} to 1. Otherwise, it sets and AC_SUBSTs

dnl HAVE_LIB${NAME}=no and LIB${NAME} and LTLIB${NAME} to empty.

dnl Sets and AC_SUBSTs the LIB${NAME}_PREFIX variable to nonempty if libname

dnl was found in ${LIB${NAME}_PREFIX}/$acl_libdirstem.

AC_DEFUN([AC_LIB_HAVE_LINKFLAGS],

[

  AC_REQUIRE([AC_LIB_PREPARE_PREFIX])

  AC_REQUIRE([AC_LIB_RPATH])

  pushdef([Name],[m4_translit([$1],[./+-], [____])])

  pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-],

                                   [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])

  dnl Search for lib[]Name and define LIB[]NAME, LTLIB[]NAME and INC[]NAME

  dnl accordingly.

  AC_LIB_LINKFLAGS_BODY([$1], [$2])

  dnl Add $INC[]NAME to CPPFLAGS before performing the following checks,

  dnl because if the user has installed lib[]Name and not disabled its use

  dnl via --without-lib[]Name-prefix, he wants to use it.

  ac_save_CPPFLAGS="$CPPFLAGS"

  AC_LIB_APPENDTOVAR([CPPFLAGS], [$INC]NAME)

  AC_CACHE_CHECK([for lib[]$1], [ac_cv_lib[]Name], [

    ac_save_LIBS="$LIBS"

    dnl If $LIB[]NAME contains some -l options, add it to the end of LIBS,

    dnl because these -l options might require -L options that are present in

    dnl LIBS. -l options benefit only from the -L options listed before it.

    dnl Otherwise, add it to the front of LIBS, because it may be a static

    dnl library that depends on another static library that is present in LIBS.

    dnl Static libraries benefit only from the static libraries listed after

    dnl it.

    case " $LIB[]NAME" in

      *" -l"*) LIBS="$LIBS $LIB[]NAME" ;;

      *)       LIBS="$LIB[]NAME $LIBS" ;;

    esac

    AC_LINK_IFELSE(

      [AC_LANG_PROGRAM([[$3]], [[$4]])],

      [ac_cv_lib[]Name=yes],

      [ac_cv_lib[]Name='m4_if([$5], [], [no], [[$5]])'])

    LIBS="$ac_save_LIBS"

  ])

  if test "$ac_cv_lib[]Name" = yes; then

    HAVE_LIB[]NAME=yes

    AC_DEFINE([HAVE_LIB]NAME, 1, [Define if you have the lib][$1 library.])

    AC_MSG_CHECKING([how to link with lib[]$1])

    AC_MSG_RESULT([$LIB[]NAME])

  else

    HAVE_LIB[]NAME=no

    dnl If $LIB[]NAME didn't lead to a usable library, we don't need

    dnl $INC[]NAME either.

    CPPFLAGS="$ac_save_CPPFLAGS"

    LIB[]NAME=

    LTLIB[]NAME=

    LIB[]NAME[]_PREFIX=

  fi

  AC_SUBST([HAVE_LIB]NAME)

  AC_SUBST([LIB]NAME)

  AC_SUBST([LTLIB]NAME)

  AC_SUBST([LIB]NAME[_PREFIX])

  popdef([NAME])

  popdef([Name])

])

dnl Determine the platform dependent parameters needed to use rpath:

dnl   acl_libext,

dnl   acl_shlibext,

dnl   acl_libname_spec,

dnl   acl_library_names_spec,

dnl   acl_hardcode_libdir_flag_spec,

dnl   acl_hardcode_libdir_separator,

dnl   acl_hardcode_direct,

dnl   acl_hardcode_minus_L.

AC_DEFUN([AC_LIB_RPATH],

[

  dnl Complain if config.rpath is missing.

  AC_REQUIRE_AUX_FILE([config.rpath])

  AC_REQUIRE([AC_PROG_CC])                dnl we use $CC, $GCC, $LDFLAGS

  AC_REQUIRE([AC_LIB_PROG_LD])            dnl we use $LD, $with_gnu_ld

  AC_REQUIRE([AC_CANONICAL_HOST])         dnl we use $host

  AC_REQUIRE([AC_CONFIG_AUX_DIR_DEFAULT]) dnl we use $ac_aux_dir

  AC_CACHE_CHECK([for shared library run path origin], [acl_cv_rpath], [

    CC="$CC" GCC="$GCC" LDFLAGS="$LDFLAGS" LD="$LD" with_gnu_ld="$with_gnu_ld" \

    ${CONFIG_SHELL-/bin/sh} "$ac_aux_dir/config.rpath" "$host" > conftest.sh

    . ./conftest.sh

    rm -f ./conftest.sh

    acl_cv_rpath=done

  ])

  wl="$acl_cv_wl"

  acl_libext="$acl_cv_libext"

  acl_shlibext="$acl_cv_shlibext"

  acl_libname_spec="$acl_cv_libname_spec"

  acl_library_names_spec="$acl_cv_library_names_spec"

  acl_hardcode_libdir_flag_spec="$acl_cv_hardcode_libdir_flag_spec"

  acl_hardcode_libdir_separator="$acl_cv_hardcode_libdir_separator"

  acl_hardcode_direct="$acl_cv_hardcode_direct"

  acl_hardcode_minus_L="$acl_cv_hardcode_minus_L"

  dnl Determine whether the user wants rpath handling at all.

  AC_ARG_ENABLE([rpath],

    [  --disable-rpath         do not hardcode runtime library paths],

    :, enable_rpath=yes)

])

dnl AC_LIB_FROMPACKAGE(name, package)

dnl declares that libname comes from the given package. The configure file

dnl will then not have a --with-libname-prefix option but a

dnl --with-package-prefix option. Several libraries can come from the same

dnl package. This declaration must occur before an AC_LIB_LINKFLAGS or similar

dnl macro call that searches for libname.

AC_DEFUN([AC_LIB_FROMPACKAGE],

[

  pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-],

                                   [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])

  define([acl_frompackage_]NAME, [$2])

  popdef([NAME])

  pushdef([PACK],[$2])

  pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-],

                                     [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])

  define([acl_libsinpackage_]PACKUP,

    m4_ifdef([acl_libsinpackage_]PACKUP, [m4_defn([acl_libsinpackage_]PACKUP)[, ]],)[lib$1])

  popdef([PACKUP])

  popdef([PACK])

])

dnl AC_LIB_LINKFLAGS_BODY(name [, dependencies]) searches for libname and

dnl the libraries corresponding to explicit and implicit dependencies.

dnl Sets the LIB${NAME}, LTLIB${NAME} and INC${NAME} variables.

dnl Also, sets the LIB${NAME}_PREFIX variable to nonempty if libname was found

dnl in ${LIB${NAME}_PREFIX}/$acl_libdirstem.

AC_DEFUN([AC_LIB_LINKFLAGS_BODY],

[

  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])

  pushdef([NAME],[m4_translit([$1],[abcdefghijklmnopqrstuvwxyz./+-],

                                   [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])

  pushdef([PACK],[m4_ifdef([acl_frompackage_]NAME, [acl_frompackage_]NAME, lib[$1])])

  pushdef([PACKUP],[m4_translit(PACK,[abcdefghijklmnopqrstuvwxyz./+-],

                                     [ABCDEFGHIJKLMNOPQRSTUVWXYZ____])])

  pushdef([PACKLIBS],[m4_ifdef([acl_frompackage_]NAME, [acl_libsinpackage_]PACKUP, lib[$1])])

  dnl By default, look in $includedir and $libdir.

  use_additional=yes

  AC_LIB_WITH_FINAL_PREFIX([

    eval additional_includedir=\"$includedir\"

    eval additional_libdir=\"$libdir\"

    eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\"

    eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\"

  ])

  AC_ARG_WITH(PACK[-prefix],

[[  --with-]]PACK[[-prefix[=DIR]  search for ]PACKLIBS[ in DIR/include and DIR/lib

  --without-]]PACK[[-prefix     don't search for ]PACKLIBS[ in includedir and libdir]],

[

    if test "X$withval" = "Xno"; then

      use_additional=no

    else

      if test "X$withval" = "X"; then

        AC_LIB_WITH_FINAL_PREFIX([

          eval additional_includedir=\"$includedir\"

          eval additional_libdir=\"$libdir\"

          eval additional_libdir2=\"$exec_prefix/$acl_libdirstem2\"

          eval additional_libdir3=\"$exec_prefix/$acl_libdirstem3\"

        ])

      else

        additional_includedir="$withval/include"

        additional_libdir="$withval/$acl_libdirstem"

        additional_libdir2="$withval/$acl_libdirstem2"

        additional_libdir3="$withval/$acl_libdirstem3"

      fi

    fi

])

  if test "X$additional_libdir2" = "X$additional_libdir"; then

    additional_libdir2=

  fi

  if test "X$additional_libdir3" = "X$additional_libdir"; then

    additional_libdir3=

  fi

  dnl Search the library and its dependencies in $additional_libdir and

  dnl $LDFLAGS. Using breadth-first-seach.

  LIB[]NAME=

  LTLIB[]NAME=

  INC[]NAME=

  LIB[]NAME[]_PREFIX=

  dnl HAVE_LIB${NAME} is an indicator that LIB${NAME}, LTLIB${NAME} have been

  dnl computed. So it has to be reset here.

  HAVE_LIB[]NAME=

  rpathdirs=

  ltrpathdirs=

  names_already_handled=

  names_next_round='$1 $2'

  while test -n "$names_next_round"; do

    names_this_round="$names_next_round"

    names_next_round=

    for name in $names_this_round; do

      already_handled=

      for n in $names_already_handled; do

        if test "$n" = "$name"; then

          already_handled=yes

          break

        fi

      done

      if test -z "$already_handled"; then

        names_already_handled="$names_already_handled $name"

        dnl See if it was already located by an earlier AC_LIB_LINKFLAGS

        dnl or AC_LIB_HAVE_LINKFLAGS call.

        uppername=`echo "$name" | sed -e 'y|abcdefghijklmnopqrstuvwxyz./+-|ABCDEFGHIJKLMNOPQRSTUVWXYZ____|'`

        eval value=\"\$HAVE_LIB$uppername\"

        if test -n "$value"; then

          if test "$value" = yes; then

            eval value=\"\$LIB$uppername\"

            test -z "$value" || LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$value"

            eval value=\"\$LTLIB$uppername\"

            test -z "$value" || LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$value"

          else

            dnl An earlier call to AC_LIB_HAVE_LINKFLAGS has determined

            dnl that this library doesn't exist. So just drop it.

            :

          fi

        else

          dnl Search the library lib$name in $additional_libdir and $LDFLAGS

          dnl and the already constructed $LIBNAME/$LTLIBNAME.

          found_dir=

          found_la=

          found_so=

          found_a=

          eval libname=\"$acl_libname_spec\"    # typically: libname=lib$name

          if test -n "$acl_shlibext"; then

            shrext=".$acl_shlibext"             # typically: shrext=.so

          else

            shrext=

          fi

          if test $use_additional = yes; then

            for additional_libdir_variable in additional_libdir additional_libdir2 additional_libdir3; do

              if test "X$found_dir" = "X"; then

                eval dir=\$$additional_libdir_variable

                if test -n "$dir"; then

                  dnl The same code as in the loop below:

                  dnl First look for a shared library.

                  if test -n "$acl_shlibext"; then

                    if test -f "$dir/$libname$shrext" && acl_is_expected_elfclass < "$dir/$libname$shrext"; then

                      found_dir="$dir"

                      found_so="$dir/$libname$shrext"

                    else

                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then

                        ver=`(cd "$dir" && \

                              for f in "$libname$shrext".*; do echo "$f"; done \

                              | sed -e "s,^$libname$shrext\\\\.,," \

                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \

                              | sed 1q ) 2>/dev/null`

                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver" && acl_is_expected_elfclass < "$dir/$libname$shrext.$ver"; then

                          found_dir="$dir"

                          found_so="$dir/$libname$shrext.$ver"

                        fi

                      else

                        eval library_names=\"$acl_library_names_spec\"

                        for f in $library_names; do

                          if test -f "$dir/$f" && acl_is_expected_elfclass < "$dir/$f"; then

                            found_dir="$dir"

                            found_so="$dir/$f"

                            break

                          fi

                        done

                      fi

                    fi

                  fi

                  dnl Then look for a static library.

                  if test "X$found_dir" = "X"; then

                    if test -f "$dir/$libname.$acl_libext" && ${AR-ar} -p "$dir/$libname.$acl_libext" | acl_is_expected_elfclass; then

                      found_dir="$dir"

                      found_a="$dir/$libname.$acl_libext"

                    fi

                  fi

                  if test "X$found_dir" != "X"; then

                    if test -f "$dir/$libname.la"; then

                      found_la="$dir/$libname.la"

                    fi

                  fi

                fi

              fi

            done

          fi

          if test "X$found_dir" = "X"; then

            for x in $LDFLAGS $LTLIB[]NAME; do

              AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

              case "$x" in

                -L*)

                  dir=`echo "X$x" | sed -e 's/^X-L//'`

                  dnl First look for a shared library.

                  if test -n "$acl_shlibext"; then

                    if test -f "$dir/$libname$shrext" && acl_is_expected_elfclass < "$dir/$libname$shrext"; then

                      found_dir="$dir"

                      found_so="$dir/$libname$shrext"

                    else

                      if test "$acl_library_names_spec" = '$libname$shrext$versuffix'; then

                        ver=`(cd "$dir" && \

                              for f in "$libname$shrext".*; do echo "$f"; done \

                              | sed -e "s,^$libname$shrext\\\\.,," \

                              | sort -t '.' -n -r -k1,1 -k2,2 -k3,3 -k4,4 -k5,5 \

                              | sed 1q ) 2>/dev/null`

                        if test -n "$ver" && test -f "$dir/$libname$shrext.$ver" && acl_is_expected_elfclass < "$dir/$libname$shrext.$ver"; then

                          found_dir="$dir"

                          found_so="$dir/$libname$shrext.$ver"

                        fi

                      else

                        eval library_names=\"$acl_library_names_spec\"

                        for f in $library_names; do

                          if test -f "$dir/$f" && acl_is_expected_elfclass < "$dir/$f"; then

                            found_dir="$dir"

                            found_so="$dir/$f"

                            break

                          fi

                        done

                      fi

                    fi

                  fi

                  dnl Then look for a static library.

                  if test "X$found_dir" = "X"; then

                    if test -f "$dir/$libname.$acl_libext" && ${AR-ar} -p "$dir/$libname.$acl_libext" | acl_is_expected_elfclass; then

                      found_dir="$dir"

                      found_a="$dir/$libname.$acl_libext"

                    fi

                  fi

                  if test "X$found_dir" != "X"; then

                    if test -f "$dir/$libname.la"; then

                      found_la="$dir/$libname.la"

                    fi

                  fi

                  ;;

              esac

              if test "X$found_dir" != "X"; then

                break

              fi

            done

          fi

          if test "X$found_dir" != "X"; then

            dnl Found the library.

            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$found_dir -l$name"

            if test "X$found_so" != "X"; then

              dnl Linking with a shared library. We attempt to hardcode its

              dnl directory into the executable's runpath, unless it's the

              dnl standard /usr/lib.

              if test "$enable_rpath" = no \

                 || test "X$found_dir" = "X/usr/$acl_libdirstem" \

                 || test "X$found_dir" = "X/usr/$acl_libdirstem2" \

                 || test "X$found_dir" = "X/usr/$acl_libdirstem3"; then

                dnl No hardcoding is needed.

                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"

              else

                dnl Use an explicit option to hardcode DIR into the resulting

                dnl binary.

                dnl Potentially add DIR to ltrpathdirs.

                dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.

                haveit=

                for x in $ltrpathdirs; do

                  if test "X$x" = "X$found_dir"; then

                    haveit=yes

                    break

                  fi

                done

                if test -z "$haveit"; then

                  ltrpathdirs="$ltrpathdirs $found_dir"

                fi

                dnl The hardcoding into $LIBNAME is system dependent.

                if test "$acl_hardcode_direct" = yes; then

                  dnl Using DIR/libNAME.so during linking hardcodes DIR into the

                  dnl resulting binary.

                  LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"

                else

                  if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then

                    dnl Use an explicit option to hardcode DIR into the resulting

                    dnl binary.

                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"

                    dnl Potentially add DIR to rpathdirs.

                    dnl The rpathdirs will be appended to $LIBNAME at the end.

                    haveit=

                    for x in $rpathdirs; do

                      if test "X$x" = "X$found_dir"; then

                        haveit=yes

                        break

                      fi

                    done

                    if test -z "$haveit"; then

                      rpathdirs="$rpathdirs $found_dir"

                    fi

                  else

                    dnl Rely on "-L$found_dir".

                    dnl But don't add it if it's already contained in the LDFLAGS

                    dnl or the already constructed $LIBNAME

                    haveit=

                    for x in $LDFLAGS $LIB[]NAME; do

                      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

                      if test "X$x" = "X-L$found_dir"; then

                        haveit=yes

                        break

                      fi

                    done

                    if test -z "$haveit"; then

                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir"

                    fi

                    if test "$acl_hardcode_minus_L" != no; then

                      dnl FIXME: Not sure whether we should use

                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"

                      dnl here.

                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_so"

                    else

                      dnl We cannot use $acl_hardcode_runpath_var and LD_RUN_PATH

                      dnl here, because this doesn't fit in flags passed to the

                      dnl compiler. So give up. No hardcoding. This affects only

                      dnl very old systems.

                      dnl FIXME: Not sure whether we should use

                      dnl "-L$found_dir -l$name" or "-L$found_dir $found_so"

                      dnl here.

                      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"

                    fi

                  fi

                fi

              fi

            else

              if test "X$found_a" != "X"; then

                dnl Linking with a static library.

                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$found_a"

              else

                dnl We shouldn't come here, but anyway it's good to have a

                dnl fallback.

                LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$found_dir -l$name"

              fi

            fi

            dnl Assume the include files are nearby.

            additional_includedir=

            case "$found_dir" in

              */$acl_libdirstem | */$acl_libdirstem/)

                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem/"'*$,,'`

                if test "$name" = '$1'; then

                  LIB[]NAME[]_PREFIX="$basedir"

                fi

                additional_includedir="$basedir/include"

                ;;

              */$acl_libdirstem2 | */$acl_libdirstem2/)

                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem2/"'*$,,'`

                if test "$name" = '$1'; then

                  LIB[]NAME[]_PREFIX="$basedir"

                fi

                additional_includedir="$basedir/include"

                ;;

              */$acl_libdirstem3 | */$acl_libdirstem3/)

                basedir=`echo "X$found_dir" | sed -e 's,^X,,' -e "s,/$acl_libdirstem3/"'*$,,'`

                if test "$name" = '$1'; then

                  LIB[]NAME[]_PREFIX="$basedir"

                fi

                additional_includedir="$basedir/include"

                ;;

            esac

            if test "X$additional_includedir" != "X"; then

              dnl Potentially add $additional_includedir to $INCNAME.

              dnl But don't add it

              dnl   1. if it's the standard /usr/include,

              dnl   2. if it's /usr/local/include and we are using GCC on Linux,

              dnl   3. if it's already present in $CPPFLAGS or the already

              dnl      constructed $INCNAME,

              dnl   4. if it doesn't exist as a directory.

              if test "X$additional_includedir" != "X/usr/include"; then

                haveit=

                if test "X$additional_includedir" = "X/usr/local/include"; then

                  if test -n "$GCC"; then

                    case $host_os in

                      linux* | gnu* | k*bsd*-gnu) haveit=yes;;

                    esac

                  fi

                fi

                if test -z "$haveit"; then

                  for x in $CPPFLAGS $INC[]NAME; do

                    AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

                    if test "X$x" = "X-I$additional_includedir"; then

                      haveit=yes

                      break

                    fi

                  done

                  if test -z "$haveit"; then

                    if test -d "$additional_includedir"; then

                      dnl Really add $additional_includedir to $INCNAME.

                      INC[]NAME="${INC[]NAME}${INC[]NAME:+ }-I$additional_includedir"

                    fi

                  fi

                fi

              fi

            fi

            dnl Look for dependencies.

            if test -n "$found_la"; then

              dnl Read the .la file. It defines the variables

              dnl dlname, library_names, old_library, dependency_libs, current,

              dnl age, revision, installed, dlopen, dlpreopen, libdir.

              save_libdir="$libdir"

              case "$found_la" in

                */* | *\\*) . "$found_la" ;;

                *) . "./$found_la" ;;

              esac

              libdir="$save_libdir"

              dnl We use only dependency_libs.

              for dep in $dependency_libs; do

                case "$dep" in

                  -L*)

                    dependency_libdir=`echo "X$dep" | sed -e 's/^X-L//'`

                    dnl Potentially add $dependency_libdir to $LIBNAME and $LTLIBNAME.

                    dnl But don't add it

                    dnl   1. if it's the standard /usr/lib,

                    dnl   2. if it's /usr/local/lib and we are using GCC on Linux,

                    dnl   3. if it's already present in $LDFLAGS or the already

                    dnl      constructed $LIBNAME,

                    dnl   4. if it doesn't exist as a directory.

                    if test "X$dependency_libdir" != "X/usr/$acl_libdirstem" \

                       && test "X$dependency_libdir" != "X/usr/$acl_libdirstem2" \

                       && test "X$dependency_libdir" != "X/usr/$acl_libdirstem3"; then

                      haveit=

                      if test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem" \

                         || test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem2" \

                         || test "X$dependency_libdir" = "X/usr/local/$acl_libdirstem3"; then

                        if test -n "$GCC"; then

                          case $host_os in

                            linux* | gnu* | k*bsd*-gnu) haveit=yes;;

                          esac

                        fi

                      fi

                      if test -z "$haveit"; then

                        haveit=

                        for x in $LDFLAGS $LIB[]NAME; do

                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

                          if test "X$x" = "X-L$dependency_libdir"; then

                            haveit=yes

                            break

                          fi

                        done

                        if test -z "$haveit"; then

                          if test -d "$dependency_libdir"; then

                            dnl Really add $dependency_libdir to $LIBNAME.

                            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-L$dependency_libdir"

                          fi

                        fi

                        haveit=

                        for x in $LDFLAGS $LTLIB[]NAME; do

                          AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

                          if test "X$x" = "X-L$dependency_libdir"; then

                            haveit=yes

                            break

                          fi

                        done

                        if test -z "$haveit"; then

                          if test -d "$dependency_libdir"; then

                            dnl Really add $dependency_libdir to $LTLIBNAME.

                            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-L$dependency_libdir"

                          fi

                        fi

                      fi

                    fi

                    ;;

                  -R*)

                    dir=`echo "X$dep" | sed -e 's/^X-R//'`

                    if test "$enable_rpath" != no; then

                      dnl Potentially add DIR to rpathdirs.

                      dnl The rpathdirs will be appended to $LIBNAME at the end.

                      haveit=

                      for x in $rpathdirs; do

                        if test "X$x" = "X$dir"; then

                          haveit=yes

                          break

                        fi

                      done

                      if test -z "$haveit"; then

                        rpathdirs="$rpathdirs $dir"

                      fi

                      dnl Potentially add DIR to ltrpathdirs.

                      dnl The ltrpathdirs will be appended to $LTLIBNAME at the end.

                      haveit=

                      for x in $ltrpathdirs; do

                        if test "X$x" = "X$dir"; then

                          haveit=yes

                          break

                        fi

                      done

                      if test -z "$haveit"; then

                        ltrpathdirs="$ltrpathdirs $dir"

                      fi

                    fi

                    ;;

                  -l*)

                    dnl Handle this in the next round.

                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's/^X-l//'`

                    ;;

                  *.la)

                    dnl Handle this in the next round. Throw away the .la's

                    dnl directory; it is already contained in a preceding -L

                    dnl option.

                    names_next_round="$names_next_round "`echo "X$dep" | sed -e 's,^X.*/,,' -e 's,^lib,,' -e 's,\.la$,,'`

                    ;;

                  *)

                    dnl Most likely an immediate library name.

                    LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$dep"

                    LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }$dep"

                    ;;

                esac

              done

            fi

          else

            dnl Didn't find the library; assume it is in the system directories

            dnl known to the linker and runtime loader. (All the system

            dnl directories known to the linker should also be known to the

            dnl runtime loader, otherwise the system is severely misconfigured.)

            LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }-l$name"

            LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-l$name"

          fi

        fi

      fi

    done

  done

  if test "X$rpathdirs" != "X"; then

    if test -n "$acl_hardcode_libdir_separator"; then

      dnl Weird platform: only the last -rpath option counts, the user must

      dnl pass all path elements in one option. We can arrange that for a

      dnl single library, but not when more than one $LIBNAMEs are used.

      alldirs=

      for found_dir in $rpathdirs; do

        alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$found_dir"

      done

      dnl Note: acl_hardcode_libdir_flag_spec uses $libdir and $wl.

      acl_save_libdir="$libdir"

      libdir="$alldirs"

      eval flag=\"$acl_hardcode_libdir_flag_spec\"

      libdir="$acl_save_libdir"

      LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"

    else

      dnl The -rpath options are cumulative.

      for found_dir in $rpathdirs; do

        acl_save_libdir="$libdir"

        libdir="$found_dir"

        eval flag=\"$acl_hardcode_libdir_flag_spec\"

        libdir="$acl_save_libdir"

        LIB[]NAME="${LIB[]NAME}${LIB[]NAME:+ }$flag"

      done

    fi

  fi

  if test "X$ltrpathdirs" != "X"; then

    dnl When using libtool, the option that works for both libraries and

    dnl executables is -R. The -R options are cumulative.

    for found_dir in $ltrpathdirs; do

      LTLIB[]NAME="${LTLIB[]NAME}${LTLIB[]NAME:+ }-R$found_dir"

    done

  fi

  popdef([PACKLIBS])

  popdef([PACKUP])

  popdef([PACK])

  popdef([NAME])

])

dnl AC_LIB_APPENDTOVAR(VAR, CONTENTS) appends the elements of CONTENTS to VAR,

dnl unless already present in VAR.

dnl Works only for CPPFLAGS, not for LIB* variables because that sometimes

dnl contains two or three consecutive elements that belong together.

AC_DEFUN([AC_LIB_APPENDTOVAR],

[

  for element in [$2]; do

    haveit=

    for x in $[$1]; do

      AC_LIB_WITH_FINAL_PREFIX([eval x=\"$x\"])

      if test "X$x" = "X$element"; then

        haveit=yes

        break

      fi

    done

    if test -z "$haveit"; then

      [$1]="${[$1]}${[$1]:+ }$element"

    fi

  done

])

dnl For those cases where a variable contains several -L and -l options

dnl referring to unknown libraries and directories, this macro determines the

dnl necessary additional linker options for the runtime path.

dnl AC_LIB_LINKFLAGS_FROM_LIBS([LDADDVAR], [LIBSVALUE], [USE-LIBTOOL])

dnl sets LDADDVAR to linker options needed together with LIBSVALUE.

dnl If USE-LIBTOOL evaluates to non-empty, linking with libtool is assumed,

dnl otherwise linking without libtool is assumed.

AC_DEFUN([AC_LIB_LINKFLAGS_FROM_LIBS],

[

  AC_REQUIRE([AC_LIB_RPATH])

  AC_REQUIRE([AC_LIB_PREPARE_MULTILIB])

  $1=

  if test "$enable_rpath" != no; then

    if test -n "$acl_hardcode_libdir_flag_spec" && test "$acl_hardcode_minus_L" = no; then

      dnl Use an explicit option to hardcode directories into the resulting

      dnl binary.

      rpathdirs=

      next=

      for opt in $2; do

        if test -n "$next"; then

          dir="$next"

          dnl No need to hardcode the standard /usr/lib.

          if test "X$dir" != "X/usr/$acl_libdirstem" \

             && test "X$dir" != "X/usr/$acl_libdirstem2" \

             && test "X$dir" != "X/usr/$acl_libdirstem3"; then

            rpathdirs="$rpathdirs $dir"

          fi

          next=

        else

          case $opt in

            -L) next=yes ;;

            -L*) dir=`echo "X$opt" | sed -e 's,^X-L,,'`

                 dnl No need to hardcode the standard /usr/lib.

                 if test "X$dir" != "X/usr/$acl_libdirstem" \

                    && test "X$dir" != "X/usr/$acl_libdirstem2" \

                    && test "X$dir" != "X/usr/$acl_libdirstem3"; then

                   rpathdirs="$rpathdirs $dir"

                 fi

                 next= ;;

            *) next= ;;

          esac

        fi

      done

      if test "X$rpathdirs" != "X"; then

        if test -n ""$3""; then

          dnl libtool is used for linking. Use -R options.

          for dir in $rpathdirs; do

            $1="${$1}${$1:+ }-R$dir"

          done

        else

          dnl The linker is used for linking directly.

          if test -n "$acl_hardcode_libdir_separator"; then

            dnl Weird platform: only the last -rpath option counts, the user

            dnl must pass all path elements in one option.

            alldirs=

            for dir in $rpathdirs; do

              alldirs="${alldirs}${alldirs:+$acl_hardcode_libdir_separator}$dir"

            done

            acl_save_libdir="$libdir"

            libdir="$alldirs"

            eval flag=\"$acl_hardcode_libdir_flag_spec\"

            libdir="$acl_save_libdir"

            $1="$flag"

          else

            dnl The -rpath options are cumulative.

            for dir in $rpathdirs; do

              acl_save_libdir="$libdir"

              libdir="$dir"

              eval flag=\"$acl_hardcode_libdir_flag_spec\"

              libdir="$acl_save_libdir"

              $1="${$1}${$1:+ }$flag"

            done

          fi

        fi

      fi

    fi

  fi

  AC_SUBST([$1])

])