← Back to branch summary

~ubuntu-branches/ubuntu/trusty/nagios-plugins/trusty-proposed

« back to all changes in this revision

Viewing changes to gl/math.in.h

  • Committer: Package Import Robot
  • Author(s): Yolanda Robla
  • Date: 2013-12-11 10:09:01 UTC
  • mfrom: (12.2.22 sid)
  • Revision ID: package-import@ubuntu.com-20131211100901-g0kqwx300l24be53
Tags: 1.5-1ubuntu1
https://launchpad.net/bugs/1259863
* Merge from Debian unstable (LP: #1259863).  Remaining changes:
  - debian/control, debian/rules, debian/nagios-plugins-extra.dirs
     + add package nagios-plugins-extra
     + Suggest nagios-plugins-contrib in the universe package (-extras).
  - debian/control
     - replaces on nagios-plugins-basic (<< 1.4.16-1ubuntu1)
     - conflicts and replaces on nagios-plugins-extra

Show diffs side-by-side

added added

removed removed

Lines of Context:
gl/math.in.h
1
1
/* A GNU-like <math.h>.
2
2
 
3
 
   Copyright (C) 2002-2003, 2007-2010 Free Software Foundation, Inc.
 
3
   Copyright (C) 2002-2003, 2007-2013 Free Software Foundation, Inc.
4
4
 
5
5
   This program is free software: you can redistribute it and/or modify
6
6
   it under the terms of the GNU General Public License as published by
15
15
   You should have received a copy of the GNU General Public License
16
16
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
17
17
 
18
 
#ifndef _GL_MATH_H
 
18
#ifndef _@GUARD_PREFIX@_MATH_H
19
19
 
20
20
#if __GNUC__ >= 3
21
21
@PRAGMA_SYSTEM_HEADER@
22
22
#endif
 
23
@PRAGMA_COLUMNS@
23
24
 
24
25
/* The include_next requires a split double-inclusion guard.  */
25
26
#@INCLUDE_NEXT_AS_FIRST_DIRECTIVE@ @NEXT_AS_FIRST_DIRECTIVE_MATH_H@
26
27
 
27
 
#ifndef _GL_MATH_H
28
 
#define _GL_MATH_H
 
28
#ifndef _@GUARD_PREFIX@_MATH_H
 
29
#define _@GUARD_PREFIX@_MATH_H
29
30
 
 
31
_GL_INLINE_HEADER_BEGIN
 
32
#ifndef _GL_MATH_INLINE
 
33
# define _GL_MATH_INLINE _GL_INLINE
 
34
#endif
30
35
 
31
36
/* The definitions of _GL_FUNCDECL_RPL etc. are copied here.  */
32
37
 
34
39
 
35
40
/* The definition of _GL_WARN_ON_USE is copied here.  */
36
41
 
 
42
#ifdef __cplusplus
 
43
/* Helper macros to define type-generic function FUNC as overloaded functions,
 
44
   rather than as macros like in C.  POSIX declares these with an argument of
 
45
   real-floating (that is, one of float, double, or long double).  */
 
46
# define _GL_MATH_CXX_REAL_FLOATING_DECL_1(func) \
 
47
static inline int                                                   \
 
48
_gl_cxx_ ## func ## f (float f)                                     \
 
49
{                                                                   \
 
50
  return func (f);                                                  \
 
51
}                                                                   \
 
52
static inline int                                                   \
 
53
_gl_cxx_ ## func ## d (double d)                                    \
 
54
{                                                                   \
 
55
  return func (d);                                                  \
 
56
}                                                                   \
 
57
static inline int                                                   \
 
58
_gl_cxx_ ## func ## l (long double l)                               \
 
59
{                                                                   \
 
60
  return func (l);                                                  \
 
61
}
 
62
# define _GL_MATH_CXX_REAL_FLOATING_DECL_2(func) \
 
63
inline int                                                          \
 
64
func (float f)                                                      \
 
65
{                                                                   \
 
66
  return _gl_cxx_ ## func ## f (f);                                 \
 
67
}                                                                   \
 
68
inline int                                                          \
 
69
func (double d)                                                     \
 
70
{                                                                   \
 
71
  return _gl_cxx_ ## func ## d (d);                                 \
 
72
}                                                                   \
 
73
inline int                                                          \
 
74
func (long double l)                                                \
 
75
{                                                                   \
 
76
  return _gl_cxx_ ## func ## l (l);                                 \
 
77
}
 
78
#endif
 
79
 
37
80
/* Helper macros to define a portability warning for the
38
81
   classification macro FUNC called with VALUE.  POSIX declares the
39
82
   classification macros with an argument of real-floating (that is,
40
83
   one of float, double, or long double).  */
41
84
#define _GL_WARN_REAL_FLOATING_DECL(func) \
42
 
static inline int                                                   \
 
85
_GL_MATH_INLINE int                                                 \
43
86
rpl_ ## func ## f (float f)                                         \
44
87
{                                                                   \
45
88
  return func (f);                                                  \
46
89
}                                                                   \
47
 
static inline int                                                   \
 
90
_GL_MATH_INLINE int                                                 \
48
91
rpl_ ## func ## d (double d)                                        \
49
92
{                                                                   \
50
93
  return func (d);                                                  \
51
94
}                                                                   \
52
 
static inline int                                                   \
 
95
_GL_MATH_INLINE int                                                 \
53
96
rpl_ ## func ## l (long double l)                                   \
54
97
{                                                                   \
55
98
  return func (l);                                                  \
66
109
   : rpl_ ## func ## l (value))
67
110
 
68
111
 
 
112
#if @REPLACE_ITOLD@
 
113
/* Pull in a function that fixes the 'int' to 'long double' conversion
 
114
   of glibc 2.7.  */
 
115
_GL_EXTERN_C void _Qp_itoq (long double *, int);
 
116
static void (*_gl_math_fix_itold) (long double *, int) = _Qp_itoq;
 
117
#endif
 
118
 
 
119
 
69
120
/* POSIX allows platforms that don't support NAN.  But all major
70
121
   machines in the past 15 years have supported something close to
71
122
   IEEE NaN, so we define this unconditionally.  We also must define
72
123
   it on platforms like Solaris 10, where NAN is present but defined
73
124
   as a function pointer rather than a floating point constant.  */
74
125
#if !defined NAN || @REPLACE_NAN@
75
 
# undef NAN
76
 
  /* The Compaq (ex-DEC) C 6.4 compiler chokes on the expression 0.0 / 0.0.  */
77
 
# ifdef __DECC
78
 
static float
 
126
# if !GNULIB_defined_NAN
 
127
#  undef NAN
 
128
  /* The Compaq (ex-DEC) C 6.4 compiler and the Microsoft MSVC 9 compiler
 
129
     choke on the expression 0.0 / 0.0.  */
 
130
#  if defined __DECC || defined _MSC_VER
 
131
_GL_MATH_INLINE float
79
132
_NaN ()
80
133
{
81
134
  static float zero = 0.0f;
82
135
  return zero / zero;
83
136
}
84
 
#  define NAN (_NaN())
85
 
# else
86
 
#  define NAN (0.0f / 0.0f)
 
137
#   define NAN (_NaN())
 
138
#  else
 
139
#   define NAN (0.0f / 0.0f)
 
140
#  endif
 
141
#  define GNULIB_defined_NAN 1
87
142
# endif
88
143
#endif
89
144
 
90
145
/* Solaris 10 defines HUGE_VAL, but as a function pointer rather
91
146
   than a floating point constant.  */
92
147
#if @REPLACE_HUGE_VAL@
 
148
# undef HUGE_VALF
 
149
# define HUGE_VALF (1.0f / 0.0f)
93
150
# undef HUGE_VAL
94
151
# define HUGE_VAL (1.0 / 0.0)
95
 
#endif
96
 
 
97
 
 
98
 
/* Write x as
99
 
     x = mantissa * 2^exp
100
 
   where
101
 
     If x finite and nonzero: 0.5 <= |mantissa| < 1.0.
102
 
     If x is zero: mantissa = x, exp = 0.
103
 
     If x is infinite or NaN: mantissa = x, exp unspecified.
104
 
   Store exp in *EXPPTR and return mantissa.  */
105
 
#if @GNULIB_FREXP@
106
 
# if @REPLACE_FREXP@
107
 
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
108
 
#   define frexp rpl_frexp
109
 
#  endif
110
 
_GL_FUNCDECL_RPL (frexp, double, (double x, int *expptr) _GL_ARG_NONNULL ((2)));
111
 
_GL_CXXALIAS_RPL (frexp, double, (double x, int *expptr));
112
 
# else
113
 
_GL_CXXALIAS_SYS (frexp, double, (double x, int *expptr));
114
 
# endif
115
 
_GL_CXXALIASWARN (frexp);
116
 
#elif defined GNULIB_POSIXCHECK
117
 
# undef frexp
118
 
/* Assume frexp is always declared.  */
119
 
_GL_WARN_ON_USE (frexp, "frexp is unportable - "
120
 
                 "use gnulib module frexp for portability");
121
 
#endif
122
 
 
123
 
 
124
 
#if @GNULIB_LOGB@
125
 
# if !@HAVE_DECL_LOGB@
126
 
_GL_EXTERN_C double logb (double x);
127
 
# endif
128
 
#elif defined GNULIB_POSIXCHECK
129
 
# undef logb
130
 
# if HAVE_RAW_DECL_LOGB
131
 
_GL_WARN_ON_USE (logb, "logb is unportable - "
132
 
                 "use gnulib module logb for portability");
133
 
# endif
134
 
#endif
135
 
 
 
152
# undef HUGE_VALL
 
153
# define HUGE_VALL (1.0L / 0.0L)
 
154
#endif
 
155
 
 
156
/* HUGE_VALF is a 'float' Infinity.  */
 
157
#ifndef HUGE_VALF
 
158
# if defined _MSC_VER
 
159
/* The Microsoft MSVC 9 compiler chokes on the expression 1.0f / 0.0f.  */
 
160
#  define HUGE_VALF (1e25f * 1e25f)
 
161
# else
 
162
#  define HUGE_VALF (1.0f / 0.0f)
 
163
# endif
 
164
#endif
 
165
 
 
166
/* HUGE_VAL is a 'double' Infinity.  */
 
167
#ifndef HUGE_VAL
 
168
# if defined _MSC_VER
 
169
/* The Microsoft MSVC 9 compiler chokes on the expression 1.0 / 0.0.  */
 
170
#  define HUGE_VAL (1e250 * 1e250)
 
171
# else
 
172
#  define HUGE_VAL (1.0 / 0.0)
 
173
# endif
 
174
#endif
 
175
 
 
176
/* HUGE_VALL is a 'long double' Infinity.  */
 
177
#ifndef HUGE_VALL
 
178
# if defined _MSC_VER
 
179
/* The Microsoft MSVC 9 compiler chokes on the expression 1.0L / 0.0L.  */
 
180
#  define HUGE_VALL (1e250L * 1e250L)
 
181
# else
 
182
#  define HUGE_VALL (1.0L / 0.0L)
 
183
# endif
 
184
#endif
 
185
 
 
186
 
 
187
/* Ensure FP_ILOGB0 and FP_ILOGBNAN are defined.  */
 
188
#if !(defined FP_ILOGB0 && defined FP_ILOGBNAN)
 
189
# if defined __NetBSD__ || defined __sgi
 
190
  /* NetBSD, IRIX 6.5: match what ilogb() does */
 
191
#  define FP_ILOGB0   (- 2147483647 - 1) /* INT_MIN */
 
192
#  define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */
 
193
# elif defined _AIX
 
194
  /* AIX 5.1: match what ilogb() does in AIX >= 5.2 */
 
195
#  define FP_ILOGB0   (- 2147483647 - 1) /* INT_MIN */
 
196
#  define FP_ILOGBNAN 2147483647 /* INT_MAX */
 
197
# elif defined __sun
 
198
  /* Solaris 9: match what ilogb() does */
 
199
#  define FP_ILOGB0   (- 2147483647) /* - INT_MAX */
 
200
#  define FP_ILOGBNAN 2147483647 /* INT_MAX */
 
201
# else
 
202
  /* Gnulib defined values.  */
 
203
#  define FP_ILOGB0   (- 2147483647) /* - INT_MAX */
 
204
#  define FP_ILOGBNAN (- 2147483647 - 1) /* INT_MIN */
 
205
# endif
 
206
#endif
 
207
 
 
208
 
 
209
#if @GNULIB_ACOSF@
 
210
# if !@HAVE_ACOSF@
 
211
#  undef acosf
 
212
_GL_FUNCDECL_SYS (acosf, float, (float x));
 
213
# endif
 
214
_GL_CXXALIAS_SYS (acosf, float, (float x));
 
215
_GL_CXXALIASWARN (acosf);
 
216
#elif defined GNULIB_POSIXCHECK
 
217
# undef acosf
 
218
# if HAVE_RAW_DECL_ACOSF
 
219
_GL_WARN_ON_USE (acosf, "acosf is unportable - "
 
220
                 "use gnulib module acosf for portability");
 
221
# endif
 
222
#endif
136
223
 
137
224
#if @GNULIB_ACOSL@
138
225
# if !@HAVE_ACOSL@ || !@HAVE_DECL_ACOSL@
 
226
#  undef acosl
139
227
_GL_FUNCDECL_SYS (acosl, long double, (long double x));
140
228
# endif
141
229
_GL_CXXALIAS_SYS (acosl, long double, (long double x));
144
232
# undef acosl
145
233
# if HAVE_RAW_DECL_ACOSL
146
234
_GL_WARN_ON_USE (acosl, "acosl is unportable - "
147
 
                 "use gnulib module mathl for portability");
148
 
# endif
149
 
#endif
150
 
 
 
235
                 "use gnulib module acosl for portability");
 
236
# endif
 
237
#endif
 
238
 
 
239
 
 
240
#if @GNULIB_ASINF@
 
241
# if !@HAVE_ASINF@
 
242
#  undef asinf
 
243
_GL_FUNCDECL_SYS (asinf, float, (float x));
 
244
# endif
 
245
_GL_CXXALIAS_SYS (asinf, float, (float x));
 
246
_GL_CXXALIASWARN (asinf);
 
247
#elif defined GNULIB_POSIXCHECK
 
248
# undef asinf
 
249
# if HAVE_RAW_DECL_ASINF
 
250
_GL_WARN_ON_USE (asinf, "asinf is unportable - "
 
251
                 "use gnulib module asinf for portability");
 
252
# endif
 
253
#endif
151
254
 
152
255
#if @GNULIB_ASINL@
153
256
# if !@HAVE_ASINL@ || !@HAVE_DECL_ASINL@
 
257
#  undef asinl
154
258
_GL_FUNCDECL_SYS (asinl, long double, (long double x));
155
259
# endif
156
260
_GL_CXXALIAS_SYS (asinl, long double, (long double x));
159
263
# undef asinl
160
264
# if HAVE_RAW_DECL_ASINL
161
265
_GL_WARN_ON_USE (asinl, "asinl is unportable - "
162
 
                 "use gnulib module mathl for portability");
163
 
# endif
164
 
#endif
165
 
 
 
266
                 "use gnulib module asinl for portability");
 
