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