# AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])

# ----------------------------------------------------------------

# If the C compiler is not in ISO C99 mode by default, try to add an

# option to output variable CC to make it so.  This macro tries

# various options that select ISO C99 on some system or another.  It

# considers the compiler to be in ISO C99 mode if it handles _Bool,

# // comments, flexible array members, inline, long long int, mixed

# code and declarations, named initialization of structs, restrict,

# va_copy, varargs macros, variable declarations in for loops and

# variable length arrays.

AC_DEFUN([AC_PROG_CC_C99],

[AC_C_STD_TRY([c99],

[[#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);

}

]],

[[

  // 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);

]],

dnl Try

dnl GCC		-std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999)

dnl AIX		-qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99)

dnl Intel ICC	-c99

dnl IRIX	-c99

dnl Solaris	(unused because it causes the compiler to assume C99 semantics for

dnl		library functions, and this is invalid before Solaris 10: -xc99)

dnl Tru64	-c99

dnl with extended modes being tried first.

[[-std=gnu99 -c99 -qlanglvl=extc99]], [$1], [$2])[]dnl

])# AC_PROG_CC_C99

# AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST,

#		ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE)

# --------------------------------------------------------------

# Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99')

# by trying to compile a program of TEST-PROLOGUE and TEST-BODY.  If this fails,

# try again with each compiler option in the space-separated OPTION-LIST; if one

# helps, append it to CC.  If eventually successful, run ACTION-IF-AVAILABLE,

# else ACTION-IF-UNAVAILABLE.

AC_DEFUN([AC_C_STD_TRY],

[AC_MSG_CHECKING([for $CC option to accept ISO ]m4_translit($1, [c], [C]))

AC_CACHE_VAL(ac_cv_prog_cc_$1,

[ac_cv_prog_cc_$1=no

ac_save_CC=$CC

AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])

for ac_arg in '' $4

do

  CC="$ac_save_CC $ac_arg"

  _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg])

  test "x$ac_cv_prog_cc_$1" != "xno" && break

done

rm -f conftest.$ac_ext

CC=$ac_save_CC

])# AC_CACHE_VAL

case "x$ac_cv_prog_cc_$1" in

  x)

    AC_MSG_RESULT([none needed]) ;;

  xno)

    AC_MSG_RESULT([unsupported]) ;;

  *)

    CC="$CC $ac_cv_prog_cc_$1"

    AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;;

esac

AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6])

])# AC_C_STD_TRY