267
# endif
 
268
#endif
 
269
 
 
270
 
 
271
#if @GNULIB_ATANF@
 
272
# if !@HAVE_ATANF@
 
273
#  undef atanf
 
274
_GL_FUNCDECL_SYS (atanf, float, (float x));
 
275
# endif
 
276
_GL_CXXALIAS_SYS (atanf, float, (float x));
 
277
_GL_CXXALIASWARN (atanf);
 
278
#elif defined GNULIB_POSIXCHECK
 
279
# undef atanf
 
280
# if HAVE_RAW_DECL_ATANF
 
281
_GL_WARN_ON_USE (atanf, "atanf is unportable - "
 
282
                 "use gnulib module atanf for portability");
 
283
# endif
 
284
#endif
166
285
 
167
286
#if @GNULIB_ATANL@
168
287
# if !@HAVE_ATANL@ || !@HAVE_DECL_ATANL@
 
288
#  undef atanl
169
289
_GL_FUNCDECL_SYS (atanl, long double, (long double x));
170
290
# endif
171
291
_GL_CXXALIAS_SYS (atanl, long double, (long double x));
174
294
# undef atanl
175
295
# if HAVE_RAW_DECL_ATANL
176
296
_GL_WARN_ON_USE (atanl, "atanl is unportable - "
177
 
                 "use gnulib module mathl for portability");
 
297
                 "use gnulib module atanl for portability");
 
298
# endif
 
299
#endif
 
300
 
 
301
 
 
302
#if @GNULIB_ATAN2F@
 
303
# if !@HAVE_ATAN2F@
 
304
#  undef atan2f
 
305
_GL_FUNCDECL_SYS (atan2f, float, (float y, float x));
 
306
# endif
 
307
_GL_CXXALIAS_SYS (atan2f, float, (float y, float x));
 
308
_GL_CXXALIASWARN (atan2f);
 
309
#elif defined GNULIB_POSIXCHECK
 
310
# undef atan2f
 
311
# if HAVE_RAW_DECL_ATAN2F
 
312
_GL_WARN_ON_USE (atan2f, "atan2f is unportable - "
 
313
                 "use gnulib module atan2f for portability");
 
314
# endif
 
315
#endif
 
316
 
 
317
 
 
318
#if @GNULIB_CBRTF@
 
319
# if @REPLACE_CBRTF@
 
320
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
321
#   undef cbrtf
 
322
#   define cbrtf rpl_cbrtf
 
323
#  endif
 
324
_GL_FUNCDECL_RPL (cbrtf, float, (float x));
 
325
_GL_CXXALIAS_RPL (cbrtf, float, (float x));
 
326
# else
 
327
#  if !@HAVE_DECL_CBRTF@
 
328
_GL_FUNCDECL_SYS (cbrtf, float, (float x));
 
329
#  endif
 
330
_GL_CXXALIAS_SYS (cbrtf, float, (float x));
 
331
# endif
 
332
_GL_CXXALIASWARN (cbrtf);
 
333
#elif defined GNULIB_POSIXCHECK
 
334
# undef cbrtf
 
335
# if HAVE_RAW_DECL_CBRTF
 
336
_GL_WARN_ON_USE (cbrtf, "cbrtf is unportable - "
 
337
                 "use gnulib module cbrtf for portability");
 
338
# endif
 
339
#endif
 
340
 
 
341
#if @GNULIB_CBRT@
 
342
# if !@HAVE_CBRT@
 
343
_GL_FUNCDECL_SYS (cbrt, double, (double x));
 
344
# endif
 
345
_GL_CXXALIAS_SYS (cbrt, double, (double x));
 
346
_GL_CXXALIASWARN (cbrt);
 
347
#elif defined GNULIB_POSIXCHECK
 
348
# undef cbrt
 
349
# if HAVE_RAW_DECL_CBRT
 
350
_GL_WARN_ON_USE (cbrt, "cbrt is unportable - "
 
351
                 "use gnulib module cbrt for portability");
 
352
# endif
 
353
#endif
 
354
 
 
355
#if @GNULIB_CBRTL@
 
356
# if @REPLACE_CBRTL@
 
357
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
358
#   undef cbrtl
 
359
#   define cbrtl rpl_cbrtl
 
360
#  endif
 
361
_GL_FUNCDECL_RPL (cbrtl, long double, (long double x));
 
362
_GL_CXXALIAS_RPL (cbrtl, long double, (long double x));
 
363
# else
 
364
#  if !@HAVE_DECL_CBRTL@
 
365
_GL_FUNCDECL_SYS (cbrtl, long double, (long double x));
 
366
#  endif
 
367
_GL_CXXALIAS_SYS (cbrtl, long double, (long double x));
 
368
# endif
 
369
_GL_CXXALIASWARN (cbrtl);
 
370
#elif defined GNULIB_POSIXCHECK
 
371
# undef cbrtl
 
372
# if HAVE_RAW_DECL_CBRTL
 
373
_GL_WARN_ON_USE (cbrtl, "cbrtl is unportable - "
 
374
                 "use gnulib module cbrtl for portability");
178
375
# endif
179
376
#endif
180
377
 
182
379
#if @GNULIB_CEILF@
183
380
# if @REPLACE_CEILF@
184
381
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
382
#   undef ceilf
185
383
#   define ceilf rpl_ceilf
186
384
#  endif
187
385
_GL_FUNCDECL_RPL (ceilf, float, (float x));
188
386
_GL_CXXALIAS_RPL (ceilf, float, (float x));
189
387
# else
190
388
#  if !@HAVE_DECL_CEILF@
 
389
#   undef ceilf
191
390
_GL_FUNCDECL_SYS (ceilf, float, (float x));
192
391
#  endif
193
392
_GL_CXXALIAS_SYS (ceilf, float, (float x));
201
400
# endif
202
401
#endif
203
402
 
 
403
#if @GNULIB_CEIL@
 
404
# if @REPLACE_CEIL@
 
405
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
406
#   define ceil rpl_ceil
 
407
#  endif
 
408
_GL_FUNCDECL_RPL (ceil, double, (double x));
 
409
_GL_CXXALIAS_RPL (ceil, double, (double x));
 
410
# else
 
411
_GL_CXXALIAS_SYS (ceil, double, (double x));
 
412
# endif
 
413
_GL_CXXALIASWARN (ceil);
 
414
#endif
 
415
 
204
416
#if @GNULIB_CEILL@
205
417
# if @REPLACE_CEILL@
206
418
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
419
#   undef ceill
207
420
#   define ceill rpl_ceill
208
421
#  endif
209
422
_GL_FUNCDECL_RPL (ceill, long double, (long double x));
210
423
_GL_CXXALIAS_RPL (ceill, long double, (long double x));
211
424
# else
212
425
#  if !@HAVE_DECL_CEILL@
 
426
#   undef ceill
213
427
_GL_FUNCDECL_SYS (ceill, long double, (long double x));
214
428
#  endif
215
429
_GL_CXXALIAS_SYS (ceill, long double, (long double x));
224
438
#endif
225
439
 
226
440
 
 
441
#if @GNULIB_COPYSIGNF@
 
442
# if !@HAVE_DECL_COPYSIGNF@
 
443
_GL_FUNCDECL_SYS (copysignf, float, (float x, float y));
 
444
# endif
 
445
_GL_CXXALIAS_SYS (copysignf, float, (float x, float y));
 
446
_GL_CXXALIASWARN (copysignf);
 
447
#elif defined GNULIB_POSIXCHECK
 
448
# undef copysignf
 
449
# if HAVE_RAW_DECL_COPYSIGNF
 
450
_GL_WARN_ON_USE (copysignf, "copysignf is unportable - "
 
451
                 "use gnulib module copysignf for portability");
 
452
# endif
 
453
#endif
 
454
 
 
455
#if @GNULIB_COPYSIGN@
 
456
# if !@HAVE_COPYSIGN@
 
457
_GL_FUNCDECL_SYS (copysign, double, (double x, double y));
 
458
# endif
 
459
_GL_CXXALIAS_SYS (copysign, double, (double x, double y));
 
460
_GL_CXXALIASWARN (copysign);
 
461
#elif defined GNULIB_POSIXCHECK
 
462
# undef copysign
 
463
# if HAVE_RAW_DECL_COPYSIGN
 
464
_GL_WARN_ON_USE (copysign, "copysign is unportable - "
 
465
                 "use gnulib module copysign for portability");
 
466
# endif
 
467
#endif
 
468
 
 
469
#if @GNULIB_COPYSIGNL@
 
470
# if !@HAVE_COPYSIGNL@
 
471
_GL_FUNCDECL_SYS (copysignl, long double, (long double x, long double y));
 
472
# endif
 
473
_GL_CXXALIAS_SYS (copysignl, long double, (long double x, long double y));
 
474
_GL_CXXALIASWARN (copysignl);
 
475
#elif defined GNULIB_POSIXCHECK
 
476
# undef copysignl
 
477
# if HAVE_RAW_DECL_COPYSIGNL
 
478
_GL_WARN_ON_USE (copysign, "copysignl is unportable - "
 
479
                 "use gnulib module copysignl for portability");
 
480
# endif
 
481
#endif
 
482
 
 
483
 
 
484
#if @GNULIB_COSF@
 
485
# if !@HAVE_COSF@
 
486
#  undef cosf
 
487
_GL_FUNCDECL_SYS (cosf, float, (float x));
 
488
# endif
 
489
_GL_CXXALIAS_SYS (cosf, float, (float x));
 
490
_GL_CXXALIASWARN (cosf);
 
491
#elif defined GNULIB_POSIXCHECK
 
492
# undef cosf
 
