acinclude.m4

dnl $Id: acinclude.m4,v 1.10 2010/02/15 14:51:50 fredette Exp $

dnl acinclude.m4 - additional tme autoconf macros:

dnl Copyright (c) 2001, 2003, 2004 Matt Fredette
dnl All rights reserved.
dnl
dnl Redistribution and use in source and binary forms, with or without
dnl modification, are permitted provided that the following conditions
dnl are met:
dnl 1. Redistributions of source code must retain the above copyright
dnl    notice, this list of conditions and the following disclaimer.
dnl 2. Redistributions in binary form must reproduce the above copyright
dnl    notice, this list of conditions and the following disclaimer in the
dnl    documentation and/or other materials provided with the distribution.
dnl 3. All advertising materials mentioning features or use of this software
dnl    must display the following acknowledgement:
dnl      This product includes software developed by Matt Fredette.
dnl 4. The name of the author may not be used to endorse or promote products
dnl    derived from this software without specific prior written permission.
dnl
dnl THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
dnl IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
dnl WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
dnl DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT,
dnl INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
dnl (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
dnl SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
dnl HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
dnl STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
dnl ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
dnl POSSIBILITY OF SUCH DAMAGE.

dnl AC_CHECK_ALIGNOF(BITS)
AC_DEFUN([AC_CHECK_ALIGNOF],
[changequote(<<, >>)dnl
dnl The name to #define.
define(<<AC_TYPE_NAME>>, translit(alignof_int$1_t, [a-z *], [A-Z_P]))dnl
dnl The cache variable name.
define(<<AC_CV_NAME>>, translit(ac_cv_alignof_int$1_t, [ *], [_p]))dnl
changequote([, ])dnl
AC_MSG_CHECKING(minimum alignment of int$1_t)
AC_CACHE_VAL(AC_CV_NAME,
[AC_TRY_RUN([#include <stdio.h>
#include <sys/types.h>
main()
{
#if (SIZEOF_SHORT * 8) == $1
#define _type short
#elif (SIZEOF_INT * 8) == $1
#define _type int
#else
#define _type long
#endif
  char try_align_buffer[sizeof(_type) * 2];
  int min_align, try_align, status;
  _type value;
  FILE *f=fopen("conftestval", "w");
  if (!f) exit(1);
  min_align = sizeof(_type);
  for(try_align = sizeof(_type); try_align-- > 1;) {
    switch(fork()) {
    case -1: exit(1);
    case 0: value = *((_type *) &try_align_buffer[try_align]); 
      fprintf(stderr, "%d\n", (int) (value / 2)); exit(0);
    default: break;
    }
    wait(&status);
    if (!status && try_align < min_align) {
      min_align = try_align;
    }
  }
  fprintf(f, "%d\n", min_align * 8);
  exit(0);
}], AC_CV_NAME=`cat conftestval`, AC_CV_NAME=$1, AC_CV_NAME=$1)])dnl
AC_CV_NAME=`expr $AC_CV_NAME / 8`
AC_MSG_RESULT($AC_CV_NAME)
AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [Define to the minimum alignment, in bytes, of int$1_t.])
undefine([AC_TYPE_NAME])dnl
undefine([AC_CV_NAME])dnl
])

