cline: comparison configure

-:63477d92411d
+:5acf05940667
 --disable-option-checking  ignore unrecognized --enable/--with options
 --disable-FEATURE       do not include FEATURE (same as --enable-FEATURE=no)
 --enable-FEATURE[=ARG]  include FEATURE [ARG=yes]
 --enable-silent-rules   less verbose build output (undo: "make V=1")
 --disable-silent-rules  verbose build output (undo: "make V=0")
---enable-debug    Turn on debugging
+--enable-debug          Turn on debugging
 --enable-dependency-tracking
 do not reject slow dependency extractors
 --disable-dependency-tracking
 speeds up one-time build
 DEBUG_TRUE='#'
 DEBUG_FALSE=
 fi
-# Checks for programs.
+# Compiler (empty default options)
+${CFLAGS=""}
 ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
 ac_compiler_gnu=$ac_cv_c_compiler_gnu
 am__fastdepCC_TRUE='#'
 am__fastdepCC_FALSE=
 fi
+case $ac_cv_prog_cc_stdc in #(
-# Checks for libraries.
+no) :
+ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no ;; #(
+*) :
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C99" >&5
+$as_echo_n "checking for $CC option to accept ISO C99... " >&6; }
+if ${ac_cv_prog_cc_c99+:} false; then :
+$as_echo_n "(cached) " >&6
+else
+ac_cv_prog_cc_c99=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdbool.h>
+#include <stdlib.h>
+#include <wchar.h>
+#include <stdio.h>
+// Check varargs macros.  These examples are taken from C99 6.10.3.5.
+#define debug(...) fprintf (stderr, __VA_ARGS__)
+#define showlist(...) puts (#__VA_ARGS__)
+#define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
+static void
+test_varargs_macros (void)
+{
+int x = 1234;
+int y = 5678;
+debug ("Flag");
+debug ("X = %d\n", x);
+showlist (The first, second, and third items.);
+report (x>y, "x is %d but y is %d", x, y);
+}
+// Check long long types.
+#define BIG64 18446744073709551615ull
+#define BIG32 4294967295ul
+#define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
+#if !BIG_OK
+your preprocessor is broken;
+#endif
+#if BIG_OK
+#else
+your preprocessor is broken;
+#endif
+static long long int bignum = -9223372036854775807LL;
+static unsigned long long int ubignum = BIG64;
+struct incomplete_array
+{
+int datasize;
+double data[];
+};
+struct named_init {
+int number;
+const wchar_t *name;
+double average;
+};
+typedef const char *ccp;
+static inline int
+test_restrict (ccp restrict text)
+{
+// See if C++-style comments work.
+// Iterate through items via the restricted pointer.
+// Also check for declarations in for loops.
+for (unsigned int i = 0; *(text+i) != '\0'; ++i)
+continue;
+return 0;
+}
+// Check varargs and va_copy.
+static void
+test_varargs (const char *format, ...)
+{
+va_list args;
+va_start (args, format);
+va_list args_copy;
+va_copy (args_copy, args);
+const char *str;
+int number;
+float fnumber;
+while (*format)
+{
+switch (*format++)
+	{
+	case 's': // string
+	  str = va_arg (args_copy, const char *);
+	  break;
+	case 'd': // int
+	  number = va_arg (args_copy, int);
+	  break;
+	case 'f': // float
+	  fnumber = va_arg (args_copy, double);
+	  break;
+	default:
+	  break;
+	}
+}
+va_end (args_copy);
+va_end (args);
+}
+int
+main ()
+{
+// Check bool.
+_Bool success = false;
+// Check restrict.
+if (test_restrict ("String literal") == 0)
+success = true;
+char *restrict newvar = "Another string";
+// Check varargs.
+test_varargs ("s, d' f .", "string", 65, 34.234);
+test_varargs_macros ();
+// Check flexible array members.
+struct incomplete_array *ia =
+malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
+ia->datasize = 10;
+for (int i = 0; i < ia->datasize; ++i)
+ia->data[i] = i * 1.234;
+// Check named initializers.
+struct named_init ni = {
+.number = 34,
+.name = L"Test wide string",
+.average = 543.34343,
+};
+ni.number = 58;
+int dynamic_array[ni.number];
+dynamic_array[ni.number - 1] = 543;
+// work around unused variable warnings
+return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
+	  || dynamic_array[ni.number - 1] != 543);
+;
+return 0;
+}
+_ACEOF
+for ac_arg in '' -std=gnu99 -std=c99 -c99 -AC99 -D_STDC_C99= -qlanglvl=extc99
+do
+CC="$ac_save_CC $ac_arg"
+if ac_fn_c_try_compile "$LINENO"; then :
+ac_cv_prog_cc_c99=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+test "x$ac_cv_prog_cc_c99" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c99" in
+x)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+xno)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+*)
+CC="$CC $ac_cv_prog_cc_c99"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c99" >&5
+$as_echo "$ac_cv_prog_cc_c99" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c99" != xno; then :
+ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99
+else
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO C89" >&5
+$as_echo_n "checking for $CC option to accept ISO C89... " >&6; }
+if ${ac_cv_prog_cc_c89+:} false; then :
+$as_echo_n "(cached) " >&6
+else
+ac_cv_prog_cc_c89=no
+ac_save_CC=$CC
+cat confdefs.h - <<_ACEOF >conftest.$ac_ext
+/* end confdefs.h.  */
+#include <stdarg.h>
+#include <stdio.h>
+struct stat;
+/* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
+struct buf { int x; };
+FILE * (*rcsopen) (struct buf *, struct stat *, int);
+static char *e (p, i)
+char **p;
+int i;
+{
+return p[i];
+}
+static char *f (char * (*g) (char **, int), char **p, ...)
+{
+char *s;
+va_list v;
+va_start (v,p);
+s = g (p, va_arg (v,int));
+va_end (v);
+return s;
+}
+/* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
+function prototypes and stuff, but not '\xHH' hex character constants.
+These don't provoke an error unfortunately, instead are silently treated
+as 'x'.  The following induces an error, until -std is added to get
+proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
+array size at least.  It's necessary to write '\x00'==0 to get something
+that's true only with -std.  */
+int osf4_cc_array ['\x00' == 0 ? 1 : -1];
+/* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
+inside strings and character constants.  */
+#define FOO(x) 'x'
+int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
+int test (int i, double x);
+struct s1 {int (*f) (int a);};
+struct s2 {int (*f) (double a);};
+int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
+int argc;
+char **argv;
+int
+main ()
+{
+return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];
+;
+return 0;
+}
+_ACEOF
+for ac_arg in '' -qlanglvl=extc89 -qlanglvl=ansi -std \
+	-Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"
+do
+CC="$ac_save_CC $ac_arg"
+if ac_fn_c_try_compile "$LINENO"; then :
+ac_cv_prog_cc_c89=$ac_arg
+fi
+rm -f core conftest.err conftest.$ac_objext
+test "x$ac_cv_prog_cc_c89" != "xno" && break
+done
+rm -f conftest.$ac_ext
+CC=$ac_save_CC
+fi
+# AC_CACHE_VAL
+case "x$ac_cv_prog_cc_c89" in
+x)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;;
+xno)
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;;
+*)
+CC="$CC $ac_cv_prog_cc_c89"
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_c89" >&5
+$as_echo "$ac_cv_prog_cc_c89" >&6; } ;;
+esac
+if test "x$ac_cv_prog_cc_c89" != xno; then :
+ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89
+else
+ac_cv_prog_cc_stdc=no
+fi
+fi
+;;
+esac
+{ $as_echo "$as_me:${as_lineno-$LINENO}: checking for $CC option to accept ISO Standard C" >&5
+$as_echo_n "checking for $CC option to accept ISO Standard C... " >&6; }
+if ${ac_cv_prog_cc_stdc+:} false; then :
+$as_echo_n "(cached) " >&6
+fi
+case $ac_cv_prog_cc_stdc in #(
+no) :
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: unsupported" >&5
+$as_echo "unsupported" >&6; } ;; #(
+'') :
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: none needed" >&5
+$as_echo "none needed" >&6; } ;; #(
+*) :
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $ac_cv_prog_cc_stdc" >&5
+$as_echo "$ac_cv_prog_cc_stdc" >&6; } ;;
+esac
 # Checks for header files.
 ac_ext=c
 ac_cpp='$CPP $CPPFLAGS'
 fi
 done
-for ac_header in stdlib.h string.h
+for ac_header in stdlib.h string.h dirent.h regex.h
 do :
 as_ac_Header=`$as_echo "ac_cv_header_$ac_header" | $as_tr_sh`
 ac_fn_c_check_header_mongrel "$LINENO" "$ac_header" "$as_ac_Header" "$ac_includes_default"
 if eval test \"x\$"$as_ac_Header"\" = x"yes"; then :
 cat >>confdefs.h <<_ACEOF

Mercurial > hg > cline / file comparison

comparison: configure

configure