493
# if HAVE_RAW_DECL_COSF
 
494
_GL_WARN_ON_USE (cosf, "cosf is unportable - "
 
495
                 "use gnulib module cosf for portability");
 
496
# endif
 
497
#endif
 
498
 
227
499
#if @GNULIB_COSL@
228
500
# if !@HAVE_COSL@ || !@HAVE_DECL_COSL@
 
501
#  undef cosl
229
502
_GL_FUNCDECL_SYS (cosl, long double, (long double x));
230
503
# endif
231
504
_GL_CXXALIAS_SYS (cosl, long double, (long double x));
234
507
# undef cosl
235
508
# if HAVE_RAW_DECL_COSL
236
509
_GL_WARN_ON_USE (cosl, "cosl is unportable - "
237
 
                 "use gnulib module mathl for portability");
238
 
# endif
239
 
#endif
240
 
 
 
510
                 "use gnulib module cosl for portability");
 
511
# endif
 
512
#endif
 
513
 
 
514
 
 
515
#if @GNULIB_COSHF@
 
516
# if !@HAVE_COSHF@
 
517
#  undef coshf
 
518
_GL_FUNCDECL_SYS (coshf, float, (float x));
 
519
# endif
 
520
_GL_CXXALIAS_SYS (coshf, float, (float x));
 
521
_GL_CXXALIASWARN (coshf);
 
522
#elif defined GNULIB_POSIXCHECK
 
523
# undef coshf
 
524
# if HAVE_RAW_DECL_COSHF
 
525
_GL_WARN_ON_USE (coshf, "coshf is unportable - "
 
526
                 "use gnulib module coshf for portability");
 
527
# endif
 
528
#endif
 
529
 
 
530
 
 
531
#if @GNULIB_EXPF@
 
532
# if !@HAVE_EXPF@
 
533
#  undef expf
 
534
_GL_FUNCDECL_SYS (expf, float, (float x));
 
535
# endif
 
536
_GL_CXXALIAS_SYS (expf, float, (float x));
 
537
_GL_CXXALIASWARN (expf);
 
538
#elif defined GNULIB_POSIXCHECK
 
539
# undef expf
 
540
# if HAVE_RAW_DECL_EXPF
 
541
_GL_WARN_ON_USE (expf, "expf is unportable - "
 
542
                 "use gnulib module expf for portability");
 
543
# endif
 
544
#endif
241
545
 
242
546
#if @GNULIB_EXPL@
243
547
# if !@HAVE_EXPL@ || !@HAVE_DECL_EXPL@
 
548
#  undef expl
244
549
_GL_FUNCDECL_SYS (expl, long double, (long double x));
245
550
# endif
246
551
_GL_CXXALIAS_SYS (expl, long double, (long double x));
249
554
# undef expl
250
555
# if HAVE_RAW_DECL_EXPL
251
556
_GL_WARN_ON_USE (expl, "expl is unportable - "
252
 
                 "use gnulib module mathl for portability");
 
557
                 "use gnulib module expl for portability");
 
558
# endif
 
559
#endif
 
560
 
 
561
 
 
562
#if @GNULIB_EXP2F@
 
563
# if !@HAVE_DECL_EXP2F@
 
564
_GL_FUNCDECL_SYS (exp2f, float, (float x));
 
565
# endif
 
566
_GL_CXXALIAS_SYS (exp2f, float, (float x));
 
567
_GL_CXXALIASWARN (exp2f);
 
568
#elif defined GNULIB_POSIXCHECK
 
569
# undef exp2f
 
570
# if HAVE_RAW_DECL_EXP2F
 
571
_GL_WARN_ON_USE (exp2f, "exp2f is unportable - "
 
572
                 "use gnulib module exp2f for portability");
 
573
# endif
 
574
#endif
 
575
 
 
576
#if @GNULIB_EXP2@
 
577
# if @REPLACE_EXP2@
 
578
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
579
#   undef exp2
 
580
#   define exp2 rpl_exp2
 
581
#  endif
 
582
_GL_FUNCDECL_RPL (exp2, double, (double x));
 
583
_GL_CXXALIAS_RPL (exp2, double, (double x));
 
584
# else
 
585
#  if !@HAVE_DECL_EXP2@
 
586
_GL_FUNCDECL_SYS (exp2, double, (double x));
 
587
#  endif
 
588
_GL_CXXALIAS_SYS (exp2, double, (double x));
 
589
# endif
 
590
_GL_CXXALIASWARN (exp2);
 
591
#elif defined GNULIB_POSIXCHECK
 
592
# undef exp2
 
593
# if HAVE_RAW_DECL_EXP2
 
594
_GL_WARN_ON_USE (exp2, "exp2 is unportable - "
 
595
                 "use gnulib module exp2 for portability");
 
596
# endif
 
597
#endif
 
598
 
 
599
#if @GNULIB_EXP2L@
 
600
# if @REPLACE_EXP2L@
 
601
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
602
#   undef exp2l
 
603
#   define exp2l rpl_exp2l
 
604
#  endif
 
605
_GL_FUNCDECL_RPL (exp2l, long double, (long double x));
 
606
_GL_CXXALIAS_RPL (exp2l, long double, (long double x));
 
607
# else
 
608
#  if !@HAVE_DECL_EXP2L@
 
609
#   undef exp2l
 
610
_GL_FUNCDECL_SYS (exp2l, long double, (long double x));
 
611
#  endif
 
612
_GL_CXXALIAS_SYS (exp2l, long double, (long double x));
 
613
# endif
 
614
_GL_CXXALIASWARN (exp2l);
 
615
#elif defined GNULIB_POSIXCHECK
 
616
# undef exp2l
 
617
# if HAVE_RAW_DECL_EXP2L
 
618
_GL_WARN_ON_USE (exp2l, "exp2l is unportable - "
 
619
                 "use gnulib module exp2l for portability");
 
620
# endif
 
621
#endif
 
622
 
 
623
 
 
624
#if @GNULIB_EXPM1F@
 
625
# if @REPLACE_EXPM1F@
 
626
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
627
#   undef expm1f
 
628
#   define expm1f rpl_expm1f
 
629
#  endif
 
630
_GL_FUNCDECL_RPL (expm1f, float, (float x));
 
631
_GL_CXXALIAS_RPL (expm1f, float, (float x));
 
632
# else
 
633
#  if !@HAVE_EXPM1F@
 
634
_GL_FUNCDECL_SYS (expm1f, float, (float x));
 
635
#  endif
 
636
_GL_CXXALIAS_SYS (expm1f, float, (float x));
 
637
# endif
 
638
_GL_CXXALIASWARN (expm1f);
 
639
#elif defined GNULIB_POSIXCHECK
 
640
# undef expm1f
 
641
# if HAVE_RAW_DECL_EXPM1F
 
642
_GL_WARN_ON_USE (expm1f, "expm1f is unportable - "
 
643
                 "use gnulib module expm1f for portability");
 
644
# endif
 
645
#endif
 
646
 
 
647
#if @GNULIB_EXPM1@
 
648
# if @REPLACE_EXPM1@
 
649
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
650
#   undef expm1
 
651
#   define expm1 rpl_expm1
 
652
#  endif
 
653
_GL_FUNCDECL_RPL (expm1, double, (double x));
 
654
_GL_CXXALIAS_RPL (expm1, double, (double x));
 
655
# else
 
656
#  if !@HAVE_EXPM1@
 
657
_GL_FUNCDECL_SYS (expm1, double, (double x));
 
658
#  endif
 
659
_GL_CXXALIAS_SYS (expm1, double, (double x));
 
660
# endif
 
661
_GL_CXXALIASWARN (expm1);
 
662
#elif defined GNULIB_POSIXCHECK
 
663
# undef expm1
 
664
# if HAVE_RAW_DECL_EXPM1
 
665
_GL_WARN_ON_USE (expm1, "expm1 is unportable - "
 
666
                 "use gnulib module expm1 for portability");
 
667
# endif
 
668
#endif
 
669
 
 
670
#if @GNULIB_EXPM1L@
 
671
# if !@HAVE_DECL_EXPM1L@
 
672
#  undef expm1l
 
673
_GL_FUNCDECL_SYS (expm1l, long double, (long double x));
 
674
# endif
 
675
_GL_CXXALIAS_SYS (expm1l, long double, (long double x));
 
676
_GL_CXXALIASWARN (expm1l);
 
677
#elif defined GNULIB_POSIXCHECK
 
678
# undef expm1l
 
679
# if HAVE_RAW_DECL_EXPM1L
 
680
_GL_WARN_ON_USE (expm1l, "expm1l is unportable - "
 
681
                 "use gnulib module expm1l for portability");
 
682
# endif
 
683
#endif
 
684
 
 
685
 
 
686
#if @GNULIB_FABSF@
 
687
# if !@HAVE_FABSF@
 
688
#  undef fabsf
 
689
_GL_FUNCDECL_SYS (fabsf, float, (float x));
 
690
# endif
 
691
_GL_CXXALIAS_SYS (fabsf, float, (float x));
 
692
_GL_CXXALIASWARN (fabsf);
 
693
#elif defined GNULIB_POSIXCHECK
 
694
# undef fabsf
 
695
# if HAVE_RAW_DECL_FABSF
 
696
_GL_WARN_ON_USE (fabsf, "fabsf is unportable - "
 
697
                 "use gnulib module fabsf for portability");
 
698
# endif
 
699
#endif
 
700
 
 
701
#if @GNULIB_FABSL@
 
702
# if @REPLACE_FABSL@
 
703
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
704
#   undef fabsl
 
705
#   define fabsl rpl_fabsl
 
706
#  endif
 
707
_GL_FUNCDECL_RPL (fabsl, long double, (long double x));
 
708
_GL_CXXALIAS_RPL (fabsl, long double, (long double x));
 
709
# else
 
710
#  if !@HAVE_FABSL@
 
711
#   undef fabsl
 
712
_GL_FUNCDECL_SYS (fabsl, long double, (long double x));
 
713
#  endif
 
714
_GL_CXXALIAS_SYS (fabsl, long double, (long double x));
 
715
# endif
 
716
_GL_CXXALIASWARN (fabsl);
 
717
#elif defined GNULIB_POSIXCHECK
 
718
# undef fabsl
 
719
# if HAVE_RAW_DECL_FABSL
 
720
_GL_WARN_ON_USE (fabsl, "fabsl is unportable - "
 
721
                 "use gnulib module fabsl for portability");
253
722
# endif
254
723
#endif
255
724
 
257
726
#if @GNULIB_FLOORF@
258
727
# if @REPLACE_FLOORF@
259
728
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
729
#   undef floorf
260
730
#   define floorf rpl_floorf
261
731
#  endif
262
732
_GL_FUNCDECL_RPL (floorf, float, (float x));
263
733
_GL_CXXALIAS_RPL (floorf, float, (float x));
264
 
#else
 
734
# else
265
735
#  if !@HAVE_DECL_FLOORF@
 
736
#   undef floorf
266
737
_GL_FUNCDECL_SYS (floorf, float, (float x));
267
738
#  endif
268
739
_GL_CXXALIAS_SYS (floorf, float, (float x));
276
747
# endif
277
748
#endif
278
749
 
 
750
#if @GNULIB_FLOOR@
 
751
# if @REPLACE_FLOOR@
 
752
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
753
#   define floor rpl_floor
 
754
#  endif
 
755
_GL_FUNCDECL_RPL (floor, double, (double x));
 
756
_GL_CXXALIAS_RPL (floor, double, (double x));
 
757
# else
 
758
_GL_CXXALIAS_SYS (floor, double, (double x));
 
759
# endif
 
760
_GL_CXXALIASWARN (floor);
 
761
#endif
 
762
 
279
763
#if @GNULIB_FLOORL@
280
764
# if @REPLACE_FLOORL@
281
765
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
766
#   undef floorl
282
767
#   define floorl rpl_floorl
283
768
#  endif
284
769
_GL_FUNCDECL_RPL (floorl, long double, (long double x));
285
770
_GL_CXXALIAS_RPL (floorl, long double, (long double x));
286
771
# else
287
772
#  if !@HAVE_DECL_FLOORL@
 
773
#   undef floorl
288
774
_GL_FUNCDECL_SYS (floorl, long double, (long double x));
289
775
#  endif
290
776
_GL_CXXALIAS_SYS (floorl, long double, (long double x));
299
785
#endif
300
786
 
301
787
 
 
788
#if @GNULIB_FMAF@
 
