gnu/usr.bin/grep/libgreputils/locale.h

   1 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */
   2 /* A POSIX <locale.h>.
   3    Copyright (C) 2007-2020 Free Software Foundation, Inc.
   4
   5    This program is free software: you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3 of the License, or
   8    (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  17
  18 #if __GNUC__ >= 3
  19 #pragma GCC system_header
  20 #endif
  21
  22
  23 #if (defined _WIN32 && !defined __CYGWIN__ && defined __need_locale_t) \
  24     || defined _GL_ALREADY_INCLUDING_LOCALE_H
  25
  26 /* Special invocation convention:
  27    - Inside mingw header files,
  28    - To handle Solaris header files (through Solaris 10) when combined
  29      with gettext's libintl.h.  */
  30
  31 #include_next <locale.h>
  32
  33 #else
  34 /* Normal invocation convention.  */
  35
  36 #ifndef _GL_LOCALE_H
  37
  38 #define _GL_ALREADY_INCLUDING_LOCALE_H
  39
  40 /* The include_next requires a split double-inclusion guard.  */
  41 #include_next <locale.h>
  42
  43 #undef _GL_ALREADY_INCLUDING_LOCALE_H
  44
  45 #ifndef _GL_LOCALE_H
  46 #define _GL_LOCALE_H
  47
  48 /* NetBSD 5.0 mis-defines NULL.  */
  49 #include <stddef.h>
  50
  51 /* Mac OS X 10.5 defines the locale_t type in <xlocale.h>.  */
  52 #if 1
  53 # include <xlocale.h>
  54 #endif
  55
  56 /* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */
  57 /* C++ compatible function declaration macros.
  58    Copyright (C) 2010-2020 Free Software Foundation, Inc.
  59
  60    This program is free software: you can redistribute it and/or modify it
  61    under the terms of the GNU General Public License as published
  62    by the Free Software Foundation; either version 3 of the License, or
  63    (at your option) any later version.
  64
  65    This program is distributed in the hope that it will be useful,
  66    but WITHOUT ANY WARRANTY; without even the implied warranty of
  67    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  68    General Public License for more details.
  69
  70    You should have received a copy of the GNU General Public License
  71    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
  72
  73 #ifndef _GL_CXXDEFS_H
  74 #define _GL_CXXDEFS_H
  75
  76 /* Begin/end the GNULIB_NAMESPACE namespace.  */
  77 #if defined __cplusplus && defined GNULIB_NAMESPACE
  78 # define _GL_BEGIN_NAMESPACE namespace GNULIB_NAMESPACE {
  79 # define _GL_END_NAMESPACE }
  80 #else
  81 # define _GL_BEGIN_NAMESPACE
  82 # define _GL_END_NAMESPACE
  83 #endif
  84
  85 /* The three most frequent use cases of these macros are:
  86
  87    * For providing a substitute for a function that is missing on some
  88      platforms, but is declared and works fine on the platforms on which
  89      it exists:
  90
  91        #if @GNULIB_FOO@
  92        # if !@HAVE_FOO@
  93        _GL_FUNCDECL_SYS (foo, ...);
  94        # endif
  95        _GL_CXXALIAS_SYS (foo, ...);
  96        _GL_CXXALIASWARN (foo);
  97        #elif defined GNULIB_POSIXCHECK
  98        ...
  99        #endif
 100
 101    * For providing a replacement for a function that exists on all platforms,
 102      but is broken/insufficient and needs to be replaced on some platforms:
 103
 104        #if @GNULIB_FOO@
 105        # if @REPLACE_FOO@
 106        #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 107        #   undef foo
 108        #   define foo rpl_foo
 109        #  endif
 110        _GL_FUNCDECL_RPL (foo, ...);
 111        _GL_CXXALIAS_RPL (foo, ...);
 112        # else
 113        _GL_CXXALIAS_SYS (foo, ...);
 114        # endif
 115        _GL_CXXALIASWARN (foo);
 116        #elif defined GNULIB_POSIXCHECK
 117        ...
 118        #endif
 119
 120    * For providing a replacement for a function that exists on some platforms
 121      but is broken/insufficient and needs to be replaced on some of them and
 122      is additionally either missing or undeclared on some other platforms:
 123
 124        #if @GNULIB_FOO@
 125        # if @REPLACE_FOO@
 126        #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 127        #   undef foo
 128        #   define foo rpl_foo
 129        #  endif
 130        _GL_FUNCDECL_RPL (foo, ...);
 131        _GL_CXXALIAS_RPL (foo, ...);
 132        # else
 133        #  if !@HAVE_FOO@   or   if !@HAVE_DECL_FOO@
 134        _GL_FUNCDECL_SYS (foo, ...);
 135        #  endif
 136        _GL_CXXALIAS_SYS (foo, ...);
 137        # endif
 138        _GL_CXXALIASWARN (foo);
 139        #elif defined GNULIB_POSIXCHECK
 140        ...
 141        #endif
 142 */
 143
 144 /* _GL_EXTERN_C declaration;
 145    performs the declaration with C linkage.  */
 146 #if defined __cplusplus
 147 # define _GL_EXTERN_C extern "C"
 148 #else
 149 # define _GL_EXTERN_C extern
 150 #endif
 151
 152 /* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes);
 153    declares a replacement function, named rpl_func, with the given prototype,
 154    consisting of return type, parameters, and attributes.
 155    Example:
 156      _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...)
 157                                   _GL_ARG_NONNULL ((1)));
 158  */
 159 #define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \
 160   _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes)
 161 #define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \
 162   _GL_EXTERN_C rettype rpl_func parameters_and_attributes
 163
 164 /* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes);
 165    declares the system function, named func, with the given prototype,
 166    consisting of return type, parameters, and attributes.
 167    Example:
 168      _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...)
 169                                   _GL_ARG_NONNULL ((1)));
 170  */
 171 #define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \
 172   _GL_EXTERN_C rettype func parameters_and_attributes
 173
 174 /* _GL_CXXALIAS_RPL (func, rettype, parameters);
 175    declares a C++ alias called GNULIB_NAMESPACE::func
 176    that redirects to rpl_func, if GNULIB_NAMESPACE is defined.
 177    Example:
 178      _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...));
 179
 180    Wrapping rpl_func in an object with an inline conversion operator
 181    avoids a reference to rpl_func unless GNULIB_NAMESPACE::func is
 182    actually used in the program.  */
 183 #define _GL_CXXALIAS_RPL(func,rettype,parameters) \
 184   _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters)
 185 #if defined __cplusplus && defined GNULIB_NAMESPACE
 186 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
 187     namespace GNULIB_NAMESPACE                                \
 188     {                                                         \
 189       static const struct _gl_ ## func ## _wrapper            \
 190       {                                                       \
 191         typedef rettype (*type) parameters;                   \
 192                                                               \
 193         inline operator type () const                         \
 194         {                                                     \
 195           return ::rpl_func;                                  \
 196         }                                                     \
 197       } func = {};                                            \
 198     }                                                         \
 199     _GL_EXTERN_C int _gl_cxxalias_dummy
 200 #else
 201 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \
 202     _GL_EXTERN_C int _gl_cxxalias_dummy
 203 #endif
 204
 205 /* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters);
 206    is like  _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters);
 207    except that the C function rpl_func may have a slightly different
 208    declaration.  A cast is used to silence the "invalid conversion" error
 209    that would otherwise occur.  */
 210 #if defined __cplusplus && defined GNULIB_NAMESPACE
 211 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
 212     namespace GNULIB_NAMESPACE                                     \
 213     {                                                              \
 214       static const struct _gl_ ## func ## _wrapper                 \
 215       {                                                            \
 216         typedef rettype (*type) parameters;                        \
 217                                                                    \
 218         inline operator type () const                              \
 219         {                                                          \
 220           return reinterpret_cast<type>(::rpl_func);               \
 221         }                                                          \
 222       } func = {};                                                 \
 223     }                                                              \
 224     _GL_EXTERN_C int _gl_cxxalias_dummy
 225 #else
 226 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \
 227     _GL_EXTERN_C int _gl_cxxalias_dummy
 228 #endif
 229
 230 /* _GL_CXXALIAS_SYS (func, rettype, parameters);
 231    declares a C++ alias called GNULIB_NAMESPACE::func
 232    that redirects to the system provided function func, if GNULIB_NAMESPACE
 233    is defined.
 234    Example:
 235      _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...));
 236
 237    Wrapping func in an object with an inline conversion operator
 238    avoids a reference to func unless GNULIB_NAMESPACE::func is
 239    actually used in the program.  */
 240 #if defined __cplusplus && defined GNULIB_NAMESPACE
 241 # define _GL_CXXALIAS_SYS(func,rettype,parameters)            \
 242     namespace GNULIB_NAMESPACE                                \
 243     {                                                         \
 244       static const struct _gl_ ## func ## _wrapper            \
 245       {                                                       \
 246         typedef rettype (*type) parameters;                   \
 247                                                               \
 248         inline operator type () const                         \
 249         {                                                     \
 250           return ::func;                                      \
 251         }                                                     \
 252       } func = {};                                            \
 253     }                                                         \
 254     _GL_EXTERN_C int _gl_cxxalias_dummy
 255 #else
 256 # define _GL_CXXALIAS_SYS(func,rettype,parameters) \
 257     _GL_EXTERN_C int _gl_cxxalias_dummy
 258 #endif
 259
 260 /* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters);
 261    is like  _GL_CXXALIAS_SYS (func, rettype, parameters);
 262    except that the C function func may have a slightly different declaration.
 263    A cast is used to silence the "invalid conversion" error that would
 264    otherwise occur.  */
 265 #if defined __cplusplus && defined GNULIB_NAMESPACE
 266 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
 267     namespace GNULIB_NAMESPACE                          \
 268     {                                                   \
 269       static const struct _gl_ ## func ## _wrapper      \
 270       {                                                 \
 271         typedef rettype (*type) parameters;             \
 272                                                         \
 273         inline operator type () const                   \
 274         {                                               \
 275           return reinterpret_cast<type>(::func);        \
 276         }                                               \
 277       } func = {};                                      \
 278     }                                                   \
 279     _GL_EXTERN_C int _gl_cxxalias_dummy
 280 #else
 281 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \
 282     _GL_EXTERN_C int _gl_cxxalias_dummy
 283 #endif
 284
 285 /* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2);
 286    is like  _GL_CXXALIAS_SYS (func, rettype, parameters);
 287    except that the C function is picked among a set of overloaded functions,
 288    namely the one with rettype2 and parameters2.  Two consecutive casts
 289    are used to silence the "cannot find a match" and "invalid conversion"
 290    errors that would otherwise occur.  */
 291 #if defined __cplusplus && defined GNULIB_NAMESPACE
 292   /* The outer cast must be a reinterpret_cast.
 293      The inner cast: When the function is defined as a set of overloaded
 294      functions, it works as a static_cast<>, choosing the designated variant.
 295      When the function is defined as a single variant, it works as a
 296      reinterpret_cast<>. The parenthesized cast syntax works both ways.  */
 297 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
 298     namespace GNULIB_NAMESPACE                                                \
 299     {                                                                         \
 300       static const struct _gl_ ## func ## _wrapper                            \
 301       {                                                                       \
 302         typedef rettype (*type) parameters;                                   \
 303                                                                               \
 304         inline operator type () const                                         \
 305         {                                                                     \
 306           return reinterpret_cast<type>((rettype2 (*) parameters2)(::func));  \
 307         }                                                                     \
 308       } func = {};                                                            \
 309     }                                                                         \
 310     _GL_EXTERN_C int _gl_cxxalias_dummy
 311 #else
 312 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \
 313     _GL_EXTERN_C int _gl_cxxalias_dummy
 314 #endif
 315
 316 /* _GL_CXXALIASWARN (func);
 317    causes a warning to be emitted when ::func is used but not when
 318    GNULIB_NAMESPACE::func is used.  func must be defined without overloaded
 319    variants.  */
 320 #if defined __cplusplus && defined GNULIB_NAMESPACE
 321 # define _GL_CXXALIASWARN(func) \
 322    _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE)
 323 # define _GL_CXXALIASWARN_1(func,namespace) \
 324    _GL_CXXALIASWARN_2 (func, namespace)
 325 /* To work around GCC bug <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
 326    we enable the warning only when not optimizing.  */
 327 # if !__OPTIMIZE__
 328 #  define _GL_CXXALIASWARN_2(func,namespace) \
 329     _GL_WARN_ON_USE (func, \
 330                      "The symbol ::" #func " refers to the system function. " \
 331                      "Use " #namespace "::" #func " instead.")
 332 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
 333 #  define _GL_CXXALIASWARN_2(func,namespace) \
 334      extern __typeof__ (func) func
 335 # else
 336 #  define _GL_CXXALIASWARN_2(func,namespace) \
 337      _GL_EXTERN_C int _gl_cxxalias_dummy
 338 # endif
 339 #else
 340 # define _GL_CXXALIASWARN(func) \
 341     _GL_EXTERN_C int _gl_cxxalias_dummy
 342 #endif
 343
 344 /* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes);
 345    causes a warning to be emitted when the given overloaded variant of ::func
 346    is used but not when GNULIB_NAMESPACE::func is used.  */
 347 #if defined __cplusplus && defined GNULIB_NAMESPACE
 348 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
 349    _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \
 350                         GNULIB_NAMESPACE)
 351 # define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \
 352    _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace)
 353 /* To work around GCC bug <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>,
 354    we enable the warning only when not optimizing.  */
 355 # if !__OPTIMIZE__
 356 #  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
 357     _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \
 358                          "The symbol ::" #func " refers to the system function. " \
 359                          "Use " #namespace "::" #func " instead.")
 360 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
 361 #  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
 362      extern __typeof__ (func) func
 363 # else
 364 #  define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \
 365      _GL_EXTERN_C int _gl_cxxalias_dummy
 366 # endif
 367 #else
 368 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \
 369     _GL_EXTERN_C int _gl_cxxalias_dummy
 370 #endif
 371
 372 #endif /* _GL_CXXDEFS_H */
 373
 374 /* The definition of _GL_ARG_NONNULL is copied here.  */
 375 /* A C macro for declaring that specific arguments must not be NULL.
 376    Copyright (C) 2009-2020 Free Software Foundation, Inc.
 377
 378    This program is free software: you can redistribute it and/or modify it
 379    under the terms of the GNU General Public License as published
 380    by the Free Software Foundation; either version 3 of the License, or
 381    (at your option) any later version.
 382
 383    This program is distributed in the hope that it will be useful,
 384    but WITHOUT ANY WARRANTY; without even the implied warranty of
 385    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 386    General Public License for more details.
 387
 388    You should have received a copy of the GNU General Public License
 389    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
 390
 391 /* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools
 392    that the values passed as arguments n, ..., m must be non-NULL pointers.
 393    n = 1 stands for the first argument, n = 2 for the second argument etc.  */
 394 #ifndef _GL_ARG_NONNULL
 395 # if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3
 396 #  define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params))
 397 # else
 398 #  define _GL_ARG_NONNULL(params)
 399 # endif
 400 #endif
 401
 402 /* The definition of _GL_WARN_ON_USE is copied here.  */
 403 /* A C macro for emitting warnings if a function is used.
 404    Copyright (C) 2010-2020 Free Software Foundation, Inc.
 405
 406    This program is free software: you can redistribute it and/or modify it
 407    under the terms of the GNU General Public License as published
 408    by the Free Software Foundation; either version 3 of the License, or
 409    (at your option) any later version.
 410
 411    This program is distributed in the hope that it will be useful,
 412    but WITHOUT ANY WARRANTY; without even the implied warranty of
 413    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 414    General Public License for more details.
 415
 416    You should have received a copy of the GNU General Public License
 417    along with this program.  If not, see <https://www.gnu.org/licenses/>.  */
 418
 419 /* _GL_WARN_ON_USE (function, "literal string") issues a declaration
 420    for FUNCTION which will then trigger a compiler warning containing
 421    the text of "literal string" anywhere that function is called, if
 422    supported by the compiler.  If the compiler does not support this
 423    feature, the macro expands to an unused extern declaration.
 424
 425    _GL_WARN_ON_USE_ATTRIBUTE ("literal string") expands to the
 426    attribute used in _GL_WARN_ON_USE.  If the compiler does not support
 427    this feature, it expands to empty.
 428
 429    These macros are useful for marking a function as a potential
 430    portability trap, with the intent that "literal string" include
 431    instructions on the replacement function that should be used
 432    instead.
 433    _GL_WARN_ON_USE is for functions with 'extern' linkage.
 434    _GL_WARN_ON_USE_ATTRIBUTE is for functions with 'static' or 'inline'
 435    linkage.
 436
 437    However, one of the reasons that a function is a portability trap is
 438    if it has the wrong signature.  Declaring FUNCTION with a different
 439    signature in C is a compilation error, so this macro must use the
 440    same type as any existing declaration so that programs that avoid
 441    the problematic FUNCTION do not fail to compile merely because they
 442    included a header that poisoned the function.  But this implies that
 443    _GL_WARN_ON_USE is only safe to use if FUNCTION is known to already
 444    have a declaration.  Use of this macro implies that there must not
 445    be any other macro hiding the declaration of FUNCTION; but
 446    undefining FUNCTION first is part of the poisoning process anyway
 447    (although for symbols that are provided only via a macro, the result
 448    is a compilation error rather than a warning containing
 449    "literal string").  Also note that in C++, it is only safe to use if
 450    FUNCTION has no overloads.
 451
 452    For an example, it is possible to poison 'getline' by:
 453    - adding a call to gl_WARN_ON_USE_PREPARE([[#include <stdio.h>]],
 454      [getline]) in configure.ac, which potentially defines
 455      HAVE_RAW_DECL_GETLINE
 456    - adding this code to a header that wraps the system <stdio.h>:
 457      #undef getline
 458      #if HAVE_RAW_DECL_GETLINE
 459      _GL_WARN_ON_USE (getline, "getline is required by POSIX 2008, but"
 460        "not universally present; use the gnulib module getline");
 461      #endif
 462
 463    It is not possible to directly poison global variables.  But it is
 464    possible to write a wrapper accessor function, and poison that
 465    (less common usage, like &environ, will cause a compilation error
 466    rather than issue the nice warning, but the end result of informing
 467    the developer about their portability problem is still achieved):
 468      #if HAVE_RAW_DECL_ENVIRON
 469      static char ***
 470      rpl_environ (void) { return &environ; }
 471      _GL_WARN_ON_USE (rpl_environ, "environ is not always properly declared");
 472      # undef environ
 473      # define environ (*rpl_environ ())
 474      #endif
 475    or better (avoiding contradictory use of 'static' and 'extern'):
 476      #if HAVE_RAW_DECL_ENVIRON
 477      static char ***
 478      _GL_WARN_ON_USE_ATTRIBUTE ("environ is not always properly declared")
 479      rpl_environ (void) { return &environ; }
 480      # undef environ
 481      # define environ (*rpl_environ ())
 482      #endif
 483    */
 484 #ifndef _GL_WARN_ON_USE
 485
 486 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
 487 /* A compiler attribute is available in gcc versions 4.3.0 and later.  */
 488 #  define _GL_WARN_ON_USE(function, message) \
 489 extern __typeof__ (function) function __attribute__ ((__warning__ (message)))
 490 #  define _GL_WARN_ON_USE_ATTRIBUTE(message) \
 491   __attribute__ ((__warning__ (message)))
 492 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
 493 /* Verify the existence of the function.  */
 494 #  define _GL_WARN_ON_USE(function, message) \
 495 extern __typeof__ (function) function
 496 #  define _GL_WARN_ON_USE_ATTRIBUTE(message)
 497 # else /* Unsupported.  */
 498 #  define _GL_WARN_ON_USE(function, message) \
 499 _GL_WARN_EXTERN_C int _gl_warn_on_use
 500 #  define _GL_WARN_ON_USE_ATTRIBUTE(message)
 501 # endif
 502 #endif
 503
 504 /* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string")
 505    is like _GL_WARN_ON_USE (function, "string"), except that the function is
 506    declared with the given prototype, consisting of return type, parameters,
 507    and attributes.
 508    This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does
 509    not work in this case.  */
 510 #ifndef _GL_WARN_ON_USE_CXX
 511 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__)
 512 #  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
 513 extern rettype function parameters_and_attributes \
 514      __attribute__ ((__warning__ (msg)))
 515 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING
 516 /* Verify the existence of the function.  */
 517 #  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
 518 extern rettype function parameters_and_attributes
 519 # else /* Unsupported.  */
 520 #  define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \
 521 _GL_WARN_EXTERN_C int _gl_warn_on_use
 522 # endif
 523 #endif
 524
 525 /* _GL_WARN_EXTERN_C declaration;
 526    performs the declaration with C linkage.  */
 527 #ifndef _GL_WARN_EXTERN_C
 528 # if defined __cplusplus
 529 #  define _GL_WARN_EXTERN_C extern "C"
 530 # else
 531 #  define _GL_WARN_EXTERN_C extern
 532 # endif
 533 #endif
 534
 535 /* The LC_MESSAGES locale category is specified in POSIX, but not in ISO C.
 536    On systems that don't define it, use the same value as GNU libintl.  */
 537 #if !defined LC_MESSAGES
 538 # define LC_MESSAGES 1729
 539 #endif
 540
 541 /* On native Windows with MSVC, 'struct lconv' lacks the members int_p_* and
 542    int_n_*.  Instead of overriding 'struct lconv', merely define these member
 543    names as macros.  This avoids trouble in C++ mode.  */
 544 #if defined _MSC_VER
 545 # define int_p_cs_precedes   p_cs_precedes
 546 # define int_p_sign_posn     p_sign_posn
 547 # define int_p_sep_by_space  p_sep_by_space
 548 # define int_n_cs_precedes   n_cs_precedes
 549 # define int_n_sign_posn     n_sign_posn
 550 # define int_n_sep_by_space  n_sep_by_space
 551 #endif
 552
 553 /* Bionic libc's 'struct lconv' is just a dummy.  */
 554 #if 0
 555 # define lconv rpl_lconv
 556 struct lconv
 557 {
 558   /* All 'char *' are actually 'const char *'.  */
 559
 560   /* Members that depend on the LC_NUMERIC category of the locale.  See
 561      <https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_04> */
 562
 563   /* Symbol used as decimal point.  */
 564   char *decimal_point;
 565   /* Symbol used to separate groups of digits to the left of the decimal
 566      point.  */
 567   char *thousands_sep;
 568   /* Definition of the size of groups of digits to the left of the decimal
 569      point.  */
 570   char *grouping;
 571
 572   /* Members that depend on the LC_MONETARY category of the locale.  See
 573      <https://pubs.opengroup.org/onlinepubs/9699919799/basedefs/V1_chap07.html#tag_07_03_03> */
 574
 575   /* Symbol used as decimal point.  */
 576   char *mon_decimal_point;
 577   /* Symbol used to separate groups of digits to the left of the decimal
 578      point.  */
 579   char *mon_thousands_sep;
 580   /* Definition of the size of groups of digits to the left of the decimal
 581      point.  */
 582   char *mon_grouping;
 583   /* Sign used to indicate a value >= 0.  */
 584   char *positive_sign;
 585   /* Sign used to indicate a value < 0.  */
 586   char *negative_sign;
 587
 588   /* For formatting local currency.  */
 589   /* Currency symbol (3 characters) followed by separator (1 character).  */
 590   char *currency_symbol;
 591   /* Number of digits after the decimal point.  */
 592   char frac_digits;
 593   /* For values >= 0: 1 if the currency symbol precedes the number, 0 if it
 594      comes after the number.  */
 595   char p_cs_precedes;
 596   /* For values >= 0: Position of the sign.  */
 597   char p_sign_posn;
 598   /* For values >= 0: Placement of spaces between currency symbol, sign, and
 599      number.  */
 600   char p_sep_by_space;
 601   /* For values < 0: 1 if the currency symbol precedes the number, 0 if it
 602      comes after the number.  */
 603   char n_cs_precedes;
 604   /* For values < 0: Position of the sign.  */
 605   char n_sign_posn;
 606   /* For values < 0: Placement of spaces between currency symbol, sign, and
 607      number.  */
 608   char n_sep_by_space;
 609
 610   /* For formatting international currency.  */
 611   /* Currency symbol (3 characters) followed by separator (1 character).  */
 612   char *int_curr_symbol;
 613   /* Number of digits after the decimal point.  */
 614   char int_frac_digits;
 615   /* For values >= 0: 1 if the currency symbol precedes the number, 0 if it
 616      comes after the number.  */
 617   char int_p_cs_precedes;
 618   /* For values >= 0: Position of the sign.  */
 619   char int_p_sign_posn;
 620   /* For values >= 0: Placement of spaces between currency symbol, sign, and
 621      number.  */
 622   char int_p_sep_by_space;
 623   /* For values < 0: 1 if the currency symbol precedes the number, 0 if it
 624      comes after the number.  */
 625   char int_n_cs_precedes;
 626   /* For values < 0: Position of the sign.  */
 627   char int_n_sign_posn;
 628   /* For values < 0: Placement of spaces between currency symbol, sign, and
 629      number.  */
 630   char int_n_sep_by_space;
 631 };
 632 #endif
 633
 634 #if 1
 635 # if 0
 636 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 637 #   undef localeconv
 638 #   define localeconv rpl_localeconv
 639 #  endif
 640 _GL_FUNCDECL_RPL (localeconv, struct lconv *, (void));
 641 _GL_CXXALIAS_RPL (localeconv, struct lconv *, (void));
 642 # else
 643 _GL_CXXALIAS_SYS (localeconv, struct lconv *, (void));
 644 # endif
 645 # if __GLIBC__ >= 2
 646 _GL_CXXALIASWARN (localeconv);
 647 # endif
 648 #elif 0
 649 # undef localeconv
 650 # define localeconv localeconv_used_without_requesting_gnulib_module_localeconv
 651 #elif defined GNULIB_POSIXCHECK
 652 # undef localeconv
 653 # if HAVE_RAW_DECL_LOCALECONV
 654 _GL_WARN_ON_USE (localeconv,
 655                  "localeconv returns too few information on some platforms - "
 656                  "use gnulib module localeconv for portability");
 657 # endif
 658 #endif
 659
 660 #if IN_GREP_GNULIB_TESTS
 661 # if 1
 662 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 663 #   undef setlocale
 664 #   define setlocale rpl_setlocale
 665 #   define GNULIB_defined_setlocale 1
 666 #  endif
 667 _GL_FUNCDECL_RPL (setlocale, char *, (int category, const char *locale));
 668 _GL_CXXALIAS_RPL (setlocale, char *, (int category, const char *locale));
 669 # else
 670 _GL_CXXALIAS_SYS (setlocale, char *, (int category, const char *locale));
 671 # endif
 672 # if __GLIBC__ >= 2
 673 _GL_CXXALIASWARN (setlocale);
 674 # endif
 675 #elif defined GNULIB_POSIXCHECK
 676 # undef setlocale
 677 # if HAVE_RAW_DECL_SETLOCALE
 678 _GL_WARN_ON_USE (setlocale, "setlocale works differently on native Windows - "
 679                  "use gnulib module setlocale for portability");
 680 # endif
 681 #endif
 682
 683 #if 1
 684 /* Included here for convenience.  */
 685 # include "setlocale_null.h"
 686 #endif
 687
 688 #if /*@GNULIB_NEWLOCALE@ ||*/ (IN_GREP_GNULIB_TESTS && 1)
 689 # if 0
 690 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 691 #   undef newlocale
 692 #   define newlocale rpl_newlocale
 693 #   define GNULIB_defined_newlocale 1
 694 #  endif
 695 _GL_FUNCDECL_RPL (newlocale, locale_t,
 696                   (int category_mask, const char *name, locale_t base)
 697                   _GL_ARG_NONNULL ((2)));
 698 _GL_CXXALIAS_RPL (newlocale, locale_t,
 699                   (int category_mask, const char *name, locale_t base));
 700 # else
 701 #  if 1
 702 _GL_CXXALIAS_SYS (newlocale, locale_t,
 703                   (int category_mask, const char *name, locale_t base));
 704 #  endif
 705 # endif
 706 # if 1
 707 _GL_CXXALIASWARN (newlocale);
 708 # endif
 709 # if 1 || 0
 710 #  ifndef HAVE_WORKING_NEWLOCALE
 711 #   define HAVE_WORKING_NEWLOCALE 1
 712 #  endif
 713 # endif
 714 #elif defined GNULIB_POSIXCHECK
 715 # undef newlocale
 716 # if HAVE_RAW_DECL_NEWLOCALE
 717 _GL_WARN_ON_USE (newlocale, "newlocale is not portable");
 718 # endif
 719 #endif
 720
 721 #if 0 || (IN_GREP_GNULIB_TESTS && 1)
 722 # if 0
 723 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 724 #   undef duplocale
 725 #   define duplocale rpl_duplocale
 726 #   define GNULIB_defined_duplocale 1
 727 #  endif
 728 _GL_FUNCDECL_RPL (duplocale, locale_t, (locale_t locale) _GL_ARG_NONNULL ((1)));
 729 _GL_CXXALIAS_RPL (duplocale, locale_t, (locale_t locale));
 730 # else
 731 #  if 1
 732 _GL_CXXALIAS_SYS (duplocale, locale_t, (locale_t locale));
 733 #  endif
 734 # endif
 735 # if 1
 736 _GL_CXXALIASWARN (duplocale);
 737 # endif
 738 # if 1 || 0
 739 #  ifndef HAVE_WORKING_DUPLOCALE
 740 #   define HAVE_WORKING_DUPLOCALE 1
 741 #  endif
 742 # endif
 743 #elif defined GNULIB_POSIXCHECK
 744 # undef duplocale
 745 # if HAVE_RAW_DECL_DUPLOCALE
 746 _GL_WARN_ON_USE (duplocale, "duplocale is buggy on some glibc systems - "
 747                  "use gnulib module duplocale for portability");
 748 # endif
 749 #endif
 750
 751 #if /*@GNULIB_FREELOCALE@ ||*/ (IN_GREP_GNULIB_TESTS && 1)
 752 # if 0
 753 #  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 754 #   undef freelocale
 755 #   define freelocale rpl_freelocale
 756 #   define GNULIB_defined_freelocale 1
 757 #  endif
 758 _GL_FUNCDECL_RPL (freelocale, void, (locale_t locale) _GL_ARG_NONNULL ((1)));
 759 _GL_CXXALIAS_RPL (freelocale, void, (locale_t locale));
 760 # else
 761 #  if 1
 762 /* Need to cast, because on FreeBSD and Mac OS X 10.13, the return type is
 763                                    int.  */
 764 _GL_CXXALIAS_SYS_CAST (freelocale, void, (locale_t locale));
 765 #  endif
 766 # endif
 767 # if 1
 768 _GL_CXXALIASWARN (freelocale);
 769 # endif
 770 #elif defined GNULIB_POSIXCHECK
 771 # undef freelocale
 772 # if HAVE_RAW_DECL_FREELOCALE
 773 _GL_WARN_ON_USE (freelocale, "freelocale is not portable");
 774 # endif
 775 #endif
 776
 777 #endif /* _GL_LOCALE_H */
 778 #endif /* _GL_LOCALE_H */
 779 #endif /* !(__need_locale_t || _GL_ALREADY_INCLUDING_LOCALE_H) */