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

# include_next.m4 serial 12
dnl Copyright (C) 2006-2009 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 IBM C 9.0, 10.1 (original versions, prior to the 2009-01 updates) on
     dnl AIX 6.1 support include_next when used as first preprocessor directive
     dnl in a file, but not when preceded by another include directive. Check
     dnl for this bug by including <stdio.h>.
     dnl Additionally, with this same compiler, include_next is a no-op when
     dnl used in a header file that was included by specifying its absolute
     dnl file name. Despite these two bugs, include_next is used in the
     dnl compiler's <math.h>. By virtue of the second bug, we need to use
     dnl include_next 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
f240aacb LC	1	# include_next.m4 serial 12
f240aacb LC	2	dnl Copyright (C) 2006-2009 Free Software Foundation, Inc.
103dc4d4 LC	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
aa7a939c LC	34	mkdir conftestd1a conftestd1b conftestd2
f240aacb LC	35	dnl IBM C 9.0, 10.1 (original versions, prior to the 2009-01 updates) on
	36	dnl AIX 6.1 support include_next when used as first preprocessor directive
	37	dnl in a file, but not when preceded by another include directive. Check
	38	dnl for this bug by including <stdio.h>.
	39	dnl Additionally, with this same compiler, include_next is a no-op when
	40	dnl used in a header file that was included by specifying its absolute
	41	dnl file name. Despite these two bugs, include_next is used in the
	42	dnl compiler's <math.h>. By virtue of the second bug, we need to use
	43	dnl include_next as well in this case.
aa7a939c LC	44	cat <<EOF > conftestd1a/conftest.h
	45	#define DEFINED_IN_CONFTESTD1
	46	#include_next <conftest.h>
	47	#ifdef DEFINED_IN_CONFTESTD2
	48	int foo;
	49	#else
	50	#error "include_next doesn't work"
	51	#endif
	52	EOF
	53	cat <<EOF > conftestd1b/conftest.h
103dc4d4	54	#define DEFINED_IN_CONFTESTD1
aa7a939c	55	#include <stdio.h>
103dc4d4 LC	56	#include_next <conftest.h>
	57	#ifdef DEFINED_IN_CONFTESTD2
	58	int foo;
	59	#else
	60	#error "include_next doesn't work"
	61	#endif
	62	EOF
	63	cat <<EOF > conftestd2/conftest.h
	64	#ifndef DEFINED_IN_CONFTESTD1
	65	#error "include_next test doesn't work"
	66	#endif
	67	#define DEFINED_IN_CONFTESTD2
	68	EOF
aa7a939c LC	69	gl_save_CPPFLAGS="$CPPFLAGS"
aa7a939c LC	70	CPPFLAGS="$gl_save_CPPFLAGS -Iconftestd1b -Iconftestd2"
103dc4d4 LC	71	AC_COMPILE_IFELSE([#include <conftest.h>],
103dc4d4 LC	72	[gl_cv_have_include_next=yes],
aa7a939c LC	73	[CPPFLAGS="$gl_save_CPPFLAGS -Iconftestd1a -Iconftestd2"
	74	AC_COMPILE_IFELSE([#include <conftest.h>],
	75	[gl_cv_have_include_next=buggy],
	76	[gl_cv_have_include_next=no])
	77	])
	78	CPPFLAGS="$gl_save_CPPFLAGS"
	79	rm -rf conftestd1a conftestd1b conftestd2
103dc4d4	80	])
e65fc94b	81	PRAGMA_SYSTEM_HEADER=
103dc4d4	82	if test $gl_cv_have_include_next = yes; then
103dc4d4	83	INCLUDE_NEXT=include_next
aa7a939c	84	INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include_next
e65fc94b LC	85	if test -n "$GCC"; then
	86	PRAGMA_SYSTEM_HEADER='#pragma GCC system_header'
	87	fi
103dc4d4	88	else
aa7a939c LC	89	if test $gl_cv_have_include_next = buggy; then
	90	INCLUDE_NEXT=include
	91	INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include_next
	92	else
	93	INCLUDE_NEXT=include
	94	INCLUDE_NEXT_AS_FIRST_DIRECTIVE=include
	95	fi