789
# if @REPLACE_FMAF@
 
790
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
791
#   undef fmaf
 
792
#   define fmaf rpl_fmaf
 
793
#  endif
 
794
_GL_FUNCDECL_RPL (fmaf, float, (float x, float y, float z));
 
795
_GL_CXXALIAS_RPL (fmaf, float, (float x, float y, float z));
 
796
# else
 
797
#  if !@HAVE_FMAF@
 
798
_GL_FUNCDECL_SYS (fmaf, float, (float x, float y, float z));
 
799
#  endif
 
800
_GL_CXXALIAS_SYS (fmaf, float, (float x, float y, float z));
 
801
# endif
 
802
_GL_CXXALIASWARN (fmaf);
 
803
#elif defined GNULIB_POSIXCHECK
 
804
# undef fmaf
 
805
# if HAVE_RAW_DECL_FMAF
 
806
_GL_WARN_ON_USE (fmaf, "fmaf is unportable - "
 
807
                 "use gnulib module fmaf for portability");
 
808
# endif
 
809
#endif
 
810
 
 
811
#if @GNULIB_FMA@
 
812
# if @REPLACE_FMA@
 
813
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
814
#   undef fma
 
815
#   define fma rpl_fma
 
816
#  endif
 
817
_GL_FUNCDECL_RPL (fma, double, (double x, double y, double z));
 
818
_GL_CXXALIAS_RPL (fma, double, (double x, double y, double z));
 
819
# else
 
820
#  if !@HAVE_FMA@
 
821
_GL_FUNCDECL_SYS (fma, double, (double x, double y, double z));
 
822
#  endif
 
823
_GL_CXXALIAS_SYS (fma, double, (double x, double y, double z));
 
824
# endif
 
825
_GL_CXXALIASWARN (fma);
 
826
#elif defined GNULIB_POSIXCHECK
 
827
# undef fma
 
828
# if HAVE_RAW_DECL_FMA
 
829
_GL_WARN_ON_USE (fma, "fma is unportable - "
 
830
                 "use gnulib module fma for portability");
 
831
# endif
 
832
#endif
 
833
 
 
834
#if @GNULIB_FMAL@
 
835
# if @REPLACE_FMAL@
 
836
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
837
#   undef fmal
 
838
#   define fmal rpl_fmal
 
839
#  endif
 
840
_GL_FUNCDECL_RPL (fmal, long double,
 
841
                  (long double x, long double y, long double z));
 
842
_GL_CXXALIAS_RPL (fmal, long double,
 
843
                  (long double x, long double y, long double z));
 
844
# else
 
845
#  if !@HAVE_FMAL@
 
846
#   undef fmal
 
847
_GL_FUNCDECL_SYS (fmal, long double,
 
848
                  (long double x, long double y, long double z));
 
849
#  endif
 
850
_GL_CXXALIAS_SYS (fmal, long double,
 
851
                  (long double x, long double y, long double z));
 
852
# endif
 
853
_GL_CXXALIASWARN (fmal);
 
854
#elif defined GNULIB_POSIXCHECK
 
855
# undef fmal
 
856
# if HAVE_RAW_DECL_FMAL
 
857
_GL_WARN_ON_USE (fmal, "fmal is unportable - "
 
858
                 "use gnulib module fmal for portability");
 
859
# endif
 
860
#endif
 
861
 
 
862
 
 
863
#if @GNULIB_FMODF@
 
864
# if @REPLACE_FMODF@
 
865
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
866
#   undef fmodf
 
867
#   define fmodf rpl_fmodf
 
868
#  endif
 
869
_GL_FUNCDECL_RPL (fmodf, float, (float x, float y));
 
870
_GL_CXXALIAS_RPL (fmodf, float, (float x, float y));
 
871
# else
 
872
#  if !@HAVE_FMODF@
 
873
#   undef fmodf
 
874
_GL_FUNCDECL_SYS (fmodf, float, (float x, float y));
 
875
#  endif
 
876
_GL_CXXALIAS_SYS (fmodf, float, (float x, float y));
 
877
# endif
 
878
_GL_CXXALIASWARN (fmodf);
 
879
#elif defined GNULIB_POSIXCHECK
 
880
# undef fmodf
 
881
# if HAVE_RAW_DECL_FMODF
 
882
_GL_WARN_ON_USE (fmodf, "fmodf is unportable - "
 
883
                 "use gnulib module fmodf for portability");
 
884
# endif
 
885
#endif
 
886
 
 
887
#if @GNULIB_FMOD@
 
888
# if @REPLACE_FMOD@
 
889
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
890
#   undef fmod
 
891
#   define fmod rpl_fmod
 
892
#  endif
 
893
_GL_FUNCDECL_RPL (fmod, double, (double x, double y));
 
894
_GL_CXXALIAS_RPL (fmod, double, (double x, double y));
 
895
# else
 
896
_GL_CXXALIAS_SYS (fmod, double, (double x, double y));
 
897
# endif
 
898
_GL_CXXALIASWARN (fmod);
 
899
#elif defined GNULIB_POSIXCHECK
 
900
# undef fmod
 
901
# if HAVE_RAW_DECL_FMOD
 
902
_GL_WARN_ON_USE (fmod, "fmod has portability problems - "
 
903
                 "use gnulib module fmod for portability");
 
904
# endif
 
905
#endif
 
906
 
 
907
#if @GNULIB_FMODL@
 
908
# if @REPLACE_FMODL@
 
909
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
910
#   undef fmodl
 
911
#   define fmodl rpl_fmodl
 
912
#  endif
 
913
_GL_FUNCDECL_RPL (fmodl, long double, (long double x, long double y));
 
914
_GL_CXXALIAS_RPL (fmodl, long double, (long double x, long double y));
 
915
# else
 
916
#  if !@HAVE_FMODL@
 
917
#   undef fmodl
 
918
_GL_FUNCDECL_SYS (fmodl, long double, (long double x, long double y));
 
919
#  endif
 
920
_GL_CXXALIAS_SYS (fmodl, long double, (long double x, long double y));
 
921
# endif
 
922
_GL_CXXALIASWARN (fmodl);
 
923
#elif defined GNULIB_POSIXCHECK
 
924
# undef fmodl
 
925
# if HAVE_RAW_DECL_FMODL
 
926
_GL_WARN_ON_USE (fmodl, "fmodl is unportable - "
 
927
                 "use gnulib module fmodl for portability");
 
928
# endif
 
929
#endif
 
930
 
 
931
 
 
932
/* Write x as
 
933
     x = mantissa * 2^exp
 
934
   where
 
935
     If x finite and nonzero: 0.5 <= |mantissa| < 1.0.
 
936
     If x is zero: mantissa = x, exp = 0.
 
937
     If x is infinite or NaN: mantissa = x, exp unspecified.
 
938
   Store exp in *EXPPTR and return mantissa.  */
 
939
#if @GNULIB_FREXPF@
 
940
# if @REPLACE_FREXPF@
 
941
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
942
#   undef frexpf
 
943
#   define frexpf rpl_frexpf
 
944
#  endif
 
945
_GL_FUNCDECL_RPL (frexpf, float, (float x, int *expptr) _GL_ARG_NONNULL ((2)));
 
946
_GL_CXXALIAS_RPL (frexpf, float, (float x, int *expptr));
 
947
# else
 
948
#  if !@HAVE_FREXPF@
 
949
#   undef frexpf
 
950
_GL_FUNCDECL_SYS (frexpf, float, (float x, int *expptr) _GL_ARG_NONNULL ((2)));
 
951
#  endif
 
952
_GL_CXXALIAS_SYS (frexpf, float, (float x, int *expptr));
 
953
# endif
 
954
_GL_CXXALIASWARN (frexpf);
 
955
#elif defined GNULIB_POSIXCHECK
 
956
# undef frexpf
 
957
# if HAVE_RAW_DECL_FREXPF
 
958
_GL_WARN_ON_USE (frexpf, "frexpf is unportable - "
 
959
                 "use gnulib module frexpf for portability");
 
960
# endif
 
961
#endif
 
962
 
 
963
/* Write x as
 
964
     x = mantissa * 2^exp
 
965
   where
 
966
     If x finite and nonzero: 0.5 <= |mantissa| < 1.0.
 
967
     If x is zero: mantissa = x, exp = 0.
 
968
     If x is infinite or NaN: mantissa = x, exp unspecified.
 
969
   Store exp in *EXPPTR and return mantissa.  */
 
970
#if @GNULIB_FREXP@
 
971
# if @REPLACE_FREXP@
 
972
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
973
#   define frexp rpl_frexp
 
974
#  endif
 
975
_GL_FUNCDECL_RPL (frexp, double, (double x, int *expptr) _GL_ARG_NONNULL ((2)));
 
976
_GL_CXXALIAS_RPL (frexp, double, (double x, int *expptr));
 
977
# else
 
978
_GL_CXXALIAS_SYS (frexp, double, (double x, int *expptr));
 
979
# endif
 
980
_GL_CXXALIASWARN (frexp);
 
981
#elif defined GNULIB_POSIXCHECK
 
982
# undef frexp
 
983
/* Assume frexp is always declared.  */
 
984
_GL_WARN_ON_USE (frexp, "frexp is unportable - "
 
985
                 "use gnulib module frexp for portability");
 
986
#endif
 
987
 
302
988
/* Write x as
303
989
     x = mantissa * 2^exp
304
990
   where
308
994
   Store exp in *EXPPTR and return mantissa.  */
