cheng/libtiff
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

*** empty log message ***

Browse Source
This commit is contained in:
Andrey Kiselev 2010-07-01 15:33:28 +00:00
parent 5122fdb3e0
commit ec2b508f60
5 changed files with 552 additions and 390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
libtiff/tif_aux.c
View File

@ -1,4 +1,4 @@
/* $Id: tif_aux.c,v 1.25 2010-03-10 18:56:48 bfriesen Exp $ */ /* $Id: tif_aux.c,v 1.26 2010-07-01 15:33:28 dron Exp $ */
/* /*
* Copyright (c) 1991-1997 Sam Leffler * Copyright (c) 1991-1997 Sam Leffler
@ -33,6 +33,32 @@
#include "tif_predict.h" #include "tif_predict.h"
#include <math.h> #include <math.h>
uint32
_TIFFMultiply32(TIFF* tif, uint32 first, uint32 second, const char* where)
{
uint32 bytes = first * second;
if (second && bytes / second != first) {
TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
bytes = 0;
}
return bytes;
}
uint64
_TIFFMultiply64(TIFF* tif, uint64 first, uint64 second, const char* where)
{
uint64 bytes = first * second;
if (second && bytes / second != first) {
TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
bytes = 0;
}
return bytes;
}
void* void*
_TIFFCheckRealloc(TIFF* tif, void* buffer, _TIFFCheckRealloc(TIFF* tif, void* buffer,
tmsize_t nmemb, tmsize_t elem_size, const char* what) tmsize_t nmemb, tmsize_t elem_size, const char* what)
@ -46,11 +72,12 @@ _TIFFCheckRealloc(TIFF* tif, void* buffer,
if (nmemb && elem_size && bytes / elem_size == nmemb) if (nmemb && elem_size && bytes / elem_size == nmemb)
cp = _TIFFrealloc(buffer, bytes); cp = _TIFFrealloc(buffer, bytes);
if (cp == NULL) if (cp == NULL) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, TIFFErrorExt(tif->tif_clientdata, tif->tif_name,
"Failed to allocate memory for %s " "Failed to allocate memory for %s "
"(%ld elements of %ld bytes each)", "(%ld elements of %ld bytes each)",
what,(long) nmemb, (long) elem_size); what,(long) nmemb, (long) elem_size);
}
return cp; return cp;
} }

54
libtiff/tif_strip.c
View File

@ -1,4 +1,4 @@
/* $Id: tif_strip.c,v 1.32 2010-03-10 18:56:49 bfriesen Exp $ */ /* $Id: tif_strip.c,v 1.33 2010-07-01 15:33:28 dron Exp $ */
/* /*
* Copyright (c) 1991-1997 Sam Leffler * Copyright (c) 1991-1997 Sam Leffler
@ -31,32 +31,6 @@
*/ */
#include "tiffiop.h" #include "tiffiop.h"
static uint32
multiply_32(TIFF* tif, uint32 nmemb, uint32 elem_size, const char* where)
{
uint32 bytes = nmemb * elem_size;
if (elem_size && bytes / elem_size != nmemb) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where);
bytes = 0;
}
return (bytes);
}
static uint64
multiply_64(TIFF* tif, uint64 nmemb, uint64 elem_size, const char* where)
{
uint64 bytes = nmemb * elem_size;
if (elem_size && bytes / elem_size != nmemb) {
TIFFErrorExt(tif->tif_clientdata, tif->tif_name, "Integer overflow in %s", where);
bytes = 0;
}
return (bytes);
}
/* /*
* Compute which strip a (row,sample) value is in. * Compute which strip a (row,sample) value is in.
*/ */
@ -92,7 +66,7 @@ TIFFNumberOfStrips(TIFF* tif)
nstrips = (td->td_rowsperstrip == (uint32) -1 ? 1 : nstrips = (td->td_rowsperstrip == (uint32) -1 ? 1 :
TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip)); TIFFhowmany_32(td->td_imagelength, td->td_rowsperstrip));
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
nstrips = multiply_32(tif, nstrips, (uint32)td->td_samplesperpixel, nstrips = _TIFFMultiply32(tif, nstrips, (uint32)td->td_samplesperpixel,
"TIFFNumberOfStrips"); "TIFFNumberOfStrips");
return (nstrips); return (nstrips);
} }
@ -143,12 +117,12 @@ TIFFVStripSize64(TIFF* tif, uint32 nrows)
samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2; samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
samplingblocks_hor=TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]); samplingblocks_hor=TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]);
samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]); samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
samplingrow_samples=multiply_64(tif,samplingblocks_hor,samplingblock_samples,module); samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
samplingrow_size=TIFFhowmany8_64(multiply_64(tif,samplingrow_samples,td->td_bitspersample,module)); samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
return(multiply_64(tif,samplingrow_size,samplingblocks_ver,module)); return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
} }
else else
return(multiply_64(tif,nrows,TIFFScanlineSize64(tif),module)); return(_TIFFMultiply64(tif,nrows,TIFFScanlineSize64(tif),module));
} }
tmsize_t tmsize_t
TIFFVStripSize(TIFF* tif, uint32 nrows) TIFFVStripSize(TIFF* tif, uint32 nrows)
@ -329,19 +303,19 @@ TIFFScanlineSize64(TIFF* tif)
} }
samplingblock_samples = ycbcrsubsampling[0]*ycbcrsubsampling[1]+2; samplingblock_samples = ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
samplingblocks_hor = TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]); samplingblocks_hor = TIFFhowmany_32(td->td_imagewidth,ycbcrsubsampling[0]);
samplingrow_samples = multiply_64(tif,samplingblocks_hor,samplingblock_samples,module); samplingrow_samples = _TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
samplingrow_size = TIFFhowmany_64(multiply_64(tif,samplingrow_samples,td->td_bitspersample,module),8); samplingrow_size = TIFFhowmany_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module),8);
scanline_size = (samplingrow_size/ycbcrsubsampling[1]); scanline_size = (samplingrow_size/ycbcrsubsampling[1]);
} }
else else
{ {
uint64 scanline_samples; uint64 scanline_samples;
scanline_samples=multiply_64(tif,td->td_imagewidth,td->td_samplesperpixel,module); scanline_samples=_TIFFMultiply64(tif,td->td_imagewidth,td->td_samplesperpixel,module);
scanline_size=TIFFhowmany_64(multiply_64(tif,scanline_samples,td->td_bitspersample,module),8); scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,scanline_samples,td->td_bitspersample,module),8);
} }
} }
else else
scanline_size=TIFFhowmany_64(multiply_64(tif,td->td_imagewidth,td->td_bitspersample,module),8); scanline_size=TIFFhowmany_64(_TIFFMultiply64(tif,td->td_imagewidth,td->td_bitspersample,module),8);
return(scanline_size); return(scanline_size);
} }
tmsize_t tmsize_t
@ -373,12 +347,12 @@ TIFFRasterScanlineSize64(TIFF* tif)
TIFFDirectory *td = &tif->tif_dir; TIFFDirectory *td = &tif->tif_dir;
uint64 scanline; uint64 scanline;
scanline = multiply_64 (tif, td->td_bitspersample, td->td_imagewidth, module); scanline = _TIFFMultiply64(tif, td->td_bitspersample, td->td_imagewidth, module);
if (td->td_planarconfig == PLANARCONFIG_CONTIG) { if (td->td_planarconfig == PLANARCONFIG_CONTIG) {
scanline = multiply_64 (tif, scanline, td->td_samplesperpixel, module); scanline = _TIFFMultiply64(tif, scanline, td->td_samplesperpixel, module);
return (TIFFhowmany8_64(scanline)); return (TIFFhowmany8_64(scanline));
} else } else
return (multiply_64 (tif, TIFFhowmany8_64(scanline), return (_TIFFMultiply64(tif, TIFFhowmany8_64(scanline),
td->td_samplesperpixel, module)); td->td_samplesperpixel, module));
} }
tmsize_t tmsize_t

