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