Edit File by line

[0] Fix | Delete

This file is part of the GNU C Library.

[1] Fix | Delete

[2] Fix | Delete

The GNU C Library is free software; you can redistribute it and/or

[3] Fix | Delete

modify it under the terms of the GNU Lesser General Public

[4] Fix | Delete

License as published by the Free Software Foundation; either

[5] Fix | Delete

version 2.1 of the License, or (at your option) any later version.

[6] Fix | Delete

[7] Fix | Delete

The GNU C Library is distributed in the hope that it will be useful,

[8] Fix | Delete

but WITHOUT ANY WARRANTY; without even the implied warranty of

[9] Fix | Delete

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

[10] Fix | Delete

Lesser General Public License for more details.

[11] Fix | Delete

[12] Fix | Delete

You should have received a copy of the GNU Lesser General Public

[13] Fix | Delete

License along with the GNU C Library; if not, see

[14] Fix | Delete

<http://www.gnu.org/licenses/>. */

[15] Fix | Delete

[16] Fix | Delete

[17] Fix | Delete

* ISO C99 Standard: 7.22 Type-generic math <tgmath.h>

[18] Fix | Delete

[19] Fix | Delete

[20] Fix | Delete

#ifndef _TGMATH_H

[21] Fix | Delete

#define _TGMATH_H 1

[22] Fix | Delete

[23] Fix | Delete

#define __GLIBC_INTERNAL_STARTING_HEADER_IMPLEMENTATION

[24] Fix | Delete

#include <bits/libc-header-start.h>

[25] Fix | Delete

[26] Fix | Delete

/* Include the needed headers. */

[27] Fix | Delete

#include <bits/floatn.h>

[28] Fix | Delete

#include <math.h>

[29] Fix | Delete

#include <complex.h>

[30] Fix | Delete

[31] Fix | Delete

[32] Fix | Delete

/* There are two variant implementations of type-generic macros in

[33] Fix | Delete

this file: one for GCC 8 and later, using __builtin_tgmath and

[34] Fix | Delete

where each macro expands each of its arguments only once, and one

[35] Fix | Delete

for older GCC, using other compiler extensions but with macros

[36] Fix | Delete

expanding their arguments many times (so resulting in exponential

[37] Fix | Delete

blowup of the size of expansions when calls to such macros are

[38] Fix | Delete

nested inside arguments to such macros). */

[39] Fix | Delete

[40] Fix | Delete

#define __HAVE_BUILTIN_TGMATH __GNUC_PREREQ (8, 0)

[41] Fix | Delete

[42] Fix | Delete

#if __GNUC_PREREQ (2, 7)

[43] Fix | Delete

[44] Fix | Delete

# if __HAVE_BUILTIN_TGMATH

[45] Fix | Delete

[46] Fix | Delete

# if __HAVE_FLOAT16 && __GLIBC_USE (IEC_60559_TYPES_EXT)

[47] Fix | Delete

# define __TG_F16_ARG(X) X ## f16,

[48] Fix | Delete

# else

[49] Fix | Delete

# define __TG_F16_ARG(X)

[50] Fix | Delete

# endif

[51] Fix | Delete

# if __HAVE_FLOAT32 && __GLIBC_USE (IEC_60559_TYPES_EXT)

[52] Fix | Delete

# define __TG_F32_ARG(X) X ## f32,

[53] Fix | Delete

# else

[54] Fix | Delete

# define __TG_F32_ARG(X)

[55] Fix | Delete

# endif

[56] Fix | Delete

# if __HAVE_FLOAT64 && __GLIBC_USE (IEC_60559_TYPES_EXT)

[57] Fix | Delete

# define __TG_F64_ARG(X) X ## f64,

[58] Fix | Delete

# else

[59] Fix | Delete

# define __TG_F64_ARG(X)

[60] Fix | Delete

# endif

[61] Fix | Delete

# if __HAVE_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT)

[62] Fix | Delete

# define __TG_F128_ARG(X) X ## f128,

[63] Fix | Delete

# else

[64] Fix | Delete

# define __TG_F128_ARG(X)

[65] Fix | Delete

# endif

[66] Fix | Delete

# if __HAVE_FLOAT32X && __GLIBC_USE (IEC_60559_TYPES_EXT)

[67] Fix | Delete

# define __TG_F32X_ARG(X) X ## f32x,

[68] Fix | Delete

# else

[69] Fix | Delete

# define __TG_F32X_ARG(X)

[70] Fix | Delete

# endif

[71] Fix | Delete

# if __HAVE_FLOAT64X && __GLIBC_USE (IEC_60559_TYPES_EXT)

[72] Fix | Delete

# define __TG_F64X_ARG(X) X ## f64x,

[73] Fix | Delete

# else

[74] Fix | Delete

# define __TG_F64X_ARG(X)

[75] Fix | Delete

# endif

[76] Fix | Delete

# if __HAVE_FLOAT128X && __GLIBC_USE (IEC_60559_TYPES_EXT)

[77] Fix | Delete

# define __TG_F128X_ARG(X) X ## f128x,

