1dnl @(#) $Header: /tcpdump/master/tcpdump/aclocal.m4,v 1.106.2.7 2005/11/08 03:00:52 guy Exp $ (LBL)
2dnl
3dnl Copyright (c) 1995, 1996, 1997, 1998
4dnl	The Regents of the University of California.  All rights reserved.
5dnl
6dnl Redistribution and use in source and binary forms, with or without
7dnl modification, are permitted provided that: (1) source code distributions
8dnl retain the above copyright notice and this paragraph in its entirety, (2)
9dnl distributions including binary code include the above copyright notice and
10dnl this paragraph in its entirety in the documentation or other materials
11dnl provided with the distribution, and (3) all advertising materials mentioning
12dnl features or use of this software display the following acknowledgement:
13dnl ``This product includes software developed by the University of California,
14dnl Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
15dnl the University nor the names of its contributors may be used to endorse
16dnl or promote products derived from this software without specific prior
17dnl written permission.
18dnl THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
19dnl WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
20dnl MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21dnl
22dnl LBL autoconf macros
23dnl
24
25dnl
26dnl Determine which compiler we're using (cc or gcc)
27dnl If using gcc, determine the version number
28dnl If using cc, require that it support ansi prototypes
29dnl If using gcc, use -O2 (otherwise use -O)
30dnl If using cc, explicitly specify /usr/local/include
31dnl
32dnl usage:
33dnl
34dnl	AC_LBL_C_INIT(copt, incls)
35dnl
36dnl results:
37dnl
38dnl	$1 (copt set)
39dnl	$2 (incls set)
40dnl	CC
41dnl	LDFLAGS
42dnl	ac_cv_lbl_gcc_vers
43dnl	LBL_CFLAGS
44dnl
45AC_DEFUN(AC_LBL_C_INIT,
46    [AC_PREREQ(2.12)
47    AC_BEFORE([$0], [AC_PROG_CC])
48    AC_BEFORE([$0], [AC_LBL_FIXINCLUDES])
49    AC_BEFORE([$0], [AC_LBL_DEVEL])
50    AC_ARG_WITH(gcc, [  --without-gcc           don't use gcc])
51    $1="-O"
52    $2=""
53    if test "${srcdir}" != "." ; then
54	    $2="-I\$(srcdir)"
55    fi
56    if test "${CFLAGS+set}" = set; then
57	    LBL_CFLAGS="$CFLAGS"
58    fi
59    if test -z "$CC" ; then
60	    case "$host_os" in
61
62	    bsdi*)
63		    AC_CHECK_PROG(SHLICC2, shlicc2, yes, no)
64		    if test $SHLICC2 = yes ; then
65			    CC=shlicc2
66			    export CC
67		    fi
68		    ;;
69	    esac
70    fi
71    if test -z "$CC" -a "$with_gcc" = no ; then
72	    CC=cc
73	    export CC
74    fi
75    AC_PROG_CC
76    if test "$GCC" = yes ; then
77	    if test "$SHLICC2" = yes ; then
78		    ac_cv_lbl_gcc_vers=2
79		    $1="-O2"
80	    else
81		    AC_MSG_CHECKING(gcc version)
82		    AC_CACHE_VAL(ac_cv_lbl_gcc_vers,
83			ac_cv_lbl_gcc_vers=`$CC -v 2>&1 | \
84			    sed -e '/^gcc version /!d' \
85				-e 's/^gcc version //' \
86				-e 's/ .*//' -e 's/^[[[^0-9]]]*//' \
87				-e 's/\..*//'`)
88		    AC_MSG_RESULT($ac_cv_lbl_gcc_vers)
89		    if test $ac_cv_lbl_gcc_vers -gt 1 ; then
90			    $1="-O2"
91		    fi
92	    fi
93    else
94	    AC_MSG_CHECKING(that $CC handles ansi prototypes)
95	    AC_CACHE_VAL(ac_cv_lbl_cc_ansi_prototypes,
96		AC_TRY_COMPILE(
97		    [#include <sys/types.h>],
98		    [int frob(int, char *)],
99		    ac_cv_lbl_cc_ansi_prototypes=yes,
100		    ac_cv_lbl_cc_ansi_prototypes=no))
101	    AC_MSG_RESULT($ac_cv_lbl_cc_ansi_prototypes)
102	    if test $ac_cv_lbl_cc_ansi_prototypes = no ; then
103		    case "$host_os" in
104
105		    hpux*)
106			    AC_MSG_CHECKING(for HP-UX ansi compiler ($CC -Aa -D_HPUX_SOURCE))
107			    savedcflags="$CFLAGS"
108			    CFLAGS="-Aa -D_HPUX_SOURCE $CFLAGS"
109			    AC_CACHE_VAL(ac_cv_lbl_cc_hpux_cc_aa,
110				AC_TRY_COMPILE(
111				    [#include <sys/types.h>],
112				    [int frob(int, char *)],
113				    ac_cv_lbl_cc_hpux_cc_aa=yes,
114				    ac_cv_lbl_cc_hpux_cc_aa=no))
115			    AC_MSG_RESULT($ac_cv_lbl_cc_hpux_cc_aa)
116			    if test $ac_cv_lbl_cc_hpux_cc_aa = no ; then
117				    AC_MSG_ERROR(see the INSTALL doc for more info)
118			    fi
119			    CFLAGS="$savedcflags"
120			    V_CCOPT="-Aa $V_CCOPT"
121			    AC_DEFINE(_HPUX_SOURCE)
122			    ;;
123
124		    *)
125			    AC_MSG_ERROR(see the INSTALL doc for more info)
126			    ;;
127		    esac
128	    fi
129	    $2="$$2 -I/usr/local/include"
130	    LDFLAGS="$LDFLAGS -L/usr/local/lib"
131
132	    case "$host_os" in
133
134	    irix*)
135		    V_CCOPT="$V_CCOPT -xansi -signed -O"
136		    ;;
137
138	    osf*)
139		    V_CCOPT="$V_CCOPT -std1 -O"
140		    ;;
141
142	    ultrix*)
143		    AC_MSG_CHECKING(that Ultrix $CC hacks const in prototypes)
144		    AC_CACHE_VAL(ac_cv_lbl_cc_const_proto,
145			AC_TRY_COMPILE(
146			    [#include <sys/types.h>],
147			    [struct a { int b; };
148			    void c(const struct a *)],
149			    ac_cv_lbl_cc_const_proto=yes,
150			    ac_cv_lbl_cc_const_proto=no))
151		    AC_MSG_RESULT($ac_cv_lbl_cc_const_proto)
152		    if test $ac_cv_lbl_cc_const_proto = no ; then
153			    AC_DEFINE(const,)
154		    fi
155		    ;;
156	    esac
157    fi
158])
159
160
161#
162# Try compiling a sample of the type of code that appears in
163# gencode.c with "inline", "__inline__", and "__inline".
164#
165# Autoconf's AC_C_INLINE, at least in autoconf 2.13, isn't good enough,
166# as it just tests whether a function returning "int" can be inlined;
167# at least some versions of HP's C compiler can inline that, but can't
168# inline a function that returns a struct pointer.
169#
170AC_DEFUN(AC_LBL_C_INLINE,
171    [AC_MSG_CHECKING(for inline)
172    AC_CACHE_VAL(ac_cv_lbl_inline, [
173	ac_cv_lbl_inline=""
174	ac_lbl_cc_inline=no
175	for ac_lbl_inline in inline __inline__ __inline
176	do
177	    AC_TRY_COMPILE(
178		[#define inline $ac_lbl_inline
179		static inline struct iltest *foo(void);
180		struct iltest {
181		    int iltest1;
182		    int iltest2;
183		};
184
185		static inline struct iltest *
186		foo()
187		{
188		    static struct iltest xxx;
189
190		    return &xxx;
191		}],,ac_lbl_cc_inline=yes,)
192	    if test "$ac_lbl_cc_inline" = yes ; then
193		break;
194	    fi
195	done
196	if test "$ac_lbl_cc_inline" = yes ; then
197	    ac_cv_lbl_inline=$ac_lbl_inline
198	fi])
199    if test ! -z "$ac_cv_lbl_inline" ; then
200	AC_MSG_RESULT($ac_cv_lbl_inline)
201    else
202	AC_MSG_RESULT(no)
203    fi
204    AC_DEFINE_UNQUOTED(inline, $ac_cv_lbl_inline, [Define as token for inline if inlining supported])])
205
206dnl
207dnl Use pfopen.c if available and pfopen() not in standard libraries
208dnl Require libpcap
209dnl Look for libpcap in ..
210dnl Use the installed libpcap if there is no local version
211dnl
212dnl usage:
213dnl
214dnl	AC_LBL_LIBPCAP(pcapdep, incls)
215dnl
216dnl results:
217dnl
218dnl	$1 (pcapdep set)
219dnl	$2 (incls appended)
220dnl	LIBS
221dnl	LBL_LIBS
222dnl
223AC_DEFUN(AC_LBL_LIBPCAP,
224    [AC_REQUIRE([AC_LBL_LIBRARY_NET])
225    dnl
226    dnl save a copy before locating libpcap.a
227    dnl
228    LBL_LIBS="$LIBS"
229    pfopen=/usr/examples/packetfilter/pfopen.c
230    if test -f $pfopen ; then
231	    AC_CHECK_FUNCS(pfopen)
232	    if test $ac_cv_func_pfopen = "no" ; then
233		    AC_MSG_RESULT(Using $pfopen)
234		    LIBS="$LIBS $pfopen"
235	    fi
236    fi
237    AC_MSG_CHECKING(for local pcap library)
238    libpcap=FAIL
239    lastdir=FAIL
240    places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
241	egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
242    for dir in $places $srcdir/../libpcap $srcdir/libpcap ; do
243	    basedir=`echo $dir | sed -e 's/[[ab]][[0-9]]*$//'`
244	    if test $lastdir = $basedir ; then
245		    dnl skip alphas when an actual release is present
246		    continue;
247	    fi
248	    lastdir=$dir
249	    if test -r $dir/libpcap.a ; then
250		    libpcap=$dir/libpcap.a
251		    d=$dir
252		    dnl continue and select the last one that exists
253	    fi
254    done
255    if test $libpcap = FAIL ; then
256	    AC_MSG_RESULT(not found)
257	    AC_CHECK_LIB(pcap, main, libpcap="-lpcap")
258	    if test $libpcap = FAIL ; then
259		    AC_MSG_ERROR(see the INSTALL doc for more info)
260	    fi
261	    dnl
262	    dnl Good old Red Hat Linux puts "pcap.h" in
263	    dnl "/usr/include/pcap"; had the LBL folks done so,
264	    dnl that would have been a good idea, but for
265	    dnl the Red Hat folks to do so just breaks source
266	    dnl compatibility with other systems.
267	    dnl
268	    dnl We work around this by assuming that, as we didn't
269	    dnl find a local libpcap, libpcap is in /usr/lib or
270	    dnl /usr/local/lib and that the corresponding header
271	    dnl file is under one of those directories; if we don't
272	    dnl find it in either of those directories, we check to
273	    dnl see if it's in a "pcap" subdirectory of them and,
274	    dnl if so, add that subdirectory to the "-I" list.
275	    dnl
276	    AC_MSG_CHECKING(for extraneous pcap header directories)
277	    if test \( ! -r /usr/local/include/pcap.h \) -a \
278			\( ! -r /usr/include/pcap.h \); then
279		if test -r /usr/local/include/pcap/pcap.h; then
280		    d="/usr/local/include/pcap"
281		elif test -r /usr/include/pcap/pcap.h; then
282		    d="/usr/include/pcap"
283		fi
284	    fi
285	    if test -z "$d" ; then
286		AC_MSG_RESULT(not found)
287	    else
288		$2="-I$d $$2"
289		AC_MSG_RESULT(found -- -I$d added)
290	    fi
291    else
292	    $1=$libpcap
293	    places=`ls $srcdir/.. | sed -e 's,/$,,' -e "s,^,$srcdir/../," | \
294    	 		egrep '/libpcap-[[0-9]]*.[[0-9]]*(.[[0-9]]*)?([[ab]][[0-9]]*)?$'`
295	    if test -r $d/pcap.h; then
296		    $2="-I$d $$2"
297	    elif test -r $places/pcap.h; then
298		    $2="-I$places $$2"
299	    else
300                    AC_MSG_ERROR(cannot find pcap.h, see INSTALL)
301 	    fi
302	    AC_MSG_RESULT($libpcap)
303    fi
304    LIBS="$libpcap $LIBS"
305    case "$host_os" in
306
307    aix*)
308	    pseexe="/lib/pse.exp"
309	    AC_MSG_CHECKING(for $pseexe)
310	    if test -f $pseexe ; then
311		    AC_MSG_RESULT(yes)
312		    LIBS="$LIBS -I:$pseexe"
313	    fi
314	    #
315	    # We need "-lodm" and "-lcfg", as libpcap requires them on
316	    # AIX, and we just build a static libpcap.a and thus can't
317	    # arrange that when you link with libpcap you automatically
318	    # link with those libraries.
319	    #
320	    LIBS="$LIBS -lodm -lcfg"
321	    ;;
322    esac
323
324    dnl
325    dnl Check for "pcap_list_datalinks()", "pcap_set_datalink()",
326    dnl and "pcap_datalink_name_to_val()", and use substitute versions
327    dnl if they're not present.
328    dnl
329    AC_CHECK_FUNC(pcap_list_datalinks,
330	AC_DEFINE(HAVE_PCAP_LIST_DATALINKS),
331	[
332	    AC_LIBOBJ(datalinks)
333	])
334    AC_CHECK_FUNC(pcap_set_datalink,
335	AC_DEFINE(HAVE_PCAP_SET_DATALINK))
336    AC_CHECK_FUNC(pcap_datalink_name_to_val,
337	[
338	    AC_DEFINE(HAVE_PCAP_DATALINK_NAME_TO_VAL)
339	    AC_CHECK_FUNC(pcap_datalink_val_to_description,
340		AC_DEFINE(HAVE_PCAP_DATALINK_VAL_TO_DESCRIPTION),
341		[
342		    AC_LIBOBJ(dlnames)
343		])
344	],
345	[
346	    AC_LIBOBJ(dlnames)
347	])
348
349    dnl
350    dnl Check for "pcap_breakloop()"; you can't substitute for it if
351    dnl it's absent (it has hooks into the live capture routines),
352    dnl so just define the HAVE_ value if it's there.
353    dnl
354    AC_CHECK_FUNCS(pcap_breakloop)
355
356    dnl
357    dnl Check for "pcap_dump_ftell()" and use a substitute version
358    dnl if it's not present.
359    AC_CHECK_FUNC(pcap_dump_ftell,
360	AC_DEFINE(HAVE_PCAP_DUMP_FTELL),
361	[
362	    AC_LIBOBJ(pcap_dump_ftell)
363	])
364])
365
366dnl
367dnl Define RETSIGTYPE and RETSIGVAL
368dnl
369dnl usage:
370dnl
371dnl	AC_LBL_TYPE_SIGNAL
372dnl
373dnl results:
374dnl
375dnl	RETSIGTYPE (defined)
376dnl	RETSIGVAL (defined)
377dnl
378AC_DEFUN(AC_LBL_TYPE_SIGNAL,
379    [AC_BEFORE([$0], [AC_LBL_LIBPCAP])
380    AC_TYPE_SIGNAL
381    if test "$ac_cv_type_signal" = void ; then
382	    AC_DEFINE(RETSIGVAL,)
383    else
384	    AC_DEFINE(RETSIGVAL,(0))
385    fi
386    case "$host_os" in
387
388    irix*)
389	    AC_DEFINE(_BSD_SIGNALS)
390	    ;;
391
392    *)
393	    dnl prefer sigaction() to sigset()
394	    AC_CHECK_FUNCS(sigaction)
395	    if test $ac_cv_func_sigaction = no ; then
396		    AC_CHECK_FUNCS(sigset)
397	    fi
398	    ;;
399    esac])
400
401dnl
402dnl If using gcc, make sure we have ANSI ioctl definitions
403dnl
404dnl usage:
405dnl
406dnl	AC_LBL_FIXINCLUDES
407dnl
408AC_DEFUN(AC_LBL_FIXINCLUDES,
409    [if test "$GCC" = yes ; then
410	    AC_MSG_CHECKING(for ANSI ioctl definitions)
411	    AC_CACHE_VAL(ac_cv_lbl_gcc_fixincludes,
412		AC_TRY_COMPILE(
413		    [/*
414		     * This generates a "duplicate case value" when fixincludes
415		     * has not be run.
416		     */
417#		include <sys/types.h>
418#		include <sys/time.h>
419#		include <sys/ioctl.h>
420#		ifdef HAVE_SYS_IOCCOM_H
421#		include <sys/ioccom.h>
422#		endif],
423		    [switch (0) {
424		    case _IO('A', 1):;
425		    case _IO('B', 1):;
426		    }],
427		    ac_cv_lbl_gcc_fixincludes=yes,
428		    ac_cv_lbl_gcc_fixincludes=no))
429	    AC_MSG_RESULT($ac_cv_lbl_gcc_fixincludes)
430	    if test $ac_cv_lbl_gcc_fixincludes = no ; then
431		    # Don't cache failure
432		    unset ac_cv_lbl_gcc_fixincludes
433		    AC_MSG_ERROR(see the INSTALL for more info)
434	    fi
435    fi])
436
437dnl
438dnl Check for flex, default to lex
439dnl Require flex 2.4 or higher
440dnl Check for bison, default to yacc
441dnl Default to lex/yacc if both flex and bison are not available
442dnl Define the yy prefix string if using flex and bison
443dnl
444dnl usage:
445dnl
446dnl	AC_LBL_LEX_AND_YACC(lex, yacc, yyprefix)
447dnl
448dnl results:
449dnl
450dnl	$1 (lex set)
451dnl	$2 (yacc appended)
452dnl	$3 (optional flex and bison -P prefix)
453dnl
454AC_DEFUN(AC_LBL_LEX_AND_YACC,
455    [AC_ARG_WITH(flex, [  --without-flex          don't use flex])
456    AC_ARG_WITH(bison, [  --without-bison         don't use bison])
457    if test "$with_flex" = no ; then
458	    $1=lex
459    else
460	    AC_CHECK_PROGS($1, flex, lex)
461    fi
462    if test "$$1" = flex ; then
463	    # The -V flag was added in 2.4
464	    AC_MSG_CHECKING(for flex 2.4 or higher)
465	    AC_CACHE_VAL(ac_cv_lbl_flex_v24,
466		if flex -V >/dev/null 2>&1; then
467			ac_cv_lbl_flex_v24=yes
468		else
469			ac_cv_lbl_flex_v24=no
470		fi)
471	    AC_MSG_RESULT($ac_cv_lbl_flex_v24)
472	    if test $ac_cv_lbl_flex_v24 = no ; then
473		    s="2.4 or higher required"
474		    AC_MSG_WARN(ignoring obsolete flex executable ($s))
475		    $1=lex
476	    fi
477    fi
478    if test "$with_bison" = no ; then
479	    $2=yacc
480    else
481	    AC_CHECK_PROGS($2, bison, yacc)
482    fi
483    if test "$$2" = bison ; then
484	    $2="$$2 -y"
485    fi
486    if test "$$1" != lex -a "$$2" = yacc -o "$$1" = lex -a "$$2" != yacc ; then
487	    AC_MSG_WARN(don't have both flex and bison; reverting to lex/yacc)
488	    $1=lex
489	    $2=yacc
490    fi
491    if test "$$1" = flex -a -n "$3" ; then
492	    $1="$$1 -P$3"
493	    $2="$$2 -p $3"
494    fi])
495
496dnl
497dnl Checks to see if union wait is used with WEXITSTATUS()
498dnl
499dnl usage:
500dnl
501dnl	AC_LBL_UNION_WAIT
502dnl
503dnl results:
504dnl
505dnl	DECLWAITSTATUS (defined)
506dnl
507AC_DEFUN(AC_LBL_UNION_WAIT,
508    [AC_MSG_CHECKING(if union wait is used)
509    AC_CACHE_VAL(ac_cv_lbl_union_wait,
510	AC_TRY_COMPILE([
511#	include <sys/types.h>
512#	include <sys/wait.h>],
513	    [int status;
514	    u_int i = WEXITSTATUS(status);
515	    u_int j = waitpid(0, &status, 0);],
516	    ac_cv_lbl_union_wait=no,
517	    ac_cv_lbl_union_wait=yes))
518    AC_MSG_RESULT($ac_cv_lbl_union_wait)
519    if test $ac_cv_lbl_union_wait = yes ; then
520	    AC_DEFINE(DECLWAITSTATUS,union wait)
521    else
522	    AC_DEFINE(DECLWAITSTATUS,int)
523    fi])
524
525dnl
526dnl Checks to see if the sockaddr struct has the 4.4 BSD sa_len member
527dnl
528dnl usage:
529dnl
530dnl	AC_LBL_SOCKADDR_SA_LEN
531dnl
532dnl results:
533dnl
534dnl	HAVE_SOCKADDR_SA_LEN (defined)
535dnl
536AC_DEFUN(AC_LBL_SOCKADDR_SA_LEN,
537    [AC_MSG_CHECKING(if sockaddr struct has sa_len member)
538    AC_CACHE_VAL(ac_cv_lbl_sockaddr_has_sa_len,
539	AC_TRY_COMPILE([
540#	include <sys/types.h>
541#	include <sys/socket.h>],
542	[u_int i = sizeof(((struct sockaddr *)0)->sa_len)],
543	ac_cv_lbl_sockaddr_has_sa_len=yes,
544	ac_cv_lbl_sockaddr_has_sa_len=no))
545    AC_MSG_RESULT($ac_cv_lbl_sockaddr_has_sa_len)
546    if test $ac_cv_lbl_sockaddr_has_sa_len = yes ; then
547	    AC_DEFINE(HAVE_SOCKADDR_SA_LEN)
548    fi])
549
550dnl
551dnl Checks to see if -R is used
552dnl
553dnl usage:
554dnl
555dnl	AC_LBL_HAVE_RUN_PATH
556dnl
557dnl results:
558dnl
559dnl	ac_cv_lbl_have_run_path (yes or no)
560dnl
561AC_DEFUN(AC_LBL_HAVE_RUN_PATH,
562    [AC_MSG_CHECKING(for ${CC-cc} -R)
563    AC_CACHE_VAL(ac_cv_lbl_have_run_path,
564	[echo 'main(){}' > conftest.c
565	${CC-cc} -o conftest conftest.c -R/a1/b2/c3 >conftest.out 2>&1
566	if test ! -s conftest.out ; then
567		ac_cv_lbl_have_run_path=yes
568	else
569		ac_cv_lbl_have_run_path=no
570	fi
571	rm -f conftest*])
572    AC_MSG_RESULT($ac_cv_lbl_have_run_path)
573    ])
574
575dnl
576dnl Check whether a given format can be used to print 64-bit integers
577dnl
578AC_DEFUN(AC_LBL_CHECK_64BIT_FORMAT,
579  [
580    AC_MSG_CHECKING([whether %$1x can be used to format 64-bit integers])
581    AC_RUN_IFELSE(
582      [
583	AC_LANG_SOURCE(
584	  [[
585#	    ifdef HAVE_INTTYPES_H
586	    #include <inttypes.h>
587#	    endif
588#	    ifdef HAVE_SYS_BITYPES_H
589            #include <sys/bitypes.h>
590#	    endif
591	    #include <stdio.h>
592	    #include <sys/types.h>
593
594	    main()
595	    {
596	      u_int64_t t = 1;
597	      char strbuf[16+1];
598	      sprintf(strbuf, "%016$1x", t << 32);
599	      if (strcmp(strbuf, "0000000100000000") == 0)
600		exit(0);
601	      else
602		exit(1);
603	    }
604	  ]])
605      ],
606      [
607	AC_DEFINE(PRId64, "$1d")
608	AC_DEFINE(PRIo64, "$1o")
609	AC_DEFINE(PRIx64, "$1x")
610	AC_DEFINE(PRIu64, "$1u")
611	AC_MSG_RESULT(yes)
612      ],
613      [
614	AC_MSG_RESULT(no)
615	$2
616      ])
617  ])
618
619dnl
620dnl Checks to see if unaligned memory accesses fail
621dnl
622dnl usage:
623dnl
624dnl	AC_LBL_UNALIGNED_ACCESS
625dnl
626dnl results:
627dnl
628dnl	LBL_ALIGN (DEFINED)
629dnl
630AC_DEFUN(AC_LBL_UNALIGNED_ACCESS,
631    [AC_MSG_CHECKING(if unaligned accesses fail)
632    AC_CACHE_VAL(ac_cv_lbl_unaligned_fail,
633	[case "$host_cpu" in
634
635	#
636	# These are CPU types where:
637	#
638	#	the CPU faults on an unaligned access, but at least some
639	#	OSes that support that CPU catch the fault and simulate
640	#	the unaligned access (e.g., Alpha/{Digital,Tru64} UNIX) -
641	#	the simulation is slow, so we don't want to use it;
642	#
643	#	the CPU, I infer (from the old
644	#
645	# XXX: should also check that they don't do weird things (like on arm)
646	#
647	#	comment) doesn't fault on unaligned accesses, but doesn't
648	#	do a normal unaligned fetch, either (e.g., presumably, ARM);
649	#
650	#	for whatever reason, the test program doesn't work
651	#	(this has been claimed to be the case for several of those
652	#	CPUs - I don't know what the problem is; the problem
653	#	was reported as "the test program dumps core" for SuperH,
654	#	but that's what the test program is *supposed* to do -
655	#	it dumps core before it writes anything, so the test
656	#	for an empty output file should find an empty output
657	#	file and conclude that unaligned accesses don't work).
658	#
659	# This run-time test won't work if you're cross-compiling, so
660	# in order to support cross-compiling for a particular CPU,
661	# we have to wire in the list of CPU types anyway, as far as
662	# I know, so perhaps we should just have a set of CPUs on
663	# which we know it doesn't work, a set of CPUs on which we
664	# know it does work, and have the script just fail on other
665	# cpu types and update it when such a failure occurs.
666	#
667	alpha*|arm*|hp*|mips*|sh*|sparc*|ia64|nv1)
668		ac_cv_lbl_unaligned_fail=yes
669		;;
670
671	*)
672		cat >conftest.c <<EOF
673#		include <sys/types.h>
674#		include <sys/wait.h>
675#		include <stdio.h>
676		unsigned char a[[5]] = { 1, 2, 3, 4, 5 };
677		main() {
678		unsigned int i;
679		pid_t pid;
680		int status;
681		/* avoid "core dumped" message */
682		pid = fork();
683		if (pid <  0)
684			exit(2);
685		if (pid > 0) {
686			/* parent */
687			pid = waitpid(pid, &status, 0);
688			if (pid < 0)
689				exit(3);
690			exit(!WIFEXITED(status));
691		}
692		/* child */
693		i = *(unsigned int *)&a[[1]];
694		printf("%d\n", i);
695		exit(0);
696		}
697EOF
698		${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS \
699		    conftest.c $LIBS >/dev/null 2>&1
700		if test ! -x conftest ; then
701			dnl failed to compile for some reason
702			ac_cv_lbl_unaligned_fail=yes
703		else
704			./conftest >conftest.out
705			if test ! -s conftest.out ; then
706				ac_cv_lbl_unaligned_fail=yes
707			else
708				ac_cv_lbl_unaligned_fail=no
709			fi
710		fi
711		rm -f conftest* core core.conftest
712		;;
713	esac])
714    AC_MSG_RESULT($ac_cv_lbl_unaligned_fail)
715    if test $ac_cv_lbl_unaligned_fail = yes ; then
716	    AC_DEFINE(LBL_ALIGN)
717    fi])
718
719dnl
720dnl If using gcc and the file .devel exists:
721dnl	Compile with -g (if supported) and -Wall
722dnl	If using gcc 2 or later, do extra prototype checking and some other
723dnl	checks
724dnl	If an os prototype include exists, symlink os-proto.h to it
725dnl
726dnl usage:
727dnl
728dnl	AC_LBL_DEVEL(copt)
729dnl
730dnl results:
731dnl
732dnl	$1 (copt appended)
733dnl	HAVE_OS_PROTO_H (defined)
734dnl	os-proto.h (symlinked)
735dnl
736AC_DEFUN(AC_LBL_DEVEL,
737    [rm -f os-proto.h
738    if test "${LBL_CFLAGS+set}" = set; then
739	    $1="$$1 ${LBL_CFLAGS}"
740    fi
741    if test -f .devel ; then
742	    if test "$GCC" = yes ; then
743		    if test "${LBL_CFLAGS+set}" != set; then
744			    if test "$ac_cv_prog_cc_g" = yes ; then
745				    $1="-g $$1"
746			    fi
747			    $1="$$1 -Wall"
748			    if test $ac_cv_lbl_gcc_vers -gt 1 ; then
749				    $1="$$1 -Wmissing-prototypes -Wstrict-prototypes -Wwrite-strings -Wpointer-arith -W"
750			    fi
751		    fi
752	    else
753		    case "$host_os" in
754
755		    irix6*)
756			    V_CCOPT="$V_CCOPT -n32"
757			    ;;
758
759		    *)
760			    ;;
761		    esac
762	    fi
763	    os=`echo $host_os | sed -e 's/\([[0-9]][[0-9]]*\)[[^0-9]].*$/\1/'`
764	    name="lbl/os-$os.h"
765	    if test -f $name ; then
766		    ln -s $name os-proto.h
767		    AC_DEFINE(HAVE_OS_PROTO_H)
768	    else
769		    AC_MSG_WARN(can't find $name)
770	    fi
771    fi])
772
773dnl
774dnl Improved version of AC_CHECK_LIB
775dnl
776dnl Thanks to John Hawkinson (jhawk@mit.edu)
777dnl
778dnl usage:
779dnl
780dnl	AC_LBL_CHECK_LIB(LIBRARY, FUNCTION [, ACTION-IF-FOUND [,
781dnl	    ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
782dnl
783dnl results:
784dnl
785dnl	LIBS
786dnl
787dnl XXX - "AC_LBL_LIBRARY_NET" was redone to use "AC_SEARCH_LIBS"
788dnl rather than "AC_LBL_CHECK_LIB", so this isn't used any more.
789dnl We keep it around for reference purposes in case it's ever
790dnl useful in the future.
791dnl
792
793define(AC_LBL_CHECK_LIB,
794[AC_MSG_CHECKING([for $2 in -l$1])
795dnl Use a cache variable name containing the library, function
796dnl name, and extra libraries to link with, because the test really is
797dnl for library $1 defining function $2, when linked with potinal
798dnl library $5, not just for library $1.  Separate tests with the same
799dnl $1 and different $2's or $5's may have different results.
800ac_lib_var=`echo $1['_']$2['_']$5 | sed 'y%./+- %__p__%'`
801AC_CACHE_VAL(ac_cv_lbl_lib_$ac_lib_var,
802[ac_save_LIBS="$LIBS"
803LIBS="-l$1 $5 $LIBS"
804AC_TRY_LINK(dnl
805ifelse([$2], [main], , dnl Avoid conflicting decl of main.
806[/* Override any gcc2 internal prototype to avoid an error.  */
807]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
808extern "C"
809#endif
810])dnl
811[/* We use char because int might match the return type of a gcc2
812    builtin and then its argument prototype would still apply.  */
813char $2();
814]),
815	    [$2()],
816	    eval "ac_cv_lbl_lib_$ac_lib_var=yes",
817	    eval "ac_cv_lbl_lib_$ac_lib_var=no")
818LIBS="$ac_save_LIBS"
819])dnl
820if eval "test \"`echo '$ac_cv_lbl_lib_'$ac_lib_var`\" = yes"; then
821  AC_MSG_RESULT(yes)
822  ifelse([$3], ,
823[changequote(, )dnl
824  ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \
825    -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
826changequote([, ])dnl
827  AC_DEFINE_UNQUOTED($ac_tr_lib)
828  LIBS="-l$1 $LIBS"
829], [$3])
830else
831  AC_MSG_RESULT(no)
832ifelse([$4], , , [$4
833])dnl
834fi
835])
836
837dnl
838dnl AC_LBL_LIBRARY_NET
839dnl
840dnl This test is for network applications that need socket() and
841dnl gethostbyname() -ish functions.  Under Solaris, those applications
842dnl need to link with "-lsocket -lnsl".  Under IRIX, they need to link
843dnl with "-lnsl" but should *not* link with "-lsocket" because
844dnl libsocket.a breaks a number of things (for instance:
845dnl gethostbyname() under IRIX 5.2, and snoop sockets under most
846dnl versions of IRIX).
847dnl
848dnl Unfortunately, many application developers are not aware of this,
849dnl and mistakenly write tests that cause -lsocket to be used under
850dnl IRIX.  It is also easy to write tests that cause -lnsl to be used
851dnl under operating systems where neither are necessary (or useful),
852dnl such as SunOS 4.1.4, which uses -lnsl for TLI.
853dnl
854dnl This test exists so that every application developer does not test
855dnl this in a different, and subtly broken fashion.
856
857dnl It has been argued that this test should be broken up into two
858dnl seperate tests, one for the resolver libraries, and one for the
859dnl libraries necessary for using Sockets API. Unfortunately, the two
860dnl are carefully intertwined and allowing the autoconf user to use
861dnl them independantly potentially results in unfortunate ordering
862dnl dependancies -- as such, such component macros would have to
863dnl carefully use indirection and be aware if the other components were
864dnl executed. Since other autoconf macros do not go to this trouble,
865dnl and almost no applications use sockets without the resolver, this
866dnl complexity has not been implemented.
867dnl
868dnl The check for libresolv is in case you are attempting to link
869dnl statically and happen to have a libresolv.a lying around (and no
870dnl libnsl.a).
871dnl
872AC_DEFUN(AC_LBL_LIBRARY_NET, [
873    # Most operating systems have gethostbyname() in the default searched
874    # libraries (i.e. libc):
875    # Some OSes (eg. Solaris) place it in libnsl
876    # Some strange OSes (SINIX) have it in libsocket:
877    AC_SEARCH_LIBS(gethostbyname, nsl socket resolv)
878    # Unfortunately libsocket sometimes depends on libnsl and
879    # AC_SEARCH_LIBS isn't up to the task of handling dependencies like this.
880    if test "$ac_cv_search_gethostbyname" = "no"
881    then
882	AC_CHECK_LIB(socket, gethostbyname,
883                     LIBS="-lsocket -lnsl $LIBS", , -lnsl)
884    fi
885    AC_SEARCH_LIBS(socket, socket, ,
886	AC_CHECK_LIB(socket, socket, LIBS="-lsocket -lnsl $LIBS", , -lnsl))
887    # DLPI needs putmsg under HPUX so test for -lstr while we're at it
888    AC_SEARCH_LIBS(putmsg, str)
889    ])
890
891dnl Copyright (c) 1999 WIDE Project. All rights reserved.
892dnl
893dnl Redistribution and use in source and binary forms, with or without
894dnl modification, are permitted provided that the following conditions
895dnl are met:
896dnl 1. Redistributions of source code must retain the above copyright
897dnl    notice, this list of conditions and the following disclaimer.
898dnl 2. Redistributions in binary form must reproduce the above copyright
899dnl    notice, this list of conditions and the following disclaimer in the
900dnl    documentation and/or other materials provided with the distribution.
901dnl 3. Neither the name of the project nor the names of its contributors
902dnl    may be used to endorse or promote products derived from this software
903dnl    without specific prior written permission.
904dnl 
905dnl THIS SOFTWARE IS PROVIDED BY THE PROJECT AND CONTRIBUTORS ``AS IS'' AND
906dnl ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
907dnl IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
908dnl ARE DISCLAIMED.  IN NO EVENT SHALL THE PROJECT OR CONTRIBUTORS BE LIABLE
909dnl FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
910dnl DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
911dnl OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
912dnl HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
913dnl LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
914dnl OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
915dnl SUCH DAMAGE.
916
917dnl
918dnl Checks to see if AF_INET6 is defined
919AC_DEFUN(AC_CHECK_AF_INET6, [
920	AC_MSG_CHECKING(for AF_INET6)
921	AC_CACHE_VAL($1,
922	AC_TRY_COMPILE([
923#		include <sys/types.h>
924#		include <sys/socket.h>],
925		[int a = AF_INET6],
926		$1=yes,
927		$1=no))
928	AC_MSG_RESULT($$1)
929		if test $$1 = yes ; then
930			AC_DEFINE(HAVE_AF_INET6)
931	fi
932])
933
934dnl
935dnl Checks to see if the sockaddr struct has the 4.4 BSD sa_len member
936dnl borrowed from LBL libpcap
937AC_DEFUN(AC_CHECK_SA_LEN, [
938	AC_MSG_CHECKING(if sockaddr struct has sa_len member)
939	AC_CACHE_VAL($1,
940	AC_TRY_COMPILE([
941#		include <sys/types.h>
942#		include <sys/socket.h>],
943		[u_int i = sizeof(((struct sockaddr *)0)->sa_len)],
944		$1=yes,
945		$1=no))
946	AC_MSG_RESULT($$1)
947		if test $$1 = yes ; then
948			AC_DEFINE(HAVE_SOCKADDR_SA_LEN)
949	fi
950])
951
952dnl
953dnl Checks for portable prototype declaration macro
954AC_DEFUN(AC_CHECK_PORTABLE_PROTO,  [
955	AC_MSG_CHECKING(for __P)
956	AC_CACHE_VAL($1,
957	AC_TRY_COMPILE([
958#		include <unistd.h>],
959		[int f __P(())],
960		$1=yes,
961		$1=no))
962	AC_MSG_RESULT($$1)
963	if test $$1 = yes; then
964		AC_DEFINE(HAVE_PORTABLE_PROTOTYPE)
965	fi
966])
967
968dnl checks for u_intXX_t
969AC_DEFUN(AC_CHECK_BITTYPES, [
970	$1=yes
971dnl check for u_int8_t
972	AC_MSG_CHECKING(for u_int8_t)
973	AC_CACHE_VAL(ac_cv_u_int8_t,
974	AC_TRY_COMPILE([
975#		include <sys/types.h>],
976		[u_int8_t i],
977		ac_cv_u_int8_t=yes,
978		ac_cv_u_int8_t=no))
979	AC_MSG_RESULT($ac_cv_u_int8_t)
980	if test $ac_cv_u_int8_t = yes; then
981		AC_DEFINE(HAVE_U_INT8_T)
982	else
983		$1=no
984	fi
985dnl check for u_int16_t
986	AC_MSG_CHECKING(for u_int16_t)
987	AC_CACHE_VAL(ac_cv_u_int16_t,
988	AC_TRY_COMPILE([
989#		include <sys/types.h>],
990		[u_int16_t i],
991		ac_cv_u_int16_t=yes,
992		ac_cv_u_int16_t=no))
993	AC_MSG_RESULT($ac_cv_u_int16_t)
994	if test $ac_cv_u_int16_t = yes; then
995		AC_DEFINE(HAVE_U_INT16_T)
996	else
997		$1=no
998	fi
999dnl check for u_int32_t
1000	AC_MSG_CHECKING(for u_int32_t)
1001	AC_CACHE_VAL(ac_cv_u_int32_t,
1002	AC_TRY_COMPILE([
1003#		include <sys/types.h>],
1004		[u_int32_t i],
1005		ac_cv_u_int32_t=yes,
1006		ac_cv_u_int32_t=no))
1007	AC_MSG_RESULT($ac_cv_u_int32_t)
1008	if test $ac_cv_u_int32_t = yes; then
1009		AC_DEFINE(HAVE_U_INT32_T)
1010	else
1011		$1=no
1012	fi
1013dnl check for u_int64_t
1014	AC_MSG_CHECKING(for u_int64_t)
1015	AC_CACHE_VAL(ac_cv_u_int64_t,
1016	AC_TRY_COMPILE([
1017#		include <sys/types.h>],
1018		[u_int64_t i],
1019		ac_cv_u_int64_t=yes,
1020		ac_cv_u_int64_t=no))
1021	AC_MSG_RESULT($ac_cv_u_int64_t)
1022	if test $ac_cv_u_int64_t = yes; then
1023		AC_DEFINE(HAVE_U_INT64_T)
1024	else
1025		$1=no
1026	fi
1027])
1028
1029dnl
1030dnl Checks for addrinfo structure
1031AC_DEFUN(AC_STRUCT_ADDRINFO, [
1032	AC_MSG_CHECKING(for addrinfo)
1033	AC_CACHE_VAL($1,
1034	AC_TRY_COMPILE([
1035#		include <netdb.h>],
1036		[struct addrinfo a],
1037		$1=yes,
1038		$1=no))
1039	AC_MSG_RESULT($$1)
1040	if test $$1 = yes; then
1041		AC_DEFINE(HAVE_ADDRINFO)
1042	else
1043		AC_DEFINE(NEED_ADDRINFO_H)
1044	fi
1045])
1046
1047dnl
1048dnl Checks for NI_MAXSERV
1049AC_DEFUN(AC_NI_MAXSERV, [
1050	AC_MSG_CHECKING(for NI_MAXSERV)
1051	AC_CACHE_VAL($1,
1052	AC_EGREP_CPP(yes, [#include <netdb.h>
1053#ifdef NI_MAXSERV
1054yes
1055#endif],
1056		$1=yes,
1057		$1=no))
1058	AC_MSG_RESULT($$1)
1059	if test $$1 != yes; then
1060		AC_DEFINE(NEED_ADDRINFO_H)
1061	fi
1062])
1063
1064dnl
1065dnl Checks for NI_NAMEREQD
1066AC_DEFUN(AC_NI_NAMEREQD, [
1067	AC_MSG_CHECKING(for NI_NAMEREQD)
1068	AC_CACHE_VAL($1,
1069	AC_EGREP_CPP(yes, [#include <netdb.h>
1070#ifdef NI_NOFQDN
1071yes
1072#endif],
1073		$1=yes,
1074		$1=no))
1075	AC_MSG_RESULT($$1)
1076	if test $$1 != yes; then
1077		AC_DEFINE(NEED_ADDRINFO_H)
1078	fi
1079])
1080
1081dnl
1082dnl Checks for sockaddr_storage structure
1083AC_DEFUN(AC_STRUCT_SA_STORAGE, [
1084	AC_MSG_CHECKING(for sockaddr_storage)
1085	AC_CACHE_VAL($1,
1086	AC_TRY_COMPILE([
1087#		include <sys/types.h>
1088#		include <sys/socket.h>],
1089		[struct sockaddr_storage s],
1090		$1=yes,
1091		$1=no))
1092	AC_MSG_RESULT($$1)
1093	if test $$1 = yes; then
1094		AC_DEFINE(HAVE_SOCKADDR_STORAGE)
1095	fi
1096])
1097
1098dnl
1099dnl Checks for macro of IP address size
1100AC_DEFUN(AC_CHECK_ADDRSZ, [
1101	$1=yes
1102dnl check for INADDRSZ
1103	AC_MSG_CHECKING(for INADDRSZ)
1104	AC_CACHE_VAL(ac_cv_inaddrsz,
1105	AC_TRY_COMPILE([
1106#		include <arpa/nameser.h>],
1107		[int a = INADDRSZ],
1108		ac_cv_inaddrsz=yes,
1109		ac_cv_inaddrsz=no))
1110	AC_MSG_RESULT($ac_cv_inaddrsz)
1111	if test $ac_cv_inaddrsz = yes; then
1112		AC_DEFINE(HAVE_INADDRSZ)
1113	else
1114		$1=no
1115	fi
1116dnl check for IN6ADDRSZ
1117	AC_MSG_CHECKING(for IN6ADDRSZ)
1118	AC_CACHE_VAL(ac_cv_in6addrsz,
1119	AC_TRY_COMPILE([
1120#		include <arpa/nameser.h>],
1121		[int a = IN6ADDRSZ],
1122		ac_cv_in6addrsz=yes,
1123		ac_cv_in6addrsz=no))
1124	AC_MSG_RESULT($ac_cv_in6addrsz)
1125	if test $ac_cv_in6addrsz = yes; then
1126		AC_DEFINE(HAVE_IN6ADDRSZ)
1127	else
1128		$1=no
1129	fi
1130])
1131
1132dnl
1133dnl check for RES_USE_INET6
1134AC_DEFUN(AC_CHECK_RES_USE_INET6, [
1135	AC_MSG_CHECKING(for RES_USE_INET6)
1136	AC_CACHE_VAL($1,
1137	AC_TRY_COMPILE([
1138#		include <sys/types.h>
1139#		include <netinet/in.h>
1140#		include <resolv.h>],
1141		[int a = RES_USE_INET6],
1142		$1=yes,
1143		$1=no))
1144	AC_MSG_RESULT($$1)
1145	if test $$1 = yes; then
1146		AC_DEFINE(HAVE_RES_USE_INET6)
1147	fi
1148])
1149
1150dnl
1151dnl check for AAAA
1152AC_DEFUN(AC_CHECK_AAAA, [
1153	AC_MSG_CHECKING(for AAAA)
1154	AC_CACHE_VAL($1,
1155	AC_TRY_COMPILE([
1156#		include <sys/types.h>
1157#		include <arpa/nameser.h>],
1158		[int a = T_AAAA],
1159		$1=yes,
1160		$1=no))
1161	AC_MSG_RESULT($$1)
1162	if test $$1 = yes; then
1163		AC_DEFINE(HAVE_AAAA)
1164	fi
1165])
1166
1167dnl
1168dnl check for struct res_state_ext
1169AC_DEFUN(AC_STRUCT_RES_STATE_EXT, [
1170	AC_MSG_CHECKING(for res_state_ext)
1171	AC_CACHE_VAL($1,
1172	AC_TRY_COMPILE([
1173#		include <sys/types.h>
1174#		include <netinet/in.h>
1175#		include <netinet6/in6.h>
1176#		include <resolv.h>],
1177		[struct __res_state_ext e],
1178		$1=yes,
1179		$1=no))
1180	AC_MSG_RESULT($$1)
1181	if test $$1 = yes; then
1182		AC_DEFINE(HAVE_RES_STATE_EXT)
1183	fi
1184])
1185
1186dnl
1187dnl check for struct res_state_ext
1188AC_DEFUN(AC_STRUCT_RES_STATE, [
1189	AC_MSG_CHECKING(for nsort in res_state)
1190	AC_CACHE_VAL($1,
1191	AC_TRY_COMPILE([
1192#		include <sys/types.h>
1193#		include <netinet/in.h>
1194#		include <netinet6/in6.h>
1195#		include <resolv.h>],
1196		[struct __res_state e; e.nsort = 0],
1197		$1=yes,
1198		$1=no))
1199	AC_MSG_RESULT($$1)
1200	if test $$1 = yes; then
1201		AC_DEFINE(HAVE_NEW_RES_STATE)
1202	fi
1203])
1204
1205dnl
1206dnl check for h_errno
1207AC_DEFUN(AC_VAR_H_ERRNO, [
1208	AC_MSG_CHECKING(for h_errno)
1209	AC_CACHE_VAL(ac_cv_var_h_errno,
1210	AC_TRY_COMPILE([
1211#		include <sys/types.h>
1212#		include <netdb.h>],
1213		[int foo = h_errno;],
1214		ac_cv_var_h_errno=yes,
1215		ac_cv_var_h_errno=no))
1216	AC_MSG_RESULT($ac_cv_var_h_errno)
1217	if test "$ac_cv_var_h_errno" = "yes"; then
1218		AC_DEFINE(HAVE_H_ERRNO)
1219	fi
1220])
1221
1222dnl
1223dnl Test for __attribute__
1224dnl
1225
1226AC_DEFUN(AC_C___ATTRIBUTE__, [
1227AC_MSG_CHECKING(for __attribute__)
1228AC_CACHE_VAL(ac_cv___attribute__, [
1229AC_COMPILE_IFELSE(
1230  AC_LANG_SOURCE([[
1231#include <stdlib.h>
1232
1233static void foo(void) __attribute__ ((noreturn));
1234
1235static void
1236foo(void)
1237{
1238  exit(1);
1239}
1240
1241int
1242main(int argc, char **argv)
1243{
1244  foo();
1245}
1246  ]]),
1247ac_cv___attribute__=yes,
1248ac_cv___attribute__=no)])
1249if test "$ac_cv___attribute__" = "yes"; then
1250  AC_DEFINE(HAVE___ATTRIBUTE__, 1, [define if your compiler has __attribute__])
1251  V_DEFS="$V_DEFS -D_U_=\"__attribute__((unused))\""
1252else
1253  V_DEFS="$V_DEFS -D_U_=\"\""
1254fi
1255AC_MSG_RESULT($ac_cv___attribute__)
1256])
1257