gl/m4/gnulib-common.m4

   1 # gnulib-common.m4 serial 72
   2 dnl Copyright (C) 2007-2022 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 AC_PREREQ([2.62])
   8
   9 # gl_COMMON
  10 # is expanded unconditionally through gnulib-tool magic.
  11 AC_DEFUN([gl_COMMON], [
  12   dnl Use AC_REQUIRE here, so that the code is expanded once only.
  13   AC_REQUIRE([gl_00GNULIB])
  14   AC_REQUIRE([gl_COMMON_BODY])
  15   AC_REQUIRE([gl_ZZGNULIB])
  16 ])
  17 AC_DEFUN([gl_COMMON_BODY], [
  18   AH_VERBATIM([_GL_GNUC_PREREQ],
  19 [/* True if the compiler says it groks GNU C version MAJOR.MINOR.  */
  20 #if defined __GNUC__ && defined __GNUC_MINOR__
  21 # define _GL_GNUC_PREREQ(major, minor) \
  22     ((major) < __GNUC__ + ((minor) <= __GNUC_MINOR__))
  23 #else
  24 # define _GL_GNUC_PREREQ(major, minor) 0
  25 #endif
  26 ])
  27   AH_VERBATIM([_Noreturn],
  28 [/* The _Noreturn keyword of C11.  */
  29 #ifndef _Noreturn
  30 # if (defined __cplusplus \
  31       && ((201103 <= __cplusplus && !(__GNUC__ == 4 && __GNUC_MINOR__ == 7)) \
  32           || (defined _MSC_VER && 1900 <= _MSC_VER)) \
  33       && 0)
  34     /* [[noreturn]] is not practically usable, because with it the syntax
  35          extern _Noreturn void func (...);
  36        would not be valid; such a declaration would only be valid with 'extern'
  37        and '_Noreturn' swapped, or without the 'extern' keyword.  However, some
  38        AIX system header files and several gnulib header files use precisely
  39        this syntax with 'extern'.  */
  40 #  define _Noreturn [[noreturn]]
  41 # elif ((!defined __cplusplus || defined __clang__) \
  42         && (201112 <= (defined __STDC_VERSION__ ? __STDC_VERSION__ : 0) \
  43             || (!defined __STRICT_ANSI__ \
  44                 && (_GL_GNUC_PREREQ (4, 7) \
  45                     || (defined __apple_build_version__ \
  46                         ? 6000000 <= __apple_build_version__ \
  47                         : 3 < __clang_major__ + (5 <= __clang_minor__))))))
  48    /* _Noreturn works as-is.  */
  49 # elif _GL_GNUC_PREREQ (2, 8) || defined __clang__ || 0x5110 <= __SUNPRO_C
  50 #  define _Noreturn __attribute__ ((__noreturn__))
  51 # elif 1200 <= (defined _MSC_VER ? _MSC_VER : 0)
  52 #  define _Noreturn __declspec (noreturn)
  53 # else
  54 #  define _Noreturn
  55 # endif
  56 #endif
  57 ])
  58   AH_VERBATIM([isoc99_inline],
  59 [/* Work around a bug in Apple GCC 4.0.1 build 5465: In C99 mode, it supports
  60    the ISO C 99 semantics of 'extern inline' (unlike the GNU C semantics of
  61    earlier versions), but does not display it by setting __GNUC_STDC_INLINE__.
  62    __APPLE__ && __MACH__ test for Mac OS X.
  63    __APPLE_CC__ tests for the Apple compiler and its version.
  64    __STDC_VERSION__ tests for the C99 mode.  */
  65 #if defined __APPLE__ && defined __MACH__ && __APPLE_CC__ >= 5465 && !defined __cplusplus && __STDC_VERSION__ >= 199901L && !defined __GNUC_STDC_INLINE__
  66 # define __GNUC_STDC_INLINE__ 1
  67 #endif])
  68   AH_VERBATIM([attribute],
  69 [/* Attributes.  */
  70 #if (defined __has_attribute \
  71      && (!defined __clang_minor__ \
  72          || 3 < __clang_major__ + (5 <= __clang_minor__)))
  73 # define _GL_HAS_ATTRIBUTE(attr) __has_attribute (__##attr##__)
  74 #else
  75 # define _GL_HAS_ATTRIBUTE(attr) _GL_ATTR_##attr
  76 # define _GL_ATTR_alloc_size _GL_GNUC_PREREQ (4, 3)
  77 # define _GL_ATTR_always_inline _GL_GNUC_PREREQ (3, 2)
  78 # define _GL_ATTR_artificial _GL_GNUC_PREREQ (4, 3)
  79 # define _GL_ATTR_cold _GL_GNUC_PREREQ (4, 3)
  80 # define _GL_ATTR_const _GL_GNUC_PREREQ (2, 95)
  81 # define _GL_ATTR_deprecated _GL_GNUC_PREREQ (3, 1)
  82 # define _GL_ATTR_diagnose_if 0
  83 # define _GL_ATTR_error _GL_GNUC_PREREQ (4, 3)
  84 # define _GL_ATTR_externally_visible _GL_GNUC_PREREQ (4, 1)
  85 # define _GL_ATTR_fallthrough _GL_GNUC_PREREQ (7, 0)
  86 # define _GL_ATTR_format _GL_GNUC_PREREQ (2, 7)
  87 # define _GL_ATTR_leaf _GL_GNUC_PREREQ (4, 6)
  88 # define _GL_ATTR_malloc _GL_GNUC_PREREQ (3, 0)
  89 # ifdef _ICC
  90 #  define _GL_ATTR_may_alias 0
  91 # else
  92 #  define _GL_ATTR_may_alias _GL_GNUC_PREREQ (3, 3)
  93 # endif
  94 # define _GL_ATTR_noinline _GL_GNUC_PREREQ (3, 1)
  95 # define _GL_ATTR_nonnull _GL_GNUC_PREREQ (3, 3)
  96 # define _GL_ATTR_nonstring _GL_GNUC_PREREQ (8, 0)
  97 # define _GL_ATTR_nothrow _GL_GNUC_PREREQ (3, 3)
  98 # define _GL_ATTR_packed _GL_GNUC_PREREQ (2, 7)
  99 # define _GL_ATTR_pure _GL_GNUC_PREREQ (2, 96)
 100 # define _GL_ATTR_returns_nonnull _GL_GNUC_PREREQ (4, 9)
 101 # define _GL_ATTR_sentinel _GL_GNUC_PREREQ (4, 0)
 102 # define _GL_ATTR_unused _GL_GNUC_PREREQ (2, 7)
 103 # define _GL_ATTR_warn_unused_result _GL_GNUC_PREREQ (3, 4)
 104 #endif
 105
 106 #ifdef __has_c_attribute
 107 # define _GL_HAS_C_ATTRIBUTE(attr) __has_c_attribute (__##attr##__)
 108 #else
 109 # define _GL_HAS_C_ATTRIBUTE(attr) 0
 110 #endif
 111
 112 ]dnl There is no _GL_ATTRIBUTE_ALIGNED; use stdalign's _Alignas instead.
 113 [
 114 /* _GL_ATTRIBUTE_ALLOC_SIZE ((N)) declares that the Nth argument of the function
 115    is the size of the returned memory block.
 116    _GL_ATTRIBUTE_ALLOC_SIZE ((M, N)) declares that the Mth argument multiplied
 117    by the Nth argument of the function is the size of the returned memory block.
 118  */
 119 /* Applies to: function, pointer to function, function types.  */
 120 #if _GL_HAS_ATTRIBUTE (alloc_size)
 121 # define _GL_ATTRIBUTE_ALLOC_SIZE(args) __attribute__ ((__alloc_size__ args))
 122 #else
 123 # define _GL_ATTRIBUTE_ALLOC_SIZE(args)
 124 #endif
 125
 126 /* _GL_ATTRIBUTE_ALWAYS_INLINE tells that the compiler should always inline the
 127    function and report an error if it cannot do so.  */
 128 /* Applies to: function.  */
 129 #if _GL_HAS_ATTRIBUTE (always_inline)
 130 # define _GL_ATTRIBUTE_ALWAYS_INLINE __attribute__ ((__always_inline__))
 131 #else
 132 # define _GL_ATTRIBUTE_ALWAYS_INLINE
 133 #endif
 134
 135 /* _GL_ATTRIBUTE_ARTIFICIAL declares that the function is not important to show
 136     in stack traces when debugging.  The compiler should omit the function from
 137     stack traces.  */
 138 /* Applies to: function.  */
 139 #if _GL_HAS_ATTRIBUTE (artificial)
 140 # define _GL_ATTRIBUTE_ARTIFICIAL __attribute__ ((__artificial__))
 141 #else
 142 # define _GL_ATTRIBUTE_ARTIFICIAL
 143 #endif
 144
 145 /* _GL_ATTRIBUTE_COLD declares that the function is rarely executed.  */
 146 /* Applies to: functions.  */
 147 /* Avoid __attribute__ ((cold)) on MinGW; see thread starting at
 148    <https://lists.gnu.org/r/emacs-devel/2019-04/msg01152.html>.
 149    Also, Oracle Studio 12.6 requires 'cold' not '__cold__'.  */
 150 #if _GL_HAS_ATTRIBUTE (cold) && !defined __MINGW32__
 151 # ifndef __SUNPRO_C
 152 #  define _GL_ATTRIBUTE_COLD __attribute__ ((__cold__))
 153 # else
 154 #  define _GL_ATTRIBUTE_COLD __attribute__ ((cold))
 155 # endif
 156 #else
 157 # define _GL_ATTRIBUTE_COLD
 158 #endif
 159
 160 /* _GL_ATTRIBUTE_CONST declares that it is OK for a compiler to omit duplicate
 161    calls to the function with the same arguments.
 162    This attribute is safe for a function that neither depends on nor affects
 163    observable state, and always returns exactly once - e.g., does not loop
 164    forever, and does not call longjmp.
 165    (This attribute is stricter than _GL_ATTRIBUTE_PURE.)  */
 166 /* Applies to: functions.  */
 167 #if _GL_HAS_ATTRIBUTE (const)
 168 # define _GL_ATTRIBUTE_CONST __attribute__ ((__const__))
 169 #else
 170 # define _GL_ATTRIBUTE_CONST
 171 #endif
 172
 173 /* _GL_ATTRIBUTE_DEALLOC (F, I) declares that the function returns pointers
 174    that can be freed by passing them as the Ith argument to the
 175    function F.
 176    _GL_ATTRIBUTE_DEALLOC_FREE declares that the function returns pointers that
 177    can be freed via 'free'; it can be used only after declaring 'free'.  */
 178 /* Applies to: functions.  Cannot be used on inline functions.  */
 179 #if _GL_GNUC_PREREQ (11, 0)
 180 # define _GL_ATTRIBUTE_DEALLOC(f, i) __attribute__ ((__malloc__ (f, i)))
 181 #else
 182 # define _GL_ATTRIBUTE_DEALLOC(f, i)
 183 #endif
 184 /* If gnulib's <string.h> or <wchar.h> has already defined this macro, continue
 185    to use this earlier definition, since <stdlib.h> may not have been included
 186    yet.  */
 187 #ifndef _GL_ATTRIBUTE_DEALLOC_FREE
 188 # define _GL_ATTRIBUTE_DEALLOC_FREE _GL_ATTRIBUTE_DEALLOC (free, 1)
 189 #endif
 190
 191 /* _GL_ATTRIBUTE_DEPRECATED: Declares that an entity is deprecated.
 192    The compiler may warn if the entity is used.  */
 193 /* Applies to:
 194      - function, variable,
 195      - struct, union, struct/union member,
 196      - enumeration, enumeration item,
 197      - typedef,
 198    in C++ also: namespace, class, template specialization.  */
 199 #if _GL_HAS_C_ATTRIBUTE (deprecated)
 200 # define _GL_ATTRIBUTE_DEPRECATED [[__deprecated__]]
 201 #elif _GL_HAS_ATTRIBUTE (deprecated)
 202 # define _GL_ATTRIBUTE_DEPRECATED __attribute__ ((__deprecated__))
 203 #else
 204 # define _GL_ATTRIBUTE_DEPRECATED
 205 #endif
 206
 207 /* _GL_ATTRIBUTE_ERROR(msg) requests an error if a function is called and
 208    the function call is not optimized away.
 209    _GL_ATTRIBUTE_WARNING(msg) requests a warning if a function is called and
 210    the function call is not optimized away.  */
 211 /* Applies to: functions.  */
 212 #if _GL_HAS_ATTRIBUTE (error)
 213 # define _GL_ATTRIBUTE_ERROR(msg) __attribute__ ((__error__ (msg)))
 214 # define _GL_ATTRIBUTE_WARNING(msg) __attribute__ ((__warning__ (msg)))
 215 #elif _GL_HAS_ATTRIBUTE (diagnose_if)
 216 # define _GL_ATTRIBUTE_ERROR(msg) __attribute__ ((__diagnose_if__ (1, msg, "error")))
 217 # define _GL_ATTRIBUTE_WARNING(msg) __attribute__ ((__diagnose_if__ (1, msg, "warning")))
 218 #else
 219 # define _GL_ATTRIBUTE_ERROR(msg)
 220 # define _GL_ATTRIBUTE_WARNING(msg)
 221 #endif
 222
 223 /* _GL_ATTRIBUTE_EXTERNALLY_VISIBLE declares that the entity should remain
 224    visible to debuggers etc., even with '-fwhole-program'.  */
 225 /* Applies to: functions, variables.  */
 226 #if _GL_HAS_ATTRIBUTE (externally_visible)
 227 # define _GL_ATTRIBUTE_EXTERNALLY_VISIBLE __attribute__ ((externally_visible))
 228 #else
 229 # define _GL_ATTRIBUTE_EXTERNALLY_VISIBLE
 230 #endif
 231
 232 /* _GL_ATTRIBUTE_FALLTHROUGH declares that it is not a programming mistake if
 233    the control flow falls through to the immediately following 'case' or
 234    'default' label.  The compiler should not warn in this case.  */
 235 /* Applies to: Empty statement (;), inside a 'switch' statement.  */
 236 /* Always expands to something.  */
 237 #if _GL_HAS_C_ATTRIBUTE (fallthrough)
 238 # define _GL_ATTRIBUTE_FALLTHROUGH [[__fallthrough__]]
 239 #elif _GL_HAS_ATTRIBUTE (fallthrough)
 240 # define _GL_ATTRIBUTE_FALLTHROUGH __attribute__ ((__fallthrough__))
 241 #else
 242 # define _GL_ATTRIBUTE_FALLTHROUGH ((void) 0)
 243 #endif
 244
 245 /* _GL_ATTRIBUTE_FORMAT ((ARCHETYPE, STRING-INDEX, FIRST-TO-CHECK))
 246    declares that the STRING-INDEXth function argument is a format string of
 247    style ARCHETYPE, which is one of:
 248      printf, gnu_printf
 249      scanf, gnu_scanf,
 250      strftime, gnu_strftime,
 251      strfmon,
 252    or the same thing prefixed and suffixed with '__'.
 253    If FIRST-TO-CHECK is not 0, arguments starting at FIRST-TO_CHECK
 254    are suitable for the format string.  */
 255 /* Applies to: functions.  */
 256 #if _GL_HAS_ATTRIBUTE (format)
 257 # define _GL_ATTRIBUTE_FORMAT(spec) __attribute__ ((__format__ spec))
 258 #else
 259 # define _GL_ATTRIBUTE_FORMAT(spec)
 260 #endif
 261
 262 /* _GL_ATTRIBUTE_LEAF declares that if the function is called from some other
 263    compilation unit, it executes code from that unit only by return or by
 264    exception handling.  This declaration lets the compiler optimize that unit
 265    more aggressively.  */
 266 /* Applies to: functions.  */
 267 #if _GL_HAS_ATTRIBUTE (leaf)
 268 # define _GL_ATTRIBUTE_LEAF __attribute__ ((__leaf__))
 269 #else
 270 # define _GL_ATTRIBUTE_LEAF
 271 #endif
 272
 273 /* _GL_ATTRIBUTE_MALLOC declares that the function returns a pointer to freshly
 274    allocated memory.  */
 275 /* Applies to: functions.  */
 276 #if _GL_HAS_ATTRIBUTE (malloc)
 277 # define _GL_ATTRIBUTE_MALLOC __attribute__ ((__malloc__))
 278 #else
 279 # define _GL_ATTRIBUTE_MALLOC
 280 #endif
 281
 282 /* _GL_ATTRIBUTE_MAY_ALIAS declares that pointers to the type may point to the
 283    same storage as pointers to other types.  Thus this declaration disables
 284    strict aliasing optimization.  */
 285 /* Applies to: types.  */
 286 /* Oracle Studio 12.6 mishandles may_alias despite __has_attribute OK.  */
 287 #if _GL_HAS_ATTRIBUTE (may_alias) && !defined __SUNPRO_C
 288 # define _GL_ATTRIBUTE_MAY_ALIAS __attribute__ ((__may_alias__))
 289 #else
 290 # define _GL_ATTRIBUTE_MAY_ALIAS
 291 #endif
 292
 293 /* _GL_ATTRIBUTE_MAYBE_UNUSED declares that it is not a programming mistake if
 294    the entity is not used.  The compiler should not warn if the entity is not
 295    used.  */
 296 /* Applies to:
 297      - function, variable,
 298      - struct, union, struct/union member,
 299      - enumeration, enumeration item,
 300      - typedef,
 301    in C++ also: class.  */
 302 /* In C++ and C2x, this is spelled [[__maybe_unused__]].
 303    GCC's syntax is __attribute__ ((__unused__)).
 304    clang supports both syntaxes.  */
 305 #if _GL_HAS_C_ATTRIBUTE (maybe_unused)
 306 # define _GL_ATTRIBUTE_MAYBE_UNUSED [[__maybe_unused__]]
 307 #else
 308 # define _GL_ATTRIBUTE_MAYBE_UNUSED _GL_ATTRIBUTE_UNUSED
 309 #endif
 310 /* Alternative spelling of this macro, for convenience.  */
 311 #define _GL_UNUSED _GL_ATTRIBUTE_MAYBE_UNUSED
 312 /* Earlier spellings of this macro.  */
 313 #define _UNUSED_PARAMETER_ _GL_ATTRIBUTE_MAYBE_UNUSED
 314
 315 /* _GL_ATTRIBUTE_NODISCARD declares that the caller of the function should not
 316    discard the return value.  The compiler may warn if the caller does not use
 317    the return value, unless the caller uses something like ignore_value.  */
 318 /* Applies to: function, enumeration, class.  */
 319 #if _GL_HAS_C_ATTRIBUTE (nodiscard)
 320 # define _GL_ATTRIBUTE_NODISCARD [[__nodiscard__]]
 321 #elif _GL_HAS_ATTRIBUTE (warn_unused_result)
 322 # define _GL_ATTRIBUTE_NODISCARD __attribute__ ((__warn_unused_result__))
 323 #else
 324 # define _GL_ATTRIBUTE_NODISCARD
 325 #endif
 326
 327 /* _GL_ATTRIBUTE_NOINLINE tells that the compiler should not inline the
 328    function.  */
 329 /* Applies to: functions.  */
 330 #if _GL_HAS_ATTRIBUTE (noinline)
 331 # define _GL_ATTRIBUTE_NOINLINE __attribute__ ((__noinline__))
 332 #else
 333 # define _GL_ATTRIBUTE_NOINLINE
 334 #endif
 335
 336 /* _GL_ATTRIBUTE_NONNULL ((N1, N2,...)) declares that the arguments N1, N2,...
 337    must not be NULL.
 338    _GL_ATTRIBUTE_NONNULL () declares that all pointer arguments must not be
 339    null.  */
 340 /* Applies to: functions.  */
 341 #if _GL_HAS_ATTRIBUTE (nonnull)
 342 # define _GL_ATTRIBUTE_NONNULL(args) __attribute__ ((__nonnull__ args))
 343 #else
 344 # define _GL_ATTRIBUTE_NONNULL(args)
 345 #endif
 346
 347 /* _GL_ATTRIBUTE_NONSTRING declares that the contents of a character array is
 348    not meant to be NUL-terminated.  */
 349 /* Applies to: struct/union members and variables that are arrays of element
 350    type '[[un]signed] char'.  */
 351 #if _GL_HAS_ATTRIBUTE (nonstring)
 352 # define _GL_ATTRIBUTE_NONSTRING __attribute__ ((__nonstring__))
 353 #else
 354 # define _GL_ATTRIBUTE_NONSTRING
 355 #endif
 356
 357 /* There is no _GL_ATTRIBUTE_NORETURN; use _Noreturn instead.  */
 358
 359 /* _GL_ATTRIBUTE_NOTHROW declares that the function does not throw exceptions.
 360  */
 361 /* Applies to: functions.  */
 362 #if _GL_HAS_ATTRIBUTE (nothrow) && !defined __cplusplus
 363 # define _GL_ATTRIBUTE_NOTHROW __attribute__ ((__nothrow__))
 364 #else
 365 # define _GL_ATTRIBUTE_NOTHROW
 366 #endif
 367
 368 /* _GL_ATTRIBUTE_PACKED declares:
 369    For struct members: The member has the smallest possible alignment.
 370    For struct, union, class: All members have the smallest possible alignment,
 371    minimizing the memory required.  */
 372 /* Applies to: struct members, struct, union,
 373    in C++ also: class.  */
 374 #if _GL_HAS_ATTRIBUTE (packed)
 375 # define _GL_ATTRIBUTE_PACKED __attribute__ ((__packed__))
 376 #else
 377 # define _GL_ATTRIBUTE_PACKED
 378 #endif
 379
 380 /* _GL_ATTRIBUTE_PURE declares that It is OK for a compiler to omit duplicate
 381    calls to the function with the same arguments if observable state is not
 382    changed between calls.
 383    This attribute is safe for a function that does not affect
 384    observable state, and always returns exactly once.
 385    (This attribute is looser than _GL_ATTRIBUTE_CONST.)  */
 386 /* Applies to: functions.  */
 387 #if _GL_HAS_ATTRIBUTE (pure)
 388 # define _GL_ATTRIBUTE_PURE __attribute__ ((__pure__))
 389 #else
 390 # define _GL_ATTRIBUTE_PURE
 391 #endif
 392
 393 /* _GL_ATTRIBUTE_RETURNS_NONNULL declares that the function's return value is
 394    a non-NULL pointer.  */
 395 /* Applies to: functions.  */
 396 #if _GL_HAS_ATTRIBUTE (returns_nonnull)
 397 # define _GL_ATTRIBUTE_RETURNS_NONNULL __attribute__ ((__returns_nonnull__))
 398 #else
 399 # define _GL_ATTRIBUTE_RETURNS_NONNULL
 400 #endif
 401
 402 /* _GL_ATTRIBUTE_SENTINEL(pos) declares that the variadic function expects a
 403    trailing NULL argument.
 404    _GL_ATTRIBUTE_SENTINEL () - The last argument is NULL (requires C99).
 405    _GL_ATTRIBUTE_SENTINEL ((N)) - The (N+1)st argument from the end is NULL.  */
 406 /* Applies to: functions.  */
 407 #if _GL_HAS_ATTRIBUTE (sentinel)
 408 # define _GL_ATTRIBUTE_SENTINEL(pos) __attribute__ ((__sentinel__ pos))
 409 #else
 410 # define _GL_ATTRIBUTE_SENTINEL(pos)
 411 #endif
 412
 413 /* A helper macro.  Don't use it directly.  */
 414 #if _GL_HAS_ATTRIBUTE (unused)
 415 # define _GL_ATTRIBUTE_UNUSED __attribute__ ((__unused__))
 416 #else
 417 # define _GL_ATTRIBUTE_UNUSED
 418 #endif
 419
 420 ]dnl There is no _GL_ATTRIBUTE_VISIBILITY; see m4/visibility.m4 instead.
 421 [
 422 /* _GL_UNUSED_LABEL; declares that it is not a programming mistake if the
 423    immediately preceding label is not used.  The compiler should not warn
 424    if the label is not used.  */
 425 /* Applies to: label (both in C and C++).  */
 426 /* Note that g++ < 4.5 does not support the '__attribute__ ((__unused__)) ;'
 427    syntax.  But clang does.  */
 428 #if !(defined __cplusplus && !_GL_GNUC_PREREQ (4, 5)) || defined __clang__
 429 # define _GL_UNUSED_LABEL _GL_ATTRIBUTE_UNUSED
 430 #else
 431 # define _GL_UNUSED_LABEL
 432 #endif
 433 ])
 434   AH_VERBATIM([async_safe],
 435 [/* The _GL_ASYNC_SAFE marker should be attached to functions that are
 436    signal handlers (for signals other than SIGABRT, SIGPIPE) or can be
 437    invoked from such signal handlers.  Such functions have some restrictions:
 438      * All functions that it calls should be marked _GL_ASYNC_SAFE as well,
 439        or should be listed as async-signal-safe in POSIX
 440        <https://pubs.opengroup.org/onlinepubs/9699919799/functions/V2_chap02.html#tag_15_04>
 441        section 2.4.3.  Note that malloc(), sprintf(), and fwrite(), in
 442        particular, are NOT async-signal-safe.
 443      * All memory locations (variables and struct fields) that these functions
 444        access must be marked 'volatile'.  This holds for both read and write
 445        accesses.  Otherwise the compiler might optimize away stores to and
 446        reads from such locations that occur in the program, depending on its
 447        data flow analysis.  For example, when the program contains a loop
 448        that is intended to inspect a variable set from within a signal handler
 449            while (!signal_occurred)
 450              ;
 451        the compiler is allowed to transform this into an endless loop if the
 452        variable 'signal_occurred' is not declared 'volatile'.
 453    Additionally, recall that:
 454      * A signal handler should not modify errno (except if it is a handler
 455        for a fatal signal and ends by raising the same signal again, thus
 456        provoking the termination of the process).  If it invokes a function
 457        that may clobber errno, it needs to save and restore the value of
 458        errno.  */
 459 #define _GL_ASYNC_SAFE
 460 ])
 461   AH_VERBATIM([micro_optimizations],
 462 [/* _GL_CMP (n1, n2) performs a three-valued comparison on n1 vs. n2, where
 463    n1 and n2 are expressions without side effects, that evaluate to real
 464    numbers (excluding NaN).
 465    It returns
 466      1  if n1 > n2
 467      0  if n1 == n2
 468      -1 if n1 < n2
 469    The naïve code   (n1 > n2 ? 1 : n1 < n2 ? -1 : 0)  produces a conditional
 470    jump with nearly all GCC versions up to GCC 10.
 471    This variant     (n1 < n2 ? -1 : n1 > n2)  produces a conditional with many
 472    GCC versions up to GCC 9.
 473    The better code  (n1 > n2) - (n1 < n2)  from Hacker's Delight § 2-9
 474    avoids conditional jumps in all GCC versions >= 3.4.  */
 475 #define _GL_CMP(n1, n2) (((n1) > (n2)) - ((n1) < (n2)))
 476 ])
 477   dnl Hint which direction to take regarding cross-compilation guesses:
 478   dnl When a user installs a program on a platform they are not intimately
 479   dnl familiar with, --enable-cross-guesses=conservative is the appropriate
 480   dnl choice.  It implements the "If we don't know, assume the worst" principle.
 481   dnl However, when an operating system developer (on a platform which is not
 482   dnl yet known to gnulib) builds packages for their platform, they want to
 483   dnl expose, not hide, possible platform bugs; in this case,
 484   dnl --enable-cross-guesses=risky is the appropriate choice.
 485   dnl Sets the variables
 486   dnl gl_cross_guess_normal    (to be used when 'yes' is good and 'no' is bad),
 487   dnl gl_cross_guess_inverted  (to be used when 'no' is good and 'yes' is bad).
 488   AC_ARG_ENABLE([cross-guesses],
 489     [AS_HELP_STRING([--enable-cross-guesses={conservative|risky}],
 490        [specify policy for cross-compilation guesses])],
 491     [if test "x$enableval" != xconservative && test "x$enableval" != xrisky; then
 492        AC_MSG_WARN([invalid argument supplied to --enable-cross-guesses])
 493        enableval=conservative
 494      fi
 495      gl_cross_guesses="$enableval"],
 496     [gl_cross_guesses=conservative])
 497   if test $gl_cross_guesses = risky; then
 498     gl_cross_guess_normal="guessing yes"
 499     gl_cross_guess_inverted="guessing no"
 500   else
 501     gl_cross_guess_normal="guessing no"
 502     gl_cross_guess_inverted="guessing yes"
 503   fi
 504   dnl Preparation for running test programs:
 505   dnl Tell glibc to write diagnostics from -D_FORTIFY_SOURCE=2 to stderr, not
 506   dnl to /dev/tty, so they can be redirected to log files.  Such diagnostics
 507   dnl arise e.g., in the macros gl_PRINTF_DIRECTIVE_N, gl_SNPRINTF_DIRECTIVE_N.
 508   LIBC_FATAL_STDERR_=1
 509   export LIBC_FATAL_STDERR_
 510 ])
 511
 512 # gl_MODULE_INDICATOR_INIT_VARIABLE([variablename])
 513 # gl_MODULE_INDICATOR_INIT_VARIABLE([variablename], [initialvalue])
 514 # initializes the shell variable that indicates the presence of the given module
 515 # as a C preprocessor expression.
 516 AC_DEFUN([gl_MODULE_INDICATOR_INIT_VARIABLE],
 517 [
 518   GL_MODULE_INDICATOR_PREFIX[]_[$1]=m4_if([$2], , [0], [$2])
 519   AC_SUBST(GL_MODULE_INDICATOR_PREFIX[]_[$1])
 520 ])
 521
 522 # gl_MODULE_INDICATOR_CONDITION
 523 # expands to a C preprocessor expression that evaluates to 1 or 0, depending
 524 # whether a gnulib module that has been requested shall be considered present
 525 # or not.
 526 m4_define([gl_MODULE_INDICATOR_CONDITION], [1])
 527
 528 # gl_MODULE_INDICATOR_SET_VARIABLE([modulename])
 529 # sets the shell variable that indicates the presence of the given module to
 530 # a C preprocessor expression that will evaluate to 1.
 531 AC_DEFUN([gl_MODULE_INDICATOR_SET_VARIABLE],
 532 [
 533   gl_MODULE_INDICATOR_SET_VARIABLE_AUX(
 534     [GL_MODULE_INDICATOR_PREFIX[]_GNULIB_[]m4_translit([[$1]],
 535                                                        [abcdefghijklmnopqrstuvwxyz./-],
 536                                                        [ABCDEFGHIJKLMNOPQRSTUVWXYZ___])],
 537     [gl_MODULE_INDICATOR_CONDITION])
 538 ])
 539
 540 # gl_MODULE_INDICATOR_SET_VARIABLE_AUX([variable])
 541 # modifies the shell variable to include the gl_MODULE_INDICATOR_CONDITION.
 542 # The shell variable's value is a C preprocessor expression that evaluates
 543 # to 0 or 1.
 544 AC_DEFUN([gl_MODULE_INDICATOR_SET_VARIABLE_AUX],
 545 [
 546   m4_if(m4_defn([gl_MODULE_INDICATOR_CONDITION]), [1],
 547     [
 548      dnl Simplify the expression VALUE || 1 to 1.
 549      $1=1
 550     ],
 551     [gl_MODULE_INDICATOR_SET_VARIABLE_AUX_OR([$1],
 552                                              [gl_MODULE_INDICATOR_CONDITION])])
 553 ])
 554
 555 # gl_MODULE_INDICATOR_SET_VARIABLE_AUX_OR([variable], [condition])
 556 # modifies the shell variable to include the given condition.  The shell
 557 # variable's value is a C preprocessor expression that evaluates to 0 or 1.
 558 AC_DEFUN([gl_MODULE_INDICATOR_SET_VARIABLE_AUX_OR],
 559 [
 560   dnl Simplify the expression 1 || CONDITION to 1.
 561   if test "$[]$1" != 1; then
 562     dnl Simplify the expression 0 || CONDITION to CONDITION.
 563     if test "$[]$1" = 0; then
 564       $1=$2
 565     else
 566       $1="($[]$1 || $2)"
 567     fi
 568   fi
 569 ])
 570
 571 # gl_MODULE_INDICATOR([modulename])
 572 # defines a C macro indicating the presence of the given module
 573 # in a location where it can be used.
 574 #                                             |  Value  |   Value   |
 575 #                                             | in lib/ | in tests/ |
 576 # --------------------------------------------+---------+-----------+
 577 # Module present among main modules:          |    1    |     1     |
 578 # --------------------------------------------+---------+-----------+
 579 # Module present among tests-related modules: |    0    |     1     |
 580 # --------------------------------------------+---------+-----------+
 581 # Module not present at all:                  |    0    |     0     |
 582 # --------------------------------------------+---------+-----------+
 583 AC_DEFUN([gl_MODULE_INDICATOR],
 584 [
 585   AC_DEFINE_UNQUOTED([GNULIB_]m4_translit([[$1]],
 586       [abcdefghijklmnopqrstuvwxyz./-],
 587       [ABCDEFGHIJKLMNOPQRSTUVWXYZ___]),
 588     [gl_MODULE_INDICATOR_CONDITION],
 589     [Define to a C preprocessor expression that evaluates to 1 or 0,
 590      depending whether the gnulib module $1 shall be considered present.])
 591 ])
 592
 593 # gl_MODULE_INDICATOR_FOR_TESTS([modulename])
 594 # defines a C macro indicating the presence of the given module
 595 # in lib or tests. This is useful to determine whether the module
 596 # should be tested.
 597 #                                             |  Value  |   Value   |
 598 #                                             | in lib/ | in tests/ |
 599 # --------------------------------------------+---------+-----------+
 600 # Module present among main modules:          |    1    |     1     |
 601 # --------------------------------------------+---------+-----------+
 602 # Module present among tests-related modules: |    1    |     1     |
 603 # --------------------------------------------+---------+-----------+
 604 # Module not present at all:                  |    0    |     0     |
 605 # --------------------------------------------+---------+-----------+
 606 AC_DEFUN([gl_MODULE_INDICATOR_FOR_TESTS],
 607 [
 608   AC_DEFINE([GNULIB_TEST_]m4_translit([[$1]],
 609       [abcdefghijklmnopqrstuvwxyz./-],
 610       [ABCDEFGHIJKLMNOPQRSTUVWXYZ___]), [1],
 611     [Define to 1 when the gnulib module $1 should be tested.])
 612 ])
 613
 614 # gl_ASSERT_NO_GNULIB_POSIXCHECK
 615 # asserts that there will never be a need to #define GNULIB_POSIXCHECK.
 616 # and thereby enables an optimization of configure and config.h.
 617 # Used by Emacs.
 618 AC_DEFUN([gl_ASSERT_NO_GNULIB_POSIXCHECK],
 619 [
 620   dnl Override gl_WARN_ON_USE_PREPARE.
 621   dnl But hide this definition from 'aclocal'.
 622   AC_DEFUN([gl_W][ARN_ON_USE_PREPARE], [])
 623 ])
 624
 625 # gl_ASSERT_NO_GNULIB_TESTS
 626 # asserts that there will be no gnulib tests in the scope of the configure.ac
 627 # and thereby enables an optimization of config.h.
 628 # Used by Emacs.
 629 AC_DEFUN([gl_ASSERT_NO_GNULIB_TESTS],
 630 [
 631   dnl Override gl_MODULE_INDICATOR_FOR_TESTS.
 632   AC_DEFUN([gl_MODULE_INDICATOR_FOR_TESTS], [])
 633 ])
 634
 635 # Test whether <features.h> exists.
 636 # Set HAVE_FEATURES_H.
 637 AC_DEFUN([gl_FEATURES_H],
 638 [
 639   AC_CHECK_HEADERS_ONCE([features.h])
 640   if test $ac_cv_header_features_h = yes; then
 641     HAVE_FEATURES_H=1
 642   else
 643     HAVE_FEATURES_H=0
 644   fi
 645   AC_SUBST([HAVE_FEATURES_H])
 646 ])
 647
 648 # gl_PROG_CC_C99
 649 # Modifies the value of the shell variable CC in an attempt to make $CC
 650 # understand ISO C99 source code.
 651 AC_DEFUN([gl_PROG_CC_C99],
 652 [
 653   dnl Just use AC_PROG_CC_C99.
 654   dnl When AC_PROG_CC_C99 and AC_PROG_CC_STDC are used together, the substituted
 655   dnl value of CC will contain the C99 enabling options twice. But this is only
 656   dnl a cosmetic problem.
 657   dnl With Autoconf >= 2.70, use AC_PROG_CC since it implies AC_PROG_CC_C99;
 658   dnl this avoids a "warning: The macro `AC_PROG_CC_C99' is obsolete."
 659   m4_version_prereq([2.70],
 660     [AC_REQUIRE([AC_PROG_CC])],
 661     [AC_REQUIRE([AC_PROG_CC_C99])])
 662 ])
 663
 664 # gl_PROG_AR_RANLIB
 665 # Determines the values for AR, ARFLAGS, RANLIB that fit with the compiler.
 666 # The user can set the variables AR, ARFLAGS, RANLIB if he wants to override
 667 # the values.
 668 AC_DEFUN([gl_PROG_AR_RANLIB],
 669 [
 670   dnl Minix 3 comes with two toolchains: The Amsterdam Compiler Kit compiler
 671   dnl as "cc", and GCC as "gcc". They have different object file formats and
 672   dnl library formats. In particular, the GNU binutils programs ar and ranlib
 673   dnl produce libraries that work only with gcc, not with cc.
 674   AC_REQUIRE([AC_PROG_CC])
 675   dnl The '][' hides this use from 'aclocal'.
 676   AC_BEFORE([$0], [A][M_PROG_AR])
 677   AC_CACHE_CHECK([for Minix Amsterdam compiler], [gl_cv_c_amsterdam_compiler],
 678     [
 679       AC_EGREP_CPP([Amsterdam],
 680         [
 681 #ifdef __ACK__
 682 Amsterdam
 683 #endif
 684         ],
 685         [gl_cv_c_amsterdam_compiler=yes],
 686         [gl_cv_c_amsterdam_compiler=no])
 687     ])
 688
 689   dnl Don't compete with AM_PROG_AR's decision about AR/ARFLAGS if we are not
 690   dnl building with __ACK__.
 691   if test $gl_cv_c_amsterdam_compiler = yes; then
 692     if test -z "$AR"; then
 693       AR='cc -c.a'
 694     fi
 695     if test -z "$ARFLAGS"; then
 696       ARFLAGS='-o'
 697     fi
 698   else
 699     dnl AM_PROG_AR was added in automake v1.11.2.  AM_PROG_AR does not AC_SUBST
 700     dnl ARFLAGS variable (it is filed into Makefile.in directly by automake
 701     dnl script on-demand, if not specified by ./configure of course).
 702     dnl Don't AC_REQUIRE the AM_PROG_AR otherwise the code for __ACK__ above
 703     dnl will be ignored.  Also, pay attention to call AM_PROG_AR in else block
 704     dnl because AM_PROG_AR is written so it could re-set AR variable even for
 705     dnl __ACK__.  It may seem like its easier to avoid calling the macro here,
 706     dnl but we need to AC_SUBST both AR/ARFLAGS (thus those must have some good
 707     dnl default value and automake should usually know them).
 708     dnl
 709     dnl The '][' hides this use from 'aclocal'.
 710     m4_ifdef([A][M_PROG_AR], [A][M_PROG_AR], [:])
 711   fi
 712
 713   dnl In case the code above has not helped with setting AR/ARFLAGS, use
 714   dnl Automake-documented default values for AR and ARFLAGS, but prefer
 715   dnl ${host}-ar over ar (useful for cross-compiling).
 716   AC_CHECK_TOOL([AR], [ar], [ar])
 717   if test -z "$ARFLAGS"; then
 718     ARFLAGS='cr'
 719   fi
 720
 721   AC_SUBST([AR])
 722   AC_SUBST([ARFLAGS])
 723   if test -z "$RANLIB"; then
 724     if test $gl_cv_c_amsterdam_compiler = yes; then
 725       RANLIB=':'
 726     else
 727       dnl Use the ranlib program if it is available.
 728       AC_PROG_RANLIB
 729     fi
 730   fi
 731   AC_SUBST([RANLIB])
 732 ])
 733
 734 # AC_C_RESTRICT
 735 # This definition is copied from post-2.70 Autoconf and overrides the
 736 # AC_C_RESTRICT macro from autoconf 2.60..2.70.
 737 m4_version_prereq([2.70.1], [], [
 738 AC_DEFUN([AC_C_RESTRICT],
 739 [AC_CACHE_CHECK([for C/C++ restrict keyword], [ac_cv_c_restrict],
 740   [ac_cv_c_restrict=no
 741    # Put '__restrict__' first, to avoid problems with glibc and non-GCC; see:
 742    # https://lists.gnu.org/archive/html/bug-autoconf/2016-02/msg00006.html
 743    # Put 'restrict' last, because C++ lacks it.
 744    for ac_kw in __restrict__ __restrict _Restrict restrict; do
 745      AC_COMPILE_IFELSE(
 746       [AC_LANG_PROGRAM(
 747          [[typedef int *int_ptr;
 748            int foo (int_ptr $ac_kw ip) { return ip[0]; }
 749            int bar (int [$ac_kw]); /* Catch GCC bug 14050.  */
 750            int bar (int ip[$ac_kw]) { return ip[0]; }
 751          ]],
 752          [[int s[1];
 753            int *$ac_kw t = s;
 754            t[0] = 0;
 755            return foo (t) + bar (t);
 756          ]])],
 757       [ac_cv_c_restrict=$ac_kw])
 758      test "$ac_cv_c_restrict" != no && break
 759    done
 760   ])
 761  AH_VERBATIM([restrict],
 762 [/* Define to the equivalent of the C99 'restrict' keyword, or to
 763    nothing if this is not supported.  Do not define if restrict is
 764    supported only directly.  */
 765 #undef restrict
 766 /* Work around a bug in older versions of Sun C++, which did not
 767    #define __restrict__ or support _Restrict or __restrict__
 768    even though the corresponding Sun C compiler ended up with
 769    "#define restrict _Restrict" or "#define restrict __restrict__"
 770    in the previous line.  This workaround can be removed once
 771    we assume Oracle Developer Studio 12.5 (2016) or later.  */
 772 #if defined __SUNPRO_CC && !defined __RESTRICT && !defined __restrict__
 773 # define _Restrict
 774 # define __restrict__
 775 #endif])
 776  case $ac_cv_c_restrict in
 777    restrict) ;;
 778    no) AC_DEFINE([restrict], []) ;;
 779    *)  AC_DEFINE_UNQUOTED([restrict], [$ac_cv_c_restrict]) ;;
 780  esac
 781 ])# AC_C_RESTRICT
 782 ])
 783
 784 # gl_BIGENDIAN
 785 # is like AC_C_BIGENDIAN, except that it can be AC_REQUIREd.
 786 # Note that AC_REQUIRE([AC_C_BIGENDIAN]) does not work reliably because some
 787 # macros invoke AC_C_BIGENDIAN with arguments.
 788 AC_DEFUN([gl_BIGENDIAN],
 789 [
 790   AC_C_BIGENDIAN
 791 ])
 792
 793 # A temporary file descriptor.
 794 # Must be less than 10, because dash 0.5.8 does not support redirections
 795 # with multi-digit file descriptors.
 796 m4_define([GL_TMP_FD], 9)
 797
 798 # gl_SILENT(command)
 799 # executes command, but without the normal configure output.
 800 # This is useful when you want to invoke AC_CACHE_CHECK (or AC_CHECK_FUNC etc.)
 801 # inside another AC_CACHE_CHECK.
 802 AC_DEFUN([gl_SILENT],
 803 [
 804   exec GL_TMP_FD>&AS_MESSAGE_FD AS_MESSAGE_FD>/dev/null
 805   $1
 806   exec AS_MESSAGE_FD>&GL_TMP_FD GL_TMP_FD>&-
 807 ])
 808
 809 # gl_CACHE_VAL_SILENT(cache-id, command-to-set-it)
 810 # is like AC_CACHE_VAL(cache-id, command-to-set-it), except that it does not
 811 # output a spurious "(cached)" mark in the midst of other configure output.
 812 # This macro should be used instead of AC_CACHE_VAL when it is not surrounded
 813 # by an AC_MSG_CHECKING/AC_MSG_RESULT pair.
 814 AC_DEFUN([gl_CACHE_VAL_SILENT],
 815 [
 816   gl_SILENT([
 817     AC_CACHE_VAL([$1], [$2])
 818   ])
 819 ])
 820
 821 # gl_CONDITIONAL(conditional, condition)
 822 # is like AM_CONDITIONAL(conditional, condition), except that it does not
 823 # produce an error
 824 #   configure: error: conditional "..." was never defined.
 825 #   Usually this means the macro was only invoked conditionally.
 826 # when only invoked conditionally. Instead, in that case, both the _TRUE
 827 # and the _FALSE case are disabled.
 828 AC_DEFUN([gl_CONDITIONAL],
 829 [
 830   pushdef([AC_CONFIG_COMMANDS_PRE], [:])dnl
 831   AM_CONDITIONAL([$1], [$2])
 832   popdef([AC_CONFIG_COMMANDS_PRE])dnl
 833   if test -z "${[$1]_TRUE}" && test -z "${[$1]_FALSE}"; then
 834     [$1]_TRUE='#'
 835     [$1]_FALSE='#'
 836   fi
 837 ])
 838
 839 # gl_CC_ALLOW_WARNINGS
 840 # sets and substitutes a variable GL_CFLAG_ALLOW_WARNINGS, to a $(CC) option
 841 # that reverts a preceding '-Werror' option, if available.
 842 # This is expected to be '-Wno-error' on gcc, clang (except clang/MSVC), xlclang
 843 # and empty otherwise.
 844 AC_DEFUN([gl_CC_ALLOW_WARNINGS],
 845 [
 846   AC_REQUIRE([AC_PROG_CC])
 847   AC_CACHE_CHECK([for C compiler option to allow warnings],
 848     [gl_cv_cc_wallow],
 849     [rm -f conftest*
 850      echo 'int dummy;' > conftest.c
 851      AC_TRY_COMMAND([${CC-cc} $CFLAGS $CPPFLAGS -c conftest.c 2>conftest1.err]) >/dev/null
 852      AC_TRY_COMMAND([${CC-cc} $CFLAGS $CPPFLAGS -Wno-error -c conftest.c 2>conftest2.err]) >/dev/null
 853      dnl Test the number of error output lines, because AIX xlc accepts the
 854      dnl option '-Wno-error', just to produce a warning
 855      dnl "Option -Wno-error was incorrectly specified. The option will be ignored."
 856      dnl afterwards.
 857      if test $? = 0 && test `wc -l < conftest1.err` = `wc -l < conftest2.err`; then
 858        gl_cv_cc_wallow='-Wno-error'
 859      else
 860        gl_cv_cc_wallow=none
 861      fi
 862      rm -f conftest*
 863     ])
 864   case "$gl_cv_cc_wallow" in
 865     none) GL_CFLAG_ALLOW_WARNINGS='' ;;
 866     *)    GL_CFLAG_ALLOW_WARNINGS="$gl_cv_cc_wallow" ;;
 867   esac
 868   AC_SUBST([GL_CFLAG_ALLOW_WARNINGS])
 869 ])
 870
 871 # gl_CXX_ALLOW_WARNINGS
 872 # sets and substitutes a variable GL_CXXFLAG_ALLOW_WARNINGS, to a $(CC) option
 873 # that reverts a preceding '-Werror' option, if available.
 874 AC_DEFUN([gl_CXX_ALLOW_WARNINGS],
 875 [
 876   dnl Requires AC_PROG_CXX or gl_PROG_ANSI_CXX.
 877   if test -n "$CXX" && test "$CXX" != no; then
 878     AC_CACHE_CHECK([for C++ compiler option to allow warnings],
 879       [gl_cv_cxx_wallow],
 880       [rm -f conftest*
 881        echo 'int dummy;' > conftest.cc
 882        AC_TRY_COMMAND([${CXX-c++} $CXXFLAGS $CPPFLAGS -c conftest.cc 2>conftest1.err]) >/dev/null
 883        AC_TRY_COMMAND([${CXX-c++} $CXXFLAGS $CPPFLAGS -Wno-error -c conftest.cc 2>conftest2.err]) >/dev/null
 884        dnl Test the number of error output lines, because AIX xlC accepts the
 885        dnl option '-Wno-error', just to produce a warning
 886        dnl "Option -Wno-error was incorrectly specified. The option will be ignored."
 887        dnl afterwards.
 888        if test $? = 0 && test `wc -l < conftest1.err` = `wc -l < conftest2.err`; then
 889          gl_cv_cxx_wallow='-Wno-error'
 890        else
 891          gl_cv_cxx_wallow=none
 892        fi
 893        rm -f conftest*
 894       ])
 895     case "$gl_cv_cxx_wallow" in
 896       none) GL_CXXFLAG_ALLOW_WARNINGS='' ;;
 897       *)    GL_CXXFLAG_ALLOW_WARNINGS="$gl_cv_cxx_wallow" ;;
 898     esac
 899   else
 900     GL_CXXFLAG_ALLOW_WARNINGS=''
 901   fi
 902   AC_SUBST([GL_CXXFLAG_ALLOW_WARNINGS])
 903 ])
 904
 905 # gl_CC_GNULIB_WARNINGS
 906 # sets and substitutes a variable GL_CFLAG_GNULIB_WARNINGS, to a $(CC) option
 907 # set that enables or disables warnings as suitable for the Gnulib coding style.
 908 AC_DEFUN([gl_CC_GNULIB_WARNINGS],
 909 [
 910   AC_REQUIRE([gl_CC_ALLOW_WARNINGS])
 911   dnl Assume that the compiler supports -Wno-* options only if it also supports
 912   dnl -Wno-error.
 913   GL_CFLAG_GNULIB_WARNINGS=''
 914   if test -n "$GL_CFLAG_ALLOW_WARNINGS"; then
 915     dnl Enable these warning options:
 916     dnl
 917     dnl                                       GCC             clang
 918     dnl -Wno-cast-qual                        >= 3            >= 3.9
 919     dnl -Wno-conversion                       >= 3            >= 3.9
 920     dnl -Wno-float-conversion                 >= 4.9          >= 3.9
 921     dnl -Wno-float-equal                      >= 3            >= 3.9
 922     dnl -Wimplicit-fallthrough                >= 7            >= 3.9
 923     dnl -Wno-pedantic                         >= 4.8          >= 3.9
 924     dnl -Wno-sign-compare                     >= 3            >= 3.9
 925     dnl -Wno-sign-conversion                  >= 4.3          >= 3.9
 926     dnl -Wno-type-limits                      >= 4.3          >= 3.9
 927     dnl -Wno-undef                            >= 3            >= 3.9
 928     dnl -Wno-unsuffixed-float-constants       >= 4.5
 929     dnl -Wno-unused-function                  >= 3            >= 3.9
 930     dnl -Wno-unused-parameter                 >= 3            >= 3.9
 931     dnl
 932     cat > conftest.c <<\EOF
 933       #if __GNUC__ >= 3 || (__clang_major__ + (__clang_minor__ >= 9) > 3)
 934       -Wno-cast-qual
 935       -Wno-conversion
 936       -Wno-float-equal
 937       -Wno-sign-compare
 938       -Wno-undef
 939       -Wno-unused-function
 940       -Wno-unused-parameter
 941       #endif
 942       #if __GNUC__ + (__GNUC_MINOR__ >= 9) > 4 || (__clang_major__ + (__clang_minor__ >= 9) > 3)
 943       -Wno-float-conversion
 944       #endif
 945       #if __GNUC__ >= 7 || (__clang_major__ + (__clang_minor__ >= 9) > 3)
 946       -Wimplicit-fallthrough
 947       #endif
 948       #if __GNUC__ + (__GNUC_MINOR__ >= 8) > 4 || (__clang_major__ + (__clang_minor__ >= 9) > 3)
 949       -Wno-pedantic
 950       #endif
 951       #if __GNUC__ + (__GNUC_MINOR__ >= 3) > 4 || (__clang_major__ + (__clang_minor__ >= 9) > 3)
 952       -Wno-sign-conversion
 953       -Wno-type-limits
 954       #endif
 955       #if __GNUC__ + (__GNUC_MINOR__ >= 5) > 4
 956       -Wno-unsuffixed-float-constants
 957       #endif
 958 EOF
 959     gl_command="$CC $CFLAGS $CPPFLAGS -E conftest.c > conftest.out"
 960     if AC_TRY_EVAL([gl_command]); then
 961       gl_options=`grep -v '#' conftest.out`
 962       for word in $gl_options; do
 963         GL_CFLAG_GNULIB_WARNINGS="$GL_CFLAG_GNULIB_WARNINGS $word"
 964       done
 965     fi
 966     rm -f conftest.c conftest.out
 967   fi
 968   AC_SUBST([GL_CFLAG_GNULIB_WARNINGS])
 969 ])
 970
 971 dnl gl_CONDITIONAL_HEADER([foo.h])
 972 dnl takes a shell variable GL_GENERATE_FOO_H (with value true or false) as input
 973 dnl and produces
 974 dnl   - an AC_SUBSTed variable FOO_H that is either a file name or empty, based
 975 dnl     on whether GL_GENERATE_FOO_H is true or false,
 976 dnl   - an Automake conditional GL_GENERATE_FOO_H that evaluates to the value of
 977 dnl     the shell variable GL_GENERATE_FOO_H.
 978 AC_DEFUN([gl_CONDITIONAL_HEADER],
 979 [
 980   m4_pushdef([gl_header_name], AS_TR_SH(m4_toupper($1)))
 981   m4_pushdef([gl_generate_var], [GL_GENERATE_]AS_TR_SH(m4_toupper($1)))
 982   m4_pushdef([gl_generate_cond], [GL_GENERATE_]AS_TR_SH(m4_toupper($1)))
 983   case "$gl_generate_var" in
 984     false) gl_header_name='' ;;
 985     true)
 986       dnl It is OK to use a .h file in lib/ from within tests/, but not vice
 987       dnl versa.
 988       if test -z "$gl_header_name"; then
 989         gl_header_name="${gl_source_base_prefix}$1"
 990       fi
 991       ;;
 992     *) echo "*** gl_generate_var is not set correctly" 1>&2; exit 1 ;;
 993   esac
 994   AC_SUBST(gl_header_name)
 995   gl_CONDITIONAL(gl_generate_cond, [$gl_generate_var])
 996   m4_popdef([gl_generate_cond])
 997   m4_popdef([gl_generate_var])
 998   m4_popdef([gl_header_name])
 999 ])