[78] Fix | Delete

# else

[79] Fix | Delete

# define __TG_F128X_ARG(X)

[80] Fix | Delete

# endif

[81] Fix | Delete

[82] Fix | Delete

# define __TGMATH_FUNCS(X) X ## f, X, X ## l, \

[83] Fix | Delete

__TG_F16_ARG (X) __TG_F32_ARG (X) __TG_F64_ARG (X) __TG_F128_ARG (X) \

[84] Fix | Delete

__TG_F32X_ARG (X) __TG_F64X_ARG (X) __TG_F128X_ARG (X)

[85] Fix | Delete

# define __TGMATH_RCFUNCS(F, C) __TGMATH_FUNCS (F) __TGMATH_FUNCS (C)

[86] Fix | Delete

# define __TGMATH_1(F, X) __builtin_tgmath (__TGMATH_FUNCS (F) (X))

[87] Fix | Delete

# define __TGMATH_2(F, X, Y) __builtin_tgmath (__TGMATH_FUNCS (F) (X), (Y))

[88] Fix | Delete

# define __TGMATH_2STD(F, X, Y) __builtin_tgmath (F ## f, F, F ## l, (X), (Y))

[89] Fix | Delete

# define __TGMATH_3(F, X, Y, Z) __builtin_tgmath (__TGMATH_FUNCS (F) \

[90] Fix | Delete

(X), (Y), (Z))

[91] Fix | Delete

# define __TGMATH_1C(F, C, X) __builtin_tgmath (__TGMATH_RCFUNCS (F, C) (X))

[92] Fix | Delete

# define __TGMATH_2C(F, C, X, Y) __builtin_tgmath (__TGMATH_RCFUNCS (F, C) \

[93] Fix | Delete

(X), (Y))

[94] Fix | Delete

[95] Fix | Delete

# else /* !__HAVE_BUILTIN_TGMATH. */

[96] Fix | Delete

[97] Fix | Delete

# ifdef __NO_LONG_DOUBLE_MATH

[98] Fix | Delete

# define __tgml(fct) fct

[99] Fix | Delete

# else

[100] Fix | Delete

# define __tgml(fct) fct ## l

[101] Fix | Delete

# endif

[102] Fix | Delete

[103] Fix | Delete

/* __floating_type expands to 1 if TYPE is a floating type (including

[104] Fix | Delete

complex floating types), 0 if TYPE is an integer type (including

[105] Fix | Delete

complex integer types). __real_integer_type expands to 1 if TYPE

[106] Fix | Delete

is a real integer type. __complex_integer_type expands to 1 if

[107] Fix | Delete

TYPE is a complex integer type. All these macros expand to integer

[108] Fix | Delete

constant expressions. All these macros can assume their argument

[109] Fix | Delete

has an arithmetic type (not vector, decimal floating-point or

[110] Fix | Delete

fixed-point), valid to pass to tgmath.h macros. */

[111] Fix | Delete

# if __GNUC_PREREQ (3, 1)

[112] Fix | Delete

/* __builtin_classify_type expands to an integer constant expression

[113] Fix | Delete

in GCC 3.1 and later. Default conversions applied to the argument

[114] Fix | Delete

of __builtin_classify_type mean it always returns 1 for real

[115] Fix | Delete

integer types rather than ever returning different values for

[116] Fix | Delete

character, boolean or enumerated types. */

[117] Fix | Delete

# define __floating_type(type) \

[118] Fix | Delete

(__builtin_classify_type (__real__ ((type) 0)) == 8)

[119] Fix | Delete

# define __real_integer_type(type) \

[120] Fix | Delete

(__builtin_classify_type ((type) 0) == 1)

[121] Fix | Delete

# define __complex_integer_type(type) \

[122] Fix | Delete

(__builtin_classify_type ((type) 0) == 9 \

[123] Fix | Delete

&& __builtin_classify_type (__real__ ((type) 0)) == 1)

[124] Fix | Delete

# else

[125] Fix | Delete

/* GCC versions predating __builtin_classify_type are also looser on

[126] Fix | Delete

what counts as an integer constant expression. */

[127] Fix | Delete

# define __floating_type(type) (((type) 1.25) != 1)

[128] Fix | Delete

# define __real_integer_type(type) (((type) (1.25 + _Complex_I)) == 1)

[129] Fix | Delete

# define __complex_integer_type(type) \

[130] Fix | Delete

(((type) (1.25 + _Complex_I)) == (1 + _Complex_I))

[131] Fix | Delete

# endif

[132] Fix | Delete

[133] Fix | Delete

/* Whether an expression (of arithmetic type) has a real type. */

[134] Fix | Delete

# define __expr_is_real(E) (__builtin_classify_type (E) != 9)

[135] Fix | Delete

[136] Fix | Delete

/* The tgmath real type for T, where E is 0 if T is an integer type

[137] Fix | Delete

and 1 for a floating type. If T has a complex type, it is

[138] Fix | Delete

unspecified whether the return type is real or complex (but it has

[139] Fix | Delete

the correct corresponding real type). */

