diff options
Diffstat (limited to 'sid/sidplay-libs-2.1.0/libsidplay/unix/ac_create_stdint_h.m4')
| -rw-r--r-- | sid/sidplay-libs-2.1.0/libsidplay/unix/ac_create_stdint_h.m4 | 501 |
1 files changed, 501 insertions, 0 deletions
diff --git a/sid/sidplay-libs-2.1.0/libsidplay/unix/ac_create_stdint_h.m4 b/sid/sidplay-libs-2.1.0/libsidplay/unix/ac_create_stdint_h.m4 new file mode 100644 index 00000000..0e807324 --- /dev/null +++ b/sid/sidplay-libs-2.1.0/libsidplay/unix/ac_create_stdint_h.m4 @@ -0,0 +1,501 @@ +dnl AC_CREATE_STDINT_H [( HEADER-TO-GENERATE [, HEDERS-TO-CHECK])] -*- sh -*- +dnl +dnl the "ISO C9X: 7.18 Integer types <stdint.h>" section requires the +dnl existence of an include file <stdint.h> that defines a set of +dnl typedefs, especially uint8_t,int32_t,uintptr_t. +dnl Many older installations will not provide this file, but some will +dnl have the very same definitions in <inttypes.h>. In other enviroments +dnl we can use the inet-types in <sys/types.h> which would define the +dnl typedefs int8_t and u_int8_t respectivly. +dnl +dnl This macros will create a local "_stdint.h" or the headerfile given as +dnl an argument. In many cases that file will just have a singular +dnl "#include <stdint.h>" or "#include <inttypes.h>" statement, while +dnl in other environments it will provide the set of basic 'stdint's defined: +dnl int8_t,uint8_t,int16_t,uint16_t,int32_t,uint32_t,intptr_t,uintptr_t +dnl int_least32_t.. int_fast32_t.. intmax_t +dnl which may or may not rely on the definitions of other files, +dnl or using the AC_COMPILE_CHECK_SIZEOF macro to determine the actual +dnl sizeof each type. +dnl +dnl if your header files require the stdint-types you will want to create an +dnl installable file mylib-int.h that all your other installable header +dnl may include. So if you have a library package named "mylib", just use +dnl AC_CREATE_STDINT_H(mylib-int.h) +dnl in configure.in and go to install that very header file in Makefile.am +dnl along with the other headers (mylib.h) - and the mylib-specific headers +dnl can simply use "#include <mylib-int.h>" to obtain the stdint-types. +dnl +dnl Remember, if the system already had a valid <stdint.h>, the generated +dnl file will include it directly. No need for fuzzy HAVE_STDINT_H things... +dnl +dnl (this file is part of the http://ac-archive.sf.net/gstdint project) +dnl @version $Id: ac_create_stdint_h.m4,v 1.2 2002/02/17 00:08:45 s_a_white Exp $ +dnl @author Guido Draheim <guidod@gmx.de> STATUS: used on new platforms + +AC_DEFUN([AC_CREATE_STDINT_H], +[# ------ AC CREATE STDINT H ------------------------------------- +AC_MSG_CHECKING([for stdint-types....]) +ac_stdint_h=`echo ifelse($1, , _stdint.h, $1)` +if test "$ac_stdint_h" = "stdint.h" ; then + AC_MSG_RESULT("(are you sure you want them in ./stdint.h?)") +elif test "$ac_stdint_h" = "inttypes.h" ; then + AC_MSG_RESULT("(are you sure you want them in ./inttypes.h?)") +else + AC_MSG_RESULT("(putting them into $ac_stdint_h)") +fi + +inttype_headers=`echo inttypes.h sys/inttypes.h sys/inttypes.h $2 \ +| sed -e 's/,/ /g'` + + ac_cv_header_stdint_x="no-file" + ac_cv_header_stdint_o="no-file" + ac_cv_header_stdint_u="no-file" + for i in stdint.h $inttype_headers ; do + unset ac_cv_type_uintptr_t + unset ac_cv_type_uint64_t + _AC_CHECK_TYPE_NEW(uintptr_t,[ac_cv_header_stdint_x=$i],dnl + continue,[#include <$i>]) + AC_CHECK_TYPE(uint64_t,[and64="(uint64_t too)"],[and64=""],[#include<$i>]) + AC_MSG_RESULT(... seen our uintptr_t in $i $and64) + break; + done + if test "$ac_cv_header_stdint_x" = "no-file" ; then + for i in stdint.h $inttype_headers ; do + unset ac_cv_type_uint32_t + unset ac_cv_type_uint64_t + AC_CHECK_TYPE(uint32_t,[ac_cv_header_stdint_o=$i],dnl + continue,[#include <$i>]) + AC_CHECK_TYPE(uint64_t,[and64="(uint64_t too)"],[and64=""],[#include<$i>]) + AC_MSG_RESULT(... seen our uint32_t in $i $and64) + break; + done + if test "$ac_cv_header_stdint_o" = "no-file" ; then + for i in sys/types.h $inttype_headers ; do + unset ac_cv_type_u_int32_t + unset ac_cv_type_u_int64_t + AC_CHECK_TYPE(u_int32_t,[ac_cv_header_stdint_u=$i],dnl + continue,[#include <$i>]) + AC_CHECK_TYPE(uint64_t,[and64="(u_int64_t too)"],[and64=""],[#include<$i>]) + AC_MSG_RESULT(... seen our u_int32_t in $i $and64) + break; + done + fi + fi + +# ----------------- DONE inttypes.h checks MAYBE C basic types -------- + +if test "$ac_cv_header_stdint_x" = "no-file" ; then + AC_COMPILE_CHECK_SIZEOF(char) + AC_COMPILE_CHECK_SIZEOF(short) + AC_COMPILE_CHECK_SIZEOF(int) + AC_COMPILE_CHECK_SIZEOF(long) + AC_COMPILE_CHECK_SIZEOF(void*) + ac_cv_header_stdint_test="yes" +else + ac_cv_header_stdint_test="no" +fi + +# ----------------- DONE inttypes.h checks START header ------------- +_ac_stdint_h=AS_TR_CPP(_$ac_stdint_h) +AC_MSG_RESULT(creating $ac_stdint_h : $_ac_stdint_h) +echo "#ifndef" $_ac_stdint_h >$ac_stdint_h +echo "#define" $_ac_stdint_h "1" >>$ac_stdint_h +echo "#ifndef" _GENERATED_STDINT_H >>$ac_stdint_h +echo "#define" _GENERATED_STDINT_H '"'$PACKAGE $VERSION'"' >>$ac_stdint_h +if test "$GCC" = "yes" ; then + echo "/* generated using a gnu compiler version" `$CC --version` "*/" \ + >>$ac_stdint_h +else + echo "/* generated using $CC */" >>$ac_stdint_h +fi +echo "" >>$ac_stdint_h + +if test "$ac_cv_header_stdint_x" != "no-file" ; then + ac_cv_header_stdint="$ac_cv_header_stdint_x" +elif test "$ac_cv_header_stdint_o" != "no-file" ; then + ac_cv_header_stdint="$ac_cv_header_stdint_o" +elif test "$ac_cv_header_stdint_u" != "no-file" ; then + ac_cv_header_stdint="$ac_cv_header_stdint_u" +else + ac_cv_header_stdint="stddef.h" +fi + +# ----------------- See if int_least and int_fast types are present +unset ac_cv_type_int_least32_t +unset ac_cv_type_int_fast32_t +AC_CHECK_TYPE(int_least32_t,,,[#include <$ac_cv_header_stdint>]) +AC_CHECK_TYPE(int_fast32_t,,,[#include<$ac_cv_header_stdint>]) + +if test "$ac_cv_header_stdint" != "stddef.h" ; then +if test "$ac_cv_header_stdint" != "stdint.h" ; then +AC_MSG_RESULT(..adding include stddef.h) + echo "#include <stddef.h>" >>$ac_stdint_h +fi ; fi +AC_MSG_RESULT(..adding include $ac_cv_header_stdint) + echo "#include <$ac_cv_header_stdint>" >>$ac_stdint_h +echo "" >>$ac_stdint_h + +# ----------------- DONE header START basic int types ------------- +if test "$ac_cv_header_stdint_x" = "no-file" ; then + AC_MSG_RESULT(... need to look at C basic types) +dnl ac_cv_header_stdint_test="yes" # moved up before creating the file +else + AC_MSG_RESULT(... seen good stdint.h inttypes) +dnl ac_cv_header_stdint_test="no" # moved up before creating the file +fi + +if test "$ac_cv_header_stdint_u" != "no-file" ; then + AC_MSG_RESULT(... seen bsd/sysv typedefs) + cat >>$ac_stdint_h <<EOF + +/* int8_t int16_t int32_t defined by inet code, redeclare the u_intXX types */ +typedef u_int8_t uint8_t; +typedef u_int16_t uint16_t; +typedef u_int32_t uint32_t; +EOF + cat >>$ac_stdint_h <<EOF + +/* glibc compatibility */ +#ifndef __int8_t_defined +#define __int8_t_defined +#endif +EOF +fi + +ac_cv_sizeof_x="$ac_cv_sizeof_char:$ac_cv_sizeof_short" +ac_cv_sizeof_X="$ac_cv_sizeof_x:$ac_cv_sizeof_int" +ac_cv_sizeof_X="$ac_cv_sizeof_X:$ac_cv_sizeof_voidp:$ac_cv_sizeof_long" +if test "$ac_cv_header_stdint" = "stddef.h" ; then +# we must guess all the basic types. Apart from byte-adressable system, +# there a few 32-bit-only dsp-systems. nibble-addressable systems are way off. + cat >>$ac_stdint_h <<EOF +/* ------------ BITSPECIFIC INTTYPES SECTION --------------- */ +EOF + t="typedefs for a" + case "$ac_cv_sizeof_X" in + 1:2:2:2:4) AC_MSG_RESULT(..adding $t normal 16-bit system) + cat >>$ac_stdint_h <<EOF +/* a normal 16-bit system */ +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned long uint32_t; +#ifndef __int8_t_defined +#define __int8_t_defined +typedef char int8_t; +typedef short int16_t; +typedef long int32_t; +#endif +EOF +;; + 1:2:2:4:4) AC_MSG_RESULT(..adding $t 32-bit system derived from a 16-bit) + cat >>$ac_stdint_h <<EOF +/* a 32-bit system derived from a 16-bit */ +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +#ifndef __int8_t_defined +#define __int8_t_defined +typedef char int8_t; +typedef short int16_t; +typedef int int32_t; +#endif +EOF +;; + 1:2:4:4:4) AC_MSG_RESULT(..adding $t normal 32-bit system) + cat >>$ac_stdint_h <<EOF +/* a normal 32-bit system */ +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +#ifndef __int8_t_defined +#define __int8_t_defined +typedef char int8_t; +typedef short int16_t; +typedef int int32_t; +#endif +EOF +;; + 1:2:4:4:8) AC_MSG_RESULT(..adding $t 32-bit system prepared for 64-bit) + cat >>$ac_stdint_h <<EOF + +/* a 32-bit system prepared for 64-bit */ +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +#ifndef __int8_t_defined +#define __int8_t_defined +typedef char int8_t; +typedef short int16_t; +typedef int int32_t; +#endif +EOF +;; + 1:2:4:8:8) AC_MSG_RESULT(..adding $t normal 64-bit system) + cat >>$ac_stdint_h <<EOF + +/* a normal 64-bit system */ +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +#ifndef __int8_t_defined +#define __int8_t_defined +typedef char int8_t; +typedef short int16_t; +typedef int int32_t; +#endif +EOF +;; + 1:2:4:8:4) AC_MSG_RESULT(..adding $t 64-bit system derived from a 32-bit) + cat >>$ac_stdint_h <<EOF + +/* a 64-bit system derived from a 32-bit system */ +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +#ifndef __int8_t_defined +#define __int8_t_defined +typedef char int8_t; +typedef short int16_t; +typedef int int32_t; +#endif +EOF +;; + *) + AC_MSG_ERROR([ $ac_cv_sizeof_X dnl + what is that a system? contact the author, quick! http://ac-archive.sf.net]) + exit 1 +;; + esac +fi + +# ------------- DONE basic int types START int64_t types ------------ +if test "$ac_cv_type_uint64_t" = "yes" +then AC_MSG_RESULT(... seen good uint64_t) + cat >>$ac_stdint_h <<EOF + +/* system headers have good uint64_t */ +#ifndef _HAVE_UINT64_T +#define _HAVE_UINT64_T +#endif +EOF + +elif test "$ac_cv_type_u_int64_t" = "yes" +then AC_MSG_RESULT(..adding typedef u_int64_t uint64_t) + cat >>$ac_stdint_h <<EOF + +/* system headers have an u_int64_t */ +#ifndef _HAVE_UINT64_T +#define _HAVE_UINT64_T +typedef u_int64_t uint64_t; +#endif +EOF +else AC_MSG_RESULT(..adding generic uint64_t runtime checks) + cat >>$ac_stdint_h <<EOF + +/* -------------------- 64 BIT GENERIC SECTION -------------------- */ +/* here are some common heuristics using compiler runtime specifics */ +#if defined __STDC_VERSION__ && defined __STDC_VERSION__ > 199901L + +#ifndef _HAVE_UINT64_T +#define _HAVE_UINT64_T +typedef long long int64_t; +typedef unsigned long long uint64_t; +#endif + +#elif !defined __STRICT_ANSI__ +#if defined _MSC_VER || defined __WATCOMC__ || defined __BORLANDC__ + +#ifndef _HAVE_UINT64_T +#define _HAVE_UINT64_T +typedef __int64 int64_t; +typedef unsigned __int64 uint64_t; +#endif + +#elif defined __GNUC__ || defined __MWERKS__ || defined __ELF__ +dnl /* note: all ELF-systems seem to have loff-support which needs 64-bit */ + +#if !defined _NO_LONGLONG +#ifndef _HAVE_UINT64_T +#define _HAVE_UINT64_T +typedef long long int64_t; +typedef unsigned long long uint64_t; +#endif +#endif + +#elif defined __alpha || (defined __mips && defined _ABIN32) + +#if !defined _NO_LONGLONG +#ifndef _HAVE_UINT64_T +#define _HAVE_UINT64_T +typedef long int64_t; +typedef unsigned long uint64_t; +#endif +#endif + /* compiler/cpu type ... or just ISO C99 */ +#endif +#endif +EOF + +# plus a default 64-bit for systems that are likely to be 64-bit ready + case "$ac_cv_sizeof_x:$ac_cv_sizeof_voidp:$ac_cv_sizeof_long" in + 1:2:8:8) AC_MSG_RESULT(..adding uint64_t default, normal 64-bit system) +cat >>$ac_stdint_h <<EOF +/* DEFAULT: */ +/* seen normal 64-bit system, CC has sizeof(long and void*) == 8 bytes */ +#ifndef _HAVE_UINT64_T +#define _HAVE_UINT64_T +typedef long int64_t; +typedef unsigned long uint64_t; +#endif +EOF +;; + 1:2:4:8) AC_MSG_RESULT(..adding uint64_t default, typedef to long) +cat >>$ac_stdint_h <<EOF +/* DEFAULT: */ +/* seen 32-bit system prepared for 64-bit, CC has sizeof(long) == 8 bytes */ +#ifndef _HAVE_UINT64_T +#define _HAVE_UINT64_T +typedef long int64_t; +typedef unsigned long uint64_t; +#endif +EOF +;; + 1:2:8:4) AC_MSG_RESULT(..adding uint64_t default, typedef long long) +cat >>$ac_stdint_h <<EOF +/* DEFAULT: */ +/* seen 64-bit derived from a 32-bit, CC has sizeof(long) == 4 bytes */ +#ifndef _HAVE_UINT64_T +#define _HAVE_UINT64_T +typedef long long int64_t; +typedef unsigned long long uint64_t; +#endif +EOF +;; + *) +cat >>$ac_stdint_h <<EOF +/* NOTE: */ +/* the configure-checks for the basic types did not make us believe */ +/* that we could add a fallback to a 'long long' typedef to int64_t */ +EOF + esac +fi + +# ------------- DONE int64_t types START intptr types ------------ +if test "$ac_cv_header_stdint_x" = "no-file" ; then + cat >>$ac_stdint_h <<EOF + +/* -------------------------- INPTR SECTION --------------------------- */ +EOF + case "$ac_cv_sizeof_x:$ac_cv_sizeof_voidp" in + 1:2:2) + a="int16_t" ; cat >>$ac_stdint_h <<EOF +/* we tested sizeof(void*) to be of 2 chars, hence we declare it 16-bit */ + +typedef uint16_t uintptr_t; +typedef int16_t intptr_t; +EOF +;; + 1:2:4) + a="int32_t" ; cat >>$ac_stdint_h <<EOF +/* we tested sizeof(void*) to be of 4 chars, hence we declare it 32-bit */ + +typedef uint32_t uintptr_t; +typedef int32_t intptr_t; +EOF +;; + 1:2:8) + a="int64_t" ; cat >>$ac_stdint_h <<EOF +/* we tested sizeof(void*) to be of 8 chars, hence we declare it 64-bit */ + +typedef uint64_t uintptr_t; +typedef int64_t intptr_t; +EOF +;; + *) + a="long" ; cat >>$ac_stdint_h <<EOF +/* we tested sizeof(void*) but got no guess, hence we declare it as if long */ + +typedef unsigned long uintptr_t; +typedef long intptr_t; +EOF +;; + esac +AC_MSG_RESULT(..adding typedef $a intptr_t) +fi + +# ------------- DONE intptr types START int_least types ------------ +if test "$ac_cv_type_int_least32_t" = "no"; then +AC_MSG_RESULT(..adding generic int_least-types) + cat >>$ac_stdint_h <<EOF + +/* --------------GENERIC INT_LEAST ------------------ */ + +typedef int8_t int_least8_t; +typedef int16_t int_least16_t; +typedef int32_t int_least32_t; +#ifdef _HAVE_INT64_T +typedef int64_t int_least64_t; +#endif + +typedef uint8_t uint_least8_t; +typedef uint16_t uint_least16_t; +typedef uint32_t uint_least32_t; +#ifdef _HAVE_INT64_T +typedef uint64_t uint_least64_t; +#endif +EOF +fi + +# ------------- DONE intptr types START int_least types ------------ +if test "$ac_cv_type_int_fast32_t" = "no"; then +AC_MSG_RESULT(..adding generic int_fast-types) + cat >>$ac_stdint_h <<EOF + +/* --------------GENERIC INT_FAST ------------------ */ + +typedef int8_t int_fast8_t; +typedef int32_t int_fast16_t; +typedef int32_t int_fast32_t; +#ifdef _HAVE_INT64_T +typedef int64_t int_fast64_t; +#endif + +typedef uint8_t uint_fast8_t; +typedef uint32_t uint_fast16_t; +typedef uint32_t uint_fast32_t; +#ifdef _HAVE_INT64_T +typedef uint64_t uint_fast64_t; +#endif +EOF +fi + +if test "$ac_cv_header_stdint_x" = "no-file" ; then + cat >>$ac_stdint_h <<EOF + +#ifdef _HAVE_INT64_T +typedef int64_t intmax_t; +typedef uint64_t uintmax_t; +#else +typedef long int intmax_t; +typedef unsigned long uintmax_t; +#endif +EOF +fi + +AC_MSG_RESULT(... DONE $ac_stdint_h) + cat >>$ac_stdint_h <<EOF + + /* once */ +#endif +#endif +EOF +]) + +dnl quote from SunOS-5.8 sys/inttypes.h: +dnl Use at your own risk. As of February 1996, the committee is squarely +dnl behind the fixed sized types; the "least" and "fast" types are still being +dnl discussed. The probability that the "fast" types may be removed before +dnl the standard is finalized is high enough that they are not currently +dnl implemented. + |