309
995
#if @GNULIB_FREXPL@ && @REPLACE_FREXPL@
310
996
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
997
#  undef frexpl
311
998
#  define frexpl rpl_frexpl
312
999
# endif
313
1000
_GL_FUNCDECL_RPL (frexpl, long double,
334
1021
#endif
335
1022
 
336
1023
 
 
1024
/* Return sqrt(x^2+y^2).  */
 
1025
#if @GNULIB_HYPOTF@
 
1026
# if @REPLACE_HYPOTF@
 
1027
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1028
#   undef hypotf
 
1029
#   define hypotf rpl_hypotf
 
1030
#  endif
 
1031
_GL_FUNCDECL_RPL (hypotf, float, (float x, float y));
 
1032
_GL_CXXALIAS_RPL (hypotf, float, (float x, float y));
 
1033
# else
 
1034
#  if !@HAVE_HYPOTF@
 
1035
_GL_FUNCDECL_SYS (hypotf, float, (float x, float y));
 
1036
#  endif
 
1037
_GL_CXXALIAS_SYS (hypotf, float, (float x, float y));
 
1038
# endif
 
1039
_GL_CXXALIASWARN (hypotf);
 
1040
#elif defined GNULIB_POSIXCHECK
 
1041
# undef hypotf
 
1042
# if HAVE_RAW_DECL_HYPOTF
 
1043
_GL_WARN_ON_USE (hypotf, "hypotf is unportable - "
 
1044
                 "use gnulib module hypotf for portability");
 
1045
# endif
 
1046
#endif
 
1047
 
 
1048
/* Return sqrt(x^2+y^2).  */
 
1049
#if @GNULIB_HYPOT@
 
1050
# if @REPLACE_HYPOT@
 
1051
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1052
#   undef hypot
 
1053
#   define hypot rpl_hypot
 
1054
#  endif
 
1055
_GL_FUNCDECL_RPL (hypot, double, (double x, double y));
 
1056
_GL_CXXALIAS_RPL (hypot, double, (double x, double y));
 
1057
# else
 
1058
_GL_CXXALIAS_SYS (hypot, double, (double x, double y));
 
1059
# endif
 
1060
_GL_CXXALIASWARN (hypot);
 
1061
#elif defined GNULIB_POSIXCHECK
 
1062
# undef hypot
 
1063
# if HAVE_RAW_DECL_HYPOT
 
1064
_GL_WARN_ON_USE (hypotf, "hypot has portability problems - "
 
1065
                 "use gnulib module hypot for portability");
 
1066
# endif
 
1067
#endif
 
1068
 
 
1069
/* Return sqrt(x^2+y^2).  */
 
1070
#if @GNULIB_HYPOTL@
 
1071
# if @REPLACE_HYPOTL@
 
1072
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1073
#   undef hypotl
 
1074
#   define hypotl rpl_hypotl
 
1075
#  endif
 
1076
_GL_FUNCDECL_RPL (hypotl, long double, (long double x, long double y));
 
1077
_GL_CXXALIAS_RPL (hypotl, long double, (long double x, long double y));
 
1078
# else
 
1079
#  if !@HAVE_HYPOTL@
 
1080
_GL_FUNCDECL_SYS (hypotl, long double, (long double x, long double y));
 
1081
#  endif
 
1082
_GL_CXXALIAS_SYS (hypotl, long double, (long double x, long double y));
 
1083
# endif
 
1084
_GL_CXXALIASWARN (hypotl);
 
1085
#elif defined GNULIB_POSIXCHECK
 
1086
# undef hypotl
 
1087
# if HAVE_RAW_DECL_HYPOTL
 
1088
_GL_WARN_ON_USE (hypotl, "hypotl is unportable - "
 
1089
                 "use gnulib module hypotl for portability");
 
1090
# endif
 
1091
#endif
 
1092
 
 
1093
 
 
1094
#if @GNULIB_ILOGBF@
 
1095
# if @REPLACE_ILOGBF@
 
1096
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1097
#   undef ilogbf
 
1098
#   define ilogbf rpl_ilogbf
 
1099
#  endif
 
1100
_GL_FUNCDECL_RPL (ilogbf, int, (float x));
 
1101
_GL_CXXALIAS_RPL (ilogbf, int, (float x));
 
1102
# else
 
1103
#  if !@HAVE_ILOGBF@
 
1104
_GL_FUNCDECL_SYS (ilogbf, int, (float x));
 
1105
#  endif
 
1106
_GL_CXXALIAS_SYS (ilogbf, int, (float x));
 
1107
# endif
 
1108
_GL_CXXALIASWARN (ilogbf);
 
1109
#elif defined GNULIB_POSIXCHECK
 
1110
# undef ilogbf
 
1111
# if HAVE_RAW_DECL_ILOGBF
 
1112
_GL_WARN_ON_USE (ilogbf, "ilogbf is unportable - "
 
1113
                 "use gnulib module ilogbf for portability");
 
1114
# endif
 
1115
#endif
 
1116
 
 
1117
#if @GNULIB_ILOGB@
 
1118
# if @REPLACE_ILOGB@
 
1119
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1120
#   undef ilogb
 
1121
#   define ilogb rpl_ilogb
 
1122
#  endif
 
1123
_GL_FUNCDECL_RPL (ilogb, int, (double x));
 
1124
_GL_CXXALIAS_RPL (ilogb, int, (double x));
 
1125
# else
 
1126
#  if !@HAVE_ILOGB@
 
1127
_GL_FUNCDECL_SYS (ilogb, int, (double x));
 
1128
#  endif
 
1129
_GL_CXXALIAS_SYS (ilogb, int, (double x));
 
1130
# endif
 
1131
_GL_CXXALIASWARN (ilogb);
 
1132
#elif defined GNULIB_POSIXCHECK
 
1133
# undef ilogb
 
1134
# if HAVE_RAW_DECL_ILOGB
 
1135
_GL_WARN_ON_USE (ilogb, "ilogb is unportable - "
 
1136
                 "use gnulib module ilogb for portability");
 
1137
# endif
 
1138
#endif
 
1139
 
 
1140
#if @GNULIB_ILOGBL@
 
1141
# if !@HAVE_ILOGBL@
 
1142
_GL_FUNCDECL_SYS (ilogbl, int, (long double x));
 
1143
# endif
 
1144
_GL_CXXALIAS_SYS (ilogbl, int, (long double x));
 
1145
_GL_CXXALIASWARN (ilogbl);
 
1146
#elif defined GNULIB_POSIXCHECK
 
1147
# undef ilogbl
 
1148
# if HAVE_RAW_DECL_ILOGBL
 
1149
_GL_WARN_ON_USE (ilogbl, "ilogbl is unportable - "
 
1150
                 "use gnulib module ilogbl for portability");
 
1151
# endif
 
1152
#endif
 
1153
 
 
1154
 
 
1155
/* Return x * 2^exp.  */
 
1156
#if @GNULIB_LDEXPF@
 
1157
# if !@HAVE_LDEXPF@
 
1158
#  undef ldexpf
 
1159
_GL_FUNCDECL_SYS (ldexpf, float, (float x, int exp));
 
1160
# endif
 
1161
_GL_CXXALIAS_SYS (ldexpf, float, (float x, int exp));
 
1162
_GL_CXXALIASWARN (ldexpf);
 
1163
#elif defined GNULIB_POSIXCHECK
 
1164
# undef ldexpf
 
1165
# if HAVE_RAW_DECL_LDEXPF
 
1166
_GL_WARN_ON_USE (ldexpf, "ldexpf is unportable - "
 
1167
                 "use gnulib module ldexpf for portability");
 
1168
# endif
 
1169
#endif
 
1170
 
337
1171
/* Return x * 2^exp.  */
338
1172
#if @GNULIB_LDEXPL@ && @REPLACE_LDEXPL@
339
1173
# if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1174
#  undef ldexpl
340
1175
#  define ldexpl rpl_ldexpl
341
1176
# endif
342
1177
_GL_FUNCDECL_RPL (ldexpl, long double, (long double x, int exp));
361
1196
#endif
362
1197
 
363
1198
 
 
1199
#if @GNULIB_LOGF@
 
1200
# if @REPLACE_LOGF@
 
1201
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1202
#   undef logf
 
1203
#   define logf rpl_logf
 
1204
#  endif
 
1205
_GL_FUNCDECL_RPL (logf, float, (float x));
 
1206
_GL_CXXALIAS_RPL (logf, float, (float x));
 
1207
# else
 
1208
#  if !@HAVE_LOGF@
 
1209
#   undef logf
 
1210
_GL_FUNCDECL_SYS (logf, float, (float x));
 
1211
#  endif
 
1212
_GL_CXXALIAS_SYS (logf, float, (float x));
 
1213
# endif
 
1214
_GL_CXXALIASWARN (logf);
 
1215
#elif defined GNULIB_POSIXCHECK
 
1216
# undef logf
 
1217
# if HAVE_RAW_DECL_LOGF
 
1218
_GL_WARN_ON_USE (logf, "logf is unportable - "
 
1219
                 "use gnulib module logf for portability");
 
1220
# endif
 
1221
#endif
 
1222
 
 
1223
#if @GNULIB_LOG@
 
1224
# if @REPLACE_LOG@
 
1225
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1226
#   undef log
 
1227
#   define log rpl_log
 
1228
#  endif
 
1229
_GL_FUNCDECL_RPL (log, double, (double x));
 
1230
_GL_CXXALIAS_RPL (log, double, (double x));
 
1231
# else
 
1232
_GL_CXXALIAS_SYS (log, double, (double x));
 
1233
# endif
 
1234
_GL_CXXALIASWARN (log);
 
1235
#elif defined GNULIB_POSIXCHECK
 
1236
# undef log
 
1237
# if HAVE_RAW_DECL_LOG
 
1238
_GL_WARN_ON_USE (log, "log has portability problems - "
 
1239
                 "use gnulib module log for portability");
 
1240
# endif
 
1241
#endif
 
1242
 
364
1243
#if @GNULIB_LOGL@
365
 
# if !@HAVE_LOGL@ || !@HAVE_DECL_LOGL@
 
1244
# if @REPLACE_LOGL@
 
1245
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1246
#   undef logl
 
1247
#   define logl rpl_logl
 
1248
#  endif
 
1249
_GL_FUNCDECL_RPL (logl, long double, (long double x));
 
1250
_GL_CXXALIAS_RPL (logl, long double, (long double x));
 
1251
# else
 
1252
#  if !@HAVE_LOGL@ || !@HAVE_DECL_LOGL@
 
1253
#   undef logl
366
1254
_GL_FUNCDECL_SYS (logl, long double, (long double x));
367
 
# endif
 
1255
#  endif
368
1256
_GL_CXXALIAS_SYS (logl, long double, (long double x));
 
1257
# endif
369
1258
_GL_CXXALIASWARN (logl);
370
1259
#elif defined GNULIB_POSIXCHECK
371
1260
# undef logl
372
1261
# if HAVE_RAW_DECL_LOGL
373
1262
_GL_WARN_ON_USE (logl, "logl is unportable - "
374
 
                 "use gnulib module mathl for portability");
 
1263
                 "use gnulib module logl for portability");
 
1264
# endif
 
1265
#endif
 
1266
 
 
1267
 
 
1268
#if @GNULIB_LOG10F@
 
1269
# if @REPLACE_LOG10F@
 
1270
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1271
#   undef log10f
 
1272
#   define log10f rpl_log10f
 
1273
#  endif
 
1274
_GL_FUNCDECL_RPL (log10f, float, (float x));
 
1275
_GL_CXXALIAS_RPL (log10f, float, (float x));
 
1276
# else
 
1277
#  if !@HAVE_LOG10F@
 
1278
#   undef log10f
 
1279
_GL_FUNCDECL_SYS (log10f, float, (float x));
 
1280
#  endif
 
1281
_GL_CXXALIAS_SYS (log10f, float, (float x));
 
1282
# endif
 
1283
_GL_CXXALIASWARN (log10f);
 
1284
#elif defined GNULIB_POSIXCHECK
 
1285
# undef log10f
 
1286
# if HAVE_RAW_DECL_LOG10F
 
1287
_GL_WARN_ON_USE (log10f, "log10f is unportable - "
 
1288
                 "use gnulib module log10f for portability");
 
1289
# endif
 
1290
#endif
 
1291
 
 
1292
#if @GNULIB_LOG10@
 
1293
# if @REPLACE_LOG10@
 
1294
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1295
#   undef log10
 
1296
#   define log10 rpl_log10
 
1297
#  endif
 
1298
_GL_FUNCDECL_RPL (log10, double, (double x));
 
1299
_GL_CXXALIAS_RPL (log10, double, (double x));
 
1300
# else
 
1301
_GL_CXXALIAS_SYS (log10, double, (double x));
 
1302
# endif
 
1303
_GL_CXXALIASWARN (log10);
 
1304
#elif defined GNULIB_POSIXCHECK
 
1305
# undef log10
 
1306
# if HAVE_RAW_DECL_LOG10
 
1307
_GL_WARN_ON_USE (log10, "log10 has portability problems - "
 
1308
                 "use gnulib module log10 for portability");
 
1309
# endif
 
1310
#endif
 
1311
 
 
1312
#if @GNULIB_LOG10L@
 
1313
# if @REPLACE_LOG10L@
 
1314
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1315
#   undef log10l
 
1316
#   define log10l rpl_log10l
 
1317
#  endif
 
1318
_GL_FUNCDECL_RPL (log10l, long double, (long double x));
 
1319
_GL_CXXALIAS_RPL (log10l, long double, (long double x));
 
1320
# else
 
1321
#  if !@HAVE_LOG10L@ || !@HAVE_DECL_LOG10L@
 
1322
#   undef log10l
 
1323
_GL_FUNCDECL_SYS (log10l, long double, (long double x));
 
1324
#  endif
 
1325
_GL_CXXALIAS_SYS (log10l, long double, (long double x));
 
1326
# endif
 
1327
_GL_CXXALIASWARN (log10l);
 
1328
#elif defined GNULIB_POSIXCHECK
 
1329
# undef log10l
 
1330
# if HAVE_RAW_DECL_LOG10L
 
1331
_GL_WARN_ON_USE (log10l, "log10l is unportable - "
 
1332
                 "use gnulib module log10l for portability");
 
1333
# endif
 
1334
#endif
 
1335
 
 
1336
 
 
1337
#if @GNULIB_LOG1PF@
 
1338
# if @REPLACE_LOG1PF@
 
1339
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1340
#   undef log1pf
 
1341
#   define log1pf rpl_log1pf
 
1342
#  endif
 
1343
_GL_FUNCDECL_RPL (log1pf, float, (float x));
 
1344
_GL_CXXALIAS_RPL (log1pf, float, (float x));
 
1345
# else
 
1346
#  if !@HAVE_LOG1PF@
 
1347
_GL_FUNCDECL_SYS (log1pf, float, (float x));
 
1348
#  endif
 
1349
_GL_CXXALIAS_SYS (log1pf, float, (float x));
 
1350
# endif
 
1351
_GL_CXXALIASWARN (log1pf);
 
1352
#elif defined GNULIB_POSIXCHECK
 
1353
# undef log1pf
 
1354
# if HAVE_RAW_DECL_LOG1PF
 
1355
_GL_WARN_ON_USE (log1pf, "log1pf is unportable - "
 
1356
                 "use gnulib module log1pf for portability");
 