[140] Fix | Delete

# define __tgmath_real_type_sub(T, E) \

[141] Fix | Delete

__typeof__ (*(0 ? (__typeof__ (0 ? (double *) 0 : (void *) (E))) 0 \

[142] Fix | Delete

: (__typeof__ (0 ? (T *) 0 : (void *) (!(E)))) 0))

[143] Fix | Delete

[144] Fix | Delete

/* The tgmath real type of EXPR. */

[145] Fix | Delete

# define __tgmath_real_type(expr) \

[146] Fix | Delete

__tgmath_real_type_sub (__typeof__ ((__typeof__ (+(expr))) 0), \

[147] Fix | Delete

__floating_type (__typeof__ (+(expr))))

[148] Fix | Delete

[149] Fix | Delete

/* The tgmath complex type for T, where E1 is 1 if T has a floating

[150] Fix | Delete

type and 0 otherwise, E2 is 1 if T has a real integer type and 0

[151] Fix | Delete

otherwise, and E3 is 1 if T has a complex type and 0 otherwise. */

[152] Fix | Delete

# define __tgmath_complex_type_sub(T, E1, E2, E3) \

[153] Fix | Delete

__typeof__ (*(0 \

[154] Fix | Delete

? (__typeof__ (0 ? (T *) 0 : (void *) (!(E1)))) 0 \

[155] Fix | Delete

: (__typeof__ (0 \

[156] Fix | Delete

? (__typeof__ (0 \

[157] Fix | Delete

? (double *) 0 \

[158] Fix | Delete

: (void *) (!(E2)))) 0 \

[159] Fix | Delete

: (__typeof__ (0 \

[160] Fix | Delete

? (_Complex double *) 0 \

[161] Fix | Delete

: (void *) (!(E3)))) 0)) 0))

[162] Fix | Delete

[163] Fix | Delete

/* The tgmath complex type of EXPR. */

[164] Fix | Delete

# define __tgmath_complex_type(expr) \

[165] Fix | Delete

__tgmath_complex_type_sub (__typeof__ ((__typeof__ (+(expr))) 0), \

[166] Fix | Delete

__floating_type (__typeof__ (+(expr))), \

[167] Fix | Delete

__real_integer_type (__typeof__ (+(expr))), \

[168] Fix | Delete

__complex_integer_type (__typeof__ (+(expr))))

[169] Fix | Delete

[170] Fix | Delete

# if (__HAVE_DISTINCT_FLOAT16 \

[171] Fix | Delete

|| __HAVE_DISTINCT_FLOAT32 \

[172] Fix | Delete

|| __HAVE_DISTINCT_FLOAT64 \

[173] Fix | Delete

|| __HAVE_DISTINCT_FLOAT32X \

[174] Fix | Delete

|| __HAVE_DISTINCT_FLOAT64X \

[175] Fix | Delete

|| __HAVE_DISTINCT_FLOAT128X)

[176] Fix | Delete

# error "Unsupported _FloatN or _FloatNx types for <tgmath.h>."

[177] Fix | Delete

# endif

[178] Fix | Delete

[179] Fix | Delete

/* Expand to text that checks if ARG_COMB has type _Float128, and if

[180] Fix | Delete

so calls the appropriately suffixed FCT (which may include a cast),

[181] Fix | Delete

or FCT and CFCT for complex functions, with arguments ARG_CALL. */

[182] Fix | Delete

# if __HAVE_DISTINCT_FLOAT128 && __GLIBC_USE (IEC_60559_TYPES_EXT)

[183] Fix | Delete

# if (!__HAVE_FLOAT64X \

[184] Fix | Delete

|| __HAVE_FLOAT64X_LONG_DOUBLE \

[185] Fix | Delete

|| !__HAVE_FLOATN_NOT_TYPEDEF)

[186] Fix | Delete

# define __TGMATH_F128(arg_comb, fct, arg_call) \

[187] Fix | Delete

__builtin_types_compatible_p (__typeof (+(arg_comb)), _Float128) \

[188] Fix | Delete

? fct ## f128 arg_call :

[189] Fix | Delete

# define __TGMATH_CF128(arg_comb, fct, cfct, arg_call) \

[190] Fix | Delete

__builtin_types_compatible_p (__typeof (+__real__ (arg_comb)), _Float128) \

[191] Fix | Delete

