include(libm4.m4)# -*- Autoconf -*- # This file is part of Autoconf. # Driver and redefinitions of some Autoconf macros for autoheader. # Copyright (C) 1994, 95, 99, 2000 Free Software Foundation, Inc. # # This program is free software; you can redistribute it and/or modify # it under the terms of the GNU General Public License as published by # the Free Software Foundation; either version 2, or (at your option) # any later version. # # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU General Public License for more details. # # You should have received a copy of the GNU General Public License # along with this program; if not, write to the Free Software # Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA # 02111-1307, USA. # # Originally written by Roland McGrath. # # Do not sinclude acsite.m4 here, because it may not be installed # yet when Autoconf is frozen. # Do not sinclude ./aclocal.m4 here, to prevent it from being frozen. m4_include(acversion.m4) m4_include(acgeneral.m4) m4_include(acspecific.m4) m4_include(acoldnames.m4) m4_namespace_push(autoheader) # AH_DEFUN(MACRO, VALUE) # ---------------------- # # Assign VALUE *and* the current value of MACRO to MACRO, in the # namespace `autoheader'. We enter the namespace `autoheader' when # running autoheader. # # There are several motivations for not just defining to be equivalent to # AUTOHEADER-NAME. # # Let autoconf::AC_FOO (abbreviated AC_FOO below) be # | AC_DEFINE(FOO, 1) # | AC_DEFINE(BAR, 1) # | AC_DEFINE(BAZ, 1, The value of BAZ.) # Let autoheader::AC_FOO (abbreviated AH_FOO below) be # | AH_TEMPLATE(FOO, The value of FOO.) # # If we hook AC_FOO to be AH_FOO only, then only FOO will be templated. # If we hook AC_FOO to expand in both the former AC_FOO and AH_FOO, then # both FOO and BAZ are templated. # # Additionaly, if AC_FOO is hooked to AH_FOO only, then we loose track # of the other AC_DEFINE, and the autoheader machinery (see the use of # the shell variable SYMS in AC_TEMPLATE) won't be able to see that BAR # is not templated at all. Hooking AC_FOO on both its AC_ and AH_ faces # makes sure we keep track of non templated DEFINEs. # # # Finally, if AC_FOO requires a macro which AC_DEFINEs a symbol, # then, if we used AH_FOO only, the required macro would not be # expanded, thus its symbols would not be prototyped. define(AH_DEFUN, [m4_namespace_define(autoheader, [$1], defn([$1]) [$2])]) # The definition of `AH_DEFUN' above is used for accumulating the # definitions before entering the `autoheader' namespace. Once we # enter the autoheader::, `AH_DEFUN' must be understood as immediatly # defining. This happens when we read user m4 files. m4_define([autoheader::AH_DEFUN], defn([m4_define])) m4_namespace_register([AH_DEFUN], [autoheader]) # These are alternate definitions of some macros, which produce # strings in the output marked with "@@@" so we can easily extract # the information we want. The `#' at the end of the first line of # each definition seems to be necessary to prevent m4 from eating # the newline, which makes the @@@ not always be at the beginning of # a line. # Autoheader is not the right program to complain about cross-compiling. AH_DEFUN([AC_TRY_RUN], [$2 $3 $4]) # AH_DEFINE(VARIABLE, [VALUE], [DESCRIPTION]) # ------------------------------------------- # When running autoheader, this macro replaces AC_DEFINE and # AC_DEFINE_UNQUOTED. # # If DESCRIPTION is not given, then there is a risk that VARIABLE will # not be properly templated. To control later that it has been # templated elsewhere, store VARIABLE in a shell growing string, SYMS. AH_DEFUN([AH_DEFINE], [ifval([$3], [AH_TEMPLATE([$1], [$3])], [# dnl Ignore CPP macro arguments. @@@syms="$syms patsubst($1, [(.*$])"@@@ ])]) AH_DEFUN([AC_DEFINE], [AH_DEFINE($@)]) AH_DEFUN([AC_DEFINE_UNQUOTED], [AH_DEFINE($@)]) # AH_TEMPLATE(KEY, DESCRIPTION) # ----------------------------- # Issue an autoheader template for KEY, i.e., a comment composed # of DESCRIPTION (properly wrapped), and then #undef KEY. AH_DEFUN([AH_TEMPLATE], [AH_VERBATIM([$1], m4_wrap([$2 */], [ ], [/* ])[ #undef $1])]) # AH_VERBATIM(KEY, TEMPLATE) # -------------------------- # If KEY is direct (i.e., no indirection such as in KEY=$my_func which may # occur if there is AC_CHECK_FUNCS($my_func)), issue an autoheader TEMPLATE # associated to the KEY. Otherwise, do nothing. # TEMPLATE is output as is, with no formating. AH_DEFUN([AH_VERBATIM], [AC_VAR_IF_INDIR([$1],, [# @@@ ac_verbatim_$1="\ _AC_SH_QUOTE([$2])" @@@ ])]) # FIXME: To be rigorous, this should not be systematic: depending # upon the arguments of AC_CHECK_LIB, we might not AC_DEFINE. AH_DEFUN([AC_CHECK_LIB], [AH_TEMPLATE(AC_TR_CPP(HAVE_LIB$1), [Define if you have the `]$1[' library (-l]$1[).]) # Success $3 # Failure $4]) AH_DEFUN([AH_CHECK_HEADERS], [AC_FOREACH([AC_Header], [$1], [AH_TEMPLATE(AC_TR_CPP(HAVE_[]AC_Header), [Define if you have the <]AC_Header[> header file.]) # Success $2 # Failure $3])]) AH_DEFUN([AC_CHECK_HEADERS], [AH_CHECK_HEADERS($@)]) AH_DEFUN([_AC_CHECK_HEADERS_DIRENT], [AH_CHECK_HEADERS($@)]) AH_DEFUN([AC_CHECK_FILES], [AC_FOREACH([AC_File], [$1], [AH_TEMPLATE(AC_TR_CPP([HAVE_]AC_File), [Define if you have the file `]AC_File['.]) # Success $2 # Failure $3])]) AH_DEFUN([AC_CHECK_DECLS], [m4_foreach([AC_Symbol], [$1], [AH_TEMPLATE(AC_TR_CPP([HAVE_DECL_]AC_Symbol), [Define to 1 if you have the declaration of `]AC_Symbol[', and to 0 if you don't.]) # Success $2 # Failure $3])]) AH_DEFUN([AC_CHECK_FUNCS], [AC_FOREACH([AC_Func], [$1], [AH_TEMPLATE(AC_TR_CPP(HAVE_[]AC_Func), [Define if you have the `]AC_Func[' function.]) # Success $2 # Failure $3]) ]) AH_DEFUN([AC_CHECK_SIZEOF], [AH_TEMPLATE(AC_TR_CPP(SIZEOF_$1), [The number of bytes in a `]$1['.])]) AH_DEFUN([AC_PROG_LEX], [AC_CHECK_LIB(fl) AC_CHECK_LIB(l)]) AH_DEFUN([AC_CHECK_MEMBERS], [m4_foreach([AC_Member], [$1], [pushdef(AC_Member_Aggregate, [patsubst(AC_Member, [\.[^.]*])]) pushdef(AC_Member_Member, [patsubst(AC_Member, [.*\.])]) AH_TEMPLATE(AC_TR_CPP(HAVE_[]AC_Member), [Define if `]AC_Member_Member[' is member of] [`]AC_Member_Aggregate['.]) popdef([AC_Member_Member]) popdef([AC_Member_Aggregate]) # Success $2 # Failure $3]) ]) # _AC_CHECK_TYPE_OLD(TYPE, DEFAULT) # --------------------------------- AH_DEFUN([_AC_CHECK_TYPE_OLD], [AH_TEMPLATE([$1], [Define to `$2' if does not define.])]) # AC_FUNC_ALLOCA # -------------- AH_DEFUN([AC_FUNC_ALLOCA], [AH_VERBATIM([STACK_DIRECTION], [/* If using the C implementation of alloca, define if you know the direction of stack growth for your system; otherwise it will be automatically deduced at run-time. STACK_DIRECTION > 0 => grows toward higher addresses STACK_DIRECTION < 0 => grows toward lower addresses STACK_DIRECTION = 0 => direction of growth unknown */ #undef STACK_DIRECTION]) ])dnl AH_FUNC_ALLOCA # AH_CHECK_TYPES((TYPES, ...)) # ---------------------------- AH_DEFUN([AC_CHECK_TYPES], [m4_foreach([AC_Type], [$1], [AH_TEMPLATE(AC_TR_CPP(HAVE_[]AC_Type), [Define if the system has the type `]AC_Type['.]) # Success $2 # Failure $3]) ]) AH_DEFUN([AC_C_CHAR_UNSIGNED], [AH_VERBATIM([__CHAR_UNSIGNED__], [/* Define if type `char' is unsigned and you are not using gcc. */ #ifndef __CHAR_UNSIGNED__ # undef __CHAR_UNSIGNED__ #endif]) ]) AH_DEFUN([AC_AIX], [AH_VERBATIM([_ALL_SOURCE], [/* Define if on AIX 3. System headers sometimes define this. We just want to avoid a redefinition error message. */ #ifndef _ALL_SOURCE # undef _ALL_SOURCE #endif]) ]) AH_DEFUN([AC_F77_WRAPPERS], [AH_TEMPLATE([F77_FUNC], [Define to a macro that performs the appropriate name mangling on its argument to make the C identifier, which *does not* contain underscores, match the name mangling scheme of the Fortran 77 compiler.]) AH_TEMPLATE([F77_FUNC_], [Define to a macro that performs the appropriate name mangling on its argument to make the C identifier, which *does* contain underscores, match the name mangling scheme of the Fortran 77 compiler.])]) AH_DEFUN([AC_CONFIG_HEADERS], [@@@config_h=patsubst($1, [ .*$], [])@@@ ]) # Enter the `autoheader' name space m4_enable(autoheader)