1357
# endif
 
1358
#endif
 
1359
 
 
1360
#if @GNULIB_LOG1P@
 
1361
# if @REPLACE_LOG1P@
 
1362
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1363
#   undef log1p
 
1364
#   define log1p rpl_log1p
 
1365
#  endif
 
1366
_GL_FUNCDECL_RPL (log1p, double, (double x));
 
1367
_GL_CXXALIAS_RPL (log1p, double, (double x));
 
1368
# else
 
1369
#  if !@HAVE_LOG1P@
 
1370
_GL_FUNCDECL_SYS (log1p, double, (double x));
 
1371
#  endif
 
1372
_GL_CXXALIAS_SYS (log1p, double, (double x));
 
1373
# endif
 
1374
_GL_CXXALIASWARN (log1p);
 
1375
#elif defined GNULIB_POSIXCHECK
 
1376
# undef log1p
 
1377
# if HAVE_RAW_DECL_LOG1P
 
1378
_GL_WARN_ON_USE (log1p, "log1p has portability problems - "
 
1379
                 "use gnulib module log1p for portability");
 
1380
# endif
 
1381
#endif
 
1382
 
 
1383
#if @GNULIB_LOG1PL@
 
1384
# if @REPLACE_LOG1PL@
 
1385
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1386
#   undef log1pl
 
1387
#   define log1pl rpl_log1pl
 
1388
#  endif
 
1389
_GL_FUNCDECL_RPL (log1pl, long double, (long double x));
 
1390
_GL_CXXALIAS_RPL (log1pl, long double, (long double x));
 
1391
# else
 
1392
#  if !@HAVE_LOG1PL@
 
1393
_GL_FUNCDECL_SYS (log1pl, long double, (long double x));
 
1394
#  endif
 
1395
_GL_CXXALIAS_SYS (log1pl, long double, (long double x));
 
1396
# endif
 
1397
_GL_CXXALIASWARN (log1pl);
 
1398
#elif defined GNULIB_POSIXCHECK
 
1399
# undef log1pl
 
1400
# if HAVE_RAW_DECL_LOG1PL
 
1401
_GL_WARN_ON_USE (log1pl, "log1pl has portability problems - "
 
1402
                 "use gnulib module log1pl for portability");
 
1403
# endif
 
1404
#endif
 
1405
 
 
1406
 
 
1407
#if @GNULIB_LOG2F@
 
1408
# if @REPLACE_LOG2F@
 
1409
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1410
#   undef log2f
 
1411
#   define log2f rpl_log2f
 
1412
#  endif
 
1413
_GL_FUNCDECL_RPL (log2f, float, (float x));
 
1414
_GL_CXXALIAS_RPL (log2f, float, (float x));
 
1415
# else
 
1416
#  if !@HAVE_DECL_LOG2F@
 
1417
#   undef log2f
 
1418
_GL_FUNCDECL_SYS (log2f, float, (float x));
 
1419
#  endif
 
1420
_GL_CXXALIAS_SYS (log2f, float, (float x));
 
1421
# endif
 
1422
_GL_CXXALIASWARN (log2f);
 
1423
#elif defined GNULIB_POSIXCHECK
 
1424
# undef log2f
 
1425
# if HAVE_RAW_DECL_LOG2F
 
1426
_GL_WARN_ON_USE (log2f, "log2f is unportable - "
 
1427
                 "use gnulib module log2f for portability");
 
1428
# endif
 
1429
#endif
 
1430
 
 
1431
#if @GNULIB_LOG2@
 
1432
# if @REPLACE_LOG2@
 
1433
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1434
#   undef log2
 
1435
#   define log2 rpl_log2
 
1436
#  endif
 
1437
_GL_FUNCDECL_RPL (log2, double, (double x));
 
1438
_GL_CXXALIAS_RPL (log2, double, (double x));
 
1439
# else
 
1440
#  if !@HAVE_DECL_LOG2@
 
1441
#   undef log2
 
1442
_GL_FUNCDECL_SYS (log2, double, (double x));
 
1443
#  endif
 
1444
_GL_CXXALIAS_SYS (log2, double, (double x));
 
1445
# endif
 
1446
_GL_CXXALIASWARN (log2);
 
1447
#elif defined GNULIB_POSIXCHECK
 
1448
# undef log2
 
1449
# if HAVE_RAW_DECL_LOG2
 
1450
_GL_WARN_ON_USE (log2, "log2 is unportable - "
 
1451
                 "use gnulib module log2 for portability");
 
1452
# endif
 
1453
#endif
 
1454
 
 
1455
#if @GNULIB_LOG2L@
 
1456
# if @REPLACE_LOG2L@
 
1457
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1458
#   undef log2l
 
1459
#   define log2l rpl_log2l
 
1460
#  endif
 
1461
_GL_FUNCDECL_RPL (log2l, long double, (long double x));
 
1462
_GL_CXXALIAS_RPL (log2l, long double, (long double x));
 
1463
# else
 
1464
#  if !@HAVE_DECL_LOG2L@
 
1465
_GL_FUNCDECL_SYS (log2l, long double, (long double x));
 
1466
#  endif
 
1467
_GL_CXXALIAS_SYS (log2l, long double, (long double x));
 
1468
# endif
 
1469
_GL_CXXALIASWARN (log2l);
 
1470
#elif defined GNULIB_POSIXCHECK
 
1471
# undef log2l
 
1472
# if HAVE_RAW_DECL_LOG2L
 
1473
_GL_WARN_ON_USE (log2l, "log2l is unportable - "
 
1474
                 "use gnulib module log2l for portability");
 
1475
# endif
 
1476
#endif
 
1477
 
 
1478
 
 
1479
#if @GNULIB_LOGBF@
 
1480
# if @REPLACE_LOGBF@
 
1481
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1482
#   undef logbf
 
1483
#   define logbf rpl_logbf
 
1484
#  endif
 
1485
_GL_FUNCDECL_RPL (logbf, float, (float x));
 
1486
_GL_CXXALIAS_RPL (logbf, float, (float x));
 
1487
# else
 
1488
#  if !@HAVE_LOGBF@
 
1489
_GL_FUNCDECL_SYS (logbf, float, (float x));
 
1490
#  endif
 
1491
_GL_CXXALIAS_SYS (logbf, float, (float x));
 
1492
# endif
 
1493
_GL_CXXALIASWARN (logbf);
 
1494
#elif defined GNULIB_POSIXCHECK
 
1495
# undef logbf
 
1496
# if HAVE_RAW_DECL_LOGBF
 
1497
_GL_WARN_ON_USE (logbf, "logbf is unportable - "
 
1498
                 "use gnulib module logbf for portability");
 
1499
# endif
 
1500
#endif
 
1501
 
 
1502
#if @GNULIB_LOGB@
 
1503
# if @REPLACE_LOGB@
 
1504
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1505
#   undef logb
 
1506
#   define logb rpl_logb
 
1507
#  endif
 
1508
_GL_FUNCDECL_RPL (logb, double, (double x));
 
1509
_GL_CXXALIAS_RPL (logb, double, (double x));
 
1510
# else
 
1511
#  if !@HAVE_DECL_LOGB@
 
1512
_GL_FUNCDECL_SYS (logb, double, (double x));
 
1513
#  endif
 
1514
_GL_CXXALIAS_SYS (logb, double, (double x));
 
1515
# endif
 
1516
_GL_CXXALIASWARN (logb);
 
1517
#elif defined GNULIB_POSIXCHECK
 
1518
# undef logb
 
1519
# if HAVE_RAW_DECL_LOGB
 
1520
_GL_WARN_ON_USE (logb, "logb is unportable - "
 
1521
                 "use gnulib module logb for portability");
 
1522
# endif
 
1523
#endif
 
1524
 
 
1525
#if @GNULIB_LOGBL@
 
1526
# if @REPLACE_LOGBL@
 
1527
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1528
#   undef logbl
 
1529
#   define logbl rpl_logbl
 
1530
#  endif
 
1531
_GL_FUNCDECL_RPL (logbl, long double, (long double x));
 
1532
_GL_CXXALIAS_RPL (logbl, long double, (long double x));
 
1533
# else
 
1534
#  if !@HAVE_LOGBL@
 
1535
_GL_FUNCDECL_SYS (logbl, long double, (long double x));
 
1536
#  endif
 
1537
_GL_CXXALIAS_SYS (logbl, long double, (long double x));
 
1538
# endif
 
1539
_GL_CXXALIASWARN (logbl);
 
1540
#elif defined GNULIB_POSIXCHECK
 
1541
# undef logbl
 
1542
# if HAVE_RAW_DECL_LOGBL
 
1543
_GL_WARN_ON_USE (logbl, "logbl is unportable - "
 
1544
                 "use gnulib module logbl for portability");
 
1545
# endif
 
1546
#endif
 
1547
 
 
1548
 
 
1549
#if @GNULIB_MODFF@
 
1550
# if @REPLACE_MODFF@
 
1551
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1552
#   undef modff
 
1553
#   define modff rpl_modff
 
1554
#  endif
 
1555
_GL_FUNCDECL_RPL (modff, float, (float x, float *iptr) _GL_ARG_NONNULL ((2)));
 
1556
_GL_CXXALIAS_RPL (modff, float, (float x, float *iptr));
 
1557
# else
 
1558
#  if !@HAVE_MODFF@
 
1559
#   undef modff
 
1560
_GL_FUNCDECL_SYS (modff, float, (float x, float *iptr) _GL_ARG_NONNULL ((2)));
 
1561
#  endif
 
1562
_GL_CXXALIAS_SYS (modff, float, (float x, float *iptr));
 
1563
# endif
 
1564
_GL_CXXALIASWARN (modff);
 
1565
#elif defined GNULIB_POSIXCHECK
 
1566
# undef modff
 
1567
# if HAVE_RAW_DECL_MODFF
 
1568
_GL_WARN_ON_USE (modff, "modff is unportable - "
 
1569
                 "use gnulib module modff for portability");
 
1570
# endif
 
1571
#endif
 
1572
 
 
1573
#if @GNULIB_MODF@
 
1574
# if @REPLACE_MODF@
 
1575
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1576
#   undef modf
 
1577
#   define modf rpl_modf
 
1578
#  endif
 
1579
_GL_FUNCDECL_RPL (modf, double, (double x, double *iptr) _GL_ARG_NONNULL ((2)));
 
1580
_GL_CXXALIAS_RPL (modf, double, (double x, double *iptr));
 
1581
# else
 
1582
_GL_CXXALIAS_SYS (modf, double, (double x, double *iptr));
 
1583
# endif
 
1584
_GL_CXXALIASWARN (modf);
 
1585
#elif defined GNULIB_POSIXCHECK
 
1586
# undef modf
 
1587
# if HAVE_RAW_DECL_MODF
 
1588
_GL_WARN_ON_USE (modf, "modf has portability problems - "
 
1589
                 "use gnulib module modf for portability");
 
1590
# endif
 
1591
#endif
 
1592
 
 
1593
#if @GNULIB_MODFL@
 
1594
# if @REPLACE_MODFL@
 
1595
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1596
#   undef modfl
 
1597
#   define modfl rpl_modfl
 
1598
#  endif
 
1599
_GL_FUNCDECL_RPL (modfl, long double, (long double x, long double *iptr)
 
1600
                                      _GL_ARG_NONNULL ((2)));
 
1601
_GL_CXXALIAS_RPL (modfl, long double, (long double x, long double *iptr));
 
1602
# else
 
1603
#  if !@HAVE_MODFL@
 
1604
#   undef modfl
 
1605
_GL_FUNCDECL_SYS (modfl, long double, (long double x, long double *iptr)
 
1606
                                      _GL_ARG_NONNULL ((2)));
 
1607
#  endif
 
1608
_GL_CXXALIAS_SYS (modfl, long double, (long double x, long double *iptr));
 
1609
# endif
 
1610
_GL_CXXALIASWARN (modfl);
 
1611
#elif defined GNULIB_POSIXCHECK
 
1612
# undef modfl
 
1613
# if HAVE_RAW_DECL_MODFL
 
1614
_GL_WARN_ON_USE (modfl, "modfl is unportable - "
 
1615
                 "use gnulib module modfl for portability");
 
1616
# endif
 
1617
#endif
 
1618
 
 
1619
 
 
1620
#if @GNULIB_POWF@
 
1621
# if !@HAVE_POWF@
 
1622
#  undef powf
 