1000
1001 dnl Expands to some code for use in .c programs that, on native Windows, defines
1002 dnl the Microsoft deprecated alias function names to the underscore-prefixed
1003 dnl actual function names. With this macro, these function names are available
1004 dnl without linking with '-loldnames' and without generating warnings.
1005 dnl Usage: Use it after all system header files are included.
1006 dnl          #include <...>
1007 dnl          #include <...>
1008 dnl          ]GL_MDA_DEFINES[
1009 dnl          ...
1010 AC_DEFUN([GL_MDA_DEFINES],[
1011 AC_REQUIRE([_GL_MDA_DEFINES])
1012 [$gl_mda_defines]
1013 ])
1014 AC_DEFUN([_GL_MDA_DEFINES],
1015 [gl_mda_defines='
1016 #if defined _WIN32 && !defined __CYGWIN__
1017 #define access    _access
1018 #define chdir     _chdir
1019 #define chmod     _chmod
1020 #define close     _close
1021 #define creat     _creat
1022 #define dup       _dup
1023 #define dup2      _dup2
1024 #define ecvt      _ecvt
1025 #define execl     _execl
1026 #define execle    _execle
1027 #define execlp    _execlp
1028 #define execv     _execv
1029 #define execve    _execve
1030 #define execvp    _execvp
1031 #define execvpe   _execvpe
1032 #define fcloseall _fcloseall
1033 #define fcvt      _fcvt
1034 #define fdopen    _fdopen
1035 #define fileno    _fileno
1036 #define gcvt      _gcvt
1037 #define getcwd    _getcwd
1038 #define getpid    _getpid
1039 #define getw      _getw
1040 #define isatty    _isatty
1041 #define j0        _j0
1042 #define j1        _j1
1043 #define jn        _jn
1044 #define lfind     _lfind
1045 #define lsearch   _lsearch
1046 #define lseek     _lseek
1047 #define memccpy   _memccpy
1048 #define mkdir     _mkdir
1049 #define mktemp    _mktemp
1050 #define open      _open
1051 #define putenv    _putenv
1052 #define putw      _putw
1053 #define read      _read
1054 #define rmdir     _rmdir
1055 #define strdup    _strdup
1056 #define swab      _swab
1057 #define tempnam   _tempnam
1058 #define tzset     _tzset
1059 #define umask     _umask
1060 #define unlink    _unlink
1061 #define utime     _utime
1062 #define wcsdup    _wcsdup
1063 #define write     _write
1064 #define y0        _y0
1065 #define y1        _y1
1066 #define yn        _yn
1067 #endif
1068 '
1069 ])