| # IJG auto-configuration source file. |
| # Process this file with autoconf to produce a configure script. |
| |
| # |
| # Configure script for IJG libjpeg |
| # |
| |
| AC_INIT([libjpeg], [7.0]) |
| |
| # Directory where autotools helper scripts lives. |
| AC_CONFIG_AUX_DIR([.]) |
| |
| # Generate configuration headers. |
| AC_CONFIG_HEADERS([jconfig.h:jconfig.cfg]) |
| |
| # Hack: disable autoheader so that it doesn't overwrite our cfg template. |
| AUTOHEADER="echo autoheader ignored" |
| |
| # Check system type |
| AC_CANONICAL_TARGET |
| |
| # Initialize Automake |
| # Don't require all the GNU mandated files |
| AM_INIT_AUTOMAKE([-Wall -Werror ansi2knr no-dist foreign]) |
| |
| # Make --enable-silent-rules the default. |
| # To get verbose build output you may configure |
| # with --disable-silent-rules or use "make V=1". |
| AM_SILENT_RULES([yes]) |
| |
| # This is required when using the de-ANSI-fication feature. |
| AM_C_PROTOTYPES |
| |
| # Add configure option --enable-maintainer-mode which enables |
| # dependency checking and generation useful to package maintainers. |
| # This is made an option to avoid confusing end users. |
| AM_MAINTAINER_MODE |
| |
| # Check for programs |
| AC_PROG_CC |
| AC_PROG_CC_STDC |
| AC_PROG_CPP |
| AC_PROG_INSTALL |
| AC_PROG_MAKE_SET |
| AC_PROG_LN_S |
| |
| # Check if LD supports linker scripts, |
| # and define automake conditional HAVE_LD_VERSION_SCRIPT if so. |
| AC_ARG_ENABLE([ld-version-script], |
| AS_HELP_STRING([--enable-ld-version-script], |
| [enable linker version script (default is enabled when possible)]), |
| [have_ld_version_script=$enableval], []) |
| if test -z "$have_ld_version_script"; then |
| AC_MSG_CHECKING([if LD -Wl,--version-script works]) |
| save_LDFLAGS="$LDFLAGS" |
| LDFLAGS="$LDFLAGS -Wl,--version-script=conftest.map" |
| cat > conftest.map <<EOF |
| VERS_1 { |
| global: sym; |
| }; |
| |
| VERS_2 { |
| global: sym; |
| } VERS_1; |
| EOF |
| AC_LINK_IFELSE(AC_LANG_PROGRAM([], []), |
| [have_ld_version_script=yes], [have_ld_version_script=no]) |
| rm -f conftest.map |
| LDFLAGS="$save_LDFLAGS" |
| AC_MSG_RESULT($have_ld_version_script) |
| fi |
| AM_CONDITIONAL(HAVE_LD_VERSION_SCRIPT, test "$have_ld_version_script" = "yes") |
| |
| # See if compiler supports prototypes. |
| AC_MSG_CHECKING(for function prototypes) |
| AC_CACHE_VAL(ijg_cv_have_prototypes, |
| [AC_TRY_COMPILE([ |
| int testfunction (int arg1, int * arg2); /* check prototypes */ |
| struct methods_struct { /* check method-pointer declarations */ |
| int (*error_exit) (char *msgtext); |
| int (*trace_message) (char *msgtext); |
| int (*another_method) (void); |
| }; |
| int testfunction (int arg1, int * arg2) /* check definitions */ |
| { return arg2[arg1]; } |
| int test2function (void) /* check void arg list */ |
| { return 0; } |
| ], [ ], ijg_cv_have_prototypes=yes, ijg_cv_have_prototypes=no)]) |
| AC_MSG_RESULT($ijg_cv_have_prototypes) |
| if test $ijg_cv_have_prototypes = yes; then |
| AC_DEFINE([HAVE_PROTOTYPES],[1],[Compiler supports function prototypes.]) |
| else |
| echo Your compiler does not seem to know about function prototypes. |
| echo Perhaps it needs a special switch to enable ANSI C mode. |
| echo If so, we recommend running configure like this: |
| echo " ./configure CC='cc -switch'" |
| echo where -switch is the proper switch. |
| fi |
| |
| # Check header files |
| AC_CHECK_HEADERS(stddef.h stdlib.h locale.h) |
| AC_CHECK_HEADER(string.h, , AC_DEFINE([NEED_BSD_STRINGS],[1],[Compiler has <strings.h> rather than standard <string.h>.])) |
| |
| # See whether type size_t is defined in any ANSI-standard places; |
| # if not, perhaps it is defined in <sys/types.h>. |
| AC_MSG_CHECKING(for size_t) |
| AC_TRY_COMPILE([ |
| #ifdef HAVE_STDDEF_H |
| #include <stddef.h> |
| #endif |
| #ifdef HAVE_STDLIB_H |
| #include <stdlib.h> |
| #endif |
| #include <stdio.h> |
| #ifdef NEED_BSD_STRINGS |
| #include <strings.h> |
| #else |
| #include <string.h> |
| #endif |
| typedef size_t my_size_t; |
| ], [ my_size_t foovar; ], ijg_size_t_ok=yes, |
| [ijg_size_t_ok="not ANSI, perhaps it is in sys/types.h"]) |
| AC_MSG_RESULT($ijg_size_t_ok) |
| if test "$ijg_size_t_ok" != yes; then |
| AC_CHECK_HEADER(sys/types.h, [AC_DEFINE([NEED_SYS_TYPES_H],[1],[Need to include <sys/types.h> in order to obtain size_t.]) |
| AC_EGREP_CPP(size_t, [#include <sys/types.h>], |
| [ijg_size_t_ok="size_t is in sys/types.h"], ijg_size_t_ok=no)], |
| ijg_size_t_ok=no) |
| AC_MSG_RESULT($ijg_size_t_ok) |
| if test "$ijg_size_t_ok" = no; then |
| echo Type size_t is not defined in any of the usual places. |
| echo Try putting '"typedef unsigned int size_t;"' in jconfig.h. |
| fi |
| fi |
| |
| # Check compiler characteristics |
| AC_MSG_CHECKING(for type unsigned char) |
| AC_TRY_COMPILE(, [ unsigned char un_char; ], |
| [AC_MSG_RESULT(yes) |
| AC_DEFINE([HAVE_UNSIGNED_CHAR],[1],[Compiler supports 'unsigned char'.])], AC_MSG_RESULT(no)) |
| dnl |
| AC_MSG_CHECKING(for type unsigned short) |
| AC_TRY_COMPILE(, [ unsigned short un_short; ], |
| [AC_MSG_RESULT(yes) |
| AC_DEFINE([HAVE_UNSIGNED_SHORT],[1],[Compiler supports 'unsigned short'.])], AC_MSG_RESULT(no)) |
| dnl |
| AC_MSG_CHECKING(for type void) |
| AC_TRY_COMPILE([ |
| /* Caution: a C++ compiler will insist on valid prototypes */ |
| typedef void * void_ptr; /* check void * */ |
| #ifdef HAVE_PROTOTYPES /* check ptr to function returning void */ |
| typedef void (*void_func) (int a, int b); |
| #else |
| typedef void (*void_func) (); |
| #endif |
| |
| #ifdef HAVE_PROTOTYPES /* check void function result */ |
| void test3function (void_ptr arg1, void_func arg2) |
| #else |
| void test3function (arg1, arg2) |
| void_ptr arg1; |
| void_func arg2; |
| #endif |
| { |
| char * locptr = (char *) arg1; /* check casting to and from void * */ |
| arg1 = (void *) locptr; |
| (*arg2) (1, 2); /* check call of fcn returning void */ |
| } |
| ], [ ], AC_MSG_RESULT(yes), [AC_MSG_RESULT(no) |
| AC_DEFINE([void],[char],[Define 'void' as 'char' for archaic compilers that don't understand it.])]) |
| AC_C_CONST |
| |
| # Check for non-broken inline under various spellings |
| AC_MSG_CHECKING(for inline) |
| ijg_cv_inline="" |
| AC_TRY_COMPILE(, [} __inline__ int foo() { return 0; } |
| int bar() { return foo();], ijg_cv_inline="__inline__", |
| AC_TRY_COMPILE(, [} __inline int foo() { return 0; } |
| int bar() { return foo();], ijg_cv_inline="__inline", |
| AC_TRY_COMPILE(, [} inline int foo() { return 0; } |
| int bar() { return foo();], ijg_cv_inline="inline"))) |
| AC_MSG_RESULT($ijg_cv_inline) |
| AC_DEFINE_UNQUOTED([INLINE],[$ijg_cv_inline],[How to obtain function inlining.]) |
| |
| # We cannot check for bogus warnings, but at least we can check for errors |
| AC_MSG_CHECKING(for broken incomplete types) |
| AC_TRY_COMPILE([ typedef struct undefined_structure * undef_struct_ptr; ], , |
| AC_MSG_RESULT(ok), |
| [AC_MSG_RESULT(broken) |
| AC_DEFINE([INCOMPLETE_TYPES_BROKEN],[1],[Compiler does not support pointers to unspecified structures.])]) |
| |
| # Test whether global names are unique to at least 15 chars |
| AC_MSG_CHECKING(for short external names) |
| AC_TRY_LINK([ |
| int possibly_duplicate_function () { return 0; } |
| int possibly_dupli_function () { return 1; } |
| ], [ ], AC_MSG_RESULT(ok), [AC_MSG_RESULT(short) |
| AC_DEFINE([NEED_SHORT_EXTERNAL_NAMES],[1],[Linker requires that global names be unique in first 15 characters.])]) |
| |
| # Run-time checks |
| AC_MSG_CHECKING(to see if char is signed) |
| AC_TRY_RUN([ |
| #ifdef HAVE_PROTOTYPES |
| int is_char_signed (int arg) |
| #else |
| int is_char_signed (arg) |
| int arg; |
| #endif |
| { |
| if (arg == 189) { /* expected result for unsigned char */ |
| return 0; /* type char is unsigned */ |
| } |
| else if (arg != -67) { /* expected result for signed char */ |
| printf("Hmm, it seems 'char' is not eight bits wide on your machine.\n"); |
| printf("I fear the JPEG software will not work at all.\n\n"); |
| } |
| return 1; /* assume char is signed otherwise */ |
| } |
| char signed_char_check = (char) (-67); |
| int main() { |
| exit(is_char_signed((int) signed_char_check)); |
| }], [AC_MSG_RESULT(no) |
| AC_DEFINE([CHAR_IS_UNSIGNED],[1],[Characters are unsigned])], AC_MSG_RESULT(yes), |
| [echo Assuming that char is signed on target machine. |
| echo If it is unsigned, this will be a little bit inefficient. |
| ]) |
| dnl |
| AC_MSG_CHECKING(to see if right shift is signed) |
| AC_TRY_RUN([ |
| #ifdef HAVE_PROTOTYPES |
| int is_shifting_signed (long arg) |
| #else |
| int is_shifting_signed (arg) |
| long arg; |
| #endif |
| /* See whether right-shift on a long is signed or not. */ |
| { |
| long res = arg >> 4; |
| |
| if (res == -0x7F7E80CL) { /* expected result for signed shift */ |
| return 1; /* right shift is signed */ |
| } |
| /* see if unsigned-shift hack will fix it. */ |
| /* we can't just test exact value since it depends on width of long... */ |
| res |= (~0L) << (32-4); |
| if (res == -0x7F7E80CL) { /* expected result now? */ |
| return 0; /* right shift is unsigned */ |
| } |
| printf("Right shift isn't acting as I expect it to.\n"); |
| printf("I fear the JPEG software will not work at all.\n\n"); |
| return 0; /* try it with unsigned anyway */ |
| } |
| int main() { |
| exit(is_shifting_signed(-0x7F7E80B1L)); |
| }], [AC_MSG_RESULT(no) |
| AC_DEFINE([RIGHT_SHIFT_IS_UNSIGNED],[1],[Broken compiler shifts signed values as an unsigned shift.])], AC_MSG_RESULT(yes), |
| AC_MSG_RESULT(Assuming that right shift is signed on target machine.)) |
| dnl |
| AC_MSG_CHECKING(to see if fopen accepts b spec) |
| AC_TRY_RUN([ |
| #include <stdio.h> |
| int main() { |
| if (fopen("conftestdata", "wb") != NULL) |
| exit(0); |
| exit(1); |
| }], AC_MSG_RESULT(yes), [AC_MSG_RESULT(no) |
| AC_DEFINE([DONT_USE_B_MODE],[1],[Don't open files in binary mode.])], |
| AC_MSG_RESULT(Assuming that it does.)) |
| |
| # Configure libtool |
| AC_LIBTOOL_WIN32_DLL |
| AC_PROG_LIBTOOL |
| |
| # Select memory manager depending on user input. |
| # If no "-enable-maxmem", use jmemnobs |
| MEMORYMGR='jmemnobs' |
| MAXMEM="no" |
| AC_ARG_ENABLE(maxmem, |
| [ --enable-maxmem[=N] enable use of temp files, set max mem usage to N MB], |
| MAXMEM="$enableval") |
| dnl [# support --with-maxmem for backwards compatibility with IJG V5.] |
| dnl AC_ARG_WITH(maxmem, , MAXMEM="$withval") |
| if test "x$MAXMEM" = xyes; then |
| MAXMEM=1 |
| fi |
| if test "x$MAXMEM" != xno; then |
| if test -n "`echo $MAXMEM | sed 's/[[0-9]]//g'`"; then |
| AC_MSG_ERROR(non-numeric argument to --enable-maxmem) |
| fi |
| DEFAULTMAXMEM=`expr $MAXMEM \* 1048576` |
| AC_DEFINE_UNQUOTED([DEFAULT_MAX_MEM], [${DEFAULTMAXMEM}], [Maximum data space library will allocate.]) |
| AC_MSG_CHECKING([for 'tmpfile()']) |
| AC_TRY_LINK([#include <stdio.h>], [ FILE * tfile = tmpfile(); ], |
| [AC_MSG_RESULT(yes) |
| MEMORYMGR='jmemansi'], |
| [AC_MSG_RESULT(no) |
| dnl if tmpfile is not present, must use jmemname. |
| MEMORYMGR='jmemname' |
| |
| # Test for the need to remove temporary files using a signal handler (for cjpeg/djpeg) |
| AC_DEFINE([NEED_SIGNAL_CATCHER],[1],[Need signal handler to clean up temporary files.]) |
| AC_MSG_CHECKING([for 'mktemp()']) |
| AC_TRY_LINK(, [ char fname[80]; mktemp(fname); ], AC_MSG_RESULT(yes), |
| [AC_MSG_RESULT(no) |
| AC_DEFINE([NO_MKTEMP],[1],[The mktemp() function is not available.])])]) |
| fi |
| AC_SUBST(MEMORYMGR) |
| |
| # Extract the library version ID from jpeglib.h. |
| AC_MSG_CHECKING([libjpeg version number]) |
| [JPEG_LIB_VERSION=`sed -e '/^#define JPEG_LIB_VERSION/!d' -e 's/^[^0-9]*\([0-9][0-9]*\).*$/\1/' $srcdir/jpeglib.h`] |
| [JPEG_LIB_VERSION="`expr $JPEG_LIB_VERSION / 10`:`expr $JPEG_LIB_VERSION % 10`"] |
| AC_MSG_RESULT([$JPEG_LIB_VERSION]) |
| AC_SUBST([JPEG_LIB_VERSION]) |
| |
| AC_CONFIG_FILES([Makefile]) |
| AC_OUTPUT |