1623
_GL_FUNCDECL_SYS (powf, float, (float x, float y));
 
1624
# endif
 
1625
_GL_CXXALIAS_SYS (powf, float, (float x, float y));
 
1626
_GL_CXXALIASWARN (powf);
 
1627
#elif defined GNULIB_POSIXCHECK
 
1628
# undef powf
 
1629
# if HAVE_RAW_DECL_POWF
 
1630
_GL_WARN_ON_USE (powf, "powf is unportable - "
 
1631
                 "use gnulib module powf for portability");
 
1632
# endif
 
1633
#endif
 
1634
 
 
1635
 
 
1636
#if @GNULIB_REMAINDERF@
 
1637
# if @REPLACE_REMAINDERF@
 
1638
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1639
#   undef remainderf
 
1640
#   define remainderf rpl_remainderf
 
1641
#  endif
 
1642
_GL_FUNCDECL_RPL (remainderf, float, (float x, float y));
 
1643
_GL_CXXALIAS_RPL (remainderf, float, (float x, float y));
 
1644
# else
 
1645
#  if !@HAVE_REMAINDERF@
 
1646
_GL_FUNCDECL_SYS (remainderf, float, (float x, float y));
 
1647
#  endif
 
1648
_GL_CXXALIAS_SYS (remainderf, float, (float x, float y));
 
1649
# endif
 
1650
_GL_CXXALIASWARN (remainderf);
 
1651
#elif defined GNULIB_POSIXCHECK
 
1652
# undef remainderf
 
1653
# if HAVE_RAW_DECL_REMAINDERF
 
1654
_GL_WARN_ON_USE (remainderf, "remainderf is unportable - "
 
1655
                 "use gnulib module remainderf for portability");
 
1656
# endif
 
1657
#endif
 
1658
 
 
1659
#if @GNULIB_REMAINDER@
 
1660
# if @REPLACE_REMAINDER@
 
1661
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1662
#   undef remainder
 
1663
#   define remainder rpl_remainder
 
1664
#  endif
 
1665
_GL_FUNCDECL_RPL (remainder, double, (double x, double y));
 
1666
_GL_CXXALIAS_RPL (remainder, double, (double x, double y));
 
1667
# else
 
1668
#  if !@HAVE_REMAINDER@ || !@HAVE_DECL_REMAINDER@
 
1669
_GL_FUNCDECL_SYS (remainder, double, (double x, double y));
 
1670
#  endif
 
1671
_GL_CXXALIAS_SYS (remainder, double, (double x, double y));
 
1672
# endif
 
1673
_GL_CXXALIASWARN (remainder);
 
1674
#elif defined GNULIB_POSIXCHECK
 
1675
# undef remainder
 
1676
# if HAVE_RAW_DECL_REMAINDER
 
1677
_GL_WARN_ON_USE (remainder, "remainder is unportable - "
 
1678
                 "use gnulib module remainder for portability");
 
1679
# endif
 
1680
#endif
 
1681
 
 
1682
#if @GNULIB_REMAINDERL@
 
1683
# if @REPLACE_REMAINDERL@
 
1684
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1685
#   undef remainderl
 
1686
#   define remainderl rpl_remainderl
 
1687
#  endif
 
1688
_GL_FUNCDECL_RPL (remainderl, long double, (long double x, long double y));
 
1689
_GL_CXXALIAS_RPL (remainderl, long double, (long double x, long double y));
 
1690
# else
 
1691
#  if !@HAVE_DECL_REMAINDERL@
 
1692
#   undef remainderl
 
1693
_GL_FUNCDECL_SYS (remainderl, long double, (long double x, long double y));
 
1694
#  endif
 
1695
_GL_CXXALIAS_SYS (remainderl, long double, (long double x, long double y));
 
1696
# endif
 
1697
_GL_CXXALIASWARN (remainderl);
 
1698
#elif defined GNULIB_POSIXCHECK
 
1699
# undef remainderl
 
1700
# if HAVE_RAW_DECL_REMAINDERL
 
1701
_GL_WARN_ON_USE (remainderl, "remainderl is unportable - "
 
1702
                 "use gnulib module remainderl for portability");
 
1703
# endif
 
1704
#endif
 
1705
 
 
1706
 
 
1707
#if @GNULIB_RINTF@
 
1708
# if !@HAVE_DECL_RINTF@
 
1709
_GL_FUNCDECL_SYS (rintf, float, (float x));
 
1710
# endif
 
1711
_GL_CXXALIAS_SYS (rintf, float, (float x));
 
1712
_GL_CXXALIASWARN (rintf);
 
1713
#elif defined GNULIB_POSIXCHECK
 
1714
# undef rintf
 
1715
# if HAVE_RAW_DECL_RINTF
 
1716
_GL_WARN_ON_USE (rintf, "rintf is unportable - "
 
1717
                 "use gnulib module rintf for portability");
 
1718
# endif
 
1719
#endif
 
1720
 
 
1721
#if @GNULIB_RINT@
 
1722
# if !@HAVE_RINT@
 
1723
_GL_FUNCDECL_SYS (rint, double, (double x));
 
1724
# endif
 
1725
_GL_CXXALIAS_SYS (rint, double, (double x));
 
1726
_GL_CXXALIASWARN (rint);
 
1727
#elif defined GNULIB_POSIXCHECK
 
1728
# undef rint
 
1729
# if HAVE_RAW_DECL_RINT
 
1730
_GL_WARN_ON_USE (rint, "rint is unportable - "
 
1731
                 "use gnulib module rint for portability");
 
1732
# endif
 
1733
#endif
 
1734
 
 
1735
#if @GNULIB_RINTL@
 
1736
# if !@HAVE_RINTL@
 
1737
_GL_FUNCDECL_SYS (rintl, long double, (long double x));
 
1738
# endif
 
1739
_GL_CXXALIAS_SYS (rintl, long double, (long double x));
 
1740
_GL_CXXALIASWARN (rintl);
 
1741
#elif defined GNULIB_POSIXCHECK
 
1742
# undef rintl
 
1743
# if HAVE_RAW_DECL_RINTL
 
1744
_GL_WARN_ON_USE (rintl, "rintl is unportable - "
 
1745
                 "use gnulib module rintl for portability");
375
1746
# endif
376
1747
#endif
377
1748
 
432
1803
_GL_CXXALIAS_RPL (roundl, long double, (long double x));
433
1804
# else
434
1805
#  if !@HAVE_DECL_ROUNDL@
 
1806
#   undef roundl
435
1807
_GL_FUNCDECL_SYS (roundl, long double, (long double x));
436
1808
#  endif
437
1809
_GL_CXXALIAS_SYS (roundl, long double, (long double x));
446
1818
#endif
447
1819
 
448
1820
 
 
1821
#if @GNULIB_SINF@
 
1822
# if !@HAVE_SINF@
 
1823
#  undef sinf
 
1824
_GL_FUNCDECL_SYS (sinf, float, (float x));
 
1825
# endif
 
1826
_GL_CXXALIAS_SYS (sinf, float, (float x));
 
1827
_GL_CXXALIASWARN (sinf);
 
1828
#elif defined GNULIB_POSIXCHECK
 
1829
# undef sinf
 
1830
# if HAVE_RAW_DECL_SINF
 
1831
_GL_WARN_ON_USE (sinf, "sinf is unportable - "
 
1832
                 "use gnulib module sinf for portability");
 
1833
# endif
 
1834
#endif
 
1835
 
449
1836
#if @GNULIB_SINL@
450
1837
# if !@HAVE_SINL@ || !@HAVE_DECL_SINL@
 
1838
#  undef sinl
451
1839
_GL_FUNCDECL_SYS (sinl, long double, (long double x));
452
1840
# endif
453
1841
_GL_CXXALIAS_SYS (sinl, long double, (long double x));
456
1844
# undef sinl
457
1845
# if HAVE_RAW_DECL_SINL
458
1846
_GL_WARN_ON_USE (sinl, "sinl is unportable - "
459
 
                 "use gnulib module mathl for portability");
460
 
# endif
461
 
#endif
462
 
 
 
1847
                 "use gnulib module sinl for portability");
 
1848
# endif
 
1849
#endif
 
1850
 
 
1851
 
 
1852
#if @GNULIB_SINHF@
 
1853
# if !@HAVE_SINHF@
 
1854
#  undef sinhf
 
1855
_GL_FUNCDECL_SYS (sinhf, float, (float x));
 
1856
# endif
 
1857
_GL_CXXALIAS_SYS (sinhf, float, (float x));
 
1858
_GL_CXXALIASWARN (sinhf);
 
1859
#elif defined GNULIB_POSIXCHECK
 
1860
# undef sinhf
 
1861
# if HAVE_RAW_DECL_SINHF
 
1862
_GL_WARN_ON_USE (sinhf, "sinhf is unportable - "
 
1863
                 "use gnulib module sinhf for portability");
 
1864
# endif
 
1865
#endif
 
1866
 
 
1867
 
 
1868
#if @GNULIB_SQRTF@
 
1869
# if !@HAVE_SQRTF@
 
1870
#  undef sqrtf
 
1871
_GL_FUNCDECL_SYS (sqrtf, float, (float x));
 
1872
# endif
 
1873
_GL_CXXALIAS_SYS (sqrtf, float, (float x));
 
1874
_GL_CXXALIASWARN (sqrtf);
 
1875
#elif defined GNULIB_POSIXCHECK
 
1876
# undef sqrtf
 
1877
# if HAVE_RAW_DECL_SQRTF
 
1878
_GL_WARN_ON_USE (sqrtf, "sqrtf is unportable - "
 
1879
                 "use gnulib module sqrtf for portability");
 
1880
# endif
 
1881
#endif
463
1882
 
464
1883
#if @GNULIB_SQRTL@
465
 
# if !@HAVE_SQRTL@ || !@HAVE_DECL_SQRTL@
 
1884
# if @REPLACE_SQRTL@
 
1885
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1886
#   undef sqrtl
 
1887
#   define sqrtl rpl_sqrtl
 
1888
#  endif
 
1889
_GL_FUNCDECL_RPL (sqrtl, long double, (long double x));
 
1890
_GL_CXXALIAS_RPL (sqrtl, long double, (long double x));
 
1891
# else
 
1892
#  if !@HAVE_SQRTL@ || !@HAVE_DECL_SQRTL@
 
1893
#   undef sqrtl
466
1894
_GL_FUNCDECL_SYS (sqrtl, long double, (long double x));
467
 
# endif
 
1895
#  endif
468
1896
_GL_CXXALIAS_SYS (sqrtl, long double, (long double x));
 
1897
# endif
469
1898
_GL_CXXALIASWARN (sqrtl);
470
1899
#elif defined GNULIB_POSIXCHECK
471
1900
# undef sqrtl
472
1901
# if HAVE_RAW_DECL_SQRTL
473
1902
_GL_WARN_ON_USE (sqrtl, "sqrtl is unportable - "
474
 
                 "use gnulib module mathl for portability");
475
 
# endif
476
 
#endif
477
 
 
 
1903
                 "use gnulib module sqrtl for portability");
 
1904
# endif
 
1905
#endif
 
1906
 
 
1907
 
 
1908
#if @GNULIB_TANF@
 
1909
# if !@HAVE_TANF@
 
1910
#  undef tanf
 
1911
_GL_FUNCDECL_SYS (tanf, float, (float x));
 
1912
# endif
 
1913
_GL_CXXALIAS_SYS (tanf, float, (float x));
 
1914
_GL_CXXALIASWARN (tanf);
 
1915
#elif defined GNULIB_POSIXCHECK
 
1916
# undef tanf
 
1917
# if HAVE_RAW_DECL_TANF
 
1918
_GL_WARN_ON_USE (tanf, "tanf is unportable - "
 
1919
                 "use gnulib module tanf for portability");
 
1920
# endif
 
1921
#endif
478
1922
 
479
1923
#if @GNULIB_TANL@
480
1924
# if !@HAVE_TANL@ || !@HAVE_DECL_TANL@
 
1925
#  undef tanl
481
1926
_GL_FUNCDECL_SYS (tanl, long double, (long double x));
482
1927
# endif
483
1928
_GL_CXXALIAS_SYS (tanl, long double, (long double x));
486
1931
# undef tanl
487
1932
# if HAVE_RAW_DECL_TANL
488
1933
_GL_WARN_ON_USE (tanl, "tanl is unportable - "
489
 
                 "use gnulib module mathl for portability");
 