dnl AC_CHECK_SHIFTMAX(BITS)
AC_DEFUN([AC_CHECK_SHIFTMAX],
[changequote(<<, >>)dnl
dnl The name to #define.
define(<<AC_TYPE_NAME>>, translit(shiftmax_int$1_t, [a-z *], [A-Z_P]))dnl
dnl The cache variable name.
define(<<AC_CV_NAME>>, translit(ac_cv_shiftmax_int$1_t, [ *], [_p]))dnl
changequote([, ])dnl
AC_MSG_CHECKING(maximum shift count for int$1_t)
AC_CACHE_VAL(AC_CV_NAME,
[AC_TRY_RUN([#include <stdio.h>
#include <sys/types.h>
main()
{
#if 8 == $1
#define _type char
#elif (SIZEOF_SHORT * 8) == $1
#define _type short
#elif (SIZEOF_INT * 8) == $1
#define _type int
#elif (SIZEOF_LONG * 8) == $1
#define _type long
#endif
  _type center, right, left;
  unsigned int shift, max_shift;
  FILE *f=fopen("conftestval", "w");
  if (!f) exit(1);
  center = 3;
  center <<= ((sizeof(center) * 4) - 1);
  max_shift = 2047;
  sscanf("0", "%d", &shift);
  for (shift += (sizeof(center) * 8);
       shift < 2048;
       shift <<= 1) {
    right = (center >> shift);
    left = (center << shift);
    if (right != 0
	|| left != 0) {
      right = (center >> (shift | 1));
      left = (center << (shift | 1));
      max_shift = ((right == (center >> 1)
		    && left == (center << 1))
		   ? shift - 1
		   : (sizeof(center) * 8) - 1);
      break;
    }
  }
  fprintf(f, "%d\n", max_shift + 1);
  exit(0);
}], AC_CV_NAME=`cat conftestval`, AC_CV_NAME=$1, AC_CV_NAME=$1)])dnl
AC_CV_NAME=`expr $AC_CV_NAME - 1`
AC_MSG_RESULT($AC_CV_NAME)
AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [Define to the maximum shift count for a int$1_t.])
undefine([AC_TYPE_NAME])dnl
undefine([AC_CV_NAME])dnl
])

dnl AC_CHECK_SHIFTSIGNED(BITS)
AC_DEFUN([AC_CHECK_SHIFTSIGNED],
[changequote(<<, >>)dnl
dnl The name to #define.
define(<<AC_TYPE_NAME>>, translit(shiftsigned_int$1_t, [a-z *], [A-Z_P]))dnl
dnl The cache variable name.
define(<<AC_CV_NAME>>, translit(ac_cv_shiftsigned_int$1_t, [ *], [_p]))dnl
changequote([, ])dnl
AC_MSG_CHECKING(for arithmetic right shifts of int$1_t)
AC_CACHE_VAL(AC_CV_NAME,
[AC_TRY_RUN([#include <stdio.h>
#include <sys/types.h>
main()
{
#if 8 == $1
#define _type signed char
#elif (SIZEOF_SHORT * 8) == $1
#define _type signed short
#elif (SIZEOF_INT * 8) == $1
#define _type signed int
#elif (SIZEOF_LONG * 8) == $1
#define _type signed long
#endif
  _type prime, shifted, dividend;
  unsigned int shift, divides;
  FILE *f;

  f=fopen("conftestval", "w");
  if (!f) exit(1);

  /* set value to the largest magnitude negative prime that it 
     will hold: */
#if $1 == 8
  prime = -127;
#elif $1 == 16
  prime = -32749;
#elif $1 == 32
  prime = -2147483647;
#elif $1 == 64
  /* this is a crafty way of constructing -9223372036854775783,
     which is 0x8000000000000000 - 0x19, without having to know 
     any compiler suffix for 64-bit literals: */
  prime = 1;
  prime <<= ($1 - 2);
  prime = -prime;
  prime *= 2;
  prime -= 0x19;
#else
#error "need another prime"
#endif

  /* all right shifts from a single bit up to SHIFTMAX_INT$1_T
     must be arithmetic, otherwise shifts aren't arithmetic: */
  for (shift = 1; 
       shift <= SHIFTMAX_INT$1_T;
       shift++) {
    shifted = prime >> shift;
    dividend = prime;
    divides = 0;
    do {
      dividend &= ~((_type) 1); /* guarantee no remainder */
      dividend /= 2;
    } while (++divides < shift);
    if (shifted != dividend) {
      break;
    }
  }

  fprintf(f, "%d\n", (shift > SHIFTMAX_INT$1_T ? 1 : 0));
  exit(0);
}], AC_CV_NAME=`cat conftestval`, AC_CV_NAME=0, AC_CV_NAME=0)])dnl
if test $AC_CV_NAME = 1; then
  AC_MSG_RESULT(yes)
  AC_DEFINE_UNQUOTED(AC_TYPE_NAME, [], [Define if all right shifts of int$1_t are arithmetic.])
else
  AC_MSG_RESULT(no)
fi
undefine([AC_TYPE_NAME])dnl
undefine([AC_CV_NAME])dnl
])

