1 /* DO NOT EDIT! GENERATED AUTOMATICALLY! */ 2 /* A GNU-like <math.h>. 3 4 Copyright (C) 2002-2003, 2007-2012 Free Software Foundation, Inc. 5 6 This program is free software: you can redistribute it and/or modify 7 it under the terms of the GNU General Public License as published by 8 the Free Software Foundation; either version 3 of the License, or 9 (at your option) any later version. 10 11 This program is distributed in the hope that it will be useful, 12 but WITHOUT ANY WARRANTY; without even the implied warranty of 13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 GNU General Public License for more details. 15 16 You should have received a copy of the GNU General Public License 17 along with this program. If not, see <http://www.gnu.org/licenses/>. */ 18 19 #ifndef _GL_MATH_H 20 21 #if __GNUC__ >= 3 22 #pragma GCC system_header 23 #endif 24 25 26 /* The include_next requires a split double-inclusion guard. */ 27 #include_next <math.h> 28 29 #ifndef _GL_MATH_H 30 #define _GL_MATH_H 31 32 _GL_INLINE_HEADER_BEGIN 33 #ifndef _GL_MATH_INLINE 34 # define _GL_MATH_INLINE _GL_INLINE 35 #endif 36 37 /* The definitions of _GL_FUNCDECL_RPL etc. are copied here. */ 38 #ifndef _GL_CXXDEFS_H 39 #define _GL_CXXDEFS_H 40 41 /* The three most frequent use cases of these macros are: 42 43 * For providing a substitute for a function that is missing on some 44 platforms, but is declared and works fine on the platforms on which 45 it exists: 46 47 #if @GNULIB_FOO@ 48 # if !@HAVE_FOO@ 49 _GL_FUNCDECL_SYS (foo, ...); 50 # endif 51 _GL_CXXALIAS_SYS (foo, ...); 52 _GL_CXXALIASWARN (foo); 53 #elif defined GNULIB_POSIXCHECK 54 ... 55 #endif 56 57 * For providing a replacement for a function that exists on all platforms, 58 but is broken/insufficient and needs to be replaced on some platforms: 59 60 #if @GNULIB_FOO@ 61 # if @REPLACE_FOO@ 62 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 63 # undef foo 64 # define foo rpl_foo 65 # endif 66 _GL_FUNCDECL_RPL (foo, ...); 67 _GL_CXXALIAS_RPL (foo, ...); 68 # else 69 _GL_CXXALIAS_SYS (foo, ...); 70 # endif 71 _GL_CXXALIASWARN (foo); 72 #elif defined GNULIB_POSIXCHECK 73 ... 74 #endif 75 76 * For providing a replacement for a function that exists on some platforms 77 but is broken/insufficient and needs to be replaced on some of them and 78 is additionally either missing or undeclared on some other platforms: 79 80 #if @GNULIB_FOO@ 81 # if @REPLACE_FOO@ 82 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 83 # undef foo 84 # define foo rpl_foo 85 # endif 86 _GL_FUNCDECL_RPL (foo, ...); 87 _GL_CXXALIAS_RPL (foo, ...); 88 # else 89 # if !@HAVE_FOO@ or if !@HAVE_DECL_FOO@ 90 _GL_FUNCDECL_SYS (foo, ...); 91 # endif 92 _GL_CXXALIAS_SYS (foo, ...); 93 # endif 94 _GL_CXXALIASWARN (foo); 95 #elif defined GNULIB_POSIXCHECK 96 ... 97 #endif 98 */ 99 100 /* _GL_EXTERN_C declaration; 101 performs the declaration with C linkage. */ 102 #if defined __cplusplus 103 # define _GL_EXTERN_C extern "C" 104 #else 105 # define _GL_EXTERN_C extern 106 #endif 107 108 /* _GL_FUNCDECL_RPL (func, rettype, parameters_and_attributes); 109 declares a replacement function, named rpl_func, with the given prototype, 110 consisting of return type, parameters, and attributes. 111 Example: 112 _GL_FUNCDECL_RPL (open, int, (const char *filename, int flags, ...) 113 _GL_ARG_NONNULL ((1))); 114 */ 115 #define _GL_FUNCDECL_RPL(func,rettype,parameters_and_attributes) \ 116 _GL_FUNCDECL_RPL_1 (rpl_##func, rettype, parameters_and_attributes) 117 #define _GL_FUNCDECL_RPL_1(rpl_func,rettype,parameters_and_attributes) \ 118 _GL_EXTERN_C rettype rpl_func parameters_and_attributes 119 120 /* _GL_FUNCDECL_SYS (func, rettype, parameters_and_attributes); 121 declares the system function, named func, with the given prototype, 122 consisting of return type, parameters, and attributes. 123 Example: 124 _GL_FUNCDECL_SYS (open, int, (const char *filename, int flags, ...) 125 _GL_ARG_NONNULL ((1))); 126 */ 127 #define _GL_FUNCDECL_SYS(func,rettype,parameters_and_attributes) \ 128 _GL_EXTERN_C rettype func parameters_and_attributes 129 130 /* _GL_CXXALIAS_RPL (func, rettype, parameters); 131 declares a C++ alias called GNULIB_NAMESPACE::func 132 that redirects to rpl_func, if GNULIB_NAMESPACE is defined. 133 Example: 134 _GL_CXXALIAS_RPL (open, int, (const char *filename, int flags, ...)); 135 */ 136 #define _GL_CXXALIAS_RPL(func,rettype,parameters) \ 137 _GL_CXXALIAS_RPL_1 (func, rpl_##func, rettype, parameters) 138 #if defined __cplusplus && defined GNULIB_NAMESPACE 139 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 140 namespace GNULIB_NAMESPACE \ 141 { \ 142 rettype (*const func) parameters = ::rpl_func; \ 143 } \ 144 _GL_EXTERN_C int _gl_cxxalias_dummy 145 #else 146 # define _GL_CXXALIAS_RPL_1(func,rpl_func,rettype,parameters) \ 147 _GL_EXTERN_C int _gl_cxxalias_dummy 148 #endif 149 150 /* _GL_CXXALIAS_RPL_CAST_1 (func, rpl_func, rettype, parameters); 151 is like _GL_CXXALIAS_RPL_1 (func, rpl_func, rettype, parameters); 152 except that the C function rpl_func may have a slightly different 153 declaration. A cast is used to silence the "invalid conversion" error 154 that would otherwise occur. */ 155 #if defined __cplusplus && defined GNULIB_NAMESPACE 156 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 157 namespace GNULIB_NAMESPACE \ 158 { \ 159 rettype (*const func) parameters = \ 160 reinterpret_cast<rettype(*)parameters>(::rpl_func); \ 161 } \ 162 _GL_EXTERN_C int _gl_cxxalias_dummy 163 #else 164 # define _GL_CXXALIAS_RPL_CAST_1(func,rpl_func,rettype,parameters) \ 165 _GL_EXTERN_C int _gl_cxxalias_dummy 166 #endif 167 168 /* _GL_CXXALIAS_SYS (func, rettype, parameters); 169 declares a C++ alias called GNULIB_NAMESPACE::func 170 that redirects to the system provided function func, if GNULIB_NAMESPACE 171 is defined. 172 Example: 173 _GL_CXXALIAS_SYS (open, int, (const char *filename, int flags, ...)); 174 */ 175 #if defined __cplusplus && defined GNULIB_NAMESPACE 176 /* If we were to write 177 rettype (*const func) parameters = ::func; 178 like above in _GL_CXXALIAS_RPL_1, the compiler could optimize calls 179 better (remove an indirection through a 'static' pointer variable), 180 but then the _GL_CXXALIASWARN macro below would cause a warning not only 181 for uses of ::func but also for uses of GNULIB_NAMESPACE::func. */ 182 # define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 183 namespace GNULIB_NAMESPACE \ 184 { \ 185 static rettype (*func) parameters = ::func; \ 186 } \ 187 _GL_EXTERN_C int _gl_cxxalias_dummy 188 #else 189 # define _GL_CXXALIAS_SYS(func,rettype,parameters) \ 190 _GL_EXTERN_C int _gl_cxxalias_dummy 191 #endif 192 193 /* _GL_CXXALIAS_SYS_CAST (func, rettype, parameters); 194 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 195 except that the C function func may have a slightly different declaration. 196 A cast is used to silence the "invalid conversion" error that would 197 otherwise occur. */ 198 #if defined __cplusplus && defined GNULIB_NAMESPACE 199 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 200 namespace GNULIB_NAMESPACE \ 201 { \ 202 static rettype (*func) parameters = \ 203 reinterpret_cast<rettype(*)parameters>(::func); \ 204 } \ 205 _GL_EXTERN_C int _gl_cxxalias_dummy 206 #else 207 # define _GL_CXXALIAS_SYS_CAST(func,rettype,parameters) \ 208 _GL_EXTERN_C int _gl_cxxalias_dummy 209 #endif 210 211 /* _GL_CXXALIAS_SYS_CAST2 (func, rettype, parameters, rettype2, parameters2); 212 is like _GL_CXXALIAS_SYS (func, rettype, parameters); 213 except that the C function is picked among a set of overloaded functions, 214 namely the one with rettype2 and parameters2. Two consecutive casts 215 are used to silence the "cannot find a match" and "invalid conversion" 216 errors that would otherwise occur. */ 217 #if defined __cplusplus && defined GNULIB_NAMESPACE 218 /* The outer cast must be a reinterpret_cast. 219 The inner cast: When the function is defined as a set of overloaded 220 functions, it works as a static_cast<>, choosing the designated variant. 221 When the function is defined as a single variant, it works as a 222 reinterpret_cast<>. The parenthesized cast syntax works both ways. */ 223 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 224 namespace GNULIB_NAMESPACE \ 225 { \ 226 static rettype (*func) parameters = \ 227 reinterpret_cast<rettype(*)parameters>( \ 228 (rettype2(*)parameters2)(::func)); \ 229 } \ 230 _GL_EXTERN_C int _gl_cxxalias_dummy 231 #else 232 # define _GL_CXXALIAS_SYS_CAST2(func,rettype,parameters,rettype2,parameters2) \ 233 _GL_EXTERN_C int _gl_cxxalias_dummy 234 #endif 235 236 /* _GL_CXXALIASWARN (func); 237 causes a warning to be emitted when ::func is used but not when 238 GNULIB_NAMESPACE::func is used. func must be defined without overloaded 239 variants. */ 240 #if defined __cplusplus && defined GNULIB_NAMESPACE 241 # define _GL_CXXALIASWARN(func) \ 242 _GL_CXXALIASWARN_1 (func, GNULIB_NAMESPACE) 243 # define _GL_CXXALIASWARN_1(func,namespace) \ 244 _GL_CXXALIASWARN_2 (func, namespace) 245 /* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 246 we enable the warning only when not optimizing. */ 247 # if !__OPTIMIZE__ 248 # define _GL_CXXALIASWARN_2(func,namespace) \ 249 _GL_WARN_ON_USE (func, \ 250 "The symbol ::" #func " refers to the system function. " \ 251 "Use " #namespace "::" #func " instead.") 252 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 253 # define _GL_CXXALIASWARN_2(func,namespace) \ 254 extern __typeof__ (func) func 255 # else 256 # define _GL_CXXALIASWARN_2(func,namespace) \ 257 _GL_EXTERN_C int _gl_cxxalias_dummy 258 # endif 259 #else 260 # define _GL_CXXALIASWARN(func) \ 261 _GL_EXTERN_C int _gl_cxxalias_dummy 262 #endif 263 264 /* _GL_CXXALIASWARN1 (func, rettype, parameters_and_attributes); 265 causes a warning to be emitted when the given overloaded variant of ::func 266 is used but not when GNULIB_NAMESPACE::func is used. */ 267 #if defined __cplusplus && defined GNULIB_NAMESPACE 268 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 269 _GL_CXXALIASWARN1_1 (func, rettype, parameters_and_attributes, \ 270 GNULIB_NAMESPACE) 271 # define _GL_CXXALIASWARN1_1(func,rettype,parameters_and_attributes,namespace) \ 272 _GL_CXXALIASWARN1_2 (func, rettype, parameters_and_attributes, namespace) 273 /* To work around GCC bug <http://gcc.gnu.org/bugzilla/show_bug.cgi?id=43881>, 274 we enable the warning only when not optimizing. */ 275 # if !__OPTIMIZE__ 276 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 277 _GL_WARN_ON_USE_CXX (func, rettype, parameters_and_attributes, \ 278 "The symbol ::" #func " refers to the system function. " \ 279 "Use " #namespace "::" #func " instead.") 280 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 281 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 282 extern __typeof__ (func) func 283 # else 284 # define _GL_CXXALIASWARN1_2(func,rettype,parameters_and_attributes,namespace) \ 285 _GL_EXTERN_C int _gl_cxxalias_dummy 286 # endif 287 #else 288 # define _GL_CXXALIASWARN1(func,rettype,parameters_and_attributes) \ 289 _GL_EXTERN_C int _gl_cxxalias_dummy 290 #endif 291 292 #endif /* _GL_CXXDEFS_H */ 293 294 /* The definition of _GL_ARG_NONNULL is copied here. */ 295 /* _GL_ARG_NONNULL((n,...,m)) tells the compiler and static analyzer tools 296 that the values passed as arguments n, ..., m must be non-NULL pointers. 297 n = 1 stands for the first argument, n = 2 for the second argument etc. */ 298 #ifndef _GL_ARG_NONNULL 299 # if (__GNUC__ == 3 && __GNUC_MINOR__ >= 3) || __GNUC__ > 3 300 # define _GL_ARG_NONNULL(params) __attribute__ ((__nonnull__ params)) 301 # else 302 # define _GL_ARG_NONNULL(params) 303 # endif 304 #endif 305 306 /* The definition of _GL_WARN_ON_USE is copied here. */ 307 #ifndef _GL_WARN_ON_USE 308 309 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 310 /* A compiler attribute is available in gcc versions 4.3.0 and later. */ 311 # define _GL_WARN_ON_USE(function, message) \ 312 extern __typeof__ (function) function __attribute__ ((__warning__ (message))) 313 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 314 /* Verify the existence of the function. */ 315 # define _GL_WARN_ON_USE(function, message) \ 316 extern __typeof__ (function) function 317 # else /* Unsupported. */ 318 # define _GL_WARN_ON_USE(function, message) \ 319 _GL_WARN_EXTERN_C int _gl_warn_on_use 320 # endif 321 #endif 322 323 /* _GL_WARN_ON_USE_CXX (function, rettype, parameters_and_attributes, "string") 324 is like _GL_WARN_ON_USE (function, "string"), except that the function is 325 declared with the given prototype, consisting of return type, parameters, 326 and attributes. 327 This variant is useful for overloaded functions in C++. _GL_WARN_ON_USE does 328 not work in this case. */ 329 #ifndef _GL_WARN_ON_USE_CXX 330 # if 4 < __GNUC__ || (__GNUC__ == 4 && 3 <= __GNUC_MINOR__) 331 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 332 extern rettype function parameters_and_attributes \ 333 __attribute__ ((__warning__ (msg))) 334 # elif __GNUC__ >= 3 && GNULIB_STRICT_CHECKING 335 /* Verify the existence of the function. */ 336 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 337 extern rettype function parameters_and_attributes 338 # else /* Unsupported. */ 339 # define _GL_WARN_ON_USE_CXX(function,rettype,parameters_and_attributes,msg) \ 340 _GL_WARN_EXTERN_C int _gl_warn_on_use 341 # endif 342 #endif 343 344 /* _GL_WARN_EXTERN_C declaration; 345 performs the declaration with C linkage. */ 346 #ifndef _GL_WARN_EXTERN_C 347 # if defined __cplusplus 348 # define _GL_WARN_EXTERN_C extern "C" 349 # else 350 # define _GL_WARN_EXTERN_C extern 351 # endif 352 #endif 353 354 #ifdef __cplusplus 355 /* Helper macros to define type-generic function FUNC as overloaded functions, 356 rather than as macros like in C. POSIX declares these with an argument of 357 real-floating (that is, one of float, double, or long double). */ 358 # define _GL_MATH_CXX_REAL_FLOATING_DECL_1(func) \ 359 static inline int \ 360 _gl_cxx_ ## func ## f (float f) \ 361 { \ 362 return func (f); \ 363 } \ 364 static inline int \ 365 _gl_cxx_ ## func ## d (double d) \ 366 { \ 367 return func (d); \ 368 } \ 369 static inline int \ 370 _gl_cxx_ ## func ## l (long double l) \ 371 { \ 372 return func (l); \ 373 } 374 # define _GL_MATH_CXX_REAL_FLOATING_DECL_2(func) \ 375 inline int \ 376 func (float f) \ 377 { \ 378 return _gl_cxx_ ## func ## f (f); \ 379 } \ 380 inline int \ 381 func (double d) \ 382 { \ 383 return _gl_cxx_ ## func ## d (d); \ 384 } \ 385 inline int \ 386 func (long double l) \ 387 { \ 388 return _gl_cxx_ ## func ## l (l); \ 389 } 390 #endif 391 392 /* Helper macros to define a portability warning for the 393 classification macro FUNC called with VALUE. POSIX declares the 394 classification macros with an argument of real-floating (that is, 395 one of float, double, or long double). */ 396 #define _GL_WARN_REAL_FLOATING_DECL(func) \ 397 _GL_MATH_INLINE int \ 398 rpl_ ## func ## f (float f) \ 399 { \ 400 return func (f); \ 401 } \ 402 _GL_MATH_INLINE int \ 403 rpl_ ## func ## d (double d) \ 404 { \ 405 return func (d); \ 406 } \ 407 _GL_MATH_INLINE int \ 408 rpl_ ## func ## l (long double l) \ 409 { \ 410 return func (l); \ 411 } \ 412 _GL_WARN_ON_USE (rpl_ ## func ## f, #func " is unportable - " \ 413 "use gnulib module " #func " for portability"); \ 414 _GL_WARN_ON_USE (rpl_ ## func ## d, #func " is unportable - " \ 415 "use gnulib module " #func " for portability"); \ 416 _GL_WARN_ON_USE (rpl_ ## func ## l, #func " is unportable - " \ 417 "use gnulib module " #func " for portability") 418 #define _GL_WARN_REAL_FLOATING_IMPL(func, value) \ 419 (sizeof (value) == sizeof (float) ? rpl_ ## func ## f (value) \ 420 : sizeof (value) == sizeof (double) ? rpl_ ## func ## d (value) \ 421 : rpl_ ## func ## l (value)) 422 423 424 #if 0 425 /* Pull in a function that fixes the 'int' to 'long double' conversion 426 of glibc 2.7. */ 427 _GL_EXTERN_C void _Qp_itoq (long double *, int); 428 static void (*_gl_math_fix_itold) (long double *, int) = _Qp_itoq; 429 #endif 430 431 432 /* POSIX allows platforms that don't support NAN. But all major 433 machines in the past 15 years have supported something close to 434 IEEE NaN, so we define this unconditionally. We also must define 435 it on platforms like Solaris 10, where NAN is present but defined 436 as a function pointer rather than a floating point constant. */ 437 #if !defined NAN || 0 438 # if !GNULIB_defined_NAN 439 # undef NAN 440 /* The Compaq (ex-DEC) C 6.4 compiler and the Microsoft MSVC 9 compiler 441 choke on the expression 0.0 / 0.0. */ 442 # if defined __DECC || defined _MSC_VER 443 _GL_MATH_INLINE float 444 _NaN () 445 { 446 static float zero = 0.0f; 447 return zero / zero; 448 } 449 # define NAN (_NaN()) 450 # else 451 # define NAN (0.0f / 0.0f) 452 # endif 453 # define GNULIB_defined_NAN 1 454 # endif 455 #endif 456 457 /* Solaris 10 defines HUGE_VAL, but as a function pointer rather 458 than a floating point constant. */ 459 #if 0 460 # undef HUGE_VALF 461 # define HUGE_VALF (1.0f / 0.0f) 462 # undef HUGE_VAL 463 # define HUGE_VAL (1.0 / 0.0) 464 # undef HUGE_VALL 465 # define HUGE_VALL (1.0L / 0.0L) 466 #endif 467 468 /* HUGE_VALF is a 'float' Infinity. */ 469 #ifndef HUGE_VALF 470 # if defined _MSC_VER 471 /* The Microsoft MSVC 9 compiler chokes on the expression 1.0f / 0.0f. */ 472 # define HUGE_VALF (1e25f * 1e25f) 473 # else 474 # define HUGE_VALF (1.0f / 0.0f) 475 # endif 476 #endif 477 478 /* HUGE_VAL is a 'double' Infinity. */ 479 #ifndef HUGE_VAL 480 # if defined _MSC_VER 481 /* The Microsoft MSVC 9 compiler chokes on the expression 1.0 / 0.0. */ 482 # define HUGE_VAL (1e250 * 1e250) 483 # else 484 # define HUGE_VAL (1.0 / 0.0) 485 # endif 486 #endif 487 488 /* HUGE_VALL is a 'long double' Infinity. */ 489 #ifndef HUGE_VALL 490 # if defined _MSC_VER 491 /* The Microsoft MSVC 9 compiler chokes on the expression 1.0L / 0.0L. */ 492 # define HUGE_VALL (1e250L * 1e250L) 493 # else 494 # define HUGE_VALL (1.0L / 0.0L) 495 # endif 496 #endif 497 498 499 /* Ensure FP_ILOGB0 and FP_ILOGBNAN are defined. */ 500 #if !(defined FP_ILOGB0 && defined FP_ILOGBNAN) 501 # if defined __NetBSD__ || defined __sgi 502 /* NetBSD, IRIX 6.5: match what ilogb() does */ 503 # define FP_ILOGB0 (- 2147483647 - 1) /* INT_MIN */ 504 # define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */ 505 # elif defined _AIX 506 /* AIX 5.1: match what ilogb() does in AIX >= 5.2 */ 507 # define FP_ILOGB0 (- 2147483647 - 1) /* INT_MIN */ 508 # define FP_ILOGBNAN 2147483647 /* INT_MAX */ 509 # elif defined __sun 510 /* Solaris 9: match what ilogb() does */ 511 # define FP_ILOGB0 (- 2147483647) /* - INT_MAX */ 512 # define FP_ILOGBNAN 2147483647 /* INT_MAX */ 513 # else 514 /* Gnulib defined values. */ 515 # define FP_ILOGB0 (- 2147483647) /* - INT_MAX */ 516 # define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */ 517 # endif 518 #endif 519 520 521 #if 0 522 # if !1 523 # undef acosf 524 _GL_FUNCDECL_SYS (acosf, float, (float x)); 525 # endif 526 _GL_CXXALIAS_SYS (acosf, float, (float x)); 527 _GL_CXXALIASWARN (acosf); 528 #elif defined GNULIB_POSIXCHECK 529 # undef acosf 530 # if HAVE_RAW_DECL_ACOSF 531 _GL_WARN_ON_USE (acosf, "acosf is unportable - " 532 "use gnulib module acosf for portability"); 533 # endif 534 #endif 535 536 #if 0 537 # if !1 || !1 538 # undef acosl 539 _GL_FUNCDECL_SYS (acosl, long double, (long double x)); 540 # endif 541 _GL_CXXALIAS_SYS (acosl, long double, (long double x)); 542 _GL_CXXALIASWARN (acosl); 543 #elif defined GNULIB_POSIXCHECK 544 # undef acosl 545 # if HAVE_RAW_DECL_ACOSL 546 _GL_WARN_ON_USE (acosl, "acosl is unportable - " 547 "use gnulib module acosl for portability"); 548 # endif 549 #endif 550 551 552 #if 0 553 # if !1 554 # undef asinf 555 _GL_FUNCDECL_SYS (asinf, float, (float x)); 556 # endif 557 _GL_CXXALIAS_SYS (asinf, float, (float x)); 558 _GL_CXXALIASWARN (asinf); 559 #elif defined GNULIB_POSIXCHECK 560 # undef asinf 561 # if HAVE_RAW_DECL_ASINF 562 _GL_WARN_ON_USE (asinf, "asinf is unportable - " 563 "use gnulib module asinf for portability"); 564 # endif 565 #endif 566 567 #if 0 568 # if !1 || !1 569 # undef asinl 570 _GL_FUNCDECL_SYS (asinl, long double, (long double x)); 571 # endif 572 _GL_CXXALIAS_SYS (asinl, long double, (long double x)); 573 _GL_CXXALIASWARN (asinl); 574 #elif defined GNULIB_POSIXCHECK 575 # undef asinl 576 # if HAVE_RAW_DECL_ASINL 577 _GL_WARN_ON_USE (asinl, "asinl is unportable - " 578 "use gnulib module asinl for portability"); 579 # endif 580 #endif 581 582 583 #if 0 584 # if !1 585 # undef atanf 586 _GL_FUNCDECL_SYS (atanf, float, (float x)); 587 # endif 588 _GL_CXXALIAS_SYS (atanf, float, (float x)); 589 _GL_CXXALIASWARN (atanf); 590 #elif defined GNULIB_POSIXCHECK 591 # undef atanf 592 # if HAVE_RAW_DECL_ATANF 593 _GL_WARN_ON_USE (atanf, "atanf is unportable - " 594 "use gnulib module atanf for portability"); 595 # endif 596 #endif 597 598 #if 0 599 # if !1 || !1 600 # undef atanl 601 _GL_FUNCDECL_SYS (atanl, long double, (long double x)); 602 # endif 603 _GL_CXXALIAS_SYS (atanl, long double, (long double x)); 604 _GL_CXXALIASWARN (atanl); 605 #elif defined GNULIB_POSIXCHECK 606 # undef atanl 607 # if HAVE_RAW_DECL_ATANL 608 _GL_WARN_ON_USE (atanl, "atanl is unportable - " 609 "use gnulib module atanl for portability"); 610 # endif 611 #endif 612 613 614 #if 0 615 # if !1 616 # undef atan2f 617 _GL_FUNCDECL_SYS (atan2f, float, (float y, float x)); 618 # endif 619 _GL_CXXALIAS_SYS (atan2f, float, (float y, float x)); 620 _GL_CXXALIASWARN (atan2f); 621 #elif defined GNULIB_POSIXCHECK 622 # undef atan2f 623 # if HAVE_RAW_DECL_ATAN2F 624 _GL_WARN_ON_USE (atan2f, "atan2f is unportable - " 625 "use gnulib module atan2f for portability"); 626 # endif 627 #endif 628 629 630 #if 0 631 # if 0 632 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 633 # undef cbrtf 634 # define cbrtf rpl_cbrtf 635 # endif 636 _GL_FUNCDECL_RPL (cbrtf, float, (float x)); 637 _GL_CXXALIAS_RPL (cbrtf, float, (float x)); 638 # else 639 # if !1 640 _GL_FUNCDECL_SYS (cbrtf, float, (float x)); 641 # endif 642 _GL_CXXALIAS_SYS (cbrtf, float, (float x)); 643 # endif 644 _GL_CXXALIASWARN (cbrtf); 645 #elif defined GNULIB_POSIXCHECK 646 # undef cbrtf 647 # if HAVE_RAW_DECL_CBRTF 648 _GL_WARN_ON_USE (cbrtf, "cbrtf is unportable - " 649 "use gnulib module cbrtf for portability"); 650 # endif 651 #endif 652 653 #if 0 654 # if !1 655 _GL_FUNCDECL_SYS (cbrt, double, (double x)); 656 # endif 657 _GL_CXXALIAS_SYS (cbrt, double, (double x)); 658 _GL_CXXALIASWARN (cbrt); 659 #elif defined GNULIB_POSIXCHECK 660 # undef cbrt 661 # if HAVE_RAW_DECL_CBRT 662 _GL_WARN_ON_USE (cbrt, "cbrt is unportable - " 663 "use gnulib module cbrt for portability"); 664 # endif 665 #endif 666 667 #if 0 668 # if 0 669 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 670 # undef cbrtl 671 # define cbrtl rpl_cbrtl 672 # endif 673 _GL_FUNCDECL_RPL (cbrtl, long double, (long double x)); 674 _GL_CXXALIAS_RPL (cbrtl, long double, (long double x)); 675 # else 676 # if !1 677 _GL_FUNCDECL_SYS (cbrtl, long double, (long double x)); 678 # endif 679 _GL_CXXALIAS_SYS (cbrtl, long double, (long double x)); 680 # endif 681 _GL_CXXALIASWARN (cbrtl); 682 #elif defined GNULIB_POSIXCHECK 683 # undef cbrtl 684 # if HAVE_RAW_DECL_CBRTL 685 _GL_WARN_ON_USE (cbrtl, "cbrtl is unportable - " 686 "use gnulib module cbrtl for portability"); 687 # endif 688 #endif 689 690 691 #if 0 692 # if 0 693 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 694 # undef ceilf 695 # define ceilf rpl_ceilf 696 # endif 697 _GL_FUNCDECL_RPL (ceilf, float, (float x)); 698 _GL_CXXALIAS_RPL (ceilf, float, (float x)); 699 # else 700 # if !1 701 # undef ceilf 702 _GL_FUNCDECL_SYS (ceilf, float, (float x)); 703 # endif 704 _GL_CXXALIAS_SYS (ceilf, float, (float x)); 705 # endif 706 _GL_CXXALIASWARN (ceilf); 707 #elif defined GNULIB_POSIXCHECK 708 # undef ceilf 709 # if HAVE_RAW_DECL_CEILF 710 _GL_WARN_ON_USE (ceilf, "ceilf is unportable - " 711 "use gnulib module ceilf for portability"); 712 # endif 713 #endif 714 715 #if 0 716 # if 0 717 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 718 # define ceil rpl_ceil 719 # endif 720 _GL_FUNCDECL_RPL (ceil, double, (double x)); 721 _GL_CXXALIAS_RPL (ceil, double, (double x)); 722 # else 723 _GL_CXXALIAS_SYS (ceil, double, (double x)); 724 # endif 725 _GL_CXXALIASWARN (ceil); 726 #endif 727 728 #if 0 729 # if 0 730 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 731 # undef ceill 732 # define ceill rpl_ceill 733 # endif 734 _GL_FUNCDECL_RPL (ceill, long double, (long double x)); 735 _GL_CXXALIAS_RPL (ceill, long double, (long double x)); 736 # else 737 # if !1 738 # undef ceill 739 _GL_FUNCDECL_SYS (ceill, long double, (long double x)); 740 # endif 741 _GL_CXXALIAS_SYS (ceill, long double, (long double x)); 742 # endif 743 _GL_CXXALIASWARN (ceill); 744 #elif defined GNULIB_POSIXCHECK 745 # undef ceill 746 # if HAVE_RAW_DECL_CEILL 747 _GL_WARN_ON_USE (ceill, "ceill is unportable - " 748 "use gnulib module ceill for portability"); 749 # endif 750 #endif 751 752 753 #if 0 754 # if !1 755 _GL_FUNCDECL_SYS (copysignf, float, (float x, float y)); 756 # endif 757 _GL_CXXALIAS_SYS (copysignf, float, (float x, float y)); 758 _GL_CXXALIASWARN (copysignf); 759 #elif defined GNULIB_POSIXCHECK 760 # undef copysignf 761 # if HAVE_RAW_DECL_COPYSIGNF 762 _GL_WARN_ON_USE (copysignf, "copysignf is unportable - " 763 "use gnulib module copysignf for portability"); 764 # endif 765 #endif 766 767 #if 0 768 # if !1 769 _GL_FUNCDECL_SYS (copysign, double, (double x, double y)); 770 # endif 771 _GL_CXXALIAS_SYS (copysign, double, (double x, double y)); 772 _GL_CXXALIASWARN (copysign); 773 #elif defined GNULIB_POSIXCHECK 774 # undef copysign 775 # if HAVE_RAW_DECL_COPYSIGN 776 _GL_WARN_ON_USE (copysign, "copysign is unportable - " 777 "use gnulib module copysign for portability"); 778 # endif 779 #endif 780 781 #if 0 782 # if !1 783 _GL_FUNCDECL_SYS (copysignl, long double, (long double x, long double y)); 784 # endif 785 _GL_CXXALIAS_SYS (copysignl, long double, (long double x, long double y)); 786 _GL_CXXALIASWARN (copysignl); 787 #elif defined GNULIB_POSIXCHECK 788 # undef copysignl 789 # if HAVE_RAW_DECL_COPYSIGNL 790 _GL_WARN_ON_USE (copysign, "copysignl is unportable - " 791 "use gnulib module copysignl for portability"); 792 # endif 793 #endif 794 795 796 #if 0 797 # if !1 798 # undef cosf 799 _GL_FUNCDECL_SYS (cosf, float, (float x)); 800 # endif 801 _GL_CXXALIAS_SYS (cosf, float, (float x)); 802 _GL_CXXALIASWARN (cosf); 803 #elif defined GNULIB_POSIXCHECK 804 # undef cosf 805 # if HAVE_RAW_DECL_COSF 806 _GL_WARN_ON_USE (cosf, "cosf is unportable - " 807 "use gnulib module cosf for portability"); 808 # endif 809 #endif 810 811 #if 0 812 # if !1 || !1 813 # undef cosl 814 _GL_FUNCDECL_SYS (cosl, long double, (long double x)); 815 # endif 816 _GL_CXXALIAS_SYS (cosl, long double, (long double x)); 817 _GL_CXXALIASWARN (cosl); 818 #elif defined GNULIB_POSIXCHECK 819 # undef cosl 820 # if HAVE_RAW_DECL_COSL 821 _GL_WARN_ON_USE (cosl, "cosl is unportable - " 822 "use gnulib module cosl for portability"); 823 # endif 824 #endif 825 826 827 #if 0 828 # if !1 829 # undef coshf 830 _GL_FUNCDECL_SYS (coshf, float, (float x)); 831 # endif 832 _GL_CXXALIAS_SYS (coshf, float, (float x)); 833 _GL_CXXALIASWARN (coshf); 834 #elif defined GNULIB_POSIXCHECK 835 # undef coshf 836 # if HAVE_RAW_DECL_COSHF 837 _GL_WARN_ON_USE (coshf, "coshf is unportable - " 838 "use gnulib module coshf for portability"); 839 # endif 840 #endif 841 842 843 #if 0 844 # if !1 845 # undef expf 846 _GL_FUNCDECL_SYS (expf, float, (float x)); 847 # endif 848 _GL_CXXALIAS_SYS (expf, float, (float x)); 849 _GL_CXXALIASWARN (expf); 850 #elif defined GNULIB_POSIXCHECK 851 # undef expf 852 # if HAVE_RAW_DECL_EXPF 853 _GL_WARN_ON_USE (expf, "expf is unportable - " 854 "use gnulib module expf for portability"); 855 # endif 856 #endif 857 858 #if 0 859 # if !1 || !1 860 # undef expl 861 _GL_FUNCDECL_SYS (expl, long double, (long double x)); 862 # endif 863 _GL_CXXALIAS_SYS (expl, long double, (long double x)); 864 _GL_CXXALIASWARN (expl); 865 #elif defined GNULIB_POSIXCHECK 866 # undef expl 867 # if HAVE_RAW_DECL_EXPL 868 _GL_WARN_ON_USE (expl, "expl is unportable - " 869 "use gnulib module expl for portability"); 870 # endif 871 #endif 872 873 874 #if 0 875 # if !1 876 _GL_FUNCDECL_SYS (exp2f, float, (float x)); 877 # endif 878 _GL_CXXALIAS_SYS (exp2f, float, (float x)); 879 _GL_CXXALIASWARN (exp2f); 880 #elif defined GNULIB_POSIXCHECK 881 # undef exp2f 882 # if HAVE_RAW_DECL_EXP2F 883 _GL_WARN_ON_USE (exp2f, "exp2f is unportable - " 884 "use gnulib module exp2f for portability"); 885 # endif 886 #endif 887 888 #if 0 889 # if 0 890 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 891 # undef exp2 892 # define exp2 rpl_exp2 893 # endif 894 _GL_FUNCDECL_RPL (exp2, double, (double x)); 895 _GL_CXXALIAS_RPL (exp2, double, (double x)); 896 # else 897 # if !1 898 _GL_FUNCDECL_SYS (exp2, double, (double x)); 899 # endif 900 _GL_CXXALIAS_SYS (exp2, double, (double x)); 901 # endif 902 _GL_CXXALIASWARN (exp2); 903 #elif defined GNULIB_POSIXCHECK 904 # undef exp2 905 # if HAVE_RAW_DECL_EXP2 906 _GL_WARN_ON_USE (exp2, "exp2 is unportable - " 907 "use gnulib module exp2 for portability"); 908 # endif 909 #endif 910 911 #if 0 912 # if 0 913 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 914 # undef exp2l 915 # define exp2l rpl_exp2l 916 # endif 917 _GL_FUNCDECL_RPL (exp2l, long double, (long double x)); 918 _GL_CXXALIAS_RPL (exp2l, long double, (long double x)); 919 # else 920 # if !1 921 # undef exp2l 922 _GL_FUNCDECL_SYS (exp2l, long double, (long double x)); 923 # endif 924 _GL_CXXALIAS_SYS (exp2l, long double, (long double x)); 925 # endif 926 _GL_CXXALIASWARN (exp2l); 927 #elif defined GNULIB_POSIXCHECK 928 # undef exp2l 929 # if HAVE_RAW_DECL_EXP2L 930 _GL_WARN_ON_USE (exp2l, "exp2l is unportable - " 931 "use gnulib module exp2l for portability"); 932 # endif 933 #endif 934 935 936 #if 0 937 # if 0 938 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 939 # undef expm1f 940 # define expm1f rpl_expm1f 941 # endif 942 _GL_FUNCDECL_RPL (expm1f, float, (float x)); 943 _GL_CXXALIAS_RPL (expm1f, float, (float x)); 944 # else 945 # if !1 946 _GL_FUNCDECL_SYS (expm1f, float, (float x)); 947 # endif 948 _GL_CXXALIAS_SYS (expm1f, float, (float x)); 949 # endif 950 _GL_CXXALIASWARN (expm1f); 951 #elif defined GNULIB_POSIXCHECK 952 # undef expm1f 953 # if HAVE_RAW_DECL_EXPM1F 954 _GL_WARN_ON_USE (expm1f, "expm1f is unportable - " 955 "use gnulib module expm1f for portability"); 956 # endif 957 #endif 958 959 #if 0 960 # if 0 961 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 962 # undef expm1 963 # define expm1 rpl_expm1 964 # endif 965 _GL_FUNCDECL_RPL (expm1, double, (double x)); 966 _GL_CXXALIAS_RPL (expm1, double, (double x)); 967 # else 968 # if !1 969 _GL_FUNCDECL_SYS (expm1, double, (double x)); 970 # endif 971 _GL_CXXALIAS_SYS (expm1, double, (double x)); 972 # endif 973 _GL_CXXALIASWARN (expm1); 974 #elif defined GNULIB_POSIXCHECK 975 # undef expm1 976 # if HAVE_RAW_DECL_EXPM1 977 _GL_WARN_ON_USE (expm1, "expm1 is unportable - " 978 "use gnulib module expm1 for portability"); 979 # endif 980 #endif 981 982 #if 0 983 # if !1 984 # undef expm1l 985 _GL_FUNCDECL_SYS (expm1l, long double, (long double x)); 986 # endif 987 _GL_CXXALIAS_SYS (expm1l, long double, (long double x)); 988 _GL_CXXALIASWARN (expm1l); 989 #elif defined GNULIB_POSIXCHECK 990 # undef expm1l 991 # if HAVE_RAW_DECL_EXPM1L 992 _GL_WARN_ON_USE (expm1l, "expm1l is unportable - " 993 "use gnulib module expm1l for portability"); 994 # endif 995 #endif 996 997 998 #if 0 999 # if !1 1000 # undef fabsf 1001 _GL_FUNCDECL_SYS (fabsf, float, (float x)); 1002 # endif 1003 _GL_CXXALIAS_SYS (fabsf, float, (float x)); 1004 _GL_CXXALIASWARN (fabsf); 1005 #elif defined GNULIB_POSIXCHECK 1006 # undef fabsf 1007 # if HAVE_RAW_DECL_FABSF 1008 _GL_WARN_ON_USE (fabsf, "fabsf is unportable - " 1009 "use gnulib module fabsf for portability"); 1010 # endif 1011 #endif 1012 1013 #if 0 1014 # if 0 1015 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1016 # undef fabsl 1017 # define fabsl rpl_fabsl 1018 # endif 1019 _GL_FUNCDECL_RPL (fabsl, long double, (long double x)); 1020 _GL_CXXALIAS_RPL (fabsl, long double, (long double x)); 1021 # else 1022 # if !1 1023 # undef fabsl 1024 _GL_FUNCDECL_SYS (fabsl, long double, (long double x)); 1025 # endif 1026 _GL_CXXALIAS_SYS (fabsl, long double, (long double x)); 1027 # endif 1028 _GL_CXXALIASWARN (fabsl); 1029 #elif defined GNULIB_POSIXCHECK 1030 # undef fabsl 1031 # if HAVE_RAW_DECL_FABSL 1032 _GL_WARN_ON_USE (fabsl, "fabsl is unportable - " 1033 "use gnulib module fabsl for portability"); 1034 # endif 1035 #endif 1036 1037 1038 #if 0 1039 # if 0 1040 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1041 # undef floorf 1042 # define floorf rpl_floorf 1043 # endif 1044 _GL_FUNCDECL_RPL (floorf, float, (float x)); 1045 _GL_CXXALIAS_RPL (floorf, float, (float x)); 1046 # else 1047 # if !1 1048 # undef floorf 1049 _GL_FUNCDECL_SYS (floorf, float, (float x)); 1050 # endif 1051 _GL_CXXALIAS_SYS (floorf, float, (float x)); 1052 # endif 1053 _GL_CXXALIASWARN (floorf); 1054 #elif defined GNULIB_POSIXCHECK 1055 # undef floorf 1056 # if HAVE_RAW_DECL_FLOORF 1057 _GL_WARN_ON_USE (floorf, "floorf is unportable - " 1058 "use gnulib module floorf for portability"); 1059 # endif 1060 #endif 1061 1062 #if 0 1063 # if 0 1064 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1065 # define floor rpl_floor 1066 # endif 1067 _GL_FUNCDECL_RPL (floor, double, (double x)); 1068 _GL_CXXALIAS_RPL (floor, double, (double x)); 1069 # else 1070 _GL_CXXALIAS_SYS (floor, double, (double x)); 1071 # endif 1072 _GL_CXXALIASWARN (floor); 1073 #endif 1074 1075 #if 0 1076 # if 0 1077 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1078 # undef floorl 1079 # define floorl rpl_floorl 1080 # endif 1081 _GL_FUNCDECL_RPL (floorl, long double, (long double x)); 1082 _GL_CXXALIAS_RPL (floorl, long double, (long double x)); 1083 # else 1084 # if !1 1085 # undef floorl 1086 _GL_FUNCDECL_SYS (floorl, long double, (long double x)); 1087 # endif 1088 _GL_CXXALIAS_SYS (floorl, long double, (long double x)); 1089 # endif 1090 _GL_CXXALIASWARN (floorl); 1091 #elif defined GNULIB_POSIXCHECK 1092 # undef floorl 1093 # if HAVE_RAW_DECL_FLOORL 1094 _GL_WARN_ON_USE (floorl, "floorl is unportable - " 1095 "use gnulib module floorl for portability"); 1096 # endif 1097 #endif 1098 1099 1100 #if 0 1101 # if 0 1102 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1103 # undef fmaf 1104 # define fmaf rpl_fmaf 1105 # endif 1106 _GL_FUNCDECL_RPL (fmaf, float, (float x, float y, float z)); 1107 _GL_CXXALIAS_RPL (fmaf, float, (float x, float y, float z)); 1108 # else 1109 # if !1 1110 _GL_FUNCDECL_SYS (fmaf, float, (float x, float y, float z)); 1111 # endif 1112 _GL_CXXALIAS_SYS (fmaf, float, (float x, float y, float z)); 1113 # endif 1114 _GL_CXXALIASWARN (fmaf); 1115 #elif defined GNULIB_POSIXCHECK 1116 # undef fmaf 1117 # if HAVE_RAW_DECL_FMAF 1118 _GL_WARN_ON_USE (fmaf, "fmaf is unportable - " 1119 "use gnulib module fmaf for portability"); 1120 # endif 1121 #endif 1122 1123 #if 0 1124 # if 0 1125 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1126 # undef fma 1127 # define fma rpl_fma 1128 # endif 1129 _GL_FUNCDECL_RPL (fma, double, (double x, double y, double z)); 1130 _GL_CXXALIAS_RPL (fma, double, (double x, double y, double z)); 1131 # else 1132 # if !1 1133 _GL_FUNCDECL_SYS (fma, double, (double x, double y, double z)); 1134 # endif 1135 _GL_CXXALIAS_SYS (fma, double, (double x, double y, double z)); 1136 # endif 1137 _GL_CXXALIASWARN (fma); 1138 #elif defined GNULIB_POSIXCHECK 1139 # undef fma 1140 # if HAVE_RAW_DECL_FMA 1141 _GL_WARN_ON_USE (fma, "fma is unportable - " 1142 "use gnulib module fma for portability"); 1143 # endif 1144 #endif 1145 1146 #if 0 1147 # if 0 1148 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1149 # undef fmal 1150 # define fmal rpl_fmal 1151 # endif 1152 _GL_FUNCDECL_RPL (fmal, long double, 1153 (long double x, long double y, long double z)); 1154 _GL_CXXALIAS_RPL (fmal, long double, 1155 (long double x, long double y, long double z)); 1156 # else 1157 # if !1 1158 # undef fmal 1159 _GL_FUNCDECL_SYS (fmal, long double, 1160 (long double x, long double y, long double z)); 1161 # endif 1162 _GL_CXXALIAS_SYS (fmal, long double, 1163 (long double x, long double y, long double z)); 1164 # endif 1165 _GL_CXXALIASWARN (fmal); 1166 #elif defined GNULIB_POSIXCHECK 1167 # undef fmal 1168 # if HAVE_RAW_DECL_FMAL 1169 _GL_WARN_ON_USE (fmal, "fmal is unportable - " 1170 "use gnulib module fmal for portability"); 1171 # endif 1172 #endif 1173 1174 1175 #if 0 1176 # if 0 1177 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1178 # undef fmodf 1179 # define fmodf rpl_fmodf 1180 # endif 1181 _GL_FUNCDECL_RPL (fmodf, float, (float x, float y)); 1182 _GL_CXXALIAS_RPL (fmodf, float, (float x, float y)); 1183 # else 1184 # if !1 1185 # undef fmodf 1186 _GL_FUNCDECL_SYS (fmodf, float, (float x, float y)); 1187 # endif 1188 _GL_CXXALIAS_SYS (fmodf, float, (float x, float y)); 1189 # endif 1190 _GL_CXXALIASWARN (fmodf); 1191 #elif defined GNULIB_POSIXCHECK 1192 # undef fmodf 1193 # if HAVE_RAW_DECL_FMODF 1194 _GL_WARN_ON_USE (fmodf, "fmodf is unportable - " 1195 "use gnulib module fmodf for portability"); 1196 # endif 1197 #endif 1198 1199 #if 0 1200 # if 0 1201 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1202 # undef fmod 1203 # define fmod rpl_fmod 1204 # endif 1205 _GL_FUNCDECL_RPL (fmod, double, (double x, double y)); 1206 _GL_CXXALIAS_RPL (fmod, double, (double x, double y)); 1207 # else 1208 _GL_CXXALIAS_SYS (fmod, double, (double x, double y)); 1209 # endif 1210 _GL_CXXALIASWARN (fmod); 1211 #elif defined GNULIB_POSIXCHECK 1212 # undef fmod 1213 # if HAVE_RAW_DECL_FMOD 1214 _GL_WARN_ON_USE (fmod, "fmod has portability problems - " 1215 "use gnulib module fmod for portability"); 1216 # endif 1217 #endif 1218 1219 #if 0 1220 # if 0 1221 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1222 # undef fmodl 1223 # define fmodl rpl_fmodl 1224 # endif 1225 _GL_FUNCDECL_RPL (fmodl, long double, (long double x, long double y)); 1226 _GL_CXXALIAS_RPL (fmodl, long double, (long double x, long double y)); 1227 # else 1228 # if !1 1229 # undef fmodl 1230 _GL_FUNCDECL_SYS (fmodl, long double, (long double x, long double y)); 1231 # endif 1232 _GL_CXXALIAS_SYS (fmodl, long double, (long double x, long double y)); 1233 # endif 1234 _GL_CXXALIASWARN (fmodl); 1235 #elif defined GNULIB_POSIXCHECK 1236 # undef fmodl 1237 # if HAVE_RAW_DECL_FMODL 1238 _GL_WARN_ON_USE (fmodl, "fmodl is unportable - " 1239 "use gnulib module fmodl for portability"); 1240 # endif 1241 #endif 1242 1243 1244 /* Write x as 1245 x = mantissa * 2^exp 1246 where 1247 If x finite and nonzero: 0.5 <= |mantissa| < 1.0. 1248 If x is zero: mantissa = x, exp = 0. 1249 If x is infinite or NaN: mantissa = x, exp unspecified. 1250 Store exp in *EXPPTR and return mantissa. */ 1251 #if 0 1252 # if 0 1253 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1254 # undef frexpf 1255 # define frexpf rpl_frexpf 1256 # endif 1257 _GL_FUNCDECL_RPL (frexpf, float, (float x, int *expptr) _GL_ARG_NONNULL ((2))); 1258 _GL_CXXALIAS_RPL (frexpf, float, (float x, int *expptr)); 1259 # else 1260 # if !1 1261 # undef frexpf 1262 _GL_FUNCDECL_SYS (frexpf, float, (float x, int *expptr) _GL_ARG_NONNULL ((2))); 1263 # endif 1264 _GL_CXXALIAS_SYS (frexpf, float, (float x, int *expptr)); 1265 # endif 1266 _GL_CXXALIASWARN (frexpf); 1267 #elif defined GNULIB_POSIXCHECK 1268 # undef frexpf 1269 # if HAVE_RAW_DECL_FREXPF 1270 _GL_WARN_ON_USE (frexpf, "frexpf is unportable - " 1271 "use gnulib module frexpf for portability"); 1272 # endif 1273 #endif 1274 1275 /* Write x as 1276 x = mantissa * 2^exp 1277 where 1278 If x finite and nonzero: 0.5 <= |mantissa| < 1.0. 1279 If x is zero: mantissa = x, exp = 0. 1280 If x is infinite or NaN: mantissa = x, exp unspecified. 1281 Store exp in *EXPPTR and return mantissa. */ 1282 #if 1 1283 # if 0 1284 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1285 # define frexp rpl_frexp 1286 # endif 1287 _GL_FUNCDECL_RPL (frexp, double, (double x, int *expptr) _GL_ARG_NONNULL ((2))); 1288 _GL_CXXALIAS_RPL (frexp, double, (double x, int *expptr)); 1289 # else 1290 _GL_CXXALIAS_SYS (frexp, double, (double x, int *expptr)); 1291 # endif 1292 _GL_CXXALIASWARN (frexp); 1293 #elif defined GNULIB_POSIXCHECK 1294 # undef frexp 1295 /* Assume frexp is always declared. */ 1296 _GL_WARN_ON_USE (frexp, "frexp is unportable - " 1297 "use gnulib module frexp for portability"); 1298 #endif 1299 1300 /* Write x as 1301 x = mantissa * 2^exp 1302 where 1303 If x finite and nonzero: 0.5 <= |mantissa| < 1.0. 1304 If x is zero: mantissa = x, exp = 0. 1305 If x is infinite or NaN: mantissa = x, exp unspecified. 1306 Store exp in *EXPPTR and return mantissa. */ 1307 #if 1 && 0 1308 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1309 # undef frexpl 1310 # define frexpl rpl_frexpl 1311 # endif 1312 _GL_FUNCDECL_RPL (frexpl, long double, 1313 (long double x, int *expptr) _GL_ARG_NONNULL ((2))); 1314 _GL_CXXALIAS_RPL (frexpl, long double, (long double x, int *expptr)); 1315 #else 1316 # if !1 1317 _GL_FUNCDECL_SYS (frexpl, long double, 1318 (long double x, int *expptr) _GL_ARG_NONNULL ((2))); 1319 # endif 1320 # if 1 1321 _GL_CXXALIAS_SYS (frexpl, long double, (long double x, int *expptr)); 1322 # endif 1323 #endif 1324 #if 1 && !(0 && !1) 1325 _GL_CXXALIASWARN (frexpl); 1326 #endif 1327 #if !1 && defined GNULIB_POSIXCHECK 1328 # undef frexpl 1329 # if HAVE_RAW_DECL_FREXPL 1330 _GL_WARN_ON_USE (frexpl, "frexpl is unportable - " 1331 "use gnulib module frexpl for portability"); 1332 # endif 1333 #endif 1334 1335 1336 /* Return sqrt(x^2+y^2). */ 1337 #if 0 1338 # if 0 1339 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1340 # undef hypotf 1341 # define hypotf rpl_hypotf 1342 # endif 1343 _GL_FUNCDECL_RPL (hypotf, float, (float x, float y)); 1344 _GL_CXXALIAS_RPL (hypotf, float, (float x, float y)); 1345 # else 1346 # if !1 1347 _GL_FUNCDECL_SYS (hypotf, float, (float x, float y)); 1348 # endif 1349 _GL_CXXALIAS_SYS (hypotf, float, (float x, float y)); 1350 # endif 1351 _GL_CXXALIASWARN (hypotf); 1352 #elif defined GNULIB_POSIXCHECK 1353 # undef hypotf 1354 # if HAVE_RAW_DECL_HYPOTF 1355 _GL_WARN_ON_USE (hypotf, "hypotf is unportable - " 1356 "use gnulib module hypotf for portability"); 1357 # endif 1358 #endif 1359 1360 /* Return sqrt(x^2+y^2). */ 1361 #if 0 1362 # if 0 1363 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1364 # undef hypot 1365 # define hypot rpl_hypot 1366 # endif 1367 _GL_FUNCDECL_RPL (hypot, double, (double x, double y)); 1368 _GL_CXXALIAS_RPL (hypot, double, (double x, double y)); 1369 # else 1370 _GL_CXXALIAS_SYS (hypot, double, (double x, double y)); 1371 # endif 1372 _GL_CXXALIASWARN (hypot); 1373 #elif defined GNULIB_POSIXCHECK 1374 # undef hypot 1375 # if HAVE_RAW_DECL_HYPOT 1376 _GL_WARN_ON_USE (hypotf, "hypot has portability problems - " 1377 "use gnulib module hypot for portability"); 1378 # endif 1379 #endif 1380 1381 /* Return sqrt(x^2+y^2). */ 1382 #if 0 1383 # if 0 1384 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1385 # undef hypotl 1386 # define hypotl rpl_hypotl 1387 # endif 1388 _GL_FUNCDECL_RPL (hypotl, long double, (long double x, long double y)); 1389 _GL_CXXALIAS_RPL (hypotl, long double, (long double x, long double y)); 1390 # else 1391 # if !1 1392 _GL_FUNCDECL_SYS (hypotl, long double, (long double x, long double y)); 1393 # endif 1394 _GL_CXXALIAS_SYS (hypotl, long double, (long double x, long double y)); 1395 # endif 1396 _GL_CXXALIASWARN (hypotl); 1397 #elif defined GNULIB_POSIXCHECK 1398 # undef hypotl 1399 # if HAVE_RAW_DECL_HYPOTL 1400 _GL_WARN_ON_USE (hypotl, "hypotl is unportable - " 1401 "use gnulib module hypotl for portability"); 1402 # endif 1403 #endif 1404 1405 1406 #if 0 1407 # if 0 1408 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1409 # undef ilogbf 1410 # define ilogbf rpl_ilogbf 1411 # endif 1412 _GL_FUNCDECL_RPL (ilogbf, int, (float x)); 1413 _GL_CXXALIAS_RPL (ilogbf, int, (float x)); 1414 # else 1415 # if !1 1416 _GL_FUNCDECL_SYS (ilogbf, int, (float x)); 1417 # endif 1418 _GL_CXXALIAS_SYS (ilogbf, int, (float x)); 1419 # endif 1420 _GL_CXXALIASWARN (ilogbf); 1421 #elif defined GNULIB_POSIXCHECK 1422 # undef ilogbf 1423 # if HAVE_RAW_DECL_ILOGBF 1424 _GL_WARN_ON_USE (ilogbf, "ilogbf is unportable - " 1425 "use gnulib module ilogbf for portability"); 1426 # endif 1427 #endif 1428 1429 #if 0 1430 # if 0 1431 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1432 # undef ilogb 1433 # define ilogb rpl_ilogb 1434 # endif 1435 _GL_FUNCDECL_RPL (ilogb, int, (double x)); 1436 _GL_CXXALIAS_RPL (ilogb, int, (double x)); 1437 # else 1438 # if !1 1439 _GL_FUNCDECL_SYS (ilogb, int, (double x)); 1440 # endif 1441 _GL_CXXALIAS_SYS (ilogb, int, (double x)); 1442 # endif 1443 _GL_CXXALIASWARN (ilogb); 1444 #elif defined GNULIB_POSIXCHECK 1445 # undef ilogb 1446 # if HAVE_RAW_DECL_ILOGB 1447 _GL_WARN_ON_USE (ilogb, "ilogb is unportable - " 1448 "use gnulib module ilogb for portability"); 1449 # endif 1450 #endif 1451 1452 #if 0 1453 # if !1 1454 _GL_FUNCDECL_SYS (ilogbl, int, (long double x)); 1455 # endif 1456 _GL_CXXALIAS_SYS (ilogbl, int, (long double x)); 1457 _GL_CXXALIASWARN (ilogbl); 1458 #elif defined GNULIB_POSIXCHECK 1459 # undef ilogbl 1460 # if HAVE_RAW_DECL_ILOGBL 1461 _GL_WARN_ON_USE (ilogbl, "ilogbl is unportable - " 1462 "use gnulib module ilogbl for portability"); 1463 # endif 1464 #endif 1465 1466 1467 /* Return x * 2^exp. */ 1468 #if 0 1469 # if !1 1470 # undef ldexpf 1471 _GL_FUNCDECL_SYS (ldexpf, float, (float x, int exp)); 1472 # endif 1473 _GL_CXXALIAS_SYS (ldexpf, float, (float x, int exp)); 1474 _GL_CXXALIASWARN (ldexpf); 1475 #elif defined GNULIB_POSIXCHECK 1476 # undef ldexpf 1477 # if HAVE_RAW_DECL_LDEXPF 1478 _GL_WARN_ON_USE (ldexpf, "ldexpf is unportable - " 1479 "use gnulib module ldexpf for portability"); 1480 # endif 1481 #endif 1482 1483 /* Return x * 2^exp. */ 1484 #if 1 && 0 1485 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1486 # undef ldexpl 1487 # define ldexpl rpl_ldexpl 1488 # endif 1489 _GL_FUNCDECL_RPL (ldexpl, long double, (long double x, int exp)); 1490 _GL_CXXALIAS_RPL (ldexpl, long double, (long double x, int exp)); 1491 #else 1492 # if !1 1493 _GL_FUNCDECL_SYS (ldexpl, long double, (long double x, int exp)); 1494 # endif 1495 # if 1 1496 _GL_CXXALIAS_SYS (ldexpl, long double, (long double x, int exp)); 1497 # endif 1498 #endif 1499 #if 1 1500 _GL_CXXALIASWARN (ldexpl); 1501 #endif 1502 #if !1 && defined GNULIB_POSIXCHECK 1503 # undef ldexpl 1504 # if HAVE_RAW_DECL_LDEXPL 1505 _GL_WARN_ON_USE (ldexpl, "ldexpl is unportable - " 1506 "use gnulib module ldexpl for portability"); 1507 # endif 1508 #endif 1509 1510 1511 #if 0 1512 # if 0 1513 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1514 # undef logf 1515 # define logf rpl_logf 1516 # endif 1517 _GL_FUNCDECL_RPL (logf, float, (float x)); 1518 _GL_CXXALIAS_RPL (logf, float, (float x)); 1519 # else 1520 # if !1 1521 # undef logf 1522 _GL_FUNCDECL_SYS (logf, float, (float x)); 1523 # endif 1524 _GL_CXXALIAS_SYS (logf, float, (float x)); 1525 # endif 1526 _GL_CXXALIASWARN (logf); 1527 #elif defined GNULIB_POSIXCHECK 1528 # undef logf 1529 # if HAVE_RAW_DECL_LOGF 1530 _GL_WARN_ON_USE (logf, "logf is unportable - " 1531 "use gnulib module logf for portability"); 1532 # endif 1533 #endif 1534 1535 #if 0 1536 # if 0 1537 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1538 # undef log 1539 # define log rpl_log 1540 # endif 1541 _GL_FUNCDECL_RPL (log, double, (double x)); 1542 _GL_CXXALIAS_RPL (log, double, (double x)); 1543 # else 1544 _GL_CXXALIAS_SYS (log, double, (double x)); 1545 # endif 1546 _GL_CXXALIASWARN (log); 1547 #elif defined GNULIB_POSIXCHECK 1548 # undef log 1549 # if HAVE_RAW_DECL_LOG 1550 _GL_WARN_ON_USE (log, "log has portability problems - " 1551 "use gnulib module log for portability"); 1552 # endif 1553 #endif 1554 1555 #if 0 1556 # if 0 1557 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1558 # undef logl 1559 # define logl rpl_logl 1560 # endif 1561 _GL_FUNCDECL_RPL (logl, long double, (long double x)); 1562 _GL_CXXALIAS_RPL (logl, long double, (long double x)); 1563 # else 1564 # if !1 || !1 1565 # undef logl 1566 _GL_FUNCDECL_SYS (logl, long double, (long double x)); 1567 # endif 1568 _GL_CXXALIAS_SYS (logl, long double, (long double x)); 1569 # endif 1570 _GL_CXXALIASWARN (logl); 1571 #elif defined GNULIB_POSIXCHECK 1572 # undef logl 1573 # if HAVE_RAW_DECL_LOGL 1574 _GL_WARN_ON_USE (logl, "logl is unportable - " 1575 "use gnulib module logl for portability"); 1576 # endif 1577 #endif 1578 1579 1580 #if 0 1581 # if 0 1582 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1583 # undef log10f 1584 # define log10f rpl_log10f 1585 # endif 1586 _GL_FUNCDECL_RPL (log10f, float, (float x)); 1587 _GL_CXXALIAS_RPL (log10f, float, (float x)); 1588 # else 1589 # if !1 1590 # undef log10f 1591 _GL_FUNCDECL_SYS (log10f, float, (float x)); 1592 # endif 1593 _GL_CXXALIAS_SYS (log10f, float, (float x)); 1594 # endif 1595 _GL_CXXALIASWARN (log10f); 1596 #elif defined GNULIB_POSIXCHECK 1597 # undef log10f 1598 # if HAVE_RAW_DECL_LOG10F 1599 _GL_WARN_ON_USE (log10f, "log10f is unportable - " 1600 "use gnulib module log10f for portability"); 1601 # endif 1602 #endif 1603 1604 #if 0 1605 # if 0 1606 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1607 # undef log10 1608 # define log10 rpl_log10 1609 # endif 1610 _GL_FUNCDECL_RPL (log10, double, (double x)); 1611 _GL_CXXALIAS_RPL (log10, double, (double x)); 1612 # else 1613 _GL_CXXALIAS_SYS (log10, double, (double x)); 1614 # endif 1615 _GL_CXXALIASWARN (log10); 1616 #elif defined GNULIB_POSIXCHECK 1617 # undef log10 1618 # if HAVE_RAW_DECL_LOG10 1619 _GL_WARN_ON_USE (log10, "log10 has portability problems - " 1620 "use gnulib module log10 for portability"); 1621 # endif 1622 #endif 1623 1624 #if 0 1625 # if 0 1626 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1627 # undef log10l 1628 # define log10l rpl_log10l 1629 # endif 1630 _GL_FUNCDECL_RPL (log10l, long double, (long double x)); 1631 _GL_CXXALIAS_RPL (log10l, long double, (long double x)); 1632 # else 1633 # if !1 || !1 1634 # undef log10l 1635 _GL_FUNCDECL_SYS (log10l, long double, (long double x)); 1636 # endif 1637 _GL_CXXALIAS_SYS (log10l, long double, (long double x)); 1638 # endif 1639 _GL_CXXALIASWARN (log10l); 1640 #elif defined GNULIB_POSIXCHECK 1641 # undef log10l 1642 # if HAVE_RAW_DECL_LOG10L 1643 _GL_WARN_ON_USE (log10l, "log10l is unportable - " 1644 "use gnulib module log10l for portability"); 1645 # endif 1646 #endif 1647 1648 1649 #if 0 1650 # if 0 1651 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1652 # undef log1pf 1653 # define log1pf rpl_log1pf 1654 # endif 1655 _GL_FUNCDECL_RPL (log1pf, float, (float x)); 1656 _GL_CXXALIAS_RPL (log1pf, float, (float x)); 1657 # else 1658 # if !1 1659 _GL_FUNCDECL_SYS (log1pf, float, (float x)); 1660 # endif 1661 _GL_CXXALIAS_SYS (log1pf, float, (float x)); 1662 # endif 1663 _GL_CXXALIASWARN (log1pf); 1664 #elif defined GNULIB_POSIXCHECK 1665 # undef log1pf 1666 # if HAVE_RAW_DECL_LOG1PF 1667 _GL_WARN_ON_USE (log1pf, "log1pf is unportable - " 1668 "use gnulib module log1pf for portability"); 1669 # endif 1670 #endif 1671 1672 #if 0 1673 # if 0 1674 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1675 # undef log1p 1676 # define log1p rpl_log1p 1677 # endif 1678 _GL_FUNCDECL_RPL (log1p, double, (double x)); 1679 _GL_CXXALIAS_RPL (log1p, double, (double x)); 1680 # else 1681 # if !1 1682 _GL_FUNCDECL_SYS (log1p, double, (double x)); 1683 # endif 1684 _GL_CXXALIAS_SYS (log1p, double, (double x)); 1685 # endif 1686 _GL_CXXALIASWARN (log1p); 1687 #elif defined GNULIB_POSIXCHECK 1688 # undef log1p 1689 # if HAVE_RAW_DECL_LOG1P 1690 _GL_WARN_ON_USE (log1p, "log1p has portability problems - " 1691 "use gnulib module log1p for portability"); 1692 # endif 1693 #endif 1694 1695 #if 0 1696 # if 0 1697 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1698 # undef log1pl 1699 # define log1pl rpl_log1pl 1700 # endif 1701 _GL_FUNCDECL_RPL (log1pl, long double, (long double x)); 1702 _GL_CXXALIAS_RPL (log1pl, long double, (long double x)); 1703 # else 1704 # if !1 1705 _GL_FUNCDECL_SYS (log1pl, long double, (long double x)); 1706 # endif 1707 _GL_CXXALIAS_SYS (log1pl, long double, (long double x)); 1708 # endif 1709 _GL_CXXALIASWARN (log1pl); 1710 #elif defined GNULIB_POSIXCHECK 1711 # undef log1pl 1712 # if HAVE_RAW_DECL_LOG1PL 1713 _GL_WARN_ON_USE (log1pl, "log1pl has portability problems - " 1714 "use gnulib module log1pl for portability"); 1715 # endif 1716 #endif 1717 1718 1719 #if 0 1720 # if 0 1721 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1722 # undef log2f 1723 # define log2f rpl_log2f 1724 # endif 1725 _GL_FUNCDECL_RPL (log2f, float, (float x)); 1726 _GL_CXXALIAS_RPL (log2f, float, (float x)); 1727 # else 1728 # if !1 1729 # undef log2f 1730 _GL_FUNCDECL_SYS (log2f, float, (float x)); 1731 # endif 1732 _GL_CXXALIAS_SYS (log2f, float, (float x)); 1733 # endif 1734 _GL_CXXALIASWARN (log2f); 1735 #elif defined GNULIB_POSIXCHECK 1736 # undef log2f 1737 # if HAVE_RAW_DECL_LOG2F 1738 _GL_WARN_ON_USE (log2f, "log2f is unportable - " 1739 "use gnulib module log2f for portability"); 1740 # endif 1741 #endif 1742 1743 #if 0 1744 # if 0 1745 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1746 # undef log2 1747 # define log2 rpl_log2 1748 # endif 1749 _GL_FUNCDECL_RPL (log2, double, (double x)); 1750 _GL_CXXALIAS_RPL (log2, double, (double x)); 1751 # else 1752 # if !1 1753 # undef log2 1754 _GL_FUNCDECL_SYS (log2, double, (double x)); 1755 # endif 1756 _GL_CXXALIAS_SYS (log2, double, (double x)); 1757 # endif 1758 _GL_CXXALIASWARN (log2); 1759 #elif defined GNULIB_POSIXCHECK 1760 # undef log2 1761 # if HAVE_RAW_DECL_LOG2 1762 _GL_WARN_ON_USE (log2, "log2 is unportable - " 1763 "use gnulib module log2 for portability"); 1764 # endif 1765 #endif 1766 1767 #if 0 1768 # if 0 1769 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1770 # undef log2l 1771 # define log2l rpl_log2l 1772 # endif 1773 _GL_FUNCDECL_RPL (log2l, long double, (long double x)); 1774 _GL_CXXALIAS_RPL (log2l, long double, (long double x)); 1775 # else 1776 # if !1 1777 _GL_FUNCDECL_SYS (log2l, long double, (long double x)); 1778 # endif 1779 _GL_CXXALIAS_SYS (log2l, long double, (long double x)); 1780 # endif 1781 _GL_CXXALIASWARN (log2l); 1782 #elif defined GNULIB_POSIXCHECK 1783 # undef log2l 1784 # if HAVE_RAW_DECL_LOG2L 1785 _GL_WARN_ON_USE (log2l, "log2l is unportable - " 1786 "use gnulib module log2l for portability"); 1787 # endif 1788 #endif 1789 1790 1791 #if 0 1792 # if 0 1793 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1794 # undef logbf 1795 # define logbf rpl_logbf 1796 # endif 1797 _GL_FUNCDECL_RPL (logbf, float, (float x)); 1798 _GL_CXXALIAS_RPL (logbf, float, (float x)); 1799 # else 1800 # if !1 1801 _GL_FUNCDECL_SYS (logbf, float, (float x)); 1802 # endif 1803 _GL_CXXALIAS_SYS (logbf, float, (float x)); 1804 # endif 1805 _GL_CXXALIASWARN (logbf); 1806 #elif defined GNULIB_POSIXCHECK 1807 # undef logbf 1808 # if HAVE_RAW_DECL_LOGBF 1809 _GL_WARN_ON_USE (logbf, "logbf is unportable - " 1810 "use gnulib module logbf for portability"); 1811 # endif 1812 #endif 1813 1814 #if 0 1815 # if 0 1816 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1817 # undef logb 1818 # define logb rpl_logb 1819 # endif 1820 _GL_FUNCDECL_RPL (logb, double, (double x)); 1821 _GL_CXXALIAS_RPL (logb, double, (double x)); 1822 # else 1823 # if !1 1824 _GL_FUNCDECL_SYS (logb, double, (double x)); 1825 # endif 1826 _GL_CXXALIAS_SYS (logb, double, (double x)); 1827 # endif 1828 _GL_CXXALIASWARN (logb); 1829 #elif defined GNULIB_POSIXCHECK 1830 # undef logb 1831 # if HAVE_RAW_DECL_LOGB 1832 _GL_WARN_ON_USE (logb, "logb is unportable - " 1833 "use gnulib module logb for portability"); 1834 # endif 1835 #endif 1836 1837 #if 0 1838 # if 0 1839 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1840 # undef logbl 1841 # define logbl rpl_logbl 1842 # endif 1843 _GL_FUNCDECL_RPL (logbl, long double, (long double x)); 1844 _GL_CXXALIAS_RPL (logbl, long double, (long double x)); 1845 # else 1846 # if !1 1847 _GL_FUNCDECL_SYS (logbl, long double, (long double x)); 1848 # endif 1849 _GL_CXXALIAS_SYS (logbl, long double, (long double x)); 1850 # endif 1851 _GL_CXXALIASWARN (logbl); 1852 #elif defined GNULIB_POSIXCHECK 1853 # undef logbl 1854 # if HAVE_RAW_DECL_LOGBL 1855 _GL_WARN_ON_USE (logbl, "logbl is unportable - " 1856 "use gnulib module logbl for portability"); 1857 # endif 1858 #endif 1859 1860 1861 #if 0 1862 # if 0 1863 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1864 # undef modff 1865 # define modff rpl_modff 1866 # endif 1867 _GL_FUNCDECL_RPL (modff, float, (float x, float *iptr) _GL_ARG_NONNULL ((2))); 1868 _GL_CXXALIAS_RPL (modff, float, (float x, float *iptr)); 1869 # else 1870 # if !1 1871 # undef modff 1872 _GL_FUNCDECL_SYS (modff, float, (float x, float *iptr) _GL_ARG_NONNULL ((2))); 1873 # endif 1874 _GL_CXXALIAS_SYS (modff, float, (float x, float *iptr)); 1875 # endif 1876 _GL_CXXALIASWARN (modff); 1877 #elif defined GNULIB_POSIXCHECK 1878 # undef modff 1879 # if HAVE_RAW_DECL_MODFF 1880 _GL_WARN_ON_USE (modff, "modff is unportable - " 1881 "use gnulib module modff for portability"); 1882 # endif 1883 #endif 1884 1885 #if 0 1886 # if 0 1887 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1888 # undef modf 1889 # define modf rpl_modf 1890 # endif 1891 _GL_FUNCDECL_RPL (modf, double, (double x, double *iptr) _GL_ARG_NONNULL ((2))); 1892 _GL_CXXALIAS_RPL (modf, double, (double x, double *iptr)); 1893 # else 1894 _GL_CXXALIAS_SYS (modf, double, (double x, double *iptr)); 1895 # endif 1896 _GL_CXXALIASWARN (modf); 1897 #elif defined GNULIB_POSIXCHECK 1898 # undef modf 1899 # if HAVE_RAW_DECL_MODF 1900 _GL_WARN_ON_USE (modf, "modf has portability problems - " 1901 "use gnulib module modf for portability"); 1902 # endif 1903 #endif 1904 1905 #if 0 1906 # if 0 1907 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1908 # undef modfl 1909 # define modfl rpl_modfl 1910 # endif 1911 _GL_FUNCDECL_RPL (modfl, long double, (long double x, long double *iptr) 1912 _GL_ARG_NONNULL ((2))); 1913 _GL_CXXALIAS_RPL (modfl, long double, (long double x, long double *iptr)); 1914 # else 1915 # if !1 1916 # undef modfl 1917 _GL_FUNCDECL_SYS (modfl, long double, (long double x, long double *iptr) 1918 _GL_ARG_NONNULL ((2))); 1919 # endif 1920 _GL_CXXALIAS_SYS (modfl, long double, (long double x, long double *iptr)); 1921 # endif 1922 _GL_CXXALIASWARN (modfl); 1923 #elif defined GNULIB_POSIXCHECK 1924 # undef modfl 1925 # if HAVE_RAW_DECL_MODFL 1926 _GL_WARN_ON_USE (modfl, "modfl is unportable - " 1927 "use gnulib module modfl for portability"); 1928 # endif 1929 #endif 1930 1931 1932 #if 0 1933 # if !1 1934 # undef powf 1935 _GL_FUNCDECL_SYS (powf, float, (float x, float y)); 1936 # endif 1937 _GL_CXXALIAS_SYS (powf, float, (float x, float y)); 1938 _GL_CXXALIASWARN (powf); 1939 #elif defined GNULIB_POSIXCHECK 1940 # undef powf 1941 # if HAVE_RAW_DECL_POWF 1942 _GL_WARN_ON_USE (powf, "powf is unportable - " 1943 "use gnulib module powf for portability"); 1944 # endif 1945 #endif 1946 1947 1948 #if 0 1949 # if 0 1950 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1951 # undef remainderf 1952 # define remainderf rpl_remainderf 1953 # endif 1954 _GL_FUNCDECL_RPL (remainderf, float, (float x, float y)); 1955 _GL_CXXALIAS_RPL (remainderf, float, (float x, float y)); 1956 # else 1957 # if !1 1958 _GL_FUNCDECL_SYS (remainderf, float, (float x, float y)); 1959 # endif 1960 _GL_CXXALIAS_SYS (remainderf, float, (float x, float y)); 1961 # endif 1962 _GL_CXXALIASWARN (remainderf); 1963 #elif defined GNULIB_POSIXCHECK 1964 # undef remainderf 1965 # if HAVE_RAW_DECL_REMAINDERF 1966 _GL_WARN_ON_USE (remainderf, "remainderf is unportable - " 1967 "use gnulib module remainderf for portability"); 1968 # endif 1969 #endif 1970 1971 #if 0 1972 # if 0 1973 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1974 # undef remainder 1975 # define remainder rpl_remainder 1976 # endif 1977 _GL_FUNCDECL_RPL (remainder, double, (double x, double y)); 1978 _GL_CXXALIAS_RPL (remainder, double, (double x, double y)); 1979 # else 1980 # if !1 || !1 1981 _GL_FUNCDECL_SYS (remainder, double, (double x, double y)); 1982 # endif 1983 _GL_CXXALIAS_SYS (remainder, double, (double x, double y)); 1984 # endif 1985 _GL_CXXALIASWARN (remainder); 1986 #elif defined GNULIB_POSIXCHECK 1987 # undef remainder 1988 # if HAVE_RAW_DECL_REMAINDER 1989 _GL_WARN_ON_USE (remainder, "remainder is unportable - " 1990 "use gnulib module remainder for portability"); 1991 # endif 1992 #endif 1993 1994 #if 0 1995 # if 0 1996 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 1997 # undef remainderl 1998 # define remainderl rpl_remainderl 1999 # endif 2000 _GL_FUNCDECL_RPL (remainderl, long double, (long double x, long double y)); 2001 _GL_CXXALIAS_RPL (remainderl, long double, (long double x, long double y)); 2002 # else 2003 # if !1 2004 # undef remainderl 2005 _GL_FUNCDECL_SYS (remainderl, long double, (long double x, long double y)); 2006 # endif 2007 _GL_CXXALIAS_SYS (remainderl, long double, (long double x, long double y)); 2008 # endif 2009 _GL_CXXALIASWARN (remainderl); 2010 #elif defined GNULIB_POSIXCHECK 2011 # undef remainderl 2012 # if HAVE_RAW_DECL_REMAINDERL 2013 _GL_WARN_ON_USE (remainderl, "remainderl is unportable - " 2014 "use gnulib module remainderl for portability"); 2015 # endif 2016 #endif 2017 2018 2019 #if 0 2020 # if !1 2021 _GL_FUNCDECL_SYS (rintf, float, (float x)); 2022 # endif 2023 _GL_CXXALIAS_SYS (rintf, float, (float x)); 2024 _GL_CXXALIASWARN (rintf); 2025 #elif defined GNULIB_POSIXCHECK 2026 # undef rintf 2027 # if HAVE_RAW_DECL_RINTF 2028 _GL_WARN_ON_USE (rintf, "rintf is unportable - " 2029 "use gnulib module rintf for portability"); 2030 # endif 2031 #endif 2032 2033 #if 0 2034 # if !1 2035 _GL_FUNCDECL_SYS (rint, double, (double x)); 2036 # endif 2037 _GL_CXXALIAS_SYS (rint, double, (double x)); 2038 _GL_CXXALIASWARN (rint); 2039 #elif defined GNULIB_POSIXCHECK 2040 # undef rint 2041 # if HAVE_RAW_DECL_RINT 2042 _GL_WARN_ON_USE (rint, "rint is unportable - " 2043 "use gnulib module rint for portability"); 2044 # endif 2045 #endif 2046 2047 #if 0 2048 # if !1 2049 _GL_FUNCDECL_SYS (rintl, long double, (long double x)); 2050 # endif 2051 _GL_CXXALIAS_SYS (rintl, long double, (long double x)); 2052 _GL_CXXALIASWARN (rintl); 2053 #elif defined GNULIB_POSIXCHECK 2054 # undef rintl 2055 # if HAVE_RAW_DECL_RINTL 2056 _GL_WARN_ON_USE (rintl, "rintl is unportable - " 2057 "use gnulib module rintl for portability"); 2058 # endif 2059 #endif 2060 2061 2062 #if 0 2063 # if 0 2064 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2065 # undef roundf 2066 # define roundf rpl_roundf 2067 # endif 2068 _GL_FUNCDECL_RPL (roundf, float, (float x)); 2069 _GL_CXXALIAS_RPL (roundf, float, (float x)); 2070 # else 2071 # if !1 2072 _GL_FUNCDECL_SYS (roundf, float, (float x)); 2073 # endif 2074 _GL_CXXALIAS_SYS (roundf, float, (float x)); 2075 # endif 2076 _GL_CXXALIASWARN (roundf); 2077 #elif defined GNULIB_POSIXCHECK 2078 # undef roundf 2079 # if HAVE_RAW_DECL_ROUNDF 2080 _GL_WARN_ON_USE (roundf, "roundf is unportable - " 2081 "use gnulib module roundf for portability"); 2082 # endif 2083 #endif 2084 2085 #if 0 2086 # if 0 2087 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2088 # undef round 2089 # define round rpl_round 2090 # endif 2091 _GL_FUNCDECL_RPL (round, double, (double x)); 2092 _GL_CXXALIAS_RPL (round, double, (double x)); 2093 # else 2094 # if !1 2095 _GL_FUNCDECL_SYS (round, double, (double x)); 2096 # endif 2097 _GL_CXXALIAS_SYS (round, double, (double x)); 2098 # endif 2099 _GL_CXXALIASWARN (round); 2100 #elif defined GNULIB_POSIXCHECK 2101 # undef round 2102 # if HAVE_RAW_DECL_ROUND 2103 _GL_WARN_ON_USE (round, "round is unportable - " 2104 "use gnulib module round for portability"); 2105 # endif 2106 #endif 2107 2108 #if 0 2109 # if 0 2110 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2111 # undef roundl 2112 # define roundl rpl_roundl 2113 # endif 2114 _GL_FUNCDECL_RPL (roundl, long double, (long double x)); 2115 _GL_CXXALIAS_RPL (roundl, long double, (long double x)); 2116 # else 2117 # if !1 2118 # undef roundl 2119 _GL_FUNCDECL_SYS (roundl, long double, (long double x)); 2120 # endif 2121 _GL_CXXALIAS_SYS (roundl, long double, (long double x)); 2122 # endif 2123 _GL_CXXALIASWARN (roundl); 2124 #elif defined GNULIB_POSIXCHECK 2125 # undef roundl 2126 # if HAVE_RAW_DECL_ROUNDL 2127 _GL_WARN_ON_USE (roundl, "roundl is unportable - " 2128 "use gnulib module roundl for portability"); 2129 # endif 2130 #endif 2131 2132 2133 #if 0 2134 # if !1 2135 # undef sinf 2136 _GL_FUNCDECL_SYS (sinf, float, (float x)); 2137 # endif 2138 _GL_CXXALIAS_SYS (sinf, float, (float x)); 2139 _GL_CXXALIASWARN (sinf); 2140 #elif defined GNULIB_POSIXCHECK 2141 # undef sinf 2142 # if HAVE_RAW_DECL_SINF 2143 _GL_WARN_ON_USE (sinf, "sinf is unportable - " 2144 "use gnulib module sinf for portability"); 2145 # endif 2146 #endif 2147 2148 #if 0 2149 # if !1 || !1 2150 # undef sinl 2151 _GL_FUNCDECL_SYS (sinl, long double, (long double x)); 2152 # endif 2153 _GL_CXXALIAS_SYS (sinl, long double, (long double x)); 2154 _GL_CXXALIASWARN (sinl); 2155 #elif defined GNULIB_POSIXCHECK 2156 # undef sinl 2157 # if HAVE_RAW_DECL_SINL 2158 _GL_WARN_ON_USE (sinl, "sinl is unportable - " 2159 "use gnulib module sinl for portability"); 2160 # endif 2161 #endif 2162 2163 2164 #if 0 2165 # if !1 2166 # undef sinhf 2167 _GL_FUNCDECL_SYS (sinhf, float, (float x)); 2168 # endif 2169 _GL_CXXALIAS_SYS (sinhf, float, (float x)); 2170 _GL_CXXALIASWARN (sinhf); 2171 #elif defined GNULIB_POSIXCHECK 2172 # undef sinhf 2173 # if HAVE_RAW_DECL_SINHF 2174 _GL_WARN_ON_USE (sinhf, "sinhf is unportable - " 2175 "use gnulib module sinhf for portability"); 2176 # endif 2177 #endif 2178 2179 2180 #if 0 2181 # if !1 2182 # undef sqrtf 2183 _GL_FUNCDECL_SYS (sqrtf, float, (float x)); 2184 # endif 2185 _GL_CXXALIAS_SYS (sqrtf, float, (float x)); 2186 _GL_CXXALIASWARN (sqrtf); 2187 #elif defined GNULIB_POSIXCHECK 2188 # undef sqrtf 2189 # if HAVE_RAW_DECL_SQRTF 2190 _GL_WARN_ON_USE (sqrtf, "sqrtf is unportable - " 2191 "use gnulib module sqrtf for portability"); 2192 # endif 2193 #endif 2194 2195 #if 0 2196 # if 0 2197 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2198 # undef sqrtl 2199 # define sqrtl rpl_sqrtl 2200 # endif 2201 _GL_FUNCDECL_RPL (sqrtl, long double, (long double x)); 2202 _GL_CXXALIAS_RPL (sqrtl, long double, (long double x)); 2203 # else 2204 # if !1 || !1 2205 # undef sqrtl 2206 _GL_FUNCDECL_SYS (sqrtl, long double, (long double x)); 2207 # endif 2208 _GL_CXXALIAS_SYS (sqrtl, long double, (long double x)); 2209 # endif 2210 _GL_CXXALIASWARN (sqrtl); 2211 #elif defined GNULIB_POSIXCHECK 2212 # undef sqrtl 2213 # if HAVE_RAW_DECL_SQRTL 2214 _GL_WARN_ON_USE (sqrtl, "sqrtl is unportable - " 2215 "use gnulib module sqrtl for portability"); 2216 # endif 2217 #endif 2218 2219 2220 #if 0 2221 # if !1 2222 # undef tanf 2223 _GL_FUNCDECL_SYS (tanf, float, (float x)); 2224 # endif 2225 _GL_CXXALIAS_SYS (tanf, float, (float x)); 2226 _GL_CXXALIASWARN (tanf); 2227 #elif defined GNULIB_POSIXCHECK 2228 # undef tanf 2229 # if HAVE_RAW_DECL_TANF 2230 _GL_WARN_ON_USE (tanf, "tanf is unportable - " 2231 "use gnulib module tanf for portability"); 2232 # endif 2233 #endif 2234 2235 #if 0 2236 # if !1 || !1 2237 # undef tanl 2238 _GL_FUNCDECL_SYS (tanl, long double, (long double x)); 2239 # endif 2240 _GL_CXXALIAS_SYS (tanl, long double, (long double x)); 2241 _GL_CXXALIASWARN (tanl); 2242 #elif defined GNULIB_POSIXCHECK 2243 # undef tanl 2244 # if HAVE_RAW_DECL_TANL 2245 _GL_WARN_ON_USE (tanl, "tanl is unportable - " 2246 "use gnulib module tanl for portability"); 2247 # endif 2248 #endif 2249 2250 2251 #if 0 2252 # if !1 2253 # undef tanhf 2254 _GL_FUNCDECL_SYS (tanhf, float, (float x)); 2255 # endif 2256 _GL_CXXALIAS_SYS (tanhf, float, (float x)); 2257 _GL_CXXALIASWARN (tanhf); 2258 #elif defined GNULIB_POSIXCHECK 2259 # undef tanhf 2260 # if HAVE_RAW_DECL_TANHF 2261 _GL_WARN_ON_USE (tanhf, "tanhf is unportable - " 2262 "use gnulib module tanhf for portability"); 2263 # endif 2264 #endif 2265 2266 2267 #if 0 2268 # if 0 2269 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2270 # define truncf rpl_truncf 2271 # endif 2272 _GL_FUNCDECL_RPL (truncf, float, (float x)); 2273 _GL_CXXALIAS_RPL (truncf, float, (float x)); 2274 # else 2275 # if !1 2276 _GL_FUNCDECL_SYS (truncf, float, (float x)); 2277 # endif 2278 _GL_CXXALIAS_SYS (truncf, float, (float x)); 2279 # endif 2280 _GL_CXXALIASWARN (truncf); 2281 #elif defined GNULIB_POSIXCHECK 2282 # undef truncf 2283 # if HAVE_RAW_DECL_TRUNCF 2284 _GL_WARN_ON_USE (truncf, "truncf is unportable - " 2285 "use gnulib module truncf for portability"); 2286 # endif 2287 #endif 2288 2289 #if 0 2290 # if 0 2291 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2292 # define trunc rpl_trunc 2293 # endif 2294 _GL_FUNCDECL_RPL (trunc, double, (double x)); 2295 _GL_CXXALIAS_RPL (trunc, double, (double x)); 2296 # else 2297 # if !1 2298 _GL_FUNCDECL_SYS (trunc, double, (double x)); 2299 # endif 2300 _GL_CXXALIAS_SYS (trunc, double, (double x)); 2301 # endif 2302 _GL_CXXALIASWARN (trunc); 2303 #elif defined GNULIB_POSIXCHECK 2304 # undef trunc 2305 # if HAVE_RAW_DECL_TRUNC 2306 _GL_WARN_ON_USE (trunc, "trunc is unportable - " 2307 "use gnulib module trunc for portability"); 2308 # endif 2309 #endif 2310 2311 #if 0 2312 # if 0 2313 # if !(defined __cplusplus && defined GNULIB_NAMESPACE) 2314 # undef truncl 2315 # define truncl rpl_truncl 2316 # endif 2317 _GL_FUNCDECL_RPL (truncl, long double, (long double x)); 2318 _GL_CXXALIAS_RPL (truncl, long double, (long double x)); 2319 # else 2320 # if !1 2321 _GL_FUNCDECL_SYS (truncl, long double, (long double x)); 2322 # endif 2323 _GL_CXXALIAS_SYS (truncl, long double, (long double x)); 2324 # endif 2325 _GL_CXXALIASWARN (truncl); 2326 #elif defined GNULIB_POSIXCHECK 2327 # undef truncl 2328 # if HAVE_RAW_DECL_TRUNCL 2329 _GL_WARN_ON_USE (truncl, "truncl is unportable - " 2330 "use gnulib module truncl for portability"); 2331 # endif 2332 #endif 2333 2334 2335 /* Definitions of function-like macros come here, after the function 2336 declarations. */ 2337 2338 2339 #if 0 2340 # if 0 2341 _GL_EXTERN_C int gl_isfinitef (float x); 2342 _GL_EXTERN_C int gl_isfinited (double x); 2343 _GL_EXTERN_C int gl_isfinitel (long double x); 2344 # undef isfinite 2345 # define isfinite(x) \ 2346 (sizeof (x) == sizeof (long double) ? gl_isfinitel (x) : \ 2347 sizeof (x) == sizeof (double) ? gl_isfinited (x) : \ 2348 gl_isfinitef (x)) 2349 # endif 2350 # ifdef __cplusplus 2351 # ifdef isfinite 2352 _GL_MATH_CXX_REAL_FLOATING_DECL_1 (isfinite) 2353 # undef isfinite 2354 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (isfinite) 2355 # endif 2356 # endif 2357 #elif defined GNULIB_POSIXCHECK 2358 # if defined isfinite 2359 _GL_WARN_REAL_FLOATING_DECL (isfinite); 2360 # undef isfinite 2361 # define isfinite(x) _GL_WARN_REAL_FLOATING_IMPL (isfinite, x) 2362 # endif 2363 #endif 2364 2365 2366 #if 0 2367 # if 0 2368 _GL_EXTERN_C int gl_isinff (float x); 2369 _GL_EXTERN_C int gl_isinfd (double x); 2370 _GL_EXTERN_C int gl_isinfl (long double x); 2371 # undef isinf 2372 # define isinf(x) \ 2373 (sizeof (x) == sizeof (long double) ? gl_isinfl (x) : \ 2374 sizeof (x) == sizeof (double) ? gl_isinfd (x) : \ 2375 gl_isinff (x)) 2376 # endif 2377 # ifdef __cplusplus 2378 # ifdef isinf 2379 _GL_MATH_CXX_REAL_FLOATING_DECL_1 (isinf) 2380 # undef isinf 2381 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (isinf) 2382 # endif 2383 # endif 2384 #elif defined GNULIB_POSIXCHECK 2385 # if defined isinf 2386 _GL_WARN_REAL_FLOATING_DECL (isinf); 2387 # undef isinf 2388 # define isinf(x) _GL_WARN_REAL_FLOATING_IMPL (isinf, x) 2389 # endif 2390 #endif 2391 2392 2393 #if 1 2394 /* Test for NaN for 'float' numbers. */ 2395 # if 1 2396 /* The original <math.h> included above provides a declaration of isnan macro 2397 or (older) isnanf function. */ 2398 # if __GNUC__ >= 4 2399 /* GCC 4.0 and newer provides three built-ins for isnan. */ 2400 # undef isnanf 2401 # define isnanf(x) __builtin_isnanf ((float)(x)) 2402 # elif defined isnan 2403 # undef isnanf 2404 # define isnanf(x) isnan ((float)(x)) 2405 # endif 2406 # else 2407 /* Test whether X is a NaN. */ 2408 # undef isnanf 2409 # define isnanf rpl_isnanf 2410 _GL_EXTERN_C int isnanf (float x); 2411 # endif 2412 #endif 2413 2414 #if 1 2415 /* Test for NaN for 'double' numbers. 2416 This function is a gnulib extension, unlike isnan() which applied only 2417 to 'double' numbers earlier but now is a type-generic macro. */ 2418 # if 1 2419 /* The original <math.h> included above provides a declaration of isnan 2420 macro. */ 2421 # if __GNUC__ >= 4 2422 /* GCC 4.0 and newer provides three built-ins for isnan. */ 2423 # undef isnand 2424 # define isnand(x) __builtin_isnan ((double)(x)) 2425 # else 2426 # undef isnand 2427 # define isnand(x) isnan ((double)(x)) 2428 # endif 2429 # else 2430 /* Test whether X is a NaN. */ 2431 # undef isnand 2432 # define isnand rpl_isnand 2433 _GL_EXTERN_C int isnand (double x); 2434 # endif 2435 #endif 2436 2437 #if 1 2438 /* Test for NaN for 'long double' numbers. */ 2439 # if 0 2440 /* The original <math.h> included above provides a declaration of isnan 2441 macro or (older) isnanl function. */ 2442 # if __GNUC__ >= 4 2443 /* GCC 4.0 and newer provides three built-ins for isnan. */ 2444 # undef isnanl 2445 # define isnanl(x) __builtin_isnanl ((long double)(x)) 2446 # elif defined isnan 2447 # undef isnanl 2448 # define isnanl(x) isnan ((long double)(x)) 2449 # endif 2450 # else 2451 /* Test whether X is a NaN. */ 2452 # undef isnanl 2453 # define isnanl rpl_isnanl 2454 _GL_EXTERN_C int isnanl (long double x) _GL_ATTRIBUTE_CONST; 2455 # endif 2456 #endif 2457 2458 /* This must come *after* the snippets for GNULIB_ISNANF and GNULIB_ISNANL! */ 2459 #if 1 2460 # if 1 2461 /* We can't just use the isnanf macro (e.g.) as exposed by 2462 isnanf.h (e.g.) here, because those may end up being macros 2463 that recursively expand back to isnan. So use the gnulib 2464 replacements for them directly. */ 2465 # if 1 && __GNUC__ >= 4 2466 # define gl_isnan_f(x) __builtin_isnanf ((float)(x)) 2467 # else 2468 _GL_EXTERN_C int rpl_isnanf (float x); 2469 # define gl_isnan_f(x) rpl_isnanf (x) 2470 # endif 2471 # if 1 && __GNUC__ >= 4 2472 # define gl_isnan_d(x) __builtin_isnan ((double)(x)) 2473 # else 2474 _GL_EXTERN_C int rpl_isnand (double x); 2475 # define gl_isnan_d(x) rpl_isnand (x) 2476 # endif 2477 # if 0 && __GNUC__ >= 4 2478 # define gl_isnan_l(x) __builtin_isnanl ((long double)(x)) 2479 # else 2480 _GL_EXTERN_C int rpl_isnanl (long double x) _GL_ATTRIBUTE_CONST; 2481 # define gl_isnan_l(x) rpl_isnanl (x) 2482 # endif 2483 # undef isnan 2484 # define isnan(x) \ 2485 (sizeof (x) == sizeof (long double) ? gl_isnan_l (x) : \ 2486 sizeof (x) == sizeof (double) ? gl_isnan_d (x) : \ 2487 gl_isnan_f (x)) 2488 # elif __GNUC__ >= 4 2489 # undef isnan 2490 # define isnan(x) \ 2491 (sizeof (x) == sizeof (long double) ? __builtin_isnanl ((long double)(x)) : \ 2492 sizeof (x) == sizeof (double) ? __builtin_isnan ((double)(x)) : \ 2493 __builtin_isnanf ((float)(x))) 2494 # endif 2495 # ifdef __cplusplus 2496 # ifdef isnan 2497 _GL_MATH_CXX_REAL_FLOATING_DECL_1 (isnan) 2498 # undef isnan 2499 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (isnan) 2500 # endif 2501 # else 2502 /* Ensure isnan is a macro. */ 2503 # ifndef isnan 2504 # define isnan isnan 2505 # endif 2506 # endif 2507 #elif defined GNULIB_POSIXCHECK 2508 # if defined isnan 2509 _GL_WARN_REAL_FLOATING_DECL (isnan); 2510 # undef isnan 2511 # define isnan(x) _GL_WARN_REAL_FLOATING_IMPL (isnan, x) 2512 # endif 2513 #endif 2514 2515 2516 #if 1 2517 # if 1 2518 # undef signbit 2519 /* GCC 4.0 and newer provides three built-ins for signbit. */ 2520 # define signbit(x) \ 2521 (sizeof (x) == sizeof (long double) ? __builtin_signbitl (x) : \ 2522 sizeof (x) == sizeof (double) ? __builtin_signbit (x) : \ 2523 __builtin_signbitf (x)) 2524 # endif 2525 # if 0 2526 # undef signbit 2527 _GL_EXTERN_C int gl_signbitf (float arg); 2528 _GL_EXTERN_C int gl_signbitd (double arg); 2529 _GL_EXTERN_C int gl_signbitl (long double arg); 2530 # if __GNUC__ >= 2 && !defined __STRICT_ANSI__ 2531 # define _GL_NUM_UINT_WORDS(type) \ 2532 ((sizeof (type) + sizeof (unsigned int) - 1) / sizeof (unsigned int)) 2533 # if defined FLT_SIGNBIT_WORD && defined FLT_SIGNBIT_BIT && !defined gl_signbitf 2534 # define gl_signbitf_OPTIMIZED_MACRO 2535 # define gl_signbitf(arg) \ 2536 ({ union { float _value; \ 2537 unsigned int _word[_GL_NUM_UINT_WORDS (float)]; \ 2538 } _m; \ 2539 _m._value = (arg); \ 2540 (_m._word[FLT_SIGNBIT_WORD] >> FLT_SIGNBIT_BIT) & 1; \ 2541 }) 2542 # endif 2543 # if defined DBL_SIGNBIT_WORD && defined DBL_SIGNBIT_BIT && !defined gl_signbitd 2544 # define gl_signbitd_OPTIMIZED_MACRO 2545 # define gl_signbitd(arg) \ 2546 ({ union { double _value; \ 2547 unsigned int _word[_GL_NUM_UINT_WORDS (double)]; \ 2548 } _m; \ 2549 _m._value = (arg); \ 2550 (_m._word[DBL_SIGNBIT_WORD] >> DBL_SIGNBIT_BIT) & 1; \ 2551 }) 2552 # endif 2553 # if defined LDBL_SIGNBIT_WORD && defined LDBL_SIGNBIT_BIT && !defined gl_signbitl 2554 # define gl_signbitl_OPTIMIZED_MACRO 2555 # define gl_signbitl(arg) \ 2556 ({ union { long double _value; \ 2557 unsigned int _word[_GL_NUM_UINT_WORDS (long double)]; \ 2558 } _m; \ 2559 _m._value = (arg); \ 2560 (_m._word[LDBL_SIGNBIT_WORD] >> LDBL_SIGNBIT_BIT) & 1; \ 2561 }) 2562 # endif 2563 # endif 2564 # define signbit(x) \ 2565 (sizeof (x) == sizeof (long double) ? gl_signbitl (x) : \ 2566 sizeof (x) == sizeof (double) ? gl_signbitd (x) : \ 2567 gl_signbitf (x)) 2568 # endif 2569 # ifdef __cplusplus 2570 # ifdef signbit 2571 _GL_MATH_CXX_REAL_FLOATING_DECL_1 (signbit) 2572 # undef signbit 2573 _GL_MATH_CXX_REAL_FLOATING_DECL_2 (signbit) 2574 # endif 2575 # endif 2576 #elif defined GNULIB_POSIXCHECK 2577 # if defined signbit 2578 _GL_WARN_REAL_FLOATING_DECL (signbit); 2579 # undef signbit 2580 # define signbit(x) _GL_WARN_REAL_FLOATING_IMPL (signbit, x) 2581 # endif 2582 #endif 2583 2584 _GL_INLINE_HEADER_END 2585 2586 #endif /* _GL_MATH_H */ 2587 #endif /* _GL_MATH_H */ 2588
