# IJG auto-configuration source file.

# Process this file with autoconf to produce a configure script.

#

# Configure script for IJG libjpeg

#

AC_INIT([libjpeg], [8.4.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 -Wno-obsolete 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_COMPILE_IFELSE([AC_LANG_SOURCE([[

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

AC_MSG_WARN([Your compiler does not seem to know about function prototypes.

Perhaps it needs a special switch to enable ANSI C mode.

If so, we recommend running configure like this:

./configure CC='cc -switch'

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

AC_MSG_WARN([Type size_t is not defined in any of the usual places.

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)])

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)])

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)],

[AC_MSG_WARN([Assuming that char is signed on target machine.

If it is unsigned, this will be a little bit inefficient.])

])

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.)])

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 IDs from jpeglib.h.

AC_MSG_CHECKING([libjpeg version number])

[major=`sed -ne 's/^#define JPEG_LIB_VERSION_MAJOR *\([0-9][0-9]*\).*$/\1/p' $srcdir/jpeglib.h`

minor=`sed -ne 's/^#define JPEG_LIB_VERSION_MINOR *\([0-9][0-9]*\).*$/\1/p' $srcdir/jpeglib.h`]

AC_SUBST([JPEG_LIB_VERSION],

[`expr $major + $minor`:0:$minor])

AC_MSG_RESULT([$JPEG_LIB_VERSION])

AC_CONFIG_FILES([Makefile])

AC_OUTPUT