103dc4d4 LC	96	fi
103dc4d4 LC	97	AC_SUBST([INCLUDE_NEXT])
aa7a939c	98	AC_SUBST([INCLUDE_NEXT_AS_FIRST_DIRECTIVE])
e65fc94b	99	AC_SUBST([PRAGMA_SYSTEM_HEADER])
103dc4d4 LC	100	])
	101
	102	# gl_CHECK_NEXT_HEADERS(HEADER1 HEADER2 ...)
	103	# ------------------------------------------
	104	# For each arg foo.h, if #include_next works, define NEXT_FOO_H to be
	105	# '<foo.h>'; otherwise define it to be
	106	# '"///usr/include/foo.h"', or whatever other absolute file name is suitable.
	107	# That way, a header file with the following line:
	108	# #@INCLUDE_NEXT@ @NEXT_FOO_H@
	109	# behaves (after sed substitution) as if it contained
	110	# #include_next <foo.h>
	111	# even if the compiler does not support include_next.
	112	# The three "///" are to pacify Sun C 5.8, which otherwise would say
	113	# "warning: #include of /usr/include/... may be non-portable".
	114	# Use `""', not `<>', so that the /// cannot be confused with a C99 comment.
	115	# Note: This macro assumes that the header file is not empty after
	116	# preprocessing, i.e. it does not only define preprocessor macros but also
	117	# provides some type/enum definitions or function/variable declarations.
	118	AC_DEFUN([gl_CHECK_NEXT_HEADERS],
	119	[
	120	AC_REQUIRE([gl_INCLUDE_NEXT])
aa7a939c	121	AC_REQUIRE([AC_CANONICAL_HOST])
103dc4d4 LC	122	AC_CHECK_HEADERS_ONCE([$1])
	123
	124	m4_foreach_w([gl_HEADER_NAME], [$1],
	125	[AS_VAR_PUSHDEF([gl_next_header],
	126	[gl_cv_next_]m4_quote(m4_defn([gl_HEADER_NAME])))
	127	if test $gl_cv_have_include_next = yes; then
	128	AS_VAR_SET([gl_next_header], ['<'gl_HEADER_NAME'>'])
	129	else
	130	AC_CACHE_CHECK(
	131	[absolute name of <]m4_quote(m4_defn([gl_HEADER_NAME]))[>],
	132	m4_quote(m4_defn([gl_next_header])),
	133	[AS_VAR_PUSHDEF([gl_header_exists],
	134	[ac_cv_header_]m4_quote(m4_defn([gl_HEADER_NAME])))
	135	if test AS_VAR_GET(gl_header_exists) = yes; then
	136	AC_LANG_CONFTEST(
	137	[AC_LANG_SOURCE(
	138	[[#include <]]m4_dquote(m4_defn([gl_HEADER_NAME]))[[>]]
	139	)])
aa7a939c LC	140	dnl AIX "xlc -E" and "cc -E" omit #line directives for header files
	141	dnl that contain only a #include of other header files and no
	142	dnl non-comment tokens of their own. This leads to a failure to
	143	dnl detect the absolute name of <dirent.h>, <signal.h>, <poll.h>
	144	dnl and others. The workaround is to force preservation of comments
	145	dnl through option -C. This ensures all necessary #line directives
	146	dnl are present. GCC supports option -C as well.
	147	case "$host_os" in
	148	aix*) gl_absname_cpp="$ac_cpp -C" ;;
	149	*) gl_absname_cpp="$ac_cpp" ;;
	150	esac
	151	dnl eval is necessary to expand gl_absname_cpp.
103dc4d4 LC	152	dnl Ultrix and Pyramid sh refuse to redirect output of eval,
	153	dnl so use subshell.
	154	AS_VAR_SET([gl_next_header],
aa7a939c	155	['"'`(eval "$gl_absname_cpp conftest.$ac_ext") 2>&AS_MESSAGE_LOG_FD \|
103dc4d4 LC	156	sed -n '\#/]m4_quote(m4_defn([gl_HEADER_NAME]))[#{
	157	s#."\(./]m4_quote(m4_defn([gl_HEADER_NAME]))[\)".*#\1#
	158	s#^/[^/]#//&#
	159	p
	160	q
	161	}'`'"'])
	162	else
	163	AS_VAR_SET([gl_next_header], ['<'gl_HEADER_NAME'>'])
	164	fi
	165	AS_VAR_POPDEF([gl_header_exists])])
	166	fi
	167	AC_SUBST(
	168	AS_TR_CPP([NEXT_]m4_quote(m4_defn([gl_HEADER_NAME]))),
	169	[AS_VAR_GET([gl_next_header])])
	170	AS_VAR_POPDEF([gl_next_header])])
	171	])