| /* A C macro for emitting warnings if a function is used. | |
| Copyright (C) 2010-2023 Free Software Foundation, Inc. | |
| This program is free software: you can redistribute it and/or modify it | |
| under the terms of the GNU Lesser General Public License as published | |
| by the Free Software Foundation; either version 2 of the License, 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 | |
| Lesser General Public License for more details. | |
| You should have received a copy of the GNU Lesser General Public License | |
| along with this program. If not, see <https://www.gnu.org/licenses/>. */ | |
| /* _GL_WARN_ON_USE (function, "literal string") issues a declaration | |
| for FUNCTION which will then trigger a compiler warning containing | |
| the text of "literal string" anywhere that function is called, if | |
| supported by the compiler. If the compiler does not support this | |
| feature, the macro expands to an unused extern declaration. | |
| _GL_WARN_ON_USE_ATTRIBUTE ("literal string") expands to the | |
| attribute used in _GL_WARN_ON_USE. If the compiler does not support | |
| this feature, it expands to empty. | |
| These macros are useful for marking a function as a potential | |
| portability trap, with the intent that "literal string" include | |
| instructions on the replacement function that should be used | |
| instead. | |
| _GL_WARN_ON_USE is for functions with 'extern' linkage. | |
| _GL_WARN_ON_USE_ATTRIBUTE is for functions with 'static' or 'inline' | |
| linkage. | |
| However, one of the reasons that a function is a portability trap is | |
| if it has the wrong signature. Declaring FUNCTION with a different | |
| signature in C is a compilation error, so this macro must use the | |
| same type as any existing declaration so that programs that avoid | |
| the problematic FUNCTION do not fail to compile merely because they | |
| included a header that poisoned the function. But this implies that | |
| _GL_WARN_ON_USE is only safe to use if FUNCTION is known to already | |
| have a declaration. Use of this macro implies that there must not | |
| be any other macro hiding the declaration of FUNCTION; but | |
| undefining FUNCTION first is part of the poisoning process anyway | |
| (although for symbols that are provided only via a macro, the result | |
| is a compilation error rather than a warning containing | |
| "literal string"). Also note that in C++, it is only safe to use if | |
| FUNCTION has no overloads. | |
| For an example, it is possible to poison 'getline' by: | |
| - adding a call to gl_WARN_ON_USE_PREPARE([[#include <stdio.h>]], | |
| [getline]) in configure.ac, which potentially defines | |
| HAVE_RAW_DECL_GETLINE | |
| - adding this code to a header that wraps the system <stdio.h>: | |
| #undef getline | |
| #if HAVE_RAW_DECL_GETLINE | |
| _GL_WARN_ON_USE (getline, "getline is required by POSIX 2008, but" | |
| "not universally present; use the gnulib module getline"); | |
| #endif | |
| It is not possible to directly poison global variables. But it is | |
| possible to write a wrapper accessor function, and poison that | |
| (less common usage, like &environ, will cause a compilation error | |
| rather than issue the nice warning, but the end result of informing | |
| the developer about their portability problem is still achieved): | |
| #if HAVE_RAW_DECL_ENVIRON | |
| static char *** | |
| rpl_environ (void) { return &environ; } | |
| _GL_WARN_ON_USE (rpl_environ, "environ is not always properly declared"); | |
| # undef environ | |
| # define environ (*rpl_environ ()) | |
| #endif | |
| or better (avoiding contradictory use of 'static' and 'extern'): | |
| #if HAVE_RAW_DECL_ENVIRON | |
| static char *** | |
| _GL_WARN_ON_USE_ATTRIBUTE ("environ is not always properly declared") | |
| rpl_environ (void) { return &environ; } | |
| # undef environ | |
| # define environ (*rpl_environ ()) | |
| #endif | |
| */ | |
| /* A compiler attribute is available in gcc versions 4.3.0 and later. */ | |
| /* Another compiler attribute is available in clang. */ | |
| /* Verify the existence of the function. */ | |
| /* _GL_WARN_ON_USE_CXX (function, rettype_gcc, rettype_clang, parameters_and_attributes, "message") | |
| is like _GL_WARN_ON_USE (function, "message"), except that in C++ mode the | |
| function is declared with the given prototype, consisting of return type, | |
| parameters, and attributes. | |
| This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does | |
| not work in this case. */ | |
| /* A compiler attribute is available in gcc versions 4.3.0 and later. */ | |
| /* Another compiler attribute is available in clang. */ | |
| /* Verify the existence of the function. */ | |
| /* _GL_WARN_EXTERN_C declaration; | |
| performs the declaration with C linkage. */ | |