dnl AC_CHECK_FLOAT_FORMAT(TYPE)
AC_DEFUN([AC_CHECK_FLOAT_FORMAT],
[changequote(<<, >>)dnl
dnl The name to #define.
define(<<AC_TYPE_NAME>>, translit(FLOAT_FORMAT_$1, [a-z *], [A-Z_P]))dnl
dnl The cache variable name.
define(<<AC_CV_NAME>>, translit(ac_cv_float_format_$1, [ *], [_p]))dnl
changequote([, ])dnl
AC_MSG_CHECKING(the floating point format of $1)
AC_CACHE_VAL(AC_CV_NAME,
[AC_TRY_RUN([#include <stdio.h>
#include <sys/types.h>
main()
{
  $1 value;
  unsigned short value_buffer[16];
#ifdef WORDS_BIGENDIAN
#define UINT16_PART(v, i) (value_buffer[(sizeof(v) / sizeof(value_buffer[0])) - ((i) + 1)])
#else
#define UINT16_PART(v, i) (value_buffer[(i)])
#endif

  FILE *f=fopen("conftestval", "w");
  if (!f) exit(1);

  /* see if this type is IEEE754 single precision: */
  value = 3.4793309169e-05;
  memcpy(value_buffer, &value, sizeof(value));
  if (sizeof(value) == 4
      && UINT16_PART(value, 1) == 0x3811
      && UINT16_PART(value, 0) == 0xef08) {
    fprintf(f, "IEEE754_SINGLE\n");
    exit (0);
  }

  /* see if this type is IEEE754 double precision: */
  value = 7.91534994289814532176e-04;
  memcpy(value_buffer, &value, sizeof(value));
  if (sizeof(value) == 8
      && UINT16_PART(value, 3) == 0x3f49
      && UINT16_PART(value, 2) == 0xefe0
      && UINT16_PART(value, 1) == 0x7501
      && UINT16_PART(value, 0) == 0xb288) {
    fprintf(f, "IEEE754_DOUBLE\n");
    exit (0);
  }

  /* see if this type might be IEEE754 extended 80-bit precision: */
  value = 1.1356523406294143949491931077970765006170e+04;
  memcpy(value_buffer, &value, sizeof(value));
  if (sizeof(value) >= 12
      && UINT16_PART(value, 0) == 0x7800
      && UINT16_PART(value, 1) == 0xd1cf
      && UINT16_PART(value, 2) == 0x17f7
      && UINT16_PART(value, 3) == 0xb172) {

    /* check for i387-style IEEE754 extended precision: */
    if (sizeof(value) == 12
	&& UINT16_PART(value, 4) == 0x400c) {
      fprintf(f, "IEEE754_EXTENDED80_I387\n");
      exit (0);
    }

    /* check for m68881-style IEEE754 extended precision: */
    if (sizeof(value) == 12
	&& UINT16_PART(value, 5) == 0x400c) {
      fprintf(f, "IEEE754_EXTENDED80_M68881\n");
      exit (0);
    }
  }

  /* otherwise, this is some native type: */
  fprintf(f, "NATIVE\n");
  exit (0);
}], AC_CV_NAME=`cat conftestval`, AC_CV_NAME=NATIVE, AC_CV_NAME=NATIVE)])dnl
AC_MSG_RESULT($AC_CV_NAME)
if test $AC_CV_NAME != NATIVE; then
  AC_DEFINE_UNQUOTED(AC_TYPE_NAME, $AC_CV_NAME, [Define to the floating point format of a $1.])
fi
undefine([AC_TYPE_NAME])dnl
undefine([AC_CV_NAME])dnl
])

