build/autoconf_prepend-include/autoconf/c.m4

   1 # This file is part of Autoconf.                        -*- Autoconf -*-
   2 # Programming languages support.
   3 # Copyright (C) 2001, 2002, 2003, 2004, 2005, 2006 Free Software
   4 # Foundation, Inc.
   5 #
   6 # This program is free software; you can redistribute it and/or modify
   7 # it under the terms of the GNU General Public License as published by
   8 # the Free Software Foundation; either version 2, or (at your option)
   9 # any later version.
  10 #
  11 # This program is distributed in the hope that it will be useful,
  12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 # GNU General Public License for more details.
  15 #
  16 # You should have received a copy of the GNU General Public License
  17 # along with this program; if not, write to the Free Software
  18 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  19 # 02110-1301, USA.
  20 #
  21 # As a special exception, the Free Software Foundation gives unlimited
  22 # permission to copy, distribute and modify the configure scripts that
  23 # are the output of Autoconf.  You need not follow the terms of the GNU
  24 # General Public License when using or distributing such scripts, even
  25 # though portions of the text of Autoconf appear in them.  The GNU
  26 # General Public License (GPL) does govern all other use of the material
  27 # that constitutes the Autoconf program.
  28 #
  29 # Certain portions of the Autoconf source text are designed to be copied
  30 # (in certain cases, depending on the input) into the output of
  31 # Autoconf.  We call these the "data" portions.  The rest of the Autoconf
  32 # source text consists of comments plus executable code that decides which
  33 # of the data portions to output in any given case.  We call these
  34 # comments and executable code the "non-data" portions.  Autoconf never
  35 # copies any of the non-data portions into its output.
  36 #
  37 # This special exception to the GPL applies to versions of Autoconf
  38 # released by the Free Software Foundation.  When you make and
  39 # distribute a modified version of Autoconf, you may extend this special
  40 # exception to the GPL to apply to your modified version as well, *unless*
  41 # your modified version has the potential to copy into its output some
  42 # of the text that was the non-data portion of the version that you started
  43 # with.  (In other words, unless your change moves or copies text from
  44 # the non-data portions to the data portions.)  If your modification has
  45 # such potential, you must delete any notice of this special exception
  46 # to the GPL from your modified version.
  47 #
  48 # Written by David MacKenzie, with help from
  49 # Akim Demaille, Paul Eggert,
  50 # Franc,ois Pinard, Karl Berry, Richard Pixley, Ian Lance Taylor,
  51 # Roland McGrath, Noah Friedman, david d zuhn, and many others.
  52
  53
  54 # -------------------- #
  55 # 1b. The C language.  #
  56 # -------------------- #
  57
  58
  59 # AC_LANG(C)
  60 # ----------
  61 # CFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
  62 m4_define([AC_LANG(C)],
  63 [ac_ext=c
  64 ac_cpp='$CPP $CPPFLAGS'
  65 ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
  66 ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
  67 ac_compiler_gnu=$ac_cv_c_compiler_gnu
  68 ])
  69
  70
  71 # AC_LANG_C
  72 # ---------
  73 AU_DEFUN([AC_LANG_C], [AC_LANG(C)])
  74
  75
  76 # _AC_LANG_ABBREV(C)
  77 # ------------------
  78 m4_define([_AC_LANG_ABBREV(C)], [c])
  79
  80
  81 # _AC_LANG_PREFIX(C)
  82 # ------------------
  83 m4_define([_AC_LANG_PREFIX(C)], [C])
  84
  85
  86 # ---------------------- #
  87 # 1c. The C++ language.  #
  88 # ---------------------- #
  89
  90
  91 # AC_LANG(C++)
  92 # ------------
  93 # CXXFLAGS is not in ac_cpp because -g, -O, etc. are not valid cpp options.
  94 m4_define([AC_LANG(C++)],
  95 [ac_ext=cpp
  96 ac_cpp='$CXXCPP $CPPFLAGS'
  97 ac_compile='$CXX -c $CXXFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
  98 ac_link='$CXX -o conftest$ac_exeext $CXXFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
  99 ac_compiler_gnu=$ac_cv_cxx_compiler_gnu
 100 ])
 101
 102
 103 # AC_LANG_CPLUSPLUS
 104 # -----------------
 105 AU_DEFUN([AC_LANG_CPLUSPLUS], [AC_LANG(C++)])
 106
 107
 108 # _AC_LANG_ABBREV(C++)
 109 # --------------------
 110 m4_define([_AC_LANG_ABBREV(C++)], [cxx])
 111
 112
 113 # _AC_LANG_PREFIX(C++)
 114 # --------------------
 115 m4_define([_AC_LANG_PREFIX(C++)], [CXX])
 116
 117
 118
 119 # ------------------------------ #
 120 # 1d. The Objective C language.  #
 121 # ------------------------------ #
 122
 123
 124 # AC_LANG(Objective C)
 125 # --------------------
 126 m4_define([AC_LANG(Objective C)],
 127 [ac_ext=m
 128 ac_cpp='$OBJCPP $CPPFLAGS'
 129 ac_compile='$OBJC -c $OBJCFLAGS $CPPFLAGS conftest.$ac_ext >&AS_MESSAGE_LOG_FD'
 130 ac_link='$OBJC -o conftest$ac_exeext $OBJCFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&AS_MESSAGE_LOG_FD'
 131 ac_compiler_gnu=$ac_cv_objc_compiler_gnu
 132 ])
 133
 134
 135 # AC_LANG_OBJC
 136 # ------------
 137 AU_DEFUN([AC_LANG_OBJC], [AC_LANG(Objective C)])
 138
 139
 140 # _AC_LANG_ABBREV(Objective C)
 141 # ----------------------------
 142 m4_define([_AC_LANG_ABBREV(Objective C)], [objc])
 143
 144
 145 # _AC_LANG_PREFIX(Objective C)
 146 # ----------------------------
 147 m4_define([_AC_LANG_PREFIX(Objective C)], [OBJC])
 148
 149
 150
 151 ## ---------------------- ##
 152 ## 2.Producing programs.  ##
 153 ## ---------------------- ##
 154
 155
 156 # --------------- #
 157 # 2b. C sources.  #
 158 # --------------- #
 159
 160 # AC_LANG_SOURCE(C)(BODY)
 161 # -----------------------
 162 # We can't use '#line $LINENO "configure"' here, since
 163 # Sun c89 (Sun WorkShop 6 update 2 C 5.3 Patch 111679-08 2002/05/09)
 164 # rejects $LINENO greater than 32767, and some configure scripts
 165 # are longer than 32767 lines.
 166 m4_define([AC_LANG_SOURCE(C)],
 167 [/* confdefs.h.  */
 168 _ACEOF
 169 cat confdefs.h >>conftest.$ac_ext
 170 cat >>conftest.$ac_ext <<_ACEOF
 171 /* end confdefs.h.  */
 172 $1])
 173
 174
 175 # AC_LANG_PROGRAM(C)([PROLOGUE], [BODY])
 176 # --------------------------------------
 177 m4_define([AC_LANG_PROGRAM(C)],
 178 [$1
 179 m4_ifdef([_AC_LANG_PROGRAM_C_F77_HOOKS], [_AC_LANG_PROGRAM_C_F77_HOOKS])[]dnl
 180 m4_ifdef([_AC_LANG_PROGRAM_C_FC_HOOKS], [_AC_LANG_PROGRAM_C_FC_HOOKS])[]dnl
 181 int
 182 main ()
 183 {
 184 dnl Do *not* indent the following line: there may be CPP directives.
 185 dnl Don't move the `;' right after for the same reason.
 186 $2
 187   ;
 188   return 0;
 189 }])
 190
 191
 192 # AC_LANG_CALL(C)(PROLOGUE, FUNCTION)
 193 # -----------------------------------
 194 # Avoid conflicting decl of main.
 195 m4_define([AC_LANG_CALL(C)],
 196 [AC_LANG_PROGRAM([$1
 197 m4_if([$2], [main], ,
 198 [/* Override any GCC internal prototype to avoid an error.
 199    Use char because int might match the return type of a GCC
 200    builtin and then its argument prototype would still apply.  */
 201 #ifdef __cplusplus
 202 extern "C"
 203 #endif
 204 char $2 ();])], [return $2 ();])])
 205
 206
 207 # AC_LANG_FUNC_LINK_TRY(C)(FUNCTION)
 208 # ----------------------------------
 209 # Don't include <ctype.h> because on OSF/1 3.0 it includes
 210 # <sys/types.h> which includes <sys/select.h> which contains a
 211 # prototype for select.  Similarly for bzero.
 212 #
 213 # This test used to merely assign f=$1 in main(), but that was
 214 # optimized away by HP unbundled cc A.05.36 for ia64 under +O3,
 215 # presumably on the basis that there's no need to do that store if the
 216 # program is about to exit.  Conversely, the AIX linker optimizes an
 217 # unused external declaration that initializes f=$1.  So this test
 218 # program has both an external initialization of f, and a use of f in
 219 # main that affects the exit status.
 220 #
 221 m4_define([AC_LANG_FUNC_LINK_TRY(C)],
 222 [AC_LANG_PROGRAM(
 223 [/* Define $1 to an innocuous variant, in case <limits.h> declares $1.
 224    For example, HP-UX 11i <limits.h> declares gettimeofday.  */
 225 #define $1 innocuous_$1
 226
 227 /* System header to define __stub macros and hopefully few prototypes,
 228     which can conflict with char $1 (); below.
 229     Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 230     <limits.h> exists even on freestanding compilers.  */
 231
 232 #ifdef __STDC__
 233 # include <limits.h>
 234 #else
 235 # include <assert.h>
 236 #endif
 237
 238 #undef $1
 239
 240 /* Override any GCC internal prototype to avoid an error.
 241    Use char because int might match the return type of a GCC
 242    builtin and then its argument prototype would still apply.  */
 243 #ifdef __cplusplus
 244 extern "C"
 245 #endif
 246 char $1 ();
 247 /* The GNU C library defines this for functions which it implements
 248     to always fail with ENOSYS.  Some functions are actually named
 249     something starting with __ and the normal name is an alias.  */
 250 #if defined __stub_$1 || defined __stub___$1
 251 choke me
 252 #endif
 253 ], [return $1 ();])])
 254
 255
 256 # AC_LANG_BOOL_COMPILE_TRY(C)(PROLOGUE, EXPRESSION)
 257 # -------------------------------------------------
 258 # Return a program that is valid if EXPRESSION is nonzero.
 259 # EXPRESSION must be an integer constant expression.
 260 # Be sure to use this array to avoid `unused' warnings, which are even
 261 # errors with `-W error'.
 262 m4_define([AC_LANG_BOOL_COMPILE_TRY(C)],
 263 [AC_LANG_PROGRAM([$1], [static int test_array @<:@1 - 2 * !($2)@:>@;
 264 test_array @<:@0@:>@ = 0
 265 ])])
 266
 267
 268 # AC_LANG_INT_SAVE(C)(PROLOGUE, EXPRESSION)
 269 # -----------------------------------------
 270 # We need `stdio.h' to open a `FILE' and `stdlib.h' for `exit'.
 271 # But we include them only after the EXPRESSION has been evaluated.
 272 m4_define([AC_LANG_INT_SAVE(C)],
 273 [AC_LANG_PROGRAM([$1
 274 static long int longval () { return $2; }
 275 static unsigned long int ulongval () { return $2; }
 276 @%:@include <stdio.h>
 277 @%:@include <stdlib.h>],
 278 [
 279   FILE *f = fopen ("conftest.val", "w");
 280   if (! f)
 281     return 1;
 282   if (($2) < 0)
 283     {
 284       long int i = longval ();
 285       if (i != ($2))
 286         return 1;
 287       fprintf (f, "%ld\n", i);
 288     }
 289   else
 290     {
 291       unsigned long int i = ulongval ();
 292       if (i != ($2))
 293         return 1;
 294       fprintf (f, "%lu\n", i);
 295     }
 296   return ferror (f) || fclose (f) != 0;
 297 ])])
 298
 299
 300 # ----------------- #
 301 # 2c. C++ sources.  #
 302 # ----------------- #
 303
 304 # AC_LANG_SOURCE(C++)(BODY)
 305 # -------------------------
 306 m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(C++)])
 307
 308
 309 # AC_LANG_PROGRAM(C++)([PROLOGUE], [BODY])
 310 # ----------------------------------------
 311 m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(C++)])
 312
 313
 314 # AC_LANG_CALL(C++)(PROLOGUE, FUNCTION)
 315 # -------------------------------------
 316 m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(C++)])
 317
 318
 319 # AC_LANG_FUNC_LINK_TRY(C++)(FUNCTION)
 320 # ------------------------------------
 321 m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(C++)])
 322
 323
 324 # AC_LANG_BOOL_COMPILE_TRY(C++)(PROLOGUE, EXPRESSION)
 325 # ---------------------------------------------------
 326 m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(C++)])
 327
 328
 329 # AC_LANG_INT_SAVE(C++)(PROLOGUE, EXPRESSION)
 330 # -------------------------------------------
 331 m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(C++)])
 332
 333
 334
 335 # ------------------------- #
 336 # 2d. Objective C sources.  #
 337 # ------------------------- #
 338
 339 # AC_LANG_SOURCE(Objective C)(BODY)
 340 # ---------------------------------
 341 m4_copy([AC_LANG_SOURCE(C)], [AC_LANG_SOURCE(Objective C)])
 342
 343
 344 # AC_LANG_PROGRAM(Objective C)([PROLOGUE], [BODY])
 345 # ------------------------------------------------
 346 m4_copy([AC_LANG_PROGRAM(C)], [AC_LANG_PROGRAM(Objective C)])
 347
 348
 349 # AC_LANG_CALL(Objective C)(PROLOGUE, FUNCTION)
 350 # ---------------------------------------------
 351 m4_copy([AC_LANG_CALL(C)], [AC_LANG_CALL(Objective C)])
 352
 353
 354 # AC_LANG_FUNC_LINK_TRY(Objective C)(FUNCTION)
 355 # --------------------------------------------
 356 m4_copy([AC_LANG_FUNC_LINK_TRY(C)], [AC_LANG_FUNC_LINK_TRY(Objective C)])
 357
 358
 359 # AC_LANG_BOOL_COMPILE_TRY(Objective C)(PROLOGUE, EXPRESSION)
 360 # -----------------------------------------------------------
 361 m4_copy([AC_LANG_BOOL_COMPILE_TRY(C)], [AC_LANG_BOOL_COMPILE_TRY(Objective C)])
 362
 363
 364 # AC_LANG_INT_SAVE(Objective C)(PROLOGUE, EXPRESSION)
 365 # ---------------------------------------------------
 366 m4_copy([AC_LANG_INT_SAVE(C)], [AC_LANG_INT_SAVE(Objective C)])
 367
 368
 369
 370 ## -------------------------------------------- ##
 371 ## 3. Looking for Compilers and Preprocessors.  ##
 372 ## -------------------------------------------- ##
 373
 374 # -------------------- #
 375 # 3b. The C compiler.  #
 376 # -------------------- #
 377
 378
 379 # _AC_ARG_VAR_CPPFLAGS
 380 # --------------------
 381 # Document and register CPPFLAGS, which is used by
 382 # AC_PROG_{CC, CPP, CXX, CXXCPP, OBJC, OBJCPP}.
 383 AC_DEFUN([_AC_ARG_VAR_CPPFLAGS],
 384 [AC_ARG_VAR([CPPFLAGS],
 385             [C/C++/Objective C preprocessor flags, e.g. -I<include dir>
 386              if you have headers in a nonstandard directory <include dir>])])
 387
 388
 389 # _AC_ARG_VAR_LDFLAGS
 390 # -------------------
 391 # Document and register LDFLAGS, which is used by
 392 # AC_PROG_{CC, CXX, F77, FC, OBJC}.
 393 AC_DEFUN([_AC_ARG_VAR_LDFLAGS],
 394 [AC_ARG_VAR([LDFLAGS],
 395             [linker flags, e.g. -L<lib dir> if you have libraries in a
 396              nonstandard directory <lib dir>])])
 397
 398
 399 # _AC_ARG_VAR_LIBS
 400 # ----------------
 401 # Document and register LIBS, which is used by
 402 # AC_PROG_{CC, CXX, F77, FC, OBJS}.
 403 AC_DEFUN([_AC_ARG_VAR_LIBS],
 404 [AC_ARG_VAR([LIBS],
 405             [libraries to pass to the linker, e.g. -l<library>])])
 406
 407
 408 # AC_LANG_PREPROC(C)
 409 # -------------------
 410 # Find the C preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
 411 AC_DEFUN([AC_LANG_PREPROC(C)],
 412 [AC_REQUIRE([AC_PROG_CPP])])
 413
 414
 415 # _AC_PROG_PREPROC_WORKS_IFELSE(IF-WORKS, IF-NOT)
 416 # -----------------------------------------------
 417 # Check if $ac_cpp is a working preprocessor that can flag absent
 418 # includes either by the exit status or by warnings.
 419 # This macro is for all languages, not only C.
 420 AC_DEFUN([_AC_PROG_PREPROC_WORKS_IFELSE],
 421 [ac_preproc_ok=false
 422 for ac_[]_AC_LANG_ABBREV[]_preproc_warn_flag in '' yes
 423 do
 424   # Use a header file that comes with gcc, so configuring glibc
 425   # with a fresh cross-compiler works.
 426   # Prefer <limits.h> to <assert.h> if __STDC__ is defined, since
 427   # <limits.h> exists even on freestanding compilers.
 428   # On the NeXT, cc -E runs the code through the compiler's parser,
 429   # not just through cpp. "Syntax error" is here to catch this case.
 430   _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@ifdef __STDC__
 431 @%:@ include <limits.h>
 432 @%:@else
 433 @%:@ include <assert.h>
 434 @%:@endif
 435                      Syntax error]])],
 436                      [],
 437                      [# Broken: fails on valid input.
 438 continue])
 439
 440   # OK, works on sane cases.  Now check whether nonexistent headers
 441   # can be detected and how.
 442   _AC_PREPROC_IFELSE([AC_LANG_SOURCE([[@%:@include <ac_nonexistent.h>]])],
 443                      [# Broken: success on invalid input.
 444 continue],
 445                      [# Passes both tests.
 446 ac_preproc_ok=:
 447 break])
 448
 449 done
 450 # Because of `break', _AC_PREPROC_IFELSE's cleaning code was skipped.
 451 rm -f conftest.err conftest.$ac_ext
 452 AS_IF([$ac_preproc_ok], [$1], [$2])])# _AC_PROG_PREPROC_WORKS_IFELSE
 453
 454
 455 # AC_PROG_CPP
 456 # -----------
 457 # Find a working C preprocessor.
 458 # We shouldn't have to require AC_PROG_CC, but this is due to the concurrency
 459 # between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CC.
 460 AN_MAKEVAR([CPP], [AC_PROG_CPP])
 461 AN_PROGRAM([cpp], [AC_PROG_CPP])
 462 AC_DEFUN([AC_PROG_CPP],
 463 [AC_REQUIRE([AC_PROG_CC])dnl
 464 AC_ARG_VAR([CPP],      [C preprocessor])dnl
 465 _AC_ARG_VAR_CPPFLAGS()dnl
 466 AC_LANG_PUSH(C)dnl
 467 AC_MSG_CHECKING([how to run the C preprocessor])
 468 # On Suns, sometimes $CPP names a directory.
 469 if test -n "$CPP" && test -d "$CPP"; then
 470   CPP=
 471 fi
 472 if test -z "$CPP"; then
 473   AC_CACHE_VAL([ac_cv_prog_CPP],
 474   [dnl
 475     # Double quotes because CPP needs to be expanded
 476     for CPP in "$CC -E" "$CC -E -traditional-cpp" "/lib/cpp"
 477     do
 478       _AC_PROG_PREPROC_WORKS_IFELSE([break])
 479     done
 480     ac_cv_prog_CPP=$CPP
 481   ])dnl
 482   CPP=$ac_cv_prog_CPP
 483 else
 484   ac_cv_prog_CPP=$CPP
 485 fi
 486 AC_MSG_RESULT([$CPP])
 487 _AC_PROG_PREPROC_WORKS_IFELSE([],
 488                 [AC_MSG_FAILURE([C preprocessor "$CPP" fails sanity check])])
 489 AC_SUBST(CPP)dnl
 490 AC_LANG_POP(C)dnl
 491 ])# AC_PROG_CPP
 492
 493 # AC_PROG_CPP_WERROR
 494 # ------------------
 495 # Treat warnings from the preprocessor as errors.
 496 AC_DEFUN([AC_PROG_CPP_WERROR],
 497 [AC_REQUIRE([AC_PROG_CPP])dnl
 498 ac_c_preproc_warn_flag=yes])# AC_PROG_CPP_WERROR
 499
 500 # AC_LANG_COMPILER(C)
 501 # -------------------
 502 # Find the C compiler.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
 503 AC_DEFUN([AC_LANG_COMPILER(C)],
 504 [AC_REQUIRE([AC_PROG_CC])])
 505
 506
 507 # ac_cv_prog_gcc
 508 # --------------
 509 # We used to name the cache variable this way.
 510 AU_DEFUN([ac_cv_prog_gcc],
 511 [ac_cv_c_compiler_gnu])
 512
 513
 514 # AC_PROG_CC([COMPILER ...])
 515 # --------------------------
 516 # COMPILER ... is a space separated list of C compilers to search for.
 517 # This just gives the user an opportunity to specify an alternative
 518 # search list for the C compiler.
 519 AN_MAKEVAR([CC],  [AC_PROG_CC])
 520 AN_PROGRAM([cc],  [AC_PROG_CC])
 521 AN_PROGRAM([gcc], [AC_PROG_CC])
 522 AC_DEFUN([AC_PROG_CC],
 523 [AC_LANG_PUSH(C)dnl
 524 AC_ARG_VAR([CC],     [C compiler command])dnl
 525 AC_ARG_VAR([CFLAGS], [C compiler flags])dnl
 526 _AC_ARG_VAR_LDFLAGS()dnl
 527 _AC_ARG_VAR_LIBS()dnl
 528 _AC_ARG_VAR_CPPFLAGS()dnl
 529 m4_ifval([$1],
 530       [AC_CHECK_TOOLS(CC, [$1])],
 531 [AC_CHECK_TOOL(CC, gcc)
 532 if test -z "$CC"; then
 533   dnl Here we want:
 534   dnl   AC_CHECK_TOOL(CC, cc)
 535   dnl but without the check for a tool without the prefix.
 536   dnl Until the check is removed from there, copy the code:
 537   if test -n "$ac_tool_prefix"; then
 538     AC_CHECK_PROG(CC, [${ac_tool_prefix}cc], [${ac_tool_prefix}cc])
 539   fi
 540 fi
 541 if test -z "$CC"; then
 542   AC_CHECK_PROG(CC, cc, cc, , , /usr/ucb/cc)
 543 fi
 544 if test -z "$CC"; then
 545   AC_CHECK_TOOLS(CC, cl.exe)
 546 fi
 547 ])
 548
 549 test -z "$CC" && AC_MSG_FAILURE([no acceptable C compiler found in \$PATH])
 550
 551 # Provide some information about the compiler.
 552 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
 553 ac_compiler=`set X $ac_compile; echo $[2]`
 554 _AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
 555 _AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
 556 _AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
 557
 558 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
 559 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
 560 _AC_LANG_COMPILER_GNU
 561 GCC=`test $ac_compiler_gnu = yes && echo yes`
 562 _AC_PROG_CC_G
 563 _AC_PROG_CC_C89
 564 AC_LANG_POP(C)dnl
 565 ])# AC_PROG_CC
 566
 567
 568 # _AC_PROG_CC_G
 569 # -------------
 570 # Check whether -g works, even if CFLAGS is set, in case the package
 571 # plays around with CFLAGS (such as to build both debugging and normal
 572 # versions of a library), tasteless as that idea is.
 573 # Don't consider -g to work if it generates warnings when plain compiles don't.
 574 m4_define([_AC_PROG_CC_G],
 575 [ac_test_CFLAGS=${CFLAGS+set}
 576 ac_save_CFLAGS=$CFLAGS
 577 AC_CACHE_CHECK(whether $CC accepts -g, ac_cv_prog_cc_g,
 578   [ac_save_c_werror_flag=$ac_c_werror_flag
 579    ac_c_werror_flag=yes
 580    ac_cv_prog_cc_g=no
 581    CFLAGS="-g"
 582    _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
 583      [ac_cv_prog_cc_g=yes],
 584      [CFLAGS=""
 585       _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
 586         [],
 587         [ac_c_werror_flag=$ac_save_c_werror_flag
 588          CFLAGS="-g"
 589          _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
 590            [ac_cv_prog_cc_g=yes])])])
 591    ac_c_werror_flag=$ac_save_c_werror_flag])
 592 if test "$ac_test_CFLAGS" = set; then
 593   CFLAGS=$ac_save_CFLAGS
 594 elif test $ac_cv_prog_cc_g = yes; then
 595   if test "$GCC" = yes; then
 596     CFLAGS="-g -O2"
 597   else
 598     CFLAGS="-g"
 599   fi
 600 else
 601   if test "$GCC" = yes; then
 602     CFLAGS="-O2"
 603   else
 604     CFLAGS=
 605   fi
 606 fi[]dnl
 607 ])# _AC_PROG_CC_G
 608
 609
 610 # AC_PROG_GCC_TRADITIONAL
 611 # -----------------------
 612 AN_FUNCTION([ioctl],   [AC_PROG_GCC_TRADITIONAL])
 613 AC_DEFUN([AC_PROG_GCC_TRADITIONAL],
 614 [AC_REQUIRE([AC_PROG_CC])dnl
 615 if test $ac_cv_c_compiler_gnu = yes; then
 616     AC_CACHE_CHECK(whether $CC needs -traditional,
 617       ac_cv_prog_gcc_traditional,
 618 [  ac_pattern="Autoconf.*'x'"
 619   AC_EGREP_CPP($ac_pattern, [#include <sgtty.h>
 620 Autoconf TIOCGETP],
 621   ac_cv_prog_gcc_traditional=yes, ac_cv_prog_gcc_traditional=no)
 622
 623   if test $ac_cv_prog_gcc_traditional = no; then
 624     AC_EGREP_CPP($ac_pattern, [#include <termio.h>
 625 Autoconf TCGETA],
 626     ac_cv_prog_gcc_traditional=yes)
 627   fi])
 628   if test $ac_cv_prog_gcc_traditional = yes; then
 629     CC="$CC -traditional"
 630   fi
 631 fi
 632 ])# AC_PROG_GCC_TRADITIONAL
 633
 634
 635 # AC_PROG_CC_C_O
 636 # --------------
 637 AC_DEFUN([AC_PROG_CC_C_O],
 638 [AC_REQUIRE([AC_PROG_CC])dnl
 639 if test "x$CC" != xcc; then
 640   AC_MSG_CHECKING([whether $CC and cc understand -c and -o together])
 641 else
 642   AC_MSG_CHECKING([whether cc understands -c and -o together])
 643 fi
 644 set dummy $CC; ac_cc=`echo $[2] |
 645                       sed 's/[[^a-zA-Z0-9_]]/_/g;s/^[[0-9]]/_/'`
 646 AC_CACHE_VAL(ac_cv_prog_cc_${ac_cc}_c_o,
 647 [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
 648 # Make sure it works both with $CC and with simple cc.
 649 # We do the test twice because some compilers refuse to overwrite an
 650 # existing .o file with -o, though they will create one.
 651 ac_try='$CC -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
 652 rm -f conftest2.*
 653 if _AC_DO_VAR(ac_try) &&
 654    test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try);
 655 then
 656   eval ac_cv_prog_cc_${ac_cc}_c_o=yes
 657   if test "x$CC" != xcc; then
 658     # Test first that cc exists at all.
 659     if _AC_DO_TOKENS(cc -c conftest.$ac_ext >&AS_MESSAGE_LOG_FD); then
 660       ac_try='cc -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
 661       rm -f conftest2.*
 662       if _AC_DO_VAR(ac_try) &&
 663          test -f conftest2.$ac_objext && _AC_DO_VAR(ac_try);
 664       then
 665         # cc works too.
 666         :
 667       else
 668         # cc exists but doesn't like -o.
 669         eval ac_cv_prog_cc_${ac_cc}_c_o=no
 670       fi
 671     fi
 672   fi
 673 else
 674   eval ac_cv_prog_cc_${ac_cc}_c_o=no
 675 fi
 676 rm -f core conftest*
 677 ])dnl
 678 if eval test \$ac_cv_prog_cc_${ac_cc}_c_o = yes; then
 679   AC_MSG_RESULT([yes])
 680 else
 681   AC_MSG_RESULT([no])
 682   AC_DEFINE(NO_MINUS_C_MINUS_O, 1,
 683            [Define to 1 if your C compiler doesn't accept -c and -o together.])
 684 fi
 685 ])# AC_PROG_CC_C_O
 686
 687
 688 # ---------------------- #
 689 # 3c. The C++ compiler.  #
 690 # ---------------------- #
 691
 692
 693 # AC_LANG_PREPROC(C++)
 694 # ---------------------
 695 # Find the C++ preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
 696 AC_DEFUN([AC_LANG_PREPROC(C++)],
 697 [AC_REQUIRE([AC_PROG_CXXCPP])])
 698
 699
 700 # AC_PROG_CXXCPP
 701 # --------------
 702 # Find a working C++ preprocessor.
 703 # We shouldn't have to require AC_PROG_CC, but this is due to the concurrency
 704 # between the AC_LANG_COMPILER_REQUIRE family and that of AC_PROG_CXX.
 705 AC_DEFUN([AC_PROG_CXXCPP],
 706 [AC_REQUIRE([AC_PROG_CXX])dnl
 707 AC_ARG_VAR([CXXCPP],   [C++ preprocessor])dnl
 708 _AC_ARG_VAR_CPPFLAGS()dnl
 709 AC_LANG_PUSH(C++)dnl
 710 AC_MSG_CHECKING([how to run the C++ preprocessor])
 711 if test -z "$CXXCPP"; then
 712   AC_CACHE_VAL(ac_cv_prog_CXXCPP,
 713   [dnl
 714     # Double quotes because CXXCPP needs to be expanded
 715     for CXXCPP in "$CXX -E" "/lib/cpp"
 716     do
 717       _AC_PROG_PREPROC_WORKS_IFELSE([break])
 718     done
 719     ac_cv_prog_CXXCPP=$CXXCPP
 720   ])dnl
 721   CXXCPP=$ac_cv_prog_CXXCPP
 722 else
 723   ac_cv_prog_CXXCPP=$CXXCPP
 724 fi
 725 AC_MSG_RESULT([$CXXCPP])
 726 _AC_PROG_PREPROC_WORKS_IFELSE([],
 727           [AC_MSG_FAILURE([C++ preprocessor "$CXXCPP" fails sanity check])])
 728 AC_SUBST(CXXCPP)dnl
 729 AC_LANG_POP(C++)dnl
 730 ])# AC_PROG_CXXCPP
 731
 732
 733 # AC_LANG_COMPILER(C++)
 734 # ---------------------
 735 # Find the C++ compiler.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
 736 AC_DEFUN([AC_LANG_COMPILER(C++)],
 737 [AC_REQUIRE([AC_PROG_CXX])])
 738
 739
 740 # ac_cv_prog_gxx
 741 # --------------
 742 # We used to name the cache variable this way.
 743 AU_DEFUN([ac_cv_prog_gxx],
 744 [ac_cv_cxx_compiler_gnu])
 745
 746
 747 # AC_PROG_CXX([LIST-OF-COMPILERS])
 748 # --------------------------------
 749 # LIST-OF-COMPILERS is a space separated list of C++ compilers to search
 750 # for (if not specified, a default list is used).  This just gives the
 751 # user an opportunity to specify an alternative search list for the C++
 752 # compiler.
 753 # aCC   HP-UX C++ compiler much better than `CC', so test before.
 754 # FCC   Fujitsu C++ compiler
 755 # KCC   KAI C++ compiler
 756 # RCC   Rational C++
 757 # xlC_r AIX C Set++ (with support for reentrant code)
 758 # xlC   AIX C Set++
 759 AN_MAKEVAR([CXX],  [AC_PROG_CXX])
 760 AN_PROGRAM([CC],   [AC_PROG_CXX])
 761 AN_PROGRAM([c++],  [AC_PROG_CXX])
 762 AN_PROGRAM([g++],  [AC_PROG_CXX])
 763 AC_DEFUN([AC_PROG_CXX],
 764 [AC_LANG_PUSH(C++)dnl
 765 AC_ARG_VAR([CXX],      [C++ compiler command])dnl
 766 AC_ARG_VAR([CXXFLAGS], [C++ compiler flags])dnl
 767 _AC_ARG_VAR_LDFLAGS()dnl
 768 _AC_ARG_VAR_LIBS()dnl
 769 _AC_ARG_VAR_CPPFLAGS()dnl
 770 _AC_ARG_VAR_PRECIOUS([CCC])dnl
 771 if test -z "$CXX"; then
 772   if test -n "$CCC"; then
 773     CXX=$CCC
 774   else
 775     AC_CHECK_TOOLS(CXX,
 776                    [m4_default([$1],
 777                                [g++ c++ gpp aCC CC cxx cc++ cl.exe FCC KCC RCC xlC_r xlC])],
 778                    g++)
 779   fi
 780 fi
 781 # Provide some information about the compiler.
 782 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
 783 ac_compiler=`set X $ac_compile; echo $[2]`
 784 _AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
 785 _AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
 786 _AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
 787
 788 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
 789 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
 790 _AC_LANG_COMPILER_GNU
 791 GXX=`test $ac_compiler_gnu = yes && echo yes`
 792 _AC_PROG_CXX_G
 793 AC_LANG_POP(C++)dnl
 794 ])# AC_PROG_CXX
 795
 796
 797 # _AC_PROG_CXX_G
 798 # --------------
 799 # Check whether -g works, even if CXXFLAGS is set, in case the package
 800 # plays around with CXXFLAGS (such as to build both debugging and
 801 # normal versions of a library), tasteless as that idea is.
 802 # Don't consider -g to work if it generates warnings when plain compiles don't.
 803 m4_define([_AC_PROG_CXX_G],
 804 [ac_test_CXXFLAGS=${CXXFLAGS+set}
 805 ac_save_CXXFLAGS=$CXXFLAGS
 806 AC_CACHE_CHECK(whether $CXX accepts -g, ac_cv_prog_cxx_g,
 807   [ac_save_cxx_werror_flag=$ac_cxx_werror_flag
 808    ac_cxx_werror_flag=yes
 809    ac_cv_prog_cxx_g=no
 810    CXXFLAGS="-g"
 811    _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
 812      [ac_cv_prog_cxx_g=yes],
 813      [CXXFLAGS=""
 814       _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
 815         [],
 816         [ac_cxx_werror_flag=$ac_save_cxx_werror_flag
 817          CXXFLAGS="-g"
 818          _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
 819            [ac_cv_prog_cxx_g=yes])])])
 820    ac_cxx_werror_flag=$ac_save_cxx_werror_flag])
 821 if test "$ac_test_CXXFLAGS" = set; then
 822   CXXFLAGS=$ac_save_CXXFLAGS
 823 elif test $ac_cv_prog_cxx_g = yes; then
 824   if test "$GXX" = yes; then
 825     CXXFLAGS="-g -O2"
 826   else
 827     CXXFLAGS="-g"
 828   fi
 829 else
 830   if test "$GXX" = yes; then
 831     CXXFLAGS="-O2"
 832   else
 833     CXXFLAGS=
 834   fi
 835 fi[]dnl
 836 ])# _AC_PROG_CXX_G
 837
 838
 839 # AC_PROG_CXX_C_O
 840 # ---------------
 841 # Test if the C++ compiler accepts the options `-c' and `-o'
 842 # simultaneously, and define `CXX_NO_MINUS_C_MINUS_O' if it does not.
 843 AC_DEFUN([AC_PROG_CXX_C_O],
 844 [AC_REQUIRE([AC_PROG_CXX])dnl
 845 AC_LANG_PUSH([C++])dnl
 846 AC_CACHE_CHECK([whether $CXX understands -c and -o together],
 847                [ac_cv_prog_cxx_c_o],
 848 [AC_LANG_CONFTEST([AC_LANG_PROGRAM([])])
 849 # We test twice because some compilers refuse to overwrite an existing
 850 # `.o' file with `-o', although they will create one.
 851 ac_try='$CXX $CXXFLAGS -c conftest.$ac_ext -o conftest2.$ac_objext >&AS_MESSAGE_LOG_FD'
 852 rm -f conftest2.*
 853 if _AC_DO_VAR(ac_try) &&
 854      test -f conftest2.$ac_objext &&
 855      _AC_DO_VAR(ac_try); then
 856   ac_cv_prog_cxx_c_o=yes
 857 else
 858   ac_cv_prog_cxx_c_o=no
 859 fi
 860 rm -f conftest*])
 861 if test $ac_cv_prog_cxx_c_o = no; then
 862   AC_DEFINE(CXX_NO_MINUS_C_MINUS_O, 1,
 863             [Define to 1 if your C++ compiler doesn't accept
 864              -c and -o together.])
 865 fi
 866 AC_LANG_POP([C++])dnl
 867 ])# AC_PROG_CXX_C_O
 868
 869
 870 # ------------------------------ #
 871 # 3d. The Objective C compiler.  #
 872 # ------------------------------ #
 873
 874
 875 # AC_LANG_PREPROC(Objective C)
 876 # ----------------------------
 877 # Find the Objective C preprocessor.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
 878 AC_DEFUN([AC_LANG_PREPROC(Objective C)],
 879 [AC_REQUIRE([AC_PROG_OBJCPP])])
 880
 881
 882 # AC_PROG_OBJCPP
 883 # --------------
 884 # Find a working Objective C preprocessor.
 885 AC_DEFUN([AC_PROG_OBJCPP],
 886 [AC_REQUIRE([AC_PROG_OBJC])dnl
 887 AC_ARG_VAR([OBJCPP],   [Objective C preprocessor])dnl
 888 _AC_ARG_VAR_CPPFLAGS()dnl
 889 AC_LANG_PUSH(Objective C)dnl
 890 AC_MSG_CHECKING([how to run the Objective C preprocessor])
 891 if test -z "$OBJCPP"; then
 892   AC_CACHE_VAL(ac_cv_prog_OBJCPP,
 893   [dnl
 894     # Double quotes because OBJCPP needs to be expanded
 895     for OBJCPP in "$OBJC -E" "/lib/cpp"
 896     do
 897       _AC_PROG_PREPROC_WORKS_IFELSE([break])
 898     done
 899     ac_cv_prog_OBJCPP=$OBJCPP
 900   ])dnl
 901   OBJCPP=$ac_cv_prog_OBJCPP
 902 else
 903   ac_cv_prog_OBJCPP=$OBJCPP
 904 fi
 905 AC_MSG_RESULT([$OBJCPP])
 906 _AC_PROG_PREPROC_WORKS_IFELSE([],
 907           [AC_MSG_FAILURE([Objective C preprocessor "$OBJCPP" fails sanity check])])
 908 AC_SUBST(OBJCPP)dnl
 909 AC_LANG_POP(Objective C)dnl
 910 ])# AC_PROG_OBJCPP
 911
 912
 913 # AC_LANG_COMPILER(Objective C)
 914 # -----------------------------
 915 # Find the Objective C compiler.  Must be AC_DEFUN'd to be AC_REQUIRE'able.
 916 AC_DEFUN([AC_LANG_COMPILER(Objective C)],
 917 [AC_REQUIRE([AC_PROG_OBJC])])
 918
 919
 920
 921 # AC_PROG_OBJC([LIST-OF-COMPILERS])
 922 # ---------------------------------
 923 # LIST-OF-COMPILERS is a space separated list of Objective C compilers to
 924 # search for (if not specified, a default list is used).  This just gives
 925 # the user an opportunity to specify an alternative search list for the
 926 # Objective C compiler.
 927 # objcc StepStone Objective-C compiler (also "standard" name for OBJC)
 928 # objc  David Stes' POC.  If you installed this, you likely want it.
 929 # cc    Native C compiler (for instance, Apple).
 930 # CC    You never know.
 931 AN_MAKEVAR([OBJC],  [AC_PROG_OBJC])
 932 AN_PROGRAM([objcc],  [AC_PROG_OBJC])
 933 AN_PROGRAM([objc],  [AC_PROG_OBJC])
 934 AC_DEFUN([AC_PROG_OBJC],
 935 [AC_LANG_PUSH(Objective C)dnl
 936 AC_ARG_VAR([OBJC],      [Objective C compiler command])dnl
 937 AC_ARG_VAR([OBJCFLAGS], [Objective C compiler flags])dnl
 938 _AC_ARG_VAR_LDFLAGS()dnl
 939 _AC_ARG_VAR_LIBS()dnl
 940 _AC_ARG_VAR_CPPFLAGS()dnl
 941 _AC_ARG_VAR_PRECIOUS([OBJC])dnl
 942 AC_CHECK_TOOLS(OBJC,
 943                [m4_default([$1], [gcc objcc objc cc CC])],
 944                gcc)
 945 # Provide some information about the compiler.
 946 _AS_ECHO_LOG([checking for _AC_LANG compiler version])
 947 ac_compiler=`set X $ac_compile; echo $[2]`
 948 _AC_DO([$ac_compiler --version >&AS_MESSAGE_LOG_FD])
 949 _AC_DO([$ac_compiler -v >&AS_MESSAGE_LOG_FD])
 950 _AC_DO([$ac_compiler -V >&AS_MESSAGE_LOG_FD])
 951
 952 m4_expand_once([_AC_COMPILER_EXEEXT])[]dnl
 953 m4_expand_once([_AC_COMPILER_OBJEXT])[]dnl
 954 _AC_LANG_COMPILER_GNU
 955 GOBJC=`test $ac_compiler_gnu = yes && echo yes`
 956 _AC_PROG_OBJC_G
 957 AC_LANG_POP(Objective C)dnl
 958 ])# AC_PROG_OBJC
 959
 960
 961 # _AC_PROG_OBJC_G
 962 # ---------------
 963 # Check whether -g works, even if OBJCFLAGS is set, in case the package
 964 # plays around with OBJCFLAGS (such as to build both debugging and
 965 # normal versions of a library), tasteless as that idea is.
 966 # Don't consider -g to work if it generates warnings when plain compiles don't.
 967 m4_define([_AC_PROG_OBJC_G],
 968 [ac_test_OBJCFLAGS=${OBJCFLAGS+set}
 969 ac_save_OBJCFLAGS=$OBJCFLAGS
 970 AC_CACHE_CHECK(whether $OBJC accepts -g, ac_cv_prog_objc_g,
 971   [ac_save_objc_werror_flag=$ac_objc_werror_flag
 972    ac_objc_werror_flag=yes
 973    ac_cv_prog_objc_g=no
 974    OBJCFLAGS="-g"
 975    _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
 976      [ac_cv_prog_objc_g=yes],
 977      [OBJCFLAGS=""
 978       _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
 979         [],
 980         [ac_objc_werror_flag=$ac_save_objc_werror_flag
 981          OBJCFLAGS="-g"
 982          _AC_COMPILE_IFELSE([AC_LANG_PROGRAM()],
 983            [ac_cv_prog_objc_g=yes])])])
 984    ac_objc_werror_flag=$ac_save_objc_werror_flag])
 985 if test "$ac_test_OBJCFLAGS" = set; then
 986   OBJCFLAGS=$ac_save_OBJCFLAGS
 987 elif test $ac_cv_prog_objc_g = yes; then
 988   if test "$GOBJC" = yes; then
 989     OBJCFLAGS="-g -O2"
 990   else
 991     OBJCFLAGS="-g"
 992   fi
 993 else
 994   if test "$GOBJC" = yes; then
 995     OBJCFLAGS="-O2"
 996   else
 997     OBJCFLAGS=
 998   fi
 999 fi[]dnl