? (__expr_is_real (arg_comb) \

[192] Fix | Delete

? fct ## f128 arg_call \

[193] Fix | Delete

: cfct ## f128 arg_call) :

[194] Fix | Delete

# else

[195] Fix | Delete

/* _Float64x is a distinct type at the C language level, which must be

[196] Fix | Delete

handled like _Float128. */

[197] Fix | Delete

# define __TGMATH_F128(arg_comb, fct, arg_call) \

[198] Fix | Delete

(__builtin_types_compatible_p (__typeof (+(arg_comb)), _Float128) \

[199] Fix | Delete

|| __builtin_types_compatible_p (__typeof (+(arg_comb)), _Float64x)) \

[200] Fix | Delete

? fct ## f128 arg_call :

[201] Fix | Delete

# define __TGMATH_CF128(arg_comb, fct, cfct, arg_call) \

[202] Fix | Delete

(__builtin_types_compatible_p (__typeof (+__real__ (arg_comb)), _Float128) \

[203] Fix | Delete

|| __builtin_types_compatible_p (__typeof (+__real__ (arg_comb)), \

[204] Fix | Delete

_Float64x)) \

[205] Fix | Delete

? (__expr_is_real (arg_comb) \

[206] Fix | Delete

? fct ## f128 arg_call \

[207] Fix | Delete

: cfct ## f128 arg_call) :

[208] Fix | Delete

# endif

[209] Fix | Delete

# else

[210] Fix | Delete

# define __TGMATH_F128(arg_comb, fct, arg_call) /* Nothing. */

[211] Fix | Delete

# define __TGMATH_CF128(arg_comb, fct, cfct, arg_call) /* Nothing. */

[212] Fix | Delete

# endif

[213] Fix | Delete

[214] Fix | Delete

# endif /* !__HAVE_BUILTIN_TGMATH. */

[215] Fix | Delete

[216] Fix | Delete

/* We have two kinds of generic macros: to support functions which are

[217] Fix | Delete

only defined on real valued parameters and those which are defined

[218] Fix | Delete

for complex functions as well. */

[219] Fix | Delete

# if __HAVE_BUILTIN_TGMATH

[220] Fix | Delete

[221] Fix | Delete

# define __TGMATH_UNARY_REAL_ONLY(Val, Fct) __TGMATH_1 (Fct, (Val))

[222] Fix | Delete

# define __TGMATH_UNARY_REAL_RET_ONLY(Val, Fct) __TGMATH_1 (Fct, (Val))

[223] Fix | Delete

# define __TGMATH_BINARY_FIRST_REAL_ONLY(Val1, Val2, Fct) \

[224] Fix | Delete

__TGMATH_2 (Fct, (Val1), (Val2))

[225] Fix | Delete

# define __TGMATH_BINARY_FIRST_REAL_STD_ONLY(Val1, Val2, Fct) \

[226] Fix | Delete

__TGMATH_2STD (Fct, (Val1), (Val2))

[227] Fix | Delete

# define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct) \

[228] Fix | Delete

__TGMATH_2 (Fct, (Val1), (Val2))

[229] Fix | Delete

# define __TGMATH_BINARY_REAL_STD_ONLY(Val1, Val2, Fct) \

[230] Fix | Delete

__TGMATH_2STD (Fct, (Val1), (Val2))

[231] Fix | Delete

# define __TGMATH_BINARY_REAL_RET_ONLY(Val1, Val2, Fct) \

[232] Fix | Delete

__TGMATH_2 (Fct, (Val1), (Val2))

[233] Fix | Delete

# define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \

[234] Fix | Delete

__TGMATH_3 (Fct, (Val1), (Val2), (Val3))

[235] Fix | Delete

# define __TGMATH_TERNARY_REAL_ONLY(Val1, Val2, Val3, Fct) \

[236] Fix | Delete

__TGMATH_3 (Fct, (Val1), (Val2), (Val3))

[237] Fix | Delete

# define __TGMATH_TERNARY_FIRST_REAL_RET_ONLY(Val1, Val2, Val3, Fct) \

[238] Fix | Delete

__TGMATH_3 (Fct, (Val1), (Val2), (Val3))

[239] Fix | Delete

# define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \

[240] Fix | Delete

__TGMATH_1C (Fct, Cfct, (Val))

[241] Fix | Delete

# define __TGMATH_UNARY_IMAG(Val, Cfct) __TGMATH_1 (Cfct, (Val))

[242] Fix | Delete

# define __TGMATH_UNARY_REAL_IMAG_RET_REAL(Val, Fct, Cfct) \

[243] Fix | Delete

__TGMATH_1C (Fct, Cfct, (Val))

[244] Fix | Delete

# define __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME(Val, Cfct) \

[245] Fix | Delete

__TGMATH_1 (Cfct, (Val))

[246] Fix | Delete

# define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \

[247] Fix | Delete

__TGMATH_2C (Fct, Cfct, (Val1), (Val2))

[248] Fix | Delete

[249] Fix | Delete

# else /* !__HAVE_BUILTIN_TGMATH. */

[250] Fix | Delete

[251] Fix | Delete

# define __TGMATH_UNARY_REAL_ONLY(Val, Fct) \

[252] Fix | Delete

(__extension__ ((sizeof (+(Val)) == sizeof (double) \

[253] Fix | Delete

|| __builtin_classify_type (Val) != 8) \

[254] Fix | Delete

? (__tgmath_real_type (Val)) Fct (Val) \

[255] Fix | Delete

: (sizeof (+(Val)) == sizeof (float)) \

[256] Fix | Delete

? (__tgmath_real_type (Val)) Fct##f (Val) \

[257] Fix | Delete

: __TGMATH_F128 ((Val), (__tgmath_real_type (Val)) Fct, \

[258] Fix | Delete

(Val)) \

[259] Fix | Delete

(__tgmath_real_type (Val)) __tgml(Fct) (Val)))

[260] Fix | Delete

[261] Fix | Delete

# define __TGMATH_UNARY_REAL_RET_ONLY(Val, Fct) \

[262] Fix | Delete

(__extension__ ((sizeof (+(Val)) == sizeof (double) \

[263] Fix | Delete

|| __builtin_classify_type (Val) != 8) \

[264] Fix | Delete

? Fct (Val) \

[265] Fix | Delete

: (sizeof (+(Val)) == sizeof (float)) \

[266] Fix | Delete

? Fct##f (Val) \

[267] Fix | Delete

: __TGMATH_F128 ((Val), Fct, (Val)) \

[268] Fix | Delete

__tgml(Fct) (Val)))

[269] Fix | Delete

[270] Fix | Delete

# define __TGMATH_BINARY_FIRST_REAL_ONLY(Val1, Val2, Fct) \

[271] Fix | Delete

(__extension__ ((sizeof (+(Val1)) == sizeof (double) \

[272] Fix | Delete

|| __builtin_classify_type (Val1) != 8) \

[273] Fix | Delete

? (__tgmath_real_type (Val1)) Fct (Val1, Val2) \

[274] Fix | Delete

: (sizeof (+(Val1)) == sizeof (float)) \

[275] Fix | Delete

? (__tgmath_real_type (Val1)) Fct##f (Val1, Val2) \

[276] Fix | Delete

: __TGMATH_F128 ((Val1), (__tgmath_real_type (Val1)) Fct, \

[277] Fix | Delete

(Val1, Val2)) \

[278] Fix | Delete

(__tgmath_real_type (Val1)) __tgml(Fct) (Val1, Val2)))

[279] Fix | Delete

[280] Fix | Delete

# define __TGMATH_BINARY_FIRST_REAL_STD_ONLY(Val1, Val2, Fct) \

[281] Fix | Delete

(__extension__ ((sizeof (+(Val1)) == sizeof (double) \

[282] Fix | Delete

|| __builtin_classify_type (Val1) != 8) \

[283] Fix | Delete

? (__tgmath_real_type (Val1)) Fct (Val1, Val2) \

[284] Fix | Delete

: (sizeof (+(Val1)) == sizeof (float)) \

[285] Fix | Delete

? (__tgmath_real_type (Val1)) Fct##f (Val1, Val2) \

[286] Fix | Delete

: (__tgmath_real_type (Val1)) __tgml(Fct) (Val1, Val2)))

[287] Fix | Delete

[288] Fix | Delete

# define __TGMATH_BINARY_REAL_ONLY(Val1, Val2, Fct) \

[289] Fix | Delete

(__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double) \

[290] Fix | Delete

&& __builtin_classify_type ((Val1) + (Val2)) == 8) \

[291] Fix | Delete

? __TGMATH_F128 ((Val1) + (Val2), \

[292] Fix | Delete

(__typeof \

[293] Fix | Delete

((__tgmath_real_type (Val1)) 0 \

[294] Fix | Delete

+ (__tgmath_real_type (Val2)) 0)) Fct, \

[295] Fix | Delete

(Val1, Val2)) \

[296] Fix | Delete

(__typeof ((__tgmath_real_type (Val1)) 0 \

[297] Fix | Delete

+ (__tgmath_real_type (Val2)) 0)) \

[298] Fix | Delete

__tgml(Fct) (Val1, Val2) \

[299] Fix | Delete

: (sizeof (+(Val1)) == sizeof (double) \

[300] Fix | Delete

|| sizeof (+(Val2)) == sizeof (double) \

[301] Fix | Delete

|| __builtin_classify_type (Val1) != 8 \

[302] Fix | Delete

|| __builtin_classify_type (Val2) != 8) \

[303] Fix | Delete

? (__typeof ((__tgmath_real_type (Val1)) 0 \

[304] Fix | Delete

+ (__tgmath_real_type (Val2)) 0)) \

[305] Fix | Delete

Fct (Val1, Val2) \

[306] Fix | Delete

: (__typeof ((__tgmath_real_type (Val1)) 0 \

[307] Fix | Delete

+ (__tgmath_real_type (Val2)) 0)) \

[308] Fix | Delete

Fct##f (Val1, Val2)))

[309] Fix | Delete

[310] Fix | Delete

# define __TGMATH_BINARY_REAL_STD_ONLY(Val1, Val2, Fct) \

[311] Fix | Delete

(__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double) \

[312] Fix | Delete

&& __builtin_classify_type ((Val1) + (Val2)) == 8) \