44
libtiff/tif_tile.c
View File

@ -1,4 +1,4 @@
/* $Id: tif_tile.c,v 1.21 2010-03-10 18:56:49 bfriesen Exp $ */ /* $Id: tif_tile.c,v 1.22 2010-07-01 15:33:28 dron Exp $ */
/* /*
* Copyright (c) 1991-1997 Sam Leffler * Copyright (c) 1991-1997 Sam Leffler
@ -31,32 +31,6 @@
*/ */
#include "tiffiop.h" #include "tiffiop.h"
static uint32
multiply_32(TIFF* tif, uint32 nmemb, uint32 elem_size, const char* where)
{
uint32 bytes = nmemb * elem_size;
if (elem_size && bytes / elem_size != nmemb) {
TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
bytes = 0;
}
return (bytes);
}
static uint64
multiply_64(TIFF* tif, uint64 nmemb, uint64 elem_size, const char* where)
{
uint64 bytes = nmemb * elem_size;
if (elem_size && bytes / elem_size != nmemb) {
TIFFErrorExt(tif->tif_clientdata, where, "Integer overflow in %s", where);
bytes = 0;
}
return (bytes);
}
/* /*
* Compute which tile an (x,y,z,s) value is in. * Compute which tile an (x,y,z,s) value is in.
*/ */
@ -153,12 +127,12 @@ TIFFNumberOfTiles(TIFF* tif)
if (dz == (uint32) -1) if (dz == (uint32) -1)
dz = td->td_imagedepth; dz = td->td_imagedepth;
ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 : ntiles = (dx == 0 || dy == 0 || dz == 0) ? 0 :
multiply_32(tif, multiply_32(tif, TIFFhowmany_32(td->td_imagewidth, dx), _TIFFMultiply32(tif, _TIFFMultiply32(tif, TIFFhowmany_32(td->td_imagewidth, dx),
TIFFhowmany_32(td->td_imagelength, dy), TIFFhowmany_32(td->td_imagelength, dy),
"TIFFNumberOfTiles"), "TIFFNumberOfTiles"),
TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles"); TIFFhowmany_32(td->td_imagedepth, dz), "TIFFNumberOfTiles");
if (td->td_planarconfig == PLANARCONFIG_SEPARATE) if (td->td_planarconfig == PLANARCONFIG_SEPARATE)
ntiles = multiply_32(tif, ntiles, td->td_samplesperpixel, ntiles = _TIFFMultiply32(tif, ntiles, td->td_samplesperpixel,
"TIFFNumberOfTiles"); "TIFFNumberOfTiles");
return (ntiles); return (ntiles);
} }
@ -174,10 +148,10 @@ TIFFTileRowSize64(TIFF* tif)
if (td->td_tilelength == 0 || td->td_tilewidth == 0) if (td->td_tilelength == 0 || td->td_tilewidth == 0)
return (0); return (0);
rowsize = multiply_64(tif, td->td_bitspersample, td->td_tilewidth, rowsize = _TIFFMultiply64(tif, td->td_bitspersample, td->td_tilewidth,
"TIFFTileRowSize"); "TIFFTileRowSize");
if (td->td_planarconfig == PLANARCONFIG_CONTIG) if (td->td_planarconfig == PLANARCONFIG_CONTIG)
rowsize = multiply_64(tif, rowsize, td->td_samplesperpixel, rowsize = _TIFFMultiply64(tif, rowsize, td->td_samplesperpixel,
"TIFFTileRowSize"); "TIFFTileRowSize");
return (TIFFhowmany8_64(rowsize)); return (TIFFhowmany8_64(rowsize));
} }
@ -240,12 +214,12 @@ TIFFVTileSize64(TIFF* tif, uint32 nrows)
samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2; samplingblock_samples=ycbcrsubsampling[0]*ycbcrsubsampling[1]+2;
samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampling[0]); samplingblocks_hor=TIFFhowmany_32(td->td_tilewidth,ycbcrsubsampling[0]);
samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]); samplingblocks_ver=TIFFhowmany_32(nrows,ycbcrsubsampling[1]);
samplingrow_samples=multiply_64(tif,samplingblocks_hor,samplingblock_samples,module); samplingrow_samples=_TIFFMultiply64(tif,samplingblocks_hor,samplingblock_samples,module);
samplingrow_size=TIFFhowmany8_64(multiply_64(tif,samplingrow_samples,td->td_bitspersample,module)); samplingrow_size=TIFFhowmany8_64(_TIFFMultiply64(tif,samplingrow_samples,td->td_bitspersample,module));
return(multiply_64(tif,samplingrow_size,samplingblocks_ver,module)); return(_TIFFMultiply64(tif,samplingrow_size,samplingblocks_ver,module));
} }
else else
return(multiply_64(tif,nrows,TIFFTileRowSize64(tif),module)); return(_TIFFMultiply64(tif,nrows,TIFFTileRowSize64(tif),module));
} }
tmsize_t tmsize_t
TIFFVTileSize(TIFF* tif, uint32 nrows) TIFFVTileSize(TIFF* tif, uint32 nrows)

11
libtiff/tiffiop.h
View File

