[bpt/guile.git] / m4 / include_next.m4

# include_next.m4 serial 10
dnl Copyright (C) 2006-2008 Free Software Foundation, Inc.
dnl This file is free software; the Free Software Foundation
dnl gives unlimited permission to copy and/or distribute it,
dnl with or without modifications, as long as this notice is preserved.

dnl From Paul Eggert and Derek Price.

dnl Sets INCLUDE_NEXT and PRAGMA_SYSTEM_HEADER.
dnl
dnl INCLUDE_NEXT expands to 'include_next' if the compiler supports it, or to
dnl 'include' otherwise.
dnl
dnl INCLUDE_NEXT_AS_FIRST_DIRECTIVE expands to 'include_next' if the compiler
dnl supports it in the special case that it is the first include directive in
dnl the given file, or to 'include' otherwise.
dnl
dnl PRAGMA_SYSTEM_HEADER can be used in files that contain #include_next,
dnl so as to avoid GCC warnings when the gcc option -pedantic is used.
dnl '#pragma GCC system_header' has the same effect as if the file was found
dnl through the include search path specified with '-isystem' options (as
dnl opposed to the search path specified with '-I' options). Namely, gcc
dnl does not warn about some things, and on some systems (Solaris and Interix)
dnl __STDC__ evaluates to 0 instead of to 1. The latter is an undesired side
dnl effect; we are therefore careful to use 'defined __STDC__' or '1' instead
dnl of plain '__STDC__'.