[313] Fix | Delete

? (__typeof ((__tgmath_real_type (Val1)) 0 \

[314] Fix | Delete

+ (__tgmath_real_type (Val2)) 0)) \

[315] Fix | Delete

__tgml(Fct) (Val1, Val2) \

[316] Fix | Delete

: (sizeof (+(Val1)) == sizeof (double) \

[317] Fix | Delete

|| sizeof (+(Val2)) == sizeof (double) \

[318] Fix | Delete

|| __builtin_classify_type (Val1) != 8 \

[319] Fix | Delete

|| __builtin_classify_type (Val2) != 8) \

[320] Fix | Delete

? (__typeof ((__tgmath_real_type (Val1)) 0 \

[321] Fix | Delete

+ (__tgmath_real_type (Val2)) 0)) \

[322] Fix | Delete

Fct (Val1, Val2) \

[323] Fix | Delete

: (__typeof ((__tgmath_real_type (Val1)) 0 \

[324] Fix | Delete

+ (__tgmath_real_type (Val2)) 0)) \

[325] Fix | Delete

Fct##f (Val1, Val2)))

[326] Fix | Delete

[327] Fix | Delete

# define __TGMATH_BINARY_REAL_RET_ONLY(Val1, Val2, Fct) \

[328] Fix | Delete