@ -1,4 +1,4 @@
/* $Id: tiffiop.h,v 1.79 2010-06-12 02:55:30 bfriesen Exp $ */ /* $Id: tiffiop.h,v 1.80 2010-07-01 15:33:28 dron Exp $ */
/* /*
* Copyright (c) 1988-1997 Sam Leffler * Copyright (c) 1988-1997 Sam Leffler
@ -319,8 +319,10 @@ extern TIFFErrorHandler _TIFFerrorHandler;
extern TIFFErrorHandlerExt _TIFFwarningHandlerExt; extern TIFFErrorHandlerExt _TIFFwarningHandlerExt;
extern TIFFErrorHandlerExt _TIFFerrorHandlerExt; extern TIFFErrorHandlerExt _TIFFerrorHandlerExt;
extern void* _TIFFCheckMalloc(TIFF* tif, tmsize_t nmemb, tmsize_t elem_size, const char* what); extern uint32 _TIFFMultiply32(TIFF*, uint32, uint32, const char*);
extern void* _TIFFCheckRealloc(TIFF* tif, void* buffer, tmsize_t nmemb, tmsize_t elem_size, const char* what); extern uint64 _TIFFMultiply64(TIFF*, uint64, uint64, const char*);
extern void* _TIFFCheckMalloc(TIFF*, tmsize_t, tmsize_t, const char*);
extern void* _TIFFCheckRealloc(TIFF*, void*, tmsize_t, tmsize_t, const char*);
extern double _TIFFUInt64ToDouble(uint64); extern double _TIFFUInt64ToDouble(uint64);
extern float _TIFFUInt64ToFloat(uint64); extern float _TIFFUInt64ToFloat(uint64);
@ -360,6 +362,9 @@ extern int TIFFInitPixarLog(TIFF*, int);
#ifdef LOGLUV_SUPPORT #ifdef LOGLUV_SUPPORT
extern int TIFFInitSGILog(TIFF*, int); extern int TIFFInitSGILog(TIFF*, int);
#endif #endif
#ifdef LZMA_SUPPORT
extern int TIFFInitLZMA(TIFF*, int);
#endif
#ifdef VMS #ifdef VMS
extern const TIFFCodec _TIFFBuiltinCODECS[]; extern const TIFFCodec _TIFFBuiltinCODECS[];
#else #else

802
m4/acinclude.m4
View File

@ -170,97 +170,130 @@ dnl Available from the GNU Autoconf Macro Archive at:
dnl http://www.gnu.org/software/ac-archive/ax_check_gl.html dnl http://www.gnu.org/software/ac-archive/ax_check_gl.html
dnl --------------------------------------------------------------------------- dnl ---------------------------------------------------------------------------
dnl @synopsis AX_CHECK_GL dnl SYNOPSIS
dnl dnl
dnl Check for an OpenGL implementation. If GL is found, the required dnl AX_CHECK_GL
dnl compiler and linker flags are included in the output variables
dnl "GL_CFLAGS" and "GL_LIBS", respectively. This macro adds the
dnl configure option "--with-apple-opengl-framework", which users can
dnl use to indicate that Apple's OpenGL framework should be used on Mac
dnl OS X. If Apple's OpenGL framework is used, the symbol
dnl "HAVE_APPLE_OPENGL_FRAMEWORK" is defined. If no GL implementation
dnl is found, "no_gl" is set to "yes".
dnl dnl
dnl @category InstalledPackages dnl DESCRIPTION
dnl @author Braden McDaniel <braden@endoframe.com> dnl
dnl @version 2004-11-15 dnl Check for an OpenGL implementation. If GL is found, the required
dnl @license AllPermissive dnl compiler and linker flags are included in the output variables
dnl "GL_CFLAGS" and "GL_LIBS", respectively. If no usable GL implementation
dnl is found, "no_gl" is set to "yes".
dnl
dnl If the header "GL/gl.h" is found, "HAVE_GL_GL_H" is defined. If the
dnl header "OpenGL/gl.h" is found, HAVE_OPENGL_GL_H is defined. These
dnl preprocessor definitions may not be mutually exclusive.
dnl
dnl LICENSE
dnl
dnl Copyright (c) 2009 Braden McDaniel <braden@endoframe.com>
dnl
dnl This program is free software; you can redistribute it and/or modify it
dnl under the terms of the GNU General Public License as published by the
dnl Free Software Foundation; either version 2 of the License, or (at your
dnl option) any later version.
dnl
dnl This program is distributed in the hope that it will be useful, but
dnl WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
dnl Public License for more details.
dnl
dnl You should have received a copy of the GNU General Public License along
dnl with this program. If not, see <http://www.gnu.org/licenses/>.
dnl
dnl As a special exception, the respective Autoconf Macro's copyright owner
dnl gives unlimited permission to copy, distribute and modify the configure
dnl scripts that are the output of Autoconf when processing the Macro. You
dnl need not follow the terms of the GNU General Public License when using
dnl or distributing such scripts, even though portions of the text of the
dnl Macro appear in them. The GNU General Public License (GPL) does govern
dnl all other use of the material that constitutes the Autoconf Macro.
dnl
dnl This special exception to the GPL applies to versions of the Autoconf
dnl Macro released by the Autoconf Archive. When you make and distribute a
dnl modified version of the Autoconf Macro, you may extend this special
dnl exception to the GPL to apply to your modified version as well.
AC_DEFUN([AX_CHECK_GL], AC_DEFUN([AX_CHECK_GL],
[AC_REQUIRE([AC_PATH_X])dnl [AC_REQUIRE([AC_CANONICAL_HOST])
AC_REQUIRE([ACX_PTHREAD])dnl AC_REQUIRE([AC_PATH_X])dnl
AC_REQUIRE([AX_PTHREAD])dnl
# AC_LANG_PUSH([C])
# There isn't a reliable way to know we should use the Apple OpenGL framework AX_LANG_COMPILER_MS
# without a configure option. A Mac OS X user may have installed an AS_IF([test X$ax_compiler_ms = Xno],
# alternative GL implementation (e.g., Mesa), which may or may not depend on X. [GL_CFLAGS="${PTHREAD_CFLAGS}"; GL_LIBS="${PTHREAD_LIBS} -lm"])
#
AC_ARG_WITH([apple-opengl-framework],
[AC_HELP_STRING([--with-apple-opengl-framework],
[use Apple OpenGL framework (Mac OS X only)])])
if test "X$with_apple_opengl_framework" = "Xyes"; then
AC_DEFINE([HAVE_APPLE_OPENGL_FRAMEWORK], [1],
[Use the Apple OpenGL framework.])
GL_LIBS="-framework OpenGL"
else
AC_LANG_PUSH(C)
AX_LANG_COMPILER_MS dnl
if test X$ax_compiler_ms = Xno; then dnl Use x_includes and x_libraries if they have been set (presumably by
GL_CFLAGS="${PTHREAD_CFLAGS}" dnl AC_PATH_X).
GL_LIBS="${PTHREAD_LIBS} -lm" dnl
fi AS_IF([test "X$no_x" != "Xyes"],
[AS_IF([test -n "$x_includes"],
[GL_CFLAGS="-I${x_includes} ${GL_CFLAGS}"])]
AS_IF([test -n "$x_libraries"],
[GL_LIBS="-L${x_libraries} -lX11 ${GL_LIBS}"]))
# ax_save_CPPFLAGS="${CPPFLAGS}"
# Use x_includes and x_libraries if they have been set (presumably by CPPFLAGS="${GL_CFLAGS} ${CPPFLAGS}"
# AC_PATH_X). AC_CHECK_HEADERS([GL/gl.h OpenGL/gl.h])
# CPPFLAGS="${ax_save_CPPFLAGS}"
if test "X$no_x" != "Xyes"; then
if test -n "$x_includes"; then
GL_CFLAGS="-I${x_includes} ${GL_CFLAGS}"
fi
if test -n "$x_libraries"; then
GL_LIBS="-L${x_libraries} -lX11 ${GL_LIBS}"
fi
fi
AC_CHECK_HEADERS([windows.h]) AC_CHECK_HEADERS([windows.h])
AC_CACHE_CHECK([for OpenGL library], [ax_cv_check_gl_libgl], m4_define([AX_CHECK_GL_PROGRAM],
[ax_cv_check_gl_libgl="no" [AC_LANG_PROGRAM([[
ax_save_CPPFLAGS="${CPPFLAGS}" # if defined(HAVE_WINDOWS_H) && defined(_WIN32)
CPPFLAGS="${GL_CFLAGS} ${CPPFLAGS}"
ax_save_LIBS="${LIBS}"
LIBS=""
ax_check_libs="-lopengl32 -lGL"
for ax_lib in ${ax_check_libs}; do
if test X$ax_compiler_ms = Xyes; then
ax_try_lib=`echo $ax_lib | sed -e 's/^-l//' -e 's/$/.lib/'`
else
ax_try_lib="${ax_lib}"
fi
LIBS="${ax_try_lib} ${GL_LIBS} ${ax_save_LIBS}"
AC_LINK_IFELSE(
[AC_LANG_PROGRAM([[
# if HAVE_WINDOWS_H && defined(_WIN32)
# include <windows.h> # include <windows.h>
# endif # endif
# include <GL/gl.h>]], # ifdef HAVE_GL_GL_H
[[glBegin(0)]])], # include <GL/gl.h>
[ax_cv_check_gl_libgl="${ax_try_lib}"; break]) # elif defined(HAVE_OPENGL_GL_H)
done # include <OpenGL/gl.h>
LIBS=${ax_save_LIBS} # else
CPPFLAGS=${ax_save_CPPFLAGS}]) # error no gl.h
# endif]],
[[glBegin(0)]])])
if test "X${ax_cv_check_gl_libgl}" = "Xno"; then AC_CACHE_CHECK([for OpenGL library], [ax_cv_check_gl_libgl],
no_gl="yes" [ax_cv_check_gl_libgl="no"
GL_CFLAGS="" case $host_cpu in
GL_LIBS="" x86_64) ax_check_gl_libdir=lib64 ;;
else *) ax_check_gl_libdir=lib ;;
GL_LIBS="${ax_cv_check_gl_libgl} ${GL_LIBS}" esac
fi ax_save_CPPFLAGS="${CPPFLAGS}"
AC_LANG_POP(C) CPPFLAGS="${GL_CFLAGS} ${CPPFLAGS}"
fi ax_save_LIBS="${LIBS}"
LIBS=""
ax_check_libs="-lopengl32 -lGL"
for ax_lib in ${ax_check_libs}; do
AS_IF([test X$ax_compiler_ms = Xyes],
[ax_try_lib=`echo $ax_lib | sed -e 's/^-l//' -e 's/$/.lib/'`],
[ax_try_lib="${ax_lib}"])
LIBS="${ax_try_lib} ${GL_LIBS} ${ax_save_LIBS}"
AC_LINK_IFELSE([AX_CHECK_GL_PROGRAM],
[ax_cv_check_gl_libgl="${ax_try_lib}"; break],
[ax_check_gl_nvidia_flags="-L/usr/${ax_check_gl_libdir}/nvidia" LIBS="${ax_try_lib} ${ax_check_gl_nvidia_flags} ${GL_LIBS} ${ax_save_LIBS}"
AC_LINK_IFELSE([AX_CHECK_GL_PROGRAM],
[ax_cv_check_gl_libgl="${ax_try_lib} ${ax_check_gl_nvidia_flags}"; break],
[ax_check_gl_dylib_flag='-dylib_file /System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib:/System/Library/Frameworks/OpenGL.framework/Versions/A/Libraries/libGL.dylib' LIBS="${ax_try_lib} ${ax_check_gl_dylib_flag} ${GL_LIBS} ${ax_save_LIBS}"
AC_LINK_IFELSE([AX_CHECK_GL_PROGRAM],
[ax_cv_check_gl_libgl="${ax_try_lib} ${ax_check_gl_dylib_flag}"; break])])])
done
AS_IF([test "X$ax_cv_check_gl_libgl" = Xno -a "X$no_x" = Xyes],
[LIBS='-framework OpenGL'
AC_LINK_IFELSE([AX_CHECK_GL_PROGRAM],
[ax_cv_check_gl_libgl="$LIBS"])])
LIBS=${ax_save_LIBS}
CPPFLAGS=${ax_save_CPPFLAGS}])
AS_IF([test "X$ax_cv_check_gl_libgl" = Xno],
[no_gl=yes; GL_CFLAGS=""; GL_LIBS=""],
[GL_LIBS="${ax_cv_check_gl_libgl} ${GL_LIBS}"])
AC_LANG_POP([C])
AC_SUBST([GL_CFLAGS]) AC_SUBST([GL_CFLAGS])
AC_SUBST([GL_LIBS]) AC_SUBST([GL_LIBS])
@ -271,76 +304,151 @@ dnl Available from the GNU Autoconf Macro Archive at:
dnl http://www.gnu.org/software/ac-archive/ax_check_glu.html dnl http://www.gnu.org/software/ac-archive/ax_check_glu.html
dnl --------------------------------------------------------------------------- dnl ---------------------------------------------------------------------------
dnl @synopsis AX_CHECK_GLU dnl SYNOPSIS
dnl dnl
dnl Check for GLU. If GLU is found, the required preprocessor and dnl AX_CHECK_GLU
dnl linker flags are included in the output variables "GLU_CFLAGS" and
dnl "GLU_LIBS", respectively. This macro adds the configure option
dnl "--with-apple-opengl-framework", which users can use to indicate
dnl that Apple's OpenGL framework should be used on Mac OS X. If
dnl Apple's OpenGL framework is used, the symbol
dnl "HAVE_APPLE_OPENGL_FRAMEWORK" is defined. If no GLU implementation
dnl is found, "no_glu" is set to "yes".
dnl dnl
dnl @category InstalledPackages dnl DESCRIPTION
dnl @author Braden McDaniel <braden@endoframe.com> dnl
dnl @version 2004-11-15 dnl Check for GLU. If GLU is found, the required preprocessor and linker
dnl @license AllPermissive dnl flags are included in the output variables "GLU_CFLAGS" and "GLU_LIBS",
dnl respectively. If no GLU implementation is found, "no_glu" is set to
dnl "yes".
dnl
dnl If the header "GL/glu.h" is found, "HAVE_GL_GLU_H" is defined. If the
dnl header "OpenGL/glu.h" is found, HAVE_OPENGL_GLU_H is defined. These
dnl preprocessor definitions may not be mutually exclusive.
dnl
dnl Some implementations (in particular, some versions of Mac OS X) are
dnl known to treat the GLU tesselator callback function type as "GLvoid
dnl (*)(...)" rather than the standard "GLvoid (*)()". If the former
dnl condition is detected, this macro defines "HAVE_VARARGS_GLU_TESSCB".
dnl
dnl LICENSE
dnl
dnl Copyright (c) 2009 Braden McDaniel <braden@endoframe.com>
dnl
dnl This program is free software; you can redistribute it and/or modify it
dnl under the terms of the GNU General Public License as published by the
dnl Free Software Foundation; either version 2 of the License, or (at your
dnl option) any later version.
dnl
dnl This program is distributed in the hope that it will be useful, but
dnl WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
dnl Public License for more details.
dnl
dnl You should have received a copy of the GNU General Public License along
dnl with this program. If not, see <http://www.gnu.org/licenses/>.
dnl
dnl As a special exception, the respective Autoconf Macro's copyright owner
dnl gives unlimited permission to copy, distribute and modify the configure
dnl scripts that are the output of Autoconf when processing the Macro. You
dnl need not follow the terms of the GNU General Public License when using
dnl or distributing such scripts, even though portions of the text of the
dnl Macro appear in them. The GNU General Public License (GPL) does govern
dnl all other use of the material that constitutes the Autoconf Macro.
dnl
dnl This special exception to the GPL applies to versions of the Autoconf
dnl Macro released by the Autoconf Archive. When you make and distribute a
dnl modified version of the Autoconf Macro, you may extend this special
dnl exception to the GPL to apply to your modified version as well.
AC_DEFUN([AX_CHECK_GLU], AC_DEFUN([AX_CHECK_GLU],
[AC_REQUIRE([AX_CHECK_GL])dnl [AC_REQUIRE([AX_CHECK_GL])dnl
AC_REQUIRE([AC_PROG_CXX])dnl AC_REQUIRE([AC_PROG_CXX])dnl
GLU_CFLAGS="${GL_CFLAGS}" GLU_CFLAGS="${GL_CFLAGS}"
if test "X${with_apple_opengl_framework}" != "Xyes"; then
AC_CACHE_CHECK([for OpenGL Utility library], [ax_cv_check_glu_libglu], ax_save_CPPFLAGS="${CPPFLAGS}"
[ax_cv_check_glu_libglu="no" CPPFLAGS="${GL_CFLAGS} ${CPPFLAGS}"
ax_save_CPPFLAGS="${CPPFLAGS}" AC_CHECK_HEADERS([GL/glu.h OpenGL/glu.h])
CPPFLAGS="${GL_CFLAGS} ${CPPFLAGS}" CPPFLAGS="${ax_save_CPPFLAGS}"
ax_save_LIBS="${LIBS}"
LIBS="" m4_define([AX_CHECK_GLU_PROGRAM],
ax_check_libs="-lglu32 -lGLU" [AC_LANG_PROGRAM([[
for ax_lib in ${ax_check_libs}; do # if defined(HAVE_WINDOWS_H) && defined(_WIN32)
if test X$ax_compiler_ms = Xyes; then
ax_try_lib=`echo $ax_lib | sed -e 's/^-l//' -e 's/$/.lib/'`
else
ax_try_lib="${ax_lib}"
fi
LIBS="${ax_try_lib} ${GL_LIBS} ${ax_save_LIBS}"
#
# libGLU typically links with libstdc++ on POSIX platforms. However,
# setting the language to C++ means that test program source is named
# "conftest.cc"; and Microsoft cl doesn't know what to do with such a
# file.
#
AC_LANG_PUSH([C++])
if test X$ax_compiler_ms = Xyes; then
AC_LANG_PUSH([C])
fi
AC_LINK_IFELSE(
[AC_LANG_PROGRAM([[
# if HAVE_WINDOWS_H && defined(_WIN32)
# include <windows.h> # include <windows.h>
# endif # endif
# include <GL/glu.h>]], # ifdef HAVE_GL_GLU_H
[[gluBeginCurve(0)]])], # include <GL/glu.h>
[ax_cv_check_glu_libglu="${ax_try_lib}"; break]) # elif defined(HAVE_OPENGL_GLU_H)
if test X$ax_compiler_ms = Xyes; then # include <OpenGL/glu.h>
AC_LANG_POP([C]) # else
fi # error no glu.h
AC_LANG_POP([C++]) # endif]],
done [[gluBeginCurve(0)]])])
LIBS=${ax_save_LIBS}
CPPFLAGS=${ax_save_CPPFLAGS}]) AC_CACHE_CHECK([for OpenGL Utility library], [ax_cv_check_glu_libglu],
if test "X${ax_cv_check_glu_libglu}" = "Xno"; then [ax_cv_check_glu_libglu="no"
no_glu="yes" ax_save_CPPFLAGS="${CPPFLAGS}"
GLU_CFLAGS="" CPPFLAGS="${GL_CFLAGS} ${CPPFLAGS}"
GLU_LIBS="" ax_save_LIBS="${LIBS}"
else
GLU_LIBS="${ax_cv_check_glu_libglu} ${GL_LIBS}" dnl
fi dnl First, check for the possibility that everything we need is already in
fi dnl GL_LIBS.
dnl
LIBS="${GL_LIBS} ${ax_save_LIBS}"
dnl
dnl libGLU typically links with libstdc++ on POSIX platforms.
dnl However, setting the language to C++ means that test program
dnl source is named "conftest.cc"; and Microsoft cl doesn't know what
dnl to do with such a file.
dnl
AC_LANG_PUSH([C++])
AS_IF([test X$ax_compiler_ms = Xyes],
[AC_LANG_PUSH([C])])
AC_LINK_IFELSE(
[AX_CHECK_GLU_PROGRAM],
[ax_cv_check_glu_libglu=yes],
[LIBS=""
ax_check_libs="-lglu32 -lGLU"
for ax_lib in ${ax_check_libs}; do
AS_IF([test X$ax_compiler_ms = Xyes],
[ax_try_lib=`echo $ax_lib | sed -e 's/^-l//' -e 's/$/.lib/'`],
[ax_try_lib="${ax_lib}"])
LIBS="${ax_try_lib} ${GL_LIBS} ${ax_save_LIBS}"
AC_LINK_IFELSE([AX_CHECK_GLU_PROGRAM],
[ax_cv_check_glu_libglu="${ax_try_lib}"; break])
done
])
AS_IF([test X$ax_compiler_ms = Xyes],
[AC_LANG_POP([C])])
AC_LANG_POP([C++])
LIBS=${ax_save_LIBS}
CPPFLAGS=${ax_save_CPPFLAGS}])
AS_IF([test "X$ax_cv_check_glu_libglu" = Xno],
[no_glu=yes; GLU_CFLAGS=""; GLU_LIBS=""],
[AS_IF([test "X$ax_cv_check_glu_libglu" = Xyes],
[GLU_LIBS="$GL_LIBS"],
[GLU_LIBS="${ax_cv_check_glu_libglu} ${GL_LIBS}"])])
AC_SUBST([GLU_CFLAGS]) AC_SUBST([GLU_CFLAGS])
AC_SUBST([GLU_LIBS]) AC_SUBST([GLU_LIBS])
dnl
dnl Some versions of Mac OS X include a broken interpretation of the GLU
dnl tesselation callback function signature.
dnl
AS_IF([test "X$ax_cv_check_glu_libglu" != Xno],
[AC_CACHE_CHECK([for varargs GLU tesselator callback function type],
[ax_cv_varargs_glu_tesscb],
[ax_cv_varargs_glu_tesscb=no
ax_save_CFLAGS="$CFLAGS"
CFLAGS="$GL_CFLAGS $CFLAGS"
AC_COMPILE_IFELSE(
[AC_LANG_PROGRAM([[
# ifdef HAVE_GL_GLU_H
# include <GL/glu.h>
# else
# include <OpenGL/glu.h>
# endif]],
[[GLvoid (*func)(...); gluTessCallback(0, 0, func)]])],
[ax_cv_varargs_glu_tesscb=yes])
CFLAGS="$ax_save_CFLAGS"])
AS_IF([test X$ax_cv_varargs_glu_tesscb = Xyes],
[AC_DEFINE([HAVE_VARARGS_GLU_TESSCB], [1],
[Use nonstandard varargs form for the GLU tesselator callback])])])
]) ])
dnl --------------------------------------------------------------------------- dnl ---------------------------------------------------------------------------
@ -348,80 +456,112 @@ dnl Available from the GNU Autoconf Macro Archive at:
dnl http://www.gnu.org/software/ac-archive/ax_check_glut.html dnl http://www.gnu.org/software/ac-archive/ax_check_glut.html
dnl --------------------------------------------------------------------------- dnl ---------------------------------------------------------------------------
dnl @synopsis AX_CHECK_GLUT
dnl dnl
dnl Check for GLUT. If GLUT is found, the required compiler and linker dnl SYNOPSIS
dnl flags are included in the output variables "GLUT_CFLAGS" and
dnl "GLUT_LIBS", respectively. This macro adds the configure option
dnl "--with-apple-opengl-framework", which users can use to indicate
dnl that Apple's OpenGL framework should be used on Mac OS X. If
dnl Apple's OpenGL framework is used, the symbol
dnl "HAVE_APPLE_OPENGL_FRAMEWORK" is defined. If GLUT is not found,
dnl "no_glut" is set to "yes".
dnl dnl
dnl @category InstalledPackages dnl AX_CHECK_GLUT
dnl @author Braden McDaniel <braden@endoframe.com> dnl
dnl @version 2004-11-15 dnl DESCRIPTION
dnl @license AllPermissive dnl
dnl Check for GLUT. If GLUT is found, the required compiler and linker flags
dnl are included in the output variables "GLUT_CFLAGS" and "GLUT_LIBS",
dnl respectively. If GLUT is not found, "no_glut" is set to "yes".
dnl
dnl If the header "GL/glut.h" is found, "HAVE_GL_GLUT_H" is defined. If the
dnl header "GLUT/glut.h" is found, HAVE_GLUT_GLUT_H is defined. These
dnl preprocessor definitions may not be mutually exclusive.
dnl
dnl LICENSE
dnl
dnl Copyright (c) 2009 Braden McDaniel <braden@endoframe.com>
dnl
dnl This program is free software; you can redistribute it and/or modify it
dnl under the terms of the GNU General Public License as published by the
dnl Free Software Foundation; either version 2 of the License, or (at your
dnl option) any later version.
dnl
dnl This program is distributed in the hope that it will be useful, but
dnl WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
dnl Public License for more details.
dnl
dnl You should have received a copy of the GNU General Public License along
dnl with this program. If not, see <http://www.gnu.org/licenses/>.
dnl
dnl As a special exception, the respective Autoconf Macro's copyright owner
dnl gives unlimited permission to copy, distribute and modify the configure
dnl scripts that are the output of Autoconf when processing the Macro. You
dnl need not follow the terms of the GNU General Public License when using
dnl or distributing such scripts, even though portions of the text of the
dnl Macro appear in them. The GNU General Public License (GPL) does govern
dnl all other use of the material that constitutes the Autoconf Macro.
dnl
dnl This special exception to the GPL applies to versions of the Autoconf
dnl Macro released by the Autoconf Archive. When you make and distribute a
dnl modified version of the Autoconf Macro, you may extend this special
dnl exception to the GPL to apply to your modified version as well.
AC_DEFUN([AX_CHECK_GLUT], AC_DEFUN([AX_CHECK_GLUT],
[AC_REQUIRE([AX_CHECK_GLU])dnl [AC_REQUIRE([AX_CHECK_GLU])dnl
AC_REQUIRE([AC_PATH_XTRA])dnl AC_REQUIRE([AC_PATH_XTRA])dnl
if test "X$with_apple_opengl_framework" = "Xyes"; then ax_save_CPPFLAGS="${CPPFLAGS}"
GLUT_CFLAGS="${GLU_CFLAGS}" CPPFLAGS="${GLU_CFLAGS} ${CPPFLAGS}"
GLUT_LIBS="-framework GLUT -lobjc ${GL_LIBS}" AC_CHECK_HEADERS([GL/glut.h GLUT/glut.h])
else CPPFLAGS="${ax_save_CPPFLAGS}"
GLUT_CFLAGS=${GLU_CFLAGS}
GLUT_LIBS=${GLU_LIBS}
# GLUT_CFLAGS=${GLU_CFLAGS}
# If X is present, assume GLUT depends on it. GLUT_LIBS=${GLU_LIBS}
#
if test "X${no_x}" != "Xyes"; then
GLUT_LIBS="${X_PRE_LIBS} -lXmu -lXi ${X_EXTRA_LIBS} ${GLUT_LIBS}"
fi
AC_LANG_PUSH(C) m4_define([AX_CHECK_GLUT_PROGRAM],
[AC_LANG_PROGRAM([[
ax_save_CPPFLAGS="${CPPFLAGS}"
CPPFLAGS="${GLUT_CFLAGS} ${CPPFLAGS}"
AC_CACHE_CHECK([for GLUT library], [ax_cv_check_glut_libglut],
[ax_cv_check_glut_libglut="no"
ax_save_LIBS="${LIBS}"
LIBS=""
ax_check_libs="-lglut32 -lglut"
for ax_lib in ${ax_check_libs}; do
if test X$ax_compiler_ms = Xyes; then
ax_try_lib=`echo $ax_lib | sed -e 's/^-l//' -e 's/$/.lib/'`
else
ax_try_lib="${ax_lib}"
fi
LIBS="${ax_try_lib} ${GLUT_LIBS} ${ax_save_LIBS}"
AC_LINK_IFELSE(
[AC_LANG_PROGRAM([[
# if HAVE_WINDOWS_H && defined(_WIN32) # if HAVE_WINDOWS_H && defined(_WIN32)
# include <windows.h> # include <windows.h>
# endif # endif
# include <GL/glut.h>]], # ifdef HAVE_GL_GLUT_H
[[glutMainLoop()]])], # include <GL/glut.h>
[ax_cv_check_glut_libglut="${ax_try_lib}"; break]) # elif defined(HAVE_GLUT_GLUT_H)
# include <GLUT/glut.h>
# else
# error no glut.h
# endif]],
[[glutMainLoop()]])])
done dnl
LIBS=${ax_save_LIBS} dnl If X is present, assume GLUT depends on it.
]) dnl
CPPFLAGS="${ax_save_CPPFLAGS}" AS_IF([test X$no_x != Xyes],
AC_LANG_POP(C) [GLUT_LIBS="${X_PRE_LIBS} -lXi ${X_EXTRA_LIBS} ${GLUT_LIBS}"])
if test "X${ax_cv_check_glut_libglut}" = "Xno"; then AC_CACHE_CHECK([for GLUT library], [ax_cv_check_glut_libglut],
no_glut="yes" [ax_cv_check_glut_libglut="no"
GLUT_CFLAGS="" AC_LANG_PUSH(C)
GLUT_LIBS="" ax_save_CPPFLAGS="${CPPFLAGS}"
else CPPFLAGS="${GLUT_CFLAGS} ${CPPFLAGS}"
GLUT_LIBS="${ax_cv_check_glut_libglut} ${GLUT_LIBS}" ax_save_LIBS="${LIBS}"
fi LIBS=""
fi ax_check_libs="-lglut32 -lglut"
for ax_lib in ${ax_check_libs}; do
AS_IF([test X$ax_compiler_ms = Xyes],
[ax_try_lib=`echo $ax_lib | sed -e 's/^-l//' -e 's/$/.lib/'`],
[ax_try_lib="${ax_lib}"])
LIBS="${ax_try_lib} ${GLUT_LIBS} ${ax_save_LIBS}"
AC_LINK_IFELSE([AX_CHECK_GLUT_PROGRAM],
[ax_cv_check_glut_libglut="${ax_try_lib}"; break])
done
AS_IF([test "X$ax_cv_check_glut_libglut" = Xno -a "X$no_x" = Xyes],
[LIBS='-framework GLUT'
AC_LINK_IFELSE([AX_CHECK_GLUT_PROGRAM],
[ax_cv_check_glut_libglut="$LIBS"])])
CPPFLAGS="${ax_save_CPPFLAGS}"
LIBS="${ax_save_LIBS}"
AC_LANG_POP(C)])
AS_IF([test "X$ax_cv_check_glut_libglut" = Xno],
[no_glut="yes"; GLUT_CFLAGS=""; GLUT_LIBS=""],
[GLUT_LIBS="${ax_cv_check_glut_libglut} ${GLUT_LIBS}"])
AC_SUBST([GLUT_CFLAGS]) AC_SUBST([GLUT_CFLAGS])
AC_SUBST([GLUT_LIBS]) AC_SUBST([GLUT_LIBS])
@ -429,77 +569,105 @@ AC_SUBST([GLUT_LIBS])
dnl --------------------------------------------------------------------------- dnl ---------------------------------------------------------------------------
dnl Available from the GNU Autoconf Macro Archive at: dnl Available from the GNU Autoconf Macro Archive at:
dnl http://www.gnu.org/software/ac-archive/acx_pthread.html dnl http://www.gnu.org/software/autoconf-archive/ax_pthread.html
dnl --------------------------------------------------------------------------- dnl ---------------------------------------------------------------------------
dnl @synopsis ACX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]]) dnl SYNOPSIS
dnl dnl
dnl This macro figures out how to build C programs using POSIX threads. dnl AX_PTHREAD([ACTION-IF-FOUND[, ACTION-IF-NOT-FOUND]])
dnl It sets the PTHREAD_LIBS output variable to the threads library and
dnl linker flags, and the PTHREAD_CFLAGS output variable to any special
dnl C compiler flags that are needed. (The user can also force certain
dnl compiler flags/libs to be tested by setting these environment
dnl variables.)
dnl dnl
dnl Also sets PTHREAD_CC to any special C compiler that is needed for dnl DESCRIPTION
dnl multi-threaded programs (defaults to the value of CC otherwise).
dnl (This is necessary on AIX to use the special cc_r compiler alias.)
dnl dnl
dnl NOTE: You are assumed to not only compile your program with these dnl This macro figures out how to build C programs using POSIX threads. It
dnl flags, but also link it with them as well. e.g. you should link dnl sets the PTHREAD_LIBS output variable to the threads library and linker
dnl with $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS dnl flags, and the PTHREAD_CFLAGS output variable to any special C compiler
dnl $LIBS dnl flags that are needed. (The user can also force certain compiler
dnl flags/libs to be tested by setting these environment variables.)
dnl dnl
dnl If you are only building threads programs, you may wish to use dnl Also sets PTHREAD_CC to any special C compiler that is needed for
dnl these variables in your default LIBS, CFLAGS, and CC: dnl multi-threaded programs (defaults to the value of CC otherwise). (This
dnl is necessary on AIX to use the special cc_r compiler alias.)
dnl dnl
dnl LIBS="$PTHREAD_LIBS $LIBS" dnl NOTE: You are assumed to not only compile your program with these flags,
dnl CFLAGS="$CFLAGS $PTHREAD_CFLAGS" dnl but also link it with them as well. e.g. you should link with
dnl CC="$PTHREAD_CC" dnl $PTHREAD_CC $CFLAGS $PTHREAD_CFLAGS $LDFLAGS ... $PTHREAD_LIBS $LIBS
dnl dnl
dnl In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute dnl If you are only building threads programs, you may wish to use these
dnl constant has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to dnl variables in your default LIBS, CFLAGS, and CC:
dnl that name (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
dnl dnl
dnl ACTION-IF-FOUND is a list of shell commands to run if a threads dnl LIBS="$PTHREAD_LIBS $LIBS"
dnl library is found, and ACTION-IF-NOT-FOUND is a list of commands to dnl CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
dnl run it if it is not found. If ACTION-IF-FOUND is not specified, the dnl CC="$PTHREAD_CC"
dnl default action will define HAVE_PTHREAD.
dnl dnl
dnl Please let the authors know if this macro fails on any platform, or dnl In addition, if the PTHREAD_CREATE_JOINABLE thread-attribute constant
dnl if you have any other suggestions or comments. This macro was based dnl has a nonstandard name, defines PTHREAD_CREATE_JOINABLE to that name
dnl on work by SGJ on autoconf scripts for FFTW (www.fftw.org) (with dnl (e.g. PTHREAD_CREATE_UNDETACHED on AIX).
dnl help from M. Frigo), as well as ac_pthread and hb_pthread macros
dnl posted by Alejandro Forero Cuervo to the autoconf macro repository.
dnl We are also grateful for the helpful feedback of numerous users.
dnl dnl
dnl @category InstalledPackages dnl ACTION-IF-FOUND is a list of shell commands to run if a threads library
dnl @author Steven G. Johnson <stevenj@alum.mit.edu> dnl is found, and ACTION-IF-NOT-FOUND is a list of commands to run it if it
dnl @version 2005-01-14 dnl is not found. If ACTION-IF-FOUND is not specified, the default action
dnl @license GPLWithACException dnl will define HAVE_PTHREAD.
dnl
dnl Please let the authors know if this macro fails on any platform, or if
dnl you have any other suggestions or comments. This macro was based on work
dnl by SGJ on autoconf scripts for FFTW (http://www.fftw.org/) (with help
dnl from M. Frigo), as well as ac_pthread and hb_pthread macros posted by
dnl Alejandro Forero Cuervo to the autoconf macro repository. We are also
dnl grateful for the helpful feedback of numerous users.
dnl
dnl LICENSE
dnl
dnl Copyright (c) 2008 Steven G. Johnson <stevenj@alum.mit.edu>
dnl
dnl This program is free software: you can redistribute it and/or modify it
dnl under the terms of the GNU General Public License as published by the
dnl Free Software Foundation, either version 3 of the License, or (at your
dnl option) any later version.
dnl
dnl This program is distributed in the hope that it will be useful, but
dnl WITHOUT ANY WARRANTY; without even the implied warranty of
dnl MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
dnl Public License for more details.
dnl
dnl You should have received a copy of the GNU General Public License along
dnl with this program. If not, see <http://www.gnu.org/licenses/>.
dnl
dnl As a special exception, the respective Autoconf Macro's copyright owner
dnl gives unlimited permission to copy, distribute and modify the configure
dnl scripts that are the output of Autoconf when processing the Macro. You
dnl need not follow the terms of the GNU General Public License when using
dnl or distributing such scripts, even though portions of the text of the
dnl Macro appear in them. The GNU General Public License (GPL) does govern
dnl all other use of the material that constitutes the Autoconf Macro.
dnl
dnl This special exception to the GPL applies to versions of the Autoconf
dnl Macro released by the Autoconf Archive. When you make and distribute a
dnl modified version of the Autoconf Macro, you may extend this special
dnl exception to the GPL to apply to your modified version as well.
AC_DEFUN([ACX_PTHREAD], [ AU_ALIAS([ACX_PTHREAD], [AX_PTHREAD])
AC_DEFUN([AX_PTHREAD], [
AC_REQUIRE([AC_CANONICAL_HOST]) AC_REQUIRE([AC_CANONICAL_HOST])
AC_LANG_SAVE AC_LANG_SAVE
AC_LANG_C AC_LANG_C
acx_pthread_ok=no ax_pthread_ok=no
# We used to check for pthread.h first, but this fails if pthread.h dnl We used to check for pthread.h first, but this fails if pthread.h
# requires special compiler flags (e.g. on True64 or Sequent). dnl requires special compiler flags (e.g. on True64 or Sequent).
# It gets checked for in the link test anyway. dnl It gets checked for in the link test anyway.
# First of all, check if the user has set any of the PTHREAD_LIBS, dnl First of all, check if the user has set any of the PTHREAD_LIBS,
# etcetera environment variables, and if threads linking works using dnl etcetera environment variables, and if threads linking works using
# them: dnl them:
if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
save_CFLAGS="$CFLAGS" save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS" CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
save_LIBS="$LIBS" save_LIBS="$LIBS"
LIBS="$PTHREAD_LIBS $LIBS" LIBS="$PTHREAD_LIBS $LIBS"
AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS]) AC_MSG_CHECKING([for pthread_join in LIBS=$PTHREAD_LIBS with CFLAGS=$PTHREAD_CFLAGS])
AC_TRY_LINK_FUNC(pthread_join, acx_pthread_ok=yes) AC_TRY_LINK_FUNC(pthread_join, ax_pthread_ok=yes)
AC_MSG_RESULT($acx_pthread_ok) AC_MSG_RESULT($ax_pthread_ok)
if test x"$acx_pthread_ok" = xno; then if test x"$ax_pthread_ok" = xno; then
PTHREAD_LIBS="" PTHREAD_LIBS=""
PTHREAD_CFLAGS="" PTHREAD_CFLAGS=""
fi fi
@ -507,54 +675,59 @@ if test x"$PTHREAD_LIBS$PTHREAD_CFLAGS" != x; then
CFLAGS="$save_CFLAGS" CFLAGS="$save_CFLAGS"
fi fi
# We must check for the threads library under a number of different dnl We must check for the threads library under a number of different
# names; the ordering is very important because some systems dnl names; the ordering is very important because some systems
# (e.g. DEC) have both -lpthread and -lpthreads, where one of the dnl (e.g. DEC) have both -lpthread and -lpthreads, where one of the
# libraries is broken (non-POSIX). dnl libraries is broken (non-POSIX).
# Create a list of thread flags to try. Items starting with a "-" are dnl Create a list of thread flags to try. Items starting with a "-" are
# C compiler flags, and other items are library names, except for "none" dnl C compiler flags, and other items are library names, except for "none"
# which indicates that we try without any flags at all, and "pthread-config" dnl which indicates that we try without any flags at all, and "pthread-config"
# which is a program returning the flags for the Pth emulation library. dnl which is a program returning the flags for the Pth emulation library.
acx_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config" ax_pthread_flags="pthreads none -Kthread -kthread lthread -pthread -pthreads -mthreads pthread --thread-safe -mt pthread-config"
# The ordering *is* (sometimes) important. Some notes on the dnl The ordering *is* (sometimes) important. Some notes on the
# individual items follow: dnl individual items follow:
# pthreads: AIX (must check this before -lpthread) dnl pthreads: AIX (must check this before -lpthread)
# none: in case threads are in libc; should be tried before -Kthread and dnl none: in case threads are in libc; should be tried before -Kthread and
# other compiler flags to prevent continual compiler warnings dnl other compiler flags to prevent continual compiler warnings
# -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h) dnl -Kthread: Sequent (threads in libc, but -Kthread needed for pthread.h)
# -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able) dnl -kthread: FreeBSD kernel threads (preferred to -pthread since SMP-able)
# lthread: LinuxThreads port on FreeBSD (also preferred to -pthread) dnl lthread: LinuxThreads port on FreeBSD (also preferred to -pthread)
# -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads) dnl -pthread: Linux/gcc (kernel threads), BSD/gcc (userland threads)
# -pthreads: Solaris/gcc dnl -pthreads: Solaris/gcc
# -mthreads: Mingw32/gcc, Lynx/gcc dnl -mthreads: Mingw32/gcc, Lynx/gcc
# -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it dnl -mt: Sun Workshop C (may only link SunOS threads [-lthread], but it
# doesn't hurt to check since this sometimes defines pthreads too; dnl doesn't hurt to check since this sometimes defines pthreads too;
# also defines -D_REENTRANT) dnl also defines -D_REENTRANT)
# pthread: Linux, etcetera dnl ... -mt is also the pthreads flag for HP/aCC
# --thread-safe: KAI C++ dnl pthread: Linux, etcetera
# pthread-config: use pthread-config program (for GNU Pth library) dnl --thread-safe: KAI C++
dnl pthread-config: use pthread-config program (for GNU Pth library)
case "${host_cpu}-${host_os}" in case "${host_cpu}-${host_os}" in
*solaris*) *solaris*)
# On Solaris (at least, for some versions), libc contains stubbed dnl On Solaris (at least, for some versions), libc contains stubbed
# (non-functional) versions of the pthreads routines, so link-based dnl (non-functional) versions of the pthreads routines, so link-based
# tests will erroneously succeed. (We need to link with -pthread or dnl tests will erroneously succeed. (We need to link with -pthreads/-mt/
# -lpthread.) (The stubs are missing pthread_cleanup_push, or rather dnl -lpthread.) (The stubs are missing pthread_cleanup_push, or rather
# a function called by this macro, so we could check for that, but dnl a function called by this macro, so we could check for that, but
# who knows whether they'll stub that too in a future libc.) So, dnl who knows whether they'll stub that too in a future libc.) So,
# we'll just look for -pthreads and -lpthread first: dnl we'll just look for -pthreads and -lpthread first:
acx_pthread_flags="-pthread -pthreads pthread -mt $acx_pthread_flags" ax_pthread_flags="-pthreads pthread -mt -pthread $ax_pthread_flags"
;; ;;
*-darwin*)
ax_pthread_flags="-pthread $ax_pthread_flags"
;;
esac esac
if test x"$acx_pthread_ok" = xno; then if test x"$ax_pthread_ok" = xno; then
for flag in $acx_pthread_flags; do for flag in $ax_pthread_flags; do
case $flag in case $flag in
none) none)
@ -567,8 +740,8 @@ for flag in $acx_pthread_flags; do
;; ;;
pthread-config) pthread-config)
AC_CHECK_PROG(acx_pthread_config, pthread-config, yes, no) AC_CHECK_PROG(ax_pthread_config, pthread-config, yes, no)
if test x"$acx_pthread_config" = xno; then continue; fi if test x"$ax_pthread_config" = xno; then continue; fi
PTHREAD_CFLAGS="`pthread-config --cflags`" PTHREAD_CFLAGS="`pthread-config --cflags`"
PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`" PTHREAD_LIBS="`pthread-config --ldflags` `pthread-config --libs`"
;; ;;
@ -584,26 +757,31 @@ for flag in $acx_pthread_flags; do
LIBS="$PTHREAD_LIBS $LIBS" LIBS="$PTHREAD_LIBS $LIBS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS" CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
# Check for various functions. We must include pthread.h, dnl Check for various functions. We must include pthread.h,
# since some functions may be macros. (On the Sequent, we dnl since some functions may be macros. (On the Sequent, we
# need a special flag -Kthread to make this header compile.) dnl need a special flag -Kthread to make this header compile.)
# We check for pthread_join because it is in -lpthread on IRIX dnl We check for pthread_join because it is in -lpthread on IRIX
# while pthread_create is in libc. We check for pthread_attr_init dnl while pthread_create is in libc. We check for pthread_attr_init
# due to DEC craziness with -lpthreads. We check for dnl due to DEC craziness with -lpthreads. We check for
# pthread_cleanup_push because it is one of the few pthread dnl pthread_cleanup_push because it is one of the few pthread
# functions on Solaris that doesn't have a non-functional libc stub. dnl functions on Solaris that doesn't have a non-functional libc stub.
# We try pthread_create on general principles. dnl We try pthread_create on general principles.
AC_TRY_LINK([#include <pthread.h>], AC_TRY_LINK([#include <pthread.h>
[pthread_t th; pthread_join(th, 0); static void routine(void* a) {a=0;}
pthread_attr_init(0); pthread_cleanup_push(0, 0); static void* start_routine(void* a) {return a;}],
pthread_create(0,0,0,0); pthread_cleanup_pop(0); ], [pthread_t th; pthread_attr_t attr;
[acx_pthread_ok=yes]) pthread_create(&th,0,start_routine,0);
pthread_join(th, 0);
pthread_attr_init(&attr);
pthread_cleanup_push(routine, 0);
pthread_cleanup_pop(0); ],
[ax_pthread_ok=yes])
LIBS="$save_LIBS" LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS" CFLAGS="$save_CFLAGS"
AC_MSG_RESULT($acx_pthread_ok) AC_MSG_RESULT($ax_pthread_ok)
if test "x$acx_pthread_ok" = xyes; then if test "x$ax_pthread_ok" = xyes; then
break; break;
fi fi
@ -612,18 +790,18 @@ for flag in $acx_pthread_flags; do
done done
fi fi
# Various other checks: dnl Various other checks:
if test "x$acx_pthread_ok" = xyes; then if test "x$ax_pthread_ok" = xyes; then
save_LIBS="$LIBS" save_LIBS="$LIBS"
LIBS="$PTHREAD_LIBS $LIBS" LIBS="$PTHREAD_LIBS $LIBS"
save_CFLAGS="$CFLAGS" save_CFLAGS="$CFLAGS"
CFLAGS="$CFLAGS $PTHREAD_CFLAGS" CFLAGS="$CFLAGS $PTHREAD_CFLAGS"
# Detect AIX lossage: JOINABLE attribute is called UNDETACHED. dnl Detect AIX lossage: JOINABLE attribute is called UNDETACHED.
AC_MSG_CHECKING([for joinable pthread attribute]) AC_MSG_CHECKING([for joinable pthread attribute])
attr_name=unknown attr_name=unknown
for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do for attr in PTHREAD_CREATE_JOINABLE PTHREAD_CREATE_UNDETACHED; do
AC_TRY_LINK([#include <pthread.h>], [int attr=$attr;], AC_TRY_LINK([#include <pthread.h>], [int attr=$attr; return attr;],
[attr_name=$attr; break]) [attr_name=$attr; break])
done done
AC_MSG_RESULT($attr_name) AC_MSG_RESULT($attr_name)
@ -647,8 +825,12 @@ if test "x$acx_pthread_ok" = xyes; then
LIBS="$save_LIBS" LIBS="$save_LIBS"
CFLAGS="$save_CFLAGS" CFLAGS="$save_CFLAGS"
# More AIX lossage: must compile with cc_r dnl More AIX lossage: must compile with xlc_r or cc_r
AC_CHECK_PROG(PTHREAD_CC, cc_r, cc_r, ${CC}) if test x"$GCC" != xyes; then
AC_CHECK_PROGS(PTHREAD_CC, xlc_r cc_r, ${CC})
else
PTHREAD_CC=$CC
fi
else else
PTHREAD_CC="$CC" PTHREAD_CC="$CC"
fi fi
@ -657,13 +839,13 @@ AC_SUBST(PTHREAD_LIBS)
AC_SUBST(PTHREAD_CFLAGS) AC_SUBST(PTHREAD_CFLAGS)
AC_SUBST(PTHREAD_CC) AC_SUBST(PTHREAD_CC)
# Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND: dnl Finally, execute ACTION-IF-FOUND/ACTION-IF-NOT-FOUND:
if test x"$acx_pthread_ok" = xyes; then if test x"$ax_pthread_ok" = xyes; then
ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1]) ifelse([$1],,AC_DEFINE(HAVE_PTHREAD,1,[Define if you have POSIX threads libraries and header files.]),[$1])
: :
else else
acx_pthread_ok=no ax_pthread_ok=no
$2 $2
fi fi
AC_LANG_RESTORE AC_LANG_RESTORE
])dnl ACX_PTHREAD ])dnl AX_PTHREAD