Remove redundant 'mpi.h'
[mpich.git] / confdb / aclocal_cc.m4
1 dnl AC_PROG_CC_GNU
2 ifdef([AC_PROG_CC_GNU],,[AC_DEFUN([AC_PROG_CC_GNU],)])
3
4 dnl PAC_PROG_CC - reprioritize the C compiler search order
5 AC_DEFUN([PAC_PROG_CC],[
6         dnl Many standard autoconf/automake/libtool macros, such as LT_INIT,
7         dnl perform an AC_REQUIRE([AC_PROG_CC]).  If this macro (PAC_PROG_CC)
8         dnl comes after LT_INIT (or similar) then the default compiler search
9         dnl path will be used instead.  This AC_BEFORE macro ensures that a
10         dnl warning will be emitted at autoconf-time (autogen.sh-time) to help
11         dnl developers notice this case.
12         AC_BEFORE([$0],[AC_PROG_CC])
13         PAC_PUSH_FLAG([CFLAGS])
14         AC_PROG_CC([icc pgcc xlc xlC pathcc gcc clang cc])
15         PAC_POP_FLAG([CFLAGS])
16 ])
17 dnl
18 dnl/*D
19 dnl PAC_C_CHECK_COMPILER_OPTION - Check that a compiler option is accepted
20 dnl without warning messages
21 dnl
22 dnl Synopsis:
23 dnl PAC_C_CHECK_COMPILER_OPTION(optionname,action-if-ok,action-if-fail)
24 dnl
25 dnl Output Effects:
26 dnl
27 dnl If no actions are specified, a working value is added to 'COPTIONS'
28 dnl
29 dnl Notes:
30 dnl This is now careful to check that the output is different, since 
31 dnl some compilers are noisy.
32 dnl 
33 dnl We are extra careful to prototype the functions in case compiler options
34 dnl that complain about poor code are in effect.
35 dnl
36 dnl Because this is a long script, we have ensured that you can pass a 
37 dnl variable containing the option name as the first argument.
38 dnl
39 dnl D*/
40 AC_DEFUN([PAC_C_CHECK_COMPILER_OPTION],[
41 AC_MSG_CHECKING([whether C compiler accepts option $1])
42 pac_opt="$1"
43 AC_LANG_PUSH([C])
44 CFLAGS_orig="$CFLAGS"
45 CFLAGS_opt="$pac_opt $CFLAGS"
46 pac_result="unknown"
47
48 AC_LANG_CONFTEST([
49         AC_LANG_PROGRAM([[#include <stdio.h>
50                           const char hw[] = "Hello, World\n";]],
51                 [[fputs (hw, stdout);]])
52 ])
53 CFLAGS="$CFLAGS_orig"
54 rm -f pac_test1.log
55 PAC_LINK_IFELSE_LOG([pac_test1.log], [], [
56     CFLAGS="$CFLAGS_opt"
57     rm -f pac_test2.log
58     PAC_LINK_IFELSE_LOG([pac_test2.log], [], [
59         PAC_RUNLOG_IFELSE([diff -b pac_test1.log pac_test2.log],
60                           [pac_result=yes],[pac_result=no])
61     ],[
62         pac_result=no
63     ])
64 ], [
65     pac_result=no
66 ])
67 AC_MSG_RESULT([$pac_result])
68 dnl Delete the conftest created by AC_LANG_CONFTEST.
69 rm -f conftest.$ac_ext
70
71 # gcc 4.2.4 on 32-bit does not complain about the -Wno-type-limits option 
72 # even though it doesn't support it.  However, when another warning is 
73 # triggered, it gives an error that the option is not recognized.  So we 
74 # need to test with a conftest file that will generate warnings.
75
76 # add an extra switch, pac_c_check_compiler_option_prototest, to
77 # disable this test just in case some new compiler does not like it.
78 #
79 # Linking with a program with an invalid prototype to ensure a compiler warning.
80
81 if test "$pac_result" = "yes" \
82      -a "$pac_c_check_compiler_option_prototest" != "no" ; then
83     AC_MSG_CHECKING([whether C compiler option $1 works with an invalid prototype program])
84     AC_LINK_IFELSE([
85         dnl We want a warning, but we don't want to inadvertently disable
86         dnl special warnings like -Werror-implicit-function-declaration (e.g.,
87         dnl in PAC_CC_STRICT) by compiling something that might actually be
88         dnl treated as an error by the compiler.  So we try to elicit an
89         dnl "unused variable" warning and/or an "uninitialized" warning with the
90         dnl test program below.
91         dnl
92         dnl The old sanity program was:
93         dnl   void main() {return 0;}
94         dnl which clang (but not GCC) would treat as an *error*, invalidating
95         dnl the test for any given parameter.
96         AC_LANG_SOURCE([int main(int argc, char **argv){ int foo, bar = 0; foo += 1; return foo; }])
97     ],[pac_result=yes],[pac_result=no])
98     AC_MSG_RESULT([$pac_result])
99 fi
100 #
101 if test "$pac_result" = "yes" ; then
102     AC_MSG_CHECKING([whether routines compiled with $pac_opt can be linked with ones compiled without $pac_opt])
103     pac_result=unknown
104     CFLAGS="$CFLAGS_orig"
105     rm -f pac_test3.log
106     PAC_COMPILE_IFELSE_LOG([pac_test3.log], [
107         AC_LANG_SOURCE([
108             int foo(void);
109             int foo(void){return 0;}
110         ])
111     ],[
112         PAC_RUNLOG([mv conftest.$OBJEXT pac_conftest.$OBJEXT])
113         saved_LIBS="$LIBS"
114         LIBS="pac_conftest.$OBJEXT $LIBS"
115
116         rm -f pac_test4.log
117         PAC_LINK_IFELSE_LOG([pac_test4.log], [AC_LANG_PROGRAM()], [
118             CFLAGS="$CFLAGS_opt"
119             rm -f pac_test5.log
120             PAC_LINK_IFELSE_LOG([pac_test5.log], [AC_LANG_PROGRAM()], [
121                 PAC_RUNLOG_IFELSE([diff -b pac_test4.log pac_test5.log],
122                                   [pac_result=yes], [pac_result=no])
123             ],[
124                 pac_result=no
125             ])
126         ],[
127             pac_result=no
128         ])
129         LIBS="$saved_LIBS"
130         rm -f pac_conftest.$OBJEXT
131     ],[
132         pac_result=no
133     ])
134     AC_MSG_RESULT([$pac_result])
135     rm -f pac_test3.log pac_test4.log pac_test5.log
136 fi
137 rm -f pac_test1.log pac_test2.log
138
139 dnl Restore CFLAGS before 2nd/3rd argument commands are executed,
140 dnl as 2nd/3rd argument command could be modifying CFLAGS.
141 CFLAGS="$CFLAGS_orig"
142 if test "$pac_result" = "yes" ; then
143      ifelse([$2],[],[COPTIONS="$COPTIONS $1"],[$2])
144 else
145      ifelse([$3],[],[:],[$3])
146 fi
147 AC_LANG_POP([C])
148 ])
149 dnl
150 dnl/*D
151 dnl PAC_C_OPTIMIZATION - Determine C options for producing optimized code
152 dnl
153 dnl Synopsis
154 dnl PAC_C_OPTIMIZATION([action if found])
155 dnl
156 dnl Output Effect:
157 dnl Adds options to 'COPTIONS' if no other action is specified
158 dnl 
159 dnl Notes:
160 dnl This is a temporary standin for compiler optimization.
161 dnl It should try to match known systems to known compilers (checking, of
162 dnl course), and then falling back to some common defaults.
163 dnl Note that many compilers will complain about -g and aggressive
164 dnl optimization.  
165 dnl D*/
166 AC_DEFUN([PAC_C_OPTIMIZATION],[
167     for copt in "-O4 -Ofast" "-Ofast" "-fast" "-O3" "-xO3" "-O" ; do
168         PAC_C_CHECK_COMPILER_OPTION($copt,found_opt=yes,found_opt=no)
169         if test "$found_opt" = "yes" ; then
170             ifelse($1,,COPTIONS="$COPTIONS $copt",$1)
171             break
172         fi
173     done
174     if test "$ac_cv_prog_gcc" = "yes" ; then
175         for copt in "-fomit-frame-pointer" "-finline-functions" \
176                  "-funroll-loops" ; do
177             PAC_C_CHECK_COMPILER_OPTION($copt,found_opt=yes,found_opt=no)
178             if test "$found_opt" = "yes" ; then
179                 ifelse($1,,COPTIONS="$COPTIONS $copt",$1)
180                 # no break because we're trying to add them all
181             fi
182         done
183         # We could also look for architecture-specific gcc options
184     fi
185
186 ])
187
188 dnl/*D
189 dnl PAC_PROG_C_UNALIGNED_DOUBLES - Check that the C compiler allows unaligned
190 dnl doubles
191 dnl
192 dnl Synopsis:
193 dnl   PAC_PROG_C_UNALIGNED_DOUBLES(action-if-true,action-if-false,
194 dnl       action-if-unknown)
195 dnl
196 dnl Notes:
197 dnl 'action-if-unknown' is used in the case of cross-compilation.
198 dnl D*/
199 AC_DEFUN([PAC_PROG_C_UNALIGNED_DOUBLES],[
200 AC_CACHE_CHECK([whether C compiler allows unaligned doubles],
201 pac_cv_prog_c_unaligned_doubles,[
202 AC_TRY_RUN([
203 void fetch_double( v )
204 double *v;
205 {
206 *v = 1.0;
207 }
208 int main( argc, argv )
209 int argc;
210 char **argv;
211 {
212 int p[4];
213 double *p_val;
214 fetch_double( (double *)&(p[0]) );
215 p_val = (double *)&(p[0]);
216 if (*p_val != 1.0) return 1;
217 fetch_double( (double *)&(p[1]) );
218 p_val = (double *)&(p[1]);
219 if (*p_val != 1.0) return 1;
220 return 0;
221 }
222 ],pac_cv_prog_c_unaligned_doubles="yes",pac_cv_prog_c_unaligned_doubles="no",
223 pac_cv_prog_c_unaligned_doubles="unknown")])
224 ifelse($1,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "yes" ; then 
225 $1
226 fi)
227 ifelse($2,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "no" ; then 
228 $2
229 fi)
230 ifelse($3,,,if test "X$pac_cv_prog_c_unaligned_doubles" = "unknown" ; then 
231 $3
232 fi)
233 ])
234
235 dnl/*D 
236 dnl PAC_PROG_C_WEAK_SYMBOLS - Test whether C supports weak alias symbols.
237 dnl
238 dnl Synopsis
239 dnl PAC_PROG_C_WEAK_SYMBOLS(action-if-true,action-if-false)
240 dnl
241 dnl Output Effect:
242 dnl Defines one of the following if a weak symbol pragma is found:
243 dnl.vb
244 dnl    HAVE_PRAGMA_WEAK - #pragma weak
245 dnl    HAVE_PRAGMA_HP_SEC_DEF - #pragma _HP_SECONDARY_DEF
246 dnl    HAVE_PRAGMA_CRI_DUP  - #pragma _CRI duplicate x as y
247 dnl.ve
248 dnl May also define
249 dnl.vb
250 dnl    HAVE_WEAK_ATTRIBUTE
251 dnl.ve
252 dnl if functions can be declared as 'int foo(...) __attribute__ ((weak));'
253 dnl sets the shell variable pac_cv_attr_weak to yes.
254 dnl Also checks for __attribute__((weak_import)) which is supported by
255 dnl Apple in Mac OSX (at least in Darwin).  Note that this provides only
256 dnl weak symbols, not weak aliases
257 dnl 
258 dnl D*/
259 AC_DEFUN([PAC_PROG_C_WEAK_SYMBOLS],[
260 pragma_extra_message=""
261 AC_CACHE_CHECK([for type of weak symbol alias support],
262 pac_cv_prog_c_weak_symbols,[
263 # Test for weak symbol support...
264 # We can't put # in the message because it causes autoconf to generate
265 # incorrect code
266 AC_TRY_LINK([
267 extern int PFoo(int);
268 #pragma weak PFoo = Foo
269 int Foo(int a) { return a; }
270 ],[return PFoo(1);],has_pragma_weak=yes)
271 #
272 # Some systems (Linux ia64 and ecc, for example), support weak symbols
273 # only within a single object file!  This tests that case.
274 # Note that there is an extern int PFoo declaration before the
275 # pragma.  Some compilers require this in order to make the weak symbol
276 # externally visible.  
277 if test "$has_pragma_weak" = yes ; then
278     PAC_COMPLINK_IFELSE([
279         AC_LANG_SOURCE([
280 extern int PFoo(int);
281 #pragma weak PFoo = Foo
282 int Foo(int);
283 int Foo(int a) { return a; }
284         ])
285     ],[
286         AC_LANG_SOURCE([
287 extern int PFoo(int);
288 int main(int argc, char **argv) {
289 return PFoo(0);}
290         ])
291     ],[
292         PAC_COMPLINK_IFELSE([
293             AC_LANG_SOURCE([
294 extern int PFoo(int);
295 #pragma weak PFoo = Foo
296 int Foo(int);
297 int Foo(int a) { return a; }
298             ])
299         ],[
300             AC_LANG_SOURCE([
301 extern int Foo(int);
302 int PFoo(int a) { return a+1;}
303 int main(int argc, char **argv) {
304 return Foo(0);}
305             ])
306         ],[
307             pac_cv_prog_c_weak_symbols="pragma weak"
308         ],[
309             has_pragma_weak=0
310             pragma_extra_message="pragma weak accepted but does not work (probably creates two non-weak entries)"
311         ])
312     ],[
313         has_pragma_weak=0
314         pragma_extra_message="pragma weak accepted but does not work (probably creates two non-weak entries)"
315     ])
316 fi
317 dnl
318 if test -z "$pac_cv_prog_c_weak_symbols" ; then 
319     AC_TRY_LINK([
320 extern int PFoo(int);
321 #pragma _HP_SECONDARY_DEF Foo  PFoo
322 int Foo(int a) { return a; }
323 ],[return PFoo(1);],pac_cv_prog_c_weak_symbols="pragma _HP_SECONDARY_DEF")
324 fi
325 dnl
326 if test -z "$pac_cv_prog_c_weak_symbols" ; then
327     AC_TRY_LINK([
328 extern int PFoo(int);
329 #pragma _CRI duplicate PFoo as Foo
330 int Foo(int a) { return a; }
331 ],[return PFoo(1);],pac_cv_prog_c_weak_symbols="pragma _CRI duplicate x as y")
332 fi
333 dnl
334 if test -z "$pac_cv_prog_c_weak_symbols" ; then
335     pac_cv_prog_c_weak_symbols="no"
336 fi
337 dnl
338 dnl If there is an extra explanatory message, echo it now so that it
339 dnl doesn't interfere with the cache result value
340 if test -n "$pragma_extra_message" ; then
341     echo $pragma_extra_message
342 fi
343 dnl
344 ])
345 if test "$pac_cv_prog_c_weak_symbols" != "no" ; then
346     case "$pac_cv_prog_c_weak_symbols" in
347         "pragma weak") AC_DEFINE(HAVE_PRAGMA_WEAK,1,[Supports weak pragma])
348         ;;
349         "pragma _HP")  AC_DEFINE(HAVE_PRAGMA_HP_SEC_DEF,1,[HP style weak pragma])
350         ;;
351         "pragma _CRI") AC_DEFINE(HAVE_PRAGMA_CRI_DUP,1,[Cray style weak pragma])
352         ;;
353     esac
354 fi
355 AC_CACHE_CHECK([whether __attribute__ ((weak)) allowed],
356 pac_cv_attr_weak,[
357 AC_TRY_COMPILE([int foo(int) __attribute__ ((weak));],[int a;],
358 pac_cv_attr_weak=yes,pac_cv_attr_weak=no)])
359 # Note that being able to compile with weak_import doesn't mean that
360 # it works.
361 AC_CACHE_CHECK([whether __attribute__ ((weak_import)) allowed],
362 pac_cv_attr_weak_import,[
363 AC_TRY_COMPILE([int foo(int) __attribute__ ((weak_import));],[int a;],
364 pac_cv_attr_weak_import=yes,pac_cv_attr_weak_import=no)])
365 # Check if the alias option for weak attributes is allowed
366 AC_CACHE_CHECK([whether __attribute__((weak,alias(...))) allowed],
367 pac_cv_attr_weak_alias,[
368 PAC_PUSH_FLAG([CFLAGS])
369 # force an error exit if the weak attribute isn't understood
370 CFLAGS=-Werror
371 AC_TRY_COMPILE([int __foo(int a){return 0;} int foo(int) __attribute__((weak,alias("__foo")));],[int a;],
372 pac_cv_attr_weak_alias=yes,pac_cv_attr_weak_alias=no)
373 # Restore original CFLAGS
374 PAC_POP_FLAG([CFLAGS])])
375 if test "$pac_cv_attr_weak_alias" = "yes" ; then
376     AC_DEFINE(HAVE_WEAK_ATTRIBUTE,1,[Attribute style weak pragma])
377 fi
378 if test "$pac_cv_prog_c_weak_symbols" = "no" -a "$pac_cv_attr_weak_alias" = "no" ; then
379     ifelse([$2],,:,[$2])
380 else
381     ifelse([$1],,:,[$1])
382 fi
383 ])
384
385 #
386 # This is a replacement that checks that FAILURES are signaled as well
387 # (later configure macros look for the .o file, not just success from the
388 # compiler, but they should not HAVE to
389 #
390 dnl --- insert 2.52 compatibility here ---
391 dnl 2.52 does not have AC_PROG_CC_WORKS
392 ifdef([AC_PROG_CC_WORKS],,[AC_DEFUN([AC_PROG_CC_WORKS],)])
393 dnl
394 AC_DEFUN([PAC_PROG_CC_WORKS],
395 [AC_PROG_CC_WORKS
396 AC_MSG_CHECKING([whether the C compiler sets its return status correctly])
397 AC_LANG_SAVE
398 AC_LANG_C
399 AC_TRY_COMPILE(,[int a = bzzzt;],notbroken=no,notbroken=yes)
400 AC_MSG_RESULT($notbroken)
401 if test "$notbroken" = "no" ; then
402     AC_MSG_ERROR([installation or configuration problem: C compiler does not
403 correctly set error code when a fatal error occurs])
404 fi
405 ])
406
407 dnl/*D 
408 dnl PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS - Test whether C and the
409 dnl linker allow multiple weak symbols.
410 dnl
411 dnl Synopsis
412 dnl PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS(action-if-true,action-if-false)
413 dnl
414 dnl 
415 dnl D*/
416 AC_DEFUN([PAC_PROG_C_MULTIPLE_WEAK_SYMBOLS],[
417 AC_CACHE_CHECK([for multiple weak symbol support],
418 pac_cv_prog_c_multiple_weak_symbols,[
419 # Test for multiple weak symbol support...
420 PAC_COMPLINK_IFELSE([
421     AC_LANG_SOURCE([
422 extern int PFoo(int);
423 extern int PFoo_(int);
424 extern int pfoo_(int);
425 #pragma weak PFoo = Foo
426 #pragma weak PFoo_ = Foo
427 #pragma weak pfoo_ = Foo
428 int Foo(int);
429 int Foo(a) { return a; }
430     ])
431 ],[
432     AC_LANG_SOURCE([
433 extern int PFoo(int), PFoo_(int), pfoo_(int);
434 int main() {
435 return PFoo(0) + PFoo_(1) + pfoo_(2);}
436     ])
437 ],[
438     pac_cv_prog_c_multiple_weak_symbols="yes"
439 ])
440 dnl
441 ])
442 if test "$pac_cv_prog_c_multiple_weak_symbols" = "yes" ; then
443     ifelse([$1],,:,[$1])
444 else
445     ifelse([$2],,:,[$2])
446 fi
447 ])
448
449 dnl Use the value of enable-strict to update CFLAGS
450 dnl pac_cc_strict_flags contains the strict flags.
451 dnl
452 dnl -std=c89 is used to select the C89 version of the ANSI/ISO C standard.
453 dnl As of this writing, many C compilers still accepted only this version,
454 dnl not the later C99 version. When all compilers accept C99, this 
455 dnl should be changed to the appropriate standard level.  Note that we've
456 dnl had trouble with gcc 2.95.3 accepting -std=c89 but then trying to 
457 dnl compile program with a invalid set of options 
458 dnl (-D __STRICT_ANSI__-trigraphs)
459 AC_DEFUN([PAC_CC_STRICT],[
460 export enable_strict_done
461 if test "$enable_strict_done" != "yes" ; then
462
463     # Some comments on strict warning options.
464     # These were added to improve portability
465     #   -Wstack-usage=262144 -- 32 bit FreeBSD did not like the mprobe test
466     #       allocating a big variable on the stack. (See tt#2160).  The "right"
467     #       value requires further investigation; 1 MiB would have at least
468     #       caught #2160 at compile-time, and only two other tests show a
469     #       warning at 256k.
470     #
471     # These were added to reduce warnings:
472     #   -Wno-missing-field-initializers  -- We want to allow a struct to be 
473     #       initialized to zero using "struct x y = {0};" and not require 
474     #       each field to be initialized individually.
475     #   -Wno-unused-parameter -- For portability, some parameters go unused
476     #       when we have different implementations of functions for 
477     #       different platforms
478     #   -Wno-unused-label -- We add fn_exit: and fn_fail: on all functions, 
479     #       but fn_fail may not be used if the function doesn't return an 
480     #       error.
481     #   -Wno-sign-compare -- read() and write() return bytes read/written
482     #       as a signed value, but we often compare this to size_t (or
483     #       msg_sz_t) variables.
484     #   -Wno-format-zero-length -- this warning is irritating and useless, since
485     #                              a zero-length format string is very well defined
486     # These were removed to reduce warnings:
487     #   -Wcast-qual -- Sometimes we need to cast "volatile char*" to 
488     #       "char*", e.g., for memcpy.
489     #   -Wpadded -- We catch struct padding with asserts when we need to
490     #   -Wredundant-decls -- Having redundant declarations is benign and the 
491     #       code already has some.
492     #   -Waggregate-return -- This seems to be a performance-related warning
493     #       aggregate return values are legal in ANSI C, but they may be returned
494     #       in memory rather than through a register.  We do use aggregate return
495     #       values, but they are structs of a single basic type (used to enforce
496     #       type checking for relative vs. absolute ptrs), and with optimization
497     #       the aggregate value is converted to a scalar.
498     #   -Wdeclaration-after-statement -- This is a C89
499     #       requirement. When compiling with C99, this should be
500     #       disabled.
501     #   -Wfloat-equal -- There are places in hwloc that set a float var to 0, then 
502     #       compare it to 0 later to see if it was updated.  Also when using strtod()
503     #       one needs to compare the return value with 0 to see whether a conversion
504     #       was performed.
505     #   -Werror-implicit-function-declaration -- implicit function declarations
506     #       should never be tolerated.  This also ensures that we get quick
507     #       compilation failures rather than later link failures that usually
508     #       come from a function name typo.
509     #   -Wcast-align -- Casting alignment warnings.  This is an
510     #       important check, but is temporarily disabled, since it is
511     #       throwing too many (correct) warnings currently, causing us
512     #       to miss other warnings.
513     #   -Wshorten-64-to-32 -- Bad type-casting warnings.  This is an
514     #       important check, but is temporarily disabled, since it is
515     #       throwing too many (correct) warnings currently, causing us
516     #       to miss other warnings.
517     #
518     # This was removed because it masks important failures (see ticket #2094).
519     # However, since Intel compiler currently does not include -Wtype-limits
520     # in -Wextra, -Wtype-limits was added to handle warnings with the Intel
521     # compiler.
522     #   -Wno-type-limits -- There are places where we compare an unsigned to 
523     #       a constant that happens to be zero e.g., if x is unsigned and 
524     #       MIN_VAL is zero, we'd like to do "MPIR_Assert(x >= MIN_VAL);".
525     #       Note this option is not supported by gcc 4.2.  This needs to be added 
526     #       after most other warning flags, so that we catch a gcc bug on 32-bit 
527     #       that doesn't give a warning that this is unsupported, unless another
528     #       warning is triggered, and then if gives an error.
529     # the embedded newlines in this string are safe because we evaluate each
530     # argument in the for-loop below and append them to the CFLAGS with a space
531     # as the separator instead
532     pac_common_strict_flags="
533         -Wall
534         -Wextra
535         -Wno-missing-field-initializers
536         -Wstrict-prototypes
537         -Wmissing-prototypes
538         -DGCC_WALL
539         -Wno-unused-parameter
540         -Wno-unused-label
541         -Wshadow
542         -Wmissing-declarations
543         -Wno-long-long
544         -Wundef
545         -Wno-endif-labels
546         -Wpointer-arith
547         -Wbad-function-cast
548         -Wwrite-strings
549         -Wno-sign-compare
550         -Wold-style-definition
551         -Wno-multichar
552         -Wno-deprecated-declarations
553         -Wpacked
554         -Wnested-externs
555         -Winvalid-pch
556         -Wno-pointer-sign
557         -Wvariadic-macros
558         -Wno-format-zero-length
559         -Wtype-limits
560         -Werror-implicit-function-declaration
561         -Wstack-usage=262144
562     "
563
564     enable_c89=no
565     enable_c99=yes
566     enable_posix=2001
567     enable_opt=yes
568     flags="`echo $1 | sed -e 's/:/ /g' -e 's/,/ /g'`"
569     for flag in ${flags}; do
570         case "$flag" in
571              c89)
572                 enable_strict_done="yes"
573                 enable_c89=yes
574                 enable_c99=no
575                 ;;
576              c99)
577                 enable_strict_done="yes"
578                 enable_c89=no
579                 enable_c99=yes
580                 ;;
581              posix1995)
582                 enable_strict_done="yes"
583                 enable_posix=1995
584                 ;;
585              posix|posix2001)
586                 enable_strict_done="yes"
587                 enable_posix=2001
588                 ;;
589              posix2008)
590                 enable_strict_done="yes"
591                 enable_posix=2008
592                 ;;
593              noposix)
594                 enable_strict_done="yes"
595                 enable_posix=no
596                 ;;
597              opt)
598                 enable_strict_done="yes"
599                 enable_opt=yes
600                 ;;
601              noopt)
602                 enable_strict_done="yes"
603                 enable_opt=no
604                 ;;
605              all|yes)
606                 enable_strict_done="yes"
607                 enable_c99=yes
608                 enable_posix=2001
609                 enable_opt=yes
610                 ;;
611              no)
612                 # Accept and ignore this value
613                 :
614                 ;;
615              *)
616                 if test -n "$flag" ; then
617                    AC_MSG_WARN([Unrecognized value for enable-strict:$flag])
618                 fi
619                 ;;
620         esac
621     done
622
623     pac_cc_strict_flags=""
624     if test "${enable_strict_done}" = "yes" ; then
625        if test "${enable_opt}" = "yes" ; then
626           pac_cc_strict_flags="-O2"
627        fi
628        pac_cc_strict_flags="$pac_cc_strict_flags $pac_common_strict_flags"
629        # We only allow one of strict-C99 or strict-C89 to be
630        # enabled. If C99 is enabled, we automatically disable C89.
631        if test "${enable_c99}" = "yes" ; then
632           PAC_APPEND_FLAG([-std=c99],[pac_cc_strict_flags])
633           # Use -D_STDC_C99= for Solaris compilers. See
634           # http://lists.gnu.org/archive/html/autoconf/2010-12/msg00059.html
635           # for discussion on why not to use -xc99
636           PAC_APPEND_FLAG([-D_STDC_C99=],[pac_cc_strict_flags])
637        elif test "${enable_c89}" = "yes" ; then
638           PAC_APPEND_FLAG([-std=c89],[pac_cc_strict_flags])
639           PAC_APPEND_FLAG([-Wdeclaration-after-statement],[pac_cc_strict_flags])
640        fi
641        # POSIX 2001 should be used with C99. But the default standard for some
642        # compilers are not C99. We must test the support of POSIX 2001 after
643        # testing C99.
644        case "$enable_posix" in
645             no)   : ;;
646             1995) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=199506L],[pac_cc_strict_flags]) ;;
647             2001) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=200112L],[pac_cc_strict_flags]) ;;
648             2008) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=200809L],[pac_cc_strict_flags]) ;;
649             *)    AC_MSG_ERROR([internal error, unexpected POSIX version: '$enable_posix']) ;;
650        esac
651        if test "$enable_posix" != "no" ; then
652            AS_CASE([$host],[*-*-darwin*], [PAC_APPEND_FLAG([-D_DARWIN_C_SOURCE],[pac_cc_strict_flags])])
653        fi
654     fi
655
656     # See if the above options work with the compiler
657     accepted_flags=""
658     for flag in $pac_cc_strict_flags ; do
659         PAC_PUSH_FLAG([CFLAGS])
660         CFLAGS="$CFLAGS $accepted_flags"
661         PAC_C_CHECK_COMPILER_OPTION([$flag],[accepted_flags="$accepted_flags $flag"],)
662         PAC_POP_FLAG([CFLAGS])
663     done
664     pac_cc_strict_flags=$accepted_flags
665 fi
666 ])
667
668 dnl/*D
669 dnl PAC_ARG_STRICT - Add --enable-strict to configure.  
670 dnl
671 dnl Synopsis:
672 dnl PAC_ARG_STRICT
673 dnl 
674 dnl Output effects:
675 dnl Adds '--enable-strict' to the command line.
676 dnl
677 dnl D*/
678 AC_DEFUN([PAC_ARG_STRICT],[
679 AC_ARG_ENABLE(strict,
680         AC_HELP_STRING([--enable-strict], [Turn on strict compilation testing]))
681 PAC_CC_STRICT($enable_strict)
682 CFLAGS="$CFLAGS $pac_cc_strict_flags"
683 export CFLAGS
684 ])
685
686 dnl Return the integer structure alignment in pac_cv_c_max_integer_align
687 dnl Possible values include
688 dnl     packed
689 dnl     two
690 dnl     four
691 dnl     eight
692 dnl
693 dnl In addition, a "Could not determine alignment" and a "error!"
694 dnl return is possible.  
695 AC_DEFUN([PAC_C_MAX_INTEGER_ALIGN],[
696 AC_CACHE_CHECK([for max C struct integer alignment],
697 pac_cv_c_max_integer_align,[
698 AC_TRY_RUN([
699 #include <stdio.h>
700 #define DBG(a,b,c)
701 int main( int argc, char *argv[] )
702 {
703     FILE *cf;
704     int is_packed  = 1;
705     int is_two     = 1;
706     int is_four    = 1;
707     int is_eight   = 1;
708     struct { char a; int b; } char_int;
709     struct { char a; short b; } char_short;
710     struct { char a; long b; } char_long;
711     struct { char a; int b; char c; } char_int_char;
712     struct { char a; short b; char c; } char_short_char;
713 #ifdef HAVE_LONG_LONG_INT
714     struct { long long int a; char b; } lli_c;
715     struct { char a; long long int b; } c_lli;
716 #endif
717     int size, extent, extent2;
718
719     /* assume max integer alignment isn't 8 if we don't have
720      * an eight-byte value :)
721      */
722 #ifdef HAVE_LONG_LONG_INT
723     if (sizeof(int) < 8 && sizeof(long) < 8 && sizeof(long long int) < 8)
724         is_eight = 0;
725 #else
726     if (sizeof(int) < 8 && sizeof(long) < 8) is_eight = 0;
727 #endif
728
729     size = sizeof(char) + sizeof(int);
730     extent = sizeof(char_int);
731     if (size != extent) is_packed = 0;
732     if ( (extent % 2) != 0) is_two = 0;
733     if ( (extent % 4) != 0) is_four = 0;
734     if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
735     DBG("char_int",size,extent);
736
737     size = sizeof(char) + sizeof(short);
738     extent = sizeof(char_short);
739     if (size != extent) is_packed = 0;
740     if ( (extent % 2) != 0) is_two = 0;
741     if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
742     if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
743     DBG("char_short",size,extent);
744
745     size = sizeof(char) + sizeof(long);
746     extent = sizeof(char_long);
747     if (size != extent) is_packed = 0;
748     if ( (extent % 2) != 0) is_two = 0;
749     if ( (extent % 4) != 0) is_four = 0;
750     if (sizeof(long) == 8 && (extent % 8) != 0) is_eight = 0;
751     DBG("char_long",size,extent);
752
753 #ifdef HAVE_LONG_LONG_INT
754     size = sizeof(char) + sizeof(long long int);
755     extent = sizeof(lli_c);
756     extent2 = sizeof(c_lli);
757     if (size != extent) is_packed = 0;
758     if ( (extent % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
759     if ( (extent % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
760     if (sizeof(long long int) >= 8 && (extent % 8) != 0 && (extent2 % 8) != 0)
761         is_eight = 0;
762 #endif
763
764     size = sizeof(char) + sizeof(int) + sizeof(char);
765     extent = sizeof(char_int_char);
766     if (size != extent) is_packed = 0;
767     if ( (extent % 2) != 0) is_two = 0;
768     if ( (extent % 4) != 0) is_four = 0;
769     if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
770     DBG("char_int_char",size,extent);
771
772     size = sizeof(char) + sizeof(short) + sizeof(char);
773     extent = sizeof(char_short_char);
774     if (size != extent) is_packed = 0;
775     if ( (extent % 2) != 0) is_two = 0;
776     if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
777     if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
778     DBG("char_short_char",size,extent);
779
780     /* If aligned mod 8, it will be aligned mod 4 */
781     if (is_eight) { is_four = 0; is_two = 0; }
782
783     if (is_four) is_two = 0;
784
785     /* Tabulate the results */
786     cf = fopen( "ctest.out", "w" );
787     if (is_packed + is_two + is_four + is_eight == 0) {
788         fprintf( cf, "Could not determine alignment\n" );
789     }
790     else {
791         if (is_packed + is_two + is_four + is_eight != 1) {
792             fprintf( cf, "error!\n" );
793         }
794         else {
795             if (is_packed) fprintf( cf, "packed\n" );
796             if (is_two) fprintf( cf, "two\n" );
797             if (is_four) fprintf( cf, "four\n" );
798             if (is_eight) fprintf( cf, "eight\n" );
799         }
800     }
801     fclose( cf );
802     return 0;
803 }],
804 pac_cv_c_max_integer_align=`cat ctest.out`,
805 pac_cv_c_max_integer_align="unknown",
806 pac_cv_c_max_integer_align="$CROSS_ALIGN_STRUCT_INT")
807 rm -f ctest.out
808 ])
809 if test -z "$pac_cv_c_max_integer_align" ; then
810     pac_cv_c_max_integer_align="unknown"
811 fi
812 ])
813
814 dnl Return the floating point structure alignment in
815 dnl pac_cv_c_max_fp_align.
816 dnl
817 dnl Possible values include:
818 dnl     packed
819 dnl     two
820 dnl     four
821 dnl     eight
822 dnl     sixteen
823 dnl
824 dnl In addition, a "Could not determine alignment" and a "error!"
825 dnl return is possible.  
826 AC_DEFUN([PAC_C_MAX_FP_ALIGN],[
827 AC_CACHE_CHECK([for max C struct floating point alignment],
828 pac_cv_c_max_fp_align,[
829 AC_TRY_RUN([
830 #include <stdio.h>
831 #define DBG(a,b,c)
832 int main( int argc, char *argv[] )
833 {
834     FILE *cf;
835     int is_packed  = 1;
836     int is_two     = 1;
837     int is_four    = 1;
838     int is_eight   = 1;
839     int is_sixteen = 1;
840     struct { char a; float b; } char_float;
841     struct { float b; char a; } float_char;
842     struct { char a; double b; } char_double;
843     struct { double b; char a; } double_char;
844 #ifdef HAVE_LONG_DOUBLE
845     struct { char a; long double b; } char_long_double;
846     struct { long double b; char a; } long_double_char;
847     struct { long double a; int b; char c; } long_double_int_char;
848 #endif
849     int size, extent1, extent2;
850
851     size = sizeof(char) + sizeof(float);
852     extent1 = sizeof(char_float);
853     extent2 = sizeof(float_char);
854     if (size != extent1) is_packed = 0;
855     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
856     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
857     if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
858         is_eight = 0;
859     DBG("char_float",size,extent1);
860
861     size = sizeof(char) + sizeof(double);
862     extent1 = sizeof(char_double);
863     extent2 = sizeof(double_char);
864     if (size != extent1) is_packed = 0;
865     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
866     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
867     if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
868         is_eight = 0;
869     DBG("char_double",size,extent1);
870
871 #ifdef HAVE_LONG_DOUBLE
872     size = sizeof(char) + sizeof(long double);
873     extent1 = sizeof(char_long_double);
874     extent2 = sizeof(long_double_char);
875     if (size != extent1) is_packed = 0;
876     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
877     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
878     if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
879         is_eight = 0;
880     if (sizeof(long double) > 8 && (extent1 % 16) != 0
881         && (extent2 % 16) != 0) is_sixteen = 0;
882     DBG("char_long-double",size,extent1);
883
884     extent1 = sizeof(long_double_int_char);
885     if ( (extent1 % 2) != 0) is_two = 0;
886     if ( (extent1 % 4) != 0) is_four = 0;
887     if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
888     if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
889 #else
890     is_sixteen = 0;
891 #endif
892
893     if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
894
895     if (is_eight) { is_four = 0; is_two = 0; }
896
897     if (is_four) is_two = 0;
898
899     /* Tabulate the results */
900     cf = fopen( "ctest.out", "w" );
901     if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
902         fprintf( cf, "Could not determine alignment\n" );
903     }
904     else {
905         if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
906             fprintf( cf, "error!\n" );
907         }
908         else {
909             if (is_packed) fprintf( cf, "packed\n" );
910             if (is_two) fprintf( cf, "two\n" );
911             if (is_four) fprintf( cf, "four\n" );
912             if (is_eight) fprintf( cf, "eight\n" );
913             if (is_sixteen) fprintf( cf, "sixteen\n" );
914         }
915     }
916     fclose( cf );
917     return 0;
918 }],
919 pac_cv_c_max_fp_align=`cat ctest.out`,
920 pac_cv_c_max_fp_align="unknown",
921 pac_cv_c_max_fp_align="$CROSS_ALIGN_STRUCT_FP")
922 rm -f ctest.out
923 ])
924 if test -z "$pac_cv_c_max_fp_align" ; then
925     pac_cv_c_max_fp_align="unknown"
926 fi
927 ])
928
929 dnl Return the floating point structure alignment in
930 dnl pac_cv_c_max_double_fp_align.
931 dnl
932 dnl Possible values include:
933 dnl     packed
934 dnl     two
935 dnl     four
936 dnl     eight
937 dnl
938 dnl In addition, a "Could not determine alignment" and a "error!"
939 dnl return is possible.  
940 AC_DEFUN([PAC_C_MAX_DOUBLE_FP_ALIGN],[
941 AC_CACHE_CHECK([for max C struct alignment of structs with doubles],
942 pac_cv_c_max_double_fp_align,[
943 AC_TRY_RUN([
944 #include <stdio.h>
945 #define DBG(a,b,c)
946 int main( int argc, char *argv[] )
947 {
948     FILE *cf;
949     int is_packed  = 1;
950     int is_two     = 1;
951     int is_four    = 1;
952     int is_eight   = 1;
953     struct { char a; float b; } char_float;
954     struct { float b; char a; } float_char;
955     struct { char a; double b; } char_double;
956     struct { double b; char a; } double_char;
957     int size, extent1, extent2;
958
959     size = sizeof(char) + sizeof(float);
960     extent1 = sizeof(char_float);
961     extent2 = sizeof(float_char);
962     if (size != extent1) is_packed = 0;
963     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
964     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
965     if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
966         is_eight = 0;
967     DBG("char_float",size,extent1);
968
969     size = sizeof(char) + sizeof(double);
970     extent1 = sizeof(char_double);
971     extent2 = sizeof(double_char);
972     if (size != extent1) is_packed = 0;
973     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
974     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
975     if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
976         is_eight = 0;
977     DBG("char_double",size,extent1);
978
979     if (is_eight) { is_four = 0; is_two = 0; }
980
981     if (is_four) is_two = 0;
982
983     /* Tabulate the results */
984     cf = fopen( "ctest.out", "w" );
985     if (is_packed + is_two + is_four + is_eight == 0) {
986         fprintf( cf, "Could not determine alignment\n" );
987     }
988     else {
989         if (is_packed + is_two + is_four + is_eight != 1) {
990             fprintf( cf, "error!\n" );
991         }
992         else {
993             if (is_packed) fprintf( cf, "packed\n" );
994             if (is_two) fprintf( cf, "two\n" );
995             if (is_four) fprintf( cf, "four\n" );
996             if (is_eight) fprintf( cf, "eight\n" );
997         }
998     }
999     fclose( cf );
1000     return 0;
1001 }],
1002 pac_cv_c_max_double_fp_align=`cat ctest.out`,
1003 pac_cv_c_max_double_fp_align="unknown",
1004 pac_cv_c_max_double_fp_align="$CROSS_ALIGN_STRUCT_DOUBLE_FP")
1005 rm -f ctest.out
1006 ])
1007 if test -z "$pac_cv_c_max_double_fp_align" ; then
1008     pac_cv_c_max_double_fp_align="unknown"
1009 fi
1010 ])
1011 AC_DEFUN([PAC_C_MAX_LONGDOUBLE_FP_ALIGN],[
1012 AC_CACHE_CHECK([for max C struct floating point alignment with long doubles],
1013 pac_cv_c_max_longdouble_fp_align,[
1014 AC_TRY_RUN([
1015 #include <stdio.h>
1016 #define DBG(a,b,c)
1017 int main( int argc, char *argv[] )
1018 {
1019     FILE *cf;
1020     int is_packed  = 1;
1021     int is_two     = 1;
1022     int is_four    = 1;
1023     int is_eight   = 1;
1024     int is_sixteen = 1;
1025     struct { char a; long double b; } char_long_double;
1026     struct { long double b; char a; } long_double_char;
1027     struct { long double a; int b; char c; } long_double_int_char;
1028     int size, extent1, extent2;
1029
1030     size = sizeof(char) + sizeof(long double);
1031     extent1 = sizeof(char_long_double);
1032     extent2 = sizeof(long_double_char);
1033     if (size != extent1) is_packed = 0;
1034     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1035     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1036     if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1037         is_eight = 0;
1038     if (sizeof(long double) > 8 && (extent1 % 16) != 0
1039         && (extent2 % 16) != 0) is_sixteen = 0;
1040     DBG("char_long-double",size,extent1);
1041
1042     extent1 = sizeof(long_double_int_char);
1043     if ( (extent1 % 2) != 0) is_two = 0;
1044     if ( (extent1 % 4) != 0) is_four = 0;
1045     if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
1046     if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
1047
1048     if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
1049
1050     if (is_eight) { is_four = 0; is_two = 0; }
1051
1052     if (is_four) is_two = 0;
1053
1054     /* Tabulate the results */
1055     cf = fopen( "ctest.out", "w" );
1056     if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
1057         fprintf( cf, "Could not determine alignment\n" );
1058     }
1059     else {
1060         if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
1061             fprintf( cf, "error!\n" );
1062         }
1063         else {
1064             if (is_packed) fprintf( cf, "packed\n" );
1065             if (is_two) fprintf( cf, "two\n" );
1066             if (is_four) fprintf( cf, "four\n" );
1067             if (is_eight) fprintf( cf, "eight\n" );
1068             if (is_sixteen) fprintf( cf, "sixteen\n" );
1069         }
1070     }
1071     fclose( cf );
1072     return 0;
1073 }],
1074 pac_cv_c_max_longdouble_fp_align=`cat ctest.out`,
1075 pac_cv_c_max_longdouble_fp_align="unknown",
1076 pac_cv_c_max_longdouble_fp_align="$CROSS_ALIGN_STRUCT_LONGDOUBLE_FP")
1077 rm -f ctest.out
1078 ])
1079 if test -z "$pac_cv_c_max_longdouble_fp_align" ; then
1080     pac_cv_c_max_longdouble_fp_align="unknown"
1081 fi
1082 ])
1083
1084 dnl Other tests assume that there is potentially a maximum alignment
1085 dnl and that if there is no maximum alignment, or a type is smaller than
1086 dnl that value, then we align on the size of the value, with the exception
1087 dnl of the "position-based alignment" rules we test for separately.
1088 dnl
1089 dnl It turns out that these assumptions have fallen short in at least one
1090 dnl case, on MacBook Pros, where doubles are aligned on 4-byte boundaries
1091 dnl even when long doubles are aligned on 16-byte boundaries. So this test
1092 dnl is here specifically to handle this case.
1093 dnl
1094 dnl Puts result in pac_cv_c_double_alignment_exception.
1095 dnl
1096 dnl Possible values currently include no and four.
1097 dnl
1098 AC_DEFUN([PAC_C_DOUBLE_ALIGNMENT_EXCEPTION],[
1099 AC_CACHE_CHECK([if double alignment breaks rules, find actual alignment],
1100 pac_cv_c_double_alignment_exception,[
1101 AC_TRY_RUN([
1102 #include <stdio.h>
1103 #define DBG(a,b,c)
1104 int main( int argc, char *argv[] )
1105 {
1106     FILE *cf;
1107     struct { char a; double b; } char_double;
1108     struct { double b; char a; } double_char;
1109     int extent1, extent2, align_4 = 0;
1110
1111     extent1 = sizeof(char_double);
1112     extent2 = sizeof(double_char);
1113
1114     /* we're interested in the largest value, will let separate test
1115      * deal with position-based issues.
1116      */
1117     if (extent1 < extent2) extent1 = extent2;
1118     if ((sizeof(double) == 8) && (extent1 % 8) != 0) {
1119        if (extent1 % 4 == 0) {
1120 #ifdef HAVE_MAX_FP_ALIGNMENT
1121           if (HAVE_MAX_FP_ALIGNMENT >= 8) align_4 = 1;
1122 #else
1123           align_4 = 1;
1124 #endif
1125        }
1126     }
1127
1128     cf = fopen( "ctest.out", "w" );
1129
1130     if (align_4) fprintf( cf, "four\n" );
1131     else fprintf( cf, "no\n" );
1132
1133     fclose( cf );
1134     return 0;
1135 }],
1136 pac_cv_c_double_alignment_exception=`cat ctest.out`,
1137 pac_cv_c_double_alignment_exception="unknown",
1138 pac_cv_c_double_alignment_exception="$CROSS_ALIGN_DOUBLE_EXCEPTION")
1139 rm -f ctest.out
1140 ])
1141 if test -z "$pac_cv_c_double_alignment_exception" ; then
1142     pac_cv_c_double_alignment_exception="unknown"
1143 fi
1144 ])
1145
1146 dnl Test for odd struct alignment rule that only applies max.
1147 dnl padding when double value is at front of type.
1148 dnl Puts result in pac_cv_c_double_pos_align.
1149 dnl
1150 dnl Search for "Power alignment mode" for more details.
1151 dnl
1152 dnl Possible values include yes, no, and unknown.
1153 dnl
1154 AC_DEFUN([PAC_C_DOUBLE_POS_ALIGN],[
1155 AC_CACHE_CHECK([if alignment of structs with doubles is based on position],
1156 pac_cv_c_double_pos_align,[
1157 AC_TRY_RUN([
1158 #include <stdio.h>
1159 #define DBG(a,b,c)
1160 int main( int argc, char *argv[] )
1161 {
1162     FILE *cf;
1163     int padding_varies_by_pos = 0;
1164     struct { char a; double b; } char_double;
1165     struct { double b; char a; } double_char;
1166     int extent1, extent2;
1167
1168     extent1 = sizeof(char_double);
1169     extent2 = sizeof(double_char);
1170     if (extent1 != extent2) padding_varies_by_pos = 1;
1171
1172     cf = fopen( "ctest.out", "w" );
1173     if (padding_varies_by_pos) fprintf( cf, "yes\n" );
1174     else fprintf( cf, "no\n" );
1175
1176     fclose( cf );
1177     return 0;
1178 }],
1179 pac_cv_c_double_pos_align=`cat ctest.out`,
1180 pac_cv_c_double_pos_align="unknown",
1181 pac_cv_c_double_pos_align="$CROSS_ALIGN_DOUBLE_POS")
1182 rm -f ctest.out
1183 ])
1184 if test -z "$pac_cv_c_double_pos_align" ; then
1185     pac_cv_c_double_pos_align="unknown"
1186 fi
1187 ])
1188
1189 dnl Test for odd struct alignment rule that only applies max.
1190 dnl padding when long long int value is at front of type.
1191 dnl Puts result in pac_cv_c_llint_pos_align.
1192 dnl
1193 dnl Search for "Power alignment mode" for more details.
1194 dnl
1195 dnl Possible values include yes, no, and unknown.
1196 dnl
1197 AC_DEFUN([PAC_C_LLINT_POS_ALIGN],[
1198 AC_CACHE_CHECK([if alignment of structs with long long ints is based on position],
1199 pac_cv_c_llint_pos_align,[
1200 AC_TRY_RUN([
1201 #include <stdio.h>
1202 #define DBG(a,b,c)
1203 int main( int argc, char *argv[] )
1204 {
1205     FILE *cf;
1206     int padding_varies_by_pos = 0;
1207 #ifdef HAVE_LONG_LONG_INT
1208     struct { char a; long long int b; } char_llint;
1209     struct { long long int b; char a; } llint_char;
1210     int extent1, extent2;
1211
1212     extent1 = sizeof(char_llint);
1213     extent2 = sizeof(llint_char);
1214     if (extent1 != extent2) padding_varies_by_pos = 1;
1215 #endif
1216
1217     cf = fopen( "ctest.out", "w" );
1218     if (padding_varies_by_pos) fprintf( cf, "yes\n" );
1219     else fprintf( cf, "no\n" );
1220
1221     fclose( cf );
1222     return 0;
1223 }],
1224 pac_cv_c_llint_pos_align=`cat ctest.out`,
1225 pac_cv_c_llint_pos_align="unknown",
1226 pac_cv_c_llint_pos_align="$CROSS_ALIGN_LLINT_POS")
1227 rm -f ctest.out
1228 ])
1229 if test -z "$pac_cv_c_llint_pos_align" ; then
1230     pac_cv_c_llint_pos_align="unknown"
1231 fi
1232 ])
1233
1234 dnl/*D
1235 dnl PAC_FUNC_NEEDS_DECL - Set NEEDS_<funcname>_DECL if a declaration is needed
1236 dnl
1237 dnl Synopsis:
1238 dnl PAC_FUNC_NEEDS_DECL(headerfiles,funcname)
1239 dnl
1240 dnl Output Effect:
1241 dnl Sets 'NEEDS_<funcname>_DECL' if 'funcname' is not declared by the 
1242 dnl headerfiles.
1243 dnl
1244 dnl Approach:
1245 dnl Attempt to assign library function to function pointer.  If the function
1246 dnl is not declared in a header, this will fail.  Use a non-static global so
1247 dnl the compiler does not warn about an unused variable.
1248 dnl
1249 dnl Simply calling the function is not enough because C89 compilers allow
1250 dnl calls to implicitly-defined functions.  Re-declaring a library function
1251 dnl with an incompatible prototype is also not sufficient because some
1252 dnl compilers (notably clang-3.2) only produce a warning in this case.
1253 dnl
1254 dnl D*/
1255 AC_DEFUN([PAC_FUNC_NEEDS_DECL],[
1256 AC_CACHE_CHECK([whether $2 needs a declaration],
1257 pac_cv_func_decl_$2,[
1258 AC_TRY_COMPILE([$1
1259 void (*fptr)(void) = (void(*)(void))$2;],[],
1260 pac_cv_func_decl_$2=no,pac_cv_func_decl_$2=yes)])
1261 if test "$pac_cv_func_decl_$2" = "yes" ; then
1262 changequote(<<,>>)dnl
1263 define(<<PAC_FUNC_NAME>>, translit(NEEDS_$2_DECL, [a-z *], [A-Z__]))dnl
1264 changequote([, ])dnl
1265     AC_DEFINE_UNQUOTED(PAC_FUNC_NAME,1,[Define if $2 needs a declaration])
1266 undefine([PAC_FUNC_NAME])
1267 fi
1268 ])
1269
1270 dnl PAC_C_GNU_ATTRIBUTE - See if the GCC __attribute__ specifier is allow.
1271 dnl Use the following
1272 dnl #ifndef HAVE_GCC_ATTRIBUTE
1273 dnl #define __attribute__(a)
1274 dnl #endif
1275 dnl If *not*, define __attribute__(a) as null
1276 dnl
1277 dnl We start by requiring Gcc.  Some other compilers accept __attribute__
1278 dnl but generate warning messages, or have different interpretations 
1279 dnl (which seems to make __attribute__ just as bad as #pragma) 
1280 dnl For example, the Intel icc compiler accepts __attribute__ and
1281 dnl __attribute__((pure)) but generates warnings for __attribute__((format...))
1282 dnl
1283 AC_DEFUN([PAC_C_GNU_ATTRIBUTE],[
1284 AC_REQUIRE([AC_PROG_CC_GNU])
1285 if test "$ac_cv_prog_gcc" = "yes" ; then
1286     AC_CACHE_CHECK([whether __attribute__ allowed],
1287 pac_cv_gnu_attr_pure,[
1288 AC_TRY_COMPILE([int foo(int) __attribute__ ((pure));],[int a;],
1289 pac_cv_gnu_attr_pure=yes,pac_cv_gnu_attr_pure=no)])
1290 AC_CACHE_CHECK([whether __attribute__((format)) allowed],
1291 pac_cv_gnu_attr_format,[
1292 AC_TRY_COMPILE([int foo(char *,...) __attribute__ ((format(printf,1,2)));],[int a;],
1293 pac_cv_gnu_attr_format=yes,pac_cv_gnu_attr_format=no)])
1294     if test "$pac_cv_gnu_attr_pure" = "yes" -a "$pac_cv_gnu_attr_format" = "yes" ; then
1295         AC_DEFINE(HAVE_GCC_ATTRIBUTE,1,[Define if GNU __attribute__ is supported])
1296     fi
1297 fi
1298 ])
1299 dnl
1300 dnl Check for a broken install (fails to preserve file modification times,
1301 dnl thus breaking libraries.
1302 dnl
1303 dnl Create a library, install it, and then try to link against it.
1304 AC_DEFUN([PAC_PROG_INSTALL_BREAKS_LIBS],[
1305 AC_CACHE_CHECK([whether install breaks libraries],
1306 ac_cv_prog_install_breaks_libs,[
1307 AC_REQUIRE([AC_PROG_RANLIB])
1308 AC_REQUIRE([AC_PROG_INSTALL])
1309 AC_REQUIRE([AC_PROG_CC])
1310 ac_cv_prog_install_breaks_libs=yes
1311
1312 AC_COMPILE_IFELSE([
1313     AC_LANG_SOURCE([ int foo(int); int foo(int a){return a;} ])
1314 ],[
1315     if ${AR-ar} ${AR_FLAGS-cr} libconftest.a conftest.$OBJEXT >/dev/null 2>&1 ; then
1316         if ${RANLIB-:} libconftest.a >/dev/null 2>&1 ; then
1317             # Anything less than sleep 10, and Mac OS/X (Darwin) 
1318             # will claim that install works because ranlib won't complain
1319             sleep 10
1320             libinstall="$INSTALL_DATA"
1321             eval "libinstall=\"$libinstall\""
1322             if ${libinstall} libconftest.a libconftest1.a >/dev/null 2>&1 ; then
1323                 saved_LIBS="$LIBS"
1324                 LIBS="libconftest1.a"
1325                 AC_LINK_IFELSE([
1326                     AC_LANG_SOURCE([
1327 extern int foo(int);
1328 int main(int argc, char **argv){ return foo(0); }
1329                     ])
1330                 ],[
1331                     # Success!  Install works
1332                     ac_cv_prog_install_breaks_libs=no
1333                 ],[
1334                     # Failure!  Does install -p work?        
1335                     rm -f libconftest1.a
1336                     if ${libinstall} -p libconftest.a libconftest1.a >/dev/null 2>&1 ; then
1337                         AC_LINK_IFELSE([],[
1338                             # Success!  Install works
1339                             ac_cv_prog_install_breaks_libs="no, with -p"
1340                         ])
1341                     fi
1342                 ])
1343                 LIBS="$saved_LIBS"
1344             fi
1345         fi
1346     fi
1347 ])
1348 rm -f libconftest*.a
1349 ]) dnl Endof ac_cache_check
1350
1351 if test -z "$RANLIB_AFTER_INSTALL" ; then
1352     RANLIB_AFTER_INSTALL=no
1353 fi
1354 case "$ac_cv_prog_install_breaks_libs" in
1355     yes)
1356         RANLIB_AFTER_INSTALL=yes
1357     ;;
1358     "no, with -p")
1359         INSTALL_DATA="$INSTALL_DATA -p"
1360     ;;
1361     *)
1362     # Do nothing
1363     :
1364     ;;
1365 esac
1366 AC_SUBST(RANLIB_AFTER_INSTALL)
1367 ])
1368
1369 #
1370 # determine if the compiler defines a symbol containing the function name
1371 #
1372 # These tests check not only that the compiler defines some symbol, such
1373 # as __FUNCTION__, but that the symbol correctly names the function.
1374 #
1375 # Defines 
1376 #   HAVE__FUNC__      (if __func__ defined)
1377 #   HAVE_CAP__FUNC__  (if __FUNC__ defined)
1378 #   HAVE__FUNCTION__  (if __FUNCTION__ defined)
1379 #
1380 AC_DEFUN([PAC_CC_FUNCTION_NAME_SYMBOL],[
1381 AC_CACHE_CHECK([whether the compiler defines __func__],
1382 pac_cv_have__func__,[
1383 tmp_am_cross=no
1384 AC_RUN_IFELSE([
1385 AC_LANG_SOURCE([
1386 #include <string.h>
1387 int foo(void);
1388 int foo(void)
1389 {
1390     return (strcmp(__func__, "foo") == 0);
1391 }
1392 int main(int argc, char ** argv)
1393 {
1394     return (foo() ? 0 : 1);
1395 }
1396 ])
1397 ], pac_cv_have__func__=yes, pac_cv_have__func__=no,tmp_am_cross=yes)
1398 if test "$tmp_am_cross" = yes ; then
1399     AC_LINK_IFELSE([
1400     AC_LANG_SOURCE([
1401 #include <string.h>
1402 int foo(void);
1403 int foo(void)
1404 {
1405     return (strcmp(__func__, "foo") == 0);
1406 }
1407 int main(int argc, char ** argv)
1408 {
1409     return (foo() ? 0 : 1);
1410 }
1411     ])
1412 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1413 fi
1414 ])
1415
1416 if test "$pac_cv_have__func__" = "yes" ; then
1417     AC_DEFINE(HAVE__FUNC__,,[define if the compiler defines __func__])
1418 fi
1419
1420 AC_CACHE_CHECK([whether the compiler defines __FUNC__],
1421 pac_cv_have_cap__func__,[
1422 tmp_am_cross=no
1423 AC_RUN_IFELSE([
1424 AC_LANG_SOURCE([
1425 #include <string.h>
1426 int foo(void);
1427 int foo(void)
1428 {
1429     return (strcmp(__FUNC__, "foo") == 0);
1430 }
1431 int main(int argc, char ** argv)
1432 {
1433     return (foo() ? 0 : 1);
1434 }
1435 ])
1436 ], pac_cv_have_cap__func__=yes, pac_cv_have_cap__func__=no,tmp_am_cross=yes)
1437 if test "$tmp_am_cross" = yes ; then
1438     AC_LINK_IFELSE([
1439     AC_LANG_SOURCE([
1440 #include <string.h>
1441 int foo(void);
1442 int foo(void)
1443 {
1444     return (strcmp(__FUNC__, "foo") == 0);
1445 }
1446 int main(int argc, char ** argv)
1447 {
1448     return (foo() ? 0 : 1);
1449 }
1450     ])
1451 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1452 fi
1453 ])
1454
1455 if test "$pac_cv_have_cap__func__" = "yes" ; then
1456     AC_DEFINE(HAVE_CAP__FUNC__,,[define if the compiler defines __FUNC__])
1457 fi
1458
1459 AC_CACHE_CHECK([whether the compiler sets __FUNCTION__],
1460 pac_cv_have__function__,[
1461 tmp_am_cross=no
1462 AC_RUN_IFELSE([
1463 AC_LANG_SOURCE([
1464 #include <string.h>
1465 int foo(void);
1466 int foo(void)
1467 {
1468     return (strcmp(__FUNCTION__, "foo") == 0);
1469 }
1470 int main(int argc, char ** argv)
1471 {
1472     return (foo() ? 0 : 1);
1473 }
1474 ])
1475 ], pac_cv_have__function__=yes, pac_cv_have__function__=no,tmp_am_cross=yes)
1476 if test "$tmp_am_cross" = yes ; then
1477     AC_LINK_IFELSE([
1478     AC_LANG_SOURCE([
1479 #include <string.h>
1480 int foo(void);
1481 int foo(void)
1482 {
1483     return (strcmp(__FUNCTION__, "foo") == 0);
1484 }
1485 int main(int argc, char ** argv)
1486 {
1487     return (foo() ? 0 : 1);
1488 }
1489     ])
1490 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1491 fi
1492 ])
1493
1494 if test "$pac_cv_have__function__" = "yes" ; then
1495     AC_DEFINE(HAVE__FUNCTION__,,[define if the compiler defines __FUNCTION__])
1496 fi
1497
1498 ])
1499
1500
1501 dnl Check structure alignment
1502 AC_DEFUN([PAC_STRUCT_ALIGNMENT],[
1503         # Initialize alignment checks
1504         is_packed=1
1505         is_two=1
1506         is_four=1
1507         is_eight=1
1508         is_largest=1
1509
1510         # See if long double exists
1511         AC_TRY_COMPILE(,[long double a;],have_long_double=yes,have_long_double=no)
1512
1513         # Get sizes of regular types
1514         AC_CHECK_SIZEOF(char)
1515         AC_CHECK_SIZEOF(int)
1516         AC_CHECK_SIZEOF(short)
1517         AC_CHECK_SIZEOF(long)
1518         AC_CHECK_SIZEOF(float)
1519         AC_CHECK_SIZEOF(double)
1520         AC_CHECK_SIZEOF(long double)
1521
1522         # char_int comparison
1523         AC_CHECK_SIZEOF(char_int, 0, [typedef struct { char a; int b; } char_int; ])
1524         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_int`
1525         extent=$ac_cv_sizeof_char_int
1526         if test "$size" != "$extent" ; then is_packed=0 ; fi
1527         if test "`expr $extent % $ac_cv_sizeof_int`" != "0" ; then is_largest=0 ; fi
1528         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1529         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1530         if test "$ac_cv_sizeof_int" = "8" -a "`expr $extent % 8`" != "0" ; then
1531            is_eight=0
1532         fi
1533
1534         # char_short comparison
1535         AC_CHECK_SIZEOF(char_short, 0, [typedef struct { char a; short b; } char_short; ])
1536         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_short`
1537         extent=$ac_cv_sizeof_char_short
1538         if test "$size" != "$extent" ; then is_packed=0 ; fi
1539         if test "`expr $extent % $ac_cv_sizeof_short`" != "0" ; then is_largest=0 ; fi
1540         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1541         if test "$ac_cv_sizeof_short" = "4" -a "`expr $extent % 4`" != "0" ; then
1542            is_four=0
1543         fi
1544         if test "$ac_cv_sizeof_short" = "8" -a "`expr $extent % 8`" != "0" ; then
1545            is_eight=0
1546         fi
1547
1548         # char_long comparison
1549         AC_CHECK_SIZEOF(char_long, 0, [typedef struct { char a; long b; } char_long; ])
1550         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_long`
1551         extent=$ac_cv_sizeof_char_long
1552         if test "$size" != "$extent" ; then is_packed=0 ; fi
1553         if test "`expr $extent % $ac_cv_sizeof_long`" != "0" ; then is_largest=0 ; fi
1554         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1555         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1556         if test "$ac_cv_sizeof_long" = "8" -a "`expr $extent % 8`" != "0" ; then
1557            is_eight=0
1558         fi
1559
1560         # char_float comparison
1561         AC_CHECK_SIZEOF(char_float, 0, [typedef struct { char a; float b; } char_float; ])
1562         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_float`
1563         extent=$ac_cv_sizeof_char_float
1564         if test "$size" != "$extent" ; then is_packed=0 ; fi
1565         if test "`expr $extent % $ac_cv_sizeof_float`" != "0" ; then is_largest=0 ; fi
1566         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1567         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1568         if test "$ac_cv_sizeof_float" = "8" -a "`expr $extent % 8`" != "0" ; then
1569            is_eight=0
1570         fi
1571
1572         # char_double comparison
1573         AC_CHECK_SIZEOF(char_double, 0, [typedef struct { char a; double b; } char_double; ])
1574         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_double`
1575         extent=$ac_cv_sizeof_char_double
1576         if test "$size" != "$extent" ; then is_packed=0 ; fi
1577         if test "`expr $extent % $ac_cv_sizeof_double`" != "0" ; then is_largest=0 ; fi
1578         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1579         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1580         if test "$ac_cv_sizeof_double" = "8" -a "`expr $extent % 8`" != "0" ; then
1581            is_eight=0
1582         fi
1583
1584         # char_long_double comparison
1585         if test "$have_long_double" = "yes"; then
1586         AC_CHECK_SIZEOF(char_long_double, 0, [
1587                                        typedef struct {
1588                                                char a;
1589                                                long double b;
1590                                        } char_long_double;
1591                                        ])
1592         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_long_double`
1593         extent=$ac_cv_sizeof_char_long_double
1594         if test "$size" != "$extent" ; then is_packed=0 ; fi
1595         if test "`expr $extent % $ac_cv_sizeof_long_double`" != "0" ; then is_largest=0 ; fi
1596         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1597         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1598         if test "$ac_cv_sizeof_long_double" = "8" -a "`expr $extent % 8`" != "0" ; then
1599            is_eight=0
1600         fi
1601         fi
1602
1603         # char_int_char comparison
1604         AC_CHECK_SIZEOF(char_int_char, 0, [
1605                                        typedef struct {
1606                                                char a;
1607                                                int b;
1608                                                char c;
1609                                        } char_int_char;
1610                                        ])
1611         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_int + $ac_cv_sizeof_char`
1612         extent=$ac_cv_sizeof_char_int_char
1613         if test "$size" != "$extent" ; then is_packed=0 ; fi
1614         if test "`expr $extent % $ac_cv_sizeof_int`" != "0" ; then is_largest=0 ; fi
1615         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1616         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1617         if test "$ac_cv_sizeof_int" = "8" -a "`expr $extent % 8`" != "0" ; then
1618            is_eight=0
1619         fi
1620
1621         # char_short_char comparison
1622         AC_CHECK_SIZEOF(char_short_char, 0, [
1623                                        typedef struct {
1624                                                char a;
1625                                                short b;
1626                                                char c;
1627                                        } char_short_char;
1628                                        ])
1629         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_short + $ac_cv_sizeof_char`
1630         extent=$ac_cv_sizeof_char_short_char
1631         if test "$size" != "$extent" ; then is_packed=0 ; fi
1632         if test "`expr $extent % $ac_cv_sizeof_short`" != "0" ; then is_largest=0 ; fi
1633         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1634         if test "$ac_cv_sizeof_short" = "4" -a "`expr $extent % 4`" != "0" ; then
1635            is_four=0
1636         fi
1637         if test "$ac_cv_sizeof_short" = "8" -a "`expr $extent % 8`" != "0" ; then
1638            is_eight=0
1639         fi
1640
1641         # If aligned mod 8, it will be aligned mod 4
1642         if test $is_eight = 1 ; then is_four=0 ; is_two=0 ; fi
1643         if test $is_four = 1 ; then is_two=0 ; fi
1644
1645         # Largest supersedes 8
1646         if test $is_largest = 1 ; then is_eight=0 ; fi
1647
1648         # Find the alignment
1649         if test "`expr $is_packed + $is_largest + $is_two + $is_four + $is_eight`" = "0" ; then
1650            pac_cv_struct_alignment="unknown"
1651         elif test "`expr $is_packed + $is_largest + $is_two + $is_four + $is_eight`" != "1" ; then
1652            pac_cv_struct_alignment="unknown"
1653         elif test $is_packed = 1 ; then
1654            pac_cv_struct_alignment="packed"
1655         elif test $is_largest = 1 ; then
1656            pac_cv_struct_alignment="largest"
1657         elif test $is_two = 1 ; then
1658            pac_cv_struct_alignment="two"
1659         elif test $is_four = 1 ; then
1660            pac_cv_struct_alignment="four"
1661         elif test $is_eight = 1 ; then
1662            pac_cv_struct_alignment="eight"
1663         fi
1664 ])
1665 dnl
1666 dnl PAC_C_MACRO_VA_ARGS
1667 dnl
1668 dnl will AC_DEFINE([HAVE_MACRO_VA_ARGS]) if the compiler supports C99 variable
1669 dnl length argument lists in macros (#define foo(...) bar(__VA_ARGS__))
1670 AC_DEFUN([PAC_C_MACRO_VA_ARGS],[
1671     AC_MSG_CHECKING([for variable argument list macro functionality])
1672     AC_LINK_IFELSE([AC_LANG_PROGRAM([
1673         #include <stdio.h>
1674         #define conftest_va_arg_macro(...) printf(__VA_ARGS__)
1675     ],
1676     [conftest_va_arg_macro("a test %d", 3);])],
1677     [AC_DEFINE([HAVE_MACRO_VA_ARGS],[1],[Define if C99-style variable argument list macro functionality])
1678      AC_MSG_RESULT([yes])],
1679     [AC_MSG_RESULT([no])])
1680 ])dnl
1681
1682 # Will AC_DEFINE([HAVE_BUILTIN_EXPECT]) if the compiler supports __builtin_expect.
1683 AC_DEFUN([PAC_C_BUILTIN_EXPECT],[
1684 AC_MSG_CHECKING([if C compiler supports __builtin_expect])
1685
1686 AC_TRY_LINK(, [
1687     return __builtin_expect(1, 1) ? 1 : 0
1688 ], [
1689     have_builtin_expect=yes
1690     AC_MSG_RESULT([yes])
1691 ], [
1692     have_builtin_expect=no
1693     AC_MSG_RESULT([no])
1694 ])
1695 if test x$have_builtin_expect = xyes ; then
1696     AC_DEFINE([HAVE_BUILTIN_EXPECT], [1], [Define to 1 if the compiler supports __builtin_expect.])
1697 fi
1698 ])