1000 ])# _AC_PROG_OBJC_G
1001
1002
1003
1004
1005
1006
1007 ## ------------------------------- ##
1008 ## 4. Compilers' characteristics.  ##
1009 ## ------------------------------- ##
1010
1011
1012 # -------------------------------- #
1013 # 4b. C compiler characteristics.  #
1014 # -------------------------------- #
1015
1016 # _AC_PROG_CC_C89 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
1017 # ----------------------------------------------------------------
1018 # If the C compiler is not in ANSI C89 (ISO C90) mode by default, try
1019 # to add an option to output variable CC to make it so.  This macro
1020 # tries various options that select ANSI C89 on some system or
1021 # another.  It considers the compiler to be in ANSI C89 mode if it
1022 # handles function prototypes correctly.
1023 AC_DEFUN([_AC_PROG_CC_C89],
1024 [_AC_C_STD_TRY([c89],
1025 [[#include <stdarg.h>
1026 #include <stdio.h>
1027 #include <sys/types.h>
1028 #include <sys/stat.h>
1029 /* Most of the following tests are stolen from RCS 5.7's src/conf.sh.  */
1030 struct buf { int x; };
1031 FILE * (*rcsopen) (struct buf *, struct stat *, int);
1032 static char *e (p, i)
1033      char **p;
1034      int i;
1035 {
1036   return p[i];
1037 }
1038 static char *f (char * (*g) (char **, int), char **p, ...)
1039 {
1040   char *s;
1041   va_list v;
1042   va_start (v,p);
1043   s = g (p, va_arg (v,int));
1044   va_end (v);
1045   return s;
1046 }
1047
1048 /* OSF 4.0 Compaq cc is some sort of almost-ANSI by default.  It has
1049    function prototypes and stuff, but not '\xHH' hex character constants.
1050    These don't provoke an error unfortunately, instead are silently treated
1051    as 'x'.  The following induces an error, until -std is added to get
1052    proper ANSI mode.  Curiously '\x00'!='x' always comes out true, for an
1053    array size at least.  It's necessary to write '\x00'==0 to get something
1054    that's true only with -std.  */
1055 int osf4_cc_array ['\x00' == 0 ? 1 : -1];
1056
1057 /* IBM C 6 for AIX is almost-ANSI by default, but it replaces macro parameters
1058    inside strings and character constants.  */
1059 #define FOO(x) 'x'
1060 int xlc6_cc_array[FOO(a) == 'x' ? 1 : -1];
1061
1062 int test (int i, double x);
1063 struct s1 {int (*f) (int a);};
1064 struct s2 {int (*f) (double a);};
1065 int pairnames (int, char **, FILE *(*)(struct buf *, struct stat *, int), int, int);
1066 int argc;
1067 char **argv;]],
1068 [[return f (e, argv, 0) != argv[0]  ||  f (e, argv, 1) != argv[1];]],
1069 dnl Don't try gcc -ansi; that turns off useful extensions and
1070 dnl breaks some systems' header files.
1071 dnl AIX circa 2003      -qlanglvl=extc89
1072 dnl old AIX             -qlanglvl=ansi
1073 dnl Ultrix, OSF/1, Tru64        -std
1074 dnl HP-UX 10.20 and later       -Ae
1075 dnl HP-UX older versions        -Aa -D_HPUX_SOURCE
1076 dnl SVR4                        -Xc -D__EXTENSIONS__
1077 [-qlanglvl=extc89 -qlanglvl=ansi -std \
1078         -Ae "-Aa -D_HPUX_SOURCE" "-Xc -D__EXTENSIONS__"], [$1], [$2])[]dnl
1079 ])# _AC_PROG_CC_C89
1080
1081
1082 # _AC_C_STD_TRY(STANDARD, TEST-PROLOGUE, TEST-BODY, OPTION-LIST,
1083 #               ACTION-IF-AVAILABLE, ACTION-IF-UNAVAILABLE)
1084 # --------------------------------------------------------------
1085 # Check whether the C compiler accepts features of STANDARD (e.g `c89', `c99')
1086 # by trying to compile a program of TEST-PROLOGUE and TEST-BODY.  If this fails,
1087 # try again with each compiler option in the space-separated OPTION-LIST; if one
1088 # helps, append it to CC.  If eventually successful, run ACTION-IF-AVAILABLE,
1089 # else ACTION-IF-UNAVAILABLE.
1090 AC_DEFUN([_AC_C_STD_TRY],
1091 [AC_MSG_CHECKING([for $CC option to accept ISO ]m4_translit($1, [c], [C]))
1092 AC_CACHE_VAL(ac_cv_prog_cc_$1,
1093 [ac_cv_prog_cc_$1=no
1094 ac_save_CC=$CC
1095 AC_LANG_CONFTEST([AC_LANG_PROGRAM([$2], [$3])])
1096 for ac_arg in '' $4
1097 do
1098   CC="$ac_save_CC $ac_arg"
1099   _AC_COMPILE_IFELSE([], [ac_cv_prog_cc_$1=$ac_arg])
1100   test "x$ac_cv_prog_cc_$1" != "xno" && break
1101 done
1102 rm -f conftest.$ac_ext
1103 CC=$ac_save_CC
1104 ])# AC_CACHE_VAL
1105 case "x$ac_cv_prog_cc_$1" in
1106   x)
1107     AC_MSG_RESULT([none needed]) ;;
1108   xno)
1109     AC_MSG_RESULT([unsupported]) ;;
1110   *)
1111     CC="$CC $ac_cv_prog_cc_$1"
1112     AC_MSG_RESULT([$ac_cv_prog_cc_$1]) ;;
1113 esac
1114 AS_IF([test "x$ac_cv_prog_cc_$1" != xno], [$5], [$6])
1115 ])# _AC_C_STD_TRY
1116
1117
1118 # _AC_PROG_CC_C99 ([ACTION-IF-AVAILABLE], [ACTION-IF-UNAVAILABLE])
1119 # ----------------------------------------------------------------
1120 # If the C compiler is not in ISO C99 mode by default, try to add an
1121 # option to output variable CC to make it so.  This macro tries
1122 # various options that select ISO C99 on some system or another.  It
1123 # considers the compiler to be in ISO C99 mode if it handles _Bool,
1124 # // comments, flexible array members, inline, long long int, mixed
1125 # code and declarations, named initialization of structs, restrict,
1126 # va_copy, varargs macros, variable declarations in for loops and
1127 # variable length arrays.
1128 AC_DEFUN([_AC_PROG_CC_C99],
1129 [_AC_C_STD_TRY([c99],
1130 [[#include <stdarg.h>
1131 #include <stdbool.h>
1132 #include <stdlib.h>
1133 #include <wchar.h>
1134 #include <stdio.h>
1135
1136 // Check varargs macros.  These examples are taken from C99 6.10.3.5.
1137 #define debug(...) fprintf (stderr, __VA_ARGS__)
1138 #define showlist(...) puts (#__VA_ARGS__)
1139 #define report(test,...) ((test) ? puts (#test) : printf (__VA_ARGS__))
1140 static void
1141 test_varargs_macros (void)
1142 {
1143   int x = 1234;
1144   int y = 5678;
1145   debug ("Flag");
1146   debug ("X = %d\n", x);
1147   showlist (The first, second, and third items.);
1148   report (x>y, "x is %d but y is %d", x, y);
1149 }
1150
1151 // Check long long types.
1152 #define BIG64 18446744073709551615ull
1153 #define BIG32 4294967295ul
1154 #define BIG_OK (BIG64 / BIG32 == 4294967297ull && BIG64 % BIG32 == 0)
1155 #if !BIG_OK
1156   your preprocessor is broken;
1157 #endif
1158 #if BIG_OK
1159 #else
1160   your preprocessor is broken;
1161 #endif
1162 static long long int bignum = -9223372036854775807LL;
1163 static unsigned long long int ubignum = BIG64;
1164
1165 struct incomplete_array
1166 {
1167   int datasize;
1168   double data[];
1169 };
1170
1171 struct named_init {
1172   int number;
1173   const wchar_t *name;
1174   double average;
1175 };
1176
1177 typedef const char *ccp;
1178
1179 static inline int
1180 test_restrict (ccp restrict text)
1181 {
1182   // See if C++-style comments work.
1183   // Iterate through items via the restricted pointer.
1184   // Also check for declarations in for loops.
1185   for (unsigned int i = 0; *(text+i) != '\0'; ++i)
1186     continue;
1187   return 0;
1188 }
1189
1190 // Check varargs and va_copy.
1191 static void
1192 test_varargs (const char *format, ...)
1193 {
1194   va_list args;
1195   va_start (args, format);
1196   va_list args_copy;
1197   va_copy (args_copy, args);
1198
1199   const char *str;
1200   int number;
1201   float fnumber;
1202
1203   while (*format)
1204     {
1205       switch (*format++)
1206         {
1207         case 's': // string
1208           str = va_arg (args_copy, const char *);
1209           break;
1210         case 'd': // int
1211           number = va_arg (args_copy, int);
1212           break;
1213         case 'f': // float
1214           fnumber = va_arg (args_copy, double);
1215           break;
1216         default:
1217           break;
1218         }
1219     }
1220   va_end (args_copy);
1221   va_end (args);
1222 }
1223 ]],
1224 [[
1225   // Check bool.
1226   _Bool success = false;
1227
1228   // Check restrict.
1229   if (test_restrict ("String literal") == 0)
1230     success = true;
1231   char *restrict newvar = "Another string";
1232
1233   // Check varargs.
1234   test_varargs ("s, d' f .", "string", 65, 34.234);
1235   test_varargs_macros ();
1236
1237   // Check flexible array members.
1238   struct incomplete_array *ia =
1239     malloc (sizeof (struct incomplete_array) + (sizeof (double) * 10));
1240   ia->datasize = 10;
1241   for (int i = 0; i < ia->datasize; ++i)
1242     ia->data[i] = i * 1.234;
1243
1244   // Check named initializers.
1245   struct named_init ni = {
1246     .number = 34,
1247     .name = L"Test wide string",
1248     .average = 543.34343,
1249   };
1250
1251   ni.number = 58;
1252
1253   int dynamic_array[ni.number];
1254   dynamic_array[ni.number - 1] = 543;
1255
1256   // work around unused variable warnings
1257   return (!success || bignum == 0LL || ubignum == 0uLL || newvar[0] == 'x'
1258           || dynamic_array[ni.number - 1] != 543);
1259 ]],
1260 dnl Try
1261 dnl GCC         -std=gnu99 (unused restrictive modes: -std=c99 -std=iso9899:1999)
1262 dnl AIX         -qlanglvl=extc99 (unused restrictive mode: -qlanglvl=stdc99)
1263 dnl Intel ICC   -c99
1264 dnl IRIX        -c99
1265 dnl Solaris     (unused because it causes the compiler to assume C99 semantics for
1266 dnl             library functions, and this is invalid before Solaris 10: -xc99)
1267 dnl Tru64       -c99
1268 dnl with extended modes being tried first.
1269 [[-std=gnu99 -c99 -qlanglvl=extc99]], [$1], [$2])[]dnl
1270 ])# _AC_PROG_CC_C99
1271
1272
1273 # AC_PROG_CC_C89
1274 # --------------
1275 AC_DEFUN([AC_PROG_CC_C89],
1276 [ AC_REQUIRE([AC_PROG_CC])dnl
1277   _AC_PROG_CC_C89
1278 ])
1279
1280
1281 # AC_PROG_CC_C99
1282 # --------------
1283 AC_DEFUN([AC_PROG_CC_C99],
1284 [ AC_REQUIRE([AC_PROG_CC])dnl
1285   _AC_PROG_CC_C99
1286 ])
1287
1288
1289 # AC_PROG_CC_STDC
1290 # ---------------
1291 AC_DEFUN([AC_PROG_CC_STDC],
1292 [ AC_REQUIRE([AC_PROG_CC])dnl
1293   AS_CASE([$ac_cv_prog_cc_stdc],
1294     [no], [ac_cv_prog_cc_c99=no; ac_cv_prog_cc_c89=no],
1295           [_AC_PROG_CC_C99([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c99],
1296              [_AC_PROG_CC_C89([ac_cv_prog_cc_stdc=$ac_cv_prog_cc_c89],
1297                               [ac_cv_prog_cc_stdc=no])])])dnl
1298   AC_MSG_CHECKING([for $CC option to accept ISO Standard C])
1299   AC_CACHE_VAL([ac_cv_prog_cc_stdc], [])
1300   AS_CASE([$ac_cv_prog_cc_stdc],
1301     [no], [AC_MSG_RESULT([unsupported])],
1302     [''], [AC_MSG_RESULT([none needed])],
1303           [AC_MSG_RESULT([$ac_cv_prog_cc_stdc])])
1304 ])
1305
1306
1307 # AC_C_BACKSLASH_A
1308 # ----------------
1309 AC_DEFUN([AC_C_BACKSLASH_A],
1310 [
1311   AC_CACHE_CHECK([whether backslash-a works in strings], ac_cv_c_backslash_a,
1312    [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1313      [[
1314 #if '\a' == 'a'
1315       syntax error;
1316 #endif
1317       char buf['\a' == 'a' ? -1 : 1];
1318       buf[0] = '\a';
1319       return buf[0] != "\a"[0];
1320      ]])],
1321      [ac_cv_c_backslash_a=yes],
1322      [ac_cv_c_backslash_a=no])])
1323   if test $ac_cv_c_backslash_a = yes; then
1324     AC_DEFINE(HAVE_C_BACKSLASH_A, 1,
1325       [Define if backslash-a works in C strings.])
1326   fi
1327 ])
1328
1329
1330 # AC_C_CROSS
1331 # ----------
1332 # Has been merged into AC_PROG_CC.
1333 AU_DEFUN([AC_C_CROSS], [])
1334
1335
1336 # AC_C_CHAR_UNSIGNED
1337 # ------------------
1338 AC_DEFUN([AC_C_CHAR_UNSIGNED],
1339 [AH_VERBATIM([__CHAR_UNSIGNED__],
1340 [/* Define to 1 if type `char' is unsigned and you are not using gcc.  */
1341 #ifndef __CHAR_UNSIGNED__
1342 # undef __CHAR_UNSIGNED__
1343 #endif])dnl
1344 AC_CACHE_CHECK(whether char is unsigned, ac_cv_c_char_unsigned,
1345 [AC_COMPILE_IFELSE([AC_LANG_BOOL_COMPILE_TRY([AC_INCLUDES_DEFAULT([])],
1346                                              [((char) -1) < 0])],
1347                    ac_cv_c_char_unsigned=no, ac_cv_c_char_unsigned=yes)])
1348 if test $ac_cv_c_char_unsigned = yes && test "$GCC" != yes; then
1349   AC_DEFINE(__CHAR_UNSIGNED__)
1350 fi
1351 ])# AC_C_CHAR_UNSIGNED
1352
1353
1354 # AC_C_BIGENDIAN ([ACTION-IF-TRUE], [ACTION-IF-FALSE], [ACTION-IF-UNKNOWN])
1355 # -------------------------------------------------------------------------
1356 AC_DEFUN([AC_C_BIGENDIAN],
1357 [AC_CACHE_CHECK(whether byte ordering is bigendian, ac_cv_c_bigendian,
1358 [# See if sys/param.h defines the BYTE_ORDER macro.
1359 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
1360 #include <sys/param.h>
1361 ],
1362 [#if  ! (defined BYTE_ORDER && defined BIG_ENDIAN && defined LITTLE_ENDIAN \
1363         && BYTE_ORDER && BIG_ENDIAN && LITTLE_ENDIAN)
1364  bogus endian macros
1365 #endif
1366 ])],
1367 [# It does; now see whether it defined to BIG_ENDIAN or not.
1368 AC_COMPILE_IFELSE([AC_LANG_PROGRAM([#include <sys/types.h>
1369 #include <sys/param.h>
1370 ], [#if BYTE_ORDER != BIG_ENDIAN
1371  not big endian
1372 #endif
1373 ])], [ac_cv_c_bigendian=yes], [ac_cv_c_bigendian=no])],
1374 [# It does not; compile a test program.
1375 AC_RUN_IFELSE(
1376 [AC_LANG_PROGRAM([AC_INCLUDES_DEFAULT], [[
1377   /* Are we little or big endian?  From Harbison&Steele.  */
1378   union
1379   {
1380     long int l;
1381     char c[sizeof (long int)];
1382   } u;
1383   u.l = 1;
1384   return u.c[sizeof (long int) - 1] == 1;
1385 ]])],
1386               [ac_cv_c_bigendian=no],
1387               [ac_cv_c_bigendian=yes],
1388 [# try to guess the endianness by grepping values into an object file
1389   ac_cv_c_bigendian=unknown
1390   AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1391 [[short int ascii_mm[] = { 0x4249, 0x4765, 0x6E44, 0x6961, 0x6E53, 0x7953, 0 };
1392 short int ascii_ii[] = { 0x694C, 0x5454, 0x656C, 0x6E45, 0x6944, 0x6E61, 0 };
1393 void _ascii () { char *s = (char *) ascii_mm; s = (char *) ascii_ii; }
1394 short int ebcdic_ii[] = { 0x89D3, 0xE3E3, 0x8593, 0x95C5, 0x89C4, 0x9581, 0 };
1395 short int ebcdic_mm[] = { 0xC2C9, 0xC785, 0x95C4, 0x8981, 0x95E2, 0xA8E2, 0 };
1396 void _ebcdic () { char *s = (char *) ebcdic_mm; s = (char *) ebcdic_ii; }]],
1397 [[ _ascii (); _ebcdic (); ]])],
1398 [if grep BIGenDianSyS conftest.$ac_objext >/dev/null ; then
1399   ac_cv_c_bigendian=yes
1400 fi
1401 if grep LiTTleEnDian conftest.$ac_objext >/dev/null ; then
1402   if test "$ac_cv_c_bigendian" = unknown; then
1403     ac_cv_c_bigendian=no
1404   else
1405     # finding both strings is unlikely to happen, but who knows?
1406     ac_cv_c_bigendian=unknown
1407   fi
1408 fi])])])])
1409 case $ac_cv_c_bigendian in
1410   yes)
1411     m4_default([$1],
1412       [AC_DEFINE([WORDS_BIGENDIAN], 1,
1413         [Define to 1 if your processor stores words with the most significant
1414          byte first (like Motorola and SPARC, unlike Intel and VAX).])]) ;;
1415   no)
1416     $2 ;;
1417   *)
1418     m4_default([$3],
1419       [AC_MSG_ERROR([unknown endianness
1420 presetting ac_cv_c_bigendian=no (or yes) will help])]) ;;
1421 esac
1422 ])# AC_C_BIGENDIAN
1423
1424
1425 # AC_C_INLINE
1426 # -----------
1427 # Do nothing if the compiler accepts the inline keyword.
1428 # Otherwise define inline to __inline__ or __inline if one of those work,
1429 # otherwise define inline to be empty.
1430 #
1431 # HP C version B.11.11.04 doesn't allow a typedef as the return value for an
1432 # inline function, only builtin types.
1433 #
1434 AN_IDENTIFIER([inline], [AC_C_INLINE])
1435 AC_DEFUN([AC_C_INLINE],
1436 [AC_CACHE_CHECK([for inline], ac_cv_c_inline,
1437 [ac_cv_c_inline=no
1438 for ac_kw in inline __inline__ __inline; do
1439   AC_COMPILE_IFELSE([AC_LANG_SOURCE(
1440 [#ifndef __cplusplus
1441 typedef int foo_t;
1442 static $ac_kw foo_t static_foo () {return 0; }
1443 $ac_kw foo_t foo () {return 0; }
1444 #endif
1445 ])],
1446                     [ac_cv_c_inline=$ac_kw])
1447   test "$ac_cv_c_inline" != no && break
1448 done
1449 ])
1450 AH_VERBATIM([inline],
1451 [/* Define to `__inline__' or `__inline' if that's what the C compiler
1452    calls it, or to nothing if 'inline' is not supported under any name.  */
1453 #ifndef __cplusplus
1454 #undef inline
1455 #endif])
1456 case $ac_cv_c_inline in
1457   inline | yes) ;;
1458   *)
1459     case $ac_cv_c_inline in
1460       no) ac_val=;;
1461       *) ac_val=$ac_cv_c_inline;;
1462     esac
1463     cat >>confdefs.h <<_ACEOF
1464 #ifndef __cplusplus
1465 #define inline $ac_val
1466 #endif
1467 _ACEOF
1468     ;;
1469 esac
1470 ])# AC_C_INLINE
1471
1472
1473 # AC_C_CONST
1474 # ----------
1475 AN_IDENTIFIER([const],  [AC_C_CONST])
1476 AC_DEFUN([AC_C_CONST],
1477 [AC_CACHE_CHECK([for an ANSI C-conforming const], ac_cv_c_const,
1478 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1479 [[/* FIXME: Include the comments suggested by Paul. */
1480 #ifndef __cplusplus
1481   /* Ultrix mips cc rejects this.  */
1482   typedef int charset[2];
1483   const charset cs;
1484   /* SunOS 4.1.1 cc rejects this.  */
1485   char const *const *pcpcc;
1486   char **ppc;
1487   /* NEC SVR4.0.2 mips cc rejects this.  */
1488   struct point {int x, y;};
1489   static struct point const zero = {0,0};
1490   /* AIX XL C 1.02.0.0 rejects this.
1491      It does not let you subtract one const X* pointer from another in
1492      an arm of an if-expression whose if-part is not a constant
1493      expression */
1494   const char *g = "string";
1495   pcpcc = &g + (g ? g-g : 0);
1496   /* HPUX 7.0 cc rejects these. */
1497   ++pcpcc;
1498   ppc = (char**) pcpcc;
1499   pcpcc = (char const *const *) ppc;
1500   { /* SCO 3.2v4 cc rejects this.  */
1501     char *t;
1502     char const *s = 0 ? (char *) 0 : (char const *) 0;
1503
1504     *t++ = 0;
1505     if (s) return 0;
1506   }
1507   { /* Someone thinks the Sun supposedly-ANSI compiler will reject this.  */
1508     int x[] = {25, 17};
1509     const int *foo = &x[0];
1510     ++foo;
1511   }
1512   { /* Sun SC1.0 ANSI compiler rejects this -- but not the above. */
1513     typedef const int *iptr;
1514     iptr p = 0;
1515     ++p;
1516   }
1517   { /* AIX XL C 1.02.0.0 rejects this saying
1518        "k.c", line 2.27: 1506-025 (S) Operand must be a modifiable lvalue. */
1519     struct s { int j; const int *ap[3]; };
1520     struct s *b; b->j = 5;
1521   }
1522   { /* ULTRIX-32 V3.1 (Rev 9) vcc rejects this */
1523     const int foo = 10;
1524     if (!foo) return 0;
1525   }
1526   return !cs[0] && !zero.x;
1527 #endif
1528 ]])],
1529                    [ac_cv_c_const=yes],
1530                    [ac_cv_c_const=no])])
1531 if test $ac_cv_c_const = no; then
1532   AC_DEFINE(const,,
1533             [Define to empty if `const' does not conform to ANSI C.])
1534 fi
1535 ])# AC_C_CONST
1536
1537
1538 # AC_C_RESTRICT
1539 # -------------
1540 # based on acx_restrict.m4, from the GNU Autoconf Macro Archive at:
1541 # http://autoconf-archive.cryp.to/acx_restrict.html
1542 #
1543 # Determine whether the C/C++ compiler supports the "restrict" keyword
1544 # introduced in ANSI C99, or an equivalent.  Do nothing if the compiler
1545 # accepts it.  Otherwise, if the compiler supports an equivalent,
1546 # define "restrict" to be that.  Here are some variants:
1547 # - GCC supports both __restrict and __restrict__
1548 # - older DEC Alpha C compilers support only __restrict
1549 # - _Restrict is the only spelling accepted by Sun WorkShop 6 update 2 C
1550 # Otherwise, define "restrict" to be empty.
1551 AN_IDENTIFIER([restrict], [AC_C_RESTRICT])
1552 AC_DEFUN([AC_C_RESTRICT],
1553 [AC_CACHE_CHECK([for C/C++ restrict keyword], ac_cv_c_restrict,
1554   [ac_cv_c_restrict=no
1555    # Try the official restrict keyword, then gcc's __restrict, and
1556    # the less common variants.
1557    for ac_kw in restrict __restrict __restrict__ _Restrict; do
1558      AC_COMPILE_IFELSE([AC_LANG_PROGRAM(
1559       [[typedef int * int_ptr;
1560         int foo (int_ptr $ac_kw ip) {
1561         return ip[0];
1562        }]],
1563       [[int s[1];
1564         int * $ac_kw t = s;
1565         t[0] = 0;
1566         return foo(t)]])],
1567       [ac_cv_c_restrict=$ac_kw])
1568      test "$ac_cv_c_restrict" != no && break
1569    done
1570   ])
1571  case $ac_cv_c_restrict in
1572    restrict) ;;
1573    no) AC_DEFINE(restrict,,
1574         [Define to equivalent of C99 restrict keyword, or to nothing if this
1575         is not supported.  Do not define if restrict is supported directly.]) ;;
1576    *)  AC_DEFINE_UNQUOTED(restrict, $ac_cv_c_restrict) ;;
1577  esac
1578 ])# AC_C_RESTRICT
1579
1580
1581 # AC_C_VOLATILE
1582 # -------------
1583 # Note that, unlike const, #defining volatile to be the empty string can
1584 # actually turn a correct program into an incorrect one, since removing
1585 # uses of volatile actually grants the compiler permission to perform
1586 # optimizations that could break the user's code.  So, do not #define
1587 # volatile away unless it is really necessary to allow the user's code
1588 # to compile cleanly.  Benign compiler failures should be tolerated.
1589 AN_IDENTIFIER([volatile], [AC_C_VOLATILE])
1590 AC_DEFUN([AC_C_VOLATILE],
1591 [AC_CACHE_CHECK([for working volatile], ac_cv_c_volatile,
1592 [AC_COMPILE_IFELSE([AC_LANG_PROGRAM([], [
1593 volatile int x;
1594 int * volatile y = (int *) 0;
1595 return !x && !y;])],
1596                    [ac_cv_c_volatile=yes],
1597                    [ac_cv_c_volatile=no])])
1598 if test $ac_cv_c_volatile = no; then
1599   AC_DEFINE(volatile,,
1600             [Define to empty if the keyword `volatile' does not work.
1601              Warning: valid code using `volatile' can become incorrect
1602              without.  Disable with care.])
1603 fi
1604 ])# AC_C_VOLATILE
1605
1606
1607 # AC_C_STRINGIZE
1608 # --------------
1609 # Checks if `#' can be used to glue strings together at the CPP level.
1610 # Defines HAVE_STRINGIZE if positive.
1611 AC_DEFUN([AC_C_STRINGIZE],
1612 [AC_CACHE_CHECK([for preprocessor stringizing operator],
1613                 [ac_cv_c_stringize],
1614 [AC_EGREP_CPP([@%:@teststring],
1615               [@%:@define x(y) #y
1616
1617 char *s = x(teststring);],
1618               [ac_cv_c_stringize=no],
1619               [ac_cv_c_stringize=yes])])
1620 if test $ac_cv_c_stringize = yes; then
1621   AC_DEFINE(HAVE_STRINGIZE, 1,
1622             [Define to 1 if cpp supports the ANSI @%:@ stringizing operator.])
1623 fi
1624 ])# AC_C_STRINGIZE
1625
1626
1627 # AC_C_PROTOTYPES
1628 # ---------------
1629 # Check if the C compiler supports prototypes, included if it needs
1630 # options.
1631 AC_DEFUN([AC_C_PROTOTYPES],
1632 [AC_REQUIRE([AC_PROG_CC])dnl
1633 AC_MSG_CHECKING([for function prototypes])
1634 if test "$ac_cv_prog_cc_c89" != no; then
1635   AC_MSG_RESULT([yes])
1636   AC_DEFINE(PROTOTYPES, 1,
1637             [Define to 1 if the C compiler supports function prototypes.])
1638   AC_DEFINE(__PROTOTYPES, 1,
1639             [Define like PROTOTYPES; this can be used by system headers.])
1640 else
1641   AC_MSG_RESULT([no])
1642 fi
1643 ])# AC_C_PROTOTYPES
1644
1645
1646 # AC_C_FLEXIBLE_ARRAY_MEMBER
1647 # --------------------------
1648 # Check whether the C compiler supports flexible array members.
1649 AC_DEFUN([AC_C_FLEXIBLE_ARRAY_MEMBER],
1650 [
1651   AC_CACHE_CHECK([for flexible array members],
1652     ac_cv_c_flexmember,
1653     [AC_COMPILE_IFELSE(
1654        [AC_LANG_PROGRAM(
1655           [[#include <stdlib.h>
1656             #include <stdio.h>
1657             #include <stddef.h>
1658             struct s { int n; double d[]; };]],
1659           [[int m = getchar ();
1660             struct s *p = malloc (offsetof (struct s, d)
1661                                   + m * sizeof (double));
1662             p->d[0] = 0.0;
1663             return p->d != (double *) NULL;]])],
1664        [ac_cv_c_flexmember=yes],
1665        [ac_cv_c_flexmember=no])])
1666   if test $ac_cv_c_flexmember = yes; then
1667     AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], [],
1668       [Define to nothing if C supports flexible array members, and to
1669        1 if it does not.  That way, with a declaration like `struct s
1670        { int n; double d@<:@FLEXIBLE_ARRAY_MEMBER@:>@; };', the struct hack
1671        can be used with pre-C99 compilers.
1672        When computing the size of such an object, don't use 'sizeof (struct s)'
1673        as it overestimates the size.  Use 'offsetof (struct s, d)' instead.
1674        Don't use 'offsetof (struct s, d@<:@0@:>@)', as this doesn't work with
1675        MSVC and with C++ compilers.])
1676   else
1677     AC_DEFINE([FLEXIBLE_ARRAY_MEMBER], 1)
1678   fi
1679 ])
1680
1681
1682 # AC_C_VARARRAYS
1683 # --------------
1684 # Check whether the C compiler supports variable-length arrays.
1685 AC_DEFUN([AC_C_VARARRAYS],
1686 [
1687   AC_CACHE_CHECK([for variable-length arrays],
1688     ac_cv_c_vararrays,
1689     [AC_COMPILE_IFELSE(
1690        [AC_LANG_PROGRAM([],
1691           [[static int x; char a[++x]; a[sizeof a - 1] = 0; return a[0];]])],
1692        [ac_cv_c_vararrays=yes],
1693        [ac_cv_c_vararrays=no])])
1694   if test $ac_cv_c_vararrays = yes; then
1695     AC_DEFINE([HAVE_C_VARARRAYS], 1,
1696       [Define to 1 if C supports variable-length arrays.])
1697   fi
1698 ])
1699
1700
1701 # AC_C_TYPEOF
1702 # -----------
1703 # Check if the C compiler supports GCC's typeof syntax.
1704 # The test case provokes incompatibilities in the Sun C compilers
1705 # (both Solaris 8 and Solaris 10).
1706 AC_DEFUN([AC_C_TYPEOF],
1707 [
1708   AC_CACHE_CHECK([for typeof syntax and keyword spelling], ac_cv_c_typeof,
1709     [ac_cv_c_typeof=no
1710      for ac_kw in typeof __typeof__ no; do
1711        test $ac_kw = no && break
1712        AC_COMPILE_IFELSE([AC_LANG_PROGRAM([],
1713          [[
1714            int value;
1715            typedef struct {
1716                    char a [1
1717                            + ! (($ac_kw (value))
1718                                 (($ac_kw (value)) 0 < ($ac_kw (value)) -1
1719                                  ? ($ac_kw (value)) - 1
1720                                  : ~ (~ ($ac_kw (value)) 0
1721                                       << sizeof ($ac_kw (value)))))]; }
1722               ac__typeof_type_;
1723            return
1724              (! ((void) ((ac__typeof_type_ *) 0), 0));
1725          ]])],
1726          [ac_cv_c_typeof=$ac_kw])
1727        test $ac_cv_c_typeof != no && break
1728      done])
1729   if test $ac_cv_c_typeof != no; then
1730     AC_DEFINE([HAVE_TYPEOF], 1,
1731       [Define to 1 if typeof works with your compiler.])
1732     if test $ac_cv_c_typeof != typeof; then
1733       AC_DEFINE_UNQUOTED([typeof], [$ac_cv_c_typeof],
1734         [Define to __typeof__ if your compiler spells it that way.])
1735     fi
1736   fi
1737 ])