dnl AC_CHECK_FLOAT_LIMITS(TYPE, LIMITS)
AC_DEFUN([AC_CHECK_FLOAT_LIMITS],
[changequote(<<, >>)dnl
dnl The names to #define.
define(<<AC_TYPE_NAME_MAX>>, translit(FLOAT_MAX_$1, [a-z *], [A-Z_P]))dnl
define(<<AC_TYPE_NAME_MIN>>, translit(FLOAT_MIN_$1, [a-z *], [A-Z_P]))dnl
dnl The cache variable name.
define(<<AC_CV_NAME>>, translit(ac_cv_float_limits_$1, [ *], [_p]))dnl
changequote([, ])dnl
AC_MSG_CHECKING(the limits of $1)
AC_CACHE_VAL(AC_CV_NAME,
[for limits in $2; do
  max=`echo $limits | sed -e 's%^\(.*\)/\(.*\)$%\1%'`
  min=`echo $limits | sed -e 's%^\(.*\)/\(.*\)$%\2%'`
  AC_TRY_COMPILE([#include <sys/types.h>
#ifdef HAVE_FLOAT_H
#include <float.h>
#endif
#ifdef HAVE_LIMITS_H
#include <limits.h>
#endif], [ $1 x; x = $max - $min; ], [AC_CV_NAME=$limits ; break], AC_CV_NAME= )
done])
if test "x$AC_CV_NAME" = x; then
  AC_MSG_ERROR(can't determine the limits of $1)
fi
AC_MSG_RESULT($AC_CV_NAME)
max=`echo $AC_CV_NAME | sed -e 's%^\(.*\)/\(.*\)$%\1%'`
min=`echo $AC_CV_NAME | sed -e 's%^\(.*\)/\(.*\)$%\2%'`
AC_DEFINE_UNQUOTED(AC_TYPE_NAME_MAX, ($max), [Define to the maximum value of a $1.])
AC_DEFINE_UNQUOTED(AC_TYPE_NAME_MIN, ($min), [Define to the minimum value of a $1.])
undefine([AC_TYPE_NAME_MAX])dnl
undefine([AC_TYPE_NAME_MIN])dnl
undefine([AC_CV_NAME])dnl
])

dnl AC_CHECK_FUNC_LONG(FUNC, FUNCTION-BODY, [INCLUDES, [LIBRARIES]])
AC_DEFUN([AC_CHECK_FUNC_LONG],
[changequote(<<, >>)dnl
dnl The name to #define.
define(<<AC_FUNC_NAME>>, translit(have_$1, [a-z *], [A-Z_P]))dnl
dnl The cache variable name.
define(<<AC_CV_NAME>>, translit(ac_cv_have_$1, [ *], [_p]))dnl
changequote([, ])dnl
AC_MSG_CHECKING(for $1)
AC_CACHE_VAL(AC_CV_NAME,
[ac_func_long_LIBS=$LIBS
LIBS="${LIBS-} $4"
AC_TRY_LINK([
$3
], [
$2
], AC_CV_NAME=yes, AC_CV_NAME=no)
LIBS=$ac_func_long_LIBS])dnl
AC_MSG_RESULT($AC_CV_NAME)
if test $AC_CV_NAME = yes; then
  AC_DEFINE_UNQUOTED(AC_FUNC_NAME, [], [Define if you have $1().])
fi
undefine([AC_FUNC_NAME])dnl
undefine([AC_CV_NAME])dnl
])

dnl The AC_HEADER_CHECK_PROTOTYPE, AC_HEADER_CHECK_PROTOTYPES,
dnl and AC_SYS_SOCKADDR_SA_LEN macros bear the following copyright:
dnl
dnl Copyright (C) 1997,1998,1999 by the Massachusetts Institute of Technology,
dnl Cambridge, MA, USA.  All Rights Reserved.
dnl
dnl This software is being provided to you, the LICENSEE, by the
dnl Massachusetts Institute of Technology (M.I.T.) under the following
dnl license.  By obtaining, using and/or copying this software, you agree
dnl that you have read, understood, and will comply with these terms and
dnl conditions:
dnl
dnl WITHIN THOSE CONSTRAINTS, permission to use, copy, modify and distribute
dnl this software and its documentation for any purpose and without fee or
dnl royalty is hereby granted, provided that you agree to comply with the
dnl following copyright notice and statements, including the disclaimer, and
dnl that the same appear on ALL copies of the software and documentation,
dnl including modifications that you make for internal use or for
dnl distribution:
dnl
dnl THIS SOFTWARE IS PROVIDED "AS IS", AND M.I.T. MAKES NO REPRESENTATIONS
dnl OR WARRANTIES, EXPRESS OR IMPLIED.  By way of example, but not
dnl limitation, M.I.T. MAKES NO REPRESENTATIONS OR WARRANTIES OF
dnl MERCHANTABILITY OR FITNESS FOR ANY PARTICULAR PURPOSE OR THAT THE USE OF
dnl THE LICENSED SOFTWARE OR DOCUMENTATION WILL NOT INFRINGE ANY THIRD PARTY
dnl PATENTS, COPYRIGHTS, TRADEMARKS OR OTHER RIGHTS.
dnl
dnl The name of the Massachusetts Institute of Technology or M.I.T. may NOT
dnl be used in advertising or publicity pertaining to distribution of the
dnl software.  Title to copyright in this software and any associated
dnl documentation shall at all times remain with M.I.T., and USER agrees to
dnl preserve same.

dnl AC_HEADER_CHECK_PROTOTYPE(FUNCTION, INCLUDES, [ACTION-IF-FOUND [, ACTION-IF-NOT-FOUND]])
AC_DEFUN([AC_HEADER_CHECK_PROTOTYPE], 
[AC_MSG_CHECKING([for a prototype for $1])
AC_CACHE_VAL(ac_cv_proto_$1,
[AC_TRY_COMPILE($2 [
struct bonch { int a, b; };
struct bonch $1();
], , eval "ac_cv_proto_$1=no", eval "ac_cv_proto_$1=yes")])
if eval "test \"`echo '$ac_cv_proto_'$1`\" = yes"; then
  AC_MSG_RESULT(yes)
  ifelse([$3], , :, [$3])
else
  AC_MSG_RESULT(no)
ifelse([$4], , , [$4
])dnl
fi
])

dnl AC_HEADER_CHECK_PROTOTYPES(INCLUDES, FUNCTION...)
AC_DEFUN([AC_HEADER_CHECK_PROTOTYPES],
[for ac_func in $2
do
AC_HEADER_CHECK_PROTOTYPE($ac_func, $1, 
[changequote(, )dnl
  ac_tr_func=PROTO_`echo $ac_func | tr 'abcdefghijklmnopqrstuvwxyz' 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'`
changequote([, ])dnl
  AC_DEFINE_UNQUOTED($ac_tr_func)])dnl
done
])

dnl AC_SYS_SOCKADDR_SA_LEN
AC_DEFUN([AC_SYS_SOCKADDR_SA_LEN],
[AC_MSG_CHECKING([for sa_len in struct sockaddr])
AC_CACHE_VAL(ac_cv_sys_sockaddr_sa_len,
[AC_TRY_COMPILE([
#include <sys/types.h>
#include <sys/socket.h>
], [
int length;
struct sockaddr sock;
length = sock.sa_len;
], ac_cv_sys_sockaddr_sa_len=yes, ac_cv_sys_sockaddr_sa_len=no)])dnl
if test $ac_cv_sys_sockaddr_sa_len = yes; then
  AC_MSG_RESULT(yes)
  AC_DEFINE_UNQUOTED(HAVE_SOCKADDR_SA_LEN, [], [Define if your struct sockaddr has sa_len.])
else
  AC_MSG_RESULT(no)
fi
])dnl