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