1/* This file is automatically generated. DO NOT EDIT! */ 2/* Generated from: NetBSD: mknative-gdb,v 1.16 2023/07/31 17:09:59 christos Exp */ 3/* Generated from: NetBSD: mknative.common,v 1.16 2018/04/15 15:13:37 christos Exp */ 4 5/* DO NOT EDIT! GENERATED AUTOMATICALLY! */ 6/* A GNU-like <math.h>. 7 8 Copyright (C) 2002-2003, 2007-2022 Free Software Foundation, Inc. 9 10 This file is free software: you can redistribute it and/or modify 11 it under the terms of the GNU Lesser General Public License as 12 published by the Free Software Foundation; either version 2.1 of the 13 License, or (at your option) any later version. 14 15 This file is distributed in the hope that it will be useful, 16 but WITHOUT ANY WARRANTY; without even the implied warranty of 17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18 GNU Lesser General Public License for more details. 19 20 You should have received a copy of the GNU Lesser General Public License 21 along with this program. If not, see <https://www.gnu.org/licenses/>. */ 22 23#ifndef _GL_MATH_H 24 25#if __GNUC__ >= 3 26#pragma GCC system_header 27#endif 28 29 30#if defined _GL_INCLUDING_MATH_H 31/* Special invocation convention: 32 - On FreeBSD 12.2 we have a sequence of nested includes 33 <math.h> -> <stdlib.h> -> <sys/wait.h> -> <sys/types.h> -> <sys/select.h> 34 -> <signal.h> -> <pthread.h> -> <stdlib.h> -> <math.h> 35 In this situation, the functions are not yet declared, therefore we cannot 36 provide the C++ aliases. */ 37 38#include_next <math.h> 39 40#else 41/* Normal invocation convention. */ 42 43/* The include_next requires a split double-inclusion guard. */ 44#define _GL_INCLUDING_MATH_H 45#include_next <math.h> 46#undef _GL_INCLUDING_MATH_H 47 48#ifndef _GL_MATH_H 49#define _GL_MATH_H 50 51/* On OpenVMS, NAN, INFINITY, and HUGEVAL macros are defined in <fp.h>. */ 52#if defined __VMS && ! defined NAN 53# include <fp.h> 54#endif 55 56#ifndef _GL_INLINE_HEADER_BEGIN 57 #error "Please include config.h first." 58#endif 59_GL_INLINE_HEADER_BEGIN 60#ifndef _GL_MATH_INLINE 61# define _GL_MATH_INLINE _GL_INLINE 62#endif 63 64/* The __attribute__ feature is available in gcc versions 2.5 and later. 65 The attribute __const__ was added in gcc 2.95. */ 66#ifndef _GL_ATTRIBUTE_CONST 67# if __GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ >= 95) || defined __clang__ 68# define _GL_ATTRIBUTE_CONST __attribute__ ((__const__)) 69# else 70# define _GL_ATTRIBUTE_CONST /* empty */ 71# endif 72#endif 73 74/* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ 75/* C++ compatible function declaration macros. 76 Copyright (C) 2010-2022 Free Software Foundation, Inc. 77 78 This program is free software: you can redistribute it and/or modify it 79 under the terms of the GNU Lesser General Public License as published 80 by the Free Software Foundation; either version 2 of the License, or 81 (at your option) any later version. 82 83 This program is distributed in the hope that it will be useful, 84 but WITHOUT ANY WARRANTY; without even the implied warranty of 85 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 86 Lesser General Public License for more details. 87 88 You should have received a copy of the GNU Lesser General Public License 89 along with this program. If not, see <https://www.gnu.org/licenses/>. */ 90 91#ifndef _GL_CXXDEFS_H 92#define _GL_CXXDEFS_H 93 94/* Begin/end the GNULIB_NAMESPACE namespace. */ 95#if defined __cplusplus && defined GNULIB_NAMESPACE 96# define _GL_BEGIN_NAMESPACE namespace GNULIB_NAMESPACE { 97# define _GL_END_NAMESPACE } 98#else 99# define _GL_BEGIN_NAMESPACE 100# define _GL_END_NAMESPACE 101#endif 102 103/* The three most frequent use cases of these macros are: 104 105 * For providing a substitute for a function that is missing on some 106 platforms, but is declared and works fine on the platforms on which 107 it exists: 108 109 #if @GNULIB_FOO@ 110 # if !@HAVE_FOO@ 111 _GL_FUNCDECL_SYS (foo, ...); 112 # endif 113 _GL_CXXALIAS_SYS (foo, ...); 114 _GL_CXXALIASWARN (foo); 115 #elif defined GNULIB_POSIXCHECK 116 ... 117 #endif 118 119 * For providing a replacement for a function that exists on all platforms, 120 but is broken/insufficient and needs to be replaced on some platforms: 121 122 #if @GNULIB_FOO@ 123 # if @REPLACE_FOO@ 124 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 125 # undef foo 126 # define foo rpl_foo 127 # endif 128 _GL_FUNCDECL_RPL (foo, ...); 129 _GL_CXXALIAS_RPL (foo, ...); 130 # else 131 _GL_CXXALIAS_SYS (foo, ...); 132 # endif 133 _GL_CXXALIASWARN (foo); 134 #elif defined GNULIB_POSIXCHECK 135 ... 136 #endif 137 138 * For providing a replacement for a function that exists on some platforms 139 but is broken/insufficient and needs to be replaced on some of them and 140 is additionally either missing or undeclared on some other platforms: 141 142 #if @GNULIB_FOO@ 143 # if @REPLACE_FOO@ 144 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 145 # undef foo 146 # define foo rpl_foo 147 # endif 148 _GL_FUNCDECL_RPL (foo, ...); 149 _GL_CXXALIAS_RPL (foo, ...); 150 # else 151 # if !@HAVE_FOO@ or if !@HAVE_DECL_FOO@ 152 _GL_FUNCDECL_SYS (foo, ...); 153 # endif 154 _GL_CXXALIAS_SYS (foo, ...); 155 # endif 156 _GL_CXXALIASWARN (foo); 157 #elif defined GNULIB_POSIXCHECK 158 ... 159 #endif 160*/ 161 162/* _GL_EXTERN_C declaration; 163 performs the declaration with C linkage. */ 164#if defined __cplusplus 165# define _GL_EXTERN_C extern "C" 166#else 167# define _GL_EXTERN_C extern 168#endif 169 170/* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes); 171 declares a replacement function, named rpl_func, with the given prototype, 172 consisting of return type, parameters, and attributes. 173 Example: 174 _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...) 175 _GL_ARG_NONNULL ((1))); 176 */ 177#define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \ 178 _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes) 179#define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \ 180 _GL_EXTERN_C rettype rpl_func parameters_and_attributes 181 182/* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes); 183 declares the system function, named func, with the given prototype, 184 consisting of return type, parameters, and attributes. 185 Example: 186 _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...) 187 _GL_ARG_NONNULL ((1))); 188 */ 189#define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \ 190 _GL_EXTERN_C rettype func parameters_and_attributes 191 192/* _GL_CXXALIAS_RPL (func, rettype, parameters); 193 declares a C++ alias called GNULIB_NAMESPACE::func 194 that redirects to rpl_func, if GNULIB_NAMESPACE is defined. 195 Example: 196 _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...)); 197 198 Wrapping rpl_func in an object with an inline conversion operator 199 avoids a reference to rpl_func unless GNULIB_NAMESPACE::func is 200 actually used in the program. */ 201#define _GL_CXXALIAS_RPL(func,rettype,parameters) \ 202 _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters) 203#if defined __cplusplus && defined GNULIB_NAMESPACE 204# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 205 namespace GNULIB_NAMESPACE \ 206 { \ 207 static const struct _gl_ ## func ## _wrapper \ 208 { \ 209 typedef rettype (*type) parameters; \ 210 \ 211 inline operator type () const \ 212 { \ 213 return ::rpl_func; \ 214 } \ 215 } func = {}; \ 216 } \ 217 _GL_EXTERN_C int _gl_cxxalias_dummy 218#else 219# define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 220 _GL_EXTERN_C int _gl_cxxalias_dummy 221#endif 222 223/* _GL_CXXALIAS_MDA (func, rettype, parameters); 224 is to be used when func is a Microsoft deprecated alias, on native Windows. 225 It declares a C++ alias called GNULIB_NAMESPACE::func 226 that redirects to _func, if GNULIB_NAMESPACE is defined. 227 Example: 228 _GL_CXXALIAS_MDA (open, int, (const char *filename, int flags, ...)); 229 */ 230#define _GL_CXXALIAS_MDA(func,rettype,parameters) \ 231 _GL_CXXALIAS_RPL_1 (func, _##func, rettype, parameters) 232 233/* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters); 234 is like _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters); 235 except that the C function rpl_func may have a slightly different 236 declaration. A cast is used to silence the "invalid conversion" error 237 that would otherwise occur. */ 238#if defined __cplusplus && defined GNULIB_NAMESPACE 239# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 240 namespace GNULIB_NAMESPACE \ 241 { \ 242 static const struct _gl_ ## func ## _wrapper \ 243 { \ 244 typedef rettype (*type) parameters; \ 245 \ 246 inline operator type () const \ 247 { \ 248 return reinterpret_cast<type>(::rpl_func); \ 249 } \ 250 } func = {}; \ 251 } \ 252 _GL_EXTERN_C int _gl_cxxalias_dummy 253#else 254# define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 255 _GL_EXTERN_C int _gl_cxxalias_dummy 256#endif 257 258/* _GL_CXXALIAS_MDA_CAST (func, rettype, parameters); 259 is like _GL_CXXALIAS_MDA (func, rettype, parameters); 260 except that the C function func may have a slightly different declaration. 261 A cast is used to silence the "invalid conversion" error that would 262 otherwise occur. */ 263#define _GL_CXXALIAS_MDA_CAST(func,rettype,parameters) \ 264 _GL_CXXALIAS_RPL_CAST_1 (func, _##func, rettype, parameters) 265 266/* _GL_CXXALIAS_SYS (func, rettype, parameters); 267 declares a C++ alias called GNULIB_NAMESPACE::func 268 that redirects to the system provided function func, if GNULIB_NAMESPACE 269 is defined. 270 Example: 271 _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...)); 272 273 Wrapping func in an object with an inline conversion operator 274 avoids a reference to func unless GNULIB_NAMESPACE::func is 275 actually used in the program. */ 276#if defined __cplusplus && defined GNULIB_NAMESPACE 277# define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 278 namespace GNULIB_NAMESPACE \ 279 { \ 280 static const struct _gl_ ## func ## _wrapper \ 281 { \ 282 typedef rettype (*type) parameters; \ 283 \ 284 inline operator type () const \ 285 { \ 286 return ::func; \ 287 } \ 288 } func = {}; \ 289 } \ 290 _GL_EXTERN_C int _gl_cxxalias_dummy 291#else 292# define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 293 _GL_EXTERN_C int _gl_cxxalias_dummy 294#endif 295 296/* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters); 297 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 298 except that the C function func may have a slightly different declaration. 299 A cast is used to silence the "invalid conversion" error that would 300 otherwise occur. */ 301#if defined __cplusplus && defined GNULIB_NAMESPACE 302# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 303 namespace GNULIB_NAMESPACE \ 304 { \ 305 static const struct _gl_ ## func ## _wrapper \ 306 { \ 307 typedef rettype (*type) parameters; \ 308 \ 309 inline operator type () const \ 310 { \ 311 return reinterpret_cast<type>(::func); \ 312 } \ 313 } func = {}; \ 314 } \ 315 _GL_EXTERN_C int _gl_cxxalias_dummy 316#else 317# define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 318 _GL_EXTERN_C int _gl_cxxalias_dummy 319#endif 320 321/* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2); 322 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 323 except that the C function is picked among a set of overloaded functions, 324 namely the one with rettype2 and parameters2. Two consecutive casts 325 are used to silence the "cannot find a match" and "invalid conversion" 326 errors that would otherwise occur. */ 327#if defined __cplusplus && defined GNULIB_NAMESPACE 328 /* The outer cast must be a reinterpret_cast. 329 The inner cast: When the function is defined as a set of overloaded 330 functions, it works as a static_cast<>, choosing the designated variant. 331 When the function is defined as a single variant, it works as a 332 reinterpret_cast<>. The parenthesized cast syntax works both ways. */ 333# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 334 namespace GNULIB_NAMESPACE \ 335 { \ 336 static const struct _gl_ ## func ## _wrapper \ 337 { \ 338 typedef rettype (*type) parameters; \ 339 \ 340 inline operator type () const \ 341 { \ 342 return reinterpret_cast<type>((rettype2 (*) parameters2)(::func)); \ 343 } \ 344 } func = {}; \ 345 } \ 346 _GL_EXTERN_C int _gl_cxxalias_dummy 347#else 348# define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 349 _GL_EXTERN_C int _gl_cxxalias_dummy 350#endif 351 352/* _GL_CXXALIASWARN (func); 353 causes a warning to be emitted when ::func is used but not when 354 GNULIB_NAMESPACE::func is used. func must be defined without overloaded 355 variants. */ 356#if defined __cplusplus && defined GNULIB_NAMESPACE 357# define _GL_CXXALIASWARN(func) \ 358 _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE) 359# define _GL_CXXALIASWARN_1(func,namespace) \ 360 _GL_CXXALIASWARN_2 (func, namespace) 361/* To work around GCC bug <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 362 we enable the warning only when not optimizing. */ 363# if !(defined __GNUC__ && !defined __clang__ && __OPTIMIZE__) 364# define _GL_CXXALIASWARN_2(func,namespace) \ 365 _GL_WARN_ON_USE (func, \ 366 "The symbol ::" #func " refers to the system function. " \ 367 "Use " #namespace "::" #func " instead.") 368# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 369# define _GL_CXXALIASWARN_2(func,namespace) \ 370 extern __typeof__ (func) func 371# else 372# define _GL_CXXALIASWARN_2(func,namespace) \ 373 _GL_EXTERN_C int _gl_cxxalias_dummy 374# endif 375#else 376# define _GL_CXXALIASWARN(func) \ 377 _GL_EXTERN_C int _gl_cxxalias_dummy 378#endif 379 380/* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes); 381 causes a warning to be emitted when the given overloaded variant of ::func 382 is used but not when GNULIB_NAMESPACE::func is used. */ 383#if defined __cplusplus && defined GNULIB_NAMESPACE 384# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 385 _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \ 386 GNULIB_NAMESPACE) 387# define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \ 388 _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace) 389/* To work around GCC bug <https://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 390 we enable the warning only when not optimizing. */ 391# if !(defined __GNUC__ && !defined __clang__ && __OPTIMIZE__) 392# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 393 _GL_WARN_ON_USE_CXX (func, rettype, rettype, parameters_and_attributes, \ 394 "The symbol ::" #func " refers to the system function. " \ 395 "Use " #namespace "::" #func " instead.") 396# else 397# define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 398 _GL_EXTERN_C int _gl_cxxalias_dummy 399# endif 400#else 401# define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 402 _GL_EXTERN_C int _gl_cxxalias_dummy 403#endif 404 405#endif /* _GL_CXXDEFS_H */ 406 407/* The definition of _GL_ARG_NONNULL is copied here. */ 408/* A C macro for declaring that specific arguments must not be NULL. 409 Copyright (C) 2009-2022 Free Software Foundation, Inc. 410 411 This program is free software: you can redistribute it and/or modify it 412 under the terms of the GNU Lesser General Public License as published 413 by the Free Software Foundation; either version 2 of the License, or 414 (at your option) any later version. 415 416 This program is distributed in the hope that it will be useful, 417 but WITHOUT ANY WARRANTY; without even the implied warranty of 418 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 419 Lesser General Public License for more details. 420 421 You should have received a copy of the GNU Lesser General Public License 422 along with this program. If not, see <https://www.gnu.org/licenses/>. */ 423 424/* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools 425 that the values passed as arguments n, ..., m must be non-NULL pointers. 426 n = 1 stands for the first argument, n = 2 for the second argument etc. */ 427#ifndef _GL_ARG_NONNULL 428# if __GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || defined __clang__ 429# define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params)) 430# else 431# define _GL_ARG_NONNULL(params) 432# endif 433#endif 434 435/* The definition of _GL_WARN_ON_USE is copied here. */ 436/* A C macro for emitting warnings if a function is used. 437 Copyright (C) 2010-2022 Free Software Foundation, Inc. 438 439 This program is free software: you can redistribute it and/or modify it 440 under the terms of the GNU Lesser General Public License as published 441 by the Free Software Foundation; either version 2 of the License, or 442 (at your option) any later version. 443 444 This program is distributed in the hope that it will be useful, 445 but WITHOUT ANY WARRANTY; without even the implied warranty of 446 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 447 Lesser General Public License for more details. 448 449 You should have received a copy of the GNU Lesser General Public License 450 along with this program. If not, see <https://www.gnu.org/licenses/>. */ 451 452/* _GL_WARN_ON_USE (function, "literal string") issues a declaration 453 for FUNCTION which will then trigger a compiler warning containing 454 the text of "literal string" anywhere that function is called, if 455 supported by the compiler. If the compiler does not support this 456 feature, the macro expands to an unused extern declaration. 457 458 _GL_WARN_ON_USE_ATTRIBUTE ("literal string") expands to the 459 attribute used in _GL_WARN_ON_USE. If the compiler does not support 460 this feature, it expands to empty. 461 462 These macros are useful for marking a function as a potential 463 portability trap, with the intent that "literal string" include 464 instructions on the replacement function that should be used 465 instead. 466 _GL_WARN_ON_USE is for functions with 'extern' linkage. 467 _GL_WARN_ON_USE_ATTRIBUTE is for functions with 'static' or 'inline' 468 linkage. 469 470 However, one of the reasons that a function is a portability trap is 471 if it has the wrong signature. Declaring FUNCTION with a different 472 signature in C is a compilation error, so this macro must use the 473 same type as any existing declaration so that programs that avoid 474 the problematic FUNCTION do not fail to compile merely because they 475 included a header that poisoned the function. But this implies that 476 _GL_WARN_ON_USE is only safe to use if FUNCTION is known to already 477 have a declaration. Use of this macro implies that there must not 478 be any other macro hiding the declaration of FUNCTION; but 479 undefining FUNCTION first is part of the poisoning process anyway 480 (although for symbols that are provided only via a macro, the result 481 is a compilation error rather than a warning containing 482 "literal string"). Also note that in C++, it is only safe to use if 483 FUNCTION has no overloads. 484 485 For an example, it is possible to poison 'getline' by: 486 - adding a call to gl_WARN_ON_USE_PREPARE([[#include <stdio.h>]], 487 [getline]) in configure.ac, which potentially defines 488 HAVE_RAW_DECL_GETLINE 489 - adding this code to a header that wraps the system <stdio.h>: 490 #undef getline 491 #if HAVE_RAW_DECL_GETLINE 492 _GL_WARN_ON_USE (getline, "getline is required by POSIX 2008, but" 493 "not universally present; use the gnulib module getline"); 494 #endif 495 496 It is not possible to directly poison global variables. But it is 497 possible to write a wrapper accessor function, and poison that 498 (less common usage, like &environ, will cause a compilation error 499 rather than issue the nice warning, but the end result of informing 500 the developer about their portability problem is still achieved): 501 #if HAVE_RAW_DECL_ENVIRON 502 static char *** 503 rpl_environ (void) { return &environ; } 504 _GL_WARN_ON_USE (rpl_environ, "environ is not always properly declared"); 505 # undef environ 506 # define environ (*rpl_environ ()) 507 #endif 508 or better (avoiding contradictory use of 'static' and 'extern'): 509 #if HAVE_RAW_DECL_ENVIRON 510 static char *** 511 _GL_WARN_ON_USE_ATTRIBUTE ("environ is not always properly declared") 512 rpl_environ (void) { return &environ; } 513 # undef environ 514 # define environ (*rpl_environ ()) 515 #endif 516 */ 517#ifndef _GL_WARN_ON_USE 518 519# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 520/* A compiler attribute is available in gcc versions 4.3.0 and later. */ 521# define _GL_WARN_ON_USE(function, message) \ 522_GL_WARN_EXTERN_C __typeof__ (function) function __attribute__ ((__warning__ (message))) 523# define _GL_WARN_ON_USE_ATTRIBUTE(message) \ 524 __attribute__ ((__warning__ (message))) 525# elif __clang_major__ >= 4 526/* Another compiler attribute is available in clang. */ 527# define _GL_WARN_ON_USE(function, message) \ 528_GL_WARN_EXTERN_C __typeof__ (function) function \ 529 __attribute__ ((__diagnose_if__ (1, message, "warning"))) 530# define _GL_WARN_ON_USE_ATTRIBUTE(message) \ 531 __attribute__ ((__diagnose_if__ (1, message, "warning"))) 532# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 533/* Verify the existence of the function. */ 534# define _GL_WARN_ON_USE(function, message) \ 535_GL_WARN_EXTERN_C __typeof__ (function) function 536# define _GL_WARN_ON_USE_ATTRIBUTE(message) 537# else /* Unsupported. */ 538# define _GL_WARN_ON_USE(function, message) \ 539_GL_WARN_EXTERN_C int _gl_warn_on_use 540# define _GL_WARN_ON_USE_ATTRIBUTE(message) 541# endif 542#endif 543 544/* _GL_WARN_ON_USE_CXX (function, rettype_gcc, rettype_clang, parameters_and_attributes, "message") 545 is like _GL_WARN_ON_USE (function, "message"), except that in C++ mode the 546 function is declared with the given prototype, consisting of return type, 547 parameters, and attributes. 548 This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does 549 not work in this case. */ 550#ifndef _GL_WARN_ON_USE_CXX 551# if !defined __cplusplus 552# define _GL_WARN_ON_USE_CXX(function,rettype_gcc,rettype_clang,parameters_and_attributes,msg) \ 553 _GL_WARN_ON_USE (function, msg) 554# else 555# if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 556/* A compiler attribute is available in gcc versions 4.3.0 and later. */ 557# define _GL_WARN_ON_USE_CXX(function,rettype_gcc,rettype_clang,parameters_and_attributes,msg) \ 558extern rettype_gcc function parameters_and_attributes \ 559 __attribute__ ((__warning__ (msg))) 560# elif __clang_major__ >= 4 561/* Another compiler attribute is available in clang. */ 562# define _GL_WARN_ON_USE_CXX(function,rettype_gcc,rettype_clang,parameters_and_attributes,msg) \ 563extern rettype_clang function parameters_and_attributes \ 564 __attribute__ ((__diagnose_if__ (1, msg, "warning"))) 565# elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 566/* Verify the existence of the function. */ 567# define _GL_WARN_ON_USE_CXX(function,rettype_gcc,rettype_clang,parameters_and_attributes,msg) \ 568extern rettype_gcc function parameters_and_attributes 569# else /* Unsupported. */ 570# define _GL_WARN_ON_USE_CXX(function,rettype_gcc,rettype_clang,parameters_and_attributes,msg) \ 571_GL_WARN_EXTERN_C int _gl_warn_on_use 572# endif 573# endif 574#endif 575 576/* _GL_WARN_EXTERN_C declaration; 577 performs the declaration with C linkage. */ 578#ifndef _GL_WARN_EXTERN_C 579# if defined __cplusplus 580# define _GL_WARN_EXTERN_C extern "C" 581# else 582# define _GL_WARN_EXTERN_C extern 583# endif 584#endif 585 586#ifdef __cplusplus 587/* Helper macros to define type-generic function FUNC as overloaded functions, 588 rather than as macros like in C. POSIX declares these with an argument of 589 real-floating (that is, one of float, double, or long double). */ 590# define _GL_MATH_CXX_REAL_FLOATING_DECL_1(func) \ 591static inline int \ 592_gl_cxx_ ## func ## f (float f) \ 593{ \ 594 return func (f); \ 595} \ 596static inline int \ 597_gl_cxx_ ## func ## d (double d) \ 598{ \ 599 return func (d); \ 600} \ 601static inline int \ 602_gl_cxx_ ## func ## l (long double l) \ 603{ \ 604 return func (l); \ 605} 606# define _GL_MATH_CXX_REAL_FLOATING_DECL_2(func,rpl_func,rettype) \ 607_GL_BEGIN_NAMESPACE \ 608inline rettype \ 609rpl_func (float f) \ 610{ \ 611 return _gl_cxx_ ## func ## f (f); \ 612} \ 613inline rettype \ 614rpl_func (double d) \ 615{ \ 616 return _gl_cxx_ ## func ## d (d); \ 617} \ 618inline rettype \ 619rpl_func (long double l) \ 620{ \ 621 return _gl_cxx_ ## func ## l (l); \ 622} \ 623_GL_END_NAMESPACE 624#endif 625 626/* Helper macros to define a portability warning for the 627 classification macro FUNC called with VALUE. POSIX declares the 628 classification macros with an argument of real-floating (that is, 629 one of float, double, or long double). */ 630#define _GL_WARN_REAL_FLOATING_DECL(func) \ 631_GL_MATH_INLINE int \ 632_GL_WARN_ON_USE_ATTRIBUTE (#func " is unportable - " \ 633 "use gnulib module " #func " for portability") \ 634rpl_ ## func ## f (float f) \ 635{ \ 636 return func (f); \ 637} \ 638_GL_MATH_INLINE int \ 639_GL_WARN_ON_USE_ATTRIBUTE (#func " is unportable - " \ 640 "use gnulib module " #func " for portability") \ 641rpl_ ## func ## d (double d) \ 642{ \ 643 return func (d); \ 644} \ 645_GL_MATH_INLINE int \ 646_GL_WARN_ON_USE_ATTRIBUTE (#func " is unportable - " \ 647 "use gnulib module " #func " for portability") \ 648rpl_ ## func ## l (long double l) \ 649{ \ 650 return func (l); \ 651} 652#define _GL_WARN_REAL_FLOATING_IMPL(func, value) \ 653 (sizeof (value) == sizeof (float) ? rpl_ ## func ## f (value) \ 654 : sizeof (value) == sizeof (double) ? rpl_ ## func ## d (value) \ 655 : rpl_ ## func ## l (value)) 656 657 658#if 0 659/* Pull in a function that fixes the 'int' to 'long double' conversion 660 of glibc 2.7. */ 661_GL_EXTERN_C void _Qp_itoq (long double *, int); 662static void (*_gl_math_fix_itold) (long double *, int) = _Qp_itoq; 663#endif 664 665 666/* POSIX allows platforms that don't support NAN. But all major 667 machines in the past 15 years have supported something close to 668 IEEE NaN, so we define this unconditionally. We also must define 669 it on platforms like Solaris 10, where NAN is present but defined 670 as a function pointer rather than a floating point constant. */ 671#if !defined NAN || 0 672# if !GNULIB_defined_NAN 673# undef NAN 674 /* The Compaq (ex-DEC) C 6.4 compiler and the Microsoft MSVC 9 compiler 675 choke on the expression 0.0 / 0.0. */ 676# if defined __DECC || defined _MSC_VER 677_GL_MATH_INLINE float 678_NaN () 679{ 680 static float zero = 0.0f; 681 return zero / zero; 682} 683# define NAN (_NaN()) 684# else 685# define NAN (0.0f / 0.0f) 686# endif 687# define GNULIB_defined_NAN 1 688# endif 689#endif 690 691/* Solaris 10 defines HUGE_VAL, but as a function pointer rather 692 than a floating point constant. */ 693#if 0 694# undef HUGE_VALF 695# define HUGE_VALF (1.0f / 0.0f) 696# undef HUGE_VAL 697# define HUGE_VAL (1.0 / 0.0) 698# undef HUGE_VALL 699# define HUGE_VALL (1.0L / 0.0L) 700#endif 701 702/* HUGE_VALF is a 'float' Infinity. */ 703#ifndef HUGE_VALF 704# if defined _MSC_VER 705/* The Microsoft MSVC 9 compiler chokes on the expression 1.0f / 0.0f. */ 706# define HUGE_VALF (1e25f * 1e25f) 707# else 708# define HUGE_VALF (1.0f / 0.0f) 709# endif 710#endif 711 712/* HUGE_VAL is a 'double' Infinity. */ 713#ifndef HUGE_VAL 714# if defined _MSC_VER 715/* The Microsoft MSVC 9 compiler chokes on the expression 1.0 / 0.0. */ 716# define HUGE_VAL (1e250 * 1e250) 717# else 718# define HUGE_VAL (1.0 / 0.0) 719# endif 720#endif 721 722/* HUGE_VALL is a 'long double' Infinity. */ 723#ifndef HUGE_VALL 724# if defined _MSC_VER 725/* The Microsoft MSVC 9 compiler chokes on the expression 1.0L / 0.0L. */ 726# define HUGE_VALL (1e250L * 1e250L) 727# else 728# define HUGE_VALL (1.0L / 0.0L) 729# endif 730#endif 731 732 733#if defined FP_ILOGB0 && defined FP_ILOGBNAN 734 /* Ensure FP_ILOGB0 and FP_ILOGBNAN are correct. */ 735# if defined __HAIKU__ 736 /* Haiku: match what ilogb() does */ 737# undef FP_ILOGB0 738# undef FP_ILOGBNAN 739# define FP_ILOGB0 (- 2147483647 - 1) /* INT_MIN */ 740# define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */ 741# endif 742#else 743 /* Ensure FP_ILOGB0 and FP_ILOGBNAN are defined. */ 744# if defined __NetBSD__ || defined __sgi 745 /* NetBSD, IRIX 6.5: match what ilogb() does */ 746# define FP_ILOGB0 (- 2147483647 - 1) /* INT_MIN */ 747# define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */ 748# elif defined _AIX 749 /* AIX 5.1: match what ilogb() does in AIX >= 5.2 */ 750# define FP_ILOGB0 (- 2147483647 - 1) /* INT_MIN */ 751# define FP_ILOGBNAN 2147483647 /* INT_MAX */ 752# elif defined __sun 753 /* Solaris 9: match what ilogb() does */ 754# define FP_ILOGB0 (- 2147483647) /* - INT_MAX */ 755# define FP_ILOGBNAN 2147483647 /* INT_MAX */ 756# else 757 /* Gnulib defined values. */ 758# define FP_ILOGB0 (- 2147483647) /* - INT_MAX */ 759# define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */ 760# endif 761#endif 762 763 764#if 0 765# if 0 766# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 767# undef acosf 768# define acosf rpl_acosf 769# endif 770_GL_FUNCDECL_RPL (acosf, float, (float x)); 771_GL_CXXALIAS_RPL (acosf, float, (float x)); 772# else 773# if !1 774# undef acosf 775_GL_FUNCDECL_SYS (acosf, float, (float x)); 776# endif 777_GL_CXXALIAS_SYS (acosf, float, (float x)); 778# endif 779_GL_CXXALIASWARN (acosf); 780#elif defined GNULIB_POSIXCHECK 781# undef acosf 782# if HAVE_RAW_DECL_ACOSF 783_GL_WARN_ON_USE (acosf, "acosf is unportable - " 784 "use gnulib module acosf for portability"); 785# endif 786#endif 787 788#if 0 789# if !1 || !1 790# undef acosl 791_GL_FUNCDECL_SYS (acosl, long double, (long double x)); 792# endif 793_GL_CXXALIAS_SYS (acosl, long double, (long double x)); 794# if __GLIBC__ >= 2 795_GL_CXXALIASWARN (acosl); 796# endif 797#elif defined GNULIB_POSIXCHECK 798# undef acosl 799# if HAVE_RAW_DECL_ACOSL 800_GL_WARN_ON_USE (acosl, "acosl is unportable - " 801 "use gnulib module acosl for portability"); 802# endif 803#endif 804 805 806#if 0 807# if 0 808# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 809# undef asinf 810# define asinf rpl_asinf 811# endif 812_GL_FUNCDECL_RPL (asinf, float, (float x)); 813_GL_CXXALIAS_RPL (asinf, float, (float x)); 814# else 815# if !1 816# undef asinf 817_GL_FUNCDECL_SYS (asinf, float, (float x)); 818# endif 819_GL_CXXALIAS_SYS (asinf, float, (float x)); 820# endif 821_GL_CXXALIASWARN (asinf); 822#elif defined GNULIB_POSIXCHECK 823# undef asinf 824# if HAVE_RAW_DECL_ASINF 825_GL_WARN_ON_USE (asinf, "asinf is unportable - " 826 "use gnulib module asinf for portability"); 827# endif 828#endif 829 830#if 0 831# if !1 || !1 832# undef asinl 833_GL_FUNCDECL_SYS (asinl, long double, (long double x)); 834# endif 835_GL_CXXALIAS_SYS (asinl, long double, (long double x)); 836# if __GLIBC__ >= 2 837_GL_CXXALIASWARN (asinl); 838# endif 839#elif defined GNULIB_POSIXCHECK 840# undef asinl 841# if HAVE_RAW_DECL_ASINL 842_GL_WARN_ON_USE (asinl, "asinl is unportable - " 843 "use gnulib module asinl for portability"); 844# endif 845#endif 846 847 848#if 0 849# if 0 850# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 851# undef atanf 852# define atanf rpl_atanf 853# endif 854_GL_FUNCDECL_RPL (atanf, float, (float x)); 855_GL_CXXALIAS_RPL (atanf, float, (float x)); 856# else 857# if !1 858# undef atanf 859_GL_FUNCDECL_SYS (atanf, float, (float x)); 860# endif 861_GL_CXXALIAS_SYS (atanf, float, (float x)); 862# endif 863_GL_CXXALIASWARN (atanf); 864#elif defined GNULIB_POSIXCHECK 865# undef atanf 866# if HAVE_RAW_DECL_ATANF 867_GL_WARN_ON_USE (atanf, "atanf is unportable - " 868 "use gnulib module atanf for portability"); 869# endif 870#endif 871 872#if 0 873# if !1 || !1 874# undef atanl 875_GL_FUNCDECL_SYS (atanl, long double, (long double x)); 876# endif 877_GL_CXXALIAS_SYS (atanl, long double, (long double x)); 878# if __GLIBC__ >= 2 879_GL_CXXALIASWARN (atanl); 880# endif 881#elif defined GNULIB_POSIXCHECK 882# undef atanl 883# if HAVE_RAW_DECL_ATANL 884_GL_WARN_ON_USE (atanl, "atanl is unportable - " 885 "use gnulib module atanl for portability"); 886# endif 887#endif 888 889 890#if 0 891# if 0 892# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 893# undef atan2f 894# define atan2f rpl_atan2f 895# endif 896_GL_FUNCDECL_RPL (atan2f, float, (float y, float x)); 897_GL_CXXALIAS_RPL (atan2f, float, (float y, float x)); 898# else 899# if !1 900# undef atan2f 901_GL_FUNCDECL_SYS (atan2f, float, (float y, float x)); 902# endif 903_GL_CXXALIAS_SYS (atan2f, float, (float y, float x)); 904# endif 905_GL_CXXALIASWARN (atan2f); 906#elif defined GNULIB_POSIXCHECK 907# undef atan2f 908# if HAVE_RAW_DECL_ATAN2F 909_GL_WARN_ON_USE (atan2f, "atan2f is unportable - " 910 "use gnulib module atan2f for portability"); 911# endif 912#endif 913 914 915#if 0 916# if 0 917# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 918# undef cbrtf 919# define cbrtf rpl_cbrtf 920# endif 921_GL_FUNCDECL_RPL (cbrtf, float, (float x)); 922_GL_CXXALIAS_RPL (cbrtf, float, (float x)); 923# else 924# if !1 925_GL_FUNCDECL_SYS (cbrtf, float, (float x)); 926# endif 927_GL_CXXALIAS_SYS (cbrtf, float, (float x)); 928# endif 929_GL_CXXALIASWARN (cbrtf); 930#elif defined GNULIB_POSIXCHECK 931# undef cbrtf 932# if HAVE_RAW_DECL_CBRTF 933_GL_WARN_ON_USE (cbrtf, "cbrtf is unportable - " 934 "use gnulib module cbrtf for portability"); 935# endif 936#endif 937 938#if 0 939# if !1 940_GL_FUNCDECL_SYS (cbrt, double, (double x)); 941# endif 942_GL_CXXALIAS_SYS (cbrt, double, (double x)); 943# if __GLIBC__ >= 2 944_GL_CXXALIASWARN1 (cbrt, double, (double x)); 945# endif 946#elif defined GNULIB_POSIXCHECK 947# undef cbrt 948# if HAVE_RAW_DECL_CBRT 949_GL_WARN_ON_USE (cbrt, "cbrt is unportable - " 950 "use gnulib module cbrt for portability"); 951# endif 952#endif 953 954#if 0 955# if 0 956# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 957# undef cbrtl 958# define cbrtl rpl_cbrtl 959# endif 960_GL_FUNCDECL_RPL (cbrtl, long double, (long double x)); 961_GL_CXXALIAS_RPL (cbrtl, long double, (long double x)); 962# else 963# if !1 964_GL_FUNCDECL_SYS (cbrtl, long double, (long double x)); 965# endif 966_GL_CXXALIAS_SYS (cbrtl, long double, (long double x)); 967# endif 968_GL_CXXALIASWARN (cbrtl); 969#elif defined GNULIB_POSIXCHECK 970# undef cbrtl 971# if HAVE_RAW_DECL_CBRTL 972_GL_WARN_ON_USE (cbrtl, "cbrtl is unportable - " 973 "use gnulib module cbrtl for portability"); 974# endif 975#endif 976 977 978#if 0 979# if 0 980# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 981# undef ceilf 982# define ceilf rpl_ceilf 983# endif 984_GL_FUNCDECL_RPL (ceilf, float, (float x)); 985_GL_CXXALIAS_RPL (ceilf, float, (float x)); 986# else 987# if !1 988# undef ceilf 989_GL_FUNCDECL_SYS (ceilf, float, (float x)); 990# endif 991_GL_CXXALIAS_SYS (ceilf, float, (float x)); 992# endif 993_GL_CXXALIASWARN (ceilf); 994#elif defined GNULIB_POSIXCHECK 995# undef ceilf 996# if HAVE_RAW_DECL_CEILF 997_GL_WARN_ON_USE (ceilf, "ceilf is unportable - " 998 "use gnulib module ceilf for portability"); 999# endif 1000#endif 1001 1002#if 0 1003# if 0 1004# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1005# undef ceil 1006# define ceil rpl_ceil 1007# endif 1008_GL_FUNCDECL_RPL (ceil, double, (double x)); 1009_GL_CXXALIAS_RPL (ceil, double, (double x)); 1010# else 1011_GL_CXXALIAS_SYS (ceil, double, (double x)); 1012# endif 1013# if __GLIBC__ >= 2 1014_GL_CXXALIASWARN1 (ceil, double, (double x)); 1015# endif 1016#endif 1017 1018#if 0 1019# if 0 1020# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1021# undef ceill 1022# define ceill rpl_ceill 1023# endif 1024_GL_FUNCDECL_RPL (ceill, long double, (long double x)); 1025_GL_CXXALIAS_RPL (ceill, long double, (long double x)); 1026# else 1027# if !1 1028# undef ceill 1029_GL_FUNCDECL_SYS (ceill, long double, (long double x)); 1030# endif 1031_GL_CXXALIAS_SYS (ceill, long double, (long double x)); 1032# endif 1033# if __GLIBC__ >= 2 1034_GL_CXXALIASWARN (ceill); 1035# endif 1036#elif defined GNULIB_POSIXCHECK 1037# undef ceill 1038# if HAVE_RAW_DECL_CEILL 1039_GL_WARN_ON_USE (ceill, "ceill is unportable - " 1040 "use gnulib module ceill for portability"); 1041# endif 1042#endif 1043 1044 1045#if 0 1046# if !1 1047# undef copysignf 1048_GL_FUNCDECL_SYS (copysignf, float, (float x, float y)); 1049# endif 1050_GL_CXXALIAS_SYS (copysignf, float, (float x, float y)); 1051_GL_CXXALIASWARN (copysignf); 1052#elif defined GNULIB_POSIXCHECK 1053# undef copysignf 1054# if HAVE_RAW_DECL_COPYSIGNF 1055_GL_WARN_ON_USE (copysignf, "copysignf is unportable - " 1056 "use gnulib module copysignf for portability"); 1057# endif 1058#endif 1059 1060#if 0 1061# if !1 1062_GL_FUNCDECL_SYS (copysign, double, (double x, double y)); 1063# endif 1064_GL_CXXALIAS_SYS (copysign, double, (double x, double y)); 1065# if __GLIBC__ >= 2 1066_GL_CXXALIASWARN1 (copysign, double, (double x, double y)); 1067# endif 1068#elif defined GNULIB_POSIXCHECK 1069# undef copysign 1070# if HAVE_RAW_DECL_COPYSIGN 1071_GL_WARN_ON_USE (copysign, "copysign is unportable - " 1072 "use gnulib module copysign for portability"); 1073# endif 1074#endif 1075 1076#if 0 1077# if !1 1078_GL_FUNCDECL_SYS (copysignl, long double, (long double x, long double y)); 1079# endif 1080_GL_CXXALIAS_SYS (copysignl, long double, (long double x, long double y)); 1081_GL_CXXALIASWARN (copysignl); 1082#elif defined GNULIB_POSIXCHECK 1083# undef copysignl 1084# if HAVE_RAW_DECL_COPYSIGNL 1085_GL_WARN_ON_USE (copysign, "copysignl is unportable - " 1086 "use gnulib module copysignl for portability"); 1087# endif 1088#endif 1089 1090 1091#if 0 1092# if 0 1093# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1094# undef cosf 1095# define cosf rpl_cosf 1096# endif 1097_GL_FUNCDECL_RPL (cosf, float, (float x)); 1098_GL_CXXALIAS_RPL (cosf, float, (float x)); 1099# else 1100# if !1 1101# undef cosf 1102_GL_FUNCDECL_SYS (cosf, float, (float x)); 1103# endif 1104_GL_CXXALIAS_SYS (cosf, float, (float x)); 1105# endif 1106_GL_CXXALIASWARN (cosf); 1107#elif defined GNULIB_POSIXCHECK 1108# undef cosf 1109# if HAVE_RAW_DECL_COSF 1110_GL_WARN_ON_USE (cosf, "cosf is unportable - " 1111 "use gnulib module cosf for portability"); 1112# endif 1113#endif 1114 1115#if 0 1116# if !1 || !1 1117# undef cosl 1118_GL_FUNCDECL_SYS (cosl, long double, (long double x)); 1119# endif 1120_GL_CXXALIAS_SYS (cosl, long double, (long double x)); 1121# if __GLIBC__ >= 2 1122_GL_CXXALIASWARN (cosl); 1123# endif 1124#elif defined GNULIB_POSIXCHECK 1125# undef cosl 1126# if HAVE_RAW_DECL_COSL 1127_GL_WARN_ON_USE (cosl, "cosl is unportable - " 1128 "use gnulib module cosl for portability"); 1129# endif 1130#endif 1131 1132 1133#if 0 1134# if 0 1135# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1136# undef coshf 1137# define coshf rpl_coshf 1138# endif 1139_GL_FUNCDECL_RPL (coshf, float, (float x)); 1140_GL_CXXALIAS_RPL (coshf, float, (float x)); 1141# else 1142# if !1 1143# undef coshf 1144_GL_FUNCDECL_SYS (coshf, float, (float x)); 1145# endif 1146_GL_CXXALIAS_SYS (coshf, float, (float x)); 1147# endif 1148_GL_CXXALIASWARN (coshf); 1149#elif defined GNULIB_POSIXCHECK 1150# undef coshf 1151# if HAVE_RAW_DECL_COSHF 1152_GL_WARN_ON_USE (coshf, "coshf is unportable - " 1153 "use gnulib module coshf for portability"); 1154# endif 1155#endif 1156 1157 1158#if 0 1159# if 0 1160# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1161# undef expf 1162# define expf rpl_expf 1163# endif 1164_GL_FUNCDECL_RPL (expf, float, (float x)); 1165_GL_CXXALIAS_RPL (expf, float, (float x)); 1166# else 1167# if !1 1168# undef expf 1169_GL_FUNCDECL_SYS (expf, float, (float x)); 1170# endif 1171_GL_CXXALIAS_SYS (expf, float, (float x)); 1172# endif 1173_GL_CXXALIASWARN (expf); 1174#elif defined GNULIB_POSIXCHECK 1175# undef expf 1176# if HAVE_RAW_DECL_EXPF 1177_GL_WARN_ON_USE (expf, "expf is unportable - " 1178 "use gnulib module expf for portability"); 1179# endif 1180#endif 1181 1182#if 0 1183# if 0 1184# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1185# undef expl 1186# define expl rpl_expl 1187# endif 1188_GL_FUNCDECL_RPL (expl, long double, (long double x)); 1189_GL_CXXALIAS_RPL (expl, long double, (long double x)); 1190# else 1191# if !1 || !1 1192# undef expl 1193_GL_FUNCDECL_SYS (expl, long double, (long double x)); 1194# endif 1195_GL_CXXALIAS_SYS (expl, long double, (long double x)); 1196# endif 1197# if __GLIBC__ >= 2 1198_GL_CXXALIASWARN (expl); 1199# endif 1200#elif defined GNULIB_POSIXCHECK 1201# undef expl 1202# if HAVE_RAW_DECL_EXPL 1203_GL_WARN_ON_USE (expl, "expl is unportable - " 1204 "use gnulib module expl for portability"); 1205# endif 1206#endif 1207 1208 1209#if 0 1210# if !1 1211_GL_FUNCDECL_SYS (exp2f, float, (float x)); 1212# endif 1213_GL_CXXALIAS_SYS (exp2f, float, (float x)); 1214_GL_CXXALIASWARN (exp2f); 1215#elif defined GNULIB_POSIXCHECK 1216# undef exp2f 1217# if HAVE_RAW_DECL_EXP2F 1218_GL_WARN_ON_USE (exp2f, "exp2f is unportable - " 1219 "use gnulib module exp2f for portability"); 1220# endif 1221#endif 1222 1223#if 0 1224# if 0 1225# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1226# undef exp2 1227# define exp2 rpl_exp2 1228# endif 1229_GL_FUNCDECL_RPL (exp2, double, (double x)); 1230_GL_CXXALIAS_RPL (exp2, double, (double x)); 1231# else 1232# if !1 1233_GL_FUNCDECL_SYS (exp2, double, (double x)); 1234# endif 1235_GL_CXXALIAS_SYS (exp2, double, (double x)); 1236# endif 1237# if __GLIBC__ >= 2 1238_GL_CXXALIASWARN1 (exp2, double, (double x)); 1239# endif 1240#elif defined GNULIB_POSIXCHECK 1241# undef exp2 1242# if HAVE_RAW_DECL_EXP2 1243_GL_WARN_ON_USE (exp2, "exp2 is unportable - " 1244 "use gnulib module exp2 for portability"); 1245# endif 1246#endif 1247 1248#if 0 1249# if 0 1250# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1251# undef exp2l 1252# define exp2l rpl_exp2l 1253# endif 1254_GL_FUNCDECL_RPL (exp2l, long double, (long double x)); 1255_GL_CXXALIAS_RPL (exp2l, long double, (long double x)); 1256# else 1257# if !1 1258# undef exp2l 1259_GL_FUNCDECL_SYS (exp2l, long double, (long double x)); 1260# endif 1261_GL_CXXALIAS_SYS (exp2l, long double, (long double x)); 1262# endif 1263_GL_CXXALIASWARN (exp2l); 1264#elif defined GNULIB_POSIXCHECK 1265# undef exp2l 1266# if HAVE_RAW_DECL_EXP2L 1267_GL_WARN_ON_USE (exp2l, "exp2l is unportable - " 1268 "use gnulib module exp2l for portability"); 1269# endif 1270#endif 1271 1272 1273#if 0 1274# if 0 1275# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1276# undef expm1f 1277# define expm1f rpl_expm1f 1278# endif 1279_GL_FUNCDECL_RPL (expm1f, float, (float x)); 1280_GL_CXXALIAS_RPL (expm1f, float, (float x)); 1281# else 1282# if !1 1283_GL_FUNCDECL_SYS (expm1f, float, (float x)); 1284# endif 1285_GL_CXXALIAS_SYS (expm1f, float, (float x)); 1286# endif 1287_GL_CXXALIASWARN (expm1f); 1288#elif defined GNULIB_POSIXCHECK 1289# undef expm1f 1290# if HAVE_RAW_DECL_EXPM1F 1291_GL_WARN_ON_USE (expm1f, "expm1f is unportable - " 1292 "use gnulib module expm1f for portability"); 1293# endif 1294#endif 1295 1296#if 0 1297# if 0 1298# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1299# undef expm1 1300# define expm1 rpl_expm1 1301# endif 1302_GL_FUNCDECL_RPL (expm1, double, (double x)); 1303_GL_CXXALIAS_RPL (expm1, double, (double x)); 1304# else 1305# if !1 1306_GL_FUNCDECL_SYS (expm1, double, (double x)); 1307# endif 1308_GL_CXXALIAS_SYS (expm1, double, (double x)); 1309# endif 1310# if __GLIBC__ >= 2 1311_GL_CXXALIASWARN1 (expm1, double, (double x)); 1312# endif 1313#elif defined GNULIB_POSIXCHECK 1314# undef expm1 1315# if HAVE_RAW_DECL_EXPM1 1316_GL_WARN_ON_USE (expm1, "expm1 is unportable - " 1317 "use gnulib module expm1 for portability"); 1318# endif 1319#endif 1320 1321#if 0 1322# if 0 1323# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1324# undef expm1l 1325# define expm1l rpl_expm1l 1326# endif 1327_GL_FUNCDECL_RPL (expm1l, long double, (long double x)); 1328_GL_CXXALIAS_RPL (expm1l, long double, (long double x)); 1329# else 1330# if !1 1331# undef expm1l 1332# if !(defined __cplusplus && defined _AIX) 1333_GL_FUNCDECL_SYS (expm1l, long double, (long double x)); 1334# endif 1335# endif 1336_GL_CXXALIAS_SYS (expm1l, long double, (long double x)); 1337# endif 1338_GL_CXXALIASWARN (expm1l); 1339#elif defined GNULIB_POSIXCHECK 1340# undef expm1l 1341# if HAVE_RAW_DECL_EXPM1L 1342_GL_WARN_ON_USE (expm1l, "expm1l is unportable - " 1343 "use gnulib module expm1l for portability"); 1344# endif 1345#endif 1346 1347 1348#if 0 1349# if !1 1350# undef fabsf 1351_GL_FUNCDECL_SYS (fabsf, float, (float x)); 1352# endif 1353_GL_CXXALIAS_SYS (fabsf, float, (float x)); 1354# if __GLIBC__ >= 2 1355_GL_CXXALIASWARN (fabsf); 1356# endif 1357#elif defined GNULIB_POSIXCHECK 1358# undef fabsf 1359# if HAVE_RAW_DECL_FABSF 1360_GL_WARN_ON_USE (fabsf, "fabsf is unportable - " 1361 "use gnulib module fabsf for portability"); 1362# endif 1363#endif 1364 1365#if 0 1366# if 0 1367# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1368# undef fabsl 1369# define fabsl rpl_fabsl 1370# endif 1371_GL_FUNCDECL_RPL (fabsl, long double, (long double x)); 1372_GL_CXXALIAS_RPL (fabsl, long double, (long double x)); 1373# else 1374# if !1 1375# undef fabsl 1376_GL_FUNCDECL_SYS (fabsl, long double, (long double x)); 1377# endif 1378_GL_CXXALIAS_SYS (fabsl, long double, (long double x)); 1379# endif 1380# if __GLIBC__ >= 2 1381_GL_CXXALIASWARN (fabsl); 1382# endif 1383#elif defined GNULIB_POSIXCHECK 1384# undef fabsl 1385# if HAVE_RAW_DECL_FABSL 1386_GL_WARN_ON_USE (fabsl, "fabsl is unportable - " 1387 "use gnulib module fabsl for portability"); 1388# endif 1389#endif 1390 1391 1392#if 0 1393# if 0 1394# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1395# undef floorf 1396# define floorf rpl_floorf 1397# endif 1398_GL_FUNCDECL_RPL (floorf, float, (float x)); 1399_GL_CXXALIAS_RPL (floorf, float, (float x)); 1400# else 1401# if !1 1402# undef floorf 1403_GL_FUNCDECL_SYS (floorf, float, (float x)); 1404# endif 1405_GL_CXXALIAS_SYS (floorf, float, (float x)); 1406# endif 1407_GL_CXXALIASWARN (floorf); 1408#elif defined GNULIB_POSIXCHECK 1409# undef floorf 1410# if HAVE_RAW_DECL_FLOORF 1411_GL_WARN_ON_USE (floorf, "floorf is unportable - " 1412 "use gnulib module floorf for portability"); 1413# endif 1414#endif 1415 1416#if 0 1417# if 0 1418# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1419# undef floor 1420# define floor rpl_floor 1421# endif 1422_GL_FUNCDECL_RPL (floor, double, (double x)); 1423_GL_CXXALIAS_RPL (floor, double, (double x)); 1424# else 1425_GL_CXXALIAS_SYS (floor, double, (double x)); 1426# endif 1427# if __GLIBC__ >= 2 1428_GL_CXXALIASWARN1 (floor, double, (double x)); 1429# endif 1430#endif 1431 1432#if 0 1433# if 0 1434# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1435# undef floorl 1436# define floorl rpl_floorl 1437# endif 1438_GL_FUNCDECL_RPL (floorl, long double, (long double x)); 1439_GL_CXXALIAS_RPL (floorl, long double, (long double x)); 1440# else 1441# if !1 1442# undef floorl 1443_GL_FUNCDECL_SYS (floorl, long double, (long double x)); 1444# endif 1445_GL_CXXALIAS_SYS (floorl, long double, (long double x)); 1446# endif 1447# if __GLIBC__ >= 2 1448_GL_CXXALIASWARN (floorl); 1449# endif 1450#elif defined GNULIB_POSIXCHECK 1451# undef floorl 1452# if HAVE_RAW_DECL_FLOORL 1453_GL_WARN_ON_USE (floorl, "floorl is unportable - " 1454 "use gnulib module floorl for portability"); 1455# endif 1456#endif 1457 1458 1459#if 0 1460# if 0 1461# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1462# undef fmaf 1463# define fmaf rpl_fmaf 1464# endif 1465_GL_FUNCDECL_RPL (fmaf, float, (float x, float y, float z)); 1466_GL_CXXALIAS_RPL (fmaf, float, (float x, float y, float z)); 1467# else 1468# if !1 1469# undef fmaf 1470_GL_FUNCDECL_SYS (fmaf, float, (float x, float y, float z)); 1471# endif 1472_GL_CXXALIAS_SYS (fmaf, float, (float x, float y, float z)); 1473# endif 1474_GL_CXXALIASWARN (fmaf); 1475#elif defined GNULIB_POSIXCHECK 1476# undef fmaf 1477# if HAVE_RAW_DECL_FMAF 1478_GL_WARN_ON_USE (fmaf, "fmaf is unportable - " 1479 "use gnulib module fmaf for portability"); 1480# endif 1481#endif 1482 1483#if 0 1484# if 0 1485# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1486# undef fma 1487# define fma rpl_fma 1488# endif 1489_GL_FUNCDECL_RPL (fma, double, (double x, double y, double z)); 1490_GL_CXXALIAS_RPL (fma, double, (double x, double y, double z)); 1491# else 1492# if !1 1493# undef fma 1494_GL_FUNCDECL_SYS (fma, double, (double x, double y, double z)); 1495# endif 1496_GL_CXXALIAS_SYS (fma, double, (double x, double y, double z)); 1497# endif 1498# if __GLIBC__ >= 2 1499_GL_CXXALIASWARN1 (fma, double, (double x, double y, double z)); 1500# endif 1501#elif defined GNULIB_POSIXCHECK 1502# undef fma 1503# if HAVE_RAW_DECL_FMA 1504_GL_WARN_ON_USE (fma, "fma is unportable - " 1505 "use gnulib module fma for portability"); 1506# endif 1507#endif 1508 1509#if 0 1510# if 0 1511# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1512# undef fmal 1513# define fmal rpl_fmal 1514# endif 1515_GL_FUNCDECL_RPL (fmal, long double, 1516 (long double x, long double y, long double z)); 1517_GL_CXXALIAS_RPL (fmal, long double, 1518 (long double x, long double y, long double z)); 1519# else 1520# if !1 1521# undef fmal 1522# if !(defined __cplusplus && defined _AIX) 1523_GL_FUNCDECL_SYS (fmal, long double, 1524 (long double x, long double y, long double z)); 1525# endif 1526# endif 1527_GL_CXXALIAS_SYS (fmal, long double, 1528 (long double x, long double y, long double z)); 1529# endif 1530_GL_CXXALIASWARN (fmal); 1531#elif defined GNULIB_POSIXCHECK 1532# undef fmal 1533# if HAVE_RAW_DECL_FMAL 1534_GL_WARN_ON_USE (fmal, "fmal is unportable - " 1535 "use gnulib module fmal for portability"); 1536# endif 1537#endif 1538 1539 1540#if 0 1541# if 0 1542# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1543# undef fmodf 1544# define fmodf rpl_fmodf 1545# endif 1546_GL_FUNCDECL_RPL (fmodf, float, (float x, float y)); 1547_GL_CXXALIAS_RPL (fmodf, float, (float x, float y)); 1548# else 1549# if !1 1550# undef fmodf 1551_GL_FUNCDECL_SYS (fmodf, float, (float x, float y)); 1552# endif 1553_GL_CXXALIAS_SYS (fmodf, float, (float x, float y)); 1554# endif 1555_GL_CXXALIASWARN (fmodf); 1556#elif defined GNULIB_POSIXCHECK 1557# undef fmodf 1558# if HAVE_RAW_DECL_FMODF 1559_GL_WARN_ON_USE (fmodf, "fmodf is unportable - " 1560 "use gnulib module fmodf for portability"); 1561# endif 1562#endif 1563 1564#if 0 1565# if 0 1566# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1567# undef fmod 1568# define fmod rpl_fmod 1569# endif 1570_GL_FUNCDECL_RPL (fmod, double, (double x, double y)); 1571_GL_CXXALIAS_RPL (fmod, double, (double x, double y)); 1572# else 1573_GL_CXXALIAS_SYS (fmod, double, (double x, double y)); 1574# endif 1575# if __GLIBC__ >= 2 1576_GL_CXXALIASWARN1 (fmod, double, (double x, double y)); 1577# endif 1578#elif defined GNULIB_POSIXCHECK 1579# undef fmod 1580# if HAVE_RAW_DECL_FMOD 1581_GL_WARN_ON_USE (fmod, "fmod has portability problems - " 1582 "use gnulib module fmod for portability"); 1583# endif 1584#endif 1585 1586#if 0 1587# if 0 1588# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1589# undef fmodl 1590# define fmodl rpl_fmodl 1591# endif 1592_GL_FUNCDECL_RPL (fmodl, long double, (long double x, long double y)); 1593_GL_CXXALIAS_RPL (fmodl, long double, (long double x, long double y)); 1594# else 1595# if !1 1596# undef fmodl 1597_GL_FUNCDECL_SYS (fmodl, long double, (long double x, long double y)); 1598# endif 1599_GL_CXXALIAS_SYS (fmodl, long double, (long double x, long double y)); 1600# endif 1601# if __GLIBC__ >= 2 1602_GL_CXXALIASWARN (fmodl); 1603# endif 1604#elif defined GNULIB_POSIXCHECK 1605# undef fmodl 1606# if HAVE_RAW_DECL_FMODL 1607_GL_WARN_ON_USE (fmodl, "fmodl is unportable - " 1608 "use gnulib module fmodl for portability"); 1609# endif 1610#endif 1611 1612 1613/* Write x as 1614 x = mantissa * 2^exp 1615 where 1616 If x finite and nonzero: 0.5 <= |mantissa| < 1.0. 1617 If x is zero: mantissa = x, exp = 0. 1618 If x is infinite or NaN: mantissa = x, exp unspecified. 1619 Store exp in *EXPPTR and return mantissa. */ 1620#if 0 1621# if 0 1622# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1623# undef frexpf 1624# define frexpf rpl_frexpf 1625# endif 1626_GL_FUNCDECL_RPL (frexpf, float, (float x, int *expptr) _GL_ARG_NONNULL ((2))); 1627_GL_CXXALIAS_RPL (frexpf, float, (float x, int *expptr)); 1628# else 1629# if !1 1630# undef frexpf 1631_GL_FUNCDECL_SYS (frexpf, float, (float x, int *expptr) _GL_ARG_NONNULL ((2))); 1632# endif 1633_GL_CXXALIAS_SYS (frexpf, float, (float x, int *expptr)); 1634# endif 1635# if __GLIBC__ >= 2 1636_GL_CXXALIASWARN (frexpf); 1637# endif 1638#elif defined GNULIB_POSIXCHECK 1639# undef frexpf 1640# if HAVE_RAW_DECL_FREXPF 1641_GL_WARN_ON_USE (frexpf, "frexpf is unportable - " 1642 "use gnulib module frexpf for portability"); 1643# endif 1644#endif 1645 1646/* Write x as 1647 x = mantissa * 2^exp 1648 where 1649 If x finite and nonzero: 0.5 <= |mantissa| < 1.0. 1650 If x is zero: mantissa = x, exp = 0. 1651 If x is infinite or NaN: mantissa = x, exp unspecified. 1652 Store exp in *EXPPTR and return mantissa. */ 1653#if 1 1654# if 1 1655# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1656# undef frexp 1657# define frexp rpl_frexp 1658# endif 1659_GL_FUNCDECL_RPL (frexp, double, (double x, int *expptr) _GL_ARG_NONNULL ((2))); 1660_GL_CXXALIAS_RPL (frexp, double, (double x, int *expptr)); 1661# else 1662_GL_CXXALIAS_SYS (frexp, double, (double x, int *expptr)); 1663# endif 1664# if __GLIBC__ >= 2 1665_GL_CXXALIASWARN1 (frexp, double, (double x, int *expptr)); 1666# endif 1667#elif defined GNULIB_POSIXCHECK 1668# undef frexp 1669/* Assume frexp is always declared. */ 1670_GL_WARN_ON_USE (frexp, "frexp is unportable - " 1671 "use gnulib module frexp for portability"); 1672#endif 1673 1674/* Write x as 1675 x = mantissa * 2^exp 1676 where 1677 If x finite and nonzero: 0.5 <= |mantissa| < 1.0. 1678 If x is zero: mantissa = x, exp = 0. 1679 If x is infinite or NaN: mantissa = x, exp unspecified. 1680 Store exp in *EXPPTR and return mantissa. */ 1681#if 1 && 0 1682# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1683# undef frexpl 1684# define frexpl rpl_frexpl 1685# endif 1686_GL_FUNCDECL_RPL (frexpl, long double, 1687 (long double x, int *expptr) _GL_ARG_NONNULL ((2))); 1688_GL_CXXALIAS_RPL (frexpl, long double, (long double x, int *expptr)); 1689#else 1690# if !1 1691_GL_FUNCDECL_SYS (frexpl, long double, 1692 (long double x, int *expptr) _GL_ARG_NONNULL ((2))); 1693# endif 1694# if 1 1695_GL_CXXALIAS_SYS (frexpl, long double, (long double x, int *expptr)); 1696# endif 1697#endif 1698#if 1 && !(0 && !1) 1699# if __GLIBC__ >= 2 1700_GL_CXXALIASWARN (frexpl); 1701# endif 1702#endif 1703#if !1 && defined GNULIB_POSIXCHECK 1704# undef frexpl 1705# if HAVE_RAW_DECL_FREXPL 1706_GL_WARN_ON_USE (frexpl, "frexpl is unportable - " 1707 "use gnulib module frexpl for portability"); 1708# endif 1709#endif 1710 1711 1712/* Return sqrt(x^2+y^2). */ 1713#if 0 1714# if 0 1715# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1716# undef hypotf 1717# define hypotf rpl_hypotf 1718# endif 1719_GL_FUNCDECL_RPL (hypotf, float, (float x, float y)); 1720_GL_CXXALIAS_RPL (hypotf, float, (float x, float y)); 1721# else 1722# if !1 1723_GL_FUNCDECL_SYS (hypotf, float, (float x, float y)); 1724# endif 1725_GL_CXXALIAS_SYS (hypotf, float, (float x, float y)); 1726# endif 1727# if __GLIBC__ >= 2 1728_GL_CXXALIASWARN (hypotf); 1729# endif 1730#elif defined GNULIB_POSIXCHECK 1731# undef hypotf 1732# if HAVE_RAW_DECL_HYPOTF 1733_GL_WARN_ON_USE (hypotf, "hypotf is unportable - " 1734 "use gnulib module hypotf for portability"); 1735# endif 1736#endif 1737 1738/* Return sqrt(x^2+y^2). */ 1739#if 0 1740# if 0 1741# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1742# undef hypot 1743# define hypot rpl_hypot 1744# endif 1745_GL_FUNCDECL_RPL (hypot, double, (double x, double y)); 1746_GL_CXXALIAS_RPL (hypot, double, (double x, double y)); 1747# else 1748_GL_CXXALIAS_SYS (hypot, double, (double x, double y)); 1749# endif 1750# if __GLIBC__ >= 2 1751_GL_CXXALIASWARN1 (hypot, double, (double x, double y)); 1752# endif 1753#elif defined GNULIB_POSIXCHECK 1754# undef hypot 1755# if HAVE_RAW_DECL_HYPOT 1756_GL_WARN_ON_USE (hypotf, "hypot has portability problems - " 1757 "use gnulib module hypot for portability"); 1758# endif 1759#endif 1760 1761/* Return sqrt(x^2+y^2). */ 1762#if 0 1763# if 0 1764# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1765# undef hypotl 1766# define hypotl rpl_hypotl 1767# endif 1768_GL_FUNCDECL_RPL (hypotl, long double, (long double x, long double y)); 1769_GL_CXXALIAS_RPL (hypotl, long double, (long double x, long double y)); 1770# else 1771# if !1 1772_GL_FUNCDECL_SYS (hypotl, long double, (long double x, long double y)); 1773# endif 1774_GL_CXXALIAS_SYS (hypotl, long double, (long double x, long double y)); 1775# endif 1776# if __GLIBC__ >= 2 1777_GL_CXXALIASWARN (hypotl); 1778# endif 1779#elif defined GNULIB_POSIXCHECK 1780# undef hypotl 1781# if HAVE_RAW_DECL_HYPOTL 1782_GL_WARN_ON_USE (hypotl, "hypotl is unportable - " 1783 "use gnulib module hypotl for portability"); 1784# endif 1785#endif 1786 1787 1788#if 0 1789# if 0 1790# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1791# undef ilogbf 1792# define ilogbf rpl_ilogbf 1793# endif 1794_GL_FUNCDECL_RPL (ilogbf, int, (float x)); 1795_GL_CXXALIAS_RPL (ilogbf, int, (float x)); 1796# else 1797# if !1 1798_GL_FUNCDECL_SYS (ilogbf, int, (float x)); 1799# endif 1800_GL_CXXALIAS_SYS (ilogbf, int, (float x)); 1801# endif 1802_GL_CXXALIASWARN (ilogbf); 1803#elif defined GNULIB_POSIXCHECK 1804# undef ilogbf 1805# if HAVE_RAW_DECL_ILOGBF 1806_GL_WARN_ON_USE (ilogbf, "ilogbf is unportable - " 1807 "use gnulib module ilogbf for portability"); 1808# endif 1809#endif 1810 1811#if 0 1812# if 0 1813# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1814# undef ilogb 1815# define ilogb rpl_ilogb 1816# endif 1817_GL_FUNCDECL_RPL (ilogb, int, (double x)); 1818_GL_CXXALIAS_RPL (ilogb, int, (double x)); 1819# else 1820# if !1 1821_GL_FUNCDECL_SYS (ilogb, int, (double x)); 1822# endif 1823_GL_CXXALIAS_SYS (ilogb, int, (double x)); 1824# endif 1825# if __GLIBC__ >= 2 1826_GL_CXXALIASWARN1 (ilogb, int, (double x)); 1827# endif 1828#elif defined GNULIB_POSIXCHECK 1829# undef ilogb 1830# if HAVE_RAW_DECL_ILOGB 1831_GL_WARN_ON_USE (ilogb, "ilogb is unportable - " 1832 "use gnulib module ilogb for portability"); 1833# endif 1834#endif 1835 1836#if 0 1837# if 0 1838# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1839# undef ilogbl 1840# define ilogbl rpl_ilogbl 1841# endif 1842_GL_FUNCDECL_RPL (ilogbl, int, (long double x)); 1843_GL_CXXALIAS_RPL (ilogbl, int, (long double x)); 1844# else 1845# if !1 1846# undef ilogbl 1847_GL_FUNCDECL_SYS (ilogbl, int, (long double x)); 1848# endif 1849_GL_CXXALIAS_SYS (ilogbl, int, (long double x)); 1850# endif 1851_GL_CXXALIASWARN (ilogbl); 1852#elif defined GNULIB_POSIXCHECK 1853# undef ilogbl 1854# if HAVE_RAW_DECL_ILOGBL 1855_GL_WARN_ON_USE (ilogbl, "ilogbl is unportable - " 1856 "use gnulib module ilogbl for portability"); 1857# endif 1858#endif 1859 1860 1861#if 1 1862/* On native Windows, map 'j0' to '_j0', so that -loldnames is not 1863 required. In C++ with GNULIB_NAMESPACE, avoid differences between 1864 platforms by defining GNULIB_NAMESPACE::j0 always. */ 1865# if defined _WIN32 && !defined __CYGWIN__ 1866# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1867# undef j0 1868# define j0 _j0 1869# endif 1870_GL_CXXALIAS_MDA (j0, double, (double x)); 1871# else 1872_GL_CXXALIAS_SYS (j0, double, (double x)); 1873# endif 1874_GL_CXXALIASWARN (j0); 1875#endif 1876 1877#if 1 1878/* On native Windows, map 'j1' to '_j1', so that -loldnames is not 1879 required. In C++ with GNULIB_NAMESPACE, avoid differences between 1880 platforms by defining GNULIB_NAMESPACE::j1 always. */ 1881# if defined _WIN32 && !defined __CYGWIN__ 1882# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1883# undef j1 1884# define j1 _j1 1885# endif 1886_GL_CXXALIAS_MDA (j1, double, (double x)); 1887# else 1888_GL_CXXALIAS_SYS (j1, double, (double x)); 1889# endif 1890_GL_CXXALIASWARN (j1); 1891#endif 1892 1893#if 1 1894/* On native Windows, map 'jn' to '_jn', so that -loldnames is not 1895 required. In C++ with GNULIB_NAMESPACE, avoid differences between 1896 platforms by defining GNULIB_NAMESPACE::jn always. */ 1897# if defined _WIN32 && !defined __CYGWIN__ 1898# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1899# undef jn 1900# define jn _jn 1901# endif 1902_GL_CXXALIAS_MDA (jn, double, (int n, double x)); 1903# else 1904_GL_CXXALIAS_SYS (jn, double, (int n, double x)); 1905# endif 1906_GL_CXXALIASWARN (jn); 1907#endif 1908 1909 1910/* Return x * 2^exp. */ 1911#if 0 1912# if !1 1913# undef ldexpf 1914_GL_FUNCDECL_SYS (ldexpf, float, (float x, int exp)); 1915# endif 1916_GL_CXXALIAS_SYS (ldexpf, float, (float x, int exp)); 1917# if __GLIBC__ >= 2 1918_GL_CXXALIASWARN (ldexpf); 1919# endif 1920#elif defined GNULIB_POSIXCHECK 1921# undef ldexpf 1922# if HAVE_RAW_DECL_LDEXPF 1923_GL_WARN_ON_USE (ldexpf, "ldexpf is unportable - " 1924 "use gnulib module ldexpf for portability"); 1925# endif 1926#endif 1927 1928/* Return x * 2^exp. */ 1929#if 0 && 0 1930# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1931# undef ldexpl 1932# define ldexpl rpl_ldexpl 1933# endif 1934_GL_FUNCDECL_RPL (ldexpl, long double, (long double x, int exp)); 1935_GL_CXXALIAS_RPL (ldexpl, long double, (long double x, int exp)); 1936#else 1937# if !1 1938_GL_FUNCDECL_SYS (ldexpl, long double, (long double x, int exp)); 1939# endif 1940# if 0 1941_GL_CXXALIAS_SYS (ldexpl, long double, (long double x, int exp)); 1942# endif 1943#endif 1944#if 0 1945# if __GLIBC__ >= 2 1946_GL_CXXALIASWARN (ldexpl); 1947# endif 1948#endif 1949#if !0 && defined GNULIB_POSIXCHECK 1950# undef ldexpl 1951# if HAVE_RAW_DECL_LDEXPL 1952_GL_WARN_ON_USE (ldexpl, "ldexpl is unportable - " 1953 "use gnulib module ldexpl for portability"); 1954# endif 1955#endif 1956 1957 1958#if 0 1959# if 0 1960# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1961# undef logf 1962# define logf rpl_logf 1963# endif 1964_GL_FUNCDECL_RPL (logf, float, (float x)); 1965_GL_CXXALIAS_RPL (logf, float, (float x)); 1966# else 1967# if !1 1968# undef logf 1969_GL_FUNCDECL_SYS (logf, float, (float x)); 1970# endif 1971_GL_CXXALIAS_SYS (logf, float, (float x)); 1972# endif 1973_GL_CXXALIASWARN (logf); 1974#elif defined GNULIB_POSIXCHECK 1975# undef logf 1976# if HAVE_RAW_DECL_LOGF 1977_GL_WARN_ON_USE (logf, "logf is unportable - " 1978 "use gnulib module logf for portability"); 1979# endif 1980#endif 1981 1982#if 0 1983# if 0 1984# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1985# undef log 1986# define log rpl_log 1987# endif 1988_GL_FUNCDECL_RPL (log, double, (double x)); 1989_GL_CXXALIAS_RPL (log, double, (double x)); 1990# else 1991_GL_CXXALIAS_SYS (log, double, (double x)); 1992# endif 1993# if __GLIBC__ >= 2 1994_GL_CXXALIASWARN1 (log, double, (double x)); 1995# endif 1996#elif defined GNULIB_POSIXCHECK 1997# undef log 1998# if HAVE_RAW_DECL_LOG 1999_GL_WARN_ON_USE (log, "log has portability problems - " 2000 "use gnulib module log for portability"); 2001# endif 2002#endif 2003 2004#if 0 2005# if 0 2006# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2007# undef logl 2008# define logl rpl_logl 2009# endif 2010_GL_FUNCDECL_RPL (logl, long double, (long double x)); 2011_GL_CXXALIAS_RPL (logl, long double, (long double x)); 2012# else 2013# if !1 || !1 2014# undef logl 2015_GL_FUNCDECL_SYS (logl, long double, (long double x)); 2016# endif 2017_GL_CXXALIAS_SYS (logl, long double, (long double x)); 2018# endif 2019# if __GLIBC__ >= 2 2020_GL_CXXALIASWARN (logl); 2021# endif 2022#elif defined GNULIB_POSIXCHECK 2023# undef logl 2024# if HAVE_RAW_DECL_LOGL 2025_GL_WARN_ON_USE (logl, "logl is unportable - " 2026 "use gnulib module logl for portability"); 2027# endif 2028#endif 2029 2030 2031#if 0 2032# if 0 2033# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2034# undef log10f 2035# define log10f rpl_log10f 2036# endif 2037_GL_FUNCDECL_RPL (log10f, float, (float x)); 2038_GL_CXXALIAS_RPL (log10f, float, (float x)); 2039# else 2040# if !1 2041# undef log10f 2042_GL_FUNCDECL_SYS (log10f, float, (float x)); 2043# endif 2044_GL_CXXALIAS_SYS (log10f, float, (float x)); 2045# endif 2046_GL_CXXALIASWARN (log10f); 2047#elif defined GNULIB_POSIXCHECK 2048# undef log10f 2049# if HAVE_RAW_DECL_LOG10F 2050_GL_WARN_ON_USE (log10f, "log10f is unportable - " 2051 "use gnulib module log10f for portability"); 2052# endif 2053#endif 2054 2055#if 0 2056# if 0 2057# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2058# undef log10 2059# define log10 rpl_log10 2060# endif 2061_GL_FUNCDECL_RPL (log10, double, (double x)); 2062_GL_CXXALIAS_RPL (log10, double, (double x)); 2063# else 2064_GL_CXXALIAS_SYS (log10, double, (double x)); 2065# endif 2066# if __GLIBC__ >= 2 2067_GL_CXXALIASWARN1 (log10, double, (double x)); 2068# endif 2069#elif defined GNULIB_POSIXCHECK 2070# undef log10 2071# if HAVE_RAW_DECL_LOG10 2072_GL_WARN_ON_USE (log10, "log10 has portability problems - " 2073 "use gnulib module log10 for portability"); 2074# endif 2075#endif 2076 2077#if 0 2078# if 0 2079# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2080# undef log10l 2081# define log10l rpl_log10l 2082# endif 2083_GL_FUNCDECL_RPL (log10l, long double, (long double x)); 2084_GL_CXXALIAS_RPL (log10l, long double, (long double x)); 2085# else 2086# if !1 || !1 2087# undef log10l 2088_GL_FUNCDECL_SYS (log10l, long double, (long double x)); 2089# endif 2090_GL_CXXALIAS_SYS (log10l, long double, (long double x)); 2091# endif 2092# if __GLIBC__ >= 2 2093_GL_CXXALIASWARN (log10l); 2094# endif 2095#elif defined GNULIB_POSIXCHECK 2096# undef log10l 2097# if HAVE_RAW_DECL_LOG10L 2098_GL_WARN_ON_USE (log10l, "log10l is unportable - " 2099 "use gnulib module log10l for portability"); 2100# endif 2101#endif 2102 2103 2104#if 0 2105# if 0 2106# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2107# undef log1pf 2108# define log1pf rpl_log1pf 2109# endif 2110_GL_FUNCDECL_RPL (log1pf, float, (float x)); 2111_GL_CXXALIAS_RPL (log1pf, float, (float x)); 2112# else 2113# if !1 2114_GL_FUNCDECL_SYS (log1pf, float, (float x)); 2115# endif 2116_GL_CXXALIAS_SYS (log1pf, float, (float x)); 2117# endif 2118_GL_CXXALIASWARN (log1pf); 2119#elif defined GNULIB_POSIXCHECK 2120# undef log1pf 2121# if HAVE_RAW_DECL_LOG1PF 2122_GL_WARN_ON_USE (log1pf, "log1pf is unportable - " 2123 "use gnulib module log1pf for portability"); 2124# endif 2125#endif 2126 2127#if 0 2128# if 0 2129# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2130# undef log1p 2131# define log1p rpl_log1p 2132# endif 2133_GL_FUNCDECL_RPL (log1p, double, (double x)); 2134_GL_CXXALIAS_RPL (log1p, double, (double x)); 2135# else 2136# if !1 2137_GL_FUNCDECL_SYS (log1p, double, (double x)); 2138# endif 2139_GL_CXXALIAS_SYS (log1p, double, (double x)); 2140# endif 2141# if __GLIBC__ >= 2 2142_GL_CXXALIASWARN1 (log1p, double, (double x)); 2143# endif 2144#elif defined GNULIB_POSIXCHECK 2145# undef log1p 2146# if HAVE_RAW_DECL_LOG1P 2147_GL_WARN_ON_USE (log1p, "log1p has portability problems - " 2148 "use gnulib module log1p for portability"); 2149# endif 2150#endif 2151 2152#if 0 2153# if 0 2154# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2155# undef log1pl 2156# define log1pl rpl_log1pl 2157# endif 2158_GL_FUNCDECL_RPL (log1pl, long double, (long double x)); 2159_GL_CXXALIAS_RPL (log1pl, long double, (long double x)); 2160# else 2161# if !1 2162_GL_FUNCDECL_SYS (log1pl, long double, (long double x)); 2163# endif 2164_GL_CXXALIAS_SYS (log1pl, long double, (long double x)); 2165# endif 2166_GL_CXXALIASWARN (log1pl); 2167#elif defined GNULIB_POSIXCHECK 2168# undef log1pl 2169# if HAVE_RAW_DECL_LOG1PL 2170_GL_WARN_ON_USE (log1pl, "log1pl has portability problems - " 2171 "use gnulib module log1pl for portability"); 2172# endif 2173#endif 2174 2175 2176#if 0 2177# if 0 2178# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2179# undef log2f 2180# define log2f rpl_log2f 2181# endif 2182_GL_FUNCDECL_RPL (log2f, float, (float x)); 2183_GL_CXXALIAS_RPL (log2f, float, (float x)); 2184# else 2185# if !1 2186# undef log2f 2187_GL_FUNCDECL_SYS (log2f, float, (float x)); 2188# endif 2189_GL_CXXALIAS_SYS (log2f, float, (float x)); 2190# endif 2191_GL_CXXALIASWARN (log2f); 2192#elif defined GNULIB_POSIXCHECK 2193# undef log2f 2194# if HAVE_RAW_DECL_LOG2F 2195_GL_WARN_ON_USE (log2f, "log2f is unportable - " 2196 "use gnulib module log2f for portability"); 2197# endif 2198#endif 2199 2200#if 0 2201# if 0 2202# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2203# undef log2 2204# define log2 rpl_log2 2205# endif 2206_GL_FUNCDECL_RPL (log2, double, (double x)); 2207_GL_CXXALIAS_RPL (log2, double, (double x)); 2208# else 2209# if !1 2210# undef log2 2211_GL_FUNCDECL_SYS (log2, double, (double x)); 2212# endif 2213_GL_CXXALIAS_SYS (log2, double, (double x)); 2214# endif 2215# if __GLIBC__ >= 2 2216_GL_CXXALIASWARN1 (log2, double, (double x)); 2217# endif 2218#elif defined GNULIB_POSIXCHECK 2219# undef log2 2220# if HAVE_RAW_DECL_LOG2 2221_GL_WARN_ON_USE (log2, "log2 is unportable - " 2222 "use gnulib module log2 for portability"); 2223# endif 2224#endif 2225 2226#if 0 2227# if 0 2228# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2229# undef log2l 2230# define log2l rpl_log2l 2231# endif 2232_GL_FUNCDECL_RPL (log2l, long double, (long double x)); 2233_GL_CXXALIAS_RPL (log2l, long double, (long double x)); 2234# else 2235# if !1 2236_GL_FUNCDECL_SYS (log2l, long double, (long double x)); 2237# endif 2238_GL_CXXALIAS_SYS (log2l, long double, (long double x)); 2239# endif 2240_GL_CXXALIASWARN (log2l); 2241#elif defined GNULIB_POSIXCHECK 2242# undef log2l 2243# if HAVE_RAW_DECL_LOG2L 2244_GL_WARN_ON_USE (log2l, "log2l is unportable - " 2245 "use gnulib module log2l for portability"); 2246# endif 2247#endif 2248 2249 2250#if 0 2251# if 0 2252# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2253# undef logbf 2254# define logbf rpl_logbf 2255# endif 2256_GL_FUNCDECL_RPL (logbf, float, (float x)); 2257_GL_CXXALIAS_RPL (logbf, float, (float x)); 2258# else 2259# if !1 2260_GL_FUNCDECL_SYS (logbf, float, (float x)); 2261# endif 2262_GL_CXXALIAS_SYS (logbf, float, (float x)); 2263# endif 2264_GL_CXXALIASWARN (logbf); 2265#elif defined GNULIB_POSIXCHECK 2266# undef logbf 2267# if HAVE_RAW_DECL_LOGBF 2268_GL_WARN_ON_USE (logbf, "logbf is unportable - " 2269 "use gnulib module logbf for portability"); 2270# endif 2271#endif 2272 2273#if 0 2274# if 0 2275# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2276# undef logb 2277# define logb rpl_logb 2278# endif 2279_GL_FUNCDECL_RPL (logb, double, (double x)); 2280_GL_CXXALIAS_RPL (logb, double, (double x)); 2281# else 2282# if !1 2283_GL_FUNCDECL_SYS (logb, double, (double x)); 2284# endif 2285_GL_CXXALIAS_SYS (logb, double, (double x)); 2286# endif 2287# if __GLIBC__ >= 2 2288_GL_CXXALIASWARN1 (logb, double, (double x)); 2289# endif 2290#elif defined GNULIB_POSIXCHECK 2291# undef logb 2292# if HAVE_RAW_DECL_LOGB 2293_GL_WARN_ON_USE (logb, "logb is unportable - " 2294 "use gnulib module logb for portability"); 2295# endif 2296#endif 2297 2298#if 0 2299# if 0 2300# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2301# undef logbl 2302# define logbl rpl_logbl 2303# endif 2304_GL_FUNCDECL_RPL (logbl, long double, (long double x)); 2305_GL_CXXALIAS_RPL (logbl, long double, (long double x)); 2306# else 2307# if !1 2308_GL_FUNCDECL_SYS (logbl, long double, (long double x)); 2309# endif 2310_GL_CXXALIAS_SYS (logbl, long double, (long double x)); 2311# endif 2312_GL_CXXALIASWARN (logbl); 2313#elif defined GNULIB_POSIXCHECK 2314# undef logbl 2315# if HAVE_RAW_DECL_LOGBL 2316_GL_WARN_ON_USE (logbl, "logbl is unportable - " 2317 "use gnulib module logbl for portability"); 2318# endif 2319#endif 2320 2321 2322#if 0 2323# if 0 2324# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2325# undef modff 2326# define modff rpl_modff 2327# endif 2328_GL_FUNCDECL_RPL (modff, float, (float x, float *iptr) _GL_ARG_NONNULL ((2))); 2329_GL_CXXALIAS_RPL (modff, float, (float x, float *iptr)); 2330# else 2331# if !1 2332# undef modff 2333_GL_FUNCDECL_SYS (modff, float, (float x, float *iptr) _GL_ARG_NONNULL ((2))); 2334# endif 2335_GL_CXXALIAS_SYS (modff, float, (float x, float *iptr)); 2336# endif 2337_GL_CXXALIASWARN (modff); 2338#elif defined GNULIB_POSIXCHECK 2339# undef modff 2340# if HAVE_RAW_DECL_MODFF 2341_GL_WARN_ON_USE (modff, "modff is unportable - " 2342 "use gnulib module modff for portability"); 2343# endif 2344#endif 2345 2346#if 0 2347# if 0 2348# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2349# undef modf 2350# define modf rpl_modf 2351# endif 2352_GL_FUNCDECL_RPL (modf, double, (double x, double *iptr) _GL_ARG_NONNULL ((2))); 2353_GL_CXXALIAS_RPL (modf, double, (double x, double *iptr)); 2354# else 2355_GL_CXXALIAS_SYS (modf, double, (double x, double *iptr)); 2356# endif 2357# if __GLIBC__ >= 2 2358_GL_CXXALIASWARN1 (modf, double, (double x, double *iptr)); 2359# endif 2360#elif defined GNULIB_POSIXCHECK 2361# undef modf 2362# if HAVE_RAW_DECL_MODF 2363_GL_WARN_ON_USE (modf, "modf has portability problems - " 2364 "use gnulib module modf for portability"); 2365# endif 2366#endif 2367 2368#if 0 2369# if 0 2370# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2371# undef modfl 2372# define modfl rpl_modfl 2373# endif 2374_GL_FUNCDECL_RPL (modfl, long double, (long double x, long double *iptr) 2375 _GL_ARG_NONNULL ((2))); 2376_GL_CXXALIAS_RPL (modfl, long double, (long double x, long double *iptr)); 2377# else 2378# if !1 2379# undef modfl 2380_GL_FUNCDECL_SYS (modfl, long double, (long double x, long double *iptr) 2381 _GL_ARG_NONNULL ((2))); 2382# endif 2383_GL_CXXALIAS_SYS (modfl, long double, (long double x, long double *iptr)); 2384# endif 2385# if __GLIBC__ >= 2 2386_GL_CXXALIASWARN (modfl); 2387# endif 2388#elif defined GNULIB_POSIXCHECK 2389# undef modfl 2390# if HAVE_RAW_DECL_MODFL 2391_GL_WARN_ON_USE (modfl, "modfl is unportable - " 2392 "use gnulib module modfl for portability"); 2393# endif 2394#endif 2395 2396 2397#if 0 2398# if !1 2399# undef powf 2400_GL_FUNCDECL_SYS (powf, float, (float x, float y)); 2401# endif 2402_GL_CXXALIAS_SYS (powf, float, (float x, float y)); 2403_GL_CXXALIASWARN (powf); 2404#elif defined GNULIB_POSIXCHECK 2405# undef powf 2406# if HAVE_RAW_DECL_POWF 2407_GL_WARN_ON_USE (powf, "powf is unportable - " 2408 "use gnulib module powf for portability"); 2409# endif 2410#endif 2411 2412 2413#if 0 2414# if 0 2415# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2416# undef remainderf 2417# define remainderf rpl_remainderf 2418# endif 2419_GL_FUNCDECL_RPL (remainderf, float, (float x, float y)); 2420_GL_CXXALIAS_RPL (remainderf, float, (float x, float y)); 2421# else 2422# if !1 2423_GL_FUNCDECL_SYS (remainderf, float, (float x, float y)); 2424# endif 2425_GL_CXXALIAS_SYS (remainderf, float, (float x, float y)); 2426# endif 2427_GL_CXXALIASWARN (remainderf); 2428#elif defined GNULIB_POSIXCHECK 2429# undef remainderf 2430# if HAVE_RAW_DECL_REMAINDERF 2431_GL_WARN_ON_USE (remainderf, "remainderf is unportable - " 2432 "use gnulib module remainderf for portability"); 2433# endif 2434#endif 2435 2436#if 0 2437# if 0 2438# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2439# undef remainder 2440# define remainder rpl_remainder 2441# endif 2442_GL_FUNCDECL_RPL (remainder, double, (double x, double y)); 2443_GL_CXXALIAS_RPL (remainder, double, (double x, double y)); 2444# else 2445# if !1 || !1 2446_GL_FUNCDECL_SYS (remainder, double, (double x, double y)); 2447# endif 2448_GL_CXXALIAS_SYS (remainder, double, (double x, double y)); 2449# endif 2450# if __GLIBC__ >= 2 2451_GL_CXXALIASWARN1 (remainder, double, (double x, double y)); 2452# endif 2453#elif defined GNULIB_POSIXCHECK 2454# undef remainder 2455# if HAVE_RAW_DECL_REMAINDER 2456_GL_WARN_ON_USE (remainder, "remainder is unportable - " 2457 "use gnulib module remainder for portability"); 2458# endif 2459#endif 2460 2461#if 0 2462# if 0 2463# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2464# undef remainderl 2465# define remainderl rpl_remainderl 2466# endif 2467_GL_FUNCDECL_RPL (remainderl, long double, (long double x, long double y)); 2468_GL_CXXALIAS_RPL (remainderl, long double, (long double x, long double y)); 2469# else 2470# if !1 2471# undef remainderl 2472# if !(defined __cplusplus && defined _AIX) 2473_GL_FUNCDECL_SYS (remainderl, long double, (long double x, long double y)); 2474# endif 2475# endif 2476_GL_CXXALIAS_SYS (remainderl, long double, (long double x, long double y)); 2477# endif 2478_GL_CXXALIASWARN (remainderl); 2479#elif defined GNULIB_POSIXCHECK 2480# undef remainderl 2481# if HAVE_RAW_DECL_REMAINDERL 2482_GL_WARN_ON_USE (remainderl, "remainderl is unportable - " 2483 "use gnulib module remainderl for portability"); 2484# endif 2485#endif 2486 2487 2488#if 0 2489# if !1 2490_GL_FUNCDECL_SYS (rintf, float, (float x)); 2491# endif 2492_GL_CXXALIAS_SYS (rintf, float, (float x)); 2493_GL_CXXALIASWARN (rintf); 2494#elif defined GNULIB_POSIXCHECK 2495# undef rintf 2496# if HAVE_RAW_DECL_RINTF 2497_GL_WARN_ON_USE (rintf, "rintf is unportable - " 2498 "use gnulib module rintf for portability"); 2499# endif 2500#endif 2501 2502#if 0 2503# if !1 2504_GL_FUNCDECL_SYS (rint, double, (double x)); 2505# endif 2506_GL_CXXALIAS_SYS (rint, double, (double x)); 2507# if __GLIBC__ >= 2 2508_GL_CXXALIASWARN1 (rint, double, (double x)); 2509# endif 2510#elif defined GNULIB_POSIXCHECK 2511# undef rint 2512# if HAVE_RAW_DECL_RINT 2513_GL_WARN_ON_USE (rint, "rint is unportable - " 2514 "use gnulib module rint for portability"); 2515# endif 2516#endif 2517 2518#if 0 2519# if 0 2520# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2521# undef rintl 2522# define rintl rpl_rintl 2523# endif 2524_GL_FUNCDECL_RPL (rintl, long double, (long double x)); 2525_GL_CXXALIAS_RPL (rintl, long double, (long double x)); 2526# else 2527# if !1 2528_GL_FUNCDECL_SYS (rintl, long double, (long double x)); 2529# endif 2530_GL_CXXALIAS_SYS (rintl, long double, (long double x)); 2531# endif 2532_GL_CXXALIASWARN (rintl); 2533#elif defined GNULIB_POSIXCHECK 2534# undef rintl 2535# if HAVE_RAW_DECL_RINTL 2536_GL_WARN_ON_USE (rintl, "rintl is unportable - " 2537 "use gnulib module rintl for portability"); 2538# endif 2539#endif 2540 2541 2542#if 0 2543# if 0 2544# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2545# undef roundf 2546# define roundf rpl_roundf 2547# endif 2548_GL_FUNCDECL_RPL (roundf, float, (float x)); 2549_GL_CXXALIAS_RPL (roundf, float, (float x)); 2550# else 2551# if !1 2552_GL_FUNCDECL_SYS (roundf, float, (float x)); 2553# endif 2554_GL_CXXALIAS_SYS (roundf, float, (float x)); 2555# endif 2556_GL_CXXALIASWARN (roundf); 2557#elif defined GNULIB_POSIXCHECK 2558# undef roundf 2559# if HAVE_RAW_DECL_ROUNDF 2560_GL_WARN_ON_USE (roundf, "roundf is unportable - " 2561 "use gnulib module roundf for portability"); 2562# endif 2563#endif 2564 2565#if 0 2566# if 0 2567# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2568# undef round 2569# define round rpl_round 2570# endif 2571_GL_FUNCDECL_RPL (round, double, (double x)); 2572_GL_CXXALIAS_RPL (round, double, (double x)); 2573# else 2574# if !1 2575_GL_FUNCDECL_SYS (round, double, (double x)); 2576# endif 2577_GL_CXXALIAS_SYS (round, double, (double x)); 2578# endif 2579# if __GLIBC__ >= 2 2580_GL_CXXALIASWARN1 (round, double, (double x)); 2581# endif 2582#elif defined GNULIB_POSIXCHECK 2583# undef round 2584# if HAVE_RAW_DECL_ROUND 2585_GL_WARN_ON_USE (round, "round is unportable - " 2586 "use gnulib module round for portability"); 2587# endif 2588#endif 2589 2590#if 0 2591# if 0 2592# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2593# undef roundl 2594# define roundl rpl_roundl 2595# endif 2596_GL_FUNCDECL_RPL (roundl, long double, (long double x)); 2597_GL_CXXALIAS_RPL (roundl, long double, (long double x)); 2598# else 2599# if !1 2600# undef roundl 2601# if !(defined __cplusplus && defined _AIX) 2602_GL_FUNCDECL_SYS (roundl, long double, (long double x)); 2603# endif 2604# endif 2605_GL_CXXALIAS_SYS (roundl, long double, (long double x)); 2606# endif 2607_GL_CXXALIASWARN (roundl); 2608#elif defined GNULIB_POSIXCHECK 2609# undef roundl 2610# if HAVE_RAW_DECL_ROUNDL 2611_GL_WARN_ON_USE (roundl, "roundl is unportable - " 2612 "use gnulib module roundl for portability"); 2613# endif 2614#endif 2615 2616 2617#if 0 2618# if 0 2619# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2620# undef sinf 2621# define sinf rpl_sinf 2622# endif 2623_GL_FUNCDECL_RPL (sinf, float, (float x)); 2624_GL_CXXALIAS_RPL (sinf, float, (float x)); 2625# else 2626# if !1 2627# undef sinf 2628_GL_FUNCDECL_SYS (sinf, float, (float x)); 2629# endif 2630_GL_CXXALIAS_SYS (sinf, float, (float x)); 2631# endif 2632_GL_CXXALIASWARN (sinf); 2633#elif defined GNULIB_POSIXCHECK 2634# undef sinf 2635# if HAVE_RAW_DECL_SINF 2636_GL_WARN_ON_USE (sinf, "sinf is unportable - " 2637 "use gnulib module sinf for portability"); 2638# endif 2639#endif 2640 2641#if 0 2642# if !1 || !1 2643# undef sinl 2644_GL_FUNCDECL_SYS (sinl, long double, (long double x)); 2645# endif 2646_GL_CXXALIAS_SYS (sinl, long double, (long double x)); 2647# if __GLIBC__ >= 2 2648_GL_CXXALIASWARN (sinl); 2649# endif 2650#elif defined GNULIB_POSIXCHECK 2651# undef sinl 2652# if HAVE_RAW_DECL_SINL 2653_GL_WARN_ON_USE (sinl, "sinl is unportable - " 2654 "use gnulib module sinl for portability"); 2655# endif 2656#endif 2657 2658 2659#if 0 2660# if 0 2661# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2662# undef sinhf 2663# define sinhf rpl_sinhf 2664# endif 2665_GL_FUNCDECL_RPL (sinhf, float, (float x)); 2666_GL_CXXALIAS_RPL (sinhf, float, (float x)); 2667# else 2668# if !1 2669# undef sinhf 2670_GL_FUNCDECL_SYS (sinhf, float, (float x)); 2671# endif 2672_GL_CXXALIAS_SYS (sinhf, float, (float x)); 2673# endif 2674_GL_CXXALIASWARN (sinhf); 2675#elif defined GNULIB_POSIXCHECK 2676# undef sinhf 2677# if HAVE_RAW_DECL_SINHF 2678_GL_WARN_ON_USE (sinhf, "sinhf is unportable - " 2679 "use gnulib module sinhf for portability"); 2680# endif 2681#endif 2682 2683 2684#if 0 2685# if 0 2686# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2687# undef sqrtf 2688# define sqrtf rpl_sqrtf 2689# endif 2690_GL_FUNCDECL_RPL (sqrtf, float, (float x)); 2691_GL_CXXALIAS_RPL (sqrtf, float, (float x)); 2692# else 2693# if !1 2694# undef sqrtf 2695_GL_FUNCDECL_SYS (sqrtf, float, (float x)); 2696# endif 2697_GL_CXXALIAS_SYS (sqrtf, float, (float x)); 2698# endif 2699_GL_CXXALIASWARN (sqrtf); 2700#elif defined GNULIB_POSIXCHECK 2701# undef sqrtf 2702# if HAVE_RAW_DECL_SQRTF 2703_GL_WARN_ON_USE (sqrtf, "sqrtf is unportable - " 2704 "use gnulib module sqrtf for portability"); 2705# endif 2706#endif 2707 2708#if 0 2709# if 0 2710# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2711# undef sqrtl 2712# define sqrtl rpl_sqrtl 2713# endif 2714_GL_FUNCDECL_RPL (sqrtl, long double, (long double x)); 2715_GL_CXXALIAS_RPL (sqrtl, long double, (long double x)); 2716# else 2717# if !1 || !1 2718# undef sqrtl 2719_GL_FUNCDECL_SYS (sqrtl, long double, (long double x)); 2720# endif 2721_GL_CXXALIAS_SYS (sqrtl, long double, (long double x)); 2722# endif 2723# if __GLIBC__ >= 2 2724_GL_CXXALIASWARN (sqrtl); 2725# endif 2726#elif defined GNULIB_POSIXCHECK 2727# undef sqrtl 2728# if HAVE_RAW_DECL_SQRTL 2729_GL_WARN_ON_USE (sqrtl, "sqrtl is unportable - " 2730 "use gnulib module sqrtl for portability"); 2731# endif 2732#endif 2733 2734 2735#if 0 2736# if 0 2737# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2738# undef tanf 2739# define tanf rpl_tanf 2740# endif 2741_GL_FUNCDECL_RPL (tanf, float, (float x)); 2742_GL_CXXALIAS_RPL (tanf, float, (float x)); 2743# else 2744# if !1 2745# undef tanf 2746_GL_FUNCDECL_SYS (tanf, float, (float x)); 2747# endif 2748_GL_CXXALIAS_SYS (tanf, float, (float x)); 2749# endif 2750_GL_CXXALIASWARN (tanf); 2751#elif defined GNULIB_POSIXCHECK 2752# undef tanf 2753# if HAVE_RAW_DECL_TANF 2754_GL_WARN_ON_USE (tanf, "tanf is unportable - " 2755 "use gnulib module tanf for portability"); 2756# endif 2757#endif 2758 2759#if 0 2760# if !1 || !1 2761# undef tanl 2762_GL_FUNCDECL_SYS (tanl, long double, (long double x)); 2763# endif 2764_GL_CXXALIAS_SYS (tanl, long double, (long double x)); 2765# if __GLIBC__ >= 2 2766_GL_CXXALIASWARN (tanl); 2767# endif 2768#elif defined GNULIB_POSIXCHECK 2769# undef tanl 2770# if HAVE_RAW_DECL_TANL 2771_GL_WARN_ON_USE (tanl, "tanl is unportable - " 2772 "use gnulib module tanl for portability"); 2773# endif 2774#endif 2775 2776 2777#if 0 2778# if 0 2779# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2780# undef tanhf 2781# define tanhf rpl_tanhf 2782# endif 2783_GL_FUNCDECL_RPL (tanhf, float, (float x)); 2784_GL_CXXALIAS_RPL (tanhf, float, (float x)); 2785# else 2786# if !1 2787# undef tanhf 2788_GL_FUNCDECL_SYS (tanhf, float, (float x)); 2789# endif 2790_GL_CXXALIAS_SYS (tanhf, float, (float x)); 2791# endif 2792_GL_CXXALIASWARN (tanhf); 2793#elif defined GNULIB_POSIXCHECK 2794# undef tanhf 2795# if HAVE_RAW_DECL_TANHF 2796_GL_WARN_ON_USE (tanhf, "tanhf is unportable - " 2797 "use gnulib module tanhf for portability"); 2798# endif 2799#endif 2800 2801 2802#if 0 2803# if 0 2804# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2805# undef truncf 2806# define truncf rpl_truncf 2807# endif 2808_GL_FUNCDECL_RPL (truncf, float, (float x)); 2809_GL_CXXALIAS_RPL (truncf, float, (float x)); 2810# else 2811# if !1 2812_GL_FUNCDECL_SYS (truncf, float, (float x)); 2813# endif 2814_GL_CXXALIAS_SYS (truncf, float, (float x)); 2815# endif 2816_GL_CXXALIASWARN (truncf); 2817#elif defined GNULIB_POSIXCHECK 2818# undef truncf 2819# if HAVE_RAW_DECL_TRUNCF 2820_GL_WARN_ON_USE (truncf, "truncf is unportable - " 2821 "use gnulib module truncf for portability"); 2822# endif 2823#endif 2824 2825#if 0 2826# if 0 2827# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2828# undef trunc 2829# define trunc rpl_trunc 2830# endif 2831_GL_FUNCDECL_RPL (trunc, double, (double x)); 2832_GL_CXXALIAS_RPL (trunc, double, (double x)); 2833# else 2834# if !1 2835_GL_FUNCDECL_SYS (trunc, double, (double x)); 2836# endif 2837_GL_CXXALIAS_SYS (trunc, double, (double x)); 2838# endif 2839# if __GLIBC__ >= 2 2840_GL_CXXALIASWARN1 (trunc, double, (double x)); 2841# endif 2842#elif defined GNULIB_POSIXCHECK 2843# undef trunc 2844# if HAVE_RAW_DECL_TRUNC 2845_GL_WARN_ON_USE (trunc, "trunc is unportable - " 2846 "use gnulib module trunc for portability"); 2847# endif 2848#endif 2849 2850#if 0 2851# if 0 2852# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2853# undef truncl 2854# define truncl rpl_truncl 2855# endif 2856_GL_FUNCDECL_RPL (truncl, long double, (long double x)); 2857_GL_CXXALIAS_RPL (truncl, long double, (long double x)); 2858# else 2859# if !1 2860_GL_FUNCDECL_SYS (truncl, long double, (long double x)); 2861# endif 2862_GL_CXXALIAS_SYS (truncl, long double, (long double x)); 2863# endif 2864_GL_CXXALIASWARN (truncl); 2865#elif defined GNULIB_POSIXCHECK 2866# undef truncl 2867# if HAVE_RAW_DECL_TRUNCL 2868_GL_WARN_ON_USE (truncl, "truncl is unportable - " 2869 "use gnulib module truncl for portability"); 2870# endif 2871#endif 2872 2873 2874#if 1 2875/* On native Windows, map 'y0' to '_y0', so that -loldnames is not 2876 required. In C++ with GNULIB_NAMESPACE, avoid differences between 2877 platforms by defining GNULIB_NAMESPACE::y0 always. */ 2878# if defined _WIN32 && !defined __CYGWIN__ 2879# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2880# undef y0 2881# define y0 _y0 2882# endif 2883_GL_CXXALIAS_MDA (y0, double, (double x)); 2884# else 2885_GL_CXXALIAS_SYS (y0, double, (double x)); 2886# endif 2887_GL_CXXALIASWARN (y0); 2888#endif 2889 2890#if 1 2891/* On native Windows, map 'y1' to '_y1', so that -loldnames is not 2892 required. In C++ with GNULIB_NAMESPACE, avoid differences between 2893 platforms by defining GNULIB_NAMESPACE::y1 always. */ 2894# if defined _WIN32 && !defined __CYGWIN__ 2895# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2896# undef y1 2897# define y1 _y1 2898# endif 2899_GL_CXXALIAS_MDA (y1, double, (double x)); 2900# else 2901_GL_CXXALIAS_SYS (y1, double, (double x)); 2902# endif 2903_GL_CXXALIASWARN (y1); 2904#endif 2905 2906#if 1 2907/* On native Windows, map 'yn' to '_yn', so that -loldnames is not 2908 required. In C++ with GNULIB_NAMESPACE, avoid differences between 2909 platforms by defining GNULIB_NAMESPACE::yn always. */ 2910# if defined _WIN32 && !defined __CYGWIN__ 2911# if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2912# undef yn 2913# define yn _yn 2914# endif 2915_GL_CXXALIAS_MDA (yn, double, (int n, double x)); 2916# else 2917_GL_CXXALIAS_SYS (yn, double, (int n, double x)); 2918# endif 2919_GL_CXXALIASWARN (yn); 2920#endif 2921 2922 2923/* Definitions of function-like macros come here, after the function 2924 declarations. */ 2925 2926 2927#if 0 2928# if 0 2929_GL_EXTERN_C int gl_isfinitef (float x); 2930_GL_EXTERN_C int gl_isfinited (double x); 2931_GL_EXTERN_C int gl_isfinitel (long double x); 2932# undef isfinite 2933# define isfinite(x) \ 2934 (sizeof (x) == sizeof (long double) ? gl_isfinitel (x) : \ 2935 sizeof (x) == sizeof (double) ? gl_isfinited (x) : \ 2936 gl_isfinitef (x)) 2937# endif 2938# ifdef __cplusplus 2939# if defined isfinite || defined GNULIB_NAMESPACE 2940_GL_MATH_CXX_REAL_FLOATING_DECL_1 (isfinite) 2941# undef isfinite 2942# if __GNUC__ >= 6 || (defined __clang__ && !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __OpenBSD__ || defined _AIX || (defined _WIN32 && !defined __CYGWIN__))) 2943 /* This platform's <cmath> possibly defines isfinite through a set of inline 2944 functions. */ 2945_GL_MATH_CXX_REAL_FLOATING_DECL_2 (isfinite, rpl_isfinite, bool) 2946# define isfinite rpl_isfinite 2947# define GNULIB_NAMESPACE_LACKS_ISFINITE 1 2948# else 2949_GL_MATH_CXX_REAL_FLOATING_DECL_2 (isfinite, isfinite, bool) 2950# endif 2951# endif 2952# endif 2953#elif defined GNULIB_POSIXCHECK 2954# if defined isfinite 2955_GL_WARN_REAL_FLOATING_DECL (isfinite); 2956# undef isfinite 2957# define isfinite(x) _GL_WARN_REAL_FLOATING_IMPL (isfinite, x) 2958# endif 2959#endif 2960 2961 2962#if 0 2963# if 0 2964_GL_EXTERN_C int gl_isinff (float x); 2965_GL_EXTERN_C int gl_isinfd (double x); 2966_GL_EXTERN_C int gl_isinfl (long double x); 2967# undef isinf 2968# define isinf(x) \ 2969 (sizeof (x) == sizeof (long double) ? gl_isinfl (x) : \ 2970 sizeof (x) == sizeof (double) ? gl_isinfd (x) : \ 2971 gl_isinff (x)) 2972# endif 2973# ifdef __cplusplus 2974# if defined isinf || defined GNULIB_NAMESPACE 2975_GL_MATH_CXX_REAL_FLOATING_DECL_1 (isinf) 2976# undef isinf 2977# if __GNUC__ >= 6 || (defined __clang__ && !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __OpenBSD__ || (defined _WIN32 && !defined __CYGWIN__))) 2978 /* This platform's <cmath> possibly defines isinf through a set of inline 2979 functions. */ 2980_GL_MATH_CXX_REAL_FLOATING_DECL_2 (isinf, rpl_isinf, bool) 2981# define isinf rpl_isinf 2982# define GNULIB_NAMESPACE_LACKS_ISINF 1 2983# else 2984_GL_MATH_CXX_REAL_FLOATING_DECL_2 (isinf, isinf, bool) 2985# endif 2986# endif 2987# endif 2988#elif defined GNULIB_POSIXCHECK 2989# if defined isinf 2990_GL_WARN_REAL_FLOATING_DECL (isinf); 2991# undef isinf 2992# define isinf(x) _GL_WARN_REAL_FLOATING_IMPL (isinf, x) 2993# endif 2994#endif 2995 2996 2997#if 0 2998/* Test for NaN for 'float' numbers. */ 2999# if 1 3000/* The original <math.h> included above provides a declaration of isnan macro 3001 or (older) isnanf function. */ 3002# if (__GNUC__ >= 4) || (__clang_major__ >= 4) 3003 /* GCC >= 4.0 and clang provide a type-generic built-in for isnan. 3004 GCC >= 4.0 also provides __builtin_isnanf, but clang doesn't. */ 3005# undef isnanf 3006# define isnanf(x) __builtin_isnan ((float)(x)) 3007# elif defined isnan 3008# undef isnanf 3009# define isnanf(x) isnan ((float)(x)) 3010# endif 3011# else 3012/* Test whether X is a NaN. */ 3013# undef isnanf 3014# define isnanf rpl_isnanf 3015_GL_EXTERN_C int isnanf (float x); 3016# endif 3017#endif 3018 3019#if 0 3020/* Test for NaN for 'double' numbers. 3021 This function is a gnulib extension, unlike isnan() which applied only 3022 to 'double' numbers earlier but now is a type-generic macro. */ 3023# if 1 3024/* The original <math.h> included above provides a declaration of isnan 3025 macro. */ 3026# if (__GNUC__ >= 4) || (__clang_major__ >= 4) 3027 /* GCC >= 4.0 and clang provide a type-generic built-in for isnan. */ 3028# undef isnand 3029# define isnand(x) __builtin_isnan ((double)(x)) 3030# else 3031# undef isnand 3032# define isnand(x) isnan ((double)(x)) 3033# endif 3034# else 3035/* Test whether X is a NaN. */ 3036# undef isnand 3037# define isnand rpl_isnand 3038_GL_EXTERN_C int isnand (double x); 3039# endif 3040#endif 3041 3042#if 0 3043/* Test for NaN for 'long double' numbers. */ 3044# if 1 3045/* The original <math.h> included above provides a declaration of isnan 3046 macro or (older) isnanl function. */ 3047# if (__GNUC__ >= 4) || (__clang_major__ >= 4) 3048 /* GCC >= 4.0 and clang provide a type-generic built-in for isnan. 3049 GCC >= 4.0 also provides __builtin_isnanl, but clang doesn't. */ 3050# undef isnanl 3051# define isnanl(x) __builtin_isnan ((long double)(x)) 3052# elif defined isnan 3053# undef isnanl 3054# define isnanl(x) isnan ((long double)(x)) 3055# endif 3056# else 3057/* Test whether X is a NaN. */ 3058# undef isnanl 3059# define isnanl rpl_isnanl 3060_GL_EXTERN_C int isnanl (long double x) _GL_ATTRIBUTE_CONST; 3061# endif 3062#endif 3063 3064/* This must come *after* the snippets for GNULIB_ISNANF and GNULIB_ISNANL! */ 3065#if 0 3066# if 0 3067/* We can't just use the isnanf macro (e.g.) as exposed by 3068 isnanf.h (e.g.) here, because those may end up being macros 3069 that recursively expand back to isnan. So use the gnulib 3070 replacements for them directly. */ 3071# if 1 && (__GNUC__ >= 4) || (__clang_major__ >= 4) 3072# define gl_isnan_f(x) __builtin_isnan ((float)(x)) 3073# else 3074_GL_EXTERN_C int rpl_isnanf (float x); 3075# define gl_isnan_f(x) rpl_isnanf (x) 3076# endif 3077# if 1 && (__GNUC__ >= 4) || (__clang_major__ >= 4) 3078# define gl_isnan_d(x) __builtin_isnan ((double)(x)) 3079# else 3080_GL_EXTERN_C int rpl_isnand (double x); 3081# define gl_isnan_d(x) rpl_isnand (x) 3082# endif 3083# if 1 && (__GNUC__ >= 4) || (__clang_major__ >= 4) 3084# define gl_isnan_l(x) __builtin_isnan ((long double)(x)) 3085# else 3086_GL_EXTERN_C int rpl_isnanl (long double x) _GL_ATTRIBUTE_CONST; 3087# define gl_isnan_l(x) rpl_isnanl (x) 3088# endif 3089# undef isnan 3090# define isnan(x) \ 3091 (sizeof (x) == sizeof (long double) ? gl_isnan_l (x) : \ 3092 sizeof (x) == sizeof (double) ? gl_isnan_d (x) : \ 3093 gl_isnan_f (x)) 3094# elif (__GNUC__ >= 4) || (__clang_major__ >= 4) 3095# undef isnan 3096# define isnan(x) \ 3097 (sizeof (x) == sizeof (long double) ? __builtin_isnan ((long double)(x)) : \ 3098 sizeof (x) == sizeof (double) ? __builtin_isnan ((double)(x)) : \ 3099 __builtin_isnan ((float)(x))) 3100# endif 3101# ifdef __cplusplus 3102# if defined isnan || defined GNULIB_NAMESPACE 3103_GL_MATH_CXX_REAL_FLOATING_DECL_1 (isnan) 3104# undef isnan 3105# if __GNUC__ >= 6 || (defined __clang__ && !((defined __APPLE__ && defined __MACH__ && __clang_major__ < 12) || (defined __FreeBSD__ && __clang_major__ < 7) || defined __OpenBSD__ || (defined _WIN32 && !defined __CYGWIN__))) 3106 /* This platform's <cmath> possibly defines isnan through a set of inline 3107 functions. */ 3108_GL_MATH_CXX_REAL_FLOATING_DECL_2 (isnan, rpl_isnan, bool) 3109# define isnan rpl_isnan 3110# define GNULIB_NAMESPACE_LACKS_ISNAN 1 3111# else 3112_GL_MATH_CXX_REAL_FLOATING_DECL_2 (isnan, isnan, bool) 3113# endif 3114# endif 3115# else 3116/* Ensure isnan is a macro. */ 3117# ifndef isnan 3118# define isnan isnan 3119# endif 3120# endif 3121#elif defined GNULIB_POSIXCHECK 3122# if defined isnan 3123_GL_WARN_REAL_FLOATING_DECL (isnan); 3124# undef isnan 3125# define isnan(x) _GL_WARN_REAL_FLOATING_IMPL (isnan, x) 3126# endif 3127#endif 3128 3129 3130#if 0 3131# if (0 \ 3132 && (!defined __cplusplus || __cplusplus < 201103)) 3133# undef signbit 3134 /* GCC >= 4.0 and clang provide three built-ins for signbit. */ 3135# define signbit(x) \ 3136 (sizeof (x) == sizeof (long double) ? __builtin_signbitl (x) : \ 3137 sizeof (x) == sizeof (double) ? __builtin_signbit (x) : \ 3138 __builtin_signbitf (x)) 3139# endif 3140# if 0 && !GNULIB_defined_signbit 3141# undef signbit 3142_GL_EXTERN_C int gl_signbitf (float arg); 3143_GL_EXTERN_C int gl_signbitd (double arg); 3144_GL_EXTERN_C int gl_signbitl (long double arg); 3145# if (__GNUC__ >= 2 || defined __clang__) && !defined __STRICT_ANSI__ 3146# define _GL_NUM_UINT_WORDS(type) \ 3147 ((sizeof (type) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) 3148# if defined FLT_SIGNBIT_WORD && defined FLT_SIGNBIT_BIT && !defined gl_signbitf 3149# define gl_signbitf_OPTIMIZED_MACRO 3150# define gl_signbitf(arg) \ 3151 ({ union { float _value; \ 3152 unsigned int _word[_GL_NUM_UINT_WORDS (float)]; \ 3153 } _m; \ 3154 _m._value = (arg); \ 3155 (_m._word[FLT_SIGNBIT_WORD] >> FLT_SIGNBIT_BIT) & 1; \ 3156 }) 3157# endif 3158# if defined DBL_SIGNBIT_WORD && defined DBL_SIGNBIT_BIT && !defined gl_signbitd 3159# define gl_signbitd_OPTIMIZED_MACRO 3160# define gl_signbitd(arg) \ 3161 ({ union { double _value; \ 3162 unsigned int _word[_GL_NUM_UINT_WORDS (double)]; \ 3163 } _m; \ 3164 _m._value = (arg); \ 3165 (_m._word[DBL_SIGNBIT_WORD] >> DBL_SIGNBIT_BIT) & 1; \ 3166 }) 3167# endif 3168# if defined LDBL_SIGNBIT_WORD && defined LDBL_SIGNBIT_BIT && !defined gl_signbitl 3169# define gl_signbitl_OPTIMIZED_MACRO 3170# define gl_signbitl(arg) \ 3171 ({ union { long double _value; \ 3172 unsigned int _word[_GL_NUM_UINT_WORDS (long double)]; \ 3173 } _m; \ 3174 _m._value = (arg); \ 3175 (_m._word[LDBL_SIGNBIT_WORD] >> LDBL_SIGNBIT_BIT) & 1; \ 3176 }) 3177# endif 3178# endif 3179# define signbit(x) \ 3180 (sizeof (x) == sizeof (long double) ? gl_signbitl (x) : \ 3181 sizeof (x) == sizeof (double) ? gl_signbitd (x) : \ 3182 gl_signbitf (x)) 3183# define GNULIB_defined_signbit 1 3184# endif 3185# ifdef __cplusplus 3186# if defined signbit || defined GNULIB_NAMESPACE 3187_GL_MATH_CXX_REAL_FLOATING_DECL_1 (signbit) 3188# undef signbit 3189# if __GNUC__ >= 6 || (defined __clang__ && !((defined __APPLE__ && defined __MACH__) || defined __FreeBSD__ || defined __OpenBSD__ || defined _AIX || (defined _WIN32 && !defined __CYGWIN__))) 3190 /* This platform's <cmath> possibly defines signbit through a set of inline 3191 functions. */ 3192_GL_MATH_CXX_REAL_FLOATING_DECL_2 (signbit, rpl_signbit, bool) 3193# define signbit rpl_signbit 3194# define GNULIB_NAMESPACE_LACKS_SIGNBIT 1 3195# else 3196_GL_MATH_CXX_REAL_FLOATING_DECL_2 (signbit, signbit, bool) 3197# endif 3198# endif 3199# endif 3200#elif defined GNULIB_POSIXCHECK 3201# if defined signbit 3202_GL_WARN_REAL_FLOATING_DECL (signbit); 3203# undef signbit 3204# define signbit(x) _GL_WARN_REAL_FLOATING_IMPL (signbit, x) 3205# endif 3206#endif 3207 3208_GL_INLINE_HEADER_END 3209 3210#endif /* _GL_MATH_H */ 3211#endif /* _GL_INCLUDING_MATH_H */ 3212#endif /* _GL_MATH_H */ 3213