1934
                 "use gnulib module tanl for portability");
 
1935
# endif
 
1936
#endif
 
1937
 
 
1938
 
 
1939
#if @GNULIB_TANHF@
 
1940
# if !@HAVE_TANHF@
 
1941
#  undef tanhf
 
1942
_GL_FUNCDECL_SYS (tanhf, float, (float x));
 
1943
# endif
 
1944
_GL_CXXALIAS_SYS (tanhf, float, (float x));
 
1945
_GL_CXXALIASWARN (tanhf);
 
1946
#elif defined GNULIB_POSIXCHECK
 
1947
# undef tanhf
 
1948
# if HAVE_RAW_DECL_TANHF
 
1949
_GL_WARN_ON_USE (tanhf, "tanhf is unportable - "
 
1950
                 "use gnulib module tanhf for portability");
490
1951
# endif
491
1952
#endif
492
1953
 
493
1954
 
494
1955
#if @GNULIB_TRUNCF@
495
 
# if !@HAVE_DECL_TRUNCF@
 
1956
# if @REPLACE_TRUNCF@
 
1957
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1958
#   define truncf rpl_truncf
 
1959
#  endif
 
1960
_GL_FUNCDECL_RPL (truncf, float, (float x));
 
1961
_GL_CXXALIAS_RPL (truncf, float, (float x));
 
1962
# else
 
1963
#  if !@HAVE_DECL_TRUNCF@
496
1964
_GL_FUNCDECL_SYS (truncf, float, (float x));
497
 
# endif
 
1965
#  endif
498
1966
_GL_CXXALIAS_SYS (truncf, float, (float x));
 
1967
# endif
499
1968
_GL_CXXALIASWARN (truncf);
500
1969
#elif defined GNULIB_POSIXCHECK
501
1970
# undef truncf
506
1975
#endif
507
1976
 
508
1977
#if @GNULIB_TRUNC@
509
 
# if !@HAVE_DECL_TRUNC@
 
1978
# if @REPLACE_TRUNC@
 
1979
#  if !(defined __cplusplus && defined GNULIB_NAMESPACE)
 
1980
#   define trunc rpl_trunc
 
1981
#  endif
 
1982
_GL_FUNCDECL_RPL (trunc, double, (double x));
 
1983
_GL_CXXALIAS_RPL (trunc, double, (double x));
 
1984
# else
 
1985
#  if !@HAVE_DECL_TRUNC@
510
1986
_GL_FUNCDECL_SYS (trunc, double, (double x));
511
 
# endif
 
1987
#  endif
512
1988
_GL_CXXALIAS_SYS (trunc, double, (double x));
 
1989
# endif
513
1990
_GL_CXXALIASWARN (trunc);
514
1991
#elif defined GNULIB_POSIXCHECK
515
1992
# undef trunc
543
2020
#endif
544
2021
 
545
2022
 
 
2023
/* Definitions of function-like macros come here, after the function
 
2024
   declarations.  */
 
2025
 
 
2026
 
546
2027
#if @GNULIB_ISFINITE@
547
2028
# if @REPLACE_ISFINITE@
548
2029
_GL_EXTERN_C int gl_isfinitef (float x);
554
2035
    sizeof (x) == sizeof (double) ? gl_isfinited (x) : \
555
2036
    gl_isfinitef (x))
556
2037
# endif
 
2038
# ifdef __cplusplus
 
2039
#  ifdef isfinite
 
2040
_GL_MATH_CXX_REAL_FLOATING_DECL_1 (isfinite)
 
2041
#   undef isfinite
 
2042
_GL_MATH_CXX_REAL_FLOATING_DECL_2 (isfinite)
 
2043
#  endif
 
2044
# endif
557
2045
#elif defined GNULIB_POSIXCHECK
558
2046
# if defined isfinite
559
2047
_GL_WARN_REAL_FLOATING_DECL (isfinite);
574
2062
    sizeof (x) == sizeof (double) ? gl_isinfd (x) : \
575
2063
    gl_isinff (x))
576
2064
# endif
 
2065
# ifdef __cplusplus
 
2066
#  ifdef isinf
 
2067
_GL_MATH_CXX_REAL_FLOATING_DECL_1 (isinf)
 
2068
#   undef isinf
 
2069
_GL_MATH_CXX_REAL_FLOATING_DECL_2 (isinf)
 
2070
#  endif
 
2071
# endif
577
2072
#elif defined GNULIB_POSIXCHECK
578
2073
# if defined isinf
579
2074
_GL_WARN_REAL_FLOATING_DECL (isinf);
609
2104
   This function is a gnulib extension, unlike isnan() which applied only
610
2105
   to 'double' numbers earlier but now is a type-generic macro.  */
611
2106
# if @HAVE_ISNAND@
612
 
/* The original <math.h> included above provides a declaration of isnan macro.  */
 
2107
/* The original <math.h> included above provides a declaration of isnan
 
2108
   macro.  */
613
2109
#  if __GNUC__ >= 4
614
2110
    /* GCC 4.0 and newer provides three built-ins for isnan.  */
615
2111
#   undef isnand
629
2125
#if @GNULIB_ISNANL@
630
2126
/* Test for NaN for 'long double' numbers.  */
631
2127
# if @HAVE_ISNANL@
632
 
/* The original <math.h> included above provides a declaration of isnan macro or (older) isnanl function.  */
 
2128
/* The original <math.h> included above provides a declaration of isnan
 
2129
   macro or (older) isnanl function.  */
633
2130
#  if __GNUC__ >= 4
634
2131
    /* GCC 4.0 and newer provides three built-ins for isnan.  */
635
2132
#   undef isnanl
642
2139
/* Test whether X is a NaN.  */
643
2140
#  undef isnanl
644
2141
#  define isnanl rpl_isnanl
645
 
_GL_EXTERN_C int isnanl (long double x);
 
2142
_GL_EXTERN_C int isnanl (long double x) _GL_ATTRIBUTE_CONST;
646
2143
# endif
647
2144
#endif
648
2145
 
654
2151
   that recursively expand back to isnan.  So use the gnulib
655
2152
   replacements for them directly. */
656
2153
#  if @HAVE_ISNANF@ && __GNUC__ >= 4
657
 
#   define gl_isnan_f(x) __builtin_isnan ((float)(x))
 
2154
#   define gl_isnan_f(x) __builtin_isnanf ((float)(x))
658
2155
#  else
659
2156
_GL_EXTERN_C int rpl_isnanf (float x);
660
2157
#   define gl_isnan_f(x) rpl_isnanf (x)
666
2163
#   define gl_isnan_d(x) rpl_isnand (x)
667
2164
#  endif
668
2165
#  if @HAVE_ISNANL@ && __GNUC__ >= 4
669
 
#   define gl_isnan_l(x) __builtin_isnan ((long double)(x))
 
2166
#   define gl_isnan_l(x) __builtin_isnanl ((long double)(x))
670
2167
#  else
671
 
_GL_EXTERN_C int rpl_isnanl (long double x);
 
2168
_GL_EXTERN_C int rpl_isnanl (long double x) _GL_ATTRIBUTE_CONST;
672
2169
#   define gl_isnan_l(x) rpl_isnanl (x)
673
2170
#  endif
674
2171
#  undef isnan
676
2173
   (sizeof (x) == sizeof (long double) ? gl_isnan_l (x) : \
677
2174
    sizeof (x) == sizeof (double) ? gl_isnan_d (x) : \
678
2175
    gl_isnan_f (x))
 
2176
# elif __GNUC__ >= 4
 
2177
#  undef isnan
 
2178
#  define isnan(x) \
 
2179
   (sizeof (x) == sizeof (long double) ? __builtin_isnanl ((long double)(x)) : \
 
2180
    sizeof (x) == sizeof (double) ? __builtin_isnan ((double)(x)) : \
 
2181
    __builtin_isnanf ((float)(x)))
 
2182
# endif
 
2183
# ifdef __cplusplus
 
2184
#  ifdef isnan
 
2185
_GL_MATH_CXX_REAL_FLOATING_DECL_1 (isnan)
 
2186
#   undef isnan
 
2187
_GL_MATH_CXX_REAL_FLOATING_DECL_2 (isnan)
 
2188
#  endif
 
2189
# else
 
2190
/* Ensure isnan is a macro.  */
 
2191
#  ifndef isnan
 
2192
#   define isnan isnan
 
2193
#  endif
679
2194
# endif
680
2195
#elif defined GNULIB_POSIXCHECK
681
2196
# if defined isnan
700
2215
_GL_EXTERN_C int gl_signbitf (float arg);
701
2216
_GL_EXTERN_C int gl_signbitd (double arg);
702
2217
_GL_EXTERN_C int gl_signbitl (long double arg);
703
 
#  if __GNUC__ >= 2 && !__STRICT_ANSI__
 
2218
#  if __GNUC__ >= 2 && !defined __STRICT_ANSI__
 
2219
#   define _GL_NUM_UINT_WORDS(type) \
 
2220
      ((sizeof (type) + sizeof (unsigned int) - 1) / sizeof (unsigned int))
704
2221
#   if defined FLT_SIGNBIT_WORD && defined FLT_SIGNBIT_BIT && !defined gl_signbitf
705
2222
#    define gl_signbitf_OPTIMIZED_MACRO
706
2223
#    define gl_signbitf(arg) \
707
2224
       ({ union { float _value;                                         \
708
 
                  unsigned int _word[(sizeof (float) + sizeof (unsigned int) - 1) / sizeof (unsigned int)]; \
 
2225
                  unsigned int _word[_GL_NUM_UINT_WORDS (float)];       \
709
2226
                } _m;                                                   \
710
2227
          _m._value = (arg);                                            \
711
2228
          (_m._word[FLT_SIGNBIT_WORD] >> FLT_SIGNBIT_BIT) & 1;          \
714
2231
#   if defined DBL_SIGNBIT_WORD && defined DBL_SIGNBIT_BIT && !defined gl_signbitd
715
2232
#    define gl_signbitd_OPTIMIZED_MACRO
716
2233
#    define gl_signbitd(arg) \
717
 
       ({ union { double _value;                                                \
718
 
                  unsigned int _word[(sizeof (double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)]; \
 
2234
       ({ union { double _value;                                        \
 
2235
                  unsigned int _word[_GL_NUM_UINT_WORDS (double)];      \
719
2236
                } _m;                                                   \
720
2237
          _m._value = (arg);                                            \
721
2238
          (_m._word[DBL_SIGNBIT_WORD] >> DBL_SIGNBIT_BIT) & 1;          \
725
2242
#    define gl_signbitl_OPTIMIZED_MACRO
726
2243
#    define gl_signbitl(arg) \
727
2244
       ({ union { long double _value;                                   \
728
 
                  unsigned int _word[(sizeof (long double) + sizeof (unsigned int) - 1) / sizeof (unsigned int)]; \
 
2245
                  unsigned int _word[_GL_NUM_UINT_WORDS (long double)]; \
729
2246
                } _m;                                                   \
730
2247
          _m._value = (arg);                                            \
731
 
          (_m._word[LDBL_SIGNBIT_WORD] >> LDBL_SIGNBIT_BIT) & 1;                \
 
2248
          (_m._word[LDBL_SIGNBIT_WORD] >> LDBL_SIGNBIT_BIT) & 1;        \
732
2249
        })
733
2250
#   endif
734
2251
#  endif
737
2254
    sizeof (x) == sizeof (double) ? gl_signbitd (x) : \
738
2255
    gl_signbitf (x))
739
2256
# endif
 
2257
# ifdef __cplusplus
 
2258
#  ifdef signbit
 
2259
_GL_MATH_CXX_REAL_FLOATING_DECL_1 (signbit)
 
2260
#   undef signbit
 
2261
_GL_MATH_CXX_REAL_FLOATING_DECL_2 (signbit)
 
2262
#  endif
 
2263
# endif
740
2264
#elif defined GNULIB_POSIXCHECK
741
2265
# if defined signbit
742
2266
_GL_WARN_REAL_FLOATING_DECL (signbit);
745
2269
# endif
746
2270
#endif
747
2271
 
 
2272
_GL_INLINE_HEADER_END
748
2273
 
749
 
#endif /* _GL_MATH_H */
750
 
#endif /* _GL_MATH_H */
 
2274
#endif /* _@GUARD_PREFIX@_MATH_H */
 
2275
#endif /* _@GUARD_PREFIX@_MATH_H */