1 /***
2 * D compatible types that correspond to various basic types in associated
3 * C and C++ compilers.
4 *
5 * Copyright: Copyright Sean Kelly 2005 - 2009.
6 * License: Distributed under the
7 * $(LINK2 http://www.boost.org/LICENSE_1_0.txt, Boost Software License 1.0).
8 * (See accompanying file LICENSE)
9 * Authors: Sean Kelly
10 * Source: $(DRUNTIMESRC core/stdc/_config.d)
11 * Standards: ISO/IEC 9899:1999 (E)
12 */
13
14 module core.stdc.config;
15
16 version (StdDdoc)
17 {
18 private
19 {
20 version (Posix)
21 enum isPosix = true;
22 else
23 enum isPosix = false;
24 static if (isPosix && (void*).sizeof > int.sizeof)
25 {
26 alias ddoc_long = long;
27 alias ddoc_ulong = ulong;
28 }
29 else
30 {
31 alias ddoc_long = int;
32 alias ddoc_ulong = uint;
33 }
34 struct ddoc_complex(T) { T re; T im; }
35 }
36
37 /***
38 * Used for a signed integer type that corresponds in size to the associated
39 * C compiler's `long` type.
40 */
41 alias c_long = ddoc_long;
42
43 /***
44 * Used for an unsigned integer type that corresponds in size to the associated
45 * C compiler's `unsigned long` type.
46 */
47 alias c_ulong = ddoc_ulong;
48
49 /***
50 * Used for a signed integer type that corresponds in size and mangling to the associated
51 * C++ compiler's `long` type.
52 */
53 alias cpp_long = c_long;
54
55 /***
56 * Used for an unsigned integer type that corresponds in size and mangling to the associated
57 * C++ compiler's `unsigned long` type.
58 */
59 alias cpp_ulong = c_ulong;
60
61 /***
62 * Used for a signed integer type that corresponds in size and mangling to the associated
63 * C++ compiler's `long long` type.
64 */
65 alias cpp_longlong = long;
66
67 /***
68 * Used for an unsigned integer type that corresponds in size and mangling to the associated
69 * C++ compiler's `unsigned long long` type.
70 */
71 alias cpp_ulonglong = ulong;
72
73 /***
74 * Used for a floating point type that corresponds in size and mangling to the associated
75 * C++ compiler's `long double` type.
76 */
77 alias c_long_double = real;
78
79 /***
80 * Used for an unsigned integer type that corresponds in size and mangling to the associated
81 * C++ compiler's `size_t` type.
82 */
83 alias cpp_size_t = size_t;
84
85 /***
86 * Used for a signed integer type that corresponds in size and mangling to the associated
87 * C++ compiler's `ptrdiff_t` type.
88 */
89 alias cpp_ptrdiff_t = ptrdiff_t;
90
91 /***
92 * Used for a complex floating point type that corresponds in size and ABI to the associated
93 * C compiler's `_Complex float` type.
94 */
95 alias c_complex_float = ddoc_complex!float;
96
97 /***
98 * Used for a complex floating point type that corresponds in size and ABI to the associated
99 * C compiler's `_Complex double` type.
100 */
101 alias c_complex_double = ddoc_complex!double;
102
103 /***
104 * Used for a complex floating point type that corresponds in size and ABI to the associated
105 * C compiler's `_Complex long double` type.
106 */
107 alias c_complex_real = ddoc_complex!real;
108 }
109 else
110 {
111
112 version (OSX)
113 version = Darwin;
114 else version (iOS)
115 version = Darwin;
116 else version (TVOS)
117 version = Darwin;
118 else version (WatchOS)
119 version = Darwin;
120
121 version (Windows)
122 {
123 enum __c_long : int;
124 enum __c_ulong : uint;
125
126 alias int c_long;
127 alias uint c_ulong;
128
129 alias __c_long cpp_long;
130 alias __c_ulong cpp_ulong;
131
132 alias long cpp_longlong;
133 alias ulong cpp_ulonglong;
134 }
135 else version (Posix)
136 {
137 static if ( (void*).sizeof > int.sizeof )
138 {
139 enum __c_longlong : long;
140 enum __c_ulonglong : ulong;
141
142 alias long c_long;
143 alias ulong c_ulong;
144
145 alias long cpp_long;
146 alias ulong cpp_ulong;
147
148 alias __c_longlong cpp_longlong;
149 alias __c_ulonglong cpp_ulonglong;
150 }
151 else
152 {
153 enum __c_long : int;
154 enum __c_ulong : uint;
155
156 alias int c_long;
157 alias uint c_ulong;
158
159 alias __c_long cpp_long;
160 alias __c_ulong cpp_ulong;
161
162 alias long cpp_longlong;
163 alias ulong cpp_ulonglong;
164 }
165 }
166 else version (WASI)
167 {
168 static if ( (void*).sizeof > int.sizeof )
169 {
170 enum __c_longlong : long;
171 enum __c_ulonglong : ulong;
172
173 alias long c_long;
174 alias ulong c_ulong;
175
176 alias long cpp_long;
177 alias ulong cpp_ulong;
178
179 alias __c_longlong cpp_longlong;
180 alias __c_ulonglong cpp_ulonglong;
181 }
182 else
183 {
184 enum __c_long : int;
185 enum __c_ulong : uint;
186
187 alias int c_long;
188 alias uint c_ulong;
189
190 alias __c_long cpp_long;
191 alias __c_ulong cpp_ulong;
192
193 alias long cpp_longlong;
194 alias ulong cpp_ulonglong;
195 }
196 }
197
198 version (GNU)
199 alias c_long_double = real;
200 else version (LDC)
201 alias c_long_double = real; // 64-bit real for MSVC targets
202 else version (SDC)
203 {
204 version (X86)
205 alias c_long_double = real;
206 else version (X86_64)
207 alias c_long_double = real;
208 }
209 else version (CRuntime_Microsoft)
210 {
211 /* long double is 64 bits, not 80 bits, but is mangled differently
212 * than double. To distinguish double from long double, create a wrapper to represent
213 * long double, then recognize that wrapper specially in the compiler
214 * to generate the correct name mangling and correct function call/return
215 * ABI conformance.
216 */
217 enum __c_long_double : double;
218
219 alias __c_long_double c_long_double;
220 }
221 else version (DigitalMars)
222 {
223 version (X86)
224 {
225 alias real c_long_double;
226 }
227 else version (X86_64)
228 {
229 version (linux)
230 alias real c_long_double;
231 else version (FreeBSD)
232 alias real c_long_double;
233 else version (OpenBSD)
234 alias real c_long_double;
235 else version (NetBSD)
236 alias real c_long_double;
237 else version (DragonFlyBSD)
238 alias real c_long_double;
239 else version (Solaris)
240 alias real c_long_double;
241 else version (Darwin)
242 alias real c_long_double;
243 }
244 }
245
246 static assert(is(c_long_double), "c_long_double needs to be declared for this platform/architecture.");
247
248 version (Darwin)
249 {
250 alias cpp_size_t = cpp_ulong;
251 version (D_LP64)
252 alias cpp_ptrdiff_t = cpp_long;
253 else
254 alias cpp_ptrdiff_t = ptrdiff_t;
255 }
256 else
257 {
258 alias cpp_size_t = size_t;
259 alias cpp_ptrdiff_t = ptrdiff_t;
260 }
261
262 /** ABI layout of native complex types.
263 */
264 struct _Complex(T)
265 if (is(T == float) || is(T == double) || is(T == c_long_double))
266 {
267 T re = 0;
268 T im = 0;
269
270 // Construction
271 /+ https://issues.dlang.org/show_bug.cgi?id=23788 dmd codegen problem with constructors and _Complex!float
272 this(_Complex!float c) { re = c.re; im = c.im; }
273 this(_Complex!double c) { re = c.re; im = c.im; }
274 this(_Complex!c_long_double c) { re = c.re; im = c.im; }
275
276 this(T re, T im) { this.re = re; this.im = im; }
277
278 this(T re) { this.re = re; this.im = 0; }
279 +/
280 // Cast
281 R opCast(R)()
282 if (is(R == _Complex!float) || is(R == _Complex!double) || is(R == _Complex!c_long_double))
283 {
284 return R(this.re, this.im);
285 }
286
287 // Assignment
288
289 ref _Complex opAssign(_Complex!float c) { re = c.re; im = c.im; return this; }
290 ref _Complex opAssign(_Complex!double c) { re = c.re; im = c.im; return this; }
291 ref _Complex opAssign(_Complex!c_long_double c) { re = c.re; im = c.im; return this; }
292
293 ref _Complex opAssign(T t) { re = t; im = 0; return this; }
294
295 // Equals
296
297 bool opEquals(_Complex!float c) { return re == c.re && im == c.im; }
298 bool opEquals(_Complex!double c) { return re == c.re && im == c.im; }
299 bool opEquals(_Complex!c_long_double c) { return re == c.re && im == c.im; }
300
301 bool opEquals(T t) { return re == t && im == 0; }
302
303 // Unary operators
304
305 // +complex
306 _Complex opUnary(string op)()
307 if (op == "+")
308 {
309 return this;
310 }
311
312 // -complex
313 _Complex opUnary(string op)()
314 if (op == "-")
315 {
316 return _Complex(-re, -im);
317 }
318
319 // BINARY OPERATORS
320
321 // complex op complex
322 _Complex!(CommonType!(T,R)) opBinary(string op, R)(_Complex!R z)
323 {
324 alias C = typeof(return);
325 auto w = C(this.re, this.im);
326 return w.opOpAssign!(op)(z);
327 }
328
329 // complex op numeric
330 _Complex!(CommonType!(T,R)) opBinary(string op, R)(R r)
331 if (is(R : c_long_double))
332 {
333 alias C = typeof(return);
334 auto w = C(this.re, this.im);
335 return w.opOpAssign!(op)(r);
336 }
337
338 // numeric + complex, numeric * complex
339 _Complex!(CommonType!(T, R)) opBinaryRight(string op, R)(R r)
340 if ((op == "+" || op == "*") && is(R : c_long_double))
341 {
342 return opBinary!(op)(r);
343 }
344
345 // numeric - complex
346 _Complex!(CommonType!(T, R)) opBinaryRight(string op, R)(R r)
347 if (op == "-" && is(R : c_long_double))
348 {
349 return _Complex(r - re, -im);
350 }
351
352 // numeric / complex
353 _Complex!(CommonType!(T, R)) opBinaryRight(string op, R)(R r)
354 if (op == "/" && is(R : c_long_double))
355 {
356 import core.math : fabs;
357 typeof(return) w = void;
358 if (fabs(re) < fabs(im))
359 {
360 immutable ratio = re/im;
361 immutable rdivd = r/(re*ratio + im);
362
363 w.re = rdivd*ratio;
364 w.im = -rdivd;
365 }
366 else
367 {
368 immutable ratio = im/re;
369 immutable rdivd = r/(re + im*ratio);
370
371 w.re = rdivd;
372 w.im = -rdivd*ratio;
373 }
374
375 return w;
376 }
377
378 // OP-ASSIGN OPERATORS
379
380 // complex += complex, complex -= complex
381 ref _Complex opOpAssign(string op, C)(C z)
382 if ((op == "+" || op == "-") && is(C R == _Complex!R))
383 {
384 mixin ("re "~op~"= z.re;");
385 mixin ("im "~op~"= z.im;");
386 return this;
387 }
388
389 // complex *= complex
390 ref _Complex opOpAssign(string op, C)(C z)
391 if (op == "*" && is(C R == _Complex!R))
392 {
393 auto temp = re*z.re - im*z.im;
394 im = im*z.re + re*z.im;
395 re = temp;
396 return this;
397 }
398
399 // complex /= complex
400 ref _Complex opOpAssign(string op, C)(C z)
401 if (op == "/" && is(C R == _Complex!R))
402 {
403 import core.math : fabs;
404 if (fabs(z.re) < fabs(z.im))
405 {
406 immutable ratio = z.re/z.im;
407 immutable denom = z.re*ratio + z.im;
408
409 immutable temp = (re*ratio + im)/denom;
410 im = (im*ratio - re)/denom;
411 re = temp;
412 }
413 else
414 {
415 immutable ratio = z.im/z.re;
416 immutable denom = z.re + z.im*ratio;
417
418 immutable temp = (re + im*ratio)/denom;
419 im = (im - re*ratio)/denom;
420 re = temp;
421 }
422 return this;
423 }
424
425 // complex += numeric, complex -= numeric
426 ref _Complex opOpAssign(string op, U : T)(U a)
427 if (op == "+" || op == "-")
428 {
429 mixin ("re "~op~"= a;");
430 return this;
431 }
432
433 // complex *= numeric, complex /= numeric
434 ref _Complex opOpAssign(string op, U : T)(U a)
435 if (op == "*" || op == "/")
436 {
437 mixin ("re "~op~"= a;");
438 mixin ("im "~op~"= a;");
439 return this;
440 }
441
442 // Helper properties.
443 pragma(inline, true)
444 {
445 static @property epsilon()() { return _Complex(T.epsilon, T.epsilon); }
446 static @property infinity()() { return _Complex(T.infinity, T.infinity); }
447 static @property max()() { return _Complex(T.max, T.max); }
448 static @property min_normal()() { return _Complex(T.min_normal, T.min_normal); }
449 static @property nan()() { return _Complex(T.nan, T.nan); }
450 static @property dig()() { return T.dig; }
451 static @property mant_dig()() { return T.mant_dig; }
452 static @property max_10_exp()() { return T.max_10_exp; }
453 static @property max_exp()() { return T.max_exp; }
454 static @property min_10_exp()() { return T.min_10_exp; }
455 static @property min_exp()() { return T.min_exp; }
456 }
457 }
458
459 enum __c_complex_float : _Complex!float;
460 enum __c_complex_double : _Complex!double;
461 enum __c_complex_real : _Complex!c_long_double;
462
463 alias c_complex_float = __c_complex_float;
464 alias c_complex_double = __c_complex_double;
465 alias c_complex_real = __c_complex_real;
466
467 private template CommonType(T, R)
468 {
469 // Special kludge for Microsoft c_long_double
470 static if (is(T == c_long_double))
471 alias CommonType = T;
472 else static if (is(R == c_long_double))
473 alias CommonType = R;
474 else
475 alias CommonType = typeof(true ? T.init : R.init);
476 }
477
478 /************ unittests ****************/
479
480 version (unittest)
481 {
482 private:
483
484 alias _cfloat = _Complex!float;
485 alias _cdouble = _Complex!double;
486 alias _creal = _Complex!c_long_double;
487
488 T abs(T)(T t) => t < 0 ? -t : t;
489 }
490
491 @safe pure nothrow unittest
492 {
493 auto c1 = _cdouble(1.0, 1.0);
494
495 // Check unary operations.
496 auto c2 = _cdouble(0.5, 2.0);
497
498 assert(c2 == +c2);
499
500 assert((-c2).re == -(c2.re));
501 assert((-c2).im == -(c2.im));
502 assert(c2 == -(-c2));
503
504 // Check complex-complex operations.
505 auto cpc = c1 + c2;
506 assert(cpc.re == c1.re + c2.re);
507 assert(cpc.im == c1.im + c2.im);
508
509 auto cmc = c1 - c2;
510 assert(cmc.re == c1.re - c2.re);
511 assert(cmc.im == c1.im - c2.im);
512
513 auto ctc = c1 * c2;
514 assert(ctc == _cdouble(-1.5, 2.5));
515
516 auto cdc = c1 / c2;
517 assert(abs(cdc.re - 0.5882352941177) < 1e-12);
518 assert(abs(cdc.im - -0.3529411764706) < 1e-12);
519
520 // Check complex-real operations.
521 double a = 123.456;
522
523 auto cpr = c1 + a;
524 assert(cpr.re == c1.re + a);
525 assert(cpr.im == c1.im);
526
527 auto cmr = c1 - a;
528 assert(cmr.re == c1.re - a);
529 assert(cmr.im == c1.im);
530
531 auto ctr = c1 * a;
532 assert(ctr.re == c1.re*a);
533 assert(ctr.im == c1.im*a);
534
535 auto cdr = c1 / a;
536 assert(abs(cdr.re - 0.00810005184033) < 1e-12);
537 assert(abs(cdr.im - 0.00810005184033) < 1e-12);
538
539 auto rpc = a + c1;
540 assert(rpc == cpr);
541
542 auto rmc = a - c1;
543 assert(rmc.re == a-c1.re);
544 assert(rmc.im == -c1.im);
545
546 auto rtc = a * c1;
547 assert(rtc == ctr);
548
549 auto rdc = a / c1;
550 assert(abs(rdc.re - 61.728) < 1e-12);
551 assert(abs(rdc.im - -61.728) < 1e-12);
552
553 rdc = a / c2;
554 assert(abs(rdc.re - 14.5242352941) < 1e-10);
555 assert(abs(rdc.im - -58.0969411765) < 1e-10);
556
557 // Check operations between different complex types.
558 auto cf = _cfloat(1.0, 1.0);
559 auto cr = _creal(1.0, 1.0);
560 auto c1pcf = c1 + cf;
561 auto c1pcr = c1 + cr;
562 static assert(is(typeof(c1pcf) == _cdouble));
563 static assert(is(typeof(c1pcr) == _creal));
564 assert(c1pcf.re == c1pcr.re);
565 assert(c1pcf.im == c1pcr.im);
566
567 auto c1c = c1;
568 auto c2c = c2;
569
570 c1c /= c1;
571 assert(abs(c1c.re - 1.0) < 1e-10);
572 assert(abs(c1c.im - 0.0) < 1e-10);
573
574 c1c = c1;
575 c1c /= c2;
576 assert(abs(c1c.re - 0.5882352941177) < 1e-12);
577 assert(abs(c1c.im - -0.3529411764706) < 1e-12);
578
579 c2c /= c1;
580 assert(abs(c2c.re - 1.25) < 1e-11);
581 assert(abs(c2c.im - 0.75) < 1e-12);
582
583 c2c = c2;
584 c2c /= c2;
585 assert(abs(c2c.re - 1.0) < 1e-11);
586 assert(abs(c2c.im - 0.0) < 1e-12);
587 }
588
589 @safe pure nothrow unittest
590 {
591 // Initialization
592 _cdouble a = _cdouble(1, 0);
593 assert(a.re == 1 && a.im == 0);
594 _cdouble b = _cdouble(1.0, 0);
595 assert(b.re == 1.0 && b.im == 0);
596 // _cdouble c = _creal(1.0, 2);
597 // assert(c.re == 1.0 && c.im == 2);
598 }
599
600 @safe pure nothrow unittest
601 {
602 // Assignments and comparisons
603 _cdouble z;
604
605 z = 1;
606 assert(z == 1);
607 assert(z.re == 1.0 && z.im == 0.0);
608
609 z = 2.0;
610 assert(z == 2.0);
611 assert(z.re == 2.0 && z.im == 0.0);
612
613 z = 1.0L;
614 assert(z == 1.0L);
615 assert(z.re == 1.0 && z.im == 0.0);
616
617 auto w = _creal(1.0, 1.0);
618 z = w;
619 assert(z == w);
620 assert(z.re == 1.0 && z.im == 1.0);
621
622 auto c = _cfloat(2.0, 2.0);
623 z = c;
624 assert(z == c);
625 assert(z.re == 2.0 && z.im == 2.0);
626 }
627
628 }
629
630
631 // Returns the mangled name for the 64-bit time_t versions of
632 // functions affected by musl's transition to 64-bit time_t.
633 // https://musl.libc.org/time64.html
634 version (CRuntime_Musl)
635 {
636 version (CRuntime_Musl_Pre_Time64)
637 enum muslRedirTime64 = false;
638 else
639 {
640 // time_t was defined as a C long in older Musl versions.
641 enum muslRedirTime64 = (c_long.sizeof == 4);
642 }
643 }
644 else
645 enum muslRedirTime64 = false;
646
647 package(core) template muslRedirTime64Mangle(string name, string redirectedName)
648 {
649 static if (muslRedirTime64)
650 enum muslRedirTime64Mangle = redirectedName;
651 else
652 enum muslRedirTime64Mangle = name;
653 }