netmod/mxm: Change supported MXM version to 3.1+
[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 "MPIU_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        case "$enable_posix" in
630             no)   : ;;
631             1995) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=199506L],[pac_cc_strict_flags]) ;;
632             2001) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=200112L],[pac_cc_strict_flags]) ;;
633             2008) PAC_APPEND_FLAG([-D_POSIX_C_SOURCE=200809L],[pac_cc_strict_flags]) ;;
634             *)    AC_MSG_ERROR([internal error, unexpected POSIX version: '$enable_posix']) ;;
635        esac
636        # We only allow one of strict-C99 or strict-C89 to be
637        # enabled. If C99 is enabled, we automatically disable C89.
638        if test "${enable_c99}" = "yes" ; then
639           PAC_APPEND_FLAG([-std=c99],[pac_cc_strict_flags])
640           # Use -D_STDC_C99= for Solaris compilers. See
641           # http://lists.gnu.org/archive/html/autoconf/2010-12/msg00059.html
642           # for discussion on why not to use -xc99
643           PAC_APPEND_FLAG([-D_STDC_C99=],[pac_cc_strict_flags])
644        elif test "${enable_c89}" = "yes" ; then
645           PAC_APPEND_FLAG([-std=c89],[pac_cc_strict_flags])
646           PAC_APPEND_FLAG([-Wdeclaration-after-statement],[pac_cc_strict_flags])
647        fi
648     fi
649
650     # See if the above options work with the compiler
651     accepted_flags=""
652     for flag in $pac_cc_strict_flags ; do
653         PAC_PUSH_FLAG([CFLAGS])
654         CFLAGS="$CFLAGS $accepted_flags"
655         PAC_C_CHECK_COMPILER_OPTION([$flag],[accepted_flags="$accepted_flags $flag"],)
656         PAC_POP_FLAG([CFLAGS])
657     done
658     pac_cc_strict_flags=$accepted_flags
659 fi
660 ])
661
662 dnl/*D
663 dnl PAC_ARG_STRICT - Add --enable-strict to configure.  
664 dnl
665 dnl Synopsis:
666 dnl PAC_ARG_STRICT
667 dnl 
668 dnl Output effects:
669 dnl Adds '--enable-strict' to the command line.
670 dnl
671 dnl D*/
672 AC_DEFUN([PAC_ARG_STRICT],[
673 AC_ARG_ENABLE(strict,
674         AC_HELP_STRING([--enable-strict], [Turn on strict compilation testing]))
675 PAC_CC_STRICT($enable_strict)
676 CFLAGS="$CFLAGS $pac_cc_strict_flags"
677 export CFLAGS
678 ])
679
680 dnl Return the integer structure alignment in pac_cv_c_max_integer_align
681 dnl Possible values include
682 dnl     packed
683 dnl     two
684 dnl     four
685 dnl     eight
686 dnl
687 dnl In addition, a "Could not determine alignment" and a "error!"
688 dnl return is possible.  
689 AC_DEFUN([PAC_C_MAX_INTEGER_ALIGN],[
690 AC_CACHE_CHECK([for max C struct integer alignment],
691 pac_cv_c_max_integer_align,[
692 AC_TRY_RUN([
693 #include <stdio.h>
694 #define DBG(a,b,c)
695 int main( int argc, char *argv[] )
696 {
697     FILE *cf;
698     int is_packed  = 1;
699     int is_two     = 1;
700     int is_four    = 1;
701     int is_eight   = 1;
702     struct { char a; int b; } char_int;
703     struct { char a; short b; } char_short;
704     struct { char a; long b; } char_long;
705     struct { char a; int b; char c; } char_int_char;
706     struct { char a; short b; char c; } char_short_char;
707 #ifdef HAVE_LONG_LONG_INT
708     struct { long long int a; char b; } lli_c;
709     struct { char a; long long int b; } c_lli;
710 #endif
711     int size, extent, extent2;
712
713     /* assume max integer alignment isn't 8 if we don't have
714      * an eight-byte value :)
715      */
716 #ifdef HAVE_LONG_LONG_INT
717     if (sizeof(int) < 8 && sizeof(long) < 8 && sizeof(long long int) < 8)
718         is_eight = 0;
719 #else
720     if (sizeof(int) < 8 && sizeof(long) < 8) is_eight = 0;
721 #endif
722
723     size = sizeof(char) + sizeof(int);
724     extent = sizeof(char_int);
725     if (size != extent) is_packed = 0;
726     if ( (extent % 2) != 0) is_two = 0;
727     if ( (extent % 4) != 0) is_four = 0;
728     if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
729     DBG("char_int",size,extent);
730
731     size = sizeof(char) + sizeof(short);
732     extent = sizeof(char_short);
733     if (size != extent) is_packed = 0;
734     if ( (extent % 2) != 0) is_two = 0;
735     if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
736     if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
737     DBG("char_short",size,extent);
738
739     size = sizeof(char) + sizeof(long);
740     extent = sizeof(char_long);
741     if (size != extent) is_packed = 0;
742     if ( (extent % 2) != 0) is_two = 0;
743     if ( (extent % 4) != 0) is_four = 0;
744     if (sizeof(long) == 8 && (extent % 8) != 0) is_eight = 0;
745     DBG("char_long",size,extent);
746
747 #ifdef HAVE_LONG_LONG_INT
748     size = sizeof(char) + sizeof(long long int);
749     extent = sizeof(lli_c);
750     extent2 = sizeof(c_lli);
751     if (size != extent) is_packed = 0;
752     if ( (extent % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
753     if ( (extent % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
754     if (sizeof(long long int) >= 8 && (extent % 8) != 0 && (extent2 % 8) != 0)
755         is_eight = 0;
756 #endif
757
758     size = sizeof(char) + sizeof(int) + sizeof(char);
759     extent = sizeof(char_int_char);
760     if (size != extent) is_packed = 0;
761     if ( (extent % 2) != 0) is_two = 0;
762     if ( (extent % 4) != 0) is_four = 0;
763     if (sizeof(int) == 8 && (extent % 8) != 0) is_eight = 0;
764     DBG("char_int_char",size,extent);
765
766     size = sizeof(char) + sizeof(short) + sizeof(char);
767     extent = sizeof(char_short_char);
768     if (size != extent) is_packed = 0;
769     if ( (extent % 2) != 0) is_two = 0;
770     if (sizeof(short) == 4 && (extent % 4) != 0) is_four = 0;
771     if (sizeof(short) == 8 && (extent % 8) != 0) is_eight = 0;
772     DBG("char_short_char",size,extent);
773
774     /* If aligned mod 8, it will be aligned mod 4 */
775     if (is_eight) { is_four = 0; is_two = 0; }
776
777     if (is_four) is_two = 0;
778
779     /* Tabulate the results */
780     cf = fopen( "ctest.out", "w" );
781     if (is_packed + is_two + is_four + is_eight == 0) {
782         fprintf( cf, "Could not determine alignment\n" );
783     }
784     else {
785         if (is_packed + is_two + is_four + is_eight != 1) {
786             fprintf( cf, "error!\n" );
787         }
788         else {
789             if (is_packed) fprintf( cf, "packed\n" );
790             if (is_two) fprintf( cf, "two\n" );
791             if (is_four) fprintf( cf, "four\n" );
792             if (is_eight) fprintf( cf, "eight\n" );
793         }
794     }
795     fclose( cf );
796     return 0;
797 }],
798 pac_cv_c_max_integer_align=`cat ctest.out`,
799 pac_cv_c_max_integer_align="unknown",
800 pac_cv_c_max_integer_align="$CROSS_ALIGN_STRUCT_INT")
801 rm -f ctest.out
802 ])
803 if test -z "$pac_cv_c_max_integer_align" ; then
804     pac_cv_c_max_integer_align="unknown"
805 fi
806 ])
807
808 dnl Return the floating point structure alignment in
809 dnl pac_cv_c_max_fp_align.
810 dnl
811 dnl Possible values include:
812 dnl     packed
813 dnl     two
814 dnl     four
815 dnl     eight
816 dnl     sixteen
817 dnl
818 dnl In addition, a "Could not determine alignment" and a "error!"
819 dnl return is possible.  
820 AC_DEFUN([PAC_C_MAX_FP_ALIGN],[
821 AC_CACHE_CHECK([for max C struct floating point alignment],
822 pac_cv_c_max_fp_align,[
823 AC_TRY_RUN([
824 #include <stdio.h>
825 #define DBG(a,b,c)
826 int main( int argc, char *argv[] )
827 {
828     FILE *cf;
829     int is_packed  = 1;
830     int is_two     = 1;
831     int is_four    = 1;
832     int is_eight   = 1;
833     int is_sixteen = 1;
834     struct { char a; float b; } char_float;
835     struct { float b; char a; } float_char;
836     struct { char a; double b; } char_double;
837     struct { double b; char a; } double_char;
838 #ifdef HAVE_LONG_DOUBLE
839     struct { char a; long double b; } char_long_double;
840     struct { long double b; char a; } long_double_char;
841     struct { long double a; int b; char c; } long_double_int_char;
842 #endif
843     int size, extent1, extent2;
844
845     size = sizeof(char) + sizeof(float);
846     extent1 = sizeof(char_float);
847     extent2 = sizeof(float_char);
848     if (size != extent1) is_packed = 0;
849     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
850     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
851     if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
852         is_eight = 0;
853     DBG("char_float",size,extent1);
854
855     size = sizeof(char) + sizeof(double);
856     extent1 = sizeof(char_double);
857     extent2 = sizeof(double_char);
858     if (size != extent1) is_packed = 0;
859     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
860     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
861     if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
862         is_eight = 0;
863     DBG("char_double",size,extent1);
864
865 #ifdef HAVE_LONG_DOUBLE
866     size = sizeof(char) + sizeof(long double);
867     extent1 = sizeof(char_long_double);
868     extent2 = sizeof(long_double_char);
869     if (size != extent1) is_packed = 0;
870     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
871     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
872     if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
873         is_eight = 0;
874     if (sizeof(long double) > 8 && (extent1 % 16) != 0
875         && (extent2 % 16) != 0) is_sixteen = 0;
876     DBG("char_long-double",size,extent1);
877
878     extent1 = sizeof(long_double_int_char);
879     if ( (extent1 % 2) != 0) is_two = 0;
880     if ( (extent1 % 4) != 0) is_four = 0;
881     if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
882     if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
883 #else
884     is_sixteen = 0;
885 #endif
886
887     if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
888
889     if (is_eight) { is_four = 0; is_two = 0; }
890
891     if (is_four) is_two = 0;
892
893     /* Tabulate the results */
894     cf = fopen( "ctest.out", "w" );
895     if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
896         fprintf( cf, "Could not determine alignment\n" );
897     }
898     else {
899         if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
900             fprintf( cf, "error!\n" );
901         }
902         else {
903             if (is_packed) fprintf( cf, "packed\n" );
904             if (is_two) fprintf( cf, "two\n" );
905             if (is_four) fprintf( cf, "four\n" );
906             if (is_eight) fprintf( cf, "eight\n" );
907             if (is_sixteen) fprintf( cf, "sixteen\n" );
908         }
909     }
910     fclose( cf );
911     return 0;
912 }],
913 pac_cv_c_max_fp_align=`cat ctest.out`,
914 pac_cv_c_max_fp_align="unknown",
915 pac_cv_c_max_fp_align="$CROSS_ALIGN_STRUCT_FP")
916 rm -f ctest.out
917 ])
918 if test -z "$pac_cv_c_max_fp_align" ; then
919     pac_cv_c_max_fp_align="unknown"
920 fi
921 ])
922
923 dnl Return the floating point structure alignment in
924 dnl pac_cv_c_max_double_fp_align.
925 dnl
926 dnl Possible values include:
927 dnl     packed
928 dnl     two
929 dnl     four
930 dnl     eight
931 dnl
932 dnl In addition, a "Could not determine alignment" and a "error!"
933 dnl return is possible.  
934 AC_DEFUN([PAC_C_MAX_DOUBLE_FP_ALIGN],[
935 AC_CACHE_CHECK([for max C struct alignment of structs with doubles],
936 pac_cv_c_max_double_fp_align,[
937 AC_TRY_RUN([
938 #include <stdio.h>
939 #define DBG(a,b,c)
940 int main( int argc, char *argv[] )
941 {
942     FILE *cf;
943     int is_packed  = 1;
944     int is_two     = 1;
945     int is_four    = 1;
946     int is_eight   = 1;
947     struct { char a; float b; } char_float;
948     struct { float b; char a; } float_char;
949     struct { char a; double b; } char_double;
950     struct { double b; char a; } double_char;
951     int size, extent1, extent2;
952
953     size = sizeof(char) + sizeof(float);
954     extent1 = sizeof(char_float);
955     extent2 = sizeof(float_char);
956     if (size != extent1) is_packed = 0;
957     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
958     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
959     if (sizeof(float) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
960         is_eight = 0;
961     DBG("char_float",size,extent1);
962
963     size = sizeof(char) + sizeof(double);
964     extent1 = sizeof(char_double);
965     extent2 = sizeof(double_char);
966     if (size != extent1) is_packed = 0;
967     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
968     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
969     if (sizeof(double) == 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
970         is_eight = 0;
971     DBG("char_double",size,extent1);
972
973     if (is_eight) { is_four = 0; is_two = 0; }
974
975     if (is_four) is_two = 0;
976
977     /* Tabulate the results */
978     cf = fopen( "ctest.out", "w" );
979     if (is_packed + is_two + is_four + is_eight == 0) {
980         fprintf( cf, "Could not determine alignment\n" );
981     }
982     else {
983         if (is_packed + is_two + is_four + is_eight != 1) {
984             fprintf( cf, "error!\n" );
985         }
986         else {
987             if (is_packed) fprintf( cf, "packed\n" );
988             if (is_two) fprintf( cf, "two\n" );
989             if (is_four) fprintf( cf, "four\n" );
990             if (is_eight) fprintf( cf, "eight\n" );
991         }
992     }
993     fclose( cf );
994     return 0;
995 }],
996 pac_cv_c_max_double_fp_align=`cat ctest.out`,
997 pac_cv_c_max_double_fp_align="unknown",
998 pac_cv_c_max_double_fp_align="$CROSS_ALIGN_STRUCT_DOUBLE_FP")
999 rm -f ctest.out
1000 ])
1001 if test -z "$pac_cv_c_max_double_fp_align" ; then
1002     pac_cv_c_max_double_fp_align="unknown"
1003 fi
1004 ])
1005 AC_DEFUN([PAC_C_MAX_LONGDOUBLE_FP_ALIGN],[
1006 AC_CACHE_CHECK([for max C struct floating point alignment with long doubles],
1007 pac_cv_c_max_longdouble_fp_align,[
1008 AC_TRY_RUN([
1009 #include <stdio.h>
1010 #define DBG(a,b,c)
1011 int main( int argc, char *argv[] )
1012 {
1013     FILE *cf;
1014     int is_packed  = 1;
1015     int is_two     = 1;
1016     int is_four    = 1;
1017     int is_eight   = 1;
1018     int is_sixteen = 1;
1019     struct { char a; long double b; } char_long_double;
1020     struct { long double b; char a; } long_double_char;
1021     struct { long double a; int b; char c; } long_double_int_char;
1022     int size, extent1, extent2;
1023
1024     size = sizeof(char) + sizeof(long double);
1025     extent1 = sizeof(char_long_double);
1026     extent2 = sizeof(long_double_char);
1027     if (size != extent1) is_packed = 0;
1028     if ( (extent1 % 2) != 0 && (extent2 % 2) != 0) is_two = 0;
1029     if ( (extent1 % 4) != 0 && (extent2 % 4) != 0) is_four = 0;
1030     if (sizeof(long double) >= 8 && (extent1 % 8) != 0 && (extent2 % 8) != 0)
1031         is_eight = 0;
1032     if (sizeof(long double) > 8 && (extent1 % 16) != 0
1033         && (extent2 % 16) != 0) is_sixteen = 0;
1034     DBG("char_long-double",size,extent1);
1035
1036     extent1 = sizeof(long_double_int_char);
1037     if ( (extent1 % 2) != 0) is_two = 0;
1038     if ( (extent1 % 4) != 0) is_four = 0;
1039     if (sizeof(long double) >= 8 && (extent1 % 8) != 0) is_eight = 0;
1040     if (sizeof(long double) > 8 && (extent1 % 16) != 0) is_sixteen = 0;
1041
1042     if (is_sixteen) { is_eight = 0; is_four = 0; is_two = 0; }
1043
1044     if (is_eight) { is_four = 0; is_two = 0; }
1045
1046     if (is_four) is_two = 0;
1047
1048     /* Tabulate the results */
1049     cf = fopen( "ctest.out", "w" );
1050     if (is_packed + is_two + is_four + is_eight + is_sixteen == 0) {
1051         fprintf( cf, "Could not determine alignment\n" );
1052     }
1053     else {
1054         if (is_packed + is_two + is_four + is_eight + is_sixteen != 1) {
1055             fprintf( cf, "error!\n" );
1056         }
1057         else {
1058             if (is_packed) fprintf( cf, "packed\n" );
1059             if (is_two) fprintf( cf, "two\n" );
1060             if (is_four) fprintf( cf, "four\n" );
1061             if (is_eight) fprintf( cf, "eight\n" );
1062             if (is_sixteen) fprintf( cf, "sixteen\n" );
1063         }
1064     }
1065     fclose( cf );
1066     return 0;
1067 }],
1068 pac_cv_c_max_longdouble_fp_align=`cat ctest.out`,
1069 pac_cv_c_max_longdouble_fp_align="unknown",
1070 pac_cv_c_max_longdouble_fp_align="$CROSS_ALIGN_STRUCT_LONGDOUBLE_FP")
1071 rm -f ctest.out
1072 ])
1073 if test -z "$pac_cv_c_max_longdouble_fp_align" ; then
1074     pac_cv_c_max_longdouble_fp_align="unknown"
1075 fi
1076 ])
1077
1078 dnl Other tests assume that there is potentially a maximum alignment
1079 dnl and that if there is no maximum alignment, or a type is smaller than
1080 dnl that value, then we align on the size of the value, with the exception
1081 dnl of the "position-based alignment" rules we test for separately.
1082 dnl
1083 dnl It turns out that these assumptions have fallen short in at least one
1084 dnl case, on MacBook Pros, where doubles are aligned on 4-byte boundaries
1085 dnl even when long doubles are aligned on 16-byte boundaries. So this test
1086 dnl is here specifically to handle this case.
1087 dnl
1088 dnl Puts result in pac_cv_c_double_alignment_exception.
1089 dnl
1090 dnl Possible values currently include no and four.
1091 dnl
1092 AC_DEFUN([PAC_C_DOUBLE_ALIGNMENT_EXCEPTION],[
1093 AC_CACHE_CHECK([if double alignment breaks rules, find actual alignment],
1094 pac_cv_c_double_alignment_exception,[
1095 AC_TRY_RUN([
1096 #include <stdio.h>
1097 #define DBG(a,b,c)
1098 int main( int argc, char *argv[] )
1099 {
1100     FILE *cf;
1101     struct { char a; double b; } char_double;
1102     struct { double b; char a; } double_char;
1103     int extent1, extent2, align_4 = 0;
1104
1105     extent1 = sizeof(char_double);
1106     extent2 = sizeof(double_char);
1107
1108     /* we're interested in the largest value, will let separate test
1109      * deal with position-based issues.
1110      */
1111     if (extent1 < extent2) extent1 = extent2;
1112     if ((sizeof(double) == 8) && (extent1 % 8) != 0) {
1113        if (extent1 % 4 == 0) {
1114 #ifdef HAVE_MAX_FP_ALIGNMENT
1115           if (HAVE_MAX_FP_ALIGNMENT >= 8) align_4 = 1;
1116 #else
1117           align_4 = 1;
1118 #endif
1119        }
1120     }
1121
1122     cf = fopen( "ctest.out", "w" );
1123
1124     if (align_4) fprintf( cf, "four\n" );
1125     else fprintf( cf, "no\n" );
1126
1127     fclose( cf );
1128     return 0;
1129 }],
1130 pac_cv_c_double_alignment_exception=`cat ctest.out`,
1131 pac_cv_c_double_alignment_exception="unknown",
1132 pac_cv_c_double_alignment_exception="$CROSS_ALIGN_DOUBLE_EXCEPTION")
1133 rm -f ctest.out
1134 ])
1135 if test -z "$pac_cv_c_double_alignment_exception" ; then
1136     pac_cv_c_double_alignment_exception="unknown"
1137 fi
1138 ])
1139
1140 dnl Test for odd struct alignment rule that only applies max.
1141 dnl padding when double value is at front of type.
1142 dnl Puts result in pac_cv_c_double_pos_align.
1143 dnl
1144 dnl Search for "Power alignment mode" for more details.
1145 dnl
1146 dnl Possible values include yes, no, and unknown.
1147 dnl
1148 AC_DEFUN([PAC_C_DOUBLE_POS_ALIGN],[
1149 AC_CACHE_CHECK([if alignment of structs with doubles is based on position],
1150 pac_cv_c_double_pos_align,[
1151 AC_TRY_RUN([
1152 #include <stdio.h>
1153 #define DBG(a,b,c)
1154 int main( int argc, char *argv[] )
1155 {
1156     FILE *cf;
1157     int padding_varies_by_pos = 0;
1158     struct { char a; double b; } char_double;
1159     struct { double b; char a; } double_char;
1160     int extent1, extent2;
1161
1162     extent1 = sizeof(char_double);
1163     extent2 = sizeof(double_char);
1164     if (extent1 != extent2) padding_varies_by_pos = 1;
1165
1166     cf = fopen( "ctest.out", "w" );
1167     if (padding_varies_by_pos) fprintf( cf, "yes\n" );
1168     else fprintf( cf, "no\n" );
1169
1170     fclose( cf );
1171     return 0;
1172 }],
1173 pac_cv_c_double_pos_align=`cat ctest.out`,
1174 pac_cv_c_double_pos_align="unknown",
1175 pac_cv_c_double_pos_align="$CROSS_ALIGN_DOUBLE_POS")
1176 rm -f ctest.out
1177 ])
1178 if test -z "$pac_cv_c_double_pos_align" ; then
1179     pac_cv_c_double_pos_align="unknown"
1180 fi
1181 ])
1182
1183 dnl Test for odd struct alignment rule that only applies max.
1184 dnl padding when long long int value is at front of type.
1185 dnl Puts result in pac_cv_c_llint_pos_align.
1186 dnl
1187 dnl Search for "Power alignment mode" for more details.
1188 dnl
1189 dnl Possible values include yes, no, and unknown.
1190 dnl
1191 AC_DEFUN([PAC_C_LLINT_POS_ALIGN],[
1192 AC_CACHE_CHECK([if alignment of structs with long long ints is based on position],
1193 pac_cv_c_llint_pos_align,[
1194 AC_TRY_RUN([
1195 #include <stdio.h>
1196 #define DBG(a,b,c)
1197 int main( int argc, char *argv[] )
1198 {
1199     FILE *cf;
1200     int padding_varies_by_pos = 0;
1201 #ifdef HAVE_LONG_LONG_INT
1202     struct { char a; long long int b; } char_llint;
1203     struct { long long int b; char a; } llint_char;
1204     int extent1, extent2;
1205
1206     extent1 = sizeof(char_llint);
1207     extent2 = sizeof(llint_char);
1208     if (extent1 != extent2) padding_varies_by_pos = 1;
1209 #endif
1210
1211     cf = fopen( "ctest.out", "w" );
1212     if (padding_varies_by_pos) fprintf( cf, "yes\n" );
1213     else fprintf( cf, "no\n" );
1214
1215     fclose( cf );
1216     return 0;
1217 }],
1218 pac_cv_c_llint_pos_align=`cat ctest.out`,
1219 pac_cv_c_llint_pos_align="unknown",
1220 pac_cv_c_llint_pos_align="$CROSS_ALIGN_LLINT_POS")
1221 rm -f ctest.out
1222 ])
1223 if test -z "$pac_cv_c_llint_pos_align" ; then
1224     pac_cv_c_llint_pos_align="unknown"
1225 fi
1226 ])
1227
1228 dnl/*D
1229 dnl PAC_FUNC_NEEDS_DECL - Set NEEDS_<funcname>_DECL if a declaration is needed
1230 dnl
1231 dnl Synopsis:
1232 dnl PAC_FUNC_NEEDS_DECL(headerfiles,funcname)
1233 dnl
1234 dnl Output Effect:
1235 dnl Sets 'NEEDS_<funcname>_DECL' if 'funcname' is not declared by the 
1236 dnl headerfiles.
1237 dnl
1238 dnl Approach:
1239 dnl Attempt to assign library function to function pointer.  If the function
1240 dnl is not declared in a header, this will fail.  Use a non-static global so
1241 dnl the compiler does not warn about an unused variable.
1242 dnl
1243 dnl Simply calling the function is not enough because C89 compilers allow
1244 dnl calls to implicitly-defined functions.  Re-declaring a library function
1245 dnl with an incompatible prototype is also not sufficient because some
1246 dnl compilers (notably clang-3.2) only produce a warning in this case.
1247 dnl
1248 dnl D*/
1249 AC_DEFUN([PAC_FUNC_NEEDS_DECL],[
1250 AC_CACHE_CHECK([whether $2 needs a declaration],
1251 pac_cv_func_decl_$2,[
1252 AC_TRY_COMPILE([$1
1253 void (*fptr)(void) = (void(*)(void))$2;],[],
1254 pac_cv_func_decl_$2=no,pac_cv_func_decl_$2=yes)])
1255 if test "$pac_cv_func_decl_$2" = "yes" ; then
1256 changequote(<<,>>)dnl
1257 define(<<PAC_FUNC_NAME>>, translit(NEEDS_$2_DECL, [a-z *], [A-Z__]))dnl
1258 changequote([, ])dnl
1259     AC_DEFINE_UNQUOTED(PAC_FUNC_NAME,1,[Define if $2 needs a declaration])
1260 undefine([PAC_FUNC_NAME])
1261 fi
1262 ])
1263
1264 dnl PAC_C_GNU_ATTRIBUTE - See if the GCC __attribute__ specifier is allow.
1265 dnl Use the following
1266 dnl #ifndef HAVE_GCC_ATTRIBUTE
1267 dnl #define __attribute__(a)
1268 dnl #endif
1269 dnl If *not*, define __attribute__(a) as null
1270 dnl
1271 dnl We start by requiring Gcc.  Some other compilers accept __attribute__
1272 dnl but generate warning messages, or have different interpretations 
1273 dnl (which seems to make __attribute__ just as bad as #pragma) 
1274 dnl For example, the Intel icc compiler accepts __attribute__ and
1275 dnl __attribute__((pure)) but generates warnings for __attribute__((format...))
1276 dnl
1277 AC_DEFUN([PAC_C_GNU_ATTRIBUTE],[
1278 AC_REQUIRE([AC_PROG_CC_GNU])
1279 if test "$ac_cv_prog_gcc" = "yes" ; then
1280     AC_CACHE_CHECK([whether __attribute__ allowed],
1281 pac_cv_gnu_attr_pure,[
1282 AC_TRY_COMPILE([int foo(int) __attribute__ ((pure));],[int a;],
1283 pac_cv_gnu_attr_pure=yes,pac_cv_gnu_attr_pure=no)])
1284 AC_CACHE_CHECK([whether __attribute__((format)) allowed],
1285 pac_cv_gnu_attr_format,[
1286 AC_TRY_COMPILE([int foo(char *,...) __attribute__ ((format(printf,1,2)));],[int a;],
1287 pac_cv_gnu_attr_format=yes,pac_cv_gnu_attr_format=no)])
1288     if test "$pac_cv_gnu_attr_pure" = "yes" -a "$pac_cv_gnu_attr_format" = "yes" ; then
1289         AC_DEFINE(HAVE_GCC_ATTRIBUTE,1,[Define if GNU __attribute__ is supported])
1290     fi
1291 fi
1292 ])
1293 dnl
1294 dnl Check for a broken install (fails to preserve file modification times,
1295 dnl thus breaking libraries.
1296 dnl
1297 dnl Create a library, install it, and then try to link against it.
1298 AC_DEFUN([PAC_PROG_INSTALL_BREAKS_LIBS],[
1299 AC_CACHE_CHECK([whether install breaks libraries],
1300 ac_cv_prog_install_breaks_libs,[
1301 AC_REQUIRE([AC_PROG_RANLIB])
1302 AC_REQUIRE([AC_PROG_INSTALL])
1303 AC_REQUIRE([AC_PROG_CC])
1304 ac_cv_prog_install_breaks_libs=yes
1305
1306 AC_COMPILE_IFELSE([
1307     AC_LANG_SOURCE([ int foo(int); int foo(int a){return a;} ])
1308 ],[
1309     if ${AR-ar} ${AR_FLAGS-cr} libconftest.a conftest.$OBJEXT >/dev/null 2>&1 ; then
1310         if ${RANLIB-:} libconftest.a >/dev/null 2>&1 ; then
1311             # Anything less than sleep 10, and Mac OS/X (Darwin) 
1312             # will claim that install works because ranlib won't complain
1313             sleep 10
1314             libinstall="$INSTALL_DATA"
1315             eval "libinstall=\"$libinstall\""
1316             if ${libinstall} libconftest.a libconftest1.a >/dev/null 2>&1 ; then
1317                 saved_LIBS="$LIBS"
1318                 LIBS="libconftest1.a"
1319                 AC_LINK_IFELSE([
1320                     AC_LANG_SOURCE([
1321 extern int foo(int);
1322 int main(int argc, char **argv){ return foo(0); }
1323                     ])
1324                 ],[
1325                     # Success!  Install works
1326                     ac_cv_prog_install_breaks_libs=no
1327                 ],[
1328                     # Failure!  Does install -p work?        
1329                     rm -f libconftest1.a
1330                     if ${libinstall} -p libconftest.a libconftest1.a >/dev/null 2>&1 ; then
1331                         AC_LINK_IFELSE([],[
1332                             # Success!  Install works
1333                             ac_cv_prog_install_breaks_libs="no, with -p"
1334                         ])
1335                     fi
1336                 ])
1337                 LIBS="$saved_LIBS"
1338             fi
1339         fi
1340     fi
1341 ])
1342 rm -f libconftest*.a
1343 ]) dnl Endof ac_cache_check
1344
1345 if test -z "$RANLIB_AFTER_INSTALL" ; then
1346     RANLIB_AFTER_INSTALL=no
1347 fi
1348 case "$ac_cv_prog_install_breaks_libs" in
1349     yes)
1350         RANLIB_AFTER_INSTALL=yes
1351     ;;
1352     "no, with -p")
1353         INSTALL_DATA="$INSTALL_DATA -p"
1354     ;;
1355     *)
1356     # Do nothing
1357     :
1358     ;;
1359 esac
1360 AC_SUBST(RANLIB_AFTER_INSTALL)
1361 ])
1362
1363 #
1364 # determine if the compiler defines a symbol containing the function name
1365 #
1366 # These tests check not only that the compiler defines some symbol, such
1367 # as __FUNCTION__, but that the symbol correctly names the function.
1368 #
1369 # Defines 
1370 #   HAVE__FUNC__      (if __func__ defined)
1371 #   HAVE_CAP__FUNC__  (if __FUNC__ defined)
1372 #   HAVE__FUNCTION__  (if __FUNCTION__ defined)
1373 #
1374 AC_DEFUN([PAC_CC_FUNCTION_NAME_SYMBOL],[
1375 AC_CACHE_CHECK([whether the compiler defines __func__],
1376 pac_cv_have__func__,[
1377 tmp_am_cross=no
1378 AC_RUN_IFELSE([
1379 AC_LANG_SOURCE([
1380 #include <string.h>
1381 int foo(void);
1382 int foo(void)
1383 {
1384     return (strcmp(__func__, "foo") == 0);
1385 }
1386 int main(int argc, char ** argv)
1387 {
1388     return (foo() ? 0 : 1);
1389 }
1390 ])
1391 ], pac_cv_have__func__=yes, pac_cv_have__func__=no,tmp_am_cross=yes)
1392 if test "$tmp_am_cross" = yes ; then
1393     AC_LINK_IFELSE([
1394     AC_LANG_SOURCE([
1395 #include <string.h>
1396 int foo(void);
1397 int foo(void)
1398 {
1399     return (strcmp(__func__, "foo") == 0);
1400 }
1401 int main(int argc, char ** argv)
1402 {
1403     return (foo() ? 0 : 1);
1404 }
1405     ])
1406 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1407 fi
1408 ])
1409
1410 if test "$pac_cv_have__func__" = "yes" ; then
1411     AC_DEFINE(HAVE__FUNC__,,[define if the compiler defines __func__])
1412 fi
1413
1414 AC_CACHE_CHECK([whether the compiler defines __FUNC__],
1415 pac_cv_have_cap__func__,[
1416 tmp_am_cross=no
1417 AC_RUN_IFELSE([
1418 AC_LANG_SOURCE([
1419 #include <string.h>
1420 int foo(void);
1421 int foo(void)
1422 {
1423     return (strcmp(__FUNC__, "foo") == 0);
1424 }
1425 int main(int argc, char ** argv)
1426 {
1427     return (foo() ? 0 : 1);
1428 }
1429 ])
1430 ], pac_cv_have_cap__func__=yes, pac_cv_have_cap__func__=no,tmp_am_cross=yes)
1431 if test "$tmp_am_cross" = yes ; then
1432     AC_LINK_IFELSE([
1433     AC_LANG_SOURCE([
1434 #include <string.h>
1435 int foo(void);
1436 int foo(void)
1437 {
1438     return (strcmp(__FUNC__, "foo") == 0);
1439 }
1440 int main(int argc, char ** argv)
1441 {
1442     return (foo() ? 0 : 1);
1443 }
1444     ])
1445 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1446 fi
1447 ])
1448
1449 if test "$pac_cv_have_cap__func__" = "yes" ; then
1450     AC_DEFINE(HAVE_CAP__FUNC__,,[define if the compiler defines __FUNC__])
1451 fi
1452
1453 AC_CACHE_CHECK([whether the compiler sets __FUNCTION__],
1454 pac_cv_have__function__,[
1455 tmp_am_cross=no
1456 AC_RUN_IFELSE([
1457 AC_LANG_SOURCE([
1458 #include <string.h>
1459 int foo(void);
1460 int foo(void)
1461 {
1462     return (strcmp(__FUNCTION__, "foo") == 0);
1463 }
1464 int main(int argc, char ** argv)
1465 {
1466     return (foo() ? 0 : 1);
1467 }
1468 ])
1469 ], pac_cv_have__function__=yes, pac_cv_have__function__=no,tmp_am_cross=yes)
1470 if test "$tmp_am_cross" = yes ; then
1471     AC_LINK_IFELSE([
1472     AC_LANG_SOURCE([
1473 #include <string.h>
1474 int foo(void);
1475 int foo(void)
1476 {
1477     return (strcmp(__FUNCTION__, "foo") == 0);
1478 }
1479 int main(int argc, char ** argv)
1480 {
1481     return (foo() ? 0 : 1);
1482 }
1483     ])
1484 ], pac_cv_have__func__=yes, pac_cv_have__func__=no)
1485 fi
1486 ])
1487
1488 if test "$pac_cv_have__function__" = "yes" ; then
1489     AC_DEFINE(HAVE__FUNCTION__,,[define if the compiler defines __FUNCTION__])
1490 fi
1491
1492 ])
1493
1494
1495 dnl Check structure alignment
1496 AC_DEFUN([PAC_STRUCT_ALIGNMENT],[
1497         # Initialize alignment checks
1498         is_packed=1
1499         is_two=1
1500         is_four=1
1501         is_eight=1
1502         is_largest=1
1503
1504         # See if long double exists
1505         AC_TRY_COMPILE(,[long double a;],have_long_double=yes,have_long_double=no)
1506
1507         # Get sizes of regular types
1508         AC_CHECK_SIZEOF(char)
1509         AC_CHECK_SIZEOF(int)
1510         AC_CHECK_SIZEOF(short)
1511         AC_CHECK_SIZEOF(long)
1512         AC_CHECK_SIZEOF(float)
1513         AC_CHECK_SIZEOF(double)
1514         AC_CHECK_SIZEOF(long double)
1515
1516         # char_int comparison
1517         AC_CHECK_SIZEOF(char_int, 0, [typedef struct { char a; int b; } char_int; ])
1518         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_int`
1519         extent=$ac_cv_sizeof_char_int
1520         if test "$size" != "$extent" ; then is_packed=0 ; fi
1521         if test "`expr $extent % $ac_cv_sizeof_int`" != "0" ; then is_largest=0 ; fi
1522         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1523         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1524         if test "$ac_cv_sizeof_int" = "8" -a "`expr $extent % 8`" != "0" ; then
1525            is_eight=0
1526         fi
1527
1528         # char_short comparison
1529         AC_CHECK_SIZEOF(char_short, 0, [typedef struct { char a; short b; } char_short; ])
1530         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_short`
1531         extent=$ac_cv_sizeof_char_short
1532         if test "$size" != "$extent" ; then is_packed=0 ; fi
1533         if test "`expr $extent % $ac_cv_sizeof_short`" != "0" ; then is_largest=0 ; fi
1534         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1535         if test "$ac_cv_sizeof_short" = "4" -a "`expr $extent % 4`" != "0" ; then
1536            is_four=0
1537         fi
1538         if test "$ac_cv_sizeof_short" = "8" -a "`expr $extent % 8`" != "0" ; then
1539            is_eight=0
1540         fi
1541
1542         # char_long comparison
1543         AC_CHECK_SIZEOF(char_long, 0, [typedef struct { char a; long b; } char_long; ])
1544         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_long`
1545         extent=$ac_cv_sizeof_char_long
1546         if test "$size" != "$extent" ; then is_packed=0 ; fi
1547         if test "`expr $extent % $ac_cv_sizeof_long`" != "0" ; then is_largest=0 ; fi
1548         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1549         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1550         if test "$ac_cv_sizeof_long" = "8" -a "`expr $extent % 8`" != "0" ; then
1551            is_eight=0
1552         fi
1553
1554         # char_float comparison
1555         AC_CHECK_SIZEOF(char_float, 0, [typedef struct { char a; float b; } char_float; ])
1556         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_float`
1557         extent=$ac_cv_sizeof_char_float
1558         if test "$size" != "$extent" ; then is_packed=0 ; fi
1559         if test "`expr $extent % $ac_cv_sizeof_float`" != "0" ; then is_largest=0 ; fi
1560         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1561         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1562         if test "$ac_cv_sizeof_float" = "8" -a "`expr $extent % 8`" != "0" ; then
1563            is_eight=0
1564         fi
1565
1566         # char_double comparison
1567         AC_CHECK_SIZEOF(char_double, 0, [typedef struct { char a; double b; } char_double; ])
1568         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_double`
1569         extent=$ac_cv_sizeof_char_double
1570         if test "$size" != "$extent" ; then is_packed=0 ; fi
1571         if test "`expr $extent % $ac_cv_sizeof_double`" != "0" ; then is_largest=0 ; fi
1572         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1573         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1574         if test "$ac_cv_sizeof_double" = "8" -a "`expr $extent % 8`" != "0" ; then
1575            is_eight=0
1576         fi
1577
1578         # char_long_double comparison
1579         if test "$have_long_double" = "yes"; then
1580         AC_CHECK_SIZEOF(char_long_double, 0, [
1581                                        typedef struct {
1582                                                char a;
1583                                                long double b;
1584                                        } char_long_double;
1585                                        ])
1586         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_long_double`
1587         extent=$ac_cv_sizeof_char_long_double
1588         if test "$size" != "$extent" ; then is_packed=0 ; fi
1589         if test "`expr $extent % $ac_cv_sizeof_long_double`" != "0" ; then is_largest=0 ; fi
1590         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1591         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1592         if test "$ac_cv_sizeof_long_double" = "8" -a "`expr $extent % 8`" != "0" ; then
1593            is_eight=0
1594         fi
1595         fi
1596
1597         # char_int_char comparison
1598         AC_CHECK_SIZEOF(char_int_char, 0, [
1599                                        typedef struct {
1600                                                char a;
1601                                                int b;
1602                                                char c;
1603                                        } char_int_char;
1604                                        ])
1605         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_int + $ac_cv_sizeof_char`
1606         extent=$ac_cv_sizeof_char_int_char
1607         if test "$size" != "$extent" ; then is_packed=0 ; fi
1608         if test "`expr $extent % $ac_cv_sizeof_int`" != "0" ; then is_largest=0 ; fi
1609         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1610         if test "`expr $extent % 4`" != "0" ; then is_four=0 ; fi
1611         if test "$ac_cv_sizeof_int" = "8" -a "`expr $extent % 8`" != "0" ; then
1612            is_eight=0
1613         fi
1614
1615         # char_short_char comparison
1616         AC_CHECK_SIZEOF(char_short_char, 0, [
1617                                        typedef struct {
1618                                                char a;
1619                                                short b;
1620                                                char c;
1621                                        } char_short_char;
1622                                        ])
1623         size=`expr $ac_cv_sizeof_char + $ac_cv_sizeof_short + $ac_cv_sizeof_char`
1624         extent=$ac_cv_sizeof_char_short_char
1625         if test "$size" != "$extent" ; then is_packed=0 ; fi
1626         if test "`expr $extent % $ac_cv_sizeof_short`" != "0" ; then is_largest=0 ; fi
1627         if test "`expr $extent % 2`" != "0" ; then is_two=0 ; fi
1628         if test "$ac_cv_sizeof_short" = "4" -a "`expr $extent % 4`" != "0" ; then
1629            is_four=0
1630         fi
1631         if test "$ac_cv_sizeof_short" = "8" -a "`expr $extent % 8`" != "0" ; then
1632            is_eight=0
1633         fi
1634
1635         # If aligned mod 8, it will be aligned mod 4
1636         if test $is_eight = 1 ; then is_four=0 ; is_two=0 ; fi
1637         if test $is_four = 1 ; then is_two=0 ; fi
1638
1639         # Largest supersedes 8
1640         if test $is_largest = 1 ; then is_eight=0 ; fi
1641
1642         # Find the alignment
1643         if test "`expr $is_packed + $is_largest + $is_two + $is_four + $is_eight`" = "0" ; then
1644            pac_cv_struct_alignment="unknown"
1645         elif test "`expr $is_packed + $is_largest + $is_two + $is_four + $is_eight`" != "1" ; then
1646            pac_cv_struct_alignment="unknown"
1647         elif test $is_packed = 1 ; then
1648            pac_cv_struct_alignment="packed"
1649         elif test $is_largest = 1 ; then
1650            pac_cv_struct_alignment="largest"
1651         elif test $is_two = 1 ; then
1652            pac_cv_struct_alignment="two"
1653         elif test $is_four = 1 ; then
1654            pac_cv_struct_alignment="four"
1655         elif test $is_eight = 1 ; then
1656            pac_cv_struct_alignment="eight"
1657         fi
1658 ])
1659 dnl
1660 dnl PAC_C_MACRO_VA_ARGS
1661 dnl
1662 dnl will AC_DEFINE([HAVE_MACRO_VA_ARGS]) if the compiler supports C99 variable
1663 dnl length argument lists in macros (#define foo(...) bar(__VA_ARGS__))
1664 AC_DEFUN([PAC_C_MACRO_VA_ARGS],[
1665     AC_MSG_CHECKING([for variable argument list macro functionality])
1666     AC_LINK_IFELSE([AC_LANG_PROGRAM([
1667         #include <stdio.h>
1668         #define conftest_va_arg_macro(...) printf(__VA_ARGS__)
1669     ],
1670     [conftest_va_arg_macro("a test %d", 3);])],
1671     [AC_DEFINE([HAVE_MACRO_VA_ARGS],[1],[Define if C99-style variable argument list macro functionality])
1672      AC_MSG_RESULT([yes])],
1673     [AC_MSG_RESULT([no])])
1674 ])dnl
1675
1676 # Will AC_DEFINE([HAVE_BUILTIN_EXPECT]) if the compiler supports __builtin_expect.
1677 AC_DEFUN([PAC_C_BUILTIN_EXPECT],[
1678 AC_MSG_CHECKING([if C compiler supports __builtin_expect])
1679
1680 AC_TRY_LINK(, [
1681     return __builtin_expect(1, 1) ? 1 : 0
1682 ], [
1683     have_builtin_expect=yes
1684     AC_MSG_RESULT([yes])
1685 ], [
1686     have_builtin_expect=no
1687     AC_MSG_RESULT([no])
1688 ])
1689 if test x$have_builtin_expect = xyes ; then
1690     AC_DEFINE([HAVE_BUILTIN_EXPECT], [1], [Define to 1 if the compiler supports __builtin_expect.])
1691 fi
1692 ])