1dnl Copyright (c) 1995, 1996, 1997, 1998
2dnl	The Regents of the University of California.  All rights reserved.
3dnl
4dnl Redistribution and use in source and binary forms, with or without
5dnl modification, are permitted provided that: (1) source code distributions
6dnl retain the above copyright notice and this paragraph in its entirety, (2)
7dnl distributions including binary code include the above copyright notice and
8dnl this paragraph in its entirety in the documentation or other materials
9dnl provided with the distribution, and (3) all advertising materials mentioning
10dnl features or use of this software display the following acknowledgement:
11dnl ``This product includes software developed by the University of California,
12dnl Lawrence Berkeley Laboratory and its contributors.'' Neither the name of
13dnl the University nor the names of its contributors may be used to endorse
14dnl or promote products derived from this software without specific prior
15dnl written permission.
16dnl THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
17dnl WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
18dnl MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
19dnl
20dnl LBL autoconf macros
21dnl
22
23dnl
24dnl Do whatever AC_LBL_C_INIT work is necessary before using AC_PROG_CC.
25dnl
26dnl It appears that newer versions of autoconf (2.64 and later) will,
27dnl if you use AC_TRY_COMPILE in a macro, stick AC_PROG_CC at the
28dnl beginning of the macro, even if the macro itself calls AC_PROG_CC.
29dnl See the "Prerequisite Macros" and "Expanded Before Required" sections
30dnl in the Autoconf documentation.
31dnl
32dnl This causes a steaming heap of fail in our case, as we were, in
33dnl AC_LBL_C_INIT, doing the tests we now do in AC_LBL_C_INIT_BEFORE_CC,
34dnl calling AC_PROG_CC, and then doing the tests we now do in
35dnl AC_LBL_C_INIT.  Now, we run AC_LBL_C_INIT_BEFORE_CC, AC_PROG_CC,
36dnl and AC_LBL_C_INIT at the top level.
37dnl
38AC_DEFUN(AC_LBL_C_INIT_BEFORE_CC,
39[
40    AC_BEFORE([$0], [AC_LBL_C_INIT])
41    AC_BEFORE([$0], [AC_PROG_CC])
42    AC_BEFORE([$0], [AC_LBL_FIXINCLUDES])
43    AC_BEFORE([$0], [AC_LBL_DEVEL])
44    AC_ARG_WITH(gcc, [  --without-gcc           don't use gcc])
45    $1=""
46    if test "${srcdir}" != "." ; then
47	    $1="-I\$(srcdir)"
48    fi
49    if test "${CFLAGS+set}" = set; then
50	    LBL_CFLAGS="$CFLAGS"
51    fi
52    if test -z "$CC" ; then
53	    case "$host_os" in
54
55	    bsdi*)
56		    AC_CHECK_PROG(SHLICC2, shlicc2, yes, no)
57		    if test $SHLICC2 = yes ; then
58			    CC=shlicc2
59			    export CC
60		    fi
61		    ;;
62	    esac
63    fi
64    if test -z "$CC" -a "$with_gcc" = no ; then
65	    CC=cc
66	    export CC
67    fi
68])
69
70dnl
71dnl Determine which compiler we're using (cc or gcc)
72dnl If using gcc, determine the version number
73dnl If using cc:
74dnl     require that it support ansi prototypes
75dnl     use -O (AC_PROG_CC will use -g -O2 on gcc, so we don't need to
76dnl     do that ourselves for gcc)
77dnl     add -g flags, as appropriate
78dnl     explicitly specify /usr/local/include
79dnl
80dnl NOTE WELL: with newer versions of autoconf, "gcc" means any compiler
81dnl that defines __GNUC__, which means clang, for example, counts as "gcc".
82dnl
83dnl usage:
84dnl
85dnl	AC_LBL_C_INIT(copt, incls)
86dnl
87dnl results:
88dnl
89dnl	$1 (copt set)
90dnl	$2 (incls set)
91dnl	CC
92dnl	LDFLAGS
93dnl	LBL_CFLAGS
94dnl
95AC_DEFUN(AC_LBL_C_INIT,
96[
97    AC_BEFORE([$0], [AC_LBL_FIXINCLUDES])
98    AC_BEFORE([$0], [AC_LBL_DEVEL])
99    AC_BEFORE([$0], [AC_LBL_SHLIBS_INIT])
100    if test "$GCC" = yes ; then
101	    #
102	    # -Werror forces warnings to be errors.
103	    #
104	    ac_lbl_cc_force_warning_errors=-Werror
105
106	    #
107	    # Try to have the compiler default to hiding symbols,
108	    # so that only symbols explicitly exported with
109	    # PCAP_API will be visible outside (shared) libraries.
110	    #
111	    AC_LBL_CHECK_COMPILER_OPT($1, -fvisibility=hidden)
112    else
113	    $2="$$2 -I/usr/local/include"
114	    LDFLAGS="$LDFLAGS -L/usr/local/lib"
115
116	    case "$host_os" in
117
118	    darwin*)
119		    #
120		    # This is assumed either to be GCC or clang, both
121		    # of which use -Werror to force warnings to be errors.
122		    #
123		    ac_lbl_cc_force_warning_errors=-Werror
124
125		    #
126		    # Try to have the compiler default to hiding symbols,
127		    # so that only symbols explicitly exported with
128		    # PCAP_API will be visible outside (shared) libraries.
129		    #
130		    AC_LBL_CHECK_COMPILER_OPT($1, -fvisibility=hidden)
131		    ;;
132
133	    hpux*)
134		    #
135		    # HP C, which is what we presume we're using, doesn't
136		    # exit with a non-zero exit status if we hand it an
137		    # invalid -W flag, can't be forced to do so even with
138		    # +We, and doesn't handle GCC-style -W flags, so we
139		    # don't want to try using GCC-style -W flags.
140		    #
141		    ac_lbl_cc_dont_try_gcc_dashW=yes
142		    ;;
143
144	    irix*)
145		    #
146		    # MIPS C, which is what we presume we're using, doesn't
147		    # necessarily exit with a non-zero exit status if we
148		    # hand it an invalid -W flag, can't be forced to do
149		    # so, and doesn't handle GCC-style -W flags, so we
150		    # don't want to try using GCC-style -W flags.
151		    #
152		    ac_lbl_cc_dont_try_gcc_dashW=yes
153		    #
154		    # It also, apparently, defaults to "char" being
155		    # unsigned, unlike most other C implementations;
156		    # I suppose we could say "signed char" whenever
157		    # we want to guarantee a signed "char", but let's
158		    # just force signed chars.
159		    #
160		    # -xansi is normally the default, but the
161		    # configure script was setting it; perhaps -cckr
162		    # was the default in the Old Days.  (Then again,
163		    # that would probably be for backwards compatibility
164		    # in the days when ANSI C was Shiny and New, i.e.
165		    # 1989 and the early '90's, so maybe we can just
166		    # drop support for those compilers.)
167		    #
168		    # -g is equivalent to -g2, which turns off
169		    # optimization; we choose -g3, which generates
170		    # debugging information but doesn't turn off
171		    # optimization (even if the optimization would
172		    # cause inaccuracies in debugging).
173		    #
174		    $1="$$1 -xansi -signed -g3"
175		    ;;
176
177	    osf*)
178		    #
179		    # Presumed to be DEC OSF/1, Digital UNIX, or
180		    # Tru64 UNIX.
181		    #
182		    # The DEC C compiler, which is what we presume we're
183		    # using, doesn't exit with a non-zero exit status if we
184		    # hand it an invalid -W flag, can't be forced to do
185		    # so, and doesn't handle GCC-style -W flags, so we
186		    # don't want to try using GCC-style -W flags.
187		    #
188		    ac_lbl_cc_dont_try_gcc_dashW=yes
189		    #
190		    # -g is equivalent to -g2, which turns off
191		    # optimization; we choose -g3, which generates
192		    # debugging information but doesn't turn off
193		    # optimization (even if the optimization would
194		    # cause inaccuracies in debugging).
195		    #
196		    $1="$$1 -g3"
197		    ;;
198
199	    solaris*)
200		    #
201		    # Assumed to be Sun C, which requires -errwarn to force
202		    # warnings to be treated as errors.
203		    #
204		    ac_lbl_cc_force_warning_errors=-errwarn
205
206		    #
207		    # Try to have the compiler default to hiding symbols,
208		    # so that only symbols explicitly exported with
209		    # PCAP_API will be visible outside (shared) libraries.
210		    #
211		    AC_LBL_CHECK_COMPILER_OPT($1, -xldscope=hidden)
212		    ;;
213
214	    ultrix*)
215		    AC_MSG_CHECKING(that Ultrix $CC hacks const in prototypes)
216		    AC_CACHE_VAL(ac_cv_lbl_cc_const_proto,
217			AC_TRY_COMPILE(
218			    [#include <sys/types.h>],
219			    [struct a { int b; };
220			    void c(const struct a *)],
221			    ac_cv_lbl_cc_const_proto=yes,
222			    ac_cv_lbl_cc_const_proto=no))
223		    AC_MSG_RESULT($ac_cv_lbl_cc_const_proto)
224		    if test $ac_cv_lbl_cc_const_proto = no ; then
225			    AC_DEFINE(const,[],
226			        [to handle Ultrix compilers that don't support const in prototypes])
227		    fi
228		    ;;
229	    esac
230	    $1="$$1 -O"
231    fi
232])
233
234dnl
235dnl Check whether, if you pass an unknown warning option to the
236dnl compiler, it fails or just prints a warning message and succeeds.
237dnl Set ac_lbl_unknown_warning_option_error to the appropriate flag
238dnl to force an error if it would otherwise just print a warning message
239dnl and succeed.
240dnl
241AC_DEFUN(AC_LBL_CHECK_UNKNOWN_WARNING_OPTION_ERROR,
242    [
243	AC_MSG_CHECKING([whether the compiler fails when given an unknown warning option])
244	save_CFLAGS="$CFLAGS"
245	CFLAGS="$CFLAGS -Wxyzzy-this-will-never-succeed-xyzzy"
246	AC_TRY_COMPILE(
247	    [],
248	    [return 0],
249	    [
250		AC_MSG_RESULT([no])
251		#
252		# We're assuming this is clang, where
253		# -Werror=unknown-warning-option is the appropriate
254		# option to force the compiler to fail.
255		#
256		ac_lbl_unknown_warning_option_error="-Werror=unknown-warning-option"
257	    ],
258	    [
259		AC_MSG_RESULT([yes])
260	    ])
261	CFLAGS="$save_CFLAGS"
262    ])
263
264dnl
265dnl Check whether the compiler option specified as the second argument
266dnl is supported by the compiler and, if so, add it to the macro
267dnl specified as the first argument
268dnl
269dnl If a third argument is supplied, treat it as C code to be compiled
270dnl with the flag in question, and the "treat warnings as errors" flag
271dnl set, and don't add the flag to the first argument if the compile
272dnl fails; this is for warning options cause problems that can't be
273dnl worked around.  If a third argument is supplied, a fourth argument
274dnl should also be supplied; it's a message desribing what the test
275dnl program is checking.
276dnl
277AC_DEFUN(AC_LBL_CHECK_COMPILER_OPT,
278    [
279	AC_MSG_CHECKING([whether the compiler supports the $2 option])
280	save_CFLAGS="$CFLAGS"
281	if expr "x$2" : "x-W.*" >/dev/null
282	then
283	    CFLAGS="$CFLAGS $ac_lbl_unknown_warning_option_error $2"
284	elif expr "x$2" : "x-f.*" >/dev/null
285	then
286	    CFLAGS="$CFLAGS -Werror $2"
287	elif expr "x$2" : "x-m.*" >/dev/null
288	then
289	    CFLAGS="$CFLAGS -Werror $2"
290	else
291	    CFLAGS="$CFLAGS $2"
292	fi
293	AC_TRY_COMPILE(
294	    [],
295	    [return 0],
296	    [
297		AC_MSG_RESULT([yes])
298		can_add_to_cflags=yes
299		#
300		# The compile supports this; do we have some C code for
301		# which the warning should *not* appear?
302		# We test the fourth argument because the third argument
303		# could contain quotes, breaking the test.
304		#
305		if test "x$4" != "x"
306		then
307		    CFLAGS="$CFLAGS $ac_lbl_cc_force_warning_errors"
308		    AC_MSG_CHECKING(whether $2 $4)
309		    AC_COMPILE_IFELSE(
310		      [AC_LANG_SOURCE($3)],
311		      [
312			#
313			# Not a problem.
314			#
315			AC_MSG_RESULT(no)
316		      ],
317		      [
318			#
319			# A problem.
320			#
321			AC_MSG_RESULT(yes)
322			can_add_to_cflags=no
323		      ])
324		fi
325		CFLAGS="$save_CFLAGS"
326		if test x"$can_add_to_cflags" = "xyes"
327		then
328		    $1="$$1 $2"
329		fi
330	    ],
331	    [
332		AC_MSG_RESULT([no])
333		CFLAGS="$save_CFLAGS"
334	    ])
335    ])
336
337dnl
338dnl Check whether the compiler supports an option to generate
339dnl Makefile-style dependency lines
340dnl
341dnl GCC uses -M for this.  Non-GCC compilers that support this
342dnl use a variety of flags, including but not limited to -M.
343dnl
344dnl We test whether the flag in question is supported, as older
345dnl versions of compilers might not support it.
346dnl
347dnl We don't try all the possible flags, just in case some flag means
348dnl "generate dependencies" on one compiler but means something else
349dnl on another compiler.
350dnl
351dnl Most compilers that support this send the output to the standard
352dnl output by default.  IBM's XLC, however, supports -M but sends
353dnl the output to {sourcefile-basename}.u, and AIX has no /dev/stdout
354dnl to work around that, so we don't bother with XLC.
355dnl
356AC_DEFUN(AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT,
357    [
358	AC_MSG_CHECKING([whether the compiler supports generating dependencies])
359	if test "$GCC" = yes ; then
360		#
361		# GCC, or a compiler deemed to be GCC by AC_PROG_CC (even
362		# though it's not); we assume that, in this case, the flag
363		# would be -M.
364		#
365		ac_lbl_dependency_flag="-M"
366	else
367		#
368		# Not GCC or a compiler deemed to be GCC; what platform is
369		# this?  (We're assuming that if the compiler isn't GCC
370		# it's the compiler from the vendor of the OS; that won't
371		# necessarily be true for x86 platforms, where it might be
372		# the Intel C compiler.)
373		#
374		case "$host_os" in
375
376		irix*|osf*|darwin*)
377			#
378			# MIPS C for IRIX, DEC C, and clang all use -M.
379			#
380			ac_lbl_dependency_flag="-M"
381			;;
382
383		solaris*)
384			#
385			# Sun C uses -xM.
386			#
387			ac_lbl_dependency_flag="-xM"
388			;;
389
390		hpux*)
391			#
392			# HP's older C compilers don't support this.
393			# HP's newer C compilers support this with
394			# either +M or +Make; the older compilers
395			# interpret +M as something completely
396			# different, so we use +Make so we don't
397			# think it works with the older compilers.
398			#
399			ac_lbl_dependency_flag="+Make"
400			;;
401
402		*)
403			#
404			# Not one of the above; assume no support for
405			# generating dependencies.
406			#
407			ac_lbl_dependency_flag=""
408			;;
409		esac
410	fi
411
412	#
413	# Is ac_lbl_dependency_flag defined and, if so, does the compiler
414	# complain about it?
415	#
416	# Note: clang doesn't seem to exit with an error status when handed
417	# an unknown non-warning error, even if you pass it
418	# -Werror=unknown-warning-option.  However, it always supports
419	# -M, so the fact that this test always succeeds with clang
420	# isn't an issue.
421	#
422	if test ! -z "$ac_lbl_dependency_flag"; then
423		AC_LANG_CONFTEST(
424		    [AC_LANG_SOURCE([[int main(void) { return 0; }]])])
425		if AC_RUN_LOG([eval "$CC $ac_lbl_dependency_flag conftest.c >/dev/null 2>&1"]); then
426			AC_MSG_RESULT([yes, with $ac_lbl_dependency_flag])
427			DEPENDENCY_CFLAG="$ac_lbl_dependency_flag"
428			MKDEP='${srcdir}/mkdep'
429		else
430			AC_MSG_RESULT([no])
431			#
432			# We can't run mkdep, so have "make depend" do
433			# nothing.
434			#
435			MKDEP='${srcdir}/nomkdep'
436		fi
437		rm -rf conftest*
438	else
439		AC_MSG_RESULT([no])
440		#
441		# We can't run mkdep, so have "make depend" do
442		# nothing.
443		#
444		MKDEP='${srcdir}/nomkdep'
445	fi
446	AC_SUBST(DEPENDENCY_CFLAG)
447	AC_SUBST(MKDEP)
448    ])
449
450dnl
451dnl Determine what options are needed to build a shared library
452dnl
453dnl usage:
454dnl
455dnl	AC_LBL_SHLIBS_INIT
456dnl
457dnl results:
458dnl
459dnl	V_SHLIB_CCOPT (modified to build position-independent code)
460dnl	V_SHLIB_CMD
461dnl	V_SHLIB_OPT
462dnl	V_SONAME_OPT
463dnl	V_RPATH_OPT
464dnl
465AC_DEFUN(AC_LBL_SHLIBS_INIT,
466    [AC_PREREQ(2.50)
467    if test "$GCC" = yes ; then
468	    #
469	    # On platforms where we build a shared library:
470	    #
471	    #	add options to generate position-independent code,
472	    #	if necessary (it's the default in AIX and Darwin/macOS);
473	    #
474	    #	define option to set the soname of the shared library,
475	    #	if the OS supports that;
476	    #
477	    #	add options to specify, at link time, a directory to
478	    #	add to the run-time search path, if that's necessary.
479	    #
480	    V_SHLIB_CMD="\$(CC)"
481	    V_SHLIB_OPT="-shared"
482	    case "$host_os" in
483
484	    aix*)
485		    ;;
486
487	    freebsd*|netbsd*|openbsd*|dragonfly*|linux*|osf*)
488	    	    #
489		    # Platforms where the linker is the GNU linker
490		    # or accepts command-line arguments like
491		    # those the GNU linker accepts.
492		    #
493		    # Some instruction sets require -fPIC on some
494		    # operating systems.  Check for them.  If you
495		    # have a combination that requires it, add it
496		    # here.
497		    #
498		    PIC_OPT=-fpic
499		    case "$host_cpu" in
500
501		    sparc64*)
502			case "$host_os" in
503
504			freebsd*|openbsd*)
505			    PIC_OPT=-fPIC
506			    ;;
507			esac
508			;;
509		    esac
510		    V_SHLIB_CCOPT="$V_SHLIB_CCOPT $PIC_OPT"
511		    V_SONAME_OPT="-Wl,-soname,"
512		    V_RPATH_OPT="-Wl,-rpath,"
513		    ;;
514
515	    hpux*)
516		    V_SHLIB_CCOPT="$V_SHLIB_CCOPT -fpic"
517	    	    #
518		    # XXX - this assumes GCC is using the HP linker,
519		    # rather than the GNU linker, and that the "+h"
520		    # option is used on all HP-UX platforms, both .sl
521		    # and .so.
522		    #
523		    V_SONAME_OPT="-Wl,+h,"
524		    #
525		    # By default, directories specifed with -L
526		    # are added to the run-time search path, so
527		    # we don't add them in pcap-config.
528		    #
529		    ;;
530
531	    solaris*)
532		    V_SHLIB_CCOPT="$V_SHLIB_CCOPT -fpic"
533		    #
534		    # XXX - this assumes GCC is using the Sun linker,
535		    # rather than the GNU linker.
536		    #
537		    V_SONAME_OPT="-Wl,-h,"
538		    V_RPATH_OPT="-Wl,-R,"
539		    ;;
540	    esac
541    else
542	    #
543	    # Set the appropriate compiler flags and, on platforms
544	    # where we build a shared library:
545	    #
546	    #	add options to generate position-independent code,
547	    #	if necessary (it's the default in Darwin/macOS);
548	    #
549	    #	if we generate ".so" shared libraries, define the
550	    #	appropriate options for building the shared library;
551	    #
552	    #	add options to specify, at link time, a directory to
553	    #	add to the run-time search path, if that's necessary.
554	    #
555	    # Note: spaces after V_SONAME_OPT are significant; on
556	    # some platforms the soname is passed with a GCC-like
557	    # "-Wl,-soname,{soname}" option, with the soname part
558	    # of the option, while on other platforms the C compiler
559	    # driver takes it as a regular option with the soname
560	    # following the option.  The same applies to V_RPATH_OPT.
561	    #
562	    case "$host_os" in
563
564	    aix*)
565		    V_SHLIB_CMD="\$(CC)"
566		    V_SHLIB_OPT="-G -bnoentry -bexpall"
567		    ;;
568
569	    freebsd*|netbsd*|openbsd*|dragonfly*|linux*)
570		    #
571		    # "cc" is GCC.
572		    #
573		    V_SHLIB_CCOPT="$V_SHLIB_CCOPT -fpic"
574		    V_SHLIB_CMD="\$(CC)"
575		    V_SHLIB_OPT="-shared"
576		    V_SONAME_OPT="-Wl,-soname,"
577		    V_RPATH_OPT="-Wl,-rpath,"
578		    ;;
579
580	    hpux*)
581		    V_SHLIB_CCOPT="$V_SHLIB_CCOPT +z"
582		    V_SHLIB_CMD="\$(LD)"
583		    V_SHLIB_OPT="-b"
584		    V_SONAME_OPT="+h "
585		    #
586		    # By default, directories specifed with -L
587		    # are added to the run-time search path, so
588		    # we don't add them in pcap-config.
589		    #
590		    ;;
591
592	    osf*)
593	    	    #
594		    # Presumed to be DEC OSF/1, Digital UNIX, or
595		    # Tru64 UNIX.
596		    #
597		    V_SHLIB_CMD="\$(CC)"
598		    V_SHLIB_OPT="-shared"
599		    V_SONAME_OPT="-soname "
600		    V_RPATH_OPT="-rpath "
601		    ;;
602
603	    solaris*)
604		    V_SHLIB_CCOPT="$V_SHLIB_CCOPT -Kpic"
605		    V_SHLIB_CMD="\$(CC)"
606		    V_SHLIB_OPT="-G"
607		    V_SONAME_OPT="-h "
608		    V_RPATH_OPT="-R"
609		    ;;
610	    esac
611    fi
612])
613
614#
615# Try compiling a sample of the type of code that appears in
616# gencode.c with "inline", "__inline__", and "__inline".
617#
618# Autoconf's AC_C_INLINE, at least in autoconf 2.13, isn't good enough,
619# as it just tests whether a function returning "int" can be inlined;
620# at least some versions of HP's C compiler can inline that, but can't
621# inline a function that returns a struct pointer.
622#
623# Make sure we use the V_CCOPT flags, because some of those might
624# disable inlining.
625#
626AC_DEFUN(AC_LBL_C_INLINE,
627    [AC_MSG_CHECKING(for inline)
628    save_CFLAGS="$CFLAGS"
629    CFLAGS="$V_CCOPT"
630    AC_CACHE_VAL(ac_cv_lbl_inline, [
631	ac_cv_lbl_inline=""
632	ac_lbl_cc_inline=no
633	for ac_lbl_inline in inline __inline__ __inline
634	do
635	    AC_TRY_COMPILE(
636		[#define inline $ac_lbl_inline
637		static inline struct iltest *foo(void);
638		struct iltest {
639		    int iltest1;
640		    int iltest2;
641		};
642
643		static inline struct iltest *
644		foo()
645		{
646		    static struct iltest xxx;
647
648		    return &xxx;
649		}],,ac_lbl_cc_inline=yes,)
650	    if test "$ac_lbl_cc_inline" = yes ; then
651		break;
652	    fi
653	done
654	if test "$ac_lbl_cc_inline" = yes ; then
655	    ac_cv_lbl_inline=$ac_lbl_inline
656	fi])
657    CFLAGS="$save_CFLAGS"
658    if test ! -z "$ac_cv_lbl_inline" ; then
659	AC_MSG_RESULT($ac_cv_lbl_inline)
660    else
661	AC_MSG_RESULT(no)
662    fi
663    AC_DEFINE_UNQUOTED(inline, $ac_cv_lbl_inline, [Define as token for inline if inlining supported])])
664
665dnl
666dnl If using gcc, make sure we have ANSI ioctl definitions
667dnl
668dnl usage:
669dnl
670dnl	AC_LBL_FIXINCLUDES
671dnl
672AC_DEFUN(AC_LBL_FIXINCLUDES,
673    [if test "$GCC" = yes ; then
674	    AC_MSG_CHECKING(for ANSI ioctl definitions)
675	    AC_CACHE_VAL(ac_cv_lbl_gcc_fixincludes,
676		AC_TRY_COMPILE(
677		    [/*
678		     * This generates a "duplicate case value" when fixincludes
679		     * has not be run.
680		     */
681#		include <sys/types.h>
682#		include <sys/time.h>
683#		include <sys/ioctl.h>
684#		ifdef HAVE_SYS_IOCCOM_H
685#		include <sys/ioccom.h>
686#		endif],
687		    [switch (0) {
688		    case _IO('A', 1):;
689		    case _IO('B', 1):;
690		    }],
691		    ac_cv_lbl_gcc_fixincludes=yes,
692		    ac_cv_lbl_gcc_fixincludes=no))
693	    AC_MSG_RESULT($ac_cv_lbl_gcc_fixincludes)
694	    if test $ac_cv_lbl_gcc_fixincludes = no ; then
695		    # Don't cache failure
696		    unset ac_cv_lbl_gcc_fixincludes
697		    AC_MSG_ERROR(see the INSTALL for more info)
698	    fi
699    fi])
700
701dnl
702dnl Checks to see if union wait is used with WEXITSTATUS()
703dnl
704dnl usage:
705dnl
706dnl	AC_LBL_UNION_WAIT
707dnl
708dnl results:
709dnl
710dnl	DECLWAITSTATUS (defined)
711dnl
712AC_DEFUN(AC_LBL_UNION_WAIT,
713    [AC_MSG_CHECKING(if union wait is used)
714    AC_CACHE_VAL(ac_cv_lbl_union_wait,
715	AC_TRY_COMPILE([
716#	include <sys/types.h>
717#	include <sys/wait.h>],
718	    [int status;
719	    u_int i = WEXITSTATUS(status);
720	    u_int j = waitpid(0, &status, 0);],
721	    ac_cv_lbl_union_wait=no,
722	    ac_cv_lbl_union_wait=yes))
723    AC_MSG_RESULT($ac_cv_lbl_union_wait)
724    if test $ac_cv_lbl_union_wait = yes ; then
725	    AC_DEFINE(DECLWAITSTATUS,union wait,[type for wait])
726    else
727	    AC_DEFINE(DECLWAITSTATUS,int,[type for wait])
728    fi])
729
730dnl
731dnl Checks to see if -R is used
732dnl
733dnl usage:
734dnl
735dnl	AC_LBL_HAVE_RUN_PATH
736dnl
737dnl results:
738dnl
739dnl	ac_cv_lbl_have_run_path (yes or no)
740dnl
741AC_DEFUN(AC_LBL_HAVE_RUN_PATH,
742    [AC_MSG_CHECKING(for ${CC-cc} -R)
743    AC_CACHE_VAL(ac_cv_lbl_have_run_path,
744	[echo 'main(){}' > conftest.c
745	${CC-cc} -o conftest conftest.c -R/a1/b2/c3 >conftest.out 2>&1
746	if test ! -s conftest.out ; then
747		ac_cv_lbl_have_run_path=yes
748	else
749		ac_cv_lbl_have_run_path=no
750	fi
751	rm -f -r conftest*])
752    AC_MSG_RESULT($ac_cv_lbl_have_run_path)
753    ])
754
755dnl
756dnl Checks to see if unaligned memory accesses fail
757dnl
758dnl usage:
759dnl
760dnl	AC_LBL_UNALIGNED_ACCESS
761dnl
762dnl results:
763dnl
764dnl	LBL_ALIGN (DEFINED)
765dnl
766AC_DEFUN(AC_LBL_UNALIGNED_ACCESS,
767    [AC_MSG_CHECKING(if unaligned accesses fail)
768    AC_CACHE_VAL(ac_cv_lbl_unaligned_fail,
769	[case "$host_cpu" in
770
771	#
772	# These are CPU types where:
773	#
774	#	the CPU faults on an unaligned access, but at least some
775	#	OSes that support that CPU catch the fault and simulate
776	#	the unaligned access (e.g., Alpha/{Digital,Tru64} UNIX) -
777	#	the simulation is slow, so we don't want to use it;
778	#
779	#	the CPU, I infer (from the old
780	#
781	# XXX: should also check that they don't do weird things (like on arm)
782	#
783	#	comment) doesn't fault on unaligned accesses, but doesn't
784	#	do a normal unaligned fetch, either (e.g., presumably, ARM);
785	#
786	#	for whatever reason, the test program doesn't work
787	#	(this has been claimed to be the case for several of those
788	#	CPUs - I don't know what the problem is; the problem
789	#	was reported as "the test program dumps core" for SuperH,
790	#	but that's what the test program is *supposed* to do -
791	#	it dumps core before it writes anything, so the test
792	#	for an empty output file should find an empty output
793	#	file and conclude that unaligned accesses don't work).
794	#
795	# This run-time test won't work if you're cross-compiling, so
796	# in order to support cross-compiling for a particular CPU,
797	# we have to wire in the list of CPU types anyway, as far as
798	# I know, so perhaps we should just have a set of CPUs on
799	# which we know it doesn't work, a set of CPUs on which we
800	# know it does work, and have the script just fail on other
801	# cpu types and update it when such a failure occurs.
802	#
803	alpha*|arm*|bfin*|hp*|mips*|sh*|sparc*|ia64|nv1)
804		ac_cv_lbl_unaligned_fail=yes
805		;;
806
807	*)
808		cat >conftest.c <<EOF
809#		include <sys/types.h>
810#		include <sys/wait.h>
811#		include <stdio.h>
812		unsigned char a[[5]] = { 1, 2, 3, 4, 5 };
813		main() {
814		unsigned int i;
815		pid_t pid;
816		int status;
817		/* avoid "core dumped" message */
818		pid = fork();
819		if (pid <  0)
820			exit(2);
821		if (pid > 0) {
822			/* parent */
823			pid = waitpid(pid, &status, 0);
824			if (pid < 0)
825				exit(3);
826			exit(!WIFEXITED(status));
827		}
828		/* child */
829		i = *(unsigned int *)&a[[1]];
830		printf("%d\n", i);
831		exit(0);
832		}
833EOF
834		${CC-cc} -o conftest $CFLAGS $CPPFLAGS $LDFLAGS \
835		    conftest.c $LIBS >/dev/null 2>&1
836		if test ! -x conftest ; then
837			dnl failed to compile for some reason
838			ac_cv_lbl_unaligned_fail=yes
839		else
840			./conftest >conftest.out
841			if test ! -s conftest.out ; then
842				ac_cv_lbl_unaligned_fail=yes
843			else
844				ac_cv_lbl_unaligned_fail=no
845			fi
846		fi
847		rm -f -r conftest* core core.conftest
848		;;
849	esac])
850    AC_MSG_RESULT($ac_cv_lbl_unaligned_fail)
851    if test $ac_cv_lbl_unaligned_fail = yes ; then
852	    AC_DEFINE(LBL_ALIGN,1,[if unaligned access fails])
853    fi])
854
855dnl
856dnl If the file .devel exists:
857dnl	Add some warning flags if the compiler supports them
858dnl	If an os prototype include exists, symlink os-proto.h to it
859dnl
860dnl usage:
861dnl
862dnl	AC_LBL_DEVEL(copt)
863dnl
864dnl results:
865dnl
866dnl	$1 (copt appended)
867dnl	HAVE_OS_PROTO_H (defined)
868dnl	os-proto.h (symlinked)
869dnl
870AC_DEFUN(AC_LBL_DEVEL,
871    [rm -f os-proto.h
872    if test "${LBL_CFLAGS+set}" = set; then
873	    $1="$$1 ${LBL_CFLAGS}"
874    fi
875    if test -f .devel ; then
876	    #
877	    # Skip all the warning option stuff on some compilers.
878	    #
879	    if test "$ac_lbl_cc_dont_try_gcc_dashW" != yes; then
880		    AC_LBL_CHECK_UNKNOWN_WARNING_OPTION_ERROR()
881		    AC_LBL_CHECK_COMPILER_OPT($1, -Wall)
882		    AC_LBL_CHECK_COMPILER_OPT($1, -Wsign-compare)
883		    AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-prototypes)
884		    AC_LBL_CHECK_COMPILER_OPT($1, -Wstrict-prototypes)
885		    AC_LBL_CHECK_COMPILER_OPT($1, -Wshadow)
886		    AC_LBL_CHECK_COMPILER_OPT($1, -Wdeclaration-after-statement)
887		    AC_LBL_CHECK_COMPILER_OPT($1, -Wused-but-marked-unused)
888		    AC_LBL_CHECK_COMPILER_OPT($1, -Wdocumentation)
889		    AC_LBL_CHECK_COMPILER_OPT($1, -Wcomma)
890		    AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-noreturn)
891		    # Warns about safeguards added in case the enums are
892		    # extended
893		    # AC_LBL_CHECK_COMPILER_OPT($1, -Wcovered-switch-default)
894		    AC_LBL_CHECK_COMPILER_OPT($1, -Wmissing-variable-declarations)
895		    AC_LBL_CHECK_COMPILER_OPT($1, -Wunused-parameter)
896		    AC_LBL_CHECK_COMPILER_OPT($1, -Wformat-nonliteral)
897		    #
898		    # This can cause problems with ntohs(), ntohl(),
899		    # htons(), and htonl() on some platforms, such
900		    # as OpenBSD 6.3 with Clang 5.0.1.  I guess the
901		    # problem is that the macro that ultimately does
902		    # the byte-swapping involves a conditional
903		    # expression that tests whether the value being
904		    # swapped is a compile-time constant or not,
905		    # using __builtin_constant_p(), and, depending
906		    # on whether it is, does a compile-time swap or
907		    # a run-time swap; perhaps the compiler always
908		    # considers one of the two results of the
909		    # conditional expressin is never evaluated,
910		    # because the conditional check is done at
911		    # compile time, and thus always says "that
912		    # expression is never executed".
913		    #
914		    # (Perhaps there should be a way of flagging
915		    # an expression that you *want* evaluated at
916		    # compile time, so that the compiler 1) warns
917		    # if it *can't* be evaluated at compile time
918		    # and 2) *doesn't* warn that the true or false
919		    # branch will never be reached.)
920		    #
921		    AC_LBL_CHECK_COMPILER_OPT($1, -Wunreachable-code,
922		      [
923#include <arpa/inet.h>
924
925unsigned short
926testme(unsigned short a)
927{
928	return ntohs(a);
929}
930		      ],
931		      [generates warnings from ntohs()])
932	    fi
933	    AC_LBL_CHECK_DEPENDENCY_GENERATION_OPT()
934	    #
935	    # We used to set -n32 for IRIX 6 when not using GCC (presumed
936	    # to mean that we're using MIPS C or MIPSpro C); it specified
937	    # the "new" faster 32-bit ABI, introduced in IRIX 6.2.  I'm
938	    # not sure why that would be something to do *only* with a
939	    # .devel file; why should the ABI for which we produce code
940	    # depend on .devel?
941	    #
942	    os=`echo $host_os | sed -e 's/\([[0-9]][[0-9]]*\)[[^0-9]].*$/\1/'`
943	    name="lbl/os-$os.h"
944	    if test -f $name ; then
945		    ln -s $name os-proto.h
946		    AC_DEFINE(HAVE_OS_PROTO_H, 1,
947			[if there's an os_proto.h for this platform, to use additional prototypes])
948	    else
949		    AC_MSG_WARN(can't find $name)
950	    fi
951    fi])
952
953dnl
954dnl Improved version of AC_CHECK_LIB
955dnl
956dnl Thanks to John Hawkinson (jhawk@mit.edu)
957dnl
958dnl usage:
959dnl
960dnl	AC_LBL_CHECK_LIB(LIBRARY, FUNCTION [, ACTION-IF-FOUND [,
961dnl	    ACTION-IF-NOT-FOUND [, OTHER-LIBRARIES]]])
962dnl
963dnl results:
964dnl
965dnl	LIBS
966dnl
967dnl XXX - "AC_LBL_LIBRARY_NET" was redone to use "AC_SEARCH_LIBS"
968dnl rather than "AC_LBL_CHECK_LIB", so this isn't used any more.
969dnl We keep it around for reference purposes in case it's ever
970dnl useful in the future.
971dnl
972
973define(AC_LBL_CHECK_LIB,
974[AC_MSG_CHECKING([for $2 in -l$1])
975dnl Use a cache variable name containing the library, function
976dnl name, and extra libraries to link with, because the test really is
977dnl for library $1 defining function $2, when linked with potinal
978dnl library $5, not just for library $1.  Separate tests with the same
979dnl $1 and different $2's or $5's may have different results.
980ac_lib_var=`echo $1['_']$2['_']$5 | sed 'y%./+- %__p__%'`
981AC_CACHE_VAL(ac_cv_lbl_lib_$ac_lib_var,
982[ac_save_LIBS="$LIBS"
983LIBS="-l$1 $5 $LIBS"
984AC_TRY_LINK(dnl
985ifelse([$2], [main], , dnl Avoid conflicting decl of main.
986[/* Override any gcc2 internal prototype to avoid an error.  */
987]ifelse(AC_LANG, CPLUSPLUS, [#ifdef __cplusplus
988extern "C"
989#endif
990])dnl
991[/* We use char because int might match the return type of a gcc2
992    builtin and then its argument prototype would still apply.  */
993char $2();
994]),
995	    [$2()],
996	    eval "ac_cv_lbl_lib_$ac_lib_var=yes",
997	    eval "ac_cv_lbl_lib_$ac_lib_var=no")
998LIBS="$ac_save_LIBS"
999])dnl
1000if eval "test \"`echo '$ac_cv_lbl_lib_'$ac_lib_var`\" = yes"; then
1001  AC_MSG_RESULT(yes)
1002  ifelse([$3], ,
1003[changequote(, )dnl
1004  ac_tr_lib=HAVE_LIB`echo $1 | sed -e 's/[^a-zA-Z0-9_]/_/g' \
1005    -e 'y/abcdefghijklmnopqrstuvwxyz/ABCDEFGHIJKLMNOPQRSTUVWXYZ/'`
1006changequote([, ])dnl
1007  AC_DEFINE_UNQUOTED($ac_tr_lib)
1008  LIBS="-l$1 $LIBS"
1009], [$3])
1010else
1011  AC_MSG_RESULT(no)
1012ifelse([$4], , , [$4
1013])dnl
1014fi
1015])
1016
1017dnl
1018dnl AC_LBL_LIBRARY_NET
1019dnl
1020dnl This test is for network applications that need socket functions and
1021dnl getaddrinfo()/getnameinfo()-ish functions.  We now require
1022dnl getaddrinfo() and getnameinfo().  We also prefer versions of
1023dnl recvmsg() that conform to the Single UNIX Specification, so that we
1024dnl can check whether a datagram received with recvmsg() was truncated
1025dnl when received due to the buffer being too small.
1026dnl
1027dnl On most operating systems, they're available in the system library.
1028dnl
1029dnl Under Solaris, we need to link with libsocket and libnsl to get
1030dnl getaddrinfo() and getnameinfo() and, if we have libxnet, we need to
1031dnl link with libxnet before libsocket to get a version of recvmsg()
1032dnl that conforms to the Single UNIX Specification.
1033dnl
1034dnl We use getaddrinfo() because we want a portable thread-safe way
1035dnl of getting information for a host name or port; there exist _r
1036dnl versions of gethostbyname() and getservbyname() on some platforms,
1037dnl but not on all platforms.
1038dnl
1039AC_DEFUN(AC_LBL_LIBRARY_NET, [
1040    #
1041    # Most operating systems have getaddrinfo() in the default searched
1042    # libraries (i.e. libc).  Check there first.
1043    #
1044    AC_CHECK_FUNC(getaddrinfo,,
1045    [
1046	#
1047	# Not found in the standard system libraries.
1048	# Try libsocket, which requires libnsl.
1049	#
1050	AC_CHECK_LIB(socket, getaddrinfo,
1051	[
1052	    #
1053	    # OK, we found it in libsocket.
1054	    #
1055	    LIBS="-lsocket -lnsl $LIBS"
1056	],
1057	[
1058	    #
1059	    # We didn't find it.
1060	    #
1061	    AC_MSG_ERROR([getaddrinfo is required, but wasn't found])
1062	], -lnsl)
1063
1064	#
1065	# OK, do we have recvmsg() in libxnet?
1066	# We also link with libsocket and libnsl.
1067	#
1068	AC_CHECK_LIB(xnet, recvmsg,
1069	[
1070	    #
1071	    # Yes - link with it as well.
1072	    #
1073	    LIBS="-lxnet $LIBS"
1074	], , -lsocket -lnsl)
1075    ])
1076    # DLPI needs putmsg under HPUX so test for -lstr while we're at it
1077    AC_SEARCH_LIBS(putmsg, str)
1078])
1079