Added Irrlicht 1.8, but without all the Windows binaries.

1 files changed, 356 insertions, 0 deletions

diff --git a/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/configure.ac b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/configure.ac
new file mode 100644
index 0000000..c3c3d81
--- /dev/null
+++ b/libraries/irrlicht-1.8/source/Irrlicht/jpeglib/configure.ac
@@ -0,0 +1,356 @@
+# 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