From d48ea5bb797037069d641da41da0f195f0124491 Mon Sep 17 00:00:00 2001 From: dan miller Date: Fri, 19 Oct 2007 05:20:48 +0000 Subject: one more for the gipper --- libraries/ode-0.9/configure.in | 580 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 580 insertions(+) create mode 100644 libraries/ode-0.9/configure.in (limited to 'libraries/ode-0.9/configure.in') diff --git a/libraries/ode-0.9/configure.in b/libraries/ode-0.9/configure.in new file mode 100644 index 0000000..96eea67 --- /dev/null +++ b/libraries/ode-0.9/configure.in @@ -0,0 +1,580 @@ +dnl Initial configure.in by Rodrigo Hernandez +dnl Modified in 26/10/2005 by Rodrigo Hernandez + +dnl AC_INIT does not take a macro as a version nr: set it separately! - Bram +AC_INIT(ODE,0.9.0,ode@ode.org) + +dnl When upgrading version nr, also change the AC_INIT line! - Bram +ODE_CURRENT=0 +ODE_REVISION=9 +ODE_AGE=0 +ODE_RELEASE=[$ODE_CURRENT].[$ODE_REVISION].[$ODE_AGE] +AC_CANONICAL_HOST +AC_CANONICAL_TARGET + +AM_INIT_AUTOMAKE(ODE,[$ODE_RELEASE]) +AM_CONFIG_HEADER(include/ode/config.h) +dnl Set CFLAGS to zero, so that we avoid getting the gratis -g -O2 +CFLAGS= +CXXFLAGS= +AC_C_BIGENDIAN +AC_PATH_X +AC_PATH_XTRA + +ODE_SONAME=libode.so.[$ODE_CURRENT] + +AC_SUBST(ODE_CURRENT) +AC_SUBST(ODE_REVISION) +AC_SUBST(ODE_AGE) +AC_SUBST(ODE_RELEASE) +AC_SUBST(ODE_SONAME) + +dnl This is needed because we have subdirectories +AC_PROG_MAKE_SET + +AC_PROG_CXX +AC_PROG_INSTALL +AC_CHECK_TOOLS([WINDRES], [windres]) +AC_C_CONST +AC_C_INLINE +AC_C_VOLATILE +AC_HEADER_STDBOOL +AC_PROG_RANLIB +AC_TYPE_SIZE_T + +dnl Check if using sonames is requested +dnl THIS IS TEMPORARY! +AC_MSG_CHECKING(if a soname should be set) +AC_ARG_ENABLE(soname,AC_HELP_STRING([--enable-soname], +[Configure ODE shared library to set the soname field on ELF files]), +use_soname=$enableval,use_soname=no) +AC_MSG_RESULT($use_soname) +AM_CONDITIONAL(USE_SONAME, test x$use_soname = xyes) + + +dnl Check if we want to build demos +AC_MSG_CHECKING(if tests should be built) +AC_ARG_ENABLE(demos,AC_HELP_STRING([--enable-demos], [build tests]), enable_demos=$enableval,enable_demos=yes) +AC_MSG_RESULT($enable_demos) +AM_CONDITIONAL(ENABLE_DEMOS, test x$enable_demos = xyes) + + +AC_ARG_WITH(arch,AC_HELP_STRING([--with-arch=[arch]], +[build for $arch, where arch is any of the -march flags passed to gcc, without the -march, for example --with-arch=pentium3]), +arch=$withval,arch=no) +ARCHFLAGS="" +if test "x$arch" != xno +then + ARCHFLAGS="-march=$arch" +fi +AC_SUBST(ARCHFLAGS) + +dnl Decide whether or not SSE is available +dnl Why dont we compile and run programs like we do to find out if +dnl this is a Pentium machine further down? simple! +dnl this may NOT be the machine on which the code is going to run in, +dnl so allow users to compile programs for their target machine. +case "$arch" in + pentium3 | pentium4 | athlon* ) + AC_DEFINE(HAVE_SSE,,[Use SSE Optimizations]) + ;; +dnl this space available for other architectures specific extensions and/or +dnl other Intel based extensions such as 3DNow, SSE2, MMX, etc. +esac + +dnl check for required headers +AC_CHECK_HEADERS( alloca.h ieeefp.h stdio.h stdlib.h math.h string.h stdarg.h malloc.h values.h float.h time.h sys/time.h ) + + +opcode=no +gimpact=no +AC_ARG_WITH(trimesh,AC_HELP_STRING([--with-trimesh=[opcode|gimpact|none]], +[use the specified system for trimesh support.]), +trimesh=$withval,trimesh=opcode +) +if test "$trimesh" = opcode +then + opcode=yes +fi +if test "$trimesh" = gimpact +then + gimpact=yes +fi + +AM_CONDITIONAL(OPCODE, test $opcode = yes) +AM_CONDITIONAL(GIMPACT, test $gimpact = yes) +AM_CONDITIONAL(TRIMESH, test $opcode = yes -o $gimpact = yes) + + +AC_MSG_CHECKING(if gyroscopic term should be used) +AC_ARG_ENABLE(gyroscopic,AC_HELP_STRING([--disable-gyroscopic], +[Configure ODE to work without gyroscopic term (may improve stability)]), +gyroscopic=$enableval,gyroscopic=yes) +AC_MSG_RESULT($gyroscopic) +if test x"$gyroscopic" = xyes +then +AC_DEFINE(dGYROSCOPIC,,[Use gyroscopic terms]) +fi + +dnl Check Precision, define the dInfinity constant--------------------------/ +AC_MSG_CHECKING(if double precision is requested) +AC_ARG_ENABLE(double-precision,AC_HELP_STRING([--enable-double-precision], +[Configure ODE to work with double precision, if not specified, single precision is used]), +precision=$enableval,precision=no) +if test "$precision" != no +then +dnl DOUBLE was chosen +AC_DEFINE(dDOUBLE,,[Use double precision]) +dnl Check from lest likelly to more likelly. +if test "$build_os" == "$target_os" +then +AC_TRY_RUN([ +#define dInfinity 1e20 +int main() +{ +if (dInfinity > 1e10 && -dInfinity < -1e10 && -dInfinity < dInfinity) +return 0; +else return -1; +} +],dinfinity=1e20,,) +AC_TRY_RUN([ +#define dInfinity 1.7976931348623157e+308 +int main() +{ +if (dInfinity > 1e10 && -dInfinity < -1e10 && -dInfinity < dInfinity) +return 0; +else return -1; +} +],dinfinity=1.7976931348623157e+308,,) +AC_TRY_RUN([ +#include +#define dInfinity HUGE_VAL +int main() +{ +if (dInfinity > 1e10 && -dInfinity < -1e10 && -dInfinity < dInfinity) +return 0; +else return -1; +} +],dinfinity=HUGE_VAL,,) +AC_TRY_RUN([ +#include +#define dInfinity DBL_MAX +int main() +{ +if (dInfinity > 1e10 && -dInfinity < -1e10 && -dInfinity < dInfinity) +return 0; +else return -1; +} +],dinfinity=DBL_MAX,,) +else +#cross-compiling, use a reasonable value. We should add an option for setting this. +dinfinity=DBL_MAX +fi +else +dnl default to SINGLE. +AC_DEFINE(dSINGLE,,[Use single precision]) +dnl Check from lest likelly to more likelly. +if test "$build_os" == "$target_os" +then +AC_TRY_RUN([ +#define dInfinity 1e20f +int main() +{ +if (dInfinity > 1e10f && -dInfinity < -1e10f && -dInfinity < dInfinity) +return 0; +else return -1; +} +],dinfinity=1e20f,,) +AC_TRY_RUN([ +#define dInfinity 3.402823466e+38F +int main() +{ +if (dInfinity > 1e10f && -dInfinity < -1e10f && -dInfinity < dInfinity) +return 0; +else return -1; +} +],dinfinity=3.402823466e+38F,,) +AC_TRY_RUN([ +#include +#define dInfinity HUGE_VALF +int main() +{ +if (dInfinity > 1e10f && -dInfinity < -1e10f && -dInfinity < dInfinity) +return 0; +else return -1; +} +],dinfinity=HUGE_VALF,,) +AC_TRY_RUN([ +#include +#define dInfinity FLT_MAX +int main() +{ +if (dInfinity > 1e10f && -dInfinity < -1e10f && -dInfinity < dInfinity) +return 0; +else return -1; +} +],dinfinity=FLT_MAX,,) +#cross-compiling, use a reasonable value. We should add an option for setting this. +dinfinity=FLT_MAX +fi +fi +AC_MSG_RESULT($precision) +AC_DEFINE_UNQUOTED(dInfinity,${dinfinity},[dInfinity Constant]) +AC_MSG_CHECKING(for appropriate dInfinity constant) +AC_MSG_RESULT($dinfinity) +dnl --------------------------------------------------------------------------/ + +dnl Define dEpsilon +AC_CHECK_HEADER(float.h,[have_float_h=yes],[have_float_h=no]) +AC_MSG_CHECKING(for appropriate dEpsilon constant) +if test "x$have_float_h" == xyes +then +if test $precision == yes +then +dEpsilon=DBL_EPSILON +else +dEpsilon=FLT_EPSILON +fi +else +if test $precision == yes +then +dEpsilon=2.2204460492503131e-16 +else +dEpsilon=1.19209290e-07f +fi +fi +AC_DEFINE_UNQUOTED(dEpsilon,${dEpsilon},[dEpsilon Constant]) +AC_MSG_RESULT($dEpsilon) + + +dnl Check for PENTIUM +if test "$build_os" == "$target_os" +then +AC_MSG_CHECKING(for a Pentium CPU) +AC_TRY_RUN([ +int main() +{ +asm ("mov \$0,%%eax;\n" + "cpuid\n" : : : "%eax"); +return 0; +}; +],pentium=yes,pentium=no,) +else +pentium=no +fi +if test "x$pentium" == xyes +then +AC_DEFINE(PENTIUM,1,[is this a pentium on a gcc-based platform?]) +fi +AC_MSG_RESULT($pentium) + +dnl Check for 64bit CPU +AC_MSG_CHECKING(for a x86-64 CPU) +if test "$build_os" == "$target_os" +then +AC_TRY_RUN([ +int main() +{ +int a = 0; +int * pa = &a; +asm ("mov %0,%%rax\n" + "movl (%%rax),%%eax\n" + : : "r"(pa) : "%rax"); +return 0; +}; +],cpu64=yes,cpu64=no,) +else +cpu64=no +fi +if test "x$cpu64" == xyes +then +AC_DEFINE(X86_64_SYSTEM,1,[is this a X86_64 system on a gcc-based platform?]) +fi +AC_MSG_RESULT($cpu64) +AM_CONDITIONAL(X86_64_SYSTEM, test x$cpu64 = xyes) + +AC_MSG_CHECKING(if building a release library) +AC_ARG_ENABLE(release,AC_HELP_STRING([--enable-release], +[build a release library with -fomit-frame-pointer and -ffast-math]), +release=$enableval,release=no) +if test "x$release" == xyes +then + CFLAGS="$CFLAGS -fomit-frame-pointer -ffast-math" + CPPFLAGS="$CPPFLAGS -fomit-frame-pointer -ffast-math" + CXXFLAGS="$CXXFLAGS -fomit-frame-pointer -ffast-math" + AC_DEFINE(dNODEBUG,,[Disable debug output]) +fi +AC_MSG_RESULT($release) + +AC_MSG_CHECKING(if building a debug library) +AC_ARG_ENABLE(debug,AC_HELP_STRING([--enable-debug], +[Add debug symbols to the library with -g]), +debug=$enableval,debug=yes) +if test "x$debug" == xyes +then + CFLAGS="$CFLAGS -g" + CPPFLAGS="$CPPFLAGS -g" + CXXFLAGS="$CXXFLAGS -g" +fi +AC_MSG_RESULT($debug) + + +dnl Check variable type sizes +AC_CHECK_SIZEOF(char) +AC_CHECK_SIZEOF(int) +AC_CHECK_SIZEOF(short) +AC_CHECK_SIZEOF(long int) +AC_CHECK_SIZEOF(void*) + +dnl Set some Platform Specific Variables +case "$host_os" in + cygwin* | mingw*) + so_ext=".dll" + DLLDEFINE="-DODE_DLL" + SHARED_LDFLAGS="-shared" + drawstuff="Win32" # if in a Windows enviroment + ;; + *apple* | *darwin*) # For Mac OS X + so_ext=".dylib" + DLLDEFINE="" + SHARED_LDFLAGS="-dynamiclib" + drawstuff="OSX" + dnl We need to use C++ compilation and linking for ode on Mac + dnl Might as well do it for all code. + CC="$CXX" + LINK="$CXXLINK" + ;; + *) + drawstuff="X11" # if anything else default to X11 + if test x$use_soname = xyes; then + so_ext=".so.$ODE_RELEASE" + else + so_ext=".so" + fi + DLLDEFINE="" + SHARED_LDFLAGS="-shared" + ;; +esac +dnl Set Conditionals +AM_CONDITIONAL(WIN32, test x$drawstuff = xWin32) +AM_CONDITIONAL(X11, test x$drawstuff = xX11) +AM_CONDITIONAL(OSX, test x$drawstuff = xOSX) +dnl Set Drawstuff variables +AC_MSG_CHECKING(which drawstuff lib to build) +AC_MSG_RESULT($drawstuff) +AC_SUBST(DRAWSTUFF) +dnl Set shared library variables +AC_MSG_CHECKING(for the suffix of shared libraries) +AC_MSG_RESULT($so_ext) +AC_DEFINE_UNQUOTED(SO_EXT,"$so_ext",[The extension for shared libraries.]) +AC_SUBST(so_ext) +AC_SUBST(SHARED_LDFLAGS) + +dnl Check for AC_PATH_X variables +if test "X$x_includes" != "XNONE"; then + CFLAGS="$CFLAGS -I$x_includes" + CXXFLAGS="$CXXFLAGS -I$x_includes" +fi +if test "X$x_libraries" != "XNONE"; then + CFLAGS="$CFLAGS -L$x_libraries" + CXXFLAGS="$CXXFLAGS -L$x_libraries" +fi + +dnl Check for OpenGL +if test "x$drawstuff" = "xOSX"; then + AC_DEFINE([HAVE_APPLE_OPENGL_FRAMEWORK], [1], + [Use the Apple OpenGL framework.]) + GL_LIBS="-framework OpenGL -framework Carbon -framework AGL" +else + AC_CHECK_HEADERS(GL/gl.h GL/glu.h GL/glext.h,,, + [[#if HAVE_GL_GL_H + #include + #endif + #if HAVE_GL_GLU_H + #include + #endif + ]]) + AC_CHECK_LIB(GL, main,[GL_LIBS="$GL_LIBS -lGL"]) + TEMP_LDFLAGS="$LDFLAGS" + LDFLAGS="$LDFLAGS $GL_LIBS" + AC_CHECK_LIB(GLU, main,[GL_LIBS="$GL_LIBS -lGLU"]) + LDFLAGS="$TEMP_LDFLAGS" + AC_CHECK_LIB(opengl32, main,[GL_LIBS="$GL_LIBS -lopengl32"]) + AC_CHECK_LIB(glu32, main,[GL_LIBS="$GL_LIBS -lglu32"]) + AC_CHECK_LIB(Xmu, main,[GL_LIBS="$GL_LIBS -lXmu"]) + AC_CHECK_LIB(Xi, main,[GL_LIBS="$GL_LIBS -lXi"]) + AC_CHECK_LIB(X, main,[GL_LIBS="$GL_LIBS -lX"]) + AC_CHECK_LIB(X11, main,[GL_LIBS="$GL_LIBS -lX11"]) +fi +AC_SUBST(GL_LIBS) + +dnl Add some Windows libraries if found +AC_CHECK_LIB(comctl32,main,[LIBS="$LIBS -lcomctl32"]) +AC_CHECK_LIB(kernel32,main,[LIBS="$LIBS -lkernel32"]) +AC_CHECK_LIB(user32,main,[LIBS="$LIBS -luser32"]) +AC_CHECK_LIB(gdi32,main,[LIBS="$LIBS -lgdi32"]) +AC_CHECK_LIB(winmm,main,[LIBS="$LIBS -lwinmm"]) + +dnl Add math and standard c++ lib just in case +AC_CHECK_LIB(stdc++,main,[LIBS="$LIBS -lstdc++"]) +AC_CHECK_LIB(m,main,[LIBS="$LIBS -lm"]) +AC_CHECK_LIB(pthread,main,[LIBS="$LIBS -lpthread"]) + + +TOPDIR=`cd $srcdir;pwd` +AC_SUBST(TOPDIR) + +dnl Check if the user wants to profile ODE using gprof +AC_MSG_CHECKING(for gprof) +AC_ARG_ENABLE(gprof, +AC_HELP_STRING([--enable-gprof],[enable profiling with gprof]), +gprof=$enableval,gprof=no) +if test "$gprof" != no +then + CFLAGS="-pg $CFLAGS" + CPPFLAGS="-pg $CPPFLAGS" + CXXFLAGS="-pg $CXXFLAGS" + AC_CHECK_LIB(gmon, main,[LIBS="$LIBS -lgmon"]) + AC_MSG_RESULT(enabled) +else + AC_MSG_RESULT(no) +fi + +dnl Check for autoscan sugested functions +AC_CHECK_FUNCS([floor memmove memset select sqrt sqrtf sinf cosf fabsf atan2f fmodf copysignf copysign snprintf vsnprintf gettimeofday isnan isnanf _isnan _isnanf __isnan __isnanf]) +if test "$build_os" == "$target_os" +then +AC_FUNC_ALLOCA +AC_FUNC_MALLOC +AC_FUNC_OBSTACK +AC_FUNC_REALLOC +AC_FUNC_SELECT_ARGTYPES +AC_FUNC_VPRINTF +fi + +dnl include found system headers into config.h +AH_TOP([ +#ifndef ODE_CONFIG_H +#define ODE_CONFIG_H +]) +AH_BOTTOM([ + +#ifdef HAVE_ALLOCA_H +#include +#endif +#if defined(HAVE_IEEEFP_H) && !defined(__CYGWIN__) +// This header creates conflicts with math.h in Cygwin. +#include +#endif +#ifdef HAVE_STDIO_H +#include +#endif +#ifdef HAVE_STDLIB_H +#include +#endif +#ifdef HAVE_MATH_H +#include +#endif +#ifdef HAVE_STRING_H +#include +#endif +#ifdef HAVE_STDARG_H +#include +#endif +#ifdef HAVE_MALLOC_H +#include +#endif +#ifdef HAVE_VALUES_H +#include +#endif +#ifdef HAVE_FLOAT_H +#include +#endif +#if SIZEOF_CHAR == 1 +typedef char int8; +typedef unsigned char uint8; +#else +#error "expecting sizeof(char) == 1" +#endif +#if SIZEOF_SHORT == 2 +typedef short int16; +typedef unsigned short uint16; +#else +#error "can not find 2 byte integer type" +#endif +/* integer types (we assume int >= 32 bits) */ +#if SIZEOF_INT == 4 +typedef short int32; +typedef unsigned short uint32; +#else +#error "can not find 4 byte integer type" +#endif +/* an integer type that we can safely cast a pointer to and + * from without loss of bits. + */ +#if SIZEOF_SHORT == SIZEOF_VOIDP +typedef unsigned short intP; +#elif SIZEOF_INT == SIZEOF_VOIDP +typedef unsigned int intP; +#elif SIZEOF_LONG_INT == SIZEOF_VOIDP +typedef unsigned long int intP; +#endif + +/* +Handle Windows DLL odities +Its easier to export all symbols using the -shared flag +for MinGW than differentiating with declspec, +so only do it for MSVC +*/ +#if defined(ODE_DLL) && defined(WIN32) && defined(_MSC_VER) +#define ODE_API __declspec( dllexport ) +#elif !defined(ODE_DLL) && defined(WIN32) && defined(MSC_VER) +#define ODE_API __declspec( dllimport ) +#else +#define ODE_API +#endif + +#endif /* #define ODE_CONFIG_H */ +]) + + +dnl Finally write our Makefiles +AC_OUTPUT([ + Makefile + include/Makefile + include/ode/Makefile + ode/Makefile + ode/src/Makefile + drawstuff/Makefile + drawstuff/src/Makefile + drawstuff/dstest/Makefile + ode/demo/Makefile + tests/Makefile + tests/CppTestHarness/Makefile + ode-config + ]) + +chmod +x ode-config + +dnl Print some useful information +echo "Configuration:" +echo " Target system type: $target" +echo " Build system type: $build" +echo " Host system type: $host" +echo " Use double precision: $precision" +echo " Use OPCODE: $opcode" +echo " Use GIMPACT: $gimpact" +echo " Use gyroscopic term: $gyroscopic" +echo " Is this a Pentium: $pentium" +echo " Is the CPU x86-64: $cpu64" +echo " Is this a release build: $release" +echo " Adding debug symbols: $debug" +echo " Using SONAME: $use_soname" +echo " Headers will be installed in $prefix/include/ode" +echo " Libraries will be installed in $prefix/lib" + +if test $gimpact = yes -a $precision = yes +then + echo "WARNING! Double precision not yet supported for GIMPACT" +fi + -- cgit v1.1