(__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double) \

[329] Fix | Delete

&& __builtin_classify_type ((Val1) + (Val2)) == 8) \

[330] Fix | Delete

? __TGMATH_F128 ((Val1) + (Val2), Fct, (Val1, Val2)) \

[331] Fix | Delete

__tgml(Fct) (Val1, Val2) \

[332] Fix | Delete

: (sizeof (+(Val1)) == sizeof (double) \

[333] Fix | Delete

|| sizeof (+(Val2)) == sizeof (double) \

[334] Fix | Delete

|| __builtin_classify_type (Val1) != 8 \

[335] Fix | Delete

|| __builtin_classify_type (Val2) != 8) \

[336] Fix | Delete

? Fct (Val1, Val2) \

[337] Fix | Delete

: Fct##f (Val1, Val2)))

[338] Fix | Delete

[339] Fix | Delete

# define __TGMATH_TERNARY_FIRST_SECOND_REAL_ONLY(Val1, Val2, Val3, Fct) \

[340] Fix | Delete

(__extension__ ((sizeof ((Val1) + (Val2)) > sizeof (double) \

[341] Fix | Delete

&& __builtin_classify_type ((Val1) + (Val2)) == 8) \

[342] Fix | Delete

? __TGMATH_F128 ((Val1) + (Val2), \

[343] Fix | Delete

(__typeof \

[344] Fix | Delete

((__tgmath_real_type (Val1)) 0 \

[345] Fix | Delete

+ (__tgmath_real_type (Val2)) 0)) Fct, \

[346] Fix | Delete

(Val1, Val2, Val3)) \

[347] Fix | Delete

(__typeof ((__tgmath_real_type (Val1)) 0 \

[348] Fix | Delete

+ (__tgmath_real_type (Val2)) 0)) \

[349] Fix | Delete

__tgml(Fct) (Val1, Val2, Val3) \

[350] Fix | Delete

: (sizeof (+(Val1)) == sizeof (double) \

[351] Fix | Delete

|| sizeof (+(Val2)) == sizeof (double) \

[352] Fix | Delete

|| __builtin_classify_type (Val1) != 8 \

[353] Fix | Delete

|| __builtin_classify_type (Val2) != 8) \

[354] Fix | Delete

? (__typeof ((__tgmath_real_type (Val1)) 0 \

[355] Fix | Delete

+ (__tgmath_real_type (Val2)) 0)) \

[356] Fix | Delete

Fct (Val1, Val2, Val3) \

[357] Fix | Delete

: (__typeof ((__tgmath_real_type (Val1)) 0 \

[358] Fix | Delete

+ (__tgmath_real_type (Val2)) 0)) \

[359] Fix | Delete

Fct##f (Val1, Val2, Val3)))

[360] Fix | Delete

[361] Fix | Delete

# define __TGMATH_TERNARY_REAL_ONLY(Val1, Val2, Val3, Fct) \

[362] Fix | Delete

(__extension__ ((sizeof ((Val1) + (Val2) + (Val3)) > sizeof (double) \

[363] Fix | Delete

&& __builtin_classify_type ((Val1) + (Val2) + (Val3)) \

[364] Fix | Delete

== 8) \

[365] Fix | Delete

? __TGMATH_F128 ((Val1) + (Val2) + (Val3), \

[366] Fix | Delete

(__typeof \

[367] Fix | Delete

((__tgmath_real_type (Val1)) 0 \

[368] Fix | Delete

+ (__tgmath_real_type (Val2)) 0 \

[369] Fix | Delete

+ (__tgmath_real_type (Val3)) 0)) Fct, \

[370] Fix | Delete

(Val1, Val2, Val3)) \

[371] Fix | Delete

(__typeof ((__tgmath_real_type (Val1)) 0 \

[372] Fix | Delete

+ (__tgmath_real_type (Val2)) 0 \

[373] Fix | Delete

+ (__tgmath_real_type (Val3)) 0)) \

[374] Fix | Delete

__tgml(Fct) (Val1, Val2, Val3) \

[375] Fix | Delete

: (sizeof (+(Val1)) == sizeof (double) \

[376] Fix | Delete

|| sizeof (+(Val2)) == sizeof (double) \

[377] Fix | Delete

|| sizeof (+(Val3)) == sizeof (double) \

[378] Fix | Delete

|| __builtin_classify_type (Val1) != 8 \

[379] Fix | Delete

|| __builtin_classify_type (Val2) != 8 \

[380] Fix | Delete

|| __builtin_classify_type (Val3) != 8) \

[381] Fix | Delete

? (__typeof ((__tgmath_real_type (Val1)) 0 \

[382] Fix | Delete

+ (__tgmath_real_type (Val2)) 0 \

[383] Fix | Delete

+ (__tgmath_real_type (Val3)) 0)) \

[384] Fix | Delete

Fct (Val1, Val2, Val3) \

[385] Fix | Delete

: (__typeof ((__tgmath_real_type (Val1)) 0 \

[386] Fix | Delete

+ (__tgmath_real_type (Val2)) 0 \

[387] Fix | Delete

+ (__tgmath_real_type (Val3)) 0)) \

[388] Fix | Delete

Fct##f (Val1, Val2, Val3)))

[389] Fix | Delete

[390] Fix | Delete

# define __TGMATH_TERNARY_FIRST_REAL_RET_ONLY(Val1, Val2, Val3, Fct) \

[391] Fix | Delete

(__extension__ ((sizeof (+(Val1)) == sizeof (double) \

[392] Fix | Delete

|| __builtin_classify_type (Val1) != 8) \

[393] Fix | Delete

? Fct (Val1, Val2, Val3) \

[394] Fix | Delete

: (sizeof (+(Val1)) == sizeof (float)) \

[395] Fix | Delete

? Fct##f (Val1, Val2, Val3) \

[396] Fix | Delete

: __TGMATH_F128 ((Val1), Fct, (Val1, Val2, Val3)) \

[397] Fix | Delete

__tgml(Fct) (Val1, Val2, Val3)))

[398] Fix | Delete

[399] Fix | Delete

/* XXX This definition has to be changed as soon as the compiler understands

[400] Fix | Delete

the imaginary keyword. */

[401] Fix | Delete

# define __TGMATH_UNARY_REAL_IMAG(Val, Fct, Cfct) \

[402] Fix | Delete

(__extension__ ((sizeof (+__real__ (Val)) == sizeof (double) \

[403] Fix | Delete

|| __builtin_classify_type (__real__ (Val)) != 8) \

[404] Fix | Delete

? (__expr_is_real (Val) \

[405] Fix | Delete

? (__tgmath_complex_type (Val)) Fct (Val) \

[406] Fix | Delete

: (__tgmath_complex_type (Val)) Cfct (Val)) \

[407] Fix | Delete

: (sizeof (+__real__ (Val)) == sizeof (float)) \

[408] Fix | Delete

? (__expr_is_real (Val) \

[409] Fix | Delete

? (__tgmath_complex_type (Val)) Fct##f (Val) \

[410] Fix | Delete

: (__tgmath_complex_type (Val)) Cfct##f (Val)) \

[411] Fix | Delete

: __TGMATH_CF128 ((Val), \

[412] Fix | Delete

(__tgmath_complex_type (Val)) Fct, \

[413] Fix | Delete

(__tgmath_complex_type (Val)) Cfct, \

[414] Fix | Delete

(Val)) \

[415] Fix | Delete

(__expr_is_real (Val) \

[416] Fix | Delete

? (__tgmath_complex_type (Val)) __tgml(Fct) (Val) \

[417] Fix | Delete

: (__tgmath_complex_type (Val)) __tgml(Cfct) (Val))))

[418] Fix | Delete

[419] Fix | Delete

# define __TGMATH_UNARY_IMAG(Val, Cfct) \

[420] Fix | Delete

(__extension__ ((sizeof (+__real__ (Val)) == sizeof (double) \

[421] Fix | Delete

|| __builtin_classify_type (__real__ (Val)) != 8) \

[422] Fix | Delete

? (__typeof__ ((__tgmath_real_type (Val)) 0 \

[423] Fix | Delete

+ _Complex_I)) Cfct (Val) \

[424] Fix | Delete

: (sizeof (+__real__ (Val)) == sizeof (float)) \

[425] Fix | Delete

? (__typeof__ ((__tgmath_real_type (Val)) 0 \

[426] Fix | Delete

+ _Complex_I)) Cfct##f (Val) \

[427] Fix | Delete

: __TGMATH_F128 (__real__ (Val), \

[428] Fix | Delete

(__typeof__ \

[429] Fix | Delete

((__tgmath_real_type (Val)) 0 \

[430] Fix | Delete

+ _Complex_I)) Cfct, (Val)) \

[431] Fix | Delete

(__typeof__ ((__tgmath_real_type (Val)) 0 \

[432] Fix | Delete

+ _Complex_I)) __tgml(Cfct) (Val)))

[433] Fix | Delete

[434] Fix | Delete

/* XXX This definition has to be changed as soon as the compiler understands

[435] Fix | Delete

the imaginary keyword. */

[436] Fix | Delete

# define __TGMATH_UNARY_REAL_IMAG_RET_REAL(Val, Fct, Cfct) \

[437] Fix | Delete

(__extension__ ((sizeof (+__real__ (Val)) == sizeof (double) \

[438] Fix | Delete

|| __builtin_classify_type (__real__ (Val)) != 8) \

[439] Fix | Delete

? (__expr_is_real (Val) \

[440] Fix | Delete

? (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\

[441] Fix | Delete

Fct (Val) \

[442] Fix | Delete

: (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\

[443] Fix | Delete

Cfct (Val)) \

[444] Fix | Delete

: (sizeof (+__real__ (Val)) == sizeof (float)) \

[445] Fix | Delete

? (__expr_is_real (Val) \

[446] Fix | Delete

? (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\

[447] Fix | Delete

Fct##f (Val) \

[448] Fix | Delete

: (__typeof__ (__real__ (__tgmath_real_type (Val)) 0))\

[449] Fix | Delete

Cfct##f (Val)) \

[450] Fix | Delete

: __TGMATH_CF128 ((Val), \

[451] Fix | Delete

(__typeof__ \

[452] Fix | Delete

(__real__ \

[453] Fix | Delete

(__tgmath_real_type (Val)) 0)) Fct, \

[454] Fix | Delete

(__typeof__ \

[455] Fix | Delete

(__real__ \

[456] Fix | Delete

(__tgmath_real_type (Val)) 0)) Cfct, \

[457] Fix | Delete

(Val)) \

[458] Fix | Delete

(__expr_is_real (Val) \

[459] Fix | Delete

? (__typeof__ (__real__ (__tgmath_real_type (Val)) 0)) \

[460] Fix | Delete

__tgml(Fct) (Val) \

[461] Fix | Delete

: (__typeof__ (__real__ (__tgmath_real_type (Val)) 0)) \

[462] Fix | Delete

__tgml(Cfct) (Val))))

[463] Fix | Delete

# define __TGMATH_UNARY_REAL_IMAG_RET_REAL_SAME(Val, Cfct) \

[464] Fix | Delete

__TGMATH_UNARY_REAL_IMAG_RET_REAL ((Val), Cfct, Cfct)

[465] Fix | Delete

[466] Fix | Delete

/* XXX This definition has to be changed as soon as the compiler understands

[467] Fix | Delete

the imaginary keyword. */

[468] Fix | Delete

# define __TGMATH_BINARY_REAL_IMAG(Val1, Val2, Fct, Cfct) \

[469] Fix | Delete

(__extension__ ((sizeof (__real__ (Val1) \

[470] Fix | Delete

+ __real__ (Val2)) > sizeof (double) \

[471] Fix | Delete

&& __builtin_classify_type (__real__ (Val1) \

[472] Fix | Delete

+ __real__ (Val2)) == 8) \

[473] Fix | Delete

? __TGMATH_CF128 ((Val1) + (Val2), \

[474] Fix | Delete

(__typeof \

[475] Fix | Delete

((__tgmath_complex_type (Val1)) 0 \

[476] Fix | Delete

+ (__tgmath_complex_type (Val2)) 0)) \

[477] Fix | Delete

Fct, \

[478] Fix | Delete

(__typeof \

[479] Fix | Delete

((__tgmath_complex_type (Val1)) 0 \

[480] Fix | Delete

+ (__tgmath_complex_type (Val2)) 0)) \

[481] Fix | Delete

Cfct, \

[482] Fix | Delete

(Val1, Val2)) \

[483] Fix | Delete

(__expr_is_real ((Val1) + (Val2)) \

[484] Fix | Delete

? (__typeof ((__tgmath_complex_type (Val1)) 0 \

[485] Fix | Delete

+ (__tgmath_complex_type (Val2)) 0)) \

[486] Fix | Delete

__tgml(Fct) (Val1, Val2) \

[487] Fix | Delete

: (__typeof ((__tgmath_complex_type (Val1)) 0 \

[488] Fix | Delete

+ (__tgmath_complex_type (Val2)) 0)) \

[489] Fix | Delete

__tgml(Cfct) (Val1, Val2)) \

[490] Fix | Delete

: (sizeof (+__real__ (Val1)) == sizeof (double) \

[491] Fix | Delete

|| sizeof (+__real__ (Val2)) == sizeof (double) \

[492] Fix | Delete

|| __builtin_classify_type (__real__ (Val1)) != 8 \

[493] Fix | Delete

|| __builtin_classify_type (__real__ (Val2)) != 8) \

[494] Fix | Delete

? (__expr_is_real ((Val1) + (Val2)) \

[495] Fix | Delete

? (__typeof ((__tgmath_complex_type (Val1)) 0 \

[496] Fix | Delete

+ (__tgmath_complex_type (Val2)) 0)) \

[497] Fix | Delete

Fct (Val1, Val2) \

[498] Fix | Delete

: (__typeof ((__tgmath_complex_type (Val1)) 0 \

[499] Fix | Delete