AC_DEFUN([gl_INCLUDE_NEXT],
[
  AC_LANG_PREPROC_REQUIRE()
  AC_CACHE_CHECK([whether the preprocessor supports include_next],
    [gl_cv_have_include_next],
    [rm -rf conftestd1a conftestd1b conftestd2
     mkdir conftestd1a conftestd1b conftestd2
     dnl The include of <stdio.h> is because IBM C 9.0 on AIX 6.1 supports
     dnl include_next when used as first preprocessor directive in a file,
     dnl but not when preceded by another include directive. Additionally,
     dnl with this same compiler, include_next is a no-op when used in a
     dnl header file that was included by specifying its absolute file name.
     dnl Despite these two bugs, include_next is used in the compiler's
     dnl <math.h>. By virtue of the second bug, we need to use include_next
     dnl as well in this case.
     cat <<EOF > conftestd1a/conftest.h
#define DEFINED_IN_CONFTESTD1
#include_next <conftest.h>
#ifdef DEFINED_IN_CONFTESTD2
int foo;
#else
#error "include_next doesn't work"
#endif
EOF
     cat <<EOF > conftestd1b/conftest.h
#define DEFINED_IN_CONFTESTD1
#include <stdio.h>
#include_next <conftest.h>
#ifdef DEFINED_IN_CONFTESTD2
int foo;
#else
#error "include_next doesn't work"
#endif
EOF
     cat <<EOF > conftestd2/conftest.h
#ifndef DEFINED_IN_CONFTESTD1
#error "include_next test doesn't work"
#endif
#define DEFINED_IN_CONFTESTD2
EOF
     gl_save_CPPFLAGS="$CPPFLAGS"
     CPPFLAGS="$gl_save_CPPFLAGS -Iconftestd1b -Iconftestd2"
     AC_COMPILE_IFELSE([#include <conftest.h>],
       [gl_cv_have_include_next=yes],
       [CPPFLAGS="$gl_save_CPPFLAGS -Iconftestd1a -Iconftestd2"
        AC_COMPILE_IFELSE([#include <conftest.h>],
          [gl_cv_have_include_next=buggy],
          [gl_cv_have_include_next=no])
       ])
     CPPFLAGS="$gl_save_CPPFLAGS"
     rm -rf conftestd1a conftestd1b conftestd2
    ])
  PRAGMA_SYSTEM_HEADER=
  if test $gl_cv_have_include_next = yes; then
    INCLUDE_NEXT=include_next
    INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include_next
    if test -n "$GCC"; then
      PRAGMA_SYSTEM_HEADER='#pragma GCC system_header'
    fi
  else
    if test $gl_cv_have_include_next = buggy; then
      INCLUDE_NEXT=include
      INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include_next
    else
      INCLUDE_NEXT=include
      INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include
    fi
  fi
  AC_SUBST([INCLUDE_NEXT])
  AC_SUBST([INCLUDE_NEXT_AS_FIRST_DIRECTIVE])
  AC_SUBST([PRAGMA_SYSTEM_HEADER])
])

# gl_CHECK_NEXT_HEADERS(HEADER1 HEADER2 ...)
# ------------------------------------------
# For each arg foo.h, if #include_next works, define NEXT_FOO_H to be
# '<foo.h>'; otherwise define it to be
# '"///usr/include/foo.h"', or whatever other absolute file name is suitable.
# That way, a header file with the following line:
#	#@INCLUDE_NEXT@ @NEXT_FOO_H@
# behaves (after sed substitution) as if it contained
#	#include_next <foo.h>
# even if the compiler does not support include_next.
# The three "///" are to pacify Sun C 5.8, which otherwise would say
# "warning: #include of /usr/include/... may be non-portable".
# Use `""', not `<>', so that the /// cannot be confused with a C99 comment.
# Note: This macro assumes that the header file is not empty after
# preprocessing, i.e. it does not only define preprocessor macros but also
# provides some type/enum definitions or function/variable declarations.
AC_DEFUN([gl_CHECK_NEXT_HEADERS],
[
  AC_REQUIRE([gl_INCLUDE_NEXT])
  AC_REQUIRE([AC_CANONICAL_HOST])
  AC_CHECK_HEADERS_ONCE([$1])

  m4_foreach_w([gl_HEADER_NAME], [$1],
    [AS_VAR_PUSHDEF([gl_next_header],
		    [gl_cv_next_]m4_quote(m4_defn([gl_HEADER_NAME])))
     if test $gl_cv_have_include_next = yes; then
       AS_VAR_SET([gl_next_header], ['<'gl_HEADER_NAME'>'])
     else
       AC_CACHE_CHECK(
	 [absolute name of <]m4_quote(m4_defn([gl_HEADER_NAME]))[>],
	 m4_quote(m4_defn([gl_next_header])),
	 [AS_VAR_PUSHDEF([gl_header_exists],
			 [ac_cv_header_]m4_quote(m4_defn([gl_HEADER_NAME])))
	  if test AS_VAR_GET(gl_header_exists) = yes; then
	    AC_LANG_CONFTEST(
	      [AC_LANG_SOURCE(
		 [[#include <]]m4_dquote(m4_defn([gl_HEADER_NAME]))[[>]]
	       )])
	    dnl AIX "xlc -E" and "cc -E" omit #line directives for header files
	    dnl that contain only a #include of other header files and no
	    dnl non-comment tokens of their own. This leads to a failure to
	    dnl detect the absolute name of <dirent.h>, <signal.h>, <poll.h>
	    dnl and others. The workaround is to force preservation of comments
	    dnl through option -C. This ensures all necessary #line directives
	    dnl are present. GCC supports option -C as well.
	    case "$host_os" in
	      aix*) gl_absname_cpp="$ac_cpp -C" ;;
	      *)    gl_absname_cpp="$ac_cpp" ;;
	    esac
	    dnl eval is necessary to expand gl_absname_cpp.
	    dnl Ultrix and Pyramid sh refuse to redirect output of eval,
	    dnl so use subshell.
	    AS_VAR_SET([gl_next_header],
	      ['"'`(eval "$gl_absname_cpp conftest.$ac_ext") 2>&AS_MESSAGE_LOG_FD |
	       sed -n '\#/]m4_quote(m4_defn([gl_HEADER_NAME]))[#{
		 s#.*"\(.*/]m4_quote(m4_defn([gl_HEADER_NAME]))[\)".*#\1#
		 s#^/[^/]#//&#
		 p
		 q
	       }'`'"'])
	  else
	    AS_VAR_SET([gl_next_header], ['<'gl_HEADER_NAME'>'])
	  fi
	  AS_VAR_POPDEF([gl_header_exists])])
     fi
     AC_SUBST(
       AS_TR_CPP([NEXT_]m4_quote(m4_defn([gl_HEADER_NAME]))),
       [AS_VAR_GET([gl_next_header])])
     AS_VAR_POPDEF([gl_next_header])])
])
Commit	Line	Data
aa7a939c	1	# include_next.m4 serial 10
103dc4d4 LC	2	dnl Copyright (C) 2006-2008 Free Software Foundation, Inc.
	3	dnl This file is free software; the Free Software Foundation
	4	dnl gives unlimited permission to copy and/or distribute it,
	5	dnl with or without modifications, as long as this notice is preserved.
	6
	7	dnl From Paul Eggert and Derek Price.
	8
e65fc94b LC	9	dnl Sets INCLUDE_NEXT and PRAGMA_SYSTEM_HEADER.
	10	dnl
	11	dnl INCLUDE_NEXT expands to 'include_next' if the compiler supports it, or to
	12	dnl 'include' otherwise.
	13	dnl
aa7a939c LC	14	dnl INCLUDE_NEXT_AS_FIRST_DIRECTIVE expands to 'include_next' if the compiler
	15	dnl supports it in the special case that it is the first include directive in
	16	dnl the given file, or to 'include' otherwise.
	17	dnl
e65fc94b LC	18	dnl PRAGMA_SYSTEM_HEADER can be used in files that contain #include_next,
	19	dnl so as to avoid GCC warnings when the gcc option -pedantic is used.
	20	dnl '#pragma GCC system_header' has the same effect as if the file was found
	21	dnl through the include search path specified with '-isystem' options (as
	22	dnl opposed to the search path specified with '-I' options). Namely, gcc
	23	dnl does not warn about some things, and on some systems (Solaris and Interix)
	24	dnl __STDC__ evaluates to 0 instead of to 1. The latter is an undesired side
	25	dnl effect; we are therefore careful to use 'defined __STDC__' or '1' instead
	26	dnl of plain '__STDC__'.
	27
103dc4d4 LC	28	AC_DEFUN([gl_INCLUDE_NEXT],
	29	[
	30	AC_LANG_PREPROC_REQUIRE()
	31	AC_CACHE_CHECK([whether the preprocessor supports include_next],
	32	[gl_cv_have_include_next],
aa7a939c LC	33	[rm -rf conftestd1a conftestd1b conftestd2
	34	mkdir conftestd1a conftestd1b conftestd2
	35	dnl The include of <stdio.h> is because IBM C 9.0 on AIX 6.1 supports
	36	dnl include_next when used as first preprocessor directive in a file,
	37	dnl but not when preceded by another include directive. Additionally,
	38	dnl with this same compiler, include_next is a no-op when used in a
	39	dnl header file that was included by specifying its absolute file name.
	40	dnl Despite these two bugs, include_next is used in the compiler's
	41	dnl <math.h>. By virtue of the second bug, we need to use include_next
	42	dnl as well in this case.
	43	cat <<EOF > conftestd1a/conftest.h
	44	#define DEFINED_IN_CONFTESTD1
	45	#include_next <conftest.h>
	46	#ifdef DEFINED_IN_CONFTESTD2
	47	int foo;
	48	#else
	49	#error "include_next doesn't work"
	50	#endif
	51	EOF
	52	cat <<EOF > conftestd1b/conftest.h
103dc4d4	53	#define DEFINED_IN_CONFTESTD1
aa7a939c	54	#include <stdio.h>
103dc4d4 LC	55	#include_next <conftest.h>
	56	#ifdef DEFINED_IN_CONFTESTD2
	57	int foo;
	58	#else
	59	#error "include_next doesn't work"
	60	#endif
	61	EOF
	62	cat <<EOF > conftestd2/conftest.h
	63	#ifndef DEFINED_IN_CONFTESTD1
	64	#error "include_next test doesn't work"
	65	#endif
	66	#define DEFINED_IN_CONFTESTD2
	67	EOF
aa7a939c LC	68	gl_save_CPPFLAGS="$CPPFLAGS"
aa7a939c LC	69	CPPFLAGS="$gl_save_CPPFLAGS -Iconftestd1b -Iconftestd2"
103dc4d4 LC	70	AC_COMPILE_IFELSE([#include <conftest.h>],
103dc4d4 LC	71	[gl_cv_have_include_next=yes],
aa7a939c LC	72	[CPPFLAGS="$gl_save_CPPFLAGS -Iconftestd1a -Iconftestd2"
	73	AC_COMPILE_IFELSE([#include <conftest.h>],
	74	[gl_cv_have_include_next=buggy],
	75	[gl_cv_have_include_next=no])
	76	])
	77	CPPFLAGS="$gl_save_CPPFLAGS"
	78	rm -rf conftestd1a conftestd1b conftestd2
103dc4d4	79	])
e65fc94b	80	PRAGMA_SYSTEM_HEADER=
103dc4d4	81	if test $gl_cv_have_include_next = yes; then
103dc4d4	82	INCLUDE_NEXT=include_next
aa7a939c	83	INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include_next
e65fc94b LC	84	if test -n "$GCC"; then
	85	PRAGMA_SYSTEM_HEADER='#pragma GCC system_header'
	86	fi
103dc4d4	87	else
aa7a939c LC	88	if test $gl_cv_have_include_next = buggy; then
	89	INCLUDE_NEXT=include
	90	INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include_next
	91	else
	92	INCLUDE_NEXT=include
	93	INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include
	94	fi
103dc4d4 LC	95	fi
103dc4d4 LC	96	AC_SUBST([INCLUDE_NEXT])
aa7a939c	97	AC_SUBST([INCLUDE_NEXT_AS_FIRST_DIRECTIVE])
e65fc94b	98	AC_SUBST([PRAGMA_SYSTEM_HEADER])
103dc4d4 LC	99	])
	100
	101	# gl_CHECK_NEXT_HEADERS(HEADER1 HEADER2 ...)
	102	# ------------------------------------------
	103	# For each arg foo.h, if #include_next works, define NEXT_FOO_H to be
	104	# '<foo.h>'; otherwise define it to be
	105	# '"///usr/include/foo.h"', or whatever other absolute file name is suitable.
	106	# That way, a header file with the following line:
	107	# #@INCLUDE_NEXT@ @NEXT_FOO_H@
	108	# behaves (after sed substitution) as if it contained
	109	# #include_next <foo.h>
	110	# even if the compiler does not support include_next.
	111	# The three "///" are to pacify Sun C 5.8, which otherwise would say
	112	# "warning: #include of /usr/include/... may be non-portable".
	113	# Use `""', not `<>', so that the /// cannot be confused with a C99 comment.
	114	# Note: This macro assumes that the header file is not empty after
	115	# preprocessing, i.e. it does not only define preprocessor macros but also
	116	# provides some type/enum definitions or function/variable declarations.
	117	AC_DEFUN([gl_CHECK_NEXT_HEADERS],
	118	[
	119	AC_REQUIRE([gl_INCLUDE_NEXT])
aa7a939c	120	AC_REQUIRE([AC_CANONICAL_HOST])
103dc4d4 LC	121	AC_CHECK_HEADERS_ONCE([$1])
	122
	123	m4_foreach_w([gl_HEADER_NAME], [$1],
	124	[AS_VAR_PUSHDEF([gl_next_header],
	125	[gl_cv_next_]m4_quote(m4_defn([gl_HEADER_NAME])))
	126	if test $gl_cv_have_include_next = yes; then
	127	AS_VAR_SET([gl_next_header], ['<'gl_HEADER_NAME'>'])
	128	else
	129	AC_CACHE_CHECK(
	130	[absolute name of <]m4_quote(m4_defn([gl_HEADER_NAME]))[>],
	131	m4_quote(m4_defn([gl_next_header])),
	132	[AS_VAR_PUSHDEF([gl_header_exists],
	133	[ac_cv_header_]m4_quote(m4_defn([gl_HEADER_NAME])))
	134	if test AS_VAR_GET(gl_header_exists) = yes; then
	135	AC_LANG_CONFTEST(
	136	[AC_LANG_SOURCE(
	137	[[#include <]]m4_dquote(m4_defn([gl_HEADER_NAME]))[[>]]
	138	)])
aa7a939c LC	139	dnl AIX "xlc -E" and "cc -E" omit #line directives for header files
	140	dnl that contain only a #include of other header files and no
	141	dnl non-comment tokens of their own. This leads to a failure to
	142	dnl detect the absolute name of <dirent.h>, <signal.h>, <poll.h>
	143	dnl and others. The workaround is to force preservation of comments
	144	dnl through option -C. This ensures all necessary #line directives
	145	dnl are present. GCC supports option -C as well.
	146	case "$host_os" in
	147	aix*) gl_absname_cpp="$ac_cpp -C" ;;
	148	*) gl_absname_cpp="$ac_cpp" ;;
	149	esac
	150	dnl eval is necessary to expand gl_absname_cpp.
103dc4d4 LC	151	dnl Ultrix and Pyramid sh refuse to redirect output of eval,
	152	dnl so use subshell.
	153	AS_VAR_SET([gl_next_header],
aa7a939c	154	['"'`(eval "$gl_absname_cpp conftest.$ac_ext") 2>&AS_MESSAGE_LOG_FD \|
103dc4d4 LC	155	sed -n '\#/]m4_quote(m4_defn([gl_HEADER_NAME]))[#{
	156	s#."\(./]m4_quote(m4_defn([gl_HEADER_NAME]))[\)".*#\1#
	157	s#^/[^/]#//&#
	158	p
	159	q
	160	}'`'"'])
	161	else
	162	AS_VAR_SET([gl_next_header], ['<'gl_HEADER_NAME'>'])
	163	fi
	164	AS_VAR_POPDEF([gl_header_exists])])
	165	fi
	166	AC_SUBST(
	167	AS_TR_CPP([NEXT_]m4_quote(m4_defn([gl_HEADER_NAME]))),
	168	[AS_VAR_GET([gl_next_header])])
	169	AS_VAR_POPDEF([gl_next_header])])
	170	])